Facebook
From Sean H, 1 Week ago, written in Python.
This paste is a reply to Chess from Sean H - view diff
Embed
Download Paste or View Raw
Hits: 24
  1. import pygame
  2. import pygame.freetype
  3. import os
  4. import time
  5. import queue
  6. import threading
  7.  
  8. pygame.init()
  9.  
  10. BLACK = (255, 0, 0)
  11. WHITE = (255, 255, 255)
  12. screen_width = 800
  13. screen_height = 600
  14. board_top_left_x = screen_width//5
  15. board_top_left_y = screen_height//10
  16. square_size = screen_height//10
  17. # screen = pygame.display.set_mode([screen_width, screen_height])
  18. # os.environ['SDL_VIDEO_WINDOWS_POS'] = '10, 10'
  19. # commands = queue.Queue()
  20.  
  21. '''
  22. class Input(threading.Thread):
  23.    def run(self):
  24.        while True:
  25.            command = input()
  26.            commands.put(command)
  27. '''
  28.  
  29.  
  30. # class for the squares of the board
  31. '''
  32. class square(pygame.sprite.Sprite):
  33.    def __init__(self, colour):
  34.        super().__init__()
  35.        self.image = pygame.Surface([square_size, square_size])
  36.        self.rect = self.image.get_rect()
  37.        pygame.draw.rect(self.image, colour, [0, 0, square_size, square_size])
  38.        self.colour = colour
  39. '''
  40.  
  41.  
  42. # class used for checking if en-passant is possible
  43. class en_passant:
  44.     double_move = False
  45.     file = " "
  46.  
  47.  
  48. # superclass for all pieces
  49. class piece(pygame.sprite.Sprite):
  50.     x = 0
  51.     y = 0
  52.     possible_moves = []
  53.     colour = "w"
  54.  
  55.     def __init__(self, x, y, name):
  56.         super().__init__()
  57.         self.x = x
  58.         self.y = y
  59.         '''
  60.        self.image = load_image(name)
  61.        self.image = pygame.transform.scale(self.image, (square_size, square_size))
  62.        self.image.set_colorkey(WHITE)
  63.        self.rect = self.image.get_rect()
  64.        '''
  65.         self.colour = name[1]
  66.         self.name = name
  67.  
  68.     def move_is_possible(self, board, move, piece_list):
  69.         moves = self.get_moves(board, piece_list)
  70.         for m in moves:
  71.             if m == move:
  72.                 return True
  73.         return False
  74.  
  75.     def get_moves(self, board, piece_list):
  76.         return self.possible_moves
  77.  
  78.     # turns the destination location of a piece into a move
  79.     def translate_coordinates(self, x, y):
  80.         return chr(self.x + 97) + str(self.y + 1) + chr(x + 97) + str(y + 1)
  81.  
  82.  
  83. # turns a letter into an x coordinate on the board
  84. def untranslate(letter):
  85.     return ord(letter) - 97
  86.  
  87.  
  88. # class for the pawn piece
  89. class pawn(piece):
  90.     def __init__(self, x, y, name):
  91.         super().__init__(x, y, name)
  92.  
  93.     def get_moves(self, board, piece_list):
  94.         self.possible_moves = []
  95.         if self.name[-1] == "w":
  96.             if board[self.x][self.y + 1] == " ":
  97.                 self.possible_moves.append(self.translate_coordinates(self.x, self.y + 1))
  98.                 if self.y == 1 and board[self.x][self.y + 2] == " ":
  99.                     self.possible_moves.append(self.translate_coordinates(self.x, self.y + 2))
  100.             if self.x + 1 < 8:
  101.                 if board[self.x + 1][self.y + 1][-1] == "b":
  102.                     self.possible_moves.append(self.translate_coordinates(self.x + 1, self.y + 1))
  103.             if self.x - 1 > -1:
  104.                 if board[self.x - 1][self.y + 1][-1] == "b":
  105.                     self.possible_moves.append(self.translate_coordinates(self.x - 1, self.y + 1))
  106.         else:
  107.             if board[self.x][self.y - 1] == " ":
  108.                 self.possible_moves.append(self.translate_coordinates(self.x, self.y - 1))
  109.                 if board[self.x][self.y - 2] == " " and self.y == 6:
  110.                     self.possible_moves.append(self.translate_coordinates(self.x, self.y - 2))
  111.             if self.x + 1 < 8:
  112.                 if board[self.x + 1][self.y - 1][-1] == "w":
  113.                     self.possible_moves.append(self.translate_coordinates(self.x + 1, self.y - 1))
  114.             if self.x - 1 > 0:
  115.                 if board[self.x - 1][self.y - 1][-1] == "w":
  116.                     self.possible_moves.append(self.translate_coordinates(self.x - 1, self.y - 1))
  117.         return self.possible_moves
  118.  
  119.     # this get_moves function returns all the squares the opposing king cannot go to because of the piece
  120.     def get_movesk(self, board):
  121.         self.possible_moves = []
  122.         if self.colour == "w":
  123.             if self.x < 7:
  124.                 self.possible_moves.append(self.translate_coordinates(self.x + 1, self.y + 1))
  125.             if self.x > 0:
  126.                 self.possible_moves.append(self.translate_coordinates(self.x - 1, self.y + 1))
  127.         else:
  128.             if self.x < 7:
  129.                 self.possible_moves.append(self.translate_coordinates(self.x + 1, self.y - 1))
  130.             if self.x > 0:
  131.                 self.possible_moves.append(self.translate_coordinates(self.x - 1, self.y - 1))
  132.         return self.possible_moves
  133.  
  134.  
  135. class bishop(piece):
  136.     def __init__(self, x, y, name):
  137.         super().__init__(x, y, name)
  138.  
  139.     def get_moves(self, board, piece_list):
  140.         self.possible_moves = []
  141.         looping = True
  142.         i = 1
  143.         while looping is True:
  144.             if self.x + i >= 8 or self.y + i >= 8:
  145.                 looping = False
  146.             elif board[self.x + i][self.y + i] == " ":
  147.                 self.possible_moves.append(self.translate_coordinates(self.x + i, self.y + i))
  148.             elif (board[self.x + i][self.y + i][-1] == "b" and self.colour == "w") | \
  149.                     (board[self.x + i][self.y + i][-1] == "w" and self.colour == "b"):
  150.                 self.possible_moves.append(self.translate_coordinates(self.x + i, self.y + i))
  151.                 looping = False
  152.             else:
  153.                 looping = False
  154.             i += 1
  155.         looping = True
  156.         i = 1
  157.         while looping is True:
  158.             if self.x + i >= 8 or self.y - i <= -1:
  159.                 looping = False
  160.             elif board[self.x + i][self.y - i] == " ":
  161.                 self.possible_moves.append(self.translate_coordinates(self.x + i, self.y - i))
  162.             elif (board[self.x + i][self.y - i][-1] == "b" and self.colour == "w") | \
  163.                     (board[self.x + i][self.y - i][-1] == "w" and self.colour == "b"):
  164.                 self.possible_moves.append(self.translate_coordinates(self.x + i, self.y - i))
  165.                 looping = False
  166.             else:
  167.                 looping = False
  168.             i += 1
  169.         looping = True
  170.         i = 1
  171.         while looping is True:
  172.             if self.x - i <= -1 or self.y + i >= 8:
  173.                 looping = False
  174.             elif board[self.x - i][self.y + i] == " ":
  175.                 self.possible_moves.append(self.translate_coordinates(self.x - i, self.y + i))
  176.             elif (board[self.x - i][self.y + i][-1] == "b" and self.colour == "w") | \
  177.                     (board[self.x - i][self.y + i][-1] == "w" and self.colour == "b"):
  178.                 self.possible_moves.append(self.translate_coordinates(self.x - i, self.y + i))
  179.                 looping = False
  180.             else:
  181.                 looping = False
  182.             i += 1
  183.         looping = True
  184.         i = 1
  185.         while looping is True:
  186.             if self.x - i <= -1 or self.y - i <= -1:
  187.                 looping = False
  188.             elif board[self.x - i][self.y - i] == " ":
  189.                 self.possible_moves.append(self.translate_coordinates(self.x - i, self.y - i))
  190.             elif (board[self.x - i][self.y - i][-1] == "b" and self.colour == "w") | \
  191.                     (board[self.x - i][self.y - i][-1] == "w" and self.colour == "b"):
  192.                 self.possible_moves.append(self.translate_coordinates(self.x - i, self.y - i))
  193.                 looping = False
  194.             else:
  195.                 looping = False
  196.             i += 1
  197.         return self.possible_moves
  198.  
  199.     # this get_moves function returns all the squares the opposing king cannot go to because of the piece
  200.     def get_movesk(self, board):
  201.         self.possible_moves = []
  202.         looping = True
  203.         i = 1
  204.         while looping is True:
  205.             if self.x + i >= 8 or self.y + i >= 8:
  206.                 looping = False
  207.             elif board[self.x + i][self.y + i] == " ":
  208.                 self.possible_moves.append(self.translate_coordinates(self.x + i, self.y + i))
  209.             else:
  210.                 self.possible_moves.append(self.translate_coordinates(self.x + i, self.y + i))
  211.                 looping = False
  212.             i += 1
  213.         looping = True
  214.         i = 1
  215.         while looping is True:
  216.             if self.x + i >= 8 or self.y - i <= -1:
  217.                 looping = False
  218.             elif board[self.x + i][self.y - i] == " ":
  219.                 self.possible_moves.append(self.translate_coordinates(self.x + i, self.y - i))
  220.             else:
  221.                 self.possible_moves.append(self.translate_coordinates(self.x + i, self.y - i))
  222.                 looping = False
  223.             i += 1
  224.         looping = True
  225.         i = 1
  226.         while looping is True:
  227.             if self.x - i <= -1 or self.y + i >= 8:
  228.                 looping = False
  229.             elif board[self.x - i][self.y + i] == " ":
  230.                 self.possible_moves.append(self.translate_coordinates(self.x - i, self.y + i))
  231.             else:
  232.                 self.possible_moves.append(self.translate_coordinates(self.x - i, self.y + i))
  233.                 looping = False
  234.             i += 1
  235.         looping = True
  236.         i = 1
  237.         while looping is True:
  238.             if self.x - i <= -1 or self.y - i <= -1:
  239.                 looping = False
  240.             elif board[self.x - i][self.y - i] == " ":
  241.                 self.possible_moves.append(self.translate_coordinates(self.x - i, self.y - i))
  242.             else:
  243.                 self.possible_moves.append(self.translate_coordinates(self.x - i, self.y - i))
  244.                 looping = False
  245.             i += 1
  246.         return self.possible_moves
  247.  
  248.  
  249. class knight(piece):
  250.     def __init__(self, x, y, name):
  251.         super().__init__(x, y, name)
  252.  
  253.     def get_moves(self, board, piece_list):
  254.         self.possible_moves = []
  255.         if self.x + 2 < 8:
  256.             x_plus_2 = True
  257.             x_plus_1 = True
  258.         elif self.x + 1 < 8:
  259.             x_plus_1 = True
  260.             x_plus_2 = False
  261.         else:
  262.             x_plus_1 = False
  263.             x_plus_2 = False
  264.         if self.x - 2 > -1:
  265.             x_minus_2 = True
  266.             x_minus_1 = True
  267.         elif self.x - 1 > -1:
  268.             x_minus_1 = True
  269.             x_minus_2 = False
  270.         else:
  271.             x_minus_1 = False
  272.             x_minus_2 = False
  273.         if self.y + 2 < 8:
  274.             y_plus_2 = True
  275.             y_plus_1 = True
  276.         elif self.y + 1 < 8:
  277.             y_plus_1 = True
  278.             y_plus_2 = False
  279.         else:
  280.             y_plus_1 = False
  281.             y_plus_2 = False
  282.         if self.y - 2 > -1:
  283.             y_minus_2 = True
  284.             y_minus_1 = True
  285.         elif self.y - 1 > -1:
  286.             y_minus_1 = True
  287.             y_minus_2 = False
  288.         else:
  289.             y_minus_1 = False
  290.             y_minus_2 = False
  291.  
  292.         if x_plus_1 is True:
  293.             if y_plus_2 is True:
  294.                 if ((board[self.x + 1][self.y + 2][-1] == "b" and self.colour == "w") or
  295.                         (board[self.x + 1][self.y + 2][-1] == "w" and self.colour == "b")) or \
  296.                         board[self.x + 1][self.y + 2] == " ":
  297.                     self.possible_moves.append(self.translate_coordinates(self.x + 1, self.y + 2))
  298.             if y_minus_2 is True:
  299.                 if ((board[self.x + 1][self.y - 2][-1] == "b" and self.colour == "w") or
  300.                         (board[self.x + 1][self.y - 2][-1] == "w" and self.colour == "b")) or \
  301.                         board[self.x + 1][self.y - 2] == " ":
  302.                     self.possible_moves.append(self.translate_coordinates(self.x + 1, self.y - 2))
  303.             if x_plus_2 is True:
  304.                 if y_minus_1 is True:
  305.                     if ((board[self.x + 2][self.y - 1][-1] == "b" and self.colour == "w") or
  306.                             (board[self.x + 2][self.y - 1][-1] == "w" and self.colour == "b")) or \
  307.                             board[self.x + 2][self.y - 1] == " ":
  308.                         self.possible_moves.append(self.translate_coordinates(self.x + 2, self.y - 1))
  309.                 if y_plus_1 is True:
  310.                     if ((board[self.x + 2][self.y + 1][-1] == "b" and self.colour == "w") or
  311.                             (board[self.x + 2][self.y + 1][-1] == "w" and self.colour == "b")) or \
  312.                             board[self.x + 2][self.y + 1] == " ":
  313.                         self.possible_moves.append(self.translate_coordinates(self.x + 2, self.y + 1))
  314.  
  315.         if x_minus_1 is True:
  316.             if y_plus_2 is True:
  317.                 if ((board[self.x - 1][self.y + 2][-1] == "b" and self.colour == "w") or (
  318.                         board[self.x - 1][self.y + 2][-1] == "w" and self.colour == "b")) or board[self.x - 1][
  319.                         self.y + 2] == " ":
  320.                     self.possible_moves.append(self.translate_coordinates(self.x - 1, self.y + 2))
  321.             if y_minus_2 is True:
  322.                 if ((board[self.x - 1][self.y - 2][-1] == "b" and self.colour == "w") or (
  323.                         board[self.x - 1][self.y - 2][-1] == "w" and self.colour == "b")) or board[self.x - 1][
  324.                         self.y - 2] == " ":
  325.                     self.possible_moves.append(self.translate_coordinates(self.x - 1, self.y - 2))
  326.             if x_minus_2 is True:
  327.                 if y_minus_1 is True:
  328.                     if ((board[self.x - 2][self.y - 1][-1] == "b" and self.colour == "w") or (
  329.                             board[self.x - 2][self.y - 1][-1] == "w" and self.colour == "b")) or board[self.x - 2][
  330.                             self.y - 1] == " ":
  331.                         self.possible_moves.append(self.translate_coordinates(self.x - 2, self.y - 1))
  332.                 if y_plus_1 is True:
  333.                     if ((board[self.x - 2][self.y + 1][-1] == "b" and self.colour == "w") or (
  334.                             board[self.x - 2][self.y + 1][-1] == "w" and self.colour == "b")) or board[self.x - 2][
  335.                             self.y + 1] == " ":
  336.                         self.possible_moves.append(self.translate_coordinates(self.x - 2, self.y + 1))
  337.         return self.possible_moves
  338.  
  339.     # this get_moves function returns all the squares the opposing king cannot go to because of the piece
  340.     def get_movesk(self, board):
  341.         self.possible_moves = []
  342.         if self.x + 2 < 8:
  343.             x_plus_2 = True
  344.             x_plus_1 = True
  345.         elif self.x + 1 < 8:
  346.             x_plus_1 = True
  347.             x_plus_2 = False
  348.         else:
  349.             x_plus_1 = False
  350.             x_plus_2 = False
  351.         if self.x - 2 > -1:
  352.             x_minus_2 = True
  353.             x_minus_1 = True
  354.         elif self.x - 1 > -1:
  355.             x_minus_1 = True
  356.             x_minus_2 = False
  357.         else:
  358.             x_minus_1 = False
  359.             x_minus_2 = False
  360.         if self.y + 2 < 8:
  361.             y_plus_2 = True
  362.             y_plus_1 = True
  363.         elif self.x + 1 < 8:
  364.             y_plus_1 = True
  365.             y_plus_2 = False
  366.         else:
  367.             y_plus_1 = False
  368.             y_plus_2 = False
  369.         if self.x - 2 > -1:
  370.             y_minus_2 = True
  371.             y_minus_1 = True
  372.         elif self.x - 1 > -1:
  373.             y_minus_1 = True
  374.             y_minus_2 = False
  375.         else:
  376.             y_minus_1 = False
  377.             y_minus_2 = False
  378.  
  379.         if x_plus_1 is True:
  380.             if y_plus_2 is True:
  381.                 self.possible_moves.append(self.translate_coordinates(self.x + 1, self.y + 2))
  382.             if y_minus_2 is True:
  383.                 self.possible_moves.append(self.translate_coordinates(self.x + 1, self.y - 2))
  384.             if x_plus_2 is True:
  385.                 if y_minus_1 is True:
  386.                     self.possible_moves.append(self.translate_coordinates(self.x + 2, self.y - 1))
  387.                 if y_plus_1 is True:
  388.                     self.possible_moves.append(self.translate_coordinates(self.x + 2, self.y + 1))
  389.  
  390.         if x_minus_1 is True:
  391.             if y_plus_2 is True:
  392.                 self.possible_moves.append(self.translate_coordinates(self.x - 1, self.y + 2))
  393.             if y_minus_2 is True:
  394.                 self.possible_moves.append(self.translate_coordinates(self.x - 1, self.y - 2))
  395.             if x_minus_2 is True:
  396.                 if y_minus_1 is True:
  397.                     self.possible_moves.append(self.translate_coordinates(self.x - 2, self.y - 1))
  398.                 if y_plus_1 is True:
  399.                     self.possible_moves.append(self.translate_coordinates(self.x - 2, self.y + 1))
  400.         return self.possible_moves
  401.  
  402.  
  403. class rook(piece):
  404.     def __init__(self, x, y, name):
  405.         super().__init__(x, y, name)
  406.  
  407.     def get_moves(self, board, piece_list):
  408.         self.possible_moves = []
  409.         up_checker = True
  410.         right_checker = True
  411.         left_checker = True
  412.         down_checker = True
  413.         i = 1
  414.         while up_checker is True or right_checker is True or left_checker is True or down_checker is True:
  415.             if self.x + i > 7:
  416.                 right_checker = False
  417.             if self.x - i < 0:
  418.                 left_checker = False
  419.             if self.y + i > 7:
  420.                 up_checker = False
  421.             if self.y - i < 0:
  422.                 down_checker = False
  423.             if up_checker is True:
  424.                 if board[self.x][self.y + i] == " ":
  425.                     self.possible_moves.append(self.translate_coordinates(self.x, self.y + i))
  426.                 elif board[self.x][self.y + i - 1][-1] == opposite(self.name[-1]):
  427.                     self.possible_moves.append(self.translate_coordinates(self.x, self.y + i))
  428.                     up_checker = False
  429.                 else:
  430.                     up_checker = False
  431.             if down_checker is True:
  432.                 if board[self.x][self.y - i] == " ":
  433.                     self.possible_moves.append(self.translate_coordinates(self.x, self.y - i))
  434.                 elif board[self.x][self.y - i][-1] == opposite(self.name[-1]):
  435.                     self.possible_moves.append(self.translate_coordinates(self.x, self.y - i))
  436.                     down_checker = False
  437.                 else:
  438.                     down_checker = False
  439.             if right_checker is True:
  440.                 if board[self.x + i][self.y] == " ":
  441.                     self.possible_moves.append(self.translate_coordinates(self.x + i, self.y))
  442.                 elif board[self.x + i][self.y][-1] == opposite(self.name[-1]):
  443.                     self.possible_moves.append(self.translate_coordinates(self.x + i, self.y))
  444.                     right_checker = False
  445.                 else:
  446.                     right_checker = False
  447.             if left_checker is True:
  448.                 if board[self.x - i][self.y] == " ":
  449.                     self.possible_moves.append(self.translate_coordinates(self.x - i, self.y))
  450.                 elif board[self.x - i][self.y][-1] == opposite(self.name[-1]):
  451.                     self.possible_moves.append(self.translate_coordinates(self.x - i, self.y))
  452.                     left_checker = False
  453.                 else:
  454.                     left_checker = False
  455.             i += 1
  456.         return self.possible_moves
  457.  
  458.     # this get_moves function returns all the squares the opposing king cannot go to because of the piece
  459.     def get_movesk(self, board):
  460.         self.possible_moves = []
  461.         up_checker = True
  462.         right_checker = True
  463.         left_checker = True
  464.         down_checker = True
  465.         i = 1
  466.         if self.x + i > 7:
  467.             right_checker = False
  468.         if self.x - i < 0:
  469.             left_checker = False
  470.         if self.y + i > 7:
  471.             up_checker = False
  472.         if self.y - i < 0:
  473.             down_checker = False
  474.         while up_checker is True or right_checker is True or left_checker is True or down_checker is True:
  475.             if up_checker is True:
  476.                 if self.y + i < 8:
  477.                     if board[self.x][self.y + i] == " ":
  478.                         self.possible_moves.append(self.translate_coordinates(self.x, self.y + i))
  479.                     else:
  480.                         self.possible_moves.append(self.translate_coordinates(self.x, self.y + i))
  481.                         up_checker = False
  482.                 else:
  483.                     up_checker = False
  484.             if down_checker is True:
  485.                 if self.y - i > -1:
  486.                     if board[self.x][self.y - i] == " ":
  487.                         self.possible_moves.append(self.translate_coordinates(self.x, self.y - i))
  488.                     else:
  489.                         self.possible_moves.append(self.translate_coordinates(self.x, self.y - i))
  490.                         down_checker = False
  491.                 else:
  492.                     down_checker = False
  493.             if right_checker is True:
  494.                 if self.x + i < 8:
  495.                     if board[self.x + i][self.y] == " ":
  496.                         self.possible_moves.append(self.translate_coordinates(self.x + i, self.y))
  497.                     else:
  498.                         self.possible_moves.append(self.translate_coordinates(self.x + i, self.y))
  499.                         right_checker = False
  500.                 else:
  501.                     right_checker = False
  502.             if left_checker is True :
  503.                 if self.x - i > -1:
  504.                     if board[self.x - i][self.y] == " ":
  505.                         self.possible_moves.append(self.translate_coordinates(self.x - i, self.y))
  506.                     else:
  507.                         self.possible_moves.append(self.translate_coordinates(self.x - i, self.y))
  508.                         left_checker = False
  509.                 else:
  510.                     left_checker = False
  511.             i += 1
  512.         return self.possible_moves
  513.  
  514.  
  515. class king(piece):
  516.     def __init__(self, x, y, name):
  517.         super().__init__(x, y, name)
  518.  
  519.     def get_moves(self, board, piece_list):
  520.         not_possible = []
  521.         move_possible = True
  522.         self.possible_moves = []
  523.         for p in piece_list:
  524.             if p.name[-1] != self.name[-1]:
  525.                 moves = p.get_movesk(board)
  526.                 for move in moves:
  527.                     if self.x + 1 > untranslate(move[2]) > self.x - 1 and \
  528.                             self.y < int(move[3]) < self.y + 2 and (p.x != self.x or p.y != self.y):
  529.                         not_possible.append(move)
  530.         if self.x + 1 < 8:
  531.             for move in not_possible:
  532.                 if untranslate(move[2]) == self.x + 1 and int(move[3]) - 1 == self.y:
  533.                     move_possible = False
  534.             if move_possible is True and (board[self.x + 1][self.y] == " " or
  535.                                           board[self.x + 1][self.y][-1] != self.colour):
  536.                 self.possible_moves.append(self.translate_coordinates(self.x + 1, self.y))
  537.             move_possible = True
  538.             if self.y + 1 < 8:
  539.                 for move in not_possible:
  540.                     if untranslate(move[2]) == self.x + 1 and int(move[3]) - 1 == self.y + 1:
  541.                         move_possible = False
  542.                 if move_possible is True and (
  543.                         board[self.x + 1][self.y + 1] == " " or board[self.x + 1][self.y + 1][-1] != self.colour):
  544.                     self.possible_moves.append(self.translate_coordinates(self.x + 1, self.y + 1))
  545.             move_possible = True
  546.             if self.y - 1 > -1:
  547.                 for move in not_possible:
  548.                     if untranslate(move[2]) == self.x + 1 and int(move[3]) - 1 == self.y - 1:
  549.                         move_possible = False
  550.                 if move_possible is True and (
  551.                         board[self.x + 1][self.y - 1] == " " or board[self.x + 1][self.y - 1][-1] != self.colour):
  552.                     self.possible_moves.append(self.translate_coordinates(self.x + 1, self.y - 1))
  553.             move_possible = True
  554.         if self.y + 1 < 8:
  555.             for move in not_possible:
  556.                 if untranslate(move[2]) == self.x and int(move[3]) - 1 == self.y + 1:
  557.                     move_possible = False
  558.             if move_possible is True and (
  559.                     board[self.x][self.y + 1] == " " or board[self.x][self.y + 1][-1] != self.colour):
  560.                 self.possible_moves.append(self.translate_coordinates(self.x, self.y + 1))
  561.             move_possible = True
  562.             if self.x - 1 > -1:
  563.                 for move in not_possible:
  564.                     if untranslate(move[2]) == self.x - 1 and int(move[3]) - 1 == self.y + 1:
  565.                         move_possible = False
  566.                 if move_possible is True and (
  567.                         board[self.x - 1][self.y + 1] == " " or board[self.x - 1][self.y + 1][-1] != self.colour):
  568.                     self.possible_moves.append(self.translate_coordinates(self.x - 1, self.y + 1))
  569.             move_possible = True
  570.         if self.x - 1 > -1:
  571.             for move in not_possible:
  572.                 if untranslate(move[2]) == self.x - 1 and int(move[3]) - 1 == self.y:
  573.                     move_possible = False
  574.             if move_possible is True and (
  575.                     board[self.x - 1][self.y] == " " or board[self.x - 1][self.y][-1] != self.colour):
  576.                 self.possible_moves.append(self.translate_coordinates(self.x - 1, self.y))
  577.             move_possible = True
  578.             if self.y - 1 > -1:
  579.                 for move in not_possible:
  580.                     if untranslate(move[2]) == self.x - 1 and int(move[3]) - 1 == self.y - 1:
  581.                         move_possible = False
  582.                 if move_possible is True and (
  583.                         board[self.x - 1][self.y - 1] == " " or board[self.x - 1][self.y - 1][-1] != self.colour):
  584.                     self.possible_moves.append(self.translate_coordinates(self.x - 1, self.y - 1))
  585.             move_possible = True
  586.         if self.y - 1 > -1:
  587.             for move in not_possible:
  588.                 if untranslate(move[2]) == self.x and int(move[3]) - 1 == self.y - 1:
  589.                     move_possible = False
  590.             if move_possible is True and (
  591.                     board[self.x][self.y - 1] == " " or board[self.x][self.y - 1][-1] != self.colour):
  592.                 self.possible_moves.append(self.translate_coordinates(self.x, self.y - 1))
  593.         return self.possible_moves
  594.  
  595.     # this get_moves function returns all the squares the opposing king cannot go to because of the piece
  596.     def get_movesk(self, board):
  597.         self.possible_moves = []
  598.         for i in range(3):
  599.             self.possible_moves.append(self.translate_coordinates(self.x + i - 1, self.y + 1))
  600.         for i in range(3):
  601.             self.possible_moves.append(self.translate_coordinates(self.x + i - 1, self.y - 1))
  602.         self.possible_moves.append(self.translate_coordinates(self.x + 1, self.y))
  603.         self.possible_moves.append(self.translate_coordinates(self.x - 1, self.y))
  604.         return self.possible_moves
  605.  
  606.  
  607. class queen(piece):
  608.     def __init__(self, x, y, name):
  609.         super().__init__(x, y, name)
  610.  
  611.     def get_moves(self, board, piece_list):
  612.         self.possible_moves = []
  613.         up_checker = True
  614.         right_checker = True
  615.         left_checker = True
  616.         down_checker = True
  617.         i = 1
  618.         while up_checker is True or right_checker is True or left_checker is True or down_checker is True:
  619.             if self.x + i > 7:
  620.                 right_checker = False
  621.             if self.x - i < 0:
  622.                 left_checker = False
  623.             if self.y + i > 7:
  624.                 up_checker = False
  625.             if self.y - i < 0:
  626.                 down_checker = False
  627.             if up_checker is True:
  628.                 if board[self.x][self.y + i] == " ":
  629.                     self.possible_moves.append(self.translate_coordinates(self.x, self.y + i))
  630.                 elif (board[self.x][self.y + i][-1] == "b" and self.colour == "w") or (
  631.                         board[self.x][self.y + i][-1] == "w" and self.colour == "b"):
  632.                     self.possible_moves.append(self.translate_coordinates(self.x, self.y + i))
  633.                     up_checker = False
  634.                 else:
  635.                     up_checker = False
  636.             if down_checker is True:
  637.                 if board[self.x][self.y - i] == " ":
  638.                     self.possible_moves.append(self.translate_coordinates(self.x, self.y - i))
  639.                 elif (board[self.x][self.y - i][-1] == "b" and self.colour == "w") or (
  640.                         board[self.x][self.y - i][-1] == "w" and self.colour == "b"):
  641.                     self.possible_moves.append(self.translate_coordinates(self.x, self.y - i))
  642.                     down_checker = False
  643.                 else:
  644.                     down_checker = False
  645.             if right_checker is True:
  646.                 if board[self.x + i][self.y] == " ":
  647.                     self.possible_moves.append(self.translate_coordinates(self.x + i, self.y))
  648.                 elif (board[self.x + i][self.y][-1] == "b" and self.colour == "w") or (
  649.                         board[self.x + i][self.y][-1] == "w" and self.colour == "b"):
  650.                     self.possible_moves.append(self.translate_coordinates(self.x + i, self.y))
  651.                     right_checker = False
  652.                 else:
  653.                     right_checker = False
  654.             if left_checker is True:
  655.                 if board[self.x - i][self.y] == " ":
  656.                     self.possible_moves.append(self.translate_coordinates(self.x - i, self.y))
  657.                 elif (board[self.x - i][self.y][-1] == "b" and self.colour == "w") or (
  658.                         board[self.x - i][self.y][-1] == "w" and self.colour == "b"):
  659.                     self.possible_moves.append(self.translate_coordinates(self.x - i, self.y))
  660.                     left_checker = False
  661.                 else:
  662.                     left_checker = False
  663.             i += 1
  664.         looping = True
  665.         i = 1
  666.         while looping is True:
  667.             if self.x + i >= 8 or self.y + i >= 8:
  668.                 looping = False
  669.             elif board[self.x + i][self.y + i] == " ":
  670.                 self.possible_moves.append(self.translate_coordinates(self.x + i, self.y + i))
  671.             elif (board[self.x + i][self.y + i][-1] == "b" and self.colour == "w") | \
  672.                     (board[self.x + i][self.y + i][-1] == "w" and self.colour == "b"):
  673.                 self.possible_moves.append(self.translate_coordinates(self.x + i, self.y + i))
  674.                 looping = False
  675.             else:
  676.                 looping = False
  677.             i += 1
  678.         looping = True
  679.         i = 1
  680.         while looping is True:
  681.             if self.x + i >= 8 or self.y - i <= -1:
  682.                 looping = False
  683.             elif board[self.x + i][self.y - i] == " ":
  684.                 self.possible_moves.append(self.translate_coordinates(self.x + i, self.y - i))
  685.             elif (board[self.x + i][self.y - i][-1] == "b" and self.colour == "w") | \
  686.                     (board[self.x + i][self.y - i][-1] == "w" and self.colour == "b"):
  687.                 self.possible_moves.append(self.translate_coordinates(self.x + i, self.y - i))
  688.                 looping = False
  689.             else:
  690.                 looping = False
  691.             i += 1
  692.         looping = True
  693.         i = 1
  694.         while looping is True:
  695.             if self.x - i <= -1 or self.y + i >= 8:
  696.                 looping = False
  697.             elif board[self.x - i][self.y + i] == " ":
  698.                 self.possible_moves.append(self.translate_coordinates(self.x - i, self.y + i))
  699.             elif (board[self.x - i][self.y + i][-1] == "b" and self.colour == "w") | \
  700.                     (board[self.x - i][self.y + i][-1] == "w" and self.colour == "b"):
  701.                 self.possible_moves.append(self.translate_coordinates(self.x - i, self.y + i))
  702.                 looping = False
  703.             else:
  704.                 looping = False
  705.             i += 1
  706.         looping = True
  707.         i = 1
  708.         while looping is True:
  709.             if self.x - i <= -1 or self.y - i <= -1:
  710.                 looping = False
  711.             elif board[self.x - i][self.y - i] == " ":
  712.                 self.possible_moves.append(self.translate_coordinates(self.x - i, self.y - i))
  713.             elif (board[self.x - i][self.y - i][-1] == "b" and self.colour == "w") | \
  714.                     (board[self.x - i][self.y - i][-1] == "w" and self.colour == "b"):
  715.                 self.possible_moves.append(self.translate_coordinates(self.x - i, self.y - i))
  716.                 looping = False
  717.             else:
  718.                 looping = False
  719.             i += 1
  720.         return self.possible_moves
  721.  
  722.     # this get_moves function returns all the squares the opposing king cannot go to because of the piece
  723.     def get_movesk(self, board):
  724.         self.possible_moves = []
  725.         up_checker = True
  726.         right_checker = True
  727.         left_checker = True
  728.         down_checker = True
  729.         i = 1
  730.         while up_checker is True or right_checker is True or left_checker is True or down_checker is True:
  731.             if self.x + i > 7:
  732.                 right_checker = False
  733.             if self.x - i < 0:
  734.                 left_checker = False
  735.             if self.y + i > 7:
  736.                 up_checker = False
  737.             if self.y - i < 0:
  738.                 down_checker = False
  739.             if up_checker is True:
  740.                 if board[self.x][self.y + i] == " ":
  741.                     self.possible_moves.append(self.translate_coordinates(self.x, self.y + i))
  742.                 else:
  743.                     self.possible_moves.append(self.translate_coordinates(self.x, self.y + i))
  744.                     up_checker = False
  745.             if down_checker is True:
  746.                 if board[self.x][self.y - i] == " ":
  747.                     self.possible_moves.append(self.translate_coordinates(self.x, self.y - i))
  748.                 else:
  749.                     self.possible_moves.append(self.translate_coordinates(self.x, self.y - i))
  750.                     down_checker = False
  751.             if right_checker is True:
  752.                 if board[self.x + i][self.y] == " ":
  753.                     self.possible_moves.append(self.translate_coordinates(self.x + i, self.y))
  754.                 else:
  755.                     self.possible_moves.append(self.translate_coordinates(self.x + i, self.y))
  756.                     right_checker = False
  757.             if left_checker is True:
  758.                 if board[self.x - i][self.y] == " ":
  759.                     self.possible_moves.append(self.translate_coordinates(self.x - i, self.y))
  760.                 else:
  761.                     self.possible_moves.append(self.translate_coordinates(self.x - i, self.y))
  762.                     left_checker = False
  763.             i += 1
  764.         looping = True
  765.         i = 1
  766.         while looping is True:
  767.             if self.x + i >= 8 or self.y + i >= 8:
  768.                 looping = False
  769.             elif board[self.x + i][self.y + i] == " ":
  770.                 self.possible_moves.append(self.translate_coordinates(self.x + i, self.y + i))
  771.             else:
  772.                 self.possible_moves.append(self.translate_coordinates(self.x + i, self.y + i))
  773.                 looping = False
  774.             i += 1
  775.         looping = True
  776.         i = 1
  777.         while looping is True:
  778.             if self.x + i >= 8 or self.y - i <= -1:
  779.                 looping = False
  780.             elif board[self.x + i][self.y - i] == " ":
  781.                 self.possible_moves.append(self.translate_coordinates(self.x + i, self.y - i))
  782.             else:
  783.                 self.possible_moves.append(self.translate_coordinates(self.x + i, self.y - i))
  784.                 looping = False
  785.             i += 1
  786.         looping = True
  787.         i = 1
  788.         while looping is True:
  789.             if self.x - i <= -1 or self.y + i >= 8:
  790.                 looping = False
  791.             elif board[self.x - i][self.y + i] == " ":
  792.                 self.possible_moves.append(self.translate_coordinates(self.x - i, self.y + i))
  793.             else:
  794.                 self.possible_moves.append(self.translate_coordinates(self.x - i, self.y + i))
  795.                 looping = False
  796.             i += 1
  797.         looping = True
  798.         i = 1
  799.         while looping is True:
  800.             if self.x - i <= -1 or self.y - i <= -1:
  801.                 looping = False
  802.             elif board[self.x - i][self.y - i] == " ":
  803.                 self.possible_moves.append(self.translate_coordinates(self.x - i, self.y - i))
  804.             else:
  805.                 self.possible_moves.append(self.translate_coordinates(self.x - i, self.y - i))
  806.                 looping = False
  807.             i += 1
  808.         return self.possible_moves
  809.  
  810.  
  811. # draws the board
  812. '''
  813. def draw_board(piece_list, squares):
  814.    squares.draw(screen)
  815.    piece_list.draw(screen)
  816.  
  817.  
  818.  
  819.    for row in range(len(board)):
  820.        for col in range(len(board)):
  821.            if board[col][row] != " ":
  822.                i = load_image(board[col][row])
  823.                i = pygame.transform.scale(i, (square_size, square_size))
  824.                i.set_colorkey(WHITE)
  825.                screen.blit(i, [square_size*col + board_top_left_x, square_size*(7-row) + board_top_left_y])
  826.  
  827.  
  828.    pygame.display.flip()
  829.  
  830.  
  831. # loads an image
  832.  
  833. def load_image(name):
  834.    f = pygame.image.load(name + ".png")
  835.    return f
  836.  
  837.  
  838. # prints to the screen
  839. def printt(text, x, y, size):
  840.    font = pygame.freetype.SysFont("Calibri", size, True)
  841.    printc, rect = font.render(text, (255, 255, 255))
  842.    screen.blit(printc, (x, y))
  843. '''
  844.  
  845. # sets up the board at the start of the game
  846. def set_up_board(board):
  847.     board[0][0] = "Rw"
  848.     board[1][0] = "Nw"
  849.     board[2][0] = "Bw"
  850.     board[3][0] = "Qw"
  851.     board[4][0] = "Kw"
  852.     board[5][0] = "Bw"
  853.     board[6][0] = "Nw"
  854.     board[7][0] = "Rw"
  855.     board[0][7] = "Rb"
  856.     board[1][7] = "Nb"
  857.     board[2][7] = "Bb"
  858.     board[3][7] = "Qb"
  859.     board[4][7] = "Kb"
  860.     board[5][7] = "Bb"
  861.     board[6][7] = "Nb"
  862.     board[7][7] = "Rb"
  863.     for i in range(8):
  864.         board[i][1] = "Pw"
  865.         board[i][6] = "Pb"
  866.     return board
  867.  
  868.  
  869. # fills the piece list with the pieces at the start of the game
  870. def set_up_pieces(piece_list):
  871.     for i in range(8):
  872.         p = pawn(i, 1, "Pw")
  873.         q = pawn(i, 6, "Pb")
  874.         piece_list.add(p)
  875.         piece_list.add(q)
  876.     r = rook(0, 0, "Rw")
  877.     piece_list.add(r)
  878.     r = rook(7, 0, "Rw")
  879.     piece_list.add(r)
  880.     r = rook(0, 7, "Rb")
  881.     piece_list.add(r)
  882.     r = rook(7, 7, "Rb")
  883.     piece_list.add(r)
  884.     n = knight(1, 0, "Nw")
  885.     piece_list.add(n)
  886.     n = knight(6, 0, "Nw")
  887.     piece_list.add(n)
  888.     n = knight(1, 7, "Nb")
  889.     piece_list.add(n)
  890.     n = knight(6, 7, "Nb")
  891.     piece_list.add(n)
  892.     b = bishop(2, 0, "Bw")
  893.     piece_list.add(b)
  894.     b = bishop(5, 0, "Bw")
  895.     piece_list.add(b)
  896.     b = bishop(2, 7, "Bb")
  897.     piece_list.add(b)
  898.     b = bishop(5, 7, "Bb")
  899.     piece_list.add(b)
  900.     q = queen(3, 0, "Qw")
  901.     piece_list.add(q)
  902.     q = queen(3, 7, "Qb")
  903.     piece_list.add(q)
  904.     k = king(4, 0, "Kw")
  905.     piece_list.add(k)
  906.     k = king(4, 7, "Kb")
  907.     piece_list.add(k)
  908.     '''
  909.    for p in piece_list:
  910.        p.rect.x = p.x * square_size + board_top_left_x
  911.        p.rect.y = (7 - p.y) * square_size + board_top_left_y
  912.    '''
  913.     return piece_list
  914.  
  915.  
  916. # checks whether it's legal to castle
  917. def castling_fine(move, board, piece_list, castle_kingside, castle_queenside):
  918.     # checks kingside castling
  919.     if move[2] == "g" and \
  920.             ((move[3] == "1" and castle_kingside[0] is True) or (move[3] == "8" and castle_kingside[1] is True)):
  921.         if board[5][int(move[3]) - 1] == " " and board[6][int(move[3]) - 1] == " ":
  922.             for p in piece_list:
  923.                 if p.name[-1] == opposite(board[untranslate(move[0])][int(move[1]) - 1][-1]):
  924.                     list = p.get_moves(board, piece_list)
  925.                     for item in list:
  926.                         if (item[2] == "e" or item[2] == "f" or item[2] == "g") and item[3] == move[3]:
  927.                             return False
  928.             return True
  929.     # checks queenside castling
  930.     elif move[2] == "c" and \
  931.             ((move[3] == "1" and castle_queenside[0] is True) or (move[3] == "8" and castle_queenside[1] is True)):
  932.         if board[1][int(move[3]) - 1] == " " and \
  933.                 board[2][int(move[3]) - 1] == " " and board[3][int(move[3]) - 1] == " ":
  934.             for p in piece_list:
  935.                 if p.name[-1] == opposite(board[untranslate(move[0])][int(move[1]) - 1][-1]):
  936.                     list = p.get_moves(board, piece_list)
  937.                     for item in list:
  938.                         if (item[2] == "c" or item[2] == "d" or item[2] == "e") and item[3] == move[3]:
  939.                             return False
  940.             return True
  941.     else:
  942.         return False
  943.  
  944.  
  945. def in_check(colour, board, piece_list):
  946.     loc = find_piece("K" + colour, board)
  947.     for p in piece_list:
  948.         if p.name[-1] != colour:
  949.             for move in p.get_moves(board, piece_list):
  950.                 if untranslate(move[2]) == loc[0] and int(move[3]) - 1 == loc[1]:
  951.                     return True
  952.     return False
  953.  
  954.  
  955. def find_piece(piece, board):
  956.     for col in range(len(board)):
  957.         for row in range(len(board)):
  958.             if piece == board[col][row]:
  959.                 return [col, row]
  960.  
  961.  
  962. # changes white to black and black to white
  963. def opposite(col):
  964.     if col == "w":
  965.         return "b"
  966.     else:
  967.         return "w"
  968.  
  969.  
  970. # checks for checkmate
  971. def checkmate(colour, board, piece_list):
  972.     if in_check(colour, board, piece_list) is True:
  973.         for p in piece_list:
  974.             if p.name[-1] == colour:
  975.                 moves = p.get_moves(board, piece_list)
  976.                 for move in moves:
  977.                     piece_taken = board[untranslate(move[2])][int(move[3]) - 1]
  978.                     board[untranslate(move[2])][int(move[3]) - 1] = board[untranslate(move[0])][int(move[1]) - 1]
  979.                     board[untranslate(move[0])][int(move[1]) - 1] = " "
  980.                     p.x = untranslate(move[2])
  981.                     p.y = int(move[3]) - 1
  982.                     if in_check(colour, board, piece_list) is True:
  983.                         pass
  984.                     else:
  985.                         board[untranslate(move[0])][int(move[1]) - 1] = board[untranslate(move[2])][int(move[3]) - 1]
  986.                         board[untranslate(move[2])][int(move[3]) - 1] = piece_taken
  987.                         p.x = untranslate(move[0])
  988.                         p.y = int(move[1]) - 1
  989.                         return False
  990.                     board[untranslate(move[0])][int(move[1]) - 1] = board[untranslate(move[2])][int(move[3]) - 1]
  991.                     board[untranslate(move[2])][int(move[3]) - 1] = piece_taken
  992.                     p.x = untranslate(move[0])
  993.                     p.y = int(move[1]) - 1
  994.         return True
  995.     return False
  996.  
  997.  
  998. # checks for a draw by stalemate
  999. def stalemate(colour, board, piece_list):
  1000.     if in_check(colour, board, piece_list) is True:
  1001.         return False
  1002.     for p in piece_list:
  1003.         if p.name[-1] == colour:
  1004.             moves = p.get_moves(board, piece_list)
  1005.             for move in moves:
  1006.                 piece_taken = board[untranslate(move[2])][int(move[3]) - 1]
  1007.                 board[untranslate(move[2])][int(move[3]) - 1] = board[untranslate(move[0])][int(move[1]) - 1]
  1008.                 board[untranslate(move[0])][int(move[1]) - 1] = " "
  1009.                 p.x = untranslate(move[2])
  1010.                 p.y = int(move[3]) - 1
  1011.                 if in_check(colour, board, piece_list) is True:
  1012.                     pass
  1013.                 else:
  1014.                     board[untranslate(move[0])][int(move[1]) - 1] = board[untranslate(move[2])][int(move[3]) - 1]
  1015.                     board[untranslate(move[2])][int(move[3]) - 1] = piece_taken
  1016.                     p.x = untranslate(move[0])
  1017.                     p.y = int(move[1]) - 1
  1018.                     return False
  1019.                 board[untranslate(move[0])][int(move[1]) - 1] = board[untranslate(move[2])][int(move[3]) - 1]
  1020.                 board[untranslate(move[2])][int(move[3]) - 1] = piece_taken
  1021.                 p.x = untranslate(move[0])
  1022.                 p.y = int(move[1]) - 1
  1023.     return True
  1024.  
  1025.  
  1026. # checks for a draw by lack of material
  1027. def draw_by_lack_of_material(board):
  1028.     pieces = []
  1029.     minor_pieces = [0, 0]
  1030.     for col in board:
  1031.         for squ in col:
  1032.             if squ != " ":
  1033.                 pieces.append(squ)
  1034.     for p in pieces:
  1035.         if p[0] == "Q" or p[0] == "R" or p[0] == "P":
  1036.             return False
  1037.         elif p[0] == "N" or p[0] == "B":
  1038.             if p[-1] == "w":
  1039.                 minor_pieces[0] += 1
  1040.             else:
  1041.                 minor_pieces[1] += 1
  1042.     if minor_pieces[0] > 2 or minor_pieces[1] > 2:
  1043.         return False
  1044.     if minor_pieces[0] == 2 or minor_pieces[1] == 2:
  1045.         for p in pieces:
  1046.             if p[0] == "B":
  1047.                 if p[-1] == "w":
  1048.                     if minor_pieces[0] == 2:
  1049.                         return False
  1050.                 else:
  1051.                     if minor_pieces[1] == 2:
  1052.                         return False
  1053.     return True
  1054.  
  1055.  
  1056. # compares past boards in order to detect draw by repetition
  1057. '''
  1058. def comp_past_boards(past_boards, board):
  1059.    board_checker = True
  1060.    same_boards = 1
  1061.    for past_board in past_boards:
  1062.        for i in range(len(board)):
  1063.            for j in range(len(board)):
  1064.                if past_board[i][j] == board[i][j]:
  1065.                    pass
  1066.                else:
  1067.                    board_checker = False
  1068.                    i = len(board)
  1069.                    j = len(board)
  1070.        if board_checker is True:
  1071.            same_boards += 1
  1072.        else:
  1073.            board_checker = True
  1074.    if same_boards > 2:
  1075.        return True
  1076.    else:
  1077.        return False
  1078. '''
  1079.  
  1080.  
  1081. def main():
  1082.     # squares = pygame.sprite.Group()
  1083.     # col = BLACK
  1084.     board = []
  1085.     piece_list = pygame.sprite.Group()
  1086.     player_to_move = "w"
  1087.     game_over = False
  1088.     castle_kingside = []
  1089.     castle_queenside = []
  1090.     e_p_checker = en_passant()
  1091.     # past_board_list = []
  1092.     # i = Input()
  1093.     # i.start()
  1094.     move_counter = 0  # counts moves made without a pawn move or a take (for 50 move draw rule)
  1095.     for i in range(2):
  1096.         castle_queenside.append(True)
  1097.         castle_kingside.append(True)
  1098.  
  1099.     move_made = False
  1100.     # sets up squares
  1101.     '''
  1102.    for i in range(8):
  1103.        for j in range(8):
  1104.            if col == BLACK:
  1105.                col = WHITE
  1106.            else:
  1107.                col = BLACK
  1108.            x = i*square_size + board_top_left_x
  1109.            y = j*square_size + board_top_left_y
  1110.            s = square(col)
  1111.            s.rect.x = x
  1112.            s.rect.y = y
  1113.            squares.add(s)
  1114.        if col == BLACK:
  1115.            col = WHITE
  1116.        else:
  1117.            col = BLACK
  1118.    '''
  1119.     for i in range(8):
  1120.         a = []
  1121.         # Adds blank spaces to the board
  1122.         for j in range(8):
  1123.             a.append(' ')
  1124.         board.append(a)
  1125.  
  1126.     board = set_up_board(board)
  1127.     # past_board_list.append(board)
  1128.     piece_list = set_up_pieces(piece_list)
  1129.     # main game loop
  1130.     while game_over is False:
  1131.         '''
  1132.        while pygame.mouse.get_pressed() == 0:
  1133.            pygame.mouse.get_pos()
  1134.        p1 = pygame.mouse.get_pos()
  1135.        while pygame.mouse.get_pressed() == 0:
  1136.            pygame.mouse.get_pos()
  1137.        p2 = pygame.mouse.get_pos()
  1138.        ans = str((p1[0] - board_top_left_x)//square_size + 1) + str((p1[1] - board_top_left_y)//square_size + 1) + \
  1139.            str((p2[0] - board_top_left_x) // square_size + 1) + str((p2[1] - board_top_left_y) // square_size + 1)
  1140.        if ans[0] + ans[1] == ans[2] + ans[3] and board[untranslate(ans[0])][int(ans[1])][0] == "K":
  1141.            ans = "resign"
  1142.        for event in pygame.event.get():
  1143.            if event.type == pygame.QUIT:
  1144.                game_over = True
  1145.        '''
  1146.         if player_to_move == "w":
  1147.             for i in range(len(board)):
  1148.                 print(8-i, end=" ")
  1149.                 for j in range(len(board)):
  1150.                     print(board[j][7-i], end=" ")
  1151.                     if board[j][7-i] == " ":
  1152.                         print(" ", end="")
  1153.                 print()
  1154.             print(" ", end=" ")
  1155.             for i in range(8):
  1156.                 print(chr(i + 97), end="  ")
  1157.             print()
  1158.         else:
  1159.             for i in range(len(board)):
  1160.                 print(i + 1, end=" ")
  1161.                 for j in range(len(board)):
  1162.                     print(board[7-j][i], end=" ")
  1163.                     if board[7-j][i] == " ":
  1164.                         print(" ", end="")
  1165.                 print()
  1166.             print(" ", end=" ")
  1167.             for i in range(8):
  1168.                 print(chr(104 - i), end="  ")
  1169.             print()
  1170.         # draw_board(piece_list, squares)
  1171.         # answered = False
  1172.         print("What move would you like to do?")
  1173.         ans = input()
  1174.         '''
  1175.        while not answered:
  1176.            try:
  1177.                ans = commands.get(False)
  1178.                answered = True
  1179.            except queue.Empty:
  1180.                ans = None
  1181.        '''
  1182.         if ans == "resign":
  1183.             game_over = True
  1184.             move_made = True
  1185.         if len(ans) == 4:
  1186.             for p in piece_list:
  1187.                 if p.x == ord(ans[0]) - 97 and p.y == int(ans[1]) - 1:
  1188.                     # checks for the majority of moves
  1189.                     if p.move_is_possible(board, ans, piece_list) is True and p.name[-1] == player_to_move:
  1190.                         board[p.x][p.y] = " "
  1191.                         p.x = untranslate(ans[2])
  1192.                         p.y = int(ans[3]) - 1
  1193.                         piece_taken = board[p.x][p.y]
  1194.                         board[p.x][p.y] = p.name
  1195.                         move_made = True
  1196.                         # reverses the move if the king is in check
  1197.                         if in_check(player_to_move, board, piece_list) is True:
  1198.                             print("Cannot do that move: you're in check.")
  1199.                             board[p.x][p.y] = piece_taken
  1200.                             p.x = untranslate(ans[0])
  1201.                             p.y = int(ans[1]) + 1
  1202.                             board[p.x][p.y] = p.name
  1203.                             move_made = False
  1204.                         else:
  1205.                             e_p_checker.double_move = False
  1206.                             if p.name[0] == "P" and int(ans[3]) == int(ans[1]) + 2:
  1207.                                 e_p_checker.double_move = True
  1208.                                 e_p_checker.file = ans[0]
  1209.                             # takes the piece if there is a piece there
  1210.                             for p2 in piece_list:
  1211.                                 if p2.x == p.x and p2.y == p.y and p2.name != p.name:
  1212.                                     p2.kill()
  1213.                                     move_counter = 0
  1214.                             # makes it impossible to castle if the king or rook moves
  1215.                             if p.name[0] == "K":
  1216.                                 if p.name[1] == "w":
  1217.                                     castle_queenside[0] = False
  1218.                                     castle_kingside[0] = False
  1219.                                 else:
  1220.                                     castle_queenside[1] = False
  1221.                                     castle_kingside[1] = False
  1222.                             elif p.name[0] == "R":
  1223.                                 if p.x == 0:
  1224.                                     if p.name[1] == "w" and p.y == 0:
  1225.                                         castle_queenside[0] = False
  1226.                                     elif p.name[1] == "b" and p.y == 7:
  1227.                                         castle_queenside[1] = False
  1228.                                 elif p.x == 7:
  1229.                                     if p.name[1] == "w" and p.y == 0:
  1230.                                         castle_kingside[0] = False
  1231.                                     elif p.name[1] == "b" and p.y == 7:
  1232.                                         castle_kingside[1] = False
  1233.                             # checks for promotion
  1234.                             if p.name[0] == "P" and (p.y == 7 or p.y == 0):
  1235.                                 print("What piece would you like? Please put R, N, B or Q.")
  1236.                                 prom = input()
  1237.                                 if prom == "R":
  1238.                                     prom_piece = rook(p.x, p.y, "R" + p.name[-1])
  1239.                                     piece_list.add(prom_piece)
  1240.                                     board[p.x][p.y] = prom_piece.name
  1241.                                     p.kill()
  1242.                                 if prom == "N":
  1243.                                     prom_piece = knight(p.x, p.y, "N" + p.name[-1])
  1244.                                     piece_list.add(prom_piece)
  1245.                                     board[p.x][p.y] = prom_piece.name
  1246.                                     p.kill()
  1247.                                 if prom == "B":
  1248.                                     prom_piece = bishop(p.x, p.y, "B" + p.name[-1])
  1249.                                     piece_list.add(prom_piece)
  1250.                                     board[p.x][p.y] = prom_piece.name
  1251.                                     p.kill()
  1252.                                 if prom == "Q":
  1253.                                     prom_piece = queen(p.x, p.y, "Q" + p.name[-1])
  1254.                                     piece_list.add(prom_piece)
  1255.                                     board[p.x][p.y] = prom_piece.name
  1256.                                     p.kill()
  1257.                     # checks if the move is a castle
  1258.                     elif p.name[0] == "K" and \
  1259.                             castling_fine(ans, board, piece_list, castle_kingside, castle_queenside) is True:
  1260.                         board[p.x][p.y] = " "
  1261.                         if untranslate(ans[2]) == p.x + 2:
  1262.                             p.x = p.x + 2
  1263.                             for p2 in piece_list:
  1264.                                 if p2.x == p.x + 1 and p2.y == p.y:
  1265.                                     p2.x = p.x - 1
  1266.                                     board[p.x - 1][p.y] = p2.name
  1267.                                     board[p.x + 1][p.y] = " "
  1268.                             board[p.x][p.y] = p.name
  1269.                             move_made = True
  1270.                             e_p_checker.double_move = False
  1271.                         elif untranslate(ans[2]) == p.x - 2:
  1272.                             p.x = p.x - 2
  1273.                             for p2 in piece_list:
  1274.                                 if p2.x == p.x - 2 and p2.y == p.y:
  1275.                                     p2.x = p.x + 1
  1276.                                     board[p.x + 1][p.y] = p2.name
  1277.                                     board[p.x - 2][p.y] = " "
  1278.                             board[p.x][p.y] = p.name
  1279.                             move_made = True
  1280.                             e_p_checker.double_move = False
  1281.                     # checks for en passant capture
  1282.                     elif p.name[0] == "P" and e_p_checker.double_move is True and \
  1283.                             ((p.y == 4 and p.name[-1] == "w") or (p.y == 3 and p.name[-1] == "b")):
  1284.                         if untranslate(e_p_checker.file) == p.x + 1:
  1285.                             if ans[2] == e_p_checker.file:
  1286.                                 e_p_checker.double_move = False
  1287.                                 board[p.x][p.y] = " "
  1288.                                 board[p.x + 1][p.y] = " "
  1289.                                 if p.name[-1] == "w":
  1290.                                     board[p.x + 1][p.y + 1] = p.name
  1291.                                 else:
  1292.                                     board[p.x + 1][p.y - 1] = p.name
  1293.                                 if in_check(p.name[-1], board, piece_list) is True:
  1294.                                     board[p.x][p.y] = p.name
  1295.                                     board[p.x + 1][p.y] = p.name[0] + opposite(p.name[-1])
  1296.                                     board[p.x + 1][p.y + 1] = " "
  1297.                                 else:
  1298.                                     for p2 in piece_list:
  1299.                                         if p2.x == p.x + 1 and p2.y == p.y:
  1300.                                             p2.kill()
  1301.                                     p.x += 1
  1302.                                     p.y += 1
  1303.                                     move_made = True
  1304.                                 e_p_checker.double_move = False
  1305.                         elif untranslate(e_p_checker.file) == p.x - 1:
  1306.                             if ans[2] == e_p_checker.file:
  1307.                                 e_p_checker.double_move = False
  1308.                                 for p2 in piece_list:
  1309.                                     if p2.x == p.x - 1 and p2.y == p.y:
  1310.                                         p2.kill()
  1311.                                 p.x -= 1
  1312.                                 p.y += 1
  1313.                                 move_made = True
  1314.                                 e_p_checker.double_move = False
  1315.         if ans == "draw":
  1316.             move_made = True
  1317.             game_over = True
  1318.             print("Draw agreed")
  1319.         if move_made is False:
  1320.             print("Move not possible")
  1321.         else:
  1322.             if player_to_move == "w":
  1323.                 player_to_move = "b"
  1324.             else:
  1325.                 player_to_move = "w"
  1326.             if game_over is False:
  1327.                 # these check for the various possible endings to the game
  1328.                 if checkmate(player_to_move, board, piece_list) is True:
  1329.                     print("Checkmate!")
  1330.                     if player_to_move == "b":
  1331.                         print("White wins!!")
  1332.                     else:
  1333.                         print("Black wins!!")
  1334.                     game_over = True
  1335.                 elif in_check(player_to_move, board, piece_list) is True:
  1336.                     print("Check!!")
  1337.                 if stalemate(player_to_move, board, piece_list) is True:
  1338.                     print("Stalemate!")
  1339.                     game_over = True
  1340.                 if board[untranslate(ans[2])][int(ans[3]) - 1][0] == "P":
  1341.                     move_counter = 0
  1342.                 else:
  1343.                     move_counter += 0.5
  1344.                     if move_counter == 50:
  1345.                         print("Draw: 50 moves without capture or pawn move")
  1346.                         game_over = True
  1347.                 '''
  1348.                if comp_past_boards(past_board_list, board) is True:
  1349.                    print("Draw by repetition")
  1350.                    game_over = True
  1351.                past_board_list.append(board)
  1352.                '''
  1353.                 if draw_by_lack_of_material(board) is True:
  1354.                     print("Draw by lack of material")
  1355.                     game_over = True
  1356.             else:
  1357.                 if player_to_move == "b":
  1358.                     print("Black wins!!")
  1359.                 else:
  1360.                     print("White wins!!")
  1361.             move_made = False
  1362.  
  1363.  
  1364. main()
  1365. '''
  1366.  
  1367. import pygame
  1368. import time
  1369. import os
  1370. import threading
  1371. import queue
  1372.  
  1373. pygame.init()
  1374.  
  1375. BLACK = (255, 0, 0)
  1376. WHITE = (255, 255, 255)
  1377. screen_width = 800
  1378. screen_height = 600
  1379. board_top_left_x = screen_width//5
  1380. board_top_left_y = screen_height//10
  1381. square_size = screen_height//10
  1382. screen = pygame.display.set_mode([screen_width, screen_height])
  1383. os.environ['SDL_VIDEO_WINDOWS_POS'] = '10, 10'
  1384. commands = queue.Queue
  1385.  
  1386.  
  1387. class Input(threading.Thread):
  1388.    def run(self):
  1389.        while True:
  1390.            command = input()
  1391.            commands.put(command)
  1392.  
  1393.  
  1394. class square(pygame.sprite.Sprite):
  1395.    def __init__(self, colour):
  1396.        super().__init__()
  1397.        self.image = pygame.Surface([square_size, square_size])
  1398.        self.rect = self.image.get_rect()
  1399.        pygame.draw.rect(self.image, colour, [0, 0, square_size, square_size])
  1400.        self.colour = colour
  1401.  
  1402.  
  1403. def load_image(name):
  1404.    f = pygame.image.load(name + ".png")
  1405.    return f
  1406.  
  1407.  
  1408. def set_up_board(board):
  1409.    board[0][0] = "Rw"
  1410.    board[1][0] = "Nw"
  1411.    board[2][0] = "Bw"
  1412.    board[3][0] = "Qw"
  1413.    board[4][0] = "Kw"
  1414.    board[5][0] = "Bw"
  1415.    board[6][0] = "Nw"
  1416.    board[7][0] = "Rw"
  1417.    board[0][7] = "Rb"
  1418.    board[1][7] = "Nb"
  1419.    board[2][7] = "Bb"
  1420.    board[3][7] = "Qb"
  1421.    board[4][7] = "Kb"
  1422.    board[5][7] = "Bb"
  1423.    board[6][7] = "Nb"
  1424.    board[7][7] = "Rb"
  1425.    for i in range(8):
  1426.        board[i][1] = "Pw"
  1427.        board[i][6] = "Pb"
  1428.    return board
  1429.  
  1430.  
  1431. def draw_board(board, squares):
  1432.    squares.draw(screen)
  1433.    for row in range(len(board)):
  1434.        for col in range(len(board)):
  1435.            if board[col][row] != " ":
  1436.                i = load_image(board[col][row])
  1437.                i = pygame.transform.scale(i, (square_size, square_size))
  1438.                i.set_colorkey(WHITE)
  1439.                screen.blit(i, [square_size*col + board_top_left_x, square_size*(7-row) + board_top_left_y])
  1440.    pygame.display.flip()
  1441.  
  1442.  
  1443. def main():
  1444.    squares = pygame.sprite.Group()
  1445.    col = BLACK
  1446.    I = Input()
  1447.    I.start()
  1448.    for i in range(8):
  1449.        for j in range(8):
  1450.            if col == BLACK:
  1451.                col = WHITE
  1452.            else:
  1453.               col = BLACK
  1454.            x = i*square_size + board_top_left_x
  1455.            y = j*square_size + board_top_left_y
  1456.            s = square(col)
  1457.            s.rect.x = x
  1458.            s.rect.y = y
  1459.            squares.add(s)
  1460.        if col == BLACK:
  1461.            col = WHITE
  1462.        else:
  1463.            col = BLACK
  1464.    board = []
  1465.    for i in range(8):
  1466.        a = []
  1467.        for j in range(8):
  1468.            a.append(' ')
  1469.        board.append(a)
  1470.    board = set_up_board(board)
  1471.    draw_board(board, squares)
  1472.    print("What move do you want to make?")
  1473.    answered = False
  1474.    while not answered:
  1475.        try:
  1476.            ans = commands.get(False)
  1477.            answered = True
  1478.        except queue.Empty:
  1479.            ans = None
  1480.    board[ord(ans[2]) - 97][int(ans[3]) - 1] = board[ord(ans[0]) - 97][int(ans[1]) - 1]
  1481.    board[ord(ans[0]) - 97][int(ans[1]) - 1] = " "
  1482.    draw_board(board, squares)
  1483.    time.sleep(5)
  1484.  
  1485.  
  1486. main()
  1487. '''
  1488.