moonpxi-nimo 0.1.0

data/lib/nimo/representations/image_representation.rb

@@ -0,0 +1,18 @@
+module Nimo
+  
+  class ImageRepresentation < ObjectRepresentation
+    represent :image
+  
+    def load(resources, params)
+			raise "Must provide :image param for image loading" unless params.has_key?(:image)
+
+      @image = resources.image(params[:image])
+      @image = @image[params[:index]] if params.has_key?(:index)
+    end
+
+    def draw
+      @image.draw(@game_object.x, @game_object.y, 0)
+    end
+  end
+  
+end

data/lib/nimo/representations/object_representation.rb

@@ -0,0 +1,67 @@
+module Nimo
+  
+  # Nimo::GameObject's view. It holds actions to be executed on every update or when a key is pressed.
+  # 
+  class ObjectRepresentation
+    include InputListener, EventListener
+    
+    attr_reader :game_object
+    attr_accessor :game_window
+
+    def initialize(game_window, game_object)
+      @game_window, @game_object = game_window, game_object
+      @always_actions = []
+    end
+
+    # Hook to load data (i.e. images and fonts) from the game window.
+    def load(resources, params)
+      raise "Load should be overriden by representation"
+    end
+
+    # Register and action that always execute on a game update.
+    def always(&action)
+      @always_actions << action
+      self
+    end
+    
+    # Register an action that will execute when the game object sends a notification. Overrides EventListener to 
+    # add default registration to game_object.
+    # 
+    def listen_to(event_type, &action)
+      super
+      game_object.register_listener(event_type, self)
+    end
+
+		# Register an observer to be invoked every update, after all actions runned. This could be useful when a more complex behavior
+		# is required from the representation, and there is a need to inspect the game object to change some state.
+    # 
+		def with_observer(&observer)
+			@observer = observer
+		end
+
+    def update
+      @always_actions.each { |action| @game_object.instance_eval(&action) }
+      process_inputs(@game_window)
+			@observer.call(self, game_object) unless @observer.nil?
+    end
+
+    # Should be overriden by childs.
+    def draw
+      raise "Draw should be overriden by representation"
+    end
+
+    def act_upon
+      @game_object
+    end
+    
+    private
+
+    # Register itself as a object representation with the shortcut name.
+    # 
+    def self.represent(representation_name)
+      Screen.register_representation(representation_name, self)
+    end
+
+  end
+  
+end

data/lib/nimo/representations/quad_representation.rb

@@ -0,0 +1,23 @@
+module Nimo
+  
+  class QuadRepresentation < ObjectRepresentation
+    represent :quad
+    attr_accessor :color
+     
+    def load(resources, params)
+      raise "Must provide :color param for quad loading" unless params.has_key?(:color)
+      
+      @color = params[:color]      
+    end
+  
+    def draw
+      @game_window.draw_quad(
+        @game_object.x, @game_object.y, @color, 
+        @game_object.x + @game_object.width, @game_object.y, @color,
+        @game_object.x, @game_object.y + @game_object.height, @color,
+        @game_object.x + @game_object.width, @game_object.y + @game_object.height, @color)
+    end
+  
+  end
+  
+end

data/lib/nimo/representations/sprite_representation.rb

@@ -0,0 +1,78 @@
+module Nimo
+  
+  class SpriteRepresentation < ObjectRepresentation
+    represent :sprite
+    attr_accessor :flip
+    
+    def initialize(game_window, game_object)
+      super(game_window, game_object)
+      @animations = {}
+      @current_animation = nil
+			@next_animation = nil
+      unflip
+    end
+
+    def load(resources, params)
+			raise "Must provide :image param for sprite loading" unless params.has_key?(:image)
+      @sprite_tiles = resources.image(params[:image])
+    end
+    
+    def flip
+      @drawing = lambda { |sprite| sprite.draw(@game_object.x + @game_object.width, @game_object.y, 0, -1) }
+    end
+    
+    def unflip
+      @drawing = lambda { |sprite| sprite.draw(@game_object.x, @game_object.y, 0) }
+    end
+
+		def change_to(animation_name)
+			@next_animation = animation_name
+		end
+
+    def draw
+      if @current_animation.name != @next_animation && @animations.has_key?(@next_animation)
+         @current_animation = @animations[@next_animation]
+         @current_animation.reset_animation
+      end
+      @drawing.call(@sprite_tiles[@current_animation.frame_index])
+    end
+    
+    # Adds a new animation to the sprite. The first animation will be set as the current.
+    # A list of options can be specified to customise the behavior:
+    # - :timeout (default is 0.1): time to wait between frames
+    # - :loop (default is true): true if the animation should start from the beginning, after the last element,
+    #       otherwise it will draw the last frame
+    def with_animation(name, frame_indexes, options = {})
+      @animations[name] = Animation.new(name, frame_indexes, options)
+      @current_animation = @animations[name] if @current_animation.nil?
+      self
+    end
+  end
+  
+  class Animation
+    attr_reader :name
+    
+    def initialize(name, frame_indexes, options)
+      @name = name
+      @frame_indexes = frame_indexes
+      @options = {:timeout => 0.1, :loop => true}.merge(options)
+      reset_animation
+    end
+    
+    def reset_animation
+      @current_index = 0
+      @time_since_last_draw = Time.now
+    end
+    
+    def frame_index
+      if (Time.now - @time_since_last_draw) > @options[:timeout]
+        @time_since_last_draw = Time.now
+        @current_index += 1
+        if @current_index == @frame_indexes.size
+          @current_index = @options[:loop] ? 0 : @frame_indexes.size - 1
+        end
+      end
+      @frame_indexes[@current_index]
+    end
+  end
+end

data/lib/nimo/representations/text_representation.rb

@@ -0,0 +1,27 @@
+module Nimo
+  
+  class TextRepresentation < ObjectRepresentation
+    represent :text
+    attr_accessor :color
+    
+    def load(resources, params)
+      validate(params)
+      
+      @font = resources.font(params[:font])
+      @color = params[:color]
+      @text = params[:text] # TODO Or should it get it from the game_object?
+    end
+  
+    def draw
+      @font.draw(@text, @game_object.x, @game_object.y, 0, 1, 1, @color)
+    end
+    
+    private
+    
+    def validate(params)
+      [:font, :color, :text].each { |param| raise "Must provide :#{param} param for font loading" unless params.has_key?(param) }
+    end
+  
+  end
+  
+end

data/lib/nimo/screen.rb

@@ -0,0 +1,103 @@
+require "forwardable"
+
+module Nimo
+  
+  # Represent a game's screen, holding representations of domain objects for updates and draws.
+  # TODO: Add info on how to add 'quad', 'image' (whatever) methods
+  # 
+  class Screen
+    include InputListener, EventListener
+    extend Forwardable
+    
+    attr_reader :id
+    
+    def_delegators :@game_window, :go_to, :open_menu, :close_menu
+    def_delegators :@resources, :images, :sounds, :fonts
+    
+    def initialize(id, game_window, resources)
+      @id, @game_window, @resources = id, game_window, resources
+      
+      @representations = []
+      @events = {}
+			@timers = []
+    end
+    
+    # Register a representation to be called as a method.
+    # Example:
+    #   Screen.register_representation(:blah, Blah)
+    #   a_screen.blah :for => obj, :with => {:attr => 42} do
+    #     # Initialising representation
+    #   end
+    #     
+    def self.register_representation(representation_name, representation_class)
+      define_method representation_name do |options, &blk|
+         representation = add(representation_class, options)
+         representation.instance_eval &blk if blk
+      end
+    end
+    
+    # Add a representation to the screen. The options params is used to specify a GameObject and params. It returns the 
+    # constructed representation.
+    # Examples of usage:
+    #   screen.add(SomeRepresentation, :for => object, :with => { :attr => "something"}) # will construct SomeRepresentation with the supplied object and :with params
+    #   screen.add(SomeRepresentation, :with => { :attr => "something"}) # will construct SomeRepresentation with a vanilla Nimo::GameObject
+    # 
+    def add(representation_class, options)
+      params = options.has_key?(:with) ? options[:with] : {}
+      game_object = options.has_key?(:for) ? options[:for] : Nimo::GameObject.new(params)
+      
+      representation = representation_class.new(@game_window, game_object)
+      representation.load(@resources, params)
+      
+      @representations << representation
+      representation
+    end
+ 
+		# Defines an <tt>action</tt> to be executed after some <tt>seconds</tt>.
+    # 
+    def timer_for(seconds, &action)
+			@timers << Timer.new(Time.now.to_f, seconds, action)
+    end
+
+    # :section: Gosu::Window hooks
+   
+    # Updates all representations.
+    # 
+    def update
+			process_timers
+			process_inputs(@game_window)
+      @representations.each { |representation| representation.update }
+    end
+  
+    # Draws all representations.
+    # 
+    def draw
+      @representations.each { |representation| representation.draw }
+    end
+
+		private
+
+		def process_timers
+			@timers.find_all { |timer| timer.time_is_up? }.each do |timer|
+				timer.run_action
+				@timers.delete(timer)
+			end
+		end
+  
+  end
+
+	class Timer
+		def initialize(start_time, delay_in_seconds, action)
+			@start_time, @delay_in_seconds, @action = start_time, delay_in_seconds, action
+		end
+
+		def time_is_up?
+			(Time.now.to_f - @start_time) > @delay_in_seconds
+		end
+
+		def run_action
+			@action.call
+		end
+	end
+  
+end

data/lib/nimo/utils/game.rb

@@ -0,0 +1,63 @@
+module Nimo
+  
+  # Helper method to create and show a new GameWindow with a construction block.
+  # 
+  # Example, from simplest.rb:
+  # 
+  #   Nimo::Game("Simplest", 640, 480) do
+  #     screen :game do
+  #       quad :with => { :width => 20, :height => 20, :color => Gosu::white } do
+  #         # Code ommited.
+  #       end
+  #       when_key(Gosu::Button::KbEscape) { exit }
+  #     end
+  #   end
+  #   
+  def self.Game(title, width, height, &blk)
+    window = Nimo::GameWindow.new(title, width, height)
+    GameBuilder.new(window).instance_eval(&blk) if block_given?
+    window.show
+    return window
+  end
+  
+  class GameBuilder
+    def initialize(game_window)
+      @game_window = game_window
+      @resources = Nimo::Resources.new(@game_window)
+    end
+
+    # Load images that can be referenced by a tag.
+    # Example of <tt>image_definitions</tt>:
+    #   images :some_tag => { :filename => "path_to_image.png" } # Load path_to_image.png to be used by the tag :some_tag
+    #   images :tile_tag => { :filename => "path_to_tile.png", :tile_dimension => [32, 50] } # Load path_to_tile.png as a tile of width 32 and height 50
+    # 
+    def images(image_definitions)
+      @resources.load_images(image_definitions)
+    end
+    
+    # Load fonts that can be referenced by a tag.
+    # Example of <tt>font_definitions</tt>:
+    #   fonts :some_tag => { :type => "font_type", :size => 20 } # Load font of type 'font_type'
+    #
+    def fonts(font_definitions)
+      @resources.load_fonts(font_definitions)
+    end
+    
+    # Load sounds that can be referenced by a tag.
+    # Example of <tt>sound_definitions</tt>:
+    #   sounds :some_tag => { :filename => "some_file.wav", :size => 20 }
+    #
+    def sounds(sound_definitions)
+      @resources.load_sounds(sound_definitions)
+    end
+    
+    # Register a new screen with the <tt>name</tt>, using the supplied block as the Screen constructor.
+    # 
+    def screen(screen_id, &blk)
+      screen = Nimo::Screen.new(screen_id, @game_window, @resources)
+      screen.instance_eval(&blk) if block_given?
+      @game_window.add_screen(screen_id, screen)
+    end
+  end
+  
+end

data/lib/nimo/utils/intersection.rb

@@ -0,0 +1,30 @@
+module Nimo
+  class Intersection
+  
+    attr_reader :x, :y, :width, :height
+  
+    def initialize(x, y, width, height)
+      @x = x
+      @y = y
+      @width = width
+      @height = height
+    end
+  
+    def self.between(obj1, obj2)
+      x = [obj1.x, obj2.x].max
+      y = [obj1.y, obj2.y].max
+      width = [obj1.x + obj1.width, obj2.x + obj2.width].min - x
+      height = [obj1.y + obj1.height, obj2.y + obj2.height].min - y
+      return Intersection.new(x, y, width, height)
+    end
+    
+    def collistion_side_for(obj)
+      if @width >= @height
+        return obj.center.y > (@y + (@height/2)) ? :top : :bottom
+      else
+        return obj.center.x > (@x + (@width/2)) ? :left : :right
+      end
+    end
+    
+  end
+end

data/lib/nimo/utils/object_extension.rb

@@ -0,0 +1,17 @@
+require "ostruct"
+
+class Object
+  
+  # Creates a new object from a hash. The hash keys will became attribute names, and
+  # the respective values will be the attribute's value.
+  #
+  # Example:
+  #   obj = Object.from_hash({:a => 1, :b => 42})
+  #   puts obj.a # 1
+  #   puts obj.b # 42
+  #    
+  def self.from_hash(hash)
+    OpenStruct.new(hash)
+  end
+  
+end

data/lib/nimo/utils/resources.rb

@@ -0,0 +1,51 @@
+module Nimo
+  
+  # Resource loader.
+  # 
+  class Resources
+
+    attr_reader :images, :fonts, :sounds
+
+    def initialize(game_window)
+      @game_window = game_window
+      @images = {}
+      @fonts  = {}
+      @sounds = {}
+    end
+    
+    def load_images(image_definitions)
+      image_definitions.each { |tag, definition| @images[tag] ||= create_image_from(definition) }
+    end
+    
+    def load_fonts(font_definitions)
+      font_definitions.each { |tag, definition| @fonts[tag] ||= Gosu::Font.new(@game_window, definition[:type], definition[:size]) }
+    end
+    
+    def load_sounds(sound_definitions)
+      sound_definitions.each { |tag, definition| @sounds[tag] ||= Gosu::Song.new(@game_window, definition[:filename]) }
+    end
+    
+    def method_missing(meth, *args, &blk)
+      super unless [:image, :sound, :font].include?(meth)
+      validate_and_return_resource(meth, args.shift)
+    end
+
+    private
+    
+    def create_image_from(definition)
+      if definition.has_key?(:tile_dimension)
+        width = definition[:tile_dimension][0]
+        height = definition[:tile_dimension][1]
+        return Gosu::Image.load_tiles(@game_window, definition[:filename], width, height, false)
+      end
+      return Gosu::Image.new(@game_window, definition[:filename], 0)
+    end
+    
+    def validate_and_return_resource(resource_type, tag)
+      resource_list = self.send("#{resource_type.to_s}s")
+      raise "No #{resource_type.to_s} resource named '#{tag}'" unless resource_list.has_key?(tag)
+      resource_list[tag]
+    end
+    
+  end
+end