mirror of
https://github.com/bitburner-official/bitburner-src.git
synced 2026-04-16 22:38:34 +02:00
564 lines
18 KiB
TypeScript
564 lines
18 KiB
TypeScript
import { BoardState, Play, SimpleOpponentStats } from "../Types";
|
|
|
|
import { Player } from "@player";
|
|
import { AugmentationName, GoColor, GoOpponent, GoPlayType, GoValidity } from "@enums";
|
|
import { Go, GoEvents } from "../Go";
|
|
import { getMove, sleep } from "../boardAnalysis/goAI";
|
|
import { getNewBoardState, makeMove, passTurn, updateCaptures, updateChains } from "../boardState/boardState";
|
|
import {
|
|
evaluateIfMoveIsValid,
|
|
getColorOnSimpleBoard,
|
|
getControlledSpace,
|
|
simpleBoardFromBoard,
|
|
} from "../boardAnalysis/boardAnalysis";
|
|
import { getOpponentStats, getScore, resetWinstreak } from "../boardAnalysis/scoring";
|
|
import { WHRNG } from "../../Casino/RNG";
|
|
import { getRecordKeys } from "../../Types/Record";
|
|
import { CalculateEffect, getEffectTypeForFaction } from "./effect";
|
|
|
|
/**
|
|
* Check the move based on the current settings
|
|
*/
|
|
export function validateMove(error: (s: string) => void, x: number, y: number, methodName = "", settings = {}) {
|
|
const check = {
|
|
emptyNode: true,
|
|
requireNonEmptyNode: false,
|
|
repeat: true,
|
|
onlineNode: true,
|
|
requireOfflineNode: false,
|
|
suicide: true,
|
|
...settings,
|
|
};
|
|
|
|
const boardSize = Go.currentGame.board.length;
|
|
if (x < 0 || x >= boardSize) {
|
|
error(`Invalid column number (x = ${x}), column must be a number 0 through ${boardSize - 1}`);
|
|
}
|
|
if (y < 0 || y >= boardSize) {
|
|
error(`Invalid row number (y = ${y}), row must be a number 0 through ${boardSize - 1}`);
|
|
}
|
|
|
|
const moveString = `${methodName} ${x},${y}: `;
|
|
validateTurn(error, moveString);
|
|
|
|
const validity = evaluateIfMoveIsValid(Go.currentGame, x, y, GoColor.black);
|
|
const point = Go.currentGame.board[x][y];
|
|
if (!point && check.onlineNode) {
|
|
error(
|
|
`The node ${x},${y} is offline, so you cannot ${
|
|
methodName === "removeRouter"
|
|
? "clear this point with removeRouter()"
|
|
: methodName === "destroyNode"
|
|
? "destroy the node. (Attempted to destroyNode)"
|
|
: "place a router there"
|
|
}.`,
|
|
);
|
|
}
|
|
if (validity === GoValidity.noSuicide && check.suicide) {
|
|
error(
|
|
`${moveString} ${validity}. That point has no neighboring empty nodes, and is not connected to a network with access to empty nodes, meaning it would be instantly captured if played there.`,
|
|
);
|
|
}
|
|
if (validity === GoValidity.boardRepeated && check.repeat) {
|
|
error(
|
|
`${moveString} ${validity}. That move would repeat the previous board state, which is illegal as it leads to infinite loops.`,
|
|
);
|
|
}
|
|
if (point?.color !== GoColor.empty && check.emptyNode) {
|
|
error(
|
|
`The point ${x},${y} is occupied by a router, so you cannot ${
|
|
methodName === "destroyNode" ? "destroy this node. (Attempted to destroyNode)" : "place a router there"
|
|
}`,
|
|
);
|
|
}
|
|
|
|
if (point?.color === GoColor.empty && check.requireNonEmptyNode) {
|
|
error(`The point ${x},${y} does not have a router on it, so you cannot clear this point with removeRouter().`);
|
|
}
|
|
if (point && check.requireOfflineNode) {
|
|
error(`The node ${x},${y} is not offline, so you cannot repair the node.`);
|
|
}
|
|
}
|
|
|
|
export function validateTurn(error: (s: string) => void, moveString = "") {
|
|
if (Go.currentGame.previousPlayer === GoColor.black) {
|
|
error(
|
|
`${moveString} ${GoValidity.notYourTurn}. Do you have multiple scripts running, or did you forget to await makeMove() or opponentNextTurn()`,
|
|
);
|
|
}
|
|
if (Go.currentGame.previousPlayer === null) {
|
|
error(
|
|
`${moveString} ${GoValidity.gameOver}. You cannot make more moves. Start a new game using resetBoardState().`,
|
|
);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Pass player's turn and await the opponent's response (or logs the end of the game if both players pass)
|
|
*/
|
|
export async function handlePassTurn(logger: (s: string) => void) {
|
|
passTurn(Go.currentGame, GoColor.black);
|
|
logger("Go turn passed.");
|
|
|
|
if (Go.currentGame.previousPlayer === null) {
|
|
logEndGame(logger);
|
|
return getOpponentNextMove(false, logger);
|
|
} else {
|
|
return getAIMove(Go.currentGame);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Validates and applies the player's router placement
|
|
*/
|
|
export async function makePlayerMove(logger: (s: string) => void, error: (s: string) => void, x: number, y: number) {
|
|
const boardState = Go.currentGame;
|
|
const validity = evaluateIfMoveIsValid(boardState, x, y, GoColor.black);
|
|
const moveWasMade = makeMove(boardState, x, y, GoColor.black);
|
|
|
|
if (validity !== GoValidity.valid || !moveWasMade) {
|
|
error(`Invalid move: ${x} ${y}. ${validity}.`);
|
|
}
|
|
|
|
GoEvents.emit();
|
|
logger(`Go move played: ${x}, ${y}`);
|
|
return getAIMove(boardState);
|
|
}
|
|
|
|
/**
|
|
Returns the promise that provides the opponent's move, once it finishes thinking.
|
|
*/
|
|
export async function getOpponentNextMove(logOpponentMove = true, logger: (s: string) => void) {
|
|
// Handle the case where Go.nextTurn isn't populated yet
|
|
if (!Go.nextTurn) {
|
|
const previousMove = getPreviousMove();
|
|
const type =
|
|
Go.currentGame.previousPlayer === null ? GoPlayType.gameOver : previousMove ? GoPlayType.move : GoPlayType.pass;
|
|
|
|
Go.nextTurn = Promise.resolve({
|
|
type,
|
|
x: previousMove?.[0] ?? null,
|
|
y: previousMove?.[1] ?? null,
|
|
});
|
|
}
|
|
|
|
// Only asynchronously log the opponent move if not disabled by the player
|
|
if (logOpponentMove) {
|
|
return Go.nextTurn.then((move) => {
|
|
if (move.type === GoPlayType.gameOver) {
|
|
logEndGame(logger);
|
|
} else if (move.type === GoPlayType.pass) {
|
|
logger(`Opponent passed their turn. You can end the game by passing as well.`);
|
|
} else if (move.type === GoPlayType.move) {
|
|
logger(`Opponent played move: ${move.x}, ${move.y}`);
|
|
}
|
|
return move;
|
|
});
|
|
}
|
|
|
|
return Go.nextTurn;
|
|
}
|
|
|
|
/**
|
|
* Retrieves a move from the current faction in response to the player's move
|
|
*/
|
|
export async function getAIMove(boardState: BoardState): Promise<Play> {
|
|
let resolve: (value: Play) => void;
|
|
Go.nextTurn = new Promise<Play>((res) => {
|
|
resolve = res;
|
|
});
|
|
|
|
getMove(boardState, GoColor.white, Go.currentGame.ai).then(async (result) => {
|
|
if (result.type === GoPlayType.pass) {
|
|
passTurn(Go.currentGame, GoColor.white);
|
|
}
|
|
|
|
// If there is no move to apply, simply return the result
|
|
if (boardState !== Go.currentGame || result.type !== GoPlayType.move || result.x === null || result.y === null) {
|
|
return resolve(result);
|
|
}
|
|
|
|
await sleep(400);
|
|
const aiUpdatedBoard = makeMove(boardState, result.x, result.y, GoColor.white);
|
|
|
|
// Handle the AI breaking. This shouldn't ever happen.
|
|
if (!aiUpdatedBoard) {
|
|
boardState.previousPlayer = GoColor.white;
|
|
console.error(`Invalid AI move attempted: ${result.x}, ${result.y}. This should not happen.`);
|
|
GoEvents.emit();
|
|
return resolve(result);
|
|
}
|
|
|
|
await sleep(300);
|
|
GoEvents.emit();
|
|
resolve(result);
|
|
});
|
|
return Go.nextTurn;
|
|
}
|
|
|
|
/**
|
|
* Returns a grid of booleans indicating if the coordinates at that location are a valid move for the player (black pieces)
|
|
*/
|
|
export function getValidMoves() {
|
|
const boardState = Go.currentGame;
|
|
// Map the board matrix into true/false values
|
|
return boardState.board.map((column, x) =>
|
|
column.reduce((validityArray: boolean[], point, y) => {
|
|
const isValid = evaluateIfMoveIsValid(boardState, x, y, GoColor.black) === GoValidity.valid;
|
|
validityArray.push(isValid);
|
|
return validityArray;
|
|
}, []),
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Returns a grid with an ID for each contiguous chain of same-state nodes (excluding dead/offline nodes)
|
|
*/
|
|
export function getChains() {
|
|
const chains: string[] = [];
|
|
// Turn the internal chain IDs into nice consecutive numbers for display to the player
|
|
return Go.currentGame.board.map((column) =>
|
|
column.reduce((chainIdArray: (number | null)[], point) => {
|
|
if (!point) {
|
|
chainIdArray.push(null);
|
|
return chainIdArray;
|
|
}
|
|
if (!chains.includes(point.chain)) {
|
|
chains.push(point.chain);
|
|
}
|
|
chainIdArray.push(chains.indexOf(point.chain));
|
|
return chainIdArray;
|
|
}, []),
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Returns a grid of numbers representing the number of open-node connections each player-owned chain has.
|
|
*/
|
|
export function getLiberties() {
|
|
return Go.currentGame.board.map((column) =>
|
|
column.reduce((libertyArray: number[], point) => {
|
|
libertyArray.push(point?.liberties?.length || -1);
|
|
return libertyArray;
|
|
}, []),
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Returns a grid indicating which player, if any, controls the empty nodes by fully encircling it with their routers
|
|
*/
|
|
export function getControlledEmptyNodes() {
|
|
const board = Go.currentGame.board;
|
|
const controlled = getControlledSpace(board);
|
|
return controlled.map((column, x: number) =>
|
|
column.reduce((ownedPoints: string, owner: GoColor, y: number) => {
|
|
if (owner === GoColor.white) {
|
|
return ownedPoints + "O";
|
|
}
|
|
if (owner === GoColor.black) {
|
|
return ownedPoints + "X";
|
|
}
|
|
if (!board[x][y]) {
|
|
return ownedPoints + "#";
|
|
}
|
|
if (board[x][y]?.color === GoColor.empty) {
|
|
return ownedPoints + "?";
|
|
}
|
|
return ownedPoints + ".";
|
|
}, ""),
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Gets the status of the current game.
|
|
* Shows the current player, current score, and the previous move coordinates.
|
|
* Previous move coordinates will be [-1, -1] for a pass, or if there are no prior moves.
|
|
*/
|
|
export function getGameState() {
|
|
const currentPlayer = getCurrentPlayer();
|
|
const score = getScore(Go.currentGame);
|
|
const previousMove = getPreviousMove();
|
|
|
|
return {
|
|
currentPlayer,
|
|
whiteScore: score[GoColor.white].sum,
|
|
blackScore: score[GoColor.black].sum,
|
|
previousMove,
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Returns 'None' if the game is over, otherwise returns the color of the current player's turn
|
|
*/
|
|
export function getCurrentPlayer(): "None" | "White" | "Black" {
|
|
if (Go.currentGame.previousPlayer === null) {
|
|
return "None";
|
|
}
|
|
return Go.currentGame.previousPlayer === GoColor.black ? GoColor.white : GoColor.black;
|
|
}
|
|
|
|
/**
|
|
* Find a move made by the previous player, if present.
|
|
*/
|
|
export function getPreviousMove(): [number, number] | null {
|
|
const priorBoard = Go.currentGame?.previousBoards[0];
|
|
if (Go.currentGame.passCount || !priorBoard) {
|
|
return null;
|
|
}
|
|
|
|
for (const rowIndexString in Go.currentGame.board) {
|
|
const row = Go.currentGame.board[+rowIndexString] ?? [];
|
|
for (const pointIndexString in row) {
|
|
const point = row[+pointIndexString];
|
|
const priorColor = point && priorBoard && getColorOnSimpleBoard(priorBoard, point.x, point.y);
|
|
const currentColor = point?.color;
|
|
const isPreviousPlayer = currentColor === Go.currentGame.previousPlayer;
|
|
const isChanged = priorColor !== currentColor;
|
|
if (priorColor && currentColor && isPreviousPlayer && isChanged) {
|
|
return [+rowIndexString, +pointIndexString];
|
|
}
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Handle post-game logging
|
|
*/
|
|
function logEndGame(logger: (s: string) => void) {
|
|
const boardState = Go.currentGame;
|
|
const score = getScore(boardState);
|
|
logger(
|
|
`Subnet complete! Final score: ${boardState.ai}: ${score[GoColor.white].sum}, Player: ${score[GoColor.black].sum}`,
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Clears the board, resets winstreak if applicable
|
|
*/
|
|
export function resetBoardState(
|
|
logger: (s: string) => void,
|
|
error: (s: string) => void,
|
|
opponent: GoOpponent,
|
|
boardSize: number,
|
|
) {
|
|
if (![5, 7, 9, 13].includes(boardSize) && opponent !== GoOpponent.w0r1d_d43m0n) {
|
|
error(`Invalid subnet size requested (${boardSize}), size must be 5, 7, 9, or 13`);
|
|
return;
|
|
}
|
|
|
|
if (opponent === GoOpponent.w0r1d_d43m0n && !Player.hasAugmentation(AugmentationName.TheRedPill, true)) {
|
|
error(`Invalid opponent requested (${opponent}), this opponent has not yet been discovered`);
|
|
return;
|
|
}
|
|
|
|
const oldBoardState = Go.currentGame;
|
|
if (oldBoardState.previousPlayer !== null && oldBoardState.previousBoards.length) {
|
|
resetWinstreak(oldBoardState.ai, false);
|
|
}
|
|
|
|
Go.currentGame = getNewBoardState(boardSize, opponent, true);
|
|
GoEvents.emit(); // Trigger a Go UI rerender
|
|
logger(`New game started: ${opponent}, ${boardSize}x${boardSize}`);
|
|
return simpleBoardFromBoard(Go.currentGame.board);
|
|
}
|
|
|
|
/**
|
|
* Retrieve and clean up stats for each opponent played against
|
|
*/
|
|
export function getStats() {
|
|
const statDetails: Partial<Record<GoOpponent, SimpleOpponentStats>> = {};
|
|
for (const opponent of getRecordKeys(Go.stats)) {
|
|
const details = getOpponentStats(opponent);
|
|
const nodePower = getOpponentStats(opponent).nodePower;
|
|
const effectPercent = (CalculateEffect(nodePower, opponent) - 1) * 100;
|
|
const effectDescription = getEffectTypeForFaction(opponent);
|
|
statDetails[opponent] = {
|
|
wins: details.wins,
|
|
losses: details.losses,
|
|
winStreak: details.winStreak,
|
|
highestWinStreak: details.highestWinStreak,
|
|
favor: details.favor,
|
|
bonusPercent: effectPercent,
|
|
bonusDescription: effectDescription,
|
|
};
|
|
}
|
|
|
|
return statDetails;
|
|
}
|
|
|
|
/** Validate singularity access by throwing an error if the player does not have access. */
|
|
export function checkCheatApiAccess(error: (s: string) => void): void {
|
|
const hasSourceFile = Player.sourceFileLvl(14) > 1;
|
|
const isBitnodeFourteenTwo = Player.sourceFileLvl(14) === 1 && Player.bitNodeN === 14;
|
|
if (!hasSourceFile && !isBitnodeFourteenTwo) {
|
|
error(
|
|
`The go.cheat API requires Source-File 14.2 to run, a power up you obtain later in the game.
|
|
It will be very obvious when and how you can obtain it.`,
|
|
);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Determines if the attempted cheat move is successful. If so, applies the cheat via the callback, and gets the opponent's response.
|
|
*
|
|
* If it fails, determines if the player's turn is skipped, or if the player is ejected from the subnet.
|
|
*/
|
|
export async function determineCheatSuccess(
|
|
logger: (s: string) => void,
|
|
callback: () => void,
|
|
successRngOverride?: number,
|
|
ejectRngOverride?: number,
|
|
): Promise<Play> {
|
|
const state = Go.currentGame;
|
|
const rng = new WHRNG(Player.totalPlaytime);
|
|
// If cheat is successful, run callback
|
|
if ((successRngOverride ?? rng.random()) <= cheatSuccessChance(state.cheatCount)) {
|
|
callback();
|
|
state.cheatCount++;
|
|
GoEvents.emit();
|
|
return getAIMove(state);
|
|
}
|
|
// If there have been prior cheat attempts, and the cheat fails, there is a 10% chance of instantly losing
|
|
else if (state.cheatCount && (ejectRngOverride ?? rng.random()) < 0.1) {
|
|
logger(`Cheat failed! You have been ejected from the subnet.`);
|
|
resetBoardState(logger, logger, state.ai, state.board[0].length);
|
|
return {
|
|
type: GoPlayType.gameOver,
|
|
x: null,
|
|
y: null,
|
|
};
|
|
}
|
|
// If the cheat fails, your turn is skipped
|
|
else {
|
|
logger(`Cheat failed. Your turn has been skipped.`);
|
|
passTurn(state, GoColor.black, false);
|
|
state.cheatCount++;
|
|
return getAIMove(state);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Cheating success rate scales with player's crime success rate, and decreases with prior cheat attempts.
|
|
*
|
|
* The source file bonus is additive success chance on top of the other multipliers.
|
|
*
|
|
* Cheat success chance required for N cheats with 100% success rate in a game:
|
|
*
|
|
* 1 100% success rate cheat requires +66% increased crime success rate
|
|
* 2 100% success cheats: +145% increased crime success rate
|
|
* 3: +282%
|
|
* 4: +535%
|
|
* 5: +1027%
|
|
* 7: +4278%
|
|
* 10: +59,854%
|
|
* 12: +534,704%
|
|
* 15: +31,358,645%
|
|
*/
|
|
export function cheatSuccessChance(cheatCount: number) {
|
|
const sourceFileBonus = Player.sourceFileLvl(14) === 3 ? 0.25 : 0;
|
|
const cheatCountScalar = (0.7 - 0.02 * cheatCount) ** cheatCount;
|
|
return Math.max(Math.min(0.6 * cheatCountScalar * Player.mults.crime_success + sourceFileBonus, 1), 0);
|
|
}
|
|
|
|
/**
|
|
* Attempts to remove an existing router from the board. Can fail. If failed, can immediately end the game
|
|
*/
|
|
export function cheatRemoveRouter(
|
|
logger: (s: string) => void,
|
|
x: number,
|
|
y: number,
|
|
successRngOverride?: number,
|
|
ejectRngOverride?: number,
|
|
) {
|
|
const point = Go.currentGame.board[x][y]!;
|
|
return determineCheatSuccess(
|
|
logger,
|
|
() => {
|
|
point.color = GoColor.empty;
|
|
updateChains(Go.currentGame.board);
|
|
Go.currentGame.previousPlayer = GoColor.black;
|
|
logger(`Cheat successful. The point ${x},${y} was cleared.`);
|
|
},
|
|
successRngOverride,
|
|
ejectRngOverride,
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Attempts play two moves at once. Can fail. If failed, can immediately end the game
|
|
*/
|
|
export function cheatPlayTwoMoves(
|
|
logger: (s: string) => void,
|
|
x1: number,
|
|
y1: number,
|
|
x2: number,
|
|
y2: number,
|
|
successRngOverride?: number,
|
|
ejectRngOverride?: number,
|
|
) {
|
|
const point1 = Go.currentGame.board[x1][y1]!;
|
|
const point2 = Go.currentGame.board[x2][y2]!;
|
|
|
|
return determineCheatSuccess(
|
|
logger,
|
|
() => {
|
|
point1.color = GoColor.black;
|
|
point2.color = GoColor.black;
|
|
updateCaptures(Go.currentGame.board, GoColor.black);
|
|
Go.currentGame.previousPlayer = GoColor.black;
|
|
|
|
logger(`Cheat successful. Two go moves played: ${x1},${y1} and ${x2},${y2}`);
|
|
},
|
|
successRngOverride,
|
|
ejectRngOverride,
|
|
);
|
|
}
|
|
|
|
export function cheatRepairOfflineNode(
|
|
logger: (s: string) => void,
|
|
x: number,
|
|
y: number,
|
|
successRngOverride?: number,
|
|
ejectRngOverride?: number,
|
|
) {
|
|
return determineCheatSuccess(
|
|
logger,
|
|
() => {
|
|
Go.currentGame.board[x][y] = {
|
|
chain: "",
|
|
liberties: null,
|
|
y,
|
|
color: GoColor.empty,
|
|
x,
|
|
};
|
|
updateChains(Go.currentGame.board);
|
|
Go.currentGame.previousPlayer = GoColor.black;
|
|
logger(`Cheat successful. The point ${x},${y} was repaired.`);
|
|
},
|
|
successRngOverride,
|
|
ejectRngOverride,
|
|
);
|
|
}
|
|
|
|
export function cheatDestroyNode(
|
|
logger: (s: string) => void,
|
|
x: number,
|
|
y: number,
|
|
successRngOverride?: number,
|
|
ejectRngOverride?: number,
|
|
) {
|
|
return determineCheatSuccess(
|
|
logger,
|
|
() => {
|
|
Go.currentGame.board[x][y] = null;
|
|
updateChains(Go.currentGame.board);
|
|
Go.currentGame.previousPlayer = GoColor.black;
|
|
logger(`Cheat successful. The point ${x},${y} was destroyed.`);
|
|
},
|
|
successRngOverride,
|
|
ejectRngOverride,
|
|
);
|
|
}
|