gamebox 0.0.1

data/lib/gamebox/input_manager.rb

@@ -0,0 +1,104 @@
+require 'publisher'
+class InputManager
+  extend Publisher
+  can_fire :key_up, :event_received
+
+  attr_accessor :hooks
+  
+  def initialize
+    @queue = EventQueue.new
+    @queue.ignore = [
+      ActiveEvent,
+      JoyAxisEvent,
+      JoyBallEvent,
+      JoyDownEvent,
+      JoyHatEvent,
+      JoyUpEvent,
+      ResizeEvent
+    ]
+    
+    @clock = Clock.new do |c|
+      c.target_framerate = 40
+      if c.respond_to? :calibrate
+        c.calibrate 
+        c.granularity = 2 if c.granularity < 2
+      end
+    end
+
+    @hooks = {}
+  end
+  
+  def framerate=(frame_rate)
+    @clock.target_framerate = frame_rate
+  end
+  
+  def framerate
+    @clock.target_framerate
+  end
+
+  def main_loop(game)
+    catch(:rubygame_quit) do
+      loop do
+        # add magic hooks
+        @queue.each do |event|
+          case event
+          when KeyDownEvent
+            case event.key
+            when K_F
+              puts "Framerate:#{@clock.framerate}"
+            when K_ESCAPE
+              throw :rubygame_quit
+            end
+          when QuitEvent
+            throw :rubygame_quit
+          end
+          fire :event_received, event
+
+          event_hooks = @hooks[event.class] 
+          event_action_hooks = event_hooks[event.key] if event_hooks
+          if event_action_hooks
+            for callback in event_action_hooks
+              callback.call
+            end
+          end
+        end
+
+        game.update @clock.tick
+      end
+    end
+  end
+
+  def register_hook(event_class, *event_ids, &block)
+    return unless block_given?
+    @hooks[event_class] ||= {}
+    for event_id in event_ids
+      @hooks[event_class][event_id] ||= []
+      @hooks[event_class][event_id] << block
+    end
+    listener = eval("self", block.binding) 
+    listener.when :remove_me do
+      unregister_hook event_class, *event_ids, &block
+    end
+  end
+  alias reg register_hook
+
+  def unregister_hook(event_class, *event_ids, &block)
+    @hooks[event_class] ||= {}
+    for event_id in event_ids
+      @hooks[event_class][event_id] ||= []
+      if block_given?
+        @hooks[event_class][event_id].delete block
+      else
+#        for blocks in @hooks[event_class][event_id]
+#          listener = eval("self", block.binding) 
+#          @hooks[event_class][event_id].delete block if listener == id
+#        end
+      end
+    end
+  end
+  alias unreg unregister_hook
+
+  def clear_hooks
+    @hooks = {}
+  end
+end

data/lib/gamebox/layered.rb

@@ -0,0 +1,34 @@
+require 'behavior'
+# Keeps track of the layer that something is to be drawn on.
+# By default it sets everything to layer 0 and parallax layer of
+# 1.
+class Layered < Behavior
+
+  attr_accessor :layer, :parallax
+  def setup
+    if @opts.is_a? Hash
+      @layer = @opts[:layer]
+      @parallax = @opts[:parallax]
+    else
+      @layer = @opts
+    end
+    
+    @layer ||= 0
+    @parallax ||= 1
+
+    layered_obj = self
+    @actor.instance_eval do
+      (class << self; self; end).class_eval do
+        define_method :layer do 
+          layered_obj.layer
+        end
+        define_method :parallax do 
+          layered_obj.parallax
+        end
+        define_method :layered do 
+          layered_obj
+        end
+      end
+    end
+  end
+end

data/lib/gamebox/level.rb

@@ -0,0 +1,64 @@
+# Levels represent on level of game play.  Some games will likely have only one
+# level. Level is responsible for loading its background, props, and directors.
+require 'inflector'
+require 'publisher'
+require 'director'
+class Level
+  extend Publisher
+
+  can_fire_anything
+  attr_accessor :director, :resource_manager, :sound_manager,
+    :opts, :viewport
+    
+  def initialize(actor_factory, resource_manager, sound_manager, viewport, opts={}) 
+    @director = Director.new
+    @actor_factory = actor_factory
+    @actor_factory.director = @director
+
+    @sound_manager = sound_manager
+    @resource_manager = resource_manager
+    @viewport = viewport
+    @opts = opts
+    setup
+  end
+
+  def setup
+  end
+
+  def create_actor(type, args={})
+    @actor_factory.build type, self, args
+  end
+
+  def update(time)
+    @director.update time
+  end
+
+  def draw(target,x_off,y_off)
+  end
+  
+  # extract all the params from a node that are needed to construct an actor
+  def create_actors_from_svg
+    float_keys = ["x","y"]
+    dynamic_actors ||= {}
+    layer = @svg_doc.find_group_by_label("actors")
+
+    unless layer.nil?
+      # each image in the layer is an actor
+      layer.images.each do |actor_def|
+      klass = actor_def.game_class.to_sym
+      handle = actor_def.game_handle
+      new_opts = {}
+      actor_def.node.attributes.each do |k,v|
+        v = v.to_f if float_keys.include? k
+        new_opts[k.to_sym] = v
+      end
+    
+      actor = create_actor klass, new_opts
+      dynamic_actors[handle.to_sym] = actor if handle
+    end
+  end
+
+  dynamic_actors
+  end
+
+end

data/lib/gamebox/linked_list.rb

@@ -0,0 +1,137 @@
+class LinkedList
+  include Enumerable
+
+  ListElem = Struct.new(:obj, :prev, :next)
+  attr_accessor :head, :tail
+
+  def initialize(enum = nil)
+    @head = @tail = ListElem.new
+    @head.next = @head
+    @head.prev = @head
+
+    append enum unless enum.nil?
+  end
+
+  # pop off the first item
+  def shift
+    tmp = @head.next
+    @head.next = tmp.next
+    tmp.next.prev = @head
+    #puts "SHIFTING [#{tmp.obj.x},#{tmp.obj.y}]"
+#    puts to_s
+    return tmp.obj
+  end
+
+  # pop off the last item
+  def unshift
+    tmp = @tail.prev
+    @tail.prev = @tail.prev.prev
+    @tail.next = @tail
+    return tmp.obj
+  end
+
+  def place(new_obj, location, elem)
+#    puts "placing #{new_obj[0][0]},#{new_obj[0][1]} #{location} #{elem.obj[0][0]},#{elem.obj[0][1]}"
+    tmp = ListElem.new
+    tmp.obj = new_obj
+    case location
+    when :before
+      tmp.next = elem
+      tmp.prev = elem.prev
+      elem.prev.next = tmp
+      elem.prev = tmp
+    when :after
+      tmp.prev = elem
+      tmp.next = elem.next
+      elem.next.prev = tmp
+      elem.next = tmp
+    end
+#    puts to_s
+    tmp
+  end
+
+  def append(e)
+#    puts "appending #{e[0][0]},#{e[0][1]}"
+    tmp = ListElem.new
+    tmp.obj = e
+    tmp.prev = @tail.prev
+    tmp.next = @tail
+    tmp.prev.next = tmp
+    tmp.next.prev = tmp
+#    puts to_s
+    self
+  end
+
+  alias :<< :append
+  def prepend(e)
+    tmp = ListElem.new
+    tmp.obj = e
+    tmp.prev = @head
+    tmp.next = @head.next
+    tmp.prev.next = tmp
+    tmp.next.prev = tmp
+    self
+  end
+  alias :>> :prepend
+
+  # only removed the first instance of e
+  def remove(e)
+    i = @head.next
+
+    while @tail != i
+      if i.obj == e
+        # remove it
+        i.prev.next = i.next
+        i.next.prev = i.prev
+        return i.obj
+      end
+      i = i.next
+    end
+    i
+  end
+  alias :- :remove
+
+  def empty?()
+    @tail.prev == @head
+  end
+
+  def each
+    i = @head.next
+
+    while @tail != i
+      yield i.obj
+      i = i.next
+    end
+  end
+
+  def each_element
+    i = @head.next
+
+    while @tail != i
+      yield i
+      i = i.next
+    end
+  end
+
+  def to_s
+    str = "LinkedList #{self.object_id} ["
+    i = @head.next
+
+    while @tail != i
+      str += "#{i.obj[0]}-#{i.obj[1]},"
+      i = i.next
+    end
+    str  += "]"
+    str
+  end
+
+  def size
+    size = 0
+    i = @head.next
+    while @tail != i
+      i = i.next
+      size += 1
+    end
+    size
+  end
+end 

data/lib/gamebox/logo.rb

@@ -0,0 +1,11 @@
+require 'actor'
+require 'graphical_actor_view'
+class LogoView < GraphicalActorView
+  def draw(target,xoff,yoff)
+    super target, 0, 0
+  end
+end
+class Logo < Actor
+  has_behaviors :graphical, 
+  :layered => {:layer => 999}
+end

data/lib/gamebox/metaclass.rb

@@ -0,0 +1,6 @@
+class Object
+  # Get a metaclass for this class
+  def self.metaclass # :nodoc: 
+    class << self; self; end; 
+  end 
+end

data/lib/gamebox/mode.rb

@@ -0,0 +1,123 @@
+require 'inflector'
+require 'viewport'
+# Mode is a state that the game is in.  (ie intro mode, multiplayer mode,
+# single player mode).
+class Mode
+  extend Publisher
+  can_fire_anything
+
+  attr_accessor :level, :drawables, :resource_manager, :sound_manager
+  def initialize(input_manager, actor_factory, resource_manager, sound_manager, config_manager, levels)
+    @input_manager = input_manager
+    @actor_factory = actor_factory
+    @resource_manager = resource_manager
+    @sound_manager = sound_manager
+    @config_manager = config_manager
+    res = @config_manager[:screen_resolution]
+
+    @viewport = Viewport.new res[0], res[1]
+    @drawables = {}
+    @levels = levels
+    setup
+  end
+
+  def setup
+  end
+
+  def start
+    @level_number = 0
+    clear_drawables
+    @level = build_level @levels[@level_number], nil
+  end
+
+  def next_level
+    @level_number += 1
+    clear_drawables
+    @level = build_level @levels[@level_number], @level
+  end
+
+  def prev_level
+    @level_number -= 1
+    clear_drawables
+    @level = build_level @levels[@level_number], @level
+  end
+
+  def restart_level
+    clear_drawables
+    @level = build_level @levels[@level_number], @level
+  end
+
+  def stop
+  end
+
+  def build_level(level_def, prev_level_instance)
+    level_sym = level_def.keys.first
+    begin
+      require level_sym.to_s+"_level"
+    rescue LoadError => ex
+      puts "Load error: #{ex.inspect}"
+      puts ex.backtrace.join("\n")
+      # maybe we have included it elsewhere
+    end
+    level_klass = ObjectSpace.const_get(Inflector.camelize(level_sym.to_s+"_level"))
+    full_level_def = { :prev_level => prev_level_instance }
+    full_level_def.merge! level_def[level_sym] if level_def[level_sym].is_a? Hash
+    level = level_klass.new @actor_factory, @resource_manager, @sound_manager, @viewport, full_level_def
+    level.when :restart_level do
+      restart_level
+    end
+    level.when :next_level do
+      if @level_number == @levels.size-1
+        fire :next_mode
+      else
+        next_level
+      end
+    end
+    level.when :prev_level do
+      if @level_number == 0
+        fire :prev_mode
+      else
+        prev_level
+      end
+    end
+
+    level
+  end
+
+  def update(time)
+    @level.update time if @level
+    @viewport.update time
+  end
+
+  def draw(target)
+    @level.draw target, @viewport.x_offset, @viewport.y_offset
+
+    for parallax_layer in @drawables.keys.sort.reverse
+      pd = @drawables[parallax_layer]
+      for layer in pd.keys.sort
+        for d in pd[layer]
+          trans_x = @viewport.x_offset parallax_layer
+          trans_y = @viewport.y_offset parallax_layer
+          d.draw target, trans_x, trans_y 
+        end
+      end
+    end
+  end
+
+  def unregister_drawable(drawable)
+    @drawables[drawable.parallax][drawable.layer].delete drawable
+  end
+
+  def clear_drawables
+    @drawables = {}
+  end
+
+  def register_drawable(drawable)
+    layer = drawable.layer
+    parallax = drawable.parallax
+    @drawables[parallax] ||= {}
+    @drawables[parallax][layer] ||= []
+    @drawables[parallax][layer] << drawable
+  end
+end
+