@gamepark/zenith 0.0.1

package/dist/PlayerId.d.ts

@@ -0,0 +1 @@
+export type PlayerId = number;

package/dist/PlayerId.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/TeamColor.d.ts

@@ -0,0 +1,9 @@
+import { PlayerId } from './PlayerId';
+export declare enum TeamColor {
+    Black = 1,
+    White = 2
+}
+export declare const teamColors: TeamColor[];
+export declare const isWhite: (playerId: TeamColor) => playerId is TeamColor.White;
+export declare const isBlack: (playerId: TeamColor) => playerId is TeamColor.Black;
+export declare const getTeamColor: (playerId: PlayerId) => TeamColor;

package/dist/TeamColor.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTeamColor = exports.isBlack = exports.isWhite = exports.teamColors = exports.TeamColor = void 0;
+var rules_api_1 = require("@gamepark/rules-api");
+var TeamColor;
+(function (TeamColor) {
+    TeamColor[TeamColor["Black"] = 1] = "Black";
+    TeamColor[TeamColor["White"] = 2] = "White";
+})(TeamColor || (exports.TeamColor = TeamColor = {}));
+exports.teamColors = (0, rules_api_1.getEnumValues)(TeamColor);
+var isWhite = function (playerId) { return playerId === TeamColor.White; };
+exports.isWhite = isWhite;
+var isBlack = function (playerId) { return playerId === TeamColor.Black; };
+exports.isBlack = isBlack;
+var getTeamColor = function (playerId) { return (playerId === 1 || playerId === 4 ? TeamColor.White : TeamColor.Black); };
+exports.getTeamColor = getTeamColor;

package/dist/ZenithOptions.d.ts

@@ -0,0 +1,5 @@
+import { OptionsSpec } from '@gamepark/rules-api';
+export type ZenithOptions = {
+    players: number;
+};
+export declare const ZenithOptionsSpec: OptionsSpec<ZenithOptions>;

package/dist/ZenithOptions.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZenithOptionsSpec = void 0;
+exports.ZenithOptionsSpec = {};

package/dist/ZenithRules.d.ts

@@ -0,0 +1,68 @@
+import { CompetitiveRank, MaterialGame, MaterialMove, PositiveSequenceStrategy, SecretMaterialRules, TimeLimit } from '@gamepark/rules-api';
+import { LocationType } from './material/LocationType';
+import { MaterialType } from './material/MaterialType';
+import { PlayerId } from './PlayerId';
+import { DiscardActionRule } from './rules/DiscardActionRule';
+import { ChoiceRule, ConditionalRule, DevelopTechnologyRule, DiscardRule, ExileRule, GiveCreditRule, GiveInfluenceRule, GiveLeaderBadgeRule, GiveZenithiumRule, MobilizeRule, ResetInfluenceRule, SpendCreditRule, TakeBonusRule, TakeLeaderBadgeRule, TransferRule, WinCreditRule, WinInfluenceRule, WinZenithiumRule } from './rules/effect';
+import { SpendZenithiumRule } from './rules/effect/SpendZenithiumRule';
+import { StealCreditRule } from './rules/effect/StealCreditRule';
+import { TakeTechnologyBonusTokenRule } from './rules/effect/TakeTechnologyBonusTokenRule';
+import { MulliganRule } from './rules/MulliganRule';
+import { PlayCardRule } from './rules/PlayCardRule';
+import { RefillRule } from './rules/RefillRule';
+export declare class ZenithRules extends SecretMaterialRules<PlayerId, MaterialType, LocationType> implements CompetitiveRank<MaterialGame<PlayerId, MaterialType, LocationType>, MaterialMove<PlayerId, MaterialType, LocationType>, PlayerId>, TimeLimit<MaterialGame<PlayerId, MaterialType, LocationType>, MaterialMove<PlayerId, MaterialType, LocationType>> {
+    rules: {
+        1: typeof MulliganRule;
+        2: typeof PlayCardRule;
+        3: typeof DiscardActionRule;
+        4: typeof TransferRule;
+        5: typeof GiveCreditRule;
+        6: typeof WinCreditRule;
+        7: typeof SpendCreditRule;
+        8: typeof ConditionalRule;
+        9: typeof WinZenithiumRule;
+        10: typeof GiveZenithiumRule;
+        11: typeof ExileRule;
+        12: typeof WinInfluenceRule;
+        13: typeof GiveInfluenceRule;
+        14: typeof ResetInfluenceRule;
+        15: typeof DevelopTechnologyRule;
+        16: typeof GiveLeaderBadgeRule;
+        17: typeof TakeLeaderBadgeRule;
+        18: typeof DiscardRule;
+        19: typeof MobilizeRule;
+        20: typeof ChoiceRule;
+        21: typeof TakeBonusRule;
+        22: typeof RefillRule;
+        23: typeof StealCreditRule;
+        24: typeof SpendZenithiumRule;
+        25: typeof TakeTechnologyBonusTokenRule;
+    };
+    locationsStrategies: {
+        1: {
+            7: PositiveSequenceStrategy<number, number, number>;
+            6: PositiveSequenceStrategy<number, number, number>;
+            8: PositiveSequenceStrategy<number, number, number>;
+            10: PositiveSequenceStrategy<number, number, number>;
+        };
+        5: {
+            17: PositiveSequenceStrategy<number, number, number>;
+            18: PositiveSequenceStrategy<number, number, number>;
+        };
+        9: {
+            21: PositiveSequenceStrategy<number, number, number>;
+            14: PositiveSequenceStrategy<number, number, number>;
+        };
+    };
+    hidingStrategies: {
+        1: {
+            7: <P extends number = number, L extends number = number>(item: import("@gamepark/rules-api").MaterialItem<P, L>, player?: P) => string[];
+            6: import("@gamepark/rules-api").HidingStrategy<number, number>;
+        };
+        9: {
+            14: import("@gamepark/rules-api").HidingStrategy<number, number>;
+        };
+    };
+    rankPlayers(_playerA: PlayerId, _playerB: PlayerId): number;
+    giveTime(): number;
+}

package/dist/ZenithRules.js

@@ -0,0 +1,128 @@
+"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));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZenithRules = void 0;
+var rules_api_1 = require("@gamepark/rules-api");
+var LocationType_1 = require("./material/LocationType");
+var MaterialType_1 = require("./material/MaterialType");
+var DiscardActionRule_1 = require("./rules/DiscardActionRule");
+var effect_1 = require("./rules/effect");
+var SpendZenithiumRule_1 = require("./rules/effect/SpendZenithiumRule");
+var StealCreditRule_1 = require("./rules/effect/StealCreditRule");
+var TakeTechnologyBonusTokenRule_1 = require("./rules/effect/TakeTechnologyBonusTokenRule");
+var EndGameHelper_1 = require("./rules/helper/EndGameHelper");
+var MulliganRule_1 = require("./rules/MulliganRule");
+var PlayCardRule_1 = require("./rules/PlayCardRule");
+var RefillRule_1 = require("./rules/RefillRule");
+var RuleId_1 = require("./rules/RuleId");
+var TeamColor_1 = require("./TeamColor");
+var ZenithRules = (function (_super) {
+    __extends(ZenithRules, _super);
+    function ZenithRules() {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        var _this = _super.apply(this, __spreadArray([], __read(arguments), false)) || this;
+        _this.rules = (_a = {},
+            _a[RuleId_1.RuleId.Muligan] = MulliganRule_1.MulliganRule,
+            _a[RuleId_1.RuleId.PlayCard] = PlayCardRule_1.PlayCardRule,
+            _a[RuleId_1.RuleId.DiscardAction] = DiscardActionRule_1.DiscardActionRule,
+            _a[RuleId_1.RuleId.Transfer] = effect_1.TransferRule,
+            _a[RuleId_1.RuleId.GiveCredit] = effect_1.GiveCreditRule,
+            _a[RuleId_1.RuleId.WinCredit] = effect_1.WinCreditRule,
+            _a[RuleId_1.RuleId.SpendCredit] = effect_1.SpendCreditRule,
+            _a[RuleId_1.RuleId.Conditional] = effect_1.ConditionalRule,
+            _a[RuleId_1.RuleId.WinZenithium] = effect_1.WinZenithiumRule,
+            _a[RuleId_1.RuleId.GiveZenithium] = effect_1.GiveZenithiumRule,
+            _a[RuleId_1.RuleId.Exile] = effect_1.ExileRule,
+            _a[RuleId_1.RuleId.WinInfluence] = effect_1.WinInfluenceRule,
+            _a[RuleId_1.RuleId.GiveInfluence] = effect_1.GiveInfluenceRule,
+            _a[RuleId_1.RuleId.ResetInfluence] = effect_1.ResetInfluenceRule,
+            _a[RuleId_1.RuleId.DevelopTechnology] = effect_1.DevelopTechnologyRule,
+            _a[RuleId_1.RuleId.GiveLeaderBadge] = effect_1.GiveLeaderBadgeRule,
+            _a[RuleId_1.RuleId.TakeLeaderBadge] = effect_1.TakeLeaderBadgeRule,
+            _a[RuleId_1.RuleId.Discard] = effect_1.DiscardRule,
+            _a[RuleId_1.RuleId.Mobilize] = effect_1.MobilizeRule,
+            _a[RuleId_1.RuleId.Choice] = effect_1.ChoiceRule,
+            _a[RuleId_1.RuleId.TakeBonus] = effect_1.TakeBonusRule,
+            _a[RuleId_1.RuleId.Refill] = RefillRule_1.RefillRule,
+            _a[RuleId_1.RuleId.StealCredit] = StealCreditRule_1.StealCreditRule,
+            _a[RuleId_1.RuleId.SpendZenithium] = SpendZenithiumRule_1.SpendZenithiumRule,
+            _a[RuleId_1.RuleId.TakeTechnologyBonusToken] = TakeTechnologyBonusTokenRule_1.TakeTechnologyBonusTokenRule,
+            _a);
+        _this.locationsStrategies = (_b = {},
+            _b[MaterialType_1.MaterialType.AgentCard] = (_c = {},
+                _c[LocationType_1.LocationType.PlayerHand] = new rules_api_1.PositiveSequenceStrategy(),
+                _c[LocationType_1.LocationType.AgentDeck] = new rules_api_1.PositiveSequenceStrategy(),
+                _c[LocationType_1.LocationType.AgentDiscard] = new rules_api_1.PositiveSequenceStrategy(),
+                _c[LocationType_1.LocationType.Influence] = new rules_api_1.PositiveSequenceStrategy(),
+                _c),
+            _b[MaterialType_1.MaterialType.InfluenceDisc] = (_d = {},
+                _d[LocationType_1.LocationType.TeamPlanets] = new rules_api_1.PositiveSequenceStrategy(),
+                _d[LocationType_1.LocationType.InfluenceDiscStock] = new rules_api_1.PositiveSequenceStrategy(),
+                _d),
+            _b[MaterialType_1.MaterialType.BonusToken] = (_e = {},
+                _e[LocationType_1.LocationType.BonusDiscard] = new rules_api_1.PositiveSequenceStrategy(),
+                _e[LocationType_1.LocationType.BonusTokenStock] = new rules_api_1.PositiveSequenceStrategy(),
+                _e),
+            _b);
+        _this.hidingStrategies = (_f = {},
+            _f[MaterialType_1.MaterialType.AgentCard] = (_g = {},
+                _g[LocationType_1.LocationType.PlayerHand] = rules_api_1.hideItemIdToOthers,
+                _g[LocationType_1.LocationType.AgentDeck] = rules_api_1.hideItemId,
+                _g),
+            _f[MaterialType_1.MaterialType.BonusToken] = (_h = {},
+                _h[LocationType_1.LocationType.BonusTokenStock] = rules_api_1.hideItemId,
+                _h),
+            _f);
+        return _this;
+    }
+    ZenithRules.prototype.rankPlayers = function (_playerA, _playerB) {
+        var winners = new EndGameHelper_1.EndGameHelper(this.game).winningTeam;
+        if ((0, TeamColor_1.getTeamColor)(_playerA) === winners)
+            return 1;
+        return -1;
+    };
+    ZenithRules.prototype.giveTime = function () {
+        return 60;
+    };
+    return ZenithRules;
+}(rules_api_1.SecretMaterialRules));
+exports.ZenithRules = ZenithRules;

package/dist/ZenithSetup.d.ts

@@ -0,0 +1,24 @@
+import { MaterialDeck, MaterialGameSetup } from '@gamepark/rules-api';
+import { Influence } from './material/Influence';
+import { LocationType } from './material/LocationType';
+import { MaterialType } from './material/MaterialType';
+import { PlayerId } from './PlayerId';
+import { TeamColor } from './TeamColor';
+import { ZenithOptions } from './ZenithOptions';
+import { ZenithRules } from './ZenithRules';
+export declare class ZenithSetup extends MaterialGameSetup<PlayerId, MaterialType, LocationType, ZenithOptions> {
+    Rules: typeof ZenithRules;
+    setupMaterial(_options: ZenithOptions): void;
+    setupBonuses(): void;
+    setupInfluenceDisc(): void;
+    setupLeaderBadge(): void;
+    setupInfluences(): void;
+    getPlanetStartPosition(planet: Influence): 0 | -1;
+    setupDeck(): void;
+    setupPlayers(): void;
+    setupTechnologyBoard(): void;
+    setupPlayer(deck: MaterialDeck, player: PlayerId): void;
+    setupTeams(): void;
+    setupTeam(team: TeamColor): void;
+    start(): void;
+}

package/dist/ZenithSetup.js

@@ -0,0 +1,316 @@
+"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.");
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZenithSetup = void 0;
+var rules_api_1 = require("@gamepark/rules-api");
+var lodash_1 = require("lodash");
+var shuffle_1 = __importDefault(require("lodash/shuffle"));
+var Agent_1 = require("./material/Agent");
+var Bonus_1 = require("./material/Bonus");
+var Credit_1 = require("./material/Credit");
+var Faction_1 = require("./material/Faction");
+var Influence_1 = require("./material/Influence");
+var LocationType_1 = require("./material/LocationType");
+var MaterialType_1 = require("./material/MaterialType");
+var Memory_1 = require("./rules/Memory");
+var RuleId_1 = require("./rules/RuleId");
+var TeamColor_1 = require("./TeamColor");
+var ZenithRules_1 = require("./ZenithRules");
+var ZenithSetup = (function (_super) {
+    __extends(ZenithSetup, _super);
+    function ZenithSetup() {
+        var _this = _super.apply(this, __spreadArray([], __read(arguments), false)) || this;
+        _this.Rules = ZenithRules_1.ZenithRules;
+        return _this;
+    }
+    ZenithSetup.prototype.setupMaterial = function (_options) {
+        this.setupDeck();
+        this.setupPlayers();
+        this.setupInfluences();
+        this.setupLeaderBadge();
+        this.setupTechnologyBoard();
+        this.setupTeams();
+        this.setupInfluenceDisc();
+        this.setupBonuses();
+    };
+    ZenithSetup.prototype.setupBonuses = function () {
+        var e_1, _a, e_2, _b, e_3, _c;
+        var shuffledBonuses = (0, shuffle_1.default)(Bonus_1.allBonuses);
+        try {
+            for (var influences_1 = __values(Influence_1.influences), influences_1_1 = influences_1.next(); !influences_1_1.done; influences_1_1 = influences_1.next()) {
+                var influence = influences_1_1.value;
+                var bonus = shuffledBonuses.shift();
+                this.material(MaterialType_1.MaterialType.BonusToken).createItem({
+                    id: bonus,
+                    location: {
+                        type: LocationType_1.LocationType.PlanetBoardBonusSpace,
+                        id: influence
+                    }
+                });
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (influences_1_1 && !influences_1_1.done && (_a = influences_1.return)) _a.call(influences_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        var technologyBoards = this.material(MaterialType_1.MaterialType.TechnologyBoard).getIndexes();
+        try {
+            for (var technologyBoards_1 = __values(technologyBoards), technologyBoards_1_1 = technologyBoards_1.next(); !technologyBoards_1_1.done; technologyBoards_1_1 = technologyBoards_1.next()) {
+                var technologyBoardIndex = technologyBoards_1_1.value;
+                this.material(MaterialType_1.MaterialType.BonusToken).createItem({
+                    id: shuffledBonuses.shift(),
+                    location: {
+                        type: LocationType_1.LocationType.TechnologyBoardBonusSpace,
+                        parent: technologyBoardIndex,
+                        x: 2
+                    }
+                });
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (technologyBoards_1_1 && !technologyBoards_1_1.done && (_b = technologyBoards_1.return)) _b.call(technologyBoards_1);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        try {
+            for (var shuffledBonuses_1 = __values(shuffledBonuses), shuffledBonuses_1_1 = shuffledBonuses_1.next(); !shuffledBonuses_1_1.done; shuffledBonuses_1_1 = shuffledBonuses_1.next()) {
+                var bonus = shuffledBonuses_1_1.value;
+                this.material(MaterialType_1.MaterialType.BonusToken).createItem({
+                    id: bonus,
+                    location: {
+                        type: LocationType_1.LocationType.BonusTokenStock
+                    }
+                });
+            }
+        }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (shuffledBonuses_1_1 && !shuffledBonuses_1_1.done && (_c = shuffledBonuses_1.return)) _c.call(shuffledBonuses_1);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
+    };
+    ZenithSetup.prototype.setupInfluenceDisc = function () {
+        var e_4, _a;
+        var _this = this;
+        var _loop_1 = function (influence) {
+            (0, lodash_1.times)(3, function () {
+                _this.material(MaterialType_1.MaterialType.InfluenceDisc).createItem({
+                    id: influence,
+                    location: {
+                        type: LocationType_1.LocationType.InfluenceDiscStock,
+                        id: influence
+                    }
+                });
+            });
+        };
+        try {
+            for (var influences_2 = __values(Influence_1.influences), influences_2_1 = influences_2.next(); !influences_2_1.done; influences_2_1 = influences_2.next()) {
+                var influence = influences_2_1.value;
+                _loop_1(influence);
+            }
+        }
+        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+        finally {
+            try {
+                if (influences_2_1 && !influences_2_1.done && (_a = influences_2.return)) _a.call(influences_2);
+            }
+            finally { if (e_4) throw e_4.error; }
+        }
+    };
+    ZenithSetup.prototype.setupLeaderBadge = function () {
+        this.material(MaterialType_1.MaterialType.LeaderBadgeToken).createItem({
+            location: {
+                type: LocationType_1.LocationType.DiplomacyBoardLeaderBadgeSpace
+            }
+        });
+    };
+    ZenithSetup.prototype.setupInfluences = function () {
+        var e_5, _a;
+        try {
+            for (var influences_3 = __values(Influence_1.influences), influences_3_1 = influences_3.next(); !influences_3_1.done; influences_3_1 = influences_3.next()) {
+                var planet = influences_3_1.value;
+                this.material(MaterialType_1.MaterialType.InfluenceDisc).createItem({
+                    id: planet,
+                    location: {
+                        type: LocationType_1.LocationType.PlanetBoardInfluenceDiscSpace,
+                        id: planet,
+                        x: this.getPlanetStartPosition(planet)
+                    }
+                });
+            }
+        }
+        catch (e_5_1) { e_5 = { error: e_5_1 }; }
+        finally {
+            try {
+                if (influences_3_1 && !influences_3_1.done && (_a = influences_3.return)) _a.call(influences_3);
+            }
+            finally { if (e_5) throw e_5.error; }
+        }
+    };
+    ZenithSetup.prototype.getPlanetStartPosition = function (planet) {
+        if (planet === Influence_1.Influence.Terra)
+            return -1;
+        return 0;
+    };
+    ZenithSetup.prototype.setupDeck = function () {
+        var shuffledAgents = (0, shuffle_1.default)(Agent_1.agents);
+        this.material(MaterialType_1.MaterialType.AgentCard).createItems(shuffledAgents.map(function (agent) { return ({
+            id: agent,
+            location: {
+                type: LocationType_1.LocationType.AgentDeck
+            }
+        }); }));
+    };
+    ZenithSetup.prototype.setupPlayers = function () {
+        var e_6, _a;
+        var deck = this.material(MaterialType_1.MaterialType.AgentCard).location(LocationType_1.LocationType.AgentDeck).deck();
+        try {
+            for (var _b = __values(this.game.players), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var player = _c.value;
+                this.setupPlayer(deck, player);
+            }
+        }
+        catch (e_6_1) { e_6 = { error: e_6_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_6) throw e_6.error; }
+        }
+    };
+    ZenithSetup.prototype.setupTechnologyBoard = function () {
+        var e_7, _a;
+        var boards = ['S', 'U', 'N'];
+        for (var i = 0; i < boards.length; i++) {
+            var current = boards[i];
+            this.material(MaterialType_1.MaterialType.TechnologyBoard).createItem({ id: current, location: { type: LocationType_1.LocationType.TechnologyBoardPlace, id: Faction_1.factions[i] } });
+            try {
+                for (var teamColors_1 = (e_7 = void 0, __values(TeamColor_1.teamColors)), teamColors_1_1 = teamColors_1.next(); !teamColors_1_1.done; teamColors_1_1 = teamColors_1.next()) {
+                    var color = teamColors_1_1.value;
+                    this.material(MaterialType_1.MaterialType.TechMarker).createItem({
+                        id: color,
+                        location: {
+                            type: LocationType_1.LocationType.TechnologyBoardTokenSpace,
+                            parent: this.material(MaterialType_1.MaterialType.TechnologyBoard).id(current).getIndex(),
+                            player: color,
+                            x: 0
+                        }
+                    });
+                }
+            }
+            catch (e_7_1) { e_7 = { error: e_7_1 }; }
+            finally {
+                try {
+                    if (teamColors_1_1 && !teamColors_1_1.done && (_a = teamColors_1.return)) _a.call(teamColors_1);
+                }
+                finally { if (e_7) throw e_7.error; }
+            }
+        }
+    };
+    ZenithSetup.prototype.setupPlayer = function (deck, player) {
+        deck.deal({
+            type: LocationType_1.LocationType.PlayerHand,
+            player: player
+        }, 4);
+    };
+    ZenithSetup.prototype.setupTeams = function () {
+        this.setupTeam(TeamColor_1.TeamColor.White);
+        this.setupTeam(TeamColor_1.TeamColor.Black);
+    };
+    ZenithSetup.prototype.setupTeam = function (team) {
+        this.material(MaterialType_1.MaterialType.CreditToken).createItem({
+            id: Credit_1.Credit.Credit1,
+            location: {
+                type: LocationType_1.LocationType.TeamCredit,
+                player: team
+            },
+            quantity: 4
+        });
+        this.material(MaterialType_1.MaterialType.CreditToken).createItem({
+            id: Credit_1.Credit.Credit3,
+            location: {
+                type: LocationType_1.LocationType.TeamCredit,
+                player: team
+            }
+        });
+        this.material(MaterialType_1.MaterialType.CreditToken).createItem({
+            id: Credit_1.Credit.Credit5,
+            location: {
+                type: LocationType_1.LocationType.TeamCredit,
+                player: team
+            }
+        });
+        this.material(MaterialType_1.MaterialType.ZenithiumToken).createItem({
+            location: {
+                type: LocationType_1.LocationType.TeamZenithium,
+                player: team
+            }
+        });
+    };
+    ZenithSetup.prototype.start = function () {
+        this.memorize(Memory_1.Memory.TurnOrder, (0, shuffle_1.default)(this.game.players));
+        this.startSimultaneousRule(RuleId_1.RuleId.Muligan);
+    };
+    return ZenithSetup;
+}(rules_api_1.MaterialGameSetup));
+exports.ZenithSetup = ZenithSetup;

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { ZenithRules } from './ZenithRules';
+export { ZenithOptionsSpec } from './ZenithOptions';
+export { ZenithSetup } from './ZenithSetup';

package/dist/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZenithSetup = exports.ZenithOptionsSpec = exports.ZenithRules = void 0;
+var ZenithRules_1 = require("./ZenithRules");
+Object.defineProperty(exports, "ZenithRules", { enumerable: true, get: function () { return ZenithRules_1.ZenithRules; } });
+var ZenithOptions_1 = require("./ZenithOptions");
+Object.defineProperty(exports, "ZenithOptionsSpec", { enumerable: true, get: function () { return ZenithOptions_1.ZenithOptionsSpec; } });
+var ZenithSetup_1 = require("./ZenithSetup");
+Object.defineProperty(exports, "ZenithSetup", { enumerable: true, get: function () { return ZenithSetup_1.ZenithSetup; } });