metro-ld25 0.3.3

data/lib/metro/events/event_state_manager.rb

@@ -0,0 +1,63 @@
+require_relative 'event_relay'
+
+module Metro
+
+  class EventStateManager
+    def initialize
+      @current_state = []
+    end
+
+    attr_accessor :window
+
+    attr_reader :current_state
+
+    #
+    # Clear all the event relays of the current game state
+    #
+    def clear
+      current_state.clear
+    end
+
+    #
+    # Fire events for held buttons within the current game state
+    #
+    def fire_events_for_held_buttons
+      current_state.each {|cs| cs.fire_events_for_held_buttons }
+    end
+
+    #
+    # Fire events for button up for the current game state
+    #
+    def fire_button_up(id)
+      current_state.each {|cs| cs.fire_button_up(id) }
+    end
+
+    #
+    # Fire events for button down within the current game state
+    #
+    def fire_button_down(id)
+      current_state.each {|cs| cs.fire_button_down(id) }
+    end
+
+    #
+    # Fire notification events within the current game state
+    #
+    def fire_events_for_notification(event,sender)
+      current_state.each {|cs| cs.fire_events_for_notification(event,sender) }
+    end
+
+    #
+    # An an event relay to the current game state
+    #
+    def add_events_for_target(target,events)
+      relay = EventRelay.new(target,window)
+
+      events.each do |target_event|
+        relay.send target_event.event, *target_event.buttons, &target_event.block
+      end
+
+      current_state.push relay
+    end
+  end
+
+end

data/lib/metro/events/events.rb

@@ -0,0 +1,3 @@
+require_relative 'has_events'
+require_relative 'event_state_manager'
+require_relative 'unknown_sender'

data/lib/metro/events/has_events.rb

@@ -0,0 +1,108 @@
+require_relative 'event_dictionary'
+
+module Metro
+
+  module HasEvents
+
+    def self.included(base)
+      base.extend ClassMethods
+      base.extend GosuConstants
+    end
+
+    module ClassMethods
+
+      #
+      # Register an event for the scene.
+      #
+      # @example Registering for a save complete event that would re-enable a menu.
+      #
+      #     class ExampleScene
+      #       event :notification, :save_complete do
+      #         menu.enabled!
+      #       end
+      #     end
+      #
+      # @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, 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
+      #
+      # @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
+      #
+      # @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 event(event_type,*args,&block)
+        EventDictionary.add target: metro_name, type: event_type, args: args, block: block
+      end
+
+      #
+      # @return a list of all the EventFactories defined for this event holding object
+      #
+      def events
+        EventDictionary.events_for_targets(hierarchy)
+      end
+
+    end
+
+  end
+
+end

data/lib/metro/events/hit_list.rb

@@ -0,0 +1,75 @@
+module Metro
+
+  #
+  # The HitList is an object that maintains when an object is touched/clicked
+  # and then moved and finally released. The object attempts to work through
+  # the process:
+  #
+  #     hit_list.hit(first_event)
+  #     hit_list.update(next_event)
+  #     hit_list.update(next_event)
+  #     hit_list.release(last_event)
+  #
+  # @see EditTransitionScene
+  #
+  class HitList
+
+    def initialize(drawers)
+      @drawers = drawers
+    end
+
+    attr_reader :drawers
+
+    def hit(event)
+      add drawers_at(event.mouse_point)
+      save_event event
+    end
+
+    def update(event)
+      offset = offset_from_last_event(event)
+      list.each { |d| d.position = d.position + offset }
+
+      save_event event
+    end
+
+    def release(event)
+      offset = offset_from_last_event(event)
+      list.each { |d| d.position = d.position + offset }
+
+      save_event event
+      clear
+    end
+
+    def drawers_at(point)
+      hit_drawers = drawers.find_all { |drawer| drawer.bounds.contains?(point) }
+
+      # assumed that we only want one item
+      top_drawer = hit_drawers.inject(hit_drawers.first) {|top,drawer| drawer.z_order > top.z_order ? drawer : top }
+      [ top_drawer ].compact
+    end
+
+    def offset_from_last_event(event)
+      return Point.zero unless @last_event
+      event.mouse_point - @last_event.mouse_point
+    end
+
+    def save_event(event)
+      @first_event = event unless @first_event
+      @last_event = event
+    end
+
+    def list
+      @list ||= []
+    end
+
+    def add(hits)
+      Array(hits).each {|hit| list.push hit }
+    end
+
+    def clear
+      list.clear
+      @first_event = nil
+    end
+
+  end
+end

data/lib/metro/events/unknown_sender.rb

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

data/lib/metro/font.rb

@@ -0,0 +1,69 @@
+module Metro
+
+  #
+  # Font is a wrapper class for a Gosu::Font. This allows for additional data
+  # to be stored without relying on monkey-patching on functionality.
+  #
+  class Font < SimpleDelegator
+
+    def initialize(gosu_font)
+      super(gosu_font)
+    end
+
+    # An alias to Gosu::Font's height method
+    def size ; height ; end
+
+    #
+    # Return a font that matches the specified criteria. Using the name, size,
+    # and window a font will be generated or retrieved from the cache.
+    #
+    # @example Finding or creating a Font
+    #
+    #     Metro::Font.find_or_create window: model.window,
+    #       name: "Times New Roman", size: 24
+    #
+    # @param [Hash] value the hash that contains the `name`, `size` and `window`
+    # that describe the font.
+    #
+    def self.find_or_create(options)
+      window, name, size = create_params(options)
+      gosu_font = fonts["#{name}:#{size}:#{window}"]
+      gosu_font ? new(gosu_font) : create(options)
+    end
+
+    #
+    # Return a font that matches the specified criteria. Using the name, size,
+    # and window a font will be generated and stored in the cache.
+    #
+    # @example Creating a Font
+    #
+    #     Metro::Font.create window: model.window,
+    #       name: "Comic Sans", size: 48
+    #
+    # @param [Hash] value the hash that contains the `name`, `size` and `window`
+    # that describe the font.
+    #
+    def self.create(options)
+      window, name, size = create_params(options)
+      gosu_font = create_gosu_font(window,name,size)
+      fonts["#{name}:#{size}:#{window}"] = gosu_font
+      new(gosu_font)
+    end
+
+    private
+
+    def self.create_params(options)
+      options.symbolize_keys!
+      [ options[:window], options[:name], options[:size] ]
+    end
+
+    def self.create_gosu_font(window, name, size)
+      Gosu::Font.new window, name, size
+    end
+
+    def self.fonts
+      @fonts ||= {}
+    end
+
+  end
+end

data/lib/metro/game.rb

@@ -0,0 +1,102 @@
+require 'metro/game/dsl'
+
+module Metro
+  module Game
+    extend self
+
+    def setup(game_configuration)
+      @config = game_configuration
+    end
+
+    #
+    # Creates a window and starts the game with the game parameters.
+    #
+    def start!
+      @window = Window.new width, height, fullscreen?
+      window.caption = name
+      window.scene = Scenes.generate(first_scene)
+      window.show
+    end
+
+    # The original parameters specified during execution. These are the args
+    # found on the command-line that are passed in when the game started.
+    def execution_parameters
+      @execution_parameters ||= []
+    end
+
+    attr_writer :execution_parameters
+
+    #
+    # @return the current game window.
+    #
+    attr_reader :window
+
+    #
+    # @return [Scene,NilClass] the current scene that is being displayed. If
+    #   this is called before the window is being displayed when this will return
+    #   a nil value.
+    #
+    def current_scene
+      window ? window.scene : nil
+    end
+
+    def first_scene
+      fetch(:first_scene)
+    end
+
+    def width
+      fetch(:width,800)
+    end
+
+    def height
+      fetch(:height,600)
+    end
+
+    def bounds
+      Units::RectangleBounds.new left: 0, right: width, top: 0, bottom: height
+    end
+
+    def dimensions
+      Units::Dimensions.of width, height
+    end
+
+    def center
+      Units::Point.at width / 2 , height / 2
+    end
+
+    def fullscreen?
+      !!fetch(:fullscreen)
+    end
+
+    def debug?
+      !!fetch(:debug)
+    end
+
+    def name
+      fetch(:name)
+    end
+
+    def authors
+      fetch(:authors)
+    end
+
+    def website
+      fetch(:website,Metro::WEBSITE)
+    end
+
+    def contact
+      fetch(:contact)
+    end
+
+    def controls
+      config.controls.defined_controls
+    end
+
+    def fetch(name,fallback = nil)
+      config.send(name) rescue fallback
+    end
+
+    attr_reader :config
+
+  end
+end

data/lib/metro/game/dsl.rb

@@ -0,0 +1,68 @@
+require_relative '../events/controls'
+
+module Metro
+  module Game
+    class DSL
+
+      def self.parse(&block)
+        config = new
+        config.instance_eval(&block)
+        config
+      end
+
+      def first_scene(scene_name = nil)
+        scene_name ? @first_scene = scene_name : @first_scene
+      end
+
+      def width(game_width = nil)
+        game_width ? @width = game_width : @width
+      end
+
+      def height(game_height = nil)
+        game_height ? @height = game_height : @height
+      end
+
+      def resolution(w,h)
+        [ width(w), height(h) ]
+      end
+
+      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
+
+      def controls(&block)
+        @controls ||= Controls.new
+        @controls.instance_eval(&block) if block
+        @controls
+      end
+
+    end
+  end
+end