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

Merge branch 'main' into refactor/frontend-css-structure

Browse Source
This commit is contained in:
Hide_D
2026-07-27 11:15:35 +00:00
parent ab6f4129a9 9f402a3d67
commit dc83df7670
4 changed files with 706 additions and 9 deletions
Download Patch File Download Diff File Expand all files Collapse all files
app/game-engine/src/turn/monthlyRaiseNpcNationAction.ts
+1 -1
View File
@@ -390,7 +390,7 @@ export const createRaiseNpcNationHandler = (options: {
scope: LogScope.SYSTEM,
category: LogCategory.HISTORY,
text: '<L><b>【공지】</b></>공백지에 임의의 국가가 생성되었습니다.',
format: LogFormat.NOTICE_YEAR_MONTH,
format: LogFormat.YEAR_MONTH,
year: environment.year,
month: environment.month,
});
app/game-engine/test/monthlyCatalogCoverage.test.ts
+5 -1
View File
@@ -102,7 +102,11 @@ const segments = [
kind: 'multi-month',
actions: ['OpenNationBetting', 'FinishNationBetting'],
coreEvidence: ['monthlyNationBettingPersistence.integration.test.ts'],
refEvidence: ['monthly_open_nation_betting.json', 'monthly_finish_nation_betting.json'],
refEvidence: [
'monthly_open_nation_betting.json',
'monthly_finish_nation_betting.json',
'monthly_nation_betting_lifecycle.json',
],
},
{
name: 'scout-block-boundaries',
app/game-engine/test/monthlyRaiseNpcNationPersistence.integration.test.ts
+141 -7
View File
@@ -1,9 +1,14 @@
import { execFileSync } from 'node:child_process';
import fs from 'node:fs';
import path from 'node:path';
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 { createProvideNpcTroopLeaderHandler } from '../src/turn/monthlyProvideNpcTroopLeaderAction.js';
import { createRaiseNpcNationHandler } from '../src/turn/monthlyRaiseNpcNationAction.js';
import { createMonthlyEventHandler } from '../src/turn/monthlyEventHandler.js';
import { InMemoryReservedTurnStore } from '../src/turn/reservedTurnStore.js';
@@ -17,6 +22,54 @@ const createdNationId = 990_086;
const occupiedCityId = 990_083;
const targetCityId = 990_086;
const createdGeneralId = 990_086;
const existingNationLeaderId = 990_087;
const createdNationLeaderId = 990_088;
const createdGeneralIds = [createdGeneralId, existingNationLeaderId, createdNationLeaderId];
type ReferenceNpcNationLifecycleTrace = {
phases: {
afterRaise: {
createdNationCount: number;
createdGeneralCount: number;
generalCountsPerCreatedNation: number[];
historyLogs: string[];
};
afterProvide: {
createdLeaderCount: number;
leaderCountsPerActiveNation: number[];
troopCount: number;
gatherTurnCounts: number[];
leaderCounterDelta: number;
};
};
};
const runReferenceNpcNationLifecycle = (): ReferenceNpcNationLifecycleTrace | null => {
const workspaceRoot = process.env.TURN_DIFFERENTIAL_WORKSPACE_ROOT;
if (process.env.TURN_DIFFERENTIAL_REFERENCE !== '1' || !workspaceRoot) {
return null;
}
const stackDirectory = path.join(workspaceRoot, 'docker_compose_files/reference');
const runnerScript =
process.env.MONTHLY_NPC_LIFECYCLE_RUNNER_SCRIPT ??
path.join(workspaceRoot, 'ref/sam/hwe/compare/monthly_event_trace.php');
const fixturePath =
process.env.MONTHLY_NPC_LIFECYCLE_FIXTURE ??
path.join(path.dirname(runnerScript), 'fixtures/monthly_npc_nation_lifecycle.json');
const stdout = execFileSync('./scripts/run-turn-differential-case.sh', ['-'], {
cwd: stackDirectory,
input: fs.readFileSync(fixturePath, 'utf8'),
encoding: 'utf8',
stdio: ['pipe', 'pipe', 'pipe'],
env: {
...process.env,
COMPOSE_PROJECT_NAME: 'sam-rebuild-reference',
TURN_DIFFERENTIAL_RUNNER_SCRIPT: runnerScript,
TURN_DIFFERENTIAL_COMPARE_DIR: path.dirname(runnerScript),
},
});
return JSON.parse(stdout) as ReferenceNpcNationLifecycleTrace;
};
const buildCity = (id: number, nationId: number, name: string): City => ({
id,
@@ -91,7 +144,7 @@ const event: TurnEvent = {
targetCode: 'month',
priority: 1_000,
condition: true,
action: [['RaiseNPCNation']],
action: [['RaiseNPCNation'], ['ProvideNPCTroopLeader']],
meta: {},
};
@@ -103,14 +156,15 @@ integration('RaiseNPCNation database persistence', () => {
await db.logEntry.deleteMany({
where: {
OR: [
{ generalId: createdGeneralId },
{ generalId: { in: createdGeneralIds } },
{ 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.generalTurn.deleteMany({ where: { generalId: { in: createdGeneralIds } } });
await db.rankData.deleteMany({ where: { generalId: { in: createdGeneralIds } } });
await db.troop.deleteMany({ where: { troopLeaderId: { in: createdGeneralIds } } });
await db.general.deleteMany({ where: { id: { in: createdGeneralIds } } });
await db.nationTurn.deleteMany({ where: { nationId: createdNationId } });
await db.diplomacy.deleteMany({
where: {
@@ -135,6 +189,7 @@ integration('RaiseNPCNation database persistence', () => {
});
it('commits the nation, city, diplomacy, ruler, turns, ranks, and history in one flush', async () => {
const referenceTrace = runReferenceNpcNationLifecycle();
const createCity = (city: City) =>
db.city.create({
data: {
@@ -191,6 +246,7 @@ integration('RaiseNPCNation database persistence', () => {
hiddenSeed: 'raise-npc-nation-persistence',
lastGeneralId: createdGeneralId - 1,
lastNationId: createdNationId - 1,
lastNPCTroopLeaderID: 40,
serverId: 'raise-npc-nation-persistence',
},
},
@@ -205,6 +261,7 @@ integration('RaiseNPCNation database persistence', () => {
hiddenSeed: 'raise-npc-nation-persistence',
lastGeneralId: createdGeneralId - 1,
lastNationId: createdNationId - 1,
lastNPCTroopLeaderID: 40,
serverId: 'raise-npc-nation-persistence',
},
};
@@ -240,12 +297,20 @@ integration('RaiseNPCNation database persistence', () => {
map,
loadArchivedNationMaxId: async () => 0,
});
const provide = createProvideNpcTroopLeaderHandler({
getWorld: () => world,
reservedTurns,
env: buildCommandEnv(snapshot.scenarioConfig),
});
world = new InMemoryTurnWorld(state, snapshot, {
schedule: { entries: [{ startMinute: 0, tickMinutes: 10 }] },
calendarHandler: createMonthlyEventHandler({
getWorld: () => world,
startYear: 190,
actions: new Map([['RaiseNPCNation', handler]]),
actions: new Map([
['RaiseNPCNation', handler],
['ProvideNPCTroopLeader', provide],
]),
}),
});
const dbHooks = await createDatabaseTurnHooks(databaseUrl!, world, { reservedTurns });
@@ -296,11 +361,80 @@ integration('RaiseNPCNation database persistence', () => {
},
})
).toBe(2);
expect(
await db.general.findMany({
where: { id: { in: [existingNationLeaderId, createdNationLeaderId] } },
orderBy: { id: 'asc' },
select: {
id: true,
name: true,
nationId: true,
cityId: true,
troopId: true,
npcState: true,
},
})
).toEqual([
{
id: existingNationLeaderId,
name: '㉥부대장 41',
nationId: existingNationId,
cityId: occupiedCityId,
troopId: existingNationLeaderId,
npcState: 5,
},
{
id: createdNationLeaderId,
name: '㉥부대장 42',
nationId: createdNationId,
cityId: targetCityId,
troopId: createdNationLeaderId,
npcState: 5,
},
]);
expect(
await db.troop.count({
where: { troopLeaderId: { in: [existingNationLeaderId, createdNationLeaderId] } },
})
).toBe(2);
for (const leaderId of [existingNationLeaderId, createdNationLeaderId]) {
expect(
await db.generalTurn.count({
where: { generalId: leaderId, actionCode: 'che_집합' },
})
).toBe(30);
expect(await db.rankData.count({ where: { generalId: leaderId } })).toBe(44);
}
expect(await db.worldState.findUniqueOrThrow({ where: { id: stateRow.id } })).toMatchObject({
meta: expect.objectContaining({ lastNPCTroopLeaderID: 42 }),
});
expect(
await db.logEntry.findFirst({
where: { year: 200, month: 1, text: { contains: '공백지에 임의의 국가' } },
select: { text: true },
})
).not.toBeNull();
).toEqual({
text: '<C>●</>200년 1월:<L><b>【공지】</b></>공백지에 임의의 국가가 생성되었습니다.',
});
if (referenceTrace) {
expect(referenceTrace.phases).toEqual({
afterRaise: {
createdNationCount: 1,
createdGeneralCount: 1,
generalCountsPerCreatedNation: [1],
historyLogs: [
'<C>●</>200년 1월:<L><b>【공지】</b></>공백지에 임의의 국가가 생성되었습니다.',
],
},
afterProvide: {
createdLeaderCount: 2,
leaderCountsPerActiveNation: [1],
troopCount: 2,
gatherTurnCounts: [30],
leaderCounterDelta: 2,
},
});
}
} finally {
await dbHooks.close();
await db.worldState.delete({ where: { id: stateRow.id } });
tools/integration-tests/test/monthlyNationBettingApiLifecycle.integration.test.ts
+559
View File
@@ -0,0 +1,559 @@
import { execFileSync } from 'node:child_process';
import fs from 'node:fs';
import path from 'node:path';
import { afterAll, beforeAll, describe, expect, it } from 'vitest';
import type { GameSessionTokenPayload } from '@sammo-ts/common/auth/gameToken';
import { InMemoryFlushStore } from '@sammo-ts/game-api/auth/flushStore.js';
import { RedisAccessTokenStore } from '@sammo-ts/game-api/auth/accessTokenStore.js';
import { InMemoryBattleSimTransport } from '@sammo-ts/game-api/battleSim/inMemoryTransport.js';
import type { GameApiContext } from '@sammo-ts/game-api/context.js';
import { InMemoryTurnDaemonTransport } from '@sammo-ts/game-api/daemon/inMemoryTransport.js';
import { appRouter } from '@sammo-ts/game-api/router.js';
import { createDatabaseTurnHooks } from '@sammo-ts/game-engine/turn/databaseHooks.js';
import { InMemoryTurnWorld } from '@sammo-ts/game-engine/turn/inMemoryWorld.js';
import {
createFinishNationBettingHandler,
createOpenNationBettingHandler,
} from '@sammo-ts/game-engine/turn/monthlyNationBettingAction.js';
import { createMonthlyEventHandler } from '@sammo-ts/game-engine/turn/monthlyEventHandler.js';
import type {
TurnEvent,
TurnGeneral,
TurnWorldSnapshot,
TurnWorldState,
} from '@sammo-ts/game-engine/turn/types.js';
import {
createGamePostgresConnector,
type GamePrismaClient,
type RedisConnector,
} from '@sammo-ts/infra';
import type { City, Nation } from '@sammo-ts/logic';
import { findTurnDifferentialWorkspaceRoot } from '../src/turn-differential/referenceSnapshot.js';
const databaseUrl = process.env.INPUT_EVENT_DATABASE_URL;
const workspaceRoot =
process.env.TURN_DIFFERENTIAL_WORKSPACE_ROOT ?? findTurnDifferentialWorkspaceRoot(process.cwd());
const integration = describe.skipIf(!databaseUrl);
const nationIds = [990_091, 990_092] as const;
const cityIds = [990_091, 990_092] as const;
const generalIds = [9_991, 9_992] as const;
const userIds = ['monthly-betting-api-user-1', 'monthly-betting-api-user-2'] as const;
const bettingId = 990_091;
const sourceEventId = 990_091;
const finishEventId = 990_093;
type ReferenceBettingLifecycle = {
phases: {
afterOpen: {
candidateNationIds: number[];
systemBonus: number;
finishEventCount: number;
historyLogs: string[];
};
afterBets: {
bets: Array<{
generalId: number;
ownerId: number | null;
selectionKey: string;
amount: number;
}>;
inheritancePrevious: number[];
spentRank: number[];
};
afterFinish: {
result: boolean;
finished: boolean;
winner: number[];
inheritancePrevious: number[];
earnedRank: number[];
historyLogs: string[];
};
};
};
const runReferenceLifecycle = (): ReferenceBettingLifecycle | null => {
if (process.env.TURN_DIFFERENTIAL_REFERENCE !== '1' || !workspaceRoot) {
return null;
}
const stackDirectory = path.join(workspaceRoot, 'docker_compose_files/reference');
const runnerScript =
process.env.MONTHLY_BETTING_LIFECYCLE_RUNNER_SCRIPT ??
path.join(workspaceRoot, 'ref/sam/hwe/compare/monthly_event_trace.php');
const fixturePath =
process.env.MONTHLY_BETTING_LIFECYCLE_FIXTURE ??
path.join(path.dirname(runnerScript), 'fixtures/monthly_nation_betting_lifecycle.json');
const stdout = execFileSync('./scripts/run-turn-differential-case.sh', ['-'], {
cwd: stackDirectory,
input: fs.readFileSync(fixturePath, 'utf8'),
encoding: 'utf8',
stdio: ['pipe', 'pipe', 'pipe'],
env: {
...process.env,
COMPOSE_PROJECT_NAME: 'sam-rebuild-reference',
TURN_DIFFERENTIAL_RUNNER_SCRIPT: runnerScript,
TURN_DIFFERENTIAL_COMPARE_DIR: path.dirname(runnerScript),
},
});
return JSON.parse(stdout) as ReferenceBettingLifecycle;
};
const buildNation = (id: number, power: number): Nation => ({
id,
name: id === nationIds[0] ? '위' : '촉',
color: id === nationIds[0] ? '#111111' : '#222222',
capitalCityId: id,
chiefGeneralId: id,
gold: id === nationIds[0] ? 1_000 : 3_000,
rice: id === nationIds[0] ? 2_000 : 4_000,
power,
level: 2,
typeCode: id === nationIds[0] ? 'che_유가' : 'che_병가',
meta: { tech: id === nationIds[0] ? 100 : 200 },
});
const buildCity = (id: number, nationId: number): City => ({
id,
name: id === cityIds[0] ? '허창' : '성도',
nationId,
level: 3,
state: 0,
population: 1_000,
populationMax: 2_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: { region: 1, trust: 50, trade: 100 },
});
const buildGeneral = (id: number, userId: string, nationId: number): TurnGeneral => ({
id,
userId,
name: id === generalIds[0] ? '장수1' : '장수2',
nationId,
cityId: nationId,
troopId: 0,
stats: { leadership: 50, strength: 50, intelligence: 50 },
experience: 0,
dedication: 0,
officerLevel: 1,
role: {
personality: null,
specialDomestic: null,
specialWar: null,
items: { horse: null, weapon: null, book: null, item: null },
},
injury: 0,
gold: 0,
rice: 0,
crew: 0,
crewTypeId: 1_100,
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'),
meta: { killturn: 1_000 },
});
const buildAuth = (index: 0 | 1): GameSessionTokenPayload => ({
version: 1,
profile: 'che:2',
issuedAt: '2026-07-27T00:00:00.000Z',
expiresAt: '2026-07-28T00:00:00.000Z',
sessionId: `monthly-betting-api-session-${index + 1}`,
user: {
id: userIds[index],
username: `bettor-${index + 1}`,
displayName: `Bettor ${index + 1}`,
roles: ['user'],
},
sanctions: {},
});
const event: TurnEvent = {
id: sourceEventId,
targetCode: 'month',
priority: 1_000,
condition: true,
action: [['OpenNationBetting', 1, 100]],
meta: {},
};
integration('monthly nation betting API lifecycle', () => {
let db: GamePrismaClient;
let closeDb: (() => Promise<void>) | undefined;
const buildContext = (index: 0 | 1): GameApiContext => {
const redisClient = {
get: async () => null,
set: async () => null,
};
return {
requestId: `monthly-betting-api-${index + 1}`,
db,
redis: redisClient as unknown as RedisConnector['client'],
turnDaemon: new InMemoryTurnDaemonTransport(),
battleSim: new InMemoryBattleSimTransport(),
profile: { id: 'che', scenario: '2', name: 'che:2' },
uploadDir: 'uploads',
uploadPath: '/uploads',
uploadPublicUrl: null,
auth: buildAuth(index),
accessTokenStore: new RedisAccessTokenStore(redisClient, 'che:2'),
flushStore: new InMemoryFlushStore(),
gameTokenSecret: 'test-secret',
};
};
const cleanFixture = async () => {
await db.inputEvent.deleteMany({ where: { actorUserId: { in: [...userIds] } } });
await db.event.deleteMany({ where: { id: { in: [sourceEventId, sourceEventId + 1, finishEventId] } } });
await db.nationBetting.deleteMany({ where: { id: bettingId } });
await db.rankData.deleteMany({ where: { generalId: { in: [...generalIds] } } });
await db.inheritanceLog.deleteMany({ where: { userId: { in: [...userIds] } } });
await db.inheritancePoint.deleteMany({ where: { userId: { in: [...userIds] } } });
await db.message.deleteMany({ where: { mailbox: { in: [...generalIds] } } });
await db.logEntry.deleteMany({
where: {
OR: [
{ text: { contains: '천하통일 후보를 점치는' } },
{ text: { contains: '천통국 예상 내기의 결과' } },
],
},
});
await db.diplomacy.deleteMany({
where: {
OR: [{ srcNationId: { in: [...nationIds] } }, { destNationId: { in: [...nationIds] } }],
},
});
await db.general.deleteMany({ where: { id: { in: [...generalIds] } } });
await db.city.deleteMany({ where: { id: { in: [...cityIds] } } });
await db.nation.deleteMany({ where: { id: { in: [...nationIds] } } });
await db.worldState.deleteMany({ where: { scenarioCode: 'monthly-nation-betting-api-lifecycle' } });
};
beforeAll(async () => {
const connector = createGamePostgresConnector({ url: databaseUrl! });
await connector.connect();
db = connector.prisma;
closeDb = () => connector.disconnect();
await cleanFixture();
});
afterAll(async () => {
await cleanFixture();
await closeDb?.();
});
it('opens in the engine, accepts session-owned API bets, and settles in the next monthly event', async () => {
const reference = runReferenceLifecycle();
const nations = [buildNation(nationIds[0], 100), buildNation(nationIds[1], 300)];
const cities = [buildCity(cityIds[0], nationIds[0]), buildCity(cityIds[1], nationIds[1])];
const generals = [
buildGeneral(generalIds[0], userIds[0], nationIds[0]),
buildGeneral(generalIds[1], userIds[1], nationIds[1]),
];
await db.nation.createMany({
data: nations.map((nation) => ({
id: nation.id,
name: nation.name,
color: nation.color,
capitalCityId: nation.capitalCityId,
chiefGeneralId: nation.chiefGeneralId,
gold: nation.gold,
rice: nation.rice,
tech: nation.id === nationIds[0] ? 100 : 200,
level: nation.level,
typeCode: nation.typeCode,
meta: {},
})),
});
await db.city.createMany({
data: cities.map((city) => ({
id: city.id,
name: city.name,
level: city.level,
nationId: city.nationId,
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,
meta: {},
})),
});
await db.general.createMany({
data: generals.map((general) => ({
id: general.id,
userId: general.userId,
name: general.name,
nationId: general.nationId,
cityId: general.cityId,
npcState: general.npcState,
leadership: general.stats.leadership,
strength: general.stats.strength,
intel: general.stats.intelligence,
officerLevel: general.officerLevel,
turnTime: general.turnTime,
meta: general.meta,
})),
});
await db.inheritancePoint.createMany({
data: userIds.map((userId) => ({ userId, key: 'previous', value: 1_000 })),
});
const row = await db.worldState.create({
data: {
scenarioCode: 'monthly-nation-betting-api-lifecycle',
currentYear: 199,
currentMonth: 12,
tickSeconds: 600,
config: {},
meta: { lastBettingId: bettingId - 1 },
},
});
const state: TurnWorldState = {
id: row.id,
currentYear: 199,
currentMonth: 12,
tickSeconds: 600,
lastTurnTime: new Date('2026-07-27T00:00:00.000Z'),
meta: { lastBettingId: bettingId - 1 },
};
const scenarioConfig: TurnWorldSnapshot['scenarioConfig'] = {
stat: { total: 300, min: 10, max: 100, npcTotal: 150, npcMax: 75, npcMin: 10, chiefMin: 70 },
iconPath: '.',
map: {},
const: {},
environment: { mapName: 'test', unitSet: 'default' },
};
let world: InMemoryTurnWorld | null = null;
const open = createOpenNationBettingHandler({ getWorld: () => world });
const finish = createFinishNationBettingHandler({ getWorld: () => world });
world = new InMemoryTurnWorld(
state,
{
scenarioConfig,
map: { id: 'test', name: 'test', cities: [] },
generals,
cities,
nations,
troops: [],
diplomacy: [],
events: [event],
initialEvents: [],
},
{
schedule: { entries: [{ startMinute: 0, tickMinutes: 10 }] },
calendarHandler: createMonthlyEventHandler({
getWorld: () => world,
startYear: 190,
actions: new Map([
['OpenNationBetting', open],
['FinishNationBetting', finish],
]),
}),
}
);
const hooks = await createDatabaseTurnHooks(databaseUrl!, world);
try {
await world.advanceMonth(new Date('0200-01-01T00:00:00.000Z'));
await hooks.hooks.flushChanges?.({
lastTurnTime: state.lastTurnTime.toISOString(),
processedGenerals: 0,
processedTurns: 1,
durationMs: 0,
partial: false,
});
const opened = await db.nationBetting.findUniqueOrThrow({ where: { id: bettingId } });
const candidates = Array.isArray(opened.candidates) ? opened.candidates : [];
const candidateNationIds = candidates.flatMap((candidate) => {
if (!candidate || typeof candidate !== 'object' || !('aux' in candidate)) {
return [];
}
const aux = candidate.aux;
return aux && typeof aux === 'object' && 'nation' in aux && typeof aux.nation === 'number'
? [aux.nation]
: [];
});
const openHistory = await db.logEntry.findMany({
where: { text: { contains: '천하통일 후보를 점치는' } },
orderBy: { id: 'asc' },
select: { text: true },
});
const createdFinishEvent = await db.event.findUniqueOrThrow({
where: { id: sourceEventId + 1 },
select: { action: true },
});
expect(createdFinishEvent.action).toEqual([
['FinishNationBetting', bettingId],
['DeleteEvent'],
]);
expect({
candidateNationIds,
systemBonus: (
await db.nationBet.findFirstOrThrow({
where: { bettingId, generalId: 0 },
select: { amount: true },
})
).amount,
finishEventCount: 1,
historyLogs: openHistory.map((entry) => entry.text),
}).toEqual({
candidateNationIds: [nationIds[1], nationIds[0]],
systemBonus: reference?.phases.afterOpen.systemBonus ?? 100,
finishEventCount: reference?.phases.afterOpen.finishEventCount ?? 1,
historyLogs:
reference?.phases.afterOpen.historyLogs ??
[
'<C>●</>200년 1월:<B><b>【내기】</b></>천하통일 후보를 점치는 <C>내기</>가 진행중입니다! 호사가의 참여를 기다립니다!',
],
});
await expect(
appRouter.createCaller(buildContext(0)).betting.bet({
bettingId,
bettingType: [1],
amount: 100,
})
).resolves.toEqual({ result: true });
await expect(
appRouter.createCaller(buildContext(1)).betting.bet({
bettingId,
bettingType: [0],
amount: 100,
})
).resolves.toEqual({ result: true });
const bets = await db.nationBet.findMany({
where: { bettingId },
orderBy: { generalId: 'asc' },
select: { generalId: true, userId: true, selectionKey: true, amount: true },
});
const afterBets = {
selections: bets.map((bet) => ({ selectionKey: bet.selectionKey, amount: bet.amount })),
inheritancePrevious: await Promise.all(
userIds.map(async (userId) => {
const point = await db.inheritancePoint.findUniqueOrThrow({
where: { userId_key: { userId, key: 'previous' } },
});
return point.value;
})
),
spentRank: await Promise.all(
generalIds.map(async (generalId) => {
const rank = await db.rankData.findUniqueOrThrow({
where: { generalId_type: { generalId, type: 'inherit_spent_dyn' } },
});
return rank.value;
})
),
};
expect(afterBets).toEqual({
selections: (reference?.phases.afterBets.bets ?? [
{ selectionKey: '[-1]', amount: 100 },
{ selectionKey: '[1]', amount: 100 },
{ selectionKey: '[0]', amount: 100 },
]).map((bet) => ({ selectionKey: bet.selectionKey, amount: bet.amount })),
inheritancePrevious: reference?.phases.afterBets.inheritancePrevious ?? [900, 900],
spentRank: reference?.phases.afterBets.spentRank ?? [100, 100],
});
world.updateNation(nationIds[0], { level: 0 });
expect(world.removeEvent(sourceEventId)).toBe(true);
expect(
world.addEvent({
id: finishEventId,
targetCode: 'month',
priority: 1_000,
condition: true,
action: [['FinishNationBetting', bettingId]],
meta: {},
})
).toBe(true);
await world.advanceMonth(new Date('0200-02-01T00:00:00.000Z'));
await hooks.hooks.flushChanges?.({
lastTurnTime: state.lastTurnTime.toISOString(),
processedGenerals: 0,
processedTurns: 1,
durationMs: 0,
partial: false,
});
const settled = await db.nationBetting.findUniqueOrThrow({ where: { id: bettingId } });
const finishHistory = await db.logEntry.findMany({
where: {
OR: [
{ text: { contains: '천하통일 후보를 점치는' } },
{ text: { contains: '천통국 예상 내기의 결과' } },
],
},
orderBy: { id: 'asc' },
select: { text: true },
});
const afterFinish = {
finished: settled.finished,
winner: settled.winner,
inheritancePrevious: await Promise.all(
userIds.map(async (userId) => {
const point = await db.inheritancePoint.findUniqueOrThrow({
where: { userId_key: { userId, key: 'previous' } },
});
return point.value;
})
),
earnedRank: await Promise.all(
generalIds.map(async (generalId) => {
const rank = await db.rankData.findUnique({
where: { generalId_type: { generalId, type: 'inherit_earned_act' } },
});
return rank?.value ?? 0;
})
),
historyLogs: finishHistory.map((entry) => entry.text),
};
expect(afterFinish).toEqual({
finished: reference?.phases.afterFinish.finished ?? true,
winner: reference?.phases.afterFinish.winner ?? [0],
inheritancePrevious: reference?.phases.afterFinish.inheritancePrevious ?? [900, 1_200],
earnedRank: reference?.phases.afterFinish.earnedRank ?? [0, 300],
historyLogs:
reference?.phases.afterFinish.historyLogs ??
[
'<C>●</>200년 1월:<B><b>【내기】</b></>천하통일 후보를 점치는 <C>내기</>가 진행중입니다! 호사가의 참여를 기다립니다!',
'<C>●</>200년 2월:<B><b>【내기】</b></> 200년 1월에 열렸던 천통국 예상 내기의 결과가 나왔습니다!',
],
});
} finally {
await hooks.close();
}
});
});