chingu 0.9rc3 → 0.9rc4

data/chingu.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{chingu}
-  s.version = "0.9rc3"
+  s.version = "0.9rc4"
 
   s.required_rubygems_version = Gem::Requirement.new("> 1.3.1") if s.respond_to? :required_rubygems_version=
   s.authors = ["ippa"]
-  s.date = %q{2011-02-26}
+  s.date = %q{2011-03-07}
   s.description = %q{OpenGL accelerated 2D game framework for Ruby. Builds on Gosu (Ruby/C++) which provides all the core functionality. Chingu adds simple yet powerful game states, prettier input handling, deployment safe asset-handling, a basic re-usable game object and stackable game logic.}
   s.email = %q{ippa@rubylicio.us}
   s.extra_rdoc_files = [
@@ -151,6 +151,7 @@ Gem::Specification.new do |s|
     "lib/chingu/game_states/popup.rb",
     "lib/chingu/gosu_ext/image.rb",
     "lib/chingu/helpers/class_inheritable_accessor.rb",
+    "lib/chingu/helpers/fps_counter.rb",
     "lib/chingu/helpers/game_object.rb",
     "lib/chingu/helpers/game_state.rb",
     "lib/chingu/helpers/gfx.rb",

data/examples/example7_gfx_helpers.rb

@@ -19,6 +19,7 @@ class Game < Chingu::Window
     push_game_state(FillGradient)
     push_game_state(FillGradientRect)
     push_game_state(FillGradientMultipleColors)
+    push_game_state(DrawCircle)
     push_game_state(Particles)
   end
   
@@ -27,6 +28,20 @@ class Game < Chingu::Window
   end
 end
 
+class DrawCircle < Chingu::GameState
+  def draw
+    $window.caption = "circles and arcs (space to continue)"
+    draw_circle(0, 0, 300, Color::RED)
+    fill_circle($window.width, $window.height, 200, Color::RED)
+    
+    colors = [Color::RED, Color::YELLOW, Color::GREEN, Color::BLUE]
+    0.step(360, 90).each_cons(2).zip(colors).each do |(a1, a2), color|
+      fill_arc(400, 100, 100, a1, a2, color)
+    end
+    
+  end
+end
+
 class Fill < Chingu::GameState 
   def draw
     $window.caption = "fill (space to continue)"

data/lib/chingu.rb

@@ -38,7 +38,7 @@ require_all "#{CHINGU_ROOT}/chingu/async_tasks"
 require_all "#{CHINGU_ROOT}/chingu"
 
 module Chingu
-  VERSION = "0.9rc3"
+  VERSION = "0.9rc4"
   
   DEBUG_COLOR = Gosu::Color.new(0xFFFF0000)
   DEBUG_ZORDER = 9999

data/lib/chingu/classic_game_object.rb

@@ -19,7 +19,7 @@
 #
 #++
 
-require_rel 'helpers/*'
+require_rel 'helpers'
 module Chingu
   #
   # GameObject inherits from BasicGameObject to get traits and some class-methods like .all and .destroy

data/lib/chingu/console.rb

@@ -25,6 +25,7 @@ module Chingu
   #
   #
   class Console
+    include Chingu::Helpers::FPSCounter         # Adds FPSCounter delegators
     include Chingu::Helpers::GameState          # Easy access to the global game state-queue
     include Chingu::Helpers::GameObject         # Adds game_objects_of_class etc ...
     
@@ -73,28 +74,6 @@ module Chingu
       game_state_manager.inside_state || 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.
     #

data/lib/chingu/fpscounter.rb

@@ -26,7 +26,19 @@ module Chingu
   # register_tick() must be called every game loop iteration
   #
 	class FPSCounter
-		attr_reader :fps, :milliseconds_since_last_tick, :ticks
+    attr_reader :milliseconds_since_last_tick
+    alias :dt :milliseconds_since_last_tick
+    
+    #
+    # Frames per second, access with $window.fps or $window.framerate
+    #
+    attr_reader :fps
+    alias :framerate :fps
+    
+    #
+    # Total amount of game iterations (ticks)
+    #
+    attr_reader :ticks
   
 		def initialize
 			@current_second = Gosu::milliseconds / 1000

data/lib/chingu/game_object.rb

@@ -19,7 +19,7 @@
 #
 #++
 
-require_rel 'helpers/*'
+require_rel 'helpers'
 module Chingu
   #
   # GameObject inherits from BasicGameObject to get traits and some class-methods like .all and .destroy

data/lib/chingu/game_object_list.rb

@@ -19,6 +19,7 @@
 #
 #++
 
+require 'forwardable'
 
 module Chingu
   #
@@ -26,18 +27,21 @@ module Chingu
   # An instance of GameObjectList is automaticly created as "game_objects" if using Chingu::Window
   #
   class GameObjectList
+    extend Forwardable
+    
     attr_reader :visible_game_objects, :unpaused_game_objects
         
     def initialize(options = {})
       @game_objects = options[:game_objects] || []
       @visible_game_objects = []
       @unpaused_game_objects = []
-      
-      #@game_objects = {}
-      #@visible_game_objects = {}
-      #@unpaused_game_objects = {}
     end
     
+    def_delegator :@game_objects, :size
+    def_delegator :@game_objects, :empty?
+    def_delegator :@game_objects, :first
+    def_delegator :@game_objects, :last
+    
     def to_s
       "#{@game_objects.size} game objects."
     end
@@ -69,10 +73,6 @@ module Chingu
       @game_objects.push(object)
       @visible_game_objects.push(object)  if object.respond_to?(:visible)  && object.visible
       @unpaused_game_objects.push(object) if object.respond_to?(:paused)   && !object.paused
-      
-      #@game_objects[object] = true
-      #@visible_game_objects[object] = true  if object.respond_to?(:visible)  && object.visible
-      #@unpaused_game_objects[object] = true if object.respond_to?(:paused)   && !object.paused
     end
     
     def remove_game_object(object)
@@ -85,14 +85,6 @@ module Chingu
       @game_objects.select { |object| object.destroy if yield(object) }
     end
     
-    def size
-      @game_objects.size
-    end
-    
-    def empty?
-      @game_objects.empty?
-    end
-
     def update
       @unpaused_game_objects.each { |go| go.update_trait; go.update; }
     end
@@ -131,14 +123,6 @@ module Chingu
       @game_objects.map { |object| yield object }
     end
 
-    def first
-      @game_objects.first
-    end
-
-    def last
-      @game_objects.last
-    end
-
     #
     # Disable automatic calling of update() and update_trait() each game loop for all game objects
     #

data/lib/chingu/game_state_manager.rb

@@ -236,8 +236,15 @@ module Chingu
     # Pops through all game states until matching a given game state
     #
     def pop_until_game_state(new_state)
-      while (state = @game_states.pop)
-        break if state == new_state
+      if new_state.is_a? Class
+        raise ArgumentError, "No state of given class is on the stack" unless @game_states.map {|s| s.class }.include? new_state
+
+        @game_states.pop until current_game_state.is_a? new_state
+
+      else
+        raise ArgumentError, "State is not on the stack" unless @game_states.include? new_state
+
+        @game_states.pop while current_game_state != new_state
       end
     end
         

data/lib/chingu/game_states/network_client.rb

@@ -71,18 +71,20 @@ module Chingu
     #
     class NetworkClient < Chingu::GameState
       attr_reader :latency, :socket, :packet_counter, :packet_buffer, :ip, :port
+      alias_method :address, :ip
       
       def initialize(options = {})
         super
         @timeout = options[:timeout] || 4        
         @debug = options[:debug]
         @ip = options[:ip] || "0.0.0.0"
-        @port = options[:port] || 7778
+        @port = options[:port] || NetworkServer::DEFAULT_PORT
+        @max_read_per_update = options[:max_read_per_update] || 50000
         
         @socket = nil
         @latency = 0
         @packet_counter = 0
-        @packet_buffer = ""
+        @packet_buffer = NetworkServer::PacketBuffer.new
       end
       
       #
@@ -110,7 +112,6 @@ module Chingu
         begin
           status = Timeout::timeout(@timeout) do
             @socket = TCPSocket.new(@ip, @port)
-            @socket.setsockopt(Socket::IPPROTO_TCP,Socket::TCP_NODELAY,1)
             on_connect
           end
         rescue Errno::ECONNREFUSED
@@ -154,14 +155,14 @@ module Chingu
       # Call this from your update() to read from socket.
       # handle_incoming_data will call on_data(raw_data) when stuff comes on on the socket.
       #
-      def handle_incoming_data(amount = 1000)
+      def handle_incoming_data(amount = @max_read_per_update)
         return unless @socket
         
         if IO.select([@socket], nil, nil, 0.0)
           begin
             packet, sender = @socket.recvfrom(amount)
             on_data(packet)        
-          rescue Errno::ECONNABORTED
+          rescue Errno::ECONNABORTED, Errno::ECONNRESET
             on_disconnect
           end
         end
@@ -171,17 +172,10 @@ module Chingu
       # on_data(data) will be called from handle_incoming_data() by default.
       #
       def on_data(data)
-        begin
-          msgs = data.split("--- ")          
-          if msgs.size > 1
-            @packet_buffer << msgs[0...-1].join("--- ")
-            YAML::load_documents(@packet_buffer) { |msg| on_msg(msg)  if msg }
-            @packet_buffer = msgs.last
-          else
-            @packet_buffer << msgs.join
-          end
-        rescue ArgumentError
-          puts "Bad YAML recieved:\n#{data}"
+        @packet_buffer.buffer_data data
+
+        while packet = @packet_buffer.next_packet
+          on_msg(Marshal.load(packet))
         end
       end
       
@@ -190,16 +184,23 @@ module Chingu
       # Can be whatever ruby-structure that responds to #to_yaml
       #
       def send_msg(msg)
-        # the "---" part is a little hack to make server understand the YAML is fully transmitted.
-        data = msg.to_yaml + "--- \n"
-        send_data(data)
+        send_data(Marshal.dump(msg))
       end
 
       #
       # Send whatever raw data to the server
       #
       def send_data(data)
-        @socket.write(data)
+        begin
+          @socket.write([data.length].pack(NetworkServer::PACKET_HEADER_FORMAT))
+          @socket.write(data)
+        rescue Errno::ECONNABORTED, Errno::ECONNRESET, Errno::EPIPE, Errno::ENOTCONN
+          on_disconnect
+        end
+      end
+
+      # Ensure that the buffer is cleared of data to write (call at the end of update or, at least after all sends).
+      def flush
         @socket.flush
       end
 

data/lib/chingu/game_states/network_server.rb

@@ -69,20 +69,62 @@ module Chingu
     # A good idea is to have a socket-ivar in your Player-model and a Player.find_by_socket(socket)
     #
     class NetworkServer < Chingu::GameState
-      attr_reader :socket, :sockets, :packet_counter, :packet_counter, :ip, :port
+      PACKET_HEADER_LENGTH = 4
+      PACKET_HEADER_FORMAT = "N"
+      DEFAULT_PORT = 7778
+
+      class PacketBuffer
+        def initialize
+          @data = '' # Buffered data.
+          @length = nil # Length of the next packet. nil if header not read yet.
+        end
+
+        # Add data string to the buffer.
+        def buffer_data(data)
+          @data << data
+        end
+
+        # Call after adding data with #buffer_data until there are no more packets left.
+        def next_packet
+          # Read the header to find out the length of the next packet.
+          unless @length
+            if @data.length >= PACKET_HEADER_LENGTH
+              @length = @data[0...PACKET_HEADER_LENGTH].unpack(PACKET_HEADER_FORMAT)[0]
+              @data[0...PACKET_HEADER_LENGTH] = ''
+            end
+          end
+
+          # If there is enough data after the header for the full packet, return it.
+          if @length and @length <= @data.length
+            begin
+              packet =  @data[0...@length]
+              @data[0...@length] = ''
+              @length = nil
+              return packet
+            rescue TypeError => ex
+              puts "Bad data received:\n#{@data.inspect}"
+              raise ex
+            end
+          else
+            return nil
+          end
+        end
+      end
+
+      attr_reader :socket, :sockets, :ip, :port
+
+      alias_method :address, :ip
       
       def initialize(options = {})
         super
         
         @ip = options[:ip] || "0.0.0.0"
-        @port = options[:port] || 7778
+        @port = options[:port] || DEFAULT_PORT
         @debug = options[:debug]
         @socket = nil
         @sockets = []
-        @buffered_output = YAML::Stream.new
         @max_read_per_update = options[:max_read_per_update] || 20000
-        
-        @packet_counter = 0
+
         @packet_buffers = Hash.new
       end
       
@@ -94,7 +136,6 @@ module Chingu
         @port = port  if port
         begin
           @socket = TCPServer.new(@ip, @port)
-          @socket.setsockopt(Socket::IPPROTO_TCP,Socket::TCP_NODELAY,1)
           on_start
         rescue
           on_start_error($!)
@@ -134,11 +175,9 @@ module Chingu
         if @socket && !@socket.closed?
           handle_incoming_connections
           handle_incoming_data
-          super
-          handle_outgoing_data
-        else
-          super
         end
+
+        super
       end
       
       #
@@ -157,10 +196,11 @@ module Chingu
 
       def handle_incoming_connections
         begin
-          socket = @socket.accept_nonblock
-          @sockets << socket
-          on_connect(socket)
-          @packet_buffers[socket] = ""
+          while socket = @socket.accept_nonblock
+            @sockets << socket
+            @packet_buffers[socket] = PacketBuffer.new
+            on_connect(socket)
+          end
         rescue IO::WaitReadable, Errno::EINTR
         end
       end
@@ -177,6 +217,7 @@ module Chingu
               on_data(socket, packet)
             rescue Errno::ECONNABORTED, Errno::ECONNRESET
               @packet_buffers[socket] = nil
+
               on_disconnect(socket)
             end
           end
@@ -187,28 +228,12 @@ module Chingu
       # on_data(data) will be called from handle_incoming_data() by default.
       #
       def on_data(socket, data)
-        begin
-          msgs = data.split("--- ")          
-          if msgs.size > 1
-            @packet_buffers[socket] << msgs[0...-1].join("--- ")
-            YAML::load_documents(@packet_buffers[socket]) { |msg| on_msg(socket, msg) if msg}
-            @packet_buffers[socket] = msgs.last
-          else
-            @packet_buffers[socket] << msgs.join
-          end
-        end
-      end
-      
-      #
-      # Send all buffered outgoing data
-      #
-      def handle_outgoing_data
-        # the "---" part is a little hack to make server understand the YAML is fully transmitted.
-        
-        data = @buffered_output.emit
-        if data.size > 0
-          @sockets.each { |socket| send_data(socket, data + "--- \n") }
-          @buffered_output = YAML::Stream.new
+        buffer = @packet_buffers[socket]
+
+        buffer.buffer_data data
+
+        while packet = buffer.next_packet
+          on_msg(socket, Marshal.load(packet))
         end
       end
       
@@ -217,7 +242,8 @@ module Chingu
       # Output is buffered and dispatched once each server-loop
       #
       def broadcast_msg(msg)
-        @buffered_output.add(msg)
+        data = Marshal.dump(msg)
+        @sockets.each {|s| send_data(s, data) }
       end
       
       #
@@ -225,8 +251,7 @@ module Chingu
       # 'msg' must responds to #to_yaml
       #
       def send_msg(socket, msg)
-        # the "---" part is a little hack to make server understand the YAML is fully transmitted.
-        send_data(socket, msg.to_yaml + "--- \n")
+        send_data(socket, Marshal.dump(msg))
       end
       
       #
@@ -234,8 +259,8 @@ module Chingu
       #
       def send_data(socket, data)
         begin
+          socket.write([data.length].pack(PACKET_HEADER_FORMAT))
           socket.write(data)
-          socket.flush
         rescue Errno::ECONNABORTED, Errno::ECONNRESET, Errno::EPIPE, Errno::ENOTCONN
           on_disconnect(socket)
         end        
@@ -247,6 +272,11 @@ module Chingu
       def disconnect_client(socket)
         socket.close
       end
+
+      # Ensure that the buffer is cleared of data to write (call at the end of update or, at least after all sends).
+      def flush
+        @sockets.each {|s| s.flush }
+      end
       
       #
       # Stops server

data/lib/chingu/helpers/fps_counter.rb

@@ -0,0 +1,39 @@
+#--
+#
+# Chingu -- OpenGL accelerated 2D game framework for Ruby
+# 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
+#
+#++
+
+require 'forwardable'
+
+module Chingu
+  module Helpers
+  
+    #
+    # Convenience-methods for classes that have an FPS counter
+    # Mixed into Chingu::Window and Chingu::Console
+    #
+    module FPSCounter
+      extend Forwardable
+      def_delegator  :@fps_counter, :ticks
+      def_delegators :@fps_counter, :fps, :framerate # TODO: switch to Gosu::fps
+      def_delegators :@fps_counter, :dt, :milliseconds_since_last_tick
+    end
+  
+  end
+end

data/lib/chingu/helpers/game_object.rb

@@ -1,135 +1,121 @@
-#--
-#
-# Chingu -- OpenGL accelerated 2D game framework for Ruby
-# 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 Helpers
-  
-  #
-  # Convenience-methods for classes that hold game objects
-  # Mixed into Chingu::Window and Chingu::GameState
-  #
-  module GameObject
-  
-    def add_game_object(object)
-      @game_objects.add_game_object(object)
-    end
-    
-    def remove_game_object(object)
-      @game_objects.remove_game_object(object)
-    end
-    
-    def game_objects
-      @game_objects
-    end
-    
-    def show_game_object(object)
-      @game_objects.show_game_object(object)
-    end    
-    def hide_game_object(object)
-      @game_objects.hide_game_object(object)
-    end
-    def pause_game_object(object)
-      @game_objects.pause_game_object(object)
-    end
-    def unpause_game_object(object)
-      @game_objects.unpause_game_object(object)
-    end 
-    
-    
-    #
-    # Fetch game objects of a certain type/class
-    #
-    def game_objects_of_class(klass)
-      @game_objects.select { |game_object| game_object.is_a? klass }
-    end
-    
-    #
-    # Creates game objects from a Chingu-spezed game objects file (created with game state 'Edit')
-    #
-    def load_game_objects(options = {})
-      file = options[:file] || self.filename + ".yml"
-      debug = options[:debug]
-      except = Array(options[:except]) || []
-      
-      require 'yaml'
-      
-      puts "* Loading game objects from #{file}" if debug
-      if File.exists?(file)
-        objects = YAML.load_file(file)
-        objects.each do |object|
-          object.each_pair do |klassname, attributes|
-            begin
-              klass = Kernel::const_get(klassname)
-              unless klass.class == "GameObject" && !except.include?(klass)
-                puts "Creating #{klassname.to_s}: #{attributes.to_s}" if debug
-                object = klass.create(attributes)
-                object.options[:created_with_editor] = true if object.options
-              end
-            rescue
-              puts "Couldn't create class '#{klassname}'"
-            end
-          end
-        end
-      end
-    end
-    
-    #
-    # Save given game_objects to a file. Hashoptions
-    # 
-    # :file - a String, name of file to write to, default is current game_state class name.
-    # :game_objects - an Array, game objects to save
-    # :classes      - an Array, save only game objects of theese classes
-    #
-    # NOTE: To save a color do:  :color => game_object.color.argb
-    #
-    def save_game_objects(options = {})
-      #
-      # TODO: Move this to GameObjectList#save ?
-      #
-      file = options[:file] || "#{self.class.to_s.downcase}.yml"
-      game_objects = options[:game_objects]
-      classes = options[:classes]
-      attributes = options[:attributes] || [:x, :y, :angle, :zorder, :factor_x, :factor_y, :alpha]
-      
-      require 'yaml'
-      objects = []
-      game_objects.each do |game_object|
-        # Only save specified classes, if given.
-        next if classes and !classes.empty? and !classes.include?(game_object.class)
-        
-        attr_hash = {}
-        attributes.each do |attr| 
-          begin
-          attr_hash[attr] = game_object.send(attr)
-          rescue NoMethodError
-            # silently ignore attributes that doesn't exist on the particular game object
-          end
-        end
-        objects << {game_object.class.to_s => attr_hash}
-      end
-
-      File.open(file, 'w') { |out| YAML.dump(objects, out) }
-    end
-    
-  end
-
-  end
+#--
+#
+# Chingu -- OpenGL accelerated 2D game framework for Ruby
+# 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
+#
+#++
+
+require 'forwardable'
+
+module Chingu
+  module Helpers
+  
+  #
+  # Convenience-methods for classes that hold game objects
+  # Mixed into Chingu::Window and Chingu::GameState
+  #
+  module GameObject
+    extend Forwardable
+    
+    attr_reader :game_objects
+    
+    def_delegator :@game_objects, :add_game_object
+    def_delegator :@game_objects, :remove_game_object
+    def_delegator :@game_objects, :show_game_object
+    def_delegator :@game_objects, :hide_game_object
+    def_delegator :@game_objects, :pause_game_object
+    def_delegator :@game_objects, :unpause_game_object
+    
+    #
+    # Fetch game objects of a certain type/class
+    #
+    def game_objects_of_class(klass)
+      @game_objects.select { |game_object| game_object.is_a? klass }
+    end
+    
+    #
+    # Creates game objects from a Chingu-spezed game objects file (created with game state 'Edit')
+    #
+    def load_game_objects(options = {})
+      file = options[:file] || self.filename + ".yml"
+      debug = options[:debug]
+      except = Array(options[:except]) || []
+      
+      require 'yaml'
+      
+      puts "* Loading game objects from #{file}" if debug
+      if File.exists?(file)
+        objects = YAML.load_file(file)
+        objects.each do |object|
+          object.each_pair do |klassname, attributes|
+            begin
+              klass = Kernel::const_get(klassname)
+              unless klass.class == "GameObject" && !except.include?(klass)
+                puts "Creating #{klassname.to_s}: #{attributes.to_s}" if debug
+                object = klass.create(attributes)
+                object.options[:created_with_editor] = true if object.options
+              end
+            rescue
+              puts "Couldn't create class '#{klassname}'"
+            end
+          end
+        end
+      end
+    end
+    
+    #
+    # Save given game_objects to a file. Hashoptions
+    # 
+    # :file - a String, name of file to write to, default is current game_state class name.
+    # :game_objects - an Array, game objects to save
+    # :classes      - an Array, save only game objects of theese classes
+    #
+    # NOTE: To save a color do:  :color => game_object.color.argb
+    #
+    def save_game_objects(options = {})
+      #
+      # TODO: Move this to GameObjectList#save ?
+      #
+      file = options[:file] || "#{self.class.to_s.downcase}.yml"
+      game_objects = options[:game_objects]
+      classes = options[:classes]
+      attributes = options[:attributes] || [:x, :y, :angle, :zorder, :factor_x, :factor_y, :alpha]
+      
+      require 'yaml'
+      objects = []
+      game_objects.each do |game_object|
+        # Only save specified classes, if given.
+        next if classes and !classes.empty? and !classes.include?(game_object.class)
+        
+        attr_hash = {}
+        attributes.each do |attr| 
+          begin
+          attr_hash[attr] = game_object.send(attr)
+          rescue NoMethodError
+            # silently ignore attributes that doesn't exist on the particular game object
+          end
+        end
+        objects << {game_object.class.to_s => attr_hash}
+      end
+
+      File.open(file, 'w') { |out| YAML.dump(objects, out) }
+    end
+    
+  end
+
+  end
 end

data/lib/chingu/helpers/game_state.rb

@@ -19,6 +19,7 @@
 #
 #++
 
+require 'forwardable'
 
 module Chingu
   module Helpers
@@ -29,33 +30,14 @@ module Chingu
   # It will make call new() on a class, and just push an object.
   #
   module GameState
-    def game_states
-      game_state_manager.game_states
-    end
-    
-    def push_game_state(state, options = {})
-      game_state_manager.push_game_state(state, options)
-    end
-  
-    def pop_game_state(options = {})
-      game_state_manager.pop_game_state(options)
-    end
-
-    def switch_game_state(state, options = {})
-      game_state_manager.switch_game_state(state, options)
-    end
-
-    def transitional_game_state(state, options = {})
-      game_state_manager.transitional_game_state(state, options)
-    end
-
-    def current_game_state
-      game_state_manager.current_game_state
-    end
-    
-    def clear_game_states
-      game_state_manager.clear_game_states
-    end
+    extend Forwardable
+    def_delegator :game_state_manager, :game_states
+    def_delegator :game_state_manager, :push_game_state
+    def_delegator :game_state_manager, :pop_game_state
+    def_delegator :game_state_manager, :switch_game_state
+    def_delegator :game_state_manager, :transitional_game_state
+    def_delegator :game_state_manager, :current_game_state
+    def_delegator :game_state_manager, :clear_game_states
   end
   
   end

data/lib/chingu/helpers/gfx.rb

@@ -27,7 +27,7 @@ module Chingu
   # All drawings depend on the global variable $window which should be an instance of Gosu::Window or Chingu::Window
   #
   module GFX
-  
+    
     #
     # Fills whole window with specified 'color' and 'zorder'
     #
@@ -48,52 +48,33 @@ module Chingu
     #   :orientation  - Either :vertical (top to bottom) or :horizontal (left to right)
     #
     
-    def fill(options, zorder = 0)
+    def fill(material, zorder = 0, mode = :default)
       #
       # if only 1 color-argument is given, assume fullscreen simple color fill.
       #
-      if options.is_a?(Gosu::Color)
-        $window.draw_quad(0, 0, options,
-                        $window.width, 0, options,
-                        $window.width, $window.height, options,
-                        0, $window.height, options, zorder, :default)
+      if material.is_a?(Gosu::Color)
+        rect = Rect.new([0, 0, $window.width, $window.height])
+        _fill_rect(rect, material, material, material, material, zorder, mode)
       else
-        fill_gradient(options)
+        fill_gradient(material)
       end
     end
     
     #
     # Draws an unfilled rect in given color
     #
-    def draw_rect(rect, color, zorder)
-      $window.draw_line(rect.x, rect.y, color, rect.right, rect.y, color, zorder)
-      $window.draw_line(rect.right, rect.y, color, rect.right, rect.bottom, color, zorder)
-      $window.draw_line(rect.right, rect.bottom, color, rect.x, rect.bottom, color, zorder)
-      $window.draw_line(rect.x, rect.bottom, color, rect.x, rect.y, color, zorder)
+    def draw_rect(rect, color, zorder = 0, mode = :default)
+      rect = Rect.new(rect) unless rect.is_a? Rect
+      _stroke_rect(rect, color, color, color, color, zorder, mode)
     end
     
     
-    #
-    # Draws an unfilled circle, thanks shawn24!
-    #
-    CIRCLE_STEP = 10
-    def draw_circle(cx,cy,r,color)      
-      0.step(360, CIRCLE_STEP) do |a1|
-        a2 = a1 + CIRCLE_STEP
-        $window.draw_line cx + Gosu.offset_x(a1, r), cy + Gosu.offset_y(a1, r), color, cx + Gosu.offset_x(a2, r), cy + Gosu.offset_y(a2, r), color, 9999
-      end
-    end
-    
     #
     # Fills a given Rect 'rect' with Color 'color', drawing with zorder 'zorder'
     #
-    def fill_rect(rect, color, zorder = 0)
-      rect = Rect.new(rect)     # Make sure it's a rect
-      $window.draw_quad(  rect.x, rect.y, color,
-                          rect.right, rect.y, color,
-                          rect.right, rect.bottom, color,
-                          rect.x, rect.bottom, color,
-                          zorder, :default)
+    def fill_rect(rect, color, zorder = 0, mode = :default)
+      rect = Rect.new(rect) unless rect.is_a? Rect
+      _fill_rect(rect, color, color, color, color, zorder, mode)
     end
     
     #
@@ -105,46 +86,147 @@ module Chingu
     #   :orientation  - Either :vertical (top to bottom) or :horizontal (left to right)
     #
     def fill_gradient(options)
-      default_options = { :from => Gosu::Color::BLACK,
-                          :to => Gosu::Color::WHITE,
-                          :thickness => 10, 
-                          :orientation => :vertical,
-                          :rect => Rect.new([0, 0, $window.width, $window.height]),
-                          :zorder => 0,
-                          :mode => :default
-                        }
-      options = default_options.merge(options)
+      options = { :from => Gosu::Color::BLACK,
+                  :to => Gosu::Color::WHITE,
+                  :orientation => :vertical,
+                  :rect => [0, 0, $window.width, $window.height],
+                  :zorder => 0,
+                  :mode => :default
+                }.merge!(options)
       
       rect   = Rect.new(options[:rect])
       colors = options[:colors] || options.values_at(:from, :to)
+      zorder = options[:zorder]
+      mode   = options[:mode]
       
       case options[:orientation]
       when :vertical
         rect.height /= colors.count - 1
         colors.each_cons(2) do |from, to|
-          $window.draw_quad(  rect.left,  rect.top,    from,
-                              rect.right, rect.top,    from,
-                              rect.right, rect.bottom, to,
-                              rect.left,  rect.bottom, to,
-                              options[:zorder], options[:mode]
-                            )
+          _fill_rect(rect, from, to, to, from, zorder, mode)
           rect.top += rect.height
         end
       when :horizontal
         rect.width /= colors.count - 1
         colors.each_cons(2) do |from, to|
-          $window.draw_quad(  rect.left,  rect.top,    from,
-                              rect.left,  rect.bottom, from,
-                              rect.right, rect.bottom, to,
-                              rect.right, rect.top,    to,
-                              options[:zorder], options[:mode]
-                            )
+          _fill_rect(rect, from, from, to, to, zorder, mode)
           rect.left += rect.width
         end
       else
         raise ArgumentError, "bad gradient orientation: #{options[:orientation]}"
       end
+      
+    end
+    
+    #
+    # Draws an unfilled circle, thanks shawn24!
+    #
+    def draw_circle(cx, cy, r, color, zorder = 0, mode = :default)
+      draw_arc(cx, cy, r, 0, 360, color, zorder, mode)
+    end
+    
+    #
+    # Draws an unfilled arc from a1 to a2
+    #
+    def draw_arc(cx, cy, r, from, to, color, zorder = 0, mode = :default)
+      from, to = to, from if from > to
+      $window.translate(cx,  cy) do
+        $window.scale(r) do
+          detail = _circle_segments(r)
+          _walk_arc(from, to, detail) do |x1, y1, x2, y2|
+            $window.draw_line(x1, y1, color,
+                              x2, y2, color,
+                              zorder, mode)
+          end
+        end
+      end
+    end
+    
+    #
+    # Draws a filled circle
+    #
+    def fill_circle(cx, cy, r, color, zorder = 0, mode = :default)
+      fill_arc(cx, cy, r, 0, 360, color, zorder, mode)
+    end
+    
+    #
+    # Draws a filled arc from a1 to a2
+    #
+    def fill_arc(cx, cy, r, from, to, color, zorder = 0, mode = :default)
+      from, to = to, from if from > to
+      $window.translate(cx,  cy) do
+        $window.scale(r) do
+          detail = _circle_segments(r)
+          _walk_arc(from, to, detail) do |x1, y1, x2, y2|
+            $window.draw_triangle(0,  0,  color,
+                                  x1, y1, color,
+                                  x2, y2, color,
+                                  zorder, mode)
+          end
+        end
+      end
     end
+    
+    private
+    
+    def _fill_rect(rect, color_a, color_b, color_c, color_d, zorder, mode)
+      left,  top    = *rect.topleft
+      right, bottom = *rect.bottomright
+      $window.draw_quad(left,  top,    color_a,
+                        left,  bottom, color_b,
+                        right, bottom, color_c,
+                        right, top,    color_d,
+                        zorder, mode)
+    end
+    
+    def _stroke_rect(rect, color_a, color_b, color_c, color_d, zorder, mode)
+      left,  top    = *rect.topleft
+      right, bottom = *rect.bottomright
+      $window.draw_line(left,  top,    color_a, left,  bottom, color_b, zorder, mode)
+      $window.draw_line(left,  bottom, color_b, right, bottom, color_c, zorder, mode)
+      $window.draw_line(right, bottom, color_c, right, top,    color_d, zorder, mode)
+      $window.draw_line(right, top,    color_d, left,  top,    color_a, zorder, mode)
+    end
+    
+    #
+    # Calculates a reasonable number of segments for a circle of the given
+    # radius. Forgive the use of a magic number.
+    #
+    # Adapted from SiegeLord's "An Efficient Way to Draw Approximate Circles
+    # in OpenGL" <http://slabode.exofire.net/circle_draw.shtml>.
+    #
+    def _circle_segments(r)
+      10 * Math.sqrt(r)
+    end
+    
+    #
+    # Appriximates an arc as a series of line segments and passes each segment
+    # to the block. Makes clever use of a transformation matrix to avoid
+    # repeated calls to sin and cos. 
+    #
+    # Adapted from SiegeLord's "An Efficient Way to Draw Approximate Circles
+    # in OpenGL" <http://slabode.exofire.net/circle_draw.shtml>.
+    #
+    def _walk_arc(from, to, detail, &block)
+      walk_segments = ((to - from).to_f * (detail - 1) / 360).floor
+      
+      theta = 2 * Math::PI / detail
+      c = Math.cos(theta)
+      s = Math.sin(theta)
+      
+      x1 = Gosu.offset_x(from, 1)
+      y1 = Gosu.offset_y(from, 1)
+      
+      0.upto(walk_segments) do
+        x2 = c * x1 - s * y1
+        y2 = s * x1 + c * y1
+        
+        block[x1, y1, x2, y2]
+        
+        x1, y1 = x2, y2
+      end
+    end
+    
   end
   
   end

data/lib/chingu/window.rb

@@ -32,6 +32,7 @@ module Chingu
   # - Tracking of button_up/button_down etc to enable Chingus pretty inputhandling
   #
   class Window < Gosu::Window
+    include Chingu::Helpers::FPSCounter         # Adds FPSCounter delegators
     include Chingu::Helpers::GFX                # Adds fill(), fade() etc to each game state
     include Chingu::Helpers::GameState          # Easy access to the global game state-queue
     include Chingu::Helpers::GameObject         # Adds game_objects_of_class etc ...
@@ -96,28 +97,6 @@ module Chingu
       game_state_manager.inside_state || game_state_manager.current_game_state || self
     end
     
-    #
-    # Frames per second, access with $window.fps or $window.framerate
-    #
-    def fps
-      @fps_counter.fps      # TODO: switch to Gosu::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.
     #
@@ -216,4 +195,4 @@ module Chingu
       $window = nil
     end
   end
-end
+end

data/spec/chingu/network_spec.rb

@@ -6,7 +6,8 @@ def data_set
     "a String" => ["Woof!"],
     "an Array" => [[1, 2, 3]],
     "a stream of packets" => [{ :foo => :bar }, "Woof!", [1, 2, 3]],
-    "huge packet" => [[:frogspawn] * 1000]
+    "huge packet" => [[:frogspawn] * 1000],
+    "100 small packets" => 100.times.map { rand(100000) },
   }
 end
 
@@ -94,15 +95,13 @@ module Chingu
           it "should send/recv #{name}" do
             @server.update # Accept the clients, so know about their existence to broadcast.
 
-            # Data should be cached.
-            data.each {|packet| @server.broadcast_msg(packet) }
-
             data.each do |packet|
               @client.should_receive(:on_msg).with(packet)
               @client2.should_receive(:on_msg).with(packet)
             end
 
-            @server.update # Push the cached messages.
+            data.each {|packet| @server.broadcast_msg(packet) }
+
             @client.update
             @client2.update
           end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: chingu
 version: !ruby/object:Gem::Version
-  version: 0.9rc3
+  version: 0.9rc4
   prerelease: 3
 platform: ruby
 authors:
@@ -9,12 +9,12 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-02-26 00:00:00.000000000 +01:00
+date: 2011-03-07 00:00:00.000000000 +01:00
 default_executable: 
 dependencies:
 - !ruby/object:Gem::Dependency
   name: gosu
-  requirement: &24030588 !ruby/object:Gem::Requirement
+  requirement: &25121820 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -22,10 +22,10 @@ dependencies:
         version: 0.7.27.1
   type: :runtime
   prerelease: false
-  version_requirements: *24030588
+  version_requirements: *25121820
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &24030108 !ruby/object:Gem::Requirement
+  requirement: &25121472 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -33,10 +33,10 @@ dependencies:
         version: 2.1.0
   type: :development
   prerelease: false
-  version_requirements: *24030108
+  version_requirements: *25121472
 - !ruby/object:Gem::Dependency
   name: watchr
-  requirement: &24029616 !ruby/object:Gem::Requirement
+  requirement: &25120920 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -44,10 +44,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *24029616
+  version_requirements: *25120920
 - !ruby/object:Gem::Dependency
   name: rcov
-  requirement: &24029220 !ruby/object:Gem::Requirement
+  requirement: &25120464 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -55,7 +55,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *24029220
+  version_requirements: *25120464
 description: OpenGL accelerated 2D game framework for Ruby. Builds on Gosu (Ruby/C++)
   which provides all the core functionality. Chingu adds simple yet powerful game
   states, prettier input handling, deployment safe asset-handling, a basic re-usable
@@ -201,6 +201,7 @@ files:
 - lib/chingu/game_states/popup.rb
 - lib/chingu/gosu_ext/image.rb
 - lib/chingu/helpers/class_inheritable_accessor.rb
+- lib/chingu/helpers/fps_counter.rb
 - lib/chingu/helpers/game_object.rb
 - lib/chingu/helpers/game_state.rb
 - lib/chingu/helpers/gfx.rb