pfrpg_utility 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 49f2a54caed217925fbbdc1da8aa2e034a75d15c
+  data.tar.gz: 21a2f8ba64a06101272dff66e045f03983bf3480
+SHA512:
+  metadata.gz: b8317083daa87df08f73aa4f3bf7f6c93c851a2f7dbca405f3e1ea45cebb405447bf581046a0a2260b5f743e9eed8b3cb1174268c7a2c45fc1f099a9fb834275
+  data.tar.gz: e0599d118521f48938a352425ee8731214d4ad4858da681d6eda90f88328456b153b7f962dadd864167d7434f303098fffa683f14ce5fadf3096d5bd5aa6cfae

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

@@ -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_utility.rb

@@ -0,0 +1,8 @@
+module PfrpgUtility
+end
+
+require 'pfrpg_utility/dice'
+require 'pfrpg_utility/affectable'
+require 'pfrpg_utility/alignment'
+require 'pfrpg_utility/effect'
+require 'pfrpg_utility/prerequisite'

data/lib/pfrpg_utility/affectable.rb

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

data/lib/pfrpg_utility/alignment.rb

@@ -0,0 +1,94 @@
+module PfrpgCore
+  class Alignment
+
+    attr_reader :alignment
+    def initialize(alignment)
+      @alignment = PfrpgCore::Alignment.parse(alignment)
+    end
+
+    def self.filter_by_character(character)
+      alignments = []
+      first_class = character.get_last_level.heroclass
+      classed = get_alignments_for_class(first_class)
+      any.each do |alignment|
+        alignments << alignment if classed.include?(alignment)
+      end
+      return alignments
+    end
+
+    def self.get_alignments_for_class(heroclass)
+      heroclass.alignment
+    end
+
+    def self.parse(alignment_str)
+      return "None" unless alignment_str
+      if alignment_str.length == 2
+        h = {
+            'CN' => "Chaotic Neutral",
+            'CE' => "Chaotic Evil",
+            'CG' => "Chaotic Good",
+            'NE' => "Neutral Evil",
+            "TN" => "True Neutral",
+            "NG" => "Neutral Good",
+            "LE" => "Lawful Evil",
+            "LG" => "Lawful Good",
+            "LN" => "Lawful Neutral"
+        }
+        return h[alignment_str] || "None"
+      else
+        return alignment_str
+      end
+    end
+
+    def self.any
+      ["Chaotic Evil", "Chaotic Neutral", "Chaotic Good",
+       "Neutral Evil", "True Neutral", "Neutral Good",
+       "Lawful Evil", "Lawful Neutral", "Lawful Good" ]
+    end
+
+    def self.never_lawful
+      ["Chaotic Evil", "Chaotic Neutral", "Chaotic Good",
+       "Neutral Evil", "True Neutral", "Neutral Good" ]
+    end
+
+    def self.any_evil
+      ["Chaotic Evil", "Neutral Evil", "Lawful Evil"]
+    end
+
+    def self.any_neutral
+      ["Neutral Good", "Neutral Evil", "True Neutral"]
+    end
+
+    def self.any_lawful
+      ["Lawful Good", "Lawful Evil", "Lawful Neutral"]
+    end
+
+    def self.from_str(alignment_str)
+      any.find { |x| x.downcase == alignment_str.downcase }
+    end
+
+    def self.from_deity_str(str)
+      case str
+        when "CE"
+          from_str('Chaotic Evil')
+        when "CN"
+          from_str('Chaotic Neutral')
+        when "CG"
+          from_str('Chaotic Good')
+        when "NE"
+          from_str('Neutral Evil')
+        when "NE"
+          from_str('True Neutral')
+        when "NG"
+          from_str('Neutral Good')
+        when "LE"
+          from_str('Lawful Evil')
+        when "LN"
+          from_str('Lawful Neutral')
+        when "LG"
+          from_str('Lawful Good')
+      end
+    end
+
+  end
+end

data/lib/pfrpg_utility/dice.rb

@@ -0,0 +1,134 @@
+# Copyright (c) 2006, Jamis Buck (jamis@37signals.com)
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# * Redistributions of source code must retain the above copyright notice,
+#   this list of conditions and the following disclaimer.
+# * Redistributions in binary form must reproduce the above copyright notice,
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+# * Neither the name of Jamis Buck nor the names of its contributors may be
+#   used to endorse or promote products derived from this software without
+#   specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+
+# Dice class. It represents one or more homogeneous dice, with an optional
+# integer increment and an optional integer multiplier. It is best used in
+# conjunction with the Integer methods added at the bottom of this file.
+#
+#   4.d6      # => Dice.new(4, 6)
+#   4.d6 + 2  # => Dice.new(4, 6) + 2
+#             # => Dice.new(4, 6, 2)
+#   4.d6 * 10 # => Dice.new(4, 6) * 10
+#             # => Dice.new(4, 6, 0, 10)
+class PfrpgCore::Dice
+  attr_reader :sides, :count, :increment, :multiplier
+
+  def initialize(count, sides, increment=0, multiplier=1)
+    @sides, @count = sides, count
+    @increment, @multiplier = increment, multiplier
+  end
+
+  # Return a new Dice object, with the given multiplier. If the dice already
+  # have a multipler, it accumulates.
+  def *(n)
+    PfrpgCore::Dice.new(count, sides, increment, multiplier * n)
+  end
+
+  # Return a new Dice object, with the given increment. If the dice already
+  # have an increment, it accumulates.
+  def +(n)
+    PfrpgCore::Dice.new(count, sides, increment+n, multiplier)
+  end
+
+  # Same as adding a negative increment.
+  def -(n)
+    self.+(-n)
+  end
+
+  # Roll the dice. If +collect+ is false (the default), returns an integer.
+  # Otherwise, it returns an array with one element for each rolled die.
+  #
+  # Note that the multipler (if any) is applied to each die, while the
+  # increment is applied at the end. If an array is returned, the
+  # increment (times the multiplier) will be the last element of the array.
+  def roll(collect=false)
+    result = collect ? [] : 0
+
+    count.times do
+      roll = (rand(sides) + 1) * multiplier
+      result = result.send(collect ? :push : :+, roll)
+    end
+
+    if increment != 0
+      result = result.send(collect ? :push : :+, increment * multiplier)
+    end
+
+    result
+  end
+
+  # Return the best +n+ of the dice rolled. If +collect+ is false (the default)
+  # an integer is returned, otherwise an array of the best rolls is returned.
+  def best(n, collect=false)
+    list = to_a.sort.last(n)
+    collect ? list : list.inject(0) { |s,v| s + v }
+  end
+
+  # Returns the highest possible integer that may be returned by rolling
+  # this dice instance.
+  def max
+    (count * sides + increment) * multiplier
+  end
+
+  # Returns the lowest possible integer that may be returned by rolling
+  # this dice instance.
+  def min
+    (count + increment) * multiplier
+  end
+
+  # Calculates and returns the average value (as a float) returned by rolling
+  # this dice instance.
+  def average
+    (max + min) / 2.0
+  end
+
+  # Same as calling #roll with a non-false parameter.
+  def to_a
+    roll(true)
+  end
+
+  # Returns a familiar representation of the dice instance.
+  def to_s
+    s = "#{count}d#{sides}"
+    s << "%+d" % increment if increment != 0
+    s << "*%d" % multiplier if multiplier != 1
+    s
+  end
+
+  alias to_i roll
+  alias inspect to_s
+end
+
+class Integer
+  # only define methods for common dice. I *could* use method_missing, but
+  # this approach helps catch typos, since I almost certainly wouldn't
+  # intend to do 2.d9 (it being a rare die, and not used by any RPG games
+  # I'm aware of). Also, the optimist in me likes to think this is more
+  # efficient than method_missing, though I haven't done any benchmarks. :)
+  [4,6,8,10,12,20].each do |sides|
+    define_method("d#{sides}") { PfrpgCore::Dice.new(self, sides) }
+  end
+end

data/lib/pfrpg_utility/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_utility/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_utility/prerequisite/alignment_prereq.rb

@@ -0,0 +1,6 @@
+class PfrpgUtility::Prerequisite::AlignmentPrereq < PfrpgUtility::Prerequisite
+  def match(character)
+    alignments = PfrpgUtility::Alignment.send(@value)
+    alignments.include?(character.alignment.alignment)
+  end
+end

data/lib/pfrpg_utility/prerequisite/attribute_prereq.rb

@@ -0,0 +1,8 @@
+class PfrpgUtility::Prerequisite::AttributePrereq < PfrpgUtility::Prerequisite
+  def match(character)
+    atr = @attribute.downcase
+    str = "modified_#{atr[0..2]}"
+    character.attributes.send(str) >= (@value.to_i)
+  end
+end
+

data/lib/pfrpg_utility/prerequisite/bab_prereq.rb

@@ -0,0 +1,5 @@
+class PfrpgUtility::Prerequisite::BabPrereq < PfrpgUtility::Prerequisite
+  def match(character)
+    character.get_highest_attack_bonus >= @value.to_i
+  end
+end

data/lib/pfrpg_utility/prerequisite/class_prereq.rb

@@ -0,0 +1,12 @@
+class PfrpgUtility::Prerequisite::ClassPrereq < PfrpgUtility::Prerequisite
+  def match(character)
+    begin
+      hc = PfrpgClasses::Heroclass.by_name(@attribute)
+      base = character.get_class_level(hc)
+      base += character.get_class_level('Eldritch Knight') if @attribute == 'Fighter'
+      return base >= value
+    rescue Exception
+      return false
+    end
+  end
+end

data/lib/pfrpg_utility/prerequisite/feat_prereq.rb

@@ -0,0 +1,10 @@
+class PfrpgUtility::Prerequisite::FeatPrereq < PfrpgUtility::Prerequisite
+  def match(character)
+    found = character.feats.find { |x| x.name == @attribute }
+    return (found != nil)
+  rescue Exception => e
+    # ap character.total_feats
+    raise e
+  end
+end
+

data/lib/pfrpg_utility/prerequisite/heroclass_feature_prereq.rb

@@ -0,0 +1,6 @@
+class PfrpgUtility::Prerequisite::HeroclassFeaturePrereq < PfrpgUtility::Prerequisite
+  def match(character)
+    found = character.class_features.find { |x| x.name.upcase[@attribute.upcase] }
+    return (found != nil)
+  end
+end

data/lib/pfrpg_utility/prerequisite/language_prereq.rb

@@ -0,0 +1,5 @@
+class PfrpgUtility::Prerequisite::LanguagePrereq < PfrpgUtility::Prerequisite
+  def match(character)
+    character.demographics.languages.include?(@value)
+  end
+end

data/lib/pfrpg_utility/prerequisite/misc_prereq.rb

@@ -0,0 +1,24 @@
+class PfrpgUtility::Prerequisite::MiscPrereq < PfrpgUtility::Prerequisite
+  def match(character)
+    begin
+      case @attribute
+      when "caster level"
+        return character.get_caster_level >= @value.to_i
+      when "total_level"
+        return character.get_total_level >= @value.to_i
+      when "caster"
+        return character.can_arcane?
+      when "divine"
+        return character.can_divine?
+      when "size"
+        return character.race.size.upcase == @value.upcase
+      end
+    rescue Exception => e
+      #ap "Exception: "
+      #ap e
+      #ap "Self:"
+      #ap self
+      return false
+    end
+  end
+end

data/lib/pfrpg_utility/prerequisite/skill_prereq.rb

@@ -0,0 +1,18 @@
+class PfrpgUtility::Prerequisite::SkillPrereq < PfrpgUtility::Prerequisite
+  def match(character)
+    skill_name = @attribute.downcase
+    if ['knowledge', 'perform', 'profession', 'craft'].include?(skill_name)
+      vals = []
+      classname = "PfrpgSkills::Skill::#{skill_name.capitalize}"
+      clazz = Kernel.const_get(classname)
+      k = clazz.new("NONE")
+      k.supported_types.each do |s|
+        vals << character.skills.current_trained_ranks(clazz.new(s).description)
+      end
+      ranks = vals.max
+    else
+      ranks = character.skills.current_trained_ranks(skill_name)
+    end
+    ranks >= @value.to_i
+  end
+end

data/lib/pfrpg_utility/version.rb

@@ -0,0 +1,3 @@
+module PfrpgUtility
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,61 @@
+--- !ruby/object:Gem::Specification
+name: pfrpg_utility
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Jordan OMara
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-12-23 00:00:00.000000000 Z
+dependencies: []
+description: utility
+email:
+- jordan@herosheets.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/pfrpg_utility/affectable.rb
+- lib/pfrpg_utility/alignment.rb
+- lib/pfrpg_utility/dice.rb
+- lib/pfrpg_utility/effect.rb
+- lib/pfrpg_utility/prerequisite/alignment_prereq.rb
+- lib/pfrpg_utility/prerequisite/attribute_prereq.rb
+- lib/pfrpg_utility/prerequisite/bab_prereq.rb
+- lib/pfrpg_utility/prerequisite/class_prereq.rb
+- lib/pfrpg_utility/prerequisite/feat_prereq.rb
+- lib/pfrpg_utility/prerequisite/heroclass_feature_prereq.rb
+- lib/pfrpg_utility/prerequisite/language_prereq.rb
+- lib/pfrpg_utility/prerequisite/misc_prereq.rb
+- lib/pfrpg_utility/prerequisite/skill_prereq.rb
+- lib/pfrpg_utility/prerequisite.rb
+- lib/pfrpg_utility/version.rb
+- lib/pfrpg_utility.rb
+- LICENSE
+- Rakefile
+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.0.14
+signing_key: 
+specification_version: 4
+summary: PFRPG Utilities
+test_files: []