ttpg-darrell 1.0.9 → 1.0.11

package/build/cjs/garbage/garbage-container.d.ts

@@ -0,0 +1,37 @@
+import { Container, GameObject } from "@tabletop-playground/api";
+export declare abstract class GarbageHandler {
+    /**
+     * Can recycle this object?
+     *
+     * @param obj
+     */
+    abstract canRecycle(obj: GameObject): boolean;
+    /**
+     * Recycle the object.
+     *
+     * @param obj
+     * @returns true if recycled
+     */
+    abstract recycle(obj: GameObject): boolean;
+}
+/**
+ * Attempt to recycle deposited objects, break up decks into individual cards.
+ */
+export declare class GarbageContainer {
+    private static _garbageHandlers;
+    private readonly _container;
+    /**
+     * Register a new recycler.
+     *
+     * @param garbageHandler
+     */
+    static addHandler(garbageHandler: GarbageHandler): void;
+    /**
+     * Clear all recycle handlers (for tests).
+     */
+    static clearHandlers(): void;
+    private static _tryRecycleObj;
+    private static _tryRecycleDeck;
+    constructor(container: Container);
+    _recycle(): void;
+}

package/build/cjs/garbage/garbage-container.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GarbageContainer = exports.GarbageHandler = void 0;
+const api_1 = require("@tabletop-playground/api");
+class GarbageHandler {
+}
+exports.GarbageHandler = GarbageHandler;
+/**
+ * Attempt to recycle deposited objects, break up decks into individual cards.
+ */
+class GarbageContainer {
+    /**
+     * Register a new recycler.
+     *
+     * @param garbageHandler
+     */
+    static addHandler(garbageHandler) {
+        this._garbageHandlers.push(garbageHandler);
+    }
+    /**
+     * Clear all recycle handlers (for tests).
+     */
+    static clearHandlers() {
+        this._garbageHandlers = [];
+    }
+    static _tryRecycleObj(obj) {
+        for (const handler of this._garbageHandlers) {
+            if (handler.canRecycle(obj)) {
+                if (handler.recycle(obj)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    static _tryRecycleDeck(deck) {
+        let recycleCount = 0;
+        const stackSize = deck.getStackSize();
+        // Process one card at a time.  Assume a handler will exist, cost to
+        // extract card worthwhile (and if not, same code path for simplicity).
+        for (let offset = stackSize - 1; offset >= 0; offset--) {
+            // Get the card (use the deck if only one card left).
+            let card;
+            if (offset === 0 && deck.getStackSize() === 1) {
+                card = deck;
+            }
+            else if (deck.getStackSize() > offset) {
+                const numCards = 1;
+                const fromFront = false;
+                const keep = false;
+                card = deck.takeCards(numCards, fromFront, offset, keep);
+            }
+            if (!card) {
+                continue;
+            }
+            // Try to recycle, return card to same spot if fails.
+            let success = GarbageContainer._tryRecycleObj(card);
+            if (success) {
+                recycleCount += 1;
+            }
+            else if (card !== deck) {
+                const toFront = false;
+                const animate = false;
+                const flipped = false;
+                deck.addCards(card, toFront, offset, animate, flipped);
+            }
+        }
+        return recycleCount === stackSize;
+    }
+    constructor(container) {
+        if (!container) {
+            throw new Error("missing container");
+        }
+        this._container = container;
+        container.onInserted.add((container, insertedObjects, player) => {
+            process.nextTick(() => {
+                this._recycle();
+            });
+        });
+    }
+    // Expose for testing.
+    _recycle() {
+        const objs = this._container.getItems();
+        for (const obj of objs) {
+            // Verify object.
+            if (!obj.isValid()) {
+                continue; // object destroyed
+            }
+            if (obj.getContainer() !== this._container) {
+                continue; // object no longer in this container
+            }
+            // Remove from container.
+            const above = this._container
+                .getPosition()
+                .add([0, 0, obj.getSize().z + 3]);
+            this._container.take(obj, above);
+            // Attempt to recyle.
+            let success;
+            if (obj instanceof api_1.Card && obj.getStackSize() > 1) {
+                success = GarbageContainer._tryRecycleDeck(obj);
+            }
+            else {
+                success = GarbageContainer._tryRecycleObj(obj);
+            }
+            // If recycle fails, return to container.
+            if (!success) {
+                this._container.addObjects([obj]);
+            }
+        }
+    }
+}
+exports.GarbageContainer = GarbageContainer;
+GarbageContainer._garbageHandlers = [];

package/build/cjs/garbage/simple-card-garbage-handler.d.ts

@@ -0,0 +1,16 @@
+import { GameObject } from "@tabletop-playground/api";
+import { GarbageHandler } from "./garbage-container";
+export declare class SimpleCardGarbageHandler implements GarbageHandler {
+    private _matNsid;
+    private _matSnapPointTag;
+    private _cardNsidPrefix;
+    private _shuffleAfterDiscard;
+    private _discardSnapPoint;
+    setMatNsid(matNsid: string): this;
+    setMatSnapPointTag(tag: string): this;
+    setCardNsidPrefix(cardNsidPrefix: string): this;
+    setShuffleAfterDiscard(shuffle: boolean): this;
+    canRecycle(obj: GameObject): boolean;
+    recycle(obj: GameObject): boolean;
+    private _getDiscardSnapPoint;
+}

package/build/cjs/garbage/simple-card-garbage-handler.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SimpleCardGarbageHandler = void 0;
+const api_1 = require("@tabletop-playground/api");
+const nsid_1 = require("../nsid/nsid");
+class SimpleCardGarbageHandler {
+    constructor() {
+        this._matNsid = "";
+        this._matSnapPointTag = "";
+        this._cardNsidPrefix = "";
+        this._shuffleAfterDiscard = false;
+    }
+    setMatNsid(matNsid) {
+        this._matNsid = matNsid;
+        return this;
+    }
+    setMatSnapPointTag(tag) {
+        this._matSnapPointTag = tag;
+        return this;
+    }
+    setCardNsidPrefix(cardNsidPrefix) {
+        this._cardNsidPrefix = cardNsidPrefix;
+        return this;
+    }
+    setShuffleAfterDiscard(shuffle) {
+        this._shuffleAfterDiscard = shuffle;
+        return this;
+    }
+    canRecycle(obj) {
+        if (!(obj instanceof api_1.Card)) {
+            return false;
+        }
+        if (obj.getStackSize() !== 1) {
+            return false;
+        }
+        const nsid = nsid_1.NSID.get(obj);
+        return (this._cardNsidPrefix.length > 0 && nsid.startsWith(this._cardNsidPrefix));
+    }
+    recycle(obj) {
+        // Verify card.
+        if (!(obj instanceof api_1.Card)) {
+            throw new Error("not a card");
+        }
+        if (obj.getStackSize() !== 1) {
+            throw new Error("not singleton card");
+        }
+        const nsid = nsid_1.NSID.get(obj);
+        if (!nsid.startsWith(this._cardNsidPrefix)) {
+            throw new Error("nsid mismatch");
+        }
+        // Find mat.
+        const snapPoint = this._getDiscardSnapPoint();
+        if (!snapPoint) {
+            return false;
+        }
+        // Find discard deck.
+        let deck = snapPoint === null || snapPoint === void 0 ? void 0 : snapPoint.getSnappedObject();
+        if (deck && !(deck instanceof api_1.Card)) {
+            deck = undefined;
+        }
+        // Discard.
+        if (deck) {
+            const toFront = false;
+            const offset = 0;
+            const animate = true;
+            const flipped = false;
+            const success = deck.addCards(obj, toFront, offset, animate, flipped);
+            if (!success) {
+                return false;
+            }
+        }
+        else {
+            const above = snapPoint.getGlobalPosition().add([0, 0, 10]);
+            const animationSpeed = 0;
+            obj.setPosition(above, animationSpeed);
+            obj.snapToGround();
+            obj.snap(); // apply snap point rotation
+        }
+        // Optionally shuffle.  Must wait for discard animation to finish!
+        if (this._shuffleAfterDiscard && deck) {
+            const finishShuffle = () => {
+                if (deck instanceof api_1.Card) {
+                    deck.shuffle();
+                }
+            };
+            const delayedShuffle = () => {
+                process.nextTick(finishShuffle);
+            };
+            if (obj.isValid()) {
+                obj.onDestroyed.add(() => {
+                    process.nextTick(delayedShuffle);
+                });
+            }
+        }
+        return true;
+    }
+    _getDiscardSnapPoint() {
+        var _a;
+        // Check cache.
+        if (this._discardSnapPoint &&
+            ((_a = this._discardSnapPoint.getParentObject()) === null || _a === void 0 ? void 0 : _a.isValid())) {
+            return this._discardSnapPoint;
+        }
+        this._discardSnapPoint = undefined;
+        // Find mat.
+        let mat = undefined;
+        const skipContained = true;
+        for (const obj of api_1.world.getAllObjects(skipContained)) {
+            const nsid = nsid_1.NSID.get(obj);
+            if (nsid === this._matNsid) {
+                mat = obj;
+                break;
+            }
+        }
+        if (!mat) {
+            return undefined;
+        }
+        // Find snap point.
+        for (const snapPoint of mat.getAllSnapPoints()) {
+            for (const tag of snapPoint.getTags()) {
+                if (tag === this._matSnapPointTag) {
+                    this._discardSnapPoint = snapPoint; // cache
+                    return snapPoint;
+                }
+            }
+        }
+        return undefined;
+    }
+}
+exports.SimpleCardGarbageHandler = SimpleCardGarbageHandler;

package/build/cjs/global/content-menu/leave-seat.d.ts

@@ -1,4 +1,11 @@
+import { Player } from "@tabletop-playground/api";
 import { AbstractGlobal } from "../abstract-global";
+/**
+ * Content menu item to leave seat.  Move to an unused slot, NOT the
+ * spectator slot.  Spectators cannot interact, preventing them from
+ * clicking any "take seat" buttons.
+ */
 export declare class LeaveSeat implements AbstractGlobal {
     init(): void;
+    static leaveSeat(clickingPlayer: Player): void;
 }

package/build/cjs/global/content-menu/leave-seat.js

@@ -2,16 +2,37 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LeaveSeat = void 0;
 const api_1 = require("@tabletop-playground/api");
+/**
+ * Content menu item to leave seat.  Move to an unused slot, NOT the
+ * spectator slot.  Spectators cannot interact, preventing them from
+ * clicking any "take seat" buttons.
+ */
 class LeaveSeat {
     init() {
         const actionName = "*Leave seat";
-        const tooltip = "Switch to spectator";
+        const tooltip = "Switch to non-seat player slot";
         api_1.world.addCustomAction(actionName, tooltip);
         api_1.globalEvents.onCustomAction.add((player, identifier) => {
             if (identifier === actionName) {
-                player.switchSlot(-1);
+                LeaveSeat.leaveSeat(player);
             }
         });
     }
+    static leaveSeat(clickingPlayer) {
+        const busy = new Set();
+        for (const player of api_1.world.getAllPlayers()) {
+            busy.add(player.getSlot());
+        }
+        for (const obj of api_1.world.getAllObjects()) {
+            busy.add(obj.getOwningPlayerSlot());
+        }
+        for (let i = 0; i < 20; i++) {
+            if (!busy.has(i)) {
+                console.log(`LeaveSeat: moving "${clickingPlayer.getName()}" to open slot ${i}`);
+                clickingPlayer.switchSlot(i);
+                break;
+            }
+        }
+    }
 }
 exports.LeaveSeat = LeaveSeat;

package/build/cjs/index.d.ts

@@ -1,3 +1,5 @@
+export * from "./garbage/garbage-container";
+export * from "./garbage/simple-card-garbage-handler";
 export * from "./global/abstract-global";
 export * from "./global/content-menu/leave-seat";
 export * from "./locale/locale";

package/build/cjs/index.js

@@ -14,6 +14,8 @@ 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("./garbage/garbage-container"), exports);
+__exportStar(require("./garbage/simple-card-garbage-handler"), exports);
 __exportStar(require("./global/abstract-global"), exports);
 __exportStar(require("./global/content-menu/leave-seat"), exports);
 __exportStar(require("./locale/locale"), exports);

package/build/esm/garbage/garbage-container.d.ts

@@ -0,0 +1,37 @@
+import { Container, GameObject } from "@tabletop-playground/api";
+export declare abstract class GarbageHandler {
+    /**
+     * Can recycle this object?
+     *
+     * @param obj
+     */
+    abstract canRecycle(obj: GameObject): boolean;
+    /**
+     * Recycle the object.
+     *
+     * @param obj
+     * @returns true if recycled
+     */
+    abstract recycle(obj: GameObject): boolean;
+}
+/**
+ * Attempt to recycle deposited objects, break up decks into individual cards.
+ */
+export declare class GarbageContainer {
+    private static _garbageHandlers;
+    private readonly _container;
+    /**
+     * Register a new recycler.
+     *
+     * @param garbageHandler
+     */
+    static addHandler(garbageHandler: GarbageHandler): void;
+    /**
+     * Clear all recycle handlers (for tests).
+     */
+    static clearHandlers(): void;
+    private static _tryRecycleObj;
+    private static _tryRecycleDeck;
+    constructor(container: Container);
+    _recycle(): void;
+}

package/build/esm/garbage/garbage-container.js

@@ -0,0 +1,108 @@
+import { Card, } from "@tabletop-playground/api";
+export class GarbageHandler {
+}
+/**
+ * Attempt to recycle deposited objects, break up decks into individual cards.
+ */
+export class GarbageContainer {
+    /**
+     * Register a new recycler.
+     *
+     * @param garbageHandler
+     */
+    static addHandler(garbageHandler) {
+        this._garbageHandlers.push(garbageHandler);
+    }
+    /**
+     * Clear all recycle handlers (for tests).
+     */
+    static clearHandlers() {
+        this._garbageHandlers = [];
+    }
+    static _tryRecycleObj(obj) {
+        for (const handler of this._garbageHandlers) {
+            if (handler.canRecycle(obj)) {
+                if (handler.recycle(obj)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    static _tryRecycleDeck(deck) {
+        let recycleCount = 0;
+        const stackSize = deck.getStackSize();
+        // Process one card at a time.  Assume a handler will exist, cost to
+        // extract card worthwhile (and if not, same code path for simplicity).
+        for (let offset = stackSize - 1; offset >= 0; offset--) {
+            // Get the card (use the deck if only one card left).
+            let card;
+            if (offset === 0 && deck.getStackSize() === 1) {
+                card = deck;
+            }
+            else if (deck.getStackSize() > offset) {
+                const numCards = 1;
+                const fromFront = false;
+                const keep = false;
+                card = deck.takeCards(numCards, fromFront, offset, keep);
+            }
+            if (!card) {
+                continue;
+            }
+            // Try to recycle, return card to same spot if fails.
+            let success = GarbageContainer._tryRecycleObj(card);
+            if (success) {
+                recycleCount += 1;
+            }
+            else if (card !== deck) {
+                const toFront = false;
+                const animate = false;
+                const flipped = false;
+                deck.addCards(card, toFront, offset, animate, flipped);
+            }
+        }
+        return recycleCount === stackSize;
+    }
+    constructor(container) {
+        if (!container) {
+            throw new Error("missing container");
+        }
+        this._container = container;
+        container.onInserted.add((container, insertedObjects, player) => {
+            process.nextTick(() => {
+                this._recycle();
+            });
+        });
+    }
+    // Expose for testing.
+    _recycle() {
+        const objs = this._container.getItems();
+        for (const obj of objs) {
+            // Verify object.
+            if (!obj.isValid()) {
+                continue; // object destroyed
+            }
+            if (obj.getContainer() !== this._container) {
+                continue; // object no longer in this container
+            }
+            // Remove from container.
+            const above = this._container
+                .getPosition()
+                .add([0, 0, obj.getSize().z + 3]);
+            this._container.take(obj, above);
+            // Attempt to recyle.
+            let success;
+            if (obj instanceof Card && obj.getStackSize() > 1) {
+                success = GarbageContainer._tryRecycleDeck(obj);
+            }
+            else {
+                success = GarbageContainer._tryRecycleObj(obj);
+            }
+            // If recycle fails, return to container.
+            if (!success) {
+                this._container.addObjects([obj]);
+            }
+        }
+    }
+}
+GarbageContainer._garbageHandlers = [];

package/build/esm/garbage/simple-card-garbage-handler.d.ts

@@ -0,0 +1,16 @@
+import { GameObject } from "@tabletop-playground/api";
+import { GarbageHandler } from "./garbage-container";
+export declare class SimpleCardGarbageHandler implements GarbageHandler {
+    private _matNsid;
+    private _matSnapPointTag;
+    private _cardNsidPrefix;
+    private _shuffleAfterDiscard;
+    private _discardSnapPoint;
+    setMatNsid(matNsid: string): this;
+    setMatSnapPointTag(tag: string): this;
+    setCardNsidPrefix(cardNsidPrefix: string): this;
+    setShuffleAfterDiscard(shuffle: boolean): this;
+    canRecycle(obj: GameObject): boolean;
+    recycle(obj: GameObject): boolean;
+    private _getDiscardSnapPoint;
+}

package/build/esm/garbage/simple-card-garbage-handler.js

@@ -0,0 +1,126 @@
+import { Card, world } from "@tabletop-playground/api";
+import { NSID } from "../nsid/nsid";
+export class SimpleCardGarbageHandler {
+    constructor() {
+        this._matNsid = "";
+        this._matSnapPointTag = "";
+        this._cardNsidPrefix = "";
+        this._shuffleAfterDiscard = false;
+    }
+    setMatNsid(matNsid) {
+        this._matNsid = matNsid;
+        return this;
+    }
+    setMatSnapPointTag(tag) {
+        this._matSnapPointTag = tag;
+        return this;
+    }
+    setCardNsidPrefix(cardNsidPrefix) {
+        this._cardNsidPrefix = cardNsidPrefix;
+        return this;
+    }
+    setShuffleAfterDiscard(shuffle) {
+        this._shuffleAfterDiscard = shuffle;
+        return this;
+    }
+    canRecycle(obj) {
+        if (!(obj instanceof Card)) {
+            return false;
+        }
+        if (obj.getStackSize() !== 1) {
+            return false;
+        }
+        const nsid = NSID.get(obj);
+        return (this._cardNsidPrefix.length > 0 && nsid.startsWith(this._cardNsidPrefix));
+    }
+    recycle(obj) {
+        // Verify card.
+        if (!(obj instanceof Card)) {
+            throw new Error("not a card");
+        }
+        if (obj.getStackSize() !== 1) {
+            throw new Error("not singleton card");
+        }
+        const nsid = NSID.get(obj);
+        if (!nsid.startsWith(this._cardNsidPrefix)) {
+            throw new Error("nsid mismatch");
+        }
+        // Find mat.
+        const snapPoint = this._getDiscardSnapPoint();
+        if (!snapPoint) {
+            return false;
+        }
+        // Find discard deck.
+        let deck = snapPoint === null || snapPoint === void 0 ? void 0 : snapPoint.getSnappedObject();
+        if (deck && !(deck instanceof Card)) {
+            deck = undefined;
+        }
+        // Discard.
+        if (deck) {
+            const toFront = false;
+            const offset = 0;
+            const animate = true;
+            const flipped = false;
+            const success = deck.addCards(obj, toFront, offset, animate, flipped);
+            if (!success) {
+                return false;
+            }
+        }
+        else {
+            const above = snapPoint.getGlobalPosition().add([0, 0, 10]);
+            const animationSpeed = 0;
+            obj.setPosition(above, animationSpeed);
+            obj.snapToGround();
+            obj.snap(); // apply snap point rotation
+        }
+        // Optionally shuffle.  Must wait for discard animation to finish!
+        if (this._shuffleAfterDiscard && deck) {
+            const finishShuffle = () => {
+                if (deck instanceof Card) {
+                    deck.shuffle();
+                }
+            };
+            const delayedShuffle = () => {
+                process.nextTick(finishShuffle);
+            };
+            if (obj.isValid()) {
+                obj.onDestroyed.add(() => {
+                    process.nextTick(delayedShuffle);
+                });
+            }
+        }
+        return true;
+    }
+    _getDiscardSnapPoint() {
+        var _a;
+        // Check cache.
+        if (this._discardSnapPoint &&
+            ((_a = this._discardSnapPoint.getParentObject()) === null || _a === void 0 ? void 0 : _a.isValid())) {
+            return this._discardSnapPoint;
+        }
+        this._discardSnapPoint = undefined;
+        // Find mat.
+        let mat = undefined;
+        const skipContained = true;
+        for (const obj of world.getAllObjects(skipContained)) {
+            const nsid = NSID.get(obj);
+            if (nsid === this._matNsid) {
+                mat = obj;
+                break;
+            }
+        }
+        if (!mat) {
+            return undefined;
+        }
+        // Find snap point.
+        for (const snapPoint of mat.getAllSnapPoints()) {
+            for (const tag of snapPoint.getTags()) {
+                if (tag === this._matSnapPointTag) {
+                    this._discardSnapPoint = snapPoint; // cache
+                    return snapPoint;
+                }
+            }
+        }
+        return undefined;
+    }
+}

package/build/esm/global/content-menu/leave-seat.d.ts

@@ -1,4 +1,11 @@
+import { Player } from "@tabletop-playground/api";
 import { AbstractGlobal } from "../abstract-global";
+/**
+ * Content menu item to leave seat.  Move to an unused slot, NOT the
+ * spectator slot.  Spectators cannot interact, preventing them from
+ * clicking any "take seat" buttons.
+ */
 export declare class LeaveSeat implements AbstractGlobal {
     init(): void;
+    static leaveSeat(clickingPlayer: Player): void;
 }

package/build/esm/global/content-menu/leave-seat.js

@@ -1,13 +1,34 @@
 import { globalEvents, world } from "@tabletop-playground/api";
+/**
+ * Content menu item to leave seat.  Move to an unused slot, NOT the
+ * spectator slot.  Spectators cannot interact, preventing them from
+ * clicking any "take seat" buttons.
+ */
 export class LeaveSeat {
     init() {
         const actionName = "*Leave seat";
-        const tooltip = "Switch to spectator";
+        const tooltip = "Switch to non-seat player slot";
         world.addCustomAction(actionName, tooltip);
         globalEvents.onCustomAction.add((player, identifier) => {
             if (identifier === actionName) {
-                player.switchSlot(-1);
+                LeaveSeat.leaveSeat(player);
             }
         });
     }
+    static leaveSeat(clickingPlayer) {
+        const busy = new Set();
+        for (const player of world.getAllPlayers()) {
+            busy.add(player.getSlot());
+        }
+        for (const obj of world.getAllObjects()) {
+            busy.add(obj.getOwningPlayerSlot());
+        }
+        for (let i = 0; i < 20; i++) {
+            if (!busy.has(i)) {
+                console.log(`LeaveSeat: moving "${clickingPlayer.getName()}" to open slot ${i}`);
+                clickingPlayer.switchSlot(i);
+                break;
+            }
+        }
+    }
 }

package/build/esm/index.d.ts

@@ -1,3 +1,5 @@
+export * from "./garbage/garbage-container";
+export * from "./garbage/simple-card-garbage-handler";
 export * from "./global/abstract-global";
 export * from "./global/content-menu/leave-seat";
 export * from "./locale/locale";

package/build/esm/index.js

@@ -1,3 +1,5 @@
+export * from "./garbage/garbage-container";
+export * from "./garbage/simple-card-garbage-handler";
 export * from "./global/abstract-global";
 export * from "./global/content-menu/leave-seat";
 export * from "./locale/locale";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ttpg-darrell",
-  "version": "1.0.9",
+  "version": "1.0.11",
   "description": "TTPG TypeScript library",
   "main": "./build/cjs/index.js",
   "module": "./build/esm/index.js",