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.to_column)
        self.board.boardlist[self.to_row][self.to_column].piece.moved = True
        self.board.boardlist[self.to_row][self.to_column].piece.delete_moves()
        return self.board.boardlist[self.to_row][self.to_column].piece.color

    def move_boot(self, color):
        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, self.final_column)
        #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].piece != None:
                    if self.board.boardlist[r][c].piece.color != color:
                        self.boot_piece.append(self.board.boardlist[r][c])
        #random piece with valid_moves>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]
        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.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, final_column):
        if isinstance(x, Pawn):
            if (final_row==0) or (final_row==7):
                self.board.boardlist[final_row][final_column].piece = Queen(x.color)
    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(final_column, final_row)
                #print(x)
                #print(x.color)
                #print(self.board.boardlist[final_row][final_column].piece.color)
                self.board.boardlist[final_row][final_column].piece = x
                exit(0)
    @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