lotu 0.1.3 → 0.1.4

data/.gitignore

@@ -19,3 +19,4 @@ rdoc
 pkg
 
 ## PROJECT::SPECIFIC
+TODO

data/README.rdoc

@@ -1,10 +1,13 @@
-== Development just started!
-So bear with me while this framework is in a primordial state. But fear not, it's shaping up pretty nicely! :D
-
 = lotu
 A simple, agile Ruby game development framework.
 
 == Install
+The preferred way to try it out is cloning from github:
+
+  git clone git://github.com/lobo-tuerto/lotu.git
+
+The is a gem right now, but while the API stabilizes it is not updated as often as the github repo.
+
   gem install lotu
 
 == Description
@@ -23,17 +26,24 @@ So, what can you do if you spot some patters here, a few more there? well, you d
 If you have any questions of suggestions don't hesitate and send me a message!
 
 
-== Features (planned)
-* Easy way to manage input, rendering, updating, etc. (check!)
-* Utility classes for viewports, game states, etc. (this is comming next!)
-* Simple access to game resources (images, sounds, songs, etc). (check!)
+== Features
+* Easy way to manage input, rendering, updating, etc.
+* Simple access to game resources (images, sounds, songs, etc).
+* Steering behaviors
+
+
+== Coming features
+* Utility classes for viewports, game states, etc.
+* Pathfinding and more AI stuff
 
 
 == Other frameworks
-I saw another framework around called Chingu, 
-It's been around for a little while and I recommend you take a look at it:
+I saw another framework around called *Chingu*, It's been around for a little while and I recommend you take a look at it:
 http://github.com/ippa/chingu
 
+There is also *gamebox*, it's based on Rubygame though:
+http://github.com/shawn42/gamebox
+
 I did find many of the ideas I have for my framework already implemented in it. But be sure I will take inspiration from many others. ;)
 Nevertheless I'm doing this because I want to become better at architecturing software. And this seems like fitting practice. :D
 

data/TODO

@@ -0,0 +1,4 @@
+* Work metaphors for Gamestate & Viewport (Scene & Camera) ?
+* Input system
+* AI system (steering behaviors, pathfinding, etc)
+* Make gems (number to words, vector2d)

data/VERSION

@@ -1 +1 @@
-0.1.3
+0.1.4

data/examples/hello_world/hello_world.rb

@@ -5,7 +5,7 @@ include Gosu::Button
 
 class MovingRuby < Lotu::Actor
 
-  def initialize
+  def initialize(opts={})
     super
     set_image 'CptnRuby Gem.png'
     set_keys(KbRight => :move_right,
@@ -36,18 +36,13 @@ class Example < Lotu::Window
 
   def initialize
     super
-    set_keys KbEscape => :close
+    set_keys(KbEscape => :close)
 
     with_path(__FILE__) do
       load_images '../media'
     end
 
-    @ruby = MovingRuby.new
-  end
-
-  def draw
-    super
-    @fps_counter.draw
+    @ruby = MovingRuby.new(:x => width/2, :y => height/2)
   end
 
 end

data/examples/mouse_pointer/mouse_pointer.rb

@@ -25,7 +25,8 @@ class Example < Lotu::Window
 
     @ruby = WarpingRuby.new
     @cursor1 = Lotu::Cursor.new(:image => 'crosshair.png',
-                                :keys => {MsLeft => [:click, false]})
+                                :keys => {MsLeft => [:click, false]},
+                                :color => 0xff0099ff)
     @cursor2 = Lotu::Cursor.new(:image => 'crosshair.png',
                                 :use_mouse => false,
                                 :keys => {
@@ -33,8 +34,8 @@ class Example < Lotu::Window
                                   KbUp => :up,
                                   KbDown => :down,
                                   KbLeft => :left,
-                                  KbRight => :right
-                                })
+                                  KbRight => :right},
+                                :color => 0xff99ff00)
 
     @cursor1.on(:click) do |x,y|
       @ruby.warp(x,y)
@@ -42,14 +43,18 @@ class Example < Lotu::Window
     @cursor2.on(:click) do |x,y|
       @ruby.warp(x,y)
     end
-  end
 
-  def draw
-    super
-    @fps_counter.draw
-    @font.draw("@cursor1: #{@cursor1.clicked_x}, #{@cursor1.clicked_y}", 10, 30, 0, 1.0, 1.0, 0xfffff000)
-    @font.draw("@cursor2: #{@cursor2.clicked_x}, #{@cursor2.clicked_y}", 10, 30+@font.height, 0, 1.0, 1.0, 0xfffff000)
+    @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)
   end
+
 end
 
 Example.new.show

data/examples/steering_behaviors/steering.rb

@@ -0,0 +1,56 @@
+#!/usr/bin/env ruby
+LIB_PATH = File.join(File.dirname(__FILE__), '..', '..', 'lib', 'lotu.rb')
+require File.expand_path(LIB_PATH)
+include Gosu::Button
+
+class SteeringRuby < Lotu::Actor
+  def initialize(opts={})
+    super
+    set_image 'CptnRuby Gem.png'
+    activate_system(Lotu::Steering, opts)
+  end
+
+  def warp(x, y)
+    @pos.x, @pos.y = x, y
+  end
+end
+
+class Example < Lotu::Window
+  def initialize
+    super
+    set_keys(KbEscape => :close,
+             MsRight => :reset_ruby)
+
+    with_path __FILE__ do
+      load_images '../media'
+    end
+
+    @ruby = SteeringRuby.new(:mass => 0.3, :max_speed => 100, :max_turn_rate => 140)
+    @ruby.warp(width/2, height/2)
+    @ruby.activate(:evade)
+
+    @ruby2 = SteeringRuby.new
+    @ruby2.activate(:pursuit)
+
+    @cursor = Lotu::Cursor.new(:image => 'crosshair.png',
+                               :keys => {MsLeft => [:click, false]})
+    @cursor.on(:click) do |x,y|
+      @ruby.pursuer = @ruby2#Lotu::Vector2d.new(x, y)
+      @ruby2.evader = @ruby
+    end
+
+    @window_info = Lotu::TextBox.new
+    @window_info.watch(@fps_counter)
+    @window_info.watch(@cursor, :color => 0xffff0000)
+
+    @ruby_info = Lotu::TextBox.new(:attach_to => @ruby, :font_size => 16)
+    @ruby_info.watch(@ruby)
+  end
+
+  def reset_ruby
+    @ruby.pos.x = width/2
+    @ruby.pos.y = height/2
+  end
+end
+
+Example.new.show

data/lib/lotu/actor.rb

@@ -1,6 +1,6 @@
 module Lotu
   class Actor
-    attr_accessor :parent, :x, :y
+    attr_accessor :parent, :x, :y, :systems
 
     def initialize(opts={})
       default_opts = {
@@ -20,6 +20,8 @@ module Lotu
       self.extend Controllable
       self.extend Eventful
       self.extend Collidable
+
+      @systems = {}
     end
 
     # Easy access to delta-time
@@ -32,6 +34,17 @@ module Lotu
       @parent.update_queue.delete(self)
     end
 
-    def update;end
+    def activate_system(klass, opts={})
+      @systems[klass] = klass.new(self, opts)
+    end
+
+    def update
+      @systems.each_pair do |klass, system|
+        system.update
+      end
+    end
+
+    def draw;end
+
   end
 end

data/lib/lotu/behaviors/drawable.rb

@@ -6,25 +6,36 @@ module Lotu
     end
 
     def init_behavior
+      class << self
+        attr_accessor :angle
+      end
+
       @image = nil
-      @color = 0xffffffff
       @z = 0
       @angle = 0.0
       @center_x = 0.5
       @center_y = 0.5
       @factor_x = 1.0
       @factor_y = 1.0
-      @color = 0xffffffff
       @mode = :default
     end
 
+    def draw_me
+      @parent.draw_queue << self unless @parent.draw_queue.include?(self)
+    end
+
+    def image
+      @image
+    end
+
     def set_image(image)
       @image = @parent.image(image)
-      @parent.draw_queue << self unless @parent.draw_queue.include?(self)
+      draw_me
     end
 
     def draw
-      @image.draw_rot(@x, @y, @z, @angle, @center_x, @center_y, @factor_x, @factor_y, @color, @mode)
+      super
+      @image.draw_rot(@x, @y, @z, @angle, @center_x, @center_y, @factor_x, @factor_y, @color, @mode) unless @image.nil?
     end
 
     def die

data/lib/lotu/behaviors/resourceful.rb

@@ -46,9 +46,7 @@ module Lotu
       puts "Loading from: #{path}"
 
       count = 0
-      Dir.entries(path).select do |entry|
-        entry =~ regexp
-      end.each do |entry|
+      Dir.entries(path).grep(regexp).each do |entry|
         begin
           container[entry] = klass.new($window, File.join(path, entry))
           count += 1

data/lib/lotu/cursor.rb

@@ -60,5 +60,9 @@ module Lotu
       adjust_mouse if use_mouse
     end
 
+    def to_s
+      "@pos(#{format('%.2f, %.2f', @x, @y)}) @clicked(#{format('%.2f, %.2f', @clicked_x, @clicked_y)})"
+    end
+
   end
 end

data/lib/lotu/{fps.rb → misc/fps.rb}

@@ -22,11 +22,7 @@ class FpsCounter
     end
   end
 
-  def draw
-    $window.font.draw("FPS: #{to_s}", 10, 10, 0, 1.0, 1.0, 0xffffff00)
-  end
-
   def to_s
-    "Samples: #{@samples} FPS: #{format("%.2f",@fps)} Objs: #{@objs} Acts: #{@actors} InputsCs: #{@inputs}"
+    "@samples(#{@samples}) @fps(#{format("%.2f",@fps)}) @objs(#{@objs}) @actors(#{@actors}) @inputs(#{@inputs})"
   end
 end

data/lib/lotu/misc/vector2d.rb

@@ -0,0 +1,124 @@
+module Lotu
+  class Vector2d
+    attr_reader :x, :y
+
+    def self.up
+      new(0, -1)
+    end
+
+    def initialize(x=0, y=0)
+      clear_cache
+      @x = Float(x)
+      @y = Float(y)
+    end
+
+    def clear_cache
+      @length = nil
+      @length_sq = nil
+      @normalized = false
+    end
+
+    def zero!
+      self.x = 0
+      self.y = 0
+    end
+
+    def zero?
+      @x == 0 && @y == 0
+    end
+
+    def length
+      @length ||= Math.sqrt(length_sq)
+    end
+
+    def length_sq
+      @length_sq ||= @x*@x + @y*@y
+    end
+
+    def x=(x)
+      clear_cache
+      @x = Float(x)
+    end
+
+    def y=(y)
+      clear_cache
+      @y = Float(y)
+    end
+
+    def normalize
+      if zero?
+        Vector2d.new(0,0)
+      else
+        Vector2d.new(@x/length, @y/length)
+      end
+    end
+
+    def normalize!
+      if zero?
+        @length = 0
+        @length_sq = 0
+        @normalized = true
+      end
+
+      return self if @normalized
+      @x /= length
+      @y /= length
+      clear_cache
+      @normalized = true
+      self
+    end
+
+    def +(v)
+      Vector2d.new(@x+v.x, @y+v.y)
+    end
+
+    def -(v)
+      Vector2d.new(@x-v.x, @y-v.y)
+    end
+
+    def /(n)
+      Vector2d.new(@x/n, @y/n)
+    end
+
+    def *(n)
+      Vector2d.new(@x*n, @y*n)
+    end
+
+    def truncate!(max_l)
+      return self if length < max_l
+      normalize!
+      self.x *= max_l
+      self.y *= max_l
+      self
+    end
+
+    def dot(v)
+      @x*v.x + @y*v.y
+    end
+
+    def perp
+      Vector2d.new(@y, -@x)
+    end
+
+    def angle
+      Gosu.angle(0, 0, @x, @y)
+    end
+
+    def angle_to(v)
+      Gosu.angle_diff(angle, v.angle)
+    end
+
+    def sign_to(v)
+      if @y * v.x > @x * v.y
+        return -1
+      else
+        return 1
+      end
+    end
+
+    def to_s
+      format('%.2f, %.2f', @x, @y)
+    end
+
+  end
+end

data/lib/lotu/systems/steering.rb

@@ -0,0 +1,198 @@
+# -*- coding: utf-8 -*-
+module Lotu
+  class Steering
+    attr_reader :force
+
+    def initialize(actor, opts={})
+      # Add new functionality to Actor
+      actor.extend ActorMethods
+
+      # Initialize attributes
+      default_opts = {
+        :mass => 1,
+        :max_speed => 350,
+        :max_turn_rate => 180,
+        :max_force => 300,
+        :wander_radius => 120,
+        :wander_distance => 240.0
+      }
+      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]
+
+      # More attributes
+      @actor = actor
+      @behaviors = {}
+      @force = Vector2d.new
+      @zero = Vector2d.new
+    end
+
+    def update
+      @force.zero!
+      @behaviors.each_pair do |behavior, active|
+        @force += send(behavior) if active
+      end
+
+      @actor.accel = @force / @actor.mass
+      @actor.accel.truncate!(@actor.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)
+
+      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)
+      else
+        @actor.vel = new_velocity
+      end
+
+      @actor.vel.truncate!(@actor.max_speed)
+      @actor.pos += @actor.vel * @actor.dt
+
+      if @actor.vel.length > 0.0001
+        @actor.heading = @actor.vel.normalize
+      end
+
+      @actor.x = @actor.pos.x
+      @actor.y = @actor.pos.y
+      @actor.angle = @actor.heading.angle
+    end
+
+    def activate(behavior)
+      @behaviors[behavior] = true
+    end
+
+    def deactivate(behavior)
+      @behaviors[behavior] = false
+    end
+
+    # 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
+    end
+
+    def flee
+      return @zero if @actor.target.nil?
+      desired_velocity = (@actor.pos - @actor.target).normalize * @actor.max_speed
+      return desired_velocity - @actor.vel
+    end
+
+    def arrive(deceleration = :normal)
+      return @zero if @actor.target.nil?
+      deceleration_values = {
+        :fast => 0.5,
+        :normal => 1,
+        :slow => 2
+      }
+      deceleration_tweaker = 1.0
+      to_target = @actor.target - @actor.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
+        desired_velocity = to_target * speed / distance_to_target
+        return desired_velocity - @actor.vel
+      else
+        @actor.vel /= 1.15
+        @actor.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 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
+      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 flee
+    end
+
+    # TODO: Fix wander
+    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
+    end
+
+    def local_to_world(local_target, heading, side, pos)
+      local_angle = heading.angle_to(local_target)
+      x = Gosu.offset_x(local_angle, local_target.length)
+      y = Gosu.offset_y(local_angle, local_target.length)
+      world_point = Vector2d.new(x, y) + pos
+    end
+
+    module ActorMethods
+
+      def self.extended(instance)
+        instance.steering_setup
+      end
+
+      def steering_setup
+        # Create accessors for the actor
+        class << self
+          attr_accessor :mass, :pos, :heading, :vel, :accel,
+          :max_speed, :max_turn_rate, :max_force,
+          :wander_radius, :wander_distance, :wander_target,
+          :target, :evader, :pursuer
+        end
+
+        # Some defaults
+        @pos = Vector2d.new(@x, @y)
+        offset_x = Gosu.offset_x(@angle, 1)
+        offset_y = Gosu.offset_y(@angle, 1)
+        @heading = Vector2d.new(offset_x, offset_y)
+        @vel = Vector2d.new
+        @accel = Vector2d.new
+        @wander_target = Vector2d.new
+      end
+
+      def activate(behavior)
+        @systems[Steering].activate(behavior)
+      end
+
+      # to_s utility methods
+      def to_s
+        ["@angle(#{format('%.2f', @angle)}°)",
+         "@pos(#{@pos})",
+         "@heading(#{@heading})",
+         "@vel |#{format('%.2f', @vel.length)}| (#{@vel})",
+         "@accel |#{format('%.2f', @accel.length)}| (#{@accel})",
+         "@seek_target(#{@seek_target})"]
+      end
+
+    end
+
+  end
+end

data/lib/lotu/text_box.rb

@@ -0,0 +1,54 @@
+module Lotu
+  class TextBox < Actor
+
+    def initialize(opts={})
+      default_opts = {
+        :font_size => 20
+      }
+      opts = default_opts.merge!(opts)
+      super(opts)
+      @watch_list = []
+      @subject_opts = {}
+      @font_size = opts[:font_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
+      draw_me
+    end
+
+    def watch(subject, opts={})
+      @watch_list << subject
+      @subject_opts[subject] = opts
+    end
+
+    def attach_to(actor)
+      @attached_to = actor
+    end
+
+    def update
+      unless @attached_to.nil?
+        @x = @attached_to.x + @attached_to.image.width / 2
+        @y = @attached_to.y - @attached_to.image.height / 2
+      end
+    end
+
+    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
+        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
+        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
+          end
+        end
+      end
+    end
+
+  end
+end

data/lib/lotu/window.rb

@@ -1,11 +1,11 @@
 module Lotu
   class Window < Gosu::Window
     # delta time
-    attr_reader :dt, :systems
+    attr_reader :dt, :systems, :fonts
     attr_accessor :update_queue, :draw_queue, :input_listeners, :font
 
     def initialize(params={})
-      super(640, 480, false)
+      super(800, 600, false)
 
       # Handy global window variable
       $window = self
@@ -18,7 +18,7 @@ module Lotu
 
       @fps_counter = FpsCounter.new
       @last_time = Gosu::milliseconds
-      @font = Gosu::Font.new(self, Gosu::default_font_name, 20)
+      @fonts = Hash.new{|h,k| h[k] = Gosu::Font.new(self, Gosu::default_font_name, k)}
 
       # Add extra functionality
       extend Controllable

data/lib/lotu.rb

@@ -2,6 +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}.each{|file| require "systems/#{file}"}
-%w{fps actor cursor window}.each{|file| require file}
+%w{collision steering}.each{|file| require "systems/#{file}"}
+%w{window actor cursor text_box}.each{|file| require file}

data/lotu.gemspec

@@ -5,16 +5,17 @@
 
 Gem::Specification.new do |s|
   s.name = %q{lotu}
-  s.version = "0.1.3"
+  s.version = "0.1.4"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["lobo_tuerto"]
-  s.date = %q{2010-03-19}
+  s.date = %q{2010-03-21}
   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 = [
     "LICENSE",
-     "README.rdoc"
+     "README.rdoc",
+     "TODO"
   ]
   s.files = [
     ".document",
@@ -43,6 +44,7 @@ Gem::Specification.new do |s|
      "examples/media/lobo_tuerto.png",
      "examples/media/title.png",
      "examples/mouse_pointer/mouse_pointer.rb",
+     "examples/steering_behaviors/steering.rb",
      "lib/lotu.rb",
      "lib/lotu/actor.rb",
      "lib/lotu/behaviors/collidable.rb",
@@ -52,8 +54,11 @@ Gem::Specification.new do |s|
      "lib/lotu/behaviors/eventful.rb",
      "lib/lotu/behaviors/resourceful.rb",
      "lib/lotu/cursor.rb",
-     "lib/lotu/fps.rb",
+     "lib/lotu/misc/fps.rb",
+     "lib/lotu/misc/vector2d.rb",
      "lib/lotu/systems/collision.rb",
+     "lib/lotu/systems/steering.rb",
+     "lib/lotu/text_box.rb",
      "lib/lotu/window.rb",
      "lotu.gemspec"
   ]
@@ -63,7 +68,8 @@ Gem::Specification.new do |s|
   s.rubygems_version = %q{1.3.6}
   s.summary = %q{A simple, agile Ruby game development framework.}
   s.test_files = [
-    "examples/hello_world/hello_world.rb",
+    "examples/steering_behaviors/steering.rb",
+     "examples/hello_world/hello_world.rb",
      "examples/mouse_pointer/mouse_pointer.rb"
   ]
 

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 1
-  - 3
-  version: 0.1.3
+  - 4
+  version: 0.1.4
 platform: ruby
 authors: 
 - lobo_tuerto
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-03-19 00:00:00 -06:00
+date: 2010-03-21 00:00:00 -06:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -40,6 +40,7 @@ extensions: []
 extra_rdoc_files: 
 - LICENSE
 - README.rdoc
+- TODO
 files: 
 - .document
 - .gitignore
@@ -67,6 +68,7 @@ files:
 - examples/media/lobo_tuerto.png
 - examples/media/title.png
 - examples/mouse_pointer/mouse_pointer.rb
+- examples/steering_behaviors/steering.rb
 - lib/lotu.rb
 - lib/lotu/actor.rb
 - lib/lotu/behaviors/collidable.rb
@@ -76,10 +78,14 @@ files:
 - lib/lotu/behaviors/eventful.rb
 - lib/lotu/behaviors/resourceful.rb
 - lib/lotu/cursor.rb
-- lib/lotu/fps.rb
+- lib/lotu/misc/fps.rb
+- lib/lotu/misc/vector2d.rb
 - lib/lotu/systems/collision.rb
+- lib/lotu/systems/steering.rb
+- lib/lotu/text_box.rb
 - lib/lotu/window.rb
 - lotu.gemspec
+- TODO
 has_rdoc: true
 homepage: http://github.com/lobo-tuerto/lotu
 licenses: []
@@ -111,5 +117,6 @@ signing_key:
 specification_version: 3
 summary: A simple, agile Ruby game development framework.
 test_files: 
+- examples/steering_behaviors/steering.rb
 - examples/hello_world/hello_world.rb
 - examples/mouse_pointer/mouse_pointer.rb