595 lines
18 KiB
TypeScript
595 lines
18 KiB
TypeScript
import {
|
|
isGeneralTurnCommandKey,
|
|
isNationTurnCommandKey,
|
|
getLegacyStringWidth,
|
|
loadGeneralTurnCommandSpecs,
|
|
loadNationTurnCommandSpecs,
|
|
type GeneralTurnCommandSpec,
|
|
type NationTurnCommandSpec,
|
|
} from '@sammo-ts/logic';
|
|
import { asRecord, isRecord } from '@sammo-ts/common';
|
|
import type { ItemModule } from '@sammo-ts/logic/items/types.js';
|
|
import { resolveLegacyPurchasableItemKeys } from '@sammo-ts/logic/rewards/legacyUniqueItemPool.js';
|
|
import { z } from 'zod';
|
|
|
|
import { loadScenarioTurnCommandProfile } from '@sammo-ts/game-engine/turn/turnCommandProfile.js';
|
|
|
|
export type TurnCommandOptionValue = string | number;
|
|
|
|
export interface TurnCommandOption {
|
|
value: TurnCommandOptionValue;
|
|
label: string;
|
|
color?: string;
|
|
description?: string;
|
|
availableNow?: boolean;
|
|
gold?: number;
|
|
rice?: number;
|
|
crew?: number;
|
|
troopId?: number;
|
|
npcState?: number;
|
|
}
|
|
|
|
export interface TurnCommandAmountPreset {
|
|
values: number[];
|
|
defaultValue: number;
|
|
min: number;
|
|
max: number;
|
|
step: number;
|
|
}
|
|
|
|
export interface TurnCommandRecruitmentCrewType {
|
|
id: number;
|
|
armType: number;
|
|
name: string;
|
|
available: boolean;
|
|
special: boolean;
|
|
attack: number;
|
|
defence: number;
|
|
speed: number;
|
|
avoid: number;
|
|
baseCost: number;
|
|
baseRice: number;
|
|
info: string[];
|
|
}
|
|
|
|
export interface TurnCommandRecruitmentGroup {
|
|
armType: number;
|
|
armName: string;
|
|
values: TurnCommandRecruitmentCrewType[];
|
|
}
|
|
|
|
export interface TurnCommandRecruitmentInfo {
|
|
techLevel: number;
|
|
leadership: number;
|
|
fullLeadership: number;
|
|
currentCrewTypeId: number;
|
|
currentCrewTypeName: string;
|
|
crew: number;
|
|
gold: number;
|
|
groups: TurnCommandRecruitmentGroup[];
|
|
}
|
|
|
|
export type TurnCommandOptionSource =
|
|
'cities' | 'nations' | 'generals' | 'crewTypes' | 'armTypes' | 'nationTypes' | 'colors' | 'items';
|
|
|
|
export interface TurnCommandInputField {
|
|
key: string;
|
|
label: string;
|
|
kind: 'text' | 'number' | 'boolean' | 'select' | 'numberTuple' | 'hidden';
|
|
required: boolean;
|
|
min?: number;
|
|
max?: number;
|
|
legacyWidthMax?: number;
|
|
step?: number;
|
|
defaultValue?: TurnCommandOptionValue | boolean;
|
|
constValue?: TurnCommandOptionValue;
|
|
options?: TurnCommandOption[];
|
|
optionSource?: TurnCommandOptionSource;
|
|
tupleLabels?: string[];
|
|
}
|
|
|
|
export interface TurnCommandInputOptions {
|
|
cities: TurnCommandOption[];
|
|
nations: TurnCommandOption[];
|
|
nationTargets?: Record<string, TurnCommandOption[]>;
|
|
generals: TurnCommandOption[];
|
|
generalTargets?: Record<string, TurnCommandOption[]>;
|
|
crewTypes: TurnCommandOption[];
|
|
armTypes: TurnCommandOption[];
|
|
nationTypes: TurnCommandOption[];
|
|
colors: TurnCommandOption[];
|
|
items: Record<string, TurnCommandOption[]>;
|
|
recruitment: TurnCommandRecruitmentInfo | null;
|
|
amountPresets?: Record<string, TurnCommandAmountPreset>;
|
|
context?: {
|
|
actorGold: number;
|
|
actorRice: number;
|
|
citySecurity?: number;
|
|
nationGold?: number;
|
|
nationRice?: number;
|
|
nationLevel?: number;
|
|
};
|
|
}
|
|
|
|
type EquipmentTradeItemModule = Pick<ItemModule, 'key' | 'slot' | 'name' | 'info' | 'cost' | 'reqSecu' | 'buyable'>;
|
|
|
|
const plainLegacyInfo = (value: string): string =>
|
|
value
|
|
.replace(/<br\s*\/?>/giu, ' · ')
|
|
.replace(/<[^>]+>/gu, '')
|
|
.replace(/\s+/gu, ' ')
|
|
.trim();
|
|
|
|
export const buildEquipmentTradeItemOptions = (options: {
|
|
configConst: Record<string, unknown>;
|
|
itemModules: readonly EquipmentTradeItemModule[];
|
|
currentSecurity: number;
|
|
generalGold: number;
|
|
}): TurnCommandInputOptions['items'] => {
|
|
const purchasableItemKeys = resolveLegacyPurchasableItemKeys(options.configConst);
|
|
const items: TurnCommandInputOptions['items'] = {
|
|
horse: [{ value: 'None', label: '판매/해제' }],
|
|
weapon: [{ value: 'None', label: '판매/해제' }],
|
|
book: [{ value: 'None', label: '판매/해제' }],
|
|
item: [{ value: 'None', label: '판매/해제' }],
|
|
};
|
|
|
|
for (const item of options.itemModules) {
|
|
if (!item.buyable || !purchasableItemKeys.has(item.key)) {
|
|
continue;
|
|
}
|
|
const cost = item.cost ?? 0;
|
|
const availability =
|
|
options.currentSecurity < item.reqSecu
|
|
? `현재 구입 불가: 치안 ${item.reqSecu.toLocaleString()} 필요`
|
|
: options.generalGold < cost
|
|
? `현재 구입 불가: 자금 ${cost.toLocaleString()} 필요`
|
|
: '현재 구입 가능';
|
|
items[item.slot].push({
|
|
value: item.key,
|
|
label: item.name,
|
|
description: `${availability} · 가격 ${cost.toLocaleString()} · ${plainLegacyInfo(item.info)}`,
|
|
});
|
|
}
|
|
return items;
|
|
};
|
|
|
|
// 레거시 및 명령 실행 모듈의 인덱스 순서와 동일해야 한다.
|
|
export const TURN_COMMAND_NATION_COLORS = [
|
|
'#FF0000',
|
|
'#800000',
|
|
'#A0522D',
|
|
'#FF6347',
|
|
'#FFA500',
|
|
'#FFDAB9',
|
|
'#FFD700',
|
|
'#FFFF00',
|
|
'#7CFC00',
|
|
'#00FF00',
|
|
'#808000',
|
|
'#008000',
|
|
'#2E8B57',
|
|
'#008080',
|
|
'#20B2AA',
|
|
'#6495ED',
|
|
'#7FFFD4',
|
|
'#AFEEEE',
|
|
'#87CEEB',
|
|
'#00FFFF',
|
|
'#00BFFF',
|
|
'#0000FF',
|
|
'#000080',
|
|
'#483D8B',
|
|
'#7B68EE',
|
|
'#BA55D3',
|
|
'#800080',
|
|
'#FF00FF',
|
|
'#FFC0CB',
|
|
'#F5F5DC',
|
|
'#E0FFFF',
|
|
'#FFFFFF',
|
|
'#A9A9A9',
|
|
] as const;
|
|
|
|
const FIELD_LABELS: Record<string, string> = {
|
|
destCityId: '대상 도시',
|
|
destCityID: '대상 도시',
|
|
destGeneralId: '대상 장수',
|
|
destGeneralID: '대상 장수',
|
|
destNationId: '대상 국가',
|
|
nationName: '국가명',
|
|
nationType: '국가 성향',
|
|
colorType: '국기 색상',
|
|
srcArmType: '기존 병과',
|
|
destArmType: '변경 병과',
|
|
itemType: '장비 종류',
|
|
itemCode: '장비',
|
|
crewType: '병종',
|
|
amount: '수량',
|
|
buyRice: '거래',
|
|
isGold: '물자',
|
|
optionText: '행동',
|
|
year: '기간(년)',
|
|
month: '기간(월)',
|
|
commandType: '대응 명령',
|
|
amountList: '지원 물자',
|
|
};
|
|
|
|
const OPTION_SOURCES: Record<string, TurnCommandOptionSource> = {
|
|
destCityId: 'cities',
|
|
destCityID: 'cities',
|
|
destGeneralId: 'generals',
|
|
destGeneralID: 'generals',
|
|
destNationId: 'nations',
|
|
nationType: 'nationTypes',
|
|
colorType: 'colors',
|
|
srcArmType: 'armTypes',
|
|
destArmType: 'armTypes',
|
|
itemCode: 'items',
|
|
crewType: 'crewTypes',
|
|
};
|
|
|
|
const STATIC_LABELS: Record<string, Record<string, string>> = {
|
|
itemType: {
|
|
horse: '명마',
|
|
weapon: '무기',
|
|
book: '서적',
|
|
item: '도구',
|
|
},
|
|
commandType: {
|
|
che_선전포고: '선전포고',
|
|
che_불가침제의: '불가침 제의',
|
|
che_불가침파기제의: '불가침 파기 제의',
|
|
che_종전제의: '종전 제의',
|
|
},
|
|
};
|
|
|
|
type JsonSchema = Record<string, unknown>;
|
|
|
|
const collectObjectSchema = (schema: JsonSchema): JsonSchema => {
|
|
const branches = schema.oneOf ?? schema.anyOf;
|
|
if (Array.isArray(branches)) {
|
|
const objectBranches = branches.filter(isRecord).map((branch) => collectObjectSchema(branch));
|
|
const properties = Object.assign({}, ...objectBranches.map((branch) => asRecord(branch.properties)));
|
|
const required = Array.from(
|
|
new Set(
|
|
objectBranches.flatMap((branch) =>
|
|
Array.isArray(branch.required)
|
|
? branch.required.filter((entry): entry is string => typeof entry === 'string')
|
|
: []
|
|
)
|
|
)
|
|
);
|
|
return { ...schema, properties, required };
|
|
}
|
|
return schema;
|
|
};
|
|
|
|
const enumOptions = (fieldKey: string, values: unknown[]): TurnCommandOption[] =>
|
|
values
|
|
.filter((value): value is TurnCommandOptionValue => typeof value === 'string' || typeof value === 'number')
|
|
.filter((value) => fieldKey !== 'commandType' || value !== 'che_피장파장')
|
|
.map((value) => ({
|
|
value,
|
|
label: STATIC_LABELS[fieldKey]?.[String(value)] ?? String(value),
|
|
}));
|
|
|
|
const buildField = (key: string, rawSchema: unknown, required: boolean): TurnCommandInputField => {
|
|
const schema = asRecord(rawSchema);
|
|
const label = FIELD_LABELS[key] ?? key;
|
|
const constValue = schema.const;
|
|
if (typeof constValue === 'string' || typeof constValue === 'number') {
|
|
return { key, label, kind: 'hidden', required, constValue };
|
|
}
|
|
|
|
if (key === 'amountList') {
|
|
return {
|
|
key,
|
|
label,
|
|
kind: 'numberTuple',
|
|
required,
|
|
tupleLabels: ['금', '쌀'],
|
|
min: 0,
|
|
step: 1,
|
|
};
|
|
}
|
|
|
|
const optionSource = OPTION_SOURCES[key];
|
|
const enumValues = Array.isArray(schema.enum) ? enumOptions(key, schema.enum) : undefined;
|
|
if (optionSource || enumValues) {
|
|
return {
|
|
key,
|
|
label,
|
|
kind: 'select',
|
|
required,
|
|
optionSource,
|
|
options: enumValues,
|
|
};
|
|
}
|
|
|
|
if (schema.type === 'boolean') {
|
|
return { key, label, kind: 'boolean', required };
|
|
}
|
|
if (schema.type === 'number' || schema.type === 'integer') {
|
|
return {
|
|
key,
|
|
label,
|
|
kind: 'number',
|
|
required,
|
|
min: typeof schema.minimum === 'number' ? schema.minimum : undefined,
|
|
max: typeof schema.maximum === 'number' ? schema.maximum : undefined,
|
|
step: schema.type === 'integer' ? 1 : undefined,
|
|
};
|
|
}
|
|
if (schema.type === 'string') {
|
|
return {
|
|
key,
|
|
label,
|
|
kind: 'text',
|
|
required,
|
|
min: typeof schema.minLength === 'number' ? schema.minLength : undefined,
|
|
max: typeof schema.maxLength === 'number' ? schema.maxLength : undefined,
|
|
legacyWidthMax: key === 'nationName' ? 18 : undefined,
|
|
};
|
|
}
|
|
|
|
throw new Error(`Unsupported turn command argument schema: ${key}`);
|
|
};
|
|
|
|
export const buildTurnCommandInputFields = (
|
|
spec: GeneralTurnCommandSpec | NationTurnCommandSpec
|
|
): TurnCommandInputField[] => {
|
|
if (!spec.reqArg) {
|
|
return [];
|
|
}
|
|
const jsonSchema = collectObjectSchema(asRecord(z.toJSONSchema(spec.argsSchema)));
|
|
const properties = asRecord(jsonSchema.properties);
|
|
const required = new Set(
|
|
Array.isArray(jsonSchema.required)
|
|
? jsonSchema.required.filter((entry): entry is string => typeof entry === 'string')
|
|
: []
|
|
);
|
|
return Object.entries(properties).map(([key, schema]) => buildField(key, schema, required.has(key)));
|
|
};
|
|
|
|
export const loadTurnCommandSpecs = async (scenarioConst?: unknown) => {
|
|
const resolution = await loadScenarioTurnCommandProfile({ scenarioConst });
|
|
const profile = resolution.profile;
|
|
const [general, nation] = await Promise.all([
|
|
loadGeneralTurnCommandSpecs(profile.general),
|
|
loadNationTurnCommandSpecs(profile.nation),
|
|
]);
|
|
return {
|
|
general,
|
|
nation,
|
|
generalGroups: resolution.generalGroups,
|
|
nationGroups: resolution.nationGroups,
|
|
};
|
|
};
|
|
|
|
const parseRegisteredTurnArgs = async (
|
|
scope: 'general' | 'nation',
|
|
action: string,
|
|
rawArgs: unknown
|
|
): Promise<Record<string, unknown>> => {
|
|
const specs =
|
|
scope === 'general'
|
|
? isGeneralTurnCommandKey(action)
|
|
? await loadGeneralTurnCommandSpecs([action])
|
|
: []
|
|
: isNationTurnCommandKey(action)
|
|
? await loadNationTurnCommandSpecs([action])
|
|
: [];
|
|
const spec = specs[0];
|
|
if (!spec) {
|
|
throw new Error(`Unknown ${scope} turn command: ${action}`);
|
|
}
|
|
if (!spec.reqArg) {
|
|
return {};
|
|
}
|
|
return spec.argsSchema.parse(rawArgs);
|
|
};
|
|
|
|
const LEGACY_REMOVED_TURN_ARG_CHARACTERS = new Set([
|
|
'"',
|
|
"'",
|
|
'ⓝ',
|
|
'ⓜ',
|
|
'ⓖ',
|
|
'ⓞ',
|
|
'ⓧ',
|
|
'㉥',
|
|
'\\',
|
|
'/',
|
|
'`',
|
|
'#',
|
|
'-',
|
|
'|',
|
|
]);
|
|
|
|
const sanitizeLegacyTurnArgString = (value: string): string => {
|
|
// Ref StringUtil::neutralize() treats the string "0" as empty because of
|
|
// PHP truthiness, both before and after removeSpecialCharacter().
|
|
if (value === '' || value === '0') {
|
|
return '';
|
|
}
|
|
const stripped = Array.from(value)
|
|
.filter((character) => !LEGACY_REMOVED_TURN_ARG_CHARACTERS.has(character))
|
|
.join('');
|
|
if (stripped === '' || stripped === '0') {
|
|
return '';
|
|
}
|
|
return stripped
|
|
.replaceAll('&', '&')
|
|
.replaceAll('<', '<')
|
|
.replaceAll('>', '>')
|
|
.replace(/^[\p{Z}\p{C}]+|[\p{Z}\p{C}]+$/gu, '');
|
|
};
|
|
|
|
export const sanitizeReservedTurnArgs = (value: unknown): unknown => {
|
|
if (typeof value === 'string') {
|
|
return sanitizeLegacyTurnArgString(value);
|
|
}
|
|
if (Array.isArray(value)) {
|
|
return value.map((entry) => sanitizeReservedTurnArgs(entry));
|
|
}
|
|
if (value !== null && typeof value === 'object') {
|
|
return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, sanitizeReservedTurnArgs(entry)]));
|
|
}
|
|
return value;
|
|
};
|
|
|
|
const LEGACY_INTEGER_TURN_ARG_KEYS = new Set([
|
|
'crewType',
|
|
'destGeneralId',
|
|
'destGeneralID',
|
|
'destCityId',
|
|
'destCityID',
|
|
'destNationId',
|
|
'destNationID',
|
|
'amount',
|
|
'colorType',
|
|
'srcArmType',
|
|
'destArmType',
|
|
]);
|
|
const LEGACY_BOOLEAN_TURN_ARG_KEYS = new Set(['isGold', 'buyRice']);
|
|
const LEGACY_INTEGER_ARRAY_TURN_ARG_KEYS = new Set([
|
|
'destNationIdList',
|
|
'destNationIDList',
|
|
'destGeneralIdList',
|
|
'destGeneralIDList',
|
|
'amountList',
|
|
]);
|
|
const LEGACY_NUMERIC_PATTERN = /^[\t\n\r\f\v ]*[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?[\t\n\r\f\v ]*$/;
|
|
|
|
const skipsLegacyOptionalValidation = (value: unknown): boolean => value === null || value === '';
|
|
|
|
const isLegacyNumeric = (value: unknown): boolean => {
|
|
if (typeof value === 'number') {
|
|
return Number.isFinite(value);
|
|
}
|
|
if (typeof value !== 'string' || !LEGACY_NUMERIC_PATTERN.test(value)) {
|
|
return false;
|
|
}
|
|
return Number.isFinite(Number(value));
|
|
};
|
|
|
|
const throwLegacyBasicTurnArgError = (): never => {
|
|
throw new Error('턴이 입력되지 않았습니다.');
|
|
};
|
|
|
|
/**
|
|
* Ref checkCommandArg() only validates common fields that are present. Missing
|
|
* command-specific fields are deliberately left for command construction, so
|
|
* nation penalties and officer checks retain their legacy error priority.
|
|
*/
|
|
export const assertReservedTurnArgsPassLegacyBasicValidation = (rawArgs: unknown): void => {
|
|
const sanitizedArgs = sanitizeReservedTurnArgs(rawArgs);
|
|
if (sanitizedArgs === null || sanitizedArgs === undefined) {
|
|
return;
|
|
}
|
|
if (typeof sanitizedArgs !== 'object') {
|
|
throwLegacyBasicTurnArgError();
|
|
}
|
|
|
|
const args = sanitizedArgs as Record<string, unknown>;
|
|
for (const key of LEGACY_INTEGER_TURN_ARG_KEYS) {
|
|
if (
|
|
Object.prototype.hasOwnProperty.call(args, key) &&
|
|
!skipsLegacyOptionalValidation(args[key]) &&
|
|
!Number.isInteger(args[key])
|
|
) {
|
|
throwLegacyBasicTurnArgError();
|
|
}
|
|
}
|
|
for (const key of LEGACY_BOOLEAN_TURN_ARG_KEYS) {
|
|
if (
|
|
Object.prototype.hasOwnProperty.call(args, key) &&
|
|
!skipsLegacyOptionalValidation(args[key]) &&
|
|
typeof args[key] !== 'boolean'
|
|
) {
|
|
throwLegacyBasicTurnArgError();
|
|
}
|
|
}
|
|
for (const key of LEGACY_INTEGER_ARRAY_TURN_ARG_KEYS) {
|
|
if (!Object.prototype.hasOwnProperty.call(args, key)) {
|
|
continue;
|
|
}
|
|
const value = args[key];
|
|
if (skipsLegacyOptionalValidation(value)) {
|
|
continue;
|
|
}
|
|
if (!Array.isArray(value) || value.some((entry) => !Number.isInteger(entry))) {
|
|
throwLegacyBasicTurnArgError();
|
|
}
|
|
}
|
|
|
|
const month = args.month;
|
|
if (
|
|
Object.prototype.hasOwnProperty.call(args, 'month') &&
|
|
!skipsLegacyOptionalValidation(month) &&
|
|
(!isLegacyNumeric(month) || Number(month) < 1 || Number(month) > 12)
|
|
) {
|
|
throwLegacyBasicTurnArgError();
|
|
}
|
|
const year = args.year;
|
|
if (
|
|
Object.prototype.hasOwnProperty.call(args, 'year') &&
|
|
!skipsLegacyOptionalValidation(year) &&
|
|
(!isLegacyNumeric(year) || Number(year) < 0)
|
|
) {
|
|
throwLegacyBasicTurnArgError();
|
|
}
|
|
for (const [key, minimum] of [
|
|
['destGeneralId', 1],
|
|
['destGeneralID', 1],
|
|
['destCityId', 1],
|
|
['destCityID', 1],
|
|
['destNationId', 1],
|
|
['destNationID', 1],
|
|
['amount', 1],
|
|
['crewType', 0],
|
|
] as const) {
|
|
if (
|
|
Object.prototype.hasOwnProperty.call(args, key) &&
|
|
!skipsLegacyOptionalValidation(args[key]) &&
|
|
Number(args[key]) < minimum
|
|
) {
|
|
throwLegacyBasicTurnArgError();
|
|
}
|
|
}
|
|
|
|
if (Object.prototype.hasOwnProperty.call(args, 'nationName')) {
|
|
const nationName = args.nationName;
|
|
if (
|
|
!skipsLegacyOptionalValidation(nationName) &&
|
|
(typeof nationName !== 'string' ||
|
|
getLegacyStringWidth(nationName) < 1 ||
|
|
getLegacyStringWidth(nationName) > 18)
|
|
) {
|
|
throw new Error('국가명은 전각 9자 또는 반각 18자 이하여야 합니다.');
|
|
}
|
|
}
|
|
};
|
|
|
|
export const assertReservedTurnActionAvailable = async (
|
|
scope: 'general' | 'nation',
|
|
action: string,
|
|
scenarioConst?: unknown
|
|
): Promise<void> => {
|
|
const specs = await loadTurnCommandSpecs(scenarioConst);
|
|
if (!specs[scope].some((entry) => entry.key === action)) {
|
|
throw new Error(`Unknown ${scope} turn command: ${action}`);
|
|
}
|
|
};
|
|
|
|
export const parseReservedTurnArgs = async (
|
|
scope: 'general' | 'nation',
|
|
action: string,
|
|
rawArgs: unknown,
|
|
scenarioConst?: unknown
|
|
): Promise<Record<string, unknown>> => {
|
|
await assertReservedTurnActionAvailable(scope, action, scenarioConst);
|
|
return parseRegisteredTurnArgs(scope, action, sanitizeReservedTurnArgs(rawArgs));
|
|
};
|