shattered_pack 0.4.0.1 → 0.5.0.1

data/lib/shattered_model/fuzzy_logic.rb

@@ -1,188 +0,0 @@
-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

@@ -1,29 +0,0 @@
-# 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/runner.rb

@@ -1,11 +0,0 @@
-module ShatteredPack
-  class Configuration #:nodoc:
-    def self.environment
-      @@environment={} unless defined? @@environment
-      return @@environment 
-    end
-    def self.environment=(environment)
-      @@environment=environment
-    end
-  end
-end

data/lib/shattered_state/runner.rb

@@ -1,39 +0,0 @@
-
-module ShatteredState
-  #The class Runner is present in model, view, and controller, and signifies the
-  #main entry point into the program.  This is called by script/runner.rb
-  class Runner #:nodoc:
-    def initialize( options = {} )
-      @@environment ||= options
-      @@environment[:input] = ShatteredPack::KeyConverter.new(@@environment[:input])
-    end
-
-    #Every time this exits, a game dies.
-    def start_game(env)
-      @@environment = env
-      each_frame do |time_elapsed|
-        @@environment[:state].update_timers(time_elapsed)
-        @@environment[:input].flush
-        @@environment[:renderer].quit if @@environment[:quit]
-      end
-    end
-
-    def each_frame
-      yield @@environment[:renderer].timeSinceLastFrame while @@environment[:renderer].nextFrame
-    end
-
-    def self.environment
-      begin
-        return @@environment
-      rescue NameError
-        return @@environment = mock_environment
-      end
-    end
-
-    def self.mock_environment
-      retv = {}
-      retv[:camera] = ShatteredView::Node.new
-      return retv
-    end
-  end
-end

data/lib/shattered_view/extensions.rb

@@ -1,10 +0,0 @@
-module ShatteredOgre #:nodoc:
-  class Vector3 #:nodoc:
-    def to_a
-      [x, y, z]
-    end
-    def to_v
-      Vector.new x, y, z
-    end
-  end
-end

data/lib/shattered_view/light.rb

@@ -1,29 +0,0 @@
-module ShatteredView
-  
-  class Light
-    def light
-      @light ||= ShatteredOgre::Scene.getSingleton().createLight
-    end
-    def direction=(*direction)
-      light.setType(ShatteredOgre::Light::LT_DIRECTIONAL) 
-      light.setDirection(direction.to_v3)
-    end
-    def diffuse=(r,g,b)
-      light.setDiffuseColour(r,g,b)
-    end
-    def specular=(r,g,b)
-      light.setSpecularColour(r,g,b)
-    end
-    def position=(pos)
-      light.setType(ShatteredOgre::Light::LT_POINT) 
-      light.setPosition(pos.to_v3)
-    end
-    def ambient=(r,g,b)
-      ShatteredOgre::Scene.getSingleton().setAmbientLight(r,g,b);
-    end
-    def attenuation=(range, const, linear, quad)
-      light.setType(ShatteredOgre::Light::LT_POINT)
-      light.setAttenuation(range, const, linear, quad)
-    end
-  end
-end

data/lib/shattered_view/mesh/animation.rb

@@ -1,20 +0,0 @@
-module ShatteredView
-class Animation
-  def initialize(mesh, name)
-    @animation = mesh.getAnimation name
-    @animation.addAsFrameListener
-  end
-  def play
-    @animation.play
-  end
-  def stop
-    @animation.stop
-  end
-  def loop=(looping)
-    @animation.setLoop(looping);
-  end
-  def time_scale=(scale)
-    @animation.setTimeScale(scale);
-  end
-end
-end

data/lib/shattered_view/mesh/mesh.rb

@@ -1,152 +0,0 @@
-$:.unshift(File.dirname(__FILE__)) unless
-  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
-
-require 'animation'
-module ShatteredView
-  module Mesh
-    def self.included(base)
-      base.extend(ClassMethods)
-      base.send(:include, InstanceMethods)
-    end
-    
-    module ClassMethods
-      # Meshes are the foundation for your world.
-      #
-      # They tie in to Ogre's .mesh file format, and display a 3d object onto the screen.
-      #
-      # Shattered has support for loading meshes, creating materials for those meshes (using RMaterials)
-      # and skeletal animation support.
-      #
-      #    class DirtyRubyView
-      #      mesh "dirty_ruby", :position => v(0,0,1)
-      #    end
-      #
-      # When a Mesh is created, all animations found in that mesh are loaded, and added
-      # as functions to that mesh.
-      #
-      # example:  Tim.mesh has animations kick and punch
-      #
-      # after loading Tim.mesh,  View has the Mesh object tim
-      #    tim.kick.play
-      #    tim.animation(:kick).play
-      #
-      # See Rmaterials and Animation for more details.
-      def mesh(file, options = {})
-        before_init_call( :mesh, file, options )
-      end
-
-      # Note: The following is broken in 0.4.0.1
-      # Animations declare helper functions for mesh animations.
-      #
-      #   class AnimatedRubyView < ...
-      #     mesh :animated_ruby, ...
-      #     animation "shatter"
-      #
-      #     def initialize
-      #       shatter # same as animated_ruby.shatter
-      #     end
-      #   end
-      #
-      # options can include any function in animation.rb
-      # and :alias => :alias_name
-      def animation(name, options = {}) 
-        play_alias = options.delete(:alias)
-        before_init_call(:animation, name, options)
-        unless play_alias.nil?
-          before_init_call(:animation_alias, name, play_alias)
-        end
-      end
-    end
-    
-    module InstanceMethods
-      
-      public
-      
-      #TODO - Should it be a list like this, or a hash with the name as the index?
-      def meshes
-#        children.collect { |child| child if child.is_a? Mesh }
-        @meshes
-      end
-
-      private
-      def mesh(file, options={})
-        mesh = Mesh.new(file)
-        name = mesh.name
-        attr_reader name.to_sym, mesh
-        
-        call_object_function_for_each_key(name, options)
-        #keep track of the meshes we create
-        mesh.attach_to(node)
-        @meshes ||= []
-        @meshes << mesh
-        mesh
-      end
-      
-      def animation(name, options={})
-        meshes.each do |mesh|
-          mesh.instance_eval <<-EOF
-          class << self
-            define_method(:#{name}) do
-              animation(:#{name})
-            end
-          end
-          EOF
-          call_object_function_for_each_key("#{mesh.name}.#{name}".to_sym, options)
-        end
-      end
-
-      def animation_alias(name, renamed)
-        define_method(renamed.to_sym) do
-          meshes.each do |mesh|
-            mesh.animation(name.to_sym).play
-          end
-        end
-      end
-    end
-    
-    # This Mesh class corresponds (almost 1 to 1) with ShatteredOgre's mesh class
-    class Mesh < ShatteredView::Node
-      attr_reader :name
-      
-      def initialize( file, options = {} )
-        super( )
-        @name = file.underscore
-        @scene_node = ShatteredOgre::Scene.getSingleton.createMesh( [0,0,0].to_v3, "#{file}.mesh" ) 
-				# TODO Log this
-#        puts "Loading Mesh: #{scene_node} from #{file}.mesh"
-        populate_animations
-      end
-      
-      # Access a given animation.  Returns nil on failure.
-      def animation( animation )
-        return @animations[animation]
-      end
-      
-      #Set the material on this mesh.  Accepts a string or a rmaterial 
-      def material=( material )
-        if material.is_a? RMaterial
-          scene_node.generateTangents if material.tangent_space
-          material = material.name
-        end
-        scene_node.setMaterial(material.to_s)
-      end
-      
-      # Remove the Ogre Mesh from the scene
-      def remove_from_scene
-        scene_node.removeFromScene
-      end
-    private
-  
-      # populate_animations queries ShatteredOgre and adds the found animations to the mesh.
-      def populate_animations
-        @animations = {}
-        (0...scene_node.getNumberOfAnimations).each do |idx|
-          name = scene_node.getAnimationName(idx)
-          @animations[name.downcase.to_sym] = ShatteredView::Animation.new(scene_node, name)
-        end
-      end
-      
-      
-    end
-  end
-end

data/lib/shattered_view/node.rb

@@ -1,105 +0,0 @@
-module ShatteredView
-  class Node
-    attr_reader :position
-    attr_accessor :scene_node
-    
-    #Returns the SceneManager::RootNode wrapped in ShatteredView::Node
-    def Node.root 
-      @@root ||= Node.new
-      @@root.scene_node = ShatteredOgre::Scene.getSingleton.getRootSceneNode
-      return @@root
-    end
-    
-    #Everything attached to this object
-    def children
-      @children ||= []
-    end
-
-    def initialize(parent = nil)
-      @position = v(0,0,0)
-      # Create an empty unassociated node.
-      @scene_node = ShatteredOgre::Scene.getSingleton.createSceneNode
-      attach_to(parent)
-    end
-    
-    # Use attach_to instead
-    def attach_child(child)
-      children << child
-      child.scene_node.attachTo(scene_node)
-    end
-    
-    # Use attach_to on the child node (with nil if you want to clear the parent)
-    def remove_child(child)
-      @children.delete child
-    end
-    
-    #Set a new parent node for the object
-    def attach_to(new_parent)
-      @parent.remove_child(self) unless @parent.nil?
-      @parent = new_parent
-      new_parent.attach_child(self) unless new_parent.nil?
-    end
-    
-    # Move the node a certain amount
-    def translate(v)
-      @position += v
-      synchronize
-    end
-    
-    def position=(v)
-      @position = v.to_v
-      synchronize
-    end
-    
-    # uses #look_at
-    def looking_at=( *look_toward )
-      look_toward = look_toward[0] if(look_toward.length == 1)
-      look_at(look_toward)
-    end
-    
-    alias_method :look_at=, :looking_at=
-  
-    # look_at a Vector, Mesh, or Actor.
-    def look_at( position )
-      position = position.position unless position.is_a?(ShatteredOgre::Vector3) || position.is_a?(Vector) || position.is_a?(Array)
-      position = position.to_v3 unless position.is_a?(ShatteredOgre::Vector3) 
-      scene_node.lookAt(position)
-      #  raise ArgumentError, "#{position.inspect} is not a Mesh, Actor, or Vector."
-    end
-  
-    # rotate along axis, degrees amount
-    def rotate( axis, degrees )
-      axis = axis.to_v.normalize
-      scene_node.rotate(axis.to_v3, degrees)
-    end
-  
-    def rotation=(axis, degrees)
-      rotate axis, degrees
-    end
-  
-    def scale=(*scale)
-      scale = scale[0]                    if scale.length == 1
-      scale = [scale, scale, scale].to_v  if scale.kind_of?(Numeric)
-      scale = scale.to_v
-      
-      scene_node.scale scale.to_v3
-    end
-    
-    def scale(amount)
-      amount = amount.to_v3 unless amount.is_a? Fixnum
-      scene_node.scale amount
-    end
-  
-    def visible=(visible)
-      scene_node.setVisible(visible)
-    end
-    
-    # Synchronize the position with C++, this is called every frame. However
-		# there are times where scene_node hasn't been initialized quite yet
-		# (such as right when a new actor is in the process of being created), so
-		# only synchronize if there's something to synchronize
-    def synchronize
-      @scene_node.setPosition(position.to_v3) unless @scene_node.nil?
-    end
-  end
-end

data/lib/shattered_view/overlay.rb

@@ -1,20 +0,0 @@
-module ShatteredView
-  class Overlay
-    attr_reader :name
-    def initialize(name)
-      @name = name
-      hide
-    end
-    def show
-      ShatteredOgre::Scene::getSingleton.showOverlay(name)
-      @visible = true
-    end
-    def hide
-      ShatteredOgre::Scene::getSingleton.hideOverlay(name)
-      @visible = false
-    end
-    def visible?
-      @visible
-    end
-  end
-end

data/lib/shattered_view/rmaterial.rb

@@ -1,43 +0,0 @@
-require 'erb'
-
-module ShatteredView
-  class RMaterial
-    attr_reader :result, :name
-    def load!(file)
-      begin
-        evaluate!(File.open(file).readlines.join(''))
-      rescue Errno::ENOENT => bang
-        raise Errno::ENOENT, "RMaterial for #{name} not found: #{bang.message}"
-      end
-    end
-    def create_ogre_material!
-      ShatteredOgre::ResourceHandler.getSingleton.addCustomMaterial(name.to_s, result)
-    end
-    def create_ogre_material=(*args)
-      load!("#{SHATTERED_ROOT}/app/media/common/templates/#{template}.rmaterial")
-      create_ogre_material!
-    end
-    def method_missing(name, *args)
-      # Check if the method is a setter
-      if name.to_s[-1].chr == "="
-        name = name.to_s[0...-1].to_sym
-        # Set the instance variable to the sent variable
-        ivar = "@#{ name }".to_sym
-        instance_variable_set(ivar, args[0])
-      else
-        begin
-          return eval("@#{name}")
-        rescue StandardError => bang
-          raise NoMethodError, "Rmaterial could not find the #{name} attribute: #{bang.message}"
-        end
-      end
-    end
-    def evaluate!(template)
-      evaluator = ERB.new(template)
-      return @result ||= evaluator.result(binding)
-    end
-    def tangent_space
-      false
-    end
-  end
-end

data/lib/shattered_view/runner.rb

@@ -1,48 +0,0 @@
-require 'erb'
-
-module ShatteredView
-  class Runner #:nodoc:
-    def initialize(options = {})
-      generate_plugin_config
-      Resources.instance.add_resource_paths("/media", "/app/media", "/app/views")
-      @renderer = ShatteredOgre::Renderer.new
-      raise Error, "Renderer failed to initialize Ogre" if @renderer.failed
-      @scene = ShatteredOgre::Scene.new(translate_to_scene_type(options[:scene_manager]))
-    end
-    def generate_plugin_config
-      plugin_directory = SHATTERED_ROOT+"/config/"
-      generated_plugin = plugin_directory+ "plugins."
-      generator = plugin_directory + "ogre_plugins.rcfg"
-      if PLATFORM =~ /mswin/
-        generated_plugin += "win32"
-      elsif PLATFORM =~ /darwin/
-        generated_plugin += "darwin" 
-      else
-        generated_plugin += "linux"
-      end
-      process_plugin(generator, generated_plugin+".cfg")
-    end
-    def process_plugin(base, generate_to)
-      puts "Generating #{generate_to} from #{base}, #{File.exists?(base)}"
-      return unless File.exists?(base)
-      generated_banner = "\n\r//=== This file is generated.  Modify the .rcfg instead. ===\n\r\n\r"
-      to_write = generated_banner + ERB.new(File.open(base,"r").read).result + generated_banner
-      output = File.open(generate_to, "w")
-      output.syswrite(to_write)
-      output.close
-    end
-    def translate_to_scene_type( symbol )
-      return ShatteredOgre::Scene::Generic if(symbol == :general)
-      return ShatteredOgre::Scene::Terrain if(symbol == :terrain)
-      return ShatteredOgre::Scene::Nature if(symbol == :nature)
-      return ShatteredOgre::Scene::NaturePaging if(symbol == :paging)
-      return ShatteredOgre::Scene::Indoor if(symbol == :indoor)
-    end
-    def add_to_environment(environment)
-      environment[:scene]=@scene
-      environment[:renderer]=@renderer
-      environment[:camera]=Camera.new @scene
-      environment[:input]=ShatteredOgre::Input.new
-    end
-  end
-end