shattered_pack 0.3.3

data/lib/shattered_model.rb

@@ -0,0 +1,3 @@
+%w(base fuzzy_logic linear_interpolator).each do |dependency|
+  require "shattered_model/#{dependency}"
+end

data/lib/shattered_model/base.rb

@@ -0,0 +1,24 @@
+module ShatteredModel #:nodoc:
+    def self.append_features(base)
+      super
+      base.extend(ClassMethods)
+    end
+    module ClassMethods #:nodoc:
+      def fuzzy_logic( file ) 
+        before_init_set("self", {:fuzzy_logic => [file]})
+      end
+    end
+    # Models encompass all of the game play logic and the game specific data.
+    #
+    # Models are useful for unit tests and for making game rules.
+    # They are where all logic (AI/collisions/etc) go.
+    class Base < ShatteredPack::Base
+      def fuzzy_logic=(file) #:nodoc:
+        @fuzzy_logic = FuzzyLogic.new
+        @fuzzy_logic.parse_fuzzy_file(File.dirname(__FILE__)+"/#{file}")
+      end
+      def update_fuzzy_logic #:nodoc:
+        @fuzzy_logic.update(self)
+      end
+    end
+end

data/lib/shattered_model/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 #:nodoc:
+  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/shattered_model/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 #:nodoc:
+  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_pack.rb

@@ -0,0 +1,11 @@
+$: << File.expand_path(File.dirname(__FILE__))
+
+%w( base runner ).each do |component|
+  require "shattered_pack/#{component}"
+end
+
+require 'shattered_support'
+require 'shattered_ogre'
+require 'shattered_model'
+require 'shattered_view'
+require 'shattered_controller'

data/lib/shattered_pack/base.rb

@@ -0,0 +1,127 @@
+
+$:.unshift(File.dirname(__FILE__)) unless
+$:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+  
+require 'timer/timer'
+require 'pre_initialize/pre_initialize'
+
+module ShatteredPack #:nodoc:
+
+  class Base
+    attr_accessor :time_elapsed
+    alias_method :per_second, :time_elapsed
+    
+    # This is overwritten to allow for a pre_initialize before initialize
+    def self.new(*options) #:nodoc
+      new_base = allocate
+      new_base.pre_initialize
+      new_base.send(:initialize, *options)
+      return new_base
+    end
+    
+    # Retrieve the current state
+    def state 
+      Configuration.environment[:state]
+    end
+    
+    # TODO - is this called anymore?
+    def update_event(time_elapsed) #:nodoc:
+      actors.each do |actor|
+        actor.update_actors(time_elapsed)
+        actor.update(time_elapsed)
+      end
+    end
+    
+    # remove_from_scene? should just be defined in model.
+    # Refactor? TODO
+    def remove_from_scene? #:nodoc:
+      return false
+    end
+    
+    # TODO outdated?
+    def update_actors(time_elapsed) #:nodoc:
+      update_event time_elapsed
+      remove_dead_actors
+    end
+    
+    # TODO outdated?
+    def remove_dead_actors #:nodoc:
+      actors.each do |actor|
+        remove_from_scene actor if actor.remove_from_scene?
+      end
+    end  
+    
+    # TODO outdated?
+    def remove_from_scene(actor)
+      actors.delete actor
+      actor.unload!
+    end
+
+    
+    public
+    
+    # attr helpers.  These are instance level attr_* functions.
+    def attr_reader(*args)
+      name, value = args
+      attr_define(:reader, name, value)
+    end
+
+    # attr helpers.  These are instance level attr_* functions.    
+    # attr_writer accepts a value as the second argument
+    def attr_writer(*args)
+      name, value = args
+      attr_define(:writer, name, value)
+    end
+    
+    # attr helpers.  These are instance level attr_* functions.    
+    # attr_accessor accepts a value as the second argument
+    def attr_accessor(*args)
+      name, value = args
+      attr_define(:accessor, name, value)
+    end
+    
+    # Define a block to execute when an object is unloaded.
+    def when_unloaded(&block)
+      @unloaded_events ||= []
+      @unloaded_events << block
+    end
+    
+    protected
+    
+    def attr_define(accessor_level, name, value)
+      self.class.send("attr_#{accessor_level}".to_sym, "#{name}".to_sym)
+      instance_variable_set("@#{name}".to_sym, value) if !value.nil?
+    end
+
+    private
+    
+    def disabled?
+      @unloaded_events == nil
+    end
+    
+    def unload!
+      return if disabled?
+      @unloaded_events.each do |event|
+        event.call
+      end
+      @unloaded_events = nil
+    end
+    
+  end
+  
+  class Error < StandardError # :nodoc:
+  end
+  
+  class RetossError < StandardError # :nodoc:
+    attr_accessor :message 
+    def initialize(error, message)
+      self.message = message
+      set_backtrace error.backtrace
+    end
+  end
+end
+
+ShatteredPack::Base.class_eval do
+	include ShatteredPack::Timer
+	include ShatteredPack::PreInitialize
+end

data/lib/shattered_pack/pre_initialize/pre_initialize.rb

@@ -0,0 +1,105 @@
+module ShatteredPack
+  module PreInitialize #:nodoc:all
+    def self.append_features(base)
+      super
+      base.extend(ClassMethods)
+      base.send(:include, InstanceMethods)
+    end
+    
+    BEFORE_INIT_CALL_VALUES = :before_init_call_values
+    BEFORE_INIT_SET_VALUES = :before_init_set_values
+    
+    module ClassMethods 
+      
+      # In the pre_initialization phase (see #before_init_call), send an object a bunch of sets.
+      #
+      # This is used in actor, camera, mesh, and virtually everywhere to support the format of:
+      #   mesh "ruby", :position => v(1,0,0)
+      #
+      # becomes 
+      #   before_init_set( :ruby, {:position => v(1,0,0) } )
+      # becomes
+      #   ruby.position=v(1,0,0)
+      # when the obect is initialized.
+      def before_init_set(variable, options={})
+        self.write_inheritable_array(BEFORE_INIT_SET_VALUES, [[ variable, options ]] )
+      end
+
+      # All shattered objects have a pre_initialization phase.  Use this to specify that
+      # a function should be called when the object is created.
+      #
+      # _Example_:
+      #   class BulletModel < ShatteredModel::Base
+      #     before_init_call(:calculate_trajectory, v(0,0,0), v(0,0,1))
+      #     def calculate_trajectory
+      #       #called before initialize is
+      #     end
+      #   end
+      #
+      def before_init_call(function, *arguments)
+        self.write_inheritable_array(BEFORE_INIT_CALL_VALUES, [[function, [*arguments]]])
+      end
+    end
+    module InstanceMethods
+      # This function is called after an object is allocated, but before it's initialized.
+      #
+      # See ShatteredPack::ClassMethods#before_init_call for usage.
+      def pre_initialize #:nodoc:
+        pre_initialize_set
+        pre_initialize_call
+      end
+  
+      # Used in pre_initialize
+      def each_init_value(name) #:nodoc:
+        startup_attributes = self.class.read_inheritable_attribute( name ) || []
+        startup_attributes.each do |actor, options|
+          next if options.nil?
+          yield actor, options
+        end
+      end
+  
+      # Used in pre_initialize for before_init_set
+      def pre_initialize_set #:nodoc:
+        each_init_value(BEFORE_INIT_SET_VALUES) do |variable, options|
+          call_object_function_for_each_key( variable, options )  
+        end
+      end
+  
+      # Used in pre_initialize for before_init_call
+      def pre_initialize_call #:nodoc:
+          each_init_value(BEFORE_INIT_CALL_VALUES) do |function, args|
+            call_object_function( :self, function, args )  
+          end
+      end
+  
+      def call_object_function_for_each_key( actor, options )
+        options.each_pair do |action, params|
+          call_object_function actor, "#{action}=", params
+        end
+      end
+  
+      def call_object_function(actor, action, params)
+        begin
+          if params.is_a? Symbol #|| (params.length == 1 && params[0].is_a?(Symbol)) this will allow substitution in before_init_call. This may not be intended behavior.
+            params = eval(params.to_s) 
+          end
+        rescue NameError
+          puts "It is not advisable to pass #{params.inspect} to #{action.inspect} for #{actor.inspect}."
+          puts "  It will try to be evaluated.  Use a string instead."
+        end
+        begin
+          sendee = eval(actor.to_s)
+          if(params.is_a? Array)
+            sendee.send( action.to_sym, *params )
+          else
+            sendee.send( action.to_sym, params )
+          end
+        rescue NoMethodError, ArgumentError => bang
+          message="Error upon #{actor.to_s}.send(#{action.to_sym.inspect}, #{params.inspect}):\n\r  #{bang.class}: \n\r\t #{bang.message}\n\r #{bang.backtrace[0]}\n\r"
+          bang = ShatteredPack::RetossError.new(bang,message)
+          raise bang
+        end
+      end
+    end
+  end
+end