metro 0.1.4 → 0.1.5

data/changelog.md

@@ -1,5 +1,14 @@
 # Metro
 
+## 0.1.5 / 2012-11-01
+
+* Metro.reload! will reload all game classes
+* Scenes can now an editable state where the position of items can be
+  updated and saved.
+* Event blocks can optionally receive an event object. The event object
+  includes modifier key information.
+
+
 ## 0.1.4 / 2012-10-28
 
 * Removed dependency on the sender gem so metro is playable on Windows

data/lib/commands/generate_model.rb

@@ -5,11 +5,11 @@ module Metro
     no_tasks do
 
       def model_filename
-        name.snake_case
+        name.underscore
       end
 
       def model_name
-        name.camel_case
+        name.classify
       end
 
     end

data/lib/commands/generate_scene.rb

@@ -6,12 +6,12 @@ module Metro
 
       def scene_filename
         scene_name = name.gsub(/_?Scene$/i,'')
-        "#{scene_name.snake_case}_scene"
+        "#{scene_name.underscore}_scene"
       end
 
       def scene_class_name
         scene_name = name.gsub(/_?Scene$/i,'')
-        "#{scene_name.camel_case}Scene"
+        "#{scene_name.classify}Scene"
       end
 
     end

data/lib/commands/generate_view.rb

@@ -6,7 +6,7 @@ module Metro
 
       def view_filename
         view_name = name.to_s.gsub(/_?Scene$/i,'')
-        view_name.snake_case
+        view_name.underscore
       end
 
     end

data/lib/gosu_ext/color.rb

@@ -22,9 +22,9 @@ class Gosu::Color
   end
 
   def self.parse_string(value)
-    parse_hex(value) || parse_rgb(value) || parse_rgba(value) || [ 255, 255, 255, 255 ]
+    parse_hex(value) || parse_rgb(value) || parse_rgba(value) || parse_gosu_color_string(value) || [ 255, 255, 255, 255 ]
   end
-  
+
   def self.parse_rgba(rgba)
     if rgba =~ /rgba\(([\d]{1,3}),([\d]{1,3}),([\d]{1,3}),(\d(?:\.\d)?)\)/
       [ (255 * $4.to_f).floor.to_i, $1.to_i, $2.to_i, $3.to_i ]
@@ -45,4 +45,18 @@ class Gosu::Color
     end
   end
 
+  def self.parse_gosu_color_string(string)
+    if string =~ /\(ARGB: ([\d]{1,3})\/([\d]{1,3})\/([\d]{1,3})\/([\d]{1,3})\)/
+      [ $1.to_i, $2.to_i, $3.to_i, $4.to_i ]
+    end
+  end
+
+  def to_s
+    "rgba(#{red},#{green},#{blue},#{alpha / 255.to_f})"
+  end
+
+  def to_json(*params)
+    to_s.to_json
+  end
+
 end

data/lib/metro.rb

@@ -2,9 +2,10 @@ require 'gosu'
 require 'gosu_ext/color'
 require 'gosu_ext/gosu_constants'
 require 'i18n'
+require 'active_support'
+require 'active_support/dependencies'
+require 'active_support/inflector'
 
-
-require 'core_ext/string'
 require 'core_ext/numeric'
 require 'logger'
 require 'erb'
@@ -49,33 +50,72 @@ module Metro
   #   the value uses the default filename.
   #
   def run(filename=default_game_filename)
-    load_game_files
-    change_into_game_directory(filename)
+    move_to_game_directory!(filename)
+    load_game_files!
     load_game_configuration(filename)
     configure_controls!
     start_game
   end
 
+  def load_game_files!
+    prepare_watcher!
+    load_game_files
+    execute_watcher!
+  end
+
+  alias_method :reload!, :load_game_files!
+
   private
 
+  def move_to_game_directory!(filename)
+    game_directory = File.dirname(filename)
+    Dir.chdir game_directory
+  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
+
+  #
+  # 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 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
+
   def load_game_files
     $LOAD_PATH.unshift(Dir.pwd) unless $LOAD_PATH.include?(Dir.pwd)
     load_paths 'models', 'scenes', 'lib'
   end
-  
-  def change_into_game_directory(filename)
-    game_directory = File.dirname(filename)
-    Dir.chdir game_directory
-  end
 
   def load_paths(*paths)
     paths.flatten.compact.each {|path| load_path path }
   end
 
   def load_path(path)
-    Dir["#{path}/**/*.rb"].each {|model| require model }
+    Dir["#{path}/**/*.rb"].each {|model| require_or_load model }
   end
 
+
   def load_game_configuration(filename)
     gamefile = File.basename(filename)
     game_files_exist!(gamefile)

data/lib/metro/events/event_data.rb

@@ -0,0 +1,61 @@
+module Metro
+  class EventData
+
+    attr_reader :mouse_x, :mouse_y, :created_at
+
+    def initialize(window)
+      @created_at = Time.now
+      @mouse_x = window.mouse_x
+      @mouse_y = 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_relay.rb

@@ -1,3 +1,5 @@
+require_relative 'event_data'
+
 module Metro
 
   #
@@ -253,7 +255,7 @@ module Metro
     # has been triggered.
     #
     def fire_button_up(id)
-      target.instance_eval( &up_action(id) )
+      execute_block_for_target( &up_action(id) )
     end
 
     #
@@ -261,7 +263,7 @@ module Metro
     # event has been triggered.
     #
     def fire_button_down(id)
-      target.instance_eval( &down_action(id) )
+      execute_block_for_target( &down_action(id) )
     end
 
     #
@@ -271,9 +273,14 @@ module Metro
     #
     def fire_events_for_held_buttons
       held_actions.each do |key,action|
-        target.instance_eval(&action) if window and window.button_down?(key)
+        execute_block_for_target(&action) if window and window.button_down?(key)
       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 or a block that will attempt to call out
     #   to the action missing method.

data/lib/metro/events/hit_list.rb

@@ -0,0 +1,77 @@
+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_x,event.mouse_y)
+      save_event event
+    end
+
+    def update(event)
+      offset_x, offset_y = offset_from_last_event(event)
+
+      list.each { |d| d.offset(offset_x,offset_y) }
+
+      save_event event
+    end
+
+    def release(event)
+      offset_x, offset_y = offset_from_last_event(event)
+
+      list.each { |d| d.offset(offset_x,offset_y) }
+
+      save_event event
+      clear
+    end
+
+    def drawers_at(x,y)
+      hit_drawers = drawers.find_all { |drawer| drawer.contains?(x,y) }
+
+      # 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)
+      [ (event.mouse_x - @last_event.mouse_x).to_i, (event.mouse_y - @last_event.mouse_y).to_i ]
+    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/models/draws.rb

@@ -30,7 +30,12 @@ module Metro
       #     end
       #
       def draw(actor_name,options = {})
-        scene_actor = ModelFactory.new 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}")

data/lib/metro/models/grid_drawer.rb

@@ -0,0 +1,57 @@
+module Metro
+  module Models
+    
+    class GridDrawer < Model
+
+      attr_writer :color, :spacing, :height, :width
+
+      def name
+        self.class.name
+      end
+
+      def spacing
+        @spacing ||= 10
+      end
+
+      def height
+        @height || Game.height
+      end
+
+      def width
+        @width || Game.width
+      end
+
+      def color
+        @color ||= Gosu::Color.new("rgba(255,255,255,0.1)")
+      end
+
+      def saveable?
+        false
+      end
+
+      def contains?(x,y)
+        false
+      end
+
+      def draw
+        draw_horizontal_lines
+        draw_vertical_lines
+      end
+
+      def draw_vertical_lines
+        xs = (width / spacing + 1).times.map {|segment| segment * spacing }
+        xs.each do |x|
+          window.draw_line(x, 1, color, x, height, color, 0, :additive)
+        end
+      end
+
+      def draw_horizontal_lines
+        ys = (height / spacing + 1).times.map {|segment| segment * spacing }
+        ys.each do |y|
+          window.draw_line(1, y, color, width, y, color, 0, :additive)
+        end
+      end
+
+    end
+  end
+end

data/lib/metro/models/image.rb

@@ -3,10 +3,10 @@ module Metro
 
     #
     # Draws an Image
-    # 
+    #
     # @example Using the Image in a view file
     #    model: "metro::models::image"
-    # 
+    #
     class Image < Model
 
       attr_accessor :x, :y, :angle, :center_x, :center_y, :x_factor, :y_factor, :z_order
@@ -25,6 +25,22 @@ module Metro
         @image ||= Gosu::Image.new(window,asset_path(path))
       end
 
+      def contains?(x,y)
+        bounds.contains?(x,y)
+      end
+
+      def bounds
+        Bounds.new x - (width * center_x), y - (height * center_y), x + (width * center_x), y + (height * center_y)
+      end
+
+      def width
+        image.width
+      end
+
+      def height
+        image.height
+      end
+
       def draw
         image.draw_rot x, y, z_order,
           angle.to_f,