shattered_controller 0.3

data/lib/auto_require.rb

@@ -0,0 +1,2 @@
+require File.dirname(__FILE__)+'/runner'
+require File.dirname(__FILE__)+'/state'

data/lib/base.rb

@@ -0,0 +1,16 @@
+include ShatteredSupport
+
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+  
+require 'keyboard_input/keyboard_input'
+
+module ShatteredController
+	class Base < ShatteredSupport::Base
+	end
+end
+
+ShatteredController::Base.class_eval do
+	include ShatteredController::KeyboardInput
+end
+

data/lib/keyboard_input/input.rb

@@ -0,0 +1,43 @@
+module ShatteredController
+# This is a wrapper around Ogre's input listener.
+# It allows us to query the status of each device every frame.
+class Input
+
+  def initialize( ogre_input )
+    @ogre_input = ogre_input
+  end
+  def key_event?( type, key_symbol )
+    return @ogre_input.send(:"isKey#{type.to_s.capitalize}", self.class.convert(key_symbol))
+  end
+  def flush
+    @ogre_input.flush
+  end
+  
+  def self.back_conversions
+    @@back_conversions ||= conversions.invert
+  end
+  def self.conversions
+    begin 
+      return @@conversions
+    rescue NameError
+    end
+    @@conversions = {}
+    ShatteredOgre.constants.each do |constant|
+      kc_evaled = eval("ShatteredOgre::#{constant}")
+      @@conversions[kc_evaled] = symbolize(constant[3..-1].downcase) if constant.to_s =~ /^KC_/
+    end
+    return @@conversions
+  end
+  def self.convert( kc_character )
+    return self.conversions[kc_character] if kc_character.is_a? Fixnum
+    return self.back_conversions[kc_character]
+  end
+private
+  def self.symbolize( name )
+    exceptions = { 'pgdown' => :page_down,
+    			   'pgup'   => :page_up }
+    return name.to_sym if exceptions[name] == nil
+    return exceptions[name]
+  end
+end
+end

data/lib/keyboard_input/keyboard_input.rb

@@ -0,0 +1,77 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'input'
+
+module ShatteredController
+  module KeyboardInput
+	  def self.append_features(base)
+	    super
+	    base.extend(ClassMethods)
+	    base.send(:include, InstanceMethods)
+	  end
+	  module ClassMethods
+	    # Key pressing can take any of the following forms:
+	    #   key :released => :up, :action => :clicked_up
+	    #   key :pressed => :left, :action => :left_pressed
+	    #   key :held => :down, :action => :move_down_fluidly
+	    # where each of the actions correspond to an actor function:
+	    #
+	    # class ExampleView < ShatteredView::Base
+	    #   def clicked_up
+	    #     #called when up is released
+	    #   end
+	    #   def left_pressed
+	    #     #called when left is released
+	    #   end
+	    #   def move_down_fluidly(time_elapsed)
+	    #     #called when down is held
+	    #   end
+	    # end
+	    #
+	    # Only key :pressed recieves the time_elapsed variable (as it is updated per frame)
+	    def key(options = {})
+	      before_init_call(:key, options)
+	    end
+	  end
+	
+	  module InstanceMethods
+	    def key_types
+	      [:pressed, :released, :held]
+	    end
+	    # Given an input of:
+	    #   key :held=>:up, :action => :key_action
+	    #   This will return [:held, :up, :key_action]
+	    #  This is not used. Todo: use in new_key
+	    def reaction_from(options)
+	      # Define the method to send the actions when the keys are pressed/clicked/released.
+	      key_types.each do |reaction|
+	        return [reaction, options[reaction],options[:action]] if !options[reaction].nil?
+	      end
+	      raise ArgumentError, "Reaction to key input must be pressed, released, or held. #{options.inspect}" if options[:reaction].nil?
+	    end
+	    # Todo: when we refactor before_init_set to not use ='s optionally, we need to allow non *args
+	    def key(actions={})
+	      key_actions << reaction_from(actions)
+	    end
+	    # Update_key will send each of the events to the actor object for whatever key options
+	    # are defined.
+	    def key_action(reaction, action, time_elapsed)
+	      if reaction == :held
+	        actor.send(action, time_elapsed)
+	      else
+	        actor.send(action)
+	      end
+	    end
+	    def key_actions
+	      @key_actions ||= []
+	    end
+	    # update_input takes the input object, and sends the actor every key event this frame.
+	    def update_input(time_elapsed, input)
+	      key_actions.each do |reaction, key, action|
+	        key_action( reaction, action, time_elapsed ) if input.key_event?(reaction,key)
+	      end
+	    end
+	  end
+	end
+end

data/lib/mock_camera.rb

@@ -0,0 +1,9 @@
+
+module ShatteredController
+	class MockCamera
+		attr_reader :position
+		def position=(x,y,z)
+		  @position=[x,y,z]
+		end
+	end
+end

data/lib/runner.rb

@@ -0,0 +1,34 @@
+
+module ShatteredController
+  #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
+    def initialize( options = {} )
+      @@environment ||= options
+      @@environment[:input] = ShatteredController::Input.new(@@environment[:input])
+    end
+    #Every time this exits, a game dies.
+    def start_game
+      each_frame do |time_elapsed|
+        @@environment[:state].update_input(time_elapsed, @@environment[:input])
+        @@environment[:input].flush
+        @@environment[:state].update_actors time_elapsed
+      end
+    end
+    def each_frame
+      yield @@environment[:renderer].timeSinceLastFrame while @@environment[:renderer].nextFrame
+    end
+    def self.environment
+      begin
+        return @@environment
+      rescue NameError
+        return mock_environment
+      end
+    end
+    def self.mock_environment
+      retv = {}
+      retv[:camera] = MockCamera.new
+      return retv
+    end
+  end
+end

data/lib/shattered_controller.rb

@@ -0,0 +1,13 @@
+begin
+#  require File.dirname(__FILE__)+"/../../shattered_support/lib/shattered_support"
+  require 'shattered_support'
+rescue MissingSourceFile
+  require 'rubygems'
+  require 'active_support'
+  require 'shattered_support'
+end
+
+require File.dirname(__FILE__)+'/runner'
+require File.dirname(__FILE__)+'/base'
+require File.dirname(__FILE__)+'/state'
+require File.dirname(__FILE__)+'/mock_camera'

data/lib/shattered_controller_tester.rb

@@ -0,0 +1,4 @@
+["shattered_support","shattered_ogre"].each do |dependancy|
+  $: << File.dirname(__FILE__) + "/../../#{dependancy}/lib"
+end
+require 'shattered_controller'

data/lib/state.rb

@@ -0,0 +1,63 @@
+include ShatteredSupport
+
+module ShatteredController
+  def self.append_features(base)
+    super
+    base.extend(ClassMethods)
+  end
+  module ClassMethods
+    # In order to set the initial position of the camera, and any other attributes you would like,
+    # use the following format.
+    #  class CameraTestState < ShatteredController::Base
+    #    camera :position => [10,0,0], :orientation => [0.5, 0.5, 0.5, 0.5]
+    #  end
+    #  
+    # If you pass a symbol as a value, the symbol will be evaluated.
+    # 
+    # This allows for things such as:
+    #
+    #   class CameraTestState < ShatteredController::Base
+    #     camera :position => :camera_position
+    #     def camera_position
+    #       return [rand*10,0,0]
+    #     end
+    #   end
+    #	
+    # The valid options are any public functions within camera that ends in =
+    # (such as position=, looking_at=)  See ShatteredView::Camera for more.
+    def camera(options = {})
+      before_init_call( 'camera', options )
+    end
+    
+    # This blurs the lines between view and controller.
+    # Valid types are [:box]
+    def sky(type, options = {})
+      before_init_set( "self", { :"sky" => [type, options[:material]] })
+    end
+  end
+  class State < ShatteredSupport::Base      
+    def pre_initialize
+      ShatteredSupport::Configuration.environment[:state] = self
+      super
+    end
+    def camera(*args)
+      if args.length == 0
+        return @camera ||= Runner.environment[:camera]
+      end
+      call_object_function_for_each_key(:camera, args[0])
+    end
+    
+    def update_input(time_elapsed, input)
+      actors.each { |actor| actor.update_input(time_elapsed, input) }
+    end
+    
+    def unload!
+      actors.each { |actor| actor.unload! }      
+    end
+    
+    def sky=(type, material)
+      Runner.environment[:scene].send("setSky#{type.to_s.capitalize}",material)
+    end
+  end
+end
+

metadata

@@ -0,0 +1,45 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.10
+specification_version: 1
+name: shattered_controller
+version: !ruby/object:Gem::Version 
+  version: "0.3"
+date: 2006-04-23
+summary: "Shattered Controller: Controls the game states and objects in Shattered."
+require_paths: 
+  - lib
+email: 
+homepage: http://www.hastilymade.com
+rubyforge_project: 
+description: Shattered Controller is used to create game states and objects within those gamestates. Shattered Controller is an integral part of any Shattered game.
+autorequire: shattered_controller
+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/auto_require.rb
+  - lib/base.rb
+  - lib/mock_camera.rb
+  - lib/runner.rb
+  - lib/shattered_controller.rb
+  - lib/shattered_controller_tester.rb
+  - lib/state.rb
+  - lib/keyboard_input/input.rb
+  - lib/keyboard_input/keyboard_input.rb
+test_files: []
+rdoc_options: []
+extra_rdoc_files: []
+executables: []
+extensions: []
+requirements: 
+  - Shattered Controller is reliant on Shattered View and Ogre.
+dependencies: []