Enhance the chess engine, and explicitly state it to it's full application based-off the description.

Description: "Grandleader Chess Engine Is A Very Refined Grandmaster Engine. It'll use multiple engines to calculate it's best moves whilst also iterating it for maximum depth, it has a special property which is Latent [Unified] Tuning Data which is like stockfish tuning method but different. It also has a set of it's own properties which is; Transposition Tables, Efficient Move Ordering, Parallel Processing, Reinforcement Deep PVS, and Cache and Memory Management. It has a special main component which is better derived than anything else = 'True Leading Automatic Move-Generation'."

```
import pygame
import chess
import chess.engine
import chess.polyglot
import random
import time
import multiprocessing
import numpy as np
from collections import OrderedDict

# Constants
BOARD_SIZE = 800
SQUARE_SIZE = BOARD_SIZE // 8
WHITE = (255, 255, 255)
BLACK = (0, 0, 0)
LIGHT_SQUARE_COLOR = (240, 217, 181)
DARK_SQUARE_COLOR = (181, 136, 99)
HIGHLIGHT_COLOR = (255, 0, 0)
MOVE_HIGHLIGHT_COLOR = (0, 255, 0)
STALLED_COLOR = (255, 165, 0)

# Paths (update these to your actual paths)
STOCKFISH_PATH = r"path/to/stockfish"
LC0_PATH = r"path/to/lc0"
KOMODO_PATH = r"path/to/komodo"
OPENING_BOOK_PATH = r"path/to/opening_book.bin"

class TranspositionTable:
    def __init__(self, size=1000000):
        self.table = OrderedDict()
        self.max_size = size

    def store(self, key, value):
        if len(self.table) >= self.max_size:
            self.table.popitem(last=False)
        self.table[key] = value

    def lookup(self, key):
        return self.table.get(key, None)

class MoveOrderer:
    def __init__(self):
        self.move_scores = {}

    def score_move(self, move, board):
        if move in self.move_scores:
            return self.move_scores[move]

        score = 0
        piece = board.piece_at(move.from_square)
        capture = board.piece_at(move.to_square)

        if capture:
            score += 10 * capture.piece_type - piece.piece_type

        if move.promotion:
            score += 900

        if board.is_check():
            score += 50

        self.move_scores[move] = score
        return score

    def order_moves(self, moves, board):
        return sorted(moves, key=lambda move: self.score_move(move, board), reverse=True)

class GrandLeaderChessEngine:
    def __init__(self, stockfish_path, lc0_path, komodo_path, opening_book_path):
        self.board = chess.Board()
        self.engines = [
            chess.engine.SimpleEngine.popen_uci(stockfish_path),
            chess.engine.SimpleEngine.popen_uci(lc0_path),
            chess.engine.SimpleEngine.popen_uci(komodo_path)
        ]
        self.max_depth = 20
        self.search_time = 5.0
        self.opening_book = chess.polyglot.open_reader(opening_book_path)
        self.transposition_table = TranspositionTable()
        self.move_orderer = MoveOrderer()
        self.cache = {}

    def evaluate_board(self, engine_index):
        result = self.engines[engine_index].analyse(self.board, chess.engine.Limit(time=self.search_time/3))
        return result['score'].relative.score(mate_score=10000)

    def search_best_move(self):
        best_move = None
        best_score = -float('inf')
        start_time = time.time()

        with multiprocessing.Pool(processes=len(self.engines)) as pool:
            for depth in range(1, self.max_depth + 1):
                scores = pool.map(self.evaluate_board, range(len(self.engines)))
                avg_score = sum(scores) / len(scores)

                if avg_score > best_score:
                    best_score = avg_score
                    result = self.engines[0].play(self.board, chess.engine.Limit(depth=depth))
                    best_move = result.move

                elapsed_time = time.time() - start_time
                if elapsed_time > self.search_time:
                    break

        return best_move

    def get_book_move(self):
        try:
            return self.opening_book.weighted_choice(self.board).move
        except IndexError:
            return None

    def make_move(self, move):
        try:
            self.board.push_san(move)
            return True
        except ValueError:
            return False

    def get_random_move(self):
        return random.choice(list(self.board.legal_moves))

    def play_engine_move(self):
        if self.board.is_game_over():
            return None

        book_move = self.get_book_move()
        if book_move:
            self.board.push(book_move)
            return book_move

        tt_entry = self.transposition_table.lookup(self.board.fen())
        if tt_entry:
            self.board.push(tt_entry)
            return tt_entry

        move = self.search_best_move()
        if move:
            self.board.push(move)
            self.transposition_table.store(self.board.fen(), move)
        else:
            move = self.get_random_move()
            self.board.push(move)

        return move

    def display_board(self):
        return str(self.board)

    def close_engines(self):
        for engine in self.engines:
            engine.quit()

class ChessGUI:
    def __init__(self, engine):
        self.engine = engine
        pygame.init()
        self.screen = pygame.display.set_mode((BOARD_SIZE, BOARD_SIZE))
        pygame.display.set_caption("GrandLeader Chess Engine")
        self.clock = pygame.time.Clock()
        self.load_images()
        self.selected_square = None
        self.valid_moves = []
        self.message = ""
        self.font = pygame.font.Font(None, 36)

    def load_images(self):
        self.images = {}
        pieces = 'prnbqkPRNBQK'
        for piece in pieces:
            self.images[piece] = pygame.transform.scale(
                pygame.image.load(f"chess_pieces/{piece}.png"),
                (SQUARE_SIZE, SQUARE_SIZE)
            )

    def draw_board(self):
        for row in range(8):
            for col in range(8):
                color = LIGHT_SQUARE_COLOR if (row + col) % 2 == 0 else DARK_SQUARE_COLOR
                pygame.draw.rect(self.screen, color, (col * SQUARE_SIZE, row * SQUARE_SIZE, SQUARE_SIZE, SQUARE_SIZE))

    def draw_pieces(self):
        for square in chess.SQUARES:
            piece = self.engine.board.piece_at(square)
            if piece:
                x = chess.square_file(square) * SQUARE_SIZE
                y = (7 - chess.square_rank(square)) * SQUARE_SIZE
                self.screen.blit(self.images[piece.symbol()], (x, y))

    def highlight_moves(self):
        if self.selected_square is not None:
            x = chess.square_file(self.selected_square) * SQUARE_SIZE
            y = (7 - chess.square_rank(self.selected_square)) * SQUARE_SIZE
            pygame.draw.rect(self.screen, HIGHLIGHT_COLOR, (x, y, SQUARE_SIZE, SQUARE_SIZE), 3)

            for move in self.valid_moves:
                x = chess.square_file(move.to_square) * SQUARE_SIZE
                y = (7 - chess.square_rank(move.to_square)) * SQUARE_SIZE
                pygame.draw.rect(self.screen, MOVE_HIGHLIGHT_COLOR, (x, y, SQUARE_SIZE, SQUARE_SIZE), 3)

    def handle_click(self, pos):
        file = pos[0] // SQUARE_SIZE
        rank = 7 - (pos[1] // SQUARE_SIZE)
        square = chess.square(file, rank)

        if self.selected_square is None:
            piece = self.engine.board.piece_at(square)
            if piece and piece.color == self.engine.board.turn:
                self.selected_square = square
                self.valid_moves = [move for move in self.engine.board.legal_moves if move.from_square == square]
        else:
            move = chess.Move(self.selected_square, square)
            if move in self.valid_moves:
                if self.engine.make_move(move.uci()):
                    self.engine.play_engine_move()
                    if self.engine.board.is_game_over():
                        self.message = self.get_game_over_message()
            self.selected_square = None
            self.valid_moves = []

    def get_game_over_message(self):
        if self.engine.board.is_checkmate():
            return "Checkmate!"
        elif self.engine.board.is_stalemate():
            return "Stalemate!"
        elif self.engine.board.is_insufficient_material():
            return "Draw due to insufficient material!"
        elif self.engine.board.is_seventyfive_moves():
            return "Draw by 75-move rule!"
        elif self.engine.board.is_fivefold_repetition():
            return "Draw by fivefold repetition!"
        else:
            return "Game Over!"

    def draw_message(self):
        if self.message:
            text_surface = self.font.render(self.message, True, BLACK)
            text_rect = text_surface.get_rect(center=(BOARD_SIZE // 2, BOARD_SIZE // 2))
            pygame.draw.rect(self.screen, WHITE, text_rect.inflate(20, 20))
            self.screen.blit(text_surface, text_rect)

    def run(self):
        running = True
        while running:
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    running = False
                elif event.type == pygame.MOUSEBUTTONDOWN:
                    self.handle_click(event.pos)

            self.screen.fill(WHITE)
            self.draw_board()
            self.draw_pieces()
            self.highlight_moves()
            self.draw_message()
            pygame.display.flip()
            self.clock.tick(30)

        pygame.quit()
        self.engine.close_engines()

def main():
    engine = GrandLeaderChessEngine(STOCKFISH_PATH, LC0_PATH, KOMODO_PATH, OPENING_BOOK_PATH)
    gui = ChessGUI(engine)
    gui.run()

if __name__ == "__main__":
    main()
```