gamebox 0.3.4 → 0.4.0.rc1

data/spec/core/physics_manager_spec.rb

@@ -0,0 +1,11 @@
+require 'helper'
+
+
+describe PhysicsManager do
+  it 'needs tests'
+
+  describe "#add_collision_func" do
+    it 'pulls actors out of the collision shapes and yields them to the block'
+    it 'accepts two arrays of types and builds chipmunk handlers accordingly (see arbiter)'
+  end
+end

data/spec/core/resource_manager_spec.rb

@@ -0,0 +1,12 @@
+require 'helper'
+
+describe 'A new resource manager' do
+  let(:actor) { stub 'actor', actor_type: 'string' }
+  subject { ResourceManager.new :wrapped_screen => stub(:screen => :fake_gosu) }
+
+  it 'should load an actor image' do
+    subject.expects(:load_image).with("string.png").returns(:surf)
+    subject.load_actor_image(actor).should == :surf
+  end
+
+end

data/spec/core/stage_manager_spec.rb

@@ -0,0 +1,140 @@
+require 'helper'
+
+describe StageManager do
+  inject_mocks :input_manager, :config_manager, :backstage,
+    :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_config) { {foo: {thing:1} } }
+  let(:bar_stage_config) { {bar: {thing:2} } }
+  let(:stages) { [foo_stage_config, bar_stage_config] }
+  let(:subcontext) { stub 'subcontext' }
+  before do
+    Gamebox.configuration.stages = stages
+    @input_manager.stubs(:clear_hooks)
+
+    # TODO sub context helper
+    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)
+  end
+
+  describe '#setup' do
+    it 'constructs' do
+      subject.should be
+    end
+
+    it 'sets up the stage config' do
+      subject.stage_names.should == [:foo, :bar]
+      subject.stage_opts.should == [{thing:1}, {thing:2}]
+    end
+  end
+
+  describe "#default_stage" do
+
+    it 'returns the first stage in the stage_config' do
+      subject.default_stage.should == :foo
+    end
+  end
+
+  describe "#switch_to_stage" do
+
+    it 'activates the new stage' do
+      subject.switch_to_stage :foo, :args
+      subject.current_stage.should == foo_stage
+    end
+
+    it 'raises the curtain on the new stage' do
+      foo_stage.expects(:curtain_raising).with(:args)
+      subject.switch_to_stage :foo, :args
+    end
+
+    it 'shuts down the current stage' do
+      foo_stage.expects(:curtain_dropping).with(:other_args)
+      @input_manager.expects(:clear_hooks).with(foo_stage)
+      subject.switch_to_stage :foo, :args
+      subject.switch_to_stage :bar, :other_args
+    end
+  end
+
+  describe '#prev_stage' do
+    it 'goes to prev stage' do
+      subject.switch_to_stage :bar
+      foo_stage.expects(:curtain_raising).with(:args)
+
+      subject.prev_stage :args
+      subject.current_stage.should == foo_stage
+    end
+
+    it 'exits on prev_stage of first stage' do
+      subject.switch_to_stage :foo
+      lambda { subject.prev_stage :args }.should raise_exception(SystemExit)
+    end
+  end
+
+  describe '#next_stage' do
+    it 'goes to next stage' do
+      subject.switch_to_stage :foo
+      bar_stage.expects(:curtain_raising).with(:args)
+
+      subject.next_stage :args
+      subject.current_stage.should == bar_stage
+    end
+
+    it 'exits on next_stage of last stage' do
+      subject.switch_to_stage :bar
+      lambda { subject.next_stage :args }.should raise_exception(SystemExit)
+    end
+  end
+
+  describe '#restart_stage' do
+    it 'restarts the current stage' do
+      subject.switch_to_stage :foo, :args
+
+      foo_stage.expects(:curtain_raising).with(:other_args)
+      subject.restart_stage :other_args
+    end
+  end
+
+  describe "#update" do
+    it 'can be called on nil stage' do
+      subject.update :target
+    end
+
+    it 'updates the current stage' do
+      subject.switch_to_stage :foo, :args
+      foo_stage.expects(:update).with(44)
+
+      subject.update 44
+    end
+  end
+
+  describe "#draw" do
+    it 'can be called on nil stage' do
+      subject.draw :target
+    end
+
+    it 'draws the current stage' do
+
+      subcontext.expects(:[]=).with(:stage, foo_stage)
+      subject.switch_to_stage :foo, :args
+      foo_stage.expects(:draw).with(:target)
+
+      subject.draw :target
+    end
+  end
+
+  describe 'callbacks' do
+    it 'registers next_stage'
+    it 'registers prev_stage'
+    it 'registers restart_stage'
+    it 'registers change_stage'
+  end
+end

data/spec/core/stage_spec.rb

@@ -0,0 +1,73 @@
+require 'helper'
+
+describe Stage do
+  inject_mocks :input_manager, :actor_factory, :resource_manager, 
+    :sound_manager, :config_manager, :director, :this_object_context,
+    :timer_manager
+  FakeDrawable = Struct.new :layer, :parallax
+
+  before do
+    @config_manager.stubs(:[]).with(:screen_resolution).returns([800,600])
+    @actor_factory.stubs(:director=)
+    @viewport = stub
+    Viewport.stubs(:new).with(800, 600).returns(@viewport)
+    @this_object_context.expects(:[]=).with(:viewport, @viewport)
+    subject.configure(:backstage, {})
+  end
+
+  it 'should construct' do
+    subject.should_not be_nil
+  end
+
+  it 'should have access to backstage' do
+    subject.backstage.should == :backstage
+  end
+
+  it 'should register drawables by parallax and layer'
+  it 'should unregister drawables by parallax and layer'
+  it 'should draw drawables by parallax and layers' do
+    a = FakeDrawable.new
+    b = FakeDrawable.new
+    c = FakeDrawable.new
+    d = FakeDrawable.new
+    e = FakeDrawable.new
+    f = FakeDrawable.new
+    x = FakeDrawable.new
+    y = FakeDrawable.new
+    z = FakeDrawable.new
+    subject.drawables = {
+      2 => {3=> [a,b,c]},
+      6 => {7=> [d,e,f]},
+      9 => {13=> [x,y,z]},
+    }
+    subject.move_layer(2, 3, 6, 7).should == [d,e,f]
+    subject.drawables[6][7].should_not be_nil
+    subject.drawables[6][7].should == [a,b,c]
+    subject.drawables[2][3].should be_nil
+  end
+  it 'should move drawables layers' do 
+
+    a = FakeDrawable.new
+    b = FakeDrawable.new
+    c = FakeDrawable.new
+    d = FakeDrawable.new
+    e = FakeDrawable.new
+    f = FakeDrawable.new
+    x = FakeDrawable.new
+    y = FakeDrawable.new
+    z = FakeDrawable.new
+    subject.drawables = {
+      2 => {3=> [a,b,c]},
+      6 => {7=> [d,e,f]},
+      9 => {13=> [x,y,z]},
+    }
+    subject.move_layer(2, 3, 6, 7).should == [d,e,f]
+    subject.drawables[6][7].should_not be_nil
+    subject.drawables[6][7].should == [a,b,c]
+    subject.drawables[2][3].should be_nil
+  end
+
+  describe "#modal_actor" do
+    it 'pauses, shows actor, unpauses when that actor dies; ug, how to test this?'
+  end
+end

data/spec/core/timer_manager_spec.rb

@@ -0,0 +1,89 @@
+require 'helper'
+
+describe TimerManager do
+  describe "#add_timer" do
+    let(:block) { Proc.new do end }
+    it 'adds a timer by name' do
+      subject.add_timer 'foo', 45, &block
+      subject.timer('foo').should == {
+        count: 0, recurring: true,
+        interval_ms: 45, callback: block
+      }
+    end
+
+    it 'raises if a timer already exists by that name' do
+      subject.add_timer 'foo', 45, &block
+      lambda { subject.add_timer 'foo', 45, &block }.should raise_exception
+    end
+  end
+
+  describe "#remove_timer" do
+    let(:block) { Proc.new do end }
+    it 'removes a timer by name' do
+      subject.add_timer 'foo', 45, &block
+      subject.remove_timer 'foo'
+
+      subject.timer('foo').should_not be
+    end
+  end
+
+  describe "#update" do
+    it 'fires timers that need to be fired and roles up counts if not yet met' do
+      calls = 0
+      block = Proc.new do calls += 1 end
+      subject.add_timer 'foo', 45, &block
+      
+      subject.update 45
+      calls.should == 0
+
+      subject.update 1
+      calls.should == 1
+
+      subject.update 90
+      calls.should == 2
+
+      subject.update 1
+      calls.should == 3
+    end
+
+    it 'removes fired non-recurring timmers' do
+      calls = 0
+      block = Proc.new do calls += 1 end
+      subject.add_timer 'foo', 45, false, &block
+
+      subject.update 46
+      calls.should == 1
+
+      subject.timer('foo').should_not be
+    end
+  end
+
+  describe "#pause" do
+    it 'pauses current timers' do
+      calls = 0
+      block = Proc.new do calls += 1 end
+      subject.add_timer 'foo', 45, false, &block
+
+      subject.pause
+      subject.update 50
+      calls.should == 0
+    end
+  end
+
+  describe "#unpause" do
+    it 'unpauses current timers' do
+      calls = 0
+      block = Proc.new do calls += 1 end
+      subject.add_timer 'foo', 45, false, &block
+
+      subject.pause
+      subject.update 50
+      calls.should == 0
+
+      subject.unpause
+      subject.update 50
+      calls.should == 1
+    end
+  end
+
+end

data/spec/{viewport_spec.rb → core/viewport_spec.rb}

@@ -1,5 +1,4 @@
-require File.join(File.dirname(__FILE__),'helper')
-
+require 'helper'
 
 class Vec
   attr_accessor :x, :y
@@ -152,7 +151,11 @@ describe 'A new viewport' do
       subject.x_offset = -10
       subject.y_offset = -100
 
-      subject.bounds.should == [10,100,810,700]
+      bounds = subject.bounds
+      bounds.left.should == 10
+      bounds.top.should == 100
+      bounds.width.should == 810
+      bounds.height.should == 700
     end
   end
   

data/spec/core/wrapped_screen_spec.rb

@@ -0,0 +1,26 @@
+require 'helper'
+
+describe WrappedScreen do
+  inject_mocks :config_manager
+
+  describe "#setup" do
+    before do
+      @config_manager.stubs(:[]).with(:screen_resolution).returns [800,555]
+      @config_manager.stubs(:[]).with(:fullscreen).returns false
+      @config_manager.stubs(:[]).with(:title).returns "Some Title!"
+      @config_manager.stubs(:[]).with(:needs_cursor).returns nil
+
+      @gosu_window = stub('gosu window')
+      HookedGosuWindow.stubs(:new).with(800, 555, false).returns @gosu_window
+    end
+
+    it 'creates a new Gosu Window with opts from config manager' do
+
+      @gosu_window.expects(:caption=).with("Some Title!")
+      @gosu_window.expects(:needs_cursor=).with(nil)
+
+      subject.screen.should == @gosu_window
+    end
+  end
+end
+

data/spec/fixtures/game.yml

@@ -0,0 +1,7 @@
+--- 
+:sound: true
+:auto_quit: KbEscape
+:fullscreen: false
+:screen_resolution: 
+- 1024
+- 768

data/spec/helper.rb

@@ -1,3 +1,11 @@
+if ENV["COVERAGE"]
+  require 'simplecov'
+  SimpleCov.start do
+    add_filter "/spec/"
+    add_filter "/lib/gamebox/lib/"
+  end 
+end
+
 here = File.dirname(__FILE__)
 gamebox_root = File.expand_path(File.join(here, '..', 'lib'))
 

data/spec/{class_finder_spec.rb → lib/class_finder_spec.rb}

@@ -1,4 +1,5 @@
-require File.join(File.dirname(__FILE__),'helper')
+require 'helper'
+
 describe ClassFinder do  
   describe "::find" do
     it "finds inflected classname" do

data/spec/stagehands/spatial_tree_stagehand_spec.rb

@@ -0,0 +1,19 @@
+require 'helper'
+
+describe SpatialTreeStagehand do
+  subject { SpatialTreeStagehand.new :stage, {} }
+  let(:tree) { stub('tree') }
+
+  before do
+    AABBTree.stubs(:new).returns tree
+  end
+
+  describe "#items" do
+    it "returns all the items" do
+      tree.stubs(:items).returns(key: :value)
+      subject.items.should == [:key]
+    end
+  end
+
+
+end

data/spec/views/graphical_actor_view_spec.rb

@@ -0,0 +1,116 @@
+require 'helper'
+
+describe :graphical_actor_view do
+  # TODO this subjet construction is WAY off now
+  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[:this_object_context] = it
+    _mocks.each do |k,v|
+      it[k] = v
+    end
+    it
+  end
+  subject { subcontext[:actor_view_factory].build actor, {} }
+  let(:actor) do 
+    subcontext[:actor].tap do |a| 
+      a.has_attribute :view, :graphical_actor_view
+      a.has_attribute :x, 2
+      a.has_attribute :y, 3
+      a.has_attribute :image, image
+      a.has_attribute :tiled
+      a.has_attribute :num_x_tiles
+      a.has_attribute :num_y_tiles
+    end
+  end
+
+  let(:image) { stub('image', width: 10, height: 20, draw:nil) }
+
+  before do
+    # inject mocks hack
+    @actor = actor
+    @stage.stub_everything
+  end
+
+  describe "#draw" do
+    context "no image" do
+      it 'does nothing if actor has no image' do
+        subject.draw(:target, 0, 0, 0)
+      end
+    end
+
+    context "with image" do
+      before do
+        Color.stubs(:new).returns :color
+        actor.stubs(:image).returns(image)
+      end
+
+      it 'creates the color with the correct alpha' do
+        Color.expects(:new).with(0xFF, 0xFF, 0xFF, 0xFF).returns(:full_color)
+        subject.draw(:target, 0, 0, 0)
+      end
+
+      it 'handles rotation correctly for physical actors' do
+        actor.stubs(:is?).with(:physical).returns(true)
+        actor.stubs(:rotation).returns(1.3)
+
+        image.expects(:draw_rot).with(2, 3, 1, 1.3, 0.5, 0.5, 1, 1, :color)
+        subject.draw(:target, 0, 0, 1)
+      end
+
+      it 'translates using the offsets passed in' do
+        actor.stubs(:is?).with(:physical).returns(true)
+        actor.stubs(:rotation).returns(1.3)
+
+        image.expects(:draw_rot).with(4, 6, 1, 1.3, 0.5, 0.5, 1, 1, :color)
+        subject.draw(:target, 2, 3, 1)
+      end
+
+      it 'handles draw correctly for plain actors w/o rotation' do
+        image.expects(:draw).with(2, 3, 1, 1, 1, :color)
+        subject.draw(:target, 0, 0, 1)
+      end
+
+      it 'handles rotation correctly for plain actors w/ rotation' do
+        actor.stubs(:rotation).returns(1.3)
+        image.expects(:draw_rot).with(2, 3, 1, 1.3, 0.5, 0.5, 1, 1, :color)
+        subject.draw(:target, 0, 0, 1)
+      end
+
+      it 'handles nil rotation' do
+        actor.stubs(:rotation).returns(nil)
+        image.expects(:draw_rot).with(2, 3, 1, 0.0, 0.5, 0.5, 1, 1, :color)
+        subject.draw(:target, 0, 0, 1)
+      end
+
+      it 'scales the image correctly' do
+        actor.stubs(:rotation).returns(nil)
+        actor.stubs(:x_scale).returns(2)
+        actor.stubs(:y_scale).returns(3)
+
+        image.expects(:draw_rot).with(2, 3, 1, 0.0, 0.5, 0.5, 2, 3, :color)
+        subject.draw(:target, 0, 0, 1)
+      end
+
+      it 'draws correctly for tiled graphical actors' do
+        actor.stubs(:rotation).returns(0.0)
+        actor.stubs(:is?).with(:graphical).returns(true)
+        actor.stubs(:tiled).returns(true)
+        actor.stubs(:num_x_tiles).returns(2)
+        actor.stubs(:num_y_tiles).returns(3)
+
+        image.expects(:draw_rot).with(2, 3, 1, 0.0, 1, 1)
+        image.expects(:draw_rot).with(2, 23, 1, 0.0, 1, 1)
+        image.expects(:draw_rot).with(2, 43, 1, 0.0, 1, 1)
+        image.expects(:draw_rot).with(12, 3, 1, 0.0, 1, 1)
+        image.expects(:draw_rot).with(12, 23, 1, 0.0, 1, 1)
+        image.expects(:draw_rot).with(12, 43, 1, 0.0, 1, 1)
+
+        subject.draw(:target, 0, 0, 1)
+      end
+
+    end
+
+  end
+end