metro 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in metro.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Franklin Webber
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,31 @@
+# metro
+
+Metro is a framework built around [gosu](https://github.com/jlnr/gosu) the 2D game development library in Ruby. The goal of Metro is to enforce common conceptual structures and conventions making it easier to quickly generate a game.
+
+> NOTE: This project is very early in development and at this point mostly a prototype to explore more of theses concepts to gain an understanding of core tools necessary to make games.
+
+Please take a look at the [example game project](https://github.com/burtlo/starry-knight) that I am building alongside of 'metro' to see how it can be used to develop games.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'metro'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install metro
+
+## Usage
+
+```
+bundle exec metro [gamefilename]
+```
+
+By default Metro will look for a file named 'metro' within the current working directory if no *gamefilename* has been provided.
+
+Please take a look at the [example game project](https://github.com/burtlo/starry-knight) that I am building alongside of 'metro' to see how it can be used to develop games.

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/metro

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+path = __FILE__
+while File.symlink?(path)
+  path = File.expand_path(File.readlink(__FILE__), File.dirname(__FILE__))
+end
+$:.unshift(File.join(File.dirname(File.expand_path(path)), '..', 'lib'))
+
+require 'metro'
+
+Metro.run(*ARGV)

data/lib/metro.rb

@@ -0,0 +1,51 @@
+require 'gosu'
+require 'logger'
+
+require 'metro/version'
+require 'metro/window'
+require 'metro/game'
+require 'metro/model'
+require 'metro/scene'
+
+def asset_path(name)
+  File.join Dir.pwd, "assets", name
+end
+
+
+def log
+  @log ||= begin
+    logger = Logger.new(STDOUT)
+    logger.level = Logger::DEBUG
+    logger
+  end
+end
+
+module Metro
+  extend self
+
+  def run(filename="metro")
+    load_game_files
+    load_game_configuration(filename)
+    start_game
+  end
+
+  def load_game_files
+    $LOAD_PATH.unshift(Dir.pwd) unless $LOAD_PATH.include?(Dir.pwd)
+    Dir['models/*.rb'].each {|model| require model }
+    Dir['scenes/*.rb'].each {|scene| require scene }
+  end
+
+  def load_game_configuration(filename)
+    game_contents = File.read(filename)
+    game_block = lambda {|instance| eval(game_contents) }
+    game = Game::DSL.parse(&game_block)
+    Game.setup game
+  end
+
+  def start_game
+    window = Window.new Game.width, Game.height, false
+    window.scene = Game.first_scene.new(window)
+    window.show
+  end
+
+end

data/lib/metro/event_relay.rb

@@ -0,0 +1,56 @@
+module Metro
+  class EventRelay
+
+    attr_reader :target, :window
+
+    attr_reader :up_actions, :down_actions, :held_actions
+
+    def initialize(target,window)
+      @target = target
+      @window = window
+      @up_actions ||= Hash.new(:_no_action)
+      @down_actions ||= Hash.new(:_no_action)
+      @held_actions ||= Hash.new(:_no_action)
+    end
+
+    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
+
+    def on_up(*args,&block)
+      on(@up_actions,args,block)
+    end
+
+    def on_down(*args,&block)
+      on(@down_actions,args,block)
+    end
+
+    def on_hold(*args,&block)
+      on(@held_actions,args,block)
+    end
+
+    def button_up(id)
+      action = up_actions[id]
+      target.instance_eval(&action)
+    end
+
+    def trigger_held_buttons
+      held_actions.each do |key,action|
+        target.instance_eval(&action) if window.button_down?(key)
+      end
+    end
+
+    def button_down(id)
+      down_actions.each do |key,action|
+        if window.button_down?(key)
+          target.instance_eval(&action)
+        end
+      end
+    end
+
+  end
+end

data/lib/metro/game.rb

@@ -0,0 +1,37 @@
+require 'metro/game/dsl'
+
+module Metro
+  module Game
+    extend self
+
+    def setup(game_configuration)
+      @config = game_configuration
+    end
+
+    attr_reader :config
+
+    def first_scene
+      config.first_scene
+    end
+
+    def width
+      config.width || 640
+    end
+
+    def height
+      config.height || 480
+    end
+
+    def dimensions
+      [ width, height ]
+    end
+
+    def center
+      [ width / 2 , height / 2 ]
+    end
+
+    # TODO: ZOrder related constants that belong to Starry Knight
+    Background, Stars, Players, UI = *0..3
+
+  end
+end

data/lib/metro/game/dsl.rb

@@ -0,0 +1,29 @@
+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 = Scenes.find(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
+
+    end
+  end
+end

data/lib/metro/model.rb

@@ -0,0 +1,12 @@
+module Metro
+  class Model
+
+    def initialize(window)
+      after_initialize
+    end
+
+    def after_initialize
+    end
+
+  end
+end

data/lib/metro/scene.rb

@@ -0,0 +1,192 @@
+require_relative 'scene_view/scene_view'
+require_relative 'scene_view/components/drawer'
+require_relative 'event_relay'
+
+module Metro
+
+  #
+  # A scene is a basic unit of a game. Within a scene you define a number of methods
+  # that handle the initial setup, event configuration, logic updating, and drawing.
+  #
+  # @see #show
+  # @see #update
+  # @see #draw
+  # @see #events
+  #
+  # A fair number of private methods within Scene are prefaced with an underscore.
+  # These methods often call non-underscored methods within those methods. This allows
+  # for scene to configure or perform some functionality, while providing an interface
+  # so that every subclass does not have to constantly call `super`.
+  #
+  class Scene
+
+    #
+    # The window is the main instance of the game. Using window can access a lot of
+    # underlying Metro::Window, a subclass of Gosu::Window, that the Scene class is
+    # obfuscating.
+    #
+    # @see Metro::Window
+    # @see Gosu::Window
+    #
+    attr_reader :window
+
+    #
+    # The events object that is configured through the {#events} method, which stores
+    # all the gamepad and keyboard events defined.
+    #
+    # @see Events
+    #
+    attr_reader :event_relays
+
+    #
+    # Customized views that contain elements to be drawn will be handled by the
+    # view_drawer.
+    #
+    # @see SceneView::Drawer
+    #
+    attr_reader :view_drawer
+
+    #
+    # Captures all classes that subclass Scene.
+    #
+    def self.inherited(base)
+      scenes << base
+    end
+
+    #
+    # All subclasses of Scene, this should be all the defined scenes
+    # within the game.
+    #
+    # @return an Array of Scene subclasses
+    #
+    def self.scenes
+      @scenes ||= []
+    end
+
+    # This provides the functionality for view handling.
+    include SceneView
+
+    #
+    # A scene is created with a window instance. When subclassing a Scene, you should
+    # hopefully not need to create an {#initialize} method or call `super` but instead
+    # implement the {#show} method which is the point of incision in the subclasses
+    # that allow for the subclasses of Scene to be setup correctly.
+    #
+    def initialize(window)
+      @window = window
+
+      @event_relays ||= []
+
+      @scene_events = EventRelay.new(self,window)
+      events(@scene_events)
+
+      @event_relays << @scene_events
+
+      @view_drawer = SceneView::Drawer.new(self)
+
+      show
+    end
+
+    #
+    # This method should be defined in the Scene subclass.
+    #
+    # @param [Events] e is the object that you can register button presses
+    #
+    def events(e) ; end
+
+    def add_event_relay(event_relay)
+      @event_relays << event_relay
+    end
+
+    def trigger_held_buttons
+      event_relays.each do |er|
+        er.trigger_held_buttons
+      end
+    end
+
+    def button_up(id)
+      event_relays.each do |er|
+        er.button_up(id)
+      end
+    end
+
+    def button_down(id)
+      event_relays.each do |er|
+        er.button_down(id)
+      end
+    end
+
+    #
+    # This method is solely a non-action method for when events are triggered
+    # for button up and button down
+    #
+    def _no_action ; end
+
+    # This method is called right after initialization
+    def show ; end
+
+    #
+    # This method handles the logic or game loop for the scene.
+    #
+    # @note This method should be implemented in the subclassed Scene
+    #
+    def update ; end
+
+    #
+    # The `_draw` method is called by the Game Window to allow for any view related
+    # drawing needs to be handled before calling the traditional `draw` method defined
+    # in the subclassed Scenes.
+    #
+    def _draw
+      view_drawer.draw(view)
+      draw
+    end
+
+    #
+    # This method handles all the visual rendering of the scene.
+    #
+    # @note This method should be implemented in the subclassed Scene
+    #
+    def draw ; end
+
+    #
+    # `transition_to` performs the work of transitioning this scene
+    # to another scene.
+    #
+    # @param [String,Symbol,Class] scene_name the name of the Scene which can be either
+    #   the class or a string/symbol representation of the shortened scene name.
+    #
+    def transition_to(scene_name)
+      new_scene = Scenes.create(scene_name,window)
+      _prepare_transition(new_scene)
+      window.scene = new_scene
+    end
+
+
+    #
+    # Before a scene is transitioned away from to a new scene, this private method is
+    # here to allow for any housekeeping or other work that needs to be done before
+    # calling the subclasses implementation of `prepare_transition`.
+    #
+    # @param [Scene] new_scene this is the instance of the scene that is about to replace
+    #   the current scene.
+    #
+    def _prepare_transition(new_scene)
+      log.debug "Preparing to transition from scene #{self} to #{new_scene}"
+      prepare_transition(new_scene)
+    end
+
+    #
+    # Before a scene is transisitioned away from to a new scene, this method is called
+    # to allow for the scene to complete any taskss, stop any actions, or pass any
+    # information from the existing scene to the scene that is about to replace it.
+    #
+    # @note This method should be implemented in the subclassed Scene
+    #
+    # @param [Scene] new_scene this is the instance of the scene that is about to replace
+    #   the current scene.
+    #
+    def prepare_transition(new_scene) ; end
+
+  end
+end

data/lib/metro/scene_view/components/drawer.rb

@@ -0,0 +1,44 @@
+module Metro
+  module SceneView
+    class Drawer
+
+      # The window is necessary as all drawing elements created require
+      # an access to this instance.
+      attr_reader :window
+
+      # The scene is necessary to ensure that any fields which contain
+      # variables within the application are properly interpolated.
+      attr_reader :scene
+
+      def initialize(scene)
+        @scene = scene
+        @window = scene.window
+        after_initialize
+      end
+      
+      def after_initialize ; end
+
+      def components
+        @components ||= begin
+          Hash.new(UnsupportedComponent).merge label: Label.new(scene),
+           select: Select.new(scene)
+        end
+      end
+
+      #
+      # Render all the view elements defined that are supported by this drawer.
+      #
+      def draw(view)
+        view.each do |name,content|
+          component = content['type'].to_sym
+          components[component].draw(content)
+        end
+      end
+
+    end
+  end
+end
+
+require_relative 'unsupported_component'
+require_relative 'label'
+require_relative 'select'

data/lib/metro/scene_view/components/label.rb

@@ -0,0 +1,23 @@
+module Metro
+  module SceneView
+    class Label < Drawer
+
+      def font
+        @font ||= Gosu::Font.new(window, Gosu::default_font_name, 20)
+      end
+
+      def draw(view)
+        label_text = scene.instance_eval( "\"#{view['text']}\"" )
+
+        label_color = view['color'] || 0xffffffff
+        label_color = label_color.to_i(16) if label_color.is_a? String
+
+        font.draw label_text,
+          view['x'], view['y'], view['z-order'],
+          view['x-factor'] || 1.0, view['y-factor'] || 1.0,
+          label_color
+      end
+
+    end
+  end
+end

data/lib/metro/scene_view/components/select.rb

@@ -0,0 +1,62 @@
+module Metro
+  module SceneView
+    class Select < Drawer
+
+      attr_accessor :selected_index, :options
+
+      def after_initialize
+        name, content = scene.view.find { |name,content| content['type'].to_sym == :select }
+
+        if content
+          @selected_index = 0
+          @options = content['options']
+          events = EventRelay.new(self,window)
+
+          events.on_up Gosu::KbLeft, Gosu::GpLeft, Gosu::KbUp, Gosu::GpUp, do: :previous_option
+          events.on_up Gosu::KbRight, Gosu::GpRight, Gosu::KbDown, Gosu::GpDown, do: :next_option
+          events.on_up Gosu::KbEnter, Gosu::KbReturn, Gosu::GpButton0, do: :selection
+
+          scene.add_event_relay events
+        end
+      end
+
+      def selection
+        scene_method = options[selected_index].downcase.gsub(/\s/,'_')
+        scene.send scene_method
+      end
+
+      def previous_option
+        @selected_index = @selected_index - 1
+        @selected_index = options.length - 1 if @selected_index <= -1
+      end
+
+      def next_option
+        @selected_index = @selected_index + 1
+        @selected_index = 0 if @selected_index >= options.length
+      end
+      
+      def _no_action ; end
+
+      def font
+        @font ||= Gosu::Font.new(window, Gosu::default_font_name, 20)
+      end
+
+      def draw(view)
+        view['options'].each_with_index do |option,index|
+
+          color = view["color"] || 0xffffffff
+
+          if index == selected_index
+            color = view["highlight-color"] || 0xffffff00
+          end
+
+          color = color.to_i(16) if color.is_a? String
+
+          y_position = view["y"] + view["padding"] * index
+          font.draw option, view["x"], y_position, Metro::Game::UI, 1.0, 1.0, color
+        end
+      end
+
+    end
+  end
+end

data/lib/metro/scene_view/components/unsupported_component.rb

@@ -0,0 +1,9 @@
+module Metro
+  module SceneView
+    class UnsupportedComponent < Drawer
+      def self.draw(view)
+        #log.warn "The component #{view['type']} does not have a supported drawer."
+      end
+    end
+  end
+end

data/lib/metro/scene_view/json_view.rb

@@ -0,0 +1,21 @@
+require 'json'
+
+module Metro
+  module SceneView
+
+    class JSONView
+      def self.find(view_name)
+        File.exists? json_view_name(view_name)
+      end
+
+      def self.parse(view_name)
+        JSON.parse File.read json_view_name(view_name)
+      end
+
+      def self.json_view_name(view_name)
+        File.extname(view_name) == "" ? "#{view_name}.json" : view_name
+      end
+    end
+
+  end
+end

data/lib/metro/scene_view/no_view.rb

@@ -0,0 +1,15 @@
+module Metro
+  module SceneView
+
+    class NoView
+      def self.find(view_name)
+        true
+      end
+
+      def self.parse(view_name)
+        {}
+      end
+    end
+
+  end
+end

data/lib/metro/scene_view/scene_view.rb

@@ -0,0 +1,52 @@
+require_relative 'yaml_view'
+require_relative 'json_view'
+require_relative 'no_view'
+
+module Metro
+  module SceneView
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    #
+    # Supported view formats
+    #
+    def _view_parsers
+      [ YAMLView, JSONView, NoView ]
+    end
+
+    #
+    # Loads the view based on the view parsers.
+    #
+    def view
+      @view ||= begin
+        parser = _view_parsers.find { |parser| parser.find self.class.view_name }
+        parser.parse self.class.view_name
+      end
+    end
+
+    module ClassMethods
+
+      #
+      # A Scene by default uses the name of the Scene to find it's associated
+      # view.
+      #
+      # @example Custom View Name
+      #
+      #     class ClosingScene < Metro::Scene
+      #       view_name :alternate
+      #     end
+      #
+      def view_name(filename = nil)
+        if filename
+          @view_name = File.join "views", filename.to_s
+        else
+          @view_name ||= File.join "views", "#{self.to_s[/^(.+)Scene$/,1].downcase}"
+        end
+      end
+
+    end
+
+  end
+end

data/lib/metro/scene_view/yaml_view.rb

@@ -0,0 +1,21 @@
+require 'yaml'
+
+module Metro
+  module SceneView
+
+    class YAMLView
+      def self.find(view_name)
+        File.exists? yaml_view_name(view_name)
+      end
+
+      def self.parse(view_name)
+        YAML.load File.read yaml_view_name(view_name)
+      end
+
+      def self.yaml_view_name(view_name)
+        File.extname(view_name) == "" ? "#{view_name}.yaml" : view_name
+      end
+    end
+
+  end
+end

data/lib/metro/scenes.rb

@@ -0,0 +1,23 @@
+module Metro
+  module Scenes
+    extend self
+
+    def scenes
+      @scenes ||= Scene.scenes.inject({}) do |dict,scene|
+        name = scene.to_s.gsub(/Scene$/,'').downcase.to_sym
+        dict[name] = scene
+        dict[scene] = scene
+        dict
+      end
+    end
+
+    def find(scene_name)
+      scenes[scene_name.to_sym]
+    end
+    
+    def create(scene_name,window)
+      find(scene_name).new(window)
+    end
+
+  end
+end

data/lib/metro/version.rb

@@ -0,0 +1,3 @@
+module Metro
+  VERSION = "0.0.1"
+end

data/lib/metro/window.rb

@@ -0,0 +1,39 @@
+require_relative 'scenes'
+
+module Metro
+
+  #
+  # A subclass of the Gosu::Window which simply acts as system
+  # to shuffle in and out scenes and transfer events.
+  #
+  class Window < Gosu::Window
+
+    attr_reader :scene
+
+    def initialize(width,height,something)
+      super width, height, something
+    end
+
+    def scene=(new_scene)
+      @scene = new_scene
+    end
+
+    def update
+      scene.trigger_held_buttons
+      scene.update
+    end
+
+    def draw
+      scene._draw
+    end
+
+    def button_up(id)
+      scene.button_up(id)
+    end
+
+    def button_down(id)
+      scene.button_down(id)
+    end
+
+  end
+end

data/metro.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'metro/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "metro"
+  gem.version       = Metro::VERSION
+  gem.authors       = ["Franklin Webber"]
+  gem.email         = ["franklin.webber@gmail.com"]
+  gem.description   = %q{A framework around Gosu to make game creation less tedious}
+  gem.summary       = %q{A framework around Gosu to make game creation less tedious}
+  gem.homepage      = "https://github.com/burtlo/metro"
+  
+  gem.add_dependency 'gosu', '~> 0.7'
+  
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+end

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification
+name: metro
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Franklin Webber
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-10-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: gosu
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.7'
+description: A framework around Gosu to make game creation less tedious
+email:
+- franklin.webber@gmail.com
+executables:
+- metro
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/metro
+- lib/metro.rb
+- lib/metro/event_relay.rb
+- lib/metro/game.rb
+- lib/metro/game/dsl.rb
+- lib/metro/model.rb
+- lib/metro/scene.rb
+- lib/metro/scene_view/components/drawer.rb
+- lib/metro/scene_view/components/label.rb
+- lib/metro/scene_view/components/select.rb
+- lib/metro/scene_view/components/unsupported_component.rb
+- lib/metro/scene_view/json_view.rb
+- lib/metro/scene_view/no_view.rb
+- lib/metro/scene_view/scene_view.rb
+- lib/metro/scene_view/yaml_view.rb
+- lib/metro/scenes.rb
+- lib/metro/version.rb
+- lib/metro/window.rb
+- metro.gemspec
+homepage: https://github.com/burtlo/metro
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: A framework around Gosu to make game creation less tedious
+test_files: []