tsgammon-core/dispatchers/CubeGameState.js

A Backgammon library for Typescript, formerly developed as a part of tsgammon-ui

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.resultToCBEoG = exports.cbToRollWhite = exports.cbToRollRed = exports.cbResponseWhite = exports.cbResponseRed = exports.cbInPlayWhite = exports.cbInPlayRed = exports.cbActionWhite = exports.cbActionRed = exports.cbOpening = void 0;
const CubeState_1 = require("../CubeState");
const EOGStatus_1 = require("../EOGStatus");
const SGResult_1 = require("../records/SGResult");
const Score_1 = require("../Score");
const StakeConf_1 = require("../StakeConf");
function cbOpening(cubeState) {
    return {
        tag: 'CBOpening',
        cubeState,
        doStartCheckerPlayRed: () => cbInPlayRed(cubeState),
        doStartCheckerPlayWhite: () => cbInPlayWhite(cubeState),
    };
}
exports.cbOpening = cbOpening;
function cbActionRed(cubeState) {
    return {
        tag: 'CBAction',
        isRed: true,
        cubeState,
        doDouble: () => {
            return cbResponseWhite(cubeState);
        },
        doStartCheckerPlay: () => {
            return cbInPlayRed(cubeState);
        },
        doSkipCubeAction: () => {
            return cbToRollRed(cubeState, 'Skip');
        },
    };
}
exports.cbActionRed = cbActionRed;
function cbActionWhite(cubeState) {
    return {
        tag: 'CBAction',
        isRed: false,
        cubeState,
        doDouble: () => {
            return cbResponseRed(cubeState);
        },
        doStartCheckerPlay: () => {
            return cbInPlayWhite(cubeState);
        },
        doSkipCubeAction: () => {
            return cbToRollWhite(cubeState, 'Skip');
        },
    };
}
exports.cbActionWhite = cbActionWhite;
function cbInPlayRed(cubeState) {
    const mayDouble = cubeState.mayDoubleFor(CubeState_1.CubeOwner.WHITE);
    return {
        tag: 'CBInPlay',
        isRed: true,
        cubeState,
        mayDouble,
        doStartCubeAction(skipCubeAction) {
            return mayDouble && !skipCubeAction
                ? cbActionWhite(cubeState)
                : cbToRollWhite(cubeState, 'Skip');
        },
    };
}
exports.cbInPlayRed = cbInPlayRed;
function cbInPlayWhite(cubeState) {
    const mayDouble = cubeState.mayDoubleFor(CubeState_1.CubeOwner.RED);
    return {
        tag: 'CBInPlay',
        isRed: false,
        cubeState,
        mayDouble,
        doStartCubeAction(skipCubeAction) {
            return mayDouble && !skipCubeAction
                ? cbActionRed(cubeState)
                : cbToRollRed(cubeState, 'Skip');
        },
    };
}
exports.cbInPlayWhite = cbInPlayWhite;
function cbResponseRed(cubeState) {
    const cbResponse = {
        tag: 'CBResponse',
        isDoubleFromRed: false,
        isRed: true,
        cubeState,
        doTake: () => {
            return doAccept(CubeState_1.CubeOwner.RED, cbToRollWhite, cubeState);
        },
        doPass: () => {
            return cbEoGWhiteWon(cubeState, (0, EOGStatus_1.eog)(), true);
        },
    };
    return cbResponse;
}
exports.cbResponseRed = cbResponseRed;
function cbResponseWhite(cubeState) {
    const cbResponse = {
        tag: 'CBResponse',
        isDoubleFromRed: true,
        isRed: false,
        cubeState,
        doTake: () => {
            return doAccept(CubeState_1.CubeOwner.WHITE, cbToRollRed, cubeState);
        },
        doPass: () => {
            return cbEoGRedWon(cubeState, (0, EOGStatus_1.eog)(), true);
        },
    };
    return cbResponse;
}
exports.cbResponseWhite = cbResponseWhite;
function doAccept(side, cbToRoll, cubeState) {
    return cbToRoll(cubeState.double(side), 'Take');
}
function cbToRollRed(cubeState, lastAction) {
    return {
        tag: 'CBToRoll',
        isRed: true,
        cubeState,
        doStartCheckerPlay: () => {
            return cbInPlayRed(cubeState);
        },
        lastAction,
    };
}
exports.cbToRollRed = cbToRollRed;
function cbToRollWhite(cubeState, lastAction) {
    return {
        tag: 'CBToRoll',
        isRed: false,
        cubeState,
        doStartCheckerPlay: () => {
            return cbInPlayWhite(cubeState);
        },
        lastAction,
    };
}
exports.cbToRollWhite = cbToRollWhite;
function resultToCBEoG(cubeState, sgResult, eogStatus) {
    switch (sgResult) {
        case SGResult_1.SGResult.WHITEWON:
            return cbEoGWhiteWon(cubeState, eogStatus, false);
        case SGResult_1.SGResult.REDWON:
            return cbEoGRedWon(cubeState, eogStatus, false);
        case SGResult_1.SGResult.NOGAME:
            return cbEoGNogame(cubeState, eogStatus);
    }
}
exports.resultToCBEoG = resultToCBEoG;
function cbEoGRedWon(cubeState, eogStatus, isWonByPass) {
    return {
        tag: 'CBEoG',
        cubeState,
        result: SGResult_1.SGResult.REDWON,
        eogStatus,
        isWonByPass,
        calcStake: (stakeConf) => {
            const applied = (0, StakeConf_1.applyStakeConf)(cubeState, eogStatus, stakeConf);
            return Object.assign(Object.assign({}, applied), { stake: (0, Score_1.scoreAsRed)(applied.stake) });
        },
    };
}
function cbEoGWhiteWon(cubeState, eogStatus, isWonByPass) {
    return {
        tag: 'CBEoG',
        cubeState,
        result: SGResult_1.SGResult.WHITEWON,
        eogStatus,
        isWonByPass,
        calcStake: (stakeConf) => {
            const applied = (0, StakeConf_1.applyStakeConf)(cubeState, eogStatus, stakeConf);
            return Object.assign(Object.assign({}, applied), { stake: (0, Score_1.scoreAsWhite)(applied.stake) });
        },
    };
}
function cbEoGNogame(cubeState, eogStatus) {
    return {
        tag: 'CBEoG',
        cubeState,
        result: SGResult_1.SGResult.NOGAME,
        eogStatus,
        isWonByPass: false,
        calcStake: () => {
            return {
                stake: (0, Score_1.score)(),
                eogStatus,
                jacobyApplied: false,
            };
        },
    };
}