devsam/core2026
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat(game-engine): implement CreateManyNPC monthly action

Browse Source
This commit is contained in:
Hide_D
2026-07-25 18:15:52 +00:00
parent 3a8dba6cbf
commit 90d195e721
11 changed files with 962 additions and 6 deletions
Download Patch File Download Diff File Expand all files Collapse all files
app/game-engine/test/inputEventAtomicity.test.ts
+13 -2
View File
@@ -49,13 +49,24 @@ describe('input event atomicity', () => {
maxNationTurns: 1,
});
store.shiftGeneralTurns(7, -1);
store.ensureGeneralTurns(8);
await expect(store.flushChanges()).rejects.toThrow('injected write failure');
expect(store.peekDirtyState()).toEqual({ generalIds: [7], nationKeys: [] });
expect(store.peekDirtyState()).toEqual({
generalIds: [7],
generalInitializationIds: [8],
nationKeys: [],
nationInitializationKeys: [],
});
failCreate = false;
await store.flushChanges();
expect(store.peekDirtyState()).toEqual({ generalIds: [], nationKeys: [] });
expect(store.peekDirtyState()).toEqual({
generalIds: [],
generalInitializationIds: [],
nationKeys: [],
nationInitializationKeys: [],
});
});
it('dispatches registry mutations that the old lifecycle switch dropped, then commits before responding', async () => {
app/game-engine/test/monthlyCreateManyNpcAction.test.ts
+356
View File
@@ -0,0 +1,356 @@
import { describe, expect, it, vi } from 'vitest';
import { LEGACY_RANDOM_GENERAL_FIRST_NAMES, LEGACY_RANDOM_GENERAL_LAST_NAMES, type City } from '@sammo-ts/logic';
import { InMemoryTurnWorld } from '../src/turn/inMemoryWorld.js';
import { createCreateManyNpcHandler } from '../src/turn/monthlyCreateManyNpcAction.js';
import { InMemoryReservedTurnStore } from '../src/turn/reservedTurnStore.js';
import { buildCommandEnv } from '../src/turn/reservedTurnCommands.js';
import type { TurnGeneral, TurnWorldSnapshot, TurnWorldState } from '../src/turn/types.js';
const buildCity = (id: number): City => ({
id,
name: `도시${id}`,
nationId: 0,
level: 4,
state: 0,
population: 10_000,
populationMax: 20_000,
agriculture: 1_000,
agricultureMax: 2_000,
commerce: 1_000,
commerceMax: 2_000,
security: 1_000,
securityMax: 2_000,
supplyState: 1,
frontState: 0,
defence: 1_000,
defenceMax: 2_000,
wall: 1_000,
wallMax: 2_000,
meta: {},
});
const buildGeneral = (id: number, patch: Partial<TurnGeneral> = {}): TurnGeneral => ({
id,
userId: null,
name: '가가',
nationId: 1,
cityId: 1,
troopId: 0,
stats: { leadership: 50, strength: 50, intelligence: 50 },
experience: 0,
dedication: 0,
officerLevel: 12,
role: {
personality: null,
specialDomestic: null,
specialWar: null,
items: { horse: null, weapon: null, book: null, item: null },
},
injury: 0,
gold: 1_000,
rice: 1_000,
crew: 0,
crewTypeId: 1100,
train: 0,
atmos: 0,
age: 30,
npcState: 0,
triggerState: { flags: {}, counters: {}, modifiers: {}, meta: {} },
lastTurn: { command: '휴식' },
turnTime: new Date('0200-05-01T00:00:00.000Z'),
recentWarTime: null,
meta: { killturn: 1_000 },
...patch,
});
const buildHarness = (generals: TurnGeneral[] = [], cityCount = 2) => {
const state: TurnWorldState = {
id: 1,
currentYear: 200,
currentMonth: 5,
tickSeconds: 600,
lastTurnTime: new Date('0200-05-01T00:00:00.000Z'),
meta: { hiddenSeed: 'create-many-npc-fixture' },
};
const snapshot: TurnWorldSnapshot = {
scenarioConfig: {
stat: { total: 300, min: 10, max: 100, npcTotal: 150, npcMax: 50, npcMin: 10, chiefMin: 70 },
iconPath: '',
map: {},
const: {
defaultStatNPCTotal: 150,
defaultStatNPCMin: 10,
defaultStatNPCMax: 50,
retirementYear: 80,
randGenFirstName: ['가'],
randGenMiddleName: [''],
randGenLastName: ['가'],
availablePersonality: ['che_안전'],
},
environment: { mapName: 'test', unitSet: 'default' },
},
map: {
id: 'test',
name: 'test',
cities: [],
defaults: { trust: 50, trade: 100, supplyState: 1, frontState: 0 },
},
generals,
cities: Array.from({ length: cityCount }, (_, index) => buildCity(index + 1)),
nations: [],
troops: [],
diplomacy: [],
events: [],
initialEvents: [],
};
const world = new InMemoryTurnWorld(state, snapshot, {
schedule: { entries: [{ startMinute: 0, tickMinutes: 10 }] },
});
const prisma = {
generalTurn: { findMany: vi.fn(), deleteMany: vi.fn(), createMany: vi.fn() },
nationTurn: { findMany: vi.fn(), deleteMany: vi.fn(), createMany: vi.fn() },
};
const reservedTurns = new InMemoryReservedTurnStore(prisma as never, {
maxGeneralTurns: 30,
maxNationTurns: 12,
});
const commandEnv = buildCommandEnv(snapshot.scenarioConfig);
const handler = createCreateManyNpcHandler({
getWorld: () => world,
reservedTurns,
env: commandEnv,
});
const environment = {
year: 200,
month: 5,
startyear: 190,
currentEventID: 1,
turnTime: new Date('0200-05-01T00:00:00.000Z'),
};
return { world, reservedTurns, handler, environment, commandEnv };
};
describe('CreateManyNPC monthly action', () => {
it('creates the legacy random-name NPC state and initializes all 30 reserved turns', async () => {
const { world, reservedTurns, handler, environment } = buildHarness([buildGeneral(1)]);
await handler([1, 0], environment, {
id: 1,
targetCode: 'month',
priority: 1,
condition: true,
action: [],
meta: {},
});
const created = world.peekDirtyState().createdGenerals[0]!;
expect({
id: created.id,
name: created.name,
cityId: created.cityId,
stats: created.stats,
experience: created.experience,
dedication: created.dedication,
age: created.age,
bornYear: created.bornYear,
deadYear: created.deadYear,
affinity: created.affinity,
personality: created.role.personality,
turnTime: created.turnTime.toISOString(),
meta: created.meta,
}).toMatchInlineSnapshot(`
{
"affinity": 94,
"age": 24,
"bornYear": 176,
"cityId": 2,
"deadYear": 226,
"dedication": 2400,
"experience": 2400,
"id": 2,
"meta": {
"belong": 0,
"dedlevel": 1,
"dex1": 0,
"dex2": 0,
"dex3": 0,
"dex4": 0,
"dex5": 0,
"killturn": 323,
"npcType": 3,
"npc_org": 3,
"specage": 27,
"specage2": 28,
},
"name": "ⓜ가가2",
"personality": "che_안전",
"stats": {
"intelligence": 47,
"leadership": 11,
"strength": 92,
},
"turnTime": "0200-05-01T00:05:45.821Z",
}
`);
expect(reservedTurns.getGeneralTurns(created.id)).toHaveLength(30);
expect(reservedTurns.peekDirtyState()).toEqual({
generalIds: [],
generalInitializationIds: [created.id],
nationKeys: [],
nationInitializationKeys: [],
});
expect(world.peekDirtyState().logs).toMatchInlineSnapshot(`
[
{
"category": "ACTION",
"format": 4,
"month": 5,
"scope": "SYSTEM",
"text": "<Y>ⓜ가가2</>라는 장수가 <S>등장</>하였습니다.",
"year": 200,
},
{
"category": "HISTORY",
"format": 8,
"month": 5,
"scope": "SYSTEM",
"text": "장수 <C>1</>명이 <S>등장</>했습니다.",
"year": 200,
},
]
`);
});
it('uses the legacy fill count and does not reserve names created in the same batch', async () => {
const { world, handler, environment } = buildHarness([
buildGeneral(1),
buildGeneral(2, { name: '부장', officerLevel: 0 }),
]);
await handler([1, 5], environment, {
id: 1,
targetCode: 'month',
priority: 1,
condition: true,
action: [],
meta: {},
});
const created = world.peekDirtyState().createdGenerals;
expect(created).toHaveLength(4);
expect(created.map((general) => general.name)).toEqual(['ⓜ가가2', 'ⓜ가가2', 'ⓜ가가2', 'ⓜ가가2']);
});
it('returns without logs or RNG-visible state when both counts are non-positive', async () => {
const { world, reservedTurns, handler, environment } = buildHarness();
await handler([0, 0], environment, {
id: 1,
targetCode: 'month',
priority: 1,
condition: true,
action: [],
meta: {},
});
expect(world.peekDirtyState().createdGenerals).toEqual([]);
expect(world.peekDirtyState().logs).toEqual([]);
expect(reservedTurns.peekDirtyState().generalInitializationIds).toEqual([]);
});
it.skipIf(!process.env.REF_HIDDEN_SEED)('matches the fixed-seed legacy fixture including RNG order', async () => {
const { world, reservedTurns, handler, environment, commandEnv } = buildHarness([], 94);
world.updateWorldMeta({ hiddenSeed: process.env.REF_HIDDEN_SEED });
commandEnv.npcStatTotal = 150;
commandEnv.npcStatMin = 10;
commandEnv.npcStatMax = 75;
commandEnv.randomGeneralFirstNames = [...LEGACY_RANDOM_GENERAL_FIRST_NAMES];
commandEnv.randomGeneralMiddleNames = [''];
commandEnv.randomGeneralLastNames = [...LEGACY_RANDOM_GENERAL_LAST_NAMES];
commandEnv.availablePersonalities = [
'che_안전',
'che_유지',
'che_재간',
'che_출세',
'che_할거',
'che_정복',
'che_패권',
'che_의협',
'che_대의',
'che_왕좌',
];
await handler(
[2, 0],
{
...environment,
year: 193,
month: 5,
startyear: 190,
turnTime: new Date('0193-05-01T00:00:00.000Z'),
},
{
id: 1,
targetCode: 'month',
priority: 1,
condition: true,
action: [],
meta: {},
}
);
expect(
world.peekDirtyState().createdGenerals.map((general) => ({
name: general.name,
cityId: general.cityId,
stats: general.stats,
experience: general.experience,
dedication: general.dedication,
age: general.age,
bornYear: general.bornYear,
deadYear: general.deadYear,
affinity: general.affinity,
personality: general.role.personality,
turnTime: general.turnTime.toISOString(),
killturn: general.meta.killturn,
specage: general.meta.specage,
specage2: general.meta.specage2,
}))
).toEqual([
{
name: 'ⓜ심송',
cityId: 33,
stats: { leadership: 15, strength: 67, intelligence: 68 },
experience: 2_000,
dedication: 2_000,
age: 20,
bornYear: 173,
deadYear: 238,
affinity: 144,
personality: 'che_유지',
turnTime: '0193-05-01T00:08:28.195Z',
killturn: 551,
specage: 24,
specage2: 29,
},
{
name: 'ⓜ하후후',
cityId: 60,
stats: { leadership: 63, strength: 13, intelligence: 74 },
experience: 2_000,
dedication: 2_000,
age: 20,
bornYear: 173,
deadYear: 236,
affinity: 141,
personality: 'che_정복',
turnTime: '0193-05-01T00:08:21.776Z',
killturn: 528,
specage: 24,
specage2: 29,
},
]);
expect(reservedTurns.peekDirtyState().generalInitializationIds).toEqual([1, 2]);
});
});
app/game-engine/test/monthlyCreateManyNpcPersistence.integration.test.ts
+243
View File
@@ -0,0 +1,243 @@
import { afterAll, beforeAll, describe, expect, it } from 'vitest';
import { createGamePostgresConnector, type GamePrismaClient } from '@sammo-ts/infra';
import type { City } from '@sammo-ts/logic';
import { createDatabaseTurnHooks } from '../src/turn/databaseHooks.js';
import { InMemoryTurnWorld } from '../src/turn/inMemoryWorld.js';
import { createCreateManyNpcHandler } from '../src/turn/monthlyCreateManyNpcAction.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 cityId = 990_081;
const createdGeneralId = 990_081;
const city: City = {
id: cityId,
name: '다수NPC저장도시',
nationId: 0,
level: 4,
state: 0,
population: 10_000,
populationMax: 20_000,
agriculture: 1_000,
agricultureMax: 2_000,
commerce: 1_000,
commerceMax: 2_000,
security: 1_000,
securityMax: 2_000,
supplyState: 1,
frontState: 0,
defence: 1_000,
defenceMax: 2_000,
wall: 1_000,
wallMax: 2_000,
meta: {},
};
const event: TurnEvent = {
id: 1,
targetCode: 'month',
priority: 1_000,
condition: true,
action: [['CreateManyNPC', 1, 0]],
meta: {},
};
integration('CreateManyNPC database persistence', () => {
let db: GamePrismaClient;
let closeDb: (() => Promise<void>) | undefined;
const clean = async () => {
await db.logEntry.deleteMany({
where: {
OR: [
{ generalId: createdGeneralId },
{
text: '<C>●</>5월:<Y>ⓜ가가</>라는 장수가 <S>등장</>하였습니다.',
year: 193,
month: 5,
},
{
text: '<R>★</>193년 5월:장수 <C>1</>명이 <S>등장</>했습니다.',
year: 193,
month: 5,
},
],
},
});
await db.generalTurn.deleteMany({ where: { generalId: createdGeneralId } });
await db.rankData.deleteMany({ where: { generalId: createdGeneralId } });
await db.general.deleteMany({ where: { id: createdGeneralId } });
await db.city.deleteMany({ where: { id: cityId } });
};
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 general, 30 resting turns, zeroed canonical rank rows, and logs atomically', async () => {
await 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: {},
},
});
const stateRow = await db.worldState.create({
data: {
scenarioCode: 'monthly-create-many-npc-persistence',
currentYear: 193,
currentMonth: 5,
tickSeconds: 600,
config: {},
meta: { hiddenSeed: 'create-many-npc-persistence', lastGeneralId: createdGeneralId - 1 },
},
});
const state: TurnWorldState = {
id: stateRow.id,
currentYear: 193,
currentMonth: 5,
tickSeconds: 600,
lastTurnTime: new Date('0193-05-01T00:00:00.000Z'),
meta: { hiddenSeed: 'create-many-npc-persistence', lastGeneralId: createdGeneralId - 1 },
};
const snapshot: TurnWorldSnapshot = {
scenarioConfig: {
stat: { total: 165, min: 15, max: 80, npcTotal: 150, npcMax: 75, npcMin: 10, chiefMin: 65 },
iconPath: '',
map: {},
const: {
randGenFirstName: ['가'],
randGenMiddleName: [''],
randGenLastName: ['가'],
availablePersonality: ['che_안전'],
},
environment: { mapName: 'test', unitSet: 'default' },
},
map: {
id: 'test',
name: 'test',
cities: [],
defaults: { trust: 50, trade: 100, supplyState: 1, frontState: 0 },
},
generals: [],
cities: [city],
nations: [],
troops: [],
diplomacy: [],
events: [event],
initialEvents: [],
};
const world = new InMemoryTurnWorld(state, snapshot, {
schedule: { entries: [{ startMinute: 0, tickMinutes: 10 }] },
});
const reservedTurns = new InMemoryReservedTurnStore(db, { maxGeneralTurns: 30, maxNationTurns: 12 });
const handler = createCreateManyNpcHandler({
getWorld: () => world,
reservedTurns,
env: buildCommandEnv(snapshot.scenarioConfig),
});
const dbHooks = await createDatabaseTurnHooks(databaseUrl!, world, { reservedTurns });
try {
await handler(
[1, 0],
{
year: 193,
month: 5,
startyear: 190,
currentEventID: 1,
turnTime: state.lastTurnTime,
},
event
);
await dbHooks.hooks.flushChanges?.({
lastTurnTime: state.lastTurnTime.toISOString(),
processedGenerals: 0,
processedTurns: 1,
durationMs: 0,
partial: false,
});
expect(await db.general.findUniqueOrThrow({ where: { id: createdGeneralId } })).toMatchObject({
name: 'ⓜ가가',
nationId: 0,
cityId,
npcState: 3,
affinity: expect.any(Number),
bornYear: expect.any(Number),
deadYear: expect.any(Number),
picture: 'default.jpg',
experience: expect.any(Number),
dedication: expect.any(Number),
personalCode: 'che_안전',
});
const turns = await db.generalTurn.findMany({
where: { generalId: createdGeneralId },
orderBy: { turnIdx: 'asc' },
});
expect(turns).toHaveLength(30);
expect(new Set(turns.map((turn) => turn.actionCode))).toEqual(new Set(['휴식']));
const ranks = await db.rankData.findMany({ where: { generalId: createdGeneralId } });
// Legacy inserts 37 RankColumn rows. Core's canonical rank model
// additionally projects experience/dedication/dex, so it owns 41.
expect(ranks).toHaveLength(41);
expect(ranks.every((rank) => rank.nationId === 0 && rank.value === 0)).toBe(true);
expect(
await db.logEntry.findMany({
where: {
year: 193,
month: 5,
text: {
in: [
'<C>●</>5월:<Y>ⓜ가가</>라는 장수가 <S>등장</>하였습니다.',
'<R>★</>193년 5월:장수 <C>1</>명이 <S>등장</>했습니다.',
],
},
},
orderBy: { id: 'asc' },
})
).toEqual(
expect.arrayContaining([
expect.objectContaining({ category: 'ACTION', text: expect.stringContaining('장수가') }),
expect.objectContaining({ category: 'HISTORY', text: expect.stringContaining('장수 <C>1</>명') }),
])
);
} finally {
await dbHooks.close();
await db.worldState.delete({ where: { id: stateRow.id } });
}
});
});