File size: 18,286 Bytes
ecb7e47 cab56b6 1e9fb9d ecb7e47 cab56b6 ecb7e47 1e9fb9d ecb7e47 cab56b6 1e9fb9d ecb7e47 cab56b6 ecb7e47 cab56b6 ecb7e47 1e9fb9d ecb7e47 1e9fb9d ecb7e47 1e9fb9d ecb7e47 1e9fb9d cab56b6 1e9fb9d ecb7e47 cab56b6 1e9fb9d cab56b6 1e9fb9d cab56b6 1e9fb9d cab56b6 1e9fb9d cab56b6 ecb7e47 1e9fb9d ecb7e47 1e9fb9d ecb7e47 1e9fb9d ecb7e47 1e9fb9d ecb7e47 cab56b6 1e9fb9d cab56b6 1e9fb9d cab56b6 ecb7e47 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 | // Online play with real people, no server of our own: WebRTC peer-to-peer through the free PeerJS broker.
// A room is a well-known peer id; the first player to claim it is the host and relays everyone's car to everyone.
// If the host leaves, the others race to claim it again. Voice chat is a mesh of audio calls, off until you
// switch your mic on, and you hear each voice from where that player's car is: louder when close, left or right, ahead or behind. Chat is quick emotes only (strangers
// can join the public city), and names are short and filtered. Anyone can be muted (voice and emotes), push-to-talk is
// a setting, a speaker icon shows who is talking, and everyone's ping to the host is shown.
const PREFIX = "voidcity-awsaa-v1-";
const ICE = { iceServers: [{ urls: "stun:stun.l.google.com:19302" }, { urls: "stun:stun1.l.google.com:19302" }, { urls: "stun:global.stun.twilio.com:3478" }] };
// a TURN relay for players behind strict networks (some phone carriers, school and office wifi), where direct links fail.
// The free no-signup relays are gone (openrelay.metered.ca no longer resolves), so this needs a free Metered account:
// its credentials URL (https://<app>.metered.live/api/v1/turn/credentials?apiKey=...) goes here. Empty: STUN only.
const TURN_URL = "";
let turnTried = false;
async function addTurn() {
if (turnTried || !TURN_URL) return; turnTried = true;
try { const r = await fetch(TURN_URL), list = await r.json(); if (Array.isArray(list)) ICE.iceServers.push(...list.filter(s => s && s.urls)); } catch { }
}
const BAD = /(fuck|shit|bitch|nigg|cunt|dick|pussy|sex|porn|kill|nazi|hitler|rape|fag)/i;
export const cleanName = s => { s = String(s || "").replace(/[^\p{L}\p{N} _-]/gu, "").trim().slice(0, 14); return !s || BAD.test(s) ? "Driver" : s; };
// what strangers may send: only these events, only sane numbers, and not too often
const EVENTS = new Set(["race", "emote"]);
const num = (v, lim) => Number.isFinite(v) && Math.abs(v) <= lim;
const okState = st => st && Array.isArray(st.p) && st.p.length === 6 && num(st.p[0], 8000) && num(st.p[1], 4000) && num(st.p[2], 8000) && st.p.slice(3).every(v => num(v, 50))
&& (st.u === undefined || (Array.isArray(st.u) && st.u.length === 3 && st.u.every(v => num(v, 500))));
const flood = c => { const now = performance.now(); if (now - (c._t || 0) > 1000) { c._t = now; c._n = 0; } return ++c._n > 60; };
export const EMOTES = ["👋 Hi!", "🏁 Race?", "😂", "🔥 Nice!", "GG", "🚓 Cops!", "Follow me", "Wait up"];
export function createNet() {
let Peer = null, peer = null, host = false, me = null, room = null, name = "Driver", hostConn = null, sendT = 0, lastState = null, closing = false;
const conns = new Map(); // host: everyone's connection
const players = new Map(); // id -> { id, name, s: [samples], model, paint, race, rp, rf, vc, emote, emoteT }
const handlers = {};
const emit = (k, ...a) => (handlers[k] || []).forEach(f => f(...a));
const status = t => emit("status", t);
let stream = null, micOn = false, calls = new Map();
// each voice: a media element (Chrome only feeds a remote WebRTC stream into Web Audio while an element plays it too, and it is
// the fallback when the game's audio isn't running) plus, once there is an audio context, a 3D panner at that player's car
const voices = new Map(); // id -> { el, src, pan, gain, an, buf, level, loud, s }
let actx = null, mic = null; // mic: an analyser on my own microphone, for the level meter
let ptt = false, talking = false; // push-to-talk: the mic only sends while the key is held
const muted = new Set(), mutedNames = new Set(); // ids, and names so a muted player stays muted after reconnecting
let rtt = null, pingT = 0; // my round trip to the host (ms)
const isMuted = id => muted.has(id) || mutedNames.has((players.get(id) || {}).name);
const applyTracks = () => { if (stream) for (const t of stream.getAudioTracks()) t.enabled = micOn && (!ptt || talking); };
const rms = (an, buf) => { an.getFloatTimeDomainData(buf); let s = 0; for (let i = 0; i < buf.length; i++) s += buf[i] * buf[i]; return Math.sqrt(s / buf.length); };
async function lib() { if (!Peer) ({ Peer } = await import("https://cdn.jsdelivr.net/npm/peerjs@1.5.4/+esm")); return Peer; }
async function join(r, nm) {
await leave(); closing = false; room = String(r).toLowerCase().replace(/[^a-z0-9-]/g, "").slice(0, 24) || "public-1"; name = cleanName(nm);
status("Connecting…"); await lib(); await addTurn(); claim();
}
function claim() {
if (closing) return;
const p = new Peer(PREFIX + room, { config: ICE, debug: 0 }); peer = p;
p.on("open", id => { host = true; me = id; status(`Online · room ${room} · you are hosting`); emit("change"); });
p.on("connection", c => {
c.on("data", d => onData(c, d));
c.on("open", () => { if (conns.size >= 11) { c.send({ t: "full" }); setTimeout(() => c.close(), 300); return; } conns.set(c.peer, c); emit("change"); });
c.on("close", () => { conns.delete(c.peer); players.delete(c.peer); dropAudio(c.peer); emit("change"); broadcast({ t: "gone", id: c.peer }); });
});
p.on("call", answer);
p.on("error", e => {
if (e.type === "unavailable-id") { p.destroy(); client(); }
else if (e.type === "peer-unavailable") { status("Room not found, retrying…"); setTimeout(() => rejoin(), 800 + Math.random() * 1500); }
else status("Network: " + e.type);
});
}
function client() {
if (closing) return;
const p = new Peer({ config: ICE, debug: 0 }); peer = p; host = false;
p.on("open", id => {
me = id; const c = p.connect(PREFIX + room, { serialization: "json", reliable: false }); hostConn = c;
c.on("open", () => { status(`Online · room ${room}`); c.send({ t: "hello", name }); emit("change"); });
c.on("data", d => onData(c, d));
c.on("close", () => { if (!closing) { status("Host left, reconnecting…"); players.clear(); emit("change"); setTimeout(rejoin, Math.random() * 1500); } });
});
p.on("call", answer);
p.on("error", e => { if (e.type === "peer-unavailable") setTimeout(rejoin, 400 + Math.random() * 1200); else status("Network: " + e.type); });
}
function rejoin() { if (closing) return; try { peer && peer.destroy(); } catch { } hostConn = null; conns.clear(); claim(); }
async function leave() {
closing = true; try { peer && peer.destroy(); } catch { } peer = null; hostConn = null; host = false; conns.clear(); players.clear();
for (const id of [...voices.keys()]) dropAudio(id); setMic(false); room = null; emit("change"); status("Offline");
}
function broadcast(m, except) { for (const [id, c] of conns) if (id !== except && c.open) try { c.send(m); } catch { } }
function upsert(id, st) {
let p = players.get(id), fresh = !p; if (!p) { p = { id, name: "Driver", s: [] }; players.set(id, p); }
if (st.n && cleanName(st.n) !== p.name) { p.name = cleanName(st.n); fresh = true; }
Object.assign(p, { model: Number.isInteger(st.m) && st.m >= 0 && st.m < 20 ? st.m : 0, paint: /^#[0-9a-f]{6}$/i.test(st.c) ? st.c : "#888888", race: typeof st.r === "string" ? st.r.slice(0, 20) : 0, rp: num(st.rp, 1e7) ? st.rp : 0, rf: num(st.rf, 1e7) ? st.rf : 0, vc: !!st.vc, wanted: num(st.w, 5) ? st.w | 0 : 0, ping: num(st.q, 10000) ? st.q | 0 : null });
const u = st.u || [0, 0, 0];
p.s.push({ t: performance.now(), x: st.p[0], y: st.p[1], z: st.p[2], yaw: st.p[3], pitch: st.p[4], roll: st.p[5], vx: u[0], vy: u[1], vz: u[2], v: num(st.v, 2000) ? st.v : 0, air: !!st.a });
if (p.s.length > 12) p.s.shift();
if (fresh) { emit("change"); ring(id); } // someone new: if my mic is on, call them so they hear me
}
function onData(c, d) {
if (!d || typeof d !== "object" || flood(c)) return;
if (d.t === "ev" && !EVENTS.has(d.k)) return;
if (d.t === "pi") { if (host && num(d.ts, 1e12)) try { c.send({ t: "po", ts: d.ts }); } catch { } return; }
if (d.t === "po") { const r = performance.now() - d.ts; if (num(d.ts, 1e12) && r >= 0 && r < 10000) rtt = rtt == null ? r : rtt * .7 + r * .3; return; }
if (host) {
if (d.t === "hello") { const p = players.get(c.peer) || { id: c.peer, s: [] }; p.name = cleanName(d.name); players.set(c.peer, p); emit("change"); return; }
if (d.t === "s") { if (okState(d)) upsert(c.peer, d); return; }
if (d.t === "ev") { broadcast({ ...d, from: c.peer }, c.peer); emit(d.k, d, c.peer); return; }
} else {
if (d.t === "w") { if (Array.isArray(d.all)) for (const st of d.all.slice(0, 16)) if (st && typeof st.id === "string" && st.id !== me && okState(st)) upsert(st.id, st); return; }
if (d.t === "gone") { players.delete(d.id); dropAudio(d.id); emit("change"); return; }
if (d.t === "full") { status("Room full, trying the next one"); room = room.replace(/(\d+)$/, n => +n + 1); rejoin(); return; }
if (d.t === "ev") { emit(d.k, d, d.from); return; }
}
}
// voice: everyone with their mic on calls everyone; people without a mic still hear
// one call per pair carries both voices. If both ring at once, the call started by the smaller id wins (both sides agree).
function answer(call) {
const old = calls.get(call.peer);
if (old && old._out && me < call.peer) { try { call.close(); } catch { } return; }
if (old) try { old.close(); } catch { }
call.answer(stream || undefined); hook(call, !!stream, false);
}
// call someone with my mic, unless a call already carries it (a call I answered without a mic is replaced)
function ring(id) {
if (!peer || !stream || !micOn || id === me) return;
const c = calls.get(id); if (c && c._sent) return;
if (c) { try { c.close(); } catch { } calls.delete(id); }
try { hook(peer.call(id, stream), true, true); } catch { }
}
function hook(call, sent, out) {
call._sent = sent; call._out = out; calls.set(call.peer, call);
call.on("stream", s => voiceIn(call.peer, s));
call.on("close", () => { if (calls.get(call.peer) === call) calls.delete(call.peer); });
}
function voiceIn(id, s) {
let v = voices.get(id); if (!v) { v = { el: new Audio() }; v.el.autoplay = true; voices.set(id, v); }
if (v.s !== s) { unwire(v); v.s = s; v.el.srcObject = s; v.el.play().catch(() => { }); }
wire(v);
}
function wire(v) {
if (v.pan || !actx || !v.s) return;
try {
v.src = actx.createMediaStreamSource(v.s); v.pan = actx.createPanner(); v.gain = actx.createGain(); v.an = actx.createAnalyser(); v.an.fftSize = 256; v.buf = new Float32Array(256);
Object.assign(v.pan, { panningModel: "HRTF", distanceModel: "linear", refDistance: 6, maxDistance: 260, rolloffFactor: 1 });
v.src.connect(v.an); v.src.connect(v.pan).connect(v.gain).connect(actx.destination);
} catch { unwire(v); }
}
function unwire(v) { try { v.src && v.src.disconnect(); v.pan && v.pan.disconnect(); v.gain && v.gain.disconnect(); } catch { } v.src = v.pan = v.gain = v.an = null; }
function micMeter() { if (mic || !actx || !stream) return; try { const src = actx.createMediaStreamSource(stream), an = actx.createAnalyser(); an.fftSize = 256; src.connect(an); mic = { src, an, buf: new Float32Array(256), level: 0 }; } catch { } }
function dropAudio(id) { const v = voices.get(id); if (v) { unwire(v); v.el.srcObject = null; voices.delete(id); } const c = calls.get(id); if (c) { try { c.close(); } catch { } calls.delete(id); } }
const now = () => performance.now();
const at = (node, x, y, z, set) => { if (node.positionX) { const t = actx.currentTime; node.positionX.setTargetAtTime(x, t, .03); node.positionY.setTargetAtTime(y, t, .03); node.positionZ.setTargetAtTime(z, t, .03); } else set.call(node, x, y, z); };
async function setMic(on) {
if (on && !stream) { try { stream = await navigator.mediaDevices.getUserMedia({ audio: { echoCancellation: true, noiseSuppression: true, autoGainControl: true } }); } catch { status("Microphone blocked"); emit("mic", false); return false; } }
micOn = on; applyTracks(); micMeter();
if (on) for (const p of players.values()) ring(p.id);
emit("mic", on); return on;
}
// players who went quiet (closed the tab, lost signal) are dropped after 15 s instead of standing still forever
setInterval(() => { const now = performance.now(); let gone = false; for (const p of [...players.values()]) { const last = p.s.length ? p.s[p.s.length - 1].t : p.seen || (p.seen = now); if (now - last > 15000) { players.delete(p.id); dropAudio(p.id); gone = true; } } if (gone) emit("change"); }, 3000);
return {
join, leave, setMic, EMOTES,
on(k, f) { (handlers[k] = handlers[k] || []).push(f); },
online: () => !!(peer && me && (host || (hostConn && hostConn.open))),
get host() { return host; }, get room() { return room; }, get me() { return me; }, get mic() { return micOn; }, get name() { return name; },
players: () => [...players.values()],
nameOf: id => (players.get(id) || {}).name || "Someone",
send(m) { // a one-off event for everyone (race start, emote)
const ev = { ...m, t: "ev", k: m.t };
if (host) broadcast({ ...ev, from: me }); else if (hostConn && hostConn.open) hostConn.send(ev);
},
// ~12 times a second: my car to the host; the host sends everyone to everyone
tick(dt, mine) {
if (!peer || !me) return;
lastState = mine;
if (!host && hostConn && hostConn.open && (pingT += dt) > 2) { pingT = 0; try { hostConn.send({ t: "pi", ts: performance.now() }); } catch { } }
sendT += dt; if (sendT < 1 / 12) return; sendT = 0;
const st = mine && { t: "s", n: name, ...mine, vc: micOn, q: rtt == null ? undefined : Math.round(rtt) };
if (host) { const all = [...(st ? [{ id: me, ...st, q: 0 }] : []), ...[...players.values()].filter(p => p.s.length).map(p => { const q = p.s[p.s.length - 1]; return { id: p.id, n: p.name, p: [q.x, q.y, q.z, q.yaw, q.pitch, q.roll], m: p.model, c: p.paint, r: p.race, rp: p.rp, rf: p.rf, vc: p.vc, v: q.v, a: q.air, w: p.wanted, u: [q.vx, q.vy, q.vz], q: p.ping ?? undefined }; })]; broadcast({ t: "w", all }); }
else if (st && hostConn && hostConn.open) try { hostConn.send(st); } catch { }
},
// where a player's car should be drawn now: 120 ms behind, between two samples; when packets are late it carries on
// along the last known velocity for up to 0.35 s (then holds) instead of freezing and jumping
sample(p) {
const now = performance.now(), t = now - 120, s = p.s; if (!s.length) return null;
const last = s[s.length - 1];
if (t >= last.t) { const k = Math.min(t - last.t, 350) / 1000; return { x: last.x + last.vx * k, y: last.y + last.vy * k, z: last.z + last.vz * k, yaw: last.yaw, pitch: last.pitch, roll: last.roll, v: last.v, air: last.air, stale: now - last.t > 4000 }; }
let a = s[0], b = last;
for (let k = 0; k < s.length - 1; k++) if (s[k].t <= t && s[k + 1].t >= t) { a = s[k]; b = s[k + 1]; break; }
const u = b.t > a.t ? Math.max(0, Math.min(1.5, (t - a.t) / (b.t - a.t))) : 1, L = (x, y) => x + (y - x) * u;
const ay = (x, y) => { let d = y - x; while (d > Math.PI) d -= 2 * Math.PI; while (d < -Math.PI) d += 2 * Math.PI; return x + d * u; };
return { x: L(a.x, b.x), y: L(a.y, b.y), z: L(a.z, b.z), yaw: ay(a.yaw, b.yaw), pitch: L(a.pitch, b.pitch), roll: L(a.roll, b.roll), v: b.v, air: b.air, stale: performance.now() - s[s.length - 1].t > 4000 };
},
// once a frame: the camera is the listener (every voice then sits where that player's car is drawn)
listen(ctx, cam) {
if (ctx && ctx !== actx) { for (const v of voices.values()) unwire(v); actx = ctx; }
if (!actx || actx.state !== "running" || !voices.size) return;
const L = actx.listener, e = cam.matrixWorld.elements, fx = -e[8], fy = -e[9], fz = -e[10], ux = e[4], uy = e[5], uz = e[6];
at(L, cam.position.x, cam.position.y, cam.position.z, L.setPosition);
if (L.forwardX) { const t = actx.currentTime; L.forwardX.setTargetAtTime(fx, t, .03); L.forwardY.setTargetAtTime(fy, t, .03); L.forwardZ.setTargetAtTime(fz, t, .03); L.upX.setTargetAtTime(ux, t, .03); L.upY.setTargetAtTime(uy, t, .03); L.upZ.setTargetAtTime(uz, t, .03); }
else L.setOrientation(fx, fy, fz, ux, uy, uz);
},
// a player's voice comes from their car; without running game audio it falls back to plain volume by distance
placeVoice(id, x, y, z, d) {
const v = voices.get(id); if (!v) return;
const live = actx && actx.state === "running";
if (live) { wire(v); }
const off = isMuted(id);
if (live && v.pan) { at(v.pan, x, y + 1, z, v.pan.setPosition); v.el.volume = 0; v.gain.gain.value = off ? 0 : 1; }
else v.el.volume = off ? 0 : Math.max(0, Math.min(1, 1 - d / 260));
// the speaking icon: a smoothed level, held a moment so it doesn't flicker between words
if (v.an) { const r = rms(v.an, v.buf); v.level = Math.max(r, (v.level || 0) * .9); v.loud = r > .02 ? now() : v.loud || 0; }
},
speaking: id => { const v = voices.get(id); return !!(v && v.loud && now() - v.loud < 350 && !isMuted(id)); },
level: id => { const v = voices.get(id); return v ? Math.min(1, (v.level || 0) * 6) : 0; },
myLevel() { if (!mic) { micMeter(); return 0; } mic.level = Math.max(rms(mic.an, mic.buf), mic.level * .85); return micOn && (!ptt || talking) ? Math.min(1, mic.level * 6) : 0; },
setPTT(on) { ptt = !!on; applyTracks(); }, talk(down) { talking = !!down; applyTracks(); },
get ptt() { return ptt; }, get talking() { return talking; }, get ping() { return host ? 0 : rtt == null ? null : Math.round(rtt); },
mute(id, on) { const n = (players.get(id) || {}).name; if (on) { muted.add(id); if (n) mutedNames.add(n); } else { muted.delete(id); if (n) mutedNames.delete(n); } emit("change"); },
muted: isMuted,
voiceIn, voice: id => voices.get(id),
};
}
|