chingu 0.7.0 → 0.7.5

data/lib/chingu.rb

@@ -33,7 +33,7 @@ require_all "#{CHINGU_ROOT}/chingu/traits"
 require_all "#{CHINGU_ROOT}/chingu"
 
 module Chingu
-  VERSION = "0.7.0"
+  VERSION = "0.7.5"
   
   DEBUG_COLOR = Gosu::Color.new(0xFFFF0000)
   DEBUG_ZORDER = 9999

data/lib/chingu/animation.rb

@@ -37,20 +37,69 @@ module Chingu
       @step = options[:step] || 1
       @dt = 0
       
+      @sub_animations = {}
+      @frame_actions = []
+      @file = media_path(@file)  if @file && !File.exist?(@file)
+      
+      #
+      # Various ways of determening the framesize
+      #
       if options[:size] && options[:size].is_a?(Array)
         @width = options[:size][0]
         @height = options[:size][1]
       elsif options[:size]
         @width = options[:size]
         @height = options[:size]
+      elsif @file =~ /_(\d+)x(\d+)/
+        # Auto-detect width/height from filename 
+        # Tilefile foo_10x25.png would mean frame width 10px and height 25px
+        @width = $1.to_i
+        @height = $2.to_i
+      else
+        # Assume the shortest side is the width/height for each frame
+        @image = Gosu::Image.new($window, @file)
+        @width = @height = (@image.width < @image.height) ? @image.width : @image.height
       end
       
-      @file = media_path(@file)  unless File.exist?(@file)
-      
-      @frame_actions = []
       @frames = Gosu::Image.load_tiles($window, @file, @width, @height, true)
     end
     
+    #
+    # Remove transparent space from each frame so the actual sprite is touching the border of the image.
+    #
+    def trim
+      @frames.each do |frame|
+        # TODO!
+      end
+    end
+    
+    #
+    # Put name on specific ranges of frames.
+    # Eg. name_frames(:default => 0..3, :explode => 3..8)
+    #
+    # Can then be accessed with @animation[:explode]
+    #
+    def frame_names=(names)
+      names.each do |key, value|
+        @sub_animations[key] = self.new_from_frames(value) if value.is_a? Range
+        #
+        # TODO: Add support for [1,4,5] array frame selection
+        #
+        # @frame_names[key] = self.new_from_frames(value) if value.is_a? Array
+      end
+    end
+    
+    #
+    # Return frame names in { :name => range } -form
+    #
+    def frame_names
+      @frame_names
+    end
+    
+    def animations
+      @sub_animations.keys
+    end
+    
     #
     # Returns first frame (GOSU::Image) from animation
     #
@@ -64,18 +113,37 @@ module Chingu
     def last
       @frames.last
     end
+		
+		#
+		# Returns true if the current frame is the last
+		#
+		def last_frame?
+			@previous_index == @index
+		end
     
     #
     # Fetch a frame or frames:
     #
-    #   @animation[0]       # returns first frame
-    #   @animation[0..2]    # returns a new Animation-instance with first, second and third frame
+    #   @animation[0]         # returns first frame
+    #   @animation[0..2]      # returns a new Animation-instance with first, second and third frame
+    #   @animation[:explode]  # returns a cached Animation-instance with frames earlier set with @animation.frame_names = { ... }
     #
     def [](index)
       return @frames[index]               if  index.is_a?(Fixnum)
       return self.new_from_frames(index)  if  index.is_a?(Range)
+      return @sub_animations[index]          if  index.is_a?(Symbol)
     end
-		
+
+    #
+    # Manually initialize a frame-range with an Animation-instance
+    #
+    #   @animation[:scan] = Animation.new(...)
+    #
+    def []=(name, animation)
+      @sub_animations[name] = animation
+      return @sub_animations[name]
+    end
+
     #
     # Get the current frame (a Gosu#Image)
     #
@@ -96,7 +164,7 @@ module Chingu
     # Returns a new animation with the frames from the original animation.
     # Specify which frames you want with "range", for example "0..3" for the 4 first frames.
     #
-    def new_from_frames(range)
+    def new_from_frames(range)				
       new_animation = self.dup
       new_animation.frames = []
       range.each do |nr|
@@ -104,12 +172,13 @@ module Chingu
       end
       return new_animation
     end
-    
+            
     #
     # Propelles the animation forward. Usually called in #update within the class which holds the animation.
     # Animation#next() will look at bounce and loop flags to always return a correct frame (a Gosu#Image)
     #
-    def next
+    def next(recursion = true)
+        
       if (@dt += $window.milliseconds_since_last_tick) > @delay
         @dt = 0
         @previous_index = @index

data/lib/chingu/basic_game_object.rb

@@ -20,10 +20,10 @@ module Chingu
     # Adds a trait or traits to a certain game class
     # Executes a standard ruby "include" the specified module
     #
-    def self.has_trait(trait, options = {})
+    def self.trait(trait, options = {})
       
       if trait.is_a?(::Symbol) || trait.is_a?(::String)
-        ## puts "has_trait #{trait}, #{options}"
+        ## puts "trait #{trait}, #{options}"
         begin
           # Convert user-given symbol (eg. :timer) to a Module (eg. Chingu::Traits::Timer)
           mod = Chingu::Traits.const_get(Chingu::Inflector.camelize(trait))
@@ -39,7 +39,7 @@ module Chingu
             extend mod2
           
             # If the newly included trait has a initialize_trait method in the ClassMethods-scope:
-            # ... call it with the options provided with the has_trait-line.
+            # ... call it with the options provided with the trait-line.
             if mod2.method_defined?(:initialize_trait)
               initialize_trait(options)
             end
@@ -49,10 +49,17 @@ module Chingu
         end
       end
     end
+    class << self; alias :has_trait :trait;  end
     
-    def self.has_traits(*traits)
-      Array(traits).each { |trait| has_trait trait }
+    def self.traits(*traits)
+      Array(traits).each { |trait_name| trait trait_name }
     end
+    class << self; alias :has_traits :traits; end
+		
+		#def self.inherited(subclass)
+		#	subclass.initialize_inherited_trait	if subclass.method_defined?(:initialize_inherited_trait)
+		#end
+			
         
     #
     # BasicGameObject initialize
@@ -78,7 +85,7 @@ module Chingu
 
       # This will call #setup_trait on the latest trait mixed in
       # which then will pass it on to the next setup_trait() with a super-call.
-      setup_trait(options)
+      setup_trait(options)      
     end
 
     #
@@ -90,8 +97,8 @@ module Chingu
     # Chingus "game_objects" which is available in all game states and the main window.
     #
     #def self.create(options = {})
-    def self.create(*options)
-      instance = self.new(*options)
+    def self.create(*options, &block)
+      instance = self.new(*options, &block)
       
       #
       # Add to parents list of game objects
@@ -157,6 +164,7 @@ module Chingu
     #
     def self.initialize_trait(options); end
     def setup_trait(options); end
+    def setup; end
     def update_trait; end
     def draw_trait; end    
     def update; end

data/lib/chingu/game_object.rb

@@ -39,19 +39,27 @@ module Chingu
         
     def initialize(options = {})
       super
-
-      # All encapsulated draw_rot arguments can be set with hash-options at creation time
+      
+      #
+      # All encapsulated Gosu::Image.draw_rot arguments can be set with hash-options at creation time
+			#
       if options[:image].is_a?(Gosu::Image)
         @image = options[:image]
       elsif options[:image].is_a? String
-        @image = Gosu::Image[options[:image]]
+				begin
+					# 1) Try loading the image the normal way
+					@image = Gosu::Image.new($window, options[:image])
+				rescue
+					# 2) Try looking up the picture using Chingus Image-cache
+					@image = Gosu::Image[options[:image]]
+				end
       end
       
       @x = options[:x] || 0
       @y = options[:y] || 0
       @angle = options[:angle] || 0
       
-      self.factor = options[:factor] || options[:scale] || 1.0
+      self.factor = options[:factor] || options[:scale] || $window.factor || 1.0
       @factor_x = options[:factor_x] if options[:factor_x]
       @factor_y = options[:factor_y] if options[:factor_y]
       
@@ -73,6 +81,12 @@ module Chingu
       
       @mode = options[:mode] || :default # :additive is also available.
       @zorder = options[:zorder] || 100
+      
+      ### super ## This crashes
+      # Call setup, this class holds an empty setup() to be overriden
+      # setup() will be an easier method to override for init-stuff since you don't need to do super etc..
+      setup
+      
     end
     
     # Quick way of setting both factor_x and factor_y
@@ -117,7 +131,16 @@ module Chingu
     def distance_to(object)
       distance(self.x, self.y, object.x, object.y)
     end
-    
+
+    #
+    # Returns a filename-friendly string from the current class-name
+    #
+    # "FireBall" -> "fire_ball"
+    #
+    def filename
+      Chingu::Inflector.underscore(self.class.to_s)
+    end
+
     #
     # Our encapsulation of GOSU's image.draw_rot, uses the objects variables to draw it on screen if @visible is true
     #
@@ -126,11 +149,17 @@ module Chingu
     end
     
     #
-    # Works as #draw() but takes offsets for all draw_rot()-arguments. Used among others by by viewport-trait
+    # Works as #draw() but takes offsets for all draw_rot()-arguments. Used among others by the viewport-trait.
     #
     def draw_relative(x=0, y=0, zorder=0, angle=0, center_x=0, center_y=0, factor_x=0, factor_y=0)
       @image.draw_rot(@x+x, @y+y, @zorder+zorder, @angle+angle, @center_x+center_x, @center_y+center_y, @factor_x+factor_x, @factor_y+factor_y, @color, @mode) if @visible
     end
-    
+
+    #
+    # Works as #draw() but takes x/y arguments. Used among others by the edit-game state.
+    #
+    def draw_at(x, y)
+      @image.draw_rot(x, y, @zorder, @angle, @center_x, @center_y, @factor_x, @factor_y, @color, @mode) if @visible
+    end
   end  
 end

data/lib/chingu/game_object_list.rb

@@ -29,6 +29,8 @@ module Chingu
         
     def initialize(options = {})
       @game_objects = options[:game_objects] || []
+			@add_game_objects = []
+			@remove_game_objects = []
       #@game_objects_by_class = Hash.new
     end
     
@@ -49,12 +51,17 @@ module Chingu
     alias :remove_all :destroy_all
     
     def add_game_object(object)
-      @game_objects.push(object)
+      #@game_objects.push(object)
+			@add_game_objects.push(object)
+			
+			
       #(@game_objects_by_class[object.class] ||= []).push(object)
     end
     
     def remove_game_object(object)
-      @game_objects.delete(object)
+      #@game_objects.delete(object)
+			@remove_game_objects.push(object)	
+			
       #@game_objects_by_class[object.class].delete(object)
     end
     
@@ -80,8 +87,18 @@ module Chingu
         object.draw_relative(x, y, zorder, angle, center_x, center_y, factor_x, factor_y)
       end
     end
-
+    
+    def sync
+			@game_objects += @add_game_objects
+			@add_game_objects.clear
+			
+			@game_objects -= @remove_game_objects
+			@remove_game_objects.clear      
+    end
+      
     def update
+      sync
+				
       @game_objects.select{ |object| not object.paused }.each do |object| 
         object.update_trait 
         object.update

data/lib/chingu/game_state.rb

@@ -57,7 +57,7 @@ module Chingu
     include Chingu::Helpers::ClassInheritableAccessor # adds classmethod class_inheritable_accessor
     
     attr_reader :options
-    attr_accessor :game_state_manager, :game_objects
+    attr_accessor :game_objects, :game_state_manager
     
     class_inheritable_accessor :trait_options
     @trait_options = Hash.new
@@ -67,10 +67,10 @@ module Chingu
     # Adds a trait or traits to a certain game class
     # Executes a standard ruby "include" the specified module
     #
-    def self.has_trait(trait, options = {})
+    def self.trait(trait, options = {})
       
       if trait.is_a?(::Symbol) || trait.is_a?(::String)
-        ## puts "has_trait #{trait}, #{options}"
+        ## puts "trait #{trait}, #{options}"
         begin
           # Convert user-given symbol (eg. :timer) to a Module (eg. Chingu::Traits::Timer)
           mod = Chingu::Traits.const_get(Chingu::Inflector.camelize(trait))
@@ -86,7 +86,7 @@ module Chingu
             extend mod2
           
             # If the newly included trait has a initialize_trait method in the ClassMethods-scope:
-            # ... call it with the options provided with the has_trait-line.
+            # ... call it with the options provided with the trait-line.
             if mod2.method_defined?(:initialize_trait)
               initialize_trait(options)
             end
@@ -96,11 +96,12 @@ module Chingu
         end
       end
     end
+    class << self; alias :has_trait :trait;  end
     
-    def self.has_traits(*traits)
-      Array(traits).each { |trait| has_trait trait }
+    def self.traits(*traits)
+      Array(traits).each { |trait| trait trait }
     end
-
+    class << self; alias :has_traits :traits; end
 
     def initialize(options = {})
       @options = options

data/lib/chingu/game_states/edit.rb

@@ -23,52 +23,80 @@ module Chingu
   module GameStates
   
     #
-    # Premade game state for chingu - A simple pause state.
-    # Pause whenever with: 
-    #   push_game_state(Chingu::GameStates::Pause)
+    # Premade game state for chingu - simple level editing.
+    # Start editing in a gamestate with:
+    #   push_game_state(Chingu::GameStates::Edit)
     #
     # requires the global $window set to the instance of Gosu::Window (automaticly handled if you use Chingu::Window)
     #
     class Edit < Chingu::GameState
+      
       def initialize(options = {})
         super
-        @grid = options[:grid]
+        @grid = options[:grid] || [8,8]
         @classes = options[:classes] || []
+        @only = options[:only] || []
+        @debug = options[:debug]
+        @file = options[:file] || "#{previous_game_state.class.to_s.downcase}.yml"
+        @zorder = 10000
         
-        @color = Gosu::Color.new(200,0,0,0)
-        @red = Gosu::Color.new(0xFFFF0000)
-        @white = Gosu::Color.new(0xFFFFFFFF)
+        @hud_color = Gosu::Color.new(150,100,100,100)
         @selected_game_object = nil        
         self.input =  { :left_mouse_button => :left_mouse_button, 
                         :released_left_mouse_button => :released_left_mouse_button,
+                        :right_mouse_button => :right_mouse_button, 
+                        :released_right_mouse_button => :released_right_mouse_button,                        
                         :delete => :destroy_selected_game_objects,
                         :backspace => :destroy_selected_game_objects,
                         :e => :save_and_quit,
                         :s => :save,
-                        :esc => :quit,
+                        :esc => :save_and_quit,
+                        :holding_up_arrow => :scroll_up,
+                        :holding_down_arrow => :scroll_down,
+                        :holding_left_arrow => :scroll_left,
+                        :holding_right_arrow => :scroll_right,
+                        :page_up => :page_up,
+                        :page_down => :page_down,
                         :"1" => :create_object_1,
                         :"2" => :create_object_2,
                         :"3" => :create_object_3,
                         :"4" => :create_object_4,
                         :"5" => :create_object_5,
                       }
-      end
-
-      def setup
-        name = if defined?(previous_game_state.filename)
-          previous_game_state.filename
-        else 
-          "#{previous_game_state.class.to_s.downcase}.yml"
+        
+        x = 20
+        y = 60
+        @classes.each do |klass|
+          puts "Creating a #{klass}"  if @debug
+          
+          # We initialize x,y,zorder,rotation_center after creation
+          # so they're not overwritten by the class initialize/setup or simular
+          game_object = klass.create
+          game_object.x = x
+          game_object.y = y
+          game_object.zorder = @zorder
+          
+          # Scale down big objects, don't scale objects under [32, 32]
+          if game_object.image
+            game_object.factor_x = 32 / game_object.image.width   if game_object.image.width > 32
+            game_object.factor_y = 32 / game_object.image.height  if game_object.image.height > 32
+          end
+          x += 40
         end
-        @filename = File.join($window.root, name)
-        @title = Text.create("File: #{@filename}", :x => 5, :y => 10)
+      end
+            
+      def setup                        
+        @title = Text.create("File: #{@file}", :x => 5, :y => 2, :factor => 1, :size => 16, :zorder => @zorder)
         @title.text += " - Grid: #{@grid}" if @grid
-        @title2 = Text.create("(1-10) Create object at mouse pos  (DEL) Delete selected object  (S) Save  (E) Save and Quit  (ESC) Quit without saving", :x => 5, :y => 30)        
-        @text = Text.create("", :x => 5, :y => 50)        
+        @text = Text.create("", :x => 200, :y => 20, :factor => 1, :size => 16, :zorder => @zorder)
+        @status_text = Text.create("-", :x => 5, :y => 20, :factor => 1, :size => 16, :zorder => @zorder)
+        #@title2 = Text.create("(1-10) Create object at mouse pos  (DEL) Delete selected object  (S) Save  (E) Save and Quit  (ESC) Quit without saving", :x => 5, :y => 30, :factor => 1)
       end
       
       def create_object_nr(number)
-        @classes[number].create(:x => $window.mouse_x, :y => $window.mouse_y, :parent => previous_game_state)  if @classes[number]
+        c = @classes[number].create(:x => x, :y => y, :parent => previous_game_state)  if @classes[number]
+        c.update
+        #@text.text = "Created a #{c.class} @ #{c.x} / #{c.y}"
       end
       
       def create_object_1; create_object_nr(0); end
@@ -77,48 +105,61 @@ module Chingu
       def create_object_4; create_object_nr(3); end
       def create_object_5; create_object_nr(4); end
       
-        
-      
       def draw
-        # Draw prev game state onto screen (the level we're editing for example)
-        previous_game_state.draw 
+        # Draw prev game state onto screen (the level we're editing)
+        previous_game_state.draw
         
-        #
-        # Draw an edit HUD
-        #
-        $window.draw_quad(  0,0,@color,
-                            $window.width,0,@color,
-                            $window.width,100,@color,
-                            0,100,@color,10)
-        #
-        # Draw debug Texts etc..
-        #
         super
         
         #
-        # Draw a red rectangle around all selected game objects
+        # Draw an edit HUD
         #
-        selected_game_objects.each do |game_object|
-          draw_rect(game_object.bounding_box.inflate(2,2), @red, 999)
-        end
+        $window.draw_quad(  0,0,@hud_color,
+                            $window.width,0,@hud_color,
+                            $window.width,100,@hud_color,
+                            0,100,@hud_color, @zorder-1)
         
         #
-        # draw a simple triagle-shaped cursor
+        # Draw red rectangles/circles around all selected game objects
         #
-        $window.draw_triangle( $window.mouse_x, $window.mouse_y, @white, 
-                               $window.mouse_x, $window.mouse_y + 10, @white, 
-                               $window.mouse_x + 10, $window.mouse_y + 10, @white, 9999)
+        selected_game_objects.each { |game_object| game_object.draw_debug }
         
+        if @cursor_game_object
+          @cursor_game_object.draw_at($window.mouse_x, $window.mouse_y)
+        else
+          #
+          # draw a simple triagle-shaped cursor
+          #
+          $window.draw_triangle( $window.mouse_x, $window.mouse_y, Color::WHITE, 
+                                $window.mouse_x, $window.mouse_y + 10, Color::WHITE, 
+                                $window.mouse_x + 10, $window.mouse_y + 10, Color::WHITE, @zorder + 10)
+        end
       end
       
       def update
+        # Sync all changes to previous game states game objects list
+        # This is needed since we don't call update on it.
+        previous_game_state.game_objects.sync
+        
         super
         
+        #
+        # We got a selected game object
+        #
+        if @selected_game_object
+          @text.text = "#{@selected_game_object.class.to_s} @ #{@selected_game_object.x} / #{@selected_game_object.y} - zorder: #{@selected_game_object.zorder}"
+        end
+        
+        #
+        # We got a selected game object and the left mouse button is held down
+        #
         if @left_mouse_button && @selected_game_object
-          @selected_game_object.x = ($window.mouse_x + @mouse_x_offset) / $window.factor
-          @selected_game_object.y = ($window.mouse_y + @mouse_y_offset) / $window.factor
-          @selected_game_object.x -= @selected_game_object.x % @grid[0]
-          @selected_game_object.y -= @selected_game_object.y % @grid[1]
+          selected_game_objects.each do |selected_game_object|            
+            selected_game_object.x = self.x + selected_game_object.options[:mouse_x_offset]
+            selected_game_object.y = self.y + selected_game_object.options[:mouse_y_offset]
+            selected_game_object.x -= selected_game_object.x % @grid[0]
+            selected_game_object.y -= selected_game_object.y % @grid[1]
+          end
           
           # TODO: better cleaner sollution
           if @selected_game_object.respond_to?(:bounding_box)
@@ -126,6 +167,8 @@ module Chingu
             @selected_game_object.bounding_box.y = @selected_game_object.y
           end
         end
+        
+        @status_text.text = "Mouseposition: #{x} / #{y}"
       end
 
       def selected_game_objects
@@ -136,69 +179,76 @@ module Chingu
         selected_game_objects.each(&:destroy)
       end
        
+      #
+      # CLICKED LEFT MOUSE BUTTON
+      #
       def left_mouse_button
         @left_mouse_button = true
-        x = $window.mouse_x / $window.factor
-        y = $window.mouse_y / $window.factor
-                
-        @text.text = "Click @ #{x} / #{y}"
         
-        #
-        # Deselect all objects
-        #
-        selected_game_objects.each do |game_object|         
-          game_object.options[:selected] = false
+        if @cursor_game_object && game_object_at(x, y)==nil && game_object_icon_at($window.mouse_x, $window.mouse_y) == nil
+          game_object = @cursor_game_object.class.create(:parent => previous_game_state)
+          game_object.update
+          game_object.options[:selected] = true
+          game_object.x = x
+          game_object.y = y
         end
         
-        #
-        # Get new object that was clicked at (if any)
-        #
+        # Get editable game object that was clicked at (if any)
         @selected_game_object = game_object_at(x, y)
         
+        # Check if user clicked on anything in the icon-toolbar of available game objects
+        @cursor_game_object = game_object_icon_at($window.mouse_x, $window.mouse_y)
+              
         if @selected_game_object
-          @text.text = "#{@text.text} : #{@selected_game_object.class.to_s}"
-          @selected_game_object.options[:selected] = true
+          #
+          # If clicking on a new object that's wasn't previosly selected
+          #  --> deselect all objects unless holding left_ctrl
+          #
+          if @selected_game_object.options[:selected] == nil
+            selected_game_objects.each { |x| x.options[:selected] = nil } unless holding?(:left_ctrl)
+          end
           
-          @mouse_x_offset = @selected_game_object.x - $window.mouse_x
-          @mouse_y_offset = @selected_game_object.y - $window.mouse_y
+          @selected_game_object.options[:selected] = true
+          #
+          # Re-align all objects x/y offset in relevance to the cursor
+          #
+          selected_game_objects.each do |selected_game_object|
+            selected_game_object.options[:mouse_x_offset] = selected_game_object.x - self.x
+            selected_game_object.options[:mouse_y_offset] = selected_game_object.y - self.y
+          end
+        else
+          selected_game_objects.each { |x| x.options[:selected] = nil } unless holding?(:left_ctrl)
         end
-        
       end
       
-      def released_left_mouse_button        
-        @left_mouse_button = false
-        @selected_game_object = false
+      def right_mouse_button
+        @cursor_game_object = game_object_at(x, y)
+        selected_game_objects.each { |x| x.options[:selected] = nil }
+      end
+      def released_right_mouse_button
       end
       
+      #
+      # RELASED LEFT MOUSE BUTTON
+      #
+      def released_left_mouse_button
+        @left_mouse_button = false
+      end
+
+      def game_object_icon_at(x, y)
+        game_objects.select do |game_object| 
+          game_object.respond_to?(:collision_at?) && game_object.collision_at?(x,y)
+        end.first
+      end
+
       def game_object_at(x, y)
         previous_game_state.game_objects.select do |game_object| 
-          game_object.respond_to?(:bounding_box) && game_object.bounding_box.collide_point?(x,y)
+          game_object.respond_to?(:collision_at?) && game_object.collision_at?(x,y)
         end.first
       end
       
-      
       def save
-        require 'yaml'
-        objects = []
-        previous_game_state.game_objects.each do |game_object|
-          objects << {game_object.class.to_s  => 
-                        {
-                        :x => game_object.x, 
-                        :y => game_object.y,
-                        :angle => game_object.angle,
-                        :zorder => game_object.zorder,
-                        :factor_x => game_object.factor_x,
-                        :factor_y => game_object.factor_y,
-                        :center_x => game_object.center_x,
-                        :center_y => game_object.center_y,
-                        }
-                      }
-        end
-        
-        #Marshal.dump(previous_game_state.game_objects, File.open(@filename, "w"))
-        File.open(@filename, 'w') do |out|
-          YAML.dump(objects, out)
-        end
+        save_game_objects(:game_objects => previous_game_state.game_objects, :file => @file, :classes => @classes)
       end
       
       def save_and_quit
@@ -209,13 +259,50 @@ module Chingu
       def quit
         pop_game_state(:setup => false)
       end
+
+      def game_object_classes
+        ObjectSpace.enum_for(:each_object, class << GameObject; self; end).to_a.select do |game_class|
+          game_class.instance_methods
+        end
+      end
       
+      def page_up
+        selected_game_objects.each { |game_object| game_object.zorder += 1 }
+        #self.previous_game_state.viewport.y -= $window.height if defined?(self.previous_game_state.viewport)
+      end
+      def page_down
+        selected_game_objects.each { |game_object| game_object.zorder -= 1 }
+        #self.previous_game_state.viewport.y += $window.height if defined?(self.previous_game_state.viewport)
+      end
+      def scroll_up
+        self.previous_game_state.viewport.y -= 10 if defined?(self.previous_game_state.viewport)
+      end
+      def scroll_down
+        self.previous_game_state.viewport.y += 10 if defined?(self.previous_game_state.viewport)
+      end
+      def scroll_left
+        self.previous_game_state.viewport.x -= 10 if defined?(self.previous_game_state.viewport)
+      end
+      def scroll_right
+        self.previous_game_state.viewport.x += 10 if defined?(self.previous_game_state.viewport)
+      end
+      def x
+        x = $window.mouse_x 
+        x += self.previous_game_state.viewport.x if defined?(self.previous_game_state.viewport)
+      end
+      def y
+        y = $window.mouse_y
+        y += self.previous_game_state.viewport.y if defined?(self.previous_game_state.viewport)
+      end
+
       #
       # If we're editing a game state with automaticly called special methods, 
       # the following takes care of those.
       #
       def method_missing(symbol, *args)
-        previous_game_state.__send__(symbol, *args)
+        if symbol != :button_down || symbol != :button_up
+          previous_game_state.__send__(symbol, *args)
+        end
       end
       
     end