pfrpg_core 0.0.2 → 0.1.1

data/lib/pfrpg_core/derived/magic.rb

@@ -0,0 +1,145 @@
+module PfrpgCore
+  module Derived
+    module Magic
+      class PfrpgCore::InvalidClassException < Exception; end
+      class PfrpgCore::SpellNotFoundException < Exception; end
+      class PfrpgCore::TooManySpellsException < Exception; end
+      class PfrpgCore::InvalidSpellException < Exception; end
+      class PfrpgCore::TooLowAttributeException < Exception; end
+
+      def spells_per_level(class_name, latest=nil)
+        latest ||= self.latest_levels
+        level = latest.find { |x| x.class_name == class_name }
+        return empty_spells unless level
+        return empty_spells if(['Paladin', 'Ranger'].include?(class_name) && level.class_number < 4)
+        base = level.heroclass.spells_per_day(level.class_number)
+        bonuses = PfrpgTables::Tables::Spells::SpellsPerDay.bonus(attr_mod(class_name))
+        total = []
+        for i in 0..9 do
+          total[i] = base[i] + bonuses[i]
+        end
+        total = filter_for_max_attribute(class_name, total)
+        total = filter_for_high_level(level.class_number, total)
+        return total
+      end
+
+      # you can only cast spells up to ($SPELLS_ATTRIBUTE - 10)th level
+      def filter_for_max_attribute(class_name, total)
+        max_spell_level = attr_static(class_name) - 10
+        return filter(total, max_spell_level)
+      end
+
+      def filter_for_high_level(level, total)
+        max_spell_level = ((level + 1)/2).floor
+        return filter(total, max_spell_level)
+      end
+
+      def filter(array, max)
+        for i in (max+1)..9 do
+          array[i] = 0
+        end
+        return array
+      end
+
+      def empty_spells
+        [0,0,0,0,0,0,0,0,0,0]
+      end
+
+      def known_sorcerer_spells
+        spells = []
+        sorc = class_features.select { |x| x.type == 'SorcererSpells' }
+        sorc.each do |x|
+          x.special.each do |spell|
+            spells << spell
+          end
+        end
+        return spells
+      end
+
+      def bloodline
+        class_features.find { |x| x.type == 'Bloodline' }
+      end
+
+      def arcane_school
+        class_features.find { |x| x.type == 'ArcaneSchool' }
+      end
+
+      def can_arcane?
+        arcane_classes = ['Bard', 'Sorcerer', 'Wizard']
+        return latest_levels.find { |x| arcane_classes.include? x.class_name }
+      end
+
+      def can_divine?
+        divine = false
+        latest_levels.each do |level|
+          if ['Cleric', 'Druid'].include? level.class_name
+            divine = true
+          elsif (['Paladin', 'Ranger'].include? level.class_name) && (level.class_number >= 4)
+            divine = true
+          end
+        end
+        return divine
+      end
+
+      def gets_familiar?
+        (class_features.find { |x| x.feature_type == 'Arcane Bond' && x.ability_name == 'Familiar' }) != nil
+      end
+
+      def gets_companion?
+        (class_features.find { |x| x.feature_type == 'Nature Bond' && x.ability_name == 'Animal Companion' }) != nil
+      end
+
+      def valid_spell?(spell, class_name, level, spellbooks)
+        return has_class?(class_name) &&
+            appropriate_level?(spell, class_name, level) &&
+            spell_fits?(class_name, level, spellbooks)
+      end
+
+      private
+
+      def attr_static(class_name)
+        heroclass = PfrpgClasses::Heroclass.by_name(class_name)
+        attr = heroclass.spells_bonus_attr
+        return self.attributes.send("modified_#{attr}")
+      end
+
+      def attr_mod(class_name)
+        heroclass = PfrpgClasses::Heroclass.by_name(class_name)
+        attr = heroclass.spells_bonus_attr
+        return self.attributes.send("#{attr}_mod")
+      end
+
+
+      def has_class?(class_name)
+        latest_levels.each do |l|
+          return true if l.class_name == class_name
+        end
+        raise InvalidClassException
+      end
+
+      def spell_fits?(class_name, level, spellbooks)
+        max_spells = spells_per_level(class_name, latest_levels)[level]
+        if spellbooks[class_name] == nil || spellbooks[class_name][level] == nil
+          return true
+        end
+        raise TooManySpellsException unless spellbooks[class_name][level].size < max_spells
+        return true
+      end
+
+      def appropriate_level?(spell, class_name, level)
+        begin
+          spell_level = spell.send(class_name.downcase)
+          raise InvalidSpellException if spell_level == 'NULL'
+          spell_level_for_class = spell.send(class_name.downcase).to_i
+          raise InvalidSpellException if spell_level_for_class > level
+          raise TooLowSpellException if (attr_static(class_name)-10) < spell_level_for_class
+          return true
+          catch Exception
+          raise InvalidSpellException
+        end
+      end
+
+    end
+
+  end
+end

data/lib/pfrpg_core/derived/misc.rb

@@ -0,0 +1,114 @@
+module PfrpgCore
+  module Derived
+    module Misc
+
+      def level_string
+        str = "#{@alignment} :"
+        @levels.each do |l|
+          str += "#{l.name}/#{l.rank}"
+          str += "*" if l.favored
+        end
+        str
+      end
+
+      def initiative
+        initiative = 0
+        initiative += @attributes.dex_mod
+        initiative += get_bonus("initiative").to_i
+        return initiative
+      end
+
+      def speed
+        base_speed =  NullObject.maybe(@race).speed || 0
+        base_speed += parse_speed_bonuses(get_bonus("speed"))
+        base_speed -= armor_speed_penalty
+        speeds = {}
+        ['land','fly','climb','swim'].each do |type|
+          speeds["#{type}_speed"] = calc_speed(type, base_speed)
+        end
+        speeds['speed'] = speeds['land_speed']
+        return speeds
+      end
+
+      def calc_speed(speed_type, base)
+        base + get_bonus("#{speed_type}_speed")
+      end
+
+      def parse_speed_bonuses(speed_bonuses)
+        speed_bonus = 0
+        speed_bonuses.each do |s|
+          speed_bonus += s.to_i if MathHelper.is_number(s)
+        end
+        speed_bonus
+      end
+
+      def hit_points
+        hp = @character.hit_points
+        # TODO : potentially move off this method when multiple hp affect stats exist
+        if (@feats.find { |x| x.name == 'Toughness' })
+          hp += 3
+          if (total_level > 3)
+            hp += total_level - 3
+          end
+        end
+        return hp
+      end
+
+      def size
+        return @race.size if @race
+        return nil
+      end
+
+      def total_level
+        @levels.inject(0) {|sum, x| sum = sum + x.rank }
+      end
+
+      def hit_die
+        total_level
+      end
+
+      def get_class_level(heroclass)
+        l = latest_levels.find { |x| x.class_name[heroclass.name] }
+        if l
+          return l.class_number
+        else
+          return 0
+        end
+      end
+
+      def explode_levels
+        # TODO: implement me
+        []
+      end
+
+      def hit_dice
+        hit_die
+      end
+
+      def get_caster_level
+        # TODO constantize somewhere better
+        caster_classes = ['Bard', 'Cleric', 'Druid', 'Paladin', 'Ranger', 'Sorcerer', 'Wizard']
+        caster_levels = latest_levels.select { |x| caster_classes.include? x.class_name }
+        max_caster_level = caster_levels.map { |x| x.class_number }.max || 0
+        ek_level = get_class_level(PfrpgClasses::Heroclass.by_name('Eldritch Knight'))
+        return (max_caster_level + ek_level) || 0
+      end
+
+      def misc_json
+        {
+            :initiative     => initiative,
+            :alignment      => @alignment,
+            :speed          => speed,
+            :hit_points     => hit_points,
+            :feats          => @feats,
+            :class_features => @class_features,
+            :levels         => @levels,
+            :total_level    => @total_level,
+            :size           => size,
+            :level_string   => level_string,
+            :temporary      => @character.temp_values
+        }
+      end
+    end
+  end
+end

data/lib/pfrpg_core/derived/offense.rb

@@ -0,0 +1,49 @@
+module PfrpgCore
+  module Derived
+    module Offense
+      def combat_maneuver_bonus
+        base = str_bonus + bab - size_modifier
+        misc = character.get_bonus('cmb').to_i
+        base += misc
+        return base
+      end
+
+      def attack_filters
+        standard_filters = [
+            PfrpgCore::Filters::StrengthMod.new(character),
+            PfrpgCore::Filters::WeaponFinesseMod.new(character),
+            PfrpgCore::Filters::RangedAttackMod.new(character),
+            PfrpgCore::Filters::WeaponFocusMod.new(character),
+            PfrpgCore::Filters::WeaponSpecializationMod.new(character),
+            PfrpgCore::Filters::ProficiencyMod.new(character)
+        ]
+        standard_filters << character.get_attack_filters
+        standard_filters.flatten
+      end
+
+      def attacks
+        macros = Macro.find_available(character)
+
+        atk = character.inventory.equipped_weapons(character.levels).collect do |w|
+          Attack.new({   :weapon_name =>  w.get_best_name,
+                         :range        => w.range,
+                         :weight_class => w.weight_class,
+                         :damage       => w.damage,
+                         :weapon_type  => w.weapon_type,
+                         :critical_range => w.critical_range,
+                         :critical_dmg => w.critical_dmg,
+                         :bonus        => w.bonus,
+                         :strength_bonus   => str_bonus,
+                         :bab          => bab,
+                         :size         => character.race.size,
+                         :filters      => attack_filters,
+                         :filter_str   => [],
+                         :weapon       => w,
+                         :macros       => macros.select { |m| m.applies_to? w }
+                     })
+        end
+        return atk
+      end
+    end
+  end
+end

data/lib/pfrpg_core/derived.rb

@@ -0,0 +1,10 @@
+module PfrpgCore
+  module Derived
+  end
+end
+
+require 'pfrpg_core/derived/defense'
+require 'pfrpg_core/derived/offense'
+require 'pfrpg_core/derived/combat_bonuses'
+require 'pfrpg_core/derived/magic'
+require 'pfrpg_core/derived/misc'

data/lib/pfrpg_core/effect_processor.rb

@@ -10,7 +10,7 @@ module PfrpgCore
       final = []
       no_stacking = effects_hash(@effects)
       no_stacking.keys.each do |key|
-        if Tables::Bonus.stackable?(key) || Tables::Bonus.special?(key)
+        if PfrpgTables::Tables::Bonus.stackable?(key) || PfrpgTables::Tables::Bonus.special?(key)
           final << no_stacking[key]
         else
           final << find_max(no_stacking[key])

data/lib/pfrpg_core/effect_totaler.rb

@@ -0,0 +1,29 @@
+module PfrpgCore
+  class EffectTotaler
+    attr_reader :character
+    def initialize(character)
+      @character = character
+    end
+
+    def effects
+      effects = []
+      [
+        NullObject.maybe(@character.feats),
+        NullObject.maybe(@character.inventory.equipment),
+        NullObject.maybe(@character.race).traits,
+        NullObject.maybe(@character.class_features)
+      ].each do |r|
+        r.each do |x|
+          effects << x.get_effects
+        end
+      end
+      # TODO : calculate level based effects
+      NullObject.maybe(@character.explode_levels).each do |l|
+        l.class_features.each do |x|
+          effects << x.get_effects
+        end
+      end
+      return effects.flatten
+    end
+  end
+end

data/lib/pfrpg_core/equipment_totaler.rb

@@ -0,0 +1,14 @@
+module PfrpgTables
+  class EquipmentTotaler
+    attr_reader :entity, :levels
+    def initialize(entity)
+      @entity = entity
+      @levels = PfrpgCore::LevelParser.new(entity.level)
+    end
+
+    def total
+      return 1000
+    end
+
+  end
+end

data/lib/pfrpg_core/feat.rb

@@ -0,0 +1,27 @@
+module PfrpgCore
+  class Feat
+    include PfrpgUtility::Affectable
+    attr_reader :name, :description, :effects, :prereqs,
+                :special, :type, :source
+
+    def initialize(params)
+      @name = params[:name]
+      @description = params[:description]
+      @effects = params[:effects] || []
+      @prereqs = params[:prereqs] || []
+      @special = params[:special]
+      @type = params[:type]
+      @source = params[:source]
+    end
+
+    def as_json(options={})
+      {
+          name: @name,
+          description: @description,
+          special: @special,
+          type: @type,
+          source: @source
+      }
+    end
+  end
+end

data/lib/pfrpg_core/feat_totaler.rb

@@ -0,0 +1,61 @@
+module PfrpgTables
+  class FeatTotaler
+    attr_reader :entity, :levels
+    def initialize(entity)
+      @entity = entity
+      @levels = PfrpgCore::LevelParser.new(entity.level)
+    end
+
+    def total
+      return level_granted + race_granted + feature_granted + choice_granted
+    end
+
+    def level_granted
+      i = (1..levels.total).inject(0) do |sum, x|
+        choices = PfrpgTables::Tables::LevelTable.for_level(x)[:choices]
+        sum = sum + (choices.select { |c| choice_is_feat(c) }).size
+      end
+      return i
+    end
+
+    def race_granted
+      i = entity.race.bonus_choices.inject(0) do |sum, x|
+        sum = sum + 1 if choice_is_feat(x)
+      end
+      return i
+    end
+
+    def feature_granted
+      i = entity.class_features.inject(0) do |sum, x|
+        if x.respond_to? 'granted_choice'
+          choices = [x.granted_choice].flatten
+          sum += (choices.select { |c| choice_is_feat(c) }).size
+        end
+      end
+      return i || 0
+    end
+
+    def choice_granted
+      choices = []
+      lvls = @levels.parse
+      lvls.keys.each do |hc|
+        clazz = PfrpgClasses::Heroclass.by_name(hc)
+        level = lvls[hc]
+        (1..level).each do |l|
+          clazz.bonuses_for_level(l)[:choices].each do |choice|
+            if (choice_is_feat(choice))
+              choice.npc_id = entity.id
+              choices << choice
+            end
+          end
+        end
+      end
+      @choose_features = choices.flatten.size
+    end
+
+    def choice_is_feat(choice)
+      choice.class.to_s['Feat'] != nil
+    end
+
+  end
+end

data/lib/pfrpg_core/feature_duplicator.rb

@@ -0,0 +1,26 @@
+class PfrpgCore::FeatureDuplicator
+
+  def self.dupe_words
+    ['Sneak Attack', 'Channel Energy', 'Damage Reduction', 'Trap Sense']
+  end
+
+  # filter things with multiple bonuses, like sneak attack and channel energy
+  def self.filter_duplicates(features)
+    dupe_words.each do |w|
+      features = features - smallest(features, w)
+    end
+    features
+  end
+
+  def self.smallest(features, phrase)
+    smallest = features.select { |x| x.name[phrase] != nil }
+    return [] if (smallest.empty? || smallest.size == 1)
+    smallest.sort_by! { |x| parse_number(x.name) }
+    smallest[0..smallest.size-2]
+  end
+
+  # of the form, 'Sneak Attack (10d6)'
+  def self.parse_number(description)
+    (description.split('d6')[0].split(' ').last.split('(')[1]).to_i
+  end
+end

data/lib/pfrpg_core/feature_totaler.rb

@@ -0,0 +1,86 @@
+module PfrpgTables
+  class FeatureTotaler
+    attr_reader :entity, :levels
+    def initialize(entity)
+      @entity = entity
+      @levels = PfrpgCore::LevelParser.new(entity.level)
+      @base_features = []
+      @choose_features = []
+      parse_features
+    end
+
+    def get_base_features
+      @base_features
+    end
+
+    def get_choose_features
+      @choose_features
+    end
+
+    def parse_features
+      choices = []
+      lvls = levels.parse
+      lvls.keys.each do |hc|
+        clazz = PfrpgClasses::Heroclass.by_name(hc)
+        level = lvls[hc]
+        (1..level).each do |l|
+          class_features = clazz.bonuses_for_level(l)[:granted_features]
+          class_features.each do |x|
+            ap "Creating granted feature:"
+            ap "\t#{x} (#{hc})"
+            @base_features << ClassFeature.granted_feature(x, hc)
+          end
+          clazz.bonuses_for_level(l)[:choices].each do |choice|
+            if !(choice_is_feat(choice))
+              choice.npc_id = entity.id
+              choices << flatten_options(choice)
+            end
+          end
+        end
+      end
+      @choose_features = choices.flatten
+    end
+
+    def flatten_options(feature_choice)
+      ap "feature chioce:"
+      ap feature_choice.choices[:options][0]
+      if feature_choice.choices[:options][0].respond_to? 'name'
+        new_options = feature_choice.choices[:options].map { |x| x.name }
+        ap "New options:"
+        ap new_options
+        feature_choice.choices[:options] = new_options
+      end
+      return feature_choice
+    end
+
+    def level_granted
+      i = (1..levels.total).inject(0) do |sum, x|
+        choices = PfrpgTables::Tables::LevelTable.for_level(x)[:choices]
+        sum = sum + (choices.select { |c| choice_is_feat(c) }).size
+      end
+      return i
+    end
+
+    def race_granted
+      race = entity.race
+      i = race.bonus_choices.inject(0) do |sum, x|
+        sum = sum + 1 if choice_is_feat(x)
+      end
+      return i
+    end
+
+    def feature_granted
+      i = entity.class_features.inject(0) do |sum, x|
+        choices = x.bonus_choices
+        sum += (choices.select { |c| choice_is_feat(c) }).size
+      end
+      return i
+    end
+
+    def choice_is_feat(choice)
+      choice.class.to_s['Feat'] != nil
+    end
+
+  end
+end
+

data/lib/pfrpg_core/filterable.rb

@@ -4,7 +4,7 @@ module PfrpgCore::Filterable
       begin
         self.filter_str << "Filtering #{f.class}"
         f.filter(self)
-      rescue Exception => e
+      rescue Exception
       end
     end
   end

data/lib/pfrpg_core/filters/filter.rb

@@ -0,0 +1,14 @@
+module PfrpgCore
+  module Filters
+  end
+end
+
+require_relative './weapon_training_mod.rb'
+require_relative './weapon_specialization_mod.rb'
+require_relative './weapon_finesse_mod.rb'
+require_relative './strength_mod.rb'
+require_relative './proficiency_mod.rb'
+require_relative './prowess_mod.rb'
+require_relative './weapon_focus_mod.rb'
+require_relative './weapon_mastery_mod.rb'
+require_relative './ranged_attack_mod.rb'

data/lib/pfrpg_core/filters/proficiency_mod.rb

@@ -0,0 +1,34 @@
+module PfrpgCore
+  module Filters
+    class ProficiencyMod
+      attr_reader :character
+      def initialize(character)
+        @character = character
+      end
+
+      def filter(attack)
+        proficiency = PfrpgCore::Specializer.new(character)
+        unless proficiency.is_proficient_in_weapon? attack.weapon
+          modify_for_weapon(attack)
+        end
+        armor = character.inventory.armor_and_shield
+        armor.each do |a|
+          unless proficiency.is_proficient_in_armor? a
+            modify_for_armor(attack, a)
+          end
+        end
+      end
+
+      def modify_for_weapon(attack)
+        attack.filter_str << 'Not proficient with weapon, -4 atk'
+        attack.other_bonus -= 4
+      end
+
+      def modify_for_armor(attack, armor)
+        attack.filter_str << "Not proficient with armor: #{armor.name}"
+        # armor check penalties are negative
+        attack.other_bonus += NullObject.maybe(armor.armor_check_penalty)
+      end
+    end
+  end
+end

data/lib/pfrpg_core/filters/prowess_mod.rb

@@ -0,0 +1,20 @@
+module PfrpgCore
+  class Filters::ProwessMod
+    attr_reader :character
+    def initialize(character)
+      @character = character
+    end
+
+    def filter(skill)
+      if (skill.name.downcase == 'intimidate')
+        feat = character.char_feats.select { |x| x.pathfinder_feat.name == 'Intimidating Prowess' }
+        modify_skill_for_prowess(skill) if feat
+      end
+    end
+
+    def modify_skill_for_prowess(skill)
+      skill.misc_bonus += character.attributes.str_mod
+    end
+  end
+end
+

data/lib/pfrpg_core/filters/ranged_attack_mod.rb

@@ -0,0 +1,28 @@
+module PfrpgCore
+  module Filters
+    class RangedAttackMod
+      attr_reader :character
+      def initialize(character)
+        @character = character
+      end
+
+      def filter(attack)
+        unless character.feats.find { |x| x.name == 'Weapon Finesse' }
+          modify_attack_for_ranged_attack(attack, character.attributes.dex_mod, character.attributes.str_mod)
+        end
+      end
+
+      def modify_attack_for_ranged_attack(attack, dex, str)
+        begin
+          ranged = attack.range.to_i
+          if !(ranged == nil || ranged == '' || ranged == 0)
+            attack.filter_str << "Range Bonus: -#{dex}, +#{str}"
+            attack.other_bonus += dex
+            attack.other_bonus -= str
+          end
+        rescue Exception => e
+        end
+      end
+    end
+  end
+end