metro 0.0.6 → 0.1.0

data/lib/metro/events/unknown_sender.rb

@@ -0,0 +1,5 @@
+module Metro
+  class UnknownSender
+    
+  end
+end

data/lib/metro/game.rb

@@ -42,6 +42,18 @@ module Metro
       config.name
     end
 
+    def authors
+      config.authors
+    end
+
+    def website
+      config.website
+    end
+
+    def contact
+      config.contact
+    end
+
     # TODO: ZOrder related constants that belong to Starry Knight
     Background, Stars, Players, UI = *0..3
 

data/lib/metro/game/dsl.rb

@@ -27,15 +27,34 @@ module Metro
       def fullscreen(set_fullscreen = nil)
         set_fullscreen.nil? ? @fullscreen : @fullscreen = set_fullscreen
       end
-      
+
       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
 
+      def author(name)
+        authors.push name
+      end
+
+      def authors
+        @authors ||= []
+      end
+
+      alias_method :artist, :author
+      alias_method :designer, :author
+
+      def website(game_website = nil)
+        game_website ? @website = game_website : @website
+      end
+
+      def contact(game_contact = nil)
+        game_contact ? @contact = game_contact : @contact
+      end
+
     end
   end
 end

data/lib/metro/missing_scene.rb

@@ -0,0 +1,21 @@
+module Metro
+  class MissingScene < Scene
+    scene_name :missing_scene
+
+    class << self
+      attr_accessor :missing_scene
+    end
+
+    draw :title, text: "Missing Scene!",
+      x: 20, y: 20, z_order: 1,
+      x_factor: 3, y_factor: 3,
+      color: 0xffffffff,
+      model: "metro::models::label"
+
+    draw :message, text: 'The scene `#{self.class.missing_scene}` was requested, but is missing!',
+      x: 20, y: 100, z_order: 1,
+      color: 0xffffffff,
+      model: "metro::models::label"
+
+  end
+end

data/lib/metro/models/draws.rb

@@ -0,0 +1,71 @@
+require_relative 'model_factory'
+
+module Metro
+  module Draws
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+
+      #
+      # Define an actor with the given name and options.
+      #
+      # As a convience the draw method will define `getter` and `setter`
+      # methods for the specified actor.
+      #
+      # @example Defining a title label within a scene
+      #
+      #     class ExampleScene
+      #       draw :title, 'text' => 'Title Screen',
+      #         'x' => 20, 'y' => 20, 'z-order' => 0,
+      #         'x-factor' => 3, 'y-factor' => 3,
+      #         'color' => 0xffffffff,
+      #         'model' => 'metro::models::label'
+      #
+      #       def show
+      #         puts "Where is my title? #{title.x},#{title.y}"
+      #       end
+      #     end
+      #
+      def draw(actor_name,options = {})
+        scene_actor = ModelFactory.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
+
+        drawings.push scene_actor
+      end
+
+      #
+      # Define several actors to be drawn.
+      #
+      def draws(*actor_names)
+        actor_names = actor_names.flatten.compact
+
+        actor_names.each do |actor_name|
+          draw actor_name
+        end
+
+        drawings
+      end
+
+      #
+      # All of the model factories that have been defined.
+      #
+      def drawings
+        @drawings ||= []
+      end
+
+      alias_method :actors, :drawings
+
+    end
+
+  end
+end

data/lib/metro/models/label.rb

@@ -14,6 +14,8 @@ module Metro
       def after_initialize
         @text = ""
         @x_factor = @y_factor = 1.0
+        @z_order = 0
+        @color = Gosu::Color.new "rgba(255,255,255,1.0)"
       end
 
       def font

data/lib/metro/models/menu.rb

@@ -6,29 +6,34 @@ module Metro
     # 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 'menu' can be defined for a given scene.
+    # @note Only one 'menu' can be defined for a given scene
     #
     class Menu < Model
+
+      event :on_up, Gosu::KbLeft, Gosu::GpLeft, Gosu::KbUp, Gosu::GpUp do
+        previous_option
+      end
+
+      event :on_up, Gosu::KbRight, Gosu::GpRight, Gosu::KbDown, Gosu::GpDown do
+        next_option
+      end
+
+      event :on_up, Gosu::KbEnter, Gosu::KbReturn, Gosu::GpButton0 do
+        selection
+      end
+
       attr_reader :selected_index, :menu_options
 
+      attr_accessor :padding
+
       def after_initialize
         @selected_index = 0
+        @padding = 40
       end
 
       def window=(value)
         @window = value
         @menu_options = options.map {|option| Option.new option }
-        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
@@ -78,11 +83,25 @@ module Metro
         end
       end
 
+      #
+      # The Option represents a choice within the menu.
+      #
       class Option
 
+        #
+        # The raw data that was used to create the option.
+        #
         attr_reader :data
 
-        attr_accessor :name, :method
+        #
+        # The human readable name of the option.
+        #
+        attr_accessor :name
+
+        #
+        # The method to execute within the scene when the option is selected.
+        #
+        attr_accessor :method
 
         def initialize(data)
           @data = data
@@ -94,9 +113,7 @@ module Metro
             @name = data
             @method = data.to_s.downcase.gsub(/\s/,'_').gsub(/^[^a-zA-Z]*/,'').gsub(/[^a-zA-Z0-9\s_]/,'')
           end
-
         end
-
       end
 
     end

data/lib/metro/models/model.rb

@@ -40,6 +40,20 @@ module Metro
     #
     def after_initialize ; end
 
+    #
+    # Generate a custom notification event with the given name.
+    #
+    # @param [Symbol] event the name of the notification to generate.
+    # 
+    def notification(event)
+      scene.notification(event.to_sym)
+    end
+
+    #
+    # Allows for the definition of events within the scene.
+    # 
+    include HasEvents
+
     #
     # 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

data/lib/metro/{scene_actor.rb → models/model_factory.rb}

@@ -1,5 +1,5 @@
 module Metro
-  class SceneActor
+  class ModelFactory
 
     attr_reader :name, :options
 

data/lib/metro/scene.rb

@@ -1,6 +1,12 @@
 require_relative 'scene_view/scene_view'
-require_relative 'scene_actor'
-require_relative 'event_relay'
+
+require_relative 'events/has_events'
+require_relative 'events/event_relay'
+require_relative 'events/unknown_sender'
+
+require_relative 'models/draws'
+
+require_relative 'animation/has_animations'
 require_relative 'animation/animation'
 
 module Metro
@@ -30,19 +36,6 @@ module Metro
     #
     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.
-    #
-    # @note This method should be implemented in the Scene subclass.
-    #
-    # @param [EventRelay] e is the EventRelay that you can register for button up,
-    #   button down, or button held events.
-    #
-    # @see EventRelay
-    #
-    def events(e) ; end
-
     #
     # This method is called right after the scene has been adopted by the window
     #
@@ -89,53 +82,58 @@ module Metro
     #
     def prepare_transition_from(old_scene) ; end
 
+    include Draws
 
     #
-    # Define a scene actor with the given name and options.
+    # When an actor is defined, through the class method `draw` a getter and setter method
+    # is defined. However, it is a better interface internally not to rely heavily on send
+    # and have this small amount of obfuscation in the event that this needs to change.
     #
-    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
+    # @return the actor with the given name.
+    #
+    def actor(name)
+      send(name)
     end
 
     #
-    # Define several standard scene actors.
+    # Post a custom notification event. This will trigger any objects that are listening
+    # for custom events.
     #
-    def self.draws(*actor_names)
-      actor_names = actor_names.flatten.compact
+    def notification(event)
 
-      actor_names.each do |actor_name|
-        draw actor_name
-      end
+      # __sender__ is made available through the sender gem, this is solely to make the
+      # the api call to generate a notification simply `#notification`. Freeing the caller
+      # from having to include themself in the execution.
+      #
+      # @note if the sender functionality proves troublesome across platforms this can
+      #   be dropped and simply require the sender to be included.
+      #
+      sender = __sender__ rescue UnknownSender
 
-      scene_actors
+      event_relays.each do |relay|
+        relay.fire_events_for_notification(event,sender)
+      end
     end
 
     #
-    # @return a list of all the SceneActors that have been defined for this Scene.
+    # A scene has events which it will register when the window is established.
     #
-    def self.scene_actors
-      @scene_actors ||= []
-    end
+    include HasEvents
 
     #
-    # Setups up the Actors for the Scene based on the SceneActors that have been
+    # A scene defines animations which it will execute when the scene starts
+    #
+    include HasAnimations
+
+    #
+    # Setups up the Actors for the Scene based on the ModelFactories 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|
+      self.class.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
@@ -163,24 +161,50 @@ module Metro
     def window=(window)
       @window = window
 
-      @event_relays = []
+      event_relays.clear
 
-      @scene_events = EventRelay.new(self,window)
-      events(@scene_events)
+      register_events!
+      register_actors!
+      register_animations!
 
-      @event_relays << @scene_events
+      show
+    end
 
-      @updaters = []
+    #
+    # Register all the events that were defined for this scene.
+    #
+    def register_events!
+      register_events_for_target(self,self.class.events)
+    end
 
-      @drawers = []
+    #
+    # Register all the actors that were defined for this scene.
+    #
+    def register_actors!
+      self.class.actors.each { |actor| register_actor(actor) }
+    end
 
-      self.class.scene_actors.each do |scene_actor|
-        actor = send(scene_actor.name)
-        actor.window = window
-        @drawers << actor
+    #
+    # Register all the animations that were defined for this scene.
+    #
+    def register_animations!
+      self.class.animations.each do |animation|
+        animate animation.options, &animation.on_complete_block
       end
+    end
 
-      show
+    #
+    # Registering an actor involves setting up the actor within
+    # the window, adding them to the list of things that need to be
+    # drawn and then registering any eventst that they might have.
+    #
+    def register_actor(actor_factory)
+      registering_actor = actor(actor_factory.name)
+      registering_actor.window = window
+
+      drawers.push(registering_actor)
+
+      register_events_for_target(registering_actor,registering_actor.class.events)
     end
 
     #
@@ -210,7 +234,7 @@ module Metro
     #
     def self.scene_name(scene_name=nil)
       @scene_name ||= begin
-        root_name = to_s[/^(.+)Scene$/,1]
+        root_name = to_s.gsub(/Scene$/,'')
         root_name.gsub!(/([A-Z\d]+)([A-Z][a-z])/,'\1_\2')
         root_name.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
         root_name.downcase!
@@ -251,7 +275,7 @@ module Metro
     # is used for animations.
     #
     def enqueue(updater)
-      @updaters << updater
+      updaters.push(updater)
     end
 
     #
@@ -259,28 +283,47 @@ module Metro
     # to be an implicit animation.
     #
     def animate(options,&block)
+      options[:actor] = actor(options[:actor]) if options[:actor].is_a? Symbol
       animation = Metro::ImplicitAnimation.new options.merge(context: self)
       animation.on_complete(&block) if block
       enqueue animation
     end
 
+
+    #
+    # The objects that need to be executed on every update. These objects are traditionally
+    # animations or window events for held pressed buttons. But can be any objects that responds
+    # to the method #update.
+    #
+    def updaters
+      @updaters ||= []
+    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 }
+      updaters.each { |updater| updater.update }
       update
     end
 
+    #
+    # The objects that need to be drawn with every draw cycle. These objects are traditionally
+    # the model objects, like the actors defined within the scene.
+    #
+    def drawers
+      @drawers ||= []
+    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 }
+      drawers.each { |drawer| drawer.draw }
       draw
     end
 
@@ -311,9 +354,9 @@ 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_scene.class.actors.find_all {|actor_factory| actor_factory.load_from_previous_scene? }.each do |actor_factory|
+        new_actor = new_scene.actor(actor_factory.name)
+        current_actor = actor(actor_factory.name)
         new_actor._load current_actor._save
       end
 
@@ -321,6 +364,26 @@ module Metro
       new_scene.prepare_transition_from(self)
     end
 
+    #
+    # Helper method that is used internally to setup the events for the specified target.
+    #
+    # @param [Object] target the intended target for the specified events. This object
+    #   will have the appropriate methods and functionality to respond appropriately
+    #   to the action blocks defined in the methods.
+    #
+    # @param [Array<EventFactory>] events an array of EventFactory objects that need to now
+    #   be mapped to the specified target.
+    #
+    def register_events_for_target(target,events)
+      target_relay = EventRelay.new(target,window)
+
+      events.each do |target_event|
+        target_relay.send target_event.event, *target_event.buttons, &target_event.block
+      end
+
+      event_relays.push(target_relay)
+    end
+
     #
     # The events object that is configured through the {#events} method, which stores
     # all the gamepad and keyboard events defined. By default a scene has an event
@@ -329,17 +392,8 @@ module Metro
     # @see Events
     # @see #add_event_relay
     #
-    attr_reader :event_relays
-
-    #
-    # Add an additional event relay to the list of event relays. It is appended
-    # to the end of the list of relays.
-    #
-    # @param [EventRelay] event_relay an event relay instance that will now
-    #   receive events generated from this scene.
-    #
-    def add_event_relay(event_relay)
-      @event_relays << event_relay
+    def event_relays
+      @event_relays ||= []
     end
 
     #