@gamepark/mythologies 0.9.3 → 0.11.0

package/dist/material/Pantheon.js

@@ -1,486 +1,294 @@
-"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.Pantheon = void 0;
-var rules_api_1 = require("@gamepark/rules-api");
-var lodash_1 = require("lodash");
-var Memory_1 = require("../Memory");
-var MythologiesRules_1 = require("../MythologiesRules");
-var PermanentEffectsRule_1 = require("../rules/effects/PermanentEffectsRule");
-var TriggerEffectsRule_1 = require("../rules/effects/TriggerEffectsRule");
-var Destiny_1 = require("./Destiny");
-var Entity_1 = require("./Entity");
-var Effect_1 = require("./entity/Effect");
-var EntityDescription_1 = require("./entity/EntityDescription");
-var LocationType_1 = require("./LocationType");
-var MaterialType_1 = require("./MaterialType");
-var Pantheon = (function (_super) {
-    __extends(Pantheon, _super);
-    function Pantheon(game, player) {
-        var _this = _super.call(this, game) || this;
-        _this.player = player;
-        return _this;
-    }
-    Object.defineProperty(Pantheon.prototype, "allCards", {
-        get: function () {
-            return this.material(MaterialType_1.MaterialType.EntityCard).location(LocationType_1.LocationType.Pantheon).player(this.player);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Pantheon.prototype, "visibleEntities", {
-        get: function () {
-            var allCards = this.allCards;
-            return allCards.location(function (_a) {
-                var x = _a.x, y = _a.y, z = _a.z;
-                return z === allCards.location(function (l) { return l.x === x && l.y === y; }).length - 1;
-            });
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Pantheon.prototype, "coveredEntities", {
-        get: function () {
-            var allCards = this.material(MaterialType_1.MaterialType.EntityCard).location(LocationType_1.LocationType.Pantheon).player(this.player);
-            return allCards.location(function (_a) {
-                var x = _a.x, y = _a.y, z = _a.z;
-                return z < allCards.location(function (l) { return l.x === x && l.y === y; }).length - 1;
-            });
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Pantheon.prototype, "grid", {
-        get: function () {
-            var visibleEntities = this.visibleEntities;
-            return (0, lodash_1.range)(0, 3).map(function (y) { return (0, lodash_1.range)(0, 3).map(function (x) { var _a; return (_a = visibleEntities.location(function (l) { return l.x === x && l.y === y; }).getItem()) === null || _a === void 0 ? void 0 : _a.id.front; }); });
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Pantheon.prototype, "indexGrid", {
-        get: function () {
-            var visibleEntities = this.visibleEntities;
-            return (0, lodash_1.range)(0, 3).map(function (y) {
-                return (0, lodash_1.range)(0, 3).map(function (x) {
-                    var entity = visibleEntities.location(function (l) { return l.x === x && l.y === y; });
-                    return entity.length > 0 ? entity.getIndex() : null;
-                });
-            });
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Pantheon.prototype, "legalSpacesToInvoke", {
-        get: function () {
-            var _this = this;
-            return this.legalSpaces.filter(function (space) { return _this.isLegalSpaceToInvoke(space); });
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Pantheon.prototype.isLegalSpaceToInvoke = function (space) {
-        var _this = this;
-        var opponents = this.game.players.filter(function (player) { return player !== _this.player; });
-        var favorTax = (0, lodash_1.sumBy)(opponents, function (opponent) { return new Pantheon(_this.game, opponent).getFavorTax(space); });
-        var gemTax = (0, lodash_1.sumBy)(opponents, function (opponent) { return new Pantheon(_this.game, opponent).getGemTax(space); });
-        return (!favorTax || this.favor >= favorTax) && (!gemTax || this.gems >= gemTax);
-    };
-    Pantheon.prototype.getFavorTax = function (space) {
-        return (0, lodash_1.sumBy)(this.visibleEntities.getItems(), function (card) {
-            return (0, lodash_1.sumBy)((0, EntityDescription_1.getEffects)(card.id.front), function (effect) { var _a, _b, _c; return (_c = (_b = (_a = effect).favorTax) === null || _b === void 0 ? void 0 : _b.call(_a, space, card)) !== null && _c !== void 0 ? _c : 0; });
-        });
-    };
-    Pantheon.prototype.getGemTax = function (space) {
-        return (0, lodash_1.sumBy)(this.visibleEntities.getItems(), function (card) {
-            return (0, lodash_1.sumBy)((0, EntityDescription_1.getEffects)(card.id.front), function (effect) { var _a, _b, _c; return (_c = (_b = (_a = effect).gemTax) === null || _b === void 0 ? void 0 : _b.call(_a, space, card)) !== null && _c !== void 0 ? _c : 0; });
-        });
-    };
-    Object.defineProperty(Pantheon.prototype, "legalSpaces", {
-        get: function () {
-            var _this = this;
-            var grid = this.grid;
-            return (0, lodash_1.range)(0, 3)
-                .flatMap(function (y) { return (0, lodash_1.range)(0, 3).map(function (x) { return ({ x: x, y: y }); }); })
-                .filter(function (space) { return _this.isLegalSpace(space, grid); });
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Pantheon.prototype.isLegalSpace = function (_a, grid) {
-        var x = _a.x, y = _a.y;
-        if (grid === void 0) { grid = this.grid; }
-        var card = this.visibleEntities.location(function (l) { return l.x === x && l.y === y; }).getItem();
-        return !card || (!(0, Entity_1.isGod)(grid[y][x]) && new PermanentEffectsRule_1.PermanentEffectsRule(this.game).canCrush(card));
-    };
-    Pantheon.prototype.isFreeSpace = function (_a) {
-        var x = _a.x, y = _a.y;
-        return this.allCards.location(function (l) { return l.x === x && l.y === y; }).length === 0;
-    };
-    Pantheon.prototype.gainGems = function (quantity) {
-        return this.material(MaterialType_1.MaterialType.GemToken).createItem({ location: { type: LocationType_1.LocationType.PlayerGems, player: this.player }, quantity: quantity });
-    };
-    Object.defineProperty(Pantheon.prototype, "gemMaterial", {
-        get: function () {
-            return this.material(MaterialType_1.MaterialType.GemToken).location(LocationType_1.LocationType.PlayerGems).player(this.player);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Pantheon.prototype, "gems", {
-        get: function () {
-            return this.gemMaterial.getQuantity();
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Pantheon.prototype.spendGems = function (quantity) {
-        return this.gemMaterial.deleteItem(quantity);
-    };
-    Pantheon.prototype.gainFavor = function (quantity) {
-        return this.material(MaterialType_1.MaterialType.FavorToken).createItem({ location: { type: LocationType_1.LocationType.PlayerFavor, player: this.player }, quantity: quantity });
-    };
-    Object.defineProperty(Pantheon.prototype, "favor", {
-        get: function () {
-            return this.material(MaterialType_1.MaterialType.FavorToken).location(LocationType_1.LocationType.PlayerFavor).player(this.player).getQuantity();
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Pantheon.prototype.loseFavor = function (quantity) {
-        if (quantity === void 0) { quantity = 1; }
-        return this.material(MaterialType_1.MaterialType.FavorToken).location(LocationType_1.LocationType.PlayerFavor).player(this.player).deleteItem(quantity);
-    };
-    Pantheon.prototype.onCardPlaced = function (move) {
-        var _a, _b;
-        var moves = [];
-        var location = move.location;
-        var card = this.material(MaterialType_1.MaterialType.EntityCard).index(move.itemIndex);
-        var cardItem = card.getItem();
-        var entity = (_a = cardItem.id.front) !== null && _a !== void 0 ? _a : ((_b = move.reveal) === null || _b === void 0 ? void 0 : _b.id).front;
-        if ((0, Entity_1.isGod)(entity)) {
-            moves.push(this.spendGems(4));
-        }
-        var grid = this.indexGrid;
-        grid[move.location.y][move.location.x] = move.itemIndex;
-        moves.push.apply(moves, __spreadArray([], __read(this.gainBonus(grid)), false));
-        var triggerEffectsRule = new TriggerEffectsRule_1.TriggerEffectsRule(this.game);
-        triggerEffectsRule.triggerCardEffect(move.itemIndex, location, { type: Effect_1.TriggerEventType.SelfPlaced });
-        var triggerEvents = this.updateGrid(grid);
-        var invoked = this.isInvoke;
-        if (invoked) {
-            moves.push.apply(moves, __spreadArray([], __read(this.onInvoke(move)), false));
-        }
-        triggerEvents.push({ type: Effect_1.TriggerEventType.EntityPlaced, cardIndex: move.itemIndex, entity: entity, location: location, invoked: invoked });
-        if (triggerEvents.length) {
-            triggerEffectsRule.triggerEffects.apply(triggerEffectsRule, __spreadArray([], __read(triggerEvents), false));
-        }
-        return moves;
-    };
-    Object.defineProperty(Pantheon.prototype, "isInvoke", {
-        get: function () {
-            return new MythologiesRules_1.MythologiesRules(this.game).delegate().isInvoke;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Pantheon.prototype.updateGrid = function (gridAfter) {
-        var e_1, _a;
-        var _b;
-        if (gridAfter === void 0) { gridAfter = this.indexGrid; }
-        var gridBefore = (_b = this.remind(Memory_1.Memory.PlayerGrid, this.player)) !== null && _b !== void 0 ? _b : this.indexGrid;
-        this.memorize(Memory_1.Memory.PlayerGrid, gridAfter, this.player);
-        var triggerEvents = [];
-        var entitiesMoved = this.getEntitiesMoved(gridBefore, gridAfter);
-        if (entitiesMoved.length) {
-            triggerEvents.push({ type: Effect_1.TriggerEventType.EntitiesMoved, player: this.player, entities: entitiesMoved });
-        }
-        var entitiesCrushed = this.getEntitiesCrushed(gridBefore, gridAfter);
-        try {
-            for (var entitiesCrushed_1 = __values(entitiesCrushed), entitiesCrushed_1_1 = entitiesCrushed_1.next(); !entitiesCrushed_1_1.done; entitiesCrushed_1_1 = entitiesCrushed_1.next()) {
-                var cardIndex = entitiesCrushed_1_1.value;
-                triggerEvents.push({ type: Effect_1.TriggerEventType.EntityCrushed, card: this.material(MaterialType_1.MaterialType.EntityCard).getItem(cardIndex), cardIndex: cardIndex });
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (entitiesCrushed_1_1 && !entitiesCrushed_1_1.done && (_a = entitiesCrushed_1.return)) _a.call(entitiesCrushed_1);
-            }
-            finally { if (e_1) throw e_1.error; }
-        }
-        for (var y = 0; y < 3; y++) {
-            if (gridBefore[y].some(function (item) { return item === null; }) && gridAfter[y].every(function (item) { return item !== null; })) {
-                triggerEvents.push({ type: Effect_1.TriggerEventType.LineEvent, eventType: Effect_1.LineEventType.Completed, player: this.player, y: y });
-            }
-        }
-        var _loop_1 = function (x) {
-            if (gridBefore.some(function (line) { return line[x] === null; }) && gridAfter.every(function (line) { return line[x] !== null; })) {
-                triggerEvents.push({ type: Effect_1.TriggerEventType.ColumnEvent, eventType: Effect_1.LineEventType.Completed, player: this_1.player, x: x });
-            }
-        };
-        var this_1 = this;
-        for (var x = 0; x < 3; x++) {
-            _loop_1(x);
-        }
-        return triggerEvents;
-    };
-    Pantheon.prototype.getEntitiesMoved = function (before, after) {
-        var entities = [];
-        for (var y = 0; y < 3; y++) {
-            var _loop_2 = function (x) {
-                var cardIndex = before[y][x];
-                if (cardIndex !== null && cardIndex !== after[y][x] && after.some(function (line) { return line.includes(cardIndex); })) {
-                    entities.push(cardIndex);
-                }
-            };
-            for (var x = 0; x < 3; x++) {
-                _loop_2(x);
-            }
-        }
-        return entities;
-    };
-    Pantheon.prototype.getEntitiesCrushed = function (before, after) {
-        var entities = [];
-        var allCardsIndexes = this.allCards.getIndexes();
-        for (var y = 0; y < 3; y++) {
-            var _loop_3 = function (x) {
-                var cardIndex = before[y][x];
-                if (cardIndex !== null && !after.some(function (line) { return line.includes(cardIndex); }) && allCardsIndexes.includes(cardIndex)) {
-                    entities.push(cardIndex);
-                }
-            };
-            for (var x = 0; x < 3; x++) {
-                _loop_3(x);
-            }
-        }
-        return entities;
-    };
-    Pantheon.prototype.gainBonus = function (grid) {
-        var e_2, _a, e_3, _b;
-        if (grid === void 0) { grid = this.indexGrid; }
-        var moves = [];
-        var fullLines = (0, lodash_1.range)(0, 3).filter(function (y) { return !grid[y].includes(null); });
-        try {
-            for (var fullLines_1 = __values(fullLines), fullLines_1_1 = fullLines_1.next(); !fullLines_1_1.done; fullLines_1_1 = fullLines_1.next()) {
-                var y = fullLines_1_1.value;
-                moves.push.apply(moves, __spreadArray([], __read(this.gainLineBonus(y)), false));
-            }
-        }
-        catch (e_2_1) { e_2 = { error: e_2_1 }; }
-        finally {
-            try {
-                if (fullLines_1_1 && !fullLines_1_1.done && (_a = fullLines_1.return)) _a.call(fullLines_1);
-            }
-            finally { if (e_2) throw e_2.error; }
-        }
-        var fullColumns = (0, lodash_1.range)(0, 3).filter(function (x) { return grid.every(function (line) { return line[x] !== null; }); });
-        try {
-            for (var fullColumns_1 = __values(fullColumns), fullColumns_1_1 = fullColumns_1.next(); !fullColumns_1_1.done; fullColumns_1_1 = fullColumns_1.next()) {
-                var x = fullColumns_1_1.value;
-                moves.push.apply(moves, __spreadArray([], __read(this.gainColumnBonus(x)), false));
-            }
-        }
-        catch (e_3_1) { e_3 = { error: e_3_1 }; }
-        finally {
-            try {
-                if (fullColumns_1_1 && !fullColumns_1_1.done && (_b = fullColumns_1.return)) _b.call(fullColumns_1);
-            }
-            finally { if (e_3) throw e_3.error; }
-        }
-        return moves;
-    };
-    Pantheon.prototype.gainLineBonus = function (y) {
-        var bonusGem = this.getBonusGem(y);
-        return bonusGem.length ? [bonusGem.moveItem({ type: LocationType_1.LocationType.PlayerGems, player: this.player })] : [];
-    };
-    Pantheon.prototype.gainColumnBonus = function (x) {
-        var bonusFavor = this.getBonusFavor(x);
-        return bonusFavor.length ? [bonusFavor.moveItem({ type: LocationType_1.LocationType.PlayerFavor, player: this.player })] : [];
-    };
-    Pantheon.prototype.getBonusGem = function (y) {
-        return this.material(MaterialType_1.MaterialType.GemToken)
-            .location(LocationType_1.LocationType.PantheonLineBonus)
-            .player(this.player)
-            .location(function (l) { return l.y === y; });
-    };
-    Pantheon.prototype.getBonusFavor = function (x) {
-        return this.material(MaterialType_1.MaterialType.FavorToken)
-            .location(LocationType_1.LocationType.PantheonColumnBonus)
-            .player(this.player)
-            .location(function (l) { return l.x === x; });
-    };
-    Pantheon.prototype.onInvoke = function (move) {
-        var e_4, _a;
-        var moves = [];
-        var card = this.material(MaterialType_1.MaterialType.EntityCard).index(move.itemIndex).getItem();
-        var entity = card.id.front;
-        if (!entity)
-            return [];
-        try {
-            for (var _b = __values(this.game.players), _c = _b.next(); !_c.done; _c = _b.next()) {
-                var player = _c.value;
-                if (player !== this.player) {
-                    var favorTax = new Pantheon(this.game, player).getFavorTax(move.location);
-                    if (favorTax > 0) {
-                        var favor = this.material(MaterialType_1.MaterialType.FavorToken).location(LocationType_1.LocationType.PlayerFavor).player(this.player);
-                        moves.push(favor.moveItem({ type: LocationType_1.LocationType.PlayerFavor, player: player }, favorTax));
-                    }
-                    var gemTax = new Pantheon(this.game, player).getGemTax(move.location);
-                    if (gemTax > 0) {
-                        var gems = this.material(MaterialType_1.MaterialType.GemToken).location(LocationType_1.LocationType.PlayerGems).player(this.player);
-                        moves.push(gems.moveItem({ type: LocationType_1.LocationType.PlayerFavor, player: player }, gemTax));
-                    }
-                }
-            }
-        }
-        catch (e_4_1) { e_4 = { error: e_4_1 }; }
-        finally {
-            try {
-                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-            }
-            finally { if (e_4) throw e_4.error; }
-        }
-        moves.push.apply(moves, __spreadArray([], __read(this.getInvokeGains(entity, move.location.y)), false));
-        return moves;
-    };
-    Pantheon.prototype.getInvokeGains = function (entity, line) {
-        var moves = [];
-        var invokeGain = EntityDescription_1.entities[entity].invoke[line];
-        if (invokeGain.gem) {
-            moves.push(this.gainGems(invokeGain.gem));
-        }
-        if (invokeGain.favor) {
-            moves.push(this.gainFavor(invokeGain.favor));
-        }
-        return moves;
-    };
-    Pantheon.prototype.hasEntity = function (entity) {
-        return this.visibleEntities.getItems().some(function (card) { return card.id.front === entity; });
-    };
-    Pantheon.prototype.getPiles = function (predicate) {
-        if (predicate === void 0) { predicate = function () { return true; }; }
-        var piles = [];
-        var myEntities = this.material(MaterialType_1.MaterialType.EntityCard).player(this.player);
-        var fullPantheon = myEntities.location(LocationType_1.LocationType.Pantheon);
-        for (var x = 0; x < 3; x++) {
-            for (var y = 0; y < 3; y++) {
-                if (predicate({ x: x, y: y })) {
-                    var pile = this.getPile({ x: x, y: y }, fullPantheon);
-                    if (pile.length > 0) {
-                        piles.push(pile);
-                    }
-                }
-            }
-        }
-        return piles;
-    };
-    Pantheon.prototype.getPile = function (_a, fullPantheon) {
-        var x = _a.x, y = _a.y;
-        if (fullPantheon === void 0) { fullPantheon = this.material(MaterialType_1.MaterialType.EntityCard).location(LocationType_1.LocationType.Pantheon).player(this.player); }
-        return fullPantheon.location(function (l) { return l.x === x && l.y === y; }).sort(function (item) { return item.location.z; });
-    };
-    Pantheon.prototype.isAbleToMove = function (entity) {
-        return !this.isVisible(entity) || new PermanentEffectsRule_1.PermanentEffectsRule(this.game).canMove(entity);
-    };
-    Pantheon.prototype.isVisible = function (entity) {
-        return this.getPile(entity.location).length - 1 === entity.location.z;
-    };
-    Object.defineProperty(Pantheon.prototype, "mythologies", {
-        get: function () {
-            return (0, lodash_1.uniq)(new Pantheon(this.game, this.player).visibleEntities.getItems().map(function (item) { return (0, Entity_1.entityMythology)(item.id.front); }));
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Pantheon.prototype, "missingMythologies", {
-        get: function () {
-            return (0, lodash_1.difference)(new Destiny_1.Destiny(this.game).mythologies, this.mythologies);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Pantheon.prototype.onEntitySacrificed = function (cardIndex) {
-        var card = this.material(MaterialType_1.MaterialType.EntityCard).getItem(cardIndex);
-        var _a = card.location, x = _a.x, y = _a.y, z = _a.z;
-        var grid = this.indexGrid;
-        if (grid[y][x] === cardIndex) {
-            var cardUnder = this.allCards.location(function (l) { return l.x === x && l.y === y && l.z !== z; }).maxBy(function (item) { return item.location.z; });
-            grid[y][x] = cardUnder.length ? cardUnder.getIndex() : null;
-            this.memorize(Memory_1.Memory.PlayerGrid, grid, this.player);
-            new TriggerEffectsRule_1.TriggerEffectsRule(this.game).triggerEffects({ type: Effect_1.TriggerEventType.EntitySacrificed, card: card, cardIndex: cardIndex });
-        }
-    };
-    Pantheon.prototype.hasCrushed = function (card) {
-        return this.allCards.location(function (l) { return l.x === card.location.x && l.y === card.location.y && l.z < card.location.z; }).length > 0;
-    };
-    Pantheon.prototype.isOpponentOngoingEffect = function () {
-        var ongoingEffect = this.remind(Memory_1.Memory.OngoingEffect);
-        if (!ongoingEffect)
-            return false;
-        var effectOwner = this.material(MaterialType_1.MaterialType.EntityCard).getItem(ongoingEffect.cardIndex).location.player;
-        return this.player !== effectOwner;
-    };
-    Pantheon.prototype.replaceSacrifice = function (cards) {
-        return this.visibleEntities.filter(function (item) {
-            return (0, EntityDescription_1.getEffects)(item.id.front).some(function (effect) { return !(0, Effect_1.isTriggeredEffect)(effect) && cards.some(function (card) { var _a; return (_a = effect.replaceSacrifice) === null || _a === void 0 ? void 0 : _a.call(effect, card, item); }); });
-        });
-    };
-    Pantheon.prototype.sacrificeToPreventMove = function () {
-        return this.visibleEntities
-            .filter(function (item) { return (0, EntityDescription_1.getEffects)(item.id.front).some(function (effect) { return !(0, Effect_1.isTriggeredEffect)(effect) && effect.sacrificeInsteadOfMove; }); })
-            .moveItems({ type: LocationType_1.LocationType.PlayerDiscard, player: this.player });
-    };
-    return Pantheon;
-}(rules_api_1.MaterialRulesPart));
-exports.Pantheon = Pantheon;
+import { MaterialRulesPart } from '@gamepark/rules-api';
+import { difference, range, sumBy, uniq } from 'es-toolkit';
+import { Memory } from '../Memory';
+import { MythologiesRules } from '../MythologiesRules';
+import { PermanentEffectsRule } from '../rules/effects/PermanentEffectsRule';
+import { TriggerEffectsRule } from '../rules/effects/TriggerEffectsRule';
+import { Destiny } from './Destiny';
+import { entityMythology, isGod } from './Entity';
+import { isTriggeredEffect, LineEventType, TriggerEventType } from './entity/Effect';
+import { entities, getEffects } from './entity/EntityDescription';
+import { LocationType } from './LocationType';
+import { MaterialType } from './MaterialType';
+export class Pantheon extends MaterialRulesPart {
+    player;
+    constructor(game, player) {
+        super(game);
+        this.player = player;
+    }
+    get allCards() {
+        return this.material(MaterialType.EntityCard).location(LocationType.Pantheon).player(this.player);
+    }
+    get visibleEntities() {
+        const allCards = this.allCards;
+        return allCards.location(({ x, y, z }) => z === allCards.location((l) => l.x === x && l.y === y).length - 1);
+    }
+    get coveredEntities() {
+        const allCards = this.material(MaterialType.EntityCard).location(LocationType.Pantheon).player(this.player);
+        return allCards.location(({ x, y, z }) => z < allCards.location((l) => l.x === x && l.y === y).length - 1);
+    }
+    get grid() {
+        const visibleEntities = this.visibleEntities;
+        return range(0, 3).map((y) => range(0, 3).map((x) => visibleEntities.location((l) => l.x === x && l.y === y).getItem()?.id.front));
+    }
+    get indexGrid() {
+        const visibleEntities = this.visibleEntities;
+        return range(0, 3).map((y) => range(0, 3).map((x) => {
+            const entity = visibleEntities.location((l) => l.x === x && l.y === y);
+            return entity.length > 0 ? entity.getIndex() : null;
+        }));
+    }
+    get legalSpacesToInvoke() {
+        return this.legalSpaces.filter((space) => this.isLegalSpaceToInvoke(space));
+    }
+    isLegalSpaceToInvoke(space) {
+        const opponents = this.game.players.filter((player) => player !== this.player);
+        const favorTax = sumBy(opponents, (opponent) => new Pantheon(this.game, opponent).getFavorTax(space));
+        const gemTax = sumBy(opponents, (opponent) => new Pantheon(this.game, opponent).getGemTax(space));
+        return (!favorTax || this.favor >= favorTax) && (!gemTax || this.gems >= gemTax);
+    }
+    getFavorTax(space) {
+        return sumBy(this.visibleEntities.getItems(), (card) => sumBy(getEffects(card.id.front), (effect) => effect.favorTax?.(space, card) ?? 0));
+    }
+    getGemTax(space) {
+        return sumBy(this.visibleEntities.getItems(), (card) => sumBy(getEffects(card.id.front), (effect) => effect.gemTax?.(space, card) ?? 0));
+    }
+    get legalSpaces() {
+        const grid = this.grid;
+        return range(0, 3)
+            .flatMap((y) => range(0, 3).map((x) => ({ x, y })))
+            .filter((space) => this.isLegalSpace(space, grid));
+    }
+    isLegalSpace({ x, y }, grid = this.grid) {
+        const card = this.visibleEntities.location((l) => l.x === x && l.y === y).getItem();
+        return !card || (!isGod(grid[y][x]) && new PermanentEffectsRule(this.game).canCrush(card));
+    }
+    isFreeSpace({ x, y }) {
+        return this.allCards.location((l) => l.x === x && l.y === y).length === 0;
+    }
+    gainGems(quantity) {
+        return this.material(MaterialType.GemToken).createItem({ location: { type: LocationType.PlayerGems, player: this.player }, quantity });
+    }
+    get gemMaterial() {
+        return this.material(MaterialType.GemToken).location(LocationType.PlayerGems).player(this.player);
+    }
+    get gems() {
+        return this.gemMaterial.getQuantity();
+    }
+    spendGems(quantity) {
+        return this.gemMaterial.deleteItem(quantity);
+    }
+    gainFavor(quantity) {
+        return this.material(MaterialType.FavorToken).createItem({ location: { type: LocationType.PlayerFavor, player: this.player }, quantity });
+    }
+    get favor() {
+        return this.material(MaterialType.FavorToken).location(LocationType.PlayerFavor).player(this.player).getQuantity();
+    }
+    loseFavor(quantity = 1) {
+        return this.material(MaterialType.FavorToken).location(LocationType.PlayerFavor).player(this.player).deleteItem(quantity);
+    }
+    onCardPlaced(move) {
+        const moves = [];
+        const location = move.location;
+        const card = this.material(MaterialType.EntityCard).index(move.itemIndex);
+        const cardItem = card.getItem();
+        const entity = cardItem.id.front ?? (move.reveal?.id).front;
+        if (isGod(entity)) {
+            moves.push(this.spendGems(4));
+        }
+        const grid = this.indexGrid;
+        const crush = grid[move.location.y][move.location.x] !== null;
+        grid[move.location.y][move.location.x] = move.itemIndex;
+        moves.push(...this.gainBonus(grid));
+        const triggerEffectsRule = new TriggerEffectsRule(this.game);
+        triggerEffectsRule.triggerCardEffect(move.itemIndex, location, { type: TriggerEventType.SelfPlaced, crush });
+        const triggerEvents = this.updateGrid(grid);
+        const invoked = this.isInvoke;
+        if (invoked) {
+            moves.push(...this.onInvoke(move));
+        }
+        triggerEvents.push({ type: TriggerEventType.EntityPlaced, cardIndex: move.itemIndex, entity, location, invoked });
+        if (triggerEvents.length) {
+            triggerEffectsRule.triggerEffects(...triggerEvents);
+        }
+        return moves;
+    }
+    get isInvoke() {
+        return new MythologiesRules(this.game).delegate().isInvoke;
+    }
+    updateGrid(gridAfter = this.indexGrid) {
+        const gridBefore = this.remind(Memory.PlayerGrid, this.player) ?? this.indexGrid;
+        this.memorize(Memory.PlayerGrid, gridAfter, this.player);
+        const triggerEvents = [];
+        const entitiesMoved = this.getEntitiesMoved(gridBefore, gridAfter);
+        if (entitiesMoved.length) {
+            triggerEvents.push({ type: TriggerEventType.EntitiesMoved, player: this.player, entities: entitiesMoved });
+        }
+        const entitiesCrushed = this.getEntitiesCrushed(gridBefore, gridAfter);
+        for (const cardIndex of entitiesCrushed) {
+            triggerEvents.push({ type: TriggerEventType.EntityCrushed, card: this.material(MaterialType.EntityCard).getItem(cardIndex), cardIndex });
+        }
+        for (let y = 0; y < 3; y++) {
+            if (gridBefore[y].some((item) => item === null) && gridAfter[y].every((item) => item !== null)) {
+                triggerEvents.push({ type: TriggerEventType.LineEvent, eventType: LineEventType.Completed, player: this.player, y });
+            }
+        }
+        for (let x = 0; x < 3; x++) {
+            if (gridBefore.some((line) => line[x] === null) && gridAfter.every((line) => line[x] !== null)) {
+                triggerEvents.push({ type: TriggerEventType.ColumnEvent, eventType: LineEventType.Completed, player: this.player, x });
+            }
+        }
+        return triggerEvents;
+    }
+    getEntitiesMoved(before, after) {
+        const entities = [];
+        for (let y = 0; y < 3; y++) {
+            for (let x = 0; x < 3; x++) {
+                const cardIndex = before[y][x];
+                if (cardIndex !== null && cardIndex !== after[y][x] && after.some((line) => line.includes(cardIndex))) {
+                    entities.push(cardIndex);
+                }
+            }
+        }
+        return entities;
+    }
+    getEntitiesCrushed(before, after) {
+        const entities = [];
+        const allCardsIndexes = this.allCards.getIndexes();
+        for (let y = 0; y < 3; y++) {
+            for (let x = 0; x < 3; x++) {
+                const cardIndex = before[y][x];
+                if (cardIndex !== null && !after.some((line) => line.includes(cardIndex)) && allCardsIndexes.includes(cardIndex)) {
+                    entities.push(cardIndex);
+                }
+            }
+        }
+        return entities;
+    }
+    gainBonus(grid = this.indexGrid) {
+        const moves = [];
+        const fullLines = range(0, 3).filter((y) => !grid[y].includes(null));
+        for (const y of fullLines) {
+            moves.push(...this.gainLineBonus(y));
+        }
+        const fullColumns = range(0, 3).filter((x) => grid.every((line) => line[x] !== null));
+        for (const x of fullColumns) {
+            moves.push(...this.gainColumnBonus(x));
+        }
+        return moves;
+    }
+    gainLineBonus(y) {
+        const bonusGem = this.getBonusGem(y);
+        return bonusGem.length ? [bonusGem.moveItem({ type: LocationType.PlayerGems, player: this.player })] : [];
+    }
+    gainColumnBonus(x) {
+        const bonusFavor = this.getBonusFavor(x);
+        return bonusFavor.length ? [bonusFavor.moveItem({ type: LocationType.PlayerFavor, player: this.player })] : [];
+    }
+    getBonusGem(y) {
+        return this.material(MaterialType.GemToken)
+            .location(LocationType.PantheonLineBonus)
+            .player(this.player)
+            .location((l) => l.y === y);
+    }
+    getBonusFavor(x) {
+        return this.material(MaterialType.FavorToken)
+            .location(LocationType.PantheonColumnBonus)
+            .player(this.player)
+            .location((l) => l.x === x);
+    }
+    onInvoke(move) {
+        const moves = [];
+        const card = this.material(MaterialType.EntityCard).index(move.itemIndex).getItem();
+        const entity = card.id.front;
+        if (!entity)
+            return [];
+        for (const player of this.game.players) {
+            if (player !== this.player) {
+                const favorTax = new Pantheon(this.game, player).getFavorTax(move.location);
+                if (favorTax > 0) {
+                    const favor = this.material(MaterialType.FavorToken).location(LocationType.PlayerFavor).player(this.player);
+                    moves.push(favor.moveItem({ type: LocationType.PlayerFavor, player }, favorTax));
+                }
+                const gemTax = new Pantheon(this.game, player).getGemTax(move.location);
+                if (gemTax > 0) {
+                    const gems = this.material(MaterialType.GemToken).location(LocationType.PlayerGems).player(this.player);
+                    moves.push(gems.moveItem({ type: LocationType.PlayerFavor, player }, gemTax));
+                }
+            }
+        }
+        moves.push(...this.getInvokeGains(entity, move.location.y));
+        return moves;
+    }
+    getInvokeGains(entity, line) {
+        const moves = [];
+        const invokeGain = entities[entity].invoke[line];
+        if (invokeGain.gem) {
+            moves.push(this.gainGems(invokeGain.gem));
+        }
+        if (invokeGain.favor) {
+            moves.push(this.gainFavor(invokeGain.favor));
+        }
+        return moves;
+    }
+    hasEntity(entity) {
+        return this.visibleEntities.getItems().some((card) => card.id.front === entity);
+    }
+    getPiles(predicate = () => true) {
+        const piles = [];
+        const myEntities = this.material(MaterialType.EntityCard).player(this.player);
+        const fullPantheon = myEntities.location(LocationType.Pantheon);
+        for (let x = 0; x < 3; x++) {
+            for (let y = 0; y < 3; y++) {
+                if (predicate({ x, y })) {
+                    const pile = this.getPile({ x, y }, fullPantheon);
+                    if (pile.length > 0) {
+                        piles.push(pile);
+                    }
+                }
+            }
+        }
+        return piles;
+    }
+    getPile({ x, y }, fullPantheon = this.material(MaterialType.EntityCard).location(LocationType.Pantheon).player(this.player)) {
+        return fullPantheon.location((l) => l.x === x && l.y === y).sort((item) => item.location.z);
+    }
+    isAbleToMove(entity) {
+        return !this.isVisible(entity) || new PermanentEffectsRule(this.game).canMove(entity);
+    }
+    isVisible(entity) {
+        return this.getPile(entity.location).length - 1 === entity.location.z;
+    }
+    get mythologies() {
+        return uniq(new Pantheon(this.game, this.player).visibleEntities.getItems().map((item) => entityMythology(item.id.front)));
+    }
+    get missingMythologies() {
+        return difference(new Destiny(this.game).mythologies, this.mythologies);
+    }
+    onEntitySacrificed(cardIndex) {
+        const card = this.material(MaterialType.EntityCard).getItem(cardIndex);
+        const { x, y, z } = card.location;
+        const grid = this.indexGrid;
+        if (grid[y][x] === cardIndex) {
+            const cardUnder = this.allCards.location((l) => l.x === x && l.y === y && l.z !== z).maxBy((item) => item.location.z);
+            grid[y][x] = cardUnder.length ? cardUnder.getIndex() : null;
+            this.memorize(Memory.PlayerGrid, grid, this.player);
+            new TriggerEffectsRule(this.game).triggerEffects({ type: TriggerEventType.EntitySacrificed, card: card, cardIndex });
+        }
+    }
+    isOpponentOngoingEffect() {
+        const ongoingEffect = this.remind(Memory.OngoingEffect);
+        if (!ongoingEffect)
+            return false;
+        const effectOwner = this.material(MaterialType.EntityCard).getItem(ongoingEffect.cardIndex).location.player;
+        return this.player !== effectOwner;
+    }
+    replaceSacrifice(cards) {
+        return this.visibleEntities.filter((item) => getEffects(item.id.front).some((effect) => !isTriggeredEffect(effect) && cards.some((card) => effect.replaceSacrifice?.(card, item))));
+    }
+    sacrificeToPreventMove() {
+        return this.visibleEntities
+            .filter((item) => getEffects(item.id.front).some((effect) => !isTriggeredEffect(effect) && effect.sacrificeInsteadOfMove))
+            .moveItems({ type: LocationType.PlayerDiscard, player: this.player });
+    }
+}