gamebox 0.2.1 → 0.3.2

data/lib/gamebox/actor_factory.rb

@@ -1,5 +1,3 @@
-require 'actor'
-require 'graphical_actor_view'
 
 # ActorFactory is responsible for loading all Actors. It passes along required params such as 
 # stage, input_manager, director, resource_manager. It also creates the ActorView 
@@ -16,6 +14,8 @@ class ActorFactory
     return cached_actor if cached_actor
 
     model_klass = ClassFinder.find(actor)
+    raise "#{actor} not found" unless model_klass
+    
     view_klass = ClassFinder.find("#{actor}_view")
     
     actor_def = {
@@ -30,16 +30,15 @@ class ActorFactory
   def build(actor, stage, opts={})
     actor_def = cached_actor_def actor
 
-    actor_type = actor_def[:actor_type]
     basic_opts = {
       :stage => stage,
       :input => @input_manager,
       :director => @director,
       :resources => stage.resource_manager,
-      :actor_type => actor
+      :actor_type => actor,
+      :wrapped_screen => @wrapped_screen
     }
     merged_opts = basic_opts.merge(opts)
-
     model = actor_def[:model_klass].new merged_opts 
 
     view_klass = opts[:view]

data/lib/gamebox/actor_view.rb

@@ -32,5 +32,13 @@ class ActorView
   def setup
   end
 
+  def screen_width
+    @screen_width ||= @wrapped_screen.width
+  end
+
+  def screen_height
+    @screen_height ||= @wrapped_screen.height
+  end
+
 end
 

data/lib/gamebox/actors/collidable_debugger.rb

@@ -1,5 +1,5 @@
-require 'actor'
-require 'actor_view'
+
+
 
 class CollidableDebugger < Actor
   

data/lib/gamebox/actors/curtain.rb

@@ -1,10 +1,10 @@
-require 'actor'
+
 require 'publisher'
-require 'actor_view'
+
 
 class CurtainView < ActorView
   def draw(target,x_off,y_off,z)
-    target.fill 0,0,1024,800, [0,0,0,@actor.height]
+    target.fill 0,0,1024,800, [0,0,0,@actor.height], z
   end
 end
 

data/lib/gamebox/actors/emitter.rb

@@ -0,0 +1,51 @@
+# class used for particle emissions
+class Emitter < Actor
+  
+  # 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)
+  def setup
+    @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_particle
+    end
+    ttl = opts[:ttl]
+    if ttl
+      suicide_timer = "#{self.object_id}_ttl" 
+      stage.add_timer suicide_timer, ttl do
+        stage.remove_timer suicide_timer
+        remove_self
+      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
+
+  def spawn_particle
+    spawn_x = self.x + @variance.sample
+    spawn_y = self.y + @variance.sample
+
+    spawn opts[:particle_actor], {x: spawn_x, y: spawn_y}.merge(opts[:particle_opts])
+  end
+end

data/lib/gamebox/actors/label.rb

@@ -1,23 +1,43 @@
 class LabelView < ActorView
-  def draw(target,x_off,y_off)
-    actor.text_image.blit target.screen, [actor.x, actor.y]
+  def draw(target,x_off,y_off,z)
+    @converted_color ||= target.convert_color(actor.color)
+    actor.font.draw actor.text, actor.x, actor.y, z, 
+      1,1,   # x factor, y factor
+      @converted_color
   end
 end
+
 class Label < Actor
-  attr_accessor :text, :text_image
+  has_behavior layered: {layer: 1}
+  attr_accessor :text, :font, :color
 
   def setup
     @text = @opts[:text]
     @size = @opts[:size]
-    @font = @opts[:font]
+    font_name = @opts[:font]
     @color = @opts[:color]
 
     @text ||= ""
     @size ||= 30
-    @font ||= "Asimov.ttf"
+    font_name ||= "Asimov.ttf"
     @color ||= [250,250,250,255]
+    layer = opts[:layer]
+    layered.layer = layer
+
+    @font = resource_manager.load_font font_name, @size
+  end
+
+  def width
+    font.text_width(text)
+  end
+
+  def height
+    [font.text_width(text),font.height]
+  end
 
-    font = resource_manager.load_font @font, @size
-    @text_image = font.render @text.to_s, true, @color
+  def resize(size)
+    @size = size
+    resource_manager.load_font @font, @size
   end
+
 end

data/lib/gamebox/actors/logo.rb

@@ -1,4 +1,4 @@
-require 'actor'
+
 class Logo < Actor
   has_behaviors :graphical, 
   :layered => {:layer => 999}

data/lib/gamebox/actors/spatial_debugger.rb

@@ -1,5 +1,5 @@
-require 'actor'
-require 'actor_view'
+
+
 
 class SpatialDebugger < Actor
   
@@ -24,24 +24,39 @@ end
 
 class SpatialDebuggerView < ActorView
   def setup
-    size = 30
-    font = "Asimov.ttf"
-    @font = @actor.resource_manager.load_font font, size
+    # size = 30
+    # font = "Asimov.ttf"
+    # @font = @actor.resource_manager.load_font font, size
   end
 
-  def draw(target,x_off,y_off)
+  def draw(target,x_off,y_off, z)
+    vp = stage.viewport
     cell_size = @actor.spatial.cell_size
     max = 0
     @actor.spatial.buckets.each do |x_bucket,stuff|
       stuff.each do |y_bucket,items|
-        max = items.size if items.size > max
+        # max = items.size if items.size > max
         x = x_bucket * cell_size + x_off
         y = y_bucket * cell_size + y_off
-        target.draw_box [x,y], [x+cell_size,y+cell_size], Color[:white]
+        target.draw_box x, y, x+cell_size, y+cell_size, [255,25,25], z
+
+        # Yes I know I may be drawing this many times for an actor
+        items.each do |item|
+          # puts "#{item.class}: [#{item.center_x}, #{item.center_y}] #{item.collidable_shape}"
+          parallax = 1
+          ix = item.center_x + x_off
+          iy = item.center_y + y_off
+
+          target.draw_box ix, iy, ix + 2, iy + 2, [255,255,255], 10
+
+          # TODO make work for non circles
+          r = item.radius
+          target.draw_box ix-r, iy-r, ix + r, iy + r, [255,255,255], 10
+        end
       end
     end
 
-    @text_image = @font.render "#{@actor.ratio} [#{max}]", true, Color[:white]
-    @text_image.blit target.screen, [@actor.x, @actor.y]
+    # @text_image = @font.render "#{@actor.ratio} [#{max}]", true, Color[:white]
+    # @text_image.blit target.screen, [@actor.x, @actor.y]
   end
 end

data/lib/gamebox/arbiter.rb

@@ -3,21 +3,11 @@ module Arbiter
   attr_reader :checks, :collisions
 
   def register_collidable(actor)
-    @spatial_hash = stagehand(:spatial)
-    @collidable_actors ||= []
-    unless @collidable_actors.include? actor
-      actor.when :remove_me do 
-        unregister_collidable actor
-      end
-      @collidable_actors << actor 
-      @spatial_hash.add(actor)
-    end
+    stagehand(:spatial).add(actor)
   end
 
   def unregister_collidable(actor)
-    @collidable_actors ||= []
-    @collidable_actors.delete actor
-    @spatial_hash.remove(actor)
+    stagehand(:spatial).remove(actor)
   end
 
   def on_collision_of(first_objs, second_objs, &block)
@@ -28,7 +18,7 @@ module Arbiter
 
     first_objs.each do |fobj|
       second_objs.each do |sobj|
-        if fobj.to_i < sobj.to_i
+        if fobj < sobj
           @collision_handlers[fobj] ||= {}
           @collision_handlers[fobj][sobj] = [false,block]
         else
@@ -44,7 +34,7 @@ module Arbiter
     collisions.each do |collision|
       first = collision.first
       second = collision.last
-      unless first.actor_type.to_i < second.actor_type.to_i
+      unless first.actor_type < second.actor_type
         tmp = first
         first = second
         second = tmp
@@ -63,29 +53,33 @@ module Arbiter
   end
 
   def find_collisions
-    @collidable_actors ||= []
+    spatial_hash = stagehand(:spatial)
+    collidable_actors = spatial_hash.moved_items
     @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
+    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
+      w = spatial_hash.cell_size * 3
       h = w
 
-      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
+      tmp_collidable_actors = spatial_hash.neighbors_of(first)
+
+      if first.is? :collidable
+        tmp_collidable_actors.each do |second|
+          @checks += 1
+          if second.is? :collidable
+            if first != second && collide?(first, second)
+              collisions[second] ||= []
+              if !collisions[second].include?(first)
+                @collisions += 1
+                collisions[first] ||= []
+                collisions[first] << second
+              end
+            end
           end
         end
       end
@@ -96,12 +90,43 @@ module Arbiter
         unique_collisions << [first,second]
       end
     end
+
     run_callbacks unique_collisions
   end
 
   def collide?(object, other)
-    # TODO perf analysis of this
-    self.send "collide_#{object.collidable_shape}_#{other.collidable_shape}?", object, other
+    if !other.is? :collidable
+      binding.pry
+    end
+    case object.collidable_shape
+    when :circle
+      case other.collidable_shape
+      when :circle
+        collide_circle_circle? object, other
+      when :aabb
+        collide_circle_aabb? object, other
+      when :polygon
+        collide_circle_polygon? object, other
+      end
+    when :aabb
+      case other.collidable_shape
+      when :circle
+        collide_aabb_circle? object, other
+      when :aabb
+        collide_aabb_aabb? object, other
+      when :polygon
+        collide_aabb_polygon? object, other
+      end
+    when :polygon
+      case other.collidable_shape
+      when :circle
+        collide_polygon_circle? object, other
+      when :aabb
+        collide_polygon_aabb? object, other
+      when :polygon
+        collide_polygon_polygon? object, other
+      end
+    end
   end
 
   def collide_circle_circle?(object, other)
@@ -110,8 +135,10 @@ module Arbiter
     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)
+    x_delta = x_prime - x
+    x_dist  = x_delta * x_delta
+    y_delta = y_prime - y
+    y_dist  = y_delta * y_delta
 
     total_radius = object.radius + other.radius
     x_dist + y_dist <= (total_radius * total_radius)

data/lib/gamebox/behavior.rb

@@ -56,11 +56,11 @@ class Behavior
     @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
+          # log("redefining #{meth} for #{@actor.class}") if @actor.respond_to? meth
           target.relegated_methods << meth
 
-          define_method meth do |*args|
-            target.send meth, *args
+          define_method meth do |*args, &block|
+            target.send meth, *args, &block
           end
         end
       end

data/lib/gamebox/behaviors/animated.rb

@@ -1,4 +1,4 @@
-require 'behavior'
+
 # 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/lib/gamebox/behaviors/audible.rb

@@ -1,4 +1,4 @@
-require 'behavior'
+
 
 class Audible < Behavior
   

data/lib/gamebox/behaviors/collidable.rb

@@ -1,7 +1,7 @@
-require 'behavior'
-require 'collidable/circle_collidable'
-require 'collidable/aabb_collidable'
-require 'collidable/polygon_collidable'
+
+
+
+
 
 # available collidable_shapes are :circle, :polygon, :aabb
 class Collidable < Behavior
@@ -22,6 +22,11 @@ class Collidable < Behavior
     @actor.stage.register_collidable @actor
   end
 
+  def removed
+    @actor.stage.unregister_collidable @actor
+    super
+  end
+
   def build_shape
     shape = nil
     @collidable_shape = opts[:shape]

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

@@ -1,8 +1,33 @@
-require 'collidable/collidable_shape'
+
 
 class AaBbCollidable < CollidableShape
   attr_accessor :cw_local_points
 
+  def setup
+    @collidable_shape = opts[:shape]
+
+    @cw_local_points = opts[:cw_local_points]
+    @cw_local_points ||= opts[:points]
+    @cw_world_points ||= build_aabb
+
+    @radius = opts[:radius]
+    @radius ||= calculate_radius
+
+    @old_x = actor_x
+    @old_y = actor_y
+  end
+
+  def build_aabb
+    w = @actor.width
+    h = @actor.height
+    [
+      [0,0],
+      [w,0],
+      [w,h],
+      [0,h]
+    ]
+  end
+
   # TODO infinite loop if actor hasn't defined width and it gets relegated to us
   def calculate_radius
     w = @actor.width