720 lines
23 KiB
TypeScript
720 lines
23 KiB
TypeScript
import {
|
|
JosaUtil,
|
|
LiteHashDRBG,
|
|
RandUtil,
|
|
} from '@sammo-ts/common';
|
|
|
|
import type {
|
|
City,
|
|
General,
|
|
GeneralTriggerState,
|
|
} from '@sammo-ts/logic/domain/entities.js';
|
|
import { ActionLogger } from '@sammo-ts/logic/logging/actionLogger.js';
|
|
import { LogFormat } from '@sammo-ts/logic/logging/types.js';
|
|
import { buildCrewTypeIndex as buildCrewTypeDefinitionIndex } from '@sammo-ts/logic/world/unitSet.js';
|
|
import { WarActionPipeline } from './actions.js';
|
|
import { WarCrewType } from './crewType.js';
|
|
import {
|
|
WarTriggerCaller,
|
|
createWarTriggerEnv,
|
|
type WarTriggerRegistry,
|
|
} from './triggers.js';
|
|
import type {
|
|
WarBattleInput,
|
|
WarBattleOutcome,
|
|
WarGeneralInput,
|
|
WarUnitReport,
|
|
} from './types.js';
|
|
import { getMetaNumber } from './utils.js';
|
|
import { WarUnitCity, WarUnitGeneral, type WarUnit } from './units.js';
|
|
|
|
const META_FULL_LEADERSHIP = 'fullLeadership';
|
|
const META_FULL_STRENGTH = 'fullStrength';
|
|
const META_FULL_INTELLIGENCE = 'fullIntelligence';
|
|
const META_DEFENCE_TRAIN = 'defenceTrain';
|
|
|
|
const defaultLoggerFactory = (options: {
|
|
generalId?: number;
|
|
nationId?: number;
|
|
}): ActionLogger => new ActionLogger(options);
|
|
|
|
const resolveCrewType = (
|
|
crewTypeIndex: Map<number, WarCrewType>,
|
|
crewTypeId: number
|
|
): WarCrewType => {
|
|
const crewType = crewTypeIndex.get(crewTypeId);
|
|
if (!crewType) {
|
|
throw new Error(`Invalid crew type: ${crewTypeId}`);
|
|
}
|
|
return crewType;
|
|
};
|
|
|
|
const buildWarCrewTypeIndex = (
|
|
unitSet: WarBattleInput['unitSet']
|
|
): Map<number, WarCrewType> => {
|
|
const index = new Map<number, WarCrewType>();
|
|
const crewTypes = buildCrewTypeDefinitionIndex(unitSet);
|
|
for (const [id, crewType] of crewTypes) {
|
|
index.set(id, new WarCrewType(crewType));
|
|
}
|
|
return index;
|
|
};
|
|
|
|
const createPipeline = <TriggerState extends GeneralTriggerState>(
|
|
input: WarGeneralInput<TriggerState>
|
|
): WarActionPipeline<TriggerState> =>
|
|
new WarActionPipeline(input.modules ?? []);
|
|
|
|
const appendCrewTypeTriggers = (
|
|
caller: WarTriggerCaller,
|
|
unit: WarUnit,
|
|
names: string[],
|
|
registry: WarTriggerRegistry | undefined
|
|
): void => {
|
|
if (!registry) {
|
|
return;
|
|
}
|
|
for (const name of names) {
|
|
const factory = registry[name];
|
|
if (!factory) {
|
|
continue;
|
|
}
|
|
const trigger = factory(unit);
|
|
if (!trigger) {
|
|
continue;
|
|
}
|
|
if (trigger instanceof WarTriggerCaller) {
|
|
caller.merge(trigger);
|
|
} else {
|
|
caller.append(trigger);
|
|
}
|
|
}
|
|
};
|
|
|
|
const buildBattleInitTriggers = (
|
|
unit: WarUnit,
|
|
registry: WarTriggerRegistry | undefined
|
|
): WarTriggerCaller => {
|
|
const caller = new WarTriggerCaller();
|
|
if (unit instanceof WarUnitGeneral) {
|
|
const context = unit.getActionContext();
|
|
caller.merge(unit.getActionPipeline().getBattleInitTriggerList(context));
|
|
}
|
|
appendCrewTypeTriggers(caller, unit, unit.getCrewType().initSkillTrigger, registry);
|
|
return caller;
|
|
};
|
|
|
|
const buildBattlePhaseTriggers = (
|
|
unit: WarUnit,
|
|
registry: WarTriggerRegistry | undefined
|
|
): WarTriggerCaller => {
|
|
const caller = new WarTriggerCaller();
|
|
if (unit instanceof WarUnitGeneral) {
|
|
appendCrewTypeTriggers(caller, unit, ['che_필살'], registry);
|
|
const context = unit.getActionContext();
|
|
caller.merge(unit.getActionPipeline().getBattlePhaseTriggerList(context));
|
|
}
|
|
appendCrewTypeTriggers(caller, unit, unit.getCrewType().phaseSkillTrigger, registry);
|
|
return caller;
|
|
};
|
|
|
|
const resolveFullStats = (general: General): {
|
|
leadership: number;
|
|
strength: number;
|
|
intelligence: number;
|
|
} => ({
|
|
leadership: getMetaNumber(general.meta, META_FULL_LEADERSHIP, general.stats.leadership),
|
|
strength: getMetaNumber(general.meta, META_FULL_STRENGTH, general.stats.strength),
|
|
intelligence: getMetaNumber(
|
|
general.meta,
|
|
META_FULL_INTELLIGENCE,
|
|
general.stats.intelligence
|
|
),
|
|
});
|
|
|
|
const isSupplyCity = (city: City): boolean => {
|
|
const supply = city.meta.supply;
|
|
if (typeof supply === 'boolean') {
|
|
return supply;
|
|
}
|
|
if (typeof supply === 'number') {
|
|
return supply > 0;
|
|
}
|
|
return city.supplyState > 0;
|
|
};
|
|
|
|
export const computeBattleOrder = (
|
|
defender: WarUnit,
|
|
attacker: WarUnitGeneral
|
|
): number => {
|
|
if (defender instanceof WarUnitCity) {
|
|
const context = attacker.getActionContext();
|
|
return attacker
|
|
.getActionPipeline()
|
|
.onCalcOpposeStat(context, 'cityBattleOrder', -1);
|
|
}
|
|
|
|
if (!(defender instanceof WarUnitGeneral)) {
|
|
return 0;
|
|
}
|
|
|
|
const general = defender.getGeneral();
|
|
if (general.crew <= 0) {
|
|
return 0;
|
|
}
|
|
if (general.rice <= general.crew / 100) {
|
|
return 0;
|
|
}
|
|
|
|
const defenceTrain = getMetaNumber(general.meta, META_DEFENCE_TRAIN, 0);
|
|
if (general.train < defenceTrain) {
|
|
return 0;
|
|
}
|
|
if (general.atmos < defenceTrain) {
|
|
return 0;
|
|
}
|
|
|
|
const realStat =
|
|
general.stats.leadership +
|
|
general.stats.strength +
|
|
general.stats.intelligence;
|
|
const fullStats = resolveFullStats(general);
|
|
const fullStat =
|
|
fullStats.leadership + fullStats.strength + fullStats.intelligence;
|
|
const totalStat = (realStat + fullStat) / 2;
|
|
|
|
const totalCrew =
|
|
(general.crew / 1_000_000) *
|
|
Math.pow(general.train * general.atmos, 1.5);
|
|
|
|
return totalStat + totalCrew / 100;
|
|
};
|
|
|
|
const resolveUnitReport = (unit: WarUnit): WarUnitReport => {
|
|
if (unit instanceof WarUnitGeneral) {
|
|
return {
|
|
id: unit.getGeneral().id,
|
|
type: 'general',
|
|
name: unit.getName(),
|
|
isAttacker: unit.isAttacker(),
|
|
killed: unit.getKilled(),
|
|
dead: unit.getDead(),
|
|
};
|
|
}
|
|
|
|
if (unit instanceof WarUnitCity) {
|
|
return {
|
|
id: unit.getCityId(),
|
|
type: 'city',
|
|
name: unit.getName(),
|
|
isAttacker: unit.isAttacker(),
|
|
killed: unit.getKilled(),
|
|
dead: unit.getDead(),
|
|
};
|
|
}
|
|
|
|
return {
|
|
id: null,
|
|
type: 'city',
|
|
name: unit.getName(),
|
|
isAttacker: unit.isAttacker(),
|
|
killed: unit.getKilled(),
|
|
dead: unit.getDead(),
|
|
};
|
|
};
|
|
|
|
const flushLoggers = (loggers: ActionLogger[]): Array<ReturnType<ActionLogger['flush']>[number]> => {
|
|
const logs: Array<ReturnType<ActionLogger['flush']>[number]> = [];
|
|
for (const logger of loggers) {
|
|
logs.push(...logger.flush());
|
|
}
|
|
return logs;
|
|
};
|
|
|
|
export const resolveWarBattle = <
|
|
TriggerState extends GeneralTriggerState = GeneralTriggerState
|
|
>(
|
|
input: WarBattleInput<TriggerState>
|
|
): WarBattleOutcome<TriggerState> => {
|
|
// process_war.php 전투 루프를 순수 로직으로 이식한다.
|
|
const rng =
|
|
input.rng ??
|
|
new RandUtil(
|
|
LiteHashDRBG.build(input.seed ?? '')
|
|
);
|
|
const loggerFactory = input.loggerFactory ?? defaultLoggerFactory;
|
|
const triggerRegistry = input.triggerRegistry;
|
|
|
|
const crewTypeIndex = buildWarCrewTypeIndex(input.unitSet);
|
|
const attackerPipeline = createPipeline(input.attacker);
|
|
const attackerLogger =
|
|
input.attacker.logger ??
|
|
loggerFactory({
|
|
generalId: input.attacker.general.id,
|
|
nationId: input.attacker.general.nationId,
|
|
});
|
|
|
|
const attackerUnit = new WarUnitGeneral(
|
|
rng,
|
|
input.config,
|
|
input.attacker.general,
|
|
input.attacker.city,
|
|
input.attacker.nation,
|
|
true,
|
|
resolveCrewType(crewTypeIndex, input.attacker.general.crewTypeId),
|
|
attackerLogger,
|
|
attackerPipeline
|
|
);
|
|
|
|
const cityLogger = loggerFactory({
|
|
nationId: input.defenderCity.nationId,
|
|
});
|
|
const cityUnit = new WarUnitCity(
|
|
rng,
|
|
input.config,
|
|
input.defenderCity,
|
|
input.defenderNation,
|
|
resolveCrewType(crewTypeIndex, input.config.castleCrewTypeId),
|
|
cityLogger,
|
|
input.time.year,
|
|
input.time.startYear
|
|
);
|
|
|
|
const defenderUnits: WarUnit<TriggerState>[] = [];
|
|
const defenderGenerals: WarUnitGeneral<TriggerState>[] = [];
|
|
for (const defender of input.defenders) {
|
|
const defenderLogger =
|
|
defender.logger ??
|
|
loggerFactory({
|
|
generalId: defender.general.id,
|
|
nationId: defender.general.nationId,
|
|
});
|
|
const unit = new WarUnitGeneral(
|
|
rng,
|
|
input.config,
|
|
defender.general,
|
|
input.defenderCity,
|
|
defender.nation,
|
|
false,
|
|
resolveCrewType(crewTypeIndex, defender.general.crewTypeId),
|
|
defenderLogger,
|
|
createPipeline(defender)
|
|
);
|
|
if (computeBattleOrder(unit, attackerUnit) <= 0) {
|
|
continue;
|
|
}
|
|
defenderUnits.push(unit);
|
|
defenderGenerals.push(unit);
|
|
}
|
|
|
|
if (
|
|
defenderGenerals.length > 0 &&
|
|
computeBattleOrder(cityUnit, attackerUnit) > 0
|
|
) {
|
|
defenderUnits.push(cityUnit);
|
|
}
|
|
|
|
defenderUnits.sort(
|
|
(lhs, rhs) =>
|
|
computeBattleOrder(rhs, attackerUnit) -
|
|
computeBattleOrder(lhs, attackerUnit)
|
|
);
|
|
|
|
const iter = defenderUnits.values();
|
|
let defender: WarUnit<TriggerState> | null = null;
|
|
|
|
const getNextDefender = (
|
|
_prevDefender: WarUnit<TriggerState> | null,
|
|
reqNext: boolean
|
|
): WarUnit<TriggerState> | null => {
|
|
if (!reqNext) {
|
|
return null;
|
|
}
|
|
const next = iter.next();
|
|
if (next.done) {
|
|
return null;
|
|
}
|
|
const candidate = next.value as WarUnit<TriggerState>;
|
|
if (computeBattleOrder(candidate, attackerUnit) <= 0) {
|
|
return null;
|
|
}
|
|
return candidate;
|
|
};
|
|
|
|
defender = getNextDefender(null, true);
|
|
let conquerCity = false;
|
|
let logWritten = false;
|
|
|
|
const attackerNationName =
|
|
(attackerUnit.getNationVar('name') as string | null) ?? 'UNKNOWN';
|
|
const attackerName = attackerUnit.getName();
|
|
const cityName = cityUnit.getName();
|
|
const seedText = input.seed ? `(전투시드: ${input.seed})` : '';
|
|
|
|
const josaRo = JosaUtil.pick(cityName, '로');
|
|
const josaYi = JosaUtil.pick(attackerName, '이');
|
|
|
|
attackerLogger.pushGlobalActionLog(
|
|
`<D><b>${attackerNationName}</b></>의 <Y>${attackerName}</>${josaYi} <G><b>${cityName}</b></>${josaRo} 진격합니다.${seedText}`,
|
|
LogFormat.MONTH
|
|
);
|
|
attackerLogger.pushGeneralActionLog(
|
|
`<G><b>${cityName}</b></>${josaRo} <M>진격</>합니다.${seedText}`,
|
|
LogFormat.MONTH
|
|
);
|
|
|
|
while (attackerUnit.getPhase() < attackerUnit.getMaxPhase()) {
|
|
logWritten = false;
|
|
|
|
if (!defender) {
|
|
defender = cityUnit;
|
|
cityUnit.setSiege();
|
|
|
|
const defenderRice = input.defenderNation?.rice ?? 0;
|
|
if (isSupplyCity(input.defenderCity) && defenderRice <= 0) {
|
|
attackerUnit.setOppose(defender);
|
|
defender.setOppose(attackerUnit);
|
|
|
|
attackerUnit.addTrain(1);
|
|
|
|
attackerUnit.addWin();
|
|
defender.addLose();
|
|
cityUnit.heavyDecreaseWealth();
|
|
|
|
attackerLogger.pushGlobalActionLog(
|
|
`병량 부족으로 <G><b>${cityName}</b></>의 수비병들이 <R>패퇴</>합니다.`,
|
|
LogFormat.MONTH
|
|
);
|
|
|
|
conquerCity = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (defender.getPhase() === 0 && !defender.getOppose()) {
|
|
defender.setPrePhase(attackerUnit.getPhase());
|
|
|
|
attackerUnit.addTrain(1);
|
|
defender.addTrain(1);
|
|
|
|
const attackerName = attackerUnit.getName();
|
|
const attackerCrewName = attackerUnit.getCrewTypeName();
|
|
|
|
if (defender instanceof WarUnitGeneral) {
|
|
const defenderName = defender.getName();
|
|
const defenderCrewName = defender.getCrewTypeName();
|
|
|
|
const josaWa = JosaUtil.pick(attackerCrewName, '와');
|
|
const josaYiDef = JosaUtil.pick(defenderCrewName, '이');
|
|
attackerLogger.pushGlobalActionLog(
|
|
`<Y>${attackerName}</>의 ${attackerCrewName}${josaWa} <Y>${defenderName}</>의 ${defenderCrewName}${josaYiDef} 대결합니다.`,
|
|
LogFormat.MONTH
|
|
);
|
|
|
|
const josaRo = JosaUtil.pick(attackerCrewName, '로');
|
|
const josaUl = JosaUtil.pick(defenderCrewName, '을');
|
|
attackerUnit.getLogger().pushGeneralActionLog(
|
|
`${attackerCrewName}${josaRo} <Y>${defenderName}</>의 ${defenderCrewName}${josaUl} <M>공격</>합니다.`,
|
|
LogFormat.MONTH
|
|
);
|
|
|
|
const defJosaRo = JosaUtil.pick(defenderCrewName, '로');
|
|
const defJosaUl = JosaUtil.pick(attackerCrewName, '을');
|
|
defender.getLogger().pushGeneralActionLog(
|
|
`${defenderCrewName}${defJosaRo} <Y>${attackerName}</>의 ${attackerCrewName}${defJosaUl} <M>수비</>합니다.`,
|
|
LogFormat.MONTH
|
|
);
|
|
} else {
|
|
const josaYiName = JosaUtil.pick(attackerName, '이');
|
|
const josaRoCrew = JosaUtil.pick(attackerCrewName, '로');
|
|
attackerLogger.pushGlobalActionLog(
|
|
`<Y>${attackerName}</>${josaYiName} ${attackerCrewName}${josaRoCrew} 성벽을 공격합니다.`,
|
|
LogFormat.MONTH
|
|
);
|
|
attackerLogger.pushGeneralActionLog(
|
|
`${attackerCrewName}${josaRoCrew} 성벽을 <M>공격</>합니다.`,
|
|
LogFormat.PLAIN
|
|
);
|
|
}
|
|
|
|
attackerUnit.setOppose(defender);
|
|
defender.setOppose(attackerUnit);
|
|
|
|
const initCaller = buildBattleInitTriggers(attackerUnit, triggerRegistry);
|
|
initCaller.merge(buildBattleInitTriggers(defender, triggerRegistry));
|
|
initCaller.fire(
|
|
{ rng, attacker: attackerUnit, defender },
|
|
createWarTriggerEnv()
|
|
);
|
|
}
|
|
|
|
attackerUnit.beginPhase();
|
|
defender.beginPhase();
|
|
|
|
const battleCaller = buildBattlePhaseTriggers(attackerUnit, triggerRegistry);
|
|
battleCaller.merge(buildBattlePhaseTriggers(defender, triggerRegistry));
|
|
battleCaller.fire(
|
|
{ rng, attacker: attackerUnit, defender },
|
|
createWarTriggerEnv()
|
|
);
|
|
|
|
let deadDefender = attackerUnit.calcDamage();
|
|
let deadAttacker = defender.calcDamage();
|
|
|
|
const attackerHP = attackerUnit.getHP();
|
|
const defenderHP = defender.getHP();
|
|
|
|
if (deadAttacker > attackerHP || deadDefender > defenderHP) {
|
|
const deadAttackerRatio = deadAttacker / Math.max(1, attackerHP);
|
|
const deadDefenderRatio = deadDefender / Math.max(1, defenderHP);
|
|
|
|
if (deadDefenderRatio > deadAttackerRatio) {
|
|
deadAttacker /= deadDefenderRatio;
|
|
deadDefender = defenderHP;
|
|
} else {
|
|
deadDefender /= deadAttackerRatio;
|
|
deadAttacker = attackerHP;
|
|
}
|
|
}
|
|
|
|
deadAttacker = Math.min(Math.ceil(deadAttacker), attackerHP);
|
|
deadDefender = Math.min(Math.ceil(deadDefender), defenderHP);
|
|
|
|
attackerUnit.decreaseHP(deadAttacker);
|
|
defender.decreaseHP(deadDefender);
|
|
|
|
attackerUnit.increaseKilled(deadDefender);
|
|
defender.increaseKilled(deadAttacker);
|
|
|
|
const phaseNickname = defender.getPhase() < 0
|
|
? '先'
|
|
: `${attackerUnit.getPhase() + 1} `;
|
|
|
|
if (deadAttacker > 0 || deadDefender > 0) {
|
|
attackerUnit.getLogger().pushGeneralBattleDetailLog(
|
|
`${phaseNickname}: <Y1>【${attackerUnit.getName()}】</> <C>${attackerUnit.getHP()} (-${deadAttacker})</> VS <C>${defender.getHP()} (-${deadDefender})</> <Y1>【${defender.getName()}】</>`
|
|
);
|
|
|
|
defender.getLogger().pushGeneralBattleDetailLog(
|
|
`${phaseNickname}: <Y1>【${defender.getName()}】</> <C>${defender.getHP()} (-${deadDefender})</> VS <C>${attackerUnit.getHP()} (-${deadAttacker})</> <Y1>【${attackerUnit.getName()}】</>`
|
|
);
|
|
}
|
|
|
|
attackerUnit.addPhase();
|
|
defender.addPhase();
|
|
|
|
const attackerState = attackerUnit.continueWar();
|
|
if (!attackerState.canContinue) {
|
|
logWritten = true;
|
|
|
|
attackerUnit.logBattleResult();
|
|
defender.logBattleResult();
|
|
|
|
attackerUnit.addLose();
|
|
defender.addWin();
|
|
|
|
attackerUnit.tryWound();
|
|
defender.tryWound();
|
|
|
|
const josaYiCrew = JosaUtil.pick(attackerUnit.getCrewTypeName(), '이');
|
|
attackerLogger.pushGlobalActionLog(
|
|
`<Y>${attackerUnit.getName()}</>의 ${attackerUnit.getCrewTypeName()}${josaYiCrew} 퇴각했습니다.`,
|
|
LogFormat.MONTH
|
|
);
|
|
attackerUnit.getLogger().pushGeneralActionLog(
|
|
attackerState.noRice ? '군량 부족으로 퇴각합니다.' : '퇴각했습니다.',
|
|
LogFormat.PLAIN
|
|
);
|
|
defender.getLogger().pushGeneralActionLog(
|
|
`<Y>${attackerUnit.getName()}</>의 ${attackerUnit.getCrewTypeName()}${josaYiCrew} 퇴각했습니다.`,
|
|
LogFormat.PLAIN
|
|
);
|
|
break;
|
|
}
|
|
|
|
const defenderState = defender.continueWar();
|
|
if (!defenderState.canContinue) {
|
|
logWritten = true;
|
|
|
|
attackerUnit.logBattleResult();
|
|
defender.logBattleResult();
|
|
|
|
if (!(defender instanceof WarUnitCity) || defender.isSiege()) {
|
|
attackerUnit.addWin();
|
|
defender.addLose();
|
|
|
|
attackerUnit.tryWound();
|
|
defender.tryWound();
|
|
|
|
if (defender === cityUnit) {
|
|
attackerUnit.addLevelExp(1000);
|
|
conquerCity = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
const josaYiDefCrew = JosaUtil.pick(defender.getCrewTypeName(), '이');
|
|
|
|
if (defender instanceof WarUnitCity && !defender.isSiege()) {
|
|
defender.setOppose(null);
|
|
} else if (defenderState.noRice) {
|
|
attackerLogger.pushGlobalActionLog(
|
|
`<Y>${defender.getName()}</>의 ${defender.getCrewTypeName()}${josaYiDefCrew} 패퇴했습니다.`,
|
|
LogFormat.MONTH
|
|
);
|
|
attackerUnit.getLogger().pushGeneralActionLog(
|
|
`<Y>${defender.getName()}</>의 ${defender.getCrewTypeName()}${josaYiDefCrew} 패퇴했습니다.`,
|
|
LogFormat.PLAIN
|
|
);
|
|
defender.getLogger().pushGeneralActionLog(
|
|
'군량 부족으로 패퇴합니다.',
|
|
LogFormat.PLAIN
|
|
);
|
|
} else {
|
|
attackerLogger.pushGlobalActionLog(
|
|
`<Y>${defender.getName()}</>의 ${defender.getCrewTypeName()}${josaYiDefCrew} 전멸했습니다.`,
|
|
LogFormat.MONTH
|
|
);
|
|
attackerUnit.getLogger().pushGeneralActionLog(
|
|
`<Y>${defender.getName()}</>의 ${defender.getCrewTypeName()}${josaYiDefCrew} 전멸했습니다.`,
|
|
LogFormat.PLAIN
|
|
);
|
|
defender.getLogger().pushGeneralActionLog(
|
|
'전멸했습니다.',
|
|
LogFormat.PLAIN
|
|
);
|
|
}
|
|
|
|
if (attackerUnit.getPhase() >= attackerUnit.getMaxPhase()) {
|
|
break;
|
|
}
|
|
|
|
defender.finishBattle();
|
|
defender = getNextDefender(defender, true);
|
|
}
|
|
}
|
|
|
|
if (!logWritten && defender) {
|
|
attackerUnit.logBattleResult();
|
|
defender.logBattleResult();
|
|
|
|
attackerUnit.tryWound();
|
|
defender.tryWound();
|
|
}
|
|
|
|
attackerUnit.finishBattle();
|
|
defender?.finishBattle();
|
|
|
|
if (cityUnit.getDead() > 0 || defender instanceof WarUnitCity) {
|
|
if (cityUnit !== defender) {
|
|
cityUnit.setOppose(attackerUnit);
|
|
cityUnit.setSiege();
|
|
cityUnit.finishBattle();
|
|
}
|
|
|
|
const newConflict = cityUnit.addConflict();
|
|
if (newConflict) {
|
|
const nationName = attackerUnit.getNationVar('name') as string;
|
|
const josaYiNation = JosaUtil.pick(nationName, '이');
|
|
attackerLogger.pushGlobalHistoryLog(
|
|
`<M><b>【분쟁】</b></><D><b>${nationName}</b></>${josaYiNation} <G><b>${cityName}</b></> 공략에 가담하여 분쟁이 발생하고 있습니다.`,
|
|
LogFormat.YEAR_MONTH
|
|
);
|
|
}
|
|
}
|
|
|
|
const logs = flushLoggers([
|
|
attackerLogger,
|
|
...defenderGenerals.map((unit) => unit.getLogger()),
|
|
]);
|
|
|
|
const reports: WarUnitReport[] = [
|
|
resolveUnitReport(attackerUnit),
|
|
...defenderUnits.map(resolveUnitReport),
|
|
resolveUnitReport(cityUnit),
|
|
];
|
|
|
|
return {
|
|
attacker: attackerUnit.getGeneral(),
|
|
defenders: defenderGenerals.map((unit) => unit.getGeneral()),
|
|
defenderCity: input.defenderCity,
|
|
logs,
|
|
conquered: conquerCity,
|
|
reports,
|
|
metrics: {
|
|
attackerPhase: attackerUnit.getPhase(),
|
|
attackerActivatedSkills: attackerUnit.getActivatedSkillLog(),
|
|
defenderActivatedSkills: defenderUnits.map((unit) =>
|
|
unit.getActivatedSkillLog()
|
|
),
|
|
},
|
|
};
|
|
};
|
|
|
|
export const resolveDefenderOrder = <
|
|
TriggerState extends GeneralTriggerState = GeneralTriggerState
|
|
>(
|
|
input: WarBattleInput<TriggerState>
|
|
): number[] => {
|
|
const rng =
|
|
input.rng ??
|
|
new RandUtil(
|
|
LiteHashDRBG.build(input.seed ?? '')
|
|
);
|
|
const loggerFactory = input.loggerFactory ?? defaultLoggerFactory;
|
|
|
|
const crewTypeIndex = buildWarCrewTypeIndex(input.unitSet);
|
|
const attackerPipeline = createPipeline(input.attacker);
|
|
const attackerLogger =
|
|
input.attacker.logger ??
|
|
loggerFactory({
|
|
generalId: input.attacker.general.id,
|
|
nationId: input.attacker.general.nationId,
|
|
});
|
|
|
|
const attackerUnit = new WarUnitGeneral(
|
|
rng,
|
|
input.config,
|
|
input.attacker.general,
|
|
input.attacker.city,
|
|
input.attacker.nation,
|
|
true,
|
|
resolveCrewType(crewTypeIndex, input.attacker.general.crewTypeId),
|
|
attackerLogger,
|
|
attackerPipeline
|
|
);
|
|
|
|
const defenderUnits: WarUnitGeneral<TriggerState>[] = [];
|
|
for (const defender of input.defenders) {
|
|
const defenderLogger =
|
|
defender.logger ??
|
|
loggerFactory({
|
|
generalId: defender.general.id,
|
|
nationId: defender.general.nationId,
|
|
});
|
|
const unit = new WarUnitGeneral(
|
|
rng,
|
|
input.config,
|
|
defender.general,
|
|
input.defenderCity,
|
|
defender.nation,
|
|
false,
|
|
resolveCrewType(crewTypeIndex, defender.general.crewTypeId),
|
|
defenderLogger,
|
|
createPipeline(defender)
|
|
);
|
|
if (computeBattleOrder(unit, attackerUnit) <= 0) {
|
|
continue;
|
|
}
|
|
defenderUnits.push(unit);
|
|
}
|
|
|
|
defenderUnits.sort(
|
|
(lhs, rhs) =>
|
|
computeBattleOrder(rhs, attackerUnit) -
|
|
computeBattleOrder(lhs, attackerUnit)
|
|
);
|
|
|
|
return defenderUnits.map((unit) => unit.getGeneral().id);
|
|
};
|