Bot.cpp

#include "Bot.h"
#include <algorithm>
#include <cstdlib>
#include <cmath>

Bot::Bot() {
}

Move Bot::findBestMove(const Board& board, const Tetromino& piece) {
    Move bestMove;

    // Try all possible rotations (0-3)
    for (int rot = 0; rot < 4; ++rot) {
        // Try all possible x positions
        for (int x = -2; x < Board::WIDTH + 2; ++x) {
            int score = evaluateBoard(board, piece, x, rot);
            if (score > bestMove.score) {
                bestMove = Move(x, rot, score);
            }
        }
    }

    return bestMove;
}

Move Bot::findBestMoveWithLookahead(const Board& board, const Tetromino& current, const Tetromino& next) {
    Move bestMove;

    // Try all possible rotations (0-3)
    for (int rot = 0; rot < 4; ++rot) {
        // Try all possible x positions
        for (int x = -2; x < Board::WIDTH + 2; ++x) {
            int score = evaluateBoardWithLookahead(board, current, x, rot, next);
            if (score > bestMove.score) {
                bestMove = Move(x, rot, score);
            }
        }
    }

    return bestMove;
}

int Bot::evaluateBoard(const Board& board, const Tetromino& piece, int x, int rotations) {
    // Create a test piece and apply rotations
    Tetromino testPiece(piece.getType());
    for (int r = 0; r < rotations; ++r) {
        testPiece.rotate();
    }
    testPiece.setX(x);
    testPiece.setY(0);

    // Check if this initial position is valid
    if (!board.isValidRotation(testPiece)) {
        return -999999;
    }

    // Find drop position
    while (board.isValidMove(testPiece, 0, 1)) {
        testPiece.move(0, 1);
    }

    // Check if final position is valid
    if (!board.isValidRotation(testPiece)) {
        return -999999;
    }

    // Simulate placement and evaluate
    Board simulatedBoard = simulatePlacement(board, testPiece, x, rotations);
    if (simulatedBoard.isGameOver()) {
        return -999999;
    }

    // Heuristic weights - tuned for survival (based on Dellacherie algorithm)
    const double LINE_CLEAR_WEIGHT = 760.0;
    const double HOLE_WEIGHT = -356.0;
    const double HEIGHT_WEIGHT = -51.0;
    const double BUMPINESS_WEIGHT = -184.0;
    const double MAX_HEIGHT_WEIGHT = -100.0;
    const double ROW_TRANSITION_WEIGHT = -80.0;
    const double COL_TRANSITION_WEIGHT = -50.0;
    const double WELL_DEPTH_WEIGHT = -30.0;

    int linesCleared = simulatedBoard.clearLines();
    int holes = countHoles(simulatedBoard);
    int aggregateHeight = getAggregateHeight(simulatedBoard);
    int bumpiness = getBumpiness(simulatedBoard);
    int maxHeight = getMaxHeight(simulatedBoard);
    int rowTransitions = getRowTransitions(simulatedBoard);
    int colTransitions = getColTransitions(simulatedBoard);
    int wellDepth = getWellDepth(simulatedBoard);

    // Heavy penalty for very high stacks
    double heightPenalty = 0;
    if (maxHeight > 15) {
        heightPenalty = (maxHeight - 15) * 200;
    }

    double score = (linesCleared * LINE_CLEAR_WEIGHT) +
                   (holes * HOLE_WEIGHT) +
                   (aggregateHeight * HEIGHT_WEIGHT) +
                   (bumpiness * BUMPINESS_WEIGHT) +
                   (maxHeight * MAX_HEIGHT_WEIGHT) +
                   (rowTransitions * ROW_TRANSITION_WEIGHT) +
                   (colTransitions * COL_TRANSITION_WEIGHT) +
                   (wellDepth * WELL_DEPTH_WEIGHT) -
                   heightPenalty;

    return static_cast<int>(score);
}

int Bot::evaluateBoardWithLookahead(const Board& board, const Tetromino& current, int x, int rot, const Tetromino& next) {
    // First, evaluate the current move
    int currentScore = evaluateBoard(board, current, x, rot);
    if (currentScore < -900000) {
        return currentScore; // Invalid move
    }

    // Simulate current piece placement
    Tetromino currentPiece(current.getType());
    for (int r = 0; r < rot; ++r) {
        currentPiece.rotate();
    }
    currentPiece.setX(x);
    currentPiece.setY(0);

    while (board.isValidMove(currentPiece, 0, 1)) {
        currentPiece.move(0, 1);
    }

    Board afterCurrent = simulatePlacement(board, currentPiece, x, rot);
    if (afterCurrent.isGameOver()) {
        return -999999;
    }

    // Now evaluate best move for next piece
    Move bestNextMove;
    for (int nextRot = 0; nextRot < 4; ++nextRot) {
        for (int nextX = -2; nextX < Board::WIDTH + 2; ++nextX) {
            int nextScore = evaluateBoard(afterCurrent, next, nextX, nextRot);
            if (nextScore > bestNextMove.score) {
                bestNextMove = Move(nextX, nextRot, nextScore);
            }
        }
    }

    // Combine scores: current move is primary, but consider next piece outcome
    // Weight current move 70%, next piece potential 30%
    return static_cast<int>(currentScore * 0.7 + bestNextMove.score * 0.3);
}

Board Bot::simulatePlacement(Board board, const Tetromino& piece, int x, int rotations) {
    // Create a test piece at the starting position
    Tetromino testPiece(piece.getType());
    for (int r = 0; r < rotations; ++r) {
        testPiece.rotate();
    }
    testPiece.setX(x);
    testPiece.setY(0);

    // Drop to bottom
    while (board.isValidMove(testPiece, 0, 1)) {
        testPiece.move(0, 1);
    }

    // Place the piece
    board.placeTetromino(testPiece);

    return board;
}

int Bot::countHoles(const Board& board) const {
    const auto& grid = board.getGrid();
    int holes = 0;

    for (int x = 0; x < Board::WIDTH; ++x) {
        bool foundBlock = false;
        for (int y = 0; y < Board::HEIGHT; ++y) {
            if (grid[y][x]) {
                foundBlock = true;
            } else if (foundBlock && !grid[y][x]) {
                holes++;
            }
        }
    }

    return holes;
}

int Bot::getAggregateHeight(const Board& board) const {
    int totalHeight = 0;
    for (int x = 0; x < Board::WIDTH; ++x) {
        totalHeight += getColumnHeight(board, x);
    }
    return totalHeight;
}

int Bot::getMaxHeight(const Board& board) const {
    int maxHeight = 0;
    for (int x = 0; x < Board::WIDTH; ++x) {
        int h = getColumnHeight(board, x);
        if (h > maxHeight) {
            maxHeight = h;
        }
    }
    return maxHeight;
}

int Bot::getBumpiness(const Board& board) const {
    int bumpiness = 0;
    int prevHeight = getColumnHeight(board, 0);

    for (int x = 1; x < Board::WIDTH; ++x) {
        int height = getColumnHeight(board, x);
        bumpiness += abs(height - prevHeight);
        prevHeight = height;
    }

    return bumpiness;
}

int Bot::getRowTransitions(const Board& board) const {
    const auto& grid = board.getGrid();
    int transitions = 0;

    for (int y = 0; y < Board::HEIGHT; ++y) {
        for (int x = 0; x < Board::WIDTH - 1; ++x) {
            // Count transitions between filled and empty cells
            if (grid[y][x] != grid[y][x+1]) {
                transitions++;
            }
        }
    }

    return transitions;
}

int Bot::getColTransitions(const Board& board) const {
    const auto& grid = board.getGrid();
    int transitions = 0;

    for (int x = 0; x < Board::WIDTH; ++x) {
        for (int y = 0; y < Board::HEIGHT - 1; ++y) {
            // Count transitions between filled and empty cells
            if (grid[y][x] != grid[y+1][x]) {
                transitions++;
            }
        }
    }

    return transitions;
}

int Bot::getWellDepth(const Board& board) const {
    int wellDepth = 0;

    for (int x = 0; x < Board::WIDTH; ++x) {
        int colHeight = getColumnHeight(board, x);
        int leftHeight = (x > 0) ? getColumnHeight(board, x - 1) : Board::HEIGHT;
        int rightHeight = (x < Board::WIDTH - 1) ? getColumnHeight(board, x + 1) : Board::HEIGHT;

        // A "well" is a column lower than both neighbors
        int minNeighborHeight = std::min(leftHeight, rightHeight);
        if (colHeight < minNeighborHeight) {
            wellDepth += (minNeighborHeight - colHeight);
        }
    }

    return wellDepth;
}

int Bot::getColumnHeight(const Board& board, int x) const {
    const auto& grid = board.getGrid();

    for (int y = 0; y < Board::HEIGHT; ++y) {
        if (grid[y][x]) {
            return Board::HEIGHT - y;
        }
    }

    return 0;
}