This commit is contained in:
823
src/hooks/combat/battlePlan.ts
Normal file
823
src/hooks/combat/battlePlan.ts
Normal file
@@ -0,0 +1,823 @@
|
||||
import { resolveRoleCombatStats } from '../../data/attributeCombat';
|
||||
import { resolveCharacterAttributeProfile } from '../../data/attributeResolver';
|
||||
import {
|
||||
appendBuildBuffs,
|
||||
resolveCompanionOutgoingDamageResult,
|
||||
resolveMonsterOutgoingDamageResult,
|
||||
resolvePlayerOutgoingDamageResult,
|
||||
tickBuildBuffs,
|
||||
} from '../../data/buildDamage';
|
||||
import {
|
||||
getSkillDelivery,
|
||||
} from '../../data/characterCombat';
|
||||
import {
|
||||
getCharacterById,
|
||||
getCharacterMaxMana,
|
||||
} from '../../data/characterPresets';
|
||||
import { getEquipmentBonuses } from '../../data/equipmentEffects';
|
||||
import {
|
||||
getClosestHostileNpc,
|
||||
getFacingTowardPlayer,
|
||||
settleHostileNpcAnimations,
|
||||
} from '../../data/hostileNpcs';
|
||||
import { getFunctionEffect } from '../../data/stateFunctions';
|
||||
import type {
|
||||
Character,
|
||||
CharacterSkillDefinition,
|
||||
CombatDelivery,
|
||||
CompanionState,
|
||||
GameState,
|
||||
SceneHostileNpc,
|
||||
StoryOption,
|
||||
} from '../../types';
|
||||
import {
|
||||
AnimationState,
|
||||
} from '../../types';
|
||||
import {
|
||||
chooseWeightedSkill,
|
||||
chooseWeightedSkillForStyle,
|
||||
inferCombatStyle,
|
||||
normalizeSkillProbabilities,
|
||||
} from '../combatStoryUtils';
|
||||
|
||||
type TurnActor = 'player' | 'companion' | 'monster';
|
||||
|
||||
export type BattlePlanStep =
|
||||
| {
|
||||
actor: 'player';
|
||||
targetHostileNpcId: string;
|
||||
originalPlayerX: number;
|
||||
strikeX: number;
|
||||
cooledDown: Record<string, number>;
|
||||
selectedSkillId: string | null;
|
||||
appliedCooldowns: Record<string, number>;
|
||||
damage: number;
|
||||
criticalHit?: boolean;
|
||||
defeated: boolean;
|
||||
endsBattle: boolean;
|
||||
delivery: CombatDelivery;
|
||||
}
|
||||
| {
|
||||
actor: 'companion';
|
||||
companionNpcId: string;
|
||||
targetHostileNpcId: string;
|
||||
strikeOffsetX: number;
|
||||
cooledDown: Record<string, number>;
|
||||
selectedSkillId: string | null;
|
||||
appliedCooldowns: Record<string, number>;
|
||||
damage: number;
|
||||
criticalHit?: boolean;
|
||||
defeated: boolean;
|
||||
endsBattle: boolean;
|
||||
delivery: CombatDelivery;
|
||||
}
|
||||
| {
|
||||
actor: 'monster';
|
||||
monsterId: string;
|
||||
originalMonsterX: number;
|
||||
strikeX: number;
|
||||
target: 'player' | 'companion';
|
||||
targetCompanionNpcId?: string;
|
||||
targetX: number;
|
||||
damage: number;
|
||||
criticalHit?: boolean;
|
||||
endsBattle: boolean;
|
||||
selectedSkillId: string | null;
|
||||
npcCharacterId: string | null;
|
||||
delivery: CombatDelivery;
|
||||
};
|
||||
|
||||
export type BattlePlan = {
|
||||
preparedState: GameState;
|
||||
turns: BattlePlanStep[];
|
||||
finalState: GameState;
|
||||
};
|
||||
|
||||
function createEmptyCooldowns(character: Character) {
|
||||
return Object.fromEntries(character.skills.map(skill => [skill.id, 0]));
|
||||
}
|
||||
|
||||
function normalizeCooldowns(character: Character, cooldowns: Record<string, number>) {
|
||||
return Object.fromEntries(character.skills.map(skill => [skill.id, Math.max(0, cooldowns[skill.id] ?? 0)]));
|
||||
}
|
||||
|
||||
function isCompanionAlive(companion: CompanionState) {
|
||||
return companion.hp > 0;
|
||||
}
|
||||
|
||||
export function resetCompanionCombatPresentation(companions: CompanionState[]) {
|
||||
return companions.map(companion => ({
|
||||
...companion,
|
||||
animationState: companion.hp > 0 ? AnimationState.IDLE : AnimationState.DIE,
|
||||
actionMode: 'idle' as const,
|
||||
offsetX: 0,
|
||||
offsetY: 0,
|
||||
transitionMs: 0,
|
||||
}));
|
||||
}
|
||||
|
||||
export function updateCompanionState(
|
||||
companions: CompanionState[],
|
||||
npcId: string,
|
||||
updater: (companion: CompanionState) => CompanionState,
|
||||
) {
|
||||
return companions.map(companion => companion.npcId === npcId ? updater(companion) : companion);
|
||||
}
|
||||
|
||||
function getCompanionSlotIndex(companions: CompanionState[], npcId: string) {
|
||||
return Math.max(0, companions.findIndex(companion => companion.npcId === npcId));
|
||||
}
|
||||
|
||||
export function getCompanionAnchorX(playerX: number, companions: CompanionState[], npcId: string) {
|
||||
const slotIndex = getCompanionSlotIndex(companions, npcId);
|
||||
return Number((playerX - (slotIndex % 2 === 0 ? 0.38 : 0.18)).toFixed(2));
|
||||
}
|
||||
|
||||
function getCompanionStrikeOffset(companions: CompanionState[], npcId: string) {
|
||||
const slotIndex = getCompanionSlotIndex(companions, npcId);
|
||||
return slotIndex % 2 === 0 ? 54 : 44;
|
||||
}
|
||||
|
||||
function getLivingPartyTargets(state: GameState) {
|
||||
const targets: Array<{ kind: 'player' } | { kind: 'companion'; npcId: string }> = [];
|
||||
if (state.playerHp > 0) {
|
||||
targets.push({ kind: 'player' });
|
||||
}
|
||||
if (state.currentNpcBattleMode === 'spar') {
|
||||
return targets;
|
||||
}
|
||||
state.companions.filter(isCompanionAlive).forEach(companion => {
|
||||
targets.push({ kind: 'companion', npcId: companion.npcId });
|
||||
});
|
||||
return targets;
|
||||
}
|
||||
|
||||
function chooseRandomPartyTarget(state: GameState) {
|
||||
const targets = getLivingPartyTargets(state);
|
||||
if (targets.length === 0) return null;
|
||||
return targets[Math.floor(Math.random() * targets.length)] ?? null;
|
||||
}
|
||||
|
||||
function getCombatActorKey(actor: TurnActor, id?: string) {
|
||||
return id ? `${actor}:${id}` : actor;
|
||||
}
|
||||
|
||||
function buildCombatTurnOrder(
|
||||
state: GameState,
|
||||
playerCharacter: Character,
|
||||
sequenceMs: number,
|
||||
turnVisualMs: number,
|
||||
resetStageMs: number,
|
||||
minTurnCount: number,
|
||||
) {
|
||||
const actorTimings = new Map<string, { actor: TurnActor; id?: string; nextAt: number; cadence: number }>();
|
||||
|
||||
actorTimings.set(getCombatActorKey('player'), {
|
||||
actor: 'player',
|
||||
nextAt: 0,
|
||||
cadence: 1400 / Math.max(
|
||||
resolveRoleCombatStats(
|
||||
resolveCharacterAttributeProfile(
|
||||
playerCharacter,
|
||||
state.worldType,
|
||||
state.customWorldProfile,
|
||||
),
|
||||
).turnSpeed,
|
||||
1,
|
||||
),
|
||||
});
|
||||
|
||||
state.companions
|
||||
.filter(companion => state.currentNpcBattleMode !== 'spar' && isCompanionAlive(companion))
|
||||
.forEach(companion => {
|
||||
const companionCharacter = getCharacterById(companion.characterId);
|
||||
if (!companionCharacter) return;
|
||||
actorTimings.set(getCombatActorKey('companion', companion.npcId), {
|
||||
actor: 'companion',
|
||||
id: companion.npcId,
|
||||
nextAt: 0,
|
||||
cadence: 1400 / Math.max(
|
||||
resolveRoleCombatStats(
|
||||
resolveCharacterAttributeProfile(
|
||||
companionCharacter,
|
||||
state.worldType,
|
||||
state.customWorldProfile,
|
||||
),
|
||||
).turnSpeed,
|
||||
1,
|
||||
),
|
||||
});
|
||||
});
|
||||
|
||||
state.sceneHostileNpcs.forEach(monster => {
|
||||
actorTimings.set(getCombatActorKey('monster', monster.id), {
|
||||
actor: 'monster',
|
||||
id: monster.id,
|
||||
nextAt: 0,
|
||||
cadence: 1400 / Math.max(monster.speed, 1),
|
||||
});
|
||||
});
|
||||
|
||||
const turnOrder: Array<{ actor: TurnActor; id?: string }> = [];
|
||||
|
||||
while (turnOrder.length < minTurnCount || turnOrder.length * (turnVisualMs + resetStageMs) < sequenceMs) {
|
||||
const availableActors = [...actorTimings.values()].filter(item => {
|
||||
if (item.actor === 'player') return state.playerHp > 0;
|
||||
if (item.actor === 'companion') {
|
||||
return state.companions.some(companion => companion.npcId === item.id && isCompanionAlive(companion));
|
||||
}
|
||||
return state.sceneHostileNpcs.some(monster => monster.id === item.id && monster.hp > 0);
|
||||
});
|
||||
|
||||
if (availableActors.length === 0) break;
|
||||
|
||||
availableActors.sort((a, b) => a.nextAt - b.nextAt || a.cadence - b.cadence);
|
||||
const nextActor = availableActors[0];
|
||||
if (!nextActor) break;
|
||||
turnOrder.push({ actor: nextActor.actor, id: nextActor.id });
|
||||
nextActor.nextAt += nextActor.cadence;
|
||||
}
|
||||
|
||||
return turnOrder;
|
||||
}
|
||||
|
||||
export function applyDamageToPartyTarget(
|
||||
state: GameState,
|
||||
target: { kind: 'player' } | { kind: 'companion'; npcId: string },
|
||||
damage: number,
|
||||
) {
|
||||
if (target.kind === 'player') {
|
||||
const adjustedDamage = Math.max(
|
||||
1,
|
||||
Math.round(damage * getEquipmentBonuses(state.playerEquipment).incomingDamageMultiplier),
|
||||
);
|
||||
|
||||
return {
|
||||
...state,
|
||||
playerHp: Math.max(0, state.playerHp - adjustedDamage),
|
||||
};
|
||||
}
|
||||
|
||||
return {
|
||||
...state,
|
||||
companions: updateCompanionState(
|
||||
state.companions,
|
||||
target.npcId,
|
||||
companion => ({
|
||||
...companion,
|
||||
hp: Math.max(0, companion.hp - damage),
|
||||
}),
|
||||
),
|
||||
};
|
||||
}
|
||||
|
||||
function tickSkillCooldowns(character: Character, cooldowns: Record<string, number>) {
|
||||
const normalized = normalizeCooldowns(character, cooldowns);
|
||||
return Object.fromEntries(
|
||||
Object.entries(normalized).map(([skillId, turns]) => [skillId, Math.max(0, turns - 1)]),
|
||||
);
|
||||
}
|
||||
|
||||
function getRequestedSkillId(option: StoryOption) {
|
||||
return typeof option.runtimePayload?.skillId === 'string'
|
||||
? option.runtimePayload.skillId
|
||||
: null;
|
||||
}
|
||||
|
||||
function choosePlayerSkillForOption(
|
||||
character: Character,
|
||||
mana: number,
|
||||
cooldowns: Record<string, number>,
|
||||
option: StoryOption,
|
||||
) {
|
||||
const requestedSkillId = getRequestedSkillId(option);
|
||||
if (requestedSkillId) {
|
||||
const requestedSkill = character.skills.find(skill => skill.id === requestedSkillId) ?? null;
|
||||
if (!requestedSkill) return null;
|
||||
if ((cooldowns[requestedSkill.id] ?? 0) > 0 || mana < requestedSkill.manaCost) return null;
|
||||
return requestedSkill;
|
||||
}
|
||||
|
||||
return chooseWeightedSkill(character, mana, cooldowns, option);
|
||||
}
|
||||
|
||||
export function getFacingForPlayer(playerX: number, monster: SceneHostileNpc | null) {
|
||||
if (!monster) return 'right' as const;
|
||||
return monster.xMeters >= playerX ? 'right' : 'left';
|
||||
}
|
||||
|
||||
export function getMeleeStrikeX(attackerX: number, defenderX: number) {
|
||||
return defenderX > attackerX
|
||||
? Number((defenderX - 0.1).toFixed(1))
|
||||
: Number((defenderX + 0.1).toFixed(1));
|
||||
}
|
||||
|
||||
export function getSkillStrikeX(skill: CharacterSkillDefinition, attackerX: number, defenderX: number) {
|
||||
return getSkillDelivery(skill) === 'ranged'
|
||||
? attackerX
|
||||
: getMeleeStrikeX(attackerX, defenderX);
|
||||
}
|
||||
|
||||
export function resetCombatPresentation(monsters: SceneHostileNpc[], playerX: number) {
|
||||
return settleHostileNpcAnimations(monsters).map(monster => ({
|
||||
...monster,
|
||||
facing: getFacingTowardPlayer(monster.xMeters, playerX),
|
||||
characterAnimation: undefined,
|
||||
combatMode: undefined,
|
||||
}));
|
||||
}
|
||||
|
||||
export function applyRecoveryEffectToState(
|
||||
state: GameState,
|
||||
character: Character,
|
||||
functionId: string,
|
||||
) {
|
||||
const effect = getFunctionEffect(functionId);
|
||||
if (
|
||||
(effect.healAmount ?? 0) <= 0 &&
|
||||
(effect.manaRestore ?? 0) <= 0 &&
|
||||
(effect.cooldownTickBonus ?? 0) <= 0
|
||||
) {
|
||||
return state;
|
||||
}
|
||||
|
||||
let cooldowns = state.playerSkillCooldowns;
|
||||
|
||||
for (let index = 0; index < (effect.cooldownTickBonus ?? 0); index += 1) {
|
||||
cooldowns = tickSkillCooldowns(character, cooldowns);
|
||||
}
|
||||
|
||||
return {
|
||||
...state,
|
||||
playerHp: Math.min(state.playerMaxHp, state.playerHp + (effect.healAmount ?? 0)),
|
||||
playerMana: Math.min(state.playerMaxMana, state.playerMana + (effect.manaRestore ?? 0)),
|
||||
playerSkillCooldowns: cooldowns,
|
||||
};
|
||||
}
|
||||
|
||||
export function buildBattlePlan({
|
||||
state,
|
||||
option,
|
||||
character,
|
||||
totalSequenceMs,
|
||||
turnVisualMs,
|
||||
resetStageMs,
|
||||
minTurnCount,
|
||||
}: {
|
||||
state: GameState;
|
||||
option: StoryOption;
|
||||
character: Character;
|
||||
totalSequenceMs: number;
|
||||
turnVisualMs: number;
|
||||
resetStageMs: number;
|
||||
minTurnCount: number;
|
||||
}): BattlePlan {
|
||||
const battleState: GameState = {
|
||||
...state,
|
||||
};
|
||||
const targetMonster = getClosestHostileNpc(
|
||||
battleState.playerX,
|
||||
battleState.sceneHostileNpcs,
|
||||
);
|
||||
if (!targetMonster) {
|
||||
return {
|
||||
preparedState: battleState,
|
||||
turns: [],
|
||||
finalState: {
|
||||
...battleState,
|
||||
inBattle: false,
|
||||
sceneHostileNpcs: [],
|
||||
companions: resetCompanionCombatPresentation(state.companions),
|
||||
animationState: AnimationState.IDLE,
|
||||
playerActionMode: 'idle' as const,
|
||||
activeCombatEffects: [],
|
||||
scrollWorld: false,
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
const functionEffect = getFunctionEffect(option.functionId);
|
||||
const isRecoveryAction = option.functionId === 'battle_recover_breath';
|
||||
const isNpcSpar = battleState.currentNpcBattleMode === 'spar';
|
||||
const sequenceMs = Math.round(totalSequenceMs * (functionEffect.turnTimeMultiplier ?? 1));
|
||||
const turnOrder = buildCombatTurnOrder(
|
||||
battleState,
|
||||
character,
|
||||
sequenceMs,
|
||||
turnVisualMs,
|
||||
resetStageMs,
|
||||
minTurnCount,
|
||||
);
|
||||
const normalizedOption = normalizeSkillProbabilities(option, character);
|
||||
const npcBattleResources = new Map<string, {
|
||||
character: Character;
|
||||
mana: number;
|
||||
cooldowns: Record<string, number>;
|
||||
}>();
|
||||
|
||||
battleState.sceneHostileNpcs.forEach(monster => {
|
||||
const npcCharacterId = monster.encounter?.characterId ?? null;
|
||||
const npcCharacter = npcCharacterId ? getCharacterById(npcCharacterId) : null;
|
||||
if (!npcCharacter) return;
|
||||
|
||||
npcBattleResources.set(monster.id, {
|
||||
character: npcCharacter,
|
||||
mana: getCharacterMaxMana(npcCharacter),
|
||||
cooldowns: createEmptyCooldowns(npcCharacter),
|
||||
});
|
||||
});
|
||||
|
||||
let simulatedState: GameState = {
|
||||
...applyRecoveryEffectToState(battleState, character, option.functionId),
|
||||
companions: resetCompanionCombatPresentation(battleState.companions),
|
||||
sceneHostileNpcs: resetCombatPresentation(
|
||||
battleState.sceneHostileNpcs,
|
||||
battleState.playerX,
|
||||
),
|
||||
activeCombatEffects: [],
|
||||
playerActionMode: 'idle' as const,
|
||||
currentNpcBattleOutcome: null,
|
||||
};
|
||||
const preparedState = simulatedState;
|
||||
const turns: BattlePlanStep[] = [];
|
||||
|
||||
for (const [turnIndex, turn] of turnOrder.entries()) {
|
||||
const currentTarget = getClosestHostileNpc(simulatedState.playerX, simulatedState.sceneHostileNpcs);
|
||||
if (!currentTarget) break;
|
||||
|
||||
if (turn.actor === 'player') {
|
||||
if (simulatedState.playerHp <= 0) continue;
|
||||
|
||||
const cooledDown = tickSkillCooldowns(character, simulatedState.playerSkillCooldowns);
|
||||
simulatedState = {
|
||||
...simulatedState,
|
||||
playerSkillCooldowns: cooledDown,
|
||||
};
|
||||
|
||||
// 后端单技能按钮通过 runtimePayload.skillId 指定技能，本地兜底也必须保持同一语义。
|
||||
const selectedSkill = isRecoveryAction
|
||||
? null
|
||||
: choosePlayerSkillForOption(character, simulatedState.playerMana, cooledDown, normalizedOption);
|
||||
if (!selectedSkill) {
|
||||
continue;
|
||||
}
|
||||
|
||||
const originalPlayerX = simulatedState.playerX;
|
||||
const delivery = getSkillDelivery(selectedSkill);
|
||||
const strikeX = getSkillStrikeX(selectedSkill, originalPlayerX, currentTarget.xMeters);
|
||||
const appliedCooldowns = {
|
||||
...cooledDown,
|
||||
[selectedSkill.id]: selectedSkill.cooldownTurns,
|
||||
};
|
||||
const damageResult = isNpcSpar
|
||||
? null
|
||||
: resolvePlayerOutgoingDamageResult(
|
||||
simulatedState,
|
||||
character,
|
||||
selectedSkill.damage,
|
||||
functionEffect.damageMultiplier ?? 1,
|
||||
`${option.functionId}:player:${turnIndex}:${selectedSkill.id}:${currentTarget.id}`,
|
||||
);
|
||||
const damage = isNpcSpar ? 1 : damageResult!.damage;
|
||||
const wouldEndSpar = isNpcSpar && currentTarget.hp - damage <= 1;
|
||||
|
||||
const resolvedMonsters = simulatedState.sceneHostileNpcs.map(monster =>
|
||||
monster.id === currentTarget.id
|
||||
? {
|
||||
...monster,
|
||||
hp: isNpcSpar
|
||||
? Math.max(1, monster.hp - damage)
|
||||
: Math.max(0, monster.hp - damage),
|
||||
}
|
||||
: monster,
|
||||
);
|
||||
const defeated = !isNpcSpar && resolvedMonsters.some(monster => monster.id === currentTarget.id && monster.hp <= 0);
|
||||
const remainingMonsters = defeated
|
||||
? resolvedMonsters.filter(monster => !(monster.id === currentTarget.id && monster.hp <= 0))
|
||||
: resolvedMonsters;
|
||||
const nextTarget = getClosestHostileNpc(originalPlayerX, remainingMonsters);
|
||||
|
||||
simulatedState = {
|
||||
...simulatedState,
|
||||
playerX: originalPlayerX,
|
||||
playerFacing: getFacingForPlayer(originalPlayerX, nextTarget ?? null),
|
||||
animationState: AnimationState.IDLE,
|
||||
playerActionMode: 'idle' as const,
|
||||
activeBuildBuffs: appendBuildBuffs(
|
||||
tickBuildBuffs(simulatedState.activeBuildBuffs),
|
||||
selectedSkill.buildBuffs,
|
||||
),
|
||||
activeCombatEffects: [],
|
||||
playerMana: Math.max(0, simulatedState.playerMana - selectedSkill.manaCost),
|
||||
playerSkillCooldowns: appliedCooldowns,
|
||||
sceneHostileNpcs: remainingMonsters.map(monster => ({
|
||||
...monster,
|
||||
characterAnimation: undefined,
|
||||
combatMode: undefined,
|
||||
})),
|
||||
companions: resetCompanionCombatPresentation(simulatedState.companions),
|
||||
inBattle: isNpcSpar ? !wouldEndSpar : remainingMonsters.length > 0,
|
||||
currentNpcBattleOutcome: wouldEndSpar
|
||||
? 'spar_complete'
|
||||
: (!isNpcSpar && remainingMonsters.length === 0 && simulatedState.currentBattleNpcId
|
||||
? 'fight_victory'
|
||||
: simulatedState.currentNpcBattleOutcome),
|
||||
};
|
||||
|
||||
turns.push({
|
||||
actor: 'player',
|
||||
targetHostileNpcId: currentTarget.id,
|
||||
originalPlayerX,
|
||||
strikeX,
|
||||
cooledDown,
|
||||
selectedSkillId: selectedSkill.id,
|
||||
appliedCooldowns,
|
||||
damage,
|
||||
criticalHit: damageResult?.isCritical ?? false,
|
||||
defeated,
|
||||
endsBattle: wouldEndSpar,
|
||||
delivery,
|
||||
});
|
||||
|
||||
if (!simulatedState.inBattle) {
|
||||
break;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
|
||||
if (turn.actor === 'companion') {
|
||||
const companion = simulatedState.companions.find(item => item.npcId === turn.id && isCompanionAlive(item));
|
||||
if (!companion) continue;
|
||||
|
||||
const companionCharacter = getCharacterById(companion.characterId);
|
||||
if (!companionCharacter) continue;
|
||||
|
||||
const companionX = getCompanionAnchorX(simulatedState.playerX, simulatedState.companions, companion.npcId);
|
||||
const targetMonster = getClosestHostileNpc(companionX, simulatedState.sceneHostileNpcs);
|
||||
if (!targetMonster) break;
|
||||
|
||||
const cooledDown = tickSkillCooldowns(companionCharacter, companion.skillCooldowns);
|
||||
simulatedState = {
|
||||
...simulatedState,
|
||||
companions: updateCompanionState(
|
||||
simulatedState.companions,
|
||||
companion.npcId,
|
||||
currentCompanion => ({
|
||||
...currentCompanion,
|
||||
skillCooldowns: cooledDown,
|
||||
}),
|
||||
),
|
||||
};
|
||||
|
||||
const selectedSkill = chooseWeightedSkillForStyle(
|
||||
companionCharacter,
|
||||
companion.mana,
|
||||
cooledDown,
|
||||
inferCombatStyle(option),
|
||||
);
|
||||
if (!selectedSkill) {
|
||||
continue;
|
||||
}
|
||||
|
||||
const delivery = getSkillDelivery(selectedSkill);
|
||||
const strikeOffsetX = delivery === 'melee'
|
||||
? getCompanionStrikeOffset(simulatedState.companions, companion.npcId)
|
||||
: 0;
|
||||
const appliedCooldowns = {
|
||||
...cooledDown,
|
||||
[selectedSkill.id]: selectedSkill.cooldownTurns,
|
||||
};
|
||||
const damageResult = isNpcSpar
|
||||
? null
|
||||
: resolveCompanionOutgoingDamageResult(
|
||||
companionCharacter,
|
||||
selectedSkill.damage,
|
||||
functionEffect.damageMultiplier ?? 1,
|
||||
state.worldType,
|
||||
state.customWorldProfile,
|
||||
`${option.functionId}:companion:${turnIndex}:${companion.npcId}:${selectedSkill.id}:${targetMonster.id}`,
|
||||
);
|
||||
const damage = isNpcSpar ? 1 : damageResult!.damage;
|
||||
const wouldEndSpar = isNpcSpar && targetMonster.hp - damage <= 1;
|
||||
|
||||
const resolvedMonsters = simulatedState.sceneHostileNpcs.map(monster =>
|
||||
monster.id === targetMonster.id
|
||||
? {
|
||||
...monster,
|
||||
hp: isNpcSpar
|
||||
? Math.max(1, monster.hp - damage)
|
||||
: Math.max(0, monster.hp - damage),
|
||||
}
|
||||
: monster,
|
||||
);
|
||||
const defeated = !isNpcSpar && resolvedMonsters.some(monster => monster.id === targetMonster.id && monster.hp <= 0);
|
||||
const remainingMonsters = defeated
|
||||
? resolvedMonsters.filter(monster => !(monster.id === targetMonster.id && monster.hp <= 0))
|
||||
: resolvedMonsters;
|
||||
|
||||
simulatedState = {
|
||||
...simulatedState,
|
||||
companions: updateCompanionState(
|
||||
resetCompanionCombatPresentation(simulatedState.companions),
|
||||
companion.npcId,
|
||||
currentCompanion => ({
|
||||
...currentCompanion,
|
||||
skillCooldowns: appliedCooldowns,
|
||||
}),
|
||||
),
|
||||
sceneHostileNpcs: remainingMonsters.map(monster => ({
|
||||
...monster,
|
||||
characterAnimation: undefined,
|
||||
combatMode: undefined,
|
||||
})),
|
||||
inBattle: isNpcSpar ? !wouldEndSpar : remainingMonsters.length > 0,
|
||||
currentNpcBattleOutcome: wouldEndSpar
|
||||
? 'spar_complete'
|
||||
: (!isNpcSpar && remainingMonsters.length === 0 && simulatedState.currentBattleNpcId
|
||||
? 'fight_victory'
|
||||
: simulatedState.currentNpcBattleOutcome),
|
||||
};
|
||||
|
||||
turns.push({
|
||||
actor: 'companion',
|
||||
companionNpcId: companion.npcId,
|
||||
targetHostileNpcId: targetMonster.id,
|
||||
strikeOffsetX,
|
||||
cooledDown,
|
||||
selectedSkillId: selectedSkill.id,
|
||||
appliedCooldowns,
|
||||
damage,
|
||||
criticalHit: damageResult?.isCritical ?? false,
|
||||
defeated,
|
||||
endsBattle: wouldEndSpar,
|
||||
delivery,
|
||||
});
|
||||
|
||||
if (!simulatedState.inBattle) {
|
||||
break;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
|
||||
const actingMonster = simulatedState.sceneHostileNpcs.find(monster => monster.id === turn.id && monster.hp > 0);
|
||||
if (!actingMonster) continue;
|
||||
|
||||
const randomTarget = chooseRandomPartyTarget(simulatedState);
|
||||
if (!randomTarget) break;
|
||||
|
||||
const originalMonsterX = actingMonster.xMeters;
|
||||
const targetX = randomTarget.kind === 'player'
|
||||
? simulatedState.playerX
|
||||
: getCompanionAnchorX(simulatedState.playerX, simulatedState.companions, randomTarget.npcId);
|
||||
const npcCombatant = npcBattleResources.get(actingMonster.id);
|
||||
|
||||
if (npcCombatant) {
|
||||
const cooledDown = tickSkillCooldowns(npcCombatant.character, npcCombatant.cooldowns);
|
||||
const selectedSkill = chooseWeightedSkillForStyle(
|
||||
npcCombatant.character,
|
||||
npcCombatant.mana,
|
||||
cooledDown,
|
||||
inferCombatStyle(option),
|
||||
);
|
||||
|
||||
npcBattleResources.set(actingMonster.id, {
|
||||
...npcCombatant,
|
||||
cooldowns: cooledDown,
|
||||
});
|
||||
|
||||
if (selectedSkill) {
|
||||
const delivery = getSkillDelivery(selectedSkill);
|
||||
const strikeX = getSkillStrikeX(selectedSkill, originalMonsterX, targetX);
|
||||
const damageResult = isNpcSpar
|
||||
? null
|
||||
: resolveCompanionOutgoingDamageResult(
|
||||
npcCombatant.character,
|
||||
selectedSkill.damage,
|
||||
functionEffect.incomingDamageMultiplier ?? 1,
|
||||
state.worldType,
|
||||
state.customWorldProfile,
|
||||
`${option.functionId}:monster-skill:${turnIndex}:${actingMonster.id}:${selectedSkill.id}:${randomTarget.kind}:${randomTarget.kind === 'companion' ? randomTarget.npcId : 'player'}`,
|
||||
);
|
||||
const damage = isNpcSpar ? 1 : damageResult!.damage;
|
||||
const wouldEndSpar = isNpcSpar && randomTarget.kind === 'player' && simulatedState.playerHp - damage <= 1;
|
||||
|
||||
npcBattleResources.set(actingMonster.id, {
|
||||
character: npcCombatant.character,
|
||||
mana: npcCombatant.mana,
|
||||
cooldowns: {
|
||||
...cooledDown,
|
||||
[selectedSkill.id]: selectedSkill.cooldownTurns,
|
||||
},
|
||||
});
|
||||
|
||||
const damagedState = applyDamageToPartyTarget(simulatedState, randomTarget, damage);
|
||||
simulatedState = {
|
||||
...damagedState,
|
||||
companions: resetCompanionCombatPresentation(damagedState.companions),
|
||||
sceneHostileNpcs: simulatedState.sceneHostileNpcs.map(monster => ({
|
||||
...monster,
|
||||
xMeters: monster.id === actingMonster.id ? originalMonsterX : monster.xMeters,
|
||||
animation: 'idle' as const,
|
||||
facing: getFacingTowardPlayer(
|
||||
monster.id === actingMonster.id ? originalMonsterX : monster.xMeters,
|
||||
simulatedState.playerX,
|
||||
),
|
||||
characterAnimation: undefined,
|
||||
combatMode: undefined,
|
||||
})),
|
||||
playerHp: isNpcSpar && randomTarget.kind === 'player'
|
||||
? Math.max(1, damagedState.playerHp)
|
||||
: damagedState.playerHp,
|
||||
inBattle: isNpcSpar ? !wouldEndSpar : damagedState.inBattle,
|
||||
currentNpcBattleOutcome: wouldEndSpar ? 'spar_complete' : simulatedState.currentNpcBattleOutcome,
|
||||
};
|
||||
|
||||
turns.push({
|
||||
actor: 'monster',
|
||||
monsterId: actingMonster.id,
|
||||
originalMonsterX,
|
||||
strikeX,
|
||||
target: randomTarget.kind,
|
||||
targetCompanionNpcId: randomTarget.kind === 'companion' ? randomTarget.npcId : undefined,
|
||||
targetX,
|
||||
damage,
|
||||
criticalHit: damageResult?.isCritical ?? false,
|
||||
endsBattle: wouldEndSpar,
|
||||
selectedSkillId: selectedSkill.id,
|
||||
npcCharacterId: npcCombatant.character.id,
|
||||
delivery,
|
||||
});
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
const strikeX = getMeleeStrikeX(originalMonsterX, targetX);
|
||||
const damageResult = isNpcSpar
|
||||
? null
|
||||
: resolveMonsterOutgoingDamageResult(
|
||||
actingMonster,
|
||||
9,
|
||||
functionEffect.incomingDamageMultiplier ?? 1,
|
||||
state.worldType,
|
||||
state.customWorldProfile,
|
||||
`${option.functionId}:monster:${turnIndex}:${actingMonster.id}:${randomTarget.kind}:${randomTarget.kind === 'companion' ? randomTarget.npcId : 'player'}`,
|
||||
);
|
||||
const damage = isNpcSpar ? 1 : damageResult!.damage;
|
||||
const wouldEndSpar = isNpcSpar && randomTarget.kind === 'player' && simulatedState.playerHp - damage <= 1;
|
||||
|
||||
const damagedState = applyDamageToPartyTarget(simulatedState, randomTarget, damage);
|
||||
simulatedState = {
|
||||
...damagedState,
|
||||
companions: resetCompanionCombatPresentation(damagedState.companions),
|
||||
sceneHostileNpcs: simulatedState.sceneHostileNpcs.map(monster => ({
|
||||
...monster,
|
||||
xMeters: monster.id === actingMonster.id ? originalMonsterX : monster.xMeters,
|
||||
animation: 'idle' as const,
|
||||
facing: getFacingTowardPlayer(
|
||||
monster.id === actingMonster.id ? originalMonsterX : monster.xMeters,
|
||||
simulatedState.playerX,
|
||||
),
|
||||
characterAnimation: undefined,
|
||||
combatMode: undefined,
|
||||
})),
|
||||
playerHp: isNpcSpar && randomTarget.kind === 'player'
|
||||
? Math.max(1, damagedState.playerHp)
|
||||
: damagedState.playerHp,
|
||||
inBattle: isNpcSpar ? !wouldEndSpar : damagedState.inBattle,
|
||||
currentNpcBattleOutcome: wouldEndSpar ? 'spar_complete' : simulatedState.currentNpcBattleOutcome,
|
||||
};
|
||||
|
||||
turns.push({
|
||||
actor: 'monster',
|
||||
monsterId: actingMonster.id,
|
||||
originalMonsterX,
|
||||
strikeX,
|
||||
target: randomTarget.kind,
|
||||
targetCompanionNpcId: randomTarget.kind === 'companion' ? randomTarget.npcId : undefined,
|
||||
targetX,
|
||||
damage,
|
||||
criticalHit: damageResult?.isCritical ?? false,
|
||||
endsBattle: wouldEndSpar,
|
||||
selectedSkillId: null,
|
||||
npcCharacterId: null,
|
||||
delivery: 'melee',
|
||||
});
|
||||
}
|
||||
|
||||
return {
|
||||
preparedState,
|
||||
turns,
|
||||
finalState: {
|
||||
...simulatedState,
|
||||
companions: resetCompanionCombatPresentation(simulatedState.companions),
|
||||
animationState: AnimationState.IDLE,
|
||||
playerActionMode: 'idle' as const,
|
||||
activeCombatEffects: [],
|
||||
scrollWorld: false,
|
||||
inBattle: simulatedState.currentNpcBattleOutcome === 'spar_complete'
|
||||
? false
|
||||
: simulatedState.sceneHostileNpcs.length > 0,
|
||||
sceneHostileNpcs: resetCombatPresentation(simulatedState.sceneHostileNpcs, simulatedState.playerX),
|
||||
},
|
||||
};
|
||||
}
|
||||
Reference in New Issue
Block a user