gamebox 0.3.4 → 0.4.0.rc1

data/lib/gamebox/core/actor_factory.rb

@@ -0,0 +1,56 @@
+
+# ActorFactory is responsible for loading all Actors. It also creates the ActorView 
+# associated with the Actor and registers it to the Stage be drawn. 
+class ActorFactory
+  construct_with :input_manager, :wrapped_screen, :resource_manager,
+    :behavior_factory, :actor_view_factory, :this_object_context
+
+  # returns the newly created Actor after it and its ActorView has been created.
+  def build(actor, opts={})
+    merged_opts = opts.merge(actor_type: actor)
+
+    model = nil
+    this_object_context.in_subcontext do |actor_context|
+      begin
+        model = actor_context[:actor]
+
+        actor_definition = Actor.definitions[actor]
+        raise "#{actor} not found in Actor.definitions" if actor_definition.nil?
+        model.configure(merged_opts)
+
+        actor_definition.behaviors.each do |behavior|
+          beh_opts = {}
+          beh_key = behavior
+
+          if behavior.is_a?(Hash)
+            beh_opts = behavior.values.first
+            beh_key = behavior.keys.first
+          end
+
+          behavior_factory.add_behavior(model, beh_key, beh_opts)
+        end
+
+        actor_view_factory.build model, opts
+      rescue Exception => e
+        # binding.pry
+        raise """
+          #{actor} not found: 
+          #{e.inspect}
+          #{e.backtrace[0..6].join("\n")}
+        """
+      end
+    end
+    model
+  end
+
+  def class_ancestors(actor)
+    klass = actor.class
+    [].tap { |actor_klasses|
+      while klass != Actor
+        actor_klasses << klass
+        klass = klass.superclass
+      end
+    }
+  end
+
+end

data/lib/gamebox/core/actor_view.rb

@@ -0,0 +1,63 @@
+class ActorView
+  construct_with :stage, :wrapped_screen, :resource_manager, :actor
+  public :stage, :wrapped_screen, :resource_manager, :actor
+
+  attr_accessor :layer, :parallax
+  def initialize
+    @layer = actor.do_or_do_not(:layer) || 0
+    @parallax = actor.do_or_do_not(:parallax) || 1
+
+    # TODO clean up the show/hide here make nice with visible behavior?
+    actor.when :remove_me do unregister  end
+    actor.when :hide_me   do unregister  end
+    actor.when :show_me   do register    end
+    
+  end
+
+  def register
+    stage.register_drawable self
+  end
+  
+  def unregister
+    stage.unregister_drawable self
+  end
+
+  def screen_width
+    @screen_width ||= wrapped_screen.width
+  end
+
+  def screen_height
+    @screen_height ||= wrapped_screen.height
+  end
+
+  class << self
+    def define(actor_view_type, &blk)
+      @definitions ||= {}
+      definition = ActorViewDefinition.new
+      definition.instance_eval &blk if block_given?
+      @definitions[actor_view_type] = definition
+    end
+
+    def definitions
+      @definitions ||= {}
+    end
+  end
+
+  # TODO can these defs be unified?
+  class ActorViewDefinition
+    attr_accessor :draw_block, :configure_block, :required_injections
+    def requires(*injections_needed)
+      @required_injections = injections_needed
+    end
+
+    def configure(&configure_block)
+      @configure_block = configure_block
+    end
+
+    def draw(&draw_block)
+      @draw_block = draw_block
+    end
+  end
+
+
+end

data/lib/gamebox/core/actor_view_factory.rb

@@ -0,0 +1,40 @@
+
+# ActorViewFactory is responsible for loading all ActorViews. It creates the ActorView 
+# associated with the Actor and registers it to the Stage be drawn. 
+class ActorViewFactory
+  construct_with :behavior_factory
+
+  # builds a new ActorView and configures it per its definition that is setup via ActorView.define
+  def build(actor, opts={})
+    # TODO  have animated, graphical, physical set a view attr on actor
+    view_klass = opts[:view] || actor.do_or_do_not(:view) || "#{actor.actor_type}_view"
+    view_definition = ActorView.definitions[view_klass.to_sym]
+    view = nil
+    if view_definition
+      actor_context = actor.this_object_context
+      view = actor_context[:actor_view]
+      reqs = view_definition.required_injections
+      if reqs
+        reqs.each do |req|
+          object = actor_context[req]
+          view.define_singleton_method req do
+            components[req] 
+          end
+          components = view.send :components
+          components[req] = object
+        end
+      end
+
+      view.define_singleton_method :draw, &view_definition.draw_block if view_definition.draw_block
+      if view_definition.configure_block
+        view.define_singleton_method :configure, &view_definition.configure_block 
+        view.configure
+      end
+
+      behavior_factory.add_behavior(actor, :visible, view: view)
+      actor.react_to :show unless opts[:hide]
+    end
+    view
+  end
+
+end

data/lib/gamebox/{arbiter.rb → core/arbiter.rb}

@@ -3,11 +3,11 @@ module Arbiter
   attr_reader :checks, :collisions
 
   def register_collidable(actor)
-    stagehand(:spatial).add(actor)
+    stagehand(:spatial_tree).add(actor)
   end
 
   def unregister_collidable(actor)
-    stagehand(:spatial).remove(actor)
+    stagehand(:spatial_tree).remove(actor)
   end
 
   def on_collision_of(first_objs, second_objs, &block)
@@ -52,35 +52,33 @@ module Arbiter
     end
   end
 
+  def interested_in_collision_of?(type1, type2)
+    @collision_handlers ||= {}
+    (@collision_handlers[type1] && @collision_handlers[type1][type2]) ||
+    (@collision_handlers[type2] && @collision_handlers[type2][type1])
+  end
+
   def find_collisions
-    spatial_hash = stagehand(:spatial)
-    collidable_actors = spatial_hash.moved_items
-    @checks = 0
-    @collisions = 0
+    aabb_tree = stagehand(:spatial_tree)
+    collidable_actors = aabb_tree.moved_items.values
+
     collisions = {}
 
     collidable_actors.each do |first|
-      x = first.x - spatial_hash.cell_size
-      y = first.y - spatial_hash.cell_size
-      # TODO base this on size of object
-      w = spatial_hash.cell_size * 3
-      h = w
-
-      tmp_collidable_actors = spatial_hash.neighbors_of(first)
-
-      if first.is? :collidable
-        tmp_collidable_actors.each do |second|
-          @checks += 1
-          if second.is? :collidable
-            if first != second && collide?(first, second)
-              collisions[second] ||= []
-              if !collisions[second].include?(first)
-                @collisions += 1
+      # if first.is? :collidable
+        # HUH? it appears that querying modifies the tree somehow?
+        aabb_tree.collisions(first) do |second|
+
+          # if second.is? :collidable
+            if first != second &&
+              interested_in_collision_of?(first.actor_type, second.actor_type) &&
+              collide?(first, second)
+              if !collisions[second] || (collisions[second] && !collisions[second].include?(first))
                 collisions[first] ||= []
                 collisions[first] << second
               end
-            end
-          end
+          #   end
+          # end
         end
       end
     end
@@ -90,17 +88,16 @@ module Arbiter
         unique_collisions << [first,second]
       end
     end
-
     run_callbacks unique_collisions
+    aabb_tree.reset
   end
 
+
+
   def collide?(object, other)
-    if !other.is? :collidable
-      binding.pry
-    end
-    case object.collidable_shape
+    case object.shape_type
     when :circle
-      case other.collidable_shape
+      case other.shape_type
       when :circle
         collide_circle_circle? object, other
       when :aabb
@@ -109,7 +106,7 @@ module Arbiter
         collide_circle_polygon? object, other
       end
     when :aabb
-      case other.collidable_shape
+      case other.shape_type
       when :circle
         collide_aabb_circle? object, other
       when :aabb
@@ -118,7 +115,7 @@ module Arbiter
         collide_aabb_polygon? object, other
       end
     when :polygon
-      case other.collidable_shape
+      case other.shape_type
       when :circle
         collide_polygon_circle? object, other
       when :aabb
@@ -159,8 +156,8 @@ module Arbiter
 
   # returns true if the projections overlap
   def project_and_detect(axis, a, b)
-    a_min, a_max = send("#{a.collidable_shape}_interval", axis, a)
-    b_min, b_max = send("#{b.collidable_shape}_interval", axis, b)
+    a_min, a_max = send("#{a.shape_type}_interval", axis, a)
+    b_min, b_max = send("#{b.shape_type}_interval", axis, b)
 
     a_min <= b_max && b_min <= a_max
   end

data/lib/gamebox/core/behavior.rb

@@ -0,0 +1,64 @@
+# Behavior is any type of behavior an actor can exibit.
+class Behavior
+  construct_with :actor
+
+  attr_accessor :opts
+
+  def configure(opts={})
+    @opts = opts
+    setup
+  end
+
+  def setup
+  end
+
+  def reacts_with(*messages_with_methods)
+    @message_handlers = messages_with_methods
+  end
+
+  def react_to(message_type, *opts)
+    # TODO perf analysis, should I use a hash here?
+    if @message_handlers && @message_handlers.include?(message_type)
+      send message_type, *opts
+    end
+  end
+
+  class << self
+
+    def define(behavior_type, &blk)
+      @definitions ||= {}
+      definition = BehaviorDefinition.new
+      definition.instance_eval &blk if block_given?
+      @definitions[behavior_type] = definition
+    end
+
+    def definitions
+      @definitions ||= {}
+    end
+  end
+
+  class BehaviorDefinition
+    attr_accessor :setup_block, :required_injections, :react_to_block, :required_behaviors,
+      :helpers_block
+
+    def requires(*injections_needed)
+      @required_injections = injections_needed
+    end
+
+    def requires_behaviors(*behaviors_needed)
+      @required_behaviors = behaviors_needed
+    end
+
+    def setup(&setup_block)
+      @setup_block = setup_block
+    end
+
+    def react_to(&react_to_block)
+      @react_to_block = react_to_block
+    end
+
+    def helpers(&helpers_block)
+      @helpers_block = helpers_block
+    end
+  end
+end

data/lib/gamebox/core/behavior_factory.rb

@@ -0,0 +1,56 @@
+# BehaviorFactory is in charge of creating all behaviors and placing them in an Actor.
+# Everything you want an Actor to _do_ is part of a Behavior. Actors are stupid buckets of data.
+# Behaviors can be created by:
+#   has_behavior in an Actor's class definition
+#   or by dynamically creating one at runtime via another behavior.
+class BehaviorFactory
+
+  # Build a behavior. Takes a symbol or a Hash.
+  #  add_behavior(:shootable) or add_behavior(:shootable => {:range=>3})
+  #  this will create a new instance of Shootable and pass
+  #  :range=>3 to it
+  def add_behavior(actor, behavior_name, opts = {})
+    raise "nil actor" if actor.nil?
+    raise "nil behavior definition" if behavior_name.nil?
+
+    behavior_definition = Behavior.definitions[behavior_name]
+
+    raise "unknown behavior #{behavior_name}" unless behavior_definition
+    context = actor.this_object_context
+    context.in_subcontext do |behavioral_context|
+      behavioral_context[:behavior].tap do |behavior|
+        reqs = behavior_definition.required_injections
+        if reqs
+          reqs.each do |req|
+            object = context[req]
+            behavior.define_singleton_method req do
+              components[req] 
+            end
+            components = behavior.send :components
+            components[req] = object
+          end
+        end
+
+        helpers = behavior_definition.helpers_block
+        if helpers
+          helpers_module = Module.new &helpers
+          behavior.extend helpers_module
+        end
+
+        behavior.define_singleton_method :react_to, behavior_definition.react_to_block if behavior_definition.react_to_block
+
+        deps = behavior_definition.required_behaviors
+        if deps
+          deps.each do |beh|
+            add_behavior actor, beh unless actor.has_behavior?(beh)
+          end
+        end
+        behavior.configure(opts)
+        behavior.instance_eval &behavior_definition.setup_block if behavior_definition.setup_block
+        actor.add_behavior behavior_name, behavior
+      end
+    end
+  end
+
+
+end

data/lib/gamebox/{config_manager.rb → core/config_manager.rb}

@@ -21,7 +21,7 @@ class ConfigManager
 
   # TODO make this path include that app name?
   def load_config(name)
-    conf = YAML::load_file(CONFIG_PATH + name + ".yml")
+    conf = YAML::load_file("#{Gamebox.configuration.config_path}#{name}.yml")
     user_file = "#{ENV['HOME']}/.gamebox/#{name}.yml"
     if File.exist? user_file
       user_conf = YAML::load_file user_file

data/lib/gamebox/core/configuration.rb

@@ -0,0 +1,39 @@
+module Gamebox
+  # Pattern stolen from rspec for configuration
+  class Configuration
+    def self.add_setting(name, opts={})
+      if opts[:alias]
+        alias_method name, opts[:alias]
+        alias_method "#{name}=", "#{opts[:alias]}="
+        alias_method "#{name}?", "#{opts[:alias]}?"
+      else
+        define_method("#{name}=") {|val| settings[name] = val}
+        define_method(name)       { settings.has_key?(name) ? settings[name] : opts[:default] }
+        define_method("#{name}?") { send name }
+      end
+    end
+
+    # add_setting :output, :alias => :output_stream
+    add_setting :config_path
+    add_setting :data_path
+    add_setting :music_path
+    add_setting :sound_path
+    add_setting :gfx_path
+    add_setting :fonts_path
+
+    add_setting :gb_config_path
+    add_setting :gb_data_path
+    add_setting :gb_music_path
+    add_setting :gb_sound_path
+    add_setting :gb_gfx_path
+    add_setting :gb_fonts_path
+  
+    add_setting :game_name, default: "Untitled Game"
+
+    add_setting :stages, default: [:demo]
+
+    def settings
+      @settings ||= {}
+    end
+  end
+end