@gamepark/mythologies 0.9.3 → 0.11.0

package/dist/MythologiesSetup.js

@@ -1,161 +1,84 @@
-"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.");
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MythologiesSetup = void 0;
-var rules_api_1 = require("@gamepark/rules-api");
-var lodash_1 = require("lodash");
-var Entity_1 = require("./material/Entity");
-var LocationType_1 = require("./material/LocationType");
-var MaterialType_1 = require("./material/MaterialType");
-var Mythology_1 = require("./material/Mythology");
-var Memory_1 = require("./Memory");
-var MythologiesRules_1 = require("./MythologiesRules");
-var RuleId_1 = require("./rules/RuleId");
-var MythologiesSetup = (function (_super) {
-    __extends(MythologiesSetup, _super);
-    function MythologiesSetup() {
-        var _this = _super !== null && _super.apply(this, arguments) || this;
-        _this.Rules = MythologiesRules_1.MythologiesRules;
-        return _this;
-    }
-    MythologiesSetup.prototype.setupMaterial = function (options) {
-        this.memorize(Memory_1.Memory.PendingEffects, []);
-        this.setupMythologies(this.getMythologies(options));
-        this.setupPlayers();
-        this.dealCreatures();
-        this.material(MaterialType_1.MaterialType.RoundToken).createItem({ location: { type: LocationType_1.LocationType.RoundSpace, id: 1 } });
-        this.createDestinyCards();
-    };
-    MythologiesSetup.prototype.getMythologies = function (options) {
-        var array = Array.isArray(options.mythologies) ? options.mythologies : [];
-        var mythologies = array.filter(function (item) { return typeof item === 'number' && Mythology_1.Mythology[item]; });
-        if (mythologies.length === 4) {
-            return mythologies;
-        }
-        else if (mythologies.length < 4) {
-            return mythologies.concat((0, lodash_1.sampleSize)((0, lodash_1.difference)((0, rules_api_1.getEnumValues)(Mythology_1.Mythology), mythologies), 4 - mythologies.length));
-        }
-        else {
-            return (0, lodash_1.sampleSize)(mythologies, 4);
-        }
-    };
-    MythologiesSetup.prototype.setupMythologies = function (mythologies) {
-        var e_1, _a;
-        this.material(MaterialType_1.MaterialType.MythologyBoard).createItems((0, lodash_1.shuffle)(mythologies).map(function (mythology, index) { return ({
-            id: { mythology: mythology, side: index % 2 },
-            location: {
-                type: LocationType_1.LocationType.Sanctuary,
-                x: index % 2,
-                y: Math.floor(index / 2)
-            }
-        }); }));
-        var _loop_1 = function (mythology) {
-            this_1.material(MaterialType_1.MaterialType.EntityCard).createItems((0, lodash_1.shuffle)((0, lodash_1.range)(1, 5)).map(function (god) { return ({
-                id: { front: mythology * 10 + god, back: { mythology: mythology, entityType: Entity_1.EntityType.Divinity } },
-                location: {
-                    type: LocationType_1.LocationType.GodsDeck,
-                    id: mythology
-                }
-            }); }));
-            this_1.material(MaterialType_1.MaterialType.EntityCard).createItems((0, lodash_1.shuffle)(Array(3).fill((0, lodash_1.range)(5, 11)).flat()).map(function (creature) { return ({
-                id: { front: mythology * 10 + creature, back: { mythology: mythology, entityType: Entity_1.EntityType.Creature } },
-                location: {
-                    type: LocationType_1.LocationType.CreaturesDeck,
-                    id: mythology
-                }
-            }); }));
-        };
-        var this_1 = this;
-        try {
-            for (var mythologies_1 = __values(mythologies), mythologies_1_1 = mythologies_1.next(); !mythologies_1_1.done; mythologies_1_1 = mythologies_1.next()) {
-                var mythology = mythologies_1_1.value;
-                _loop_1(mythology);
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (mythologies_1_1 && !mythologies_1_1.done && (_a = mythologies_1.return)) _a.call(mythologies_1);
-            }
-            finally { if (e_1) throw e_1.error; }
-        }
-    };
-    MythologiesSetup.prototype.setupPlayers = function () {
-        var e_2, _a;
-        var _loop_2 = function (player) {
-            this_2.material(MaterialType_1.MaterialType.DraftToken).createItems((0, lodash_1.shuffle)([true, true, false]).map(function (front) { return ({
-                id: { front: front, back: player },
-                location: { type: LocationType_1.LocationType.PlayerHand, player: player }
-            }); }));
-            this_2.material(MaterialType_1.MaterialType.GemToken).createItems((0, lodash_1.range)(0, 3).map(function (y) { return ({ location: { type: LocationType_1.LocationType.PantheonLineBonus, player: player, y: y } }); }));
-            this_2.material(MaterialType_1.MaterialType.FavorToken).createItems((0, lodash_1.range)(0, 3).map(function (x) { return ({ location: { type: LocationType_1.LocationType.PantheonColumnBonus, player: player, x: x } }); }));
-        };
-        var this_2 = this;
-        try {
-            for (var _b = __values(this.players), _c = _b.next(); !_c.done; _c = _b.next()) {
-                var player = _c.value;
-                _loop_2(player);
-            }
-        }
-        catch (e_2_1) { e_2 = { error: e_2_1 }; }
-        finally {
-            try {
-                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-            }
-            finally { if (e_2) throw e_2.error; }
-        }
-        this.material(MaterialType_1.MaterialType.FirstPlayerToken).createItem({ location: { type: LocationType_1.LocationType.FirstPlayerTokenSpot, player: this.players[0] } });
-    };
-    MythologiesSetup.prototype.dealCreatures = function () {
-        var e_3, _a;
-        var mythologyBoards = this.material(MaterialType_1.MaterialType.MythologyBoard);
-        try {
-            for (var _b = __values(mythologyBoards.getIndexes()), _c = _b.next(); !_c.done; _c = _b.next()) {
-                var index = _c.value;
-                var mythology = mythologyBoards.getItem(index).id.mythology;
-                var deck = this.material(MaterialType_1.MaterialType.EntityCard).location(LocationType_1.LocationType.CreaturesDeck).locationId(mythology).deck();
-                deck.deal({ type: LocationType_1.LocationType.SanctuaryCreatureSpot, parent: index }, 3);
-            }
-        }
-        catch (e_3_1) { e_3 = { error: e_3_1 }; }
-        finally {
-            try {
-                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-            }
-            finally { if (e_3) throw e_3.error; }
-        }
-    };
-    MythologiesSetup.prototype.createDestinyCards = function () {
-        this.material(MaterialType_1.MaterialType.DestinyCard).createItems((0, lodash_1.shuffle)((0, lodash_1.range)(1, 5)).map(function (id) { return ({ id: id, location: { type: LocationType_1.LocationType.DestinyDeck } }); }));
-    };
-    MythologiesSetup.prototype.start = function () {
-        this.startRule(RuleId_1.RuleId.DrawDestinyCard);
-    };
-    return MythologiesSetup;
-}(rules_api_1.MaterialGameSetup));
-exports.MythologiesSetup = MythologiesSetup;
+import { getEnumValues, MaterialGameSetup } from '@gamepark/rules-api';
+import { difference, range, sampleSize, shuffle } from 'es-toolkit';
+import { EntityType } from './material/Entity';
+import { LocationType } from './material/LocationType';
+import { MaterialType } from './material/MaterialType';
+import { Mythology } from './material/Mythology';
+import { Memory } from './Memory';
+import { MythologiesRules } from './MythologiesRules';
+import { RuleId } from './rules/RuleId';
+export class MythologiesSetup extends MaterialGameSetup {
+    Rules = MythologiesRules;
+    setupMaterial(options) {
+        this.memorize(Memory.PendingEffects, []);
+        this.setupMythologies(this.getMythologies(options));
+        this.setupPlayers();
+        this.dealCreatures();
+        this.material(MaterialType.RoundToken).createItem({ location: { type: LocationType.RoundSpace, id: 1 } });
+        this.createDestinyCards();
+    }
+    getMythologies(options) {
+        const array = Array.isArray(options.mythologies) ? options.mythologies : [];
+        const mythologies = array.filter((item) => typeof item === 'number' && Mythology[item]);
+        if (mythologies.length === 4) {
+            return mythologies;
+        }
+        else if (mythologies.length < 4) {
+            return mythologies.concat(sampleSize(difference(getEnumValues(Mythology), mythologies), 4 - mythologies.length));
+        }
+        else {
+            return sampleSize(mythologies, 4);
+        }
+    }
+    setupMythologies(mythologies) {
+        this.material(MaterialType.MythologyBoard).createItems(shuffle(mythologies).map((mythology, index) => ({
+            id: { mythology, side: index % 2 },
+            location: {
+                type: LocationType.Sanctuary,
+                x: index % 2,
+                y: Math.floor(index / 2)
+            }
+        })));
+        for (const mythology of mythologies) {
+            this.material(MaterialType.EntityCard).createItems(shuffle(range(1, 5)).map((god) => ({
+                id: { front: mythology * 10 + god, back: { mythology, entityType: EntityType.Divinity } },
+                location: {
+                    type: LocationType.GodsDeck,
+                    id: mythology
+                }
+            })));
+            this.material(MaterialType.EntityCard).createItems(shuffle(Array(3).fill(range(5, 11)).flat()).map((creature) => ({
+                id: { front: mythology * 10 + creature, back: { mythology, entityType: EntityType.Creature } },
+                location: {
+                    type: LocationType.CreaturesDeck,
+                    id: mythology
+                }
+            })));
+        }
+    }
+    setupPlayers() {
+        for (const player of this.players) {
+            this.material(MaterialType.DraftToken).createItems(shuffle([true, true, false]).map((front) => ({
+                id: { front, back: player },
+                location: { type: LocationType.PlayerHand, player }
+            })));
+            this.material(MaterialType.GemToken).createItems(range(0, 3).map((y) => ({ location: { type: LocationType.PantheonLineBonus, player, y } })));
+            this.material(MaterialType.FavorToken).createItems(range(0, 3).map((x) => ({ location: { type: LocationType.PantheonColumnBonus, player, x } })));
+        }
+        this.material(MaterialType.FirstPlayerToken).createItem({ location: { type: LocationType.FirstPlayerTokenSpot, player: this.players[0] } });
+    }
+    dealCreatures() {
+        const mythologyBoards = this.material(MaterialType.MythologyBoard);
+        for (const index of mythologyBoards.getIndexes()) {
+            const mythology = mythologyBoards.getItem(index).id.mythology;
+            const deck = this.material(MaterialType.EntityCard).location(LocationType.CreaturesDeck).locationId(mythology).deck();
+            deck.deal({ type: LocationType.SanctuaryCreatureSpot, parent: index }, 3);
+        }
+    }
+    createDestinyCards() {
+        this.material(MaterialType.DestinyCard).createItems(shuffle(range(1, 5)).map((id) => ({ id, location: { type: LocationType.DestinyDeck } })));
+    }
+    start() {
+        this.startRule(RuleId.DrawDestinyCard);
+    }
+}

package/dist/PlayerColor.d.ts

@@ -1,10 +1,10 @@
-export declare enum PlayerColor {
-    Green = 1,
-    Red = 2,
-    Blue = 3,
-    Grey = 4
-}
-export type DraftTokenId = {
-    front?: boolean;
-    back: PlayerColor;
-};
+export declare enum PlayerColor {
+    Green = 1,
+    Red = 2,
+    Blue = 3,
+    Grey = 4
+}
+export type DraftTokenId = {
+    front?: boolean;
+    back: PlayerColor;
+};

package/dist/PlayerColor.js

@@ -1,10 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PlayerColor = void 0;
-var PlayerColor;
-(function (PlayerColor) {
-    PlayerColor[PlayerColor["Green"] = 1] = "Green";
-    PlayerColor[PlayerColor["Red"] = 2] = "Red";
-    PlayerColor[PlayerColor["Blue"] = 3] = "Blue";
-    PlayerColor[PlayerColor["Grey"] = 4] = "Grey";
-})(PlayerColor = exports.PlayerColor || (exports.PlayerColor = {}));
+export var PlayerColor;
+(function (PlayerColor) {
+    PlayerColor[PlayerColor["Green"] = 1] = "Green";
+    PlayerColor[PlayerColor["Red"] = 2] = "Red";
+    PlayerColor[PlayerColor["Blue"] = 3] = "Blue";
+    PlayerColor[PlayerColor["Grey"] = 4] = "Grey";
+})(PlayerColor || (PlayerColor = {}));

package/dist/index.d.ts

@@ -1,3 +1,3 @@
-export { MythologiesRules } from './MythologiesRules';
-export { MythologiesOptionsSpec } from './MythologiesOptions';
-export { MythologiesSetup } from './MythologiesSetup';
+export { MythologiesRules } from './MythologiesRules';
+export { MythologiesOptionsSpec } from './MythologiesOptions';
+export { MythologiesSetup } from './MythologiesSetup';

package/dist/index.js

@@ -1,9 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MythologiesSetup = exports.MythologiesOptionsSpec = exports.MythologiesRules = void 0;
-var MythologiesRules_1 = require("./MythologiesRules");
-Object.defineProperty(exports, "MythologiesRules", { enumerable: true, get: function () { return MythologiesRules_1.MythologiesRules; } });
-var MythologiesOptions_1 = require("./MythologiesOptions");
-Object.defineProperty(exports, "MythologiesOptionsSpec", { enumerable: true, get: function () { return MythologiesOptions_1.MythologiesOptionsSpec; } });
-var MythologiesSetup_1 = require("./MythologiesSetup");
-Object.defineProperty(exports, "MythologiesSetup", { enumerable: true, get: function () { return MythologiesSetup_1.MythologiesSetup; } });
+export { MythologiesRules } from './MythologiesRules';
+export { MythologiesOptionsSpec } from './MythologiesOptions';
+export { MythologiesSetup } from './MythologiesSetup';

package/dist/material/Destiny.d.ts

@@ -1,15 +1,15 @@
-import { MaterialRulesPart } from '@gamepark/rules-api';
-import { PlayerColor } from '../PlayerColor';
-import { Mythology } from './Mythology';
-export declare class Destiny extends MaterialRulesPart {
-    get mythologies(): Mythology[];
-    getMythologyBoard(player: PlayerColor): import("@gamepark/rules-api").Material<number, number, number>;
-    getMythology(player: PlayerColor): Mythology;
-    getDestinyMap(destiny: number): PlayerColor[][];
-    get cardsWithoutToken(): import("@gamepark/rules-api").Material<number, number, number>;
-    getAvailableCards(player: PlayerColor): import("@gamepark/rules-api").Material<number, number, number>;
-    getAvailableCardsOnBoard(player: PlayerColor): import("@gamepark/rules-api").Material<number, number, number>;
-    getTopDeckCreature(mythology: Mythology): import("@gamepark/rules-api").MaterialDeck<number, number, number>;
-    getBoardsWithoutPlayer(): import("@gamepark/rules-api").Material<number, number, number>;
-    get creaturesOnTopOfDecks(): import("@gamepark/rules-api").Material<number, number, number>;
-}
+import { MaterialRulesPart } from '@gamepark/rules-api';
+import { PlayerColor } from '../PlayerColor';
+import { Mythology } from './Mythology';
+export declare class Destiny extends MaterialRulesPart {
+    get mythologies(): Mythology[];
+    getMythologyBoard(player: PlayerColor): import("@gamepark/rules-api").Material<number, number, number>;
+    getMythology(player: PlayerColor): Mythology;
+    getDestinyMap(destiny: number): PlayerColor[][];
+    get cardsWithoutToken(): import("@gamepark/rules-api").Material<number, number, number>;
+    getAvailableCards(player: PlayerColor): import("@gamepark/rules-api").Material<number, number, number>;
+    getAvailableCardsOnBoard(player: PlayerColor): import("@gamepark/rules-api").Material<number, number, number>;
+    getTopDeckCreature(mythology: Mythology): import("@gamepark/rules-api").MaterialDeck<number, number, number>;
+    getBoardsWithoutPlayer(): import("@gamepark/rules-api").Material<number, number, number>;
+    get creaturesOnTopOfDecks(): import("@gamepark/rules-api").Material<number, number, number>;
+}

package/dist/material/Destiny.js

@@ -1,130 +1,91 @@
-"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.Destiny = void 0;
-var rules_api_1 = require("@gamepark/rules-api");
-var PlayerColor_1 = require("../PlayerColor");
-var Entity_1 = require("./Entity");
-var LocationType_1 = require("./LocationType");
-var MaterialType_1 = require("./MaterialType");
-var Destiny = (function (_super) {
-    __extends(Destiny, _super);
-    function Destiny() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    Object.defineProperty(Destiny.prototype, "mythologies", {
-        get: function () {
-            return this.material(MaterialType_1.MaterialType.MythologyBoard)
-                .getItems()
-                .map(function (item) { return item.id.mythology; });
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Destiny.prototype.getMythologyBoard = function (player) {
-        var destiny = this.material(MaterialType_1.MaterialType.DestinyCard)
-            .location(LocationType_1.LocationType.CurrentDestiny)
-            .maxBy(function (item) { return item.location.x; })
-            .getItem().id;
-        var map = this.getDestinyMap(destiny);
-        var y = map.findIndex(function (line) { return line.includes(player); });
-        var x = map[y].indexOf(player);
-        return this.material(MaterialType_1.MaterialType.MythologyBoard).location(function (location) { return location.x === x && location.y === y; });
-    };
-    Destiny.prototype.getMythology = function (player) {
-        return this.getMythologyBoard(player).getItem().id.mythology;
-    };
-    Destiny.prototype.getDestinyMap = function (destiny) {
-        switch (destiny) {
-            case 1:
-                return [
-                    [PlayerColor_1.PlayerColor.Blue, PlayerColor_1.PlayerColor.Green],
-                    [PlayerColor_1.PlayerColor.Grey, PlayerColor_1.PlayerColor.Red]
-                ];
-            case 2:
-                return [
-                    [PlayerColor_1.PlayerColor.Red, PlayerColor_1.PlayerColor.Blue],
-                    [PlayerColor_1.PlayerColor.Green, PlayerColor_1.PlayerColor.Grey]
-                ];
-            case 3:
-                return [
-                    [PlayerColor_1.PlayerColor.Green, PlayerColor_1.PlayerColor.Grey],
-                    [PlayerColor_1.PlayerColor.Red, PlayerColor_1.PlayerColor.Blue]
-                ];
-            case 4:
-                return [
-                    [PlayerColor_1.PlayerColor.Grey, PlayerColor_1.PlayerColor.Red],
-                    [PlayerColor_1.PlayerColor.Blue, PlayerColor_1.PlayerColor.Green]
-                ];
-            default:
-                throw new Error("Unknown destiny card: ".concat(destiny));
-        }
-    };
-    Object.defineProperty(Destiny.prototype, "cardsWithoutToken", {
-        get: function () {
-            var tokensOnCards = this.material(MaterialType_1.MaterialType.DraftToken).location(LocationType_1.LocationType.OnEntityCard).getItems();
-            var cardsWithToken = tokensOnCards.map(function (item) { return item.location.parent; });
-            return this.material(MaterialType_1.MaterialType.EntityCard).index(function (index) { return !cardsWithToken.includes(index); });
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Destiny.prototype.getAvailableCards = function (player) {
-        var entities = this.getAvailableCardsOnBoard(player);
-        if (entities.getItems().some(function (item) { return (0, Entity_1.isCreature)(item.id.front); })) {
-            return entities;
-        }
-        var topDeckCreature = this.getTopDeckCreature(this.getMythology(player));
-        var indexes = entities.getIndexes().concat(topDeckCreature.getIndex());
-        return this.material(MaterialType_1.MaterialType.EntityCard).index(indexes);
-    };
-    Destiny.prototype.getAvailableCardsOnBoard = function (player) {
-        var boardCards = this.cardsWithoutToken.location(function (l) { return l.type === LocationType_1.LocationType.SanctuaryGodSpot || l.type === LocationType_1.LocationType.SanctuaryCreatureSpot; });
-        return boardCards.parent(this.getMythologyBoard(player).getIndex());
-    };
-    Destiny.prototype.getTopDeckCreature = function (mythology) {
-        return this.material(MaterialType_1.MaterialType.EntityCard).location(LocationType_1.LocationType.CreaturesDeck).locationId(mythology).deck();
-    };
-    Destiny.prototype.getBoardsWithoutPlayer = function () {
-        var _this = this;
-        var destiny = this.material(MaterialType_1.MaterialType.DestinyCard)
-            .location(LocationType_1.LocationType.CurrentDestiny)
-            .maxBy(function (item) { return item.location.x; })
-            .getItem().id;
-        var map = this.getDestinyMap(destiny);
-        return this.material(MaterialType_1.MaterialType.MythologyBoard).location(function (l) { return !_this.game.players.includes(map[l.y][l.x]); });
-    };
-    Object.defineProperty(Destiny.prototype, "creaturesOnTopOfDecks", {
-        get: function () {
-            var mythologies = this.material(MaterialType_1.MaterialType.MythologyBoard)
-                .getItems()
-                .map(function (item) { return item.id.mythology; });
-            var creaturesInDecks = this.material(MaterialType_1.MaterialType.EntityCard).location(LocationType_1.LocationType.CreaturesDeck);
-            var creaturesIndexes = mythologies.map(function (mythology) {
-                return creaturesInDecks
-                    .locationId(mythology)
-                    .maxBy(function (item) { return item.location.x; })
-                    .getIndex();
-            });
-            return this.material(MaterialType_1.MaterialType.EntityCard).index(creaturesIndexes);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    return Destiny;
-}(rules_api_1.MaterialRulesPart));
-exports.Destiny = Destiny;
+import { MaterialRulesPart } from '@gamepark/rules-api';
+import { PlayerColor } from '../PlayerColor';
+import { isCreature } from './Entity';
+import { LocationType } from './LocationType';
+import { MaterialType } from './MaterialType';
+export class Destiny extends MaterialRulesPart {
+    get mythologies() {
+        return this.material(MaterialType.MythologyBoard)
+            .getItems()
+            .map((item) => item.id.mythology);
+    }
+    getMythologyBoard(player) {
+        const destiny = this.material(MaterialType.DestinyCard)
+            .location(LocationType.CurrentDestiny)
+            .maxBy((item) => item.location.x)
+            .getItem().id;
+        const map = this.getDestinyMap(destiny);
+        const y = map.findIndex((line) => line.includes(player));
+        const x = map[y].indexOf(player);
+        return this.material(MaterialType.MythologyBoard).location((location) => location.x === x && location.y === y);
+    }
+    getMythology(player) {
+        return this.getMythologyBoard(player).getItem().id.mythology;
+    }
+    getDestinyMap(destiny) {
+        switch (destiny) {
+            case 1:
+                return [
+                    [PlayerColor.Blue, PlayerColor.Green],
+                    [PlayerColor.Grey, PlayerColor.Red]
+                ];
+            case 2:
+                return [
+                    [PlayerColor.Red, PlayerColor.Blue],
+                    [PlayerColor.Green, PlayerColor.Grey]
+                ];
+            case 3:
+                return [
+                    [PlayerColor.Green, PlayerColor.Grey],
+                    [PlayerColor.Red, PlayerColor.Blue]
+                ];
+            case 4:
+                return [
+                    [PlayerColor.Grey, PlayerColor.Red],
+                    [PlayerColor.Blue, PlayerColor.Green]
+                ];
+            default:
+                throw new Error(`Unknown destiny card: ${destiny}`);
+        }
+    }
+    get cardsWithoutToken() {
+        const tokensOnCards = this.material(MaterialType.DraftToken).location(LocationType.OnEntityCard).getItems();
+        const cardsWithToken = tokensOnCards.map((item) => item.location.parent);
+        return this.material(MaterialType.EntityCard).index((index) => !cardsWithToken.includes(index));
+    }
+    getAvailableCards(player) {
+        const entities = this.getAvailableCardsOnBoard(player);
+        if (entities.getItems().some((item) => isCreature(item.id.front))) {
+            return entities;
+        }
+        const topDeckCreature = this.getTopDeckCreature(this.getMythology(player));
+        const indexes = entities.getIndexes().concat(topDeckCreature.getIndex());
+        return this.material(MaterialType.EntityCard).index(indexes);
+    }
+    getAvailableCardsOnBoard(player) {
+        const boardCards = this.cardsWithoutToken.location((l) => l.type === LocationType.SanctuaryGodSpot || l.type === LocationType.SanctuaryCreatureSpot);
+        return boardCards.parent(this.getMythologyBoard(player).getIndex());
+    }
+    getTopDeckCreature(mythology) {
+        return this.material(MaterialType.EntityCard).location(LocationType.CreaturesDeck).locationId(mythology).deck();
+    }
+    getBoardsWithoutPlayer() {
+        const destiny = this.material(MaterialType.DestinyCard)
+            .location(LocationType.CurrentDestiny)
+            .maxBy((item) => item.location.x)
+            .getItem().id;
+        const map = this.getDestinyMap(destiny);
+        return this.material(MaterialType.MythologyBoard).location((l) => !this.game.players.includes(map[l.y][l.x]));
+    }
+    get creaturesOnTopOfDecks() {
+        const mythologies = this.material(MaterialType.MythologyBoard)
+            .getItems()
+            .map((item) => item.id.mythology);
+        const creaturesInDecks = this.material(MaterialType.EntityCard).location(LocationType.CreaturesDeck);
+        const creaturesIndexes = mythologies.map((mythology) => creaturesInDecks
+            .locationId(mythology)
+            .maxBy((item) => item.location.x)
+            .getIndex());
+        return this.material(MaterialType.EntityCard).index(creaturesIndexes);
+    }
+}