import { Component } from "../ecs/components.js"; import { tileKey } from "../world/coordinates.js"; import { OVERWORLD_ID, normalizeDimensionId } from "../../../shared/world/dimensions.js"; import { LIGHT_FADE_MS, LIGHT_MAX_DURATION_MS, LIGHT_OWNER_DISTANCE_CAP_MS, SPELL_DARK_INTENSITY, SPELL_LIGHT_INTENSITY, SPELL_LIGHT_RANGE_TILES, COMBAT_RANGE_TILES } from "../../../shared/spells/constants.js"; /** * Authoritative temporary spell lights / darkness keyed by tile + dimension. * @typedef {object} SpellLight * @property {number} tileX * @property {number} tileY * @property {string} dimensionId * @property {number} ownerEntityId * @property {number} expiresAt * @property {number} maxDurationMs * @property {number} baseRange * @property {number} baseIntensity * @property {"light"|"dark"} kind */ export class SpellLightRegistry { constructor() { /** @type {Map} */ this.byTile = new Map(); this.nextLightId = 1; } getAt (tileX, tileY, dimensionId = OVERWORLD_ID) { const dim = normalizeDimensionId(dimensionId); return this.byTile.get(tileKey(tileX, tileY, dim)) ?? null; } /** @returns {{ light: SpellLight, extended: boolean }} */ placeOrExtend ({ tileX, tileY, ownerEntityId, durationMs, baseRange = SPELL_LIGHT_RANGE_TILES, baseIntensity = SPELL_LIGHT_INTENSITY, kind = "light", dimensionId = OVERWORLD_ID, now = Date.now() }) { const dim = normalizeDimensionId(dimensionId); const key = tileKey(tileX, tileY, dim); const addMs = Math.max(0, Math.min(LIGHT_MAX_DURATION_MS, durationMs | 0)); const range = Math.max(0, Number(baseRange) || SPELL_LIGHT_RANGE_TILES); const intensity = Math.max(0, Number(baseIntensity) || (kind === "dark" ? SPELL_DARK_INTENSITY : SPELL_LIGHT_INTENSITY)); const existing = this.byTile.get(key); if (existing && existing.kind === kind) { const remaining = Math.max(0, existing.expiresAt - now); const next = Math.min(LIGHT_MAX_DURATION_MS, remaining + addMs); existing.expiresAt = now + next; existing.maxDurationMs = Math.max(existing.maxDurationMs, next); existing.ownerEntityId = ownerEntityId; existing.baseRange = Math.max(existing.baseRange ?? 0, range); existing.baseIntensity = Math.max(existing.baseIntensity ?? 0, intensity); return { light: existing, extended: true }; } const light = { lightId: this.nextLightId++, tileX, tileY, dimensionId: dim, ownerEntityId, expiresAt: now + addMs, maxDurationMs: addMs, baseRange: range, baseIntensity: intensity, kind: kind === "dark" ? "dark" : "light" }; this.byTile.set(key, light); return { light, extended: false }; } removeAt (tileX, tileY, dimensionId = OVERWORLD_ID) { const dim = normalizeDimensionId(dimensionId); const key = tileKey(tileX, tileY, dim); const existing = this.byTile.get(key); if (!existing) { return null; } this.byTile.delete(key); return existing; } /** Tick ownership distance penalty and expiry. Returns replication events. */ tick (world, now = Date.now()) { const events = []; for (const [, light] of [...this.byTile.entries()]) { const dim = normalizeDimensionId(light.dimensionId ?? OVERWORLD_ID); if (now >= light.expiresAt) { this.byTile.delete(tileKey(light.tileX, light.tileY, dim)); events.push({ type: light.kind === "dark" ? "spell-dark-remove" : "spell-light-remove", tileX: light.tileX, tileY: light.tileY, dimensionId: dim }); continue; } const ownerHandle = world.ecs.handleOf(light.ownerEntityId); const ownerPos = ownerHandle != null ? world.ecs.get(ownerHandle, Component.position) : null; if (ownerPos) { const ownerDim = normalizeDimensionId(ownerPos.dimensionId ?? OVERWORLD_ID); if (ownerDim !== dim) { continue; } const dist = Math.max( Math.abs(ownerPos.tileX - light.tileX), Math.abs(ownerPos.tileY - light.tileY) ); if (dist > COMBAT_RANGE_TILES) { const remaining = light.expiresAt - now; const capped = Math.min(remaining, LIGHT_OWNER_DISTANCE_CAP_MS); if (capped !== remaining) { light.expiresAt = now + capped; const eventType = light.kind === "dark" ? "spell-dark-update" : "spell-light-update"; events.push({ type: eventType, ...publicSpellLight(light, now) }); } } } } return events; } listInBounds (minX, minY, maxX, maxY, now = Date.now(), dimensionId = null) { const dimFilter = dimensionId != null ? normalizeDimensionId(dimensionId) : null; const out = []; for (const light of this.byTile.values()) { if (dimFilter != null && normalizeDimensionId(light.dimensionId ?? OVERWORLD_ID) !== dimFilter) { continue; } if (light.tileX < minX || light.tileX > maxX || light.tileY < minY || light.tileY > maxY) { continue; } if (now >= light.expiresAt) { continue; } out.push(publicSpellLight(light, now)); } return out; } } export function publicSpellLight (light, now = Date.now()) { const remainingMs = Math.max(0, light.expiresAt - now); const fadeT = remainingMs <= LIGHT_FADE_MS ? remainingMs / LIGHT_FADE_MS : 1; const range = light.baseRange * fadeT; const intensity = light.baseIntensity * fadeT; return { tileX: light.tileX, tileY: light.tileY, dimensionId: normalizeDimensionId(light.dimensionId ?? OVERWORLD_ID), ownerEntityId: light.ownerEntityId, remainingMs, rangeTiles: range, intensity, expiresAt: light.expiresAt, kind: light.kind === "dark" ? "dark" : "light" }; } export function spellLightsForDynamicLighting (registry, now = Date.now(), dimensionId = null) { const lights = []; const darks = []; if (!registry) { return { lights, darks }; } const dimFilter = dimensionId != null ? normalizeDimensionId(dimensionId) : null; for (const light of registry.byTile.values()) { if (dimFilter != null && normalizeDimensionId(light.dimensionId ?? OVERWORLD_ID) !== dimFilter) { continue; } if (now >= light.expiresAt) { continue; } const pub = publicSpellLight(light, now); if (pub.intensity <= 0 || pub.rangeTiles <= 0) { continue; } const entry = { tileX: light.tileX, tileY: light.tileY, range: pub.rangeTiles, intensity: pub.intensity }; if (light.kind === "dark") { darks.push(entry); } else { lights.push(entry); } } return { lights, darks }; }