Compare commits
No commits in common. "08c6a67d1697d0a1f7c54f3ecd927da262efe312" and "a82b6b0685c7c032f6e4bba5d7975ad8d156659c" have entirely different histories.
08c6a67d16
...
a82b6b0685
160
src/core/game.ts
160
src/core/game.ts
|
|
@ -1,104 +1,80 @@
|
|||
import { MutableSignal, mutableSignal } from "@/utils/mutable-signal";
|
||||
import {MutableSignal, mutableSignal} from "@/utils/mutable-signal";
|
||||
import {
|
||||
Command,
|
||||
CommandRegistry,
|
||||
CommandResult,
|
||||
CommandRunnerContextExport,
|
||||
CommandSchema,
|
||||
createCommandRegistry,
|
||||
createCommandRunnerContext,
|
||||
parseCommandSchema,
|
||||
Command,
|
||||
CommandRegistry, CommandResult,
|
||||
CommandRunnerContextExport,
|
||||
CommandSchema,
|
||||
createCommandRegistry,
|
||||
createCommandRunnerContext, parseCommandSchema,
|
||||
} from "@/utils/command";
|
||||
import { PromptValidator } from "@/utils/command/command-runner";
|
||||
import { Mulberry32RNG, ReadonlyRNG, RNG } from "@/utils/rng";
|
||||
import {PromptValidator} from "@/utils/command/command-runner";
|
||||
import {Mulberry32RNG, ReadonlyRNG, RNG} from "@/utils/rng";
|
||||
|
||||
export interface IGameContext<TState extends Record<string, unknown> = {}> {
|
||||
get value(): TState;
|
||||
get rng(): ReadonlyRNG;
|
||||
produce(fn: (draft: TState) => void): void;
|
||||
produceAsync(fn: (draft: TState) => void): Promise<void>;
|
||||
run<T>(input: string): Promise<CommandResult<T>>;
|
||||
runParsed<T>(command: Command): Promise<CommandResult<T>>;
|
||||
prompt: <TResult, TArgs extends any[] = any[]>(
|
||||
def: PromptDef<TArgs>,
|
||||
validator: PromptValidator<TResult, TArgs>,
|
||||
currentPlayer?: string | null,
|
||||
) => Promise<TResult>;
|
||||
|
||||
// test only
|
||||
_state: MutableSignal<TState>;
|
||||
_commands: CommandRunnerContextExport<IGameContext<TState>>;
|
||||
_rng: RNG;
|
||||
export interface IGameContext<TState extends Record<string, unknown> = {} > {
|
||||
get value(): TState;
|
||||
get rng(): ReadonlyRNG;
|
||||
produce(fn: (draft: TState) => void): void;
|
||||
produceAsync(fn: (draft: TState) => void): Promise<void>;
|
||||
run<T>(input: string): Promise<CommandResult<T>>;
|
||||
runParsed<T>(command: Command): Promise<CommandResult<T>>;
|
||||
prompt: <TResult,TArgs extends any[]=any[]>(def: PromptDef<TArgs>, validator: PromptValidator<TResult,TArgs>, currentPlayer?: string | null) => Promise<TResult>;
|
||||
|
||||
// test only
|
||||
_state: MutableSignal<TState>;
|
||||
_commands: CommandRunnerContextExport<IGameContext<TState>>;
|
||||
_rng: RNG;
|
||||
}
|
||||
export type IGameContextExport<TState extends Record<string, unknown> = {}> =
|
||||
Omit<IGameContext<TState>, "_state" | "_commands" | "_rng">;
|
||||
|
||||
export function createGameContext<TState extends Record<string, unknown> = {}>(
|
||||
commandRegistry: CommandRegistry<IGameContext<TState>>,
|
||||
initialState?: TState | (() => TState),
|
||||
export function createGameContext<TState extends Record<string, unknown> = {} >(
|
||||
commandRegistry: CommandRegistry<IGameContext<TState>>,
|
||||
initialState?: TState | (() => TState)
|
||||
): IGameContext<TState> {
|
||||
const stateValue =
|
||||
typeof initialState === "function"
|
||||
? initialState()
|
||||
: (initialState ?? ({} as TState));
|
||||
const state = mutableSignal(stateValue);
|
||||
let commands: CommandRunnerContextExport<IGameContext<TState>> = null as any;
|
||||
const stateValue = typeof initialState === 'function' ? initialState() : initialState ?? {} as TState;
|
||||
const state = mutableSignal(stateValue);
|
||||
let commands: CommandRunnerContextExport<IGameContext<TState>> = null as any;
|
||||
|
||||
const context: IGameContext<TState> = {
|
||||
get value(): TState {
|
||||
return state.value;
|
||||
},
|
||||
get rng() {
|
||||
return this._rng;
|
||||
},
|
||||
produce(fn) {
|
||||
return state.produce(fn);
|
||||
},
|
||||
produceAsync(fn) {
|
||||
return state.produceAsync(fn);
|
||||
},
|
||||
run<T>(input: string) {
|
||||
return commands.run<T>(input);
|
||||
},
|
||||
runParsed<T>(command: Command) {
|
||||
return commands.runParsed<T>(command);
|
||||
},
|
||||
prompt(def, validator, currentPlayer) {
|
||||
return commands.prompt(
|
||||
def.schema,
|
||||
validator,
|
||||
def.hintText,
|
||||
currentPlayer,
|
||||
);
|
||||
},
|
||||
const context: IGameContext<TState> = {
|
||||
get value(): TState {
|
||||
return state.value;
|
||||
},
|
||||
get rng() {
|
||||
return this._rng;
|
||||
},
|
||||
produce(fn) {
|
||||
return state.produce(fn);
|
||||
},
|
||||
produceAsync(fn) {
|
||||
return state.produceAsync(fn);
|
||||
},
|
||||
run<T>(input: string) {
|
||||
return commands.run<T>(input);
|
||||
},
|
||||
runParsed<T>(command: Command) {
|
||||
return commands.runParsed<T>(command);
|
||||
},
|
||||
prompt(def, validator, currentPlayer) {
|
||||
return commands.prompt(def.schema, validator, def.hintText, currentPlayer);
|
||||
},
|
||||
|
||||
_state: state,
|
||||
_commands: commands,
|
||||
_rng: new Mulberry32RNG(),
|
||||
};
|
||||
|
||||
_state: state,
|
||||
_commands: commands,
|
||||
_rng: new Mulberry32RNG(),
|
||||
};
|
||||
|
||||
context._commands = commands = createCommandRunnerContext(
|
||||
commandRegistry,
|
||||
context,
|
||||
);
|
||||
|
||||
return context;
|
||||
context._commands = commands = createCommandRunnerContext(commandRegistry, context);
|
||||
|
||||
return context;
|
||||
}
|
||||
|
||||
export type PromptDef<TArgs extends any[] = any[]> = {
|
||||
schema: CommandSchema;
|
||||
hintText?: string;
|
||||
};
|
||||
export function createPromptDef<TArgs extends any[] = any[]>(
|
||||
schema: CommandSchema | string,
|
||||
hintText?: string,
|
||||
): PromptDef<TArgs> {
|
||||
schema = typeof schema === "string" ? parseCommandSchema(schema) : schema;
|
||||
return { schema, hintText };
|
||||
export type PromptDef<TArgs extends any[]=any[]> = {
|
||||
schema: CommandSchema,
|
||||
hintText?: string,
|
||||
}
|
||||
export function createPromptDef<TArgs extends any[]=any[]>(schema: CommandSchema | string, hintText?: string): PromptDef<TArgs> {
|
||||
schema = typeof schema === 'string' ? parseCommandSchema(schema) : schema;
|
||||
return { schema, hintText };
|
||||
}
|
||||
|
||||
export function createGameCommandRegistry<
|
||||
TState extends Record<string, unknown> = {},
|
||||
>() {
|
||||
return createCommandRegistry<IGameContext<TState>>();
|
||||
}
|
||||
export function createGameCommandRegistry<TState extends Record<string, unknown> = {} >() {
|
||||
return createCommandRegistry<IGameContext<TState>>();
|
||||
}
|
||||
|
|
@ -2,37 +2,39 @@
|
|||
# type: 'item' = inventory item card, 'status' = status effect card
|
||||
# costType: 'energy' = costs energy per turn, 'uses' = limited uses, 'none' = free
|
||||
# targetType: 'single' = target one enemy, 'none' = no target
|
||||
# effects := ~cardEffect(card)
|
||||
# onPlay: effects triggered when card is played
|
||||
# onDraw: effects triggered when card enters hand
|
||||
# onDiscard: effects triggered when card is discarded
|
||||
|
||||
id,name,desc,type,costType,costCount,targetType
|
||||
string,string,string,'item'|'status','energy'|'uses'|'none',int,'single'|'none'
|
||||
sword,剑,【攻击2】【攻击2】,item,energy,1,single
|
||||
greataxe,长斧,对全体【攻击5】,item,energy,2,none
|
||||
spear,长枪,【攻击2】【攻击2】【攻击2】,item,energy,1,single
|
||||
dagger,短刀,【攻击3】【攻击3】,item,energy,1,single
|
||||
dart,飞镖,【攻击1】抓一张牌,item,energy,0,single
|
||||
crossbow,十字弩,【攻击6】对同一目标打出其他十字弩,item,energy,2,single
|
||||
shield,盾,【防御3】,item,energy,1,none
|
||||
hat,斗笠,【防御8】,item,energy,2,none
|
||||
cape,披风,【防御2】下回合【防御2】,item,energy,1,none
|
||||
bracer,护腕,【防御1】抓1张牌,item,energy,0,none
|
||||
greatshield,大盾,【防御5】,item,energy,1,none
|
||||
chainmail,锁子甲,本回合受到伤害-3,item,energy,1,none
|
||||
bandage,绷带,从牌堆或弃牌堆随机移除1张伤口,item,uses,3,none
|
||||
poisonPotion,淬毒药剂,周围物品的【攻击】+2,item,uses,3,none
|
||||
fortifyPotion,强固药剂,周围物品的【防御】+2,item,uses,3,none
|
||||
vitalityPotion,活力药剂,获得1点能量,item,uses,3,none
|
||||
focusPotion,集中药剂,抓2张牌,item,uses,3,none
|
||||
healingPotion,治疗药剂,从牌堆或弃牌堆移除3张伤口,item,uses,3,none
|
||||
waterBag,水袋,下回合开始时获得1能量抓2张牌,item,energy,1,none
|
||||
rope,绳索,周围物品的牌【防御】+2直到打出,item,energy,1,none
|
||||
belt,腰带,从牌堆周围物品的牌当中选择一张加入手牌,item,energy,0,none
|
||||
torch,火把,下次打出周围物品的牌时将其消耗并获得1能量,item,energy,1,none
|
||||
whetstone,磨刀石,周围物品的牌【攻击】+3直到打出,item,energy,1,none
|
||||
blacksmithHammer,铁匠锤,从牌堆/弃牌堆选择一张牌随机变为一张周围物品的牌,item,energy,1,none
|
||||
wound,伤口,无效果占用手牌和牌堆,status,none,0,none
|
||||
venom,蛇毒,弃掉时受到3点伤害,status,none,0,none
|
||||
curse,诅咒,受攻击时物品攻击-1直到弃掉一张该物品的牌,status,none,0,none
|
||||
static,静电,在手里时受电击伤害+1,status,none,0,none
|
||||
fatigue,疲劳,占用手牌,status,none,0,none
|
||||
vultureEye,秃鹫之眼,抓到时获得3层暴露,status,none,0,none
|
||||
id,name,desc,type,costType,costCount,targetType,effects
|
||||
string,string,string,'item'|'status','energy'|'uses'|'none',int,'single'|'none',['onPlay'|'onDraw'|'onDiscard';'self'|'target'|'all'|'random';@effect;number][]
|
||||
sword,剑,【攻击2】【攻击2】,item,energy,1,single,[onPlay;target;attack;2];[onPlay;target;attack;2]
|
||||
greataxe,长斧,对全体【攻击5】,item,energy,2,none,[onPlay;all;attack;5]
|
||||
spear,长枪,【攻击2】【攻击2】【攻击2】,item,energy,1,single,[onPlay;target;attack;2];[onPlay;target;attack;2];[onPlay;target;attack;2]
|
||||
dagger,短刀,【攻击3】【攻击3】,item,energy,1,single,[onPlay;target;attack;3];[onPlay;target;attack;3]
|
||||
dart,飞镖,【攻击1】抓一张牌,item,energy,0,single,[onPlay;target;attack;1];[onPlay;self;draw;1]
|
||||
crossbow,十字弩,【攻击6】对同一目标打出其他十字弩,item,energy,2,single,[onPlay;target;attack;6];[onPlay;self;crossbow;0]
|
||||
shield,盾,【防御3】,item,energy,1,none,[onPlay;self;defend;3]
|
||||
hat,斗笠,【防御8】,item,energy,2,none,[onPlay;self;defend;8]
|
||||
cape,披风,【防御2】下回合【防御2】,item,energy,1,none,[onPlay;self;defend;2];[onPlay;self;defendNext;2]
|
||||
bracer,护腕,【防御1】抓1张牌,item,energy,0,none,[onPlay;self;defend;1];[onPlay;self;draw;1]
|
||||
greatshield,大盾,【防御5】,item,energy,1,none,[onPlay;self;defend;5]
|
||||
chainmail,锁子甲,本回合受到伤害-3,item,energy,1,none,[onPlay;self;damageReduce;3]
|
||||
bandage,绷带,从牌堆或弃牌堆随机移除1张伤口,item,uses,3,none,[onPlay;self;removeWound;1]
|
||||
poisonPotion,淬毒药剂,周围物品的【攻击】+2,item,uses,3,none,[onPlay;self;attackBuff;2]
|
||||
fortifyPotion,强固药剂,周围物品的【防御】+2,item,uses,3,none,[onPlay;self;defendBuff;2]
|
||||
vitalityPotion,活力药剂,获得1点能量,item,uses,3,none,[onPlay;self;gainEnergy;1]
|
||||
focusPotion,集中药剂,抓2张牌,item,uses,3,none,[onPlay;self;draw;2]
|
||||
healingPotion,治疗药剂,从牌堆或弃牌堆移除3张伤口,item,uses,3,none,[onPlay;self;removeWound;3]
|
||||
waterBag,水袋,下回合开始时获得1能量抓2张牌,item,energy,1,none,[onPlay;self;energyNext;1];[onPlay;self;drawNext;2]
|
||||
rope,绳索,周围物品的牌【防御】+2直到打出,item,energy,1,none,[onPlay;self;defendBuffUntilPlay;2]
|
||||
belt,腰带,从牌堆周围物品的牌当中选择一张加入手牌,item,energy,0,none,[onPlay;self;drawChoice;1]
|
||||
torch,火把,下次打出周围物品的牌时将其消耗并获得1能量,item,energy,1,none,[onPlay;self;burnForEnergy;1]
|
||||
whetstone,磨刀石,周围物品的牌【攻击】+3直到打出,item,energy,1,none,[onPlay;self;attackBuffUntilPlay;3]
|
||||
blacksmithHammer,铁匠锤,从牌堆/弃牌堆选择一张牌随机变为一张周围物品的牌,item,energy,1,none,[onPlay;self;transformRandom;1]
|
||||
wound,伤口,无效果占用手牌和牌堆,status,none,0,none,
|
||||
venom,蛇毒,弃掉时受到3点伤害,status,none,0,none,[onDiscard;self;attack;3]
|
||||
curse,诅咒,受攻击时物品攻击-1直到弃掉一张该物品的牌,status,none,0,none,[onDraw;self;curse;1]
|
||||
static,静电,在手里时受电击伤害+1,status,none,0,none,[onDraw;self;static;1]
|
||||
fatigue,疲劳,占用手牌,status,none,0,none,
|
||||
vultureEye,秃鹫之眼,抓到时获得3层暴露,status,none,0,none,[onDraw;self;expose;3]
|
||||
|
|
|
|||
|
|
|
@ -1,4 +1,4 @@
|
|||
import type { CardEffect } from './cardEffect.csv';
|
||||
import type { Effect } from './effect.csv';
|
||||
|
||||
type CardTable = readonly {
|
||||
readonly id: string;
|
||||
|
|
@ -8,7 +8,7 @@ type CardTable = readonly {
|
|||
readonly costType: "energy" | "uses" | "none";
|
||||
readonly costCount: number;
|
||||
readonly targetType: "single" | "none";
|
||||
readonly effects: CardEffect[];
|
||||
readonly effects: ["onPlay" | "onDraw" | "onDiscard", "self" | "target" | "all" | "random", Effect, number][];
|
||||
}[];
|
||||
|
||||
export type Card = CardTable[number];
|
||||
|
|
|
|||
|
|
@ -1,32 +0,0 @@
|
|||
id,card,trigger,target,effects
|
||||
string,@card,'onPlay'|'onDraw'|'onDiscard','self'|'target'|'all'|'random',[@effect;number][]
|
||||
sword,sword,onPlay,target,[attack;2];[attack;2]
|
||||
greataxe,greataxe,onPlay,all,[attack;5]
|
||||
spear,spear,onPlay,target,[attack;2];[attack;2];[attack;2]
|
||||
dagger,dagger,onPlay,target,[attack;3];[attack;3]
|
||||
dart,dart,onPlay,target,[attack;1]
|
||||
dart-draw,dart,onPlay,self,[draw;1]
|
||||
crossbow,crossbow,onPlay,target,[attack;6]
|
||||
crossbow-combo,crossbow,onPlay,self,[crossbow;0]
|
||||
shield,shield,onPlay,self,[defend;3]
|
||||
hat,hat,onPlay,self,[defend;8]
|
||||
cape,cape,onPlay,self,[defend;2];[defendNext;2]
|
||||
bracer,bracer,onPlay,self,[defend;1];[draw;1]
|
||||
greatshield,greatshield,onPlay,self,[defend;5]
|
||||
chainmail,chainmail,onPlay,self,[damageReduce;3]
|
||||
bandage,bandage,onPlay,self,[removeWound;1]
|
||||
poisonPotion,poisonPotion,onPlay,self,[attackBuff;2]
|
||||
fortifyPotion,fortifyPotion,onPlay,self,[defendBuff;2]
|
||||
vitalityPotion,vitalityPotion,onPlay,self,[gainEnergy;1]
|
||||
focusPotion,focusPotion,onPlay,self,[draw;2]
|
||||
healingPotion,healingPotion,onPlay,self,[removeWound;3]
|
||||
waterBag,waterBag,onPlay,self,[energyNext;1];[drawNext;2]
|
||||
rope,rope,onPlay,self,[defendBuffUntilPlay;2]
|
||||
belt,belt,onPlay,self,[drawChoice;1]
|
||||
torch,torch,onPlay,self,[burnForEnergy;1]
|
||||
whetstone,whetstone,onPlay,self,[attackBuffUntilPlay;3]
|
||||
blacksmithHammer,blacksmithHammer,onPlay,self,[transformRandom;1]
|
||||
venom,venom,onDiscard,self,[attack;3]
|
||||
curse,curse,onDraw,self,[curse;1]
|
||||
static,static,onDraw,self,[static;1]
|
||||
vultureEye,vultureEye,onDraw,self,[expose;3]
|
||||
|
|
|
@ -1,15 +0,0 @@
|
|||
import type { Card } from './card.csv';
|
||||
import type { Effect } from './effect.csv';
|
||||
|
||||
type CardEffectTable = readonly {
|
||||
readonly id: string;
|
||||
readonly card: Card;
|
||||
readonly trigger: "onPlay" | "onDraw" | "onDiscard";
|
||||
readonly target: "self" | "target" | "all" | "random";
|
||||
readonly effects: [Effect, number][];
|
||||
}[];
|
||||
|
||||
export type CardEffect = CardEffectTable[number];
|
||||
|
||||
declare function getData(): CardEffectTable;
|
||||
export default getData;
|
||||
|
|
@ -6,125 +6,116 @@ import { EffectData } from "@/samples/slay-the-spire-like/system/types";
|
|||
import getEffects from "../effect.csv";
|
||||
|
||||
export function addCardEventTriggers(triggers: Triggers) {
|
||||
const effects = getEffects();
|
||||
const effects = getEffects();
|
||||
|
||||
function findEffect(id: string): EffectData {
|
||||
const found = effects.find((e) => e.id === id);
|
||||
if (found) return found;
|
||||
return {
|
||||
id,
|
||||
name: id,
|
||||
description: "",
|
||||
lifecycle: "instant",
|
||||
} as EffectData;
|
||||
}
|
||||
|
||||
// storm: give static card to player when storm enemy attacks
|
||||
triggers.onEnemyIntent.use(async (ctx, next) => {
|
||||
await next();
|
||||
|
||||
const enemy = getCombatEntity(ctx.game.value, ctx.enemyId);
|
||||
if (!enemy || !enemy.isAlive) return;
|
||||
|
||||
const storm = enemy.effects.storm?.stacks ?? 0;
|
||||
if (storm > 0) {
|
||||
for (let i = 0; i < storm; i++) {
|
||||
await triggers.onEffectApplied.execute(ctx.game, {
|
||||
effect: findEffect("static"),
|
||||
entityKey: "player",
|
||||
stacks: 1,
|
||||
sourceEntityKey: ctx.enemyId,
|
||||
});
|
||||
}
|
||||
function findEffect(id: string): EffectData {
|
||||
const found = effects.find(e => e.id === id);
|
||||
if (found) return found;
|
||||
return { id, name: id, description: "", lifecycle: "instant" } as EffectData;
|
||||
}
|
||||
});
|
||||
|
||||
// crossbow: replay other crossbows on same target
|
||||
triggers.onEffectApplied.use(async (ctx, next) => {
|
||||
await next();
|
||||
// storm: give static card to player when storm enemy attacks
|
||||
triggers.onEnemyIntent.use(async (ctx, next) => {
|
||||
await next();
|
||||
|
||||
if (ctx.effect.id !== "crossbow" || !ctx.cardId || !ctx.targetId) return;
|
||||
const enemy = getCombatEntity(ctx.game.value, ctx.enemyId);
|
||||
if (!enemy || !enemy.isAlive) return;
|
||||
|
||||
const { cards, regions } = ctx.game.value.player.deck;
|
||||
const handIds = [...regions.hand.childIds];
|
||||
for (const id of handIds) {
|
||||
const card = cards[id];
|
||||
if (card && card.itemId === "crossbow" && id !== ctx.cardId) {
|
||||
await triggers.onCardPlayed.execute(ctx.game, {
|
||||
cardId: id,
|
||||
targetId: ctx.targetId,
|
||||
sourceEntityKey: "player",
|
||||
});
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
// burnForEnergy: consume adjacent item, gain energy when its card is played
|
||||
triggers.onCardPlayed.use(async (ctx, next) => {
|
||||
await next();
|
||||
|
||||
const card = ctx.game.value.player.deck.cards[ctx.cardId];
|
||||
if (!card) return;
|
||||
const playedItemId = card.itemId;
|
||||
|
||||
const adjacent = getAdjacentItems<GameItemMeta>(
|
||||
ctx.game.value.inventory,
|
||||
playedItemId,
|
||||
);
|
||||
for (const [adjItemId] of adjacent) {
|
||||
const adjEffects = ctx.game.value.player.itemEffects[adjItemId];
|
||||
if (!adjEffects) continue;
|
||||
const burn = adjEffects.burnForEnergy;
|
||||
if (!burn || burn.stacks <= 0) continue;
|
||||
|
||||
await ctx.game.produceAsync((draft) => {
|
||||
const item = draft.inventory.items.get(adjItemId);
|
||||
if (item) {
|
||||
draft.inventory.items.delete(adjItemId);
|
||||
const storm = enemy.effects.storm?.stacks ?? 0;
|
||||
if (storm > 0) {
|
||||
for (let i = 0; i < storm; i++) {
|
||||
await triggers.onEffectApplied.execute(ctx.game, {
|
||||
effect: findEffect("static"),
|
||||
entityKey: "player",
|
||||
stacks: 1,
|
||||
sourceEntityKey: ctx.enemyId,
|
||||
});
|
||||
}
|
||||
}
|
||||
draft.player.energy += burn.stacks;
|
||||
delete draft.player.itemEffects[adjItemId];
|
||||
});
|
||||
break;
|
||||
}
|
||||
});
|
||||
|
||||
// sandwormKing: heal 10 hp when player discards fatigue
|
||||
triggers.onCardDiscarded.use(async (ctx, next) => {
|
||||
await next();
|
||||
|
||||
const card = ctx.game.value.player.deck.cards[ctx.cardId];
|
||||
if (!card || card.cardData.id !== "fatigue") return;
|
||||
|
||||
const sandwormKing = ctx.game.value.enemies.find(
|
||||
(e) => e.enemy.id === "沙虫王" && e.isAlive,
|
||||
);
|
||||
if (!sandwormKing) return;
|
||||
|
||||
await ctx.game.produceAsync((draft) => {
|
||||
const king = draft.enemies.find((e) => e.id === sandwormKing.id);
|
||||
if (king) {
|
||||
king.hp = Math.min(king.hp + 10, king.maxHp);
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
// vulture: give vultureEye when vulture deals damage
|
||||
triggers.onDamage.use(async (ctx, next) => {
|
||||
await next();
|
||||
// crossbow: replay other crossbows on same target
|
||||
triggers.onEffectApplied.use(async (ctx, next) => {
|
||||
await next();
|
||||
|
||||
const dealt = ctx.amount - (ctx.prevented ?? 0);
|
||||
if (dealt <= 0 || !ctx.sourceEntityKey) return;
|
||||
if (ctx.effect.id !== "crossbow" || !ctx.cardId || !ctx.targetId) return;
|
||||
|
||||
const attacker = getCombatEntity(ctx.game.value, ctx.sourceEntityKey);
|
||||
if (!attacker || !("enemy" in attacker) || attacker.enemy.id !== "秃鹫")
|
||||
return;
|
||||
|
||||
await triggers.onEffectApplied.execute(ctx.game, {
|
||||
effect: findEffect("vultureEye"),
|
||||
entityKey: "player",
|
||||
stacks: 1,
|
||||
sourceEntityKey: ctx.sourceEntityKey,
|
||||
const { cards, regions } = ctx.game.value.player.deck;
|
||||
const handIds = [...regions.hand.childIds];
|
||||
for (const id of handIds) {
|
||||
const card = cards[id];
|
||||
if (card && card.itemId === "crossbow" && id !== ctx.cardId) {
|
||||
await triggers.onCardPlayed.execute(ctx.game, {
|
||||
cardId: id,
|
||||
targetId: ctx.targetId,
|
||||
sourceEntityKey: "player",
|
||||
});
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
// burnForEnergy: consume adjacent item, gain energy when its card is played
|
||||
triggers.onCardPlayed.use(async (ctx, next) => {
|
||||
await next();
|
||||
|
||||
const card = ctx.game.value.player.deck.cards[ctx.cardId];
|
||||
if (!card) return;
|
||||
const playedItemId = card.itemId;
|
||||
|
||||
const adjacent = getAdjacentItems<GameItemMeta>(ctx.game.value.inventory, playedItemId);
|
||||
for (const [adjItemId] of adjacent) {
|
||||
const adjEffects = ctx.game.value.player.itemEffects[adjItemId];
|
||||
if (!adjEffects) continue;
|
||||
const burn = adjEffects.burnForEnergy;
|
||||
if (!burn || burn.stacks <= 0) continue;
|
||||
|
||||
await ctx.game.produceAsync(draft => {
|
||||
const item = draft.inventory.items.get(adjItemId);
|
||||
if (item) {
|
||||
draft.inventory.items.delete(adjItemId);
|
||||
}
|
||||
draft.player.energy += burn.stacks;
|
||||
delete draft.player.itemEffects[adjItemId];
|
||||
});
|
||||
break;
|
||||
}
|
||||
});
|
||||
|
||||
// sandwormKing: heal 10 hp when player discards fatigue
|
||||
triggers.onCardDiscarded.use(async (ctx, next) => {
|
||||
await next();
|
||||
|
||||
const card = ctx.game.value.player.deck.cards[ctx.cardId];
|
||||
if (!card || card.cardData.id !== "fatigue") return;
|
||||
|
||||
const sandwormKing = ctx.game.value.enemies.find(
|
||||
e => e.enemy.id === "沙虫王" && e.isAlive
|
||||
);
|
||||
if (!sandwormKing) return;
|
||||
|
||||
await ctx.game.produceAsync(draft => {
|
||||
const king = draft.enemies.find(e => e.id === sandwormKing.id);
|
||||
if (king) {
|
||||
king.hp = Math.min(king.hp + 10, king.maxHp);
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
// vulture: give vultureEye when vulture deals damage
|
||||
triggers.onDamage.use(async (ctx, next) => {
|
||||
await next();
|
||||
|
||||
const dealt = ctx.amount - (ctx.prevented ?? 0);
|
||||
if (dealt <= 0 || !ctx.sourceEntityKey) return;
|
||||
|
||||
const attacker = getCombatEntity(ctx.game.value, ctx.sourceEntityKey);
|
||||
if (!attacker || !("enemy" in attacker) || attacker.enemy.id !== "秃鹫") return;
|
||||
|
||||
await triggers.onEffectApplied.execute(ctx.game, {
|
||||
effect: findEffect("vultureEye"),
|
||||
entityKey: "player",
|
||||
stacks: 1,
|
||||
sourceEntityKey: ctx.sourceEntityKey,
|
||||
});
|
||||
});
|
||||
});
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,327 +1,240 @@
|
|||
import { CombatGameContext } from "./types";
|
||||
import {CombatGameContext} from "./types";
|
||||
import {
|
||||
addEntityEffect,
|
||||
addItemEffect,
|
||||
getAliveEnemies,
|
||||
onEntityPostureDamage,
|
||||
onEntityEffectUpkeep,
|
||||
onPlayerItemEffectUpkeep,
|
||||
onItemDiscard,
|
||||
onItemPlay,
|
||||
payCardCost,
|
||||
getCombatEntity,
|
||||
getEffectTargets,
|
||||
addEntityEffect,
|
||||
addItemEffect,
|
||||
getAliveEnemies, onEntityPostureDamage,
|
||||
onEntityEffectUpkeep,
|
||||
onPlayerItemEffectUpkeep, onItemDiscard, onItemPlay, payCardCost, getCombatEntity, getEffectTargets
|
||||
} from "@/samples/slay-the-spire-like/system/combat/effects";
|
||||
import { promptMainAction } from "@/samples/slay-the-spire-like/system/combat/prompts";
|
||||
import { moveToRegion, shuffle } from "@/core/region";
|
||||
import { createMiddlewareChain } from "@/utils/middleware";
|
||||
import { EffectData } from "@/samples/slay-the-spire-like/system/types";
|
||||
import { getAdjacentItems } from "@/samples/slay-the-spire-like/system/grid-inventory";
|
||||
import { GameItemMeta } from "@/samples/slay-the-spire-like/system/progress";
|
||||
import {promptMainAction} from "@/samples/slay-the-spire-like/system/combat/prompts";
|
||||
import {moveToRegion, shuffle} from "@/core/region";
|
||||
import {createMiddlewareChain} from "@/utils/middleware";
|
||||
import {EffectData} from "@/samples/slay-the-spire-like/system/types";
|
||||
import {getAdjacentItems} from "@/samples/slay-the-spire-like/system/grid-inventory";
|
||||
import {GameItemMeta} from "@/samples/slay-the-spire-like/system/progress";
|
||||
|
||||
type TriggerTypes = {
|
||||
onCombatStart: {};
|
||||
onTurnStart: { entityKey: "player" | string };
|
||||
onTurnEnd: { entityKey: "player" | string };
|
||||
onShuffle: {};
|
||||
onCardPlayed: {
|
||||
cardId: string;
|
||||
targetId?: string;
|
||||
sourceEntityKey?: "player" | string;
|
||||
};
|
||||
onCardDiscarded: { cardId: string; sourceEntityKey?: "player" | string };
|
||||
onCardDrawn: { cardId: string; sourceEntityKey?: "player" | string };
|
||||
onDraw: { count: number };
|
||||
onEffectApplied: {
|
||||
effect: EffectData;
|
||||
entityKey: "player" | string;
|
||||
stacks: number;
|
||||
cardId?: string;
|
||||
sourceEntityKey?: "player" | string;
|
||||
targetId?: string;
|
||||
};
|
||||
onHpChange: { entityKey: "player" | string; amount: number };
|
||||
onDamage: {
|
||||
entityKey: "player" | string;
|
||||
amount: number;
|
||||
prevented?: number;
|
||||
sourceEntityKey?: "player" | string;
|
||||
};
|
||||
onEnemyIntent: { enemyId: string; sourceEntityKey?: "player" | string };
|
||||
onIntentUpdate: { enemyId: string };
|
||||
};
|
||||
|
||||
export function createTriggers() {
|
||||
const triggers = {
|
||||
onCombatStart: createTrigger("onCombatStart"),
|
||||
onTurnStart: createTrigger("onTurnStart", async (ctx) => {
|
||||
await ctx.game.produceAsync((draft) => {
|
||||
const entity = getCombatEntity(draft, ctx.entityKey);
|
||||
if (entity) onEntityEffectUpkeep(entity);
|
||||
if (entity === draft.player) onPlayerItemEffectUpkeep(draft.player);
|
||||
});
|
||||
}),
|
||||
onTurnEnd: createTrigger("onTurnEnd", async (ctx) => {
|
||||
if (ctx.entityKey !== "player") return;
|
||||
const { regions } = ctx.game.value.player.deck;
|
||||
for (const cardId of Object.values(regions.hand.childIds)) {
|
||||
await triggers.onCardDiscarded.execute(ctx.game, { cardId });
|
||||
}
|
||||
await ctx.game.produceAsync(
|
||||
(draft) => (draft.player.energy = draft.player.maxEnergy),
|
||||
);
|
||||
await triggers.onDraw.execute(ctx.game, { count: 5 });
|
||||
}),
|
||||
onShuffle: createTrigger("onShuffle", async (ctx) => {
|
||||
await ctx.game.produceAsync((draft) => {
|
||||
const { cards, regions } = draft.player.deck;
|
||||
for (const cardId of Object.values(regions.discardPile.childIds))
|
||||
moveToRegion(cards[cardId], regions.discardPile, regions.drawPile);
|
||||
shuffle(regions.drawPile, cards, ctx.game.rng);
|
||||
});
|
||||
}),
|
||||
onCardPlayed: createTrigger("onCardPlayed", async (ctx) => {
|
||||
await ctx.game.produceAsync((draft) => {
|
||||
const { cards, regions } = draft.player.deck;
|
||||
const card = cards[ctx.cardId];
|
||||
payCardCost(
|
||||
draft.player,
|
||||
card.cardData.costType,
|
||||
card.cardData.costCount,
|
||||
card.itemId,
|
||||
draft.inventory,
|
||||
);
|
||||
moveToRegion(card, regions.hand, regions.discardPile);
|
||||
onItemPlay(draft.player, card.itemId);
|
||||
});
|
||||
const { cards, regions } = ctx.game.value.player.deck;
|
||||
const card = cards[ctx.cardId];
|
||||
const source = ctx.sourceEntityKey ?? "player";
|
||||
for (const { trigger, target, effects } of card.cardData.effects) {
|
||||
if (trigger !== "onPlay") continue;
|
||||
for (const [effect, stacks] of effects)
|
||||
for (const entity of getEffectTargets(target, ctx.game, ctx.targetId))
|
||||
await triggers.onEffectApplied.execute(ctx.game, {
|
||||
effect,
|
||||
entityKey: entity.id,
|
||||
stacks,
|
||||
cardId: ctx.cardId,
|
||||
sourceEntityKey: source,
|
||||
targetId: ctx.targetId,
|
||||
});
|
||||
}
|
||||
}),
|
||||
onCardDiscarded: createTrigger("onCardDiscarded", async (ctx) => {
|
||||
await ctx.game.produceAsync((draft) => {
|
||||
const { cards, regions } = draft.player.deck;
|
||||
moveToRegion(cards[ctx.cardId], regions.hand, regions.discardPile);
|
||||
onItemDiscard(draft.player, cards[ctx.cardId].itemId);
|
||||
});
|
||||
const { cards, regions } = ctx.game.value.player.deck;
|
||||
const card = cards[ctx.cardId];
|
||||
const source = ctx.sourceEntityKey ?? "player";
|
||||
for (const { trigger, target, effects } of card.cardData.effects) {
|
||||
if (trigger !== "onDiscard") continue;
|
||||
for (const [effect, stacks] of effects)
|
||||
for (const entity of getEffectTargets(target, ctx.game))
|
||||
await triggers.onEffectApplied.execute(ctx.game, {
|
||||
effect,
|
||||
entityKey: entity.id,
|
||||
stacks,
|
||||
cardId: ctx.cardId,
|
||||
sourceEntityKey: source,
|
||||
});
|
||||
}
|
||||
}),
|
||||
onCardDrawn: createTrigger("onCardDrawn", async (ctx) => {
|
||||
await ctx.game.produceAsync((draft) => {
|
||||
const { cards, regions } = draft.player.deck;
|
||||
moveToRegion(cards[ctx.cardId], regions.drawPile, regions.hand);
|
||||
});
|
||||
const { cards, regions } = ctx.game.value.player.deck;
|
||||
const card = cards[ctx.cardId];
|
||||
const source = ctx.sourceEntityKey ?? "player";
|
||||
for (const { trigger, target, effects } of card.cardData.effects) {
|
||||
if (trigger !== "onDraw") continue;
|
||||
for (const [effect, stacks] of effects)
|
||||
for (const entity of getEffectTargets(target, ctx.game))
|
||||
await triggers.onEffectApplied.execute(ctx.game, {
|
||||
effect,
|
||||
entityKey: entity.id,
|
||||
stacks,
|
||||
cardId: ctx.cardId,
|
||||
sourceEntityKey: source,
|
||||
});
|
||||
}
|
||||
}),
|
||||
onDraw: createTrigger("onDraw", async (ctx) => {
|
||||
let toDraw = ctx.count;
|
||||
while (toDraw > 0) {
|
||||
let inDraw =
|
||||
ctx.game.value.player.deck.regions.drawPile.childIds.length;
|
||||
if (inDraw <= 0) await triggers.onShuffle.execute(ctx.game, {});
|
||||
|
||||
inDraw = ctx.game.value.player.deck.regions.drawPile.childIds.length;
|
||||
if (inDraw <= 0) break;
|
||||
|
||||
const children = ctx.game.value.player.deck.regions.drawPile.childIds;
|
||||
const cardId = children[children.length - 1];
|
||||
await triggers.onCardDrawn.execute(ctx.game, { cardId });
|
||||
toDraw--;
|
||||
}
|
||||
}),
|
||||
onEffectApplied: createTrigger("onEffectApplied", async (ctx) => {
|
||||
if (ctx.effect.lifecycle === "instant") return;
|
||||
|
||||
if (ctx.effect.lifecycle.startsWith("item")) {
|
||||
if (ctx.cardId) {
|
||||
const card = ctx.game.value.player.deck.cards[ctx.cardId];
|
||||
const nearby = getAdjacentItems<GameItemMeta>(
|
||||
ctx.game.value.inventory,
|
||||
card.itemId,
|
||||
);
|
||||
for (const itemId of nearby.keys()) {
|
||||
await ctx.game.produceAsync((draft) => {
|
||||
addItemEffect(draft.player, itemId, ctx.effect, ctx.stacks);
|
||||
});
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
await ctx.game.produceAsync((draft) => {
|
||||
const entity =
|
||||
ctx.entityKey === "player"
|
||||
? draft.player
|
||||
: draft.enemies.find((e) => e.id === ctx.entityKey);
|
||||
if (entity) addEntityEffect(entity, ctx.effect, ctx.stacks);
|
||||
});
|
||||
}),
|
||||
onHpChange: createTrigger("onHpChange", async (ctx) => {
|
||||
await ctx.game.produceAsync((draft) => {
|
||||
const entity =
|
||||
ctx.entityKey === "player"
|
||||
? draft.player
|
||||
: draft.enemies.find((e) => e.id === ctx.entityKey);
|
||||
if (!entity) return;
|
||||
entity.hp += ctx.amount;
|
||||
entity.isAlive = entity.hp > 0;
|
||||
draft.result = !draft.player.isAlive
|
||||
? "defeat"
|
||||
: draft.enemies.every((e) => !e.isAlive)
|
||||
? "victory"
|
||||
: null;
|
||||
});
|
||||
if (ctx.game.value.result) throw ctx.game.value;
|
||||
}),
|
||||
onDamage: createTrigger("onDamage", async (ctx) => {
|
||||
const entity =
|
||||
ctx.entityKey === "player"
|
||||
? ctx.game.value.player
|
||||
: ctx.game.value.enemies.find((e) => e.id === ctx.entityKey);
|
||||
if (!entity || !entity.isAlive) return;
|
||||
const dealt = Math.min(
|
||||
Math.max(0, entity.hp),
|
||||
ctx.amount - (ctx.prevented || 0),
|
||||
);
|
||||
await ctx.game.produceAsync((draft) => {
|
||||
onEntityPostureDamage(entity, dealt);
|
||||
});
|
||||
await triggers.onHpChange.execute(ctx.game, {
|
||||
entityKey: ctx.entityKey,
|
||||
amount: -dealt,
|
||||
});
|
||||
}),
|
||||
onEnemyIntent: createTrigger("onEnemyIntent", async (ctx) => {
|
||||
const enemy = ctx.game.value.enemies.find((e) => e.id === ctx.enemyId);
|
||||
if (!enemy || !enemy.isAlive) return;
|
||||
|
||||
const intent = enemy.currentIntent;
|
||||
if (!intent) return;
|
||||
|
||||
const source = ctx.sourceEntityKey ?? enemy.id;
|
||||
for (const [target, effect, stacks] of intent.effects) {
|
||||
for (const entity of getEffectTargets(target, ctx.game))
|
||||
await triggers.onEffectApplied.execute(ctx.game, {
|
||||
effect,
|
||||
entityKey: entity.id,
|
||||
stacks,
|
||||
sourceEntityKey: source,
|
||||
});
|
||||
}
|
||||
}),
|
||||
onIntentUpdate: createTrigger("onIntentUpdate", async (ctx) => {
|
||||
await ctx.game.produceAsync((draft) => {
|
||||
const enemy = draft.enemies.find((e) => e.id === ctx.enemyId);
|
||||
if (!enemy) return;
|
||||
|
||||
const intent = enemy.currentIntent;
|
||||
if (!intent) return;
|
||||
|
||||
const nextIntents = intent.nextIntents;
|
||||
if (nextIntents.length > 0) {
|
||||
const nextIndex = ctx.game.rng.nextInt(nextIntents.length);
|
||||
enemy.currentIntent = nextIntents[nextIndex];
|
||||
}
|
||||
});
|
||||
}),
|
||||
};
|
||||
return triggers;
|
||||
onCombatStart: {},
|
||||
onTurnStart: { entityKey: "player" | string, },
|
||||
onTurnEnd: { entityKey: "player" | string, },
|
||||
onShuffle: {},
|
||||
onCardPlayed: { cardId: string, targetId?: string, sourceEntityKey?: "player" | string },
|
||||
onCardDiscarded: { cardId: string, sourceEntityKey?: "player" | string },
|
||||
onCardDrawn: { cardId: string, sourceEntityKey?: "player" | string },
|
||||
onDraw: {count: number},
|
||||
onEffectApplied: { effect: EffectData, entityKey: "player" | string, stacks: number, cardId?: string, sourceEntityKey?: "player" | string, targetId?: string },
|
||||
onHpChange: { entityKey: "player" | string, amount: number},
|
||||
onDamage: { entityKey: "player" | string, amount: number, prevented?: number, sourceEntityKey?: "player" | string},
|
||||
onEnemyIntent: { enemyId: string, sourceEntityKey?: "player" | string },
|
||||
onIntentUpdate: { enemyId: string },
|
||||
}
|
||||
export type Triggers = ReturnType<typeof createTriggers>;
|
||||
export function createStartWith(build: (triggers: Triggers) => void) {
|
||||
const triggers = createTriggers();
|
||||
build(triggers);
|
||||
return async function (game: CombatGameContext) {
|
||||
await triggers.onCombatStart.execute(game, {});
|
||||
|
||||
try {
|
||||
while (true) {
|
||||
await triggers.onTurnStart.execute(game, { entityKey: "player" });
|
||||
while (true) {
|
||||
const action = await promptMainAction(game);
|
||||
if (action.action === "end-turn") break;
|
||||
if (action.action === "play") {
|
||||
await triggers.onCardPlayed.execute(game, action);
|
||||
}
|
||||
}
|
||||
await triggers.onTurnEnd.execute(game, { entityKey: "player" });
|
||||
function createTriggers(){
|
||||
const triggers = {
|
||||
onCombatStart: createTrigger("onCombatStart"),
|
||||
onTurnStart: createTrigger("onTurnStart", async ctx => {
|
||||
await ctx.game.produceAsync(draft => {
|
||||
const entity = getCombatEntity(draft, ctx.entityKey);
|
||||
if(entity) onEntityEffectUpkeep(entity);
|
||||
if(entity === draft.player)
|
||||
onPlayerItemEffectUpkeep(draft.player);
|
||||
})
|
||||
}),
|
||||
onTurnEnd: createTrigger("onTurnEnd", async ctx => {
|
||||
if(ctx.entityKey !== "player")return;
|
||||
const {regions} = ctx.game.value.player.deck;
|
||||
for(const cardId of Object.values(regions.hand.childIds)){
|
||||
await triggers.onCardDiscarded.execute(ctx.game,{cardId});
|
||||
}
|
||||
await ctx.game.produceAsync(draft => draft.player.energy = draft.player.maxEnergy);
|
||||
await triggers.onDraw.execute(ctx.game,{count: 5});
|
||||
}),
|
||||
onShuffle: createTrigger("onShuffle", async ctx => {
|
||||
await ctx.game.produceAsync(draft => {
|
||||
const {cards, regions} = draft.player.deck;
|
||||
for(const cardId of Object.values(regions.discardPile.childIds))
|
||||
moveToRegion(cards[cardId], regions.discardPile, regions.drawPile);
|
||||
shuffle(regions.drawPile, cards, ctx.game.rng);
|
||||
});
|
||||
}),
|
||||
onCardPlayed: createTrigger("onCardPlayed", async ctx => {
|
||||
await ctx.game.produceAsync(draft => {
|
||||
const {cards, regions} = draft.player.deck;
|
||||
const card = cards[ctx.cardId];
|
||||
payCardCost(draft.player, card.cardData.costType, card.cardData.costCount, card.itemId, draft.inventory);
|
||||
moveToRegion(card, regions.hand, regions.discardPile);
|
||||
onItemPlay(draft.player, card.itemId);
|
||||
});
|
||||
const {cards, regions} = ctx.game.value.player.deck;
|
||||
const card = cards[ctx.cardId];
|
||||
const source = ctx.sourceEntityKey ?? "player";
|
||||
for(const [trigger, target, effect, stacks] of card.cardData.effects){
|
||||
if(trigger !== 'onPlay') continue;
|
||||
for(const entity of getEffectTargets(target, ctx.game, ctx.targetId))
|
||||
await triggers.onEffectApplied.execute(ctx.game,{effect, entityKey: entity.id, stacks, cardId: ctx.cardId, sourceEntityKey: source, targetId: ctx.targetId});
|
||||
}
|
||||
}),
|
||||
onCardDiscarded: createTrigger("onCardDiscarded", async ctx => {
|
||||
await ctx.game.produceAsync(draft => {
|
||||
const {cards, regions} = draft.player.deck;
|
||||
moveToRegion(cards[ctx.cardId], regions.hand, regions.discardPile);
|
||||
onItemDiscard(draft.player, cards[ctx.cardId].itemId);
|
||||
});
|
||||
const {cards, regions} = ctx.game.value.player.deck;
|
||||
const card = cards[ctx.cardId];
|
||||
const source = ctx.sourceEntityKey ?? "player";
|
||||
for(const [trigger, target, effect, stacks] of card.cardData.effects){
|
||||
if(trigger !== 'onDiscard') continue;
|
||||
for(const entity of getEffectTargets(target, ctx.game))
|
||||
await triggers.onEffectApplied.execute(ctx.game,{effect, entityKey: entity.id, stacks, cardId: ctx.cardId, sourceEntityKey: source});
|
||||
}
|
||||
}),
|
||||
onCardDrawn: createTrigger("onCardDrawn", async ctx => {
|
||||
await ctx.game.produceAsync(draft => {
|
||||
const {cards, regions} = draft.player.deck;
|
||||
moveToRegion(cards[ctx.cardId], regions.drawPile, regions.hand);
|
||||
});
|
||||
const {cards, regions} = ctx.game.value.player.deck;
|
||||
const card = cards[ctx.cardId];
|
||||
const source = ctx.sourceEntityKey ?? "player";
|
||||
for(const [trigger, target, effect, stacks] of card.cardData.effects){
|
||||
if(trigger !== 'onDraw') continue;
|
||||
for(const entity of getEffectTargets(target, ctx.game))
|
||||
await triggers.onEffectApplied.execute(ctx.game,{effect, entityKey: entity.id, stacks, cardId: ctx.cardId, sourceEntityKey: source});
|
||||
}
|
||||
}),
|
||||
onDraw: createTrigger("onDraw", async ctx => {
|
||||
let toDraw = ctx.count;
|
||||
while(toDraw > 0){
|
||||
let inDraw = ctx.game.value.player.deck.regions.drawPile.childIds.length;
|
||||
if(inDraw <= 0) await triggers.onShuffle.execute(ctx.game,{});
|
||||
|
||||
for (const enemy of getAliveEnemies(game.value)) {
|
||||
await triggers.onTurnStart.execute(game, { entityKey: enemy.id });
|
||||
}
|
||||
for (const enemy of getAliveEnemies(game.value)) {
|
||||
await triggers.onEnemyIntent.execute(game, { enemyId: enemy.id });
|
||||
await triggers.onIntentUpdate.execute(game, { enemyId: enemy.id });
|
||||
}
|
||||
for (const enemy of getAliveEnemies(game.value)) {
|
||||
await triggers.onTurnEnd.execute(game, { entityKey: enemy.id });
|
||||
}
|
||||
}
|
||||
} catch (e) {
|
||||
if (e === game.value) return game.value.result;
|
||||
throw e;
|
||||
inDraw = ctx.game.value.player.deck.regions.drawPile.childIds.length;
|
||||
if(inDraw <= 0) break;
|
||||
|
||||
const children = ctx.game.value.player.deck.regions.drawPile.childIds;
|
||||
const cardId = children[children.length - 1];
|
||||
await triggers.onCardDrawn.execute(ctx.game,{cardId});
|
||||
toDraw--;
|
||||
}
|
||||
}),
|
||||
onEffectApplied: createTrigger("onEffectApplied", async ctx => {
|
||||
if(ctx.effect.lifecycle === 'instant') return;
|
||||
|
||||
if(ctx.effect.lifecycle.startsWith("item")) {
|
||||
if(ctx.cardId){
|
||||
const card = ctx.game.value.player.deck.cards[ctx.cardId];
|
||||
const nearby = getAdjacentItems<GameItemMeta>(ctx.game.value.inventory, card.itemId);
|
||||
for(const itemId of nearby.keys()){
|
||||
await ctx.game.produceAsync(draft => {
|
||||
addItemEffect(draft.player, itemId, ctx.effect, ctx.stacks);
|
||||
});
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
await ctx.game.produceAsync(draft => {
|
||||
const entity = ctx.entityKey === "player" ? draft.player : draft.enemies.find(e => e.id === ctx.entityKey);
|
||||
if(entity) addEntityEffect(entity, ctx.effect, ctx.stacks);
|
||||
})
|
||||
}),
|
||||
onHpChange: createTrigger("onHpChange", async ctx => {
|
||||
await ctx.game.produceAsync(draft => {
|
||||
const entity = ctx.entityKey === "player" ? draft.player : draft.enemies.find(e => e.id === ctx.entityKey);
|
||||
if(!entity) return;
|
||||
entity.hp += ctx.amount;
|
||||
entity.isAlive = entity.hp > 0;
|
||||
draft.result = !draft.player.isAlive ? "defeat" : draft.enemies.every(e => !e.isAlive) ? "victory" : null;
|
||||
});
|
||||
if(ctx.game.value.result) throw ctx.game.value;
|
||||
}),
|
||||
onDamage: createTrigger("onDamage", async ctx => {
|
||||
const entity = ctx.entityKey === "player" ? ctx.game.value.player : ctx.game.value.enemies.find(e => e.id === ctx.entityKey);
|
||||
if(!entity || !entity.isAlive) return;
|
||||
const dealt = Math.min(Math.max(0,entity.hp), ctx.amount - (ctx.prevented || 0));
|
||||
await ctx.game.produceAsync(draft => {
|
||||
onEntityPostureDamage(entity, dealt);
|
||||
});
|
||||
await triggers.onHpChange.execute(ctx.game,{entityKey: ctx.entityKey, amount: -dealt});
|
||||
}),
|
||||
onEnemyIntent: createTrigger("onEnemyIntent", async ctx => {
|
||||
const enemy = ctx.game.value.enemies.find(e => e.id === ctx.enemyId);
|
||||
if(!enemy || !enemy.isAlive) return;
|
||||
|
||||
const intent = enemy.currentIntent;
|
||||
if(!intent) return;
|
||||
|
||||
const source = ctx.sourceEntityKey ?? enemy.id;
|
||||
for(const [target, effect, stacks] of intent.effects){
|
||||
for(const entity of getEffectTargets(target, ctx.game))
|
||||
await triggers.onEffectApplied.execute(ctx.game, { effect, entityKey: entity.id, stacks, sourceEntityKey: source });
|
||||
}
|
||||
}),
|
||||
onIntentUpdate: createTrigger("onIntentUpdate", async ctx => {
|
||||
await ctx.game.produceAsync(draft => {
|
||||
const enemy = draft.enemies.find(e => e.id === ctx.enemyId);
|
||||
if(!enemy) return;
|
||||
|
||||
const intent = enemy.currentIntent;
|
||||
if(!intent) return;
|
||||
|
||||
const nextIntents = intent.nextIntents;
|
||||
if(nextIntents.length > 0){
|
||||
const nextIndex = ctx.game.rng.nextInt(nextIntents.length);
|
||||
enemy.currentIntent = nextIntents[nextIndex];
|
||||
}
|
||||
});
|
||||
}),
|
||||
}
|
||||
return triggers;
|
||||
}
|
||||
export type Triggers = ReturnType<typeof createTriggers>
|
||||
export function createStartWith(build: (triggers: Triggers) => void){
|
||||
const triggers = createTriggers();
|
||||
build(triggers);
|
||||
return async function(game: CombatGameContext){
|
||||
await triggers.onCombatStart.execute(game,{});
|
||||
|
||||
try {
|
||||
while (true) {
|
||||
await triggers.onTurnStart.execute(game, {entityKey: "player"});
|
||||
while (true) {
|
||||
const action = await promptMainAction(game);
|
||||
if (action.action === "end-turn") break;
|
||||
if (action.action === "play") {
|
||||
await triggers.onCardPlayed.execute(game, action);
|
||||
}
|
||||
}
|
||||
await triggers.onTurnEnd.execute(game, {entityKey: "player"});
|
||||
|
||||
for (const enemy of getAliveEnemies(game.value)) {
|
||||
await triggers.onTurnStart.execute(game, {entityKey: enemy.id});
|
||||
}
|
||||
for (const enemy of getAliveEnemies(game.value)) {
|
||||
await triggers.onEnemyIntent.execute(game, {enemyId: enemy.id});
|
||||
await triggers.onIntentUpdate.execute(game, {enemyId: enemy.id});
|
||||
}
|
||||
for (const enemy of getAliveEnemies(game.value)) {
|
||||
await triggers.onTurnEnd.execute(game, {entityKey: enemy.id});
|
||||
}
|
||||
}
|
||||
}catch(e){
|
||||
if(e === game.value) return game.value.result;
|
||||
throw e;
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
type TriggerContext<TKey extends keyof TriggerTypes> = TriggerTypes[TKey] & {
|
||||
event: TKey;
|
||||
game: CombatGameContext;
|
||||
};
|
||||
function createTrigger<TKey extends keyof TriggerTypes>(
|
||||
event: TKey,
|
||||
fallback?: (ctx: TriggerContext<TKey>) => Promise<void>,
|
||||
) {
|
||||
const { use, execute } = createMiddlewareChain<TriggerContext<TKey>, void>(
|
||||
fallback,
|
||||
);
|
||||
return {
|
||||
use,
|
||||
execute: async (game: CombatGameContext, ctx: TriggerTypes[TKey]) => {
|
||||
const param = { ...ctx, game, event };
|
||||
await execute(param);
|
||||
return param;
|
||||
},
|
||||
};
|
||||
}
|
||||
type TriggerContext<TKey extends keyof TriggerTypes> = TriggerTypes[TKey] & { event: TKey, game: CombatGameContext };
|
||||
function createTrigger<TKey extends keyof TriggerTypes>(event: TKey, fallback?: (ctx: TriggerContext<TKey>) => Promise<void>) {
|
||||
const {use, execute} = createMiddlewareChain<TriggerContext<TKey>,void>(fallback);
|
||||
return {
|
||||
use,
|
||||
execute: async (game: CombatGameContext, ctx: TriggerTypes[TKey]) => {
|
||||
const param = {...ctx, game, event};
|
||||
await execute(param);
|
||||
return param;
|
||||
},
|
||||
}
|
||||
}
|
||||
|
|
@ -1,59 +1,53 @@
|
|||
import type { PlayerDeck } from "../deck/types";
|
||||
import {
|
||||
EnemyData,
|
||||
IntentData,
|
||||
} from "@/samples/slay-the-spire-like/system/types";
|
||||
import { EffectData } from "@/samples/slay-the-spire-like/system/types";
|
||||
import { GridInventory } from "@/samples/slay-the-spire-like/system/grid-inventory";
|
||||
import { GameItemMeta } from "@/samples/slay-the-spire-like/system/progress";
|
||||
import {EnemyData, IntentData} from "@/samples/slay-the-spire-like/system/types";
|
||||
import {EffectData} from "@/samples/slay-the-spire-like/system/types";
|
||||
import {GridInventory} from "@/samples/slay-the-spire-like/system/grid-inventory";
|
||||
import {GameItemMeta} from "@/samples/slay-the-spire-like/system/progress";
|
||||
|
||||
export type EffectTable = Record<string, { data: EffectData; stacks: number }>;
|
||||
export type EffectTable = Record<string, {data: EffectData, stacks: number}>;
|
||||
|
||||
export type CombatEntity = {
|
||||
id: string; // player is just "player"
|
||||
effects: EffectTable;
|
||||
hp: number;
|
||||
maxHp: number;
|
||||
isAlive: boolean;
|
||||
id: string; // player is just "player"
|
||||
effects: EffectTable;
|
||||
hp: number;
|
||||
maxHp: number;
|
||||
isAlive: boolean;
|
||||
};
|
||||
|
||||
export type PlayerEntity = CombatEntity & {
|
||||
energy: number;
|
||||
maxEnergy: number;
|
||||
deck: PlayerDeck;
|
||||
itemEffects: Record<string, EffectTable>;
|
||||
};
|
||||
energy: number;
|
||||
maxEnergy: number;
|
||||
deck: PlayerDeck;
|
||||
itemEffects: Record<string, EffectTable>;
|
||||
}
|
||||
|
||||
export type EnemyEntity = CombatEntity & {
|
||||
enemy: EnemyData;
|
||||
intents: Record<string, IntentData>;
|
||||
currentIntent: IntentData;
|
||||
enemy: EnemyData;
|
||||
intents: Record<string, IntentData>;
|
||||
currentIntent: IntentData;
|
||||
};
|
||||
|
||||
export type CombatPhase = "playerTurn" | "enemyTurn" | "combatEnd";
|
||||
export type CombatResult = "victory" | "defeat";
|
||||
|
||||
export type LootEntry =
|
||||
| {
|
||||
type: "gold";
|
||||
amount: number;
|
||||
}
|
||||
| {
|
||||
type: "item";
|
||||
itemId: string;
|
||||
};
|
||||
|
||||
export type CombatState = {
|
||||
enemies: EnemyEntity[];
|
||||
player: PlayerEntity;
|
||||
inventory: GridInventory<GameItemMeta>;
|
||||
|
||||
phase: CombatPhase;
|
||||
turnNumber: number;
|
||||
result: CombatResult | null;
|
||||
|
||||
loot: LootEntry[];
|
||||
export type LootEntry = {
|
||||
type: "gold";
|
||||
amount: number;
|
||||
} | {
|
||||
type: "item",
|
||||
itemId: string;
|
||||
};
|
||||
|
||||
export type CombatGameContext =
|
||||
import("@/core/game").IGameContextExport<CombatState>;
|
||||
export type CombatState = {
|
||||
enemies: EnemyEntity[];
|
||||
player: PlayerEntity;
|
||||
inventory: GridInventory<GameItemMeta>;
|
||||
|
||||
phase: CombatPhase;
|
||||
turnNumber: number;
|
||||
result: CombatResult | null;
|
||||
|
||||
loot: LootEntry[];
|
||||
};
|
||||
|
||||
export type CombatGameContext = import("@/core/game").IGameContext<CombatState>;
|
||||
|
|
|
|||
|
|
@ -1,26 +1,16 @@
|
|||
export type EffectData = {
|
||||
readonly id: string;
|
||||
readonly name: string;
|
||||
readonly description: string;
|
||||
readonly lifecycle: EffectLifecycle;
|
||||
readonly id: string;
|
||||
readonly name: string;
|
||||
readonly description: string;
|
||||
readonly lifecycle: EffectLifecycle;
|
||||
};
|
||||
export type EffectLifecycle =
|
||||
| "instant"
|
||||
| "temporary"
|
||||
| "lingering"
|
||||
| "permanent"
|
||||
| "posture"
|
||||
| "item"
|
||||
| "itemTemporary"
|
||||
| "itemUntilPlay"
|
||||
| "itemUntilDiscard"
|
||||
| "itemPermanent";
|
||||
export type EffectLifecycle = "instant" | "temporary" | "lingering" | "permanent" | "posture" | "item" | "itemTemporary" | "itemUntilPlay" | "itemUntilDiscard" | "itemPermanent";
|
||||
|
||||
export type EnemyData = {
|
||||
readonly id: string;
|
||||
readonly name: string;
|
||||
readonly intents: readonly IntentData[];
|
||||
readonly description: string;
|
||||
readonly id: string;
|
||||
readonly name: string;
|
||||
readonly intents: readonly IntentData[];
|
||||
readonly description: string;
|
||||
};
|
||||
|
||||
export type CardType = "item" | "status";
|
||||
|
|
@ -28,62 +18,44 @@ export type CardCostType = "energy" | "uses" | "none";
|
|||
export type CardTargetType = "single" | "none";
|
||||
export type EffectTarget = "self" | "player" | "team";
|
||||
|
||||
export type CardEffectTrigger = "onPlay" | "onDraw" | "onDiscard";
|
||||
export type CardEffectTarget = "self" | "target" | "all" | "random";
|
||||
|
||||
export type CardEffect = {
|
||||
readonly id: string;
|
||||
readonly trigger: CardEffectTrigger;
|
||||
readonly target: CardEffectTarget;
|
||||
readonly effects: readonly [EffectData, number][];
|
||||
};
|
||||
|
||||
export type CardData = {
|
||||
readonly id: string;
|
||||
readonly name: string;
|
||||
readonly desc: string;
|
||||
readonly type: CardType;
|
||||
readonly costType: CardCostType;
|
||||
readonly costCount: number;
|
||||
readonly targetType: CardTargetType;
|
||||
readonly effects: readonly CardEffect[];
|
||||
readonly id: string;
|
||||
readonly name: string;
|
||||
readonly desc: string;
|
||||
readonly type: CardType;
|
||||
readonly costType: CardCostType;
|
||||
readonly costCount: number;
|
||||
readonly targetType: CardTargetType;
|
||||
readonly effects: readonly [CardEffectTrigger, CardEffectTarget, EffectData, number][];
|
||||
};
|
||||
export type CardEffectTrigger = "onPlay" | "onDraw" | "onDiscard";
|
||||
export type CardEffectTarget = "self" | "target" | "all" | "random"
|
||||
|
||||
export type EncounterType =
|
||||
| "minion"
|
||||
| "elite"
|
||||
| "event"
|
||||
| "shop"
|
||||
| "camp"
|
||||
| "curio";
|
||||
export type EncounterType = "minion" | "elite" | "event" | "shop" | "camp" | "curio";
|
||||
export type EncounterData = {
|
||||
readonly id: string;
|
||||
readonly type: EncounterType;
|
||||
readonly name: string;
|
||||
readonly description: string;
|
||||
readonly enemies: readonly [
|
||||
data: EnemyData,
|
||||
hp: number,
|
||||
effects: [EffectData, stacks: number][],
|
||||
][];
|
||||
readonly dialogue: string;
|
||||
readonly id: string;
|
||||
readonly type: EncounterType;
|
||||
readonly name: string;
|
||||
readonly description: string;
|
||||
readonly enemies: readonly [data: EnemyData, hp: number, effects: [EffectData, stacks: number][]][];
|
||||
readonly dialogue: string;
|
||||
};
|
||||
|
||||
export type IntentData = {
|
||||
readonly id: string;
|
||||
readonly enemy: EnemyData;
|
||||
readonly initialIntent: boolean;
|
||||
readonly nextIntents: readonly IntentData[];
|
||||
readonly brokenIntent: readonly IntentData[];
|
||||
readonly effects: readonly [EffectTarget, EffectData, number][];
|
||||
readonly id: string;
|
||||
readonly enemy: EnemyData;
|
||||
readonly initialIntent: boolean;
|
||||
readonly nextIntents: readonly IntentData[];
|
||||
readonly brokenIntent: readonly IntentData[];
|
||||
readonly effects: readonly [EffectTarget, EffectData, number][];
|
||||
};
|
||||
|
||||
export type ItemData = {
|
||||
readonly id: string;
|
||||
readonly type: string;
|
||||
readonly name: string;
|
||||
readonly shape: string;
|
||||
readonly card: CardData;
|
||||
readonly price: number;
|
||||
readonly description: string;
|
||||
readonly id: string;
|
||||
readonly type: string;
|
||||
readonly name: string;
|
||||
readonly shape: string;
|
||||
readonly card: CardData;
|
||||
readonly price: number;
|
||||
readonly description: string;
|
||||
};
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
|
|
@ -1,13 +1,8 @@
|
|||
import { describe, it, expect } from "vitest";
|
||||
import data from "@/samples/slay-the-spire-like/data";
|
||||
import { CardData } from "@/samples/slay-the-spire-like";
|
||||
import { describe, it, expect } from 'vitest';
|
||||
import data from '@/samples/slay-the-spire-like/data';
|
||||
|
||||
describe("data import", () => {
|
||||
it("should import properly", () => {
|
||||
expect(data.desert.getEffects).toBeDefined();
|
||||
expect(
|
||||
data.desert.getCards().find((c: CardData) => c.id === "crossbow")?.effects
|
||||
?.length,
|
||||
).toBe(2);
|
||||
});
|
||||
describe('data import', () => {
|
||||
it('should import properly', () => {
|
||||
expect(data.desert.effects).toBeDefined();
|
||||
});
|
||||
});
|
||||
|
|
|
|||
|
|
@ -1,405 +1,386 @@
|
|||
import { describe, it, expect } from "vitest";
|
||||
import {
|
||||
generatePointCrawlMap,
|
||||
hasPath,
|
||||
} from "@/samples/slay-the-spire-like/system/map/generator";
|
||||
import {
|
||||
MapNodeType,
|
||||
MapLayerType,
|
||||
} from "@/samples/slay-the-spire-like/system/map/types";
|
||||
import { createRNG } from "@/utils/rng";
|
||||
import { getEncounters } from "@/samples/slay-the-spire-like/data/desert";
|
||||
const encounters = getEncounters();
|
||||
import { describe, it, expect } from 'vitest';
|
||||
import { generatePointCrawlMap, hasPath } from '@/samples/slay-the-spire-like/system/map/generator';
|
||||
import { MapNodeType, MapLayerType } from '@/samples/slay-the-spire-like/system/map/types';
|
||||
import { createRNG } from '@/utils/rng';
|
||||
import { encounters } from '@/samples/slay-the-spire-like/data/desert';
|
||||
|
||||
describe("generatePointCrawlMap", () => {
|
||||
it("should generate a map with 10 layers", () => {
|
||||
const map = generatePointCrawlMap(createRNG(123), encounters);
|
||||
expect(map.layers.length).toBe(10);
|
||||
});
|
||||
describe('generatePointCrawlMap', () => {
|
||||
it('should generate a map with 10 layers', () => {
|
||||
const map = generatePointCrawlMap(createRNG(123), encounters);
|
||||
expect(map.layers.length).toBe(10);
|
||||
});
|
||||
|
||||
it("should have correct layer structure", () => {
|
||||
const map = generatePointCrawlMap(createRNG(123), encounters);
|
||||
const expectedStructure = [
|
||||
"start",
|
||||
MapLayerType.Wild,
|
||||
MapLayerType.Wild,
|
||||
MapLayerType.Settlement,
|
||||
MapLayerType.Wild,
|
||||
MapLayerType.Wild,
|
||||
MapLayerType.Settlement,
|
||||
MapLayerType.Wild,
|
||||
MapLayerType.Wild,
|
||||
"end",
|
||||
];
|
||||
it('should have correct layer structure', () => {
|
||||
const map = generatePointCrawlMap(createRNG(123), encounters);
|
||||
const expectedStructure = [
|
||||
'start',
|
||||
MapLayerType.Wild,
|
||||
MapLayerType.Wild,
|
||||
MapLayerType.Settlement,
|
||||
MapLayerType.Wild,
|
||||
MapLayerType.Wild,
|
||||
MapLayerType.Settlement,
|
||||
MapLayerType.Wild,
|
||||
MapLayerType.Wild,
|
||||
'end',
|
||||
];
|
||||
|
||||
for (let i = 0; i < expectedStructure.length; i++) {
|
||||
expect(map.layers[i].layerType).toBe(expectedStructure[i]);
|
||||
}
|
||||
});
|
||||
|
||||
it("should have correct node counts per layer", () => {
|
||||
const map = generatePointCrawlMap(createRNG(123), encounters);
|
||||
const expectedCounts = [1, 3, 3, 4, 3, 3, 4, 3, 3, 1];
|
||||
|
||||
for (let i = 0; i < expectedCounts.length; i++) {
|
||||
expect(map.layers[i].nodeIds.length).toBe(expectedCounts[i]);
|
||||
}
|
||||
});
|
||||
|
||||
it("should have Start and End nodes with correct types", () => {
|
||||
const map = generatePointCrawlMap(createRNG(123), encounters);
|
||||
const startNode = map.nodes.get("node-0-0");
|
||||
const endNode = map.nodes.get("node-9-0");
|
||||
|
||||
expect(startNode?.type).toBe(MapNodeType.Start);
|
||||
expect(endNode?.type).toBe(MapNodeType.End);
|
||||
});
|
||||
|
||||
it("should have wild layers with minion/elite/event types", () => {
|
||||
const map = generatePointCrawlMap(createRNG(123), encounters);
|
||||
const wildLayerIndices = [1, 2, 4, 5, 7, 8];
|
||||
const validWildTypes = new Set([
|
||||
MapNodeType.Minion,
|
||||
MapNodeType.Elite,
|
||||
MapNodeType.Event,
|
||||
]);
|
||||
|
||||
for (const layerIdx of wildLayerIndices) {
|
||||
const layer = map.layers[layerIdx];
|
||||
for (const nodeId of layer.nodeIds) {
|
||||
const node = map.nodes.get(nodeId);
|
||||
expect(node).toBeDefined();
|
||||
expect(validWildTypes.has(node!.type)).toBe(true);
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
it("should have settlement layers with at least 1 camp, 1 shop, 1 curio", () => {
|
||||
const map = generatePointCrawlMap(createRNG(123), encounters);
|
||||
const settlementLayerIndices = [3, 6];
|
||||
|
||||
for (const layerIdx of settlementLayerIndices) {
|
||||
const layer = map.layers[layerIdx];
|
||||
const nodeTypes = layer.nodeIds.map((id) => map.nodes.get(id)!.type);
|
||||
|
||||
expect(nodeTypes).toContain(MapNodeType.Camp);
|
||||
expect(nodeTypes).toContain(MapNodeType.Shop);
|
||||
expect(nodeTypes).toContain(MapNodeType.Curio);
|
||||
expect(nodeTypes.length).toBe(4);
|
||||
}
|
||||
});
|
||||
|
||||
it("should have Start connected to all 3 wild nodes", () => {
|
||||
const map = generatePointCrawlMap(createRNG(42), encounters);
|
||||
const startNode = map.nodes.get("node-0-0");
|
||||
const wildLayer = map.layers[1];
|
||||
|
||||
expect(startNode?.childIds.length).toBe(3);
|
||||
expect(startNode?.childIds).toEqual(
|
||||
expect.arrayContaining(wildLayer.nodeIds),
|
||||
);
|
||||
});
|
||||
|
||||
it("should have each wild node connect to 1 wild node in wild→wild layers", () => {
|
||||
const map = generatePointCrawlMap(createRNG(42), encounters);
|
||||
const wildToWildTransitions = [
|
||||
{ src: 1, tgt: 2 },
|
||||
{ src: 4, tgt: 5 },
|
||||
{ src: 7, tgt: 8 },
|
||||
];
|
||||
|
||||
for (const transition of wildToWildTransitions) {
|
||||
const srcLayer = map.layers[transition.src];
|
||||
for (const srcId of srcLayer.nodeIds) {
|
||||
const srcNode = map.nodes.get(srcId);
|
||||
expect(srcNode?.childIds.length).toBe(1);
|
||||
const childLayer = map.layers[transition.tgt];
|
||||
expect(childLayer.nodeIds).toContain(srcNode!.childIds[0]);
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
it("should have each wild node connect to 2 settlement nodes in wild→settlement layers", () => {
|
||||
const map = generatePointCrawlMap(createRNG(42), encounters);
|
||||
const wildToSettlementTransitions = [
|
||||
{ src: 2, tgt: 3 },
|
||||
{ src: 5, tgt: 6 },
|
||||
];
|
||||
|
||||
for (const transition of wildToSettlementTransitions) {
|
||||
const srcLayer = map.layers[transition.src];
|
||||
for (const srcId of srcLayer.nodeIds) {
|
||||
const srcNode = map.nodes.get(srcId);
|
||||
expect(srcNode?.childIds.length).toBe(2);
|
||||
const childLayer = map.layers[transition.tgt];
|
||||
for (const childId of srcNode!.childIds) {
|
||||
expect(childLayer.nodeIds).toContain(childId);
|
||||
for (let i = 0; i < expectedStructure.length; i++) {
|
||||
expect(map.layers[i].layerType).toBe(expectedStructure[i]);
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
it("should have settlement nodes connect correctly (1-2-2-1 pattern)", () => {
|
||||
const map = generatePointCrawlMap(createRNG(42), encounters);
|
||||
const settlementToWildTransitions = [
|
||||
{ src: 3, tgt: 4 },
|
||||
{ src: 6, tgt: 7 },
|
||||
];
|
||||
it('should have correct node counts per layer', () => {
|
||||
const map = generatePointCrawlMap(createRNG(123), encounters);
|
||||
const expectedCounts = [1, 3, 3, 4, 3, 3, 4, 3, 3, 1];
|
||||
|
||||
for (const transition of settlementToWildTransitions) {
|
||||
const srcLayer = map.layers[transition.src];
|
||||
const tgtLayer = map.layers[transition.tgt];
|
||||
|
||||
// First and last settlement connect to 1 wild
|
||||
const firstSettlement = map.nodes.get(srcLayer.nodeIds[0]);
|
||||
expect(firstSettlement?.childIds.length).toBe(1);
|
||||
const lastSettlement = map.nodes.get(srcLayer.nodeIds[3]);
|
||||
expect(lastSettlement?.childIds.length).toBe(1);
|
||||
|
||||
// Middle two settlements connect to 2 wilds
|
||||
for (let i = 1; i <= 2; i++) {
|
||||
const midSettlement = map.nodes.get(srcLayer.nodeIds[i]);
|
||||
expect(midSettlement?.childIds.length).toBe(2);
|
||||
for (const childId of midSettlement!.childIds) {
|
||||
expect(tgtLayer.nodeIds).toContain(childId);
|
||||
for (let i = 0; i < expectedCounts.length; i++) {
|
||||
expect(map.layers[i].nodeIds.length).toBe(expectedCounts[i]);
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
it("should have all 3 wild nodes connect to End", () => {
|
||||
const map = generatePointCrawlMap(createRNG(42), encounters);
|
||||
const lastWildLayer = map.layers[8];
|
||||
const endNode = map.nodes.get("node-9-0");
|
||||
it('should have Start and End nodes with correct types', () => {
|
||||
const map = generatePointCrawlMap(createRNG(123), encounters);
|
||||
const startNode = map.nodes.get('node-0-0');
|
||||
const endNode = map.nodes.get('node-9-0');
|
||||
|
||||
for (const wildId of lastWildLayer.nodeIds) {
|
||||
const wildNode = map.nodes.get(wildId);
|
||||
expect(wildNode?.childIds).toEqual([endNode!.id]);
|
||||
}
|
||||
});
|
||||
expect(startNode?.type).toBe(MapNodeType.Start);
|
||||
expect(endNode?.type).toBe(MapNodeType.End);
|
||||
});
|
||||
|
||||
it("should have all nodes reachable from Start and can reach End", () => {
|
||||
const map = generatePointCrawlMap(createRNG(123), encounters);
|
||||
const startId = "node-0-0";
|
||||
const endId = "node-9-0";
|
||||
it('should have wild layers with minion/elite/event types', () => {
|
||||
const map = generatePointCrawlMap(createRNG(123), encounters);
|
||||
const wildLayerIndices = [1, 2, 4, 5, 7, 8];
|
||||
const validWildTypes = new Set([MapNodeType.Minion, MapNodeType.Elite, MapNodeType.Event]);
|
||||
|
||||
for (const nodeId of map.nodes.keys()) {
|
||||
if (nodeId === startId || nodeId === endId) continue;
|
||||
expect(hasPath(map, startId, nodeId)).toBe(true);
|
||||
expect(hasPath(map, nodeId, endId)).toBe(true);
|
||||
}
|
||||
});
|
||||
|
||||
it("should not have crossing edges in wild→wild transitions", () => {
|
||||
const map = generatePointCrawlMap(createRNG(12345), encounters);
|
||||
const wildToWildTransitions = [
|
||||
{ src: 1, tgt: 2 },
|
||||
{ src: 4, tgt: 5 },
|
||||
{ src: 7, tgt: 8 },
|
||||
];
|
||||
|
||||
for (const transition of wildToWildTransitions) {
|
||||
const srcLayer = map.layers[transition.src];
|
||||
const tgtLayer = map.layers[transition.tgt];
|
||||
|
||||
// Collect edges as pairs of indices
|
||||
const edges: Array<{ srcIndex: number; tgtIndex: number }> = [];
|
||||
for (let s = 0; s < srcLayer.nodeIds.length; s++) {
|
||||
const srcNode = map.nodes.get(srcLayer.nodeIds[s]);
|
||||
for (const tgtId of srcNode!.childIds) {
|
||||
const t = tgtLayer.nodeIds.indexOf(tgtId);
|
||||
edges.push({ srcIndex: s, tgtIndex: t });
|
||||
for (const layerIdx of wildLayerIndices) {
|
||||
const layer = map.layers[layerIdx];
|
||||
for (const nodeId of layer.nodeIds) {
|
||||
const node = map.nodes.get(nodeId);
|
||||
expect(node).toBeDefined();
|
||||
expect(validWildTypes.has(node!.type)).toBe(true);
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
// Check for crossings
|
||||
for (let e1 = 0; e1 < edges.length; e1++) {
|
||||
for (let e2 = e1 + 1; e2 < edges.length; e2++) {
|
||||
const { srcIndex: s1, tgtIndex: t1 } = edges[e1];
|
||||
const { srcIndex: s2, tgtIndex: t2 } = edges[e2];
|
||||
it('should have settlement layers with at least 1 camp, 1 shop, 1 curio', () => {
|
||||
const map = generatePointCrawlMap(createRNG(123), encounters);
|
||||
const settlementLayerIndices = [3, 6];
|
||||
|
||||
if (s1 === s2) continue;
|
||||
if (t1 === t2) continue;
|
||||
for (const layerIdx of settlementLayerIndices) {
|
||||
const layer = map.layers[layerIdx];
|
||||
const nodeTypes = layer.nodeIds.map(id => map.nodes.get(id)!.type);
|
||||
|
||||
const crosses = (s1 < s2 && t1 > t2) || (s1 > s2 && t1 < t2);
|
||||
expect(crosses).toBe(false);
|
||||
expect(nodeTypes).toContain(MapNodeType.Camp);
|
||||
expect(nodeTypes).toContain(MapNodeType.Shop);
|
||||
expect(nodeTypes).toContain(MapNodeType.Curio);
|
||||
expect(nodeTypes.length).toBe(4);
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
it("should not have crossing edges in wild→settlement transitions", () => {
|
||||
const map = generatePointCrawlMap(createRNG(12345), encounters);
|
||||
const wildToSettlementTransitions = [
|
||||
{ src: 2, tgt: 3 },
|
||||
{ src: 5, tgt: 6 },
|
||||
];
|
||||
it('should have Start connected to all 3 wild nodes', () => {
|
||||
const map = generatePointCrawlMap(createRNG(42), encounters);
|
||||
const startNode = map.nodes.get('node-0-0');
|
||||
const wildLayer = map.layers[1];
|
||||
|
||||
for (const transition of wildToSettlementTransitions) {
|
||||
const srcLayer = map.layers[transition.src];
|
||||
const tgtLayer = map.layers[transition.tgt];
|
||||
expect(startNode?.childIds.length).toBe(3);
|
||||
expect(startNode?.childIds).toEqual(expect.arrayContaining(wildLayer.nodeIds));
|
||||
});
|
||||
|
||||
// Collect edges as pairs of indices
|
||||
const edges: Array<{ srcIndex: number; tgtIndex: number }> = [];
|
||||
for (let s = 0; s < srcLayer.nodeIds.length; s++) {
|
||||
const srcNode = map.nodes.get(srcLayer.nodeIds[s]);
|
||||
for (const tgtId of srcNode!.childIds) {
|
||||
const t = tgtLayer.nodeIds.indexOf(tgtId);
|
||||
edges.push({ srcIndex: s, tgtIndex: t });
|
||||
it('should have each wild node connect to 1 wild node in wild→wild layers', () => {
|
||||
const map = generatePointCrawlMap(createRNG(42), encounters);
|
||||
const wildToWildTransitions = [
|
||||
{ src: 1, tgt: 2 },
|
||||
{ src: 4, tgt: 5 },
|
||||
{ src: 7, tgt: 8 },
|
||||
];
|
||||
|
||||
for (const transition of wildToWildTransitions) {
|
||||
const srcLayer = map.layers[transition.src];
|
||||
for (const srcId of srcLayer.nodeIds) {
|
||||
const srcNode = map.nodes.get(srcId);
|
||||
expect(srcNode?.childIds.length).toBe(1);
|
||||
const childLayer = map.layers[transition.tgt];
|
||||
expect(childLayer.nodeIds).toContain(srcNode!.childIds[0]);
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
// Check for crossings
|
||||
for (let e1 = 0; e1 < edges.length; e1++) {
|
||||
for (let e2 = e1 + 1; e2 < edges.length; e2++) {
|
||||
const { srcIndex: s1, tgtIndex: t1 } = edges[e1];
|
||||
const { srcIndex: s2, tgtIndex: t2 } = edges[e2];
|
||||
it('should have each wild node connect to 2 settlement nodes in wild→settlement layers', () => {
|
||||
const map = generatePointCrawlMap(createRNG(42), encounters);
|
||||
const wildToSettlementTransitions = [
|
||||
{ src: 2, tgt: 3 },
|
||||
{ src: 5, tgt: 6 },
|
||||
];
|
||||
|
||||
if (s1 === s2) continue;
|
||||
if (t1 === t2) continue;
|
||||
|
||||
const crosses = (s1 < s2 && t1 > t2) || (s1 > s2 && t1 < t2);
|
||||
expect(crosses).toBe(false);
|
||||
for (const transition of wildToSettlementTransitions) {
|
||||
const srcLayer = map.layers[transition.src];
|
||||
for (const srcId of srcLayer.nodeIds) {
|
||||
const srcNode = map.nodes.get(srcId);
|
||||
expect(srcNode?.childIds.length).toBe(2);
|
||||
const childLayer = map.layers[transition.tgt];
|
||||
for (const childId of srcNode!.childIds) {
|
||||
expect(childLayer.nodeIds).toContain(childId);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
it("should not have crossing edges in settlement→wild transitions", () => {
|
||||
const map = generatePointCrawlMap(createRNG(12345), encounters);
|
||||
const settlementToWildTransitions = [
|
||||
{ src: 3, tgt: 4 },
|
||||
{ src: 6, tgt: 7 },
|
||||
];
|
||||
it('should have settlement nodes connect correctly (1-2-2-1 pattern)', () => {
|
||||
const map = generatePointCrawlMap(createRNG(42), encounters);
|
||||
const settlementToWildTransitions = [
|
||||
{ src: 3, tgt: 4 },
|
||||
{ src: 6, tgt: 7 },
|
||||
];
|
||||
|
||||
for (const transition of settlementToWildTransitions) {
|
||||
const srcLayer = map.layers[transition.src];
|
||||
const tgtLayer = map.layers[transition.tgt];
|
||||
for (const transition of settlementToWildTransitions) {
|
||||
const srcLayer = map.layers[transition.src];
|
||||
const tgtLayer = map.layers[transition.tgt];
|
||||
|
||||
// Collect edges as pairs of indices
|
||||
const edges: Array<{ srcIndex: number; tgtIndex: number }> = [];
|
||||
for (let s = 0; s < srcLayer.nodeIds.length; s++) {
|
||||
const srcNode = map.nodes.get(srcLayer.nodeIds[s]);
|
||||
for (const tgtId of srcNode!.childIds) {
|
||||
const t = tgtLayer.nodeIds.indexOf(tgtId);
|
||||
edges.push({ srcIndex: s, tgtIndex: t });
|
||||
// First and last settlement connect to 1 wild
|
||||
const firstSettlement = map.nodes.get(srcLayer.nodeIds[0]);
|
||||
expect(firstSettlement?.childIds.length).toBe(1);
|
||||
const lastSettlement = map.nodes.get(srcLayer.nodeIds[3]);
|
||||
expect(lastSettlement?.childIds.length).toBe(1);
|
||||
|
||||
// Middle two settlements connect to 2 wilds
|
||||
for (let i = 1; i <= 2; i++) {
|
||||
const midSettlement = map.nodes.get(srcLayer.nodeIds[i]);
|
||||
expect(midSettlement?.childIds.length).toBe(2);
|
||||
for (const childId of midSettlement!.childIds) {
|
||||
expect(tgtLayer.nodeIds).toContain(childId);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
// Check for crossings
|
||||
for (let e1 = 0; e1 < edges.length; e1++) {
|
||||
for (let e2 = e1 + 1; e2 < edges.length; e2++) {
|
||||
const { srcIndex: s1, tgtIndex: t1 } = edges[e1];
|
||||
const { srcIndex: s2, tgtIndex: t2 } = edges[e2];
|
||||
it('should have all 3 wild nodes connect to End', () => {
|
||||
const map = generatePointCrawlMap(createRNG(42), encounters);
|
||||
const lastWildLayer = map.layers[8];
|
||||
const endNode = map.nodes.get('node-9-0');
|
||||
|
||||
if (s1 === s2) continue;
|
||||
if (t1 === t2) continue;
|
||||
|
||||
const crosses = (s1 < s2 && t1 > t2) || (s1 > s2 && t1 < t2);
|
||||
expect(crosses).toBe(false);
|
||||
for (const wildId of lastWildLayer.nodeIds) {
|
||||
const wildNode = map.nodes.get(wildId);
|
||||
expect(wildNode?.childIds).toEqual([endNode!.id]);
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
it("should assign encounters to all non-Start/End nodes", () => {
|
||||
const map = generatePointCrawlMap(createRNG(456), encounters);
|
||||
it('should have all nodes reachable from Start and can reach End', () => {
|
||||
const map = generatePointCrawlMap(createRNG(123), encounters);
|
||||
const startId = 'node-0-0';
|
||||
const endId = 'node-9-0';
|
||||
|
||||
for (const node of map.nodes.values()) {
|
||||
if (node.type === MapNodeType.Start || node.type === MapNodeType.End) {
|
||||
// Start and End nodes should not have encounters
|
||||
expect(node.encounter).toBeUndefined();
|
||||
} else {
|
||||
// All other nodes (minion/elite/event/camp/shop/curio) must have encounters
|
||||
expect(
|
||||
node.encounter,
|
||||
`Node ${node.id} (${node.type}) should have encounter data`,
|
||||
).toBeDefined();
|
||||
expect(node.encounter!.name).toBeTruthy();
|
||||
expect(node.encounter!.description).toBeTruthy();
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
it("should assign encounters to all nodes across multiple seeds", () => {
|
||||
// Test multiple seeds to ensure no random failure
|
||||
for (let seed = 0; seed < 20; seed++) {
|
||||
const map = generatePointCrawlMap(createRNG(seed), encounters);
|
||||
|
||||
for (const node of map.nodes.values()) {
|
||||
if (node.type === MapNodeType.Start || node.type === MapNodeType.End) {
|
||||
continue;
|
||||
for (const nodeId of map.nodes.keys()) {
|
||||
if (nodeId === startId || nodeId === endId) continue;
|
||||
expect(hasPath(map, startId, nodeId)).toBe(true);
|
||||
expect(hasPath(map, nodeId, endId)).toBe(true);
|
||||
}
|
||||
expect(
|
||||
node.encounter,
|
||||
`Seed ${seed}: Node ${node.id} (${node.type}) missing encounter`,
|
||||
).toBeDefined();
|
||||
expect(node.encounter!.name).toBeTruthy();
|
||||
expect(node.encounter!.description).toBeTruthy();
|
||||
}
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
it("should minimize same-layer repetitions in wild layer pairs", () => {
|
||||
// Test that wild layers in pairs (1-2, 4-5, 7-8) have minimal duplicate types within each layer
|
||||
const map = generatePointCrawlMap(createRNG(12345), encounters);
|
||||
const wildPairIndices = [
|
||||
[1, 2],
|
||||
[4, 5],
|
||||
[7, 8],
|
||||
];
|
||||
it('should not have crossing edges in wild→wild transitions', () => {
|
||||
const map = generatePointCrawlMap(createRNG(12345), encounters);
|
||||
const wildToWildTransitions = [
|
||||
{ src: 1, tgt: 2 },
|
||||
{ src: 4, tgt: 5 },
|
||||
{ src: 7, tgt: 8 },
|
||||
];
|
||||
|
||||
for (const [layer1Idx, layer2Idx] of wildPairIndices) {
|
||||
const layer1 = map.layers[layer1Idx];
|
||||
const layer2 = map.layers[layer2Idx];
|
||||
for (const transition of wildToWildTransitions) {
|
||||
const srcLayer = map.layers[transition.src];
|
||||
const tgtLayer = map.layers[transition.tgt];
|
||||
|
||||
// Count repetitions in layer 1
|
||||
const layer1Types = layer1.nodeIds.map((id) => map.nodes.get(id)!.type);
|
||||
const layer1Unique = new Set(layer1Types).size;
|
||||
const layer1Repetitions = layer1Types.length - layer1Unique;
|
||||
// Collect edges as pairs of indices
|
||||
const edges: Array<{ srcIndex: number; tgtIndex: number }> = [];
|
||||
for (let s = 0; s < srcLayer.nodeIds.length; s++) {
|
||||
const srcNode = map.nodes.get(srcLayer.nodeIds[s]);
|
||||
for (const tgtId of srcNode!.childIds) {
|
||||
const t = tgtLayer.nodeIds.indexOf(tgtId);
|
||||
edges.push({ srcIndex: s, tgtIndex: t });
|
||||
}
|
||||
}
|
||||
|
||||
// Count repetitions in layer 2
|
||||
const layer2Types = layer2.nodeIds.map((id) => map.nodes.get(id)!.type);
|
||||
const layer2Unique = new Set(layer2Types).size;
|
||||
const layer2Repetitions = layer2Types.length - layer2Unique;
|
||||
// Check for crossings
|
||||
for (let e1 = 0; e1 < edges.length; e1++) {
|
||||
for (let e2 = e1 + 1; e2 < edges.length; e2++) {
|
||||
const { srcIndex: s1, tgtIndex: t1 } = edges[e1];
|
||||
const { srcIndex: s2, tgtIndex: t2 } = edges[e2];
|
||||
|
||||
// With optimal selection, we expect fewer repetitions than pure random
|
||||
// On average, random would have ~1.5 repetitions per 3-node layer
|
||||
// With 3 attempts, we should typically get 0-1 repetitions
|
||||
expect(layer1Repetitions + layer2Repetitions).toBeLessThanOrEqual(2);
|
||||
}
|
||||
});
|
||||
if (s1 === s2) continue;
|
||||
if (t1 === t2) continue;
|
||||
|
||||
it("should minimize adjacent repetitions in wild→wild connections", () => {
|
||||
// Test that wild nodes connected by wild→wild edges have different types
|
||||
const map = generatePointCrawlMap(createRNG(12345), encounters);
|
||||
const wildToWildPairs = [
|
||||
{ src: 1, tgt: 2 },
|
||||
{ src: 4, tgt: 5 },
|
||||
{ src: 7, tgt: 8 },
|
||||
];
|
||||
|
||||
let totalAdjacentRepetitions = 0;
|
||||
|
||||
for (const pair of wildToWildPairs) {
|
||||
const srcLayer = map.layers[pair.src];
|
||||
const tgtLayer = map.layers[pair.tgt];
|
||||
|
||||
// Each wild node connects to exactly 1 wild node in next layer (1-to-1)
|
||||
for (let i = 0; i < srcLayer.nodeIds.length; i++) {
|
||||
const srcNode = map.nodes.get(srcLayer.nodeIds[i])!;
|
||||
const tgtId = srcNode.childIds[0];
|
||||
const tgtNode = map.nodes.get(tgtId)!;
|
||||
|
||||
if (srcNode.type === tgtNode.type) {
|
||||
totalAdjacentRepetitions++;
|
||||
const crosses = (s1 < s2 && t1 > t2) || (s1 > s2 && t1 < t2);
|
||||
expect(crosses).toBe(false);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
// With 3 wild pairs and 3 nodes each, that's 9 connections total
|
||||
// Random would have ~3 repetitions (1/3 chance per connection)
|
||||
// With optimal selection of 3 attempts, should be much lower (0-2)
|
||||
expect(totalAdjacentRepetitions).toBeLessThanOrEqual(3);
|
||||
});
|
||||
it('should not have crossing edges in wild→settlement transitions', () => {
|
||||
const map = generatePointCrawlMap(createRNG(12345), encounters);
|
||||
const wildToSettlementTransitions = [
|
||||
{ src: 2, tgt: 3 },
|
||||
{ src: 5, tgt: 6 },
|
||||
];
|
||||
|
||||
for (const transition of wildToSettlementTransitions) {
|
||||
const srcLayer = map.layers[transition.src];
|
||||
const tgtLayer = map.layers[transition.tgt];
|
||||
|
||||
// Collect edges as pairs of indices
|
||||
const edges: Array<{ srcIndex: number; tgtIndex: number }> = [];
|
||||
for (let s = 0; s < srcLayer.nodeIds.length; s++) {
|
||||
const srcNode = map.nodes.get(srcLayer.nodeIds[s]);
|
||||
for (const tgtId of srcNode!.childIds) {
|
||||
const t = tgtLayer.nodeIds.indexOf(tgtId);
|
||||
edges.push({ srcIndex: s, tgtIndex: t });
|
||||
}
|
||||
}
|
||||
|
||||
// Check for crossings
|
||||
for (let e1 = 0; e1 < edges.length; e1++) {
|
||||
for (let e2 = e1 + 1; e2 < edges.length; e2++) {
|
||||
const { srcIndex: s1, tgtIndex: t1 } = edges[e1];
|
||||
const { srcIndex: s2, tgtIndex: t2 } = edges[e2];
|
||||
|
||||
if (s1 === s2) continue;
|
||||
if (t1 === t2) continue;
|
||||
|
||||
const crosses = (s1 < s2 && t1 > t2) || (s1 > s2 && t1 < t2);
|
||||
expect(crosses).toBe(false);
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
it('should not have crossing edges in settlement→wild transitions', () => {
|
||||
const map = generatePointCrawlMap(createRNG(12345), encounters);
|
||||
const settlementToWildTransitions = [
|
||||
{ src: 3, tgt: 4 },
|
||||
{ src: 6, tgt: 7 },
|
||||
];
|
||||
|
||||
for (const transition of settlementToWildTransitions) {
|
||||
const srcLayer = map.layers[transition.src];
|
||||
const tgtLayer = map.layers[transition.tgt];
|
||||
|
||||
// Collect edges as pairs of indices
|
||||
const edges: Array<{ srcIndex: number; tgtIndex: number }> = [];
|
||||
for (let s = 0; s < srcLayer.nodeIds.length; s++) {
|
||||
const srcNode = map.nodes.get(srcLayer.nodeIds[s]);
|
||||
for (const tgtId of srcNode!.childIds) {
|
||||
const t = tgtLayer.nodeIds.indexOf(tgtId);
|
||||
edges.push({ srcIndex: s, tgtIndex: t });
|
||||
}
|
||||
}
|
||||
|
||||
// Check for crossings
|
||||
for (let e1 = 0; e1 < edges.length; e1++) {
|
||||
for (let e2 = e1 + 1; e2 < edges.length; e2++) {
|
||||
const { srcIndex: s1, tgtIndex: t1 } = edges[e1];
|
||||
const { srcIndex: s2, tgtIndex: t2 } = edges[e2];
|
||||
|
||||
if (s1 === s2) continue;
|
||||
if (t1 === t2) continue;
|
||||
|
||||
const crosses = (s1 < s2 && t1 > t2) || (s1 > s2 && t1 < t2);
|
||||
expect(crosses).toBe(false);
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
it('should assign encounters to all non-Start/End nodes', () => {
|
||||
const map = generatePointCrawlMap(createRNG(456), encounters);
|
||||
|
||||
for (const node of map.nodes.values()) {
|
||||
if (node.type === MapNodeType.Start || node.type === MapNodeType.End) {
|
||||
// Start and End nodes should not have encounters
|
||||
expect(node.encounter).toBeUndefined();
|
||||
} else {
|
||||
// All other nodes (minion/elite/event/camp/shop/curio) must have encounters
|
||||
expect(node.encounter, `Node ${node.id} (${node.type}) should have encounter data`).toBeDefined();
|
||||
expect(node.encounter!.name).toBeTruthy();
|
||||
expect(node.encounter!.description).toBeTruthy();
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
it('should assign encounters to all nodes across multiple seeds', () => {
|
||||
// Test multiple seeds to ensure no random failure
|
||||
for (let seed = 0; seed < 20; seed++) {
|
||||
const map = generatePointCrawlMap(createRNG(seed), encounters);
|
||||
|
||||
for (const node of map.nodes.values()) {
|
||||
if (node.type === MapNodeType.Start || node.type === MapNodeType.End) {
|
||||
continue;
|
||||
}
|
||||
expect(node.encounter, `Seed ${seed}: Node ${node.id} (${node.type}) missing encounter`).toBeDefined();
|
||||
expect(node.encounter!.name).toBeTruthy();
|
||||
expect(node.encounter!.description).toBeTruthy();
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
it('should minimize same-layer repetitions in wild layer pairs', () => {
|
||||
// Test that wild layers in pairs (1-2, 4-5, 7-8) have minimal duplicate types within each layer
|
||||
const map = generatePointCrawlMap(createRNG(12345), encounters);
|
||||
const wildPairIndices = [
|
||||
[1, 2],
|
||||
[4, 5],
|
||||
[7, 8],
|
||||
];
|
||||
|
||||
for (const [layer1Idx, layer2Idx] of wildPairIndices) {
|
||||
const layer1 = map.layers[layer1Idx];
|
||||
const layer2 = map.layers[layer2Idx];
|
||||
|
||||
// Count repetitions in layer 1
|
||||
const layer1Types = layer1.nodeIds.map(id => map.nodes.get(id)!.type);
|
||||
const layer1Unique = new Set(layer1Types).size;
|
||||
const layer1Repetitions = layer1Types.length - layer1Unique;
|
||||
|
||||
// Count repetitions in layer 2
|
||||
const layer2Types = layer2.nodeIds.map(id => map.nodes.get(id)!.type);
|
||||
const layer2Unique = new Set(layer2Types).size;
|
||||
const layer2Repetitions = layer2Types.length - layer2Unique;
|
||||
|
||||
// With optimal selection, we expect fewer repetitions than pure random
|
||||
// On average, random would have ~1.5 repetitions per 3-node layer
|
||||
// With 3 attempts, we should typically get 0-1 repetitions
|
||||
expect(layer1Repetitions + layer2Repetitions).toBeLessThanOrEqual(2);
|
||||
}
|
||||
});
|
||||
|
||||
it('should minimize adjacent repetitions in wild→wild connections', () => {
|
||||
// Test that wild nodes connected by wild→wild edges have different types
|
||||
const map = generatePointCrawlMap(createRNG(12345), encounters);
|
||||
const wildToWildPairs = [
|
||||
{ src: 1, tgt: 2 },
|
||||
{ src: 4, tgt: 5 },
|
||||
{ src: 7, tgt: 8 },
|
||||
];
|
||||
|
||||
let totalAdjacentRepetitions = 0;
|
||||
|
||||
for (const pair of wildToWildPairs) {
|
||||
const srcLayer = map.layers[pair.src];
|
||||
const tgtLayer = map.layers[pair.tgt];
|
||||
|
||||
// Each wild node connects to exactly 1 wild node in next layer (1-to-1)
|
||||
for (let i = 0; i < srcLayer.nodeIds.length; i++) {
|
||||
const srcNode = map.nodes.get(srcLayer.nodeIds[i])!;
|
||||
const tgtId = srcNode.childIds[0];
|
||||
const tgtNode = map.nodes.get(tgtId)!;
|
||||
|
||||
if (srcNode.type === tgtNode.type) {
|
||||
totalAdjacentRepetitions++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// With 3 wild pairs and 3 nodes each, that's 9 connections total
|
||||
// Random would have ~3 repetitions (1/3 chance per connection)
|
||||
// With optimal selection of 3 attempts, should be much lower (0-2)
|
||||
expect(totalAdjacentRepetitions).toBeLessThanOrEqual(3);
|
||||
});
|
||||
});
|
||||
|
|
|
|||
|
|
@ -11,13 +11,12 @@
|
|||
"declaration": true,
|
||||
"declarationMap": true,
|
||||
"outDir": "./dist",
|
||||
|
||||
"rootDir": ".",
|
||||
"rootDir": "./src",
|
||||
"baseUrl": ".",
|
||||
"paths": {
|
||||
"@/*": ["src/*"],
|
||||
},
|
||||
"@/*": ["src/*"]
|
||||
}
|
||||
},
|
||||
"include": ["src/**/*", "tests/**/*"],
|
||||
"exclude": ["node_modules", "dist"],
|
||||
"include": ["src/**/*"],
|
||||
"exclude": ["node_modules", "dist", "tests"]
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,13 +1,13 @@
|
|||
import { defineConfig } from "tsup";
|
||||
import { fileURLToPath } from "url";
|
||||
import * as fs from "fs";
|
||||
import * as path from "path";
|
||||
import { csvLoader } from "inline-schema/csv-loader/esbuild";
|
||||
import { yarnSpinnerPlugin } from "yarn-spinner-loader/esbuild";
|
||||
import type { Plugin } from "esbuild";
|
||||
import { defineConfig } from 'tsup';
|
||||
import { fileURLToPath } from 'url';
|
||||
import * as fs from 'fs';
|
||||
import * as path from 'path';
|
||||
import {csvLoader} from 'inline-schema/csv-loader/esbuild';
|
||||
import {yarnSpinnerPlugin} from 'yarn-spinner-loader/esbuild';
|
||||
import type { Plugin } from 'esbuild';
|
||||
|
||||
const srcDir = fileURLToPath(new URL("./src", import.meta.url));
|
||||
const samplesDir = fileURLToPath(new URL("./src/samples", import.meta.url));
|
||||
const srcDir = fileURLToPath(new URL('./src', import.meta.url));
|
||||
const samplesDir = fileURLToPath(new URL('./src/samples', import.meta.url));
|
||||
|
||||
// Auto-discover samples entry points
|
||||
function getSamplesEntries(): Record<string, string> {
|
||||
|
|
@ -18,13 +18,13 @@ function getSamplesEntries(): Record<string, string> {
|
|||
const fullPath = path.join(samplesDir, item);
|
||||
if (fs.statSync(fullPath).isDirectory()) {
|
||||
// Directory sample (e.g. boop) - look for index.ts
|
||||
const indexPath = path.join(fullPath, "index.ts");
|
||||
const indexPath = path.join(fullPath, 'index.ts');
|
||||
if (fs.existsSync(indexPath)) {
|
||||
entries[item] = indexPath;
|
||||
}
|
||||
} else if (item.endsWith(".ts")) {
|
||||
} else if (item.endsWith('.ts')) {
|
||||
// Single file sample (e.g. tic-tac-toe.ts)
|
||||
entries[item.replace(".ts", "")] = fullPath;
|
||||
entries[item.replace('.ts', '')] = fullPath;
|
||||
}
|
||||
}
|
||||
return entries;
|
||||
|
|
@ -37,20 +37,20 @@ const samplesEntries = getSamplesEntries();
|
|||
*/
|
||||
function rewriteBoardgameImports(): Plugin {
|
||||
return {
|
||||
name: "rewrite-boardgame-imports",
|
||||
name: 'rewrite-boardgame-imports',
|
||||
setup(build) {
|
||||
build.onResolve({ filter: /^@\/(core|utils)\// }, (args) => {
|
||||
build.onResolve({ filter: /^@\/(core|utils)\// }, args => {
|
||||
// Mark these as external and rewrite to 'boardgame-core'
|
||||
return {
|
||||
path: "boardgame-core",
|
||||
path: 'boardgame-core',
|
||||
external: true,
|
||||
};
|
||||
});
|
||||
|
||||
|
||||
// Also handle @/index imports
|
||||
build.onResolve({ filter: /^@\/index$/ }, (args) => {
|
||||
build.onResolve({ filter: /^@\/index$/ }, args => {
|
||||
return {
|
||||
path: "boardgame-core",
|
||||
path: 'boardgame-core',
|
||||
external: true,
|
||||
};
|
||||
});
|
||||
|
|
@ -60,25 +60,11 @@ function rewriteBoardgameImports(): Plugin {
|
|||
|
||||
export default defineConfig({
|
||||
entry: samplesEntries,
|
||||
format: ["esm"],
|
||||
format: ['esm'],
|
||||
dts: true,
|
||||
clean: true,
|
||||
sourcemap: true,
|
||||
outDir: "dist/samples",
|
||||
external: [
|
||||
"@preact/signals-core",
|
||||
"mutative",
|
||||
"inline-schema",
|
||||
"boardgame-core",
|
||||
],
|
||||
esbuildPlugins: [
|
||||
csvLoader({ writeToDisk: true }),
|
||||
rewriteBoardgameImports(),
|
||||
yarnSpinnerPlugin(),
|
||||
],
|
||||
esbuildOptions(options) {
|
||||
options.alias = {
|
||||
"@": srcDir,
|
||||
};
|
||||
},
|
||||
outDir: 'dist/samples',
|
||||
external: ['@preact/signals-core', 'mutative', 'inline-schema', 'boardgame-core'],
|
||||
esbuildPlugins: [csvLoader({ writeToDisk: true }), rewriteBoardgameImports(), yarnSpinnerPlugin()],
|
||||
});
|
||||
|
|
|
|||
Loading…
Reference in New Issue