@gamepark/greylune 0.1.0

package/dist/rules/EventRule.js

@@ -0,0 +1,39 @@
+import { isCustomMoveType, isMoveItemType } from '@gamepark/rules-api';
+import { eventTileData, isFestival } from '../material/EventTile';
+import { LocationType } from '../material/LocationType';
+import { MaterialType } from '../material/MaterialType';
+import { CustomMoveType } from './CustomMoveType';
+import { GreyluneRule } from './GreyluneRule';
+export class EventRule extends GreyluneRule {
+    get newcomer() {
+        return this.myVillagers.location((location) => location.type === LocationType.EventSpace && location.x === undefined);
+    }
+    onRuleStart() {
+        const moves = this.getPlayerMoves();
+        if (moves.length > 1)
+            return [];
+        return moves.length ? moves : this.endOfAction();
+    }
+    getPlayerMoves() {
+        const tile = this.eventTile;
+        if (tile === undefined || !this.newcomer.length)
+            return [];
+        return this.eventOptions.map((option) => isFestival(tile) ? this.newcomer.moveItem({ ...this.eventSpace, x: option }) : this.customMove(CustomMoveType.TakeEventOption, option));
+    }
+    afterItemMove(move) {
+        if (!isMoveItemType(MaterialType.Villager)(move) || move.location.type !== LocationType.EventSpace)
+            return [];
+        return move.location.x === undefined ? [] : this.takeOption(move.location.x);
+    }
+    onCustomMove(move) {
+        if (isCustomMoveType(CustomMoveType.TakeEventOption)(move))
+            return this.takeOption(move.data);
+        return super.onCustomMove(move);
+    }
+    takeOption(option) {
+        const ability = eventTileData[this.eventTile].abilities[option];
+        this.pushGains(ability.gains ?? []);
+        return [...this.payRequirements(ability.requirements), ...this.endOfAction()];
+    }
+}
+//# sourceMappingURL=EventRule.js.map

package/dist/rules/EventRule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EventRule.js","sourceRoot":"","sources":["../../src/rules/EventRule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,gBAAgB,EAAE,cAAc,EAAY,MAAM,qBAAqB,CAAA;AAC5F,OAAO,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAA;AACjE,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAA;AACvD,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAA;AACvD,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAA;AACjD,OAAO,EAAkC,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAe7E,MAAM,OAAO,SAAU,SAAQ,YAAY;IAEzC,IAAI,QAAQ;QACV,OAAO,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,CAAC,IAAI,KAAK,YAAY,CAAC,UAAU,IAAI,QAAQ,CAAC,CAAC,KAAK,SAAS,CAAC,CAAA;IACvH,CAAC;IAED,WAAW;QACT,MAAM,KAAK,GAAG,IAAI,CAAC,cAAc,EAAE,CAAA;QACnC,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC;YAAE,OAAO,EAAE,CAAA;QAE/B,OAAO,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,EAAE,CAAA;IAClD,CAAC;IAED,cAAc;QACZ,MAAM,IAAI,GAAG,IAAI,CAAC,SAAS,CAAA;QAI3B,IAAI,IAAI,KAAK,SAAS,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM;YAAE,OAAO,EAAE,CAAA;QAC1D,OAAO,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CACtC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,GAAG,IAAI,CAAC,UAAU,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,cAAc,CAAC,eAAe,EAAE,MAAM,CAAC,CACvI,CAAA;IACH,CAAC;IAGD,aAAa,CAAC,IAAkD;QAC9D,IAAI,CAAC,cAAc,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,QAAQ,CAAC,IAAI,KAAK,YAAY,CAAC,UAAU;YAAE,OAAO,EAAE,CAAA;QAC7G,OAAO,IAAI,CAAC,QAAQ,CAAC,CAAC,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAA;IAC9E,CAAC;IAGD,YAAY,CAAC,IAAgB;QAC3B,IAAI,gBAAgB,CAAC,cAAc,CAAC,eAAe,CAAC,CAAC,IAAI,CAAC;YAAE,OAAO,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAc,CAAC,CAAA;QACvG,OAAO,KAAK,CAAC,YAAY,CAAC,IAAI,CAAC,CAAA;IACjC,CAAC;IAEO,UAAU,CAAC,MAAc;QAC/B,MAAM,OAAO,GAAG,aAAa,CAAC,IAAI,CAAC,SAAU,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,CAAA;QAChE,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,KAAK,IAAI,EAAE,CAAC,CAAA;QACnC,OAAO,CAAC,GAAG,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC,YAAY,CAAC,EAAE,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC,CAAA;IAC/E,CAAC;CACF"}

package/dist/rules/FinalScoringRule.d.ts

@@ -0,0 +1,18 @@
+import { MaterialRulesPart } from '@gamepark/rules-api';
+import { LocationType } from '../material/LocationType';
+import { MaterialSource } from '../material/MaterialSource';
+import { MaterialType } from '../material/MaterialType';
+import { PlayerColor } from '../PlayerColor';
+import { GreyluneMove } from './GreyluneRule';
+import { RuleId } from './RuleId';
+type Count = {
+    rule: RuleId;
+    score: (source: MaterialSource, player: PlayerColor) => number;
+};
+export declare const finalScoring: Count[];
+export declare class FinalScoringRule extends MaterialRulesPart<PlayerColor, MaterialType, LocationType, RuleId> {
+    onRuleStart(): GreyluneMove[];
+}
+export declare const scoreStillToCount: (source: MaterialSource, player: PlayerColor, rule?: RuleId) => number;
+export {};
+//# sourceMappingURL=FinalScoringRule.d.ts.map

package/dist/rules/FinalScoringRule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FinalScoringRule.d.ts","sourceRoot":"","sources":["../../src/rules/FinalScoringRule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAA;AACvD,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAA;AACvD,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAA;AAC3D,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAA;AAEvD,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAA;AAC5C,OAAO,EAAE,YAAY,EAAc,MAAM,gBAAgB,CAAA;AACzD,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAA;AAEjC,KAAK,KAAK,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,CAAC,MAAM,EAAE,cAAc,EAAE,MAAM,EAAE,WAAW,KAAK,MAAM,CAAA;CAAE,CAAA;AAG7F,eAAO,MAAM,YAAY,EAAE,KAAK,EAK/B,CAAA;AAUD,qBAAa,gBAAiB,SAAQ,iBAAiB,CAAC,WAAW,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,CAAC;IACtG,WAAW,IAAI,YAAY,EAAE,CAU5B;CACF;AAQD,eAAO,MAAM,iBAAiB,WAAY,cAAc,UAAU,WAAW,SAAS,MAAM,KAAG,MAI9F,CAAA"}

package/dist/rules/FinalScoringRule.js

@@ -0,0 +1,30 @@
+import { MaterialRulesPart } from '@gamepark/rules-api';
+import { companionsScore, itemsScore, playerVp, questScore, skillScore } from '../material/PlayerState';
+import { scoreMoves } from './GreyluneRule';
+import { RuleId } from './RuleId';
+export const finalScoring = [
+    { rule: RuleId.QuestsScoring, score: questScore },
+    { rule: RuleId.CompanionsScoring, score: companionsScore },
+    { rule: RuleId.ItemsScoring, score: itemsScore },
+    { rule: RuleId.SkillsScoring, score: skillScore }
+];
+export class FinalScoringRule extends MaterialRulesPart {
+    onRuleStart() {
+        const step = finalScoring.findIndex(({ rule }) => rule === this.game.rule?.id);
+        const next = finalScoring[step + 1];
+        return [
+            ...this.game.players.flatMap((player) => {
+                const points = finalScoring[step].score(this, player);
+                return points ? scoreMoves(this, player, playerVp(this, player) + points) : [];
+            }),
+            next ? this.startRule(next.rule) : this.endGame()
+        ];
+    }
+}
+export const scoreStillToCount = (source, player, rule) => {
+    if (rule === undefined)
+        return 0;
+    const step = Math.max(0, finalScoring.findIndex((count) => count.rule === rule));
+    return finalScoring.slice(step).reduce((total, { score }) => total + score(source, player), 0);
+};
+//# sourceMappingURL=FinalScoringRule.js.map

package/dist/rules/FinalScoringRule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FinalScoringRule.js","sourceRoot":"","sources":["../../src/rules/FinalScoringRule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAA;AAIvD,OAAO,EAAE,eAAe,EAAE,UAAU,EAAE,QAAQ,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAA;AAEvG,OAAO,EAAgB,UAAU,EAAE,MAAM,gBAAgB,CAAA;AACzD,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAA;AAKjC,MAAM,CAAC,MAAM,YAAY,GAAY;IACnC,EAAE,IAAI,EAAE,MAAM,CAAC,aAAa,EAAE,KAAK,EAAE,UAAU,EAAE;IACjD,EAAE,IAAI,EAAE,MAAM,CAAC,iBAAiB,EAAE,KAAK,EAAE,eAAe,EAAE;IAC1D,EAAE,IAAI,EAAE,MAAM,CAAC,YAAY,EAAE,KAAK,EAAE,UAAU,EAAE;IAChD,EAAE,IAAI,EAAE,MAAM,CAAC,aAAa,EAAE,KAAK,EAAE,UAAU,EAAE;CAClD,CAAA;AAUD,MAAM,OAAO,gBAAiB,SAAQ,iBAAkE;IACtG,WAAW;QACT,MAAM,IAAI,GAAG,YAAY,CAAC,SAAS,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,KAAK,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,EAAE,CAAC,CAAA;QAC9E,MAAM,IAAI,GAAG,YAAY,CAAC,IAAI,GAAG,CAAC,CAAC,CAAA;QACnC,OAAO;YACL,GAAG,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,MAAM,EAAE,EAAE;gBACtC,MAAM,MAAM,GAAG,YAAY,CAAC,IAAI,CAAC,CAAC,KAAK,CAAC,IAAI,EAAE,MAAM,CAAC,CAAA;gBACrD,OAAO,MAAM,CAAC,CAAC,CAAC,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE,CAAA;YAChF,CAAC,CAAC;YACF,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,EAAE;SAClD,CAAA;IACH,CAAC;CACF;AAQD,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC,MAAsB,EAAE,MAAmB,EAAE,IAAa,EAAU,EAAE;IACtG,IAAI,IAAI,KAAK,SAAS;QAAE,OAAO,CAAC,CAAA;IAChC,MAAM,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,YAAY,CAAC,SAAS,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC,CAAA;IAChF,OAAO,YAAY,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC,KAAK,GAAG,KAAK,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC,CAAC,CAAA;AAChG,CAAC,CAAA"}

package/dist/rules/GreyluneRule.d.ts

@@ -0,0 +1,87 @@
+import { CustomMove, Location, Material, MaterialMove, PlayerTurnRule } from '@gamepark/rules-api';
+import { PlayerColor } from '../PlayerColor';
+import { Count, Gain, Requirement } from '../material/Effect';
+import { EventTile } from '../material/EventTile';
+import { LocationType } from '../material/LocationType';
+import { MaterialType } from '../material/MaterialType';
+import { MaterialSource } from '../material/MaterialSource';
+import { ReactionEffect, TriggerType } from '../material/Reaction';
+import { VillageCard } from '../material/VillageCard';
+import { Season } from '../Season';
+import { RuleId } from './RuleId';
+export type GreyluneMove = MaterialMove<PlayerColor, MaterialType, LocationType, RuleId>;
+export type GreyluneMaterial = Material<PlayerColor, MaterialType, LocationType>;
+export type SkillMarker = MaterialType.StrengthMarker | MaterialType.MagicMarker;
+export type CostReduction = {
+    force?: number;
+    villagers?: number;
+    coins?: number;
+    noSurcharge?: boolean;
+    itemVp?: number;
+    freeSealValue?: boolean;
+};
+export type ReactionChoice = {
+    card: number;
+    option: number;
+};
+export declare abstract class GreyluneRule extends PlayerTurnRule<PlayerColor, MaterialType, LocationType, RuleId> {
+    get villageCards(): GreyluneMaterial;
+    get encounterCards(): GreyluneMaterial;
+    get villagers(): GreyluneMaterial;
+    get myVillagers(): GreyluneMaterial;
+    get activeVillagers(): GreyluneMaterial;
+    get adventurer(): GreyluneMaterial;
+    playerCard(index: number): VillageCard;
+    get coins(): number;
+    get force(): number;
+    get magic(): number;
+    get season(): Season;
+    get hasStoryToTell(): boolean;
+    canReceive(gains?: Gain[]): boolean;
+    get temporaryForce(): number;
+    get temporaryMagic(): number;
+    get tileOfTheYear(): GreyluneMaterial;
+    get eventTile(): EventTile | undefined;
+    get eventSpace(): Location<PlayerColor, LocationType>;
+    get hasUsedEvent(): boolean;
+    get eventOptions(): number[];
+    get gains(): Gain[];
+    pushGains(gains: Gain[], first?: boolean): void;
+    endOfAction(): GreyluneMove[];
+    amount(count: Count): number;
+    gainMove(gain: Gain): GreyluneMove | undefined;
+    onCustomMove(move: CustomMove): GreyluneMove[];
+    private get money();
+    gainCoins(amount: number): GreyluneMove[];
+    payCoins(amount: number): GreyluneMove[];
+    gainVp(amount: number): GreyluneMove[];
+    gainSkill(marker: SkillMarker, amount: number): GreyluneMove[];
+    moveSkillMarker(marker: SkillMarker, amount: number): GreyluneMove[];
+    skillGained(marker: SkillMarker, amount: number): GreyluneMove[];
+    gainVillagers(amount: number): GreyluneMove[];
+    canPay(requirements?: Requirement[], reduction?: CostReduction): boolean;
+    private canPayOne;
+    payRequirements(requirements?: Requirement[]): GreyluneMove[];
+    coinCost(requirements?: Requirement[]): number;
+    private payOne;
+    spendVillagers(amount: number): GreyluneMove[];
+    get costReduction(): CostReduction;
+    reduceCost(reduction: CostReduction): void;
+    reactionChoices(triggers: TriggerType[]): ReactionChoice[];
+    private canReact;
+    get playerCards(): GreyluneMaterial;
+    potentialReduction(triggers: TriggerType[]): CostReduction;
+    resume(triggers?: TriggerType[]): GreyluneMove[];
+    openReactions(triggers: TriggerType[], next: RuleId): GreyluneMove[];
+    reactionEffect(card: number, option: number): ReactionEffect;
+    useReaction(card: number, option: number): GreyluneMove[];
+    private payReactionCost;
+    private applyReaction;
+    nextActivePlayer(): PlayerColor | undefined;
+    seasonRule(player: PlayerColor): RuleId;
+    endOfTurn(): GreyluneMove[];
+    forgetAction(): void;
+}
+export declare const vpTokenFor: (total: number) => number;
+export declare const scoreMoves: (source: MaterialSource, player: PlayerColor, total: number) => GreyluneMove[];
+//# sourceMappingURL=GreyluneRule.d.ts.map

package/dist/rules/GreyluneRule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GreyluneRule.d.ts","sourceRoot":"","sources":["../../src/rules/GreyluneRule.ts"],"names":[],"mappings":"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"}

package/dist/rules/GreyluneRule.js

@@ -0,0 +1,432 @@
+import { getEnumValues, isCustomMoveType, PlayerTurnRule } from '@gamepark/rules-api';
+import { BONUS_TOKEN_SCORES, MAX_SKILL, SCORE_TRACK_SIZE } from '../Constants';
+import { Memory } from '../Memory';
+import { bonusToken, GainType, gathered, placeVillager, RequirementType, SEAL } from '../material/Effect';
+import { encounterCardData } from '../material/EncounterCard';
+import { eventTileData, isFestival } from '../material/EventTile';
+import { LocationType } from '../material/LocationType';
+import { MaterialType } from '../material/MaterialType';
+import { activeVillagers, keepsPotions, playerCoins, playerForce, playerMagic, playerSeason, playerVp, scoreValue, vpTokenTotal } from '../material/PlayerState';
+import { ReactionType, TriggerType } from '../material/Reaction';
+import { coinUnits } from '../material/Tokens';
+import { getVillagerPlayer } from '../material/Villager';
+import { isPotion, villageCardData } from '../material/VillageCard';
+import { getVpToken, getVpTokenValue, VpTokenValue } from '../material/VpToken';
+import { Season } from '../Season';
+import { isLastYear } from '../Year';
+import { CustomMoveType } from './CustomMoveType';
+import { RuleId } from './RuleId';
+export class GreyluneRule extends PlayerTurnRule {
+    get villageCards() {
+        return this.material(MaterialType.VillageCard);
+    }
+    get encounterCards() {
+        return this.material(MaterialType.EncounterCard);
+    }
+    get villagers() {
+        return this.material(MaterialType.Villager);
+    }
+    get myVillagers() {
+        return this.villagers.id((villager) => getVillagerPlayer(villager) === this.player);
+    }
+    get activeVillagers() {
+        return activeVillagers(this, this.player);
+    }
+    get adventurer() {
+        return this.material(MaterialType.Adventurer).id(this.player);
+    }
+    playerCard(index) {
+        return this.villageCards.getItem(index).id.front;
+    }
+    get coins() {
+        return playerCoins(this, this.player);
+    }
+    get force() {
+        return playerForce(this, this.player);
+    }
+    get magic() {
+        return playerMagic(this, this.player);
+    }
+    get season() {
+        return playerSeason(this, this.player);
+    }
+    get hasStoryToTell() {
+        const untold = this.encounterCards.location(LocationType.UntoldStories).player(this.player);
+        if (untold.filter((item) => encounterCardData[item.id.front].story > 0).length)
+            return true;
+        return (untold.length > 0 &&
+            this.reactionChoices([TriggerType.TellStory]).some(({ card, option }) => this.reactionEffect(card, option).type === ReactionType.StoryValue3));
+    }
+    canReceive(gains = []) {
+        return !gains.some((gain) => gain.type === GainType.TellStory) || this.hasStoryToTell;
+    }
+    get temporaryForce() {
+        return this.remind(Memory.TemporaryForce) ?? 0;
+    }
+    get temporaryMagic() {
+        return this.remind(Memory.TemporaryMagic) ?? 0;
+    }
+    get tileOfTheYear() {
+        return this.material(MaterialType.EventTile).location(LocationType.EventPile).rotation(true);
+    }
+    get eventTile() {
+        return this.tileOfTheYear.getItem()?.id;
+    }
+    get eventSpace() {
+        return { type: LocationType.EventSpace, parent: this.tileOfTheYear.getIndex() };
+    }
+    get hasUsedEvent() {
+        return this.myVillagers.location(LocationType.EventSpace).length > 0;
+    }
+    get eventOptions() {
+        const tile = this.eventTile;
+        if (tile === undefined)
+            return [];
+        const taken = this.villagers.location(LocationType.EventSpace).getItems().map((item) => item.location.x);
+        return eventTileData[tile].abilities.flatMap((ability, option) => this.canPay(ability.requirements) && !(isFestival(tile) && taken.includes(option)) ? [option] : []);
+    }
+    get gains() {
+        return this.remind(Memory.Gains) ?? [];
+    }
+    pushGains(gains, first = false) {
+        if (gains.length)
+            this.memorize(Memory.Gains, first ? [...gains, ...this.gains] : [...this.gains, ...gains]);
+    }
+    endOfAction() {
+        return [this.startRule(RuleId.ResolveEffects)];
+    }
+    amount(count) {
+        return count === SEAL ? (this.remind(Memory.SealValue) ?? 0) : count;
+    }
+    gainMove(gain) {
+        switch (gain.type) {
+            case GainType.Coins:
+                return this.customMove(CustomMoveType.GainCoins, this.amount(gain.count));
+            case GainType.Vp:
+                return this.customMove(CustomMoveType.GainVp, this.amount(gain.count));
+            case GainType.Score:
+                return this.customMove(CustomMoveType.GainVp, scoreValue(this, this.player, gain.score));
+            default:
+                return undefined;
+        }
+    }
+    onCustomMove(move) {
+        if (isCustomMoveType(CustomMoveType.GainCoins)(move))
+            return [...this.gainCoins(move.data), ...this.resume()];
+        if (isCustomMoveType(CustomMoveType.GainVp)(move))
+            return [...this.gainVp(move.data), ...this.resume()];
+        return [];
+    }
+    get money() {
+        return this.material(MaterialType.Coin).location(LocationType.PlayerCoins).player(this.player).money(coinUnits);
+    }
+    gainCoins(amount) {
+        return this.money.addMoney(amount, { type: LocationType.PlayerCoins, player: this.player });
+    }
+    payCoins(amount) {
+        return this.money.removeMoney(amount, { type: LocationType.PlayerCoins, player: this.player });
+    }
+    gainVp(amount) {
+        const total = playerVp(this, this.player) + amount;
+        const tokens = this.material(MaterialType.BonusToken).location(LocationType.BonusTokens).player(this.player).length;
+        if (total >= BONUS_TOKEN_SCORES[0] && tokens === 3)
+            this.pushGains([bonusToken], true);
+        if (total >= BONUS_TOKEN_SCORES[1] && tokens >= 2)
+            this.pushGains([bonusToken], true);
+        return scoreMoves(this, this.player, total);
+    }
+    gainSkill(marker, amount) {
+        const moves = this.moveSkillMarker(marker, amount);
+        return moves.length ? [...moves, ...this.skillGained(marker, amount)] : [];
+    }
+    moveSkillMarker(marker, amount) {
+        const markers = this.material(marker).player(this.player);
+        const { location } = markers.getItem();
+        const x = Math.min(MAX_SKILL, Math.max(0, (location.x ?? 0) + amount));
+        return x === location.x ? [] : [markers.moveItem({ ...location, x })];
+    }
+    skillGained(marker, amount) {
+        this.memorize(Memory.CurrentGain, { type: marker === MaterialType.StrengthMarker ? GainType.Force : GainType.Magic, count: amount });
+        return this.resume([TriggerType.GainSkill]);
+    }
+    gainVillagers(amount) {
+        return this.villagers.location(LocationType.VillagerReserve).player(this.player).limit(amount).moveItems({
+            type: LocationType.ActiveVillagers,
+            player: this.player
+        });
+    }
+    canPay(requirements = [], reduction = this.costReduction) {
+        return gathered(requirements).every((requirement) => this.canPayOne(requirement, reduction));
+    }
+    canPayOne(requirement, reduction = this.costReduction) {
+        const count = requirement.count ?? 1;
+        switch (requirement.type) {
+            case RequirementType.Force:
+                return this.force + this.temporaryForce >= count;
+            case RequirementType.Magic:
+                return this.magic + this.temporaryMagic >= count;
+            case RequirementType.Skills:
+                return this.force + this.temporaryForce + this.magic + this.temporaryMagic >= count;
+            case RequirementType.SpendCoins:
+                return this.coins >= Math.max(0, count - (reduction.coins ?? 0));
+            case RequirementType.SpendForce:
+                return this.force >= Math.max(0, count - (reduction.force ?? 0));
+            case RequirementType.SpendMagic:
+                return this.magic >= count;
+            case RequirementType.SpendVillagers:
+                return this.activeVillagers.length >= Math.max(0, count - (reduction.villagers ?? 0));
+            case RequirementType.ReturnVillager:
+                return this.activeVillagers.length >= count;
+            case RequirementType.DiscardItem:
+                return this.material(MaterialType.VillageCard).location(LocationType.Items).player(this.player).length >= 1;
+            case RequirementType.TellStories:
+                return this.encounterCards.location(LocationType.UntoldStories).player(this.player).length >= count;
+            default:
+                return true;
+        }
+    }
+    payRequirements(requirements = []) {
+        return gathered(requirements).flatMap((requirement) => this.payOne(requirement));
+    }
+    coinCost(requirements = []) {
+        const reduction = this.costReduction;
+        return requirements.reduce((total, requirement) => {
+            if (requirement.type === RequirementType.SpendCoins)
+                return total + Math.max(0, (requirement.count ?? 1) - (reduction.coins ?? 0));
+            if (requirement.type === RequirementType.SealCoins)
+                return total + (this.remind(Memory.SealValue) ?? 0);
+            return total;
+        }, 0);
+    }
+    payOne(requirement) {
+        const count = requirement.count ?? 1;
+        const reduction = this.costReduction;
+        switch (requirement.type) {
+            case RequirementType.SpendCoins:
+            case RequirementType.SealCoins:
+                return this.payCoins(this.coinCost([requirement]));
+            case RequirementType.SpendForce:
+                return this.moveSkillMarker(MaterialType.StrengthMarker, -Math.max(0, count - (reduction.force ?? 0)));
+            case RequirementType.SpendMagic:
+                return this.moveSkillMarker(MaterialType.MagicMarker, -count);
+            case RequirementType.SpendVillagers:
+                return this.spendVillagers(Math.max(0, count - (reduction.villagers ?? 0)));
+            case RequirementType.ReturnVillager:
+                return this.activeVillagers.limit(count).moveItems({ type: LocationType.VillagerReserve, player: this.player });
+            default:
+                return [];
+        }
+    }
+    spendVillagers(amount) {
+        if (amount <= 0)
+            return [];
+        return this.activeVillagers.limit(amount).moveItems({ type: LocationType.Camp });
+    }
+    get costReduction() {
+        return this.remind(Memory.CostReduction) ?? {};
+    }
+    reduceCost(reduction) {
+        this.memorize(Memory.CostReduction, { ...this.costReduction, ...reduction });
+    }
+    reactionChoices(triggers) {
+        const choices = [];
+        for (const card of this.playerCards.getIndexes()) {
+            const reaction = villageCardData[this.playerCard(card)].reaction;
+            if (!reaction || !reaction.triggers.some((trigger) => triggers.includes(trigger)))
+                continue;
+            if (!this.canReact(card, reaction))
+                continue;
+            reaction.options.forEach((effect, option) => {
+                if (effect.trigger === undefined || triggers.includes(effect.trigger))
+                    choices.push({ card, option });
+            });
+        }
+        return choices;
+    }
+    canReact(card, reaction) {
+        const item = this.villageCards.getItem(card);
+        for (const requirement of reaction.requirements) {
+            if (requirement.type === RequirementType.Tilt && item.location.rotation === true)
+                return false;
+            if (requirement.type === RequirementType.DiscardCard && item.location.rotation === true)
+                return false;
+            if (!this.canPayOne(requirement))
+                return false;
+        }
+        return !(reaction.triggers.includes(TriggerType.TiltCard) && this.remind(Memory.LastTilted) === card);
+    }
+    get playerCards() {
+        return this.villageCards.player(this.player).location((location) => location.type === LocationType.Items || location.type === LocationType.Companions);
+    }
+    potentialReduction(triggers) {
+        const reduction = { ...this.costReduction };
+        for (const card of new Set(this.reactionChoices(triggers).map((choice) => choice.card))) {
+            for (const option of villageCardData[this.playerCard(card)].reaction.options) {
+                switch (option.type) {
+                    case ReactionType.ReduceForceCost:
+                        reduction.force = (reduction.force ?? 0) + 1;
+                        break;
+                    case ReactionType.ReduceVillagerCost:
+                        reduction.villagers = (reduction.villagers ?? 0) + 1;
+                        break;
+                    case ReactionType.CheaperItem:
+                        reduction.coins = (reduction.coins ?? 0) + 1;
+                        break;
+                    case ReactionType.ChooseSealValue:
+                        reduction.freeSealValue = true;
+                        break;
+                }
+            }
+        }
+        return reduction;
+    }
+    resume(triggers = []) {
+        return this.openReactions(triggers, RuleId.ResolveEffects);
+    }
+    openReactions(triggers, next) {
+        if (!triggers.length || !this.reactionChoices(triggers).length)
+            return [this.startRule(next)];
+        this.memorize(Memory.Trigger, triggers);
+        this.memorize(Memory.Resume, next);
+        return [this.startRule(RuleId.Reaction)];
+    }
+    reactionEffect(card, option) {
+        return villageCardData[this.playerCard(card)].reaction.options[option];
+    }
+    useReaction(card, option) {
+        const tiltedBefore = this.remind(Memory.LastTilted);
+        return [...this.payReactionCost(card), ...this.applyReaction(card, option, tiltedBefore)];
+    }
+    payReactionCost(card) {
+        const front = this.playerCard(card);
+        const reaction = villageCardData[front].reaction;
+        const moves = [];
+        let tilted = false;
+        for (const requirement of reaction.requirements) {
+            switch (requirement.type) {
+                case RequirementType.Tilt:
+                    moves.push(this.villageCards.index(card).rotateItem(true));
+                    tilted = true;
+                    break;
+                case RequirementType.DiscardCard:
+                    if (isPotion(front) && keepsPotions(this, this.player)) {
+                        moves.push(this.villageCards.index(card).rotateItem(true));
+                        tilted = true;
+                    }
+                    else {
+                        moves.push(this.villageCards.index(card).deleteItem());
+                    }
+                    break;
+                default:
+                    moves.push(...this.payRequirements([requirement]));
+            }
+        }
+        if (tilted) {
+            this.memorize(Memory.LastTilted, card);
+            const triggers = this.remind(Memory.Trigger) ?? [];
+            if (!triggers.includes(TriggerType.TiltCard))
+                this.memorize(Memory.Trigger, [...triggers, TriggerType.TiltCard]);
+        }
+        return moves;
+    }
+    applyReaction(card, option, tiltedBefore) {
+        const effect = this.reactionEffect(card, option);
+        switch (effect.type) {
+            case ReactionType.ExtraTravel:
+                this.memorize(Memory.TravelDistance, (this.remind(Memory.TravelDistance) ?? 0) + effect.count);
+                return [];
+            case ReactionType.PlaceVillager:
+                this.pushGains([placeVillager], true);
+                return [];
+            case ReactionType.TemporarySkills:
+                if (effect.force)
+                    this.memorize(Memory.TemporaryForce, this.temporaryForce + effect.force);
+                if (effect.magic)
+                    this.memorize(Memory.TemporaryMagic, this.temporaryMagic + effect.magic);
+                return [];
+            case ReactionType.IgnoreCondition:
+                this.memorize(Memory.IgnoredConditions, (this.remind(Memory.IgnoredConditions) ?? 0) + 1);
+                return [];
+            case ReactionType.StoryValue3:
+                this.memorize(Memory.StoryBoost, (this.remind(Memory.StoryBoost) ?? 0) + 1);
+                return [];
+            case ReactionType.ReduceForceCost:
+                this.reduceCost({ force: (this.costReduction.force ?? 0) + 1 });
+                return [];
+            case ReactionType.ReduceVillagerCost:
+                this.reduceCost({ villagers: (this.costReduction.villagers ?? 0) + 1 });
+                return [];
+            case ReactionType.CheaperItem:
+                this.reduceCost({ coins: (this.costReduction.coins ?? 0) + 1, itemVp: (this.costReduction.itemVp ?? 0) + 1 });
+                return [];
+            case ReactionType.ExtraCoins:
+                return this.gainCoins(effect.count);
+            case ReactionType.NoSurcharge:
+                this.reduceCost({ noSurcharge: true });
+                return [];
+            case ReactionType.ChooseSealValue:
+                this.reduceCost({ freeSealValue: true });
+                return [];
+            case ReactionType.OtherSkill: {
+                const gain = this.remind(Memory.CurrentGain);
+                this.pushGains([{ type: gain?.type === GainType.Force ? GainType.Magic : GainType.Force, count: 1 }], true);
+                return [];
+            }
+            case ReactionType.StraightenTilted:
+                return tiltedBefore === undefined ? [] : [this.villageCards.index(tiltedBefore).rotateItem(false)];
+        }
+    }
+    nextActivePlayer() {
+        const players = this.game.players;
+        const start = players.indexOf(this.player);
+        for (let step = 1; step <= players.length; step++) {
+            const player = players[(start + step) % players.length];
+            if (playerSeason(this, player) !== Season.Autumn)
+                return player;
+        }
+        return undefined;
+    }
+    seasonRule(player) {
+        return playerSeason(this, player) === Season.Spring ? RuleId.Spring : RuleId.Summer;
+    }
+    endOfTurn() {
+        this.forgetAction();
+        const next = this.nextActivePlayer();
+        if (next !== undefined)
+            return [this.startPlayerTurn(this.seasonRule(next), next)];
+        return [this.startRule(isLastYear(this) ? RuleId.QuestsScoring : RuleId.Winter)];
+    }
+    forgetAction() {
+        for (const key of getEnumValues(Memory))
+            this.forget(key);
+    }
+}
+export const vpTokenFor = (total) => Math.min(100, Math.floor(total / SCORE_TRACK_SIZE) * SCORE_TRACK_SIZE);
+export const scoreMoves = (source, player, total) => [
+    ...vpTokenMoves(source, player, total),
+    ...scoreMarkerMoves(source, player, total)
+];
+const scoreMarkerMoves = (source, player, total) => {
+    const marker = source.material(MaterialType.ScoreMarker).id(player);
+    const x = total - vpTokenFor(total);
+    return marker.getItem()?.location.x === x ? [] : [marker.moveItem({ type: LocationType.ScoreTrack, x })];
+};
+const vpTokenMoves = (source, player, total) => {
+    const value = vpTokenFor(total);
+    const tokens = source.material(MaterialType.VpToken);
+    const held = tokens.location(LocationType.PlayerVpTokens).player(player).getItem();
+    const heldValue = held ? vpTokenTotal(held.id, held.location.rotation === true) : 0;
+    if (value === heldValue)
+        return [];
+    const moves = [];
+    const wanted = value >= 75 ? VpTokenValue.Vp75 : VpTokenValue.Vp25;
+    if (held && getVpTokenValue(held.id) !== wanted) {
+        moves.push(tokens.location(LocationType.PlayerVpTokens).player(player).deleteItem());
+    }
+    if (value === 0)
+        return moves;
+    const flipped = value === 50 || value === 100;
+    moves.push(tokens.id(getVpToken(player, wanted)).moveItem({ type: LocationType.PlayerVpTokens, player, rotation: flipped }));
+    return moves;
+};
+//# sourceMappingURL=GreyluneRule.js.map