pfrpg_core 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 04e10d025ab0c0eabc6af56107b277194255e478
+  data.tar.gz: 7c2dfb7e770d7399d495ab5eae8aaedabcd97adc
+SHA512:
+  metadata.gz: 5f755c54bebcc8ede1c1cdcd7c5aa094b00de3f63e3e46d7cec2f40d6c97f7538fb5af38d6bfee79fc6763ef39c8e014c8e912536cb72bbcf479681f7ba85e97
+  data.tar.gz: a69a83f0f8d0e08596b5f2f49cd2fa94475862194449c6ba6d5af2765eff2c5ad1aed2b896866a7ff1e5f9623cc1370be5a36a3f765005951b78857605f31adb

data/Rakefile

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

data/lib/pfrpg_core/affectable.rb

@@ -0,0 +1,7 @@
+module PfrpgCore
+  module Affectable
+    def get_effects
+      Effect.load(effects)
+    end
+  end
+end

data/lib/pfrpg_core/bonus.rb

@@ -0,0 +1,8 @@
+module PfrpgCore
+  module Bonus
+    def get_bonus(bonus)
+      apply_bonuses if @bonuses == nil
+      NullObject.maybe(@bonuses.get(bonus))
+    end
+  end
+end

data/lib/pfrpg_core/bonuses.rb

@@ -0,0 +1,57 @@
+module PfrpgCore
+  class Bonuses
+    attr_reader :bonus_pool
+    def initialize
+      @bonus_pool = {}
+    end
+
+    def specials
+      ['speed', 'damage_reduction', 'spell_resistance', 'class_skill']
+    end
+
+    def get(key)
+      if specials.include? key
+        return self.send(key)
+      else
+        return NullObject.maybe(@bonus_pool[key])
+      end
+    end
+
+    def plus(key, value)
+      begin
+        v = MathHelper.is_number(value) ? value.to_i : value
+        if specials.include? key
+          if @bonus_pool[key]
+            @bonus_pool[key] << value
+          else
+            @bonus_pool[key] = [value]
+          end
+        elsif @bonus_pool[key]
+          @bonus_pool[key] += v
+        else
+          @bonus_pool[key] = v
+        end
+      rescue Exception => e
+        ap @bonus_pool
+        ap "Trying to add #{key}, #{value}"
+      end
+    end
+
+    def speed
+      [ @bonus_pool['speed'] ].flatten
+    end
+
+    def class_skill
+      [ @bonus_pool['class_skill'] ].flatten
+    end
+
+    def damage_reduction
+      [ @bonus_pool['damage_reduction'] ].flatten
+    end
+
+    def spell_resistance
+      [ @bonus_pool['spell_resistance'] ].flatten
+    end
+
+  end
+end

data/lib/pfrpg_core/effect.rb

@@ -0,0 +1,39 @@
+class PfrpgCore::Effect
+  attr_accessor :type, :key, :value, :affect
+  def initialize(type, key, value, affect=nil)
+    # standard effect proc; add a value
+    basic = Proc.new do |character, attribute, value|
+      character.bonuses.plus(attribute, value)
+    end
+    affect ||= basic
+    @type   = type
+    @key    = key
+    @value  = value
+    @affect = affect
+  end
+
+  def self.load(effects_string)
+    return effects_string if effects_string.instance_of? Array
+    return [ effects_string ] if effects_string.instance_of? PfrpgCore::Effect
+    return [] if effects_string.nil? || effects_string.empty?
+    unless effects_string.instance_of? String
+      ap "Error effect: "
+      ap effects_string
+    end
+    raise Exception unless effects_string.instance_of? String
+    effects_string.split(";").map { |effect| parse_effect(effect) }
+  end
+
+  def self.parse_effect(string)
+    p = string.split(":")
+    type    = p[0]
+    key     = p[1]
+    value   = p[2]
+    PfrpgCore::Effect.new(type, key, value)
+  end
+
+  def apply(character)
+    @affect.call(character, @key, @value)
+  end
+
+end

data/lib/pfrpg_core/effect_processor.rb

@@ -0,0 +1,49 @@
+module PfrpgCore
+  class EffectProcessor
+    attr_reader :character, :effects
+    def initialize(character, effects)
+      @character = character
+      @effects = effects
+    end
+
+    def process_effects
+      final = []
+      no_stacking = effects_hash(@effects)
+      no_stacking.keys.each do |key|
+        if Tables::Bonus.stackable?(key) || Tables::Bonus.special?(key)
+          final << no_stacking[key]
+        else
+          final << find_max(no_stacking[key])
+        end
+      end
+      return final.flatten
+    end
+
+    def effects_hash(effects)
+      hash = {}
+      effects.each do |effect|
+        if hash[effect.key] == nil
+          hash[effect.key] = []
+        end
+        hash[effect.key] << effect
+      end
+      hash
+    end
+
+    def find_max(effects)
+      max = nil
+      effects.each do |e|
+        if max == nil || is_larger(e.value, max.value)
+          max = e
+        end
+      end
+      return max
+    end
+
+    def is_larger(a, b)
+      int_a = MathHelper.is_number(a) ? a.to_i : -999
+      int_b = MathHelper.is_number(b) ? b.to_i : -999
+      int_a > int_b
+    end
+  end
+end

data/lib/pfrpg_core/feat_finder.rb

@@ -0,0 +1,49 @@
+module PfrpgCore
+  class FeatFinder
+    attr_reader :entity, :feats
+    def initialize(entity, feats)
+      @entity = entity
+      @feats = feats
+    end
+
+    def find_feats
+      feats = @feats
+      feats = filter_feats_by_owned(feats, entity)
+      feats = filter_feats_by_prereq(feats, entity)
+      return feats
+    end
+
+    def filter_feats_by_owned(feats, entity)
+      owned_feats = entity.feats
+      feats.select do |f|
+          repeat_list.include?(f.name) ||
+          doesnt_include_feat(owned_feats, f)
+      end
+    end
+
+    def doesnt_include_feat(feats, feat)
+      !(feats.find { |x| x.name == feat.name })
+    end
+
+    def filter_feats_by_prereq(feats, entity)
+      feats.select do |f|
+        prereq_check(entity, f)
+      end
+    end
+
+    def prereq_check(entity, feat)
+      prereqs = Prerequisite.load(feat.prereq_code)
+      prereqs.all? { |x| x.match(entity) }
+    end
+
+    def repeat_list
+      [
+        'Exotic Weapon Proficiency',
+        'Martial Weapon Proficiency',
+        'Weapon Focus',
+        'Spell Focus',
+        'Custom Feat'
+      ]
+    end
+  end
+end

data/lib/pfrpg_core/filterable.rb

@@ -0,0 +1,11 @@
+module PfrpgCore::Filterable
+  def apply_filters
+    @filters.each do |f|
+      begin
+        self.filter_str << "Filtering #{f.class}"
+        f.filter(self)
+      rescue Exception => e
+      end
+    end
+  end
+end

data/lib/pfrpg_core/level_parser.rb

@@ -0,0 +1,34 @@
+module PfrpgCore
+  class LevelParser
+    attr_reader :level_string, :levels
+    def initialize(level_string)
+      @level_string = level_string
+      @levels = parse
+    end
+
+    def total
+      return @levels.values.inject(0) { |sum, l| sum + l }
+    end
+
+    def parse
+      levels = {}
+      splits = @level_string.split(';')
+      raise Exception if splits[0].empty?
+
+      splits.each do |s|
+        level = s.split(':')[1].to_i
+        hc = s.split(':')[0]
+        raise Exception if (hc.empty?)
+        levels[hc] = level
+      end
+      return levels
+    end
+
+    def valid_total_level
+      return total <= 20
+    rescue Exception
+      return false
+    end
+
+  end
+end

data/lib/pfrpg_core/math_helper.rb

@@ -0,0 +1,6 @@
+class PfrpgCore::MathHelper
+  def self.is_number(s)
+    s.to_s.match(/\A[+-]?\d+?(\.\d+)?\Z/) == nil ? false : true
+  end
+
+end

data/lib/pfrpg_core/null_object.rb

@@ -0,0 +1,37 @@
+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
+
+  def empty?
+    true
+  end
+
+  def as_json(options={})
+    ""
+  end
+
+  def method_missing(*args, &block)
+    self
+  end
+
+  def self.maybe(value)
+    case value
+    when nil then NullObject.new
+    else value
+    end
+  end
+
+  def +(other)
+    case other
+    when String
+      to_s + other
+    when Fixnum
+     to_i + other
+    when Float
+     to_f + other
+    end
+  end
+end

data/lib/pfrpg_core/prerequisite.rb

@@ -0,0 +1,58 @@
+module PfrpgCore
+  class Prerequisite
+
+    def initialize(attribute, value, matcher=nil)
+      default_matcher = Proc.new do |character, attribute, value|
+        true
+      end
+      @attribute = attribute
+      @value     = value
+      @matcher   = matcher || default_matcher
+    end
+
+    def self.load(prereq_string)
+      begin
+        prereqs = []
+        p = prereq_string.split(";")
+        p.each { |x| prereqs << parse_prereq(x) }
+        prereqs
+      rescue Exception
+        []
+      end
+    end
+
+    def self.parse_prereq(string)
+      p = string.split(":")
+      type = p[0]
+      attribute = p[1]
+      value = p[2]
+      case type
+      when "class"
+        Prerequisite::ClassPrereq.new(attribute, value)
+      when "attribute"
+        Prerequisite::AttributePrereq.new(attribute, value)
+      when "alignment"
+        Prerequisite::AlignmentPrereq.new(attribute, value)
+      when "feat"
+        Prerequisite::FeatPrereq.new(attribute, value)
+      when "skill"
+        Prerequisite::SkillPrereq.new(attribute, value)
+      when "class_feature"
+        Prerequisite::HeroclassFeaturePrereq.new(attribute, value)
+      when "combat"
+        Prerequisite::BabPrereq.new(attribute, value)
+      when "language"
+        Prerequisite::LanguagePrereq.new(attribute, value)
+      when "misc"
+        Prerequisite::MiscPrereq.new(attribute, value)
+      else
+        Prerequisite.new(attribute, value)
+      end
+    end
+
+    def match(character)
+      @matcher.call(character, @attribute, @value)
+    end
+
+  end
+end

data/lib/pfrpg_core/quick_classed.rb

@@ -0,0 +1,37 @@
+# basic class math. classes must provide latest_levels method
+# with a map of heroclass name & level
+module PfrpgCore
+  module QuickClassed
+    def get_class_level(heroclass)
+      l = latest_levels[heroclass.name]
+      l ||= 0
+      return l
+    end
+
+    def explode_levels
+      # TODO: implement me
+      []
+    end
+
+    def get_total_level
+      latest_levels.keys.inject(0) do |key, sum|
+        sum = sum + latest_levels[key]
+      end
+    end
+
+    def hit_dice
+      get_total_level
+    end
+
+    def get_caster_level
+      # TODO constantize somewhere better
+      caster_classes = ['Bard', 'Cleric', 'Druid', 'Paladin', 'Ranger', 'Sorcerer', 'Wizard']
+      caster_levels = []
+      latest_levels.keys.each do |key|
+        caster_levels << latest_levels[key] if caster_classes.include? key
+      end
+      ek_level = get_class_level(Heroclass.by_name('Eldritch Knight'))
+      return (caster_levels.max + ek_level) || 0
+    end
+  end
+end

data/lib/pfrpg_core/version.rb

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

data/lib/pfrpg_core.rb

@@ -0,0 +1,11 @@
+require 'pfrpg_core/effect'
+require 'pfrpg_core/effect_processor'
+require 'pfrpg_core/math_helper'
+require 'pfrpg_core/null_object'
+
+Dir[File.expand_path(File.join(File.dirname(File.absolute_path(__FILE__)), 'pfrpg_core/')) + "/**/*.rb"].each do |file|
+  require file
+end
+
+module PfrpgCore
+end

data/test/feat_totaler_test.rb

@@ -0,0 +1,14 @@
+require 'minitest/autorun'
+require 'test/helper'
+
+class FeatFinderTest < Minitest::Test
+
+  def test_filter_feats_by_owned
+    e = PsuedoEntity.new
+    feats = [ PsuedoFeat.new('Feat1') ]
+    finder = FeatFinder.new(e, feats)
+    assert finder.find_feats.empty?
+  end
+
+
+end

data/test/helper.rb

@@ -0,0 +1,20 @@
+class Helper
+
+  PsuedoFeat = Struct.new(:name) do
+    def prereq_code
+      nil
+    end
+  end
+
+  class PsuedoEntity
+    attr_accessor :feats
+    def initialize(feats = nil)
+      @feats = feats
+      @feats ||= default_feats
+    end
+
+    def default_feats
+      [ PsuedoFeat.new('Feat1') ]
+    end
+  end
+end

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification
+name: pfrpg_core
+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:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.1.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.1.1
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: core
+email:
+- jordan@herosheets.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Rakefile
+- lib/pfrpg_core.rb
+- lib/pfrpg_core/affectable.rb
+- lib/pfrpg_core/bonus.rb
+- lib/pfrpg_core/bonuses.rb
+- lib/pfrpg_core/effect.rb
+- lib/pfrpg_core/effect_processor.rb
+- lib/pfrpg_core/feat_finder.rb
+- lib/pfrpg_core/filterable.rb
+- lib/pfrpg_core/level_parser.rb
+- lib/pfrpg_core/math_helper.rb
+- lib/pfrpg_core/null_object.rb
+- lib/pfrpg_core/prerequisite.rb
+- lib/pfrpg_core/quick_classed.rb
+- lib/pfrpg_core/version.rb
+- test/feat_totaler_test.rb
+- test/helper.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 core
+test_files:
+- test/feat_totaler_test.rb
+- test/helper.rb