gamebox 0.0.6 → 0.0.7

data/lib/gamebox/ftor.rb

@@ -0,0 +1,2 @@
+require 'rubygame/ftor'
+Ftor = Rubygame::Ftor

data/lib/gamebox/gamebox_application.rb

@@ -4,6 +4,8 @@ $: << "#{File.dirname(__FILE__)}/../config"
 require 'rubygems'
 require 'rubygame'
 include Rubygame
+include Rubygame::Events
+require 'event_compat'
 require 'surface_ext'
 
 require "environment"
@@ -23,7 +25,16 @@ class GameboxApp
   end
 
   def initialize
-    @context = DIY::Context.from_file(APP_ROOT + '/config/objects.yml')
+    gamebox_objects = YAML.load(File.read(GAMEBOX_PATH + 'data/config/objects.yml'))
+
+    game_objects_file = APP_ROOT + '/config/objects.yml'
+    game_specific_objects = {}
+    if File.exist? game_objects_file
+      game_specific_objects = YAML.load(File.read(game_objects_file))
+    end
+    objects = gamebox_objects.merge! game_specific_objects
+
+    @context = DIY::Context.from_yaml(YAML.dump(objects))
   end
   
   def setup

data/lib/gamebox/generators/actor_generator.rb

@@ -28,13 +28,13 @@ class ActorGenerator
   end
 
   def build_test_actor
-    template_file = File.open(File.join(GAMEBOX_PATH,'templates','test_actor.erb'))
+    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,'test','test_'+Inflector.underscore(@actor_name)+".rb")
+    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

data/lib/gamebox/generators/view_generator.rb

@@ -0,0 +1,42 @@
+
+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/input_manager.rb

@@ -1,26 +1,52 @@
 require 'publisher'
+
+# InputManager handles the pumping of SDL for events and distributing of said events.
+# You can gain access to these events by registering for all events, 
+# or just the ones you care about.
+# All events:
+# input_manager.when :event_received do |evt|
+#   ...
+# end
+# 
+# Some events:
+# input_manager.reg KeyPressed, :space do
+#   ...
+# end
+#
+# Don't forget to unreg for these things between stages, 
+# since the InputManager is shared across stages.
 class InputManager
   extend Publisher
   can_fire :key_up, :event_received
 
+
+  # lookup map for mouse button clicks
   MOUSE_BUTTON_LOOKUP = {
-    1 => :left,
-    2 => :middle,
-    3 => :right,
+    MOUSE_LEFT   => :left,
+    MOUSE_MIDDLE => :middle,
+    MOUSE_RIGHT  => :right,
   }
 
-  attr_accessor :hooks
-  
-  def initialize
+  constructor :config_manager
+
+  # Sets up the clock and main event loop. You should never call this method, 
+  # as this class should be initialized by diy.
+  def setup
     @queue = EventQueue.new
+    @queue.enable_new_style_events
     @queue.ignore = [
-      ActiveEvent,
-      JoyAxisEvent,
-      JoyBallEvent,
-      JoyDownEvent,
-      JoyHatEvent,
-      JoyUpEvent,
-      ResizeEvent
+      InputFocusGained,
+      InputFocusLost,
+      MouseFocusGained,
+      MouseFocusLost,
+      WindowMinimized,
+      WindowUnminimized,
+      JoystickAxisMoved,
+      JoystickBallMoved,
+      JoystickButtonPressed,
+      JoystickButtonReleased,
+      JoystickHatMoved,
+      WindowResized
     ]
     
     @clock = Clock.new do |c|
@@ -31,39 +57,49 @@ class InputManager
       end
     end
 
+    @auto_quit = @config_manager[:auto_quit]
+
     @hooks = {}
     @non_id_hooks = {}
   end
   
+  # Sets the target framerate for the game. 
+  # This setting controls how lock Clock#tick will delay.
   def framerate=(frame_rate)
     @clock.target_framerate = frame_rate
   end
   
+  # Returns the target framerate.
   def framerate
     @clock.target_framerate
   end
 
+  # This is where the queue gets pumped. This gets called from your game application.
   def main_loop(game)
     catch(:rubygame_quit) do
       loop do
         # add magic hooks
         @queue.each do |event|
           case event
-          when KeyDownEvent
+          when KeyPressed
             case event.key
-            when K_F
+            when :f
               puts "Framerate:#{@clock.framerate}"
-            when K_ESCAPE
-              throw :rubygame_quit
+            when @auto_quit
+              throw :rubygame_quit 
             end
-          when QuitEvent
+          when QuitRequested
             throw :rubygame_quit
           end
           fire :event_received, event
 
           event_hooks = @hooks[event.class] 
           id = event.key if event.respond_to? :key
-          id ||= MOUSE_BUTTON_LOOKUP[event.button] if event.respond_to? :button
+
+          if event.respond_to? :button
+            id ||= (MOUSE_BUTTON_LOOKUP[event.button] or event.button)
+          end
+
           unless id.nil?
             event_action_hooks = event_hooks[id] if event_hooks
             if event_action_hooks
@@ -86,7 +122,22 @@ class InputManager
     end
   end
 
+  # registers a block to be called when matching events are pulled from the SDL queue.
+  # ie 
+  # input_manager.register_hook KeyPressed do |evt|
+  #   # will be called on every key press
+  # end
+  # input_manager.register_hook KeyPressed, K_SPACE do |evt|
+  #   # will be called on every spacebar key press
+  # end
   def register_hook(event_class, *event_ids, &block)
+    return unless block_given?
+    listener = eval("self", block.binding) 
+    _register_hook listener, event_class, *event_ids, &block
+  end
+  alias reg register_hook
+
+  def _register_hook(listener, event_class, *event_ids, &block)
     return unless block_given?
     @hooks[event_class] ||= {}
     for event_id in event_ids
@@ -97,13 +148,15 @@ class InputManager
     if event_ids.empty?
       @non_id_hooks[event_class] << 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
 
+  # unregisters a block to be called when matching events are pulled from the SDL queue.
+  # ie 
+  # input_manager.unregister_hook KeyPressed, :space, registered_block
+  # also see InputManager#clear_hooks for clearing many hooks
   def unregister_hook(event_class, *event_ids, &block)
     @hooks[event_class] ||= {}
     for event_id in event_ids
@@ -117,6 +170,9 @@ class InputManager
   end
   alias unreg unregister_hook
 
+
+  # removes all blocks that are in the scope of listener's instance.
+  # clears all listeners if listener is nil
   def clear_hooks(listener=nil)
     if listener
       for event_klass, id_listeners in @hooks
@@ -137,4 +193,15 @@ class InputManager
       @non_id_hooks = {}
     end
   end
+
+  # autohook a boolean to be set to true while a key is pressed
+  def while_key_pressed(key, target, accessor)
+    _register_hook target, KeyPressed, key do
+      target.send accessor.to_s+"=", true
+    end
+    _register_hook target, KeyReleased, key do
+      target.send accessor.to_s+"=", false
+    end
+  end
+
 end

data/lib/gamebox/{inflector.rb → lib/inflector.rb}

@@ -200,7 +200,7 @@ module Inflector
     class_name_in_module.to_s.gsub(/^.*::/, '')
   end
 
-  # Create the name of a table like Rails does for models to table names. This method
+  # Create the name of a table like Rails does for stagels to table names. This method
   # uses the pluralize method on the last word in the string.
   #
   # Examples
@@ -211,7 +211,7 @@ module Inflector
     pluralize(underscore(class_name))
   end
 
-  # Create a class name from a table name like Rails does for table names to models.
+  # Create a class name from a table name like Rails does for table names to stagels.
   # Note that this returns a string and not a Class. (To convert to an actual class
   # follow classify with constantize.)
   #

data/lib/gamebox/lib/numbers_ext.rb

@@ -0,0 +1,3 @@
+class Float
+    INFINITY = 1.0/0.0
+end

data/lib/gamebox/lib/surface_ext.rb

@@ -0,0 +1,76 @@
+require 'ftor'
+include Rubygame::Color
+module Rubygame
+  class Surface
+    def draw_line_s(point1, point2, color, thickness)
+      half_thickness = thickness/2.0
+      x1 = point1[0]
+      y1 = point1[1]
+      x2 = point2[0]
+      y2 = point2[1]
+
+      point1_vector = Ftor.new x1, y1
+      point2_vector = Ftor.new x2, y2
+
+      line_vector = point2_vector-point1_vector
+      perp_vector = line_vector.normal.unit
+
+      points = []
+      pvt = perp_vector*half_thickness
+      poly_point1 = Ftor.new(x1,y1)+pvt
+      poly_point2 = Ftor.new(x2,y2)+pvt
+      poly_point3 = Ftor.new(x2,y2)-pvt
+      poly_point4 = Ftor.new(x1,y1)-pvt
+
+      points << [poly_point1.x,poly_point1.y]
+      points << [poly_point2.x,poly_point2.y]
+      points << [poly_point3.x,poly_point3.y]
+      points << [poly_point4.x,poly_point4.y]
+      points << [poly_point1.x,poly_point1.y]
+
+      draw_polygon_s points, color
+      draw_circle_s [x1,y1], half_thickness, color
+      draw_circle_s [x2,y2], half_thickness, color
+    end
+
+    # BY IPPA
+    def fill_gradient(user_options = {})
+      # merge arguments from methodcall Over default options
+      default_options = {  
+        :from_color => :black,
+        :to_color => :white, 
+        :thickness => 10, 
+        :orientation => :down, 
+        :rect => Rect.new([0, 0, self.width, self.height])
+      }
+      options = default_options.merge(user_options)
+
+      # typecast color and rect arguments      
+      from_color = (options[:from_color].is_a? ColorRGB)? options[:from_color] : Color[options[:from_color]]
+      to_color = (options[:to_color].is_a? ColorRGB)? options[:to_color] : Color[options[:to_color]]
+      rect = (options[:rect].is_a? Rect)? options[:rect] : Rect.new(:rect)
+
+      length = (options[:orientation] == :vertical) ? rect.height : rect.width
+      weight_step = 1.0 / (length.to_f / options[:thickness].to_f)
+      weight = 0.0
+      x = rect.x
+      y = rect.y
+
+      while weight < 1.0 
+        color = to_color.average(from_color, weight)
+
+        if options[:orientation] == :vertical
+          self.draw_box_s([x, y], [rect.width, y + options[:thickness]], color)
+          y += options[:thickness] 
+        else
+          self.draw_box_s([x, y],[x + options[:thickness], rect.height], color)
+          x += options[:thickness]          
+        end
+
+        weight += weight_step
+      end
+    end
+
+  end
+
+end # module Rubygame

data/lib/gamebox/physical_director.rb

@@ -12,6 +12,6 @@ class PhysicalDirector < Director
   end
 
   def actor_removed(act)
-    act.level.unregister_physical_object act if act.is? :physical
+    act.stage.unregister_physical_object act if act.is? :physical
   end
 end

data/lib/gamebox/{physical_level.rb → physical_stage.rb}

@@ -1,29 +1,26 @@
-# 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.
-# PhysicalLevel adds a physics space to the Level
-require 'level'
+# 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
+require 'stage'
 require 'physics'
 require 'physical_director'
-class PhysicalLevel < Level
+class PhysicalStage < Stage
   
   attr_accessor :space
 
-  def initialize(actor_factory, resource_manager, sound_manager, input_manager, viewport, opts={}) 
-    @actor_factory = actor_factory
-    @director = PhysicalDirector.new
-    @actor_factory.director = @director
-
-    @resource_manager = resource_manager
-    @sound_manager = sound_manager
-    @input_manager = input_manager
-    @viewport = viewport
-    @opts = opts
-
+  def setup
+    super
+    setup_space
+  end
+  
+  def setup_space
     @space = Space.new
     @space.iterations = 20
-    @space.elastic_iterations = 0
+    @space.elastic_iterations = 5
+  end
 
-    setup
+  def create_director
+    PhysicalDirector.new
   end
 
   PHYSICS_STEP = 25.0
@@ -87,4 +84,17 @@ class PhysicalLevel < Level
     end
   end
 
+  # Find any / all objects who's bounding box currently contains
+  # the passed in screen position. Requires a block as this sets
+  # a callback all the way down in Chipmunk and could be called
+  # 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
+
 end