dd-next-encounters 1.0.0 → 1.0.1

data/lib/data/xp_difficulty_table.rb

@@ -0,0 +1,23 @@
+module XpDifficultyTable
+	 XP_DIFFICULTY_TABLE = 
+{1=>{:easy=>25, :medium=>50, :hard=>75, :deadly=>100},
+ 2=>{:easy=>50, :medium=>100, :hard=>150, :deadly=>200},
+ 3=>{:easy=>75, :medium=>150, :hard=>225, :deadly=>400},
+ 4=>{:easy=>125, :medium=>250, :hard=>375, :deadly=>500},
+ 5=>{:easy=>250, :medium=>500, :hard=>750, :deadly=>1100},
+ 6=>{:easy=>300, :medium=>600, :hard=>900, :deadly=>1400},
+ 7=>{:easy=>350, :medium=>750, :hard=>1100, :deadly=>1700},
+ 8=>{:easy=>450, :medium=>900, :hard=>1400, :deadly=>2100},
+ 9=>{:easy=>550, :medium=>1100, :hard=>1600, :deadly=>2400},
+ 10=>{:easy=>600, :medium=>1200, :hard=>1900, :deadly=>2800},
+ 11=>{:easy=>800, :medium=>1600, :hard=>2400, :deadly=>3600},
+ 12=>{:easy=>1000, :medium=>2000, :hard=>3000, :deadly=>4500},
+ 13=>{:easy=>1100, :medium=>2200, :hard=>3400, :deadly=>5100},
+ 14=>{:easy=>1250, :medium=>2500, :hard=>3800, :deadly=>5700},
+ 15=>{:easy=>1400, :medium=>2800, :hard=>4300, :deadly=>6400},
+ 16=>{:easy=>1600, :medium=>3200, :hard=>4800, :deadly=>7200},
+ 17=>{:easy=>2000, :medium=>3900, :hard=>5900, :deadly=>8800},
+ 18=>{:easy=>2100, :medium=>4200, :hard=>6300, :deadly=>9500},
+ 19=>{:easy=>2400, :medium=>4900, :hard=>7300, :deadly=>10900},
+ 20=>{:easy=>2800, :medium=>5700, :hard=>8500, :deadly=>12700}}
+end

data/lib/encounters/encounter.rb

@@ -0,0 +1,42 @@
+class Encounter
+
+  def initialize( party_xp_level )
+    @monsters = []
+    @party_xp_level = party_xp_level
+  end
+
+  # Return true or false. Monster added or not
+  def add_monster_if_possible( monster )
+    if can_add_monster?( monster )
+      @monsters << monster
+      return true
+    end
+    false
+  end
+
+  def can_add_monster?( monster )
+    encounter_value( @monsters + [ monster ] ) <= @party_xp_level
+  end
+
+  def to_s
+    @monsters.group_by {|i| i.key}.map{ |_, v| "#{v.count} #{v.first.name}"}.join( ', ' )
+  end
+
+  private
+
+  def encounter_value( encounter )
+    encounter.map{ |e| e.xp_value }.reduce(&:+) * get_encounter_multiplier( encounter )
+  end
+
+  def get_encounter_multiplier( encounter )
+    count = encounter.count
+    mul = 1
+    mul = 1.5 if count >= 2
+    mul = 2 if count >= 3
+    mul = 2.5 if count >= 7
+    mul = 3 if count >= 11
+    mul = 4 if count >= 15
+    mul
+  end
+
+end

data/lib/encounters/lair.rb

@@ -0,0 +1,86 @@
+require_relative 'encounter'
+require_relative '../data/xp_difficulty_table'
+
+class Lair
+
+  include XpDifficultyTable
+
+  AVAILABLE_ENCOUNTER_LEVEL=[ :easy, :medium, :hard, :deadly ]
+
+  def initialize( *encounters_types )
+    @monster_manual = MonstersManual.new
+    @monsters = nil
+    @xp_difficulty_table = XP_DIFFICULTY_TABLE
+    @encounters_types = encounters_types
+    @encounters={}
+  end
+
+  def read_manuals
+    read_monster_manual
+  end
+
+  def groups
+    @monster_manual.validate_loaded
+    @monster_manual.groups.keys
+  end
+
+  # encounter_level : :easy, :medium, :hard, :deadly
+  def get_encounter( encounter_level, *hero_level )
+    @monster_manual.validate_loaded
+
+    raise "Bad encounter level : #{encounter_level.inspect}. Available encounter level : #{AVAILABLE_ENCOUNTER_LEVEL.inspect}" unless AVAILABLE_ENCOUNTER_LEVEL.include?( encounter_level )
+    party_xp_level = hero_level.map{ |hl| @xp_difficulty_table[hl][encounter_level] }.reduce(&:+)
+
+    encounter = Encounter.new( party_xp_level )
+
+    # Choose a random encounter type
+    encounter_type = @encounters_types.sample
+    bosses = @encounters[encounter_type][:bosses]
+    troops = @encounters[encounter_type][:troops]
+
+    # Choose a random boss
+    boss = bosses.sample if !bosses.empty? && rand( 1 .. 2 ) == 1
+    encounter.add_monster_if_possible( boss ) if boss
+
+    # Choose a random monster
+    monster = get_corresponding_monsters( troops, party_xp_level ).sample
+
+    loop do
+      break unless encounter.add_monster_if_possible( monster )
+    end
+
+    encounter
+  end
+
+  private
+
+  def get_corresponding_monsters( troops, party_xp_level)
+    troops.map{ |m| m if m.xp_value < party_xp_level }.compact
+  end
+
+  def read_monster_manual
+    @monster_manual.load
+    validate_encounters_types
+
+    @monsters = @monster_manual.select( sources: [ 'Basic Rules', 'Monster Manual' ] )
+
+    @encounters_types.each do |encounter_type|
+      @encounters[encounter_type] ||= { troops: [], bosses: [] }
+      @encounters[encounter_type][:troops] = @monster_manual.groups[encounter_type]&.troops
+      @encounters[encounter_type][:bosses] = @monster_manual.groups[encounter_type]&.bosses
+    end
+  end
+
+  private
+
+  def validate_encounters_types
+    @encounters_types.each do |encounter_type|
+      unless @monster_manual.groups.include?( encounter_type )
+        raise "Bad lair type : #{encounter_type.inspect}" + ". Available lairs types : #{@monster_manual.groups.keys}"
+      end
+    end
+    @encounters_types =  @monster_manual.groups.keys if @encounters_types.empty?
+  end
+
+end
+

data/lib/monsters/monster.rb

@@ -0,0 +1,36 @@
+require 'json'
+
+class Object
+  private
+
+  def set_instance_variables(binding, *variables)
+    variables.each do |var|
+      instance_variable_set("@#{var}", eval(var.to_s, binding))
+    end
+  end
+
+end
+
+class Monster
+
+  attr_reader :challenge, :name, :type, :source, :key, :groups
+  attr_accessor :xp_value, :boss
+
+  def initialize( challenge, name, type, source )
+    set_instance_variables(binding, *local_variables)
+    @key = @name.gsub( /[ -]/, '_' ).gsub( 'é', 'e' ).delete( "()'’“”" ).downcase.to_sym
+    @groups = []
+    @accepted_bosses = []
+    @boss = false
+  end
+
+  def add_groups( groups )
+    @groups ||= []
+    @groups += groups
+  end
+
+  def to_hash
+    { key: @key, challenge: @challenge, name: @name, type: @type, source: @source, xp_value: @xp_value, boss: @boss, groups: @groups }
+  end
+
+end

data/lib/monsters/monsters_group.rb

@@ -0,0 +1,30 @@
+class MonstersGroup
+
+  attr_reader :troops, :bosses
+
+  def initialize
+    @troops = []
+    @bosses = []
+    # This mean that this group is inferior to the listed groups. They wont accept
+    @groups_inferiority = []
+  end
+
+  def add_monster( monster )
+    @troops << monster unless monster.boss
+    @bosses << monster if monster.boss
+  end
+
+  # def to_s
+  #   { troops: @troops.map{ |m| m.key }, bosses: @bosses.map{ |m| m.key } }
+  # end
+
+  def to_hash
+    { troops: @troops.map{ |m| m.key }, bosses: @bosses.map{ |m| m.key } }
+  end
+
+  def from_hash( monsters, hash )
+    @troops = hash[:troops].map{ |tk| monsters[tk] }
+    @bosses = hash[:bosses].map{ |tk| monsters[tk] }
+  end
+
+end

data/lib/monsters/monsters_manual.rb

@@ -0,0 +1,107 @@
+require 'json'
+require 'pp'
+require_relative 'monster'
+require_relative 'monsters_group'
+require_relative '../../lib/data/monsters_manual_content'
+
+class MonstersManual
+
+  attr_reader :monsters, :groups
+
+  include MonstersManualContent
+
+  def initialize
+    @monsters = {}
+    @sources = {}
+    @challenges = {}
+    @types = {}
+    @groups = {}
+  end
+
+  def load
+    @monsters = {}
+    MONSTERS_MANUAL_CONTENT[:monsters].each do |m|
+      monster = Monster.new( m[:challenge], m[:name], m[:type], m[:source] )
+      monster.xp_value = m[:xp_value]
+      monster.boss = m[:boss]
+      monster.add_groups( m[:groups] )
+      @monsters[ monster.key ] = monster
+    end
+
+    @sources = MONSTERS_MANUAL_CONTENT[:sources]
+    @challenges = MONSTERS_MANUAL_CONTENT[:challenges]
+    @types = MONSTERS_MANUAL_CONTENT[:types]
+
+    MONSTERS_MANUAL_CONTENT[:groups].each do |k, group_hash|
+      group = MonstersGroup.new
+      group.from_hash( @monsters, group_hash )
+      @groups[k] = group
+    end
+  end
+
+  def save( filename )
+    monster_manual = {
+        monsters: @monsters.map{ |_, m| m.to_hash },
+        sources: @sources,
+        challenges: @challenges,
+        types: @types,
+        groups: Hash[ @groups.map{ |k, g| [ k, g.to_hash ] } ]
+    }
+    File.open( filename, 'w' ) do |f|
+      f.puts 'module MonstersManualContent'
+      f.puts "\t MONSTERS_MANUAL_CONTENT = "
+      PP.pp(monster_manual,f)
+      f.puts 'end'
+    end
+  end
+
+  def sources
+    @sources.keys.sort
+  end
+
+  def challenges
+    @challenges.keys.sort
+  end
+
+  def types
+    @types.keys.sort
+  end
+
+  def select( sources: :all, types: :all, min_challenge: :none, max_challenge: :none )
+    validate_loaded
+
+    sources_ids = ( sources == :all ? @sources.values.flatten : sources.map{ |s| @sources[s] }.flatten )
+    types_ids = ( types == :all ? @types.values.flatten : types.map{ |t| @types[t] }.flatten )
+
+    challenges = @challenges.keys
+    challenges.reject!{ |c| c > max_challenge } if max_challenge != :none
+    challenges.reject!{ |c| c < min_challenge } if min_challenge != :none
+    challenges_ids = challenges.map{ |c| @challenges[ c ] }.flatten
+
+    monsters_ids = sources_ids & types_ids & challenges_ids
+    monsters_ids.map{ |m| @monsters[m] }
+  end
+
+  def add_monster( monster )
+    @monsters[monster.key]=monster
+
+    @sources[monster.source] ||= []
+    @sources[monster.source] << monster.key
+
+    @challenges[monster.challenge] ||= []
+    @challenges[monster.challenge] << monster.key
+
+    @types[monster.type] ||= []
+    @types[monster.type] << monster.key
+
+    monster.groups.each do |group|
+      @groups[group] ||= MonstersGroup.new
+      @groups[group].add_monster( monster )
+    end
+  end
+
+  def validate_loaded
+    raise 'Monster manual not loadad' if @monsters.empty?
+  end
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dd-next-encounters
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.1
 platform: ruby
 authors:
 - Cédric Zuger
@@ -30,7 +30,15 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- README.md
+- lib/data/monsters_manual_content.rb
+- lib/data/xp_difficulty_table.rb
 - lib/dd-next-encounters.rb
+- lib/encounters/encounter.rb
+- lib/encounters/lair.rb
+- lib/monsters/monster.rb
+- lib/monsters/monsters_group.rb
+- lib/monsters/monsters_manual.rb
 homepage: https://github.com/czuger/dd-next-encounters
 licenses:
 - MIT