gamebox 0.2.1 → 0.3.2

data/lib/gamebox/views/graphical_actor_view.rb

@@ -1,43 +1,49 @@
-require 'actor_view'
+
 
 class GraphicalActorView < ActorView
   def draw(target, x_off, y_off, z)
-    x = @actor.x
-    y = @actor.y
+    x = actor.x
+    y = actor.y
 
     offset_x = x+x_off
     offset_y = y+y_off
 
-    img = @actor.image
+    img = actor.image
     return if img.nil?
 
-    #if @actor.is? :animated or 
-    if @actor.is? :physical
+    alpha = actor.respond_to?(:alpha) ? actor.alpha : 0xFF
+    color = Color.new(alpha,0xFF,0xFF,0xFF)
+
+    x_scale = actor.x_scale
+    y_scale = actor.y_scale
+
+    if actor.is? :physical
       img_w = img.width
       img_h = img.height
 
-      offset_x = x-img_w/2 + x_off
-      offset_y = y-img_h/2 + y_off
-      img.draw_rot offset_x, offset_y, z, @actor.rotation
+      img.draw_rot offset_x, offset_y, z, actor.rotation, 0.5, 0.5, x_scale, y_scale
     else
-      graphical_behavior = @actor.graphical if @actor.is? :graphical
+      graphical_behavior = actor.graphical if actor.is? :graphical
       if graphical_behavior && graphical_behavior.tiled?
         x_tiles = graphical_behavior.num_x_tiles
         y_tiles = graphical_behavior.num_y_tiles
-#        img_w, img_h = *img.size
         img_w = img.width
         img_h = img.height
         x_tiles.times do |col|
           y_tiles.times do |row|
-#            img.blit target.screen, [offset_x+col*img_w,offset_y+row*img_h]
-            img.draw offset_x+col*img_w, offset_y+row*img_h, z
+            # TODO why is there a nasty black line between these that jitters?
+            img.draw_rot offset_x+col*img_w, offset_y+row*img_h, z, actor.rotation, x_scale, y_scale
           end
         end
       else
-#        img.blit target.screen, [offset_x,offset_y]
-        img.draw offset_x, offset_y, z
+        if actor.respond_to? :rotation
+          rot = actor.rotation || 0.0
+          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
       end
     end
-    target.draw_line(offset_x,offset_y,offset_x+1,offset_y+1,[255,10,10],z)
   end
+
 end

data/lib/gamebox/wrapped_screen.rb

@@ -12,6 +12,14 @@ class WrappedScreen
     @screen.send name, *args
   end
 
+  def width
+    @screen.fullscreen? ? screen_width : @screen.width
+  end
+
+  def height
+    @screen.fullscreen? ? screen_height : @screen.height
+  end
+
   def draw_box(x1,y1,x2,y2,color, z)
     c = convert_color(color)
     @screen.draw_line x1, y1, c, x2, y1, c, z
@@ -28,7 +36,7 @@ class WrappedScreen
   CIRCLE_STEP = 10
   # is very expensive
   # cache it if you can somehow
-  def draw_circle(cx,cy,r,color, z)
+  def draw_circle(cx,cy,r,color, z, step=CIRCLE_STEP)
     c_color = convert_color(color)
     
     x1, y1 = 0, -r

data/script/perf_spatial_hash.rb

@@ -1,73 +1,64 @@
-$: << File.dirname(__FILE__)+"/../lib/gamebox"
+require 'bundler'
+Bundler.setup
 
-require 'spatial_hash'
-require 'new_spatial_hash'
+require 'constructor'
+require 'publisher'
+require 'gamebox'
 require 'benchmark'
 
-Shape = Struct.new(:x,:y,:width,:height)
+class Arb 
+  include Arbiter
+  extend Publisher
+  can_fire_anything
 
-def do_it(hash, num_times, obj_size)
-  num_times.times do |i|
-    hash.add(Shape.new(i,i,obj_size,obj_size))
+  def initialize(spatial)
+    @spatial = spatial
+    on_collision_of :otherthingy, :thingy do |f,b|
+      puts "collide"
+    end
   end
-
-  num_times.times do |i|
-    hash.items_at i, i
+  def stagehand(name)
+    @spatial
   end
 
-  hash.rehash
-  hash.rehash
-  hash.rehash
-  hash.rehash
+end
 
-  num_times.times do |i|
-    hash.items_at i, i
+class Shape 
+  extend Publisher
+  can_fire_anything
+  attr_accessor :x,:y,:width,:height,:collidable_shape,:radius
+  def initialize(*args)
+    @x,@y,@width,@height,@collidable_shape,@radius = *args
   end
+    
+  def center_x;self.x;end
+  def center_y;self.y;end
+  def actor_type;:thingy;end
 end
 
-OldSpatialHash = SpatialHash
-
-Benchmark.bm(60) do|b|
-  
-  @lots = 1_000
-  @small_grid = 5
-  @medium_grid = 80
-
-  @small_object = 2
-  @medium_object = 20
-  @large_object = 100
-
-  impls = %w{old new}
-  impls.each do |impl|
-    klass = ObjectSpace.const_get "#{impl.capitalize}SpatialHash"
-    b.report("#{impl} w/ lots of small objects in small size grid") do
-      hash = klass.new @small_grid, true
-      do_it(hash,@lots, @small_object)
-    end
-
-    b.report("#{impl} w/ lots of medium objects in small size grid") do
-      hash = klass.new @small_grid, true
-      do_it(hash,@lots, @medium_object)
-    end
-
-    b.report("#{impl} w/ lots of small objects in medium size grid") do
-      hash = klass.new @medium_grid, true
-      do_it(hash,@lots, @small_object)
-    end
+actor_count = 100
+loop_count = 100
+obj_size = 40
+cell_size = 80
 
-    b.report("#{impl} w/ lots of medium objects in medium size grid") do
-      hash = klass.new @medium_grid, true
-      do_it(hash,@lots, @medium_object)
-    end
+hash = SpatialHash.new cell_size#, true
+arb = Arb.new hash
+actor_count.times do |i|
+  shape = Shape.new(i*20, i*20, obj_size,obj_size,:circle,obj_size)
+  arb.register_collidable shape
+end
 
-    b.report("#{impl} w/ lots of large objects in small size grid") do
-      hash = klass.new @small_grid, true
-      do_it(hash,@lots, @large_object)
-    end
-    b.report("#{impl} w/ lots of large objects in small size grid no resize") do
-      hash = klass.new @small_grid, false
-      do_it(hash,@lots, @large_object)
+ Benchmark.bm(60) do|b|
+ #30.times do |i|
+   hash_cell_size = cell_size #+ 5*i
+   hash.cell_size = hash_cell_size
+   b.report("#{actor_count} actors w/ size #{obj_size} cell size #{hash_cell_size} for #{loop_count} update loops") do
+    loop_count.times do
+      hash.rehash
+      arb.find_collisions
     end
-  end
+   end
+  end 
+ #end
 
-end
+puts "hash auto-size:#{hash.cell_size}"

data/script/perf_struct_vs_array.rb

@@ -0,0 +1,32 @@
+require 'benchmark'
+
+# Point = Struct.new :x, :y
+class Point
+  attr_accessor :x, :y
+  def initialize(x,y)
+    @x = x
+    @y = y
+  end
+end
+NUM = 10_000_000
+Benchmark.bm(60) do |b|
+  b.report("array") do
+    NUM.times do 
+      it = [4,6]
+      it[0] = 1
+      it[1] = 3
+      it[0]
+      it[1]
+    end
+  end
+  b.report("struct") do
+    NUM.times do 
+      it = Point.new 4, 6
+      it.x = 1
+      it.y = 3
+      it.x 
+      it.y 
+    end
+  end
+end
+

data/spec/actor_factory_spec.rb

@@ -0,0 +1,61 @@
+require File.join(File.dirname(__FILE__),'helper')
+describe ActorFactory do
+  before do
+    @input_manager = mock
+    @screen = mock
+    @stage = mock
+    @resource_manager = mock
+    @stage = mock
+    @stage.stubs(:resource_manager).returns(@resource_manager)
+    @director = mock
+    params = {:input_manager => @input_manager, :wrapped_screen => @screen}
+    @target = ActorFactory.new params
+    @target.director = @director
+    @opts = Actor::DEFAULT_PARAMS.merge({:foo => :bar})
+    @basic_opts = {
+      :stage => @stage,
+      :input => @input_manager,
+      :director => @director,
+      :resources => @resource_manager,
+      :wrapped_screen => @screen,
+    }
+    @merged_opts = @basic_opts.merge(@opts)
+    
+  end
+  
+  describe "#build" do
+    it "creates an Actor instance and registers the view" do
+
+      view_actor = nil
+      @stage.expects(:register_drawable).with() do |view|
+        view.class.should == ActorView
+        view.stage.should == @stage
+        view.wrapped_screen.should == @screen
+        view.actor.class.should == Actor
+        view_actor = view.actor
+      end
+      @merged_opts[:actor_type] = :actor
+      
+      act = @target.build :actor, @stage, @opts
+      act.opts.should == @merged_opts
+      act.class.should == Actor
+      act.should == view_actor
+    end
+    
+    it "creates an Actor instance with no view" do
+      @merged_opts[:actor_type] = :no_view_actor
+      
+      act = @target.build :no_view_actor, @stage, @opts
+      act.opts.should == @merged_opts
+      act.class.should == NoViewActor
+    end
+    
+    it "nil on actor not found" do
+      lambda{ @target.build :no_actor, @stage, @opts }.should raise_error("no_actor not found")
+    end
+    
+  end
+  
+  class NoViewActor < Actor
+  end
+end

data/spec/actor_spec.rb

@@ -1,42 +1,40 @@
 require File.join(File.dirname(__FILE__),'helper')
-require 'actor'
-require 'behavior'
-
 describe 'A new actor' do
-  before do
-    opts = {:stage=>"stage", :input=>"input", 
+  let(:stage) { mock }
+  subject { 
+    opts = {:stage=>stage, :input=>"input", 
       :resources=>"resource", :actor_type => :actor}
-    @actor = Actor.new opts
-  end
+    Actor.new opts
+  }
 
   it 'should be alive' do
-    @actor.alive?.should be_true
+    subject.alive?.should be_true
   end
 
   it 'should be the correct type' do
-    @actor.actor_type.should == :actor
+    subject.actor_type.should == :actor
   end
 
   it 'should be at (0,0)' do
-    @actor.x.should equal(0)
-    @actor.y.should equal(0)
+    subject.x.should equal(0)
+    subject.y.should equal(0)
   end
 
   it 'should have access to backstage' do
-    @actor.stage = mock(:backstage => :stuff)
-    @actor.backstage.should == :stuff
+    subject.stage = mock(:backstage => :stuff)
+    subject.backstage.should == :stuff
   end
 
   it 'should have atts set' do
-    @actor.stage.should == "stage" 
-    @actor.input_manager.should == "input" 
-    @actor.resource_manager.should == "resource" 
-    @actor.behaviors.size.should equal(0)
+    subject.stage.should == stage 
+    subject.input_manager.should == "input" 
+    subject.resource_manager.should == "resource" 
+    subject.behaviors.size.should equal(0)
   end
 
   it 'should fire anything' do
     Proc.new {
-      @actor.when :foofoo_bar do
+      subject.when :foofoo_bar do
         "blah"
       end
     }.should_not raise_error
@@ -52,6 +50,14 @@ describe 'A new actor' do
     @james.is?(:smart).should be_true
     @james.instance_variable_get('@behaviors')[:smart].instance_variable_get('@opts').should == {:really=>true}
   end
+
+  describe '#viewport' do
+    it 'should return the stages viewport' do
+      stage.stubs(:viewport).returns(:da_viewport)
+      subject.viewport.should == :da_viewport
+    end
+  end
+
 end
 
 class Cool < Behavior; end

data/spec/actor_view_spec.rb

@@ -1,16 +1,61 @@
 require File.join(File.dirname(__FILE__),'helper')
-require 'actor_view'
+
 
 describe 'A new actor view' do
+  before do
+    @actor = mock
+    @stage = mock
+    @actor.stubs :when
+  end
 
   it 'should be layered 0/1 by default' do
-    @test_me = ActorView.new :stage, Actor.new({}), :wrapped_screen
+    @actor.expects(:is?).with(:layered).returns(false)
+    @test_me = ActorView.new @stage, @actor, :wrapped_screen
     @test_me.layer.should == 0
     @test_me.parallax.should == 1
   end
 
-  it 'should call setup on creation; tests that require subclassing seem wrong...'
-  it 'should accept layered behavior params from actor'
-  it 'should register for show/hide/remove events'
-  it 'should manage a cached surface for drawing'
+  it 'should call setup on creation' do
+    ActorView.any_instance.expects :setup
+    @actor.expects(:is?).with(:layered).returns(false)
+    @test_me = ActorView.new @stage, @actor, :wrapped_screen
+  end
+
+  it 'should accept layered behavior params from actor' do
+    @actor.stubs(:layer => 6, :parallax => 3)
+    @actor.expects(:is?).with(:layered).returns(true)
+    @test_me = ActorView.new @stage, @actor, :wrapped_screen
+
+    @test_me.layer.should == 6
+    @test_me.parallax.should == 3
+  end
+  
+  it 'should register for show events' do
+    @actor = Actor.new({})
+    
+    @test_me = ActorView.new @stage, @actor, :wrapped_screen
+    @stage.expects(:register_drawable).with(@test_me)
+    
+    @actor.send :fire, :show_me
+  end
+
+  it 'should register for hide events' do
+    @actor = Actor.new({})
+    
+    @test_me = ActorView.new @stage, @actor, :wrapped_screen
+    @stage.expects(:unregister_drawable).with(@test_me)
+    
+    @actor.send :fire, :hide_me
+  end
+
+  it 'should register for remove events' do
+    @actor = Actor.new({})
+    
+    @test_me = ActorView.new @stage, @actor, :wrapped_screen
+    @stage.expects(:unregister_drawable).with(@test_me)
+    
+    @actor.send :fire, :remove_me
+  end
+  
+  it 'should manage a cached surface for drawing (possibly use record{})' 
 end