2210 lines
79 KiB
TypeScript
2210 lines
79 KiB
TypeScript
import type {
|
|
TurnDaemonCommandHandler,
|
|
TurnDaemonCommand,
|
|
TurnDaemonCommandExecutionContext,
|
|
TurnDaemonCommandResult,
|
|
} from '../lifecycle/types.js';
|
|
import { GamePrisma, type DatabaseClient } from '@sammo-ts/infra';
|
|
import { asRecord, JosaUtil, LiteHashDRBG, RandUtil } from '@sammo-ts/common';
|
|
import {
|
|
LogCategory,
|
|
LogFormat,
|
|
LogScope,
|
|
ITEM_KEYS,
|
|
addOccupiedUniqueItemKeys,
|
|
buildVoteUniqueSeed,
|
|
countOccupiedUniqueItems,
|
|
createItemModuleRegistry,
|
|
isDefenceTrainPenaltyWaivedByScenarioEffect,
|
|
isValidTroopNameWidth,
|
|
loadItemModules,
|
|
normalizeTroopName,
|
|
resolveTroopSecretPermission,
|
|
resolveUniqueConfig,
|
|
rollUniqueLottery,
|
|
type ItemModule,
|
|
type MapDefinition,
|
|
type ScenarioMeta,
|
|
type TriggerValue,
|
|
type TurnCommandProfile,
|
|
} from '@sammo-ts/logic';
|
|
import { simpleSerialize } from '@sammo-ts/logic/war/utils.js';
|
|
import {
|
|
cloneItemInventory,
|
|
ensureItemInventory,
|
|
equipNewItem,
|
|
removeEquippedItem,
|
|
} from '@sammo-ts/logic/items/index.js';
|
|
import type { InMemoryTurnWorld } from './inMemoryWorld.js';
|
|
import type { InMemoryReservedTurnStore } from './reservedTurnStore.js';
|
|
import type { TurnGeneral } from './types.js';
|
|
import { createImmediateGeneralActionExecutor, type ImmediateGeneralActionExecutor } from './reservedTurnHandler.js';
|
|
import { openAuction } from '../auction/opener.js';
|
|
import {
|
|
hasScenarioStaticEventHandler,
|
|
IMMEDIATE_TROOP_JOIN_MOVE_HANDLER,
|
|
LEGACY_TROOP_JOIN_EVENT,
|
|
} from './scenarioStaticEvents.js';
|
|
import {
|
|
createGeneralFromSelectionPool,
|
|
reselectGeneralFromSelectionPool,
|
|
SelectPoolError,
|
|
} from './selectPoolService.js';
|
|
import { createGeneralFromJoin, JoinCreateGeneralError } from './joinCreateGeneralService.js';
|
|
import { NpcPossessionError, possessNpcGeneral } from './npcPossessionService.js';
|
|
|
|
let itemRegistryPromise: Promise<Map<string, ItemModule>> | null = null;
|
|
|
|
const getItemRegistry = async (): Promise<Map<string, ItemModule>> => {
|
|
if (!itemRegistryPromise) {
|
|
itemRegistryPromise = loadItemModules([...ITEM_KEYS]).then((modules) => createItemModuleRegistry(modules));
|
|
}
|
|
return itemRegistryPromise;
|
|
};
|
|
|
|
const readMetaNumber = (meta: Record<string, unknown>, key: string, fallback: number): number => {
|
|
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 fallback;
|
|
};
|
|
|
|
const hasOfficerLock = (meta: Record<string, unknown>, key: string, officerLevel: number): boolean =>
|
|
(readMetaNumber(meta, key, 0) & (1 << officerLevel)) !== 0;
|
|
|
|
const setOfficerLock = (
|
|
meta: Record<string, TriggerValue>,
|
|
key: string,
|
|
officerLevel: number
|
|
): Record<string, TriggerValue> => ({
|
|
...meta,
|
|
[key]: readMetaNumber(meta, key, 0) | (1 << officerLevel),
|
|
});
|
|
|
|
const resolveNationChiefLevel = (nationLevel: number): number => {
|
|
if (nationLevel >= 6) return 5;
|
|
if (nationLevel >= 4) return 7;
|
|
if (nationLevel >= 2) return 9;
|
|
return 11;
|
|
};
|
|
|
|
const resolvePermissionKind = (general: TurnGeneral): 'normal' | 'ambassador' | 'auditor' => {
|
|
const permission = general.meta.permission;
|
|
return permission === 'ambassador' || permission === 'auditor' ? permission : 'normal';
|
|
};
|
|
|
|
const resolveMaxSecretPermission = (general: TurnGeneral): number => {
|
|
const penalty = asRecord(general.penalty);
|
|
if (penalty.noTopSecret || penalty.noChief) return 1;
|
|
if (penalty.noAmbassador) return 2;
|
|
return 4;
|
|
};
|
|
|
|
const refreshActorKillturn = (world: InMemoryTurnWorld, actor: TurnGeneral): void => {
|
|
const worldKillturn = readMetaNumber(asRecord(world.getState().meta), 'killturn', 0);
|
|
const actorKillturn = readMetaNumber(asRecord(actor.meta), 'killturn', 0);
|
|
if (worldKillturn <= actorKillturn) {
|
|
return;
|
|
}
|
|
world.updateGeneral(actor.id, {
|
|
meta: {
|
|
...actor.meta,
|
|
killturn: worldKillturn,
|
|
},
|
|
});
|
|
};
|
|
|
|
interface CommandHandlerContext {
|
|
world: InMemoryTurnWorld;
|
|
commandDb?: GamePrisma.TransactionClient;
|
|
auctionFinalizer?: AuctionFinalizer;
|
|
auctionBidder?: AuctionBidder;
|
|
tournamentRewardFinalizer?: TournamentRewardFinalizer;
|
|
getImmediateGeneralActionExecutor?: () => Promise<ImmediateGeneralActionExecutor>;
|
|
}
|
|
|
|
const requireCommandDatabase = (ctx: CommandHandlerContext): DatabaseClient => {
|
|
if (!ctx.commandDb) {
|
|
throw new Error('ENGINE mutation transaction is required for selection-pool commands.');
|
|
}
|
|
return ctx.commandDb as unknown as DatabaseClient;
|
|
};
|
|
|
|
const resolveCommandAcceptedAt = async (
|
|
db: DatabaseClient,
|
|
command: Extract<
|
|
TurnDaemonCommand,
|
|
{ type: 'joinCreateGeneral' | 'npcPossessGeneral' | 'selectPoolCreate' | 'selectPoolReselect' }
|
|
>
|
|
): Promise<Date> => {
|
|
if (!command.requestId) {
|
|
throw new Error(`${command.type} requestId is required.`);
|
|
}
|
|
const event = await db.inputEvent.findUnique({
|
|
where: { requestId: command.requestId },
|
|
select: { createdAt: true, actorUserId: true, target: true, eventType: true },
|
|
});
|
|
if (!event) {
|
|
throw new Error(`ENGINE input event ${command.requestId} is missing.`);
|
|
}
|
|
if (event.actorUserId !== command.userId) {
|
|
throw new Error(`ENGINE input event actor does not match ${command.type} user.`);
|
|
}
|
|
if (event.target !== 'ENGINE' || event.eventType !== command.type) {
|
|
throw new Error(`ENGINE input event type does not match ${command.type}.`);
|
|
}
|
|
return event.createdAt;
|
|
};
|
|
|
|
const assertImmediateGeneralActionActor = async (
|
|
ctx: CommandHandlerContext,
|
|
command: Extract<TurnDaemonCommand, { type: 'buildNationCandidate' | 'instantRetreat' }>,
|
|
general: TurnGeneral
|
|
): Promise<void> => {
|
|
if (general.userId !== command.userId) {
|
|
throw new Error(`${command.type} general owner does not match command user.`);
|
|
}
|
|
if (!command.requestId) {
|
|
return;
|
|
}
|
|
const db = requireCommandDatabase(ctx);
|
|
const event = await db.inputEvent.findUnique({
|
|
where: { requestId: command.requestId },
|
|
select: { actorUserId: true },
|
|
});
|
|
if (!event) {
|
|
throw new Error(`ENGINE input event ${command.requestId} is missing.`);
|
|
}
|
|
if (event.actorUserId !== command.userId) {
|
|
throw new Error(`ENGINE input event actor does not match ${command.type} user.`);
|
|
}
|
|
};
|
|
|
|
async function handleJoinCreateGeneral(
|
|
ctx: CommandHandlerContext,
|
|
command: Extract<TurnDaemonCommand, { type: 'joinCreateGeneral' }>
|
|
): Promise<TurnDaemonCommandResult> {
|
|
const db = requireCommandDatabase(ctx);
|
|
const worldState = await db.worldState.findUnique({
|
|
where: { id: ctx.world.getState().id },
|
|
});
|
|
if (!worldState) {
|
|
throw new Error('Join world state is missing.');
|
|
}
|
|
const acceptedAt = await resolveCommandAcceptedAt(db, command);
|
|
try {
|
|
return {
|
|
type: 'joinCreateGeneral',
|
|
...(await createGeneralFromJoin({
|
|
db,
|
|
world: ctx.world,
|
|
worldState,
|
|
input: {
|
|
userId: command.userId,
|
|
ownerDisplayName: command.ownerDisplayName,
|
|
seedOwnerIdentity: command.seedOwnerIdentity,
|
|
name: command.name,
|
|
leadership: command.leadership,
|
|
strength: command.strength,
|
|
intel: command.intel,
|
|
pic: command.pic,
|
|
character: command.character,
|
|
profileId: command.profileId,
|
|
...(command.ownerPicture !== undefined ? { ownerPicture: command.ownerPicture } : {}),
|
|
...(command.ownerImageServer !== undefined ? { ownerImageServer: command.ownerImageServer } : {}),
|
|
...(command.ownerCanUsePicture !== undefined
|
|
? { ownerCanUsePicture: command.ownerCanUsePicture }
|
|
: {}),
|
|
...(command.ownerLegacyPenalty !== undefined
|
|
? { ownerLegacyPenalty: command.ownerLegacyPenalty }
|
|
: {}),
|
|
...(command.inheritSpecial !== undefined ? { inheritSpecial: command.inheritSpecial } : {}),
|
|
...(command.inheritTurntimeZone !== undefined
|
|
? { inheritTurntimeZone: command.inheritTurntimeZone }
|
|
: {}),
|
|
...(command.inheritCity !== undefined ? { inheritCity: command.inheritCity } : {}),
|
|
...(command.inheritBonusStat !== undefined ? { inheritBonusStat: command.inheritBonusStat } : {}),
|
|
},
|
|
acceptedAt,
|
|
})),
|
|
};
|
|
} catch (error) {
|
|
if (error instanceof JoinCreateGeneralError) {
|
|
return {
|
|
type: 'joinCreateGeneral',
|
|
ok: false,
|
|
code: error.code,
|
|
reason: error.message,
|
|
};
|
|
}
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
async function handleNpcPossessGeneral(
|
|
ctx: CommandHandlerContext,
|
|
command: Extract<TurnDaemonCommand, { type: 'npcPossessGeneral' }>
|
|
): Promise<TurnDaemonCommandResult> {
|
|
const db = requireCommandDatabase(ctx);
|
|
const worldState = await db.worldState.findUnique({
|
|
where: { id: ctx.world.getState().id },
|
|
});
|
|
if (!worldState) {
|
|
throw new Error('NPC possession world state is missing.');
|
|
}
|
|
const acceptedAt = await resolveCommandAcceptedAt(db, command);
|
|
try {
|
|
return {
|
|
type: 'npcPossessGeneral',
|
|
...(await possessNpcGeneral({
|
|
db,
|
|
world: ctx.world,
|
|
worldState,
|
|
userId: command.userId,
|
|
ownerDisplayName: command.ownerDisplayName,
|
|
profileId: command.profileId,
|
|
...(command.ownerLegacyPenalty !== undefined ? { ownerLegacyPenalty: command.ownerLegacyPenalty } : {}),
|
|
generalId: command.generalId,
|
|
tokenNonce: command.tokenNonce,
|
|
acceptedAt,
|
|
})),
|
|
};
|
|
} catch (error) {
|
|
if (error instanceof NpcPossessionError) {
|
|
return {
|
|
type: 'npcPossessGeneral',
|
|
ok: false,
|
|
code: error.code,
|
|
reason: error.message,
|
|
};
|
|
}
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
async function handleSelectPoolCreate(
|
|
ctx: CommandHandlerContext,
|
|
command: Extract<TurnDaemonCommand, { type: 'selectPoolCreate' }>
|
|
): Promise<TurnDaemonCommandResult> {
|
|
const db = requireCommandDatabase(ctx);
|
|
const worldState = await db.worldState.findUnique({
|
|
where: { id: ctx.world.getState().id },
|
|
});
|
|
if (!worldState) {
|
|
throw new Error('Selection-pool world state is missing.');
|
|
}
|
|
const acceptedAt = await resolveCommandAcceptedAt(db, command);
|
|
try {
|
|
return {
|
|
type: 'selectPoolCreate',
|
|
...(await createGeneralFromSelectionPool({
|
|
db,
|
|
world: ctx.world,
|
|
worldState,
|
|
userId: command.userId,
|
|
ownerDisplayName: command.ownerDisplayName,
|
|
uniqueName: command.uniqueName,
|
|
personality: command.personality,
|
|
seedOwnerIdentity: command.seedOwnerIdentity,
|
|
now: acceptedAt,
|
|
})),
|
|
};
|
|
} catch (error) {
|
|
if (error instanceof SelectPoolError) {
|
|
return {
|
|
type: 'selectPoolCreate',
|
|
ok: false,
|
|
code: error.code,
|
|
reason: error.message,
|
|
};
|
|
}
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
async function handleSelectPoolReselect(
|
|
ctx: CommandHandlerContext,
|
|
command: Extract<TurnDaemonCommand, { type: 'selectPoolReselect' }>
|
|
): Promise<TurnDaemonCommandResult> {
|
|
const db = requireCommandDatabase(ctx);
|
|
const worldState = await db.worldState.findUnique({
|
|
where: { id: ctx.world.getState().id },
|
|
});
|
|
if (!worldState) {
|
|
throw new Error('Selection-pool world state is missing.');
|
|
}
|
|
const acceptedAt = await resolveCommandAcceptedAt(db, command);
|
|
try {
|
|
return {
|
|
type: 'selectPoolReselect',
|
|
...(await reselectGeneralFromSelectionPool({
|
|
db,
|
|
world: ctx.world,
|
|
worldState,
|
|
userId: command.userId,
|
|
ownerDisplayName: command.ownerDisplayName,
|
|
uniqueName: command.uniqueName,
|
|
now: acceptedAt,
|
|
})),
|
|
};
|
|
} catch (error) {
|
|
if (error instanceof SelectPoolError) {
|
|
return {
|
|
type: 'selectPoolReselect',
|
|
ok: false,
|
|
code: error.code,
|
|
reason: error.message,
|
|
};
|
|
}
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
interface AuctionFinalizer {
|
|
finalize(auctionId: number, db?: GamePrisma.TransactionClient): Promise<TurnDaemonCommandResult>;
|
|
}
|
|
|
|
interface AuctionBidder {
|
|
bid(
|
|
command: Extract<TurnDaemonCommand, { type: 'auctionBid' }>,
|
|
db?: GamePrisma.TransactionClient
|
|
): Promise<TurnDaemonCommandResult>;
|
|
}
|
|
|
|
interface TournamentRewardFinalizer {
|
|
finalize(
|
|
command: Extract<TurnDaemonCommand, { type: 'tournamentReward' }>,
|
|
db?: GamePrisma.TransactionClient
|
|
): Promise<TurnDaemonCommandResult>;
|
|
}
|
|
|
|
async function handleSetNationMeta(
|
|
ctx: CommandHandlerContext,
|
|
command: Extract<TurnDaemonCommand, { type: 'setNationMeta' }>
|
|
): Promise<TurnDaemonCommandResult> {
|
|
const { world } = ctx;
|
|
const nation = world.getNationById(command.nationId);
|
|
if (!nation) {
|
|
return {
|
|
type: 'setNationMeta',
|
|
ok: false,
|
|
nationId: command.nationId,
|
|
reason: '국가 정보를 찾을 수 없습니다.',
|
|
};
|
|
}
|
|
|
|
const meta = (nation.meta ?? {}) as Record<string, unknown>;
|
|
const currentUpdatedAt = typeof meta._updatedAt === 'string' ? meta._updatedAt : undefined;
|
|
if (command.expectedUpdatedAt && currentUpdatedAt && command.expectedUpdatedAt !== currentUpdatedAt) {
|
|
return {
|
|
type: 'setNationMeta',
|
|
ok: false,
|
|
nationId: command.nationId,
|
|
reason: 'CONFLICT',
|
|
currentUpdatedAt,
|
|
};
|
|
}
|
|
|
|
const updatedAt = new Date().toISOString();
|
|
const nextMeta = {
|
|
...meta,
|
|
...command.updates,
|
|
_updatedAt: updatedAt,
|
|
};
|
|
|
|
world.updateNation(command.nationId, {
|
|
meta: nextMeta,
|
|
});
|
|
return {
|
|
type: 'setNationMeta',
|
|
ok: true,
|
|
nationId: command.nationId,
|
|
updatedAt,
|
|
};
|
|
}
|
|
|
|
async function handleAdjustGeneralResources(
|
|
ctx: CommandHandlerContext,
|
|
command: Extract<TurnDaemonCommand, { type: 'adjustGeneralResources' }>
|
|
): Promise<TurnDaemonCommandResult> {
|
|
const { world } = ctx;
|
|
if (!command.adjustments || command.adjustments.length === 0) {
|
|
return { type: 'adjustGeneralResources', ok: false, reason: '조정 대상이 없습니다.' };
|
|
}
|
|
|
|
const targets = command.adjustments.map((adjustment) => {
|
|
const general = world.getGeneralById(adjustment.generalId);
|
|
return { adjustment, general };
|
|
});
|
|
|
|
for (const { adjustment, general } of targets) {
|
|
if (!general) {
|
|
continue;
|
|
}
|
|
const nextGold = general.gold + (adjustment.goldDelta ?? 0);
|
|
const nextRice = general.rice + (adjustment.riceDelta ?? 0);
|
|
const minGoldAfter = adjustment.minGoldAfter ?? 0;
|
|
if (nextGold < minGoldAfter || nextRice < 0) {
|
|
return { type: 'adjustGeneralResources', ok: false, reason: '자원이 부족합니다.' };
|
|
}
|
|
}
|
|
|
|
let processed = 0;
|
|
let missing = 0;
|
|
let totalGoldDelta = 0;
|
|
let totalRiceDelta = 0;
|
|
|
|
for (const { adjustment, general } of targets) {
|
|
if (!general) {
|
|
missing += 1;
|
|
continue;
|
|
}
|
|
const goldDelta = adjustment.goldDelta ?? 0;
|
|
const riceDelta = adjustment.riceDelta ?? 0;
|
|
world.updateGeneral(adjustment.generalId, {
|
|
gold: general.gold + goldDelta,
|
|
rice: general.rice + riceDelta,
|
|
});
|
|
processed += 1;
|
|
totalGoldDelta += goldDelta;
|
|
totalRiceDelta += riceDelta;
|
|
}
|
|
return {
|
|
type: 'adjustGeneralResources',
|
|
ok: true,
|
|
processed,
|
|
missing,
|
|
totalGoldDelta,
|
|
totalRiceDelta,
|
|
};
|
|
}
|
|
|
|
async function handleAdjustGeneralMeta(
|
|
ctx: CommandHandlerContext,
|
|
command: Extract<TurnDaemonCommand, { type: 'adjustGeneralMeta' }>
|
|
): Promise<TurnDaemonCommandResult> {
|
|
const { world } = ctx;
|
|
if (!command.adjustments || command.adjustments.length === 0) {
|
|
return {
|
|
type: 'adjustGeneralMeta',
|
|
ok: false,
|
|
reason: '메타 조정 대상이 없습니다.',
|
|
};
|
|
}
|
|
|
|
let processed = 0;
|
|
let missing = 0;
|
|
|
|
for (const adjustment of command.adjustments) {
|
|
if (!adjustment || typeof adjustment.generalId !== 'number') {
|
|
continue;
|
|
}
|
|
const general = world.getGeneralById(adjustment.generalId);
|
|
if (!general) {
|
|
missing += 1;
|
|
continue;
|
|
}
|
|
const nextMeta = { ...general.meta } as TurnGeneral['meta'];
|
|
for (const [key, delta] of Object.entries(adjustment.metaDelta ?? {})) {
|
|
if (typeof delta !== 'number' || !Number.isFinite(delta)) {
|
|
continue;
|
|
}
|
|
const current = typeof nextMeta[key] === 'number' ? Number(nextMeta[key]) : 0;
|
|
nextMeta[key] = current + delta;
|
|
}
|
|
world.updateGeneral(adjustment.generalId, { meta: nextMeta });
|
|
processed += 1;
|
|
}
|
|
return {
|
|
type: 'adjustGeneralMeta',
|
|
ok: true,
|
|
processed,
|
|
missing,
|
|
};
|
|
}
|
|
|
|
async function handleTournamentMatchResult(
|
|
ctx: CommandHandlerContext,
|
|
command: Extract<TurnDaemonCommand, { type: 'tournamentMatchResult' }>
|
|
): Promise<TurnDaemonCommandResult> {
|
|
const { world } = ctx;
|
|
const resolvePrefix = (type: number): string => {
|
|
switch (type) {
|
|
case 1:
|
|
return 'tl';
|
|
case 2:
|
|
return 'ts';
|
|
case 3:
|
|
return 'ti';
|
|
case 0:
|
|
default:
|
|
return 'tt';
|
|
}
|
|
};
|
|
|
|
const prefix = resolvePrefix(command.tournamentType);
|
|
const attacker = command.attackerId > 0 ? world.getGeneralById(command.attackerId) : null;
|
|
const defender = command.defenderId > 0 ? world.getGeneralById(command.defenderId) : null;
|
|
if (!attacker && !defender) {
|
|
return {
|
|
type: 'tournamentMatchResult',
|
|
ok: false,
|
|
tournamentType: command.tournamentType,
|
|
attackerId: command.attackerId,
|
|
defenderId: command.defenderId,
|
|
result: command.result,
|
|
reason: '장수 정보를 찾을 수 없습니다.',
|
|
};
|
|
}
|
|
|
|
const rankKey = (suffix: string): string => `${prefix}${suffix}`;
|
|
const getRankNumber = (general: TurnGeneral | null, key: string): number =>
|
|
general && typeof general.meta[key] === 'number' ? Number(general.meta[key]) : 0;
|
|
|
|
const attackerG = getRankNumber(attacker, rankKey('g'));
|
|
const defenderG = getRankNumber(defender, rankKey('g'));
|
|
|
|
let attackerGDelta: number;
|
|
let defenderGDelta: number;
|
|
let attackerW = 0;
|
|
let attackerD = 0;
|
|
let attackerL = 0;
|
|
let defenderW = 0;
|
|
let defenderD = 0;
|
|
let defenderL = 0;
|
|
|
|
if (command.result === 'attacker') {
|
|
attackerW = 1;
|
|
defenderL = 1;
|
|
if (attackerG > defenderG) {
|
|
attackerGDelta = 1;
|
|
defenderGDelta = 0;
|
|
} else if (attackerG === defenderG) {
|
|
attackerGDelta = 2;
|
|
defenderGDelta = -1;
|
|
} else {
|
|
attackerGDelta = 3;
|
|
defenderGDelta = -2;
|
|
}
|
|
} else if (command.result === 'defender') {
|
|
attackerL = 1;
|
|
defenderW = 1;
|
|
if (defenderG > attackerG) {
|
|
defenderGDelta = 1;
|
|
attackerGDelta = 0;
|
|
} else if (attackerG === defenderG) {
|
|
defenderGDelta = 2;
|
|
attackerGDelta = -1;
|
|
} else {
|
|
defenderGDelta = 3;
|
|
attackerGDelta = -2;
|
|
}
|
|
} else {
|
|
attackerD = 1;
|
|
defenderD = 1;
|
|
if (attackerG > defenderG) {
|
|
attackerGDelta = 1;
|
|
defenderGDelta = -1;
|
|
} else if (attackerG === defenderG) {
|
|
attackerGDelta = 0;
|
|
defenderGDelta = 0;
|
|
} else {
|
|
attackerGDelta = -1;
|
|
defenderGDelta = 1;
|
|
}
|
|
}
|
|
|
|
if (attacker) {
|
|
const nextMeta = { ...attacker.meta } as TurnGeneral['meta'];
|
|
nextMeta[rankKey('w')] = getRankNumber(attacker, rankKey('w')) + attackerW;
|
|
nextMeta[rankKey('d')] = getRankNumber(attacker, rankKey('d')) + attackerD;
|
|
nextMeta[rankKey('l')] = getRankNumber(attacker, rankKey('l')) + attackerL;
|
|
nextMeta[rankKey('g')] = attackerG + attackerGDelta;
|
|
world.updateGeneral(attacker.id, { meta: nextMeta });
|
|
}
|
|
|
|
if (defender) {
|
|
const nextMeta = { ...defender.meta } as TurnGeneral['meta'];
|
|
nextMeta[rankKey('w')] = getRankNumber(defender, rankKey('w')) + defenderW;
|
|
nextMeta[rankKey('d')] = getRankNumber(defender, rankKey('d')) + defenderD;
|
|
nextMeta[rankKey('l')] = getRankNumber(defender, rankKey('l')) + defenderL;
|
|
nextMeta[rankKey('g')] = defenderG + defenderGDelta;
|
|
world.updateGeneral(defender.id, { meta: nextMeta });
|
|
}
|
|
return {
|
|
type: 'tournamentMatchResult',
|
|
ok: true,
|
|
tournamentType: command.tournamentType,
|
|
attackerId: command.attackerId,
|
|
defenderId: command.defenderId,
|
|
result: command.result,
|
|
};
|
|
}
|
|
|
|
async function handlePatchGeneral(
|
|
ctx: CommandHandlerContext,
|
|
command: Extract<TurnDaemonCommand, { type: 'patchGeneral' }>
|
|
): Promise<TurnDaemonCommandResult> {
|
|
const { world } = ctx;
|
|
const general = world.getGeneralById(command.generalId);
|
|
if (!general) {
|
|
return {
|
|
type: 'patchGeneral',
|
|
ok: false,
|
|
generalId: command.generalId,
|
|
reason: '장수 정보를 찾을 수 없습니다.',
|
|
};
|
|
}
|
|
|
|
const patch: Partial<typeof general> = {};
|
|
if (command.patch.meta) {
|
|
patch.meta = {
|
|
...general.meta,
|
|
...command.patch.meta,
|
|
} as TurnGeneral['meta'];
|
|
}
|
|
if (command.patch.turnTime) {
|
|
const nextTurnTime = new Date(command.patch.turnTime);
|
|
if (!Number.isNaN(nextTurnTime.getTime())) {
|
|
patch.turnTime = nextTurnTime;
|
|
}
|
|
}
|
|
if (command.patch.stats) {
|
|
patch.stats = {
|
|
...general.stats,
|
|
...command.patch.stats,
|
|
};
|
|
}
|
|
if (typeof command.patch.specialWar === 'string') {
|
|
patch.role = {
|
|
...general.role,
|
|
specialWar: command.patch.specialWar,
|
|
};
|
|
}
|
|
|
|
world.updateGeneral(command.generalId, patch);
|
|
return { type: 'patchGeneral', ok: true, generalId: command.generalId };
|
|
}
|
|
|
|
async function handleShiftSchedule(
|
|
ctx: CommandHandlerContext,
|
|
command: Extract<TurnDaemonCommand, { type: 'shiftSchedule' }>
|
|
): Promise<TurnDaemonCommandResult> {
|
|
if (!ctx.commandDb) {
|
|
return {
|
|
type: 'shiftSchedule',
|
|
ok: false,
|
|
actionId: command.actionId,
|
|
reason: '시간 조정은 데이터베이스 transaction 경계에서만 실행할 수 있습니다.',
|
|
};
|
|
}
|
|
|
|
const shifted = ctx.world.shiftSchedule(command.deltaMinutes);
|
|
const shiftedAuctions = await ctx.commandDb.$executeRaw(
|
|
GamePrisma.sql`
|
|
UPDATE auction
|
|
SET close_at = close_at + (${command.deltaMinutes} * INTERVAL '1 minute'),
|
|
updated_at = NOW()
|
|
WHERE status = 'OPEN'
|
|
`
|
|
);
|
|
|
|
return {
|
|
type: 'shiftSchedule',
|
|
ok: true,
|
|
actionId: command.actionId,
|
|
deltaMinutes: command.deltaMinutes,
|
|
lastTurnTime: shifted.lastTurnTime,
|
|
shiftedGenerals: shifted.shiftedGenerals,
|
|
shiftedAuctions,
|
|
checkpoint: ctx.world.getCheckpoint(),
|
|
};
|
|
}
|
|
|
|
async function handleTroopJoin(
|
|
ctx: CommandHandlerContext,
|
|
command: Extract<TurnDaemonCommand, { type: 'troopJoin' }>
|
|
): Promise<TurnDaemonCommandResult> {
|
|
const { world } = ctx;
|
|
const general = world.getGeneralById(command.generalId);
|
|
if (!general) {
|
|
return {
|
|
type: 'troopJoin',
|
|
ok: false,
|
|
generalId: command.generalId,
|
|
troopId: command.troopId,
|
|
reason: '장수 정보를 찾을 수 없습니다.',
|
|
};
|
|
}
|
|
if (general.troopId !== 0) {
|
|
return {
|
|
type: 'troopJoin',
|
|
ok: false,
|
|
generalId: command.generalId,
|
|
troopId: command.troopId,
|
|
reason: '이미 부대에 소속되어 있습니다.',
|
|
};
|
|
}
|
|
if (general.nationId <= 0) {
|
|
return {
|
|
type: 'troopJoin',
|
|
ok: false,
|
|
generalId: command.generalId,
|
|
troopId: command.troopId,
|
|
reason: '국가에 소속되어 있지 않습니다.',
|
|
};
|
|
}
|
|
|
|
const troop = world.getTroopById(command.troopId);
|
|
if (!troop || troop.nationId !== general.nationId) {
|
|
return {
|
|
type: 'troopJoin',
|
|
ok: false,
|
|
generalId: command.generalId,
|
|
troopId: command.troopId,
|
|
reason: '부대가 올바르지 않습니다.',
|
|
};
|
|
}
|
|
|
|
world.updateGeneral(command.generalId, {
|
|
troopId: command.troopId,
|
|
});
|
|
if (
|
|
hasScenarioStaticEventHandler(
|
|
world.getScenarioConfig(),
|
|
LEGACY_TROOP_JOIN_EVENT,
|
|
IMMEDIATE_TROOP_JOIN_MOVE_HANDLER
|
|
)
|
|
) {
|
|
const leader = world.getGeneralById(troop.id);
|
|
if (
|
|
leader &&
|
|
leader.troopId === leader.id &&
|
|
leader.nationId === general.nationId &&
|
|
leader.cityId !== general.cityId
|
|
) {
|
|
const city = world.getCityById(leader.cityId);
|
|
if (city) {
|
|
world.updateGeneral(command.generalId, {
|
|
troopId: command.troopId,
|
|
cityId: leader.cityId,
|
|
});
|
|
const josaRo = JosaUtil.pick(city.name, '로');
|
|
world.pushLog({
|
|
scope: LogScope.GENERAL,
|
|
category: LogCategory.ACTION,
|
|
format: LogFormat.PLAIN,
|
|
text: `부대 주둔지인 <G><b>${city.name}</b></>${josaRo} 즉시 이동합니다.`,
|
|
generalId: general.id,
|
|
meta: {},
|
|
});
|
|
}
|
|
}
|
|
}
|
|
return {
|
|
type: 'troopJoin',
|
|
ok: true,
|
|
generalId: command.generalId,
|
|
troopId: command.troopId,
|
|
};
|
|
}
|
|
|
|
async function handleTroopCreate(
|
|
ctx: CommandHandlerContext,
|
|
command: Extract<TurnDaemonCommand, { type: 'troopCreate' }>
|
|
): Promise<TurnDaemonCommandResult> {
|
|
const { world } = ctx;
|
|
const general = world.getGeneralById(command.generalId);
|
|
if (!general) {
|
|
return {
|
|
type: 'troopCreate',
|
|
ok: false,
|
|
generalId: command.generalId,
|
|
reason: '장수 정보를 찾을 수 없습니다.',
|
|
};
|
|
}
|
|
|
|
const troopName = normalizeTroopName(command.troopName);
|
|
if (!troopName) {
|
|
return { type: 'troopCreate', ok: false, generalId: command.generalId, reason: '부대 이름이 없습니다.' };
|
|
}
|
|
if (!isValidTroopNameWidth(troopName)) {
|
|
return {
|
|
type: 'troopCreate',
|
|
ok: false,
|
|
generalId: command.generalId,
|
|
reason: '부대 이름은 전각 9자 또는 반각 18자 이하여야 합니다.',
|
|
};
|
|
}
|
|
if (general.troopId !== 0 || world.getTroopById(general.id)) {
|
|
return {
|
|
type: 'troopCreate',
|
|
ok: false,
|
|
generalId: command.generalId,
|
|
reason: '이미 부대에 소속되어 있습니다.',
|
|
};
|
|
}
|
|
if (general.nationId <= 0 || !world.getNationById(general.nationId)) {
|
|
return {
|
|
type: 'troopCreate',
|
|
ok: false,
|
|
generalId: command.generalId,
|
|
reason: '국가에 소속되어 있지 않습니다.',
|
|
};
|
|
}
|
|
|
|
const troop = world.createTroop({
|
|
id: general.id,
|
|
nationId: general.nationId,
|
|
name: troopName,
|
|
});
|
|
if (!troop) {
|
|
return {
|
|
type: 'troopCreate',
|
|
ok: false,
|
|
generalId: command.generalId,
|
|
reason: '부대가 생성되지 않았습니다. 버그일 수 있습니다.',
|
|
};
|
|
}
|
|
world.updateGeneral(general.id, { troopId: general.id });
|
|
return {
|
|
type: 'troopCreate',
|
|
ok: true,
|
|
generalId: general.id,
|
|
troopId: troop.id,
|
|
troopName: troop.name,
|
|
};
|
|
}
|
|
|
|
async function handleTroopExit(
|
|
ctx: CommandHandlerContext,
|
|
command: Extract<TurnDaemonCommand, { type: 'troopExit' }>
|
|
): Promise<TurnDaemonCommandResult> {
|
|
const { world } = ctx;
|
|
const general = world.getGeneralById(command.generalId);
|
|
if (!general) {
|
|
return {
|
|
type: 'troopExit',
|
|
ok: false,
|
|
generalId: command.generalId,
|
|
reason: '장수 정보를 찾을 수 없습니다.',
|
|
};
|
|
}
|
|
if (general.troopId === 0) {
|
|
return {
|
|
type: 'troopExit',
|
|
ok: false,
|
|
generalId: command.generalId,
|
|
reason: '부대에 소속되어 있지 않습니다.',
|
|
};
|
|
}
|
|
|
|
if (general.troopId !== general.id) {
|
|
world.updateGeneral(command.generalId, {
|
|
troopId: 0,
|
|
});
|
|
return {
|
|
type: 'troopExit',
|
|
ok: true,
|
|
generalId: command.generalId,
|
|
wasLeader: false,
|
|
};
|
|
}
|
|
|
|
const troopId = general.troopId;
|
|
const members = world.listGenerals().filter((entry) => entry.troopId === troopId);
|
|
for (const member of members) {
|
|
world.updateGeneral(member.id, { troopId: 0 });
|
|
}
|
|
world.removeTroop(troopId);
|
|
return {
|
|
type: 'troopExit',
|
|
ok: true,
|
|
generalId: command.generalId,
|
|
wasLeader: true,
|
|
};
|
|
}
|
|
|
|
async function handleTroopKick(
|
|
ctx: CommandHandlerContext,
|
|
command: Extract<TurnDaemonCommand, { type: 'troopKick' }>
|
|
): Promise<TurnDaemonCommandResult> {
|
|
const fail = (reason: string): TurnDaemonCommandResult => ({
|
|
type: 'troopKick',
|
|
ok: false,
|
|
generalId: command.generalId,
|
|
troopId: command.troopId,
|
|
targetGeneralId: command.targetGeneralId,
|
|
reason,
|
|
});
|
|
const { world } = ctx;
|
|
const actor = world.getGeneralById(command.generalId);
|
|
if (!actor) {
|
|
return fail('장수 정보를 찾을 수 없습니다.');
|
|
}
|
|
const troop = world.getTroopById(command.troopId);
|
|
if (
|
|
command.generalId !== command.troopId ||
|
|
actor.troopId !== actor.id ||
|
|
!troop ||
|
|
troop.id !== actor.id ||
|
|
troop.nationId !== actor.nationId
|
|
) {
|
|
return fail('권한이 부족합니다.');
|
|
}
|
|
|
|
const target = world.getGeneralById(command.targetGeneralId);
|
|
if (!target) {
|
|
return fail('장수 정보를 찾을 수 없습니다.');
|
|
}
|
|
if (target.troopId === 0) {
|
|
return fail('부대에 소속되어 있지 않습니다.');
|
|
}
|
|
if (target.troopId !== command.troopId) {
|
|
return fail('다른 부대에 소속되어 있습니다.');
|
|
}
|
|
if (target.id === command.troopId) {
|
|
return fail('부대장을 추방할 수 없습니다.');
|
|
}
|
|
|
|
world.updateGeneral(target.id, { troopId: 0 });
|
|
return {
|
|
type: 'troopKick',
|
|
ok: true,
|
|
generalId: actor.id,
|
|
troopId: troop.id,
|
|
targetGeneralId: target.id,
|
|
};
|
|
}
|
|
|
|
async function handleTroopRename(
|
|
ctx: CommandHandlerContext,
|
|
command: Extract<TurnDaemonCommand, { type: 'troopRename' }>
|
|
): Promise<TurnDaemonCommandResult> {
|
|
const fail = (reason: string): TurnDaemonCommandResult => ({
|
|
type: 'troopRename',
|
|
ok: false,
|
|
generalId: command.generalId,
|
|
troopId: command.troopId,
|
|
reason,
|
|
});
|
|
const { world } = ctx;
|
|
const actor = world.getGeneralById(command.generalId);
|
|
if (!actor) {
|
|
return fail('장수 정보를 찾을 수 없습니다.');
|
|
}
|
|
|
|
const nation = world.getNationById(actor.nationId);
|
|
const permission = resolveTroopSecretPermission(actor, nation?.meta ?? {}, false);
|
|
if (actor.id !== command.troopId && permission < 4) {
|
|
return fail('권한이 부족합니다.');
|
|
}
|
|
|
|
const troopName = normalizeTroopName(command.troopName);
|
|
if (!troopName) {
|
|
return fail('부대 이름이 없습니다.');
|
|
}
|
|
if (!isValidTroopNameWidth(troopName)) {
|
|
return fail('부대 이름은 전각 9자 또는 반각 18자 이하여야 합니다.');
|
|
}
|
|
|
|
const troop = world.getTroopById(command.troopId);
|
|
if (!troop || actor.nationId <= 0 || troop.nationId !== actor.nationId) {
|
|
return fail('부대가 없습니다.');
|
|
}
|
|
world.updateTroop(troop.id, { name: troopName });
|
|
return {
|
|
type: 'troopRename',
|
|
ok: true,
|
|
generalId: actor.id,
|
|
troopId: troop.id,
|
|
troopName,
|
|
};
|
|
}
|
|
|
|
async function handleDieOnPrestart(
|
|
ctx: CommandHandlerContext,
|
|
command: Extract<TurnDaemonCommand, { type: 'dieOnPrestart' }>
|
|
): Promise<TurnDaemonCommandResult> {
|
|
const { world } = ctx;
|
|
const general = world.getGeneralById(command.generalId);
|
|
if (!general) {
|
|
return {
|
|
type: 'dieOnPrestart',
|
|
ok: false,
|
|
generalId: command.generalId,
|
|
reason: '장수 정보를 찾을 수 없습니다.',
|
|
};
|
|
}
|
|
const worldState = world.getState();
|
|
const opentime = worldState.meta.opentime as string | undefined;
|
|
if (opentime && new Date(worldState.lastTurnTime) > new Date(opentime)) {
|
|
return { type: 'dieOnPrestart', ok: false, generalId: command.generalId, reason: '가오픈 기간이 아닙니다.' };
|
|
}
|
|
|
|
if (general.npcState !== 0 || general.nationId !== 0) {
|
|
return { type: 'dieOnPrestart', ok: false, generalId: command.generalId, reason: '삭제할 수 없는 상태입니다.' };
|
|
}
|
|
|
|
world.removeGeneral(command.generalId);
|
|
return { type: 'dieOnPrestart', ok: true, generalId: command.generalId };
|
|
}
|
|
|
|
async function handleBuildNationCandidate(
|
|
ctx: CommandHandlerContext,
|
|
command: Extract<TurnDaemonCommand, { type: 'buildNationCandidate' }>
|
|
): Promise<TurnDaemonCommandResult> {
|
|
const { world } = ctx;
|
|
const general = world.getGeneralById(command.generalId);
|
|
if (!general) {
|
|
return {
|
|
type: 'buildNationCandidate',
|
|
ok: false,
|
|
generalId: command.generalId,
|
|
reason: '장수가 없습니다',
|
|
};
|
|
}
|
|
await assertImmediateGeneralActionActor(ctx, command, general);
|
|
|
|
const worldState = world.getState();
|
|
const opentime = worldState.meta.opentime as string | undefined;
|
|
if (opentime && new Date(worldState.lastTurnTime) > new Date(opentime)) {
|
|
return {
|
|
type: 'buildNationCandidate',
|
|
ok: false,
|
|
generalId: command.generalId,
|
|
reason: '게임이 시작되었습니다.',
|
|
};
|
|
}
|
|
if (general.nationId !== 0) {
|
|
return {
|
|
type: 'buildNationCandidate',
|
|
ok: false,
|
|
generalId: command.generalId,
|
|
reason: '이미 국가에 소속되어있습니다.',
|
|
};
|
|
}
|
|
|
|
if (!ctx.getImmediateGeneralActionExecutor) {
|
|
throw new Error('Immediate general action runtime is not configured.');
|
|
}
|
|
const hiddenSeed = asRecord(worldState.meta).hiddenSeed ?? asRecord(worldState.meta).seed ?? worldState.id;
|
|
const executor = await ctx.getImmediateGeneralActionExecutor();
|
|
const execution = await executor.execute({
|
|
actionKey: 'che_거병',
|
|
generalId: command.generalId,
|
|
rng: new RandUtil(
|
|
new LiteHashDRBG(
|
|
simpleSerialize(
|
|
typeof hiddenSeed === 'string' || typeof hiddenSeed === 'number' ? hiddenSeed : String(hiddenSeed),
|
|
'BuildNationCandidate',
|
|
command.generalId
|
|
)
|
|
)
|
|
),
|
|
refreshKillturn: true,
|
|
});
|
|
return {
|
|
type: 'buildNationCandidate',
|
|
ok: execution.ok,
|
|
generalId: command.generalId,
|
|
...(execution.reason ? { reason: execution.reason } : {}),
|
|
};
|
|
}
|
|
|
|
async function handleInstantRetreat(
|
|
ctx: CommandHandlerContext,
|
|
command: Extract<TurnDaemonCommand, { type: 'instantRetreat' }>
|
|
): Promise<TurnDaemonCommandResult> {
|
|
const { world } = ctx;
|
|
const config = world.getScenarioConfig();
|
|
const availableInstantAction = config.const.availableInstantAction as Record<string, boolean> | undefined;
|
|
if (!availableInstantAction?.instantRetreat) {
|
|
return {
|
|
type: 'instantRetreat',
|
|
ok: false,
|
|
generalId: command.generalId,
|
|
reason: '접경귀환을 사용할 수 없는 시나리오입니다.',
|
|
};
|
|
}
|
|
const general = world.getGeneralById(command.generalId);
|
|
if (!general) {
|
|
return {
|
|
type: 'instantRetreat',
|
|
ok: false,
|
|
generalId: command.generalId,
|
|
reason: '장수가 없습니다',
|
|
};
|
|
}
|
|
await assertImmediateGeneralActionActor(ctx, command, general);
|
|
|
|
if (!ctx.getImmediateGeneralActionExecutor) {
|
|
throw new Error('Immediate general action runtime is not configured.');
|
|
}
|
|
const state = world.getState();
|
|
const hiddenSeed = asRecord(state.meta).hiddenSeed ?? asRecord(state.meta).seed ?? state.id;
|
|
const executor = await ctx.getImmediateGeneralActionExecutor();
|
|
const execution = await executor.execute({
|
|
actionKey: 'che_접경귀환',
|
|
generalId: command.generalId,
|
|
rng: new RandUtil(
|
|
new LiteHashDRBG(
|
|
simpleSerialize(
|
|
typeof hiddenSeed === 'string' || typeof hiddenSeed === 'number' ? hiddenSeed : String(hiddenSeed),
|
|
'InstantRetreat',
|
|
command.generalId,
|
|
state.currentYear,
|
|
state.currentMonth,
|
|
general.cityId
|
|
)
|
|
)
|
|
),
|
|
});
|
|
return {
|
|
type: 'instantRetreat',
|
|
ok: execution.ok,
|
|
generalId: command.generalId,
|
|
...(execution.reason ? { reason: execution.reason } : {}),
|
|
};
|
|
}
|
|
|
|
async function handleVacation(
|
|
ctx: CommandHandlerContext,
|
|
command: Extract<TurnDaemonCommand, { type: 'vacation' }>
|
|
): Promise<TurnDaemonCommandResult> {
|
|
const { world } = ctx;
|
|
const general = world.getGeneralById(command.generalId);
|
|
if (!general) {
|
|
return { type: 'vacation', ok: false, generalId: command.generalId, reason: '장수 정보를 찾을 수 없습니다.' };
|
|
}
|
|
const autorunUser = asRecord(world.getState().meta.autorun_user);
|
|
if (autorunUser.limit_minutes) {
|
|
return {
|
|
type: 'vacation',
|
|
ok: false,
|
|
generalId: command.generalId,
|
|
reason: '자동 턴인 경우에는 휴가 명령이 불가능합니다.',
|
|
};
|
|
}
|
|
const killturn = readMetaNumber(asRecord(world.getState().meta), 'killturn', 0);
|
|
world.updateGeneral(general.id, {
|
|
meta: {
|
|
...general.meta,
|
|
killturn: killturn * 3,
|
|
},
|
|
});
|
|
return { type: 'vacation', ok: true, generalId: command.generalId };
|
|
}
|
|
|
|
const normalizeDefenceTrain = (value: number): number => {
|
|
if (value <= 40) {
|
|
return 40;
|
|
}
|
|
if (value <= 90) {
|
|
return Math.round(value / 10) * 10;
|
|
}
|
|
return 999;
|
|
};
|
|
|
|
async function handleSetMySetting(
|
|
ctx: CommandHandlerContext,
|
|
command: Extract<TurnDaemonCommand, { type: 'setMySetting' }>
|
|
): Promise<TurnDaemonCommandResult> {
|
|
const { world } = ctx;
|
|
const general = world.getGeneralById(command.generalId);
|
|
if (!general) {
|
|
return {
|
|
type: 'setMySetting',
|
|
ok: false,
|
|
generalId: command.generalId,
|
|
reason: '장수 정보를 찾을 수 없습니다.',
|
|
};
|
|
}
|
|
|
|
const settings = command.settings;
|
|
const previousDefenceTrain = readMetaNumber(general.meta, 'defence_train', 80);
|
|
const nextDefenceTrain =
|
|
settings.defence_train === undefined ? previousDefenceTrain : normalizeDefenceTrain(settings.defence_train);
|
|
const nextMeta = { ...general.meta };
|
|
|
|
if (settings.tnmt !== undefined) {
|
|
nextMeta.tnmt = settings.tnmt < 0 || settings.tnmt > 1 ? 1 : settings.tnmt;
|
|
}
|
|
if (settings.use_treatment !== undefined) {
|
|
nextMeta.use_treatment = Math.max(10, Math.min(100, settings.use_treatment));
|
|
}
|
|
if (settings.use_auto_nation_turn !== undefined) {
|
|
nextMeta.use_auto_nation_turn = settings.use_auto_nation_turn;
|
|
}
|
|
|
|
let nextTrain = general.train;
|
|
let nextAtmos = general.atmos;
|
|
if (nextDefenceTrain !== previousDefenceTrain) {
|
|
nextMeta.myset = readMetaNumber(general.meta, 'myset', 0) - 1;
|
|
nextMeta.defence_train = nextDefenceTrain;
|
|
if (nextDefenceTrain === 999) {
|
|
const scenarioEffect = world.getScenarioConfig().environment.scenarioEffect;
|
|
const ignoresPenalty = isDefenceTrainPenaltyWaivedByScenarioEffect(scenarioEffect);
|
|
const constValues = asRecord(world.getScenarioConfig().const);
|
|
const maxTrain = readMetaNumber(constValues, 'maxTrainByWar', 100);
|
|
const maxAtmos = readMetaNumber(constValues, 'maxAtmosByWar', 100);
|
|
const trainDelta = ignoresPenalty ? 0 : -3;
|
|
const atmosDelta = ignoresPenalty ? 0 : -6;
|
|
nextTrain = Math.max(20, Math.min(maxTrain, general.train + trainDelta));
|
|
nextAtmos = Math.max(20, Math.min(maxAtmos, general.atmos + atmosDelta));
|
|
}
|
|
}
|
|
|
|
world.updateGeneral(command.generalId, {
|
|
meta: nextMeta,
|
|
train: nextTrain,
|
|
atmos: nextAtmos,
|
|
});
|
|
return { type: 'setMySetting', ok: true, generalId: command.generalId };
|
|
}
|
|
|
|
async function handleDropItem(
|
|
ctx: CommandHandlerContext,
|
|
command: Extract<TurnDaemonCommand, { type: 'dropItem' }>
|
|
): Promise<TurnDaemonCommandResult> {
|
|
const { world } = ctx;
|
|
const general = world.getGeneralById(command.generalId);
|
|
if (!general) {
|
|
return { type: 'dropItem', ok: false, generalId: command.generalId, reason: '장수 정보를 찾을 수 없습니다.' };
|
|
}
|
|
const slot = (['horse', 'weapon', 'book', 'item'] as const).find((candidate) => candidate === command.itemType);
|
|
if (!slot || !general.role.items[slot]) {
|
|
return { type: 'dropItem', ok: false, generalId: command.generalId, reason: '아이템을 가지고 있지 않습니다.' };
|
|
}
|
|
const nextGeneral = {
|
|
...general,
|
|
role: { ...general.role, items: { ...general.role.items } },
|
|
itemInventory: cloneItemInventory(ensureItemInventory(general)),
|
|
};
|
|
removeEquippedItem(nextGeneral, slot);
|
|
|
|
world.updateGeneral(command.generalId, {
|
|
role: nextGeneral.role,
|
|
itemInventory: nextGeneral.itemInventory,
|
|
});
|
|
return { type: 'dropItem', ok: true, generalId: command.generalId };
|
|
}
|
|
|
|
async function handleAuctionFinalize(
|
|
ctx: CommandHandlerContext,
|
|
command: Extract<TurnDaemonCommand, { type: 'auctionFinalize' }>
|
|
): Promise<TurnDaemonCommandResult> {
|
|
if (!ctx.auctionFinalizer) {
|
|
return {
|
|
type: 'auctionFinalize',
|
|
ok: false,
|
|
auctionId: command.auctionId,
|
|
reason: '경매 확정기가 준비되지 않았습니다.',
|
|
};
|
|
}
|
|
return ctx.auctionFinalizer.finalize(command.auctionId, ctx.commandDb);
|
|
}
|
|
|
|
async function handleAuctionOpen(
|
|
ctx: CommandHandlerContext,
|
|
command: Extract<TurnDaemonCommand, { type: 'auctionOpen' }>
|
|
): Promise<TurnDaemonCommandResult> {
|
|
return openAuction(command, ctx.world, ctx.commandDb);
|
|
}
|
|
|
|
async function handleAuctionBid(
|
|
ctx: CommandHandlerContext,
|
|
command: Extract<TurnDaemonCommand, { type: 'auctionBid' }>
|
|
): Promise<TurnDaemonCommandResult> {
|
|
if (!ctx.auctionBidder) {
|
|
return {
|
|
type: 'auctionBid',
|
|
ok: false,
|
|
auctionId: command.auctionId,
|
|
reason: '경매 입찰기가 준비되지 않았습니다.',
|
|
};
|
|
}
|
|
return ctx.auctionBidder.bid(command, ctx.commandDb);
|
|
}
|
|
|
|
async function handleChangePermission(
|
|
ctx: CommandHandlerContext,
|
|
command: Extract<TurnDaemonCommand, { type: 'changePermission' }>
|
|
): Promise<TurnDaemonCommandResult> {
|
|
const { world } = ctx;
|
|
const general = world.getGeneralById(command.generalId);
|
|
if (!general) {
|
|
return {
|
|
type: 'changePermission',
|
|
ok: false,
|
|
generalId: command.generalId,
|
|
reason: '장수 정보를 찾을 수 없습니다.',
|
|
};
|
|
}
|
|
const nation = world.getNationById(general.nationId);
|
|
if (!nation || general.officerLevel !== 12 || nation.chiefGeneralId !== general.id) {
|
|
return { type: 'changePermission', ok: false, generalId: command.generalId, reason: '군주가 아닙니다.' };
|
|
}
|
|
|
|
const uniqueTargetIds = [...new Set(command.targetGeneralIds)];
|
|
if (uniqueTargetIds.length > 2) {
|
|
return {
|
|
type: 'changePermission',
|
|
ok: false,
|
|
generalId: command.generalId,
|
|
reason: command.isAmbassador
|
|
? '외교권자는 최대 둘까지만 설정 가능합니다.'
|
|
: '조언자는 최대 둘까지만 설정 가능합니다.',
|
|
};
|
|
}
|
|
|
|
const targetType = command.isAmbassador ? 'ambassador' : 'auditor';
|
|
const requiredPermission = command.isAmbassador ? 4 : 3;
|
|
const targets: TurnGeneral[] = [];
|
|
for (const targetId of uniqueTargetIds) {
|
|
const target = world.getGeneralById(targetId);
|
|
if (
|
|
!target ||
|
|
target.nationId !== general.nationId ||
|
|
target.officerLevel === 12 ||
|
|
!['normal', targetType].includes(resolvePermissionKind(target)) ||
|
|
resolveMaxSecretPermission(target) < requiredPermission
|
|
) {
|
|
continue;
|
|
}
|
|
targets.push(target);
|
|
}
|
|
|
|
for (const candidate of world.listGenerals()) {
|
|
if (candidate.nationId !== general.nationId || resolvePermissionKind(candidate) !== targetType) {
|
|
continue;
|
|
}
|
|
world.updateGeneral(candidate.id, {
|
|
meta: {
|
|
...candidate.meta,
|
|
permission: 'normal',
|
|
},
|
|
});
|
|
}
|
|
for (const target of targets) {
|
|
world.updateGeneral(target.id, {
|
|
meta: {
|
|
...target.meta,
|
|
permission: targetType,
|
|
},
|
|
});
|
|
}
|
|
return { type: 'changePermission', ok: true, generalId: command.generalId };
|
|
}
|
|
|
|
async function handleKick(
|
|
ctx: CommandHandlerContext,
|
|
command: Extract<TurnDaemonCommand, { type: 'kick' }>
|
|
): Promise<TurnDaemonCommandResult> {
|
|
const { world } = ctx;
|
|
const general = world.getGeneralById(command.generalId);
|
|
if (!general) {
|
|
return { type: 'kick', ok: false, generalId: command.generalId, reason: '장수 정보를 찾을 수 없습니다.' };
|
|
}
|
|
const nation = world.getNationById(general.nationId);
|
|
if (!nation || general.officerLevel < 5) {
|
|
return { type: 'kick', ok: false, generalId: command.generalId, reason: '수뇌가 아닙니다.' };
|
|
}
|
|
const actorPenalty = asRecord(general.penalty);
|
|
if (actorPenalty.noBanGeneral) {
|
|
return { type: 'kick', ok: false, generalId: command.generalId, reason: '추방할 수 없는 상태입니다.' };
|
|
}
|
|
if (hasOfficerLock(asRecord(nation.meta), 'chief_set', general.officerLevel)) {
|
|
return {
|
|
type: 'kick',
|
|
ok: false,
|
|
generalId: command.generalId,
|
|
reason: '이미 추방 권한을 사용했습니다.',
|
|
};
|
|
}
|
|
|
|
const target = world.getGeneralById(command.destGeneralId);
|
|
if (!target || target.id === general.id || target.nationId !== general.nationId) {
|
|
return {
|
|
type: 'kick',
|
|
ok: false,
|
|
generalId: command.generalId,
|
|
reason: '대상을 찾을 수 없거나 같은 국가가 아닙니다.',
|
|
};
|
|
}
|
|
if (resolveMaxSecretPermission(target) === 4 && resolvePermissionKind(target) === 'ambassador') {
|
|
return {
|
|
type: 'kick',
|
|
ok: false,
|
|
generalId: command.generalId,
|
|
reason: '외교권자는 추방할 수 없습니다.',
|
|
};
|
|
}
|
|
|
|
const config = asRecord(world.getScenarioConfig().const);
|
|
const defaultGold = readMetaNumber(config, 'defaultGold', 1000);
|
|
const defaultRice = readMetaNumber(config, 'defaultRice', 1000);
|
|
const returnedGold = Math.max(0, target.gold - defaultGold);
|
|
const returnedRice = Math.max(0, target.rice - defaultRice);
|
|
const targetMeta = target.meta;
|
|
const nextMeta: TurnGeneral['meta'] = {
|
|
...targetMeta,
|
|
officerCity: 0,
|
|
officer_city: 0,
|
|
belong: 0,
|
|
makelimit: 12,
|
|
permission: 'normal',
|
|
};
|
|
|
|
const worldState = world.getState();
|
|
const scenarioMeta = asRecord(asRecord(worldState.meta).scenarioMeta);
|
|
const startYear = readMetaNumber(scenarioMeta, 'startYear', worldState.currentYear);
|
|
if (worldState.currentYear > startYear || target.npcState >= 2) {
|
|
const betray = Math.max(0, readMetaNumber(targetMeta, 'betray', 0));
|
|
const maxBetrayCnt = readMetaNumber(config, 'maxBetrayCnt', 9);
|
|
nextMeta.betray = Math.min(maxBetrayCnt, betray + 1);
|
|
world.updateGeneral(target.id, {
|
|
experience: Math.max(0, Math.floor(target.experience - target.experience * 0.15 * betray)),
|
|
dedication: Math.max(0, Math.floor(target.dedication - target.dedication * 0.15 * betray)),
|
|
});
|
|
} else {
|
|
nextMeta.makelimit = targetMeta.makelimit ?? 12;
|
|
}
|
|
if (worldState.currentYear < startYear + 3) {
|
|
const ruler = world.getGeneralById(nation.chiefGeneralId ?? 0);
|
|
if (ruler) {
|
|
world.updateGeneral(ruler.id, { injury: Math.min(80, ruler.injury + 1) });
|
|
}
|
|
}
|
|
|
|
if (target.troopId === target.id) {
|
|
for (const member of world.listGenerals()) {
|
|
if (member.troopId === target.id) {
|
|
world.updateGeneral(member.id, { troopId: 0 });
|
|
}
|
|
}
|
|
world.removeTroop(target.id);
|
|
}
|
|
|
|
world.updateGeneral(command.destGeneralId, {
|
|
nationId: 0,
|
|
officerLevel: 0,
|
|
troopId: 0,
|
|
gold: Math.min(target.gold, defaultGold),
|
|
rice: Math.min(target.rice, defaultRice),
|
|
meta: nextMeta,
|
|
});
|
|
const nationMeta =
|
|
worldState.currentYear >= startYear + 3
|
|
? setOfficerLock(nation.meta, 'chief_set', general.officerLevel)
|
|
: { ...nation.meta };
|
|
nationMeta.gennum = Math.max(0, readMetaNumber(nation.meta, 'gennum', 0) - (target.npcState !== 5 ? 1 : 0));
|
|
world.updateNation(nation.id, {
|
|
gold: nation.gold + returnedGold,
|
|
rice: nation.rice + returnedRice,
|
|
meta: nationMeta,
|
|
});
|
|
refreshActorKillturn(world, general);
|
|
|
|
const josaYi = JosaUtil.pick(target.name, '이');
|
|
world.pushLog({
|
|
scope: LogScope.SYSTEM,
|
|
category: LogCategory.SUMMARY,
|
|
format: LogFormat.MONTH,
|
|
text: `<Y>${target.name}</>${josaYi} <D><b>${nation.name}</b></>에서 <R>추방</>당했습니다.`,
|
|
meta: {},
|
|
});
|
|
world.pushLog({
|
|
scope: LogScope.GENERAL,
|
|
category: LogCategory.HISTORY,
|
|
format: LogFormat.YEAR_MONTH,
|
|
text: `<D>${nation.name}</>에서 추방됨`,
|
|
generalId: target.id,
|
|
meta: {},
|
|
});
|
|
if (target.npcState >= 2) {
|
|
const worldMeta = asRecord(worldState.meta);
|
|
const hiddenSeed = worldMeta.hiddenSeed ?? worldMeta.seed ?? worldState.id;
|
|
const rng = new RandUtil(
|
|
new LiteHashDRBG(
|
|
simpleSerialize(
|
|
typeof hiddenSeed === 'string' || typeof hiddenSeed === 'number' ? hiddenSeed : String(hiddenSeed),
|
|
'BanNPC',
|
|
worldState.currentYear,
|
|
worldState.currentMonth,
|
|
target.id
|
|
)
|
|
)
|
|
);
|
|
const npcBanMessageProb = readMetaNumber(config, 'npcBanMessageProb', 0.01);
|
|
if (rng.nextBool(npcBanMessageProb)) {
|
|
const text = rng.choice([
|
|
'날 버리다니... 곧 전장에서 복수해주겠다...',
|
|
'추방이라... 내가 무얼 잘못했단 말인가...',
|
|
'어디 추방해가면서 잘되나 보자... 꼭 복수하겠다.',
|
|
'인덕이 제일이거늘... 추방이 웬말인가... 저주한다!',
|
|
'날 추방했으니 그 복수로 적국에 정보를 팔아 넘겨야겠군요. 그럼 이만.',
|
|
]);
|
|
const messageTarget = {
|
|
generalId: target.id,
|
|
generalName: target.name,
|
|
nationId: nation.id,
|
|
nationName: nation.name,
|
|
color: nation.color,
|
|
icon: target.picture === null ? '' : String(target.picture),
|
|
};
|
|
world.queueMessage({
|
|
msgType: 'public',
|
|
src: messageTarget,
|
|
dest: messageTarget,
|
|
text,
|
|
time: new Date(),
|
|
validUntil: new Date('9999-12-31T00:00:00.000Z'),
|
|
option: {},
|
|
});
|
|
}
|
|
}
|
|
return { type: 'kick', ok: true, generalId: command.generalId };
|
|
}
|
|
|
|
async function handleAppoint(
|
|
ctx: CommandHandlerContext,
|
|
command: Extract<TurnDaemonCommand, { type: 'appoint' }>
|
|
): Promise<TurnDaemonCommandResult> {
|
|
const { world } = ctx;
|
|
const general = world.getGeneralById(command.generalId);
|
|
if (!general) {
|
|
return { type: 'appoint', ok: false, generalId: command.generalId, reason: '장수 정보를 찾을 수 없습니다.' };
|
|
}
|
|
const nation = world.getNationById(general.nationId);
|
|
if (!nation || general.officerLevel < 5) {
|
|
return { type: 'appoint', ok: false, generalId: command.generalId, reason: '수뇌가 아닙니다.' };
|
|
}
|
|
const actorPenalty = asRecord(general.penalty);
|
|
if (command.officerLevel === 12) {
|
|
return {
|
|
type: 'appoint',
|
|
ok: false,
|
|
generalId: command.generalId,
|
|
reason: '군주를 대상으로 할 수 없습니다.',
|
|
};
|
|
}
|
|
|
|
const target = world.getGeneralById(command.destGeneralId);
|
|
if (command.destGeneralId !== 0 && (!target || target.nationId !== general.nationId)) {
|
|
return {
|
|
type: 'appoint',
|
|
ok: false,
|
|
generalId: command.generalId,
|
|
reason: '대상을 찾을 수 없거나 같은 국가가 아닙니다.',
|
|
};
|
|
}
|
|
|
|
if (command.officerLevel >= 5 && command.officerLevel < 12) {
|
|
if (actorPenalty.noChiefChange) {
|
|
return {
|
|
type: 'appoint',
|
|
ok: false,
|
|
generalId: command.generalId,
|
|
reason: '수뇌를 임명할 수 없는 상태입니다.',
|
|
};
|
|
}
|
|
const minLevel = resolveNationChiefLevel(nation.level);
|
|
if (command.officerLevel < minLevel) {
|
|
return {
|
|
type: 'appoint',
|
|
ok: false,
|
|
generalId: command.generalId,
|
|
reason: '임명불가능한 관직입니다.',
|
|
};
|
|
}
|
|
if (hasOfficerLock(asRecord(nation.meta), 'chief_set', command.officerLevel)) {
|
|
return {
|
|
type: 'appoint',
|
|
ok: false,
|
|
generalId: command.generalId,
|
|
reason: '지금은 임명할 수 없습니다.',
|
|
};
|
|
}
|
|
if (target) {
|
|
const targetPenalty = asRecord(target.penalty);
|
|
if (targetPenalty.noChief) {
|
|
return {
|
|
type: 'appoint',
|
|
ok: false,
|
|
generalId: command.generalId,
|
|
reason: '수뇌가 될 수 없는 상태입니다.',
|
|
};
|
|
}
|
|
const chiefStatMin = world.getScenarioConfig().stat.chiefMin;
|
|
if (command.officerLevel !== 11 && command.officerLevel % 2 === 0 && target.stats.strength < chiefStatMin) {
|
|
return { type: 'appoint', ok: false, generalId: command.generalId, reason: '무력이 부족합니다.' };
|
|
}
|
|
if (
|
|
command.officerLevel !== 11 &&
|
|
command.officerLevel % 2 === 1 &&
|
|
target.stats.intelligence < chiefStatMin
|
|
) {
|
|
return { type: 'appoint', ok: false, generalId: command.generalId, reason: '지력이 부족합니다.' };
|
|
}
|
|
}
|
|
for (const g of world.listGenerals()) {
|
|
if (g.nationId === general.nationId && g.officerLevel === command.officerLevel) {
|
|
world.updateGeneral(g.id, {
|
|
officerLevel: 1,
|
|
meta: { ...g.meta, officerCity: 0, officer_city: 0 },
|
|
});
|
|
}
|
|
}
|
|
if (command.destGeneralId !== 0) {
|
|
world.updateGeneral(command.destGeneralId, {
|
|
officerLevel: command.officerLevel,
|
|
meta: { ...target!.meta, officerCity: 0, officer_city: 0 },
|
|
});
|
|
}
|
|
world.updateNation(nation.id, {
|
|
meta: setOfficerLock(nation.meta, 'chief_set', command.officerLevel),
|
|
});
|
|
} else if (command.officerLevel >= 2 && command.officerLevel <= 4) {
|
|
const city = world.getCityById(command.destCityId);
|
|
if (!city || city.nationId !== general.nationId) {
|
|
return {
|
|
type: 'appoint',
|
|
ok: false,
|
|
generalId: command.generalId,
|
|
reason: '도시를 찾을 수 없거나 아군 도시가 아닙니다.',
|
|
};
|
|
}
|
|
if (hasOfficerLock(asRecord(city.meta), 'officer_set', command.officerLevel)) {
|
|
return {
|
|
type: 'appoint',
|
|
ok: false,
|
|
generalId: command.generalId,
|
|
reason: '이미 다른 장수가 임명되어있습니다.',
|
|
};
|
|
}
|
|
if (target && target.officerLevel >= 4 && actorPenalty.noChiefChange) {
|
|
return {
|
|
type: 'appoint',
|
|
ok: false,
|
|
generalId: command.generalId,
|
|
reason: '수뇌인 장수를 변경할 수 없는 상태입니다.',
|
|
};
|
|
}
|
|
const chiefStatMin = world.getScenarioConfig().stat.chiefMin;
|
|
if (target && command.officerLevel === 4 && target.stats.strength < chiefStatMin) {
|
|
return { type: 'appoint', ok: false, generalId: command.generalId, reason: '무력이 부족합니다.' };
|
|
}
|
|
if (target && command.officerLevel === 3 && target.stats.intelligence < chiefStatMin) {
|
|
return { type: 'appoint', ok: false, generalId: command.generalId, reason: '지력이 부족합니다.' };
|
|
}
|
|
for (const g of world.listGenerals()) {
|
|
if (
|
|
g.nationId === general.nationId &&
|
|
g.meta.officerCity === command.destCityId &&
|
|
g.officerLevel === command.officerLevel
|
|
) {
|
|
world.updateGeneral(g.id, {
|
|
officerLevel: 1,
|
|
meta: { ...g.meta, officerCity: 0, officer_city: 0 },
|
|
});
|
|
}
|
|
}
|
|
if (command.destGeneralId !== 0) {
|
|
world.updateGeneral(command.destGeneralId, {
|
|
officerLevel: command.officerLevel,
|
|
meta: { ...target!.meta, officerCity: command.destCityId, officer_city: command.destCityId },
|
|
});
|
|
}
|
|
world.updateCity(city.id, {
|
|
meta: setOfficerLock(city.meta, 'officer_set', command.officerLevel),
|
|
});
|
|
} else {
|
|
return { type: 'appoint', ok: false, generalId: command.generalId, reason: '올바르지 않은 지정입니다.' };
|
|
}
|
|
refreshActorKillturn(world, general);
|
|
return { type: 'appoint', ok: true, generalId: command.generalId };
|
|
}
|
|
|
|
async function handleTournamentRefund(
|
|
ctx: CommandHandlerContext,
|
|
command: Extract<TurnDaemonCommand, { type: 'tournamentRefund' }>
|
|
): Promise<TurnDaemonCommandResult> {
|
|
const { world } = ctx;
|
|
if (!command.refunds || command.refunds.length === 0) {
|
|
return {
|
|
type: 'tournamentRefund',
|
|
ok: false,
|
|
bettingId: command.bettingId,
|
|
reason: '환불 대상이 없습니다.',
|
|
};
|
|
}
|
|
|
|
let processed = 0;
|
|
let missing = 0;
|
|
let totalRefund = 0;
|
|
|
|
for (const refund of command.refunds) {
|
|
if (!refund || typeof refund.generalId !== 'number' || typeof refund.amount !== 'number') {
|
|
continue;
|
|
}
|
|
if (refund.amount <= 0) {
|
|
continue;
|
|
}
|
|
const general = world.getGeneralById(refund.generalId);
|
|
if (!general) {
|
|
missing += 1;
|
|
continue;
|
|
}
|
|
world.updateGeneral(refund.generalId, {
|
|
gold: general.gold + refund.amount,
|
|
});
|
|
processed += 1;
|
|
totalRefund += refund.amount;
|
|
}
|
|
return {
|
|
type: 'tournamentRefund',
|
|
ok: true,
|
|
bettingId: command.bettingId,
|
|
processed,
|
|
missing,
|
|
totalRefund,
|
|
};
|
|
}
|
|
|
|
async function handleTournamentBettingPayout(
|
|
ctx: CommandHandlerContext,
|
|
command: Extract<TurnDaemonCommand, { type: 'tournamentBettingPayout' }>
|
|
): Promise<TurnDaemonCommandResult> {
|
|
const { world } = ctx;
|
|
if (!command.payouts || command.payouts.length === 0) {
|
|
return {
|
|
type: 'tournamentBettingPayout',
|
|
ok: false,
|
|
bettingId: command.bettingId,
|
|
reason: '정산 대상이 없습니다.',
|
|
};
|
|
}
|
|
|
|
let processed = 0;
|
|
let missing = 0;
|
|
let totalPayout = 0;
|
|
const metaDeltas = new Map<number, { betwin: number; betwingold: number }>();
|
|
|
|
for (const payout of command.payouts) {
|
|
if (!payout || typeof payout.generalId !== 'number' || typeof payout.amount !== 'number') {
|
|
continue;
|
|
}
|
|
if (payout.amount <= 0) {
|
|
continue;
|
|
}
|
|
const general = world.getGeneralById(payout.generalId);
|
|
if (!general) {
|
|
missing += 1;
|
|
continue;
|
|
}
|
|
world.updateGeneral(payout.generalId, {
|
|
gold: general.gold + payout.amount,
|
|
});
|
|
processed += 1;
|
|
totalPayout += payout.amount;
|
|
const currentDelta = metaDeltas.get(payout.generalId) ?? { betwin: 0, betwingold: 0 };
|
|
metaDeltas.set(payout.generalId, {
|
|
betwin: currentDelta.betwin + 1,
|
|
betwingold: currentDelta.betwingold + payout.amount,
|
|
});
|
|
}
|
|
|
|
for (const [generalId, delta] of metaDeltas) {
|
|
const general = world.getGeneralById(generalId);
|
|
if (!general) {
|
|
continue;
|
|
}
|
|
const nextMeta = { ...general.meta } as TurnGeneral['meta'];
|
|
const betwinKey = 'betwin';
|
|
const betwingoldKey = 'betwingold';
|
|
const currentBetwin = typeof nextMeta[betwinKey] === 'number' ? Number(nextMeta[betwinKey]) : 0;
|
|
const currentBetwingold = typeof nextMeta[betwingoldKey] === 'number' ? Number(nextMeta[betwingoldKey]) : 0;
|
|
nextMeta[betwinKey] = currentBetwin + delta.betwin;
|
|
nextMeta[betwingoldKey] = currentBetwingold + delta.betwingold;
|
|
world.updateGeneral(generalId, { meta: nextMeta });
|
|
}
|
|
return {
|
|
type: 'tournamentBettingPayout',
|
|
ok: true,
|
|
bettingId: command.bettingId,
|
|
processed,
|
|
missing,
|
|
totalPayout,
|
|
};
|
|
}
|
|
|
|
async function handleTournamentReward(
|
|
ctx: CommandHandlerContext,
|
|
command: Extract<TurnDaemonCommand, { type: 'tournamentReward' }>
|
|
): Promise<TurnDaemonCommandResult> {
|
|
if (!ctx.tournamentRewardFinalizer) {
|
|
return {
|
|
type: 'tournamentReward',
|
|
ok: false,
|
|
winnerId: command.winnerId,
|
|
runnerUpId: command.runnerUpId,
|
|
reason: '보상 처리기가 준비되지 않았습니다.',
|
|
};
|
|
}
|
|
return ctx.tournamentRewardFinalizer.finalize(command, ctx.commandDb);
|
|
}
|
|
|
|
// 설문 보상은 API에서 전달된 RNG 결과를 재검증한 뒤 월드에 반영한다.
|
|
async function handleVoteReward(
|
|
ctx: CommandHandlerContext,
|
|
command: Extract<TurnDaemonCommand, { type: 'voteReward' }>
|
|
): Promise<TurnDaemonCommandResult> {
|
|
const { world } = ctx;
|
|
const general = world.getGeneralById(command.generalId);
|
|
if (!general) {
|
|
return {
|
|
type: 'voteReward',
|
|
ok: false,
|
|
voteId: command.voteId,
|
|
generalId: command.generalId,
|
|
reason: '장수 정보를 찾을 수 없습니다.',
|
|
};
|
|
}
|
|
|
|
const baseMeta = general.meta;
|
|
const metaRecord = asRecord(baseMeta);
|
|
const existingRewards = asRecord(metaRecord.voteRewards);
|
|
const rewardKey = String(command.voteId);
|
|
if (Object.prototype.hasOwnProperty.call(existingRewards, rewardKey)) {
|
|
const existingValue = existingRewards[rewardKey];
|
|
const existingEntry = asRecord(existingValue);
|
|
const existingItemKey = typeof existingEntry.itemKey === 'string' ? existingEntry.itemKey : null;
|
|
const awarded = existingEntry.awarded === true || Boolean(existingItemKey);
|
|
return {
|
|
type: 'voteReward',
|
|
ok: true,
|
|
voteId: command.voteId,
|
|
generalId: command.generalId,
|
|
awardedUnique: awarded,
|
|
itemKey: existingItemKey ?? null,
|
|
alreadyApplied: true,
|
|
};
|
|
}
|
|
|
|
const worldState = world.getState();
|
|
const worldMeta = asRecord(worldState.meta);
|
|
const scenarioMeta = asRecord(worldMeta.scenarioMeta);
|
|
const startYear = readMetaNumber(scenarioMeta, 'startYear', worldState.currentYear);
|
|
const initYear = readMetaNumber(worldMeta, 'initYear', startYear);
|
|
const initMonth = readMetaNumber(worldMeta, 'initMonth', 1);
|
|
const scenarioId = readMetaNumber(worldMeta, 'scenarioId', 0);
|
|
const hiddenSeed = worldMeta.hiddenSeed ?? worldMeta.seed ?? worldState.id;
|
|
|
|
const itemRegistry = await getItemRegistry();
|
|
const configConst = asRecord(world.getScenarioConfig().const);
|
|
const uniqueConfig = resolveUniqueConfig(configConst);
|
|
const generals = world.listGenerals();
|
|
const occupiedUniqueCounts = countOccupiedUniqueItems(
|
|
generals.map((entry) => entry.role.items),
|
|
itemRegistry
|
|
);
|
|
if (ctx.commandDb) {
|
|
const reservedUniqueRows = await ctx.commandDb.auction.findMany({
|
|
where: {
|
|
type: 'UNIQUE_ITEM',
|
|
status: { in: ['OPEN', 'FINALIZING'] },
|
|
targetCode: { not: null },
|
|
},
|
|
select: { targetCode: true },
|
|
});
|
|
addOccupiedUniqueItemKeys(
|
|
occupiedUniqueCounts,
|
|
reservedUniqueRows.map((row) => row.targetCode),
|
|
itemRegistry
|
|
);
|
|
}
|
|
const userCount = generals.filter((entry) => entry.npcState < 2).length;
|
|
const rngSeed = buildVoteUniqueSeed(
|
|
typeof hiddenSeed === 'string' || typeof hiddenSeed === 'number' ? hiddenSeed : String(hiddenSeed),
|
|
command.voteId,
|
|
command.generalId
|
|
);
|
|
const rng = new RandUtil(LiteHashDRBG.build(rngSeed));
|
|
const itemKey = rollUniqueLottery({
|
|
rng,
|
|
config: uniqueConfig,
|
|
itemRegistry,
|
|
generalItems: general.role.items,
|
|
occupiedUniqueCounts,
|
|
scenarioId,
|
|
userCount,
|
|
currentYear: worldState.currentYear,
|
|
currentMonth: worldState.currentMonth,
|
|
startYear,
|
|
initYear,
|
|
initMonth,
|
|
acquireType: '설문조사',
|
|
});
|
|
|
|
const expectedUnique = command.unique?.expected ?? false;
|
|
const expectedItemKey = command.unique?.itemKey ?? null;
|
|
if (expectedUnique !== Boolean(itemKey)) {
|
|
return {
|
|
type: 'voteReward',
|
|
ok: false,
|
|
voteId: command.voteId,
|
|
generalId: command.generalId,
|
|
reason: '유니크 판정이 일치하지 않습니다.',
|
|
};
|
|
}
|
|
if (expectedUnique) {
|
|
if (!expectedItemKey || !itemKey || expectedItemKey !== itemKey) {
|
|
return {
|
|
type: 'voteReward',
|
|
ok: false,
|
|
voteId: command.voteId,
|
|
generalId: command.generalId,
|
|
reason: '유니크 판정이 일치하지 않습니다.',
|
|
};
|
|
}
|
|
} else if (itemKey) {
|
|
return {
|
|
type: 'voteReward',
|
|
ok: false,
|
|
voteId: command.voteId,
|
|
generalId: command.generalId,
|
|
reason: '유니크 판정이 일치하지 않습니다.',
|
|
};
|
|
}
|
|
|
|
const rewardEntry: Record<string, TriggerValue> = {
|
|
awarded: Boolean(itemKey),
|
|
at: new Date().toISOString(),
|
|
};
|
|
if (itemKey) {
|
|
rewardEntry.itemKey = itemKey;
|
|
}
|
|
|
|
const nextVoteRewards: Record<string, TriggerValue> = {
|
|
...(existingRewards as Record<string, TriggerValue>),
|
|
[rewardKey]: rewardEntry,
|
|
};
|
|
|
|
const nextMeta: TurnGeneral['meta'] = {
|
|
...baseMeta,
|
|
voteRewards: nextVoteRewards,
|
|
};
|
|
|
|
const patch: Partial<TurnGeneral> = {
|
|
gold: general.gold + command.goldReward,
|
|
meta: nextMeta,
|
|
};
|
|
|
|
if (itemKey) {
|
|
const itemModule = itemRegistry.get(itemKey);
|
|
if (!itemModule) {
|
|
return {
|
|
type: 'voteReward',
|
|
ok: false,
|
|
voteId: command.voteId,
|
|
generalId: command.generalId,
|
|
reason: '유니크 아이템을 찾을 수 없습니다.',
|
|
};
|
|
}
|
|
const nextGeneral = {
|
|
...general,
|
|
role: { ...general.role, items: { ...general.role.items } },
|
|
itemInventory: cloneItemInventory(ensureItemInventory(general)),
|
|
};
|
|
equipNewItem(nextGeneral, itemModule.slot, itemKey, {
|
|
...(itemModule.initialCharges === undefined ? {} : { charges: itemModule.initialCharges }),
|
|
});
|
|
patch.role = nextGeneral.role;
|
|
patch.itemInventory = nextGeneral.itemInventory;
|
|
|
|
const nationName = world.getNationById(general.nationId)?.name ?? '재야';
|
|
const generalName = general.name;
|
|
const itemName = itemModule.name;
|
|
const itemRawName = itemModule.rawName;
|
|
const josaYi = JosaUtil.pick(generalName, '이');
|
|
const josaUl = JosaUtil.pick(itemRawName, '을');
|
|
|
|
world.pushLog({
|
|
scope: LogScope.GENERAL,
|
|
category: LogCategory.ACTION,
|
|
format: LogFormat.MONTH,
|
|
text: `<C>${itemName}</>${josaUl} 습득했습니다!`,
|
|
generalId: general.id,
|
|
meta: {},
|
|
});
|
|
world.pushLog({
|
|
scope: LogScope.GENERAL,
|
|
category: LogCategory.HISTORY,
|
|
format: LogFormat.YEAR_MONTH,
|
|
text: `<C>${itemName}</>${josaUl} 습득`,
|
|
generalId: general.id,
|
|
meta: {},
|
|
});
|
|
world.pushLog({
|
|
scope: LogScope.SYSTEM,
|
|
category: LogCategory.SUMMARY,
|
|
format: LogFormat.MONTH,
|
|
text: `<Y>${generalName}</>${josaYi} <C>${itemName}</>${josaUl} 습득했습니다!`,
|
|
meta: {},
|
|
});
|
|
world.pushLog({
|
|
scope: LogScope.SYSTEM,
|
|
category: LogCategory.HISTORY,
|
|
format: LogFormat.YEAR_MONTH,
|
|
text: `<C><b>【설문조사】</b></><D><b>${nationName}</b></>의 <Y>${generalName}</>${josaYi} <C>${itemName}</>${josaUl} 습득했습니다!`,
|
|
meta: {},
|
|
});
|
|
}
|
|
|
|
world.updateGeneral(command.generalId, patch);
|
|
return {
|
|
type: 'voteReward',
|
|
ok: true,
|
|
voteId: command.voteId,
|
|
generalId: command.generalId,
|
|
awardedUnique: Boolean(itemKey),
|
|
...(itemKey ? { itemKey } : {}),
|
|
};
|
|
}
|
|
|
|
export const createTurnDaemonCommandHandler = (options: {
|
|
world: InMemoryTurnWorld;
|
|
reservedTurns?: InMemoryReservedTurnStore;
|
|
scenarioMeta?: ScenarioMeta;
|
|
map?: MapDefinition;
|
|
commandProfile?: TurnCommandProfile;
|
|
getAdditionalOccupiedUniqueItemKeys?: () => Iterable<string | null | undefined>;
|
|
auctionFinalizer?: AuctionFinalizer;
|
|
auctionBidder?: AuctionBidder;
|
|
tournamentRewardFinalizer?: TournamentRewardFinalizer;
|
|
}): TurnDaemonCommandHandler => {
|
|
let immediateGeneralActionExecutor: Promise<ImmediateGeneralActionExecutor> | null = null;
|
|
const ctx: CommandHandlerContext = {
|
|
world: options.world,
|
|
auctionFinalizer: options.auctionFinalizer,
|
|
auctionBidder: options.auctionBidder,
|
|
tournamentRewardFinalizer: options.tournamentRewardFinalizer,
|
|
getImmediateGeneralActionExecutor: () => {
|
|
immediateGeneralActionExecutor ??= createImmediateGeneralActionExecutor({
|
|
world: options.world,
|
|
reservedTurns: options.reservedTurns,
|
|
scenarioMeta: options.scenarioMeta,
|
|
map: options.map,
|
|
commandProfile: options.commandProfile,
|
|
getAdditionalOccupiedUniqueItemKeys: async () => {
|
|
if (ctx.commandDb) {
|
|
const rows = await ctx.commandDb.auction.findMany({
|
|
where: {
|
|
type: 'UNIQUE_ITEM',
|
|
status: { in: ['OPEN', 'FINALIZING'] },
|
|
targetCode: { not: null },
|
|
},
|
|
select: { targetCode: true },
|
|
});
|
|
return rows.map((row) => row.targetCode);
|
|
}
|
|
return options.getAdditionalOccupiedUniqueItemKeys?.() ?? [];
|
|
},
|
|
});
|
|
return immediateGeneralActionExecutor;
|
|
},
|
|
};
|
|
|
|
type HandlerMap = Partial<
|
|
Record<TurnDaemonCommand['type'], (command: TurnDaemonCommand) => Promise<TurnDaemonCommandResult>>
|
|
>;
|
|
|
|
const handlers: HandlerMap = {
|
|
troopCreate: (command) =>
|
|
handleTroopCreate(ctx, command as Extract<TurnDaemonCommand, { type: 'troopCreate' }>),
|
|
troopJoin: (command) => handleTroopJoin(ctx, command as Extract<TurnDaemonCommand, { type: 'troopJoin' }>),
|
|
troopExit: (command) => handleTroopExit(ctx, command as Extract<TurnDaemonCommand, { type: 'troopExit' }>),
|
|
troopKick: (command) => handleTroopKick(ctx, command as Extract<TurnDaemonCommand, { type: 'troopKick' }>),
|
|
troopRename: (command) =>
|
|
handleTroopRename(ctx, command as Extract<TurnDaemonCommand, { type: 'troopRename' }>),
|
|
dieOnPrestart: (command) =>
|
|
handleDieOnPrestart(ctx, command as Extract<TurnDaemonCommand, { type: 'dieOnPrestart' }>),
|
|
buildNationCandidate: (command) =>
|
|
handleBuildNationCandidate(ctx, command as Extract<TurnDaemonCommand, { type: 'buildNationCandidate' }>),
|
|
instantRetreat: (command) =>
|
|
handleInstantRetreat(ctx, command as Extract<TurnDaemonCommand, { type: 'instantRetreat' }>),
|
|
vacation: (command) => handleVacation(ctx, command as Extract<TurnDaemonCommand, { type: 'vacation' }>),
|
|
setMySetting: (command) =>
|
|
handleSetMySetting(ctx, command as Extract<TurnDaemonCommand, { type: 'setMySetting' }>),
|
|
dropItem: (command) => handleDropItem(ctx, command as Extract<TurnDaemonCommand, { type: 'dropItem' }>),
|
|
auctionFinalize: (command) =>
|
|
handleAuctionFinalize(ctx, command as Extract<TurnDaemonCommand, { type: 'auctionFinalize' }>),
|
|
auctionOpen: (command) =>
|
|
handleAuctionOpen(ctx, command as Extract<TurnDaemonCommand, { type: 'auctionOpen' }>),
|
|
auctionBid: (command) => handleAuctionBid(ctx, command as Extract<TurnDaemonCommand, { type: 'auctionBid' }>),
|
|
changePermission: (command) =>
|
|
handleChangePermission(ctx, command as Extract<TurnDaemonCommand, { type: 'changePermission' }>),
|
|
kick: (command) => handleKick(ctx, command as Extract<TurnDaemonCommand, { type: 'kick' }>),
|
|
appoint: (command) => handleAppoint(ctx, command as Extract<TurnDaemonCommand, { type: 'appoint' }>),
|
|
tournamentRefund: (command) =>
|
|
handleTournamentRefund(ctx, command as Extract<TurnDaemonCommand, { type: 'tournamentRefund' }>),
|
|
tournamentBettingPayout: (command) =>
|
|
handleTournamentBettingPayout(
|
|
ctx,
|
|
command as Extract<TurnDaemonCommand, { type: 'tournamentBettingPayout' }>
|
|
),
|
|
tournamentReward: (command) =>
|
|
handleTournamentReward(ctx, command as Extract<TurnDaemonCommand, { type: 'tournamentReward' }>),
|
|
voteReward: (command) => handleVoteReward(ctx, command as Extract<TurnDaemonCommand, { type: 'voteReward' }>),
|
|
setNationMeta: (command) =>
|
|
handleSetNationMeta(ctx, command as Extract<TurnDaemonCommand, { type: 'setNationMeta' }>),
|
|
adjustGeneralResources: (command) =>
|
|
handleAdjustGeneralResources(
|
|
ctx,
|
|
command as Extract<TurnDaemonCommand, { type: 'adjustGeneralResources' }>
|
|
),
|
|
adjustGeneralMeta: (command) =>
|
|
handleAdjustGeneralMeta(ctx, command as Extract<TurnDaemonCommand, { type: 'adjustGeneralMeta' }>),
|
|
tournamentMatchResult: (command) =>
|
|
handleTournamentMatchResult(ctx, command as Extract<TurnDaemonCommand, { type: 'tournamentMatchResult' }>),
|
|
patchGeneral: (command) =>
|
|
handlePatchGeneral(ctx, command as Extract<TurnDaemonCommand, { type: 'patchGeneral' }>),
|
|
joinCreateGeneral: (command) =>
|
|
handleJoinCreateGeneral(ctx, command as Extract<TurnDaemonCommand, { type: 'joinCreateGeneral' }>),
|
|
npcPossessGeneral: (command) =>
|
|
handleNpcPossessGeneral(ctx, command as Extract<TurnDaemonCommand, { type: 'npcPossessGeneral' }>),
|
|
selectPoolCreate: (command) =>
|
|
handleSelectPoolCreate(ctx, command as Extract<TurnDaemonCommand, { type: 'selectPoolCreate' }>),
|
|
selectPoolReselect: (command) =>
|
|
handleSelectPoolReselect(ctx, command as Extract<TurnDaemonCommand, { type: 'selectPoolReselect' }>),
|
|
shiftSchedule: (command) =>
|
|
handleShiftSchedule(ctx, command as Extract<TurnDaemonCommand, { type: 'shiftSchedule' }>),
|
|
};
|
|
|
|
return {
|
|
handle: async (
|
|
command,
|
|
executionContext?: TurnDaemonCommandExecutionContext
|
|
): Promise<TurnDaemonCommandResult | null> => {
|
|
const handler = handlers[command.type];
|
|
if (!handler) {
|
|
return null;
|
|
}
|
|
ctx.commandDb = executionContext?.db;
|
|
try {
|
|
return await handler(command);
|
|
} finally {
|
|
ctx.commandDb = undefined;
|
|
}
|
|
},
|
|
};
|
|
};
|