shattered 0.5.0.1 → 0.7.0

data/test/ogre_test_plugins.windows.cfg

@@ -0,0 +1,14 @@
+# Defines plugins to load
+
+# Define plugin folder
+PluginFolder=.
+
+# Define plugins
+Plugin=RenderSystem_Direct3D9
+Plugin=RenderSystem_GL
+Plugin=Plugin_ParticleFX
+Plugin=Plugin_BSPSceneManager
+Plugin=Plugin_OctreeSceneManager
+Plugin=Plugin_CgProgramManager
+
+

data/test/test_helper.rb

@@ -0,0 +1,109 @@
+# Set the shattered root to the current directory.  Used in shattered_light.rb.
+SHATTERED_ROOT=File.dirname(__FILE__)
+require File.expand_path(File.dirname(__FILE__) + '/../lib/shattered')
+
+require 'test/unit'
+
+require 'rubygems'
+#require 'turn' # Prettifies unit test output.
+require 'mocha' # Mock objects
+
+#require 'pmsrb/memory_profile'
+
+def ostats(last_stat = nil)
+ stats = Hash.new(0)
+ ObjectSpace.each_object {|o| stats[o.class] += 1}
+
+ stats.sort {|(k1,v1),(k2,v2)| v2 <=> v1}.each do |k,v|
+   if last_stat && (v - last_stat[k]) > 0
+     $mem_log.printf "leaked:  %-50s  %10d", k, v
+     $mem_log.printf " | delta %10d", (v - last_stat[k]) 
+     $mem_log.puts
+   end
+ end
+
+ stats
+end
+
+if ENV["MEMORY_PROFILE"] == "true"
+  mem_log_file = File.join(File.dirname(__FILE__), "..", "log", "memory_profile.log")
+  $mem_log = File.open(mem_log_file, "w")
+  $memory_profile = true
+  puts "Writing results of memory profile to #{File.expand_path(mem_log_file)}"
+end
+
+class Test::Unit::TestCase
+  # Run through Ogre setup routines so we have access to the system.
+	#
+	# Any test classes that override #setup will need to call super
+	#
+	# I use class variables to make sure only one window pops up instead
+	# of one per test case, which would make things really, really slow.
+	# In the else clause here, do any cleanup you need.
+	def setup
+		@@root ||= nil
+		unless @@root
+			dir = File.expand_path( File.dirname(__FILE__) )
+			@@root = ShatteredOgre.create_root(File.dirname(__FILE__)+"/ogre_test_plugins.#{Platform.short_name}.cfg", File.dirname(__FILE__)+"/ogre_test_defaults.save", File.dirname(__FILE__)+"/log/ogre_test.log")
+
+			@@scene_manager = @@root.create_scene_manager(Ogre::ST_GENERIC, "test")
+      Shattered::Game.scene_manager = @@scene_manager
+    
+			# If needed later
+			#media_path = File.expand_path(File.dirname(__FILE__)+"/media")
+			#ResourceGroupManager.instance.add_resource_location(media_path, "FileSystem", "General")
+
+			# Find a renderer to use
+			renderers = @@root.get_available_renderers
+			@@root.set_render_system(renderers[0])
+
+			@@root.initialise(false)
+
+			# I really, really don't want this! 
+			# but I don't seem to have a choice right now.
+			@@window = @@root.create_render_window("Testing Ogre", 320, 240, false)
+
+#			ResourceGroupManager.instance.initialise_all_resource_groups
+		end
+	  @stats = ostats(@stats) if $memory_profile
+	end
+	
+	def self.render_window
+	  @@window
+	end
+
+  def self.root
+    @@root
+  end
+
+	def teardown
+	  if $memory_profile
+	    GC.start
+	    $mem_log.puts name
+	    @stats = ostats(@stats) 
+    end
+#		@@scene_manager.clear_scene
+	end
+
+	def scene_manager
+		@@scene_manager
+	end
+
+	def window
+		@@window
+	end
+
+end
+
+module Shattered
+class Game
+    #Load the root, setup the render window
+    def setup_ogre
+      @root = Test::Unit::TestCase.root
+      @render_window = Test::Unit::TestCase.render_window
+
+    	return true
+    end  
+end
+end
+

data/test/unit/shattered_game/actor_test.rb

@@ -0,0 +1,9 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class Superman < Shattered::Actor; end
+
+class ActorTest < Test::Unit::TestCase
+  def test_actor_works
+    assert Superman.new.methods.include? "node"
+  end
+end

data/test/unit/shattered_game/game_test.rb

@@ -0,0 +1,49 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class TestGame < Shattered::Game
+  title "Unit Tests"
+end
+
+class ActorTest < Test::Unit::TestCase
+  attr_reader :game
+
+  def setup
+    super
+    @game = TestGame.instance
+  end
+
+  def test_game_is_mv
+    assert game.methods.include? "node"
+  end
+  
+  def test_game_has_initial_objects
+    [ "scene_manager", "render_window", "root", "viewport", "camera", "keyboard_listener", "keyboard", "mouse",
+      "play" ].each do |attribute|
+      assert(game.methods.include?(attribute), "game does not have '#{attribute}'")
+    end
+  end
+  
+  def test_can_create_scene_node
+    game.create_scene_manager(:general)
+    node = game.scene_manager.root_scene_node.create_child_scene_node
+
+    assert node.is_a?(Ogre::SceneNode)
+  end
+  
+  def test_is_a_singleton
+    game2 = Shattered::Game.instance
+    assert_equal(game2, game)
+  end
+  
+  def test_has_logger
+    assert_equal(Logger, game.log.class)
+  end
+  
+  def test_game_input
+    assert_equal(Input::Keyboard, game.keyboard_listener.class)
+  end
+  
+  def test_game_title
+    assert_equal("Unit Tests", game.title)
+  end
+end

data/test/unit/shattered_game/runner_test.rb

@@ -0,0 +1,56 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+#class RunnerTest < Test::Unit::TestCase
+
+	#include ShatteredState
+
+  #def setup
+	#	create_mocks :state, :input, :renderer
+  #end
+
+	#def teardown
+#		verify_mocks
+	#end
+
+	#def test_me
+	#	flunk "Owie, this is bad. Fix Runner. Uncomment these tests to see what I mean"
+	#end
+
+	# TODO ACK WARNING
+	#
+	# TEST INTERACTIONS
+	#
+	# Move the environemnt class variable to an instance variable, maybe using the
+	# config. syntax seen with Rails
+	#
+#	def test_constructor
+#		runner = ShatteredState::Runner.new :val1 => 'val1', :val2 => 'val2'
+#		assert_equal 'val1', Runner.environment[:val1]
+#		assert_equal 'val2', Runner.environment[:val2]
+#		assert Runner.environment[:input].is_a?(ShatteredState::KeyConverter)
+#	end
+#
+#	# X to make sure that it runs after the above
+#	def test_x_game_loop
+#		time_elapsed = 10
+#		@renderer.expect.nextFrame.returns(true)
+#		@renderer.expect.timeSinceLastFrame.returns(time_elapsed)
+#		@state.expect.update_timers(time_elapsed)
+#		@input.expect.flush
+#
+#		@renderer.expect.nextFrame.returns(true)
+#		@renderer.expect.timeSinceLastFrame.returns(time_elapsed)
+#		@state.expect.update_timers(time_elapsed)
+#		@input.expect.flush
+#
+#		@renderer.expect.nextFrame.returns(false)
+#
+#		runner = ShatteredState::Runner.new
+#		Runner.environment[:input] = @input
+#		Runner.environment[:state] = @state
+#		Runner.environment[:renderer] = @renderer
+#		runner.start_game
+#	end
+#
+#end
+

data/test/unit/shattered_model/controls/mouse.controls

@@ -0,0 +1,4 @@
+pressed => mouse.press(:left)
+released => mouse.release(:left)
+
+

data/test/unit/shattered_model/controls/player.controls

@@ -0,0 +1,4 @@
+levitate   => hold :control
+jump       => press :space
+move :left => press :left
+stop :left => release :left

data/test/unit/shattered_model/controls/too_many_delims.controls

@@ -0,0 +1 @@
+levitate => press :not_a_key => oops => pasted a line

data/test/unit/shattered_model/key_controls_test.rb

@@ -0,0 +1,89 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+include Shattered
+
+class Player
+  include Input
+  attr_reader :methods_called
+  
+  # Collect all the methods that are called
+  def method_missing(name, *args)
+    @methods_called ||= []
+    @methods_called << name.to_s
+  end
+end
+
+class ModelTest
+  include Model
+end
+
+class KeyMappingTest < Test::Unit::TestCase
+  def setup
+    super
+    @player = Player.new
+    @player.controls.path=File.expand_path(File.join(File.dirname(__FILE__), "controls"))
+  end
+
+  # Ensures parsing seperates the file correctly.
+	def test_key_parsing
+	  @player.controls.on
+	  expected_events = {"release :left"=>"stop :left",
+                       "press :left"=>"move :left",
+                       "hold :control"=>"levitate",
+                       "press :space"=>"jump"}
+	  assert_equal(expected_events, @player.controls.actions)
+	end
+	
+	# Nil should clear out the key mapping
+	def test_keyboard_reset
+	  @player.controls.on
+	  assert_equal(true, @player.controls.active?)
+    @player.controls.off
+	  assert_equal(false, @player.controls.active?)
+  end
+	
+	# The keyboard checker is responsible for instance_evaling the 
+	#   hold :key, etc commands
+	def test_keyboard_input_is_updated
+	  @player.controls.on
+
+	  with_input(mock()) do |input|
+      input.expects(:hold).returns(false)
+      input.expects(:press).returns(false).times(2)
+      input.expects(:release).returns(false)
+      @player.update_input
+
+      assert_equal(nil, @player.methods_called)
+    end
+  end
+  
+  def test_keyboard_input_calls_actions
+    @player.controls.on
+
+	  with_input(mock()) do |input|      
+      input.expects(:hold).returns(true)
+      input.expects(:press).returns(true).times(2)
+      input.expects(:release).returns(true)
+      @player.update_input
+      
+      assert_equal(["jump", "levitate", "move", "stop"], @player.methods_called.sort)
+    end
+  end
+  
+  def with_input(fake_input)
+	  real_input = Game.instance.input
+    Game.instance.input = fake_input
+    yield fake_input
+    Game.instance.input = real_input
+  end
+	
+	# Should only be 'action' => 'condition' on each line.
+	def test_exception_on_multiple_delims
+    assert_raises(Input::ControlsParseError) { @player.controls('too_many_delims').on }
+	end
+	
+	# Shattered::Model include also includes keymap.
+	def test_model_includes_keymap
+	  assert(ModelTest.instance_methods.include?("controls"), "ModelTest doesn't have keyboard mappings.")
+	end
+end

data/test/unit/shattered_model/key_converter_test.rb

@@ -0,0 +1,37 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+include Shattered
+
+class KeyConverterTest < Test::Unit::TestCase
+  def test_constant_to_symbol
+    assert_equal :a, Input::Converter.convert(OIS::KC_A)
+  end
+
+	def test_symbol_exceptions
+    assert_equal :page_down, Input::Converter.convert(OIS::KC_PGDOWN)
+    assert_equal :page_up, Input::Converter.convert(OIS::KC_PGUP)
+	end
+
+	def test_reverse_exceptions
+    assert_equal OIS::KC_PGDOWN, Input::Converter.convert(:page_down)
+    assert_equal OIS::KC_PGUP, Input::Converter.convert(:page_up)
+	end
+
+  def test_symbol_to_constant
+    assert_equal OIS::KC_A, Input::Converter.convert(:a)
+    assert_equal OIS::KC_PGDOWN, Input::Converter.convert(:page_down)
+    assert_equal OIS::KC_PGUP, Input::Converter.convert(:page_up)
+  end
+
+	def test_bad_symbol_throws
+		assert_nil Input::Converter.convert(:crappycrapcrap)	
+		assert_nil Input::Converter.convert(:someothercrap)	
+	end
+	
+  def test_key_string
+    assert_equal Input::Converter.convert(","), OIS::KC_COMMA
+    assert_equal Input::Converter.convert("."), OIS::KC_PERIOD
+    assert_equal Input::Converter.convert("f1"), Input::Converter.convert(:f1)
+  end  
+
+end

data/test/unit/shattered_model/keyboard_input_test.rb

@@ -0,0 +1,32 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+include Shattered
+
+class KeyboardInputTest < Test::Unit::TestCase
+
+  def setup
+    @ogre_mock = mock()
+	  @input = Input::Keyboard.new(@ogre_mock, mock())
+  end
+  
+  
+  ## TODO: add me
+  # Actions should be checked every frame
+  def test_keys_get_checked_on_frame
+  end
+	
+	def test_key_hold
+    @ogre_mock.expects(:key_held?)
+	  @input.hold(:a)
+  end
+  
+  def test_key_press
+    @ogre_mock.expects(:key_pressed?)
+	  @input.press(:a)
+  end
+
+  def test_key_release
+    @ogre_mock.expects(:key_released?)	
+	  @input.release(:a)
+  end
+end

data/test/unit/shattered_model/mouse_controls_test.rb

@@ -0,0 +1,50 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+include Shattered
+
+class Player
+  include Input
+  attr_reader :methods_called
+  
+  # Collect all the methods that are called
+  def method_missing(name, *args)
+    @methods_called ||= []
+    @methods_called << name.to_s
+  end
+end
+
+class ModelTest
+  include Model
+end
+
+class KeyMappingTest < Test::Unit::TestCase
+  def setup
+    super
+    @player = Player.new
+	  @player.controls.path=File.expand_path(File.join(File.dirname(__FILE__), "controls"))
+  end
+
+  
+  def with_input(fake_input)
+	  real_input = Game.instance.keyboard_listener
+    Game.instance.keyboard_listener = fake_input
+    yield fake_input
+    Game.instance.keyboard_listener = real_input
+  end
+	
+	def test_mouse
+	  @player.controls("mouse").on
+
+	  with_input(mock()) do |input|
+	    mouse=mock()
+	    input.expects(:mouse).at_least_once.returns(mouse)
+	    mouse.expects(:press).returns(true)
+	    mouse.expects(:release).returns(true)
+	 
+	    @player.update_input
+      
+      assert_equal(["pressed", "released"], @player.methods_called.sort)
+	  end
+	  
+	end
+end