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/src/turn/databaseHooks.ts
+19 -3
View File
@@ -153,6 +153,11 @@ const buildRankRows = (
}));
};
const buildInitialRankRows = (
general: ReturnType<InMemoryTurnWorld['consumeDirtyState']>['generals'][number]
): Array<{ generalId: number; nationId: number; type: string; value: number }> =>
buildRankRows(general).map((row) => ({ ...row, nationId: 0, value: 0 }));
const buildGeneralUpdate = (
general: ReturnType<InMemoryTurnWorld['consumeDirtyState']>['generals'][number]
): TurnEngineGeneralUpdateInput => ({
@@ -175,6 +180,10 @@ const buildGeneralUpdate = (
train: toLegacyDatabaseInt(general.train),
atmos: toLegacyDatabaseInt(general.atmos),
age: general.age,
affinity: general.affinity ?? null,
bornYear: general.bornYear,
deadYear: general.deadYear,
picture: general.picture ?? null,
npcState: general.npcState,
horseCode: toCode(general.role.items.horse),
weaponCode: toCode(general.role.items.weapon),
@@ -212,6 +221,10 @@ const buildGeneralCreate = (
train: toLegacyDatabaseInt(general.train),
atmos: toLegacyDatabaseInt(general.atmos),
age: general.age,
affinity: general.affinity ?? null,
bornYear: general.bornYear,
deadYear: general.deadYear,
picture: general.picture ?? null,
horseCode: toCode(general.role.items.horse),
weaponCode: toCode(general.role.items.weapon),
bookCode: toCode(general.role.items.book),
@@ -662,9 +675,12 @@ export const createDatabaseTurnHooks = async (
),
]);
const rankTargets = [...createdGenerals, ...generals];
if (rankTargets.length > 0) {
const rankRows = rankTargets.flatMap(buildRankRows);
const rankTargets = generals.filter((general) => !createdIds.has(general.id));
if (createdGenerals.length > 0 || rankTargets.length > 0) {
const rankRows = [
...createdGenerals.flatMap(buildInitialRankRows),
...rankTargets.flatMap(buildRankRows),
];
await Promise.all(
rankRows.map((row) =>
prisma.rankData.upsert({
app/game-engine/src/turn/inMemoryWorld.ts
+13
View File
@@ -454,6 +454,19 @@ export class InMemoryTurnWorld {
return next;
}
addGeneral(general: TurnGeneral): boolean {
if (this.generals.has(general.id)) {
return false;
}
const worldKillturn = resolveWorldKillturn(this.state.meta);
const normalized = normalizeGeneralTurnTime({ ...general }, this.state.lastTurnTime);
const ensured = ensureGeneralKillturn(normalized, worldKillturn);
this.generals.set(general.id, ensured);
this.dirtyGeneralIds.add(general.id);
this.createdGeneralIds.add(general.id);
return true;
}
removeGeneral(id: number): boolean {
if (!this.generals.has(id)) {
return false;
app/game-engine/src/turn/monthlyCreateManyNpcAction.ts
+271
View File
@@ -0,0 +1,271 @@
import { JosaUtil, LiteHashDRBG, RandUtil, asRecord } from '@sammo-ts/common';
import { LogCategory, LogFormat, LogScope, type TurnCommandEnv } from '@sammo-ts/logic';
import { simpleSerialize } from '@sammo-ts/logic/war/utils.js';
import type { InMemoryTurnWorld } from './inMemoryWorld.js';
import type { MonthlyEventActionHandler, MonthlyEventEnvironment } from './monthlyEventHandler.js';
import type { InMemoryReservedTurnStore } from './reservedTurnStore.js';
import type { TurnGeneral } from './types.js';
const NPC_TYPE = 3;
const NPC_NAME_PREFIX = 'ⓜ';
const LEGACY_GENERAL_NAME_PREFIXES = ['', 'ⓝ', 'ⓝ', 'ⓜ', 'ⓖ', '㉥', 'ⓤ', 'ⓞ'];
const STAT_TYPE_WEIGHTS = { 무: 0.333, 지: 0.333, 무지: 0.334 } as const;
const readLegacyNumber = (value: unknown, fallback: number): number => {
if (typeof value === 'number' && Number.isFinite(value)) {
return value;
}
if (typeof value === 'string' && value.trim() !== '') {
const parsed = Number(value);
if (Number.isFinite(parsed)) {
return parsed;
}
}
return fallback;
};
const resolveHiddenSeed = (world: InMemoryTurnWorld): string | number => {
const state = world.getState();
const value = state.meta.hiddenSeed ?? state.meta.seed ?? state.id;
return typeof value === 'string' || typeof value === 'number' ? value : String(value);
};
const countLegacyNameDuplicates = (generals: readonly TurnGeneral[], baseName: string): number => {
let count = 0;
for (const prefix of LEGACY_GENERAL_NAME_PREFIXES) {
const target = `${prefix}${baseName}`;
count += generals.filter((general) => general.name.startsWith(target)).length;
}
return count;
};
const pickNames = (
rng: RandUtil,
count: number,
existingGenerals: readonly TurnGeneral[],
env: TurnCommandEnv
): string[] => {
const firstNames = env.randomGeneralFirstNames ?? ['가'];
const middleNames = env.randomGeneralMiddleNames ?? [''];
const lastNames = env.randomGeneralLastNames ?? ['가'];
const names: string[] = [];
for (let index = 0; index < count; index += 1) {
let loopCount = 0;
while (true) {
let name = `${rng.choice(firstNames)}${rng.choice(middleNames)}${rng.choice(lastNames)}`;
const duplicateCount = countLegacyNameDuplicates(existingGenerals, name);
if (duplicateCount === 0) {
names.push(name);
break;
}
if (loopCount >= 99 || duplicateCount < 2) {
name += duplicateCount + 1;
names.push(name);
break;
}
loopCount += 1;
}
}
return names;
};
const buildStats = (rng: RandUtil, env: TurnCommandEnv): TurnGeneral['stats'] => {
const totalStat = env.npcStatTotal ?? 150;
const minStat = env.npcStatMin ?? 10;
const maxStat = env.npcStatMax ?? 50;
const pickType = rng.choiceUsingWeight(STAT_TYPE_WEIGHTS);
let mainStat = maxStat - rng.nextRangeInt(0, minStat);
let otherStat = minStat + rng.nextRangeInt(0, Math.trunc(minStat / 2));
let subStat = totalStat - mainStat - otherStat;
if (subStat < minStat) {
subStat = otherStat;
otherStat = minStat;
mainStat = totalStat - subStat - otherStat;
// GeneralBuilder::fillRandomStat()의 기존 truthy 검사까지 보존한다.
if (mainStat !== 0) {
throw new Error('기본 스탯 설정값이 잘못되어 있음');
}
}
if (pickType === '무') {
return { leadership: subStat, strength: mainStat, intelligence: otherStat };
}
if (pickType === '지') {
return { leadership: subStat, strength: otherStat, intelligence: mainStat };
}
return { leadership: otherStat, strength: subStat, intelligence: mainStat };
};
const buildSpecialityAge = (retirementYear: number, age: number, relativeYear: number, divisor: number): number =>
Math.max(Math.round((retirementYear - age) / divisor - relativeYear / 2), 3) + age;
const buildNpc = (options: {
world: InMemoryTurnWorld;
reservedTurns: InMemoryReservedTurnStore;
rng: RandUtil;
environment: MonthlyEventEnvironment;
env: TurnCommandEnv;
baseName: string;
}): TurnGeneral => {
const { world, reservedTurns, rng, environment, env } = options;
const age = rng.nextRangeInt(20, 25);
const bornYear = environment.year - age;
const deadYear = environment.year + rng.nextRangeInt(10, 50);
const stats = buildStats(rng, env);
const affinity = rng.nextRangeInt(1, 150);
const relativeYear = Math.max(environment.year - environment.startyear, 0);
const configValues = asRecord(world.getScenarioConfig().const);
const retirementYear = readLegacyNumber(configValues.retirementYear, 80);
const specAge = buildSpecialityAge(retirementYear, age, relativeYear, 12);
const specAge2 = buildSpecialityAge(retirementYear, age, relativeYear, 6);
const personality = rng.choice(env.availablePersonalities ?? ['che_안전']);
const cities = world.listCities();
if (cities.length === 0) {
throw new Error('CreateManyNPC requires at least one city.');
}
const city = rng.choice(cities);
const turnMinutes = world.getState().tickSeconds / 60;
if (!(turnMinutes > 0)) {
throw new Error('CreateManyNPC requires a positive turn term.');
}
const turnSecond = rng.nextRangeInt(0, 60 * turnMinutes - 1);
const turnFraction = rng.nextRangeInt(0, 999_999);
// core DB는 millisecond precision이므로 레거시 microsecond 값을 내림해
// 저장한다. 먼 과거 연도에서 IEEE-754 덧셈이 반올림하지 않도록 먼저
// 정수화한다.
const turnTime = new Date(environment.turnTime.getTime() + turnSecond * 1_000 + Math.floor(turnFraction / 1_000));
const killturn = (deadYear - environment.year) * 12 + rng.nextRangeInt(0, 11) + environment.month - 1;
const id = world.getNextGeneralId();
const general: TurnGeneral = {
id,
userId: null,
name: `${NPC_NAME_PREFIX}${options.baseName}`,
nationId: 0,
cityId: city.id,
troopId: 0,
stats,
experience: age * 100,
dedication: age * 100,
officerLevel: 0,
role: {
personality,
specialDomestic: env.defaultSpecialDomestic,
specialWar: env.defaultSpecialWar,
items: { horse: null, weapon: null, book: null, item: null },
},
injury: 0,
gold: 1_000,
rice: 1_000,
crew: 0,
crewTypeId: env.defaultCrewTypeId,
train: 0,
atmos: 0,
age,
npcState: NPC_TYPE,
bornYear,
deadYear,
affinity,
picture: 'default.jpg',
triggerState: {
flags: {},
counters: {},
modifiers: {},
meta: {},
},
lastTurn: { command: '휴식' },
turnTime,
recentWarTime: null,
meta: {
killturn,
npcType: NPC_TYPE,
npc_org: NPC_TYPE,
belong: 0,
dedlevel: 1,
specage: specAge,
specage2: specAge2,
dex1: 0,
dex2: 0,
dex3: 0,
dex4: 0,
dex5: 0,
},
};
if (!world.addGeneral(general)) {
throw new Error(`CreateManyNPC generated a duplicate general id: ${id}`);
}
reservedTurns.ensureGeneralTurns(id);
return general;
};
export const createCreateManyNpcHandler = (options: {
getWorld: () => InMemoryTurnWorld | null;
reservedTurns: InMemoryReservedTurnStore;
env: TurnCommandEnv;
}): MonthlyEventActionHandler => {
return (args, environment) => {
const world = options.getWorld();
if (!world) {
return;
}
const npcCount = readLegacyNumber(args[0], 10);
const fillCount = readLegacyNumber(args[1], 0);
if (npcCount <= 0 && fillCount <= 0) {
return;
}
let moreGeneralCount = 0;
if (fillCount !== 0) {
const chiefs = world
.listGenerals()
.filter((general) => general.npcState < 3 && general.officerLevel === 12);
const chiefNationIds = new Set(chiefs.map((general) => general.nationId));
const registeredGeneralCount = world
.listGenerals()
.filter((general) => chiefNationIds.has(general.nationId) && general.npcState < 4).length;
moreGeneralCount = chiefs.length * fillCount - registeredGeneralCount;
}
const requestedCount = npcCount + moreGeneralCount;
const rng = new RandUtil(
new LiteHashDRBG(
simpleSerialize(resolveHiddenSeed(world), 'CreateManyNPC', environment.year, environment.month)
)
);
const baseNames = pickNames(rng, requestedCount, world.listGenerals(), options.env);
const created = baseNames.map((baseName) =>
buildNpc({
world,
reservedTurns: options.reservedTurns,
rng,
environment,
env: options.env,
baseName,
})
);
const count = created.length;
const actionText =
count === 1
? `<Y>${created[0]!.name}</>${JosaUtil.pick(created[0]!.name, '라')}는 장수가 <S>등장</>하였습니다.`
: `장수 <C>${count}</>명이 <S>등장</>하였습니다.`;
world.pushLog({
scope: LogScope.SYSTEM,
category: LogCategory.ACTION,
text: actionText,
format: LogFormat.MONTH,
year: environment.year,
month: environment.month,
});
world.pushLog({
scope: LogScope.SYSTEM,
category: LogCategory.HISTORY,
text: `장수 <C>${count}</>명이 <S>등장</>했습니다.`,
format: LogFormat.NOTICE_YEAR_MONTH,
year: environment.year,
month: environment.month,
});
};
};
app/game-engine/src/turn/reservedTurnStore.ts
+27
View File
@@ -74,6 +74,7 @@ type ReservedTurnDatabaseClient = Pick<TurnEngineDatabaseClient, 'generalTurn' |
export interface ReservedTurnChanges {
generalIds: number[];
generalInitializationIds: number[];
nationKeys: string[];
nationInitializationKeys: string[];
}
@@ -83,6 +84,7 @@ export class InMemoryReservedTurnStore {
private readonly nationTurns = new Map<string, ReservedTurnEntry[]>();
private readonly dirtyGeneralIds = new Set<number>();
private readonly dirtyNationKeys = new Set<string>();
private readonly pendingGeneralInitializationIds = new Set<number>();
private readonly pendingNationInitializationKeys = new Set<string>();
private readonly maxGeneralTurns: number;
private readonly maxNationTurns: number;
@@ -207,6 +209,11 @@ export class InMemoryReservedTurnStore {
return list[turnIdx] ?? createDefaultEntry();
}
ensureGeneralTurns(generalId: number): void {
this.getGeneralTurns(generalId);
this.pendingGeneralInitializationIds.add(generalId);
}
ensureNationTurns(nationId: number, officerLevel: number): void {
const key = buildNationKey(nationId, officerLevel);
this.getNationTurns(nationId, officerLevel);
@@ -229,6 +236,7 @@ export class InMemoryReservedTurnStore {
peekDirtyState(): ReservedTurnChanges {
return {
generalIds: Array.from(this.dirtyGeneralIds),
generalInitializationIds: Array.from(this.pendingGeneralInitializationIds),
nationKeys: Array.from(this.dirtyNationKeys),
nationInitializationKeys: Array.from(this.pendingNationInitializationKeys),
};
@@ -238,6 +246,9 @@ export class InMemoryReservedTurnStore {
for (const generalId of changes.generalIds) {
this.dirtyGeneralIds.delete(generalId);
}
for (const generalId of changes.generalInitializationIds) {
this.pendingGeneralInitializationIds.delete(generalId);
}
for (const key of changes.nationKeys) {
this.dirtyNationKeys.delete(key);
}
@@ -260,6 +271,22 @@ export class InMemoryReservedTurnStore {
});
}
for (const generalId of changes.generalInitializationIds) {
if (changes.generalIds.includes(generalId)) {
continue;
}
const turns = this.getGeneralTurns(generalId);
await prisma.generalTurn.createMany({
data: turns.map((entry, turnIdx) => ({
generalId,
turnIdx,
actionCode: normalizeAction(entry.action),
arg: asJson(normalizeArgs(entry.args)),
})),
skipDuplicates: true,
});
}
for (const key of changes.nationKeys) {
const [nationIdRaw, officerLevelRaw] = key.split(':');
const nationId = Number(nationIdRaw);
app/game-engine/src/turn/turnDaemon.ts
+13 -1
View File
@@ -51,6 +51,8 @@ import { createUpdateNationLevelHandler } from './monthlyNationLevelAction.js';
import { createProcessSemiAnnualHandler } from './monthlySemiAnnualAction.js';
import { createProcessWarIncomeHandler } from './monthlyWarIncomeAction.js';
import { createCreateAdminNpcHandler } from './monthlyCreateAdminNpcAction.js';
import { createCreateManyNpcHandler } from './monthlyCreateManyNpcAction.js';
import { buildCommandEnv } from './reservedTurnCommands.js';
import { DatabaseTurnDaemonLease, TurnDaemonLeaseUnavailableError } from '../lifecycle/databaseTurnDaemonLease.js';
export interface TurnDaemonRuntimeOptions {
@@ -153,8 +155,9 @@ const createTurnDaemonRuntimeWithLease = async (
Array.isArray(event.action) &&
event.action.some((action) => Array.isArray(action) && action[0] === name)
);
const eventRequiresReservedTurns = hasEventAction('UpdateNationLevel') || hasEventAction('CreateManyNPC');
const reservedTurnStoreHandle =
options.generalTurnHandler && !hasEventAction('UpdateNationLevel')
options.generalTurnHandler && !eventRequiresReservedTurns
? null
: await createReservedTurnStore({
databaseUrl: options.databaseUrl,
@@ -171,6 +174,7 @@ const createTurnDaemonRuntimeWithLease = async (
const nationTraits = await loadNationTraitModules([...NATION_TRAIT_KEYS], new NationTraitLoader());
const nationTraitMap = new Map(nationTraits.map((module) => [module.key, module]));
const monthlyActionModules = await loadActionModuleBundle(snapshot.unitSet);
const monthlyCommandEnv = buildCommandEnv(snapshot.scenarioConfig, snapshot.unitSet);
const unification = options.calendarHandler
? null
: createUnificationHandler({
@@ -220,6 +224,14 @@ const createTurnDaemonRuntimeWithLease = async (
);
eventActions.set('CreateAdminNPC', createCreateAdminNpcHandler());
if (reservedTurnStoreHandle) {
eventActions.set(
'CreateManyNPC',
createCreateManyNpcHandler({
getWorld: () => worldRef,
reservedTurns: reservedTurnStoreHandle.store,
env: monthlyCommandEnv,
})
);
eventActions.set(
'UpdateNationLevel',
createUpdateNationLevelHandler({
app/game-engine/src/turn/types.ts
+1
View File
@@ -25,6 +25,7 @@ export interface TurnGeneral extends General {
bornYear?: number;
deadYear?: number;
affinity?: number | null;
picture?: string | null;
turnTime: Date;
recentWarTime?: Date | null;
lastTurn?: GeneralLastTurn;
app/game-engine/src/turn/worldLoader.ts
+1
View File
@@ -204,6 +204,7 @@ const mapGeneralRow = (row: TurnEngineGeneralRow): TurnGeneral => {
bornYear: row.bornYear,
deadYear: row.deadYear,
affinity: row.affinity,
picture: row.picture,
triggerState: {
flags: {},
counters: {},