traveller_rpg 0.0.1.1 → 0.1.0.1

data/lib/traveller_rpg/career.rb

@@ -5,62 +5,35 @@ module TravellerRPG
     class Error < RuntimeError; end
     class UnknownAssignment < Error; end
 
-    #
-    # Actually useful defaults
-
     TERM_YEARS = 4
-    ADVANCED_EDUCATION = 8
 
     #
-    # Examples -- but should not be used as actual defaults
-
-    QUALIFICATION = [:default, 5]
-
-    PERSONAL_SKILLS = Array.new(6) { :default }
-    SERVICE_SKILLS = Array.new(6) { :default }
-    ADVANCED_SKILLS = Array.new(6) { :default }
+    # Temporary defaults
 
-    RANKS = { 0 => ['Rookie', :default, 0] }
-    SPECIALIST = {
-      default: {
-        skills: Array.new(6) { :default },
-        survival: [:default, 5],
-        advancement: [:default, 5],
-        ranks: RANKS,
-      }
-    }
-
-    EVENTS = {
-      2 => nil,
-      3 => nil,
-      4 => nil,
-      5 => nil,
-      6 => nil,
-      7 => nil,
-      8 => nil,
-      9 => nil,
-      10 => nil,
-      11 => nil,
-      12 => nil,
+    EVENTS = Array.new(11) { |i|
+      "Event #{i+2}"
+    }.each.with_index.reduce({}) { |memo, (s,idx)|
+      memo.merge(idx + 2 => { :text => s })
     }
-    MISHAPS = {
-      1 => nil,
-      2 => nil,
-      3 => nil,
-      4 => nil,
-      5 => nil,
-      6 => nil,
+    MISHAPS = Array.new(6) { |i|
+      "Mishap #{i+1}"
+    }.each.with_index.reduce({}) { |memo, (s,idx)|
+      memo.merge(idx + 1 => { :text => s })
     }
 
-    MUSTER_OUT = {
-      1 => [0, 'Default'],
-      2 => [0, 'Default'],
-      3 => [5, 'Default'],
-      4 => [5, 'Default'],
-      5 => [10, 'Default'],
-      6 => [10, 'Default'],
-      7 => [5000, 'Default'], # Gambler DM +1
-    }
+    #
+    # Needed to function
+
+    # ADVANCED_EDUCATION (false for Drifter)
+    # QUALIFICATION      (false for Drifter)
+    # PERSONAL_SKILLS
+    # SERVICE_SKILLS
+    # ADVANCED_SKILLS    (unless ADVANCED_EDUCATION is false)
+    # SPECIALIST
+    # EVENTS
+    # MISHAPS
+    # CREDITS
+    # BENEFITS
 
     def self.roll_check?(label, dm:, check:, roll: nil)
       roll ||= TravellerRPG.roll('2d6')
@@ -69,65 +42,120 @@ module TravellerRPG
       (roll + dm) >= check
     end
 
-    def self.muster_roll(label, dm: 0)
-      roll = TravellerRPG.roll('d6')
-      clamped = (roll + dm).clamp(1, 7)
-      puts "#{label} roll: #{roll} (DM #{dm}) = #{clamped}"
-      clamped
+    # helper method -- handles :choose
+    def self.stat_check(hsh)
+      return hsh if hsh == false
+      raise(Error, hsh.inspect) unless hsh.is_a?(Hash) and hsh.size == 1
+      case hsh[:choose]
+      when Hash
+        s = TravellerRPG.choose("Choose stat check:",
+                                *hsh[:choose].keys)
+        [s, hsh[:choose][s]]
+      when NilClass
+        s = hsh.keys.first
+        [s, hsh[s]]
+      else
+        raise(Error, "unexpected choose: #{hsh[:choose]}")
+      end
     end
 
-    attr_reader :term, :active, :rank, :assignment
+    attr_reader :term, :status, :rank, :title, :assignment
 
-    def initialize(char, term: 0, active: false, rank: 0)
+    def initialize(char, term: 0, status: :new, rank: 0)
       @char = char
 
       # career tracking
       @term = term
-      @active = active
+      @status = status
       @rank = rank
       @term_mandate = nil
       @title = nil
+      @assignment = nil
+    end
+
+    def name
+      self.class.name.split('::').last
     end
 
     def officer?
       false
     end
 
-    def activate(assignment = nil)
-      @active = true
+    def active?
+      @status == :active
+    end
+
+    def finished?
+      [:mishap, :finished].include? @status
+    end
+
+    def must_remain?
+      @term_mandate == :must_remain
+    end
+
+    def must_exit?
+      @term_mandate == :must_exit
+    end
+
+    # move status from :new to :active
+    # take on an assignment
+    # take any rank 0 title or skill
+    #
+    def activate(asg = nil)
+      raise(Error, "can't activate status: #{@status}") unless @status == :new
       s = self.class::SPECIALIST
-      if assignment
-        raise(UnknownAssignment, assignment.inspect) unless s.key?(assignment)
-        @assignment = assignment
+      if asg
+        raise(UnknownAssignment, asg.inspect) unless s.key?(asg)
+        @assignment = asg
       else
-        @assignment = TravellerRPG.choose("Choose a specialty:", *s.keys)
+        @assignment = TravellerRPG.choose("Choose assignment:", *s.keys)
       end
-      @title, skill, level = self.rank_benefit
-      @char.train(skill, level) if skill
-      self
+      @status = :active
+      self.take_rank_benefit
     end
 
-    def active?
-      !!@active
+    def specialty
+      if @assignment and self.class::SPECIALIST.key?(@assignment)
+        self.class::SPECIALIST[@assignment]
+      else
+        raise(Error, "unknown assignment: #{@assignment.inspect}")
+      end
+    end
+
+    def service_skills(choose: false)
+      if choose
+        self.class::SERVICE_SKILLS.map { |s|
+          if s.is_a? Hash
+            TravellerRPG.choose("Choose skill:", *s.fetch(:choose))
+          else
+            s
+          end
+        }
+      else
+        self.class::SERVICE_SKILLS.reduce([]) { |ary, s|
+          ary + (s.is_a?(Hash) ? s.fetch(:choose) : [s])
+        }
+      end
     end
 
     def qualify_check?(dm: 0)
-      stat, check = self.class::QUALIFICATION
+      stat, check = self.class.stat_check(self.class::QUALIFICATION)
+      return true if stat == false        # only for Drifter
       @char.log "#{self.name} qualification: #{stat} #{check}+"
       dm += @char.stats_dm(stat)
       self.class.roll_check?('Qualify', dm: dm, check: check)
     end
 
     def survival_check?(dm: 0)
-      stat, check = self.specialty.fetch(:survival)
-      @char.log "#{self.name} #{@assignment} survival: #{stat} #{check}+"
+      stat, check = self.class.stat_check(self.specialty.fetch(:survival))
+      @char.log "#{self.name} [#{@assignment}] survival: #{stat} #{check}+"
       dm += @char.stats_dm(stat)
       self.class.roll_check?('Survival', dm: dm, check: check)
     end
 
     def advancement_check?(dm: 0)
-      stat, check = self.specialty.fetch(:advancement)
-      @char.log "#{self.name} #{@assignment} advancement: #{stat} #{check}+"
+      stat, check = self.class.stat_check(self.specialty.fetch(:advancement))
+      @char.log "#{self.name} [#{@assignment}] advancement: #{stat} #{check}+"
       dm += @char.stats_dm(stat)
       roll = TravellerRPG.roll('2d6')
       if roll <= @term
@@ -141,91 +169,81 @@ module TravellerRPG
     end
 
     def advanced_education?
-      @char.stats[:education] >= self.class::ADVANCED_EDUCATION
+      self.class::ADVANCED_EDUCATION and
+        @char.stats.education >= self.class::ADVANCED_EDUCATION
     end
 
-    # any skills obtained start at level 1
+    def advancement_roll(dm: 0)
+      if self.advancement_check?(dm: dm)
+        self.advance_rank
+        self.training_roll
+      end
+    end
+
+    # any skills obtained start at level 1; always a bump (+1)
     def training_roll
-      choices = [:personal, :service, :specialist]
-      choices << :advanced if self.advanced_education?
-      choices << :officer if self.officer?
+      choices = %w{Personal Service Specialist}
+      choices << 'Advanced' if self.advanced_education?
+      choices << 'Officer' if self.officer?
       choice = TravellerRPG.choose("Choose skills regimen:", *choices)
-      roll = TravellerRPG.roll('d6')
-      @char.log "Training roll: #{roll}"
-      @char.train \
-              case choice
-              when :personal then self.class::PERSONAL_SKILLS.fetch(roll - 1)
-              when :service  then self.class::SERVICE_SKILLS.fetch(roll - 1)
-              when :specialist
-                self.class::SPECIALIST.dig(@assignment, :skills, roll - 1)
-              when :advanced then self.class::ADVANCED_SKILLS.fetch(roll - 1)
-              when :officer  then self.class::OFFICER_SKILLS.fetch(roll - 1)
-              end
+      roll = TravellerRPG.roll('d6', label: "#{choice} training")
+      skill =
+        case choice
+        when 'Personal' then self.class::PERSONAL_SKILLS.fetch(roll - 1)
+        when 'Service'  then self.class::SERVICE_SKILLS.fetch(roll - 1)
+        when 'Specialist' then self.specialty.fetch(:skills).fetch(roll - 1)
+        when 'Advanced' then self.class::ADVANCED_SKILLS.fetch(roll - 1)
+        when 'Officer'  then self.class::OFFICER_SKILLS.fetch(roll - 1)
+        end
+      if skill.is_a?(Hash)
+        skill = TravellerRPG.choose("Choose:", *skill.fetch(:choose))
+      end
+      # the "skill" could be a stat e.g. endurance
+      if @char.skills.known?(skill)
+        @char.skills.bump(skill)
+      else
+        @char.stats.bump(skill)
+      end
+      @char.log "Trained #{skill} +1"
       self
     end
 
-    def event_roll(dm: 0)
-      roll = TravellerRPG.roll('2d6')
-      clamped = (roll + dm).clamp(2, 12)
-      puts "Event roll: #{roll} (DM #{dm}) = #{clamped}"
-      @char.log "Event: #{self.class::EVENTS.fetch(clamped) || roll}"
-      # TODO: actually perform the event stuff
+    def event_roll
+      ev = self.class::EVENTS.fetch TravellerRPG.roll('2d6', label: 'Event')
+      @char.log "Event: #{ev.fetch(:text)}"
+      # TODO: actually perform the event stuff in ev['script']
     end
 
     def mishap_roll
-      roll = TravellerRPG.roll('d6')
-      puts "Mishap roll: #{roll}"
-      @char.log "Mishap: #{self.class::MISHAPS.fetch(roll) || roll}"
-      # TODO: actually perform the mishap stuff
+      mh = self.class::MISHAPS.fetch TravellerRPG.roll('d6', label: 'Mishap')
+      @char.log "Mishap: #{mh.fetch(:text)}"
+      # TODO: actually perform the mishap stuff in mh['script']
     end
 
     def advance_rank
       @rank += 1
       @char.log "Advanced career to rank #{@rank}"
-      title, skill, level = self.rank_benefit
-      if title
-        @char.log "Awarded rank title: #{title}"
-        @title = title
-      end
-      if skill
-        @char.log "Achieved rank skill: #{skill} #{level}"
-        @char.train(skill, level)
-      end
-      self
+      self.take_rank_benefit
     end
 
-    def must_remain?
-      @term_mandate == :must_remain
-    end
-
-    def must_exit?
-      @term_mandate == :must_exit
+    # possibly nil
+    def rank_benefit
+      self.specialty.fetch(:ranks)[@rank]
     end
 
     def run_term
-      raise(Error, "career is inactive") unless @active
+      raise(Error, "career is inactive") unless self.active?
       raise(Error, "must exit") if self.must_exit?
       @term += 1
       @char.log format("%s term %i started, age %i",
                        self.name, @term, @char.age)
       self.training_roll
 
-      # TODO: DM?
       if self.survival_check?
         @char.log format("%s term %i completed successfully.",
                          self.name, @term)
         @char.age TERM_YEARS
-
-        # TODO: DM?
-        self.commission_roll if self.respond_to?(:commission_roll)
-
-        # TODO: DM?
-        if self.advancement_check?
-          self.advance_rank
-          self.training_roll
-        end
-
-        # TODO: DM?
+        self.advancement_roll # TODO: DM?
         self.event_roll
       else
         years = rand(TERM_YEARS) + 1
@@ -233,96 +251,120 @@ module TravellerRPG
                          self.name, years)
         @char.age years
         self.mishap_roll
-        @active = false
+        @status = :mishap
       end
+      self
     end
 
     def retirement_bonus
       @term >= 5 ? @term * 2000 : 0
     end
 
-    def muster_out(dm: 0)
+    # returns the roll value with DM applied
+    def muster_roll
+      dm = @char.skills.check?('Gambler', 1) ? 1 : 0
+      TravellerRPG.roll('d6', label: 'Muster', dm: dm)
+    end
+
+    def muster_out
       @char.log "Muster out: #{self.name}"
       raise(Error, "career has not started") unless @term > 0
-      dm += @char.skill_check?(:gambler, 1) ? 1 : 0
-
-      # one cash and one benefit per term
-      # except if last term suffered mishap, no benefit for that term
-
       cash_rolls = @term.clamp(0, 3 - @char.cash_rolls)
-      benefit_rolls = @term
-
-      if @active
-        @char.log "Career is in good standing -- collect all benefits"
-        @active = false
-      else
-        @char.log "Left career early -- lose benefit for last term"
+      total_ranks = self.officer? ? self.rank + self.enlisted_rank : self.rank
+      benefit_rolls = @term + ((total_ranks + 1) / 2).clamp(0, 3)
+
+      case @status
+      when :active
+        @char.log "Muster out: Career in good standing; collect all benefits"
+      when :mishap
+        @char.log "Muster out: Career ended early; lose last term benefit"
         benefit_rolls -= 1
+      when :new, :finished
+        raise "invalid status: #{@status}"
+      else
+        raise "unknown status: #{@status}"
       end
 
+      # Collect "muster out" benefits
       cash_rolls.times {
-        clamped = self.class.muster_roll('Cash', dm: dm)
-        @char.cash_roll self.class::MUSTER_OUT.fetch(clamped).first
+        @char.cash_roll self.class::CREDITS.fetch(self.muster_roll)
       }
       benefit_rolls.times {
-        clamped = self.class.muster_roll('Benefits', dm: dm)
-        @char.benefit self.class::MUSTER_OUT.fetch(clamped).last
+        b = self.class::BENEFITS.fetch(self.muster_roll)
+        case b
+        when Array
+          b.each { |ben| @char.benefit ben }
+        when Hash
+          choice = TravellerRPG.choose("Choose benefit:", *b.fetch(:choose))
+          @char.benefit choice
+        else
+          @char.benefit b
+        end
       }
-      @char.log "Retirement bonus: #{self.retirement_bonus}"
       @char.benefit self.retirement_bonus
+      @status = :finished
       self
     end
 
-    def name
-      self.class.name.split('::').last
-    end
-
-    def specialty
-      self.class::SPECIALIST.fetch(@assignment)
-    end
-
-    # possibly nil
-    def rank_benefit
-      self.specialty.fetch(:ranks)[@rank]
-    end
-
-    def report(term: true, active: true, rank: true, spec: true)
+    def report(term: true, status: true, rank: true, spec: true)
       hsh = {}
       hsh['Term'] = @term if term
-      hsh['Active'] = @active if active
+      hsh['Status'] = @status.to_s.capitalize if status
       hsh['Specialty'] = @assignment if spec
+      hsh['Title'] = @title if @title
       if rank
-        hsh['Officer Rank'] = self.rank if self.officer?
-        hsh['Rank'] = @rank
-        hsh['Title'] = @title if @title
+        if self.officer?
+          hsh['Officer Rank'] = @officer
+          hsh['Enlisted Rank'] = @rank
+        else
+          hsh['Rank'] = @rank
+        end
       end
       report = ["Career: #{self.name}", "==="]
       hsh.each { |label, val|
-        val = val.to_s.capitalize if val.is_a? Symbol
-        report << format("%s: %s", label.to_s.rjust(10, ' '), val.to_s)
+        report << format("%s: %s", label.to_s.rjust(15, ' '), val)
       }
       report.join("\n")
     end
-  end
 
+    protected
+
+    def take_rank_benefit
+      rb = self.rank_benefit or return self
+      label = self.officer? ? "officer rank" : "rank"
+      title, skill, stat, level = rb.values_at(:title, :skill, :stat, :level)
+      if title
+        @char.log "Awarded #{label} title: #{title}"
+        @title = title
+      end
+      if rb[:choose]
+        raise("unexpected choose: #{rb}") unless rb[:choose].is_a?(Array)
+        choices = rb[:choose].map { |h|
+          [h[:skill] || h[:stat], h[:level]].compact.join(' ')
+        }
+        choice = TravellerRPG.choose("Choose rank bonus:", *choices)
+        skill, stat, level = rb[:choose].select { |h|
+          choice == [h[:skill] || h[:stat], h[:level]].compact.join(' ')
+        }.first.values_at(:skill, :stat, :level)
+        raise "#{skill.inspect} or #{stat.inspect}" unless skill or stat
+      end
+      if skill
+        @char.log "Achieved #{label} bonus: #{skill} #{level}"
+        @char.skills.bump(skill, level)
+      end
+      if stat
+        @char.log "Achieved #{label} bonus: #{stat} #{level}"
+        @char.stats.bump(stat, level)
+      end
+      self
+    end
+  end
 
   #
-  # MilitaryCareer adds Officer commission and parallel Officer ranks
+  # MilitaryCareer adds Officer commission opportunity which unlocks
+  # Officer skills and Officer ranks
 
   class MilitaryCareer < Career
-
-    #
-    # Actually useful defaults
-
-    COMMISSION = [:social_status, 8]
-
-    #
-    # Examples -- but should not be used as actual defaults
-
-    AGE_PENALTY = 40
-    OFFICER_SKILLS = Array.new(6) { :default }
-    OFFICER_RANKS = {}
-
     def initialize(char, **kwargs)
       super(char, **kwargs)
       @officer = false
@@ -335,26 +377,33 @@ module TravellerRPG
     end
 
     def commission_check?(dm: 0)
-      stat, check = self.class::COMMISSION
+      stat, check = self.class.stat_check(self.class::COMMISSION)
       @char.log "#{self.name} commission: #{stat} #{check}"
       dm += @char.stats_dm(stat)
       self.class.roll_check?('Commission', dm: dm, check: check)
     end
 
-    #
-    # Achieve an officer commission
-
-    def commission_roll(dm: 0)
-      return if @officer
-      if TravellerRPG.choose("Apply for commission?", :yes, :no) == :yes
-        if self.commission_check?
+    def advancement_roll(dm: 0)
+      if !@officer and
+         (@term == 1 or @char.stats[:social_status] > 9) and true
+         # TravellerRPG.choose("Apply for commission?", :yes, :no) == :yes
+        comm_dm = @term > 1 ? dm - 1 : dm
+        if self.commission_check?(dm: comm_dm)
           @char.log "Became an officer!"
-          @officer = 0       # officer rank
-          self.advance_rank  # officers start at rank 1
+          @officer = 1
+          self.take_rank_benefit
+
+          # skip normal advancement after successful commission
+          # but take the bonus training roll
+          self.training_roll
+
+          return self
         else
           @char.log "Commission was rejected"
         end
       end
+      # perform normal advancement unless commission was obtained
+      super(dm: dm)
     end
 
     #
@@ -380,15 +429,7 @@ module TravellerRPG
       return super unless @officer
       @officer += 1
       @char.log "Advanced career to officer rank #{@officer}"
-      title, skill, level = self.rank_benefit
-      if title
-        @char.log "Awarded officer rank title: #{title}"
-        @title = title
-      end
-      if skill
-        @char.log "Achieved officer rank skill: #{skill} #{level}"
-        @char.train(skill, level)
-      end
+      self.take_rank_benefit
     end
   end
 end