Fixed gui, various game validation tweaks

Author: lyudmil-mitev

chesslib/board.py

@@ -1,11 +1,13 @@
 # -*- encoding: utf-8 -*-
 from itertools import groupby
+from copy import deepcopy
 
 import pieces
 import re
 
 class ChessError(Exception): pass
 class InvalidCoord(ChessError): pass
+class InvalidColor(ChessError): pass
 class InvalidMove(ChessError): pass
 class Check(ChessError): pass
 class CheckMate(ChessError): pass
@@ -65,12 +67,13 @@ def __getitem__(self, coord):
         except KeyError:
             return None
 
-    def check_for_check_after_move(self, p):
+    def save_to_file(self): pass
+
+    def is_in_check_after_move(self, p1, p2):
         # Create a temporary board
-        p1,p2 = p
-        tmp = Board(self.export())
+        tmp = deepcopy(self)
         tmp._do_move(p1,p2)
-        return self.is_in_check(self[p1].color)
+        return tmp.is_in_check(self[p1].color)
 
     def move(self, p1, p2):
         p1, p2 = p1.upper(), p2.upper()
@@ -84,46 +87,20 @@ def move(self, p1, p2):
         possible_moves = piece.possible_moves(p1)
         # 0. Check if p2 is in the possible moves
         if p2 not in possible_moves:
-           raise InvalidMove
+            raise InvalidMove
 
         # If enemy has any moves look for check
         if self.all_possible_moves(enemy):
-           filter(self.check_for_check_after_move, map(lambda p2: (p1,p2), possible_moves))
+           if self.is_in_check_after_move(p1,p2):
+              raise Check
 
         if not possible_moves and self.is_in_check(piece.color):
-           raise CheckMate
+            raise CheckMate
         elif not possible_moves:
-           raise Draw
+            raise Draw
         else:
-           self._do_move(p1,p2)
-           self._finish_move(piece, dest, p1,p2)
-
-        '''
-        # 1. Filter possible moves: remove the ones that will make you in check
-         # if no possible moves and not in check -- Draw
-         # if no possible moves and in check -- Checkmate
-        if enemy_moves:
-           # Save current state
-           temporary_board = Board(self.export())
-
-           if p2 in piece.possible_moves(p1):
-              _do_move(p1, p2)
-           elif not piece.possible_moves(p1):
-              raise CheckMate(enemy + " wins!")
-
-           if is_in_check(piece.get_color()):
-              # Restore table
-              table = current_table
-              raise Check
-
-           _finish_move(piece,dest,p1,p2)
-
-        elif p2 in piece.possible_moves(p1):
-           _do_move(p1, p2)
-           _finish_move(piece,dest,p1,p2)
-        elif not piece.possible_moves(p1):
-           raise Draw
-        '''
+            self._do_move(p1,p2)
+            self._finish_move(piece, dest, p1,p2)
 
     def get_enemy(self, color):
         if color == "white": return "black"
@@ -186,17 +163,18 @@ def occupied(self, color):
         if(color not in ("black", "white")): raise InvalidColor
 
         for coord in self:
-            if self[coord].color == color: result.append(coord)
+            if self[coord].color == color:
+               result.append(coord)
         return result
 
     def is_king(self, piece):
-       return isinstance(piece, pieces.King)
-          
+        return isinstance(piece, pieces.King)
+
 
     def get_king_position(self, color):
-       for pos in self.keys():
-          if self.is_king(self[pos]) and self[pos].color == color:
-             return pos
+        for pos in self.keys():
+            if self.is_king(self[pos]) and self[pos].color == color:
+                return pos
 
     def get_king(self, color):
         if(color not in ("black", "white")): raise InvalidColor
@@ -209,7 +187,7 @@ def is_in_check(self, color):
         return king in map(self.__getitem__, self.all_possible_moves(enemy))
 
     def letter_notation(self,coord):
-        if not self.is_in_bounds(coord): raise InvalidCoord
+        if not self.is_in_bounds(coord): return
         try:
             return self.axis_y[coord[1]] + str(self.axis_x[coord[0]])
         except IndexError:
@@ -242,6 +220,7 @@ def load(self, fen):
         '''
             Import state from FEN notation
         '''
+        self.clear()
         # Split data
         fen = fen.split(' ')
         # Expand blanks

chesslib/boardgui.py

@@ -1,12 +1,13 @@
-import board as chessboard
+import board
 import pieces
 import Tkinter as tk
 from PIL import Image, ImageTk
 
 class BoardGUI(tk.Frame):
-    def __init__(self, parent, rows=8, columns=8, size=32, color1="white", color2="grey"):
+    def __init__(self, parent, chessboard, rows=8, columns=8, size=32, color1="white", color2="grey"):
         ''' size is the size of a square, in pixels '''
 
+        self.chessboard = chessboard
         self.rows = rows
         self.columns = columns
         self.size = size
@@ -27,28 +28,18 @@ def __init__(self, parent, rows=8, columns=8, size=32, color1="white", color2="g
                                 width=canvas_width, height=canvas_height, background="grey")
         self.canvas.pack(side="top", fill="both", expand=True, padx=2, pady=2)
 
-        # this binding will cause a refresh if the user interactively
-        # changes the window size
-        self.canvas.bind("<Configure>", self.refresh)
         self.canvas.bind("<Button-1>", self.click)
 
         self.button_quit = tk.Button(self, text="New", fg="black", command=self.reset)
         self.button_quit.pack(side=tk.LEFT)
-        self.button_save = tk.Button(self, text="Save", fg="black", command=chessboard.save_to_file)
+        self.button_save = tk.Button(self, text="Save", fg="black", command=self.chessboard.save_to_file)
         self.button_save.pack(side=tk.LEFT)
 
         self.label_status = tk.Label(self, text="   White's turn  ", fg="black")
         self.label_status.pack(side=tk.LEFT)
         self.button_quit = tk.Button(self, text="Quit", fg="black", command=self.close)
         self.button_quit.pack(side=tk.RIGHT)
 
-
-        #self.button_load = tk.Button(self, text="Load", fg="black")
-        #self.button_load.pack(side=tk.RIGHT)
-
-        #self.button_save = tk.Button(self, text="Save", fg="black")
-        #self.button_save.pack(side=tk.RIGHT)
-
     def close(self):
         self.parent.destroy()
 
@@ -58,30 +49,21 @@ def click(self, event):
         row = 7-(event.y / row_pix)
         # self.label_status["text"] = "%s, %s, %s, %s" % (event.x, event.y, col, row)
         self.selected = (row, col)
-        pos = chessboard.letter_notation(self.selected)
-        piece = chessboard.get(pos)
-        if piece is not None and (piece.color == chessboard.player_turn):
+        pos = self.chessboard.letter_notation(self.selected)
+        piece = self.chessboard[pos]
+        if piece is not None and (piece.color == self.chessboard.player_turn):
             self.selected_piece = (piece, pos)
-            self.hilighted = map(chessboard.number_notation, (chessboard.get(pos).possible_moves(pos)))
+            self.hilighted = map(self.chessboard.number_notation, (self.chessboard[pos].possible_moves(pos)))
 
         if self.selected_piece and ((piece is None) or\
               (piece.color != self.selected_piece[0].color)):
             # making a move
             try:
-                chessboard.move(self.selected_piece[1], pos)
-            except chessboard.Check:
-                self.label_status["text"] = " You are in check!"
-            except chessboard.CheckMate:
-                self.label_status["text"] = " Check!"
-            except chessboard.InvalidMove:
-                self.label_status["text"] = " Invalid move!"
-            except chessboard.Draw:
-                self.label_status["text"] = " Draw!"
-            except Exception as e:
+                self.chessboard.move(self.selected_piece[1], pos)
+            except board.ChessError as e:
                 self.label_status["text"] = e.__class__.__name__
             else:
-                self.label_status["text"] = " " + self.selected_piece[0].get_color().capitalize() +": "+ self.selected_piece[1]+pos
-
+                self.label_status["text"] = " " + self.selected_piece[0].color.capitalize() +": "+ self.selected_piece[1]+pos
 
             self.selected_piece = None
             self.hilighted = None
@@ -104,7 +86,7 @@ def placepiece(self, name, row, column):
         self.canvas.coords(name, x0, y0)
 
     def refresh(self, event={}):
-        '''Redraw the board, possibly in response to window being resized'''
+        '''Redraw the board'''
         try:
             self.xsize = int((event.width-1) / self.columns)
             self.ysize = int((event.height-1) / self.rows)
@@ -135,35 +117,31 @@ def refresh(self, event={}):
 
     def draw_pieces(self):
         self.canvas.delete("piece")
-        for x in range(0,len(chessboard.table)):
-            for y in range(0,len(chessboard.table[x])):
-                piece = chessboard.table[x][y]
-                if piece is not None:
-                    filename = "img/%s%s.png" % (piece.color, piece.abbriviation)
-                    piecename = "%s%s%s" % (piece.abbriviation, x, y)
+        for coord, piece in self.chessboard.iteritems():
+            x,y = self.chessboard.number_notation(coord)
+            if piece is not None:
+                filename = "img/%s%s.png" % (piece.color, piece.abbriviation.lower())
+                piecename = "%s%s%s" % (piece.abbriviation, x, y)
 
-                    if(filename not in self.icons):
-                        self.icons[filename] = ImageTk.PhotoImage(file=filename, width=32, height=32)
+                if(filename not in self.icons):
+                    self.icons[filename] = ImageTk.PhotoImage(file=filename, width=32, height=32)
 
-                    self.addpiece(piecename, self.icons[filename], x, y)
-                    self.placepiece(piecename, x, y)
-        #print chessboard.unicode_representation()
+                self.addpiece(piecename, self.icons[filename], x, y)
+                self.placepiece(piecename, x, y)
 
     def reset(self):
-        chessboard.init()
+        self.chessboard.load(board.FEN_STARTING)
         self.refresh()
         self.draw_pieces()
         self.refresh()
 
-def display():
+def display(chessboard):
     root = tk.Tk()
     root.title("Simply Chess")
-    b= BoardGUI(root)
+    b= BoardGUI(root, chessboard)
     b.pack(side="top", fill="both", expand="false", padx=4, pady=4)
     b.draw_pieces()
-    #b.placepiece("bishop", 6, 6)
 
-    #b.addpiece("player2", player2, 3,5)
     root.resizable(0,0)
     root.mainloop()
 

chesslib/pieces.py

@@ -64,9 +64,9 @@ def possible_moves(self, position, orthogonal, diagonal, distance):
             for step in range(1, distance+1):
                 if collision: break
                 dest = from_[0]+step*x, from_[1]+step*y
-                if dest not in board.occupied('white') + board.occupied('black'):
+                if self.board.letter_notation(dest) not in board.occupied('white') + board.occupied('black'):
                     legal_moves.append(dest)
-                elif dest in board.occupied(piece.color):
+                elif self.board.letter_notation(dest) in board.occupied(piece.color):
                     collision = True
                 else:
                     legal_moves.append(dest)
@@ -101,18 +101,18 @@ def possible_moves(self, position):
         forward = from_[0] + direction, from_[1]
 
         # Can we move forward?
-        if forward not in blocked:
+        if board.letter_notation(forward) not in blocked:
             legal_moves.append(forward)
             if from_[0] == homerow:
                 # If pawn in starting position we can do a double move
-                double_forward = forward[0] + direction, forward[1]
-                if double_forward not in blocked:
+                double_forward = (forward[0] + direction, forward[1])
+                if board.letter_notation(double_forward) not in blocked:
                     legal_moves.append(double_forward)
 
         # Attacking
         for a in range(-1, 2, 2):
             attack = from_[0] + direction, from_[1] + a
-            if attack in board.occupied(enemy):
+            if board.letter_notation(attack) in board.occupied(enemy):
                 legal_moves.append(attack)
 
         # TODO: En passant
@@ -132,7 +132,7 @@ def possible_moves(self,position):
 
         for x,y in deltas:
             dest = from_[0]+x, from_[1]+y
-            if(dest not in board.occupied(piece.color)):
+            if(board.letter_notation(dest) not in board.occupied(piece.color)):
                 legal_moves.append(dest)
 
         legal_moves = filter(board.is_in_bounds, legal_moves)

game.py

@@ -6,11 +6,10 @@
 
 if os.path.exists("state.fen"):
     with open("state.fen") as save:
-        board.init()
-        board.load(save.read())
+        b = board.Board(save.read())
 else:
-    board.init()
-boardgui.display()
+    b = board.Board()
+boardgui.display(b)
 
 ## Text Mode