lotu 0.1.15 → 0.1.16

data/VERSION

@@ -1 +1 @@
-0.1.15
+0.1.16

data/examples/{hello_world → 01_hello_world}/moving_portraits.rb

@@ -1,4 +1,5 @@
 #!/usr/bin/env ruby
+# -*- coding: utf-8 -*-
 
 # Hello world for lotu
 # Here you will learn about:
@@ -17,7 +18,6 @@ include Lotu
 # subclass, set the image for all the instances of that class and
 # define the movement methods
 class Portrait < Actor
-
   def initialize( opts )
     # It's important to call super so we take advantage of automatic
     # management for this object (being added to draw and update queues)
@@ -32,15 +32,15 @@ class Portrait < Actor
   def move_left;  @x -= 1 end
   def move_up;    @y -= 1 end
   def move_down;  @y += 1 end
-
 end
 
 # Let's subclass the Game class and write some code!
 class MyPortraits < Game
+  use StalkerSystem, :stalk => [Actor, TextBox, Portrait, Object]
 
   def initialize
     # This will call the hooks:
-    # load_resources, setup_systems, setup_input and setup_actors
+    # load_resources, setup_actors, setup_input and setup_events
     # declared in the parent class
     super
     # When the Escape key is pressed, call the close method on our
@@ -82,6 +82,8 @@ class MyPortraits < Game
     @info = TextBox.new
     # Add some text
     @info.text("Hello world!")
+    @info.watch lambda{ "FPS: #{ fps }" }
+    @info.watch( @systems[StalkerSystem] )
     # Add more text, but specify the color and size in pixels
     @info.text("Move the portraits around with arrow keys", :size => 16, :color => 0xff33ccff)
   end

data/examples/{screen_cursor → 02_screen_cursor}/mouse_and_keyboard_cursors.rb

@@ -14,26 +14,19 @@ include Lotu
 
 # Create a class for displaying something on screen
 class Lobo < Actor
-  def initialize(opts={})
+  def initialize( opts={} )
     super
     set_image 'lobo_tuerto.png', :width => 100
   end
 
   # Define a method for teleporting our instances around
-  def teleport(x, y)
+  def teleport( x, y )
     @x, @y = x, y
   end
 end
 
 class Cursors < Game
-  def initialize
-    # This will call the hooks:
-    # load_resources, setup_systems, setup_input and setup_actors
-    # declared in the parent class
-    super
-    # Custom setup methods for this class
-    setup_events
-  end
+  use StalkerSystem, :stalk => [Actor, Cursor, TextBox, Lobo, Object]
 
   def load_resources
     with_path_from_file(__FILE__) do
@@ -41,19 +34,6 @@ class Cursors < Game
     end
   end
 
-  def setup_systems
-    # It's important to call super here to setup the InputSystem in
-    # the parent class
-    super
-    # To use the systems lotu provides, you just "use" them
-    # Let's activate the FPS system, so we can track the frames per
-    #second our app is pushing out
-    use(FpsSystem)
-    # Activate the stalker system to track how many objects of these
-    # classes are around
-    use(StalkerSystem, :stalk => [Actor, Cursor, TextBox, Lobo, Object])
-  end
-
   # Setup some input handling for our Cursors app
   def setup_input
     set_keys(KbEscape => :close,
@@ -123,10 +103,10 @@ class Cursors < Game
     @info = TextBox.new(:size => 15)
     @info.text("Press F1 to hide this text", :size => 24)
     # Watch the FPS, so we get a nice FPS report on the screen
-    @info.watch(@systems[FpsSystem], :size => 20)
+    @info.watch(lambda{ "FPS: #{ fps }" }, :size => 20)
     # Watch the Stalker system, so we know how many objects of the
-    # classes we specified up in setup_systems are around
-    @info.watch(@systems[StalkerSystem], :color => 0xff3ffccf)
+    # classes we specified up in "use StalkerSystem" are around
+    @info.watch( @systems[StalkerSystem], :color => 0xff3ffccf )
     # We can change the size for a specific line of text
     @info.text("@cursor1 data:", :size => 20)
     @info.text("move with Mouse | click with LeftMouseButton")

data/examples/03_collisions/box.rb

@@ -0,0 +1,83 @@
+#!/usr/bin/env ruby
+
+LIB_PATH = File.join(File.dirname(__FILE__), '..', '..', 'lib', 'lotu.rb')
+require File.expand_path(LIB_PATH)
+
+include Lotu
+include Gosu
+
+class Box < Actor
+  collides_as :box
+
+  def initialize( opts )
+    # It's important to call super so we take advantage of automatic
+    # management for this object (being added to draw and update queues)
+    super
+    # Use the image which filename is "lobo_tuerto.png", and scale
+    # it's size to half width and half height
+    set_image 'lobo_tuerto.png', :factor_x => 0.5, :factor_y => 0.5
+    calc_radius
+  end
+
+  # Let's define some basic movement methods
+  def move_right; @x += 1 end
+  def move_left;  @x -= 1 end
+  def move_up;    @y -= 1 end
+  def move_down;  @y += 1 end
+end
+
+class Example < Game
+  use CollisionSystem
+  use StalkerSystem, :stalk => [Game, Box, Actor, BaseSystem, Object]
+
+  def initialize
+    super
+    set_keys(KbEscape => :close,
+             KbD => [:debug!, false])
+  end
+
+  # This method is called when we call super inside initialize
+  def load_resources
+    # From this file,
+    with_path_from_file(__FILE__) do
+      # go back one dir and search inside media/images
+      load_images '../media/images'
+    end
+  end
+
+  def setup_events
+    when_colliding( :box, :box ) do |b1, b2|
+      b1.color = Gosu::Color.from_hsv(rand(360), 1, 1)
+      b2.color = Gosu::Color.from_hsv(rand(360), 1, 1)
+    end
+  end
+
+  # This method is called when we call super inside initialize
+  def setup_actors
+    # Create a portrait in the middle of the screen
+    @lobo1 = Box.new(:x => width/2 - 100, :y => height/2)
+    # Map keys to some methods
+    @lobo1.set_keys(KbRight => :move_right,
+                    KbLeft => :move_left,
+                    KbUp => :move_up,
+                    KbDown => :move_down)
+
+    # Rinse and repeat... but invert some keys
+    @lobo2 = Box.new(:x => width/2 + 100, :y => height/2)
+    @lobo2.set_keys(KbRight => :move_left,
+                    KbLeft => :move_right,
+                    KbUp => :move_up,
+                    KbDown => :move_down)
+
+    # Create a TextBox so we can display a message on screen
+    @info = TextBox.new
+    # Add some text
+    @info.text("Hello world!")
+    @info.watch lambda{ "FPS: #{ fps }" }
+    @info.watch( @systems[StalkerSystem] )
+    # Add more text, but specify the color and size in pixels
+    @info.text("Move the portraits around with arrow keys", :size => 16, :color => 0xff33ccff)
+  end
+end
+
+Example.new.show

data/examples/{steering_behaviors → 04_steering_behaviors}/pursuit_and_evade.rb

@@ -14,12 +14,7 @@ include Lotu
 # Let's define a Missile class that will use a Steering system to
 # control it's movement
 class Missile < Actor
-  def initialize(opts={})
-    super
-    # Activate the steering system and pass the opts, since they might
-    # have some config info for the system
-    use(SteeringSystem, opts)
-  end
+  use SteeringSystem
 
   def teleport(x, y)
     @pos.x, @pos.y = x, y
@@ -28,14 +23,7 @@ end
 
 # The main app class
 class SteeringMissiles < Game
-  def initialize
-    # This will call the hooks:
-    # load_resources, setup_systems, setup_input and setup_actors
-    # declared in the parent class
-    super
-    # Custom setup methods for this class
-    setup_events
-  end
+  use StalkerSystem, :stalk => [Actor, Missile, Vector2d, Object]
 
   # Let's load some images and animations, check out the animations
   # directory, the animation there was created with:
@@ -54,13 +42,6 @@ class SteeringMissiles < Game
              KbF1 => [:toggle_missile_info, false])
   end
 
-  def setup_systems
-    # It's important to call super here to setup the InputSystem
-    super
-    use(FpsSystem)
-    use(StalkerSystem, :stalk => [Actor, Missile, Vector2d, Object])
-  end
-
   def setup_actors
     @big_missile = Missile.new(:mass => 0.3, :max_speed => 100, :max_turn_rate => 140)
     @big_missile.teleport(width/2, height/2)
@@ -77,8 +58,8 @@ class SteeringMissiles < Game
 
     @window_info = TextBox.new(:size => 15)
     @window_info.text("Press F1 to hide this text", :size => 24)
-    @window_info.watch(@systems[FpsSystem], :size => 20)
-    @window_info.watch(@systems[StalkerSystem], :color => 0xff33ccff)
+    @window_info.watch(lambda{ "FPS: #{fps}" }, :size => 20)
+    @window_info.watch( @systems[StalkerSystem], :color => 0xff33ccff)
     @window_info.watch(@cursor, :color => @cursor.color)
     @window_info.text("Click to start the simulation", :color => 0xffffff00)
     @window_info.text("One will pursuit while the other evades, right click to center evader on screen")

data/examples/{steering_behaviors → 04_steering_behaviors}/pursuit_and_evade_multiple.rb

@@ -14,12 +14,7 @@ include Lotu
 # Let's define a Missile class that will use a Steering system to
 # control it's movement
 class Missile < Actor
-  def initialize(opts={})
-    super
-    # Activate the steering system and pass the opts, since they might
-    # have some config info for the system
-    use(SteeringSystem, opts)
-  end
+  use SteeringSystem
 
   def teleport(x, y)
     @pos.x, @pos.y = x, y
@@ -28,14 +23,7 @@ end
 
 # The main app class
 class EvadeMultiple < Game
-  def initialize
-    # This will call the hooks:
-    # load_resources, setup_systems, setup_input and setup_actors
-    # declared in the parent class
-    super
-    # Custom setup methods for this class
-    setup_events
-  end
+  use StalkerSystem, :stalk => [Actor, Missile, Vector2d, Object]
 
   # Let's load some images and animations, check out the animations
   # directory, the animation there was created with:
@@ -55,13 +43,6 @@ class EvadeMultiple < Game
              KbSpace => [:pause!, false])
   end
 
-  def setup_systems
-    # It's important to call super here to setup the InputSystem
-    super
-    use(FpsSystem)
-    use(StalkerSystem, :stalk => [Actor, Missile, Vector2d, Object])
-  end
-
   def setup_actors
     @big_missile = Missile.new(:mass => 0.3, :max_speed => 100, :max_turn_rate => 140)
     @big_missile.teleport(width/2, height/2)
@@ -81,8 +62,8 @@ class EvadeMultiple < Game
 
     @window_info = TextBox.new(:size => 15)
     @window_info.text("Press F1 to hide this text", :size => 24)
-    @window_info.watch(@systems[FpsSystem], :size => 20)
-    @window_info.watch(@systems[StalkerSystem], :color => 0xff33ccff)
+    @window_info.watch(lambda{ "FPS: #{fps}" }, :size => 20)
+    @window_info.watch( @systems[StalkerSystem], :color => 0xff33ccff)
     @window_info.watch(@cursor, :color => @cursor.color)
     @window_info.text("Click to start the simulation", :color => 0xffffff00)
     @window_info.text("Little missiles will pursuit while the big one evades, right click to center big one on screen")

data/lib/lotu/actor.rb

@@ -1,13 +1,20 @@
 module Lotu
   class Actor
-    attr_accessor :parent, :x, :y, :systems,
+    extend Behavior
+
+    behave_like SystemUser
+    use AnimationSystem
+    use InterpolationSystem
+
+    behave_like Eventful
+    behave_like Collidable
+    behave_like Controllable
+
+    attr_accessor :parent, :x, :y,
     :z, :angle, :center_x, :center_y,
     :factor_x, :factor_y, :color, :mode, :image,
     :width, :height
 
-    include SystemUser
-    include Controllable
-
     def initialize(opts={})
       default_opts = {
         :x => 0,
@@ -22,20 +29,17 @@ module Lotu
         :mode => :default,
         :parent => $lotu
       }
+
       opts = default_opts.merge!(opts)
       @parent = opts[:parent]
       @parent.manage_me(self)
       set_image(opts[:image], opts) if opts[:image]
       parse_options(opts)
       @color = rand_color if opts[:rand_color]
-
       set_keys(opts[:keys]) unless opts[:keys].nil?
 
-      # Add extra functionality
-      self.extend Eventful
-      self.extend Collidable
-      use(AnimationSystem)
-      use(InterpolationSystem)
+      # so it can start behaving
+      init_behavior opts
     end
 
     # Easy access to delta-time
@@ -118,12 +122,16 @@ module Lotu
     end
 
     def update
-      @systems.each_pair do |klass, system|
-        system.update
-      end
+      # to call update on behaviors (that in turn wil call
+      # update on systems, for example)
+      super
     end
 
     def draw
+      # to call draw on behaviors (that in turn will call
+      # draw on systems, for example)
+      super
+
       unless @image.nil?
         @image.draw_rot(@x, @y, @z, @angle, @center_x, @center_y, @factor_x*@zoom_x, @factor_y*@zoom_y, @color, @mode)
         draw_debug if $lotu.debug?

data/lib/lotu/behavior.rb

@@ -0,0 +1,19 @@
+module Lotu
+  module Behavior
+
+    def behave_like something
+      class << self
+        attr_accessor :behavior_options
+      end
+      include something
+
+      @behavior_options ||= Hash.new{ |h,k| h[k] = {} }
+    end
+
+    def inherited subclass
+      subclass.behavior_options =
+        behavior_options.inject({}){ |hash, opts| hash[opts[0]] = opts[1].deep_copy; hash }
+    end
+
+  end
+end

data/lib/lotu/behaviors/collidable.rb

@@ -1,20 +1,35 @@
 module Lotu
   module Collidable
 
-    def self.extended(instance)
-      instance.init_behavior
+    def self.included base
+      base.extend ClassMethods
     end
 
-    def init_behavior
-      @collision_tag = nil
+    def calc_radius
+      if @width
+        @collision_radius = @width/2.0 * @factor_x
+      elsif @height
+        @collision_radius = @height/2.0 * @factor_y
+      else
+        @collision_radius = 100
+      end
     end
 
-    def collides_as(tag)
-      @collision_tag = tag
-      @parent.systems[CollisionSystem].add_entity(self, tag)
+    def init_behavior opts
+      super if defined? super
+
+      calc_radius
+      class << self
+        attr_accessor :collision_radius
+      end
+
+      @collision_tag = self.class.behavior_options[Collidable]
+      # TODO: Change @parent for @manager (could be a Game or a Scene)
+      @parent.systems[CollisionSystem].add_entity(self, @collision_tag) if @parent.systems[CollisionSystem]
     end
 
     def collides_with(other)
+      return false if self.equal? other
       Gosu.distance(@x, @y, other.x, other.y) < @collision_radius + other.collision_radius
     end
 
@@ -23,5 +38,11 @@ module Lotu
       @parent.systems[CollisionSystem].remove_entity(self, @collision_tag) if @parent.systems[CollisionSystem]
     end
 
+    module ClassMethods
+      def collides_as tag
+        behavior_options[Collidable] = tag
+      end
+    end
+
   end
 end

data/lib/lotu/behaviors/controllable.rb

@@ -13,7 +13,7 @@ module Lotu
     # This will call #go_up every 50ms
     # Gosu::Button::KbUp => [:go_up, 50]
     def set_keys(keys)
-      @parent.systems[InputSystem].set_keys(self, keys)
+      @parent.systems[InputManagerSystem].set_keys(self, keys)
     end
 
   end

data/lib/lotu/behaviors/eventful.rb

@@ -18,11 +18,8 @@
 module Lotu
   module Eventful
 
-    def self.extended(instance)
-      instance.init_behavior
-    end
-
-    def init_behavior
+    def init_behavior opts
+      super if defined? super
       @events = {}
     end
 

data/lib/lotu/behaviors/resource_manager.rb

@@ -0,0 +1,104 @@
+module Lotu
+  module ResourceManager
+
+    attr_accessor :images, :sounds, :songs, :animations, :default_font
+
+    def init_behavior opts
+      super if defined? super
+      @images = {}
+      @sounds = {}
+      @songs = {}
+      @animations = Hash.new{ |h,k| h[k] = [] }
+      @default_font = Hash.new{ |h,k| h[k] = Gosu::Font.new( self, Gosu::default_font_name, k ) }
+    end
+
+    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 with_path_from_file(path, &blk)
+      @path = File.expand_path(File.dirname path)
+      instance_eval &blk
+    end
+
+    protected
+    def load_images( path )
+      count = 0
+      with_files(/\.png$|\.jpg$|\.bmp$/, path) do |file_name, file_path|
+        @images[file_name] = Gosu::Image.new($lotu, file_path)
+        count += 1
+      end
+      puts "\n#{count} image(s) loaded."
+    end
+
+    def load_sounds(path)
+      count = 0
+      with_files(/\.ogg$|\.mp3$|\.wav$/, path) do |file_name, file_path|
+        @sounds[file_name] = Gosu::Sample.new($lotu, file_path)
+        count += 1
+      end
+      puts "\n#{count} sounds(s) loaded."
+    end
+
+    def load_songs(path)
+      count = 0
+      with_files(/\.ogg$|\.mp3$|\.wav$/, path) do |file_name, file_path|
+        @songs[file_name] = Gosu::Song.new($lotu, file_path)
+        count += 1
+      end
+      puts "\n#{count} song(s) loaded."
+    end
+
+    def load_animations(path)
+      count = 0
+      coords = Hash.new{|h,k| h[k] = []}
+
+      with_files(/\.txt$/, path) do |file_name, file_path|
+        name = File.basename(file_name, '.txt')
+        File.open(file_path) do |file|
+          file.lines.each do |line|
+            coords[name] << line.scan(/\d+/).map!(&:to_i)
+          end
+        end
+        false
+      end
+
+      with_files(/\.png$|\.jpg$|\.bmp$/, path) do |file_name, file_path|
+        name, extension = file_name.split('.')
+        coords[name].each do |index, x, y, width, height|
+          @animations[file_name] << Gosu::Image.new($lotu, file_path, true, x, y, width, height)
+        end
+        count += 1 if coords[name]
+      end
+      puts "\n#{count} animation(s) loaded."
+    end
+
+    def with_files(regexp, path)
+      path = File.expand_path(File.join(@path, path))
+      puts "\nLoading from: #{path}".blue if @debug
+
+      Dir.entries(path).grep(regexp).each do |entry|
+        begin
+          report = yield(entry, File.join(path, entry))
+          print '.'.green if report
+        rescue Exception => e
+          print '.'.red
+          puts e, File.join(path, entry) if @debug
+        end
+      end
+    end
+
+  end
+end

data/lib/lotu/behaviors/system_user.rb

@@ -1,10 +1,48 @@
 module Lotu
   module SystemUser
 
-    # Allows to activate a system in the host
-    def use( klass, opts={} )
+    attr_accessor :systems
+
+    def self.included base
+      base.extend ClassMethods
+    end
+
+    def init_behavior user_opts
+      super if defined? super
       @systems ||= Hash.new
-      @systems[klass] = klass.new( self, opts )
+
+      options_for_me = self.class.behavior_options[SystemUser]
+
+      options_for_me && options_for_me.each do |klass, options|
+        # add the behavior options to the user_opts hash
+        # in case we need access to some level class config param
+        user_opts.merge!(options)
+        @systems[klass] = klass.new( self, user_opts )
+      end
+    end
+
+    # Need to call this inside update
+    def update
+      super if defined? super
+      @systems.each_value do |system|
+        system.update
+      end
+    end
+
+    # Need to call this inside draw
+    def draw
+      super if defined? super
+      # Systems may report interesting stuff
+      @systems.each_value do |system|
+        system.draw
+      end
+    end
+
+    # Allows to activate a system in the host
+    module ClassMethods
+      def use( klass, opts={} )
+        behavior_options[SystemUser][klass] = opts
+      end
     end
 
   end