Hugging Face's logo

Spaces:
axonis22
/
muse-engine-32
Running

App Files Community
muse-engine-32 / engine /engine.js
axonis22's picture
axonis22
Muse Engine 32: your FBX/GLB scene as the level, skinned characters, Model check, save/load setup
6c78aa4 verified
Raw History Blame Contribute Delete
219 kB
// Muse Breaker Engine - Phase 29 Combat Feel
// Muse Glimmer - own engine
// Raw WebGL1, no libraries
// Licence: MIT (see LICENSE). The Axonis name and logo are not covered by the MIT licence.
// Muse Engine 29 - Look Picker build: Phase 29 engine + [e29 coach] look/config hooks (search '[e29]'; see muse-authored/FIXES.md)
// Muse Engine 30 - Scene Level: loaded scenes become the level (mesh colliders, units/up-axis), crosshair + pyramid fixes (search '[e30]')
// Muse Engine 32 RC - Save / Load + Model Check (search '[e32]'): setup JSON, drag-and-drop, model check, root-motion strip, perf pass.
// Muse Engine 31 - Animated Characters: skinned GLB/FBX enemies, GPU skinning, clip roles + crossfade, capsule + head/body hitboxes (search '[e31]')
// Phase 29: combat feel — hostile solid AABB (no wall-clip) + fall-then-boom death
// Phase 28: movement pass — land on tops, coyote/buffer jump, step-up/mantle, ladder + parkour route
// Phase 27: Mooring Bollard mesh; Phase 26 NM; Phase 25 TEX; Phase 24 Mitsh/Mitch base
// Phase 21.1 + coach: ammo-in-box pickups; night bulbs self-glow; nearest+farthest lamp pair
// coach: per-axis AABB + height-gated sides + walkable tops
(() => {
const canvas = document.getElementById('muse-canvas');
const hud = document.getElementById('hud');
if (hud) hud.textContent = 'Muse Glimmer · Engine 32 RC · Save / Load + Model Check'; // [e31]; [e32] RC label
const creditEl = document.getElementById('credit');
const gl = canvas.getContext('webgl', { antialias: true }) || canvas.getContext('experimental-webgl');
if (!gl) {
document.body.innerHTML = '<pre>WebGL not supported</pre>';
return;
}
function resize() {
const dpr = Math.min(window.devicePixelRatio || 1, 2);
const w = Math.floor(canvas.clientWidth * dpr);
const h = Math.floor(canvas.clientHeight * dpr);
if (canvas.width !== w || canvas.height !== h) {
canvas.width = w;
canvas.height = h;
gl.viewport(0, 0, w, h);
}
}
window.addEventListener('resize', resize);
resize();
// [e31] GPU skinning palette: 3 vec4 rows per joint (affine 3x4). Keep ~24 vectors for the other vertex uniforms.
const E31_MAXVU = gl.getParameter(gl.MAX_VERTEX_UNIFORM_VECTORS) || 128;
const E31_MAX_BONES = Math.max(8, Math.min(60, Math.floor((E31_MAXVU - 24) / 3), (+((location.search.match(/[?&]maxbones=(\d+)/) || [])[1]) || 60))); // ?maxbones=N simulates a smaller GPU
const E31_SKIN_GLSL = `
attribute vec4 aSkinIdx;
attribute vec4 aSkinW;
uniform float uSkinOn;
uniform vec4 uBones[${E31_MAX_BONES * 3}];
void skinRows(out vec4 r0, out vec4 r1, out vec4 r2){
ivec4 bi = ivec4(aSkinIdx + 0.5) * 3;
r0 = uBones[bi.x] * aSkinW.x + uBones[bi.y] * aSkinW.y + uBones[bi.z] * aSkinW.z + uBones[bi.w] * aSkinW.w;
r1 = uBones[bi.x + 1] * aSkinW.x + uBones[bi.y + 1] * aSkinW.y + uBones[bi.z + 1] * aSkinW.z + uBones[bi.w + 1] * aSkinW.w;
r2 = uBones[bi.x + 2] * aSkinW.x + uBones[bi.y + 2] * aSkinW.y + uBones[bi.z + 2] * aSkinW.z + uBones[bi.w + 2] * aSkinW.w;
}
`;
const vsSource = `
attribute vec3 aPos;
attribute vec3 aNormal;
attribute vec2 aUV;
attribute vec4 aTangent;
${E31_SKIN_GLSL}
uniform mat4 uModel;
uniform mat4 uView;
uniform mat4 uProj;
uniform mat4 uLightMVP;
varying vec3 vNormal;
varying vec3 vWorldPos;
varying vec4 vShadowCoord;
varying vec2 vUV;
varying vec3 vT;
varying vec3 vB;
varying vec3 vN;
void main(){
vec3 sP = aPos; vec3 sN = aNormal; vec3 sT = aTangent.xyz;
if (uSkinOn > 0.5) { // [e31] GPU skinning (4 weights)
vec4 r0; vec4 r1; vec4 r2; skinRows(r0, r1, r2);
vec4 p4 = vec4(aPos, 1.0);
sP = vec3(dot(r0, p4), dot(r1, p4), dot(r2, p4));
sN = vec3(dot(r0.xyz, aNormal), dot(r1.xyz, aNormal), dot(r2.xyz, aNormal));
sT = vec3(dot(r0.xyz, aTangent.xyz), dot(r1.xyz, aTangent.xyz), dot(r2.xyz, aTangent.xyz));
}
vec4 world = uModel * vec4(sP, 1.0);
vWorldPos = world.xyz;
mat3 nMat = mat3(uModel);
vec3 N = normalize(nMat * sN);
vNormal = N;
vN = N;
vec3 T = nMat * sT;
T = normalize(T - N * dot(N, T));
float tw = aTangent.w == 0.0 ? 1.0 : aTangent.w;
vT = T;
vB = cross(N, T) * tw;
vShadowCoord = uLightMVP * world;
vUV = aUV;
gl_Position = uProj * uView * world;
}
`;
const fsSource = `
precision mediump float;
varying vec3 vNormal;
varying vec3 vWorldPos;
varying vec4 vShadowCoord;
varying vec2 vUV;
varying vec3 vT;
varying vec3 vB;
varying vec3 vN;
uniform vec3 uLightDir;
uniform float uAmbientAmt;
uniform float uDirAmt;
uniform vec3 uBaseColor;
uniform vec3 uSpecColor;
uniform float uShininess;
uniform vec3 uPointPos;
uniform vec3 uPointColor;
uniform float uPointRadius;
uniform vec3 uPointPos2;
uniform vec3 uPointColor2;
uniform float uPointRadius2;
uniform float uAlpha;
uniform sampler2D uShadowMap;
uniform float uShadowBias;
uniform float uUseShadow;
uniform vec3 uCamPos;
uniform vec3 uFogColor;
uniform float uFogNear;
uniform float uFogFar;
uniform sampler2D uAlbedo;
uniform float uUseTex;
uniform sampler2D uNormalMap;
uniform float uHasNormalMap;
uniform float uNormalScale;
void main(){
vec3 N = normalize(vNormal);
if (uHasNormalMap > 0.5) {
vec3 mapN = texture2D(uNormalMap, vUV).xyz * 2.0 - 1.0;
mapN.xy *= uNormalScale;
mapN = normalize(mapN);
vec3 T = normalize(vT);
vec3 B = normalize(vB);
vec3 Nn = normalize(vN);
N = normalize(mat3(T, B, Nn) * mapN);
}
vec3 Ldir = normalize(uLightDir);
float diffDir = max(dot(N, Ldir), 0.0);
vec3 colDir = uBaseColor * uAmbientAmt;
vec3 shadowCoord = vShadowCoord.xyz / vShadowCoord.w;
shadowCoord = shadowCoord * 0.5 + 0.5;
float shadow = 1.0;
if (uUseShadow > 0.5 && shadowCoord.x >= 0.0 && shadowCoord.x <= 1.0 && shadowCoord.y >= 0.0 && shadowCoord.y <= 1.0 && shadowCoord.z >= 0.0 && shadowCoord.z <= 1.0) {
float closest = texture2D(uShadowMap, shadowCoord.xy).r;
float currentDepth = shadowCoord.z - uShadowBias;
float s0 = (currentDepth <= closest) ? 1.0 : 0.35;
float texel = 1.0 / 1024.0;
float s1 = (currentDepth <= texture2D(uShadowMap, shadowCoord.xy + vec2(texel, 0.0)).r) ? 1.0 : 0.35;
float s2 = (currentDepth <= texture2D(uShadowMap, shadowCoord.xy + vec2(0.0, texel)).r) ? 1.0 : 0.35;
shadow = (s0 + s1 + s2) / 3.0;
}
colDir += uBaseColor * uDirAmt * diffDir * shadow;
vec3 toLight = uPointPos - vWorldPos;
float dist = length(toLight);
float att = 1.0 / (1.0 + 0.09*dist + 0.032*dist*dist);
float pointFactor = 0.0;
if (dist < uPointRadius) {
vec3 Lpoint = normalize(toLight);
pointFactor = max(dot(N, Lpoint), 0.0) * att;
}
vec3 colPoint = uPointColor * pointFactor;
vec3 toLight2 = uPointPos2 - vWorldPos;
float dist2 = length(toLight2);
float att2 = 1.0 / (1.0 + 0.09*dist2 + 0.032*dist2*dist2);
float pointFactor2 = 0.0;
if (dist2 < uPointRadius2) {
vec3 Lpoint2 = normalize(toLight2);
pointFactor2 = max(dot(N, Lpoint2), 0.0) * att2;
}
vec3 colPoint2 = uPointColor2 * pointFactor2;
vec3 col = colDir + colPoint + colPoint2;
vec3 V = normalize(-vWorldPos + uCamPos);
vec3 H = normalize(Ldir + V);
float spec = pow(max(dot(N, H), 0.0), uShininess);
col += uSpecColor * spec * 0.6;
if (uUseTex > 0.5) {
vec3 tex = texture2D(uAlbedo, vUV).rgb;
col *= tex;
}
float fogDist = length(vWorldPos - uCamPos);
float fogFactor = clamp((fogDist - uFogNear) / (uFogFar - uFogNear), 0.0, 1.0);
col = mix(col, uFogColor, fogFactor);
gl_FragColor = vec4(col, uAlpha);
}
`;
const vsDepth = `
attribute vec3 aPos;
${E31_SKIN_GLSL}
uniform mat4 uModel;
uniform mat4 uLightVP;
void main(){
vec3 sP = aPos;
if (uSkinOn > 0.5) { vec4 r0; vec4 r1; vec4 r2; skinRows(r0, r1, r2); vec4 p4 = vec4(aPos, 1.0); sP = vec3(dot(r0, p4), dot(r1, p4), dot(r2, p4)); } // [e31]
gl_Position = uLightVP * uModel * vec4(sP, 1.0);
}
`;
const fsDepth = `
precision mediump float;
void main(){ gl_FragColor = vec4(0.0,0.0,0.0,1.0); }
`;
function compile(type, source) {
const s = gl.createShader(type);
gl.shaderSource(s, source);
gl.compileShader(s);
if (!gl.getShaderParameter(s, gl.COMPILE_STATUS)) {
console.error(gl.getShaderInfoLog(s));
}
return s;
}
// [e31] shader variants: the skin branch is compiled out of the plain programs (a uniform branch still costs every vertex on
// SwiftShader / low-end GPUs) and compiled in unconditionally for the skinned variants used only by skinned character parts.
function e31Variant(src, skinned){ return src.split('if (uSkinOn > 0.5) {').join(skinned ? 'if (true) {' : 'if (false) {'); }
const program = gl.createProgram();
gl.attachShader(program, compile(gl.VERTEX_SHADER, e31Variant(vsSource, false))); // [e31] plain variant
gl.attachShader(program, compile(gl.FRAGMENT_SHADER, fsSource));
gl.bindAttribLocation(program, 0, 'aPos'); // [e31] keep attribute 0 = always-enabled position (skin attributes are optional)
gl.linkProgram(program);
if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
console.error(gl.getProgramInfoLog(program));
}
const depthProgram = gl.createProgram();
gl.attachShader(depthProgram, compile(gl.VERTEX_SHADER, e31Variant(vsDepth, false))); // [e31] plain variant
gl.attachShader(depthProgram, compile(gl.FRAGMENT_SHADER, fsDepth));
gl.bindAttribLocation(depthProgram, 0, 'aPos'); // [e31]
gl.linkProgram(depthProgram);
// [e31] uniform mirror: the engine keeps setting uniforms through the plain-program locations. While a skinned variant is
// current those calls are translated to it, and each variant is brought up to date (and back) when it is switched in.
const E31U = (function(){
const info = new Map(), plainLoc = new Map(), recs = new Map(), baseOf = new Map(), skinLoc = new Map(), applied = new Map(), dirty = new Map();
const _gul = gl.getUniformLocation.bind(gl), _use = gl.useProgram.bind(gl), orig = {};
let cur = null, ver = 0;
gl.getUniformLocation = function(p, name){
const l = _gul(p, name);
if (l && (p === program || p === depthProgram)) { info.set(l, { base: p, name: name }); if (!plainLoc.has(p)) plainLoc.set(p, new Map()); plainLoc.get(p).set(name, l); }
return l;
};
function locIn(skin, name){ const m = skinLoc.get(skin); if (!m.has(name)) m.set(name, _gul(skin, name)); return m.get(name); }
function call(l, r){ if (!l || !r) return; const f = orig[r.fn]; if (r.mat) f(l, r.a, r.buf); else if (r.vec) f(l, r.buf); else f(l, r.a, r.b, r.c, r.d); }
['uniform1f', 'uniform2f', 'uniform3f', 'uniform4f', 'uniform1i', 'uniform1fv', 'uniform2fv', 'uniform3fv', 'uniform4fv', 'uniformMatrix3fv', 'uniformMatrix4fv'].forEach(function(fn){
const o = orig[fn] = gl[fn].bind(gl), mat = fn.indexOf('Matrix') >= 0, vec = !mat && fn.slice(-1) === 'v';
gl[fn] = function(loc, a, b, c, d){
const I = loc ? info.get(loc) : null;
if (!I) return o(loc, a, b, c, d);
let R = recs.get(I.base); if (!R) { R = new Map(); recs.set(I.base, R); }
let r = R.get(I.name); if (!r) { r = { fn: fn, mat: mat, vec: vec, a: 0, b: 0, c: 0, d: 0, buf: null, ver: 0 }; R.set(I.name, r); }
r.fn = fn; r.mat = mat; r.vec = vec; r.ver = ++ver;
if (mat || vec) { const src = mat ? b : a; if (!r.buf || r.buf.length !== src.length) r.buf = new Float32Array(src.length); r.buf.set(src); r.a = a; }
else { r.a = a; r.b = b; r.c = c; r.d = d; }
if (baseOf.get(cur) === I.base) { call(locIn(cur, I.name), r); applied.get(cur).set(I.name, r.ver); dirty.get(I.base).add(I.name); return; }
return o(loc, a, b, c, d);
};
});
gl.useProgram = function(p){
_use(p); cur = p;
const base = baseOf.get(p);
if (base) { const R = recs.get(base), A = applied.get(p); if (R) R.forEach(function(r, name){ if ((A.get(name) || 0) < r.ver) { call(locIn(p, name), r); A.set(name, r.ver); } }); }
else if (dirty.has(p) && dirty.get(p).size) { const R = recs.get(p), L = plainLoc.get(p) || new Map(); dirty.get(p).forEach(function(name){ call(L.get(name), R.get(name)); }); dirty.get(p).clear(); }
};
return { register: function(skin, base){ baseOf.set(skin, base); skinLoc.set(skin, new Map()); applied.set(skin, new Map()); if (!dirty.has(base)) dirty.set(base, new Set()); } };
})();
const aPos = gl.getAttribLocation(program, 'aPos');
const aNormal = gl.getAttribLocation(program, 'aNormal');
const aUV = gl.getAttribLocation(program, 'aUV');
const uModel = gl.getUniformLocation(program, 'uModel');
const uView = gl.getUniformLocation(program, 'uView');
const uProj = gl.getUniformLocation(program, 'uProj');
const uLightMVP = gl.getUniformLocation(program, 'uLightMVP');
const uLightDir = gl.getUniformLocation(program, 'uLightDir');
const uAmbientAmt = gl.getUniformLocation(program, 'uAmbientAmt');
const uDirAmt = gl.getUniformLocation(program, 'uDirAmt');
const uBaseColor = gl.getUniformLocation(program, 'uBaseColor');
const uSpecColor = gl.getUniformLocation(program, 'uSpecColor');
const uShininess = gl.getUniformLocation(program, 'uShininess');
const uPointPos = gl.getUniformLocation(program, 'uPointPos');
const uPointColor = gl.getUniformLocation(program, 'uPointColor');
const uPointRadius = gl.getUniformLocation(program, 'uPointRadius');
const uPointPos2 = gl.getUniformLocation(program, 'uPointPos2');
const uPointColor2 = gl.getUniformLocation(program, 'uPointColor2');
const uPointRadius2 = gl.getUniformLocation(program, 'uPointRadius2');
const uAlpha = gl.getUniformLocation(program, 'uAlpha');
const uShadowMap = gl.getUniformLocation(program, 'uShadowMap');
const uShadowBias = gl.getUniformLocation(program, 'uShadowBias');
const uUseShadow = gl.getUniformLocation(program, 'uUseShadow');
const uCamPos = gl.getUniformLocation(program, 'uCamPos');
const uFogColor = gl.getUniformLocation(program, 'uFogColor');
const uFogNear = gl.getUniformLocation(program, 'uFogNear');
const uFogFar = gl.getUniformLocation(program, 'uFogFar');
const uAlbedo = gl.getUniformLocation(program, 'uAlbedo');
const uUseTex = gl.getUniformLocation(program, 'uUseTex');
const aTangent = gl.getAttribLocation(program, 'aTangent');
const uNormalMap = gl.getUniformLocation(program, 'uNormalMap');
const uHasNormalMap = gl.getUniformLocation(program, 'uHasNormalMap');
const uNormalScale = gl.getUniformLocation(program, 'uNormalScale');
const d_aPos = gl.getAttribLocation(depthProgram, 'aPos');
const d_uModel = gl.getUniformLocation(depthProgram, 'uModel');
const d_uLightVP = gl.getUniformLocation(depthProgram, 'uLightVP');
// [e31] skinned variants: same attribute slots as the plain programs, skin attributes on the next two free slots
const E31_SKIN_SLOTS = (function(){ let m = 0; [aPos, aNormal, aUV, aTangent].forEach(function(l){ if (l > m) m = l; }); return [m + 1, m + 2]; })();
function e31LinkSkin(vs, fs, binds){ const p = gl.createProgram(); gl.attachShader(p, compile(gl.VERTEX_SHADER, e31Variant(vs, true))); gl.attachShader(p, compile(gl.FRAGMENT_SHADER, fs));
binds.forEach(function(b){ if (b[1] >= 0) gl.bindAttribLocation(p, b[1], b[0]); }); gl.bindAttribLocation(p, E31_SKIN_SLOTS[0], 'aSkinIdx'); gl.bindAttribLocation(p, E31_SKIN_SLOTS[1], 'aSkinW');
gl.linkProgram(p); if (!gl.getProgramParameter(p, gl.LINK_STATUS)) console.error(gl.getProgramInfoLog(p)); return p; }
const skinProgram = e31LinkSkin(vsSource, fsSource, [['aPos', aPos], ['aNormal', aNormal], ['aUV', aUV], ['aTangent', aTangent]]);
const skinDepthProgram = e31LinkSkin(vsDepth, fsDepth, [['aPos', d_aPos]]);
E31U.register(skinProgram, program); E31U.register(skinDepthProgram, depthProgram);
const aSkinIdx = E31_SKIN_SLOTS[0], aSkinW = E31_SKIN_SLOTS[1], d_aSkinIdx = E31_SKIN_SLOTS[0], d_aSkinW = E31_SKIN_SLOTS[1];
const uBones = gl.getUniformLocation(skinProgram, 'uBones'), d_uBones = gl.getUniformLocation(skinDepthProgram, 'uBones');
gl.enable(gl.DEPTH_TEST);
const depthExt = gl.getExtension('WEBGL_depth_texture');
let useShadowMap = !!depthExt;
const SHADOW_SIZE = 1024;
let shadowTex = null, shadowFBO = null;
let shadowColor = null;
if (useShadowMap) {
shadowTex = gl.createTexture();
gl.bindTexture(gl.TEXTURE_2D, shadowTex);
gl.texImage2D(gl.TEXTURE_2D, 0, gl.DEPTH_COMPONENT, SHADOW_SIZE, SHADOW_SIZE, 0, gl.DEPTH_COMPONENT, gl.UNSIGNED_INT, null);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
shadowColor = gl.createTexture();
gl.bindTexture(gl.TEXTURE_2D, shadowColor);
gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, SHADOW_SIZE, SHADOW_SIZE, 0, gl.RGBA, gl.UNSIGNED_BYTE, null);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
shadowFBO = gl.createFramebuffer();
gl.bindFramebuffer(gl.FRAMEBUFFER, shadowFBO);
gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, shadowColor, 0);
gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, gl.TEXTURE_2D, shadowTex, 0);
let status = gl.checkFramebufferStatus(gl.FRAMEBUFFER);
if (status !== gl.FRAMEBUFFER_COMPLETE) {
gl.bindTexture(gl.TEXTURE_2D, shadowTex);
gl.texImage2D(gl.TEXTURE_2D, 0, gl.DEPTH_COMPONENT, SHADOW_SIZE, SHADOW_SIZE, 0, gl.DEPTH_COMPONENT, gl.UNSIGNED_SHORT, null);
gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, gl.TEXTURE_2D, shadowTex, 0);
status = gl.checkFramebufferStatus(gl.FRAMEBUFFER);
}
if (status !== gl.FRAMEBUFFER_COMPLETE) {
console.warn('Shadow FBO incomplete, falling back to blob shadows');
useShadowMap = false;
}
gl.bindFramebuffer(gl.FRAMEBUFFER, null);
}
const albedoTex = gl.createTexture();
gl.bindTexture(gl.TEXTURE_2D, albedoTex);
const sizeTex = 256;
const canvasTex = document.createElement('canvas');
canvasTex.width = sizeTex;
canvasTex.height = sizeTex;
const ctx = canvasTex.getContext('2d');
const imgData = ctx.createImageData(sizeTex, sizeTex);
const d = imgData.data;
const tile = 32;
for (let y=0; y<sizeTex; y++) {
for (let x=0; x<sizeTex; x++) {
const i = (y*sizeTex + x)*4;
const cx = Math.floor(x/tile)%2;
const cy = Math.floor(y/tile)%2;
const edge = ((x%tile)<2 || (y%tile)<2) ? 1 : 0;
const v = (cx ^ cy) ? 210 : 95;
const r = v + edge*25;
const g = (v*0.85) + edge*18;
const b = (v*0.55) + edge*10;
d[i]=Math.min(255,r|0); d[i+1]=Math.min(255,g|0); d[i+2]=Math.min(255,b|0); d[i+3]=255;
}
}
ctx.putImageData(imgData,0,0);
gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, canvasTex);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.REPEAT);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.REPEAT);
// Flat tangent-space normal (0.5,0.5,1) when material has no normalTexture
const flatNormalTex = gl.createTexture();
gl.bindTexture(gl.TEXTURE_2D, flatNormalTex);
gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, 1, 1, 0, gl.RGBA, gl.UNSIGNED_BYTE, new Uint8Array([128,128,255,255]));
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
function createMesh(positions, normals, uvs) {
const vertCount = positions.length / 3;
const data = new Float32Array(vertCount * 8);
for (let i = 0; i < vertCount; i++) {
data[i*8+0] = positions[i*3+0];
data[i*8+1] = positions[i*3+1];
data[i*8+2] = positions[i*3+2];
data[i*8+3] = normals[i*3+0];
data[i*8+4] = normals[i*3+1];
data[i*8+5] = normals[i*3+2];
if (uvs && uvs.length >= (i+1)*2) {
data[i*8+6] = uvs[i*2+0];
data[i*8+7] = uvs[i*2+1];
} else {
data[i*8+6] = positions[i*3+0] * 0.4;
data[i*8+7] = positions[i*3+2] * 0.4;
}
}
const vbo = gl.createBuffer();
gl.bindBuffer(gl.ARRAY_BUFFER, vbo);
gl.bufferData(gl.ARRAY_BUFFER, data, gl.STATIC_DRAW);
return { vbo, count: vertCount, stride: 32, hasTangent: false };
}
// Phase 26: pos3+norm3+uv2+tan4 (xyz + handedness w)
function createMeshWithTangents(positions, normals, uvs, tangents) {
const vertCount = positions.length / 3;
const data = new Float32Array(vertCount * 12);
for (let i = 0; i < vertCount; i++) {
const o = i * 12;
data[o+0] = positions[i*3+0];
data[o+1] = positions[i*3+1];
data[o+2] = positions[i*3+2];
data[o+3] = normals[i*3+0];
data[o+4] = normals[i*3+1];
data[o+5] = normals[i*3+2];
if (uvs && uvs.length >= (i+1)*2) {
data[o+6] = uvs[i*2+0];
data[o+7] = uvs[i*2+1];
} else {
data[o+6] = positions[i*3+0] * 0.4;
data[o+7] = positions[i*3+2] * 0.4;
}
if (tangents && tangents.length >= (i+1)*4) {
data[o+8] = tangents[i*4+0];
data[o+9] = tangents[i*4+1];
data[o+10] = tangents[i*4+2];
data[o+11] = tangents[i*4+3];
} else {
data[o+8] = 1; data[o+9] = 0; data[o+10] = 0; data[o+11] = 1;
}
}
const vbo = gl.createBuffer();
gl.bindBuffer(gl.ARRAY_BUFFER, vbo);
gl.bufferData(gl.ARRAY_BUFFER, data, gl.STATIC_DRAW);
return { vbo, count: vertCount, stride: 48, hasTangent: true };
}
/** Build UV-based tangents (WebGL1-stable; no OES_standard_derivatives required). */
function computeTangentsFromUV(posOut, normOut, uvOut) {
const nVert = posOut.length / 3;
const tan1 = new Float32Array(nVert * 3);
const tan2 = new Float32Array(nVert * 3);
for (let i = 0; i < nVert; i += 3) {
const i0 = i, i1 = i + 1, i2 = i + 2;
const x0 = posOut[i0*3], y0 = posOut[i0*3+1], z0 = posOut[i0*3+2];
const x1 = posOut[i1*3], y1 = posOut[i1*3+1], z1 = posOut[i1*3+2];
const x2 = posOut[i2*3], y2 = posOut[i2*3+1], z2 = posOut[i2*3+2];
const u0 = uvOut[i0*2], v0 = uvOut[i0*2+1];
const u1 = uvOut[i1*2], v1 = uvOut[i1*2+1];
const u2 = uvOut[i2*2], v2 = uvOut[i2*2+1];
const ex1 = x1 - x0, ey1 = y1 - y0, ez1 = z1 - z0;
const ex2 = x2 - x0, ey2 = y2 - y0, ez2 = z2 - z0;
const du1 = u1 - u0, dv1 = v1 - v0;
const du2 = u2 - u0, dv2 = v2 - v0;
const det = du1 * dv2 - du2 * dv1;
const r = Math.abs(det) > 1e-8 ? 1.0 / det : 0.0;
const tx = (ex1 * dv2 - ex2 * dv1) * r;
const ty = (ey1 * dv2 - ey2 * dv1) * r;
const tz = (ez1 * dv2 - ez2 * dv1) * r;
const bx = (ex2 * du1 - ex1 * du2) * r;
const by = (ey2 * du1 - ey1 * du2) * r;
const bz = (ez2 * du1 - ez1 * du2) * r;
for (const vi of [i0, i1, i2]) {
tan1[vi*3] += tx; tan1[vi*3+1] += ty; tan1[vi*3+2] += tz;
tan2[vi*3] += bx; tan2[vi*3+1] += by; tan2[vi*3+2] += bz;
}
}
const out = new Float32Array(nVert * 4);
for (let i = 0; i < nVert; i++) {
let nx = normOut[i*3], ny = normOut[i*3+1], nz = normOut[i*3+2];
let tx = tan1[i*3], ty = tan1[i*3+1], tz = tan1[i*3+2];
const ndott = nx*tx + ny*ty + nz*tz;
tx -= nx * ndott; ty -= ny * ndott; tz -= nz * ndott;
let len = Math.hypot(tx, ty, tz);
if (len < 1e-8) {
// stable fallback: pick axis least aligned with N
if (Math.abs(nx) < 0.9) { tx = 1; ty = 0; tz = 0; }
else { tx = 0; ty = 0; tz = 1; }
const nd = nx*tx + ny*ty + nz*tz;
tx -= nx * nd; ty -= ny * nd; tz -= nz * nd;
len = Math.hypot(tx, ty, tz) || 1;
}
tx /= len; ty /= len; tz /= len;
const bx = tan2[i*3], by = tan2[i*3+1], bz = tan2[i*3+2];
const cx = ny*tz - nz*ty, cy = nz*tx - nx*tz, cz = nx*ty - ny*tx;
const w = (cx*bx + cy*by + cz*bz) < 0 ? -1 : 1;
out[i*4] = tx; out[i*4+1] = ty; out[i*4+2] = tz; out[i*4+3] = w;
}
return out;
}
function bindDefaultTangent() {
if (aTangent < 0) return;
gl.disableVertexAttribArray(aTangent);
gl.vertexAttrib4f(aTangent, 1, 0, 0, 1);
}
function clearNormalMapUniforms() {
gl.uniform1f(uHasNormalMap, 0.0);
gl.uniform1f(uNormalScale, 1.0);
gl.activeTexture(gl.TEXTURE2);
gl.bindTexture(gl.TEXTURE_2D, flatNormalTex);
gl.uniform1i(uNormalMap, 2);
}
const OBJ_PYRAMID = `
v -1.2 0 -1.2
v 1.2 0 -1.2
v 1.2 0 1.2
v -1.2 0 1.2
v 0 1.8 0
f 1 2 5
f 2 3 5
f 3 4 5
f 4 1 5
f 1 4 3
f 1 3 2
`;
const OBJ_ROCK = `
v -0.6 0 -0.5
v 0.6 0 -0.5
v 0.5 0 0.6
v -0.5 0 0.6
v 0 0.9 0
v -0.4 0.4 -0.3
v 0.4 0.4 -0.3
v 0.3 0.4 0.4
v -0.3 0.4 0.4
f 1 2 5
f 2 3 5
f 3 4 5
f 4 1 5
f 1 6 5
f 2 7 5
f 3 8 5
f 4 9 5
f 6 7 2
f 7 8 3
f 8 9 4
f 9 6 1
`;
function parseOBJ(objText) {
const verts = [];
const faces = [];
const lines = objText.split('\n');
for (let line of lines) {
line = line.trim();
if (!line || line.startsWith('#')) continue;
const p = line.split(/\s+/);
if (p[0] === 'v') {
verts.push(parseFloat(p[1]), parseFloat(p[2]), parseFloat(p[3]));
} else if (p[0] === 'f') {
const idx = p.slice(1).map(s => parseInt(s.split('/')[0],10)-1);
for (let i=1;i<idx.length-1;i++) {
faces.push(idx[0], idx[i], idx[i+1]);
}
}
}
const pos = [];
const norm = [];
for (let i=0;i<faces.length;i+=3) {
const i0 = faces[i]*3, i1 = faces[i+1]*3, i2 = faces[i+2]*3;
const x0=verts[i0], y0=verts[i0+1], z0=verts[i0+2];
const x1=verts[i1], y1=verts[i1+1], z1=verts[i1+2];
const x2=verts[i2], y2=verts[i2+1], z2=verts[i2+2];
pos.push(x0,y0,z0, x1,y1,z1, x2,y2,z2);
const ux = x1-x0, uy = y1-y0, uz = z1-z0;
const vx = x2-x0, vy = y2-y0, vz = z2-z0;
let nx = uy*vz - uz*vy;
let ny = uz*vx - ux*vz;
let nz = ux*vy - uy*vx;
const len = Math.hypot(nx,ny,nz) || 1;
nx/=len; ny/=len; nz/=len;
norm.push(nx,ny,nz, nx,ny,nz, nx,ny,nz);
}
return createMesh(new Float32Array(pos), new Float32Array(norm));
}
const objMesh = parseOBJ(OBJ_PYRAMID);
const objRock = parseOBJ(OBJ_ROCK);
function meshBoundsFromPositions(positions) {
let minX=Infinity,minY=Infinity,minZ=Infinity,maxX=-Infinity,maxY=-Infinity,maxZ=-Infinity;
for (let i = 0; i < positions.length; i += 3) {
const x=positions[i], y=positions[i+1], z=positions[i+2];
if (x<minX)minX=x; if (y<minY)minY=y; if (z<minZ)minZ=z;
if (x>maxX)maxX=x; if (y>maxY)maxY=y; if (z>maxZ)maxZ=z;
}
return { min:[minX,minY,minZ], max:[maxX,maxY,maxZ], size:[maxX-minX, maxY-minY, maxZ-minZ] };
}
let glbLastBounds = { min:[0,0,0], max:[1,1,1], size:[1,1,1] };
// Phase 25/26: multi-mesh GLB + TEXCOORD_0 + baseColor + normalTexture (WebGL1)
const whiteTex = gl.createTexture();
gl.bindTexture(gl.TEXTURE_2D, whiteTex);
gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, 1, 1, 0, gl.RGBA, gl.UNSIGNED_BYTE, new Uint8Array([255,255,255,255]));
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
function mat4FromTRS(t, r, s) {
let m = identity();
if (t) { m[12] = t[0]; m[13] = t[1]; m[14] = t[2]; }
if (r) {
const x = r[0], y = r[1], z = r[2], w = r[3];
const x2 = x + x, y2 = y + y, z2 = z + z;
const xx = x * x2, xy = x * y2, xz = x * z2;
const yy = y * y2, yz = y * z2, zz = z * z2;
const wx = w * x2, wy = w * y2, wz = w * z2;
const q = identity();
q[0] = 1 - (yy + zz); q[1] = xy + wz; q[2] = xz - wy;
q[4] = xy - wz; q[5] = 1 - (xx + zz); q[6] = yz + wx;
q[8] = xz + wy; q[9] = yz - wx; q[10] = 1 - (xx + yy);
m = multiply(m, q);
}
if (s) {
const sx = s[0], sy = s[1], sz = s[2];
const sm = identity();
sm[0]=sx; sm[5]=sy; sm[10]=sz;
m = multiply(m, sm);
}
return m;
}
function nodeLocalMatrix(node) {
if (node.matrix && node.matrix.length === 16) return new Float32Array(node.matrix);
return mat4FromTRS(node.translation, node.rotation, node.scale);
}
function transformPoint(m, x, y, z) {
return [
m[0]*x + m[4]*y + m[8]*z + m[12],
m[1]*x + m[5]*y + m[9]*z + m[13],
m[2]*x + m[6]*y + m[10]*z + m[14]
];
}
function loadImageTextureFromUrl(url) {
return new Promise(function (resolve, reject) {
const img = new Image();
img.onload = function () {
const tex = gl.createTexture();
gl.bindTexture(gl.TEXTURE_2D, tex);
gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, 0);
gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, img);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
resolve(tex);
};
img.onerror = function () { reject(new Error('Texture load failed')); };
img.src = url;
});
}
function loadEmbeddedImageTexture(gltf, binBytes, imageIndex) {
const image = gltf.images[imageIndex];
if (image.uri && image.uri.indexOf('data:') === 0) return loadImageTextureFromUrl(image.uri);
if (image.bufferView == null) return Promise.reject(new Error('Image has no bufferView/uri'));
const view = gltf.bufferViews[image.bufferView];
const start = view.byteOffset || 0;
const slice = binBytes.slice(start, start + view.byteLength);
const mime = image.mimeType || 'image/png';
const blob = new Blob([slice], { type: mime });
const url = URL.createObjectURL(blob);
return loadImageTextureFromUrl(url).then(function (tex) {
URL.revokeObjectURL(url);
return tex;
});
}
function parseGLBChunks(arrayBuffer) {
const dv = new DataView(arrayBuffer);
if (arrayBuffer.byteLength < 12) throw new Error('GLB too short');
if (dv.getUint32(0, true) !== 0x46546C67) throw new Error('Not GLB (bad magic)');
if (dv.getUint32(4, true) !== 2) throw new Error('Need GLB version 2');
const totalLen = dv.getUint32(8, true);
let offset = 12;
let json = null;
let binStart = 0;
let binLen = 0;
while (offset + 8 <= arrayBuffer.byteLength && offset < totalLen) {
const chunkLen = dv.getUint32(offset, true);
const chunkType = dv.getUint32(offset + 4, true);
offset += 8;
if (offset + chunkLen > arrayBuffer.byteLength) throw new Error('GLB chunk overrun');
if (chunkType === 0x4E4F534A) {
const bytes = new Uint8Array(arrayBuffer, offset, chunkLen);
let end = chunkLen;
while (end > 0 && bytes[end - 1] === 0x20) end--;
json = JSON.parse(new TextDecoder('utf-8').decode(bytes.subarray(0, end)));
} else if (chunkType === 0x004E4942) {
binStart = offset;
binLen = chunkLen;
}
offset += chunkLen;
}
if (!json) throw new Error('No JSON chunk');
const binBytes = arrayBuffer.slice(binStart, binStart + binLen);
return { json, binBytes, binStart, dv };
}
function readAccessorGLB(json, binBytes, dvAbs, binStartAbs, accIndex, asIndex) {
const accessors = json.accessors || [];
const bufferViews = json.bufferViews || [];
const acc = accessors[accIndex];
if (!acc) throw new Error('Missing accessor');
const bv = bufferViews[acc.bufferView];
if (!bv && acc.bufferView != null) throw new Error('Missing bufferView');
const comps = ({ SCALAR:1, VEC2:2, VEC3:3, VEC4:4 })[acc.type] || 3;
const typeSize = ({ 5120:1, 5121:1, 5122:2, 5123:2, 5125:4, 5126:4 })[acc.componentType];
if (!typeSize) throw new Error('Unsupported componentType');
const count = acc.count;
const byteOffset = (bv ? (bv.byteOffset || 0) : 0) + (acc.byteOffset || 0);
const stride = (bv && bv.byteStride) ? bv.byteStride : (comps * typeSize);
const out = asIndex ? new Uint32Array(count) : new Float32Array(count * comps);
const src = new DataView(binBytes);
for (let i = 0; i < count; i++) {
const base = byteOffset + i * stride;
for (let c = 0; c < comps; c++) {
const o = base + c * typeSize;
let v;
switch (acc.componentType) {
case 5120: v = src.getInt8(o); break;
case 5121: v = src.getUint8(o); break;
case 5122: v = src.getInt16(o, true); break;
case 5123: v = src.getUint16(o, true); break;
case 5125: v = src.getUint32(o, true); break;
case 5126: v = src.getFloat32(o, true); break;
default: v = 0;
}
if (acc.normalized) {
if (acc.componentType === 5120) v /= 127;
else if (acc.componentType === 5121) v /= 255;
else if (acc.componentType === 5122) v /= 32767;
else if (acc.componentType === 5123) v /= 65535;
}
if (asIndex) out[i] = v >>> 0;
else out[i * comps + c] = v;
}
}
return { data: out, count: count, min: acc.min, max: acc.max };
}
function expandPrimitiveToArrays(json, binBytes, prim) {
const attrs = prim.attributes || {};
if (attrs.POSITION === undefined) return null;
const posAcc = readAccessorGLB(json, binBytes, null, 0, attrs.POSITION, false);
let normAcc = (attrs.NORMAL !== undefined) ? readAccessorGLB(json, binBytes, null, 0, attrs.NORMAL, false) : null;
let uvAcc = (attrs.TEXCOORD_0 !== undefined) ? readAccessorGLB(json, binBytes, null, 0, attrs.TEXCOORD_0, false) : null;
let tanAcc = (attrs.TANGENT !== undefined) ? readAccessorGLB(json, binBytes, null, 0, attrs.TANGENT, false) : null;
let idx = (prim.indices !== undefined) ? readAccessorGLB(json, binBytes, null, 0, prim.indices, true).data : null;
let posOut, normOut, uvOut, tanOut = null;
if (idx) {
const nTri = idx.length;
posOut = new Float32Array(nTri * 3);
normOut = new Float32Array(nTri * 3);
uvOut = new Float32Array(nTri * 2);
if (tanAcc) tanOut = new Float32Array(nTri * 4);
for (let i = 0; i < nTri; i++) {
const vi = idx[i];
posOut[i*3] = posAcc.data[vi*3];
posOut[i*3+1] = posAcc.data[vi*3+1];
posOut[i*3+2] = posAcc.data[vi*3+2];
if (normAcc) {
normOut[i*3] = normAcc.data[vi*3];
normOut[i*3+1] = normAcc.data[vi*3+1];
normOut[i*3+2] = normAcc.data[vi*3+2];
}
if (uvAcc) {
uvOut[i*2] = uvAcc.data[vi*2] || 0;
uvOut[i*2+1] = uvAcc.data[vi*2+1] || 0;
}
if (tanAcc && tanOut) {
tanOut[i*4] = tanAcc.data[vi*4] || 0;
tanOut[i*4+1] = tanAcc.data[vi*4+1] || 0;
tanOut[i*4+2] = tanAcc.data[vi*4+2] || 0;
tanOut[i*4+3] = tanAcc.data[vi*4+3] != null ? tanAcc.data[vi*4+3] : 1;
}
}
} else {
posOut = posAcc.data;
normOut = normAcc ? normAcc.data : new Float32Array(posAcc.count * 3);
uvOut = uvAcc ? uvAcc.data : new Float32Array(posAcc.count * 2);
if (tanAcc) tanOut = tanAcc.data;
}
if (!normAcc) {
for (let i = 0; i < posOut.length; i += 9) {
const x0=posOut[i], y0=posOut[i+1], z0=posOut[i+2];
const x1=posOut[i+3], y1=posOut[i+4], z1=posOut[i+5];
const x2=posOut[i+6], y2=posOut[i+7], z2=posOut[i+8];
let nx = (y1-y0)*(z2-z0) - (z1-z0)*(y2-y0);
let ny = (z1-z0)*(x2-x0) - (x1-x0)*(z2-z0);
let nz = (x1-x0)*(y2-y0) - (y1-y0)*(x2-x0);
const len = Math.hypot(nx,ny,nz) || 1;
nx/=len; ny/=len; nz/=len;
for (let k = 0; k < 3; k++) {
normOut[i + k*3] = nx;
normOut[i + k*3 + 1] = ny;
normOut[i + k*3 + 2] = nz;
}
}
}
return { posOut, normOut, uvOut, tanOut, posAcc };
}
/** Sync first-mesh parse (compat). Prefer loadGLBTextured for look. */
function parseGLB(arrayBuffer) {
const { json, binBytes } = parseGLBChunks(arrayBuffer);
const meshes = json.meshes || [];
if (!meshes.length) throw new Error('No meshes');
const prims = meshes[0].primitives || [];
let prim = null;
for (let i = 0; i < prims.length; i++) {
const m = prims[i].mode;
if (m === undefined || m === 4) { prim = prims[i]; break; }
}
if (!prim) throw new Error('No TRIANGLES primitive');
const arrays = expandPrimitiveToArrays(json, binBytes, prim);
if (!arrays) throw new Error('No POSITION');
glbLastBounds = meshBoundsFromPositions(arrays.posOut);
if (arrays.posAcc.min && arrays.posAcc.max && arrays.posAcc.min.length >= 3) {
const mn = arrays.posAcc.min, mx = arrays.posAcc.max;
glbLastBounds = { min:mn.slice(0,3), max:mx.slice(0,3), size:[mx[0]-mn[0], mx[1]-mn[1], mx[2]-mn[2]] };
}
return createMesh(arrays.posOut, arrays.normOut, arrays.uvOut);
}
function loadGLBTextured(arrayBuffer) {
const { json, binBytes } = parseGLBChunks(arrayBuffer);
const mats = json.materials || [];
const materialColor = [];
const materialTex = [];
const materialNm = [];
const materialNmScale = [];
const texPromises = [];
function queueEmbeddedTex(texIndex, assignFn) {
if (texIndex == null || !json.textures || !json.images) return;
const texInfo = json.textures[texIndex];
if (!texInfo) return;
const imgIndex = texInfo.source;
const image = json.images[imgIndex];
if (!image) return;
let p;
if (image.bufferView != null || (image.uri && image.uri.indexOf('data:') === 0)) {
p = loadEmbeddedImageTexture(json, binBytes, imgIndex).catch(function () { return null; });
} else {
p = Promise.resolve(null);
}
texPromises.push(p.then(assignFn));
}
for (let mi = 0; mi < mats.length; mi++) {
(function (mi) {
const mat = mats[mi] || {};
const pbr = mat.pbrMetallicRoughness || {};
const bc = pbr.baseColorFactor || [1, 1, 1, 1];
materialColor[mi] = [bc[0], bc[1], bc[2]];
materialTex[mi] = null;
materialNm[mi] = null;
materialNmScale[mi] = 1.0;
if (pbr.baseColorTexture) {
queueEmbeddedTex(pbr.baseColorTexture.index, function (t) { materialTex[mi] = t; });
}
if (mat.normalTexture) {
const nt = mat.normalTexture;
if (nt.scale != null) materialNmScale[mi] = nt.scale;
queueEmbeddedTex(nt.index, function (t) { materialNm[mi] = t; });
}
})(mi);
}
return Promise.all(texPromises).then(function () {
const nodes = json.nodes || [];
const meshes = json.meshes || [];
const sceneIndex = json.scene != null ? json.scene : 0;
const scene = (json.scenes && json.scenes[sceneIndex]) || { nodes: nodes.length ? [0] : [] };
const roots = scene.nodes || [];
const parts = [];
let aabbMin = [Infinity, Infinity, Infinity];
let aabbMax = [-Infinity, -Infinity, -Infinity];
function expandAABB(wx, wy, wz) {
if (wx < aabbMin[0]) aabbMin[0] = wx;
if (wy < aabbMin[1]) aabbMin[1] = wy;
if (wz < aabbMin[2]) aabbMin[2] = wz;
if (wx > aabbMax[0]) aabbMax[0] = wx;
if (wy > aabbMax[1]) aabbMax[1] = wy;
if (wz > aabbMax[2]) aabbMax[2] = wz;
}
function processMesh(meshIndex, world) {
const mesh = meshes[meshIndex];
if (!mesh || !mesh.primitives) return;
for (let p = 0; p < mesh.primitives.length; p++) {
const prim = mesh.primitives[p];
const mode = prim.mode;
if (mode !== undefined && mode !== 4) continue;
const arrays = expandPrimitiveToArrays(json, binBytes, prim);
if (!arrays) continue;
for (let i = 0; i < arrays.posOut.length; i += 3) {
const wp = transformPoint(world, arrays.posOut[i], arrays.posOut[i+1], arrays.posOut[i+2]);
expandAABB(wp[0], wp[1], wp[2]);
}
const matIndex = prim.material != null ? prim.material : -1;
const color = matIndex >= 0 && materialColor[matIndex] ? materialColor[matIndex].slice() : [0.85, 0.85, 0.85];
const tex = matIndex >= 0 ? materialTex[matIndex] : null;
const nm = matIndex >= 0 ? materialNm[matIndex] : null;
const nmScale = matIndex >= 0 && materialNmScale[matIndex] != null ? materialNmScale[matIndex] : 1.0;
let gm; // [lookB-fix] was `let mesh`, which shadowed the outer mesh -> TDZ ReferenceError on every GLB
if (nm || arrays.tanOut) {
const tans = arrays.tanOut || computeTangentsFromUV(arrays.posOut, arrays.normOut, arrays.uvOut);
gm = createMeshWithTangents(arrays.posOut, arrays.normOut, arrays.uvOut, tans);
} else {
gm = createMesh(arrays.posOut, arrays.normOut, arrays.uvOut);
}
parts.push({
mesh: gm,
color: color,
tex: tex,
useTex: !!tex,
nm: nm,
useNm: !!nm,
nmScale: nmScale,
world: new Float32Array(world)
});
}
}
function walk(nodeIndex, parentWorld) {
const node = nodes[nodeIndex];
if (!node) return;
const local = nodeLocalMatrix(node);
const world = multiply(parentWorld, local);
if (node.mesh != null) processMesh(node.mesh, world);
const children = node.children || [];
for (let c = 0; c < children.length; c++) walk(children[c], world);
}
const I = identity();
if (!roots.length && nodes.length) {
for (let ri = 0; ri < nodes.length; ri++) walk(ri, I);
} else {
for (let r = 0; r < roots.length; r++) walk(roots[r], I);
}
if (!isFinite(aabbMin[0])) { aabbMin = [-1, 0, -1]; aabbMax = [1, 1, 1]; }
const cx = (aabbMin[0] + aabbMax[0]) * 0.5;
const cz = (aabbMin[2] + aabbMax[2]) * 0.5;
const sx = aabbMax[0] - aabbMin[0], sy = aabbMax[1] - aabbMin[1], sz = aabbMax[2] - aabbMin[2];
const extent = Math.max(sx, sy, sz) || 1;
const fitScale = 1.6 / extent;
let fit = identity();
const sm = identity(); sm[0]=fitScale; sm[5]=fitScale; sm[10]=fitScale;
const tm = identity(); tm[12]=-cx; tm[13]=-aabbMin[1]; tm[14]=-cz;
fit = multiply(sm, tm);
glbLastBounds = {
min: aabbMin.slice(), max: aabbMax.slice(),
size: [sx, sy, sz]
};
for (let d = 0; d < parts.length; d++) {
parts[d].local = multiply(fit, parts[d].world);
}
return { parts: parts, bounds: glbLastBounds, fitScale: fitScale };
});
}
const triPos = new Float32Array([0,1.2,0, -1.0,-0.5,0, 1.0,-0.5,0]);
const triNorm = new Float32Array([0,0,1, 0,0,1, 0,0,1]);
const triangle = createMesh(triPos, triNorm);
const size = 10;
const groundPos = new Float32Array([
-size,0,-size, size,0,-size, size,0,size,
-size,0,-size, size,0,size, -size,0,size
]);
const groundNorm = new Float32Array([0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0]);
const ground = createMesh(groundPos, groundNorm);
const boxSize = 1.0;
const h = boxSize*0.5;
const bPos = new Float32Array([
-h,-h, h, h,-h, h, h, h, h,
-h,-h, h, h, h, h, -h, h, h,
-h,-h,-h, -h, h,-h, h, h,-h,
-h,-h,-h, h, h,-h, h,-h,-h,
-h,-h,-h, -h,-h, h, -h, h, h,
-h,-h,-h, -h, h, h, -h, h,-h,
h,-h,-h, h, h,-h, h, h, h,
h,-h,-h, h, h, h, h,-h, h,
-h, h,-h, -h, h, h, h, h, h,
-h, h,-h, h, h, h, h, h,-h,
-h,-h,-h, h,-h,-h, h,-h, h,
-h,-h,-h, h,-h, h, -h,-h, h
]);
const bNorm = new Float32Array([
0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,
0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,
-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,
1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,
0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,
0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0
]);
const crateMesh = createMesh(bPos, bNorm);
const shadowQuadPos = new Float32Array([-1,0,-1, 1,0,-1, 1,0,1, -1,0,-1, 1,0,1, -1,0,1]);
const shadowQuadNorm = new Float32Array([0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0]);
const shadowQuad = createMesh(shadowQuadPos, shadowQuadNorm);
const gridLines = [];
const step = 1;
for (let i=-size;i<=size;i++){
gridLines.push(-size,0,i, size,0,i);
gridLines.push(i,0,-size, i,0,size);
}
const gridVBO = gl.createBuffer();
gl.bindBuffer(gl.ARRAY_BUFFER, gridVBO);
gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(gridLines), gl.STATIC_DRAW);
function perspective(fov, aspect, near, far) {
const f = 1.0 / Math.tan(fov * 0.5);
const out = new Float32Array(16);
out[0] = f / aspect; out[1]=0; out[2]=0; out[3]=0;
out[4]=0; out[5]=f; out[6]=0; out[7]=0;
out[8]=0; out[9]=0; out[10]=(far+near)/(near-far); out[11]=-1;
out[12]=0; out[13]=0; out[14]=(2*far*near)/(near-far); out[15]=0;
return out;
}
function ortho(l,r,b,t,n,f){
const out = new Float32Array(16);
out[0]=2/(r-l); out[1]=0; out[2]=0; out[3]=0;
out[4]=0; out[5]=2/(t-b); out[6]=0; out[7]=0;
out[8]=0; out[9]=0; out[10]=-2/(f-n); out[11]=0;
out[12]=-(r+l)/(r-l); out[13]=-(t+b)/(t-b); out[14]=-(f+n)/(f-n); out[15]=1;
return out;
}
function lookAt(eye, center, up) {
const zx = eye[0]-center[0], zy = eye[1]-center[1], zz = eye[2]-center[2];
let zl = Math.hypot(zx,zy,zz)||1; const fx = zx/zl, fy = zy/zl, fz = zz/zl;
const ux = up[0], uy = up[1], uz = up[2];
let sx = fy*uz - fz*uy, sy = fz*ux - fx*uz, sz = fx*uy - fy*ux;
let sl = Math.hypot(sx,sy,sz)||1; sx/=sl; sy/=sl; sz/=sl;
const cx = sy*fz - sz*fy, cy = sz*fx - sx*fz, cz = sx*fy - sy*fx;
const out = new Float32Array(16);
out[0]=sx; out[1]=cx; out[2]=fx; out[3]=0;
out[4]=sy; out[5]=cy; out[6]=fy; out[7]=0;
out[8]=sz; out[9]=cz; out[10]=fz; out[11]=0;
out[12]=-(sx*eye[0]+sy*eye[1]+sz*eye[2]);
out[13]=-(cx*eye[0]+cy*eye[1]+cz*eye[2]);
out[14]=-(fx*eye[0]+fy*eye[1]+fz*eye[2]);
out[15]=1;
return out;
}
function multiply(a,b){
const out = new Float32Array(16);
for(let i=0;i<4;i++) for(let j=0;j<4;j++){
out[i*4+j]= a[i*4+0]*b[0*4+j]+a[i*4+1]*b[1*4+j]+a[i*4+2]*b[2*4+j]+a[i*4+3]*b[3*4+j];
}
return out;
}
function rotateX(m, a){
const c = Math.cos(a), s = Math.sin(a);
const out = m.slice();
const r1c0=out[4], r2c0=out[8], r1c1=out[5], r2c1=out[9], r1c2=out[6], r2c2=out[10], r1c3=out[7], r2c3=out[11];
out[4] = c*r1c0 - s*r2c0;
out[8] = s*r1c0 + c*r2c0;
out[5] = c*r1c1 - s*r2c1;
out[9] = s*r1c1 + c*r2c1;
out[6] = c*r1c2 - s*r2c2;
out[10]= s*r1c2 + c*r2c2;
out[7] = c*r1c3 - s*r2c3;
out[11]= s*r1c3 + c*r2c3;
return out;
}
function rotateY(m, a){
const c=Math.cos(a), s=Math.sin(a);
const r = new Float32Array(16);
r[0]=c; r[1]=0; r[2]=-s; r[3]=0;
r[4]=0; r[5]=1; r[6]=0; r[7]=0;
r[8]=s; r[9]=0; r[10]=c; r[11]=0;
r[12]=0; r[13]=0; r[14]=0; r[15]=1;
return multiply(r,m);
}
function translate(m, x,y,z){
const out = new Float32Array(m);
out[12] = m[0]*x + m[4]*y + m[8]*z + m[12];
out[13] = m[1]*x + m[5]*y + m[10]*z + m[14];
out[14] = m[2]*x + m[6]*y + m[10]*z + m[14];
return out;
}
function scale(m, s){
const out = new Float32Array(m);
out[0]*=s; out[1]*=s; out[2]*=s;
out[4]*=s; out[5]*=s; out[6]*=s;
out[8]*=s; out[9]*=s; out[10]*=s;
return out;
}
function identity(){ return new Float32Array([1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1]); }
const cam = {
pos: [0,1.6,5],
yaw: 0,
pitch: 0,
speed: 4.0,
sens: 0.002
};
const orbit = {
enabled: false,
yaw: 0.6,
pitch: 0.35,
radius: 9.0,
target: [0,0.8, -1.5],
yawTarget: 0.6,
pitchTarget: 0.35
};
const keys = {};
let nightMode = false;
let score = 0;
let shootCooldown = 0;
let hitFlashTimer = 0;
let hitStyleGl = [1.0, 0.92, 0.25];
let hitStyleDur = 0.28;
let playerHP = 5;
let hurtCooldown = 0;
let hurtFlash = 0;
let charShapePack = 0;
const CHAR_SHAPES = [
{ id:'BOX', dogXZ:1.0, dogY:0.6, dogZ:1.2, dogRadExtra:0.35, hostScale:1.2, patrolScale:1.1 },
{ id:'TALL', dogXZ:0.75, dogY:1.15, dogZ:0.9, dogRadExtra:0.5, hostScale:1.55, patrolScale:1.4 }
];
function applyCharShapePack(){
const sh = CHAR_SHAPES[charShapePack];
for (const d of dogs){
d.shapeXZ = sh.dogXZ; d.shapeY = sh.dogY; d.shapeZ = sh.dogZ; d.radExtra = sh.dogRadExtra;
}
hostile.scale = sh.hostScale;
patrolHostile.scale = sh.patrolScale;
flashHint('CHARS ' + sh.id + ' (distance test)');
}
const MAG_CAP = 12;
let ammoMag = 8;
let ammoReserve = 16;
let wonOnce = false;
let reloading = false;
let reloadTimer = 0;
let muzzleFlash = 0;
let crouching = false;
const standEye = 1.6;
const crouchEye = 1.05;
let velY = 0;
let airY = 0;
let onGround = true;
let onLadder = false;
let coyoteTimer = 0;
let jumpBufferTimer = 0;
let wasOnGround = true;
const GRAVITY = 24;
const JUMP_VEL = 8.2;
const CLIMB_SPEED = 2.8;
const COYOTE_TIME = 0.10;
const JUMP_BUFFER = 0.12;
const STEP_UP = 0.55;
const MANTLE_MAX = 1.15;
const PLAYER_R = 0.35;
// ===== BEGIN GAME DATA: Breaker Bay level data / tuning (MIT like the rest; still inline here until the engine/game split in PLAN.md moves it to game/) =====
// Phase 28 parkour route (right of spawn, clear of bollard/pier exhibits)
const parkourBlocks = [
{ pos:[3.6, 0.25, 3.4], scale:[1.2, 0.50, 1.2], color:[0.72,0.42,0.22] },
{ pos:[4.9, 0.80, 2.7], scale:[1.15, 0.70, 1.15], color:[0.75,0.48,0.25] },
{ pos:[6.1, 1.40, 1.9], scale:[1.2, 0.70, 1.2], color:[0.70,0.40,0.20] },
{ pos:[7.2, 2.10, 1.0], scale:[1.25, 0.70, 1.25], color:[0.35,0.55,0.78] }
];
const ladder = { pos:[7.2, 1.55, -0.15], scale:[0.34, 3.1, 0.34], color:[0.55,0.38,0.22], spec:[0.25,0.18,0.12], shin:18 };
const ladderDeck = { pos:[7.2, 3.20, -0.9], scale:[2.0, 0.22, 1.8], color:[0.30,0.70,0.45], spec:[0.25,0.40,0.30], shin:24 };
// Phase 29 — hostile death timeline: fall/settle then boom/despawn
const HOSTILE_DEATH_FALL = 0.42;
const HOSTILE_DEATH_BOOM = 0.18;
const HOSTILE_DEATH_TOTAL = HOSTILE_DEATH_FALL + HOSTILE_DEATH_BOOM;
const hostile = {
mesh: crateMesh,
pos: [-7.2, 0.6, -5.0],
scale: 1.2,
hp: 5,
alive: true,
speed: 1.35,
aggroRange: 8.0,
loseRange: 18.0,
alerted: false,
hitFlash: 0,
dying: 0,
deathBoomPending: false,
tipSign: 1,
baseY: 0.0
};
const patrolHostile = {
mesh: crateMesh,
pos: [4.0, 0.6, 2.0],
scale: 1.1,
hp: 5,
alive: true,
speed: 1.8,
hitFlash: 0,
waypointA: [4.0, 0.6, 2.0],
waypointB: [-4.0, 0.6, 2.0],
targetIsA: false,
hurtCooldown: 0,
dying: 0,
deathBoomPending: false,
tipSign: -1,
baseY: 0.0
};
// Phase 25 lean: fewer dogs / ammo clutter; keep shootables
const dogs = [
{ mesh: crateMesh, pos: [0.5, 0.25, -1.2], scale: 0.9, color:[0.55,0.45,0.35], spec:[0.3,0.25,0.2], shin:24, wanderTimer:0, speed:0.95, target:[0,0,0], alive:true, hp:2, hitFlash:0 }
];
const ammoPickups = [
{ mesh: crateMesh, pos: [-2.5, 0.35, -3.5], scale: 0.75, color: [0.42,0.28,0.16], spec:[0.25,0.2,0.15], shin:28, alive:true, amount:10, name:'ammoPick0', accent:[0.25,0.95,0.95] },
{ mesh: crateMesh, pos: [5.2, 0.35, 0.8], scale: 0.75, color: [0.42,0.28,0.16], spec:[0.25,0.2,0.15], shin:28, alive:true, amount:12, name:'ammoPick1', accent:[0.98,0.82,0.2] },
{ mesh: crateMesh, pos: [2.4, 0.35, -6.4], scale: 0.75, color: [0.42,0.28,0.16], spec:[0.25,0.2,0.15], shin:28, alive:true, amount:10, name:'ammoPick2', accent:[0.35,0.95,0.45] }
];
function drawAmmoBox(p){
const ls = p.scale;
gl.uniform1f(uUseTex, 0.0);
let m = identity();
m[0]=ls; m[5]=ls*0.55; m[10]=ls;
m[12]=p.pos[0]; m[13]=p.pos[1]; m[14]=p.pos[2];
gl.uniformMatrix4fv(uModel, false, m);
drawMesh(p.mesh, m, p.color, p.spec, p.shin);
let lid = identity();
lid[0]=ls*0.95; lid[5]=ls*0.75; lid[10]=ls*0.08;
lid[12]=p.pos[0]; lid[13]=p.pos[1] + ls*0.35; lid[14]=p.pos[2] - ls*0.55;
gl.uniformMatrix4fv(uModel, false, lid);
drawMesh(p.mesh, lid, curLook.ammo.lid, [0.2,0.15,0.1], 22);
const acc = p.accent || [0.9,0.85,0.3];
for (let i = 0; i < 3; i++){
let a = identity();
a[0]=ls*0.16; a[5]=ls*0.28; a[10]=ls*0.48;
a[12]=p.pos[0] + (i-1)*ls*0.26;
a[13]=p.pos[1] + ls*0.28;
a[14]=p.pos[2] + ls*0.02;
gl.uniformMatrix4fv(uModel, false, a);
drawMesh(p.mesh, a, acc, [1.0,1.0,0.85], 90);
}
}
const door = {
mesh: crateMesh,
pos: [-4.5, 1.1, -2.0],
scale: [0.25, 2.2, 1.6],
color: [0.6,0.6,0.65],
spec: [0.2,0.2,0.25],
shin: 20,
open: false,
name: 'door'
};
const lamps = [
{ name:'lamp0', pos:[0.4,0.0,-2.2], postScale:[0.12,1.8,0.12], bulbScale:[0.22,0.22,0.22], warm:true, on:true, broken:false },
{ name:'lamp1', pos:[-2.0,0.0,-1.0], postScale:[0.12,1.6,0.12], bulbScale:[0.22,0.22,0.22], warm:true, on:true, broken:false },
{ name:'lamp2', pos:[3.2,0.0,-2.6], postScale:[0.14,1.9,0.14], bulbScale:[0.28,0.28,0.28], warm:true, on:true, broken:false }
];
// ===== END GAME DATA =====
function lampBulbTip(l){
return [l.pos[0], l.pos[1] + l.postScale[1] + l.bulbScale[1]*0.5, l.pos[2]];
}
function lampLit(l){
return nightMode && l.on && !l.broken;
}
function nearestLitLamps(n){
const lit = lamps.filter(lampLit);
if (lit.length <= n) return lit.slice();
lit.sort((a,b)=>{
const ta = lampBulbTip(a), tb = lampBulbTip(b);
const da = Math.hypot(ta[0]-cam.pos[0], ta[2]-cam.pos[2]);
const db = Math.hypot(tb[0]-cam.pos[0], tb[2]-cam.pos[2]);
return da - db;
});
if (n >= 2 && lit.length >= 2) {
return [lit[0], lit[lit.length - 1]];
}
return lit.slice(0, n);
}
let audioCtx = null;
function ensureAudio(){
if (audioCtx) return;
try {
audioCtx = new (window.AudioContext || window.webkitAudioContext)();
} catch(e){}
}
function beep(freq, dur, vol){
if (!cfg.sound) return; // [e29] sound toggle
try {
ensureAudio();
if (!audioCtx) return;
if (audioCtx.state === 'suspended') audioCtx.resume();
const o = audioCtx.createOscillator();
const g = audioCtx.createGain();
o.type = 'square';
o.frequency.value = freq;
g.gain.value = vol;
o.connect(g); g.connect(audioCtx.destination);
o.start();
g.gain.exponentialRampToValueAtTime(0.0001, audioCtx.currentTime + dur);
o.stop(audioCtx.currentTime + dur);
} catch(e){}
}
function sfxShoot(){ beep(700, 0.06, 0.05); }
function sfxReloadStart(){ beep(300, 0.08, 0.04); }
function sfxReloadEnd(){ beep(600, 0.12, 0.05); }
function sfxHit(){ beep(200, 0.07, 0.05); }
function sfxHurt(){ beep(140, 0.12, 0.07); }
function sfxPickup(){ beep(880, 0.07, 0.05); beep(1200, 0.08, 0.04); }
function sfxDoor(){ beep(180, 0.1, 0.05); }
function sfxBump(){ beep(110, 0.05, 0.06); }
function sfxWin(){ beep(520, 0.1, 0.05); beep(780, 0.15, 0.05); }
let _bumpSfxAt = 0;
function sfxBumpThrottled(minGap){
const t = (typeof performance !== 'undefined' ? performance.now() : Date.now());
if (t - _bumpSfxAt < (minGap || 180)) return;
_bumpSfxAt = t;
sfxBump();
}
function enterOrbit(){
if (orbit.enabled) return;
orbit._saved = [cam.pos[0], cam.pos[1], cam.pos[2], cam.yaw, cam.pitch];
orbit.enabled = true;
document.exitPointerLock?.();
}
function exitOrbit(){
if (!orbit.enabled) return;
orbit.enabled = false;
if (orbit._saved) {
cam.pos[0] = orbit._saved[0];
cam.pos[2] = orbit._saved[2];
cam.yaw = orbit._saved[3];
cam.pitch = orbit._saved[4];
}
cam.pos[1] = crouching ? crouchEye : standEye;
}
let demoDrive = null;
function stopDemoDrive(){
if (demoDrive) {
clearInterval(demoDrive);
demoDrive = null;
}
keys['KeyW'] = keys['KeyS'] = keys['KeyA'] = keys['KeyD'] = false;
}
function toggleNight(){
nightMode = !nightMode;
cfg.night = nightMode; // [e29]
flashHint(nightMode ? ('NIGHT — ' + lamps.filter(l=>l.on && !l.broken).length + ' LAMPS') : 'DAY — LAMPS OFF');
}
window.addEventListener('keydown', e=>{
if (uiBlocked) return; // [e29] overlay open
if (['KeyW','KeyA','KeyS','KeyD','ArrowUp','ArrowDown','ArrowLeft','ArrowRight','Space'].includes(e.code)) {
e.preventDefault();
stopDemoDrive();
}
keys[e.code]=true;
if (e.code === 'Space' && !crouching) {
jumpBufferTimer = JUMP_BUFFER;
}
if (e.code === 'ControlLeft' || e.code === 'ControlRight') {
crouching = true;
}
if (e.code === 'KeyO') {
if (orbit.enabled) exitOrbit(); else enterOrbit();
}
if (e.code === 'Escape') {
exitOrbit();
document.exitPointerLock?.();
}
if (e.code === 'KeyN' || e.code === 'KeyG') {
toggleNight();
}
if (e.code === 'KeyL') {
e.preventDefault();
if (e.shiftKey) openGlbPicker(); else cycleLook(); // [e29] L = look, Shift+L = GLB pick
}
if (e.code === 'KeyK') {
e.preventDefault();
toggleLookProp();
}
if (e.code === 'KeyC') {
showCredit(2000);
}
if (e.code === 'KeyP') {
coachDump();
}
if (e.code === 'KeyT') {
charShapePack = (charShapePack + 1) % CHAR_SHAPES.length;
applyCharShapePack();
}
if (e.code === 'KeyR') {
if (!reloading && ammoMag < MAG_CAP && ammoReserve > 0) {
reloading = true;
reloadTimer = 1.5;
flashHint('RELOADING');
sfxReloadStart();
}
}
if (e.code === 'KeyE') {
const dx = cam.pos[0] - door.pos[0];
const dz = cam.pos[2] - door.pos[2];
if (Math.hypot(dx, dz) < 2.2) {
door.open = !door.open;
sfxDoor(); flashHint(door.open ? 'DOOR OPEN' : 'DOOR CLOSED');
}
}
});
window.addEventListener('keyup', e=>{
keys[e.code]=false;
if (e.code === 'ControlLeft' || e.code === 'ControlRight') {
crouching = false;
}
});
let mouseDown=false;
let pendingShoot = false;
document.addEventListener('pointerlockchange', ()=>{
if (document.pointerLockElement === canvas && pendingShoot) {
pendingShoot = false;
tryShoot();
}
});
canvas.addEventListener('mousedown', (e)=>{
if (uiBlocked) return; // [e29]
stopDemoDrive();
mouseDown=true;
if (e.button === 0) {
if (document.pointerLockElement === canvas) {
tryShoot();
} else {
pendingShoot = true;
canvas.requestPointerLock?.();
}
}
});
window.addEventListener('mouseup', ()=>mouseDown=false);
canvas.addEventListener('mousemove', e=>{
if (orbit.enabled) {
if(!mouseDown) return;
orbit.yawTarget += e.movementX * cam.sens;
orbit.pitchTarget += e.movementY * cam.sens;
orbit.pitchTarget = Math.max(-1.4, Math.min(1.4, orbit.pitchTarget));
} else {
if(!mouseDown && document.pointerLockElement !== canvas) return;
cam.yaw += e.movementX * cam.sens;
cam.pitch += e.movementY * cam.sens;
cam.pitch = Math.max(-1.5, Math.min(1.5, cam.pitch));
}
});
function flatForward(){
return [Math.sin(cam.yaw), 0, -Math.cos(cam.yaw)];
}
function flatRight(){
return [Math.cos(cam.yaw), 0, Math.sin(cam.yaw)];
}
function updateCamera(dt){
if (orbit.enabled) {
orbit.yaw += (orbit.yawTarget - orbit.yaw) * 0.12;
orbit.pitch += (orbit.pitchTarget - orbit.pitch) * 0.12;
const cp = Math.cos(orbit.pitch);
const sp = Math.sin(orbit.pitch);
const cy = Math.cos(orbit.yaw);
const sy = Math.sin(orbit.yaw);
cam.pos[0] = orbit.target[0] + orbit.radius * cp * sy;
cam.pos[1] = orbit.target[1] + orbit.radius * sp;
cam.pos[2] = orbit.target[2] + orbit.radius * cp * cy;
return;
}
const fwd = flatForward();
const right = flatRight();
let move = 0;
let strafe = 0;
if(keys['KeyW']||keys['ArrowUp']) move += 1;
if(keys['KeyS']||keys['ArrowDown']) move -= 1;
if(keys['KeyA']||keys['ArrowLeft']) strafe += 1;
if(keys['KeyD']||keys['ArrowRight']) strafe -= 1;
// diagonal: both keys at once (W+A = forward-left), normalize so speed stays even
const mlen = Math.hypot(move, strafe);
if (mlen > 1e-6) { move /= mlen; strafe /= mlen; }
const eye = crouching ? crouchEye : standEye;
function nodeTopY(node) {
if (!node || !node.pos) return 0;
const s = node.scale;
const sy = Array.isArray(s) ? s[1] : (typeof s === 'number' ? s : 1);
if (node.pivot === 'base' && node.aabbH != null) return node.pos[1] + node.aabbH;
// center-pivot crates / boxes / parkour: pos is center
if (Array.isArray(s) || (typeof s === 'number' && node.pivot !== 'base')) {
return node.pos[1] + sy * 0.5;
}
return node.pos[1] + sy * 0.5;
}
function collectWalkTops() {
const tops = [];
for (let i = 0; i < parkourBlocks.length; i++) {
const pl = parkourBlocks[i];
tops.push({
x: pl.pos[0], z: pl.pos[2],
hx: pl.scale[0] * 0.5 + 0.06, hz: pl.scale[2] * 0.5 + 0.06,
top: pl.pos[1] + pl.scale[1] * 0.5
});
}
// ladder deck
if (cfg.parkour) tops.push({
x: ladderDeck.pos[0], z: ladderDeck.pos[2],
hx: ladderDeck.scale[0] * 0.5 + 0.06, hz: ladderDeck.scale[2] * 0.5 + 0.06,
top: ladderDeck.pos[1] + ladderDeck.scale[1] * 0.5
});
// pier + any walkable scene nodes + solid crates (land on tops)
for (let i = 0; i < sceneNodes.length; i++) {
const n = sceneNodes[i];
if (!n.pos) continue;
if (n.name === 'ground' || n.name === 'marker') continue;
if (n.climb) continue;
if (n.hp !== undefined && n.hp <= 0 && !(n.dying > 0)) continue;
const s = n.scale;
const sx = Array.isArray(s) ? s[0] : s;
const sz = Array.isArray(s) ? s[2] : s;
const top = nodeTopY(n);
if (!(n.walkable || n.name === 'pier' || n.hp !== undefined || n.solidR)) continue;
tops.push({
x: n.pos[0], z: n.pos[2],
hx: (Array.isArray(s) ? sx : sx) * 0.5 + 0.08,
hz: (Array.isArray(s) ? sz : sz) * 0.5 + 0.08,
top: top
});
}
// bollard look prop (proxy cylinder as box)
if (typeof lookProp !== 'undefined' && lookProp && lookProp.visible) {
tops.push({
x: lookProp.pos[0], z: lookProp.pos[2],
hx: 0.38, hz: 0.38,
top: lookProp.pos[1] + 1.15
});
}
return tops;
}
function platformFloor(px, pz, fromY) {
if (levelOn()) return levelFloor(px, pz, fromY); // [e30] loaded scene is the floor
let best = 0.0;
const tops = collectWalkTops();
for (let i = 0; i < tops.length; i++) {
const pl = tops[i];
if (Math.abs(px - pl.x) <= pl.hx && Math.abs(pz - pl.z) <= pl.hz) {
// land only when above / near this top (not under a ceiling)
if (fromY + 0.55 >= pl.top && pl.top > best) best = pl.top;
}
}
return best;
}
function tryJump() {
if (crouching || !cfg.jump) return false; // [e29] jump toggle
if (!(onGround || coyoteTimer > 0 || onLadder)) return false;
if (onLadder) {
onLadder = false;
velY = JUMP_VEL * 0.85;
onGround = false;
coyoteTimer = 0;
jumpBufferTimer = 0;
try { beep(420, 0.05, 0.04); } catch (_) {}
flashHint('JUMP OFF');
return true;
}
// no infinite air-jump: require ground or coyote
velY = JUMP_VEL;
onGround = false;
coyoteTimer = 0;
jumpBufferTimer = 0;
wasOnGround = false;
try { beep(420, 0.05, 0.04); } catch (_) {}
flashHint('JUMP');
return true;
}
// --- ladder mount / climb ---
const lx = ladder.pos[0], lz = ladder.pos[2];
const deckTop = ladderDeck.pos[1] + ladderDeck.scale[1] * 0.5;
const ladderTop = deckTop;
const nearLadderXZ = cfg.parkour && Math.hypot(cam.pos[0] - lx, cam.pos[2] - lz) < 0.9;
const climbPressed = !!(keys['KeyW']||keys['KeyS']||keys['ArrowUp']||keys['ArrowDown']);
const onDeckXZ = (
Math.abs(cam.pos[0] - ladderDeck.pos[0]) < ladderDeck.scale[0] * 0.5 &&
Math.abs(cam.pos[2] - ladderDeck.pos[2]) < ladderDeck.scale[2] * 0.5
);
if (!onLadder && nearLadderXZ && !onDeckXZ && airY < deckTop - 0.25 && climbPressed) {
onLadder = true;
velY = 0;
onGround = false;
flashHint('LADDER');
}
if (onLadder) {
velY = 0;
let climb = 0;
if (keys['KeyW']||keys['ArrowUp']) climb += 1;
if (keys['KeyS']||keys['ArrowDown']) climb -= 1;
airY += climb * CLIMB_SPEED * dt;
cam.pos[0] += (lx - cam.pos[0]) * Math.min(1, 3.5 * dt);
cam.pos[2] += (lz - cam.pos[2]) * Math.min(1, 3.5 * dt);
// A/D step off
if (keys['KeyA']||keys['ArrowLeft']||keys['KeyD']||keys['ArrowRight']) {
cam.pos[0] += right[0] * strafe * cam.speed * 0.55 * dt;
cam.pos[2] += right[2] * strafe * cam.speed * 0.55 * dt;
if (Math.hypot(cam.pos[0] - lx, cam.pos[2] - lz) > 1.1) onLadder = false;
}
if (airY <= 0) { airY = 0; onLadder = false; onGround = true; velY = 0; }
if (airY >= ladderTop - 0.05) {
airY = ladderTop;
onLadder = false;
velY = 0;
onGround = true;
flashHint('DECK');
}
if (jumpBufferTimer > 0) tryJump();
cam.pos[1] = eye + airY;
return;
}
// intended horizontal delta
const dx = (fwd[0]*move + right[0]*strafe) * cam.speed * dt;
const dz = (fwd[2]*move + right[2]*strafe) * cam.speed * dt;
// step-up / mantle probe: if forward is blocked at feet but clear at raised height, lift
function blockedAt(px, pz, feetY) {
if (!cfg.collision) return null; // [e29] engine part: collision off = noclip
if (levelOn()) return levelBlockedAt(px, pz, feetY); // [e30] walls/steps from the scene mesh
const r = PLAYER_R;
for (let i = 0; i < sceneNodes.length; i++) {
const node = sceneNodes[i];
if (!node.pos) continue;
if (node.name === 'pier' || node.name === 'ground' || node.name === 'marker') continue;
if (node.climb || node.walkable) continue;
if (node.hp !== undefined && node.hp <= 0 && !(node.dying > 0)) continue;
const top = nodeTopY(node);
if (feetY >= top - 0.02) continue; // on top — not a side block
const s = node.scale;
const sx = Array.isArray(s) ? s[0] : s;
const sz = Array.isArray(s) ? s[2] : s;
const halfX = sx * 0.5 + r, halfZ = sz * 0.5 + r;
if (px > node.pos[0] - halfX && px < node.pos[0] + halfX &&
pz > node.pos[2] - halfZ && pz < node.pos[2] + halfZ) return top;
}
// parkour sides when below top
for (let i = 0; i < parkourBlocks.length; i++) {
const pl = parkourBlocks[i];
const top = pl.pos[1] + pl.scale[1] * 0.5;
if (feetY >= top - 0.02) continue;
const hx = pl.scale[0] * 0.5 + r, hz = pl.scale[2] * 0.5 + r;
if (Math.abs(px - pl.pos[0]) < hx && Math.abs(pz - pl.pos[2]) < hz) return top;
}
// ladder body is climbable — not a hard block here
return null;
}
// try move X then Z (per-axis), with step-up / mantle
function moveAxis(ax, az) {
const nx = cam.pos[0] + ax;
const nz = cam.pos[2] + az;
const hit = blockedAt(nx, nz, airY);
if (hit == null) {
cam.pos[0] = nx; cam.pos[2] = nz;
return;
}
const rise = hit - airY;
// auto step-up for small ledges
if (rise > 0.02 && rise <= STEP_UP + 0.02 && onGround) {
const hit2 = blockedAt(nx, nz, hit + 0.02);
if (hit2 == null) {
airY = hit;
cam.pos[0] = nx; cam.pos[2] = nz;
onGround = true; velY = 0;
return;
}
}
// mantle: press forward (or jump buffer) into taller ledge up to MANTLE_MAX
const wantMantle = (move > 0.2 || jumpBufferTimer > 0) && rise > STEP_UP && rise <= MANTLE_MAX;
if (wantMantle && (onGround || coyoteTimer > 0.02)) {
const hit2 = blockedAt(nx, nz, hit + 0.05);
if (hit2 == null) {
airY = hit;
cam.pos[0] = nx; cam.pos[2] = nz;
velY = 0; onGround = true; jumpBufferTimer = 0;
flashHint('MANTLE');
return;
}
}
// blocked on this axis — leave position (other axis may still move)
}
const ox = cam.pos[0], oz = cam.pos[2];
moveAxis(dx, 0);
moveAxis(0, dz);
// if both axes alone failed but diagonal into a corner, stay put (already handled)
// vertical: coyote + gravity + landing
if (onGround) {
coyoteTimer = COYOTE_TIME;
} else {
coyoteTimer = Math.max(0, coyoteTimer - dt);
}
if (jumpBufferTimer > 0) {
jumpBufferTimer -= dt;
if (tryJump()) { /* consumed */ }
}
if (!cfg.gravity) { // [e29] engine part: gravity off = fly (Space up, Ctrl down)
velY = 0; jumpBufferTimer = 0;
if (keys['Space']) airY += 3.2 * dt;
if (keys['ControlLeft'] || keys['ControlRight']) airY -= 3.2 * dt;
airY = levelOn() ? Math.max(level.collider.stats.min[1] - 5, Math.min(level.collider.stats.max[1] + 12, airY)) : Math.max(0, Math.min(12, airY)); // [e30]
onGround = airY <= 0.001; coyoteTimer = COYOTE_TIME; wasOnGround = onGround;
cam.pos[1] = standEye + airY;
return;
}
const floorProbe = platformFloor(cam.pos[0], cam.pos[2], airY);
if (!onGround || velY !== 0 || airY > floorProbe + 0.001) {
velY -= GRAVITY * dt;
airY += velY * dt;
const floorNow = platformFloor(cam.pos[0], cam.pos[2], airY);
if (velY <= 0 && airY <= floorNow + 0.14) {
airY = floorNow;
velY = 0;
onGround = true;
coyoteTimer = COYOTE_TIME;
} else if (airY <= 0 && !levelOn()) { // [e30] no implicit y=0 floor inside a loaded level
airY = 0;
velY = 0;
onGround = true;
coyoteTimer = COYOTE_TIME;
} else {
onGround = false;
}
} else {
airY = floorProbe;
velY = 0;
onGround = true;
coyoteTimer = COYOTE_TIME;
}
// walked off ledge → start coyote (already set when onGround flips)
if (wasOnGround && !onGround && velY <= 0) {
coyoteTimer = COYOTE_TIME;
}
wasOnGround = onGround;
cam.pos[1] = eye + airY;
}
function drawMesh(mesh, modelMat, baseColor, specColor, shininess){
const stride = mesh.stride || 32;
gl.bindBuffer(gl.ARRAY_BUFFER, mesh.vbo);
gl.enableVertexAttribArray(aPos);
gl.enableVertexAttribArray(aNormal);
if (aUV >= 0) gl.enableVertexAttribArray(aUV);
gl.vertexAttribPointer(aPos, 3, gl.FLOAT, false, stride, 0);
gl.vertexAttribPointer(aNormal, 3, gl.FLOAT, false, stride, 12);
if (aUV >= 0) gl.vertexAttribPointer(aUV, 2, gl.FLOAT, false, stride, 24);
bindDefaultTangent();
clearNormalMapUniforms();
gl.uniformMatrix4fv(uModel, false, modelMat);
gl.uniform3fv(uBaseColor, baseColor);
gl.uniform3fv(uSpecColor, cfg.lightExtras ? specColor : ZERO3); // [e29] engine part
gl.uniform1f(uShininess, shininess);
gl.drawArrays(gl.TRIANGLES, 0, mesh.count);
}
function drawMeshDepth(mesh, modelMat){
const stride = mesh.stride || 32;
gl.bindBuffer(gl.ARRAY_BUFFER, mesh.vbo);
gl.enableVertexAttribArray(d_aPos);
gl.vertexAttribPointer(d_aPos, 3, gl.FLOAT, false, stride, 0);
gl.uniformMatrix4fv(d_uModel, false, modelMat);
gl.drawArrays(gl.TRIANGLES, 0, mesh.count);
}
function drawTexturedPart(part, rootModel){
const model = multiply(rootModel, part.local || identity());
const stride = part.mesh.stride || 32;
gl.bindBuffer(gl.ARRAY_BUFFER, part.mesh.vbo);
gl.enableVertexAttribArray(aPos);
gl.enableVertexAttribArray(aNormal);
if (aUV >= 0) gl.enableVertexAttribArray(aUV);
gl.vertexAttribPointer(aPos, 3, gl.FLOAT, false, stride, 0);
gl.vertexAttribPointer(aNormal, 3, gl.FLOAT, false, stride, 12);
if (aUV >= 0) gl.vertexAttribPointer(aUV, 2, gl.FLOAT, false, stride, 24);
if (part.mesh.hasTangent && aTangent >= 0) {
gl.enableVertexAttribArray(aTangent);
gl.vertexAttribPointer(aTangent, 4, gl.FLOAT, false, stride, 32);
} else {
bindDefaultTangent();
}
gl.uniformMatrix4fv(uModel, false, model);
gl.uniform3fv(uBaseColor, part.color || [1,1,1]);
gl.uniform3fv(uSpecColor, cfg.lightExtras ? (part.spec || [0.35,0.35,0.35]) : ZERO3); // [e29]
gl.uniform1f(uShininess, part.shin || 48);
if (cfg.textures && part.useTex && part.tex) { // [e29] engine part
gl.activeTexture(gl.TEXTURE1);
gl.bindTexture(gl.TEXTURE_2D, part.tex);
gl.uniform1i(uAlbedo, 1);
gl.uniform1f(uUseTex, 1.0);
} else {
gl.uniform1f(uUseTex, 0.0);
}
if (cfg.textures && part.useNm && part.nm) { // [e29] engine part
gl.activeTexture(gl.TEXTURE2);
gl.bindTexture(gl.TEXTURE_2D, part.nm);
gl.uniform1i(uNormalMap, 2);
gl.uniform1f(uHasNormalMap, 1.0);
gl.uniform1f(uNormalScale, part.nmScale != null ? part.nmScale : 1.0);
} else {
clearNormalMapUniforms();
}
gl.drawArrays(gl.TRIANGLES, 0, part.mesh.count);
gl.activeTexture(gl.TEXTURE1);
gl.bindTexture(gl.TEXTURE_2D, albedoTex);
gl.uniform1i(uAlbedo, 1);
bindDefaultTangent();
clearNormalMapUniforms();
clearNormalMapUniforms();
if (aTangent >= 0) gl.disableVertexAttribArray(aTangent);
}
// ===== BEGIN GAME DATA: Breaker Bay level data / tuning (MIT like the rest; still inline here until the engine/game split in PLAN.md moves it to game/) =====
// Phase 25 lean scene: fewer decorative props; keep cover + parkour + shoot crates
const LEAN_SCENE = true;
const sceneNodes = [
{ mesh: ground, model: identity(), color: [0.32,0.42,0.52], spec:[0.05,0.05,0.07], shin: 8, name:'ground', useTex:1 },
{ mesh: triangle, model: null, color: [0.9,0.4,0.2], spec:[0.6,0.3,0.2], shin: 32, name:'marker' },
{ mesh: crateMesh, model: null, color: [0.7,0.6,0.45], spec:[0.55,0.45,0.25], shin: 28, name:'crate0', pos:[-1.0,0.7,-3.0], scale:1.4, hp:3, maxHp:3, dying:0, pivot:'center' },
{ mesh: crateMesh, model: null, color: [0.6,0.7,0.55], spec:[0.35,0.55,0.45], shin: 36, name:'crate1', pos:[1.4,0.6,-6.2], scale:1.2, hp:3, maxHp:3, dying:0, pivot:'center' },
{ mesh: objMesh, model: null, color: [0.85,0.65,0.35], spec:[0.9,0.8,0.6], shin: 64, name:'objPyramid', pos:[-1.2,0.0,0.4], scale:1.0, solidR:1.25, hp:3, maxHp:3, dying:0, pivot:'base', aabbH:1.8 },
{ mesh: crateMesh, model: null, color:[0.60,0.62,0.66], spec:[0.25,0.25,0.30], shin:22, name:'pier', pos:[0.0,0.1,-8.5], scale:[7.0,0.2,1.8], walkable:true },
{ mesh: crateMesh, model: null, color:[0.88,0.18,0.14], spec:[0.55,0.2,0.15], shin:28, name:'redBox0', pos:[2.2,0.4,-1.8], scale:0.85, hp:2, maxHp:2, dying:0, pivot:'center' },
{ mesh: crateMesh, model: null, color:[0.9,0.16,0.12], spec:[0.55,0.2,0.15], shin:28, name:'redBox1', pos:[-4.6,0.4,-4.4], scale:0.9, hp:2, maxHp:2, dying:0, pivot:'center' },
{ mesh: crateMesh, model: null, color:[0.72,0.42,0.22], spec:[0.3,0.2,0.12], shin:20, name:'parkour0', pos:[3.6,0.25,3.4], scale:[1.2,0.50,1.2], walkable:true },
{ mesh: crateMesh, model: null, color:[0.75,0.48,0.25], spec:[0.3,0.2,0.12], shin:20, name:'parkour1', pos:[4.9,0.80,2.7], scale:[1.15,0.70,1.15], walkable:true },
{ mesh: crateMesh, model: null, color:[0.70,0.40,0.20], spec:[0.3,0.2,0.12], shin:20, name:'parkour2', pos:[6.1,1.40,1.9], scale:[1.2,0.70,1.2], walkable:true },
{ mesh: crateMesh, model: null, color:[0.35,0.55,0.78], spec:[0.25,0.35,0.45], shin:24, name:'parkour3', pos:[7.2,2.10,1.0], scale:[1.25,0.70,1.25], walkable:true },
{ mesh: crateMesh, model: null, color:[0.55,0.38,0.22], spec:[0.25,0.18,0.12], shin:18, name:'ladder', pos:[7.2,1.55,-0.15], scale:[0.34,3.1,0.34], climb:true },
{ mesh: crateMesh, model: null, color:[0.30,0.70,0.45], spec:[0.25,0.40,0.30], shin:24, name:'ladderDeck', pos:[7.2,3.20,-0.9], scale:[2.0,0.22,1.8], walkable:true }
];
const childMarker = { mesh: triangle, parent:'crate0', local: [0,1.2,0], color:[1.0,0.9,0.3], spec:[1.0,0.9,0.5], shin: 80 };
// ===== END GAME DATA =====
function frustumCull(node){
if (!node.pos) return true;
const dx = cam.pos[0] - node.pos[0];
const dz = cam.pos[2] - node.pos[2];
const dist = Math.hypot(dx, dz);
if (dist > 35) return false;
const sc = node.scale;
const half = (Array.isArray(sc) ? Math.max(sc[0], sc[2]) : sc) * 0.9;
if (Math.abs(cam.pos[0] - node.pos[0]) > 40 + half) return false;
if (Math.abs(cam.pos[2] - node.pos[2]) > 40 + half) return false;
return true;
}
function resolveCollision(){
if (!cfg.collision) return; // [e29] engine part: collision off = noclip
if (levelOn()) { levelPushPlayer(); return; } // [e30]
// Phase 28: height-gated side push — standing on top does not snag; resolve min-pen on XZ only.
// Vertical (airY / velY) is never cleared here.
const r = PLAYER_R;
const feetY = airY;
function solidTop(node) {
const s = node.scale;
const sy = Array.isArray(s) ? s[1] : (typeof s === 'number' ? s : 1);
if (node.pivot === 'base' && node.aabbH != null) return node.pos[1] + node.aabbH;
return node.pos[1] + sy * 0.5;
}
function pushOutXZ(cx, cz, hx, hz) {
const minX = cx - hx, maxX = cx + hx;
const minZ = cz - hz, maxZ = cz + hz;
if (cam.pos[0] <= minX || cam.pos[0] >= maxX || cam.pos[2] <= minZ || cam.pos[2] >= maxZ) return;
const dxL = cam.pos[0] - minX, dxR = maxX - cam.pos[0];
const dzB = cam.pos[2] - minZ, dzF = maxZ - cam.pos[2];
const m = Math.min(dxL, dxR, dzB, dzF);
// prefer the axis of least penetration (stable edges)
if (m === dxL) cam.pos[0] = minX;
else if (m === dxR) cam.pos[0] = maxX;
else if (m === dzB) cam.pos[2] = minZ;
else cam.pos[2] = maxZ;
}
for (const node of sceneNodes){
if (!node.pos) continue;
if (node.name === 'pier' || node.name === 'ground' || node.name === 'marker') continue;
if (node.climb || node.walkable) continue;
if (node.hp !== undefined && node.hp <= 0 && !(node.dying > 0)) continue;
const top = solidTop(node);
// on / above top → land via platformFloor; do not side-push (avoids mid-air stick)
if (feetY >= top - 0.05) continue;
const s = node.scale;
const sx = Array.isArray(s) ? s[0] : s;
const sz = Array.isArray(s) ? s[2] : s;
pushOutXZ(node.pos[0], node.pos[2], sx * 0.5 + r, sz * 0.5 + r);
}
// bollard proxy when visible
if (lookProp && lookProp.visible) {
const bTop = lookProp.pos[1] + 1.15;
if (feetY < bTop - 0.05) {
pushOutXZ(lookProp.pos[0], lookProp.pos[2], 0.38 + r, 0.38 + r);
}
}
if (!door.open) {
const s = door.scale;
const sx = Array.isArray(s) ? s[0] : s;
const sz = Array.isArray(s) ? s[2] : s;
pushOutXZ(door.pos[0], door.pos[2], sx * 0.5 + r, sz * 0.5 + r);
}
}
function shareAmmoIntoMag(){
const need = MAG_CAP - ammoMag;
if (need <= 0 || ammoReserve <= 0) return 0;
const take = Math.min(need, ammoReserve);
ammoMag += take;
ammoReserve -= take;
return take;
}
function checkAmmoPickups(){
for (const p of ammoPickups){
if (!p.alive) continue;
const dx = cam.pos[0] - p.pos[0];
const dz = cam.pos[2] - p.pos[2];
if (Math.hypot(dx, dz) < 1.45){
ammoReserve += p.amount;
p.alive = false;
const shared = shareAmmoIntoMag();
sfxPickup(); flashHint('AMMO ' + ammoMag + '/' + ammoReserve + (shared ? (' MAG+' + shared) : (' RES+' + p.amount)));
}
}
}
let targets = sceneNodes.filter(n => n.hp !== undefined);
function refreshTargets(){
targets = sceneNodes.filter(n => n.hp !== undefined);
}
const hintEl = document.createElement('div');
hintEl.style.position='fixed';
hintEl.style.left='50%';
hintEl.style.top='18%';
hintEl.style.transform='translateX(-50%)';
hintEl.style.color='#fff';
hintEl.style.fontSize='14px';
hintEl.style.background='rgba(0,0,0,.55)';
hintEl.style.padding='6px 10px';
hintEl.style.borderRadius='8px';
hintEl.style.opacity='0';
hintEl.style.transition='opacity .3s';
hintEl.style.pointerEvents='none';
document.body.appendChild(hintEl);
let lastHintText = '';
function flashHint(text){
lastHintText = text;
hintEl.textContent = text;
hintEl.style.opacity='1';
setTimeout(()=>{ hintEl.style.opacity='0'; }, 1500);
}
// Phase 27 — Muse pick: pierMooringBollard (Mooring Bollard), in-engine pos+norm+uv
function createPierMooringBollardMesh() {
const pos = [];
const norm = [];
const uvs = [];
function pushTri(ax,ay,az, bx,by,bz, cx,cy,cz, nx,ny,nz, ua,va, ub,vb, uc,vc) {
pos.push(ax,ay,az, bx,by,bz, cx,cy,cz);
norm.push(nx,ny,nz, nx,ny,nz, nx,ny,nz);
uvs.push(ua,va, ub,vb, uc,vc);
}
function addCylinder(r, y0, y1, segs, v0, v1) {
for (let i = 0; i < segs; i++) {
const a0 = (i / segs) * Math.PI * 2;
const a1 = ((i + 1) / segs) * Math.PI * 2;
const c0 = Math.cos(a0), s0 = Math.sin(a0);
const c1 = Math.cos(a1), s1 = Math.sin(a1);
const x0 = c0 * r, z0 = s0 * r;
const x1 = c1 * r, z1 = s1 * r;
const u0 = i / segs, u1 = (i + 1) / segs;
// side
pushTri(x0,y0,z0, x1,y0,z1, x1,y1,z1, c0,0,s0, u0,v0, u1,v0, u1,v1);
pushTri(x0,y0,z0, x1,y1,z1, x0,y1,z0, c0,0,s0, u0,v0, u1,v1, u0,v1);
// top cap
pushTri(0,y1,0, x0,y1,z0, x1,y1,z1, 0,1,0, 0.5,0.5, 0.5+c0*0.5,0.5+s0*0.5, 0.5+c1*0.5,0.5+s1*0.5);
// bottom cap
pushTri(0,y0,0, x1,y0,z1, x0,y0,z0, 0,-1,0, 0.5,0.5, 0.5+c1*0.5,0.5+s1*0.5, 0.5+c0*0.5,0.5+s0*0.5);
}
}
function addBox(cx,cy,cz, sx,sy,sz, u0,v0,u1,v1) {
const x0 = cx - sx*0.5, x1 = cx + sx*0.5;
const y0 = cy - sy*0.5, y1 = cy + sy*0.5;
const z0 = cz - sz*0.5, z1 = cz + sz*0.5;
// +Z
pushTri(x0,y0,z1, x1,y0,z1, x1,y1,z1, 0,0,1, u0,v0, u1,v0, u1,v1);
pushTri(x0,y0,z1, x1,y1,z1, x0,y1,z1, 0,0,1, u0,v0, u1,v1, u0,v1);
// -Z
pushTri(x1,y0,z0, x0,y0,z0, x0,y1,z0, 0,0,-1, u0,v0, u1,v0, u1,v1);
pushTri(x1,y0,z0, x0,y1,z0, x1,y1,z0, 0,0,-1, u0,v0, u1,v1, u0,v1);
// +X
pushTri(x1,y0,z1, x1,y0,z0, x1,y1,z0, 1,0,0, u0,v0, u1,v0, u1,v1);
pushTri(x1,y0,z1, x1,y1,z0, x1,y1,z1, 1,0,0, u0,v0, u1,v1, u0,v1);
// -X
pushTri(x0,y0,z0, x0,y0,z1, x0,y1,z1, -1,0,0, u0,v0, u1,v0, u1,v1);
pushTri(x0,y0,z0, x0,y1,z1, x0,y1,z0, -1,0,0, u0,v0, u1,v1, u0,v1);
// +Y
pushTri(x0,y1,z1, x1,y1,z1, x1,y1,z0, 0,1,0, u0,v0, u1,v0, u1,v1);
pushTri(x0,y1,z1, x1,y1,z0, x0,y1,z0, 0,1,0, u0,v0, u1,v1, u0,v1);
// -Y
pushTri(x0,y0,z0, x1,y0,z0, x1,y0,z1, 0,-1,0, u0,v0, u1,v0, u1,v1);
pushTri(x0,y0,z0, x1,y0,z1, x0,y0,z1, 0,-1,0, u0,v0, u1,v1, u0,v1);
}
const segs = 16;
addCylinder(0.30, 0.00, 0.15, segs, 0.00, 0.12); // base
addCylinder(0.22, 0.15, 1.05, segs, 0.12, 0.88); // shaft
addCylinder(0.28, 1.05, 1.20, segs, 0.88, 1.00); // cap
// horns at shaft top (~y=1.05), along +/- Z
addBox(0.00, 1.05, 0.25, 0.12, 0.12, 0.50, 0.0, 0.0, 1.0, 1.0);
addBox(0.00, 1.05, -0.25, 0.12, 0.12, 0.50, 0.0, 0.0, 1.0, 1.0);
const tans = computeTangentsFromUV(pos, norm, uvs);
return createMeshWithTangents(new Float32Array(pos), new Float32Array(norm), new Float32Array(uvs), tans);
}
const LOOK_TOYCAR_URL = 'models/look/khronos-toy-car.glb';
const pierMooringBollardMesh = createPierMooringBollardMesh();
const lookProp = {
parts: [],
authoredParts: [{
mesh: pierMooringBollardMesh,
color: [0.28, 0.30, 0.34],
spec: [0.48, 0.45, 0.40],
shin: 72,
useTex: false,
useNm: false,
local: null
}],
pos: [2.4, 0.0, -4.2],
yaw: 0.0,
visible: true,
loaded: true,
name: 'pierMooringBollard'
};
function lookPropRootModel(){
// T * R: yaw in place, then world translation (avoid pre-existing translate quirks)
let m = rotateY(identity(), lookProp.yaw);
m[12] = lookProp.pos[0];
m[13] = lookProp.pos[1];
m[14] = lookProp.pos[2];
return m;
}
function applyLookParts(parts){
lookProp.parts = parts || [];
lookProp.loaded = lookProp.parts.length > 0 || (lookProp.authoredParts && lookProp.authoredParts.length > 0);
lookProp.visible = true;
}
function loadLookGlbUrl(url, hintOk){
flashHint('LOOK LOAD…');
return fetch(url).then(function(r){
if (!r.ok) throw new Error('HTTP ' + r.status);
return r.arrayBuffer();
}).then(function(ab){
return loadGLBTextured(ab);
}).then(function(res){
applyLookParts(res.parts);
flashHint(hintOk || ('LOOK ' + res.parts.length + ' MESH'));
return res;
}).catch(function(err){
console.error(err);
flashHint('LOOK FAIL');
});
}
function toggleLookProp(){
// Phase 27: authored Mooring Bollard is the default look prop (no ToyCar).
// Key L still picks a GLB into lookProp.parts; authoredParts stay.
lookProp.visible = !lookProp.visible;
cfg.bollard = lookProp.visible; // [e29]
flashHint(lookProp.visible ? 'LOOK ON · BOLLARD' : 'LOOK OFF');
}
// Auto-load showroom ToyCar look bar (CC0) when served on 8780
// no cars in bay scene (Paul) — ToyCar auto-load off; Key L for bay-fitting GLB+NM
// loadLookGlbUrl(LOOK_TOYCAR_URL, 'TOYCAR LOOK');
const glbFileInput = document.createElement('input');
glbFileInput.type = 'file';
glbFileInput.accept = '.glb,model/gltf-binary';
glbFileInput.style.display = 'none';
document.body.appendChild(glbFileInput);
function openGlbPicker(){
if (typeof levelOn === 'function' && levelOn()) { flashHint('SHIFT+L PROP IS OFF IN A LOADED LEVEL · TAB → MODEL IMPORT'); return; } // [lookB-fix]
try { glbFileInput.value = ''; } catch (_) {}
glbFileInput.click();
}
function applyGlbImport(mesh){
const b = glbLastBounds || { size:[1,1,1], min:[0,0,0] };
const h = Math.max(b.size[1] || 1, 1e-4);
const sc = 1.5 / h;
let node = sceneNodes.find(n => n.name === 'glbImport');
if (!node) {
node = {
mesh: mesh,
model: null,
color: [0.72, 0.68, 0.62],
spec: [0.35, 0.32, 0.28],
shin: 36,
name: 'glbImport',
pos: [1.5, 0.0, -3.5],
scale: sc,
hp: 3,
maxHp: 3,
dying: 0,
pivot: 'base',
aabbH: h
};
sceneNodes.push(node);
} else {
node.mesh = mesh;
node.scale = sc;
node.aabbH = h;
node.hp = 3;
node.maxHp = 3;
node.dying = 0;
node.pos = [1.5, 0.0, -3.5];
node.color = [0.72, 0.68, 0.62];
}
refreshTargets();
return node;
}
glbFileInput.addEventListener('change', function(){
const file = glbFileInput.files && glbFileInput.files[0];
if (!file) return;
const reader = new FileReader();
reader.onload = function(){
loadGLBTextured(reader.result).then(function(res){
applyLookParts(res.parts);
// [lookB-fix] textured load worked: no extra grey fallback copy (it ignored node transforms and drew upside-down)
const oldFb = sceneNodes.findIndex(n => n.name === 'glbImport');
if (oldFb >= 0) { sceneNodes.splice(oldFb, 1); refreshTargets(); }
flashHint('GLB LOOK ' + res.parts.length);
}).catch(function(err){
console.error(err);
try {
const mesh = parseGLB(reader.result);
applyGlbImport(mesh);
flashHint('GLB LOADED (UNTEXTURED FALLBACK)'); // [lookB-fix]
} catch (e2) {
console.error(e2);
flashHint('GLB FAIL');
}
});
};
reader.onerror = function(){ flashHint('GLB FAIL'); };
reader.readAsArrayBuffer(file);
});
function rayAABB(origin, dir, min, max){
let tmin = -Infinity, tmax = Infinity;
for (let i=0;i<3;i++){
if (Math.abs(dir[i]) < 1e-6){
if (origin[i] < min[i] || origin[i] > max[i]) return null;
} else {
const ood = 1.0 / dir[i];
let t1 = (min[i] - origin[i]) * ood;
let t2 = (max[i] - origin[i]) * ood;
if (t1 > t2) [t1,t2] = [t2,t1];
tmin = Math.max(tmin, t1);
tmax = Math.min(tmax, t2);
if (tmin > tmax) return null;
}
}
if (tmax < 0) return null;
return tmin > 0 ? tmin : tmax;
}
function nodeHitAABB(node){
if (!node || !node.pos) return null;
const s = node.scale;
const sx = Array.isArray(s) ? s[0] : (s || 1);
const sy = Array.isArray(s) ? s[1] : (s || 1);
const sz = Array.isArray(s) ? s[2] : (s || 1);
const cx = node.pos[0], cz = node.pos[2];
const nm = node.name || '';
if (node.pivot === 'base') {
const sc = Array.isArray(s) ? 1.0 : (s || 1);
const h = (node.aabbH || sy) * sc;
const y0 = node.pos[1];
let hx = sx * 0.5, hz = sz * 0.5;
if (typeof node.solidR === 'number' && node.solidR > 0) {
hx = node.solidR * sc; hz = node.solidR * sc;
} else if (/objPyramid/i.test(nm)) { hx = 1.25 * sc; hz = 1.25 * sc; }
else if (/objRock/i.test(nm)) { hx = 0.65 * sc; hz = 0.65 * sc; }
return [[cx - hx, y0, cz - hz], [cx + hx, y0 + h, cz + hz]];
}
const cy = node.pos[1];
const y0 = Math.max(0, cy - sy*0.5);
return [[cx - sx*0.5, y0, cz - sz*0.5], [cx + sx*0.5, y0 + sy, cz + sz*0.5]];
}
function tryShoot(){
if (!cfg.playerShoot) { flashHint('SHOOTING OFF (config)'); return; } // [e29]
if (reloading) { flashHint('RELOADING'); return; }
if (shootCooldown > 0) return;
if (ammoMag <= 0){
if (!reloading && ammoReserve > 0) {
reloading = true;
reloadTimer = 1.0;
flashHint('RELOADING');
sfxReloadStart();
return;
}
flashHint('NO AMMO');
shootCooldown = 0.15;
return;
}
if (!cfg.infiniteAmmo) ammoMag -= 1; // [e29] ammo-limit toggle
shootCooldown = 0.25;
muzzleFlash = 0.12;
sfxShoot();
const eye = [cam.pos[0], cam.pos[1], cam.pos[2]];
const cp = Math.cos(cam.pitch);
const dir = [
Math.sin(cam.yaw) * cp,
Math.sin(cam.pitch),
-Math.cos(cam.yaw) * cp
];
const len = Math.hypot(dir[0], dir[1], dir[2]) || 1;
dir[0]/=len; dir[1]/=len; dir[2]/=len;
let best = null, bestT = Infinity;
for (const node of targets){
if (node.hp <= 0 || (node.dying && node.dying > 0)) continue;
const box = nodeHitAABB(node);
if (!box) continue;
let t = rayAABB(eye, dir, box[0], box[1]);
if (t !== null && node.name === 'objPyramid') t = pyramidRayT(node, eye, dir); // [e30] exact pyramid, not its square AABB
if (t !== null && t < bestT){
bestT = t; best = node;
}
}
if (cfg.enemies && hostile.alive && hostile.dying <= 0) {
const s = hostile.scale;
const cy = hostile.baseY + s * 0.5;
const cx = hostile.pos[0], cz = hostile.pos[2];
const min = [cx - s*0.5, cy - s*0.5, cz - s*0.5];
const max = [cx + s*0.5, cy + s*0.5, cz + s*0.5];
const t = e31On() ? e31Ray(hostile, eye, dir) : rayAABB(eye, dir, min, max); // [e31] head sphere / body capsule
if (t !== null && t < bestT) {
bestT = t; best = { isHostile:true };
}
}
if (cfg.enemies && patrolHostile.alive && patrolHostile.dying <= 0) {
const s = patrolHostile.scale;
const cy = patrolHostile.baseY + s * 0.5;
const cx = patrolHostile.pos[0], cz = patrolHostile.pos[2];
const min = [cx - s*0.5, cy - s*0.5, cz - s*0.5];
const max = [cx + s*0.5, cy + s*0.5, cz + s*0.5];
const t = e31On() ? e31Ray(patrolHostile, eye, dir) : rayAABB(eye, dir, min, max); // [e31] head sphere / body capsule
if (t !== null && t < bestT) {
bestT = t; best = { isPatrol:true };
}
}
for (let di = 0; di < dogs.length; di++){
const d = dogs[di];
if (!d.alive || !cfg.dogs) continue;
const sx = d.scale, sy = d.scale * 0.6, sz = d.scale * 1.2;
const cx = d.pos[0], cy = d.pos[1], cz = d.pos[2];
const min = [cx - sx*0.5, cy - sy*0.5, cz - sz*0.5];
const max = [cx + sx*0.5, cy + sy*0.5, cz + sz*0.5];
const t = e32DogRay(d, eye, dir, min, max); // [e32] capsule when the dog uses the rig
if (t !== null && t < bestT) {
bestT = t; best = { isDog:true, dogIndex: di };
}
}
for (let li = 0; li < lamps.length; li++){
const l = lamps[li];
if (l.broken) continue;
const tip = lampBulbTip(l);
const hs = Math.max(l.bulbScale[0], l.bulbScale[1], l.bulbScale[2]) * 1.1 + 0.25;
const postW = Math.max(l.postScale[0], l.postScale[2]) * 0.5 + 0.22;
const min = [l.pos[0] - postW, l.pos[1], l.pos[2] - postW];
const max = [l.pos[0] + postW, tip[1] + hs, l.pos[2] + postW];
const tt = rayAABB(eye, dir, min, max);
if (tt !== null && tt < bestT) {
bestT = tt; best = { isLamp:true, lampIndex: li };
}
}
const skipImpact = { ground:1, marker:1, pier:1 };
for (const node of sceneNodes){
if (!node.pos || skipImpact[node.name]) continue;
if (node.hp !== undefined) continue;
const box = nodeHitAABB(node);
if (!box) continue;
const t = rayAABB(eye, dir, box[0], box[1]);
if (t !== null && t < bestT) {
bestT = t; best = { isImpact:true, node: node };
}
}
if (!door.open) {
const box = nodeHitAABB(door);
if (box) {
const t = rayAABB(eye, dir, box[0], box[1]);
if (t !== null && t < bestT) {
bestT = t; best = { isImpact:true, node: door };
}
}
}
{ const lh = levelShotTest(eye, dir, bestT); if (lh) { bestT = lh.t; best = { isLevel: true, hit: lh }; } } // [e30] scene mesh stops bullets
recordShot(eye, dir, bestT); // [e30]
if (best){
sfxHit();
if (best.isHostile) {
const st = resolveHitStyle('hostile');
showHitMarker(st);
applyObjectFlash(hostile, st);
hostile.hp -= e31Damage(hostile); // [e31] headshot x3
score += 2;
if (hostile.hp <= 0) {
if (hostile.dying <= 0) {
hostile.dying = HOSTILE_DEATH_TOTAL;
hostile.deathBoomPending = true;
hostile.tipSign = (hostile.pos[0] - cam.pos[0]) >= 0 ? 1 : -1;
}
flashHint('HOSTILE DOWN');
} else {
flashHint(st.hint);
}
} else if (best.isPatrol) {
const st = resolveHitStyle('patrol');
showHitMarker(st);
applyObjectFlash(patrolHostile, st);
patrolHostile.hp -= e31Damage(patrolHostile); // [e31] headshot x3
score += 2;
if (patrolHostile.hp <= 0) {
if (patrolHostile.dying <= 0) {
patrolHostile.dying = HOSTILE_DEATH_TOTAL;
patrolHostile.deathBoomPending = true;
patrolHostile.tipSign = (patrolHostile.pos[0] - cam.pos[0]) >= 0 ? 1 : -1;
}
flashHint('PATROL DOWN');
} else {
flashHint(st.hint);
}
} else if (best.isDog) {
const d = dogs[best.dogIndex];
const st = resolveHitStyle('dog');
showHitMarker(st);
applyObjectFlash(d, st);
score += 1;
d.hp = (d.hp == null ? 2 : d.hp) - 1;
const ax = d.pos[0] - cam.pos[0], az = d.pos[2] - cam.pos[2];
const al = Math.hypot(ax, az) || 1;
d.target[0] = d.pos[0] + (ax/al) * 4.0;
d.target[2] = d.pos[2] + (az/al) * 4.0;
d.wanderTimer = 1.2;
d.speed = Math.max(d.speed, 2.4);
if (d.hp <= 0) {
d.alive = false;
flashHint('DOG DOWN');
} else {
flashHint(st.hint);
}
} else if (best.isLamp) {
const l = lamps[best.lampIndex];
const st = resolveHitStyle('lamp');
showHitMarker(st);
applyObjectFlash(l, st);
l.hitFlash = 0.4;
l.broken = true;
l.on = false;
score += 1;
flashHint(nightMode ? 'LAMP HIT — OUT' : 'LAMP HIT');
} else if (best.isLevel) { e30LevelHit(best); // [e30]
} else if (best.isImpact) {
const n = best.node;
const st = resolveHitStyle('impact', n);
showHitMarker(st);
applyObjectFlash(n, st);
flashHint(st.hint);
} else {
const st = resolveHitStyle('target', best);
showHitMarker(st);
applyObjectFlash(best, st);
best.hp -= 1;
score += 1;
if (best.hp <= 0){
if (!best.dying) best.dying = cfg.deathFx ? 0.55 : 0.001; // [e29]
}
flashHint(st.hint);
}
}
e31AfterShot(best); // [e31]
}
function groundedBoxModel(posX,posZ,scaleXZ,scaleY,baseY){
let m = identity();
m[0]=scaleXZ; m[5]=scaleY; m[10]=scaleXZ;
m[12]=posX; m[13]=baseY + scaleY * 0.5; m[14]=posZ;
return m;
}
function hostileDeathPhase(h){
if (!(h.dying > 0)) return null;
if (h.dying > HOSTILE_DEATH_BOOM) {
const fallLeft = h.dying - HOSTILE_DEATH_BOOM;
const u = 1.0 - Math.max(0, Math.min(1, fallLeft / HOSTILE_DEATH_FALL));
return { phase: 'fall', u: u };
}
const u = 1.0 - Math.max(0, Math.min(1, h.dying / HOSTILE_DEATH_BOOM));
return { phase: 'boom', u: u };
}
function hostileDrawScale(h){
let dmg = 1.0 - Math.max(0, 5 - Math.max(h.hp, 0)) * 0.05;
const ph = hostileDeathPhase(h);
if (!ph) {
return { xz: Math.max(0.02, h.scale * dmg), y: Math.max(0.02, h.scale * dmg), tip: 0, sink: 0, flash: false };
}
const tipSign = (h.tipSign == null ? 1 : h.tipSign);
if (ph.phase === 'fall') {
// ragdoll-lite: tip + sink while body still readable
const tip = tipSign * ph.u * (Math.PI * 0.48);
const sink = ph.u * h.scale * 0.38;
const squash = 1.0 - ph.u * 0.22;
return {
xz: Math.max(0.02, h.scale * dmg * (0.92 + 0.08 * (1.0 - ph.u))),
y: Math.max(0.02, h.scale * dmg * squash),
tip: tip,
sink: sink,
flash: false
};
}
// boom: expand pulse then fade-out / despawn
const pulse = 1.0 + ph.u * 1.75;
const fade = Math.max(0.02, 1.0 - ph.u);
return {
xz: Math.max(0.02, h.scale * dmg * pulse * fade),
y: Math.max(0.02, h.scale * dmg * 0.32 * pulse * fade),
tip: tipSign * (Math.PI * 0.48),
sink: h.scale * 0.38,
flash: true
};
}
function hostileModel(h){
const hs = hostileDrawScale(h);
const baseY = (h.baseY || 0) - (hs.sink || 0);
let m = groundedBoxModel(h.pos[0], h.pos[2], hs.xz, hs.y, baseY);
if (hs.tip) m = rotateX(m, hs.tip);
return { m: m, hs: hs };
}
function tickHostileDeath(h, dt, downHint){
if (!(h.dying > 0)) return false;
if (!cfg.deathFx) { h.dying = 0; h.alive = false; h.deathBoomPending = false; return true; } // [e29]
const wasFall = h.dying > HOSTILE_DEATH_BOOM;
h.dying -= dt;
if (wasFall && h.dying <= HOSTILE_DEATH_BOOM && h.deathBoomPending) {
h.deathBoomPending = false;
h.hitFlash = 0.22;
h.hitFlashColor = [1.0, 0.9, 0.35];
flashHint('BOOM');
try { sfxHit(); } catch (_) {}
}
if (h.dying <= 0) {
h.dying = 0;
h.alive = false;
h.deathBoomPending = false;
}
return true;
}
// Phase 29: solid world AABBs for AI — same spirit as player side push / dog solids.
// Skip floors (ground/pier/marker) and climbables; collide buildings/props/door/bollard.
function hostileSkipsNode(node){
if (!node || !node.pos) return true;
const nm = node.name || '';
if (nm === 'pier' || nm === 'ground' || nm === 'marker') return true;
if (node.climb || node.walkable) return true;
return false;
}
function pushOutOfNodes(pos, bodyHalf){
function addBox(boxes, minX, maxX, minZ, maxZ){
boxes.push([minX, maxX, minZ, maxZ]);
}
const boxes = [];
for (const node of sceneNodes){
if (hostileSkipsNode(node)) continue;
if (node.hp !== undefined && node.hp <= 0 && !(node.dying > 0)) continue;
const box = nodeHitAABB(node);
if (!box) continue;
const pad = bodyHalf;
addBox(boxes, box[0][0] - pad, box[1][0] + pad, box[0][2] - pad, box[1][2] + pad);
}
if (!door.open) {
const box = nodeHitAABB(door);
if (box) {
const pad = bodyHalf;
addBox(boxes, box[0][0] - pad, box[1][0] + pad, box[0][2] - pad, box[1][2] + pad);
}
}
if (lookProp && lookProp.visible) {
const pad = bodyHalf + 0.38;
addBox(boxes, lookProp.pos[0] - pad, lookProp.pos[0] + pad, lookProp.pos[2] - pad, lookProp.pos[2] + pad);
}
for (let pass = 0; pass < 5; pass++){
let moved = false;
for (const b of boxes){
const minX = b[0], maxX = b[1], minZ = b[2], maxZ = b[3];
if (pos[0] <= minX || pos[0] >= maxX || pos[2] <= minZ || pos[2] >= maxZ) continue;
const dxL = pos[0] - minX, dxR = maxX - pos[0];
const dzB = pos[2] - minZ, dzF = maxZ - pos[2];
const m = Math.min(dxL, dxR, dzB, dzF);
if (m === dxL) pos[0] = minX;
else if (m === dxR) pos[0] = maxX;
else if (m === dzB) pos[2] = minZ;
else pos[2] = maxZ;
moved = true;
}
if (!moved) break;
}
}
function moveHostileXZ(h, tryX, tryZ, half, step){
if (levelOn()) { levelMoveChar(h, tryX, tryZ, e31R(h), e31H(h), false); return; } // [e30]; [e31] fitted capsule
const ox = h.pos[0], oz = h.pos[2];
// substep to reduce tunneling through thin AABBs
const dist = Math.hypot(tryX - ox, tryZ - oz);
const nSub = Math.max(1, Math.min(4, Math.ceil(dist / Math.max(0.12, half * 0.35))));
let cx = ox, cz = oz;
const dx = (tryX - ox) / nSub, dz = (tryZ - oz) / nSub;
for (let i = 0; i < nSub; i++){
const px = cx, pz = cz;
cx = px + dx; cz = pz + dz;
h.pos[0] = cx; h.pos[2] = cz;
pushOutOfNodes(h.pos, half);
if (Math.hypot(h.pos[0] - px, h.pos[2] - pz) < Math.hypot(dx, dz) * 0.18) {
// blocked — try axes separately (player-style)
h.pos[0] = px + dx; h.pos[2] = pz;
pushOutOfNodes(h.pos, half);
const xOk = Math.abs(h.pos[0] - px) > Math.abs(dx) * 0.2;
if (!xOk) {
h.pos[0] = px; h.pos[2] = pz + dz;
pushOutOfNodes(h.pos, half);
}
}
cx = h.pos[0]; cz = h.pos[2];
}
}
function updateHostile(dt){
if (!hostile.alive) return;
if (tickHostileDeath(hostile, dt, 'HOSTILE DOWN')) return;
const px = cam.pos[0], pz = cam.pos[2];
const hx = hostile.pos[0], hz = hostile.pos[2];
let dx = px - hx, dz = pz - hz;
const distXZ = Math.hypot(dx, dz);
const r = 0.28;
const half = hostile.scale * 0.5 + r;
if (!hostile.alerted) {
if (distXZ <= (hostile.aggroRange || 7)) {
hostile.alerted = true;
flashHint('HOSTILE');
} else {
pushOutOfNodes(hostile.pos, half);
return;
}
} else if (distXZ > (hostile.loseRange || 14)) {
hostile.alerted = false;
pushOutOfNodes(hostile.pos, half);
return;
}
if (distXZ > 0.01) {
const step = e31ChaseSpeed(hostile, distXZ) * dt; // [e31] animated: run when far
const nx = dx / distXZ, nz = dz / distXZ;
const tryX = hostile.pos[0] + nx * step;
const tryZ = hostile.pos[2] + nz * step;
moveHostileXZ(hostile, tryX, tryZ, half, step);
} else {
pushOutOfNodes(hostile.pos, half);
}
separateFromDogs(hostile.pos, hostile.scale * 0.55);
pushOutOfNodes(hostile.pos, half);
if (hurtCooldown > 0) hurtCooldown -= dt;
const d2 = Math.hypot(hostile.pos[0] - px, hostile.pos[2] - pz);
if (cfg.enemyAttack && d2 < 1.2 && hurtCooldown <= 0) { // [e29] toggle
playerHP -= 1;
hurtCooldown = 0.6;
hurtFlash = 0.25;
flashHint('HURT'); sfxHurt();
if (playerHP <= 0) {
// Phase 29: brief down beat then recover (no full death screen yet)
hurtFlash = 0.55;
flashHint('DOWN');
playerHP = 5;
hurtCooldown = 1.5;
const ax = cam.pos[0] - hostile.pos[0], az = cam.pos[2] - hostile.pos[2];
const al = Math.hypot(ax, az) || 1;
hostile.pos[0] -= (ax/al) * 2.2;
hostile.pos[2] -= (az/al) * 2.2;
pushOutOfNodes(hostile.pos, half);
setTimeout(function(){ flashHint('RECOVERED'); }, 420);
}
}
}
function separateFromDogs(pos, bodyR){
for (const d of dogs){
if (!d.alive) continue;
const dogR = Math.max((d.scale || 0.7) * 0.6, 0.55) + (d.radExtra != null ? d.radExtra : 0.4);
const minSep = bodyR + dogR + 0.08;
let dx = pos[0] - d.pos[0];
let dz = pos[2] - d.pos[2];
let dist = Math.hypot(dx, dz);
if (dist < 0.0001) { dx = 1; dz = 0; dist = 1; }
if (dist < minSep) {
const nx = dx / dist, nz = dz / dist;
const need = minSep - dist;
pos[0] += nx * need;
pos[2] += nz * need;
d.pos[0] -= nx * need * 0.25;
d.pos[2] -= nz * need * 0.25;
d.wanderTimer = 0;
sfxBumpThrottled(160);
}
}
}
function updatePatrolHostile(dt){
if (!patrolHostile.alive) return;
if (tickHostileDeath(patrolHostile, dt, 'PATROL DOWN')) return;
const half = patrolHostile.scale * 0.5 + 0.28;
const target = patrolHostile.targetIsA ? patrolHostile.waypointA : patrolHostile.waypointB;
let dx = target[0] - patrolHostile.pos[0];
let dz = target[2] - patrolHostile.pos[2];
const dist = Math.hypot(dx, dz);
if (dist > 0.05) {
const nx = dx / dist, nz = dz / dist;
const step = e31PatrolSpeed() * dt; // [e31]
const tryX = patrolHostile.pos[0] + nx * step;
const tryZ = patrolHostile.pos[2] + nz * step;
const beforeX = patrolHostile.pos[0], beforeZ = patrolHostile.pos[2];
moveHostileXZ(patrolHostile, tryX, tryZ, half, step);
// if solids blocked most of the step, flip waypoint (keep patrol intent)
if (Math.hypot(patrolHostile.pos[0]-beforeX, patrolHostile.pos[2]-beforeZ) < step * 0.2) {
patrolHostile.targetIsA = !patrolHostile.targetIsA;
}
} else {
patrolHostile.targetIsA = !patrolHostile.targetIsA;
}
const pBeforeX = patrolHostile.pos[0], pBeforeZ = patrolHostile.pos[2];
separateFromDogs(patrolHostile.pos, patrolHostile.scale * 0.6);
pushOutOfNodes(patrolHostile.pos, half);
if (Math.hypot(patrolHostile.pos[0]-pBeforeX, patrolHostile.pos[2]-pBeforeZ) > 0.15) {
patrolHostile.targetIsA = !patrolHostile.targetIsA;
}
if (patrolHostile.hurtCooldown > 0) patrolHostile.hurtCooldown -= dt;
const d2 = Math.hypot(patrolHostile.pos[0] - cam.pos[0], patrolHostile.pos[2] - cam.pos[2]);
if (cfg.enemyAttack && d2 < 1.2 && hurtCooldown <= 0) { // [e29] toggle
playerHP -= 1;
hurtCooldown = 0.6;
hurtFlash = 0.25;
flashHint('HURT'); sfxHurt();
if (playerHP <= 0) {
hurtFlash = 0.55;
flashHint('DOWN');
playerHP = 5;
hurtCooldown = 1.5;
const ax = cam.pos[0] - patrolHostile.pos[0], az = cam.pos[2] - patrolHostile.pos[2];
const al = Math.hypot(ax, az) || 1;
patrolHostile.pos[0] -= (ax/al) * 2.2;
patrolHostile.pos[2] -= (az/al) * 2.2;
pushOutOfNodes(patrolHostile.pos, half);
setTimeout(function(){ flashHint('RECOVERED'); }, 420);
}
}
}
function updateDogs(dt){
for (const d of dogs){
if (!d.alive) continue;
if (d.wanderTimer > 0){
d.wanderTimer -= dt;
} else {
d.wanderTimer = 2.0 + Math.random()*3.0;
const ang = Math.random()*Math.PI*2;
const rad = 1.2 + Math.random()*2.0;
d.target[0] = d.pos[0] + Math.cos(ang)*rad;
d.target[2] = d.pos[2] + Math.sin(ang)*rad;
}
const dogRad = Math.max((d.scale || 0.7) * 0.55, (d.scale || 0.7) * 0.6) + (d.radExtra != null ? d.radExtra : 0.35);
function solidBoxes(){
const boxes = [];
function add(minX, maxX, minZ, maxZ){
boxes.push([minX, maxX, minZ, maxZ]);
}
for (const node of sceneNodes){
if (!node || !node.pos) continue;
const nm = node.name || '';
if (nm === 'ground' || nm === 'marker') continue;
if (node.hp !== undefined && node.hp <= 0 && !(node.dying > 0)) continue;
const box = nodeHitAABB(node);
if (!box) continue;
const pad = dogRad + 0.18;
add(box[0][0] - pad, box[1][0] + pad, box[0][2] - pad, box[1][2] + pad);
}
if (!door.open) {
const s = door.scale;
const sx = Array.isArray(s) ? s[0] : s, sz = Array.isArray(s) ? s[2] : s;
const pad = dogRad + 0.1;
add(door.pos[0] - sx*0.5 - pad, door.pos[0] + sx*0.5 + pad,
door.pos[2] - sz*0.5 - pad, door.pos[2] + sz*0.5 + pad);
}
for (const p of ammoPickups){
if (!p.alive) continue;
const hs = (p.scale || 0.7) * 0.6 + dogRad;
add(p.pos[0] - hs, p.pos[0] + hs, p.pos[2] - hs, p.pos[2] + hs);
}
for (const l of lamps){
const pr = Math.max(l.postScale[0], l.postScale[2]) * 0.5 + dogRad;
add(l.pos[0] - pr, l.pos[0] + pr, l.pos[2] - pr, l.pos[2] + pr);
}
return boxes;
}
function pushDogOut(pos){
let hit = false;
const boxes = solidBoxes();
for (let pass = 0; pass < 5; pass++){
let moved = false;
for (const b of boxes){
const minX = b[0], maxX = b[1], minZ = b[2], maxZ = b[3];
if (pos[0] <= minX || pos[0] >= maxX || pos[2] <= minZ || pos[2] >= maxZ) continue;
const dxL = pos[0] - minX, dxR = maxX - pos[0];
const dzB = pos[2] - minZ, dzF = maxZ - pos[2];
const m = Math.min(dxL, dxR, dzB, dzF);
if (m === dxL) pos[0] = minX;
else if (m === dxR) pos[0] = maxX;
else if (m === dzB) pos[2] = minZ;
else pos[2] = maxZ;
moved = true; hit = true;
}
if (!moved) break;
}
return hit;
}
const dx = d.target[0] - d.pos[0];
const dz = d.target[2] - d.pos[2];
const dist = Math.hypot(dx, dz);
if (dist > 0.05){
const nx = dx/dist, nz = dz/dist;
const steps = 3;
const step = (d.speed * dt) / steps;
for (let s = 0; s < steps; s++){
const ox = d.pos[0], oz = d.pos[2];
if (levelOn()) { if (!levelMoveChar(d, ox + nx * step, oz + nz * step, 0.35, 0.6, true)) d.wanderTimer = Math.min(d.wanderTimer, 0.15); continue; } // [e30]
d.pos[0] = ox + nx * step;
d.pos[2] = oz + nz * step;
const blocked = pushDogOut(d.pos);
if (Math.hypot(d.pos[0]-ox, d.pos[2]-oz) < step * 0.25) {
d.pos[0] = ox + nx * step; d.pos[2] = oz;
pushDogOut(d.pos);
const xOk = Math.abs(d.pos[0] - ox) > step * 0.2;
if (!xOk) {
d.pos[0] = ox; d.pos[2] = oz + nz * step;
pushDogOut(d.pos);
}
d.wanderTimer = Math.min(d.wanderTimer, 0.15);
} else if (blocked) {
d.wanderTimer = Math.min(d.wanderTimer, 0.4);
}
}
} else {
pushDogOut(d.pos);
}
for (const o of dogs){
if (o === d || !o.alive) continue;
const ddx = d.pos[0] - o.pos[0];
const ddz = d.pos[2] - o.pos[2];
const dd = Math.hypot(ddx, ddz);
const minSep = dogRad + ((o.scale || 0.7) * 0.55 + 0.35) * 0.85;
if (dd > 0.001 && dd < minSep){
const push = (minSep - dd) * 0.5;
const nnx = ddx / dd, nnz = ddz / dd;
d.pos[0] += nnx * push;
d.pos[2] += nnz * push;
o.pos[0] -= nnx * push;
o.pos[2] -= nnz * push;
pushDogOut(d.pos);
pushDogOut(o.pos);
d.wanderTimer = 0;
o.wanderTimer = 0;
sfxBumpThrottled(220);
}
}
if (!levelOn() && d.pos[0] < -6) d.pos[0] = -6;
if (!levelOn() && d.pos[0] > 6) d.pos[0] = 6;
if (!levelOn() && d.pos[2] < -8) d.pos[2] = -8;
if (!levelOn() && d.pos[2] > 2) d.pos[2] = 2;
}
}
let last = performance.now();
let frames = 0, fpsTime = 0, fps = 0;
const fpsEl = document.createElement('div');
fpsEl.style.position='fixed';
fpsEl.style.right='12px';
fpsEl.style.top='12px';
fpsEl.style.color='#9ecbff';
fpsEl.style.fontSize='12px';
fpsEl.style.opacity='0.85';
fpsEl.style.background='rgba(0,0,0,.25)';
fpsEl.style.padding='6px 10px';
fpsEl.style.borderRadius='8px';
fpsEl.style.pointerEvents='none';
document.body.appendChild(fpsEl);
const crossEl = document.createElement('div');
crossEl.id = 'muse-cross';
crossEl.style.cssText = 'position:fixed;left:50%;top:50%;width:18px;height:18px;margin:-9px 0 0 -9px;pointer-events:none;z-index:20;';
crossEl.innerHTML = '<div style="position:absolute;left:8px;top:0;width:2px;height:18px;background:rgba(220,240,255,.75)"></div><div style="position:absolute;left:0;top:8px;width:18px;height:2px;background:rgba(220,240,255,.75)"></div>';
document.body.appendChild(crossEl);
const hitMarkEl = document.createElement('div');
hitMarkEl.id = 'muse-hitmark';
hitMarkEl.style.cssText = 'position:fixed;left:50%;top:50%;width:28px;height:28px;margin:-14px 0 0 -14px;pointer-events:none;z-index:21;opacity:0;transition:opacity .08s;color:#ffe566;font-size:22px;font-weight:700;text-align:center;line-height:28px;text-shadow:0 0 8px #ffaa00,0 0 2px #000';
hitMarkEl.textContent = 'X';
document.body.appendChild(hitMarkEl);
const HIT_STYLES = {
hostile: { mark:'+', css:'#ff4d4d', gl:[1.0,0.25,0.22], flash:[1.0,0.45,0.4], dur:0.34, hint:'HIT HOSTILE' },
patrol: { mark:'+', css:'#ff9a3c', gl:[1.0,0.55,0.15], flash:[1.0,0.75,0.35], dur:0.34, hint:'HIT PATROL' },
dog: { mark:'*', css:'#ffe08a', gl:[1.0,0.88,0.45], flash:[1.0,0.9,0.7], dur:0.3, hint:'DOG!' },
wood: { mark:'#', css:'#c48a4a', gl:[0.85,0.55,0.28], flash:[0.95,0.7,0.4], dur:0.28, hint:'WOOD HIT' },
metal: { mark:'+', css:'#d8f0ff', gl:[0.75,0.9,1.0], flash:[0.85,0.95,1.0], dur:0.26, hint:'METAL HIT' },
wall: { mark:'x', css:'#a8b4c4', gl:[0.7,0.78,0.88], flash:[0.85,0.88,0.92], dur:0.26, hint:'WALL HIT' },
stone: { mark:'*', css:'#d2c4a0', gl:[0.85,0.78,0.55], flash:[0.9,0.85,0.7], dur:0.3, hint:'STONE HIT' },
soft: { mark:'X', css:'#ffe566', gl:[1.0,0.92,0.25], flash:[1.0,0.75,0.45], dur:0.28, hint:'TARGET HIT' },
lamp: { mark:'*', css:'#fff6b0', gl:[1.0,0.95,0.55], flash:[1.0,1.0,0.85], dur:0.45, hint:'LAMP HIT', burst:true }
};
function resolveHitStyle(kind, node){
if (kind === 'hostile') return HIT_STYLES.hostile;
if (kind === 'patrol') return HIT_STYLES.patrol;
if (kind === 'dog') return HIT_STYLES.dog;
if (kind === 'lamp') return HIT_STYLES.lamp;
const name = (node && node.name) ? String(node.name) : '';
if (/barrel|door/i.test(name)) return HIT_STYLES.metal;
if (/bayWall|warehouse|shed|pier/i.test(name)) return HIT_STYLES.wall;
if (/cover|crate|rope|Stack/i.test(name)) return HIT_STYLES.wood;
if (/glb|glbImport/i.test(name)) return HIT_STYLES.stone;
if (/Pyramid|Rock|obj/i.test(name)) return HIT_STYLES.stone;
if (kind === 'impact') {
if (/Wall|warehouse|shed/i.test(name)) return HIT_STYLES.wall;
if (/cover|rope/i.test(name)) return HIT_STYLES.wood;
return HIT_STYLES.wall;
}
return HIT_STYLES.soft;
}
function showHitMarker(style){
if (!cfg.fx) return; // [e29] engine part: FX
style = style || HIT_STYLES.soft;
hitMarkEl.textContent = style.mark;
hitMarkEl.style.color = style.css;
hitMarkEl.style.textShadow = '0 0 10px ' + style.css + ',0 0 2px #000';
hitMarkEl.style.opacity = '1';
hitMarkEl.style.fontSize = style.burst ? '36px' : '22px';
hitMarkEl.style.width = style.burst ? '48px' : '28px';
hitMarkEl.style.height = style.burst ? '48px' : '28px';
hitMarkEl.style.margin = style.burst ? '-24px 0 0 -24px' : '-14px 0 0 -14px';
hitMarkEl.style.lineHeight = style.burst ? '48px' : '28px';
hitMarkEl.style.transform = style.burst ? 'scale(1.6)' : 'scale(1.2)';
if (style.burst) {
hitMarkEl.style.border = '2px solid ' + style.css;
hitMarkEl.style.borderRadius = '50%';
hitMarkEl.style.background = 'rgba(255,240,160,0.25)';
hitMarkEl.style.boxShadow = '0 0 18px ' + style.css;
} else {
hitMarkEl.style.border = 'none';
hitMarkEl.style.borderRadius = '0';
hitMarkEl.style.background = 'transparent';
hitMarkEl.style.boxShadow = 'none';
}
hitStyleGl = style.gl.slice();
hitStyleDur = style.dur;
hitFlashTimer = style.dur;
setTimeout(function(){
hitMarkEl.style.opacity = '0';
hitMarkEl.style.transform = 'scale(1)';
hitMarkEl.style.border = 'none';
hitMarkEl.style.background = 'transparent';
hitMarkEl.style.boxShadow = 'none';
}, Math.max(180, style.dur * 1000 * 0.75));
}
function applyObjectFlash(node, style){
if (!node || !style) return;
node.hitFlash = Math.max(node.hitFlash || 0, style.dur * 0.65);
node.hitFlashColor = style.flash.slice();
}
function coachDump(){
try {
const stamp = new Date().toISOString().replace(/[:.]/g,'-');
const state = {
stamp,
title: document.title,
cam: { pos: cam.pos.slice(), yaw: cam.yaw, pitch: cam.pitch },
ammoMag: ammoMag,
ammoReserve: ammoReserve,
reloading: reloading,
nightMode: nightMode,
score: score,
hostile: { alive: hostile.alive, hp: hostile.hp, pos: hostile.pos.slice(), dying: hostile.dying },
patrol: { alive: patrolHostile.alive, hp: patrolHostile.hp, pos: patrolHostile.pos.slice(), dying: patrolHostile.dying },
dogs: dogs.map(d=>({pos:d.pos.slice(), alive:d.alive})),
targets: targets.map(t => ({ name: t.name, hp: t.hp, dying: t.dying||0, pos: t.pos ? t.pos.slice() : null })),
lastHint: lastHintText
};
const a1 = document.createElement('a');
a1.href = URL.createObjectURL(new Blob([JSON.stringify(state,null,2)], {type:'application/json'}));
a1.download = 'muse-coach-'+stamp+'.json';
document.body.appendChild(a1); a1.click(); a1.remove();
setTimeout(function(){ URL.revokeObjectURL(a1.href); }, 2000);
const a2 = document.createElement('a');
a2.href = canvas.toDataURL('image/png');
a2.download = 'muse-coach-'+stamp+'.png';
document.body.appendChild(a2); a2.click(); a2.remove();
flashHint('COACH DUMP');
} catch (e) {
console.warn(e);
flashHint('DUMP FAIL');
}
}
function showCredit(duration=2500){
if (!creditEl) return;
creditEl.style.opacity='1';
creditEl.style.pointerEvents='auto';
setTimeout(()=>{
creditEl.style.opacity='0';
creditEl.style.pointerEvents='none';
}, duration);
}
// =====================================================================
// [e29 coach] Look picker + config panel hooks.
// Visual swap only: colliders, hitboxes, AI and timings are untouched by
// looks. Gameplay toggles (config panel) are opt-in and default to the
// shipped Phase 29 behaviour.
// =====================================================================
const cylMesh = (function(seg){
const P = [], N = [];
for (let i = 0; i < seg; i++){
const a0 = i / seg * Math.PI * 2, a1 = (i + 1) / seg * Math.PI * 2;
const c0 = Math.cos(a0), s0 = Math.sin(a0), c1 = Math.cos(a1), s1 = Math.sin(a1);
const x0 = c0*0.5, z0 = s0*0.5, x1 = c1*0.5, z1 = s1*0.5;
P.push(x0,-0.5,z0, x1,0.5,z1, x1,-0.5,z1, x0,-0.5,z0, x0,0.5,z0, x1,0.5,z1);
N.push(c0,0,s0, c1,0,s1, c1,0,s1, c0,0,s0, c0,0,s0, c1,0,s1);
P.push(0,0.5,0, x1,0.5,z1, x0,0.5,z0); N.push(0,1,0, 0,1,0, 0,1,0);
P.push(0,-0.5,0, x0,-0.5,z0, x1,-0.5,z1); N.push(0,-1,0, 0,-1,0, 0,-1,0);
}
return createMesh(new Float32Array(P), new Float32Array(N));
})(20);
function builtinGroundPixel(x, y){
// exact Phase 29 checker (moved into a function so looks can repaint)
const cx = Math.floor(x/tile)%2;
const cy = Math.floor(y/tile)%2;
const edge = ((x%tile)<2 || (y%tile)<2) ? 1 : 0;
const v = (cx ^ cy) ? 210 : 95;
return [v + edge*25, (v*0.85) + edge*18, (v*0.55) + edge*10];
}
// Look A built-ins = the exact Phase 29 values (captured before any look applies)
const LOOK_A_BUILTIN = {
id: 'A', name: 'Look A · Breaker Bay (Phase 29)',
env: {
dayClear:[0.45,0.58,0.78], dayFog:[0.45,0.58,0.78],
nightClearBase:[0.005,0.007,0.020], nightClearPerLamp:[0.004,0.005,0.008],
nightFogBase:[0.01,0.015,0.04], nightFogPerLamp:[0.004,0.005,0.01],
fogNear:8.0, fogFar:28.0,
sunDirDay:[0.5,0.8,0.6], sunDirNight:[0.25,0.95,0.35],
dayAmbient:0.25, dayDiffuse:0.75,
nightAmbientBase:0.022, nightAmbientPerLamp:0.008,
nightDiffuseBase:0.045, nightDiffusePerLamp:0.015,
lampColor1:[1.0,0.88,0.48], lampColor2:[0.95,0.82,0.42], lampBoost:2.75,
gridColor:[0.75,0.85,1.0]
},
groundPixel: null,
nodes: {},
trims: {},
lamps: { post:[0.35,0.35,0.38], bulbOn:[1.0,0.92,0.45], bulbOff:[0.22,0.22,0.24], bulbBroken:[0.12,0.12,0.13] },
ammo: { body:[0.42,0.28,0.16], lid:[0.48,0.32,0.18] },
charBox: {
hostile: { color:[0.9,0.2,0.2], spec:[0.6,0.2,0.2], shin:40 },
patrol: { color:[0.95,0.65,0.15], spec:[0.7,0.4,0.1], shin:40 },
dog: { color:dogs[0].color.slice(), spec:dogs[0].spec.slice(), shin:dogs[0].shin }
},
characters: { hostile:null, patrol:null, dog:null },
backdrop: []
};
for (const n of sceneNodes) LOOK_A_BUILTIN.nodes[n.name] = { color:n.color.slice(), spec:(n.spec||[0.2,0.2,0.2]).slice(), shin:(n.shin||32) };
LOOK_A_BUILTIN.nodes.door = { color:door.color.slice(), spec:door.spec.slice(), shin:door.shin };
{ const b = lookProp.authoredParts[0]; LOOK_A_BUILTIN.nodes.bollard = { color:b.color.slice(), spec:b.spec.slice(), shin:b.shin }; }
const lookIssues = [];
function _fin(x){ return typeof x === 'number' && isFinite(x); }
function _col(a, d){ return (Array.isArray(a) && a.length === 3 && a.every(_fin)) ? a.map(x => Math.max(0, Math.min(1, x))) : (d ? d.slice() : null); }
function _vec(a, d){ return (Array.isArray(a) && a.length === 3 && a.every(_fin) && (a[0]||a[1]||a[2])) ? a.slice() : d.slice(); }
function _num(a, d, lo, hi){ return _fin(a) ? Math.max(lo, Math.min(hi, a)) : d; }
function _partMatrix(p){
const m = identity();
m[0] = p.size[0]; m[5] = p.size[1]; m[10] = p.size[2];
m[12] = p.pos[0]; m[13] = p.pos[1]; m[14] = p.pos[2];
return m;
}
function _parts(list, max, where, opts){
const out = [];
if (!Array.isArray(list)) return out;
if (list.length > max) lookIssues.push(where + ': ' + list.length + ' parts > max ' + max + ' (extra dropped)');
for (const p of list.slice(0, max)){
if (!p || !Array.isArray(p.pos) || p.pos.length !== 3 || !p.pos.every(_fin) ||
!Array.isArray(p.size) || p.size.length !== 3 || !p.size.every(_fin)) { lookIssues.push(where + ': malformed part dropped'); continue; }
const q = {
shape: p.shape === 'cyl' ? 'cyl' : 'box',
pos: p.pos.slice(),
size: p.size.map(s => Math.max(0.005, Math.min(opts.maxSize, Math.abs(s)))),
color: _col(p.color, [0.6,0.6,0.6]),
spec: _col(p.spec, [0.2,0.2,0.2]),
shin: _num(p.shin, 24, 1, 256)
};
if (opts.backdrop && Math.abs(q.pos[0]) <= 11 && Math.abs(q.pos[2]) <= 11) { lookIssues.push(where + ': part inside play area dropped'); continue; }
q.lm = _partMatrix(q);
out.push(q);
}
return out;
}
function resolveLook(pack){
lookIssues.length = 0;
const A = LOOK_A_BUILTIN;
const src = pack || A;
const E = src.env || {};
const D = A.env;
const L = { id: String(src.id || 'A'), name: String(src.name || src.id || 'Look'), env: {} };
for (const k of ['dayClear','nightClearBase','nightClearPerLamp','nightFogBase','nightFogPerLamp','lampColor1','lampColor2']) L.env[k] = _col(E[k], D[k]);
L.env.dayFog = _col(E.dayFog, L.env.dayClear);
L.env.sunDirDay = _vec(E.sunDirDay, D.sunDirDay);
L.env.sunDirNight = _vec(E.sunDirNight, D.sunDirNight);
L.env.fogNear = _num(E.fogNear, D.fogNear, 0, 200);
L.env.fogFar = _num(E.fogFar, D.fogFar, L.env.fogNear + 1, 400);
for (const k of ['dayAmbient','dayDiffuse','nightAmbientBase','nightAmbientPerLamp','nightDiffuseBase','nightDiffusePerLamp']) L.env[k] = _num(E[k], D[k], 0, 2);
L.env.lampBoost = _num(E.lampBoost, D.lampBoost, 0, 8);
L.env.gridColor = (E.gridColor === null) ? null : _col(E.gridColor, D.gridColor);
L.groundPixel = (typeof src.groundPixel === 'function') ? src.groundPixel : null;
L.nodes = {};
const SN = src.nodes || {};
for (const name in A.nodes){
const d = A.nodes[name], n = SN[name] || {};
L.nodes[name] = { color:_col(n.color, d.color), spec:_col(n.spec, d.spec), shin:_num(n.shin, d.shin, 1, 256) };
}
L.trims = {};
const ST = src.trims || {};
for (const name in ST){
if (!A.nodes[name] || name === 'ground' || name === 'marker') { lookIssues.push('trims.' + name + ': unknown/unsupported node ignored'); continue; }
L.trims[name] = _parts(ST[name], 8, 'trims.' + name, { maxSize: 1.2 });
}
const SLm = src.lamps || {};
L.lamps = {}; for (const k in A.lamps) L.lamps[k] = _col(SLm[k], A.lamps[k]);
{ // [e29 lampfix] a shot bulb must read as OUT: never let bulbBroken be brighter than bulbOff
const lum = c => 0.2126*c[0] + 0.7152*c[1] + 0.0722*c[2];
const lb = lum(L.lamps.bulbBroken), lo = lum(L.lamps.bulbOff);
if (lb > lo && lb > 0) {
const f = (0.5 * lo) / lb;
L.lamps.bulbBroken = L.lamps.bulbBroken.map(v => v * f);
lookIssues.push('lamps.bulbBroken brighter than bulbOff: darkened so shot lamps read as out');
}
}
const SA = src.ammo || {};
L.ammo = { body:_col(SA.body, A.ammo.body), lid:_col(SA.lid, A.ammo.lid) };
L.charBox = {};
L.characters = {};
const SC = src.characters || {};
for (const k of ['hostile','patrol','dog']){
const c = SC[k] || {};
const d = A.charBox[k];
L.charBox[k] = { color:_col(c.color, d.color), spec:_col(c.spec, d.spec), shin:_num(c.shin, d.shin, 1, 256) };
const parts = _parts(c.parts, 12, 'characters.' + k, { maxSize: 1.2 });
L.characters[k] = parts.length ? parts : null;
}
L.backdrop = _parts(src.backdrop, 30, 'backdrop', { maxSize: 30, backdrop: true });
if (lookIssues.length) console.info('[look ' + L.id + '] sanitised:', lookIssues.slice());
L.issues = lookIssues.slice();
return L;
}
function paintGround(fn){
const data = imgData.data;
let failed = false;
for (let y = 0; y < sizeTex; y++){
for (let x = 0; x < sizeTex; x++){
let c = null;
if (fn && !failed) {
try { c = fn(x, y, sizeTex); } catch (err) { failed = true; console.info('[look] groundPixel threw, using built-in checker', err && err.message); }
if (!(Array.isArray(c) && c.length >= 3 && _fin(c[0]) && _fin(c[1]) && _fin(c[2]))) c = null;
}
if (!c) c = builtinGroundPixel(x, y);
const i = (y*sizeTex + x)*4;
data[i] = Math.max(0, Math.min(255, c[0]|0));
data[i+1] = Math.max(0, Math.min(255, c[1]|0));
data[i+2] = Math.max(0, Math.min(255, c[2]|0));
data[i+3] = 255;
}
}
ctx.putImageData(imgData, 0, 0);
gl.bindTexture(gl.TEXTURE_2D, albedoTex);
gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, canvasTex);
}
let curLook = resolveLook(null);
function resetLamps(){ // [e29 lampfix] fresh lamps on look switch: no dead lamps carried across looks
for (const l of lamps) { l.on = true; l.broken = false; l.hitFlash = 0; l.hitFlashColor = null; }
}
function applyLook(pack){
const prevLookId = curLook ? curLook.id : null;
curLook = resolveLook(pack);
if (prevLookId !== curLook.id) resetLamps();
const allNodes = sceneNodes.concat(parkourStash.nodes);
for (const node of allNodes){
const n = curLook.nodes[node.name];
if (!n) continue;
node.color = n.color.slice(); node.spec = n.spec.slice(); node.shin = n.shin;
}
const dn = curLook.nodes.door; door.color = dn.color.slice(); door.spec = dn.spec.slice(); door.shin = dn.shin;
const bn = curLook.nodes.bollard, bp = lookProp.authoredParts[0];
bp.color = bn.color.slice(); bp.spec = bn.spec.slice(); bp.shin = bn.shin;
for (const p of ammoPickups) p.color = curLook.ammo.body.slice();
for (const d of dogs) { d.color = curLook.charBox.dog.color.slice(); d.spec = curLook.charBox.dog.spec.slice(); d.shin = curLook.charBox.dog.shin; }
paintGround(curLook.groundPixel);
return curLook;
}
function lookFromRegistry(){
const M = window.MuseLooks;
if (!M || typeof M.get !== 'function') return null;
try { return M.get(M.active()) || null; } catch (err) { return null; }
}
function cycleLook(){
if (window.MuseLooks && typeof window.MuseLooks.next === 'function') window.MuseLooks.next();
else flashHint('LOOK A only (no look packs loaded)');
}
// ---- imported models (config panel: scene / character) ----
const importSlots = { scene: null, character: null };
function _potCanvas(img){
const w = img.width || img.videoWidth || 1, h = img.height || img.videoHeight || 1;
const pw = Math.min(1024, Math.pow(2, Math.round(Math.log2(Math.max(1, w)))));
const ph = Math.min(1024, Math.pow(2, Math.round(Math.log2(Math.max(1, h)))));
const c = document.createElement('canvas'); c.width = pw; c.height = ph;
c.getContext('2d').drawImage(img, 0, 0, pw, ph);
return c;
}
function _freeSlot(slot){
const s = importSlots[slot];
if (!s) return;
for (const p of s.parts){ try { gl.deleteBuffer(p.mesh.vbo); } catch(_){} if (p.tex && !p.sharedTex) { try { gl.deleteTexture(p.tex); } catch(_){} } } // [e32] shared textures freed once
importSlots[slot] = null;
}
function setImportedModel(slot, meshes, info){
if (slot !== 'scene' && slot !== 'character') throw new Error('slot must be scene|character');
_freeSlot(slot);
if (!meshes || !meshes.length) return null;
const parts = [];
const _texCache = new Map(); // [e32] image -> GL texture (parts that share a material share one texture)
for (const m of meshes){
const mesh = createMesh(m.positions, m.normals, m.uvs || null);
const part = { mesh: mesh, color: _col(m.color, [0.8,0.8,0.8]), spec: [0.25,0.25,0.25], shin: 32, useTex: false, useNm: false, local: null, tex: null };
{ const P = m.positions; let x0 = Infinity, y0 = Infinity, z0 = Infinity, x1 = -Infinity, y1 = -Infinity, z1 = -Infinity; // [e32] bounding sphere
for (let i = 0; i < P.length; i += 3) { const x = P[i], y = P[i+1], z = P[i+2]; if (x < x0) x0 = x; if (x > x1) x1 = x; if (y < y0) y0 = y; if (y > y1) y1 = y; if (z < z0) z0 = z; if (z > z1) z1 = z; }
part.bs = P.length ? [(x0+x1)/2, (y0+y1)/2, (z0+z1)/2, Math.hypot(x1-x0, y1-y0, z1-z0) / 2] : null; }
const _tk = m.image ? (_texCache.get(m.image) || {})[m.flipY ? 1 : 0] : null;
if (_tk) { part.tex = _tk; part.useTex = true; part.sharedTex = true; }
else if (m.image) {
try {
const tex = gl.createTexture();
gl.bindTexture(gl.TEXTURE_2D, tex);
gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, !!m.flipY);
gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, _potCanvas(m.image));
gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, false);
gl.generateMipmap(gl.TEXTURE_2D);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR_MIPMAP_LINEAR);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.REPEAT);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.REPEAT);
part.tex = tex; part.useTex = true;
{ const e = _texCache.get(m.image) || {}; e[m.flipY ? 1 : 0] = tex; _texCache.set(m.image, e); } // [e32]
} catch (err) { console.info('[import] texture skipped', err && err.message); }
}
parts.push(part);
}
importSlots[slot] = { parts: parts, info: info || {} };
flashHint((slot === 'scene' ? 'SCENE MODEL ' : 'CHARACTER MODEL ') + ((info && info.name) || ''));
return importSlots[slot].info;
}
function clearImportedModel(slot){ _freeSlot(slot); flashHint(slot === 'scene' ? 'SCENE: BUILT-IN' : 'CHARACTERS: BUILT-IN'); }
// ---- config (gameplay toggles) ----
const CFG_KEY = 'muse-engine-29.settings';
const ZERO3 = [0, 0, 0];
// Every default reproduces the original Phase 29 behaviour exactly.
const CFG_DEFAULTS = {
// engine parts
shadows: true, textures: true, lightExtras: true, fx: true, fog: true,
collision: true, enemyAI: true, gravity: true, sound: true,
// gameplay / scene
enemies: true, enemyAttack: true, dogs: true,
playerShoot: true, infiniteAmmo: false,
jump: true, parkour: true,
deathFx: true, hud: true, grid: true, bollard: true, night: false,
builtinProps: true, importDog: false,
stripRootMotion: true // [e32] play clips in place (root motion removed)
};
const cfg = Object.assign({}, CFG_DEFAULTS);
try { const raw = localStorage.getItem(CFG_KEY); if (raw) { const o = JSON.parse(raw); for (const k in CFG_DEFAULTS) if (typeof o[k] === 'boolean') cfg[k] = o[k]; } } catch (_) {}
const shadowCapable = useShadowMap;
const parkourStash = { nodes: [], blocks: [] };
const PARKOUR_NAMES = /^(parkour\d|ladder|ladderDeck)$/;
function _applyParkour(on){
if (level && level.active) return; // [e30] built-in parkour is stashed while a scene is the level
if (!on && !parkourStash.nodes.length) {
for (let i = sceneNodes.length - 1; i >= 0; i--) if (PARKOUR_NAMES.test(sceneNodes[i].name)) parkourStash.nodes.unshift(sceneNodes.splice(i, 1)[0]);
parkourStash.blocks = parkourBlocks.splice(0, parkourBlocks.length);
onLadder = false;
} else if (on && parkourStash.nodes.length) {
for (const n of parkourStash.nodes) sceneNodes.push(n);
for (const b of parkourStash.blocks) parkourBlocks.push(b);
parkourStash.nodes = []; parkourStash.blocks = [];
}
}
const hudEls = function(){ return [fpsEl, document.getElementById('hud'), document.getElementById('banner'), hintEl]; };
function applyConfig(){
_applyParkour(cfg.parkour);
useShadowMap = cfg.shadows && shadowCapable;
lookProp.visible = cfg.bollard;
nightMode = cfg.night;
if (cfg.infiniteAmmo && ammoMag <= 0) ammoMag = MAG_CAP;
for (const el of hudEls()) if (el) el.style.visibility = cfg.hud ? '' : 'hidden';
}
function setConfig(partial, silent){
for (const k in partial) if (k in CFG_DEFAULTS && typeof partial[k] === 'boolean') cfg[k] = partial[k];
applyConfig();
try { localStorage.setItem(CFG_KEY, JSON.stringify(cfg)); } catch (_) {}
return Object.assign({}, cfg);
}
// ---- pause / input block while an overlay (start screen, config panel) is open ----
let uiBlocked = false;
function setBlocked(on){
uiBlocked = !!on;
if (uiBlocked) {
for (const k in keys) keys[k] = false;
mouseDown = false; pendingShoot = false;
stopDemoDrive();
if (document.pointerLockElement) document.exitPointerLock?.();
}
}
// ---- draw helpers for look parts / imported models ----
const FLASH_SPEC = [0.9,0.8,0.5];
function drawLookParts(parts, parentM, flashCol, depth){
for (let i = 0; i < parts.length; i++){
const p = parts[i];
const wm = multiply(p.lm, parentM); // engine multiply(a,b) == B·A → parent · local
const mesh = p.shape === 'cyl' ? cylMesh : crateMesh;
if (depth) { drawMeshDepth(mesh, wm); continue; }
gl.uniform1f(uUseTex, 0.0);
drawMesh(mesh, wm, flashCol || p.color, flashCol ? FLASH_SPEC : p.spec, flashCol ? 40 : p.shin);
}
}
function drawImportParts(slot, parentM, flashCol, depth){
const s = importSlots[slot]; if (!s) return;
for (const part of s.parts){
if (depth) { drawMeshDepth(part.mesh, parentM); continue; }
if (slot === 'scene' && parentM === IDENT && !e32Visible(part)) continue; // [e32] frustum culling (batched level parts)
if (flashCol) drawTexturedPart({ mesh: part.mesh, color: flashCol, spec: FLASH_SPEC, shin: 40, useTex: false, local: null }, parentM);
else drawTexturedPart(part, parentM);
}
if (!depth) gl.uniform1f(uUseTex, 0.0);
}
// kind: hostile|patrol|dog. m = the existing collider-sized body matrix.
function drawCharacter(kind, m, mesh, color, spec, shin, flashing, depth){
if (e31Draw(kind, flashing ? color : null, depth)) return; // [e31] animated rig
if (importSlots.character && !importSlots.character.rig && (kind !== 'dog' || cfg.importDog)) { drawImportParts('character', m, flashing ? color : null, depth); return; }
const parts = curLook.characters[kind];
if (parts) { drawLookParts(parts, m, flashing ? color : null, depth); return; }
if (depth) { drawMeshDepth(mesh, m); return; }
gl.uniformMatrix4fv(uModel, false, m);
drawMesh(mesh, m, color, spec, shin);
}
function drawNodeTrims(node, model, flashCol, depth){
const t = curLook.trims[node.name];
if (t && t.length) drawLookParts(t, model, flashCol, depth);
}
function hideBuiltinProp(node){
return !cfg.builtinProps && !!importSlots.scene && node.name !== 'ground' && node.name !== 'marker';
}
const IDENT = identity();
function drawLookWorldExtras(depth){
if (curLook.backdrop.length) drawLookParts(curLook.backdrop, IDENT, null, depth);
if (importSlots.scene) drawImportParts('scene', IDENT, null, depth);
}
// ---- public API for looks/, ui/ scripts and the local test harness ----
window.MuseEngine29 = {
version: 'e29-lookpicker-1',
applyLook: function(){ return applyLook(lookFromRegistry()); },
look: function(){ return { id: curLook.id, name: curLook.name, issues: curLook.issues.slice() }; },
builtinLookA: function(){ return JSON.parse(JSON.stringify(LOOK_A_BUILTIN)); },
groundPixelBuiltin: function(x, y){ return builtinGroundPixel(x, y); },
cycleLook: cycleLook,
getConfig: function(){ return Object.assign({}, cfg); },
configDefaults: function(){ return Object.assign({}, CFG_DEFAULTS); },
setConfig: setConfig,
setBlocked: setBlocked,
isBlocked: function(){ return uiBlocked; },
setImportedModel: setImportedModel,
clearImportedModel: clearImportedModel,
importInfo: function(slot){ return importSlots[slot] ? Object.assign({}, importSlots[slot].info) : null; },
flashHint: function(t){ flashHint(t); },
status: function(){
return {
look: curLook.id, fps: fps, paused: uiBlocked, night: nightMode, shadows: useShadowMap,
hp: playerHP, ammoMag: ammoMag, ammoReserve: ammoReserve, score: score, airY: airY,
cam: [cam.pos[0], cam.pos[1], cam.pos[2]],
hostile: { alive: hostile.alive, hp: hostile.hp, dying: hostile.dying, pos: hostile.pos.slice() },
patrol: { alive: patrolHostile.alive, hp: patrolHostile.hp, dying: patrolHostile.dying, pos: patrolHostile.pos.slice() },
dogs: dogs.map(d => ({ alive: d.alive, pos: d.pos.slice() })),
sceneNodes: sceneNodes.length, parkourBlocks: parkourBlocks.length, lastHint: lastHintText,
lookProp: { visible: !!lookProp.visible, parts: (lookProp.parts || []).length }, // [lookB-fix]
lamps: lamps.map(l => ({ name: l.name, on: l.on, broken: l.broken, lit: lampLit(l) })), // [e29 lampfix]
imports: { scene: importSlots.scene ? importSlots.scene.info : null, character: importSlots.character ? importSlots.character.info : null }
};
}
};
if (/[?&]test=1/.test(location.search)) {
// local test harness only (not used by the UI)
window.MuseEngine29.test = {
place: function(x, z, yaw, pitch){ cam.pos[0] = x; cam.pos[2] = z; if (yaw != null) cam.yaw = yaw; if (pitch != null) cam.pitch = pitch; },
aimAt: function(which){
const h = which === 'patrol' ? patrolHostile : hostile;
const tx = h.pos[0], tz = h.pos[2], ty = (h.baseY || 0) + h.scale * 0.5;
const dx = tx - cam.pos[0], dz = tz - cam.pos[2], dy = ty - cam.pos[1];
cam.yaw = Math.atan2(dx, -dz); cam.pitch = Math.atan2(dy, Math.hypot(dx, dz));
return [cam.yaw, cam.pitch];
},
shoot: function(){ shootCooldown = 0; tryShoot(); return { ammoMag: ammoMag, score: score }; },
jump: function(){ keys['Space'] = true; jumpBufferTimer = JUMP_BUFFER; setTimeout(function(){ keys['Space'] = false; }, 80); },
aimAtLamp: function(i){ // [e29 lampfix] aim at the centre of lamp i's bulb
const t = lampBulbTip(lamps[i]);
const dx = t[0] - cam.pos[0], dz = t[2] - cam.pos[2], dy = t[1] - cam.pos[1];
cam.yaw = Math.atan2(dx, -dz); cam.pitch = Math.atan2(dy, Math.hypot(dx, dz));
return [cam.yaw, cam.pitch];
},
lampColors: function(){ return JSON.parse(JSON.stringify(curLook.lamps)); },
freezeHostiles: function(on){ hostile.speed = on ? 0 : 1.35; patrolHostile.speed = on ? 0 : 1.8; }
};
}
applyConfig();
{
const qm = location.search.match(/[?&]look=([A-Za-z0-9_-]+)/);
if (qm && window.MuseLooks && typeof window.MuseLooks.get === 'function' && window.MuseLooks.get(qm[1])) {
try { window.MuseLooks.setActive(qm[1]); } catch (_) {}
}
}
applyLook(lookFromRegistry());
if (window.MuseLooks && typeof window.MuseLooks.onChange === 'function') {
window.MuseLooks.onChange(function(){
applyLook(lookFromRegistry());
flashHint('LOOK ' + curLook.id + ' · ' + curLook.name);
});
}
// ===================== [e29 coach] end of look/config block =====================
// ===================== [e30 coach] Phase 30: loaded scene = the level (mesh colliders), crosshair fix, pyramid hit =====================
// The collider maths (grid, ground/wall/ray queries, spawn search) is Muse-authored with coach fixes: engine/physics/mesh-collider.js
// (see game/muse-authored/phase30/FIXES-P30.md). The footprint probe below is coach code.
// This block wires it into the Phase 28/29 movement, AI, shooting and draw code. Built-in colliders come back when the
// "Scene colliders" toggle is off or the scene is cleared.
CFG_DEFAULTS.sceneColliders = true;
try { const o30 = JSON.parse(localStorage.getItem(CFG_KEY) || '{}'); cfg.sceneColliders = (typeof o30.sceneColliders === 'boolean') ? o30.sceneColliders : true; } catch (_) { cfg.sceneColliders = true; }
var level = { collider: null, spawnNode: null, spawn: null, active: false, stash: null, stats: null, respawns: 0, lastShot: null, buildMs: 0 };
const LV_H = 1.75, BUILTIN_SPAWN = [0, 1.6, 5];
function levelOn(){ return !!(level && level.active); }
function _lvCell(stats){ const sx = stats.max[0] - stats.min[0], sz = stats.max[2] - stats.min[2]; return Math.max(1.0, Math.min(8.0, Math.sqrt(Math.max(1, sx * sz) / Math.max(1, stats.tris / 12)))); }
function buildLevelCollider(positions){
const MC = window.MuseMeshCollider;
if (!MC || !MC.build || !positions || positions.length < 9) return null;
const t0 = performance.now();
let mn = [Infinity, Infinity, Infinity], mx = [-Infinity, -Infinity, -Infinity];
for (let i = 0; i < positions.length; i += 3) for (let k = 0; k < 3; k++) { const v = positions[i + k]; if (v < mn[k]) mn[k] = v; if (v > mx[k]) mx[k] = v; }
const cell = _lvCell({ min: mn, max: mx, tris: positions.length / 9 });
const c = MC.build(positions, { cell: cell, walkableNy: 0.7 });
level.buildMs = Math.round(performance.now() - t0);
return c;
}
// [e30 coach] player footprint probe: centre + 8 points just OUTSIDE the wall radius (r + 3 cm). Muse's groundAtDisc samples at
// 0.7 r, i.e. inside the cylinder, so a riser blocked the player (wallHit at r) before the step top was ever seen and
// step-up/mantle only worked when a long frame jumped past it. Probing at r + 3 cm sees the top first.
const _LV_PR = PLAYER_R + 0.03, _LV_D = _LV_PR * Math.SQRT1_2;
const _LV_PROBE = [[0, 0], [_LV_PR, 0], [-_LV_PR, 0], [0, _LV_PR], [0, -_LV_PR], [_LV_D, _LV_D], [_LV_D, -_LV_D], [-_LV_D, _LV_D], [-_LV_D, -_LV_D]];
function _lvGround(x, z, maxY){
const C = level.collider; let best = null;
for (let i = 0; i < 9; i++) { const g = C.groundAt(x + _LV_PROBE[i][0], z + _LV_PROBE[i][1], maxY); if (g != null && (best == null || g > best)) best = g; }
return best;
}
function levelFloor(px, pz, fromY){ const g = _lvGround(px, pz, fromY + 0.55); return g == null ? -1e9 : g; }
function levelBlockedAt(px, pz, feetY){
const C = level.collider;
const g = _lvGround(px, pz, feetY + MANTLE_MAX + 0.05);
const base = (g != null && g > feetY) ? g : feetY;
if (C.wallHit(px, pz, PLAYER_R, base + 0.15, base + LV_H)) return feetY + 50; // wall: not steppable
if (g != null && g > feetY + 0.02) return g; // ledge / step / mantle top
return null;
}
function levelPushPlayer(){
const C = level.collider;
for (let i = 0; i < 3; i++) {
const p = C.pushOut(cam.pos[0], cam.pos[2], PLAYER_R, airY + STEP_UP + 0.05, airY + LV_H);
if (!p || (!p[0] && !p[1])) break;
cam.pos[0] += p[0]; cam.pos[2] += p[1];
}
}
function levelCanStand(x, z, r, baseY, h){
const C = level.collider;
const g = C.groundAtDisc(x, z, r, baseY + 0.55);
if (g == null || g < baseY - 1.2) return null; // no floor / cliff: AI stays on its level
const b = Math.max(g, baseY);
if (C.wallHit(x, z, r, b + 0.15, b + h)) return null;
return g;
}
function _charBase(o, isDog){ return isDog ? (o.pos[1] - (o._halfY != null ? o._halfY : 0.25)) : (o.baseY || 0); }
function _setCharBase(o, g, isDog){ if (isDog) o.pos[1] = g + (o._halfY != null ? o._halfY : 0.25); else { o.baseY = g; } }
function levelMoveChar(o, x, z, r, h, isDog){
const base = _charBase(o, isDog);
let g = levelCanStand(x, z, r, base, h);
if (g != null) { o.pos[0] = x; o.pos[2] = z; _setCharBase(o, g, isDog); return true; }
g = levelCanStand(x, o.pos[2], r, base, h);
if (g != null) { o.pos[0] = x; _setCharBase(o, g, isDog); return true; }
g = levelCanStand(o.pos[0], z, r, base, h);
if (g != null) { o.pos[2] = z; _setCharBase(o, g, isDog); return true; }
return false;
}
function _lvSpawnPoint(hx, hz){ try { return level.collider.findSpawn(hx, hz, {}); } catch (err) { console.warn('[level] findSpawn', err); return null; } }
function _placePlayer(p){ cam.pos[0] = p[0]; cam.pos[2] = p[2]; airY = p[1]; velY = 0; onGround = true; onLadder = false; cam.pos[1] = standEye + airY; }
function respawnInLevel(){ if (level.spawn) { _placePlayer(level.spawn); level.respawns++; flashHint('RESPAWN'); } }
function activateLevel(){
const C = level.collider, st = C.stats;
const S = level.stash = {
nodes: sceneNodes.splice(0, sceneNodes.length), lamps: lamps.splice(0, lamps.length), pickups: ammoPickups.splice(0, ammoPickups.length),
door: door.pos.slice(), ladder: ladder.pos.slice(), deck: ladderDeck.pos.slice(), bollard: lookProp.visible,
hostile: { pos: hostile.pos.slice(), baseY: hostile.baseY }, patrol: { pos: patrolHostile.pos.slice(), baseY: patrolHostile.baseY, a: patrolHostile.waypointA.slice(), b: patrolHostile.waypointB.slice() },
dogs: dogs.map(d => d.pos.slice()), cam: [cam.pos[0], cam.pos[1], cam.pos[2], cam.yaw, cam.pitch], airY: airY
};
refreshTargets();
door.pos[0] = 9999; door.pos[1] = -500; door.pos[2] = 9999;
ladder.pos[0] = 9999; ladder.pos[2] = 9999; ladderDeck.pos[0] = 9999; ladderDeck.pos[2] = 9999;
lookProp.visible = false;
// spawn: named node (PlayerStart/spawn) snapped to the floor, else nearest valid spot to the scene centre
const cx = (st.min[0] + st.max[0]) / 2, cz = (st.min[2] + st.max[2]) / 2;
let sp = null;
if (level.spawnNode) {
const n = level.spawnNode;
const g = C.groundAtDisc(n[0], n[2], PLAYER_R, n[1] + 1.0);
if (g != null && !C.wallHit(n[0], n[2], PLAYER_R, g + 0.3, g + LV_H)) sp = [n[0], g, n[2]];
else sp = _lvSpawnPoint(n[0], n[2]);
level.spawnSource = sp ? 'node' : 'search';
}
if (!sp) { sp = _lvSpawnPoint(cx, cz); level.spawnSource = sp ? 'search' : 'none'; }
if (!sp) sp = [cx, st.max[1] + 0.5, cz];
level.spawn = sp;
_placePlayer(sp);
cam.yaw = Math.atan2(cx - sp[0], -(cz - sp[2])) || 0; cam.pitch = -0.08;
// enemies: move onto valid floor near the player (keep their AI); dogs keep their height offset
const put = function(o, hx, hz, isDog){ const p = _lvSpawnPoint(hx, hz); if (!p) return false; o.pos[0] = p[0]; o.pos[2] = p[2]; _setCharBase(o, p[1], isDog); return true; };
const fx = Math.sin(cam.yaw), fz = -Math.cos(cam.yaw);
put(hostile, sp[0] + fx * 9 + fz * 3, sp[2] + fz * 9 - fx * 3, false);
if (put(patrolHostile, sp[0] + fx * 6 - fz * 4, sp[2] + fz * 6 + fx * 4, false)) {
const a = patrolHostile.pos.slice(); const b2 = _lvSpawnPoint(a[0] - fz * 5, a[2] + fx * 5) || a;
patrolHostile.waypointA = [a[0], a[1], a[2]]; patrolHostile.waypointB = [b2[0], a[1], b2[2]];
}
for (let i = 0; i < dogs.length; i++) { const d = dogs[i]; if (d._halfY == null) d._halfY = S.dogs[i][1]; put(d, sp[0] + fx * 4 + fz * (2 + i), sp[2] + fz * 4 - fx * (2 + i), true); }
level.active = true;
flashHint('LEVEL: ' + ((importSlots.scene && importSlots.scene.info.name) || 'scene') + ' · colliders ' + st.tris + ' tris');
}
function deactivateLevel(){
const S = level.stash; level.active = false;
if (S) {
for (const n of S.nodes) sceneNodes.push(n); for (const l of S.lamps) lamps.push(l); for (const p of S.pickups) ammoPickups.push(p);
refreshTargets();
for (let k = 0; k < 3; k++) { door.pos[k] = S.door[k]; ladder.pos[k] = S.ladder[k]; ladderDeck.pos[k] = S.deck[k]; }
lookProp.visible = cfg.bollard;
for (let k = 0; k < 3; k++) { hostile.pos[k] = S.hostile.pos[k]; patrolHostile.pos[k] = S.patrol.pos[k]; }
hostile.baseY = S.hostile.baseY; patrolHostile.baseY = S.patrol.baseY; patrolHostile.waypointA = S.patrol.a.slice(); patrolHostile.waypointB = S.patrol.b.slice();
dogs.forEach((d, i) => { for (let k = 0; k < 3; k++) d.pos[k] = S.dogs[i][k]; });
}
level.stash = null;
cam.pos[0] = BUILTIN_SPAWN[0]; cam.pos[2] = BUILTIN_SPAWN[2]; airY = 0; velY = 0; onGround = true; cam.pos[1] = standEye; cam.yaw = 0; cam.pitch = 0;
applyConfig();
flashHint('BUILT-IN COLLIDERS');
}
function syncLevel(){
const want = !!(level.collider && importSlots.scene && importSlots.scene.info && importSlots.scene.info.mode === 'level' && cfg.sceneColliders);
if (want && !level.active) activateLevel();
else if (!want && level.active) deactivateLevel();
}
const _setImported29 = setImportedModel, _clearImported29 = clearImportedModel;
function setImportedModel30(slot, meshes, info, extra){
if (slot === 'scene' && level.active) deactivateLevel();
if (slot === 'scene') { level.collider = null; level.spawnNode = null; level.spawn = null; level.stats = null; }
const out = _setImported29(slot, meshes, info);
if (slot === 'scene' && extra && extra.collision && extra.collision.length >= 9) {
level.collider = buildLevelCollider(extra.collision);
level.spawnNode = extra.spawn || null;
if (level.collider) {
const s = level.collider.stats;
level.stats = { tris: s.tris, walkable: s.walkable, walls: s.walls, cells: s.cells, buildMs: level.buildMs };
if (importSlots.scene) importSlots.scene.info.collider = level.stats;
} else if (importSlots.scene) importSlots.scene.info.collider = null;
}
syncLevel();
if (slot === 'scene' && importSlots.scene) {
importSlots.scene.info.levelActive = level.active;
importSlots.scene.info.spawn = level.spawn ? level.spawn.map(v => +v.toFixed(3)) : null;
importSlots.scene.info.spawnSource = level.active ? level.spawnSource : null;
}
return importSlots[slot] ? importSlots[slot].info : out;
}
function clearImportedModel30(slot){
if (slot === 'scene') { if (level.active) deactivateLevel(); level.collider = null; level.spawnNode = null; level.spawn = null; level.stats = null; }
_clearImported29(slot);
}
function levelShotTest(eye, dir, bestT){
let hit = null;
if (levelOn()) { const h = level.collider.raycast(eye[0], eye[1], eye[2], dir[0], dir[1], dir[2], 200); if (h && h.t < bestT) hit = h; }
return hit;
}
function recordShot(eye, dir, t){ level.lastShot = { eye: eye.slice(), dir: dir.slice(), t: (t === Infinity ? null : t) }; }
function e30LevelHit(best){
const st = HIT_STYLES.wall;
showHitMarker(st);
flashHint('SCENE HIT');
}
// --- [e30] pyramid: its square AABB also covered empty air around the slopes (e.g. lamp1 seen from spawn read STONE HIT) ---
const _PYR = [[-1.2,0,-1.2],[1.2,0,-1.2],[1.2,0,1.2],[-1.2,0,1.2],[0,1.8,0]];
const _PYR_F = [[0,1,4],[1,2,4],[2,3,4],[3,0,4],[0,3,2],[0,2,1]];
function _rayTri(o, d, a, b, c){
const e1 = [b[0]-a[0], b[1]-a[1], b[2]-a[2]], e2 = [c[0]-a[0], c[1]-a[1], c[2]-a[2]];
const p = [d[1]*e2[2]-d[2]*e2[1], d[2]*e2[0]-d[0]*e2[2], d[0]*e2[1]-d[1]*e2[0]];
const det = e1[0]*p[0] + e1[1]*p[1] + e1[2]*p[2];
if (Math.abs(det) < 1e-9) return null;
const inv = 1 / det, s = [o[0]-a[0], o[1]-a[1], o[2]-a[2]];
const u = (s[0]*p[0] + s[1]*p[1] + s[2]*p[2]) * inv; if (u < 0 || u > 1) return null;
const q = [s[1]*e1[2]-s[2]*e1[1], s[2]*e1[0]-s[0]*e1[2], s[0]*e1[1]-s[1]*e1[0]];
const v = (d[0]*q[0] + d[1]*q[1] + d[2]*q[2]) * inv; if (v < 0 || u + v > 1) return null;
const t = (e2[0]*q[0] + e2[1]*q[1] + e2[2]*q[2]) * inv;
return t > 1e-6 ? t : null;
}
function pyramidRayT(node, eye, dir){
const sc = (typeof node.scale === 'number') ? node.scale : 1, P = node.pos;
const V = _PYR.map(v => [P[0] + v[0]*sc, P[1] + v[1]*sc, P[2] + v[2]*sc]);
let best = null;
for (const f of _PYR_F) { const t = _rayTri(eye, dir, V[f[0]], V[f[1]], V[f[2]]); if (t != null && (best == null || t < best)) best = t; }
return best;
}
// --- [e30] crosshair + hit marker follow the game view (canvas) centre, not the window centre ---
let _xhKey = '';
function syncCrosshair(){
const r = canvas.getBoundingClientRect();
const k = r.left + ',' + r.top + ',' + r.width + ',' + r.height;
if (k === _xhKey) return;
_xhKey = k;
const x = (r.left + r.width / 2) + 'px', y = (r.top + r.height / 2) + 'px';
crossEl.style.left = x; crossEl.style.top = y; hitMarkEl.style.left = x; hitMarkEl.style.top = y;
}
window.addEventListener('scroll', function(){ _xhKey = ''; syncCrosshair(); }, true);
window.addEventListener('resize', function(){ _xhKey = ''; syncCrosshair(); });
let _e30Proj = null, _e30View = null;
function e30Frame(){
syncCrosshair();
if (levelOn()) {
if (lookProp.visible) lookProp.visible = false; // K / bollard toggle has no place in a loaded level
if (level.collider && airY < level.collider.stats.min[1] - 12) respawnInLevel(); // fell out of the level
}
}
function e30Matrices(proj, view){ _e30Proj = proj; _e30View = view; e32Frustum(proj, view); } // [e32] frustum planes per frame
function _mulV(m, v){ return [m[0]*v[0]+m[4]*v[1]+m[8]*v[2]+m[12]*v[3], m[1]*v[0]+m[5]*v[1]+m[9]*v[2]+m[13]*v[3], m[2]*v[0]+m[6]*v[1]+m[10]*v[2]+m[14]*v[3], m[3]*v[0]+m[7]*v[1]+m[11]*v[2]+m[15]*v[3]]; }
window.MuseEngine29.version = 'e30-scene-level-1';
window.MuseEngine29.setImportedModel = setImportedModel30;
window.MuseEngine29.clearImportedModel = clearImportedModel30;
{ const _sc29 = window.MuseEngine29.setConfig; window.MuseEngine29.setConfig = function(p, s){ const r = _sc29(p, s); syncLevel(); return Object.assign({}, cfg); }; }
window.MuseEngine29.level = function(){
return { active: level.active, hasCollider: !!level.collider, stats: level.stats, spawn: level.spawn, spawnSource: level.spawnSource || null,
spawnNode: level.spawnNode, respawns: level.respawns, sceneColliders: cfg.sceneColliders };
};
window.MuseEngine29.respawn = function(){ if (levelOn()) respawnInLevel(); else { cam.pos[0] = BUILTIN_SPAWN[0]; cam.pos[2] = BUILTIN_SPAWN[2]; airY = 0; velY = 0; } };
{ const _st29 = window.MuseEngine29.status; window.MuseEngine29.status = function(){ const s = _st29(); s.level = window.MuseEngine29.level(); s.onGround = onGround; s.feetY = airY; return s; }; }
if (window.MuseEngine29.test) {
const T = window.MuseEngine29.test;
T.placeFeet = function(x, feetY, z, yaw, pitch){ cam.pos[0] = x; cam.pos[2] = z; airY = feetY; velY = 0; onGround = false; cam.pos[1] = standEye + airY; if (yaw != null) cam.yaw = yaw; if (pitch != null) cam.pitch = pitch; };
T.lastShot = function(){ const s = level.lastShot; if (!s || s.t == null) return s; return { eye: s.eye, dir: s.dir, t: s.t, point: [s.eye[0]+s.dir[0]*s.t, s.eye[1]+s.dir[1]*s.t, s.eye[2]+s.dir[2]*s.t] }; };
T.project = function(x, y, z){ // world -> CSS pixel (page) coordinates of the game view
if (!_e30Proj) return null;
const c = _mulV(_e30Proj, _mulV(_e30View, [x, y, z, 1]));
if (c[3] <= 0) return null;
const r = canvas.getBoundingClientRect();
return [r.left + (c[0] / c[3] * 0.5 + 0.5) * r.width, r.top + (1 - (c[1] / c[3] * 0.5 + 0.5)) * r.height];
};
T.crosshair = function(){ const r = crossEl.getBoundingClientRect(); return [r.left + r.width / 2, r.top + r.height / 2]; };
T.ground = function(x, z, maxY){ return level.collider ? level.collider.groundAt(x, z, maxY == null ? 1e6 : maxY) : null; };
T.wallHit = function(x, z, y0, y1){ return level.collider ? level.collider.wallHit(x, z, PLAYER_R, y0, y1) : null; };
T.pyramidRayT = function(){ const n = targets.concat(level.stash ? level.stash.nodes : []).find(t => t.name === 'objPyramid'); return n ? pyramidRayT(n, cam.pos.slice(), [Math.sin(cam.yaw)*Math.cos(cam.pitch), Math.sin(cam.pitch), -Math.cos(cam.yaw)*Math.cos(cam.pitch)]) : null; };
}
// ===================== [e30 coach] end of Phase 30 block =====================
// ===================== [e31 coach] Phase 31: animated characters (GPU skinning, clip roles, capsule + head/body hitboxes) =====================
// Muse-authored maths (engine/anim/*.js, reviewed + fixed by the coach, see game/muse-authored/phase31/FIXES-P31.md):
// MuseSkeletonPose (sampling, crossfade, world + palette matrices), MuseClipMap (clip roles), MuseCapsuleFit (capsule, head sphere, ray tests),
// MuseBoneBudget (joint palette <= E31_MAX_BONES). The importer (engine/ui/model-import.js toCharacterRig) builds the rig.
// This block is coach plumbing: GPU buffers, per-actor animation state machine, hitboxes, death clip, API + test hooks.
var e31 = { rig: null, actors: { hostile: null, patrol: null }, runSpeed: 2.2, idleSpeed: 0.18, fade: 0.2, deathHold: 1.2,
overrides: {}, roles: null, lastHit: null, pendingHint: null, forcedSpeed: { hostile: null, patrol: null } };
const E31_ROLES = ['idle', 'walk', 'run', 'shoot', 'death'];
function e31On(){ return !!(e31.rig && importSlots.character && importSlots.character.rig === e31.rig); }
// column-major 4x4 helpers (C = A * B), independent of the engine's multiply() argument order
function _m4mul(a, b){ const o = new Float32Array(16); for (let c = 0; c < 4; c++) for (let r = 0; r < 4; r++) { o[c*4+r] = a[r]*b[c*4] + a[4+r]*b[c*4+1] + a[8+r]*b[c*4+2] + a[12+r]*b[c*4+3]; } return o; }
function _m4TRy(x, y, z, yaw){ const c = Math.cos(yaw), s = Math.sin(yaw); return new Float32Array([c,0,-s,0, 0,1,0,0, s,0,c,0, x,y,z,1]); }
function _m4Rx(a){ const c = Math.cos(a), s = Math.sin(a); return new Float32Array([1,0,0,0, 0,c,s,0, 0,-s,c,0, 0,0,0,1]); }
function _m4S(x, y, z){ return new Float32Array([x,0,0,0, 0,y,0,0, 0,0,z,0, 0,0,0,1]); }
function _m4pt(m, p){ return [m[0]*p[0]+m[4]*p[1]+m[8]*p[2]+m[12], m[1]*p[0]+m[5]*p[1]+m[9]*p[2]+m[13], m[2]*p[0]+m[6]*p[1]+m[10]*p[2]+m[14]]; }
function _angLerp(a, b, t){ let d = b - a; while (d > Math.PI) d -= 2*Math.PI; while (d < -Math.PI) d += 2*Math.PI; return a + d * t; }
function e31ActorOf(h){ return h === hostile ? e31.actors.hostile : h === patrolHostile ? e31.actors.patrol : null; }
function e31Roles(){
const rig = e31.rig; if (!rig) return null;
const CM = window.MuseClipMap;
let m = null;
try { m = (CM && CM.match) ? CM.match(rig.clipNames, { overrides: e31.overrides }) : null; } catch (err) { console.warn('[e31] clip match', err); }
if (!m) m = rig.match || { roles: { idle: -1, walk: -1, run: -1, shoot: -1, death: -1 }, unmatched: [] };
e31.roles = m;
if (importSlots.character) { importSlots.character.info.roles = Object.assign({}, m.roles); importSlots.character.info.unmatched = (m.unmatched || []).slice(); importSlots.character.info.overrides = Object.assign({}, e31.overrides); }
return m;
}
function e31Clip(role){
const R = (e31.roles || {}).roles || {}; const g = (k) => (R[k] != null && R[k] >= 0) ? R[k] : -1;
if (role === 'walk') { const w = g('walk'); return w >= 0 ? w : (g('run') >= 0 ? g('run') : g('idle')); }
if (role === 'run') { const r = g('run'); return r >= 0 ? r : (g('walk') >= 0 ? g('walk') : g('idle')); }
return g(role);
}
function e31MakeActor(h){
const SP = window.MuseSkeletonPose, rig = e31.rig, N = rig.skeleton.nodes.length;
const a = { fader: new SP.Fader(rig.skeleton), pose: SP.createPose(N), world: new Float32Array(16 * N), palette: new Float32Array(12 * Math.max(1, rig.palette.slots)),
role: null, clip: -1, speed: 0, last: [h.pos[0], h.pos[2]], yaw: 0, shootT: 0, deathT: -1, switches: 0, history: [], model: identity(), head: null, body: null };
SP.restPose(rig.skeleton, a.pose);
return a;
}
function e31SetRig(rig){
e31.rig = rig || null; e31.actors.hostile = null; e31.actors.patrol = null; e31.overrides = {}; e31.lastHit = null;
if (!rig) return;
try { const saved = JSON.parse(localStorage.getItem('muse-engine-31.clipmap.' + (importSlots.character.info.name || '')) || 'null'); if (saved && typeof saved === 'object') e31.overrides = saved; } catch (_) {}
e31Roles();
e31.actors.hostile = e31MakeActor(hostile); e31.actors.patrol = e31MakeActor(patrolHostile);
}
// ---- per-frame: speed -> role -> crossfade -> pose -> palette; hitboxes follow the animated head ----
function e31Tick(dt){
if (!e31On()) return;
const SP = window.MuseSkeletonPose, rig = e31.rig, cap = rig.capsule;
for (const kind of ['hostile', 'patrol']) {
const h = kind === 'hostile' ? hostile : patrolHostile, a = e31.actors[kind];
if (!a || !h.alive) continue;
const dx = h.pos[0] - a.last[0], dz = h.pos[2] - a.last[1];
a.last[0] = h.pos[0]; a.last[1] = h.pos[2];
let inst = dt > 0 ? Math.hypot(dx, dz) / dt : a.speed;
if (inst > 15) inst = 0; // teleport (level activation / respawn), not movement
if (dt > 0) a.speed += (inst - a.speed) * Math.min(1, dt * 8);
if (dt > 0 && Math.hypot(dx, dz) > 1e-4 && inst <= 15) a.yaw = _angLerp(a.yaw, Math.atan2(dx, dz), Math.min(1, dt * 10));
else if (kind === 'hostile' && hostile.alerted && dt > 0) a.yaw = _angLerp(a.yaw, Math.atan2(cam.pos[0] - h.pos[0], cam.pos[2] - h.pos[2]), Math.min(1, dt * 6));
if (h.alive && !(h.dying > 0)) a.deathT = -1;
let role;
if (h.dying > 0 && e31Clip('death') >= 0 && cfg.deathFx) role = 'death';
else if (a.shootT > 0 && e31Clip('shoot') >= 0) { role = 'shoot'; a.shootT -= dt; }
else {
const run = a.role === 'run' ? a.speed > e31.runSpeed * 0.85 : a.speed > e31.runSpeed;
const move = (a.role === 'walk' || a.role === 'run') ? a.speed > e31.idleSpeed * 0.6 : a.speed > e31.idleSpeed;
role = run ? 'run' : move ? 'walk' : 'idle';
}
const ci = e31Clip(role);
if (role !== a.role || ci !== a.clip) {
if (ci >= 0 && ci !== a.clip) { a.fader.play(ci, role === 'death' ? 0.12 : e31.fade, { loop: role !== 'death' && role !== 'shoot', speed: 1 }); a.switches++; }
if (ci >= 0 && ci === a.clip && role === 'shoot') { a.fader.play(ci, 0, { loop: false }); }
a.history.push({ role: role, clip: ci, t: +performance.now().toFixed(0) }); if (a.history.length > 24) a.history.shift();
a.role = role; a.clip = ci;
}
if (a.clip >= 0) a.fader.update(dt, rig.clips, a.pose); else SP.restPose(rig.skeleton, a.pose);
SP.worldMatrices(rig.skeleton, a.pose, IDENT, a.world);
SP.skinPalette(a.world, rig.palette.nodes, rig.palette.invBind, null, a.palette);
// model matrix: placement * yaw * fit (feet at 0, capsule axis at x=z=0, metres, +Z forward)
const F = rig.fitM;
if (h.dying > 0 && role !== 'death') { // no death clip: Phase 29 fall-then-boom applied to the rig
const hs = hostileDrawScale(h), k = 1 / Math.max(0.05, h.scale);
a.model = _m4mul(_m4mul(_m4mul(_m4TRy(h.pos[0], (h.baseY || 0) - (hs.sink || 0), h.pos[2], 0), _m4Rx(hs.tip || 0)), _m4S(hs.xz * k, hs.y * k, hs.xz * k)), _m4mul(_m4TRy(0, 0, 0, a.yaw), F));
} else {
let sink = 0;
if (role === 'death') { const dur = rig.clips[a.clip].duration; sink = Math.max(0, a.deathT - dur - e31.deathHold * 0.4) * 0.9; }
a.model = _m4mul(_m4TRy(h.pos[0], (h.baseY || 0) - sink, h.pos[2], a.yaw), F);
}
// hitboxes (world): body capsule (fitted from the bind pose) + head sphere riding on the head joint
const base = h.baseY || 0;
let headTop = cap.height;
if (rig.head) {
const Mh = _m4mul(a.world.subarray(16 * rig.head.node, 16 * rig.head.node + 16), rig.head.invBindM);
const c = _m4pt(a.model, _m4pt(rig.a0M, _m4pt(Mh, rig.head.cRaw)));
a.head = { c: c, r: rig.head.r };
headTop = c[1] - base - rig.head.r; // bottom of the head sphere (chin / neck)
} else a.head = null;
// body capsule: its top hemisphere ends just under the head sphere, so head shots are not swallowed by the body
const yTop = Math.max(cap.radius * 1.05, Math.min(cap.height - cap.radius, headTop - cap.radius * 0.5));
a.body = { a: [h.pos[0], base + Math.min(cap.radius, yTop), h.pos[2]], b: [h.pos[0], base + yTop, h.pos[2]], r: cap.radius };
}
if (e31.pendingHint) { flashHint(e31.pendingHint); e31.pendingHint = null; }
}
// death: the clip replaces fall-then-boom when the rig has one (hold the last frame, sink, despawn)
const _tickDeath30 = tickHostileDeath;
tickHostileDeath = function(h, dt, hint){
const a = e31On() ? e31ActorOf(h) : null;
if (a && h.dying > 0 && cfg.deathFx && e31Clip('death') >= 0) {
if (a.deathT < 0) a.deathT = 0;
a.deathT += dt;
const dur = e31.rig.clips[e31Clip('death')].duration;
if (a.deathT >= dur + e31.deathHold) { h.dying = 0; h.alive = false; h.deathBoomPending = false; }
return true;
}
return _tickDeath30(h, dt, hint);
};
// attack beat: the shoot clip plays when an enemy lands a hit on the player
const _updHostile30 = updateHostile, _updPatrol30 = updatePatrolHostile;
updateHostile = function(dt){ const hp0 = playerHP; _updHostile30(dt); if (playerHP !== hp0) e31Shoot('hostile'); };
updatePatrolHostile = function(dt){ const hp0 = playerHP; _updPatrol30(dt); if (playerHP !== hp0) e31Shoot('patrol'); };
function e31Shoot(kind){ const a = e31.actors[kind]; if (!e31On() || !a) return false; const ci = e31Clip('shoot'); if (ci < 0) return false; a.shootT = e31.rig.clips[ci].duration; a.role = null; return true; }
function e31ChaseSpeed(h, dist){ // animated hostiles sprint (run clip) when far, walk when close
if (e31.forcedSpeed.hostile != null && h === hostile) return e31.forcedSpeed.hostile;
if (!e31On() || h.speed <= 0 || e31Clip('run') < 0) return h.speed;
return dist > 6 ? h.speed * 2.3 : h.speed;
}
function e31PatrolSpeed(){ return (e31.forcedSpeed.patrol != null) ? e31.forcedSpeed.patrol : patrolHostile.speed; }
function e31R(h){ return e31On() ? e31.rig.capsule.radius : h.scale * 0.5; }
function e31H(h){ return e31On() ? e31.rig.capsule.height : h.scale; }
// ---- shooting: head sphere vs body capsule (nearest wins); head = HEADSHOT x3 damage ----
function e31Ray(h, eye, dir){
const a = e31ActorOf(h), CF = window.MuseCapsuleFit;
if (!a || !a.body || !CF) return null;
const tb = CF.rayCapsule(eye, dir, a.body.a, a.body.b, a.body.r);
const th = a.head ? CF.raySphere(eye, dir, a.head.c, a.head.r) : -1;
let t = null, zone = null;
if (tb >= 0) { t = tb; zone = 'body'; }
if (th >= 0 && (t == null || th <= t + 1e-6)) { t = th; zone = 'head'; }
h._zone = zone;
return t;
}
function e31Damage(h){ if (!e31On()) return 1; return h._zone === 'head' ? 3 : 1; }
function e31AfterShot(best){
if (!e31On() || !best || !(best.isHostile || best.isPatrol)) return;
const h = best.isHostile ? hostile : patrolHostile;
e31.lastHit = { kind: best.isHostile ? 'hostile' : 'patrol', zone: h._zone, hp: h.hp, down: h.hp <= 0, t: +performance.now().toFixed(0) };
if (h._zone === 'head') { e31.pendingHint = h.hp <= 0 ? 'HEADSHOT · ' + (best.isHostile ? 'HOSTILE' : 'PATROL') + ' DOWN' : 'HEADSHOT'; flashHint(e31.pendingHint); }
}
// ---- draw: skinned parts with the actor's palette (main + shadow pass) ----
function e31Draw(kind, flashCol, depth){
if (!e31On()) return false;
if (kind === 'dog') return e32DrawDog(flashCol, depth); // [e32] dogs use the rig when 'Dogs use the loaded character' is on
const a = e31.actors[kind]; if (!a) return false;
const parts = importSlots.character.parts;
const locI = depth ? d_aSkinIdx : aSkinIdx, locW = depth ? d_aSkinW : aSkinW;
gl.useProgram(depth ? skinDepthProgram : skinProgram); // skinned variant (the plain programs have no skinning code)
gl.uniform4fv(depth ? d_uBones : uBones, a.palette);
for (const part of parts) {
if (!part.skinVbo) continue;
const M = part.A ? _m4mul(a.model, part.A) : a.model;
gl.bindBuffer(gl.ARRAY_BUFFER, part.skinVbo);
if (locI >= 0) { gl.enableVertexAttribArray(locI); gl.vertexAttribPointer(locI, 4, gl.FLOAT, false, 32, 0); }
if (locW >= 0) { gl.enableVertexAttribArray(locW); gl.vertexAttribPointer(locW, 4, gl.FLOAT, false, 32, 16); }
if (depth) drawMeshDepth(part.mesh, M);
else if (flashCol) drawTexturedPart({ mesh: part.mesh, color: flashCol, spec: FLASH_SPEC, shin: 40, useTex: false, local: null }, M);
else drawTexturedPart(part, M);
}
if (locI >= 0) gl.disableVertexAttribArray(locI);
if (locW >= 0) gl.disableVertexAttribArray(locW);
if (!depth) gl.uniform1f(uUseTex, 0.0);
gl.useProgram(depth ? depthProgram : program);
return true;
}
// ---- import hook: skin buffers + rig ----
const _setImported30 = setImportedModel30, _clearImported30 = clearImportedModel30;
function _e31FreeSkin(){ const s = importSlots.character; if (s) for (const p of s.parts) if (p.skinVbo) { try { gl.deleteBuffer(p.skinVbo); } catch (_) {} p.skinVbo = null; } }
function setImportedModel31(slot, meshes, info, extra){
if (slot === 'character') { _e31FreeSkin(); e31SetRig(null); }
const out = _setImported30(slot, meshes, info, extra);
if (slot === 'character' && extra && extra.rig && importSlots.character) {
const rig = extra.rig, s = importSlots.character;
if (!window.MuseSkeletonPose) { console.warn('[e31] skeleton-pose.js missing: rig drawn static'); return out; }
s.parts.forEach(function(p, i){
const m = meshes[i], n = m.positions.length / 3, d = new Float32Array(n * 8);
for (let v = 0; v < n; v++) for (let k = 0; k < 4; k++) { d[v*8+k] = m.skinIndex[v*4+k]; d[v*8+4+k] = m.skinWeight[v*4+k]; }
p.skinVbo = gl.createBuffer(); gl.bindBuffer(gl.ARRAY_BUFFER, p.skinVbo); gl.bufferData(gl.ARRAY_BUFFER, d, gl.STATIC_DRAW);
p.A = m.A ? new Float32Array(m.A) : null;
});
rig.fitM = new Float32Array(rig.fit); rig.a0M = new Float32Array(rig.a0);
if (rig.head) rig.head.invBindM = new Float32Array(rig.head.invBind);
s.rig = rig;
e31SetRig(rig);
s.info.gpuSkinning = true; s.info.maxBonesGPU = E31_MAX_BONES;
flashHint('ANIMATED CHARACTER ' + (info.name || '') + ' · ' + rig.clips.length + ' clips · ' + rig.joints.count + ' bones');
}
return importSlots[slot] ? importSlots[slot].info : out;
}
function clearImportedModel31(slot){ if (slot === 'character') { _e31FreeSkin(); e31SetRig(null); } _clearImported30(slot); }
function e31ActorStatus(kind){
const a = e31.actors[kind], h = kind === 'hostile' ? hostile : patrolHostile; if (!a) return null;
const st = a.fader.state ? a.fader.state() : {};
return { role: a.role, clip: a.clip, clipName: a.clip >= 0 ? e31.rig.clips[a.clip].name : null, speed: +a.speed.toFixed(3), yaw: +a.yaw.toFixed(3),
weight: st.weight != null ? +(+st.weight).toFixed(3) : null, fading: !!st.fading, time: st.time != null ? +(+st.time).toFixed(3) : null, done: !!st.done,
switches: a.switches, deathT: +a.deathT.toFixed(3), feetY: +(h.baseY || 0).toFixed(3), alive: h.alive, dying: h.dying, hp: h.hp,
head: a.head ? { c: a.head.c.map(v => +v.toFixed(3)), r: +a.head.r.toFixed(3) } : null,
body: a.body ? { a: a.body.a.map(v => +v.toFixed(3)), b: a.body.b.map(v => +v.toFixed(3)), r: +a.body.r.toFixed(3) } : null,
history: a.history.slice(-10) };
}
window.MuseEngine29.version = 'e31-anim-chars-1';
window.MuseEngine29.setImportedModel = setImportedModel31;
window.MuseEngine29.clearImportedModel = clearImportedModel31;
window.MuseEngine29.skinInfo = function(){ return { maxBones: E31_MAX_BONES, maxVertexUniformVectors: E31_MAXVU }; };
window.MuseEngine29.anim = function(){
if (!e31On()) return { active: false, maxBones: E31_MAX_BONES };
const rig = e31.rig;
return { active: true, maxBones: E31_MAX_BONES, clips: rig.clipNames.slice(), clipDurations: rig.clips.map(c => +c.duration.toFixed(3)), roles: Object.assign({}, e31.roles.roles), unmatched: (e31.roles.unmatched || []).slice(),
overrides: Object.assign({}, e31.overrides), joints: rig.joints.count, paletteSlots: rig.palette.slots, capsule: rig.capsule, head: rig.head ? { bone: rig.head.name, r: rig.head.r, c: rig.head.c } : null,
runSpeed: e31.runSpeed, fade: e31.fade, lastHit: e31.lastHit, hostile: e31ActorStatus('hostile'), patrol: e31ActorStatus('patrol') };
};
window.MuseEngine29.setClipOverride = function(role, index){ // index: clip index, -1 = none, null/undefined = auto
if (E31_ROLES.indexOf(role) < 0) throw new Error('role must be one of ' + E31_ROLES.join('|'));
if (index == null || index === 'auto') delete e31.overrides[role]; else e31.overrides[role] = index | 0;
if (e31On()) { try { localStorage.setItem('muse-engine-31.clipmap.' + (importSlots.character.info.name || ''), JSON.stringify(e31.overrides)); } catch (_) {} e31Roles(); for (const k in e31.actors) if (e31.actors[k]) e31.actors[k].role = null; }
return e31.roles ? Object.assign({}, e31.roles.roles) : null;
};
window.MuseEngine29.animConfig = function(o){ o = o || {}; if (o.runSpeed > 0) e31.runSpeed = +o.runSpeed; if (o.fade >= 0) e31.fade = +o.fade; return { runSpeed: e31.runSpeed, fade: e31.fade }; };
{ const _st30 = window.MuseEngine29.status; window.MuseEngine29.status = function(){ const s = _st30(); s.anim = window.MuseEngine29.anim(); return s; }; }
if (window.MuseEngine29.test) {
const T = window.MuseEngine29.test;
T.charShoot = function(kind){ return e31Shoot(kind || 'hostile'); };
T.charSpeed = function(kind, v){ e31.forcedSpeed[kind] = (v == null ? null : +v); return e31.forcedSpeed[kind]; };
T.aimAtPoint = function(x, y, z){ const dx = x - cam.pos[0], dz = z - cam.pos[2], dy = y - cam.pos[1]; cam.yaw = Math.atan2(dx, -dz); cam.pitch = Math.atan2(dy, Math.hypot(dx, dz)); return [cam.yaw, cam.pitch]; };
T.headPoint = function(kind){ const a = e31.actors[kind || 'hostile']; return a && a.head ? a.head.c.slice() : null; };
T.bodyPoint = function(kind){ const a = e31.actors[kind || 'hostile']; if (!a || !a.body) return null; return [a.body.a[0], (a.body.a[1] + a.body.b[1]) * 0.5, a.body.a[2]]; };
T.resetEnemies = function(){ for (const h of [hostile, patrolHostile]) { h.alive = true; h.dying = 0; h.hp = 5; h.deathBoomPending = false; h.hitFlash = 0; } for (const k in e31.actors) if (e31.actors[k]) { e31.actors[k].deathT = -1; e31.actors[k].role = null; } };
}
// ===================== [e31 coach] end of Phase 31 block =====================
// ===================== [e32 coach] Phase 32: Engine 32 RC (model check, root motion toggle, dogs use the character, perf) =====================
// Muse-authored helpers (reviewed + fixed by the coach, see game/muse-authored/phase32/FIXES-P32.md):
// MuseModelCheck (engine/check/model-check.js): warnings for the Model check panel; MuseRootMotion (engine/anim/root-motion.js): the
// importer measures root motion and builds in-place clips; MuseSetup (engine/io/setup-schema.js): setup JSON + drop planner (used by engine/ui/e32-ui.js).
// This block is coach plumbing: live clip-set switch, dog actors driven by the loaded rig, frustum culling of batched scene parts,
// the modelCheck() API and test hooks.
const E32_VERSION = 'e32-rc-1';
const E32_DOG_SCALE = 0.5; // the loaded character drawn at half size as the dog
let _e32Dog = null; // set by the dog draw loops just before drawCharacter('dog', ...)
const e32 = { dogActors: new Map(), frame: 0, planes: null, drawn: 0, culled: 0, lastDrawn: 0, lastCulled: 0 };
function e32ApplyClips(){ const r = e31.rig; if (r && r.clipsRaw && r.clipsStripped) r.clips = cfg.stripRootMotion ? r.clipsStripped : r.clipsRaw; }
function e32DogOn(){ return e31On() && !!cfg.importDog; }
function e32DogFeet(d){ return d.pos[1] - (d._halfY != null ? d._halfY : 0.25); }
function e32DogActor(d){
let a = e32.dogActors.get(d);
if (!a || a.rig !== e31.rig) { a = e31MakeActor(d); a.rig = e31.rig; e32.dogActors.set(d, a); }
return a;
}
function e32Tick(dt){
e32ApplyClips();
if (!e32DogOn()) { if (e32.dogActors.size) e32.dogActors.clear(); return; }
const SP = window.MuseSkeletonPose, rig = e31.rig, cap = rig.capsule, s = E32_DOG_SCALE;
for (const d of dogs) {
if (!d.alive || !cfg.dogs) continue;
const a = e32DogActor(d);
const dx = d.pos[0] - a.last[0], dz = d.pos[2] - a.last[1];
a.last[0] = d.pos[0]; a.last[1] = d.pos[2];
let inst = dt > 0 ? Math.hypot(dx, dz) / dt : a.speed;
if (inst > 15) inst = 0;
if (dt > 0) a.speed += (inst - a.speed) * Math.min(1, dt * 8);
if (dt > 0 && Math.hypot(dx, dz) > 1e-4 && inst <= 15) a.yaw = _angLerp(a.yaw, Math.atan2(dx, dz), Math.min(1, dt * 10));
const run = a.role === 'run' ? a.speed > 1.4 : a.speed > 1.6;
const move = (a.role === 'walk' || a.role === 'run') ? a.speed > e31.idleSpeed * 0.6 : a.speed > e31.idleSpeed;
const role = run ? 'run' : move ? 'walk' : 'idle';
const ci = e31Clip(role);
if (role !== a.role || ci !== a.clip) {
if (ci >= 0 && ci !== a.clip) { a.fader.play(ci, e31.fade, { loop: true, speed: 1 }); a.switches++; }
a.history.push({ role: role, clip: ci, t: +performance.now().toFixed(0) }); if (a.history.length > 24) a.history.shift();
a.role = role; a.clip = ci;
}
if (a.clip >= 0) a.fader.update(dt, rig.clips, a.pose); else SP.restPose(rig.skeleton, a.pose);
SP.worldMatrices(rig.skeleton, a.pose, IDENT, a.world);
SP.skinPalette(a.world, rig.palette.nodes, rig.palette.invBind, null, a.palette);
const feet = e32DogFeet(d);
a.model = _m4mul(_m4mul(_m4TRy(d.pos[0], feet, d.pos[2], a.yaw), _m4S(s, s, s)), rig.fitM);
a.body = { a: [d.pos[0], feet + cap.radius * s, d.pos[2]], b: [d.pos[0], feet + Math.max(cap.radius * s * 1.05, (cap.height - cap.radius) * s), d.pos[2]], r: cap.radius * s };
}
}
function e32DrawActor(a, flashCol, depth){
const parts = importSlots.character.parts;
const locI = depth ? d_aSkinIdx : aSkinIdx, locW = depth ? d_aSkinW : aSkinW;
gl.useProgram(depth ? skinDepthProgram : skinProgram);
gl.uniform4fv(depth ? d_uBones : uBones, a.palette);
for (const part of parts) {
if (!part.skinVbo) continue;
const M = part.A ? _m4mul(a.model, part.A) : a.model;
gl.bindBuffer(gl.ARRAY_BUFFER, part.skinVbo);
if (locI >= 0) { gl.enableVertexAttribArray(locI); gl.vertexAttribPointer(locI, 4, gl.FLOAT, false, 32, 0); }
if (locW >= 0) { gl.enableVertexAttribArray(locW); gl.vertexAttribPointer(locW, 4, gl.FLOAT, false, 32, 16); }
if (depth) drawMeshDepth(part.mesh, M);
else if (flashCol) drawTexturedPart({ mesh: part.mesh, color: flashCol, spec: FLASH_SPEC, shin: 40, useTex: false, local: null }, M);
else drawTexturedPart(part, M);
}
if (locI >= 0) gl.disableVertexAttribArray(locI);
if (locW >= 0) gl.disableVertexAttribArray(locW);
if (!depth) gl.uniform1f(uUseTex, 0.0);
gl.useProgram(depth ? depthProgram : program);
return true;
}
function e32DrawDog(flashCol, depth){
const d = _e32Dog; _e32Dog = null;
if (!d || !e32DogOn()) return false;
const a = e32.dogActors.get(d); if (!a || a.rig !== e31.rig || !a.model) return false;
return e32DrawActor(a, flashCol, depth);
}
function e32DogRay(d, eye, dir, min, max){
if (!e32DogOn()) return rayAABB(eye, dir, min, max);
const a = e32.dogActors.get(d), CF = window.MuseCapsuleFit;
if (!a || !a.body || !CF) return rayAABB(eye, dir, min, max);
const t = CF.rayCapsule(eye, dir, a.body.a, a.body.b, a.body.r);
return t >= 0 ? t : null;
}
// ---- frustum culling for batched scene parts (main pass only; the shadow pass still draws everything) ----
function e32Frustum(proj, view){
e32.lastDrawn = e32.drawn; e32.lastCulled = e32.culled; e32.drawn = 0; e32.culled = 0; e32.frame++;
if (!proj || !view) { e32.planes = null; return; }
const m = _m4mul(proj, view), P = [];
const row = (r) => [m[r], m[4 + r], m[8 + r], m[12 + r]];
const r0 = row(0), r1 = row(1), r2 = row(2), r3 = row(3);
for (const [a, sgn] of [[r0, 1], [r0, -1], [r1, 1], [r1, -1], [r2, 1], [r2, -1]]) {
const p = [r3[0] + sgn * a[0], r3[1] + sgn * a[1], r3[2] + sgn * a[2], r3[3] + sgn * a[3]];
const l = Math.hypot(p[0], p[1], p[2]) || 1; P.push([p[0] / l, p[1] / l, p[2] / l, p[3] / l]);
}
e32.planes = P;
}
function e32Visible(part){
const b = part.bs, P = e32.planes;
if (!b || !P) { e32.drawn++; return true; }
for (let i = 0; i < 6; i++) { const p = P[i]; if (p[0] * b[0] + p[1] * b[1] + p[2] * b[2] + p[3] < -b[3]) { e32.culled++; return false; } }
e32.drawn++; return true;
}
// ---- Model check: facts from the importer + live engine state -> MuseModelCheck.analyze ----
function e32ModelCheck(slot){
const s = importSlots[slot]; if (!s) return null;
const info = s.info || {};
const f = JSON.parse(JSON.stringify(info.check || { kind: slot, name: info.name }));
if (slot === 'scene' && info.mode === 'level') f.scene = { mode: 'level', colliderTris: (info.collider || {}).tris || 0, walkableTris: (info.collider || {}).walkable || 0,
spawn: info.spawnSource || (info.spawnNode ? 'node' : 'search') };
const rigOK = !!(s.rig && s.rig.clipsStripped && s.rig.clipsStripped !== s.rig.clipsRaw);
if (f.rig && f.rig.clips) {
const R = (e31.roles && e31.roles.roles) || info.roles || {};
f.rig.roles = Object.assign({}, R);
f.rig.clips.forEach(function(c){ c.stripped = !!cfg.stripRootMotion && rigOK; });
}
const MC = window.MuseModelCheck;
let res;
try { res = MC ? MC.analyze(f) : null; } catch (err) { console.warn('[e32] model check', err); res = null; }
if (!res) res = { level: 'ok', warnings: [], summary: { errors: 0, warns: 0, infos: 0, codes: [] }, unavailable: true };
// [e32 scope change] importer notes (extraChecks from extra readers) + MuseTextureBudget (LARGE_TEXTURES / TEXTURE_MEMORY / NPOT_TEXTURES)
let budget = null; const extra = (f.extraChecks || []).slice();
const TB = window.MuseTextureBudget;
if (TB && f.textures && f.textures.sizes) { try { budget = TB.analyze(f.textures.sizes); extra.push.apply(extra, budget.warnings); } catch (err) { console.warn('[e32] texture budget', err); } }
if (extra.length) {
const ord = { error: 0, warn: 1, info: 2 }, all = res.warnings.concat(extra.filter(function(w){ return w && ord[w.level] != null; }));
all.forEach(function(w, i){ w._i = i; }); all.sort(function(a, b){ return (ord[a.level] - ord[b.level]) || (a._i - b._i); }); all.forEach(function(w){ delete w._i; });
const sm = { errors: 0, warns: 0, infos: 0, codes: all.map(function(w){ return w.code; }) };
all.forEach(function(w){ if (w.level === 'error') sm.errors++; else if (w.level === 'warn') sm.warns++; else sm.infos++; });
res = Object.assign({}, res, { warnings: all, summary: sm, level: sm.errors ? 'error' : sm.warns ? 'warn' : 'ok' });
}
const takes = ((f.rig && f.rig.clips) || []).map(function(c){
const e = MC ? MC.estimateFps(c.times || []) : { fps: 0, frames: (c.times || []).length, standard: false };
return { name: c.name, duration: c.duration, fps: e.fps, frames: e.frames, standard: e.standard, keys: (c.times || []).length, rootMotionM: c.rootMotionM || 0, stripped: !!c.stripped };
});
if (f.rig && f.rig.clips) f.rig.clips.forEach(function(c){ delete c.times; });
return { slot: slot, name: info.name, mode: info.mode, facts: f, level: res.level, warnings: res.warnings, summary: res.summary, takes: takes, textureBudget: budget ? { count: budget.count, decodedMB: budget.totalDecodedMB, uploadMB: budget.totalUploadMB, largest: budget.largest } : null,
drawParts: info.drawParts || (s.parts ? s.parts.length : 0), srcParts: info.srcParts || (s.parts ? s.parts.length : 0), rootNode: info.rootMotion ? info.rootMotion.node : null };
}
{ // setImportedModel: apply the clip set for the current toggle and drop old dog actors
const _set31 = window.MuseEngine29.setImportedModel;
window.MuseEngine29.setImportedModel = function(slot, meshes, info, extra){ const r = _set31(slot, meshes, info, extra); if (slot === 'character') { e32.dogActors.clear(); e32ApplyClips(); } return r; };
const _clr31 = window.MuseEngine29.clearImportedModel;
window.MuseEngine29.clearImportedModel = function(slot){ if (slot === 'character') e32.dogActors.clear(); return _clr31(slot); };
}
window.MuseEngine29.version = E32_VERSION;
window.MuseEngine29.releaseLabel = 'Engine 32 RC';
window.MuseEngine29.modelCheck = e32ModelCheck;
window.MuseEngine29.perf = function(){ const s = importSlots.scene; return { sceneDrawParts: s ? s.parts.length : 0, sceneSrcParts: s && s.info ? (s.info.srcParts || s.parts.length) : 0,
drawnLastFrame: e32.lastDrawn, culledLastFrame: e32.lastCulled, sharedTextures: s ? s.parts.filter(function(p){ return p.sharedTex; }).length : 0,
textures: s ? new Set(s.parts.filter(function(p){ return p.tex; }).map(function(p){ return p.tex; })).size : 0 }; };
{ const _st31 = window.MuseEngine29.status; window.MuseEngine29.status = function(){ const s = _st31();
s.e32 = { version: E32_VERSION, stripRootMotion: !!cfg.stripRootMotion, dogsUseCharacter: e32DogOn(), dogActors: e32.dogActors.size }; return s; }; }
if (window.MuseEngine29.test) {
const T = window.MuseEngine29.test;
T.rootPos = function(kind){ // engine-space position of the rig's root-motion node for an actor ('hostile' | 'patrol' | 'dog')
const rig = e31.rig; if (!rig || !rig.rootMotion || rig.rootMotion.node < 0) return null;
const a = kind === 'dog' ? e32.dogActors.get(dogs[0]) : e31.actors[kind || 'hostile']; if (!a || !a.model) return null;
const w = a.world, n = rig.rootMotion.node;
return _m4pt(a.model, _m4pt(rig.a0M, [w[16 * n + 12], w[16 * n + 13], w[16 * n + 14]]));
};
T.dogActor = function(){ const d = dogs[0], a = e32.dogActors.get(d); if (!a) return null;
return { role: a.role, clip: a.clip, clipName: a.clip >= 0 ? e31.rig.clips[a.clip].name : null, speed: +a.speed.toFixed(3), switches: a.switches, pos: d.pos.slice(), feet: +e32DogFeet(d).toFixed(3),
body: a.body ? { a: a.body.a.map(function(v){ return +v.toFixed(3); }), b: a.body.b.map(function(v){ return +v.toFixed(3); }), r: +a.body.r.toFixed(3) } : null }; };
T.dogPoint = function(){ const a = e32.dogActors.get(dogs[0]); if (!a || !a.body) { const d = dogs[0]; return d.pos.slice(); } return [a.body.a[0], (a.body.a[1] + a.body.b[1]) * 0.5, a.body.a[2]]; };
T.dogs = function(){ return dogs.map(function(d){ return { pos: d.pos.slice(), alive: d.alive, hp: d.hp }; }); };
T.moveDog = function(x, z){ const d = dogs[0]; d.pos[0] = x; d.pos[2] = z; d.target = [x, 0, z]; const a = e32.dogActors.get(d); if (a) { a.last[0] = x; a.last[1] = z; } return d.pos.slice(); };
}
// ===================== [e32 coach] end of Phase 32 block =====================
let _charShapeInit = false;
function render(now){
if (!_charShapeInit) { _charShapeInit = true; applyCharShapePack(); }
resize();
e30Frame(); // [e30]
const dt = Math.min(0.05, (now - last)/1000);
last = now;
if (shootCooldown > 0) shootCooldown -= dt;
if (hitFlashTimer > 0) hitFlashTimer -= dt;
if (hurtFlash > 0) hurtFlash -= dt;
if (muzzleFlash > 0) muzzleFlash -= dt;
if (reloading) {
reloadTimer -= dt;
if (reloadTimer <= 0) {
reloading = false;
const take = shareAmmoIntoMag();
flashHint(take > 0 ? ('RELOADED +' + take) : 'RELOADED');
sfxReloadEnd();
}
}
if (!uiBlocked) updateCamera(dt); // [e29] paused while an overlay is open
if (!orbit.enabled && !uiBlocked) {
resolveCollision();
checkAmmoPickups();
if (cfg.enemies) { // [e29] gameplay toggle + engine part (AI update)
if (cfg.enemyAI) { updateHostile(dt); updatePatrolHostile(dt); }
else { tickHostileDeath(hostile, dt); tickHostileDeath(patrolHostile, dt); }
}
if (cfg.dogs && cfg.enemyAI) updateDogs(dt); // [e29]
for (const n of sceneNodes) {
if (n.dying > 0) {
n.dying -= dt;
if (n.dying <= 0) { n.dying = 0; n.hp = 0; }
}
}
const allCratesDown = targets.filter(t => t.name && /^(crate\d|obj)/.test(t.name)).every(t => t.hp <= 0);
if (hostile.alive === false && patrolHostile.alive === false && allCratesDown && !wonOnce){
wonOnce = true;
flashHint('WIN');
}
}
e31Tick(uiBlocked ? 0 : dt); // [e31] poses + palettes + hitboxes
e32Tick(uiBlocked ? 0 : dt); // [e32] clip set + dog actors
frames++; fpsTime += dt;
if (fpsTime >= 0.5){ fps = Math.round(frames / fpsTime); frames=0; fpsTime=0; }
const litCount = lamps.filter(lampLit).length;
const modeStr = nightMode ? ('NIGHT L' + litCount + '/' + lamps.length + (litCount===0?' MOON':'')) : 'DAY';
const reloadStr = reloading ? ' RELOAD' : '';
const crouchStr = crouching ? ' CROUCH' : '';
const dogsAlive = dogs.filter(d=>d.alive).length;
fpsEl.textContent = fps + ' FPS · ' + modeStr + ' · HP ' + playerHP + ' · AMMO ' + ammoMag + '/' + ammoReserve + reloadStr + crouchStr + ' · DOGS ' + dogsAlive + ' · Score ' + score;
const aspect = canvas.width / canvas.height;
const proj = perspective(Math.PI/4, aspect, 0.1, 100);
let view;
if (orbit.enabled) {
view = lookAt(cam.pos, orbit.target, [0,1,0]);
} else {
const cp = Math.cos(cam.pitch), sp = Math.sin(cam.pitch);
const target = [
cam.pos[0] + Math.sin(cam.yaw) * cp,
cam.pos[1] + sp,
cam.pos[2] + (-Math.cos(cam.yaw) * cp)
];
view = lookAt(cam.pos, target, [0,1,0]);
}
e30Matrices(proj, view); // [e30]
const LE = curLook.env; // [e29] look env
const lightDirDay = LE.sunDirDay;
const lightDirNight = LE.sunDirNight;
const lightDir = nightMode ? lightDirNight : lightDirDay;
const lightPos = [0,0,0];
const shadowC = levelOn() ? [cam.pos[0], cam.pos[1] - standEye, cam.pos[2]] : orbit.target; // [e30] shadows follow the player in a level
for (let i=0;i<3;i++) lightPos[i] = shadowC[i] - lightDir[i]*12;
const lightView = lookAt(lightPos, shadowC, [0,1,0]);
const lightProj = ortho(-10,10,-10,10,1,35);
const lightVP = multiply(lightProj, lightView);
const lightMVP = lightVP;
const dayClear = LE.dayClear;
const litForSky = nightMode ? lamps.filter(lampLit).length : 4;
const nightClear = [
LE.nightClearBase[0] + litForSky * LE.nightClearPerLamp[0],
LE.nightClearBase[1] + litForSky * LE.nightClearPerLamp[1],
LE.nightClearBase[2] + litForSky * LE.nightClearPerLamp[2]
];
const clearCol = nightMode ? nightClear : dayClear;
gl.clearColor(clearCol[0], clearCol[1], clearCol[2], 1.0);
if (useShadowMap) {
gl.bindFramebuffer(gl.FRAMEBUFFER, shadowFBO);
gl.viewport(0,0,SHADOW_SIZE,SHADOW_SIZE);
gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);
gl.useProgram(depthProgram);
gl.colorMask(false, false, false, false);
gl.uniformMatrix4fv(d_uLightVP, false, lightVP);
const casterModels = {};
for (const node of sceneNodes) {
if (node.name === 'ground') continue;
if (node.hp !== undefined && node.hp <= 0 && !(node.dying > 0)) continue;
let model = identity();
if (node.name === 'marker' && !node.pos) {
model = rotateY(identity(), now*0.001*1.2);
} else if (node.pos) {
let s = node.scale;
if (!Array.isArray(s)) s = [s,s,s];
let m = identity();
m[0]=s[0]; m[5]=s[1]; m[10]=s[2];
m[12] = node.pos[0]; m[13] = node.pos[1]; m[14] = node.pos[2];
model = m;
}
casterModels[node.name] = model;
if (hideBuiltinProp(node)) continue; // [e29]
drawMeshDepth(node.mesh, model);
drawNodeTrims(node, model, null, true); // [e29]
}
for (const p of ammoPickups){
if (!p.alive) continue;
let m = identity();
m[0]=p.scale; m[5]=p.scale; m[10]=p.scale;
m[12]=p.pos[0]; m[13]=p.pos[1]; m[14]=p.pos[2];
drawMeshDepth(p.mesh, m);
}
for (const d of dogs){
if (!d.alive || !cfg.dogs) continue;
let m = identity();
m[0]=d.scale; m[5]=d.scale*0.6; m[10]=d.scale*1.2;
m[12]=d.pos[0]; m[13]=d.pos[1]; m[14]=d.pos[2];
_e32Dog = d; drawCharacter('dog', m, d.mesh, null, null, 0, false, true); // [e29]; [e32] which dog
}
if (casterModels['crate0']) {
let parentM = casterModels['crate0'];
let childM = translate(identity(), childMarker.local[0], childMarker.local[1], childMarker.local[2]);
childM = multiply(parentM, childM);
drawMeshDepth(childMarker.mesh, childM);
}
if (lookProp.visible) {
const root = lookPropRootModel();
const auth = lookProp.authoredParts || [];
for (let ai = 0; ai < auth.length; ai++) {
const part = auth[ai];
const model = multiply(root, part.local || identity());
drawMeshDepth(part.mesh, model);
}
if (lookProp.parts && lookProp.parts.length) {
for (let li = 0; li < lookProp.parts.length; li++) {
const part = lookProp.parts[li];
const model = multiply(root, part.local || identity());
drawMeshDepth(part.mesh, model);
}
}
}
if (cfg.enemies && hostile.alive) {
drawCharacter('hostile', hostileModel(hostile).m, hostile.mesh, null, null, 0, false, true); // [e29]
}
if (cfg.enemies && patrolHostile.alive) {
drawCharacter('patrol', hostileModel(patrolHostile).m, patrolHostile.mesh, null, null, 0, false, true); // [e29]
}
let doorM = identity();
let ds = door.scale;
doorM[0]=ds[0]; doorM[5]=ds[1]; doorM[10]=ds[2];
doorM[12]=door.pos[0]; doorM[13]=door.pos[1]; doorM[14]=door.pos[2];
if (door.open) doorM = rotateY(doorM, Math.PI/2);
drawMeshDepth(door.mesh, doorM);
for (const l of lamps){
let m = identity();
m[0]=l.postScale[0]; m[5]=l.postScale[1]; m[10]=l.postScale[2];
m[12]=l.pos[0]; m[13]=l.pos[1]; m[14]=l.pos[2];
drawMeshDepth(crateMesh, m);
let bm = identity();
bm[0]=l.bulbScale[0]; bm[5]=l.bulbScale[1]; bm[10]=l.bulbScale[2];
bm[12]=l.pos[0]; bm[13]=l.pos[1]+l.postScale[1]*0.5+0.1; bm[14]=l.pos[2];
drawMeshDepth(crateMesh, bm);
}
drawLookWorldExtras(true); // [e29] backdrop + imported scene
gl.colorMask(true, true, true, true);
gl.bindFramebuffer(gl.FRAMEBUFFER, null);
}
gl.viewport(0,0,canvas.width,canvas.height);
gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);
gl.useProgram(program);
gl.uniformMatrix4fv(uProj, false, proj);
gl.uniformMatrix4fv(uView, false, view);
gl.uniform3fv(uLightDir, lightDir);
let sceneAmbient = LE.dayAmbient;
if (nightMode) {
const litN = lamps.filter(lampLit).length;
sceneAmbient = LE.nightAmbientBase + litN * LE.nightAmbientPerLamp;
gl.uniform1f(uAmbientAmt, sceneAmbient);
gl.uniform1f(uDirAmt, LE.nightDiffuseBase + litN * LE.nightDiffusePerLamp);
} else {
gl.uniform1f(uAmbientAmt, sceneAmbient);
gl.uniform1f(uDirAmt, LE.dayDiffuse);
}
const activeLamps = (nightMode && cfg.lightExtras) ? nearestLitLamps(2) : []; // [e29]
const pointBoost = LE.lampBoost;
if (activeLamps[0]) {
gl.uniform3fv(uPointPos, lampBulbTip(activeLamps[0]));
gl.uniform3fv(uPointColor, [LE.lampColor1[0]*pointBoost, LE.lampColor1[1]*pointBoost, LE.lampColor1[2]*pointBoost]);
gl.uniform1f(uPointRadius, 18.0);
} else {
gl.uniform3fv(uPointPos, [0,0,0]);
gl.uniform3fv(uPointColor, [0,0,0]);
gl.uniform1f(uPointRadius, 0.0);
}
if (activeLamps[1]) {
gl.uniform3fv(uPointPos2, lampBulbTip(activeLamps[1]));
gl.uniform3fv(uPointColor2, [LE.lampColor2[0]*pointBoost, LE.lampColor2[1]*pointBoost, LE.lampColor2[2]*pointBoost]);
gl.uniform1f(uPointRadius2, 17.0);
} else {
gl.uniform3fv(uPointPos2, [0,0,0]);
gl.uniform3fv(uPointColor2, [0,0,0]);
gl.uniform1f(uPointRadius2, 0.0);
}
gl.uniform1f(uAlpha, 1.0);
gl.uniform3fv(uCamPos, cam.pos);
const fogCol = nightMode
? [LE.nightFogBase[0] + litForSky*LE.nightFogPerLamp[0], LE.nightFogBase[1] + litForSky*LE.nightFogPerLamp[1], LE.nightFogBase[2] + litForSky*LE.nightFogPerLamp[2]]
: LE.dayFog;
gl.uniform3fv(uFogColor, fogCol);
gl.uniform1f(uFogNear, cfg.fog ? LE.fogNear : 900.0); // [e29] fog toggle
gl.uniform1f(uFogFar, cfg.fog ? LE.fogFar : 1000.0);
gl.activeTexture(gl.TEXTURE1);
gl.bindTexture(gl.TEXTURE_2D, albedoTex);
gl.uniform1i(uAlbedo, 1);
if (useShadowMap) {
gl.activeTexture(gl.TEXTURE0);
gl.bindTexture(gl.TEXTURE_2D, shadowTex);
gl.uniform1i(uShadowMap, 0);
gl.uniformMatrix4fv(uLightMVP, false, lightMVP);
gl.uniform1f(uShadowBias, 0.004);
gl.uniform1f(uUseShadow, 1.0);
} else {
gl.uniformMatrix4fv(uLightMVP, false, identity());
gl.uniform1f(uShadowBias, 0.0);
gl.uniform1f(uUseShadow, 0.0);
}
if (LE.gridColor && cfg.grid && !levelOn()) { // [e29] grid colour from look / toggle; [e30] hidden in a loaded level
gl.bindBuffer(gl.ARRAY_BUFFER, gridVBO);
gl.enableVertexAttribArray(aPos);
gl.vertexAttribPointer(aPos, 3, gl.FLOAT, false, 12, 0);
gl.disableVertexAttribArray(aNormal);
if (aUV >= 0) gl.disableVertexAttribArray(aUV);
gl.uniformMatrix4fv(uModel, false, identity());
gl.uniform3fv(uBaseColor, LE.gridColor);
gl.uniform3fv(uSpecColor, [0.0,0.0,0.0]);
gl.uniform1f(uShininess, 1.0);
gl.uniform1f(uUseTex, 0.0);
gl.drawArrays(gl.LINES, 0, gridLines.length/3);
}
if (!useShadowMap) {
gl.uniform1f(uPointRadius, 0.0);
gl.uniform1f(uPointRadius2, 0.0);
gl.uniform3fv(uLightDir, [0.0, 1.0, 0.0]);
gl.uniform1f(uAlpha, 0.38);
gl.enable(gl.BLEND);
gl.blendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA);
gl.depthMask(false);
for (const node of sceneNodes) {
if (!frustumCull(node) || !node.pos) continue;
if (node.hp !== undefined && node.hp <= 0 && !(node.dying > 0)) continue;
const s = node.scale;
const sx = (Array.isArray(s) ? s[0] : s) * 1.15;
const sz = (Array.isArray(s) ? s[2] : s) * 1.15;
let m = identity();
m[0]=sx; m[5]=1.0; m[10]=sz;
m[12] = node.pos[0]; m[13] = 0.02; m[14] = node.pos[2];
gl.uniformMatrix4fv(uModel, false, m);
gl.uniform3fv(uBaseColor, [0.02,0.02,0.04]);
gl.uniform3fv(uSpecColor, [0,0,0]);
gl.uniform1f(uShininess, 1.0);
gl.uniform1f(uUseTex, 0.0);
gl.bindBuffer(gl.ARRAY_BUFFER, shadowQuad.vbo);
gl.enableVertexAttribArray(aPos);
gl.enableVertexAttribArray(aNormal);
gl.vertexAttribPointer(aPos, 3, gl.FLOAT, false, 32, 0);
gl.vertexAttribPointer(aNormal, 3, gl.FLOAT, false, 32, 12);
if (aUV >= 0) {
gl.enableVertexAttribArray(aUV);
gl.vertexAttribPointer(aUV, 2, gl.FLOAT, false, 32, 24);
}
gl.drawArrays(gl.TRIANGLES, 0, shadowQuad.count);
}
gl.depthMask(true);
gl.disable(gl.BLEND);
gl.uniform1f(uAlpha, 1.0);
gl.uniform3fv(uLightDir, lightDir);
{
const al = (nightMode && cfg.lightExtras) ? nearestLitLamps(2) : []; // [e29]
gl.uniform1f(uPointRadius, al[0] ? 16.0 : 0.0);
gl.uniform1f(uPointRadius2, al[1] ? 15.0 : 0.0);
}
}
const nodeModels = {};
for (const node of sceneNodes) {
if (!frustumCull(node)) continue;
if (node.hp !== undefined && node.hp <= 0 && !(node.dying > 0)) continue;
if (hideBuiltinProp(node)) continue; // [e29]
let model = identity();
if (node.name === 'marker' && !node.pos) {
model = rotateY(identity(), now*0.001*1.2);
} else if (node.pos) {
const s = node.scale;
const sx = Array.isArray(s) ? s[0] : s;
const sy = Array.isArray(s) ? s[1] : s;
const sz = Array.isArray(s) ? s[2] : s;
let m = identity();
m[0]=sx; m[5]=sy; m[10]=sz;
m[12] = node.pos[0]; m[13] = node.pos[1]; m[14] = node.pos[2];
model = m;
}
nodeModels[node.name] = model;
gl.enableVertexAttribArray(aNormal);
gl.uniform1f(uUseTex, (node.useTex && cfg.textures) ? 1.0 : 0.0); // [e29]
let baseColor = node.color.slice();
const _lookFlash = !!(node.hitFlash && node.hitFlash > 0); // [e29]
if (node.hitFlash && node.hitFlash > 0){
baseColor = (node.hitFlashColor && node.hitFlashColor.length === 3)
? node.hitFlashColor.slice()
: [1.0, 0.6, 0.6];
node.hitFlash -= dt;
}
if (node.hp !== undefined && node.pos && (node.hp > 0 || node.dying > 0)){
const s = node.scale;
const sx0 = Array.isArray(s) ? s[0] : s;
const sy0 = Array.isArray(s) ? s[1] : s;
const sz0 = Array.isArray(s) ? s[2] : s;
const maxHp = node.maxHp || 3;
const hpShow = Math.max(node.hp, 0);
let dmg = 1.0 - (maxHp - hpShow) * 0.08;
if (dmg < 0.7) dmg = 0.7;
let fall = 1.0;
if (node.dying > 0) {
fall = Math.max(0, Math.min(1, node.dying / 0.55));
dmg = 0.7;
}
const sx = sx0 * dmg * (0.55 + 0.45 * fall);
const sy = sy0 * dmg * fall;
const sz = sz0 * dmg * (0.55 + 0.45 * fall);
model[0]=Math.max(0.02,sx); model[5]=Math.max(0.02,sy); model[10]=Math.max(0.02,sz);
model[12]=node.pos[0]; model[14]=node.pos[2];
if (node.pivot === 'base') {
model[13]=node.pos[1];
} else {
model[13]= model[5] * 0.5;
}
}
gl.uniformMatrix4fv(uModel, false, model);
drawMesh(node.mesh, model, baseColor, node.spec || [0.2,0.2,0.2], node.shin || 32);
if (node.pos) drawNodeTrims(node, model, _lookFlash ? baseColor : null, false); // [e29]
}
for (const p of ammoPickups){
if (!p.alive) continue;
drawAmmoBox(p);
}
for (const d of dogs){
if (!d.alive || !cfg.dogs) continue;
let m = identity();
m[0]=d.scale; m[5]=d.scale*0.6; m[10]=d.scale*1.2;
m[12]=d.pos[0]; m[13]=d.pos[1]; m[14]=d.pos[2];
gl.uniform1f(uUseTex, 0.0);
let col = d.color.slice();
const _dogFlash = d.hitFlash > 0; // [e29]
if (d.hitFlash > 0) {
col = (d.hitFlashColor && d.hitFlashColor.length === 3) ? d.hitFlashColor.slice() : [1.0, 0.9, 0.7];
d.hitFlash -= dt;
}
_e32Dog = d; drawCharacter('dog', m, d.mesh, col, d.spec, d.shin, _dogFlash, false); // [e29]; [e32] which dog
}
if (nodeModels['crate0']) {
let parentM = nodeModels['crate0'];
let childM = translate(identity(), childMarker.local[0], childMarker.local[1], childMarker.local[2]);
childM = multiply(parentM, childM);
gl.uniform1f(uUseTex, 0.0);
drawMesh(childMarker.mesh, childM, childMarker.color, childMarker.spec, childMarker.shin);
}
let doorM = identity();
let ds = door.scale;
doorM[0]=ds[0]; doorM[5]=ds[1]; doorM[10]=ds[2];
doorM[12]=door.pos[0]; doorM[13]=door.pos[1]; doorM[14]=door.pos[2];
if (door.open) doorM = rotateY(doorM, Math.PI/2);
gl.uniform1f(uUseTex, 0.0);
let doorCol = door.color;
if (door.hitFlash && door.hitFlash > 0) {
doorCol = (door.hitFlashColor && door.hitFlashColor.length === 3)
? door.hitFlashColor.slice()
: [0.85, 0.95, 1.0];
door.hitFlash -= dt;
}
gl.uniformMatrix4fv(uModel, false, doorM);
drawMesh(door.mesh, doorM, doorCol, door.spec, door.shin);
for (const l of lamps){
const postH = l.postScale[1];
let m = identity();
m[0]=l.postScale[0]; m[5]=postH; m[10]=l.postScale[2];
m[12]=l.pos[0]; m[13]=l.pos[1] + postH * 0.5; m[14]=l.pos[2];
gl.uniform1f(uUseTex, 0.0);
gl.uniformMatrix4fv(uModel, false, m);
let postCol = curLook.lamps.post.slice(); // [e29]
if (l.hitFlash && l.hitFlash > 0) {
postCol = (l.hitFlashColor && l.hitFlashColor.length === 3) ? l.hitFlashColor.slice() : [1.0,0.95,0.7];
l.hitFlash -= dt;
}
drawMesh(crateMesh, m, postCol, [0.15,0.15,0.18], 18);
let bm = identity();
const lit = lampLit(l);
const bs = lit
? [l.bulbScale[0]*1.15, l.bulbScale[1]*1.15, l.bulbScale[2]*1.15]
: [l.bulbScale[0]*0.95, l.bulbScale[1]*0.95, l.bulbScale[2]*0.95];
bm[0]=bs[0]; bm[5]=bs[1]; bm[10]=bs[2];
bm[12]=l.pos[0]; bm[13]=l.pos[1] + postH + l.bulbScale[1]*0.5; bm[14]=l.pos[2];
let bulbCol = lit ? curLook.lamps.bulbOn : (l.broken ? curLook.lamps.bulbBroken : curLook.lamps.bulbOff); // [e29]
if (l.hitFlash && l.hitFlash > 0) bulbCol = [1.0, 1.0, 0.75];
const bulbSpec = lit ? [1.0,0.98,0.75] : [0.08,0.08,0.1];
const bulbShin = lit ? 120 : 12;
if (lit && cfg.lightExtras) gl.uniform1f(uAmbientAmt, 1.35); // [e29]
gl.uniformMatrix4fv(uModel, false, bm);
drawMesh(crateMesh, bm, bulbCol, bulbSpec, bulbShin);
if (lit) gl.uniform1f(uAmbientAmt, sceneAmbient);
}
drawLookWorldExtras(false); // [e29] backdrop + imported scene
gl.uniform1f(uUseTex, 0.0);
// Phase 26 look prop (textured + normal-mapped multi-mesh GLB)
if (lookProp.visible) {
const root = lookPropRootModel();
const auth = lookProp.authoredParts || [];
for (let ai = 0; ai < auth.length; ai++) {
drawTexturedPart(auth[ai], root);
}
if (lookProp.parts && lookProp.parts.length) {
for (let li = 0; li < lookProp.parts.length; li++) {
drawTexturedPart(lookProp.parts[li], root);
}
}
gl.uniform1f(uUseTex, 0.0);
}
if (cfg.enemies && hostile.alive) {
const hm = hostileModel(hostile);
let m = hm.m;
gl.uniform1f(uUseTex, 0.0);
const hb = curLook.charBox.hostile; // [e29]
let baseColor = hb.color.slice();
const _hFlash = !!(hm.hs.flash || hostile.hitFlash > 0); // [e29]
if (hm.hs.flash) baseColor = [1.0, 0.85, 0.25];
if (hostile.hitFlash > 0) {
baseColor = (hostile.hitFlashColor && hostile.hitFlashColor.length === 3)
? hostile.hitFlashColor.slice() : [1.0, 0.45, 0.4];
hostile.hitFlash -= dt;
}
drawCharacter('hostile', m, hostile.mesh, baseColor, hb.spec, hb.shin, _hFlash, false); // [e29]
}
if (cfg.enemies && patrolHostile.alive) {
const hm = hostileModel(patrolHostile);
let m = hm.m;
gl.uniform1f(uUseTex, 0.0);
const pb = curLook.charBox.patrol; // [e29]
let baseColor = pb.color.slice();
const _pFlash = !!(hm.hs.flash || patrolHostile.hitFlash > 0); // [e29]
if (hm.hs.flash) baseColor = [1.0, 0.9, 0.35];
if (patrolHostile.hitFlash > 0) {
baseColor = (patrolHostile.hitFlashColor && patrolHostile.hitFlashColor.length === 3)
? patrolHostile.hitFlashColor.slice() : [1.0, 0.75, 0.35];
patrolHostile.hitFlash -= dt;
}
drawCharacter('patrol', m, patrolHostile.mesh, baseColor, pb.spec, pb.shin, _pFlash, false); // [e29]
}
if (cfg.fx && hitFlashTimer > 0) { // [e29] engine part: FX
gl.enable(gl.BLEND);
gl.blendFunc(gl.SRC_ALPHA, gl.ONE);
gl.disable(gl.DEPTH_TEST);
const dur = hitStyleDur > 0.01 ? hitStyleDur : 0.28;
const a = Math.max(0, Math.min(1, hitFlashTimer / dur));
const s = 0.035 + 0.025 * (1.0 - a);
const q = new Float32Array([
-s, -s*0.12, s, -s*0.12, s, s*0.12, -s, -s*0.12, s, s*0.12, -s, s*0.12,
-s*0.12, -s, s*0.12, -s, s*0.12, s, -s*0.12, -s, s*0.12, s, -s*0.12, s
]);
const vboH = gl.createBuffer();
gl.bindBuffer(gl.ARRAY_BUFFER, vboH);
gl.bufferData(gl.ARRAY_BUFFER, q, gl.STATIC_DRAW);
gl.vertexAttribPointer(aPos, 2, gl.FLOAT, false, 0, 0);
gl.enableVertexAttribArray(aPos);
gl.disableVertexAttribArray(aNormal);
gl.uniformMatrix4fv(uModel, false, identity());
gl.uniformMatrix4fv(uView, false, identity());
gl.uniformMatrix4fv(uProj, false, identity());
gl.uniform3fv(uBaseColor, hitStyleGl);
gl.uniform1f(uAlpha, a * 0.95);
gl.drawArrays(gl.TRIANGLES, 0, 12);
gl.deleteBuffer(vboH);
gl.enable(gl.DEPTH_TEST);
gl.disable(gl.BLEND);
gl.uniform1f(uAlpha, 1.0);
}
if (cfg.fx && muzzleFlash > 0) { // [e29] engine part: FX
gl.enable(gl.BLEND);
gl.blendFunc(gl.SRC_ALPHA, gl.ONE);
gl.disable(gl.DEPTH_TEST);
const alpha = Math.max(0, muzzleFlash / 0.12);
const quad = new Float32Array([-0.08, -0.08, 0.08, -0.08, 0.08, 0.08, -0.08, -0.08, 0.08, 0.08, -0.08, 0.08]);
const vbo = gl.createBuffer();
gl.bindBuffer(gl.ARRAY_BUFFER, vbo);
gl.bufferData(gl.ARRAY_BUFFER, quad, gl.STATIC_DRAW);
gl.vertexAttribPointer(aPos, 2, gl.FLOAT, false, 0, 0);
gl.enableVertexAttribArray(aPos);
gl.disableVertexAttribArray(aNormal);
gl.uniformMatrix4fv(uModel, false, identity());
gl.uniformMatrix4fv(uView, false, identity());
gl.uniformMatrix4fv(uProj, false, identity());
gl.uniform3fv(uBaseColor, [1.0, 0.85, 0.4]);
gl.uniform1f(uAlpha, alpha * 0.9);
gl.drawArrays(gl.TRIANGLES, 0, 6);
gl.deleteBuffer(vbo);
gl.enable(gl.DEPTH_TEST);
gl.disable(gl.BLEND);
}
requestAnimationFrame(render);
}
showCredit(2500);
// ===== BEGIN GAME DATA: Breaker Bay demo/showcase camera scripts (MIT like the rest; still inline here until the engine/game split in PLAN.md moves it to game/) =====
if (/sell=p8/.test(location.search)) {
setTimeout(()=>{
nightMode = false;
cam.pos = [3.2, 1.55, 4.0];
cam.yaw = -0.85;
cam.pitch = -0.12;
cam.speed = 2.6;
orbit.target = [0.15, 1.0, -2.3];
orbit.radius = 7.2;
flashHint('FBO shadows');
const t0 = performance.now();
let orbitArmed = false;
demoDrive = setInterval(() => {
if (!demoDrive) return;
const t = (performance.now() - t0) / 1000;
nightMode = false;
keys['KeyW'] = (t >= 0.1 && t < 2.2);
keys['KeyA'] = (t >= 2.2 && t < 3.0);
keys['KeyD'] = false;
keys['KeyS'] = false;
if (!orbit.enabled) {
cam.yaw = -0.85 + Math.sin(t * 0.7) * 0.35;
cam.pitch = -0.12 + Math.sin(t * 0.9) * 0.06;
}
if (!orbitArmed && t >= 3.0) {
orbitArmed = true;
orbit.target = [0.15, 1.05, -2.3];
orbit.radius = 7.0;
orbit.yaw = -0.7;
orbit.pitch = 0.18;
enterOrbit();
}
if (orbit.enabled) {
orbit.yawTarget = -0.7 + (t - 3.0) * 0.55;
orbit.pitchTarget = 0.18 + Math.sin((t - 3.0) * 0.8) * 0.07;
orbit.radius = 7.0 + Math.sin((t - 3.0) * 0.4) * 0.8;
}
if (t >= 16.0) {
stopDemoDrive();
if (orbit.enabled) exitOrbit();
}
}, 33);
}, 900);
} else if (/sell=p9/.test(location.search)) {
setTimeout(()=>{
nightMode = false;
cam.pos = [4.0, 1.7, 11.0];
cam.yaw = -0.25;
cam.pitch = 0.08;
cam.speed = 2.6;
orbit.target = [-3.0, 2.2, -2.0];
orbit.radius = 13.5;
flashHint('sky / fog / pillars');
const t0 = performance.now();
let orbitArmed = false;
demoDrive = setInterval(() => {
if (!demoDrive) return;
const t = (performance.now() - t0) / 1000;
nightMode = false;
keys['KeyW'] = (t >= 0.1 && t < 2.5);
keys['KeyA'] = false;
keys['KeyD'] = (t >= 2.5 && t < 3.2);
keys['KeyS'] = false;
if (!orbit.enabled) {
cam.yaw = -0.25 + t * 0.18;
cam.pitch = 0.08 + Math.sin(t * 0.6) * 0.06;
}
if (!orbitArmed && t >= 3.2) {
orbitArmed = true;
orbit.target = [-2.5, 2.3, -1.5];
orbit.radius = 13.0;
orbit.yaw = 0.15;
orbit.pitch = 0.08;
enterOrbit();
}
if (orbit.enabled) {
orbit.yawTarget = 0.15 + (t - 3.2) * 0.52;
orbit.pitchTarget = 0.08 + Math.sin((t - 3.2) * 0.5) * 0.10;
orbit.radius = 13.0 + Math.sin((t - 3.2) * 0.3) * 1.5;
}
if (t >= 16.0) {
stopDemoDrive();
if (orbit.enabled) exitOrbit();
}
}, 33);
}, 900);
} else if (/demo=1/.test(location.search)) {
setTimeout(()=>{
cam.pos = [0.0, 1.6, 5.0];
cam.yaw = 0.0;
cam.pitch = -0.15;
cam.speed = 2.4;
orbit.target = [1.2, 0.8, -1.6];
const t0 = performance.now();
let orbitArmed = false;
let nightToggled = false;
demoDrive = setInterval(() => {
if (!demoDrive) return;
const t = (performance.now() - t0) / 1000;
keys['KeyW'] = (t >= 0.3 && t < 3.2);
keys['KeyS'] = (t >= 6.5 && t < 7.5);
keys['KeyA'] = (t >= 3.3 && t < 5.2);
keys['KeyD'] = (t >= 5.3 && t < 6.5);
if (!orbit.enabled && t < 12) {
cam.yaw = Math.sin(t * 0.4) * 0.55;
cam.pitch = -0.15 + Math.sin(t * 0.55) * 0.08;
}
if (!orbitArmed && t >= 7.8) {
orbitArmed = true;
enterOrbit();
setTimeout(()=>{ if (demoDrive) exitOrbit(); }, 2800);
}
if (orbit.enabled) {
orbit.yawTarget = 0.6 + (t - 7.8) * 0.55;
orbit.pitchTarget = 0.32;
}
if (!nightToggled && t >= 3.5) {
nightMode = true;
nightToggled = true;
flashHint('N day/night');
}
if (nightToggled && t >= 8.5 && nightMode) {
nightMode = false;
}
if (t > 4.2 && t < 4.5) tryShoot();
if (t > 5.8 && t < 6.1) tryShoot();
if (t >= 11.2) {
stopDemoDrive();
if (orbit.enabled) exitOrbit();
}
}, 40);
}, 2500);
}
// ===== END GAME DATA =====
requestAnimationFrame(render);
})();