| 1 | /** |
| 2 | * Build evaluateConditionSet context from ECS entity + conditionAccess snapshot. |
| 3 | * Used on simulation workers (no stateDb). |
| 4 | */ |
| 5 | import { Component } from "../ecs/components.js"; |
| 6 | import { countItemInSlots } from "../../../shared/items/inventory.js"; |
| 7 | import { resolveSkillRequirementLevel } from "../../../shared/combat/combatLevel.js"; |
| 8 | import { CHUNK_SIZE } from "../../../shared/protocol/constants.js"; |
| 9 | import { OVERWORLD_ID, normalizeDimensionId } from "../../../shared/world/dimensions.js"; |
| 10 | import { doorHasRequirements, doorRequirementsMet } from "../../../shared/world/doorRequirements.js"; |
| 11 | import { |
| 12 | deriveCompletedStepIds, |
| 13 | resolveQuestStepId |
| 14 | } from "../../../shared/quests/questProgress.js"; |
| 15 | import { BlockType } from "../../../shared/definitions/tiles.js"; |
| 16 | import { tileToChunk, tileToLocal, tileKey } from "../world/coordinates.js"; |
| 17 | |
| 18 | function killProgressKey (condition) |
| 19 | { |
| 20 | if (condition?.spawnerId) |
| 21 | { return `spawner:${condition.spawnerId}`; } |
| 22 | return `mob:${condition.mobTypeId}`; |
| 23 | } |
| 24 | |
| 25 | function interactProgressKey (condition) |
| 26 | { |
| 27 | if (condition?.tileX != null) |
| 28 | { return `tile:${condition.tileX},${condition.tileY}`; } |
| 29 | return `block:${condition.blockTypeId}`; |
| 30 | } |
| 31 | |
| 32 | function floorDiv (value, size) |
| 33 | { |
| 34 | return Math.floor(value / size); |
| 35 | } |
| 36 | |
| 37 | /** |
| 38 | * Serializable snapshot stored on Component.conditionAccess. |
| 39 | * @param {import("../persistence/stateDb.js").StateDb} stateDb |
| 40 | * @param {number} characterId |
| 41 | * @param {{ quest?: Function, allQuests?: Function } | null} [questContent] |
| 42 | */ |
| 43 | export function buildConditionAccessSnapshot (stateDb, characterId, questContent = null) |
| 44 | { |
| 45 | const questStates = Object.create(null); |
| 46 | const questProgress = Object.create(null); |
| 47 | const questSteps = Object.create(null); |
| 48 | for (const def of questContent?.allQuests?.() ?? []) |
| 49 | { |
| 50 | questSteps[def.questId] = (def.steps ?? []).map((step) => step.stepId); |
| 51 | } |
| 52 | for (const row of stateDb.listQuestStates(characterId)) |
| 53 | { |
| 54 | const def = questContent?.quest?.(row.questId) ?? null; |
| 55 | questStates[row.questId] = resolveQuestStepId(def, row.state); |
| 56 | questProgress[row.questId] = { |
| 57 | ...(row.progress ?? {}), |
| 58 | completedStepIds: deriveCompletedStepIds(def, row.state, row.progress) |
| 59 | }; |
| 60 | } |
| 61 | const dialogueHeard = (stateDb.listDialogueHeard(characterId) ?? []).map( |
| 62 | (row) => `${row.dialogue_id}\0${row.step_id}` |
| 63 | ); |
| 64 | const dialogueTriggers = (stateDb.listDialogueTriggers?.(characterId) ?? []).map( |
| 65 | (row) => `${row.dialogue_id}\0${row.trigger_id}` |
| 66 | ); |
| 67 | const visitedDimensions = (stateDb.listVisitedDimensions(characterId) ?? []).map( |
| 68 | (row) => normalizeDimensionId(row.dimensionId) |
| 69 | ); |
| 70 | return { |
| 71 | questStates, |
| 72 | questProgress, |
| 73 | questSteps, |
| 74 | dialogueHeard, |
| 75 | dialogueTriggers, |
| 76 | visitedDimensions |
| 77 | }; |
| 78 | } |
| 79 | |
| 80 | /** |
| 81 | * @param {object} world — WorkerWorld-like (ecs + chunkData) |
| 82 | * @param {number} entityId |
| 83 | */ |
| 84 | export function buildEntityConditionContext (world, entityId) |
| 85 | { |
| 86 | const handle = world.ecs.handleOf(entityId); |
| 87 | if (handle == null) |
| 88 | { return null; } |
| 89 | const position = world.ecs.get(handle, Component.position); |
| 90 | if (!position) |
| 91 | { return null; } |
| 92 | const tileX = position.tileX | 0; |
| 93 | const tileY = position.tileY | 0; |
| 94 | const dimensionId = normalizeDimensionId(position.dimensionId ?? OVERWORLD_ID); |
| 95 | const inventory = world.ecs.get(handle, Component.inventory)?.slots ?? []; |
| 96 | const health = world.ecs.get(handle, Component.health); |
| 97 | const stamina = world.ecs.get(handle, Component.stamina); |
| 98 | const skills = world.ecs.get(handle, Component.skills); |
| 99 | const access = world.ecs.get(handle, Component.conditionAccess) ?? { |
| 100 | questStates: {}, |
| 101 | questProgress: {}, |
| 102 | questSteps: {}, |
| 103 | dialogueHeard: [], |
| 104 | dialogueTriggers: [], |
| 105 | visitedDimensions: [] |
| 106 | }; |
| 107 | const heard = new Set(access.dialogueHeard ?? []); |
| 108 | const triggers = new Set(access.dialogueTriggers ?? []); |
| 109 | const visited = new Set(access.visitedDimensions ?? []); |
| 110 | const questStates = access.questStates ?? {}; |
| 111 | const questProgress = access.questProgress ?? {}; |
| 112 | const questSteps = access.questSteps ?? {}; |
| 113 | return { |
| 114 | tileX, |
| 115 | tileY, |
| 116 | chunkX: floorDiv(tileX, CHUNK_SIZE), |
| 117 | chunkY: floorDiv(tileY, CHUNK_SIZE), |
| 118 | dimensionId, |
| 119 | hp: health?.current ?? 0, |
| 120 | maxHp: health?.max ?? 1, |
| 121 | stamina: stamina?.current ?? 0, |
| 122 | maxStamina: stamina?.max ?? 1, |
| 123 | countItem: (itemId) => countItemInSlots(inventory, itemId | 0), |
| 124 | questState: (questId) => questStates[String(questId)] ?? "not-started", |
| 125 | questSteps: (questId) => questSteps[String(questId)] ?? null, |
| 126 | hasCompletedStep: (questId, stepId) => |
| 127 | { |
| 128 | const ids = questProgress[String(questId)]?.completedStepIds ?? []; |
| 129 | return ids.includes(String(stepId ?? "")); |
| 130 | }, |
| 131 | dialogueHeard: (dialogueId, stepId) => heard.has(`${dialogueId}\0${stepId}`), |
| 132 | dialogueTriggerLatched: (dialogueId, trigger) => triggers.has(`${dialogueId}\0${trigger}`), |
| 133 | skillLevel: (skillId) => resolveSkillRequirementLevel(skills ?? {}, skillId), |
| 134 | hasVisitedDimension: (dimId) => visited.has(normalizeDimensionId(dimId)), |
| 135 | killCount: (condition) => |
| 136 | { |
| 137 | const key = killProgressKey(condition); |
| 138 | let total = 0; |
| 139 | for (const progress of Object.values(questProgress)) |
| 140 | { total += progress?.counters?.[key] | 0; } |
| 141 | return total; |
| 142 | }, |
| 143 | interactBlockDone: (condition) => |
| 144 | { |
| 145 | const key = interactProgressKey(condition); |
| 146 | for (const progress of Object.values(questProgress)) |
| 147 | { |
| 148 | if (progress?.interacts?.[key]) |
| 149 | { return true; } |
| 150 | } |
| 151 | return false; |
| 152 | } |
| 153 | }; |
| 154 | } |
| 155 | |
| 156 | function readDoorBlock (world, tileX, tileY, dimensionId) |
| 157 | { |
| 158 | const data = world.chunkData?.(tileToChunk(tileX), tileToChunk(tileY), dimensionId); |
| 159 | if (!data) |
| 160 | { return null; } |
| 161 | const index = tileToLocal(tileY) * CHUNK_SIZE + tileToLocal(tileX); |
| 162 | return data.blocks?.[index] ?? null; |
| 163 | } |
| 164 | |
| 165 | /** |
| 166 | * Players must meet door requirements; mobs ignore gates. |
| 167 | * Empty requirements always allow. |
| 168 | */ |
| 169 | export function entityDoorRequirementsAllow (world, entityId, tileX, tileY) |
| 170 | { |
| 171 | const handle = world.ecs.handleOf(entityId); |
| 172 | if (handle == null) |
| 173 | { return true; } |
| 174 | const position = world.ecs.get(handle, Component.position); |
| 175 | const dimensionId = normalizeDimensionId(position?.dimensionId ?? OVERWORLD_ID); |
| 176 | const block = readDoorBlock(world, tileX, tileY, dimensionId); |
| 177 | if (!block || (block.typeId | 0) !== BlockType.door || !doorHasRequirements(block)) |
| 178 | { return true; } |
| 179 | if (!world.ecs.get(handle, Component.character)) |
| 180 | { return true; } |
| 181 | const ctx = buildEntityConditionContext(world, entityId); |
| 182 | return doorRequirementsMet(block, ctx); |
| 183 | } |
| 184 | |
| 185 | export { tileKey }; |