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

feat(engine): finalize unification archives atomically

Browse Source
This commit is contained in:
Hide_D
2026-07-31 14:10:22 +00:00
parent 8ea8e6e26f
commit 02515303fd
20 changed files with 1516 additions and 843 deletions
Download Patch File Download Diff File Expand all files Collapse all files
app/game-engine/src/turn/unificationHandler.ts
+61 -772
View File
@@ -1,794 +1,83 @@
import { createGamePostgresConnector } from '@sammo-ts/infra';
import { asRecord, HALL_OF_FAME_TYPES, type HallOfFameType } from '@sammo-ts/common';
import type { LogEntryDraft } from '@sammo-ts/logic';
import { LogCategory, LogFormat, LogScope } from '@sammo-ts/logic';
import { asNumber, asRecord, JosaUtil } from '@sammo-ts/common';
import { LogCategory, LogFormat, LogScope, type LogEntryDraft } from '@sammo-ts/logic';
import type { TurnCalendarHandler } from './inMemoryWorld.js';
import type { InMemoryTurnWorld } from './inMemoryWorld.js';
const UNIFIER_POINT = 2000;
const readMetaNumber = (meta: Record<string, unknown>, key: string): number => {
const value = meta[key];
if (typeof value !== 'number' || !Number.isFinite(value)) {
return 0;
}
return value;
};
const readMetaNumberOrNull = (meta: Record<string, unknown>, key: string): number | null => {
const value = meta[key];
if (typeof value === 'number' && Number.isFinite(value)) {
return Math.floor(value);
}
if (typeof value === 'string') {
const parsed = Number(value);
if (Number.isFinite(parsed)) {
return Math.floor(parsed);
}
}
return null;
};
const computeHallRate = (numerator: number, denominator: number): number => {
if (denominator <= 0) {
return 0;
}
return numerator / denominator;
};
const computeDexPoint = (meta: Record<string, unknown>): number => {
let total = 0;
for (const [key, value] of Object.entries(meta)) {
if (!key.startsWith('dex')) {
continue;
}
if (typeof value === 'number' && Number.isFinite(value)) {
total += value;
}
}
return total * 0.001;
};
import type { InMemoryTurnWorld, TurnCalendarHandler } from './inMemoryWorld.js';
import { queueYearbookSnapshot } from './yearbookHandler.js';
const buildUnificationLog = (nationName: string): LogEntryDraft => ({
scope: LogScope.SYSTEM,
category: LogCategory.HISTORY,
format: LogFormat.YEAR_MONTH,
text: `<C>●</><Y><b>【통일】</b></><D><b>${nationName}</b></>이 전토를 통일하였습니다.`,
text: `<C>●</><Y><b>【통일】</b></><D><b>${nationName}</b></>${JosaUtil.pick(nationName, '이')} 전토를 통일하였습니다.`,
meta: {},
});
const buildNationHistoryLog = (nationId: number, nationName: string): LogEntryDraft => ({
scope: LogScope.NATION,
category: LogCategory.HISTORY,
format: LogFormat.YEAR_MONTH,
nationId,
text: `<D><b>${nationName}</b></>${JosaUtil.pick(nationName, '이')} 전토를 통일`,
meta: {},
});
const buildGeneralActionLog = (generalId: number, nationId: number, nationName: string): LogEntryDraft => ({
scope: LogScope.GENERAL,
category: LogCategory.ACTION,
format: LogFormat.YEAR_MONTH,
generalId,
nationId,
text: `<D><b>${nationName}</b></>${JosaUtil.pick(nationName, '이')} 전토를 통일하였습니다.`,
meta: {},
});
const resolveServerId = (world: InMemoryTurnWorld, fallback: string): string => {
const serverId = world.getState().meta.serverId;
return typeof serverId === 'string' && serverId.trim() ? serverId.trim() : fallback;
};
export const createUnificationHandler = (options: {
databaseUrl: string;
profileName: string;
getWorld: () => InMemoryTurnWorld | null;
}): { handler: TurnCalendarHandler; close: () => Promise<void> } => {
const connector = createGamePostgresConnector({ url: options.databaseUrl });
const ready = connector.connect();
const settleInheritance = async (winnerNationId: number, year: number, month: number): Promise<void> => {
await ready;
const prisma = connector.prisma;
const generals = await prisma.general.findMany({
where: {
userId: { not: null },
npcState: { lt: 2 },
},
select: {
id: true,
userId: true,
nationId: true,
officerLevel: true,
meta: true,
},
});
const userIds = Array.from(new Set(generals.map((general) => general.userId).filter(Boolean))) as string[];
if (userIds.length === 0) {
return;
}
const pointRows = await prisma.inheritancePoint.findMany({
where: {
userId: { in: userIds },
},
select: {
userId: true,
key: true,
value: true,
},
});
const pointMap = new Map<string, Map<string, number>>();
for (const row of pointRows) {
const bucket = pointMap.get(row.userId) ?? new Map();
bucket.set(row.key, row.value);
pointMap.set(row.userId, bucket);
}
for (const general of generals) {
if (!general.userId) {
continue;
}
const meta = asRecord(general.meta);
const livedMonth = readMetaNumber(meta, 'inherit_lived_month');
const maxDomestic = readMetaNumber(meta, 'max_domestic_critical');
const activeAction = readMetaNumber(meta, 'inherit_active_action');
const combat = readMetaNumber(meta, 'rank_warnum') * 5;
const sabotage = readMetaNumber(meta, 'firenum') * 20;
const dex = computeDexPoint(meta);
const points = pointMap.get(general.userId) ?? new Map();
const previous = points.get('previous') ?? 0;
const unifier = points.get('unifier') ?? 0;
const earned =
livedMonth +
maxDomestic +
activeAction * 3 +
combat +
sabotage +
dex +
unifier +
(general.nationId === winnerNationId && general.officerLevel > 4 ? UNIFIER_POINT : 0);
const total = previous + earned;
await prisma.inheritancePoint.upsert({
where: {
userId_key: {
userId: general.userId,
key: 'previous',
},
},
update: { value: total },
create: { userId: general.userId, key: 'previous', value: total },
});
await prisma.inheritancePoint.deleteMany({
where: {
userId: general.userId,
key: { not: 'previous' },
},
});
await prisma.inheritanceResult.create({
data: {
serverId: options.profileName,
owner: general.userId,
generalId: general.id,
year,
month,
value: {
previous,
lived_month: livedMonth,
max_domestic_critical: maxDomestic,
active_action: activeAction,
combat,
sabotage,
dex,
unifier,
unifierAward:
general.nationId === winnerNationId && general.officerLevel > 4 ? UNIFIER_POINT : 0,
},
},
});
await prisma.inheritanceLog.create({
data: {
userId: general.userId,
year,
month,
text: `천하 통일 정산: ${Math.floor(total).toLocaleString()} 포인트`,
},
});
}
};
const settleHallOfFame = async (winnerNationId: number): Promise<void> => {
const world = options.getWorld();
if (!world) {
return;
}
await ready;
const prisma = connector.prisma;
const state = world.getState();
const meta = asRecord(state.meta);
const serverId =
typeof meta.serverId === 'string' && meta.serverId.trim() ? meta.serverId.trim() : options.profileName;
const season = readMetaNumberOrNull(meta, 'season') ?? 1;
const scenario = readMetaNumberOrNull(meta, 'scenarioId') ?? 0;
const scenarioName =
typeof asRecord(meta.scenarioMeta).title === 'string' ? String(asRecord(meta.scenarioMeta).title) : '';
const startTime = typeof meta.starttime === 'string' ? meta.starttime : null;
const unitedTime = new Date().toISOString();
const [serverCount, nationRows, generalRows, rankRows] = await Promise.all([
prisma.gameHistory.count(),
prisma.nation.findMany({ select: { id: true, name: true, color: true } }),
prisma.general.findMany({
where: { npcState: { lt: 2 } },
select: {
id: true,
userId: true,
nationId: true,
name: true,
picture: true,
imageServer: true,
experience: true,
dedication: true,
},
}),
prisma.rankData.findMany({
where: { generalId: { gt: 0 } },
select: { generalId: true, type: true, value: true },
}),
]);
const nationMap = new Map<number, { name: string; color: string }>();
for (const nation of nationRows) {
nationMap.set(nation.id, { name: nation.name, color: nation.color });
}
const rankMap = new Map<number, Record<string, number>>();
for (const row of rankRows) {
const entry = rankMap.get(row.generalId) ?? {};
entry[row.type] = row.value;
rankMap.set(row.generalId, entry);
}
const hallTypes: Array<[HallOfFameType, 'natural' | 'rank' | 'calc']> = HALL_OF_FAME_TYPES.map((type) => {
if (type === 'experience' || type === 'dedication' || type.startsWith('dex')) {
return [type, 'natural'];
}
if (type.endsWith('rate')) {
return [type, 'calc'];
}
return [type, 'rank'];
});
for (const general of generalRows) {
const ranks = rankMap.get(general.id) ?? {};
const warnum = ranks.warnum ?? 0;
const killnum = ranks.killnum ?? 0;
const killcrew = ranks.killcrew ?? 0;
const deathcrew = ranks.deathcrew ?? 0;
const killcrewPerson = ranks.killcrew_person ?? 0;
const deathcrewPerson = ranks.deathcrew_person ?? 0;
const ttw = ranks.ttw ?? 0;
const ttd = ranks.ttd ?? 0;
const ttl = ranks.ttl ?? 0;
const tlw = ranks.tlw ?? 0;
const tld = ranks.tld ?? 0;
const tll = ranks.tll ?? 0;
const tsw = ranks.tsw ?? 0;
const tsd = ranks.tsd ?? 0;
const tsl = ranks.tsl ?? 0;
const tiw = ranks.tiw ?? 0;
const tid = ranks.tid ?? 0;
const til = ranks.til ?? 0;
const betGold = ranks.betgold ?? 0;
const betWinGold = ranks.betwingold ?? 0;
const ttTotal = ttw + ttd + ttl;
const tlTotal = tlw + tld + tll;
const tsTotal = tsw + tsd + tsl;
const tiTotal = tiw + tid + til;
const calcValues: Record<string, number> = {
winrate: computeHallRate(killnum, warnum),
killrate: computeHallRate(killcrew, Math.max(1, deathcrew)),
killrate_person: computeHallRate(killcrewPerson, Math.max(1, deathcrewPerson)),
ttrate: computeHallRate(ttw, Math.max(1, ttTotal)),
tlrate: computeHallRate(tlw, Math.max(1, tlTotal)),
tsrate: computeHallRate(tsw, Math.max(1, tsTotal)),
tirate: computeHallRate(tiw, Math.max(1, tiTotal)),
betrate: computeHallRate(betWinGold, Math.max(1, betGold)),
};
const nation = nationMap.get(general.nationId) ?? { name: '재야', color: '#000000' };
const aux = {
name: general.name,
nationName: nation.name,
bgColor: nation.color,
fgColor: nation.color,
picture: general.picture,
imgsvr: general.imageServer,
startTime,
unitedTime,
ownerName: general.userId ?? null,
serverID: serverId,
serverIdx: serverCount,
serverName: options.profileName,
scenarioName,
};
for (const [typeName, valueType] of hallTypes) {
const value =
valueType === 'natural'
? typeName === 'experience'
? general.experience
: typeName === 'dedication'
? general.dedication
: (ranks[typeName] ?? 0)
: valueType === 'rank'
? (ranks[typeName] ?? 0)
: (calcValues[typeName] ?? 0);
if ((typeName === 'winrate' || typeName === 'killrate') && warnum < 10) {
continue;
}
if (typeName === 'ttrate' && ttTotal < 50) {
continue;
}
if (typeName === 'tlrate' && tlTotal < 50) {
continue;
}
if (typeName === 'tsrate' && tsTotal < 50) {
continue;
}
if (typeName === 'tirate' && tiTotal < 50) {
continue;
}
if (typeName === 'betrate' && betGold < 1000) {
continue;
}
if (value <= 0) {
continue;
}
const existing = await prisma.hallOfFame.findUnique({
where: {
serverId_type_generalNo: {
serverId,
type: typeName,
generalNo: general.id,
},
},
});
if (!existing) {
await prisma.hallOfFame.create({
data: {
serverId,
season,
scenario,
generalNo: general.id,
type: typeName,
value,
owner: general.userId ?? null,
aux,
},
});
continue;
}
if (value > existing.value) {
await prisma.hallOfFame.update({
where: { id: existing.id },
data: { value, aux },
});
}
}
}
await prisma.gameHistory.update({
where: { serverId },
data: {
winnerNation: winnerNationId,
date: new Date(),
},
});
};
const settleDynasty = async (winnerNationId: number): Promise<void> => {
const world = options.getWorld();
if (!world) {
return;
}
await ready;
const prisma = connector.prisma;
const state = world.getState();
const meta = asRecord(state.meta);
const serverId =
typeof meta.serverId === 'string' && meta.serverId.trim() ? meta.serverId.trim() : options.profileName;
const serverName =
typeof meta.serverName === 'string' && meta.serverName.trim()
? meta.serverName.trim()
: options.profileName;
const [serverCount, nationRows, cityRows, generalRows, rankRows, historyRows, oldNationRows] =
await Promise.all([
prisma.gameHistory.count(),
prisma.nation.findMany({
select: {
id: true,
name: true,
color: true,
level: true,
typeCode: true,
gold: true,
rice: true,
meta: true,
capitalCityId: true,
},
}),
prisma.city.findMany({
select: { nationId: true, population: true, populationMax: true },
}),
prisma.general.findMany({
select: {
id: true,
userId: true,
name: true,
nationId: true,
dedication: true,
officerLevel: true,
picture: true,
imageServer: true,
leadership: true,
strength: true,
intel: true,
experience: true,
gold: true,
rice: true,
crew: true,
crewTypeId: true,
train: true,
atmos: true,
age: true,
startAge: true,
npcState: true,
personalCode: true,
specialCode: true,
special2Code: true,
cityId: true,
troopId: true,
turnTime: true,
meta: true,
},
}),
prisma.rankData.findMany({
where: {
nationId: winnerNationId,
type: { in: ['killnum', 'firenum'] },
},
select: { generalId: true, type: true, value: true },
}),
prisma.logEntry.findMany({
where: {
nationId: winnerNationId,
scope: LogScope.NATION,
category: LogCategory.HISTORY,
},
orderBy: { id: 'asc' },
select: { text: true },
}),
prisma.oldNation.findMany({
where: { serverId },
select: { data: true },
}),
]);
const winnerNation = nationRows.find((nation) => nation.id === winnerNationId);
if (!winnerNation) {
return;
}
const powerMap = new Map<number, number>();
for (const nation of world.listNations()) {
powerMap.set(nation.id, nation.power);
}
const winnerGenerals = generalRows.filter((general) => general.nationId === winnerNationId);
const winnerGeneralIds = winnerGenerals.map((general) => general.id);
const noNationGenerals = generalRows.filter((general) => general.nationId === 0);
const cityCount = cityRows.filter((city) => city.nationId === winnerNationId).length;
const popSum = cityRows
.filter((city) => city.nationId === winnerNationId)
.reduce((sum, city) => sum + city.population, 0);
const popMaxSum = cityRows
.filter((city) => city.nationId === winnerNationId)
.reduce((sum, city) => sum + city.populationMax, 0);
const popText = `${popSum} / ${popMaxSum}`;
const popRate = popMaxSum > 0 ? `${Math.round((popSum / popMaxSum) * 10000) / 100} %` : '0 %';
const officerMap = new Map<number, { name: string; picture: string | null }>();
for (const general of winnerGenerals) {
if (general.officerLevel < 5) {
continue;
}
if (!officerMap.has(general.officerLevel)) {
officerMap.set(general.officerLevel, { name: general.name, picture: general.picture ?? null });
}
}
const generalNameMap = new Map<number, string>();
for (const general of generalRows) {
generalNameMap.set(general.id, general.name);
}
const buildTopList = (type: 'killnum' | 'firenum', limit: number): string => {
const rows = rankRows
.filter((row) => row.type === type && row.value > 0)
.sort((a, b) => b.value - a.value)
.slice(0, limit);
return rows
.map((row) => `${generalNameMap.get(row.generalId) ?? '무명'}【${row.value.toLocaleString('ko-KR')}】`)
.join(', ');
};
const tiger = buildTopList('killnum', 5);
const eagle = buildTopList('firenum', 7);
const gen = winnerGenerals
.slice()
.sort((a, b) => b.dedication - a.dedication)
.map((general) => general.name)
.join(', ');
const nationNames: string[] = [];
const nationTypeCounts = new Map<string, number>();
for (const row of oldNationRows) {
const data = asRecord(row.data);
const name = typeof data.name === 'string' ? data.name : '';
const type = typeof data.type === 'string' ? data.type : '';
if (name) {
nationNames.push(name);
}
if (type) {
nationTypeCounts.set(type, (nationTypeCounts.get(type) ?? 0) + 1);
}
}
if (!nationNames.includes(winnerNation.name)) {
nationNames.push(winnerNation.name);
}
if (winnerNation.typeCode) {
nationTypeCounts.set(winnerNation.typeCode, (nationTypeCounts.get(winnerNation.typeCode) ?? 0) + 1);
}
const nationHist = Array.from(nationTypeCounts.entries())
.map(([key, count]) => `${key}(${count})`)
.join(', ');
const phase = `${serverName}${serverCount}기`;
const nationCount = `${Math.max(1, nationRows.length)} / ${Math.max(1, nationRows.length)}`;
const genCount = `${generalRows.length} / ${generalRows.length}`;
const history = historyRows.map((row) => row.text);
await prisma.oldNation.upsert({
where: {
serverId_nation_sourceId: {
serverId,
nation: winnerNationId,
sourceId: 0,
},
},
update: {
data: {
nation: winnerNationId,
name: winnerNation.name,
color: winnerNation.color,
type: winnerNation.typeCode,
level: winnerNation.level,
gold: winnerNation.gold,
rice: winnerNation.rice,
power: powerMap.get(winnerNationId) ?? 0,
capitalCityId: winnerNation.capitalCityId,
generals: winnerGeneralIds,
history,
meta: winnerNation.meta ?? {},
},
date: new Date(),
},
create: {
serverId,
nation: winnerNationId,
sourceId: 0,
data: {
nation: winnerNationId,
name: winnerNation.name,
color: winnerNation.color,
type: winnerNation.typeCode,
level: winnerNation.level,
gold: winnerNation.gold,
rice: winnerNation.rice,
power: powerMap.get(winnerNationId) ?? 0,
capitalCityId: winnerNation.capitalCityId,
generals: winnerGeneralIds,
history,
meta: winnerNation.meta ?? {},
},
},
});
await prisma.oldNation.upsert({
where: {
serverId_nation_sourceId: {
serverId,
nation: 0,
sourceId: 0,
},
},
update: {
data: {
nation: 0,
name: '재야',
color: '#000000',
type: 'neutral',
level: 0,
gold: 0,
rice: 0,
power: 0,
capitalCityId: null,
generals: noNationGenerals.map((general) => general.id),
history: [],
meta: {},
},
date: new Date(),
},
create: {
serverId,
nation: 0,
sourceId: 0,
data: {
nation: 0,
name: '재야',
color: '#000000',
type: 'neutral',
level: 0,
gold: 0,
rice: 0,
power: 0,
capitalCityId: null,
generals: noNationGenerals.map((general) => general.id),
history: [],
meta: {},
},
},
});
const oldGeneralTargets = generalRows.filter(
(general) => general.nationId === 0 || general.nationId === winnerNationId
);
const generalHistoryRows = oldGeneralTargets.length
? await prisma.logEntry.findMany({
where: {
generalId: { in: oldGeneralTargets.map((general) => general.id) },
scope: LogScope.GENERAL,
category: LogCategory.HISTORY,
},
orderBy: { id: 'desc' },
select: { generalId: true, text: true },
})
: [];
const historyByGeneral = new Map<number, string[]>();
for (const row of generalHistoryRows) {
if (row.generalId === null) {
continue;
}
const history = historyByGeneral.get(row.generalId) ?? [];
history.push(row.text);
historyByGeneral.set(row.generalId, history);
}
await Promise.all(
oldGeneralTargets.map((general) =>
((snapshot) =>
prisma.oldGeneral.upsert({
where: {
by_no: {
serverId,
generalNo: general.id,
},
},
update: {
owner: general.userId ?? null,
name: general.name,
lastYearMonth: state.currentYear * 100 + state.currentMonth,
turnTime: general.turnTime,
data: snapshot,
},
create: {
serverId,
generalNo: general.id,
owner: general.userId ?? null,
name: general.name,
lastYearMonth: state.currentYear * 100 + state.currentMonth,
turnTime: general.turnTime,
data: snapshot,
},
}))({
...general,
turnTime: general.turnTime.toISOString(),
history: historyByGeneral.get(general.id) ?? [],
})
)
);
await prisma.emperor.create({
data: {
serverId,
phase,
nationCount,
nationName: nationNames.join(', '),
nationHist,
genCount,
personalHist: '',
specialHist: '',
name: winnerNation.name,
type: winnerNation.typeCode,
color: winnerNation.color,
year: state.currentYear,
month: state.currentMonth,
power: powerMap.get(winnerNationId) ?? 0,
gennum: winnerGenerals.length,
citynum: cityCount,
pop: popText,
poprate: popRate,
gold: winnerNation.gold,
rice: winnerNation.rice,
l12name: officerMap.get(12)?.name ?? '',
l12pic: officerMap.get(12)?.picture ?? '',
l11name: officerMap.get(11)?.name ?? '',
l11pic: officerMap.get(11)?.picture ?? '',
l10name: officerMap.get(10)?.name ?? '',
l10pic: officerMap.get(10)?.picture ?? '',
l9name: officerMap.get(9)?.name ?? '',
l9pic: officerMap.get(9)?.picture ?? '',
l8name: officerMap.get(8)?.name ?? '',
l8pic: officerMap.get(8)?.picture ?? '',
l7name: officerMap.get(7)?.name ?? '',
l7pic: officerMap.get(7)?.picture ?? '',
l6name: officerMap.get(6)?.name ?? '',
l6pic: officerMap.get(6)?.picture ?? '',
l5name: officerMap.get(5)?.name ?? '',
l5pic: officerMap.get(5)?.picture ?? '',
tiger,
eagle,
gen,
history,
aux: {
winnerNationId,
},
},
});
};
const handler: TurnCalendarHandler = {
}): { handler: TurnCalendarHandler } => ({
handler: {
onMonthChanged: (context) => {
const world = options.getWorld();
if (!world) {
return;
}
if (!world) return;
const state = world.getState();
const meta = asRecord(state.meta);
if (typeof meta.isUnited === 'number' && meta.isUnited !== 0) {
return;
}
if (asNumber(meta.isunited ?? meta.isUnited, 0) !== 0) return;
const activeNations = world.listNations().filter((nation) => nation.level > 0);
if (activeNations.length !== 1) {
return;
}
const winner = activeNations[0];
if (activeNations.length !== 1) return;
const winner = activeNations[0]!;
const cities = world.listCities();
const ownedCount = cities.filter((city) => city.nationId === winner.id).length;
if (ownedCount !== cities.length) {
return;
if (cities.length === 0 || cities.some((city) => city.nationId !== winner.id)) return;
const serverId = resolveServerId(world, options.profileName);
world.updateWorldMeta({
isUnited: 2,
isunited: 2,
refreshLimit: asNumber(meta.refreshLimit, 0) * 100,
});
world.pushLog(buildNationHistoryLog(winner.id, winner.name));
for (const general of world.listGenerals().filter((entry) => entry.nationId === winner.id)) {
world.pushLog(buildGeneralActionLog(general.id, winner.id, winner.name));
}
world.updateWorldMeta({ isUnited: 2 });
world.pushLog(buildUnificationLog(winner.name));
void settleInheritance(winner.id, context.currentYear, context.currentMonth);
void settleHallOfFame(winner.id);
void settleDynasty(winner.id);
queueYearbookSnapshot(world, options.profileName, context.currentYear, context.currentMonth);
world.queueUnificationFinalization({
generationKey: `unification:${serverId}`,
serverId,
profileName: options.profileName,
winnerNationId: winner.id,
year: context.currentYear,
month: context.currentMonth,
completedAt: new Date(state.lastTurnTime.getTime()),
});
},
};
const close = async (): Promise<void> => {
await ready;
await connector.disconnect();
};
return { handler, close };
};
},
});