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

fix(engine): finalize united events and auctions compatibly

Browse Source
This commit is contained in:
Hide_D
2026-07-31 14:56:57 +00:00
parent d8a893e6a8
commit bb6d2f524e
15 changed files with 995 additions and 138 deletions
Download Patch File Download Diff File Expand all files Collapse all files
app/game-engine/test/unificationFinalization.integration.test.ts
+187 -13
View File
@@ -2,14 +2,20 @@ import { afterAll, beforeAll, describe, expect, it } from 'vitest';
import { createGamePostgresConnector, type GamePrismaClient } from '@sammo-ts/infra';
import { createAuctionBidder } from '../src/auction/bidder.js';
import { createDatabaseTurnHooks } from '../src/turn/databaseHooks.js';
import { composeCalendarHandlers } from '../src/turn/calendarHandlers.js';
import { EngineStateManager } from '../src/turn/engineStateManager.js';
import { InMemoryTurnWorld } from '../src/turn/inMemoryWorld.js';
import { createMonthlyEventHandler, type MonthlyEventActionHandler } from '../src/turn/monthlyEventHandler.js';
import { createMergeInheritPointRankHandler } from '../src/turn/monthlyUniqueInheritAction.js';
import { loadPendingUnificationAuctionCancellations } from '../src/turn/unificationAuctionCancellation.js';
import { createUnificationHandler } from '../src/turn/unificationHandler.js';
import { loadTurnWorldFromDatabase } from '../src/turn/worldLoader.js';
const databaseUrl = process.env.INPUT_EVENT_DATABASE_URL;
const integration = describe.skipIf(!databaseUrl);
const fixtureId = 992_001;
const fixtureId = 8_901;
const serverId = 'che_unification_atomicity_fixture';
const profileName = 'che';
const userId = 'unification-atomicity-user';
@@ -19,6 +25,9 @@ integration('unification finalization transaction', () => {
let closeDb: (() => Promise<void>) | undefined;
const cleanup = async (): Promise<void> => {
await db.message.deleteMany({ where: { mailbox: fixtureId } });
await db.auction.deleteMany({ where: { hostGeneralId: fixtureId } });
await db.event.deleteMany({ where: { id: fixtureId } });
await db.unificationFinalization.deleteMany({ where: { serverId } });
await db.yearbookHistory.deleteMany({ where: { profileName: serverId } });
await db.emperor.deleteMany({ where: { serverId } });
@@ -120,15 +129,54 @@ integration('unification finalization transaction', () => {
rank_warnum: 4,
firenum: 2,
dex1: 100,
max_belong: 4,
betwin: 2,
betgold: 1_000,
betwingold: 500,
inherit_earned_act: 5,
inherit_spent_dyn: 30,
},
},
});
await db.inheritancePoint.createMany({
data: [
{ userId, key: 'previous', value: 100 },
{ userId, key: 'unifier', value: 7 },
{ userId, key: 'tournament', value: 11 },
],
});
const futureCloseAt = new Date(Date.now() + 86_400_000);
const uniqueAuction = await db.auction.create({
data: {
type: 'UNIQUE_ITEM',
targetCode: 'che_서적_07_논어',
hostGeneralId: fixtureId,
hostName: '(상인)',
detail: { title: '논어 경매', isReverse: false },
status: 'OPEN',
closeAt: futureCloseAt,
},
});
const resourceAuction = await db.auction.create({
data: {
type: 'BUY_RICE',
targetCode: '100',
hostGeneralId: fixtureId,
hostName: '원자장수',
detail: { title: '쌀 구매 경매', amount: 100, isReverse: false },
status: 'OPEN',
closeAt: futureCloseAt,
},
});
await db.event.create({
data: {
id: fixtureId,
targetCode: 'united',
priority: 5_000,
condition: true,
action: [['MergeInheritPointRank']],
meta: { fixture: 'unification-atomicity' },
},
});
const worldRow = await db.worldState.create({
data: {
scenarioCode: 'unification-atomicity-fixture',
@@ -160,14 +208,71 @@ integration('unification finalization transaction', () => {
},
});
const beforeBid = await loadTurnWorldFromDatabase({ databaseUrl: databaseUrl! });
const bidWorld = new InMemoryTurnWorld(beforeBid.state, beforeBid.snapshot, {
schedule: { entries: [{ startMinute: 0, tickMinutes: 10 }] },
});
const bidder = await createAuctionBidder({ databaseUrl: databaseUrl!, world: bidWorld });
try {
await expect(
bidder.bid({
type: 'auctionBid',
auctionId: uniqueAuction.id,
generalId: fixtureId,
amount: 30,
tryExtendCloseDate: false,
})
).resolves.toMatchObject({ ok: true, auctionId: uniqueAuction.id });
await expect(
bidder.bid({
type: 'auctionBid',
auctionId: uniqueAuction.id,
generalId: fixtureId,
amount: 50,
tryExtendCloseDate: false,
})
).resolves.toMatchObject({ ok: true, auctionId: uniqueAuction.id });
} finally {
await bidder.close();
}
expect(
(await db.inheritancePoint.findUniqueOrThrow({ where: { userId_key: { userId, key: 'previous' } } })).value
).toBe(50);
expect(
await db.rankData.findUniqueOrThrow({
where: { generalId_type: { generalId: fixtureId, type: 'inherit_spent_dyn' } },
})
).toMatchObject({ value: 50 });
expect(
(await db.auctionBid.findMany({ where: { auctionId: uniqueAuction.id }, orderBy: { id: 'asc' } })).map(
(bid) => bid.meta
)
).toEqual([
expect.objectContaining({ inheritSpentTrackedAmount: 30 }),
expect.objectContaining({ inheritSpentTrackedAmount: 50 }),
]);
const loaded = await loadTurnWorldFromDatabase({ databaseUrl: databaseUrl! });
let world: InMemoryTurnWorld | null = null;
const unification = createUnificationHandler({ profileName, getWorld: () => world });
const actions = new Map<string, MonthlyEventActionHandler>();
actions.set('MergeInheritPointRank', createMergeInheritPointRankHandler({ getWorld: () => world }));
const events = createMonthlyEventHandler({ getWorld: () => world, startYear: 190, actions });
const unification = createUnificationHandler({
profileName,
getWorld: () => world,
loadPendingUniqueAuctions: () => loadPendingUnificationAuctionCancellations(databaseUrl!),
dispatchUnitedEvents: (context) => events.dispatchTarget('united', context),
});
world = new InMemoryTurnWorld(loaded.state, loaded.snapshot, {
schedule: { entries: [{ startMinute: 0, tickMinutes: 10 }] },
calendarHandler: unification.handler,
calendarHandler: composeCalendarHandlers(events, unification.handler),
});
const hooks = await createDatabaseTurnHooks(databaseUrl!, world, { profileName });
const stateManager = new EngineStateManager();
stateManager.register('world', {
capture: () => world!.captureState(),
restore: (captured) => world!.restoreState(captured),
});
const runResult = {
lastTurnTime: '0190-07-01T00:00:00.000Z',
processedGenerals: 0,
@@ -176,12 +281,21 @@ integration('unification finalization transaction', () => {
partial: false,
};
try {
await world.advanceMonth(new Date('0190-07-01T00:00:00.000Z'));
expect(world.getState().meta).toMatchObject({ isUnited: 2, isunited: 2, refreshLimit: 200 });
expect(world.peekDirtyState().pendingUnificationFinalizations).toHaveLength(1);
expect(world.peekDirtyState().pendingYearbookSnapshots).toHaveLength(1);
await expect(hooks.hooks.flushChanges?.(runResult)).rejects.toThrow();
const beforeFailedTurn = world.captureState();
await expect(
stateManager.transaction(async () => {
await world!.advanceMonth(new Date('0190-07-01T00:00:00.000Z'));
expect(world!.getState().meta).toMatchObject({ isUnited: 2, isunited: 2, refreshLimit: 200 });
expect(world!.peekDirtyState().pendingUnificationFinalizations).toHaveLength(1);
expect(world!.peekDirtyState().pendingYearbookSnapshots).toHaveLength(1);
expect(world!.getGeneralById(fixtureId)).toMatchObject({
inheritancePoints: { previous: 100, unifier: 2_000, tournament: 11 },
meta: { inherit_earned_dyn: 2_155.1, inherit_earned: 2_160.1, inherit_spent: 0 },
});
await hooks.hooks.flushChanges?.(runResult);
})
).rejects.toThrow();
expect(world.captureState()).toEqual(beforeFailedTurn);
expect(await db.unificationFinalization.count({ where: { serverId } })).toBe(0);
expect(await db.yearbookHistory.count({ where: { profileName: serverId } })).toBe(0);
@@ -192,8 +306,11 @@ integration('unification finalization transaction', () => {
expect(
(await db.inheritancePoint.findUniqueOrThrow({ where: { userId_key: { userId, key: 'previous' } } }))
.value
).toBe(100);
expect(world.peekDirtyState().pendingUnificationFinalizations).toHaveLength(1);
).toBe(50);
expect((await db.auction.findUniqueOrThrow({ where: { id: uniqueAuction.id } })).status).toBe('OPEN');
expect((await db.auction.findUniqueOrThrow({ where: { id: resourceAuction.id } })).status).toBe('OPEN');
expect(await db.message.count({ where: { mailbox: fixtureId } })).toBe(0);
expect(world.peekDirtyState().pendingUnificationFinalizations).toHaveLength(0);
await db.gameHistory.create({
data: {
@@ -204,13 +321,70 @@ integration('unification finalization transaction', () => {
scenarioName: '원자성 시나리오',
},
});
await hooks.hooks.flushChanges?.(runResult);
await stateManager.transaction(async () => {
await world!.advanceMonth(new Date('0190-07-01T00:00:00.000Z'));
await hooks.hooks.flushChanges?.(runResult);
});
expect(await db.unificationFinalization.count({ where: { serverId } })).toBe(1);
expect(await db.inheritanceResult.count({ where: { serverId } })).toBe(1);
expect(await db.oldGeneral.count({ where: { serverId } })).toBe(1);
expect(await db.oldNation.count({ where: { serverId } })).toBe(2);
expect(await db.emperor.count({ where: { serverId } })).toBe(1);
expect(
(await db.inheritancePoint.findUniqueOrThrow({ where: { userId_key: { userId, key: 'previous' } } }))
.value
).toBe(2_255);
expect(await db.inheritancePoint.count({ where: { userId, key: { not: 'previous' } } })).toBe(0);
expect(await db.inheritanceResult.findFirstOrThrow({ where: { serverId } })).toMatchObject({
value: expect.objectContaining({
previous: 100,
max_belong: 40,
tournament: 11,
betting: 5,
unifier: 2_000,
unifierBeforeAward: 0,
unifierAward: 2_000,
total: 2_255,
}),
});
expect(await db.auction.findUniqueOrThrow({ where: { id: uniqueAuction.id } })).toMatchObject({
status: 'CANCELED',
finishedAt: new Date('0190-07-01T00:00:00.000Z'),
});
expect((await db.auction.findUniqueOrThrow({ where: { id: resourceAuction.id } })).status).toBe('OPEN');
expect(await db.auctionBid.count({ where: { auctionId: uniqueAuction.id } })).toBe(2);
const cancellationMessage = await db.message.findFirstOrThrow({ where: { mailbox: fixtureId } });
expect(cancellationMessage).toMatchObject({
mailbox: fixtureId,
src: 0,
dest: fixtureId,
time: new Date('0190-07-01T00:00:00.000Z'),
});
expect(cancellationMessage.message).toMatchObject({
text: `${uniqueAuction.id}번 논어 경매가 취소되었습니다.`,
});
expect(await db.event.count({ where: { id: fixtureId } })).toBe(1);
expect(
await db.rankData.findUniqueOrThrow({
where: { generalId_type: { generalId: fixtureId, type: 'inherit_spent' } },
})
).toMatchObject({ value: 0 });
await expect(
db.rankData.findUniqueOrThrow({
where: { generalId_type: { generalId: fixtureId, type: 'inherit_spent_dyn' } },
})
).resolves.toMatchObject({ value: 0 });
await expect(
db.rankData.findUniqueOrThrow({
where: { generalId_type: { generalId: fixtureId, type: 'inherit_earned_dyn' } },
})
).resolves.toMatchObject({ value: 2_155 });
await expect(
db.rankData.findUniqueOrThrow({
where: { generalId_type: { generalId: fixtureId, type: 'inherit_earned' } },
})
).resolves.toMatchObject({ value: 2_160 });
expect((await db.gameHistory.findUniqueOrThrow({ where: { serverId } })).winnerNation).toBe(fixtureId);
const yearbook = await db.yearbookHistory.findUniqueOrThrow({
where: {
app/game-engine/test/unificationHandler.test.ts
+219
View File
@@ -0,0 +1,219 @@
import { describe, expect, it, vi } from 'vitest';
import type { City, MapDefinition, Nation } from '@sammo-ts/logic';
import { composeCalendarHandlers } from '../src/turn/calendarHandlers.js';
import { InMemoryTurnWorld } from '../src/turn/inMemoryWorld.js';
import { createMonthlyEventHandler, type MonthlyEventActionHandler } from '../src/turn/monthlyEventHandler.js';
import { createMergeInheritPointRankHandler } from '../src/turn/monthlyUniqueInheritAction.js';
import { createUnificationHandler } from '../src/turn/unificationHandler.js';
import { createTurnDaemonCommandHandler } from '../src/turn/worldCommandHandler.js';
import type { TurnGeneral, TurnWorldSnapshot, TurnWorldState } from '../src/turn/types.js';
const map: MapDefinition = {
id: 'united-test',
name: 'united-test',
cities: [],
defaults: { trust: 50, trade: 100, supplyState: 1, frontState: 0 },
};
const general: TurnGeneral = {
id: 1,
userId: 'user-1',
name: '통일장수',
nationId: 1,
cityId: 1,
troopId: 0,
stats: { leadership: 80, strength: 70, intelligence: 60 },
turnTime: new Date('0190-07-01T00:00:00.000Z'),
role: {
items: { horse: null, weapon: null, book: null, item: null },
personality: null,
specialDomestic: null,
specialWar: null,
},
triggerState: { flags: {}, counters: {}, modifiers: {}, meta: {} },
inheritancePoints: { previous: 100, unifier: 7, tournament: 11 },
meta: {
killturn: 24,
inherit_lived_month: 10,
max_belong: 4,
max_domestic_critical: 20,
inherit_active_action: 3,
rank_warnum: 4,
firenum: 2,
dex1: 100,
betwin: 2,
betgold: 1000,
betwingold: 500,
inherit_earned_act: 5,
inherit_spent_dyn: 50,
},
officerLevel: 12,
experience: 10,
dedication: 5,
injury: 0,
gold: 100,
rice: 100,
crew: 100,
crewTypeId: 0,
train: 0,
atmos: 0,
age: 40,
npcState: 0,
picture: '1.png',
imageServer: 0,
};
const nation: Nation = {
id: 1,
name: '통일국',
color: '#ffffff',
capitalCityId: 1,
chiefGeneralId: 1,
gold: 1000,
rice: 2000,
power: 3000,
level: 1,
typeCode: 'test',
meta: {},
};
const city: City = {
id: 1,
name: '통일도시',
nationId: 1,
level: 1,
state: 0,
population: 1000,
populationMax: 2000,
agriculture: 0,
agricultureMax: 0,
commerce: 0,
commerceMax: 0,
security: 0,
securityMax: 0,
supplyState: 1,
frontState: 0,
defence: 0,
defenceMax: 0,
wall: 0,
wallMax: 0,
meta: {},
};
describe('unification handler', () => {
it('refunds pending unique bids and runs UNITED before setting the united flag', async () => {
const observed: Array<{ isUnited: unknown; unifier: number; previous: number; spent: unknown }> = [];
const actions = new Map<string, MonthlyEventActionHandler>();
let world: InMemoryTurnWorld | null = null;
actions.set('MergeInheritPointRank', createMergeInheritPointRankHandler({ getWorld: () => world }));
actions.set('ObserveUnited', () => {
const current = world!.getGeneralById(1)!;
observed.push({
isUnited: world!.getState().meta.isUnited,
unifier: current.inheritancePoints?.unifier ?? 0,
previous: current.inheritancePoints?.previous ?? 0,
spent: current.meta.inherit_spent_dyn,
});
});
const events = createMonthlyEventHandler({ getWorld: () => world, startYear: 190, actions });
const auctionCancellation = {
auctionId: 77,
status: 'OPEN' as const,
closeAt: new Date('0190-08-01T00:00:00.000Z'),
title: '보물 경매',
highestBidId: 5,
bidderGeneralId: 1,
amount: 30,
rankTrackedAmount: 30,
};
const legacyAuctionCancellation = {
auctionId: 78,
status: 'FINALIZING' as const,
closeAt: new Date('0190-08-02T00:00:00.000Z'),
title: '기존 보물 경매',
highestBidId: 6,
bidderGeneralId: 1,
amount: 20,
rankTrackedAmount: 0,
};
const unification = createUnificationHandler({
profileName: 'che',
getWorld: () => world,
loadPendingUniqueAuctions: async () => [auctionCancellation, legacyAuctionCancellation],
dispatchUnitedEvents: (context) => events.dispatchTarget('UNITED', context),
});
const state: TurnWorldState = {
id: 1,
currentYear: 190,
currentMonth: 6,
tickSeconds: 600,
lastTurnTime: new Date('0190-06-01T00:00:00.000Z'),
meta: { serverId: 'server-1', refreshLimit: 2 },
};
const snapshot: TurnWorldSnapshot = {
generals: [general],
cities: [city],
nations: [nation],
troops: [],
diplomacy: [],
events: [
{
id: 10,
targetCode: 'united',
priority: 5000,
condition: true,
action: [['ObserveUnited'], ['MergeInheritPointRank']],
meta: {},
},
],
initialEvents: [],
scenarioConfig: {
stat: { total: 300, min: 10, max: 100, npcTotal: 150, npcMax: 50, npcMin: 10, chiefMin: 70 },
iconPath: '',
map: {},
const: {},
environment: { mapName: map.id, unitSet: 'test' },
},
scenarioMeta: {
title: 'united test',
startYear: 190,
life: null,
fiction: null,
history: [],
ignoreDefaultEvents: false,
},
map,
};
world = new InMemoryTurnWorld(state, snapshot, {
schedule: { entries: [{ startMinute: 0, tickMinutes: 10 }] },
calendarHandler: composeCalendarHandlers(events, unification.handler),
});
await world.advanceMonth(new Date('0190-07-01T00:00:00.000Z'));
expect(observed).toEqual([{ isUnited: undefined, unifier: 2007, previous: 150, spent: 20 }]);
expect(world.getState().meta).toMatchObject({ isUnited: 2, isunited: 2, refreshLimit: 200 });
expect(world.getGeneralById(1)).toMatchObject({
inheritancePoints: { previous: 150, unifier: 2007, tournament: 11 },
meta: { inherit_earned_dyn: 2162.1, inherit_earned: 2167.1, inherit_spent: 20 },
});
expect(world.listEvents('united')).toHaveLength(1);
expect(world.peekDirtyState().pendingUnificationFinalizations).toEqual([
expect.objectContaining({ auctionCancellations: [auctionCancellation, legacyAuctionCancellation] }),
]);
const bid = vi.fn();
const commands = createTurnDaemonCommandHandler({
world,
auctionBidder: { bid },
});
await expect(
commands.handle({ type: 'auctionBid', auctionId: 77, generalId: 1, amount: 100 })
).resolves.toMatchObject({ ok: false, reason: '천하통일 후에는 경매를 이용할 수 없습니다.' });
await expect(
commands.handle({ type: 'auctionOpen', auctionType: 'UNIQUE_ITEM', generalId: 1, amount: 100 })
).resolves.toMatchObject({ ok: false, reason: '천하통일 후에는 경매를 이용할 수 없습니다.' });
expect(bid).not.toHaveBeenCalled();
});
});
app/game-engine/test/unificationPersistence.test.ts
+19 -1
View File
@@ -4,7 +4,7 @@ import type { GamePrisma } from '@sammo-ts/infra';
import type { City, Nation } from '@sammo-ts/logic';
import { InMemoryTurnWorld } from '../src/turn/inMemoryWorld.js';
import { persistUnificationFinalization } from '../src/turn/unificationPersistence.js';
import { persistUnificationFinalization, resolveStoredInheritancePoint } from '../src/turn/unificationPersistence.js';
import type { TurnGeneral, TurnWorldSnapshot, TurnWorldState } from '../src/turn/types.js';
const buildWorld = (): InMemoryTurnWorld => {
@@ -135,12 +135,29 @@ const input = {
year: 190,
month: 7,
completedAt: new Date('0190-07-01T00:00:00.000Z'),
auctionCancellations: [],
} as const;
describe('persistUnificationFinalization', () => {
it.each([
{ label: 'missing row', rows: [], memoryValue: 2_000, expected: 0 },
{ label: 'zero row', rows: [['unifier', 0] as const], memoryValue: 2_000, expected: 0 },
{ label: 'positive row', rows: [['unifier', 7] as const], memoryValue: 2_007, expected: 7 },
])('resolves the pre-award unifier value for $label', ({ rows, memoryValue, expected }) => {
expect(
resolveStoredInheritancePoint(
new Map<string, number>(rows),
{ inheritancePoints: { unifier: memoryValue } },
'unifier',
2_000
)
).toBe(expected);
});
it('does not write when the transaction-scoped generation was already applied', async () => {
const transaction = Object.assign({} as GamePrisma.TransactionClient, {
$executeRaw: vi.fn().mockResolvedValue(1),
$queryRaw: vi.fn().mockResolvedValue([]),
unificationFinalization: {
findUnique: vi.fn().mockResolvedValue({
generationKey: input.generationKey,
@@ -171,6 +188,7 @@ describe('persistUnificationFinalization', () => {
const emperorCreate = vi.fn().mockResolvedValue({});
const transaction = Object.assign({} as GamePrisma.TransactionClient, {
$executeRaw: vi.fn().mockResolvedValue(1),
$queryRaw: vi.fn().mockResolvedValue([]),
unificationFinalization: {
findUnique: vi.fn().mockResolvedValue(null),
create: vi.fn().mockResolvedValue({}),