756 lines
26 KiB
TypeScript
756 lines
26 KiB
TypeScript
import { describe, expect, it, vi } from 'vitest';
|
|
|
|
import { LiteHashDRBG, RandUtil } from '@sammo-ts/common';
|
|
import type { MapDefinition, ScenarioEffectKey, TurnSchedule } from '@sammo-ts/logic';
|
|
import { simpleSerialize } from '@sammo-ts/logic/war/utils.js';
|
|
|
|
import { InMemoryTurnWorld } from '../src/turn/inMemoryWorld.js';
|
|
import type { InMemoryReservedTurnStore } from '../src/turn/reservedTurnStore.js';
|
|
import { createImmediateGeneralActionExecutor } from '../src/turn/reservedTurnHandler.js';
|
|
import type { TurnGeneral, TurnWorldSnapshot, TurnWorldState } from '../src/turn/types.js';
|
|
import { createTurnDaemonCommandHandler } from '../src/turn/worldCommandHandler.js';
|
|
|
|
const schedule: TurnSchedule = { entries: [{ startMinute: 0, tickMinutes: 10 }] };
|
|
|
|
const buildMapCity = (id: number, connections: number[]): MapDefinition['cities'][number] => ({
|
|
id,
|
|
name: `도시${id}`,
|
|
level: 1,
|
|
region: 1,
|
|
position: { x: id, y: id },
|
|
connections,
|
|
max: {
|
|
population: 100_000,
|
|
agriculture: 1_000,
|
|
commerce: 1_000,
|
|
security: 1_000,
|
|
defence: 1_000,
|
|
wall: 1_000,
|
|
},
|
|
initial: {
|
|
population: 10_000,
|
|
agriculture: 100,
|
|
commerce: 100,
|
|
security: 100,
|
|
defence: 100,
|
|
wall: 100,
|
|
},
|
|
});
|
|
|
|
const buildGeneral = (overrides: Partial<TurnGeneral> = {}): TurnGeneral => ({
|
|
id: 7,
|
|
userId: 'user-7',
|
|
name: '테스트장수',
|
|
nationId: 1,
|
|
cityId: 1,
|
|
troopId: 0,
|
|
stats: { leadership: 70, strength: 60, intelligence: 50 },
|
|
turnTime: new Date('0185-01-01T00:00:00Z'),
|
|
recentWarTime: null,
|
|
role: {
|
|
items: { horse: 'che_명마', weapon: null, book: null, item: null },
|
|
personality: null,
|
|
specialDomestic: null,
|
|
specialWar: null,
|
|
},
|
|
triggerState: { flags: {}, counters: {}, modifiers: {}, meta: {} },
|
|
meta: {
|
|
killturn: 12,
|
|
myset: 3,
|
|
defence_train: 80,
|
|
tnmt: 0,
|
|
use_treatment: 10,
|
|
use_auto_nation_turn: 1,
|
|
},
|
|
penalty: {},
|
|
officerLevel: 1,
|
|
experience: 0,
|
|
dedication: 0,
|
|
injury: 0,
|
|
gold: 1_000,
|
|
rice: 1_000,
|
|
crew: 100,
|
|
crewTypeId: 0,
|
|
train: 90,
|
|
atmos: 90,
|
|
age: 20,
|
|
npcState: 0,
|
|
...overrides,
|
|
});
|
|
|
|
const buildWorld = (
|
|
general = buildGeneral(),
|
|
options: { autorunLimit?: boolean; scenarioEffect?: ScenarioEffectKey | null } = {}
|
|
) => {
|
|
const state: TurnWorldState = {
|
|
id: 1,
|
|
currentYear: 185,
|
|
currentMonth: 1,
|
|
tickSeconds: 600,
|
|
lastTurnTime: new Date('0185-01-01T00:00:00Z'),
|
|
meta: {
|
|
killturn: 24,
|
|
autorun_user: options.autorunLimit ? { limit_minutes: 60 } : {},
|
|
},
|
|
};
|
|
const snapshot: TurnWorldSnapshot = {
|
|
generals: [general],
|
|
cities: [],
|
|
nations: [],
|
|
troops: [],
|
|
diplomacy: [],
|
|
events: [],
|
|
initialEvents: [],
|
|
scenarioConfig: {
|
|
stat: { total: 300, min: 10, max: 100, npcTotal: 150, npcMax: 50, npcMin: 10, chiefMin: 65 },
|
|
iconPath: '',
|
|
map: {},
|
|
const: { maxTrainByWar: 100, maxAtmosByWar: 100 },
|
|
environment: {
|
|
mapName: 'test',
|
|
unitSet: 'test',
|
|
...(options.scenarioEffect !== undefined ? { scenarioEffect: options.scenarioEffect } : {}),
|
|
},
|
|
},
|
|
scenarioMeta: {
|
|
title: 'test',
|
|
startYear: 180,
|
|
life: null,
|
|
fiction: null,
|
|
history: [],
|
|
ignoreDefaultEvents: false,
|
|
},
|
|
map: {
|
|
id: 'test',
|
|
name: 'test',
|
|
cities: [],
|
|
defaults: { trust: 50, trade: 100, supplyState: 1, frontState: 0 },
|
|
},
|
|
};
|
|
const world = new InMemoryTurnWorld(state, snapshot, { schedule });
|
|
return { world, handler: createTurnDaemonCommandHandler({ world }) };
|
|
};
|
|
|
|
const buildImmediateActionWorld = (options: {
|
|
general: TurnGeneral;
|
|
cities: TurnWorldSnapshot['cities'];
|
|
nations: TurnWorldSnapshot['nations'];
|
|
map: MapDefinition;
|
|
availableInstantRetreat?: boolean;
|
|
lastTurnTime?: Date;
|
|
scenarioConst?: Record<string, unknown>;
|
|
}) => {
|
|
const state: TurnWorldState = {
|
|
id: 1,
|
|
currentYear: 180,
|
|
currentMonth: 1,
|
|
tickSeconds: 600,
|
|
lastTurnTime: options.lastTurnTime ?? new Date('0180-01-01T00:00:00Z'),
|
|
meta: {
|
|
hiddenSeed: 'immediate-action-test',
|
|
killturn: 24,
|
|
opentime: '0180-02-01T00:00:00.000Z',
|
|
scenarioId: 1000,
|
|
},
|
|
};
|
|
const scenarioMeta = {
|
|
title: '즉시 행동 테스트',
|
|
startYear: 180,
|
|
life: null,
|
|
fiction: null,
|
|
history: [],
|
|
ignoreDefaultEvents: false,
|
|
};
|
|
const snapshot: TurnWorldSnapshot = {
|
|
generals: [options.general],
|
|
cities: options.cities,
|
|
nations: options.nations,
|
|
troops: [],
|
|
diplomacy: [],
|
|
events: [],
|
|
initialEvents: [],
|
|
scenarioConfig: {
|
|
stat: { total: 300, min: 10, max: 100, npcTotal: 150, npcMax: 50, npcMin: 10, chiefMin: 65 },
|
|
iconPath: '',
|
|
map: {},
|
|
const: {
|
|
openingPartYear: 3,
|
|
baseRice: 2_000,
|
|
availableInstantAction: {
|
|
instantRetreat: options.availableInstantRetreat ?? false,
|
|
},
|
|
...(options.scenarioConst ?? {}),
|
|
},
|
|
environment: {
|
|
mapName: 'test',
|
|
unitSet: 'test',
|
|
},
|
|
},
|
|
scenarioMeta,
|
|
map: options.map,
|
|
};
|
|
const world = new InMemoryTurnWorld(state, snapshot, { schedule });
|
|
const ensureNationTurns = vi.fn();
|
|
const reservedTurns = { ensureNationTurns } as unknown as InMemoryReservedTurnStore;
|
|
const handler = createTurnDaemonCommandHandler({
|
|
world,
|
|
reservedTurns,
|
|
scenarioMeta,
|
|
map: options.map,
|
|
});
|
|
return { world, handler, ensureNationTurns, reservedTurns, scenarioMeta };
|
|
};
|
|
|
|
describe('my information world commands', () => {
|
|
it('normalizes legacy settings and charges myset only when defence mode changes', async () => {
|
|
const fixture = buildWorld();
|
|
|
|
await expect(
|
|
fixture.handler.handle({
|
|
type: 'setMySetting',
|
|
generalId: 7,
|
|
settings: {
|
|
tnmt: 9,
|
|
defence_train: 94,
|
|
use_treatment: 200,
|
|
use_auto_nation_turn: 0,
|
|
},
|
|
})
|
|
).resolves.toMatchObject({ ok: true });
|
|
|
|
expect(fixture.world.getGeneralById(7)).toMatchObject({
|
|
train: 87,
|
|
atmos: 84,
|
|
meta: {
|
|
tnmt: 1,
|
|
defence_train: 999,
|
|
use_treatment: 100,
|
|
use_auto_nation_turn: 0,
|
|
myset: 2,
|
|
},
|
|
});
|
|
|
|
await fixture.handler.handle({
|
|
type: 'setMySetting',
|
|
generalId: 7,
|
|
settings: { tnmt: 0, defence_train: 999, use_treatment: 1 },
|
|
});
|
|
expect(fixture.world.getGeneralById(7)?.meta).toMatchObject({
|
|
tnmt: 0,
|
|
use_treatment: 10,
|
|
myset: 2,
|
|
});
|
|
});
|
|
|
|
it.each([
|
|
'event_UnlimitedDefenceThresholdChange',
|
|
'event_StrongAttacker',
|
|
'event_MoreEffect',
|
|
] satisfies ScenarioEffectKey[])(
|
|
'preserves the %s scenario that waives the no-defence penalty',
|
|
async (scenarioEffect) => {
|
|
const fixture = buildWorld(buildGeneral(), { scenarioEffect });
|
|
await fixture.handler.handle({
|
|
type: 'setMySetting',
|
|
generalId: 7,
|
|
settings: { defence_train: 999 },
|
|
});
|
|
expect(fixture.world.getGeneralById(7)).toMatchObject({ train: 90, atmos: 90 });
|
|
}
|
|
);
|
|
|
|
it('applies vacation killturn and rejects it in automatic-turn mode', async () => {
|
|
const allowed = buildWorld();
|
|
await expect(allowed.handler.handle({ type: 'vacation', generalId: 7 })).resolves.toMatchObject({ ok: true });
|
|
expect(allowed.world.getGeneralById(7)?.meta.killturn).toBe(72);
|
|
|
|
const blocked = buildWorld(buildGeneral(), { autorunLimit: true });
|
|
await expect(blocked.handler.handle({ type: 'vacation', generalId: 7 })).resolves.toMatchObject({
|
|
ok: false,
|
|
reason: '자동 턴인 경우에는 휴가 명령이 불가능합니다.',
|
|
});
|
|
expect(blocked.world.getGeneralById(7)?.meta.killturn).toBe(12);
|
|
});
|
|
|
|
it('drops only the authenticated command target slot and rejects an empty slot', async () => {
|
|
const fixture = buildWorld();
|
|
await expect(
|
|
fixture.handler.handle({ type: 'dropItem', generalId: 7, itemType: 'weapon' })
|
|
).resolves.toMatchObject({ ok: false });
|
|
await expect(
|
|
fixture.handler.handle({ type: 'dropItem', generalId: 7, itemType: 'horse' })
|
|
).resolves.toMatchObject({ ok: true });
|
|
expect(fixture.world.getGeneralById(7)?.role.items.horse).toBeNull();
|
|
});
|
|
|
|
it('executes pre-open uprising through the action stack without advancing the turn clock', async () => {
|
|
const general = buildGeneral({
|
|
nationId: 0,
|
|
cityId: 1,
|
|
turnTime: new Date('0180-01-01T00:10:00Z'),
|
|
experience: 0,
|
|
dedication: 0,
|
|
meta: {
|
|
killturn: 3,
|
|
inherit_active_action: 2,
|
|
leadership_exp: 0,
|
|
strength_exp: 0,
|
|
intel_exp: 0,
|
|
},
|
|
});
|
|
const fixture = buildImmediateActionWorld({
|
|
general,
|
|
cities: [
|
|
{
|
|
id: 1,
|
|
name: '낙양',
|
|
nationId: 0,
|
|
supplyState: 1,
|
|
meta: {},
|
|
} as TurnWorldSnapshot['cities'][number],
|
|
],
|
|
nations: [
|
|
{
|
|
id: 1,
|
|
name: general.name,
|
|
color: '#111111',
|
|
typeCode: 'che_중립',
|
|
level: 1,
|
|
capitalCityId: 0,
|
|
chiefGeneralId: 0,
|
|
gold: 0,
|
|
rice: 0,
|
|
power: 0,
|
|
meta: {},
|
|
},
|
|
],
|
|
map: {
|
|
id: 'test',
|
|
name: 'test',
|
|
cities: [buildMapCity(1, [])],
|
|
},
|
|
});
|
|
|
|
await expect(
|
|
fixture.handler.handle({
|
|
type: 'buildNationCandidate',
|
|
userId: general.userId!,
|
|
generalId: general.id,
|
|
})
|
|
).resolves.toMatchObject({ ok: true });
|
|
|
|
const createdNation = fixture.world.listNations().find((nation) => nation.id === 2);
|
|
expect(createdNation).toMatchObject({
|
|
name: `㉥${general.name}`,
|
|
color: '#330000',
|
|
typeCode: 'che_중립',
|
|
level: 0,
|
|
capitalCityId: 0,
|
|
chiefGeneralId: general.id,
|
|
gold: 0,
|
|
rice: 2_000,
|
|
meta: {
|
|
rate: 20,
|
|
bill: 100,
|
|
strategic_cmd_limit: 12,
|
|
surlimit: 72,
|
|
secretlimit: 1,
|
|
gennum: 1,
|
|
},
|
|
});
|
|
expect(fixture.world.getGeneralById(general.id)).toMatchObject({
|
|
nationId: 2,
|
|
officerLevel: 12,
|
|
experience: 100,
|
|
dedication: 100,
|
|
turnTime: general.turnTime,
|
|
lastTurn: { command: '거병', arg: {} },
|
|
meta: {
|
|
belong: 1,
|
|
officer_city: 0,
|
|
inherit_active_action: 3,
|
|
killturn: 24,
|
|
},
|
|
});
|
|
expect(fixture.ensureNationTurns.mock.calls).toEqual([
|
|
[2, 12],
|
|
[2, 11],
|
|
]);
|
|
expect(fixture.world.getDiplomacyEntry(1, 2)).toMatchObject({ state: 2, term: 0 });
|
|
expect(fixture.world.getDiplomacyEntry(2, 1)).toMatchObject({ state: 2, term: 0 });
|
|
const { logs } = fixture.world.consumeDirtyState();
|
|
expect(logs.map((entry) => entry.text)).toEqual(
|
|
expect.arrayContaining([
|
|
'거병에 성공하였습니다. <1>00:10</>',
|
|
expect.stringContaining('낙양'),
|
|
expect.stringContaining('세력을 결성하였습니다.'),
|
|
])
|
|
);
|
|
});
|
|
|
|
it('rejects a penalized uprising before allocating a nation or writing a log', async () => {
|
|
const general = buildGeneral({
|
|
nationId: 0,
|
|
cityId: 1,
|
|
penalty: { noFoundNation: true },
|
|
});
|
|
const fixture = buildImmediateActionWorld({
|
|
general,
|
|
cities: [{ id: 1, name: '낙양', nationId: 0, supplyState: 1, meta: {} }] as TurnWorldSnapshot['cities'],
|
|
nations: [],
|
|
map: {
|
|
id: 'test',
|
|
name: 'test',
|
|
cities: [buildMapCity(1, [])],
|
|
},
|
|
});
|
|
|
|
await expect(
|
|
fixture.handler.handle({
|
|
type: 'buildNationCandidate',
|
|
userId: general.userId!,
|
|
generalId: general.id,
|
|
})
|
|
).resolves.toMatchObject({ ok: false });
|
|
expect(fixture.world.listNations()).toEqual([]);
|
|
expect(fixture.world.getGeneralById(general.id)).toMatchObject({
|
|
nationId: 0,
|
|
experience: general.experience,
|
|
dedication: general.dedication,
|
|
});
|
|
expect(fixture.ensureNationTurns).not.toHaveBeenCalled();
|
|
expect(fixture.world.consumeDirtyState().logs).toEqual([]);
|
|
});
|
|
|
|
it('uses the Ref generic unique seed independently from the immediate-action RNG', async () => {
|
|
const general = buildGeneral({
|
|
nationId: 0,
|
|
cityId: 1,
|
|
meta: {
|
|
killturn: 3,
|
|
inheritRandomUnique: true,
|
|
leadership_exp: 0,
|
|
strength_exp: 0,
|
|
intel_exp: 0,
|
|
},
|
|
});
|
|
const map = {
|
|
id: 'test',
|
|
name: 'test',
|
|
cities: [buildMapCity(1, [])],
|
|
};
|
|
const fixture = buildImmediateActionWorld({
|
|
general,
|
|
cities: [{ id: 1, name: '낙양', nationId: 0, supplyState: 1, meta: {} }] as TurnWorldSnapshot['cities'],
|
|
nations: [],
|
|
map,
|
|
scenarioConst: {
|
|
allItems: {
|
|
weapon: {
|
|
che_무기_12_칠성검: 1,
|
|
},
|
|
},
|
|
maxUniqueItemLimit: [[-1, 1]],
|
|
minMonthToAllowInheritItem: 0,
|
|
},
|
|
});
|
|
const actionRng = new RandUtil(new LiteHashDRBG('immediate-action-main-rng'));
|
|
const nextFloat = vi.spyOn(actionRng, 'nextFloat1');
|
|
const nextInt = vi.spyOn(actionRng, 'nextInt');
|
|
const nextIntInclusive = vi.spyOn(actionRng, 'nextIntInclusive');
|
|
const executor = await createImmediateGeneralActionExecutor({
|
|
world: fixture.world,
|
|
reservedTurns: fixture.reservedTurns,
|
|
scenarioMeta: fixture.scenarioMeta,
|
|
map,
|
|
});
|
|
|
|
await expect(
|
|
executor.execute({
|
|
actionKey: 'che_거병',
|
|
generalId: general.id,
|
|
rng: actionRng,
|
|
refreshKillturn: true,
|
|
})
|
|
).resolves.toEqual({ ok: true });
|
|
expect(fixture.world.getGeneralById(general.id)?.role.items.weapon).toBe('che_무기_12_칠성검');
|
|
expect(fixture.world.consumeDirtyState().logs.some((entry) => entry.text.includes('【아이템】'))).toBe(true);
|
|
expect(nextFloat).not.toHaveBeenCalled();
|
|
expect(nextInt).not.toHaveBeenCalled();
|
|
expect(nextIntInclusive).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('preserves the Ref uprising precheck order and messages after the game starts', async () => {
|
|
const general = buildGeneral({ nationId: 1, cityId: 1 });
|
|
const fixture = buildImmediateActionWorld({
|
|
general,
|
|
cities: [{ id: 1, name: '낙양', nationId: 1, supplyState: 1, meta: {} }] as TurnWorldSnapshot['cities'],
|
|
nations: [],
|
|
map: {
|
|
id: 'test',
|
|
name: 'test',
|
|
cities: [buildMapCity(1, [])],
|
|
},
|
|
lastTurnTime: new Date('0180-03-01T00:00:00.000Z'),
|
|
});
|
|
|
|
await expect(
|
|
fixture.handler.handle({
|
|
type: 'buildNationCandidate',
|
|
userId: general.userId!,
|
|
generalId: general.id,
|
|
})
|
|
).resolves.toMatchObject({
|
|
ok: false,
|
|
reason: '게임이 시작되었습니다.',
|
|
});
|
|
});
|
|
|
|
it('executes instant retreat with the legacy seed and leaves the reserved turn untouched', async () => {
|
|
const originalLastTurn = { command: '훈련', arg: { marker: 1 } };
|
|
const general = buildGeneral({
|
|
nationId: 1,
|
|
cityId: 2,
|
|
turnTime: new Date('0180-01-01T00:10:00Z'),
|
|
lastTurn: originalLastTurn,
|
|
});
|
|
const map = {
|
|
id: 'test',
|
|
name: 'test',
|
|
cities: [buildMapCity(1, [2]), buildMapCity(2, [1])],
|
|
};
|
|
const cities = [
|
|
{ id: 1, name: '낙양', nationId: 1, supplyState: 1, meta: {} },
|
|
{ id: 2, name: '장안', nationId: 2, supplyState: 1, meta: {} },
|
|
] as TurnWorldSnapshot['cities'];
|
|
const nations = [
|
|
{
|
|
id: 1,
|
|
name: '아국',
|
|
color: '#111111',
|
|
typeCode: 'che_중립',
|
|
level: 1,
|
|
capitalCityId: 1,
|
|
chiefGeneralId: general.id,
|
|
gold: 0,
|
|
rice: 0,
|
|
power: 0,
|
|
meta: {},
|
|
},
|
|
{
|
|
id: 2,
|
|
name: '타국',
|
|
color: '#222222',
|
|
typeCode: 'che_중립',
|
|
level: 1,
|
|
capitalCityId: 2,
|
|
chiefGeneralId: 0,
|
|
gold: 0,
|
|
rice: 0,
|
|
power: 0,
|
|
meta: {},
|
|
},
|
|
] as TurnWorldSnapshot['nations'];
|
|
const fixture = buildImmediateActionWorld({
|
|
general,
|
|
cities,
|
|
nations,
|
|
map,
|
|
availableInstantRetreat: true,
|
|
});
|
|
|
|
await expect(
|
|
fixture.handler.handle({
|
|
type: 'instantRetreat',
|
|
userId: general.userId!,
|
|
generalId: general.id,
|
|
})
|
|
).resolves.toMatchObject({
|
|
ok: true,
|
|
});
|
|
expect(fixture.world.getGeneralById(general.id)).toMatchObject({
|
|
cityId: 1,
|
|
turnTime: general.turnTime,
|
|
lastTurn: originalLastTurn,
|
|
});
|
|
expect(fixture.world.consumeDirtyState().logs.map((entry) => entry.text)).toContain(
|
|
'<G><b>낙양</b></>으로 접경귀환했습니다.'
|
|
);
|
|
});
|
|
|
|
it('chooses equal-distance retreat cities in the Ref map BFS connection order', async () => {
|
|
const general = buildGeneral({ nationId: 1, cityId: 2 });
|
|
const map = {
|
|
id: 'test',
|
|
name: 'test',
|
|
cities: [buildMapCity(1, [2]), buildMapCity(2, [3, 1]), buildMapCity(3, [2])],
|
|
};
|
|
const fixture = buildImmediateActionWorld({
|
|
general,
|
|
cities: [
|
|
{ id: 1, name: '첫째', nationId: 1, supplyState: 1, meta: {} },
|
|
{ id: 3, name: '셋째', nationId: 1, supplyState: 1, meta: {} },
|
|
{ id: 2, name: '출발', nationId: 2, supplyState: 1, meta: {} },
|
|
] as TurnWorldSnapshot['cities'],
|
|
nations: [
|
|
{
|
|
id: 1,
|
|
name: '아국',
|
|
color: '#111111',
|
|
typeCode: 'che_중립',
|
|
level: 1,
|
|
capitalCityId: 1,
|
|
chiefGeneralId: general.id,
|
|
gold: 0,
|
|
rice: 0,
|
|
power: 0,
|
|
meta: {},
|
|
},
|
|
],
|
|
map,
|
|
availableInstantRetreat: true,
|
|
});
|
|
const expectedIndex = new RandUtil(
|
|
new LiteHashDRBG(
|
|
simpleSerialize('immediate-action-test', 'InstantRetreat', general.id, 180, 1, general.cityId)
|
|
)
|
|
).nextIntInclusive(1);
|
|
|
|
await expect(
|
|
fixture.handler.handle({
|
|
type: 'instantRetreat',
|
|
userId: general.userId!,
|
|
generalId: general.id,
|
|
})
|
|
).resolves.toMatchObject({ ok: true });
|
|
expect(fixture.world.getGeneralById(general.id)?.cityId).toBe([3, 1][expectedIndex]);
|
|
});
|
|
|
|
it('rejects an immediate action when the command user does not own the runtime general', async () => {
|
|
const general = buildGeneral({ nationId: 0, cityId: 1 });
|
|
const fixture = buildImmediateActionWorld({
|
|
general,
|
|
cities: [{ id: 1, name: '낙양', nationId: 0, supplyState: 1, meta: {} }] as TurnWorldSnapshot['cities'],
|
|
nations: [],
|
|
map: {
|
|
id: 'test',
|
|
name: 'test',
|
|
cities: [buildMapCity(1, [])],
|
|
},
|
|
});
|
|
|
|
await expect(
|
|
fixture.handler.handle({
|
|
type: 'buildNationCandidate',
|
|
userId: 'different-user',
|
|
generalId: general.id,
|
|
})
|
|
).rejects.toThrow('general owner does not match command user');
|
|
expect(fixture.world.listNations()).toEqual([]);
|
|
});
|
|
|
|
it('attributes an instant-retreat constraint failure to the session general log', async () => {
|
|
const general = buildGeneral({ nationId: 0, cityId: 1 });
|
|
const fixture = buildImmediateActionWorld({
|
|
general,
|
|
cities: [{ id: 1, name: '낙양', nationId: 0, supplyState: 1, meta: {} }] as TurnWorldSnapshot['cities'],
|
|
nations: [],
|
|
map: {
|
|
id: 'test',
|
|
name: 'test',
|
|
cities: [buildMapCity(1, [])],
|
|
},
|
|
availableInstantRetreat: true,
|
|
});
|
|
|
|
await expect(
|
|
fixture.handler.handle({
|
|
type: 'instantRetreat',
|
|
userId: general.userId!,
|
|
generalId: general.id,
|
|
})
|
|
).resolves.toMatchObject({ ok: false });
|
|
expect(fixture.world.consumeDirtyState().logs).toEqual([
|
|
expect.objectContaining({
|
|
scope: 'GENERAL',
|
|
category: 'ACTION',
|
|
generalId: general.id,
|
|
}),
|
|
]);
|
|
});
|
|
|
|
it('persists the ref failure log when instant retreat has no reachable supplied city', async () => {
|
|
const general = buildGeneral({ nationId: 1, cityId: 2 });
|
|
const fixture = buildImmediateActionWorld({
|
|
general,
|
|
cities: [
|
|
{ id: 1, name: '낙양', nationId: 1, supplyState: 0, meta: {} },
|
|
{ id: 2, name: '장안', nationId: 2, supplyState: 1, meta: {} },
|
|
] as TurnWorldSnapshot['cities'],
|
|
nations: [
|
|
{
|
|
id: 1,
|
|
name: '아국',
|
|
color: '#111111',
|
|
typeCode: 'che_중립',
|
|
level: 1,
|
|
capitalCityId: 1,
|
|
chiefGeneralId: general.id,
|
|
gold: 0,
|
|
rice: 0,
|
|
power: 0,
|
|
meta: {},
|
|
},
|
|
],
|
|
map: {
|
|
id: 'test',
|
|
name: 'test',
|
|
cities: [buildMapCity(1, [2]), buildMapCity(2, [1])],
|
|
},
|
|
availableInstantRetreat: true,
|
|
});
|
|
|
|
await expect(
|
|
fixture.handler.handle({
|
|
type: 'instantRetreat',
|
|
userId: general.userId!,
|
|
generalId: general.id,
|
|
})
|
|
).resolves.toMatchObject({
|
|
ok: false,
|
|
reason: '가까운 아국 도시가 없습니다.',
|
|
});
|
|
expect(fixture.world.getGeneralById(general.id)?.cityId).toBe(2);
|
|
expect(fixture.world.consumeDirtyState().logs.map((entry) => entry.text)).toContain(
|
|
'3칸 이내에 아국 도시가 없습니다.'
|
|
);
|
|
});
|
|
|
|
it('checks the Ref instant-retreat scenario gate before looking up the general', async () => {
|
|
const general = buildGeneral({ nationId: 1, cityId: 1 });
|
|
const fixture = buildImmediateActionWorld({
|
|
general,
|
|
cities: [{ id: 1, name: '낙양', nationId: 1, supplyState: 1, meta: {} }] as TurnWorldSnapshot['cities'],
|
|
nations: [],
|
|
map: {
|
|
id: 'test',
|
|
name: 'test',
|
|
cities: [buildMapCity(1, [])],
|
|
},
|
|
availableInstantRetreat: false,
|
|
});
|
|
fixture.world.removeGeneral(general.id);
|
|
|
|
await expect(
|
|
fixture.handler.handle({
|
|
type: 'instantRetreat',
|
|
userId: general.userId!,
|
|
generalId: general.id,
|
|
})
|
|
).resolves.toMatchObject({
|
|
ok: false,
|
|
reason: '접경귀환을 사용할 수 없는 시나리오입니다.',
|
|
});
|
|
});
|
|
});
|