Szachy/move.py

from board import Board
from square import Square
from pawn import Pawn
from knight import Knight
from bishop import Bishop
from rook import Rook
from queen import Queen
from king import King
import random

class Move:
    def move_rival(self, ruch):
        self.from_column = Move.letters_to__numbers(ruch[0])
        self.from_row = int(ruch[1])
        self.to_column = Move.letters_to__numbers(ruch[3])
        self.to_row = int(ruch[4])

        #update board
        self.x = self.board.boardlist[self.from_row][self.from_column].piece
        self.board.boardlist[self.from_row][self.from_column].piece = None
        #Move.mat(self, self.x, self.to_row, self.to_column)
        self.board.boardlist[self.to_row][self.to_column].piece = self.x
        Move.pawn_promotion(self, self.x, self.to_row)
        self.board.boardlist[self.to_row][self.to_column].piece.moved = True
        return self.board.boardlist[self.to_row][self.to_column].piece.color

    def move_boot(self, color): #kolor przeciwnika
        self.x, self.initial_row, self.initial_column, self.final_row, self.final_column = Move.random_valid_move(self, color)
        self.board.boardlist[self.initial_row][self.initial_column].piece = None
        Move.mat(self, self.x, self.final_row, self.final_column)
        self.board.boardlist[self.final_row][self.final_column].piece = self.x

        Move.pawn_promotion(self, self.x, self.final_row)
        # update piece
        self.board.boardlist[self.final_row][self.final_column].piece.moved = True
        self.board.boardlist[self.final_row][self.final_column].piece.delete_moves()

        self.initial_column = Move.numbers_to_letters(self.initial_column)
        self.final_column = Move.numbers_to_letters(self.final_column)
        self.ruch = str(self.initial_column) + str(self.initial_row) + ' ' + str(self.final_column) + str(
            self.final_row)
        return self.ruch

    def random_valid_move(self, color):
        self.boot_piece = []
        self.piece_row_column = []
        for r in range(0, 8):
            for c in range(0, 8):
                if self.board.boardlist[r][c].has_piece():
                    if self.board.boardlist[r][c].piece.color != color:
                        self.kopia = []
                        for move in self.board.boardlist[r][c].piece.valid_moves:
                            if Move.check_szach(self, color, r, c, move[0], move[1]) is False:
                                self.kopia.append(move)
                        self.board.boardlist[r][c].piece.valid_moves=self.kopia
        for xddr in range(8):
            for xddc in range(8):
                if self.board.boardlist[xddr][xddc].has_piece() and self.board.boardlist[xddr][xddc].piece.color!=color:
                    if (len(self.board.boardlist[xddr][xddc].piece.valid_moves)>0):
                        self.boot_piece.append(self.board.boardlist[xddr][xddc])
        if (len(self.boot_piece)==0):
            print("MAT")
            exit(0)
        self.value = random.randrange(0, len(self.boot_piece))
        self.initial_piece = self.boot_piece[self.value]
        while len(self.initial_piece.piece.valid_moves) == 0:
            self.value = random.randrange(0, len(self.boot_piece))
            self.initial_piece = self.boot_piece[self.value]
        print(self.initial_piece.row, self.initial_piece.column)
        self.move_initial_row = self.initial_piece.row
        self.move_initial_column = self.initial_piece.column
        #random move for piece
        self.value = random.randrange(0, len(self.initial_piece.piece.valid_moves))
        self.move_final = self.initial_piece.piece.valid_moves[self.value]

        self.move_final_row = self.move_final[0]
        self.move_final_column = self.move_final[1]
        self.x = self.board.boardlist[self.move_initial_row][self.move_initial_column].piece

        return self.x, self.move_initial_row, self.move_initial_column, self. move_final_row, self.move_final_column

    def calc_moves(self, piece, row, column):
        #piece.delete_moves()
        piece.valid_moves=[]
        if piece.name == 'rook':
            Rook.straightline_moves(self, piece, row, column,True)
            pass
        elif piece.name == 'pawn':
            Pawn.pawn_moves(self, piece, row, column)
            pass
        elif piece.name == 'knight':
            Knight.knight_moves(self, piece, row, column)
        elif piece.name == 'bishop':
            pass
            Bishop.straightline_moves(self, piece, row, column,False)
        elif piece.name == 'queen':
            pass
            Queen.straightline_moves(self, piece, row, column,True)
            Queen.straightline_moves(self, piece, row, column,False)
        elif piece.name == 'king':
            King.king_moves(self, piece, row, column)
            pass

    def pawn_promotion(self, x, final_row):
        if x.name == "pawn":
            if (final_row == 0) or (final_row == 7):
                x.name == "queen"
    def mat(self, x, final_row, final_column):
        if self.board.boardlist[final_row][final_column].has_piece():
            if self.board.boardlist[final_row][final_column].piece.name == 'king':

                print("MAT")
                exit(0)
        pass

    def check_szach(self, color, initial_row, initial_column, final_row, final_column):#kolor przeciwnika

        self.piece = self.board.boardlist[initial_row][initial_column].piece
        self.previous_piece = self.board.boardlist[final_row][final_column].piece
        self.board.boardlist[initial_row][initial_column].piece = None
        self.board.boardlist[final_row][final_column].piece = self.piece
        for rowxd in range(8):
            for columnxd in range(8):
                if self.board.boardlist[rowxd][columnxd].has_piece():
                    if self.board.boardlist[rowxd][columnxd].piece.color == color:
                        Move.calc_moves(self, self.board.boardlist[rowxd][columnxd].piece, rowxd, columnxd)
        for r1 in range(8):
            for c1 in range(8):
                if self.board.boardlist[r1][c1].has_piece():
                    if self.board.boardlist[r1][c1].piece.name=='king' and self.board.boardlist[r1][c1].piece.color != color:
                        self.king_position= (r1,c1)
        #tu skonczylas
        for r2 in range(8):
            for c2 in range(8):
                if self.board.boardlist[r2][c2].has_piece():
                    if self.board.boardlist[r2][c2].piece.color == color:
                        if self.king_position in self.board.boardlist[r2][c2].piece.valid_moves:
                            self.board.boardlist[final_row][final_column].piece=self.previous_piece
                            self.board.boardlist[initial_row][initial_column].piece= self.piece
                            #print("XXXXXXXXXXXXXXXXXXX")
                            for rowxd2 in range(8):
                                for columnxd2 in range(8):
                                    if self.board.boardlist[rowxd2][columnxd2].has_piece():
                                        if self.board.boardlist[rowxd2][columnxd2].piece.color == color:
                                            Move.calc_moves(self, self.board.boardlist[rowxd2][columnxd2].piece, rowxd2,columnxd2)
                            #print("valid moves przeciwnika")
                            #print(self.board.boardlist[r2][c2].piece.valid_moves)
                            return True

        self.board.boardlist[final_row][final_column].piece = self.previous_piece
        self.board.boardlist[initial_row][initial_column].piece = self.piece
        for rowxd in range(8):
            for columnxd in range(8):
                if self.board.boardlist[rowxd][columnxd].has_piece():
                    if self.board.boardlist[rowxd][columnxd].has_piece():
                        if self.board.boardlist[rowxd][columnxd].piece.color == color:
                            Move.calc_moves(self, self.board.boardlist[rowxd][columnxd].piece, rowxd, columnxd)
        return False



    @staticmethod
    def numbers_to_letters(number):
        if number == 0:
            number = "A"
        elif number == 1:
            number = "B"
        elif number == 2:
            number = "C"
        elif number == 3:
            number = "D"
        elif number == 4:
            number = "E"
        elif number == 5:
            number = "F"
        elif number == 6:
            number = "G"
        elif number == 7:
            number = "H"
        return number

    @staticmethod
    def letters_to__numbers(letter):
        if letter == 'A':
            letter = 0
        elif letter == 'B':
            letter = 1
        elif letter == 'C':
            letter = 2
        elif letter == 'D':
            letter = 3
        elif letter == 'E':
            letter = 4
        elif letter == 'F':
            letter = 5
        elif letter == 'G':
            letter = 6
        elif letter == 'H':
            letter = 7
        return letter