@konoui/mjimage 0.5.1 → 0.6.0

package/dist/index.d.ts

@@ -1,7 +1,6 @@
 import { Actor } from 'xstate';
 import { AnyActorRef } from 'xstate';
 import { EventObject } from 'xstate';
-import { incrementalIDGenerator as incrementalIDGenerator_2 } from './state-machine';
 import { InferOutput } from 'valibot';
 import { MaxValueAction } from 'valibot';
 import { MetaObject } from 'xstate';
@@ -17,7 +16,6 @@ import { StateMachine } from 'xstate';
 import { StateValue } from 'xstate';
 import { StrictObjectSchema } from 'valibot';
 import { StringSchema } from 'valibot';
-import { Wind as Wind_2 } from '../..';
 
 export declare class ActorHand extends Hand {
     isBackHand(): boolean;
@@ -61,7 +59,7 @@ declare class BaseHelper {
     readonly scale: number;
     readonly svgSprite: boolean;
     constructor(props?: ImageHelperConfig);
-    protected getDiffTileHeightWidth(t: Tile): number;
+    protected getHorizontalTileYOffset(t: Tile): number;
     private image;
     createImage(tile: Tile, x: number, y: number): Image_2 | Use;
     createTextImage(tile: Tile, x: number, y: number, t: string): G;
@@ -117,6 +115,7 @@ export declare abstract class Block {
 
 export declare class BlockAnKan extends Block {
     constructor(tiles: readonly Tile[]);
+    get tiles(): readonly Tile[];
     get tilesWithBack(): Tile[];
     static from(s: string): BlockAnKan;
     toString(): string;
@@ -126,15 +125,17 @@ export declare class BlockCalculator {
     hand: Hand;
     constructor(hand: Hand);
     calc(lastTile: Tile): readonly Block[][];
-    markDrawn(hands: readonly Block[][], lastTile: Tile): readonly Block[][];
+    markedHands(hands: readonly Block[][], lastTile: Tile): readonly Block[][];
+    markedHand(hand: readonly Block[], lastTile: Tile): readonly Block[][];
     sevenPairs(): readonly Block[][];
     thirteenOrphans(): readonly Block[][];
     nineGates(): readonly Block[][];
-    fourSetsOnePair(): readonly Block[][];
-    private patternAll;
+    standardType(): readonly Block[][];
+    private calcAllBlockCombinations;
     private handleBack;
     private handleZ;
     private addRedPattern;
+    private addRedPatterns;
     private handleNumType;
 }
 
@@ -216,17 +217,15 @@ export declare interface BoardContext {
     finalWallWin?: boolean;
     finalDiscardWin?: boolean;
     oneShotWin?: boolean;
-    enableRoundUp8000?: boolean;
-    disableCountable32000?: boolean;
-    disableDouble32000?: boolean;
+    enableRoundUpMangan?: boolean;
+    disableCountableYakuman?: boolean;
+    disableDoubleYakuman?: boolean;
 }
 
 declare type BoardRound = (typeof ROUND_MAP)[keyof typeof ROUND_MAP];
 
 declare type BoardWind = (typeof WIND_MAP)[keyof typeof WIND_MAP];
 
-export declare const callBlockIndex: (caller: Wind, discardedBy: Wind, type: typeof BLOCK.PON | typeof BLOCK.DAI_KAN) => 0 | 1 | 2 | 3;
-
 export declare interface CallEvent {
     id: string;
     type: Extract<ChoiceEvent, "PON" | "CHI" | "AN_KAN" | "SHO_KAN" | "DAI_KAN">;
@@ -235,12 +234,6 @@ export declare interface CallEvent {
     block: SerializedBlock;
 }
 
-export declare interface Candidate {
-    tile: Tile;
-    candidates: readonly Tile[];
-    shanten: number;
-}
-
 export declare interface ChoiceAfterCalled {
     id: string;
     type: Extract<Event_2, "CHOICE_AFTER_CALLED">;
@@ -294,6 +287,8 @@ export declare interface ChoiceForReachAcceptance {
     choices: Pick<DiscardedChoice, "RON">;
 }
 
+export declare const compareTiles: (i: Tile, j: Tile) => number;
+
 export declare class Controller {
     wall: IWall;
     playerIDs: string[];
@@ -302,7 +297,7 @@ export declare class Controller {
     oneShotMap: { [key in Wind]: boolean; };
     missingMap: { [key in Wind]: boolean; };
     controller: Controller;
-    genEventID: ReturnType<incrementalIDGenerator_2>;
+    genEventID: ReturnType<incrementalIDGenerator>;
     }, {
     type: "";
     } | {
@@ -366,9 +361,9 @@ export declare class Controller {
     mailBox: {
         [id: string]: PlayerEvent[];
     };
-    histories: History_2[];
+    histories: GameHistory[];
     debugMode: boolean;
-    constructor(players: PlayerConnection[], params?: {
+    constructor(players: PlayerSession[], params?: {
         debug?: boolean;
         shuffle?: boolean;
     });
@@ -381,8 +376,8 @@ export declare class Controller {
     emit(e: PlayerEvent): void;
     enqueue(event: PlayerEvent): void;
     pollReplies(eventID: string, wind: Wind[]): void;
-    export(): History_2[];
-    static load(h: History_2): Controller;
+    export(): GameHistory[];
+    static load(h: GameHistory): Controller;
     start(): void;
     startGame(): void;
     finalResult(ret: WinResult, iam: Wind): WinResult;
@@ -396,7 +391,7 @@ export declare class Controller {
     doPon(w: Wind, discardedBy: Wind, t?: Tile): BlockPon[] | false;
     doChi(w: Wind, discardedBy: Wind, t?: Tile): BlockChi[] | false;
     redPattern(blocks: BlockChi[]): BlockChi[];
-    doReach(w: Wind): Candidate[] | false;
+    doReach(w: Wind): TileAnalysis[] | false;
     doDiscard(w: Wind, called?: BlockChi | BlockPon): Tile[];
     cannotDiscardTile(b: BlockChi): Tile[];
     doAnKan(w: Wind): BlockAnKan[] | false;
@@ -432,7 +427,7 @@ export declare const convertInput: (i: TableInput) => {
 export declare class Counter {
     disable: boolean;
     private c;
-    safeMap: {
+    safeTileMap: {
         "1z": {
             [name: string]: boolean;
         };
@@ -617,7 +612,7 @@ export declare interface DrawEvent {
 
 declare interface DrawnChoice {
     TSUMO: false | SerializedWinResult;
-    REACH: false | SerializedCandidate[];
+    REACH: false | SerializedTileAnalysis[];
     AN_KAN: false | SerializedBlock[];
     SHO_KAN: false | SerializedBlock[];
     DISCARD: false | string[];
@@ -634,16 +629,16 @@ export declare const drawTable: (svg: Svg, tableInput: string, config: ImageHelp
 }) => void;
 
 export declare class Efficiency {
-    static calcCandidates(hand: Hand, choices: Tile[], options?: {
+    static calcEffectiveTiles(hand: Hand, choices: Tile[], options?: {
         arrangeRed?: boolean;
-        fourSetsOnePair?: boolean;
-    }): Candidate[];
-    static candidateTiles(hand: Hand, options?: {
-        fourSetsOnePair?: boolean;
+        standardTypeOnly?: boolean;
+    }): TileAnalysis[];
+    static getEffectiveTiles(hand: Hand, options?: {
+        standardTypeOnly?: boolean;
         typeFilter?: Type[];
     }): {
         shanten: number;
-        candidates: Tile[];
+        effectiveTiles: Tile[];
     };
 }
 
@@ -708,6 +703,36 @@ export declare class G extends Mark {
     each(block: (idx: number, children: Mark[]) => void, deep: boolean): void;
 }
 
+export declare interface GameHistory {
+    round: Round;
+    scores: {
+        [wind in string]: number;
+    };
+    players: {
+        [id in string]: Wind;
+    };
+    sticks: {
+        reach: number;
+        dead: number;
+    };
+    wall: WallProps;
+    choiceEvents: {
+        [id: string]: PlayerEvent[];
+    };
+}
+
+export declare const getCallBlockIndex: (caller: Wind, discardedBy: Wind, type: typeof BLOCK.PON | typeof BLOCK.DAI_KAN) => 0 | 1 | 3 | 2;
+
+export declare function getPointDescription(params: {
+    base: number;
+    fu: number;
+    han: number;
+    isTsumo: boolean;
+    isParent: boolean;
+    isYakuman?: boolean;
+    isCountableYakuman?: boolean;
+}): string;
+
 export declare class Hand {
     protected data: HandData;
     constructor(input: string | Block[], allowBackBlock?: boolean);
@@ -748,25 +773,6 @@ export declare interface HandsInput {
     left: Block[];
 }
 
-declare interface History_2 {
-    round: Round;
-    scores: {
-        [key in string]: number;
-    };
-    players: {
-        [key in string]: Wind;
-    };
-    sticks: {
-        reach: number;
-        dead: number;
-    };
-    wall: WallProps;
-    choiceEvents: {
-        [id: string]: PlayerEvent[];
-    };
-}
-export { History_2 as History }
-
 declare class Image_2 extends Mark {
     attrs: Attrs & {
         href?: string;
@@ -809,7 +815,7 @@ export declare interface IRiver {
     cannotContinue(): boolean;
 }
 
-export declare function isNum5(t: Tile): boolean;
+export declare function is5Tile(t: Tile): boolean;
 
 export declare interface IWall {
     kan(): Tile;
@@ -905,7 +911,7 @@ export declare const OP: {
     readonly COLOR_GRAYSCALE: "^";
 };
 
-declare type Operator = (typeof OP)[keyof typeof OP];
+export declare type Operator = (typeof OP)[keyof typeof OP];
 
 export declare const optimizeSVG: (draw: Svg) => void;
 
@@ -923,7 +929,7 @@ export declare class Parser {
     tiles(): readonly Tile[];
     tileSeparators(): readonly (Tile | Separator)[];
     private makeBlocks;
-    validate(input: string): void;
+    private validate;
 }
 
 export declare const parseTableInput: (s: string) => {
@@ -959,8 +965,8 @@ export declare const parseTableInput: (s: string) => {
 };
 
 export declare class PlaceManager {
-    private pToW;
-    private wToP;
+    private playerToWind;
+    private windToPlayer;
     round: Round;
     sticks: {
         reach: number;
@@ -985,7 +991,7 @@ export declare class PlaceManager {
     wind(id: string): Wind;
     playerID(w: Wind): string;
     get playerMap(): {
-        [key: string]: Wind;
+        [id: string]: Wind;
     };
 }
 
@@ -993,40 +999,40 @@ export declare class Player extends BaseActor {
     river: River;
     doras: Tile[];
     constructor(playerID: string, eventHandler: EventHandler);
-    get myWind(): Wind_2;
+    get myWind(): Wind;
     setHands(e: DistributeEvent): void;
     handleDiscard(tiles: Tile[]): Tile;
     handleEvent(e: PlayerEvent): void;
 }
 
-export declare interface PlayerCandidate {
-    tile: Tile;
-    sum: number;
-    candidates: {
-        tile: Tile;
-        n: number;
-    }[];
-    shanten: number;
+export declare class PlayerEfficiency {
+    static analyzePlayerEfficiency(counter: Counter, analyses: TileAnalysis[]): PlayerTileAnalysis[];
+    static selectMinPriority(c: Counter, playerAnalyses: PlayerTileAnalysis[], doras: Tile[]): PlayerTileAnalysis;
+    private static calcPriority;
 }
 
-export declare interface PlayerConnection {
+export declare type PlayerEvent = DistributeEvent | EndEvent | CallEvent | RonEvent | TsumoEvent | DiscardEvent | DrawEvent | ReachEvent | ReachAcceptedEvent | NewDoraEvent | ChoiceAfterDrawnEvent | ChoiceAfterDiscardedEvent | ChoiceAfterCalled | ChoiceForReachAcceptance | ChoiceForChanKan;
+
+export declare interface PlayerSession {
     id: string;
     handler: EventHandler;
 }
 
-export declare class PlayerEfficiency {
-    static calcPlayerCandidates(counter: Counter, candidates: Candidate[]): PlayerCandidate[];
-    static selectMinPriority(c: Counter, playerCandidates: PlayerCandidate[], doras: Tile[]): PlayerCandidate;
-    private static calcPriority;
+export declare interface PlayerTileAnalysis {
+    tile: Tile;
+    sum: number;
+    effectiveTiles: {
+        tile: Tile;
+        count: number;
+    }[];
+    shanten: number;
 }
 
-export declare type PlayerEvent = DistributeEvent | EndEvent | CallEvent | RonEvent | TsumoEvent | DiscardEvent | DrawEvent | ReachEvent | ReachAcceptedEvent | NewDoraEvent | ChoiceAfterDrawnEvent | ChoiceAfterDiscardedEvent | ChoiceAfterCalled | ChoiceForReachAcceptance | ChoiceForChanKan;
-
 export declare class PointCalculator {
     hand: Hand;
     cfg: {
         doras: readonly Tile[];
-        blindDoras: readonly Tile[];
+        hiddenDoras: readonly Tile[];
         roundWind: Tile;
         myWind: Tile;
         reached: 0 | 1 | 2;
@@ -1039,19 +1045,26 @@ export declare class PointCalculator {
         finalWallWin: boolean;
         finalDiscardWin: boolean;
         oneShotWin: boolean;
-        enableRoundUp8000: boolean;
-        disableCountable32000: boolean;
-        disableDouble32000: boolean;
+        enableRoundUpMangan: boolean;
+        disableCountableYakuman: boolean;
+        disableDoubleYakuman: boolean;
         orig: BoardContext;
     };
     constructor(hand: Hand, params: BoardContext);
     calc(...hands: readonly Block[][]): WinResult | false;
-    calcPatterns(hands: readonly Block[][]): {
-        yakus: Yaku[];
-        fu: number;
-        hand: Block[];
-        is32000?: boolean;
-    }[];
+    getWinningHands(hands: readonly Block[][]): WinningHand[];
+    private selectBestHand;
+    private calculateScore;
+    private hasYakuman;
+    private isRoundUpMangan;
+    private isTsumoWin;
+    private calculateDeltas;
+    private calculateRonDeltas;
+    private calculateTsumoDeltas;
+    private calculateParentTsumoDeltas;
+    private calculateChildTsumoDeltas;
+    private addStickPoints;
+    private getBasePoints;
     private minus;
     dA1(h: readonly Block[]): Yaku[];
     dB1(h: readonly Block[]): Yaku[];
@@ -1137,7 +1150,7 @@ export declare class Rect extends Mark {
 
 export declare class Replayer {
     index: number;
-    histories: History_2[];
+    histories: GameHistory[];
     constructor(v: string);
     next(): void;
     prev(): void;
@@ -1161,7 +1174,11 @@ export declare class River {
         t: Tile;
         callMarker?: boolean;
     }[];
-    get lastTile(): any;
+    get lastTile(): {
+        w: Wind;
+        t: Tile;
+        callMarker?: boolean;
+    };
     markCalled(): void;
     cannotContinue(): boolean;
 }
@@ -1260,9 +1277,9 @@ declare type SerializedBoardContext = Omit<BoardContext, "doraIndicators" | "hid
     hiddenDoraIndicators?: readonly string[];
 };
 
-export declare interface SerializedCandidate {
+export declare interface SerializedTileAnalysis {
     tile: string;
-    candidates: readonly string[];
+    effectiveTiles: readonly string[];
     shanten: number;
 }
 
@@ -1279,10 +1296,10 @@ export declare class ShantenCalculator {
     calc(): number;
     sevenPairs(): number;
     thirteenOrphans(): number;
-    fourSetsOnePair(): number;
-    private patternNumType;
+    standardType(): number;
+    private calcNumberTilePatterns;
     private groupRemainingTiles;
-    private calcCommon;
+    private calcStandardType;
 }
 
 export declare function shuffle<T>(array: T[]): T[];
@@ -1432,7 +1449,11 @@ export declare const TILE_CONTEXT: {
     readonly BLOCK_MARGIN_SCALE: 0.3;
 };
 
-export declare const tileSortFunc: (i: Tile, j: Tile) => number;
+export declare interface TileAnalysis {
+    tile: Tile;
+    effectiveTiles: readonly Tile[];
+    shanten: number;
+}
 
 export declare const toDora: (doraIndicator: Tile) => Tile;
 
@@ -1513,16 +1534,20 @@ export declare const WIND_MAP: {
     readonly "4z": "北";
 };
 
-export declare interface WinResult {
+declare interface WinningHand {
+    hand: Block[];
+    fu: number;
+    yakus: readonly Yaku[];
+    han: number;
+    isYakuman?: boolean;
+}
+
+export declare interface WinResult extends WinningHand {
     deltas: {
         readonly [w in Wind]: number;
     };
-    han: number;
-    fu: number;
-    yakus: readonly Yaku[];
     points: number;
-    rawPoints: number;
-    hand: Block[];
+    basePoints: number;
     boardContext: BoardContext;
     description: string;
 }
@@ -1530,7 +1555,7 @@ export declare interface WinResult {
 export declare interface Yaku {
     name: string;
     han: number;
-    is32000?: boolean;
+    isYakuman?: boolean;
 }
 
 export { }