chingu 0.9rc7 → 0.9rc8

data/examples/high_score_list.yml

@@ -1,34 +1,34 @@
 --- 
-- :name: NEW
-  :score: 10197
+- :score: 10197
   :text: from example13.rb
-- :name: NEW
-  :score: 10187
+  :name: NEW
+- :score: 10187
   :text: from example13.rb
-- :name: NEW
-  :score: 10177
+  :name: NEW
+- :score: 10177
   :text: from example13.rb
-- :name: NEW
-  :score: 10167
+  :name: NEW
+- :score: 10167
   :text: from example13.rb
-- :name: NEW
-  :score: 10157
+  :name: NEW
+- :score: 10157
   :text: from example13.rb
-- :name: NEW
-  :score: 10147
+  :name: NEW
+- :score: 10147
   :text: from example13.rb
-- :name: NEW
-  :score: 10137
+  :name: NEW
+- :score: 10137
   :text: from example13.rb
-- :name: NEW
-  :score: 10127
+  :name: NEW
+- :score: 10127
   :text: from example13.rb
-- :name: NEW
-  :score: 10117
+  :name: NEW
+- :score: 10117
   :text: from example13.rb
-- :name: NEW
-  :score: 10112
+  :name: NEW
+- :score: 10112
   :text: from example13.rb
-- :name: NEW
-  :score: 10107
+  :name: NEW
+- :score: 10107
   :text: from example13.rb
+  :name: NEW

data/lib/chingu.rb

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

data/lib/chingu/animation.rb

@@ -14,10 +14,13 @@ module Chingu
     
     #
     # Create a new Animation. 
+    # Must use :file OR :frames OR :image to create it.
     #
     #   - loop: [true|false]. After the last frame is used, start from the beginning.
     #   - bounce: [true|false]. After the last frame is used, play it backwards untill the first frame is used again, then start playing forwards again.
     #   - file:   Tile-file to cut up animation frames from. Could be a full path or just a name -- then it will look for media_path(file)
+    #   - frames: Creates the animation from existing images which are the same size (Array<Gosu::Image>)
+    #   - image: Image containing a strip of frames for the animation (Gosu::Image)
     #   - width:  width of each frame in the tileanimation
     #   - height:  width of each frame in the tileanimation
     #   - size: [width, height]-Array or just one fixnum which will spez both height and width
@@ -25,54 +28,71 @@ module Chingu
     #   - step: [steps] move animation forward [steps] frames each time we call #next
     #
     def initialize(options)
-      #options = {:step => 1, :loop => true, :bounce => false, :width => 32, :height => 32, :index => 0, :delay => 100}.merge(options)
-      options = {:step => 1, :loop => true, :bounce => false, :index => 0, :delay => 100}.merge(options)
-      
+      options = {:step => 1, :loop => true, :bounce => false, :index => 0, :delay => 100}.merge!(options)
+
       @loop = options[:loop]
       @bounce = options[:bounce]
-      @file = options[:file]
+      file = options[:file]
+      image = options[:image]
+      @frames = options[:frames]
       @index = options[:index]
       @delay = options[:delay]
       @step = options[:step] || 1
       @dt = 0
-      
+
       @sub_animations = {}
       @frame_actions = []
       
-      unless File.exists?(@file)
-        Gosu::Image.autoload_dirs.each do |autoload_dir|
-          full_path = File.join(autoload_dir, @file)
-          if File.exists?(full_path)
-            @file = full_path
-            break
-          end
+      raise ArgumentError, "Must provide one of :frames, :image OR :file parameter" unless [@frames, file, image].compact.size == 1
+
+      if @frames        
+        raise ArgumentError, "Must provide at least one frame image with :frames" if @frames.empty?
+        raise ArgumentError, ":frames must consist of images only" unless @frames.all? {|i| i.is_a? Gosu::Image }
+        
+        @width, @height = @frames[0].width, @frames[0].height
+        
+        raise ArgumentError, ":frames must be of identical size" unless @frames[1..-1].all? {|i| i.width == @width and i.height == @height }
+        
+      else    
+        if file and not File.exists?(file)
+          Gosu::Image.autoload_dirs.each do |autoload_dir|
+            full_path = File.join(autoload_dir, file)
+            if File.exists?(full_path)
+              file = full_path
+              break
+            end
+          end      
         end
+
+        #
+        # Various ways of determening the framesize
+        #
+        if options[:height] && options[:width]
+          @height = options[:height]
+          @width = options[:width]
+        elsif options[:size] && options[:size].is_a?(Array)
+          @width = options[:size][0]
+          @height = options[:size][1]
+        elsif options[:size]
+          @width = options[:size]
+          @height = options[:size]
+        elsif file
+          if file =~ /_(\d+)x(\d+)/
+            # Auto-detect width/height from filename
+            # Tilefile foo_10x25.png would mean frame width 10px and height 25px
+            @width = $1.to_i
+            @height = $2.to_i
+          else
+            # Assume the shortest side of the actual file is the width/height for each frame
+            image = Gosu::Image.new($window, file)
+            @width = @height = (image.width < image.height) ? image.width : image.height
+           end
+        else
+          @width = @height = (image.width < image.height) ? image.width : image.height
+        end
+        
+        @frames = Gosu::Image.load_tiles($window, image || file, @width, @height, true)
       end
-      
-      #
-      # Various ways of determening the framesize
-      #
-      if options[:height] && options[:width]
-        @height = options[:height]
-        @width = options[:width]
-      elsif options[:size] && options[:size].is_a?(Array)
-        @width = options[:size][0]
-        @height = options[:size][1]
-      elsif options[:size]
-        @width = options[:size]
-        @height = options[:size]
-      elsif @file =~ /_(\d+)x(\d+)/
-        # Auto-detect width/height from filename 
-        # Tilefile foo_10x25.png would mean frame width 10px and height 25px
-        @width = $1.to_i
-        @height = $2.to_i
-      else
-        # Assume the shortest side is the width/height for each frame
-        @image = Gosu::Image.new($window, @file)
-        @width = @height = (@image.width < @image.height) ? @image.width : @image.height
-      end
-      
-      @frames = Gosu::Image.load_tiles($window, @file, @width, @height, true)
     end
     
     #
@@ -247,4 +267,4 @@ module Chingu
       end
     end		
   end
-end
+end

data/lib/chingu/game_state_manager.rb

@@ -97,43 +97,13 @@ module Chingu
     # Switch to a given game state, _replacing_ the current active one.
     # By default setup() is called on the game state  we're switching _to_.
     # .. and finalize() is called on the game state we're switching _from_.
-    #
+    #   
     def switch_game_state(state, options = {})
-      options = {:setup => true, :finalize => true, :transitional => true}.merge(options)
-      
-      new_state = game_state_instance(state)
+      options = {:setup => true, :finalize => true, :transitional => true}.merge!(options)
       
-      if new_state
-        # Make sure the game state knows about the manager
-        new_state.game_state_manager = self
-        
-        # Give the soon-to-be-disabled state a chance to clean up by calling finalize() on it.
-        current_game_state.finalize   if current_game_state.respond_to?(:finalize) && options[:finalize]
-        
-        # So BasicGameObject#create connects object to new state in its setup()
-        # Is this doubled in GameState.initialize() ?
-        self.inside_state = new_state
-        
-        # Call setup
-        new_state.setup               if new_state.respond_to?(:setup) && options[:setup]
-        
-        if @transitional_game_state && options[:transitional]
-          # If we have a transitional, switch to that instead, with new_state as first argument
-          transitional_game_state = @transitional_game_state.new(new_state, @transitional_game_state_options)
-          transitional_game_state.game_state_manager = self
-          self.push_game_state(transitional_game_state, :transitional => false)
-        else
-          if current_game_state.nil?
-            @game_states << new_state
-          else
-            # Replace last (active) state with new one
-            @game_states[-1] = new_state
-          end
-        end
-        ## MOVED: self.inside_state = current_game_state
-      end
-      
-      self.inside_state = nil   # no longer 'inside' (as in within initialize() etc) a game state
+      # Don't setup or finalize the underlying state, since it never becomes active.
+      pop_game_state(options.merge(:setup => false))
+      push_game_state(state, options.merge(:finalize => false))
     end
     alias :switch :switch_game_state
     
@@ -233,18 +203,18 @@ module Chingu
     alias :clear :clear_game_states
     
     #
-    # Pops through all game states until matching a given game state
-    #
-    def pop_until_game_state(new_state)
+    # Pops through all game states until matching a given game state (takes either a class or instance to match).
+    #    
+    def pop_until_game_state(new_state, options = {})
       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
+        raise ArgumentError, "No state of given class is on the stack" unless @game_states.any? {|s| s.is_a? new_state }
 
-        @game_states.pop until current_game_state.is_a? new_state
+        pop_game_state(options) 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
+        pop_game_state(options) until current_game_state == new_state
       end
     end
         

data/lib/chingu/game_states/edit.rb

@@ -136,6 +136,10 @@ module Chingu
 
         @hud_height = 140
         @toolbar_icon_size = [32,32]
+        draw_toolbar_objects
+      end
+
+      def draw_toolbar_objects
         x = 20
         y = 60
         @classes.each do |klass|
@@ -162,9 +166,8 @@ module Chingu
           rescue
             puts "Couldn't use #{klass} in editor: #{$!}"
           end
-        end
+        end        
       end
-      
       def display_help
 text = <<END_OF_STRING
   F1: This help screen

data/lib/chingu/game_states/enter_name.rb

@@ -63,7 +63,7 @@ module Chingu
           end
         end
       
-        @texts[@index].color = Color::RED
+        @texts[@index].color = ::Gosu::Color::RED
         @name = Text.create("", :rotaion_center => :top_center, :x => $window.width/2, :y => 60, :size => 80)
       end
     
@@ -94,8 +94,8 @@ module Chingu
         new_value = @index + amount
         @index = new_value  if new_value < @letters.size && new_value >= 0
         
-        @texts.each { |text| text.color = Color::WHITE }
-        @texts[@index].color = Color::RED
+        @texts.each { |text| text.color = ::Gosu::Color::WHITE }
+        @texts[@index].color = ::Gosu::Color::RED
         
         sleep(0.15)
       end

data/lib/chingu/game_states/network_client.rb

@@ -18,20 +18,19 @@
 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 #
 #++
-
 module Chingu
   module GameStates  
     #
     # A game state for a client in a multiplayer game, suitable for smaller/middle sized games.
     # Used in combination with game state NetworkServer.
     #
-    # Uses nonblocking polling TCP and YAML to communicate. 
+    # Uses non-blocking polling TCP and marshal to communicate.
     # If your game state inherits from NetworkClient you'll have the following methods available:
     #
-    #   connect(ip, port)               # Start a nonblocking connection. only connect() uses previosly given ip:port
-    #   send_data(data)                 # Send raw data on the network, nonblocking
-    #   send_msg(whatever ruby data)    # Will get YAML'd and sent to server
-    #   handle_incoming_data(max_size)  # Nonblocking read of incoming server data
+    #   connect(address, port)          # Start a non-blocking connection. only connect() uses previosly given ip:port
+    #   send_data(data)                 # Send raw data on the network, non-blocking
+    #   send_msg(whatever ruby data)    # Will get marshalled and sent to server
+    #   handle_incoming_data(max_size)  # Non-blocking read of incoming server data
     #   disconnect_from_server          # Shuts down all network connections
     #   
     # The following callbacks can be overwritten to add your game logic:
@@ -46,7 +45,7 @@ module Chingu
     #   PlayState < Chingu::GameStates::NetworkClient
     #     def initialize(options = {})
     #       super   # this is always needed!
-    #       connect(options[:ip], options[:port])
+    #       connect(options[:address], options[:port])
     #     end
     #     
     #     def on_connect
@@ -65,29 +64,25 @@ module Chingu
     #
     # So why not EventMachine? No doubt in my mind that EventMachine is a hell of a library Chingu rolls its own for 2 reasons:
     #
-    #   AFAIK EventMachine can be hard to intergrate with the classic game loop, event machine wants its own loop
-    #   Rubys nonblocking sockets work, so why not keep it simple
+    #   AFAIK EventMachine can be hard to integrate with the classic game loop, event machine wants its own loop
+    #   Rubys non-blocking sockets work, so why not keep it simple
     #
     #
-    class NetworkClient < Chingu::GameState
-      attr_reader :latency, :socket, :packet_counter, :packet_buffer, :ip, :port
-      alias_method :address, :ip
+    class NetworkClient < NetworkState
+      attr_reader :socket, :timeout
 
       def connected?; @connected; end
       
       def initialize(options = {})
-        super
-        @timeout = options[:timeout] || 4        
-        @debug = options[:debug]
-        @ip = options[:ip] || "0.0.0.0"
-        @port = options[:port] || NetworkServer::DEFAULT_PORT
+        super(options)
+
+        @timeout = options[:timeout] || 4000
+
         @max_read_per_update = options[:max_read_per_update] || 50000
         
         @socket = nil
         @connected = false
-        @latency = 0
-        @packet_counter = 0
-        @packet_buffer = NetworkServer::PacketBuffer.new
+        @packet_buffer = PacketBuffer.new
       end
       
       #
@@ -98,47 +93,56 @@ module Chingu
       # 4) #on_data(data) will call #on_msgs(msg)
       #
       def update
-  
+
         if @socket and not @connected
-          begin
-            # Start/Check on our nonblocking tcp connection
-            @socket.connect_nonblock(@sockaddr)
-          rescue Errno::EINPROGRESS   #rescue IO::WaitWritable
-          rescue Errno::EALREADY
-            if IO.select([@socket],nil,nil,0.1).nil?
+          if Gosu::milliseconds >= @connect_times_out_at
+            @socket = nil
+            on_timeout
+          else
+            begin
+              # Start/Check on our nonblocking tcp connection
+              @socket.connect_nonblock(@sockaddr)
+            rescue Errno::EINPROGRESS   #rescue IO::WaitWritable
+            rescue Errno::EALREADY
+            rescue Errno::EISCONN
+              @connected = true
+              on_connect
+            rescue Errno::EHOSTUNREACH, Errno::ECONNREFUSED, Errno::ECONNRESET, Errno::EINVAL
               @socket = nil
               on_connection_refused
+            rescue Errno::ETIMEDOUT
+              @socket = nil
+              on_timeout
             end
-          rescue Errno::EISCONN
-            @connected = true
-            on_connect
-          rescue Errno::EHOSTUNREACH, Errno::ECONNREFUSED, Errno::ECONNRESET, Errno::EINVAL
-            @socket = nil
-            on_connection_refused
-          rescue Errno::ETIMEDOUT
-            @socket = nil
-            on_timeout
           end
         end
         
-        handle_incoming_data
+        handle_incoming_data if @connected
+
         super
       end
       
       #
-      # Connect to a given ip:port (the server)
-      # Connect is done in a blocking manner.      
-      # Will timeout after 4 seconds
-      #
-      def connect(ip = nil, port = nil)
+      # Connect to a given address:port (the server)
+      # Connect is done in a non-blocking manner.
+      # May pass :address and :port, which will overwrite any existing values.
+      def connect(options = {})
+        options = {
+          :address => @address,
+          :port => @port,
+          :reconnect => false, # Doesn't reset the timeout timer; used internally.
+        }.merge! options
+        
         return if @socket
         
-        @ip = ip      if ip
-        @port = port  if port
+        @address = options[:address]
+        @port = options[:port]
     
         # Set up our @socket, update() will handle the actual nonblocking connection
         @socket = Socket.new(Socket::Constants::AF_INET, Socket::Constants::SOCK_STREAM, 0)
-        @sockaddr = Socket.sockaddr_in(@port, @ip)
+        @sockaddr = Socket.sockaddr_in(@port, @address)
+
+        @connect_times_out_at = Gosu::milliseconds + @timeout unless options[:reconnect]
         
         return self
       end
@@ -147,23 +151,22 @@ module Chingu
       # Called when connect() fails with connection refused (closed port)
       #
       def on_connection_refused
-        puts "[on_connection_refused() #{@ip}:#{@port}]"  if @debug
-        connect(@ip, @port)
+        puts "[on_connection_refused() #{@address}:#{@port}]"  if @debug
+        connect(:reconnect => true)
       end
 
       #
       # Called when connect() recieves no initial answer from server
       #
       def on_timeout
-        puts "[on_timeout() #{@ip}:#{@port}]"  if @debug
-        connect(@ip, @port)
+        puts "[on_timeout() #{@address}:#{@port}]"  if @debug
       end
       
       #
       # on_connect will be called when client successfully makes a connection to server
       #
       def on_connect
-        puts "[Connected to Server #{@ip}:#{@port}]"  if @debug
+        puts "[Connected to Server #{@address}:#{@port}]"  if @debug
       end
       
       #
@@ -178,16 +181,14 @@ module Chingu
       # handle_incoming_data will call on_data(raw_data) when stuff comes on on the socket.
       #
       def handle_incoming_data(amount = @max_read_per_update)
-        return unless @socket
+        return unless @socket and connected?
         
         if IO.select([@socket], nil, nil, 0.0)
           begin
             packet, sender = @socket.recvfrom(amount)
             on_data(packet)        
           rescue Errno::ECONNABORTED, Errno::ECONNRESET
-            @connected = false
-            @socket = nil
-            on_disconnect
+            disconnect_from_server
           end
         end
       end
@@ -198,14 +199,26 @@ module Chingu
       def on_data(data)
         @packet_buffer.buffer_data data
 
+        @bytes_received += data.length
+
         while packet = @packet_buffer.next_packet
-          on_msg(Marshal.load(packet))
+          @packets_received += 1
+          begin
+            on_msg(Marshal.load(packet))
+          rescue TypeError
+            disconnect_from_server
+            break
+          end
         end
       end
+
+      # Handler when message packets are received. Should be overriden in your code.
+      def on_msg(packet)
+        # should be overridden.
+      end
       
       #
       # Send a msg to the server
-      # Can be whatever ruby-structure that responds to #to_yaml
       #
       def send_msg(msg)
         send_data(Marshal.dump(msg))
@@ -213,28 +226,36 @@ module Chingu
 
       #
       # Send whatever raw data to the server
-      #
+      # Returns amount of data sent, including header.
       def send_data(data)
-        begin
-          @socket.write([data.length].pack(NetworkServer::PACKET_HEADER_FORMAT))
-          @socket.write(data)
-        rescue Errno::ECONNABORTED, Errno::ECONNRESET, Errno::EPIPE, Errno::ENOTCONN
-          @connected = false
-          @socket = nil
-          on_disconnect
-        end
+        length = @socket.write([data.length].pack(NetworkServer::PACKET_HEADER_FORMAT))
+        length += @socket.write(data)
+        @packets_sent += 1
+        @bytes_sent += length
+        length
+      rescue Errno::ECONNABORTED, Errno::ECONNRESET, Errno::EPIPE, Errno::ENOTCONN
+        disconnect_from_server
+        0
       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
+        @socket.flush if @socket
+      rescue IOError
+        disconnect_from_server
       end
 
       #
       # Shuts down all communication (closes socket) with server
       #
       def disconnect_from_server
-        @socket.close
+        @socket.close if @socket and not @socket.closed?
+      rescue Errno::ENOTCONN
+      ensure
+        @socket = nil
+        was_connected = @connected
+        @connected = false
+        on_disconnect if was_connected
       end
       alias close disconnect_from_server
       alias stop disconnect_from_server