BlueGit

timfa raytracer

Files

raytracer / build / game.js

game.js

game.js 57.0 KiB Download Raw
1
2/*
3 * Start File:
4 * /workspace/raytracer-work/src/textureColumn.js
5 */
6/**
7 * Texture-column helpers for Wolfenstein-style wall strips.
8 * Each screen column samples exactly one source pixel column.
9 */
10function textureColumnIndex (tileX, texWidth)
11{
12 if (!(texWidth > 0))
13 { return 0; }
14
15 var sx = Math.floor(Number(tileX) * texWidth);
16 if (sx < 0)
17 { sx = 0; }
18 if (sx > texWidth - 1)
19 { sx = texWidth - 1; }
20 return sx;
21}
22
23function textureColumnUv (tileX, texWidth)
24{
25 var sx = textureColumnIndex(tileX, texWidth);
26 var w = texWidth > 0 ? texWidth : 1;
27 return {
28 sx: sx,
29 sw: 1,
30 u0: sx / w,
31 u1: (sx + 1) / w,
32 v0: 0,
33 v1: 1
34 };
35}
36
37/** Face U from hit position within a cell (no +1 bias). */
38function faceTileX (hitCoord, cellSize, face)
39{
40 var local = hitCoord % cellSize;
41 if (local < 0)
42 { local += cellSize; }
43 var t = local / cellSize;
44 switch (face)
45 {
46 case "north": return t;
47 case "south": return 1 - t;
48 case "east": return 1 - t;
49 case "west": return t;
50 default: return t;
51 }
52}
53
54if (typeof module !== "undefined" && module.exports)
55{
56 module.exports = {
57 textureColumnIndex: textureColumnIndex,
58 textureColumnUv: textureColumnUv,
59 faceTileX: faceTileX
60 };
61}
62
63/*
64 * End File:
65 * /workspace/raytracer-work/src/textureColumn.js
66 */
67
68/*
69 * Start File:
70 * /workspace/raytracer-work/src/ppda/depthDecode.js
71 */
72/**
73 * Depth encodings matching Paperdoll Renderer camera::DepthFormat.
74 * Canonical compositor sample is u16 gray + u16 alpha (0..65535).
75 */
76var DepthDecode =
77{
78 EPSILON_U16: 1,
79
80 parseFormat: function (encoding, bits)
81 {
82 var enc = encoding || "gray";
83 var b = bits == null ? 16 : Number(bits);
84 if (b !== 8 && b !== 16)
85 { throw new Error("depth_bits moet 8 of 16 zijn, kreeg " + bits); }
86 if (enc !== "gray" && enc !== "rgb_bands" && enc !== "rgb_packed")
87 { throw new Error("depth_encoding onbekend: " + enc); }
88 return { encoding: enc, bits: b };
89 },
90
91 max: function (fmt)
92 { return (1 << fmt.bits) - 1; },
93
94 levels: function (fmt)
95 {
96 var m = this.max(fmt);
97 if (fmt.encoding === "gray")
98 { return m; }
99 if (fmt.encoding === "rgb_bands")
100 { return 3 * m; }
101 return Math.pow(2, 3 * fmt.bits) - 1;
102 },
103
104 decodeValue: function (fmt, c0, c1, c2)
105 {
106 var m = this.max(fmt);
107 var b = m + 1;
108 var v;
109 if (fmt.encoding === "gray")
110 { v = c0; }
111 else if (fmt.encoding === "rgb_bands")
112 { v = c0 + c1 + c2; }
113 else
114 { v = c0 * b * b + c1 * b + c2; }
115 return v / this.levels(fmt);
116 },
117
118 encodeValue: function (fmt, t)
119 {
120 t = Math.max(0, Math.min(1, Number(t) || 0));
121 var m = this.max(fmt);
122 var v = Math.round(t * this.levels(fmt));
123 if (fmt.encoding === "gray")
124 { return [v, 0, 0]; }
125 if (fmt.encoding === "rgb_bands")
126 {
127 return [
128 Math.min(v, m),
129 Math.min(Math.max(v - m, 0), m),
130 Math.min(Math.max(v - 2 * m, 0), m)
131 ];
132 }
133 var b = m + 1;
134 return [Math.floor(v / (b * b)), Math.floor(v / b) % b, v % b];
135 },
136
137 /**
138 * Decode one pixel channel tuple to canonical u16 (gray, alpha).
139 * channels: [c0,c1,c2,a] in native bit depth units.
140 */
141 decodePixelChannels: function (fmt, channels)
142 {
143 var c0 = channels[0] || 0;
144 var c1 = channels[1] || 0;
145 var c2 = channels[2] || 0;
146 var a = channels[3] != null ? channels[3] : this.max(fmt);
147 if (fmt.encoding === "rgb_bands")
148 {
149 var m = this.max(fmt);
150 if ((c1 > 0 && c0 !== m) || (c2 > 0 && c1 !== m))
151 { throw new Error("depth rgb_bands: ongeldige bandvolgorde"); }
152 }
153 var t = this.decodeValue(fmt, c0, c1, c2);
154 var scale = 65535 / this.max(fmt);
155 return {
156 gray: Math.round(t * 65535),
157 alpha: Math.round(a * scale)
158 };
159 },
160
161 /** Meters from camera using near/far and normalized t (0..1 from gray/65535). */
162 distanceMeters: function (grayU16, near, far)
163 {
164 var t = (grayU16 & 0xffff) / 65535;
165 return near + t * (far - near);
166 }
167};
168
169if (typeof module !== "undefined" && module.exports)
170{ module.exports = DepthDecode; }
171
172/*
173 * End File:
174 * /workspace/raytracer-work/src/ppda/depthDecode.js
175 */
176
177/*
178 * Start File:
179 * /workspace/raytracer-work/src/ppda/viewFrame.js
180 */
181/**
182 * Choose paperdoll view (yaw/pitch) and animation frame.
183 * Yaw 0 = character front (Paperdoll/glTF convention).
184 */
185var PpdaViewFrame =
186{
187 /**
188 * Relative viewing yaw in degrees [0,360): direction from NPC to player,
189 * minus the NPC's facing yaw (degrees, 0 = faces +X/east in world… mapped
190 * so that when the player looks at the NPC's front, relative yaw ≈ 0).
191 *
192 * World: +X east, +Y south (legacy raycaster). NPC facingYawDeg: 0 looks
193 * toward +X. Paperdoll yaw 0 is front. We map world facing so that the
194 * camera looking opposite to facing sees front.
195 */
196 relativeYawDeg: function (playerX, playerY, npcX, npcY, npcFacingDeg)
197 {
198 var dx = playerX - npcX;
199 var dy = playerY - npcY;
200 // Angle of vector NPC→player in world degrees (0=+X, 90=+Y).
201 var toPlayer = Math.atan2(dy, dx) * 180 / Math.PI;
202 if (toPlayer < 0)
203 { toPlayer += 360; }
204 // When player stands in front of NPC, toPlayer ≈ npcFacing.
205 // Paperdoll wants yaw 0 for front → relative = toPlayer - facing.
206 var rel = toPlayer - (npcFacingDeg || 0);
207 rel = ((rel % 360) + 360) % 360;
208 return rel;
209 },
210
211 nearestInList: function (value, list, circular360)
212 {
213 if (!list || !list.length)
214 { return 0; }
215 var best = list[0];
216 var bestD = Infinity;
217 for (var i = 0; i < list.length; i++)
218 {
219 var v = list[i];
220 var d = Math.abs(value - v);
221 if (circular360)
222 { d = Math.min(d, 360 - d); }
223 if (d < bestD)
224 {
225 bestD = d;
226 best = v;
227 }
228 }
229 return best;
230 },
231
232 pickYaw: function (relativeYawDeg, yaws)
233 {
234 return this.nearestInList(((relativeYawDeg % 360) + 360) % 360, yaws || [0], true);
235 },
236
237 pickPitch: function (playerPitchRad, pitches)
238 {
239 // player pitch: 0 = horizon; positive looks down in this game.
240 // Paperdoll: positive pitch = from above. Invert sign for mapping.
241 var deg = -(playerPitchRad || 0) * 180 / Math.PI;
242 return this.nearestInList(deg, pitches || [0]);
243 },
244
245 frameIndex: function (timeSec, fps, frameCount)
246 {
247 var n = Math.max(1, frameCount | 0);
248 var f = Math.max(1, fps | 0);
249 var idx = Math.floor((timeSec || 0) * f);
250 idx %= n;
251 if (idx < 0)
252 { idx += n; }
253 return idx;
254 },
255
256 findClip: function (ppda, clipTokenOrName)
257 {
258 var clips = ppda && ppda.clips || [];
259 for (var i = 0; i < clips.length; i++)
260 {
261 if (clips[i].token === clipTokenOrName || clips[i].name === clipTokenOrName)
262 { return clips[i]; }
263 }
264 return clips[0] || null;
265 },
266
267 findView: function (frame, pitch, yaw)
268 {
269 var views = frame && frame.views || [];
270 for (var i = 0; i < views.length; i++)
271 {
272 if (views[i].pitch === pitch && views[i].yaw === yaw)
273 { return views[i]; }
274 }
275 return null;
276 },
277
278 uvRect: function (view, atlasW, atlasH)
279 {
280 if (!view)
281 { return { u0: 0, v0: 0, u1: 1, v1: 1, x: 0, y: 0, w: 0, h: 0 }; }
282 var w = atlasW || 1;
283 var h = atlasH || 1;
284 return {
285 x: view.x,
286 y: view.y,
287 w: view.w,
288 h: view.h,
289 u0: view.x / w,
290 v0: view.y / h,
291 u1: (view.x + view.w) / w,
292 v1: (view.y + view.h) / h
293 };
294 }
295};
296
297if (typeof module !== "undefined" && module.exports)
298{ module.exports = PpdaViewFrame; }
299
300/*
301 * End File:
302 * /workspace/raytracer-work/src/ppda/viewFrame.js
303 */
304
305/*
306 * Start File:
307 * /workspace/raytracer-work/src/ppda/compositor.js
308 */
309/**
310 * Live body+equipment compositor — port of compositor.rs compose().
311 * Per pixel: nearest valid depth wins; ties keep lower layer index (body first).
312 * Valid = depth alpha ≠ 0 AND diffuse alpha ≠ 0.
313 */
314var PpdaCompositor =
315{
316 DEPTH_EPSILON_U16: 1,
317
318 /**
319 * @param {Array<{width,height,diffuse:Uint8ClampedArray|Uint8Array,depthGray:Uint16Array,depthAlpha:Uint16Array,normal?:Uint8Array,specular?:Uint8Array}>} layers
320 */
321 compose: function (layers)
322 {
323 if (!layers || !layers.length)
324 { throw new Error("geen lagen om te composeren"); }
325 var width = layers[0].width;
326 var height = layers[0].height;
327 var pixels = width * height;
328 if (!pixels)
329 { throw new Error("lege afmetingen"); }
330 for (var li = 0; li < layers.length; li++)
331 {
332 var L = layers[li];
333 if (L.width !== width || L.height !== height)
334 { throw new Error("laag " + li + " heeft andere afmetingen"); }
335 if (L.diffuse.length !== pixels * 4 || L.depthGray.length !== pixels || L.depthAlpha.length !== pixels)
336 { throw new Error("laag " + li + " inconsistente buffers"); }
337 }
338
339 var diffuse = new Uint8ClampedArray(pixels * 4);
340 var normal = new Uint8ClampedArray(pixels * 4);
341 var specular = new Uint8ClampedArray(pixels * 4);
342 var depthGray = new Uint16Array(pixels);
343 var depthAlpha = new Uint16Array(pixels);
344 var winner = new Uint8Array(pixels);
345 for (var i = 0; i < pixels; i++)
346 { winner[i] = 255; }
347
348 var eps = this.DEPTH_EPSILON_U16;
349 for (var i = 0; i < pixels; i++)
350 {
351 var bestDepth = null;
352 var bestLayer = null;
353 for (var layerIdx = 0; layerIdx < layers.length; layerIdx++)
354 {
355 var layer = layers[layerIdx];
356 if (layer.depthAlpha[i] === 0 || layer.diffuse[i * 4 + 3] === 0)
357 { continue; }
358 var gray = layer.depthGray[i];
359 if (bestDepth == null)
360 {
361 bestDepth = gray;
362 bestLayer = layerIdx;
363 }
364 else if (gray + eps < bestDepth)
365 {
366 bestDepth = gray;
367 bestLayer = layerIdx;
368 }
369 else if (gray <= bestDepth + eps)
370 {
371 /* tie: keep lower index */
372 }
373 }
374 if (bestLayer != null)
375 {
376 var src = layers[bestLayer];
377 var o = i * 4;
378 diffuse[o] = src.diffuse[o];
379 diffuse[o + 1] = src.diffuse[o + 1];
380 diffuse[o + 2] = src.diffuse[o + 2];
381 diffuse[o + 3] = src.diffuse[o + 3];
382 if (src.normal)
383 {
384 normal[o] = src.normal[o];
385 normal[o + 1] = src.normal[o + 1];
386 normal[o + 2] = src.normal[o + 2];
387 normal[o + 3] = src.normal[o + 3];
388 }
389 if (src.specular)
390 {
391 specular[o] = src.specular[o];
392 specular[o + 1] = src.specular[o + 1];
393 specular[o + 2] = src.specular[o + 2];
394 specular[o + 3] = src.specular[o + 3];
395 }
396 depthGray[i] = src.depthGray[i];
397 depthAlpha[i] = src.depthAlpha[i];
398 winner[i] = bestLayer;
399 }
400 }
401
402 return {
403 width: width,
404 height: height,
405 diffuse: diffuse,
406 normal: normal,
407 specular: specular,
408 depthGray: depthGray,
409 depthAlpha: depthAlpha,
410 winner: winner
411 };
412 },
413
414 /** Simple ambient+Lambert approx for preview (Preview2d-achtig, licht). */
415 relightDiffuse: function (composed, lightAmt)
416 {
417 lightAmt = lightAmt == null ? 1 : lightAmt;
418 var out = new Uint8ClampedArray(composed.diffuse.length);
419 for (var i = 0; i < composed.diffuse.length; i += 4)
420 {
421 var a = composed.diffuse[i + 3];
422 if (a === 0)
423 { continue; }
424 var ndot = 0.75;
425 if (composed.normal && composed.normal[i + 3])
426 {
427 var nx = composed.normal[i] / 255 * 2 - 1;
428 var ny = composed.normal[i + 1] / 255 * 2 - 1;
429 var nz = composed.normal[i + 2] / 255 * 2 - 1;
430 ndot = Math.max(0, nx * 0.3 + ny * 0.2 + nz * 0.9);
431 }
432 var shade = Math.min(1, 0.35 + 0.65 * ndot) * lightAmt;
433 out[i] = Math.min(255, Math.round(composed.diffuse[i] * shade));
434 out[i + 1] = Math.min(255, Math.round(composed.diffuse[i + 1] * shade));
435 out[i + 2] = Math.min(255, Math.round(composed.diffuse[i + 2] * shade));
436 out[i + 3] = a;
437 }
438 return out;
439 }
440};
441
442if (typeof module !== "undefined" && module.exports)
443{ module.exports = PpdaCompositor; }
444
445/*
446 * End File:
447 * /workspace/raytracer-work/src/ppda/compositor.js
448 */
449
450/*
451 * Start File:
452 * /workspace/raytracer-work/src/ppda/loadPpda.js
453 */
454/**
455 * Strict-enough .ppda loader for formats 1–5 (Paperdoll AtlasSet consumer).
456 */
457var PpdaLoader =
458{
459 SUPPORTED_FORMATS: [1, 2, 3, 4, 5],
460
461 parse: function (jsonText, options)
462 {
463 options = options || {};
464 var doc;
465 try
466 { doc = typeof jsonText === "string" ? JSON.parse(jsonText) : jsonText; }
467 catch (e)
468 { throw new Error("ppda: ongeldige JSON (" + e.message + ")"); }
469
470 if (!doc || typeof doc !== "object")
471 { throw new Error("ppda: root moet een object zijn"); }
472
473 var ver = doc.format_version;
474 if (this.SUPPORTED_FORMATS.indexOf(ver) < 0)
475 { throw new Error("ppda: format_version " + ver + " niet ondersteund (wel: " + this.SUPPORTED_FORMATS.join(",") + ")"); }
476
477 if (!doc.sex || !doc.settype)
478 { throw new Error("ppda: sex/settype verplicht"); }
479 if (!doc.fps || doc.fps < 1)
480 { throw new Error("ppda: fps ongeldig"); }
481 if (!doc.cell_width || !doc.cell_height)
482 { throw new Error("ppda: cell_width/height verplicht"); }
483 if (!Array.isArray(doc.pitches) || !Array.isArray(doc.yaws) || !doc.pitches.length || !doc.yaws.length)
484 { throw new Error("ppda: pitches/yaws verplicht"); }
485 if (!doc.maps || typeof doc.maps !== "object")
486 { throw new Error("ppda: maps verplicht"); }
487 ["diffuse", "depth"].forEach(function (k)
488 {
489 if (!doc.maps[k] || !doc.maps[k].file)
490 { throw new Error("ppda: maps." + k + ".file verplicht"); }
491 if (String(doc.maps[k].file).indexOf("..") >= 0 || String(doc.maps[k].file).indexOf("/") >= 0 || String(doc.maps[k].file).indexOf("\\") >= 0)
492 { throw new Error("ppda: maps." + k + ".file mag geen pad bevatten"); }
493 });
494 if (!Array.isArray(doc.clips) || !doc.clips.length)
495 { throw new Error("ppda: clips verplicht"); }
496
497 for (var ci = 0; ci < doc.clips.length; ci++)
498 {
499 var clip = doc.clips[ci];
500 if (!clip.frames || clip.frames.length !== clip.frame_count)
501 { throw new Error("ppda: clip '" + (clip.name || ci) + "' frames≠frame_count"); }
502 for (var fi = 0; fi < clip.frames.length; fi++)
503 {
504 var fr = clip.frames[fi];
505 if (!fr.views || !fr.views.length)
506 { throw new Error("ppda: frame zonder views"); }
507 for (var vi = 0; vi < fr.views.length; vi++)
508 {
509 var v = fr.views[vi];
510 if (v.w == null || v.h == null || v.x == null || v.y == null)
511 { throw new Error("ppda: view mist x/y/w/h"); }
512 }
513 }
514 }
515
516 var encoding = doc.depth_encoding;
517 var bits = doc.depth_bits;
518 if (!encoding)
519 {
520 // v1 / legacy long text in identity.depth → gray16
521 encoding = "gray";
522 bits = bits || 16;
523 }
524 else if (/gray/i.test(encoding) && encoding.indexOf("rgb_") < 0)
525 {
526 encoding = "gray";
527 }
528 else if (encoding.indexOf("rgb_bands") >= 0)
529 { encoding = "rgb_bands"; }
530 else if (encoding.indexOf("rgb_packed") >= 0)
531 { encoding = "rgb_packed"; }
532
533 var near = doc.depth_near != null ? doc.depth_near : (doc.identity && doc.identity.near);
534 var far = doc.depth_far != null ? doc.depth_far : (doc.identity && doc.identity.far);
535 if (near == null || far == null)
536 { throw new Error("ppda: depth_near/far of identity.near/far verplicht"); }
537
538 var fmt = DepthDecode.parseFormat(encoding, bits || 16);
539
540 return {
541 format_version: ver,
542 sex: doc.sex,
543 settype: doc.settype,
544 fps: doc.fps,
545 cell_width: doc.cell_width,
546 cell_height: doc.cell_height,
547 pitches: doc.pitches.slice(),
548 yaws: doc.yaws.slice(),
549 maps: doc.maps,
550 clips: doc.clips,
551 identity: doc.identity || null,
552 project: doc.project || null,
553 depth_near: Number(near),
554 depth_far: Number(far),
555 depth_format: fmt,
556 camera_distance: doc.identity && doc.identity.camera_distance != null
557 ? Number(doc.identity.camera_distance)
558 : 10,
559 height_milli: doc.identity && doc.identity.framing
560 ? doc.identity.framing.height_milli
561 : 2600,
562 raw: doc
563 };
564 },
565
566 compatKey: function (ppda)
567 {
568 var id = ppda.identity || {};
569 return {
570 sex: ppda.sex,
571 body_model_sha256: id.body_model_sha256 || "",
572 fps: ppda.fps,
573 cell_width: ppda.cell_width,
574 cell_height: ppda.cell_height,
575 pitches: ppda.pitches.join(","),
576 yaws: ppda.yaws.join(","),
577 near: ppda.depth_near,
578 far: ppda.depth_far
579 };
580 },
581
582 assertCompatible: function (a, b)
583 {
584 var ka = this.compatKey(a);
585 var kb = this.compatKey(b);
586 var keys = Object.keys(ka);
587 for (var i = 0; i < keys.length; i++)
588 {
589 var k = keys[i];
590 if (String(ka[k]) !== String(kb[k]))
591 { throw new Error("ppda incompatible: " + k + " (" + ka[k] + " vs " + kb[k] + ")"); }
592 }
593 }
594};
595
596if (typeof module !== "undefined" && module.exports)
597{ module.exports = PpdaLoader; }
598
599/*
600 * End File:
601 * /workspace/raytracer-work/src/ppda/loadPpda.js
602 */
603
604/*
605 * Start File:
606 * /workspace/raytracer-work/src/ppda/atlasRuntime.js
607 */
608/**
609 * Browser/runtime atlas set: loads PNG diffuse/normal/specular + u16 depth,
610 * extracts cells, composes body+gear on CPU (cell is 32×48 — cheap).
611 */
612var PpdaAtlasRuntime =
613{
614 _canvas: null,
615 _ctx: null,
616
617 _ensureCanvas: function ()
618 {
619 if (typeof document === "undefined")
620 { return null; }
621 if (!this._canvas)
622 {
623 this._canvas = document.createElement("canvas");
624 this._ctx = this._canvas.getContext("2d", { willReadFrequently: true });
625 }
626 return this._ctx;
627 },
628
629 loadImage: function (url)
630 {
631 return new Promise(function (resolve, reject)
632 {
633 var img = new Image();
634 img.onload = function ()
635 { resolve(img); };
636 img.onerror = function ()
637 { reject(new Error("image load failed: " + url)); };
638 img.src = url;
639 });
640 },
641
642 loadU16Depth: function (url, expectW, expectH)
643 {
644 return fetch(url).then(function (r)
645 {
646 if (!r.ok)
647 { throw new Error("depth fetch " + r.status + " " + url); }
648 return r.arrayBuffer();
649 }).then(function (buf)
650 {
651 var need = expectW * expectH * 4;
652 if (buf.byteLength < need)
653 { throw new Error("depth u16 te kort: " + buf.byteLength + " < " + need); }
654 return new Uint16Array(buf.slice(0, need));
655 });
656 },
657
658 /**
659 * @returns {Promise<{ppda, images, depthU16, baseUrl}>}
660 */
661 loadSet: function (baseUrl, ppdaFile)
662 {
663 var self = this;
664 baseUrl = baseUrl.replace(/\/?$/, "/");
665 return fetch(baseUrl + ppdaFile).then(function (r)
666 {
667 if (!r.ok)
668 { throw new Error("ppda fetch " + r.status); }
669 return r.text();
670 }).then(function (text)
671 {
672 var ppda = PpdaLoader.parse(text);
673 var maps = ppda.maps;
674 var jobs = [
675 self.loadImage(baseUrl + maps.diffuse.file),
676 maps.normal ? self.loadImage(baseUrl + maps.normal.file) : Promise.resolve(null),
677 maps.specular ? self.loadImage(baseUrl + maps.specular.file) : Promise.resolve(null)
678 ];
679 var depthFile = maps.depth.file;
680 var dw = maps.depth.width || maps.diffuse.width;
681 var dh = maps.depth.height || maps.diffuse.height;
682 if (maps.depth.storage === "u16le_ga" || /\.u16$/i.test(depthFile))
683 { jobs.push(self.loadU16Depth(baseUrl + depthFile, dw, dh)); }
684 else
685 { throw new Error("browser-loader verwacht depth als .u16 (storage=u16le_ga); got " + depthFile); }
686
687 return Promise.all(jobs).then(function (parts)
688 {
689 return {
690 ppda: ppda,
691 baseUrl: baseUrl,
692 diffuseImg: parts[0],
693 normalImg: parts[1],
694 specularImg: parts[2],
695 depthU16: parts[3],
696 depthW: dw,
697 depthH: dh
698 };
699 });
700 });
701 },
702
703 extractRgbaCell: function (img, view)
704 {
705 var ctx = this._ensureCanvas();
706 if (!ctx)
707 { throw new Error("geen canvas voor cell extract"); }
708 this._canvas.width = view.w;
709 this._canvas.height = view.h;
710 ctx.clearRect(0, 0, view.w, view.h);
711 ctx.drawImage(img, view.x, view.y, view.w, view.h, 0, 0, view.w, view.h);
712 return ctx.getImageData(0, 0, view.w, view.h).data;
713 },
714
715 extractDepthCell: function (depthU16, atlasW, view)
716 {
717 var n = view.w * view.h;
718 var gray = new Uint16Array(n);
719 var alpha = new Uint16Array(n);
720 for (var y = 0; y < view.h; y++)
721 {
722 for (var x = 0; x < view.w; x++)
723 {
724 var si = ((view.y + y) * atlasW + (view.x + x)) * 2;
725 var di = y * view.w + x;
726 gray[di] = depthU16[si];
727 alpha[di] = depthU16[si + 1];
728 }
729 }
730 return { depthGray: gray, depthAlpha: alpha };
731 },
732
733 layerFromSet: function (set, clipToken, frameIndex, pitch, yaw)
734 {
735 var clip = PpdaViewFrame.findClip(set.ppda, clipToken);
736 if (!clip)
737 { throw new Error("clip niet gevonden: " + clipToken); }
738 var frame = clip.frames[frameIndex];
739 if (!frame)
740 { throw new Error("frame " + frameIndex + " ontbreekt"); }
741 var view = PpdaViewFrame.findView(frame, pitch, yaw);
742 if (!view)
743 { throw new Error("view p" + pitch + " y" + yaw + " ontbreekt"); }
744 if (view.empty)
745 {
746 var emptyN = view.w * view.h;
747 return {
748 width: view.w,
749 height: view.h,
750 diffuse: new Uint8ClampedArray(emptyN * 4),
751 normal: new Uint8ClampedArray(emptyN * 4),
752 specular: new Uint8ClampedArray(emptyN * 4),
753 depthGray: new Uint16Array(emptyN),
754 depthAlpha: new Uint16Array(emptyN),
755 view: view
756 };
757 }
758 var diffuse = this.extractRgbaCell(set.diffuseImg, view);
759 var normal = set.normalImg ? this.extractRgbaCell(set.normalImg, view) : null;
760 var specular = set.specularImg ? this.extractRgbaCell(set.specularImg, view) : null;
761 var depth = this.extractDepthCell(set.depthU16, set.depthW, view);
762 return {
763 width: view.w,
764 height: view.h,
765 diffuse: diffuse,
766 normal: normal,
767 specular: specular,
768 depthGray: depth.depthGray,
769 depthAlpha: depth.depthAlpha,
770 view: view
771 };
772 },
773
774 composeView: function (bodySet, gearSet, clipToken, frameIndex, pitch, yaw)
775 {
776 var body = this.layerFromSet(bodySet, clipToken, frameIndex, pitch, yaw);
777 var layers = [body];
778 if (gearSet)
779 {
780 PpdaLoader.assertCompatible(bodySet.ppda, gearSet.ppda);
781 layers.push(this.layerFromSet(gearSet, clipToken, frameIndex, pitch, yaw));
782 }
783 var composed = PpdaCompositor.compose(layers);
784 composed.view = body.view;
785 composed.lit = PpdaCompositor.relightDiffuse(composed, 1);
786 return composed;
787 }
788};
789
790if (typeof module !== "undefined" && module.exports)
791{ module.exports = PpdaAtlasRuntime; }
792
793/*
794 * End File:
795 * /workspace/raytracer-work/src/ppda/atlasRuntime.js
796 */
797
798/*
799 * Start File:
800 * /workspace/raytracer-work/src/levelFormat.js
801 */
802/**
803 * Level pack format (schema v1) for raytracer + editor.
804 * walls: tile type ids; floors/ceilings: texture id string or null (black).
805 * lights: reserved list (not rendered yet).
806 */
807var LevelFormat =
808{
809 CURRENT_VERSION: 1,
810 MAX_SIZE: 128,
811 MAX_LEVELS: 64,
812 KNOWN_TEXTURES: ["stone", "wood"],
813
814 emptyLevel: function (name, width, height)
815 {
816 width = Math.max(3, Math.min(this.MAX_SIZE, width || 10));
817 height = Math.max(3, Math.min(this.MAX_SIZE, height || 10));
818 var n = width * height;
819 var walls = [];
820 var floors = [];
821 var ceilings = [];
822 for (var i = 0; i < n; i++)
823 {
824 var x = i % width;
825 var y = Math.floor(i / width);
826 var border = x === 0 || y === 0 || x === width - 1 || y === height - 1;
827 walls.push(border ? 1 : 0);
828 floors.push(border ? null : "stone");
829 ceilings.push(border ? null : "stone");
830 }
831 return {
832 id: "level-" + Date.now().toString(36),
833 name: name || "Nieuw level",
834 width: width,
835 height: height,
836 cellSize: 32,
837 spawn: { tileX: 1, tileY: 1, yawRad: 0 },
838 walls: walls,
839 floors: floors,
840 ceilings: ceilings,
841 npcs: [],
842 lights: []
843 };
844 },
845
846 defaultPack: function ()
847 {
848 return {
849 format_version: this.CURRENT_VERSION,
850 textures: [
851 { id: "stone", url: "images/stone.png" },
852 { id: "wood", url: "images/wood.png" }
853 ],
854 levels: []
855 };
856 },
857
858 /** Migrate legacy Levels[] (tiles only) into a pack. */
859 fromLegacyLevels: function (legacyArr, npcsByLevel)
860 {
861 var pack = this.defaultPack();
862 for (var i = 0; i < (legacyArr || []).length; i++)
863 {
864 var L = legacyArr[i];
865 var n = L.width * L.height;
866 var floors = [];
867 var ceilings = [];
868 for (var t = 0; t < n; t++)
869 {
870 var solid = L.tiles[t] === 1 || L.tiles[t] === 3;
871 floors.push(solid ? null : "stone");
872 ceilings.push(solid ? null : "stone");
873 }
874 pack.levels.push({
875 id: "level-" + (i + 1),
876 name: L.name || ("Level " + (i + 1)),
877 width: L.width,
878 height: L.height,
879 cellSize: 32,
880 spawn: {
881 tileX: L.spawnX,
882 tileY: L.spawnY,
883 yawRad: 0
884 },
885 walls: L.tiles.slice(),
886 floors: floors,
887 ceilings: ceilings,
888 npcs: (npcsByLevel && npcsByLevel[i]) || [],
889 lights: []
890 });
891 }
892 return pack;
893 },
894
895 validateTextureId: function (tex, allowNull)
896 {
897 if (tex == null || tex === "")
898 { return !!allowNull; }
899 return this.KNOWN_TEXTURES.indexOf(tex) >= 0;
900 },
901
902 validateLevel: function (level, index)
903 {
904 var prefix = "level[" + (index == null ? "?" : index) + "]";
905 if (!level || typeof level !== "object")
906 { throw new Error(prefix + ": moet een object zijn"); }
907 if (!level.id || typeof level.id !== "string")
908 { throw new Error(prefix + ": id verplicht"); }
909 if (!level.name || typeof level.name !== "string")
910 { throw new Error(prefix + ": name verplicht"); }
911 var w = level.width | 0;
912 var h = level.height | 0;
913 if (w < 3 || h < 3 || w > this.MAX_SIZE || h > this.MAX_SIZE)
914 { throw new Error(prefix + ": width/height 3.." + this.MAX_SIZE); }
915 var n = w * h;
916 if (!Array.isArray(level.walls) || level.walls.length !== n)
917 { throw new Error(prefix + ": walls lengte ≠ width*height"); }
918 if (!Array.isArray(level.floors) || level.floors.length !== n)
919 { throw new Error(prefix + ": floors lengte ≠ width*height"); }
920 if (!Array.isArray(level.ceilings) || level.ceilings.length !== n)
921 { throw new Error(prefix + ": ceilings lengte ≠ width*height"); }
922 for (var i = 0; i < n; i++)
923 {
924 var wall = level.walls[i];
925 if (typeof wall !== "number" || wall !== (wall | 0) || wall < 0 || wall > 3)
926 { throw new Error(prefix + ": walls[" + i + "] ongeldig"); }
927 if (!this.validateTextureId(level.floors[i], true))
928 { throw new Error(prefix + ": floors[" + i + "] onbekende textuur"); }
929 if (!this.validateTextureId(level.ceilings[i], true))
930 { throw new Error(prefix + ": ceilings[" + i + "] onbekende textuur"); }
931 }
932 if (!level.spawn || typeof level.spawn.tileX !== "number" || typeof level.spawn.tileY !== "number")
933 { throw new Error(prefix + ": spawn.tileX/tileY verplicht"); }
934 if (level.spawn.tileX < 0 || level.spawn.tileY < 0 || level.spawn.tileX >= w || level.spawn.tileY >= h)
935 { throw new Error(prefix + ": spawn buiten de map"); }
936 if (typeof level.spawn.yawRad !== "number")
937 { level.spawn.yawRad = 0; }
938 if (!Array.isArray(level.npcs))
939 { throw new Error(prefix + ": npcs moet een array zijn"); }
940 if (!Array.isArray(level.lights))
941 { level.lights = []; }
942 if (level.cellSize == null)
943 { level.cellSize = 32; }
944 return level;
945 },
946
947 validatePack: function (pack)
948 {
949 if (!pack || typeof pack !== "object")
950 { throw new Error("pack: root moet een object zijn"); }
951 var ver = pack.format_version;
952 if (ver !== 1)
953 { throw new Error("pack: format_version " + ver + " niet ondersteund (wel: 1)"); }
954 if (!Array.isArray(pack.levels))
955 { throw new Error("pack: levels moet een array zijn"); }
956 if (pack.levels.length > this.MAX_LEVELS)
957 { throw new Error("pack: te veel levels"); }
958 if (pack.levels.length < 1)
959 { throw new Error("pack: minstens één level"); }
960 var ids = {};
961 for (var i = 0; i < pack.levels.length; i++)
962 {
963 this.validateLevel(pack.levels[i], i);
964 if (ids[pack.levels[i].id])
965 { throw new Error("pack: dubbele level-id " + pack.levels[i].id); }
966 ids[pack.levels[i].id] = true;
967 }
968 if (!Array.isArray(pack.textures))
969 { pack.textures = this.defaultPack().textures; }
970 return pack;
971 },
972
973 parse: function (jsonText)
974 {
975 var doc;
976 try
977 { doc = typeof jsonText === "string" ? JSON.parse(jsonText) : jsonText; }
978 catch (e)
979 { throw new Error("levels.json: ongeldige JSON (" + e.message + ")"); }
980 return this.validatePack(doc);
981 },
982
983 /** Runtime view used by World (tiles = walls). */
984 toRuntimeLevel: function (level)
985 {
986 return {
987 id: level.id,
988 name: level.name,
989 width: level.width,
990 height: level.height,
991 cellSize: level.cellSize || 32,
992 spawnX: level.spawn.tileX,
993 spawnY: level.spawn.tileY,
994 spawnYaw: level.spawn.yawRad || 0,
995 tiles: level.walls,
996 floors: level.floors,
997 ceilings: level.ceilings,
998 npcs: level.npcs || [],
999 lights: level.lights || []
1000 };
1001 },
1002
1003 findLevelIndex: function (pack, query)
1004 {
1005 if (query == null || query === "")
1006 { return 0; }
1007 var asNum = Number(query);
1008 if (!isNaN(asNum) && asNum === (asNum | 0) && asNum >= 0 && asNum < pack.levels.length)
1009 { return asNum; }
1010 for (var i = 0; i < pack.levels.length; i++)
1011 {
1012 if (pack.levels[i].id === query || pack.levels[i].name === query)
1013 { return i; }
1014 }
1015 return -1;
1016 },
1017
1018 cloneLevel: function (level)
1019 {
1020 return JSON.parse(JSON.stringify(level));
1021 }
1022};
1023
1024if (typeof module !== "undefined" && module.exports)
1025{ module.exports = LevelFormat; }
1026
1027/*
1028 * End File:
1029 * /workspace/raytracer-work/src/levelFormat.js
1030 */
1031
1032/*
1033 * Start File:
1034 * /workspace/raytracer-work/src/floorCast.js
1035 */
1036/**
1037 * Classic floor/ceiling casting (Lode-style) — pure math + CPU NEAREST fill.
1038 * Chosen over a grid data-texture shader because frameworkv3 is WebGL1 sprites
1039 * without a shared depth buffer; one ImageData upload stays simple and keeps
1040 * wall/NPC draw order unchanged (floor under walls).
1041 */
1042var FloorCast =
1043{
1044 /**
1045 * World-space floor hit for screen pixel (sx, sy).
1046 * @returns {{wx:number,wy:number,rowDist:number}|null}
1047 */
1048 floorHit: function (sx, sy, screenW, screenH, playerX, playerY, rot, pitch, posZ)
1049 {
1050 var mid = screenH / 2 + (-pitch * screenH * 0.25);
1051 var p = sy - mid;
1052 if (p === 0)
1053 { return null; }
1054 var absP = Math.abs(p);
1055 posZ = posZ == null ? screenH * 0.5 : posZ;
1056 var rowDist = posZ / absP;
1057 var camX = (2 * sx / screenW) - 1;
1058 // Match wall FOV: rotationalOffset ≈ camX * (π/4) at screen edges.
1059 var rayAngle = rot + camX * (Math.PI / 4);
1060 var dirX = Math.cos(rayAngle);
1061 var dirY = Math.sin(rayAngle);
1062 return {
1063 wx: playerX + dirX * rowDist,
1064 wy: playerY + dirY * rowDist,
1065 rowDist: rowDist,
1066 isCeiling: p < 0
1067 };
1068 },
1069
1070 /**
1071 * Sample NEAREST from RGBA Uint8ClampedArray tex (tw×th).
1072 */
1073 sampleNearest: function (rgba, tw, th, u, v)
1074 {
1075 var tx = Math.floor(((u % 1) + 1) % 1 * tw);
1076 var ty = Math.floor(((v % 1) + 1) % 1 * th);
1077 if (tx < 0) tx = 0;
1078 if (ty < 0) ty = 0;
1079 if (tx >= tw) tx = tw - 1;
1080 if (ty >= th) ty = th - 1;
1081 var o = (ty * tw + tx) * 4;
1082 return [rgba[o], rgba[o + 1], rgba[o + 2], rgba[o + 3]];
1083 },
1084
1085 /**
1086 * Fill ImageData with floor (below horizon) and ceiling (above).
1087 * texMap: { stone: {rgba,w,h}, wood: {...} }
1088 * level: runtime level with floors[], ceilings[], width, height, cellSize
1089 */
1090 render: function (imgData, screenW, screenH, player, level, texMap, cellSize)
1091 {
1092 cellSize = cellSize || 32;
1093 var data = imgData.data;
1094 var mid = screenH / 2 + (-player.pitch * screenH * 0.25);
1095 var posZ = screenH * 0.5;
1096 var lw = level.width;
1097 var lh = level.height;
1098 var floors = level.floors;
1099 var ceilings = level.ceilings;
1100
1101 // Step 2×2: NEAREST block fill — ~4× sneller, nog steeds pixelig.
1102 var step = 2;
1103 for (var sy = 0; sy < screenH; sy += step)
1104 {
1105 var p = (sy + step * 0.5) - mid;
1106 if (Math.abs(p) < 0.5)
1107 { continue; }
1108 var isCeil = p < 0;
1109 var rowDist = posZ / Math.abs(p);
1110 var shade = Math.max(0.35, Math.min(1, 1.2 - rowDist / 400));
1111 for (var sx = 0; sx < screenW; sx += step)
1112 {
1113 var camX = (2 * (sx + step * 0.5) / screenW) - 1;
1114 var rayAngle = player.rotation + camX * (Math.PI / 4);
1115 var wx = player.x + Math.cos(rayAngle) * rowDist;
1116 var wy = player.y + Math.sin(rayAngle) * rowDist;
1117 var cx = Math.floor(wx / cellSize);
1118 var cy = Math.floor(wy / cellSize);
1119 var r = 0, g = 0, b = 0;
1120 if (cx >= 0 && cy >= 0 && cx < lw && cy < lh)
1121 {
1122 var idx = cx + cy * lw;
1123 var texId = isCeil ? ceilings[idx] : floors[idx];
1124 if (texId && texMap[texId])
1125 {
1126 var tex = texMap[texId];
1127 var u = (wx / cellSize) - cx;
1128 var vv = (wy / cellSize) - cy;
1129 var c = this.sampleNearest(tex.rgba, tex.w, tex.h, u, vv);
1130 r = (c[0] * shade) | 0;
1131 g = (c[1] * shade) | 0;
1132 b = (c[2] * shade) | 0;
1133 }
1134 }
1135 for (var dy = 0; dy < step && sy + dy < screenH; dy++)
1136 {
1137 for (var dx = 0; dx < step && sx + dx < screenW; dx++)
1138 {
1139 var o = ((sy + dy) * screenW + (sx + dx)) * 4;
1140 data[o] = r;
1141 data[o + 1] = g;
1142 data[o + 2] = b;
1143 data[o + 3] = 255;
1144 }
1145 }
1146 }
1147 }
1148 return imgData;
1149 }
1150};
1151
1152if (typeof module !== "undefined" && module.exports)
1153{ module.exports = FloorCast; }
1154
1155/*
1156 * End File:
1157 * /workspace/raytracer-work/src/floorCast.js
1158 */
1159
1160/*
1161 * Start File:
1162 * /workspace/raytracer-work/src/levels.js
1163 */
1164var Levels =
1165[
1166 {
1167 name: "Level 1",
1168 width: 10,
1169 height: 10,
1170 spawnX: 1,
1171 spawnY: 1,
1172 tiles:
1173 [
1174 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1175 1, 0, 0, 0, 0, 0, 0, 0, 0, 1,
1176 1, 0, 1, 1, 0, 0, 3, 3, 0, 1,
1177 1, 0, 0, 1, 0, 0, 0, 0, 0, 1,
1178 1, 0, 0, 0, 0, 1, 0, 1, 0, 1,
1179 1, 0, 0, 0, 0, 1, 0, 1, 0, 1,
1180 1, 0, 0, 0, 0, 1, 2, 1, 0, 1,
1181 1, 0, 1, 0, 0, 1, 3, 1, 0, 1,
1182 1, 0, 0, 0, 0, 0, 0, 0, 0, 1,
1183 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
1184 ]
1185 }
1186];
1187
1188/*
1189 * End File:
1190 * /workspace/raytracer-work/src/levels.js
1191 */
1192
1193/*
1194 * Start File:
1195 * /workspace/raytracer-work/src/tiles.js
1196 */
1197/** Tile table; Image fields filled after preload. */
1198var Tiles =
1199{
1200 Nothing:
1201 {
1202 ID: 0,
1203 Color: { R: 255, G: 255, B: 255 },
1204 Solid: false,
1205 ImageName: null
1206 },
1207 Stone:
1208 {
1209 ID: 1,
1210 Color: { R: 155, G: 155, B: 155 },
1211 Solid: true,
1212 ImageName: "stone"
1213 },
1214 Finish:
1215 {
1216 ID: 2,
1217 Color: { R: 255, G: 255, B: 0 },
1218 Solid: false,
1219 ImageName: null
1220 },
1221 Wood:
1222 {
1223 ID: 3,
1224 Color: { R: 168, G: 102, B: 50 },
1225 Solid: true,
1226 ImageName: "wood"
1227 },
1228 findByID: function (id)
1229 {
1230 for (var key in Tiles)
1231 {
1232 if (!Object.prototype.hasOwnProperty.call(Tiles, key))
1233 { continue; }
1234 var value = Tiles[key];
1235 if (value && value.ID === id)
1236 { return value; }
1237 }
1238 return null;
1239 },
1240 bindImages: function (images)
1241 {
1242 for (var key in Tiles)
1243 {
1244 if (!Object.prototype.hasOwnProperty.call(Tiles, key))
1245 { continue; }
1246 var tile = Tiles[key];
1247 if (tile && tile.ImageName && images[tile.ImageName])
1248 { tile.Image = images[tile.ImageName]; }
1249 }
1250 }
1251};
1252
1253/*
1254 * End File:
1255 * /workspace/raytracer-work/src/tiles.js
1256 */
1257
1258/*
1259 * Start File:
1260 * /workspace/raytracer-work/src/world.js
1261 */
1262var World =
1263{
1264 size: 32,
1265 level: null,
1266 pack: null,
1267 levelIndex: 0,
1268
1269 loadPack: function (pack)
1270 {
1271 this.pack = pack;
1272 },
1273
1274 loadLevel: function (indexOrId)
1275 {
1276 if (!this.pack)
1277 { throw new Error("World: geen level-pack geladen"); }
1278 var idx = typeof indexOrId === "number"
1279 ? indexOrId
1280 : LevelFormat.findLevelIndex(this.pack, indexOrId);
1281 if (idx < 0 || idx >= this.pack.levels.length)
1282 { throw new Error("World: level niet gevonden: " + indexOrId); }
1283 this.levelIndex = idx;
1284 this.level = LevelFormat.toRuntimeLevel(this.pack.levels[idx]);
1285 this.size = this.level.cellSize || 32;
1286 },
1287
1288 spawnPoint: function ()
1289 {
1290 return {
1291 x: this.level.spawnX * this.size + this.size / 2,
1292 y: this.level.spawnY * this.size + this.size / 2,
1293 yaw: this.level.spawnYaw || 0
1294 };
1295 },
1296
1297 rayCast: function (x, y, radian)
1298 {
1299 var maxDist = this.level.width + this.level.height;
1300 var cell = this.size;
1301 var tileXpercentage = 0;
1302 var tileXp = 0;
1303 var tileYp = 0;
1304
1305 var hrayX, hrayY, hoffX, hoffY, distDone, hmapX, hmapY, htileHit;
1306 var hDir = "north";
1307 distDone = 0;
1308 var aTan = -1 / Math.tan(radian);
1309
1310 if (radian > Math.PI)
1311 {
1312 hrayY = Math.floor(y / cell) * cell - 0.01;
1313 hrayX = (y - hrayY) * aTan + x;
1314 hoffY = -cell;
1315 hoffX = -hoffY * aTan;
1316 }
1317 else if (radian < Math.PI)
1318 {
1319 hrayY = Math.floor(y / cell) * cell + cell;
1320 hrayX = (y - hrayY) * aTan + x;
1321 hoffY = cell;
1322 hoffX = -hoffY * aTan;
1323 hDir = "south";
1324 }
1325 else
1326 {
1327 hrayX = x;
1328 hrayY = y;
1329 distDone = maxDist;
1330 }
1331
1332 while (distDone < maxDist)
1333 {
1334 tileXp = ((hrayX % cell) + cell) % cell / cell;
1335 tileYp = ((hrayY % cell) + cell) % cell / cell;
1336 hmapX = Math.floor(hrayX / cell);
1337 hmapY = Math.floor(hrayY / cell);
1338 var htileHitId = this.level.tiles[hmapX + hmapY * this.level.width];
1339 htileHit = Tiles.findByID(htileHitId);
1340 if (htileHit && htileHit.Solid)
1341 { distDone = maxDist; }
1342 else
1343 {
1344 hrayX += hoffX;
1345 hrayY += hoffY;
1346 distDone += 1;
1347 }
1348 }
1349
1350 switch (hDir)
1351 {
1352 case "north": tileXpercentage = tileXp; break;
1353 case "south": tileXpercentage = 1 - tileXp; break;
1354 case "east": tileXpercentage = 1 - tileYp; break;
1355 case "west": tileXpercentage = tileYp; break;
1356 }
1357
1358 var hResult = {
1359 tile: htileHit,
1360 tileX: tileXpercentage,
1361 endX: hrayX,
1362 endY: hrayY,
1363 dir: hDir
1364 };
1365
1366 var rayX, rayY, offX, offY, mapX, mapY, tileHit;
1367 var vDir = "east";
1368 var nTan = -Math.tan(radian);
1369 distDone = 0;
1370
1371 if (radian > Math.PI / 2 && radian < Math.PI * 1.5)
1372 {
1373 rayX = Math.floor(x / cell) * cell - 0.01;
1374 rayY = (x - rayX) * nTan + y;
1375 offX = -cell;
1376 offY = -offX * nTan;
1377 }
1378 else if (radian < Math.PI / 2 || radian > Math.PI * 1.5)
1379 {
1380 rayX = Math.floor(x / cell) * cell + cell;
1381 rayY = (x - rayX) * nTan + y;
1382 offX = cell;
1383 offY = -offX * nTan;
1384 vDir = "west";
1385 }
1386 else
1387 {
1388 rayX = x;
1389 rayY = y;
1390 distDone = maxDist;
1391 }
1392
1393 while (distDone < maxDist)
1394 {
1395 tileXp = ((rayX % cell) + cell) % cell / cell;
1396 tileYp = ((rayY % cell) + cell) % cell / cell;
1397 mapX = Math.floor(rayX / cell);
1398 mapY = Math.floor(rayY / cell);
1399 var tileHitId = this.level.tiles[mapX + mapY * this.level.width];
1400 tileHit = Tiles.findByID(tileHitId);
1401 if (tileHit && tileHit.Solid)
1402 { distDone = maxDist; }
1403 else
1404 {
1405 rayX += offX;
1406 rayY += offY;
1407 distDone += 1;
1408 }
1409 }
1410
1411 switch (vDir)
1412 {
1413 case "north": tileXpercentage = tileXp; break;
1414 case "south": tileXpercentage = 1 - tileXp; break;
1415 case "east": tileXpercentage = 1 - tileYp; break;
1416 case "west": tileXpercentage = tileYp; break;
1417 }
1418
1419 var vResult = {
1420 tile: tileHit,
1421 tileX: tileXpercentage,
1422 endX: rayX,
1423 endY: rayY,
1424 dir: vDir
1425 };
1426
1427 var dxH = hResult.endX - x;
1428 var dyH = hResult.endY - y;
1429 var dxV = vResult.endX - x;
1430 var dyV = vResult.endY - y;
1431 hResult.distance = Math.sqrt(dxH * dxH + dyH * dyH);
1432 vResult.distance = Math.sqrt(dxV * dxV + dyV * dyV);
1433
1434 if (hResult.distance < vResult.distance)
1435 { return hResult; }
1436 return vResult;
1437 }
1438};
1439
1440if (typeof module !== "undefined" && module.exports)
1441{
1442 module.exports = { World: World };
1443}
1444
1445/*
1446 * End File:
1447 * /workspace/raytracer-work/src/world.js
1448 */
1449
1450/*
1451 * Start File:
1452 * /workspace/raytracer-work/src/player.js
1453 */
1454var Player =
1455{
1456 x: 0,
1457 y: 0,
1458 rotation: 0,
1459 pitch: 0,
1460 /** Screen columns per frame. 240 is sharp on ~1080p and cheap (~240 drawSprite calls). */
1461 horizontalResolution: 240,
1462 gunX: 0.6,
1463 gunY: 0.6,
1464 currentGun: 0,
1465 guns: 3,
1466
1467 resetToSpawn: function ()
1468 {
1469 var spawn = World.spawnPoint();
1470 this.x = spawn.x;
1471 this.y = spawn.y;
1472 this.rotation = spawn.yaw != null ? spawn.yaw : 0;
1473 this.pitch = 0;
1474 },
1475
1476 applyLookDelta: function (movementX, movementY)
1477 {
1478 this.pitch += movementY * 0.01;
1479 this.rotation += movementX * 0.001;
1480 if (this.pitch > Math.PI)
1481 { this.pitch = Math.PI; }
1482 if (this.pitch < -Math.PI)
1483 { this.pitch = -Math.PI; }
1484 if (this.rotation > Math.PI * 2)
1485 { this.rotation -= Math.PI * 2; }
1486 if (this.rotation < 0)
1487 { this.rotation += Math.PI * 2; }
1488 },
1489
1490 /** Legacy angles: 0 = +X (east), increases toward +Y. */
1491 forwardVector: function (radian)
1492 {
1493 return { x: Math.cos(radian), y: Math.sin(radian) };
1494 },
1495
1496 tryMove: function (rot, speed, deltaTime)
1497 {
1498 if (World.rayCast(this.x, this.y, rot).distance <= 5)
1499 { return; }
1500 var forward = this.forwardVector(rot);
1501 this.x += forward.x * deltaTime * speed;
1502 this.y += forward.y * deltaTime * speed;
1503 },
1504
1505 update: function (deltaTime)
1506 {
1507 if (GameInput.isHeld(37) || GameInput.isHeld(65))
1508 {
1509 var rotL = this.rotation - Math.PI / 2;
1510 if (rotL < 0) { rotL += Math.PI * 2; }
1511 this.tryMove(rotL, 60, deltaTime);
1512 }
1513 if (GameInput.isHeld(39) || GameInput.isHeld(68))
1514 {
1515 var rotR = this.rotation + Math.PI / 2;
1516 if (rotR > Math.PI * 2) { rotR -= Math.PI * 2; }
1517 this.tryMove(rotR, 60, deltaTime);
1518 }
1519 if (GameInput.isHeld(38) || GameInput.isHeld(87))
1520 { this.tryMove(this.rotation, 60, deltaTime); }
1521 if (GameInput.isHeld(40) || GameInput.isHeld(83))
1522 {
1523 var rotB = this.rotation + Math.PI;
1524 if (rotB > Math.PI * 2) { rotB -= Math.PI * 2; }
1525 if (World.rayCast(this.x, this.y, rotB).distance > 5)
1526 {
1527 var forward = this.forwardVector(this.rotation);
1528 this.x -= forward.x * deltaTime * 40;
1529 this.y -= forward.y * deltaTime * 40;
1530 }
1531 }
1532 if (GameInput.isHeld(188))
1533 {
1534 this.horizontalResolution -= this.horizontalResolution * 0.1 * deltaTime;
1535 if (this.horizontalResolution < 30)
1536 { this.horizontalResolution = 30; }
1537 }
1538 if (GameInput.isHeld(190))
1539 {
1540 this.horizontalResolution += this.horizontalResolution * 0.1 * deltaTime;
1541 }
1542 }
1543};
1544
1545/*
1546 * End File:
1547 * /workspace/raytracer-work/src/player.js
1548 */
1549
1550/*
1551 * Start File:
1552 * /workspace/raytracer-work/src/npc.js
1553 */
1554/**
1555 * Paperdoll NPC billboards.
1556 * Compose body+gear on CPU when view/frame changes (cell ~32×48).
1557 * Project with per-pixel depth into an offscreen RGBA buffer + z-buffer,
1558 * then one WebGL textured quad — avoids thousands of drawSprite calls.
1559 */
1560var NpcSystem =
1561{
1562 npcs: [],
1563 bodySet: null,
1564 gearSet: null,
1565 ready: false,
1566 cache: {},
1567 worldScale: 32,
1568 _overlay: null,
1569 _overlayCtx: null,
1570 _overlayImg: null,
1571 _zbuf: null,
1572 _zbufW: 0,
1573 _zbufH: 0,
1574
1575 initEmpty: function ()
1576 {
1577 this.npcs = [];
1578 this.cache = {};
1579 this.ready = false;
1580 },
1581
1582 addNpc: function (opts)
1583 {
1584 this.npcs.push({
1585 x: opts.x,
1586 y: opts.y,
1587 facingDeg: opts.facingDeg || 0,
1588 clip: opts.clip || "walk",
1589 animating: opts.animating !== false,
1590 time: opts.time || 0,
1591 label: opts.label || "npc"
1592 });
1593 },
1594
1595 load: function (bodyBase, bodyPpda, gearBase, gearPpda)
1596 {
1597 var self = this;
1598 return PpdaAtlasRuntime.loadSet(bodyBase, bodyPpda).then(function (body)
1599 {
1600 self.bodySet = body;
1601 if (!gearBase)
1602 {
1603 self.ready = true;
1604 return body;
1605 }
1606 return PpdaAtlasRuntime.loadSet(gearBase, gearPpda).then(function (gear)
1607 {
1608 PpdaLoader.assertCompatible(body.ppda, gear.ppda);
1609 self.gearSet = gear;
1610 self.ready = true;
1611 return body;
1612 });
1613 });
1614 },
1615
1616 update: function (dt)
1617 {
1618 for (var i = 0; i < this.npcs.length; i++)
1619 {
1620 if (this.npcs[i].animating)
1621 { this.npcs[i].time += dt; }
1622 }
1623 },
1624
1625 composedFor: function (npc, pitch, yaw)
1626 {
1627 if (!this.bodySet)
1628 { return null; }
1629 var clip = PpdaViewFrame.findClip(this.bodySet.ppda, npc.clip);
1630 var frameCount = clip ? clip.frame_count : 1;
1631 var frame = PpdaViewFrame.frameIndex(npc.time, this.bodySet.ppda.fps, frameCount);
1632 var key = npc.clip + "|" + frame + "|" + pitch + "|" + yaw;
1633 if (this.cache[key])
1634 { return this.cache[key]; }
1635 var composed = PpdaAtlasRuntime.composeView(
1636 this.bodySet,
1637 this.gearSet,
1638 npc.clip,
1639 frame,
1640 pitch,
1641 yaw
1642 );
1643 this.cache[key] = composed;
1644 var keys = Object.keys(this.cache);
1645 if (keys.length > 96)
1646 { delete this.cache[keys[0]]; }
1647 return composed;
1648 },
1649
1650 _ensureOverlay: function (w, h)
1651 {
1652 if (!this._overlay || this._overlay.width !== w || this._overlay.height !== h)
1653 {
1654 this._overlay = document.createElement("canvas");
1655 this._overlay.width = w;
1656 this._overlay.height = h;
1657 this._overlayCtx = this._overlay.getContext("2d");
1658 this._overlayImg = null;
1659 this._overlayTex = null;
1660 this._zbuf = new Float32Array(w * h);
1661 this._zbufW = w;
1662 this._zbufH = h;
1663 }
1664 },
1665
1666 /**
1667 * @param {Float32Array} wallDepthPerCol length = screen width
1668 */
1669 draw: function (scene, player, wallDepthPerCol)
1670 {
1671 if (!this.ready || !this.bodySet)
1672 { return; }
1673
1674 var w = Math.round(scene.real_size.x);
1675 var h = Math.round(scene.real_size.y);
1676 this._ensureOverlay(w, h);
1677 var ctx = this._overlayCtx;
1678 ctx.clearRect(0, 0, w, h);
1679 var img = ctx.createImageData(w, h);
1680 var data = img.data;
1681 var zbuf = this._zbuf;
1682 var i;
1683 for (i = 0; i < w * h; i++)
1684 {
1685 var col = i % w;
1686 zbuf[i] = wallDepthPerCol[col];
1687 }
1688
1689 var ppda = this.bodySet.ppda;
1690 var heightM = (ppda.height_milli || 2600) / 1000;
1691 var camDist = ppda.camera_distance || 10;
1692 var near = ppda.depth_near;
1693 var far = ppda.depth_far;
1694 var metersToWorld = this.worldScale;
1695 var tint = scene.npcLight != null ? scene.npcLight : 1;
1696
1697 var list = this.npcs.slice().sort(function (a, b)
1698 {
1699 var da = (a.x - player.x) * (a.x - player.x) + (a.y - player.y) * (a.y - player.y);
1700 var db = (b.x - player.x) * (b.x - player.x) + (b.y - player.y) * (b.y - player.y);
1701 return db - da;
1702 });
1703
1704 for (var ni = 0; ni < list.length; ni++)
1705 {
1706 var npc = list[ni];
1707 var dx = npc.x - player.x;
1708 var dy = npc.y - player.y;
1709 var dist = Math.sqrt(dx * dx + dy * dy);
1710 if (dist < 0.5 || dist > 800)
1711 { continue; }
1712
1713 var angleTo = Math.atan2(dy, dx);
1714 var delta = angleTo - player.rotation;
1715 while (delta > Math.PI) { delta -= Math.PI * 2; }
1716 while (delta < -Math.PI) { delta += Math.PI * 2; }
1717 if (Math.abs(delta) > Math.PI * 0.55)
1718 { continue; }
1719
1720 var relYaw = PpdaViewFrame.relativeYawDeg(player.x, player.y, npc.x, npc.y, npc.facingDeg);
1721 var yaw = PpdaViewFrame.pickYaw(relYaw, ppda.yaws);
1722 var pitch = Math.abs(player.pitch) < 0.25
1723 ? PpdaViewFrame.nearestInList(0, ppda.pitches)
1724 : PpdaViewFrame.pickPitch(player.pitch, ppda.pitches);
1725
1726 var composed = this.composedFor(npc, pitch, yaw);
1727 if (!composed)
1728 { continue; }
1729
1730 var spriteH = (World.size * heightM) * (h / dist) * 0.5;
1731 var aspect = composed.width / Math.max(1, composed.height);
1732 var spriteW = spriteH * aspect;
1733 var screenX = (w / 2) + (delta / (Math.PI / 3)) * (w / 2);
1734 var screenY = h / 2 + (-player.pitch * h * 0.25);
1735 var left = screenX - spriteW / 2;
1736 var top = screenY - spriteH / 2;
1737 var cols = Math.max(1, Math.ceil(spriteW));
1738
1739 for (var c = 0; c < cols; c++)
1740 {
1741 var sx = Math.floor(left + c);
1742 if (sx < 0 || sx >= w)
1743 { continue; }
1744 var u = (c + 0.5) / cols;
1745 var texX = Math.min(composed.width - 1, Math.max(0, Math.floor(u * composed.width)));
1746 var y0 = Math.floor(top);
1747 var y1 = Math.ceil(top + spriteH);
1748
1749 for (var sy = y0; sy < y1; sy++)
1750 {
1751 if (sy < 0 || sy >= h)
1752 { continue; }
1753 var v = (sy - top + 0.5) / spriteH;
1754 if (v < 0 || v >= 1)
1755 { continue; }
1756 var texY = Math.min(composed.height - 1, Math.max(0, Math.floor(v * composed.height)));
1757 var pi = texY * composed.width + texX;
1758 var a = composed.lit[pi * 4 + 3];
1759 if (!a || composed.depthAlpha[pi] === 0)
1760 { continue; }
1761
1762 var depthM = near + (composed.depthGray[pi] / 65535) * (far - near);
1763 var pixelDist = dist + (depthM - camDist) * metersToWorld;
1764 if (pixelDist < 0.05)
1765 { pixelDist = 0.05; }
1766
1767 var zi = sy * w + sx;
1768 if (pixelDist >= zbuf[zi])
1769 { continue; }
1770 zbuf[zi] = pixelDist;
1771
1772 var o = zi * 4;
1773 data[o] = Math.min(255, Math.round(composed.lit[pi * 4] * tint));
1774 data[o + 1] = Math.min(255, Math.round(composed.lit[pi * 4 + 1] * tint));
1775 data[o + 2] = Math.min(255, Math.round(composed.lit[pi * 4 + 2] * tint));
1776 data[o + 3] = a;
1777 }
1778 }
1779 }
1780
1781 ctx.putImageData(img, 0, 0);
1782 var glc = scene.glContext;
1783 // Re-upload every frame (content changes).
1784 if (this._overlayTex)
1785 {
1786 var gl = glc.gl;
1787 gl.bindTexture(gl.TEXTURE_2D, this._overlayTex);
1788 gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, this._overlay);
1789 }
1790 else
1791 {
1792 var prevMin = glc.textureMinFilter;
1793 var prevMag = glc.textureMagFilter;
1794 glc.setDefaultTextureFilter(glc.gl.NEAREST, glc.gl.NEAREST);
1795 this._overlayTex = glc.getTexture(this._overlay);
1796 glc.textureMinFilter = prevMin;
1797 glc.textureMagFilter = prevMag;
1798 }
1799
1800 glc.drawSprite({
1801 texture: this._overlayTex,
1802 x: w / 2,
1803 y: h / 2,
1804 w: w,
1805 h: h,
1806 rotationDeg: 0,
1807 alpha: 1,
1808 uvRect: { u0: 0, v0: 0, u1: 1, v1: 1 }
1809 });
1810 }
1811};
1812
1813/*
1814 * End File:
1815 * /workspace/raytracer-work/src/npc.js
1816 */
1817
1818/*
1819 * Start File:
1820 * /workspace/raytracer-work/src/raycastScene.js
1821 */
1822/**
1823 * Fullscreen WebGL raycast view on frameworkv3.
1824 * Wall strips: one source texel column per screen column, NEAREST, tinted for shading.
1825 */
1826class RaycastScene extends Scene
1827{
1828 constructor (width, height)
1829 {
1830 super(0, 0, width, height, Scene.DisplayModes.absolute);
1831 this.backgroundColor = { r: 0, g: 0, b: 0 };
1832 this.tintShader = null;
1833 this.solidTexture = null;
1834 this.gunImages = null;
1835 this._lookBound = false;
1836 this.floorTexMap = null;
1837 this._floorCanvas = null;
1838 this._floorCtx = null;
1839 this._floorTex = null;
1840 }
1841
1842 onLoad ()
1843 {
1844 const gl = this.glContext.gl;
1845 this.glContext.setDefaultTextureFilter(gl.NEAREST, gl.NEAREST);
1846
1847 this.tintShader = new Shader(Shader.DEFAULT_VERT, [
1848 "precision mediump float;",
1849 "uniform sampler2D u_texture;",
1850 "uniform float u_alpha;",
1851 "uniform vec3 u_tint;",
1852 "varying vec2 v_texCoord;",
1853 "void main() {",
1854 " vec4 color = texture2D(u_texture, v_texCoord);",
1855 " gl_FragColor = vec4(color.rgb * u_tint, color.a * u_alpha);",
1856 "}"
1857 ].join("\n"));
1858
1859 // 1x1 white for solid (untextured) walls.
1860 const c = document.createElement("canvas");
1861 c.width = 1;
1862 c.height = 1;
1863 const ctx = c.getContext("2d");
1864 ctx.fillStyle = "#ffffff";
1865 ctx.fillRect(0, 0, 1, 1);
1866 this.solidTexture = this.glContext.getTexture(c);
1867
1868 this.bindPointerLock();
1869 }
1870
1871 bindPointerLock ()
1872 {
1873 if (this._lookBound)
1874 { return; }
1875 this._lookBound = true;
1876 const canvas = this.cv_canvas;
1877 canvas.addEventListener("click", function ()
1878 {
1879 if (canvas.requestPointerLock)
1880 { canvas.requestPointerLock(); }
1881 });
1882 document.addEventListener("mousemove", function (e)
1883 {
1884 if (document.pointerLockElement === canvas)
1885 { Player.applyLookDelta(e.movementX || 0, e.movementY || 0); }
1886 });
1887 }
1888
1889 update (deltaTime)
1890 {
1891 super.update(deltaTime);
1892 Player.update(deltaTime);
1893 if (typeof NpcSystem !== "undefined")
1894 { NpcSystem.update(deltaTime); }
1895 if (Player.horizontalResolution > this.real_size.x)
1896 { Player.horizontalResolution = this.real_size.x; }
1897 }
1898
1899 draw ()
1900 {
1901 if (this.destroyed || !this.glContext)
1902 { return; }
1903
1904 this.g_fixSize();
1905 const glc = this.glContext;
1906 glc.endOffscreenPass();
1907 glc.clear(0, 0, 0, 1);
1908
1909 this.drawFloorCeiling();
1910 const wallDepth = this.drawColumns();
1911 if (typeof NpcSystem !== "undefined" && NpcSystem.ready)
1912 { NpcSystem.draw(this, Player, wallDepth); }
1913 this.drawGun();
1914 }
1915
1916
1917 setFloorTextures (texMap)
1918 {
1919 this.floorTexMap = texMap;
1920 }
1921
1922 drawFloorCeiling ()
1923 {
1924 if (!this.floorTexMap || !World.level || !World.level.floors)
1925 { return; }
1926 const w = Math.max(1, Math.round(this.real_size.x));
1927 const h = Math.max(1, Math.round(this.real_size.y));
1928 if (!this._floorCanvas || this._floorCanvas.width !== w || this._floorCanvas.height !== h)
1929 {
1930 this._floorCanvas = document.createElement("canvas");
1931 this._floorCanvas.width = w;
1932 this._floorCanvas.height = h;
1933 this._floorCtx = this._floorCanvas.getContext("2d");
1934 this._floorTex = null;
1935 }
1936 const img = this._floorCtx.createImageData(w, h);
1937 FloorCast.render(img, w, h, Player, World.level, this.floorTexMap, World.size);
1938 this._floorCtx.putImageData(img, 0, 0);
1939 const glc = this.glContext;
1940 const gl = glc.gl;
1941 if (this._floorTex)
1942 {
1943 gl.bindTexture(gl.TEXTURE_2D, this._floorTex);
1944 gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, this._floorCanvas);
1945 }
1946 else
1947 {
1948 glc.setDefaultTextureFilter(gl.NEAREST, gl.NEAREST);
1949 this._floorTex = glc.getTexture(this._floorCanvas);
1950 }
1951 glc.drawSprite({
1952 texture: this._floorTex,
1953 x: w / 2,
1954 y: h / 2,
1955 w: w,
1956 h: h,
1957 rotationDeg: 0,
1958 alpha: 1,
1959 uvRect: { u0: 0, v0: 0, u1: 1, v1: 1 }
1960 });
1961 }
1962
1963 faceLight (dir)
1964 {
1965 switch (dir)
1966 {
1967 case "east": return 0.9;
1968 case "west": return 0.8;
1969 case "south": return 0.7;
1970 default: return 1.0;
1971 }
1972 }
1973
1974 drawColumns ()
1975 {
1976 const glc = this.glContext;
1977 const w = this.real_size.x;
1978 const h = this.real_size.y;
1979 const cols = Math.max(1, Math.floor(Player.horizontalResolution));
1980 const rad = Math.PI / (cols * 2);
1981 const widthLine = w / cols;
1982 const wallDepth = new Float32Array(Math.max(1, Math.round(w)));
1983 for (var zi = 0; zi < wallDepth.length; zi++)
1984 { wallDepth[zi] = 1e9; }
1985
1986 for (var i = 0; i < cols; i++)
1987 {
1988 var offsetP = -0.5 + (i / cols);
1989 var offset = offsetP * cols;
1990 var rotationalOffset = offset * rad;
1991 var rot = Player.rotation + rotationalOffset;
1992 if (rot < 0) { rot += Math.PI * 2; }
1993 if (rot > Math.PI * 2) { rot -= Math.PI * 2; }
1994
1995 var rayHit = World.rayCast(Player.x, Player.y, rot);
1996 if (!rayHit || !rayHit.tile)
1997 { continue; }
1998
1999 var light = this.faceLight(rayHit.dir);
2000 var deltaAngle = Player.rotation - rot;
2001 var dist = rayHit.distance * Math.cos(deltaAngle);
2002 if (dist < 0.0001)
2003 { dist = 0.0001; }
2004
2005 var xLine = i * widthLine;
2006 var wallH = (World.size * h) / dist;
2007 var yCenter = (h / 2) + (-Player.pitch * (World.size * h - wallH) * 0.005);
2008
2009 var tint = [light, light, light];
2010 var htmlImage = null;
2011 var texW = 1;
2012
2013 // Z-buffer for NPC occlusion (per screen pixel column).
2014 var x0 = Math.max(0, Math.floor(xLine));
2015 var x1 = Math.min(wallDepth.length, Math.ceil(xLine + widthLine));
2016 for (var xz = x0; xz < x1; xz++)
2017 {
2018 if (dist < wallDepth[xz])
2019 { wallDepth[xz] = dist; }
2020 }
2021
2022 if (rayHit.tile.Image && rayHit.tile.Image.g_image)
2023 {
2024 htmlImage = rayHit.tile.Image.g_image;
2025 texW = htmlImage.width || 1;
2026 var uv = textureColumnUv(rayHit.tileX, texW);
2027 glc.drawSprite({
2028 texture: glc.getTexture(htmlImage),
2029 x: xLine + widthLine / 2,
2030 y: yCenter,
2031 w: widthLine,
2032 h: wallH,
2033 rotationDeg: 0,
2034 alpha: 1,
2035 uvRect: { u0: uv.u0, v0: uv.v0, u1: uv.u1, v1: uv.v1 },
2036 shader: this.tintShader,
2037 uniforms: { u_tint: tint }
2038 });
2039 }
2040 else
2041 {
2042 var c = rayHit.tile.Color || { R: 255, G: 255, B: 255 };
2043 tint = [(c.R / 255) * light, (c.G / 255) * light, (c.B / 255) * light];
2044 glc.drawSprite({
2045 texture: this.solidTexture,
2046 x: xLine + widthLine / 2,
2047 y: yCenter,
2048 w: widthLine,
2049 h: wallH,
2050 rotationDeg: 0,
2051 alpha: 1,
2052 uvRect: { u0: 0, v0: 0, u1: 1, v1: 1 },
2053 shader: this.tintShader,
2054 uniforms: { u_tint: tint }
2055 });
2056 }
2057 }
2058 return wallDepth;
2059 }
2060
2061 drawGun ()
2062 {
2063 const images = this.game && this.game.images;
2064 if (!images)
2065 { return; }
2066 var gunImg = null;
2067 switch (Player.currentGun)
2068 {
2069 case 0: gunImg = images.shotgun; break;
2070 case 1: gunImg = images.machinegun; break;
2071 case 2: gunImg = images.pulserifle; break;
2072 }
2073 if (!gunImg || !gunImg.g_image)
2074 { return; }
2075
2076 var p = this.real_size.y / 1080;
2077 var gw = p * gunImg.g_image.width;
2078 var gh = p * gunImg.g_image.height;
2079 var gx = this.real_size.x * Player.gunX + gw / 2;
2080 var gy = this.real_size.y * Player.gunY + gh / 2;
2081
2082 gunImg.draw(
2083 this,
2084 gx,
2085 gy,
2086 gw,
2087 gh,
2088 0,
2089 false,
2090 false,
2091 1,
2092 0
2093 );
2094 }
2095}
2096
2097/*
2098 * End File:
2099 * /workspace/raytracer-work/src/raycastScene.js
2100 */
2101
2102/*
2103 * Start File:
2104 * /workspace/raytracer-work/src/main.js
2105 */
2106console.log("Raytracer starting");
2107var game = new Game();
2108var levelPack = null;
2109
2110function queryLevelParam ()
2111{
2112 try
2113 {
2114 var q = new URLSearchParams(window.location.search);
2115 return q.get("level");
2116 }
2117 catch (e)
2118 { return null; }
2119}
2120
2121function extractTexPixels (img)
2122{
2123 var c = document.createElement("canvas");
2124 c.width = img.width;
2125 c.height = img.height;
2126 var ctx = c.getContext("2d");
2127 ctx.drawImage(img, 0, 0);
2128 return { rgba: ctx.getImageData(0, 0, c.width, c.height).data, w: c.width, h: c.height };
2129}
2130
2131function applyLevel (pack, indexOrId, scene)
2132{
2133 World.loadPack(pack);
2134 World.loadLevel(indexOrId);
2135 Player.resetToSpawn();
2136 NpcSystem.initEmpty();
2137 var npcs = World.level.npcs || [];
2138 for (var i = 0; i < npcs.length; i++)
2139 { NpcSystem.addNpc(npcs[i]); }
2140
2141 var body = npcs[0] && npcs[0].body ? npcs[0].body : "paperdolls/male-body/";
2142 var bodyPpda = npcs[0] && npcs[0].bodyPpda ? npcs[0].bodyPpda : "male-body-atlas.ppda";
2143 var gear = npcs[0] && npcs[0].gear ? npcs[0].gear : "paperdolls/male-sword/";
2144 var gearPpda = npcs[0] && npcs[0].gearPpda ? npcs[0].gearPpda : "male-sword-atlas.ppda";
2145 if (npcs.length)
2146 {
2147 NpcSystem.load(body, bodyPpda, gear, gearPpda).catch(function (err)
2148 { console.error("Paperdoll load failed", err); });
2149 }
2150 var title = document.getElementById("level-label");
2151 if (title)
2152 { title.textContent = World.level.name + " (" + (World.levelIndex + 1) + "/" + pack.levels.length + ")"; }
2153}
2154
2155window.onload = function ()
2156{
2157 game.preloadImagesThenStart(
2158 [
2159 { name: "stone", url: "images/stone.png" },
2160 { name: "wood", url: "images/wood.png" },
2161 { name: "shotgun", url: "images/shotgun.png" },
2162 { name: "machinegun", url: "images/machinegun.png" },
2163 { name: "pulserifle", url: "images/pulserifle.png" }
2164 ],
2165 function ()
2166 {
2167 Tiles.bindImages(game.images);
2168
2169 var packPromise;
2170 var q = null;
2171 try { q = new URLSearchParams(window.location.search); } catch (e) {}
2172 if (q && q.get("playtest") === "1")
2173 {
2174 packPromise = Promise.resolve().then(function ()
2175 {
2176 var raw = localStorage.getItem("raytracer-levels-v1");
2177 if (!raw) throw new Error("Geen editor-playtest in localStorage");
2178 return raw;
2179 });
2180 }
2181 else
2182 {
2183 packPromise = fetch("levels.json").then(function (r)
2184 {
2185 if (!r.ok)
2186 { throw new Error("levels.json HTTP " + r.status); }
2187 return r.text();
2188 });
2189 }
2190 packPromise.then(function (text)
2191 {
2192 levelPack = LevelFormat.parse(text);
2193 var w = Math.max(320, window.innerWidth - 2);
2194 var h = Math.max(240, window.innerHeight - 2);
2195 var scene = new RaycastScene(w, h);
2196 scene.npcLight = 1;
2197 scene.setFloorTextures({
2198 stone: extractTexPixels(game.images.stone.g_image),
2199 wood: extractTexPixels(game.images.wood.g_image)
2200 });
2201 game.loadScene(scene);
2202
2203 var want = queryLevelParam();
2204 var idx = LevelFormat.findLevelIndex(levelPack, want);
2205 if (idx < 0)
2206 { idx = 0; }
2207 applyLevel(levelPack, idx, scene);
2208
2209 window.addEventListener("resize", function ()
2210 {
2211 scene.size.x = Math.max(320, window.innerWidth - 2);
2212 scene.size.y = Math.max(240, window.innerHeight - 2);
2213 });
2214
2215 var prev = document.getElementById("btn-prev-level");
2216 var next = document.getElementById("btn-next-level");
2217 if (prev)
2218 {
2219 prev.onclick = function ()
2220 {
2221 var i = (World.levelIndex - 1 + levelPack.levels.length) % levelPack.levels.length;
2222 applyLevel(levelPack, i, scene);
2223 };
2224 }
2225 if (next)
2226 {
2227 next.onclick = function ()
2228 {
2229 var i = (World.levelIndex + 1) % levelPack.levels.length;
2230 applyLevel(levelPack, i, scene);
2231 };
2232 }
2233 }).catch(function (err)
2234 {
2235 console.error(err);
2236 alert("Kon levels.json niet laden: " + err.message);
2237 });
2238 }
2239 );
2240};
2241
2242/*
2243 * End File:
2244 * /workspace/raytracer-work/src/main.js
2245 */