gamebox 0.3.4 → 0.4.0.rc1

data/README.txt

@@ -1,34 +0,0 @@
-= gamebox
-
-* http://shawn42.github.com/gamebox/
-
-== DESCRIPTION:
-
-  A game template for building and distributing Gosu games. See docs/getting_started.rdoc for help getting started.
-
-== FEATURES/PROBLEMS:
-
-* Quickly generate a game and have it up and running.
-
-== SYNOPSIS:
-
-  A game template for building and distributing Gosu games.
-
-== REQUIREMENTS:
-
-* Gosu
-* constructor gem
-* publisher gem
-* bundler
-* rspec (for gamebox tests)
-* algorithms gem (optional for line of site and A*)
-
-== INSTALL:
-
-* gem install gamebox; gamebox my_cool_game
-
-== LICENSE:
-
-(MIT)
-
-Copyright (c) 2009 Shawn Anderson

data/lib/gamebox/actor.rb

@@ -1,179 +0,0 @@
-# Actor represent a game object.
-# Actors can have behaviors added and removed from them. Such as :physical or :animated.
-# They are created and hooked up to their optional View class in Stage#create_actor.
-class Actor
-  include Kvo
-  
-  attr_accessor :behaviors, :stage, :input_manager,
-    :resource_manager, :alive, :opts, :visible, :director, 
-    :wrapped_screen,
-    :actor_type
-
-  # TODO change alive and visible to be KVO
-  kvo_attr_accessor :x, :y, :alive, :visible
-
-  can_fire_anything
-
-  DEFAULT_PARAMS = {
-    :x => 0,
-    :y => 0,
-  }.freeze
-
-  def initialize(opts={}) # :nodoc:
-    @opts = DEFAULT_PARAMS.merge opts
-    self.x = @opts[:x]
-    self.y = @opts[:y]
-
-    @stage = @opts[:stage]
-    @input_manager = @opts[:input]
-    @resource_manager = @opts[:resources]
-    @director = @opts[:director]
-    @actor_type = @opts[:actor_type]
-    @wrapped_screen = @opts[:wrapped_screen]
-    self.alive = true
-
-    @behaviors = {}
-
-    # add our classes behaviors and parents behaviors
-    klass = self.class
-    actor_klasses = []
-    while klass != Actor
-      actor_klasses << klass
-      klass = klass.superclass
-    end
-
-    behavior_defs = {}
-    ordered_behaviors = []
-    
-    actor_klasses.reverse.each do |actor_klass|
-      actor_behaviors = actor_klass.behaviors.dup
-      actor_behaviors.each do |behavior|
-
-        behavior_sym = behavior.is_a?(Hash) ? behavior.keys.first : behavior
-
-        ordered_behaviors << behavior_sym unless ordered_behaviors.include? behavior_sym
-        behavior_defs[behavior_sym] = behavior
-      end
-    end
-
-    ordered_behaviors.each do |behavior|
-      is behavior_defs[behavior] unless is? behavior
-    end
-    setup
-  end
-
-  # Called at the end of actor/behavior initialization. To be defined by the
-  # child class.
-  def setup
-  end
-
-  # Is the actor still alive?
-  def alive?
-    self.alive
-  end
-
-  def screen
-    @wrapped_screen
-  end
-
-  # Tells the actor's Director that he wants to be removed; and unsubscribes
-  # the actor from all input events.
-  def remove_self
-    self.alive = false
-    fire :remove_me
-    @input_manager.unsubscribe_all self
-  end
-
-  # Does this actor have this behavior?
-  def is?(behavior_sym)
-    !@behaviors[behavior_sym].nil?
-  end
-
-  # Adds the given behavior to the actor. Takes a symbol or a Hash.
-  #  act.is(:shootable) or act.is(:shootable => {:range=>3})
-  #  this will create a new instance of Shootable and pass
-  #  :range=>3 to it
-  #  Actor#is does try to require 'shootable' but will not throw an error if shootable cannot be required.
-  def is(behavior_def)
-    if behavior_def.is_a?(Hash)
-      behavior_sym = behavior_def.keys.first
-      behavior_opts = behavior_def.values.first
-    else
-      behavior_sym = behavior_def
-      behavior_opts = {}
-    end
-    klass = Object.const_get Inflector.camelize(behavior_sym)
-    @behaviors[behavior_sym] = klass.new self, behavior_opts
-  end
-
-  # removed the behavior from the actor.
-  def is_no_longer(behavior_sym)
-    behavior = @behaviors.delete behavior_sym
-    behavior.removed if behavior
-  end
-
-  # Calls update on all the actor's behaviors.
-  def update_behaviors(time)
-    for behavior in @behaviors.values
-      behavior.update time
-    end
-  end
-
-  # Creates a new actor and returns it. (This actor will automatically be added to the Director.
-  def spawn(type, args={})
-    @stage.spawn type, args
-  end
-
-  # Access to backstage for storage
-  def backstage
-    @stage.backstage
-  end
-
-  # to be defined in child class
-  def update(time)
-    # TODO maybe use a callback list for child classes
-    update_behaviors time
-  end
-  
-  def hide
-    fire :hide_me if visible?
-    self.visible = false
-  end
-  
-  def show
-    fire :show_me unless visible?
-    self.visible = true
-  end
-  
-  def visible?
-    self.visible
-  end
-
-  def viewport
-    @stage.viewport
-  end
-
-  def self.behaviors
-    @behaviors ||= []
-  end
-
-  def self.has_behaviors(*args)
-    @behaviors ||= []
-    for a in args
-      if a.is_a? Hash
-        for k,v in a 
-          h = {}
-          h[k]=v
-          @behaviors << h
-        end
-      else
-        @behaviors << a
-      end
-    end
-    @behaviors
-  end
-
-  def self.has_behavior(*args)
-    has_behaviors *args
-  end
-end

data/lib/gamebox/actor_factory.rb

@@ -1,57 +0,0 @@
-
-# ActorFactory is responsible for loading all Actors. It passes along required params such as 
-# stage, input_manager, director, resource_manager. It also creates the ActorView 
-# associated with the Actor and registers it to the Stage be drawn. 
-class ActorFactory
-  constructor :input_manager, :wrapped_screen
-
-  attr_accessor :stage_manager, :director
-  
-  # Returns a hash of actor params {:model_klass=>k, :view_klass=>v}. This is for performance reasons.
-  def cached_actor_def(actor)
-    @actor_cache ||= {}
-    cached_actor = @actor_cache[actor]
-    return cached_actor if cached_actor
-
-    model_klass = ClassFinder.find(actor)
-    raise "#{actor} not found" unless model_klass
-    
-    view_klass = ClassFinder.find("#{actor}_view")
-    
-    actor_def = {
-      :model_klass => model_klass,
-      :view_klass => view_klass
-    }
-    @actor_cache[actor] = actor_def
-    actor_def
-  end
-
-  # returns the newly created Actor after it and its ActorView has been created.
-  def build(actor, stage, opts={})
-    actor_def = cached_actor_def actor
-
-    basic_opts = {
-      :stage => stage,
-      :input => @input_manager,
-      :director => @director,
-      :resources => stage.resource_manager,
-      :actor_type => actor,
-      :wrapped_screen => @wrapped_screen
-    }
-    merged_opts = basic_opts.merge(opts)
-    model = actor_def[:model_klass].new merged_opts 
-
-    view_klass = opts[:view]
-    view_klass ||= actor_def[:view_klass]
-    
-    if model.is? :animated or model.is? :graphical or model.is? :physical
-      view_klass ||= GraphicalActorView
-    end
-    
-    view_klass.new stage, model, @wrapped_screen if view_klass
-    
-    model.show unless opts[:hide]
-
-    return model
-  end
-end

data/lib/gamebox/actor_view.rb

@@ -1,44 +0,0 @@
-class ActorView
-  attr_accessor :actor, :stage, :layer, :parallax, :wrapped_screen
-  def initialize(stage, actor, wrapped_screen)
-    @stage = stage
-    @actor = actor
-    @wrapped_screen = wrapped_screen
-
-    @layer = 0
-    @parallax = 1
-    if @actor.is? :layered
-      @layer = @actor.layer
-      @parallax = @actor.parallax
-    end
-
-    actor.when :remove_me do unregister end
-    
-    actor.when :hide_me do unregister  end
-    
-    actor.when :show_me do register end
-    
-    setup
-  end
-  
-  def register
-    @stage.register_drawable self
-  end
-  
-  def unregister
-    @stage.unregister_drawable self
-  end
-
-  def setup
-  end
-
-  def screen_width
-    @screen_width ||= @wrapped_screen.width
-  end
-
-  def screen_height
-    @screen_height ||= @wrapped_screen.height
-  end
-
-end
-

data/lib/gamebox/actors/spatial_debugger.rb

@@ -1,62 +0,0 @@
-
-
-
-class SpatialDebugger < Actor
-  
-  has_behavior :updatable
-
-  attr_reader :spatial, :ratio
-  def setup
-    @spatial = stage.stagehand(:spatial)
-  end
-
-  def update(time)
-    super
-    if stage.checks && stage.checks > 0
-      @ratio = "size:#{@spatial.cell_size} #{stage.collisions} / #{stage.checks} ("
-      @ratio += "#{stage.collisions / stage.checks.to_f})"
-    else
-      @ratio = "N/A"
-    end
-  end
-  
-end
-
-class SpatialDebuggerView < ActorView
-  def setup
-    # size = 30
-    # font = "Asimov.ttf"
-    # @font = @actor.resource_manager.load_font font, size
-  end
-
-  def draw(target,x_off,y_off, z)
-    vp = stage.viewport
-    cell_size = @actor.spatial.cell_size
-    max = 0
-    @actor.spatial.buckets.each do |x_bucket,stuff|
-      stuff.each do |y_bucket,items|
-        # max = items.size if items.size > max
-        x = x_bucket * cell_size + x_off
-        y = y_bucket * cell_size + y_off
-        target.draw_box x, y, x+cell_size, y+cell_size, [255,25,25], z
-
-        # Yes I know I may be drawing this many times for an actor
-        items.each do |item|
-          # puts "#{item.class}: [#{item.center_x}, #{item.center_y}] #{item.collidable_shape}"
-          parallax = 1
-          ix = item.center_x + x_off
-          iy = item.center_y + y_off
-
-          target.draw_box ix, iy, ix + 2, iy + 2, [255,255,255], 10
-
-          # TODO make work for non circles
-          r = item.radius
-          target.draw_box ix-r, iy-r, ix + r, iy + r, [255,255,255], 10
-        end
-      end
-    end
-
-    # @text_image = @font.render "#{@actor.ratio} [#{max}]", true, Color[:white]
-    # @text_image.blit target.screen, [@actor.x, @actor.y]
-  end
-end

data/lib/gamebox/behavior.rb

@@ -1,70 +0,0 @@
-# Behavior is any type of behavior an actor can exibit.
-class Behavior
-  attr_accessor :actor, :opts, :relegated_methods
-
-  def initialize(actor,opts={})
-    @actor = actor
-    @opts = opts
-    @relegated_methods = []
-
-    req_behs = self.class.required_behaviors
-    req_behs.each do |beh|
-      unless @actor.is? beh
-        @actor.is beh
-      end
-    end
-    setup
-  end
-
-  def setup
-  end
-
-  def removed
-    target = self
-
-    @actor.instance_eval do
-      (class << self; self; end).class_eval do
-        target.relegated_methods.each do |meth|
-          remove_method meth
-        end
-      end
-    end
-  end
-
-  def update(time)
-  end
-
-  def self.required_behaviors
-    @required_behaviors ||= []
-  end
-
-  def self.requires_behaviors(*args)
-    @required_behaviors ||= []
-    for a in args
-      @required_behaviors << a
-    end
-    @behaviors
-  end
-
-  def self.requires_behavior(*args)
-    requires_behaviors(*args)
-  end
-
-  def relegates(*methods)
-    target = self
-
-    @actor.instance_eval do
-      (class << self; self; end).class_eval do
-        methods.each do |meth|
-          # log("redefining #{meth} for #{@actor.class}") if @actor.respond_to? meth
-          target.relegated_methods << meth
-
-          define_method meth do |*args, &block|
-            target.send meth, *args, &block
-          end
-        end
-      end
-    end
-  end
-
-end