chingu 0.5.5.3

data/lib/chingu/traits/input.rb

@@ -0,0 +1,38 @@
+#--
+#
+# Chingu -- Game framework built on top of the opengl accelerated gamelib Gosu
+# Copyright (C) 2009 ippa / ippa@rubylicio.us
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+#++
+
+
+module Chingu
+  module Traits
+    module Input
+    
+      def input=(input_map)
+        @input = input_map
+        @parent.add_input_client(self)  if @parent
+      end
+      
+      def input
+        @input
+      end
+      
+    end
+  end
+end

data/lib/chingu/traits/retrofy.rb

@@ -0,0 +1,53 @@
+#--
+#
+# Chingu -- Game framework built on top of the opengl accelerated gamelib Gosu
+# Copyright (C) 2009 ippa / ippa@rubylicio.us
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+#++
+
+
+module Chingu
+  module Traits
+    #
+    # A chingu trait providing easier handling of the "retrofy" effect (non-blurry zoom)
+    # Aims to help out when using zoom-factor to create a retrofeeling with big pixels.
+    # Provides screen_x and screen_y which takes the zoom into account
+    # Also provides new code for draw() which uses screen_x / screen_y instead of x / y
+    #
+    module Retrofy
+      
+      def setup_trait(options)
+        @retrofy_options = {:debug => false}.merge(options)        
+
+        super
+      end
+
+      def screen_x
+        (@x * self.factor).to_i
+      end
+
+      def screen_y
+        (@y * self.factor).to_i
+      end
+      
+      def draw
+        @image.draw_rot(self.screen_x, self.screen_y, @zorder, @angle, @center_x, @center_y, @factor_x, @factor_y, @color, @mode)
+      end
+      
+    end
+  end
+end

data/lib/chingu/traits/rotation_center.rb

@@ -0,0 +1,84 @@
+#--
+#
+# Chingu -- Game framework built on top of the opengl accelerated gamelib Gosu
+# Copyright (C) 2009 ippa / ippa@rubylicio.us
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+#++
+
+
+module Chingu
+  module Traits
+    module RotationCenter
+      #
+      # returns [center_x, center_y] (see Gosu::Image#draw_rot)
+      # 
+      @@rotation_centers = {
+        :top_left => [0,0],
+        :left_top => [0,0],
+        
+        :center_left => [0,0.5],
+        :middle_left => [0,0.5],
+        :left_center => [0,0.5],
+        :left_middle => [0,0.5],
+        
+        :bottom_left => [0,1],
+        :left_bottom => [0,1],
+        
+        :top_center => [0.5,0],
+        :top_middle => [0.5,0],
+        :center_top => [0.5,0],
+        :middle_top => [0.5,0],
+        
+        :center_center => [0.5,0.5],
+        :middle_middle => [0.5,0.5],
+        :center => [0.5,0.5],
+        :middle => [0.5,0.5],
+        
+        :bottom_center => [0.5,1],
+        :bottom_middle => [0.5,1],
+        :center_bottom => [0.5,1],
+        :middle_bottom => [0.5,1],
+        
+        :top_right => [1,0],
+        :right_top => [1,0],
+        
+        :center_right => [1,0.5],
+        :middle_right => [1,0.5],
+        :right_center => [1,0.5],
+        :right_middle => [1,0.5],
+        
+        :bottom_right => [1,1],
+        :right_bottom => [1,1]
+      }
+    
+      #
+      # Sets @center_x and @center_y according to given alignment. Available alignments are:
+      #
+      #   :top_left, :center_left, :bottom_left, :top_center, 
+      #   :center_center, :bottom_center, :top_right, :center_right and :bottom_right
+      #
+      # They're also available in the opposite order with the same meaning.
+      # They're also available (hey, hashlookups are speedy) with "middle" instead of "center" since
+      # those 2 words basicly have the same meaning and are both understandable.
+      #
+      def rotation_center(alignment)
+        @center_x, @center_y = @@rotation_centers[alignment.to_sym]
+      end
+      
+    end
+  end
+end

data/lib/chingu/traits/timer.rb

@@ -0,0 +1,90 @@
+#--
+#
+# Chingu -- Game framework built on top of the opengl accelerated gamelib Gosu
+# Copyright (C) 2009 ippa / ippa@rubylicio.us
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+#++
+
+
+module Chingu
+  module Traits
+    #
+    # A chingu trait providing timer-methods to its includer, examples:
+    #   during(300) { @color = Color.new(0xFFFFFFFF) }   # forces @color to white ever update for 300 ms
+    #   after(400) { self.destroy! }                     # destroy object after 400 ms
+    #   between(1000,2000) { self.rotate(10) }           # starting after 1 second, call rotate(10) each update during 1 second
+    #
+    # All the above can be combined with a 'then { do_something }'. For example, a classic shmup damage effect:
+    #   during(100) { @color.alpha = 100 }.then { @color.alpha = 255 }
+    #
+    module Timer 
+      def setup_trait(options)
+        @timer_options = {:debug => false}.merge(options)        
+        
+        #
+        # Timers are saved as an array of arrays where each entry contains:
+        # [start_time, end_time (or nil if one-shot), &block]
+        #
+        @_timers = Array.new
+        super
+      end
+
+      def during(time, &block)
+        ms = milliseconds()
+        @_last_timer = [ms, ms + time, block]
+        @_timers << @_last_timer
+        self
+      end
+      
+      def after(time, &block)
+        ms = milliseconds()
+        @_last_timer = [ms + time, nil, block]
+        @_timers << @_last_timer
+        self
+      end
+      
+      def between(start_time, end_time, &block)
+        ms = milliseconds()
+        @_last_timer = [ms + start_time, ms + end_time, block]
+        @_timers << @_last_timer
+        self
+      end
+      
+      def then(&block)
+        # ...use one-shots start_time for our trailing "then".
+        # ...use durable timers end_time for our trailing "then".
+        start_time = @_last_timer[1].nil? ? @_last_timer[0] : @_last_timer[1]
+        @_timers << [start_time, nil, block]
+      end
+      
+      def update_trait
+        ms = milliseconds()
+        @_timers.each do |start_time, end_time, block|
+          if ms > start_time && (end_time == nil || ms < end_time)
+            block.call
+          end
+        end
+
+        # Remove one-shot timers (only a start_time, no end_time) and all timers which have expired
+        @_timers.reject! { |start_time, end_time, block| (ms > start_time && end_time == nil) || (end_time != nil && ms > end_time) }
+        
+        super
+      end
+      
+    end
+  end
+end

data/lib/chingu/traits/velocity.rb

@@ -0,0 +1,67 @@
+#--
+#
+# Chingu -- Game framework built on top of the opengl accelerated gamelib Gosu
+# Copyright (C) 2009 ippa / ippa@rubylicio.us
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+#++
+
+
+module Chingu
+  module Traits
+    #
+    # A chingu trait providing velocity and acceleration logic. 
+    #
+    module Velocity
+      attr_accessor :velocity_x, :velocity_y, :acceleration_x, :acceleration_y, :max_velocity
+      
+      #def self.initialize_trait(options)
+      #  @velocity_options = {:debug => false}.merge(options)
+      #  puts "Velocity#initialize"    if @velocity_options[:debug]
+      #  super
+      #end
+            
+      def setup_trait(options)
+        @velocity_options = {:debug => false}.merge(options)        
+        puts "Velocity#setup"   if @velocity_options[:debug]
+        
+        @velocity_x = options[:velocity_x] || 0
+        @velocity_y = options[:velocity_y] || 0
+        @acceleration_x = options[:acceleration_x] || 0
+        @acceleration_y = options[:acceleration_y] || 0
+        @max_velocity = options[:max_velocity] || 1000
+        super
+      end
+      
+      #
+      # Modifies X & Y of parent
+      #
+      def update_trait
+        puts "Velocity#update"    if @velocity_options[:debug]
+        
+        @velocity_y += @acceleration_y		if	(@velocity_y + @acceleration_y).abs < @max_velocity
+        @velocity_x += @acceleration_x		if	(@velocity_x + @acceleration_x).abs < @max_velocity
+        @y += @velocity_y
+        @x += @velocity_x
+        super
+      end
+      
+      def stop
+        @acceleration_y = @acceleration_x = @velocity_y = @acceleration_y = 0
+      end      
+    end
+  end
+end

data/lib/chingu/window.rb

@@ -0,0 +1,170 @@
+module Chingu
+
+  class Window < Gosu::Window
+    # adds push_game_state, pop_game_state, current_game_state and previous_game_state
+    include Chingu::GameStateHelpers    
+    
+    # adds fill() etc...
+    include Chingu::GFXHelpers
+    
+    # adds game_objects_of_class etc ...
+    include Chingu::GameObjectHelpers
+    
+    # Input dispatch helpers
+    include Chingu::InputDispatcher
+    
+    # input= and input
+    include Chingu::InputClient
+    
+    attr_reader :root, :game_state_manager, :game_objects, :milliseconds_since_last_tick
+    
+    #
+    # See http://www.libgosu.org/rdoc/classes/Gosu/Window.html
+    #
+    # On top of that we add:
+    # - Default widht / height, --fullscreen option from console
+    # - Global variable $window
+    # - Standard #update which updates all Chingu::GameObject's 
+    # - Standard #draw which goes through 
+    # - Assethandling with Image["picture.png"] and Sample["shot.wav"]
+    # - Default input mapping escape to close 
+    #
+    def initialize(width = 800, height = 600, fullscreen = false, update_interval = 16.666666)
+      fullscreen ||= ARGV.include?("--fullscreen")
+      $window = super(width, height, fullscreen, update_interval)
+			
+      @root = File.dirname(File.expand_path($0))
+      Gosu::Image.autoload_dirs = [".", File.join(@root, "gfx"), File.join(@root, "media")]
+      Gosu::Sample.autoload_dirs = [".", File.join(@root, "sound"), File.join(@root, "media")]
+      Gosu::Tile.autoload_dirs = [".", File.join(@root, "gfx"), File.join(@root, "media")]
+      Gosu::Song.autoload_dirs = [".", File.join(@root, "sfx"), File.join(@root, "media")]
+			
+      @game_objects = GameObjectList.new
+      @input_clients = Set.new  # Set is like a unique Array with Hash lookupspeed
+      
+      @fps_counter = FPSCounter.new
+      @game_state_manager = GameStateManager.new
+      @milliseconds_since_last_tick = 0
+    end
+    
+    def current_parent
+      game_state_manager.current_game_state || self
+    end
+    
+    #
+    # Frames per second, access with $window.fps or $window.framerate
+    #
+    def fps
+      @fps_counter.fps
+    end
+    alias :framerate :fps
+
+    #
+    # Total amount of game iterations (ticks)
+    #
+    def ticks
+      @fps_counter.ticks
+    end
+    
+    #
+    # Mathematical short name for "milliseconds since last tick"
+    #
+    def dt
+      @milliseconds_since_last_tick
+    end
+
+    #
+    # Chingus core-logic / loop. Gosu will call this each game-iteration.
+    #
+    def update
+      #
+      # Register a tick with our rather standard tick/framerate counter. 
+      # Returns the amount of milliseconds since last tick. This number is used in all update()-calls.
+      # Without this self.fps would return an incorrect value.
+      # If you override this in your Chingu::Window class, make sure to call super.
+      #
+      @milliseconds_since_last_tick = @fps_counter.register_tick      
+      
+      intermediate_update
+    end
+    
+    #
+    # "game logic" update that is safe to call even between Gosus update-calls
+    #
+    def intermediate_update
+      #
+      # Dispatch inputmap for main window
+      #
+      dispatch_input_for(self)
+      
+      #
+      # Dispatch input for all input-clients handled by to main window (game objects with input created in main win)
+      #
+      @input_clients.each { |game_object| dispatch_input_for(game_object) }
+      
+      
+      #
+      # Call update() on all game objects belonging to the main window.
+      #
+      update_game_objects
+      
+      #
+      # Call update() on all game objects belonging to the current game state.
+      #
+      update_game_state_manager
+    end
+    
+    # 
+    # Chingus main screen manupulation method.
+    # If you override this in your Chingu::Window class, make sure to call super.
+    # Gosu will call this each game-iteration just after #update
+    #
+    def draw
+      #
+      # Draw all game objects associated with the main window.      
+      #
+      @game_objects.draw
+      
+      #
+      # Let the game state manager call draw on the active game state (if any)
+      #
+      @game_state_manager.draw
+    end
+    
+    #
+    # Call update() on all game objects in main game window.
+    #
+    def update_game_objects
+      @game_objects.update
+    end
+    
+    #
+    # Call update() on our game_state_manger
+    # -> call update on active state 
+    # -> call update on all game objects in that state
+    #
+    def update_game_state_manager
+      @game_state_manager.update
+    end
+
+    #
+    # By default button_up sends the keyevent to the GameStateManager
+    # .. Which then is responsible to send it to the right GameState(s)
+    #
+    def button_up(id)
+      dispatch_button_up(id, self)
+      @input_clients.each { |object| dispatch_button_up(id, object) }
+      @game_state_manager.button_up(id)
+    end
+    
+    #
+    # By default button_down sends the keyevent to the GameStateManager
+    # .. Which then is responsible to send it to the right GameState(s)
+    #
+    def button_down(id)
+      dispatch_button_down(id, self)
+      @input_clients.each { |object| dispatch_button_down(id, object) }
+      @game_state_manager.button_down(id)
+    end
+  end
+end