metro-ld25 0.3.3

data/lib/metro/image.rb

@@ -0,0 +1,68 @@
+module Metro
+
+  #
+  # Image is a wrapper class for a Gosu Image. This allows for additional data
+  # to be stored without relying on monkey-patching on functionality.
+  #
+  class Image < SimpleDelegator
+
+    def initialize(gosu_image,path,tileable)
+      super(gosu_image)
+      @path = path
+      @tileable = tileable
+    end
+
+    # The relative path of the image
+    attr_reader :path
+
+    # The tileability of the image
+    attr_reader :tileable
+
+    def dimensions
+      Metro::Units::Dimensions.of width, height
+    end
+
+    #
+    # Finds an existing image or creates a new image given the window, path,
+    # and tileablilty.
+    #
+    # @example Finding or creating an Image
+    #
+    #     Metro::Image.find_or_create window: model.window,
+    #       path: "asset_path", tileable: tileable
+    #
+    def self.find_or_create(options)
+      path = AssetPath.with(options[:path])
+      images[path.to_s] or (images[path.to_s] = create(options))
+    end
+
+    #
+    # Create an image given the window, path, and tileability.
+    #
+    # @example Creating an Image
+    #
+    #     Metro::Image.create window: model.window,
+    #       path: "asset_path", tileable: tileable
+    #
+    def self.create(options)
+      window, asset_path, tileable = create_params(options)
+      gosu_image = Gosu::Image.new(window,asset_path.filepath,tileable)
+      new gosu_image, asset_path.path, tileable
+    end
+
+    private
+
+    def self.create_params(options)
+      options.symbolize_keys!
+      asset_path = AssetPath.with(options[:path])
+      window = options[:window]
+      tileable = !!options[:tileable]
+      [ window, asset_path, tileable ]
+    end
+
+    def self.images
+      @images ||= {}
+    end
+
+  end
+end

data/lib/metro/logging.rb

@@ -0,0 +1,33 @@
+
+#
+# Generates a default logger to standard out that can be used within Metro or the game.
+# 
+# @example Outputting information at the debug level
+# 
+#     log.debug "The the screen resolution is #{Game.width},#{Game.height}"
+# 
+def log
+  @log ||= begin
+    logger = Logger.new(STDOUT)
+    logger.level = Logger::DEBUG
+    logger
+  end
+end
+
+#
+# Display an error message defined within the localization file. A game error displays
+# a error title, message, and actions that can be taken to possibly address this issue.
+# 
+# @param [String] message the I18n string found in the locale file.
+# @param [Hash] details contains all the possible key-value pairs that might be needed
+#  for the localized error messages.
+# 
+def error!(messages, details = {})
+  details = { show: true, exit: true }.merge details
+
+  message = TemplateMessage.new messages: messages, details: details,
+    website: Game.website, contact: Game.contact
+
+  warn message if details[:show]
+  exit 1 if details[:exit]
+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!",
+      position: "20,20,1",
+      color: "rgb(255,0,0)",
+      font: {size: 80},
+      model: "metro::ui::label"
+    
+    draw :message, text: 'The scene `#{self.class.missing_scene}` was requested, but is missing!',
+      position: "20,100,1",
+      color: "rgb(255,255,255)",
+      model: "metro::ui::label"
+
+  end
+end

data/lib/metro/models/audio/song.rb

@@ -0,0 +1,33 @@
+module Metro
+  module Audio
+
+    #
+    # A song represents an audio representation.
+    #
+    class Song < Metro::Model
+
+      property :song
+      property :volume, default: 1.0
+      property :state, type: :text, default: 'play'
+
+      def show
+        song.volume = self.volume
+        play if state == "play"
+      end
+
+      def stop
+        song.stop
+      end
+
+      def play
+        song.play if not song.playing? and not song.paused?
+      end
+
+      def pause
+        song.playing? ? song.pause : song.play
+      end
+
+    end
+
+  end
+end

data/lib/metro/models/draws.rb

@@ -0,0 +1,86 @@
+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 convenience 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',
+      #         model: 'metro::ui::label'
+      #         position: '20,20,0',
+      #         scale: '3,3',
+      #         color: 'rgba(255,255,255,1.0)'
+      #
+      #       def show
+      #         puts "Where is my title? #{title.x},#{title.y}"
+      #       end
+      #     end
+      #
+      def draw(actor_name,options = {})
+
+        view_content_for_actor = view.content[actor_name.to_s]
+
+        actor_data = view_content_for_actor.merge(options)
+        actor_data[:name] = actor_name
+
+        scene_actor = ModelFactory.new actor_name, actor_data
+
+        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 a sound actor with the given anem and options.
+      #
+      # @see #draw
+      #
+      def play(song_name,options={})
+        draw song_name, options.merge(model: "metro::audio::song")
+      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/key_value_coding.rb

@@ -0,0 +1,38 @@
+module Metro
+
+  #
+  # Key-Value coding emulates the functionality found in Objective-C, which allows
+  # for an object to be sent a message which contains the method to return. This is
+  # the same as Ruby. However, Objective-C also supports the use of the dot notation
+  # within the keys to acces the sub-values.
+  #
+  # @example Setting the red value of the color on a Model.
+  #
+  #     class Elf
+  #       include KeyValueCoding
+  #
+  #       attr_accessor :color
+  #     end
+  #
+  #     elf = Elf.new
+  #     elf.color = Gosu::Color.new "rgb(0,0,0)"
+  #
+  #     elf.get("color.red")      # => 0
+  #     elf.set("color.red",255)
+  #     elf.get("color.red")      # => 255
+  #
+  module KeyValueCoding
+
+    def set(name,value)
+      keys = name.to_s.split('.')
+      key_to_set = keys[0..-2].inject(self) {|target,method| target.send(method) }
+      key_to_set.send("#{keys.last}=",value)
+    end
+
+    def get(name)
+      keys = name.to_s.split('.')
+      keys.inject(self) {|target,method| target.send(method) }
+    end
+  end
+
+end

data/lib/metro/models/model.rb

@@ -0,0 +1,236 @@
+require_relative 'key_value_coding'
+require_relative 'properties/property'
+require_relative 'models'
+
+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
+    include PropertyOwner
+    include Units
+
+    #
+    # This is an entry point for customization. As the model's {#initialize}
+    # method performs may perform some initialization that may be necessary.
+    #
+    # At this point the model has been created. However, the window and scene
+    # of the model will not have been defined and defined properties rely on
+    # the window or scene will return nil values. Other properties also will
+    # likely not be set.
+    #
+    # @note This method should be implemented in the Model subclass.
+    #
+    def after_initialize ; end
+
+    #
+    # This is an entry point for customization. After the model's properties
+    # have been set and the model has been assigned to the window and scene
+    # this method is called. Here is where customization of properties or
+    # final positioning can be performed.
+    #
+    # @note This method may be implemented in the Model subclass.
+    #
+    def show ; end
+
+    #
+    # This is called every update interval while the actor is in the scene
+    #
+    # @note This method should be implemented in the Model subclass
+    #
+    def update ; end
+
+    #
+    # This is called after an update. A model normally is not removed after
+    # an update, however if the model responds true to #completed? then it
+    # will be removed.
+    #
+    # @note This method should be implemented in the Model sublclass if you
+    #   are interested in having the model be removed from the scene.
+    #
+    def completed? ; false ; end
+
+    #
+    # This is called after every {#update} and when the OS wants the window to
+    # repaint itself.
+    #
+    # @note This method should be implemented in the Model subclass.
+    #
+    def draw ; end
+
+    def self.model_name(model_name=nil)
+      @model_name ||= to_s.underscore
+      model_name ? @model_name = model_name.to_s : @model_name
+    end
+
+    #
+    # @return [String] the name of the model class.
+    #
+    property :model, type: :text
+
+    #
+    # @return [String] the name of model as it is used within the view or the scene.
+    #   This is the common name, the key within the view file, or the name symbol
+    #   name specified in the scene.
+    #
+    property :name, type: :text
+
+    #
+    # @return [TrueClass,FalseClass] true if the model should be saved to the
+    #   view file, false when the model should not be savedable to the view file.
+    #
+    property :saveable_to_view, type: :boolean, default: true
+
+    #
+    # 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
+
+    include KeyValueCoding
+
+    #
+    # 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,self)
+    end
+
+    #
+    # Allows for the definition of events within the scene.
+    #
+    include HasEvents
+
+    #
+    # A helper method that allows the current model to generate another model. This
+    # is useful as it allows for the current model to pass window and scene state
+    # to the created model.
+    #
+    # @param [String] model_name the name of the model to be created.
+    # @return [Metro::Model] the metro model instance
+    #
+    def create(model_name,options={})
+      # @TODO: this is another path that parallels the ModelFactory
+      model_class = Metro::Models.find(model_name)
+      mc = model_class.new options
+      mc.scene = scene
+      mc.window = window
+      mc
+    end
+
+    #
+    # By default a model has no bounds. Each subclass of model will have to
+    # define how their bounds are defined.
+    #
+    def bounds
+      Bounds.none
+    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 = {})
+      _load(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 = {})
+      # Clean up and symbolize all the keys then merge that with the existing properties
+      options.keys.each do |key|
+        property_name = key.to_s.underscore.to_sym
+        if respond_to? "#{property_name}="
+          send("#{property_name}=",options.delete(key))
+        else
+          options[property_name] = options.delete(key)
+        end
+      end
+
+      properties.merge! 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
+      properties
+    end
+
+    #
+    # Generate a hash representation of the model.
+    #
+    def to_hash
+      { name => properties.except(:name) }
+    end
+
+    #
+    # @return a common name that can be used through the system as a common identifier.
+    #
+    def self.metro_name
+      name.underscore
+    end
+
+    #
+    # @return an array of all ancestor models by name
+    #
+    def self.hierarchy
+      ancestors.find_all {|a| a.respond_to? :metro_name }.map(&:metro_name)
+    end
+
+    #
+    # Captures all classes that subclass Model.
+    #
+    def self.inherited(base)
+      models << base.to_s
+      Models.add(base)
+    end
+
+    #
+    # All subclasses of Model, this should be all the defined
+    #
+    def self.models
+      @models ||= []
+    end
+
+  end
+end
+
+require_relative 'ui/ui'
+require_relative 'audio/song'