metro 0.0.3 → 0.0.5

data/lib/gosu_ext/color.rb

@@ -0,0 +1,24 @@
+class Gosu::Color
+
+  alias_method :gosu_initialize, :initialize
+
+  #
+  # Monkey-patching the initialize to allow for another Gosu::Color
+  # and Strings.
+  #
+  def initialize(*args)
+    if args.length == 1
+      value = args.first
+      if value.is_a? Gosu::Color
+        gosu_initialize value.alpha, value.red, value.green, value.blue
+      elsif value.is_a? String
+        gosu_initialize value.to_i(16)
+      else
+        gosu_initialize value
+      end
+    else
+      gosu_initialize *args
+    end
+  end
+
+end

data/lib/metro.rb

@@ -1,11 +1,15 @@
 require 'gosu'
+require 'gosu_ext/color'
+
 require 'logger'
 
+
 require 'metro/version'
 require 'metro/window'
 require 'metro/game'
-require 'metro/model'
 require 'metro/scene'
+require 'metro/models/model'
+require 'metro/models/generic'
 
 def asset_path(name)
   File.join Dir.pwd, "assets", name
@@ -50,7 +54,6 @@ module Metro
     $LOAD_PATH.unshift(Dir.pwd) unless $LOAD_PATH.include?(Dir.pwd)
     Dir['models/*.rb'].each {|model| require model }
     Dir['scenes/*.rb'].each {|scene| require scene }
-    Dir['drawers/*.rb'].each {|drawer| require drawer }
   end
 
   def load_game_configuration(filename)
@@ -62,6 +65,7 @@ module Metro
 
   def start_game
     window = Window.new Game.width, Game.height, Game.fullscreen?
+    window.caption = Game.name
     window.scene = Scenes.generate(Game.first_scene)
     window.show
   end

data/lib/metro/animation/animation.rb

@@ -1,65 +1,94 @@
-class Animation
-
-  attr_reader :current_step
-
-  def initialize(options)
-    @current_step = 0
-
-    options.each do |key,value|
-      send :instance_variable_set, "@#{key}".to_sym, value
-      self.class.send :define_method, key do
-        instance_variable_get("@#{key}")
+module Metro
+
+  #
+  # Animation is the motion that gives a system it's life. An animation
+  # in this case is a really a mechanism that allows for an action to
+  # be repeated for a given interval of time.
+  #
+  class Animation
+
+    def initialize(options)
+      @current_step = 0
+
+      options.each do |key,value|
+        send :instance_variable_set, "@#{key}".to_sym, value
+        self.class.send :define_method, key do
+          instance_variable_get("@#{key}")
+        end
       end
+      after_initialize
     end
-    after_initialize
-  end
-
-  def completed?
-    current_step >= interval
-  end
 
-  def step!
-    return if completed?
-
-    execute_step
-    next_step
+    #
+    # Sets the action that happens with each step of the animation.
+    #
+    def on_step(&block)
+      @step_block = block
+    end
 
-    complete! if completed?
-  end
+    #
+    # Sets the action that happens when the animation is completed.
+    #
+    def on_complete(&block)
+      @complete_block = block
+    end
 
-  def next_step
-    @current_step = current_step + step_interval
-  end
+    #
+    # Perform a step of an animation, if it hasn't already been completed.
+    #
+    def update
+      return if completed?
 
-  def step_interval
-    1
-  end
+      execute_step
+      next_step
 
-  def execute_block_in_context(block_name)
-    if respond_to? block_name
-      block_to_execute = send(block_name)
-      context.instance_eval(&block_to_execute)
-    else
-      instance_variable_get("@#{block_name}").call
+      complete! if completed?
+    end
+    
+    #
+    # @return the current step of the animation.
+    #
+    attr_reader :current_step
+
+    attr_reader :step_block, :complete_block
+
+    #
+    # Move to the next step in the animation.
+    #
+    def next_step
+      @current_step = current_step + step_interval
     end
-  end
 
-  def execute_step
-    execute_block_in_context(:step_block)
-  end
+    #
+    # @return the interval at which the animation take place.
+    #
+    def step_interval
+      1
+    end
+    
+    # 
+    # @return true if the animation has completed all the actions, false
+    #   if there are remaining actions.
+    # 
+    def completed?
+      current_step >= interval
+    end
 
-  def complete!
-    execute_block_in_context(:completed)
-  end
+    #
+    # Perform the action that happens with each step of the animation.
+    #
+    def execute_step
+      context.instance_eval(&@step_block) if step_block and context
+    end
 
-  def step(&block)
-    @step_block = block if block
-  end
+    #
+    # Perform the action that happens when the animation is completed.
+    #
+    def complete!
+      context.instance_eval(&@complete_block) if complete_block and context
+    end
 
-  def completed(&block)
-    @completed = block if block
   end
-
 end
 
 require_relative 'implicit_animation'

data/lib/metro/animation/easing.rb

@@ -1,28 +1,31 @@
-module Easing
-  module Linear
-    extend self
+module Metro
+  module Easing
 
-    def linear(moment,start,change,interval)
-      change * moment / interval + start
-    end
+    module Linear
+      extend self
+
+      def linear(moment,start,change,interval)
+        change * moment / interval + start
+      end
 
-    def calculate(start,final,interval)
-      change = final - start
-      (1..interval).map { |time| linear(time,start,change,interval) }
+      def calculate(start,final,interval)
+        change = final - start
+        (1..interval).map { |time| linear(time.to_f,start,change,interval) }
+      end
     end
-  end
 
-  module EaseIn
-    extend self
+    module EaseIn
+      extend self
 
-    def ease_in_quad(moment,start,change,interval)
-      change * (moment = moment / interval) * moment + start
-    end
+      def ease_in_quad(moment,start,change,interval)
+        change * (moment = moment / interval) * moment + start
+      end
 
-    def calculate(start,final,interval)
-      change = final - start
-      (1..interval).map { |time| ease_in_quad(time,start,change,interval) }
+      def calculate(start,final,interval)
+        change = final - start
+        (1..interval).map { |time| ease_in_quad(time.to_f,start,change,interval) }
+      end
     end
+
   end
 end
-

data/lib/metro/animation/implicit_animation.rb

@@ -1,43 +1,102 @@
 require_relative 'easing'
 
-class ImplicitAnimation < Animation
+module Metro
 
-  attr_reader :attributes
-  attr_reader :deltas
+  #
+  # An Implicit Animation is an animation without all the work.
+  # This little animation will take care of figuring out moving an
+  # actor from one position to another, the rotation, the alpha,
+  # etc.
+  #
+  # @example Creating an explicit animation that moves a player
+  #
+  #     animation = ImplicitAnimation.new actor: player,
+  #       to: { x: final_x, y: final_y },
+  #       interval: 80,
+  #       easing: :ease_in,
+  #       context: scene
+  #
+  #     animation.on_complete do
+  #       transition_to :main
+  #     end
+  #
+  # Here an animation is created that will move the player to the
+  # position (final_x,final_y), specified in the :to hash that is
+  # provided, over the interval of 80 steps. Additionally the movement
+  # is done with an easing in.
+  #
+  # @note The actor object must respond to setter methods that match
+  #   the specified attributes (e.g. x, y).
+  #
+  # The context provided is the context that the 'on_complete' block
+  # is executed. In this case, upon completition, transition the scene
+  # from the current one to the main scene.
+  #
+  class ImplicitAnimation < Animation
 
-  def delta_for_step(attribute)
-    deltas[attribute].at(current_step)
-  end
+    #
+    # @return the array of attributes that are being animated.
+    #
+    attr_reader :attributes
 
-  def stepping(stepping)
-    @steppings ||= begin
-      hash = Hash.new(Easing::Linear)
-      hash.merge! linear: Easing::Linear,
-        ease_in: Easing::EaseIn
-    end
-    @steppings[stepping]
-  end
+    #
+    # @return a Hash that contains all the animation step deltas
+    #   for each attribute.
+    #
+    attr_reader :deltas
 
-  def easing
-    @easing || :linear
-  end
+    #
+    # @return the type of easing that the implicit animation should employ.
+    #   By default it uses linear but can be overridden when the easing is
+    #   configured.
+    #
+    attr_reader :easing
 
-  def after_initialize
-    @deltas = {}
+    #
+    # Additional initializion is required to calculate the attributes
+    # that are going to be animated and to determine each of their deltas.
+    #
+    def after_initialize
+      @deltas = {}
 
-    @attributes = to.map { |attribute,final| attribute }
+      @attributes = to.map { |attribute,final| attribute }
 
-    to.each do |attribute,final|
-      start = actor.send(attribute)
-      deltas[attribute] = stepping(easing).calculate(start,final,interval)
+      to.each do |attribute,final|
+        start = actor.send(attribute)
+        deltas[attribute] = stepping(easing).calculate(start.to_f,final.to_f,interval.to_f)
+      end
     end
 
-    step do
+    #
+    # @return the correct easing based on the specified name. When the name
+    #   provided does not match anything then default to linear easing.
+    #
+    def stepping(stepping)
+      @steppings ||= begin
+        hash = Hash.new(Easing::Linear)
+        hash.merge! linear: Easing::Linear,
+          ease_in: Easing::EaseIn
+      end
+      @steppings[stepping]
+    end
+
+    #
+    # The ImplicitAnimation overrides the {Animation#execute_step} and
+    # updates the attributes of the actor based upon the value of the
+    # current animation step.
+    #
+    def execute_step
       attributes.each do |attribute|
         actor.send "#{attribute}=", delta_for_step(attribute)
       end
     end
 
-  end
+    #
+    # @return the delta for the attribute for the given step
+    #
+    def delta_for_step(attribute)
+      deltas[attribute].at(current_step)
+    end
 
+  end
 end

data/lib/metro/game.rb

@@ -33,11 +33,15 @@ module Metro
     def fullscreen?
       !!config.fullscreen
     end
-    
+
     def debug?
       !!config.debug
     end
 
+    def name
+      config.name
+    end
+
     # TODO: ZOrder related constants that belong to Starry Knight
     Background, Stars, Players, UI = *0..3
 

data/lib/metro/game/dsl.rb

@@ -31,6 +31,10 @@ module Metro
       def debug(set_debug = nil)
         set_debug.nil? ? @debug : @debug = set_debug
       end
+      
+      def name(set_name = nil)
+        set_name.nil? ? @name : @name = set_name
+      end
 
     end
   end

data/lib/metro/models/generic.rb

@@ -0,0 +1,12 @@
+module Metro
+  module Models
+
+    #
+    # Generic model is used when no model is cannot not be found
+    # when mapping the view content
+    #
+    class Generic < Model
+
+    end
+  end
+end

data/lib/metro/models/image.rb

@@ -0,0 +1,29 @@
+module Metro
+  module Models
+
+    #
+    # Draws an Image
+    # 
+    # @example Using the Image in a view file
+    #    model: "metro::models::image"
+    # 
+    class Image < Model
+
+      attr_accessor :angle, :center_x, :center_y, :x_factor, :y_factor
+
+      def image
+        @image ||= Gosu::Image.new(window,asset_path(path))
+      end
+
+      def draw
+        image.draw_rot x, y, z_order,
+          angle.to_f,
+          center_x, center_y,
+          x_factor, y_factor,
+          color
+      end
+
+    end
+
+  end
+end