/** Shared lighting raycast and falloff — used by server bake and client dynamic lights. */ import { LightOcclusion } from "../definitions/tiles.js"; export function bresenhamTiles (x0, y0, x1, y1) { const tiles = []; let x = x0; let y = y0; const dx = Math.abs(x1 - x0); const dy = Math.abs(y1 - y0); const sx = x0 < x1 ? 1 : -1; const sy = y0 < y1 ? 1 : -1; let err = dx - dy; while (true) { tiles.push({ x, y }); if (x === x1 && y === y1) { break; } const e2 = 2 * err; if (e2 > -dy) { err -= dy; x += sx; } if (e2 < dx) { err += dx; y += sy; } } return tiles; } /** * Binary LOS for combat / legacy callers (`true` = clear). * Destination may be blocked and still "reached" (facing surface). */ export function rayReaches (fromX, fromY, toX, toY, isClear) { const ray = evaluateLightRay(fromX, fromY, toX, toY, (x, y) => (isClear(x, y) ? LightOcclusion.clear : LightOcclusion.solid)); return ray.reaches; } /** * Light transmission along a Bresenham ray. * Walks the line without allocating a tile array (hot path for dynamic lights). * @param {(x: number, y: number) => number} occlusionAt * {@link LightOcclusion.clear|partial|solid} * @returns {{ reaches: boolean, extraDistance: number }} * `extraDistance` is added to geometric hypot for falloff (partial tiles * cost +1 each, i.e. that step falls off twice as fast). */ export function evaluateLightRay (fromX, fromY, toX, toY, occlusionAt) { if (fromX === toX && fromY === toY) { return { reaches: occlusionAt(toX, toY) !== LightOcclusion.solid, extraDistance: 0 }; } let x = fromX; let y = fromY; const dx = Math.abs(toX - fromX); const dy = Math.abs(toY - fromY); const sx = fromX < toX ? 1 : -1; const sy = fromY < toY ? 1 : -1; let err = dx - dy; let extraDistance = 0; // Only tiles strictly between source and target can occlude / add penalty. while (x !== toX || y !== toY) { const e2 = 2 * err; if (e2 > -dy) { err -= dy; x += sx; } if (e2 < dx) { err += dx; y += sy; } if (x === toX && y === toY) { break; } const level = occlusionAt(x, y) | 0; if (level >= LightOcclusion.solid) { return { reaches: false, extraDistance: 0 }; } if (level === LightOcclusion.partial) { extraDistance += 1; } } return { reaches: true, extraDistance }; } export function falloffAtDistance (dist, range) { if (range <= 0 || dist > range) { return 0; } const t = 1 - dist / range; return t * t * (3 - 2 * t); } export function encodeLight (dist, range) { const falloff = falloffAtDistance(dist, range); if (falloff <= 0) { return 0; } return Math.max(1, Math.round(255 * falloff)); } export function lightIntensity (encoded) { return Math.min(1, Math.max(0, (encoded ?? 0) / 255)); } /** * Best dynamic light at a tile (0–1). * @param {Array<{ tileX: number, tileY: number, range: number, intensity?: number }>} sources * @param {(x: number, y: number) => number|boolean} occlusionAt * LightOcclusion level, or legacy boolean (`true` = clear). */ export function dynamicLightAtTile (tileX, tileY, sources, occlusionAt) { if (!sources?.length) { return 0; } const occlude = normalizeOcclusionFn(occlusionAt); let best = 0; for (const source of sources) { const range = source.range; if (!(range > 0)) { continue; } const geo = Math.hypot(tileX - source.tileX, tileY - source.tileY); // Partial occlusion only *increases* distance — never shortens it. if (geo > range) { continue; } const ray = evaluateLightRay(source.tileX, source.tileY, tileX, tileY, occlude); if (!ray.reaches) { continue; } const dist = geo + ray.extraDistance; if (dist > range) { continue; } best = Math.max(best, falloffAtDistance(dist, range) * (source.intensity ?? 1)); } return best; } /** Best dynamic darkness contribution at a tile (0–1), same falloff as light. */ export function dynamicDarknessAtTile (tileX, tileY, sources, occlusionAt) { return dynamicLightAtTile(tileX, tileY, sources, occlusionAt); } function normalizeOcclusionFn (occlusionAt) { return (x, y) => { const value = occlusionAt(x, y); if (value === true) { return LightOcclusion.clear; } if (value === false) { return LightOcclusion.solid; } return value | 0; }; }