/** Shared condition kinds + ConditionSet evaluation (server provides snapshot). */ import { OVERWORLD_ID, normalizeDimensionId } from "../world/dimensions.js"; import { isMetaSkillId } from "../definitions/skills.js"; import { legacyQuestStepNumber } from "./questProgress.js"; export const ConditionKind = Object.freeze({ hasItem: "hasItem", atTile: "atTile", nearTile: "nearTile", inRect: "inRect", atChunk: "atChunk", inDimension: "inDimension", hasVisitedDimension: "hasVisitedDimension", questState: "questState", /** @deprecated Read on load and converted. Prefer hasCompletedStep. */ questStepAtLeast: "questStepAtLeast", hasCompletedStep: "hasCompletedStep", dialogueHeard: "dialogueHeard", dialogueTrigger: "dialogueTrigger", hpAtLeast: "hpAtLeast", staminaAtLeast: "staminaAtLeast", hpPercentAtLeast: "hpPercentAtLeast", staminaPercentAtLeast: "staminaPercentAtLeast", skillLevelAtLeast: "skillLevelAtLeast", killCount: "killCount", killMobFromSpawner: "killMobFromSpawner", interactBlock: "interactBlock" }); /** Required threshold for skillLevelAtLeast (meta levels may exceed 99). */ export function skillRequirementThreshold (condition) { const level = Math.max(1, Number(condition?.level) || 1) | 0; if (isMetaSkillId(condition?.skillId)) { return Math.min(99_999, level); } return Math.min(99, level); } /** * How clauses in a ConditionSet combine. * - allOf: every clause must pass (legacy default) * - oneOrMoreOf: at least one clause must pass * - onlyOneOf: exactly one clause must pass * - noneOf: fail if any clause passes (inverted one-or-more) */ export const ConditionSetMode = Object.freeze({ allOf: "allOf", oneOrMoreOf: "oneOrMoreOf", onlyOneOf: "onlyOneOf", noneOf: "noneOf" }); export const CONDITION_SET_MODE_LABELS = Object.freeze({ [ConditionSetMode.allOf]: "All of", [ConditionSetMode.oneOrMoreOf]: "One or more of", [ConditionSetMode.onlyOneOf]: "Only one of", [ConditionSetMode.noneOf]: "None of" }); export function normalizeConditionSetMode (raw) { const mode = String(raw ?? "").trim(); if (Object.values(ConditionSetMode).includes(mode)) { return mode; } return ConditionSetMode.allOf; } export function emptyConditionSet () { return { mode: ConditionSetMode.allOf, all: [] }; } /** * @param {object | Array | null | undefined} raw * @param {{ quests?: Function | Array | Map } | Function | null} [options] * Quest catalog so legacy questStepAtLeast / numeric questState can convert on load. */ export function normalizeConditionSet (raw, options = null) { const lookup = questLookupFromOptions(options); const all = []; const list = Array.isArray(raw?.all) ? raw.all : (Array.isArray(raw) ? raw : []); for (const entry of list) { const clause = normalizeConditionClause(entry, lookup); if (clause) { all.push(clause); } } return { mode: normalizeConditionSetMode(raw?.mode), all }; } function questLookupFromOptions (options) { const quests = typeof options === "function" ? options : options?.quests; if (typeof quests === "function") { return quests; } if (!quests) { return null; } const map = new Map(); const list = quests instanceof Map ? [...quests.values()] : quests; for (const quest of list ?? []) { const questId = String(quest?.questId ?? "").trim(); if (questId) { map.set(questId, quest); } } return (questId) => map.get(String(questId ?? "")) ?? null; } function normalizeConditionClause (entry, lookup) { if (!entry || typeof entry !== "object") { return null; } const condition = entry.condition && typeof entry.condition === "object" ? entry.condition : entry; const kind = String(condition.kind ?? "").trim(); if (!kind) { return null; } return { not: !!entry.not, condition: convertLegacyQuestCondition( normalizeConditionFields({ ...condition, kind }), lookup ) }; } /** * questStepAtLeast step 1 → quest started. * questStepAtLeast step N (N > 1) → hasCompletedStep of step N-1. * Past the end of a known quest → quest completed (the only way the old check passed). * Numeric questState → that step's id, when the quest def is available. * Unknown quests keep questStepAtLeast so a later load can still convert. */ export function convertLegacyQuestCondition (condition, lookup) { if (!condition || typeof condition !== "object") { return condition; } if (condition.kind === ConditionKind.questState) { const index = legacyQuestStepNumber(condition.state); if (index == null || !lookup) { return condition; } const step = lookup(condition.questId)?.steps?.[index - 1]; if (!step?.stepId) { return condition; } return { ...condition, state: step.stepId }; } if (condition.kind !== ConditionKind.questStepAtLeast) { return condition; } const stepNum = Math.max(1, Number(condition.step) || 1); const questId = String(condition.questId ?? "").trim().slice(0, 80); if (stepNum <= 1) { return { kind: ConditionKind.questState, questId, state: "started" }; } const def = lookup?.(questId) ?? null; const steps = def?.steps ?? null; if (!steps) { return { kind: ConditionKind.questStepAtLeast, questId, step: stepNum }; } const prev = steps[stepNum - 2]; if (prev?.stepId) { return { kind: ConditionKind.hasCompletedStep, questId, stepId: String(prev.stepId) }; } return { kind: ConditionKind.questState, questId, state: "completed" }; } /** Ensure place conditions carry dimensionId (default overworld). */ function normalizeConditionFields (condition) { const kind = condition.kind; if ( kind === ConditionKind.atTile || kind === ConditionKind.nearTile || kind === ConditionKind.inRect || kind === ConditionKind.atChunk || kind === ConditionKind.interactBlock || kind === ConditionKind.inDimension || kind === ConditionKind.hasVisitedDimension ) { return { ...condition, dimensionId: normalizeDimensionId(condition.dimensionId ?? OVERWORLD_ID) }; } if (kind === ConditionKind.hasCompletedStep) { return { kind, questId: String(condition.questId ?? "").trim().slice(0, 80), stepId: String(condition.stepId ?? "").trim().slice(0, 64) }; } if (kind === ConditionKind.questState) { return { ...condition, kind, questId: String(condition.questId ?? "").trim().slice(0, 80) }; } return condition; } /** * @param {ReturnType} set * @param {object} ctx — snapshot from server (see evaluateCondition) */ export function evaluateConditionSet (set, ctx) { const clauses = set?.all ?? []; if (clauses.length === 0) { return true; } let passCount = 0; for (const clause of clauses) { const raw = evaluateCondition(clause.condition, ctx); const ok = clause.not ? !raw : raw; if (ok) { passCount += 1; } } const mode = normalizeConditionSetMode(set?.mode); switch (mode) { case ConditionSetMode.oneOrMoreOf: return passCount >= 1; case ConditionSetMode.onlyOneOf: return passCount === 1; case ConditionSetMode.noneOf: return passCount === 0; case ConditionSetMode.allOf: default: return passCount === clauses.length; } } function sameDimension (condition, ctx) { const want = normalizeDimensionId(condition.dimensionId ?? OVERWORLD_ID); const have = normalizeDimensionId(ctx.dimensionId ?? OVERWORLD_ID); return want === have; } export function evaluateCondition (condition, ctx) { if (!condition || typeof condition !== "object") { return false; } const kind = condition.kind; switch (kind) { case ConditionKind.hasItem: return (ctx.countItem?.(condition.itemId) ?? 0) >= Math.max(1, Number(condition.quantity) || 1); case ConditionKind.atTile: return sameDimension(condition, ctx) && ctx.tileX === (Number(condition.tileX) | 0) && ctx.tileY === (Number(condition.tileY) | 0); case ConditionKind.nearTile: { if (!sameDimension(condition, ctx)) { return false; } const range = Math.max(1, Number(condition.range) || 1); const dx = Math.abs(ctx.tileX - (Number(condition.tileX) | 0)); const dy = Math.abs(ctx.tileY - (Number(condition.tileY) | 0)); return Math.max(dx, dy) <= range; } case ConditionKind.inRect: { if (!sameDimension(condition, ctx)) { return false; } const minX = Math.min(Number(condition.minTileX) | 0, Number(condition.maxTileX) | 0); const maxX = Math.max(Number(condition.minTileX) | 0, Number(condition.maxTileX) | 0); const minY = Math.min(Number(condition.minTileY) | 0, Number(condition.maxTileY) | 0); const maxY = Math.max(Number(condition.minTileY) | 0, Number(condition.maxTileY) | 0); return ctx.tileX >= minX && ctx.tileX <= maxX && ctx.tileY >= minY && ctx.tileY <= maxY; } case ConditionKind.atChunk: return sameDimension(condition, ctx) && ctx.chunkX === (Number(condition.chunkX) | 0) && ctx.chunkY === (Number(condition.chunkY) | 0); case ConditionKind.inDimension: return normalizeDimensionId(ctx.dimensionId ?? OVERWORLD_ID) === normalizeDimensionId(condition.dimensionId ?? OVERWORLD_ID); case ConditionKind.hasVisitedDimension: return !!ctx.hasVisitedDimension?.( normalizeDimensionId(condition.dimensionId ?? OVERWORLD_ID) ); case ConditionKind.questState: return questStatesEqual( ctx.questState?.(condition.questId), condition.state, condition.questId, ctx ); case ConditionKind.hasCompletedStep: return !!ctx.hasCompletedStep?.(condition.questId, condition.stepId); case ConditionKind.questStepAtLeast: return evaluateLegacyQuestStepAtLeast(condition, ctx); case ConditionKind.dialogueHeard: return !!ctx.dialogueHeard?.(condition.dialogueId, condition.stepId); case ConditionKind.dialogueTrigger: return !!ctx.dialogueTriggerLatched?.(condition.dialogueId, condition.trigger); case ConditionKind.hpAtLeast: return (ctx.hp ?? 0) >= Math.max(0, Number(condition.amount) || 0); case ConditionKind.staminaAtLeast: return (ctx.stamina ?? 0) >= Math.max(0, Number(condition.amount) || 0); case ConditionKind.hpPercentAtLeast: { const max = Math.max(1, ctx.maxHp ?? 1); const pct = ((ctx.hp ?? 0) / max) * 100; return pct >= Math.min(100, Math.max(0, Number(condition.percent) || 0)); } case ConditionKind.staminaPercentAtLeast: { const max = Math.max(1, ctx.maxStamina ?? 1); const pct = ((ctx.stamina ?? 0) / max) * 100; return pct >= Math.min(100, Math.max(0, Number(condition.percent) || 0)); } case ConditionKind.skillLevelAtLeast: return (ctx.skillLevel?.(condition.skillId) ?? 1) >= skillRequirementThreshold(condition); case ConditionKind.killCount: case ConditionKind.killMobFromSpawner: return (ctx.killCount?.(condition) ?? 0) >= Math.max(1, Number(condition.count) || 1); case ConditionKind.interactBlock: return sameDimension(condition, ctx) && !!ctx.interactBlockDone?.(condition); default: return false; } } function questStatesEqual (actual, expected, questId, ctx) { const want = resolveExpectedQuestState(expected, questId, ctx); if (want === "started") { return actual != null && actual !== "not-started"; } if (want === "not-started") { return actual == null || actual === "not-started"; } if (want === "completed") { return actual === "completed"; } return String(actual ?? "") === String(want ?? ""); } /** Numeric questState ("on step N") maps through the quest's step list when known. */ function resolveExpectedQuestState (expected, questId, ctx) { if (expected === "not-started" || expected === "completed" || expected === "started") { return expected; } const index = legacyQuestStepNumber(expected); if (index != null) { const steps = ctx?.questSteps?.(questId); if (Array.isArray(steps) && steps[index - 1]) { return steps[index - 1]; } } return expected; } /** * Unconverted questStepAtLeast, same rule as convertLegacyQuestCondition: * step 1 = started, step N = has completed step N-1, past the end = quest completed. */ function evaluateLegacyQuestStepAtLeast (condition, ctx) { const stepNum = Math.max(1, Number(condition?.step) || 1); const questId = condition?.questId; const actual = ctx.questState?.(questId); if (stepNum <= 1) { return actual != null && actual !== "not-started"; } const steps = ctx.questSteps?.(questId); if (!Array.isArray(steps)) { return false; } const prev = steps[stepNum - 2]; if (!prev) { return actual === "completed"; } return !!ctx.hasCompletedStep?.(questId, prev); } export const EffectKind = Object.freeze({ giveItem: "giveItem", giveXp: "giveXp", takeItem: "takeItem", startQuest: "startQuest" }); export function normalizeEffects (raw) { if (!Array.isArray(raw)) { return []; } const out = []; for (const entry of raw) { if (!entry || typeof entry !== "object") { continue; } const kind = String(entry.kind ?? "").trim(); if (!Object.values(EffectKind).includes(kind)) { continue; } if (kind === EffectKind.giveItem) { const itemId = Number(entry.itemId); if (!Number.isFinite(itemId) || itemId <= 0) { continue; } out.push({ kind, itemId: itemId | 0, quantity: Math.max(1, Math.min(99_999, Number(entry.quantity) || 1)) | 0, toBank: !!entry.toBank }); continue; } if (kind === EffectKind.giveXp) { const skillId = String(entry.skillId ?? "").trim(); const amount = Math.max(0, Math.min(10_000_000, Number(entry.amount) || 0)) | 0; if (!skillId || amount <= 0) { continue; } out.push({ kind, skillId, amount }); continue; } if (kind === EffectKind.takeItem) { const itemId = Number(entry.itemId); if (!Number.isFinite(itemId) || itemId <= 0) { continue; } out.push({ kind, itemId: itemId | 0, quantity: Math.max(1, Math.min(99_999, Number(entry.quantity) || 1)) | 0 }); continue; } if (kind === EffectKind.startQuest) { const questId = String(entry.questId ?? "").trim().slice(0, 80); if (!questId) { continue; } out.push({ kind, questId }); } } return out; }