gamebox 0.3.2 → 0.3.3

data/Gemfile

@@ -1,2 +1,3 @@
 source "http://rubygems.org"
 gemspec
+# gem 'perftools.rb', :git => 'git://github.com/bearded/perftools.rb.git', :branch => 'perftools-1.8'

data/gamebox.gemspec

@@ -25,12 +25,9 @@ Gem::Specification.new do |s|
   s.add_dependency "tween"
   s.add_dependency "require_all"
   s.add_dependency "kvo"
-  s.add_dependency "pry", '0.9.6'
-  s.add_dependency "pry-remote"
-
-  # TODO make this optional
-  s.add_dependency "chipmunk"
 
+  s.add_development_dependency "pry", '~>0.9.7'
+  s.add_development_dependency "pry-remote"
   s.add_development_dependency "rspec-core"
   s.add_development_dependency "rspec-mocks"
   s.add_development_dependency "rspec-expectations"
@@ -38,7 +35,6 @@ Gem::Specification.new do |s|
   s.add_development_dependency "rspec"
   s.add_development_dependency "rake"
   s.add_development_dependency "polaris"
-  s.add_development_dependency 'rcov'
 
 end
 

data/lib/gamebox.rb

@@ -1,5 +1,4 @@
 GAMEBOX_PATH = File.join(File.dirname(__FILE__),"gamebox/")
-require 'chipmunk'
 require 'diy'
 require 'constructor'
 require 'kvo'
@@ -16,5 +15,10 @@ def log(output, level = :debug)
   puts "[#{t.min}:#{t.sec}:#{t.usec}] [#{level}] #{output}"
 end
 
+begin
+  require 'chipmunk'
+rescue LoadError
+end
+
 require 'require_all'
 require_all Dir.glob("#{GAMEBOX_PATH}/**/*.rb").reject { |f| f.match("template_app") || f.match("spec") || f.match("gamebox_application.rb")}

data/lib/gamebox/actors/collidable_debugger.rb

@@ -16,19 +16,19 @@ end
 class CollidableDebuggerView < ActorView
 
   def setup
-    @color = Color[:white]
+    @color = Color::WHITE
   end
 
-  def draw(target,x_off,y_off)
+  def draw(target,x_off,y_off,z)
     collider = @actor.actor
     case collider.collidable_shape
     when :circle
-      target.draw_circle [x_off+collider.center_x, y_off+collider.center_y], collider.radius, @color
+      target.draw_circle x_off+collider.center_x, y_off+collider.center_y, collider.radius, @color, z
     else
       collider.cw_world_lines.each do |line|
         f = line.first
         l = line.last
-        target.draw_line [x_off+f[0],y_off+f[1]],[x_off+l[0],y_off+l[1]], @color
+        target.draw_line x_off+f[0],y_off+f[1],x_off+l[0],y_off+l[1], @color, z
       end
     end
   end

data/lib/gamebox/actors/fps.rb

@@ -1,23 +1,8 @@
-class FpsView < ActorView
-  def draw(target,x_off,y_off)
-    text = @actor.fps.to_s
-    text = '0'*(6-text.size)+text if text.size < 6
+class FpsView < LabelView; end
+class Fps < Label
 
-    font = @stage.resource_manager.load_font 'Asimov.ttf', 30
-    text_image = font.render text, true, [250,250,250,255]
-
-    x = @actor.x
-    y = @actor.y
-
-    text_image.blit target.screen, [x,y]
-  end
-end
-class Fps < Actor
-
-  has_behavior :layered => {:layer => 999}
-
-  def fps
-    input_manager.current_framerate.round
+  def text
+    fps
   end
 
 end

data/lib/gamebox/arbiter.rb

@@ -130,18 +130,13 @@ module Arbiter
   end
 
   def collide_circle_circle?(object, other)
-    x = object.center_x
-    y = object.center_y
-    x_prime = other.center_x
-    y_prime = other.center_y
-
-    x_delta = x_prime - x
+    x_delta = other.center_x - object.center_x
     x_dist  = x_delta * x_delta
-    y_delta = y_prime - y
+    y_delta = other.center_y - object.center_y
     y_dist  = y_delta * y_delta
 
     total_radius = object.radius + other.radius
-    x_dist + y_dist <= (total_radius * total_radius)
+    (x_dist + y_dist) <= (total_radius * total_radius)
   end
 
   # Idea from:

data/lib/gamebox/behaviors/physical.rb

@@ -86,14 +86,14 @@ class Physical < Behavior
     when :circle
       @radius = @opts[:radius]
 
-      @moment_of_inertia ||= @opts[:fixed] ? Float::INFINITY : moment_for_circle(@mass, @radius, 0, ZERO_VEC_2)
+      @moment_of_inertia ||= @opts[:fixed] ? Float::INFINITY : CP::moment_for_circle(@mass, @radius, 0, ZERO_VEC_2)
       @body = CP::Body.new(@mass, @moment_of_inertia)
       @shape = CP::Shape::Circle.new(@body, @radius, ZERO_VEC_2)
 
     when :poly
       shape_array = @opts[:verts].collect{|v| vec2(v[0],v[1])}
 
-      @moment_of_inertia ||= @opts[:fixed] ? Float::INFINITY : moment_for_poly(@mass, shape_array, ZERO_VEC_2)
+      @moment_of_inertia ||= @opts[:fixed] ? Float::INFINITY : CP::moment_for_poly(@mass, shape_array, ZERO_VEC_2)
       @body = CP::Body.new(@mass, @moment_of_inertia)
       @shape = CP::Shape::Poly.new(@body, shape_array, ZERO_VEC_2)
       verts = @opts[:verts].dup

data/lib/gamebox/input_manager.rb

@@ -51,19 +51,22 @@ class InputManager
     @window.when :button_down do |button_id|
       _handle_event button_id, :down
     end
+
     @window.when :update do |millis|
 
-      @last_mouse_x ||= mouse_x
-      @last_mouse_y ||= mouse_y
+      if @uses_mouse
+        @last_mouse_x ||= mouse_x
+        @last_mouse_y ||= mouse_y
 
-      x_diff = @last_mouse_x - mouse_x
-      y_diff = @last_mouse_y - mouse_y
+        x_diff = @last_mouse_x - mouse_x
+        y_diff = @last_mouse_y - mouse_y
 
-      unless x_diff < 0.1 && x_diff > -0.1 && y_diff < 0.1 && y_diff > -0.1
-        _handle_event nil, :motion
+        unless x_diff < 0.1 && x_diff > -0.1 && y_diff < 0.1 && y_diff > -0.1
+          _handle_event nil, :motion
 
-        @last_mouse_x = mouse_x
-        @last_mouse_y = mouse_y
+          @last_mouse_x = mouse_x
+          @last_mouse_y = mouse_y
+        end
       end
 
       game.update millis
@@ -112,21 +115,21 @@ class InputManager
       event_type = :game_pad
     end
 
-    event = {
-      :type => event_type, 
-      :id => gosu_id,
-      :action => action,
-      :callback_key => callback_key,
-      :data => event_data
-    }
+    # single threaded.. keep same event
+    @event ||= {}
+    @event[:type] = event_type
+    @event[:id] = gosu_id
+    @event[:action] = action
+    @event[:callback_key] = callback_key
+    @event[:data] = event_data
 
-    fire_event(event)
+    fire_event(@event)
 
     if mouse_dragged
       drag_data = {:to => [mouse_x, mouse_y], :from => [@last_click_x, @last_click_y]}
-      event[:data] = drag_data
-      event[:callback_key] = :mouse_drag
-      fire_event(event)
+      @event[:data] = drag_data
+      @event[:callback_key] = :mouse_drag
+      fire_event(@event)
     end
   end
 
@@ -178,11 +181,13 @@ class InputManager
     return unless block_given?
     @hooks[event_class] ||= {}
     for event_id in event_ids
+      @uses_mouse = true if event_id >= MsRangeBegin && event_id <= MsRangeEnd
       @hooks[event_class][event_id] ||= []
       @hooks[event_class][event_id] << block
     end
     @non_id_hooks[event_class] ||= []
     if event_ids.empty?
+      @uses_mouse = true
       @non_id_hooks[event_class] << block
     end
     if listener.respond_to?(:can_fire?) && listener.can_fire?(:remove_me)

data/lib/gamebox/physics.rb

@@ -1,35 +1,32 @@
-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)
+if defined? CP
+  ZERO_VEC_2 = vec2(0,0)
+  def vec2(*args)
+    CP::Vec2.new *args
+  end
 
-class CP::Space
-  alias :add_collision_func_old :add_collision_func
-  
-  # 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
+  class CP::Space
+    alias :add_collision_func_old :add_collision_func
     
-    firsts.each do |f|
-      seconds.each do |s|
-        add_collision_func_old(f,s,&block)
+    # 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|
+          add_collision_func_old(f,s,&block)
+        end
       end
     end
   end
-
+else
+  ZERO_VEC_2 = Ftor.new(0,0)
+  def vec2(*args)
+    Ftor.new *args
+  end
 end

data/lib/gamebox/resource_manager.rb

@@ -89,7 +89,7 @@ class ResourceManager
         end
         cached_img = Image.new(@window, full_name)
       rescue Exception => ex
-        log "Cannot load image #{file_name}", :warn
+        # log "Cannot load image #{file_name}", :warn
       end
       @loaded_images[file_name] = cached_img
     end

data/lib/gamebox/sound_manager.rb

@@ -28,6 +28,7 @@ class SoundManager
       end if files
 
       @sounds = {}
+      @playing_sounds = {}
       files = Dir.glob "#{SOUND_PATH}**.{#{SUPPORTED_AUDIO_EXTS.join(',')}}"
       for f in files
         name = File.basename(f)
@@ -50,7 +51,8 @@ class SoundManager
   # play_sound :foo # play sound at 100% volume
   def play_sound(what, opts={})
     if @enabled && @sounds[what]
-      @sounds[what].play #opts
+      merged_opts = {volume:1, speed:1, looping:false}.merge opts
+      @playing_sounds[what] = @sounds[what].play merged_opts[:volume], merged_opts[:speed], merged_opts[:looping]
     end
   end
 
@@ -79,7 +81,7 @@ class SoundManager
   # stop_sound :foo
   def stop_sound(what)
     if @enabled
-      @sounds[what].stop if @sounds[what]
+      @playing_sounds[what].stop if @playing_sounds[what]
     end
   end
 

data/lib/gamebox/spatial_bucket.rb

@@ -0,0 +1,9 @@
+class SpatialBucket < Array
+  attr_accessor :x, :y
+  def initialize(x,y)
+    @x = x
+    @y = y
+    super()
+  end
+end
+

data/lib/gamebox/spatial_hash.rb

@@ -4,10 +4,11 @@ class SpatialHash
   attr_accessor :auto_resize
 
   def initialize(cell_size, resize = false)
-    @cell_size = cell_size.to_f
+    @cell_size = cell_size.to_i
     @items = {}
     @auto_resize = resize
 
+    # TODO auto resize is broken atm
     if @auto_resize
       @total_w = 0
       @total_h = 0
@@ -18,12 +19,13 @@ class SpatialHash
   end
 
   def cell_size=(new_size)
-    @cell_size = new_size
+    @cell_size = new_size.to_i
     rehash
   end
 
   def rehash
     @moved_items = {}
+    # TODO WTF?
     return
     items = @items
 
@@ -33,7 +35,7 @@ class SpatialHash
         avg_w = @total_w / items.size
         avg_h = @total_h / items.size
 
-        @cell_size = (avg_w+avg_h)
+        @cell_size = (avg_w+avg_h).to_i
       end
 
       @total_w = 0
@@ -61,12 +63,9 @@ class SpatialHash
   def _add(item)
     buckets = lookup item
     @items[item] = buckets
+
     buckets.each do |bucket|
-      x,y = *bucket
-      @buckets[x] ||= {}
-      @buckets[x][y] ||= []
-      target_bucket = @buckets[x][y]
-      target_bucket << item 
+      bucket << item
 
       if @auto_resize
         w = item.width if item.respond_to? :width
@@ -85,13 +84,12 @@ class SpatialHash
   end
 
   def _remove(item)
-    buckets = @items[item]
-    (buckets || []).each do |bucket|
-      x,y = *bucket
-      return if @buckets[x].nil? || @buckets[x][y].nil?
-      @buckets[x][y].delete item
+    buckets = @items.delete item
+    if buckets
+      buckets.each do |bucket|
+        bucket.delete item
+      end
     end
-    @items.delete item
   end
 
   def lookup(item)
@@ -103,34 +101,39 @@ class SpatialHash
 
     x = item.x
     y = item.y
-    min_x, min_y = bucket_for x, y
+    min_x = bucket_cell_for x
+    min_y = bucket_cell_for y
     if w == 1 && h == 1
       max_x = min_x
       max_y = min_y
     else
-      max_x, max_y = bucket_for x+w-1, y+h-1
+      max_x = bucket_cell_for x+w-1
+      max_y = bucket_cell_for y+h-1
     end
 
     buckets = []
-    (max_x-min_x+1).times do |i|
-      bucket_x = min_x + i
-      (max_y-min_y+1).times do |j|
-        buckets << [bucket_x,min_y+j] 
+    bucket_x = min_x
+    while bucket_x < max_x + 1 do 
+      bucket_y = min_y
+      while bucket_y < max_y + 1 do 
+        @buckets[bucket_x] ||= {}
+        @buckets[bucket_x][bucket_y] ||= SpatialBucket.new(bucket_x, bucket_y)
+        buckets << @buckets[bucket_x][bucket_y]
+        bucket_y += 1
       end
+      bucket_x += 1
     end
 
     buckets
   end
 
-  def bucket_for(x,y)
-    bucket_x = (x/cell_size).floor
-    bucket_y = (y/cell_size).floor
-    return [bucket_x, bucket_y]
+  def bucket_cell_for(location)
+    (location.to_i / cell_size).to_i
   end
-  
+
   def items_at(x,y)
-    bucket_x = (x/@cell_size).floor
-    bucket_y = (y/@cell_size).floor
+    bucket_x = bucket_cell_for x
+    bucket_y = bucket_cell_for y
     if @buckets[bucket_x].nil? || @buckets[bucket_x][bucket_y].nil?
       return []
     else
@@ -141,12 +144,14 @@ class SpatialHash
   def items_in(x,y,w,h)
     return items_at x, y if ((w.nil? || w == 1) && (h.nil? || w == 1))
 
-    min_x, min_y = bucket_for x, y
+    min_x = bucket_cell_for x
+    min_y = bucket_cell_for y
     if w == 1 && h == 1
       max_x = min_x
       max_y = min_y
     else
-      max_x, max_y = bucket_for x+w-1, y+h-1
+      max_x = bucket_cell_for x+w-1
+      max_y = bucket_cell_for y+w-1
     end
 
     items_in_bucket_range min_x, min_y, max_x, max_y
@@ -175,14 +180,11 @@ class SpatialHash
   # 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
+    min_bucket_x = buckets.min_by{ |bucket| bucket.x }.x - dist
+    min_bucket_y = buckets.min_by{ |bucket| bucket.y }.y - dist
+    max_bucket_x = buckets.max_by{ |bucket| bucket.x }.x + dist
+    max_bucket_y = buckets.max_by{ |bucket| bucket.y }.y + dist
 
     items = items_in_bucket_range min_bucket_x, min_bucket_y, max_bucket_x, max_bucket_y
     items-[item]