@gamepark/mythologies 0.1.0

package/dist/material/Pantheon.js

@@ -0,0 +1,357 @@
+"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 MythologiesRules_1 = require("../MythologiesRules");
+var TriggerEffectsRule_1 = require("../rules/effects/TriggerEffectsRule");
+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;
+            });
+        },
+        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, "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 trollOpponents = this.getOpponentsWithTrollAt(space);
+        return !trollOpponents.length || this.favor >= trollOpponents.length;
+    };
+    Pantheon.prototype.getOpponentsWithTrollAt = function (_a) {
+        var _this = this;
+        var x = _a.x, y = _a.y;
+        return this.game.players.filter(function (player) {
+            if (player === _this.player)
+                return false;
+            return new Pantheon(_this.game, player).grid[y][x] === Entity_1.Entity.Troll;
+        });
+    };
+    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; }
+        return !(0, Entity_1.isGod)(grid[y][x]);
+    };
+    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 moves = [];
+        var location = move.location;
+        var card = this.material(MaterialType_1.MaterialType.EntityCard).index(move.itemIndex);
+        var cardItem = card.getItem();
+        var entity = cardItem.id.front;
+        if ((0, Entity_1.isGod)(entity)) {
+            moves.push(this.spendGems(4));
+        }
+        var grid = this.grid;
+        grid[move.location.y][move.location.x] = entity;
+        moves.push.apply(moves, __spreadArray([], __read(this.gainBonus(grid)), false));
+        var triggerEffectsRule = new TriggerEffectsRule_1.TriggerEffectsRule(this.game);
+        var crushed = this.allCards.location(function (l) { return l.x === move.location.x && l.y === move.location.y; }).maxBy(function (item) { return item.location.z; });
+        triggerEffectsRule.triggerCardEffect(card, { type: Effect_1.TriggerEventType.SelfPlaced, location: location, crush: crushed.length > 0 });
+        var invoke = this.isInvoke;
+        if (invoke) {
+            moves.push.apply(moves, __spreadArray([], __read(this.onInvoke(move)), false));
+        }
+        var triggerEvents = [];
+        if (invoke) {
+            triggerEvents.push({ type: Effect_1.TriggerEventType.EntityInvoked, card: cardItem, cardIndex: move.itemIndex });
+        }
+        if (crushed.length) {
+            triggerEvents.push({ type: Effect_1.TriggerEventType.EntityCrushed, card: crushed.getItem(), cardIndex: crushed.getIndex() });
+        }
+        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.gainBonus = function (grid) {
+        var e_1, _a, e_2, _b;
+        if (grid === void 0) { grid = this.grid; }
+        var moves = [];
+        var fullLines = (0, lodash_1.range)(0, 3).filter(function (y) { return !grid[y].includes(undefined); });
+        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;
+                var bonusGem = this.getBonusGem(y);
+                if (bonusGem.length) {
+                    moves.push(bonusGem.moveItem({ type: LocationType_1.LocationType.PlayerGems, player: this.player }));
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (fullLines_1_1 && !fullLines_1_1.done && (_a = fullLines_1.return)) _a.call(fullLines_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        var fullColumns = (0, lodash_1.range)(0, 3).filter(function (x) { return grid.every(function (line) { return line[x] !== undefined; }); });
+        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;
+                var bonusFavor = this.getBonusFavor(x);
+                if (bonusFavor.length) {
+                    moves.push(bonusFavor.moveItem({ type: LocationType_1.LocationType.PlayerFavor, player: this.player }));
+                }
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (fullColumns_1_1 && !fullColumns_1_1.done && (_b = fullColumns_1.return)) _b.call(fullColumns_1);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        return moves;
+    };
+    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_3, _a;
+        var moves = [];
+        var card = this.material(MaterialType_1.MaterialType.EntityCard).index(move.itemIndex).getItem();
+        var entity = card.id.front;
+        if (!entity)
+            return [];
+        var trollOpponents = this.getOpponentsWithTrollAt(move.location);
+        var favor = this.material(MaterialType_1.MaterialType.FavorToken).location(LocationType_1.LocationType.PlayerFavor).player(this.player);
+        try {
+            for (var trollOpponents_1 = __values(trollOpponents), trollOpponents_1_1 = trollOpponents_1.next(); !trollOpponents_1_1.done; trollOpponents_1_1 = trollOpponents_1.next()) {
+                var trollOpponent = trollOpponents_1_1.value;
+                moves.push(favor.moveItem({ type: LocationType_1.LocationType.PlayerFavor, player: trollOpponent }));
+            }
+        }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (trollOpponents_1_1 && !trollOpponents_1_1.done && (_a = trollOpponents_1.return)) _a.call(trollOpponents_1);
+            }
+            finally { if (e_3) throw e_3.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);
+        var _loop_1 = function (x) {
+            var _loop_2 = function (y) {
+                if (predicate({ x: x, y: y })) {
+                    var pile = fullPantheon.location(function (l) { return l.x === x && l.y === y; }).sort(function (item) { return item.location.z; });
+                    if (pile.length > 0) {
+                        piles.push(pile);
+                    }
+                }
+            };
+            for (var y = 0; y < 3; y++) {
+                _loop_2(y);
+            }
+        };
+        for (var x = 0; x < 3; x++) {
+            _loop_1(x);
+        }
+        return piles;
+    };
+    Pantheon.prototype.isAbleToMove = function (entity) {
+        return !this.visibleEntities.getItems().some(function (item) { return item.id.front === Entity_1.Entity.Naga && (0, rules_api_1.areAdjacentSquares)(item.location, entity.location); });
+    };
+    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 () {
+            var mythologies = this.material(MaterialType_1.MaterialType.MythologyBoard)
+                .getItems()
+                .map(function (item) { return item.id.mythology; });
+            return (0, lodash_1.difference)(mythologies, this.mythologies);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return Pantheon;
+}(rules_api_1.MaterialRulesPart));
+exports.Pantheon = Pantheon;

package/dist/material/Trial.d.ts

@@ -0,0 +1,22 @@
+import { MaterialMove, MaterialRulesPart, XYCoordinates } from '@gamepark/rules-api';
+import { PlayerColor } from '../PlayerColor';
+import { Mythology } from './Mythology';
+import { Pantheon } from './Pantheon';
+export declare class Trial extends MaterialRulesPart {
+    passTrials(player: PlayerColor): MaterialMove<number, number, number, number>[];
+    passTrial(player: PlayerColor, [mythology1, mythology2]: Mythology[]): boolean;
+    passTrialOnLocation(player: PlayerColor, mythology: Mythology, searchLocation: (location: Partial<XYCoordinates>) => boolean): boolean;
+    getPantheon(player: PlayerColor): Pantheon;
+    getVisibleEntities(player: PlayerColor, searchLocation?: (location: Partial<XYCoordinates>) => boolean): import("@gamepark/rules-api").Material<number, number, number>;
+    haveMoreInvokeFavorThanNeighbor(player: PlayerColor, searchLocation: (location: Partial<XYCoordinates>) => boolean): boolean;
+    getInvokeGains(player: PlayerColor, searchLocation: (location: Partial<XYCoordinates>) => boolean): import("./entity/EntityDescription").InvokeGain[];
+    getInvokeFavorGain(player: PlayerColor, searchLocation: (location: Partial<XYCoordinates>) => boolean): number;
+    getInvokeGemsGain(player: PlayerColor, searchLocation: (location: Partial<XYCoordinates>) => boolean): number;
+    noEmptySpace(player: PlayerColor, searchLocation: (location: Partial<XYCoordinates>) => boolean): boolean;
+    countGods(player: PlayerColor, searchLocation: (location: Partial<XYCoordinates>) => boolean): number;
+    countCreatures(player: PlayerColor, searchLocation: (location: Partial<XYCoordinates>) => boolean): number;
+    getMythologies(player: PlayerColor, searchLocation: (location: Partial<XYCoordinates>) => boolean): Mythology[];
+    getTrialReward([mythology1, mythology2]: Mythology[]): number;
+    getTrialLeftReward(mythology: Mythology): 1 | 2;
+    getTrialRightReward(mythology: Mythology): 1 | 2;
+}

package/dist/material/Trial.js

@@ -0,0 +1,184 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Trial = void 0;
+var rules_api_1 = require("@gamepark/rules-api");
+var lodash_1 = require("lodash");
+var CustomMoveType_1 = require("../CustomMoveType");
+var Memory_1 = require("../Memory");
+var Entity_1 = require("./Entity");
+var EntityDescription_1 = require("./entity/EntityDescription");
+var MaterialType_1 = require("./MaterialType");
+var Mythology_1 = require("./Mythology");
+var Pantheon_1 = require("./Pantheon");
+var Trial = (function (_super) {
+    __extends(Trial, _super);
+    function Trial() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    Trial.prototype.passTrials = function (player) {
+        var moves = [];
+        var mythologyBoards = this.material(MaterialType_1.MaterialType.MythologyBoard);
+        var round = this.material(MaterialType_1.MaterialType.RoundToken).getItem().location.id;
+        if (round === 3 || (round === 4 && this.remind(Memory_1.Memory.TrialFailure, player))) {
+            var firstTrialBoards = mythologyBoards.location(function (l) { return l.y === 0; }).sort(function (item) { return item.location.x; });
+            var firstTrialMythologies = firstTrialBoards.getItems().map(function (item) { return item.id.mythology; });
+            if (this.passTrial(player, firstTrialMythologies)) {
+                var reward = this.getTrialReward(firstTrialMythologies);
+                moves.push(this.customMove(CustomMoveType_1.CustomMoveType.TrialSuccess, { trial: 1, reward: round === 3 ? reward : reward - 1 }));
+            }
+            else {
+                moves.push(this.customMove(CustomMoveType_1.CustomMoveType.TrialFailure, 1));
+            }
+        }
+        if (round === 4) {
+            var secondTrialBoards = mythologyBoards.location(function (l) { return l.y === 1; }).sort(function (item) { return item.location.x; });
+            var secondTrialMythologies = secondTrialBoards.getItems().map(function (item) { return item.id.mythology; });
+            if (this.passTrial(player, secondTrialMythologies)) {
+                var reward = this.getTrialReward(secondTrialMythologies);
+                moves.push(this.customMove(CustomMoveType_1.CustomMoveType.TrialSuccess, { trial: 2, reward: reward }));
+            }
+            else {
+                moves.push(this.customMove(CustomMoveType_1.CustomMoveType.TrialFailure, 2));
+            }
+        }
+        return moves;
+    };
+    Trial.prototype.passTrial = function (player, _a) {
+        var _this = this;
+        var _b = __read(_a, 2), mythology1 = _b[0], mythology2 = _b[1];
+        switch (mythology2) {
+            case Mythology_1.Mythology.Greek:
+                return this.passTrialOnLocation(player, mythology1, function (location) { return location.y === 0; });
+            case Mythology_1.Mythology.Norse:
+                return this.passTrialOnLocation(player, mythology1, function (location) { return location.y === 1; });
+            case Mythology_1.Mythology.Egyptian:
+                return this.passTrialOnLocation(player, mythology1, function (location) { return location.x === 1; });
+            case Mythology_1.Mythology.Hindu:
+                return this.passTrialOnLocation(player, mythology1, function (location) { return location.y === 2; });
+            case Mythology_1.Mythology.Inca:
+                return this.passTrialOnLocation(player, mythology1, function (location) { return location.x === 0; });
+            case Mythology_1.Mythology.Chinese:
+                return (this.passTrialOnLocation(player, mythology1, function (location) { return location.x === location.y; }) ||
+                    this.passTrialOnLocation(player, mythology1, function (location) { return location.x === 2 - location.y; }));
+            case Mythology_1.Mythology.Zulu:
+                return this.passTrialOnLocation(player, mythology1, function (location) { return location.x === 2; });
+            case Mythology_1.Mythology.Celtic:
+                return (0, lodash_1.range)(0, 3).some(function (y) { return _this.passTrialOnLocation(player, mythology1, function (location) { return location.y === y; }); });
+        }
+    };
+    Trial.prototype.passTrialOnLocation = function (player, mythology, searchLocation) {
+        switch (mythology) {
+            case Mythology_1.Mythology.Greek:
+                return this.haveMoreInvokeFavorThanNeighbor(player, searchLocation);
+            case Mythology_1.Mythology.Norse:
+                return this.noEmptySpace(player, searchLocation) && this.countGods(player, searchLocation) >= 1;
+            case Mythology_1.Mythology.Egyptian:
+                return this.getPantheon(player).coveredEntities.location(searchLocation).length >= 2;
+            case Mythology_1.Mythology.Hindu:
+                return this.countGods(player, searchLocation) >= 2;
+            case Mythology_1.Mythology.Inca:
+                return this.countCreatures(player, searchLocation) === 0;
+            case Mythology_1.Mythology.Chinese:
+                return this.noEmptySpace(player, searchLocation) && this.getVisibleEntities(player).length <= 6;
+            case Mythology_1.Mythology.Zulu:
+                return (0, lodash_1.uniq)(this.getMythologies(player, searchLocation)).length >= 3;
+            case Mythology_1.Mythology.Celtic:
+                return this.getInvokeGemsGain(player, searchLocation) >= 3;
+        }
+    };
+    Trial.prototype.getPantheon = function (player) {
+        return new Pantheon_1.Pantheon(this.game, player);
+    };
+    Trial.prototype.getVisibleEntities = function (player, searchLocation) {
+        var visibleEntities = this.getPantheon(player).visibleEntities;
+        return searchLocation ? visibleEntities.location(searchLocation) : visibleEntities;
+    };
+    Trial.prototype.haveMoreInvokeFavorThanNeighbor = function (player, searchLocation) {
+        var _this = this;
+        var favor = this.getInvokeFavorGain(player, searchLocation);
+        return (0, rules_api_1.getNeighbors)(player, this.game.players).some(function (neighbor) { return _this.getInvokeFavorGain(neighbor, searchLocation) < favor; });
+    };
+    Trial.prototype.getInvokeGains = function (player, searchLocation) {
+        return this.getVisibleEntities(player, searchLocation)
+            .getItems()
+            .map(function (item) { return EntityDescription_1.entities[item.id.front].invoke[item.location.y]; });
+    };
+    Trial.prototype.getInvokeFavorGain = function (player, searchLocation) {
+        return (0, lodash_1.sumBy)(this.getInvokeGains(player, searchLocation), function (gain) { var _a; return (_a = gain.favor) !== null && _a !== void 0 ? _a : 0; });
+    };
+    Trial.prototype.getInvokeGemsGain = function (player, searchLocation) {
+        return (0, lodash_1.sumBy)(this.getInvokeGains(player, searchLocation), function (gain) { var _a; return (_a = gain.gem) !== null && _a !== void 0 ? _a : 0; });
+    };
+    Trial.prototype.noEmptySpace = function (player, searchLocation) {
+        return this.getPantheon(player).grid.every(function (line, y) { return line.every(function (space, x) { return space !== undefined || !searchLocation({ x: x, y: y }); }); });
+    };
+    Trial.prototype.countGods = function (player, searchLocation) {
+        return this.getVisibleEntities(player, searchLocation).id(function (id) { return (0, Entity_1.isGod)(id.front); }).length;
+    };
+    Trial.prototype.countCreatures = function (player, searchLocation) {
+        return this.getVisibleEntities(player, searchLocation).id(function (id) { return (0, Entity_1.isCreature)(id.front); }).length;
+    };
+    Trial.prototype.getMythologies = function (player, searchLocation) {
+        return this.getVisibleEntities(player, searchLocation)
+            .getItems()
+            .map(function (item) { return (0, Entity_1.entityMythology)(item.id.front); });
+    };
+    Trial.prototype.getTrialReward = function (_a) {
+        var _b = __read(_a, 2), mythology1 = _b[0], mythology2 = _b[1];
+        return this.getTrialLeftReward(mythology1) + this.getTrialRightReward(mythology2);
+    };
+    Trial.prototype.getTrialLeftReward = function (mythology) {
+        switch (mythology) {
+            case Mythology_1.Mythology.Greek:
+            case Mythology_1.Mythology.Norse:
+            case Mythology_1.Mythology.Egyptian:
+            case Mythology_1.Mythology.Inca:
+                return 1;
+            default:
+                return 2;
+        }
+    };
+    Trial.prototype.getTrialRightReward = function (mythology) {
+        switch (mythology) {
+            case Mythology_1.Mythology.Chinese:
+            case Mythology_1.Mythology.Zulu:
+            case Mythology_1.Mythology.Celtic:
+                return 1;
+            default:
+                return 2;
+        }
+    };
+    return Trial;
+}(rules_api_1.MaterialRulesPart));
+exports.Trial = Trial;

package/dist/material/entity/Effect.d.ts

@@ -0,0 +1,91 @@
+import { Location, Material, MaterialGame, MaterialItem, MaterialMove, PlayerTurnRule, SimultaneousRule } from '@gamepark/rules-api';
+import { PlayerColor } from '../../PlayerColor';
+import { RuleId } from '../../rules/RuleId';
+import { EntityId } from '../Entity';
+import { LocationType } from '../LocationType';
+import { MaterialType } from '../MaterialType';
+export type Effect = {
+    trigger: (event: TriggerEvent, card: Material, game: MaterialGame) => boolean;
+    rule: new (game: MaterialGame) => EffectRule;
+};
+interface EffectRule {
+    canPlayEffect(cardIndex: number): boolean;
+    playEffect(): MaterialMove[];
+}
+export declare abstract class PlayerEffectRule extends PlayerTurnRule implements EffectRule {
+    canPlayEffect(_cardIndex: number): boolean;
+    ruleId?: RuleId;
+    playEffect(): MaterialMove[];
+    onRuleStart(): MaterialMove<number, number, number, number>[];
+    get card(): MaterialItem<number, number, EntityId>;
+    getEffect<Event extends TriggerEvent>(): PendingEffect<Event>;
+    endEffect(): MaterialMove[];
+}
+export declare abstract class SimultaneousEffectRule extends SimultaneousRule implements EffectRule {
+    canPlayEffect(_cardIndex: number): boolean;
+    ruleId?: RuleId;
+    playEffect(): MaterialMove[];
+    getAffectedPlayers(): PlayerColor[];
+    isOpponent(player: PlayerColor): boolean;
+    get card(): MaterialItem<number, number, EntityId>;
+    getEffect<Event extends TriggerEvent>(): PendingEffect<Event>;
+    getMovesAfterPlayersDone(): MaterialMove[];
+}
+export declare enum TriggerEventType {
+    EndOfGame = 1,
+    SelfPlaced = 2,
+    EntityInvoked = 3,
+    LineBonusGain = 4,
+    ColumnBonusGain = 5,
+    Infinite = 6,
+    EntityCrushed = 7,
+    EntitySacrificed = 8
+}
+export type SelfPlaced = {
+    type: TriggerEventType.SelfPlaced;
+    location: Location;
+    crush: boolean;
+};
+export declare const isPlaced: (event: TriggerEvent) => event is SelfPlaced;
+export type EndOfGameEvent = {
+    type: TriggerEventType.EndOfGame;
+};
+export declare const isEndOfGame: (event: TriggerEvent) => event is EndOfGameEvent;
+export type EntityInvoked = {
+    type: TriggerEventType.EntityInvoked;
+    card: MaterialItem<MaterialType, LocationType, EntityId>;
+    cardIndex: number;
+};
+export type LineBonusGained = {
+    type: TriggerEventType.LineBonusGain;
+    player: PlayerColor;
+    y: number;
+};
+export type ColumnBonusGained = {
+    type: TriggerEventType.ColumnBonusGain;
+    player: PlayerColor;
+    x: number;
+};
+export type Infinite = {
+    type: TriggerEventType.Infinite;
+};
+export declare const oncePerTurn: (event: TriggerEvent) => event is Infinite;
+export declare const isPlacedCrush: (event: TriggerEvent) => event is SelfPlaced;
+export type EntityCrushed = {
+    type: TriggerEventType.EntityCrushed;
+    card: MaterialItem<MaterialType, LocationType, EntityId>;
+    cardIndex: number;
+};
+export declare const isCrushed: (event: TriggerEvent, card: Material) => event is EntityCrushed;
+export type EntitySacrificed = {
+    type: TriggerEventType.EntitySacrificed;
+    card: MaterialItem<MaterialType, LocationType, EntityId>;
+    cardIndex: number;
+};
+export type TriggerEvent = EndOfGameEvent | SelfPlaced | EntityInvoked | LineBonusGained | ColumnBonusGained | Infinite | EntityCrushed | EntitySacrificed;
+export type PendingEffect<Event extends TriggerEvent = TriggerEvent> = {
+    cardIndex: number;
+    effectIndex: number;
+    triggerEvent: Event;
+};
+export {};