gamebox 0.3.4 → 0.4.0.rc1

data/lib/gamebox/actors/svg_actor.rb

@@ -2,45 +2,58 @@ 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
-  
-  attr_accessor :segments, :type
-  def setup
-    @name = @opts[:name]
-    @svg_doc = @opts[:svg_doc]
+define_behavior :svg_built do
+
+  requires_behaviors :positioned
+  requires :physics_manager
+
+  setup do
+    name = @opts[:name]
+    svg_doc = @opts[:svg_doc]
     
-    my_layer = @svg_doc.find_group_by_label(@name.to_s)
-    build_from_vertices my_layer.path.vertices
+    my_layer = svg_doc.find_group_by_label(name.to_s)
+    segments = build_from_vertices my_layer.path.vertices
+
+    actor.has_attributes segments: segments,
+                         name: name
   end
   
-  def build_from_vertices(vertices)
-    
-    moment_of_inertia,mass = Float::INFINITY,Float::INFINITY
-    terrain_body = CP::Body.new(mass,moment_of_inertia)
-    elasticity = 0
-    friction = 0.7
-    thickness = 6
-    @segments = []
-    vertices.each_cons(2) do |a,b|
-      seg = CP::Shape::Segment.new(terrain_body, a,b, thickness)
-      seg.collision_type = @name
-      seg.e = elasticity
-      seg.u = friction
-      seg.group = :terrain
-      @segments << [a,b]
-      @stage.space.add_static_shape(seg)
+  helpers do
+    def build_from_vertices(vertices)
+      
+      moment_of_inertia,mass = Float::INFINITY,Float::INFINITY
+      terrain_body = CP::Body.new(mass,moment_of_inertia)
+      elasticity = 0
+      friction = 0.7
+      thickness = 6
+      segments = []
+      [].tap do |segments|
+        vertices.each_cons(2) do |a,b|
+          seg = CP::Shape::Segment.new(terrain_body, a,b, thickness)
+          seg.collision_type = @name
+          seg.e = elasticity
+          seg.u = friction
+          seg.group = :terrain
+          segments << [a,b]
+          physics_manager.space.add_static_shape(seg)
+        end
+      end
     end
   end
 end
 
-class SvgActorView < ActorView
-  def draw(target, x_off, y_off, z)
-    @actor.segments.each do |seg|
-      p1 = seg[0]
-      p2 = seg[1]
-      # 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
+define_actor :svg_actor do
+  has_behavior :svg_built
+
+  view do
+    draw do |target, x_off, y_off, z|
+      actor.segments.each do |seg|
+        p1 = seg[0]
+        p2 = seg[1]
+        # 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
 end

data/lib/gamebox/behaviors/animated.rb

@@ -2,84 +2,64 @@
 # keeps track of an image for you based on the actor's class, and
 # current action, and frame num
 # by default it expects images to be:
-# data/graphics/classname/action/01..n.png
-class Animated < Behavior
-  requires_behavior :updatable
-  
-  attr_accessor :frame_time, :frame_num, :animating, :frame_update_time
-  def setup
+# data/graphics/actor_type/action/01..n.png
+Behavior.define :animated do
+  requires :resource_manager, :director
+  setup do
     @images = {}
     @frame_update_time = @opts[:frame_update_time]
     @frame_update_time ||= 60
     @frame_time = 0
-    
+
     # all animated actors have to have an idle animation
     # data/graphics/ship/idle/1.png
     @frame_num = 0
-    self.action = :idle
-
-    relegates :image, :width, :height, 
-      :start_animating, :stop_animating, :animated,
-      :action, :action=
-
-  end
-
-  def animated
-    self
-  end
 
-  def width
-    image.width
-  end
+    actor.has_attributes action: :idle, 
+                         animating: true
+    actor.has_attributes :image, :width, :height
 
-  def height
-    image.height
-  end
-
-  def update(time)
-    return unless @animating
-    @frame_time += time
-    if @frame_time > @frame_update_time
-      next_frame
-      @frame_time = @frame_time-@frame_update_time
+    actor.when :action_changed do |old_action, new_action|
+      action_changed old_action, new_action
+      actor.animating = @images[new_action].size > 1
     end
-  end
 
-  def next_frame()
-    @frame_num = (@frame_num + 1) % @images[@action].size
-  end
+    action_changed nil, actor.action
 
-  # load all the images for this action
-  def load_action(action)
-    @actor.resource_manager.load_animation_set @actor, action 
+    director.when :update do |time|
+      if actor.animating
+        @frame_time += time
+        if @frame_time > @frame_update_time
+          next_frame
+          @frame_time = @frame_time-@frame_update_time
+        end
+        set_image
+      end
+    end
   end
 
-  def action
-    @action
-  end
+  helpers do
+    def next_frame
+      action_set = @images[actor.action]
+      @frame_num = (@frame_num + 1) % action_set.size unless action_set.nil?
+    end
 
-  def action=(new_action)
-    @images[new_action] ||= load_action(new_action)
-    if @images[new_action].size > 1
-      start_animating
-    else
-      stop_animating
+    def action_changed(old_action, new_action)
+      @images[new_action] ||= resource_manager.load_animation_set actor, new_action
+      @frame_num = 0
+      set_image
     end
-    @frame_num = 0
-    @action = new_action
-  end
 
-  # returns the current image, or nil if no action is defined
-  def image
-    @images[@action][@frame_num]
-  end
+    def set_image
+      action_set = @images[actor.action]
+      raise "unknown action set #{actor.action} for #{actor}" if action_set.nil?
 
-  def start_animating
-    @animating = true
+      image = action_set[@frame_num]
+      actor.image = image
+      actor.width = image.width
+      actor.height = image.height
+    end
   end
 
-  def stop_animating
-    @animating = false
-  end
 
 end

data/lib/gamebox/behaviors/audible.rb

@@ -1,23 +1,23 @@
 
 
-class Audible < Behavior
+Behavior.define :audible do
   
-  def setup
-    @sound_manager = @actor.stage.sound_manager
-
-    audible_obj = self
-    relegates :play_sound, :stop_sound
+  requires :sound_manager
+  setup do
+    reacts_with :play_sound, :stop_sound
   end
 
-  # Plays a sound via the SoundManager.  See SoundManager for
-  # details on how to "define" sounds.
-  def play_sound(*args)
-    @sound_manager.play_sound *args
-  end
+  helpers do
+    # Plays a sound via the SoundManager.  See SoundManager for
+    # details on how to "define" sounds.
+    def play_sound(*args)
+      sound_manager.play_sound *args
+    end
 
-  # Stops a sound via the SoundManager.
-  def stop_sound(*args)
-    @sound_manager.stop_sound *args
+    # Stops a sound via the SoundManager.
+    def stop_sound(*args)
+      sound_manager.stop_sound *args
+    end
   end
 
 end

data/lib/gamebox/behaviors/collidable.rb

@@ -1,53 +1,82 @@
+# available shape_types are :circle, :polygon, :aabb
+Behavior.define :collidable do
 
+  requires_behaviors :positioned
 
+  requires :stage
+  setup do
+    shape_type = opts[:shape]
 
+    w = actor.do_or_do_not(:width) || 1
+    h = actor.do_or_do_not(:height) || 1
+    hw = w / 2
+    hh = h / 2
+    x = (actor.do_or_do_not(:x) || 0) - hw
+    y = (actor.do_or_do_not(:y) || 0) - hh
 
+    actor.has_attributes( shape_type: shape_type,
+                          width: w,
+                          height: h,
+                          x: x,
+                          y: y )
 
-# available collidable_shapes are :circle, :polygon, :aabb
-class Collidable < Behavior
+    shape = 
+      case shape_type
+      when :circle
+        CircleCollidable.new actor, opts
+      when :aabb
+        AaBbCollidable.new actor, opts
+      when :polygon
+        PolygonCollidable.new actor, opts
+      end
+    shape.setup
 
-  attr_accessor :collidable_shape, :cw_local_points, :shape
+    actor.width = shape.width
+    actor.height = shape.height
+    bb = Rect.new
+    bb.x = actor.x
+    bb.y = actor.y
+    bb.w = actor.width
+    bb.h = actor.height
 
-  def setup
-    @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
+    actor.has_attributes( shape: shape,
+                          center_x: shape.center_x,
+                          center_y: shape.center_y,
+                          cw_world_points: shape.cw_world_points,
+                          cw_world_lines: shape.cw_world_lines,
+                          cw_world_edge_normals: shape.cw_world_edge_normals,
+                          bb: bb,
+                          radius: shape.radius
+                        )
 
-    register_actor
-  end
+    stage.register_collidable actor
 
-  def register_actor
-    @actor.stage.register_collidable @actor
+    reacts_with :remove, :position_changed
   end
 
-  def removed
-    @actor.stage.unregister_collidable @actor
-    super
-  end
-
-  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
+  helpers do
+    def remove
+      stage.unregister_collidable actor
     end
 
-    shape.setup
-    shape
-  end
-
-  def update(time)
-    shape.update(time)
-  end
+    def position_changed
+      shape = actor.shape
+      shape.recalculate_collidable_cache
+      actor.center_x = shape.center_x
+      actor.center_y = shape.center_y
+      actor.width = shape.width
+      actor.height = shape.height
+      actor.cw_world_points = shape.cw_world_points
+      actor.cw_world_lines = shape.cw_world_lines
+      actor.cw_world_edge_normals = shape.cw_world_edge_normals
+      actor.radius = shape.radius
 
-  def method_missing(name, *args)
-    @shape.send(name, *args)
+      bb = actor.bb
+      bb.x = actor.x
+      bb.y = actor.y
+      bb.w = actor.width
+      bb.h = actor.height
+    end
   end
 end

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

@@ -4,10 +4,10 @@ class AaBbCollidable < CollidableShape
   attr_accessor :cw_local_points
 
   def setup
-    @collidable_shape = opts[:shape]
+    @shape_type = opts[:shape]
 
     @cw_local_points = opts[:cw_local_points]
-    @cw_local_points ||= opts[:points]
+    @cw_local_points ||= opts[:points] || []
     @cw_world_points ||= build_aabb
 
     @radius = opts[:radius]
@@ -28,7 +28,6 @@ class AaBbCollidable < CollidableShape
     ]
   end
 
-  # 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

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

@@ -1,5 +1,8 @@
 class CollidableShape
   attr_accessor :opts, :actor, :radius
+
+  attr_reader :cw_world_points, :cw_local_points, :cw_world_lines, :cw_world_edge_normals
+
   def initialize(actor, options)
     @opts = options
     @actor = actor
@@ -18,6 +21,7 @@ class CollidableShape
     @actor.y + @y_offset
   end
 
+  # TODO find out if this is called
   def setup
   end
 
@@ -26,10 +30,8 @@ class CollidableShape
   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

@@ -4,7 +4,7 @@ class PolygonCollidable < CollidableShape
   attr_accessor :cw_local_points
 
   def setup
-    @collidable_shape = opts[:shape]
+    @shape_type = opts[:shape]
 
     @cw_local_points = opts[:cw_local_points]
     @cw_local_points ||= opts[:points]

data/lib/gamebox/behaviors/emitting.rb

@@ -0,0 +1,48 @@
+Behavior.define :emitting do
+  # options:
+  # delay: ms to wait between creating more particles
+  # particle_actor: actor to spawn as particle
+  # particle_opts: opts to be passed to the spawned particle
+  # ttl: ms to live (optional, will live forever if omitted)
+  # spawn_variance: dist in pixels to spawn away from emitter (default -10..10)
+  # location_tween: tween object that will be used to move the emitter (optional)
+  # follow: actor to follow (optional)
+  requires :stage
+  setup do
+    # TODO which opts do we want from actor and which from behavior?
+    opts = actor.opts
+    variance = opts[:spawn_variance] || (-10..10)
+
+    spawn_timer = "#{self.object_id}_spawn"
+    self.when :remove_me do
+      stage.remove_timer spawn_timer
+    end
+    stage.add_timer spawn_timer, opts[:delay] do
+      spawn_x = self.x + variance.sample
+      spawn_y = self.y + variance.sample
+
+      stage.spawn opts[:particle_actor], {x: spawn_x, y: spawn_y}.merge(opts[:particle_opts])
+    end
+    ttl = opts[:ttl]
+    if ttl
+      suicide_timer = "#{self.object_id}_ttl" 
+      stage.add_timer suicide_timer, ttl do
+        stage.remove_timer suicide_timer
+        actor.remove
+      end
+    end
+
+    target = opts[:follow]
+    if target
+      self.x = target.x
+      self.y = target.y
+      target.when :x_changed do
+        self.x = target.x
+      end
+      target.when :y_changed do
+        self.y = target.y
+      end
+    end
+
+  end
+end