traveller_rpg 0.0.1.1 → 0.1.0.1

data/lib/traveller_rpg/career_path.rb

@@ -1,39 +1,45 @@
 require 'traveller_rpg'
+require 'traveller_rpg/character'
 require 'traveller_rpg/careers'
+require 'traveller_rpg/skill'
 
 module TravellerRPG
-  autoload :Generator, 'traveller_rpg/generator'
-
   class CareerPath
-    class Error < RuntimeError; end
-    class Ineligible < Error; end
+    class Ineligible < RuntimeError; end
 
     DRAFT_CAREERS = {
-      1 => ['Navy', nil],
-      2 => ['Army', nil],
-      3 => ['Marines', nil],
-      4 => ['Merchant', :merchant_marine],
-      5 => ['Scout', nil],
-      6 => ['Agent', :law_enforcement],
+      1 => ['Navy'],
+      2 => ['Army'],
+      3 => ['Marines'],
+      # TODO: define Merchant career
+      # 4 => ['Merchant', 'Merchant Marine'],
+      4 => ['Marines'],
+      5 => ['Scout'],
+      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)
+    def self.draft_career?(str)
+      DRAFT_CAREERS.values.map(&:first).include? str
+    end
+
+    def self.run(careers, character:)
+      puts "\n", character.report(stuff: false, credits: false)
       path = self.new(character)
       loop {
-        careers = path.eligible(careers)
+        careers = careers.select { |c| path.eligible? c }
         break if careers.empty?
-        choice = TravellerRPG.choose("Choose a career:", *careers)
-        career = self.career_class(choice).new(character)
+        career = TravellerRPG.choose("Choose a career:", *careers)
         path.run(career)
         puts "\n", path.report, "\n"
+        break if character.age > 45
         break if TravellerRPG.choose("Exit career mode?", :yes, :no) == :yes
       }
+      puts
+      puts character.log.join("\n")
       path
     end
 
@@ -45,97 +51,98 @@ module TravellerRPG
       @careers = []
     end
 
-    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
+    def career(career_name)
+      self.class.career_class(career_name).new(@char)
+    end
+
+    def eligible?(career)
+      case career
+      when Career
+        return false if career.status != :new or career.term != 0
+        cls = career.class
+      when String
+        cls = CareerPath.career_class(career)
+      end
+      !@careers.any? { |c| cls === c }
     end
 
-    def apply(career)
+    # Run career to completion; keep running terms while possible
+    def run(career, asg = nil)
+      run! self.apply career, asg
+    end
+
+    # Pass eligibility and qualify_check
+    # Take Drifter or Draft if disqualified
+    # Then enter career
+    def apply(career, asg = nil)
+      career = self.career(career) if career.is_a? String
       raise(Ineligible, career.name) unless self.eligible?(career)
       if career.qualify_check?(dm: -1 * @careers.size)
         @char.log "Qualified for #{career.name}"
-        self.enter(career)
+        self.enter career, asg
       else
         @char.log "Did not qualify for #{career.name}"
-        false
-      end
-    end
-
-    def fallback
-      case TravellerRPG.choose("Fallback career:", :drifter, :draft)
-      when :drifter
-        self.enter TravellerRPG::Drifter.new(@char)
-      when :draft
-        self.draft
+        case TravellerRPG.choose("Choose fallback:", 'Drifter', 'Draft')
+        when 'Drifter' then self.enter 'Drifter'
+        when 'Draft'   then self.draft
+        end
       end
     end
 
-    # return an active career, no qualification, that has completed basic
+    # return an active career, no qualification check, 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
+      roll = TravellerRPG.roll('d6', label: "Draft")
+      career, asg = self.class::DRAFT_CAREERS.fetch(roll)
+      @char.log "Drafted: #{[career, asg].compact.join(', ')}"
+      self.enter(career, asg)
     end
 
-    def eligible(careers)
-      careers.select { |c| self.eligible?(c) }
+    def basic_training(career)
+      raise(Ineligible, "career has already started") unless career.term.zero?
+      raise(Ineligible, "career must be active") unless career.active?
+      if @careers.length > 0
+        choices = career.service_skills.reject { |s| @char.skills[s] }
+        if !choices.empty?
+          @char.basic_training choices.first if choices.size == 1
+          @char.basic_training TravellerRPG.choose('Choose skill:', *choices)
+        end
+      else
+        # Take "all" SERVICE_SKILLS, but choose any choices
+        career.service_skills(choose: true).each { |s|
+          @char.basic_training s
+        }
+      end
+      career
     end
 
-    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 }
+    def report(char: true, careers: true)
+      [@char.report, @careers.map(&:report).join("\n\n")].join("\n\n")
     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
+    protected
+
+    # ensure Career object; log; activate; basic_training; return Career
+    def enter(career, asg = nil)
+      career = self.career(career) if career.is_a? String
       @char.log "Entering new career: #{career.name}"
-      career.activate
-      self.basic_training(career)
-      career
+      self.basic_training(career.activate(asg))
     end
 
-    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
+    # take an active career and run_term until complete
+    # muster_out and update career history
+    def run!(career)
+      raise(Error, "#{career.name} isn't active") unless career.active?
+      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
       }
-    end
-
-    def report(char: true, careers: true)
-      [@char.report,
-       @careers.map(&:report).join("\n\n")].join("\n\n")
+      career.muster_out
+      @careers << career
+      career
     end
   end
 end

data/lib/traveller_rpg/careers.rb

@@ -1,567 +1,279 @@
+require 'yaml'
 require 'traveller_rpg'
 require 'traveller_rpg/career'
+require 'traveller_rpg/character'
+require 'traveller_rpg/skill_set'
 
 module TravellerRPG
-  class Agent < Career
-    QUALIFICATION   = [:intelligence, 6]
-    ADVANCED_EDUCATION = 8
-    PERSONAL_SKILLS = [:gun_combat_group, :dexterity, :endurance,
-                       :melee_group, :intelligence, :athletics_group]
-    SERVICE_SKILLS  = [:streetwise, :drive_group, :investigate,
-                       :flyer_group, :recon, :gun_combat_group]
-    ADVANCED_SKILLS = [:advocate, :language_group, :explosives,
-                       :medic, :vacc_suit, :electronics_group]
-    RANKS = {
-      1 => ['Agent', :deception, 1],
-      2 => ['Field Agent', :investigate, 1],
-      4 => ['Special Agent', :gun_combat_group, 1],
-      5 => ['Assistant Director', nil, nil],
-      6 => ['Director', nil, nil],
-    }
-    SPECIALIST = {
-      law_enforcement: {
-        skills:   [:investigate, :recon, :streetwise,
-                   :stealth, :melee_group, :advocate],
-        survival: [:endurance, 6],
-        advancement: [:intelligence, 6],
-        ranks: {
-          0 => ['Rookie', nil, nil],
-          1 => ['Corporal', :streetwise, 1],
-          2 => ['Sergeant', nil, nil],
-          3 => ['Detective', nil, nil],
-          4 => ['Lieutenant', :investigate, 1],
-          5 => ['Chief', :admin, 1],
-          6 => ['Commissioner', :social_standing, nil],
-        },
-      },
-      intelligence: {
-        skills: [:investigate, :recon, :comms,
-                 :stealth, :persuade, :deception],
-        survival: [:intelligence, 7],
-        advancement: [:intelligence, 5],
-        ranks: RANKS,
-      },
-      corporate: {
-        skills: [:investigate, :computers, :stealth,
-                 :carouse, :deception, :streetwise],
-        survival: [:intelligence, 5],
-        advancement: [:intelligence, 7],
-        ranks: RANKS,
-      },
-    }
-
-    MUSTER_OUT = {
-      1 => [1000, 'Scientific Equipment'],
-      2 => [2000, 'INT +1'],
-      3 => [5000, 'Ship Share'],
-      4 => [7500, 'Weapon'],
-      5 => [10000, 'Combat Implant'],
-      6 => [25000, 'SOC +1 or Combat Implant'],
-      7 => [50000, 'TAS Membership'],
-    }
-
-    EVENTS = {
-      2 => 'Disaster! Roll on the Mishap Table, but you are not ejected ' +
-           'from this career.',
-      3 => 'An investigation takes on a dangerous turn.  Roll ' +
-           'Investigate 8+ or Streetwise 8+. If you fail, roll on the ' +
-           'Mishap Table.  If you suceed, increase one skill of ' +
-           'Deception, Jack-of-all-Trades, Persuade, or Tactics.',
-      4 => 'You complete a mission for your superiors, and are suitably ' +
-           'rewarded.  Gain DM+1 to any one Benefit Roll from this career.',
-      5 => 'You establish a network of contacts.  Gain d3 Contacts.',
-      6 => 'You are given advanced training in a specialist field. Roll ' +\
-           'EDU 8+ to increase any existing skill by 1.',
-      7 => 'Life Event. Roll on the Live Events Table.',
-      8 => 'You go undercover to investigate an enemy.  Roll Deception 8+.' +
-           'If you succeed, roll immediately on the Rogue or Citizen Events ' +
-           'Table and make one roll on any Specialist skill table for that ' +
-           'career. If you fail, roll immediately on the Rogue or Citizen ' +
-           'Mishap Table',
-      9 => 'You go above and beyond the call of duty.  Gain DM+2 to your ' +
-           'next Advancement check',
-      10 => 'You are given spcialist training in vehicles.  Gain one of ' +
-            'Drive 1, Flyer 1, Pilot 1, or Gunner 1.',
-      11 => 'You are befriended by a senior agent. Either increase ' +
-            'Investigate by 1 or DM+4 to an Advancement roll thanks to ' +
-            'their aid.',
-      12 => 'Your efforts uncover a major conspiracy against your ' +
-            'employers. You are automatically promoted.',
-    }
-
-    MISHAPS = {
-      1 => 'Severely injured in action.  Roll twice on the Injury table ' +
-           'or take a level 2 Injury.',
-      2 => 'A criminal offers you a deal.  Accept the deal to leave career; ' +
-           'Refuse, and you must roll twice on the Injury Table and take ' +
-           'the lower result.  Gain an Enemy and one level in any skill.',
-      3 => 'An investigation goes critically wrong, ruining your career. ' +
-           'Roll Advocate 8+; Succeed == keep benefit this term; ' +
-           'Fail, lost benefit as normal.  A roll of 2 mandates ' +
-           'Prisoner career next term',
-      4 => 'You learn something you should not know, and people want to ' +
-           'kill you for it.  Gain an Enemy and Deception 1',
-      5 => 'Your work comes home with you, and someone gets hurt. ' +
-           'Choose a Contact, Ally, or Family Member, and roll twice on the ' +
-           'Injury Table for them, taking the lower result.',
-      6 => 'Injured. Roll on the Injury table.',
-    }
-
-  end
-
-  class Citizen < Career; end
-
-  class Drifter < Career
-    # QUALIFICATION = [:intelligence, 0]
-    ADVANCED_EDUCATION = 99
-    PERSONAL_SKILLS = [:strength, :endurance, :dexterity,
-                       :language_group, :social_sciences_group,
-                       :jack_of_all_trades]
-    SERVICE_SKILLS = [:athletics_group, :melee_unarmed_combat, :recon,
-                      :streetwise, :stealth, :survival]
-    ADVANCED_SKILLS = []
-    SPECIALIST = {
-      barbarian: {
-        skills: [:animals_group, :carouse, :melee_blade,
-                 :stealth, :seafarer_group, :survival],
-        survival: [:endurance, 7],
-        advancement: [:strength, 7],
-        ranks: {
-          1 => [nil, :survival, 1],
-          2 => ['Warrior', :melee_blade, 1],
-          4 => ['Chieftain', :leadership, 1],
-          6 => ['Warlord', nil, nil],
-        },
-      },
-      wanderer: {
-        skills: [:drive_group, :deception, :recon,
-                 :stealth, :streetwise, :survival],
-        survival: [:endurance, 7],
-        advancement: [:intelligence, 7],
-        ranks: {
-          1 => [nil, :streetwise, 1],
-          3 => [nil, :deception, 1],
-        },
-      },
-      scavenger: {
-        skills: [:pilot_small_craft, :mechanic, :astrogation,
-                 :vacc_suit, :engineer_group, :gun_combat_group],
-        survival: [:dexterity, 7],
-        advancement: [:endurance, 7],
-        ranks: {
-          1 => [nil, :vacc_suit, 1],
-          3 => [nil, :mechanic, 1],
-        },
-      },
-    }
-
-    MUSTER_OUT = {
-      1 => [0, 'Contact'],
-      2 => [0, 'Weapon'],
-      3 => [1000, 'Ally'],
-      4 => [2000, 'Weapon'],
-      5 => [3000, 'EDU +1'],
-      6 => [4000, 'Ship Share'],
-      7 => [8000, 'Ship Share x2'],
-    }
-
-    EVENTS = {
-      1 => '',
-      2 => '',
-      3 => '',
-      4 => '',
-      5 => '',
-      6 => '',
-      7 => '',
-      8 => '',
-      9 => '',
-      10 => '',
-      11 => '',
-      12 => '',
-    }
-
-    MISHAPS = {
-      1 => '',
-      2 => '',
-      3 => '',
-      4 => '',
-      5 => '',
-      6 => '',
-    }
-
-    def qualify_check?(dm: 0)
-      true
+  module Careers
+    class Error < RuntimeError; end
+    class StatError < Error; end
+    class UnknownStat < StatError; end
+    class StatCheckError < StatError; end
+    class SkillError < Error; end
+    class UnknownSkill < SkillError; end
+    class RankError < Error; end
+    class EventError < Error; end
+    class MishapError < Error; end
+    class CreditError < Error; end
+    class BenefitError < Error; end
+
+    def self.load(file_name)
+      hsh = YAML.load_file(self.find(file_name))
+      raise "unexpected object: #{hsh.inspect}" unless hsh.is_a?(Hash)
+      hsh
     end
-  end
-
-  class Entertainer < Career; end
-  class Merchant < Career; end
-  class Rogue < Career; end
-  class Scholar < Career; end
-
-  class Scout < Career
-    QUALIFICATION   = [:intelligence, 5]
-    ADVANCED_EDUCATION = 8
-    PERSONAL_SKILLS = [:strength, :dexterity, :endurance,
-                       :intelligence, :education, :jack_of_all_trades]
-    SERVICE_SKILLS  = [:pilot_small_craft, :survival, :mechanic,
-                      :astrogation, :comms, :gun_combat_group]
-    ADVANCED_SKILLS = [:medic, :navigation, :engineer_group,
-                       :computers, :space_sciences_group, :jack_of_all_trades]
-
-    RANKS = {
-      1 => ['Scout', :vacc_suit, 1],
-      3 => ['Senior Scout', :pilot, 1],
-    }
-
-    SPECIALIST = {
-      courier: {
-        skills:   [:comms, :sensors, :pilot_spacecraft,
-                   :vacc_suit, :zero_g, :astrogation],
-        survival: [:endurance, 5],
-        advancement: [:education, 9],
-        ranks: RANKS,
-      },
-      surveyor: {
-        skills: [:sensors, :persuade, :pilot_small_craft,
-                 :navigation, :diplomat, :streetwise],
-        survival: [:endurance, 6],
-        advancement: [:intelligence, 8],
-        ranks: RANKS,
-      },
-      explorer: {
-        skills: [:sensors, :pilot_spacecraft, :pilot_small_craft,
-                 :life_sciences_group, :stealth, :recon],
-        survival: [:endurance, 7],
-        advancement: [:education, 7],
-        ranks: RANKS,
-      },
-    }
-
-    MUSTER_OUT = {
-      1 => [20000, 'Ship Share'],
-      2 => [20000, 'INT +1'],
-      3 => [30000, 'EDU +1'],
-      4 => [30000, 'Weapon'],
-      5 => [50000, 'Weapon'],
-      6 => [50000, 'Scout Ship'],
-      7 => [50000, 'Scout Ship'],
-    }
-
-    # Weapon: Select any weapon up to 1000 creds and TL12
-    # If this benefit is rolled more than once, take a different weapon
-    # or one level in the appropriate Melee or Gun Combat skill
-
-    # Scout Ship: Receive a scout ship in exchange for performing periodic
-    #             scout missions
-
-    # Ship share: Accumulate these to redeem for a ship.  They are worth
-    #             roughly 1M creds but cannot be redeemed for creds.
-
-
-    EVENTS = {
-      2 => 'Disaster! Roll on the mishap table but you are not ejected ' +
-           'from career.',
-      3 => 'Ambush! Choose Pilot 8+ to escape or Persuade 10+ to bargain. ' +
-           'Gain an Enemy either way',
-      4 => 'Survey an alien world.  Choose Animals, Survival, Recon, or ' +
-           'Life Sciences 1',
-      5 => 'You perform an exemplary service.  Gain a benefit roll with +1 DM',
-      6 => 'You spend several years exploring the star system; ' +
-           'Choose Atrogation, Navigation, Pilot (small craft) or Mechanic 1',
-      7 => 'Life event.  Roll on the Life Events table',
-      8 => 'Gathered intelligence on an alien race.  Roll Sensors 8+ or ' +
-           'Deception 8+.  Gain an ally in the Imperium and +2 DM to your ' +
-           'next Advancement roll on success.  Roll on the mishap table on ' +
-           'failure, but you are not ejected from career.',
-      9 => 'You rescue disaster survivors.  Roll either Medic 8+ or ' +
-           'Engineer 8+.  Gain a Contact and +2 DM on next Advancement roll ' +
-           'or else gain an Enemy',
-      10 => 'You spend a great deal of time on the fringes of known space. ' +
-            'Roll Survival 8+ or Pilot 8+.  Gain a Contact in an alien race ' +
-            'and one level in any skill, or else roll on the Mishap table.',
-      11 => 'You serve as a courier for an important message for the ' +
-            'Imperium.  Gain one level of diplomat or take +4 DM to your ' +
-            'next Advancement roll.',
-      12 => 'You make an important discovery for the Imperium.  Gain a ' +
-            'career rank.',
-    }
-
-    MISHAPS = {
-      1 => 'Severely injured in action.  Roll twice on the Injury table ' +
-           'or take a level 2 Injury.',
-      2 => 'Suffer psychological damage. Reduce Intelligence or Social ' +
-           'Standing by 1',
-      3 => 'Your ship is damaged, and you have to hitch a ride back to ' +
-           'your nearest scout base.  Gain 1d6 Contacts and 1d3 Enemies.',
-      4 => 'You inadvertently cause a conflict between the Imperium and ' +
-           'a minor world or race.  Gain a Rival and Diplomat 1.',
-      5 => 'You have no idea what happened to you.  Your ship was found ' +
-           'drifting on the fringes of friendly space',
-      6 => 'Injured.  Roll on the Injury table.',
-    }
-  end
 
-  class Army < MilitaryCareer
-    QUALIFICATION = [:endurance, 5]
-    AGE_PENALTY = 30
-    PERSONAL_SKILLS = [:strength, :dexterity, :endurance,
-                       :gambler, :medic, :melee_group]
-    SERVICE_SKILLS = [:drive_group, :athletics_group, :gun_combat_group,
-                      :recon, :melee_group, :heavy_weapons_group]
-    ADVANCED_SKILLS = [:tactics_military, :leadership, :advocate,
-                       :diplomat, :electronics, :admin]
-    OFFICER_SKILLS = [:tactics_military, :leadership, :advocate,
-                      :diplomat, :electronics, :admin]
-    RANKS = {
-      0 => ['Private', :gun_combat_group, 1],
-      1 => ['Lance Corporal', :recon, 1],
-      2 => ['Corporal', nil, nil],
-      3 => ['Lance Sergeant', :leadership, 1],
-      4 => ['Sergeant', nil, nil],
-      5 => ['Gunnery Sergeant', nil, nil],
-      6 => ['Sergeant Major', nil, nil],
-    }
-    OFFICER_RANKS = {
-      1 => ['Lieutenant', :leadership, 1],
-      2 => ['Captain', nil, nil],
-      3 => ['Major', :tactics_military, 1],
-      4 => ['Lieutenant Colonel', nil, nil],
-      5 => ['Colonel', nil, nil],
-      6 => ['General', :social_status, 10],  # TODO
-    }
+    def self.find(file_name)
+      path = File.join(__dir__, 'careers', file_name)
+      files = Dir["#{path}*"].grep %r{\.ya?ml\z}
+      case files.size
+      when 0
+        raise "can't find #{file_name}"
+      when 1
+        files[0]
+      else
+        # prefer .yaml to .yml -- otherwise give up
+        files.grep(/\.yaml\z/).first or
+          raise "#{file_name} matches #{files}"
+      end
+    end
 
-    SPECIALIST = {
-      support: {
-        skills: [:mechanic, :flyer_group, :engineer_group, # TODO: profession
-                 :explosives, :comms, :medic],
-        survival: [:endurance, 5],
-        advancement: [:education, 7],
-        ranks: RANKS,
-      },
-      infantry: {
-        skills: [:gun_combat_group, :melee_group, :heavy_weapons_group,
-                 :stealth, :athletics_group, :recon],
-        survival: [:strength, 6],
-        advancement: [:education, 6],
-        ranks: RANKS,
-      },
-      cavalry: {
-        skills: [:mechanic, :drive_group, :flyer_group,
-                 :recon, :heavy_weapons_group, :sensors], # TODO: HW vehicle
-        survival: [:intelligence, 7],
-        advancement: [:intelligence, 5],
-        ranks: RANKS,
-      },
-    }
+    def self.skill?(str)
+      !!TravellerRPG::SkillSet.split_skill!(str) rescue false
+    end
 
-    EVENTS = {
-      2 => nil,
-      3 => nil,
-      4 => nil,
-      5 => nil,
-      6 => nil,
-      7 => nil,
-      8 => nil,
-      9 => nil,
-      10 => nil,
-      11 => nil,
-      12 => nil,
-    }
+    # accepts symbol or string
+    def self.stat? stat
+      Character::Stats.member? stat
+    end
 
-    MISHAPS = {
-      1 => nil,
-      2 => nil,
-      3 => nil,
-      4 => nil,
-      5 => nil,
-      6 => nil,
-    }
+    # accepts symbol or string; raises if not recongnized
+    def self.stat_sym! stat
+      raise(UnknownStat, stat) unless self.stat? stat
+      Character::Stats.sym stat
+    end
 
-    # roll => [cash, benefit]
-    MUSTER_OUT = {
-      1 => [2000, 'Combat Implant'],
-      2 => [5000, 'INT +1'],
-      3 => [10_000, 'EDU +1'],
-      4 => [10_000, 'Weapon'],
-      5 => [10_000, 'Armour'],
-      6 => [20_000, 'END +1 or Combat Implant'],
-      7 => [30_000, 'SOC +1'],
-    }
-  end
+    # accepts symbol or string; returns symbol if stat is recognized
+    def self.stat_sym stat
+      self.stat?(stat) ? Character::Stats.sym(stat) : stat
+    end
 
-  class Marines < MilitaryCareer
-    QUALIFICATION = [:endurance, 6]
-    AGE_PENALTY = 30
+    # convert 'choose' to :choose and e.g. 'strength' to :strength
+    def self.fetch_stat_check!(hsh, key)
+      raise(StatCheckError, "#{key} not found: #{hsh}") unless hsh.key? key
+      cfg = hsh[key] or return false # e.g. Drifter
+      raise(StatCheckError, cfg) unless cfg.is_a?(Hash) and cfg.size == 1
+      result = {}
+      if cfg.key? 'choose'
+        result[:choose] = {}
+        cfg['choose'].each { |stat, check|
+          result[:choose][self.stat_sym!(stat)] = check
+        }
+      else
+        result[self.stat_sym!(cfg.keys.first)] = cfg.values.first
+      end
+      result
+    end
 
-    PERSONAL_SKILLS = [:strength, :dexterity, :endurance,
-                       :gambler, :melee_unarmed_combat, :melee_blade]
-    SERVICE_SKILLS = [:athletics_group, :vacc_suit, :tactics_group,
-                      :heavy_weapons_group, :gun_combat_group, :stealth]
-    ADVANCED_SKILLS = [:medic, :survival, :explosives,
-                       :engineer_group, :pilot_group, :navigation]
-    OFFICER_SKILLS = [:engineer_group, :tactics_group, :admin,
-                      :advocate, :vacc_suit, :leadership]
-    RANKS = {
-      0 => ['Marine', :gun_combat_group, 1], # TODO
-      1 => ['Lance Corporal', :gun_combat_group, 1],
-      2 => ['Corporal', nil, nil],
-      3 => ['Lance Sergeant', :leadership, 1],
-      4 => ['Sergeant', nil, nil],
-      5 => ['Gunnery Sergeant', :endurance, nil],
-      6 => ['Sergeant Major', nil, nil],
-    }
-    OFFICER_RANKS = {
-      1 => ['Lieutenant', :leadership, 1],
-      2 => ['Captain', nil, nil],
-      3 => ['Force Commander', :tactics_group, 1],
-      4 => ['Lieutenant Colonel', nil, nil],
-      5 => ['Colonel', :social_status, 10],  # TODO
-      6 => ['Brigadier', nil, nil],
-    }
+    def self.fetch_skills!(hsh, key, stats_ok: true)
+      ary = hsh[key] or raise(SkillError, hsh[key].inspect)
+      unless ary.is_a?(Array) and ary.size == 6
+        raise(SkillError, "unexpected: #{ary}")
+      end
+      self.extract_skills(ary, stats_ok: stats_ok)
+    end
 
-    SPECIALIST = {
-      support: {
-        skills: [:engineer_electronics, :mechanic, :flyer_group, # TODO
-                 :medic, :heavy_weapons_group, :gun_combat_group],
-        survival: [:endurance, 5],
-        advancement: [:education, 7],
-        ranks: RANKS,
-      },
-      star_marine: {
-        skills: [:vacc_suit, :athletics_group, :gunner_group,
-                 :melee_blade, :engineer_electronics, :gun_combat_group],
-        survival: [:endurance, 6],
-        advancement: [:education, 6],
-        ranks: RANKS,
-      },
-      ground_assault: {
-        skills: [:vacc_suit, :heavy_weapons_group, :recon,
-                 :melee_blade, :tactics_military, :gun_combat_group],
-        survival: [:endurance, 7],
-        advancement: [:education, 5],
-        ranks: RANKS,
+    # convert 'choose' to :choose and e.g. 'strength' to :strength
+    def self.extract_skills(ary, stats_ok: true)
+      ary.reduce([]) { |memo, val|
+        case val
+        when Hash
+          raise(SkillError, val) unless val['choose'].is_a? Array
+          val = {
+            choose: self.extract_skills(val['choose'], stats_ok: stats_ok)
+          }
+        else
+          if stats_ok and self.stat? val
+            val = self.stat_sym! val
+          else
+            raise(UnknownSkill, val) unless self.skill? val
+          end
+        end
+        memo + [val]
       }
-    }
-
-    EVENTS = {
-      2 => nil,
-      3 => nil,
-      4 => nil,
-      5 => nil,
-      6 => nil,
-      7 => nil,
-      8 => nil,
-      9 => nil,
-      10 => nil,
-      11 => nil,
-      12 => nil,
-    }
+    end
 
-    MISHAPS = {
-      1 => nil,
-      2 => nil,
-      3 => nil,
-      4 => nil,
-      5 => nil,
-      6 => nil,
-    }
+    def self.ranks(hsh, key = 'ranks')
+      r = hsh[key] or raise(RankError, "no rank: #{hsh}")
+      raise(RankError, r) unless r.is_a? Hash and r.size <= 7
+      result = {}
+      r.each { |rank, h|
+        result[rank] = {}
+        raise(RankError, h) unless h.is_a? Hash and h.size <= 3
+        raise(RankError, h) if (h.keys & %w{title skill stat choose}).empty?
+        title, skill, stat, level = h.values_at(*%w{title skill stat level})
+        if title
+          raise(RankError, "not a string: #{title}") unless title.is_a?(String)
+          result[rank][:title] = title
+        end
+        choices = h['choose']
+        if choices
+          raise("bad choices: #{choices}") unless choices.is_a?(Array)
+          result[rank][:choose] = []
+          choices.each { |hh|
+            if hh['skill'] and hh['stat']
+              raise("can't have both skill and stat: #{hh}")
+            elsif hh['skill']
+              raise(UnknownSkill, hh['skill']) unless self.skill?(hh['skill'])
+              res = { skill: hh['skill'] }
+              res[:level] = hh['level'] if hh['level']
+              result[rank][:choose] << res
+            elsif hh['stat']
+              res = { stat: self.stat_sym!(hh['stat']) }
+              res[:level] = hh['level'] if hh['level']
+              result[rank][:choose] << res
+            else
+              raise("need at least one of skill or stat: #{hh}")
+            end
+          }
+          next
+        end
+
+        # ok, no choose
+
+        if skill
+          case skill
+          when String
+            result[rank][:skill] =
+              self.skill?(skill) ? skill : raise(UnknownSkill, skill)
+          else
+            raise(UnknownSkill, skill)
+          end
+        end
+        if stat
+          case stat
+          when String, Symbol
+            result[rank][:stat] = self.stat_sym! stat
+          else
+            raise(UnknownStat, stat)
+          end
+        end
+        if level
+          raise(RankError, "unexpected level: #{level}") unless skill or stat
+          raise(RankError, "bad level: #{level}") unless (0..5).include?(level)
+          result[rank][:level] = level
+        end
+      }
+      result
+    end
 
-    MUSTER_OUT = {
-      1 => [2000, 'Armour'],
-      2 => [5000, 'INT +1'],
-      3 => [5000, 'EDU +1'],
-      4 => [10_000, 'Weapon'],
-      5 => [20_000, 'TAS Membership'],
-      6 => [30_000, 'Armour or END +1'],
-      7 => [40_000, 'SOC +2'],
-    }
-  end
+    def self.specialist(hsh)
+      result = {}
+      hsh.fetch('specialist').each { |asg, cfg|
+        result[asg] = {}
+        result[asg][:survival] = self.fetch_stat_check!(cfg, 'survival')
+        result[asg][:advancement] = self.fetch_stat_check!(cfg, 'advancement')
+        result[asg][:skills] = self.fetch_skills!(cfg, 'skills')
+        result[asg][:ranks] = self.ranks(cfg)
+      }
+      result
+    end
 
-  class Navy < MilitaryCareer
-    QUALIFICATION = [:intelligence, 6]
-    AGE_PENALTY = 34
+    def self.events(hsh, key, size)
+      result = {}
+      e = hsh[key]
+      raise(EventError, "#{key} #{e}") unless e.is_a?(Hash) and e.size == size
+      e.each { |num, h|
+        result[num] = {}
+        raise(EventError, h) unless h.is_a?(Hash)
+        result[num][:text] = h.fetch('text')
+        result[num][:script] = h['script'] if h['script']
+      }
+      result
+    end
 
-    PERSONAL_SKILLS = [:strength, :dexterity, :endurance,
-                       :intelligence, :education, :social_standing]
-    SERVICE_SKILLS = [:pilot_group, :vacc_suit, :athletics_group,
-                      :gunner_group, :mechanic, :gun_combat_group]
-    ADVANCED_SKILLS = [:engineer_electronics, :astrogation, :engineer_group,
-                       :drive_group, :navigation, :admin]
-    OFFICER_SKILLS = [:leadership, :engineer_electronics, :pilot,
-                      :melee_blade, :admin, :tactics_naval]
-    RANKS = {
-      0 => ['Crewman', nil, nil],
-      1 => ['Able Spacehand', :mechanic, 1],
-      2 => ['Petty Officer 3rd class', :vacc_suit, 1],
-      3 => ['Petty Officer 2nd class', nil, nil],
-      4 => ['Petty Officer 1st class', :endurance, nil],
-      5 => ['Chief Petty Officer', nil, nil],
-      6 => ['Master Chief', nil, nil],
-    }
-    OFFICER_RANKS = {
-      1 => ['Ensign', :melee_blade, 1],
-      2 => ['Sublieutenant', :leadership, 1],
-      3 => ['Lieutenant', nil, nil],
-      4 => ['Commander', :tactics_naval, 1],
-      5 => ['Captain', :social_status, 10], # TODO
-      6 => ['Admiral', :social_status, 12], # TODO
-    }
-    SPECIALIST = {
-      line_crew: {
-        skills: [:engineer_electronics, :mechanic, :gun_combat_group,
-                 :flyer_group, :melee_group, :vacc_suit],
-        survival: [:intelligence, 5],
-        advancement: [:education, 7],
-        ranks: RANKS,
-      },
-      engineer_gunner: {
-        skills: [:engineer_group, :mechanic, :engineer_electronics,
-                 :engineer_group, :gunner_group, :flyer_group],
-        survival: [:intelligence, 6],
-        advancement: [:education, 6],
-        ranks: RANKS,
-      },
-      flight: {
-        skills: [:pilot_group, :flyer_group, :gunner_group,
-                 :pilot_small_craft, :astrogation, :engineer_electronics],
-        survival: [:dexterity, 7],
-        advancement: [:education, 5],
-        ranks: RANKS,
-      },
-    }
+    def self.credits(hsh)
+      c = hsh.fetch('credits')
+      raise(CreditError, c) unless c.is_a?(Array) and c.size == 7
+      creds = {}
+      c.each.with_index { |credits, idx|
+        raise(CreditError, credits) unless credits.is_a? Integer
+        creds[idx + 1] = credits
+      }
+      creds
+    end
 
-    EVENTS = {
-      2 => nil,
-      3 => nil,
-      4 => nil,
-      5 => nil,
-      6 => nil,
-      7 => nil,
-      8 => nil,
-      9 => nil,
-      10 => nil,
-      11 => nil,
-      12 => nil,
-    }
+    def self.benefits(hsh)
+      result = {}
+      b = hsh.fetch('benefits')
+      raise(BenefitError, b) unless b.is_a?(Array) and b.size == 7
+      b.each.with_index { |item, idx|
+        case item
+        when String
+          result[idx + 1] = self.stat_sym(item)
+        when Hash
+          ary = item['choose']
+          raise(BenefitError, item) unless ary.is_a?(Array) and ary.size < 5
+          result[idx + 1] = { choose: ary.map { |a| self.stat_sym(a) } }
+        when Array
+          result[idx + 1] = item.map { |a| self.stat_sym(a) }
+        else
+          raise(BenefitError, item)
+        end
+      }
+      result
+    end
 
-    MISHAPS = {
-      1 => nil,
-      2 => nil,
-      3 => nil,
-      4 => nil,
-      5 => nil,
-      6 => nil,
-    }
+    def self.generate_classes(file_name, superclass)
+      scope = TravellerRPG
+      self.load(file_name).each { |name, cfg|
+        # inherit from Career
+        c = Class.new(superclass)
+
+        begin
+          # create class constants
+          c.const_set('QUALIFICATION',
+                      self.fetch_stat_check!(cfg, 'qualification'))
+          c.const_set('PERSONAL_SKILLS', self.fetch_skills!(cfg, 'personal'))
+          c.const_set('SERVICE_SKILLS', self.fetch_skills!(cfg, 'service'))
+          if cfg.key?('advanced_education')
+            c.const_set('ADVANCED_EDUCATION', cfg['advanced_education'])
+            if cfg['advanced_education']
+              c.const_set('ADVANCED_SKILLS',
+                          self.fetch_skills!(cfg, 'advanced'))
+            end
+          end
+          c.const_set('SPECIALIST', self.specialist(cfg))
+          # TODO: Events and mishaps are tedious to write.
+          #       Currently Career::EVENTS and ::MISHAPS provides defaults.
+          #       These should be mandatory once defined for each career.
+          if cfg['events']
+            c.const_set('EVENTS', self.events(cfg, 'events', 11))
+            c.const_set('MISHAPS', self.events(cfg, 'mishaps', 6))
+          end
+          c.const_set('CREDITS', self.credits(cfg))
+          c.const_set('BENEFITS', self.benefits(cfg))
+
+
+          if superclass == MilitaryCareer
+            c.const_set('AGE_PENALTY', cfg.fetch('age_penalty'))
+            c.const_set('COMMISSION',
+                        self.fetch_stat_check!(cfg, 'commission'))
+            c.const_set('OFFICER_RANKS',
+                        self.ranks(cfg, 'officer_ranks'))
+            c.const_set('OFFICER_SKILLS', self.fetch_skills!(cfg, 'officer'))
+          end
+        rescue => e
+          warn ["Career: #{name}", e.class, e].join("\n")
+          raise
+        end
+        # set class e.g. TravellerRPG::Agent
+        scope.const_set(name, c)
+      }
+    end
 
-    MUSTER_OUT = {
-      1 => [1000, 'Personal Vehicle or Ship Share'],
-      2 => [5000, 'INT +1'],
-      3 => [5000, 'EDU +1 or two Ship Shares'],
-      4 => [10_000, 'Weapon'],
-      5 => [20_000, 'TAS Membership'],
-      6 => [50_000, "Ship's Boat or two Ship Shares"],
-      7 => [50_000, 'SOC +2'],
-    }
+    self.generate_classes('base', Career)
+    self.generate_classes('military', MilitaryCareer)
   end
 end