BlueGit

timfa questward

Files

questward / shared / quests / conditions.js

conditions.js

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