gamebox 0.4.0.rc5 → 0.4.0.rc11

data/lib/gamebox/core/stage_manager.rb

@@ -1,7 +1,7 @@
 class StageManager
 
-  construct_with :input_manager, :config_manager, :backstage,
-    :this_object_context
+  construct_with :input_manager, :config_manager,
+    :stage_factory, :this_object_context
 
   attr_reader :stage_names, :stage_opts
 
@@ -78,13 +78,13 @@ class StageManager
     @stage = stage_name
     @stage_args = args
     @stages[@stage] = create_stage(@stage, @stage_opts[@stage_names.index(@stage)])
-    @stages[@stage].curtain_raising *args
+    @stages[@stage].curtain_up *args
   end
 
   def shutdown_current_stage(*args)
     if @stage and @stages and @stages[@stage]
       current_stage = @stages[@stage]
-      current_stage.curtain_dropping *args
+      current_stage.curtain_down *args
       input_manager.clear_hooks(current_stage)
       @stages.delete @stage
       @stage = nil
@@ -93,13 +93,7 @@ class StageManager
   end
 
   def create_stage(name, opts)
-    stage_instance = nil
-    this_object_context.in_subcontext do |stage_context|
-      name_or_klass = opts[:class] || name
-      stage_instance = stage_context["#{name_or_klass}_stage"]
-      stage_context[:stage] = stage_instance 
-    end
-    stage_instance.configure(backstage, opts)
+    stage_instance = stage_factory.build(name, opts)
 
     stage_instance.when :next_stage do |*args|
       next_stage *args

data/lib/gamebox/core/timer_manager.rb

@@ -3,6 +3,7 @@ class TimerManager
   def initialize
     @timers ||= {}
     @dead_timers = []
+    @callbacks = []
   end
 
   # add block to be executed every interval_ms millis
@@ -23,18 +24,21 @@ class TimerManager
 
   # update each timers counts, call any blocks that are over their interval
   def update(time_delta)
-    # TODO handle overwriting the same timer name...
+    @callbacks.clear
+    @dead_timers.clear
+
     @timers.each do |name, timer_hash|
       timer_hash[:count] += time_delta
       if timer_hash[:count] > timer_hash[:interval_ms]
         timer_hash[:count] -= timer_hash[:interval_ms]
-        timer_hash[:callback].call
+        @callbacks << timer_hash[:callback]
         @dead_timers << name unless timer_hash[:recurring]
       end
     end
     @dead_timers.each do |name|
       remove_timer name
     end
+    @callbacks.each &:call
   end
 
   def pause

data/lib/gamebox/core/viewport.rb

@@ -3,9 +3,11 @@
 class Viewport
   extend Publisher
   can_fire :scrolled
+
+  construct_with :config_manager
   
   attr_accessor :x_offset, :y_offset, :follow_target, :width,
-    :height, :x_offset_range, :y_offset_range, :boundary
+    :height, :x_offset_range, :y_offset_range, :boundary, :rotation
 
   attr_reader :speed
 
@@ -13,13 +15,18 @@ class Viewport
     "xoff:#{@x_offset} yoff:#{@y_offset}"
   end
 
-  def initialize(width, height)
+  def initialize
+    res = config_manager[:screen_resolution]
+    @width = res[0]
+    @height = res[1]
+    reset
+  end
+
+  def reset
+    @rotation = 0
     @speed = 1
     @x_offset = 0
     @y_offset = 0
-
-    @width = width
-    @height = height
   end
 
   def scroll(x_delta,y_delta)

data/lib/gamebox/core/wrapped_screen.rb

@@ -4,16 +4,15 @@ class WrappedScreen
   def initialize
     width, height = *config_manager[:screen_resolution]
     fullscreen = config_manager[:fullscreen]
-    needs_cursor = config_manager[:needs_cursor]
     @screen = HookedGosuWindow.new width, height, fullscreen
     @screen.tap do |screen|
-      screen.caption = config_manager[:title]
-      screen.needs_cursor = config_manager[:needs_cursor]
+      screen.caption = Gamebox.configuration.game_name
+      screen.needs_cursor = Gamebox.configuration.needs_cursor?
     end
   end
 
-  def method_missing(name,*args)
-    @screen.send name, *args
+  def method_missing(name,*args, &blk)
+    @screen.send name, *args, &blk
   end
 
   def width
@@ -129,5 +128,9 @@ class WrappedScreen
   def draw_image(image, x, y, z, x_scale = 1, y_scale = 1, color = 0xffffffff, mode = :default)
     image.draw x, y, z, x_scale, y_scale, color, mode
   end
+
+  def draw_rotated_image(image, x, y, z, angle, center_x = 0.5, center_y = 0.5, x_scale = 1, y_scale = 1, color = 0xffffffff, mode = :default)
+    image.draw_rot x, y, z, angle, center_x, center_y, x_scale, y_scale, color, mode
+  end
 end
   

data/lib/gamebox/gamebox_application.rb

@@ -3,12 +3,13 @@ $: << "#{File.dirname(__FILE__)}/../config"
 
 begin
   # optional file
-  require "environment" 
+  require "environment"
 rescue LoadError => err
 end
 
 class GameboxApp
   attr_reader :context, :game
+
   def self.run(argv,env)
     GameboxApp.new.start argv, env
   end
@@ -17,19 +18,16 @@ class GameboxApp
     @context = Conject.default_object_context
   end
 
-  def setup
-    @game = @context[:game]
-    @game.configure
-    @config_manager = @context[:config_manager]
-    setup_debug_server if @config_manager[:debug_server] || ARGV.include?("-debug-server")
+  def start(argv,env)
+    setup(argv,env)
+    main_loop
+    shutdown
   end
 
-  def setup_debug_server
-    Thread.new do
-      loop do
-        binding.remote_pry
-      end
-    end
+  def setup(argv,env)
+    @game = @context[:game]
+    @game.configure
+    self.class.post_setup_handlers.each { |handler| handler.setup(argv, env, @context[:config_manager]) }
   end
 
   def main_loop
@@ -38,18 +36,22 @@ class GameboxApp
     @input_manager.show
   end
 
-  def shutdown
-  end
-
-  def start(argv,env)
-    setup
+  def shutdown ; end
 
-    main_loop
+  def self.register_post_setup_handler(handler)
+    post_setup_handlers.push handler
+  end
 
-    shutdown
+  def self.post_setup_handlers
+    @post_setup_handlers ||= [ ]
   end
+
 end
 
+GameboxApp.register_post_setup_handler PostSetupHandlers::FileWatcher
+GameboxApp.register_post_setup_handler PostSetupHandlers::GameboxAppAddDebugHelpers
+GameboxApp.register_post_setup_handler PostSetupHandlers::PryRemoteServer
+
 if $0 == __FILE__
   GameboxApp.run ARGV, ENV
 end

data/lib/gamebox/lib/array_ext.rb

@@ -0,0 +1,9 @@
+class Array
+  def self.wrap(thing)
+    if thing.is_a? Array
+      thing
+    else
+      [thing]
+    end
+  end
+end

data/lib/gamebox/lib/observable_attributes.rb

@@ -1,5 +1,29 @@
 module ObservableAttributes
 
+  # atomically update all attributes
+  # it updates all of the values; then triggers the events
+  # my_actor.update_attributes(x: 5, y: 7)
+  # will emit both x_changed and y_changed after setting _both_ values
+  def update_attributes(attributes)
+    # TODO put this in kvo gem; there is too much internal knowlege of where
+    # kvo stores stuff 
+    #
+    # self.kvo_set('x', new_val, silent: true)
+    # self.changed('x', old_val, new_val)
+    old_values = attributes.keys.inject({}) do |hash, attr_name|
+      hash[attr_name] = self.send(attr_name)
+      hash
+    end
+
+    attributes.each do |name, val|
+      self.instance_variable_set("@kvo_#{name}", val)
+    end
+
+    attributes.each do |name, val|
+      fire "#{name}_changed".to_sym, old_values[name], val
+    end
+  end
+
   def has_attributes(*names)
     if names.first.is_a? Hash
       names.first.each do |name, default|

data/lib/gamebox/lib/vector2.rb

@@ -0,0 +1,432 @@
+#++
+# Copyright (C) 2008-2010  John Croisant
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights to
+# use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+# of the Software, and to permit persons to whom the Software is furnished to do
+# so, subject to the following conditions: # 
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.  # 
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+# The Vector2 class implements two-dimensional vectors.
+# It is used to represent positions, movements, and velocities
+# in 2D space.
+# 
+class Vector2
+  include Enumerable
+
+  RAD_TO_DEG = 180.0 / Math::PI
+  DEG_TO_RAD = Math::PI / 180.0
+
+  class << self
+
+    alias :[] :new
+
+
+    # Creates a new Vector2 from an angle in radians and a
+    # magnitude. Use #new_polar_deg for degrees.
+    # 
+    def new_polar( angle_rad, magnitude )
+      self.new( Math::cos(angle_rad)*magnitude,
+                Math::sin(angle_rad)*magnitude )
+    end
+
+
+    # Creates a new Vector2 from an angle in degrees and a
+    # magnitude. Use #new_polar for radians.
+    # 
+    def new_polar_deg( angle_deg, magnitude )
+      self.new_polar( angle_deg * DEG_TO_RAD, magnitude )
+    end
+
+
+    # call-seq:
+    #   Vector2.many( [x1,y1], [x2,y2], ... )
+    # 
+    # Converts multiple [x,y] Arrays to Vector2s.
+    # Returns the resulting vectors in an Array.
+    # 
+    def many( *pairs )
+      pairs.collect { |pair| self.new(*pair) }
+    end
+
+  end
+
+
+  # Creates a new Vector2 with the given x and y values.
+  def initialize( x, y )
+    @x, @y = x.to_f, y.to_f
+  end
+
+  attr_reader :x, :y
+
+  def x=( value )
+    raise "can't modify frozen object" if frozen?
+    @x = value.to_f
+    @hash = nil
+    self
+  end
+
+  def y=( value )
+    raise "can't modify frozen object" if frozen?
+    @y = value.to_f
+    @hash = nil
+    self
+  end
+
+
+  # Sets this vector's x and y components.
+  def set!( x, y )
+    raise "can't modify frozen object" if frozen?
+    @x = x.to_f
+    @y = y.to_f
+    @hash = nil
+    self
+  end
+
+
+  # Sets this vector's angle (in radians) and magnitude.
+  # Use #set_polar_deg! for degrees.
+  # 
+  def set_polar!( angle_rad, mag )
+    raise "can't modify frozen object" if frozen?
+    @x = Math::cos(angle_rad) * mag
+    @y = Math::sin(angle_rad) * mag
+    @hash = nil
+    self
+  end
+
+
+  # Sets this vector's angle (in degrees) and magnitude.
+  # Use #set_polar! for radians.
+  # 
+  def set_polar_deg!( angle_deg, mag )
+    set_polar!( angle_deg * DEG_TO_RAD, mag )
+    self
+  end
+
+
+  # Adds the given vector to this one and return the
+  # resulting vector.
+  # 
+  def +( vector )
+    self.class.new( @x + vector.at(0), @y + vector.at(1) )
+  end
+
+  # call-seq:
+  #   move!( [x,y] )
+  #   move!( x,y )
+  # 
+  # Moves the vector by the given x and y amounts.
+  def move!( x, y=nil )
+    raise "can't modify frozen object" if frozen?
+    if y.nil?
+      a = x.to_ary
+      @x += a[0]
+      @y += a[1]
+    else
+      @x += x
+      @y += y
+    end
+    @hash = nil
+    self
+  end
+
+  # call-seq:
+  #   move( [x,y] )
+  #   move( x,y )
+  # 
+  # Like #move!, but returns a new vector.
+  def move( x, y=nil )
+    self.dup.move!(x, y)
+  end
+
+
+  # Subtracts the given vector from this one and return
+  # the resulting vector.
+  # 
+  def -( vector )
+    self.class.new( @x - vector.at(0), @y - vector.at(1) )
+  end
+
+
+  # Returns the opposite of this vector, i.e. Vector2[-x, -y].
+  def -@
+    self.class.new( -@x, -@y )
+  end
+
+  # Reverses the vector's direction, i.e. Vector2[-x, -y].
+  def reverse!
+    raise "can't modify frozen object" if frozen?
+    @x, @y = -@x, -@y
+    @hash = nil
+    self
+  end
+
+  # Like #reverse!, but returns a new vector.
+  def reverse
+    self.dup.reverse!
+  end
+
+
+  # Multiplies this vector by the given scalar (Numeric),
+  # and return the resulting vector.
+  # 
+  def *( scalar )
+    self.class.new( @x * scalar, @y * scalar )
+  end
+
+
+  # True if the given vector's x and y components are
+  # equal to this vector's components (within a small margin
+  # of error to compensate for floating point imprecision).
+  # 
+  def ==( vector )
+    _nearly_equal?(@x, vector.at(0)) and _nearly_equal?(@y, vector.at(1))
+  end
+
+
+  # Returns a component of this vector as if it were an
+  # [x,y] Array.
+  # 
+  def []( index )
+    [@x, @y][index]
+  end
+
+  alias :at :[]
+
+
+  def hash # :nodoc:
+    @hash ||= (((@x - @x.modulo(1E-10)).hash << 2) +
+               ((@y - @y.modulo(1E-10)).hash << 1) +
+               self.class.hash)
+  end
+
+
+  # Iterates over this vector as if it were an [x,y] Array.
+  # 
+  def each( &block )
+    [@x, @y].each( &block )
+  end
+
+
+  # Returns the angle of this vector, relative to the positive
+  # X axis, in radians. Use #angle_deg for degrees.
+  # 
+  def angle
+    Math.atan2( @y, @x )
+  end
+
+
+  # Sets the vector's angle in radians. The vector keeps the same
+  # magnitude as before.
+  # 
+  def angle=( angle_rad )
+    raise "can't modify frozen object" if frozen?
+    m = magnitude
+    @x = Math::cos(angle_rad) * m
+    @y = Math::sin(angle_rad) * m
+    @hash = nil
+    self
+  end
+
+
+  # Returns the angle of this vector relative to the other vector,
+  # in radians. Use #angle_deg_with for degrees.
+  # 
+  def angle_with( vector )
+    Math.acos( udot(vector) )
+  end
+
+
+  # Returns the angle of this vector, relative to the positive
+  # X axis, in degrees. Use #angle for radians.
+  # 
+  def angle_deg
+    angle * RAD_TO_DEG
+  end
+
+
+  # Sets the vector's angle in degrees. The vector keeps the same
+  # magnitude as before.
+  # 
+  def angle_deg=( angle_deg )
+    self.angle = angle_deg * DEG_TO_RAD
+    self
+  end
+
+
+  # Returns the angle of this vector relative to the other vector,
+  # in degrees. Use #angle_with for radians.
+  # 
+  def angle_deg_with( vector )
+    angle_with(vector) * RAD_TO_DEG
+  end
+
+
+  # Returns the dot product between this vector and the other vector.
+  def dot( vector )
+    (@x * vector.at(0)) + (@y * vector.at(1))
+  end
+
+
+  # Returns the magnitude (distance) of this vector.
+  def magnitude
+    Math.hypot( @x, @y )
+  end
+
+
+  # Sets the vector's magnitude (distance). The vector keeps the
+  # same angle as before.
+  # 
+  def magnitude=( mag )
+    raise "can't modify frozen object" if frozen?
+    angle_rad = angle
+    @x = Math::cos(angle_rad) * mag
+    @y = Math::sin(angle_rad) * mag
+    @hash = nil
+    self
+  end
+
+
+  # Returns a copy of this vector, but rotated 90 degrees
+  # counter-clockwise.
+  # 
+  def perp
+    self.class.new( -@y, @x )
+  end
+
+
+  # Sets this vector to the vector projection (aka vector resolute)
+  # of this vector onto the other vector. See also #projected_onto.
+  # 
+  def project_onto!( vector )
+    raise "can't modify frozen object" if frozen?
+    @x, @y = *(vector * vector.dot(self) * (1/vector.magnitude**2))
+    @hash = nil
+    self
+  end
+
+  # Like #project_onto!, but returns a new vector.
+  def projected_onto( vector )
+    dup.project_onto!( vector )
+  end
+
+
+  # Rotates the vector the given number of radians.
+  # Use #rotate_deg! for degrees.
+  # 
+  def rotate!( angle_rad )
+    self.angle += angle_rad
+    self
+  end
+
+  # Like #rotate!, but returns a new vector.
+  def rotate( angle_rad )
+    dup.rotate!( angle_rad )
+  end
+
+
+  # Rotates the vector the given number of degrees.
+  # Use #rotate for radians.
+  # 
+  def rotate_deg!( angle_deg )
+    self.angle_deg += angle_deg
+    self
+  end
+
+  # Like #rotate_deg!, but returns a new vector.
+  def rotate_deg( angle_deg )
+    dup.rotate_deg!( angle_deg )
+  end
+
+
+  # call-seq:
+  #   scale!( scale )
+  #   scale!( scale_x, scale_y )
+  # 
+  # Multiplies this vector's x and y values.
+  #
+  # If one number is given, the vector will be equal to
+  # Vector2[x*scale, y*scale]. If two numbers are given, it will be
+  # equal to Vector2[x*scale_x, y*scale_y].
+  # 
+  # Example:
+  # 
+  #   v = Vector2[1.5,2.5]
+  #   v.scale!( 2 )           # => Vector2[3,5]
+  #   v.scale!( 3, 4 )        # => Vector2[9,20]
+  # 
+  def scale!( scale_x, scale_y = scale_x )
+    raise "can't modify frozen object" if frozen?
+    @x, @y = @x * scale_x, @y * scale_y
+    @hash = nil
+    self
+  end
+
+  # Like #scale!, but returns a new vector.
+  def scale( scale_x, scale_y = scale_x )
+    dup.scale!(scale_x, scale_y)
+  end
+
+
+  # Returns this vector as an [x,y] Array.
+  def to_ary
+    [@x, @y]
+  end
+
+  alias :to_a :to_ary
+
+
+  def to_s
+    "Vector2[#{@x}, #{@y}]"
+  end
+
+  alias :inspect :to_s
+
+
+  # Returns the dot product of this vector's #unit and the other
+  # vector's #unit.
+  # 
+  def udot( vector )
+    unit.dot( vector.unit )
+  end
+
+
+  # Sets this vector's magnitude to 1.
+  def unit!
+    raise "can't modify frozen object" if frozen?
+    scale = 1/magnitude
+    @x, @y = @x * scale, @y * scale
+    @hash = nil
+    self
+  end
+
+  alias :normalize! :unit!
+
+  # Like #unit!, but returns a new vector.
+  def unit
+    self.dup.unit!
+  end
+
+  alias :normalized :unit
+
+
+  private
+
+  def _nearly_equal?( a, b, threshold=1E-10 ) # :nodoc:
+    (a - b).abs <= threshold
+  end
+
+end