traveller_rpg 0.0.0.4 → 0.0.1.1

data/lib/traveller_rpg/career.rb

@@ -4,23 +4,31 @@ module TravellerRPG
   class Career
     class Error < RuntimeError; end
     class UnknownAssignment < Error; end
-    class MusterError < Error; end
 
-    def self.advanced_skills?(stats)
-      stats.education >= 8
-    end
+    #
+    # Actually useful defaults
 
     TERM_YEARS = 4
+    ADVANCED_EDUCATION = 8
+
+    #
+    # Examples -- but should not be used as actual defaults
 
-    QUALIFY_CHECK = 5
-    SURVIVAL_CHECK = 6
-    ADVANCEMENT_CHECK = 9
+    QUALIFICATION = [:default, 5]
 
-    STATS = Array.new(6) { :default }
+    PERSONAL_SKILLS = Array.new(6) { :default }
     SERVICE_SKILLS = Array.new(6) { :default }
     ADVANCED_SKILLS = Array.new(6) { :default }
-    SPECIALIST_SKILLS = { default: Array.new(6) { :default } }
-    RANKS = {}
+
+    RANKS = { 0 => ['Rookie', :default, 0] }
+    SPECIALIST = {
+      default: {
+        skills: Array.new(6) { :default },
+        survival: [:default, 5],
+        advancement: [:default, 5],
+        ranks: RANKS,
+      }
+    }
 
     EVENTS = {
       2 => nil,
@@ -35,7 +43,6 @@ module TravellerRPG
       11 => nil,
       12 => nil,
     }
-
     MISHAPS = {
       1 => nil,
       2 => nil,
@@ -45,149 +52,146 @@ module TravellerRPG
       6 => nil,
     }
 
-    CASH = {
-      2 => -500,
-      3 => -100,
-      4 => 200,
-      5 => 400,
-      6 => 600,
-      7 => 800,
-      8 => 1000,
-      9 => 2000,
-      10 => 4000,
-      11 => 8000,
-      12 => 16000,
+    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
     }
 
-    attr_reader :stats, :skills, :benefits
-    attr_accessor :term, :active, :rank
+    def self.roll_check?(label, dm:, check:, roll: nil)
+      roll ||= TravellerRPG.roll('2d6')
+      puts format("%s check: rolled %i (DM %i) against %i",
+                  label, roll, dm, check)
+      (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
+    end
+
+    attr_reader :term, :active, :rank, :assignment
 
-    def initialize(char, assignment: nil, term: 0, active: false, rank: 0,
-                   benefits: {})
+    def initialize(char, term: 0, active: false, rank: 0)
       @char = char
-      @assignment = assignment
-      if @assignment and !self.class::SPECIALIST_SKILLS.key?(@assignment)
-        raise(UnknownAssignment, assignment.inspect)
-      end
 
       # career tracking
       @term = term
       @active = active
       @rank = rank
-      @benefits = benefits  # acquired equipment, ships / shares
       @term_mandate = nil
+      @title = nil
+    end
+
+    def officer?
+      false
     end
 
-    def assignment
-      @assignment ||= TravellerRPG.choose("Choose a specialty:",
-                                       *self.class::SPECIALIST_SKILLS.keys)
+    def activate(assignment = nil)
+      @active = true
+      s = self.class::SPECIALIST
+      if assignment
+        raise(UnknownAssignment, assignment.inspect) unless s.key?(assignment)
+        @assignment = assignment
+      else
+        @assignment = TravellerRPG.choose("Choose a specialty:", *s.keys)
+      end
+      @title, skill, level = self.rank_benefit
+      @char.train(skill, level) if skill
+      self
     end
 
     def active?
       !!@active
     end
 
-    def qualify_check?(career_count, dm: 0)
-      dm += -1 * career_count
-      roll = TravellerRPG.roll('2d6')
-      puts format("Qualify check: rolled %i (DM %i) against %i",
-                  roll, dm, self.class::QUALIFY_CHECK)
-      (roll + dm) >= self.class::QUALIFY_CHECK
+    def qualify_check?(dm: 0)
+      stat, check = self.class::QUALIFICATION
+      @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}+"
+      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}+"
+      dm += @char.stats_dm(stat)
       roll = TravellerRPG.roll('2d6')
-      puts format("Survival check: rolled %i (DM %i) against %i",
-                  roll, dm, self.class::SURVIVAL_CHECK)
-      (roll + dm) >= self.class::SURVIVAL_CHECK
+      if roll <= @term
+        @term_mandate = :must_exit
+      elsif roll == 12
+        @term_mandate = :must_remain
+      else
+        @term_mandate = nil
+      end
+      self.class.roll_check?('Advancement', dm: dm, check: check, roll: roll)
     end
 
-    def advancement_check?(roll: nil, dm: 0)
-      roll ||= TravellerRPG.roll('2d6')
-      puts format("Advancement check: rolled %i (DM %i) against %i",
-                  roll, dm, self.class::ADVANCEMENT_CHECK)
-      (roll + dm) >= self.class::ADVANCEMENT_CHECK
+    def advanced_education?
+      @char.stats[:education] >= self.class::ADVANCED_EDUCATION
     end
 
     # any skills obtained start at level 1
     def training_roll
+      choices = [: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 (d6): #{roll}"
-      choices = [:stats, :service, :specialist]
-      choices << :advanced if self.class.advanced_skills?(@char.stats)
-      choices << :officer if self.respond_to?(:officer) and self.officer
-      choice = TravellerRPG.choose("Choose training regimen:", *choices)
-      case choice
-      when :stats
-        stat = self.class::STATS.fetch(roll - 1)
-        if @char.stats.respond_to?(stat)
-          @char.stats.boost(stat => 1)
-          @char.log "Trained #{stat} to #{@char.stats.send(stat)}"
-        else
-          raise "bad stat: #{stat}" unless TravellerRPG::SKILLS.key?(stat)
-          # stat is likely :jack_of_all_trades skill
-          @char.skills[stat] ||= 0
-          @char.skills[stat] += 1
-          @char.log "Trained (stats) skill #{stat} to #{@char.skills[stat]}"
-        end
-      when :service
-        svc = self.class::SERVICE_SKILLS.fetch(roll - 1)
-        @char.skills[svc] ||= 0
-        @char.skills[svc] += 1
-        @char.log "Trained service skill #{svc} to #{@char.skills[svc]}"
-      when :specialist
-        spec =
-          self.class::SPECIALIST_SKILLS.fetch(self.assignment).fetch(roll - 1)
-        @char.skills[spec] ||= 0
-        @char.skills[spec] += 1
-        @char.log "Trained #{@assignment} specialist skill #{spec} " +
-                  "to #{@char.skills[spec]}"
-      when :advanced
-        adv = self.class::ADVANCED_SKILLS.fetch(roll - 1)
-        @char.skills[adv] ||= 0
-        @char.skills[adv] += 1
-        @char.log "Trained advanced skill #{adv} to #{@char.skills[adv]}"
-      when :officer
-        off = self.class::OFFICER_SKILLS.fetch(roll - 1)
-        @char.skills[off] ||= 0
-        @char.skills[off] += 1
-        @char.log "Trained officer skill #{off} to #{@char.skills[off]}"
-      end
+      @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
+      self
     end
 
     def event_roll(dm: 0)
       roll = TravellerRPG.roll('2d6')
       clamped = (roll + dm).clamp(2, 12)
-      @char.log "Event roll (2d6): #{roll} + DM #{dm} = #{clamped}"
-      @char.log self.class::EVENTS.fetch(clamped)
+      puts "Event roll: #{roll} (DM #{dm}) = #{clamped}"
+      @char.log "Event: #{self.class::EVENTS.fetch(clamped) || roll}"
       # TODO: actually perform the event stuff
     end
 
     def mishap_roll
       roll = TravellerRPG.roll('d6')
-      @char.log "Mishap roll (d6): #{roll}"
-      @char.log self.class::MISHAPS.fetch(roll)
+      puts "Mishap roll: #{roll}"
+      @char.log "Mishap: #{self.class::MISHAPS.fetch(roll) || roll}"
       # TODO: actually perform the mishap stuff
     end
 
-    def cash_roll(dm: 0)
-      roll = TravellerRPG.roll('2d6')
-      clamped = (roll + dm).clamp(2, 12)
-      amount = self.class::CASH.fetch(clamped)
-      puts "Cash roll: #{roll} (DM #{dm}) = #{clamped} for #{amount}"
-      amount
-    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.skills[skill] ||= 0
-        @char.skills[skill] = level if level > @char.skills[skill]
+        @char.train(skill, level)
       end
+      self
     end
 
     def must_remain?
@@ -206,30 +210,28 @@ module TravellerRPG
                        self.name, @term, @char.age)
       self.training_roll
 
+      # TODO: DM?
       if self.survival_check?
-        @char.log format("%s term %i was successful", self.name, @term)
+        @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)
 
-        adv_roll = TravellerRPG.roll('2d6')
         # TODO: DM?
-        if self.advancement_check?(roll: adv_roll)
+        if self.advancement_check?
           self.advance_rank
           self.training_roll
         end
-        if adv_roll <= @term
-          @term_mandate = :must_exit
-        elsif adv_roll == 12
-          @term_mandate = :must_remain
-        else
-          @term_mandate = nil
-        end
 
+        # TODO: DM?
         self.event_roll
       else
-        @char.log "#{self.name} career ended with a mishap!"
-        @char.age rand(TERM_YEARS) + 1
+        years = rand(TERM_YEARS) + 1
+        @char.log format("%s career ended with a mishap after %i years.",
+                         self.name, years)
+        @char.age years
         self.mishap_roll
         @active = false
       end
@@ -240,30 +242,153 @@ module TravellerRPG
     end
 
     def muster_out(dm: 0)
+      @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
-        raise(MusterError, "career has not started") unless @term > 0
+        @char.log "Career is in good standing -- collect all benefits"
         @active = false
-        cash_benefit = 0
-        @char.log "Muster out: #{self.name}"
-        dm += @char.skill_check?(:gambler, 1) ? 1 : 0
-        @term.clamp(0, 3).times {
-          cash_benefit += self.cash_roll(dm: dm)
-        }
-        @char.log "Cash benefit: #{cash_benefit}"
-        @char.log "Retirement bonus: #{self.retirement_bonus}"
-        @benefits[:cash] ||= 0
-        @benefits[:cash] += cash_benefit + self.retirement_bonus
-        @benefits
+      else
+        @char.log "Left career early -- lose benefit for last term"
+        benefit_rolls -= 1
       end
+
+      cash_rolls.times {
+        clamped = self.class.muster_roll('Cash', dm: dm)
+        @char.cash_roll self.class::MUSTER_OUT.fetch(clamped).first
+      }
+      benefit_rolls.times {
+        clamped = self.class.muster_roll('Benefits', dm: dm)
+        @char.benefit self.class::MUSTER_OUT.fetch(clamped).last
+      }
+      @char.log "Retirement bonus: #{self.retirement_bonus}"
+      @char.benefit self.retirement_bonus
+      self
     end
 
     def name
       self.class.name.split('::').last
     end
 
+    def specialty
+      self.class::SPECIALIST.fetch(@assignment)
+    end
+
     # possibly nil
     def rank_benefit
-      self.class::RANKS[@rank]
+      self.specialty.fetch(:ranks)[@rank]
+    end
+
+    def report(term: true, active: true, rank: true, spec: true)
+      hsh = {}
+      hsh['Term'] = @term if term
+      hsh['Active'] = @active if active
+      hsh['Specialty'] = @assignment if spec
+      if rank
+        hsh['Officer Rank'] = self.rank if self.officer?
+        hsh['Rank'] = @rank
+        hsh['Title'] = @title if @title
+      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.join("\n")
+    end
+  end
+
+
+  #
+  # MilitaryCareer adds Officer commission and parallel 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
+    end
+
+    # Implement age penalty
+    def qualify_check?(dm: 0)
+      dm -= 2 if @char.age >= self.class::AGE_PENALTY
+      super(dm: dm)
+    end
+
+    def commission_check?(dm: 0)
+      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?
+          @char.log "Became an officer!"
+          @officer = 0       # officer rank
+          self.advance_rank  # officers start at rank 1
+        else
+          @char.log "Commission was rejected"
+        end
+      end
+    end
+
+    #
+    # Handle parallel officer track, conditional on officer commission
+
+    def officer?
+      !!@officer
+    end
+
+    def enlisted_rank
+      @rank
+    end
+
+    def rank
+      @officer ? @officer : @rank
+    end
+
+    def rank_benefit
+      @officer ? self.class::OFFICER_RANKS[@officer] : super
+    end
+
+    def advance_rank
+      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
     end
   end
 end

data/lib/traveller_rpg/career_path.rb

@@ -1,33 +1,67 @@
-require 'traveller_rpg/career'
+require 'traveller_rpg'
+require 'traveller_rpg/careers'
 
 module TravellerRPG
+  autoload :Generator, 'traveller_rpg/generator'
+
   class CareerPath
     class Error < RuntimeError; end
     class Ineligible < Error; end
 
-    attr_reader :char, :careers, :active_career
+    DRAFT_CAREERS = {
+      1 => ['Navy', nil],
+      2 => ['Army', nil],
+      3 => ['Marines', nil],
+      4 => ['Merchant', :merchant_marine],
+      5 => ['Scout', nil],
+      6 => ['Agent', :law_enforcement],
+    }
+
+    def self.career_class(str)
+      TravellerRPG.const_get(str.split('::').last)
+    end
+
+    def self.run(careers, character: nil)
+      character = Generator.character unless character
+      puts "\n", character.report(desc: :long, stuff: false, credits: false)
+      path = self.new(character)
+      loop {
+        careers = path.eligible(careers)
+        break if careers.empty?
+        choice = TravellerRPG.choose("Choose a career:", *careers)
+        career = self.career_class(choice).new(character)
+        path.run(career)
+        puts "\n", path.report, "\n"
+        break if TravellerRPG.choose("Exit career mode?", :yes, :no) == :yes
+      }
+      path
+    end
+
+    attr_reader :char, :careers
 
     def initialize(character)
       @char = character
       @char.log "Initiated new career path"
       @careers = []
-      @active_career
     end
 
-    def eligible?(career)
-      case career
-      when Career
-        return false if career.active?
-        cls = career.class
-      when String
-        cls = TravellerRPG.career_class(career)
-      end
-      !@careers.any? { |c| c.class == cls }
+    def run(career)
+      career = self.fallback unless self.apply(career)
+      loop {
+        career.run_term
+        break unless career.active?
+        break if career.must_exit?
+        next if career.must_remain?
+        break if TravellerRPG.choose("Muster out?", :yes, :no) == :yes
+      }
+      career.muster_out
+      @careers << career
+      career
     end
 
     def apply(career)
       raise(Ineligible, career.name) unless self.eligible?(career)
-      if career.qualify_check?(@careers.size)
+      if career.qualify_check?(dm: -1 * @careers.size)
         @char.log "Qualified for #{career.name}"
         self.enter(career)
       else
@@ -36,58 +70,72 @@ module TravellerRPG
       end
     end
 
-    def enter(career)
-      raise(Ineligible, career.name) unless self.eligible?(career)
-      raise(Error, "career is already active") if career.active?
-      raise(Error, "career has already started") unless career.term == 0
-      self.muster_out
-      @char.log "Entering new career: #{career.name}"
-      @active_career = career
-      @active_career.active = true
-      self.basic_training
-      self
+    def fallback
+      case TravellerRPG.choose("Fallback career:", :drifter, :draft)
+      when :drifter
+        self.enter TravellerRPG::Drifter.new(@char)
+      when :draft
+        self.draft
+      end
     end
 
-    def basic_training
-      return unless @active_career.term.zero?
-      if @careers.length.zero?
-        @active_career.class::SERVICE_SKILLS
-      else
-        [TravellerRPG.choose("Service skill",
-                             *@active_career.class::SERVICE_SKILLS)]
-      end.each { |sym|
-        unless char.skills.key?(sym)
-          @char.log "Acquired basic training skill: #{sym} 0"
-          @char.skills[sym] = 0
-        end
-      }
+    # return an active career, no qualification, that has completed basic
+    # training
+    def draft
+      roll = TravellerRPG.roll('d6')
+      puts "Draft roll: #{roll}"
+      dc = self.class::DRAFT_CAREERS.fetch(roll)
+      @char.log "Drafted: #{dc.compact.join(', ')}"
+
+      career = CareerPath.career_class(dc.first).new(@char)
+      career.activate(dc.last)
+      self.basic_training(career)
+      career
     end
 
-    def run_term
-      raise(Error, "no active career") unless @active_career
-      @active_career.run_term
-      unless @active_career.active?
-        @careers << @active_career
-        @active_career = nil
-      end
+    def eligible(careers)
+      careers.select { |c| self.eligible?(c) }
     end
 
-    def muster_out
-      if @active_career
-        raise(Error, "career is inactive") unless @active_career.active?
-        raise(Error, "must remain") if @active_career.must_remain?
-        @char.add_stuff(@active_career.muster_out)
-        @careers << @active_career
-        @active_career = nil
+    def eligible?(career)
+      case career
+      when Career
+        return false if career.active?
+        cls = career.class
+      when String
+        cls = CareerPath.career_class(career)
       end
+      return true if cls == TravellerRPG::Drifter
+      !@careers.any? { |c| c.class == cls }
+    end
+
+    def enter(career)
+      raise(Ineligible, career.name) unless self.eligible?(career)
+      raise(Error, "career is already active") if career.active?
+      raise(Error, "career has already started") unless career.term == 0
+      @char.log "Entering new career: #{career.name}"
+      career.activate
+      self.basic_training(career)
+      career
     end
 
-    def draft_term
-      @char.log "Drafted! (fake)"
+    def basic_training(career)
+      return unless career.term.zero?
+      skills = career.class::SERVICE_SKILLS - @char.skills.keys
+      return if skills.empty?
+      if @careers.length > 0
+        skills = [TravellerRPG.choose("Choose service skill:", *skills)]
+      end
+      skills.each { |sym|
+        raise "unknown skill: #{sym}" unless TravellerRPG::SKILLS.key?(sym)
+        @char.log "Acquired basic training skill: #{sym} 0"
+        @char.skills[sym] = 0
+      }
     end
 
-    def drifter_term
-      @char.log "Became a drifter (fake)"
+    def report(char: true, careers: true)
+      [@char.report,
+       @careers.map(&:report).join("\n\n")].join("\n\n")
     end
   end
 end