gamebox 0.0.7 → 0.0.8

data/lib/gamebox/actor.rb

@@ -7,21 +7,20 @@ class Actor
   can_fire_anything
   
   attr_accessor :behaviors, :x, :y, :stage, :input_manager,
-    :resource_manager, :alive, :opts, :sound_manager, :visible,
-    :director
-
+    :resource_manager, :alive, :opts, :visible, :director, 
+    :actor_type
 
   def initialize(opts={}) # :nodoc:
     @opts = opts
-    @x = @opts[:x]
-    @y = @opts[:y]
+    @x = opts[:x]
+    @y = opts[:y]
     @x ||= 0
     @y ||= 0
     @stage = opts[:stage]
     @input_manager = opts[:input]
-    @sound_manager = opts[:sound]
     @resource_manager = opts[:resources]
     @director = opts[:director]
+    @actor_type = opts[:actor_type]
     @alive = true
 
     @behaviors = {}
@@ -109,18 +108,12 @@ class Actor
 
   # Creates a new actor and returns it. (This actor will automatically be added to the Director.
   def spawn(type, args={})
-    @stage.create_actor type, args
-  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
+    @stage.spawn type, args
   end
 
-  # Stops a sound via the SoundManager.
-  def stop_sound(*args)
-    @sound_manager.stop_sound *args
+  # Access to backstage for storage
+  def backstage
+    @stage.backstage
   end
 
   # to be defined in child class
@@ -142,29 +135,28 @@ class Actor
   def visible?
     @visible
   end
-  
-  # magic
-  metaclass.instance_eval do
-    define_method( :behaviors ) do
-      @behaviors ||= []
-    end
-    define_method( :has_behaviors ) do |*args|
-      @behaviors ||= []
-      for a in args
-        if a.is_a? Hash
-          for k,v in a 
-            h = {}
-            h[k]=v
-            @behaviors << h
-          end
-        else
-          @behaviors << a
+
+  def self.behaviors
+    @behaviors ||= []
+  end
+
+  def self.has_behaviors(*args)
+    @behaviors ||= []
+    for a in args
+      if a.is_a? Hash
+        for k,v in a 
+          h = {}
+          h[k]=v
+          @behaviors << h
         end
+      else
+        @behaviors << a
       end
-      @behaviors
-    end
-    define_method( :has_behavior ) do |*args|
-      has_behaviors *args
     end
+    @behaviors
+  end
+
+  def self.has_behavior(*args)
+    has_behaviors *args
   end
 end

data/lib/gamebox/actor_factory.rb

@@ -2,10 +2,10 @@ require 'actor'
 require 'graphical_actor_view'
 
 # ActorFactory is responsible for loading all Actors. It passes along required params such as 
-# stage, input_manager, sound_manager, director, resource_manager. It also creates the ActorView 
+# stage, input_manager, director, resource_manager. It also creates the ActorView 
 # associated with the Actor and registers it to the Stage be drawn. 
 class ActorFactory
-  constructor :input_manager, :sound_manager
+  constructor :input_manager
 
   attr_accessor :stage_manager, :director
   
@@ -15,27 +15,9 @@ class ActorFactory
     cached_actor = @actor_cache[actor]
     return cached_actor if cached_actor
 
+    model_klass = ClassFinder.find(actor)
+    view_klass = ClassFinder.find("#{actor}_view")
     
-    model_klass_name = Inflector.camelize actor
-    begin
-      model_klass = Object.const_get model_klass_name
-    rescue NameError
-      # not there yet
-      begin
-        require actor.to_s
-        require actor.to_s+"_view"
-      rescue LoadError => ex
-        # maybe its included somewhere else
-      ensure
-        model_klass = Object.const_get model_klass_name
-      end
-    end
-    
-    begin
-      view_klass = Object.const_get model_klass_name+"View"
-    rescue Exception => ex
-      # hrm...
-    end
     actor_def = {
       :model_klass => model_klass,
       :view_klass => view_klass
@@ -48,12 +30,13 @@ 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,
-      :sound => @sound_manager,
       :director => @director,
-      :resources => stage.resource_manager
+      :resources => stage.resource_manager,
+      :actor_type => actor
     }
     merged_opts = basic_opts.merge(opts)
 

data/lib/gamebox/actors/curtain.rb

@@ -0,0 +1,57 @@
+require 'actor'
+require 'publisher'
+require 'actor_view'
+
+class CurtainView < ActorView
+  def draw(target,x_off,y_off)
+    target.draw_box_s [0,0],[1024,800], [0,0,0,@actor.height]
+  end
+end
+
+class Curtain < Actor
+  extend Publisher
+
+  can_fire :curtain_up, :curtain_down
+
+  has_behavior :updatable, :layered => {:layer => 99_999}
+
+  attr_accessor :height
+
+  FULL_CURTAIN = 255
+  NO_CURTAIN = 0
+  def setup
+    @duration_in_ms = @opts[:duration]
+    @duration_in_ms ||= 1000
+
+    case @opts[:dir]
+    when :up
+      @height = FULL_CURTAIN
+      @dir = -1
+    when :down
+      @height = NO_CURTAIN
+      @dir = 1
+    end
+  end
+
+  # Update curtain height 0-255 (alpha)
+  def update(time)
+    perc_change = time.to_f/@duration_in_ms
+    amount = FULL_CURTAIN * perc_change * @dir
+    @height += amount.floor
+
+    if @height < 0
+      @height = 0
+      if alive?
+        fire :curtain_up
+        remove_self
+      end
+    elsif @height > 255
+      @height = 255
+      if alive?
+        fire :curtain_down
+        remove_self
+      end
+    end
+
+  end
+end

data/lib/gamebox/actors/label.rb

@@ -0,0 +1,23 @@
+class LabelView < ActorView
+  def draw(target,x_off,y_off)
+    actor.text_image.blit target.screen, [actor.x, actor.y]
+  end
+end
+class Label < Actor
+  attr_accessor :text, :text_image
+
+  def setup
+    @text = @opts[:text]
+    @size = @opts[:size]
+    @font = @opts[:font]
+    @color = @opts[:color]
+
+    @text ||= ""
+    @size ||= 30
+    @font ||= "Asimov.ttf"
+    @color ||= [250,250,250,255]
+
+    font = resource_manager.load_font @font, @size
+    @text_image = font.render @text.to_s, true, @color
+  end
+end

data/lib/gamebox/actors/score.rb

@@ -13,24 +13,28 @@ class ScoreView < ActorView
   end
 end
 class Score < Actor
+
   has_behavior :layered => {:layer => 999}
-  attr_accessor :score
 
   def setup
-    clear
+    clear if backstage[:score].nil?
+  end
+
+  def score
+    backstage[:score]
   end
 
   def clear
-    @score = 0
+    backstage[:score] = 0
   end
 
   def +(amount)
-    @score += amount
+    backstage[:score] += amount
     self
   end
 
   def -(amount)
-    @score -= amount
+    backstage[:score] -= amount
     self
   end
 end

data/lib/gamebox/arbiter.rb

@@ -0,0 +1,75 @@
+# this module gets mixed into a stage to allow it to handle collision detection
+module Arbiter
+
+  def register_collidable(actor)
+    @collidable_actors ||= []
+    unless @collidable_actors.include? actor
+      actor.when :remove_me do 
+        unregister_collidable actor
+      end
+      @collidable_actors << actor 
+    end
+  end
+
+  def unregister_collidable(actor)
+    @collidable_actors ||= []
+    @collidable_actors.delete actor
+  end
+
+  def on_collision_of(first_objs, second_objs, &block)
+    first_objs = [first_objs].flatten
+    second_objs = [second_objs].flatten
+
+    @collision_handlers ||= {}
+
+    first_objs.each do |fobj|
+      second_objs.each do |sobj|
+#        puts "registering #{fobj} and #{sobj}"
+        @collision_handlers[fobj] ||= {}
+        @collision_handlers[fobj][sobj] = block
+      end
+    end
+  end
+
+  # TODO how is this going to get called?, method chaining update?
+  def find_collisions
+    collisions = []
+    @collidable_actors.size.times do |i|
+      first = @collidable_actors[i]
+      (@collidable_actors.size).times do |j|
+        second = @collidable_actors[i-j]
+
+        if collide?(first, second)
+          collisions << [first,second]
+        end
+      end
+    end
+
+    collisions.each do |collision|
+      first = collision.first
+      second = collision.last
+      colliders = @collision_handlers[first.actor_type]
+      callback = colliders[second.actor_type] unless colliders.nil?
+      callback.call first, second unless callback.nil?
+    end
+  end
+
+  def collide?(object, other)
+    self.send "collide_#{object.shape}_#{object.shape}?", object, other
+  end
+
+  def collide_circle_circle?(object, other)
+#    puts "comparing #{object.actor_type}[#{object.object_id}] to #{other.actor_type}[#{other.object_id}]"
+    x = object.x + object.radius
+    y = object.y + object.radius
+    x_prime = other.x + other.radius
+    y_prime = other.y + other.radius
+
+    x_dist  = (x_prime - x) * (x_prime - x)
+    y_dist  = (y_prime - y) * (y_prime - y)
+
+    total_radius = object.radius + other.radius
+    x_dist + y_dist < (total_radius) * (total_radius)
+  end
+
+end

data/lib/gamebox/backstage.rb

@@ -0,0 +1,17 @@
+# Backstage is a place to store things across stages. It does not allow you to store Actors here.
+class Backstage
+  def initialize
+    @storage = {}
+  end
+
+  def set(key, value)
+    raise "Actors cannot wander back stage!" if value.is_a? Actor
+    @storage[key] = value
+  end
+  alias []= set
+
+  def get(key)
+    @storage[key]
+  end
+  alias [] get
+end

data/lib/gamebox/behavior.rb

@@ -1,10 +1,16 @@
 # Behavior is any type of behavior an actor can exibit.
 class Behavior
-  attr_accessor :actor
+  attr_accessor :actor, :opts
 
   def initialize(actor,opts={})
     @actor = actor
     @opts = opts
+    req_behs = self.class.required_behaviors
+    req_behs.each do |beh|
+      unless @actor.is? beh
+        @actor.is beh
+      end
+    end
     setup
   end
 
@@ -16,4 +22,21 @@ class Behavior
 
   def update(time)
   end
+
+  def self.required_behaviors
+    @required_behaviors ||= []
+  end
+
+  def self.requires_behaviors(*args)
+    @required_behaviors ||= []
+    for a in args
+      @required_behaviors << a
+    end
+    @behaviors
+  end
+
+  def self.requires_behavior(*args)
+    requires_behaviors(*args)
+  end
+
 end

data/lib/gamebox/behaviors/animated.rb

@@ -4,6 +4,8 @@ require 'behavior'
 # 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
     @images = {}

data/lib/gamebox/behaviors/audible.rb

@@ -0,0 +1,34 @@
+require 'behavior'
+
+class Audible < Behavior
+  
+  def setup
+    @sound_manager = @actor.stage.sound_manager
+
+    audible_obj = self
+    @actor.instance_eval do
+      (class << self; self; end).class_eval do
+        define_method :play_sound do |*args|
+          audible_obj.play_sound *args
+        end
+        define_method :stop_sound do |*args|
+          audible_obj.stop_sound *args
+        end
+      end
+  end
+
+
+  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
+
+  # Stops a sound via the SoundManager.
+  def stop_sound(*args)
+    @sound_manager.stop_sound *args
+  end
+
+end