coop_al 1.0.1

data/lib/coop_al/session_date_generator.rb

@@ -0,0 +1,43 @@
+module CoopAl
+  ##
+  # SessionDateGenerator
+  #
+  class SessionDateGenerator
+    def initialize(options)
+      @next_date = options[:end_date]
+      @session_frequency = options[:session_frequency]
+      @skip_frequency = options[:skip_frequency]
+      @sessions = []
+      @blackout_dates = options[:blackout_dates]
+    end
+
+    def add_session
+      @sessions.push(@next_date)
+      advance_next_date
+    end
+
+    def session(number)
+      @sessions[-number]
+    end
+
+    private
+
+    def advance_next_date
+      loop do
+        @next_date -= @session_frequency
+        break if ok?(@next_date)
+      end
+    end
+
+    def ok?(date)
+      return false if @blackout_dates.include?(date)
+      return true if @skip_frequency.nil?
+      return false if roll_dice("d#{@skip_frequency}") == 1
+      true
+    end
+
+    def blackout?(date)
+      @blackout_dates.include?(date)
+    end
+  end
+end

data/lib/coop_al/session_encounter.rb

@@ -0,0 +1,76 @@
+module CoopAl
+  ##
+  # SessionEncounter
+  #
+  class SessionEncounter
+    attr_reader :xp, :treasure
+    def initialize(name, monsters, xp, treasure, items)
+      @name = name
+      @monster_counts = monster_counts(monsters)
+      @monsters = monsters.uniq.sort
+      @xp = xp
+      @treasure = treasure
+      @items = items
+    end
+
+    def counts?
+      @xp.nonzero?
+    end
+
+    def dump(s)
+      s.puts "Encounter: #{@name}"
+      s.puts " Monsters: #{monsters_s}"
+      s.puts " XP: #{@xp}"
+      s.puts " Treasure: #{@treasure}" unless @treasure.zero?
+      s.puts " Items: #{items_s}" unless @items.empty?
+    end
+
+    private
+
+    def monster_counts(monsters)
+      results = {}
+      monsters.each do |m|
+        if results.key?(m)
+          results[m] += 1
+        else
+          results[m] = 1
+        end
+      end
+      results
+    end
+
+    def monsters_s
+      @monsters.map { |m| pluralize(m, @monster_counts[m]) }.join(', ')
+    end
+
+    def pluralize(monster, count)
+      return monster if count == 1
+      "#{monster} (#{count})"
+    end
+
+    def items_s
+      @items.map(&:to_s).join(', ')
+    end
+  end
+
+  ##
+  # Downtime
+  #
+  class Downtime
+    def xp
+      0
+    end
+
+    def treasure
+      Value.new
+    end
+
+    def counts?
+      true
+    end
+
+    def dump(s)
+      s.puts 'Downtime'
+    end
+  end
+end

data/lib/coop_al/session_log.rb

@@ -0,0 +1,51 @@
+module CoopAl
+  ##
+  # SessionLog
+  #
+  class SessionLog
+    def initialize(date_generator, options)
+      @date_generator = date_generator
+      @encounter_count = options.key?(:encounter_count) ? options[:encounter_count] : 10
+      @party_size = options.key?(:party_size) ? options[:party_size] : 6
+      @dm_name = options.key?(:dm_name) ? options[:dm_name] : 'Cameron'
+      @accumulated_xp = 0
+      @accumulated_treasure = Value.new
+      @sessions = []
+    end
+
+    def record_encounter(adventure_name, encounter_name, monsters, xp, loot)
+      ensure_active_session(adventure_name)
+      @accumulated_xp += xp / @party_size
+      @accumulated_treasure += loot.treasure_value / @party_size
+      active_session.add_encounter(SessionEncounter.new(encounter_name, monsters, xp / @party_size, loot.treasure_value / @party_size, loot.items.dup))
+    end
+
+    def record_downtime(adventure_name)
+      ensure_active_session(adventure_name)
+      active_session.add_encounter(Downtime.new)
+    end
+
+    def dump(s)
+      @sessions.each { |e| e.dump(s) }
+      s.puts "Session Count: #{@sessions.size}"
+    end
+
+    private
+
+    def ensure_active_session(adventure_name)
+      start_new_session(adventure_name) if @sessions.empty? || active_session.done?
+    end
+
+    def active_session
+      @sessions.last
+    end
+
+    def start_new_session(adventure_name)
+      @sessions.push(Session.new(session_number, @date_generator, adventure_name, @dm_name, @accumulated_xp, @accumulated_treasure.dup, @encounter_count))
+    end
+
+    def session_number
+      @sessions.size + 1
+    end
+  end
+end

data/lib/coop_al/state.rb

@@ -0,0 +1,85 @@
+module CoopAl
+  ##
+  # State
+  #
+  class State
+    attr_reader :xp, :loot, :items
+    attr_accessor :current_path
+
+    def initialize
+      @path_stack = [Path.root]
+      @xp = 0
+      @loot = Loot.empty
+      @visited_paths = []
+    end
+
+    def current_path
+      @path_stack.last
+    end
+
+    def path_depth
+      @path_stack.size
+    end
+
+    def in_downtime?
+      current_path.root?
+    end
+
+    def available_paths(library)
+      all_available_paths(library).select { |p| !@visited_paths.include?(p) }
+    end
+
+    def all_available_paths(library)
+      if path_depth == 1
+        if in_downtime?
+          library.all_entries
+        else
+          chapter = library.resolve(current_path)
+          chapter.links + downtime_if_available(chapter)
+        end
+      else
+        chapter = library.resolve(@path_stack[0])
+        library.all_entries + chapter.links + downtime_if_available(chapter)
+      end
+    end
+
+    def downtime_if_available(chapter)
+      return [Path.root] if chapter.links_to_downtime? && !in_downtime?
+      []
+    end
+
+    def apply_path(path)
+      if path_depth == 1
+        if path.root?
+          @path_stack.push(path)
+        else
+          @path_stack = [current_path + path]
+          @visited_paths << current_path
+        end
+      else
+        @path_stack = [path]
+        @visited_paths << path
+      end
+    end
+
+    def add_xp(xp)
+      @xp += xp
+    end
+
+    def add_loot(loot)
+      @loot += loot
+    end
+
+    def add_items(items)
+      @items.concat(items)
+    end
+
+    def treasure_value
+      @treasure.inject(Value.new) { |a, e| a + e.value }
+    end
+
+    def history_includes?(path)
+      @visited_paths.include?(path)
+    end
+  end
+end

data/lib/coop_al/state_reporter.rb

@@ -0,0 +1,72 @@
+module CoopAl
+  ##
+  # StateReporter
+  #
+  class StateReporter
+    def initialize(state, library, options = {})
+      @state = state
+      @library = library
+      @party_size = options.key?(:party_size) ? options[:party_size] : 6
+      @show_xp = options.key?(:show_xp) ? options[:show_xp] : true
+      @show_loot = options.key?(:show_loot) ? options[:show_loot] : true
+      @show_paths = options.key?(:show_paths) ? options[:show_paths] : true
+    end
+
+    def report(s)
+      report_xp(s) if @show_xp
+      report_loot(s) if @show_loot
+      report_paths(s) if @show_paths
+    end
+
+    private
+
+    def report_xp(s)
+      s.puts "Character Level: #{character_level} (#{character_xp} XP - #{@state.xp} XP total)"
+    end
+
+    def character_xp
+      @state.xp / @party_size
+    end
+
+    def character_level
+      Coop::XpRequirementTable.new.level_from_xp(character_xp)
+    end
+
+    def report_loot(s)
+      report_treasure(s)
+      report_items(s)
+    end
+
+    def report_treasure(s)
+      return if @state.loot.treasures.empty?
+      s.puts "Treasure: #{character_treasure} (#{@state.loot.treasure_value} total)"
+    end
+
+    def report_items(s)
+      items = @state.loot.items
+      return if items.empty?
+      s.puts 'Items:'
+      s.puts items.map { |item| "  #{item.description_with_origin}" }
+    end
+
+    def character_treasure
+      @state.loot.treasure_value / @party_size
+    end
+
+    def report_paths(s)
+      s.puts 'Paths:'
+      if available_paths.empty?
+        s.puts '  None'
+      else
+        s.puts available_paths.map { |p| "  #{p}" }.join("\n")
+      end
+    end
+
+    def available_paths
+      @state.available_paths(@library).map do |p|
+        return ['Downtime'] if p.root?
+        "#{@library.resolve(p).description} (#{p})"
+      end
+    end
+  end
+end

data/lib/coop_al/trace.rb

@@ -0,0 +1,29 @@
+require 'singleton'
+
+module CoopAl
+  ##
+  # Trace
+  #
+  class Trace
+    include Singleton
+
+    attr_writer :tracing, :stream
+
+    def initialize
+      @tracing = false
+      @stream = STDOUT
+    end
+
+    def info(s)
+      @stream.puts(s) if @tracing
+    end
+
+    def warn(s)
+      @stream.puts("[WARNING] #{s}") if @tracing
+    end
+
+    def error(s)
+      @stream.puts("[ERROR] #{s}") if @tracing
+    end
+  end
+end

data/lib/coop_al/treasure.rb

@@ -0,0 +1,21 @@
+module CoopAl
+  ##
+  # Treasure
+  #
+  class Treasure
+    attr_reader :value
+
+    def initialize(value, description = nil)
+      @value = value
+      @description = description
+    end
+
+    def to_s
+      if @description.nil?
+        "coins (#{@value})"
+      else
+        "#{@description} (#{@value})"
+      end
+    end
+  end
+end

data/lib/coop_al/treasure_tables.rb

@@ -0,0 +1,28 @@
+table :individual_treasure_cr_0_4 do
+  f(1..30) { '5d6'.cp }
+  f(31..60) { '4d6'.sp }
+  f(61..70) { '3d6'.ep }
+  f(71..95) { '3d6'.gp }
+  f(96..100) { '1d6'.pp }
+end
+
+table :individual_treasure_cr_5_10 do
+  f(1..30) { '4d6*100'.cp + '1d6*10'.ep }
+  f(31..60) { '6d6*10'.sp + '2d6*10'.gp }
+  f(61..70) { '3d6*10'.ep + '2d6*10'.gp }
+  f(71..95) { '4d6*10'.gp }
+  f(96..100) { '2d6*10'.gp + '3d6'.pp }
+end
+
+table :individual_treasure_cr_11_16 do
+  f(1..20) { '4d6*100'.sp + '1d6*100'.gp }
+  f(21..35) { '1d6*100'.ep + '1d6*100'.gp }
+  f(36..75) { '2d6*100'.gp + '1d6*10'.pp }
+  f(76..100) { '2d6*100'.gp + '2d6*10'.pp }
+end
+
+table :individual_treasure_cr_17_ do
+  f(1..15) { '2d6*1000'.ep + '8d6*100'.gp }
+  f(16..55) { '1d6*1000'.gp + '1d6*100'.pp }
+  f(56..100) { '1d6*1000'.gp + '2d6*100'.pp }
+end

data/lib/coop_al/value.rb

@@ -0,0 +1,167 @@
+module CoopAl
+  ##
+  # Value
+  #
+  class Value
+    attr_reader :platinum, :electrum, :gold, :silver, :copper
+
+    def initialize(amounts = {})
+      @platinum = amounts[:platinum] || 0
+      @electrum = amounts[:electrum] || 0
+      @gold = amounts[:gold] || 0
+      @silver = amounts[:silver] || 0
+      @copper = amounts[:copper] || 0
+      normalize
+    end
+
+    alias pp platinum
+    alias ep electrum
+    alias gp gold
+    alias sp silver
+    alias cp copper
+
+    def zero?
+      raw_value.zero?
+    end
+
+    def nonzero?
+      !zero?
+    end
+
+    def raw_value
+      @platinum * 10 + @gold + @silver / 10.0 + @copper / 100.0 + @electrum / 2.0
+    end
+
+    def normalize_from(value)
+      @platinum = 0
+      @electrum = 0
+      @gold = value.floor
+      value -= @gold
+      value *= 10
+      @silver = value.floor
+      value -= @silver
+      value *= 10
+      @copper = value.floor
+    end
+
+    def normalize
+      normalize_from(raw_value)
+    end
+
+    def +(other)
+      @platinum += other.pp
+      @electrum += other.ep
+      @gold += other.gp
+      @silver += other.sp
+      @copper += other.cp
+      normalize
+      self
+    end
+
+    def *(other)
+      normalize_from(raw_value * other)
+      self
+    end
+
+    def /(other)
+      normalize_from(raw_value / other)
+      self
+    end
+
+    def self.platinum(amount)
+      Value.new(platinum: amount)
+    end
+
+    def self.gold(amount)
+      Value.new(gold: amount)
+    end
+
+    def self.silver(amount)
+      Value.new(silver: amount)
+    end
+
+    def self.copper(amount)
+      Value.new(copper: amount)
+    end
+
+    def self.electrum(amount)
+      Value.new(electrum: amount)
+    end
+
+    def to_a
+      [@platinum, @electrum, @gold, @silver, @copper]
+    end
+
+    def to_s
+      [
+        [@platinum, 'pp'],
+        [@gold, 'gp'],
+        [@silver, 'sp'],
+        [@copper, 'cp'],
+        [@electrum, 'ep']
+      ].select { |v| v[0].nonzero? }.map { |v| "#{v[0]}#{v[1]}" }.join(', ')
+    end
+  end
+end
+
+##
+# Integer monkey-patch
+#
+class Integer
+  def platinum
+    Coop::Value.platinum(to_i)
+  end
+
+  def gold
+    Coop::Value.gold(to_i)
+  end
+
+  def silver
+    Coop::Value.silver(to_i)
+  end
+
+  def copper
+    Coop::Value.copper(to_i)
+  end
+
+  def electrum
+    Coop::Value.electrum(to_i)
+  end
+
+  alias gp gold
+  alias sp silver
+  alias cp copper
+  alias pp platinum
+  alias ep electrum
+end
+
+##
+# String monkey-patch
+#
+class String
+  def platinum
+    Coop::Value.platinum(roll_dice(self))
+  end
+
+  def gold
+    Coop::Value.gold(roll_dice(self))
+  end
+
+  def silver
+    Coop::Value.silver(roll_dice(self))
+  end
+
+  def copper
+    Coop::Value.copper(roll_dice(self))
+  end
+
+  def electrum
+    Coop::Value.electrum(roll_dice(self))
+  end
+
+  alias gp gold
+  alias sp silver
+  alias cp copper
+  alias pp platinum
+  alias ep electrum
+end

data/lib/coop_al/version.rb

@@ -0,0 +1,3 @@
+module CoopAl
+  VERSION = '1.0.1'.freeze
+end

data/lib/coop_al/xp.rb

@@ -0,0 +1,86 @@
+module CoopAl
+  ##
+  # XpRewardTable
+  #
+  class XpRewardTable
+    def initialize
+      @xp_by_cr = {
+        cr0: 10,
+        cr1_8: 25,
+        cr1_4: 50,
+        cr1_2: 100,
+        cr1: 200,
+        cr2: 450,
+        cr3: 700,
+        cr4: 1_100,
+        cr5: 1_800,
+        cr6: 2_300,
+        cr7: 2_900,
+        cr8: 3_900,
+        cr9: 5_000,
+        cr10: 5_900,
+        cr11: 7_200,
+        cr12: 8_400,
+        cr13: 10_000,
+        cr14: 11_500,
+        cr15: 13_000,
+        cr16: 15_000,
+        cr17: 18_000,
+        cr18: 20_000,
+        cr19: 22_000,
+        cr20: 25_000,
+        cr21: 33_000,
+        cr22: 41_000,
+        cr23: 50_000,
+        cr24: 62_000,
+        cr25: 75_000,
+        cr26: 90_000,
+        cr27: 105_000,
+        cr28: 120_000,
+        cr29: 135_000,
+        cr30: 155_000
+      }
+    end
+
+    def [](cr)
+      @xp_by_cr[cr]
+    end
+  end
+
+  ##
+  # XpRequirementTable
+  #
+  class XpRequirementTable
+    def initialize
+      @xp_by_level = {
+        1 => 0,
+        2 => 300,
+        3 => 900,
+        4 => 2_700,
+        5 => 6_500,
+        6 => 14_000,
+        7 => 23_000,
+        8 => 34_000,
+        9 => 48_000,
+        10 => 64_000,
+        11 => 85_000,
+        12 => 100_000,
+        13 => 120_000,
+        14 => 140_000,
+        15 => 165_000,
+        16 => 195_000,
+        17 => 225_000,
+        18 => 265_000,
+        19 => 305_000,
+        20 => 355_000
+      }
+    end
+
+    def level_from_xp(xp)
+      20.downto(1) do |i|
+        return i if xp >= @xp_by_level[i]
+      end
+      raise 'Invalid xp value (#{xp})'
+    end
+  end
+end

data/lib/coop_al.rb

@@ -0,0 +1,34 @@
+require 'tablescript'
+require 'coop_al/treasure_tables'
+require 'coop_al/trace'
+require 'coop_al/version'
+require 'coop_al/exception'
+require 'coop_al/monster_definition'
+require 'coop_al/loot_generator'
+require 'coop_al/bestiary'
+require 'coop_al/treasure'
+require 'coop_al/value'
+require 'coop_al/path'
+require 'coop_al/state'
+require 'coop_al/chapter'
+require 'coop_al/monster'
+require 'coop_al/item'
+require 'coop_al/encounter'
+require 'coop_al/random_encounter'
+require 'coop_al/library_generator'
+require 'coop_al/random_encounter_generator'
+require 'coop_al/encounter_generator'
+require 'coop_al/chapter_generator'
+require 'coop_al/path_follower'
+require 'coop_al/session_encounter'
+require 'coop_al/session_date_generator'
+require 'coop_al/session'
+require 'coop_al/session_log'
+require 'coop_al/xp'
+require 'coop_al/adventure'
+require 'coop_al/adventure_generator'
+require 'coop_al/library'
+require 'coop_al/loot'
+require 'coop_al/state_reporter'
+require 'coop_al/bestiary_populator'
+require 'coop_al/bestiary_generator'