gamebox 0.4.0.rc5 → 0.4.0.rc11

data/spec/behaviors/positioned_spec.rb

@@ -7,10 +7,10 @@ describe :positioned do
   let(:subcontext) do 
     it = nil
     Conject.default_object_context.in_subcontext{|ctx|it = ctx}; 
+    it[:director] = director
     _mocks = create_mocks *(Actor.object_definition.component_names + ActorView.object_definition.component_names - [:actor, :behavior, :this_object_context])
     _mocks.each do |k,v|
       it[k] = v
-      it[:director] = director
     end
     it
   end
@@ -25,13 +25,20 @@ describe :positioned do
     end
   end
 
-  it 'rolls up x and y changes to position_changed on update' do
+  it 'keeps position up to date w/ x and y' do
     subject
+    called = 0
+    actor.when(:position_changed) do
+      called += 1
+    end
     actor.x = 99
+    called.should == 1
 
-    expects_event(actor, :position_changed) do
-      director.fire :update, 50
-    end
+    actor.y = 8
+
+    called.should == 2
+    actor.position.x.should == 99
+    actor.position.y.should == 8
   end
 
   context "options passed in" do

data/spec/core/actor_spec.rb

@@ -1,15 +1,36 @@
 require 'helper'
 describe Actor do
 
-  subject { create_actor :actor }
+  inject_mocks :this_object_context
+
   let(:behavior) { stub(react_to: nil) }
 
   it 'is alive' do
     subject.should be_alive
   end
 
-  it 'has the correct type' do
-    subject.actor_type.should == :actor
+  describe "#configure" do
+    it 'sets up observable attributes' do
+      subject.configure(x: 12)
+      subject.x.should == 12
+      previous_x = nil
+      next_x = nil
+
+      subject.when :x_changed do |old_x, new_x|
+        previous_x = old_x
+        next_x = new_x
+      end
+
+      subject.x = 22
+      subject.x.should == 22
+      previous_x.should == 12
+      next_x.should == 22
+    end
+
+    it 'sets actor type' do
+      subject.configure(actor_type: :monkey)
+      subject.actor_type.should == :monkey
+    end
   end
 
   it 'fires anything' do
@@ -27,6 +48,13 @@ describe Actor do
     end
   end
 
+  describe "#input" do
+    it 'pulls an input mapper from the context' do
+      @this_object_context.stubs(:[]).with(:input_mapper).returns(:mapz)
+      subject.input.should == :mapz
+    end
+  end
+
   describe "#remove_behavior" do
     it 'removes a behavior to the actors list of behaviors' do
       subject.add_behavior :foo, behavior

data/spec/core/actor_view_spec.rb

@@ -5,7 +5,7 @@ describe ActorView do
   let!(:subcontext) do 
     it = nil
     Conject.default_object_context.in_subcontext{|ctx|it = ctx}; 
-    _mocks = create_mocks *(Actor.object_definition.component_names + ActorView.object_definition.component_names - [:actor])
+    _mocks = create_mocks *(Actor.object_definition.component_names + ActorView.object_definition.component_names - [:actor, :this_object_context])
     _mocks.each do |k,v|
       it[k] = v
     end

data/spec/core/behavior_spec.rb

@@ -8,5 +8,8 @@ describe Behavior do
   describe "#add_behavior" do
     it 'uses the behavior factory to add the behavior to the actor'
   end
+  describe "#remove_behavior" do
+    it 'tells the actor to drop a behavior by name'
+  end
 
 end

data/spec/core/configuration_spec.rb

@@ -2,7 +2,54 @@ require 'helper'
 
 describe Gamebox::Configuration do
   describe ".add_setting" do
-    it 'works with all the gamebox settings'
-    it 'can add custom settings'
+    it 'can add custom settings' do
+      described_class.add_setting :foopy
+
+      subject.foopy.should_not be
+      subject.foopy?.should_not be
+      subject.foopy = :yep
+      subject.foopy.should == :yep
+    end
   end
+
+  describe "gamebox settings" do
+    it 'has all the settings' do
+      [ :config_path,
+        :data_path,
+        :music_path,
+        :sound_path,
+        :gfx_path,
+        :fonts_path,
+        :gb_config_path,
+        :gb_data_path,
+        :gb_music_path,
+        :gb_sound_path,
+        :gb_gfx_path,
+        :gb_fonts_path,
+        :game_name, 
+        :needs_cursor,
+        :stages ].each do |setting|
+        subject.should respond_to(setting)
+      end
+    end
+
+    describe "game_name" do
+      it 'has default value' do
+        subject.game_name.should == "Untitled Game"
+      end
+    end
+
+    describe "needs_cursor" do
+      it 'has default value' do
+        subject.needs_cursor.should be_false
+      end
+    end
+
+    describe "stages" do
+      it 'has default value' do
+        subject.stages.should == [:demo]
+      end
+    end
+  end
+
 end

data/spec/core/input_mapper_spec.rb

@@ -0,0 +1,7 @@
+require 'helper'
+describe InputMapper do
+  describe '#map_input' do
+    it 'registers single up / down keys'
+    it 'registers the same key to many actions'
+  end
+end

data/spec/core/renderer_spec.rb

@@ -0,0 +1,89 @@
+require 'helper'
+
+describe Renderer do
+  inject_mocks :viewport
+
+  let(:a) { stub('a', layer: 0, parallax: 0) }
+  let(:b) { stub('b', layer: 0, parallax: 0) }
+
+  let(:c) { stub('c', layer: 1, parallax: 0) }
+  let(:d) { stub('d', layer: 2, parallax: 0) }
+  let(:e) { stub('e', layer: 3, parallax: 0) }
+  let(:f) { stub('f', layer: 4, parallax: 0) }
+
+  let(:x) { stub('x', layer: 0, parallax: 1) }
+  let(:y) { stub('y', layer: 2, parallax: 1) }
+
+  let(:z) { stub('z', layer: 0, parallax: 3) }
+  let(:target) { stub }
+  let(:viewport) { @viewport }
+
+  before do
+    viewport.stubs width: 400, height: 300, rotation: Math::PI
+    target.stubs(:rotate).yields
+    viewport.stubs(:x_offset).with(0).returns(:trans_x_zero)
+    viewport.stubs(:y_offset).with(0).returns(:trans_y_zero)
+    viewport.stubs(:x_offset).with(1).returns(:trans_x_one)
+    viewport.stubs(:y_offset).with(1).returns(:trans_y_one)
+    viewport.stubs(:x_offset).with(3).returns(:trans_x_three)
+    viewport.stubs(:y_offset).with(3).returns(:trans_y_three)
+  end
+
+  it 'registers and draws drawables by parallax and layers' do
+    target.expects(:rotate).with(-Math::PI, 200, 150).yields
+    subject.register_drawable a
+    subject.register_drawable b
+    subject.register_drawable c
+    subject.register_drawable d
+    subject.register_drawable e
+    subject.register_drawable f
+    subject.register_drawable x
+    subject.register_drawable y
+    subject.register_drawable z
+
+    a.expects(:draw).with(target, :trans_x_zero, :trans_y_zero, 4)
+    b.expects(:draw).with(target, :trans_x_zero, :trans_y_zero, 4)
+    c.expects(:draw).with(target, :trans_x_zero, :trans_y_zero, 5)
+    d.expects(:draw).with(target, :trans_x_zero, :trans_y_zero, 6)
+    e.expects(:draw).with(target, :trans_x_zero, :trans_y_zero, 7)
+    f.expects(:draw).with(target, :trans_x_zero, :trans_y_zero, 8)
+    x.expects(:draw).with(target, :trans_x_one, :trans_y_one, 2)
+    y.expects(:draw).with(target, :trans_x_one, :trans_y_one, 3)
+    z.expects(:draw).with(target, :trans_x_three, :trans_y_three, 1)
+
+    subject.draw(target)
+  end
+
+  it 'should unregister drawables by parallax and layer' do
+    subject.register_drawable a
+    subject.register_drawable b
+
+    subject.unregister_drawable a
+    b.expects(:draw).with(target, :trans_x_zero, :trans_y_zero, 1)
+
+    subject.draw(target)
+  end
+
+  it 'should move drawables layers' do 
+    subject.register_drawable a
+    subject.register_drawable b
+    subject.register_drawable x
+    subject.register_drawable y
+
+    a.expects(:parallax=).with(1)
+    b.expects(:parallax=).with(1)
+    a.expects(:layer=).with(4)
+    b.expects(:layer=).with(4)
+
+    subject.move_layer 0, 0, 1, 4
+
+    a.expects(:draw).with(target, :trans_x_zero, :trans_y_zero, 3)
+    b.expects(:draw).with(target, :trans_x_zero, :trans_y_zero, 3)
+    x.expects(:draw).with(target, :trans_x_one, :trans_y_one, 1)
+    y.expects(:draw).with(target, :trans_x_one, :trans_y_one, 2)
+
+    subject.draw(target)
+  end
+
+
+end

data/spec/core/stage_definition_spec.rb

@@ -0,0 +1,41 @@
+require 'helper'
+
+describe StageDefinition do
+  let(:some_block) { Proc.new {} }
+
+  describe "#requires" do
+    it 'assigns the required injections' do
+      subject.requires(:a, :b)
+      subject.required_injections.should == [:a, :b]
+    end
+  end
+
+  describe "#curtain_up" do
+    it 'stores the block' do
+      subject.curtain_up &some_block
+      subject.curtain_up_block.should == some_block
+    end
+  end
+
+  describe "#curtain_down" do
+    it 'stores the block' do
+      subject.curtain_down &some_block
+      subject.curtain_down_block.should == some_block
+    end
+  end
+
+  describe "#render_with" do
+    it 'stores the renderer name' do
+      subject.render_with :foopy
+      subject.renderer.should == :foopy
+    end
+  end
+
+  describe "#helpers" do
+    it 'stores the block' do
+      subject.helpers &some_block
+      subject.helpers_block.should == some_block
+    end
+  end
+
+end

data/spec/core/stage_manager_spec.rb

@@ -1,14 +1,14 @@
 require 'helper'
 
 describe StageManager do
-  inject_mocks :input_manager, :config_manager, :backstage,
+  inject_mocks :input_manager, :config_manager, :stage_factory,
     :this_object_context
 
   class FooStage; end
   class BarStage; end
 
-  let(:foo_stage) { stub('foo stage', when: nil, curtain_raising: nil, curtain_dropping: nil) }
-  let(:bar_stage) { stub('bar stage', when: nil, curtain_raising: nil, curtain_dropping: nil) }
+  let(:foo_stage) { stub('foo stage', when: nil, curtain_up: nil, curtain_down: nil) }
+  let(:bar_stage) { stub('bar stage', when: nil, curtain_up: nil, curtain_down: nil) }
   let(:foo_stage_config) { {foo: {thing:1} } }
   let(:bar_stage_config) { {bar: {thing:2} } }
   let(:stages) { [foo_stage_config, bar_stage_config] }
@@ -21,9 +21,9 @@ describe StageManager do
     subcontext.stubs(:[]).with('foo_stage').returns(foo_stage)
     subcontext.stubs(:[]).with('bar_stage').returns(bar_stage)
     subcontext.stubs(:[]=)
-    foo_stage.stubs(:configure).with(@backstage, {thing:1})
-    bar_stage.stubs(:configure).with(@backstage, {thing:2})
     @this_object_context.stubs(:in_subcontext).yields(subcontext)
+    @stage_factory.stubs(:build).with(:foo, anything).returns(foo_stage)
+    @stage_factory.stubs(:build).with(:bar, anything).returns(bar_stage)
   end
 
   describe '#setup' do
@@ -52,12 +52,12 @@ describe StageManager do
     end
 
     it 'raises the curtain on the new stage' do
-      foo_stage.expects(:curtain_raising).with(:args)
+      foo_stage.expects(:curtain_up).with(:args)
       subject.switch_to_stage :foo, :args
     end
 
     it 'shuts down the current stage' do
-      foo_stage.expects(:curtain_dropping).with(:other_args)
+      foo_stage.expects(:curtain_down).with(:other_args)
       @input_manager.expects(:clear_hooks).with(foo_stage)
       subject.switch_to_stage :foo, :args
       subject.switch_to_stage :bar, :other_args
@@ -67,7 +67,7 @@ describe StageManager do
   describe '#prev_stage' do
     it 'goes to prev stage' do
       subject.switch_to_stage :bar
-      foo_stage.expects(:curtain_raising).with(:args)
+      foo_stage.expects(:curtain_up).with(:args)
 
       subject.prev_stage :args
       subject.current_stage.should == foo_stage
@@ -82,7 +82,7 @@ describe StageManager do
   describe '#next_stage' do
     it 'goes to next stage' do
       subject.switch_to_stage :foo
-      bar_stage.expects(:curtain_raising).with(:args)
+      bar_stage.expects(:curtain_up).with(:args)
 
       subject.next_stage :args
       subject.current_stage.should == bar_stage
@@ -98,7 +98,7 @@ describe StageManager do
     it 'restarts the current stage' do
       subject.switch_to_stage :foo, :args
 
-      foo_stage.expects(:curtain_raising).with(:other_args)
+      foo_stage.expects(:curtain_up).with(:other_args)
       subject.restart_stage :other_args
     end
   end
@@ -123,7 +123,7 @@ describe StageManager do
 
     it 'draws the current stage' do
 
-      subcontext.expects(:[]=).with(:stage, foo_stage)
+      @stage_factory.stubs(:build).with(:foo, :args).returns(foo_stage)
       subject.switch_to_stage :foo, :args
       foo_stage.expects(:draw).with(:target)
 

data/spec/core/stage_spec.rb

@@ -3,99 +3,59 @@ require 'helper'
 describe Stage do
   inject_mocks :input_manager, :actor_factory, :resource_manager, 
     :sound_manager, :config_manager, :director, :this_object_context,
-    :timer_manager
-
-  let(:a) { stub('a', layer: 0, parallax: 0) }
-  let(:b) { stub('b', layer: 0, parallax: 0) }
-
-  let(:c) { stub('c', layer: 1, parallax: 0) }
-  let(:d) { stub('d', layer: 2, parallax: 0) }
-  let(:e) { stub('e', layer: 3, parallax: 0) }
-  let(:f) { stub('f', layer: 4, parallax: 0) }
-
-  let(:x) { stub('x', layer: 0, parallax: 1) }
-  let(:y) { stub('y', layer: 2, parallax: 1) }
-
-  let(:z) { stub('z', layer: 0, parallax: 3) }
-  let(:target) { stub }
-  let(:viewport) { stub }
+    :timer_manager, :viewport
 
   before do
-    @config_manager.stubs(:[]).with(:screen_resolution).returns([800,600])
-    @actor_factory.stubs(:director=)
-    Viewport.stubs(:new).with(800, 600).returns(viewport)
-    @this_object_context.expects(:[]=).with(:viewport, viewport)
-    subject.configure(:backstage, {})
+    @renderer = stub('renderer', :clear_drawables)
+    subject.stubs(:renderer).returns @renderer
 
-    viewport.stubs(:x_offset).with(0).returns(:trans_x_zero)
-    viewport.stubs(:y_offset).with(0).returns(:trans_y_zero)
-    viewport.stubs(:x_offset).with(1).returns(:trans_x_one)
-    viewport.stubs(:y_offset).with(1).returns(:trans_y_one)
-    viewport.stubs(:x_offset).with(3).returns(:trans_x_three)
-    viewport.stubs(:y_offset).with(3).returns(:trans_y_three)
+    @viewport.stubs(:reset)
+    subject.configure(:backstage, {})
   end
 
-  it 'should construct' do
-    subject.should_not be_nil
-  end
+  describe "#configure" do
 
-  it 'should have access to backstage' do
-    subject.backstage.should == :backstage
+    it 'assigns backstage' do
+      subject.backstage.should == :backstage
+    end
   end
 
-  it 'registers and draws drawables by parallax and layers' do
-    subject.register_drawable a
-    subject.register_drawable b
-    subject.register_drawable c
-    subject.register_drawable d
-    subject.register_drawable e
-    subject.register_drawable f
-    subject.register_drawable x
-    subject.register_drawable y
-    subject.register_drawable z
-
-    a.expects(:draw).with(target, :trans_x_zero, :trans_y_zero, 4)
-    b.expects(:draw).with(target, :trans_x_zero, :trans_y_zero, 4)
-    c.expects(:draw).with(target, :trans_x_zero, :trans_y_zero, 5)
-    d.expects(:draw).with(target, :trans_x_zero, :trans_y_zero, 6)
-    e.expects(:draw).with(target, :trans_x_zero, :trans_y_zero, 7)
-    f.expects(:draw).with(target, :trans_x_zero, :trans_y_zero, 8)
-    x.expects(:draw).with(target, :trans_x_one, :trans_y_one, 2)
-    y.expects(:draw).with(target, :trans_x_one, :trans_y_one, 3)
-    z.expects(:draw).with(target, :trans_x_three, :trans_y_three, 1)
-
-    subject.draw(target)
+  describe "#create_actor" do
+    it 'uses the actor factory to create an actor' do
+      @actor_factory.stubs(:build).with(:foo, :bar).returns(:my_new_actor)
+      subject.create_actor(:foo, :bar).should == :my_new_actor
+    end
   end
 
-  it 'should unregister drawables by parallax and layer' do
-    subject.register_drawable a
-    subject.register_drawable b
-
-    subject.unregister_drawable a
-    b.expects(:draw).with(target, :trans_x_zero, :trans_y_zero, 1)
-
-    subject.draw(target)
+  describe "#spawn" do
+    it 'uses the actor factory to create an actor' do
+      @actor_factory.stubs(:build).with(:foo, :bar).returns(:my_new_actor)
+      subject.spawn(:foo, :bar).should == :my_new_actor
+    end
   end
 
-  it 'should move drawables layers' do 
-    subject.register_drawable a
-    subject.register_drawable b
-    subject.register_drawable x
-    subject.register_drawable y
-
-    a.expects(:parallax=).with(1)
-    b.expects(:parallax=).with(1)
-    a.expects(:layer=).with(4)
-    b.expects(:layer=).with(4)
+  describe "#create_actors_from_svg" do
+    it 'maybe sticks around?'
+  end
 
-    subject.move_layer 0, 0, 1, 4
+  describe "#draw" do
+    it 'passes through to the renderer' do
+      @renderer.expects(:draw).with(:target)
+      subject.draw(:target)
+    end
+  end
 
-    a.expects(:draw).with(target, :trans_x_zero, :trans_y_zero, 3)
-    b.expects(:draw).with(target, :trans_x_zero, :trans_y_zero, 3)
-    x.expects(:draw).with(target, :trans_x_one, :trans_y_one, 1)
-    y.expects(:draw).with(target, :trans_x_one, :trans_y_one, 2)
+  describe "#update" do
+    it 'distributes the update' do
+      @director.expects(:update).with(:time)
+      @viewport.expects(:update).with(:time)
+      @timer_manager.expects(:update).with(:time)
+      subject.update(:time)
+    end
 
-    subject.draw(target)
+    it 'updates stagehands'
+    it 'checks for collisions'
   end
 
+
 end