moonpxi-nimo 0.1.0

data/spec/nimo/game_window_spec.rb

@@ -0,0 +1,88 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Nimo::GameWindow do
+  
+  before(:each) do
+    @game_window = Nimo::GameWindow.new("Test", 640, 480)
+  end
+  
+  describe "(screen transition)" do 
+    before(:each) do
+      @game_window.add_screen(:first, Nimo::Screen.new(:first, nil, nil))
+      @game_window.add_screen(:second, Nimo::Screen.new(:second, nil, nil))
+      @game_window.add_screen(:third, Nimo::Screen.new(:third, nil, nil))
+    end
+     
+    it "should have the first screen added as the current screen" do
+      @game_window.current_screen.id.should == :first
+    end
+  
+    it "should cycle through available screens" do
+      @game_window.go_to(:second)
+      @game_window.current_screen.id.should == :second
+      @game_window.go_to(:third)
+      @game_window.current_screen.id.should == :third
+      @game_window.go_to(:first)
+      @game_window.current_screen.id.should == :first
+    end
+  
+    it "should open and close a 'menu' screen" do
+      @game_window.open_menu(:second)
+      @game_window.current_screen.id.should == :second
+      @game_window.open_menu(:third)
+      @game_window.current_screen.id.should == :third
+      @game_window.close_menu
+      @game_window.current_screen.id.should == :second
+      @game_window.close_menu
+      @game_window.current_screen.id.should == :first
+    end
+    
+    it "should throw error if screen is not available" do
+      lambda { @game_window.go_to(:wrong_screen) }.should raise_error("There is no screen named wrong_screen")
+    end
+  
+  end
+  
+  describe "(game loop)" do
+    it "should proxy updates and draws to current screen" do
+      mock_screen = new_mock_screen("screen")
+
+      expect(:update, mock_screen)
+      expect(:draw, mock_screen)
+    end
+    
+    it "should proxy draws to background screens" do
+      mock_screen1 = new_mock_screen("mock1")
+      mock_screen2 = new_mock_screen("mock2")
+
+      @game_window.open_menu("mock2")
+
+      expect(:update, mock_screen2)
+      expect(:draw, mock_screen1, mock_screen2)
+    end
+
+    it "should not proxy draw for background screen after closing the menu" do
+      mock_screen1 = new_mock_screen("mock1")
+      mock_screen2 = new_mock_screen("mock2")
+      
+      @game_window.open_menu("mock2")
+      @game_window.close_menu
+
+      expect(:update, mock_screen1)
+      expect(:draw, mock_screen1)
+    end
+    
+    def new_mock_screen(name)
+      mock_screen = mock(name)
+      mock_screen.should_receive(:notify).once
+      @game_window.add_screen(name, mock_screen)
+      return mock_screen
+    end
+    
+    def expect(method_name, *instances)
+      instances.each { |instance| instance.should_receive(method_name) }
+      @game_window.send(method_name)
+    end
+  end
+  
+end

data/spec/nimo/listeners/event_listener_spec.rb

@@ -0,0 +1,34 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe "Nimo::EventListener module" do
+  
+  class SomeEventListener
+    include Nimo::EventListener
+    attr_accessor :was_notified
+    
+    def initialize
+      @was_notified = false
+    end
+  end
+  
+  it "should register and execute event" do
+    listener = new_listener(:an_event)
+    
+    listener.notify(:an_event)
+    listener.was_notified.should be_true
+  end
+  
+  it "should not execute action for different event" do
+    listener = new_listener(:an_event)
+    
+    listener.notify(:another_event)
+    listener.was_notified.should be_false
+  end
+  
+  def new_listener(event)
+    listener = SomeEventListener.new
+    listener.listen_to(event) { listener.was_notified = true }
+    return listener
+  end
+  
+end

data/spec/nimo/listeners/input_listener_spec.rb

@@ -0,0 +1,87 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe "Nimo::InputListener module" do
+  
+  class SomeInputListener
+    include Nimo::InputListener
+    attr_reader :num_of_updates
+    
+    def initialize(acting_upon = self)
+      @num_of_updates = 0
+      @acting_upon = acting_upon
+    end
+    
+    def act_upon
+      @acting_upon
+    end
+  end
+  
+  before(:each) do
+    @mock_window = mock("game window")
+  end
+  
+  describe "(key actions)" do
+    it "should not execute key event when key was not pressed" do
+      listener = new_listener(false)
+      listener.process_inputs(@mock_window)
+    
+      listener.num_of_updates.should == 0
+    end
+  
+    it "should execute key event when key is pressed" do
+      listener = new_listener(true)
+      listener.process_inputs(@mock_window)
+    
+      listener.num_of_updates.should == 1
+    end
+    
+    it "should execute key event multiple times when it is repeatable" do
+      listener = new_listener(true)
+      2.times { listener.process_inputs(@mock_window) }
+    
+      listener.num_of_updates.should == 2
+    end
+    
+    it "should execute non repeatable key event once before clearing the button" do
+      listener = new_listener(true, :repeatable => false)
+      2.times { listener.process_inputs(@mock_window) }
+    
+      listener.num_of_updates.should == 1
+    end
+    
+    def new_listener(is_button_down, options = {})
+      @mock_window.should_receive(:button_down?).with(Gosu::Button::KbLeft).at_least(1).and_return(is_button_down)
+      listener = SomeInputListener.new
+      listener.when_key(Gosu::Button::KbLeft, options) { @num_of_updates += 1 }
+      return listener
+    end
+  end
+  
+  describe "(any key actions)" do
+    it "should execute the 'any key' action when any button is pressed" do
+      was_called = false
+      listener = SomeInputListener.new(nil)
+      listener.any_key { was_called = true }
+
+      listener.button_down(nil)
+      
+      was_called.should be_true
+    end
+  end
+  
+  describe "(acting upon an external object)" do
+    it "should act upon an external object" do
+      external = Struct.new(:count).new
+      external.count = 0
+      
+      @mock_window.should_receive(:button_down?).with(Gosu::Button::KbLeft).and_return(true)
+      listener = SomeInputListener.new(external)
+      listener.when_key(Gosu::Button::KbLeft, options) { self.count += 1 }
+      
+      listener.process_inputs(@mock_window)
+    
+      external.count.should == 1
+    end
+  end
+  
+end

data/spec/nimo/representations/image_representation_spec.rb

@@ -0,0 +1,41 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Nimo::ImageRepresentation do
+  
+  before(:each) do
+    @resources = mock("resources")
+    @image_file = mock("image file")    
+    @game_object = Nimo::GameObject.new(:x => 0, :y => 0, :width => 10, :height => 10)
+  end
+  
+  it "should load image from resources and draw it" do
+    expect_image_access(:some_file_tag, @image_file)
+    representation = load_representation(:image => :some_file_tag)
+    
+    @image_file.should_receive(:draw)
+    representation.draw
+  end
+  
+  it "should load image from tile resource and draw it" do
+    expect_image_access(:some_file_tag, [nil, @image_file, nil])
+    representation = load_representation(:image => :some_file_tag, :index => 1)
+    
+    @image_file.should_receive(:draw)
+    representation.draw
+  end
+
+	it "should raise exception when loading with a missing :image param" do
+		lambda { load_representation({}) }.should raise_error("Must provide :image param for image loading")
+	end
+
+	def load_representation(params)
+    representation = Nimo::ImageRepresentation.new(nil, @game_object)
+    representation.load(@resources, params)
+		return representation
+	end
+
+	def expect_image_access(tag, image)
+		@resources.should_receive(:image).with(tag).and_return(image)
+	end
+  
+end

data/spec/nimo/representations/object_representation_spec.rb

@@ -0,0 +1,74 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Nimo::ObjectRepresentation do
+  
+  describe "(always actions)" do
+    it "should execute registered update event" do
+      was_updated = false
+      representation = Nimo::ObjectRepresentation.new(nil, nil)
+      representation.always { was_updated = true }
+    
+      representation.update
+    
+      was_updated.should be_true
+    end
+  end
+  
+  describe "(listener actions)" do
+    it "should execute action when receive notification" do
+      was_updated = false
+      mock_object = mock("object")
+
+      representation = Nimo::ObjectRepresentation.new(nil, mock_object)
+      mock_object.should_receive(:register_listener).with(:some_event, representation)
+      
+      representation.listen_to(:some_event) { was_updated = true }
+      representation.notify(:some_event)
+
+      was_updated.should be_true
+    end
+    
+    it "should ignore event if not registered" do
+      was_updated = false
+      mock_object = mock("object")
+
+      representation = Nimo::ObjectRepresentation.new(nil, mock_object)
+      mock_object.should_receive(:register_listener).with(:some_event, representation)
+      
+      representation.listen_to(:some_event) { was_updated = true }
+      representation.notify(:another_event)
+      
+      was_updated.should be_false
+    end
+  end
+
+	describe "(observer actions)" do
+		it "observer called after actions" do
+			always_called = false
+			key_called = false
+	    was_updated = false
+      
+			mock_window = mock("game window")
+			mock_window.should_receive(:button_down?).with(Gosu::Button::KbLeft).and_return(true)
+
+      representation = Nimo::ObjectRepresentation.new(mock_window, nil)
+      representation.always { always_called = true }
+      representation.when_key(Gosu::Button::KbLeft) { key_called = true }
+			representation.with_observer { |rep, obj| was_updated = true  }
+
+      representation.update
+    
+      was_updated.should be_true
+		end
+	end
+	
+	describe "(exceptions for methods that should be overriden)" do
+	  it "should raise exception when load was not override" do
+	    lambda { Nimo::ObjectRepresentation.new(nil, nil).load(nil, nil) }.should raise_error("Load should be overriden by representation")
+	  end
+	  
+	  it "should raise exception when draw was not override" do
+	    lambda { Nimo::ObjectRepresentation.new(nil, nil).draw }.should raise_error("Draw should be overriden by representation")
+	  end
+	end
+end

data/spec/nimo/representations/sprite_representation_spec.rb

@@ -0,0 +1,73 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Nimo::SpriteRepresentation do
+  
+  before(:each) do
+    @mock_window = mock("game window")
+    mock_resources = mock("resources")
+    @tiles = [mock("sprite tile 1"), mock("sprite tile 2"), mock("sprite tile 3"), mock("sprite tile 4")]
+    
+    mock_resources.should_receive(:image).with(:test_tiles).and_return(@tiles)
+    
+	  obj = Nimo::GameObject.new(:x => 0, :y => 0, :width => 20, :height => 20, :current_state => :state_one)
+    @sprite = Nimo::SpriteRepresentation.new(@mock_window, obj).
+      with_animation(:state_one, [0, 1]).
+      with_animation(:state_two, [2, 3], :loop => false)
+    @sprite.load(mock_resources, :image => :test_tiles)
+  end
+  
+  it "should draw animation based on game object's current state" do
+    @tiles[0].should_receive(:draw).with(0, 0, 0)
+    @sprite.draw    
+  end
+  
+  it "should draw the same frame when draw called before frame timeout" do
+    @tiles[0].should_receive(:draw).twice.with(0, 0, 0)
+    
+    2.times { @sprite.draw }
+  end
+  
+  it "should cycle to the next frame of animation after the frame timeout" do
+    @tiles[0].should_receive(:draw).with(0, 0, 0)
+    @tiles[1].should_receive(:draw).with(0, 0, 0)
+    
+    2.times { @sprite.draw; sleep 0.2 }
+  end
+  
+  it "should cycle to beginning if it loops animation (by default it should loop)" do
+    @tiles[0].should_receive(:draw).twice.with(0, 0, 0)
+    @tiles[1].should_receive(:draw).with(0, 0, 0)
+    
+    3.times { @sprite.draw; sleep 0.2 }
+  end
+  
+  it "should change animation when changing state" do
+    @tiles[0].should_receive(:draw).with(0, 0, 0)
+    @tiles[2].should_receive(:draw).with(0, 0, 0)
+    
+    @sprite.draw
+    @sprite.change_to(:state_two)
+    @sprite.draw
+  end
+  
+  it "should not change animation when game object changes to a state with no animation" do
+    @tiles[0].should_receive(:draw).twice.with(0, 0, 0)
+    
+    @sprite.draw
+    @sprite.change_to(:state_none)
+    @sprite.draw
+  end
+  
+  it "should keep drawing last frame animation do not loop" do
+    @tiles[2].should_receive(:draw).with(0, 0, 0)
+    @tiles[3].should_receive(:draw).twice.with(0, 0, 0)
+    
+    @sprite.change_to(:state_two)
+    3.times { @sprite.draw; sleep 0.2 }
+  end
+  
+  it "should raise exception when trying to load sprite with missing :image param" do
+    empty_resources = mock("resources")
+    lambda { @sprite.load(empty_resources, {}) }.should raise_error("Must provide :image param for sprite loading")
+  end
+end

data/spec/nimo/representations/text_representation_spec.rb

@@ -0,0 +1,21 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Nimo::TextRepresentation do
+
+	it "should raise exception when loading with a missing :image param" do
+		lambda { load_representation_with(:text => :some_text, :color => :some_color) }.should raise_error("Must provide :font param for font loading")
+	end
+	
+	it "should raise exception when loading with a missing :color param" do
+		lambda { load_representation_with(:text => :some_text, :font => :some_font) }.should raise_error("Must provide :color param for font loading")
+	end
+	
+	it "should raise exception when loading with a missing :text param" do
+		lambda { load_representation_with(:font => :some_font, :color => :some_color) }.should raise_error("Must provide :text param for font loading")
+	end
+	
+	def load_representation_with(params)
+    Nimo::TextRepresentation.new(nil, nil).load(nil, params) 
+	end
+
+end

data/spec/nimo/screen_spec.rb

@@ -0,0 +1,114 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Nimo::Screen do
+  
+  it "should register and execute event" do
+    event_called = false
+    
+    screen = Nimo::Screen.new(:id, nil, nil)
+    screen.listen_to(:on_enter) { event_called = true }
+    
+    event_called.should == false
+    screen.notify(:on_enter)
+    event_called.should == true
+  end
+  
+  it "should register new representation" do
+    screen = Nimo::Screen.new(:id, nil, nil)
+    screen.respond_to?(:new_representation).should be_false
+
+    Nimo::Screen.register_representation(:new_representation, nil)
+    
+    screen.respond_to?(:new_representation).should be_true
+  end
+  
+  describe "(loading representations)" do
+    before(:each) do
+      @representation_class = mock("representation class")
+      @representation = mock("representation")
+      @representation_class.should_receive(:new).and_return(@representation)
+      @screen = Nimo::Screen.new(:id, nil, nil)
+    end
+    
+    it "should load representation using the :with params" do
+      with_params = { :blah => "something" }
+      @representation.should_receive(:load).with(nil, with_params)
+      @screen.add(@representation_class, {:with => with_params})
+    end
+    
+    it "should forward updates and draws to representations" do
+      @representation.should_receive(:load).with(nil, {})
+      @screen.add(@representation_class, {})
+
+      @representation.should_receive(:update)
+      @screen.update
+
+      @representation.should_receive(:draw)
+      @screen.draw
+    end  
+  end
+
+  describe "(timer events)" do
+    it "should not execute timer action before it's time" do
+      was_called = false
+
+      screen = screen_with_timer(100) { was_called = true }
+      screen.update
+      
+      was_called.should be_false
+    end
+    
+    it "should execute timer action only once" do
+      number_of_executions = 0
+
+      screen = screen_with_timer(0.1) { number_of_executions += 1 }
+      sleep 0.2
+      5.times { screen.update }
+      
+      number_of_executions.should == 1
+    end
+
+		it "should define and execute multiple timers" do
+			first_called = second_called = false
+
+			screen = screen_with_timer(0.1) { first_called = true }
+			screen.timer_for(0.1) { second_called = true }
+
+			sleep 0.2
+			screen.update
+
+			first_called.should be_true
+			second_called.should be_true
+		end
+
+		def screen_with_timer(delay, &action)
+			screen = Nimo::Screen.new(:id, nil, nil)
+      screen.timer_for(delay, &action)
+			return screen
+		end
+
+  end
+ 
+  describe "(forwarding screen transition methods to game window)" do
+    [:go_to, :open_menu, :close_menu].each do |method_name|
+      it "should forward #{method_name} method to game_window" do
+        mock_window = mock("window")
+        mock_window.should_receive(method_name)
+
+        Nimo::Screen.new(:id, mock_window, nil).send(method_name)
+      end
+    end
+  end
+  
+  describe "(forwarding resource usage methods to resources)" do
+    [:sounds, :images, :fonts].each do |method_name|
+      it "should forward #{method_name} method to game_window" do
+        resources = mock("resources")
+        resources.should_receive(method_name)
+
+        Nimo::Screen.new(:id, nil, resources).send(method_name)
+      end
+    end
+  end
+  
+end