BlueGit

timfa questward

Files

questward / shared / quests / conditions.js

conditions.js

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