chingu 0.7.6.6 → 0.7.6.7

data/lib/chingu/game_states/debug.rb

@@ -23,16 +23,33 @@ module Chingu
   module GameStates
   
     #
-    # Debug game state (F1 is default key to start/exit debug win, 'p' to pause game)
+    # Debug game state (F1 is default key to start/exit debug win, 'p'
+    # to pause game)
+    #
+    # Usage: 
     #  
     class Debug < Chingu::GameState
-      def initialize(options)
+      include Chingu::Helpers::OptionsSetter
+      
+      attr_accessor :fade_color, :text_color, :text, :x_offset, :y_offset
+      
+      # TODO - centralize!
+      Z = 999
+
+      DEFAULTS = {
+        :x_offset => 10,
+        :y_offset => 10,
+        :text_color => Gosu::Color.new(255,255,255,255),
+        :fade_color => Gosu::Color.new(100,100,100,70),
+        :paused => false
+      }
+
+      def initialize(options = {})
         super
-        @white = Color.new(255,255,255,255)
-        @fade_color = Gosu::Color.new(100,255,255,255)
-        
-        @font = Gosu::Font.new($window, default_font_name, 15)
-        @paused = true
+        set_options(options, DEFAULTS)
+
+        # it fails when setup in DEFAULTS as it needs existing $window
+        @font ||= Gosu::Font.new($window, Gosu::default_font_name, 16)
         
         self.input = {:p => :pause, :f1 => :return_to_game, :esc => :return_to_game}
       end
@@ -42,7 +59,7 @@ module Chingu
       end
       
       def pause
-        @paused = @paused ? false : true
+        @paused = !@paused
       end
       
       def update
@@ -50,16 +67,45 @@ module Chingu
       end
       
       def draw
-        game_state_manager.previous_game_state.draw
+        previous_state.draw unless previous_state.nil?
 
         $window.draw_quad(  0,0,@fade_color,
                             $window.width,0,@fade_color,
                             $window.width,$window.height,@fade_color,
-                            0,$window.height,@fade_color,10)
-                       
-        text = "DEBUG CONSOLE"
-        @font.draw(text, $window.width - @font.text_width(text), @font.height, 999)
-      end  
+                            0,$window.height,@fade_color,10)                       
+        
+        @font.draw("DEBUG CONSOLE", @x_offset, @y_offset, Z)       
+        print_lines(@text || generate_info)
+      end
+
+      protected
+      
+      def print_lines(text)
+        height = @font.height
+        lines = text.respond_to?(:lines) ? text.lines : text
+        
+        lines.each_with_index do |line,i|
+          @font.draw(line, @x_offset, @y_offset + height * (i+3), Z,1,1, @text_color)
+        end       
+      end
+
+      def generate_info
+        info = ''
+        info << previous_state.to_s
+
+        info << "\nObjects\n"         
+
+        previous_state.game_objects.each do |o|
+          info << "  #{o.class.to_s}: #{o.to_s}\n"
+        end
+
+        info
+      end
+
+      def previous_state
+        game_state_manager.previous_game_state        
+      end
+      
     end
   end
 end

data/lib/chingu/game_states/edit.rb

@@ -268,7 +268,11 @@ module Chingu
         #
         # Draw red rectangles/circles around all selected game objects
         #
-        selected_game_objects.each { |game_object| game_object.draw_debug }
+        if defined?(previous_game_state.viewport)
+          previous_game_state.viewport.apply {  selected_game_objects.each { |game_object| game_object.draw_debug } }
+        else
+          selected_game_objects.each { |game_object| game_object.draw_debug }
+        end
         
         if @cursor_game_object
           @cursor_game_object.draw_at($window.mouse_x, $window.mouse_y)

data/lib/chingu/game_states/fade_to.rb

@@ -36,7 +36,7 @@ module Chingu
     class FadeTo < Chingu::GameState
       
       def initialize(new_game_state, options = {})
-        @options = {:speed => 3, :zorder => 999999}.merge(options)
+        @options = {:speed => 3, :zorder => INFINITY}.merge(options)
         
         @new_game_state = new_game_state
         @new_game_state = new_game_state.new if new_game_state.is_a? Class        

data/lib/chingu/helpers/input_client.rb

@@ -45,16 +45,24 @@ module Chingu
     #
     module InputClient
       #
-      # Returns true or false depending on if the key is pressed
+      # Returns true or false depending if any of the given keys are pressed
       #
-      def holding?(key)
-        $window.button_down?(Chingu::Input::SYMBOL_TO_CONSTANT[key])
+      # Example:
+      #   @player.go_left if holding?(:left, :a)
+      #
+      def holding?(*keys)
+        Array(keys).each do |key|
+          return true if $window.button_down?(Chingu::Input::SYMBOL_TO_CONSTANT[key])
+        end
+        return false
       end
       
+      #
+      # Input-map writer
+      #
       def input=(input_map)
         @input ||= Hash.new
-        #@input = input_map
-
+        
         if input_map.is_a? Array
           #
           # Un-nest input_map [:left, :right, :space]

data/lib/chingu/helpers/input_dispatcher.rb

@@ -80,21 +80,26 @@ module Chingu
     # For a given object, dispatch "action".
     # An action can be:
     #
-    # * Symbol (:p, :space), translates into a method-call
-    # * Proc/Lambda, call() it
+    # * Symbol (:p, :space) or String, translates into a method-call
+    # * Proc/Lambda or Method, call() it
     # * GameState-instance, push it on top of stack
     # * GameState-inherited class, create a new instance, cache it and push it on top of stack
     #
     def dispatch_action(action, object)
       # puts "Dispatch Action: #{action} - Objects class: #{object.class.to_s}"
-      if action.is_a? Symbol
+      case action
+      when Symbol, String
         object.send(action)
-      elsif action.is_a? Proc
-        action.call
-      elsif action.is_a? Chingu::GameState
-        push_game_state(action)
-      elsif action.superclass == Chingu::GameState
+      when Proc, Method
+        action[]
+      when Chingu::GameState
         push_game_state(action)
+      when Class
+        if action.ancestors.include?(Chingu::GameState)
+          push_game_state(action)
+        end
+      else
+        # TODO possibly raise an error? This ought to be handled when the input is specified in the first place.
       end
     end
   end

data/lib/chingu/helpers/options_setter.rb

@@ -0,0 +1,33 @@
+module Chingu
+  module Helpers
+
+    #
+    # Provides #set_options method to simplify common initialization from Hash.
+    #
+    module OptionsSetter
+
+      protected
+      
+      #
+      # Takes hash and sets the instance variables denoted by 'keys'
+      # to 'values'. Uses setter, when available, otherwise simple
+      # 'instance_variable_set' is called. You can specify defaults
+      # for your convenience.
+      #
+      def set_options(options, defaults = {})
+        options = defaults.merge(options)
+        
+        options.each do |attr,value|
+          setter = "#{attr}="
+
+          if self.respond_to?(setter)
+            self.send(setter, value)
+          else
+            self.instance_variable_set("@#{attr.to_s}", value)
+          end
+        end
+      end
+        
+    end
+  end
+end

data/lib/chingu/input.rb

@@ -104,11 +104,11 @@ module Chingu
     # Gamepad-buttons 0-15
     (0..15).each do |number|
       CONSTANT_TO_SYMBOL[eval("GpButton#{number.to_s}")] = [
-        "gamepad_button_#{number.to_s}",
-        "gamepad_#{number.to_s}",
-        "pad_button_#{number.to_s}",
-        "pad_#{number.to_s}",
-        "gp_#{number.to_s}"
+        "gamepad_button_#{number.to_s}".to_sym,
+        "gamepad_#{number.to_s}".to_sym,
+        "pad_button_#{number.to_s}".to_sym,
+        "pad_#{number.to_s}".to_sym,
+        "gp_#{number.to_s}".to_sym
       ]
     end
 

data/lib/chingu/rect.rb

@@ -226,6 +226,7 @@ class Rect < Array
 
 	# Return the x coordinate of the center of the Rect
 	def centerx; return self.at(0)+(self.at(2).div(2)); end
+  alias center_x centerx;
 
 	# Set the x coordinate of the center of the Rect by translating the
 	# Rect (adjusting the x offset).
@@ -236,6 +237,7 @@ class Rect < Array
 
 	# Return the y coordinate of the center of the Rect
 	def centery; return self.at(1)+(self.at(3).div(2)); end
+  alias center_y centery;
 
 	# Set the y coordinate of the center of the Rect by translating the
 	# Rect (adjusting the y offset).

data/lib/chingu/text.rb

@@ -34,7 +34,7 @@ module Chingu
   #
   class Text < Chingu::GameObject
     attr_accessor :text
-    attr_reader :height, :gosu_font, :line_spacing, :align, :max_width, :background
+    attr_reader :size, :gosu_font, :line_spacing, :align, :max_width, :background
 
     @@size = nil
     @@font = nil
@@ -69,14 +69,14 @@ module Chingu
   
       @text = text || options[:text] || "-No text specified-"
       @font =  options[:font] || @@font || Gosu::default_font_name()
-      @height = @size = options[:height] || options[:size] || @@size || 15
+      @size = options[:size] || options[:height] || @@size || 15
       @line_spacing = options[:line_spacing] || 1
       @align = options[:align] || :left
       @max_width = options[:max_width]
       @padding = options[:padding] || @@padding
       self.rotation_center = :top_left
 
-      @gosu_font = Gosu::Font.new($window, @font, @height)
+      @gosu_font = Gosu::Font.new($window, @font, @size)
       create_image  unless @image
 
       if options[:background]
@@ -89,6 +89,8 @@ module Chingu
         @background.width = self.width + @padding * 2
         @background.height = self.height + @padding * 2
       end
+      
+      self.height = options[:height]  if options[:height]
     end
     
     #
@@ -99,10 +101,6 @@ module Chingu
       create_image
     end
     
-    def size
-      @height
-    end
-    
     #
     # Returns the width, in pixels, the given text would occupy if drawn.
     #
@@ -125,9 +123,9 @@ module Chingu
     #
     def create_image
       if @max_width
-        @image = Gosu::Image.from_text($window, @text, @font, @height, @line_spacing, @max_width, @align)
+        @image = Gosu::Image.from_text($window, @text, @font, @size, @line_spacing, @max_width, @align)
       else
-        @image = Gosu::Image.from_text($window, @text, @font, @height)
+        @image = Gosu::Image.from_text($window, @text, @font, @size)
       end
     end
   end

data/lib/chingu/traits/animation.rb

@@ -62,6 +62,7 @@ module Chingu
             state = $3.length > 0 ? $3 : "default"            
             animations[state.to_sym] = Chingu::Animation.new(trait_options[:animation].merge(:file => tile_file))
           elsif tile_file =~ /[a-zA-Z\_+]\.(bmp|png)/
+            puts tile_file
             animations[:default] = Chingu::Animation.new(trait_options[:animation].merge(:file => tile_file))
           end
           

data/lib/chingu/traits/bounding_box.rb

@@ -93,11 +93,7 @@ module Chingu
       # Visualises the bounding box as a red rectangle.
       #
       def draw_debug
-        if defined?(parent.viewport)
-          $window.draw_rect(self.bounding_box.move(-parent.viewport.x, -parent.viewport.y), Chingu::DEBUG_COLOR, Chingu::DEBUG_ZORDER)
-        else
-          $window.draw_rect(self.bounding_box, Chingu::DEBUG_COLOR, Chingu::DEBUG_ZORDER)
-        end        
+        $window.draw_rect(self.bounding_box, Chingu::DEBUG_COLOR, Chingu::DEBUG_ZORDER)
       end
       
     end

data/lib/chingu/traits/bounding_circle.rb

@@ -80,12 +80,7 @@ module Chingu
       # Visualises the bounding circle as a red circle.
       #
       def draw_debug
-        x,y = self.x, self.y          # Do we need to take center_x/center_y into consideration here?
-        if defined?(parent.viewport)
-          $window.draw_circle(x - parent.viewport.x, y - parent.viewport.y, self.radius, Chingu::DEBUG_COLOR)
-        else
-          $window.draw_circle(x, y, self.radius, Chingu::DEBUG_COLOR)
-        end
+        $window.draw_circle(self.x, self.y, self.radius, Chingu::DEBUG_COLOR)
       end
         
     end

data/lib/chingu/traits/effect.rb

@@ -65,15 +65,15 @@ module Chingu
       
       # Increase @factor_x and @factor_y at the same time.
       def scale(amount = 0.1)
-        @factor_x += amount
-        @factor_y += amount
+        self.factor_x += amount
+        self.factor_y += amount
       end
       alias :zoom :scale
           
       # Ddecrease @factor_x and @factor_y at the same time.
       def scale_out(amount = 0.1)
-        @factor_x -= amount
-        @factor_y -= amount
+        self.factor_x -= amount
+        self.factor_y -= amount
       end
       alias :zoom_out :scale_out
       

data/lib/chingu/traits/retrofy.rb

@@ -63,7 +63,7 @@ module Chingu
       end      
       
       def draw
-        @image.draw_rot(self.screen_x, self.screen_y, @zorder, @angle, @center_x, @center_y, @factor_x, @factor_y, @color, @mode)
+        self.image.draw_rot(self.screen_x, self.screen_y, self.zorder, self.angle, self.center_x, self.center_y, self.factor_x, self.factor_y, self.color, self.mode)
       end
     end
   end

data/lib/chingu/traits/sprite.rb

@@ -0,0 +1,234 @@
+#--
+# Part of Chingu -- OpenGL accelerated 2D game framework for Ruby
+# Copyright (C) 2009 ippa / ippa@rubylicio.us
+#
+# Written/Refactored by Jakub Hozak - jakub.hozak@gmail.com
+#
+#++
+
+module Chingu
+  module Traits
+
+    #
+    # A Chingu trait providing ability to be drawn as an image.
+    #
+    # Example:
+    # 
+    #   class Rocket < BasicGameObject
+    #     trait :sprite, :image => 'rocket.png'
+    #   end
+    #
+    #   Rocket.create
+    #
+    # Options:
+    #  :image - actual sprite to draw
+    #         - see #image= for details as this method is used to set this option
+    #  
+    # Introducing Variables:
+    #  :x, :y, :angle, :factor_x, :factor_y, :center_x, :center_y, :zorder, :mode, :visible
+    #
+    module Sprite
+
+      include Chingu::Helpers::OptionsSetter
+      
+      module ClassMethods
+        def initialize_trait(options = {})
+          trait_options[:sprite] = options
+        end
+      end
+      
+      attr_accessor :x, :y, :angle, :factor_x, :factor_y, :center_x, :center_y, :zorder, :mode, :visible
+
+      # default settings for all variables unless set in constructor
+      DEFAULTS = {
+        :x => 0, :y => 0, :angle => 0,
+        :factor_x => 1.0, :factor_y => 1.0,
+        :zorder => 100, :center_x => 0.5, :center_y => 0.5,
+        :mode => :default,
+        :color => nil
+      }
+
+      def setup_trait(object_options = {})
+        set_options(trait_options[:sprite].merge(object_options), DEFAULTS)
+        super
+      end
+
+      def color=(color)
+        @color = color.is_a?(Gosu::Color) ? color : Gosu::Color.new(color ||  0xFFFFFFFF)
+      end
+
+      #
+      # Accepts String, callable object or any-other non-nil capable
+      # of drawing itself on screen.
+      #
+      # Examples:
+      #   image = 'rocket.png'
+      #   image = Gosu::Image.new($window, 'rocket.png')
+      #     
+      #    image = lambda do
+      #      # TexPlay is library for Gosu image generation
+      #      TexPlay.create_image($window,10,10).paint { circle(5,5,5, :color => :red) }
+      #    end
+      #
+      def image=(image)
+        raise ArgumentError.new("No image set") if image.nil?
+        
+        @image = if String === image
+                   # 1) Try loading the image the normal way
+                   # 2) Try looking up the picture using Chingus Image-cache
+                   Gosu::Image.new($window, image,false) rescue Gosu::Image[image]
+                 elsif image.respond_to? :call
+                   image.call
+                 else
+                   image
+                 end
+      end
+
+      #
+      # Get all settings from a game object in one array.
+      # Complemented by the GameObject#attributes= setter.
+      # Makes it easy to clone a objects x,y,angle etc.
+      #
+      def attributes
+        [@x, @y, @angle, @center_x, @center_y, @factor_x, @factor_y, @color, @mode, @zorder]
+      end
+  
+      #
+      # Set all attributes on 1 line
+      # Mainly used in combination with game_object1.attributes = game_object2.attributes
+      #
+      def attributes=(attributes)
+        self.x, self.y, self.angle, self.center_x, self.center_y, self.factor_x, self.factor_y, self.color, self.mode, self.zorder = *attributes
+      end
+
+      #
+      # Set an effective width for the object on screen.
+      # Chingu does this by setting factor_x depending on imge.width and width given.
+      # Usually better to have a large image and make it smaller then the other way around.
+      #
+      def width=(width)
+        @factor_x = width.to_f / @image.width.to_f
+      end
+    
+      # Get effective on width by calculating it from image-width and factor
+      def width
+        (@image.width * @factor_x).abs
+      end
+
+      #
+      # Set an effective height for the object on screen.
+      # Chingu does this by setting factor_x depending on imge.width and width given.
+      # Usually better to have a large image and make it smaller then the other way around.
+      #
+      def height=(height)
+        @factor_y = height.to_f / @image.height.to_f
+      end
+    
+      # Get effective on heightby calculating it from image-width and factor
+      def height
+        (@image.height.to_f * @factor_y).abs
+      end
+
+      # Set width and height in one swoop
+      def size=(size)
+        self.width, self.height = *size
+      end
+    
+      # Get objects width and height in an array
+      def size
+        [self.width, self.height]
+      end
+      
+
+      # Quick way of setting both factor_x and factor_y
+      def factor=(factor)
+        @factor_x = @factor_y = factor
+      end
+      alias scale= factor=
+      # alias scale factor
+          
+      # Quick way of setting both center_x and center_y
+      def center=(center)
+        @center_x = @center_y = center
+      end
+    
+      # Get objects alpha-value (internally stored in @color.alpha)
+      def alpha
+        @color.alpha
+      end
+    
+      # Set objects alpha-value (internally stored in @color.alpha)
+      # If out of range, set to closest working value. this makes fading simpler.
+      def alpha=(value)
+        value = 0   if value < 0
+        value = 255 if value > 255
+        @color.alpha = value
+      end
+
+      #
+      # Sets angle, normalize it to between 0..360
+      #
+      def angle=(value)
+        if value < 0
+          value = 360+value
+        elsif value > 360
+          value = value-360
+        end
+        @angle = value
+      end
+
+      #
+      # Disable automatic calling of draw and draw_trait each game loop
+      #
+      def hide!
+        @visible = false
+      end
+    
+      #
+      # Enable automatic calling of draw and draw_trait each game loop
+      #
+      def show!
+        @visible = true
+      end
+    
+      #
+      # Returns true if visible (not hidden)
+      #
+      def visible?
+        @visible == true
+      end    
+
+
+      # Returns true if object is inside the game window, false if outside
+      def inside_window?(x = @x, y = @y)
+        x >= 0 && x <= $window.width && y >= 0 && y <= $window.height
+      end
+
+      # Returns true object is outside the game window 
+      def outside_window?(x = @x, y = @y)
+        not inside_window?(x,y)
+      end
+
+      #
+      # Our encapsulation of GOSU's image.draw_rot, uses the objects variables to draw it on screen if @visible is true
+      #
+      def draw
+        draw_relative
+      end
+
+      #
+      # 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)
+        draw_relative(x,y)
+      end
+    end
+  end
+end