goban-engine/build/engine/ScoreEstimator.d.ts

This contains the built Go engine that is used by the Goban package. There are no display components in this package, only the logic for playing the game of Go, making it suitable for usage in node.js or other server-side environments.

import { NumberMatrix } from "./util";
import { StoneString } from "./StoneString";
import type { GobanBase } from "../GobanBase";
import { GobanEngine, PlayerScore, GobanEngineRules } from "./GobanEngine";
import { JGOFMove, JGOFNumericPlayerColor, JGOFSealingIntersection } from "./formats/JGOF";
import { BoardState } from "./BoardState";
export interface ScoreEstimateRequest {
    player_to_move: "black" | "white";
    width: number;
    height: number;
    board_state: JGOFNumericPlayerColor[][];
    rules: GobanEngineRules;
    black_prisoners?: number;
    white_prisoners?: number;
    komi?: number;
    jwt: string;
    /** Whether to run autoscoring logic. If true, player_to_move is
     * essentially ignored as we compute estimates with each player moving
     * first in turn. */
    autoscore?: boolean;
}
export interface ScoreEstimateResponse {
    /** Matrix of ownership estimates ranged from -1 (white) to 1 (black) */
    ownership: number[][];
    /** Estimated score */
    score?: number;
    /** Estimated win rate */
    win_rate?: number;
    /** Board state after autoscoring logic has been run. Only defined if autoscore was true in the request. */
    autoscored_board_state?: JGOFNumericPlayerColor[][];
    /** Intersections that are dead or dame.  Only defined if autoscore was true in the request. */
    autoscored_removed?: JGOFMove[];
    /** Coordinates that still need sealing */
    autoscored_needs_sealing?: JGOFSealingIntersection[];
}
/**
 * The interface that local estimators should follow.
 *
 * @param board representation of the board with any dead stones already
 *              removed (black = 1, empty = 0, white = -1)
 * @param color_to_move the player whose turn it is
 * @param trials number of playouts.  Not applicable to all estimators, but
 *               higher generally means higher accuracy and higher compute cost
 * @param tolerance (0.0-1.0) confidence required to mark an intersection not neutral.
 */
type LocalEstimator = (board: number[][], color_to_move: "black" | "white", trials: number, tolerance: number) => NumberMatrix;
export declare function set_local_ownership_estimator(estimator: LocalEstimator): void;
export declare class ScoreEstimator extends BoardState {
    white: PlayerScore;
    black: PlayerScore;
    engine: GobanEngine;
    private groups;
    tolerance: number;
    amount: number;
    ownership: Array<Array<number>>;
    territory: Array<Array<number>>;
    trials: number;
    winner: string;
    color_to_move: "black" | "white";
    estimated_hard_score: number;
    when_ready: Promise<void>;
    prefer_remote: boolean;
    autoscored_state?: JGOFNumericPlayerColor[][];
    autoscored_removed?: JGOFMove[];
    autoscore: boolean;
    autoscored_needs_sealing?: JGOFSealingIntersection[];
    constructor(engine: GobanEngine, goban_callback: GobanBase | undefined, trials: number, tolerance: number, prefer_remote?: boolean, autoscore?: boolean, removal?: boolean[][]);
    estimateScore(trials: number, tolerance: number, autoscore: boolean): Promise<void>;
    private estimateScoreRemote;
    private estimateScoreLocal;
    updateEstimate(estimated_score: number, ownership: Array<Array<number>>, score?: number): void;
    getProbablyDead(): string;
    handleClick(i: number, j: number, mod_key: boolean, press_duration_ms: number): void;
    setRemoved(x: number, y: number, removed: boolean): void;
    clearRemoved(): void;
    clearAutoScore(): void;
    getStoneRemovalString(): string;
    getGroup(x: number, y: number): StoneString;
    /**
     * Computes a rough estimation of ownership and score.
     */
    score(): ScoreEstimator;
}
/**
 * Adjust Estimate to account for Ruleset (i.e. territory vs area) and captures
 * @param engine Go engine is required because the ruleset is taken into account
 * @param board the current board state
 * @param area_map Representation of the ownership, 1=Black, -1=White, 0=Undecided
 *                 using Area rules
 * @param score estimated score (not accounting for captures)
 */
export declare function adjust_estimate(engine: GobanEngine, board: Array<Array<JGOFNumericPlayerColor>>, area_map: number[][], score: number): {
    score: number;
    ownership: import("./util").Matrix<number>;
};
export {};