BlueGit

timfa questward

Files

questward / server / src / doors / conditionContext.js

conditionContext.js

feat: branch quest steps and remember which steps were finished
timfa project_85689633_bot_760517ee9267c86ff1d6c3a0237abf7d · pushed by timfa · 4 weeks ago
25915c58 History
conditionContext.js 6.2 KiB Download Raw
1/**
2 * Build evaluateConditionSet context from ECS entity + conditionAccess snapshot.
3 * Used on simulation workers (no stateDb).
4 */
5import { Component } from "../ecs/components.js";
6import { countItemInSlots } from "../../../shared/items/inventory.js";
7import { resolveSkillRequirementLevel } from "../../../shared/combat/combatLevel.js";
8import { CHUNK_SIZE } from "../../../shared/protocol/constants.js";
9import { OVERWORLD_ID, normalizeDimensionId } from "../../../shared/world/dimensions.js";
10import { doorHasRequirements, doorRequirementsMet } from "../../../shared/world/doorRequirements.js";
11import {
12 deriveCompletedStepIds,
13 resolveQuestStepId
14} from "../../../shared/quests/questProgress.js";
15import { BlockType } from "../../../shared/definitions/tiles.js";
16import { tileToChunk, tileToLocal, tileKey } from "../world/coordinates.js";
17
18function killProgressKey (condition)
19{
20 if (condition?.spawnerId)
21 { return `spawner:${condition.spawnerId}`; }
22 return `mob:${condition.mobTypeId}`;
23}
24
25function interactProgressKey (condition)
26{
27 if (condition?.tileX != null)
28 { return `tile:${condition.tileX},${condition.tileY}`; }
29 return `block:${condition.blockTypeId}`;
30}
31
32function 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 */
43export 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 */
84export 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
156function 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 */
169export 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
185export { tileKey };