metro-ld26 0.3.4

data/lib/metro/window.rb

@@ -0,0 +1,95 @@
+module Metro
+
+  #
+  # A subclass of the Gosu::Window which simply acts as system
+  # to shuffle in and out scenes and relay event information.
+  #
+  class Window < Gosu::Window
+
+    #
+    # The scene of the window.
+    #
+    # @see Scene
+    #
+    attr_accessor :scene
+
+    def state
+      scene.state
+    end
+
+    #
+    # @param [Fixnum] width the width of the game window
+    # @param [Fixnum] height the height of the game window
+    # @param [TrueClass,FalseClass] fullscreen the boolean flag to enable or
+    #   disable fullscreen
+    #
+    def initialize(width,height,fullscreen)
+      super width, height, fullscreen
+    end
+
+    def scene=(scene)
+      scene.window = self
+      @scene = scene
+    end
+
+    #
+    # This is called every update interval while the window is being shown.
+    #
+    def update
+      state.fire_events_for_mouse_movement
+      state.fire_events_for_held_buttons
+      scene.base_update
+    end
+
+    #
+    # This is called after every {#update} and when the OS wants the window to
+    # repaint itself.
+    #
+    def draw
+      scene.base_draw
+    end
+
+    #
+    # Called before {#update} when the user releases a button while the window
+    # has focus.
+    #
+    def button_up(id)
+      state.fire_button_up(id)
+    end
+
+    #
+    # Called before {#update} when the user presses a button while the window
+    # has focus.
+    #
+    def button_down(id)
+      state.fire_button_down(id)
+    end
+
+    #
+    # @return the dimensions of the current window.
+    #
+    def dimensions
+      Metro::Units::Dimensions.of width, height
+    end
+
+    #
+    # Define an acessor that enables/disables the use of a cursor
+    # within the window. The value should be truthy/falsy.
+    #
+    attr_accessor :cursor
+
+    #
+    # Gosu uses this method to determine if the cursor should be shown.
+    #
+    alias_method :needs_cursor?, :cursor
+
+    def show_cursor
+      self.cursor = true
+    end
+
+    def hide_cursor
+      self.cursor = false
+    end
+
+  end
+end

data/lib/setup_handlers/exit_if_dry_run.rb

@@ -0,0 +1,26 @@
+module Metro
+  module SetupHandlers
+
+    #
+    # If the user has enabled the dry-run flag, this is the point at which the
+    # game will exit.
+    #
+    # Dry run mode is useful for determine if all dependencies have successfully
+    # been met and the source code will load successfully.
+    #
+    class ExitIfDryRun
+      #
+      # @param [Metro::Parameters::Options] options the options that the game
+      #   was provided when it was launched.
+      #
+      def setup(options)
+        return unless options.dry_run?
+        puts TemplateMessage.new message: 'dry_run.success'
+        exit
+      end
+    end
+  end
+
+  register_setup_handler SetupHandlers::ExitIfDryRun.new
+
+end

data/lib/setup_handlers/game_execution.rb

@@ -0,0 +1,65 @@
+module Metro
+  module SetupHandlers
+
+    #
+    # The GameExecution allows for a game to be executed. This is used by Metro
+    # to validate that the code can be loaded and run before actually running
+    # it (specifically when reloading live running code)
+    #
+    class GameExecution
+
+      #
+      # Perform a game execution with the specified parameters and return the
+      # result of that game execution.
+      #
+      def self.execute(parameters)
+        execution = new(parameters)
+        execution.execute!
+        execution
+      end
+
+      # @return the output generated from the execution of code.
+      attr_reader :output
+
+      # @return an array of parameters that will be provided to the execution
+      #   of the game.
+      attr_reader :parameters
+
+      #
+      # @param [Array] parameters an array of the game parameters that are
+      #   to be provided to this execution of the game.
+      #
+      def initialize(parameters)
+        @parameters = parameters
+      end
+
+      # @return the status code that was returned when the game execution
+      #   has completed.
+      def status
+        @status ||= 0
+      end
+
+      # Perform the game execution.
+      def execute!
+        @output, @status = Open3.capture2e(game_execution_string)
+      end
+
+      # @return [TrueClass,FalseClass] true if the execution was successful.
+      def valid?
+        status == 0
+      end
+
+      # @return [TrueClass,FalseClass] true if the execution was a failure.
+      def invalid?
+        status != 0
+      end
+
+      private
+
+      def game_execution_string
+        "#{Metro.executable_path} #{parameters.join(" ")}"
+      end
+    end
+
+  end
+end

data/lib/setup_handlers/load_game_configuration.rb

@@ -0,0 +1,65 @@
+module Metro
+  module SetupHandlers
+
+    #
+    # LoadGameConfiguration is a meta pregame setup handler as it defines multiple
+    # setup handlers to be executed related to game configuration.
+    #
+    class GameConfiguration
+      #
+      # @param [Metro::Parameters::Options] options the options that the game
+      #   was provided when it was launched.
+      #
+      def setup(options)
+        ParseAndLoadGameConfiguration.new.setup(options)
+        ConfigureControls.new.setup(options)
+      end
+    end
+
+    #
+    # Loads the game configuration information and sets up a Game object with the
+    # content loaded from the game configuration.
+    #
+    class ParseAndLoadGameConfiguration
+
+      #
+      # @param [Metro::Parameters::Options] options the options that the game
+      #   was provided when it was launched.
+      #
+      def setup(options)
+        filename = options.filename
+
+        Game.execution_parameters = options.execution_parameters
+
+        gamefile = File.basename(filename)
+        game_files_exist!(gamefile)
+        game_contents = File.read(gamefile)
+        game_block = lambda {|instance| eval(game_contents) }
+        game = Game::DSL.parse(&game_block)
+        Game.setup game
+      end
+
+      def game_files_exist!(*files)
+        files.compact.flatten.each { |file| game_file_exists?(file) }
+      end
+
+      def game_file_exists?(file)
+        error!("error.missing_metro_file",file: file) unless File.exists?(file)
+        error!("error.specified_directory",directory: file) if File.directory?(file)
+      end
+    end
+
+    #
+    # After the game has been configured it is time to configure the controls for
+    # the game.
+    #
+    class ConfigureControls
+      def setup(options)
+        EventRelay.define_controls Game.controls
+      end
+    end
+  end
+
+  register_setup_handler SetupHandlers::GameConfiguration.new
+
+end

data/lib/setup_handlers/load_game_files.rb

@@ -0,0 +1,101 @@
+require_relative 'game_execution'
+
+module Metro
+  module SetupHandlers
+
+    #
+    # LoadGameFiles will load all the game files within the current working
+    # directory that are in the pre-defined Metro game folders.
+    #
+    # LoadGameFiles uses ActiveSupport::Dependencies::WatchStack to spy on all
+    # the constants that are added when the game runs. This grants the class
+    # the ability to provide dynamic reloading of the classes as they change.
+    #
+    class LoadGameFiles
+
+      #
+      # @param [Metro::Parameters::Options] options the options that the game
+      #   was provided when it was launched.
+      #
+      def setup(options)
+        load_game_files!
+      end
+
+      #
+      # Drop any already defined events. Drop all the existing classes, reload
+      # the game files, and prepare the new game files for unloading the next
+      # time around that reload has been called.
+      #
+      def load_game_files!
+        EventDictionary.reset!
+        Image.images.clear
+        Animation.images.clear
+        Song.songs.clear
+        Font.fonts.clear
+
+        prepare_watcher!
+        load_game_files
+        execute_watcher!
+      end
+
+      #
+      # Launch the game in a sub-process in dry-run mode. Starting the
+      # game in dry-run mode here makes it so it will not launch a window
+      # and simply check to see if the code is valid and working correctly.
+      #
+      def launch_game_in_dry_run_mode
+        GameExecution.execute Game.execution_parameters + [ "--dry-run" ]
+      end
+
+      #
+      # The watcher should watch the Object Namespace for any changes. Any constants
+      # that are added will be tracked from this point forward.
+      #
+      def prepare_watcher!
+        ActiveSupport::Dependencies.clear
+        watcher.watch_namespaces([ Object ])
+      end
+
+      #
+      # The watcher will keep track of all the constants that were added to the Object
+      # Namespace after the start of the execution of the game. This will allow for only
+      # those objects to be reloaded.
+      #
+      def watcher
+        @watcher ||= ActiveSupport::Dependencies::WatchStack.new
+      end
+
+      def load_game_files
+        $LOAD_PATH.unshift(Dir.pwd) unless $LOAD_PATH.include?(Dir.pwd)
+        load_paths 'lib'
+        load_path 'scenes', prioritize: 'game_scene.rb'
+        load_path 'models', prioritize: 'game_model.rb'
+      end
+
+      def load_paths(*paths)
+        paths.flatten.compact.each {|path| load_path path }
+      end
+
+      def load_path(path,options = {})
+        files = Dir["#{path}/**/*.rb"]
+        files.sort! {|file| File.basename(file) == options[:prioritize] ? -1 : 1 }
+        files.each {|file| require_or_load file }
+      end
+
+      #
+      # The watcher will now mark all the constants that it has watched being loaded
+      # as unloadable. Doing so exhausts the list of constants found so the watcher
+      # will be empty.
+      #
+      # @note an exception is raised if the watcher is not prepared every time this
+      #   is called.
+      #
+      def execute_watcher!
+        watcher.new_constants.each { |constant| unloadable constant }
+      end
+    end
+  end
+
+  register_setup_handler SetupHandlers::LoadGameFiles.new
+
+end

data/lib/setup_handlers/move_to_game_directory.rb

@@ -0,0 +1,25 @@
+module Metro
+  module SetupHandlers
+
+    #
+    # If the filename provide contains path information, then we need to move the
+    # current working directory into the root of the game directory. This is
+    # important because assets and other various paths are dependent on that
+    # being the location during execution.
+    #
+    class MoveToGameDirectory
+      #
+      # @param [Metro::Parameters::Options] options the options that the game
+      #   was provided when it was launched.
+      # 
+      def setup(options)
+        filename = options.filename
+        game_directory = File.dirname(filename)
+        Dir.chdir game_directory
+      end
+    end
+  end
+
+  register_setup_handler SetupHandlers::MoveToGameDirectory.new
+
+end

data/lib/setup_handlers/reload_game_on_game_file_changes.rb

@@ -0,0 +1,79 @@
+module Metro
+  module SetupHandlers
+
+    #
+    # When the game is launched in **debug** mode the game directories will be
+    # monitored for changes. When a change occurs within one of the game source
+    # files the game and scene will be reloaded.
+    #
+    class ReloadGameOnGameFileChanges
+
+      def watched_filepaths
+        source_filepaths + view_filepaths + asset_filepaths
+      end
+
+      #
+      # @NOTE this is duplication of the paths is also defined in LoadGameFiles.
+      # @see Metro::SetupHandlers::LoadGameFiles
+      #
+      def source_filepaths
+        [ 'lib', 'scenes', 'models' ]
+      end
+
+      def view_filepaths
+        [ 'views' ]
+      end
+
+      def asset_filepaths
+        [ 'assets' ]
+      end
+
+      #
+      # @param [Metro::Parameters::Options] options the options that the game
+      #   was provided when it was launched.
+      #
+      def setup(options)
+        start_watcher if Game.debug? and not options.packaged?
+      end
+
+      def start_watcher
+        Thread.abort_on_exception = true
+        Thread.new { watch_filepaths(watched_filepaths) }
+      end
+
+      #
+      # Defines the listener that will watch the filepaths
+      #
+      def watch_filepaths(filepaths)
+        listener = Listen.to(*filepaths)
+        listener.change(&on_change)
+        listener.start
+      end
+
+      #
+      # @return [Proc] the body of code to execute when a file change event has
+      #   been received.
+      #
+      def on_change
+        Proc.new { |modified,added,removed| reload_game_because_files_changed(modified + added + removed) }
+      end
+
+      #
+      # Perform a game reload if the game source is valid.
+      #
+      def reload_game_because_files_changed(changed)
+        log.debug "Metro has detected #{changed.count} game source #{changed.count != 1 ? 'files have' : 'file has'} changed. RELOADING GAME CODE!"
+        if Metro.game_has_valid_code?
+          Game.current_scene.after(1.tick) do
+            Metro.reload!
+            scene_is_being_edited = scene_name == "metro/edit_transition"
+            transition_to(scene_name) unless scene_is_being_edited
+          end
+        end
+      end
+
+    end
+  end
+
+  register_setup_handler SetupHandlers::ReloadGameOnGameFileChanges.new
+end