pfrpg_core 0.0.2 → 0.1.1

data/lib/pfrpg_core/filters/skill_focus_mod.rb

@@ -0,0 +1,25 @@
+module PfrpgCore
+  module Filters
+    class SkillFocusMod
+      attr_reader :character
+      def initialize(character)
+        @character = character
+      end
+
+      def filter(skill)
+        prof_feats = character.feats.select { |x| x.name == 'Skill Focus' }
+        skills = []
+        prof_feats.each do |f|
+          skills << f.feat_special
+        end
+        if skills.include? skill.name
+          modify_skill_for_skill_focus(skill)
+        end
+      end
+
+      def modify_skill_for_skill_focus(skill)
+        skill.misc_bonus += 3
+      end
+    end
+  end
+end

data/lib/pfrpg_core/filters/strength_mod.rb

@@ -0,0 +1,21 @@
+module PfrpgCore
+  module Filters
+    class StrengthMod
+      attr_reader :character
+      def initialize(character)
+        @character = character
+      end
+
+      def filter(attack)
+        if attack.weapon.applies_strength_dmg?
+          base_mod = character.attributes.str_mod
+          if(attack.weapon.weight_class == 'Two-handed')
+            base_mod = (base_mod * 1.5)
+          end
+          attack.filter_str << "Strength damage : #{base_mod}"
+          attack.damage.add_static(base_mod) if attack.weapon.applies_strength_dmg?
+        end
+      end
+    end
+  end
+end

data/lib/pfrpg_core/filters/weapon_finesse_mod.rb

@@ -0,0 +1,24 @@
+module PfrpgCore
+  module Filters
+    class WeaponFinesseMod
+      attr_reader :character
+      def initialize(character)
+        @character = character
+      end
+
+      def filter(attack)
+        if character.feats.find { |x| x.name == 'Weapon Finesse' }
+          modify_attack_for_weapon_finesse(attack, character.attributes.dex_mod, character.attributes.str_mod)
+        end
+      end
+
+      def modify_attack_for_weapon_finesse(attack, dex, str)
+        if attack.weight_class == 'light' || attack.weight_class == 'natural'
+          attack.filter_str << "Weapon Finesse: -#{dex}, +#{str}"
+          attack.other_bonus += dex
+          attack.other_bonus -= str
+        end
+      end
+    end
+  end
+end

data/lib/pfrpg_core/filters/weapon_focus_mod.rb

@@ -0,0 +1,23 @@
+module PfrpgCore
+  module Filters
+    class WeaponFocusMod
+      attr_reader :character
+      def initialize(character)
+        @character = character
+      end
+
+      def filter(attack)
+        f = character.feats.find { |x| x.name == 'Weapon Focus' }
+        if f != nil && (attack.weapon.name.downcase == f.special.downcase)
+          modify(attack)
+        end
+        return attack
+      end
+
+      def modify(attack)
+        attack.filter_str << "Weapon Focus: attack bonus +1"
+        attack.other_bonus += 1
+      end
+    end
+  end
+end

data/lib/pfrpg_core/filters/weapon_mastery_mod.rb

@@ -0,0 +1,23 @@
+class PfrpgCore::Filters::WeaponMasteryMod
+  attr_reader :character, :special
+  def initialize(character, feature)
+    @character = character
+    @special   = feature.special
+  end
+
+  def filter(attack)
+    if attack.weapon.name == @special
+      modify(attack)
+    end
+  end
+
+  def modify(attack)
+    attack.critical_damage = increase_crit(attack.critical_damage)
+  end
+
+  def increase_crit(crit_str)
+    crit_num = crit_str.split("x")[0].to_i
+    crit_num += 1
+    "#{crit_num}x"
+  end
+end

data/lib/pfrpg_core/filters/weapon_specialization_mod.rb

@@ -0,0 +1,22 @@
+module PfrpgCore
+  module Filters
+    class WeaponSpecializationMod
+      attr_reader :character
+      def initialize(character)
+        @character = character
+      end
+
+      def filter(attack)
+        f = character.feats.find { |x| x.name == 'Weapon Specialization' }
+        if f != nil && attack.weapon.name == f.feat_special
+          modify(a)
+        end
+      end
+
+      def modify(attack)
+        attack.filter_str << "Weapon Specialization: +2 damage"
+        attack.damage.add_static(2)
+      end
+    end
+  end
+end

data/lib/pfrpg_core/filters/weapon_training_mod.rb

@@ -0,0 +1,22 @@
+module PfrpgCore
+  module Filters
+    class WeaponTrainingMod
+      attr_reader :character, :feature
+      def initialize(character, feature)
+        @character = character
+        @feature   = feature
+      end
+
+      def filter(attack)
+        trainer = PfrpgCore::WeaponTrainingCalculator.new(character)
+        trained = trainer.trained_value(attack.weapon, feature)
+        modify(attack, trained)
+      end
+
+      def modify(attack, val)
+        attack.other_bonus += val
+        attack.damage.add_static(val)
+      end
+    end
+  end
+end

data/lib/pfrpg_core/inventory.rb

@@ -0,0 +1,62 @@
+module PfrpgCore
+  class Inventory
+    attr_reader :equipment, :inventory
+    def initialize(equipment, inventory)
+      @equipment = equipment
+      @inventory = inventory
+    end
+
+    def get_armor_ac
+      equipped_armor.nil? ? 0 : equipped_armor.ac_bonus
+    end
+
+    def get_shield_ac
+      shield = equipment.find { |x| x.slot == 'shield' }
+      shield.nil? ? 0 : shield.ac_bonus
+    end
+
+    def equipped_defensive
+      equipment.select { |x| x.ac_bonus != nil }
+    end
+
+    def equipped_armor
+      equipment.find { |x| x.slot == 'armor' }
+    end
+
+    def armor_and_shield
+      e = [ equipped_armor ]
+      e << equipment.find { |x| x.slot == 'shield' }
+      e.delete_if { |x| x == nil }
+      e
+    end
+
+    # monk is obnoxious
+    def equipped_weapons(levels = [])
+      weapons = equipment.select { |x| x.type == 'Weapon' || x.type == 'MagicWeapon' }
+      monk = levels.find { |x| x.classname == 'Monk' }
+      weapons << unarmed_strike(monk.rank) if (monk != nil && weapons.empty?)
+      return weapons
+    end
+
+    def unarmed_strike(monk_level)
+      PfrpgClasses::Heroclass.by_name('Monk').get_unarmed_weapon(monk_level)
+    end
+
+    def ac_penalty(bonuses = Bonuses.new)
+      ac_penalty = 0
+      equipment.each do |e|
+        ac_penalty += NullObject.maybe(e.armor_check_penalty).to_i
+      end
+      ac_penalty += bonuses.get("ac_penalty").to_i
+      ac_penalty = 0 if ac_penalty > 0
+      ac_penalty
+    end
+
+    def as_json(options={})
+      {
+        equipment: get_equipment,
+        inventory: get_inventory
+      }
+    end
+  end
+end

data/lib/pfrpg_core/item.rb

@@ -0,0 +1,42 @@
+module PfrpgCore
+  class Item
+    include PfrpgUtility::Affectable
+    attr_reader :name, :description, :slot, :type, :equipped, :effects,
+                :cost, :dmg_s, :dmg_m, :critical_range, :critical_dmg,
+                :range, :weight, :dmg_type, :special, :source, :weapon_type,
+                :weight_class, :ac_bonus, :max_dex_bonus, :armor_check_penalty,
+                :arcane_spell_failure_chance, :speed_twenty, :speed_thirty
+
+    def initialize(item, equipped)
+      @name = item[:name]
+      @description = item[:description]
+      @slot = item[:slot]
+      @type = item[:type]
+      @effects = item[:effects]
+      @cost = item[:cost]
+      @dmg_m = item[:dmg_m]
+      @dmg_s = item[:dmg_s]
+      @critical_range = item[:critical_range]
+      @critical_dmg = item[:critical_dmg]
+      @range = item[:range]
+      @weight = item[:weight]
+      @dmg_type = item[:dmg_type]
+      @special = item[:special]
+      @source = item[:source]
+      @weapon_type = item[:weapon_type]
+      @weight_class = item[:weight_class]
+      @ac_bonus = item[:ac_bonus]
+      @max_dex_bonus = item[:max_dex_bonus]
+      @armor_check_penalty = item[:armor_check_penalty]
+      @arcane_spell_failure_chance = item[:arcane_spell_failure_chance]
+      @speed_twenty = item[:speed_twenty]
+      @speed_thirty = item[:speed_thirty]
+      @equipped = equipped
+    end
+
+    def applies_strength_dmg?
+      ['light', 'one-handed', 'two-handed'].include?(weight_class.downcase) ||
+          name == 'Sling'
+    end
+  end
+end

data/lib/pfrpg_core/level.rb

@@ -0,0 +1,14 @@
+require 'pfrpg_classes'
+
+module PfrpgCore
+  class Level
+    attr_reader :rank, :classname, :favored, :heroclass
+    def initialize(level)
+      @rank = level.class_number
+      @classname = level.class_name
+      @heroclass = PfrpgClasses::Heroclass.by_name(@classname)
+      @favored = level.favored
+    end
+  end
+
+end

data/lib/pfrpg_core/level_parser.rb

@@ -3,13 +3,21 @@ module PfrpgCore
     attr_reader :level_string, :levels
     def initialize(level_string)
       @level_string = level_string
-      @levels = parse
+      begin
+        @levels = parse
+      rescue Exception
+        @levels = {}
+      end
     end
 
     def total
       return @levels.values.inject(0) { |sum, l| sum + l }
     end
 
+    def levelmap
+      @levels.map { |x| PfrpgCore::Level.new(x) }
+    end
+
     def parse
       levels = {}
       splits = @level_string.split(';')

data/lib/pfrpg_core/macros/macro.rb

@@ -0,0 +1,62 @@
+module PfrpgCore
+  class Macro
+    attr_reader :character
+
+    def initialize(character)
+      @character = character
+    end
+
+    def available?
+      false
+    end
+
+    def applies_to?(_weapon)
+      false
+    end
+
+    def slug
+      name = self.class.name.split("PfrpgCore::")[1]
+      name.split('Macro').first
+    end
+
+    def name
+      slug.titleize
+    end
+
+    def info
+      nil
+    end
+
+    def as_json
+      {
+        slug: slug,
+        name: name,
+        info: info
+      }
+    end
+
+    def self.find_available(character)
+      macro_subclasses.map { |m| m.new(character) }.keep_if { |m| m.available? }
+    end
+
+    # TODO:  This should not be needed - Rails provides #subclasses but there is
+    #        crazy classloading stuff happening (or not happening actually) that
+    #        is causing this to be empty...
+    def self.macro_subclasses
+      # Macro.subclasses
+      [
+        PowerAttackMacro,
+        SneakAttackMacro,
+        RapidShotMacro,
+        ManyshotMacro,
+        VitalStrikeMacro
+      ]
+    end
+  end
+end
+
+require 'pfrpg_core/macros/manyshot_macro'
+require 'pfrpg_core/macros/power_attack_macro'
+require 'pfrpg_core/macros/rapid_shot_macro'
+require 'pfrpg_core/macros/sneak_attack_macro'
+require 'pfrpg_core/macros/vital_strike_macro'

data/lib/pfrpg_core/macros/manyshot_macro.rb

@@ -0,0 +1,12 @@
+module PfrpgCore
+  class ManyshotMacro < Macro
+
+    def available?
+      character.feats.any? { |feat| feat.name == 'Manyshot' }
+    end
+
+    def applies_to?(weapon)
+      weapon.weight_class == 'ranged' && weapon.name.downcase.include?('bow')
+    end
+  end
+end

data/lib/pfrpg_core/macros/power_attack_macro.rb

@@ -0,0 +1,12 @@
+module PfrpgCore
+  class PowerAttackMacro < Macro
+
+    def available?
+      character.feats.any? { |feat| feat.name == 'Power Attack' }
+    end
+
+    def applies_to?(weapon)
+      weapon.weight_class != 'ranged' && weapon.weight_class != 'ammunition'
+    end
+  end
+end

data/lib/pfrpg_core/macros/rapid_shot_macro.rb

@@ -0,0 +1,12 @@
+module PfrpgCore
+  class RapidShotMacro < Macro
+
+    def available?
+      character.feats.any? { |feat| feat.name == 'Rapid Shot' }
+    end
+
+    def applies_to?(weapon)
+      weapon.weight_class == 'ranged'
+    end
+  end
+end

data/lib/pfrpg_core/macros/sneak_attack_macro.rb

@@ -0,0 +1,33 @@
+module PfrpgCore
+  class SneakAttackMacro < Macro
+
+    def initialize(character)
+      super
+
+      sneak_attack_features = character.class_features.select do |feature|
+        feature.name.downcase.start_with? 'sneak a'
+      end
+
+      @sneak_attack_level = sneak_attack_features.map do |feature|
+        /Sneak Attack \((\d+)d6\)/.match(feature.name)[1].to_i
+      end.max || 0
+    end
+
+    def name
+      "Sneak Attack (level #{@sneak_attack_level})"
+    end
+
+    def available?
+      @sneak_attack_level.nonzero?
+    end
+
+    def applies_to?(weapon)
+      true
+    end
+
+    def info
+      { sneakAttackLevel: @sneak_attack_level }
+    end
+
+  end
+end

data/lib/pfrpg_core/macros/vital_strike_macro.rb

@@ -0,0 +1,12 @@
+module PfrpgCore
+  class VitalStrikeMacro < Macro
+
+    def available?
+      character.feats.any? { |feat| feat.name == 'Vital Strike' }
+    end
+
+    def applies_to?(weapon)
+      true
+    end
+  end
+end

data/lib/pfrpg_core/null_object.rb

@@ -1,37 +1,39 @@
-class PfrpgCore::NullObject < Numeric
-  def to_a; []; end
-  def to_s; ""; end
-  def to_str; ""; end
-  def to_f; 0.0; end
-  def to_i; 0; end
+module PfrpgCore
+  class NullObject < Numeric
+    def to_a; []; end
+    def to_s; ""; end
+    def to_str; ""; end
+    def to_f; 0.0; end
+    def to_i; 0; end
 
-  def empty?
-    true
-  end
+    def empty?
+      true
+    end
 
-  def as_json(options={})
-    ""
-  end
+    def as_json(options={})
+      ""
+    end
 
-  def method_missing(*args, &block)
-    self
-  end
+    def method_missing(*args, &block)
+      self
+    end
 
-  def self.maybe(value)
-    case value
-    when nil then NullObject.new
-    else value
+    def self.maybe(value)
+      case value
+        when nil then NullObject.new
+        else value
+      end
     end
-  end
 
-  def +(other)
-    case other
-    when String
-      to_s + other
-    when Fixnum
-     to_i + other
-    when Float
-     to_f + other
+    def +(other)
+      case other
+        when String
+          to_s + other
+        when Fixnum
+          to_i + other
+        when Float
+          to_f + other
+      end
     end
   end
-end
+end

data/lib/pfrpg_core/saving_throws.rb

@@ -0,0 +1,43 @@
+module PfrpgCore
+  class SavingThrows
+
+    def initialize(saves, bonuses, attributes)
+      @attributes = attributes
+      @will = saves[:will]
+      @will_bonus = NullObject.maybe(bonuses.get('will')).to_i
+      @fortitude = saves[:fort]
+      @fort_bonus = NullObject.maybe(bonuses.get('fort')).to_i
+      @reflex = saves[:ref]
+      @ref_bonus = NullObject.maybe(bonuses.get('ref')).to_i
+    end
+
+    def fortitude
+      @attributes.con_mod + @fortitude + @fort_bonus
+    end
+
+    def reflex
+      @attributes.dex_mod + @reflex + @ref_bonus
+    end
+
+    def will
+      @attributes.wis_mod + @will + @will_bonus
+    end
+
+    def as_json(options={})
+      {
+          :con_modifier => @attributes.con_mod,
+          :wis_modifier => @attributes.wis_mod,
+          :dex_modifier => @attributes.dex_mod,
+          :base_ref     => @reflex,
+          :base_fort    => @fortitude,
+          :base_will    => @will,
+          :bonus_ref    => @ref_bonus,
+          :bonus_will   => @will_bonus,
+          :bonus_fort   => @fort_bonus,
+          :fortitude    => fortitude,
+          :reflex       => reflex,
+          :will         => will
+      }
+    end
+  end
+end