@gamepark/mythologies 0.1.0

package/dist/material/entity/zulu/Impundulu.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Impundulu = void 0;
+exports.Impundulu = {
+    invoke: [{ favor: 1 }, {}, {}]
+};

package/dist/material/entity/zulu/Inkanyamba.d.ts

@@ -0,0 +1,2 @@
+import { EntityDescription } from '../EntityDescription';
+export declare const Inkanyamba: EntityDescription;

package/dist/material/entity/zulu/Inkanyamba.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Inkanyamba = void 0;
+exports.Inkanyamba = {
+    invoke: [{}, { favor: 1 }, { gem: 1 }]
+};

package/dist/material/entity/zulu/Inkosazana.d.ts

@@ -0,0 +1,2 @@
+import { EntityDescription } from '../EntityDescription';
+export declare const Inkosazana: EntityDescription;

package/dist/material/entity/zulu/Inkosazana.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Inkosazana = void 0;
+exports.Inkosazana = {
+    invoke: [{}, { gem: 1, favor: 1 }, { favor: 1 }]
+};

package/dist/material/entity/zulu/Shembe.d.ts

@@ -0,0 +1,2 @@
+import { EntityDescription } from '../EntityDescription';
+export declare const Shembe: EntityDescription;

package/dist/material/entity/zulu/Shembe.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Shembe = void 0;
+exports.Shembe = {
+    invoke: [{ gem: 1 }, { gem: 2 }, {}]
+};

package/dist/material/entity/zulu/Tokoloshe.d.ts

@@ -0,0 +1,2 @@
+import { EntityDescription } from '../EntityDescription';
+export declare const Tokoloshe: EntityDescription;

package/dist/material/entity/zulu/Tokoloshe.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Tokoloshe = void 0;
+exports.Tokoloshe = {
+    invoke: [{}, { gem: 3 }, { favor: 2 }]
+};

package/dist/material/entity/zulu/Umvelinqangi.d.ts

@@ -0,0 +1,2 @@
+import { EntityDescription } from '../EntityDescription';
+export declare const Umvelinqangi: EntityDescription;

package/dist/material/entity/zulu/Umvelinqangi.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Umvelinqangi = void 0;
+exports.Umvelinqangi = {
+    invoke: [{ gem: 1, favor: 1 }, { gem: 1 }, {}]
+};

package/dist/material/entity/zulu/Unkulunkulu.d.ts

@@ -0,0 +1,2 @@
+import { EntityDescription } from '../EntityDescription';
+export declare const Unkulunkulu: EntityDescription;

package/dist/material/entity/zulu/Unkulunkulu.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Unkulunkulu = void 0;
+exports.Unkulunkulu = {
+    invoke: [{ favor: 1 }, { favor: 2 }, {}]
+};

package/dist/material/entity/zulu/Unwabu.d.ts

@@ -0,0 +1,2 @@
+import { EntityDescription } from '../EntityDescription';
+export declare const Unwabu: EntityDescription;

package/dist/material/entity/zulu/Unwabu.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Unwabu = void 0;
+exports.Unwabu = {
+    invoke: [{ gem: 2 }, { favor: 1 }, {}]
+};

package/dist/material/entity/zulu/Werehyena.d.ts

@@ -0,0 +1,2 @@
+import { EntityDescription } from '../EntityDescription';
+export declare const Werehyena: EntityDescription;

package/dist/material/entity/zulu/Werehyena.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Werehyena = void 0;
+exports.Werehyena = {
+    invoke: [{}, { gem: 1 }, { gem: 2 }]
+};

package/dist/rules/ChooseDraftTokenRule.d.ts

@@ -0,0 +1,15 @@
+import { ItemMove, SimultaneousRule } from '@gamepark/rules-api';
+import { LocationType } from '../material/LocationType';
+import { PlayerColor } from '../PlayerColor';
+import { RuleId } from './RuleId';
+export declare class ChooseDraftTokenRule extends SimultaneousRule {
+    onRuleStart(): import("@gamepark/rules-api").MoveItem<number, number, number>[];
+    getActivePlayerLegalMoves(player: PlayerColor): import("@gamepark/rules-api").MoveItem<number, number, number>[];
+    getTokenDestination(player: PlayerColor): {
+        type: LocationType;
+        parent: number;
+        rotation: boolean;
+    };
+    afterItemMove(move: ItemMove): import("@gamepark/rules-api").Shuffle<number>[] | import("@gamepark/rules-api").EndPlayerTurn<PlayerColor>[] | (import("@gamepark/rules-api").MoveItem<number, number, number> | import("@gamepark/rules-api").StartRule<RuleId.DrawDestinyCard> | import("@gamepark/rules-api").StartSimultaneousRule<PlayerColor, RuleId.PlaceToken>)[];
+    getMovesAfterPlayersDone(): import("@gamepark/rules-api").MoveItemsAtOnce<number, number, number>[];
+}

package/dist/rules/ChooseDraftTokenRule.js

@@ -0,0 +1,103 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChooseDraftTokenRule = void 0;
+var rules_api_1 = require("@gamepark/rules-api");
+var Destiny_1 = require("../material/Destiny");
+var LocationType_1 = require("../material/LocationType");
+var MaterialType_1 = require("../material/MaterialType");
+var RuleId_1 = require("./RuleId");
+var ChooseDraftTokenRule = (function (_super) {
+    __extends(ChooseDraftTokenRule, _super);
+    function ChooseDraftTokenRule() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    ChooseDraftTokenRule.prototype.onRuleStart = function () {
+        var _this = this;
+        var destinyLeft = this.material(MaterialType_1.MaterialType.DestinyCard).location(LocationType_1.LocationType.DestinyDeck).length;
+        var takeTokens = this.material(MaterialType_1.MaterialType.DraftToken)
+            .location(LocationType_1.LocationType.PlayerHand)
+            .id(function (id) { return id.front === true; });
+        var playersHavingToTake = this.game.players.filter(function (player) { return takeTokens.player(player).length > destinyLeft; });
+        return playersHavingToTake.map(function (player) { return takeTokens.player(player).deck().dealOne(_this.getTokenDestination(player)); });
+    };
+    ChooseDraftTokenRule.prototype.getActivePlayerLegalMoves = function (player) {
+        return this.material(MaterialType_1.MaterialType.DraftToken).location(LocationType_1.LocationType.PlayerHand).player(player).moveItems(this.getTokenDestination(player));
+    };
+    ChooseDraftTokenRule.prototype.getTokenDestination = function (player) {
+        var mythologyBoard = new Destiny_1.Destiny(this.game).getMythologyBoard(player);
+        return {
+            type: LocationType_1.LocationType.PlayedTokenSpot,
+            parent: mythologyBoard.getIndex(),
+            rotation: true
+        };
+    };
+    ChooseDraftTokenRule.prototype.afterItemMove = function (move) {
+        if ((0, rules_api_1.isMoveItemType)(MaterialType_1.MaterialType.DraftToken)(move)) {
+            if (move.location.type === LocationType_1.LocationType.PlayedTokenSpot) {
+                return [this.endPlayerTurn(this.material(MaterialType_1.MaterialType.DraftToken).getItem(move.itemIndex).id.back)];
+            }
+            else if (move.location.type === LocationType_1.LocationType.PlayerHand) {
+                return [this.material(MaterialType_1.MaterialType.DraftToken).location(LocationType_1.LocationType.PlayerHand).player(move.location.player).shuffle()];
+            }
+        }
+        else if ((0, rules_api_1.isMoveItemTypeAtOnce)(MaterialType_1.MaterialType.DraftToken)(move)) {
+            var playedTokens = this.material(MaterialType_1.MaterialType.DraftToken).location(LocationType_1.LocationType.PlayedTokenSpot);
+            var takeBackPassTokens = playedTokens
+                .id(function (id) { return id.front === false; })
+                .moveItems(function (item) { return ({ type: LocationType_1.LocationType.PlayerHand, player: item.id.back }); });
+            var playersTaking = playedTokens
+                .id(function (id) { return id.front === true; })
+                .getItems()
+                .map(function (item) { return item.id.back; });
+            return __spreadArray(__spreadArray([], __read(takeBackPassTokens), false), [
+                playersTaking.length ? this.startSimultaneousRule(RuleId_1.RuleId.PlaceToken, playersTaking) : this.startRule(RuleId_1.RuleId.DrawDestinyCard)
+            ], false);
+        }
+        return [];
+    };
+    ChooseDraftTokenRule.prototype.getMovesAfterPlayersDone = function () {
+        return [this.material(MaterialType_1.MaterialType.DraftToken).location(LocationType_1.LocationType.PlayedTokenSpot).moveItemsAtOnce({ rotation: false })];
+    };
+    return ChooseDraftTokenRule;
+}(rules_api_1.SimultaneousRule));
+exports.ChooseDraftTokenRule = ChooseDraftTokenRule;

package/dist/rules/DrawDestinyCardRule.d.ts

@@ -0,0 +1,7 @@
+import { ItemMove, MaterialMove, MaterialRulesPart } from '@gamepark/rules-api';
+import { RuleId } from './RuleId';
+export declare class DrawDestinyCardRule extends MaterialRulesPart {
+    onRuleStart(): (import("@gamepark/rules-api").MoveItem<number, number, number> | import("@gamepark/rules-api").StartSimultaneousRule<number, RuleId.ChooseDraftToken>)[];
+    afterItemMove(move: ItemMove): MaterialMove<number, number, number, number>[];
+    exileCards(): MaterialMove<number, number, number, number>[];
+}

package/dist/rules/DrawDestinyCardRule.js

@@ -0,0 +1,116 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DrawDestinyCardRule = void 0;
+var rules_api_1 = require("@gamepark/rules-api");
+var lodash_1 = require("lodash");
+var Destiny_1 = require("../material/Destiny");
+var LocationType_1 = require("../material/LocationType");
+var MaterialType_1 = require("../material/MaterialType");
+var RuleId_1 = require("./RuleId");
+var DrawDestinyCardRule = (function (_super) {
+    __extends(DrawDestinyCardRule, _super);
+    function DrawDestinyCardRule() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    DrawDestinyCardRule.prototype.onRuleStart = function () {
+        var playersWithDraftToken = (0, lodash_1.uniq)(this.material(MaterialType_1.MaterialType.DraftToken)
+            .location(LocationType_1.LocationType.PlayerHand)
+            .id(function (id) { return id.front === true; })
+            .getItems()
+            .map(function (item) { return item.location.player; }));
+        return [
+            this.material(MaterialType_1.MaterialType.DestinyCard).location(LocationType_1.LocationType.DestinyDeck).deck().dealOne({ type: LocationType_1.LocationType.CurrentDestiny }),
+            this.startSimultaneousRule(RuleId_1.RuleId.ChooseDraftToken, playersWithDraftToken)
+        ];
+    };
+    DrawDestinyCardRule.prototype.afterItemMove = function (move) {
+        if (this.game.players.length === 2 && (0, rules_api_1.isMoveItemType)(MaterialType_1.MaterialType.DestinyCard)(move)) {
+            return this.exileCards();
+        }
+        return [];
+    };
+    DrawDestinyCardRule.prototype.exileCards = function () {
+        var e_1, _a;
+        var moves = [];
+        var boards = new Destiny_1.Destiny(this.game).getBoardsWithoutPlayer();
+        var count = this.material(MaterialType_1.MaterialType.DestinyCard).location(LocationType_1.LocationType.CurrentDestiny).length;
+        var tokensOnCards = this.material(MaterialType_1.MaterialType.DraftToken).location(LocationType_1.LocationType.OnEntityCard).getItems();
+        var cardsWithToken = tokensOnCards.map(function (item) { return item.location.parent; });
+        var entities = this.material(MaterialType_1.MaterialType.EntityCard).index(function (index) { return !cardsWithToken.includes(index); });
+        var creatures = entities.location(LocationType_1.LocationType.SanctuaryCreatureSpot);
+        var gods = entities.location(LocationType_1.LocationType.SanctuaryGodSpot);
+        try {
+            for (var _b = __values(boards.getIndexes()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var index = _c.value;
+                var creature = creatures.parent(index).location(function (l) { return l.x === count - 1; });
+                if (creature.length) {
+                    moves.push(creature.deleteItem());
+                }
+                else {
+                    moves.push.apply(moves, __spreadArray([], __read(gods.parent(index).deleteItems()), false));
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return moves;
+    };
+    return DrawDestinyCardRule;
+}(rules_api_1.MaterialRulesPart));
+exports.DrawDestinyCardRule = DrawDestinyCardRule;

package/dist/rules/EndGameRule.d.ts

@@ -0,0 +1,5 @@
+import { PlayerTurnRule } from '@gamepark/rules-api';
+import { RuleId } from './RuleId';
+export declare class EndGameRule extends PlayerTurnRule {
+    onRuleStart(): import("@gamepark/rules-api").StartPlayerTurn<number, RuleId.ResolveEffects>[] | import("@gamepark/rules-api").EndGame[];
+}

package/dist/rules/EndGameRule.js

@@ -0,0 +1,44 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EndGameRule = void 0;
+var rules_api_1 = require("@gamepark/rules-api");
+var Effect_1 = require("../material/entity/Effect");
+var MaterialType_1 = require("../material/MaterialType");
+var Memory_1 = require("../Memory");
+var TriggerEffectsRule_1 = require("./effects/TriggerEffectsRule");
+var RuleId_1 = require("./RuleId");
+var EndGameRule = (function (_super) {
+    __extends(EndGameRule, _super);
+    function EndGameRule() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    EndGameRule.prototype.onRuleStart = function () {
+        new TriggerEffectsRule_1.TriggerEffectsRule(this.game).triggerEffects({ type: Effect_1.TriggerEventType.EndOfGame });
+        var pendingEffects = this.remind(Memory_1.Memory.PendingEffects);
+        if (pendingEffects.length) {
+            var cardIndex = pendingEffects[0][0].cardIndex;
+            var player = this.material(MaterialType_1.MaterialType.EntityCard).getItem(cardIndex).location.player;
+            return [this.startPlayerTurn(RuleId_1.RuleId.ResolveEffects, player)];
+        }
+        else {
+            return [this.endGame()];
+        }
+    };
+    return EndGameRule;
+}(rules_api_1.PlayerTurnRule));
+exports.EndGameRule = EndGameRule;

package/dist/rules/PlaceCardsRule.d.ts

@@ -0,0 +1,13 @@
+import { CustomMove, ItemMove, MaterialMove, PlayerTurnRule } from '@gamepark/rules-api';
+import { RuleId } from './RuleId';
+export declare class PlaceCardsRule extends PlayerTurnRule {
+    isInvoke: boolean;
+    getPlayerMoves(): MaterialMove<number, number, number, number>[];
+    get infiniteEffects(): import("../material/entity/Effect").PendingEffect<import("../material/entity/Effect").TriggerEvent>[];
+    get tokens(): import("@gamepark/rules-api").Material<number, number, number>;
+    afterItemMove(move: ItemMove): MaterialMove<number, number, number, number>[];
+    onCustomMove(move: CustomMove): MaterialMove<number, number, number, number>[];
+    onPass(): MaterialMove<number, number, number, number>[];
+    get nextRule(): import("@gamepark/rules-api").StartPlayerTurn<number, RuleId.PlaceCards> | import("@gamepark/rules-api").StartPlayerTurn<number, RuleId.Upkeep> | import("@gamepark/rules-api").StartPlayerTurn<number, RuleId.EndGame>;
+    get round(): number;
+}

package/dist/rules/PlaceCardsRule.js

@@ -0,0 +1,192 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlaceCardsRule = void 0;
+var rules_api_1 = require("@gamepark/rules-api");
+var CustomMoveType_1 = require("../CustomMoveType");
+var Entity_1 = require("../material/Entity");
+var Effect_1 = require("../material/entity/Effect");
+var EntityDescription_1 = require("../material/entity/EntityDescription");
+var LocationType_1 = require("../material/LocationType");
+var MaterialType_1 = require("../material/MaterialType");
+var Pantheon_1 = require("../material/Pantheon");
+var Trial_1 = require("../material/Trial");
+var Memory_1 = require("../Memory");
+var ResolveEffectsRule_1 = require("./effects/ResolveEffectsRule");
+var TriggerEffectsRule_1 = require("./effects/TriggerEffectsRule");
+var RuleId_1 = require("./RuleId");
+var PlaceCardsRule = (function (_super) {
+    __extends(PlaceCardsRule, _super);
+    function PlaceCardsRule() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.isInvoke = true;
+        return _this;
+    }
+    PlaceCardsRule.prototype.getPlayerMoves = function () {
+        var e_1, _a;
+        var _this = this;
+        var moves = this.infiniteEffects.map(function (effect) { return _this.customMove(CustomMoveType_1.CustomMoveType.PlayEffect, effect); });
+        var tokens = this.tokens.getItems();
+        var cards = this.material(MaterialType_1.MaterialType.EntityCard).index(tokens.map(function (token) { return token.location.parent; }));
+        if (cards.length) {
+            var cardsICanInvoke = new Pantheon_1.Pantheon(this.game, this.player).gems < 4 ? cards.id(function (id) { return !(0, Entity_1.isGod)(id.front); }) : cards;
+            try {
+                for (var _b = __values(new Pantheon_1.Pantheon(this.game, this.player).legalSpacesToInvoke), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var _d = _c.value, x = _d.x, y = _d.y;
+                    moves.push.apply(moves, __spreadArray([], __read(cardsICanInvoke.moveItems({ type: LocationType_1.LocationType.Pantheon, x: x, y: y, player: this.player })), false));
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            moves.push.apply(moves, __spreadArray([], __read(cards.moveItems({ type: LocationType_1.LocationType.PlayerDiscard, player: this.player })), false));
+        }
+        else {
+            moves.push(this.customMove(CustomMoveType_1.CustomMoveType.Pass));
+        }
+        return moves;
+    };
+    Object.defineProperty(PlaceCardsRule.prototype, "infiniteEffects", {
+        get: function () {
+            var _this = this;
+            var _a, _b;
+            var pendingRule = (_a = this.remind(Memory_1.Memory.PendingRule)) !== null && _a !== void 0 ? _a : this.game.rule;
+            if ((pendingRule === null || pendingRule === void 0 ? void 0 : pendingRule.id) !== RuleId_1.RuleId.PlaceCards || pendingRule.player !== this.player)
+                return [];
+            var pendingEffect = new TriggerEffectsRule_1.TriggerEffectsRule(this.game).getPlayerEffects(this.player, { type: Effect_1.TriggerEventType.Infinite });
+            var oncePerTurnUsed = (_b = this.remind(Memory_1.Memory.OncePerTurn)) !== null && _b !== void 0 ? _b : [];
+            return pendingEffect.filter(function (pendingEffect) {
+                var card = _this.material(MaterialType_1.MaterialType.EntityCard).getItem(pendingEffect.cardIndex);
+                var effect = (0, EntityDescription_1.getEffects)(card.id.front)[pendingEffect.effectIndex];
+                return !oncePerTurnUsed.includes(pendingEffect.cardIndex) && new effect.rule(_this.game).canPlayEffect(pendingEffect.cardIndex);
+            });
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(PlaceCardsRule.prototype, "tokens", {
+        get: function () {
+            var _this = this;
+            return this.material(MaterialType_1.MaterialType.DraftToken)
+                .location(LocationType_1.LocationType.OnEntityCard)
+                .id(function (id) { return id.back === _this.player; });
+        },
+        enumerable: false,
+        configurable: true
+    });
+    PlaceCardsRule.prototype.afterItemMove = function (move) {
+        var moves = [];
+        if ((0, rules_api_1.isMoveItemType)(MaterialType_1.MaterialType.EntityCard)(move)) {
+            var token = this.tokens.parent(move.itemIndex);
+            if (token.length) {
+                moves.push(token.moveItem({ type: LocationType_1.LocationType.PlayerHand, player: this.player }));
+                var pantheon = new Pantheon_1.Pantheon(this.game, this.player);
+                if (move.location.type === LocationType_1.LocationType.PlayerDiscard) {
+                    moves.push(pantheon.gainGems(2));
+                }
+            }
+        }
+        else if ((0, rules_api_1.isMoveItemType)(MaterialType_1.MaterialType.DraftToken)(move) && this.tokens.length === 0) {
+            moves.push(this.material(MaterialType_1.MaterialType.DraftToken).location(LocationType_1.LocationType.PlayerHand).player(this.player).shuffle());
+        }
+        return moves;
+    };
+    PlaceCardsRule.prototype.onCustomMove = function (move) {
+        if (move.type === CustomMoveType_1.CustomMoveType.Pass) {
+            return this.onPass();
+        }
+        else if (move.type === CustomMoveType_1.CustomMoveType.TrialSuccess) {
+            var reward = move.data.reward;
+            return [new Pantheon_1.Pantheon(this.game, this.player).gainFavor(reward)];
+        }
+        else if (move.type === CustomMoveType_1.CustomMoveType.TrialFailure) {
+            this.memorize(Memory_1.Memory.TrialFailure, true, this.player);
+        }
+        else if (move.type === CustomMoveType_1.CustomMoveType.PlayEffect) {
+            this.memorize(Memory_1.Memory.PendingRule, this.game.rule);
+            return new ResolveEffectsRule_1.ResolveEffectsRule(this.game).onCustomMove(move);
+        }
+        return [];
+    };
+    PlaceCardsRule.prototype.onPass = function () {
+        return __spreadArray(__spreadArray([], __read(new Trial_1.Trial(this.game).passTrials(this.player)), false), [this.nextRule], false);
+    };
+    Object.defineProperty(PlaceCardsRule.prototype, "nextRule", {
+        get: function () {
+            if (this.material(MaterialType_1.MaterialType.DraftToken).location(LocationType_1.LocationType.OnEntityCard).length > 0) {
+                return this.startPlayerTurn(RuleId_1.RuleId.PlaceCards, this.nextPlayer);
+            }
+            else if (this.round < 4) {
+                return this.startPlayerTurn(RuleId_1.RuleId.Upkeep, this.nextPlayer);
+            }
+            else {
+                return this.startPlayerTurn(RuleId_1.RuleId.EndGame, this.nextPlayer);
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(PlaceCardsRule.prototype, "round", {
+        get: function () {
+            return this.material(MaterialType_1.MaterialType.RoundToken).getItem().location.id;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return PlaceCardsRule;
+}(rules_api_1.PlayerTurnRule));
+exports.PlaceCardsRule = PlaceCardsRule;

package/dist/rules/PlaceTokenRule.d.ts

@@ -0,0 +1,13 @@
+import { ItemMove, MaterialMove, SimultaneousRule } from '@gamepark/rules-api';
+import { Mythology } from '../material/Mythology';
+import { PlayerColor } from '../PlayerColor';
+import { RuleId } from './RuleId';
+export declare class PlaceTokenRule extends SimultaneousRule {
+    onRuleStart(): MaterialMove<number, number, number, number>[];
+    getActivePlayerLegalMoves(player: PlayerColor): import("@gamepark/rules-api").MoveItem<number, number, number>[];
+    getAvailableCards(player: PlayerColor): number[];
+    getTopDeckCreature(mythology: Mythology): number;
+    afterItemMove(move: ItemMove): import("@gamepark/rules-api").EndPlayerTurn<PlayerColor>[];
+    getMovesAfterPlayersDone(): import("@gamepark/rules-api").StartRule<RuleId.DrawDestinyCard>[] | (import("@gamepark/rules-api").MoveItem<number, number, number> | import("@gamepark/rules-api").StartPlayerTurn<number, RuleId.PlaceCards>)[];
+    onRuleEnd(): never[];
+}