@gamepark/mythologies 0.10.0 → 0.12.0

package/dist/rules/EndGameRule.js

@@ -1,105 +1,34 @@
-"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));
-};
-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.");
-};
-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 Pantheon_1 = require("../material/Pantheon");
-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 __spreadArray(__spreadArray([], __read(this.convertGems()), false), [this.endGame()], false);
-        }
-    };
-    EndGameRule.prototype.convertGems = function () {
-        var e_1, _a;
-        var moves = [];
-        try {
-            for (var _b = __values(this.game.players), _c = _b.next(); !_c.done; _c = _b.next()) {
-                var player = _c.value;
-                var pantheon = new Pantheon_1.Pantheon(this.game, player);
-                var gems = pantheon.gems;
-                if (gems >= 3) {
-                    var favor = Math.floor(gems / 3);
-                    moves.push(pantheon.spendGems(favor * 3));
-                    moves.push(pantheon.gainFavor(favor));
-                }
-            }
-        }
-        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 EndGameRule;
-}(rules_api_1.PlayerTurnRule));
-exports.EndGameRule = EndGameRule;
+import { PlayerTurnRule } from '@gamepark/rules-api';
+import { TriggerEventType } from '../material/entity/Effect';
+import { MaterialType } from '../material/MaterialType';
+import { Pantheon } from '../material/Pantheon';
+import { Memory } from '../Memory';
+import { TriggerEffectsRule } from './effects/TriggerEffectsRule';
+import { RuleId } from './RuleId';
+export class EndGameRule extends PlayerTurnRule {
+    onRuleStart() {
+        new TriggerEffectsRule(this.game).triggerEffects({ type: TriggerEventType.EndOfGame });
+        const pendingEffects = this.remind(Memory.PendingEffects);
+        if (pendingEffects.length) {
+            const cardIndex = pendingEffects[0].effects[0].cardIndex;
+            const player = this.material(MaterialType.EntityCard).getItem(cardIndex).location.player;
+            return [this.startPlayerTurn(RuleId.ResolveEffects, player)];
+        }
+        else {
+            return [...this.convertGems(), this.endGame()];
+        }
+    }
+    convertGems() {
+        const moves = [];
+        for (const player of this.game.players) {
+            const pantheon = new Pantheon(this.game, player);
+            const gems = pantheon.gems;
+            if (gems >= 3) {
+                const favor = Math.floor(gems / 3);
+                moves.push(pantheon.spendGems(favor * 3));
+                moves.push(pantheon.gainFavor(favor));
+            }
+        }
+        return moves;
+    }
+}

package/dist/rules/PlaceCardsRule.d.ts

@@ -1,14 +1,14 @@
-import { CustomMove, ItemMove, MaterialMove, PlayerTurnRule } from '@gamepark/rules-api';
-import { PendingEffect } from '../material/entity/Effect';
-import { RuleId } from './RuleId';
-export declare class PlaceCardsRule extends PlayerTurnRule {
-    isInvoke: boolean;
-    getPlayerMoves(): MaterialMove<number, number, number, number>[];
-    get infiniteEffects(): PendingEffect<import("../material/entity/Effect").TriggerEvent>[];
-    isOncePerTurnAvailable(cardIndex: number): boolean;
-    beforeItemMove(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;
-}
+import { CustomMove, ItemMove, MaterialMove, PlayerTurnRule } from '@gamepark/rules-api';
+import { CardEffect } from '../material/entity/Effect';
+import { RuleId } from './RuleId';
+export declare class PlaceCardsRule extends PlayerTurnRule {
+    isInvoke: boolean;
+    getPlayerMoves(): MaterialMove[];
+    get infiniteEffects(): CardEffect[];
+    isOncePerTurnAvailable(cardIndex: number): boolean;
+    beforeItemMove(move: ItemMove): MaterialMove[];
+    onCustomMove(move: CustomMove): MaterialMove[];
+    onPass(): MaterialMove[];
+    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

@@ -1,206 +1,107 @@
-"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 cards = this.material(MaterialType_1.MaterialType.EntityCard).location(LocationType_1.LocationType.PlayerSelectedCards).player(this.player);
-        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;
-            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 });
-            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];
-                var canPlayEffect = (0, Effect_1.isTriggeredEffect)(effect) && new effect.rule(_this.game).canPlayEffect(pendingEffect.cardIndex);
-                return canPlayEffect && _this.isOncePerTurnAvailable(pendingEffect.cardIndex);
-            });
-        },
-        enumerable: false,
-        configurable: true
-    });
-    PlaceCardsRule.prototype.isOncePerTurnAvailable = function (cardIndex) {
-        var _a;
-        var oncePerTurnUsed = (_a = this.remind(Memory_1.Memory.OncePerTurn)) !== null && _a !== void 0 ? _a : [];
-        return !oncePerTurnUsed.includes(cardIndex);
-    };
-    PlaceCardsRule.prototype.beforeItemMove = function (move) {
-        var moves = [];
-        if ((0, rules_api_1.isMoveItemType)(MaterialType_1.MaterialType.EntityCard)(move)) {
-            if (this.material(MaterialType_1.MaterialType.EntityCard).getItem(move.itemIndex).location.type === LocationType_1.LocationType.PlayerSelectedCards) {
-                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 (move.location.type === LocationType_1.LocationType.Pantheon) {
-                    moves.push.apply(moves, __spreadArray([], __read(pantheon.onCardPlaced(move)), false));
-                }
-            }
-        }
-        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).onPlayEffect(move.data);
-        }
-        else if (move.type === CustomMoveType_1.CustomMoveType.EndEffect) {
-            return new ResolveEffectsRule_1.ResolveEffectsRule(this.game).onEndEffect();
-        }
-        return [];
-    };
-    PlaceCardsRule.prototype.onPass = function () {
-        var e_2, _a;
-        var moves = [];
-        var effects = new TriggerEffectsRule_1.TriggerEffectsRule(this.game).getPlayerEffects(this.player, { type: Effect_1.TriggerEventType.EndOfTurn, player: this.player });
-        var resolveEffectsRule = new ResolveEffectsRule_1.ResolveEffectsRule(this.game);
-        try {
-            for (var effects_1 = __values(effects), effects_1_1 = effects_1.next(); !effects_1_1.done; effects_1_1 = effects_1.next()) {
-                var effect = effects_1_1.value;
-                moves.push.apply(moves, __spreadArray([], __read(resolveEffectsRule.playEffect(effect)), false));
-            }
-        }
-        catch (e_2_1) { e_2 = { error: e_2_1 }; }
-        finally {
-            try {
-                if (effects_1_1 && !effects_1_1.done && (_a = effects_1.return)) _a.call(effects_1);
-            }
-            finally { if (e_2) throw e_2.error; }
-        }
-        moves.push.apply(moves, __spreadArray([], __read(new Trial_1.Trial(this.game).passTrials(this.player)), false));
-        moves.push(this.nextRule);
-        return moves;
-    };
-    Object.defineProperty(PlaceCardsRule.prototype, "nextRule", {
-        get: function () {
-            if (this.material(MaterialType_1.MaterialType.EntityCard).location(LocationType_1.LocationType.PlayerSelectedCards).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;
+import { isMoveItemType, PlayerTurnRule } from '@gamepark/rules-api';
+import { CustomMoveType } from '../CustomMoveType';
+import { isGod } from '../material/Entity';
+import { isTriggeredEffect, TriggerEventType } from '../material/entity/Effect';
+import { getEffects } from '../material/entity/EntityDescription';
+import { LocationType } from '../material/LocationType';
+import { MaterialType } from '../material/MaterialType';
+import { Pantheon } from '../material/Pantheon';
+import { Trial } from '../material/Trial';
+import { Memory } from '../Memory';
+import { ResolveEffectsRule } from './effects/ResolveEffectsRule';
+import { TriggerEffectsRule } from './effects/TriggerEffectsRule';
+import { RuleId } from './RuleId';
+export class PlaceCardsRule extends PlayerTurnRule {
+    isInvoke = true;
+    getPlayerMoves() {
+        const moves = this.infiniteEffects.map((effect) => this.customMove(CustomMoveType.PlayEffect, effect));
+        const cards = this.material(MaterialType.EntityCard).location(LocationType.PlayerSelectedCards).player(this.player);
+        if (cards.length) {
+            const cardsICanInvoke = new Pantheon(this.game, this.player).gems < 4 ? cards.id((id) => !isGod(id.front)) : cards;
+            for (const { x, y } of new Pantheon(this.game, this.player).legalSpacesToInvoke) {
+                moves.push(...cardsICanInvoke.moveItems({ type: LocationType.Pantheon, x, y, player: this.player }));
+            }
+            moves.push(...cards.moveItems({ type: LocationType.PlayerDiscard, player: this.player }));
+        }
+        else {
+            moves.push(this.customMove(CustomMoveType.Pass));
+        }
+        return moves;
+    }
+    get infiniteEffects() {
+        const pendingRule = this.remind(Memory.PendingRule) ?? this.game.rule;
+        if (pendingRule?.id !== RuleId.PlaceCards || pendingRule.player !== this.player)
+            return [];
+        const pendingEffect = new TriggerEffectsRule(this.game).getPlayerEffects(this.player, { type: TriggerEventType.Infinite });
+        return pendingEffect.filter((pendingEffect) => {
+            const card = this.material(MaterialType.EntityCard).getItem(pendingEffect.cardIndex);
+            const effect = getEffects(card.id.front)[pendingEffect.effectIndex];
+            const canPlayEffect = isTriggeredEffect(effect) && new effect.rule(this.game).canPlayEffect(pendingEffect.cardIndex);
+            return canPlayEffect && this.isOncePerTurnAvailable(pendingEffect.cardIndex);
+        });
+    }
+    isOncePerTurnAvailable(cardIndex) {
+        const oncePerTurnUsed = this.remind(Memory.OncePerTurn) ?? [];
+        return !oncePerTurnUsed.includes(cardIndex);
+    }
+    beforeItemMove(move) {
+        const moves = [];
+        if (isMoveItemType(MaterialType.EntityCard)(move)) {
+            if (this.material(MaterialType.EntityCard).getItem(move.itemIndex).location.type === LocationType.PlayerSelectedCards) {
+                const pantheon = new Pantheon(this.game, this.player);
+                if (move.location.type === LocationType.PlayerDiscard) {
+                    moves.push(pantheon.gainGems(2));
+                }
+                else if (move.location.type === LocationType.Pantheon) {
+                    moves.push(...pantheon.onCardPlaced(move));
+                }
+            }
+        }
+        return moves;
+    }
+    onCustomMove(move) {
+        if (move.type === CustomMoveType.Pass) {
+            return this.onPass();
+        }
+        else if (move.type === CustomMoveType.TrialSuccess) {
+            const { reward } = move.data;
+            return [new Pantheon(this.game, this.player).gainFavor(reward)];
+        }
+        else if (move.type === CustomMoveType.TrialFailure) {
+            this.memorize(Memory.TrialFailure, true, this.player);
+        }
+        else if (move.type === CustomMoveType.PlayEffect) {
+            this.memorize(Memory.PendingRule, this.game.rule);
+            return new ResolveEffectsRule(this.game).playEffect(move.data);
+        }
+        else if (move.type === CustomMoveType.EndEffect) {
+            return new ResolveEffectsRule(this.game).onEndEffect();
+        }
+        return [];
+    }
+    onPass() {
+        const moves = [];
+        const effects = new TriggerEffectsRule(this.game).getPlayerEffects(this.player, { type: TriggerEventType.EndOfTurn, player: this.player });
+        const resolveEffectsRule = new ResolveEffectsRule(this.game);
+        for (const effect of effects) {
+            moves.push(...resolveEffectsRule.playEffect(effect));
+        }
+        moves.push(...new Trial(this.game).passTrials(this.player));
+        moves.push(this.nextRule);
+        return moves;
+    }
+    get nextRule() {
+        if (this.material(MaterialType.EntityCard).location(LocationType.PlayerSelectedCards).length > 0) {
+            return this.startPlayerTurn(RuleId.PlaceCards, this.nextPlayer);
+        }
+        else if (this.round < 4) {
+            return this.startPlayerTurn(RuleId.Upkeep, this.nextPlayer);
+        }
+        else {
+            return this.startPlayerTurn(RuleId.EndGame, this.nextPlayer);
+        }
+    }
+    get round() {
+        return this.material(MaterialType.RoundToken).getItem().location.id;
+    }
+}

package/dist/rules/PlaceTokenRule.d.ts

@@ -1,12 +1,12 @@
-import { ItemMove, MaterialMove, SimultaneousRule } from '@gamepark/rules-api';
-import { EntityItem } from '../material/Entity';
-import { PlayerColor } from '../PlayerColor';
-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): import("@gamepark/rules-api").Material<number, number, number>;
-    afterItemMove(move: ItemMove): import("@gamepark/rules-api").EndPlayerTurn<PlayerColor>[];
-    getMovesAfterPlayersDone(): MaterialMove<number, number, number, number>[];
-    get playersFromFirstPlayer(): number[];
-    getMythologyBoardIndex(item: EntityItem): number;
-}
+import { ItemMove, MaterialMove, SimultaneousRule } from '@gamepark/rules-api';
+import { EntityItem } from '../material/Entity';
+import { PlayerColor } from '../PlayerColor';
+export declare class PlaceTokenRule extends SimultaneousRule {
+    onRuleStart(): MaterialMove[];
+    getActivePlayerLegalMoves(player: PlayerColor): import("@gamepark/rules-api").MoveItem<number, number, number>[];
+    getAvailableCards(player: PlayerColor): import("@gamepark/rules-api").Material<number, number, number>;
+    afterItemMove(move: ItemMove): import("@gamepark/rules-api").EndPlayerTurn<PlayerColor>[];
+    getMovesAfterPlayersDone(): MaterialMove[];
+    get playersFromFirstPlayer(): number[];
+    getMythologyBoardIndex(item: EntityItem): number;
+}