MPCG 3: Making a Clickable Board

        import {
    createBoardArrow,
    createBoardPointDiv,
    setupPaiShoBoard,
} from "../ActuatorHelp.js";
import {
    clearMessage,
    pointClicked,
    RmbDown,
    RmbUp,
    showPointMessage,
} from "../PaiShoMain.js";
import {
    MARKED,
    NON_PLAYABLE,
    POSSIBLE_MOVE,
} from "../skud-pai-sho/SkudPaiShoBoardPoint.js";
import { GodaiController } from "./GodaiController.js";
import { GodaiTileManager } from "./GodaiTileManager.js";

export class GodaiActuator {
    /** @type {HTMLDivElement} */ gameContainer;
    /** @type {boolean}        */ isMobile;
    /** @type {boolean}        */ animationOn;
    /** @type {HTMLDivElement} */ boardContainer;
    /** @type {Element}        */ arrowContainer;
    /** @type {HTMLDivElement} */ hostTilesContainer;
    /** @type {HTMLDivElement} */ guestTilesContainer;

    /**
     * @param {HTMLDivElement} gameContainer
     * @param {boolean} isMovile
     * @param {boolean} enableAnimation
     */
    constructor(gameContainer, isMovile, enableAnimation) {
        this.gameContainer = gameContainer;
        this.isMobile = isMovile;
        this.animationOn = enableAnimation;

        // NOTE: This function is imported from ../ActuatorHelp.js
        let containers = setupPaiShoBoard(
            this.gameContainer,
            GodaiController.getHostTilesContainerDivs(),
            GodaiController.getGuestTilesContainerDivs(),
            false
        );

        this.boardContainer = containers.boardContainer;
        this.arrowContainer = containers.arrowContainer;
        this.hostTilesContainer = containers.hostTilesContainer;
        this.guestTilesContainer = containers.guestTilesContainer;
    }

    setAnimationOn(isOn) {
        this.animationOn = isOn;
    }

    /**
     * Calls forth `this.htmlify()`
     *
     * NOTE: This is function is the key for updating your board state, so you should never call `this.htmlify()` directly
     * @param {GodaiBoard} board
     * @param {GodaiTileManager} tileManager
     * @param {PaiShoMarkingManager} markingManager
     * @param {*} moveToAnimate
     * @param {number} moveAnimationBeginStep
     */
    actuate(
        board,
        tileManager,
        markingManager,
        moveToAnimate,
        moveAnimationBeginStep
    ) {
        let self = this;
        if (!moveAnimationBeginStep) {
            moveAnimationBeginStep = 0;
        }

        window.requestAnimationFrame(function () {
            self.htmlify(board, tileManager, markingManager);
        });
    }

    /**
     * Creates the html grid found on the board
     *
     * @param {GodaiBoard} board
     * @param {GodaiTileManager} tileManager
     * @param {PaiShoMarkingManager} markingManager
     * @param {number} moveToAnimate
     * @param {number} moveAnimationBeginStep
     */
    htmlify(
        board,
        tileManager,
        markingManager,
        moveToAnimate,
        moveAnimationBeginStep
    ) {
        this.clearContainer(this.boardContainer);
        this.clearContainer(this.arrowContainer);

        for (const column of board.cells) {
            for (const cell of column) {
                if (
                    markingManager.pointIsMarked(cell) &&
                    !cell.isType(MARKED)
                ) {
                    cell.addType(MARKED);
                } else if (
                    !markingManager.pointIsMarked(cell) &&
                    cell.isType(MARKED)
                ) {
                    cell.removeType(MARKED);
                }

                if (cell) {
                    this.addBoardPoint(cell);
                }
            }
        }

        // Draw arrows
        for (let [_, arrow] of Object.entries(markingManager.arrows)) {
            this.arrowContainer.appendChild(
                createBoardArrow(arrow[0], arrow[1])
            );
        }

        let fullTileSet = new GodaiTileManager();

        // Go through tile piles and clear containers
        for (const tile of fullTileSet.hostTiles) {
            this.clearTileContainer(tile);
        }
        for (const tile of fullTileSet.guestTiles) {
            this.clearTileContainer(tile);
        }
        // Don't forget the deleted tiles!
        this.clearContainer(
            this.hostTilesContainer.querySelector("span.tileLibrary")
        );
        this.clearContainer(
            this.guestTilesContainer.querySelector("span.tileLibrary")
        );

        // Go through tile piles and display
        for (const tile of tileManager.hostTiles) {
            this.addTile(tile, this.hostTilesContainer);
        }
        for (const tile of tileManager.guestTiles) {
            this.addTile(tile, this.guestTilesContainer);
        }

        // Add deleted tiles
        for (const capturedTile of tileManager.capturedHostTiles) {
            this._addCapturedTile(capturedTile, this.hostTilesContainer);
        }
        for (const capturedTile of tileManager.capturedGuestTiles) {
            this._addCapturedTile(capturedTile, this.guestTilesContainer);
        }
    }

    /** @param {Element} container */
    clearContainer(container) {
        while (container.firstChild) {
            container.removeChild(container.firstChild);
        }
    }

    /**
     * Taken from CaptureActuator.js
     *
     * Remember to add the correct div with its proper tile code in
     * `Controller.getHostTilesContainerDivs()` / `Controller.getGuestTilesContainerDivs()` or else this breaks
     * @param {GodaiTile} tile
     */
    clearTileContainer(tile) {
        let containerClass = "." + tile.getImageName();
        let container = document.querySelector(containerClass);
        while (container.firstChild != null) {
            container.removeChild(container.firstChild);
        }
    }

    /**
     * Taken from CaptureActuator.js
     * @param {GodaiTile} tile
     * @param {HTMLDivElement} mainContainer Seems to be unused, but I'll keep it just in case :)
     */
    addTile(tile, mainContainer) {
        let container = mainContainer.querySelector("." + tile.getImageName());
        let div = document.createElement("div");

        div.classList.add("point");
        div.classList.add("hasTile");

        if (tile.selectedFromPile) {
            div.classList.add("selectedFromPile");
            div.classList.add("drained");
        }

        let img = document.createElement("img");
        let srcValue = this.getTileImageSourceDir();

        img.src = srcValue + tile.getImageName() + ".png";
        div.appendChild(img);

        div.setAttribute("name", tile.getImageName());
        div.setAttribute("id", tile.id);

        if (this.isMobile) {
            div.addEventListener("click", () => {
                unplayedTileClicked(div);
                showTileMessage(div);
            });
        } else {
            div.addEventListener("click", () => unplayedTileClicked(div));
            div.addEventListener("mouseover", () => showTileMessage(div));
            div.addEventListener("mouseout", clearMessage);
        }

        container.appendChild(div);
    }

    /**
     * Function of mine so to seperate concerns
     * @param {GodaiTile} tile
     * @param {HTMLDivElement} mainContainer Container of tiles.
     */
    _addCapturedTile(tile, mainContainer) {
        const capturedContainer =
            mainContainer.querySelector("span.tileLibrary");
        const div = document.createElement("div");

        div.classList.add("point");
        div.classList.add("hasTile");

        const img = document.createElement("img");
        const srcValue = this.getTileImageSourceDir();

        img.src = srcValue + tile.getImageName() + ".png";

        div.appendChild(img);

        div.setAttribute("name", tile.getImageName());
        div.setAttribute("id", tile.id);

        if (this.isMobile) {
            div.addEventListener("click", () => {
                showTileMessage(div);
            });
        } else {
            div.addEventListener("mouseover", () => showTileMessage(div));
            div.addEventListener("mouseout", clearMessage);
        }

        capturedContainer.appendChild(div);
    }

    /**
     * Taken from CaptureActuator.js
     * @param {GodaiBoardPoint} bp
     */
    addBoardPoint(bp) {
        let div = createBoardPointDiv(bp);

        if (!bp.isType(NON_PLAYABLE)) {
            div.classList.add("activePoint");

            if (bp.isType(MARKED)) {
                div.classList.add("markedPoint");
            }

            if (bp.isType(POSSIBLE_MOVE)) {
                div.classList.add("possibleMove");
            }

            if (this.isMobile) {
                div.setAttribute(
                    "ontouchstart",
                    "pointClicked(this); showPointMessage(this);"
                );
            } else {
                div.addEventListener("click", () => pointClicked(div));
                div.addEventListener("mouseover", () => showPointMessage(div));
                div.addEventListener("mouseout", clearMessage);
                div.addEventListener("mousedown", (e) => {
                    // Right Mouse Button
                    if (e.button == 2) {
                        RmbDown(div);
                    }
                });
                div.addEventListener("mouseup", (e) => {
                    // Right Mouse Button
                    if (e.button == 2) {
                        RmbUp(div);
                    }
                });
                div.addEventListener("contextmenu", (e) => {
                    e.preventDefault();
                });
            }
        }

        if (bp.hasTile()) {
            div.classList.add("hasTile");

            let img = document.createElement("img");
            let srcValue = this.getTileImageSourceDir();
            img.src = srcValue + bp.tile.getImageName() + ".png";

            div.appendChild(img);
        }

        this.boardContainer.appendChild(div);
    }

    // NOTE: Check out the other actuators for a better method than staticly adding the link to the images.
    getTileImageSourceDir() {
        return "./images/Godai/" + "original" + "/";
    }
}
    

        import { GodaiActuator } from "./GodaiActuator";
import { GodaiTileManager } from "./GodaiTileManager";
import { GodaiBoard } from "./GodaiBoard";
import { PaiShoMarkingManager } from "../pai-sho-common/PaiShoMarkingManager";
import { setGameLogText } from "../PaiShoMain";

export class GodaiGameManager {
    /** @type {string}               */ gameLogText;
    /** @type {boolean}              */ isCopy;
    /** @type {GodaiActuator}        */ actuator;
    /** @type {GodaiTileManager}     */ tileManager;
    /** @type {GodaiBoard}           */ board;
    /** @type {GodaiTileManager}     */ tileManager;
    /** @type {PaiShoMarkingManager} */ markingManager;
    /** @type {string}               */ lastPlayerName;

    constructor(actuator, ignoreActuate, isCopy) {
        this.gameLogText = "";
        this.isCopy = isCopy;
        this.actuator = actuator;

        this.tileManager = new GodaiTileManager();
        this.markingManager = new PaiShoMarkingManager();

        this.setup(ignoreActuate);
    }

    /** Set up the game */
    setup(ignoreActuate) {
        this.board = new GodaiBoard();

        if (!ignoreActuate) {
            this.actuate();
        }
    }

    /** @param {*} moveToAnimate */
    actuate(moveToAnimate) {
        if (this.isCopy) return;

        this.actuator.actuate(
            this.board,
            this.tileManager,
            this.markingManager,
            moveToAnimate
        );
        setGameLogText(this.gameLogText); // NOTE: This is imported from ../PaiShoMain.js
    }

    /**
     * @param {GodaiBoardPoint} boardPoint
     * @param {boolean} ignoreActuate
     */
    revealPossibleMovePoints(boardPoint, ignoreActuate) {
        if (!boardPoint.hasTile()) return;

        this.board.setPossibleMovePoints(boardPoint);

        if (!ignoreActuate) {
            this.actuate();
        }
    }

    revealDeployPoints(player, tileCode, ignoreActuate) {
        this.board.setDeployPointsPossibleMoves(player, tileCode);

        if (!ignoreActuate) {
            this.actuate();
        }
    }

    hidePossibleMovePoints(ignoreActuate) {
        this.board.removePossibleMovePoints();
        this.tileManager.removeSelectedTileFlags();
        if (!ignoreActuate) {
            this.actuate();
        }
    }

    cleanup() {}

    /**
     * NOTE: This method will be covered in another time
     * @param {GodaiNotationMove} move Move to play
     * */
    runNotationMove(move, withActuate) {}

    hasEnded() {
        return this.board.winners.length > 0;
    }

    getWinner() {
        if (this.board.winners.length === 1) {
            return this.board.winners[0];
        } else if (this.board.winners.length > 1) {
            return "BOTH players";
        }
    }

    getWinReason() {
        return this.board.winnerReason;
    }
}
    

        // NOTE: There are three classes here, they're all related so here's where they are all located
import { BRAND_NEW } from "../PaiShoMain.js";

export class GodaiNotationMove {
    fullMoveText = "";
    isValid = false;

    /** @type {number} */
    moveNum = 0;
    playerCode = "";
    moveType = "";

    // MOVE information
    /** @type {NotationPoint} */ startPoint;
    /** @type {NotationPoint} */ endPoint;

    // DEPLOY information
    tileType = "";

    constructor(text) {
        this.fullMoveText = text;
        this.analyzeMove();
    }

    /**
     * Based on `this.fullMoveText`, decides if its a valid move notation or not
     *
     * NOTE: This method will be covered in a later post
     */
    analyzeMove() {}

    isValidNotation() {
        return this.isValid;
    }
}

export class GodaiGameNotation {
    /** @type {string} */
    notationText = "";

    /** @type {Array<GodaiNotationMove>} */
    moves = [];

    /** @param {string} text */
    setNotationText(text) {
        this.notationText = text;
        this.loadMoves();
    }

    /** @param {string} text */
    addNotationLine(text) {
        this.notationText += ";" + text.trim();
        this.loadMoves();
    }

    /** @param {GodaiNotationMove} move  */
    addMove(move) {
        if (this.notationText) {
            this.notationText += ";" + move.fullMoveText;
        } else {
            this.notationText = move.fullMoveText;
        }

        this.loadMoves();
    }

    removeLastMove() {
        this.notationText = this.notationText.substring(
            0,
            this.notationText.lastIndexOf(";")
        );
        this.loadMoves();
    }

    getPlayerMoveNum() {
        let moveNum = 1;
        let lastMove = this.moves[this.moves.length - 1];

        if (lastMove) {
            moveNum = lastMove.moveNum;
            if (lastMove.playerCode == GUEST) {
                moveNum++;
            }
        }

        return moveNum;
    }

    /**
     * NOTE: If your game starts with HOST may want to modify this method accordingly,
     * look at the other GameNotations from variants that start with host
     * @param {GodaiNotationBuilder} builder
     * @returns {GodaiNotationMove}
     */
    getNotationMoveFromBuilder(builder) {
        let moveNum = 1;
        let player = GUEST;
        let lastMove = this.moves[this.moves.length - 1];

        if (lastMove) {
            moveNum = lastMove.moveNum;

            if (lastMove.moveNum === 0 && lastMove.playerCode === HOST) {
                player = GUEST;
            } else if (
                lastMove.moveNum === 0 &&
                lastMove.playerCode === GUEST
            ) {
                moveNum++;
                player = GUEST;
            } else if (lastMove.playerCode === HOST) {
                moveNum++;
            } else {
                player = HOST;
            }
        }

        return builder.getNotationMove(moveNum, player);
    }

    /**
     * For each move split from `this.notationText`, analyze each one of them and add them to `this.moves`
     * if they're valid
     */
    loadMoves() {
        this.moves = [];
        let lines = [];
        if (this.notationText) {
            if (this.notationText.includes(";")) {
                lines = this.notationText.split(";");
            } else {
                lines = [this.notationText];
            }
        }

        let lastPlayer = HOST; // Lets say the host started the game
        for (const line of lines) {
            let move = new GodaiNotationMove(line);
            if (move.isValidNotation() && move.playerCode !== lastPlayer) {
                this.moves.push(move);
                lastPlayer = move.player;
            } else {
                debug("the player check is broken?");
            }
        }
    }

    /* GETTERS FOR TEXT */

    getNotationHtml() {
        let lines = [];
        if (this.notationText) {
            if (this.notationText.includes(";")) {
                lines = this.notationText.split(";");
            } else {
                lines = [this.notationText];
            }
        }

        let notationHTML = lines.reduce(
            (acc, line) => (acc += line + "<br />"),
            ""
        );
        return notationHTML;
    }

    notationTextForUrl() {
        return this.notationText;
    }

    getNotationForEmail() {
        let lines = [];
        if (this.notationText) {
            if (this.notationText.includes(";")) {
                lines = this.notationText.split(";");
            } else {
                lines = [this.notationText];
            }
        }

        let notationHTML = lines.reduce(
            (acc, line) => (acc += line + "[BR]"),
            ""
        );
        return notationHTML;
    }

    getLastMoveText() {
        return this.moves[this.moves.length - 1].fullMoveText;
    }

    getLastMoveNumber() {
        return this.moves[this.moves.length - 1].moveNum;
    }
}

export class GodaiNotationBuilder {
    status = BRAND_NEW;

    moveType = "";
    plantedlowerType = "";

    // NOTE: These are imported from ..CommonNotationObjects along with the HOST and GUEST keywords
    /** @type {NotationPoint} */ startPoint;
    /** @type {NotationPoint} */ endPoint;

    /**
     *
     * Taken from CaptureGameNotation.js
     * @param {number} moveNum
     * @param {string} player
     * @returns {GodaiNotationMove}
     */
    getNotationMove(moveNum, player) {
        let notationLine = moveNum + player.charAt(0) + ".";

        if (this.moveType === MOVE) {
            notationLine += `(${this.startPoint.pointText})-(${this.endPoint.pointText})`;
        } else if (this.moveType === DEPLOY) {
            notationLine += `${this.tileType}(${this.endPoint.pointText})`;
        }

        return new GodaiNotationMove(notationLine);
    }
}
    

        import { RowAndColumn } from "../CommonNotationObjects";
import { GodaiBoardPoint } from "./GodaiBoardPoint";
import { NON_PLAYABLE } from "../skud-pai-sho/SkudPaiShoBoardPoint";

export class GodaiBoard {
    /** @type {RowAndColumn} */ size;
    /** @type {Array<Array<GodaiBoardPoint>>} */ cells;
    /** @type {Array<string>} */ winners;
    /** @type {string} */ winnerReason = "";

    constructor() {
        // NOTE: If your variant is played on intersections, then keep the size as it is.
        // If it is instead played in spaces like in Adevar, then change it to 18x18
        this.size = new RowAndColumn(17, 17);
        this.cells = this.brandNew();
        this.winners = [];
    }

    // NOTE: The whole reason this class is so bloated and is around 600 lines long
    brandNew() {}

    /**
     * Taken from SpiritBoard.js
     * @param {number} numColumns Number of Columns to add. They're added from the center
     * @param {Array<GodaiBoardPoint>} points points to add, from left to right
     * @returns {Array<GodaiBoardPoint>}
     */
    newRow(numColumns, points) {
        let cells = [];
        let numBlanksOnSides = (this.size.row - numColumns) / 2;

        let nonPoint = new GodaiBoardPoint();
        nonPoint.addType(NON_PLAYABLE);

        for (var i = 0; i < this.size.row; i++) {
            if (i < numBlanksOnSides) {
                cells[i] = nonPoint;
            } else if (i < numBlanksOnSides + numColumns) {
                if (points) {
                    cells[i] = points[i - numBlanksOnSides];
                } else {
                    cells[i] = nonPoint;
                }
            } else {
                cells[i] = nonPoint;
            }
        }

        return cells;
    }

    /**
     * Taken from VagabondBoard.js
     * @param {GodaiBoardPoint} bpStart
     * @param {GodaiBoardPoint} bpEnd
     * @param {number} numMoves
     */
    _verifyAbleToReach(bpStart, bpEnd, numMoves) {
        // Recursion!
        return this._pathFound(bpStart, bpEnd, numMoves, bpStart);
    }

    /**
     * Taken from VagabondBoard.js
     *
     * NOTE: This method, along with others that were made exclusively for this one,
     * are the *second* reason why this class is so bloated
     * @param {GodaiBoardPoint} bpStart
     * @param {GodaiBoardPoint} bpEnd
     * @param {number} numMoves
     */
    _pathFound(bpStart, bpEnd, numMoves) {}

    /**
     * @param {string} playerCode GUEST or HOST
     * @param {NotationPoint} notationPointStart
     * @param {NotationPoint} notationPointEnd
     */
    moveTile(playerCode, notationPointStart, notationPointEnd) {}

    /**
     * Taken from VagabondBoard.js
     * @param {GodaiBoardPoint} boardPointStart
     */
    setPossibleMovePoints(boardPointStart) {}

    /**
     * @param {string} player HOST or GUEST
     * @param {string} tileCode
     * @returns
     */
    setDeployPointsPossibleMoves(player, tileCode) {}

    removePossibleMovePoints() {
        this.cells.forEach((row) => {
            row.forEach((bp) => bp.removeType(POSSIBLE_MOVE));
        });
    }

    /**
     *
     * @param {GodaiTile} tile
     * @param {NotationPoint} notationPoint
     */
    placeTile(tile, notationPoint) {
        this.putTileOnPoint(tile, notationPoint);

        // Things to do after a tile is placed

        // Nothing :)
    }

    putTileOnPoint(tile, notationPoint) {
        let p = notationPoint.rowAndColumn;
        let point = this.cells[p.row][p.col];
        point.putTile(tile);
    }

    /**
     * Checks whether a player has won, and adds it as a winner and the reason why.
     * @param {GodaiTileManager} tileManager Contains all the tiles neccesary to check if a player has won
     */
    checkForEndGame(tileManager) {}

    /**
     * NOTE: This methods will be useful when calculating possible moves,
     * be sure to look at the boards to see any other methods used for unortodox movements!
     * @param {RowAndColumn} rowAndCol
     * @returns {Array<RowAndColumn>}
     */
    getSurroundingBoardPoints(initialBoardPoint) {
        var surroundingPoints = [];
        for (
            var row = initialBoardPoint.row - 1;
            row <= initialBoardPoint.row + 1;
            row++
        ) {
            for (
                var col = initialBoardPoint.col - 1;
                col <= initialBoardPoint.col + 1;
                col++
            ) {
                if (
                    (row !== initialBoardPoint.row ||
                        col !== initialBoardPoint.col) && // Not the center given point
                    row >= 0 &&
                    col >= 0 &&
                    row < 17 &&
                    col < 17
                ) {
                    // Not outside range of the grid
                    var boardPoint = this.cells[row][col];
                    if (!boardPoint.isType(NON_PLAYABLE)) {
                        // Not non-playable
                        surroundingPoints.push(boardPoint);
                    }
                }
            }
        }
        return surroundingPoints;
    }

    getTilesOnBoard() {
        let tiles = [];

        for (const row of this.cells) {
            for (const bp of row) {
                if (!bp.isType(NON_PLAYABLE) && bp.hasTile()) {
                    tiles.push(bp.tile);
                }
            }
        }

        return tiles;
    }
}
    

        // NOTE: You will export your board point types from here

export class GodaiBoardPoint {
    /** @type {Array<string>} */ types;
    /** @type {number}        */ row;
    /** @type {number}        */ col;
    /** @type {GodaiTile}     */ tile;

    constructor() {
        this.types = [];
        this.row = -1;
        this.col = -1;
    }

    /**
     * Taken from SpiritBoardPoint.js
     * @param {string} type Type of point. Use constants only.
     */
    addType(type) {
        if (!this.types.includes(type)) {
            this.types.push(type);
        }
    }

    /**
     * Taken from SpiritBoardPoint.js
     * @param {string} type Type of point. Use constants only.
     */
    removeType(type) {
        for (let i = 0; i < this.types.length; i++) {
            if (this.types[i] === type) {
                this.types.splice(i, 1);
            }
        }
    }

    /**
     * Taken from SpiritBoardPoint.js
     * @param {GodaiTile} tile
     */
    putTile(tile) {
        this.tile = tile;
    }

    removeTile() {
        let tile = this.tile;
        this.tile = null;
        return tile;
    }

    /**
     * Taken from SpiritBoardPoint.js
     */
    hasTile() {
        if (this.tile) return true;
        return false;
    }

    isType(type) {
        return this.types.includes(type);
    }

    /* POINT TYPES */

    // NOTE: Here you will place all your board point types as static constructors. I'll leave you with two examples:

    static neutral() {
        let point = new GodaiBoardPoint();
        point.addType(NEUTRAL);
        return point;
    }

    static gate() {
        let point = new GodaiBoardPoint();
        point.addType(GATE);
        return point;
    }
}
    

        import { GUEST, HOST } from "../CommonNotationObjects";
import { debug } from "../GameData";
import { GodaiTile } from "./GodaiTile";

export class GodaiTileManager {
    /** @type {Array<GodaiTile>} */ hostTiles;
    /** @type {Array<GodaiTile>} */ guestTiles;
    /** @type {Array<GodaiTile>} */ capturedHostTiles;
    /** @type {Array<GodaiTile>} */ capturedGuestTiles;

    constructor() {
        this.hostTiles = this.loadTileSet("H");
        this.guestTiles = this.loadTileSet("G");

        this.capturedHostTiles = [];
        this.capturedGuestTiles = [];
    }

    /**
     * NOTE: We'll check this out later
     * @param {'G' | 'H'} tileCode
     * @returns {Array<GodaiTile>} array of tiles
     */
    loadTileSet(ownerCode) {
        let tiles = [];
        return tiles;
    }

    /**
     * Grabs a tile from the corresponding tile and returns it.
     * @param {string} player HOST or GUEST
     * @param {string} tileCode tilecode
     * @returns {GodaiTile | null}
     */
    grabTile(player, tileCode) {
        let tilePile = player == HOST ? this.hostTiles : this.guestTiles;

        /** @type {GodaiTile} */
        let tile;
        for (var i = 0; i < tilePile.length; i++) {
            if (tilePile[i].code === tileCode) {
                var newTileArr = tilePile.splice(i, 1);
                tile = newTileArr[0];
                break;
            }
        }

        if (!tile) {
            debug(
                "And we didn't get any tiles from params: " +
                    player +
                    " " +
                    tileCode
            );
        }

        return tile;
    }

    peekTile(player, tileCode, tileId) {
        let tilePile = player === HOST ? this.hostTiles : this.guestTiles;

        if (tileId) {
            for (let i = 0; i < tilePile.length; i++) {
                if (tilePile[i].id === tileId) {
                    return tilePile[i];
                }
            }
        }

        for (let i = 0; i < tilePile.length; i++) {
            if (tilePile[i].code === tileCode) {
                return tilePile[i];
            }
        }
    }

    /**
     *
     * @param {GodaiTile} tile
     * @param {string} playerCode GUEST or HOST
     */
    addToCapturedTiles(tile, playerCode) {
        if (playerCode === GUEST) {
            this.capturedGuestTiles.push(tile);
        } else if (playerCode === HOST) {
            this.capturedHostTiles.push(tile);
        }
    }

    removeSelectedTileFlags() {
        this.hostTiles.forEach((tile) => (tile.selectedFromPile = false));
        this.guestTiles.forEach((tile) => (tile.selectedFromPile = false));
    }
}
    

        import { GUEST, HOST } from "../CommonNotationObjects";
import { debug } from "../GameData";
import { tileIdIncrement } from "../skud-pai-sho/SkudPaiShoTile";

// NOTE: Here you'll define your tile type constants for easy use and identification
// This will be done on a later post

export class GodaiTile {
    /** @type {string}  */ code;
    /** @type {string}  */ ownerCode;
    /** @type {string}  */ ownerName;
    /** @type {number}  */ id;
    /** @type {boolean} */ selectedFromPile;

    /**
     * @param {string} code Identifies the tile
     * @param {'G'|'H'} ownerCode Identifies the player who owns the tile.
     */
    constructor(code, ownerCode) {
        this.code = code;
        this.ownerCode = ownerCode;

        if (this.ownerCode === "G") {
            this.ownerName = GUEST;
        } else if (this.ownerCode === "H") {
            this.ownerName = HOST;
        } else {
            debug("INCORRECT OWNER CODE");
        }

        this.id = tileIdIncrement();
    }

    /**
     * Calculates the moving distance of a tile based on the sorrounding board points.
     *
     * NOTE: This method may vary on your use, for now lets just return an arbitrary number so the code is happy.
     *
     * NOTE: If your game has complex interactions based on the tile's sorroundings, this method will grow. A lot.
     * @returns {number} Moving distance based on its sorrounding conditions
     */
    getMoveDistance(sorroundingBPs, isInGate) {
        return 3;
    }

    getImageName() {
        return this.ownerCode + "" + this.code;
    }

    getCopy() {
        return new GodaiTile(this.code, this.ownerCode);
    }

    static getTileName(tileCode) {
        let name = "";

        // NOTE: At a later post this method will use the tile type constants I've mentioned earlier.
        // For now, your tiles without an identity

        return name;
    }
}