traveller_rpg 0.0.0.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5641a18846aa83312b6821006edc36d5add290b17263c4258ad76413b8891993
+  data.tar.gz: 2041763e41ee95d19f4917ff3d996f53820e544caa63655d6e8a5d7cbf361ad9
+SHA512:
+  metadata.gz: 2ebedfc2b15be64c0a617b376640397a42fccce3d1df8948da6f2c340aa5dbc60ca4cbe28ff3c20bd1e52df9b10867c97d83412e300f49bc05b1b3299c111cda
+  data.tar.gz: f21f01d409cd0f3169126e744527f35ee88d9f545974cd57d548082270b94f0e4b7350d0e152ab46eeb999741dcee110adf4a34aaae3c4ddc27ba48a1e2a795e

data/README.md

@@ -0,0 +1,6 @@
+# Traveller RPG
+
+This work was inspired by
+https://github.com/LeamHall/CT_Character_Generator which is also the origin
+for some of the `data/*.txt` files.  Most of the behavior is based on
+information available from http://www.traveller-srd.com/core-rules

data/Rakefile

@@ -0,0 +1,18 @@
+require 'rake/testtask'
+
+Rake::TestTask.new :test do |t|
+  t.pattern = "test/*.rb"
+  t.warning = true
+end
+
+begin
+  require 'buildar'
+
+  Buildar.new do |b|
+    b.gemspec_file = 'traveller_rpg.gemspec'
+    b.version_file = 'VERSION'
+    b.use_git = true
+  end
+rescue LoadError
+  warn "buildar tasks unavailable"
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.0.4

data/bin/chargen

@@ -0,0 +1,47 @@
+#!/usr/bin/env ruby
+
+require 'pry'
+require 'traveller_rpg'
+require 'traveller_rpg/careers'
+require 'traveller_rpg/generator'
+require 'traveller_rpg/career_path'
+
+char = TravellerRPG::Generator.character
+path = TravellerRPG::CareerPath.new(char)
+
+careers = %w{Scout}
+
+loop {
+  careers = careers.select { |c| path.eligible? c }
+  if careers.empty?
+    puts "No eligible careers available!"
+    break
+  end
+  career = TravellerRPG.choose("Choose a career", *careers)
+  career = TravellerRPG.career_class(career).new(char)
+
+  # skip draft / drifter for now
+  accepted = false
+  accepted = path.apply(career) while !accepted
+
+  #
+  loop {
+    path.run_term
+    break unless path.active_career
+    break if career.must_exit?
+    next if career.must_remain?
+    break if TravellerRPG.choose("Muster out?", :yes, :no) == :yes
+  }
+  path.muster_out if path.active_career
+
+  puts char.desc.pretty_inspect
+  puts char.stats.pretty_inspect
+  puts char.skills.pretty_inspect
+  puts char.stuff.pretty_inspect
+
+  break if TravellerRPG.choose("Exit career mode?", :yes, :no) == :yes
+}
+
+binding.pry if ENV['PRY']
+
+puts "DONE"

data/lib/traveller_rpg/career.rb

@@ -0,0 +1,269 @@
+require 'traveller_rpg'
+
+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
+
+    TERM_YEARS = 4
+
+    QUALIFY_CHECK = 5
+    SURVIVAL_CHECK = 6
+    ADVANCEMENT_CHECK = 9
+
+    STATS = Array.new(6) { :default }
+    SERVICE_SKILLS = Array.new(6) { :default }
+    ADVANCED_SKILLS = Array.new(6) { :default }
+    SPECIALIST_SKILLS = { default: Array.new(6) { :default } }
+    RANKS = {}
+
+    EVENTS = {
+      2 => nil,
+      3 => nil,
+      4 => nil,
+      5 => nil,
+      6 => nil,
+      7 => nil,
+      8 => nil,
+      9 => nil,
+      10 => nil,
+      11 => nil,
+      12 => nil,
+    }
+
+    MISHAPS = {
+      1 => nil,
+      2 => nil,
+      3 => nil,
+      4 => nil,
+      5 => nil,
+      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,
+    }
+
+    attr_reader :stats, :skills, :benefits
+    attr_accessor :term, :active, :rank
+
+    def initialize(char, assignment: nil, term: 0, active: false, rank: 0,
+                   benefits: {})
+      @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
+    end
+
+    def assignment
+      @assignment ||= TravellerRPG.choose("Choose a specialty:",
+                                       *self.class::SPECIALIST_SKILLS.keys)
+    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
+    end
+
+    def survival_check?(dm: 0)
+      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
+    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
+    end
+
+    # any skills obtained start at level 1
+    def training_roll
+      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
+    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)
+      # 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)
+      # 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}"
+        @char.log "Achieved rank skill: #{skill} #{level}"
+        @char.skills[skill] ||= 0
+        @char.skills[skill] = level if level > @char.skills[skill]
+      end
+    end
+
+    def must_remain?
+      @term_mandate == :must_remain
+    end
+
+    def must_exit?
+      @term_mandate == :must_exit
+    end
+
+    def run_term
+      raise(Error, "career is inactive") unless @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
+
+      if self.survival_check?
+        @char.log format("%s term %i was successful", self.name, @term)
+        @char.age TERM_YEARS
+
+        self.commission_roll if self.respond_to?(:commission_roll)
+
+        adv_roll = TravellerRPG.roll('2d6')
+        # TODO: DM?
+        if self.advancement_check?(roll: adv_roll)
+          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
+
+        self.event_roll
+      else
+        @char.log "#{self.name} career ended with a mishap!"
+        @char.age rand(TERM_YEARS) + 1
+        self.mishap_roll
+        @active = false
+      end
+    end
+
+    def retirement_bonus
+      @term >= 5 ? @term * 2000 : 0
+    end
+
+    def muster_out(dm: 0)
+      if @active
+        raise(MusterError, "career has not started") unless @term > 0
+        @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
+      end
+    end
+
+    def name
+      self.class.name.split('::').last
+    end
+
+    # possibly nil
+    def rank_benefit
+      self.class::RANKS[@rank]
+    end
+  end
+end

data/lib/traveller_rpg/career_path.rb

@@ -0,0 +1,93 @@
+require 'traveller_rpg/career'
+
+module TravellerRPG
+  class CareerPath
+    class Error < RuntimeError; end
+    class Ineligible < Error; end
+
+    attr_reader :char, :careers, :active_career
+
+    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 }
+    end
+
+    def apply(career)
+      raise(Ineligible, career.name) unless self.eligible?(career)
+      if career.qualify_check?(@careers.size)
+        @char.log "Qualified for #{career.name}"
+        self.enter(career)
+      else
+        @char.log "Did not qualify for #{career.name}"
+        false
+      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
+    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
+      }
+    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
+    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
+      end
+    end
+
+    def draft_term
+      @char.log "Drafted! (fake)"
+    end
+
+    def drifter_term
+      @char.log "Became a drifter (fake)"
+    end
+  end
+end

data/lib/traveller_rpg/careers.rb

@@ -0,0 +1,159 @@
+require 'traveller_rpg'
+require 'traveller_rpg/career'
+
+module TravellerRPG
+  class MilitaryCareer < Career
+    COMMISSION_CHECK = 9
+    OFFICER_SKILLS = Array.new(6) { :default }
+    OFFICER_RANKS = {}
+
+    attr_reader :officer, :officer_rank
+
+    def initialize(char, **kwargs)
+      super(char, **kwargs)
+      @officer = false
+    end
+
+    def rank
+      @officer ? @officer_rank : @rank
+    end
+
+    def rank_benefit
+      @officer ? self.class::OFFICER_RANKS[@officer_rank] : super
+    end
+
+    def advance_rank
+      return super unless @officer
+      @officer_rank += 1
+      @char.log "Advanced career to officer rank #{@officer_rank}"
+      title, skill, level = self.rank_benefit
+      if title
+        @char.log "Awarded officer rank title: #{title}"
+        @char.log "Achieved officer rank skill: #{skill} #{level}"
+        @char.skills[skill] ||= 0
+        @char.skills[skill] = level if level > @char.skills[skill]
+      end
+    end
+
+    def commission_check?(dm = 0)
+      roll = TravellerRPG.roll('2d6')
+      puts format("Commission check: roll %i (DM %i) against %i",
+                  roll, dm, self.class::COMMISSION_CHECK)
+      (roll + dm) >= self.class::COMMISSION_CHECK
+    end
+
+    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 = true
+          @officer_rank = 1
+        else
+          @char.log "Commission was rejected"
+        end
+      end
+    end
+
+    def officer?
+      !!@officer
+    end
+  end
+
+  class Navy < MilitaryCareer
+  end
+
+  class Army < MilitaryCareer
+  end
+
+  class Marines < MilitaryCareer
+  end
+
+  class MerchantMarine < MilitaryCareer
+  end
+
+  class Agent < MilitaryCareer
+  end
+
+  class Scout < MilitaryCareer
+    # note, 6th "stat" is really a skill - jack of all trades
+    STATS = [: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,
+                       :computers, :space_science, :jack_of_all_trades]
+
+    # made up by Rick
+    OFFICER_SKILLS = [:deception, :language_group, :investigate,
+                      :remote_operations, :tactics_military, :leadership]
+    SPECIALIST_SKILLS = {
+      courier: [:comms, :sensors, :pilot_spacecraft,
+                :vacc_suit, :zero_g, :astrogation],
+      survey: [:sensors, :persuade, :pilot_small_craft,
+               :navigation, :diplomat, :streetwise],
+      exploration: [:sensors, :pilot_spacecraft, :pilot_small_craft,
+                    :life_science_any, :stealth, :recon],
+    }
+
+    # key: roll; values: title, skill, skill_value
+    RANKS = {
+      1 => [:scout, :vacc_suit, 1],
+      3 => [:senior_scout, :pilot, 1],
+    }
+
+    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.',
+    }
+
+    # not defined at http://www.traveller-srd.com/core-rules/careers/ :(
+    BENEFITS = {}
+
+    def qualify_check?(career_count)
+      @char.log format("Qualify DM is based on Intelligence %i",
+                       @char.stats.intelligence)
+      super(career_count, dm: @char.class.stats_dm(@char.stats.intelligence))
+    end
+  end
+
+  class Drifter < Career
+  end
+end

data/lib/traveller_rpg/character.rb

@@ -0,0 +1,128 @@
+require 'traveller_rpg'
+
+module TravellerRPG
+  class Character
+    Stats = Struct.new(:strength, :dexterity, :endurance,
+                       :intelligence, :education, :social_status) do
+      def self.roll(spec = '2d6')
+        self.new(*Array.new(6) { TravellerRPG.roll spec })
+      end
+
+      def self.empty
+        self.new(*Array.new(6) { 0 })
+      end
+
+      def boost(hsh)
+        hsh.each { |k,v| self[k] += v if self[k] }
+        self
+      end
+    end
+
+    Description = Struct.new(:name, :gender, :age,
+                             :appearance, :plot, :temperament) do
+      def self.new_with_hash(hsh)
+        self.new(hsh[:name], hsh[:gender], hsh[:age],
+                 hsh[:appearance], hsh[:plot], hsh[:temperament])
+      end
+
+      def merge(other)
+        other = self.class.new_with_hash(other) if other.is_a?(Hash)
+        self.class.new(other.name || self.name,
+                       other.gender || self.gender,
+                       other.age    || self.age,
+                       other.appearance || self.appearance,
+                       other.plot       || self.plot,
+                       other.temperament || self.temperament)
+      end
+    end
+
+    def self.stats_dm(stat)
+      case stat
+      when 0 then -3
+      when 1..2 then -2
+      when 3..5 then -1
+      when 6..8 then 0
+      when 9..11 then 1
+      when 12..14 then 2
+      when 15..20 then 3
+      else
+        raise "unexpected stat: #{stat} (#{stat.class})"
+      end
+    end
+
+    attr_reader :desc, :stats, :homeworld, :skills, :stuff
+
+    def initialize(desc:, stats:, homeworld:,
+                   skills: {}, stuff: {}, log: [])
+      @desc = desc
+      @stats = stats
+      @homeworld = homeworld
+      @skills = skills
+      @stuff = stuff
+      @log = log
+      self.birth
+    end
+
+    # gain background skills based on homeworld
+    def birth
+      return nil unless @log.empty?
+      self.log format("%s was born on %s (%s)",
+                      @desc.name,
+                      @homeworld.name,
+                      @homeworld.traits.join(' '))
+      skill_count = 3 + self.class.stats_dm(@stats.education)
+      self.log format("Education %i qualifies for %i skills",
+                      @stats.education, skill_count)
+      skill_choices = []
+
+      # choose skill_count skills
+      if @homeworld.skills.size <= skill_count
+        self.log format("Homeworld %s only has %i skills available",
+                        @homeworld.name, @homeworld.skills.size)
+        skill_choices = @homeworld.skills
+      else
+        skill_count.times { |i|
+          available = @homeworld.skills - skill_choices
+          skill_choices << TravellerRPG.choose("Choose a skill:", *available)
+        }
+      end
+      skill_choices.each { |sym|
+        self.log "Acquired background skill: #{sym} 0"
+        @skills[sym] ||= 0
+      }
+    end
+
+    def add_stuff(benefits)
+      benefits.each { |sym, val|
+        self.log "Collecting #{sym} #{val}"
+        case @stuff[sym]
+        when Numeric, Array
+          self.log "Adding #{sym} #{val} to #{@stuff[sym]}"
+          @stuff[sym] += val
+        when NilClass
+          @stuff[sym] = val
+        else
+          raise("unexpected benefit: #{sym} #{val} (#{val.class})")
+        end
+      }
+    end
+
+    def log(msg = nil)
+      return @log unless msg
+      puts msg
+      @log << msg
+    end
+
+    def name
+      @desc.name
+    end
+
+    def age(years = nil)
+      years ? @desc.age += years : @desc.age
+    end
+
+    def skill_check?(skill, val = 0)
+      @skills[skill] and @skills[skill] >= val
+    end
+  end
+end

data/lib/traveller_rpg/data.rb

@@ -0,0 +1,20 @@
+module TravellerRPG
+  module Data
+    PATH = File.expand_path(File.join(__dir__, '..', '..', 'data'))
+    raise "can't find #{PATH}" unless File.directory?(PATH)
+
+    def self.files
+      Dir[File.join(PATH, '*')]
+    end
+
+    def self.sample(filename)
+      path = File.join(PATH, filename)
+      raise "#{path} does not exist" unless File.exist?(path)
+      if filename.match %r{\.txt\z}
+        File.readlines(path).sample.chomp
+      else
+        raise "can't handle #{filename}"
+      end
+    end
+  end
+end

data/lib/traveller_rpg/generator.rb

@@ -0,0 +1,63 @@
+require 'traveller_rpg'
+require 'traveller_rpg/data'
+require 'traveller_rpg/character'
+require 'traveller_rpg/homeworld'
+
+module TravellerRPG
+  module Generator
+    def self.character(descr = {}, homeworld: nil)
+      homeworld ||= self.homeworld
+      Character.new(desc: self.desc.merge(descr),
+                    stats: Character::Stats.roll,
+                    homeworld: homeworld)
+    end
+
+    def self.homeworld(name = nil)
+      name ||= Data.sample('homeworlds.txt')
+      Homeworld.new(name)
+    end
+
+    def self.name(gender)
+      case gender.to_s.downcase
+      when 'm', 'male'
+        Data.sample('male_names.txt')
+      when 'f', 'female'
+        Data.sample('female_names.txt')
+      else
+        raise "unknown gender: #{gender}"
+      end
+    end
+
+    def self.gender
+      TravellerRPG.roll(dice: 1) > 3 ? 'M' : 'F'
+    end
+
+    def self.hair(tone: nil, body: nil, color: nil, length: nil)
+      tone ||= Data.sample('hair_tone.txt')
+      body ||= Data.sample('hair_body.txt')
+      color ||= Data.sample('hair_colors.txt')
+      length ||= Data.sample('hair_length.txt')
+      [tone, body, color, length].join(' ')
+    end
+
+    def self.appearance(hair: nil, skin: nil)
+      hair ||= self.hair
+      skin ||= Data.sample('skin_tones.txt')
+      "#{hair} hair with #{skin} skin"
+    end
+
+    def self.plot
+      Data.sample('plots.txt')
+    end
+
+    def self.temperament
+      Data.sample('temperaments.txt')
+    end
+
+    def self.desc
+      gender = self.gender
+      Character::Description.new(self.name(gender), gender, 18,
+                                 self.appearance, self.plot, self.temperament)
+    end
+  end
+end

data/lib/traveller_rpg/homeworld.rb

@@ -0,0 +1,51 @@
+require 'traveller_rpg'
+
+module TravellerRPG
+  class Homeworld
+    TRAITS = {
+      agricultural: :animals,
+      asteroid: :zero_g,
+      desert: :survival,
+      fluid_oceans: :seafarer,
+      garden: :animals,
+      high_technology: :computers,
+      high_population: :streetwise,
+      ice_capped: :vacc_suit,
+      industrial: :trade,
+      low_technology: :survival,
+      poor: :animals,
+      rich: :carouse,
+      water_world: :seafarer,
+      vacuum: :vacc_suit,
+      education: [:admin, :advocate, :art, :carouse, :comms,
+                  :computer, :drive, :engineer, :language, :medic,
+                  :physical_science, :life_science, :social_science,
+                  :space_science, :trade],
+    }
+    TRAIT_MIN = 3
+    TRAIT_MAX = 6
+
+    attr_reader :name, :traits, :skills
+
+    def initialize(name, traits = [])
+      @name = name
+      if traits.size > self.class::TRAIT_MAX
+        warn "lots of world traits: #{traits}"
+      elsif traits.empty?
+        sample_num = rand(TRAIT_MAX - TRAIT_MIN + 1) + TRAIT_MIN
+        traits = self.class::TRAITS.keys.sample(sample_num)
+      end
+      @traits = traits
+      @skills = []
+      @traits.each { |trait|
+        skill = self.class::TRAITS.fetch(trait)
+        if skill.is_a?(Array)
+          skill.each { |sk| @skills << sk }
+        else
+          @skills << skill
+        end
+      }
+      @skills.uniq!
+    end
+  end
+end

data/lib/traveller_rpg.rb

@@ -0,0 +1,222 @@
+module TravellerRPG
+  PLAYER_CHOICE = ENV['PLAYER_CHOICE']
+
+  ROLL_RGX = %r{
+    \A    # starts with
+    (\d*) # 0 or more digits; dice count
+    [dD]  # character d
+    (\d+) # 1 or more digits; face count
+    \z    # end str
+  }x
+
+  def self.roll(str = nil, faces: 6, dice: 2, count: 1)
+    return self.roll_str(str) if str
+    rolln = -> (faces, dice) { Array.new(dice) { rand(faces) + 1 } }
+    (Array.new(count) { rolln.(faces, dice).sum }.sum.to_f / count).round
+  end
+
+  def self.roll_str(str)
+    matches = str.match(ROLL_RGX) or raise("bad roll: #{str}")
+    dice, faces = matches[1], matches[2]
+    self.roll(dice: dice.empty? ? 1 : dice.to_i, faces: faces.to_i)
+  end
+
+  def self.choose(msg, *args)
+    return self.player_choose(msg, *args) if PLAYER_CHOICE
+    puts msg + '  (' + args.join(' ') + ')'
+    choice = args.sample
+    puts "> #{choice}"
+    choice
+  end
+
+  def self.player_choose(msg, *args)
+    chosen = false
+    while !chosen
+      puts msg + '  (' + args.join(' ') + ')'
+      choice = self.prompt.to_s.downcase.to_sym
+      if args.include?(choice)
+        chosen = choice
+      else
+        puts "Try again.\n"
+      end
+    end
+    chosen
+  end
+
+  def self.player_prompt(msg = nil)
+    print msg + ' ' if msg
+    print '> '
+    $stdin.gets(chomp: true)
+  end
+
+  def self.career_class(str)
+    Object.const_get("TravellerRPG::#{str.split('::').last}")
+  end
+
+  # per http://www.traveller-srd.com/core-rules/skills/
+  SKILLS = {
+    admin:  nil,
+    advocate: nil,
+
+    animals_group: nil,
+    animals_riding: nil,
+    animals_veterinary: nil,
+    animals_training: nil,
+    animals_farming: nil,
+
+    athletics_group: nil,
+    athletics_coordination: nil,
+    athletics_endurance: nil,
+    athletics_strength: nil,
+    athletics_flying: nil,
+
+    art_group: nil,
+    art_acting: nil,
+    art_dance: nil,
+    art_holography: nil,
+    art_instrument: nil,
+    art_sculpting: nil,
+    art_writing: nil,
+
+    astrogation: nil,
+    battle_dress: nil,
+    broker: nil,
+    carouse: nil,
+    comms: nil,
+    computers: nil,
+    deception: nil,
+    diplomat: nil,
+
+    drive_group: nil,
+    drive_hovercraft: nil,
+    drive_mole: nil,
+    drive_tracked: nil,
+    drive_walker: nil,
+    drive_wheeled: nil,
+
+    engineer_group: nil,
+    engineer_manoeuvre: nil,
+    engineer_jump_drive: nil,
+    engineer_electronics: nil,
+    engineer_life_support: nil,
+    engineer_power: nil,
+
+    explosives: nil,
+
+    flyer_group: nil,
+    flyer_airship: nil,
+    flyer_grav: nil,
+    flyer_rotor: nil,
+    flyer_wing: nil,
+
+    gambler: nil,
+
+    gunner_group: nil,
+    gunner_turrets: nil,
+    gunner_ortillery: nil,
+    gunner_screens: nil,
+    gunner_capital_weapons: nil,
+
+    gun_combat_group: nil,
+    gun_combat_slug_rifle: nil,
+    gun_combat_slug_pistol: nil,
+    gun_combat_shotgun: nil,
+    gun_combat_energy_rifle: nil,
+    gun_combat_energy_pistol: nil,
+
+    heavy_weapons_group: nil,
+    heavy_weapons_launchers: nil,
+    heavy_weapons_man_portable_artillery: nil,
+    heavy_weapons_field_artillery: nil,
+
+    investigate: nil,
+    jack_of_all_trades: nil,
+
+    language_group: nil,
+    language_anglic: nil,
+
+    leadership: nil,
+
+    life_sciences_group: nil,
+    life_sciences_biology: nil,
+    life_sciences_cybernetics: nil,
+    life_sciences_genetics: nil,
+    life_sciences_psionicology: nil,
+
+    mechanic: nil,
+    medic: nil,
+
+    melee_group: nil,
+    melee_unarmed_combat: nil,
+    melee_blade: nil,
+    melee_bludgeon: nil,
+    melee_natural_weapons: nil,
+
+    navigation: nil,
+    persuade: nil,
+
+    pilot_group: nil,
+    pilot_small_craft: nil,
+    pilot_spacecraft: nil,
+    pilot_capital_ships: nil,
+
+    physical_sciences_group: nil,
+    physical_sciences_physics: nil,
+    physical_sciences_chemistry: nil,
+    physical_sciences_electronics: nil,
+
+    recon: nil,
+    remote_operations: nil,
+
+    seafarer_group: nil,
+    seafarer_sail: nil,
+    seafarer_submarine: nil,
+    seafarer_ocean_ships: nil,
+    seafarer_motorboats: nil,
+
+    sensors: nil,
+
+    social_sciences_group: nil,
+    social_sciences_archeology: nil,
+    social_sciences_economics: nil,
+    social_sciences_history: nil,
+    social_sciences_linguistics: nil,
+    social_sciences_philosophy: nil,
+    social_sciences_psychology: nil,
+    social_sciences_sophontology: nil,
+
+    space_sciences_group: nil,
+    space_sciences_planetology: nil,
+    space_sciences_robotics: nil,
+    space_sciences_xenology: nil,
+
+    stealth: nil,
+    steward: nil,
+    streetwise: nil,
+    survival: nil,
+
+    tactics_group: nil,
+    tactics_military: nil,
+    tactics_ground: nil,
+
+    trade_group: nil,
+    trade_biologicals: nil,
+    trade_civil_engineering: nil,
+    trade_space_construction: nil,
+    trade_hydroponics: nil,
+    trade_polymers: nil,
+
+    vacc_suit: nil,
+    zero_g: nil,
+  }
+end
+
+# compatibility stuff
+
+unless Comparable.method_defined?(:clamp)
+  module Comparable
+    def clamp(low, high)
+      [[self, low].max, high].min
+    end
+  end
+end

data/traveller_rpg.gemspec

@@ -0,0 +1,29 @@
+Gem::Specification.new do |s|
+  s.name = 'traveller_rpg'
+  s.summary = 'Automating portions of Traveller RPG'
+  s.description = 'Mostly based on Traveller SRD'
+  s.authors = ["Rick Hull"]
+  s.homepage = 'https://github.com/rickhull/traveller_rpg'
+  s.license = 'LGPL-3.0'
+  s.files = [
+    'traveller_rpg.gemspec',
+    'VERSION',
+    'Rakefile',
+    'README.md',
+    'lib/traveller_rpg.rb',
+    'lib/traveller_rpg/career_path.rb',
+    'lib/traveller_rpg/career.rb',
+    'lib/traveller_rpg/careers.rb',
+    'lib/traveller_rpg/character.rb',
+    'lib/traveller_rpg/data.rb',
+    'lib/traveller_rpg/generator.rb',
+    'lib/traveller_rpg/homeworld.rb',
+    'bin/chargen',
+  ]
+  s.executables = ['chargen']
+  s.add_development_dependency 'buildar', '~> 3'
+  s.add_development_dependency 'minitest', '~> 5'
+  s.required_ruby_version = '~> 2'
+
+  s.version = File.read(File.join(__dir__, 'VERSION')).chomp
+end

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification
+name: traveller_rpg
+version: !ruby/object:Gem::Version
+  version: 0.0.0.4
+platform: ruby
+authors:
+- Rick Hull
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-12-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: buildar
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5'
+description: Mostly based on Traveller SRD
+email: 
+executables:
+- chargen
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- Rakefile
+- VERSION
+- bin/chargen
+- lib/traveller_rpg.rb
+- lib/traveller_rpg/career.rb
+- lib/traveller_rpg/career_path.rb
+- lib/traveller_rpg/careers.rb
+- lib/traveller_rpg/character.rb
+- lib/traveller_rpg/data.rb
+- lib/traveller_rpg/generator.rb
+- lib/traveller_rpg/homeworld.rb
+- traveller_rpg.gemspec
+homepage: https://github.com/rickhull/traveller_rpg
+licenses:
+- LGPL-3.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - "~>"
+    - !ruby/object:Gem::Version
+      version: '2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.14
+signing_key: 
+specification_version: 4
+summary: Automating portions of Traveller RPG
+test_files: []