kdletters
718 lines
21 KiB
TypeScript
718 lines
21 KiB
TypeScript
import { resolveCustomWorldRoleIdReference } from '../services/customWorldRoleReferences';
|
|
import {
|
|
canUseLimitedPrimaryNpcChat,
|
|
resolveActiveSceneActEncounterFocusNpcId,
|
|
resolveActiveSceneActEncounterNpcIds,
|
|
} from '../services/customWorldSceneActRuntime';
|
|
import {
|
|
AnimationState,
|
|
Encounter,
|
|
GameState,
|
|
SceneHostileNpc,
|
|
SceneNpc,
|
|
WorldType,
|
|
} from '../types';
|
|
import { getRecruitedNpcIds } from './companionRoster';
|
|
import {
|
|
createSceneHostileNpcsFromEncounters,
|
|
createSceneHostileNpcsFromIds,
|
|
getFacingTowardPlayer,
|
|
getMonsterGroupAnchorX,
|
|
pickEncounterMonsterIds,
|
|
PLAYER_BASE_X_METERS,
|
|
} from './hostileNpcs';
|
|
import { buildInitialNpcState, createNpcBattleMonster } from './npcInteractions';
|
|
import {
|
|
buildEncounterFromSceneNpc,
|
|
getSceneFriendlyNpcs,
|
|
getSceneHostileNpcs,
|
|
getWorldCampScenePreset,
|
|
} from './scenePresets';
|
|
|
|
export const EXPLORE_APPROACH_DURATION_MS = 4000;
|
|
export const PREVIEW_ENTITY_X_METERS = 12;
|
|
export const RESOLVED_ENTITY_X_METERS = 3.2;
|
|
export const CALL_OUT_ENTRY_X_METERS = 18;
|
|
export const TREASURE_ENCOUNTERS_ENABLED = false;
|
|
const SCENE_ACT_BACK_ROW_BATTLE_X_METERS = Number(
|
|
(RESOLVED_ENTITY_X_METERS + 1.08).toFixed(2),
|
|
);
|
|
const SCENE_ACT_BACK_ROW_BATTLE_Y_OFFSETS = [62, -46] as const;
|
|
|
|
function isNpcBattleAlignmentDebugEnabled() {
|
|
if (typeof window === 'undefined') {
|
|
return false;
|
|
}
|
|
|
|
return (
|
|
window.localStorage.getItem('rpg:npc-battle-alignment-debug') === '1' ||
|
|
window.location.search.includes('npcBattleAlignmentDebug=1')
|
|
);
|
|
}
|
|
|
|
function logNpcBattleFormation(
|
|
label: string,
|
|
monsters: Array<Pick<SceneHostileNpc, 'id' | 'xMeters' | 'yOffset' | 'encounter'>>,
|
|
) {
|
|
if (!isNpcBattleAlignmentDebugEnabled()) {
|
|
return;
|
|
}
|
|
|
|
console.info(
|
|
`[npc-battle-formation] ${label}`,
|
|
monsters.map((monster) => ({
|
|
id: monster.id,
|
|
encounterId: monster.encounter?.id ?? null,
|
|
encounterName: monster.encounter?.npcName ?? null,
|
|
xMeters: monster.xMeters,
|
|
yOffset: monster.yOffset,
|
|
})),
|
|
);
|
|
}
|
|
|
|
function getNpcEncounterKey(encounter: Encounter) {
|
|
return encounter.id ?? encounter.npcName;
|
|
}
|
|
|
|
function getResolvedNpcState(state: GameState, encounter: Encounter) {
|
|
return state.npcStates[getNpcEncounterKey(encounter)] ?? buildInitialNpcState(encounter, state.worldType, state);
|
|
}
|
|
|
|
function shouldAutoStartBattleForEncounter(state: GameState, encounter: Encounter) {
|
|
if (encounter.kind !== 'npc') return false;
|
|
const npcState = getResolvedNpcState(state, encounter);
|
|
const npcId = getNpcEncounterKey(encounter);
|
|
if (
|
|
canUseLimitedPrimaryNpcChat({
|
|
profile: state.customWorldProfile,
|
|
sceneId: state.currentScenePreset?.id ?? null,
|
|
storyEngineMemory: state.storyEngineMemory,
|
|
npcId,
|
|
affinity: npcState.affinity,
|
|
})
|
|
) {
|
|
return false;
|
|
}
|
|
return npcState.affinity < 0 || (npcState.relationState?.affinity ?? npcState.affinity) < 0;
|
|
}
|
|
|
|
function resolveSceneActEncounterMembers(
|
|
state: GameState,
|
|
encounter: Encounter,
|
|
) {
|
|
const currentSceneNpcs = state.currentScenePreset?.npcs ?? [];
|
|
if (currentSceneNpcs.length === 0) {
|
|
return [];
|
|
}
|
|
|
|
const activeActNpcIds = resolveActiveSceneActEncounterNpcIds({
|
|
profile: state.customWorldProfile,
|
|
sceneId: state.currentScenePreset?.id ?? null,
|
|
storyEngineMemory: state.storyEngineMemory,
|
|
});
|
|
if (activeActNpcIds.length <= 1) {
|
|
return [];
|
|
}
|
|
|
|
const seenNpcIds = new Set<string>();
|
|
|
|
return currentSceneNpcs
|
|
.filter((candidate) => {
|
|
const candidateIds = [
|
|
candidate.id,
|
|
candidate.characterId,
|
|
candidate.name,
|
|
candidate.title,
|
|
]
|
|
.map((value) =>
|
|
resolveCustomWorldRoleIdReference(state.customWorldProfile, value),
|
|
)
|
|
.filter(Boolean);
|
|
|
|
return candidateIds.some((candidateId) => activeActNpcIds.includes(candidateId));
|
|
})
|
|
.filter((npc): npc is SceneNpc => Boolean(npc))
|
|
.filter((npc) => {
|
|
if (seenNpcIds.has(npc.id)) {
|
|
return false;
|
|
}
|
|
seenNpcIds.add(npc.id);
|
|
return true;
|
|
})
|
|
.slice(0, 3);
|
|
}
|
|
|
|
function getSceneActBattleSlots(primaryX: number) {
|
|
return [
|
|
{
|
|
xMeters: primaryX,
|
|
yOffset: 0,
|
|
},
|
|
{
|
|
xMeters: SCENE_ACT_BACK_ROW_BATTLE_X_METERS,
|
|
yOffset: SCENE_ACT_BACK_ROW_BATTLE_Y_OFFSETS[0],
|
|
},
|
|
{
|
|
xMeters: SCENE_ACT_BACK_ROW_BATTLE_X_METERS,
|
|
yOffset: SCENE_ACT_BACK_ROW_BATTLE_Y_OFFSETS[1],
|
|
},
|
|
] satisfies Array<Pick<SceneHostileNpc, 'xMeters' | 'yOffset'>>;
|
|
}
|
|
|
|
export function buildNpcBattleFormationFromEncounter(params: {
|
|
state: GameState;
|
|
encounter: Encounter;
|
|
mode?: 'fight' | 'spar';
|
|
}) {
|
|
const { state, encounter, mode = 'fight' } = params;
|
|
const sceneActMembers = resolveSceneActEncounterMembers(state, encounter);
|
|
const primaryX =
|
|
sceneActMembers.length > 1
|
|
? RESOLVED_ENTITY_X_METERS
|
|
: encounter.xMeters ?? RESOLVED_ENTITY_X_METERS;
|
|
const formationSourceEncounters =
|
|
sceneActMembers.length > 1
|
|
? sceneActMembers.map((member, index) =>
|
|
buildEncounterFromSceneNpc(
|
|
member,
|
|
index === 0 ? primaryX : SCENE_ACT_BACK_ROW_BATTLE_X_METERS,
|
|
),
|
|
)
|
|
: [encounter];
|
|
const slots = getSceneActBattleSlots(primaryX);
|
|
|
|
const resolvedFormation = formationSourceEncounters.map((memberEncounter, index) => {
|
|
const slot = slots[index] ?? slots[slots.length - 1] ?? {
|
|
xMeters: primaryX,
|
|
yOffset: 0,
|
|
};
|
|
const npcState = getResolvedNpcState(state, memberEncounter);
|
|
const battleMonster = createNpcBattleMonster(
|
|
memberEncounter,
|
|
npcState,
|
|
mode,
|
|
{
|
|
worldType: state.worldType,
|
|
customWorldProfile: state.customWorldProfile,
|
|
},
|
|
);
|
|
|
|
return {
|
|
...battleMonster,
|
|
xMeters: slot.xMeters,
|
|
yOffset: slot.yOffset,
|
|
facing: getFacingTowardPlayer(slot.xMeters, PLAYER_BASE_X_METERS),
|
|
encounter: battleMonster.encounter
|
|
? {
|
|
...battleMonster.encounter,
|
|
xMeters: slot.xMeters,
|
|
}
|
|
: battleMonster.encounter,
|
|
} satisfies SceneHostileNpc;
|
|
});
|
|
|
|
logNpcBattleFormation(
|
|
`buildNpcBattleFormationFromEncounter:${encounter.id ?? encounter.npcName}`,
|
|
resolvedFormation,
|
|
);
|
|
|
|
return resolvedFormation;
|
|
}
|
|
|
|
function buildResolvedNpcBattleState(state: GameState, encounter: Encounter) {
|
|
const battleNpcId = getNpcEncounterKey(encounter);
|
|
|
|
return {
|
|
...state,
|
|
// 中文注释：幕预览和正式运行都统一走这一套 NPC 战斗编队生成，
|
|
// 避免开战时把同幕后排角色压缩成单体，导致阵容缺失和站位突变。
|
|
sceneHostileNpcs: buildNpcBattleFormationFromEncounter({
|
|
state,
|
|
encounter,
|
|
mode: 'fight',
|
|
}),
|
|
currentEncounter: null,
|
|
npcInteractionActive: false,
|
|
playerX: 0,
|
|
playerFacing: 'right' as const,
|
|
animationState: AnimationState.IDLE,
|
|
playerActionMode: 'idle' as const,
|
|
activeCombatEffects: [],
|
|
scrollWorld: false,
|
|
inBattle: true,
|
|
currentBattleNpcId: battleNpcId,
|
|
currentNpcBattleMode: 'fight' as const,
|
|
currentNpcBattleOutcome: null,
|
|
// 中文注释：NPC 开战后要保留战前原始遭遇，供战斗收尾时恢复和平态站位。
|
|
// 这里复用现有 sparReturnEncounter 存槽，避免战后误把 battle encounter 的临时坐标带回场景。
|
|
sparReturnEncounter: encounter,
|
|
sparPlayerHpBefore: null,
|
|
sparPlayerMaxHpBefore: null,
|
|
sparStoryHistoryBefore: null,
|
|
};
|
|
}
|
|
|
|
function pickRandomItem<T>(items: T[]) {
|
|
if (items.length === 0) return null;
|
|
return items[Math.floor(Math.random() * items.length)] ?? null;
|
|
}
|
|
|
|
function createTreasureEncounter(state: GameState, treasureHint: string): Encounter {
|
|
return {
|
|
id: `treasure-${state.currentScenePreset?.id ?? 'unknown'}`,
|
|
kind: 'treasure',
|
|
npcName: '宝藏',
|
|
npcDescription: `你发现了与${treasureHint}相关的线索，看起来像是有人故意藏起的宝物。`,
|
|
npcAvatar: '/Icons/47_treasure.png',
|
|
context: 'treasure',
|
|
xMeters: PREVIEW_ENTITY_X_METERS,
|
|
};
|
|
}
|
|
|
|
function getAvailableFriendlySceneNpcs(state: GameState) {
|
|
const recruitedNpcIds = getRecruitedNpcIds(state);
|
|
const isCampScene = Boolean(
|
|
state.worldType
|
|
&& state.currentScenePreset?.id
|
|
&& getWorldCampScenePreset(state.worldType)?.id === state.currentScenePreset.id,
|
|
);
|
|
const activeActNpcIds = resolveActiveSceneActEncounterNpcIds({
|
|
profile: state.customWorldProfile,
|
|
sceneId: state.currentScenePreset?.id ?? null,
|
|
storyEngineMemory: state.storyEngineMemory,
|
|
});
|
|
const activeActNpcIdSet = new Set(activeActNpcIds);
|
|
|
|
return getSceneFriendlyNpcs(state.currentScenePreset)
|
|
.filter(candidate =>
|
|
!isCampScene ||
|
|
Boolean(candidate.characterId) ||
|
|
activeActNpcIdSet.has(candidate.id),
|
|
)
|
|
.filter(candidate => candidate.characterId !== state.playerCharacter?.id)
|
|
.filter(candidate => !recruitedNpcIds.has(candidate.id))
|
|
.filter(candidate =>
|
|
activeActNpcIdSet.size === 0
|
|
? true
|
|
: activeActNpcIdSet.has(candidate.id)
|
|
|| (candidate.characterId ? activeActNpcIdSet.has(candidate.characterId) : false),
|
|
);
|
|
}
|
|
|
|
function getAvailableActiveSceneActNpcs(state: GameState) {
|
|
const recruitedNpcIds = getRecruitedNpcIds(state);
|
|
const activeActNpcIds = resolveActiveSceneActEncounterNpcIds({
|
|
profile: state.customWorldProfile,
|
|
sceneId: state.currentScenePreset?.id ?? null,
|
|
storyEngineMemory: state.storyEngineMemory,
|
|
});
|
|
const activeActNpcIdSet = new Set(activeActNpcIds);
|
|
if (activeActNpcIdSet.size === 0) {
|
|
return [];
|
|
}
|
|
|
|
return (state.currentScenePreset?.npcs ?? [])
|
|
.filter(candidate => {
|
|
const candidateIds = [
|
|
candidate.id,
|
|
candidate.characterId,
|
|
candidate.name,
|
|
candidate.title,
|
|
]
|
|
.map((value) =>
|
|
resolveCustomWorldRoleIdReference(state.customWorldProfile, value),
|
|
)
|
|
.filter(Boolean);
|
|
return candidateIds.some(id => activeActNpcIdSet.has(id));
|
|
})
|
|
.filter(candidate => candidate.characterId !== state.playerCharacter?.id)
|
|
.filter(candidate => !recruitedNpcIds.has(candidate.id));
|
|
}
|
|
|
|
function getAvailableHostileSceneNpcs(state: GameState) {
|
|
const recruitedNpcIds = getRecruitedNpcIds(state);
|
|
|
|
return getSceneHostileNpcs(state.currentScenePreset)
|
|
.filter(candidate => !recruitedNpcIds.has(candidate.id))
|
|
.filter((candidate): candidate is SceneNpc & { monsterPresetId: string } => Boolean(candidate.monsterPresetId));
|
|
}
|
|
|
|
function pickEncounterHostileNpcs(hostileNpcs: Array<SceneNpc & { monsterPresetId: string }>) {
|
|
const selectedMonsterIds = new Set(
|
|
pickEncounterMonsterIds(hostileNpcs.map(npc => npc.monsterPresetId)),
|
|
);
|
|
|
|
return hostileNpcs.filter(npc => selectedMonsterIds.has(npc.monsterPresetId));
|
|
}
|
|
|
|
function pickFriendlySceneNpcForActiveAct(state: GameState, npcs: SceneNpc[]) {
|
|
const focusNpcId = resolveActiveSceneActEncounterFocusNpcId({
|
|
profile: state.customWorldProfile,
|
|
sceneId: state.currentScenePreset?.id ?? null,
|
|
storyEngineMemory: state.storyEngineMemory,
|
|
});
|
|
|
|
return (
|
|
npcs.find(
|
|
(npc) =>
|
|
resolveCustomWorldRoleIdReference(state.customWorldProfile, npc.id) === focusNpcId ||
|
|
resolveCustomWorldRoleIdReference(
|
|
state.customWorldProfile,
|
|
npc.characterId,
|
|
) === focusNpcId ||
|
|
resolveCustomWorldRoleIdReference(
|
|
state.customWorldProfile,
|
|
npc.name,
|
|
) === focusNpcId ||
|
|
resolveCustomWorldRoleIdReference(
|
|
state.customWorldProfile,
|
|
npc.title,
|
|
) === focusNpcId,
|
|
) ?? pickRandomItem(npcs)
|
|
);
|
|
}
|
|
|
|
function hasActiveSceneActEncounterTarget(state: GameState) {
|
|
return resolveActiveSceneActEncounterNpcIds({
|
|
profile: state.customWorldProfile,
|
|
sceneId: state.currentScenePreset?.id ?? null,
|
|
storyEngineMemory: state.storyEngineMemory,
|
|
}).length > 0;
|
|
}
|
|
|
|
function buildEmptyEncounterPreview() {
|
|
return {
|
|
sceneHostileNpcs: [],
|
|
currentEncounter: null,
|
|
npcInteractionActive: false,
|
|
inBattle: false,
|
|
};
|
|
}
|
|
|
|
function buildActiveSceneActNpcEncounter(
|
|
state: GameState,
|
|
availableNpcs: SceneNpc[],
|
|
xMeters: number,
|
|
) {
|
|
const npc = pickFriendlySceneNpcForActiveAct(state, availableNpcs);
|
|
|
|
return {
|
|
sceneHostileNpcs: [],
|
|
currentEncounter: npc ? buildFriendlyEncounter(npc, xMeters) : null,
|
|
npcInteractionActive: false,
|
|
inBattle: false,
|
|
};
|
|
}
|
|
|
|
function buildHostileEncounterGroup(
|
|
state: GameState,
|
|
entryX: number,
|
|
animation: 'idle' | 'move',
|
|
) {
|
|
if (!state.worldType || !state.currentScenePreset) return [];
|
|
|
|
const selectedHostiles = pickEncounterHostileNpcs(getAvailableHostileSceneNpcs(state));
|
|
const hostileEncounters = selectedHostiles.map(npc => buildEncounterFromSceneNpc(npc));
|
|
const hostileMonsters = createSceneHostileNpcsFromEncounters(
|
|
state.worldType,
|
|
hostileEncounters,
|
|
PLAYER_BASE_X_METERS,
|
|
);
|
|
const anchorX = getMonsterGroupAnchorX(hostileMonsters);
|
|
|
|
return hostileMonsters.map(monster => {
|
|
const xMeters = Number((entryX + (monster.xMeters - anchorX)).toFixed(2));
|
|
return {
|
|
...monster,
|
|
xMeters,
|
|
facing: getFacingTowardPlayer(xMeters, PLAYER_BASE_X_METERS),
|
|
animation,
|
|
encounter: monster.encounter
|
|
? {
|
|
...monster.encounter,
|
|
xMeters,
|
|
}
|
|
: monster.encounter,
|
|
};
|
|
});
|
|
}
|
|
|
|
function buildFriendlyEncounter(npc: SceneNpc, xMeters: number) {
|
|
return {
|
|
...buildEncounterFromSceneNpc(npc, xMeters),
|
|
xMeters,
|
|
} satisfies Encounter;
|
|
}
|
|
|
|
function buildResolvedHostileBattleState(state: GameState, hostileEncounters: Encounter[]) {
|
|
if (!state.worldType) return state;
|
|
|
|
const resolvedMonsters = createSceneHostileNpcsFromEncounters(
|
|
state.worldType,
|
|
hostileEncounters,
|
|
PLAYER_BASE_X_METERS,
|
|
).map(monster => ({
|
|
...monster,
|
|
animation: 'idle' as const,
|
|
facing: getFacingTowardPlayer(monster.xMeters, PLAYER_BASE_X_METERS),
|
|
encounter: monster.encounter
|
|
? {
|
|
...monster.encounter,
|
|
xMeters: monster.xMeters,
|
|
}
|
|
: monster.encounter,
|
|
}));
|
|
|
|
return {
|
|
...state,
|
|
sceneHostileNpcs: resolvedMonsters,
|
|
currentEncounter: null,
|
|
npcInteractionActive: false,
|
|
playerX: 0,
|
|
playerFacing: 'right' as const,
|
|
animationState: AnimationState.IDLE,
|
|
playerActionMode: 'idle' as const,
|
|
activeCombatEffects: [],
|
|
scrollWorld: false,
|
|
inBattle: true,
|
|
};
|
|
}
|
|
|
|
export function createSceneEncounterPreview(state: GameState) {
|
|
if (!state.worldType || !state.currentScenePreset) {
|
|
return buildEmptyEncounterPreview();
|
|
}
|
|
|
|
if (hasActiveSceneActEncounterTarget(state)) {
|
|
return buildActiveSceneActNpcEncounter(
|
|
state,
|
|
getAvailableActiveSceneActNpcs(state),
|
|
PREVIEW_ENTITY_X_METERS,
|
|
);
|
|
}
|
|
|
|
const availableNpcs = getAvailableFriendlySceneNpcs(state);
|
|
const availableHostiles = getAvailableHostileSceneNpcs(state);
|
|
const availableKinds: Array<'hostile' | 'npc' | 'treasure'> = [];
|
|
if (availableHostiles.length > 0) availableKinds.push('hostile');
|
|
if (availableNpcs.length > 0) availableKinds.push('npc');
|
|
if (TREASURE_ENCOUNTERS_ENABLED && (state.currentScenePreset.treasureHints?.length ?? 0) > 0) {
|
|
availableKinds.push('treasure');
|
|
}
|
|
|
|
const kind = pickRandomItem(availableKinds);
|
|
if (!kind) {
|
|
return buildEmptyEncounterPreview();
|
|
}
|
|
|
|
if (kind === 'hostile') {
|
|
return {
|
|
sceneHostileNpcs: buildHostileEncounterGroup(state, PREVIEW_ENTITY_X_METERS, 'idle'),
|
|
currentEncounter: null,
|
|
npcInteractionActive: false,
|
|
inBattle: false,
|
|
};
|
|
}
|
|
|
|
if (kind === 'npc') {
|
|
const npc = pickFriendlySceneNpcForActiveAct(state, availableNpcs);
|
|
|
|
return {
|
|
sceneHostileNpcs: [],
|
|
currentEncounter: npc ? buildFriendlyEncounter(npc, PREVIEW_ENTITY_X_METERS) : null,
|
|
npcInteractionActive: false,
|
|
inBattle: false,
|
|
};
|
|
}
|
|
|
|
const treasureHint = pickRandomItem(state.currentScenePreset.treasureHints ?? []);
|
|
return {
|
|
sceneHostileNpcs: [],
|
|
currentEncounter: treasureHint ? createTreasureEncounter(state, treasureHint) : null,
|
|
npcInteractionActive: false,
|
|
inBattle: false,
|
|
};
|
|
}
|
|
|
|
export function createSceneCallOutEncounter(state: GameState) {
|
|
if (!state.worldType || !state.currentScenePreset) {
|
|
return buildEmptyEncounterPreview();
|
|
}
|
|
|
|
if (hasActiveSceneActEncounterTarget(state)) {
|
|
return buildActiveSceneActNpcEncounter(
|
|
state,
|
|
getAvailableActiveSceneActNpcs(state),
|
|
CALL_OUT_ENTRY_X_METERS,
|
|
);
|
|
}
|
|
|
|
const availableNpcs = getAvailableFriendlySceneNpcs(state);
|
|
const availableKinds: Array<'hostile' | 'npc' | 'treasure'> = [];
|
|
const availableHostiles = getAvailableHostileSceneNpcs(state);
|
|
if (availableHostiles.length > 0) availableKinds.push('hostile');
|
|
|
|
if (availableNpcs.length > 0) availableKinds.push('npc');
|
|
if (TREASURE_ENCOUNTERS_ENABLED && (state.currentScenePreset.treasureHints?.length ?? 0) > 0) {
|
|
availableKinds.push('treasure');
|
|
}
|
|
|
|
const kind = pickRandomItem(availableKinds);
|
|
if (kind === 'hostile') {
|
|
return {
|
|
sceneHostileNpcs: buildHostileEncounterGroup(state, CALL_OUT_ENTRY_X_METERS, 'move'),
|
|
currentEncounter: null,
|
|
npcInteractionActive: false,
|
|
inBattle: false,
|
|
};
|
|
}
|
|
|
|
if (kind === 'npc') {
|
|
const npc = pickFriendlySceneNpcForActiveAct(state, availableNpcs);
|
|
return {
|
|
sceneHostileNpcs: [],
|
|
currentEncounter: npc ? buildFriendlyEncounter(npc, CALL_OUT_ENTRY_X_METERS) : null,
|
|
npcInteractionActive: false,
|
|
inBattle: false,
|
|
};
|
|
}
|
|
|
|
if (kind === 'treasure') {
|
|
const treasureHint = pickRandomItem(state.currentScenePreset.treasureHints ?? []);
|
|
return {
|
|
sceneHostileNpcs: [],
|
|
currentEncounter: treasureHint
|
|
? {
|
|
...createTreasureEncounter(state, treasureHint),
|
|
xMeters: CALL_OUT_ENTRY_X_METERS,
|
|
}
|
|
: null,
|
|
npcInteractionActive: false,
|
|
inBattle: false,
|
|
};
|
|
}
|
|
|
|
return {
|
|
sceneHostileNpcs: [],
|
|
currentEncounter: null,
|
|
npcInteractionActive: false,
|
|
inBattle: false,
|
|
};
|
|
}
|
|
|
|
export function ensureSceneEncounterPreview(state: GameState): GameState {
|
|
if (
|
|
state.inBattle ||
|
|
state.sceneHostileNpcs.length > 0 ||
|
|
state.currentEncounter ||
|
|
!state.currentScenePreset ||
|
|
!state.worldType
|
|
) {
|
|
return state;
|
|
}
|
|
|
|
return {
|
|
...state,
|
|
...createSceneEncounterPreview(state),
|
|
playerX: 0,
|
|
playerFacing: 'right' as const,
|
|
animationState: AnimationState.IDLE,
|
|
playerActionMode: 'idle' as const,
|
|
activeCombatEffects: [],
|
|
scrollWorld: false,
|
|
};
|
|
}
|
|
|
|
export function hasAutoBattleSceneEncounter(state: GameState) {
|
|
if (!state.currentScenePreset || !state.worldType || state.inBattle) {
|
|
return false;
|
|
}
|
|
|
|
if (state.sceneHostileNpcs.length > 0) {
|
|
return state.sceneHostileNpcs.some(monster => Boolean(monster.encounter?.monsterPresetId));
|
|
}
|
|
|
|
return state.currentEncounter?.kind === 'npc'
|
|
? shouldAutoStartBattleForEncounter(state, state.currentEncounter)
|
|
: false;
|
|
}
|
|
|
|
export function resolveSceneEncounterPreview(state: GameState): GameState {
|
|
if (!state.currentScenePreset || !state.worldType) {
|
|
return state;
|
|
}
|
|
|
|
const previewState =
|
|
state.sceneHostileNpcs.length > 0 || state.currentEncounter
|
|
? state
|
|
: ensureSceneEncounterPreview(state);
|
|
|
|
if (previewState.sceneHostileNpcs.length > 0) {
|
|
const hostileEncounters = previewState.sceneHostileNpcs
|
|
.map(monster => monster.encounter)
|
|
.filter((encounter): encounter is Encounter => Boolean(encounter?.monsterPresetId));
|
|
|
|
if (hostileEncounters.length > 0) {
|
|
return buildResolvedHostileBattleState(previewState, hostileEncounters);
|
|
}
|
|
|
|
const resolvedMonsters = createSceneHostileNpcsFromIds(
|
|
previewState.worldType ?? WorldType.WUXIA,
|
|
previewState.sceneHostileNpcs.map(monster => monster.id),
|
|
PLAYER_BASE_X_METERS,
|
|
).map(monster => ({
|
|
...monster,
|
|
animation: 'idle' as const,
|
|
facing: getFacingTowardPlayer(monster.xMeters, PLAYER_BASE_X_METERS),
|
|
}));
|
|
|
|
return {
|
|
...previewState,
|
|
sceneHostileNpcs: resolvedMonsters,
|
|
currentEncounter: null,
|
|
npcInteractionActive: false,
|
|
playerX: 0,
|
|
playerFacing: 'right' as const,
|
|
animationState: AnimationState.IDLE,
|
|
playerActionMode: 'idle' as const,
|
|
activeCombatEffects: [],
|
|
scrollWorld: false,
|
|
inBattle: true,
|
|
};
|
|
}
|
|
|
|
if (
|
|
previewState.currentEncounter?.kind === 'npc'
|
|
&& shouldAutoStartBattleForEncounter(previewState, previewState.currentEncounter)
|
|
) {
|
|
return buildResolvedNpcBattleState(previewState, previewState.currentEncounter);
|
|
}
|
|
|
|
if (previewState.currentEncounter) {
|
|
return {
|
|
...previewState,
|
|
currentEncounter: {
|
|
...previewState.currentEncounter,
|
|
xMeters: RESOLVED_ENTITY_X_METERS,
|
|
},
|
|
npcInteractionActive: false,
|
|
sceneHostileNpcs: [],
|
|
playerX: 0,
|
|
playerFacing: 'right' as const,
|
|
animationState: AnimationState.IDLE,
|
|
playerActionMode: 'idle' as const,
|
|
activeCombatEffects: [],
|
|
scrollWorld: false,
|
|
inBattle: false,
|
|
};
|
|
}
|
|
|
|
return previewState;
|
|
}
|
|
|
|
export function getPreviewEntityX(state: GameState) {
|
|
return state.sceneHostileNpcs.length > 0
|
|
? getMonsterGroupAnchorX(state.sceneHostileNpcs)
|
|
: state.currentEncounter?.xMeters ?? PREVIEW_ENTITY_X_METERS;
|
|
}
|