485 lines
17 KiB
TypeScript
485 lines
17 KiB
TypeScript
import { TRPCError } from '@trpc/server';
|
|
import { asRecord } from '@sammo-ts/common';
|
|
|
|
import type { GameApiContext } from '../../context.js';
|
|
import { zWorldStateConfig, zWorldStateMeta } from '../../context.js';
|
|
import { loadMapLayout } from '../../maps/mapLayout.js';
|
|
import { loadPublicMap } from '../../maps/worldMap.js';
|
|
import { procedure, router } from '../../trpc.js';
|
|
import { loadTraitNames } from '../nation/shared.js';
|
|
import { z } from 'zod';
|
|
|
|
type WorldTrendSnapshot = {
|
|
year: number;
|
|
month: number;
|
|
userCnt: number;
|
|
maxUserCnt: number;
|
|
npcCnt: number;
|
|
nationCnt: number;
|
|
turnTerm: number;
|
|
fictionMode: string;
|
|
starttime: string;
|
|
opentime: string;
|
|
turntime: string;
|
|
otherTextInfo: string;
|
|
isUnited: number;
|
|
};
|
|
|
|
type NationSummary = {
|
|
id: number;
|
|
name: string;
|
|
color: string;
|
|
level: number;
|
|
capitalCityId: number;
|
|
generalCount: number;
|
|
cityCount: number;
|
|
};
|
|
|
|
type NationCountRow = {
|
|
nationId: number;
|
|
count: number;
|
|
};
|
|
|
|
type NpcListSort = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8;
|
|
|
|
type TrafficHistoryItem = {
|
|
year: number;
|
|
month: number;
|
|
refresh: number;
|
|
online: number;
|
|
date: string;
|
|
};
|
|
|
|
const PUBLIC_CACHE_TTL_SECONDS = 600;
|
|
|
|
const buildPublicCacheKey = (ctx: GameApiContext, key: string): string =>
|
|
`sammo:public:${key}:${ctx.profile.id}:${ctx.profile.scenario}`;
|
|
|
|
const loadWorldTrendSnapshot = async (ctx: GameApiContext): Promise<WorldTrendSnapshot> => {
|
|
const rawWorldState = await ctx.db.worldState.findFirst();
|
|
if (!rawWorldState) {
|
|
throw new TRPCError({
|
|
code: 'NOT_FOUND',
|
|
message: 'World state not found',
|
|
});
|
|
}
|
|
|
|
const config = zWorldStateConfig.parse(rawWorldState.config);
|
|
const meta = zWorldStateMeta.parse(rawWorldState.meta);
|
|
|
|
const [userCnt, npcCnt, nationCnt] = await Promise.all([
|
|
ctx.db.general.count({ where: { npcState: 0 } }),
|
|
ctx.db.general.count({ where: { npcState: { gt: 0 } } }),
|
|
ctx.db.nation.count({ where: { level: { gt: 0 } } }),
|
|
]);
|
|
|
|
return {
|
|
year: rawWorldState.currentYear,
|
|
month: rawWorldState.currentMonth,
|
|
userCnt,
|
|
maxUserCnt: config.maxUserCnt ?? 500,
|
|
npcCnt,
|
|
nationCnt,
|
|
turnTerm: rawWorldState.tickSeconds / 60,
|
|
fictionMode: config.fictionMode ?? '사실',
|
|
starttime: meta.starttime ?? '',
|
|
opentime: meta.opentime ?? '',
|
|
turntime: meta.turntime ?? '',
|
|
otherTextInfo: meta.otherTextInfo ?? '',
|
|
isUnited: meta.isUnited ?? 0,
|
|
};
|
|
};
|
|
|
|
const loadCachedWorldTrend = async (ctx: GameApiContext): Promise<WorldTrendSnapshot> => {
|
|
const cacheKey = buildPublicCacheKey(ctx, 'worldTrend');
|
|
const cached = await ctx.redis.get(cacheKey);
|
|
if (cached) {
|
|
try {
|
|
return JSON.parse(cached) as WorldTrendSnapshot;
|
|
} catch {
|
|
// Ignore cache parse errors.
|
|
}
|
|
}
|
|
|
|
const snapshot = await loadWorldTrendSnapshot(ctx);
|
|
await ctx.redis.set(cacheKey, JSON.stringify(snapshot), { EX: PUBLIC_CACHE_TTL_SECONDS });
|
|
return snapshot;
|
|
};
|
|
|
|
const loadCachedNationList = async (ctx: GameApiContext): Promise<NationSummary[]> => {
|
|
const cacheKey = buildPublicCacheKey(ctx, 'nationList');
|
|
const cached = await ctx.redis.get(cacheKey);
|
|
if (cached) {
|
|
try {
|
|
return JSON.parse(cached) as NationSummary[];
|
|
} catch {
|
|
// Ignore cache parse errors.
|
|
}
|
|
}
|
|
|
|
const [nations, generalCounts, cityCounts] = await Promise.all([
|
|
ctx.db.nation.findMany({
|
|
select: {
|
|
id: true,
|
|
name: true,
|
|
color: true,
|
|
level: true,
|
|
capitalCityId: true,
|
|
},
|
|
orderBy: [{ level: 'desc' }, { id: 'asc' }],
|
|
}),
|
|
ctx.db.$queryRaw<NationCountRow[]>`
|
|
SELECT nation_id as "nationId", COUNT(*)::int as "count"
|
|
FROM general
|
|
GROUP BY nation_id
|
|
`,
|
|
ctx.db.$queryRaw<NationCountRow[]>`
|
|
SELECT nation_id as "nationId", COUNT(*)::int as "count"
|
|
FROM city
|
|
GROUP BY nation_id
|
|
`,
|
|
]);
|
|
|
|
const generalCountMap = new Map<number, number>();
|
|
for (const row of generalCounts) {
|
|
generalCountMap.set(row.nationId, row.count);
|
|
}
|
|
|
|
const cityCountMap = new Map<number, number>();
|
|
for (const row of cityCounts) {
|
|
cityCountMap.set(row.nationId, row.count);
|
|
}
|
|
|
|
const summary = nations.map((nation) => ({
|
|
id: nation.id,
|
|
name: nation.name,
|
|
color: nation.color,
|
|
level: nation.level,
|
|
capitalCityId: nation.capitalCityId ?? 0,
|
|
generalCount: generalCountMap.get(nation.id) ?? 0,
|
|
cityCount: cityCountMap.get(nation.id) ?? 0,
|
|
}));
|
|
|
|
await ctx.redis.set(cacheKey, JSON.stringify(summary), { EX: PUBLIC_CACHE_TTL_SECONDS });
|
|
return summary;
|
|
};
|
|
|
|
const normalizeTraitKey = (value: string): string | null => (value && value !== 'None' ? value : null);
|
|
|
|
const readFiniteMetaNumber = (meta: Record<string, unknown>, key: string): number => {
|
|
const value = meta[key];
|
|
return typeof value === 'number' && Number.isFinite(value) ? value : 0;
|
|
};
|
|
|
|
const parseTrafficHistory = (value: unknown): TrafficHistoryItem[] => {
|
|
if (!Array.isArray(value)) {
|
|
return [];
|
|
}
|
|
|
|
const result: TrafficHistoryItem[] = [];
|
|
for (const item of value) {
|
|
const row = asRecord(item);
|
|
const year = readFiniteMetaNumber(row, 'year');
|
|
const month = readFiniteMetaNumber(row, 'month');
|
|
const refresh = readFiniteMetaNumber(row, 'refresh');
|
|
const online = readFiniteMetaNumber(row, 'online');
|
|
const date = typeof row.date === 'string' ? row.date : '';
|
|
if (year > 0 && month > 0 && date) {
|
|
result.push({ year, month, refresh, online, date });
|
|
}
|
|
}
|
|
return result;
|
|
};
|
|
|
|
const compareString = (left: string, right: string): number => {
|
|
if (left === right) {
|
|
return 0;
|
|
}
|
|
return left < right ? -1 : 1;
|
|
};
|
|
|
|
const sortNpcList = <T extends {
|
|
name: string;
|
|
nationId: number;
|
|
statTotal: number;
|
|
leadership: number;
|
|
strength: number;
|
|
intelligence: number;
|
|
experience: number;
|
|
dedication: number;
|
|
}>(rows: T[], sort: NpcListSort): T[] =>
|
|
rows.sort((left, right) => {
|
|
switch (sort) {
|
|
case 2:
|
|
return left.nationId - right.nationId;
|
|
case 3:
|
|
return right.statTotal - left.statTotal;
|
|
case 4:
|
|
return right.leadership - left.leadership;
|
|
case 5:
|
|
return right.strength - left.strength;
|
|
case 6:
|
|
return right.intelligence - left.intelligence;
|
|
case 7:
|
|
return right.experience - left.experience;
|
|
case 8:
|
|
return right.dedication - left.dedication;
|
|
case 1:
|
|
default:
|
|
return compareString(left.name, right.name);
|
|
}
|
|
});
|
|
|
|
export const publicRouter = router({
|
|
getMapLayout: procedure.query(async ({ ctx }) => {
|
|
return loadMapLayout(ctx.profile.scenario);
|
|
}),
|
|
getCachedMap: procedure.query(async ({ ctx }) => {
|
|
const map = await loadPublicMap(ctx, true);
|
|
if (!map) {
|
|
throw new TRPCError({
|
|
code: 'PRECONDITION_FAILED',
|
|
message: 'World state is not initialized.',
|
|
});
|
|
}
|
|
return map;
|
|
}),
|
|
getWorldTrend: procedure.query(async ({ ctx }) => {
|
|
return loadCachedWorldTrend(ctx);
|
|
}),
|
|
getNationList: procedure.query(async ({ ctx }) => {
|
|
return loadCachedNationList(ctx);
|
|
}),
|
|
getTraffic: procedure.query(async ({ ctx }) => {
|
|
const worldState = await ctx.db.worldState.findFirst();
|
|
if (!worldState) {
|
|
throw new TRPCError({
|
|
code: 'PRECONDITION_FAILED',
|
|
message: 'World state is not initialized.',
|
|
});
|
|
}
|
|
|
|
const meta = asRecord(worldState.meta);
|
|
const rawOnlineSince = meta.lastTurnTime ?? meta.turntime;
|
|
const parsedOnlineSince =
|
|
typeof rawOnlineSince === 'string' || rawOnlineSince instanceof Date
|
|
? new Date(rawOnlineSince)
|
|
: null;
|
|
const onlineSince =
|
|
parsedOnlineSince && Number.isFinite(parsedOnlineSince.getTime())
|
|
? parsedOnlineSince
|
|
: new Date(Date.now() - worldState.tickSeconds * 1_000);
|
|
const [accessTotal, currentOnline, topAccess] = await Promise.all([
|
|
ctx.db.generalAccessLog.aggregate({
|
|
_sum: {
|
|
refresh: true,
|
|
refreshScoreTotal: true,
|
|
},
|
|
}),
|
|
ctx.db.generalAccessLog.count({
|
|
where: {
|
|
lastRefresh: {
|
|
gte: onlineSince,
|
|
},
|
|
},
|
|
}),
|
|
ctx.db.generalAccessLog.findMany({
|
|
orderBy: [{ refresh: 'desc' }, { generalId: 'asc' }],
|
|
take: 5,
|
|
select: {
|
|
generalId: true,
|
|
refresh: true,
|
|
refreshScoreTotal: true,
|
|
},
|
|
}),
|
|
]);
|
|
|
|
const generalIds = topAccess.map((entry) => entry.generalId);
|
|
const generalRows =
|
|
generalIds.length > 0
|
|
? await ctx.db.general.findMany({
|
|
where: { id: { in: generalIds } },
|
|
select: { id: true, name: true },
|
|
})
|
|
: [];
|
|
const generalName = new Map(generalRows.map((general) => [general.id, general.name]));
|
|
const totalRefresh = accessTotal._sum.refresh ?? 0;
|
|
const totalRefreshScore = accessTotal._sum.refreshScoreTotal ?? 0;
|
|
const currentRefresh = Math.max(readFiniteMetaNumber(meta, 'refresh'), totalRefresh);
|
|
const history = parseTrafficHistory(meta.recentTraffic);
|
|
history.push({
|
|
year: worldState.currentYear,
|
|
month: worldState.currentMonth,
|
|
refresh: currentRefresh,
|
|
online: currentOnline,
|
|
date: new Date().toISOString(),
|
|
});
|
|
|
|
return {
|
|
history,
|
|
maxRefresh: Math.max(
|
|
1,
|
|
readFiniteMetaNumber(meta, 'maxrefresh'),
|
|
...history.map((entry) => entry.refresh)
|
|
),
|
|
maxOnline: Math.max(1, readFiniteMetaNumber(meta, 'maxonline'), ...history.map((entry) => entry.online)),
|
|
suspects: [
|
|
{
|
|
generalId: null,
|
|
name: '접속자 총합',
|
|
refresh: totalRefresh,
|
|
refreshScoreTotal: totalRefreshScore,
|
|
},
|
|
...topAccess.map((entry) => ({
|
|
generalId: entry.generalId,
|
|
name: generalName.get(entry.generalId) ?? `장수 ${entry.generalId}`,
|
|
refresh: entry.refresh,
|
|
refreshScoreTotal: entry.refreshScoreTotal,
|
|
})),
|
|
],
|
|
};
|
|
}),
|
|
getGeneralList: procedure.query(async ({ ctx }) => {
|
|
const [generals, nations] = await Promise.all([
|
|
ctx.db.general.findMany({
|
|
select: {
|
|
id: true,
|
|
name: true,
|
|
npcState: true,
|
|
nationId: true,
|
|
leadership: true,
|
|
strength: true,
|
|
intel: true,
|
|
},
|
|
}),
|
|
ctx.db.nation.findMany({
|
|
select: {
|
|
id: true,
|
|
name: true,
|
|
},
|
|
}),
|
|
]);
|
|
|
|
const nationMap = new Map<number, string>();
|
|
for (const nation of nations) {
|
|
nationMap.set(nation.id, nation.name);
|
|
}
|
|
|
|
return generals.map((general) => ({
|
|
id: general.id,
|
|
name: general.name,
|
|
npcState: general.npcState,
|
|
nationId: general.nationId,
|
|
nationName: nationMap.get(general.nationId) ?? '무주',
|
|
leadership: general.leadership,
|
|
strength: general.strength,
|
|
intelligence: general.intel,
|
|
}));
|
|
}),
|
|
getNpcList: procedure
|
|
.input(
|
|
z
|
|
.object({
|
|
sort: z.number().int().min(1).max(8).catch(1).optional(),
|
|
})
|
|
.optional()
|
|
)
|
|
.query(async ({ ctx, input }) => {
|
|
const sort = (input?.sort ?? 1) as NpcListSort;
|
|
const [generals, nations] = await Promise.all([
|
|
ctx.db.general.findMany({
|
|
where: { npcState: { gt: 0 } },
|
|
select: {
|
|
id: true,
|
|
name: true,
|
|
npcState: true,
|
|
nationId: true,
|
|
leadership: true,
|
|
strength: true,
|
|
intel: true,
|
|
experience: true,
|
|
dedication: true,
|
|
personalCode: true,
|
|
specialCode: true,
|
|
special2Code: true,
|
|
meta: true,
|
|
},
|
|
orderBy: { id: 'asc' },
|
|
}),
|
|
ctx.db.nation.findMany({
|
|
select: { id: true, name: true },
|
|
}),
|
|
]);
|
|
|
|
const personalityKeys = generals.map((general) => normalizeTraitKey(general.personalCode));
|
|
const domesticKeys = generals.map((general) => normalizeTraitKey(general.specialCode));
|
|
const warKeys = generals.map((general) => normalizeTraitKey(general.special2Code));
|
|
const [personalityMap, domesticMap, warMap] = await Promise.all([
|
|
loadTraitNames(personalityKeys, 'personality'),
|
|
loadTraitNames(domesticKeys, 'domestic'),
|
|
loadTraitNames(warKeys, 'war'),
|
|
]);
|
|
const nationMap = new Map(nations.map((nation) => [nation.id, nation.name]));
|
|
|
|
// Legacy select_pool rows preceded possessed NPC rows before its stable-value sort.
|
|
const pool = generals.filter((general) => general.npcState >= 2);
|
|
const possessed = generals.filter((general) => general.npcState === 1);
|
|
const rows = [...pool, ...possessed].map((general) => {
|
|
const meta = asRecord(general.meta);
|
|
const personalityKey = normalizeTraitKey(general.personalCode);
|
|
const domesticKey = normalizeTraitKey(general.specialCode);
|
|
const warKey = normalizeTraitKey(general.special2Code);
|
|
const ownerName =
|
|
general.npcState === 1
|
|
? typeof meta.owner_name === 'string'
|
|
? meta.owner_name
|
|
: typeof meta.ownerName === 'string'
|
|
? meta.ownerName
|
|
: ''
|
|
: '';
|
|
|
|
return {
|
|
id: general.id,
|
|
name: general.name,
|
|
npcState: general.npcState,
|
|
ownerName,
|
|
level: readFiniteMetaNumber(meta, 'explevel'),
|
|
nationId: general.nationId,
|
|
nationName: nationMap.get(general.nationId) ?? '-',
|
|
personality: personalityKey
|
|
? {
|
|
key: personalityKey,
|
|
name: personalityMap.get(personalityKey)?.name ?? personalityKey,
|
|
info: personalityMap.get(personalityKey)?.info ?? '',
|
|
}
|
|
: null,
|
|
specialDomestic: domesticKey
|
|
? {
|
|
key: domesticKey,
|
|
name: domesticMap.get(domesticKey)?.name ?? domesticKey,
|
|
info: domesticMap.get(domesticKey)?.info ?? '',
|
|
}
|
|
: null,
|
|
specialWar: warKey
|
|
? {
|
|
key: warKey,
|
|
name: warMap.get(warKey)?.name ?? warKey,
|
|
info: warMap.get(warKey)?.info ?? '',
|
|
}
|
|
: null,
|
|
statTotal: general.leadership + general.strength + general.intel,
|
|
leadership: general.leadership,
|
|
strength: general.strength,
|
|
intelligence: general.intel,
|
|
experience: general.experience,
|
|
dedication: general.dedication,
|
|
};
|
|
});
|
|
|
|
return {
|
|
sort,
|
|
generals: sortNpcList(rows, sort),
|
|
};
|
|
}),
|
|
});
|