coop_al 1.0.1

data/lib/coop_al/encounter.rb

@@ -0,0 +1,148 @@
+module CoopAl
+  ##
+  # Encounter
+  #
+  class Encounter
+    attr_reader :name
+
+    def initialize(name, parent)
+      @name = name
+      @parent = parent
+      @monsters = []
+      @xp = 0
+      @loot = Loot.empty
+      @sub_encounters = []
+    end
+
+    def adventure_name
+      @parent.adventure_name
+    end
+
+    def full_name
+      if @parent.nil?
+        @name
+      else
+        @parent.full_name + ' - ' + @name
+      end
+    end
+
+    def add_sub_encounter(encounter)
+      @sub_encounters << encounter
+    end
+
+    def add_monster(monster)
+      @monsters << monster
+    end
+
+    def add_treasure(treasure)
+      @loot.add_treasure(treasure)
+    end
+
+    def add_item(item)
+      @loot.add_item(item)
+    end
+
+    def add_xp(amount)
+      @xp += amount
+    end
+
+    def run(state, log)
+      run_sub_encounters(state, log)
+      trace unless empty?
+      log.record_encounter(adventure_name, full_name, monster_names, total_xp, total_loot)
+      state.add_xp(total_xp)
+      state.add_loot(total_loot)
+    end
+
+    def empty?
+      @monsters.empty? && @xp.zero? && @loot.empty?
+    end
+
+    private
+
+    def trace
+      Trace.instance.info("Encounter: #{full_name}")
+      Trace.instance.info("Fighting: #{all_monster_names}") unless @monsters.empty?
+      trace_xp
+      trace_loot
+    end
+
+    def trace_xp
+      Trace.instance.info("Monster XP: #{monster_xp}") unless @monsters.empty?
+      Trace.instance.info("Encounter XP: #{encounter_xp}") unless @xp.zero?
+    end
+
+    def trace_loot
+      trace_treasure
+      trace_items
+    end
+
+    def trace_treasure
+      Trace.instance.info("Encounter Treasure: #{encounter_treasure}") unless encounter_loot.treasures.empty?
+      Trace.instance.info("Monster Treasure: #{monster_treasure}") unless monster_loot.treasures.empty?
+    end
+
+    def trace_items
+      Trace.instance.info("Encounter Items: #{encounter_items}") unless encounter_loot.items.empty?
+      Trace.instance.info("Monster Items: #{monster_items}") unless monster_loot.items.empty?
+    end
+
+    def all_monster_names
+      @monsters.map(&:id).join(', ')
+    end
+
+    def total_xp
+      encounter_xp + monster_xp
+    end
+
+    def encounter_xp
+      @xp
+    end
+
+    def monster_xp
+      @monsters.inject(0) do |total, monster|
+        total + monster.xp
+      end
+    end
+
+    def total_loot
+      encounter_loot + monster_loot
+    end
+
+    def encounter_loot
+      @loot
+    end
+
+    def encounter_treasure
+      encounter_loot.treasures.map(&:to_s).join(', ')
+    end
+
+    def encounter_items
+      encounter_loot.items.map(&:to_s).join(', ')
+    end
+
+    def monster_loot
+      @monsters.inject(Loot.empty) do |loot, monster|
+        loot + monster.loot
+      end
+    end
+
+    def monster_items
+      monster_loot.items.map(&:to_s).join(', ')
+    end
+
+    def monster_treasure
+      monster_loot.treasures.map(&:to_s).join(', ')
+    end
+
+    def monster_names
+      @monsters.map(&:to_s)
+    end
+
+    def run_sub_encounters(state, log)
+      @sub_encounters.each do |encounter|
+        encounter.run(state, log)
+      end
+    end
+  end
+end

data/lib/coop_al/encounter_generator.rb

@@ -0,0 +1,67 @@
+module CoopAl
+  ##
+  # EncounterGenerator
+  #
+  class EncounterGenerator
+    def initialize(name, parent, bestiary)
+      @bestiary = bestiary
+      @encounter = Encounter.new(name, parent)
+    end
+
+    def generate_encounter(&blk)
+      instance_eval(&blk)
+      @encounter
+    end
+
+    def monsters(count, id, treasure = :default)
+      expand_count(count).times do
+        @encounter.add_monster(@bestiary.create(id, treasure, @encounter))
+      end
+    end
+
+    def monster(id, treasure = :default)
+      monsters(1, id, treasure)
+    end
+
+    def treasure(value, description = nil)
+      @encounter.add_treasure(Treasure.new(value, description))
+    end
+
+    def items(count, description)
+      @encounter.add_item(Item.new(expand_count(count), description, @encounter))
+    end
+
+    def item(description)
+      items(1, description)
+    end
+
+    def encounter(name, &blk)
+      generator = EncounterGenerator.new(name, @encounter, @bestiary)
+      @encounter.add_sub_encounter(generator.generate_encounter(&blk))
+    end
+
+    def random(name, &blk)
+      generator = RandomEncounterGenerator.new(name, @encounter, @bestiary)
+      @encounter.add_sub_encounter(generator.generate_encounter(&blk))
+    end
+
+    def xp(amount)
+      @encounter.add_xp(amount)
+    end
+
+    def npc(cr)
+      xp(XpRewardTable.new[cr])
+    end
+
+    def npcs(count, cr)
+      xp(count * XpRewardTable.new[cr])
+    end
+
+    private
+
+    def expand_count(count)
+      return roll_dice(count) if count.is_a?(String)
+      count
+    end
+  end
+end

data/lib/coop_al/exception.rb

@@ -0,0 +1,7 @@
+module CoopAl
+  ##
+  # Exception
+  #
+  class Exception < StandardError
+  end
+end

data/lib/coop_al/item.rb

@@ -0,0 +1,30 @@
+module CoopAl
+  ##
+  # Item
+  #
+  class Item
+    attr_reader :description
+
+    def initialize(count, description, encounter)
+      @count = count
+      @description = description
+      @encounter = encounter
+    end
+
+    def to_s
+      if @count == 1
+        @description
+      else
+        "#{@description} (#{@count})"
+      end
+    end
+
+    def description_with_origin
+      "#{self} (from #{origin})"
+    end
+
+    def origin
+      @encounter.full_name
+    end
+  end
+end

data/lib/coop_al/library.rb

@@ -0,0 +1,54 @@
+require 'singleton'
+
+module CoopAl
+  ##
+  # Library
+  #
+  class Library
+    include Singleton
+
+    def initialize
+      @adventures = {}
+    end
+
+    def empty?
+      @adventures.empty?
+    end
+
+    def add_adventure(adventure)
+      raise Exception, 'Duplicate adventure' if @adventures.key?(adventure.name)
+      @adventures[adventure.name] = adventure
+    end
+
+    def adventure?(name)
+      @adventures.key?(name)
+    end
+
+    def adventure(name)
+      @adventures[name]
+    end
+
+    def path?(path)
+      raise Exception, "Cannot resolve relative path (#{path})" if path.relative?
+      return false unless @adventures.key?(path.adventure)
+      @adventures[path.adventure].chapter?(path.chapter)
+    end
+
+    def resolve(path)
+      raise Exception, "Adventure (#{path.adventure}) not found" unless @adventures.key?(path.adventure)
+      @adventures[path.adventure].chapter(path.chapter)
+    end
+
+    def all_entries
+      @adventures.values.inject([]) { |a, e| a + e.all_entries }
+    end
+
+    def available_paths_from(path)
+      return all_entries if path.root?
+      current_chapter = resolve(path)
+      paths = current_chapter.links
+      paths << Path.root if current_chapter.links_to_downtime?
+      paths
+    end
+  end
+end

data/lib/coop_al/library_generator.rb

@@ -0,0 +1,4 @@
+def adventure(name, description = nil, &blk)
+  generator = CoopAl::AdventureGenerator.new(name, description, CoopAl::Bestiary.instance)
+  generator.instance_eval(&blk)
+end

data/lib/coop_al/loot.rb

@@ -0,0 +1,49 @@
+module CoopAl
+  ##
+  # Loot
+  #
+  class Loot
+    attr_reader :treasures, :items
+
+    def initialize(treasures, items)
+      @treasures = treasures
+      @items = items
+    end
+
+    def empty?
+      return false unless @treasures.empty?
+      return false unless @items.empty?
+      true
+    end
+
+    def add_treasure(treasure)
+      @treasures << treasure
+    end
+
+    def add_item(item)
+      @items << item
+    end
+
+    def +(other)
+      @treasures += other.treasures
+      @items += other.items
+      self
+    end
+
+    def treasure_value
+      @treasures.inject(Value.new) { |a, e| a + e.value }
+    end
+
+    def self.empty
+      Loot.new([], [])
+    end
+
+    def self.from_treasure(treasure)
+      Loot.new([treasure], [])
+    end
+
+    def self.from_item(item)
+      Loot.new([], [item])
+    end
+  end
+end

data/lib/coop_al/loot_generator.rb

@@ -0,0 +1,42 @@
+module CoopAl
+  ##
+  # LootGenerator
+  #
+  class LootGenerator
+    def initialize
+    end
+
+    def generate(cr, treasure)
+      return Loot.empty if treasure == :no_treasure
+      return generate_individual(cr) if treasure == :individual
+      generate_hoard(cr)
+    end
+
+    private
+
+    def generate_individual(cr)
+      table_name = individual_treasure_table_by_cr(cr)
+      treasure = Treasure.new(roll_on(table_name))
+      Loot.from_treasure(treasure)
+    end
+
+    def individual_treasure_table_by_cr(cr)
+      value = cr_value(cr)
+      return :individual_treasure_cr_0_4 if value <= 4
+      return :individual_treasure_cr_5_10 if value <= 10
+      return :individual_treasure_cr_11_16 if value <= 16
+      :individual_treasure_cr_17_
+    end
+
+    def cr_value(cr)
+      return 0.125 if cr == :cr1_8
+      return 0.25 if cr == :cr1_4
+      return 0.5 if cr == :cr1_2
+      cr[2..-1].to_i
+    end
+
+    def generate_hoard(_cr)
+      raise 'Hoard loot not implemented'
+    end
+  end
+end

data/lib/coop_al/monster.rb

@@ -0,0 +1,19 @@
+module CoopAl
+  ##
+  # Monster
+  #
+  class Monster
+    attr_reader :id, :xp, :loot, :encounter
+
+    def initialize(id, xp, loot, encounter)
+      @id = id
+      @xp = xp
+      @loot = loot
+      @encounter = encounter
+    end
+
+    def to_s
+      @id.to_s
+    end
+  end
+end

data/lib/coop_al/monster_definition.rb

@@ -0,0 +1,18 @@
+module CoopAl
+  ##
+  # MonsterDefinition
+  #
+  class MonsterDefinition
+    attr_reader :id, :cr, :treasure
+
+    def initialize(id, cr, treasure)
+      @id = id
+      @cr = cr
+      @treasure = treasure
+    end
+
+    def ==(other)
+      @id == other.id && @cr == other.cr && @treasure == other.treasure
+    end
+  end
+end

data/lib/coop_al/path.rb

@@ -0,0 +1,65 @@
+module CoopAl
+  ##
+  # Path
+  #
+  class Path
+    attr_reader :adventure, :chapter
+
+    def initialize(adventure, chapter)
+      @adventure = adventure
+      @chapter = chapter
+    end
+
+    def root?
+      @adventure.nil? && @chapter.nil?
+    end
+
+    def relative?
+      @adventure.nil? && !@chapter.nil?
+    end
+
+    def absolute?
+      !relative?
+    end
+
+    def self.absolute(adventure, chapter)
+      Path.new(adventure, chapter)
+    end
+
+    def self.relative(chapter)
+      Path.new(nil, chapter)
+    end
+
+    def self.root
+      Path.new(nil, nil)
+    end
+
+    def self.parse(path)
+      tokens = path.split('/').map(&:to_sym)
+      raise "Invalid path #{path}" if tokens.count > 2
+      return absolute(tokens[0], tokens[1]) if tokens.count == 2
+      return root if tokens[0] == :downtime
+      relative(tokens[0])
+    end
+
+    def ==(other)
+      to_s == other.to_s
+    end
+
+    def +(other)
+      local_path = other.is_a?(Path) ? other : Path.parse(other)
+      return local_path if local_path.absolute?
+      raise 'Cannot add two relative paths' if relative?
+      Path.absolute(@adventure, other.chapter)
+    end
+
+    def to_s
+      adventure_s + @chapter.to_s
+    end
+
+    def adventure_s
+      return @adventure.to_s + '/' if absolute?
+      ''
+    end
+  end
+end

data/lib/coop_al/path_follower.rb

@@ -0,0 +1,34 @@
+module CoopAl
+  ##
+  # PathFollower
+  #
+  class PathFollower
+    attr_reader :state
+
+    def initialize(library, starting_state)
+      @library = library
+      @state = starting_state
+    end
+
+    def follow(paths, log)
+      paths.each do |path|
+        follow_path(path, log)
+      end
+      @state
+    end
+
+    private
+
+    def follow_path(path, log)
+      if path.root?
+        log.record_downtime(@library.resolve(@state.current_path).adventure_name)
+        @state.apply_path(path)
+      else
+        raise Exception, "#{path} not a valid next path" unless @library.path?(@state.current_path + path)
+        raise Exception, "Cannot repeat path (#{path})" if @state.history_includes?(@state.current_path + path)
+        @state.apply_path(path)
+        @library.resolve(@state.current_path).follow(@state, log)
+      end
+    end
+  end
+end

data/lib/coop_al/random_encounter.rb

@@ -0,0 +1,30 @@
+module CoopAl
+  ##
+  # RandomEncounter
+  #
+  class RandomEncounter
+    def initialize(name, parent)
+      @name = name
+      @parent = parent
+      @entries = []
+    end
+
+    def add_entry(entry)
+      @entries << entry
+    end
+
+    def set_entry(roll, entry)
+      @entries[roll - 1] = entry
+    end
+
+    def set_range(range, entry)
+      range.each do |i|
+        set_entry(i, entry)
+      end
+    end
+
+    def run(state, log)
+      @entries[roll_dice("d#{@entries.count}") - 1].run(state, log)
+    end
+  end
+end

data/lib/coop_al/random_encounter_generator.rb

@@ -0,0 +1,37 @@
+module CoopAl
+  ##
+  # RandomEncounterGenerator
+  #
+  class RandomEncounterGenerator
+    def initialize(name, parent, bestiary)
+      @name = name
+      @parent = parent
+      @bestiary = bestiary
+      @encounter = RandomEncounter.new(name, parent)
+    end
+
+    def generate_encounter(&blk)
+      instance_eval(&blk)
+      @encounter
+    end
+
+    def fixed(*args, &blk)
+      generator = EncounterGenerator.new(@name, @parent, @bestiary)
+      entry = generator.generate_encounter(&blk)
+      if args.empty?
+        @encounter.add_entry(entry)
+      else
+        roll = args.shift
+        if roll.is_a?(Integer)
+          @encounter.set_entry(roll, entry)
+        elsif roll.is_a?(Range)
+          @encounter.set_range(roll, entry)
+        else
+          raise "Inappropriate roll descriptor (#{roll})"
+        end
+      end
+    end
+
+    alias f fixed
+  end
+end

data/lib/coop_al/session.rb

@@ -0,0 +1,55 @@
+module CoopAl
+  ##
+  # Session
+  #
+  class Session
+    def initialize(number, date_generator, adventure_name, dm_name, starting_xp, starting_treasure, encounter_count)
+      @number = number
+      @date_generator = date_generator
+      @adventure_name = adventure_name
+      @dm_name = dm_name
+      @starting_xp = starting_xp
+      @starting_treasure = starting_treasure
+      @encounter_count = encounter_count
+      @encounters = []
+
+      @date_generator.add_session
+    end
+
+    def add_encounter(encounter)
+      @encounters << encounter
+    end
+
+    def done?
+      @encounters.count { |e| e.counts? } == @encounter_count
+    end
+
+    def dump(s)
+      s.puts "Adventure: #{@adventure_name}"
+      s.puts "Session ##{@number}: #{@date_generator.session(@number)}"
+      s.puts "DM: #{@dm_name}"
+      s.puts "Starting XP: #{@starting_xp} (level #{level(@starting_xp)})"
+      s.puts "XP Earned: #{xp_earned}"
+      s.puts "XP Total: #{@starting_xp + xp_earned} (level #{level(@starting_xp + xp_earned)})"
+      s.puts "Starting Treasure: #{@starting_treasure}"
+      s.puts "Treasure +/-: #{treasure_earned}"
+      s.puts "Treasure Total: #{@starting_treasure + treasure_earned}"
+      @encounters.each { |e| e.dump(s) if e.counts? }
+      s.puts
+    end
+
+    private
+
+    def xp_earned
+      @encounters.inject(0) { |a, e| a + e.xp }
+    end
+
+    def treasure_earned
+      @encounters.inject(Value.new) { |a, e| a + e.treasure }
+    end
+
+    def level(xp)
+      XpRequirementTable.new.level_from_xp(xp)
+    end
+  end
+end