gamebox 0.1.1 → 0.2.1

data/lib/gamebox/actors/svg_actor.rb

@@ -1,9 +1,5 @@
-require 'actor'
-require 'actor_view'
-
 require "enumerator"
 
-
 # SvgActor knows how to build himself based on an svg document based on the :name 
 # passed in being the group name in the doc (layer).
 class SvgActor < Actor
@@ -38,11 +34,13 @@ class SvgActor < Actor
 end
 
 class SvgActorView < ActorView
-  def draw(target,x_off,y_off)
+  def draw(target, x_off, y_off, z)
     @actor.segments.each do |seg|
       p1 = seg[0]
       p2 = seg[1]
-      target.draw_line_s [p1.x+x_off,p1.y+y_off], [p2.x+x_off,p2.y+y_off], [25,255,25,255], 6
+      # TODO pull in draw_line_s?
+      target.draw_line p1.x+x_off, p1.y+y_off, p2.x+x_off, p2.y+y_off, [25,255,25,255], z
+      #target.draw_line_s [p1.x+x_off,p1.y+y_off], [p2.x+x_off,p2.y+y_off], [25,255,25,255], 6
     end
   end
 end

data/lib/gamebox/arbiter.rb

@@ -1,5 +1,6 @@
 # this module gets mixed into a stage to allow it to handle collision detection
 module Arbiter
+  attr_reader :checks, :collisions
 
   def register_collidable(actor)
     @spatial_hash = stagehand(:spatial)
@@ -27,42 +28,62 @@ module Arbiter
 
     first_objs.each do |fobj|
       second_objs.each do |sobj|
-#        puts "registering #{fobj} and #{sobj}"
-        @collision_handlers[fobj] ||= {}
-        @collision_handlers[sobj] ||= {}
-        @collision_handlers[fobj][sobj] = block
-        @collision_handlers[sobj][fobj] = block
+        if fobj.to_i < sobj.to_i
+          @collision_handlers[fobj] ||= {}
+          @collision_handlers[fobj][sobj] = [false,block]
+        else
+          @collision_handlers[sobj] ||= {}
+          @collision_handlers[sobj][fobj] = [true,block]
+        end
       end
     end
   end
 
   def run_callbacks(collisions)
+    @collision_handlers ||= {}
     collisions.each do |collision|
       first = collision.first
       second = collision.last
+      unless first.actor_type.to_i < second.actor_type.to_i
+        tmp = first
+        first = second
+        second = tmp
+      end
 
       colliders = @collision_handlers[first.actor_type]
-      callback = colliders[second.actor_type] unless colliders.nil?
-      callback.call first, second unless callback.nil?
+      swapped, callback = colliders[second.actor_type] unless colliders.nil?
+      unless callback.nil?
+        if swapped
+          callback.call second, first 
+        else
+          callback.call first, second 
+        end
+      end
     end
   end
 
   def find_collisions
     @collidable_actors ||= []
+    @checks = 0
+    @collisions = 0
     tmp_collidable_actors = @collidable_actors.dup
     collisions = {}
 
     @collidable_actors.each do |first|
       x = first.x - @spatial_hash.cell_size
       y = first.y - @spatial_hash.cell_size
+      # TODO base this on size of object
       w = @spatial_hash.cell_size * 3
       h = w
-      tmp_collidable_actors = @spatial_hash.items_in(x,y,w,h)
+
+      tmp_collidable_actors = @spatial_hash.neighbors_of(first)
 
       tmp_collidable_actors.each do |second|
+        @checks += 1
         if first != second && collide?(first, second)
           collisions[second] ||= []
           if !collisions[second].include?(first)
+            @collisions += 1
             collisions[first] ||= []
             collisions[first] << second
           end
@@ -79,21 +100,93 @@ module Arbiter
   end
 
   def collide?(object, other)
-    self.send "collide_#{object.shape}_#{object.shape}?", object, other
+    # TODO perf analysis of this
+    self.send "collide_#{object.collidable_shape}_#{other.collidable_shape}?", object, other
   end
 
   def collide_circle_circle?(object, other)
-#    puts "comparing #{object.actor_type}[#{object.object_id}] to #{other.actor_type}[#{other.object_id}]"
-    x = object.x + object.radius
-    y = object.y + object.radius
-    x_prime = other.x + other.radius
-    y_prime = other.y + other.radius
+    x = object.center_x
+    y = object.center_y
+    x_prime = other.center_x
+    y_prime = other.center_y
 
     x_dist  = (x_prime - x) * (x_prime - x)
     y_dist  = (y_prime - y) * (y_prime - y)
 
     total_radius = object.radius + other.radius
-    x_dist + y_dist < (total_radius) * (total_radius)
+    x_dist + y_dist <= (total_radius * total_radius)
+  end
+
+  # Idea from:
+  # http://gpwiki.org/index.php/Polygon_Collision
+  # and http://www.gamedev.net/community/forums/topic.asp?topic_id=540755&whichpage=1&#3488866
+  def collide_polygon_polygon?(object, other)
+    if collide_circle_circle? object, other
+      # collect vector's perp
+      potential_sep_axis = 
+        (object.cw_world_edge_normals | other.cw_world_edge_normals).uniq
+      potential_sep_axis.each do |axis|
+        return false unless project_and_detect(axis, object, other)           
+      end 
+    else
+      return false
+    end
+    true
+  end
+  alias collide_aabb_aabb? collide_polygon_polygon?
+
+  # returns true if the projections overlap
+  def project_and_detect(axis, a, b)
+    a_min, a_max = send("#{a.collidable_shape}_interval", axis, a)
+    b_min, b_max = send("#{b.collidable_shape}_interval", axis, b)
+
+    a_min <= b_max && b_min <= a_max
   end
 
+  def polygon_interval(axis, object)
+    min = max = nil
+    object.cw_world_points.each do |edge|
+      # vector dot product
+      d = edge[0] * axis[0] + edge[1] * axis[1]
+      min ||= d
+      max ||= d
+      min = d if d < min
+      max = d if d > max
+    end
+    [min,max]
+  end
+  alias aabb_interval polygon_interval
+
+  def circle_interval(axis, object)
+    axis_x = axis[0]
+    axis_y = axis[1]
+
+    obj_x = object.center_x
+    obj_y = object.center_y
+
+    length = Math.sqrt(axis_x * axis_x + axis_y * axis_y)
+    cn = axis_x*obj_x + axis_y*obj_y
+    rlength = object.radius*length
+    min = cn - rlength
+    max = cn + rlength
+    [min,max]
+  end
+
+  def collide_polygon_circle?(object, other)
+    collide_circle_polygon?(other, object)
+  end
+  alias collide_aabb_circle?  collide_polygon_circle?
+
+  def collide_circle_polygon?(object, other)
+    if collide_circle_circle? object, other
+      potential_sep_axis = other.cw_world_edge_normals
+      potential_sep_axis.each do |axis|
+        return false unless project_and_detect(axis, object, other)           
+      end 
+      true 
+    else
+      false
+    end
+  end
+  alias collide_circle_aabb? collide_circle_polygon?
 end

data/lib/gamebox/behavior.rb

@@ -1,10 +1,12 @@
 # Behavior is any type of behavior an actor can exibit.
 class Behavior
-  attr_accessor :actor, :opts
+  attr_accessor :actor, :opts, :relegated_methods
 
   def initialize(actor,opts={})
     @actor = actor
     @opts = opts
+    @relegated_methods = []
+
     req_behs = self.class.required_behaviors
     req_behs.each do |beh|
       unless @actor.is? beh
@@ -18,6 +20,15 @@ class Behavior
   end
 
   def removed
+    target = self
+
+    @actor.instance_eval do
+      (class << self; self; end).class_eval do
+        target.relegated_methods.each do |meth|
+          remove_method meth
+        end
+      end
+    end
   end
 
   def update(time)
@@ -39,4 +50,21 @@ class Behavior
     requires_behaviors(*args)
   end
 
+  def relegates(*methods)
+    target = self
+
+    @actor.instance_eval do
+      (class << self; self; end).class_eval do
+        methods.each do |meth|
+          log("redefining #{meth} for #{@actor.class}") if @actor.respond_to? meth
+          target.relegated_methods << meth
+
+          define_method meth do |*args|
+            target.send meth, *args
+          end
+        end
+      end
+    end
+  end
+
 end

data/lib/gamebox/behaviors/animated.rb

@@ -18,31 +18,22 @@ class Animated < Behavior
     @frame_num = 0
     self.action = :idle
 
-    animated_obj = self
+    relegates :image, :width, :height, 
+      :start_animating, :stop_animating, :animated,
+      :action, :action=
 
-    @actor.instance_eval do
-      (class << self; self; end).class_eval do
-        define_method :image do 
-          animated_obj.image
-        end
-        define_method :start_animating do
-          animated_obj.start_animating
-        end
-        define_method :stop_animating do
-          animated_obj.stop_animating
-        end
-        define_method :action do
-          animated_obj.action
-        end
-        define_method :action= do |action_sym|
-          animated_obj.action = action_sym
-        end
-        define_method :animated do 
-          animated_obj
-        end
-      end
-    end
+  end
+
+  def animated
+    self
+  end
+
+  def width
+    image.width
+  end
 
+  def height
+    image.height
   end
 
   def update(time)

data/lib/gamebox/behaviors/audible.rb

@@ -6,18 +6,7 @@ class Audible < Behavior
     @sound_manager = @actor.stage.sound_manager
 
     audible_obj = self
-    @actor.instance_eval do
-      (class << self; self; end).class_eval do
-        define_method :play_sound do |*args|
-          audible_obj.play_sound *args
-        end
-        define_method :stop_sound do |*args|
-          audible_obj.stop_sound *args
-        end
-      end
-  end
-
-
+    relegates :play_sound, :stop_sound
   end
 
   # Plays a sound via the SoundManager.  See SoundManager for

data/lib/gamebox/behaviors/collidable.rb

@@ -1,26 +1,19 @@
 require 'behavior'
+require 'collidable/circle_collidable'
+require 'collidable/aabb_collidable'
+require 'collidable/polygon_collidable'
 
+# available collidable_shapes are :circle, :polygon, :aabb
 class Collidable < Behavior
 
-  attr_accessor :shape, :radius, :width
+  attr_accessor :collidable_shape, :cw_local_points, :shape
 
   def setup
-    @shape = opts[:shape]
-    @radius = opts[:radius]
-    @width = opts[:width]
-
-    collidable_obj = self
-
-    @actor.instance_eval do
-      (class << self; self; end).class_eval do
-        define_method :shape do |*args|
-          collidable_obj.shape *args
-        end
-        define_method :radius do |*args|
-          collidable_obj.radius *args
-        end
-      end
-    end
+    @shape = build_shape
+
+    relegates :collidable_shape, :radius, :cw_world_points, :cw_world_lines, :center_x, :center_y, :cw_world_edge_normals
+    relegates :width unless @actor.respond_to? :width
+    relegates :height unless @actor.respond_to? :height
 
     register_actor
   end
@@ -29,13 +22,27 @@ class Collidable < Behavior
     @actor.stage.register_collidable @actor
   end
 
-  def bounding_box
-    [ @actor.x-@width,@actor.y-@width,
-      @actor.x+@width,@actor.y+@width ]
+  def build_shape
+    shape = nil
+    @collidable_shape = opts[:shape]
+    case @collidable_shape
+    when :circle
+      shape = CircleCollidable.new @actor, opts
+    when :aabb
+      shape = AaBbCollidable.new @actor, opts
+    when :polygon
+      shape = PolygonCollidable.new @actor, opts
+    end
+
+    shape.setup
+    shape
   end
 
-  def bounding_circle
-    [ @actor.x+@radius, @actor.y+@radius, @radius]
+  def update(time)
+    shape.update(time)
   end
 
+  def method_missing(name, *args)
+    @shape.send(name, *args)
+  end
 end

data/lib/gamebox/behaviors/collidable/aabb_collidable.rb

@@ -0,0 +1,61 @@
+require 'collidable/collidable_shape'
+
+class AaBbCollidable < CollidableShape
+  attr_accessor :cw_local_points
+
+  # TODO infinite loop if actor hasn't defined width and it gets relegated to us
+  def calculate_radius
+    w = @actor.width
+    hw = w * 0.5
+    h = @actor.height
+    hh = h * 0.5
+    Math.sqrt(hw*hw+hh*hh)
+  end
+
+  def center_x
+    actor_x + @actor.width * 0.5
+  end
+
+  def center_y
+    actor_y + @actor.height * 0.5
+  end
+
+  def cw_world_points
+    @cached_points ||= @cw_local_points.map{|lp| [lp[0]+actor_x,lp[1]+actor_y]}
+  end
+
+  def cw_world_lines
+    return @cached_lines if @cached_lines
+    lines = [] 
+
+    hw = @actor.width * 0.5
+    hh = @actor.height * 0.5
+    lines = [
+      [[actor_x-hw,actor_y+hh], [actor_x+hw,actor_y+hh]],
+      [[actor_x+hw,actor_y+hh], [actor_x+hw,actor_y-hh]],
+      [[actor_x+hw,actor_y-hh], [actor_x-hw,actor_y-hh]],
+      [[actor_x-hw,actor_y-hh], [actor_x-hw,actor_y+hh]]
+    ]
+
+    @cached_lines = lines
+  end
+
+  def cw_world_edge_normals
+    @cached_normals ||= [[1,0],[0,1]]
+  end
+
+  def recalculate_collidable_cache
+    unless @old_x == actor_x && @old_y == actor_y
+      clear_collidable_cache
+      @old_x = actor_x
+      @old_y = actor_y
+    end
+  end
+
+  def clear_collidable_cache
+    @cached_points = nil
+    @cached_lines = nil
+    @cached_poly_center = nil
+  end
+
+end