gamebox 0.1.1 → 0.2.1

data/lib/gamebox/physical_stage.rb

@@ -14,7 +14,7 @@ class PhysicalStage < Stage
   end
   
   def setup_space
-    @space = Space.new
+    @space = CP::Space.new
     @space.iterations = 20
     @space.elastic_iterations = 5
   end
@@ -44,7 +44,7 @@ class PhysicalStage < Stage
   end
 
   def update(time)
-    update_physics time
+    update_physics time 
     super
   end
 
@@ -97,4 +97,14 @@ class PhysicalStage < Stage
     end
   end
 
+  def pause
+    pause_physics
+    super
+  end
+
+  def unpause
+    super
+    restart_physics
+  end
+
 end

data/lib/gamebox/physics.rb

@@ -1,10 +1,21 @@
 require 'chipmunk'
 
-#require 'numbers_ext'
-include CP
+
+def vec2(*args)
+  CP::Vec2.new *args
+end
+
+def moment_for_circle(*args)
+  CP.moment_for_circle(*args)
+end
+
+def moment_for_poly(*args)
+  CP.moment_for_poly(*args)
+end
+
 ZERO_VEC_2 = vec2(0,0)
 
-class Space
+class CP::Space
   alias :add_collision_func_old :add_collision_func
   
   # allows for passing arrays of collision types not just single ones

data/lib/gamebox/resource_manager.rb

@@ -5,10 +5,14 @@ require 'inflector'
 require 'svg_document'
 
 class ResourceManager
-  def initialize
+
+  constructor :wrapped_screen
+
+  def setup
     @loaded_images = {}
     @loaded_fonts = {}
     @loaded_svgs = {}
+    @window = @wrapped_screen.screen
   end
 
   def load_actor_image(actor)
@@ -42,40 +46,21 @@ class ResourceManager
   #
   def load_tile_set(actor, action)
     actor_dir = Inflector.underscore(actor.class)
-    tileset = load_image "#{actor_dir}/#{action}.png"
+    tileset_name = "#{actor_dir}/#{action}.png"
+    tileset = load_image tileset_name
 
     action_imgs = []
-    w,h = *tileset.size
-    color = tileset.get_at 0, 0
+    w = tileset.width
+    h = tileset.height
 
     if h > w
       # down
       num_frames = h/w
-      clip_from = Rubygame::Rect.new(0, 0, w, w)
-      clip_to = Rubygame::Rect.new(0, 0, w, w)
-      num_frames.times do
-        surface = Rubygame::Surface.new(clip_to.size)
-        surface.fill color
-        tileset.blit surface, clip_to, clip_from
-        surface.set_colorkey color
-        surface = surface.to_display_alpha
-        action_imgs << surface
-        clip_from.y += w
-      end
+      action_imgs = Image.load_tiles @window, GFX_PATH+tileset_name, -1, -num_frames, true
     else
       # right
       num_frames = w/h
-      clip_from = Rubygame::Rect.new(0, 0, h, h)
-      clip_to = Rubygame::Rect.new(0, 0, h, h)
-      num_frames.times do
-        surface = Rubygame::Surface.new(clip_to.size)
-        surface.fill color
-        tileset.blit surface, clip_to, clip_from
-        surface.set_colorkey color
-        surface = surface.to_display_alpha
-        action_imgs << surface
-        clip_from.x += h
-      end
+      action_imgs = Image.load_tiles @window, GFX_PATH+tileset_name, -num_frames, -1, true
     end
 
     action_imgs
@@ -100,12 +85,14 @@ class ResourceManager
     cached_img = @loaded_images[file_name]
     if cached_img.nil?
       begin
-        #cached_img = Rubygame::Surface.load(File.expand_path(GFX_PATH + file_name))
-        cached_img = Rubygame::Surface.load(GFX_PATH + file_name)
+        full_name = GFX_PATH + file_name
+        if ! File.exist? full_name
+          #check global gamebox location
+          full_name = GAMEBOX_GFX_PATH + file_name
+        end
+        cached_img = Image.new(@window, full_name)
       rescue Exception => ex
-        #check global gamebox location
-        #cached_img = Rubygame::Surface.load(File.expand_path(GAMEBOX_GFX_PATH + file_name))
-        cached_img = Rubygame::Surface.load(GAMEBOX_GFX_PATH + file_name)
+        puts "Cannot load image #{file_name}"
       end
       @loaded_images[file_name] = cached_img
     end
@@ -114,40 +101,36 @@ class ResourceManager
 
   def load_music(full_name)
     begin
-      sound = Rubygame::Music.load(full_name)
-      return sound
-    rescue Rubygame::SDLError => ex
+      music = Song.new(@window, full_name)
+      return music
+    rescue Excpetion => ex
       puts "Cannot load music " + full_name + " : " + ex
     end
   end
 
   def load_sound(full_name)
     begin
-      sound = Rubygame::Sound.load(full_name)
+      sound = Sample.new(@window, full_name)
       return sound
-    rescue Rubygame::SDLError => ex
+    rescue Excpetion => ex
       puts "Cannot load sound " + full_name + " : " + ex
     end
   end
 
-  # loads TTF fonts from the fonts dir and caches them for later
+  # loads fonts from the fonts dir and caches them for later
   def load_font(name, size)
     @loaded_fonts[name] ||= {}
     return @loaded_fonts[name][size] if @loaded_fonts[name][size]
     begin
-      unless @ttf_loaded
-        TTF.setup
-        @ttf_loaded = true
-      end
       #full_name = File.expand_path(FONTS_PATH + name)
       full_name = FONTS_PATH + name
-      begin
-        font = TTF.new(full_name, size)
+      if File.exist? full_name
+        font = Font.new(@window, full_name, size)
         @loaded_fonts[name][size] = font
-      rescue Exception => ex
+      else
         #full_name = File.expand_path(GAMEBOX_FONTS_PATH + name)
         full_name = GAMEBOX_FONTS_PATH + name
-        font = TTF.new(full_name, size)
+        font = Font.new(@window, full_name, size)
         @loaded_fonts[name][size] = font
       end
       return font
@@ -157,26 +140,6 @@ class ResourceManager
     return nil
   end
 
-  # TODO make this path include that app name?
-  def load_config(name)
-    conf = YAML::load_file(CONFIG_PATH + name + ".yml")
-    user_file = "#{ENV['HOME']}/.gamebox/#{name}.yml"
-    if File.exist? user_file
-      user_conf = YAML::load_file user_file
-      conf = conf.merge user_conf
-    end
-    conf
-  end
-
-  def save_settings(name, settings)
-    user_gamebox_dir = "#{ENV['HOME']}/.gamebox"
-    FileUtils.mkdir_p user_gamebox_dir
-    user_file = "#{ENV['HOME']}/.gamebox/#{name}.yml"
-    File.open user_file, "w" do |f|
-      f.write settings.to_yaml
-    end
-  end
-
   def load_svg(file_name)
     # TODO create LEVEL_PATH in environment
     cached_svg = @loaded_svgs[file_name]

data/lib/gamebox/sound_manager.rb

@@ -9,9 +9,8 @@ class SoundManager
   # checks to see if sdl_mixer is availalbe and preloads the sounds and music directories. 
   def setup
 
-    puts 'Warning, sound disabled' unless
-      (@enabled = (Rubygame::VERSIONS[:sdl_mixer] != nil))
-    @enabled = (@enabled and (@config_manager.settings[:sound].nil? or @config_manager.settings[:sound] == true))
+    puts 'CHANGE TO LOG:Warning, sound disabled' unless
+    @enabled = (@config_manager.settings[:sound].nil? or @config_manager.settings[:sound] == true)
 
     if @enabled
       @music = {}
@@ -50,11 +49,7 @@ class SoundManager
   # play_sound :foo # play sound at 100% volume
   def play_sound(what, opts={})
     if @enabled && @sounds[what]
-      volume = opts.delete :volume
-      @sound_thread = Thread.new do
-        @sounds[what].volume = volume if volume
-        @sounds[what].play opts
-      end
+      @sounds[what].play #opts
     end
   end
 
@@ -64,11 +59,10 @@ class SoundManager
   def play_music(what, opts={})
     if @enabled && @music[what]
       volume = opts.delete :volume
-      opts[:repeats] = -1 unless opts[:repeat]
-      @music_thread = Thread.new do
-        @music[what].volume = volume if volume
-        @music[what].play opts
-      end
+      repeat = opts[:repeat]
+      repeat ||= false
+      @music[what].volume = volume if volume
+      @music[what].play repeat
     end
   end
 

data/lib/gamebox/spatial_hash.rb

@@ -1,11 +1,15 @@
 class SpatialHash
 
-  attr_reader :cell_size
+  attr_reader :cell_size, :buckets 
+  attr_accessor :auto_resize
 
-  def initialize(cell_size)
+  def initialize(cell_size, resize = false)
     @cell_size = cell_size.to_f
-    @buckets = {}
-    @items = []
+    @items = {}
+    @total_w = 0
+    @total_h = 0
+    @auto_resize = resize
+    rehash
   end
 
   def cell_size=(new_size)
@@ -15,9 +19,22 @@ class SpatialHash
 
   def rehash
     items = @items
-    @items = []
+
+    if @auto_resize
+      # recommeded cell size == 2 x avg obj size
+      if @total_w > 0 && items.size > 0
+        avg_w = @total_w / items.size
+        avg_h = @total_h / items.size
+
+        @cell_size = (avg_w+avg_h)
+      end
+    end
+
+    @total_w = 0
+    @total_h = 0
+    @items = {}
     @buckets = {}
-    items.each do |item|
+    items.values.each do |item|
       add item
     end
   end
@@ -29,10 +46,14 @@ class SpatialHash
       @buckets[x] ||= {}
       @buckets[x][y] ||= []
       target_bucket = @buckets[x][y]
-      unless target_bucket.include? item
-        target_bucket << item 
-        @items << item
-      end
+      target_bucket << item 
+      @items[item] = item
+      w = item.width if item.respond_to? :width
+      h = item.height if item.respond_to? :height
+      w ||= 1
+      h ||= 1
+      @total_w += w 
+      @total_h += h 
     end
   end
 
@@ -55,8 +76,9 @@ class SpatialHash
 
     buckets = []
     (max_x-min_x+1).times do |i|
+      bucket_x = min_x + i
       (max_y-min_y+1).times do |j|
-        buckets << [min_x+i,min_y+j] 
+        buckets << [bucket_x,min_y+j] 
       end
     end
 
@@ -100,18 +122,42 @@ class SpatialHash
       max_x, max_y = bucket_for x+w-1, y+h-1
     end
 
+    items_in_bucket_range min_x, min_y, max_x, max_y
+  end
+
+  def items_in_bucket_range(min_x,min_y,max_x,max_y)
     items = []
     (max_x-min_x+1).times do |i|
+      bucket_x = min_x + i
+      x_bucket = @buckets[bucket_x]
+      have_bucket_x = x_bucket.nil?
+
       (max_y-min_y+1).times do |j|
-        bucket_x = min_x + i
         bucket_y = min_y + j
-        unless @buckets[bucket_x].nil? || @buckets[bucket_x][bucket_y].nil?
-          items << @buckets[bucket_x][bucket_y]
+        unless have_bucket_x || x_bucket[bucket_y].nil?
+          items << x_bucket[bucket_y]
         end
       end
     end
     items.flatten.uniq
   end
 
+  # will look dist number of cells around all the cells
+  # occupied by the item
+  def neighbors_of(item, dist=1)
+    buckets = lookup(item)
+    min_bucket_x, min_bucket_y = *buckets.first
+    max_bucket_x, max_bucket_y = *buckets.last
+
+    min_bucket_x = min_bucket_x-1
+    min_bucket_y = min_bucket_y-1
+
+    max_bucket_x = max_bucket_x+1
+    max_bucket_y = max_bucket_y+1
+
+    items = items_in_bucket_range min_bucket_x, min_bucket_y, max_bucket_x, max_bucket_y
+    items-[item]
+  end
+
 end
 

data/lib/gamebox/spatial_stagehand.rb

@@ -14,8 +14,23 @@ class SpatialStagehand < Stagehand
     @spatial_actors.cell_size
   end
 
+  def cell_size=(new_size)
+    @spatial_actors.cell_size = new_size
+  end
+
+  def auto_resize=(val)
+    @spatial_actors.auto_resize = val
+  end
+
+  def buckets
+    @spatial_actors.buckets
+  end
+
   def add(actor)
     @spatial_actors.add actor
+    actor.when :remove_me do 
+      @spatial_actors.remove actor
+    end
   end
 
   def remove(actor)
@@ -34,4 +49,8 @@ class SpatialStagehand < Stagehand
     @spatial_actors.items_in x, y, w, h
   end
 
+  def neighbors_of(item, dist=1)
+    @spatial_actors.neighbors_of item, dist
+  end
+
 end

data/lib/gamebox/stage.rb

@@ -101,6 +101,7 @@ class Stage
   end
 
   def draw(target)
+    z = 0
     @drawables.keys.sort.reverse.each do |parallax_layer|
 
       drawables_on_parallax_layer = @drawables[parallax_layer]
@@ -111,8 +112,14 @@ class Stage
           trans_x = @viewport.x_offset parallax_layer
           trans_y = @viewport.y_offset parallax_layer
 
+          z += 1
           drawables_on_parallax_layer[layer].each do |drawable|
-            drawable.draw target, trans_x, trans_y 
+            begin
+              drawable.draw target, trans_x, trans_y, z
+            rescue Exception => ex
+              p drawable.class
+              p ex
+            end
           end
         end
       end
@@ -192,7 +199,13 @@ class Stage
     @unpause_listeners << block if block_given?
   end
 
+  def paused?
+    @pause
+  end
+
   def pause
+    @pause_listeners ||= []
+    @paused = true
     @director.pause
     @input_manager.pause
     @paused_timers = @timers
@@ -203,6 +216,7 @@ class Stage
   end
 
   def unpause
+    @unpause_listeners ||= []
     @director.unpause
     @input_manager.unpause
     @timers = @paused_timers
@@ -210,6 +224,7 @@ class Stage
     @unpause_listeners.each do |listener|
       listener.call
     end
+    @paused = true
   end
 
   def stagehand(stagehand_sym, opts={})