shattered_model 0.3

data/lib/base.rb

@@ -0,0 +1,22 @@
+include ShatteredSupport
+
+module ShatteredModel
+    def self.append_features(base)
+      super
+      base.extend(ClassMethods)
+    end
+    module ClassMethods
+      def fuzzy_logic( file )
+        before_init_set("self", {:fuzzy_logic => [file]})
+      end
+    end
+    class Base < ShatteredSupport::Base
+      def fuzzy_logic=(file)
+        @fuzzy_logic = FuzzyLogic.new
+        @fuzzy_logic.parse_fuzzy_file(File.dirname(__FILE__)+"/#{file}")
+      end
+      def update_fuzzy_logic
+        @fuzzy_logic.update(self)
+      end
+    end
+end

data/lib/fuzzy_logic.rb

@@ -0,0 +1,188 @@
+require 'yaml'
+# This provides basic fuzzy logic.  That is, it will tell you what properties any given
+# attribute contains based upon previous definition.
+#
+# Example:
+#   player_logic.add_classification( :hp, :dieing, :hp, :max => 5, :min => 45 )
+#   player_logic.add_classification( :hp, :healthy, :max => 80, :min => 65 )
+#   player_logic.hp(15) => [[:dieing, 0.75], [:healthy, 0.0]]
+class FuzzyLogic
+  attr_reader :consequences
+  def initialize
+    @attributes = {}
+    @consequences = {}  
+  end
+  
+  def add_consequence( consequence, classifications={} )
+    @consequences[classifications] ||= []
+    @consequences[classifications] += [consequence]
+  end
+  
+  def add_classification( attribute, classification, options = {} )
+    define_attribute(attribute) if(@attributes[attribute].nil?)
+    define_interpolator(attribute,classification,options)
+  end
+  
+  def consequences_of(options={})
+    # transform the passed in attributes to probability sets
+    valid_sequences = []
+    options.each_pair do |attribute, value|
+      valid_sequences << {attribute => classifications_of(attribute,value)}
+    end
+    # combine the probability sets
+    valid_combinations = compile_consequence_combinations(valid_sequences)
+    # realize the consequences of the combined probability sets
+    return consequences_of_combinations(valid_combinations)
+  end
+  
+  def parse_fuzzy_file( file_name )
+    file_name += ".yaml" if not(file_name =~ /\.yaml$/)
+    raise ArgumentError, "Cannot find #{file_name}" if not(File.file? file_name)
+    begin
+      fuzzy_file = YAML::load(File.open(file_name))
+    rescue ArgumentError => bang
+      raise ArgumentError, "Error when loading #{file_name} : #{bang.message}"
+    end
+    parse_attributes(fuzzy_file)
+    add_consequences_from_parsed(parse_consequences(fuzzy_file['consequences']))
+  end
+  
+  # The algorithm always performs an action on update.
+  def update(object)
+    status = {}
+    @attributes.each_pair do |attribute, classifications|
+      status.merge!({attribute => object.send(attribute)})
+    end
+    consequences = consequences_of(status)
+    total_probability = 0
+    consequences.each_pair do |actions, probability|
+      total_probability+=probability
+    end
+    action_at_probability = rand*total_probability
+    total_probability = 0
+    consequences.each_pair do |actions, probability|
+      total_probability += probability
+      if( action_at_probability < total_probability )
+        actions.each do |action|
+          object.send(action)
+        end
+        break
+      end
+    end
+  end
+
+  private
+
+  # This function recursively moves through each valid combination of probabilities.
+  # It sums the probabilities by multiplication.
+  def compile_consequence_combinations(valid_sequences, compiled={}, probability=1.0)
+    retv = []
+    attribute = valid_sequences[0].keys[0]
+    classifications = valid_sequences[0][attribute]
+    classifications.each do |classification, chance|
+      next if chance == 0
+      nprobability=probability*chance
+      compiled[attribute]=classification
+      if(valid_sequences.length == 1)
+        retv << [compiled.dup, nprobability]
+      else
+        retv += compile_consequence_combinations(valid_sequences[1..-1],compiled,nprobability)
+      end
+    end
+    return retv
+  end
+  
+  def consequences_of_combinations(combinations)
+    consequences = {}
+    combinations.each do |combination, probability|
+      # where a = { {1 => 2}, 3 } and b = {1,2}, a[b] != 3
+      # in order to circumvent this (error?) we use the fact that
+      # a.keys[0] == b
+      @consequences.keys.each do |index|
+        next if index != combination
+        consequences[@consequences[index]] ||= 0
+        consequences[@consequences[index]]+=probability
+      end
+    end
+    return consequences
+  end
+  
+  def parse_attributes(yaml)
+    yaml['attributes'].each_pair do |attribute, classifications|
+      classifications.each_pair do |classification, options|
+        options.keys.each do |key|
+          options[key.to_sym]=options.delete key
+        end
+        add_classification( attribute.to_sym, classification.to_sym, options )
+      end
+    end
+  end
+  
+  def parse_consequences(consequences,result={})
+    compilation = []
+    consequences.each_pair do |consequence, action|
+      nresult = result.dup
+      nresult.merge!(attribute_for(consequence.to_sym) => consequence.to_sym)
+      if action.is_a? String
+        compilation += [nresult => action.to_sym]
+      else
+        compilation+=parse_consequences(action,nresult)
+      end
+    end
+    return compilation
+  end
+  
+  def add_consequences_from_parsed(compilation)
+    compilation.each do |item|
+      item.each_pair do |index, action|
+        add_consequence(action, index)
+      end
+    end
+  end
+  
+  def attribute_for(unknown_classification)
+    @attributes.each_pair do |attribute, classifications|
+      classifications.keys.each do |classification|
+        return attribute if classification == unknown_classification
+      end
+    end
+    return nil
+  end
+
+  def define_attribute(attribute)
+    @attributes[attribute] = {}
+    eval <<-EOF
+    class << self
+      define_method(:#{attribute}) do |at|
+        classifications_of(:#{attribute},at)
+      end
+    end
+EOF
+  end
+
+  def define_interpolator( attribute, classification,options )
+    interpolator = LinearInterpolator.new
+    @attributes[attribute][classification] = interpolator
+
+    add_point(interpolator, options[:max],1)
+    add_point(interpolator, options[:min],0)
+  end
+
+  def classifications_of( attribute, at )
+    retv = []
+    @attributes[attribute].each_pair do |classification,interpolator|
+      retv << [ classification, interpolator.value_at(at) ]
+    end
+    return retv.sort_by { |classification| (1.0-classification[1]) }
+  end
+
+  def add_point( interpolator, points, value )
+    if(points.is_a? Array)
+      points.each do |x|
+        interpolator.add_point(x,value)
+      end
+    else
+      interpolator.add_point(points,value)
+    end
+  end
+end

data/lib/linear_interpolator.rb

@@ -0,0 +1,29 @@
+# This provides basic linear interpolation between any number of arbitrarily defined points.
+# It is used for fuzzy logic.  Although, fuzzy logic based on a statistically normal curve
+# provides best results, linear interpolation provides a "gud 'nuf" approach.
+class LinearInterpolator
+  def add_point(x,y)
+    @points ||= []
+    @points << [x,y]
+    @points = @points.sort_by { |x| x[0] }
+  end
+  def value_at(x)
+    return 0 if @points.nil?
+    return @points[0][1] if x < @points[0][0]
+    return @points[-1][1] if x > @points[-1][0]
+    
+    after,before=nil,nil
+    @points.each_with_index do |point,i|
+      if(point[0] >= x)
+        after = point
+        before = @points[i-1]
+      end
+    end
+    
+    m=(before[1]-after[1])/(before[0]-after[0]).to_f
+    x-=before[0]
+    b=before[1]
+    
+    return m*x+b
+  end
+end

data/lib/shattered_model.rb

@@ -0,0 +1,11 @@
+begin
+#  require File.dirname(__FILE__) + '/../../shattered_support/lib/shattered_support'
+  require 'shattered_support'
+rescue MissingSourceFile
+  require 'rubygems'
+  require 'shattered_support'
+end
+
+require File.dirname(__FILE__) + '/base'
+require File.dirname(__FILE__) + '/fuzzy_logic'
+require File.dirname(__FILE__) + '/linear_interpolator'

data/lib/shattered_model_tester.rb

@@ -0,0 +1,2 @@
+$: << File.dirname(__FILE__) + "/../../shattered_support/lib"
+require 'shattered_model'

metadata

@@ -0,0 +1,40 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.10
+specification_version: 1
+name: shattered_model
+version: !ruby/object:Gem::Version 
+  version: "0.3"
+date: 2006-04-23
+summary: "Shattered Model: Provides basic commands any game object needs."
+require_paths: 
+  - lib
+email: 
+homepage: http://www.hastilymade.com
+rubyforge_project: 
+description: Shattered Model is the basis for the shattered powered game.  It facilitatess the most testable and gameplay related code.
+autorequire: shattered_model
+default_executable: 
+bindir: bin
+has_rdoc: "true"
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+    - 
+      - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+  version: 
+platform: ruby
+authors: []
+files: 
+  - lib/base.rb
+  - lib/fuzzy_logic.rb
+  - lib/linear_interpolator.rb
+  - lib/shattered_model.rb
+  - lib/shattered_model_tester.rb
+test_files: []
+rdoc_options: []
+extra_rdoc_files: []
+executables: []
+extensions: []
+requirements: []
+dependencies: []