455 lines
18 KiB
TypeScript
455 lines
18 KiB
TypeScript
import { createGamePostgresConnector, GamePrisma, type GamePrismaClient } from '@sammo-ts/infra';
|
|
import { ActionLogger, ItemLoader, LogFormat, UserLogger, isItemKey } from '@sammo-ts/logic';
|
|
import { JosaUtil } from '@sammo-ts/common';
|
|
|
|
import type { TurnDaemonCommandResult, TurnDaemonHooks } from '../lifecycle/types.js';
|
|
import type { InMemoryTurnWorld } from '../turn/inMemoryWorld.js';
|
|
import type { LogEntryDraft } from '@sammo-ts/logic';
|
|
|
|
export interface AuctionFinalizer {
|
|
finalize(auctionId: number): Promise<TurnDaemonCommandResult>;
|
|
close(): Promise<void>;
|
|
}
|
|
|
|
type AuctionType = 'BUY_RICE' | 'SELL_RICE' | 'UNIQUE_ITEM';
|
|
type AuctionStatus = 'OPEN' | 'FINALIZING' | 'FINISHED' | 'CANCELED';
|
|
|
|
const COEFF_EXTENSION_MINUTES_PER_BID = 1 / 6;
|
|
const MIN_EXTENSION_MINUTES_PER_BID = 1;
|
|
|
|
interface AuctionRow {
|
|
id: number;
|
|
type: AuctionType;
|
|
targetCode: string | null;
|
|
hostGeneralId: number;
|
|
hostName: string | null;
|
|
detail: unknown;
|
|
status: AuctionStatus;
|
|
closeAt: Date;
|
|
}
|
|
|
|
interface AuctionBidRow {
|
|
id: number;
|
|
generalId: number;
|
|
amount: number;
|
|
}
|
|
|
|
interface AuctionDetailBase {
|
|
title?: string;
|
|
isReverse?: boolean;
|
|
availableLatestBidCloseDate?: string | null;
|
|
}
|
|
|
|
interface AuctionDetailResource extends AuctionDetailBase {
|
|
amount?: number;
|
|
}
|
|
|
|
const buildFlushResult = (world: InMemoryTurnWorld) => {
|
|
const state = world.getState();
|
|
return {
|
|
lastTurnTime: state.lastTurnTime.toISOString(),
|
|
processedGenerals: 0,
|
|
processedTurns: 0,
|
|
durationMs: 0,
|
|
partial: false,
|
|
checkpoint: world.getCheckpoint(),
|
|
};
|
|
};
|
|
|
|
const flushWorld = async (world: InMemoryTurnWorld, hooks?: TurnDaemonHooks): Promise<void> => {
|
|
if (!hooks?.flushChanges) {
|
|
return;
|
|
}
|
|
await hooks.flushChanges(buildFlushResult(world));
|
|
};
|
|
|
|
const parseDetail = (detail: unknown): AuctionDetailResource => {
|
|
if (!detail || typeof detail !== 'object') {
|
|
return {};
|
|
}
|
|
return detail as AuctionDetailResource;
|
|
};
|
|
|
|
const toTurnMinutes = (tickSeconds: number): number => Math.max(1, Math.round(tickSeconds / 60));
|
|
|
|
const resolveTurnMinutes = async (prisma: GamePrismaClient): Promise<number> => {
|
|
const rows = (await prisma.$queryRaw(
|
|
GamePrisma.sql`SELECT tick_seconds as "tickSeconds" FROM world_state ORDER BY id LIMIT 1`
|
|
)) as Array<{ tickSeconds: number }>;
|
|
return toTurnMinutes(rows[0]?.tickSeconds ?? 60);
|
|
};
|
|
|
|
const extendCloseDate = (options: {
|
|
now: Date;
|
|
closeAt: Date;
|
|
turnMinutes: number;
|
|
availableLatestBidCloseDate?: Date | null;
|
|
}): Date => {
|
|
const { now, closeAt, turnMinutes, availableLatestBidCloseDate } = options;
|
|
const extendMinutes = Math.max(MIN_EXTENSION_MINUTES_PER_BID, turnMinutes * COEFF_EXTENSION_MINUTES_PER_BID);
|
|
const extended = new Date(now.getTime() + extendMinutes * 60 * 1000);
|
|
if (extended.getTime() <= closeAt.getTime()) {
|
|
return closeAt;
|
|
}
|
|
if (availableLatestBidCloseDate && extended.getTime() > availableLatestBidCloseDate.getTime()) {
|
|
return availableLatestBidCloseDate;
|
|
}
|
|
return extended;
|
|
};
|
|
|
|
const pushLogs = (world: InMemoryTurnWorld, logs: LogEntryDraft[]): void => {
|
|
for (const log of logs) {
|
|
world.pushLog(log);
|
|
}
|
|
};
|
|
|
|
const refundInheritancePoint = async (options: {
|
|
prisma: GamePrismaClient;
|
|
userId: string;
|
|
amount: number;
|
|
}): Promise<void> => {
|
|
const { prisma, userId, amount } = options;
|
|
if (!userId || amount <= 0) {
|
|
return;
|
|
}
|
|
const current = await prisma.inheritancePoint.findUnique({
|
|
where: {
|
|
userId_key: {
|
|
userId,
|
|
key: 'previous',
|
|
},
|
|
},
|
|
});
|
|
const nextValue = (current?.value ?? 0) + amount;
|
|
await prisma.inheritancePoint.upsert({
|
|
where: {
|
|
userId_key: {
|
|
userId,
|
|
key: 'previous',
|
|
},
|
|
},
|
|
update: {
|
|
value: nextValue,
|
|
},
|
|
create: {
|
|
userId,
|
|
key: 'previous',
|
|
value: nextValue,
|
|
},
|
|
});
|
|
};
|
|
|
|
export const createAuctionFinalizer = async (options: {
|
|
databaseUrl: string;
|
|
world: InMemoryTurnWorld;
|
|
hooks?: TurnDaemonHooks;
|
|
}): Promise<AuctionFinalizer> => {
|
|
const connector = createGamePostgresConnector({ url: options.databaseUrl });
|
|
await connector.connect();
|
|
const prisma = connector.prisma;
|
|
const world = options.world;
|
|
const hooks = options.hooks;
|
|
const itemLoader = new ItemLoader();
|
|
|
|
const getGeneralUserId = async (generalId: number): Promise<string | null> => {
|
|
const rows = await prisma.$queryRaw<{ userId: string | null }[]>(
|
|
GamePrisma.sql`SELECT user_id as "userId" FROM general WHERE id = ${generalId}`
|
|
);
|
|
return rows[0]?.userId ?? null;
|
|
};
|
|
|
|
return {
|
|
finalize: async (auctionId: number): Promise<TurnDaemonCommandResult> => {
|
|
const rows = await prisma.$queryRaw<AuctionRow[]>(
|
|
GamePrisma.sql`
|
|
SELECT id,
|
|
type,
|
|
target_code as "targetCode",
|
|
host_general_id as "hostGeneralId",
|
|
host_name as "hostName",
|
|
detail,
|
|
status,
|
|
close_at as "closeAt"
|
|
FROM auction
|
|
WHERE id = ${auctionId}
|
|
`
|
|
);
|
|
const auction = rows[0];
|
|
if (!auction) {
|
|
return {
|
|
type: 'auctionFinalize',
|
|
ok: false,
|
|
auctionId,
|
|
reason: '경매 정보를 찾을 수 없습니다.',
|
|
};
|
|
}
|
|
|
|
if (auction.status === 'FINISHED' || auction.status === 'CANCELED') {
|
|
return { type: 'auctionFinalize', ok: true, auctionId };
|
|
}
|
|
|
|
if (auction.status !== 'FINALIZING') {
|
|
return {
|
|
type: 'auctionFinalize',
|
|
ok: false,
|
|
auctionId,
|
|
reason: '경매가 확정 대기 상태가 아닙니다.',
|
|
};
|
|
}
|
|
|
|
const detail = parseDetail(auction.detail);
|
|
const isReverse = detail.isReverse === true;
|
|
|
|
const bidRows = await prisma.$queryRaw<AuctionBidRow[]>(
|
|
isReverse
|
|
? GamePrisma.sql`
|
|
SELECT id, general_id as "generalId", amount
|
|
FROM auction_bid
|
|
WHERE auction_id = ${auctionId}
|
|
ORDER BY amount ASC, id ASC
|
|
LIMIT 1
|
|
`
|
|
: GamePrisma.sql`
|
|
SELECT id, general_id as "generalId", amount
|
|
FROM auction_bid
|
|
WHERE auction_id = ${auctionId}
|
|
ORDER BY amount DESC, id ASC
|
|
LIMIT 1
|
|
`
|
|
);
|
|
const highestBid = bidRows[0] ?? null;
|
|
|
|
const now = new Date();
|
|
const logs: LogEntryDraft[] = [];
|
|
const globalLogger = new ActionLogger();
|
|
|
|
const finalizeStatus = async (status: AuctionStatus) => {
|
|
await prisma.$executeRaw(
|
|
GamePrisma.sql`
|
|
UPDATE auction
|
|
SET status = ${status},
|
|
finished_at = ${now},
|
|
updated_at = ${now}
|
|
WHERE id = ${auctionId}
|
|
`
|
|
);
|
|
};
|
|
|
|
if (!highestBid) {
|
|
if (auction.type === 'BUY_RICE' || auction.type === 'SELL_RICE') {
|
|
const amount = detail.amount;
|
|
if (!amount || amount <= 0) {
|
|
await finalizeStatus('CANCELED');
|
|
return {
|
|
type: 'auctionFinalize',
|
|
ok: false,
|
|
auctionId,
|
|
reason: '경매 거래량 정보가 없습니다.',
|
|
};
|
|
}
|
|
if (auction.hostGeneralId > 0) {
|
|
const host = world.getGeneralById(auction.hostGeneralId);
|
|
if (!host) {
|
|
await finalizeStatus('CANCELED');
|
|
return {
|
|
type: 'auctionFinalize',
|
|
ok: false,
|
|
auctionId,
|
|
reason: '경매 주최자를 찾을 수 없습니다.',
|
|
};
|
|
}
|
|
const resourceKey = auction.type === 'BUY_RICE' ? 'rice' : 'gold';
|
|
world.updateGeneral(host.id, {
|
|
[resourceKey]: host[resourceKey] + amount,
|
|
});
|
|
const hostLogger = new ActionLogger({ generalId: host.id, nationId: host.nationId });
|
|
hostLogger.pushGeneralActionLog(`경매가 유찰되어 ${resourceKey === 'rice' ? '쌀' : '금'} ${amount}을 회수했습니다.`, LogFormat.PLAIN);
|
|
logs.push(...hostLogger.flush());
|
|
globalLogger.pushGlobalActionLog(`경매 ${auctionId}번이 유찰되었습니다.`, LogFormat.PLAIN);
|
|
}
|
|
}
|
|
|
|
logs.push(...globalLogger.flush());
|
|
pushLogs(world, logs);
|
|
await flushWorld(world, hooks);
|
|
await finalizeStatus('FINISHED');
|
|
return { type: 'auctionFinalize', ok: true, auctionId };
|
|
}
|
|
|
|
const bidder = world.getGeneralById(highestBid.generalId);
|
|
if (!bidder) {
|
|
await finalizeStatus('CANCELED');
|
|
return {
|
|
type: 'auctionFinalize',
|
|
ok: false,
|
|
auctionId,
|
|
reason: '입찰자를 찾을 수 없습니다.',
|
|
};
|
|
}
|
|
|
|
if (auction.type === 'BUY_RICE' || auction.type === 'SELL_RICE') {
|
|
const amount = detail.amount;
|
|
if (!amount || amount <= 0) {
|
|
await finalizeStatus('CANCELED');
|
|
return {
|
|
type: 'auctionFinalize',
|
|
ok: false,
|
|
auctionId,
|
|
reason: '경매 거래량 정보가 없습니다.',
|
|
};
|
|
}
|
|
const hostResource = auction.type === 'BUY_RICE' ? 'rice' : 'gold';
|
|
const bidderResource = auction.type === 'BUY_RICE' ? 'gold' : 'rice';
|
|
if (auction.hostGeneralId > 0) {
|
|
const host = world.getGeneralById(auction.hostGeneralId);
|
|
if (!host) {
|
|
await finalizeStatus('CANCELED');
|
|
return {
|
|
type: 'auctionFinalize',
|
|
ok: false,
|
|
auctionId,
|
|
reason: '경매 주최자를 찾을 수 없습니다.',
|
|
};
|
|
}
|
|
world.updateGeneral(host.id, {
|
|
[bidderResource]: host[bidderResource] + highestBid.amount,
|
|
});
|
|
const hostLogger = new ActionLogger({ generalId: host.id, nationId: host.nationId });
|
|
const hostJosa = JosaUtil.pick(host.name, '이');
|
|
hostLogger.pushGeneralActionLog(
|
|
`${auctionId}번 경매 성사: ${host.name}${hostJosa} ${hostResource === 'rice' ? '쌀' : '금'} ${amount}을 판매했습니다.`,
|
|
LogFormat.PLAIN
|
|
);
|
|
logs.push(...hostLogger.flush());
|
|
}
|
|
|
|
world.updateGeneral(bidder.id, {
|
|
[hostResource]: bidder[hostResource] + amount,
|
|
});
|
|
const bidderLogger = new ActionLogger({ generalId: bidder.id, nationId: bidder.nationId });
|
|
bidderLogger.pushGeneralActionLog(
|
|
`${auctionId}번 경매 성사: ${hostResource === 'rice' ? '쌀' : '금'} ${amount}을 획득했습니다.`,
|
|
LogFormat.PLAIN
|
|
);
|
|
logs.push(...bidderLogger.flush());
|
|
|
|
globalLogger.pushGlobalActionLog(`경매 ${auctionId}번 거래가 성사되었습니다.`, LogFormat.PLAIN);
|
|
} else if (auction.type === 'UNIQUE_ITEM') {
|
|
const itemKey = auction.targetCode;
|
|
if (!itemKey) {
|
|
await finalizeStatus('CANCELED');
|
|
return {
|
|
type: 'auctionFinalize',
|
|
ok: false,
|
|
auctionId,
|
|
reason: '유니크 아이템 정보가 없습니다.',
|
|
};
|
|
}
|
|
if (!isItemKey(itemKey)) {
|
|
await finalizeStatus('CANCELED');
|
|
return {
|
|
type: 'auctionFinalize',
|
|
ok: false,
|
|
auctionId,
|
|
reason: '아이템 키가 올바르지 않습니다.',
|
|
};
|
|
}
|
|
const itemModule = await itemLoader.load(itemKey).catch(() => null);
|
|
if (!itemModule) {
|
|
await finalizeStatus('CANCELED');
|
|
await refundInheritancePoint({
|
|
prisma,
|
|
userId: (await getGeneralUserId(bidder.id)) ?? '',
|
|
amount: highestBid.amount,
|
|
});
|
|
return {
|
|
type: 'auctionFinalize',
|
|
ok: false,
|
|
auctionId,
|
|
reason: '아이템 정보를 불러올 수 없습니다.',
|
|
};
|
|
}
|
|
|
|
const slot = itemModule.slot;
|
|
const currentItem = bidder.role.items?.[slot] ?? null;
|
|
if (currentItem && currentItem !== 'None' && isItemKey(currentItem)) {
|
|
const currentModule = await itemLoader.load(currentItem).catch(() => null);
|
|
if (currentModule && !currentModule.buyable) {
|
|
const turnMinutes = await resolveTurnMinutes(prisma);
|
|
const availableLatestBidCloseDate = detail.availableLatestBidCloseDate
|
|
? new Date(detail.availableLatestBidCloseDate)
|
|
: null;
|
|
const nextCloseAt = extendCloseDate({
|
|
now,
|
|
closeAt: auction.closeAt,
|
|
turnMinutes,
|
|
availableLatestBidCloseDate,
|
|
});
|
|
await prisma.$executeRaw(
|
|
GamePrisma.sql`
|
|
UPDATE auction
|
|
SET status = 'OPEN',
|
|
close_at = ${nextCloseAt},
|
|
updated_at = ${now}
|
|
WHERE id = ${auctionId}
|
|
`
|
|
);
|
|
globalLogger.pushGlobalActionLog(
|
|
`유니크 경매 ${auctionId}번이 보유 제한으로 연장되었습니다.`,
|
|
LogFormat.PLAIN
|
|
);
|
|
logs.push(...globalLogger.flush());
|
|
pushLogs(world, logs);
|
|
await flushWorld(world, hooks);
|
|
return {
|
|
type: 'auctionFinalize',
|
|
ok: false,
|
|
auctionId,
|
|
reason: '유니크 보유 제한으로 연장',
|
|
};
|
|
}
|
|
}
|
|
world.updateGeneral(bidder.id, {
|
|
role: {
|
|
...bidder.role,
|
|
items: {
|
|
...bidder.role.items,
|
|
[slot]: itemKey,
|
|
},
|
|
},
|
|
});
|
|
|
|
const bidderLogger = new ActionLogger({ generalId: bidder.id, nationId: bidder.nationId });
|
|
const josaUl = JosaUtil.pick(itemModule.rawName, '을');
|
|
bidderLogger.pushGeneralActionLog(
|
|
`유니크 경매 낙찰로 ${itemModule.name}${josaUl} 획득했습니다.`,
|
|
LogFormat.PLAIN
|
|
);
|
|
logs.push(...bidderLogger.flush());
|
|
|
|
const bidderUserId = await getGeneralUserId(bidder.id);
|
|
if (bidderUserId) {
|
|
const userIdNum = Number(bidderUserId);
|
|
if (Number.isFinite(userIdNum)) {
|
|
const userLogger = new UserLogger(userIdNum);
|
|
userLogger.push(`유니크 ${itemModule.name} 경매로 ${highestBid.amount} 포인트 사용`, 'inheritPoint');
|
|
logs.push(...userLogger.flush());
|
|
}
|
|
}
|
|
|
|
globalLogger.pushGlobalActionLog(`유니크 경매 ${auctionId}번이 성사되었습니다.`, LogFormat.PLAIN);
|
|
}
|
|
|
|
logs.push(...globalLogger.flush());
|
|
pushLogs(world, logs);
|
|
await flushWorld(world, hooks);
|
|
await finalizeStatus('FINISHED');
|
|
|
|
return { type: 'auctionFinalize', ok: true, auctionId };
|
|
},
|
|
close: async () => {
|
|
await connector.disconnect();
|
|
},
|
|
};
|
|
};
|