metro-ld26 0.3.4

data/lib/metro/scenes.rb

@@ -0,0 +1,154 @@
+module Metro
+
+  #
+  # @example Finding a scene based on the scene name
+  #
+  #     class IntroScene < Metro::Scene
+  #       # ... scene content ...
+  #     end
+  #
+  #     Scenes.find("intro")    # => IntroScene
+  #     Scenes.find(:intro)     # => IntroScene
+  #
+  # @example Creating a scene instance based on the scene name
+  #
+  #     class IntroScene < Metro::Scene
+  #       # ... scene content ...
+  #     end
+  #
+  #     Scenes.generate("intro")    # => [SCENE: title]
+  #     Scenes.generate(:intro)     # => [SCENE: title]
+  #
+  # @example Finding a scene that does not exist
+  #
+  #     scene = Scenes.find(:unknown)
+  #     scene.missing_scene            # => :unknown
+  #
+  module Scenes
+    extend self
+
+    #
+    # Add a scene to the hash of scenes with the scene name of the scene as the key
+    # to retrieving this scene.
+    #
+    # @param [Scene] scene the scene to be added to the hash of Scenes.
+    #
+    def add(scene)
+      all_scenes_for(scene).each { |scene| scenes_hash[scene.scene_name] = scene.to_s }
+    end
+
+    #
+    # Finds the scene based on the specified scene name.
+    #
+    # @param [String,Symbol] scene_name the name of the scene to locate.
+    # @return the Scene class that is found matching the specified scene name.
+    #
+    def find(scene_name)
+      scenes_hash[scene_name].constantize
+    end
+
+    #
+    # @return [Array<String>] all the names supported by the scenes hash.
+    #
+    def list
+      scenes_hash.keys
+    end
+
+    #
+    # Finds the scene with the specified name and then creates an instance of that
+    # scene.
+    #
+    # @param [String,Symbol,Object] scene_name the name of the scene to locate.
+    # @return an instance of Scene that is found matching the specified scene name
+    #
+    def generate(scene_or_scene_name,options = {})
+      new_scene = generate_scene_from(scene_or_scene_name)
+      apply_post_filters(new_scene,options)
+    end
+
+    #
+    # If we have been given a scene, then we simply want to use it otherwise
+    # we need to find and generate our scene from the scene name.
+    #
+    # @param [String,Sybmol,Class] scene_or_scene_name the name of the scene or an instance
+    #   of Scene.
+    #
+    def generate_scene_from(scene_or_scene_name)
+      if scene_or_scene_name.is_a? Scene
+        scene_or_scene_name
+      else
+        find(scene_or_scene_name).new
+      end
+    end
+
+    #
+    # Post filters are applied to the scene after it has been found. These are
+    # all objects that can respond to the #filter method.
+    #
+    def post_filters
+      @post_filters ||= []
+    end
+
+    #
+    # Register a filter that will be executed after a scene is found and generated. This
+    # allows for the scene to be modified or changed based on the provided options.
+    #
+    # A filter is any object that responds to #filter and accepts two parameters: the
+    # scene and a hash of options.
+    #
+    # @param [#filter] post_filter a filter is an object that can act as a filter.
+    #
+    def register_post_filter(post_filter)
+      post_filters.push(post_filter)
+    end
+
+    private
+
+    #
+    # Apply all the post filtering to the specified scene with the given options
+    #
+    # @return a Scene object that has been filtered.
+    #
+    def apply_post_filters(new_scene,options)
+      post_filters.inject(new_scene) {|scene,post| post.filter(scene,options) }
+    end
+
+    #
+    # @return a Hash that allows for accessing  symbol names of the scenes
+    #   as well as the class name constants to allow for the scenes to be found.
+    #
+    def scenes_hash
+      @scenes_hash ||= hash_with_missing_scene_default
+    end
+
+    #
+    # Create a hash that will return a setup missing scene by default.
+    #
+    def hash_with_missing_scene_default
+      hash = HashWithIndifferentAccess.new do |hash,key|
+        missing_scene = hash[:missing_scene].constantize
+        missing_scene.missing_scene = key.to_sym
+        missing_scene
+      end
+      hash[:missing_scene] = "Metro::MissingScene"
+      hash
+    end
+
+    #
+    # Returns all subclassed scenes of the scene or scenes provided. This method is
+    # meant to be called recursively to generate the entire list of all the scenes.
+    #
+    # @param [Scene,Array<Scene>] scenes a scene or scene subclass or an array of
+    #   scene subclasses.
+    #
+    def all_scenes_for(scenes)
+      Array(scenes).map do |scene_class_name|
+        scene = scene_class_name.constantize
+        [ scene ] + all_scenes_for(scene.scenes)
+      end.flatten.compact
+    end
+
+  end
+end
+
+require_relative 'transitions/scene_transitions'

data/lib/metro/song.rb

@@ -0,0 +1,56 @@
+module Metro
+
+  #
+  # Song is a wrapper class for a Gosu Song. This allows for additional data to be stored
+  # without relying on monkey-patching on functionality.
+  #
+  class Song < SimpleDelegator
+
+    attr_accessor :song, :path
+
+    def initialize(song,path)
+      super(song)
+      @song = song
+      @path = path
+    end
+
+    #
+    # Finds an existing song or creates a new song given the window and path.
+    #
+    # @example Finding or creating an Song
+    #
+    #     Metro::Image.find_or_create window: model.window, path: "asset_path"
+    #
+    def self.find_or_create(options)
+      path = AssetPath.with(options[:path])
+      songs[path.to_s] or (songs[path.to_s] = create(options))
+    end
+
+    #
+    # Create an Song given the window and path.
+    #
+    # @example Creating an Song
+    #
+    #     Metro::Song.create window: model.window, path: "asset_path"
+    #
+    def self.create(options)
+      window, asset_path = create_params(options)
+      gosu_song = Gosu::Song.new(window,asset_path.filepath)
+      new gosu_song, asset_path.path
+    end
+
+    private
+
+    def self.create_params(options)
+      options.symbolize_keys!
+      asset_path = AssetPath.with(options[:path])
+      window = options[:window]
+      [ window, asset_path ]
+    end
+
+    def self.songs
+      @songs ||= {}
+    end
+
+  end
+end

data/lib/metro/template_message.rb

@@ -0,0 +1,60 @@
+class TemplateMessage
+
+  def initialize(details = {})
+    @messages = Array(details[:message]) + Array(details[:messages])
+    @details = details[:details]
+    @website = details[:website]
+    @email = details[:contact]
+  end
+
+  class Message
+    
+    attr_reader :name, :details
+    
+    def initialize(name,details)
+      @name = name
+      @details = details
+    end
+
+    def field_locale(field)
+      I18n.t("#{name}.#{field}",details)
+    end
+
+    def title
+      field_locale 'title'
+    end
+
+    def message
+      field_locale 'message'
+    end
+
+    def actions
+      Array( field_locale('actions') ).map {|action| "* #{action}" }.join("\n")
+    end
+  end
+
+  def messages
+    @messages.map {|m| Message.new m, @details }
+  end
+
+  def website
+    Array(@website).map {|website| "* #{website}" }.join("\n")
+  end
+
+  def email
+    Array(@email).map {|email| "* #{email}" }.join("\n")
+  end
+
+  def message_filename
+    File.join(File.dirname(__FILE__),"..","templates","message.erb")
+  end
+
+  def message_template
+    File.read(message_filename)
+  end
+
+  def to_s
+    ERB.new(message_template).result(binding)
+  end
+
+end

data/lib/metro/transitions/edit_transition_scene.rb

@@ -0,0 +1,100 @@
+require_relative '../events/hit_list'
+
+module Metro
+
+  #
+  # The Edit Transition Scene is place where scenes go to be edited. Any scene
+  # can transition into edit mode. This scene will copy all the actors and
+  # gain access to the view.
+  #
+  # This scene grants new keyboard commands that will enable, disable, and
+  # toggle feature of edit mode:
+  #
+  # * `e` will end edit mode
+  # * `g` will toggle the display of the grid
+  # * `l` will toggle the display of the model labels
+  # * `b` will toggle the bounding boxes around the models.
+  #
+  class EditTransitionScene < Metro::TransitionScene
+
+    def initialize
+      #
+      # The EditTransitionScene needs to have all the drawers
+      # cleared from the class because it may still have
+      # drawers from other things that this was executed.
+      #
+      # This is a product of using the classes to store the definitions
+      # of scene. This means we need to change this so that it is much
+      # easier to dup scenes.
+      #
+      self.class.drawings.clear
+      self.class.draw :overlay, model: "metro::ui::grid_drawer"
+      self.class.draw :labeler, model: "metro::ui::model_labeler"
+      add_actors_to_scene
+      after_initialize
+    end
+
+    def prepare_transition_from(old_scene)
+      next_scene.prepare_transition_from(old_scene)
+      @previous_scene = old_scene
+
+      # Set the view name to the previous scene's view name
+      self.class.view_name old_scene.view_name
+      self.class.view.format = old_scene.class.view.format
+
+      # import all the actors from the previous scene into the current scene.
+      old_scene.class.actors.each do |scene_actor|
+        self.class.draw scene_actor.name, scene_actor.options
+      end
+
+      add_actors_to_scene
+    end
+
+    def show
+      window.show_cursor
+    end
+
+    event :on_up, KbE do
+      transition_to next_scene.scene_name
+    end
+
+    event :on_up, KbG do
+      overlay.enabled = !overlay.enabled
+    end
+
+    event :on_up, KbL do
+      labeler.should_draw_labels = !labeler.should_draw_labels
+    end
+
+    event :on_up, KbB do
+      labeler.should_draw_bounding_boxes = !labeler.should_draw_bounding_boxes
+    end
+
+    #
+    # Generate a hitlist which manages the click start, hold, and release
+    # of the mouse button.
+    #
+    def hitlist
+      @hitlist ||= HitList.new(drawers)
+    end
+
+    event :on_down, MsLeft do |event|
+      hitlist.hit(event)
+    end
+
+    event :on_hold, MsLeft do |event|
+      hitlist.update(event)
+    end
+
+    event :on_up, MsLeft do |event|
+      hitlist.release(event)
+    end
+
+    event :on_up, KbS do
+      log.info "Saving changes to Scene #{previous_scene} View - #{view_name}"
+      save_view
+    end
+
+  end
+
+end

data/lib/metro/transitions/fade_transition_scene.rb

@@ -0,0 +1,66 @@
+module Metro
+  class FadeTransitionScene < TransitionScene
+
+    draw :rectangle, model: "metro::ui::rectangle"
+
+    #
+    # When the scene is shown set up the starting color for the rectangle
+    # and queue the animation to transition the color to the final color.
+    #
+    def show
+      rectangle.color = starting_color
+
+      color = final_color
+
+      animate :rectangle, to: { red: color.red,
+                                green: color.green,
+                                blue: color.blue,
+                                alpha: color.alpha },
+                          interval: interval do
+
+        transition_to next_scene
+      end
+    end
+
+    def interval
+      options[:interval] || default_interval
+    end
+
+    def default_interval
+      60
+    end
+
+    def starting_color
+      options_starting_color || default_starting_color
+    end
+
+    def options_starting_color
+      color_from_options(:from)
+    end
+
+    def default_starting_color
+      Gosu::Color.new "rgb(255,255,255)"
+    end
+
+    def final_color
+      options_final_color || default_final_color
+    end
+
+    def options_final_color
+      color_from_options(:to)
+    end
+
+    def default_final_color
+      Gosu::Color.new "rgb(0,0,0)"
+    end
+
+    def color_from_options(position)
+      if options[position]
+        if options[position][:color]
+          Gosu::Color.new options[position][:color]
+        end
+      end
+    end
+
+  end
+end

data/lib/metro/transitions/scene_transitions.rb

@@ -0,0 +1,44 @@
+require_relative 'transition_scene'
+
+module Metro
+  module SceneTransitions
+    extend self
+
+    def insert_transition(scene,options)
+      return scene unless options.key?(:with)
+      name = options[:with]
+      generate_transition(name,scene,options)
+    end
+
+    alias_method :filter, :insert_transition
+
+    def generate_transition(name,next_scene,options)
+      transition = find_transition(name).new
+      transition.next_scene = next_scene
+      transition.options = options
+      transition
+    end
+
+    def find_transition(name)
+      transition_name = supported_transitions[name]
+      transition_name.constantize
+    end
+
+    def supported_transitions
+      @supported_transitions ||= begin
+        hash = HashWithIndifferentAccess.new("Metro::FadeTransitionScene")
+        hash[:edit] = "Metro::EditTransitionScene"
+        hash
+      end
+    end
+
+  end
+
+  #
+  # The Scene Transition should act as a filter and allow for
+  # common or custom scenes to be inserted between the scene
+  # that was about to be displayed.
+  #
+  Scenes.register_post_filter SceneTransitions
+
+end