traveller_rpg 0.0.1.1 → 0.1.0.1

data/lib/traveller_rpg/character.rb

@@ -1,11 +1,21 @@
 require 'traveller_rpg'
+require 'traveller_rpg/homeworld'
+require 'traveller_rpg/skill_set'
 
 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 })
+      def self.sym(str)
+        str.is_a?(Symbol) ? str : str.to_s.downcase.gsub(' ', '_').to_sym
+      end
+
+      def self.member?(stat)
+        self.members.include? self.sym stat
+      end
+
+      def self.roll
+        self.new(*Array.new(6) { TravellerRPG.roll '2d6' })
       end
 
       def self.empty
@@ -16,23 +26,44 @@ module TravellerRPG
         hsh.each { |k,v| self[k] += v if self[k] }
         self
       end
+
+      def bump(sym, level = nil)
+        if level
+          self[sym] = level if level > self[sym]
+        else
+          self[sym] += 1
+        end
+      end
+
+      def report
+        rpt = []
+        w = 'Social Status'.size + 2
+        self.members.each { |sym|
+          rpt << format("%s: %s", sym.to_s.capitalize.rjust(w, ' '), self[sym])
+        }
+        rpt.join("\n")
+      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])
+      def merge(other)
+        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
 
-      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)
+      def report(short: false)
+        rpt = []
+        w = (short ? 'Gender' : 'Temperament').size + 2
+        self.members.each { |sym|
+          next if short and [:appearance, :plot, :temperament].include?(sym)
+          rpt << format("%s: %s", sym.to_s.capitalize.rjust(w, ' '), self[sym])
+        }
+        rpt.join("\n")
       end
     end
 
@@ -50,89 +81,64 @@ module TravellerRPG
       end
     end
 
-    attr_reader :desc, :stats, :homeworld, :skills,
-                :stuff, :credits, :cash_rolls
+    attr_reader :desc, :stats, :skills, :stuff, :credits, :cash_rolls
 
-    def initialize(desc:, stats:, homeworld:,
-                   skills: {}, stuff: {}, log: [], credits: 0, cash_rolls: 0)
+    def initialize(desc:, stats:, skills: SkillSet.new, stuff: {},
+                   log: [], credits: 0, cash_rolls: 0, homeworld: nil)
       @desc = desc
       @stats = stats
-      @homeworld = homeworld
       @skills = skills
       @stuff = stuff
       @log = log
-      @cash_rolls = cash_rolls # max 3 lifetime
       @credits = credits
-      self.birth
+      @cash_rolls = cash_rolls # max 3 lifetime
+      self.birth(homeworld) if homeworld
     end
 
     def stats_dm(stat_sym)
       self.class.stats_dm(@stats[stat_sym])
     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.stats_dm(: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)
-        }
+    # accepts an array of strings or a single string
+    # choose from the array; provide a single skill
+    # return nil if no skill was trained
+    def basic_training(skill)
+      unless @skills[skill]
+        self.log "Basic Training: #{skill} 0"
+        @skills.provide skill
       end
-      skill_choices.each { |sym|
-        if TravellerRPG::SKILLS.key?(sym)
-          self.log "Acquired background skill: #{sym} 0"
-          @skills[sym] ||= 0
-        else
-          raise(KeyError, sym)
-        end
-      }
       self
     end
 
-    def train(sym, level = nil)
-      target = TravellerRPG::SKILLS.key?(sym) ? @skills : @stats
-      target[sym] ||= 0
-      if level
-        if target[sym] < level
-          target[sym] = level
+    def benefit(item)
+      case item
+      when Integer
+        if item != 0
+          @credits += item
+          self.log "Career benefit: #{item} credits"
+        end
+      when String
+        matches = item.match %r{\A(\d)x (.+)}
+        if matches
+          # e.g. 2x Ship Share
+          count = matches[1].to_i
+          item = matches[2]
         else
-          self.log "#{sym} #{level} is < current #{target[sym]}"
+          count = 1
         end
+        qty = count > 1 ? "(#{count})" : ''
+        @stuff[item] ||= 0
+        @stuff[item] += count
+        self.log "Career benefit: #{item} #{qty}"
+      when Symbol
+        @stats.bump(item)
+        self.log "Career benefit: #{item} bump to #{@stats[item]}"
+      when Array
+        item.each { |i| self.benefit i }
       else
-        target[sym] += 1
-        level = target[sym]
+        raise "unexpected benefit: #{item.inspect}"
       end
-      self.log "#{sym} is trained to #{level}"
-    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
-      }
+      self
     end
 
     def log(msg = nil)
@@ -142,6 +148,7 @@ module TravellerRPG
       self
     end
 
+    # convenience
     def name
       @desc.name
     end
@@ -150,62 +157,23 @@ module TravellerRPG
       years ? @desc.age += years : @desc.age
     end
 
-    def skill_check?(skill, val = 0)
-      @skills[skill] and @skills[skill] >= val
-    end
-
-    def skill_level(sym)
-      @skills[sym] and @skills[sym].clamp(0, 4)
-    end
-
     def cash_roll(amount)
       @cash_rolls += 1
       if @cash_rolls <= 3
         @credits += amount
-        self.log "Acquired #{amount} credits from cash roll ##{@cash_rolls}"
+        self.log "Cash roll ##{@cash_rolls}: #{amount} credits"
       else
-        self.log "Ignoring cash roll ##{@cash_rolls}"
+        self.log "Cash roll ##{@cash_rolls}: Ignored"
       end
       self
     end
 
-    def benefit(item)
-      if item.is_a?(Integer)
-        if item != 0
-          self.log "Acquired #{item} credits as a career benefit"
-          @credits += item
-        end
-      else
-        self.log "Acquired #{item} as a career benefit"
-        @stuff[item] ||= 0
-        @stuff[item] += 1
-      end
-    end
-
     def report(desc: :short, stats: true, skills: true, stuff: true,
                log: false, credits: true)
       hsh = {}
-      if desc
-        hsh['Description'] = { 'Name'   => @desc.name,
-                               'Gender' => @desc.gender,
-                               'Age'    => @desc.age }
-        if desc == :long
-          hsh['Description'].merge! 'Appearance'  => @desc.appearance,
-                                    'Temperament' => @desc.temperament,
-                                    'Plot'        => @desc.plot
-        end
-      end
-      if stats
-        hsh['Characteristics'] = {
-          'Strength' => @stats.strength,
-          'Dexterity' => @stats.dexterity,
-          'Endurance' => @stats.endurance,
-          'Intelligence' => @stats.intelligence,
-          'Education' => @stats.education,
-          'Social Status' => @stats.social_status,
-        }
-      end
-      hsh['Skills'] = @skills if skills
+      hsh['Description'] = @desc.report(short: desc == :short) if desc
+      hsh['Characteristics'] = @stats.report if stats
+      hsh['Skills'] = @skills.report if skills
       hsh['Stuff'] = @stuff if stuff
       hsh['Log'] = @log if log
       if credits
@@ -217,10 +185,12 @@ module TravellerRPG
       report = []
       hsh.each { |section, tbl|
         report << "#{section}\n==="
-        report << "(none)" if tbl.empty?
-        if tbl.is_a?(Hash)
-          tbl.each { |label, val|
-            report << format("%s: %s", label.to_s.rjust(20, ' '), val.to_s)
+        if tbl.empty?
+          report << "(none)"
+        elsif tbl.is_a?(Hash)
+          width = tbl.keys.map(&:size).max + 2
+          tbl.each { |k, v|
+            report << format("%s: %s", k.to_s.rjust(width, ' '), v)
           }
         elsif tbl.is_a?(Array)
           report += tbl
@@ -231,5 +201,26 @@ module TravellerRPG
       }
       report.join("\n")
     end
+
+    protected
+
+    # gain background skills based on homeworld
+    def birth(homeworld)
+      raise "log should be empty" unless @log.empty?
+      skill_count = 3 + self.stats_dm(:education)
+      self.log format("%s was born on %s (%s)",
+                      @desc.name,
+                      homeworld.name,
+                      homeworld.traits.join(' '))
+      puts self.report(desc: :long, skills: false,
+                       stuff: false, credits: false)
+      self.log format("Education %i provides up to %i background skills",
+                      @stats.education, skill_count)
+      homeworld.choose_skills(skill_count).each { |skill|
+        self.log "Background skill: #{skill} 0"
+        @skills.provide skill
+      }
+      self
+    end
   end
 end

data/lib/traveller_rpg/generator.rb

@@ -29,7 +29,7 @@ module TravellerRPG
     end
 
     def self.gender
-      TravellerRPG.roll(dice: 1) > 3 ? 'M' : 'F'
+      TravellerRPG.roll('d6') > 3 ? 'M' : 'F'
     end
 
     def self.hair(tone: nil, body: nil, color: nil, length: nil)

data/lib/traveller_rpg/homeworld.rb

@@ -3,49 +3,68 @@ require 'traveller_rpg'
 module TravellerRPG
   class Homeworld
     TRAITS = {
-      agricultural: :animals_group,
-      asteroid: :zero_g,
-      desert: :survival,
-      fluid_oceans: :seafarer_group,
-      garden: [:animals_riding, :animals_veterinary],
-      high_technology: :computers,
-      high_population: :streetwise,
-      ice_capped: :vacc_suit,
-      industrial: :trade_group,
-      low_technology: :survival,
-      poor: :animals_group,
-      rich: :carouse,
-      water_world: :seafarer_group,
-      vacuum: :vacc_suit,
-      education: [:admin, :advocate, :art_group, :carouse, :comms,
-                  :computers, :drive_group, :engineer_group, :language_group,
-                  :medic, :physical_sciences_group, :life_sciences_group,
-                  :social_sciences_group, :space_sciences_group, :trade_group],
+      economy: {
+        agricultural: ['Animals'],
+        industrial:   ['Profession'],
+        high_tech:    ['Astrogation', 'Electronics'],
+      },
+      wealth: {
+        poor:         ['Medic',   'Melee'],
+        rich:         ['Carouse', 'Gambler', 'Profession'],
+      },
+      population: {
+        low_population:  ['Jack Of All Trades', 'Survival'],
+        high_population: ['Art', 'Streetwise'],
+      },
+      environment: {
+        desert:       ['Flyer',      'Survival'],
+        fluid_oceans: ['Navigation', 'Seafarer'],
+        garden:       ['Animals',    'Art'],
+        ice_capped:   ['Science',    'Vacc Suit'],
+        minerals:     ['Drive',      'Explosives'],
+        water_world:  ['Seafarer',   'Tactics'],
+      },
     }
     TRAIT_MIN = 3
-    TRAIT_MAX = 6
+    TRAIT_MAX = TRAITS.keys.size
 
     attr_reader :name, :traits, :skills
 
-    def initialize(name, traits = [])
+    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
-      }
+
+      if traits.empty?
+        trait_count = rand(TRAIT_MAX - TRAIT_MIN + 1) + TRAIT_MIN
+        @traits = self.class::TRAITS.keys.sample(trait_count).map { |t|
+          k = TRAITS[t].keys.sample
+          @skills += TRAITS[t][k]
+          k
+        }
+      else
+        @traits = []
+        traits.each { |type, trait|
+          @skills += TRAITS.fetch(type).fetch(trait)
+          @traits << trait
+        }
+      end
+
       @skills.uniq!
+      def @skills.choose(count)
+        s = self.dup
+        return s if s.size < count
+        Array.new(count) {
+          s.delete TravellerRPG.choose("Choose background skill:", *s)
+        }
+      end
+    end
+
+    def choose_skills(count)
+      s = @skills.dup
+      return s if s.size <= count
+      Array.new(count) {
+        s.delete TravellerRPG.choose("Choose background skill:", *s)
+      }
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: traveller_rpg
 version: !ruby/object:Gem::Version
-  version: 0.0.1.1
+  version: 0.1.0.1
 platform: ruby
 authors:
 - Rick Hull
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-12-05 00:00:00.000000000 Z
+date: 2018-01-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: buildar