BlueGit

timfa questward

Files

questward / shared / quests / conditions.js

conditions.js

conditions.js 9.5 KiB Download Raw
1/** Shared condition kinds + ConditionSet evaluation (server provides snapshot). */
2
3import { OVERWORLD_ID, normalizeDimensionId } from "../world/dimensions.js";
4import { isMetaSkillId } from "../definitions/skills.js";
5
6export const ConditionKind = Object.freeze({
7 hasItem: "hasItem",
8 atTile: "atTile",
9 nearTile: "nearTile",
10 inRect: "inRect",
11 atChunk: "atChunk",
12 inDimension: "inDimension",
13 hasVisitedDimension: "hasVisitedDimension",
14 questState: "questState",
15 questStepAtLeast: "questStepAtLeast",
16 dialogueHeard: "dialogueHeard",
17 dialogueTrigger: "dialogueTrigger",
18 hpAtLeast: "hpAtLeast",
19 staminaAtLeast: "staminaAtLeast",
20 hpPercentAtLeast: "hpPercentAtLeast",
21 staminaPercentAtLeast: "staminaPercentAtLeast",
22 skillLevelAtLeast: "skillLevelAtLeast",
23 killCount: "killCount",
24 killMobFromSpawner: "killMobFromSpawner",
25 interactBlock: "interactBlock"
26});
27
28/** Required threshold for skillLevelAtLeast (meta levels may exceed 99). */
29export function skillRequirementThreshold (condition)
30{
31 const level = Math.max(1, Number(condition?.level) || 1) | 0;
32 if (isMetaSkillId(condition?.skillId))
33 { return Math.min(99_999, level); }
34 return Math.min(99, level);
35}
36
37/**
38 * How clauses in a ConditionSet combine.
39 * - allOf: every clause must pass (legacy default)
40 * - oneOrMoreOf: at least one clause must pass
41 * - onlyOneOf: exactly one clause must pass
42 * - noneOf: fail if any clause passes (inverted one-or-more)
43 */
44export const ConditionSetMode = Object.freeze({
45 allOf: "allOf",
46 oneOrMoreOf: "oneOrMoreOf",
47 onlyOneOf: "onlyOneOf",
48 noneOf: "noneOf"
49});
50
51export const CONDITION_SET_MODE_LABELS = Object.freeze({
52 [ConditionSetMode.allOf]: "All of",
53 [ConditionSetMode.oneOrMoreOf]: "One or more of",
54 [ConditionSetMode.onlyOneOf]: "Only one of",
55 [ConditionSetMode.noneOf]: "None of"
56});
57
58export function normalizeConditionSetMode (raw)
59{
60 const mode = String(raw ?? "").trim();
61 if (Object.values(ConditionSetMode).includes(mode))
62 { return mode; }
63 return ConditionSetMode.allOf;
64}
65
66export function emptyConditionSet ()
67{
68 return { mode: ConditionSetMode.allOf, all: [] };
69}
70
71export function normalizeConditionSet (raw)
72{
73 const all = [];
74 const list = Array.isArray(raw?.all) ? raw.all : (Array.isArray(raw) ? raw : []);
75 for (const entry of list)
76 {
77 const clause = normalizeConditionClause(entry);
78 if (clause)
79 { all.push(clause); }
80 }
81 return {
82 mode: normalizeConditionSetMode(raw?.mode),
83 all
84 };
85}
86
87function normalizeConditionClause (entry)
88{
89 if (!entry || typeof entry !== "object")
90 { return null; }
91 const condition = entry.condition && typeof entry.condition === "object"
92 ? entry.condition
93 : entry;
94 const kind = String(condition.kind ?? "").trim();
95 if (!kind)
96 { return null; }
97 return {
98 not: !!entry.not,
99 condition: normalizeConditionFields({ ...condition, kind })
100 };
101}
102
103/** Ensure place conditions carry dimensionId (default overworld). */
104function normalizeConditionFields (condition)
105{
106 const kind = condition.kind;
107 if (
108 kind === ConditionKind.atTile
109 || kind === ConditionKind.nearTile
110 || kind === ConditionKind.inRect
111 || kind === ConditionKind.atChunk
112 || kind === ConditionKind.interactBlock
113 || kind === ConditionKind.inDimension
114 || kind === ConditionKind.hasVisitedDimension
115 )
116 {
117 return {
118 ...condition,
119 dimensionId: normalizeDimensionId(condition.dimensionId ?? OVERWORLD_ID)
120 };
121 }
122 return condition;
123}
124
125/**
126 * @param {ReturnType<typeof normalizeConditionSet>} set
127 * @param {object} ctx — snapshot from server (see evaluateCondition)
128 */
129export function evaluateConditionSet (set, ctx)
130{
131 const clauses = set?.all ?? [];
132 if (clauses.length === 0)
133 { return true; }
134 let passCount = 0;
135 for (const clause of clauses)
136 {
137 const raw = evaluateCondition(clause.condition, ctx);
138 const ok = clause.not ? !raw : raw;
139 if (ok)
140 { passCount += 1; }
141 }
142 const mode = normalizeConditionSetMode(set?.mode);
143 switch (mode)
144 {
145 case ConditionSetMode.oneOrMoreOf:
146 return passCount >= 1;
147 case ConditionSetMode.onlyOneOf:
148 return passCount === 1;
149 case ConditionSetMode.noneOf:
150 return passCount === 0;
151 case ConditionSetMode.allOf:
152 default:
153 return passCount === clauses.length;
154 }
155}
156
157function sameDimension (condition, ctx)
158{
159 const want = normalizeDimensionId(condition.dimensionId ?? OVERWORLD_ID);
160 const have = normalizeDimensionId(ctx.dimensionId ?? OVERWORLD_ID);
161 return want === have;
162}
163
164export function evaluateCondition (condition, ctx)
165{
166 if (!condition || typeof condition !== "object")
167 { return false; }
168 const kind = condition.kind;
169 switch (kind)
170 {
171 case ConditionKind.hasItem:
172 return (ctx.countItem?.(condition.itemId) ?? 0) >= Math.max(1, Number(condition.quantity) || 1);
173 case ConditionKind.atTile:
174 return sameDimension(condition, ctx)
175 && ctx.tileX === (Number(condition.tileX) | 0)
176 && ctx.tileY === (Number(condition.tileY) | 0);
177 case ConditionKind.nearTile:
178 {
179 if (!sameDimension(condition, ctx))
180 { return false; }
181 const range = Math.max(1, Number(condition.range) || 1);
182 const dx = Math.abs(ctx.tileX - (Number(condition.tileX) | 0));
183 const dy = Math.abs(ctx.tileY - (Number(condition.tileY) | 0));
184 return Math.max(dx, dy) <= range;
185 }
186 case ConditionKind.inRect:
187 {
188 if (!sameDimension(condition, ctx))
189 { return false; }
190 const minX = Math.min(Number(condition.minTileX) | 0, Number(condition.maxTileX) | 0);
191 const maxX = Math.max(Number(condition.minTileX) | 0, Number(condition.maxTileX) | 0);
192 const minY = Math.min(Number(condition.minTileY) | 0, Number(condition.maxTileY) | 0);
193 const maxY = Math.max(Number(condition.minTileY) | 0, Number(condition.maxTileY) | 0);
194 return ctx.tileX >= minX && ctx.tileX <= maxX && ctx.tileY >= minY && ctx.tileY <= maxY;
195 }
196 case ConditionKind.atChunk:
197 return sameDimension(condition, ctx)
198 && ctx.chunkX === (Number(condition.chunkX) | 0)
199 && ctx.chunkY === (Number(condition.chunkY) | 0);
200 case ConditionKind.inDimension:
201 return normalizeDimensionId(ctx.dimensionId ?? OVERWORLD_ID)
202 === normalizeDimensionId(condition.dimensionId ?? OVERWORLD_ID);
203 case ConditionKind.hasVisitedDimension:
204 return !!ctx.hasVisitedDimension?.(
205 normalizeDimensionId(condition.dimensionId ?? OVERWORLD_ID)
206 );
207 case ConditionKind.questState:
208 return questStatesEqual(ctx.questState?.(condition.questId), condition.state);
209 case ConditionKind.questStepAtLeast:
210 {
211 const state = ctx.questState?.(condition.questId);
212 const step = Math.max(1, Number(condition.step) || 1);
213 if (state === "completed")
214 { return true; }
215 if (typeof state === "number")
216 { return state >= step; }
217 return false;
218 }
219 case ConditionKind.dialogueHeard:
220 return !!ctx.dialogueHeard?.(condition.dialogueId, condition.stepId);
221 case ConditionKind.dialogueTrigger:
222 return !!ctx.dialogueTriggerLatched?.(condition.dialogueId, condition.trigger);
223 case ConditionKind.hpAtLeast:
224 return (ctx.hp ?? 0) >= Math.max(0, Number(condition.amount) || 0);
225 case ConditionKind.staminaAtLeast:
226 return (ctx.stamina ?? 0) >= Math.max(0, Number(condition.amount) || 0);
227 case ConditionKind.hpPercentAtLeast:
228 {
229 const max = Math.max(1, ctx.maxHp ?? 1);
230 const pct = ((ctx.hp ?? 0) / max) * 100;
231 return pct >= Math.min(100, Math.max(0, Number(condition.percent) || 0));
232 }
233 case ConditionKind.staminaPercentAtLeast:
234 {
235 const max = Math.max(1, ctx.maxStamina ?? 1);
236 const pct = ((ctx.stamina ?? 0) / max) * 100;
237 return pct >= Math.min(100, Math.max(0, Number(condition.percent) || 0));
238 }
239 case ConditionKind.skillLevelAtLeast:
240 return (ctx.skillLevel?.(condition.skillId) ?? 1) >= skillRequirementThreshold(condition);
241 case ConditionKind.killCount:
242 case ConditionKind.killMobFromSpawner:
243 return (ctx.killCount?.(condition) ?? 0) >= Math.max(1, Number(condition.count) || 1);
244 case ConditionKind.interactBlock:
245 return sameDimension(condition, ctx) && !!ctx.interactBlockDone?.(condition);
246 default:
247 return false;
248 }
249}
250
251function questStatesEqual (actual, expected)
252{
253 if (expected === "not-started" || expected === "completed")
254 { return actual === expected || (expected === "not-started" && (actual == null || actual === "not-started")); }
255 const n = Number(expected);
256 return Number.isFinite(n) && actual === (n | 0);
257}
258
259export const EffectKind = Object.freeze({
260 giveItem: "giveItem",
261 giveXp: "giveXp",
262 takeItem: "takeItem",
263 startQuest: "startQuest"
264});
265
266export function normalizeEffects (raw)
267{
268 if (!Array.isArray(raw))
269 { return []; }
270 const out = [];
271 for (const entry of raw)
272 {
273 if (!entry || typeof entry !== "object")
274 { continue; }
275 const kind = String(entry.kind ?? "").trim();
276 if (!Object.values(EffectKind).includes(kind))
277 { continue; }
278 if (kind === EffectKind.giveItem)
279 {
280 const itemId = Number(entry.itemId);
281 if (!Number.isFinite(itemId) || itemId <= 0)
282 { continue; }
283 out.push({
284 kind,
285 itemId: itemId | 0,
286 quantity: Math.max(1, Math.min(99_999, Number(entry.quantity) || 1)) | 0,
287 toBank: !!entry.toBank
288 });
289 continue;
290 }
291 if (kind === EffectKind.giveXp)
292 {
293 const skillId = String(entry.skillId ?? "").trim();
294 const amount = Math.max(0, Math.min(10_000_000, Number(entry.amount) || 0)) | 0;
295 if (!skillId || amount <= 0)
296 { continue; }
297 out.push({ kind, skillId, amount });
298 continue;
299 }
300 if (kind === EffectKind.takeItem)
301 {
302 const itemId = Number(entry.itemId);
303 if (!Number.isFinite(itemId) || itemId <= 0)
304 { continue; }
305 out.push({
306 kind,
307 itemId: itemId | 0,
308 quantity: Math.max(1, Math.min(99_999, Number(entry.quantity) || 1)) | 0
309 });
310 continue;
311 }
312 if (kind === EffectKind.startQuest)
313 {
314 const questId = String(entry.questId ?? "").trim().slice(0, 80);
315 if (!questId)
316 { continue; }
317 out.push({ kind, questId });
318 }
319 }
320 return out;
321}