(function () { 'use strict'; var FIXED_DT = 1 / 60; var MAX_CATCHUP = 5; var THREE = window.THREE; var gDiagnostics = []; /** A game-code bug: throw so it surfaces at the call site. */ function gFail(message) { throw new Error('[GAMIFY] ' + message); } /** * A host-driven problem worth reporting but not worth breaking the channel * over. Deduped and capped: the same bad param arriving on every slider drag * must not flood the report. */ function gNote(message) { if (gDiagnostics.indexOf(message) >= 0) return; if (gDiagnostics.length >= 25) return; gDiagnostics.push(message); if (window.__GAMIFY_SHOW_ERRORS__ && window.console) console.warn('[GAMIFY] ' + message); } function gDiagnosticsList() { return gDiagnostics.slice(); } function gList(values) { return values.length ? values.join(', ') : '(none)'; } /** * NaN is the worst silent failure available: it propagates through every later * calculation, the object drifts off-screen or vanishes, and nothing ever * throws. Catch it at the boundary where it enters. */ function gFinite(value, label, api) { if (typeof value !== 'number' || !isFinite(value)) { gFail( api + ': ' + label + ' must be a finite number, got ' + gDescribe(value) + '. A NaN here silently poisons every later calculation instead of failing.' ); } return value; } function gDescribe(value) { if (value === null) return 'null'; if (value === undefined) return 'undefined'; if (typeof value === 'number') return String(value); if (typeof value === 'string') return '"' + value + '"'; if (Array.isArray(value)) return 'an array of ' + value.length; return typeof value; } /** * Object pool. * * Lives here, shared, because it did NOT exist in the three runtime at all — * the capsule documented g.pool for every engine, so a 3D game following the * documented API got "g.pool is not a function". Two copies of an API is how * that happens; one copy is the fix. */ function makePool(factory, reset) { if (typeof factory !== 'function') { gFail('pool() needs a factory function, e.g. g.pool(function () { return { x: 0, y: 0 }; }).'); } if (reset !== undefined && typeof reset !== 'function') { gFail('pool(): the second argument must be a reset function, got ' + gDescribe(reset) + '.'); } var free = []; var live = []; return { live: live, spawn: function () { var item = free.length ? free.pop() : factory(); if (item === null || item === undefined) { gFail('pool.spawn(): the factory returned ' + gDescribe(item) + '. It must return an object.'); } live.push(item); return item; }, /** * Releasing something that is not live used to push it onto the free list * anyway. A double release therefore queued the same object twice, and the * next two spawns handed the SAME object to two callers — two entities * sharing one position, with no error to explain it. */ release: function (item) { var index = live.indexOf(item); if (index < 0) { gFail( 'pool.release(): that item is not live. It was either already released ' + '(which would hand the same object to two future spawns) or never came from this pool.' ); } live.splice(index, 1); if (reset) reset(item); free.push(item); }, releaseAll: function () { while (live.length) this.release(live[live.length - 1]); }, }; } var G_DEFINITION_KEYS = [ 'params', 'actions', 'setup', 'update', 'draw', 'render', 'state', 'inject', 'resize', 'multiplayer', ]; var G_HOOKS = ['setup', 'update', 'draw', 'render', 'state', 'inject', 'resize']; function gValidateDefinition(definition) { if (!definition || typeof definition !== 'object') { gFail( 'GAMIFY.game() needs a definition object, got ' + gDescribe(definition) + '. Expected GAMIFY.game({ setup, update, draw }).' ); } var unknown = Object.keys(definition).filter(function (key) { return G_DEFINITION_KEYS.indexOf(key) < 0; }); if (unknown.length) { gFail( 'GAMIFY.game() got unknown key(s): ' + gList(unknown) + '. Valid keys are: ' + gList(G_DEFINITION_KEYS) + '. A misspelled hook (setUp, drawFrame, updateGame) is silently never ' + 'called, so this is rejected rather than ignored.' ); } G_HOOKS.forEach(function (hook) { if (hook in definition && typeof definition[hook] !== 'function') { gFail('GAMIFY.game(): ' + hook + ' must be a function, got ' + gDescribe(definition[hook]) + '.'); } }); // A game with neither of these runs forever and does nothing, but "boots". if (typeof definition.update !== 'function' && typeof definition.draw !== 'function') { gFail( 'GAMIFY.game() needs at least update(g, dt) or draw(g). With neither, the ' + 'game loops forever doing nothing and still reports a clean boot.' ); } if (definition.actions !== undefined) { if (!definition.actions || typeof definition.actions !== 'object' || Array.isArray(definition.actions)) { gFail('GAMIFY.game(): actions must be an object mapping names to key arrays, e.g. { jump: ["Space"] }.'); } Object.keys(definition.actions).forEach(function (action) { var keys = definition.actions[action]; if (!Array.isArray(keys)) { gFail( 'GAMIFY.game(): actions.' + action + ' must be an ARRAY of keys, got ' + gDescribe(keys) + '. Write { ' + action + ': ["Space"] }, not { ' + action + ': "Space" }.' ); } keys.forEach(function (key) { if (typeof key !== 'string' || !key.length) { gFail('GAMIFY.game(): actions.' + action + ' contains ' + gDescribe(key) + '; keys must be non-empty strings.'); } gCheckKeyName(action, key); }); }); } if (definition.multiplayer !== undefined) { var mp = definition.multiplayer; if (!mp || typeof mp !== 'object' || Array.isArray(mp)) { gFail('GAMIFY.game(): multiplayer must be an object, e.g. { room: "url", tickRate: 20, self: (g) => ({ x: 0 }) }.'); } if (typeof mp.self !== 'function') { gFail( 'GAMIFY.game(): multiplayer.self must be a function returning this player\'s shared state, ' + 'e.g. self: (g) => ({ x: g.data.me.x, y: g.data.me.y }). Without it there is nothing to send.' ); } ['onJoin', 'onLeave', 'onEvent'].forEach(function (hook) { if (hook in mp && typeof mp[hook] !== 'function') { gFail('GAMIFY.game(): multiplayer.' + hook + ' must be a function, got ' + gDescribe(mp[hook]) + '.'); } }); var mpKeys = ['room', 'tickRate', 'self', 'onJoin', 'onLeave', 'onEvent']; var unknownMp = Object.keys(mp).filter(function (key) { return mpKeys.indexOf(key) < 0; }); if (unknownMp.length) { gFail( 'GAMIFY.game(): multiplayer got unknown key(s): ' + gList(unknownMp) + '. Valid keys are: ' + gList(mpKeys) + '.' ); } if (mp.tickRate !== undefined && (typeof mp.tickRate !== 'number' || !isFinite(mp.tickRate) || mp.tickRate <= 0)) { gFail('GAMIFY.game(): multiplayer.tickRate must be a positive number of broadcasts per second.'); } } if (definition.params !== undefined) { if (!definition.params || typeof definition.params !== 'object' || Array.isArray(definition.params)) { gFail('GAMIFY.game(): params must be a flat object of tunable values, e.g. { speed: 240 }.'); } Object.keys(definition.params).forEach(function (key) { var value = definition.params[key]; var kind = typeof value; if (kind !== 'number' && kind !== 'boolean' && kind !== 'string') { gFail( 'GAMIFY.game(): params.' + key + ' must be a number, boolean or string so the ' + 'studio can retune it live, got ' + gDescribe(value) + '. Put structured data in setup() on g.data.' ); } if (kind === 'number' && !isFinite(value)) { gFail('GAMIFY.game(): params.' + key + ' is ' + String(value) + ', which is not a usable default.'); } }); } } /** * Key names that will never match. normalizeKey lowercases single characters, * so 'A' is fine — but 'space' stays 'space' and never equals the normalized * 'Space', leaving a dead control with no error anywhere. */ var G_KEY_ALIASES = { space: 'Space', enter: 'Enter', escape: 'Escape', esc: 'Escape', shift: 'Shift', tab: 'Tab', control: 'Control', ctrl: 'Control', alt: 'Alt', backspace: 'Backspace', arrowup: 'ArrowUp', arrowdown: 'ArrowDown', arrowleft: 'ArrowLeft', arrowright: 'ArrowRight', up: 'ArrowUp', down: 'ArrowDown', left: 'ArrowLeft', right: 'ArrowRight', }; function gCheckKeyName(action, key) { if (key.length === 1) return; var canonical = G_KEY_ALIASES[key.toLowerCase()]; if (canonical && canonical !== key) { gFail( 'GAMIFY.game(): actions.' + action + ' uses "' + key + '", which never matches a real key event. ' + 'Use "' + canonical + '" (KeyboardEvent.key values are case-sensitive).' ); } if (key.indexOf('+') >= 0) { gFail( 'GAMIFY.game(): actions.' + action + ' uses "' + key + '". Key combinations are not supported; ' + 'list single keys and check modifiers yourself if you need them.' ); } } /** Sixty sends a second per client is how a room falls over. */ var NET_MAX_TICK_RATE = 30; var NET_PEER_TIMEOUT_MS = 6000; function makeNet(config) { var enabled = !!config; var cfg = config || {}; var conf = window.__GAMIFY_SUPABASE__ || null; var canConnect = !!(enabled && conf && conf.url && conf.anonKey && window.supabase); /** Per-tab identity. Two tabs on one machine are two players. */ var selfId = 'p_' + Math.random().toString(36).slice(2, 8) + Date.now().toString(36).slice(-4); var room = 'lobby'; if (enabled) { if (cfg.room === 'url' || !cfg.room) { try { var fromQuery = new URLSearchParams(location.search).get('room'); room = fromQuery ? String(fromQuery).slice(0, 60) : 'lobby'; } catch (e) { room = 'lobby'; } } else { room = String(cfg.room).slice(0, 60); } } var tickRate = Math.max(1, Math.min(NET_MAX_TICK_RATE, cfg.tickRate || 20)); var sendEvery = 1 / tickRate; var sinceSend = 0; /** * Two snapshots per peer, with arrival times. Rendering interpolates between * them: at 20Hz a peer snapped straight to its last position visibly * stutters, and the instinctive fix — raising the tick rate — makes the * bandwidth problem worse without fixing the stutter. */ var peerData = {}; var peerList = []; var stats = { sent: 0, received: 0, dropped: 0 }; var channel = null; var connected = false; var joinOrder = {}; function now() { return Date.now(); } function rebuildList() { peerList.length = 0; var ids = Object.keys(peerData); for (var i = 0; i < ids.length; i += 1) peerList.push(peerData[ids[i]].view); } function ensurePeer(id) { if (peerData[id]) return peerData[id]; var entry = { id: id, prev: null, next: null, lastSeen: now(), view: { id: id, latencyMs: 0 }, }; peerData[id] = entry; rebuildList(); if (typeof cfg.onJoin === 'function') { try { cfg.onJoin(window.__GAMIFY_CTX__, entry.view); } catch (e) { gNote('multiplayer onJoin threw: ' + e.message); } } return entry; } function dropPeer(id) { var entry = peerData[id]; if (!entry) return; delete peerData[id]; delete joinOrder[id]; rebuildList(); if (typeof cfg.onLeave === 'function') { try { cfg.onLeave(window.__GAMIFY_CTX__, entry.view); } catch (e) { gNote('multiplayer onLeave threw: ' + e.message); } } } function receiveSnapshot(id, data) { if (id === selfId) return; var entry = ensurePeer(id); var t = now(); entry.prev = entry.next || { t: t, data: data }; entry.next = { t: t, data: data }; entry.lastSeen = t; stats.received += 1; } /** * Interpolate to RENDER time, one step behind the newest snapshot. Being * deliberately slightly in the past is what makes motion smooth instead of * extrapolating into positions a peer never occupied. */ function interpolate() { var t = now() - (1000 / tickRate); var ids = Object.keys(peerData); var expired = null; for (var i = 0; i < ids.length; i += 1) { var entry = peerData[ids[i]]; if (now() - entry.lastSeen > NET_PEER_TIMEOUT_MS) { (expired = expired || []).push(entry.id); continue; } if (!entry.next) continue; var a = entry.prev || entry.next; var b = entry.next; var span = b.t - a.t; var alpha = span > 0 ? Math.max(0, Math.min(1, (t - a.t) / span)) : 1; var keys = Object.keys(b.data); for (var k = 0; k < keys.length; k += 1) { var key = keys[k]; var to = b.data[key]; var from = a.data[key]; // Numbers are blended; anything else takes the newest value as-is. if (typeof to === 'number' && typeof from === 'number') { entry.view[key] = from + (to - from) * alpha; } else { entry.view[key] = to; } } } if (expired) for (var e = 0; e < expired.length; e += 1) dropPeer(expired[e]); } function connect() { if (!canConnect) return; var client; try { client = window.supabase.createClient(conf.url, conf.anonKey, { realtime: { params: { eventsPerSecond: NET_MAX_TICK_RATE } }, }); } catch (error) { gNote('multiplayer could not start: ' + (error && error.message)); return; } channel = client.channel('gamify:' + room, { config: { presence: { key: selfId }, broadcast: { self: false } }, }); channel .on('broadcast', { event: 's' }, function (message) { var body = message && message.payload; if (body && body.i) receiveSnapshot(body.i, body.d || {}); }) .on('broadcast', { event: 'e' }, function (message) { var body = message && message.payload; if (!body || body.i === selfId) return; stats.received += 1; if (typeof cfg.onEvent === 'function') { try { cfg.onEvent(window.__GAMIFY_CTX__, body.n, body.p, body.i); } catch (error) { gNote('multiplayer onEvent threw: ' + error.message); } } }) /** * Presence, not goodbye messages: a player who closes the tab or loses * their connection never sends one, and a ghost peer standing still * forever is worse than no peer at all. */ .on('presence', { event: 'sync' }, function () { var state = {}; try { state = channel.presenceState() || {}; } catch (e) { state = {}; } var present = {}; var ids = Object.keys(state); for (var i = 0; i < ids.length; i += 1) { present[ids[i]] = true; var meta = state[ids[i]] && state[ids[i]][0]; if (meta && meta.at && joinOrder[ids[i]] === undefined) joinOrder[ids[i]] = meta.at; } var known = Object.keys(peerData); for (var k = 0; k < known.length; k += 1) { if (!present[known[k]]) dropPeer(known[k]); } for (var p = 0; p < ids.length; p += 1) { if (ids[p] !== selfId) ensurePeer(ids[p]); } }) .subscribe(function (status) { connected = status === 'SUBSCRIBED'; api.online = connected; if (connected) { joinOrder[selfId] = Date.now(); try { channel.track({ at: joinOrder[selfId] }); } catch (e) {} } }); } var api = { enabled: enabled, /** False until the socket is actually up — never assume it will be. */ online: false, id: selfId, room: room, tickRate: tickRate, peers: peerList, stats: stats, get count() { return peerList.length + 1; }, /** * Earliest joiner is host. Something has to own shared objects, and with * broadcast there is no server to do it. Re-elects automatically when the * current host leaves, because presence removed them from joinOrder. */ get isHost() { if (!connected) return true; var ids = Object.keys(joinOrder); var best = selfId; var bestAt = joinOrder[selfId] === undefined ? Infinity : joinOrder[selfId]; for (var i = 0; i < ids.length; i += 1) { var at = joinOrder[ids[i]]; if (at < bestAt || (at === bestAt && ids[i] < best)) { best = ids[i]; bestAt = at; } } return best === selfId; }, /** A discrete one-off: a shot, a pickup, a scored point. */ emit: function (name, payload) { if (!connected || !channel) { stats.dropped += 1; return false; } try { channel.send({ type: 'broadcast', event: 'e', payload: { i: selfId, n: String(name), p: payload === undefined ? null : payload }, }); stats.sent += 1; return true; } catch (error) { stats.dropped += 1; return false; } }, /** Called by the engine on the FIXED clock, never per frame. */ __step: function (context, dt) { if (!enabled) return; sinceSend += dt; if (sinceSend < sendEvery) return; sinceSend = 0; if (!connected || !channel || typeof cfg.self !== 'function') return; var snapshot; try { snapshot = cfg.self(context); } catch (error) { gNote('multiplayer self() threw: ' + error.message); return; } if (!snapshot || typeof snapshot !== 'object') return; try { channel.send({ type: 'broadcast', event: 's', payload: { i: selfId, d: snapshot } }); stats.sent += 1; } catch (error) { stats.dropped += 1; } }, /** Called before draw, so peers are positioned for THIS frame. */ __render: function () { if (enabled) interpolate(); }, __report: function () { return { enabled: enabled, online: connected, room: room, id: selfId, tickRate: tickRate, peers: peerList.length, isHost: api.isHost, sent: stats.sent, received: stats.received, dropped: stats.dropped, }; }, __teardown: function () { if (channel) { try { channel.unsubscribe(); } catch (e) {} } channel = null; connected = false; api.online = false; }, }; if (enabled && !canConnect) { /** * Reported, not thrown. A game whose multiplayer is unconfigured must still * boot and be playable alone — but the reason has to reach the verdict, or * "my game has no other players" becomes unexplainable. */ gNote( 'multiplayer is declared but not connected' + (!conf || !conf.url ? ' — no Supabase project is configured for this game' : !window.supabase ? ' — the Supabase client did not load' : '') + '. The game runs single-player: g.net.online is false and g.net.peers is empty.' ); } if (canConnect) connect(); return api; } function makeBackend() { var conf = window.__GAMIFY_SUPABASE__ || null; var ready = !!(conf && conf.url && conf.anonKey && window.supabase); var client = null; var session = null; var listeners = []; var signInPromise = null; if (ready) { try { client = window.supabase.createClient(conf.url, conf.anonKey, { auth: { persistSession: true, autoRefreshToken: true, storageKey: 'gamify-auth' }, }); } catch (error) { ready = false; gNote('backend could not start: ' + (error && error.message)); } } function offline(api) { gFail( api + ' needs a Supabase project, and none is connected to this game. ' + 'Ask the user to connect one in the Backend tab, or keep this state in memory. ' + 'Check g.db.ready before calling if the feature is optional.' ); } function fail(api, table, error) { var message = (error && (error.message || error.hint || error.details)) || String(error); var code = error && error.code ? ' [' + error.code + ']' : ''; var advice = ''; if (/relation .* does not exist/i.test(message) || (error && error.code === '42P01')) { advice = ' The table "' + table + '" does not exist — provision it with provision_tables first.'; } else if (error && (error.code === '42501' || /row-level security/i.test(message))) { advice = ' Row Level Security rejected this. On an owner-scoped table you may only touch your own rows, ' + 'and user_id is set for you — do not pass it yourself.'; } else if (error && error.code === '23502') { advice = ' A required column was missing from the row you sent.'; } gFail(api + '("' + table + '") failed' + code + ': ' + message + '.' + advice); } /** * One in-flight sign-in, shared. Several systems calling ensure() during * setup() must not open several sessions and race each other. */ function ensureSession() { if (!ready) return Promise.resolve(null); if (session) return Promise.resolve(session); if (signInPromise) return signInPromise; signInPromise = client.auth .getSession() .then(function (result) { if (result && result.data && result.data.session) return result.data.session; return client.auth.signInAnonymously().then(function (created) { if (created && created.error) throw created.error; return created && created.data ? created.data.session : null; }); }) .then(function (live) { session = live; signInPromise = null; for (var i = 0; i < listeners.length; i += 1) { try { listeners[i](api.auth.user()); } catch (e) {} } return live; }) .catch(function (error) { signInPromise = null; /** * Reported, not thrown. Anonymous sign-in is disabled by default on new * Supabase projects, and a game must not die on the title screen because * of a project setting — but the reason has to reach the verdict or * "nothing saves" is unexplainable. */ gNote( 'could not sign in: ' + ((error && error.message) || error) + '. If this says anonymous sign-ins are disabled, enable them in Supabase ' + '(Authentication → Providers → Anonymous). Saves and per-player data will not work until then.' ); return null; }); return signInPromise; } /** Owner-scoped tables need user_id; the game must never have to know that. */ function withOwner(row) { var uid = session && session.user ? session.user.id : null; if (!uid) return row; var copy = {}; Object.keys(row || {}).forEach(function (key) { copy[key] = row[key]; }); if (copy.user_id === undefined) copy.user_id = uid; return copy; } var api = { auth: { get ready() { return ready; }, /** Resolves once a session exists. Called for you before setup(). */ ensure: ensureSession, user: function () { if (!session || !session.user) return null; return { id: session.user.id, email: session.user.email || null, anonymous: !session.user.email, }; }, get id() { return session && session.user ? session.user.id : null; }, onChange: function (callback) { if (typeof callback === 'function') listeners.push(callback); }, /** * Upgrade an anonymous player to a real account WITHOUT changing their * uid, so everything they already saved stays theirs. */ linkEmail: function (email) { if (!ready) offline('g.auth.linkEmail'); return client.auth.updateUser({ email: String(email) }).then(function (result) { if (result.error) gFail('g.auth.linkEmail failed: ' + result.error.message); return true; }); }, signOut: function () { if (!ready) return Promise.resolve(); session = null; return client.auth.signOut().then(function () { return ensureSession(); }); }, }, db: { get ready() { return ready; }, /** Insert one row. user_id is filled in for you on owner-scoped tables. */ insert: function (table, row) { if (!ready) offline('g.db.insert'); return ensureSession().then(function () { return client.from(table).insert(withOwner(row)).select().then(function (result) { if (result.error) fail('g.db.insert', table, result.error); return result.data && result.data[0] ? result.data[0] : null; }); }); }, /** * Insert or replace on a conflict — the shape a save slot needs. Requires * a unique index on the onConflict columns, which provision_tables creates. */ upsert: function (table, row, onConflict) { if (!ready) offline('g.db.upsert'); return ensureSession().then(function () { var query = client.from(table).upsert(withOwner(row), onConflict ? { onConflict: onConflict } : undefined); return query.select().then(function (result) { if (result.error) fail('g.db.upsert', table, result.error); return result.data && result.data[0] ? result.data[0] : null; }); }); }, /** * Read rows. RLS decides what is visible, so an owner-scoped table returns * only this player's rows without the game filtering anything. * * select(table, { match, order, desc, limit }) */ select: function (table, options) { if (!ready) offline('g.db.select'); var opts = options || {}; return ensureSession().then(function () { var query = client.from(table).select(opts.columns || '*'); if (opts.match) { Object.keys(opts.match).forEach(function (key) { query = query.eq(key, opts.match[key]); }); } if (opts.order) query = query.order(opts.order, { ascending: !opts.desc }); if (opts.limit) query = query.limit(opts.limit); return query.then(function (result) { if (result.error) fail('g.db.select', table, result.error); return result.data || []; }); }); }, update: function (table, match, patch) { if (!ready) offline('g.db.update'); return ensureSession().then(function () { var query = client.from(table).update(patch); Object.keys(match || {}).forEach(function (key) { query = query.eq(key, match[key]); }); return query.select().then(function (result) { if (result.error) fail('g.db.update', table, result.error); return result.data || []; }); }); }, remove: function (table, match) { if (!ready) offline('g.db.remove'); return ensureSession().then(function () { var query = client.from(table).delete(); Object.keys(match || {}).forEach(function (key) { query = query.eq(key, match[key]); }); return query.then(function (result) { if (result.error) fail('g.db.remove', table, result.error); return true; }); }); }, /** * Call a server-side function. The only honest way to submit a score: * anything computed in the browser is a value the player chose. */ rpc: function (name, args) { if (!ready) offline('g.db.rpc'); return ensureSession().then(function () { return client.rpc(name, args || {}).then(function (result) { if (result.error) fail('g.db.rpc', name, result.error); return result.data; }); }); }, }, __report: function () { return { ready: ready, signedIn: !!(session && session.user), anonymous: !!(session && session.user && !session.user.email), }; }, __start: ensureSession, }; return api; } function mulberry32(seed) { var a = seed >>> 0; return function () { a = (a + 0x6D2B79F5) >>> 0; var t = a; t = Math.imul(t ^ (t >>> 15), t | 1); t ^= t + Math.imul(t ^ (t >>> 7), t | 61); return ((t ^ (t >>> 14)) >>> 0) / 4294967296; }; } function makeRng(seed) { var next = mulberry32(seed); return { seed: seed, next: next, range: function (min, max) { gFinite(min, 'min', 'rng.range'); gFinite(max, 'max', 'rng.range'); return min + next() * (max - min); }, int: function (min, max) { gFinite(min, 'min', 'rng.int'); gFinite(max, 'max', 'rng.int'); return Math.floor(min + next() * (max - min + 1)); }, pick: function (list) { if (!Array.isArray(list)) gFail('rng.pick() needs an array, got ' + gDescribe(list) + '.'); if (!list.length) gFail('rng.pick() was given an empty array â€” there is nothing to choose from.'); return list[Math.floor(next() * list.length)]; }, chance: function (p) { gFinite(p, 'p', 'rng.chance'); return next() < p; }, }; } function makeAudio() { var ctx = null, master = null, muted = false; function ensure() { if (ctx) { if (ctx.state === 'suspended') ctx.resume(); return ctx; } var Ctor = window.AudioContext || window.webkitAudioContext; if (!Ctor) return null; ctx = new Ctor(); master = ctx.createGain(); master.gain.value = muted ? 0 : 0.7; master.connect(ctx.destination); return ctx; } return { unlock: ensure, /** * The AudioContext itself, and the master bus everything should connect * to. blip() alone cannot build a real mix â€” a game that wants scheduled * envelopes, filtered noise, or a compressor needs the context, and with * no way to reach it a whole hand-written audio module silently no-ops. * (That happened: every sound function bailed on a.ctx || a.context.) * * Getters, so touching them unlocks the context rather than handing back * a null captured before the first gesture. */ get ctx() { return ensure(); }, get context() { return ensure(); }, get destination() { ensure(); return master; }, setMuted: function (v) { muted = !!v; if (master) master.gain.value = muted ? 0 : 0.7; }, blip: function (freq, duration, type) { var c = ensure(); if (!c || muted) return; var osc = c.createOscillator(), gain = c.createGain(); osc.type = type || 'square'; osc.frequency.value = freq || 440; var d = duration || 0.12; gain.gain.setValueAtTime(0.28, c.currentTime); gain.gain.exponentialRampToValueAtTime(0.0001, c.currentTime + d); osc.connect(gain); gain.connect(master); osc.start(); osc.stop(c.currentTime + d); }, }; } function makeInput(domElement) { var keyToActions = {}, down = {}, pressed = {}; // Retained so a query for an undeclared action can name what IS declared. var actionMap = {}; var pointer = { x: 0, y: 0, dx: 0, dy: 0, down: false, locked: false }; function norm(key) { return key === ' ' ? 'Space' : (key.length === 1 ? key.toLowerCase() : key); } function bind(map) { keyToActions = {}; actionMap = map || {}; Object.keys(actionMap).forEach(function (action) { (actionMap[action] || []).forEach(function (key) { var k = norm(key); if (!keyToActions[k]) keyToActions[k] = []; keyToActions[k].push(action); }); }); } window.addEventListener('keydown', function (e) { var list = keyToActions[norm(e.key)]; if (!list) return; e.preventDefault(); list.forEach(function (a) { if (!down[a]) pressed[a] = true; down[a] = true; }); }); window.addEventListener('keyup', function (e) { var list = keyToActions[norm(e.key)]; if (!list) return; e.preventDefault(); list.forEach(function (a) { down[a] = false; }); }); window.addEventListener('blur', function () { down = {}; }); /** * Mouse-look needs pointer lock. Without it the browser reports motion * only while the cursor happens to be over the canvas, and it stops dead * at the window edge â€” which reads as "turning is broken" in any * first-person game. Listen on the document so deltas keep arriving once * the pointer is locked and the cursor no longer exists. */ document.addEventListener('mousemove', function (e) { pointer.dx += e.movementX || 0; pointer.dy += e.movementY || 0; if (!pointer.locked) { pointer.x = e.clientX; pointer.y = e.clientY; } }); domElement.addEventListener('mousedown', function () { pointer.down = true; }); window.addEventListener('mouseup', function () { pointer.down = false; }); document.addEventListener('pointerlockchange', function () { pointer.locked = document.pointerLockElement === domElement; }); /** * Browsers grant pointer lock only from a user gesture, so a game cannot * simply ask for it in setup(). Games opt in with input.lockOnClick() and * the next real click captures the mouse. */ var lockWanted = false; domElement.addEventListener('click', function () { if (lockWanted && !pointer.locked && domElement.requestPointerLock) { var granted = domElement.requestPointerLock(); if (granted && typeof granted.catch === 'function') granted.catch(function () {}); } }); /** Same contract as canvas2d: an unbound action is a bug, not a false. */ function requireAction(action, method) { if (typeof action !== 'string' || !action.length) { gFail('input.' + method + '() needs an action name, got ' + gDescribe(action) + '.'); } if (!Object.prototype.hasOwnProperty.call(actionMap, action)) { gFail( 'input.' + method + '("' + action + '"): no such action. Declared actions: ' + gList(Object.keys(actionMap)) + '. Add it to the actions map in GAMIFY.game(), or use input.has() if it is optional.' ); } } return { bind: bind, down: function (a) { requireAction(a, 'down'); return !!down[a]; }, pressed: function (a) { requireAction(a, 'pressed'); return !!pressed[a]; }, has: function (a) { return Object.prototype.hasOwnProperty.call(actionMap, a); }, pointer: pointer, endStep: function () { pressed = {}; pointer.dx = 0; pointer.dy = 0; }, force: function (a, isDown) { requireAction(a, 'force'); if (isDown && !down[a]) pressed[a] = true; down[a] = !!isDown; }, clear: function () { down = {}; pressed = {}; }, requestPointerLock: function () { if (!domElement.requestPointerLock) return; var granted = domElement.requestPointerLock(); if (granted && typeof granted.catch === 'function') granted.catch(function () {}); }, /** Opt in once in setup(); the next click captures the mouse. */ lockOnClick: function () { lockWanted = true; }, exitPointerLock: function () { if (document.exitPointerLock) document.exitPointerLock(); }, isPointerLocked: function () { return !!pointer.locked; }, }; } /** * The asset library, by @name handle. * * Uploads reached the CDN and the definition and then stopped there â€” the game * never received them, so the only way to use one was to paste its CDN URL into * the source. asset() is the supported path, and it THROWS on an unknown name * rather than returning undefined: a silent undefined becomes a broken texture * or a mute sound with no error, which is the exact failure mode this engine * keeps producing. */ var assetTable = window.__GAMIFY_ASSETS__ || {}; /** * Live animated rigs, stepped by the engine on the fixed clock. * * Games forgot to call mixer.update() constantly, or called it in draw() * where it drifts against the simulation. Owning it here means an animated * character cannot silently stand still. */ var activeRigs = []; /** * How many asset loads are in flight. * * Verification steps SIMULATED time (advanceTime), so no real wall clock passes * — which means an async model load never finishes before the run ends. The * agent then sees an empty scene, concludes the asset failed, and "fixes" a * load that was working. The harness reads this and waits for real network * time before it judges anything. */ window.__GAMIFY_ASSETS_PENDING__ = 0; function assetLoadStarted() { window.__GAMIFY_ASSETS_PENDING__ += 1; } function assetLoadSettled() { window.__GAMIFY_ASSETS_PENDING__ = Math.max(0, window.__GAMIFY_ASSETS_PENDING__ - 1); } function makeAssets() { return { url: function (name) { var entry = assetTable[name]; if (!entry) { var known = Object.keys(assetTable); throw new Error( 'No asset named "' + name + '". ' + (known.length ? 'Available: ' + known.join(', ') : 'This game has no assets yet.') ); } return entry.url; }, has: function (name) { return !!assetTable[name]; }, list: function () { return Object.keys(assetTable).map(function (name) { return { name: name, kind: assetTable[name].kind, url: assetTable[name].url }; }); }, /** A ready