devsam/core2026
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: 전투 시뮬레이터를 브라우저 Worker로 이관

Browse Source 
서버가 권위 환경과 반복 seed를 준비하고 공용 logic 프로세서를 브라우저와 기존 서버 fallback이 함께 사용하도록 변경한다. production Chromium에서 고정 seed와 1000회 Node 결과 동등성을 검증한다.
This commit is contained in:
Hide_D
2026-08-17 01:45:41 +00:00
parent 63005c22fe
commit 161ec90bf8
23 changed files with 1258 additions and 854 deletions
Download Patch File Download Diff File Expand all files Collapse all files
app/game-api/src/battleSim/environment.ts
+6 -2
View File
@@ -1,10 +1,13 @@
import type { WorldStateRow } from '../context.js';
import type { BattleSimJobPayload, BattleSimRequestPayload } from './types.js';
import { randomUUID } from 'node:crypto';
import { loadUnitSetDefinitionByName } from '@sammo-ts/game-engine/scenario/unitSetLoader.js';
import { normalizeScenarioEffect, type ScenarioEffectKey, type WarEngineConfig } from '@sammo-ts/logic';
import { asRecord } from '@sammo-ts/common';
import type { UnitSetDefinition } from '@sammo-ts/logic';
import type { WorldStateRow } from '../context.js';
import type { BattleSimJobPayload, BattleSimRequestPayload } from './types.js';
const DEFAULT_WAR_CONFIG = {
armPerPhase: 500,
maxTrainByCommand: 100,
@@ -133,6 +136,7 @@ export const buildBattleSimJobPayload = async (
return {
...request,
seeds: request.seed ? [] : Array.from({ length: request.repeatCnt }, () => randomUUID()),
unitSet: environment.unitSet,
config: environment.config,
time: {
app/game-api/src/battleSim/processor.ts
+2 -507
View File
@@ -1,507 +1,2 @@
import crypto from 'node:crypto';
import type { RandUtil } from '@sammo-ts/common';
import {
formatLogText,
getTechCost,
LogCategory,
LogFormat,
LogScope,
resolveDefenderOrder,
resolveWarBattle,
createItemActionModules,
createItemModuleRegistry,
createRefOrderedActionStack,
createScenarioEffectActionModules,
ITEM_KEYS,
loadItemModules,
createInheritBuffModules,
createTraitCatalog,
createOfficerLevelActionModules,
DOMESTIC_TRAIT_KEYS,
EVENT_DOMESTIC_TRAIT_KEYS,
loadDomesticTraitModules,
loadEventDomesticTraitModules,
loadNationTraitModules,
loadPersonalityTraitModules,
loadWarTraitModules,
NATION_TRAIT_KEYS,
PERSONALITY_TRAIT_KEYS,
TraitWarActionRouter,
WAR_TRAIT_KEYS,
compileCrewTypeCatalog,
createCrewTypeWarTriggerRegistry,
type City,
type General,
type Nation,
type RefOrderedActionStack,
type UnitSetDefinition,
type WarBattleOutcome,
type WarActionModule,
type WarUnitReport,
type WarBattleTraceEvent,
type CrewTypeDefinition,
} from '@sammo-ts/logic';
import { type BattleSimJobPayload, type BattleSimLogBuckets, type BattleSimResultPayload } from './types.js';
import { convertLog } from './logFormatter.js';
const DEFAULT_GENERAL_AGE = 20;
const inheritBuffModules = createInheritBuffModules();
const itemWarModules: WarActionModule[] = createItemActionModules(
createItemModuleRegistry(await loadItemModules([...ITEM_KEYS]))
).war;
const crewTypeWarTriggerRegistry = createCrewTypeWarTriggerRegistry();
const traitCatalog = createTraitCatalog({
domestic: [
...(await loadDomesticTraitModules([...DOMESTIC_TRAIT_KEYS])),
...(await loadEventDomesticTraitModules([...EVENT_DOMESTIC_TRAIT_KEYS])),
],
war: await loadWarTraitModules([...WAR_TRAIT_KEYS]),
personality: await loadPersonalityTraitModules([...PERSONALITY_TRAIT_KEYS]),
nation: await loadNationTraitModules([...NATION_TRAIT_KEYS]),
});
const nationWarModule = new TraitWarActionRouter('nation', traitCatalog);
const officerWarModule = createOfficerLevelActionModules().war;
const domesticWarModule = new TraitWarActionRouter('domestic', traitCatalog);
const warTraitModule = new TraitWarActionRouter('war', traitCatalog);
const personalityWarModule = new TraitWarActionRouter('personality', traitCatalog);
const buildWarActionModules = (
unitSet: UnitSetDefinition,
scenarioEffect?: string | null
): RefOrderedActionStack<WarActionModule> => {
const crewTypeCatalog = compileCrewTypeCatalog(unitSet, crewTypeWarTriggerRegistry);
const scenario = createScenarioEffectActionModules(scenarioEffect);
return createRefOrderedActionStack<WarActionModule>({
nation: nationWarModule,
officer: officerWarModule,
domestic: domesticWarModule,
war: warTraitModule,
personality: personalityWarModule,
crewType: crewTypeCatalog.warActionModule,
inheritance: inheritBuffModules.war,
scenario: scenario.war,
items: itemWarModules,
});
};
const normalizeItemCode = (value: string | null): string | null => (value === 'None' ? null : value);
const mapNationPayload = (payload: BattleSimJobPayload['attackerNation']): Nation => ({
id: payload.nation,
name: payload.name,
color: '#000000',
capitalCityId: payload.capital,
chiefGeneralId: null,
gold: payload.gold,
rice: payload.rice,
power: 0,
level: payload.level,
typeCode: payload.type,
meta: {
tech: payload.tech,
gennum: payload.gennum,
},
});
const mapCityPayload = (payload: BattleSimJobPayload['attackerCity']): City => ({
id: payload.city,
name: payload.name,
nationId: payload.nation,
level: payload.level,
state: payload.state,
population: payload.pop,
populationMax: payload.pop_max,
agriculture: payload.agri,
agricultureMax: payload.agri_max,
commerce: payload.comm,
commerceMax: payload.comm_max,
security: payload.secu,
securityMax: payload.secu_max,
supplyState: payload.supply,
frontState: payload.state,
defence: payload.def,
defenceMax: payload.def_max,
wall: payload.wall,
wallMax: payload.wall_max,
meta: {
trust: payload.trust,
dead: payload.dead,
conflict: payload.conflict,
supply: payload.supply,
},
});
const mapGeneralPayload = (
payload: BattleSimJobPayload['attackerGeneral'],
currentCityId: number
): General => ({
id: payload.no,
name: payload.name,
nationId: payload.nation,
cityId: payload.city ?? currentCityId,
troopId: 0,
stats: {
leadership: payload.leadership,
strength: payload.strength,
intelligence: payload.intel,
},
experience: payload.experience,
dedication: payload.dedication,
officerLevel: payload.officer_level,
role: {
personality: payload.personal,
specialDomestic: payload.special ?? null,
specialWar: payload.special2,
items: {
horse: normalizeItemCode(payload.horse),
weapon: normalizeItemCode(payload.weapon),
book: normalizeItemCode(payload.book),
item: normalizeItemCode(payload.item),
},
},
injury: payload.injury,
gold: payload.gold,
rice: payload.rice,
crew: payload.crew,
crewTypeId: payload.crewtype,
train: payload.train,
atmos: payload.atmos,
age: DEFAULT_GENERAL_AGE,
npcState: 0,
triggerState: {
flags: {},
counters: {},
modifiers: {},
meta: payload.inheritBuff ? { inheritBuff: JSON.stringify(payload.inheritBuff) } : {},
},
meta: {
killturn: 24,
explevel: payload.explevel,
turnTime: payload.turntime,
recentWar: payload.recent_war ?? '',
dex1: payload.dex1,
dex2: payload.dex2,
dex3: payload.dex3,
dex4: payload.dex4,
dex5: payload.dex5,
intel_exp: payload.intel_exp,
strength_exp: payload.strength_exp,
leadership_exp: payload.leadership_exp,
defence_train: payload.defence_train,
officerCity: payload.officer_city,
officer_city: payload.officer_city,
rank_warnum: payload.warnum,
rank_killnum: payload.killnum,
rank_killcrew: payload.killcrew,
},
});
const buildLogBuckets = (options: {
logs: WarBattleOutcome['logs'];
year: number;
month: number;
attackerId: number;
attackerNationId: number;
}): BattleSimLogBuckets => {
const buckets = {
generalHistoryLog: [] as string[],
generalActionLog: [] as string[],
generalBattleResultLog: [] as string[],
generalBattleDetailLog: [] as string[],
nationalHistoryLog: [] as string[],
globalHistoryLog: [] as string[],
globalActionLog: [] as string[],
};
for (const entry of options.logs) {
const format = entry.format ?? LogFormat.RAWTEXT;
const text = formatLogText(entry.text, format, options.year, options.month);
if (entry.scope === LogScope.GENERAL && entry.generalId === options.attackerId) {
switch (entry.category) {
case LogCategory.HISTORY:
buckets.generalHistoryLog.push(text);
break;
case LogCategory.ACTION:
buckets.generalActionLog.push(text);
break;
case LogCategory.BATTLE_BRIEF:
buckets.generalBattleResultLog.push(text);
break;
case LogCategory.BATTLE_DETAIL:
buckets.generalBattleDetailLog.push(text);
break;
default:
break;
}
continue;
}
if (
entry.scope === LogScope.NATION &&
entry.nationId === options.attackerNationId &&
entry.category === LogCategory.HISTORY
) {
buckets.nationalHistoryLog.push(text);
continue;
}
if (entry.scope === LogScope.SYSTEM) {
if (entry.category === LogCategory.HISTORY) {
buckets.globalHistoryLog.push(text);
} else if (entry.category === LogCategory.SUMMARY) {
buckets.globalActionLog.push(text);
}
}
}
return {
generalHistoryLog: convertLog(buckets.generalHistoryLog.join('<br>')),
generalActionLog: convertLog(buckets.generalActionLog.join('<br>')),
generalBattleResultLog: convertLog(buckets.generalBattleResultLog.join('<br>')),
generalBattleDetailLog: convertLog(buckets.generalBattleDetailLog.join('<br>')),
nationalHistoryLog: convertLog(buckets.nationalHistoryLog.join('<br>')),
globalHistoryLog: convertLog(buckets.globalHistoryLog.join('<br>')),
globalActionLog: convertLog(buckets.globalActionLog.join('<br>')),
};
};
const resolveRandomSeed = (): string => crypto.randomUUID();
const resolveCityTrainAtmos = (year: number, startYear: number): number =>
Math.min(110, Math.max(60, year - startYear + 59));
const resolveCityRiceConsumption = (options: {
battle: WarBattleOutcome;
defenderNation: Nation;
unitSet: UnitSetDefinition;
castleCrewTypeId: number;
year: number;
startYear: number;
}): number => {
const cityReport = options.battle.reports.find((report: WarUnitReport) => report.type === 'city');
if (!cityReport) {
return 0;
}
if (cityReport.killed <= 0 && cityReport.dead <= 0) {
return 0;
}
const crewType = options.unitSet.crewTypes?.find(
(item: CrewTypeDefinition) => item.id === options.castleCrewTypeId
);
const riceCoef = crewType?.rice ?? 1;
const tech = Number(options.defenderNation.meta.tech ?? 0);
const trainAtmos = resolveCityTrainAtmos(options.year, options.startYear);
let rice = (cityReport.killed / 100) * 0.8;
rice *= riceCoef;
rice *= getTechCost(tech);
rice *= trainAtmos / 100 - 0.2;
return Math.round(rice);
};
const resolveDefenderOrderPayload = (payload: BattleSimJobPayload): number[] => {
const attackerNation = mapNationPayload(payload.attackerNation);
const defenderNation = mapNationPayload(payload.defenderNation);
const attackerCity = mapCityPayload(payload.attackerCity);
const defenderCity = mapCityPayload(payload.defenderCity);
const attacker = mapGeneralPayload(payload.attackerGeneral, attackerCity.id);
const defenders = payload.defenderGenerals.map((general) => mapGeneralPayload(general, defenderCity.id));
const warActionModules = buildWarActionModules(payload.unitSet, payload.scenarioEffect);
return resolveDefenderOrder({
unitSet: payload.unitSet,
config: payload.config,
time: payload.time,
seed: 'order',
attacker: {
general: attacker,
city: attackerCity,
nation: attackerNation,
modules: warActionModules,
},
defenders: defenders.map((general) => ({
general,
city: defenderCity,
nation: defenderNation,
modules: warActionModules,
})),
defenderCity,
defenderNation,
});
};
export interface BattleSimProcessorOptions {
trace?: (event: WarBattleTraceEvent) => void;
rngFactory?: (seed: string) => RandUtil;
}
export const processBattleSimJob = (
payload: BattleSimJobPayload,
options: BattleSimProcessorOptions = {}
): BattleSimResultPayload => {
if (payload.action === 'reorder') {
return {
result: true,
reason: 'success',
order: resolveDefenderOrderPayload(payload),
};
}
let repeatCnt = payload.repeatCnt;
const warActionModules = buildWarActionModules(payload.unitSet, payload.scenarioEffect);
const baseSeed = payload.seed ?? '';
if (baseSeed) {
repeatCnt = 1;
}
let lastBattle: WarBattleOutcome | null = null;
let attackerKilled = 0;
let attackerDead = 0;
let attackerMaxKilled = 0;
let attackerMinKilled = Number.POSITIVE_INFINITY;
let attackerMaxDead = 0;
let attackerMinDead = Number.POSITIVE_INFINITY;
let attackerAvgRice = 0;
let defenderAvgRice = 0;
let avgPhase = 0;
let avgWar = 0;
const attackerSkills: Record<string, number> = {};
const defendersSkills: Array<Record<string, number>> = [];
const weight = 1 / Math.max(1, repeatCnt);
for (let idx = 0; idx < repeatCnt; idx += 1) {
const seed = idx === 0 ? baseSeed || resolveRandomSeed() : resolveRandomSeed();
const attackerNation = mapNationPayload(payload.attackerNation);
const defenderNation = mapNationPayload(payload.defenderNation);
const attackerCity = mapCityPayload(payload.attackerCity);
const defenderCity = mapCityPayload(payload.defenderCity);
const attackerGeneral = mapGeneralPayload(payload.attackerGeneral, attackerCity.id);
const defenderGenerals = payload.defenderGenerals.map((general) =>
mapGeneralPayload(general, defenderCity.id)
);
const initialRice = new Map<number, number>();
initialRice.set(attackerGeneral.id, attackerGeneral.rice);
for (const defender of defenderGenerals) {
initialRice.set(defender.id, defender.rice);
}
const outcome = resolveWarBattle({
seed,
rng: options.rngFactory?.(seed),
unitSet: payload.unitSet,
config: payload.config,
time: payload.time,
attacker: {
general: attackerGeneral,
city: attackerCity,
nation: attackerNation,
modules: warActionModules,
},
defenders: defenderGenerals.map((general) => ({
general,
city: defenderCity,
nation: defenderNation,
modules: warActionModules,
})),
defenderCity,
defenderNation,
trace: options.trace,
});
lastBattle = outcome;
const attackerReport = outcome.reports.find(
(report: WarUnitReport) => report.type === 'general' && report.isAttacker
);
const killed = attackerReport?.killed ?? 0;
const dead = attackerReport?.dead ?? 0;
attackerKilled += killed * weight;
attackerDead += dead * weight;
attackerMaxKilled = Math.max(attackerMaxKilled, killed);
attackerMinKilled = Math.min(attackerMinKilled, killed);
attackerMaxDead = Math.max(attackerMaxDead, dead);
attackerMinDead = Math.min(attackerMinDead, dead);
const phase = outcome.metrics?.attackerPhase ?? 0;
avgPhase += phase * weight;
const defenderCount = outcome.metrics?.defenderActivatedSkills.length ?? 0;
avgWar += defenderCount * weight;
const attackerRiceInit = initialRice.get(attackerGeneral.id) ?? attackerGeneral.rice;
attackerAvgRice += (attackerRiceInit - outcome.attacker.rice) * weight;
let defenderRiceInit = 0;
let defenderRiceAfter = 0;
for (const defender of outcome.defenders) {
defenderRiceInit += initialRice.get(defender.id) ?? defender.rice;
defenderRiceAfter += defender.rice;
}
const cityRice = resolveCityRiceConsumption({
battle: outcome,
defenderNation,
unitSet: payload.unitSet,
castleCrewTypeId: payload.config.castleCrewTypeId,
year: payload.time.year,
startYear: payload.time.startYear,
});
defenderAvgRice += (defenderRiceInit - defenderRiceAfter + cityRice) * weight;
const attackerActivated = outcome.metrics?.attackerActivatedSkills ?? {};
for (const [skillName, value] of Object.entries(attackerActivated) as [string, number][]) {
attackerSkills[skillName] = (attackerSkills[skillName] ?? 0) + value * weight;
}
const defenderActivated = outcome.metrics?.defenderActivatedSkills ?? [];
for (let defIdx = 0; defIdx < defenderActivated.length; defIdx += 1) {
while (defIdx >= defendersSkills.length) {
defendersSkills.push({});
}
const bucket = defendersSkills[defIdx]!;
for (const [skillName, value] of Object.entries(defenderActivated[defIdx]!) as [string, number][]) {
bucket[skillName] = (bucket[skillName] ?? 0) + value * weight;
}
}
}
if (!lastBattle) {
return {
result: false,
reason: '전투 결과를 생성하지 못했습니다.',
};
}
const logBuckets = buildLogBuckets({
logs: lastBattle.logs,
year: payload.time.year,
month: payload.time.month,
attackerId: lastBattle.attacker.id,
attackerNationId: payload.attackerNation.nation,
});
return {
result: true,
reason: 'success',
datetime: payload.attackerGeneral.turntime,
lastWarLog: logBuckets,
avgWar,
phase: avgPhase,
killed: attackerKilled,
maxKilled: attackerMaxKilled,
minKilled: attackerMinKilled === Number.POSITIVE_INFINITY ? 0 : attackerMinKilled,
dead: attackerDead,
maxDead: attackerMaxDead,
minDead: attackerMinDead === Number.POSITIVE_INFINITY ? 0 : attackerMinDead,
attackerRice: attackerAvgRice,
defenderRice: defenderAvgRice,
attackerSkills,
defendersSkills,
};
};
export { processBattleSimJob } from '@sammo-ts/logic';
export type { BattleSimProcessorOptions } from '@sammo-ts/logic';
app/game-api/src/battleSim/types.ts
+11 -136
View File
@@ -1,140 +1,15 @@
import type { UnitSetDefinition } from '@sammo-ts/logic';
import type { BattleSimJobPayload, BattleSimResultPayload } from '@sammo-ts/logic';
import type { WarEngineConfig, WarTimeContext } from '@sammo-ts/logic';
export type BattleSimAction = 'reorder' | 'battle';
export interface BattleSimGeneralPayload {
no: number;
name: string;
nation: number;
/** Current city. Older clients omit this; the surrounding city payload is authoritative then. */
city?: number;
turntime: string;
personal: string | null;
special?: string | null;
special2: string | null;
crew: number;
crewtype: number;
atmos: number;
train: number;
intel: number;
intel_exp: number;
book: string | null;
strength: number;
strength_exp: number;
weapon: string | null;
injury: number;
leadership: number;
leadership_exp: number;
horse: string | null;
item: string | null;
explevel: number;
experience: number;
dedication: number;
officer_level: number;
officer_city: number;
gold: number;
rice: number;
dex1: number;
dex2: number;
dex3: number;
dex4: number;
dex5: number;
defence_train: number;
recent_war: string | null;
warnum: number;
killnum: number;
killcrew: number;
inheritBuff?: Record<string, number> | number[];
}
export interface BattleSimCityPayload {
city: number;
nation: number;
supply: number;
name: string;
pop: number;
agri: number;
comm: number;
secu: number;
def: number;
wall: number;
trust: number;
level: number;
pop_max: number;
agri_max: number;
comm_max: number;
secu_max: number;
def_max: number;
wall_max: number;
dead: number;
state: number;
conflict: string;
}
export interface BattleSimNationPayload {
type: string;
tech: number;
level: number;
capital: number;
nation: number;
name: string;
gold: number;
rice: number;
gennum: number;
}
export interface BattleSimRequestPayload {
action: BattleSimAction;
seed?: string;
repeatCnt: number;
year: number;
month: number;
attackerGeneral: BattleSimGeneralPayload;
attackerCity: BattleSimCityPayload;
attackerNation: BattleSimNationPayload;
defenderGenerals: BattleSimGeneralPayload[];
defenderCity: BattleSimCityPayload;
defenderNation: BattleSimNationPayload;
}
export interface BattleSimJobPayload extends BattleSimRequestPayload {
unitSet: UnitSetDefinition;
config: WarEngineConfig;
time: WarTimeContext;
scenarioEffect?: string | null;
}
export interface BattleSimLogBuckets {
generalHistoryLog: string;
generalActionLog: string;
generalBattleResultLog: string;
generalBattleDetailLog: string;
nationalHistoryLog: string;
globalHistoryLog: string;
globalActionLog: string;
}
export interface BattleSimResultPayload {
result: boolean;
reason: string;
datetime?: string;
lastWarLog?: BattleSimLogBuckets;
avgWar?: number;
phase?: number;
killed?: number;
maxKilled?: number;
minKilled?: number;
dead?: number;
maxDead?: number;
minDead?: number;
attackerRice?: number;
defenderRice?: number;
attackerSkills?: Record<string, number>;
defendersSkills?: Array<Record<string, number>>;
order?: number[];
}
export type {
BattleSimAction,
BattleSimCityPayload,
BattleSimGeneralPayload,
BattleSimJobPayload,
BattleSimLogBuckets,
BattleSimNationPayload,
BattleSimRequestPayload,
BattleSimResultPayload,
} from '@sammo-ts/logic';
export interface BattleSimJob {
jobId: string;
app/game-api/src/router/battle/index.ts
+120 -111
View File
@@ -62,6 +62,17 @@ const resolveDexValue = (meta: Record<string, unknown>, key: string): number =>
};
export const battleRouter = router({
prepareSimulation: accessReadOnlyAuthedInputProcedure(zBattleSimRequest).mutation(async ({ ctx, input }) => {
const worldState = await ctx.db.worldState.findFirst();
if (!worldState) {
throw new TRPCError({
code: 'PRECONDITION_FAILED',
message: 'World state is not initialized.',
});
}
return buildBattleSimJobPayload(worldState, input, ctx.profile.id);
}),
simulate: accessReadOnlyAuthedInputProcedure(zBattleSimRequest).mutation(async ({ ctx, input }) => {
const worldState = await ctx.db.worldState.findFirst();
if (!worldState) {
@@ -176,122 +187,120 @@ export const battleRouter = router({
};
}),
getGeneralDetail: accessAuthedInputProcedure(
z.object({
generalId: z.number().int().positive(),
})
)
.query(async ({ ctx, input }) => {
const worldState = await ctx.db.worldState.findFirst();
if (!worldState) {
throw new TRPCError({
code: 'PRECONDITION_FAILED',
message: 'World state is not initialized.',
});
}
const me = await getMyGeneral(ctx);
const general = await ctx.db.general.findUnique({
where: { id: input.generalId },
select: {
id: true,
name: true,
npcState: true,
nationId: true,
leadership: true,
strength: true,
intel: true,
officerLevel: true,
injury: true,
rice: true,
crew: true,
crewTypeId: true,
atmos: true,
train: true,
experience: true,
horseCode: true,
weaponCode: true,
bookCode: true,
itemCode: true,
personalCode: true,
specialCode: true,
special2Code: true,
meta: true,
},
z.object({
generalId: z.number().int().positive(),
})
).query(async ({ ctx, input }) => {
const worldState = await ctx.db.worldState.findFirst();
if (!worldState) {
throw new TRPCError({
code: 'PRECONDITION_FAILED',
message: 'World state is not initialized.',
});
}
if (!general) {
throw new TRPCError({
code: 'NOT_FOUND',
message: 'General not found.',
});
}
const me = await getMyGeneral(ctx);
const general = await ctx.db.general.findUnique({
where: { id: input.generalId },
select: {
id: true,
name: true,
npcState: true,
nationId: true,
leadership: true,
strength: true,
intel: true,
officerLevel: true,
injury: true,
rice: true,
crew: true,
crewTypeId: true,
atmos: true,
train: true,
experience: true,
horseCode: true,
weaponCode: true,
bookCode: true,
itemCode: true,
personalCode: true,
specialCode: true,
special2Code: true,
meta: true,
},
});
const environment = await buildBattleSimEnvironment(worldState, ctx.profile.id);
const defaultCrewTypeId =
environment.unitSet.defaultCrewTypeId ?? environment.unitSet.crewTypes?.[0]?.id ?? 0;
if (!general) {
throw new TRPCError({
code: 'NOT_FOUND',
message: 'General not found.',
});
}
const meta = asRecord(general.meta);
const isSameNation = me.nationId > 0 && me.nationId === general.nationId;
const environment = await buildBattleSimEnvironment(worldState, ctx.profile.id);
const defaultCrewTypeId = environment.unitSet.defaultCrewTypeId ?? environment.unitSet.crewTypes?.[0]?.id ?? 0;
const base = {
no: general.id,
name: general.name,
officer_level: general.officerLevel,
explevel: resolveExpLevel(meta, general.experience),
leadership: general.leadership,
horse: normalizeOptionalKey(general.horseCode),
strength: general.strength,
weapon: normalizeOptionalKey(general.weaponCode),
intel: general.intel,
book: normalizeOptionalKey(general.bookCode),
item: normalizeOptionalKey(general.itemCode),
injury: general.injury,
rice: general.rice,
personal: normalizeOptionalKey(general.personalCode),
special: normalizeOptionalKey(general.specialCode),
special2: normalizeOptionalKey(general.special2Code),
crew: general.crew,
crewtype: general.crewTypeId,
atmos: general.atmos,
train: general.train,
dex1: resolveDexValue(meta, 'dex1'),
dex2: resolveDexValue(meta, 'dex2'),
dex3: resolveDexValue(meta, 'dex3'),
dex4: resolveDexValue(meta, 'dex4'),
dex5: resolveDexValue(meta, 'dex5'),
defence_train: readNumber(meta.defenceTrain, 80),
warnum: readNumber(meta.rank_warnum, 0),
killnum: readNumber(meta.rank_killnum, 0),
killcrew: readNumber(meta.rank_killcrew, 0),
const meta = asRecord(general.meta);
const isSameNation = me.nationId > 0 && me.nationId === general.nationId;
const base = {
no: general.id,
name: general.name,
officer_level: general.officerLevel,
explevel: resolveExpLevel(meta, general.experience),
leadership: general.leadership,
horse: normalizeOptionalKey(general.horseCode),
strength: general.strength,
weapon: normalizeOptionalKey(general.weaponCode),
intel: general.intel,
book: normalizeOptionalKey(general.bookCode),
item: normalizeOptionalKey(general.itemCode),
injury: general.injury,
rice: general.rice,
personal: normalizeOptionalKey(general.personalCode),
special: normalizeOptionalKey(general.specialCode),
special2: normalizeOptionalKey(general.special2Code),
crew: general.crew,
crewtype: general.crewTypeId,
atmos: general.atmos,
train: general.train,
dex1: resolveDexValue(meta, 'dex1'),
dex2: resolveDexValue(meta, 'dex2'),
dex3: resolveDexValue(meta, 'dex3'),
dex4: resolveDexValue(meta, 'dex4'),
dex5: resolveDexValue(meta, 'dex5'),
defence_train: readNumber(meta.defenceTrain, 80),
warnum: readNumber(meta.rank_warnum, 0),
killnum: readNumber(meta.rank_killnum, 0),
killcrew: readNumber(meta.rank_killcrew, 0),
};
if (!isSameNation) {
return {
general: {
...base,
officer_level: 1,
horse: null,
weapon: null,
book: null,
item: null,
crew: 0,
crewtype: defaultCrewTypeId,
rice: 10000,
train: environment.config.maxTrainByCommand,
atmos: environment.config.maxAtmosByCommand,
dex1: 0,
dex2: 0,
dex3: 0,
dex4: 0,
dex5: 0,
defence_train: 80,
warnum: 0,
killnum: 0,
killcrew: 0,
},
};
}
if (!isSameNation) {
return {
general: {
...base,
officer_level: 1,
horse: null,
weapon: null,
book: null,
item: null,
crew: 0,
crewtype: defaultCrewTypeId,
rice: 10000,
train: environment.config.maxTrainByCommand,
atmos: environment.config.maxAtmosByCommand,
dex1: 0,
dex2: 0,
dex3: 0,
dex4: 0,
dex5: 0,
defence_train: 80,
warnum: 0,
killnum: 0,
killcrew: 0,
},
};
}
return { general: base };
}),
return { general: base };
}),
});
app/game-api/src/services/generalAccess.ts
+1
View File
@@ -61,6 +61,7 @@ export const generalAccessEndpointWeights = {
'npc.setNationPolicy': 0,
'npc.setNationPriority': 0,
'npc.setGeneralPriority': 0,
'battle.prepareSimulation': 0,
'battle.simulate': 0,
} as const satisfies Record<string, 0 | 1 | 2>;
app/game-api/test/battleSimProcessor.test.ts
+21
View File
@@ -1,4 +1,5 @@
import { describe, expect, it } from 'vitest';
import { LiteHashDRBG, RandUtil } from '@sammo-ts/common';
import type { BattleSimJobPayload } from '../src/battleSim/types.js';
import { processBattleSimJob } from '../src/battleSim/processor.js';
@@ -259,6 +260,26 @@ describe('battle sim processor', () => {
expect(processBattleSimJob(legacyPayload)).toEqual(processBattleSimJob(baselinePayload));
});
it('uses server-issued per-repeat seeds deterministically when no fixed seed is supplied', () => {
const firstPayload = buildPayload('battle');
delete firstPayload.seed;
firstPayload.repeatCnt = 2;
firstPayload.seeds = ['server-repeat-0', 'server-repeat-1'];
const secondPayload = structuredClone(firstPayload);
const observedSeeds: string[] = [];
const first = processBattleSimJob(firstPayload, {
rngFactory: (seed) => {
observedSeeds.push(seed);
return new RandUtil(LiteHashDRBG.build(seed));
},
});
const second = processBattleSimJob(secondPayload);
expect(first).toEqual(second);
expect(observedSeeds).toEqual(['server-repeat-0', 'server-repeat-1']);
});
it('returns the fixed defender ID order for reorder action', () => {
const payload = buildPayload('reorder');
const result = processBattleSimJob(payload);
app/game-api/test/battleSimRouter.test.ts
+59
View File
@@ -257,6 +257,58 @@ const buildContext = (options: {
};
describe('battle router orchestration', () => {
it('prepares the authoritative browser-worker payload without queuing server work', async () => {
const battleSim = new QueuedBattleSimTransport();
const state: WorldStateRow = {
id: 1,
scenarioCode: 'default',
currentYear: 200,
currentMonth: 1,
tickSeconds: 600,
config: { environment: { scenarioEffect: 'event_MoreEffect' } },
meta: { scenarioMeta: { startYear: 180 } },
updatedAt: new Date('2026-01-01T00:00:00Z'),
};
const caller = appRouter.createCaller(buildContext({ state, battleSim }));
const request = { ...buildBattleRequest(), repeatCnt: 1000 };
delete (request as Partial<typeof request>).seed;
const prepared = await caller.battle.prepareSimulation(request);
expect(prepared).toMatchObject({
action: 'battle',
repeatCnt: 1000,
scenarioEffect: 'event_MoreEffect',
time: { year: 200, month: 1, startYear: 180 },
config: { armPerPhase: 500, maxTrainByWar: 110, maxAtmosByWar: 150 },
});
expect(prepared.unitSet.crewTypes?.length).toBeGreaterThan(0);
expect(prepared.seeds).toHaveLength(1000);
expect(new Set(prepared.seeds).size).toBe(1000);
expect(battleSim.simulateCalls).toBe(0);
});
it('does not allocate repeat seeds when the client supplies a fixed seed', async () => {
const battleSim = new QueuedBattleSimTransport();
const state: WorldStateRow = {
id: 1,
scenarioCode: 'default',
currentYear: 200,
currentMonth: 1,
tickSeconds: 600,
config: {},
meta: {},
updatedAt: new Date('2026-01-01T00:00:00Z'),
};
const caller = appRouter.createCaller(buildContext({ state, battleSim }));
const prepared = await caller.battle.prepareSimulation(buildBattleRequest());
expect(prepared.seed).toBe('test-seed');
expect(prepared.seeds).toEqual([]);
expect(battleSim.simulateCalls).toBe(0);
});
it('returns queued then completed results via transport', async () => {
const battleSim = new QueuedBattleSimTransport();
const state: WorldStateRow = {
@@ -351,6 +403,9 @@ describe('battle router orchestration', () => {
} as unknown as DatabaseClient;
const anonymous = appRouter.createCaller(buildContext({ state, battleSim, userId: null, db }));
await expect(anonymous.battle.prepareSimulation(buildBattleRequest())).rejects.toMatchObject({
code: 'UNAUTHORIZED',
});
await expect(anonymous.battle.simulate(buildBattleRequest())).rejects.toMatchObject({
code: 'UNAUTHORIZED',
});
@@ -358,6 +413,10 @@ describe('battle router orchestration', () => {
const noGeneralUser = appRouter.createCaller(
buildContext({ state, battleSim, userId: 'user-without-general', db })
);
await expect(noGeneralUser.battle.prepareSimulation(buildBattleRequest())).resolves.toMatchObject({
action: 'battle',
seed: 'test-seed',
});
await expect(noGeneralUser.battle.simulate(buildBattleRequest())).resolves.toMatchObject({
status: 'queued',
});
app/game-api/test/directMutationJournalInventory.test.ts
+2 -2
View File
@@ -96,7 +96,7 @@ const classifications = {
],
operational: ['turnDaemon.pause', 'turnDaemon.resume', 'turnDaemon.run'],
externalUpload: ['board.uploadImage'],
readOnlyMutationTransport: ['battle.simulate'],
readOnlyMutationTransport: ['battle.prepareSimulation', 'battle.simulate'],
sessionOnly: ['auth.exchangeGatewayToken'],
} as const;
@@ -142,7 +142,7 @@ describe('game-api direct mutation journal inventory', () => {
const classified = Object.values(classifications).flat().sort();
expect(new Set(classified).size).toBe(classified.length);
expect(classified).toHaveLength(86);
expect(classified).toHaveLength(87);
expect(actual).toEqual(classified);
});
});
app/game-api/test/generalAccessTracking.test.ts
+1
View File
@@ -122,6 +122,7 @@ describe('general access tracking', () => {
'npc.setNationPolicy': 0,
'npc.setNationPriority': 0,
'npc.setGeneralPriority': 0,
'battle.prepareSimulation': 0,
'battle.simulate': 0,
});
});