795 lines
29 KiB
TypeScript
795 lines
29 KiB
TypeScript
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 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;
|
|
};
|
|
|
|
const buildUnificationLog = (nationName: string): LogEntryDraft => ({
|
|
scope: LogScope.SYSTEM,
|
|
category: LogCategory.HISTORY,
|
|
format: LogFormat.YEAR_MONTH,
|
|
text: `<C>●</><Y><b>【통일】</b></><D><b>${nationName}</b></>이 전토를 통일하였습니다.`,
|
|
meta: {},
|
|
});
|
|
|
|
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 = {
|
|
onMonthChanged: (context) => {
|
|
const world = options.getWorld();
|
|
if (!world) {
|
|
return;
|
|
}
|
|
const state = world.getState();
|
|
const meta = asRecord(state.meta);
|
|
if (typeof meta.isUnited === 'number' && meta.isUnited !== 0) {
|
|
return;
|
|
}
|
|
|
|
const activeNations = world.listNations().filter((nation) => nation.level > 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;
|
|
}
|
|
|
|
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);
|
|
},
|
|
};
|
|
|
|
const close = async (): Promise<void> => {
|
|
await ready;
|
|
await connector.disconnect();
|
|
};
|
|
|
|
return { handler, close };
|
|
};
|