X-Git-Url: https://git.ucc.asn.au/?p=progcomp2013.git;a=blobdiff_plain;f=qchess%2Fqchess.py;h=427472cbd6769a127d5a49ca8eec9f1acb85cf8b;hp=ced6001689cd5f7c24f84928540bcba60c5434d9;hb=159708785516e4dd5a1ddceadd1e371f48dd3d23;hpb=a6d91c8bb286fa91f9e2a56b304043ff48154322

diff --git a/qchess/qchess.py b/qchess/qchess.py
index ced6001..427472c 100755
--- a/qchess/qchess.py
+++ b/qchess/qchess.py
@@ -20,7 +20,7 @@ class Piece():
 		
 		self.move_pattern = None
 		self.coverage = None
-
+		self.possible_moves = None
 		
 
 	def init_from_copy(self, c):
@@ -76,7 +76,7 @@ class Piece():
 	
 	# Collapses the wave function!		
 	def select(self):
-		if self.current_type == "unknown":
+		if self.current_type == "unknown" or not self.choice in [0,1]:
 			self.choice = random.randint(0,1)
 			if self.types[self.choice][0] == '?':
 				self.types[self.choice] = self.types[self.choice][1:]
@@ -112,6 +112,7 @@ class Board():
 		self.king = {"white" : None, "black" : None} # We need to keep track of the king, because he is important
 		self.max_moves = None
 		self.moves = 0
+		self.move_stack = []
 		for c in ["black", "white"]:
 			del self.unrevealed_types[c]["unknown"]
 
@@ -282,10 +283,19 @@ class Board():
 
 		if len(self.possible_moves(piece)) <= 0:
 			piece.deselect() # Piece can't move; deselect it
+			
+		# Piece needs to recalculate moves
+		piece.possible_moves = None
 		
 	# Update the board when a piece has been moved
 	def update_move(self, x, y, x2, 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))
+		
+		if not [x2,y2] in self.possible_moves(piece):
+			raise Exception("ILLEGAL move")
+		
 		self.grid[x][y] = None
 		taken = self.grid[x2][y2]
 		if taken != None:
@@ -309,6 +319,11 @@ class Board():
 
 		piece.deselect() # Uncollapse (?) the wavefunction!
 		self.moves += 1
+		
+		# All other pieces need to recalculate moves
+		for p in self.pieces["white"] + self.pieces["black"]:
+			p.possible_moves = None
+		
 		#self.verify()	
 
 	# Update the board from a string
@@ -366,7 +381,7 @@ class Board():
 			if prob > 0:
 				result.update({p : prob})
 		
-		self.verify()
+		#self.verify()
 		return result
 
 
@@ -407,7 +422,7 @@ class Board():
 				for point in self.possible_moves(p, reject_allied):
 					result[point[0]][point[1]] += prob
 		
-		self.verify()
+		#self.verify()
 		p.current_type = "unknown"
 		return result
 
@@ -433,10 +448,25 @@ class Board():
 	# This is probably inefficient, but I looked at some sample chess games and they seem to actually do things this way
 	# reject_allied indicates whether squares occupied by allied pieces will be removed
 	# (set to false to check for defense)
-	def possible_moves(self, p, reject_allied = True):
-		result = []
+	def possible_moves(self, p, reject_allied = True, state=None):
 		if p == None:
+			raise Exception("SANITY: No piece")
+		
+		
+		
+		if state != None and state != p.current_type:
+			old_type = p.current_type
+			p.current_type = state
+			result = self.possible_moves(p, reject_allied, state=None)
+			p.current_type = old_type
 			return result
+		
+		if p.possible_moves != None:
+			return p.possible_moves
+		
+		
+		result = []
+		
 
 		
 		if p.current_type == "unknown":
@@ -508,7 +538,9 @@ class Board():
 			if g != None and (g.colour == p.colour and reject_allied == True):
 				result.remove(point) # Remove allied pieces
 		
-		self.verify()
+		#self.verify()
+		
+		p.possible_moves = result
 		return result
 
 
@@ -550,6 +582,34 @@ class Board():
 	# I typed the full statement about 30 times before writing this function...
 	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]
+		self.move_stack.append([piece, target, piece.x, piece.y, x, y])
+		[piece.x, piece.y] = [x, y]
+		self.grid[x][y] = piece
+		self.grid[piece.x][piece.y] = None
+		
+		for p in self.pieces["white"] + self.pieces["black"]:
+			p.possible_moves = None
+		
+	# Restore move
+	def pop_move(self):
+		#print str(self.move_stack)
+		[piece, target, x1, y1, x2, y2] = self.move_stack[len(self.move_stack)-1]
+		self.move_stack = self.move_stack[:-1]
+		piece.x = x1
+		piece.y = y1
+		self.grid[x1][y1] = piece
+		if target != None:
+			target.x = x2
+			target.y = y2
+		self.grid[x2][y2] = target
+		
+		for p in self.pieces["white"] + self.pieces["black"]:
+				p.possible_moves = None
+		
 # --- board.py --- #
 import subprocess
 import select
@@ -856,10 +916,9 @@ class AgentBishop(AgentRandom): # Inherits from AgentRandom (in qchess)
 				
 				
 				# Get total probability that the move is protected
-				[xx,yy] = [piece.x, piece.y]
-				[piece.x, piece.y] = [x, y]
-				self.board.grid[x][y] = piece
-				self.board.grid[xx][yy] = None
+				self.board.push_move(piece, x, y)
+				
+
 				
 				defenders = self.board.coverage(x, y, piece.colour, reject_allied = False)
 				d_prob = 0.0
@@ -882,9 +941,8 @@ class AgentBishop(AgentRandom): # Inherits from AgentRandom (in qchess)
 				if (a_prob > 1.0):
 					a_prob = 1.0
 
-				self.board.grid[x][y] = target
-				self.board.grid[xx][yy] = piece
-				[piece.x, piece.y] = [xx, yy]
+				self.board.pop_move()
+				
 
 				
 				# Score of the move
@@ -2546,4 +2604,4 @@ if __name__ == "__main__":
 		sys.exit(102)
 
 # --- main.py --- #
-# EOF - created from make on Tue Feb 12 17:06:37 WST 2013
+# EOF - created from make on Thu Feb 28 23:49:16 WST 2013