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

feat: raise monthly NPC nations

Browse Source
This commit is contained in:
Hide_D
2026-07-25 18:56:34 +00:00
parent d0df2cdd00
commit a0f7493f1a
7 changed files with 1080 additions and 6 deletions
Download Patch File Download Diff File Expand all files Collapse all files
app/game-engine/test/monthlyRaiseNpcNationAction.test.ts
+314
View File
@@ -0,0 +1,314 @@
import { describe, expect, it, vi } from 'vitest';
import { PERSONALITY_TRAIT_KEYS, type City, type MapDefinition, type Nation } from '@sammo-ts/logic';
import { InMemoryTurnWorld } from '../src/turn/inMemoryWorld.js';
import { createRaiseNpcNationHandler } from '../src/turn/monthlyRaiseNpcNationAction.js';
import { InMemoryReservedTurnStore } from '../src/turn/reservedTurnStore.js';
import { buildCommandEnv } from '../src/turn/reservedTurnCommands.js';
import type { TurnEvent, TurnGeneral, TurnWorldSnapshot, TurnWorldState } from '../src/turn/types.js';
const buildCity = (id: number, nationId: number, level = 5): City => ({
id,
name: `도시${id}`,
nationId,
level,
state: 0,
population: 10_000 + id,
populationMax: 50_000 + id,
agriculture: 1_000 + id,
agricultureMax: 5_000 + id,
commerce: 2_000 + id,
commerceMax: 6_000 + id,
security: 3_000 + id,
securityMax: 7_000 + id,
supplyState: 1,
frontState: 0,
defence: 4_000 + id,
defenceMax: 8_000 + id,
wall: 5_000 + id,
wallMax: 9_000 + id,
meta: { trust: 50 },
});
const buildNation = (id: number): Nation => ({
id,
name: `국가${id}`,
color: '#777777',
capitalCityId: 1,
chiefGeneralId: 1,
gold: 1_000,
rice: 1_000,
power: 0,
level: 2,
typeCode: 'che_유가',
meta: { tech: 120 },
});
const buildGeneral = (): TurnGeneral => ({
id: 1,
userId: null,
name: '군주',
nationId: 1,
cityId: 1,
troopId: 0,
stats: { leadership: 50, strength: 50, intelligence: 50 },
experience: 0,
dedication: 0,
officerLevel: 12,
role: {
personality: 'che_안전',
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,
bornYear: 170,
deadYear: 250,
affinity: 1,
picture: 'default.jpg',
triggerState: { flags: {}, counters: {}, modifiers: {}, meta: {} },
lastTurn: { command: '휴식' },
turnTime: new Date('0200-01-01T00:00:00.000Z'),
recentWarTime: null,
meta: { killturn: 1_000 },
});
const map: MapDefinition = {
id: 'test',
name: 'test',
cities: [1, 2, 3, 4, 5].map((id) => ({
id,
name: `도시${id}`,
level: id === 3 ? 4 : 5,
region: 1,
position: { x: id, y: 0 },
connections: [id - 1, id + 1].filter((target) => target >= 1 && target <= 5),
max: {
population: 50_000 + id,
agriculture: 5_000 + id,
commerce: 6_000 + id,
security: 7_000 + id,
defence: 8_000 + id,
wall: 9_000 + id,
},
initial: {
population: 10_000 + id,
agriculture: 1_000 + id,
commerce: 2_000 + id,
security: 3_000 + id,
defence: 4_000 + id,
wall: 5_000 + id,
},
})),
};
const event: TurnEvent = {
id: 1,
targetCode: 'month',
priority: 1_000,
condition: true,
action: [['RaiseNPCNation']],
meta: {},
};
const buildHarness = (archivedNationMaxId = 0, hiddenSeed = 'raise-npc-nation-fixture') => {
const state: TurnWorldState = {
id: 1,
currentYear: 200,
currentMonth: 1,
tickSeconds: 600,
lastTurnTime: new Date('0200-01-01T00:00:00.000Z'),
meta: { hiddenSeed, serverId: 'fixture-server' },
};
const snapshot: TurnWorldSnapshot = {
scenarioConfig: {
stat: { total: 300, min: 10, max: 100, npcTotal: 150, npcMax: 75, npcMin: 10, chiefMin: 70 },
iconPath: '.',
map: {},
const: {
retirementYear: 80,
availablePersonality: ['che_안전'],
randGenFirstName: ['가'],
randGenMiddleName: [''],
randGenLastName: ['나'],
},
environment: { mapName: 'test', unitSet: 'default' },
},
map,
generals: [buildGeneral()],
cities: [
buildCity(1, 1),
buildCity(2, 0),
buildCity(3, 0, 4),
buildCity(4, 0),
buildCity(5, 0, 4),
],
nations: [buildNation(1)],
troops: [],
diplomacy: [],
events: [event],
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 = createRaiseNpcNationHandler({
getWorld: () => world,
reservedTurns,
env: commandEnv,
map,
loadArchivedNationMaxId: vi.fn().mockResolvedValue(archivedNationMaxId),
});
return {
world,
reservedTurns,
commandEnv,
handler,
environment: {
year: 200,
month: 1,
startyear: 190,
currentEventID: 1,
turnTime: state.lastTurnTime,
},
};
};
describe('RaiseNPCNation monthly action', () => {
it('creates only distance-qualified NPC nations and initializes their ruler and turns', async () => {
const { world, reservedTurns, handler, environment } = buildHarness();
await handler([], environment, event);
const dirty = world.peekDirtyState();
expect(dirty.createdNations).toHaveLength(1);
expect(dirty.createdGenerals).toHaveLength(1);
expect(dirty.createdNations[0]).toMatchInlineSnapshot(`
{
"capitalCityId": 4,
"chiefGeneralId": 2,
"color": "#2E8B57",
"gold": 0,
"id": 2,
"level": 2,
"meta": {
"bill": 100,
"can_국기변경": 1,
"gennum": 1,
"infoText": "우리도 할 수 있다! 도시4군",
"rate": 15,
"scout": 0,
"strategicCommandLimit": 24,
"surrenderLimit": 72,
"tech": 120,
"war": 0,
},
"name": "ⓤ도시4",
"power": 0,
"rice": 2000,
"typeCode": "che_오두미도",
}
`);
expect(dirty.createdGenerals[0]).toMatchObject({
id: 2,
name: 'ⓤ도시4태수',
nationId: 2,
cityId: 4,
officerLevel: 12,
age: 20,
npcState: 6,
bornYear: 180,
deadYear: 260,
meta: { killturn: 240, npc_org: 6 },
});
expect(world.getCityById(2)?.nationId).toBe(0);
expect(world.getCityById(4)).toMatchObject({
nationId: 2,
population: 10_001,
agriculture: 1_001,
commerce: 2_001,
security: 3_001,
defence: 4_001,
wall: 5_001,
meta: { trust: 100 },
});
expect(world.getCityById(5)?.nationId).toBe(0);
expect(reservedTurns.getGeneralTurns(2)).toHaveLength(30);
expect(reservedTurns.peekDirtyState().nationInitializationKeys).toEqual([
'2:12',
'2:11',
'2:10',
'2:9',
]);
expect(dirty.logs).toEqual([
expect.objectContaining({
category: 'HISTORY',
text: '<L><b>【공지】</b></>공백지에 임의의 국가가 생성되었습니다.',
}),
]);
});
it('starts after the archived nation id for the same server', async () => {
const { world, handler, environment } = buildHarness(9);
await handler([], environment, event);
expect(world.peekDirtyState().createdNations[0]?.id).toBe(10);
});
it.skipIf(!process.env.REF_HIDDEN_SEED)('matches the fixed-seed legacy nation and ruler fields', async () => {
const { world, handler, commandEnv, environment } = buildHarness(99, process.env.REF_HIDDEN_SEED);
commandEnv.availablePersonalities = [...PERSONALITY_TRAIT_KEYS];
await handler([], environment, event);
const nation = world.peekDirtyState().createdNations[0]!;
const ruler = world.peekDirtyState().createdGenerals[0]!;
expect({
id: nation.id,
color: nation.color,
typeCode: nation.typeCode,
tech: nation.meta.tech,
ruler: {
stats: ruler.stats,
affinity: ruler.affinity,
personality: ruler.role.personality,
turnTime: ruler.turnTime.toISOString(),
killturn: ruler.meta.killturn,
specAge: ruler.meta.specage,
specAge2: ruler.meta.specage2,
},
}).toEqual({
id: 100,
color: '#FFA500',
typeCode: 'che_음양가',
tech: 120,
ruler: {
stats: { leadership: 70, strength: 65, intelligence: 15 },
affinity: 141,
personality: 'che_패권',
turnTime: '0200-01-01T00:08:56.503Z',
killturn: 240,
specAge: 23,
specAge2: 25,
},
});
});
});
app/game-engine/test/monthlyRaiseNpcNationPersistence.integration.test.ts
+315
View File
@@ -0,0 +1,315 @@
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 { createRaiseNpcNationHandler } from '../src/turn/monthlyRaiseNpcNationAction.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 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']],
meta: {},
};
integration('RaiseNPCNation database persistence', () => {
let db: GamePrismaClient;
let closeDb: (() => Promise<void>) | undefined;
const clean = async () => {
await db.logEntry.deleteMany({
where: {
OR: [
{ generalId: createdGeneralId },
{ year: 200, month: 1, text: { contains: '공백지에 임의의 국가' } },
],
},
});
await db.generalTurn.deleteMany({ where: { generalId: createdGeneralId } });
await db.rankData.deleteMany({ where: { generalId: createdGeneralId } });
await db.general.deleteMany({ where: { id: createdGeneralId } });
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 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: 200,
currentMonth: 1,
tickSeconds: 600,
config: {},
meta: {
hiddenSeed: 'raise-npc-nation-persistence',
lastGeneralId: createdGeneralId - 1,
lastNationId: createdNationId - 1,
serverId: 'raise-npc-nation-persistence',
},
},
});
const state: TurnWorldState = {
id: stateRow.id,
currentYear: 200,
currentMonth: 1,
tickSeconds: 600,
lastTurnTime: new Date('0200-01-01T00:00:00.000Z'),
meta: {
hiddenSeed: 'raise-npc-nation-persistence',
lastGeneralId: createdGeneralId - 1,
lastNationId: createdNationId - 1,
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 world = new InMemoryTurnWorld(state, snapshot, {
schedule: { entries: [{ startMinute: 0, tickMinutes: 10 }] },
});
const reservedTurns = new InMemoryReservedTurnStore(db, { maxGeneralTurns: 30, maxNationTurns: 12 });
const handler = createRaiseNpcNationHandler({
getWorld: () => world,
reservedTurns,
env: buildCommandEnv(snapshot.scenarioConfig),
map,
loadArchivedNationMaxId: async () => 0,
});
const dbHooks = await createDatabaseTurnHooks(databaseUrl!, world, { reservedTurns });
try {
await handler(
[],
{
year: 200,
month: 1,
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.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(41);
expect(
await db.diplomacy.count({
where: {
OR: [{ srcNationId: createdNationId }, { destNationId: createdNationId }],
},
})
).toBe(2);
expect(
await db.logEntry.findFirst({
where: { year: 200, month: 1, text: { contains: '공백지에 임의의 국가' } },
})
).not.toBeNull();
} finally {
await dbHooks.close();
await db.worldState.delete({ where: { id: stateRow.id } });
}
});
});