gamebox 0.4.0.rc5 → 0.4.0.rc11

data/lib/gamebox/core/game.rb

@@ -2,7 +2,7 @@ class Game
 
   # BTW: we have extra deps to make sure they are all built at game construction time
   construct_with :wrapped_screen, :input_manager, :sound_manager,
-    :stage_manager
+    :stage_manager, :config_manager
 
   def configure
     stage_manager.change_stage_to stage_manager.default_stage

data/lib/gamebox/core/input_manager.rb

@@ -1,8 +1,5 @@
 require 'publisher'
 
-# looks like theres a bug in Gosu
-KbRangeBegin = 0
-
 # InputManager handles the pumping 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.
@@ -25,7 +22,7 @@ class InputManager
   DOWN_EVENTS = [:mouse_down, :keyboard_down, :game_pad_down]
   UP_EVENTS = [:mouse_up, :keyboard_up, :game_pad_up]
 
-  attr_accessor :window
+  attr_accessor :window, :down_ids
   construct_with :config_manager, :wrapped_screen
 
   # Sets up the clock and main event loop. You should never call this method, 

data/lib/gamebox/core/input_mapper.rb

@@ -0,0 +1,85 @@
+class InputMapper
+  extend Publisher
+  can_fire_anything
+
+  construct_with :input_manager
+  def initialize
+    @action_ids = {}
+  end
+
+  # map_input is to be setup outside of an actor and passed in at construction
+  # time ie:
+  #
+  # mapper.map_input {
+  #  '+a' => :jump,   # emit jump when 'a' is _pressed_
+  #  '-b' => :duck,   # emit duck when 'b' is _released_
+  #  'c'  => :block   # emit block when 'c' is _pressed_ AND _released_
+  # }
+  #
+  # all keys will have a <key_name>? defined for checking state at anytime
+  # create_actor :fighter, input: mapper
+  # 
+  # all of the actor's behaviors can / should use the input mapper instead of raw key bindings
+  def map_input(input_hash)
+    input_hash.each do |input, actions|
+      if input.start_with? '-'
+        register_key_released(input[1..-1], actions)
+      elsif input.start_with? '+'
+        register_key_pressed(input[1..-1], actions)
+      else
+        register_key_released(input, actions)
+        register_key_pressed(input, actions)
+      end
+    end
+  end
+
+  # unsubscribes for all input
+  def clear
+    input_manager.unsubscribe_all
+  end
+
+  def method_missing(name, *args)
+    if name.to_s.end_with? '?'
+      button_syms = @action_ids[name[0..-2].to_sym]
+      if button_syms
+        return button_syms.any? do |button_sym| 
+          input_manager.down_ids.include? BUTTON_SYM_TO_ID[button_sym]
+        end
+      end
+    end
+
+    false
+  end
+
+  private
+  def register_key_pressed(key, actions)
+    id = BUTTON_SYM_TO_ID[key.to_sym]
+    raise "unknown button id from #{key}" unless id
+
+    input_manager.reg :down, id do |*args|
+      Array.wrap(actions).each do |action|
+        fire action, *args
+      end
+    end
+    def_state_probe_method(key, actions)
+  end
+
+  def register_key_released(key, actions)
+    id = BUTTON_SYM_TO_ID[key.to_sym]
+    raise "unknown button id from #{key}" unless id
+    input_manager.reg :up, id do |*args|
+      Array.wrap(actions).each do |action|
+        fire action, *args
+      end
+    end
+
+    def_state_probe_method(key, actions)
+  end
+
+  def def_state_probe_method(key, actions)
+    Array.wrap(actions).each do |action|
+      @action_ids[action] ||= []
+      @action_ids[action] << key.to_sym
+    end
+  end
+end

data/lib/gamebox/core/physics.rb

@@ -1,5 +1,4 @@
 if defined? CP
-  ZERO_VEC_2 = vec2(0,0) unless defined? ZERO_VEC_2
   def vec2(*args)
     CP::Vec2.new *args
   end
@@ -15,8 +14,13 @@ if defined? CP
   end
 
 else
-  ZERO_VEC_2 = Ftor.new(0,0)
   def vec2(*args)
-    Ftor.new *args
+    Vector2.new *args
   end
 end
+
+ZERO_VEC_2 = vec2(0,0)
+
+module Math
+  HALF_PI = PI / 2.0
+end

data/lib/gamebox/core/physics_manager.rb

@@ -4,9 +4,13 @@ class PhysicsManager
   def_delegators( :@space,
                   :damping,            :damping=,
                   :gravity,            :gravity=,
-                  :iterations,         :iterations= )
+                  :iterations,         :iterations=,
+                  :on_post_step,       :add_post_step_callback
+                )
 
   attr_accessor :space
+  delegate 'add_post_step_callback' => '@space'
+
 
   # Time per physics step, in milliseconds (default 15). Small steps
   # make the simulation more stable than large steps, but if the step

data/lib/gamebox/core/renderer.rb

@@ -0,0 +1,72 @@
+class Renderer
+  construct_with :viewport
+
+  def initialize
+    clear_drawables
+  end
+
+  def register_drawable(drawable)
+    layer = drawable.layer
+    parallax = drawable.parallax
+    unless @drawables[parallax]
+      @drawables[parallax] = {}
+      @parallax_layers = @drawables.keys.sort.reverse
+    end
+    unless @drawables[parallax][layer]
+      @drawables[parallax][layer] = []
+      @layer_orders[parallax] = @drawables[parallax].keys.sort
+    end
+    @drawables[parallax][layer] << drawable
+  end
+
+
+  def unregister_drawable(drawable)
+    @drawables[drawable.parallax][drawable.layer].delete drawable
+  end
+
+  def clear_drawables
+    @drawables = {}
+    @layer_orders = {}
+    @parallax_layers = []
+  end
+
+
+  def draw(target)
+    center_x = viewport.width / 2
+    center_y = viewport.height / 2
+
+    target.rotate(-viewport.rotation, center_x, center_y) do
+      z = 0
+      @parallax_layers.each do |parallax_layer|
+        drawables_on_parallax_layer = @drawables[parallax_layer]
+
+        if drawables_on_parallax_layer
+          @layer_orders[parallax_layer].each do |layer|
+
+            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, z
+            end
+          end
+        end
+      end
+    end
+  end
+
+  # move all actors from one layer to another
+  # note, this will remove all actors in that layer!
+  def move_layer(from_parallax, from_layer, to_parallax, to_layer)
+    drawable_list = @drawables[from_parallax][from_layer].dup
+
+    drawable_list.each do |drawable|
+      unregister_drawable drawable      
+      drawable.parallax = to_parallax
+      drawable.layer = to_layer
+      register_drawable drawable      
+    end
+  end
+
+end

data/lib/gamebox/core/stage.rb

@@ -7,28 +7,17 @@ class Stage
 
   construct_with :input_manager, :actor_factory, :resource_manager, 
     :sound_manager, :config_manager, :director, :timer_manager, 
-    :this_object_context
+    :viewport, :this_object_context
 
-  def self.inherited(kid)
-    kid.construct_with *self.object_definition.component_names
-  end
-
-  attr_accessor :opts, :viewport, :backstage
+  attr_accessor :opts, :backstage
 
   def configure(backstage, opts)
-    res = config_manager[:screen_resolution]
-    @viewport = Viewport.new res[0], res[1]
-    this_object_context[:viewport] = @viewport
+    viewport.reset
 
     @stagehands = {}
     @backstage = backstage
     @opts = opts
-
-    setup
-  end
-
-  def setup
-    clear_drawables
+    renderer.clear_drawables
   end
 
   def create_actor(type, args={})
@@ -61,10 +50,14 @@ class Stage
 
     dynamic_actors
   end
+  
+  def draw(target)
+    renderer.draw target
+  end
 
   def update(time)
     director.update time
-    @viewport.update time
+    viewport.update time
     @stagehands.each do |name, stagehand|
       stagehand.update time 
     end
@@ -72,77 +65,12 @@ class Stage
     timer_manager.update time
   end
 
-  def curtain_raising(*args)
-    curtain_up *args
-  end
-
-  def curtain_dropping(*args)
-    curtain_down *args
-  end
-
   def curtain_up(*args)
   end
 
   def curtain_down(*args)
   end
 
-  def draw(target)
-    z = 0
-    @parallax_layers.each do |parallax_layer|
-      drawables_on_parallax_layer = @drawables[parallax_layer]
-
-      if drawables_on_parallax_layer
-        @layer_orders[parallax_layer].each do |layer|
-
-          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, z
-          end
-        end
-      end
-    end
-  end
-
-  def unregister_drawable(drawable)
-    @drawables[drawable.parallax][drawable.layer].delete drawable
-  end
-
-  def clear_drawables
-    @drawables = {}
-    @layer_orders = {}
-    @parallax_layers = []
-  end
-
-  def register_drawable(drawable)
-    layer = drawable.layer
-    parallax = drawable.parallax
-    unless @drawables[parallax]
-      @drawables[parallax] = {}
-      @parallax_layers = @drawables.keys.sort.reverse
-    end
-    unless @drawables[parallax][layer]
-      @drawables[parallax][layer] = []
-      @layer_orders[parallax] = @drawables[parallax].keys.sort
-    end
-    @drawables[parallax][layer] << drawable
-  end
-
-  # move all actors from one layer to another
-  # note, this will remove all actors in that layer!
-  def move_layer(from_parallax, from_layer, to_parallax, to_layer)
-    drawable_list = @drawables[from_parallax][from_layer].dup
-
-    drawable_list.each do |drawable|
-      unregister_drawable drawable      
-      drawable.parallax = to_parallax
-      drawable.layer = to_layer
-      register_drawable drawable      
-    end
-  end
-
   def on_pause(&block)
     @pause_listeners ||= []
     @pause_listeners << block if block_given?
@@ -207,6 +135,22 @@ class Stage
     klass.new self, opts
   end
 
+  class << self
+
+    def define(stage_name, opts={}, &blk)
+      @definitions ||= {}
+      raise "Stage [#{stage_name}] already defined at #{@definitions[stage_name].source}" if @definitions[stage_name]
+
+      definition = StageDefinition.new
+      definition.source = caller.detect{|c|!c.match /core/}
+      definition.instance_eval &blk if block_given?
+      @definitions[stage_name] = definition
+    end
+
+    def definitions
+      @definitions ||= {}
+    end
+  end
 
 end
 

data/lib/gamebox/core/stage_definition.rb

@@ -0,0 +1,60 @@
+class StageDefinition
+  attr_accessor :curtain_up_block, :curtain_down_block, :renderer,
+    :helpers_block, :required_injections, :source
+
+  # Required objects that you need for your specific stage
+  # The objects will be created for you.
+  # example:
+  # define_stage :main_menu do
+  #   require :magic_thinger
+  # end
+  def requires(*injections_needed)
+    # kid.construct_with *self.object_definition.component_names
+    @required_injections = injections_needed
+  end
+
+  # Define a block of code to run when your stage is and ready to play
+  # example:
+  # define_stage :main_menu do
+  #   curtain_up do
+  #     @info = load_some_info
+  #   end
+  # end
+  def curtain_up(&curtain_up_block)
+    @curtain_up_block = curtain_up_block
+  end
+
+  # Define a block of code to run when your stage has been shutdown
+  # example:
+  # define_stage :main_menu do
+  #   curtain_down do
+  #     @info = load_some_info
+  #   end
+  # end
+  def curtain_down(&curtain_down_block)
+    @curtain_down_block = curtain_down_block
+  end
+
+  # Replaces the default renderer with your own.
+  # example:
+  #   define_stage :main_menu do
+  #     render_with :my_render
+  #     ...
+  #   end
+  def render_with(render_class_name)
+    @renderer = render_class_name
+  end
+
+  # Define any helper methods / include modules here
+  # These will be available for curtain_up / update / draw to use.
+  # example:
+  # define_stage :main_menu do
+  #   include MinMaxHelpers
+  #   def calculate_thinger
+  #     ...
+  #   end
+  # end
+  def helpers(&helpers_block)
+    @helpers_block = helpers_block
+  end
+end

data/lib/gamebox/core/stage_factory.rb

@@ -0,0 +1,56 @@
+class StageFactory
+  construct_with :this_object_context, :backstage
+
+  def build(stage_name, opts={})
+    this_object_context.in_subcontext do |stage_context|
+      begin
+        stage_context[:stage].tap do |stage|
+
+          stage_definition = Stage.definitions[stage_name]
+          raise "#{stage_name} not found in Stage.definitions" if stage_definition.nil?
+          # requires
+          reqs = stage_definition.required_injections
+          if reqs
+            reqs.each do |req|
+              object = stage_context[req]
+              stage.define_singleton_method req do
+                components[req] 
+              end
+              components = stage.send :components
+              components[req] = object
+            end
+          end
+
+          renderer_type = stage_definition.renderer || :renderer
+          renderer = stage_context[renderer_type]
+          stage_context[:renderer] = renderer unless renderer_type == :renderer
+          stage.define_singleton_method :renderer do
+            components[:renderer] 
+          end
+          components = stage.send :components
+          components[:renderer] = renderer
+
+          # helpers
+          helpers = stage_definition.helpers_block
+          if helpers
+            helpers_module = Module.new &helpers
+            stage.extend helpers_module
+          end
+
+          stage.configure(backstage, opts)
+
+          # setup
+          stage.define_singleton_method(:curtain_up, &stage_definition.curtain_up_block) if stage_definition.curtain_up_block
+          stage.define_singleton_method(:curtain_down, &stage_definition.curtain_down_block) if stage_definition.curtain_down_block
+        end
+
+      rescue Exception => e
+        raise """
+          #{stage_name} not found: 
+          #{e.inspect}
+          #{e.backtrace[0..6].join("\n")}
+        """
+      end
+    end
+  end
+end