gamebox 0.3.4 → 0.4.0.rc1

data/spec/core/backstage_spec.rb

@@ -0,0 +1,37 @@
+require 'helper'
+
+describe Backstage do
+
+
+  it 'should construct' do
+    subject.should_not be_nil
+  end
+
+  it 'should return nil if not found' do
+    subject.get(:foo).should be_nil
+  end
+
+  it 'should return the value if found' do
+    subject.set(:foo,:foo_val).should == :foo_val
+    subject.get(:foo).should == :foo_val
+  end
+
+  it 'should replace with new values' do
+    subject.set(:foo,:foo_val).should == :foo_val
+    subject.get(:foo).should == :foo_val
+
+    subject.set(:foo,:other_val).should == :other_val
+    subject.get(:foo).should == :other_val
+  end
+
+  it 'should properly offer bracket notation' do
+    subject[:foo] = :val
+    subject[:foo].should == :val
+  end
+
+  it 'should raise if an Actor strolls off backstage' do
+    foo = create_actor
+    lambda{ subject[:foo] = foo }.should raise_error
+  end
+
+end

data/spec/core/behavior_factory_spec.rb

@@ -0,0 +1,50 @@
+require 'helper'
+
+describe BehaviorFactory do
+  let(:some_behavior) { stub('some behavior', required_behaviors: []) }
+  let(:object_context) { mock('object context') }
+  let(:some_actor) { stub('some actor', add_behavior: nil, this_object_context: object_context) }
+
+  before do
+    Behavior.define :shootable
+
+    object_context.stubs(:[]).with(:behavior).returns(some_behavior)
+    object_context.stubs(:in_subcontext).yields(object_context)
+    some_behavior.stubs(:configure)
+  end
+
+  describe "#add_behavior" do
+    it 'creates the behavior based on the actor and symbol behavior_def' do
+      some_behavior.expects(:configure).with({})
+
+      subject.add_behavior some_actor, :shootable
+    end
+
+    it 'adds the behavior to the actor' do
+      some_actor.expects(:add_behavior).with(:shootable, some_behavior)
+      subject.add_behavior some_actor, :shootable
+    end
+
+    it 'configures the behavior with the given opts' do
+      opts = {some: 'opts'}
+      some_behavior.expects(:configure).with(opts)
+
+      subject.add_behavior some_actor, :shootable, opts 
+    end
+
+    it 'raises on nil actor' do
+      lambda { subject.add_behavior nil, {} }.should raise_exception(/nil actor/)
+    end
+
+    it 'raises on nil behavior def' do
+      lambda { subject.add_behavior some_actor, nil }.should raise_exception(/nil behavior definition/)
+    end
+
+    it 'raises for missing behavior' do
+      lambda { subject.add_behavior actor, :do_not_exist }.should raise_exception
+    end
+
+    it 'creates all required behaviors'
+    it 'mixes in helpers'
+  end
+end

data/spec/core/behavior_spec.rb

@@ -0,0 +1,8 @@
+require 'helper'
+
+describe Behavior do
+  let(:actor) { create_actor }
+
+  it 'should auto-require behaviors that it depends on' 
+
+end

data/spec/core/configuration_spec.rb

@@ -0,0 +1,8 @@
+require 'helper'
+
+describe Gamebox::Configuration do
+  describe ".add_setting" do
+    it 'works with all the gamebox settings'
+    it 'can add custom settings'
+  end
+end

data/spec/core/core_spec.rb

@@ -0,0 +1,13 @@
+require 'helper'
+
+describe Gamebox do
+  describe '.configure' do
+    it 'yields the configuration object to the given block'
+    it 'raises if no block is given'
+  end
+
+  describe '.configuration' do
+    it 'returns a new configuration object on first call'
+    it 'returns the same configuration object on subsequent calls'
+  end
+end

data/spec/core/font_style_factory_spec.rb

@@ -0,0 +1,17 @@
+require 'helper'
+
+describe FontStyleFactory do
+  describe "#build" do
+    inject_mocks :this_object_context
+    let(:style) { stub }
+    before do
+      @this_object_context.stubs(:in_subcontext).yields(@this_object_context)
+      @this_object_context.stubs(:[]).with('font_style').returns style
+    end
+
+    it 'pulls the font style from the context and configures it' do
+      style.expects(:configure).with('arial', 22, :purple, 2, 0.5)
+      subject.build 'arial', 22, :purple, 2, 0.5
+    end
+  end
+end

data/spec/core/font_style_spec.rb

@@ -0,0 +1,41 @@
+require 'helper'
+
+describe FontStyle do
+  inject_mocks :resource_manager
+  let(:font) { mock }
+  
+  before do
+    @resource_manager.expects(:load_font).with("FooFace", 24).returns font
+    subject.configure "FooFace", 24, :aquamarine, 1, 1
+  end
+  
+  it 'constructs a font from style specifications' do
+    subject.name.should == "FooFace"
+    subject.size.should == 24
+    subject.color.should == :aquamarine
+    subject.x_scale.should == 1
+    subject.y_scale.should == 1
+  end
+  
+  it 'calculates the width of the given text' do
+    font.expects(:text_width).with("Blah").returns 56
+    
+    subject.calc_width("Blah").should == 56
+  end
+  
+  it 'has a height' do
+    font.expects(:height).returns 42
+    subject.height.should == 42
+  end
+  
+  it 'updates the font when the face or size change' do
+    subject.name = "Bob"
+    subject.size = 21
+    @resource_manager.expects(:load_font).with("Bob", 21).returns :newfont
+    
+    subject.reload
+    subject.font.should == :newfont
+  end
+end
+
+

data/spec/core/hooked_gosu_window_spec.rb

@@ -0,0 +1,75 @@
+require 'helper'
+
+describe HookedGosuWindow do
+  class Gosu::Window
+    def initialize(*args)
+      # TODO not sure how to handle this for travis-ci breakage..
+      # hopefully travis ci starts working again some day...
+      # sometimes causes seg faults if running bundle exec rake
+      # autorelease garbage in output if I don't do this
+    end
+  end
+
+  subject { HookedGosuWindow.new 2, 3, false }
+
+  it 'should inherit from Gosu::Window' do
+    described_class.is_a? Gosu::Window
+  end
+
+  describe "#needs_cursor?" do
+    it 'defaults to nil' do
+      subject.needs_cursor.should be_nil
+    end
+
+    it 'returns the instance variable' do
+      subject.needs_cursor = :foopy
+      subject.needs_cursor.should == :foopy
+      subject.needs_cursor?.should == :foopy
+    end
+  end
+
+  describe "#update" do
+    it 'fires initial update with full millis' do
+      Gosu.stubs(:milliseconds).returns 58
+
+      expects_event subject, :update, [[58]] do
+        subject.update
+      end
+    end
+
+    it 'fires initial update with deltas' do
+      subject.instance_variable_set('@last_millis', 30)
+      Gosu.stubs(:milliseconds).returns 58
+
+      expects_event subject, :update, [[28]] do
+        subject.update
+      end
+
+    end
+  end
+
+  describe "#draw" do
+    it 'fires the draw event' do
+      expects_event subject, :draw, [[]] do
+        subject.draw
+      end
+    end
+  end
+
+  describe "#button_down" do
+    it 'fires the button_down event' do
+      expects_event subject, :button_down, [[44]] do
+        subject.button_down 44
+      end
+    end
+  end
+
+  describe "#button_up" do
+    it 'fires the button_up event' do
+      expects_event subject, :button_up, [[44]] do
+        subject.button_up 44
+      end
+    end
+  end
+
+end

data/spec/core/input_manager_spec.rb

@@ -0,0 +1,285 @@
+require 'helper'
+
+describe InputManager do
+  inject_mocks :config_manager, :wrapped_screen
+  before do
+    @config_manager.stubs(:[] => nil)
+    @window = evented_stub(stub('window', mouse_x: 43, mouse_y: 12))
+    @wrapped_screen.stubs(screen: @window)
+    subject.register game
+  end
+  let(:game) { stub('game') }
+
+  describe "mouse drag event" do
+    it "fires 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)
+
+      fire_event(subject, MsLeft, :down)
+      pretend_event(subject, nil, :motion)
+      @window.stubs(:mouse_x).returns(to_x)
+      @window.stubs(:mouse_y).returns(to_y)
+      fire_event(subject, MsLeft, :up)
+
+    end
+  end
+
+  describe "non-id specific events" do
+    it 'calls callback for all keyboard events' do
+      key_pressed = 0
+      subject.reg :keyboard_down do
+        key_pressed += 1
+      end
+
+      fire_event(subject, KbT, :up)
+      key_pressed.should == 0
+
+      # fire_event(subject, MsLeft, :down)
+      # key_pressed.should == 0
+
+      fire_event(subject, KbT, :down)
+      key_pressed.should == 1
+    end
+
+    it 'calls callback for all mouse events' do
+      mouse_pressed = 0
+      subject.reg :mouse_down do
+        mouse_pressed += 1
+      end
+
+      fire_event(subject, MsLeft, :up)
+      mouse_pressed.should == 0
+
+      # fire_event(subject, KbT, :down)
+      # mouse_pressed.should == 0
+
+      fire_event(subject, MsLeft, :down)
+      mouse_pressed.should == 1
+    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
+
+      fire_event(subject, KbT, :down)
+      r_pressed.should == 0
+      y_pressed.should == 0
+
+      fire_event(subject, KbR, :up)
+      r_pressed.should == 0
+      y_pressed.should == 0
+
+      fire_event(subject, KbR, :down)
+      r_pressed.should == 1
+      y_pressed.should == 0
+
+      fire_event(subject, KbY, :down)
+      r_pressed.should == 1
+      y_pressed.should == 1
+
+      subject.clear_hooks self
+
+      # has now been unregistered
+      fire_event(subject, KbR, :down)
+      r_pressed.should == 1
+
+      fire_event(subject, KbY, :down)
+      y_pressed.should == 1
+    end
+
+    it 'passes along args'
+  end
+
+  describe "mapping an event id to a boolean" do
+    it "sets 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
+
+      fire_event(subject, KbLeft, :down)
+      listener.left.should be_true
+
+      fire_event(subject, GpLeft, :down)
+      listener.left.should be_true
+
+      fire_event(subject, GpLeft, :up)
+      listener.left.should be_true
+
+      fire_event(subject, KbT, :up)
+      listener.left.should be_true
+
+      fire_event(subject, KbLeft, :up)
+      listener.left.should be_false
+    end
+  end
+
+  describe "mapping multiple keys to a boolean" do
+    it "sets an ivar to true as long as ANY of the keys are down" do
+      listener = Struct.new(:left).new
+      subject.while_pressed [KbLeft, GpLeft], listener, :left
+
+      listener.left.should be_false
+
+      fire_event(subject, KbLeft, :down)
+      listener.left.should be_true
+
+      fire_event(subject, GpLeft, :down)
+      listener.left.should be_true
+
+      fire_event(subject, KbT, :up)
+      listener.left.should be_true
+
+      fire_event(subject, KbP, :down)
+      listener.left.should be_true
+
+      fire_event(subject, GpLeft, :up)
+      listener.left.should be_true
+
+      fire_event(subject, KbLeft, :up)
+      listener.left.should be_false
+    end
+  end
+
+  describe 'clearing events' do
+    it 'clears an event by listener when registered by button id' do
+      pressed = false
+      subject.reg :keyboard_down, KbLeft do
+        pressed = true
+      end
+
+      subject.clear_hooks self
+      fire_event(subject, KbLeft, :down)
+      pressed.should == false
+    end
+
+    it 'clears an event by listener when registered without button id' do
+      pressed = false
+      subject.reg :keyboard_down do
+        pressed = true
+      end
+
+      subject.clear_hooks self
+      fire_event(subject, KbLeft, :down)
+      pressed.should == false
+    end
+
+    it 'clears all events if no listener is provided' do
+      pressed = false
+      subject.reg :keyboard_down do
+        pressed = true
+      end
+
+      subject.clear_hooks
+      fire_event(subject, KbLeft, :down)
+      pressed.should == false
+    end
+
+  end
+
+  describe "#show" do
+    before do
+      @window.stubs(:show)
+      @wrapped_screen.stubs(screen: @window)
+    end
+
+    it 'shows the window' do
+      @window.expects(:show)
+      subject.show
+    end
+  end
+
+  describe "#register" do
+    it 'handles an update event' do
+      game.expects(:update).with(:millis)
+      @window.fire :update, :millis
+    end
+
+    it 'handles a draw event' do
+      game.expects(:draw)
+      @window.fire :draw
+    end
+  end
+
+  describe 'registering actors' do
+    it 'unregisters actors on death' do
+      subject
+      tom_cruise = create_actor :actor
+      called = false
+      subject.send :_register_hook, tom_cruise, :down, KbSpace do
+        called = true
+      end
+
+      tom_cruise.send :fire, :remove_me, tom_cruise
+      fire_event(subject, KbSpace, :down)
+      called.should be_false
+    end
+  end
+
+  it 'tracks the mouse motion events'
+  it 'cleanly removes handlers not using ids'
+  describe 'pausing' do
+    it 'pause/unpause' do
+      key_pressed = 0
+      subject.reg :keyboard_down do
+        key_pressed += 1
+      end
+
+      fire_event(subject, KbT, :down)
+      key_pressed.should == 1
+
+      subject.pause
+
+      fire_event(subject, KbT, :down)
+      key_pressed.should == 1
+
+      paused_pressed = 0
+      subject.reg :keyboard_down do
+        paused_pressed += 1
+      end
+
+      fire_event(subject, KbT, :down)
+      paused_pressed.should == 1
+
+      subject.unpause
+      fire_event(subject, KbT, :down)
+      paused_pressed.should == 1
+      key_pressed.should == 2
+    end
+  end
+
+  private
+  def fire_event(target, id, direction)
+    @window.fire "button_#{direction}".to_sym, id
+  end
+
+  def pretend_event(target, id, direction)
+    target.send :handle_event, id, direction
+  end
+
+end