gamebox 0.1.1 → 0.2.1

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

@@ -0,0 +1,17 @@
+require 'collidable/collidable_shape'
+
+class CircleCollidable < CollidableShape
+
+  def setup
+    @radius ||= opts[:radius]
+  end
+
+  def center_x
+    actor_x + radius
+  end
+
+  def center_y
+    actor_y + radius
+  end
+
+end

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

@@ -0,0 +1,35 @@
+class CollidableShape
+  attr_accessor :opts, :actor, :radius
+  def initialize(actor, options)
+    @opts = options
+    @actor = actor
+
+    @x_offset = opts[:x_offset]
+    @y_offset = opts[:y_offset]
+    @x_offset ||= 0
+    @y_offset ||= 0
+  end
+
+  def actor_x
+    @actor.x + @x_offset
+  end
+
+  def actor_y
+    @actor.y + @y_offset
+  end
+
+  def setup
+  end
+
+  def width
+    @radius * 2
+  end
+  alias :height :width
+
+  def update(time)
+    recalculate_collidable_cache
+  end
+
+  def recalculate_collidable_cache
+  end
+end

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

@@ -0,0 +1,85 @@
+require 'collidable/collidable_shape'
+
+class PolygonCollidable < CollidableShape
+  attr_accessor :cw_local_points
+
+  def setup
+    @collidable_shape = opts[:shape]
+
+    @cw_local_points = opts[:cw_local_points]
+    @cw_local_points ||= opts[:points]
+
+    @radius = opts[:radius]
+    @radius ||= calculate_radius
+
+    @old_x = actor_x
+    @old_y = actor_y
+  end
+
+  def calculate_radius
+    local_avg = cw_local_points.inject([0,0]) {|s, (x,y)| s[0] += x; s[1]+=y; s}.map {|x| x / cw_local_points.size}
+    max_dist = 0
+    cw_local_points.each do |lp|
+      x_dist = local_avg[0]-lp[0]
+      y_dist = local_avg[1]-lp[1]
+      dist = Math.sqrt(x_dist*x_dist + y_dist*y_dist)
+      max_dist = dist if dist > max_dist
+    end 
+    max_dist
+  end
+
+  def center_x
+    poly_center[0]
+  end
+
+  def center_y
+    poly_center[1]
+  end
+
+  def poly_center
+    @cached_poly_center ||= cw_world_points.inject([0,0]) {|s, (x,y)| s[0] += x; s[1]+=y; s}.map {|x| x / cw_world_points.size}
+  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 = [] 
+
+    cw_world_points.each_cons(2) do |a,b|
+      lines << [a,b]
+    end
+    lines << [cw_world_points[-1],cw_world_points[0]]
+
+    @cached_lines = lines
+  end
+
+  def cw_world_edge_normals
+    return @cached_normals if @cached_normals
+
+    @cached_normals = cw_world_lines.map do |edge|
+      # vector subtraction
+      v = edge[1][0]-edge[0][0], edge[1][1]-edge[0][1]
+      [-v[1],v[0]]
+    end
+
+    @cached_normals
+  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

data/lib/gamebox/behaviors/graphical.rb

@@ -15,16 +15,19 @@ class Graphical < Behavior
     @num_y_tiles ||= 1
 
     graphical_obj = self
-    @actor.instance_eval do
-      (class << self; self; end).class_eval do
-        define_method :image do 
-          graphical_obj.image
-        end
-        define_method :graphical do 
-          graphical_obj
-        end
-      end
-    end
+    relegates :image, :graphical, :width, :height
+  end
+
+  def graphical
+    self
+  end
+
+  def width
+    image.width
+  end
+
+  def height
+    image.height
   end
 
   def tiled?

data/lib/gamebox/behaviors/layered.rb

@@ -16,26 +16,12 @@ class Layered < Behavior
     @layer ||= 0
     @parallax ||= 1
 
-    layered_obj = self
-    @actor.instance_eval do
-      (class << self; self; end).class_eval do
-        define_method :layer= do |new_layer|
-          layered_obj.layer = new_layer
-        end
-        define_method :parallax= do |new_parallax|
-          layered_obj.parallax = new_parallax
-        end
-        define_method :layer do 
-          layered_obj.layer
-        end
-        define_method :parallax do 
-          layered_obj.parallax
-        end
-        define_method :layered do 
-          layered_obj
-        end
-      end
-    end
+    relegates :layer=, :layer, :parallax=, :parallax, 
+      :layered
+  end
+
+  def layered
+    self
   end
 
   def parallax=(new_parallax)

data/lib/gamebox/behaviors/physical.rb

@@ -19,70 +19,101 @@ class Physical < Behavior
   attr_accessor :shapes, :body, :opts, :parts, :segments_groups
 
   def shape
-    @shapes.first if @shapes
+    if @shapes
+      @shapes.first 
+    else
+      @shape
+    end
   end
   
   def setup
-    # TODO add defaults?
-    @mass = @opts[:mass]
-    @mass ||= Float::INFINITY
     @parts = {}
     @shapes = []
     @segments_groups = []
 
-    moment_of_inertia = @opts[:moment]
+    @moment_of_inertia = @opts[:moment]
 
-    case @opts[:shape]
-    when :circle
-      @radius = @opts[:radius]
+    build_main_shape
+    setup_main_collisions
+    setup_position
+    setup_elasticity
+    setup_friction
 
-      moment_of_inertia ||= @opts[:fixed] ? Float::INFINITY : moment_for_circle(@mass, @radius, 0, ZERO_VEC_2)
-      @body = Body.new(@mass, moment_of_inertia)
-      @shape = Shape::Circle.new(@body, @radius, ZERO_VEC_2)
+    build_secondary_shapes
 
-    when :poly
-      shape_array = @opts[:verts].collect{|v| vec2(v[0],v[1])}
+    register
 
-      moment_of_inertia ||= @opts[:fixed] ? Float::INFINITY : moment_for_poly(@mass, shape_array, ZERO_VEC_2)
-      @body = Body.new(@mass, moment_of_inertia)
-      @shape = Shape::Poly.new(@body, shape_array, ZERO_VEC_2)
-      verts = @opts[:verts].dup
-      verts << @opts[:verts][0]
-      @segments_groups << verts
-    end
+    # write code here to keep physics and x,y of actor in sync
+    relegates :x, :y, :x=, :y=, :shape, :body, :parts,
+      :rotation, :warp, :segment_groups, :physical
+  end
+
+  def setup_friction
+    @friction = @opts[:friction]
+    @friction ||= 0.4
+    @shape.u = @friction
+  end
+
+  def setup_elasticity
+    @elasticity = @opts[:elasticity]
+    @elasticity ||= 0.1
+    @shape.e = @elasticity
+  end
 
-    collision_type = @opts[:collision_group]
-    collision_type ||= 
+  def setup_main_collisions
+    @collision_type = @opts[:collision_group]
+    @collision_type ||= 
       Inflector.underscore(@actor.class).to_sym
-      
-    @body.a = @opts[:angle] if @opts[:angle]
+    @shape.collision_type = @collision_type
+  end
 
-    @shape.collision_type = collision_type
+  def setup_position
+    @body.a = @opts[:angle] if @opts[:angle]
     start_x = @opts[:x]
     start_y = @opts[:y]
     start_x ||= @actor.x
     start_y ||= @actor.y
     @shape.body.p = vec2(start_x,start_y)
 
-    elasticity = @opts[:elasticity]
-    elasticity ||= 0.1
-    @shape.e = elasticity
+  end
+
+  def build_main_shape
+    @mass = @opts[:mass]
+    @mass ||= Float::INFINITY
+
+    case @opts[:shape]
+    when :circle
+      @radius = @opts[:radius]
+
+      @moment_of_inertia ||= @opts[:fixed] ? Float::INFINITY : moment_for_circle(@mass, @radius, 0, ZERO_VEC_2)
+      @body = CP::Body.new(@mass, @moment_of_inertia)
+      @shape = CP::Shape::Circle.new(@body, @radius, ZERO_VEC_2)
+
+    when :poly
+      shape_array = @opts[:verts].collect{|v| vec2(v[0],v[1])}
+
+      @moment_of_inertia ||= @opts[:fixed] ? Float::INFINITY : moment_for_poly(@mass, shape_array, ZERO_VEC_2)
+      @body = CP::Body.new(@mass, @moment_of_inertia)
+      @shape = CP::Shape::Poly.new(@body, shape_array, ZERO_VEC_2)
+      verts = @opts[:verts].dup
+      verts << @opts[:verts][0]
+      @segments_groups << verts
+    end
 
-    friction = @opts[:friction]
-    friction ||= 0.4
-    @shape.u = friction
-    
     @shapes << @shape
+  end
+
+  def build_secondary_shapes
 
     if @opts[:shapes]
       for obj in @opts[:shapes]
         for part_name, part_def in obj
           # add another shape here
           part_shape_array = part_def[:verts].collect{|v| vec2(v[0],v[1])}
-          part_shape = Shape::Poly.new(@body, part_shape_array, part_def[:offset])
+          part_shape = CP::Shape::Poly.new(@body, part_shape_array, part_def[:offset])
           part_shape.collision_type = part_name.to_sym
           # TODO pass all physics params to parts (ie u and e)
-          part_shape.u = friction
+          part_shape.u = @friction
           @shapes << part_shape
           verts = part_def[:verts].dup
           verts << part_def[:verts][0]
@@ -90,10 +121,10 @@ class Physical < Behavior
         end
       end
     end
+  end
 
-
+  def register
     physical_obj = self
-
     if @actor.stage.respond_to? :register_physical_object
       if @opts[:fixed]
         @actor.stage.register_physical_object physical_obj, true
@@ -103,64 +134,56 @@ class Physical < Behavior
     else
       raise "physical actor in a non-physical stage!"
     end
+  end
 
-    # write code here to keep physics and x,y of actor in sync
-    @actor.instance_eval do
-      (class << self; self; end).class_eval do
-        define_method :x do 
-          physical_obj.body.p.x
-        end
-        define_method :y do 
-          physical_obj.body.p.y
-        end
-        define_method :x= do |new_x|
-          raise "I am physical, you should apply forces"
-        end
-        define_method :y= do |new_y|
-          raise "I am physical, you should apply forces"
-        end
-        define_method :shape do 
-          physical_obj.shape
-        end
-        define_method :body do 
-          physical_obj.body
-        end
-        define_method :parts do 
-          physical_obj.parts
-        end
-        define_method :deg do 
-          # TODO hack!! why do poly's not work the same?
-          if physical_obj.opts[:shape] == :poly
-            -((physical_obj.body.a-1.57) * 180.0 / Math::PI + 90)
-          else
-            -((physical_obj.body.a) * 180.0 / Math::PI + 90)
-          end
-        end
-        define_method :warp do |new_p|
-          physical_obj.body.p = new_p
-          @stage.space.rehash_static if physical_obj.opts[:fixed]
-        end
-        define_method :segment_groups do 
-          physical_obj.segments_groups
-        end
-        define_method :physical do 
-          physical_obj
-        end
-        define_method :image do 
-          old_image = nil
-          rot_deg = deg.round % 360
-
-          if is? :animated
-            old_image = animated.image
-          elsif is? :graphical
-            old_image = graphical.image
-          end
-
-          if old_image
-            old_image.rotozoom(rot_deg,1,true)
-          end
-        end
-      end
+  def x
+    body.p.x
+  end
+
+  def y
+    body.p.y
+  end
+
+  def x=(new_x)
+    body.p = vec2(new_x, y)
+  end
+
+  def y=(new_y)
+    body.p = vec2(x, new_y)
+  end
+
+  def rotation
+    # TODO hack!! why do poly's not work the same?
+    if opts[:shape] == :poly
+      ((body.a-1.57) * 180.0 / Math::PI + 90) % 360
+    else
+      ((body.a) * 180.0 / Math::PI + 90) % 360
     end
+#    rot_deg = rotation.round % 360
   end
+
+  def warp(new_p)
+    body.p = new_p
+    @actor.stage.space.rehash_static if opts[:fixed]
+  end
+
+  def physical
+    self
+  end
+
+#  def image
+#    old_image = nil
+#    rot_deg = rotation.round % 360
+#
+#    if @actor.is? :animated
+#      old_image = @actor.animated.image
+#    elsif @actor.is? :graphical
+#      old_image = @actor.graphical.image
+#    end
+#
+#    if old_image
+#      # XXX rotate when drawing, not when getting image
+#      old_image.rotozoom(rot_deg,1,true)
+#    end
+#  end
 end