279 lines
10 KiB
TypeScript
279 lines
10 KiB
TypeScript
import { GAME_TICKS_PER_TURN, JosaUtil, LiteHashDRBG, RandUtil, asRecord } from '@sammo-ts/common';
|
|
import { LogCategory, LogFormat, LogScope, type TurnCommandEnv } from '@sammo-ts/logic';
|
|
import { simpleSerialize } from '@sammo-ts/logic/war/utils.js';
|
|
|
|
import type { InMemoryTurnWorld } from './inMemoryWorld.js';
|
|
import type { MonthlyEventActionHandler, MonthlyEventEnvironment } from './monthlyEventHandler.js';
|
|
import type { InMemoryReservedTurnStore } from './reservedTurnStore.js';
|
|
import type { TurnGeneral } from './types.js';
|
|
|
|
const NPC_TYPE = 3;
|
|
const NPC_NAME_PREFIX = 'ⓜ';
|
|
const LEGACY_GENERAL_NAME_PREFIXES = ['', 'ⓝ', 'ⓝ', 'ⓜ', 'ⓖ', '㉥', 'ⓤ', 'ⓞ'];
|
|
const STAT_TYPE_WEIGHTS = { 무: 0.333, 지: 0.333, 무지: 0.334 } as const;
|
|
|
|
const readLegacyNumber = (value: unknown, fallback: number): number => {
|
|
if (typeof value === 'number' && Number.isFinite(value)) {
|
|
return value;
|
|
}
|
|
if (typeof value === 'string' && value.trim() !== '') {
|
|
const parsed = Number(value);
|
|
if (Number.isFinite(parsed)) {
|
|
return parsed;
|
|
}
|
|
}
|
|
return fallback;
|
|
};
|
|
|
|
const resolveHiddenSeed = (world: InMemoryTurnWorld): string | number => {
|
|
const state = world.getState();
|
|
const value = state.meta.hiddenSeed ?? state.meta.seed ?? state.id;
|
|
return typeof value === 'string' || typeof value === 'number' ? value : String(value);
|
|
};
|
|
|
|
const countLegacyNameDuplicates = (generals: readonly TurnGeneral[], baseName: string): number => {
|
|
let count = 0;
|
|
for (const prefix of LEGACY_GENERAL_NAME_PREFIXES) {
|
|
const target = `${prefix}${baseName}`;
|
|
count += generals.filter((general) => general.name.startsWith(target)).length;
|
|
}
|
|
return count;
|
|
};
|
|
|
|
export const pickNpcNames = (
|
|
rng: RandUtil,
|
|
count: number,
|
|
existingGenerals: readonly TurnGeneral[],
|
|
env: TurnCommandEnv
|
|
): string[] => {
|
|
const firstNames = env.randomGeneralFirstNames ?? ['가'];
|
|
const middleNames = env.randomGeneralMiddleNames ?? [''];
|
|
const lastNames = env.randomGeneralLastNames ?? ['가'];
|
|
const names: string[] = [];
|
|
|
|
for (let index = 0; index < count; index += 1) {
|
|
let loopCount = 0;
|
|
while (true) {
|
|
let name = `${rng.choice(firstNames)}${rng.choice(middleNames)}${rng.choice(lastNames)}`;
|
|
const duplicateCount = countLegacyNameDuplicates(existingGenerals, name);
|
|
if (duplicateCount === 0) {
|
|
names.push(name);
|
|
break;
|
|
}
|
|
if (loopCount >= 99 || duplicateCount < 2) {
|
|
name += duplicateCount + 1;
|
|
names.push(name);
|
|
break;
|
|
}
|
|
loopCount += 1;
|
|
}
|
|
}
|
|
return names;
|
|
};
|
|
|
|
export const buildNpcStats = (
|
|
rng: RandUtil,
|
|
env: TurnCommandEnv,
|
|
weights: Readonly<Record<string, number>> = STAT_TYPE_WEIGHTS
|
|
): TurnGeneral['stats'] => {
|
|
const totalStat = env.npcStatTotal ?? 150;
|
|
const minStat = env.npcStatMin ?? 10;
|
|
const maxStat = env.npcStatMax ?? 50;
|
|
const pickType = rng.choiceUsingWeight(weights);
|
|
let mainStat = maxStat - rng.nextRangeInt(0, minStat);
|
|
let otherStat = minStat + rng.nextRangeInt(0, Math.trunc(minStat / 2));
|
|
let subStat = totalStat - mainStat - otherStat;
|
|
|
|
if (subStat < minStat) {
|
|
subStat = otherStat;
|
|
otherStat = minStat;
|
|
mainStat = totalStat - subStat - otherStat;
|
|
// GeneralBuilder::fillRandomStat()의 기존 truthy 검사까지 보존한다.
|
|
if (mainStat !== 0) {
|
|
throw new Error('기본 스탯 설정값이 잘못되어 있음');
|
|
}
|
|
}
|
|
|
|
if (pickType === '무') {
|
|
return { leadership: subStat, strength: mainStat, intelligence: otherStat };
|
|
}
|
|
if (pickType === '지') {
|
|
return { leadership: subStat, strength: otherStat, intelligence: mainStat };
|
|
}
|
|
return { leadership: otherStat, strength: subStat, intelligence: mainStat };
|
|
};
|
|
|
|
const buildSpecialityAge = (retirementYear: number, age: number, relativeYear: number, divisor: number): number =>
|
|
Math.max(Math.round((retirementYear - age) / divisor - relativeYear / 2), 3) + age;
|
|
|
|
const buildNpc = (options: {
|
|
world: InMemoryTurnWorld;
|
|
reservedTurns: InMemoryReservedTurnStore;
|
|
rng: RandUtil;
|
|
environment: MonthlyEventEnvironment;
|
|
env: TurnCommandEnv;
|
|
baseName: string;
|
|
}): TurnGeneral => {
|
|
const { world, reservedTurns, rng, environment, env } = options;
|
|
const age = rng.nextRangeInt(20, 25);
|
|
const bornYear = environment.year - age;
|
|
const deadYear = environment.year + rng.nextRangeInt(10, 50);
|
|
const stats = buildNpcStats(rng, env);
|
|
const affinity = rng.nextRangeInt(1, 150);
|
|
const relativeYear = Math.max(environment.year - environment.startyear, 0);
|
|
const configValues = asRecord(world.getScenarioConfig().const);
|
|
const retirementYear = readLegacyNumber(configValues.retirementYear, 80);
|
|
const specAge = buildSpecialityAge(retirementYear, age, relativeYear, 12);
|
|
const specAge2 = buildSpecialityAge(retirementYear, age, relativeYear, 6);
|
|
const personality = rng.choice(env.availablePersonalities ?? ['che_안전']);
|
|
const cities = world.listCities();
|
|
if (cities.length === 0) {
|
|
throw new Error('CreateManyNPC requires at least one city.');
|
|
}
|
|
const city = rng.choice(cities);
|
|
const turnMinutes = world.getState().tickSeconds / 60;
|
|
if (!(turnMinutes > 0)) {
|
|
throw new Error('CreateManyNPC requires a positive turn term.');
|
|
}
|
|
const turnSecond = rng.nextRangeInt(0, 60 * turnMinutes - 1);
|
|
const turnFraction = rng.nextRangeInt(0, 999_999);
|
|
const ticksPerSecond = GAME_TICKS_PER_TURN / world.getState().tickSeconds;
|
|
const turnTick =
|
|
world.dateToGameTick(environment.turnTime) +
|
|
turnSecond * ticksPerSecond +
|
|
Math.floor((turnFraction * ticksPerSecond) / 1_000_000);
|
|
const turnTime = world.gameTickToDate(turnTick);
|
|
const killturn = (deadYear - environment.year) * 12 + rng.nextRangeInt(0, 11) + environment.month - 1;
|
|
const id = world.getNextGeneralId();
|
|
const general: TurnGeneral = {
|
|
id,
|
|
userId: null,
|
|
name: `${NPC_NAME_PREFIX}${options.baseName}`,
|
|
nationId: 0,
|
|
cityId: city.id,
|
|
troopId: 0,
|
|
stats,
|
|
experience: age * 100,
|
|
dedication: age * 100,
|
|
officerLevel: 0,
|
|
role: {
|
|
personality,
|
|
specialDomestic: env.defaultSpecialDomestic,
|
|
specialWar: env.defaultSpecialWar,
|
|
items: { horse: null, weapon: null, book: null, item: null },
|
|
},
|
|
injury: 0,
|
|
gold: 1_000,
|
|
rice: 1_000,
|
|
crew: 0,
|
|
crewTypeId: env.defaultCrewTypeId,
|
|
train: 0,
|
|
atmos: 0,
|
|
age,
|
|
npcState: NPC_TYPE,
|
|
bornYear,
|
|
deadYear,
|
|
affinity,
|
|
picture: 'default.jpg',
|
|
triggerState: {
|
|
flags: {},
|
|
counters: {},
|
|
modifiers: {},
|
|
meta: {},
|
|
},
|
|
lastTurn: { command: '휴식' },
|
|
turnTime,
|
|
turnTick,
|
|
recentWarTime: null,
|
|
meta: {
|
|
killturn,
|
|
npcType: NPC_TYPE,
|
|
npc_org: NPC_TYPE,
|
|
belong: 0,
|
|
dedlevel: 1,
|
|
specage: specAge,
|
|
specage2: specAge2,
|
|
dex1: 0,
|
|
dex2: 0,
|
|
dex3: 0,
|
|
dex4: 0,
|
|
dex5: 0,
|
|
},
|
|
};
|
|
if (!world.addGeneral(general)) {
|
|
throw new Error(`CreateManyNPC generated a duplicate general id: ${id}`);
|
|
}
|
|
reservedTurns.ensureGeneralTurns(id);
|
|
return general;
|
|
};
|
|
|
|
export const createCreateManyNpcHandler = (options: {
|
|
getWorld: () => InMemoryTurnWorld | null;
|
|
reservedTurns: InMemoryReservedTurnStore;
|
|
env: TurnCommandEnv;
|
|
}): MonthlyEventActionHandler => {
|
|
return (args, environment) => {
|
|
const world = options.getWorld();
|
|
if (!world) {
|
|
return;
|
|
}
|
|
const npcCount = readLegacyNumber(args[0], 10);
|
|
const fillCount = readLegacyNumber(args[1], 0);
|
|
if (npcCount <= 0 && fillCount <= 0) {
|
|
return;
|
|
}
|
|
|
|
let moreGeneralCount = 0;
|
|
if (fillCount !== 0) {
|
|
const chiefs = world
|
|
.listGenerals()
|
|
.filter((general) => general.npcState < 3 && general.officerLevel === 12);
|
|
const chiefNationIds = new Set(chiefs.map((general) => general.nationId));
|
|
const registeredGeneralCount = world
|
|
.listGenerals()
|
|
.filter((general) => chiefNationIds.has(general.nationId) && general.npcState < 4).length;
|
|
moreGeneralCount = chiefs.length * fillCount - registeredGeneralCount;
|
|
}
|
|
|
|
const requestedCount = npcCount + moreGeneralCount;
|
|
const rng = new RandUtil(
|
|
new LiteHashDRBG(
|
|
simpleSerialize(resolveHiddenSeed(world), 'CreateManyNPC', environment.year, environment.month)
|
|
)
|
|
);
|
|
const baseNames = pickNpcNames(rng, requestedCount, world.listGenerals(), options.env);
|
|
const created = baseNames.map((baseName) =>
|
|
buildNpc({
|
|
world,
|
|
reservedTurns: options.reservedTurns,
|
|
rng,
|
|
environment,
|
|
env: options.env,
|
|
baseName,
|
|
})
|
|
);
|
|
|
|
const count = created.length;
|
|
const actionText =
|
|
count === 1
|
|
? `<Y>${created[0]!.name}</>${JosaUtil.pick(created[0]!.name, '라')}는 장수가 <S>등장</>하였습니다.`
|
|
: `장수 <C>${count}</>명이 <S>등장</>하였습니다.`;
|
|
world.pushLog({
|
|
scope: LogScope.SYSTEM,
|
|
category: LogCategory.ACTION,
|
|
text: actionText,
|
|
format: LogFormat.MONTH,
|
|
year: environment.year,
|
|
month: environment.month,
|
|
});
|
|
world.pushLog({
|
|
scope: LogScope.SYSTEM,
|
|
category: LogCategory.HISTORY,
|
|
text: `장수 <C>${count}</>명이 <S>등장</>했습니다.`,
|
|
format: LogFormat.NOTICE_YEAR_MONTH,
|
|
year: environment.year,
|
|
month: environment.month,
|
|
});
|
|
};
|
|
};
|