metro-ld26 0.3.4

data/lib/metro/animation/scene_animation.rb

@@ -0,0 +1,16 @@
+require_relative 'on_update_operation'
+
+module Metro
+
+  module SceneAnimation
+    extend self
+
+    def build(options,&block)
+      animation = Metro::ImplicitAnimation.new options
+      animation.on_complete(&block) if block
+      animation
+    end
+
+  end
+
+end

data/lib/metro/asset_path.rb

@@ -0,0 +1,97 @@
+
+#
+# The asset_path is a helper which will generate a filepath based on the current
+# working directory of the game. This allows for game author's to specify a path
+# relative within the assets directory of their game.
+#
+# @note Paths that are defined within views use this helper and are assumed to
+#   be paths relative within the assets directory of the game. For images,
+#   samples, and songs in a model consider using a property.
+#
+# @see Metro::Model::ImageProperty
+# @see Metro::Model::AnimationProperty
+# @see Metro::Model::SongProperty
+# @see Metro::Model::SampleProperty
+#
+# @note Also consider the model classes Image, Animation, Song, and Sample for
+#   creating the assets found within the assets folder. Each of those will
+#   assist with using the asset_path internally to find the asset.
+#
+# @see Metro::Image
+# @see Metro::Animation
+# @see Metro::Song
+# @see Metro::Sample
+#
+# @example Loading a raw Gosu::Image with an `asset_path`
+#
+#     class Player < Metro::Model
+#       def image
+#         @image ||= Gosu::Image.new( window, asset_path("player.png"), false )
+#       end
+#       def draw
+#         image.draw_rot(x,y,2,angle)
+#       end
+#     end
+#
+def asset_path(name)
+  File.join Dir.pwd, "assets", name
+end
+
+#
+# The metro_asset_path is a helper which will generate a filepath based on the
+# directory of the metro library. This is used to retrieve internal assets which
+# can be used to serve up missing images, animations, samples, or songs or
+# defaults that may come with the metro game library.
+#
+#
+def metro_asset_path(name)
+  File.join Metro.asset_dir, name
+end
+
+module Metro
+
+  #
+  # An AssetPath searches through the various paths based on the path provided.
+  #
+  # First it assumes the path is absolute, second it assuemts that path is within
+  # the game, and third it assumes it is within metro itself.
+  #
+  class AssetPath
+
+    def self.with(path)
+      path.is_a?(AssetPath) ? path : new(path.to_s)
+    end
+
+    def initialize(path)
+      @path = path
+    end
+
+    attr_reader :path
+
+    def filepath
+      @filepath ||= begin
+        absolute_asset?(path) or game_asset?(path) or metro_asset?(path)
+      end
+    end
+
+    def absolute_asset?(path)
+      asset_at_path? path
+    end
+
+    def game_asset?(path)
+      asset_at_path? asset_path(path)
+    end
+
+    def metro_asset?(path)
+      asset_at_path? metro_asset_path(path)
+    end
+
+    alias_method :to_s, :filepath
+
+    private
+
+    def asset_at_path?(asset_path)
+      asset_path if File.exists?(asset_path) and File.file?(asset_path)
+    end
+  end
+end

data/lib/metro/events/control_definition.rb

@@ -0,0 +1,11 @@
+module Metro
+  class ControlDefinition
+    attr_accessor :name, :event, :args
+
+    def initialize(name,event,args)
+      @name = name
+      @event = event
+      @args = args
+    end
+  end
+end

data/lib/metro/events/controls.rb

@@ -0,0 +1,42 @@
+require_relative 'control_definition'
+
+module Metro
+  #
+  # Assists in creating and the storing of ControlDefinitions.
+  #
+  # @see DSL
+  #
+  class Controls
+
+    #
+    # Creation through controls is usually done with an instance_eval
+    # of a block and this allows for a flexible interface.
+    #
+    # @param [String,Symbol] name the name or the alias of the control
+    #   as it will be used within the course of the game.
+    #
+    def method_missing(name,*params,&block)
+      options = params.find {|param| param.is_a? Hash }
+      define_control(name,options)
+    end
+
+    def define_control(name,options)
+      event = _event_type(options)
+      args = _event_args(options)
+
+      defined_controls.push ControlDefinition.new name, event, args
+    end
+
+    def _event_type(options)
+      options[:is]
+    end
+
+    def _event_args(options)
+      options[:with]
+    end
+
+    def defined_controls
+      @defined_controls ||= []
+    end
+  end
+end

data/lib/metro/events/event_data.rb

@@ -0,0 +1,60 @@
+module Metro
+  class EventData
+
+    attr_reader :mouse_point, :created_at
+
+    def initialize(window)
+      @created_at = Time.now
+      @mouse_point = Metro::Units::Point.at window.mouse_x, window.mouse_y
+
+      capture_modifier_keys(window)
+    end
+
+    def modifier_keys
+      @modifier_keys ||= {}
+    end
+
+    def capture_modifier_keys(window)
+      self.class.modifier_key_list.each do |key|
+        modifier_keys[key] = window.button_down?(key)
+      end
+    end
+
+    #
+    # TODO: This attempt to reduce duplication is brittle and will likely end in heartache.
+    #
+
+    def self.modifier_key_list_names
+      @modifier_key_list_names ||= %w[ KbLeftControl KbRightControl
+                                        KbLeftAlt KbRightAlt
+                                        KbLeftMeta KbRightMeta
+                                        KbLeftShift KbRightShift ]
+    end
+
+    def self.modifier_key_list
+      @modifier_key_list ||= modifier_key_list_names.map {|key| "Gosu::#{key}".constantize }
+    end
+
+    #
+    # Generate methods for each left and right modifier key
+    #
+
+    modifier_key_list_names.each_with_index do |key_name,index|
+      define_method "#{key_name.gsub(/^Kb/,'').underscore}?" do
+        modifier_keys[self.class.modifier_key_list[index]]
+      end
+    end
+
+    #
+    # Define generic modifier keys that is not concerned with whether it
+    # was the left key or the right key.
+    #
+
+    [ :control?, :alt?, :meta?, :shift? ].each do |generic|
+      define_method generic do
+        send("left_#{generic}") or send("right_#{generic}")
+      end
+    end
+
+  end
+end

data/lib/metro/events/event_dictionary.rb

@@ -0,0 +1,52 @@
+require_relative 'event_factory'
+
+module Metro
+
+  module EventDictionary
+    extend self
+
+    #
+    # All defined events within this dictionary.
+    #
+    def events
+      @events ||= HashWithIndifferentAccess.new
+    end
+
+    #
+    # @example Adding a new SceneEvent to the Dictionary
+    #
+    #     SceneEventDictionary.add target: scene_name, type: event_type, args: args, block: block
+    #
+    def add(params = {})
+      target = params[:target]
+      event = EventFactory.new params[:type], params[:args], &params[:block]
+      events[target] = events_for_target(target).push event
+    end
+
+    #
+    # Return all the events for all the specified targets.
+    #
+    def events_for_targets(*list)
+      found_events = Array(list).flatten.compact.map {|s| events_for_target(s) }.flatten.compact
+      found_events
+    end
+
+    #
+    # Return the events for the specified target
+    #
+    def events_for_target(scene_name)
+      events[scene_name] ||= []
+    end
+
+    #
+    # When the game is reset the event dictionary needs to flush out all of the events that it
+    # has loaded as the game files will be reloaded. All metro related components will not
+    # be removed as those files are not reloaded when the game is reloaded.
+    #
+    def reset!
+      events.delete_if { |name,events| ! name.start_with? "metro/" }
+    end
+
+  end
+
+end

data/lib/metro/events/event_factory.rb

@@ -0,0 +1,17 @@
+module Metro
+
+  class EventFactory
+
+    attr_reader :event, :args, :block
+
+    alias_method :buttons, :args
+
+    def initialize(event,args=[],&block)
+      @event = event
+      @args = args
+      @block = block
+    end
+
+  end
+
+end

data/lib/metro/events/event_relay.rb

@@ -0,0 +1,342 @@
+require_relative 'event_data'
+
+module Metro
+
+  #
+  # An EventRelay represents a target's willingness to respond to events
+  # generate from the window. An event relay is generate for every scene
+  # but additional relays can be generated to also listen for events.
+  #
+  # An event relay can register a target to listen for the following window
+  # events: 'button_down'; 'button_up'; and 'button_held'.
+  #
+  # @note registering for 'button_held' events require that the window be
+  #   speicfied. As that is the only way to ask if the button is currently
+  #   pressed.
+  #
+  # @see #on_up
+  # @see #on_down
+  # @see #on_hold
+  #
+  class EventRelay
+
+    #
+    # Defines the provided controls for every EventRelay that is created.
+    #
+    # @see #define_control
+    #
+    # @param [Array<ControlDefinition>] controls the definitions of controls
+    #   that should be added to all EventRelays.
+    #
+    def self.define_controls(controls)
+      controls.each { |control| define_control control }
+    end
+
+    #
+    # Defines a control from a ControlDefinition for all EventRelays. A
+    # control is a way of defining a shortcut for a common event. This
+    # could be the use of a common set of keys for confirmation or canceling.
+    #
+    def self.define_control(control)
+      check_for_already_defined_control!(control)
+
+      define_method control.name do |&block|
+        send(control.event,*control.args,&block)
+      end
+    end
+
+    def self.check_for_already_defined_control!(control)
+      if instance_methods.include? control.name
+        error! "error.reserved_control_name", name: control.name
+      end
+    end
+
+    #
+    # An event relay is created a with a target and optionally a window.
+    #
+    # @param [Object] target the object that will execute the code when
+    #   the button events have fired have been triggered.
+    # @param [Window] window the window of the game. This parameter is
+    #   optional and only required if the events are interested in buttons
+    #   being held.
+    #
+    def initialize(target,window = nil)
+      @target = target
+      @window = window
+      @up_actions ||= {}
+      @down_actions ||= {}
+      @held_actions ||= {}
+      @mouse_movement_actions ||= []
+      @custom_notifications ||= HashWithIndifferentAccess.new([])
+    end
+
+    attr_reader :target, :window
+
+    #
+    # Register for a button_down event. These events are fired when
+    # the button is pressed down. This event only fires once when the
+    # button moves from the not pressed to the down state.
+    #
+    # @example Registering for a button down event to call a method named 'previous_option'
+    #
+    #     class ExampleScene
+    #       event :on_down, GpLeft, GpUp, do: :previous_option
+    #
+    #       def previous_option
+    #         @selected_index = @selected_index - 1
+    #         @selected_index = options.length - 1 if @selected_index <= -1
+    #       end
+    #     end
+    #
+    # Here in this scene if the GpLeft or GpUp buttons are pressed down the method
+    # `previous_options` will be executed.
+    #
+    #
+    # @example Registering for a button down event with a block of code to execute
+    #
+    #     class ExampleScene
+    #        event :on_down, GpLeft, GpUp do
+    #         @selected_index = @selected_index - 1
+    #         @selected_index = options.length - 1 if @selected_index <= -1
+    #       end
+    #     end
+    #
+    # This example uses a block instead of a method name but it is absolultey the same
+    # as the last example.
+    #
+    def on_down(*args,&block)
+      _on(@down_actions,args,block)
+    end
+
+    alias_method :button_down, :on_down
+
+    #
+    # Register for a button_up event. These events are fired when
+    # the button is released (from being pressed down). This event only fires
+    # once when the button moves from the pressed state to the up state.
+    #
+    # @example Registering for a button down event to call a method named 'next_option'
+    #
+    #     class ExampleScene
+    #        event :on_up, KbEscape, do: :leave_scene
+    #
+    #       def leave_scene
+    #         transition_to :title
+    #       end
+    #     end
+    #
+    # Here in this scene if the Escape Key is pressed and released the example scene
+    # will transition to the title scene.
+    #
+    # @example Registering for a button up event with a block of code to execute
+    #
+    #     class ExampleScene
+    #       event :on_up, KbEscape do
+    #        transition_to :title
+    #       end
+    #     end
+    #
+    # This example uses a block instead of a method name but it is absolultey the same
+    # as the last example.
+    #
+    def on_up(*args,&block)
+      _on(@up_actions,args,block)
+    end
+
+    alias_method :button_up, :on_up
+
+    #
+    # Register for a button_held event. These events are fired when
+    # the button is currently in the downstate. This event continues to fire at the
+    # beginning of every update of a scene until the button is released.
+    #
+    # @note button_held events require that the window be specified during initialization.
+    #
+    # @example Registering for button held events
+    #
+    #     class ExampleScene
+    #       event :on_hold KbLeft, GpLeft do
+    #         player.turn_left
+    #       end
+    #
+    #       event :on_hold, KbRight, GpRight do
+    #         player.turn_right
+    #       end
+    #
+    #       event :on_hold, KbUp, Gosu::GpButton0, do: :calculate_accleration
+    #
+    #       def calculate_acceleration
+    #         long_complicated_calculated_result = 0
+    #         # ... multi-line calculations to determine the player acceleration ...
+    #         player.accelerate = long_complicated_calculated_result
+    #       end
+    #     end
+    #
+    def on_hold(*args,&block)
+      log.warn "Registering for a on_hold event requires that a window be provided." unless window
+      _on(@held_actions,args,block)
+    end
+
+    alias_method :button_hold, :on_hold
+    alias_method :button_held, :on_hold
+
+
+    #
+    # Register for mouse movements events. These events are fired each update
+    # providing an event which contains the current position of the mouse.
+    #
+    # @note mouse movement events fire with each update so it is up to the
+    #    receiving object of the event to determine if the new mouse movement
+    #    is a delta.
+    #
+    # @note mouse movement events require that the window be specified during initialization.
+    #
+    # @example Registering for button held events
+    #
+    #     class ExampleScene
+    #
+    #       draws :player
+    #
+    #       event :on_mouse_movement do |event|
+    #         player.position = event.mouse_point
+    #       end
+    #     end
+    #
+    def on_mouse_movement(*args,&block)
+      options = (args.last.is_a?(Hash) ? args.pop : {})
+      @mouse_movement_actions << ( block || lambda { |instance| send(options[:do]) } )
+    end
+
+    #
+    # Register for a custom notification event. These events are fired when
+    # another object within the game posts a notification with matching criteria.
+    # If there has indeed been a match, then the stored action block will be fired.
+    #
+    # When the action block is specified is defined with no parameters it is assumed that
+    # that the code should be executed within the context of the object that defined
+    # the action, the 'target'.
+    #
+    # @example Registering for a save complete event that would re-enable a menu.
+    #
+    #     class ExampleScene
+    #       event :notification, :save_complete do
+    #         menu.enabled!
+    #       end
+    #     end
+    #
+    # The action block can also be specified with two parameters. In this case the code is
+    # no longer executed within the context of the object and is instead provided the
+    # the action target and the action source.
+    #
+    # @example Registering for a win game event that explicitly states the target and source.
+    #
+    #     class ExampleScene
+    #
+    #       event :notification, :win_game do |target,winner|
+    #         target.declare_winner winner
+    #       end
+    #
+    #       def declare_winner(winning_player)
+    #         # ...
+    #       end
+    #     end
+    #
+    def notification(param,&block)
+      custom_notifications[param.to_sym] = custom_notifications[param.to_sym] + [ block ]
+    end
+
+    attr_reader :up_actions, :down_actions, :held_actions
+
+    attr_reader :mouse_movement_actions
+
+    attr_reader :custom_notifications
+
+    def _on(hash,args,block)
+      options = (args.last.is_a?(Hash) ? args.pop : {})
+
+      args.each do |keystroke|
+        hash[keystroke] = block || lambda { |instance| send(options[:do]) }
+      end
+    end
+
+    #
+    # This is called by external or parent source of events, usually a Scene, when a button up event
+    # has been triggered.
+    #
+    def fire_button_up(id)
+      execute_block_for_target( &up_action(id) )
+    end
+
+    #
+    # This is called by external or parent source of events, usually a Scene, when a button down
+    # event has been triggered.
+    #
+    def fire_button_down(id)
+      execute_block_for_target( &down_action(id) )
+    end
+
+    #
+    # Fire the events mapped to the held buttons within the context
+    # of the specified target. This method is differently formatted because held buttons are not
+    # events but polling to see if the button is still being held.
+    #
+    def fire_events_for_held_buttons
+      held_actions.each do |key,action|
+        execute_block_for_target(&action) if window and window.button_down?(key)
+      end
+    end
+
+    #
+    # Fire events for all the registered actions that are suppose to receive
+    # the mouse movement events.
+    #
+    def fire_events_for_mouse_movement
+      mouse_movement_actions.each do |action|
+        execute_block_for_target(&action)
+      end
+    end
+
+    def execute_block_for_target(&block)
+      event_data = EventData.new(window)
+      target.instance_exec(event_data,&block)
+    end
+
+    # @return a block of code that is mapped for the 'button_up' id
+    def up_action(id)
+      up_actions[id] || lambda {|no_op| }
+    end
+
+    # @return a block of code that is mapped for the 'button_down' id
+    def down_action(id)
+      down_actions[id] || lambda {|no_op| }
+    end
+
+    #
+    # Fire all events mapped to the matching notification.
+    #
+    def fire_events_for_notification(event,sender)
+      notification_actions = custom_notifications[event]
+      notification_actions.each do |action|
+        _fire_event_for_notification(event,sender,action)
+      end
+    end
+
+    #
+    # Fire a single event based on the matched notification.
+    #
+    # An action without any parameters is assumed to be executed within the contexxt
+    # of the target. If there are two parameters we will simply execute the action and
+    # pass it both the target and the sender.
+    #
+    def _fire_event_for_notification(event,sender,action)
+      if action.arity == 2
+        target.instance_exec(sender,event,&action)
+      elsif action.arity == 1
+        target.instance_exec(sender,&action)
+      else
+        target.instance_eval(&action)
+      end
+    end
+
+  end
+end