gamebox 0.3.4 → 0.4.0.rc1

data/lib/gamebox/{physical_stage.rb → core/physics_manager.rb}

@@ -1,28 +1,15 @@
-# Stage represent on level of game play.  Some games will likely have only one
-# stage. Stage is responsible for loading its background, props, and directors.
-# PhysicalStage adds a physics space to the Stage
+# PhysicsManager creates and manages chipmunks space.
+class PhysicsManager
+  extend Forwardable
+  def_delegators :@space, :elastic_iterations=, :damping=, :gravity=
 
-
-
-class PhysicalStage < Stage
-  
   attr_accessor :space
-
-  def setup
-    super
-    setup_space
-  end
-  
-  def setup_space
+  def configure
     @space = CP::Space.new
     @space.iterations = 20
     @space.elastic_iterations = 5
   end
 
-  def create_director
-    PhysicalDirector.new
-  end
-
   PHYSICS_STEP = 25.0
   def update_physics(time)
     unless @physics_paused
@@ -45,10 +32,32 @@ class PhysicalStage < Stage
 
   def update(time)
     update_physics time 
-    super
+  end
+
+  # allows for passing arrays of collision types not just single ones
+  # add_collision_func([:foo,:bar], [:baz,:yar]) becomes:
+  # add_collision_func(:foo, :baz)
+  # add_collision_func(:foo, :yar)
+  # add_collision_func(:bar, :baz)
+  # add_collision_func(:bar, :yar)
+  def add_collision_func(first_objs, second_objs, &block)
+    firsts = [first_objs].flatten
+    seconds = [second_objs].flatten
+    
+    firsts.each do |f|
+      seconds.each do |s|
+        @space.add_collision_func(f,s) do |a, b|
+          block.call a.actor, b.actor
+        end
+      end
+    end
   end
 
   def register_physical_object(obj,static=false)
+    obj.when :remove_me do
+      unregister_physical_object obj
+    end
+
     if static
       obj.shapes.each do |shape|
         @space.add_static_shape shape
@@ -72,13 +81,13 @@ class PhysicalStage < Stage
 
   def unregister_physical_object(obj,static=false)
     if static
-      obj.physical.shapes.each do |shape|
+      obj.shapes.each do |shape|
         @space.remove_static_shape shape
       end
     else
       @space.remove_body(obj.body)
       
-      obj.physical.shapes.each do |shape|
+      obj.shapes.each do |shape|
         @space.remove_shape shape
       end
     end
@@ -90,21 +99,18 @@ class PhysicalStage < Stage
   # later in the future.
   #
   # This block is called on each actor found
-  def pick(x, y, &block)
-    @space.shape_point_query(vec2(x, y)) do |found|
-      actor = @director.find_physical_obj(found)
-      block.call(actor)
-    end
-  end
+  # def pick(x, y, &block)
+  #   @space.shape_point_query(vec2(x, y)) do |found|
+  #     actor = @director.find_physical_obj(found)
+  #     block.call(actor)
+  #   end
+  # end
 
   def pause
     pause_physics
-    super
   end
 
   def unpause
-    super
     restart_physics
   end
-
 end

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

@@ -3,24 +3,23 @@ require "fileutils"
 
 class ResourceManager
 
-  constructor :wrapped_screen
+  construct_with :wrapped_screen
 
-  def setup
+  def initialize
     @loaded_images = {}
     @loaded_fonts = {}
     @loaded_svgs = {}
-    @window = @wrapped_screen.screen
+    @window = wrapped_screen.screen
   end
 
   def load_actor_image(actor)
     # use pngs only for now
-    actor_name = Inflector.underscore(actor.class)
-    return load_image("#{actor_name}.png")
+    # actor_name = Inflector.underscore(actor.class)
+    return load_image("#{actor.actor_type}.png")
   end
 
   def load_animation_set(actor, action)
-    actor_dir = Inflector.underscore(actor.class)
-    using_tileset = File.exist?("#{GFX_PATH}#{actor_dir}/#{action}.png")
+    using_tileset = File.exist?("#{Gamebox.configuration.gfx_path}#{actor.actor_type}/#{action}.png")
     if using_tileset
       load_tile_set(actor, action)
     else
@@ -53,11 +52,11 @@ class ResourceManager
     if h > w
       # down
       num_frames = h/w
-      action_imgs = Image.load_tiles @window, GFX_PATH+tileset_name, -1, -num_frames, true
+      action_imgs = Image.load_tiles @window, Gamebox.configuration.gfx_path+tileset_name, -1, -num_frames, true
     else
       # right
       num_frames = w/h
-      action_imgs = Image.load_tiles @window, GFX_PATH+tileset_name, -num_frames, -1, true
+      action_imgs = Image.load_tiles @window, Gamebox.configuration.gfx_path+tileset_name, -num_frames, -1, true
     end
 
     action_imgs
@@ -65,14 +64,13 @@ class ResourceManager
 
   def load_frame_set(actor, action)
     # use pngs only for now
-    actor_dir = Inflector.underscore(actor.class)
-    frames = Dir.glob("#{GFX_PATH}#{actor_dir}/#{action}/*.png")
+    frames = Dir.glob("#{Gamebox.configuration.gfx_path}#{actor.actor_type}/#{action}/*.png")
     action_imgs = []
 
     frames = frames.sort_by {|f| File.basename(f).to_i }
 
     for frame in frames
-      rel_path = frame.slice(GFX_PATH.size,frame.size)
+      rel_path = frame.slice(Gamebox.configuration.gfx_path.size,frame.size)
       action_imgs << load_image(rel_path)
     end
     action_imgs
@@ -82,10 +80,10 @@ class ResourceManager
     cached_img = @loaded_images[file_name]
     if cached_img.nil?
       begin
-        full_name = GFX_PATH + file_name
+        full_name = Gamebox.configuration.gfx_path + file_name
         if ! File.exist? full_name
           #check global gamebox location
-          full_name = GAMEBOX_GFX_PATH + file_name
+          full_name = Gamebox.configuration.gb_gfx_path + file_name
         end
         cached_img = Image.new(@window, full_name)
       rescue Exception => ex
@@ -116,6 +114,9 @@ class ResourceManager
 
   # loads fonts from the fonts dir and caches them for later
   def load_font(name, size)
+    config = Gamebox.configuration
+    fonts_path = config.fonts_path
+    gb_fonts_path = config.gb_fonts_path
     @loaded_fonts[name] ||= {}
     return @loaded_fonts[name][size] if @loaded_fonts[name][size]
     begin
@@ -123,19 +124,19 @@ class ResourceManager
         font = Font.new(@window, name, size)
         @loaded_fonts[name][size] = font
       else
-        full_name = FONTS_PATH + name
+        full_name = fonts_path + name
         if File.exist? full_name
           font = Font.new(@window, full_name, size)
           @loaded_fonts[name][size] = font
         else
-          full_name = GAMEBOX_FONTS_PATH + name
+          full_name = gb_fonts_path + name
           font = Font.new(@window, full_name, size)
           @loaded_fonts[name][size] = font
         end
       end
       return font
     rescue Exception => ex
-      debug "Cannot load font #{full_name}:#{ex}"
+      log "Cannot load font #{full_name}:#{ex}"
     end
     return nil
   end
@@ -152,7 +153,7 @@ class ResourceManager
   end
 
   def load_tiles(filename, tile_width, tile_height)
-    Image.load_tiles @window, GFX_PATH+filename, tile_width, tile_height, true
+    Image.load_tiles @window, Gamebox.configuration.gfx_path+filename, tile_width, tile_height, true
   end
 
 

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

@@ -4,39 +4,41 @@
 class SoundManager
   attr_accessor :sounds, :music
 
-  constructor :resource_manager, :config_manager
+  construct_with :resource_manager, :config_manager
   SUPPORTED_AUDIO_EXTS = %w(wav ogg mp3 au aiff caf)
   
   # checks to see if sdl_mixer is availalbe and preloads the sounds and music directories. 
-  def setup
+  def initialize
 
     puts 'CHANGE TO LOG:Warning, sound disabled' unless
-    @enabled = (@config_manager.settings[:sound].nil? or @config_manager.settings[:sound] == true)
+    @enabled = (config_manager.settings[:sound].nil? or config_manager.settings[:sound] == true)
 
     if @enabled
       @music = {}
-      files = Dir.glob "#{MUSIC_PATH}**.{#{SUPPORTED_AUDIO_EXTS.join(',')}}"
+      music_path = Gamebox.configuration.music_path
+      files = Dir.glob "#{music_path}**.{#{SUPPORTED_AUDIO_EXTS.join(',')}}"
       for f in files
         name = File.basename(f)
         begin
           sym = name.gsub(" ","_").split(".")[0..-2].join(".").to_sym
           ext = name.gsub(" ","_").split(".").last
           unless ext == "txt"
-            @music[sym] = @resource_manager.load_music(f)
+            @music[sym] = resource_manager.load_music(f)
           end
         rescue;end
       end if files
 
       @sounds = {}
       @playing_sounds = {}
-      files = Dir.glob "#{SOUND_PATH}**.{#{SUPPORTED_AUDIO_EXTS.join(',')}}"
+      sound_path = Gamebox.configuration.sound_path
+      files = Dir.glob "#{sound_path}**.{#{SUPPORTED_AUDIO_EXTS.join(',')}}"
       for f in files
         name = File.basename(f)
         begin
           sym = name.gsub(" ","_").split(".")[0..-2].join(".").to_sym
           ext = name.gsub(" ","_").split(".").last
           unless ext == "txt"
-            @sounds[sym] = @resource_manager.load_sound(f)
+            @sounds[sym] = resource_manager.load_sound(f)
           end
         rescue;end
       end if files

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

@@ -5,40 +5,34 @@ class Stage
   extend Publisher
   can_fire_anything
 
-  attr_accessor :drawables, :resource_manager, :sound_manager,
-    :director, :opts, :viewport, :input_manager, :backstage
+  construct_with :input_manager, :actor_factory, :resource_manager, 
+    :sound_manager, :config_manager, :director, :timer_manager, 
+    :this_object_context
 
-  def initialize(input_manager, actor_factory, resource_manager, sound_manager, config_manager, backstage, opts)
-    @input_manager = input_manager
+  def self.inherited(kid)
+    kid.construct_with *self.object_definition.component_names
+  end
 
-    @resource_manager = resource_manager
-    @sound_manager = sound_manager
+  attr_accessor :drawables, :opts, :viewport, :backstage
 
-    @config_manager = config_manager
-    res = @config_manager[:screen_resolution]
+  def configure(backstage, opts)
+    res = config_manager[:screen_resolution]
     @viewport = Viewport.new res[0], res[1]
-
-    @actor_factory = actor_factory
-    @director = create_director
-    @actor_factory.director = @director
-    @backstage = backstage
+    this_object_context[:viewport] = @viewport
 
     @stagehands = {}
+    @backstage = backstage
     @opts = opts
 
     setup
   end
 
-  def create_director
-    Director.new
-  end
-
   def setup
     clear_drawables
   end
 
   def create_actor(type, args={})
-    @actor_factory.build type, self, args
+    actor_factory.build type, args
   end
   alias :spawn :create_actor 
 
@@ -69,13 +63,13 @@ class Stage
   end
 
   def update(time)
-    @director.update time
+    director.update time
     @viewport.update time
     @stagehands.each do |name, stagehand|
       stagehand.update time 
     end
     find_collisions
-    update_timers time
+    timer_manager.update time
   end
 
   def curtain_raising(*args)
@@ -94,28 +88,18 @@ class Stage
 
   def draw(target)
     z = 0
-    # TODO PERF cache this array and invalidate when new layers come in?
     @parallax_layers.each do |parallax_layer|
-    # @drawables.keys.sort.reverse.each do |parallax_layer|
-
       drawables_on_parallax_layer = @drawables[parallax_layer]
 
       if drawables_on_parallax_layer
         @layer_orders[parallax_layer].each do |layer|
-        # drawables_on_parallax_layer.keys.sort.each do |layer|
 
           trans_x = @viewport.x_offset parallax_layer
           trans_y = @viewport.y_offset parallax_layer
 
           z += 1
           drawables_on_parallax_layer[layer].each do |drawable|
-            begin
-              drawable.draw target, trans_x, trans_y, z
-            rescue Exception => ex
-              p drawable.class
-              p ex
-              p ex.backtrace
-            end
+            drawable.draw target, trans_x, trans_y, z
           end
         end
       end
@@ -129,6 +113,7 @@ class Stage
   def clear_drawables
     @drawables = {}
     @layer_orders = {}
+    @parallax_layers = []
   end
 
   def register_drawable(drawable)
@@ -163,42 +148,6 @@ class Stage
 
   end
 
-  def remove_timer(name)
-    @timers ||= {}
-    @timers.delete name
-  end
-
-  def timer(name)
-    @timers ||= {}
-    @timers[name]
-  end
-
-  # add block to be executed every interval_ms millis
-  # TODO make this hash based on object => name => block
-  # to clean up the timed behavior
-  def add_timer(name, interval_ms, &block)
-    @new_timers ||= {}
-    @new_timers[name] = {:count => 0,
-      :interval_ms => interval_ms, :callback => block}
-  end
-
-  # update each timers counts, call any blocks that are over their interval
-  def update_timers(time_delta)
-    # TODO handle overwriting the same timer name...
-    @timers ||= {}
-    if @new_timers
-      @timers.merge!(@new_timers) 
-      @new_timers = nil
-    end
-    @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
-      end
-    end
-  end
-
   def on_pause(&block)
     @pause_listeners ||= []
     @pause_listeners << block if block_given?
@@ -216,10 +165,9 @@ class Stage
   def pause
     @pause_listeners ||= []
     @paused = true
-    @director.pause
-    @input_manager.pause
-    @paused_timers = @timers
-    @timers = nil
+    director.pause
+    timer_manager.pause
+    input_manager.pause
     @pause_listeners.each do |listener|
       listener.call
     end
@@ -227,10 +175,9 @@ class Stage
 
   def unpause
     @unpause_listeners ||= []
-    @director.unpause
-    @input_manager.unpause
-    @timers = @paused_timers
-    @paused_timers = nil
+    director.unpause
+    input_manager.unpause
+    timer_manager.unpause
     @unpause_listeners.each do |listener|
       listener.call
     end
@@ -241,15 +188,30 @@ class Stage
     @stagehands[stagehand_sym] ||= create_stagehand(stagehand_sym, opts)
   end
 
+  # pauses the current stage, creates an actor using args, unpauses on actor death
+  #
+  # Example:
+  #  modal_actor :dialog, x: 40, y: 50, message: "WOW"
+  def modal_actor(*args)
+    on_pause do
+      pause_actor = spawn *args
+      pause_actor.when :remove_me do
+        @pause_listeners = nil
+        unpause
+        yield if block_given?
+      end
+    end
+    pause
+
+  end
+
+  private
   def create_stagehand(name, opts)
     underscored_class = "#{name}_stagehand"
-    begin
-      require underscored_class
-    rescue LoadError
-      # TODO log this?
-    end
     klass = ClassFinder.find underscored_class
     klass.new self, opts
   end
+
+
 end