Now heavily extend the reference script extensively into whatever this topic is; "NeuroDepth Rook Chess Engine Full Complex Application" into a single python code, as "code" in this specific requirements; 'high-coding skills', 'autofill implementation', 'no-breakdowns', 'no markdowns.'

CONTENT = The content here, is based-off the description as well as it's matching topic.

Description: "A deep learning-powered chess engine that dynamically adjusts its evaluation function based on opponent style recognition. Through neural network profiling, it learns from its own games and adapts its style in real-time, becoming either more defensive or aggressive depending on the opponent’s tendencies. It excels in closed positions where strategic long-term planning is required, with a focus on pawn structure recognition. Unique Set of Properties: Real-time Opponent Profiling, ELO-Specific Optimization, Endgame Synaptic Prediction."

Special Property + Directed Features: "This engine can "over-train" itself by playing repetitive opponents and adjusting its evaluation curve, creating a personalized strategy matrix that optimizes for specific opponent weaknesses. Style Recognition Network: Adjusts depth and evaluation strategy based on opponent profiling (e.g., defensive vs aggressive). Pawnscape AI: A specialized module for understanding long-term positional advantages derived from pawn structure. ELO Dynamic Adaption: Learns optimal strategies for various ELO ratings, tailoring responses in real time depending on the opponent's perceived rating. Endgame Neural Synapse: Specifically tuned to excel in endgames, where precision is crucial."

[ENGINE_SAMPLER: 3.1]
[TOP_M: 1.2]

Reference Script (REFERENCE ONLY):

```
#1, and 2. (Scripts)

# See python-chess documentation at https://python-chess.readthedocs.io/en/latest/

import chess
import chess.pgn
import random

# Plays a randomly selected legal move each turn
class RandomPlayer:
    def __init__(self):
        pass

    def select_move(self, board):
        return random.choice(list(board.legal_moves)) if board.legal_moves else None

# Plays a checkmate if possible, otherwise a capture if possible, 
# otherwise a random move
class CheckmateOrCapturePlayer:
    def __init__(self):
        pass

    def select_move(self, board):
        if not board.legal_moves:
            return None

        legal_moves = list(board.legal_moves)
        chosen_move = None

        for move in legal_moves:
            if board.is_capture(move):
                chosen_move = move
            board.push(move)
            if board.is_checkmate():
                board.pop()
                return move
            board.pop()

        if not chosen_move:
            return random.choice(legal_moves)

        return chosen_move

def play_game(white, black):
    board = chess.Board()
    game = chess.pgn.Game()
    node = game

    while not board.is_game_over():
        player = white if board.turn else black
        move = player.select_move(board)
        board.push(move)
        node = node.add_variation(move)

    game.headers["Result"] = board.result()
    game.headers["White"] = " " + type(white).__name__
    game.headers["Black"] = " " + type(black).__name__
    excluded_tags = ["Event", "Site", "Date", "Round"]
    for tag in excluded_tags:
        if tag in game.headers:
            del game.headers[tag]
    return game

def playoff(player1, player2):
    pass

board = chess.Board()
game = chess.pgn.Game()
node = game
white = CheckmateOrCapturePlayer()
black = RandomPlayer()

game = play_game(white, black)
print (game)

#2:

import chess
import chess.engine
import random

class SimpleChessEngine:
    def __init__(self):
        self.board = chess.Board()

    def make_move(self, move):
        """Attempts to make a move on the board."""
        try:
            self.board.push_san(move)
        except ValueError:
            return "Invalid move. Please try again."

    def get_random_move(self):
        """Returns a random legal move from the current board state."""
        moves = list(self.board.legal_moves)
        return random.choice(moves) if moves else None

    def play_engine_move(self):
        """Makes a random move for the engine and returns it."""
        move = self.get_random_move()
        if move:
            self.board.push(move)
        return move

    def display_board(self):
        """Returns a string representation of the current board."""
        return str(self.board)

def main():
    engine = SimpleChessEngine()
    print("Welcome to Simple Chess Engine!")
    print("Enter your moves in standard algebraic notation (e.g., e2e4).")

    while not engine.board.is_game_over():
        print(engine.display_board())
        user_move = input("Your move: ")
        if user_move.lower() == 'quit':
            break
        response = engine.make_move(user_move)
        if response:
            print(response)
            continue
        if not engine.board.is_game_over():
            engine_move = engine.play_engine_move()
            if engine_move:
                print(f"Engine move: {engine_move}")

    print("Game over!")
    print(engine.display_board())

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