pfrpg_readers 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4885ad49ec886cd2e8d960b8f97010033e3d4441
+  data.tar.gz: 1d3d76f37dfac171e966bb099cb96479b77a64e0
+SHA512:
+  metadata.gz: e8b81723f671480ffc70a1d5ff87ea4e8619bbfb4d76d25b6138bf8edbb17202600b3cab8abff3caa715d7958aa44f97b53831583008f138c540ca5332f1ca32
+  data.tar.gz: b62737180c42527a8ddd7cdba4068ae2e37bd36af3e25c2be5e218284cfc33009d3b3ff556f6f5a9ed72e6b1226a1e6b19eeca67d27fb587d169e3cb9a8cde3e

data/lib/pfrpg_readers.rb

@@ -0,0 +1,8 @@
+require 'pfrpg_readers/defensible'
+
+Dir[File.expand_path(File.join(File.dirname(File.absolute_path(__FILE__)), 'pfrpg_readers/')) + "/**/*.rb"].each do |file|
+  require file
+end
+
+module PfrpgReaders
+end

data/lib/pfrpg_readers/attack.rb

@@ -0,0 +1,64 @@
+module PfrpgReaders
+  class Attack
+    include PfrpgCore::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
+
+    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]
+      @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
+      }
+    end
+
+    def get_damage
+      size == 'MEDIUM' ? damage.dmg_m : damage.dmg_s
+    end
+  end
+end

data/lib/pfrpg_readers/attackable.rb

@@ -0,0 +1,47 @@
+require_relative 'filters/filter.rb'
+
+module PfrpgReaders
+  module Attackable
+    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 = [
+        Filters::StrengthMod.new(character),
+        Filters::WeaponFinesseMod.new(character),
+        Filters::RangedAttackMod.new(character),
+        Filters::WeaponFocusMod.new(character),
+        Filters::WeaponSpecializationMod.new(character),
+        Filters::ProficiencyMod.new(character)
+      ]
+      standard_filters << character.get_attack_filters
+      standard_filters.flatten
+    end
+
+    def attacks
+      atk = []
+      character.equipped_weapons.each do |w|
+        atk << 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
+                       })
+      end
+      return atk
+    end
+  end
+end

data/lib/pfrpg_readers/attributes_reader.rb

@@ -0,0 +1,76 @@
+class PfrpgReaders::AttributesReader
+  attr_reader :character
+
+  def initialize(character)
+    @character = character
+  end
+
+  def as_json(options={})
+    {
+      :values => {
+        :strength => strength,
+        :dexterity => dexterity,
+        :charisma => charisma,
+        :wisdom => wisdom,
+        :constitution => constitution,
+        :intelligence => intelligence
+      },
+      :modifier => {
+        :strength => strength_modifier,
+        :dexterity => dexterity_modifier,
+        :charisma => charisma_modifier,
+        :wisdom => wisdom_modifier,
+        :constitution => constitution_modifier,
+        :intelligence => intelligence_modifier
+      }
+    }
+  end
+
+  def strength
+    @character.modified_str
+  end
+
+  def strength_modifier
+    @character.str_mod
+  end
+
+  def dexterity
+    @character.modified_dex
+  end
+
+  def dexterity_modifier
+   @character.dex_mod
+  end
+
+  def charisma
+    @character.modified_cha
+  end
+
+  def charisma_modifier
+    @character.cha_mod
+  end
+
+  def intelligence
+    @character.modified_int
+  end
+
+  def intelligence_modifier
+    @character.int_mod
+  end
+
+  def wisdom
+    @character.modified_wis
+  end
+
+  def wisdom_modifier
+    @character.wis_mod
+  end
+
+  def constitution
+    @character.modified_con
+  end
+
+  def constitution_modifier
+    @character.con_mod
+  end
+end

data/lib/pfrpg_readers/avatar_url.rb

@@ -0,0 +1,15 @@
+class PfrpgReaders::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_readers/combat_reader.rb

@@ -0,0 +1,60 @@
+module PfrpgReaders
+  class CombatReader
+    include PfrpgReaders::Defensible
+    include PfrpgReaders::Attackable
+
+    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.str_mod)
+      @dex_bonus = NullObject.maybe(character.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.get_armor_ac)
+      @shield_ac = NullObject.maybe(character.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_readers/defensible.rb

@@ -0,0 +1,27 @@
+module PfrpgReaders
+  module Defensible
+    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

data/lib/pfrpg_readers/demographics_reader.rb

@@ -0,0 +1,21 @@
+class PfrpgReaders::DemographicsReader
+  attr_reader :player_name, :character_name, :deity, :gender
+
+  def initialize(character)
+    if @character.respond_to? 'player_name'
+      @player_name    = character.player_name
+    end
+    @character_name = character.name
+    @deity          = character.deity
+    @gender         = character.gender
+  end
+
+  def as_json(options={})
+    {
+      :player_name    => @player_name,
+      :character_name => @character_name,
+      :deity          => @deity,
+      :gender         => @gender
+    }
+  end
+end

data/lib/pfrpg_readers/feature_duplicator.rb

@@ -0,0 +1,26 @@
+module FeatureDuplicator
+
+  def dupe_words
+    ['Sneak Attack', 'Channel Energy', 'Damage Reduction', 'Trap Sense']
+  end
+
+  # filter things with multiple bonuses, like sneak attack and channel energy
+  def filter_duplicates(features)
+    dupe_words.each do |w|
+      features = features - smallest(features, w)
+    end
+    features
+  end
+
+  def 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 parse_number(description)
+    (description.split('d6')[0].split(' ').last.split('(')[1]).to_i
+  end
+end

data/lib/pfrpg_readers/filters/filter.rb

@@ -0,0 +1,11 @@
+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 './weapon_focus_mod.rb'
+
+module PfrpgReaders
+  module Filters
+  end
+end

data/lib/pfrpg_readers/filters/proficiency_mod.rb

@@ -0,0 +1,34 @@
+module PfrpgReaders
+  module Filters
+    class ProficiencyMod
+      attr_reader :character
+      def initialize(character)
+        @character = character
+      end
+
+      def filter(attack)
+        proficiency = Specializer.new(character)
+        unless proficiency.is_proficient_in_weapon? attack.weapon
+          modify_for_weapon(attack)
+        end
+        armor = character.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_readers/filters/ranged_attack_mod.rb

@@ -0,0 +1,28 @@
+module PfrpgReaders
+  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.dex_mod, character.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

data/lib/pfrpg_readers/filters/skill_focus_mod.rb

@@ -0,0 +1,25 @@
+module PfrpgReaders
+  module Filters
+    class SkillFocusMod
+      attr_reader :character
+      def initialize(character)
+        @character = character
+      end
+
+      def filter(skill)
+        prof_feats = character.char_feats.select { |x| x.pathfinder_feat.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_readers/filters/strength_mod.rb

@@ -0,0 +1,21 @@
+module PfrpgReaders
+  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.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_readers/filters/weapon_finesse_mod.rb

@@ -0,0 +1,24 @@
+module PfrpgReaders
+  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.dex_mod, character.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_readers/filters/weapon_focus_mod.rb

@@ -0,0 +1,23 @@
+module PfrpgReaders
+  module Filters
+    class WeaponFocusMod
+      attr_reader :character
+      def initialize(character)
+        @character = character
+      end
+
+      def filter(attack)
+        f = character.char_feats.find { |x| x.pathfinder_feat.name == 'Weapon Focus' }
+        if f != nil && (attack.weapon.name.downcase == f.feat_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_readers/filters/weapon_mastery_mod.rb

@@ -0,0 +1,24 @@
+class PfrpgReaders::WeaponMasteryMod
+  attr_reader :character, :feature
+  def initialize(character, feature)
+    @character = character
+    @feature   = feature
+  end
+
+  def filter(attack)
+    if attack.weapon.name == @feature.weapon_type
+      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_readers/filters/weapon_specialization_mod.rb

@@ -0,0 +1,22 @@
+module PfrpgReaders
+  module Filters
+    class WeaponSpecializationMod
+      attr_reader :character
+      def initialize(character)
+        @character = character
+      end
+
+      def filter(attack)
+        f = character.char_feats.find { |x| x.pathfinder_feat.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_readers/filters/weapon_training_mod.rb

@@ -0,0 +1,22 @@
+module PfrpgReaders
+  module Filters
+    class WeaponTrainingMod
+      attr_reader :character, :feature
+      def initialize(character, feature)
+        @character = character
+        @feature   = feature
+      end
+
+      def filter(attack)
+        trainer = Cheesewhiz.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_readers/inventory_reader.rb

@@ -0,0 +1,39 @@
+class PfrpgReaders::InventoryReader
+
+  attr_reader :inventory, :equipment
+  def initialize(character)
+    @character = character
+    @inventory = get_inventory
+    @equipment = get_equipment
+  end
+
+  def get_inventory
+    @character.inventory
+  end
+
+  def get_equipment
+    @character.equipment
+  end
+
+  def pretty(items)
+    items.map { |i| PrettyItem.new(i) }
+  end
+
+  def as_json(options={})
+    {
+      :equipment    => get_equipment,
+      :inventory    => get_inventory
+    }
+  end
+end
+
+class PfrpgReaders::PrettyItem
+  attr_reader :name, :description, :slot, :type, :equipped
+
+  def initialize(item)
+    @name         = item.name
+    @description  = item.description
+    @slot         = item.slot
+    @type         = item.type
+  end
+end

data/lib/pfrpg_readers/misc_reader.rb

@@ -0,0 +1,156 @@
+module PfrpgReaders
+  class MiscReader
+    include FeatureDuplicator
+    attr_reader :initiative, :speed, :hit_points, :feats, :class_features, :levels,
+                :total_level, :alignment, :languages, :size
+    def initialize(character)
+      @character      = character
+      @initiative     = gen_initiative
+      @speed          = gen_speed
+      @feats          = gen_feats
+      @class_features = gen_class_features
+      @levels         = gen_levels
+      @total_level    = gen_total_level
+      @hit_points     = gen_hit_points
+      @alignment      = character.alignment
+      @size           = character.racial_size
+    end
+
+    def as_json(options={})
+      {
+        :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
+
+    def level_string
+      str = "#{alignment} :"
+      @levels.each do |l|
+        str += "#{l.name}/#{l.level}"
+        str += "*" if l.favored
+      end
+      str
+    end
+
+    def gen_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 gen_total_level
+      if @character.respond_to? 'get_last_level'
+        return 0 if @character.levels.empty?
+        return @character.get_last_level.number
+      end
+      @character.latest_levels.inject(0) {|sum, x| sum = sum + x.class_number }
+    end
+
+    def gen_speed
+      base_speed =  NullObject.maybe(@character.race).speed || 0
+      base_speed += parse_speed_bonuses(@character.get_bonus("speed"))
+      base_speed -= @character.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 + @character.get_bonus("#{speed_type}_speed")
+    end
+
+    def gen_initiative
+      initiative = 0
+      initiative += @character.dex_mod
+      initiative += @character.get_bonus("initiative").to_i
+      return initiative
+    end
+
+    def gen_feats
+      @character.total_feats.map { |x| PrettyFeat.new(x) }
+    end
+
+    def gen_class_features
+      features = @character.class_features.map { |x| PrettyClassFeature.new(x) }
+      filter_duplicates(features)
+    end
+
+    def gen_levels
+      @character.latest_levels.map { |x| PrettyLevel.new(x, @character) }
+    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
+
+
+  end
+
+  class MiscReader::PrettyFeat
+    attr_reader :name, :description, :special
+    def initialize(char_feat)
+      if char_feat.respond_to? 'pathfinder_feat'
+        feat = NullObject.maybe(char_feat.pathfinder_feat)
+      else
+        feat = NullObject.maybe(char_feat.feat)
+      end
+      @name        = feat.name || "Feat"
+      if (@name == 'Custom Feat')
+        @description = char_feat.feat_special
+      else
+        @description = feat.benefit
+        @special     = char_feat.feat_special
+      end
+    end
+  end
+
+  class MiscReader::PrettyLevel
+    attr_reader :name, :level, :favored
+    def initialize(level, character)
+      @name     = level.class_name
+      @level    = level.class_number
+      if character.respond_to? 'preferred_class'
+        @favored  = (level.class_name == character.preferred_class)
+      end
+    end
+  end
+
+  class MiscReader::PrettyClassFeature
+    attr_reader :name, :description, :type
+    def initialize(feature)
+      if feature.respond_to? 'feature'
+        f = feature.feature
+      else
+        f = feature
+      end
+      # TODO this belogns on the feature object
+      @type         = feature.feature_type
+      @category     = f.category
+      @name         = f.display_name
+      @description  = f.description
+      @special = feature.special
+    end
+  end
+end

data/lib/pfrpg_readers/pfrpg_character.rb

@@ -0,0 +1,41 @@
+module PfrpgReaders
+  class PFRPGCharacter
+    attr_reader :character, :attributes, :feats, :skills, :spells, :combat, :misc,
+                :inventory, :avatar
+
+    def initialize(character)
+      @character    = character
+      @attributes   = AttributesReader.new(character)
+      @demographics = DemographicsReader.new(character)
+      @combat       = CombatReader.new(character)
+      @saves        = SavesReader.new(character)
+      @misc         = MiscReader.new(character)
+      @skills       = SkillsReader.new(character)
+      @inventory    = InventoryReader.new(character)
+      @spells       = SpellsReader.new(character)
+      @avatar       = character.avatar if character.respond_to? 'avatar'
+    end
+
+    def as_json(options={})
+     p = {
+        :id         => @character.id,
+        :uuid         => @character.uuid,
+        :character  => @character,
+        :demographics => @demographics,
+        :attributes => @attributes,
+        :combat     => @combat,
+        :saves      => @saves,
+        :misc       => @misc,
+        :skills     => @skills,
+        :spells     => @spells,
+        :inventory  => @inventory
+      }
+      p[:avatar] = AvatarURL.new(@avatar) if @avatar
+      p
+    end
+
+    def find_by_id(id)
+      Character.find(id)
+    end
+  end
+end

data/lib/pfrpg_readers/pfrpg_npc.rb

@@ -0,0 +1,40 @@
+module PfrpgReaders
+  module PfrpgReaders
+    class PfrpgNpc
+      attr_reader :npc, :attributes, :feats, :skills, :spells, :combat, :misc,
+                  :inventory, :avatar
+
+      def initialize(npc)
+        @npc    = npc
+        @attributes   = AttributesReader.new(npc)
+        @demographics = DemographicsReader.new(npc)
+        @combat       = CombatReader.new(npc)
+        @saves        = SavesReader.new(npc)
+        @misc         = MiscReader.new(npc)
+        @skills       = SkillsReader.new(npc)
+        @inventory    = InventoryReader.new(npc)
+        @spells       = SpellsReader.new(npc)
+        @validation   = ValidationReader.new(npc)
+        @avatar       = npc.avatar
+      end
+
+      def as_json(options={})
+        {
+          :id         => @npc.id,
+          :uuid       => @npc.uuid,
+          :npc        => @npc,
+          :demographics => @demographics,
+          :attributes => @attributes,
+          :combat     => @combat,
+          :saves      => @saves,
+          :misc       => @misc,
+          :skills     => @skills,
+          :spells     => @spells,
+          :inventory  => @inventory,
+          :validation => @validation,
+          :avatar     => AvatarURL.new(@avatar)
+        }
+      end
+    end
+  end
+end

data/lib/pfrpg_readers/saves_reader.rb

@@ -0,0 +1,42 @@
+class PfrpgReaders::SavesReader
+  attr_reader :character, :con_modifier, :dex_modifier, :wis_modifier,
+              :saves, :bonuses
+  def initialize(character)
+    @character    = character
+    @con_modifier = character.con_mod
+    @wis_modifier = character.wis_mod
+    @dex_modifier = character.dex_mod
+    @saves        = character.get_saves
+    @bonuses      = character.get_save_bonuses
+  end
+
+  def as_json(options={})
+    {
+      :con_modifier => @con_modifier,
+      :wis_modifier => @wis_modifier,
+      :dex_modifier => @dex_modifier,
+      :base_ref     => @saves[:ref],
+      :base_fort    => @saves[:fort],
+      :base_will    => @saves[:will],
+      :bonus_ref    => @bonuses[:ref],
+      :bonus_will   => @bonuses[:will],
+      :bonus_fort   => @bonuses[:fort],
+      :fortitude    => fortitude,
+      :reflex       => reflex,
+      :will         => will
+    }
+  end
+
+  def fortitude
+    con_modifier + saves[:fort] + bonuses[:fort]
+  end
+
+  def reflex
+    dex_modifier + saves[:ref] + bonuses[:ref]
+  end
+
+  def will
+    wis_modifier + saves[:will] + bonuses[:will]
+  end
+end
+

data/lib/pfrpg_readers/skills_reader.rb

@@ -0,0 +1,115 @@
+module PfrpgReaders
+  class SkillsReader
+    attr_reader :skills
+    def initialize(character)
+      @character = character
+      @skills    = gen_skills
+    end
+
+    def skill_filters
+      [
+        Filters::SkillFocusMod.new(@character)
+      ]
+    end
+
+    def gen_skills
+      @character.get_all_skills.map { |x| PrettySkill.new(x, @character, skill_filters) }
+    end
+
+    def as_json(options={})
+      skillz = {}
+      skills.each do |s|
+        skillz[s.name] = s
+      end
+      skillz
+    end
+  end
+
+  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
+      @trained_rank  = skill[:char_skill]['trained_rank']
+      @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.latest_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 && found)
+    end
+
+    def class_skill_bonuses(character)
+      bonuses = character.get_bonus("class_skill")
+      bonuses ||= []
+      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
+      bonus = character.send("#{attribute}_mod")
+      bonus ||= 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"
+        misc = character.get_bonus(skill[:skill].bonus_str).to_i
+      else
+        misc = character.get_bonus(skill[:skill].description).to_i
+      end
+      misc ||= 0
+    end
+
+  end
+end

data/lib/pfrpg_readers/spells_reader.rb

@@ -0,0 +1,51 @@
+class PfrpgReaders::SpellsReader
+  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

data/lib/pfrpg_readers/validation_reader.rb

@@ -0,0 +1,32 @@
+module PfrpgReaders
+  class ValidationReader
+    attr_reader :feats, :skills, :features
+    def initialize(entity)
+      @entity = entity
+      @feats = feat_total
+      @skills = skill_total
+      @features = feature_total
+    end
+
+    def feat_total
+      return PfrpgTables::FeatTotaler.new(entity).total
+    end
+
+    def skill_total
+      0
+    end
+
+    def feature_total
+      0
+    end
+
+    def as_json(options = {})
+      {
+        :feats => @feats,
+        :skills => @skills,
+        :features => @features
+      }
+    end
+
+  end
+end

data/lib/pfrpg_readers/version.rb

@@ -0,0 +1,3 @@
+module PfrpgReaders
+  VERSION = "0.0.1"
+end

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification
+name: pfrpg_readers
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Jordan OMara
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-11-11 00:00:00.000000000 Z
+dependencies: []
+description: readers
+email:
+- jordan@herosheets.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/pfrpg_readers.rb
+- lib/pfrpg_readers/attack.rb
+- lib/pfrpg_readers/attackable.rb
+- lib/pfrpg_readers/attributes_reader.rb
+- lib/pfrpg_readers/avatar_url.rb
+- lib/pfrpg_readers/combat_reader.rb
+- lib/pfrpg_readers/defensible.rb
+- lib/pfrpg_readers/demographics_reader.rb
+- lib/pfrpg_readers/feature_duplicator.rb
+- lib/pfrpg_readers/filters/filter.rb
+- lib/pfrpg_readers/filters/proficiency_mod.rb
+- lib/pfrpg_readers/filters/ranged_attack_mod.rb
+- lib/pfrpg_readers/filters/skill_focus_mod.rb
+- lib/pfrpg_readers/filters/strength_mod.rb
+- lib/pfrpg_readers/filters/weapon_finesse_mod.rb
+- lib/pfrpg_readers/filters/weapon_focus_mod.rb
+- lib/pfrpg_readers/filters/weapon_mastery_mod.rb
+- lib/pfrpg_readers/filters/weapon_specialization_mod.rb
+- lib/pfrpg_readers/filters/weapon_training_mod.rb
+- lib/pfrpg_readers/inventory_reader.rb
+- lib/pfrpg_readers/misc_reader.rb
+- lib/pfrpg_readers/pfrpg_character.rb
+- lib/pfrpg_readers/pfrpg_npc.rb
+- lib/pfrpg_readers/saves_reader.rb
+- lib/pfrpg_readers/skills_reader.rb
+- lib/pfrpg_readers/spells_reader.rb
+- lib/pfrpg_readers/validation_reader.rb
+- lib/pfrpg_readers/version.rb
+homepage: http://herosheets.com
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: PFRPG readers
+test_files: []