@konoui/mjimage 0.0.1 → 0.0.2

package/dist/mjs/lib/controller/efficiency.d.ts

@@ -0,0 +1,36 @@
+import { Wind } from "../constants";
+import { Tile } from "../parser";
+import { Hand } from "../calculator";
+import { Counter } from "./managers";
+export interface Candidate {
+    tile: Tile;
+    candidates: Tile[];
+    shanten: number;
+}
+export declare class Efficiency {
+    static calcCandidates(hand: Hand, choices: Tile[]): Candidate[];
+    static candidateTiles(hand: Hand): {
+        shanten: number;
+        candidates: Tile[];
+    };
+}
+export interface PlayerCandidate {
+    tile: Tile;
+    sum: number;
+    candidates: {
+        tile: Tile;
+        n: number;
+    }[];
+    shanten: number;
+}
+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 class RiskRank {
+    static selectTile(c: Counter, targetUsers: Wind[], tiles: Tile[]): Tile;
+    static rank(c: Counter, targetUsers: Wind[], t: Tile): number;
+    static rankZ(c: Counter, targetUser: Wind, t: Tile): number;
+    static rankN(c: Counter, targetUser: Wind, t: Tile): 0 | 3 | 4 | 8 | 5 | 6 | 12;
+}

package/dist/mjs/lib/controller/efficiency.js

@@ -0,0 +1,217 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RiskRank = exports.PlayerEfficiency = exports.Efficiency = void 0;
+var assert_1 = __importDefault(require("assert"));
+var constants_1 = require("../constants");
+var parser_1 = require("../parser");
+var calculator_1 = require("../calculator");
+var Efficiency = (function () {
+    function Efficiency() {
+    }
+    Efficiency.calcCandidates = function (hand, choices) {
+        (0, assert_1.default)(choices.length > 0, "choices to discard is zero");
+        var ret = [];
+        for (var _i = 0, choices_1 = choices; _i < choices_1.length; _i++) {
+            var t = choices_1[_i];
+            var tiles = hand.dec([t]);
+            var c = Efficiency.candidateTiles(hand);
+            hand.inc(tiles);
+            if (ret.length == 0 || c.shanten < ret[0].shanten) {
+                ret = [
+                    {
+                        shanten: c.shanten,
+                        candidates: c.candidates,
+                        tile: t,
+                    },
+                ];
+            }
+            else if (c.shanten == ret[0].shanten) {
+                ret.push({
+                    candidates: c.candidates,
+                    shanten: c.shanten,
+                    tile: t,
+                });
+            }
+        }
+        return ret;
+    };
+    Efficiency.candidateTiles = function (hand) {
+        var r = Number.POSITIVE_INFINITY;
+        var candidates = [];
+        for (var _i = 0, _a = Object.values(constants_1.KIND); _i < _a.length; _i++) {
+            var k = _a[_i];
+            if (k == constants_1.KIND.BACK)
+                continue;
+            for (var n = 1; n < hand.getArrayLen(k); n++) {
+                if (hand.get(k, n) >= 4)
+                    continue;
+                var t = new parser_1.Tile(k, n);
+                var tiles = hand.inc([t]);
+                var s = new calculator_1.ShantenCalculator(hand).calc();
+                hand.dec(tiles);
+                if (s < r) {
+                    r = s;
+                    candidates = [t];
+                }
+                else if (s == r)
+                    candidates.push(t);
+            }
+        }
+        return {
+            shanten: r,
+            candidates: candidates,
+        };
+    };
+    return Efficiency;
+}());
+exports.Efficiency = Efficiency;
+var weight = function (t, doras) {
+    var base = 1;
+    var v = base;
+    for (var _i = 0, doras_1 = doras; _i < doras_1.length; _i++) {
+        var d = doras_1[_i];
+        if (d.equals(t, true))
+            v *= 2;
+    }
+    return v;
+};
+var PlayerEfficiency = (function () {
+    function PlayerEfficiency() {
+    }
+    PlayerEfficiency.calcPlayerCandidates = function (counter, candidates) {
+        var playerCandidates = [];
+        for (var _i = 0, candidates_1 = candidates; _i < candidates_1.length; _i++) {
+            var s = candidates_1[_i];
+            var sum = 0;
+            var pairs = [];
+            for (var _a = 0, _b = s.candidates; _a < _b.length; _a++) {
+                var c = _b[_a];
+                pairs.push({
+                    tile: c.clone(),
+                    n: counter.get(c),
+                });
+                sum += counter.get(c);
+            }
+            playerCandidates.push({
+                sum: sum,
+                tile: s.tile,
+                candidates: pairs,
+                shanten: s.shanten,
+            });
+        }
+        return playerCandidates;
+    };
+    PlayerEfficiency.selectMinPriority = function (c, playerCandidates, doras) {
+        (0, assert_1.default)(playerCandidates.length > 0);
+        var min = 0;
+        var idx = 0;
+        for (var i = 0; i < playerCandidates.length; i++) {
+            var p = PlayerEfficiency.calcPriority(c, playerCandidates[i], doras);
+            if (p < min) {
+                min = p;
+                idx = i;
+            }
+        }
+        return playerCandidates[idx];
+    };
+    PlayerEfficiency.calcPriority = function (c, playerCandidate, doras) {
+        var tile = playerCandidate.tile;
+        var v = 0;
+        if (tile.k == constants_1.KIND.Z) {
+            v = c.get(tile);
+            if (tile.n == 5 || tile.n == 6 || tile.n == 7)
+                v *= 2;
+            return v * weight(tile, doras);
+        }
+        else {
+            var same = c.get(tile);
+            v += same * weight(tile, doras);
+            var np1 = c.get(new parser_1.Tile(tile.k, tile.n + 1)), np2 = c.get(new parser_1.Tile(tile.k, tile.n + 2));
+            var nm1 = c.get(new parser_1.Tile(tile.k, tile.n - 1)), nm2 = c.get(new parser_1.Tile(tile.k, tile.n - 2));
+            var left = tile.n - 2 > 0 ? Math.min(nm1, nm2) : 0;
+            var right = tile.n + 2 <= 9 ? Math.min(np1, np2) : 0;
+            var cc = tile.n - 1 >= 1 && tile.n + 1 <= 9 ? Math.min(np1, nm1) : 0;
+            var centerLeft = Math.max(left, cc);
+            var centerRight = Math.max(cc, right);
+            v += same * weight(tile, doras);
+            v += left * weight(new parser_1.Tile(tile.k, tile.n - 2), doras);
+            v += right * weight(new parser_1.Tile(tile.k, tile.n + 2), doras);
+            v += centerLeft * weight(new parser_1.Tile(tile.k, tile.n - 1), doras);
+            v += centerRight * weight(new parser_1.Tile(tile.k, tile.n + 1), doras);
+            if (tile.n == 0)
+                v * 2;
+            return v;
+        }
+    };
+    return PlayerEfficiency;
+}());
+exports.PlayerEfficiency = PlayerEfficiency;
+var RiskRank = (function () {
+    function RiskRank() {
+    }
+    RiskRank.selectTile = function (c, targetUsers, tiles) {
+        (0, assert_1.default)(targetUsers.length > 0 && tiles.length > 0);
+        var ret = tiles[0];
+        var min = Number.POSITIVE_INFINITY;
+        for (var _i = 0, tiles_1 = tiles; _i < tiles_1.length; _i++) {
+            var t = tiles_1[_i];
+            var v = RiskRank.rank(c, targetUsers, t);
+            if (v < min) {
+                ret = t;
+                min = v;
+            }
+        }
+        return ret;
+    };
+    RiskRank.rank = function (c, targetUsers, t) {
+        var max = 0;
+        var f = t.isNum() ? RiskRank.rankN : RiskRank.rankZ;
+        for (var _i = 0, targetUsers_1 = targetUsers; _i < targetUsers_1.length; _i++) {
+            var targetUser = targetUsers_1[_i];
+            var v = f(c, targetUser, t);
+            if (max < v)
+                max = v;
+        }
+        return max;
+    };
+    RiskRank.rankZ = function (c, targetUser, t) {
+        if (t.k != constants_1.KIND.Z)
+            throw new Error("expected KIND.Z but ".concat(t.toString()));
+        if (c.isSafeTile(t.k, t.n, targetUser))
+            return 0;
+        var remaining = c.get(t);
+        return Math.min(remaining, 3);
+    };
+    RiskRank.rankN = function (c, targetUser, t) {
+        if (!t.isNum())
+            throw new Error("expected KIND.NUMBER but ".concat(t.toString()));
+        var n = t.n;
+        var k = t.k;
+        if (c.isSafeTile(k, n, targetUser))
+            return 0;
+        if (n == 1)
+            return c.isSafeTile(k, 4, targetUser) ? 3 : 6;
+        if (n == 9)
+            return c.isSafeTile(k, 6, targetUser) ? 3 : 6;
+        if (n == 2)
+            return c.isSafeTile(k, 5, targetUser) ? 4 : 8;
+        if (n == 8)
+            return c.isSafeTile(k, 5, targetUser) ? 4 : 8;
+        if (n == 3)
+            return c.isSafeTile(k, 6, targetUser) ? 5 : 8;
+        if (n == 7)
+            return c.isSafeTile(k, 4, targetUser) ? 5 : 8;
+        var left = c.isSafeTile(k, n - 3, targetUser);
+        var right = c.isSafeTile(k, n + 3, targetUser);
+        if (left && right)
+            return 4;
+        if (left || right)
+            return 8;
+        return 12;
+    };
+    return RiskRank;
+}());
+exports.RiskRank = RiskRank;

package/dist/mjs/lib/controller/events.d.ts

@@ -0,0 +1,172 @@
+import { Wind, Round } from "../constants";
+import { BlockAnKan, BlockChi, BlockDaiKan, BlockPon, BlockShoKan, Tile } from "../parser";
+import { Candidate } from "./";
+import { WinResult } from "../calculator";
+type Event = CallEvent | "DRAW" | "CHOICE_AFTER_DRAWN" | "CHOICE_AFTER_DISCARDED" | "CHOICE_AFTER_CALLED" | "CHOICE_FOR_CHAN_KAN" | "DISTRIBUTE" | "NEW_DORA" | "END_GAME";
+type ChoiceEvent = "PON" | "CHI" | "RON" | "DISCARD" | "TSUMO" | "REACH" | "AN_KAN" | "SHO_KAN" | "DAI_KAN" | "DRAWN_GAME_BY_NINE_TILES";
+export interface DistributeEvent {
+    id: string;
+    type: Extract<Event, "DISTRIBUTE">;
+    hands: {
+        [key in Wind]: string;
+    };
+    wind: Wind;
+    doraMarker: Tile;
+    players: string[];
+    places: {
+        [key: string]: Wind;
+    };
+    sticks: {
+        reach: number;
+        dead: number;
+    };
+    round: Round;
+    scores: {
+        [key: string]: number;
+    };
+}
+export interface EndEvent {
+    id: string;
+    type: Extract<Event, "END_GAME">;
+    subType: "WIN_GAME" | "DRAWN_GAME" | "FOUR_KAN" | "FOUR_WIND" | "NINE_TILES";
+    wind: Wind;
+    scores: {
+        [key: string]: number;
+    };
+    sticks: {
+        reach: number;
+        dead: number;
+    };
+    deltas: {
+        [key in Wind]: number;
+    };
+    hands: {
+        [key in Wind]: string;
+    };
+    shouldContinue: boolean;
+}
+export interface CallEvent {
+    id: string;
+    type: Extract<ChoiceEvent, "PON" | "CHI" | "AN_KAN" | "SHO_KAN" | "DAI_KAN">;
+    iam: Wind;
+    wind: Wind;
+    block: BlockPon | BlockChi | BlockAnKan | BlockShoKan | BlockDaiKan;
+}
+export interface RonEvent {
+    id: string;
+    type: Extract<ChoiceEvent, "RON">;
+    iam: Wind;
+    wind: Wind;
+    ret: WinResult;
+    targetInfo: {
+        wind: Wind;
+        tile: Tile;
+    };
+    pushBackReachStick: boolean;
+}
+export interface TsumoEvent {
+    id: string;
+    type: Extract<ChoiceEvent, "TSUMO">;
+    iam: Wind;
+    wind: Wind;
+    lastTile: Tile;
+    ret: WinResult;
+}
+export interface DiscardEvent {
+    id: string;
+    type: Extract<ChoiceEvent, "DISCARD">;
+    iam: Wind;
+    wind: Wind;
+    tile: Tile;
+}
+export interface DrawEvent {
+    id: string;
+    type: Extract<Event, "DRAW">;
+    subtype?: "kan";
+    iam: Wind;
+    wind: Wind;
+    tile: Tile;
+}
+export interface ReachEvent {
+    id: string;
+    type: Extract<ChoiceEvent, "REACH">;
+    tile: Tile;
+    iam: Wind;
+    wind: Wind;
+}
+export interface NewDoraEvent {
+    id: string;
+    type: Extract<Event, "NEW_DORA">;
+    doraMarker: Tile;
+    wind: Wind;
+}
+export interface ChoiceAfterDrawnEvent {
+    id: string;
+    type: Extract<Event, "CHOICE_AFTER_DRAWN">;
+    wind: Wind;
+    tileInfo: {
+        wind: Wind;
+        tile: Tile;
+    };
+    choices: DrawnChoice;
+}
+export interface ChoiceAfterDiscardedEvent {
+    id: string;
+    type: Extract<Event, "CHOICE_AFTER_DISCARDED">;
+    wind: Wind;
+    tileInfo: {
+        wind: Wind;
+        tile: Tile;
+    };
+    choices: DiscardedChoice;
+}
+export interface ChoiceAfterCalled {
+    id: string;
+    type: Extract<Event, "CHOICE_AFTER_CALLED">;
+    wind: Wind;
+    choices: Pick<DrawnChoice, "DISCARD">;
+}
+export interface ChoiceForChanKan {
+    id: string;
+    type: Extract<Event, "CHOICE_FOR_CHAN_KAN">;
+    wind: Wind;
+    tileInfo: {
+        wind: Wind;
+        tile: Tile;
+    };
+    choices: Pick<DiscardedChoice, "RON">;
+}
+export type PlayerEvent = DistributeEvent | EndEvent | CallEvent | RonEvent | TsumoEvent | DiscardEvent | DrawEvent | ReachEvent | NewDoraEvent | ChoiceAfterDrawnEvent | ChoiceAfterDiscardedEvent | ChoiceAfterCalled | ChoiceForChanKan;
+interface DiscardedChoice {
+    RON: false | WinResult;
+    PON: false | BlockPon[];
+    CHI: false | BlockChi[];
+    DAI_KAN: false | BlockDaiKan;
+}
+interface DrawnChoice {
+    TSUMO: false | WinResult;
+    REACH: false | Candidate[];
+    AN_KAN: false | BlockAnKan[];
+    SHO_KAN: false | BlockShoKan[];
+    DISCARD: false | Tile[];
+    DRAWN_GAME_BY_NINE_TILES: boolean;
+}
+export declare function prioritizeDiscardedEvents(events: ChoiceAfterDiscardedEvent[]): {
+    events: ChoiceAfterDiscardedEvent[];
+    type: boolean | keyof DiscardedChoice;
+};
+export declare function prioritizeDrawnEvents(events: ChoiceAfterDrawnEvent[]): {
+    events: ChoiceAfterDrawnEvent[];
+    type: boolean | keyof DrawnChoice;
+};
+export interface EventHandler {
+    emit(e: PlayerEvent): void;
+    on(handler: EventHandlerFunc): void;
+}
+export type EventHandlerFunc = (e: PlayerEvent) => void;
+export declare const createEventPipe: () => [EventHandler, EventHandler];
+export declare const createEventEmitter: () => {
+    emit: (e: PlayerEvent) => void;
+    on: (h: EventHandlerFunc) => void;
+};
+export {};

package/dist/mjs/lib/controller/events.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEventEmitter = exports.createEventPipe = exports.prioritizeDrawnEvents = exports.prioritizeDiscardedEvents = void 0;
+var eventmit_1 = require("eventmit");
+function prioritizeDiscardedEvents(events) {
+    var _a;
+    var order = ["RON", "DAI_KAN", "PON", "CHI"];
+    var choices = events.map(function (e) { return e.choices; });
+    var indexes = prioritizeEvents(choices, order);
+    var selected = indexes.map(function (idx) { return events[idx]; });
+    return {
+        events: selected,
+        type: priorityIndex(order, (_a = selected[0]) === null || _a === void 0 ? void 0 : _a.choices),
+    };
+}
+exports.prioritizeDiscardedEvents = prioritizeDiscardedEvents;
+function prioritizeDrawnEvents(events) {
+    var _a;
+    var order = [
+        "TSUMO",
+        "REACH",
+        "AN_KAN",
+        "SHO_KAN",
+        "DRAWN_GAME_BY_NINE_TILES",
+        "DISCARD",
+    ];
+    var choices = events.map(function (e) { return e.choices; });
+    var indexes = prioritizeEvents(choices, order);
+    var selected = indexes.map(function (idx) { return events[idx]; });
+    return {
+        events: selected,
+        type: priorityIndex(order, (_a = selected[0]) === null || _a === void 0 ? void 0 : _a.choices),
+    };
+}
+exports.prioritizeDrawnEvents = prioritizeDrawnEvents;
+function prioritizeEvents(choices, order) {
+    var highestPriorityIndices = [];
+    var highestPriority = Number.POSITIVE_INFINITY;
+    for (var i = 0; i < choices.length; i++) {
+        var choice = choices[i];
+        if (hasChoices(choice, order)) {
+            var priority = calculatePriority(order, choice);
+            if (priority < highestPriority) {
+                highestPriority = priority;
+                highestPriorityIndices = [i];
+            }
+            else if (priority === highestPriority) {
+                highestPriorityIndices.push(i);
+            }
+        }
+    }
+    return highestPriorityIndices;
+}
+function hasChoices(choice, order) {
+    return order.some(function (v) { return !!choice[v]; });
+}
+function calculatePriority(order, choice) {
+    for (var i = 0; i < order.length; i++) {
+        var key = order[i];
+        if (!!choice[key])
+            return i;
+    }
+    return Number.POSITIVE_INFINITY;
+}
+function priorityIndex(order, choice) {
+    if (choice == null)
+        return false;
+    for (var _i = 0, order_1 = order; _i < order_1.length; _i++) {
+        var key = order_1[_i];
+        if (!!choice[key])
+            return key;
+    }
+    return false;
+}
+var createEventPipe = function () {
+    var e1 = (0, eventmit_1.eventmit)();
+    var e2 = (0, eventmit_1.eventmit)();
+    var p1 = {
+        emit: e1.emit,
+        on: function (h) { return e2.on(h); },
+    };
+    var p2 = {
+        emit: e2.emit,
+        on: function (h) { return e1.on(h); },
+    };
+    return [p1, p2];
+};
+exports.createEventPipe = createEventPipe;
+var createEventEmitter = function () {
+    var emitter = (0, eventmit_1.eventmit)();
+    var emit = function (e) {
+        emitter.emit(e);
+    };
+    var on = function (h) {
+        emitter.on(h);
+    };
+    return {
+        emit: emit,
+        on: on,
+    };
+};
+exports.createEventEmitter = createEventEmitter;

package/dist/mjs/lib/controller/game.d.ts

@@ -0,0 +1,5 @@
+import { Controller } from "../controller";
+export declare const createLocalGame: (params?: {
+    playerIDs?: string[] | undefined;
+    debug?: boolean | undefined;
+} | undefined) => Controller;

package/dist/mjs/lib/controller/game.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLocalGame = void 0;
+var controller_1 = require("../controller");
+var createLocalGame = function (params) {
+    var _a;
+    var _b = (0, controller_1.createEventPipe)(), ce1 = _b[0], pe1 = _b[1];
+    var _c = (0, controller_1.createEventPipe)(), ce2 = _c[0], pe2 = _c[1];
+    var _d = (0, controller_1.createEventPipe)(), ce3 = _d[0], pe3 = _d[1];
+    var _e = (0, controller_1.createEventPipe)(), ce4 = _e[0], pe4 = _e[1];
+    var playerIDs = (_a = params === null || params === void 0 ? void 0 : params.playerIDs) !== null && _a !== void 0 ? _a : [
+        "player-1",
+        "player-2",
+        "player-3",
+        "player-4",
+    ];
+    new controller_1.Player(playerIDs[0], pe1);
+    new controller_1.Player(playerIDs[1], pe2);
+    new controller_1.Player(playerIDs[2], pe3);
+    new controller_1.Player(playerIDs[3], pe4);
+    var players = [
+        { handler: ce1, id: playerIDs[0] },
+        { handler: ce2, id: playerIDs[1] },
+        { handler: ce3, id: playerIDs[2] },
+        { handler: ce4, id: playerIDs[3] },
+    ];
+    return new controller_1.Controller(players, { debug: params === null || params === void 0 ? void 0 : params.debug });
+};
+exports.createLocalGame = createLocalGame;

package/dist/mjs/lib/controller/index.d.ts

@@ -0,0 +1,10 @@
+export * from "./events";
+export * from "./managers";
+export * from "./river";
+export * from "./state-machine";
+export * from "./wall";
+export * from "./controller";
+export * from "./player";
+export * from "./replay";
+export * from "./game";
+export * from "./efficiency";

package/dist/mjs/lib/controller/index.js

@@ -0,0 +1,26 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./events"), exports);
+__exportStar(require("./managers"), exports);
+__exportStar(require("./river"), exports);
+__exportStar(require("./state-machine"), exports);
+__exportStar(require("./wall"), exports);
+__exportStar(require("./controller"), exports);
+__exportStar(require("./player"), exports);
+__exportStar(require("./replay"), exports);
+__exportStar(require("./game"), exports);
+__exportStar(require("./efficiency"), exports);

package/dist/mjs/lib/controller/managers.d.ts

@@ -0,0 +1,89 @@
+import { Wind, Round } from "../constants";
+import { Kind, Tile } from "../parser";
+export declare class ScoreManager {
+    private reachValue;
+    private m;
+    constructor(initial: {
+        [key: string]: number;
+    });
+    get summary(): {
+        [key: string]: number;
+    };
+    reach(id: string): void;
+    restoreReachStick(id: string): void;
+    update(result: {
+        "1w": number;
+        "2w": number;
+        "3w": number;
+        "4w": number;
+    }, windMap: {
+        [key: string]: Wind;
+    }): void;
+}
+export declare class PlaceManager {
+    private pToW;
+    private wToP;
+    round: Round;
+    sticks: {
+        reach: number;
+        dead: number;
+    };
+    constructor(initial: {
+        [key: string]: Wind;
+    }, params?: {
+        round: Round;
+        sticks: {
+            reach: number;
+            dead: number;
+        };
+    });
+    private update;
+    incrementDeadStick(): void;
+    incrementReachStick(): void;
+    nextRound(): void;
+    decrementReachStick(): void;
+    resetDeadStick(): void;
+    resetReachStick(): void;
+    is(r: Round): boolean;
+    wind(id: string): "1w" | "2w" | "3w" | "4w";
+    playerID(w: Wind): string;
+    get playerMap(): {
+        [key: string]: "1w" | "2w" | "3w" | "4w";
+    };
+}
+export declare const nextRound: (r: Round) => "1w1" | "1w2" | "1w3" | "1w4" | "2w1" | "2w2" | "2w3" | "2w4" | "3w1" | "3w2" | "3w3" | "3w4" | "4w1" | "4w2" | "4w3" | "4w4";
+export declare const prevRound: (r: Round) => "1w1" | "1w2" | "1w3" | "1w4" | "2w1" | "2w2" | "2w3" | "2w4" | "3w1" | "3w2" | "3w3" | "3w4" | "4w1" | "4w2" | "4w3" | "4w4";
+export declare const nextWind: (w: Wind) => Wind;
+export declare const prevWind: (w: Wind) => Wind;
+export declare function createWindMap<T>(initial: T, clone?: boolean): {
+    "1w": T;
+    "2w": T;
+    "3w": T;
+    "4w": T;
+};
+export declare function shuffle<T>(array: T[]): T[];
+export declare class Counter {
+    disable: boolean;
+    private c;
+    safeMap: {
+        "1w": {
+            [name: string]: boolean;
+        };
+        "2w": {
+            [name: string]: boolean;
+        };
+        "3w": {
+            [name: string]: boolean;
+        };
+        "4w": {
+            [name: string]: boolean;
+        };
+    };
+    constructor(disable?: boolean);
+    get(t: Tile): number;
+    dec(...tiles: Tile[]): void;
+    addTileToSafeMap(t: Tile, targetUser: Wind): void;
+    isSafeTile(k: Kind, n: number, targetUser: Wind): boolean;
+    private key;
+    reset(): void;
+}