@thegraid/hexlib 1.0.0

package/dist/text-log.js

@@ -0,0 +1,53 @@
+import { stime } from '@thegraid/easeljs-lib';
+import { Container, Text } from '@thegraid/easeljs-module';
+import { F } from '@thegraid/common-lib';
+export class TextLog extends Container {
+    Aname;
+    size;
+    lead;
+    constructor(Aname, nlines = 6, size = 30, lead = 3) {
+        super();
+        this.Aname = Aname;
+        this.size = size;
+        this.lead = lead;
+        this.lines = new Array(nlines);
+        for (let ndx = 0; ndx < nlines; ndx++)
+            this.lines[ndx] = this.newText(`//0:`);
+        this.addChild(...this.lines);
+    }
+    lines;
+    lastLine = '';
+    nReps = 0;
+    height(n = this.lines.length) {
+        return (this.size + this.lead) * n;
+    }
+    clear() {
+        this.lines.forEach(tline => tline.text = '');
+        this.stage?.update();
+    }
+    newText(line = '') {
+        const text = new Text(line, F.fontSpec(this.size));
+        text.textAlign = 'left';
+        text.mouseEnabled = false;
+        return text;
+    }
+    spaceLines(cy = 0, lead = this.lead) {
+        this.lines.forEach(tline => (tline.y = cy, cy += tline.getMeasuredLineHeight() + lead));
+    }
+    log(line, from = '', toConsole = true) {
+        line = line.replace('/\n/g', '-');
+        toConsole && console.log(stime(`${from}:`), line);
+        if (line === this.lastLine) {
+            this.lines[this.lines.length - 1].text = `[${++this.nReps}] ${line}`;
+        }
+        else {
+            this.removeChild(this.lines.shift());
+            this.lines.push(this.addChild(this.newText(line)));
+            this.spaceLines();
+            this.lastLine = line;
+            this.nReps = 0;
+        }
+        this.stage?.update();
+        return line;
+    }
+}

package/dist/tile-source.js

@@ -0,0 +1,115 @@
+import { ValueEvent } from "@thegraid/easeljs-lib";
+import { NumCounter } from "./counters";
+import { H } from "./hex-intfs";
+import { TP } from "./table-params";
+/** a Dispenser of a set of Tiles.
+ *
+ * Source.hex.tile or Source.hex.meep holds an available Tile, placed by moveTo()
+ */
+export class TileSource {
+    type;
+    player;
+    hex;
+    static update = 'update';
+    Aname;
+    allUnits = new Array();
+    available = new Array();
+    counter; // counter of available units.
+    constructor(type, player, hex, counter) {
+        this.type = type;
+        this.player = player;
+        this.hex = hex;
+        this.Aname = `${type.name}Source`;
+        if (counter === undefined) {
+            const cont = hex.map.mapCont.counterCont; // GP.gamePlay.hexMap.mapCont.counterCont;
+            const { x, y } = hex.cont.localToLocal(0, TP.hexRad / H.sqrt3, cont);
+            counter = this.makeCounter(`${type.name}:${player?.index ?? 'any'}`, this.numAvailable, `lightblue`, TP.hexRad / 2);
+            counter.attachToContainer(cont, { x: counter.x + x, y: counter.y + y });
+        }
+        this.counter = counter;
+    }
+    /** can override */
+    makeCounter(name, initValue, color, fontSize, fontName, textColor) {
+        return new NumCounter(name, initValue, color, fontSize, fontName, textColor);
+    }
+    /** length of available[] plus unit on this.hex */
+    get numAvailable() { return this.available.length + (this.hex?.tile || this.hex?.meep ? 1 : 0); }
+    /** mark unit available for later deployment */
+    availUnit(unit) {
+        if (!this.allUnits.includes(unit)) {
+            this.allUnits.push(unit);
+            unit.source = this;
+        }
+        if (!this.available.includes(unit)) {
+            this.available.push(unit);
+            unit.hex = undefined;
+            unit.visible = false;
+            unit.x = unit.y = 0;
+        }
+        this.updateCounter();
+    }
+    /** is the top available unit, next to be picked. */
+    isAvailable(unit) {
+        return this.hex.tile === unit;
+    }
+    /** move unit to undefined, remove from parent container, remove from available and allUnits. */
+    deleteUnit(unit) {
+        if (unit && this.isAvailable(unit)) {
+            unit.moveTo(undefined); // --> this.nextUnit();
+            unit.parent?.removeChild(unit);
+        }
+        const ndx = this.allUnits.indexOf(unit);
+        if (ndx >= 0)
+            this.allUnits.splice(ndx, 1);
+        const adx = this.available.indexOf(unit);
+        if (adx > 0) {
+            this.available.splice(adx, 1);
+            this.updateCounter();
+        }
+    }
+    /** move all units to undefined, and remove from parent container.
+     * remove all from available (and allUnits)
+     * @return number of units deleted (previous length of allUnits).
+     */
+    deleteAll(doAlso) {
+        const n = this.allUnits.length;
+        this.allUnits.forEach(unit => {
+            unit.moveTo(undefined); // --> this.nextUnit();
+            unit.parent?.removeChild(unit);
+            doAlso(unit);
+        });
+        this.allUnits.length = 0;
+        this.available.length = 0;
+        this.updateCounter();
+        return n;
+    }
+    filterUnits(pred) { return this.allUnits.filter(pred); }
+    get sourceHexUnit() {
+        return (this.hex.tile || this.hex.meep); // moveTo puts it somewhere...
+    }
+    /** programmatic, vs Table.dragStart */
+    takeUnit() {
+        const unit = this.sourceHexUnit;
+        unit?.moveTo(undefined);
+        this.nextUnit();
+        return unit;
+    }
+    /** move next available unit to source.hex, make visible */
+    nextUnit(unit = this.available.shift()) {
+        if (unit) {
+            unit.visible = true;
+            unit.moveTo(this.hex); // and try push to available
+        }
+        this.updateCounter();
+        return unit;
+    }
+    updateCounter() {
+        this.counter.parent?.setChildIndex(this.counter, this.counter.parent.numChildren - 1);
+        this.counter.setValue(this.numAvailable);
+        ValueEvent.dispatchValueEvent(this.counter, TileSource.update, this.numAvailable);
+        this.hex?.cont?.updateCache(); // updateCache of counter on hex
+        this.hex?.map?.update(); // updateCache of hexMap with hex & counter
+    }
+}
+export class UnitSource extends TileSource {
+}

package/dist/tile.js

@@ -0,0 +1,312 @@
+import { C, S, className, stime } from "@thegraid/common-lib";
+import { Bitmap, Container } from "@thegraid/easeljs-module";
+import { ImageLoader } from "./image-loader";
+import { C1, HexShape, TileShape } from "./shapes";
+import { TP } from "./table-params";
+import { CenterText } from "@thegraid/easeljs-lib";
+class TileLoader {
+    Uname = ['Univ0', 'Univ1']; // from citymap
+    aliases = { Monument1: 'arc_de_triomphe3', Monument2: 'Statue-of-liberty' };
+    fromAlias(names) {
+        return names.map(name => this.aliases[name] ?? name);
+    }
+    imageArgs = {
+        root: 'assets/images/',
+        fnames: this.fromAlias(['Recycle']),
+        ext: 'png',
+    };
+    imageLoader;
+    /** use ImageLoader to load images, THEN invoke callback. */
+    loadImages(cb) {
+        this.imageLoader = new ImageLoader(this.imageArgs, (imap) => cb?.());
+    }
+    getImage(name) {
+        return this.imageLoader.imap.get(this.aliases[name] ?? name);
+    }
+}
+/** Someday refactor: all the cardboard bits (Tiles, Meeples & Coins) */
+class Tile0 extends Container {
+    static gamePlay;
+    static loader = new TileLoader();
+    // constructor() { super(); }
+    gamePlay = Tile.gamePlay;
+    player;
+    get pColor() { return this.player?.color; }
+    get recycleVerb() { return 'demolished'; }
+    /** name in set of filenames loaded in GameSetup */
+    addImageBitmap(name, at = this.numChildren - 1) {
+        const img = Tile0.loader.getImage(name), bm = new Bitmap(img);
+        const width = TP.hexRad, scale = width / Math.max(img.height, img.width);
+        bm.scaleX = bm.scaleY = scale;
+        const sw = img.width * scale, sh = img.height * scale;
+        bm.x = -sw / 2;
+        bm.y = -sh / 2;
+        bm.y -= Tile.textSize / 2;
+        this.addChildAt(bm, at);
+        return bm;
+    }
+    get radius() { return TP.hexRad; }
+    ;
+    baseShape = this.makeShape();
+    /** Default is TileShape; a HexShape with translucent disk.
+     * add more graphics with paint(colorn)
+     * also: addBitmapImage()
+     */
+    makeShape() {
+        return new TileShape(this.radius);
+    }
+    /** paint with PlayerColor; updateCache()
+     * @param pColor the 'short' PlayerColor
+     * @param colorn the actual color (default = TP.colorScheme[pColor])
+     */
+    paint(pColor = this.player?.color, colorn = pColor ?? C1.grey) {
+        this.baseShape.paint(colorn); // set or update baseShape.graphics
+        this.updateCache(); // push graphics to bitmapCache
+    }
+}
+/** all the [Hexagonal] game pieces that appear; can be dragged/dropped.
+ *
+ * Two subspecies: MapTile are 'stationary' on the HexMap, Meeple are 'mobile'.
+ */
+export class Tile extends Tile0 {
+    Aname;
+    static allTiles = [];
+    static textSize = TP.hexRad / 3;
+    // static source: any[] = [];
+    static makeSource0(unitSource, 
+    // IF (per-player) static source: TileSource[] ELSE static source: TileSource
+    type, player, hex, n = 0) {
+        const source = new unitSource(type, player, hex);
+        if (player) {
+            type.source[player.index] = source;
+        }
+        else {
+            type.source = source;
+        }
+        // Create initial Tile/Units:
+        for (let i = 0; i < n; i++) {
+            const unit = new type(player, i + 1);
+            source.availUnit(unit);
+        }
+        source.nextUnit(); // unit.moveTo(source.hex)
+        return source;
+    }
+    source;
+    // Tile
+    constructor(
+    /** typically: className-serial; may be supplied as 'name' or undefined */
+    Aname, 
+    /** the owning Player. */
+    player) {
+        super();
+        this.Aname = Aname;
+        Tile.allTiles.push(this);
+        const cName = Aname?.split('-')[0] ?? className(this); // className is subject to uglification!
+        this.name = cName; // used for saveState!
+        if (!Aname)
+            this.Aname = `${cName}-${Tile.allTiles.length}`;
+        const rad = this.radius;
+        if (TP.cacheTiles > 0)
+            this.cache(-rad, -rad, 2 * rad, 2 * rad, TP.cacheTiles);
+        this.addChild(this.baseShape);
+        this.setPlayerAndPaint(player);
+        this.nameText = this.addTextChild(rad / 2);
+    }
+    nameText;
+    setNameText(name) {
+        this.nameText.text = name.replace(/-/g, '\n');
+        const nlines = this.nameText.text.split('\n').length - 1;
+        this.nameText.y = (nlines == 0) ? 0 : -nlines * this.nameText.getMeasuredHeight() / 4;
+        this.updateCache();
+    }
+    // for BalMark:
+    // get nB() { return 0; }
+    // get nR() { return 0; }
+    // get fB() { return 0; }
+    // get fR() { return 0; }
+    /** location at start-of-game & after-Recycle; Meeple & Civic; Policy: sendHome -> sendToBag */
+    homeHex;
+    /** location at start-of-drag */
+    fromHex;
+    isDragable(ctx) { return true; }
+    _hex;
+    /** the map Hex on which this Tile sits. */
+    get hex() { return this._hex; }
+    /** only one Tile on a Hex, Tile on only one Hex */
+    set hex(hex) {
+        if (this.hex?.tile === this)
+            this.hex.tile = undefined;
+        this._hex = hex;
+        if (hex !== undefined)
+            hex.tile = this;
+    }
+    updateCache(compositeOperation) {
+        if (!this.cacheID)
+            return;
+        super.updateCache(compositeOperation);
+    }
+    setPlayerAndPaint(player) {
+        this.player = player;
+        this.paint(undefined, player?.color);
+        return this;
+    }
+    toString() {
+        return `${this.Aname}@${this.hex?.Aname ?? this.fromHex?.Aname ?? '?'}`;
+    }
+    /** name in set of filenames loaded in GameSetup
+     * @param at = 2; above HexShape
+     */
+    addImageBitmap(name, at = 2) {
+        let bm = super.addImageBitmap(name, at);
+        this.updateCache();
+        return bm;
+    }
+    addTextChild(y0 = this.radius / 2, text = this.Aname?.replace(/-/g, '\n'), size = Tile.textSize, vis = false) {
+        const nameText = new CenterText(text, size);
+        nameText.y = y0; // Meeple overrides in constructor!
+        nameText.visible = vis;
+        this.addChild(nameText);
+        return nameText;
+    }
+    textVis(vis = !this.nameText.visible) {
+        this.nameText.visible = vis;
+        this.updateCache();
+    }
+    rightClickable() {
+        const ifRightClick = (evt) => {
+            const nevt = evt.nativeEvent;
+            if (nevt.button === 2) {
+                this.onRightClick(evt);
+                nevt.preventDefault(); // evt is non-cancelable, but stop the native event...
+                nevt.stopImmediatePropagation(); // TODO: prevent Dragger.clickToDrag() when button !== 0
+            }
+        };
+        this.on(S.click, ifRightClick, this, false, {}, true); // TS fails with overload
+    }
+    onRightClick(evt) {
+        console.log(stime(this, `.rightclick: ${this}`), this);
+    }
+    overSet(tile) {
+        tile.parent && console.log(stime(this, `.overSet: removeChild: ${tile}`), tile);
+        tile.parent?.removeChild(tile); // moveBonusTo/sendHome may do this.
+    }
+    // Tile
+    /** Post-condition: tile.hex == hex; low-level, physical move.
+     *
+     * calls this.source.nextUnit() if tile was dragged from this.source.
+     */
+    moveTo(hex) {
+        const fromHex = this.fromHex;
+        this.hex = hex; // may collide with source.hex.meep, setUnit, overSet?
+        if (this.source && fromHex === this.source.hex && fromHex !== hex) {
+            this.source.nextUnit(); // shift; moveTo(source.hex); update source counter
+        }
+    }
+    /** Tile.dropFunc() --> placeTile (to Map, reserve, ~>auction; not Recycle); semantic move/action. */
+    placeTile(toHex, payCost = false) {
+        this.gamePlay.placeEither(this, toHex, payCost);
+    }
+    resetTile() {
+        this.x = this.y = 0;
+    }
+    /**
+     * After Capture or Recycle/Replace.
+     * Post-condition: !tile.hex.isOnMap; tile.hex = this.homeHex may be undefined [UnitSource, AuctionTile, BonusTile]
+     */
+    sendHome() {
+        this.resetTile();
+        this.moveTo(this.homeHex); // override for AuctionTile.tileBag & UnitSource<Meeple>
+        if (!this.homeHex)
+            this.parent?.removeChild(this);
+        const source = this.source;
+        if (source) {
+            source.availUnit(this);
+            if (!source.hex.tile)
+                source.nextUnit();
+        }
+    }
+    showTargetMark(hex, ctx) {
+        ctx.targetHex = hex?.isLegal ? hex : this.fromHex;
+        ctx.targetHex?.map.showMark(ctx.targetHex);
+    }
+    /**
+     * Augment Table.dragFunc0().
+     *
+     * isLegal already set;
+     * record ctx.targetHex & showMark() when Tile is over a legal targetHex.
+     */
+    dragFunc0(hex, ctx) {
+        this.showTargetMark(hex, ctx);
+    }
+    /** entry point from Table.dropFunc; delegate to this.dropFunc() */
+    dropFunc0(hex, ctx) {
+        this.dropFunc(ctx.targetHex, ctx);
+        ctx.targetHex?.map.showMark(undefined); // if (this.fromHex === undefined)
+    }
+    cantBeMovedBy(player, ctx) {
+        return (ctx?.lastShift || this.player === undefined || this.player === player) ? undefined : "Not your Tile";
+    }
+    /** override as necessary. */
+    dragStart(ctx) { }
+    /** state of shiftKey has changed during drag */
+    dragShift(shiftKey, ctx) { }
+    markLegal(table, setLegal = (hex) => { hex.isLegal = false; }, ctx) {
+        table.newHexes.forEach(setLegal);
+        table.hexMap.forEachHex(setLegal);
+    }
+    /**
+     * Override in AuctionTile, Civic, Meeple/Leader
+     * @param toHex a potential targetHex (table.hexUnderObj(dragObj.xy))
+     */
+    isLegalTarget(toHex, ctx) {
+        if (!toHex)
+            return false;
+        if (!!toHex.tile)
+            return false; // note: from AuctionHexes to Reserve overrides this.
+        if (toHex.meep && !(toHex.meep.player === this.gamePlay.curPlayer))
+            return false; // QQQ: can place on non-player meep?
+        if (this.hex?.isOnMap && !ctx?.lastShift)
+            return false;
+        return true;
+    }
+    isLegalRecycle(ctx) {
+        return true;
+    }
+    /**
+     * Tile.dropFunc; Override in AuctionTile, Civic, Meeple/Leader.
+     * @param targetHex Hex2 this Tile is over when dropped (may be undefined; see also: ctx.targetHex)
+     * @param ctx DragContext
+     */
+    dropFunc(targetHex, ctx) {
+        this.placeTile(targetHex);
+    }
+    noLegal() {
+        // const cause = this.gamePlay.failToBalance(this) ?? '';
+        // const [infR, coinR] = this.gamePlay.getInfR(this);
+        // this.gamePlay.logText(`No placement for ${this.andInfStr} ${cause} infR=${infR} coinR=${coinR}`, 'Tile.noLegal')
+    }
+    logRecycle(verb) {
+        const cp = this.gamePlay.curPlayer;
+        const loc = this.hex?.isOnMap ? 'onMap' : 'offMap';
+        const info = { Aname: this.Aname, fromHex: this.fromHex?.Aname, cp: cp.colorn, tile: { ...this } };
+        console.log(stime(this, `.recycleTile[${loc}]: ${verb}`), info);
+        this.gamePlay.logText(`${cp.Aname} ${verb} ${this}`, `GamePlay.recycle`);
+    }
+}
+/** A plain WHITE tile; for Debt */
+export class WhiteTile extends Tile {
+    // TileShape does not work here:
+    makeShape() { return new HexShape(this.radius); }
+    paint(pColor, colorn) {
+        super.paint(pColor, C.WHITE); // TODO: using cgf
+    }
+}
+/** a half-sized Tile. */
+export class Token extends Tile {
+    makeShape() {
+        return new HexShape(this.radius * .5);
+    }
+}
+/** Tiles that can be played to the Map: AuctionTile, Civic, Monument, BonusTile */
+export class MapTile extends Tile {
+}

package/dist/types.js

@@ -0,0 +1,15 @@
+/** drill down through value of inner fields. */
+export function findFieldValue(obj, ...names) {
+    let next;
+    const n = names.shift();
+    if (!n)
+        return obj; // return obj when no more field accessors
+    if (typeof (n) == 'string') {
+        next = obj[n];
+    }
+    else {
+        const nn = n.find(n => !!obj[n]);
+        next = !!nn ? obj[nn] : !!n[0] ? undefined : obj; // [null, foo, bar] -> next = obj
+    }
+    return !!next ? findFieldValue(next, ...names) : undefined;
+}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@thegraid/hexlib",
+  "version": "1.0.0",
+  "description": "library for hex-based games",
+  "main": "dist/index.js",
+  "type": "module",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "newlib": "npm i ../../ts/createjs-lib/thegraid-easeljs-lib-*.tgz ; rm -rf .angular/cache",
+    "note:": "remember to rm -rf .angular/cache when [re-]installing a tgz",
+    "tgz": "rm -rf *.tgz; npm pack",
+    "pub": "npm run build; npm version ${1:-patch}; npm publish --access public",
+    "testEdit": "test/testEditBox.sh",
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "clean": "rm -f dist/*",
+    "build": "npm run clean; npm run tsc; date",
+    "tsc": "tsc"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jackpunt/hexlib.git"
+  },
+  "keywords": [
+    "hexagon",
+    "game"
+  ],
+  "author": "jack punt",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/jackpunt/hexlib/issues"
+  },
+  "homepage": "https://github.com/jackpunt/hexlib#readme",
+  "dependencies": {
+    "@thegraid/common-lib": "^1.3.40",
+    "@thegraid/easeljs-lib": "^1.3.8",
+    "json5": "^2.2.3"
+  },
+  "devDependencies": {
+    "@types/node": "^18.15.11",
+    "@types/wicg-file-system-access": "^2020.9.8",
+    "typescript": "~4.9.4"
+  }
+}