pfrpg_core 0.0.2 → 0.1.1

data/lib/pfrpg_core/skills.rb

@@ -0,0 +1,141 @@
+require 'pfrpg_skills'
+
+module PfrpgCore
+  class PrettySkill
+    include PfrpgCore::Filterable
+    attr_reader :name, :class_skill, :stat_bonus, :ac_penalty,
+                :misc_bonus, :total_bonus, :trained_rank, :attribute,
+                :filters, :filter_str
+
+    def initialize(skill, character, skill_filters)
+      @class_skill   = is_class_skill?(skill, character)
+      @ac_penalty    = calculate_ac_penalty(skill, character)
+      @name          = skill[:skill].description
+      if skill[:char_skill]
+        @trained_rank  = skill[:char_skill]['trained_rank']
+      else
+        @trained_rank = 0
+      end
+      @stat_bonus    = calculate_attribute_bonus(skill, character)
+      @misc_bonus    = calculate_misc_bonus(skill, character)
+      @attribute     = skill[:skill].attribute
+      @total_bonus   = total_bonuses
+      @filters       = skill_filters
+      @filter_str    = []
+      apply_filters
+    end
+
+    def misc_bonus=(misc)
+      @misc_bonus=misc
+    end
+
+    def as_json(options={})
+      {
+          :class_skill  => @class_skill,
+          :ac_penalty   => @ac_penalty,
+          :name         => @name,
+          :trained_rank => @trained_rank,
+          :stat_bonus   => @stat_bonus,
+          :misc_bonus   => @misc_bonus,
+          :total_bonus  => @total_bonus,
+          :attribute    => @attribute
+      }
+    end
+
+    def is_class_skill?(skill, character)
+      found = character.levels.any? do |l|
+        l.heroclass.skills.find { |x| x.to_s == skill[:skill].to_s }
+      end
+      found ||= class_skill_bonuses(character).find do |x|
+          if x
+            x.downcase == skill[:skill].description.downcase
+          else
+            false
+          end
+      end
+      return (found != nil)
+    end
+
+    def class_skill_bonuses(character)
+      bonuses = character.get_bonus("class_skill")
+      return bonuses || []
+    end
+
+    def calculate_ac_penalty(skill, character)
+      ac_penalty = 0
+      if skill[:skill].ac_penalty?
+        ac_penalty = character.get_ac_penalty
+      end
+      ac_penalty
+    end
+
+    def calculate_attribute_bonus(skill, character)
+      attribute = skill[:skill].attribute
+      character.attributes.send("#{attribute}_mod") || 0
+    end
+
+    def total_bonuses
+      total = @misc_bonus + @stat_bonus - @ac_penalty + @trained_rank
+      total += 3 if (@class_skill && @trained_rank > 0)
+      total
+    end
+
+    def calculate_misc_bonus(skill, character)
+      if skill[:skill].respond_to? "bonus_str"
+        return character.get_bonus(skill[:skill].bonus_str).to_i
+      else
+        return character.get_bonus(skill[:skill].description).to_i
+      end
+    end
+
+  end
+
+  class Skills
+    attr_reader :skills, :max_training_level
+    def initialize(character)
+      @character = character
+      @bonuses   = character.bonuses
+      @attributes= character.attributes
+      @skillz    = character.base_skills || []
+      @max_training_level = character.hit_die
+      @skills    = @skillz.map { |x| PrettySkill.new(x, @character, skill_filters) }
+    end
+
+    def skill_filters
+      [
+          Filters::SkillFocusMod.new(@character),
+          Filters::ProwessMod.new(@character)
+      ]
+    end
+
+    def as_json(options={})
+      skillz = {}
+      @skills.each do |s|
+        skillz[s.name] = s
+      end
+      skillz
+    end
+
+    def current_trained_ranks(name)
+      begin
+        get_skill(name).trained_rank
+      rescue Exception => e
+        return 0
+      end
+    end
+
+    def get_skill(name)
+      @skills.find { |x| x.name.downcase[name.downcase] }
+    end
+
+    def skills_per_level(heroclass, favored_bonus)
+      base = heroclass.skills_per_level
+      i = @attributes.int_mod
+      r = ((@character.race.name == 'Human') && 1) || 0 # +1 for Human
+      f = ((favored_bonus == 'skill') && 1) || 0 # +1 for favored
+      # puts "base #{base} + i #{i} + r #{r} + f #{f} = #{base + i + r + f}"
+      return base + i + r + f
+    end
+
+  end
+end

data/lib/pfrpg_core/specializer.rb

@@ -0,0 +1,48 @@
+module PfrpgCore
+  class Specializer
+    attr_reader :character, :proficient_types
+    def initialize(character)
+      @character = character
+      @proficient_types = proficiency_strings(character)
+    end
+
+    def proficiency_strings(character)
+      proficient_items = { :types => [], :singles => [] }
+      prof_feats = character.feats.select { |x| x.name['Proficiency'] }
+      prof_feats.each do |feat|
+        proficient_items[:types] << parse_types(feat)
+        proficient_items[:singles] << parse_singles(feat)
+      end
+      proficient_items[:types] = proficient_items[:types].flatten
+      proficient_items[:singles] = proficient_items[:singles].flatten
+      proficient_items
+    end
+
+    def parse_types(feat)
+      if feat.effects && feat.effects['TYPE']
+        read_str(feat.effects)
+      end
+    end
+
+    def parse_singles(feat)
+      if feat.effects && feat.effects['SINGLE']
+        feat.special
+      elsif feat.effects && feat.effects['GROUP']
+        read_str(feat.effects)
+      end
+    end
+
+    def read_str(str)
+      str.split(':')[1].split(';')[0]
+    end
+
+    def is_proficient_in_weapon?(weapon)
+      return true if weapon.weapon_type == 'natural'
+      proficient_types[:types].include?(weapon.weapon_type) || proficient_types[:singles].include?(weapon.name)
+    end
+
+    def is_proficient_in_armor?(armor)
+      proficient_types[:types].include? armor.weight_class
+    end
+  end
+end

data/lib/pfrpg_core/spell.rb

@@ -0,0 +1,37 @@
+module PfrpgCore
+  class Spell
+    attr_reader :id, :name, :spell_level, :effect, :targets, :duration,
+                :range, :saving_throw, :spell_resistance, :sorcerer_level,
+                :description
+
+    def initialize(array)
+      @id = array[0]
+      @name = array[1]
+      @spell_level = array[2]
+      @effect = array[3]
+      @targets = array[4]
+      @duration = array[5]
+      @range = array[6]
+      @saving_throw = array[7]
+      @spell_resistance = array[8]
+      @sorcerer_level = array[9]
+      @description = array[10]
+    end
+
+    def as_json(options={})
+      {
+        :id => id,
+        :name => name,
+        :spell_level => spell_level,
+        :effect => effect,
+        :targets => targets,
+        :duration => duration,
+        :range => range,
+        :saving_throw => saving_throw,
+        :spell_resistance => spell_resistance,
+        :sorcerer_level => sorcerer_level,
+        :description => description
+      }
+    end
+  end
+end

data/lib/pfrpg_core/spell_books.rb

@@ -0,0 +1,36 @@
+module PfrpgCore
+  class SpellBooks
+
+    class InvalidClassException < Exception; end
+    class SpellNotFoundException < Exception; end
+    class TooManySpellsException < Exception; end
+    class InvalidSpellException < Exception; end
+    class TooLowAttributeException < Exception; end
+
+    attr_reader :sorcerer, :cleric, :wizard, :druid, :paladin,
+                :ranger, :bard
+    def initialize(character)
+      l = character.latest_levels
+      @wizard = character.spells_per_level('Wizard', l)
+      @cleric = character.spells_per_level('Cleric', l)
+      @druid = character.spells_per_level('Druid', l)
+      @paladin = character.spells_per_level('Paladin', l)
+      @ranger = character.spells_per_level('Ranger', l)
+      @bard = character.spells_per_level('Bard', l)
+      @sorcerer = character.known_sorcerer_spells
+    end
+
+    def as_json(options={})
+      {
+          :sorcerer_spells  => @sorcerer,
+          :Cleric    => @cleric,
+          :Wizard    => @wizard,
+          :Druid     => @druid,
+          :Paladin   => @paladin,
+          :Ranger    => @ranger,
+          :Bard      => @bard
+      }
+    end
+
+  end
+end

data/lib/pfrpg_core/spells_per_level.rb

@@ -0,0 +1,53 @@
+module PfrpgCore
+  class SpellsPerLevel
+    def initialize(character)
+      @character = character
+      @spells    = {}
+    end
+
+    def get_sorcerer_spells
+      @character.known_sorcerer_spells
+    end
+
+    def get_cleric
+      []
+    end
+
+    def get_sorcerer
+      []
+    end
+
+    def get_wizard
+      []
+    end
+
+    def get_druid
+      []
+    end
+
+    def get_ranger
+      []
+    end
+
+    def get_bard
+      []
+    end
+
+    def get_paladin
+      []
+    end
+
+    def as_json(options={})
+      l = @character.latest_levels
+      {
+          :sorcerer_spells  => get_sorcerer_spells,
+          :Cleric    => @character.spells_per_level('Cleric', l),
+          :Wizard    => @character.spells_per_level('Wizard', l),
+          :Druid     => @character.spells_per_level('Druid', l),
+          :Paladin   => @character.spells_per_level('Paladin', l),
+          :Ranger    => @character.spells_per_level('Ranger', l),
+          :Bard      => @character.spells_per_level('Bard', l)
+      }
+    end
+  end
+end

data/lib/pfrpg_core/version.rb

@@ -1,3 +1,3 @@
 module PfrpgCore
-  VERSION = "0.0.2"
+  VERSION = "0.1.1"
 end

data/lib/pfrpg_core/weapon_training_calculator.rb

@@ -0,0 +1,36 @@
+module PfrpgCore
+  class WeaponTrainingCalculator
+    attr_reader :character, :trained_types
+    def initialize(character)
+      @character = character
+      @trained_types = gen_trained_types
+    end
+
+    def gen_trained_types
+      types = []
+      trains = character.class_features.select { |x| x.type['WeaponTraining'] }
+      trains.sort! { |x,y| x.created < y.created }
+      trains.each do |train|
+        types << train.ability_name
+      end
+      types
+    end
+
+    def feature_trained?(weapon, feature)
+      PfrpgTables::Tables::Weapons.weapon_training_members(feature.ability_name).include? weapon.get_base_name
+    end
+
+    def trained_value(weapon, feature)
+      return 0 unless feature_trained?(weapon, feature)
+      bonus = trained_types.size
+      weapon_name = weapon.get_base_name
+      trained_types.each do |t|
+        if PfrpgTables::Tables::Weapons.weapon_training_members(t).include? weapon_name
+          return bonus
+        end
+        bonus -= 1
+      end
+      return 0
+    end
+  end
+end

data/lib/pfrpg_core.rb

@@ -1,11 +1,22 @@
 module PfrpgCore
 end
 
-require 'pfrpg_core/effect'
+require 'pfrpg_utility'
+
+require 'pfrpg_core/filters/filter'
+require 'pfrpg_core/macros/macro'
+require 'pfrpg_core/attributes'
+require 'pfrpg_core/bonus'
+require 'pfrpg_core/derived'
+require 'pfrpg_core/character'
+require 'pfrpg_core/feature_duplicator'
 require 'pfrpg_core/effect_processor'
+require 'pfrpg_core/feat_finder'
+require 'pfrpg_core/filterable'
 require 'pfrpg_core/math_helper'
 require 'pfrpg_core/null_object'
+require 'pfrpg_core/weapon_training_calculator'
 
 Dir[File.expand_path(File.join(File.dirname(File.absolute_path(__FILE__)), 'pfrpg_core/')) + "/**/*.rb"].each do |file|
   require file
-end
+end

data/test/alignment_test.rb

@@ -0,0 +1,30 @@
+require 'minitest/autorun'
+require 'pfrpg_core'
+require 'pfrpg_utility'
+
+class AlignmentTest < Minitest::Test
+
+  def test_abbreviation_parse
+    assert PfrpgUtility::Alignment.parse("CN") == 'Chaotic Neutral'
+    assert PfrpgUtility::Alignment.parse("CNP") == "CNP"
+  end
+
+  def test_unlawful
+    assert PfrpgUtility::Alignment.never_lawful.include? 'True Neutral'
+    assert !(PfrpgUtility::Alignment.never_lawful.include? 'Lawful Good')
+  end
+
+  def test_evil
+    assert PfrpgUtility::Alignment.any_evil.include? 'Lawful Evil'
+    assert !(PfrpgUtility::Alignment.any_evil.include? 'Lawful Good')
+  end
+
+  def test_any
+    assert PfrpgUtility::Alignment.any_evil.include? 'Lawful Evil'
+  end
+
+  def test_obj
+    assert PfrpgUtility::Alignment.new('CN').alignment == 'Chaotic Neutral'
+  end
+
+end

data/test/attributes_test.rb

@@ -0,0 +1,50 @@
+require 'minitest/autorun'
+require 'pfrpg_core'
+require_relative './test_helper'
+
+class AttributesTest < Minitest::Test
+  include TestHelper
+
+  def test_max_dex_bonus
+    b = basic_attributes
+    b[:max_dex] = 4
+    b[:raw_dex] = 20
+    attributes = PfrpgCore::Attributes.new(b, PfrpgCore::Bonuses.new)
+    assert attributes.dex_mod == 4
+  end
+
+  def test_max_dex_bonus
+    b = basic_attributes
+    b[:max_dex] = 6
+    b[:raw_dex] = 20
+    attributes = PfrpgCore::Attributes.new(b, PfrpgCore::Bonuses.new)
+    assert attributes.dex_mod == 5
+  end
+
+  def test_negative_bonus
+    b = basic_attributes
+    b[:raw_str] = 8
+    attributes = PfrpgCore::Attributes.new(b, PfrpgCore::Bonuses.new)
+    assert attributes.str_mod == -1
+  end
+
+  def test_positive_bonus
+    b = basic_attributes
+    b[:raw_wis] = 12
+    attributes = PfrpgCore::Attributes.new(b, PfrpgCore::Bonuses.new)
+    assert attributes.wis_mod == 1
+  end
+
+  def test_zero_bonus
+    attributes = PfrpgCore::Attributes.new(basic_attributes, PfrpgCore::Bonuses.new)
+    assert attributes.cha_mod == 0
+  end
+
+  def test_additional_bonus
+    bonuses = PfrpgCore::Bonuses.new
+    bonuses.plus('con', 4)
+    attributes = PfrpgCore::Attributes.new(basic_attributes, bonuses)
+    assert attributes.con_mod == 2
+  end
+
+end

data/test/bonus_test.rb

@@ -0,0 +1,29 @@
+require 'minitest/autorun'
+require 'pfrpg_core'
+
+class BonusTest < Minitest::Test
+
+  class LilBonus
+    attr_reader :map
+    def initialize(map)
+      @map = map
+    end
+
+    def get(str)
+      return map[str]
+    end
+  end
+
+  class BonusTester
+    include PfrpgCore::Bonus
+    def apply_bonuses
+      @bonuses = LilBonus.new({"test" => "Bonus!"})
+    end
+  end
+
+  def test_bonuses
+    b = BonusTester.new
+    assert b.get_bonus("test") == 'Bonus!'
+  end
+
+end

data/test/feat_totaler_test.rb

@@ -1,14 +1,31 @@
 require 'minitest/autorun'
-require 'test/helper'
+require 'pfrpg_core'
 
-class FeatFinderTest < Minitest::Test
+class FeatTotalerTest < Minitest::Test
+
+  MockFeat = Struct.new(:name) do
+    def prereq_code
+      nil
+    end
+  end
+
+  class MockEntity
+    attr_accessor :feats
+    def initialize(feats = nil)
+      @feats = feats
+      @feats ||= default_feats
+    end
+
+    def default_feats
+      [ MockFeat.new('Feat1') ]
+    end
+  end
 
   def test_filter_feats_by_owned
-    e = PsuedoEntity.new
-    feats = [ PsuedoFeat.new('Feat1') ]
-    finder = FeatFinder.new(e, feats)
+    e = MockEntity.new
+    feats = [ MockFeat.new('Feat1') ]
+    finder = PfrpgCore::FeatFinder.new(e, feats)
     assert finder.find_feats.empty?
   end
 
-
-end
+end

data/test/helper.rb

@@ -14,7 +14,7 @@ class Helper
     end
 
     def default_feats
-      [ PsuedoFeat.new('Feat1') ]
+      [ MockFeat.new('Feat1') ]
     end
   end
 end

data/test/levels_test.rb

@@ -0,0 +1,19 @@
+require 'minitest/autorun'
+require 'pfrpg_core'
+require_relative './test_helper'
+
+class LevelsTest < Minitest::Test
+  include TestHelper
+
+  def setup
+    @c = plain_character
+  end
+
+  def test_basic
+    assert @c.levels.size == 1
+    assert @c.levels[0].classname == 'Fighter'
+    assert @c.levels[0].rank == 10
+    assert @c.hit_die == 10
+  end
+
+end

data/test/misc_test.rb

@@ -0,0 +1,78 @@
+require 'minitest/autorun'
+require 'pfrpg_core'
+require_relative  './test_helper'
+
+class MiscTest < Minitest::Test
+  include TestHelper
+
+  def setup
+    @c = plain_character
+  end
+
+  def test_initiative
+    assert @c.initiative == 0
+  end
+
+  def test_upgraded_initiative_dex
+    @bonuses.plus('dex', 4)
+    @c.bonuses = @bonuses
+    assert @c.initiative == 2
+  end
+
+  def test_upgraded_initiative
+    @bonuses.plus('initiative', 4)
+    @c.bonuses = @bonuses
+    assert @c.initiative == 4
+  end
+
+  def test_speed
+    ['land','fly','climb','swim'].each do |type|
+      assert @c.speed["#{type}_speed"] == 30
+    end
+  end
+
+  class MockSlowArmor
+    def slot; 'armor'; end
+    def speed_thirty; 15; end
+    def speed_twenty; 10; end
+  end
+
+  def test_speed_heavy
+    @c.inventory = PfrpgCore::Inventory.new([MockSlowArmor.new], [])
+    assert @c.speed['land_speed'] == 15
+  end
+
+  def test_speed_heavy_dwarf
+    @c.race = PfrpgRaces::Race.fetch('Dwarf')
+    @c.inventory = PfrpgCore::Inventory.new([MockSlowArmor.new], [])
+    assert @c.speed['land_speed'] == 20
+  end
+
+  class MockMockCharacter
+    def hit_points; 15; end
+  end
+
+  def test_hit_points
+    @c.character = MockMockCharacter.new
+    assert @c.hit_points == 15
+  end
+
+  def test_hit_points
+    feats = [ PfrpgCore::Feat.new({name: 'Toughness'}) ]
+    @c.character = MockMockCharacter.new
+    @c.feats = feats
+    # formual for toughness
+    assert @c.hit_points == (15 + 3 + @c.total_level - 3)
+  end
+
+  def test_total_level
+    assert @c.total_level == 10
+  end
+
+  def test_total_level_more
+    @c.levels << PfrpgCore::Level.new(Le.new('Rogue', 5, false))
+    assert @c.total_level == 15
+    assert @c.hit_die == 15
+  end
+
+end

data/test/saves_test.rb

@@ -0,0 +1,54 @@
+require 'minitest/autorun'
+require 'pfrpg_core'
+require_relative './test_helper'
+
+class SavesTest < Minitest::Test
+
+  include TestHelper
+
+  def setup
+    @bonuses = PfrpgCore::Bonuses.new
+    @attributes = PfrpgCore::Attributes.new(basic_attributes, @bonuses)
+  end
+
+  def test_basc
+    b = basic_saves
+    saves = PfrpgCore::SavingThrows.new(b, @bonuses, @attributes)
+    assert saves.reflex == 5
+  end
+
+  def test_positive_bonus
+    b = basic_saves
+    bonuses = PfrpgCore::Bonuses.new
+    bonuses.plus('ref', 4)
+    saves = PfrpgCore::SavingThrows.new(b, bonuses, @attributes)
+    assert saves.reflex == 9
+  end
+
+  def test_negative_bonus
+    b = basic_saves
+    bonuses = PfrpgCore::Bonuses.new
+    bonuses.plus('ref', -4)
+    saves = PfrpgCore::SavingThrows.new(b, bonuses, @attributes)
+    assert saves.reflex == 1
+  end
+
+  def test_con_bonus
+    @bonuses.plus('con', 4)
+    saves = PfrpgCore::SavingThrows.new(basic_saves, @bonuses, @attributes)
+    assert saves.fortitude == 7
+  end
+
+  def test_wis_bonus
+    @bonuses.plus('wis', -4)
+    saves = PfrpgCore::SavingThrows.new(basic_saves, @bonuses, @attributes)
+    assert saves.will == 3
+  end
+
+  def test_dex_bonus
+    @bonuses.plus('dex', 4)
+    @bonuses.plus('ref', -2)
+    saves = PfrpgCore::SavingThrows.new(basic_saves, @bonuses, @attributes)
+    assert saves.reflex == 5
+  end
+end