BlueGit

timfa questward

Files

questward / shared / quests / conditions.js

conditions.js

conditions.js 6.8 KiB Download Raw
1/** Shared condition kinds + ConditionSet evaluation (server provides snapshot). */
2
3import { OVERWORLD_ID, normalizeDimensionId } from "../world/dimensions.js";
4
5export const ConditionKind = Object.freeze({
6 hasItem: "hasItem",
7 atTile: "atTile",
8 nearTile: "nearTile",
9 inRect: "inRect",
10 atChunk: "atChunk",
11 inDimension: "inDimension",
12 hasVisitedDimension: "hasVisitedDimension",
13 questState: "questState",
14 questStepAtLeast: "questStepAtLeast",
15 dialogueHeard: "dialogueHeard",
16 dialogueTrigger: "dialogueTrigger",
17 hpAtLeast: "hpAtLeast",
18 staminaAtLeast: "staminaAtLeast",
19 hpPercentAtLeast: "hpPercentAtLeast",
20 staminaPercentAtLeast: "staminaPercentAtLeast",
21 skillLevelAtLeast: "skillLevelAtLeast",
22 killCount: "killCount",
23 interactBlock: "interactBlock"
24});
25
26export function emptyConditionSet ()
27{
28 return { all: [] };
29}
30
31export function normalizeConditionSet (raw)
32{
33 const all = [];
34 const list = Array.isArray(raw?.all) ? raw.all : (Array.isArray(raw) ? raw : []);
35 for (const entry of list)
36 {
37 const clause = normalizeConditionClause(entry);
38 if (clause)
39 { all.push(clause); }
40 }
41 return { all };
42}
43
44function normalizeConditionClause (entry)
45{
46 if (!entry || typeof entry !== "object")
47 { return null; }
48 const condition = entry.condition && typeof entry.condition === "object"
49 ? entry.condition
50 : entry;
51 const kind = String(condition.kind ?? "").trim();
52 if (!kind)
53 { return null; }
54 return {
55 not: !!entry.not,
56 condition: normalizeConditionFields({ ...condition, kind })
57 };
58}
59
60/** Ensure place conditions carry dimensionId (default overworld). */
61function normalizeConditionFields (condition)
62{
63 const kind = condition.kind;
64 if (
65 kind === ConditionKind.atTile
66 || kind === ConditionKind.nearTile
67 || kind === ConditionKind.inRect
68 || kind === ConditionKind.atChunk
69 || kind === ConditionKind.interactBlock
70 || kind === ConditionKind.inDimension
71 || kind === ConditionKind.hasVisitedDimension
72 )
73 {
74 return {
75 ...condition,
76 dimensionId: normalizeDimensionId(condition.dimensionId ?? OVERWORLD_ID)
77 };
78 }
79 return condition;
80}
81
82/**
83 * @param {ReturnType<typeof normalizeConditionSet>} set
84 * @param {object} ctx — snapshot from server (see evaluateCondition)
85 */
86export function evaluateConditionSet (set, ctx)
87{
88 const clauses = set?.all ?? [];
89 if (clauses.length === 0)
90 { return true; }
91 for (const clause of clauses)
92 {
93 const raw = evaluateCondition(clause.condition, ctx);
94 const ok = clause.not ? !raw : raw;
95 if (!ok)
96 { return false; }
97 }
98 return true;
99}
100
101function sameDimension (condition, ctx)
102{
103 const want = normalizeDimensionId(condition.dimensionId ?? OVERWORLD_ID);
104 const have = normalizeDimensionId(ctx.dimensionId ?? OVERWORLD_ID);
105 return want === have;
106}
107
108export function evaluateCondition (condition, ctx)
109{
110 if (!condition || typeof condition !== "object")
111 { return false; }
112 const kind = condition.kind;
113 switch (kind)
114 {
115 case ConditionKind.hasItem:
116 return (ctx.countItem?.(condition.itemId) ?? 0) >= Math.max(1, Number(condition.quantity) || 1);
117 case ConditionKind.atTile:
118 return sameDimension(condition, ctx)
119 && ctx.tileX === (Number(condition.tileX) | 0)
120 && ctx.tileY === (Number(condition.tileY) | 0);
121 case ConditionKind.nearTile:
122 {
123 if (!sameDimension(condition, ctx))
124 { return false; }
125 const range = Math.max(1, Number(condition.range) || 1);
126 const dx = Math.abs(ctx.tileX - (Number(condition.tileX) | 0));
127 const dy = Math.abs(ctx.tileY - (Number(condition.tileY) | 0));
128 return Math.max(dx, dy) <= range;
129 }
130 case ConditionKind.inRect:
131 {
132 if (!sameDimension(condition, ctx))
133 { return false; }
134 const minX = Math.min(Number(condition.minTileX) | 0, Number(condition.maxTileX) | 0);
135 const maxX = Math.max(Number(condition.minTileX) | 0, Number(condition.maxTileX) | 0);
136 const minY = Math.min(Number(condition.minTileY) | 0, Number(condition.maxTileY) | 0);
137 const maxY = Math.max(Number(condition.minTileY) | 0, Number(condition.maxTileY) | 0);
138 return ctx.tileX >= minX && ctx.tileX <= maxX && ctx.tileY >= minY && ctx.tileY <= maxY;
139 }
140 case ConditionKind.atChunk:
141 return sameDimension(condition, ctx)
142 && ctx.chunkX === (Number(condition.chunkX) | 0)
143 && ctx.chunkY === (Number(condition.chunkY) | 0);
144 case ConditionKind.inDimension:
145 return normalizeDimensionId(ctx.dimensionId ?? OVERWORLD_ID)
146 === normalizeDimensionId(condition.dimensionId ?? OVERWORLD_ID);
147 case ConditionKind.hasVisitedDimension:
148 return !!ctx.hasVisitedDimension?.(
149 normalizeDimensionId(condition.dimensionId ?? OVERWORLD_ID)
150 );
151 case ConditionKind.questState:
152 return questStatesEqual(ctx.questState?.(condition.questId), condition.state);
153 case ConditionKind.questStepAtLeast:
154 {
155 const state = ctx.questState?.(condition.questId);
156 const step = Math.max(1, Number(condition.step) || 1);
157 if (state === "completed")
158 { return true; }
159 if (typeof state === "number")
160 { return state >= step; }
161 return false;
162 }
163 case ConditionKind.dialogueHeard:
164 return !!ctx.dialogueHeard?.(condition.dialogueId, condition.stepId);
165 case ConditionKind.dialogueTrigger:
166 return !!ctx.dialogueTriggerLatched?.(condition.dialogueId, condition.trigger);
167 case ConditionKind.hpAtLeast:
168 return (ctx.hp ?? 0) >= Math.max(0, Number(condition.amount) || 0);
169 case ConditionKind.staminaAtLeast:
170 return (ctx.stamina ?? 0) >= Math.max(0, Number(condition.amount) || 0);
171 case ConditionKind.hpPercentAtLeast:
172 {
173 const max = Math.max(1, ctx.maxHp ?? 1);
174 const pct = ((ctx.hp ?? 0) / max) * 100;
175 return pct >= Math.min(100, Math.max(0, Number(condition.percent) || 0));
176 }
177 case ConditionKind.staminaPercentAtLeast:
178 {
179 const max = Math.max(1, ctx.maxStamina ?? 1);
180 const pct = ((ctx.stamina ?? 0) / max) * 100;
181 return pct >= Math.min(100, Math.max(0, Number(condition.percent) || 0));
182 }
183 case ConditionKind.skillLevelAtLeast:
184 return (ctx.skillLevel?.(condition.skillId) ?? 1) >= Math.max(1, Math.min(99, Number(condition.level) || 1));
185 case ConditionKind.killCount:
186 return (ctx.killCount?.(condition) ?? 0) >= Math.max(1, Number(condition.count) || 1);
187 case ConditionKind.interactBlock:
188 return sameDimension(condition, ctx) && !!ctx.interactBlockDone?.(condition);
189 default:
190 return false;
191 }
192}
193
194function questStatesEqual (actual, expected)
195{
196 if (expected === "not-started" || expected === "completed")
197 { return actual === expected || (expected === "not-started" && (actual == null || actual === "not-started")); }
198 const n = Number(expected);
199 return Number.isFinite(n) && actual === (n | 0);
200}
201
202export const EffectKind = Object.freeze({
203 giveItem: "giveItem",
204 giveXp: "giveXp",
205 takeItem: "takeItem",
206 startQuest: "startQuest"
207});
208
209export function normalizeEffects (raw)
210{
211 if (!Array.isArray(raw))
212 { return []; }
213 const out = [];
214 for (const entry of raw)
215 {
216 if (!entry || typeof entry !== "object")
217 { continue; }
218 const kind = String(entry.kind ?? "").trim();
219 if (!Object.values(EffectKind).includes(kind))
220 { continue; }
221 out.push({ ...entry, kind });
222 }
223 return out;
224}