558 lines
22 KiB
TypeScript
558 lines
22 KiB
TypeScript
import { describe, expect, it } from 'vitest';
|
|
import type { LogEntryDraft, TurnSchedule, UnitSetDefinition } from '@sammo-ts/logic';
|
|
import { DIPLOMACY_STATE, LogCategory, LogFormat, LogScope } from '@sammo-ts/logic';
|
|
import type { InMemoryTurnWorld, TurnCalendarHandler } from '../src/turn/inMemoryWorld.js';
|
|
import type { TurnGeneral, TurnWorldSnapshot, TurnWorldState } from '../src/turn/types.js';
|
|
import { LARGE_TEST_MAP, buildLargeTestCities } from './fixtures/largeTestMap.js';
|
|
import { createTurnTestHarness } from './helpers/turnTestHarness.js';
|
|
|
|
const mockDate = new Date('0181-08-01T00:00:00Z');
|
|
|
|
const createNpcGeneral = (
|
|
id: number,
|
|
cityId: number,
|
|
stats: { leadership: number; strength: number; intelligence: number }
|
|
): TurnGeneral => ({
|
|
id,
|
|
name: `NPC_${id}`,
|
|
nationId: 0,
|
|
cityId,
|
|
troopId: 0,
|
|
stats,
|
|
turnTime: mockDate,
|
|
role: {
|
|
items: { horse: null, weapon: null, book: null, item: null },
|
|
personality: null,
|
|
specialDomestic: null,
|
|
specialWar: null,
|
|
},
|
|
triggerState: { flags: {}, counters: {}, modifiers: {}, meta: {} },
|
|
meta: { killturn: 800 },
|
|
officerLevel: 1,
|
|
experience: 0,
|
|
dedication: 0,
|
|
injury: 0,
|
|
gold: 20000,
|
|
rice: 20000,
|
|
crew: 0,
|
|
crewTypeId: 1100,
|
|
train: 0,
|
|
atmos: 0,
|
|
age: 30,
|
|
npcState: 2,
|
|
});
|
|
|
|
const maxCityStats = (city: ReturnType<typeof buildLargeTestCities>[number]) => ({
|
|
...city,
|
|
population: city.populationMax,
|
|
agriculture: city.agricultureMax,
|
|
commerce: city.commerceMax,
|
|
security: city.securityMax,
|
|
defence: city.defenceMax,
|
|
wall: city.wallMax,
|
|
meta: { ...(city.meta ?? {}), trust: 100, trade: 100 },
|
|
});
|
|
|
|
const addMonths = (year: number, month: number, delta: number): { year: number; month: number } => {
|
|
const total = year * 12 + (month - 1) + delta;
|
|
const nextYear = Math.floor(total / 12);
|
|
const nextMonth = (total % 12) + 1;
|
|
return { year: nextYear, month: nextMonth };
|
|
};
|
|
|
|
const buildUnificationLog = (nationName: string): LogEntryDraft => ({
|
|
scope: LogScope.SYSTEM,
|
|
category: LogCategory.HISTORY,
|
|
format: LogFormat.YEAR_MONTH,
|
|
text: `<C>●</><Y><b>【통일】</b></><D><b>${nationName}</b></>이 전토를 통일하였습니다.`,
|
|
meta: {},
|
|
});
|
|
|
|
const boostNationOneCities = (world: InMemoryTurnWorld) => {
|
|
const cities = world.listCities();
|
|
for (const city of cities) {
|
|
if (city.nationId !== 1) {
|
|
continue;
|
|
}
|
|
world.updateCity(city.id, {
|
|
population: city.populationMax,
|
|
defence: city.defenceMax,
|
|
wall: city.wallMax,
|
|
meta: { ...(city.meta ?? {}), trust: 100 },
|
|
});
|
|
}
|
|
};
|
|
|
|
const dumpWorldStatus = (world: InMemoryTurnWorld, label: string) => {
|
|
const state = world.getState();
|
|
const cities = world.listCities();
|
|
const generals = world.listGenerals();
|
|
const nations = world.listNations();
|
|
|
|
const nationStats = nations.map((nation) => {
|
|
const nationCities = cities.filter((city) => city.nationId === nation.id);
|
|
const nationGenerals = generals.filter((general) => general.nationId === nation.id);
|
|
const totalGold = nationGenerals.reduce((sum, general) => sum + general.gold, 0);
|
|
const totalRice = nationGenerals.reduce((sum, general) => sum + general.rice, 0);
|
|
const avgGold = nationGenerals.length > 0 ? Math.floor(totalGold / nationGenerals.length) : 0;
|
|
const avgRice = nationGenerals.length > 0 ? Math.floor(totalRice / nationGenerals.length) : 0;
|
|
return {
|
|
id: nation.id,
|
|
name: nation.name,
|
|
level: nation.level,
|
|
typeCode: nation.typeCode,
|
|
capitalCityId: nation.capitalCityId,
|
|
cityCount: nationCities.length,
|
|
generalCount: nationGenerals.length,
|
|
chiefCount: nationGenerals.filter((general) => general.officerLevel === 12).length,
|
|
gold: nation.gold,
|
|
rice: nation.rice,
|
|
avgGold,
|
|
avgRice,
|
|
meta: nation.meta,
|
|
};
|
|
});
|
|
|
|
const citySummary = cities.map((city) => ({
|
|
id: city.id,
|
|
name: city.name,
|
|
nationId: city.nationId,
|
|
level: city.level,
|
|
population: city.population,
|
|
agriculture: city.agriculture,
|
|
commerce: city.commerce,
|
|
security: city.security,
|
|
defence: city.defence,
|
|
wall: city.wall,
|
|
supplyState: city.supplyState,
|
|
frontState: city.frontState,
|
|
}));
|
|
|
|
console.log('[DEBUG] world status', {
|
|
label,
|
|
year: state.currentYear,
|
|
month: state.currentMonth,
|
|
nationCount: nations.length,
|
|
cityCount: cities.length,
|
|
generalCount: generals.length,
|
|
nationStats,
|
|
diplomacy: world.listDiplomacy().map((entry) => ({
|
|
fromNationId: entry.fromNationId,
|
|
toNationId: entry.toNationId,
|
|
state: entry.state,
|
|
term: entry.term,
|
|
})),
|
|
citySummary,
|
|
});
|
|
};
|
|
|
|
describe('NPC 건국/통일 장기 시뮬레이션', () => {
|
|
it('건국, 선포, 출병, 점령과 장기 국가 감소가 안정적으로 진행되어야 한다', async () => {
|
|
const cities = buildLargeTestCities().map(maxCityStats);
|
|
for (const city of cities) {
|
|
city.nationId = 0;
|
|
}
|
|
|
|
const unitSet: UnitSetDefinition = {
|
|
id: 'test_unit_set',
|
|
name: 'TestUnitSet',
|
|
defaultCrewTypeId: 1100,
|
|
crewTypes: [
|
|
{
|
|
id: 1100,
|
|
armType: 1,
|
|
name: '보병',
|
|
attack: 100,
|
|
defence: 150,
|
|
speed: 7,
|
|
avoid: 10,
|
|
magicCoef: 0,
|
|
cost: 10,
|
|
rice: 10,
|
|
requirements: [],
|
|
attackCoef: {},
|
|
defenceCoef: {},
|
|
info: [],
|
|
initSkillTrigger: null,
|
|
phaseSkillTrigger: null,
|
|
iActionList: null,
|
|
},
|
|
{
|
|
id: 1400,
|
|
armType: 4,
|
|
name: '귀병',
|
|
attack: 80,
|
|
defence: 80,
|
|
speed: 7,
|
|
avoid: 5,
|
|
magicCoef: 0.5,
|
|
cost: 9,
|
|
rice: 9,
|
|
requirements: [],
|
|
attackCoef: {},
|
|
defenceCoef: {},
|
|
info: [],
|
|
initSkillTrigger: null,
|
|
phaseSkillTrigger: null,
|
|
iActionList: null,
|
|
},
|
|
],
|
|
};
|
|
|
|
const generals: TurnGeneral[] = [];
|
|
for (let i = 0; i < 300; i += 1) {
|
|
const cityId = cities[i % cities.length]!.id;
|
|
const stats =
|
|
i % 2 === 0
|
|
? { leadership: 75, strength: 75, intelligence: 10 }
|
|
: { leadership: 75, strength: 10, intelligence: 75 };
|
|
generals.push(createNpcGeneral(i + 1, cityId, stats));
|
|
}
|
|
|
|
const snapshot: TurnWorldSnapshot = {
|
|
generals: generals as any,
|
|
cities: cities as any,
|
|
nations: [],
|
|
troops: [],
|
|
diplomacy: [],
|
|
events: [],
|
|
initialEvents: [],
|
|
map: LARGE_TEST_MAP as any,
|
|
scenarioConfig: {
|
|
stat: { total: 300, min: 10, max: 100, npcTotal: 150, npcMax: 50, npcMin: 10, chiefMin: 70 },
|
|
iconPath: '',
|
|
map: {},
|
|
const: {
|
|
openingPartYear: 3,
|
|
develCost: 10,
|
|
baseGold: 1000,
|
|
baseRice: 1000,
|
|
maxResourceActionAmount: 10000,
|
|
minAvailableRecruitPop: 0,
|
|
},
|
|
environment: { mapName: 'large_test_map', unitSet: 'default' },
|
|
},
|
|
scenarioMeta: {
|
|
startYear: 180,
|
|
} as any,
|
|
unitSet: unitSet as any,
|
|
};
|
|
|
|
const state: TurnWorldState = {
|
|
id: 1,
|
|
currentYear: 181,
|
|
currentMonth: 8,
|
|
tickSeconds: 600,
|
|
lastTurnTime: mockDate,
|
|
meta: { seed: 1, initYear: 181, initMonth: 8 },
|
|
};
|
|
|
|
const schedule: TurnSchedule = {
|
|
entries: [{ startMinute: 0, tickMinutes: 10 }],
|
|
};
|
|
|
|
const worldRef = { current: null as InMemoryTurnWorld | null };
|
|
|
|
const unificationHandler: TurnCalendarHandler = {
|
|
onMonthChanged: () => {
|
|
const world = worldRef.current;
|
|
if (!world) {
|
|
return;
|
|
}
|
|
boostNationOneCities(world);
|
|
const meta = world.getState().meta as Record<string, unknown>;
|
|
if (typeof meta.isUnited === 'number' && meta.isUnited !== 0) {
|
|
return;
|
|
}
|
|
const citiesNow = world.listCities();
|
|
const activeNations = world
|
|
.listNations()
|
|
.filter((nation) => nation.level > 0)
|
|
.filter((nation) => citiesNow.some((city) => city.nationId === nation.id));
|
|
if (activeNations.length !== 1) {
|
|
return;
|
|
}
|
|
const winner = activeNations[0];
|
|
const ownedCount = citiesNow.filter((city) => city.nationId === winner.id).length;
|
|
if (ownedCount !== citiesNow.length) {
|
|
return;
|
|
}
|
|
world.updateWorldMeta({ isUnited: 2 });
|
|
world.pushLog(buildUnificationLog(winner.name));
|
|
},
|
|
};
|
|
|
|
const lastNationAiState = new Map<number, unknown>();
|
|
let declarationCount = 0;
|
|
let sortieCount = 0;
|
|
let lastResolvedAction = 'none';
|
|
|
|
const { runUntil, getCollectedLogs, getCollectedLogsCount, getCollectedLogsRange } =
|
|
await createTurnTestHarness({
|
|
snapshot,
|
|
state,
|
|
schedule,
|
|
map: LARGE_TEST_MAP,
|
|
worldRef,
|
|
extraCalendarHandlers: [unificationHandler],
|
|
collectLogs: true,
|
|
onActionResolved: (payload) => {
|
|
const currentWorld = worldRef.current;
|
|
if (currentWorld) {
|
|
const nationIds = new Set(currentWorld.listNations().map((nation) => nation.id));
|
|
const orphanCities = currentWorld
|
|
.listCities()
|
|
.filter((city) => city.nationId > 0 && !nationIds.has(city.nationId));
|
|
if (orphanCities.length > 0) {
|
|
throw new Error(
|
|
`orphan city ownership after ${lastResolvedAction}, before ${payload.kind}:${payload.actionKey}: ${orphanCities
|
|
.map((city) => `${city.id}->${city.nationId}`)
|
|
.join(', ')}`
|
|
);
|
|
}
|
|
}
|
|
lastResolvedAction = `${payload.kind}:${payload.actionKey}`;
|
|
if (payload.kind === 'general') {
|
|
if (payload.actionKey === 'che_출병') {
|
|
sortieCount += 1;
|
|
}
|
|
return;
|
|
}
|
|
if (payload.nationId) {
|
|
lastNationAiState.set(payload.nationId, payload.aiState ?? null);
|
|
}
|
|
if (payload.actionKey === 'che_선전포고') {
|
|
declarationCount += 1;
|
|
}
|
|
},
|
|
});
|
|
|
|
let monthlyLogCursor = 0;
|
|
const maxMonthlyLogEntries = 20;
|
|
const _dumpMonthlyLogs = (label: string) => {
|
|
const end = getCollectedLogsCount();
|
|
if (end <= monthlyLogCursor) {
|
|
return;
|
|
}
|
|
const logs = getCollectedLogsRange(monthlyLogCursor, end);
|
|
monthlyLogCursor = end;
|
|
if (logs.length === 0) {
|
|
return;
|
|
}
|
|
const historyLogs = logs.filter((log) => log.category === LogCategory.HISTORY);
|
|
if (historyLogs.length === 0) {
|
|
return;
|
|
}
|
|
const limitedLogs = historyLogs.slice(0, maxMonthlyLogEntries);
|
|
const truncated = historyLogs.length - limitedLogs.length;
|
|
console.log('[DEBUG] month history logs', {
|
|
label,
|
|
total: historyLogs.length,
|
|
truncated,
|
|
logs: limitedLogs.map((log) => log.text),
|
|
});
|
|
};
|
|
|
|
try {
|
|
await runUntil(
|
|
(current) => current.currentYear > 182 || (current.currentYear === 182 && current.currentMonth >= 1)
|
|
);
|
|
|
|
const world = worldRef.current;
|
|
if (!world) {
|
|
throw new Error('world not initialized');
|
|
}
|
|
|
|
const foundedNations = world.listNations().filter((nation) => nation.level > 0);
|
|
expect(foundedNations.length).toBeGreaterThanOrEqual(2);
|
|
const foundedNationCount = foundedNations.length;
|
|
|
|
await runUntil(
|
|
(current) => current.currentYear > 183 || (current.currentYear === 183 && current.currentMonth >= 6)
|
|
);
|
|
|
|
const neutralCities = world.listCities().filter((city) => city.nationId <= 0);
|
|
expect(neutralCities.length).toBe(0);
|
|
|
|
const hasHighOfficer = world
|
|
.listGenerals()
|
|
.some((general) => general.nationId > 0 && general.officerLevel >= 12);
|
|
expect(hasHighOfficer).toBe(true);
|
|
|
|
if (declarationCount === 0) {
|
|
await runUntil(
|
|
(current) => current.currentYear > 190 || (current.currentYear === 190 && current.currentMonth >= 1)
|
|
);
|
|
if (declarationCount === 0) {
|
|
const generals = world.listGenerals().filter((general) => general.nationId > 0);
|
|
const yearMonth = world.getState().currentYear * 12 + world.getState().currentMonth - 1;
|
|
const startYear = (snapshot.scenarioMeta as { startYear?: number } | null)?.startYear ?? 180;
|
|
const startYearMonth = (startYear + 2) * 12 + (5 - 1);
|
|
const diplomacyList = world.listDiplomacy();
|
|
const crewSummary = world
|
|
.listNations()
|
|
.filter((nation) => nation.level > 0)
|
|
.map((nation) => {
|
|
const nationGenerals = generals.filter((general) => general.nationId === nation.id);
|
|
const crewed = nationGenerals.filter(
|
|
(general) => general.crew > 0 && general.crewTypeId > 0
|
|
);
|
|
return {
|
|
nationId: nation.id,
|
|
totalGenerals: nationGenerals.length,
|
|
crewedGenerals: crewed.length,
|
|
maxCrew: crewed.reduce((max, general) => Math.max(max, general.crew), 0),
|
|
};
|
|
});
|
|
const dipTrace = world
|
|
.listNations()
|
|
.filter((nation) => nation.level > 0)
|
|
.map((nation) => {
|
|
const warTargets = diplomacyList.filter(
|
|
(entry) =>
|
|
entry.fromNationId === nation.id &&
|
|
(entry.state === DIPLOMACY_STATE.WAR || entry.state === DIPLOMACY_STATE.DECLARATION)
|
|
);
|
|
const declareTerms = warTargets
|
|
.filter((entry) => entry.state === DIPLOMACY_STATE.DECLARATION)
|
|
.map((entry) => entry.term);
|
|
const minWarTerm = declareTerms.length > 0 ? Math.min(...declareTerms) : null;
|
|
const frontStatus = world
|
|
.listCities()
|
|
.some(
|
|
(city) => city.nationId === nation.id && city.supplyState > 0 && city.frontState > 0
|
|
);
|
|
const hasCrew = generals.some(
|
|
(general) => general.nationId === nation.id && general.crew > 0
|
|
);
|
|
const meta = (nation.meta ?? {}) as Record<string, unknown>;
|
|
const lastAttackable = typeof meta.last_attackable === 'number' ? meta.last_attackable : 0;
|
|
return {
|
|
nationId: nation.id,
|
|
yearMonth,
|
|
startYearMonth,
|
|
warTargets: warTargets.length,
|
|
minWarTerm,
|
|
frontStatus,
|
|
hasCrew,
|
|
lastAttackable,
|
|
};
|
|
});
|
|
const diplomacyPairs = world
|
|
.listDiplomacy()
|
|
.filter((entry) => entry.fromNationId !== entry.toNationId)
|
|
.map((entry) => ({
|
|
from: entry.fromNationId,
|
|
to: entry.toNationId,
|
|
state: entry.state,
|
|
term: entry.term,
|
|
}));
|
|
|
|
console.log('[DEBUG] no declaration by 190-01', {
|
|
nations: world.listNations().map((nation) => ({
|
|
id: nation.id,
|
|
name: nation.name,
|
|
level: nation.level,
|
|
capitalCityId: nation.capitalCityId,
|
|
meta: nation.meta,
|
|
})),
|
|
crewSummary,
|
|
dipTrace,
|
|
diplomacyPairs,
|
|
lastNationAiState: Array.from(lastNationAiState.entries()).map(([nationId, aiState]) => {
|
|
const record = (aiState ?? {}) as Record<string, unknown>;
|
|
return {
|
|
nationId,
|
|
dipState: record.dipState,
|
|
attackable: record.attackable,
|
|
frontCities: record.frontCities,
|
|
warTargetNation: record.warTargetNation,
|
|
year: record.year,
|
|
month: record.month,
|
|
};
|
|
}),
|
|
});
|
|
throw new Error('no declaration by 190-01');
|
|
}
|
|
}
|
|
|
|
let prevNationCount = world
|
|
.listNations()
|
|
.filter(
|
|
(nation) => nation.level > 0 && world.listCities().some((city) => city.nationId === nation.id)
|
|
).length;
|
|
let unifiedAt: { year: number; month: number } | null = null;
|
|
|
|
while (true) {
|
|
const target = addMonths(world.getState().currentYear, world.getState().currentMonth, 1);
|
|
await runUntil(
|
|
(current) =>
|
|
current.currentYear > target.year ||
|
|
(current.currentYear === target.year && current.currentMonth >= target.month)
|
|
);
|
|
//_dumpMonthlyLogs(`${target.year}-${String(target.month).padStart(2, '0')}`);
|
|
|
|
const nationIds = new Set(world.listNations().map((nation) => nation.id));
|
|
const orphanCities = world
|
|
.listCities()
|
|
.filter((city) => city.nationId > 0 && !nationIds.has(city.nationId));
|
|
if (orphanCities.length > 0) {
|
|
dumpWorldStatus(world, '존재하지 않는 국가가 도시를 소유');
|
|
throw new Error(
|
|
`orphan city ownership: ${orphanCities
|
|
.map((city) => `${city.id}->${city.nationId}`)
|
|
.join(', ')}`
|
|
);
|
|
}
|
|
|
|
const activeNationCount = world
|
|
.listNations()
|
|
.filter((nation) => nation.level > 0)
|
|
.filter((nation) => world.listCities().some((city) => city.nationId === nation.id)).length;
|
|
const totalGenerals = world.listGenerals().length;
|
|
|
|
expect(activeNationCount).toBeLessThanOrEqual(prevNationCount);
|
|
expect(totalGenerals).toBeGreaterThanOrEqual(2);
|
|
|
|
prevNationCount = activeNationCount;
|
|
|
|
if (activeNationCount === 1 && !unifiedAt) {
|
|
const nextMonth = addMonths(world.getState().currentYear, world.getState().currentMonth, 1);
|
|
await runUntil(
|
|
(current) =>
|
|
current.currentYear > nextMonth.year ||
|
|
(current.currentYear === nextMonth.year && current.currentMonth >= nextMonth.month)
|
|
);
|
|
unifiedAt = nextMonth;
|
|
break;
|
|
}
|
|
|
|
if (
|
|
world.getState().currentYear > 260 ||
|
|
(world.getState().currentYear === 260 && world.getState().currentMonth >= 1)
|
|
) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
const meta = world.getState().meta as Record<string, unknown>;
|
|
const logs = getCollectedLogs();
|
|
const hasUnificationLog = logs.some((log) => log.text.includes('전토를 통일하였습니다.'));
|
|
if (unifiedAt) {
|
|
expect(meta.isUnited).toBe(2);
|
|
expect(hasUnificationLog).toBe(true);
|
|
} else {
|
|
expect(prevNationCount).toBeLessThan(foundedNationCount);
|
|
expect(meta.isUnited ?? 0).toBe(0);
|
|
}
|
|
expect(sortieCount).toBeGreaterThan(0);
|
|
} catch (error) {
|
|
const world = worldRef.current;
|
|
if (world) {
|
|
dumpWorldStatus(world, '테스트 실패');
|
|
}
|
|
throw error;
|
|
}
|
|
}, 180000);
|
|
});
|