gamebox 0.4.1 → 0.5.0

data/lib/gamebox/spec/helper.rb

@@ -23,6 +23,7 @@ module GameboxSpecHelpers
       before { 
         @_beh_mock_names = Behavior.object_definition.component_names
         @actor = evented_stub(mock("actor_for_#{behavior_name}"))
+        @actor.stubs(has_attribute: nil, do_or_do_not: nil)
         @_mocks_created = create_mocks *(@_beh_mock_names - [:actor])
         @_mocks_created[:actor] = @actor
 
@@ -206,9 +207,7 @@ class EventedStub
   def method_missing(name, *args)
     @inner_stub.send name, *args
   end
-  def fire(*args)
-    super
-  end
+  public :fire
 end
 
 module GameboxAcceptanceSpecHelpers

data/lib/gamebox/tasks/gamebox_tasks.rake

@@ -49,7 +49,7 @@ namespace :generate do
       File.open(File.join(File.dirname(__FILE__), "../../..", "/templates/#{generator_name}_template.erb")) do |io|
         template = ERB.new io.read
         instance_variable_set("@#{generator_name}_name", args["#{generator_name}_name"])
-        File.open "#{APP_ROOT}src/#{ generator_name}s/#{args["#{generator_name}_name"]}_#{generator_name}.rb", "w" do |out|
+        File.open "#{APP_ROOT}src/#{ generator_name}s/#{args["#{generator_name}_name"]}.rb", "w" do |out|
           out.puts template.result binding
         end
       end
@@ -57,92 +57,3 @@ namespace :generate do
   end
 end
 
-namespace :dist do
-  desc "Build a .app for your gamebox game"
-  task :mac do
-    GAME_NAME = "UntitledGame" unless defined?(GAME_NAME)
-    # DL template os x app
-    remote_file = "gosu-mac-wrapper-#{Gosu::VERSION}.tar.gz"
-    mac_build = "#{APP_ROOT}build/mac"
-    local_file = "#{mac_build}/#{remote_file}"
-
-    require 'net/http'
-    mkdir_p mac_build
-    # if false
-      Net::HTTP.start("www.libgosu.org") do |http|
-        resp = http.get("/downloads/#{remote_file}")
-        open(local_file, "wb") { |file| file.write(resp.body) }
-      end
-    # end
-
-    # Expand it
-    cd mac_build
-    `tar xzf #{remote_file}`
-    app_name = "#{GAME_NAME}.app"
-    contents = "#{app_name}/Contents"
-    resources = "#{contents}/Resources"
-    dot_app_lib = "#{resources}/lib"
-    gem_vendored = "#{mac_build}/#{resources}/gems"
-
-    mv 'RubyGosu App.app', app_name
-    %w(config data src).each do |src|
-      cp_r "../../#{src}", resources
-    end
-
-    # TODO remove chingu / chipmunk / etc
-    clean_em_out = %w(chingu chingu.rb).map{|it| "#{dot_app_lib}/#{it}"}
-    rm_rf clean_em_out#, :verbose => true, :noop => true
-
-    cd APP_ROOT
-    p `bundle --system package`
-    p `bundle package`
-    p `bundle --deployment`
-    mkdir_p gem_vendored
-    rejects = %w(chipmunk gosu)
-    Dir["vendor/bundle/ruby/**/gems/**/lib"].each do |gemmy|
-      cp_r gemmy, gem_vendored unless rejects.any?{|exclude| gemmy.match exclude}
-    end
-
-    cd mac_build
-    File.open "#{resources}/Main.rb", "w+" do |main|
-      main.puts <<-EOS
-      $: << "\#{File.dirname(__FILE__)}/config"
-
-      $: << "\#{File.dirname(__FILE__)}/gems/lib"
-
-      rejects = %w(spec src/app.rb vendor Main.rb)
-      ok_dirs = %w(config gems src)
-      REQUIRE_ALLS = ok_dirs.map{|dir| Dir.glob("\#{dir}/*.rb").reject{ |f| rejects.any?{|exclude| f.match exclude}}}.flatten
-
-      require 'environment'
-
-      GameboxApp.run ARGV, ENV
-      EOS
-    end
-
-    # modify plist file
-    # UntitledGame
-    cd "#{GAME_NAME}.app/Contents"
-    plist = File.open("Info.plist").read
-    File.open("Info.plist", 'w+') do |f|
-      f.puts plist.gsub "UntitledGame", GAME_NAME
-    end
-  end
-
-  task :win do
-    # create dist dir
-    FileUtils.mkdir "#{APP_ROOT}dist" unless File.exist? "dist"
-    # pull down windows app shell
-    # expand into place
-    sh 'cd #{APP_ROOT}dist; wget http://github.com/downloads/shawn42/gamebox/gamebox_app.zip; unzip gamebox_app.zip; mv gamebox_app/* .; rm gamebox_app.zip; rm -rf gamebox_app'
-
-    # copy config/src/lib/data into dist/src
-    %w{vendor config data }.each do |dir|
-      FileUtils.cp_r dir, File.join('dist','src', dir) if File.exist? dir
-    end
-    FileUtils.cp_r 'src', File.join('dist', 'src')
-
-    # create zip of dist?
-  end
-end
-

data/lib/gamebox/version.rb

@@ -1,8 +1,8 @@
 module Gamebox
   module VERSION #:nodoc:
     MAJOR = 0
-    MINOR = 4
-    TINY  = 1
+    MINOR = 5
+    TINY  = 0
     RC    = 0
 
     if RC > 0

data/lib/gamebox/views/graphical_actor_view.rb

@@ -17,6 +17,14 @@ define_actor_view :graphical_actor_view do
     x_scale = actor.do_or_do_not(:x_scale) || 1
     y_scale = actor.do_or_do_not(:y_scale) || 1
 
+    anchor_x = 0.5
+    anchor_y = 0.5
+    anchor_point = actor.do_or_do_not(:anchor) || :center
+    if anchor_point == :top_left
+      anchor_x = 0
+      anchor_y = 0
+    end
+
     if actor.do_or_do_not(:tiled)
       x_tiles = actor.num_x_tiles
       y_tiles = actor.num_y_tiles
@@ -25,16 +33,13 @@ define_actor_view :graphical_actor_view do
       x_tiles.times do |col|
         y_tiles.times do |row|
           # TODO why is there a nasty black line between these that jitters?
+          # is it float precision vs integers for location?
           img.draw offset_x+col*img_w, offset_y+row*img_h, z, x_scale, y_scale
         end
       end
     else
-      rot = actor.do_or_do_not :rotation
-      if rot
-        img.draw_rot offset_x, offset_y, z, rot, 0.5, 0.5, x_scale, y_scale, color
-      else
-        img.draw offset_x, offset_y, z, x_scale, y_scale, color
-      end
+      rot = actor.do_or_do_not(:rotation) || 0
+      img.draw_rot offset_x, offset_y, z, rot, anchor_x, anchor_y, x_scale, y_scale, color
     end
   end
 

data/spec/acceptance/input_mapper_spec.rb

@@ -8,33 +8,33 @@ describe "Using input mapper", acceptance: true do
   it 'sets actor state based on input' do
     game.stage do |stage| # instance of TestingStage
       foxy = create_actor :foxy
-      foxy.input.map_input 'left' => :move_left,
-                           'right' => :move_right,
-                           'd' => :move_right
+      foxy.controller.map_controls 'left'  => :move_left,
+                                   'right' => :move_right,
+                                   'd'     => :move_right
     end
 
-    input = game.actor(:foxy).input
-    input.move_left?.should be_false
-    input.move_right?.should be_false
+    controller = game.actor(:foxy).controller
+    controller.move_left?.should be_false
+    controller.move_right?.should be_false
 
     press_key KbLeft
     press_key KbD
 
-    input.move_left?.should be_true
-    input.move_right?.should be_true
+    controller.move_left?.should be_true
+    controller.move_right?.should be_true
 
     release_key KbD
-    input.move_left?.should be_true
-    input.move_right?.should be_false
+    controller.move_left?.should be_true
+    controller.move_right?.should be_false
 
 
     press_key KbRight
-    input.move_left?.should be_true
-    input.move_right?.should be_true
+    controller.move_left?.should be_true
+    controller.move_right?.should be_true
 
     release_key KbRight
-    input.move_left?.should be_true
-    input.move_right?.should be_false
+    controller.move_left?.should be_true
+    controller.move_right?.should be_false
   end
 
 end

data/spec/actors/label_spec.rb

@@ -12,10 +12,13 @@ describe :label do
   describe "#behavior" do
     subjectify_behavior(:label)
 
+    let(:stylish_font) { stub(calc_width: 22, height: 30) }
+
     before do
-      @actor.stubs(has_attributes: nil, font_name: "fonty.ttf",
-                   font_size: 22, color: :red)
+      @actor.stubs(has_attributes: nil, font_name: "fonty.ttf", text: "some text",
+                   font_size: 22, color: :red, :width= => nil, :height= => nil)
       @font_style_factory.stubs(:build)
+      @actor.stubs(:font_style).returns(stylish_font)
     end
 
     it 'sets up attributes on actor' do
@@ -27,8 +30,14 @@ describe :label do
         width:     0,
         height:    0,
         layer:     1)
-      @font_style_factory.stubs(:build).with('fonty.ttf', 22, :red).returns(:stylish_font)
-      @actor.expects(:has_attributes).with(font_style: :stylish_font)
+      @font_style_factory.stubs(:build).with('fonty.ttf', 22, :red).returns(stylish_font)
+      @actor.expects(:has_attributes).with(font_style: stylish_font)
+
+      stylish_font.stubs(:calc_width).with("some text").returns(:some_stylish_width)
+      stylish_font.stubs(:height).returns(:some_stylish_height)
+
+      @actor.expects(:width=).with(:some_stylish_width)
+      @actor.expects(:height=).with(:some_stylish_height)
      
       subject
     end

data/spec/behaviors/collidable_spec.rb

@@ -22,12 +22,12 @@ describe :collidable do
   let!(:actor) { subcontext[:actor] }
 
   before do
-    @stage.stubs(:register_collidable)
+    @stage.stubs :register_collidable
   end
 
   describe "aabb shape" do
     let(:opts) do
-      {:shape => :aabb,
+      {shape: :aabb,
         :cw_world_points => [
           [-15,10],[15,10],
           [15,-10], [-15,10]

data/spec/behaviors/positioned_spec.rb

@@ -1,52 +1,49 @@
 require 'helper'
 
 describe :positioned do
+  subjectify_behavior :positioned
 
-  subject { subcontext[:behavior_factory].add_behavior actor, :positioned, opts }
-  let(:director) { evented_stub(stub_everything('director')) }
-  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
-    end
-    it
-  end
-  let!(:actor) { subcontext[:actor] }
   let(:opts) { {} }
+  before do 
+    actor.stubs(:has_attributes)
+  end
 
   context "empty options" do
-    it 'defines x,y on actor' do
+    it 'defines x,y,position on actor' do
+      actor.expects(:has_attributes).with(x: 0, y: 0, position: vec2(0,0))
       subject
-      actor.x.should == 0
-      actor.y.should == 0
     end
   end
 
-  it 'keeps position up to date w/ x and y' do
+  it 'updates position on x change' do
     subject
-    called = 0
-    actor.when(:position_changed) do
-      called += 1
-    end
-    actor.x = 99
-    called.should == 1
 
-    actor.y = 8
+    actor.expects(:position=).with(vec2(1,2))
+    actor.stubs(x: 1, y: 2)
+    actor.fire(:x_changed)
+  end
 
-    called.should == 2
-    actor.position.x.should == 99
-    actor.position.y.should == 8
+  it 'updates position on y change' do
+    subject
+
+    actor.expects(:position=).with(vec2(1,2))
+    actor.stubs(x: 1, y: 2)
+    actor.fire(:y_changed)
   end
 
   context "options passed in" do
     let(:opts) { { x: 5, y: 8} }
-    it 'defines x,y on actor' do
+    it 'defines x,y,position on actor' do
+      actor.expects(:has_attributes).with(x: 5, y: 8, position: vec2(5,8))
       subject
-      actor.x.should == 5
-      actor.y.should == 8
     end
   end
+
+  it "keeps x and y up to date if position changes" do
+    subject
+
+    actor.expects(:update_attributes).with(x: 2, y: 3)
+    actor.stubs(position: vec2(2,3))
+    actor.fire(:position_changed)
+  end
 end

data/spec/core/actor_spec.rb

@@ -48,10 +48,10 @@ describe Actor do
     end
   end
 
-  describe "#input" do
+  describe "#controller" do
     it 'pulls an input mapper from the context' do
       @this_object_context.stubs(:[]).with(:input_mapper).returns(:mapz)
-      subject.input.should == :mapz
+      subject.controller.should == :mapz
     end
   end
 

data/spec/core/input_mapper_spec.rb

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

data/spec/core/resource_manager_spec.rb

@@ -1,12 +1,28 @@
 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
+  context 'no image_name' do
+    let(:actor) { stub 'actor', actor_type: 'string', do_or_do_not: nil }
+
+    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
+
+  context 'with image_name' do
+    let(:actor) { 
+      a = stub('actor')
+      a.stubs(:do_or_do_not).with(:image_name).returns('string')
+      a
+    }
+
+    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
 
 end

data/spec/core/viewport_spec.rb

@@ -20,29 +20,205 @@ describe Viewport do
     subject.x_offset.should == 0
     subject.y_offset.should == 0
   end
-  
-  it 'should center the viewport on an actor when follow' do
-    actor = Vec.new 900, 200
-    subject.follow actor
-    
-    subject.x_offset.should == -500
-    subject.y_offset.should == 100
-    subject.follow_target.should equal(actor)
+
+  describe "#stay_centered_on" do
+
+    it 'should center the viewport on an actor when stay_centered_on' do
+      actor = Vec.new 900, 200
+      subject.stay_centered_on actor
+
+      subject.x_offset.should == -500
+      subject.y_offset.should == 100
+      subject.follow_target.should equal(actor)
+    end
+
+    it 'should center the viewport on an actor (plus offset) when stay_centered_on' do
+      actor = Vec.new 900, 200
+      subject.stay_centered_on actor, x_offset: -40, y_offset: 20
+
+      subject.x_offset.should == -460
+      subject.y_offset.should == 80
+      subject.follow_target.should equal(actor)
+    end
+
+    it 'should stay_centered_on a target if target has gone right;down of its buffer' do
+      actor = Vec.new 900, 200
+      subject.stay_centered_on actor, x_chain_length: 100, y_chain_length: 200
+
+      subject.update 100
+      actor.x = 990
+      actor.y = 390
+
+      subject.update 100
+      subject.x_offset.should == -500
+      subject.y_offset.should == 100
+
+      actor.x = 1001
+      actor.y = 401
+      subject.update 100
+
+      subject.x_offset.should == -501
+      subject.y_offset.should == 99
+    end
+
+    it 'should stay_centered_on a target if target has gone left;up of its buffer' do
+      actor = Vec.new 900, 200
+      subject.expects(:fire).with(:scrolled).twice
+      subject.stay_centered_on actor, x_chain_length: 100, y_chain_length: 200
+
+      subject.update 100
+      actor.x = 810
+      actor.y = 10
+
+      subject.update 100
+      subject.x_offset.should == -500
+      subject.y_offset.should == 100
+
+      actor.x = 799
+      actor.y = -1
+      subject.update 100
+
+      subject.x_offset.should == -499
+      subject.y_offset.should == 101
+    end
+
+    it 'should respect the speed setting' do
+      actor = Vec.new 900, 200
+      subject.speed = 0.5
+      subject.stay_centered_on actor, x_chain_length: 100, y_chain_length: 200
+
+      subject.update 100
+      actor.x = 990
+      actor.y = 390
+
+      subject.update 100
+      subject.x_offset.should == -500
+      subject.y_offset.should == 100
+
+      actor.x = 1002
+      actor.y = 402
+      subject.update 100
+
+      subject.x_offset.should == -501
+      subject.y_offset.should == 99
+
+    end
+
+    it 'should fire :scrolled event when targeting an actor' do
+      actor = Vec.new 900, 200
+      subject.expects(:fire).with(:scrolled)
+      subject.stay_centered_on actor, x_chain_length: 100, y_chain_length: 200
+    end
+  end
+
+  describe "#follow" do
+
+    it 'should center the viewport on an actor when follow' do
+      actor = Vec.new 900, 200
+      subject.follow actor
+
+      subject.x_offset.should == -500
+      subject.y_offset.should == 100
+      subject.follow_target.should equal(actor)
+    end
+
+    it 'should center the viewport on an actor (plus offset) when follow' do
+      actor = Vec.new 900, 200
+      subject.follow actor, [40,-20]
+
+      subject.x_offset.should == -460
+      subject.y_offset.should == 80
+      subject.follow_target.should equal(actor)
+    end
+
+    it 'should follow a target if target has gone right;down of its buffer' do
+      actor = Vec.new 900, 200
+      subject.follow actor, [0,0], [100,200] 
+
+      subject.update 100
+      actor.x = 990
+      actor.y = 390
+
+      subject.update 100
+      subject.x_offset.should == -500
+      subject.y_offset.should == 100
+
+      actor.x = 1001
+      actor.y = 401
+      subject.update 100
+
+      subject.x_offset.should == -501
+      subject.y_offset.should == 99
+    end
+
+    it 'should follow a target if target has gone left;up of its buffer' do
+      actor = Vec.new 900, 200
+      subject.expects(:fire).with(:scrolled).twice
+      subject.follow actor, [0,0], [100,200] 
+
+      subject.update 100
+      actor.x = 810
+      actor.y = 10
+
+      subject.update 100
+      subject.x_offset.should == -500
+      subject.y_offset.should == 100
+
+      actor.x = 799
+      actor.y = -1
+      subject.update 100
+
+      subject.x_offset.should == -499
+      subject.y_offset.should == 101
+    end
+
+    it 'should respect the speed setting' do
+      actor = Vec.new 900, 200
+      subject.speed = 0.5
+      subject.follow actor, [0,0], [100,200]
+
+      subject.update 100
+      actor.x = 990
+      actor.y = 390
+
+      subject.update 100
+      subject.x_offset.should == -500
+      subject.y_offset.should == 100
+
+      actor.x = 1002
+      actor.y = 402
+      subject.update 100
+
+      subject.x_offset.should == -501
+      subject.y_offset.should == 99
+
+    end
+
+    it 'should fire :scrolled event when targeting an actor' do
+      actor = Vec.new 900, 200
+      subject.expects(:fire).with(:scrolled)
+      subject.follow actor, [0,0], [100,200] 
+    end
+
   end
-  
-  it 'should center the viewport on an actor (plus offset) when follow' do
-    actor = Vec.new 900, 200
-    subject.follow actor, [40,-20]
-    
-    subject.x_offset.should == -460
-    subject.y_offset.should == 80
-    subject.follow_target.should equal(actor)
+
+  it 'enforces speed is >= 0 and <= 1' do
+    subject.speed.should == 1
+
+    subject.speed = 0
+    subject.speed.should == 0
+
+    subject.speed = 2
+    subject.speed.should == 1
+
+    subject.speed = 0.1
+    subject.speed.should be_within(0.001).of(0.1)
   end
-  
+
   it 'should respect parallax scrolling layers for offsets' do
     subject.x_offset = -200
     subject.y_offset = -300
-    
+
     subject.x_offset(2).should == -100
     subject.y_offset(2).should == -150
   end
@@ -50,102 +226,20 @@ describe Viewport do
   it 'should return a zero offset on INFINITY' do
     subject.x_offset = -200
     subject.y_offset = -300
-    
+
     subject.x_offset(Float::INFINITY).should == 0
     subject.y_offset(Float::INFINITY).should == 0
   end
-  
-  it 'shouldn\'t update anything unless following a target' do
+
+  it "shouldn't update anything unless following a target" do
     subject.x_offset = -200
     subject.y_offset = -300
-    
+
     subject.update 3000
-    
+
     subject.x_offset.should == -200
     subject.y_offset.should == -300
   end
-  
-  it 'should follow a target if target has gone right;down of its buffer' do
-    actor = Vec.new 900, 200
-    subject.follow actor, [0,0], [100,200] 
-    
-    subject.update 100
-    actor.x = 990
-    actor.y = 390
-    
-    subject.update 100
-    subject.x_offset.should == -500
-    subject.y_offset.should == 100
-    
-    actor.x = 1001
-    actor.y = 401
-    subject.update 100
-    
-    subject.x_offset.should == -501
-    subject.y_offset.should == 99
-  end
-  
-  it 'should follow a target if target has gone left;up of its buffer' do
-    actor = Vec.new 900, 200
-    subject.expects(:fire).with(:scrolled).twice
-    subject.follow actor, [0,0], [100,200] 
-    
-    subject.update 100
-    actor.x = 810
-    actor.y = 10
-
-    subject.update 100
-    subject.x_offset.should == -500
-    subject.y_offset.should == 100
-    
-    actor.x = 799
-    actor.y = -1
-    subject.update 100
-    
-    subject.x_offset.should == -499
-    subject.y_offset.should == 101
-  end
-
-  it 'should respect the speed setting' do
-    actor = Vec.new 900, 200
-    subject.speed = 0.5
-    subject.follow actor, [0,0], [100,200]
-    
-    subject.update 100
-    actor.x = 990
-    actor.y = 390
-    
-    subject.update 100
-    subject.x_offset.should == -500
-    subject.y_offset.should == 100
-
-    actor.x = 1002
-    actor.y = 402
-    subject.update 100
-    
-    subject.x_offset.should == -501
-    subject.y_offset.should == 99
-
-  end
-
-  it 'enforces speed is >= 0 and <= 1' do
-    subject.speed.should == 1
-
-    subject.speed = 0
-    subject.speed.should == 0
-
-    subject.speed = 2
-    subject.speed.should == 1
-
-    subject.speed = 0.1
-    subject.speed.should be_within(0.001).of(0.1)
-  end
-  
-  it 'should fire :scrolled event when targeting an actor' do
-    actor = Vec.new 900, 200
-    subject.expects(:fire).with(:scrolled)
-    subject.follow actor, [0,0], [100,200] 
-  end
 
   describe "#bounds" do
     it 'returns the bounds as [x1,y1,x2,y2]' do
@@ -157,9 +251,9 @@ describe Viewport do
       bounds = subject.bounds
       bounds.left.should == 10
       bounds.top.should == 100
-      bounds.width.should == 810
-      bounds.height.should == 700
+      bounds.width.should == 800
+      bounds.height.should == 600
     end
   end
-  
+
 end