X-Git-Url: https://git.ucc.asn.au/?p=progcomp2013.git;a=blobdiff_plain;f=qchess%2Fsrc%2Fgame.py;h=15c53b1315086129fcc8dd21497b1ad7b3393bd9;hp=d91ea607026c81c8af992532c9f2766908623fd3;hb=538a32cb30f21a1a48653d7b639ab0c82db44d83;hpb=337c794fe317a54c65bf5de103bf1a55c0ceb141

diff --git a/qchess/src/game.py b/qchess/src/game.py
index d91ea60..15c53b1 100644
--- a/qchess/src/game.py
+++ b/qchess/src/game.py
@@ -5,7 +5,7 @@
 
 # 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
@@ -14,8 +14,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):
@@ -24,22 +27,35 @@ class GameThread(StoppableThread):
 			
 			for p in self.players:
 				with self.lock:
-					if isinstance(p, NetworkSender):
-						self.state["turn"] = p.base_player # "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
-
-					
 						
-
-					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 = 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)
@@ -63,21 +79,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)
+
 
 										
 
@@ -93,31 +131,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
-
-				if self.board.king["black"] == None:
-					if self.board.king["white"] == None:
+			
+					end = self.board.end_condition()
+					if end != None:		
 						with self.lock:
-							self.final_result = self.state["turn"].colour + " DRAW"
+							if end == "DRAW":
+								self.final_result = self.state["turn"].colour + " " + end
+							else:
+								self.final_result = end
+						self.stop()
+				
+					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 = "white"
-					self.stop()
-				elif self.board.king["white"] == None:
-					with self.lock:
-						self.final_result = "black"
-					self.stop()
-						
+							self.final_result = self.state["turn"].colour + " " + e.message
+						break
 
-				if self.stopped():
-					break
 
 
 		for p2 in self.players:
@@ -131,95 +170,146 @@ class GameThread(StoppableThread):
 	
 # A thread that replays a log file
 class ReplayThread(GameThread):
-	def __init__(self, players, src, end=False,max_lines=None):
+	def __init__(self, players, src, end=False,max_moves=None):
 		self.board = Board(style="empty")
+		self.board.max_moves = max_moves
 		GameThread.__init__(self, self.board, players)
 		self.src = src
-		self.max_lines = max_lines
-		self.line_number = 0
 		self.end = end
 
 		self.reset_board(self.src.readline())
 
 	def reset_board(self, line):
-		pieces = {"white" : [], "black" : []}
-		king = {"white" : None, "black" : None}
-		for x in range(w):
-			for y in range(h):
-				self.board.grid[x][y] = None
-		while line != "# Start game":
+		agent_str = ""
+		self_str = ""
+		while line != "# Start game" and line != "# EOF":
+			
+			while line == "":
+				line = self.src.readline().strip(" \r\n")
+				continue
+
+			if line[0] == '#':
+				line = self.src.readline().strip(" \r\n")
+				continue
+
+			self_str += line + "\n"
+
+			if self.players[0].name == "dummy" and self.players[1].name == "dummy":
+				line = self.src.readline().strip(" \r\n")
+				continue
+			
 			tokens = line.split(" ")
-			[x, y] = map(int, tokens[len(tokens)-1].split(","))
-			current_type = tokens[1]
-			types = map(lambda e : e.strip("'[], "), tokens[2].split(","))
+			types = map(lambda e : e.strip("[] ,'"), tokens[2:4])
+			for i in range(len(types)):
+				if types[i][0] == "?":
+					types[i] = "unknown"
 
-			target = Piece(tokens[0], x, y, current_type)
-			try:
-				target.choice = types.index(current_type)
-			except:
-				target.choice = -1
+			agent_str += tokens[0] + " " + tokens[1] + " " + str(types) + " ".join(tokens[4:]) + "\n"
+			line = self.src.readline().strip(" \r\n")
 
-			pieces[token[0]].append(target)
-			if target.current_type == "king":
-				king[token[0]] = target
+		for p in self.players:
+			p.reset_board(agent_str)
 		
-			line = self.src.readline().strip(" \r\n")
+		
+		self.board.reset_board(self_str)
 
-		self.board.pieces = pieces
-		self.board.king = king
 	
 	def run(self):
 		move_count = 0
+		last_line = ""
 		line = self.src.readline().strip(" \r\n")
 		while line != "# EOF":
+
+
 			if self.stopped():
 				break
-
+			
+			if len(line) <= 0:
+				continue
 					
 
 			if line[0] == '#':
+				last_line = line
 				line = self.src.readline().strip(" \r\n")
 				continue
 
 			tokens = line.split(" ")
 			if tokens[0] == "white" or tokens[0] == "black":
 				self.reset_board(line)
+				last_line = line
 				line = self.src.readline().strip(" \r\n")
 				continue
 
-			move = line.split(":")[1]
+			move = line.split(":")
+			move = move[len(move)-1].strip(" \r\n")
 			tokens = move.split(" ")
+			
+			
 			try:
 				[x,y] = map(int, tokens[0:2])
 			except:
+				last_line = line
 				self.stop()
 				break
 
+			log(move)
+
 			target = self.board.grid[x][y]
+			with self.lock:
+				if target.colour == "white":
+					self.state["turn"] = self.players[0]
+				else:
+					self.state["turn"] = self.players[1]
 			
 			move_piece = (tokens[2] == "->")
-
 			if move_piece:
 				[x2,y2] = map(int, tokens[len(tokens)-2:])
 
-			log(move)
-			self.board.update(move)
+			if isinstance(graphics, GraphicsThread):
+				with graphics.lock:
+					graphics.state["select"] = target
+					
+			if not move_piece:
+				self.board.update_select(x, y, int(tokens[2]), tokens[len(tokens)-1])
+				if isinstance(graphics, GraphicsThread):
+					with graphics.lock:
+						if target.current_type != "unknown":
+							graphics.state["moves"] = self.board.possible_moves(target)
+						else:
+							graphics.state["moves"] = None
+					time.sleep(turn_delay)
+			else:
+				self.board.update_move(x, y, x2, y2)
+				if isinstance(graphics, GraphicsThread):
+					with graphics.lock:
+						graphics.state["moves"] = [[x2,y2]]
+					time.sleep(turn_delay)
+					with graphics.lock:
+						graphics.state["select"] = None
+						graphics.state["moves"] = None
+						graphics.state["dest"] = None
+			
+
+			
+			
+			
 			for p in self.players:
 				p.update(move)
+
+			last_line = line
+			line = self.src.readline().strip(" \r\n")
 			
-			if isinstance(graphics, GraphicsThread):
-				with self.lock:
-					if target.colour == "white":
-						self.state["turn"] = self.players[0]
-					else:
-						self.state["turn"] = self.players[1]
+			
+			end = self.board.end_condition()
+			if end != None:
+				self.final_result = end
+				self.stop()
+				break
+					
+						
+						
 
-				with graphics.lock:
-					graphics.state["select"] = target
-					if move_piece:
-						graphics.state["moves"] = [[x2, y2]]
-					elif target.current_type != "unknown":
-						graphics.state["moves"] = self.board.possible_moves(target)
+			
 					
 
 
@@ -228,18 +318,28 @@ class ReplayThread(GameThread):
 				
 			
 
-		if self.max_lines != None and self.max_lines > count:
-			sys.stderr.write(sys.argv[0] + " : Replaying from file; stopping at last line (" + str(count) + ")\n")
-			sys.stderr.write(sys.argv[0] + " : (You requested line " + str(self.max_lines) + ")\n")
+		
 
 		if self.end and isinstance(graphics, GraphicsThread):
 			#graphics.stop()
 			pass # Let the user stop the display
-		elif not self.end:
+		elif not self.end and self.board.end_condition() == None:
 			global game
+			# Work out the last move
+					
+			t = last_line.split(" ")
+			if t[len(t)-2] == "black":
+				self.players.reverse()
+			elif t[len(t)-2] == "white":
+				pass
+			elif self.state["turn"] != None and self.state["turn"].colour == "white":
+				self.players.reverse()
+
+
 			game = GameThread(self.board, self.players)
 			game.run()
-		
+		else:
+			pass