gamebox 0.3.4 → 0.4.0.rc1

data/lib/gamebox/behaviors/timed.rb

@@ -1,33 +0,0 @@
-class Timed < Behavior
-
-  def setup
-    actor.when :remove_me do |actor|
-      clear_timers
-    end
-
-    @timers = []
-    relegates :add_timer, :remove_timer
-  end
-
-  def add_timer(name, ms, recurring = true, &block)
-    timer_name = "#{actor.object_id} #{name}"
-    @timers << timer_name
-    actor.stage.add_timer timer_name, ms do
-      block.call
-      actor.stage.remove_timer timer_name unless recurring
-    end
-  end
-
-  def remove_timer(name)
-    timer_name = "#{actor.object_id} #{name}"
-    @timers.delete timer_name
-    actor.stage.remove_timer timer_name
-  end
-
-  def clear_timers
-    @timers.each do |timer_name|
-      actor.stage.remove_timer timer_name
-    end
-  end
-
-end

data/lib/gamebox/behaviors/updatable.rb

@@ -1,12 +0,0 @@
-
-
-class Updatable < Behavior
-  
-  def setup
-    @actor.director.add_actor @actor
-  end
-
-  def removed
-    @actor.director.remove_actor @actor
-  end
-end

data/lib/gamebox/console_app.rb

@@ -1,41 +0,0 @@
-if $0 == __FILE__
-  puts "Connecting to game..."
-  require 'irb'
-  require 'irb/completion'
-  module IRB
-    def IRB.start_session(obj)
-      unless $irb
-        IRB.setup nil
-        ## maybe set some opts here, as in parse_opts in irb/init.rb?
-        IRB.load_modules
-      end
-    
-      workspace = WorkSpace.new(obj)
-
-      if @CONF[:SCRIPT] ## normally, set by parse_opts
-        $irb = Irb.new(workspace, @CONF[:SCRIPT])
-      else
-        $irb = Irb.new(workspace)
-      end
-
-      @CONF[:IRB_RC].call($irb.context) if @CONF[:IRB_RC]
-      @CONF[:MAIN_CONTEXT] = $irb.context
-
-      trap("INT") do
-        $irb.signal_handle
-      end
-
-      catch(:IRB_EXIT) do
-        $irb.eval_input
-      end
-      print "\n"
-    
-      ## might want to reset your app's interrupt handler here
-    end
-  end
-
-  require 'drb'
-  DRb.start_service
-  game = DRbObject.new nil, "druby://localhost:7373"
-  IRB.start_session game
-end

data/lib/gamebox/gamebox_generator.rb

@@ -1,32 +0,0 @@
-# # This is the generator for gamebox
-# 
-# $: << File.join(File.dirname(__FILE__),'generators')
-# 
-# unless "".respond_to? :end_with?
-#   class String
-#     def end_with?(ending)
-#       self[size-ending.size..-1] == ending
-#     end
-#   end
-# end
-# 
-# def print_usage
-#   puts "generate what *opts"
-#   puts "TODO list all generators here"
-# end
-# # TODO pull these out into generators/ dir for listing
-# 
-# if ARGV.size < 1
-#   print_usage 
-#   exit 0
-# end
-# 
-# # TODO load generator file based on ARGV[0]
-# generator_klass_name = 
-#   Inflector.camelize ARGV[0].downcase+"_generator"
-# 
-# require Inflector.underscore(generator_klass_name)
-# 
-# generator_klass = Object.const_get generator_klass_name
-# generator_klass.new.generate(ARGV[1..-1])
-# 

data/lib/gamebox/generators/actor_generator.rb

@@ -1,43 +0,0 @@
-
-class ActorGenerator
-  require 'erb'
-  def generate(*args)
-
-    @actor_name = ARGV[1]
-    @behaviors = ARGV[2]
-    @bind = binding
-
-    build_actor
-    build_test_actor
-
-    # load test_actor and replace
-  end
-  
-  def build_actor
-    template_file = File.open(File.join(GAMEBOX_PATH,'templates','actor.erb'))
-    template_contents = template_file.readlines.join
-    actor_template = ERB.new(template_contents)
-
-    result = actor_template.result @bind
-
-    out_file = File.join(APP_ROOT,'src',Inflector.underscore(@actor_name)+".rb")
-    raise "File exists [#{out_file}]" if File.exists? out_file
-    File.open(out_file,"w+") do |f|
-      f.write result
-    end
-  end
-
-  def build_test_actor
-    template_file = File.open(File.join(GAMEBOX_PATH,'templates','actor_spec.erb'))
-    template_contents = template_file.readlines.join
-    actor_template = ERB.new(template_contents)
-
-    result = actor_template.result @bind
-
-    out_file = File.join(APP_ROOT,'spec',Inflector.underscore(@actor_name)+"_spec.rb")
-    raise "File exists [#{out_file}]" if File.exists? out_file
-    File.open(out_file,"w+") do |f|
-      f.write result
-    end
-  end
-end

data/lib/gamebox/generators/view_generator.rb

@@ -1,42 +0,0 @@
-
-class ViewGenerator
-  require 'erb'
-  def generate(*args)
-
-    @actor_view_name = ARGV[1]
-    @actor_view_name += "View" unless @actor_view_name.end_with? "View"
-    @behaviors = ARGV[2]
-    @bind = binding
-
-    build_actor_view
-    build_test_actor_view
-  end
-  
-  def build_actor_view
-    template_file = File.open(File.join(GAMEBOX_PATH,'templates','actor_view.erb'))
-    template_contents = template_file.readlines.join
-    actor_view_template = ERB.new(template_contents)
-
-    result = actor_view_template.result @bind
-
-    out_file = File.join(APP_ROOT,'src',Inflector.underscore(@actor_view_name)+".rb")
-    raise "File exists [#{out_file}]" if File.exists? out_file
-    File.open(out_file,"w+") do |f|
-      f.write result
-    end
-  end
-
-  def build_test_actor_view
-    template_file = File.open(File.join(GAMEBOX_PATH,'templates','actor_view_spec.erb'))
-    template_contents = template_file.readlines.join
-    actor_view_template = ERB.new(template_contents)
-
-    result = actor_view_template.result @bind
-
-    out_file = File.join(APP_ROOT,'spec',Inflector.underscore(@actor_view_name)+"_spec.rb")
-    raise "File exists [#{out_file}]" if File.exists? out_file
-    File.open(out_file,"w+") do |f|
-      f.write result
-    end
-  end
-end

data/lib/gamebox/physical_director.rb

@@ -1,17 +0,0 @@
-
-
-class PhysicalDirector < Director
-  def find_physical_obj(shape)
-    @actors.select{|a|a.respond_to?(:shape) && a.shape==shape}.first
-  end
-
-  def remove_physical_obj(shape)
-    act = find_physical_obj shape
-    act.remove_self
-    act
-  end
-
-  def actor_removed(act)
-    act.stage.unregister_physical_object act if act.is? :physical
-  end
-end

data/lib/gamebox/physics.rb

@@ -1,32 +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
-      
-      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/spatial_bucket.rb

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

data/lib/gamebox/spatial_hash.rb

@@ -1,194 +0,0 @@
-class SpatialHash
-
-  attr_reader :cell_size, :buckets, :items, :moved_items
-  attr_accessor :auto_resize
-
-  def initialize(cell_size, resize = false)
-    @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
-    end
-    @items = {}
-    @buckets = {}
-    rehash
-  end
-
-  def cell_size=(new_size)
-    @cell_size = new_size.to_i
-    rehash
-  end
-
-  def rehash
-    @moved_items = {}
-    # TODO WTF?
-    return
-    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).to_i
-      end
-
-      @total_w = 0
-      @total_h = 0
-    end
-
-    @items = {}
-    @buckets = {}
-    items.values.each do |item|
-      add item
-    end
-  end
-
-  # does not remove or add event handlers
-  def move(item)
-    @moved_items[item] = item
-    _remove item
-    _add item
-  end
-
-  def add(item)
-    _add item
-  end
-
-  def _add(item)
-    buckets = lookup item
-    @items[item] = buckets
-
-    buckets.each do |bucket|
-      bucket << item
-
-      if @auto_resize
-        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
-  end
-
-  def remove(item)
-    @moved_items.delete item
-    _remove item
-  end
-
-  def _remove(item)
-    buckets = @items.delete item
-    if buckets
-      buckets.each do |bucket|
-        bucket.delete item
-      end
-    end
-  end
-
-  def lookup(item)
-    w = item.width if item.respond_to? :width
-    h = item.height if item.respond_to? :height
-
-    w ||= 1
-    h ||= 1
-
-    x = item.x
-    y = item.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 = bucket_cell_for x+w-1
-      max_y = bucket_cell_for y+h-1
-    end
-
-    buckets = []
-    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_cell_for(location)
-    (location.to_i / cell_size).to_i
-  end
-
-  def items_at(x,y)
-    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
-      @buckets[bucket_x][bucket_y]
-    end
-  end
-
-  def items_in(x,y,w,h)
-    return items_at x, y if ((w.nil? || w == 1) && (h.nil? || w == 1))
-
-    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 = 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
-  end
-
-  def items_in_bucket_range(min_x,min_y,max_x,max_y)
-    items = {}
-    (min_x+1..(max_x+1)).each do |bucket_x|
-      x_bucket = @buckets[bucket_x]
-
-      if x_bucket
-        (min_y+1..(max_y+1)).each do |bucket_y|
-          objects = x_bucket[bucket_y]
-          if objects
-            objects.each do |item|
-              items[item] = item
-            end
-          end
-        end
-      end
-    end
-    items.values
-  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 = 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]
-  end
-
-end
-