pfrpg_core 0.0.2 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 24480e464296020ce60bfca1fd95227cadb8a359
-  data.tar.gz: 83c3d9251284b87f32e90b80f60fb8f7268d5c85
+  metadata.gz: a81b275bf8b1f380b13725652a251c708cd48916
+  data.tar.gz: 6e3b733562b317dd49e56212fa62a9e5e73c8ba8
 SHA512:
-  metadata.gz: 1e9e1834b2016406b8bbe9d48635a33fccfec7f43783bc05c6dd6d3b539772fd5f49654e495fe4ca845713cc0ba8012cd633634ef88b96092122c06b4cdff962
-  data.tar.gz: 187698110638a04a7b3ecfa318102cc2e00e3d8a771a581c9d90d18b144c4f1bb4bb16ac9da5465316c36b20ee40a467698cda211a74b4ac46417f917d44ded7
+  metadata.gz: 6d64a6bd2e769cad43e6f45994b9630678a40bcc5a22c26259566add1f313392acd68a6fe07d572a42ecef60ef7cd87a15c4676e978b8180f793d46001438e63
+  data.tar.gz: edc3cd41f5c5d5edd0037d5602f4bc20597f3216992974519f83fd0181e44f3c6cebf9a24854f538981f2c11f9b8ba374d3f1da91e6d9f17ef03d949668aef25

data/LICENSE

@@ -0,0 +1,23 @@
+The MIT License (MIT)
+[OSI Approved License]
+The MIT License (MIT)
+
+Copyright (c) 2014 HeroSheets, LLC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/Rakefile

@@ -2,6 +2,6 @@ require 'rake/testtask'
 
 Rake::TestTask.new do |t|
     t.libs.push "lib"
-    t.test_files = FileList['test/*_test.rb']
+    t.test_files = FileList['test/*.rb']
     t.verbose = true
 end

data/lib/pfrpg_core/attack.rb

@@ -0,0 +1,66 @@
+module PfrpgCore
+  class Attack
+    include Filterable
+
+    attr_accessor :weapon_name, :range, :damage, :weapon_type,
+                  :base_bonus, :weapon_bonus, :weight_class, :critical_range,
+                  :critical_dmg, :size, :weapon, :other_bonus, :filter_str,
+                  :strength_bonus, :bab, :macros
+
+    def initialize(args)
+      @weapon_name    = args[:weapon_name]
+      @range          = args[:range]
+      @weight_class   = args[:weight_class]
+      @damage         = args[:damage]
+      @weapon_type    = args[:weapon_type]
+      @critical_range = args[:critical_range]
+      @critical_dmg   = args[:critical_dmg]
+      @weapon_bonus   = args[:bonus] # bonus from weapon
+      @strength_bonus = args[:strength_bonus]
+      @bab            = args[:bab]
+      @size           = args[:size]
+      @filters        = args[:filters]
+      @filter_str     = []
+      @weapon         = args[:weapon]
+      @macros         = args[:macros]
+      @other_bonus    = 0 # things like weapon spec, training, etc
+      apply_filters
+    end
+
+    def attack_bonus
+      attacks = []
+      static_bonus = NullObject.maybe(weapon_bonus) +
+          NullObject.maybe(other_bonus) +
+          NullObject.maybe(strength_bonus)
+      base = NullObject.maybe(bab)
+      attacks << (static_bonus + base)
+      while(base >= 6)
+        base -= 5
+        attacks << (static_bonus + base)
+      end
+      return attacks
+    end
+
+    def as_json(options={})
+      {
+          :weapon_name  => @weapon_name,
+          :range        => @range,
+          :weight_class => @weight_class,
+          :damage       => get_damage.to_s,
+          :weapon_type  => @weapon_type,
+          :critical_range => @critical_range,
+          :critical_dmg => @critical_dmg,
+          :weapon_bonus => @weapon_bonus,
+          :strength_bonus   => @strength_bonus,
+          :other_bonus  => @other_bonus,
+          :attack_bonus => attack_bonus,
+          :filters      => filter_str,
+          :macros       => @macros.map { |m| m.as_json }
+      }
+    end
+
+    def get_damage
+      size == 'MEDIUM' ? damage.dmg_m : damage.dmg_s
+    end
+  end
+end

data/lib/pfrpg_core/attributes.rb

@@ -0,0 +1,113 @@
+module PfrpgCore
+  class Attributes
+
+    attr_accessor :raw_int, :raw_dex, :raw_str,
+                  :raw_con, :raw_wis, :raw_cha, :max_dex
+
+    def initialize(attributes,bonuses=Bonuses.new)
+      @raw_int = attributes[:raw_int]
+      @raw_con = attributes[:raw_con]
+      @raw_str = attributes[:raw_str]
+      @raw_wis = attributes[:raw_wis]
+      @raw_cha = attributes[:raw_cha]
+      @raw_dex = attributes[:raw_dex]
+      @max_dex = attributes[:max_dex] || 1000
+      @bonuses = bonuses
+    end
+
+    def set_bonuses(bonuses)
+      @bonuses = bonuses
+    end
+
+    def modified_int
+      get_modified('int')
+    end
+
+    def int_mod
+      get_modifier(modified_int)
+    end
+
+    def modified_dex
+      get_modified('dex')
+    end
+
+    def dex_mod
+      # TODO : feats let you overcome this
+      dex = get_modifier(modified_dex)
+      max = @max_dex
+      dex = max if (dex > max)
+      dex
+    end
+
+    def modified_str
+      get_modified('str')
+    end
+
+    def str_mod
+      get_modifier(modified_str)
+    end
+
+    def modified_con
+      get_modified('con')
+    end
+
+    def con_mod
+      get_modifier(modified_con)
+    end
+
+    def modified_cha
+      get_modified('cha')
+    end
+
+    def cha_mod
+      get_modifier(modified_cha)
+    end
+
+    def modified_wis
+      get_modified('wis')
+    end
+
+    def wis_mod
+      get_modifier(modified_wis)
+    end
+
+    def get_modified(attribute)
+      base = self.send("raw_#{attribute}") || 0
+      base += NullObject.maybe(@bonuses.get(attribute)).to_i
+      base
+    end
+
+    def get_modifier(val)
+      return ((val - 10) / 2.0).floor
+    end
+
+
+    def as_json(options={})
+      {
+          :values => {
+              :strength => modified_str,
+              :dexterity => modified_dex,
+              :charisma => modified_cha,
+              :wisdom => modified_wis,
+              :constitution => modified_con,
+              :intelligence => modified_int
+          },
+          :modifier => {
+              :strength => str_mod,
+              :dexterity => dex_mod,
+              :charisma => cha_mod,
+              :wisdom => wis_mod,
+              :constitution => con_mod,
+              :intelligence => int_mod
+          }
+      }
+    end
+
+    alias_method :constitution, :modified_con
+    alias_method :strength, :modified_str
+    alias_method :wisdom, :modified_wis
+    alias_method :intelligence, :modified_int
+    alias_method :dexterity, :modified_dex
+    alias_method :charisma, :modified_cha
+  end
+end

data/lib/pfrpg_core/avatar_url.rb

@@ -0,0 +1,15 @@
+class PfrpgCore::AvatarURL
+  attr_reader :avatar
+  def initialize(avatar)
+    @avatar = avatar
+  end
+
+  def as_json(options={})
+    {
+      default_url: avatar.url,
+      thumb_url: avatar.url(:thumb),
+      medium_url: avatar.url(:medium),
+      square_url: avatar.url(:square)
+    }
+  end
+end

data/lib/pfrpg_core/bonus.rb

@@ -5,4 +5,4 @@ module PfrpgCore
       NullObject.maybe(@bonuses.get(bonus))
     end
   end
-end
+end

data/lib/pfrpg_core/character.rb

@@ -0,0 +1,83 @@
+module PfrpgCore
+  class Character
+    include PfrpgCore::Bonus
+    include Derived::CombatBonuses
+    include Derived::Magic
+    include Derived::Misc
+
+    attr_accessor :levels, :class_features, :feats, :inventory, :base_skills,
+                  :spells, :attributes, :saves, :alignment, :race, :saves,
+                  :demographics, :character_id, :character_uuid, :avatar,
+                  :racial_bonuses, :latest_levels, :bonuses, :effects, :skills,
+                  :combat, :spellbooks
+
+    def initialize(params)
+      @character_uuid = params[:uuid]
+      @character_id   = params[:id]
+      # TODO: Refactor client to remove @character
+      # computed by calling objects
+      @character      = params[:character]
+      @avatar         = params[:avatar]
+      @demographics   = params[:demographics]
+      @race           = params[:race][:race]
+      @racial_bonuses = params[:race][:bonuses]
+      prime_bonuses_with_racial_stats
+      @attributes     = PfrpgCore::Attributes.new(params[:attributes], @bonuses)
+      @levels         = params[:levels][:latest].map { |x| PfrpgCore::Level.new(x) }
+      @latest_levels  = params[:levels][:latest]
+      @alignment      = params[:alignment]
+      @feats          = params[:feats]
+      @class_features = FeatureDuplicator.filter_duplicates(params[:features])
+      @inventory      = params[:inventory]
+      @base_skills    = params[:base_skills]
+      @spellbooks     = params[:spellbooks]
+      # uncomputable until bonuses are calculated
+      apply_bonuses
+      @attributes.set_bonuses(@bonuses)
+      @attributes.max_dex = self.get_max_dex_bonus
+      @saves          = SavingThrows.new(params[:saves], @bonuses, @attributes)
+      @combat         = PfrpgCore::Combat.new(self)
+      @skills         = PfrpgCore::Skills.new(self)
+      @spells         = PfrpgCore::SpellBooks.new(self)
+    end
+
+    def prime_bonuses_with_racial_stats
+      @bonuses = PfrpgCore::Bonuses.new
+      apply_effects(@racial_bonuses.map { |x| x.get_effects }.flatten)
+    end
+
+    def apply_bonuses
+      apply_effects(PfrpgCore::EffectTotaler.new(self).effects)
+    end
+
+    def apply_effects(effects)
+      e = PfrpgCore::EffectProcessor.new(self, effects)
+      e.process_effects.each do |effect|
+        effect.apply(self)
+      end
+    end
+
+    def name
+      @demographics.character_name
+    end
+
+    def as_json(options={})
+      p = {
+          :id           => @character_id,
+          :uuid         => @character_uuid,
+          :character    => @character,
+          :demographics => @demographics,
+          :attributes   => @attributes,
+          :combat       => @combat,
+          :saves        => @saves,
+          :misc         => misc_json,
+          :skills       => @skills,
+          :spells       => @spells,
+          :inventory    => @inventory
+      }
+      p[:avatar] = AvatarURL.new(@avatar) if @avatar
+      p
+    end
+
+  end
+end

data/lib/pfrpg_core/class_feature.rb

@@ -0,0 +1,31 @@
+module PfrpgCore
+  class ClassFeature
+    include PfrpgUtility::Affectable
+
+    attr_reader :name, :description, :effects, :category,
+                :special, :type, :attack_filter, :armor_filter,
+                :ability_name
+
+    def initialize(params)
+      @name         = params[:name]
+      @description  = params[:description]
+      @effects      = params[:effects]
+      @type         = params[:type]
+      @category     = params[:category]
+      @special      = params[:special]
+      @attack_filter= params[:attack_filter]
+      @armor_filter = params[:armor_filter]
+      @ability_name = params[:ability_name]
+    end
+
+    def as_json(options={})
+      {
+          name: @name,
+          description: @description,
+          type: @type,
+          category: @category,
+          name: @name
+      }
+    end
+  end
+end

data/lib/pfrpg_core/combat.rb

@@ -0,0 +1,60 @@
+module PfrpgCore
+  class Combat
+    include Derived::Defense
+    include Derived::Offense
+
+    attr_reader :character, :str_bonus, :dex_bonus, :bab,
+                :weapon_finesse, :size_modifier, :deflection_modifier, :dodge_modifier,
+                :armor_ac, :shield_ac, :natural_armor, :max_dex_bonus, :armor_check_penalty,
+                :damage_reduction, :spell_resistance, :armor_modifier
+
+    def initialize(character)
+      @character = character
+      @str_bonus = NullObject.maybe(character.attributes.str_mod)
+      @dex_bonus = NullObject.maybe(character.attributes.dex_mod)
+      @bab = NullObject.maybe(character.get_highest_attack_bonus)
+      @weapon_finesse = false
+      @dodge_modifier = NullObject.maybe(character.get_dodge_modifier)
+      @deflection_modifier = NullObject.maybe(character.get_deflection_modifier)
+      @armor_ac = NullObject.maybe(character.inventory.get_armor_ac)
+      @shield_ac = NullObject.maybe(character.inventory.get_shield_ac)
+      @natural_armor = NullObject.maybe(character.get_natural_armor)
+      @size_modifier = NullObject.maybe(character.get_size_modifier)
+      @armor_check_penalty = NullObject.maybe(character.get_ac_penalty)
+      @max_dex_bonus = NullObject.maybe(character.get_max_dex_bonus)
+      @spell_resistance = NullObject.maybe(character.get_spell_resistance)
+      @damage_reduction = NullObject.maybe(character.get_damage_reduction)
+      @armor_modifier = NullObject.maybe(character.get_armor_modifier)
+    end
+
+    def as_json(options={})
+      {
+          :str_bonus      => @str_bonus,
+          :dex_bonus      => @dex_bonus,
+          :bab            => @bab,
+          :weapon_finesse => @weapon_finesse,
+          :dodge_modifier => @dodge_modifier,
+          :armor_modifier => @armor_modifier,
+          :deflection_modifier => @deflection_modifier,
+          :armor_ac       => @armor_ac,
+          :shield_ac      => @shield_ac,
+          :natural_armor  => @natural_armor,
+          :size_modifier  => @size_modifier,
+          :armor_class    => armor_class,
+          :flat_footed_ac => flat_footed_ac,
+          :cmd            => combat_maneuver_defense,
+          :touch_ac       => touch_ac,
+          :spell_resistance => spell_resistance,
+          :damage_reduction => damage_reduction,
+          :attacks        => attacks,
+          :cmb            => combat_maneuver_bonus
+      }
+    end
+
+    private
+    def base_ac
+      10
+    end
+
+  end
+end

data/lib/pfrpg_core/demographics.rb

@@ -0,0 +1,30 @@
+module PfrpgCore
+  class Demographics
+    attr_reader :player_name, :character_name, :deity, :gender, :height, :weight,
+                :description, :languages
+
+    def initialize(params)
+      @player_name    = params[:player_name]
+      @character_name = params[:name]
+      @deity          = params[:deity]
+      @gender         = params[:gender]
+      @weight         = params[:weight]
+      @height         = params[:height]
+      @description    = params[:description]
+      @languages      = params[:languages]
+    end
+
+    def as_json(options={})
+      {
+          :player_name    => @player_name,
+          :character_name => @character_name,
+          :deity          => @deity,
+          :gender         => @gender,
+          :height         => @height,
+          :weight         => @weight,
+          :description    => @description,
+          :languages      => @languages
+      }
+    end
+  end
+end

data/lib/pfrpg_core/derived/combat_bonuses.rb

@@ -0,0 +1,78 @@
+module PfrpgCore
+  module Derived
+    module CombatBonuses
+      def get_dodge_modifier
+        get_bonus("dodge").to_i
+      end
+
+      def get_deflection_modifier
+        get_bonus("deflection").to_i
+      end
+
+      def get_armor_modifier
+        get_bonus("armor").to_i
+      end
+
+      def get_size_modifier
+        NullObject.maybe(@race).size_modifier
+      end
+
+      def get_natural_armor
+        get_bonus("natural_armor").to_i
+      end
+
+      def get_damage_reduction
+        get_bonus('damage_reduction')
+      end
+
+      def get_spell_resistance
+        get_bonus('spell_resistance')
+      end
+
+      def get_max_dex_bonus
+        max_dex_bonus = 100
+        any_max = false
+        @inventory.equipment.each do |e|
+          if (e.max_dex_bonus != nil) && (e.max_dex_bonus < max_dex_bonus)
+            any_max = true
+            max_dex_bonus = e.max_dex_bonus
+          end
+        end
+        max_dex_bonus += get_bonus("max_dex_bonus").to_i
+        max_dex_bonus
+      end
+
+      # the accurate BAB for a character is the sum of the highest
+      # granted bonuses from each class
+      # this method is NOT concerned with generating multi-attack bonuses
+      def get_highest_attack_bonus
+        bab = 0
+        latest_levels.each do |l|
+          bab += l.base_attack_bonus[0]
+        end
+        bab
+        return bab
+      end
+
+      def armor_speed_penalty
+        begin
+          return 0 if race.name == 'Dwarf'
+          return (race.speed == 30) ? (30 - @inventory.equipped_armor.speed_thirty) :
+              (20 - @inventory.equipped_armor.speed_twenty)
+        rescue Exception
+          return 0
+        end
+      end
+
+      def get_ac_penalty
+        @inventory.ac_penalty(self.bonuses)
+      end
+
+      def get_attack_filters
+        base = class_features.select { |x| x.attack_filter != nil }
+        filter_classes = base.collect { |x| [x,x.attack_filter] }
+        filter_classes.map { |x| x[1].new(self,x[0])}
+      end
+    end
+  end
+end

data/lib/pfrpg_core/derived/defense.rb

@@ -0,0 +1,29 @@
+module PfrpgCore
+  module Derived
+    module Defense
+      def armor_class
+        base_ac + dodge_modifier + deflection_modifier + armor_ac + shield_ac + natural_armor + size_modifier + dex_bonus + armor_modifier
+      end
+
+      def flat_footed_ac
+        base_ac + deflection_modifier + armor_ac + shield_ac + natural_armor + size_modifier
+      end
+
+      def combat_maneuver_defense
+        base_ac + str_bonus + dex_bonus + dodge_modifier + deflection_modifier + bab - size_modifier
+      end
+
+      def touch_ac
+        base_ac + dex_bonus + dodge_modifier + deflection_modifier + size_modifier
+      end
+
+      def spell_resistance
+        spell_resistance
+      end
+
+      def damage_reduction
+        damage_reduction
+      end
+    end
+  end
+end