chingu 0.5.5.3

data/lib/chingu/effects.rb

@@ -0,0 +1,36 @@
+#--
+#
+# 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
+#
+#++
+
+
+#
+# Effect-class
+#
+module Chingu
+  class Effect
+    def initialize(options)
+      super({:mode => :additive}.merge(options))
+      @trail = options[:trail] || 10
+    end
+      
+    def update
+    end    
+  end
+end

data/lib/chingu/fpscounter.rb

@@ -0,0 +1,62 @@
+#--
+#
+# 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
+  #
+  # Calculates a fps and a tick-time for use in update-calls
+  # register_tick() must be called every game loop iteration
+  #
+	class FPSCounter
+		attr_reader :fps, :milliseconds_since_last_tick, :ticks
+  
+		def initialize
+			@current_second = Gosu::milliseconds / 1000
+			@accum_fps = 0
+			@fps = 0
+      @ticks = 0
+      
+      @milliseconds_since_last_tick = 0
+			@last_value = Gosu::milliseconds
+		end
+  
+    #
+    # This should be called once every game-iteration, preferable in update()
+    #
+		def register_tick
+			@accum_fps += 1
+      @ticks += 1
+			current_second = Gosu::milliseconds / 1000
+			if current_second != @current_second
+				@current_second = current_second
+				@fps = @accum_fps
+				@accum_fps = 0
+			end
+
+      #
+      # Calculate how many milliseconds passed since last game loop iteration.
+      #
+			@milliseconds_since_last_tick = Gosu::milliseconds - @last_value
+			@last_value = Gosu::milliseconds
+			return @milliseconds_since_last_tick
+		end
+	end
+end

data/lib/chingu/game_object.rb

@@ -0,0 +1,127 @@
+#--
+#
+# 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
+  #
+  # GameObject is our BasisGameObject (class with framespecific stuff)
+  #
+  # On top of that, it encapsulates GOSUs Image#draw_rot and all its parameters.
+  #
+  class GameObject < Chingu::BasicGameObject
+    attr_accessor :image, :x, :y, :angle, :center_x, :center_y, :factor_x, :factor_y, :color, :mode, :zorder
+    attr_reader :paused, :visible, :factor, :center
+    has_trait :input, :rotation_center
+        
+    def initialize(options = {})
+      super
+
+      # All encapsulated 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 = Image[options[:image]]
+      end
+      
+      @x = options[:x] || 0
+      @y = options[:y] || 0
+      @angle = options[:angle] || 0
+      
+      self.center = options[:center] || 0.5
+      self.factor = options[:factor] || 1.0
+      @center_x = options[:center_x] if options[:center_x]
+      @center_y = options[:center_y] if options[:center_y]
+      @factor_x = options[:factor_x] if options[:factor_x]
+      @factor_y = options[:factor_y] if options[:factor_y]
+
+      if options[:color].is_a?(Gosu::Color)
+        @color = options[:color]
+      else
+        @color = Gosu::Color.new(options[:color] || 0xFFFFFFFF)
+      end      
+      
+      @mode = options[:mode] || :default # :additive is also available.
+      @zorder = options[:zorder] || 100
+                        
+      # gameloop/framework logic (TODO: use or get rid of)
+      @paused = options[:paused] || false
+      @visible = options[:visible] || true
+      
+      setup_trait(options)  if respond_to?(:setup_trait)
+    end
+    
+    #
+    # Disable auto-updating of traits 
+    #
+    def pause!
+      @paused = true
+    end
+    #
+    # Enable auto-update of traits
+    #
+    def unpause!
+      @paused = false
+    end
+    #
+    # Disable auto-drawing of object
+    #
+    def hide!
+      @visible = false
+    end
+    #
+    # Enable auto-drawing of object
+    #
+    def show!
+      @visible = true
+    end
+    
+    # Quick way of setting both factor_x and factor_y
+    def factor=(factor)
+      @factor = factor
+      @factor_x = @factor_y = factor
+    end
+          
+    # Quick way of setting both center_x and center_y
+    def center=(center)
+      @center = center
+      @center_x = @center_y = center
+    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
+    
+    # Calculates the distance from self to a given objevt
+    def distance_to(object)
+      distance(self.x, self.y, object.x, object.y)
+    end
+    
+    def draw
+      @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

@@ -0,0 +1,91 @@
+#--
+#
+# 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
+  #
+  # Manages a list of game objects
+  # An instance of GameObjectList is automaticly created as "game_objects" if using Chingu::Window
+  #
+  class GameObjectList
+        
+    def initialize
+      @game_objects = Array.new
+      #@game_objects_by_class = Hash.new
+    end
+    
+    def to_s
+      "#{@game_objects.size} game objects."
+    end
+    
+    def of_class(klass)
+      @game_objects.select { |game_object| game_object.is_a? klass }
+      #@game_objects_by_class[klass] || []
+    end
+    
+    def remove_all
+      @game_objects.clear
+      #@game_objects_of_class.clear
+    end
+    alias :clear :remove_all
+    
+    def add_game_object(object)
+      @game_objects.push(object)
+      #(@game_objects_by_class[object.class] ||= []).push(object)
+    end
+    
+    def remove_game_object(object)
+      @game_objects.delete(object)
+      #@game_objects_by_class[object.class].delete(object)
+    end
+    
+    def destroy_if
+      @game_objects.reject! { |object| yield(object) }
+      #@game_objects_by_class.delete_if { |klass, object| yield(object) }
+    end
+    
+    def size
+      @game_objects.size
+    end
+    
+    def draw
+      @game_objects.each{ |object| object.visible }.each do |object| 
+        object.draw_trait
+        object.draw
+      end
+    end
+    
+    def update
+      @game_objects.select{ |object| not object.paused }.each do |object| 
+        object.update_trait 
+        object.update
+      end
+    end
+    
+    def each
+      @game_objects.each { |object| yield object }
+    end
+    
+    def select
+      @game_objects.select { |object| yield object }
+    end
+  end  
+end

data/lib/chingu/game_state.rb

@@ -0,0 +1,137 @@
+#--
+#
+# 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
+  #
+  # Chingu incorporates a basic push/pop game state system (as discussed here: http://www.gamedev.net/community/forums/topic.asp?topic_id=477320).
+  # Game states is a way of organizing your intros, menus, levels.
+  # Game states aren't complicated. In Chingu a GameState is a class that behaves mostly like your default Gosu::Window (or in our case Chingu::Window) game loop.
+  #
+  # # A simple GameState-example
+  # class Intro < Chingu::GameState
+  #   def update
+  #     # game logic here
+  #   end
+  #
+  #   def draw
+  #     # screen manipulation here
+  #   end
+  #        
+  #   # Called when we enter the game state
+  #   def setup
+  #     @player.angle = 0   # point player upwards
+  #   end
+  #    
+  #   # Called when we leave the current game state
+  #   def finalize
+  #     push_game_state(Menu)   # switch to game state "Menu"
+  #   end
+  # end
+  #
+
+  class GameState
+    include Chingu::GameStateHelpers    # Easy access to the global game state-queue
+    include Chingu::GFXHelpers          # Adds fill(), fade() etc to each game state
+    include Chingu::GameObjectHelpers   # adds game_objects_of_class etc ...
+    include Chingu::InputDispatcher     # dispatch-helpers
+    include Chingu::InputClient
+    
+    attr_reader :options                # so jlnr can access his :level-number
+    attr_accessor :game_state_manager, :game_objects
+    
+    def initialize(options = {})
+      @options = options
+      ## @game_state_manager = options[:game_state_manager] || $window.game_state_manager
+      @game_objects = GameObjectList.new
+      @input_clients = Set.new          # Set is like a unique Array with Hash lookupspeed
+      
+      # Game state mamanger can be run alone
+      if defined?($window) && $window.respond_to?(:game_state_manager)
+        $window.game_state_manager.inside_state = self
+      end
+    end
+        
+    #
+    # An unique identifier for the GameState-class, 
+    # Used in game state manager to keep track of created states.
+    #
+    def to_sym
+      self.class.to_s.to_sym
+    end
+
+    def to_s
+      self.class.to_s
+    end
+    
+    def setup
+      # Your game state setup logic here.
+    end
+    
+    #
+    # Called when a button is pressed and a game state is active
+    #
+    def button_down(id)
+      dispatch_button_down(id, self)
+      @input_clients.each { |object| dispatch_button_down(id, object) } if @input_clients
+    end
+    
+    #
+    # Called when a button is released and a game state active
+    #
+    def button_up(id)
+      dispatch_button_up(id, self)
+      @input_clients.each { |object| dispatch_button_up(id, object) }   if @input_clients
+    end
+    
+    #
+    # Calls update on each game object that has current game state as parent (created inside that game state)
+    #
+    def update
+      dispatch_input_for(self)
+      
+      @input_clients.each { |game_object| dispatch_input_for(game_object) }      
+      
+      @game_objects.update
+    end
+    
+    #
+    # Calls Draw on each game object that has current game state as parent (created inside that game state)
+    #
+    def draw
+      @game_objects.draw
+    end
+        
+    #
+    # Closes game state by poping it off the stack (and activating the game state below)
+    #
+    def close
+      pop_game_state
+    end
+    
+    #
+    # Closes main window and terminates the application
+    #
+    def close_game
+      $window.close
+    end
+  end
+end