metro 0.0.3 → 0.0.5

data/lib/metro/models/label.rb

@@ -0,0 +1,29 @@
+module Metro
+  module Models
+
+    #
+    # Draws a string of text
+    # 
+    # @example Using the Label in a view file
+    #    model: "metro::models::label"
+    # 
+    class Label < Model
+
+      attr_accessor :x, :y, :x_factor, :y_factor, :z_order
+
+      def initialize
+        @x_factor = @y_factor = 1.0
+      end
+
+      def font
+        @font ||= Gosu::Font.new(window, Gosu::default_font_name, 20)
+      end
+
+      def draw
+        label_text = scene.instance_eval( "\"#{text}\"" )
+        font.draw label_text, x, y, z_order, x_factor, y_factor, color
+      end
+
+    end
+  end
+end

data/lib/metro/models/model.rb

@@ -0,0 +1,188 @@
+module Metro
+
+  #
+  # The Model is a basic, generic representation of a game object
+  # that has a visual representation within the scene's window.
+  #
+  # Model is designed to be an abstract class, to be subclassed by
+  # other models.
+  #
+  # @see Models::Generic
+  #
+  class Model
+
+    #
+    # The window that this model that this window is currently being
+    # displayed.
+    #
+    # The current value of window is managed by the scene
+    # as this is set when the Scene is added to the window. All the
+    # models gain access to the window.
+    #
+    # @see Window
+    #
+    attr_accessor :window
+
+    #
+    # The scene that this model is currently being displayed.
+    #
+    # The current value of scene is managed by the scene as this
+    # is set when the scene is created.
+    #
+    # @see Scene
+    attr_accessor :scene
+
+    #
+    # This is an entry point for customization. As the model's {#initialize}
+    # method performs may perform some initialization that may be necessary.
+    #
+    # @note This method should be implemented in the Model subclass.
+    #
+    def after_initialize ; end
+
+    #
+    # Returns the color of the model. In most cases where color is a prominent
+    # attribute (e.g. label) this will be the color. In the cases where color
+    # is less promenint (e.g. image) this will likely be a color that can be
+    # used to influence the drawing of it.
+    #
+    # @see #alpha
+    #
+    attr_reader :color
+
+    #
+    # Sets the color of the model.
+    #
+    # @param [String,Fixnum,Gosu::Color] value the new color to set.
+    #
+    def color=(value)
+      @color = Gosu::Color.new(value)
+    end
+
+    #
+    # @return the alpha value of the model's color. This is an integer value
+    #   between 0 and 255.
+    #
+    def alpha
+      color.alpha
+    end
+
+    #
+    # Sets the alpha of the model.
+    #
+    # @param [String,Fixnum] value the new value of the alpha level for the model.
+    #   This value should be between 0 and 255.
+    #
+    def alpha=(value)
+      # TODO: coerce the value is between 0 and 255
+      color.alpha = value.to_i
+    end
+
+    #
+    # Create an instance of a model.
+    #
+    # @note Overridding initialize method should be avoided, using the {#aftter_initialize)
+    # method or done with care to ensure that functionality is preserved.
+    #
+    def initialize(options = {})
+      after_initialize
+    end
+
+    #
+    # Loads a hash of content into the model. This process will convert the hash
+    # of content into setter and getter methods with appropriate ruby style names.
+    #
+    # This is used internally when the model is created for the Scene. It is loaded
+    # with the contents of the view.
+    #
+    def _load(options = {})
+      options = {} unless options
+
+      options.each do |raw_key,value|
+
+        key = raw_key.dup
+        key.gsub!(/-/,'_')
+        key.gsub!(/([A-Z\d]+)([A-Z][a-z])/,'\1_\2')
+        key.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+
+        unless respond_to? key
+          self.class.send :define_method, key do
+            instance_variable_get("@#{key}")
+          end
+        end
+
+        unless respond_to? "#{key}="
+          self.class.send :define_method, "#{key}=" do |value|
+            instance_variable_set("@#{key}",value)
+          end
+        end
+
+        _loaded_options.push key
+        send "#{key}=", value
+      end
+
+    end
+
+    def _loaded_options
+      @_loaded_options ||= []
+    end
+
+    #
+    # Generate a hash export of all the fields that were previously stored within
+    # the model.
+    #
+    # This is used internally within the scene to transfer the data from one model
+    # to another model.
+    #
+    def _save
+      data_export = @_loaded_options.map {|option| [ option, send(option) ] }.flatten
+      Hash[*data_export]
+    end
+
+    #
+    # Captures all classes that subclass Model.
+    #
+    # @see #self.scenes
+    #
+    def self.inherited(base)
+      models << base
+    end
+
+    #
+    # All subclasses of Model, this should be all the defined model within the game.
+    #
+    # @return an Array of Scene subclasses
+    #
+    def self.models
+      @models ||= []
+    end
+
+    #
+    # Convert the specified model name into the class of the model.
+    #
+    # @return the Model class given the specified model name.
+    def self.model(name)
+      @models_hash ||= begin
+
+        hash = Hash.new(Models::Generic)
+
+        models.each do |model|
+          common_name = model.to_s.gsub(/([A-Z\d]+)([A-Z][a-z])/,'\1_\2')
+          common_name.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+          common_name.downcase!
+
+          hash[common_name] = model
+        end
+        hash
+      end
+
+      @models_hash[name]
+    end
+
+  end
+end
+
+require_relative 'generic'
+require_relative 'label'
+require_relative 'select'
+require_relative 'image'

data/lib/metro/models/select.rb

@@ -0,0 +1,77 @@
+module Metro
+  module Models
+
+    #
+    # Draws a a menu of options. It is called a Select as it is named after the HTML
+    # element select. A select model also inserts itself into the scene as an event
+    # target as it needs to maintain the state of the menu. When an option is selected
+    # an event is fired based on the name of the option.
+    #
+    # @note Only one 'select' can be defined for a given scene.
+    #
+    class Select < Model
+      attr_accessor :selected_index, :options
+
+      def initialize
+        @selected_index = 0
+      end
+
+      def window=(value)
+        @window = value
+        events
+      end
+      
+      def events
+        relay = EventRelay.new(self,window)
+
+        relay.on_up Gosu::KbLeft, Gosu::GpLeft, Gosu::KbUp, Gosu::GpUp, do: :previous_option
+        relay.on_up Gosu::KbRight, Gosu::GpRight, Gosu::KbDown, Gosu::GpDown, do: :next_option
+        relay.on_up Gosu::KbEnter, Gosu::KbReturn, Gosu::GpButton0, do: :selection
+
+        scene.add_event_relay relay
+      end
+
+      def selection
+        scene_method = options[selected_index].downcase.gsub(/\s/,'_')
+        scene.send scene_method
+      end
+
+      def previous_option
+        @selected_index = @selected_index - 1
+        @selected_index = options.length - 1 if @selected_index <= -1
+      end
+
+      def next_option
+        @selected_index = @selected_index + 1
+        @selected_index = 0 if @selected_index >= options.length
+      end
+
+      def font
+        @font ||= Gosu::Font.new(window, Gosu::default_font_name, 20)
+      end
+
+      attr_reader :highlight_color
+
+      def highlight_color=(value)
+        @highlight_color = Gosu::Color.new(value)
+      end
+
+      def alpha=(value)
+        color.alpha = value.floor
+        highlight_color.alpha = value.floor
+      end
+
+      def draw
+        options.each_with_index do |option,index|
+
+          draw_color = color
+          draw_color = highlight_color if index == selected_index
+
+          y_position = y + padding * index
+          font.draw option, x, y_position, Metro::Game::UI, 1.0, 1.0, draw_color
+        end
+      end
+
+    end
+  end
+end

data/lib/metro/scene.rb

@@ -1,4 +1,5 @@
 require_relative 'scene_view/scene_view'
+require_relative 'scene_actor'
 require_relative 'event_relay'
 require_relative 'animation/animation'
 
@@ -20,6 +21,15 @@ module Metro
   #
   class Scene
 
+    #
+    # As Scene does a lot of work for you with regarding to setting up content, it is
+    # best not to override #initialize and instead define an #after_initialize method
+    # within the subclasses of Scene.
+    #
+    # @note This method should be implemented in the Scene subclass.
+    #
+    def after_initialize ; end
+
     #
     # The events method is where a scene has access to configure the events that it
     # would like to listen for during the scene.
@@ -79,6 +89,62 @@ module Metro
     #
     def prepare_transition_from(old_scene) ; end
 
+
+    #
+    # Define a scene actor with the given name and options.
+    #
+    def self.draw(actor_name,options = {})
+      scene_actor = SceneActor.new actor_name, options
+
+      define_method actor_name do
+        instance_variable_get("@#{actor_name}")
+      end
+
+      define_method "#{actor_name}=" do |value|
+        instance_variable_set("@#{actor_name}",value)
+      end
+
+      scene_actors.push scene_actor
+    end
+
+    #
+    # Define several standard scene actors.
+    #
+    def self.draws(*actor_names)
+      actor_names = actor_names.flatten.compact
+
+      actor_names.each do |actor_name|
+        draw actor_name
+      end
+
+      scene_actors
+    end
+
+    #
+    # @return a list of all the SceneActors that have been defined for this Scene.
+    #
+    def self.scene_actors
+      @scene_actors ||= []
+    end
+
+    #
+    # Setups up the Actors for the Scene based on the SceneActors that have been
+    # defined.
+    #
+    # @note this method should not be overriden, otherwise the actors will perish!
+    # @see #after_initialize
+    #
+    def initialize
+      self.class.scene_actors.each do |scene_actor|
+        actor_data = { 'name' => scene_actor.name }.merge (view[scene_actor.name] || {})
+        actor_instance = scene_actor.create(actor_data)
+        actor_instance.scene = self
+        send "#{scene_actor.name}=", actor_instance
+      end
+
+      after_initialize
+    end
+
     #
     # The window is the main instance of the game. Using window can access a lot of
     # underlying Metro::Window, a subclass of Gosu::Window, that the Scene class is
@@ -104,6 +170,16 @@ module Metro
 
       @event_relays << @scene_events
 
+      @updaters = []
+
+      @drawers = []
+
+      self.class.scene_actors.each do |scene_actor|
+        actor = send(scene_actor.name)
+        actor.window = window
+        @drawers << actor
+      end
+
       show
     end
 
@@ -170,17 +246,35 @@ module Metro
     end
 
     #
-    # The `base_draw` method is called by the Game Window. This is allow for any special
-    # drawing needs to be handled before calling the traditional `draw` method defined
-    # in the subclassed Scene.
+    # Enqueue will add an updater to the list of updaters that are run initially when
+    # update is called. An updater is any object that can respond to #update. This
+    # is used for animations.
+    #
+    def enqueue(updater)
+      @updaters << updater
+    end
+
+    #
+    # The `base_update` method is called by the Game Window. This is to allow for any
+    # special update needs to be handled before calling the traditional `update` method
+    # defined in the subclassed Scene.
+    #
+    def base_update
+      @updaters.each { |updater| updater.update }
+      update
+    end
+
+    #
+    # The `base_draw` method is called by the Game Window. This is to allow for any
+    # special drawing needs to be handled before calling the traditional `draw` method
+    # defined in the subclassed Scene.
     #
     def base_draw
+      @drawers.each { |drawer| drawer.draw }
       draw
     end
 
     # This provides the functionality for view handling.
-    # @note the inclusion of view functionality redefines {#base_draw} so it must proceed
-    #   the declaration of that method.
     include SceneView
 
     #
@@ -196,7 +290,6 @@ module Metro
       window.scene = new_scene
     end
 
-
     #
     # Before a scene is transitioned away from to a new scene, this private method is
     # here to allow for any housekeeping or other work that needs to be done before
@@ -207,6 +300,13 @@ module Metro
     #
     def _prepare_transition(new_scene)
       log.debug "Preparing to transition from scene #{self} to #{new_scene}"
+
+      new_scene.class.scene_actors.find_all {|actor| actor.load_from_previous_scene? }.each do |scene_actor|
+        new_actor = new_scene.send(scene_actor.name)
+        current_actor = send(scene_actor.name)
+        new_actor._load current_actor._save
+      end
+
       prepare_transition_to(new_scene)
       new_scene.prepare_transition_from(self)
     end