gamebox 0.2.1 → 0.3.2

data/spec/animated_spec.rb

@@ -1,13 +1,11 @@
 require File.join(File.dirname(__FILE__),'helper')
-require 'animated'
 
 describe 'A new animated behavior' do
   before do
     @rm = stub(:load_animation_set => ['1.png_img_obj','2.png_img_obj'])
-
-    opts = {:stage=>"stage", :input=>"input", :resources=>@rm}
-    @actor = Actor.new opts
-    @actor.should_receive(:is?).with(:updatable).and_return(true)
+    @actor = Actor.new({})
+    @actor.expects(:is?).with(:updatable).returns(true)
+    @actor.stubs(:resource_manager).returns(@rm)
     @animated = Animated.new @actor
   end
 
@@ -56,7 +54,30 @@ describe 'A new animated behavior' do
     @animated.start_animating
     @animated.animating.should equal(true)
   end
+  
+  it 'should return itself for animated' do
+    @animated.animated.should == @animated
+  end
+
+  it 'should set the action and animate accordingly for single frame' do
+    @animated.animating = true
+    @rm.expects(:load_animation_set).with(@actor, :foo).returns([:frame_one])
+    @animated.action = :foo
+    
+    @animated.animating.should be_false
+    @animated.frame_num.should == 0
+    @animated.action.should == :foo
+  end
+
+  it 'should set the action and animate accordingly for many frames' do
+    @animated.animating = false
+    @rm.expects(:load_animation_set).with(@actor, :foo).returns([:frame_one, :frame_two])
+    @animated.action = :foo
+    
+    @animated.animating.should be_true
+    @animated.frame_num.should == 0
+    @animated.action.should == :foo
+  end
 
-  it 'should set the action and animate accordingly'
 
 end

data/spec/arbiter_spec.rb

@@ -1,5 +1,5 @@
 require File.join(File.dirname(__FILE__),'helper')
-require 'arbiter'
+
 
 class Arb
   include Arbiter
@@ -15,39 +15,27 @@ describe 'Arbiter' do
     @arbiter.should_not be_nil
   end
 
-  describe '#center_x' do
-    it 'should return the center x for circle'
-    it 'should return the center x for aabb'
-    it 'should return the center x for polygon'
-  end
-
-  describe '#center_y' do
-    it 'should return the center y for circle'
-    it 'should return the center y for aabb'
-    it 'should return the center y for polygon'
-  end
-
   describe '#collide?' do
     it 'should call the correct circle circle collision method' do
-      a = stub(:collidable_shape => :circle)
-      b = stub(:collidable_shape => :circle)
-      @arbiter.should_receive(:collide_circle_circle?).with(a,b).and_return(true)
+      a = stub(:collidable_shape => :circle, :is? => true)
+      b = stub(:collidable_shape => :circle, :is? => true)
+      @arbiter.expects(:collide_circle_circle?).with(a,b).returns(true)
 
       @arbiter.collide?(a,b).should be_true
     end
 
-    it 'should call the correct circle polygon collision method' do
-      a = stub(:collidable_shape => :circle)
-      b = stub(:collidable_shape => :polygon)
-      @arbiter.should_receive(:collide_circle_polygon?).with(a,b).and_return(true)
+    it 'should call the correct circle polygon collis?ion method' do
+      a = stub(:collidable_shape => :circle, :is? => true)
+      b = stub(:collidable_shape => :polygon, :is? => true)
+      @arbiter.expects(:collide_circle_polygon?).with(a,b).returns(true)
 
       @arbiter.collide?(a,b).should be_true
     end
 
-    it 'should call the correct polygon circle collision method' do
-      a = stub(:collidable_shape => :polygon)
-      b = stub(:collidable_shape => :circle)
-      @arbiter.should_receive(:collide_circle_polygon?).with(b,a).and_return(true)
+    it 'should call the correct polygon circle collis?ion method' do
+      a = stub(:collidable_shape => :polygon, :is? => true)
+      b = stub(:collidable_shape => :circle, :is? => true)
+      @arbiter.expects(:collide_circle_polygon?).with(b,a).returns(true)
 
       @arbiter.collide?(a,b).should be_true
     end

data/spec/backstage_spec.rb

@@ -1,5 +1,5 @@
 require File.join(File.dirname(__FILE__),'helper')
-require 'backstage'
+
 
 describe 'A new backstage' do
 

data/spec/behavior_spec.rb

@@ -1,5 +1,5 @@
 require File.join(File.dirname(__FILE__),'helper')
-require 'behavior'
+
 
 describe 'A new behavior' do
   before do
@@ -9,14 +9,14 @@ describe 'A new behavior' do
 
   it 'should auto-require behaviors that it depends on' 
   it 'should relegate properly' do
-    @target.should_receive(:foo).and_return(:bar)
+    @target.expects(:foo).returns(:bar)
     @target.relegates :foo
 
     @actor.foo.should == :bar
   end
 
   it 'should un-relegate properly' do
-    @target.should_receive(:foo).and_return(:bar)
+    @target.expects(:foo).returns(:bar)
     @target.relegates :foo
     @actor.foo.should == :bar
     

data/spec/class_finder_spec.rb

@@ -0,0 +1,13 @@
+require File.join(File.dirname(__FILE__),'helper')
+describe ClassFinder do  
+  describe "::find" do
+    it "finds inflected classname" do
+      ClassFinder.find(:class_finder).should == ClassFinder
+    end
+    
+    it "returns nil if not found" do
+      ClassFinder.find(:klass_not_found).should be_nil
+    end
+  end
+  
+end

data/spec/collidable_spec.rb

@@ -1,14 +1,34 @@
 require File.join(File.dirname(__FILE__),'helper')
-require 'collidable'
+
+class SizedActor < Actor
+  def width;12;end
+  def height;10;end
+end
 
 describe 'A new collidable behavior' do
   before do
-    @stage = mock(:register_collidable => nil)
+    @stage = stub(:register_collidable => nil)
     @actor_opts = {:actor_type => :actor, :stage=>@stage, :input=>"input", :resources=> :rm}
     @actor = Actor.new @actor_opts
   end
 
 
+  describe "aabb shape" do
+    before do
+      @behavior_opts = {:shape => :aabb,
+        :cw_world_points => [
+          [-15,10],[15,10],
+          [15,-10], [-15,10]
+        ]}
+      @actor = SizedActor.new @actor_opts
+      @collidable = Collidable.new @actor, @behavior_opts
+    end
+
+    it "constructs based on points" do
+      @collidable.collidable_shape.should == :aabb
+    end
+  end
+
   describe "circle shape" do
     before do
       @behavior_opts = {:shape => :circle}
@@ -16,17 +36,17 @@ describe 'A new collidable behavior' do
     end
 
     it 'should recalculate_collidable_cache on update' do
-      @collidable.shape.should_receive(:recalculate_collidable_cache)
+      @collidable.shape.expects(:recalculate_collidable_cache)
       @collidable.update 4
     end
 
     it 'should relegate methods on actor' do
-      @collidable.should_receive(:width).and_return(44)
+      @collidable.expects(:width).returns(44)
       @actor.width.should == 44
-      @collidable.should_receive(:height).and_return(45)
+      @collidable.expects(:height).returns(45)
       @actor.height.should == 45
 
-      @collidable.should_receive(:collidable_shape).and_return(:circlez)
+      @collidable.expects(:collidable_shape).returns(:circlez)
       @actor.collidable_shape.should == :circlez
     end
 
@@ -34,16 +54,16 @@ describe 'A new collidable behavior' do
       @actor.x = 3
       @actor.y = 6
       @collidable = Collidable.new @actor, :shape => :circle, :radius => 20
-      @collidable.center_x.should be_close(23, 0.001)
-      @collidable.center_y.should be_close(26, 0.001)
+      @collidable.center_x.should be_within(0.001).of(3)
+      @collidable.center_y.should be_within(0.001).of(6)
     end
   end
 
   describe "polygon shape" do
     it 'should calculate center point for polygon' do
       @collidable = Collidable.new @actor, :shape => :polygon, :points => [[0,0],[10,7],[20,10]]
-      @collidable.center_x.should be_close(10, 0.001)
-      @collidable.center_y.should be_close(5, 0.001)
+      @collidable.center_x.should be_within(0.001).of(10)
+      @collidable.center_y.should be_within(0.001).of(5)
     end
 
     it 'should translate points to world coords for poly' do

data/spec/emitter_spec.rb

@@ -0,0 +1,20 @@
+require 'helper'
+
+describe Emitter do
+  before do
+    @stage = stub_everything
+    # @stage.expects(:sound_manager)
+    # @stage.expects(:respond_to?).with(:register_physical_object).returns(true)
+    # @stage.expects(:register_physical_object).with(any_args)
+
+    @emitter = create_actor :emitter, {:stage => @stage}
+  end
+
+  it 'should be' do
+    @emitter.should be
+  end
+
+  it 'should add a timer for spawning particle actors' do
+  end
+
+end

data/spec/helper.rb

@@ -1,25 +1,9 @@
 here = File.dirname(__FILE__)
 gamebox_root = File.expand_path(File.join(here, '..', 'lib'))
 
-#$LOAD_PATH.unshift File.expand_path(gamebox_root, 'gamebox')
-require File.expand_path(File.join(here, '..', 'load_paths'))
-require 'spec'
-
-# TODO this lives in both gamebox.rb and here... seems strange
-[
-"gamebox",
-"gamebox/actors", 
-"gamebox/ai", 
-"gamebox/behaviors", 
-"gamebox/generators", 
-"gamebox/lib", 
-"gamebox/tasks", 
-"gamebox/views"
-].each do |path|
-  $LOAD_PATH.unshift File.join(gamebox_root,path)
+require 'pry'
+require File.join(File.dirname(__FILE__),'..', 'lib', 'gamebox')
+require File.join(File.dirname(__FILE__),'..', 'lib', 'gamebox', 'spec', 'helper')
+RSpec.configure do |config|
+  config.mock_with :mocha
 end
-
-require 'metaclass'
-require 'constructor'
-require 'actor'
-

data/spec/input_manager_spec.rb

@@ -0,0 +1,134 @@
+require File.join(File.dirname(__FILE__),'helper')
+
+describe InputManager do
+  before do
+    @config = stub(:[] => nil)
+    @window = mock
+    @wrapped_screen = stub(:screen => @window)
+  end
+  let(:subject) { InputManager.new :config_manager => @config, :wrapped_screen => @wrapped_screen }
+
+  describe "mouse drag event" do
+    it "should fire after a mouse down, mouse motion, mouse up" do
+      from_x = 40
+      from_y = 20
+      to_x = 140
+      to_y = 120
+      @window.stubs(:mouse_x).returns(from_x)
+      @window.stubs(:mouse_y).returns(from_y)
+
+      event_data = {:from => [from_x, from_y],:to => [to_x, to_y]}
+      exp_event = {
+        :type => :mouse, 
+        :id => MsLeft,
+        :action => :up,
+        :callback_key => :mouse_drag,
+        :data => event_data
+      }
+
+      subject.stubs(:fire).with(:event_received, any_parameters)
+
+      subject.expects(:fire).with(:event_received, exp_event)
+
+      subject._handle_event(MsLeft, :down)
+      subject._handle_event(nil, :motion)
+      @window.stubs(:mouse_x).returns(to_x)
+      @window.stubs(:mouse_y).returns(to_y)
+      subject._handle_event(MsLeft, :up)
+
+    end
+  end
+
+  describe "standard keyboard events" do
+    it 'calls the callbacks for the correct events' do
+      r_pressed = 0
+      y_pressed = 0
+      subject.reg :keyboard_down, KbR do
+        r_pressed += 1
+      end
+      subject.reg :keyboard_down, KbY do
+        y_pressed += 1
+      end
+
+      subject._handle_event(KbT, :down)
+      r_pressed.should == 0
+      y_pressed.should == 0
+
+      subject._handle_event(KbR, :up)
+      r_pressed.should == 0
+      y_pressed.should == 0
+
+      subject._handle_event(KbR, :down)
+      r_pressed.should == 1
+      y_pressed.should == 0
+
+      subject._handle_event(KbY, :down)
+      r_pressed.should == 1
+      y_pressed.should == 1
+
+      subject.clear_hooks self
+
+      # has now been unregistered
+      subject._handle_event(KbR, :down)
+      r_pressed.should == 1
+
+      subject._handle_event(KbY, :down)
+      y_pressed.should == 1
+    end
+
+    it 'passes along args'
+  end
+
+  describe "mapping an event id to a boolean" do
+    it "should set an ivar to true as long as the event id is down" do
+      listener = Struct.new(:left).new
+      subject.while_pressed KbLeft, listener, :left
+
+      listener.left.should be_false
+
+      subject._handle_event(KbLeft, :down)
+      listener.left.should be_true
+
+      subject._handle_event(GpLeft, :down)
+      listener.left.should be_true
+
+      subject._handle_event(GpLeft, :up)
+      listener.left.should be_true
+
+      subject._handle_event(KbT, :up)
+      listener.left.should be_true
+
+      subject._handle_event(KbLeft, :up)
+      listener.left.should be_false
+    end
+  end
+
+  describe "mapping multiple keys to a boolean" do
+    it "should set an ivar to true as long as ANY of the keys are down" do
+      pending
+      listener = Struct.new(:left).new
+      subject.while_pressed [KbLeft, GpLeft], listener, :left
+
+      listener.left.should be_false
+
+      subject._handle_event(KbLeft, :down)
+      listener.left.should be_true
+
+      subject._handle_event(GpLeft, :down)
+      listener.left.should be_true
+
+      subject._handle_event(KbT, :up)
+      listener.left.should be_true
+
+      subject._handle_event(KbP, :down)
+      listener.left.should be_true
+
+      subject._handle_event(GpLeft, :up)
+      listener.left.should be_true
+
+      subject._handle_event(KbLeft, :up)
+      listener.left.should be_false
+    end
+  end
+
+end

data/spec/label_spec.rb

@@ -1,5 +1,4 @@
 require File.join(File.dirname(__FILE__),'helper')
-require 'label'
 
 describe 'a new Label' do
   before do 

data/spec/physical_spec.rb

@@ -1,6 +1,4 @@
 require File.join(File.dirname(__FILE__),'helper')
-require 'physical'
-require 'actor'
 
 class CircleActor < Actor
   has_behaviors :physical => {:shape => :circle, 
@@ -12,14 +10,125 @@ describe 'A new physical behavior' do
   before do
     @stage = stub(:load_animation_set => ['1.png_img_obj','2.png_img_obj'],:register_physical_object => true)
 
-    opts = {:stage=>@stage, :input=>"input", :resources=>"rm"}
-    @actor = CircleActor.new opts
+    @opts = {:stage=>@stage, :input=>"input", :resources=>"rm"}
+    @actor = CircleActor.new @opts
     @physical = @actor.physical
   end
 
   it 'should add methods to its actor' do
     @actor.should.respond_to? :x
-    pending 'testing this feels dirty...'
+    pending 'add shared example for relegates'
+  end
+
+  describe "#pivot" do
+    it 'creates a new PivotJoint and adds it to the space' do
+      other = CircleActor.new @opts
+      v1 = vec2(2,3)
+      v2 = vec2(4,5)
+      CP::Constraint::PivotJoint.expects(:new).with(@physical.body, other.body, v1, v2).returns(:joint)
+      @stage.expects(:register_physical_constraint).with(:joint)
+
+      @actor.pivot(v1, other, v2).should == :joint
+    end
+  end
+
+  describe "#pin" do
+    it 'creates a new PinJoint and adds it to the space' do
+      other = CircleActor.new @opts
+      v1 = vec2(2,3)
+      v2 = vec2(4,5)
+      CP::Constraint::PinJoint.expects(:new).with(@physical.body, other.body, v1, v2).returns(:joint)
+      @stage.expects(:register_physical_constraint).with(:joint)
+
+      @actor.pin(v1, other, v2).should == :joint
+    end
+  end
+
+  describe "#spring" do
+    it 'creates a new DampedSpring and adds it to the space' do
+      other = CircleActor.new @opts
+      v1 = vec2(2,3)
+      v2 = vec2(4,5)
+      CP::Constraint::DampedSpring.expects(:new).with(@physical.body, other.body, v1, v2, 1,2,3).returns(:spring)
+      @stage.expects(:register_physical_constraint).with(:spring)
+
+      @actor.spring(v1, other, v2, 1, 2, 3).should == :spring
+    end
+  end
+
+
+
+  describe "#groove" do
+    it 'creates a new GrooveJoint and adds it to the space' do
+      other = CircleActor.new @opts
+      v1 = vec2(2,3)
+      v2 = vec2(4,5)
+      v3 = vec2(9,7)
+      CP::Constraint::GrooveJoint.expects(:new).with(@physical.body, other.body, v1, v2, v3).returns(:groove)
+      @stage.expects(:register_physical_constraint).with(:groove)
+
+      @actor.groove(v1, v2, other, v3).should == :groove
+    end
+  end
+
+  describe "#rotary_spring" do
+    it 'creates a new DampedRotarySpring and adds it to the space' do
+      other = CircleActor.new @opts
+      CP::Constraint::DampedRotarySpring.expects(:new).with(@physical.body, other.body, 3.14, 10, 50).returns(:rotary_spring)
+      @stage.expects(:register_physical_constraint).with(:rotary_spring)
+      @actor.rotary_spring(other, 3.14, 10, 50).should == :rotary_spring
+    end
+  end
+
+  describe "#rotary_limit" do
+    it 'creates a new RotaryLimitJoint and adds it to the space' do
+      other = CircleActor.new @opts
+      CP::Constraint::RotaryLimitJoint.expects(:new).with(@physical.body, other.body, 0, 3).returns(:rotary_limit)
+      @stage.expects(:register_physical_constraint).with(:rotary_limit)
+      @actor.rotary_limit(other, 0, 3).should == :rotary_limit
+    end
+  end
+
+  describe "#ratchet" do
+    it 'creates a new RatchetJoint and adds it to the space' do
+      other = CircleActor.new @opts
+      CP::Constraint::RatchetJoint.expects(:new).with(@physical.body, other.body, 0, 0.3).returns(:ratchet)
+      @stage.expects(:register_physical_constraint).with(:ratchet)
+      @actor.ratchet(other, 0, 0.3).should == :ratchet
+    end
+  end
+
+  describe "#gear" do
+    it 'creates a new GearJoint and adds it to the space' do
+      other = CircleActor.new @opts
+      CP::Constraint::GearJoint.expects(:new).with(@physical.body, other.body, 0, 0.3).returns(:gear)
+      @stage.expects(:register_physical_constraint).with(:gear)
+      @actor.gear(other, 0, 0.3).should == :gear
+    end
+  end
+
+  describe "#motor" do
+    it 'creates a new SimpleMotor and adds it to the space' do
+      other = CircleActor.new @opts
+      CP::Constraint::SimpleMotor.expects(:new).with(@physical.body, other.body, 40).returns(:motor)
+      @stage.expects(:register_physical_constraint).with(:motor)
+      @actor.motor(other, 40).should == :motor
+    end
+  end
+
+  describe "#slide" do
+    it 'creates the slide joint and adds it to the space' do
+      other = CircleActor.new @opts
+      v1 = vec2(2,3)
+      v2 = vec2(4,5)
+      min = 2.0
+      max = 3.0
+      CP::Constraint::SlideJoint.expects(:new).with(@physical.body, other.body, v1, v2, min, max).returns(:joint)
+
+      @stage.expects(:register_physical_constraint).with(:joint)
+
+      @actor.slide(v1, other, v2, min, max).should == :joint
+    end
   end
 
 end