@gamepark/zenith 0.0.1

package/dist/material/Bonus.d.ts

@@ -0,0 +1,12 @@
+export declare enum Bonus {
+    Exile2OpponentCards = 1,
+    Mobilize2 = 2,
+    TakeLeaderBadge = 3,
+    Transfer = 4,
+    Win1Zenithium = 5,
+    Win3Credits = 6,
+    Win4Credits = 7,
+    WinInfluence = 8
+}
+export declare const allBonuses: Bonus[];
+export declare const bonuses: Bonus[];

package/dist/material/Bonus.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bonuses = exports.allBonuses = exports.Bonus = void 0;
+var rules_api_1 = require("@gamepark/rules-api");
+var Bonus;
+(function (Bonus) {
+    Bonus[Bonus["Exile2OpponentCards"] = 1] = "Exile2OpponentCards";
+    Bonus[Bonus["Mobilize2"] = 2] = "Mobilize2";
+    Bonus[Bonus["TakeLeaderBadge"] = 3] = "TakeLeaderBadge";
+    Bonus[Bonus["Transfer"] = 4] = "Transfer";
+    Bonus[Bonus["Win1Zenithium"] = 5] = "Win1Zenithium";
+    Bonus[Bonus["Win3Credits"] = 6] = "Win3Credits";
+    Bonus[Bonus["Win4Credits"] = 7] = "Win4Credits";
+    Bonus[Bonus["WinInfluence"] = 8] = "WinInfluence";
+})(Bonus || (exports.Bonus = Bonus = {}));
+exports.allBonuses = [
+    Bonus.WinInfluence,
+    Bonus.WinInfluence,
+    Bonus.WinInfluence,
+    Bonus.WinInfluence,
+    Bonus.Win3Credits,
+    Bonus.Win3Credits,
+    Bonus.Win4Credits,
+    Bonus.Win4Credits,
+    Bonus.Win1Zenithium,
+    Bonus.Win1Zenithium,
+    Bonus.Win1Zenithium,
+    Bonus.Exile2OpponentCards,
+    Bonus.Mobilize2,
+    Bonus.Transfer,
+    Bonus.TakeLeaderBadge,
+    Bonus.TakeLeaderBadge
+];
+exports.bonuses = (0, rules_api_1.getEnumValues)(Bonus);

package/dist/material/Bonuses.d.ts

@@ -0,0 +1,14 @@
+import { Bonus } from './Bonus';
+import { Effect } from './effect/Effect';
+export type BonusDescription = {
+    effect: Effect;
+};
+export declare const Exile2OpponentCards: BonusDescription;
+export declare const Mobilize2: BonusDescription;
+export declare const TakeLeaderBadge: BonusDescription;
+export declare const Transfer: BonusDescription;
+export declare const Win1Zenithium: BonusDescription;
+export declare const Win3Credit: BonusDescription;
+export declare const Win4Credits: BonusDescription;
+export declare const WinInfluence: BonusDescription;
+export declare const Bonuses: Record<Bonus, BonusDescription>;

package/dist/material/Bonuses.js

@@ -0,0 +1,63 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Bonuses = exports.WinInfluence = exports.Win4Credits = exports.Win3Credit = exports.Win1Zenithium = exports.Transfer = exports.TakeLeaderBadge = exports.Mobilize2 = exports.Exile2OpponentCards = void 0;
+var Bonus_1 = require("./Bonus");
+var EffectType_1 = require("./effect/EffectType");
+exports.Exile2OpponentCards = {
+    effect: {
+        type: EffectType_1.EffectType.Exile,
+        quantity: 2,
+        opponent: true
+    }
+};
+exports.Mobilize2 = {
+    effect: {
+        type: EffectType_1.EffectType.Mobilize,
+        quantity: 2
+    }
+};
+exports.TakeLeaderBadge = {
+    effect: {
+        type: EffectType_1.EffectType.TakeLeaderBadge
+    }
+};
+exports.Transfer = {
+    effect: {
+        type: EffectType_1.EffectType.Transfer
+    }
+};
+exports.Win1Zenithium = {
+    effect: {
+        type: EffectType_1.EffectType.WinZenithium,
+        quantity: 1
+    }
+};
+exports.Win3Credit = {
+    effect: {
+        type: EffectType_1.EffectType.WinCredit,
+        quantity: 3
+    }
+};
+exports.Win4Credits = {
+    effect: {
+        type: EffectType_1.EffectType.WinCredit,
+        quantity: 4
+    }
+};
+exports.WinInfluence = {
+    effect: {
+        type: EffectType_1.EffectType.WinInfluence,
+        quantity: 1
+    }
+};
+exports.Bonuses = (_a = {},
+    _a[Bonus_1.Bonus.Exile2OpponentCards] = exports.Exile2OpponentCards,
+    _a[Bonus_1.Bonus.Mobilize2] = exports.Mobilize2,
+    _a[Bonus_1.Bonus.TakeLeaderBadge] = exports.TakeLeaderBadge,
+    _a[Bonus_1.Bonus.Transfer] = exports.Transfer,
+    _a[Bonus_1.Bonus.Win1Zenithium] = exports.Win1Zenithium,
+    _a[Bonus_1.Bonus.Win3Credits] = exports.Win3Credit,
+    _a[Bonus_1.Bonus.Win4Credits] = exports.Win4Credits,
+    _a[Bonus_1.Bonus.WinInfluence] = exports.WinInfluence,
+    _a);

package/dist/material/Credit.d.ts

@@ -0,0 +1,6 @@
+export declare enum Credit {
+    Credit1 = 1,
+    Credit3 = 3,
+    Credit5 = 5
+}
+export declare const credits: Credit[];

package/dist/material/Credit.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.credits = exports.Credit = void 0;
+var rules_api_1 = require("@gamepark/rules-api");
+var Credit;
+(function (Credit) {
+    Credit[Credit["Credit1"] = 1] = "Credit1";
+    Credit[Credit["Credit3"] = 3] = "Credit3";
+    Credit[Credit["Credit5"] = 5] = "Credit5";
+})(Credit || (exports.Credit = Credit = {}));
+exports.credits = (0, rules_api_1.getEnumValues)(Credit);

package/dist/material/Faction.d.ts

@@ -0,0 +1,6 @@
+export declare enum Faction {
+    Animod = 1,
+    Human = 2,
+    Robot = 3
+}
+export declare const factions: Faction[];

package/dist/material/Faction.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.factions = exports.Faction = void 0;
+var rules_api_1 = require("@gamepark/rules-api");
+var Faction;
+(function (Faction) {
+    Faction[Faction["Animod"] = 1] = "Animod";
+    Faction[Faction["Human"] = 2] = "Human";
+    Faction[Faction["Robot"] = 3] = "Robot";
+})(Faction || (exports.Faction = Faction = {}));
+exports.factions = (0, rules_api_1.getEnumValues)(Faction);

package/dist/material/Influence.d.ts

@@ -0,0 +1,8 @@
+export declare enum Influence {
+    Mercury = 1,
+    Venus = 2,
+    Terra = 3,
+    Mars = 4,
+    Jupiter = 5
+}
+export declare const influences: Influence[];

package/dist/material/Influence.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.influences = exports.Influence = void 0;
+var rules_api_1 = require("@gamepark/rules-api");
+var Influence;
+(function (Influence) {
+    Influence[Influence["Mercury"] = 1] = "Mercury";
+    Influence[Influence["Venus"] = 2] = "Venus";
+    Influence[Influence["Terra"] = 3] = "Terra";
+    Influence[Influence["Mars"] = 4] = "Mars";
+    Influence[Influence["Jupiter"] = 5] = "Jupiter";
+})(Influence || (exports.Influence = Influence = {}));
+exports.influences = (0, rules_api_1.getEnumValues)(Influence);

package/dist/material/LocationType.d.ts

@@ -0,0 +1,23 @@
+export declare enum LocationType {
+    PlanetBoardPlace = 1,
+    TechnologyBoardPlace = 2,
+    DiplomacyBoardPlace = 3,
+    PlanetBoardInfluenceDiscSpace = 4,
+    TechnologyBoardTokenSpace = 5,
+    AgentDeck = 6,
+    PlayerHand = 7,
+    AgentDiscard = 8,
+    DiplomacyBoardLeaderBadgeSpace = 9,
+    Influence = 10,
+    TeamCredit = 11,
+    TeamZenithium = 12,
+    TeamLeaderBadge = 13,
+    BonusTokenStock = 14,
+    PlanetBoardBonusSpace = 15,
+    TechnologyBoardBonusSpace = 16,
+    TeamPlanets = 17,
+    InfluenceDiscStock = 18,
+    ZenithiumStock = 19,
+    CreditStock = 20,
+    BonusDiscard = 21
+}

package/dist/material/LocationType.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocationType = void 0;
+var LocationType;
+(function (LocationType) {
+    LocationType[LocationType["PlanetBoardPlace"] = 1] = "PlanetBoardPlace";
+    LocationType[LocationType["TechnologyBoardPlace"] = 2] = "TechnologyBoardPlace";
+    LocationType[LocationType["DiplomacyBoardPlace"] = 3] = "DiplomacyBoardPlace";
+    LocationType[LocationType["PlanetBoardInfluenceDiscSpace"] = 4] = "PlanetBoardInfluenceDiscSpace";
+    LocationType[LocationType["TechnologyBoardTokenSpace"] = 5] = "TechnologyBoardTokenSpace";
+    LocationType[LocationType["AgentDeck"] = 6] = "AgentDeck";
+    LocationType[LocationType["PlayerHand"] = 7] = "PlayerHand";
+    LocationType[LocationType["AgentDiscard"] = 8] = "AgentDiscard";
+    LocationType[LocationType["DiplomacyBoardLeaderBadgeSpace"] = 9] = "DiplomacyBoardLeaderBadgeSpace";
+    LocationType[LocationType["Influence"] = 10] = "Influence";
+    LocationType[LocationType["TeamCredit"] = 11] = "TeamCredit";
+    LocationType[LocationType["TeamZenithium"] = 12] = "TeamZenithium";
+    LocationType[LocationType["TeamLeaderBadge"] = 13] = "TeamLeaderBadge";
+    LocationType[LocationType["BonusTokenStock"] = 14] = "BonusTokenStock";
+    LocationType[LocationType["PlanetBoardBonusSpace"] = 15] = "PlanetBoardBonusSpace";
+    LocationType[LocationType["TechnologyBoardBonusSpace"] = 16] = "TechnologyBoardBonusSpace";
+    LocationType[LocationType["TeamPlanets"] = 17] = "TeamPlanets";
+    LocationType[LocationType["InfluenceDiscStock"] = 18] = "InfluenceDiscStock";
+    LocationType[LocationType["ZenithiumStock"] = 19] = "ZenithiumStock";
+    LocationType[LocationType["CreditStock"] = 20] = "CreditStock";
+    LocationType[LocationType["BonusDiscard"] = 21] = "BonusDiscard";
+})(LocationType || (exports.LocationType = LocationType = {}));

package/dist/material/MaterialType.d.ts

@@ -0,0 +1,12 @@
+export declare enum MaterialType {
+    AgentCard = 1,
+    TechnologyBoard = 2,
+    PlanetBoard = 3,
+    DiplomacyBoard = 4,
+    InfluenceDisc = 5,
+    TechMarker = 6,
+    ZenithiumToken = 7,
+    CreditToken = 8,
+    BonusToken = 9,
+    LeaderBadgeToken = 10
+}

package/dist/material/MaterialType.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MaterialType = void 0;
+var MaterialType;
+(function (MaterialType) {
+    MaterialType[MaterialType["AgentCard"] = 1] = "AgentCard";
+    MaterialType[MaterialType["TechnologyBoard"] = 2] = "TechnologyBoard";
+    MaterialType[MaterialType["PlanetBoard"] = 3] = "PlanetBoard";
+    MaterialType[MaterialType["DiplomacyBoard"] = 4] = "DiplomacyBoard";
+    MaterialType[MaterialType["InfluenceDisc"] = 5] = "InfluenceDisc";
+    MaterialType[MaterialType["TechMarker"] = 6] = "TechMarker";
+    MaterialType[MaterialType["ZenithiumToken"] = 7] = "ZenithiumToken";
+    MaterialType[MaterialType["CreditToken"] = 8] = "CreditToken";
+    MaterialType[MaterialType["BonusToken"] = 9] = "BonusToken";
+    MaterialType[MaterialType["LeaderBadgeToken"] = 10] = "LeaderBadgeToken";
+})(MaterialType || (exports.MaterialType = MaterialType = {}));

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

@@ -0,0 +1,144 @@
+import { Faction } from '../Faction';
+import { Influence } from '../Influence';
+import { MaterialType } from '../MaterialType';
+import { EffectType } from './EffectType';
+export declare enum ConditionType {
+    DoEffect = 0,
+    Leader = 1,
+    HaveCredits = 2
+}
+export type LeaderCondition = {
+    type: ConditionType.Leader;
+};
+export type HaveCreditsCondition = {
+    type: ConditionType.HaveCredits;
+    min: number;
+};
+export type DoEffectCondition = {
+    type: ConditionType.DoEffect;
+    effect: Effect;
+};
+export type Condition = DoEffectCondition | LeaderCondition | HaveCreditsCondition;
+export type ConditionalEffect = {
+    type: EffectType.Conditional;
+    mandatory?: boolean;
+    condition: Condition;
+    effect: Effect;
+};
+export type SpendCreditEffect = {
+    type: EffectType.SpendCredit;
+    factors: number[];
+    quantities: number[];
+    quantity?: number;
+};
+export type SpendZenithiumEffect = {
+    type: EffectType.SpendZenithium;
+    factors: number[];
+    quantities: number[];
+    quantity?: number;
+};
+export type WinCreditEffect = {
+    type: EffectType.WinCredit;
+    quantity?: number;
+    factorPerDifferentOpponentInfluence?: number;
+    factorPerDifferentInfluence?: number;
+    perLevel1Technology?: number[];
+    opponent?: boolean;
+};
+export type GiveCreditEffect = {
+    type: EffectType.GiveCredit;
+    quantity: number;
+};
+export type StealCreditEffect = {
+    type: EffectType.StealCredit;
+    quantity: number;
+};
+export type TransferEffect = {
+    type: EffectType.Transfer;
+    influence?: Influence;
+    quantity?: number;
+};
+export type WinZenithiumEffect = {
+    type: EffectType.WinZenithium;
+    quantity?: number;
+    opponent?: boolean;
+    perLevel1Technology?: number[];
+};
+export type TakeBonusEffect = {
+    type: EffectType.TakeBonus;
+    visible?: boolean;
+};
+export type GiveZenithiumEffect = {
+    type: EffectType.GiveZenithium;
+    quantity?: number;
+};
+export type ExileEffect = {
+    type: EffectType.Exile;
+    factors?: number[];
+    quantity?: number;
+    except?: Influence;
+    quantities?: number[];
+    opponent?: boolean;
+    influence?: Influence;
+};
+export type WinInfluenceEffect = {
+    type: EffectType.WinInfluence;
+    except?: Influence;
+    influence?: Influence;
+    quantity?: number;
+    pattern?: number[];
+    times?: number;
+    resetDifferentPlanet?: boolean;
+    differentPlanet?: boolean;
+    fromCenter?: boolean;
+    opponentSide?: boolean;
+};
+export type GiveInfluenceEffect = {
+    type: EffectType.GiveInfluence;
+    except?: Influence;
+};
+export type ResetInfluenceEffect = {
+    type: EffectType.ResetInfluence;
+};
+export type DevelopTechnologyEffect = {
+    type: EffectType.DevelopTechnology;
+    free?: boolean;
+    lowest?: boolean;
+    discount?: number;
+    faction?: Faction;
+    optional?: boolean;
+};
+export type GiveLeaderBadgeEffect = {
+    type: EffectType.GiveLeaderBadge;
+};
+export type TakeLeaderBadgeEffect = {
+    type: EffectType.TakeLeaderBadge;
+    gold?: boolean;
+};
+export type DiscardEffect = {
+    type: EffectType.Discard;
+    full?: boolean;
+};
+export type MobilizeEffect = {
+    type: EffectType.Mobilize;
+    quantity?: number;
+};
+export type ChoiceEffect = {
+    type: EffectType.Choice;
+    left: Effect;
+    right: Effect;
+};
+export type TakeTechnologyBonusToken = {
+    type: EffectType.TakeTechnologyBonusToken;
+    faction: Faction;
+    x: number;
+};
+export type Effect = ConditionalEffect | WinCreditEffect | SpendCreditEffect | GiveCreditEffect | TransferEffect | WinZenithiumEffect | GiveZenithiumEffect | SpendZenithiumEffect | StealCreditEffect | ExileEffect | WinInfluenceEffect | GiveInfluenceEffect | ResetInfluenceEffect | DevelopTechnologyEffect | GiveLeaderBadgeEffect | TakeLeaderBadgeEffect | DiscardEffect | MobilizeEffect | ChoiceEffect | TakeBonusEffect | TakeTechnologyBonusToken;
+export type ExpandedEffect<T extends Effect = Effect> = T & {
+    effectSource: {
+        type: MaterialType;
+        value: unknown;
+    };
+};
+export declare const isSpendZenithium: (effect: Effect) => effect is SpendZenithiumEffect;
+export declare const isDoEffect: (condition: Condition) => condition is DoEffectCondition;

package/dist/material/effect/Effect.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDoEffect = exports.isSpendZenithium = exports.ConditionType = void 0;
+var EffectType_1 = require("./EffectType");
+var ConditionType;
+(function (ConditionType) {
+    ConditionType[ConditionType["DoEffect"] = 0] = "DoEffect";
+    ConditionType[ConditionType["Leader"] = 1] = "Leader";
+    ConditionType[ConditionType["HaveCredits"] = 2] = "HaveCredits";
+})(ConditionType || (exports.ConditionType = ConditionType = {}));
+var isSpendZenithium = function (effect) { return effect.type === EffectType_1.EffectType.SpendZenithium; };
+exports.isSpendZenithium = isSpendZenithium;
+var isDoEffect = function (condition) { return condition.type === ConditionType.DoEffect; };
+exports.isDoEffect = isDoEffect;

package/dist/material/effect/EffectType.d.ts

@@ -0,0 +1,23 @@
+export declare enum EffectType {
+    Transfer = 1,
+    GiveCredit = 2,
+    WinCredit = 3,
+    SpendCredit = 4,
+    Conditional = 5,
+    WinZenithium = 6,
+    GiveZenithium = 7,
+    Exile = 8,
+    WinInfluence = 9,
+    GiveInfluence = 10,
+    ResetInfluence = 11,
+    DevelopTechnology = 12,
+    GiveLeaderBadge = 13,
+    TakeLeaderBadge = 14,
+    Discard = 15,
+    Mobilize = 16,
+    Choice = 17,
+    TakeBonus = 18,
+    StealCredit = 19,
+    SpendZenithium = 20,
+    TakeTechnologyBonusToken = 21
+}

package/dist/material/effect/EffectType.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EffectType = void 0;
+var EffectType;
+(function (EffectType) {
+    EffectType[EffectType["Transfer"] = 1] = "Transfer";
+    EffectType[EffectType["GiveCredit"] = 2] = "GiveCredit";
+    EffectType[EffectType["WinCredit"] = 3] = "WinCredit";
+    EffectType[EffectType["SpendCredit"] = 4] = "SpendCredit";
+    EffectType[EffectType["Conditional"] = 5] = "Conditional";
+    EffectType[EffectType["WinZenithium"] = 6] = "WinZenithium";
+    EffectType[EffectType["GiveZenithium"] = 7] = "GiveZenithium";
+    EffectType[EffectType["Exile"] = 8] = "Exile";
+    EffectType[EffectType["WinInfluence"] = 9] = "WinInfluence";
+    EffectType[EffectType["GiveInfluence"] = 10] = "GiveInfluence";
+    EffectType[EffectType["ResetInfluence"] = 11] = "ResetInfluence";
+    EffectType[EffectType["DevelopTechnology"] = 12] = "DevelopTechnology";
+    EffectType[EffectType["GiveLeaderBadge"] = 13] = "GiveLeaderBadge";
+    EffectType[EffectType["TakeLeaderBadge"] = 14] = "TakeLeaderBadge";
+    EffectType[EffectType["Discard"] = 15] = "Discard";
+    EffectType[EffectType["Mobilize"] = 16] = "Mobilize";
+    EffectType[EffectType["Choice"] = 17] = "Choice";
+    EffectType[EffectType["TakeBonus"] = 18] = "TakeBonus";
+    EffectType[EffectType["StealCredit"] = 19] = "StealCredit";
+    EffectType[EffectType["SpendZenithium"] = 20] = "SpendZenithium";
+    EffectType[EffectType["TakeTechnologyBonusToken"] = 21] = "TakeTechnologyBonusToken";
+})(EffectType || (exports.EffectType = EffectType = {}));

package/dist/rules/CustomMoveType.d.ts

@@ -0,0 +1,8 @@
+export declare enum CustomMoveType {
+    Pass = 1,
+    Diplomacy = 2,
+    DoCondition = 3,
+    SpendCredit = 4,
+    Choice = 5,
+    WinCreditLog = 6
+}

package/dist/rules/CustomMoveType.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomMoveType = void 0;
+var CustomMoveType;
+(function (CustomMoveType) {
+    CustomMoveType[CustomMoveType["Pass"] = 1] = "Pass";
+    CustomMoveType[CustomMoveType["Diplomacy"] = 2] = "Diplomacy";
+    CustomMoveType[CustomMoveType["DoCondition"] = 3] = "DoCondition";
+    CustomMoveType[CustomMoveType["SpendCredit"] = 4] = "SpendCredit";
+    CustomMoveType[CustomMoveType["Choice"] = 5] = "Choice";
+    CustomMoveType[CustomMoveType["WinCreditLog"] = 6] = "WinCreditLog";
+})(CustomMoveType || (exports.CustomMoveType = CustomMoveType = {}));

package/dist/rules/DiscardActionRule.d.ts

@@ -0,0 +1,8 @@
+import { CustomMove, ItemMove, MaterialMove, PlayerTurnRule } from '@gamepark/rules-api';
+import { RuleId } from './RuleId';
+export declare class DiscardActionRule extends PlayerTurnRule {
+    getPlayerMoves(): MaterialMove[];
+    beforeItemMove(move: ItemMove): MaterialMove<number, number, number, number>[];
+    afterItemMove(move: ItemMove): MaterialMove[];
+    onCustomMove(move: CustomMove): import("@gamepark/rules-api").StartRule<RuleId>[];
+}

package/dist/rules/DiscardActionRule.js

@@ -0,0 +1,84 @@
+"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.DiscardActionRule = void 0;
+var rules_api_1 = require("@gamepark/rules-api");
+var MaterialType_1 = require("../material/MaterialType");
+var CustomMoveType_1 = require("./CustomMoveType");
+var DiplomacyBoardRule_1 = require("./discard-action/DiplomacyBoardRule");
+var TechnologyBoardRule_1 = require("./discard-action/TechnologyBoardRule");
+var RuleId_1 = require("./RuleId");
+var DiscardActionRule = (function (_super) {
+    __extends(DiscardActionRule, _super);
+    function DiscardActionRule() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    DiscardActionRule.prototype.getPlayerMoves = function () {
+        var moves = [];
+        moves.push.apply(moves, __spreadArray([], __read(new TechnologyBoardRule_1.TechnologyBoardRule(this.game).getPlayerMoves()), false));
+        moves.push.apply(moves, __spreadArray([], __read(new DiplomacyBoardRule_1.DiplomacyBoardRule(this.game).getPlayerMoves()), false));
+        if (!moves.length) {
+            moves.push(this.startPlayerTurn(RuleId_1.RuleId.PlayCard, this.nextPlayer));
+        }
+        return moves;
+    };
+    DiscardActionRule.prototype.beforeItemMove = function (move) {
+        if ((0, rules_api_1.isMoveItemType)(MaterialType_1.MaterialType.TechMarker)(move)) {
+            return new TechnologyBoardRule_1.TechnologyBoardRule(this.game).beforeItemMove(move);
+        }
+        return [];
+    };
+    DiscardActionRule.prototype.afterItemMove = function (move) {
+        if ((0, rules_api_1.isMoveItemType)(MaterialType_1.MaterialType.TechMarker)(move)) {
+            return new TechnologyBoardRule_1.TechnologyBoardRule(this.game).afterItemMove(move);
+        }
+        return [];
+    };
+    DiscardActionRule.prototype.onCustomMove = function (move) {
+        if ((0, rules_api_1.isCustomMoveType)(CustomMoveType_1.CustomMoveType.Diplomacy)(move)) {
+            return new DiplomacyBoardRule_1.DiplomacyBoardRule(this.game).onCustomMove(move);
+        }
+        return [];
+    };
+    return DiscardActionRule;
+}(rules_api_1.PlayerTurnRule));
+exports.DiscardActionRule = DiscardActionRule;

package/dist/rules/Memory.d.ts

@@ -0,0 +1,25 @@
+import { Influence } from '../material/Influence';
+import { MaterialType } from '../material/MaterialType';
+export declare enum Memory {
+    Mulligan = 1,
+    TurnOrder = 2,
+    DiscardFaction = 3,
+    Effects = 4,
+    LastPlanetsMoved = 5,
+    CantPass = 6,
+    AlreadyPlayedPlayers = 7,
+    Pattern = 8,
+    CardPlayed = 9,
+    Credit = 10,
+    Zenithium = 11,
+    CurrentEffect = 12,
+    WonBonus = 13
+}
+export type PatternType = {
+    influence: Influence;
+    count: number;
+};
+export type EffectSourceType = {
+    type: MaterialType;
+    value: unknown;
+};

package/dist/rules/Memory.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Memory = void 0;
+var Memory;
+(function (Memory) {
+    Memory[Memory["Mulligan"] = 1] = "Mulligan";
+    Memory[Memory["TurnOrder"] = 2] = "TurnOrder";
+    Memory[Memory["DiscardFaction"] = 3] = "DiscardFaction";
+    Memory[Memory["Effects"] = 4] = "Effects";
+    Memory[Memory["LastPlanetsMoved"] = 5] = "LastPlanetsMoved";
+    Memory[Memory["CantPass"] = 6] = "CantPass";
+    Memory[Memory["AlreadyPlayedPlayers"] = 7] = "AlreadyPlayedPlayers";
+    Memory[Memory["Pattern"] = 8] = "Pattern";
+    Memory[Memory["CardPlayed"] = 9] = "CardPlayed";
+    Memory[Memory["Credit"] = 10] = "Credit";
+    Memory[Memory["Zenithium"] = 11] = "Zenithium";
+    Memory[Memory["CurrentEffect"] = 12] = "CurrentEffect";
+    Memory[Memory["WonBonus"] = 13] = "WonBonus";
+})(Memory || (exports.Memory = Memory = {}));

package/dist/rules/MulliganRule.d.ts

@@ -0,0 +1,12 @@
+import { CustomMove, MaterialMove, MoveItem, SimultaneousRule } from '@gamepark/rules-api';
+import { PlayerId } from '../PlayerId';
+export declare class MulliganRule extends SimultaneousRule {
+    getActivePlayerLegalMoves(player: PlayerId): MaterialMove[];
+    onCustomMove(move: CustomMove): MaterialMove[];
+    getMulliganCount(player: PlayerId): number;
+    get deck(): import("@gamepark/rules-api").MaterialDeck<number, number, number>;
+    beforeItemMove(move: MoveItem): never[];
+    getHand(playerId: PlayerId): import("@gamepark/rules-api").Material<number, number, number>;
+    getMovesAfterPlayersDone(): MaterialMove[];
+    get turnOrder(): PlayerId[];
+}