@gamepark/zenith 0.0.1

package/dist/rules/helper/TechnologyHelper.js

@@ -0,0 +1,96 @@
+"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 __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TechnologyHelper = void 0;
+var rules_api_1 = require("@gamepark/rules-api");
+var LocationType_1 = require("../../material/LocationType");
+var MaterialType_1 = require("../../material/MaterialType");
+var TechnologyActions_1 = require("../discard-action/TechnologyActions");
+var Memory_1 = require("../Memory");
+var TechnologyHelper = (function (_super) {
+    __extends(TechnologyHelper, _super);
+    function TechnologyHelper() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    TechnologyHelper.prototype.applyTechnology = function (move) {
+        var board = this.material(MaterialType_1.MaterialType.TechnologyBoard).getItem(move.location.parent);
+        var actions = (0, TechnologyActions_1.getTechnologyAction)(board.id);
+        this.memorize(Memory_1.Memory.Effects, function (effects) {
+            if (effects === void 0) { effects = []; }
+            var newEffects = JSON.parse(JSON.stringify(actions.slice(0, move.location.x).reverse()));
+            effects.push.apply(effects, __spreadArray([], __read(newEffects.flat().map(function (e) { return (__assign(__assign({}, e), { effectSource: {
+                    type: MaterialType_1.MaterialType.TechnologyBoard,
+                    value: board.location.id
+                } })); })), false));
+            return effects;
+        });
+        var hasLine = this.material(MaterialType_1.MaterialType.TechMarker)
+            .location(LocationType_1.LocationType.TechnologyBoardTokenSpace)
+            .player(move.location.player)
+            .filter(function (item) { return item.location.x >= move.location.x; }).length === 3;
+        if (hasLine && TechnologyActions_1.TechnologyLineBonuses[move.location.x - 1]) {
+            this.memorize(Memory_1.Memory.Effects, function (effects) {
+                if (effects === void 0) { effects = []; }
+                var effect = JSON.parse(JSON.stringify(TechnologyActions_1.TechnologyLineBonuses[move.location.x - 1]));
+                effects.push(__assign(__assign({}, effect), { effectSource: {
+                        type: MaterialType_1.MaterialType.TechnologyBoard,
+                        value: board.location.id
+                    } }));
+                return effects;
+            });
+        }
+        return [];
+    };
+    return TechnologyHelper;
+}(rules_api_1.PlayerTurnRule));
+exports.TechnologyHelper = TechnologyHelper;

package/dist/rules/helper/ZenithiumHelper.d.ts

@@ -0,0 +1,10 @@
+import { MaterialGame, MaterialMove, MaterialRulesPart } from '@gamepark/rules-api';
+import { PlayerId } from '../../PlayerId';
+export declare class ZenithiumHelper extends MaterialRulesPart {
+    readonly player: PlayerId;
+    private playerHelper;
+    constructor(game: MaterialGame, player: PlayerId);
+    winZenithium(count?: number): MaterialMove[];
+    giveZenithium(to: PlayerId, count?: number): MaterialMove[];
+    spendZenithium(count?: number): MaterialMove[];
+}

package/dist/rules/helper/ZenithiumHelper.js

@@ -0,0 +1,59 @@
+"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.ZenithiumHelper = void 0;
+var rules_api_1 = require("@gamepark/rules-api");
+var LocationType_1 = require("../../material/LocationType");
+var MaterialType_1 = require("../../material/MaterialType");
+var PlayerHelper_1 = require("./PlayerHelper");
+var ZenithiumHelper = (function (_super) {
+    __extends(ZenithiumHelper, _super);
+    function ZenithiumHelper(game, player) {
+        var _this = _super.call(this, game) || this;
+        _this.player = player;
+        _this.playerHelper = new PlayerHelper_1.PlayerHelper(game, player);
+        return _this;
+    }
+    ZenithiumHelper.prototype.winZenithium = function (count) {
+        if (count === void 0) { count = 1; }
+        return [
+            this.material(MaterialType_1.MaterialType.ZenithiumToken).createItem({
+                location: {
+                    type: LocationType_1.LocationType.TeamZenithium,
+                    player: this.playerHelper.team
+                },
+                quantity: count
+            })
+        ];
+    };
+    ZenithiumHelper.prototype.giveZenithium = function (to, count) {
+        if (count === void 0) { count = 1; }
+        return this.material(MaterialType_1.MaterialType.ZenithiumToken)
+            .location(LocationType_1.LocationType.TeamZenithium)
+            .player(this.playerHelper.team)
+            .moveItems({
+            type: LocationType_1.LocationType.TeamZenithium,
+            player: new PlayerHelper_1.PlayerHelper(this.game, to).team
+        }, count);
+    };
+    ZenithiumHelper.prototype.spendZenithium = function (count) {
+        if (count === void 0) { count = 1; }
+        return this.material(MaterialType_1.MaterialType.ZenithiumToken).location(LocationType_1.LocationType.TeamZenithium).player(this.playerHelper.team).deleteItems(count);
+    };
+    return ZenithiumHelper;
+}(rules_api_1.MaterialRulesPart));
+exports.ZenithiumHelper = ZenithiumHelper;

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@gamepark/zenith",
+  "version": "0.0.1",
+  "description": "The rules of Zenith adapted for Game Park",
+  "sideEffects": false,
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "author": "Romain Fromi <romain@game-park.com> (https://game-park.com/)",
+  "license": "ISC",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "tsc",
+    "publish": "lerna publish",
+    "lint": "eslint --fix"
+  },
+  "peerDependencies": {
+    "@gamepark/rules-api": ">=6.33",
+    "lodash": ">=4.17"
+  },
+  "devDependencies": {
+    "@gamepark/rules-api": "~6.36.7",
+    "@types/lodash": "^4.17.7",
+    "i18next": "^22.0.3",
+    "lodash": "^4.17.21"
+  },
+  "gitHead": "2e48797e96fea5d8bd82532fd97ee26242c7246f"
+}