BlueGit

timfa questward

Files

questward / shared / lighting / raycast.js

raycast.js

magics
timfa Tim Falken · pushed by timfa · 2 months ago
8b1a158b History
raycast.js 3.7 KiB Download Raw
1/** Shared lighting raycast and falloff — used by server bake and client dynamic lights. */
2
3import { LightOcclusion } from "../definitions/tiles.js";
4
5export function bresenhamTiles (x0, y0, x1, y1)
6{
7 const tiles = [];
8 let x = x0;
9 let y = y0;
10 const dx = Math.abs(x1 - x0);
11 const dy = Math.abs(y1 - y0);
12 const sx = x0 < x1 ? 1 : -1;
13 const sy = y0 < y1 ? 1 : -1;
14 let err = dx - dy;
15
16 while (true)
17 {
18 tiles.push({ x, y });
19 if (x === x1 && y === y1)
20 { break; }
21
22 const e2 = 2 * err;
23 if (e2 > -dy)
24 {
25 err -= dy;
26 x += sx;
27 }
28 if (e2 < dx)
29 {
30 err += dx;
31 y += sy;
32 }
33 }
34 return tiles;
35}
36
37/**
38 * Binary LOS for combat / legacy callers (`true` = clear).
39 * Destination may be blocked and still "reached" (facing surface).
40 */
41export function rayReaches (fromX, fromY, toX, toY, isClear)
42{
43 const ray = evaluateLightRay(fromX, fromY, toX, toY, (x, y) =>
44 (isClear(x, y) ? LightOcclusion.clear : LightOcclusion.solid));
45 return ray.reaches;
46}
47
48/**
49 * Light transmission along a Bresenham ray.
50 * @param {(x: number, y: number) => number} occlusionAt
51 * {@link LightOcclusion.clear|partial|solid}
52 * @returns {{ reaches: boolean, extraDistance: number }}
53 * `extraDistance` is added to geometric hypot for falloff (partial tiles
54 * cost +1 each, i.e. that step falls off twice as fast).
55 */
56export function evaluateLightRay (fromX, fromY, toX, toY, occlusionAt)
57{
58 if (fromX === toX && fromY === toY)
59 {
60 return {
61 reaches: occlusionAt(toX, toY) !== LightOcclusion.solid,
62 extraDistance: 0
63 };
64 }
65
66 const tiles = bresenhamTiles(fromX, fromY, toX, toY);
67 let extraDistance = 0;
68 // Only tiles strictly between source and target can occlude / add penalty.
69 for (let i = 1; i < tiles.length - 1; i++)
70 {
71 const level = occlusionAt(tiles[i].x, tiles[i].y) | 0;
72 if (level >= LightOcclusion.solid)
73 { return { reaches: false, extraDistance: 0 }; }
74 if (level === LightOcclusion.partial)
75 { extraDistance += 1; }
76 }
77 return { reaches: true, extraDistance };
78}
79
80export function falloffAtDistance (dist, range)
81{
82 if (range <= 0 || dist > range)
83 { return 0; }
84
85 const t = 1 - dist / range;
86 return t * t * (3 - 2 * t);
87}
88
89export function encodeLight (dist, range)
90{
91 const falloff = falloffAtDistance(dist, range);
92 if (falloff <= 0)
93 { return 0; }
94
95 return Math.max(1, Math.round(255 * falloff));
96}
97
98export function lightIntensity (encoded)
99{
100 return Math.min(1, Math.max(0, (encoded ?? 0) / 255));
101}
102
103/**
104 * Best dynamic light at a tile (0–1).
105 * @param {Array<{ tileX: number, tileY: number, range: number, intensity?: number }>} sources
106 * @param {(x: number, y: number) => number|boolean} occlusionAt
107 * LightOcclusion level, or legacy boolean (`true` = clear).
108 */
109export function dynamicLightAtTile (tileX, tileY, sources, occlusionAt)
110{
111 const occlude = normalizeOcclusionFn(occlusionAt);
112 let best = 0;
113 for (const source of sources)
114 {
115 const geo = Math.hypot(tileX - source.tileX, tileY - source.tileY);
116 const ray = evaluateLightRay(source.tileX, source.tileY, tileX, tileY, occlude);
117 if (!ray.reaches)
118 { continue; }
119 const dist = geo + ray.extraDistance;
120 if (dist > source.range)
121 { continue; }
122 best = Math.max(best, falloffAtDistance(dist, source.range) * (source.intensity ?? 1));
123 }
124 return best;
125}
126
127/** Best dynamic darkness contribution at a tile (0–1), same falloff as light. */
128export function dynamicDarknessAtTile (tileX, tileY, sources, occlusionAt)
129{
130 return dynamicLightAtTile(tileX, tileY, sources, occlusionAt);
131}
132
133function normalizeOcclusionFn (occlusionAt)
134{
135 return (x, y) =>
136 {
137 const value = occlusionAt(x, y);
138 if (value === true)
139 { return LightOcclusion.clear; }
140 if (value === false)
141 { return LightOcclusion.solid; }
142 return value | 0;
143 };
144}