feat: 실행 중 게임 옵션 변경을 지원

Gateway 관리 화면에서 현재 기수의 장수 생성 제한, 유저 자동턴, 턴 간격을 내구성 action으로 변경한다. 턴 간격 변경은 논리 tick과 현재 게임 시각을 보존하며 DB와 Redis의 tick 기반 시각을 재투영하고 기존 로그 timestamp는 유지한다.
2026-08-17 16:05:07 +00:00
parent 50e7d894e4
commit ca6823d409
26 changed files with 1680 additions and 115 deletions
@@ -127,6 +127,7 @@ describe('durable read-model change journal mapping', () => {
        const world = {
            getState: () => ({ ...state, meta: { ...state.meta } }),
            getScenarioConfig: () => config,
+            getWorldConfig: () => config,
        } as unknown as InMemoryTurnWorld;
        const baseline = createWorldReadModelSignature(world);

@@ -3,6 +3,8 @@ import { describe, expect, it, vi } from 'vitest';
 import type { GamePrismaClient } from '@sammo-ts/infra';
 import { InMemoryTurnWorld } from '../src/turn/inMemoryWorld.js';
 import { applyRuntimeClockShift } from '../src/turn/runtimeClockShift.js';
+import { applyRuntimeGameSettings } from '../src/turn/runtimeGameSettings.js';
+import { createTurnDaemonCommandHandler } from '../src/turn/worldCommandHandler.js';
 import type { TurnGeneral, TurnWorldSnapshot, TurnWorldState } from '../src/turn/types.js';

 const buildGeneral = (id: number, turnTime: string): TurnGeneral =>
@@ -160,6 +162,107 @@ describe('runtime clock shift', () => {
    });
 });

+describe('runtime turn term change', () => {
+    it('preserves the current game display while reprojecting tick-owned dates', () => {
+        const wallAnchor = new Date('2026-07-30T10:00:00.000Z');
+        const changedAt = new Date('2026-07-30T10:05:00.000Z');
+        const world = buildWorld({
+            clockBaseTime: wallAnchor,
+            clockTick: 0,
+            clockMode: 'realtime',
+            clockWallAnchor: wallAnchor,
+            lastTurnTick: 0,
+        });
+        world.setCheckpoint({
+            turnTime: '2026-07-30T10:10:00.000Z',
+            turnTick: 36_000_000,
+            generalId: 1,
+            year: 190,
+            month: 1,
+        });
+
+        const before = world.getGameNow(changedAt);
+        const result = world.changeTurnTerm(20, changedAt);
+
+        expect(result).toMatchObject({
+            changed: true,
+            previousTurnTermMinutes: 10,
+            turnTermMinutes: 20,
+            previousClockBaseTime: '2026-07-30T10:00:00.000Z',
+            clockBaseTime: '2026-07-30T09:55:00.000Z',
+            lastTurnTime: '2026-07-30T09:55:00.000Z',
+            shiftedGenerals: 2,
+        });
+        expect(world.getGameNow(changedAt)).toEqual(before);
+        expect(world.getGeneralById(1)?.turnTime.toISOString()).toBe('2026-07-30T10:15:00.000Z');
+        expect(world.getGeneralById(1)?.turnTick).toBe(36_000_000);
+        expect(world.getCheckpoint()?.turnTime).toBe('2026-07-30T10:15:00.000Z');
+        expect(world.getState()).toMatchObject({
+            tickSeconds: 1200,
+            clockTick: 18_000_000,
+            lastTurnTick: 0,
+        });
+        expect(world.getWorldConfig()).toMatchObject({ turnTermMinutes: 20 });
+    });
+
+    it('updates all three live settings and only emits a new history log', async () => {
+        const changedAt = new Date('2026-07-30T10:05:00.000Z');
+        const world = buildWorld({
+            clockBaseTime: new Date('2026-07-30T10:00:00.000Z'),
+            clockTick: 0,
+            clockMode: 'realtime',
+            clockWallAnchor: new Date('2026-07-30T10:00:00.000Z'),
+            lastTurnTick: 0,
+        });
+        const executeRaw = vi.fn(async () => 1);
+        const db = {
+            inputEvent: {
+                findUnique: vi.fn(async () => ({
+                    createdAt: changedAt,
+                    target: 'ENGINE',
+                    eventType: 'updateRuntimeSettings',
+                })),
+            },
+            $executeRaw: executeRaw,
+        } as unknown as GamePrismaClient;
+        const handler = createTurnDaemonCommandHandler({ world });
+
+        const result = await handler.handle(
+            {
+                type: 'updateRuntimeSettings',
+                requestId: 'runtime-settings:test',
+                actionId: 'action-test',
+                settings: {
+                    turnTermMinutes: 20,
+                    blockGeneralCreate: 2,
+                    autorunUser: { limitMinutes: 720, options: ['develop', 'recruit_high', 'chief'] },
+                },
+            },
+            { db }
+        );
+
+        expect(result).toMatchObject({
+            type: 'updateRuntimeSettings',
+            ok: true,
+            termChanged: true,
+            reprojectedAuctions: 1,
+            reprojectedMessages: 1,
+            reprojectedVotes: 1,
+        });
+        expect(executeRaw).toHaveBeenCalledTimes(3);
+        expect(world.getWorldConfig()).toMatchObject({ turnTermMinutes: 20, blockGeneralCreate: 2 });
+        expect(world.getState().meta).toMatchObject({
+            autorun_user: {
+                limit_minutes: 720,
+                options: { develop: true, recruit_high: true, chief: true },
+            },
+        });
+        expect(world.peekDirtyState().logs).toEqual([
+            expect.objectContaining({ text: '<R>★</>턴시간이 <C>20분</>으로 변경됩니다.' }),
+        ]);
+    });
+});
+
 describe('runtime clock shift projection', () => {
    it('waits for the durable engine event and applies Redis projections idempotently', async () => {
        const actionId = '68f1f0e4-3b95-4aeb-9925-c7e93caf1ba7';
@@ -285,3 +388,126 @@ describe('runtime clock shift projection', () => {
        expect(inputEventCreate).toHaveBeenCalledTimes(3);
    });
 });
+
+describe('runtime game settings projection', () => {
+    it('waits for the engine result and reprojects tournament tick dates idempotently', async () => {
+        const actionId = '98f1f0e4-3b95-4aeb-9925-c7e93caf1ba7';
+        let eventStatus: 'PENDING' | 'SUCCEEDED' = 'PENDING';
+        let created = false;
+        const db = {
+            inputEvent: {
+                create: vi.fn(async () => {
+                    if (created) throw { code: 'P2002' };
+                    created = true;
+                    return {};
+                }),
+                findUniqueOrThrow: vi.fn(async () =>
+                    eventStatus === 'PENDING'
+                        ? {
+                              eventType: 'updateRuntimeSettings',
+                              payload: {
+                                  type: 'updateRuntimeSettings',
+                                  actionId,
+                                  settings: {
+                                      turnTermMinutes: 20,
+                                      blockGeneralCreate: 2,
+                                      autorunUser: { limitMinutes: 720, options: ['develop', 'chief'] },
+                                  },
+                              },
+                              status: 'PENDING',
+                              result: null,
+                              error: null,
+                          }
+                        : {
+                              eventType: 'updateRuntimeSettings',
+                              payload: {
+                                  type: 'updateRuntimeSettings',
+                                  actionId,
+                                  settings: {
+                                      turnTermMinutes: 20,
+                                      blockGeneralCreate: 2,
+                                      autorunUser: { limitMinutes: 720, options: ['develop', 'chief'] },
+                                  },
+                              },
+                              status: 'SUCCEEDED',
+                              result: {
+                                  type: 'updateRuntimeSettings',
+                                  ok: true,
+                                  actionId,
+                                  settings: {
+                                      turnTermMinutes: 20,
+                                      blockGeneralCreate: 2,
+                                      autorunUser: { limitMinutes: 720, options: ['develop', 'chief'] },
+                                  },
+                                  termChanged: true,
+                                  previousTurnTermMinutes: 10,
+                                  turnTermMinutes: 20,
+                                  previousClockBaseTime: '2026-07-30T10:00:00.000Z',
+                                  clockBaseTime: '2026-07-30T09:55:00.000Z',
+                                  lastTurnTime: '2026-07-30T09:55:00.000Z',
+                                  shiftedGenerals: 2,
+                                  reprojectedAuctions: 1,
+                                  reprojectedMessages: 1,
+                                  reprojectedVotes: 1,
+                              },
+                              error: null,
+                          }
+                ),
+            },
+        } as unknown as GamePrismaClient;
+        const stateKey = 'sammo:hwe:default:tournament:state';
+        const values = new Map<string, string>([
+            [
+                stateKey,
+                JSON.stringify({
+                    stage: 1,
+                    nextAt: '2026-07-30T10:10:00.000Z',
+                    bettingCloseAt: '2026-07-30T10:05:00.000Z',
+                }),
+            ],
+        ]);
+        const redis = {
+            get: async (key: string) => values.get(key) ?? null,
+            set: async (key: string, value: string, options?: { NX?: boolean }) => {
+                if (options?.NX && values.has(key)) return null;
+                values.set(key, value);
+                return 'OK';
+            },
+            del: async (key: string) => (values.delete(key) ? 1 : 0),
+            eval: async (_script: string, options: { keys: string[]; arguments: string[] }) => {
+                options.arguments.forEach((value, index) => values.set(options.keys[index]!, value));
+                return '1';
+            },
+        };
+        const action = {
+            id: actionId,
+            profileName: 'hwe:default',
+            action: 'UPDATE_RUNTIME_SETTINGS',
+            durationMinutes: null,
+            payload: {
+                settings: {
+                    turnTermMinutes: 20,
+                    blockGeneralCreate: 2,
+                    autorunUser: { limitMinutes: 720, options: ['develop', 'chief'] },
+                },
+            },
+        };
+
+        await expect(
+            applyRuntimeGameSettings({ action, profileName: 'hwe:default', db, redis })
+        ).resolves.toMatchObject({ status: 'REQUESTED' });
+        eventStatus = 'SUCCEEDED';
+        await expect(
+            applyRuntimeGameSettings({ action, profileName: 'hwe:default', db, redis })
+        ).resolves.toMatchObject({ status: 'APPLIED' });
+        await expect(
+            applyRuntimeGameSettings({ action, profileName: 'hwe:default', db, redis })
+        ).resolves.toMatchObject({ status: 'APPLIED' });
+
+        expect(JSON.parse(values.get(stateKey) ?? '{}')).toMatchObject({
+            nextAt: '2026-07-30T10:15:00.000Z',
+            bettingCloseAt: '2026-07-30T10:05:00.000Z',
+            runtimeSettingsActionIds: [actionId],
+        });
+    });
+});
@@ -17,7 +17,10 @@ const databaseUrl = process.env.INPUT_EVENT_DATABASE_URL;
 const integration = describe.skipIf(!databaseUrl);
 const requestId = 'integration:engine:runtime-clock-shift';
 const actionId = 'b9f68480-dba9-4e03-a62b-499e6234f18a';
-const generalIds = [990_301, 990_302] as const;
+const runtimeSettingsRequestId = 'integration:engine:runtime-game-settings';
+const runtimeSettingsActionId = 'c9f68480-dba9-4e03-a62b-499e6234f18a';
+const generalIds = [990_301, 990_302, 990_303] as const;
+const runtimeSettingsLogText = 'runtime-settings-existing-log';

 const buildGeneral = (id: number, turnTime: Date): TurnGeneral =>
    ({
@@ -50,16 +53,23 @@ const buildGeneral = (id: number, turnTime: Date): TurnGeneral =>
        npcState: 0,
    }) as TurnGeneral;

-const waitForSucceeded = async (db: GamePrismaClient): Promise<void> => {
+const waitForSucceeded = async (db: GamePrismaClient, targetRequestId = requestId): Promise<void> => {
    const deadline = Date.now() + 5_000;
    while (Date.now() < deadline) {
-        const event = await db.inputEvent.findUnique({ where: { requestId }, select: { status: true } });
+        const event = await db.inputEvent.findUnique({
+            where: { requestId: targetRequestId },
+            select: { status: true },
+        });
        if (event?.status === 'SUCCEEDED') {
            return;
        }
        await new Promise((resolve) => setTimeout(resolve, 25));
    }
-    throw new Error('runtime clock shift input event did not complete');
+    const event = await db.inputEvent.findUnique({
+        where: { requestId: targetRequestId },
+        select: { status: true, error: true, attempts: true },
+    });
+    throw new Error(`runtime input event did not complete: ${JSON.stringify(event)}`);
 };

 integration('runtime clock shift persistence', () => {
@@ -71,17 +81,27 @@ integration('runtime clock shift persistence', () => {
        await connector.connect();
        db = connector.prisma;
        closeDb = () => connector.disconnect();
-        await db.inputEvent.deleteMany({ where: { requestId } });
+        await db.inputEvent.deleteMany({ where: { requestId: { in: [requestId, runtimeSettingsRequestId] } } });
+        await db.votePoll.deleteMany({ where: { openerGeneralId: generalIds[2] } });
+        await db.message.deleteMany({ where: { mailbox: generalIds[2] } });
+        await db.logEntry.deleteMany({ where: { text: runtimeSettingsLogText } });
        await db.auction.deleteMany({ where: { hostGeneralId: { in: [...generalIds] } } });
        await db.general.deleteMany({ where: { id: { in: [...generalIds] } } });
-        await db.worldState.deleteMany({ where: { scenarioCode: 'runtime-clock-shift' } });
+        await db.worldState.deleteMany({
+            where: { scenarioCode: { in: ['runtime-clock-shift', 'runtime-game-settings'] } },
+        });
    });

    afterAll(async () => {
-        await db.inputEvent.deleteMany({ where: { requestId } });
+        await db.inputEvent.deleteMany({ where: { requestId: { in: [requestId, runtimeSettingsRequestId] } } });
+        await db.votePoll.deleteMany({ where: { openerGeneralId: generalIds[2] } });
+        await db.message.deleteMany({ where: { mailbox: generalIds[2] } });
+        await db.logEntry.deleteMany({ where: { text: runtimeSettingsLogText } });
        await db.auction.deleteMany({ where: { hostGeneralId: { in: [...generalIds] } } });
        await db.general.deleteMany({ where: { id: { in: [...generalIds] } } });
-        await db.worldState.deleteMany({ where: { scenarioCode: 'runtime-clock-shift' } });
+        await db.worldState.deleteMany({
+            where: { scenarioCode: { in: ['runtime-clock-shift', 'runtime-game-settings'] } },
+        });
        await closeDb?.();
    });

@@ -126,7 +146,7 @@ integration('runtime clock shift persistence', () => {
                db.auction.create({
                    data: {
                        type: 'BUY_RICE',
-                        hostGeneralId: generalIds[index % generalIds.length]!,
+                        hostGeneralId: generals[index % generals.length]!.id,
                        detail: {},
                        status,
                        closeAt: new Date(`2099-07-30T1${index}:00:00.000Z`),
@@ -278,4 +298,250 @@ integration('runtime clock shift persistence', () => {

        await db.worldState.delete({ where: { id: row.id } });
    });
+
+    it('reprojects tick-owned dates for a live turn-term change without rewriting existing log timestamps', async () => {
+        const base = new Date('2099-08-01T10:00:00.000Z');
+        const row = await db.worldState.create({
+            data: {
+                scenarioCode: 'runtime-game-settings',
+                currentYear: 191,
+                currentMonth: 2,
+                tickSeconds: 600,
+                clockBaseTime: base,
+                clockTick: 0,
+                clockMode: 'manual',
+                clockWallAnchor: base,
+                lastTurnTick: 0,
+                config: { turnTermMinutes: 10, blockGeneralCreate: 0 },
+                meta: { lastTurnTime: base.toISOString(), turnterm: 10 },
+            },
+        });
+        const general = {
+            ...buildGeneral(generalIds[2], new Date('2099-08-01T10:10:00.000Z')),
+            turnTick: GAME_TICKS_PER_TURN,
+            recentWarTime: new Date('2099-08-01T10:05:00.000Z'),
+            recentWarTick: GAME_TICKS_PER_TURN / 2,
+        };
+        await db.general.create({
+            data: {
+                id: general.id,
+                name: general.name,
+                nationId: general.nationId,
+                cityId: general.cityId,
+                troopId: general.troopId,
+                turnTime: general.turnTime,
+                turnTick: BigInt(general.turnTick),
+                recentWarTime: general.recentWarTime,
+                recentWarTick: BigInt(general.recentWarTick),
+            },
+        });
+        const auction = await db.auction.create({
+            data: {
+                type: 'BUY_RICE',
+                hostGeneralId: general.id,
+                detail: {},
+                status: 'OPEN',
+                closeAt: new Date('2099-08-01T10:10:00.000Z'),
+                closeTick: BigInt(GAME_TICKS_PER_TURN),
+            },
+        });
+        const message = await db.message.create({
+            data: {
+                mailbox: general.id,
+                type: 'runtime-settings-test',
+                src: 0,
+                dest: general.id,
+                time: new Date('2099-08-01T10:05:00.000Z'),
+                timeTick: BigInt(GAME_TICKS_PER_TURN / 2),
+                validUntil: new Date('2099-08-01T10:10:00.000Z'),
+                validUntilTick: BigInt(GAME_TICKS_PER_TURN),
+                message: {},
+            },
+        });
+        const vote = await db.votePoll.create({
+            data: {
+                title: 'runtime settings test',
+                options: ['yes', 'no'],
+                revealMode: 'ALWAYS',
+                openerGeneralId: general.id,
+                openerName: general.name,
+                startAt: new Date('2099-08-01T10:05:00.000Z'),
+                startTick: BigInt(GAME_TICKS_PER_TURN / 2),
+                endAt: new Date('2099-08-01T10:10:00.000Z'),
+                endTick: BigInt(GAME_TICKS_PER_TURN),
+            },
+        });
+        const originalLogTime = new Date('2026-01-02T03:04:05.000Z');
+        const existingLog = await db.logEntry.create({
+            data: {
+                scope: 'SYSTEM',
+                category: 'HISTORY',
+                year: 191,
+                month: 2,
+                text: runtimeSettingsLogText,
+                createdAt: originalLogTime,
+            },
+        });
+
+        const state: TurnWorldState = {
+            id: row.id,
+            currentYear: 191,
+            currentMonth: 2,
+            tickSeconds: 600,
+            lastTurnTime: base,
+            clockBaseTime: base,
+            clockTick: 0,
+            clockMode: 'manual',
+            clockWallAnchor: base,
+            lastTurnTick: 0,
+            meta: row.meta as Record<string, unknown>,
+        };
+        const snapshot: TurnWorldSnapshot = {
+            scenarioConfig: {
+                stat: { total: 300, min: 10, max: 100, npcTotal: 150, npcMax: 50, npcMin: 10, chiefMin: 70 },
+                iconPath: '',
+                map: {},
+                const: {},
+                environment: { mapName: 'test', unitSet: 'default' },
+            },
+            worldConfig: row.config as Record<string, unknown>,
+            map: {
+                id: 'test',
+                name: 'test',
+                cities: [],
+                defaults: { trust: 50, trade: 100, supplyState: 1, frontState: 0 },
+            },
+            generals: [general],
+            cities: [],
+            nations: [],
+            troops: [],
+            diplomacy: [],
+            events: [],
+            initialEvents: [],
+        };
+        const world = new InMemoryTurnWorld(state, snapshot, {
+            schedule: { entries: [{ startMinute: 0, tickMinutes: 10 }] },
+        });
+        const stateStore = new InMemoryTurnStateStore(world);
+        await stateStore.saveCheckpoint({
+            turnTime: base.toISOString(),
+            turnTick: 0,
+            generalId: 0,
+            year: 191,
+            month: 2,
+        });
+        const hooks = await createDatabaseTurnHooks(databaseUrl!, world);
+        const queue = new DatabaseTurnDaemonCommandQueue(db);
+        await queue.initialize();
+        const stateManager = new EngineStateManager();
+        stateManager.register('world', {
+            capture: () => world.captureState(),
+            restore: (saved) => world.restoreState(saved),
+        });
+        const lifecycle = new TurnDaemonLifecycle(
+            {
+                clock: new SystemClock(),
+                controlQueue: queue,
+                commandResponder: queue,
+                commandHandler: createTurnDaemonCommandHandler({ world }),
+                hooks: hooks.hooks,
+                stateManager,
+                stateStore,
+                getNextTickTime: (lastTurnTime) =>
+                    getNextTickTime(lastTurnTime, Math.max(1, Math.round(world.getState().tickSeconds / 60))),
+                processor: {
+                    run: async () => ({
+                        lastTurnTime: world.getState().lastTurnTime.toISOString(),
+                        processedGenerals: 0,
+                        processedTurns: 0,
+                        durationMs: 0,
+                        partial: false,
+                    }),
+                },
+            },
+            {
+                profile: 'integration',
+                defaultBudget: { budgetMs: 1000, maxGenerals: 10, catchUpCap: 1 },
+            }
+        );
+
+        await db.inputEvent.create({
+            data: {
+                requestId: runtimeSettingsRequestId,
+                target: 'ENGINE',
+                eventType: 'updateRuntimeSettings',
+                payload: {
+                    type: 'updateRuntimeSettings',
+                    requestId: runtimeSettingsRequestId,
+                    actionId: runtimeSettingsActionId,
+                    settings: {
+                        turnTermMinutes: 20,
+                        blockGeneralCreate: 2,
+                        autorunUser: {
+                            limitMinutes: 720,
+                            options: ['develop', 'recruit_high', 'chief'],
+                        },
+                    },
+                } as GamePrisma.InputJsonValue,
+            },
+        });
+        const loop = lifecycle.start();
+        try {
+            await waitForSucceeded(db, runtimeSettingsRequestId);
+        } finally {
+            await lifecycle.stop('test complete');
+            await loop;
+            await hooks.close();
+        }
+
+        const storedWorld = await db.worldState.findUniqueOrThrow({ where: { id: row.id } });
+        expect(storedWorld).toMatchObject({ tickSeconds: 1200, clockBaseTime: base, lastTurnTick: 0n });
+        expect(storedWorld.config).toMatchObject({ turnTermMinutes: 20, blockGeneralCreate: 2 });
+        expect(storedWorld.meta).toMatchObject({
+            turnterm: 20,
+            autorun_user: {
+                limit_minutes: 720,
+                options: { develop: true, recruit_high: true, chief: true },
+            },
+        });
+        expect(await db.general.findUniqueOrThrow({ where: { id: general.id } })).toMatchObject({
+            turnTime: new Date('2099-08-01T10:20:00.000Z'),
+            turnTick: BigInt(GAME_TICKS_PER_TURN),
+            recentWarTime: new Date('2099-08-01T10:10:00.000Z'),
+        });
+        expect((await db.auction.findUniqueOrThrow({ where: { id: auction.id } })).closeAt).toEqual(
+            new Date('2099-08-01T10:20:00.000Z')
+        );
+        expect(await db.message.findUniqueOrThrow({ where: { id: message.id } })).toMatchObject({
+            time: new Date('2099-08-01T10:10:00.000Z'),
+            validUntil: new Date('2099-08-01T10:20:00.000Z'),
+        });
+        expect(await db.votePoll.findUniqueOrThrow({ where: { id: vote.id } })).toMatchObject({
+            startAt: new Date('2099-08-01T10:10:00.000Z'),
+            endAt: new Date('2099-08-01T10:20:00.000Z'),
+        });
+        expect(await db.logEntry.findUniqueOrThrow({ where: { id: existingLog.id } })).toMatchObject({
+            text: runtimeSettingsLogText,
+            createdAt: originalLogTime,
+        });
+        expect(await db.logEntry.findFirst({ where: { text: { contains: '턴시간이 <C>20분' } } })).not.toBeNull();
+        expect(lifecycle.getStatus().nextTurnTime).toBe('2099-08-01T10:20:00.000Z');
+        expect(await db.inputEvent.findUniqueOrThrow({ where: { requestId: runtimeSettingsRequestId } })).toMatchObject(
+            {
+                status: 'SUCCEEDED',
+                result: {
+                    type: 'updateRuntimeSettings',
+                    ok: true,
+                    actionId: runtimeSettingsActionId,
+                    termChanged: true,
+                    previousTurnTermMinutes: 10,
+                    turnTermMinutes: 20,
+                    shiftedGenerals: 1,
+                    reprojectedAuctions: 1,
+                    reprojectedMessages: 1,
+                    reprojectedVotes: 1,
+                },
+            }
+        );
+    });
 });