Separate client and server codes. Keep everything in one git repo for simplicity

[vchess.git] / client / client_OLD / javascripts / variants / Dark.js

class DarkRules extends ChessRules
{
    // Standard rules, in the shadow
    setOtherVariables(fen)
    {
        super.setOtherVariables(fen);
        const [sizeX,sizeY] = [V.size.x,V.size.y];
        this.enlightened = {
            "w": doubleArray(sizeX,sizeY),
            "b": doubleArray(sizeX,sizeY)
        };
        // Setup enlightened: squares reachable by each side
        // (TODO: one side would be enough ?)
        this.updateEnlightened();
    }

    updateEnlightened()
    {
        for (let i=0; i<V.size.x; i++)
        {
            for (let j=0; j<V.size.y; j++)
            {
                this.enlightened["w"][i][j] = false;
                this.enlightened["b"][i][j] = false;
            }
        }
        const pawnShift = {"w":-1, "b":1};
        // Initialize with pieces positions (which are seen)
        for (let i=0; i<V.size.x; i++)
        {
            for (let j=0; j<V.size.y; j++)
            {
                if (this.board[i][j] != V.EMPTY)
                {
                    const color = this.getColor(i,j);
                    this.enlightened[color][i][j] = true;
                    // Add potential squares visible by "impossible pawn capture"
                    if (this.getPiece(i,j) == V.PAWN)
                    {
                        for (let shiftY of [-1,1])
                        {
                            if (V.OnBoard(i+pawnShift[color],j+shiftY)
                                && this.board[i+pawnShift[color]][j+shiftY] == V.EMPTY)
                            {
                                this.enlightened[color][i+pawnShift[color]][j+shiftY] = true;
                            }
                        }
                    }
                }
            }
        }
        const currentTurn = this.turn;
        this.turn = "w";
        const movesWhite = this.getAllValidMoves();
        this.turn = "b";
        const movesBlack = this.getAllValidMoves();
        this.turn = currentTurn;
        for (let move of movesWhite)
            this.enlightened["w"][move.end.x][move.end.y] = true;
        for (let move of movesBlack)
            this.enlightened["b"][move.end.x][move.end.y] = true;
    }

    // Has to be redefined to avoid an infinite loop
    getAllValidMoves()
    {
        const color = this.turn;
        const oppCol = V.GetOppCol(color);
        let potentialMoves = [];
        for (let i=0; i<V.size.x; i++)
        {
            for (let j=0; j<V.size.y; j++)
            {
                if (this.board[i][j] != V.EMPTY && this.getColor(i,j) == color)
                    Array.prototype.push.apply(potentialMoves, this.getPotentialMovesFrom([i,j]));
            }
        }
        return potentialMoves; //because there are no checks
    }

    atLeastOneMove()
    {
        if (this.kingPos[this.turn][0] < 0)
            return false;
        return true; //TODO: is it right?
    }

    underCheck(color)
    {
        return false; //there is no check
    }

    getCheckSquares(color)
    {
        return [];
    }

    updateVariables(move)
    {
        super.updateVariables(move);
        if (move.vanish.length >= 2 && move.vanish[1].p == V.KING)
        {
            // We took opponent king !
            this.kingPos[this.turn] = [-1,-1];
        }

        // Update moves for both colors:
        this.updateEnlightened();
    }

    unupdateVariables(move)
    {
        super.unupdateVariables(move);
        const c = move.vanish[0].c;
        const oppCol = V.GetOppCol(c);
        if (this.kingPos[oppCol][0] < 0)
        {
            // Last move took opponent's king
            for (let psq of move.vanish)
            {
                if (psq.p == 'k')
                {
                    this.kingPos[oppCol] = [psq.x, psq.y];
                    break;
                }
            }
        }

        // Update moves for both colors:
        this.updateEnlightened();
    }

    checkGameEnd()
    {
        // No valid move: our king disappeared
        return this.turn == "w" ? "0-1" : "1-0";
    }

    static get THRESHOLD_MATE()
    {
        return 500; //checkmates evals may be slightly below 1000
    }

    // In this special situation, we just look 1 half move ahead
    getComputerMove()
    {
        const maxeval = V.INFINITY;
        const color = this.turn;
        const oppCol = V.GetOppCol(color);
        const pawnShift = (color == "w" ? -1 : 1);
        const kp = this.kingPos[color];

        // Do not cheat: the current enlightment is all we can see
        const myLight = JSON.parse(JSON.stringify(this.enlightened[color]));

        // Can a slider on (i,j) apparently take my king?
        // NOTE: inaccurate because assume yes if some squares are shadowed
        const sliderTake = ([i,j], piece) => {
            let step = undefined;
            if (piece == V.BISHOP)
            {
                if (Math.abs(kp[0] - i) == Math.abs(kp[1] - j))
                {
                    step =
                    [
                        (i-kp[0]) / Math.abs(i-kp[0]),
                        (j-kp[1]) / Math.abs(j-kp[1])
                    ];
                }
            }
            else if (piece == V.ROOK)
            {
                if (kp[0] == i)
                    step = [0, (j-kp[1]) / Math.abs(j-kp[1])];
                else if (kp[1] == j)
                    step = [(i-kp[0]) / Math.abs(i-kp[0]), 0];
            }
            if (!step)
                return false;
            // Check for obstacles
            let obstacle = false;
            for (
                let x=kp[0]+step[0], y=kp[1]+step[1];
                x != i && y != j;
                x += step[0], y+= step[1])
            {
                if (myLight[x][y] && this.board[x][y] != V.EMPTY)
                {
                    obstacle = true;
                    break;
                }
            }
            if (!obstacle)
                return true;
            return false;
        };

        // Do I see something which can take my king ?
        const kingThreats = () => {
            for (let i=0; i<V.size.x; i++)
            {
                for (let j=0; j<V.size.y; j++)
                {
                    if (myLight[i][j] && this.board[i][j] != V.EMPTY
                        && this.getColor(i,j) != color)
                    {
                        switch (this.getPiece(i,j))
                        {
                            case V.PAWN:
                                if (kp[0] + pawnShift == i && Math.abs(kp[1]-j) == 1)
                                    return true;
                                break;
                            case V.KNIGHT:
                                if ((Math.abs(kp[0] - i) == 2 && Math.abs(kp[1] - j) == 1) ||
                                    (Math.abs(kp[0] - i) == 1 && Math.abs(kp[1] - j) == 2))
                                {
                                    return true;
                                }
                                break;
                            case V.KING:
                                if (Math.abs(kp[0] - i) == 1 && Math.abs(kp[1] - j) == 1)
                                    return true;
                                break;
                            case V.BISHOP:
                                if (sliderTake([i,j], V.BISHOP))
                                    return true;
                                break;
                            case V.ROOK:
                                if (sliderTake([i,j], V.ROOK))
                                    return true;
                                break;
                            case V.QUEEN:
                                if (sliderTake([i,j], V.BISHOP) || sliderTake([i,j], V.ROOK))
                                    return true;
                                break;
                        }
                    }
                }
            }
            return false;
        };

        let moves = this.getAllValidMoves();
        for (let move of moves)
        {
            this.play(move);
            if (this.kingPos[oppCol][0] >= 0 && kingThreats())
            {
                // We didn't take opponent king, and our king will be captured: bad
                move.eval = -maxeval;
            }
            this.undo(move);
            if (!!move.eval)
                continue;

            move.eval = 0; //a priori...

            // Can I take something ? If yes, do it if it seems good...
            if (move.vanish.length == 2 && move.vanish[1].c != color) //avoid castle
            {
                const myPieceVal = V.VALUES[move.appear[0].p];
                const hisPieceVal = V.VALUES[move.vanish[1].p];
                if (myPieceVal <= hisPieceVal)
                    move.eval = hisPieceVal - myPieceVal + 2; //favor captures
                else
                {
                    // Taking a pawn with minor piece,
                    // or minor piece or pawn with a rook,
                    // or anything but a queen with a queen,
                    // or anything with a king.
                    // ==> Do it at random, although
                    //     this is clearly inferior to what a human can deduce...
                    move.eval = (Math.random() < 0.5 ? 1 : -1);
                }
            }
        }

        // TODO: also need to implement the case when an opponent piece (in light)
        // is threatening something - maybe not the king, but e.g. pawn takes rook.

        moves.sort((a,b) => b.eval - a.eval);
        let candidates = [0];
        for (let j=1; j<moves.length && moves[j].eval == moves[0].eval; j++)
            candidates.push(j);
        return moves[_.sample(candidates, 1)];
    }
}