gamebox 0.3.4 → 0.4.0.rc1

data/lib/gamebox/{stage_manager.rb → core/stage_manager.rb}

@@ -1,68 +1,39 @@
 class StageManager
 
-  constructor :resource_manager, :actor_factory, :input_manager,
-    :sound_manager, :config_manager
+  construct_with :input_manager, :config_manager, :backstage,
+    :this_object_context
 
-  def setup
+  attr_reader :stage_names, :stage_opts
+
+  def initialize
     @stages = {}
-    @backstage = Backstage.new
 
-    @actor_factory.stage_manager = self
-    stages = @config_manager.load_config('stage_config')[:stages]
+    stages = Gamebox.configuration.stages
 
     @stage_names = []
     @stage_opts = []
     stages.each do |stage|
-      stage_name = stage.keys.first
-      opts = stage.values.first
-      @stage_names << stage_name
-      opts ||= {}
-      @stage_opts << opts
-    end
-  end
-  
-  def lookup_stage_class(stage_name)
-    index = @stage_names.index stage_name
-    opts = @stage_opts[index]
-
-    name = opts[:class]
-    name ||= stage_name
-    stage_klass_name ||= Inflector.camelize name.to_s+"Stage"
-
-    begin
-      require name.to_s+"_stage"
-    rescue LoadError => ex
-      STDERR.puts ex
-      # TODO hrm.. should this get logged
-      # hope it's defined somewhere else
+      if stage.is_a? Hash
+        stage_name = stage.keys.first
+        opts = stage.values.first
+        @stage_names << stage_name
+        opts ||= {}
+        @stage_opts << opts
+      else
+        @stage_names << stage
+        @stage_opts << {}
+      end
     end
-    stage_klass = ObjectSpace.const_get stage_klass_name
   end
 
-  def create_stage(name, opts)
-    stage_instance = lookup_stage_class(name).new(@input_manager, @actor_factory, @resource_manager, @sound_manager, @config_manager, @backstage, opts)
-
-    stage_instance.when :next_stage do |*args|
-      next_stage *args
-    end
-    stage_instance.when :prev_stage do |*args|
-      prev_stage *args
-    end
-    stage_instance.when :restart_stage do |*args|
-      restart_stage *args
-    end
-    stage_instance.when :change_stage do |stage_name, *args|
-      switch_to_stage stage_name, *args
-    end
-
-    
-    stage_instance
+  def default_stage
+    @stage_names.first
   end
 
   def next_stage(*args)
     index = @stage_names.index @stage
     if index == @stage_names.size-1
-      puts "last stage, exiting"
+      log "last stage, exiting"
       exit
     end
 
@@ -72,7 +43,7 @@ class StageManager
   def prev_stage(*args)
     index = @stage_names.index @stage
     if index == 0
-      puts "first stage, exiting"
+      log "first stage, exiting"
       exit
     end
 
@@ -80,9 +51,6 @@ class StageManager
   end
 
   def restart_stage(*args)
-    current_stage.curtain_dropping *args
-    index = @stage_names.index @stage
-
     switch_to_stage @stage, *args
   end
 
@@ -117,11 +85,36 @@ class StageManager
     if @stage and @stages and @stages[@stage]
       current_stage = @stages[@stage]
       current_stage.curtain_dropping *args
-      @input_manager.clear_hooks(current_stage)
+      input_manager.clear_hooks(current_stage)
       @stages.delete @stage
       @stage = nil
       @stage_args = nil
     end
   end
 
+  def create_stage(name, opts)
+    stage_instance = nil
+    this_object_context.in_subcontext do |stage_context|
+      name_or_klass = opts[:class] || name
+      stage_instance = stage_context["#{name_or_klass}_stage"]
+      stage_context[:stage] = stage_instance 
+    end
+    stage_instance.configure(backstage, opts)
+
+    stage_instance.when :next_stage do |*args|
+      next_stage *args
+    end
+    stage_instance.when :prev_stage do |*args|
+      prev_stage *args
+    end
+    stage_instance.when :restart_stage do |*args|
+      restart_stage *args
+    end
+    stage_instance.when :change_stage do |stage_name, *args|
+      switch_to_stage stage_name, *args
+    end
+    stage_instance
+  end
+
+
 end

data/lib/gamebox/core/timer_manager.rb

@@ -0,0 +1,50 @@
+class TimerManager
+
+  def initialize
+    @timers ||= {}
+    @dead_timers = []
+  end
+
+  # add block to be executed every interval_ms millis
+  def add_timer(name, interval_ms, recurring = true, &block)
+    raise "timer [#{name}] already exists" if @timers[name]
+    @timers[name] = {
+      count: 0, recurring: recurring,
+      interval_ms: interval_ms, callback: block}
+  end
+
+  def remove_timer(name)
+    @timers.delete name
+  end
+
+  def timer(name)
+    @timers[name]
+  end
+
+  # update each timers counts, call any blocks that are over their interval
+  def update(time_delta)
+    # TODO handle overwriting the same timer name...
+    @timers.each do |name, timer_hash|
+      timer_hash[:count] += time_delta
+      if timer_hash[:count] > timer_hash[:interval_ms]
+        timer_hash[:count] -= timer_hash[:interval_ms]
+        timer_hash[:callback].call
+        @dead_timers << name unless timer_hash[:recurring]
+      end
+    end
+    @dead_timers.each do |name|
+      remove_timer name
+    end
+  end
+
+  def pause
+    @paused_timers = @timers
+    @timers = {}
+  end
+
+  def unpause
+    @timers = @paused_timers
+    @paused_timers = {}
+  end
+
+end

data/lib/gamebox/{viewport.rb → core/viewport.rb}

@@ -76,7 +76,6 @@ class Viewport
         scrolled = true
       end
 
-
       y_diff = @height/2 + @follow_offset_y - y - @y_offset
       if y_diff.abs > @buffer_y
         # move screen
@@ -120,14 +119,14 @@ class Viewport
 
     @x_offset = @width/2 - @follow_target.x + @follow_offset_x
     @y_offset = @height/2 - @follow_target.y + @follow_offset_y
-    
+
     fire :scrolled
   end
 
   def bounds
     left = -@x_offset
     top = -@y_offset
-    [left, top, left + @width, top + @height]
+    Rect.new left, top, left + @width, top + @height
   end
 
 end

data/lib/gamebox/{wrapped_screen.rb → core/wrapped_screen.rb}

@@ -1,11 +1,15 @@
 class WrappedScreen
-  constructor :config_manager
+  construct_with :config_manager
   attr_accessor :screen
-  def setup
-    width, height = *@config_manager[:screen_resolution]
-    fullscreen = @config_manager[:fullscreen]
+  def initialize
+    width, height = *config_manager[:screen_resolution]
+    fullscreen = config_manager[:fullscreen]
+    needs_cursor = config_manager[:needs_cursor]
     @screen = HookedGosuWindow.new width, height, fullscreen
-    @screen.caption = @config_manager[:title]
+    @screen.tap do |screen|
+      screen.caption = config_manager[:title]
+      screen.needs_cursor = config_manager[:needs_cursor]
+    end
   end
 
   def method_missing(name,*args)
@@ -114,19 +118,8 @@ class WrappedScreen
     c
   end
 
-  def size_text(text, font_file, font_size)
-    @font_cache ||= {}
-    @font_cache[font_file] ||= {}
-    font = @font_cache[font_file][font_size] ||= Font.new(@screen, font_file, font_size)
-
-    return [font.text_width(text),font.height]
-  end
-
-  def render_text(text, font_file, font_size, color)
-    @font_cache ||= {}
-    @font_cache[font_file] ||= {}
-    font = @font_cache[font_file][font_size] ||= Font.new(@screen, font_file, font_size)
-
-    DelayedText.new font, text
+  def print(text, x, y, z, font_style)
+    font_style.font.draw text, x, y, z, font_style.x_scale, font_style.y_scale, convert_color(font_style.color)
   end
 end
+  

data/lib/gamebox/gamebox_application.rb

@@ -14,25 +14,16 @@ class GameboxApp
   end
 
   def initialize
-    gamebox_objects = YAML.load(File.read(GAMEBOX_PATH + 'data/config/objects.yml'))
-
-    game_objects_file = APP_ROOT + '/config/objects.yml'
-    game_specific_objects = {}
-    if File.exist? game_objects_file
-      game_specific_objects = YAML.load(File.read(game_objects_file))
-    end
-    objects = gamebox_objects.merge! game_specific_objects
-
-    @context = DIY::Context.from_yaml(YAML.dump(objects))
+    @context = Conject.default_object_context
   end
-  
+
   def setup
     @game = @context[:game]
-    
+    @game.configure
     @config_manager = @context[:config_manager]
     setup_debug_server if @config_manager[:debug_server] || ARGV.include?("-debug-server")
   end
-  
+
   def setup_debug_server
     Thread.new do
       loop do
@@ -40,10 +31,11 @@ class GameboxApp
       end
     end
   end
-  
+
   def main_loop
     @input_manager = @context[:input_manager]
-    @input_manager.main_loop @game
+    @input_manager.register @game
+    @input_manager.show
   end
 
   def shutdown

data/lib/gamebox/lib/evented_attributes.rb

@@ -0,0 +1,51 @@
+module EventedAttributes
+
+  def has_attributes(*names)
+    if names.first.is_a? Hash
+      names.first.each do |name, default|
+        has_attribute name, default
+      end
+    else
+      names.each do |name|
+        has_attribute name
+      end
+    end
+  end
+
+  def has_attribute(name, value=nil)
+    @evented_attributes ||= []
+    unless has_attribute? name
+      @evented_attributes << name
+      self.metaclass.send :kvo_attr_accessor, name
+      self.define_singleton_method "#{name}?" do
+        self.send name
+      end
+      self.send("#{name}=", value)
+    end
+  end
+
+  def has_attribute?(name)
+    @evented_attributes && @evented_attributes.include?(name)
+  end
+
+  def attributes
+    {}.tap do |atts|
+      if @evented_attributes
+        @evented_attributes.each do |name|
+          atts[name] = self.send name
+        end
+      end
+    end
+  end
+
+  def self.included(klass)
+    klass.instance_eval do
+      include Kvo
+      def has_attribute(name)
+        kvo_attr_accessor name
+      end
+    end
+
+  end
+
+end

data/lib/gamebox/lib/min_max_helpers.rb

@@ -0,0 +1,10 @@
+module MinMaxHelpers
+  def min(a,b)
+    a < b ? a : b
+  end
+  def max(a,b)
+    a > b ? a : b
+  end
+
+end
+

data/lib/gamebox/lib/rect.rb

@@ -68,6 +68,7 @@
 # In Rubygame, Rects are used for collision detection and describing 
 # the area of a Surface to operate on.
 class Rect < Array
+  include MinMaxHelpers
 
   #--
   # GENERAL
@@ -142,20 +143,12 @@ class Rect < Array
   def inspect; "#<Rect:#{self.object_id} [%s,%s,%s,%s]>"%self; end
 
 
-  # Returns an SDL::Rect version of this Rect. Float values are
-  # rounded to the nearest integer.
-  # 
-  def to_sdl                    # :nodoc:
-    SDL::Rect.new( self.collect{|n| n.round } )
-  end
-
-
   #--
   # ATTRIBUTES
   #++
 
-  # Returns self.at(0)
-  def x; return self.at(0); end
+  # Returns self[0]
+  def x; return self[0]; end
   # Sets self[0] to +val+
   def x=(val); self[0] = val; end
 
@@ -164,8 +157,8 @@ class Rect < Array
   alias l x
   alias l= x=;
 
-  # Returns self.at(1)
-  def y; return self.at(1); end
+  # Returns self[1]
+  def y; return self[1]; end
   # Sets self[1] to +val+
   def y=(val); self[1] = val; end
 
@@ -174,16 +167,16 @@ class Rect < Array
   alias t y
   alias t= y=;
 
-  # Returns self.at(2)
-  def w; return self.at(2); end
+  # Returns self[2]
+  def w; return self[2]; end
   # Sets self[2] to +val+
   def w=(val); self[2] = val; end
 
   alias width w
   alias width= w=;
 
-  # Returns self.at(3)
-  def h; return self.at(3); end
+  # Returns self[3]
+  def h; return self[3]; end
   # Sets self[3] to +val+
   def h=(val); self[3] = val; end
 
@@ -201,21 +194,21 @@ class Rect < Array
   end
 
   # Return the x coordinate of the right side of the Rect.
-  def right; return self.at(0)+self.at(2); end
+  def right; return self[0]+self[2]; end
 
   # Set the x coordinate of the right side of the Rect by translating the
   # Rect (adjusting the x offset).
-  def right=(r); self[0] = r - self.at(2); return r; end
+  def right=(r); self[0] = r - self[2]; return r; end
 
   alias r right
   alias r= right=;
 
   # Return the y coordinate of the bottom side of the Rect.
-  def bottom; return self.at(1)+self.at(3); end
+  def bottom; return self[1]+self[3]; end
 
   # Set the y coordinate of the bottom side of the Rect by translating the
   # Rect (adjusting the y offset).
-  def bottom=(b); self[1] = b - self.at(3); return b; end
+  def bottom=(b); self[1] = b - self[3]; return b; end
 
   alias b bottom
   alias b= bottom=;
@@ -234,21 +227,21 @@ class Rect < Array
   alias c= center=;
 
   # Return the x coordinate of the center of the Rect
-  def centerx; return self.at(0)+(self.at(2).div(2)); end
+  def centerx; return self[0]+(self[2].div(2)); end
 
   # Set the x coordinate of the center of the Rect by translating the
   # Rect (adjusting the x offset).
-  def centerx=(x); self[0] = x - (self.at(2).div(2)); return x; end
+  def centerx=(x); self[0] = x - (self[2].div(2)); return x; end
 
   alias cx centerx
   alias cx= centerx=;
 
   # Return the y coordinate of the center of the Rect
-  def centery; return self.at(1)+(self.at(3).div(2)); end
+  def centery; return self[1]+(self[3].div(2)); end
 
   # Set the y coordinate of the center of the Rect by translating the
   # Rect (adjusting the y offset).
-  def centery=(y); self[1] = y- (self.at(3).div(2)); return y; end
+  def centery=(y); self[1] = y- (self[3].div(2)); return y; end
 
   alias cy centery
   alias cy= centery=;
@@ -268,7 +261,7 @@ class Rect < Array
   alias tl= topleft=;
 
   # Return the x and y coordinates of the top-right corner of the Rect
-  def topright; return self.right, self.at(1); end
+  def topright; return self.right, self[1]; end
 
   # Set the x and y coordinates of the top-right corner of the Rect by 
   # translating the Rect (adjusting the x and y offsets).
@@ -282,7 +275,7 @@ class Rect < Array
   alias tr= topright=;
 
   # Return the x and y coordinates of the bottom-left corner of the Rect
-  def bottomleft; return self.at(0), self.bottom; end
+  def bottomleft; return self[0], self.bottom; end
 
   # Set the x and y coordinates of the bottom-left corner of the Rect by 
   # translating the Rect (adjusting the x and y offsets).
@@ -311,7 +304,7 @@ class Rect < Array
 
   # Return the x and y coordinates of the midpoint on the left side of the
   # Rect.
-  def midleft; return self.at(0), self.centery; end  
+  def midleft; return self[0], self.centery; end  
 
   # Set the x and y coordinates of the midpoint on the left side of the Rect
   # by translating the Rect (adjusting the x and y offsets).
@@ -326,7 +319,7 @@ class Rect < Array
 
   # Return the x and y coordinates of the midpoint on the left side of the
   # Rect.
-  def midtop; return self.centerx, self.at(1); end  
+  def midtop; return self.centerx, self[1]; end  
 
   # Set the x and y coordinates of the midpoint on the top side of the Rect
   # by translating the Rect (adjusting the x and y offsets).
@@ -389,31 +382,31 @@ class Rect < Array
     unless rect.contain?(nself)
 
       #If self is too wide:
-      if nself.at(2) >= rect.at(2)
-        self[0] = rect.centerx - nself.at(2).div(2)
+      if nself[2] >= rect[2]
+        self[0] = rect.centerx - nself[2].div(2)
         #Else self is not too wide
       else
         #If self is to the left of arg
-        if nself.at(0) < rect.at(0)
-          self[0] = rect.at(0)
+        if nself[0] < rect[0]
+          self[0] = rect[0]
         #If self is to the right of arg
         elsif nself.right > rect.right
-          self[0] = rect.right - nself.at(2)
+          self[0] = rect.right - nself[2]
         #Otherwise, leave x alone
         end
       end
 
       #If self is too tall:
-      if nself.at(3) >= rect.at(3)
-        self[1] = rect.centery - nself.at(3).div(2)
+      if nself[3] >= rect[3]
+        self[1] = rect.centery - nself[3].div(2)
         #Else self is not too tall
       else
         #If self is above arg
-        if nself.at(1) < rect.at(1)
-          self[1] = rect.at(1)
+        if nself[1] < rect[1]
+          self[1] = rect[1]
         #If self below arg
         elsif nself.bottom > rect.bottom
-          self[1] = rect.bottom - nself.at(3)
+          self[1] = rect.bottom - nself[3]
         #Otherwise, leave y alone
         end
       end
@@ -435,10 +428,10 @@ class Rect < Array
     nself = self.normalize
     other = Rect.new_from_object(rect).normalize!
     if self.collide_rect?(other)
-      self[0] = [nself.at(0), other.at(0)].max
-      self[1] = [nself.at(1), other.at(1)].max
-      self[2] = [nself.right, other.right].min - self.at(0)
-      self[3] = [nself.bottom, other.bottom].min - self.at(1)
+      self[0] = [nself[0], other[0]].max
+      self[1] = [nself[1], other[1]].max
+      self[2] = [nself.right, other.right].min - self[0]
+      self[3] = [nself.bottom, other.bottom].min - self[1]
     else #if they do not intersect at all:
       self[0], self[1] = nself.topleft
       self[2], self[3] = 0, 0
@@ -505,8 +498,8 @@ class Rect < Array
 
   # True if the caller and the given Rect overlap (or touch) at all.
   def collide_rect?(rect)
-    nself = self.normalize
-    rect  = Rect.new_from_object(rect).normalize!
+    nself = self #.normalize
+    rect  = Rect.new_from_object(rect)#.normalize!
     return ((nself.l >= rect.l && nself.l <= rect.r) or (rect.l >= nself.l && rect.l <= nself.r)) &&
            ((nself.t >= rect.t && nself.t <= rect.b) or (rect.t >= nself.t && rect.t <= nself.b))
   end
@@ -514,18 +507,18 @@ class Rect < Array
   # True if the given Rect is totally within the caller. Borders may
   # overlap.
   def contain?(rect)
-    nself = self.normalize
-    rect = Rect.new_from_object(rect).normalize!
+    nself = self#.normalize
+    rect = Rect.new_from_object(rect)#.normalize!
     return (nself.left <= rect.left and rect.right <= nself.right and
           nself.top <= rect.top and rect.bottom <= nself.bottom)
   end
 
   # As #inflate!, but the original caller is not changed.
   def inflate(x,y)
-    return self.class.new(self.at(0) - x.div(2),
-                          self.at(1) - y.div(2),
-                          self.at(2) + x,
-                          self.at(3) + y)
+    return self.class.new(self[0] - x.div(2),
+                          self[1] - y.div(2),
+                          self[2] + x,
+                          self[3] + y)
   end
 
   # Increase the Rect's size is the x and y directions, while keeping the
@@ -561,11 +554,11 @@ class Rect < Array
   # area it represents. Has no effect on Rects with non-negative width
   # and height. Some Rect methods will automatically normalize the Rect.
   def normalize!
-    if self.at(2) < 0
-      self[0], self[2] = self.at(0)+self.at(2), -self.at(2)
+    if self[2] < 0
+      self[0], self[2] = self[0]+self[2], -self[2]
     end
-    if self.at(3) < 0
-      self[1], self[3] = self.at(1)+self.at(3), -self.at(3)
+    if self[3] < 0
+      self[1], self[3] = self[1]+self[3], -self[3]
     end
     self
   end
@@ -606,6 +599,71 @@ class Rect < Array
     return self
   end
 
+  # calculate the area of the Rect
+  def area
+    w * h
+  end
+
+  def zero_out!
+    self[0] = 0
+    self[1] = 0
+    self[2] = 0
+    self[3] = 0
+  end
+
+  def union_area(rect)
+    rleft = self.left
+    rtop = self.top
+    rright = self.right
+    rbottom = self.bottom
+    r2 = Rect.new_from_object(rect)
+
+    rleft = min(rleft, r2.left)
+    rtop = min(rtop, r2.top)
+    rright = max(rright, r2.right)
+    rbottom = max(rbottom, r2.bottom)
+
+    (rright - rleft) * (rbottom - rtop)
+  end
+
+  def union_fast(rect)
+    rleft = self.left
+    rtop = self.top
+    rright = self.right
+    rbottom = self.bottom
+    r2 = Rect.new_from_object(rect)
+
+    rleft = min(rleft, r2.left)
+    rtop = min(rtop, r2.top)
+    rright = max(rright, r2.right)
+    rbottom = max(rbottom, r2.bottom)
+
+    Rect.new(rleft, rtop, rright - rleft, rbottom - rtop)
+  end
+
+  def expand_to_include!(rect)
+    rleft = self.left
+    rtop = self.top
+    rright = self.right
+    rbottom = self.bottom
+    r2 = Rect.new_from_object(rect)
+
+    rleft = min(rleft, r2.left)
+    rtop = min(rtop, r2.top)
+    rright = max(rright, r2.right)
+    rbottom = max(rbottom, r2.bottom)
+
+    self.x = rleft
+    self.y = rtop
+    self.w = rright - rleft
+    self.h = rbottom - rtop
+  end
+
+  def refit_for!(rect_a, rect_b)
+    self.zero_out!
+    self.expand_to_include! rect_a
+    self.expand_to_include! rect_b
+  end
 
 end # class Rect