@gamepark/mythologies 0.1.0

package/dist/CustomMoveType.d.ts

@@ -0,0 +1,13 @@
+export declare enum CustomMoveType {
+    Pass = 1,
+    TrialSuccess = 2,
+    TrialFailure = 3,
+    PlayEffect = 4,
+    EndEffect = 5,
+    ChoosePlayer = 6,
+    ChooseMythology = 7
+}
+export type TrialSuccessData = {
+    trial: number;
+    reward: number;
+};

package/dist/CustomMoveType.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomMoveType = void 0;
+var CustomMoveType;
+(function (CustomMoveType) {
+    CustomMoveType[CustomMoveType["Pass"] = 1] = "Pass";
+    CustomMoveType[CustomMoveType["TrialSuccess"] = 2] = "TrialSuccess";
+    CustomMoveType[CustomMoveType["TrialFailure"] = 3] = "TrialFailure";
+    CustomMoveType[CustomMoveType["PlayEffect"] = 4] = "PlayEffect";
+    CustomMoveType[CustomMoveType["EndEffect"] = 5] = "EndEffect";
+    CustomMoveType[CustomMoveType["ChoosePlayer"] = 6] = "ChoosePlayer";
+    CustomMoveType[CustomMoveType["ChooseMythology"] = 7] = "ChooseMythology";
+})(CustomMoveType = exports.CustomMoveType || (exports.CustomMoveType = {}));

package/dist/Memory.d.ts

@@ -0,0 +1,13 @@
+export declare enum Memory {
+    KeepTokenPlaceSecret = 1,
+    TrialFailure = 2,
+    PendingEffects = 3,
+    PendingRule = 4,
+    OngoingEffect = 5,
+    OncePerTurn = 6,
+    OdinTargetMythology = 10,
+    FenrirPaid1 = 11,
+    AnubisInvoke1 = 12,
+    GarudaSacrificeCount = 13,
+    VetalaCount = 14
+}

package/dist/Memory.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Memory = void 0;
+var Memory;
+(function (Memory) {
+    Memory[Memory["KeepTokenPlaceSecret"] = 1] = "KeepTokenPlaceSecret";
+    Memory[Memory["TrialFailure"] = 2] = "TrialFailure";
+    Memory[Memory["PendingEffects"] = 3] = "PendingEffects";
+    Memory[Memory["PendingRule"] = 4] = "PendingRule";
+    Memory[Memory["OngoingEffect"] = 5] = "OngoingEffect";
+    Memory[Memory["OncePerTurn"] = 6] = "OncePerTurn";
+    Memory[Memory["OdinTargetMythology"] = 10] = "OdinTargetMythology";
+    Memory[Memory["FenrirPaid1"] = 11] = "FenrirPaid1";
+    Memory[Memory["AnubisInvoke1"] = 12] = "AnubisInvoke1";
+    Memory[Memory["GarudaSacrificeCount"] = 13] = "GarudaSacrificeCount";
+    Memory[Memory["VetalaCount"] = 14] = "VetalaCount";
+})(Memory = exports.Memory || (exports.Memory = {}));

package/dist/MythologiesOptions.d.ts

@@ -0,0 +1,12 @@
+import { OptionsSpec } from '@gamepark/rules-api';
+import { Mythology } from './material/Mythology';
+import { PlayerColor } from './PlayerColor';
+type PlayerOptions = {
+    id: PlayerColor;
+};
+export type MythologiesOptions = {
+    players: PlayerOptions[];
+    mythologies?: Mythology[];
+};
+export declare const MythologiesOptionsSpec: OptionsSpec<MythologiesOptions>;
+export {};

package/dist/MythologiesOptions.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MythologiesOptionsSpec = void 0;
+var rules_api_1 = require("@gamepark/rules-api");
+var PlayerColor_1 = require("./PlayerColor");
+exports.MythologiesOptionsSpec = {
+    players: {
+        id: {
+            label: function (t) { return t('player.id'); },
+            values: (0, rules_api_1.getEnumValues)(PlayerColor_1.PlayerColor),
+            valueSpec: function (id) { return ({ label: function (t) { return t("player.".concat(id)); } }); }
+        }
+    }
+};

package/dist/MythologiesRules.d.ts

@@ -0,0 +1,111 @@
+import { CustomMove, FillGapStrategy, ItemMove, Material, MaterialGame, MaterialItem, MaterialMove, PositiveSequenceStrategy, SecretMaterialRules, StackingStrategy, TimeLimit } from '@gamepark/rules-api';
+import { LocationType } from './material/LocationType';
+import { MaterialType } from './material/MaterialType';
+import { PlayerColor } from './PlayerColor';
+import { ChooseDraftTokenRule } from './rules/ChooseDraftTokenRule';
+import { DrawDestinyCardRule } from './rules/DrawDestinyCardRule';
+import { AlfEffectRule } from './rules/effects/AlfEffectRule';
+import { AnubisEffectRule } from './rules/effects/AnubisEffectRule';
+import { AthenaEffectRule } from './rules/effects/AthenaEffectRule';
+import { BabaiEffectRule } from './rules/effects/BabaiEffectRule';
+import { BennuEffectRule } from './rules/effects/BennuEffectRule';
+import { CentaurEffectRule, CentaurEffectSacrificeRule } from './rules/effects/CentaurEffectRule';
+import { ChimeraEffectRule } from './rules/effects/ChimeraEffectRule';
+import { CobraEffectRule, CobraInvokeEffect } from './rules/effects/CobraEffectRule';
+import { CyclopsEffectRule } from './rules/effects/CyclopsEffectRule';
+import { DraugrEffectRule } from './rules/effects/DraugrEffectRule';
+import { FenrirChoiceRule, FenrirEffectRule } from './rules/effects/FenrirEffectRule';
+import { GarudaEffectRule } from './rules/effects/GarudaEffectRule';
+import { GorgonEffectRule } from './rules/effects/GorgonEffectRule';
+import { GriffinEffectRule } from './rules/effects/GriffinEffectRule';
+import { HadesEffectRule } from './rules/effects/HadesEffectRule';
+import { KinnaraEffectRule, KinnaraPlaceEffectRule } from './rules/effects/KinnaraEffectRule';
+import { MinotaurEffectRule } from './rules/effects/MinotaurEffectRule';
+import { OdinEffectRule } from './rules/effects/OdinEffectRule';
+import { RakshasaEffectRule } from './rules/effects/RakshasaEffectRule';
+import { ResolveEffectsRule } from './rules/effects/ResolveEffectsRule';
+import { ShivaEffectRule } from './rules/effects/ShivaEffectRule';
+import { SphinxEffectRule } from './rules/effects/SphinxEffectRule';
+import { ThorEffectRule } from './rules/effects/ThorEffectRule';
+import { VetalaEffectRule } from './rules/effects/VetalaEffectRule';
+import { EndGameRule } from './rules/EndGameRule';
+import { PlaceCardsRule } from './rules/PlaceCardsRule';
+import { PlaceTokenRule } from './rules/PlaceTokenRule';
+import { RuleId } from './rules/RuleId';
+import { UpkeepRule } from './rules/UpkeepRule';
+export declare class MythologiesRules extends SecretMaterialRules<PlayerColor, MaterialType, LocationType> implements TimeLimit<MaterialGame<PlayerColor, MaterialType, LocationType>, MaterialMove<PlayerColor, MaterialType, LocationType>, PlayerColor> {
+    rules: {
+        1: typeof DrawDestinyCardRule;
+        2: typeof ChooseDraftTokenRule;
+        3: typeof PlaceTokenRule;
+        4: typeof PlaceCardsRule;
+        5: typeof UpkeepRule;
+        6: typeof EndGameRule;
+        10: typeof ResolveEffectsRule;
+        11: typeof AthenaEffectRule;
+        12: typeof HadesEffectRule;
+        13: typeof MinotaurEffectRule;
+        14: typeof CentaurEffectRule;
+        15: typeof CentaurEffectSacrificeRule;
+        16: typeof GorgonEffectRule;
+        17: typeof CyclopsEffectRule;
+        18: typeof GriffinEffectRule;
+        19: typeof ChimeraEffectRule;
+        20: typeof OdinEffectRule;
+        21: typeof ThorEffectRule;
+        22: typeof DraugrEffectRule;
+        23: typeof FenrirChoiceRule;
+        24: typeof FenrirEffectRule;
+        25: typeof AlfEffectRule;
+        26: typeof AnubisEffectRule;
+        27: typeof SphinxEffectRule;
+        28: typeof CobraEffectRule;
+        29: typeof CobraInvokeEffect;
+        30: typeof BabaiEffectRule;
+        31: typeof BennuEffectRule;
+        32: typeof ShivaEffectRule;
+        33: typeof RakshasaEffectRule;
+        34: typeof GarudaEffectRule;
+        35: typeof VetalaEffectRule;
+        36: typeof KinnaraEffectRule;
+        37: typeof KinnaraPlaceEffectRule;
+    };
+    locationsStrategies: {
+        2: {
+            2: PositiveSequenceStrategy<number, number, number>;
+            3: PositiveSequenceStrategy<number, number, number>;
+            6: FillGapStrategy<number, number, number>;
+            19: StackingStrategy;
+            22: PositiveSequenceStrategy<number, number, number>;
+        };
+        4: {
+            5: PositiveSequenceStrategy<number, number, number>;
+        };
+        10: {
+            15: PositiveSequenceStrategy<number, number, number>;
+            16: PositiveSequenceStrategy<number, number, number>;
+        };
+    };
+    hidingStrategies: {
+        2: {
+            2: import("@gamepark/rules-api").HidingStrategy<number, number>;
+            3: (item: MaterialItem) => string[];
+            7: (item: MaterialItem, player?: PlayerColor) => string[];
+            6: (item: MaterialItem, player?: PlayerColor) => string[];
+        };
+        4: {
+            5: import("@gamepark/rules-api").HidingStrategy<number, number>;
+            17: (item: MaterialItem) => string[];
+        };
+        10: {
+            15: import("@gamepark/rules-api").HidingStrategy<number, number>;
+        };
+    };
+    keepMoveSecret(move: MaterialMove): boolean;
+    beforeItemMove(move: ItemMove): MaterialMove<number, number, number, number>[];
+    onEntitySacrificed(card: Material): void;
+    protected onCustomMove(move: CustomMove): import("@gamepark/rules-api").EndGame[] | import("@gamepark/rules-api").StartPlayerTurn<PlayerColor, RuleId.ResolveEffects>[] | (import("@gamepark/rules-api").StartPlayerTurn<number, RuleId.PlaceCards> | import("@gamepark/rules-api").StartRule<RuleId.PlaceCards>)[];
+    getAutomaticMoves(): import("@gamepark/rules-api").StartPlayerTurn<PlayerColor, RuleId.ResolveEffects>[];
+    startEffectsResolution(): import("@gamepark/rules-api").StartPlayerTurn<PlayerColor, RuleId.ResolveEffects>[];
+    giveTime(): number;
+}

package/dist/MythologiesRules.js

@@ -0,0 +1,218 @@
+"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.MythologiesRules = void 0;
+var rules_api_1 = require("@gamepark/rules-api");
+var CustomMoveType_1 = require("./CustomMoveType");
+var Effect_1 = require("./material/entity/Effect");
+var LocationType_1 = require("./material/LocationType");
+var MaterialType_1 = require("./material/MaterialType");
+var Pantheon_1 = require("./material/Pantheon");
+var Memory_1 = require("./Memory");
+var ChooseDraftTokenRule_1 = require("./rules/ChooseDraftTokenRule");
+var DrawDestinyCardRule_1 = require("./rules/DrawDestinyCardRule");
+var AlfEffectRule_1 = require("./rules/effects/AlfEffectRule");
+var AnubisEffectRule_1 = require("./rules/effects/AnubisEffectRule");
+var AthenaEffectRule_1 = require("./rules/effects/AthenaEffectRule");
+var BabaiEffectRule_1 = require("./rules/effects/BabaiEffectRule");
+var BennuEffectRule_1 = require("./rules/effects/BennuEffectRule");
+var CentaurEffectRule_1 = require("./rules/effects/CentaurEffectRule");
+var ChimeraEffectRule_1 = require("./rules/effects/ChimeraEffectRule");
+var CobraEffectRule_1 = require("./rules/effects/CobraEffectRule");
+var CyclopsEffectRule_1 = require("./rules/effects/CyclopsEffectRule");
+var DraugrEffectRule_1 = require("./rules/effects/DraugrEffectRule");
+var FenrirEffectRule_1 = require("./rules/effects/FenrirEffectRule");
+var GarudaEffectRule_1 = require("./rules/effects/GarudaEffectRule");
+var GorgonEffectRule_1 = require("./rules/effects/GorgonEffectRule");
+var GriffinEffectRule_1 = require("./rules/effects/GriffinEffectRule");
+var HadesEffectRule_1 = require("./rules/effects/HadesEffectRule");
+var KinnaraEffectRule_1 = require("./rules/effects/KinnaraEffectRule");
+var MinotaurEffectRule_1 = require("./rules/effects/MinotaurEffectRule");
+var OdinEffectRule_1 = require("./rules/effects/OdinEffectRule");
+var RakshasaEffectRule_1 = require("./rules/effects/RakshasaEffectRule");
+var ResolveEffectsRule_1 = require("./rules/effects/ResolveEffectsRule");
+var ShivaEffectRule_1 = require("./rules/effects/ShivaEffectRule");
+var SphinxEffectRule_1 = require("./rules/effects/SphinxEffectRule");
+var ThorEffectRule_1 = require("./rules/effects/ThorEffectRule");
+var TriggerEffectsRule_1 = require("./rules/effects/TriggerEffectsRule");
+var VetalaEffectRule_1 = require("./rules/effects/VetalaEffectRule");
+var EndGameRule_1 = require("./rules/EndGameRule");
+var PlaceCardsRule_1 = require("./rules/PlaceCardsRule");
+var PlaceTokenRule_1 = require("./rules/PlaceTokenRule");
+var RuleId_1 = require("./rules/RuleId");
+var UpkeepRule_1 = require("./rules/UpkeepRule");
+var MythologiesRules = (function (_super) {
+    __extends(MythologiesRules, _super);
+    function MythologiesRules() {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.rules = (_a = {},
+            _a[RuleId_1.RuleId.DrawDestinyCard] = DrawDestinyCardRule_1.DrawDestinyCardRule,
+            _a[RuleId_1.RuleId.ChooseDraftToken] = ChooseDraftTokenRule_1.ChooseDraftTokenRule,
+            _a[RuleId_1.RuleId.PlaceToken] = PlaceTokenRule_1.PlaceTokenRule,
+            _a[RuleId_1.RuleId.PlaceCards] = PlaceCardsRule_1.PlaceCardsRule,
+            _a[RuleId_1.RuleId.Upkeep] = UpkeepRule_1.UpkeepRule,
+            _a[RuleId_1.RuleId.EndGame] = EndGameRule_1.EndGameRule,
+            _a[RuleId_1.RuleId.ResolveEffects] = ResolveEffectsRule_1.ResolveEffectsRule,
+            _a[RuleId_1.RuleId.AthenaEffect] = AthenaEffectRule_1.AthenaEffectRule,
+            _a[RuleId_1.RuleId.HadesEffect] = HadesEffectRule_1.HadesEffectRule,
+            _a[RuleId_1.RuleId.MinotaurEffect] = MinotaurEffectRule_1.MinotaurEffectRule,
+            _a[RuleId_1.RuleId.CentaurEffect] = CentaurEffectRule_1.CentaurEffectRule,
+            _a[RuleId_1.RuleId.CentaurEffectSacrifice] = CentaurEffectRule_1.CentaurEffectSacrificeRule,
+            _a[RuleId_1.RuleId.GorgonEffect] = GorgonEffectRule_1.GorgonEffectRule,
+            _a[RuleId_1.RuleId.CyclopsEffect] = CyclopsEffectRule_1.CyclopsEffectRule,
+            _a[RuleId_1.RuleId.GriffinEffect] = GriffinEffectRule_1.GriffinEffectRule,
+            _a[RuleId_1.RuleId.ChimeraEffect] = ChimeraEffectRule_1.ChimeraEffectRule,
+            _a[RuleId_1.RuleId.OdinEffect] = OdinEffectRule_1.OdinEffectRule,
+            _a[RuleId_1.RuleId.ThorEffect] = ThorEffectRule_1.ThorEffectRule,
+            _a[RuleId_1.RuleId.DraugrEffect] = DraugrEffectRule_1.DraugrEffectRule,
+            _a[RuleId_1.RuleId.FenrirChoice] = FenrirEffectRule_1.FenrirChoiceRule,
+            _a[RuleId_1.RuleId.FenrirEffect] = FenrirEffectRule_1.FenrirEffectRule,
+            _a[RuleId_1.RuleId.AlfEffect] = AlfEffectRule_1.AlfEffectRule,
+            _a[RuleId_1.RuleId.AnubisEffect] = AnubisEffectRule_1.AnubisEffectRule,
+            _a[RuleId_1.RuleId.SphinxEffect] = SphinxEffectRule_1.SphinxEffectRule,
+            _a[RuleId_1.RuleId.CobraEffect] = CobraEffectRule_1.CobraEffectRule,
+            _a[RuleId_1.RuleId.CobraInvokeEffect] = CobraEffectRule_1.CobraInvokeEffect,
+            _a[RuleId_1.RuleId.BabaiEffect] = BabaiEffectRule_1.BabaiEffectRule,
+            _a[RuleId_1.RuleId.BennuEffect] = BennuEffectRule_1.BennuEffectRule,
+            _a[RuleId_1.RuleId.ShivaEffect] = ShivaEffectRule_1.ShivaEffectRule,
+            _a[RuleId_1.RuleId.RakshasaEffect] = RakshasaEffectRule_1.RakshasaEffectRule,
+            _a[RuleId_1.RuleId.GarudaEffect] = GarudaEffectRule_1.GarudaEffectRule,
+            _a[RuleId_1.RuleId.VetalaEffect] = VetalaEffectRule_1.VetalaEffectRule,
+            _a[RuleId_1.RuleId.KinnaraEffect] = KinnaraEffectRule_1.KinnaraEffectRule,
+            _a[RuleId_1.RuleId.KinnaraPlaceEffect] = KinnaraEffectRule_1.KinnaraPlaceEffectRule,
+            _a);
+        _this.locationsStrategies = (_b = {},
+            _b[MaterialType_1.MaterialType.EntityCard] = (_c = {},
+                _c[LocationType_1.LocationType.GodsDeck] = new rules_api_1.PositiveSequenceStrategy(),
+                _c[LocationType_1.LocationType.CreaturesDeck] = new rules_api_1.PositiveSequenceStrategy(),
+                _c[LocationType_1.LocationType.SanctuaryCreatureSpot] = new rules_api_1.FillGapStrategy(),
+                _c[LocationType_1.LocationType.Pantheon] = new rules_api_1.StackingStrategy(),
+                _c[LocationType_1.LocationType.PlayerDiscard] = new rules_api_1.PositiveSequenceStrategy(),
+                _c),
+            _b[MaterialType_1.MaterialType.DraftToken] = (_d = {},
+                _d[LocationType_1.LocationType.PlayerHand] = new rules_api_1.PositiveSequenceStrategy(),
+                _d),
+            _b[MaterialType_1.MaterialType.DestinyCard] = (_e = {},
+                _e[LocationType_1.LocationType.DestinyDeck] = new rules_api_1.PositiveSequenceStrategy(),
+                _e[LocationType_1.LocationType.CurrentDestiny] = new rules_api_1.PositiveSequenceStrategy(),
+                _e),
+            _b);
+        _this.hidingStrategies = (_f = {},
+            _f[MaterialType_1.MaterialType.EntityCard] = (_g = {},
+                _g[LocationType_1.LocationType.GodsDeck] = rules_api_1.hideFront,
+                _g[LocationType_1.LocationType.CreaturesDeck] = function (item) { return (item.location.rotation ? [] : ['id.front']); },
+                _g[LocationType_1.LocationType.SanctuaryGodSpot] = function (item, player) { var _a; return (((_a = item.location.rotation) !== null && _a !== void 0 ? _a : player) === player ? [] : ['id.front']); },
+                _g[LocationType_1.LocationType.SanctuaryCreatureSpot] = function (item, player) { var _a; return (((_a = item.location.rotation) !== null && _a !== void 0 ? _a : player) === player ? [] : ['id.front']); },
+                _g),
+            _f[MaterialType_1.MaterialType.DraftToken] = (_h = {},
+                _h[LocationType_1.LocationType.PlayerHand] = rules_api_1.hideFrontToOthers,
+                _h[LocationType_1.LocationType.PlayedTokenSpot] = function (item) { return (item.location.rotation ? ['id.front'] : []); },
+                _h),
+            _f[MaterialType_1.MaterialType.DestinyCard] = (_j = {},
+                _j[LocationType_1.LocationType.DestinyDeck] = rules_api_1.hideItemId,
+                _j),
+            _f);
+        return _this;
+    }
+    MythologiesRules.prototype.keepMoveSecret = function (move) {
+        return ((0, rules_api_1.isMoveItemType)(MaterialType_1.MaterialType.DraftToken)(move) &&
+            this.remind(Memory_1.Memory.KeepTokenPlaceSecret, this.material(MaterialType_1.MaterialType.DraftToken).getItem(move.itemIndex).id.back) === true);
+    };
+    MythologiesRules.prototype.beforeItemMove = function (move) {
+        var _a;
+        if ((0, rules_api_1.isMoveItemType)(MaterialType_1.MaterialType.EntityCard)(move)) {
+            if (move.location.type === LocationType_1.LocationType.Pantheon) {
+                var location = this.material(MaterialType_1.MaterialType.EntityCard).getItem(move.itemIndex).location;
+                if (location.type !== LocationType_1.LocationType.Pantheon && location.type !== LocationType_1.LocationType.PlayerBufferArea) {
+                    return new Pantheon_1.Pantheon(this.game, move.location.player).onCardPlaced(move);
+                }
+            }
+            else if (move.location.type === LocationType_1.LocationType.PlayerDiscard) {
+                var card = this.material(MaterialType_1.MaterialType.EntityCard).index(move.itemIndex);
+                var location = card.getItem().location;
+                if (location.type === LocationType_1.LocationType.Pantheon) {
+                    this.onEntitySacrificed(card);
+                }
+            }
+        }
+        if ((0, rules_api_1.isMoveItemTypeAtOnce)(MaterialType_1.MaterialType.EntityCard)(move)) {
+            if (move.location.type === LocationType_1.LocationType.PlayerDiscard) {
+                var pile = this.material(MaterialType_1.MaterialType.EntityCard).index(move.indexes);
+                if (((_a = pile.getItem()) === null || _a === void 0 ? void 0 : _a.location.type) === LocationType_1.LocationType.Pantheon) {
+                    var topCard = pile.maxBy(function (item) { return item.location.z; });
+                    this.onEntitySacrificed(topCard);
+                }
+            }
+        }
+        if ((0, rules_api_1.isMoveItemType)(MaterialType_1.MaterialType.GemToken)(move) && move.location.type === LocationType_1.LocationType.PlayerGems) {
+            var gem = this.material(MaterialType_1.MaterialType.GemToken).getItem(move.itemIndex);
+            var player = gem.location.player;
+            if (gem.location.type === LocationType_1.LocationType.PantheonLineBonus && player === move.location.player) {
+                new TriggerEffectsRule_1.TriggerEffectsRule(this.game).triggerEffects({ type: Effect_1.TriggerEventType.LineBonusGain, player: player, y: gem.location.y });
+            }
+        }
+        if ((0, rules_api_1.isMoveItemType)(MaterialType_1.MaterialType.FavorToken)(move) && move.location.type === LocationType_1.LocationType.PlayerFavor) {
+            var favor = this.material(MaterialType_1.MaterialType.FavorToken).getItem(move.itemIndex);
+            var player = favor.location.player;
+            if (favor.location.type === LocationType_1.LocationType.PantheonColumnBonus && player === move.location.player) {
+                new TriggerEffectsRule_1.TriggerEffectsRule(this.game).triggerEffects({ type: Effect_1.TriggerEventType.ColumnBonusGain, player: player, x: favor.location.x });
+            }
+        }
+        return [];
+    };
+    MythologiesRules.prototype.onEntitySacrificed = function (card) {
+        new TriggerEffectsRule_1.TriggerEffectsRule(this.game).triggerEffects({ type: Effect_1.TriggerEventType.EntitySacrificed, card: card.getItem(), cardIndex: card.getIndex() });
+    };
+    MythologiesRules.prototype.onCustomMove = function (move) {
+        var _a;
+        if (move.type === CustomMoveType_1.CustomMoveType.EndEffect) {
+            this.forget(Memory_1.Memory.OngoingEffect);
+            if (this.remind(Memory_1.Memory.PendingEffects).length) {
+                return this.startEffectsResolution();
+            }
+            else {
+                var _b = this.remind(Memory_1.Memory.PendingRule), id = _b.id, player = _b.player;
+                this.forget(Memory_1.Memory.PendingRule);
+                switch (id) {
+                    case RuleId_1.RuleId.EndGame:
+                        return [this.endGame()];
+                    default:
+                        return [player === ((_a = this.game.rule) === null || _a === void 0 ? void 0 : _a.player) ? this.startRule(RuleId_1.RuleId.PlaceCards) : this.startPlayerTurn(RuleId_1.RuleId.PlaceCards, player)];
+                }
+            }
+        }
+        return [];
+    };
+    MythologiesRules.prototype.getAutomaticMoves = function () {
+        var _a;
+        if (!this.remind(Memory_1.Memory.OngoingEffect) && ((_a = this.game.rule) === null || _a === void 0 ? void 0 : _a.id) !== RuleId_1.RuleId.ResolveEffects && this.remind(Memory_1.Memory.PendingEffects).length) {
+            return this.startEffectsResolution();
+        }
+        return [];
+    };
+    MythologiesRules.prototype.startEffectsResolution = function () {
+        var cardIndex = this.remind(Memory_1.Memory.PendingEffects)[0][0].cardIndex;
+        var player = this.material(MaterialType_1.MaterialType.EntityCard).getItem(cardIndex).location.player;
+        return [this.startPlayerTurn(RuleId_1.RuleId.ResolveEffects, player)];
+    };
+    MythologiesRules.prototype.giveTime = function () {
+        return 60;
+    };
+    return MythologiesRules;
+}(rules_api_1.SecretMaterialRules));
+exports.MythologiesRules = MythologiesRules;

package/dist/MythologiesSetup.d.ts

@@ -0,0 +1,17 @@
+import { MaterialGameSetup } from '@gamepark/rules-api';
+import { LocationType } from './material/LocationType';
+import { MaterialType } from './material/MaterialType';
+import { Mythology } from './material/Mythology';
+import { MythologiesOptions } from './MythologiesOptions';
+import { MythologiesRules } from './MythologiesRules';
+import { PlayerColor } from './PlayerColor';
+export declare class MythologiesSetup extends MaterialGameSetup<PlayerColor, MaterialType, LocationType, MythologiesOptions> {
+    Rules: typeof MythologiesRules;
+    setupMaterial(options: MythologiesOptions): void;
+    getMythologies(options: MythologiesOptions): Mythology[];
+    setupMythologies(mythologies: Mythology[]): void;
+    setupPlayers(): void;
+    dealCreatures(): void;
+    private createDestinyCards;
+    start(): void;
+}

package/dist/MythologiesSetup.js

@@ -0,0 +1,161 @@
+"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)(Mythology_1.availableMythologies, 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(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.God } },
+                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;

package/dist/PlayerColor.d.ts

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

package/dist/PlayerColor.js

@@ -0,0 +1,10 @@
+"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 = {}));

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,9 @@
+"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; } });

package/dist/material/Destiny.d.ts

@@ -0,0 +1,9 @@
+import { MaterialRulesPart } from '@gamepark/rules-api';
+import { PlayerColor } from '../PlayerColor';
+export declare class Destiny extends MaterialRulesPart {
+    getMythologyBoard(player: PlayerColor): import("@gamepark/rules-api").Material<number, number, number>;
+    getMythology(player: PlayerColor): import("./Mythology").Mythology;
+    getDestinyMap(destiny: number): PlayerColor[][];
+    getAvailableEntities(player: PlayerColor): import("@gamepark/rules-api").Material<number, number, number>;
+    getBoardsWithoutPlayer(): import("@gamepark/rules-api").Material<number, number, number>;
+}