Fixed various bugs in packets.py, and rejiggered spelling_mp.py to use QuickStreamClient and QuickStreamServer.

packets.py

@@ -104,47 +104,51 @@ class PacketUtility:
 class QuickStreamServer(PacketUtility):
     """Get a server set up easily!  Note: This kind of server is NOT always ideal."""
 
-    def __init__(self, port, expectedClients = 1, ipAddress = ''):
+    def __init__(self, port = 1028, expectedClients = 1, ipAddress = ''):
         """Creates a quick server using the specified port and number of expected clients."""
         self.clients = [] # Start with an empty list of clients
         serverSocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-        if len(ipAddress) >= 7:
+        if len(ipAddress) >= 6:
             address = (ipAddress, port)
         else:
             address = (socket.gethostname(), port) 
         serverSocket.bind(address)
-        serverSocket.listen(expectedClients)
+        serverSocket.listen(1)
         for i in range(expectedClients):
             self.clients.append(serverSocket.accept())
         serverSocket.close()
     
     def __del__(self):
-        for i in range(len(self.clients)):
-            self.clients[i][0].close()
+        self.close()
+    
+    def close(self):
+        if self.clients:
+            for i in range(len(self.clients)):
+                self.clients[i][0].close()
     
     def getByte(self):
-        """Get a tuple of byte-size ints from each client."""
+        """Get a list of byte-size ints from each client."""
         ret = []
         for i in range(len(self.clients)):
             ret.append(QuickStreamServer.get_int(self.clients[i][0], 1))
         return ret
     
     def getShort(self):
-        """Get a tuple of short ints from each client."""
+        """Get a list of short ints from each client."""
         ret = []
         for i in range(len(self.clients)):
             ret.append(QuickStreamServer.get_int(self.clients[i][0], 2))
         return ret
     
     def getInt(self):
-        """Get a tuple of ints from each client."""
+        """Get a list of ints from each client."""
         ret = []
         for i in range(len(self.clients)):
             ret.append(QuickStreamServer.get_int(self.clients[i][0], 4))
         return ret
         
     def getLong(self):
-        """Get a tuple of long ints from each client."""
+        """Get a list of long ints from each client."""
         ret = []
         for i in range(len(self.clients)):
             ret.append(QuickStreamServer.get_int(self.clients[i][0], 8))
@@ -159,21 +163,25 @@ class QuickStreamServer(PacketUtility):
     
     def sendByte(self, message):
         """Send a tuple of byte-size ints to each client."""
+        if not isinstance(message, tuple): message = tuple(message)
         for i in range(len(self.clients)):
             QuickStreamServer.send_int(self.clients[i][0], message, 1)
     
     def sendShort(self, message):
         """Send a tuple of short ints to each client."""
+        if not isinstance(message, tuple): message = tuple(message)
         for i in range(len(self.clients)):
             QuickStreamServer.send_int(self.clients[i][0], message, 2)
     
     def sendByte(self, message):
         """Send a tuple of ints to each client."""
+        if not isinstance(message, tuple): message = tuple(message)
         for i in range(len(self.clients)):
             QuickStreamServer.send_int(self.clients[i][0], message, 4)
     
-    def sendShort(self, message):
+    def sendLong(self, message):
         """Send a tuple of long ints to each client."""
+        if not isinstance(message, tuple): message = tuple(message)
         for i in range(len(self.clients)):
             QuickStreamServer.send_int(self.clients[i][0], message, 8)
     
@@ -185,13 +193,18 @@ class QuickStreamServer(PacketUtility):
 class QuickStreamClient(PacketUtility):
     """Get a client set up easily!  Note: This kind of client is NOT always ideal."""
     
-    def __init__(self, ipAddress, port):
+    def __init__(self, ipAddress, port = 1028):
         """Creates a quick client using the specified IP address and port."""
-        server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-        server.connect((ipAddress, port))
+        self.server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        self.server.connect((ipAddress, port))
     
     def __del__(self):
-        server.close()
+        if self.server:
+            self.server.close()
+    
+    def close(self):
+        if self.server:
+            self.server.close()
     
     def getByte(self):
         """Get a tuple of byte-size ints from the server."""
@@ -215,23 +228,27 @@ class QuickStreamClient(PacketUtility):
     
     def sendByte(self, message):
         """Send a tuple of byte-size ints to the server."""
+        if not isinstance(message, tuple): message = tuple(message)
         QuickStreamClient.send_int(self.server, message, 1)
     
     def sendShort(self, message):
         """Send a tuple of short ints to the server."""
+        if not isinstance(message, tuple): message = tuple(message)
         QuickStreamClient.send_int(self.server, message, 2)
 
     def sendInt(self, message):
         """Send a tuple of ints to the server."""
+        if not isinstance(message, tuple): message = tuple(message)
         QuickStreamClient.send_int(self.server, message, 4)
     
     def sendLong(self, message):
         """Send a tuple of long ints to the server."""
+        if not isinstance(message, tuple): message = tuple(message)
         QuickStreamClient.send_int(self.server, message, 8)
     
     def sendString(self, message):
         """Send a string to the server."""
-        QuickStreamClient.sent_str(self.server, message)
+        QuickStreamClient.send_str(self.server, message)
 
 # Legacy support:
 get_int = PacketUtility.get_int