GamePlay.jack

/* Information about players and who's turn is to move. */
class GamePlay {
    // rectangle to draw itself into, with top left corner.
    field int x, y, size;
    field int crtPlayerToMove;
    // if you selected a square and then another, it tells
    // the gameplay we want to move from selected square to
    // the current square.
    field int selRow, selCol;   // current selected square
    field int crtRow, crtCol;   // current square we're on
    field String helpText;
    // reference to it, so it can tell it when a move has happened.
    field Board board;

    constructor GamePlay new(int _x, int _y, int _size, Board b) {
        let x = _x;
        let y = _y;
        let size = _size;
        // just an acquaintance, doesn't deallocate it itself.
        let board = b;
        do newGame();
        return this;
    }

    method void dispose() {
        do Memory.deAlloc(this);
        return;
    }

    method void newGame() {
        let crtPlayerToMove = Utils.WHITE();
        do _drawPlayerToMoveIndicator();
        let selRow = -1;
        let selCol = -1;
        // defaults to A1 in left bottom corner
        do _writeCurrentSquare(0, 0);
        do _writeInHelpTextArea("");
        return;
    }

    // react to user pressing keys by changing its view
    // and by letting the board that a move happened, to update
    // its state as well.
    method void pressedKey(int key) {
        var String s1, s2;

        if (key = Utils.LEFTARROWKEY()) {
            let crtCol = Math.max(0, crtCol - 1);
        }
        if (key = Utils.UPARROWKEY()) {
            let crtRow = Math.min(Utils.CHESSN() - 1, crtRow + 1);
        }
        if (key = Utils.RIGHTARROWKEY()) {
            let crtCol = Math.min(Utils.CHESSN() - 1, crtCol + 1);
        }
        if (key = Utils.DOWNARROWKEY()) {
            let crtRow = Math.max(0, crtRow - 1);
        }
        if (key = Utils.ESCKEY()) {
            do newGame();
            do board.newBoard();
        }
        if (key = Utils.SPACEKEY()) {
            // if no current selection, we record it and show on the screen
            if (selRow = -1) {
                let selRow = crtRow;
                let selCol = crtCol;
                let s1 = Board.coordsToString(selRow, selCol);
                let s2 = Utils.concat("selected ", s1);
                do _writeInHelpTextArea(s2);
                do s1.dispose();
                do s2.dispose();
            } else {
                // move there
                if (board.isLegalMove(selRow, selCol,
                                      crtRow, crtCol,
                                      crtPlayerToMove)) {
                    // perform the move, then update who's turn to move is.
                    do board.move(selRow, selCol, crtRow, crtCol);
                    let crtPlayerToMove = Utils.mod(crtPlayerToMove + 1, 2);
                    do _drawPlayerToMoveIndicator();
                    // reset selected square now
                    let selRow = -1;
                    let selCol = -1;
                    do _writeInHelpTextArea("");
                // else, reset selection, let user know it was an illegal move.
                } else {
                    let selRow = -1;
                    let selCol = -1;
                    do _writeInHelpTextArea("illegal move");
                }
            }
        }

        do _writeCurrentSquare(crtRow, crtCol);
        return;
    }

    method void draw() {
        do Utils.drawRectangleBorder(x, y, x + size, y + size);
        do _drawPlayerToMoveIndicator();
        do _writeInPlayerArea(Utils.WHITE(), 2, "Player 1");
        do _writeInPlayerArea(Utils.BLACK(), 2, "Player 2");
        do Utils.printStringAtPx(
            "Crt square: ",
            x + Utils.FONTWIDTH(),
            (y + (size / 2)) - Utils.FONTHEIGHT()
        );
        return;
    }

    method void _drawPlayerToMoveIndicator() {
        // erase crt player indicator from both.
        do _writeInPlayerArea(Utils.WHITE(), 0, " ");
        do _writeInPlayerArea(Utils.BLACK(), 0, " ");
        // redraw the active player.
        do _writeInPlayerArea(crtPlayerToMove, 0, "<");
        return;
    }

    method void _writeCurrentSquare(int row, int col) {
        var String coordsString;

        let coordsString = Board.coordsToString(row, col);

        // updates the current values
        let crtRow = row;
        let crtCol = col;

        // write crt square on screen for users to see.
        do Utils.printStringAtPx(
            coordsString,
            (x + (size / 2)) + (Utils.FONTWIDTH() * 5),
            (y + (size / 2)) - Utils.FONTHEIGHT()
        );

        do coordsString.dispose();
        return;
    }

    method void _writeInHelpTextArea(String help) {
        var String empty;

        // write an empty line over it first, to erase any previous message.
        let empty = "               ";
        do Utils.printStringAtPx(
            empty,
            x + Utils.FONTWIDTH(),
            y + (size / 2)
        );
        // writes help text for user.
        do Utils.printStringAtPx(
            help,
            x + Utils.FONTWIDTH(),
            y + (size / 2)
        );
        let helpText = help;
        return;
    }

    method void _writeInPlayerArea(int color, int offset, String text) {
        var int row;
        if (color = Utils.WHITE()) {
            let row = (y + size) - (Utils.FONTWIDTH() * 2);
        } else {
            let row = y + Utils.FONTWIDTH();
        }

        do Utils.printStringAtPx(
            text,
            x + (Utils.FONTWIDTH() * (offset + 1)),
            row
        );
        return;
    }
}