X-Git-Url: https://git.ucc.asn.au/?p=progcomp2013.git;a=blobdiff_plain;f=qchess%2Fqchess.py;h=1dd8691002816907f2fb979b0ed015a46ff08fc9;hp=587cfa48aa4526988b12c3e4eec8aa9321a117fc;hb=1da52d4a75c75ddff22f3a67a2c06875b335e601;hpb=f7cca7e99d39a6b04b605e988d182a9b8a9e4be3

diff --git a/qchess/qchess.py b/qchess/qchess.py
index 587cfa4..1dd8691 100755
--- a/qchess/qchess.py
+++ b/qchess/qchess.py
@@ -257,7 +257,7 @@ class Board():
 	# Select a piece on the board (colour is the colour of whoever is doing the selecting)
 	def select(self, x,y, colour=None):
 		if not self.on_board(x, y): # Get on board everyone!
-			raise Exception("BOUNDS")
+			raise Exception("BOUNDS " + str(x) + ","+str(y))
 
 		piece = self.grid[x][y]
 		if piece == None:
@@ -272,7 +272,8 @@ class Board():
 
 	# Update the board when a piece has been selected
 	# "type" is apparently reserved, so I'll use "state"
-	def update_select(self, x, y, type_index, state, sanity=True):
+	def update_select(self, x, y, type_index, state, sanity=True, deselect=True):
+		#debug(str(self) + " update_select called")
 		piece = self.grid[x][y]
 		if piece.types[type_index] == "unknown":
 			if not state in self.unrevealed_types[piece.colour].keys() and sanity == True:
@@ -284,7 +285,7 @@ class Board():
 		piece.types[type_index] = state
 		piece.current_type = state
 
-		if len(self.possible_moves(piece)) <= 0:
+		if deselect == True and len(self.possible_moves(piece)) <= 0:
 			piece.deselect() # Piece can't move; deselect it
 			
 		# Piece needs to recalculate moves
@@ -292,7 +293,7 @@ class Board():
 		
 	# Update the board when a piece has been moved
 	def update_move(self, x, y, x2, y2, sanity=True):
-				
+		#debug(str(self) + " update_move called \""+str(x)+ " " + str(y) + " -> " + str(x2) + " " + str(y2) + "\"")	
 		piece = self.grid[x][y]
 		#print "Moving " + str(x) + "," + str(y) + " to " + str(x2) + "," + str(y2) + "; possible_moves are " + str(self.possible_moves(piece))
 		
@@ -331,8 +332,8 @@ class Board():
 
 	# Update the board from a string
 	# Guesses what to do based on the format of the string
-	def update(self, result, sanity=True):
-		#print "Update called with \"" + str(result) + "\""
+	def update(self, result, sanity=True, deselect=True):
+		#debug(str(self) + " update called \""+str(result)+"\"")
 		# String always starts with 'x y'
 		try:
 			s = result.split(" ")
@@ -342,7 +343,7 @@ class Board():
 
 		piece = self.grid[x][y]
 		if piece == None and sanity == True:
-			raise Exception("EMPTY")
+			raise Exception("EMPTY " + str(x) + " " + str(y))
 
 		# If a piece is being moved, the third token is '->'
 		# We could get away with just using four integers, but that wouldn't look as cool
@@ -366,7 +367,7 @@ class Board():
 
 
 			# Select the piece
-			self.update_select(x, y, type_index, state, sanity)
+			self.update_select(x, y, type_index, state, sanity=sanity, deselect=deselect)
 
 		return result
 
@@ -431,6 +432,12 @@ class Board():
 		return result
 
 	def prob_is_type(self, p, state):
+		if p.current_type != 0:
+			if state == p.current_type:
+				return 1.0
+			else:
+				return 0.0
+		
 		prob = 0.5
 		result = 0
 		for i in range(len(p.types)):
@@ -473,7 +480,7 @@ class Board():
 
 		
 		if p.current_type == "unknown":
-			raise Exception("SANITY: Piece state unknown")
+			raise Exception("SANITY: Unknown state for piece: "+str(p))
 			# The below commented out code causes things to break badly
 			#for t in p.types:
 			#	if t == "unknown":
@@ -586,6 +593,8 @@ class Board():
 	def on_board(self, x, y):
 		return (x >= 0 and x < w) and (y >= 0 and y < h)
 	
+	
+	
 	# Pushes a move temporarily
 	def push_move(self, piece, x, y):
 		target = self.grid[x][y]
@@ -611,7 +620,7 @@ class Board():
 		self.grid[x2][y2] = target
 		
 		for p in self.pieces["white"] + self.pieces["black"]:
-				p.possible_moves = None
+			p.possible_moves = None
 		
 # --- board.py --- #
 import subprocess
@@ -636,6 +645,150 @@ class Player():
 
 	def reset_board(self, s):
 		pass
+	
+	def __str__(self):
+		return self.name + "<"+str(self.colour)+">"
+
+	def base_player(self):
+		return self
+	
+
+
+def open_fifo(name, mode, timeout=None):
+	if timeout == None:
+		return open(name, mode)
+	
+	
+	class Worker(threading.Thread):
+		def __init__(self):
+			threading.Thread.__init__(self)
+			self.result = None
+			self.exception = None
+
+			
+		def run(self):		
+			try:
+				self.result = open(name, mode)
+			except Exception, e:
+				self.exception = e
+				self.result = None
+		
+
+	w = Worker()
+	w.start()
+	
+	start = time.time()
+	while time.time() - start < timeout:
+		if w.is_alive() == False:
+			w.join()
+			if w.exception != None:
+				raise w.exception
+			return w.result
+		time.sleep(0.1)
+	
+	
+	if w.is_alive():
+		#sys.stderr.write("FIFO_TIMEOUT!\n")
+		# Recursive to deal with possible race condition
+		try:
+			if mode == "r":
+				f = open_fifo(name, "w", 1)
+			else:
+				f = open_fifo(name, "r", 1)
+		except:
+			pass
+			
+		#sys.stderr.write("Opened other end!\n")
+		while w.is_alive():
+			time.sleep(0.1)
+			
+		w.join()
+		f.close()
+		w.result.close()
+		raise Exception("FIFO_TIMEOUT")
+	else:
+		w.join()
+		if w.exception != None:
+			raise w.exception
+		return w.result
+	
+
+# Player that runs through a fifo
+class FifoPlayer(Player):
+	
+	timeout = 300
+	
+	def __init__(self, name, colour):
+		Player.__init__(self, name, colour)
+		os.mkfifo(self.name+".in")
+		os.mkfifo(self.name+".out")
+
+		try:
+			self.fifo_out = open_fifo(self.name+".out","w", FifoPlayer.timeout)
+		except:
+			raise Exception("FIFO_TIMEOUT")
+		else:
+			self.fifo_out.write("START "+colour+"\n")
+			self.fifo_out.close()
+
+		
+		
+		
+		
+	def update(self, result):
+		sys.stderr.write("update fifo called\n")
+		try:
+			self.fifo_out = open_fifo(self.name+".out", "w", FifoPlayer.timeout)
+		except:
+			raise Exception("FIFO_TIMEOUT")
+		else:
+			self.fifo_out.write(result +"\n")
+			self.fifo_out.close()
+			return result
+		
+	def select(self):
+		sys.stderr.write("select fifo called\n")
+		try:
+			self.fifo_out = open_fifo(self.name+".out", "w", FifoPlayer.timeout)
+		except:
+			#sys.stderr.write("TIMEOUT\n")
+			raise Exception("FIFO_TIMEOUT")
+		else:
+			
+			self.fifo_out.write("SELECT?\n")
+			self.fifo_out.close()
+			self.fifo_in = open_fifo(self.name+".in", "r", FifoPlayer.timeout)
+			s = map(int, self.fifo_in.readline().strip(" \r\n").split(" "))
+			self.fifo_in.close()
+			return s
+	
+	def get_move(self):
+		sys.stderr.write("get_move fifo called\n")
+		try:
+			self.fifo_out = open_fifo(self.name+".out", "w", FifoPlayer.timeout)
+		except:
+			raise Exception("FIFO_TIMEOUT")
+		else:
+			self.fifo_out.write("MOVE?\n")
+			self.fifo_out.close()
+			self.fifo_in = open_fifo(self.name+".in", "r", FifoPlayer.timeout)
+			s = map(int, self.fifo_in.readline().strip(" \r\n").split(" "))
+			self.fifo_in.close()
+			return s
+	
+	def quit(self, result):
+		try:
+			self.fifo_out = open_fifo(self.name+".out", "w", FifoPlayer.timeout)
+		except:
+			os.remove(self.name+".in")
+			os.remove(self.name+".out")
+			#raise Exception("FIFO_TIMEOUT")
+			
+		else:
+			self.fifo_out.write(result + "\n")
+			self.fifo_out.close()
+			os.remove(self.name+".in")
+			os.remove(self.name+".out")
 
 # Player that runs from another process
 class ExternalAgent(Player):
@@ -745,9 +898,11 @@ class HumanPlayer(Player):
 				sys.stdout.write("SELECTION?\n")
 				try:
 					p = map(int, sys.stdin.readline().strip("\r\n ").split(" "))
+					return p
 				except:
 					sys.stderr.write("ILLEGAL GIBBERISH\n")
 					continue
+
 	# It's your move captain
 	def get_move(self):
 		if isinstance(graphics, GraphicsThread):
@@ -763,6 +918,7 @@ class HumanPlayer(Player):
 				sys.stdout.write("MOVE?\n")
 				try:
 					p = map(int, sys.stdin.readline().strip("\r\n ").split(" "))
+					return p
 				except:
 					sys.stderr.write("ILLEGAL GIBBERISH\n")
 					continue
@@ -879,10 +1035,9 @@ class ExternalWrapper(ExternalAgent):
 
 
 class AgentBishop(AgentRandom): # Inherits from AgentRandom (in qchess)
-	def __init__(self, name, colour):
+	def __init__(self, name, colour,value={"pawn" : 1, "bishop" : 3, "knight" : 3, "rook" : 5, "queen" : 9, "king" : 100, "unknown" : 2}):
 		InternalAgent.__init__(self, name, colour)
-		self.value = {"pawn" : 1, "bishop" : 3, "knight" : 3, "rook" : 5, "queen" : 9, "king" : 100, "unknown" : 4}
-
+		self.value = value
 		self.aggression = 2.0 # Multiplier for scoring due to aggressive actions
 		self.defence = 1.0 # Multiplier for scoring due to defensive actions
 		
@@ -1077,8 +1232,11 @@ class Worker(multiprocessing.Process):
 		self.q = q
 
 	def run(self):
-		#print str(self) + " runs " + str(self.function) + " with args " + str(self.args) 
+		#print str(self) + " runs " + str(self.function) + " with args " + str(self.args)
+		#try:
 		self.q.put(self.function(*self.args))
+		#except IOError:
+		#	pass
 		
 		
 
@@ -1099,7 +1257,7 @@ def TimeoutFunction(function, args, timeout):
 			w.terminate()
 			s.join()
 			raise Exception("TIMEOUT")
-
+		time.sleep(0.1)
 	
 		
 
@@ -1131,36 +1289,105 @@ import select
 network_timeout_start = -1.0 # Timeout in seconds to wait for the start of a message
 network_timeout_delay = 1.0 # Maximum time between two characters being received
 
-class Network(Player):
-	def __init__(self, colour, address = (None,4562), baseplayer = None):
+class NetworkPlayer(Player):
+	def __init__(self, colour, network, player):
+		Player.__init__(self, "@network:"+str(network.address), colour) 
+		self.player = player
+		self.network = network
+		
+	def __str__(self):
+		return "NetworkPlayer<"+str(self.colour)+","+str(self.player)+">"
+		
+	def select(self):
+		#debug(str(self) + " select called")
+		if self.player != None:
+			s = self.player.select()
+			self.send_message(str(s[0]) + " " + str(s[1]))
+		else:
+			s = map(int, self.get_response().split(" "))
+			for p in game.players:
+				if p != self and isinstance(p, NetworkPlayer) and p.player == None:
+					p.network.send_message(str(s[0]) + " " + str(s[1]))
+		if s == [-1,-1]:
+			game.final_result = "network terminate"
+			game.stop()
+		return s
+	
+	def send_message(self, message):
+		#debug(str(self) + " send_message(\""+str(message)+"\") called")
+		self.network.send_message(message)
 		
-		if baseplayer != None:
-			name = baseplayer.name + " --> @network"
+	def get_response(self):
+		#debug(str(self) + " get_response() called")
+		s = self.network.get_response()
+		#debug(str(self) + " get_response() returns \""+str(s)+"\"")
+		return s
+			
+			
+	def get_move(self):
+		#debug(str(self) + " get_move called")
+		if self.player != None:
+			s = self.player.get_move()
+			self.send_message(str(s[0]) + " " + str(s[1]))
 		else:
-			name = "<-- @network"
+			s = map(int, self.get_response().split(" "))
+			for p in game.players:
+				if p != self and isinstance(p, NetworkPlayer) and p.player == None:
+					p.network.send_message(str(s[0]) + " " + str(s[1]))
+					
+		if s == [-1,-1]:
+			game.final_result = "network terminate"
+			game.stop()
+		return s
+	
+	def update(self, result):
+		#debug(str(self) + " update(\""+str(result)+"\") called")
+		if self.network.server == True:
+			if self.player == None:
+				self.send_message(result)
+		elif self.player != None:
+			result = self.get_response()
+			if result == "-1 -1":
+				game.final_result = "network terminate"
+				game.stop()
+				return "-1 -1"
+			self.board.update(result, deselect=False)
 		
 		
-				
-		Player.__init__(self, name, colour)
-		debug("Colour is " + str(self.colour))
 		
+		if self.player != None:
+			result = self.player.update(result)
+			
+		return result
+		
+		
+	
+	def base_player(self):
+		if self.player == None:
+			return self
+		else:
+			return self.player.base_player()
+		
+	def quit(self, result):
+		try:
+			self.send_message("-1 -1")
+		except:
+			pass
+
+class Network():
+	def __init__(self, address = (None,4562)):
 		self.socket = socket.socket()
 		self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
-		self.baseplayer = baseplayer
 		#self.socket.setblocking(0)
-		
 		self.address = address
 		self.server = (address[0] == None)
-
-		if self.colour == "black":
-			self.address = (self.address[0], self.address[1] + 1)
-				
-		debug(str(self) + ":"+str(self.address))
 		
-		self.board = None
-			
+		
+		self.connected = False
 			
 	def connect(self):	
+		#debug(str(self) + "Tries to connect")
+		self.connected = True
 		if self.address[0] == None:
 			self.host = "0.0.0.0" #socket.gethostname() # Breaks things???
 			self.socket.bind((self.host, self.address[1]))
@@ -1179,6 +1406,7 @@ class Network(Player):
 				return
 			
 		else:
+			time.sleep(0.3)
 			self.socket.connect(self.address)
 			self.src = self.socket
 			self.src.send("ok\n")
@@ -1192,37 +1420,12 @@ class Network(Player):
 				return
 			
 
-	def select(self):
-		if self.baseplayer != None:
-			s = self.baseplayer.select()
-			self.send_message(str(s[0]) + " " + str(s[1]))
-			return s
-		return map(int,self.get_response().split(" "))
-	
-	def get_move(self):
-		if self.baseplayer != None:
-			s = self.baseplayer.get_move()
-			self.send_message(str(s[0]) + " " + str(s[1]))
-			return s
-		return map(int,self.get_response().split(" "))
-	
-	def update(self, result):
-		if self.baseplayer != None:
-			result = self.baseplayer.update(result)
-			self.send_message(result)
-			return result
-		if self.server:
-			self.send_message(result)
-		else:
-			s = self.get_response()
-			if self.board != None:
-				self.board.update(s)
-			
+		
 	def __str__(self):
-		return "Network<"+str(self.colour)+","+str(self.baseplayer)+">:"+str(self.address)
+		return "@network:"+str(self.address)
 
 	def get_response(self):
-		debug(str(self) + " get_response called...")
+		
 		# Timeout the start of the message (first character)
 		if network_timeout_start > 0.0:
 			ready = select.select([self.src], [], [], network_timeout_start)[0]
@@ -1245,7 +1448,7 @@ class Network(Player):
 			else:
 				raise Exception("UNRESPONSIVE")
 
-		debug(str(self) + " get_response returns " + s.strip(" \r\n"))
+		
 		return s.strip(" \r\n")
 
 	def send_message(self,s):
@@ -1259,28 +1462,11 @@ class Network(Player):
 		else:
 			raise Exception("UNRESPONSIVE")
 		
-		debug(str(self) + " send_message sent " + s)
-
-	def check_quit(self, s):
-		s = s.split(" ")
-		if s[0] == "QUIT":
-			with game.lock:
-				game.final_result = " ".join(s[1:]) + " " + str(opponent(self.colour))
-			game.stop()
-			return True
-			
-	def quit(self, result):
-		if self.baseplayer != None:
-			self.send_message("QUIT")
-			
-		with game.lock:
-			game.final_result = result
-		game.stop()	
-
-
-
-
 		
+
+	def close(self):
+		self.src.shutdown()
+		self.src.close()
 # --- network.py --- #
 import threading
 
@@ -1296,15 +1482,14 @@ class StoppableThread(threading.Thread):
 		self._stop.set()
 
 	def stopped(self):
-		return self._stop.isSet()
-# --- thread_util.py --- #
+		return self._stop.isSet()# --- thread_util.py --- #
 log_files = []
 import datetime
 import urllib2
 
 class LogFile():
-	def __init__(self, log):	
-		
+	def __init__(self, log, name):	
+		self.name = name
 		self.log = log
 		self.logged = []
 		self.log.write("# Log starts " + str(datetime.datetime.now()) + "\n")
@@ -1338,7 +1523,7 @@ class ShortLog(LogFile):
 			self.log = sys.stdout
 		else:
 			self.log = open(file_name, "w", 0)
-		LogFile.__init__(self, self.log)
+		LogFile.__init__(self, self.log, "@"+file_name)
 		self.file_name = file_name
 		self.phase = 0
 
@@ -1489,7 +1674,7 @@ def log_init(board, players):
 
 # A thread that runs the game
 class GameThread(StoppableThread):
-	def __init__(self, board, players):
+	def __init__(self, board, players, server = True):
 		StoppableThread.__init__(self)
 		self.board = board
 		self.players = players
@@ -1498,8 +1683,11 @@ class GameThread(StoppableThread):
 		self.lock = threading.RLock() #lock for access of self.state
 		self.cond = threading.Condition() # conditional for some reason, I forgot
 		self.final_result = ""
+		self.server = server
+		self.retry_illegal = False
 		
 		
+	
 
 	# Run the game (run in new thread with start(), run in current thread with run())
 	def run(self):
@@ -1508,24 +1696,35 @@ class GameThread(StoppableThread):
 			
 			for p in self.players:
 				with self.lock:
-					if isinstance(p, Network) and p.baseplayer != None:
-						self.state["turn"] = p.baseplayer # "turn" contains the player who's turn it is
-					else:
-						self.state["turn"] = p
-				#try:
-				if True:
+					self.state["turn"] = p.base_player()
+				try:
+				#if True:
 					[x,y] = p.select() # Player selects a square
 					if self.stopped():
+						#debug("Quitting in select")
 						break
 						
-					if isinstance(p, Network) == False or p.server == True:
-						result = self.board.select(x, y, colour = p.colour)
+					if isinstance(p, NetworkPlayer):
+						if p.network.server == True:
+							result = self.board.select(x, y, colour = p.colour)
+						else:
+							result = None
+							
 					else:
-						result = p.get_response()
-						self.board.update(result)
-						
+						result = self.board.select(x, y, colour = p.colour)
+					
+					result = p.update(result)
+					if self.stopped():
+						break
 					for p2 in self.players:
+						if p2 == p:
+							continue
 						p2.update(result) # Inform players of what happened
+						if self.stopped():
+							break
+					
+					if self.stopped():
+						break
 
 
 					log(result)
@@ -1549,21 +1748,43 @@ class GameThread(StoppableThread):
 								graphics.state["dest"] = None
 						continue
 
-					try:
-						[x2,y2] = p.get_move() # Player selects a destination
-					except:
-						self.stop()
+					#try:
+					[x2,y2] = p.get_move() # Player selects a destination
+					#except:
+					#	self.stop()
 
 					if self.stopped():
+						#debug("Quitting in get_move")
 						break
-
-					result = str(x) + " " + str(y) + " -> " + str(x2) + " " + str(y2)
-					log(result)
-
-					self.board.update_move(x, y, x2, y2)
 					
+					if isinstance(p, NetworkPlayer):
+						if p.network.server == True:
+							result = str(x) + " " + str(y) + " -> " + str(x2) + " " + str(y2)
+							self.board.update_move(x, y, x2, y2)
+						else:
+							result = None
+							
+					else:
+						result = str(x) + " " + str(y) + " -> " + str(x2) + " " + str(y2)
+						self.board.update_move(x, y, x2, y2)
+					
+					result = p.update(result)
+					if self.stopped():
+						break
 					for p2 in self.players:
+						if p2 == p:
+							continue
 						p2.update(result) # Inform players of what happened
+						if self.stopped():
+							break
+					
+					if self.stopped():
+						break
+					
+					
+											
+					log(result)
+
 
 										
 
@@ -1579,26 +1800,32 @@ class GameThread(StoppableThread):
 							graphics.state["dest"] = None
 							graphics.state["moves"] = None
 
-			# Commented out exception stuff for now, because it makes it impossible to tell if I made an IndentationError somewhere
-			#	except Exception,e:
-			#		result = e.message
-			#		#sys.stderr.write(result + "\n")
-			#		
-			#		self.stop()
-			#		with self.lock:
-			#			self.final_result = self.state["turn"].colour + " " + e.message
-
-				end = self.board.end_condition()
-				if end != None:		
-					with self.lock:
-						if end == "DRAW":
-							self.final_result = self.state["turn"].colour + " " + end
-						else:
-							self.final_result = end
-					self.stop()
+			
+					end = self.board.end_condition()
+					if end != None:		
+						with self.lock:
+							if end == "DRAW":
+								self.final_result = self.state["turn"].colour + " " + end
+							else:
+								self.final_result = end
+						self.stop()
 				
-				if self.stopped():
-					break
+					if self.stopped():
+						break
+				except Exception,e:
+				#if False:
+
+					
+					result = e.message
+					if self.retry_illegal:
+						self.state["turn"].update(result);
+					else:
+						sys.stderr.write("qchess.py exception: "+result + "\n")
+						self.stop()
+						with self.lock:
+							self.final_result = self.state["turn"].colour + " " + e.message
+						break
+
 
 
 		for p2 in self.players:
@@ -2215,6 +2442,18 @@ class GraphicsThread(StoppableThread):
 						#print "Reject " + str(i) + str(event.pos) + " vs " + str(t)
 		
 
+	# Function to choose between dedicated server or normal play
+	def SelectServer(self):
+	
+		choice = self.SelectButton(["Normal", "Join Eigenserver"],prompt="Game type?")
+		if choice == 0:
+			return None
+		choice = self.SelectButton(["progcomp.ucc", "other"], prompt="Address?")
+		if choice == 0:
+			return "progcomp.ucc.asn.au"
+		else:
+			return self.getstr(prompt = "Enter address:")
+			
 	# Function to pick players in a nice GUI way
 	def SelectPlayers(self, players = []):
 
@@ -2277,7 +2516,7 @@ class GraphicsThread(StoppableThread):
 								time.sleep(1)
 								p = None
 						players.append(p)
-			elif choice == 2:
+			elif choice == 1:
 				address = ""
 				while address == "":
 					self.board.display_grid(self.window, self.grid_sz)
@@ -2304,6 +2543,87 @@ class GraphicsThread(StoppableThread):
 				
 			
 # --- graphics.py --- #
+def dedicated_server():
+	global log_files
+	
+	max_games = 5
+	games = []
+	gameID = 0
+	while True:
+		# Get players
+		gameID += 1
+		log("Getting clients...")
+		s = socket.socket()
+		s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+		s.bind(("0.0.0.0", 4562))
+		s.listen(2)
+		ss = s.accept()
+		
+		log("Got white player")
+		
+		args = ["python", "qchess.py", "--no-graphics", "@network::"+str(4600+2*len(games)), "@network::"+str(4600+2*len(games))]
+		if len(log_files) != 0:
+			for l in log_files:
+				if l.name == "":
+					args.append("--log")
+				else:
+					args.append("--log="+str(l.name)+"_"+str(gameID))
+		
+		g = subprocess.Popen(args, stdout=subprocess.PIPE)
+		games.append(g)
+		
+		time.sleep(0.5)
+		ss[0].send("white " + str(4600 + 2*(len(games)-1)))
+		ss[0].shutdown(socket.SHUT_RD)
+		ss[0].close()
+		
+		time.sleep(0.5)
+		ss = s.accept()
+		
+		log("Got black player")
+		
+		time.sleep(0.5)
+		ss[0].send("black " + str(4600 + 2*(len(games)-1)))
+		ss[0].shutdown(socket.SHUT_RD)
+		ss[0].close()
+		
+		s.shutdown(socket.SHUT_RDWR)
+		s.close()
+		
+		
+		while len(games) > max_games:
+			#log("Too many games; waiting for game to finish...")
+			ready = select.select(map(lambda e : e.stdout, games),[], [])
+			for r in ready[0]:
+				s = r.readline().strip(" \r\n").split(" ")
+				if s[0] == "white" or s[0] == "black":
+					for g in games[:]:
+						if g.stdout == r:
+							log("Game " + str(g) + " has finished")
+							games.remove(g)
+							
+	return 0
+	
+def client(addr, player="@human"):
+	
+	
+	
+	s = socket.socket()
+	s.connect((addr, 4562))
+	
+	[colour,port] = s.recv(1024).strip(" \r\n").split(" ")
+	
+	#debug("Colour: " + colour + ", port: " + port)
+	
+	s.shutdown(socket.SHUT_RDWR)
+	s.close()
+	
+	if colour == "white":
+		p = subprocess.Popen(["python", "qchess.py", player, "@network:"+addr+":"+port])
+	else:
+		p = subprocess.Popen(["python", "qchess.py", "@network:"+addr+":"+port, player])
+	p.wait()
+	return 0# --- server.py --- #
 #!/usr/bin/python -u
 
 # Do you know what the -u does? It unbuffers stdin and stdout
@@ -2331,10 +2651,22 @@ def make_player(name, colour):
 			return HumanPlayer(name, colour)
 		s = name[1:].split(":")
 		if s[0] == "network":
-			address = (None, 4562)
+			ip = None
+			port = 4562
+			#print str(s)
 			if len(s) > 1:
-				address = (s[1], 4562)
-			return Network(colour, address, baseplayer = None)
+				if s[1] != "":
+					ip = s[1]
+			if len(s) > 2:
+				port = int(s[2])
+				
+			if ip == None:
+				if colour == "black":
+					port += 1
+			elif colour == "white":
+				port += 1
+						
+			return NetworkPlayer(colour, Network((ip, port)), None)
 		if s[0] == "internal":
 
 			import inspect
@@ -2354,7 +2686,11 @@ def make_player(name, colour):
 			sys.stderr.write(sys.argv[0] + " : Can't find an internal agent matching \"" + s[1] + "\"\n")
 			sys.stderr.write(sys.argv[0] + " : Choices are: " + str(map(lambda e : e[0], internal_agents)) + "\n")
 			return None
-			
+		if s[0] == "fifo":
+			if len(s) > 1:
+				return FifoPlayer(s[1], colour)
+			else:
+				return FifoPlayer(str(os.getpid())+"."+colour, colour)
 
 	else:
 		return ExternalAgent(name, colour)
@@ -2377,6 +2713,10 @@ def main(argv):
 	global always_reveal_states
 	global sleep_timeout
 
+
+	retry_illegal = False
+	server_addr = None
+
 	max_moves = None
 	src_file = None
 	
@@ -2433,17 +2773,26 @@ def main(argv):
 
 					if len(f.split(":")) == 2:
 						max_moves = int(f.split(":")[1])
-
+						
+		elif (arg[1] == '-' and arg[2:].split("=")[0] == "server"):
+			#debug("Server: " + str(arg[2:]))
+			if len(arg[2:].split("=")) <= 1:
+				server_addr = True
+			else:
+				server_addr = arg[2:].split("=")[1]
+			
 		elif (arg[1] == '-' and arg[2:].split("=")[0] == "log"):
 			# Log file
 			if len(arg[2:].split("=")) == 1:
-				log_files.append(LogFile(sys.stdout))
+				log_files.append(LogFile(sys.stdout,""))
 			else:
 				f = arg[2:].split("=")[1]
-				if f[0] == '@':
+				if f == "":
+					log_files.append(LogFile(sys.stdout, ""))
+				elif f[0] == '@':
 					log_files.append(ShortLog(f[1:]))
 				else:
-					log_files.append(LogFile(open(f, "w", 0)))
+					log_files.append(LogFile(open(f, "w", 0), f))
 		elif (arg[1] == '-' and arg[2:].split("=")[0] == "delay"):
 			# Delay
 			if len(arg[2:].split("=")) == 1:
@@ -2463,12 +2812,29 @@ def main(argv):
 				sleep_timeout = -1
 			else:
 				sleep_timeout = float(arg[2:].split("=")[1])
-				
+		elif (arg[1] == '-' and arg[2:] == "retry-illegal"):
+			retry_illegal = not retry_illegal
 		elif (arg[1] == '-' and arg[2:] == "help"):
 			# Help
 			os.system("less data/help.txt") # The best help function
 			return 0
-
+		
+	# Dedicated server?
+	
+	#debug("server_addr = " + str(server_addr))
+	
+	if server_addr != None:
+		if server_addr == True:
+			return dedicated_server()
+		else:
+			if len(players) > 1:
+				sys.stderr.write("Only a single player may be provided when --server is used\n")
+				return 1
+			if len(players) == 1:
+				return client(server_addr, players[0].name)
+			else:
+				return client(server_addr)
+		
 
 	# Create the board
 	
@@ -2494,6 +2860,7 @@ def main(argv):
 		board = Board(style)
 		board.max_moves = max_moves
 		game = GameThread(board, players) 
+		game.retry_illegal = retry_illegal
 
 
 
@@ -2513,6 +2880,15 @@ def main(argv):
 	# If there are no players listed, display a nice pretty menu
 	if len(players) != 2:
 		if graphics != None:
+			
+			server_addr = graphics.SelectServer()
+			if server_addr != None:
+				pygame.quit() # Time to say goodbye
+				if server_addr == True:
+					return dedicated_server()
+				else:
+					return client(server_addr)	
+			
 			players = graphics.SelectPlayers(players)
 		else:
 			sys.stderr.write(sys.argv[0] + " : Usage " + sys.argv[0] + " white black\n")
@@ -2523,27 +2899,22 @@ def main(argv):
 		sys.stderr.write(sys.argv[0] + " : Graphics window closed before players chosen\n")
 		return 45
 
-
-	# Wrap Networks players around original players if necessary
-	for i in range(len(players)):
-		if isinstance(players[i], Network) and players[i].baseplayer == None:
-			for j in range(len(players)):
-				if i == j:
+	old = players[:]
+	for p in old:
+		if isinstance(p, NetworkPlayer):
+			for i in range(len(old)):
+				if old[i] == p or isinstance(old[i], NetworkPlayer):
 					continue
-					
-				port = players[i].address[1]
-				if players[j].colour == "black" and players[i].colour == "white":
-					pass
-				elif players[j].colour == "white" and players[i].colour == "black":
-					port -= 1
-				players[j] = Network(players[j].colour, (players[i].address[0], port), baseplayer = players[j])
-			
-			
+				players[i] = NetworkPlayer(old[i].colour, p.network, old[i])
+		
 	for p in players:
-		if isinstance(p, Network):
-			if p.address[0] != None:
-				time.sleep(0.2)
-			p.connect()
+		#debug(str(p))
+		if isinstance(p, NetworkPlayer):
+			p.board = game.board
+			if not p.network.connected:
+				if not p.network.server:
+					time.sleep(0.2)
+				p.network.connect()
 				
 	
 	# If using windows, select won't work; use horrible TimeoutPlayer hack
@@ -2592,11 +2963,19 @@ def main(argv):
 	sys.stdout.write(game.final_result + "\n")
 
 	return error
+		
+		
+	
+		
+	
+		
+		
 
 # This is how python does a main() function...
 if __name__ == "__main__":
+	retcode = 0
 	try:
-		sys.exit(main(sys.argv))
+		retcode = main(sys.argv)
 	except KeyboardInterrupt:
 		sys.stderr.write(sys.argv[0] + " : Got KeyboardInterrupt. Stopping everything\n")
 		if isinstance(graphics, StoppableThread):
@@ -2607,8 +2986,21 @@ if __name__ == "__main__":
 			game.stop()
 			if game.is_alive():
 				game.join()
-
-		sys.exit(102)
+		retcode = 102
+	#except Exception, e:
+	#	sys.stderr.write(sys.argv[0] + " : " + e.message + "\n")
+	#	retcode = 103	
+		
+	try:
+    		sys.stdout.close()
+	except:
+    		pass
+	try:
+    		sys.stderr.close()
+	except:
+    		pass
+	sys.exit(retcode)
+		
 
 # --- main.py --- #
-# EOF - created from make on Fri Apr  5 14:17:50 WST 2013
+# EOF - created from make on Friday 21 June  18:15:14 WST 2013