@thegraid/hexlib 1.0.0

package/dist/choosers.js

@@ -0,0 +1,59 @@
+import { C, S } from "@thegraid/common-lib";
+import { BoolChoice, Chooser, DropdownButton, DropdownChoice, EditBox, KeyBinder } from "@thegraid/easeljs-lib";
+/** no choice: a DropdownChoice with 1 mutable item that can be set by setValue(...) */
+export class NC extends DropdownChoice {
+    static style(defStyle) {
+        let baseStyle = DropdownButton.mergeStyle(defStyle);
+        let pidStyle = { arrowColor: 'transparent', textAlign: 'right' };
+        return DropdownButton.mergeStyle(pidStyle, baseStyle);
+    }
+    constructor(items, item_w, item_h, defStyle = {}) {
+        super(items, item_w, item_h, NC.style(defStyle));
+    }
+    /** never expand */
+    rootclick() { }
+    setValue(value, item, target) {
+        item.value = value; // for reference?
+        this._rootButton.text.text = value;
+        return true;
+    }
+}
+/** Chooser with an EditBox
+ *
+ * Bind M-v to pasteClipboard()
+ */
+export class EBC extends Chooser {
+    editBox;
+    constructor(items, item_w, item_h, style = {}) {
+        super(items, item_w, item_h, style);
+        style && (style.bgColor = style.fillColor);
+        style && (style.textColor = C.BLACK);
+        this.editBox = new EditBox({ x: 0, y: 0, w: item_w, h: item_h * 1 }, style);
+        this.addChild(this.editBox);
+        const scope = this.editBox.keyScope;
+        KeyBinder.keyBinder.setKey('M-v', () => this.pasteClipboard, scope);
+        this.on(S.click, () => this.editBox.setFocus(true), this);
+    }
+    /**
+     * insert text from window system clipboard: await navigator.clipboard.readText();
+     * @param pt where to inject text [this.point]
+     * @param n number of following chars to delete [0], if n<0 delete ALL following chars
+     */
+    pasteClipboard(pt = this.editBox.point, n = 0) {
+        const paste = async () => {
+            let text = await navigator.clipboard.readText();
+            this.editBox.splice(pt, n < 0 ? undefined : n, text);
+        };
+        paste();
+    }
+    setValue(value, item, target) {
+        this.editBox.setText(value);
+        return true;
+    }
+}
+/** like StatsPanel: read-only output field */
+export class PidChoice extends NC {
+}
+/** present [false, true] with any pair of string: ['false', 'true'] */
+export class BC extends BoolChoice {
+}

package/dist/counters.js

@@ -0,0 +1,155 @@
+import { S } from "@thegraid/common-lib";
+import { ValueCounter, ValueEvent } from "@thegraid/easeljs-lib"; // "./value-counter";
+import { Shape } from "@thegraid/easeljs-module";
+/** ValueCounter in a Rectangle. */
+export class ValueCounterBox extends ValueCounter {
+    /** return width, height; suitable for makeBox() => drawRect()  */
+    boxSize(text) {
+        const width = text.getMeasuredWidth();
+        const height = text.getMeasuredLineHeight();
+        const high = height * 1.1; // change from ellispe margins
+        const wide = Math.max(width * 1.1, high); // change from ellispe margins
+        return { width: wide, height: high };
+    }
+    makeBox(color, high, wide) {
+        let shape = new Shape();
+        shape.graphics.c().f(color).drawRect(-wide / 2, -high / 2, wide, high); // change from ellispe
+        return shape;
+    }
+}
+export class ButtonBox extends ValueCounterBox {
+    constructor(name, initValue, color, fontSize, fontName, textColor) {
+        super(name, initValue, color, fontSize, fontName, textColor);
+        this.mouseEnabled = true;
+    }
+}
+/** ValueCounter specifically for number values (not string), includes incValueEvent() and clickToInc() */
+export class NumCounter extends ValueCounter {
+    setValue(value) {
+        super.setValue(value);
+    }
+    getValue() {
+        return super.getValue() ?? 0;
+    }
+    incValue(incr) {
+        this.updateValue(this.getValue() + incr);
+        this.dispatchEvent(new ValueEvent('incr', incr));
+    }
+    /**
+     *
+     * @param incr configure click/incValue:
+     * - false: click does nothing
+     * - !false: click -> this.incValue()
+     * - NumCounter: this.incValue(x) -> incr.incValue(x)
+     */
+    clickToInc(incr = true) {
+        const incv = (evt) => (evt?.ctrlKey ? -1 : 1) * (evt?.shiftKey ? 10 : 1);
+        if (incr) {
+            this.mouseEnabled = true;
+            this.on(S.click, (evt) => this.incValue(incv(evt.nativeEvent)));
+            if (incr instanceof NumCounter) {
+                this.on('incr', (evt) => incr.incValue(evt.value));
+            }
+        }
+    }
+}
+/**
+ * NumCounterBoxLabeled: larger box to include the label.
+ */
+export class NumCounterBox extends NumCounter {
+    labelH = 0;
+    setLabel(label, offset, fontSize) {
+        fontSize = fontSize ?? this.labelFontSize;
+        offset = offset ?? { x: this.label?.x ?? 0, y: this.label?.y || (fontSize / 2) };
+        super.setLabel(label, offset, fontSize);
+        this.labelH = this.label?.text ? this.labelFontSize ?? 0 : 0;
+        this.wide = -1; // force new box
+        this.setBoxWithValue(this.value);
+    }
+    makeBox0(color, high, wide) {
+        const shape = new Shape();
+        shape.graphics.c().f(color).drawRect(-wide / 2, -high / 2, wide, high); // centered on {x,y}
+        return shape;
+    }
+    makeBox(color, high, wide) {
+        const yinc = this.label ? this.labelFontSize / 2 : 0; // dubious math; but works for now...
+        const shape = this.makeBox0(color, high + yinc, wide); // 4 px beneath for label
+        shape.y += yinc / 2;
+        return shape;
+    }
+    /** return width, height; suitable for makeBox() => drawRect()  */
+    boxSize(text) {
+        const width = text.getMeasuredWidth();
+        const height = text.getMeasuredLineHeight();
+        const high = height * 1.1; // change from ellispe margins
+        const wide = Math.max(width * 1.1, high); // change from ellispe margins
+        return { width: wide, height: high };
+    }
+}
+export class NoZeroCounter extends NumCounter {
+    setBoxWithValue(value) {
+        super.setBoxWithValue(value || '');
+    }
+}
+export class DecimalCounter extends NumCounterBox {
+    decimal = 0;
+    constructor(name, initValue, color, fontSize, fontName) {
+        super(name, initValue, color, fontSize, fontName);
+    }
+    setBoxWithValue(value) {
+        super.setBoxWithValue(value.toFixed(this.decimal));
+    }
+}
+export class PerRoundCounter extends DecimalCounter {
+    gamePlay;
+    get perRound() { return this.value / Math.max(1, Math.floor(this.gamePlay.turnNumber / 2)); }
+    decimal = 1;
+    setBoxWithValue(value) {
+        super.setBoxWithValue(this.perRound);
+    }
+}
+// export class CostIncCounter extends NumCounter {
+//   /**
+//    * Show InfR for curPlayer to place Tile;
+//    * @param hex place Counter above the given hex.
+//    * @param name internal identifyier
+//    * @param ndx cost increment based on CostIncMatrix[ndx]; -1 -> show no cost
+//    * @param repaint calc cost for: Player OR true/false->curPlayer;
+//    * - Note: false -> const cost, no repaint
+//    */
+//   constructor(
+//     public hex: Hex2,
+//     name = `costInc`,
+//     public ndx = -1,
+//     public repaint: boolean | Player = true
+//   ) {
+//     super(name, 0, 'grey', TP.hexRad / 2)
+//     const counterCont = hex.mapCont.counterCont;
+//     const xy = hex.cont.localToLocal(0, TP.hexRad * H.sqrt3_2, counterCont);
+//     this.attachToContainer(counterCont, xy);
+//   }
+//   protected override makeBox(color: string, high: number, wide: number): DisplayObject {
+//     const box = new InfShape('lightgrey');
+//     const size = Math.max(high, wide)
+//     box.scaleX = box.scaleY = .5 * size / TP.hexRad;
+//     return box
+//   }
+//   /** return width, height; suitable for makeBox() => drawRect()  */
+//   protected override boxSize(text: Text): { width: number; height: number } {
+//     let width = text.getMeasuredWidth();
+//     let height = text.getMeasuredLineHeight();
+//     let high = height * 1.1;
+//     let wide = Math.max(width * 1.1, high);
+//     let rv = { width: wide, height: high };
+//     return rv;
+//   }
+// }
+// class CostTotalCounter extends CostIncCounter {
+//   protected override makeBox(color: string, high: number, wide: number): DisplayObject {
+//     let box = new Shape();
+//     let size = Math.max(high, wide)
+//     box.graphics.c().f(C.coinGold).dc(0, 0, TP.hexRad);
+//     box.scaleX = box.scaleY = .5 * size / TP.hexRad;
+//     return box
+//   }
+// }

package/dist/game-play.js

@@ -0,0 +1,455 @@
+import { json } from "@thegraid/common-lib";
+import { KeyBinder, S, Undo, blinkAndThen, stime } from "@thegraid/easeljs-lib";
+import { Container } from "@thegraid/easeljs-module";
+import { GameState } from "./game-state";
+import { Hex, Hex2, HexMap } from "./hex";
+import { Meeple } from "./meeple";
+import { Player } from "./player";
+import { TP } from "./table-params";
+import { Tile } from "./tile";
+export class NamedContainer extends Container {
+    Aname;
+    constructor(name, cx = 0, cy = 0) {
+        super();
+        this.Aname = this.name = name;
+        this.x = cx;
+        this.y = cy;
+    }
+}
+class HexEvent {
+}
+class Move {
+    Aname = "";
+    ind = 0;
+    board = {};
+}
+/** Implement game, enforce the rules, manage GameStats & hexMap; no GUI/Table required.
+ *
+ * Actions are:
+ * - Reserve: place one Tile from auction to Player reserve
+ * - Recruit: place a Builder/Leader (in Civic);
+ *   do Build/Police action (requires 5 Econ)
+ * - Build: move Master/Builders, build one Tile (from auction or reserve)
+ * - Police: place one (in Station), move police (& leaders/builders), attack/capture;
+ *   collatoral damge (3 Econ); dismiss Police
+ * - Crime: place one on unoccupied hex adjacent to opponent Tile (requires 3 Econ)
+ *   move Criminals, attack/capture;
+ *   (Player keeps the captured Tile/Meeple; maybe earn VP if Crime Lord)
+ * -
+ */
+export class GamePlay0 {
+    gameSetup;
+    /** the latest GamePlay instance in this VM/context/process */
+    static gamePlay;
+    static gpid = 0;
+    id = GamePlay0.gpid++;
+    gameState = (this instanceof GamePlay) ? new GameState(this) : undefined;
+    get gamePhase() { return this.gameState.state; }
+    isPhase(name) { return this.gamePhase === this.gameState.states[name]; }
+    phaseDone(...args) { this.gameState.done(...args); }
+    recycleHex;
+    ll(n) { return TP.log > n; }
+    get logWriter() { return this.gameSetup.logWriter; }
+    get allPlayers() { return Player.allPlayers; }
+    get allTiles() { return Tile.allTiles; }
+    hexMap = new HexMap(TP.hexRad, true, Hex2); // create base map; no districts until Table.layoutTable!
+    history = []; // sequence of Move that bring board to its state
+    redoMoves = [];
+    logWriterLine0() {
+        const setup = this.gameSetup, thus = this, turn = thus.turnNumber;
+        let line = { time: stime.fs(), turn };
+        let line0 = json(line, true); // machine readable starting conditions
+        console.log(`-------------------- ${line0}`);
+        this.logWriter.writeLine(`{start: ${line0}},`);
+    }
+    /** GamePlay0 - supply GodNames for each: new Player(...). */
+    constructor(gameSetup) {
+        this.gameSetup = gameSetup;
+        this.hexMap.Aname = `mainMap`;
+        //this.hexMap.makeAllDistricts(); // For 'headless'; re-created by Table, after addToMapCont()
+    }
+    turnNumber = 0; // = history.lenth + 1 [by this.setNextPlayer]
+    curPlayerNdx = 0; // curPlayer defined in GamePlay extends GamePlay0
+    curPlayer;
+    preGame = true;
+    nextPlayer(plyr = this.curPlayer) {
+        const nxt = (plyr.index + 1) % Player.allPlayers.length;
+        return Player.allPlayers[nxt];
+    }
+    forEachPlayer(f) {
+        this.allPlayers.forEach((p, index, players) => f(p, index, players));
+    }
+    logText(line, from = '') {
+        if (this instanceof GamePlay)
+            this.table.logText(line, from);
+    }
+    /**
+     * When player has completed Actions and Event, do next player.
+     */
+    endTurn() {
+        // Jubilee if win condition:
+        if (this.isEndOfGame()) {
+            this.endGame();
+        }
+        else {
+            this.setNextPlayer();
+        }
+    }
+    endGame() {
+        const scores = [];
+        let topScore = -1, winner;
+        console.log(stime(this, `.endGame: Game Over`));
+        // console.log(stime(this, `.endGame: Winner = ${winner.Aname}`), scores);
+    }
+    newTurn() { }
+    setNextPlayer(turnNumber) {
+        if (turnNumber === undefined) {
+            this.turnNumber = turnNumber = this.turnNumber + 1;
+            this.newTurn(); // override calls saveState()
+        }
+        this.turnNumber = turnNumber;
+        const index = (turnNumber % this.allPlayers.length);
+        this.preGame = false;
+        this.curPlayerNdx = index;
+        this.curPlayer = this.allPlayers[index];
+        this.curPlayer.newTurn();
+    }
+    isEndOfGame() {
+        // can only win at the end of curPlayer's turn:
+        const endp = false;
+        if (endp)
+            console.log(stime(this, `.isEndOfGame:`));
+        return endp;
+    }
+    /** Planner may override with alternative impl. */
+    newMoveFunc;
+    newMove(hex, sc, caps, gp) {
+        return this.newMoveFunc ? this.newMoveFunc(hex, sc, caps, gp) : new Move();
+    }
+    undoRecs = new Undo().enableUndo();
+    addUndoRec(obj, name, value = obj.name) {
+        this.undoRecs.addUndoRec(obj, name, value);
+    }
+    /** update Counters (econ, expense, vp) for ALL players. */
+    updateCounters() {
+        // Player.allPlayers.forEach(player => player.setCounters(false));
+        this.hexMap.update();
+    }
+    logFailure(type, reqd, avail, toHex) {
+        const failText = `${type} required: ${reqd} > ${avail}`;
+        console.log(stime(this, `.failToPayCost:`), failText, toHex.Aname);
+        this.logText(failText, `GamePlay.failToPayCost`);
+    }
+    /**
+     * Move tile to hex (or recycle), updating influence.
+     *
+     * Tile.dropFunc() -> Tile.placeTile() -> gp.placeEither()
+     * @param tile ignore if undefined
+     * @param toHex tile.moveTo(toHex)
+     * @param payCost commit and verify payment
+     */
+    placeEither(tile, toHex, payCost) {
+        if (!tile)
+            return;
+        const fromHex = tile.fromHex;
+        if (toHex !== fromHex)
+            this.logText(`${tile} -> ${toHex}`, `gamePlay.placeEither`);
+        tile.moveTo(toHex); // placeEither(tile, hex) --> moveTo(hex)
+        if (toHex === this.recycleHex) {
+            this.logText(`Recycle ${tile} from ${fromHex?.Aname || '?'}`, `gamePlay.placeEither`);
+            this.recycleTile(tile); // Score capture; log; return to homeHex
+        }
+        this.updateCounters();
+    }
+    recycleTile(tile) {
+        if (!tile)
+            return; // no prior reserveTile...
+        let verb = tile.recycleVerb ?? 'recycled';
+        if (tile.fromHex?.isOnMap) {
+            if (tile.player !== this.curPlayer) {
+                verb = 'defeated';
+            }
+            else if (tile instanceof Meeple) {
+            }
+        }
+        tile.logRecycle(verb);
+        tile.sendHome(); // recycleTile
+    }
+}
+/** GamePlay with Table & GUI (KeyBinder, ParamGUI & Dragger) */
+export class GamePlay extends GamePlay0 {
+    table; // access to GUI (drag/drop) methods.
+    /** GamePlay is the GUI-augmented extension of GamePlay0; uses Table */
+    constructor(scenario, table, gameSetup) {
+        super(gameSetup); // hexMap, history, gStats...
+        Tile.gamePlay = this; // table
+        this.table = table;
+        if (this.table.stage.canvas)
+            this.bindKeys();
+    }
+    /** suitable for keybinding */
+    unMove() {
+        this.curPlayer.meeples.forEach((meep) => meep.hex?.isOnMap && meep.unMove());
+    }
+    bindKeys() {
+        let table = this.table;
+        let roboPause = () => { this.forEachPlayer(p => this.pauseGame(p)); };
+        let roboResume = () => { this.forEachPlayer(p => this.resumeGame(p)); };
+        let roboStep = () => {
+            let p = this.curPlayer, op = this.nextPlayer(p);
+            this.pauseGame(op);
+            this.resumeGame(p);
+        };
+        // KeyBinder.keyBinder.setKey('p', { thisArg: this, func: roboPause })
+        // KeyBinder.keyBinder.setKey('r', { thisArg: this, func: roboResume })
+        // KeyBinder.keyBinder.setKey('s', { thisArg: this, func: roboStep })
+        // KeyBinder.keyBinder.setKey('R', { thisArg: this, func: () => this.runRedo = true })
+        // KeyBinder.keyBinder.setKey('q', { thisArg: this, func: () => this.runRedo = false })
+        // KeyBinder.keyBinder.setKey(/1-9/, { thisArg: this, func: (e: string) => { TP.maxBreadth = Number.parseInt(e) } })
+        KeyBinder.keyBinder.setKey('M-z', { thisArg: this, func: this.undoMove });
+        KeyBinder.keyBinder.setKey('b', { thisArg: this, func: this.undoMove });
+        KeyBinder.keyBinder.setKey('f', { thisArg: this, func: this.redoMove });
+        //KeyBinder.keyBinder.setKey('S', { thisArg: this, func: this.skipMove })
+        KeyBinder.keyBinder.setKey('Escape', { thisArg: table, func: table.stopDragging }); // Escape
+        KeyBinder.keyBinder.setKey('C-c', { thisArg: this, func: this.stopPlayer }); // C-c Stop Planner
+        KeyBinder.keyBinder.setKey('u', { thisArg: this, func: this.unMove });
+        // KeyBinder.keyBinder.setKey('n', () => { this.endTurn(); this.gameState.phase('BeginTurn') });
+        KeyBinder.keyBinder.setKey('C-c', { thisArg: this, func: this.reCacheTiles });
+        KeyBinder.keyBinder.setKey('c', { thisArg: this, func: this.clickConfirm, argVal: false });
+        KeyBinder.keyBinder.setKey('y', { thisArg: this, func: this.clickConfirm, argVal: true });
+        KeyBinder.keyBinder.setKey('d', { thisArg: this, func: this.clickDone, argVal: true });
+        KeyBinder.keyBinder.setKey('l', () => this.logWriter.pickLogFile());
+        KeyBinder.keyBinder.setKey('L', () => this.logWriter.showBacklog());
+        KeyBinder.keyBinder.setKey('M-l', () => this.logWriter.closeFile());
+        KeyBinder.keyBinder.setKey('C-l', () => this.readFileState());
+        KeyBinder.keyBinder.setKey('r', () => this.readFileState());
+        KeyBinder.keyBinder.setKey('h', () => { this.table.textLog.visible = !this.table.textLog.visible; this.hexMap.update(); });
+        // KeyBinder.keyBinder.setKey('U', { thisArg: this.gameState, func: this.gameState.undoAction, argVal: true })
+        KeyBinder.keyBinder.setKey('p', { thisArg: this, func: this.saveState, argVal: true });
+        KeyBinder.keyBinder.setKey('P', { thisArg: this, func: this.pickState, argVal: true });
+        KeyBinder.keyBinder.setKey('C-p', { thisArg: this, func: this.pickState, argVal: false }); // can't use Meta-P
+        KeyBinder.keyBinder.setKey('k', () => this.logWriter.showBacklog());
+        KeyBinder.keyBinder.setKey('D', () => this.fixit());
+        KeyBinder.keyBinder.setKey('C-s', () => {
+            blinkAndThen(this.hexMap.mapCont.markCont, () => this.gameSetup.restart({}));
+        });
+        // diagnostics:
+        table.undoShape.on(S.click, () => this.undoMove(), this);
+        table.redoShape.on(S.click, () => this.redoMove(), this);
+    }
+    /** enter debugger, with interesting values in local scope */
+    fixit() {
+        const table = this.table, player = this.curPlayer;
+        const hexMap = this.hexMap;
+        console.log(stime(this, `.fixit:`), { player, table, hexMap });
+        table.toggleText(true);
+        debugger;
+        return;
+    }
+    /** when turnNumber auto-increments. */
+    newTurn() {
+    }
+    readFileState() {
+        document.getElementById('fsReadFileButton')?.click();
+    }
+    // async fileState() {
+    //   // Sadly, there is no way to suggest the filename for read?
+    //   // I suppose we could do a openToWrite {suggestedName: ...} and accept the 'already exists'
+    //   // seek to end, ...but not clear we could ever READ from the file handle.
+    //   const turn = this.gameSetup.fileTurn;
+    //   const [startelt, ...stateArray] = await this.gameSetup.injestFile(`log/${this.gameSetup.fileName}.js`, turn);
+    //   const state = stateArray.find(state => state.turn === turn);
+    //   this.backStates.length = this.nstate = 0;
+    //   this.backStates.unshift(state);
+    //   console.log(stime(this, `.fileState: logArray =\n`), stateArray);
+    //   this.gameSetup.restart(state);
+    // }
+    backStates = [];
+    /** setNextPlayer->startTurn (or Key['p']) */
+    saveState() {
+        if (this.nstate !== 0) {
+            this.backStates = this.backStates.slice(this.nstate); // remove ejected states
+            this.nstate = 0;
+        }
+        const state = this.gameSetup.scenarioParser.saveState(this);
+        this.backStates.unshift(state);
+        console.log(stime(this, `.saveState -------- #${this.nstate}:${this.backStates.length - 1} turn=${state.turn}`), state);
+    }
+    // TODO: setup undo index to go fwd and back? wire into undoCont?
+    nstate = 0;
+    /** move nstate to older(back=true, S-P) or newer(back=false, C-P) states in backStates */
+    pickState(back = true) {
+        this.nstate = back ? Math.min(this.backStates.length - 1, this.nstate + 1) : Math.max(0, this.nstate - 1);
+        const state = this.backStates[this.nstate];
+        console.log(stime(this, `.pickState -------- #${this.nstate}:${this.backStates.length - 1} turn=${state.turn}:`), state);
+        this.gameSetup.parseScenenario(state); // typically sets gamePlay.turnNumber
+        console.log(stime(this, `.pickState -------- #${this.nstate}:${this.backStates.length - 1} turn=${state.turn}:`), state);
+        this.setNextPlayer(this.turnNumber);
+    }
+    clickDone() {
+        this.table.doneClicked({});
+    }
+    clickConfirm(val) {
+        this.curPlayer.panel.clickConfirm(val);
+    }
+    useReferee = true;
+    async waitPaused(p = this.curPlayer, ident = '') {
+        this.hexMap.update();
+        let isPaused = !p.planner.pauseP.resolved;
+        if (isPaused) {
+            console.log(stime(this, `.waitPaused: ${p.colorn} ${ident} waiting...`));
+            await p.planner?.waitPaused(ident);
+            console.log(stime(this, `.waitPaused: ${p.colorn} ${ident} running`));
+        }
+        this.hexMap.update();
+    }
+    pauseGame(p = this.curPlayer) {
+        p.planner?.pause();
+        this.hexMap.update();
+        console.log(stime(this, `.pauseGame: ${p.colorn}`));
+    }
+    resumeGame(p = this.curPlayer) {
+        p.planner?.resume();
+        this.hexMap.update();
+        console.log(stime(this, `.resumeGame: ${p.colorn}`));
+    }
+    /** tell [robo-]Player to stop thinking and make their Move; also set useRobo = false */
+    stopPlayer() {
+        this.autoMove(false);
+        this.curPlayer.stopMove();
+        console.log(stime(this, `.stopPlan:`), { planner: this.curPlayer.planner }, '----------------------');
+        setTimeout(() => { this.table.showWinText(`stopPlan`); }, 400);
+    }
+    /** undo and makeMove(incb=1) */
+    makeMoveAgain(arg, ev) {
+        if (this.curPlayer.plannerRunning)
+            return;
+        this.undoMove();
+        this.makeMove(true, undefined, 1);
+    }
+    cacheScale = TP.cacheTiles;
+    reCacheTiles() {
+        this.cacheScale = Math.max(1, this.table.scaleCont.scaleX);
+        TP.cacheTiles = (TP.cacheTiles == 0) ? this.cacheScale : 0;
+        console.log(stime('GamePlay', `.reCacheTiles: TP.cacheTiles=`), TP.cacheTiles, this.table.scaleCont.scaleX);
+        Tile.allTiles.forEach(tile => {
+            if (tile.cacheID) {
+                tile.uncache();
+            }
+            else {
+                const rad = tile.radius, b = tile.getBounds() ?? { x: -rad, y: -rad, width: 2 * rad, height: 2 * rad };
+                // tile.cache(b?.x ?? -rad, b?.y ?? -rad, b?.width ?? 2 * rad, b?.height ?? 2 * rad, TP.cacheTiles);
+                tile.cache(b.x, b.y, b.width, b.height, TP.cacheTiles);
+            }
+        });
+        this.hexMap.update();
+    }
+    /**
+     * Current Player takes action.
+     *
+     * after setNextPlayer: enable Player (GUI or Planner) to respond
+     * with playerMove() [table.moveStoneToHex()]
+     *
+     * Note: 1st move: player = otherPlayer(curPlayer)
+     * @param auto this.runRedo || undefined -> player.useRobo
+     * @param ev KeyBinder event, not used.
+     * @param incb increase Breadth of search
+     */
+    makeMove(auto, ev, incb = 0) {
+        let player = this.curPlayer;
+        if (this.runRedo) {
+            this.waitPaused(player, `.makeMove(runRedo)`).then(() => setTimeout(() => this.redoMove(), 10));
+            return;
+        }
+        if (auto === undefined)
+            auto = player.useRobo;
+        player.playerMove(auto, incb); // make one robo move
+    }
+    /** if useRobo == true, then Player delegates to robo-player immediately. */
+    autoMove(useRobo = false) {
+        this.forEachPlayer(p => {
+            this.roboPlay(p.index, useRobo);
+        });
+    }
+    autoPlay(pid = 0) {
+        this.roboPlay(pid, true); // KeyBinder uses arg2
+        if (this.curPlayerNdx == pid)
+            this.makeMove(true);
+    }
+    roboPlay(pid = 0, useRobo = true) {
+        let p = this.allPlayers[pid];
+        p.useRobo = useRobo;
+        console.log(stime(this, `.autoPlay: ${p.colorn}.useRobo=`), p.useRobo);
+    }
+    /** when true, run all the redoMoves. */
+    set runRedo(val) { (this._runRedo = val) && this.makeMove(); }
+    get runRedo() { return this.redoMoves.length > 0 ? this._runRedo : (this._runRedo = false); }
+    _runRedo = false;
+    /** invoked by GUI or Keyboard */
+    undoMove(undoTurn = true) {
+        this.table.stopDragging(); // drop on nextHex (no Move)
+        //
+        // undo state...
+        //
+        this.showRedoMark();
+        this.hexMap.update();
+    }
+    /** doTableMove(redoMoves[0]) */
+    redoMove() {
+        this.table.stopDragging(); // drop on nextHex (no Move)
+        let move = this.redoMoves[0]; // addStoneEvent will .shift() it off
+        if (!move)
+            return;
+        this.table.doTableMove(move.hex);
+        this.showRedoMark();
+        this.hexMap.update();
+    }
+    showRedoMark(hex = this.redoMoves[0]?.hex) {
+        if (!!hex) { // unless Skip or Resign...
+            this.hexMap.showMark((hex instanceof Hex) ? hex : Hex.ofMap(hex, this.hexMap));
+        }
+    }
+    endTurn() {
+        // vvvv maybe unnecessary: prompted by other confusion in save/restore:
+        // this.table.activateActionSelect(true, undefined); // resetToFirstButton() before newTurn->saveState.
+        super.endTurn();
+    }
+    setNextPlayer(turnNumber) {
+        this.curPlayer.panel.showPlayer(false);
+        super.setNextPlayer(turnNumber); // update player.coins
+        const fileName = this.gameSetup.logWriter.fileName;
+        const [logName, ext] = (fileName ?? this.gameSetup.logTime_js)?.split('.');
+        const backLog = this.logWriter.fileName ? '' : ' **';
+        const logAt = `${logName}@${this.turnNumber}${backLog}`;
+        this.logText(`&file=${logAt} ${this.curPlayer.Aname} ${stime.fs()}`, `GamePlay.setNextPlayer`);
+        ;
+        document.getElementById('readFileName').value = logAt;
+        this.curPlayer.panel.showPlayer(true);
+        this.paintForPlayer();
+        this.updateCounters(); // beginning of round...
+        this.curPlayer.panel.visible = true;
+        this.table.showNextPlayer(); // get to nextPlayer, waitPaused when Player tries to make a move.?
+        this.hexMap.update();
+        this.startTurn();
+        this.makeMove();
+    }
+    /** After setNextPlayer() */
+    startTurn() {
+    }
+    paintForPlayer() {
+    }
+    /** dropFunc | eval_sendMove -- indicating new Move attempt */
+    localMoveEvent(hev) {
+        let redo = this.redoMoves.shift(); // pop one Move, maybe pop them all:
+        //if (!!redo && redo.hex !== hev.hex) this.redoMoves.splice(0, this.redoMoves.length)
+        //this.doPlayerMove(hev.hex, hev.playerColor)
+        this.setNextPlayer();
+        this.ll(2) && console.log(stime(this, `.localMoveEvent: after doPlayerMove - setNextPlayer =`), this.curPlayer.color);
+        return false;
+    }
+    /** local Player has moved (S.add); network ? (sendMove.then(removeMoveEvent)) : localMoveEvent() */
+    playerMoveEvent(hev) {
+        this.localMoveEvent(hev);
+        return false;
+    }
+}