Fix bugs and documentate stuff

[progcomp2013.git] / qchess / src / board.py

diff --git a/qchess/src/board.py b/qchess/src/board.py
index a9825d0..8fbbaa0 100644 (file)
--- a/qchess/src/board.py
+++ b/qchess/src/board.py
@@ -15,6 +15,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"]
 
@@ -185,10 +186,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:
@@ -212,6 +222,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
@@ -269,7 +284,7 @@ class Board():
                        if prob > 0:
                                result.update({p : prob})
                
-               self.verify()
+               #self.verify()
                return result
 
 
@@ -310,7 +325,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
 
@@ -336,10 +351,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":
@@ -411,7 +441,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
 
 
@@ -453,3 +485,31 @@ 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
+