gamebox 0.3.4 → 0.4.0.rc1

data/lib/gamebox/behaviors/positioned.rb

@@ -0,0 +1,16 @@
+define_behavior :positioned do
+  requires :director
+  setup do
+    actor.has_attributes x: 0, y: 0
+    director.when :update do |time|
+      if @x_dirty || @y_dirty
+        actor.react_to :position_changed
+        actor.emit :position_changed 
+      end
+      @x_dirty = false
+      @y_dirty = false
+    end
+    actor.when :x_changed do @x_dirty = true end
+    actor.when :y_changed do @y_dirty = true end
+  end
+end

data/lib/gamebox/behaviors/projectile.rb

@@ -0,0 +1,15 @@
+define_behavior :projectile do
+
+  requires :director
+  requires_behaviors :positioned
+  setup do
+    actor.has_attributes vel_x: 0,
+                         vel_y: 0
+
+    director.when :update do |time, secs|
+      actor.x += (actor.vel_x * secs)
+      actor.y += (actor.vel_y * secs)
+    end
+  end
+
+end

data/lib/gamebox/behaviors/visible.rb

@@ -0,0 +1,16 @@
+# in charge of registering / showing / hiding of actor views
+define_behavior :visible do
+  requires :stage
+  setup do
+    actor.has_attribute :visible
+  end
+
+  react_to do |message, *args|
+    if message == :show
+      stage.register_drawable opts[:view] unless actor.visible
+    elsif message == :hide
+      stage.unregister_drawable opts[:view] if actor.visible
+    end
+    actor.visible = message == :show
+  end
+end

data/lib/gamebox/core/aabb_helpers.rb

@@ -0,0 +1,61 @@
+module AABBTreeDebugHelpers
+  def valid?
+    return true unless @root
+    @root.contains_children?
+  end
+
+  def each(&blk)
+    return unless @root
+    query @root.bb, &blk
+  end
+
+  def each_node(&blk)
+    return unless @root
+    @root.each_node &blk
+  end
+
+  def each_leaf(&blk)
+    return unless @root
+    @root.each_leaf &blk
+  end
+end
+
+module AABBNodeDebugHelpers
+
+  def contains_children?
+    if leaf?
+      true
+    else
+      @bb.contain?(a.bb) &&
+        @bb.contain?(b.bb) &&
+        @a.contains_children? &&
+        @b.contains_children?
+    end
+  end
+
+  def each_node(&blk)
+    blk.call self
+    unless leaf?
+      @a.each_node &blk
+      @b.each_node &blk
+    end
+  end
+
+  def each_leaf(&blk)
+    if leaf?
+      blk.call self
+    else leaf?
+      @a.each_leaf &blk
+      @b.each_leaf &blk
+    end
+  end
+
+  def root
+    node = self
+    while node.parent
+      node = node.parent
+    end
+    node
+  end
+
+end

data/lib/gamebox/core/aabb_node.rb

@@ -0,0 +1,118 @@
+# This is the primary element in an AABBTree.
+# It acts as both containing elements and leaf elements. Leaves have an @object, 
+# containers have @a and @b nodes. All leaf nodes have a cached list of
+# collisions that contain references to other nodes in the tree.
+class AABBNode
+  include AABBNodeDebugHelpers
+  attr_accessor :bb, :a, :b, :parent, :object, :cached_collisions
+
+  def initialize(parent, object, bb)
+    @parent = parent
+    @a = nil
+    @b = nil
+
+    @object = object
+    @bb = bb
+  end
+
+  def insert_subtree(leaf)
+    if leaf?
+      new_node = AABBNode.new nil, nil, @bb.union_fast(leaf.bb)
+      new_node.a = self
+      new_node.b = leaf
+      return new_node
+    else
+      cost_a = @b.bb.area + @a.bb.union_area(leaf.bb)
+      cost_b = @a.bb.area + @b.bb.union_area(leaf.bb)
+
+      if cost_a == cost_b
+        cost_a = @a.proximity(leaf)
+        cost_b = @b.proximity(leaf)
+      end
+
+      if cost_b < cost_a
+        self.b = @b.insert_subtree leaf
+      else
+        self.a = @a.insert_subtree leaf
+      end
+
+      @bb.expand_to_include! leaf.bb
+      return self
+    end
+  end
+
+  def remove_subtree(leaf)
+    if leaf == self
+      return nil
+    else
+      if leaf.parent == self
+        other_child = other(leaf)
+        other_child.parent = @parent
+        return other_child
+      else
+        leaf.parent.disown_child leaf
+        return self
+      end
+    end
+  end
+
+  def query_subtree(search_bb, &blk)
+    if @bb.collide_rect? search_bb
+      if leaf?
+        blk.call @object
+      else
+        @a.query_subtree search_bb, &blk
+        @b.query_subtree search_bb, &blk
+      end
+    end
+  end
+
+  def leaf?
+    @object
+  end
+
+  def a=(new_a)
+    @a = new_a
+    @a.parent = self
+  end
+
+  def b=(new_b)
+    @b = new_b
+    @b.parent = self
+  end
+
+  def other(child)
+    @a == child ? @b : @a
+  end
+
+  def disown_child(leaf)
+    value = other(leaf)
+    raise "Internal Error: Cannot replace child of a leaf." if @parent.leaf?
+    raise "Internal Error: AABBNode is not a child of parent." unless self == @parent.a || self == @parent.b
+
+    if @parent.a == self
+      @parent.a = value
+    else
+      @parent.b = value
+    end
+
+    @parent.update_bb
+  end
+
+  def update_bb
+    node = self
+    unless node.leaf?
+      node.bb.refit_for! node.a.bb, node.b.bb
+      while node = node.parent
+        node.bb.refit_for! node.a.bb, node.b.bb
+      end
+    end
+  end
+
+  def proximity(other_node)
+    other_bb = other_node.bb
+    (@bb.left + @bb.right - other_bb.left - other_bb.right).abs +
+      (@bb.bottom + @bb.top - other_bb.bottom - other_bb.top).abs 
+  end
+end
+

data/lib/gamebox/core/aabb_tree.rb

@@ -0,0 +1,137 @@
+# AABBTree is a binary tree where each node has a bounding box that contains
+# its children's bounding boxes. It extrapolates and expands the node bounding
+# boxes before inserting to lower the amount of updates to the tree structure.
+# It caches all leaf node collisions for quick lookup.
+class AABBTree
+  include AABBTreeDebugHelpers
+  DEFAULT_BB_SCALE = 1
+  VELOCITY_SCALE = 3
+
+  attr_reader :items
+  extend Forwardable
+  def_delegators :@items, :size, :include?
+
+  def initialize
+    @items = {}
+    @root = nil
+  end
+
+  def query(search_bb, &callback)
+    return unless @root
+    @root.query_subtree search_bb, &callback
+  end
+
+  def collisions(item, &blk)
+    leaf = @items[item]
+    return unless leaf && leaf.cached_collisions
+    leaf.cached_collisions.each do |collider|
+      blk.call collider.object
+    end
+  end
+
+  def insert(item)
+    raise "Adding an existing item, please use update" if @items[item]
+    leaf = AABBNode.new nil, item, calculate_bb(item)
+    @items[item] = leaf
+    insert_leaf leaf
+  end
+
+  def remove(item)
+    leaf = @items.delete item
+    @root = @root.remove_subtree leaf if leaf
+    clear_cached_collisions leaf
+  end
+
+  def update(item)
+    node = @items[item]
+    if node && node.leaf?
+      new_bb = calculate_bb(item)
+      unless node.bb.contain? item.bb
+        node.bb = new_bb
+        clear_cached_collisions node
+        @root = @root.remove_subtree node
+        insert_leaf node
+      end
+    end
+  end
+
+  private
+
+  def clear_cached_collisions(leaf)
+    cached_collisions = leaf.cached_collisions
+
+    if cached_collisions
+      leaf.cached_collisions = nil
+      cached_collisions.each do |other|
+        other.cached_collisions.delete leaf
+      end
+    end
+  end
+
+  def build_cached_collisions(leaf)
+    each_leaf do |other|
+      if leaf != other && leaf.bb.collide_rect?(other.bb)
+        leaf.cached_collisions ||= []
+        other.cached_collisions ||= []
+        leaf.cached_collisions << other 
+        other.cached_collisions << leaf
+      end
+    end
+  end
+
+  def insert_leaf(leaf)
+    if @root
+      @root = @root.insert_subtree leaf
+    else
+      @root = leaf
+    end
+    build_cached_collisions leaf
+  end
+
+  def expand_bb_by!(bb, percent)
+    new_w = bb.w * percent
+    new_h = bb.h * percent
+    hw = new_w / 2.0
+    hh = new_h / 2.0
+
+    bb.x = (bb.x - hw).ceil
+    bb.y = (bb.y - hh).ceil
+    bb.w = (bb.w + new_w).ceil
+    bb.h = (bb.h + new_h).ceil
+    bb
+  end
+
+  def project_bb_by_velocity!(bb, velocity_vector)
+    future_vector = velocity_vector * VELOCITY_SCALE
+    projected_bb = [bb.x + velocity_vector.x,
+                    bb.y + velocity_vector.y,
+                    bb.w, bb.h ]
+
+    u_bb = bb.union_fast(projected_bb)
+    bb.x = u_bb.x
+    bb.y = u_bb.y
+    bb.w = u_bb.w
+    bb.h = u_bb.y
+  end
+
+  def calculate_bb(item)
+    if item.respond_to? :bb
+      bb = item.bb.dup
+      project_bb_by_velocity!(bb, item.velocity) if item.respond_to? :velocity
+      expand_bb_by!(bb, DEFAULT_BB_SCALE)
+    else
+      if item.respond_to? :width
+        w = item.width
+        h = item.height
+      elsif item.respond_to? :radius
+        w = item.radius * 2
+        h = item.radius * 2
+      end
+      w ||= 2
+      h ||= 2
+
+      expand_bb_by!(Rect.new item.x, item.y, w, h, DEFAULT_BB_SCALE)
+    end
+  end
+end
+

data/lib/gamebox/core/actor.rb

@@ -0,0 +1,102 @@
+# Actor represent a game object.
+# Actors can have behaviors added and removed from them. Such as :physical or :animated.
+# They are created and hooked up to their optional View class in Stage#create_actor.
+class Actor
+  extend Publisher
+  include EventedAttributes
+  include Gamebox::Extensions::Object::Yoda
+  can_fire_anything
+  construct_with :this_object_context
+  public :this_object_context
+
+  has_attribute :alive
+
+  def initialize
+    @behaviors = {}
+  end
+
+  def configure(opts={}) # :nodoc:
+    has_attributes opts
+    self.actor_type = opts[:actor_type]
+    self.alive = true
+  end
+
+  def add_behavior(name, behavior)
+    @behaviors[name] = behavior
+  end
+
+  def react_to(message, *opts)
+    # TODO cache the values array?
+    @behaviors.values.each do |behavior|
+      behavior.react_to(message, *opts)
+    end
+  end
+
+  def has_behavior?(name)
+    @behaviors[name]
+  end
+
+  def emit(event, *args)
+    fire event, *args
+  end
+
+  # Tells the actor's Director that he wants to be removed; and unsubscribes
+  # the actor from all input events.
+  def remove
+    self.alive = false
+    react_to :remove
+    fire :remove_me
+  end
+
+  def to_s
+    atts = methods.sort - Actor.instance_methods
+    atts_hash = {}
+    atts.each do |att|
+      atts_hash[att] = send(att) unless att.to_s.end_with? "="
+    end
+    "#{self.actor_type}:#{self.object_id} with attributes\n#{atts_hash.inspect}"
+  end
+
+  # TODO should this live somewhere else?
+  # TODO should we support "inheritance" of components?
+  class << self
+
+    def define(actor_type, opts={}, &blk)
+      @definitions ||= {}
+      definition = ActorDefinition.new
+      definition.instance_eval &blk if block_given?
+      @definitions[actor_type] = definition
+
+      view_blk = definition.view_blk
+      if view_blk
+        ActorView.define "#{actor_type}_view".to_sym, &view_blk
+      end
+    end
+
+    def definitions
+      @definitions ||= {}
+    end
+
+  end
+
+  class ActorDefinition
+    attr_accessor :behaviors, :attributes, :view_blk
+    def initialize
+      @behaviors = []
+      @attributes = []
+    end
+
+    def has_behaviors(*behaviors)
+      behaviors.each do |beh|
+        @behaviors << beh
+      end
+    end
+    alias has_behavior has_behaviors
+
+    # TODO spec view helper on actor def
+    def view(&blk)
+      @view_blk = blk
+    end
+  end
+
+end