moonpxi-nimo 0.1.0

data/examples/spritey.rb

@@ -0,0 +1,90 @@
+# 
+# spritey.rb
+# 
+# Demonstrate how to create sprites and animations.
+# 
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'nimo'
+include Gosu::Button
+
+WINDOW_WIDTH = 512
+WINDOW_HEIGHT = 480
+WINDOW = {:x => 0, :y => 0, :width => WINDOW_WIDTH, :height => WINDOW_HEIGHT}
+
+class Player < Nimo::GameObject
+	include Nimo::Behavior::WithVelocity
+
+  def initialize
+    super(:x => 0, :y => WINDOW_HEIGHT - 62, :width => 48, :height => 62, :speed => 5, :boundary => Object.from_hash(WINDOW))
+  end
+  
+  def move_left
+		@velocity.x = -1	  
+  end
+  
+  def move_right
+		@velocity.x = 1
+  end
+  
+  def move
+		super
+    if y < @boundary.height - @height
+      @velocity.y += 0.01
+    else
+      @velocity.y = 0
+    end
+  
+	  @velocity.x = 0	
+  end
+  
+  def jump
+    # Cannot jump twice
+    if @y >= @boundary.height - @height
+      @velocity.y = -1
+      @y += @speed * @velocity.y
+    end
+  end
+end
+
+
+if __FILE__ == $PROGRAM_NAME
+  Nimo::Game("Spritey", WINDOW_WIDTH, WINDOW_HEIGHT) do
+    images :jeeklabs => { :filename => "examples/images/jeeklabs.png" },
+           :tcheco => { :filename => "examples/images/tcheco.png", :tile_dimension => [48, 62] }
+           
+    screen :title do
+      quad :with => WINDOW.merge(:color => Gosu::white)
+      image :with => {:x => 116, :y => 190, :image => :jeeklabs}
+      
+      any_key { go_to :game }
+    end
+    
+    screen :game do
+      player_observer = Proc.new do |rep, obj|
+  		  rep.flip if obj.velocity.x < 0
+  		  rep.unflip if obj.velocity.x > 0	
+
+  			rep.change_to(:stopped) if obj.velocity.x == 0
+  			rep.change_to(:walking) if obj.velocity.x != 0
+  			rep.change_to(:jumping) if obj.velocity.y < 0
+  			rep.change_to(:falling) if obj.velocity.y > 0
+  		end
+
+      quad :with => WINDOW.merge(:color => Gosu::white)
+      sprite :for => Player.new, :with => {:image => :tcheco} do
+        always { move }
+        when_key(KbLeft) { move_left }
+        when_key(KbRight) { move_right }
+        when_key(KbUp) { jump }
+        with_animation(:stopped, [0])
+        with_animation(:walking, [1, 2, 3, 4])
+        with_animation(:jumping, [5, 6, 7], :loop => false)
+        with_animation(:falling, [8, 9], :loop => false)
+  			with_observer(&player_observer)
+			end
+  			
+  		when_key(KbEscape) { exit }
+    end
+  end
+end

data/lib/nimo.rb

@@ -0,0 +1,35 @@
+# Libraries
+begin
+  # In case you use Gosu via RubyGems.
+  require "rubygems"
+rescue LoadError
+  # In case you don't.
+end
+
+require "gosu"
+
+# NIMO_DIR = File.expand_path(File.dirname(__FILE__) + "/nimo")
+NIMO_DIR = "nimo"
+
+require NIMO_DIR + "/utils/object_extension"
+require NIMO_DIR + "/utils/intersection"
+require NIMO_DIR + "/utils/resources"
+require NIMO_DIR + "/utils/game"
+
+require NIMO_DIR + "/listeners/input_listener"
+require NIMO_DIR + "/listeners/event_listener"
+
+require NIMO_DIR + "/game_object"
+require NIMO_DIR + "/game_window"
+require NIMO_DIR + "/screen"
+
+require NIMO_DIR + "/behavior/with_velocity"
+require NIMO_DIR + "/behavior/deflector"
+require NIMO_DIR + "/behavior/projectile"
+require NIMO_DIR + "/behavior/moveable"
+
+require NIMO_DIR + "/representations/object_representation"
+require NIMO_DIR + "/representations/quad_representation"
+require NIMO_DIR + "/representations/image_representation"
+require NIMO_DIR + "/representations/text_representation"
+require NIMO_DIR + "/representations/sprite_representation"

data/lib/nimo/behavior/deflector.rb

@@ -0,0 +1,39 @@
+module Nimo::Behavior
+  
+  module Deflector
+    
+    def deflect(projectile)
+      @collision_timeout ||= 0
+      @collision_timeout -= 1 if @collision_timeout > 0
+      return unless @collision_timeout.zero? && collide?(projectile)
+
+      case intersection(projectile).collistion_side_for(self)
+        when :top
+          projectile.velocity.y = -projectile.velocity.y.abs
+        when :bottom
+          projectile.velocity.y = projectile.velocity.y.abs
+        when :left
+          projectile.velocity.x = -projectile.velocity.x.abs
+        when :right
+          projectile.velocity.x = projectile.velocity.x.abs
+      end
+
+      projectile.velocity.adjust(deflection_modifier(projectile))
+      @deflect_action.call(projectile) if @deflect_action
+      @collision_timeout = 5
+    end
+
+    def when_deflect(&action)
+      @deflect_action = action
+      self
+    end
+
+    protected
+
+    def deflection_modifier(projectile)
+      0
+    end
+    
+  end
+  
+end

data/lib/nimo/behavior/moveable.rb

@@ -0,0 +1,33 @@
+module Nimo::Behavior
+  
+  module Moveable
+    
+    def initialize(*params)
+      @speed = 0
+      @boundary = nil
+      super(*params)
+    end
+    
+    def move_left
+      @x -= @speed
+      @x = @boundary.x if @boundary && @x < @boundary.x
+    end
+
+    def move_right
+      @x += @speed
+      @x = @boundary.width - @width if @boundary && (@x + @width) > @boundary.width
+    end
+
+    def move_up
+      @y -= @speed
+      @y = @boundary.y if @boundary && @y < @boundary.y
+    end
+
+    def move_down
+      @y += @speed
+      @y = @boundary.height - @height if @boundary && (@y + @height) > @boundary.height
+    end
+    
+  end
+  
+end

data/lib/nimo/behavior/projectile.rb

@@ -0,0 +1,23 @@
+module Nimo::Behavior 
+  
+  module Projectile
+		include WithVelocity
+    
+    def initialize(*params)
+      @deflectors = []
+      super(*params)
+    end
+    
+    def move
+      @deflectors.each { |deflector| deflector.deflect(self) }
+			super
+    end
+    
+    def with_deflectors(*new_deflectors)
+      @deflectors += new_deflectors
+      @deflectors.flatten!
+    end
+
+  end
+  
+end

data/lib/nimo/behavior/with_velocity.rb

@@ -0,0 +1,28 @@
+module Nimo::Behavior
+  
+  Velocity = Struct.new(:x, :y) do
+    def adjust(radian)
+      xl = Math::cos(radian)*self.x - Math::sin(radian)*self.y
+      yl = Math::sin(radian)*self.x + Math::cos(radian)*self.y
+      self.x = xl
+      self.y = yl
+    end
+  end
+  
+  module WithVelocity
+    attr_reader :velocity
+    
+    def initialize(*params)
+      @speed = 0
+      @velocity = Velocity.new(0.0, 0.0)
+      super(*params)
+    end
+    
+    def move
+      @x += @speed * @velocity.x
+      @y += @speed * @velocity.y
+    end
+
+  end
+  
+end

data/lib/nimo/game_object.rb

@@ -0,0 +1,58 @@
+module Nimo
+  
+  #
+  # Base game domain object containing position, dimension and state information. Any object that represents
+  # a game entity should extend this class.
+  # 
+  # The position (:x and :y) and dimension (:width and :height) are used for visual representations and any 
+  # useful game behavior.
+  # 
+  class GameObject
+    attr_accessor :x, :y, :width, :height
+      
+    def initialize(config_options = {})
+      configure_with({:x => 0, :y => 0, :width => 0, :height => 0}.merge(config_options))
+      @listeners = {}
+    end
+  
+    def at(x, y)
+      @x = x
+      @y = y
+    end
+  
+    def dimension(width, height)
+      @width = width
+      @height = height
+    end
+    
+    # config_options is a hash that can take the following keys: :x, :y, :width, :height. 
+    # The key restriction is not being enforced.
+    def configure_with(config_options)
+      config_options.each { |attribute, value| instance_variable_set("@#{attribute}", value) }
+    end
+  
+    def collide?(obj)
+      !(obj.x > (@x + @width)  || @x > (obj.x + obj.width) ||
+        obj.y > (@y + @height) || @y > (obj.y + obj.height))
+    end
+    
+    def intersection(obj)
+      collide?(obj) ? Intersection.between(self, obj) : nil
+    end
+
+    def center
+      Object.from_hash(:x => @x + (@width/2), :y => @y + (@height/2))
+    end
+    
+    def register_listener(event_type, listener)
+      @listeners[event_type] ||= []
+      @listeners[event_type] << listener
+    end
+    
+    def notify(event_type)
+      @listeners[event_type].each { |listener| listener.notify(event_type) } if @listeners.has_key? event_type
+    end
+    
+  end
+  
+end

data/lib/nimo/game_window.rb

@@ -0,0 +1,59 @@
+module Nimo
+  
+  # Represents a game instance and provides access to the game screen and screen transition.
+  # It is an extension of Gosu::Window, thus implementing the update, draw and button_down hooks.
+  #
+  class GameWindow < Gosu::Window
+    
+    attr_reader :current_screen
+    
+    def initialize(name, width, height)
+      super(width, height, false)
+      self.caption = name
+      
+      @screens = {}
+      @background_screens = []
+    end
+    
+    def add_screen(name, screen)
+      @screens[name] = screen
+      go_to(name) if @screens.size == 1
+    end
+    
+    # Switch to a Screen registered with the <tt>screen_name</tt>, notifying listeners of the :on_enter event. 
+    #     
+    def go_to(screen_name)
+      raise "There is no screen named #{screen_name}" unless @screens.has_key? screen_name
+      @current_screen = @screens[screen_name]
+      @current_screen.notify(:on_enter)
+    end
+
+    # Open a Screen registered with the <tt>screen_name</tt> as a menu. To dismiss the menu, use close_menu.
+    #
+    def open_menu(screen_name)
+      @background_screens << @current_screen
+      go_to(screen_name)
+    end
+    
+    def close_menu
+      @current_screen = @background_screens.pop
+    end
+    
+    # :section: Gosu::Window hooks
+    
+    def update
+     @current_screen.update
+    end
+
+    def draw
+      @background_screens.each { |screen| screen.draw }
+      @current_screen.draw
+    end
+  
+    def button_down(id)
+      @current_screen.button_down(id)
+    end
+    
+  end
+
+end

data/lib/nimo/listeners/event_listener.rb

@@ -0,0 +1,27 @@
+module Nimo
+  
+  # Listen for events and execute for actions on notification.
+  # 
+  module EventListener
+    
+    # Register an action to be executed when an event is notified.
+    # 
+    def listen_to(event, &action)
+      events[event] = action
+    end
+    
+    # Execute registered action for notified event.
+    # 
+    def notify(event)
+      events[event].call if events.has_key?(event)
+    end
+    
+    private 
+    
+    def events
+      @events ||= {}
+    end
+    
+  end
+  
+end

data/lib/nimo/listeners/input_listener.rb

@@ -0,0 +1,70 @@
+module Nimo
+  
+  # Listen for inputs (key presses) and execute the corresponding actions on update.
+  # 
+  module InputListener
+    
+    # Register an action that will execute when the key is pressed.
+    # An options hash can be specified to customise the behavior. The options are:
+    # - <tt>:repeatable</tt> (defaults to true) - execute the action every update regardless if the key was already pressed in the previous update.
+    # 
+    def when_key(key, options = {}, &action)
+      key_actions[key] = KeyAction.new(action, options)
+    end
+    
+    # Register an action to be executed everytime a key is pressed.
+    # 
+    def any_key(&action)
+      @any_key_action = action
+    end
+    
+    # Gosu hook invoked anytime a button is pressed
+    # 
+    def button_down(id) #:nodoc:
+       act_upon.instance_eval(&@any_key_action) if @any_key_action
+    end
+    
+    def process_inputs(game_window)
+      key_actions.each do |key, key_action|
+        act_upon.instance_eval(&key_action.action) if key_action.should_execute?(game_window.button_down?(key))
+      end
+    end
+    
+    protected
+    
+    # Defines the object to be the context of the action. By default it is <tt>self</tt>.
+    # 
+    def act_upon
+      self
+    end
+    
+    private
+    
+    def key_actions
+      @key_actions ||= {}
+    end
+    
+    
+    class KeyAction
+      attr_reader :action
+
+      def initialize(action, options)
+        @action = action
+        @options = {:repeatable => true}.merge(options)
+        @pressed_since = nil
+      end
+
+      def should_execute?(is_button_down)
+        should_execute = false
+        if is_button_down
+          should_execute = @pressed_since.nil? || @options[:repeatable]
+          @pressed_since = Time.now if @pressed_since.nil?
+        else
+          @pressed_since = nil
+        end
+        return should_execute
+      end
+
+    end
+  end
+end