gamebox 0.3.4 → 0.4.0.rc1

data/lib/gamebox/behaviors/graphical.rb

@@ -2,62 +2,28 @@
 # keeps track of an image for you based on the actor's class
 # by default it expects images to be:
 # data/graphics/classname.png
-class Graphical < Behavior
-
-  attr_accessor :image, :num_x_tiles, :num_y_tiles, :rotation
-  def setup
-
-    @image = @actor.resource_manager.load_actor_image @actor
-    @tiled = @opts[:tiled]
-    @num_x_tiles = @opts[:num_x_tiles]
-    @num_y_tiles = @opts[:num_y_tiles]
-    @num_x_tiles ||= 1
-    @num_y_tiles ||= 1
-    @rotation = 0.0
-
-    relegates :image, :graphical, :width, :height, :rotation, :rotation=, 
-      :scale, :scale=, :x_scale, :y_scale, :x_scale=, :y_scale=
-  end
-
-  def graphical
-    self
-  end
-
-  def width
-    image.width
-  end
-
-  def height
-    image.height
-  end
-
-  def tiled?
-    @tiled
-  end
-
-  def scale
-    @scale || 1
-  end
-
-  def scale=(s)
-    @scale = s
-  end
-
-  def x_scale
-    @x_scale || scale
-  end
-
-  def x_scale=(xs)
-    @x_scale = xs
-  end
-
-
-  def y_scale
-    @y_scale || scale
-  end
-
-  def y_scale=(ys)
-    @y_scale = ys
+Behavior.define :graphical do
+
+  requires :resource_manager
+  setup do 
+    image = resource_manager.load_actor_image(actor)
+    scale = @opts[:scale] || 1,
+    actor.has_attributes( image: image,
+                          width: image.width,
+                          height: image.height,
+                          tiled: @opts[:tiled],
+                          view: @opts[:view] || :graphical_actor_view,
+                          num_x_tiles: @opts[:num_x_tiles] || 1,
+                          num_y_tiles: @opts[:num_y_tiles] || 1,
+                          scale: scale,
+                          x_scale: @opts[:x_scale] || scale,
+                          y_scale: @opts[:y_scale] || scale,
+                          rotation: 0.0 )
+
+    actor.when :image_changed do |old, new|
+      actor.width = new.width
+      actor.height = new.height
+    end
   end
 
 end

data/lib/gamebox/behaviors/layered.rb

@@ -2,33 +2,20 @@
 # Keeps track of the layer that something is to be drawn on.
 # By default it sets everything to layer 0 and parallax layer of
 # 1.
-class Layered < Behavior
+Behavior.define :layered do
 
-  attr_accessor :layer, :parallax
-  def setup
+  setup do
     if @opts.is_a? Hash
-      @layer = @opts[:layer]
-      @parallax = @opts[:parallax]
+      layer = @opts[:layer]
+      parallax = @opts[:parallax]
     else
-      @layer = @opts
+      layer = @opts
     end
     
-    @layer ||= 0
-    @parallax ||= 1
+    layer ||= 0
+    parallax ||= 1
 
-    relegates :layer=, :layer, :parallax=, :parallax, 
-      :layered
+    actor.has_attributes layer: layer, parallax: parallax
   end
 
-  def layered
-    self
-  end
-
-  def parallax=(new_parallax)
-    @parallax = new_parallax
-  end
-
-  def layer=(new_layer)
-    @layer = new_layer
-  end
 end

data/lib/gamebox/behaviors/physical.rb

@@ -10,25 +10,25 @@
 #    :friction => 0.4,
 #    :moment => Float::INFINITY,
 #    :verts => [[-15,-20],[-15,20],[15,20],[15,-20]]}
-class Physical < Behavior
-  attr_accessor :shapes, :body, :opts, :parts, :segments_groups
-
-  def shape
-    if @shapes
-      @shapes.first 
-    else
-      @shape
-    end
-  end
-  
-  def setup
-    @parts = {}
-    @shapes = []
-    @constraints = []
-    @segments_groups = []
+Behavior.define :physical do
 
+  requires :physics_manager, :director
+  setup do
     @moment_of_inertia = @opts[:moment]
 
+    actor.has_attributes x: 0, y: 0
+
+    actor.has_attributes :x, :y, :shape, :shapes, :body,
+      :rotation, :segment_groups, :constraints,
+      :pivot, :pin, :spring, :slide, :groove,
+      :rotary_spring, :rotary_limit, :ratchet,
+      :gear, :motor
+
+    actor.shapes = []
+    actor.constraints = []
+    actor.segment_groups = []
+
+
     build_main_shape
     setup_main_collisions
     setup_position
@@ -37,235 +37,224 @@ class Physical < Behavior
 
     build_secondary_shapes
 
-
     register
-    warp(vec2(@actor.x,@actor.y))
 
-    # 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,
-      :pivot, :pin, :spring, :slide, :groove,
-      :rotary_spring, :rotary_limit, :ratchet,
-      :gear, :motor
-  end
+    # TODO use positioned?
+    actor.when :position_changed do
+      actor.body.p = vec2(actor.x, actor.y)
+    end
 
-  def setup_friction
-    @friction = @opts[:friction]
-    @friction ||= 0.4
-    @shape.u = @friction
-  end
+    director.when :update do |time|
+      actor.x = actor.body.p.x
+      actor.y = actor.body.p.y
+      actor.rotation = rotation
+    end
 
-  def setup_elasticity
-    @elasticity = @opts[:elasticity]
-    @elasticity ||= 0.1
-    @shape.e = @elasticity
-  end
+    warp(vec2(actor.x,actor.y))
 
-  def setup_main_collisions
-    @collision_type = @opts[:collision_group]
-    @collision_type ||= 
-      Inflector.underscore(@actor.class).to_sym
-    @shape.collision_type = @collision_type
+    reacts_with :warp
   end
 
-  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)
+  helpers do
+    def setup_friction
+      @friction = @opts[:friction]
+      @friction ||= 0.4
+      actor.shape.u = @friction
+    end
 
-  end
+    def setup_elasticity
+      @elasticity = @opts[:elasticity]
+      @elasticity ||= 0.1
+      actor.shape.e = @elasticity
+    end
 
-  def build_main_shape
-    @mass = @opts[:mass]
-    @mass ||= Float::INFINITY
+    def setup_main_collisions
+      @collision_type = @opts[:collision_group]
+      @collision_type ||= actor.actor_type
+      actor.shape.collision_type = @collision_type
+    end
 
-    case @opts[:shape]
-    when :circle
-      @radius = @opts[:radius]
+    def setup_position
+      actor.body.a = @opts[:angle] if @opts[:angle]
+      start_x = @opts[:x]
+      start_y = @opts[:y]
+      start_x ||= actor.x
+      start_y ||= actor.y
+      actor.shape.body.p = vec2(start_x,start_y)
 
-      @moment_of_inertia ||= @opts[:fixed] ? Float::INFINITY : CP::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)
+    end
 
-    when :poly
-      shape_array = @opts[:verts].collect{|v| vec2(v[0],v[1])}
+    def build_main_shape
+      @mass = @opts[:mass]
+      @mass ||= Float::INFINITY
 
-      @moment_of_inertia ||= @opts[:fixed] ? Float::INFINITY : CP::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
+      case @opts[:shape]
+      when :circle
+        @radius = @opts[:radius]
 
-    @shapes << @shape
+        @moment_of_inertia ||= @opts[:fixed] ? Float::INFINITY : CP::moment_for_circle(@mass, @radius, 0, ZERO_VEC_2)
+        actor.body = CP::Body.new(@mass, @moment_of_inertia)
+        actor.shape = CP::Shape::Circle.new(actor.body, @radius, ZERO_VEC_2)
 
-    @body.p = vec2(actor.x,actor.y)
-  end
+      when :poly
+        shape_array = @opts[:verts].collect{|v| vec2(v[0],v[1])}
 
-  def build_secondary_shapes
-
-    if @opts[:shapes]
-      for obj in @opts[:shapes]
-        for part_name, part_def in obj
-          # TODO merge this with build main shape
-          part_shape = nil
-          case part_def[:shape]
-          when :poly
-            part_shape_array = part_def[:verts].collect{|v| vec2(v[0],v[1])}
-            part_shape = CP::Shape::Poly.new(@body, part_shape_array, part_def[:offset])
-            part_shape.collision_type = part_name.to_sym
+        @moment_of_inertia ||= @opts[:fixed] ? Float::INFINITY : CP::moment_for_poly(@mass, shape_array, ZERO_VEC_2)
+        actor.body = CP::Body.new(@mass, @moment_of_inertia)
+        actor.shape = CP::Shape::Poly.new(actor.body, shape_array, ZERO_VEC_2)
+        verts = @opts[:verts].dup
+        verts << @opts[:verts][0]
+        actor.segment_groups << verts
+      end
 
-            # TODO pass all physics params to parts (ie u and e)
-            part_shape.u = @friction
-            verts = part_def[:verts].dup
-            verts << part_def[:verts][0]
-            @segments_groups << verts
-          when :circle
-            part_shape = CP::Shape::Circle.new(@body, part_def[:radius], part_def[:offset])
-          else
-            raise "unsupported sub shape type"
+      actor.shape.actor = actor
+      actor.shapes << actor.shape
+
+      actor.body.p = vec2(actor.x,actor.y)
+    end
+
+    def build_secondary_shapes
+
+      if @opts[:shapes]
+        for obj in @opts[:shapes]
+          for part_name, part_def in obj
+            # TODO merge this with build main shape
+            part_shape = nil
+            case part_def[:shape]
+            when :poly
+              part_shape_array = part_def[:verts].collect{|v| vec2(v[0],v[1])}
+              part_shape = CP::Shape::Poly.new(actor.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
+              verts = part_def[:verts].dup
+              verts << part_def[:verts][0]
+              actor.segment_groups << verts
+            when :circle
+              part_shape = CP::Shape::Circle.new(actor.body, part_def[:radius], part_def[:offset])
+            else
+              raise "unsupported sub shape type"
+            end
+            part_shape.collision_type = part_name.to_sym
+            part_shape.actor = actor
+            actor.shapes << part_shape
           end
-          part_shape.collision_type = part_name.to_sym
-          @shapes << part_shape
-          # puts @shapes.inspect
         end
       end
     end
-  end
 
-  def register
-    @actor.when :remove_me do
-      cleanup_constraints
-    end
+    def register
+      actor.when :remove_me do
+        cleanup_constraints
+      end
 
-    physical_obj = self
-    if @actor.stage.respond_to? :register_physical_object
-      if @opts[:fixed]
-        @actor.stage.register_physical_object physical_obj, true
+      if physics_manager
+        if @opts[:fixed]
+          physics_manager.register_physical_object actor, true
+        else
+          physics_manager.register_physical_object actor
+        end
       else
-        @actor.stage.register_physical_object physical_obj
+        raise "physical actor in a non-physical stage!"
       end
-    else
-      raise "physical actor in a non-physical stage!"
     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
+    def rotation
+      if opts[:shape] == :poly
+        ((actor.body.a-1.57) * 180.0 / Math::PI + 90) % 360
+      else
+        ((actor.body.a) * 180.0 / Math::PI + 90) % 360
+      end
     end
-  end
 
-  def warp(new_p)
-    body.p = new_p
-    @actor.stage.space.rehash_static if opts[:fixed]
-  end
-
-  def physical
-    self
-  end
-
-  def pivot(my_anchor, other_physical, other_anchor)
-    pivot = CP::Constraint::PivotJoint.new(physical.body, other_physical.body, my_anchor, other_anchor)
-    @actor.stage.register_physical_constraint pivot
-    @constraints << pivot
-    pivot
-  end
-
-  def pin(my_anchor, other_physical, other_anchor)
-    pin = CP::Constraint::PinJoint.new(physical.body, other_physical.physical.body, my_anchor, other_anchor)
-    @actor.stage.register_physical_constraint pin
-    @constraints << pin
-    pin
-  end
-
-  def spring(my_anchor, other_physical, other_anchor, rest_length, stiffness, damping)
-    spring = CP::Constraint::DampedSpring.new(physical.body,other_physical.body,
-                                         my_anchor,other_anchor, rest_length, stiffness, damping)
-    @actor.stage.register_physical_constraint spring
-    @constraints << spring
-    spring
-  end
-
-  def slide(my_anchor, other_physical, other_anchor, min_distance, max_distance)
-    slide = CP::Constraint::SlideJoint.new(physical.body, other_physical.body, my_anchor, other_anchor, min_distance, max_distance)
-    @actor.stage.register_physical_constraint slide
-    @constraints << slide
-    slide
-  end
-
-  def groove(groove_start, groove_end, other_physical, other_anchor)
-    groove = CP::Constraint::GrooveJoint.new(physical.body, other_physical.body, groove_start, groove_end, other_anchor)
-    @actor.stage.register_physical_constraint groove
-    @constraints << groove
-    groove
-  end
-
-  #
-  # All of these rotary joint types expect angles in radians.
-  #
-
-  def rotary_spring(other_physical, rest_angle, stiffness, damping)
-    rotary_spring = CP::Constraint::DampedRotarySpring.new(physical.body, other_physical.body, rest_angle, stiffness, damping)
-    @actor.stage.register_physical_constraint rotary_spring
-    @constraints << rotary_spring
-    rotary_spring
-  end
-
-  def rotary_limit(other_physical, min_angle, max_angle)
-    rotary_limit = CP::Constraint::RotaryLimitJoint.new(physical.body, other_physical.body, min_angle, max_angle)
-    @actor.stage.register_physical_constraint rotary_limit
-    @constraints << rotary_limit
-    rotary_limit
-  end
-
-  def ratchet(other_physical, phase, ratchet)
-    ratchet_joint = CP::Constraint::RatchetJoint.new(physical.body, other_physical.body, phase, ratchet)
-    @actor.stage.register_physical_constraint ratchet_joint
-    @constraints << ratchet_joint
-    ratchet_joint
-  end
-
-  def gear(other_physical, phase, ratio)
-    gear = CP::Constraint::GearJoint.new(physical.body, other_physical.body, phase, ratio)
-    @actor.stage.register_physical_constraint gear
-    @constraints << gear
-    gear
-  end
-
-  def motor(other_physical, rate)
-    motor = CP::Constraint::SimpleMotor.new(physical.body, other_physical.body, rate)
-    @actor.stage.register_physical_constraint motor
-    @constraints << motor
-    motor
-  end
+    def warp(new_p)
+      actor.body.p = new_p
+      physics_manager.space.rehash_static if opts[:fixed]
+    end
 
-  def cleanup_constraints
-    @constraints.each do |c|
-      @actor.stage.unregister_physical_constraint c
+    # TODO use react_to to handle these requests?
+    # def pivot(my_anchor, other_physical, other_anchor)
+    #   pivot = CP::Constraint::PivotJoint.new(actor.body, other_physical.actor.body, my_anchor, other_anchor)
+    #   physics_manager.register_physical_constraint pivot
+    #   actor.constraints << pivot
+    #   pivot
+    # end
+
+    # def pin(my_anchor, other_physical, other_anchor)
+    #   pin = CP::Constraint::PinJoint.new(actor.body, other_physical.physical.body, my_anchor, other_anchor)
+    #   physics_manager.register_physical_constraint pin
+    #   actor.constraints << pin
+    #   pin
+    # end
+
+    # def spring(my_anchor, other_physical, other_anchor, rest_length, stiffness, damping)
+    #   spring = CP::Constraint::DampedSpring.new(body,other_physical.body,
+    #                                        my_anchor,other_anchor, rest_length, stiffness, damping)
+    #   physics_manager.register_physical_constraint spring
+    #   actor.constraints << spring
+    #   spring
+    # end
+
+    # def slide(my_anchor, other_physical, other_anchor, min_distance, max_distance)
+    #   slide = CP::Constraint::SlideJoint.new(actor.body, other_physical.body, my_anchor, other_anchor, min_distance, max_distance)
+    #   physics_manager.register_physical_constraint slide
+    #   actor.constraints << slide
+    #   slide
+    # end
+
+    # def groove(groove_start, groove_end, other_physical, other_anchor)
+    #   groove = CP::Constraint::GrooveJoint.new(actor.body, other_physical.body, groove_start, groove_end, other_anchor)
+    #   physics_manager.register_physical_constraint groove
+    #   actor.constraints << groove
+    #   groove
+    # end
+
+    # #
+    # # All of these rotary joint types expect angles in radians.
+    # #
+
+    # def rotary_spring(other_physical, rest_angle, stiffness, damping)
+    #   rotary_spring = CP::Constraint::DampedRotarySpring.new(actor.body, other_physical.body, rest_angle, stiffness, damping)
+    #   physics_manager.register_physical_constraint rotary_spring
+    #   actor.constraints << rotary_spring
+    #   rotary_spring
+    # end
+
+    # def rotary_limit(other_physical, min_angle, max_angle)
+    #   rotary_limit = CP::Constraint::RotaryLimitJoint.new(actor.body, other_physical.body, min_angle, max_angle)
+    #   physics_manager.register_physical_constraint rotary_limit
+    #   actor.constraints << rotary_limit
+    #   rotary_limit
+    # end
+
+    # def ratchet(other_physical, phase, ratchet)
+    #   ratchet_joint = CP::Constraint::RatchetJoint.new(actor.body, other_physical.body, phase, ratchet)
+    #   physics_manager.register_physical_constraint ratchet_joint
+    #   actor.constraints << ratchet_joint
+    #   ratchet_joint
+    # end
+
+    # def gear(other_physical, phase, ratio)
+    #   gear = CP::Constraint::GearJoint.new(actor.body, other_physical.body, phase, ratio)
+    #   physics_manager.register_physical_constraint gear
+    #   actor.constraints << gear
+    #   gear
+    # end
+
+    # def motor(other_physical, rate)
+    #   motor = CP::Constraint::SimpleMotor.new(actor.body, other_physical.body, rate)
+    #   physics_manager.register_physical_constraint motor
+    #   actor.constraints << motor
+    #   motor
+    # end
+
+    def cleanup_constraints
+      actor.constraints.each do |c|
+        physics_manager.unregister_physical_constraint c
+      end
     end
   end