@thegraid/hexlib 1.0.0

package/dist/image-loader.js

@@ -0,0 +1,69 @@
+import { stime } from "@thegraid/common-lib";
+/** Simple async Image loader [from ImageReveal.loadImage()]
+ *
+ * see also: createjs.ImageLoader, which we don't use.
+ */
+export class ImageLoader {
+    static ipser = 0; // debug
+    /**
+     * Promise to load url as HTMLImageElement
+     */
+    loadImage(fname0, ext = this.ext) {
+        const fname = fname0.split('.')[0];
+        const ip0 = this.ipmap.get(fname);
+        if (ip0) {
+            return ip0;
+        }
+        const url = `${this.root}${fname}.${ext}`;
+        //console.log(stime(`image-loader: try loadImage`), url)
+        const ip = new Promise((res, rej) => {
+            const img = new Image();
+            img.onload = (evt => {
+                img.Aname = fname;
+                this.imap.set(fname, img); // record image as loaded!
+                res(img);
+            });
+            img.onerror = ((err) => rej(`failed to load ${url} -> ${err}`));
+            img.src = url; // start loading
+        });
+        // ip['Aname'] = `${fname}-${++ImageLoader.ipser}`;
+        this.ipmap.set(fname, ip);
+        return ip;
+    }
+    /**
+     * load all fnames, return Promise.all()
+     * @param fnames
+     */
+    loadImages(fnames = this.fnames, ext = this.ext) {
+        fnames.forEach(fname => this.ipmap.set(fname, this.loadImage(fname, ext)));
+        return this.imageMapPromise = Promise.all(this.ipmap.values()).then((images) => this.imap, (reason) => {
+            console.error(stime(this, `loadImages failed: ${reason}`));
+            return this.imap;
+        });
+    }
+    /**
+     *
+     * @param args -
+     * - root: path to image directory with trailing '/'
+     * - fnames: string[] basenames of each image to load
+     * - ext: file extension (for ex: 'png' or 'jpg')
+     *
+     * @param imap supply or create new Map()
+     * @param cb invoked with (imap)
+     */
+    constructor(args, cb) {
+        this.root = args.root;
+        this.fnames = args.fnames;
+        this.ext = args.ext;
+        if (cb) {
+            this.loadImages().then(imap => cb(imap));
+        }
+    }
+    imap = new Map();
+    ipmap = new Map();
+    root;
+    fnames;
+    ext;
+    imagePromises;
+    imageMapPromise;
+}

package/dist/meeple.js

@@ -0,0 +1,152 @@
+import { Shape } from "@thegraid/easeljs-module";
+import { C1, PaintableShape } from "./shapes";
+import { TP } from "./table-params";
+import { Tile } from "./tile";
+class MeepleShape extends PaintableShape {
+    player;
+    radius;
+    static fillColor = 'rgba(225,225,225,.7)';
+    static backColor = 'rgba(210,210,120,.5)'; // transparent light green
+    constructor(player, radius = TP.meepleRad) {
+        super((color) => this.mscgf(color));
+        this.player = player;
+        this.radius = radius;
+        this.y = TP.meepleY0;
+        this.setMeepleBounds();
+        this.backSide = this.makeOverlay(this.y);
+    }
+    setMeepleBounds(r = this.radius) {
+        this.setBounds(-r, -r, 2 * r, 2 * r);
+    }
+    backSide; // visible when Meeple is 'faceDown' after a move.
+    makeOverlay(y0) {
+        const { x, width: w } = this.getBounds();
+        const over = new Shape();
+        over.graphics.f(MeepleShape.backColor).dc(x + w / 2, y0, w / 2);
+        over.visible = false;
+        over.name = over.Aname = 'backSide';
+        return over;
+    }
+    /** stroke a ring of colorn, stroke-width = 2, r = radius-2; fill disk with (~WHITE,.7) */
+    mscgf(colorn = this.player?.colorn ?? C1.grey, ss = 2, rs = 0) {
+        const r = this.radius;
+        const g = this.graphics.c().ss(ss).s(colorn).f(MeepleShape.fillColor).dc(0, 0, r - rs - ss / 2); // disk & ring
+        return g;
+    }
+}
+export class Meeple extends Tile {
+    static allMeeples = [];
+    get backSide() { return this.baseShape.backSide; }
+    get recycleVerb() { return 'dismissed'; }
+    /**
+     * Meeple - Leader, Police, Criminal
+     * @param Aname
+     * @param player (undefined for Chooser)
+     * @param civicTile Tile where this Meeple spawns
+     */
+    constructor(Aname, player) {
+        super(Aname, player);
+        this.addChild(this.backSide);
+        this.player = player;
+        this.nameText.visible = true;
+        this.nameText.y = this.baseShape.y;
+        // this.paint();
+        Meeple.allMeeples.push(this);
+    }
+    /** the map Hex on which this Meeple sits. */
+    get hex() { return this._hex; }
+    /** only one Meep on a Hex, Meep on only one Hex */
+    set hex(hex) {
+        if (this.hex?.meep === this)
+            this.hex.meep = undefined;
+        this._hex = hex;
+        if (hex !== undefined)
+            hex.meep = this;
+    }
+    get radius() { return TP.meepleRad; } // 31.578 vs 60*.4 = 24
+    textVis(v) { super.textVis(true); }
+    makeShape() { return new MeepleShape(this.player, this.radius); }
+    /** location at start-of-turn; for Meeples.unMove() */
+    startHex;
+    // we need to unMove meeples in the proper order; lest we get 2 meeps on a hex.
+    // meepA -> hexC, meepB -> hexA; undo: meepA -> hexA (collides with meepB), meepB -> hexB
+    // Assert: if meepA.startHex is occupied by meepB, then meepB is NOT on meepB.startHex;
+    // So: recurse to move meepB to its startHex;
+    // Note: with multiple/illegal moves, meepA -> hexB, meepB -> hexA; infinite recurse
+    // So: remove meepA from hexB before moving meepB -> hexB
+    unMove() {
+        if (this.hex === this.startHex)
+            return;
+        this.placeTile(undefined, false); // take meepA off the map;
+        this.startHex.meep?.unMove(); // recurse to move meepB to meepB.startHex
+        this.placeTile(this.startHex, false); // Move & update influence; Note: no unMove for Hire! (sendHome)
+        this.faceUp();
+    }
+    /** start of turn, faceUp(undefined) --> faceUp; moveTo(true|false) --> faceUp|faceDn */
+    faceUp(up = true) {
+        if (this.backSide)
+            this.backSide.visible = !up;
+        if (up && this.hex)
+            this.startHex = this.hex; // set at start of turn.
+        this.updateCache();
+        if (this.hex?.isOnMap)
+            this.gamePlay.hexMap.update();
+    }
+    moveTo(hex) {
+        const destMeep = hex?.meep;
+        if (destMeep && destMeep !== this) {
+            destMeep.x += 10; // make double occupancy apparent [until this.unMove()]
+            destMeep.unMove();
+        }
+        const fromHex = this.fromHex;
+        super.moveTo(hex); // hex.set(meep) = this; this.x/y = hex.x/y
+        this.faceUp(!(hex?.isOnMap && fromHex?.isOnMap && hex !== this.startHex));
+    }
+    cantBeMovedBy(player, ctx) {
+        const reason1 = super.cantBeMovedBy(player, ctx);
+        if (reason1 || reason1 === false)
+            return reason1;
+        // if (!ctx?.lastShift && !this.canAutoUnmove && this.backSide.visible) return "already moved"; // no move if not faceUp
+        return undefined;
+    }
+    isOnLine(hex0, fromHex = this.hex) {
+        return !!fromHex.linkDirs.find(dir => fromHex.hexesInDir(dir).includes(hex0));
+        // return !!fromHex.linkDirs.find(dir => fromHex.findInDir(dir, hex => hex === hex0));
+        // return !!fromHex.findLinkHex((hex, dir) => !!hex.findInDir(dir, hex => hex === hex0));
+    }
+    get canAutoUnmove() { return this.player?.allOnMap(Meeple).filter(meep => meep.hex !== meep.startHex).length == 1; }
+    /** override markLegal(), if *this* is the only meeple to have moved,
+     * unMove it to reset influence; can always move back to startHex; */
+    markLegal(table, setLegal, ctx) {
+        if (!ctx?.lastShift && !!setLegal && this.canAutoUnmove) {
+            this.unMove(); // this.hex = this.startHex;
+        }
+        super.markLegal(table, setLegal);
+        if (this.fromHex)
+            this.fromHex.isLegal = !!setLegal; // if (this.startHex) [not all Tiles have a fromHex!]
+        return;
+    }
+    isLegalTarget0(hex, ctx) {
+        if (!hex)
+            return false;
+        if (hex.meep)
+            return false;
+        if (!hex.isOnMap)
+            return false; // RecycleHex is "on" the map?
+        if (!ctx?.lastShift && this.backSide.visible)
+            return false;
+        return true;
+    }
+    isLegalTarget(hex, ctx) {
+        return this.isLegalTarget0(hex, ctx);
+    }
+    isLegalRecycle(ctx) {
+        if (this.player === this.gamePlay.curPlayer)
+            return true;
+        return false;
+    }
+    resetTile() {
+        this.faceUp();
+        this.startHex = undefined;
+    }
+}

package/dist/plan-proxy.js

@@ -0,0 +1,33 @@
+import { stime } from "@thegraid/common-lib";
+class mockPlanner {
+    waitPaused(ident) {
+        throw new Error("Method not implemented.");
+    }
+    pause() {
+        throw new Error("Method not implemented.");
+    }
+    resume() {
+        throw new Error("Method not implemented.");
+    }
+    roboMove(run) {
+        throw new Error("Method not implemented.");
+    }
+    terminate() {
+        console.log(stime(this, `.terminate: TBD`));
+    }
+}
+export class Planner extends mockPlanner {
+    pauseP;
+}
+/**
+ * IPlanner factory method, invoked from Player.newGame()
+ * @param hexMap from the main GamePlay, location of Hex for makeMove
+ * @param index player.index [0 -> 'b', 1 -> 'w']
+ * @returns Planner or PlannerProxy
+ */
+export function newPlanner(hexMap, index) {
+    // let planner = TP.pWorker
+    //   ? new PlannerProxy(hexMap.mh, hexMap.nh, index, logWriter)    // -> Remote Planner [no Parallel]
+    //   : new Planner(hexMap.mh, hexMap.nh, index, logWriter) // -> Local ParallelPlanner *or* Planner
+    return new mockPlanner();
+}

package/dist/player-panel.js

@@ -0,0 +1,125 @@
+import { CenterText, S, stime } from "@thegraid/easeljs-lib";
+import { Container, Graphics, MouseEvent } from "@thegraid/easeljs-module";
+import { NamedContainer } from "./game-play";
+import { RectShape, UtilButton } from "./shapes";
+import { TP } from "./table-params";
+export class PlayerPanel extends NamedContainer {
+    table;
+    player;
+    high;
+    wide;
+    dir;
+    outline;
+    get hexMap() { return this.table.gamePlay.hexMap; }
+    /**
+     *
+     * @param table
+     * @param player
+     * @param high
+     * @param wide
+     * @param row
+     * @param col
+     * @param dir
+     */
+    constructor(table, player, high, wide, row, col, dir = -1) {
+        super(player.Aname); // for debugger
+        this.table = table;
+        this.player = player;
+        this.high = high;
+        this.wide = wide;
+        this.dir = dir;
+        table.hexMap.mapCont.resaCont.addChild(this);
+        table.setToRowCol(this, row, col);
+        this.setOutline();
+        this.makeConfirmation();
+    }
+    get metrics() {
+        const { dxdc, dydr } = this.table.hexMap.xywh, dir = this.dir;
+        const wide = dxdc * this.wide, high = dydr * this.high, brad = TP.hexRad, gap = 6, rowh = 2 * brad + gap;
+        return { dir, dydr, wide, high, brad, gap, rowh };
+    }
+    get objects() {
+        const player = this.player, index = player.index, panel = this;
+        const table = this.table, gamePlay = this.player.gamePlay;
+        return { panel, player, index, table, gamePlay };
+    }
+    /**
+     *
+     * @param t1 stroke width (2)
+     * @param bgc fill color
+     */
+    setOutline(t1 = 2, bgc = this.bg0) {
+        const { wide, high, brad, gap } = this.metrics;
+        const t2 = t1 * 2 + 1, g = new Graphics().ss(t2);
+        this.removeChild(this.outline);
+        this.outline = new RectShape({ x: -t1, y: -t1, w: wide + t2, h: high + t2 }, bgc, this.player.color, g);
+        this.addChildAt(this.outline, 0);
+    }
+    bg0 = 'rgba(255,255,255,.3)';
+    bg1 = 'rgba(255,255,255,.5)';
+    showPlayer(show = (this.player && this.player === this.player.gamePlay.curPlayer)) {
+        this.setOutline(show ? 4 : 2, show ? this.bg1 : this.bg0);
+    }
+    confirmContainer;
+    makeConfirmation() {
+        const { wide, high, brad, gap, rowh } = this.metrics;
+        const { table } = this.objects;
+        const conf = this.confirmContainer = new Container();
+        conf.name = 'confirm';
+        const bg0 = new RectShape({ x: 0, y: -brad - gap, w: wide, h: high }, '', '');
+        bg0.paint('rgba(240,240,240,.2)');
+        const bg1 = new RectShape({ x: 0, y: 4 * rowh - brad - 2 * gap, w: wide, h: high - 4 * rowh + gap }, '', '');
+        bg1.paint('rgba(240,240,240,.8)');
+        const title = conf.titleText = new CenterText('Are you sure?', 30);
+        title.x = wide / 2;
+        title.y = 3.85 * rowh;
+        const msgText = conf.messageText = new CenterText('', 30);
+        msgText.x = wide / 2;
+        msgText.y = 5 * rowh;
+        const button1 = conf.buttonYes = new UtilButton('lightgreen', 'Yes', TP.hexRad);
+        const button2 = conf.buttonCan = new UtilButton('rgb(255, 100, 100)', 'Cancel', TP.hexRad);
+        button1.y = button2.y = 6 * rowh;
+        button1.x = wide * .4;
+        button2.x = wide * .6;
+        conf.addChild(bg0, bg1, button1, button2, msgText, title);
+        conf.visible = false;
+        table.overlayCont.addChild(conf);
+    }
+    /** keybinder access to areYouSure */
+    clickConfirm(yes = true) {
+        // let target = (this.confirmContainer.children[2] as UtilButton);
+        if (!this.confirmContainer.visible)
+            return;
+        const buttonYes = this.confirmContainer.buttonYes;
+        const buttonCan = this.confirmContainer.buttonCan;
+        const nativeMouseEvent = undefined;
+        const event = new MouseEvent(S.click, false, true, 0, 0, nativeMouseEvent, -1, true, 0, 0);
+        (yes ? buttonYes : buttonCan).dispatchEvent(event);
+    }
+    areYouSure(msg, yes, cancel, afterUpdate = () => { }) {
+        const { panel, table } = this.objects, doneVis = table.doneButton.visible;
+        table.doneButton.mouseEnabled = table.doneButton.visible = false;
+        const conf = this.confirmContainer;
+        const button1 = conf.buttonYes;
+        const button2 = conf.buttonCan;
+        const msgText = conf.children[4];
+        msgText.text = msg;
+        const clear = (func) => {
+            conf.visible = false;
+            button1.removeAllEventListeners();
+            button2.removeAllEventListeners();
+            table.doneButton.mouseEnabled = table.doneButton.visible = doneVis;
+            button1.updateWait(false, func);
+        };
+        button2.visible = !!cancel;
+        button1.label_text = !!cancel ? 'Yes' : 'Continue';
+        conf.titleText.text = !!cancel ? 'Are your sure?' : 'Click to Confirm';
+        button1.on(S.click, () => clear(yes), this, true);
+        button2.on(S.click, () => clear(cancel ?? yes), this, true);
+        console.log(stime(this, `.areYouSure? [${this.player.Aname}], ${msg}`));
+        panel.localToLocal(0, 0, table.overlayCont, conf);
+        conf.visible = true;
+        button1.updateWait(false, afterUpdate);
+        // setTimeout(cancel, 500);
+    }
+}

package/dist/player.js

@@ -0,0 +1,112 @@
+import { stime } from "@thegraid/common-lib";
+import { Meeple } from "./meeple";
+import { TP } from "./table-params";
+import { MapTile, Tile, } from "./tile";
+export class Player {
+    index;
+    gamePlay;
+    static allPlayers = [];
+    static colorScheme = ['Red', 'Blue', 'darkgreen', 'Violet', 'gold', 'purple'];
+    Aname;
+    constructor(index, gamePlay) {
+        this.index = index;
+        this.gamePlay = gamePlay;
+        Player.allPlayers[index] = this;
+        this.color = Player.colorScheme[index];
+        this.Aname = `P${index}:${this.color}`;
+        console.log(stime(this, `.new:`), this.Aname);
+    }
+    _color;
+    get color() { return this._color; }
+    set color(c) { this._color = c; }
+    /** much useful context about this Player. */
+    panel;
+    get colorn() { return this._color; }
+    // Player shall paint their pieces to their color as necessary;
+    // Other code shall operate using player.index;
+    allOf(claz) { return Tile.allTiles.filter(t => t instanceof claz && t.player === this); }
+    allOnMap(claz) { return this.allOf(claz).filter(t => t.hex?.isOnMap); }
+    /** Resi/Busi/PS/Lake/Civics in play on Map */
+    get mapTiles() { return this.allOf(MapTile); }
+    // Player's Leaders, Police & Criminals
+    get meeples() { return Meeple.allMeeples.filter(meep => meep.player == this); }
+    ;
+    _score = 0;
+    get score() { return this._score; }
+    set score(score) {
+        this._score = Math.floor(score);
+    }
+    // Created in masse by Table.layoutCounter
+    coinCounter; // set by layoutCounters: `${'Coin'}Counter`
+    get coins() { return this.coinCounter?.getValue(); }
+    set coins(v) { this.coinCounter?.updateValue(v); }
+    get otherPlayer() { return Player.allPlayers[1 - this.index]; }
+    planner;
+    /** if true then invoke plannerMove */
+    useRobo = false;
+    startDir;
+    /** make Civics, Leaders & Police; also makeLeaderHex() */
+    makePlayerBits() {
+    }
+    get isDestroyed() {
+        return this.allOnMap(MapTile).length == 0;
+    }
+    get isComplete() {
+        return false;
+    }
+    endGame() {
+        this.planner?.terminate();
+        this.planner = undefined;
+    }
+    static remotePlayer = 1; // temporary, bringup-debug: index of 'remotePlayer' (see below)
+    /**
+     * Before start each new game.
+     *
+     * [make newPlanner for this Player]
+     */
+    newGame(gamePlay, url = TP.networkUrl) {
+        this.planner?.terminate();
+        // this.hgClient = (this.index == Player.remotePlayer) ? new HgClient(url, (hgClient) => {
+        //   console.log(stime(this, `.hgClientOpen!`), hgClient)
+        // }) : undefined
+        // this.planner = newPlanner(gamePlay.hexMap, this.index)
+    }
+    newTurn() {
+        // faceUp and record start location:
+        this.meeples.forEach(meep => meep.faceUp()); // set meep.startHex for unMove
+    }
+    stopMove() {
+        this.planner?.roboMove(false);
+    }
+    /** if Planner is not running, maybe start it; else wait for GUI */ // TODO: move Table.dragger to HumanPlanner
+    playerMove(useRobo = this.useRobo, incb = 0) {
+        let running = this.plannerRunning;
+        // feedback for KeyMove:
+        TP.log > 0 && console.log(stime(this, `(${this.colorn}).playerMove(${useRobo}): useRobo=${this.useRobo}, running=${running}`));
+        if (running)
+            return;
+        if (useRobo || this.useRobo) {
+            // start plannerMove from top of stack:
+            // setTimeout(() => this.plannerMove(incb))
+        }
+        return; // robo or GUI will invoke gamePlay.doPlayerMove(...)
+    }
+    plannerRunning = false;
+    plannerMove(incb = 0) {
+        this.planner?.roboMove(true);
+        this.plannerRunning = true;
+        // let iHistory = this.table.gamePlay.iHistory
+        // let ihexPromise = this.planner.makeMove(sc, iHistory, incb)
+        // ihexPromise.then((ihex: IHex) => {
+        //   this.plannerRunning = false
+        //   this.table.moveStoneToHex(ihex, sc)
+        // })
+    }
+}
+class RemotePlayer extends Player {
+    newGame(gamePlay) {
+        this.planner?.terminate();
+        // this.hgClient = (this.index == RemotePlayer.remotePlayer) ? new HgClient() : undefined
+        // this.planner = newPlanner(gamePlay.hexMap, this.index, gamePlay.logWriter)
+    }
+}

package/dist/scenario-parser.js

@@ -0,0 +1,67 @@
+// TODO: namespace or object for GameState names
+import { S, stime } from "@thegraid/common-lib";
+import { KeyBinder } from "@thegraid/easeljs-lib";
+export class ScenarioParser {
+    map;
+    gamePlay;
+    constructor(map, gamePlay) {
+        this.map = map;
+        this.gamePlay = gamePlay;
+    }
+    // coins, score, actions, events, AnkhPowers, Guardians in stable; specials for Amun, Bastet, Horus, ...
+    parseScenario(setup) {
+        if (!setup)
+            return;
+        // console.log(stime(this, `.parseScenario: curState =`), this.saveState(this.gamePlay, true)); // log current state for debug...
+        console.log(stime(this, `.parseScenario: newState =`), setup);
+        const { gameState, turn } = setup;
+        const map = this.map, gamePlay = this.gamePlay, allPlayers = gamePlay.allPlayers, table = gamePlay.table;
+        const turnSet = (turn !== undefined); // indicates a Saved Scenario: assign & place everything
+        if (turnSet) {
+            gamePlay.turnNumber = turn;
+            table.logText(`turn = ${turn}`, `parseScenario`);
+            this.gamePlay.allTiles.forEach(tile => tile.hex?.isOnMap ? tile.sendHome() : undefined); // clear existing map
+        }
+        if (gameState) {
+            this.gamePlay.gameState.parseState(gameState);
+        }
+        this.gamePlay.hexMap.update();
+    }
+    saveState(gamePlay, silent = false) {
+        const turn = Math.max(0, gamePlay.turnNumber);
+        const coins = gamePlay.allPlayers.map(p => p.coins);
+        const time = stime.fs();
+        const gameState = this.gamePlay.gameState.saveState();
+        const setupElt = { turn, time, coins, gameState, };
+        this.logState(setupElt);
+        return setupElt;
+    }
+    /** write each component of SetupElt on a line, wrapped between '{' ... '\n}' */
+    logState(state, logWriter = this.gamePlay.logWriter) {
+        let lines = '{', keys = Object.keys(state), n = keys.length - 1;
+        keys.forEach((key, ndx) => {
+            const line = JSON.stringify(state[key]);
+            lines = `${lines}\n  ${key}: ${line}${ndx < n ? ',' : ''}`;
+        });
+        lines = `${lines}\n},`;
+        logWriter.writeLine(lines);
+    }
+    /** debug utility */
+    identCells(map) {
+        map.forEachHex(hex => {
+            const hc = hex.cont;
+            hc.mouseEnabled = true;
+            hc.on(S.click, () => {
+                hex.isLegal = !hex.isLegal;
+                map.update();
+            });
+        });
+        KeyBinder.keyBinder.setKey('x', {
+            func: () => {
+                const cells = map.filterEachHex(hex => hex.isLegal);
+                const list = cells.map(hex => `${hex.rcs},`);
+                console.log(''.concat(...list));
+            }
+        });
+    }
+}