lotu 0.1.7 → 0.1.9

data/VERSION

@@ -1 +1 @@
-0.1.7
+0.1.9

data/examples/hello_world/hello_world.rb

@@ -7,13 +7,16 @@ class MovingRuby < Lotu::Actor
 
   def initialize(opts={})
     super
+    # Use the image which filename is CptnRuby Gem.png
     set_image 'CptnRuby Gem.png'
+    # Map keys to some methods
     set_keys(KbRight => :move_right,
              KbLeft => :move_left,
              KbUp => :move_up,
              KbDown => :move_down)
   end
 
+  # Let's define some basic movement methods
   def move_right
     @x += 1
   end
@@ -35,14 +38,25 @@ end
 class Example < Lotu::Window
 
   def initialize
+    # This will call the hooks:
+    # load_resources, setup_systems and setup_actors
+    # declared in the parent class
     super
+    # When the Escape key is pressed, call the close method on class Example
     set_keys(KbEscape => :close)
+  end
 
+  def load_resources
+    # From this file,
     with_path_from_file(__FILE__) do
-      load_images '../media'
+      # go back one dir and search inside media/
+      load_images '../media/'
     end
+  end
 
+  def setup_actors
     @ruby = MovingRuby.new(:x => width/2, :y => height/2)
+    # Create a TextBox so we can display a message on screen
     @info = Lotu::TextBox.new
     @info.text("Move around with arrow keys")
   end

data/examples/mouse_pointer/mouse_pointer.rb

@@ -16,13 +16,27 @@ end
 
 class Example < Lotu::Window
   def initialize
+    # This will call the hooks:
+    # load_resources, setup_systems and setup_actors
+    # declared in the parent class
     super
-    set_keys KbEscape => :close
+    # Custom setup methods for this class
+    setup_input
+    setup_events
+  end
 
+  def load_resources
     with_path_from_file(__FILE__) do
       load_images '../media'
     end
+  end
+
+  def setup_systems
+    use(Lotu::FpsSystem)
+    use(Lotu::StalkerSystem, :stalk => [Lotu::Actor, Lotu::InputController, Object])
+  end
 
+  def setup_actors
     @ruby = WarpingRuby.new(:x => width/2, :y => height/2)
     @cursor1 = Lotu::Cursor.new(:image => 'crosshair.png',
                                 :keys => {MsLeft => [:click, false]},
@@ -36,25 +50,33 @@ class Example < Lotu::Window
                                   KbLeft => :left,
                                   KbRight => :right},
                                 :color => 0xff99ff00)
+    @cursor2.x = width*3/4
+    @cursor2.y = height/2
+
+    # Create a TextBox with default option :size => 15
+    @info = Lotu::TextBox.new(:size => 15)
+    @info.watch(@systems[Lotu::FpsSystem])
+    @info.watch(@systems[Lotu::StalkerSystem])
+    # We can change the size for a specific line of text
+    @info.watch("@cursor1 data:", :size => 20)
+    # Color too
+    @info.watch(@cursor1, :color => 0xff0099ff)
+    @info.watch("@cursor2 data:", :size => 20)
+    @info.watch(@cursor2, :color => 0xff99ff00)
+    @info.text("Move @cursor1 with mouse and @cursor2 with arrow keys (click with space!)")
+  end
+
+  def setup_input
+    set_keys KbEscape => :close
+  end
 
+  def setup_events
     @cursor1.on(:click) do |x,y|
       @ruby.warp(x,y)
     end
     @cursor2.on(:click) do |x,y|
       @ruby.warp(x,y)
     end
-
-    @cursor2.x = width*3/4
-    @cursor2.y = height/2
-
-    @info = Lotu::TextBox.new
-    @info.watch(@fps_counter)
-    @info.watch("@cursor1 data:")
-    @info.watch(@cursor1, :color => 0xff0099ff, :font_size => 15)
-    @info.watch("@cursor2 data:")
-    @info.watch(@cursor2, :color => 0xff99ff00, :font_size => 15)
-    @info.text("")
-    @info.text("Move @cursor1 with mouse and @cursor2 with arrow keys (click with space!)", :font_size => 15)
   end
 
 end

data/examples/steering_behaviors/steering.rb

@@ -7,7 +7,7 @@ class SteeringRuby < Lotu::Actor
   def initialize(opts={})
     super
     set_image 'CptnRuby Gem.png'
-    activate_system(Lotu::Steering, opts)
+    use(Lotu::SteeringSystem, opts)
   end
 
   def warp(x, y)
@@ -17,14 +17,31 @@ end
 
 class Example < Lotu::Window
   def initialize
+    # This will call the hooks:
+    # load_resources, setup_systems and setup_actors
+    # declared in the parent class
     super
-    set_keys(KbEscape => :close,
-             MsRight => :reset_ruby)
+    # Custom setup methods for this class
+    setup_input
+    setup_events
+  end
 
+  def load_resources
     with_path_from_file(__FILE__) do
       load_images '../media'
     end
+  end
+
+  def setup_input
+    set_keys(KbEscape => :close,
+             MsRight => :reset_ruby)
+  end
+
+  def setup_systems
+    use(Lotu::FpsSystem)
+  end
 
+  def setup_actors
     @ruby = SteeringRuby.new(:mass => 0.3, :max_speed => 100, :max_turn_rate => 140)
     @ruby.warp(width/2, height/2)
     @ruby.activate(:evade)
@@ -34,21 +51,24 @@ class Example < Lotu::Window
 
     @cursor = Lotu::Cursor.new(:image => 'crosshair.png',
                                :keys => {MsLeft => [:click, false]})
-    @cursor.on(:click) do |x,y|
-      @ruby.pursuer = @ruby2
-      @ruby2.evader = @ruby
-    end
 
-    @window_info = Lotu::TextBox.new(:font_size => 15)
-    @window_info.watch(@fps_counter, :font_size => 20)
+    @window_info = Lotu::TextBox.new(:size => 15)
+    @window_info.watch(@systems[Lotu::FpsSystem])
     @window_info.watch(@cursor, :color => 0xffff0000)
     @window_info.text("Click to start the simulation")
     @window_info.text("One will pursuit while the other evades, right click to center evader on screen")
 
-    @ruby_info = Lotu::TextBox.new(:attach_to => @ruby, :font_size => 14)
+    @ruby_info = Lotu::TextBox.new(:attach_to => @ruby, :size => 14)
     @ruby_info.watch(@ruby)
   end
 
+  def setup_events
+    @cursor.on(:click) do |x,y|
+      @ruby.pursuer = @ruby2
+      @ruby2.evader = @ruby
+    end
+  end
+
   def reset_ruby
     @ruby.pos.x = width/2
     @ruby.pos.y = height/2

data/lib/lotu/actor.rb

@@ -2,6 +2,8 @@ module Lotu
   class Actor
     attr_accessor :parent, :x, :y, :systems
 
+    include SystemUser
+
     def initialize(opts={})
       default_opts = {
         :x => 0,
@@ -32,10 +34,6 @@ module Lotu
       @parent.update_queue.delete(self)
     end
 
-    def activate_system(klass, opts={})
-      @systems[klass] = klass.new(self, opts)
-    end
-
     def update
       @systems.each_pair do |klass, system|
         system.update

data/lib/lotu/behaviors/collidable.rb

@@ -11,7 +11,7 @@ module Lotu
 
     def collides_as(tag)
       @collision_tag = tag
-      @parent.systems[:collision].add_entity(self, tag)
+      @parent.systems[CollisionSystem].add_entity(self, tag)
     end
 
     def collides_with(other)
@@ -20,7 +20,7 @@ module Lotu
 
     def die
       super
-      @parent.systems[:collision].remove_entity(self, @collision_tag)
+      @parent.systems[CollisionSystem].remove_entity(self, @collision_tag)
     end
 
   end

data/lib/lotu/behaviors/system_user.rb

@@ -0,0 +1,10 @@
+module Lotu
+  module SystemUser
+
+    # Allows to activate a system in the host
+    def use(klass, opts={})
+      @systems[klass] = klass.new(self, opts)
+    end
+
+  end
+end

data/lib/lotu/misc/string.rb

@@ -0,0 +1,14 @@
+# As saw in a russian comment by ZARATUSTR at:
+# http://kpumuk.info/ruby-on-rails/colorizing-console-ruby-script-output/
+class String
+
+  def red; colorize(self, "\e[1m\e[31m") end
+  def green; colorize(self, "\e[1m\e[32m") end
+  def dark_green; colorize(self, "\e[32m") end
+  def yellow; colorize(self, "\e[1m\e[33m") end
+  def blue; colorize(self, "\e[1m\e[34m") end
+  def dark_blue; colorize(self, "\e[34m") end
+  def pur; colorize(self, "\e[1m\e[35m") end
+  def colorize(text, color_code) "#{color_code}#{text}\e[0m" end
+
+end

data/lib/lotu/systems/collision_system.rb

@@ -0,0 +1,41 @@
+module Lotu
+  class CollisionSystem
+
+    def initialize(user, opts={})
+      user.extend UserMethods
+      @entities = Hash.new{ |h,k| h[k] = [] }
+      @actions = {}
+    end
+
+    def add_entity(obj, tag)
+      @entities[tag] << obj
+    end
+
+    def remove_entity(obj, tag)
+      @entities[tag].delete(obj)
+    end
+
+    def when_colliding(type1, type2, &blk)
+      @actions[[type1, type2]] = blk
+    end
+
+    def update
+      @actions.each do |tags, blk|
+        @entities[tags[0]].each do |ent1|
+          @entities[tags[1]].each do |ent2|
+            blk.call(ent1, ent2) if ent1.collides_with(ent2)
+          end
+        end
+      end
+    end
+
+    def draw;end
+
+    module UserMethods
+      def when_colliding(*args, &blk)
+        systems[CollisionSystem].when_colliding(*args, &blk)
+      end
+    end
+
+  end
+end

data/lib/lotu/systems/fps_system.rb

@@ -0,0 +1,32 @@
+module Lotu
+  class FpsSystem
+
+    def initialize(user, opts={})
+      default_opts = {
+        :samples => 10
+      }
+      opts = default_opts.merge!(opts)
+      @accum = 0.0
+      @ticks = 0
+      @fps = 0.0
+      @samples = opts[:samples]
+    end
+
+    def update
+      @ticks += 1
+      @accum += $window.dt
+      if @ticks >= @samples
+        @fps = @ticks/@accum
+        @ticks = 0
+        @accum = 0.0
+      end
+    end
+
+    def to_s
+      "Samples per second: #{@samples} | FPS: #{format("%.2f",@fps)}"
+    end
+
+    def draw;end
+
+  end
+end

data/lib/lotu/systems/stalker_system.rb

@@ -0,0 +1,30 @@
+module Lotu
+  class StalkerSystem
+
+    def initialize(user, opts={})
+      default_opts = {
+        :stalk => [Actor]
+      }
+      opts = default_opts.merge!(opts)
+      @stalked = {}
+      opts[:stalk].each do |type|
+        @stalked[type] = 0
+      end
+    end
+
+    def update
+      @stalked.each_key do |type|
+        @stalked[type] = ObjectSpace.each_object(type).count
+      end
+    end
+
+    def to_s
+      @stalked.map do |type, count|
+        "#{type}: #{count}"
+      end
+    end
+
+    def draw;end
+
+  end
+end

data/lib/lotu/systems/{steering.rb → steering_system.rb}

@@ -1,11 +1,10 @@
 # -*- coding: utf-8 -*-
 module Lotu
-  class Steering
-    attr_reader :force
+  class SteeringSystem
 
-    def initialize(actor, opts={})
+    def initialize(user, opts={})
       # Add new functionality to Actor
-      actor.extend ActorMethods
+      user.extend UserMethods
 
       # Initialize attributes
       default_opts = {
@@ -18,20 +17,20 @@ module Lotu
       }
       opts = default_opts.merge!(opts)
 
-      actor.mass = opts[:mass]
-      actor.max_speed = opts[:max_speed]
-      actor.max_turn_rate = opts[:max_turn_rate]
-      actor.max_force = opts[:max_force]
-      actor.wander_radius = opts[:wander_radius]
-      actor.wander_distance = opts[:wander_distance]
+      user.mass = opts[:mass]
+      user.max_speed = opts[:max_speed]
+      user.max_turn_rate = opts[:max_turn_rate]
+      user.max_force = opts[:max_force]
+      user.wander_radius = opts[:wander_radius]
+      user.wander_distance = opts[:wander_distance]
 
       # More attributes
-      @actor = actor
+      @user = user
       @behaviors = {}
       @force = Vector2d.new
       @zero = Vector2d.new
-      actor.pos.x = actor.x
-      actor.pos.y = actor.y
+      user.pos.x = user.x
+      user.pos.y = user.y
     end
 
     def update
@@ -40,32 +39,32 @@ module Lotu
         @force += send(behavior) if active
       end
 
-      @actor.accel = @force / @actor.mass
-      @actor.accel.truncate!(@actor.max_force)
+      @user.accel = @force / @user.mass
+      @user.accel.truncate!(@user.max_force)
 
-      max_angle = @actor.max_turn_rate * @actor.dt
-      new_velocity = @actor.vel + @actor.accel * @actor.dt
-      angle_to_new_velocity = @actor.heading.angle_to(new_velocity)
+      max_angle = @user.max_turn_rate * @user.dt
+      new_velocity = @user.vel + @user.accel * @user.dt
+      angle_to_new_velocity = @user.heading.angle_to(new_velocity)
 
       if angle_to_new_velocity.abs > max_angle
-        sign = @actor.heading.sign_to(new_velocity)
-        corrected_angle = @actor.heading.angle + max_angle * sign
-        @actor.vel.x = Gosu.offset_x(corrected_angle, new_velocity.length)
-        @actor.vel.y = Gosu.offset_y(corrected_angle, new_velocity.length)
+        sign = @user.heading.sign_to(new_velocity)
+        corrected_angle = @user.heading.angle + max_angle * sign
+        @user.vel.x = Gosu.offset_x(corrected_angle, new_velocity.length)
+        @user.vel.y = Gosu.offset_y(corrected_angle, new_velocity.length)
       else
-        @actor.vel = new_velocity
+        @user.vel = new_velocity
       end
 
-      @actor.vel.truncate!(@actor.max_speed)
-      @actor.pos += @actor.vel * @actor.dt
+      @user.vel.truncate!(@user.max_speed)
+      @user.pos += @user.vel * @user.dt
 
-      if @actor.vel.length > 0.0001
-        @actor.heading = @actor.vel.normalize
+      if @user.vel.length > 0.0001
+        @user.heading = @user.vel.normalize
       end
 
-      @actor.x = @actor.pos.x
-      @actor.y = @actor.pos.y
-      @actor.angle = @actor.heading.angle
+      @user.x = @user.pos.x
+      @user.y = @user.pos.y
+      @user.angle = @user.heading.angle
     end
 
     def activate(behavior)
@@ -78,61 +77,61 @@ module Lotu
 
     # The steering behaviors themselves
     def seek
-      return @zero if @actor.target.nil?
-      desired_velocity = (@actor.target - @actor.pos).normalize * @actor.max_speed
-      return desired_velocity - @actor.vel
+      return @zero if @user.target.nil?
+      desired_velocity = (@user.target - @user.pos).normalize * @user.max_speed
+      return desired_velocity - @user.vel
     end
 
     def flee
-      return @zero if @actor.target.nil?
-      desired_velocity = (@actor.pos - @actor.target).normalize * @actor.max_speed
-      return desired_velocity - @actor.vel
+      return @zero if @user.target.nil?
+      desired_velocity = (@user.pos - @user.target).normalize * @user.max_speed
+      return desired_velocity - @user.vel
     end
 
     def arrive(deceleration = :normal)
-      return @zero if @actor.target.nil?
+      return @zero if @user.target.nil?
       deceleration_values = {
         :fast => 0.5,
         :normal => 1,
         :slow => 2
       }
       deceleration_tweaker = 1.0
-      to_target = @actor.target - @actor.pos
+      to_target = @user.target - @user.pos
       distance_to_target = to_target.length
 
       if distance_to_target > 10
         speed = distance_to_target / (deceleration_tweaker * deceleration_values[deceleration])
-        speed = [speed, @actor.max_speed].min
+        speed = [speed, @user.max_speed].min
         desired_velocity = to_target * speed / distance_to_target
-        return desired_velocity - @actor.vel
+        return desired_velocity - @user.vel
       else
-        @actor.vel /= 1.15
-        @actor.accel /= 1.15
+        @user.vel /= 1.15
+        @user.accel /= 1.15
       end
       return @zero
     end
 
     def pursuit
-      return @zero if @actor.evader.nil?
-      to_evader = @actor.evader.pos - @actor.pos
-      relative_heading = @actor.heading.dot(@actor.evader.heading)
-      if to_evader.dot(@actor.heading) > 0 && relative_heading < -0.95
-        @actor.target = @actor.evader.pos
+      return @zero if @user.evader.nil?
+      to_evader = @user.evader.pos - @user.pos
+      relative_heading = @user.heading.dot(@user.evader.heading)
+      if to_evader.dot(@user.heading) > 0 && relative_heading < -0.95
+        @user.target = @user.evader.pos
         return seek
       end
 
-      look_ahead_time = to_evader.length / (@actor.max_speed + @actor.evader.vel.length)
-      predicted_position = @actor.evader.pos + @actor.evader.vel * look_ahead_time
-      @actor.target = predicted_position
+      look_ahead_time = to_evader.length / (@user.max_speed + @user.evader.vel.length)
+      predicted_position = @user.evader.pos + @user.evader.vel * look_ahead_time
+      @user.target = predicted_position
       return seek
     end
 
     def evade
-      return @zero if @actor.pursuer.nil?
-      to_pursuer = @actor.pursuer.pos - @actor.pos
-      look_ahead_time = to_pursuer.length / (@actor.max_speed + @actor.pursuer.vel.length)
-      predicted_position = @actor.pursuer.pos + @actor.pursuer.vel * look_ahead_time
-      @actor.target = @actor.pursuer.pos
+      return @zero if @user.pursuer.nil?
+      to_pursuer = @user.pursuer.pos - @user.pos
+      look_ahead_time = to_pursuer.length / (@user.max_speed + @user.pursuer.vel.length)
+      predicted_position = @user.pursuer.pos + @user.pursuer.vel * look_ahead_time
+      @user.target = @user.pursuer.pos
       return flee
     end
 
@@ -140,12 +139,12 @@ module Lotu
     def wander
       wander_jitter = 10
 
-      @actor.wander_target += Vector2d.new(Gosu.random(-1,1), Gosu.random(-1,1))
-      @actor.wander_target.normalize!
-      @actor.wander_target *= @actor.wander_radius
-      target_local = @actor.wander_target + Vector2d.new(0, @actor.wander_distance)
-      target_world = local_to_world(target_local, @actor.heading, @actor.heading.perp, @actor.pos)
-      return target_world - @actor.pos
+      @user.wander_target += Vector2d.new(Gosu.random(-1,1), Gosu.random(-1,1))
+      @user.wander_target.normalize!
+      @user.wander_target *= @user.wander_radius
+      target_local = @user.wander_target + Vector2d.new(0, @user.wander_distance)
+      target_world = local_to_world(target_local, @user.heading, @user.heading.perp, @user.pos)
+      return target_world - @user.pos
     end
 
     def local_to_world(local_target, heading, side, pos)
@@ -155,14 +154,14 @@ module Lotu
       world_point = Vector2d.new(x, y) + pos
     end
 
-    module ActorMethods
+    module UserMethods
 
       def self.extended(instance)
         instance.steering_setup
       end
 
       def steering_setup
-        # Create accessors for the actor
+        # Create accessors for the user
         class << self
           attr_accessor :mass, :pos, :heading, :vel, :accel,
           :max_speed, :max_turn_rate, :max_force,
@@ -181,7 +180,7 @@ module Lotu
       end
 
       def activate(behavior)
-        @systems[Steering].activate(behavior)
+        @systems[SteeringSystem].activate(behavior)
       end
 
       def distance_to_target

data/lib/lotu/text_box.rb

@@ -4,15 +4,14 @@ module Lotu
 
     def initialize(opts={})
       default_opts = {
-        :font_size => 20
+        :size => 20
       }
       opts = default_opts.merge!(opts)
       super(opts)
       #TODO puede especificar a quién watchear y sus opciones de
       #dibujado en los parámetros
       @watch_list = []
-      @subject_opts = {}
-      @font_size = opts[:font_size]
+      @size = opts[:size]
       @attached_to = opts[:attach_to]
       # Since we aren't setting an image for this, we need to specify
       # this actor needs to be drawed
@@ -24,8 +23,7 @@ module Lotu
     end
 
     def watch(subject, opts={})
-      @watch_list << subject
-      @subject_opts[subject] = opts
+      @watch_list << [subject, opts]
     end
 
     def attach_to(actor)
@@ -41,17 +39,17 @@ module Lotu
 
     def draw
       pos_y = 0
-      @watch_list.each do |watched|
-        my_font_size = @subject_opts[watched][:font_size] || @font_size
-        my_color = @subject_opts[watched][:color] || @color
+      @watch_list.each do |watched, opts|
+        my_size = opts[:size] || @size
+        my_color = opts[:color] || @color
         my_text = watched.to_s
         if my_text.is_a?(String)
-          $window.fonts[my_font_size].draw(my_text, @x, @y + pos_y, @z, @factor_x, @factor_y, my_color)
-          pos_y += my_font_size
+          $window.fonts[my_size].draw(my_text, @x, @y + pos_y, @z, @factor_x, @factor_y, my_color)
+          pos_y += my_size
         else
           my_text.each do |line|
-            $window.fonts[my_font_size].draw(line, @x, @y + pos_y, @z, @factor_x, @factor_y, my_color)
-            pos_y += my_font_size
+            $window.fonts[my_size].draw(line, @x, @y + pos_y, @z, @factor_x, @factor_y, my_color)
+            pos_y += my_size
           end
         end
       end

data/lib/lotu/window.rb

@@ -1,52 +1,99 @@
 module Lotu
   class Window < Gosu::Window
-    # delta time
+    # Accessors for time delta, systems and fonts
     attr_reader :dt, :systems, :fonts
-    attr_accessor :update_queue, :draw_queue, :input_listeners, :font
+    # Accessors for queues
+    attr_accessor :update_queue, :draw_queue, :input_listeners
+
+    include SystemUser
 
     def initialize(params={})
       super(800, 600, false)
 
       # Handy global window variable
       $window = self
+      @debug = true
+      setup_containers
 
-      # Systems setup
-      @systems = {}
-      @update_queue = []
-      @draw_queue = []
-      @input_register = Hash.new{|hash,key| hash[key] = []}
-
-      @fps_counter = FpsCounter.new
+      # For timer initialization
       @last_time = Gosu::milliseconds
+      # Memoize fonts by size
       @fonts = Hash.new{|h,k| h[k] = Gosu::Font.new(self, Gosu::default_font_name, k)}
 
       # Add extra functionality
       extend Controllable
-      extend Resourceful
-      extend Systems::Collision
+
+      # Call hook methods
+      load_resources
+      setup_systems
+      setup_actors
     end
 
+
+    # Hook methods, these are meant to be replaced by subclasses
+    def load_resources;end
+    def setup_systems;end
+    def setup_actors;end
+
+    # Setup various containers
+    def setup_containers
+      # For systems
+      @systems = {}
+
+      # For queues
+      @update_queue = []
+      @draw_queue = []
+      @input_register = Hash.new{|hash,key| hash[key] = []}
+
+      # For resource management
+      @images = {}
+      @sounds = {}
+      @songs = {}
+      @animations = {}
+    end
+
+    # Main update loop
     def update
       new_time = Gosu::milliseconds
       @dt = (new_time - @last_time)/1000.0
       @last_time = new_time
-      @fps_counter.update(@dt)
 
+      # Update each system
       @systems.each_value do |system|
         system.update
       end
 
-      @update_queue.each do |item|
-        item.update
+      # Update each actor
+      @update_queue.each do |actor|
+        actor.update
       end
     end
 
+    # Main draw loop
     def draw
-      @draw_queue.each do |item|
-        item.draw
+      # Systems may report interesting stuff
+      @systems.each_value do |system|
+        system.draw
+      end
+
+      # Draw each actor in queue
+      @draw_queue.each do |actor|
+        actor.draw
       end
     end
 
+    # For actor management
+    def manage_me(actor)
+      @draw_queue << actor
+      @update_queue << actor
+    end
+
+    def kill_me(actor)
+      @draw_queue.delete(actor)
+      @update_queue.delete(actor)
+    end
+
+    # These are for managing input
     def button_down(id)
       @input_register[id].each do |item|
         item.button_down(id)
@@ -59,7 +106,6 @@ module Lotu
       end
     end
 
-    # Register controller
     def register_for_input(controller)
       controller.keys.each_key do |key|
         @input_register[key] << controller
@@ -67,8 +113,79 @@ module Lotu
       @update_queue << controller
     end
 
-    def register_for_draw(object)
-      @draw_queue << object
+    # These are for managing resources
+    def image(name)
+      @images[name]
+    end
+
+    def sound(name)
+      @sounds[name]
+    end
+
+    def song(name)
+      @songs[name]
     end
+
+    def animation(name)
+      @animations[name]
+    end
+
+    def load_images(path)
+      with_files(/\.png|\.jpg|\.bmp/, path) do |file_name, file_path|
+        @images[file_name] = Gosu::Image.new($window, file_path)
+      end
+    end
+
+    def load_sounds(path)
+      with_files(/\.ogg|\.mp3|\.wav/, path) do |file_name, file_path|
+        @sounds[file_name] = Gosu::Sample.new($window, file_path)
+      end
+    end
+
+    def load_songs(path)
+      with_files(/\.ogg|\.mp3|\.wav/, path) do |file_name, file_path|
+        @songs[file_name] = Gosu::Song.new($window, file_path)
+      end
+    end
+
+    def load_animations(path)
+      path = File.expand_path(File.join(@path, path))
+      puts "Loading from: #{path}"
+
+      count = 0
+      Dir.entries(path).grep(regexp).each do |entry|
+        begin
+          @animations[entry] = klass.new($window, File.join(path, entry))
+          count += 1
+        rescue Exception => e
+          puts e, File.join(path, entry)
+        end
+      end
+      puts "#{count} #{klass} files loaded."
+    end
+
+    def with_path_from_file(path, &blk)
+      @path = File.expand_path(File.dirname path)
+      yield
+    end
+
+    def with_files(regexp, path)
+      path = File.expand_path(File.join(@path, path))
+      puts "\nLoading from: #{path}"
+
+      count = 0
+      Dir.entries(path).grep(regexp).each do |entry|
+        begin
+          yield(entry, File.join(path, entry))
+          count += 1
+          print '.'.green
+        rescue Exception => e
+          print '.'.red
+          puts e, File.join(path, entry) if @debug
+        end
+      end
+      puts "\n#{count} file(s) loaded."
+    end
+
   end
 end

data/lib/lotu.rb

@@ -2,7 +2,7 @@ LOTU_ROOT = File.expand_path(File.join(File.dirname(__FILE__), 'lotu'))
 $LOAD_PATH.unshift(LOTU_ROOT)
 
 require 'gosu'
-%w{fps vector2d}.each{|file| require "misc/#{file}"}
-%w{collidable controllable resourceful drawable controllable/input_controller eventful}.each{|file| require "behaviors/#{file}"}
-%w{collision steering}.each{|file| require "systems/#{file}"}
+%w{vector2d string}.each{|file| require "misc/#{file}"}
+%w{system_user collidable controllable drawable controllable/input_controller eventful}.each{|file| require "behaviors/#{file}"}
+%w{stalker_system fps_system collision_system steering_system}.each{|file| require "systems/#{file}"}
 %w{window actor cursor text_box}.each{|file| require file}

data/lotu.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{lotu}
-  s.version = "0.1.7"
+  s.version = "0.1.9"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["lobo_tuerto"]
-  s.date = %q{2010-03-22}
+  s.date = %q{2010-03-25}
   s.description = %q{lotu aims to bring an agile and simple game development framework to life. It provides useful abstractions so you can concentrate on developing your game.}
   s.email = %q{dev@lobotuerto.com}
   s.extra_rdoc_files = [
@@ -52,12 +52,14 @@ Gem::Specification.new do |s|
      "lib/lotu/behaviors/controllable/input_controller.rb",
      "lib/lotu/behaviors/drawable.rb",
      "lib/lotu/behaviors/eventful.rb",
-     "lib/lotu/behaviors/resourceful.rb",
+     "lib/lotu/behaviors/system_user.rb",
      "lib/lotu/cursor.rb",
-     "lib/lotu/misc/fps.rb",
+     "lib/lotu/misc/string.rb",
      "lib/lotu/misc/vector2d.rb",
-     "lib/lotu/systems/collision.rb",
-     "lib/lotu/systems/steering.rb",
+     "lib/lotu/systems/collision_system.rb",
+     "lib/lotu/systems/fps_system.rb",
+     "lib/lotu/systems/stalker_system.rb",
+     "lib/lotu/systems/steering_system.rb",
      "lib/lotu/text_box.rb",
      "lib/lotu/window.rb",
      "lotu.gemspec",

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 1
-  - 7
-  version: 0.1.7
+  - 9
+  version: 0.1.9
 platform: ruby
 authors: 
 - lobo_tuerto
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-03-22 00:00:00 -06:00
+date: 2010-03-25 00:00:00 -06:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -76,12 +76,14 @@ files:
 - lib/lotu/behaviors/controllable/input_controller.rb
 - lib/lotu/behaviors/drawable.rb
 - lib/lotu/behaviors/eventful.rb
-- lib/lotu/behaviors/resourceful.rb
+- lib/lotu/behaviors/system_user.rb
 - lib/lotu/cursor.rb
-- lib/lotu/misc/fps.rb
+- lib/lotu/misc/string.rb
 - lib/lotu/misc/vector2d.rb
-- lib/lotu/systems/collision.rb
-- lib/lotu/systems/steering.rb
+- lib/lotu/systems/collision_system.rb
+- lib/lotu/systems/fps_system.rb
+- lib/lotu/systems/stalker_system.rb
+- lib/lotu/systems/steering_system.rb
 - lib/lotu/text_box.rb
 - lib/lotu/window.rb
 - lotu.gemspec

data/lib/lotu/behaviors/resourceful.rb

@@ -1,61 +0,0 @@
-# Add methods to load and access images, sounds & songs
-module Lotu
-  module Resourceful
-
-    def self.extended(instance)
-      instance.init_behavior
-    end
-
-    def init_behavior
-      @images = {}
-      @sounds = {}
-      @songs = {}
-    end
-
-    def image(name)
-      @images[name]
-    end
-
-    def sound(name)
-      @sounds[name]
-    end
-
-    def song(name)
-      @songs[name]
-    end
-
-    def load_images(path)
-      load_resources(@images, /\.png|\.jpg|\.bmp/, path, Gosu::Image)
-    end
-
-    def load_sounds(path)
-      load_resources(@sounds, /\.ogg|\.mp3|\.wav/, path, Gosu::Sample)
-    end
-
-    def load_songs(path)
-      load_resources(@songs, /\.ogg|\.mp3|\.wav/, path, Gosu::Song)
-    end
-
-    def with_path_from_file(path, &blk)
-      @path = File.expand_path(File.dirname path)
-      yield
-    end
-
-    def load_resources(container, regexp, path, klass)
-      path = File.expand_path(File.join(@path, path))
-      puts "Loading from: #{path}"
-
-      count = 0
-      Dir.entries(path).grep(regexp).each do |entry|
-        begin
-          container[entry] = klass.new($window, File.join(path, entry))
-          count += 1
-        rescue Exception => e
-          puts e, File.join(path, entry)
-        end
-      end
-      puts "#{count} #{klass} files loaded."
-    end
-
-  end
-end

data/lib/lotu/misc/fps.rb

@@ -1,28 +0,0 @@
-class FpsCounter
-  attr_reader :fps
-  
-  def initialize(samples = 10)
-    @accum = 0.0
-    @ticks = 0
-    @fps = 0.0
-    @samples = samples
-    @objs = @actors = @input_controllers = 0
-  end
-
-  def update(dt)
-    @ticks += 1
-    @accum += dt
-    if @ticks >= @samples
-      @fps = @ticks/@accum
-      @ticks = 0
-      @accum = 0.0
-      @objs = ObjectSpace.each_object.count
-      @actors = ObjectSpace.each_object(Lotu::Actor).count
-      @inputs = ObjectSpace.each_object(Lotu::InputController).count
-    end
-  end
-
-  def to_s
-    "@samples(#{@samples}) @fps(#{format("%.2f",@fps)}) @objs(#{@objs}) @actors(#{@actors}) @inputs(#{@inputs})"
-  end
-end

data/lib/lotu/systems/collision.rb

@@ -1,46 +0,0 @@
-module Lotu
-  module Systems
-
-    module Collision
-      def self.extended(instance)
-        instance.systems[:collision] = CollisionSystem.new
-      end
-
-      def when_colliding(*args, &blk)
-        systems[:collision].when_colliding(*args, &blk)
-      end
-    end
-
-    class CollisionSystem
-
-      def initialize
-        @entities = Hash.new{ |h,k| h[k] = [] }
-        @actions = {}
-      end
-
-      def add_entity(obj, tag)
-        @entities[tag] << obj
-      end
-
-      def remove_entity(obj, tag)
-        @entities[tag].delete(obj)
-      end
-
-      def when_colliding(type1, type2, &blk)
-        @actions[[type1, type2]] = blk
-      end
-
-      def update
-        @actions.each do |tags, blk|
-          @entities[tags[0]].each do |ent1|
-            @entities[tags[1]].each do |ent2|
-              blk.call(ent1, ent2) if ent1.collides_with(ent2)
-            end
-          end
-        end
-      end
-
-    end
-
-  end
-end