444 lines
17 KiB
TypeScript
444 lines
17 KiB
TypeScript
import { execFileSync } from 'node:child_process';
|
|
import fs from 'node:fs';
|
|
import path from 'node:path';
|
|
|
|
import { afterAll, beforeAll, describe, expect, it } from 'vitest';
|
|
import { createGamePostgresConnector, type GamePrismaClient } from '@sammo-ts/infra';
|
|
import type { City, MapDefinition, Nation } from '@sammo-ts/logic';
|
|
|
|
import { createDatabaseTurnHooks } from '../src/turn/databaseHooks.js';
|
|
import { InMemoryTurnWorld } from '../src/turn/inMemoryWorld.js';
|
|
import { createProvideNpcTroopLeaderHandler } from '../src/turn/monthlyProvideNpcTroopLeaderAction.js';
|
|
import { createRaiseNpcNationHandler } from '../src/turn/monthlyRaiseNpcNationAction.js';
|
|
import { createMonthlyEventHandler } from '../src/turn/monthlyEventHandler.js';
|
|
import { InMemoryReservedTurnStore } from '../src/turn/reservedTurnStore.js';
|
|
import { buildCommandEnv } from '../src/turn/reservedTurnCommands.js';
|
|
import type { TurnEvent, TurnWorldSnapshot, TurnWorldState } from '../src/turn/types.js';
|
|
|
|
const databaseUrl = process.env.INPUT_EVENT_DATABASE_URL;
|
|
const integration = describe.skipIf(!databaseUrl);
|
|
const existingNationId = 990_083;
|
|
const createdNationId = 990_086;
|
|
const occupiedCityId = 990_083;
|
|
const targetCityId = 990_086;
|
|
const createdGeneralId = 990_086;
|
|
const existingNationLeaderId = 990_087;
|
|
const createdNationLeaderId = 990_088;
|
|
const createdGeneralIds = [createdGeneralId, existingNationLeaderId, createdNationLeaderId];
|
|
|
|
type ReferenceNpcNationLifecycleTrace = {
|
|
phases: {
|
|
afterRaise: {
|
|
createdNationCount: number;
|
|
createdGeneralCount: number;
|
|
generalCountsPerCreatedNation: number[];
|
|
historyLogs: string[];
|
|
};
|
|
afterProvide: {
|
|
createdLeaderCount: number;
|
|
leaderCountsPerActiveNation: number[];
|
|
troopCount: number;
|
|
gatherTurnCounts: number[];
|
|
leaderCounterDelta: number;
|
|
};
|
|
};
|
|
};
|
|
|
|
const runReferenceNpcNationLifecycle = (): ReferenceNpcNationLifecycleTrace | null => {
|
|
const workspaceRoot = process.env.TURN_DIFFERENTIAL_WORKSPACE_ROOT;
|
|
if (process.env.TURN_DIFFERENTIAL_REFERENCE !== '1' || !workspaceRoot) {
|
|
return null;
|
|
}
|
|
const stackDirectory = path.join(workspaceRoot, 'docker_compose_files/reference');
|
|
const runnerScript =
|
|
process.env.MONTHLY_NPC_LIFECYCLE_RUNNER_SCRIPT ??
|
|
path.join(workspaceRoot, 'ref/sam/hwe/compare/monthly_event_trace.php');
|
|
const fixturePath =
|
|
process.env.MONTHLY_NPC_LIFECYCLE_FIXTURE ??
|
|
path.join(path.dirname(runnerScript), 'fixtures/monthly_npc_nation_lifecycle.json');
|
|
const stdout = execFileSync('./scripts/run-turn-differential-case.sh', ['-'], {
|
|
cwd: stackDirectory,
|
|
input: fs.readFileSync(fixturePath, 'utf8'),
|
|
encoding: 'utf8',
|
|
stdio: ['pipe', 'pipe', 'pipe'],
|
|
env: {
|
|
...process.env,
|
|
COMPOSE_PROJECT_NAME: 'sam-rebuild-reference',
|
|
TURN_DIFFERENTIAL_RUNNER_SCRIPT: runnerScript,
|
|
TURN_DIFFERENTIAL_COMPARE_DIR: path.dirname(runnerScript),
|
|
},
|
|
});
|
|
return JSON.parse(stdout) as ReferenceNpcNationLifecycleTrace;
|
|
};
|
|
|
|
const buildCity = (id: number, nationId: number, name: string): City => ({
|
|
id,
|
|
name,
|
|
nationId,
|
|
level: 5,
|
|
state: 0,
|
|
population: 10_000,
|
|
populationMax: 50_000,
|
|
agriculture: 1_000,
|
|
agricultureMax: 5_000,
|
|
commerce: 2_000,
|
|
commerceMax: 6_000,
|
|
security: 3_000,
|
|
securityMax: 7_000,
|
|
supplyState: 1,
|
|
frontState: 0,
|
|
defence: 4_000,
|
|
defenceMax: 8_000,
|
|
wall: 5_000,
|
|
wallMax: 9_000,
|
|
meta: { trust: 50 },
|
|
});
|
|
|
|
const occupiedCity = buildCity(occupiedCityId, existingNationId, '기준도시');
|
|
const targetCity = buildCity(targetCityId, 0, 'NPC건국도시');
|
|
const existingNation: Nation = {
|
|
id: existingNationId,
|
|
name: '기준국',
|
|
color: '#777777',
|
|
capitalCityId: occupiedCityId,
|
|
chiefGeneralId: null,
|
|
gold: 1_000,
|
|
rice: 1_000,
|
|
power: 0,
|
|
level: 2,
|
|
typeCode: 'che_유가',
|
|
meta: { tech: 120 },
|
|
};
|
|
|
|
const map: MapDefinition = {
|
|
id: 'test',
|
|
name: 'test',
|
|
cities: [occupiedCityId, 990_084, 990_085, targetCityId].map((id, index, rows) => ({
|
|
id,
|
|
name: `지도도시${id}`,
|
|
level: 5,
|
|
region: 1,
|
|
position: { x: index, y: 0 },
|
|
connections: [...(index > 0 ? [rows[index - 1]!] : []), ...(index + 1 < rows.length ? [rows[index + 1]!] : [])],
|
|
max: {
|
|
population: 50_000,
|
|
agriculture: 5_000,
|
|
commerce: 6_000,
|
|
security: 7_000,
|
|
defence: 8_000,
|
|
wall: 9_000,
|
|
},
|
|
initial: {
|
|
population: 10_000,
|
|
agriculture: 1_000,
|
|
commerce: 2_000,
|
|
security: 3_000,
|
|
defence: 4_000,
|
|
wall: 5_000,
|
|
},
|
|
})),
|
|
};
|
|
|
|
const event: TurnEvent = {
|
|
id: 1,
|
|
targetCode: 'month',
|
|
priority: 1_000,
|
|
condition: true,
|
|
action: [['RaiseNPCNation'], ['ProvideNPCTroopLeader']],
|
|
meta: {},
|
|
};
|
|
|
|
integration('RaiseNPCNation database persistence', () => {
|
|
let db: GamePrismaClient;
|
|
let closeDb: (() => Promise<void>) | undefined;
|
|
|
|
const clean = async () => {
|
|
await db.logEntry.deleteMany({
|
|
where: {
|
|
OR: [
|
|
{ generalId: { in: createdGeneralIds } },
|
|
{ year: 200, month: 1, text: { contains: '공백지에 임의의 국가' } },
|
|
],
|
|
},
|
|
});
|
|
await db.generalTurn.deleteMany({ where: { generalId: { in: createdGeneralIds } } });
|
|
await db.rankData.deleteMany({ where: { generalId: { in: createdGeneralIds } } });
|
|
await db.troop.deleteMany({ where: { troopLeaderId: { in: createdGeneralIds } } });
|
|
await db.general.deleteMany({ where: { id: { in: createdGeneralIds } } });
|
|
await db.nationTurn.deleteMany({ where: { nationId: createdNationId } });
|
|
await db.diplomacy.deleteMany({
|
|
where: {
|
|
OR: [{ srcNationId: createdNationId }, { destNationId: createdNationId }],
|
|
},
|
|
});
|
|
await db.nation.deleteMany({ where: { id: { in: [createdNationId, existingNationId] } } });
|
|
await db.city.deleteMany({ where: { id: { in: [occupiedCityId, targetCityId] } } });
|
|
};
|
|
|
|
beforeAll(async () => {
|
|
const connector = createGamePostgresConnector({ url: databaseUrl! });
|
|
await connector.connect();
|
|
db = connector.prisma;
|
|
closeDb = () => connector.disconnect();
|
|
await clean();
|
|
});
|
|
|
|
afterAll(async () => {
|
|
await clean();
|
|
await closeDb?.();
|
|
});
|
|
|
|
it('commits the nation, city, diplomacy, ruler, turns, ranks, and history in one flush', async () => {
|
|
const referenceTrace = runReferenceNpcNationLifecycle();
|
|
const createCity = (city: City) =>
|
|
db.city.create({
|
|
data: {
|
|
id: city.id,
|
|
name: city.name,
|
|
nationId: city.nationId,
|
|
level: city.level,
|
|
supplyState: city.supplyState,
|
|
frontState: city.frontState,
|
|
population: city.population,
|
|
populationMax: city.populationMax,
|
|
agriculture: city.agriculture,
|
|
agricultureMax: city.agricultureMax,
|
|
commerce: city.commerce,
|
|
commerceMax: city.commerceMax,
|
|
security: city.security,
|
|
securityMax: city.securityMax,
|
|
trust: 50,
|
|
trade: 100,
|
|
defence: city.defence,
|
|
defenceMax: city.defenceMax,
|
|
wall: city.wall,
|
|
wallMax: city.wallMax,
|
|
region: 1,
|
|
conflict: {},
|
|
meta: {},
|
|
},
|
|
});
|
|
await createCity(occupiedCity);
|
|
await createCity(targetCity);
|
|
await db.nation.create({
|
|
data: {
|
|
id: existingNation.id,
|
|
name: existingNation.name,
|
|
color: existingNation.color,
|
|
capitalCityId: existingNation.capitalCityId,
|
|
chiefGeneralId: null,
|
|
gold: existingNation.gold,
|
|
rice: existingNation.rice,
|
|
tech: 120,
|
|
level: existingNation.level,
|
|
typeCode: existingNation.typeCode,
|
|
meta: existingNation.meta,
|
|
},
|
|
});
|
|
const stateRow = await db.worldState.create({
|
|
data: {
|
|
scenarioCode: 'monthly-raise-npc-nation-persistence',
|
|
currentYear: 199,
|
|
currentMonth: 12,
|
|
tickSeconds: 600,
|
|
config: {},
|
|
meta: {
|
|
hiddenSeed: 'raise-npc-nation-persistence',
|
|
lastGeneralId: createdGeneralId - 1,
|
|
lastNationId: createdNationId - 1,
|
|
lastNPCTroopLeaderID: 40,
|
|
serverId: 'raise-npc-nation-persistence',
|
|
},
|
|
},
|
|
});
|
|
const state: TurnWorldState = {
|
|
id: stateRow.id,
|
|
currentYear: 199,
|
|
currentMonth: 12,
|
|
tickSeconds: 600,
|
|
lastTurnTime: new Date('0199-12-01T00:00:00.000Z'),
|
|
meta: {
|
|
hiddenSeed: 'raise-npc-nation-persistence',
|
|
lastGeneralId: createdGeneralId - 1,
|
|
lastNationId: createdNationId - 1,
|
|
lastNPCTroopLeaderID: 40,
|
|
serverId: 'raise-npc-nation-persistence',
|
|
},
|
|
};
|
|
const snapshot: TurnWorldSnapshot = {
|
|
scenarioConfig: {
|
|
stat: { total: 165, min: 15, max: 80, npcTotal: 150, npcMax: 75, npcMin: 10, chiefMin: 65 },
|
|
iconPath: '.',
|
|
map: {},
|
|
const: {
|
|
retirementYear: 80,
|
|
availablePersonality: ['che_안전'],
|
|
randGenFirstName: ['가'],
|
|
randGenMiddleName: [''],
|
|
randGenLastName: ['나'],
|
|
},
|
|
environment: { mapName: 'test', unitSet: 'default' },
|
|
},
|
|
map,
|
|
generals: [],
|
|
cities: [occupiedCity, targetCity],
|
|
nations: [existingNation],
|
|
troops: [],
|
|
diplomacy: [],
|
|
events: [event],
|
|
initialEvents: [],
|
|
};
|
|
const reservedTurns = new InMemoryReservedTurnStore(db, { maxGeneralTurns: 30, maxNationTurns: 12 });
|
|
let world: InMemoryTurnWorld | null = null;
|
|
const handler = createRaiseNpcNationHandler({
|
|
getWorld: () => world,
|
|
reservedTurns,
|
|
env: buildCommandEnv(snapshot.scenarioConfig),
|
|
map,
|
|
loadArchivedNationMaxId: async () => 0,
|
|
});
|
|
const provide = createProvideNpcTroopLeaderHandler({
|
|
getWorld: () => world,
|
|
reservedTurns,
|
|
env: buildCommandEnv(snapshot.scenarioConfig),
|
|
});
|
|
world = new InMemoryTurnWorld(state, snapshot, {
|
|
schedule: { entries: [{ startMinute: 0, tickMinutes: 10 }] },
|
|
calendarHandler: createMonthlyEventHandler({
|
|
getWorld: () => world,
|
|
startYear: 190,
|
|
actions: new Map([
|
|
['RaiseNPCNation', handler],
|
|
['ProvideNPCTroopLeader', provide],
|
|
]),
|
|
}),
|
|
});
|
|
const dbHooks = await createDatabaseTurnHooks(databaseUrl!, world, { reservedTurns });
|
|
|
|
try {
|
|
await world.advanceMonth(new Date('0200-01-01T00:00:00.000Z'));
|
|
await dbHooks.hooks.flushChanges?.({
|
|
lastTurnTime: state.lastTurnTime.toISOString(),
|
|
processedGenerals: 0,
|
|
processedTurns: 1,
|
|
durationMs: 0,
|
|
partial: false,
|
|
});
|
|
|
|
expect(await db.nation.findUniqueOrThrow({ where: { id: createdNationId } })).toMatchObject({
|
|
name: 'ⓤNPC건국도시',
|
|
capitalCityId: targetCityId,
|
|
chiefGeneralId: createdGeneralId,
|
|
gold: 0,
|
|
rice: 2_000,
|
|
tech: 120,
|
|
level: 2,
|
|
});
|
|
expect(await db.city.findUniqueOrThrow({ where: { id: targetCityId } })).toMatchObject({
|
|
nationId: createdNationId,
|
|
trust: 100,
|
|
population: occupiedCity.population,
|
|
agriculture: occupiedCity.agriculture,
|
|
commerce: occupiedCity.commerce,
|
|
security: occupiedCity.security,
|
|
defence: occupiedCity.defence,
|
|
wall: occupiedCity.wall,
|
|
});
|
|
expect(await db.general.findUniqueOrThrow({ where: { id: createdGeneralId } })).toMatchObject({
|
|
name: 'ⓤNPC건국도시태수',
|
|
nationId: createdNationId,
|
|
cityId: targetCityId,
|
|
officerLevel: 12,
|
|
npcState: 6,
|
|
});
|
|
expect(await db.generalTurn.count({ where: { generalId: createdGeneralId } })).toBe(30);
|
|
expect(await db.nationTurn.count({ where: { nationId: createdNationId } })).toBe(48);
|
|
expect(await db.rankData.count({ where: { generalId: createdGeneralId } })).toBe(44);
|
|
expect(
|
|
await db.diplomacy.count({
|
|
where: {
|
|
OR: [{ srcNationId: createdNationId }, { destNationId: createdNationId }],
|
|
},
|
|
})
|
|
).toBe(2);
|
|
expect(
|
|
await db.general.findMany({
|
|
where: { id: { in: [existingNationLeaderId, createdNationLeaderId] } },
|
|
orderBy: { id: 'asc' },
|
|
select: {
|
|
id: true,
|
|
name: true,
|
|
nationId: true,
|
|
cityId: true,
|
|
troopId: true,
|
|
npcState: true,
|
|
},
|
|
})
|
|
).toEqual([
|
|
{
|
|
id: existingNationLeaderId,
|
|
name: '㉥부대장 41',
|
|
nationId: existingNationId,
|
|
cityId: occupiedCityId,
|
|
troopId: existingNationLeaderId,
|
|
npcState: 5,
|
|
},
|
|
{
|
|
id: createdNationLeaderId,
|
|
name: '㉥부대장 42',
|
|
nationId: createdNationId,
|
|
cityId: targetCityId,
|
|
troopId: createdNationLeaderId,
|
|
npcState: 5,
|
|
},
|
|
]);
|
|
expect(
|
|
await db.troop.count({
|
|
where: { troopLeaderId: { in: [existingNationLeaderId, createdNationLeaderId] } },
|
|
})
|
|
).toBe(2);
|
|
for (const leaderId of [existingNationLeaderId, createdNationLeaderId]) {
|
|
expect(
|
|
await db.generalTurn.count({
|
|
where: { generalId: leaderId, actionCode: 'che_집합' },
|
|
})
|
|
).toBe(30);
|
|
expect(await db.rankData.count({ where: { generalId: leaderId } })).toBe(44);
|
|
}
|
|
expect(await db.worldState.findUniqueOrThrow({ where: { id: stateRow.id } })).toMatchObject({
|
|
meta: expect.objectContaining({ lastNPCTroopLeaderID: 42 }),
|
|
});
|
|
expect(
|
|
await db.logEntry.findFirst({
|
|
where: { year: 200, month: 1, text: { contains: '공백지에 임의의 국가' } },
|
|
select: { text: true },
|
|
})
|
|
).toEqual({
|
|
text: '<C>●</>200년 1월:<L><b>【공지】</b></>공백지에 임의의 국가가 생성되었습니다.',
|
|
});
|
|
if (referenceTrace) {
|
|
expect(referenceTrace.phases).toEqual({
|
|
afterRaise: {
|
|
createdNationCount: 1,
|
|
createdGeneralCount: 1,
|
|
generalCountsPerCreatedNation: [1],
|
|
historyLogs: [
|
|
'<C>●</>200년 1월:<L><b>【공지】</b></>공백지에 임의의 국가가 생성되었습니다.',
|
|
],
|
|
},
|
|
afterProvide: {
|
|
createdLeaderCount: 2,
|
|
leaderCountsPerActiveNation: [1],
|
|
troopCount: 2,
|
|
gatherTurnCounts: [30],
|
|
leaderCounterDelta: 2,
|
|
},
|
|
});
|
|
}
|
|
} finally {
|
|
await dbHooks.close();
|
|
await db.worldState.delete({ where: { id: stateRow.id } });
|
|
}
|
|
});
|
|
});
|