unifying_electro_magnetism / Why-plotters /gravity-why-plotter-fix.html
perrabyte's picture
Upload 1494 files
f8506a2 verified
Raw History Blame Contribute Delete
40.8 kB
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>Why does this orbit do that? — Gravity sandbox</title>
<style>
:root {
--bg: #07070f; --panel: #111120; --border: #27273a; --text: #e8e8f2;
--dim: #8a8aa4; --accent: #6cf; --good: #4caf50; --bad: #ff5566;
--warn: #ffb454; --star: #ffd257; --planet: #5ea8ff; --hole: #b47aff;
}
* { box-sizing: border-box; }
body {
margin: 0; background: var(--bg); color: var(--text);
font-family: ui-sans-serif, system-ui, -apple-system, sans-serif;
font-size: 14px; line-height: 1.55;
}
header { padding: 14px 22px; border-bottom: 1px solid var(--border); }
header h1 { margin: 0 0 3px; font-size: 17px; font-weight: 600; }
header p { margin: 0; color: var(--dim); font-size: 12.5px; max-width: 960px; }
main {
display: grid; grid-template-columns: minmax(0, 1.15fr) minmax(0, 1fr);
gap: 14px; padding: 14px; max-width: 1480px; margin: 0 auto;
}
@media (max-width: 1000px) { main { grid-template-columns: 1fr; } }
.panel { background: var(--panel); border: 1px solid var(--border); border-radius: 8px; overflow: hidden; }
.panel-header {
padding: 8px 12px; border-bottom: 1px solid var(--border);
display: flex; align-items: center; justify-content: space-between;
gap: 8px; flex-wrap: wrap;
}
.panel-header h2 {
margin: 0; font-size: 11px; font-weight: 600;
text-transform: uppercase; letter-spacing: 0.07em; color: var(--dim);
}
.toolrow { display: flex; gap: 6px; align-items: center; flex-wrap: wrap; }
button, select {
background: #0d0d19; color: var(--text); border: 1px solid var(--border);
border-radius: 4px; padding: 4px 9px; font-size: 11.5px; cursor: pointer;
font-family: inherit;
}
button:hover { border-color: var(--accent); color: var(--accent); }
button.on { border-color: var(--accent); color: var(--accent); background: rgba(102,204,255,0.10); }
button:disabled { opacity: 0.4; cursor: default; }
.canvas-wrap { position: relative; background: #04040a; line-height: 0; }
canvas { display: block; width: 100%; height: auto; touch-action: none; }
#stage { cursor: crosshair; }
.badge {
position: absolute; font-family: ui-monospace, monospace; font-size: 10.5px;
color: var(--dim); background: rgba(0,0,0,0.55); padding: 3px 7px;
border-radius: 4px; pointer-events: none;
}
#coordBadge { bottom: 8px; left: 8px; }
#modeBadge { top: 8px; left: 8px; }
#modeBadge.armed { color: var(--accent); border: 1px solid rgba(102,204,255,0.4); }
.strip {
display: grid; grid-template-columns: repeat(4, minmax(0,1fr));
gap: 1px; background: var(--border); border-top: 1px solid var(--border);
}
.stat { background: var(--panel); padding: 7px 10px; }
.stat .k { font-size: 9.5px; color: var(--dim); text-transform: uppercase; letter-spacing: 0.05em; }
.stat .v { font-family: ui-monospace, monospace; font-size: 13px; color: var(--text); margin-top: 1px; }
@media (max-width: 620px) { .strip { grid-template-columns: repeat(2, minmax(0,1fr)); } }
#explanation { padding: 12px 15px; font-size: 12.5px; max-height: 560px; overflow-y: auto; }
#explanation h3 { margin: 0 0 8px; font-size: 12.5px; color: var(--accent); font-weight: 600; }
#explanation h4 { margin: 14px 0 4px; font-size: 11px; color: var(--dim); text-transform: uppercase; letter-spacing: 0.06em; }
#explanation p { margin: 7px 0; }
.verdict { padding: 7px 11px; border-radius: 4px; margin: 9px 0; font-weight: 600; font-size: 12.5px; }
.verdict.bad { background: rgba(255,85,102,0.12); color: #ff8a99; border-left: 3px solid #ff5566; }
.verdict.good { background: rgba(76,175,80,0.12); color: #8fdc92; border-left: 3px solid #4caf50; }
.verdict.warn { background: rgba(255,180,84,0.12); color: #ffcf8a; border-left: 3px solid #ffb454; }
.verdict.info { background: rgba(180,122,255,0.12); color: #d3b3ff; border-left: 3px solid #b47aff; }
#explanation table { width: 100%; border-collapse: collapse; font-family: ui-monospace, monospace; font-size: 11px; margin: 7px 0; }
#explanation th, #explanation td { text-align: left; padding: 3px 6px; border-bottom: 1px solid var(--border); }
#explanation th { color: var(--dim); font-weight: 500; }
.eq { font-family: ui-monospace, monospace; font-size: 12px; background: #0d0d19; border: 1px solid var(--border); border-radius: 4px; padding: 7px 10px; margin: 7px 0; line-height: 1.85; overflow-x: auto; }
.note { color: var(--dim); font-size: 11.5px; border-top: 1px solid var(--border); padding-top: 9px; margin-top: 13px; line-height: 1.6; }
.legend { display: flex; gap: 11px; flex-wrap: wrap; font-size: 10.5px; color: var(--dim); align-items: center; }
.legend span { display: inline-flex; align-items: center; gap: 4px; }
.swatch { width: 9px; height: 9px; border-radius: 50%; display: inline-block; }
.slider-row { display: flex; align-items: center; gap: 7px; font-size: 10.5px; color: var(--dim); }
input[type="range"] { width: 92px; accent-color: var(--accent); }
.massval { font-family: ui-monospace, monospace; color: var(--text); min-width: 30px; display: inline-block; }
</style>
</head>
<body>
<header>
<h1>Why does this orbit do that?</h1>
<p>A gravitational sandbox. Place stars, planets and black holes. Watch the field, drop test particles, and read <i>why</i> the motion is what it is — Gauss's law on a probing ring, Kepler's closed orbits, the two-frequency resonance counter, and what changes near a black hole.</p>
</header>
<main>
<div class="panel">
<div class="panel-header">
<h2>Space</h2>
<div class="toolrow">
<button id="btnStar" class="tool">+ Star</button>
<button id="btnPlanet" class="tool">+ Planet</button>
<button id="btnHole" class="tool">+ Black hole</button>
<button id="btnClear">Clear</button>
</div>
</div>
<div class="canvas-wrap">
<canvas id="stage" width="720" height="620"></canvas>
<div class="badge" id="modeBadge">select a body type, then click to place</div>
<div class="badge" id="coordBadge">—</div>
</div>
<div class="toolrow" style="padding:8px 12px; border-top:1px solid var(--border);">
<button id="btnParticle" class="tool on">+ Test particle</button>
<button id="btnPause">Pause</button>
<button id="btnReset">Reset sim</button>
<button id="btnPreset">Load: Sun + planets</button>
<button id="btnBinary">Load: binary + circumbinary</button>
<button id="btnBH">Load: black hole + star</button>
<span class="slider-row">mass <input type="range" id="massSlider" min="1" max="60" value="10"><span class="massval" id="massVal">10</span></span>
<span class="slider-row">GR <input type="range" id="grSlider" min="0" max="1" step="0.05" value="0"><span class="massval" id="grVal">0.00</span></span>
</div>
<div class="legend" style="padding:0 12px 9px;">
<span><i class="swatch" style="background:var(--star)"></i>star (source)</span>
<span><i class="swatch" style="background:var(--planet)"></i>planet (light)</span>
<span><i class="swatch" style="background:var(--hole)"></i>black hole (strong, GR)</span>
<span><i class="swatch" style="background:#ff5566"></i>traced particle</span>
<span>drag a body to move · drag empty space to pan · scroll to zoom</span>
</div>
<div class="strip">
<div class="stat"><div class="k">Flux through ring</div><div class="v" id="s-flux">—</div></div>
<div class="stat"><div class="k">Enclosed mass</div><div class="v" id="s-menc">—</div></div>
<div class="stat"><div class="k">ω_r / ω_φ</div><div class="v" id="s-ratio">—</div></div>
<div class="stat"><div class="k">predicted precession</div><div class="v" id="s-prec">—</div></div>
</div>
</div>
<div class="panel">
<div class="panel-header">
<h2>Why — local analysis at the cursor</h2>
<div class="toolrow">
<button id="btnProbe" class="on">ring probe</button>
<button id="btnField" class="on">field</button>
<button id="btnStream" class="on">streamlines</button>
<button id="btnTrace" class="on">trace orbits</button>
</div>
</div>
<div id="explanation">
<p style="color:var(--dim)">Place a body, then move the cursor over a ring to probe Gauss's law, or drop a test particle to watch its orbit.</p>
</div>
</div>
</main>
<script>
"use strict";
// ================================================================ constants
const W = 720, H = 620;
const G_CONST = 1.0;
const SOFT2 = 0.05;
const DT = 0.0012;
const SUBS = 4;
const stage = document.getElementById("stage");
const ctx = stage.getContext("2d");
const explanationEl = document.getElementById("explanation");
const coordBadge = document.getElementById("coordBadge");
const modeBadge = document.getElementById("modeBadge");
// ================================================================ state
let bodies = [];
let particles = [];
let view = { xmin: -5, xmax: 5, ymin: -4.3, ymax: 4.3 };
const HOME_VIEW = { ...view };
let placing = "star";
let placingParticle = true;
let paused = false;
let newMass = 10;
let grMode = 0;
let cursor = null;
let dragBody = null;
let dragging = false, dragStart = null;
let showProbe = true, showField = true, showStream = true, showTrace = true;
const STAR_PRESET_M = 20;
const HOLE_PRESET_M = 55;
const PLANET_PRESET_M = 1.2;
// ================================================================ presets
function loadSunSystem() {
bodies = []; particles = [];
bodies.push({ x: 0, y: 0, vx: 0, vy: 0, m: STAR_PRESET_M, type: "star" });
const Rs = [1.1, 1.8, 2.6, 3.5];
const ts = [0, 0.9, -1.8, 2.4];
Rs.forEach((r, i) => {
const v = Math.sqrt(G_CONST * STAR_PRESET_M / r);
bodies.push({
x: r * Math.cos(ts[i]), y: r * Math.sin(ts[i]),
vx: -v * Math.sin(ts[i]), vy: v * Math.cos(ts[i]),
m: PLANET_PRESET_M * (1 + 0.3 * i), type: "planet",
});
});
view = { xmin: -4.1, xmax: 4.1, ymin: -3.5, ymax: 3.5 };
dropTestParticle(2.15, 0.0, "circular");
}
function loadBinary() {
bodies = []; particles = [];
const m = STAR_PRESET_M * 0.75, d = 1.2;
const v = Math.sqrt(G_CONST * m / (2 * d));
bodies.push({ x: -d / 2, y: 0, vx: 0, vy: -v, m, type: "star" });
bodies.push({ x: d / 2, y: 0, vx: 0, vy: v, m, type: "star" });
view = { xmin: -5.5, xmax: 5.5, ymin: -4.7, ymax: 4.7 };
const r = 4.0, M = 2 * m;
const vc = Math.sqrt(G_CONST * M / r);
dropTestParticle(r, 0, null, -vc);
}
function loadBlackHole() {
bodies = []; particles = [];
bodies.push({ x: 0, y: 0, vx: 0, vy: 0, m: HOLE_PRESET_M, type: "hole" });
view = { xmin: -6, xmax: 6, ymin: -5.2, ymax: 5.2 };
const r = 4.2, vc = Math.sqrt(G_CONST * HOLE_PRESET_M / r) * 0.72;
dropTestParticle(r, 0, null, -vc);
}
// ================================================================ physics
const _acc = { ax: 0, ay: 0 };
function accelAt(x, y, out) {
let ax = 0, ay = 0;
for (const b of bodies) {
const dx = b.x - x, dy = b.y - y;
const r2 = dx * dx + dy * dy + SOFT2;
const r = Math.sqrt(r2);
let a = G_CONST * b.m / (r2 * r);
if (grMode > 0 && b.type === "hole") {
const rs = 0.35 * (b.m / HOLE_PRESET_M);
a *= (1 + grMode * 3 * rs / r);
}
ax += a * dx;
ay += a * dy;
}
out.ax = ax; out.ay = ay;
return out;
}
function accel(x, y) { return accelAt(x, y, _acc); }
function speedAt(x, y) { const a = accel(x, y); return Math.hypot(a.ax, a.ay); }
function fieldAt(x, y) { const a = accel(x, y); return { f: a.ax, g: a.ay }; }
// ================================================================ flux
function fluxThroughRing(cx, cy, R, samples = 480) {
let sum = 0;
const dL = 2 * Math.PI * R / samples;
for (let i = 0; i < samples; i++) {
const t = 2 * Math.PI * i / samples;
const nx = Math.cos(t), ny = Math.sin(t);
const F = fieldAt(cx + R * nx, cy + R * ny);
sum += (F.f * nx + F.g * ny) * dL;
}
return sum;
}
function enclosedMass(cx, cy, R) {
let M = 0;
for (const b of bodies) if (Math.hypot(b.x - cx, b.y - cy) <= R) M += b.m;
return M;
}
function totalMassInside(cx, cy, R) {
let M = 0;
for (const b of bodies) if (Math.hypot(b.x - cx, b.y - cy) <= R) M += b.m;
return M;
}
// ================================================================ integrator
function bodyAccel(i, out) {
let ax = 0, ay = 0;
const bi = bodies[i];
for (let j = 0; j < bodies.length; j++) {
if (j === i) continue;
const bj = bodies[j];
const dx = bj.x - bi.x, dy = bj.y - bi.y;
const r2 = dx * dx + dy * dy + SOFT2;
const r = Math.sqrt(r2);
let a = G_CONST * bj.m / (r2 * r);
if (grMode > 0 && bj.type === "hole") {
const rs = 0.35 * (bj.m / HOLE_PRESET_M);
a *= (1 + grMode * 3 * rs / r);
}
ax += a * dx;
ay += a * dy;
}
out.ax = ax; out.ay = ay;
return out;
}
const _ba1 = { ax: 0, ay: 0 }, _ba2 = { ax: 0, ay: 0 };
function stepBodies() {
const n = bodies.length;
if (n === 0) return;
// KDK leapfrog: kick(dt/2) -> drift(dt) -> kick(dt/2)
for (let i = 0; i < n; i++) {
bodyAccel(i, _ba1);
bodies[i].vx += _ba1.ax * DT * 0.5;
bodies[i].vy += _ba1.ay * DT * 0.5;
bodies[i].x += bodies[i].vx * DT;
bodies[i].y += bodies[i].vy * DT;
}
for (let i = n - 1; i >= 0; i--) {
if (!bodies[i]) continue;
bodyAccel(i, _ba2);
bodies[i].vx += _ba2.ax * DT * 0.5;
bodies[i].vy += _ba2.ay * DT * 0.5;
// safety: never let NaN poison the whole system
if (!isFinite(bodies[i].x) || !isFinite(bodies[i].y) ||
!isFinite(bodies[i].vx) || !isFinite(bodies[i].vy)) {
bodies.splice(i, 1);
continue;
}
// clamp runaway velocity
const sp = Math.hypot(bodies[i].vx, bodies[i].vy);
if (sp > 80) {
bodies[i].vx *= 80 / sp;
bodies[i].vy *= 80 / sp;
}
}
}
function stepParticles() {
for (const p of particles) {
let a = accel(p.x, p.y);
p.vx += a.ax * DT * 0.5; p.vy += a.ay * DT * 0.5;
p.x += p.vx * DT; p.y += p.vy * DT;
a = accel(p.x, p.y);
p.vx += a.ax * DT * 0.5; p.vy += a.ay * DT * 0.5;
if (!isFinite(p.x) || !isFinite(p.y)) { p.dead = true; continue; }
const sp = Math.hypot(p.vx, p.vy);
if (sp > 120) { p.vx *= 120 / sp; p.vy *= 120 / sp; }
p.trail.push([p.x, p.y]);
if (p.trail.length > 1400) p.trail.shift();
const host = heaviestBody();
if (host) {
const dx = p.x - host.x, dy = p.y - host.y;
const r = Math.hypot(dx, dy);
const th = Math.atan2(dy, dx);
if (p.prevTheta === undefined) { p.prevTheta = th; p.prevR = r; }
let dth = th - p.prevTheta;
while (dth > Math.PI) dth -= 2 * Math.PI;
while (dth < -Math.PI) dth += 2 * Math.PI;
p.angleTotal = (p.angleTotal || 0) + dth;
p.prevTheta = th;
p.phiCycles = Math.abs(p.angleTotal) / (2 * Math.PI);
const drdt = r - p.prevR;
if (p.lastDrdt !== undefined && Math.sign(drdt) !== Math.sign(p.lastDrdt)) {
p.radialTurns = (p.radialTurns || 0) + 1;
}
p.lastDrdt = drdt;
p.prevR = r;
p.radialCycles = (p.radialTurns || 0) / 2;
p.radius = r;
if (r > p.far) p.far = r;
if (r < p.near) p.near = r;
}
}
particles = particles.filter(p => !p.dead && Math.hypot(p.x, p.y) < 60);
}
function heaviestBody() {
let best = null;
for (const b of bodies) if (!best || b.m > best.m) best = b;
return best;
}
function dropTestParticle(x, y, kind, vyOverride) {
const host = heaviestBody();
let vx = 0, vy = 0;
if (host) {
const dx = x - host.x, dy = y - host.y;
const r = Math.hypot(dx, dy) + 1e-9;
const Menc = totalMassInside(host.x, host.y, r);
const vc = Math.sqrt(G_CONST * Math.max(Menc, 1e-9) / r);
vx = -dy / r * vc; vy = dx / r * vc;
}
if (vyOverride !== undefined && vyOverride !== null) vy = vyOverride;
particles.push({
x, y, vx, vy, trail: [[x, y]],
near: Infinity, far: 0,
radialTurns: 0, angleTotal: 0,
});
}
// ================================================================ drawing
function toPx(x, y) {
return {
sx: (x - view.xmin) / (view.xmax - view.xmin) * W,
sy: (view.ymax - y) / (view.ymax - view.ymin) * H,
};
}
function toWorld(sx, sy) {
return {
x: view.xmin + (sx / W) * (view.xmax - view.xmin),
y: view.ymax - (sy / H) * (view.ymax - view.ymin),
};
}
const PAL = [
[8, 8, 20], [14, 20, 48], [26, 44, 96], [48, 84, 160],
[92, 140, 220], [170, 208, 255], [255, 255, 255],
[255, 236, 170], [255, 190, 90], [240, 120, 30], [170, 40, 10],
];
function lerp(a, b, t) { return a + (b - a) * t; }
function palColor(u) {
u = Math.max(0, Math.min(1, u));
const n = PAL.length - 1, x = u * n, i = Math.floor(x), f = x - i;
const c0 = PAL[i], c1 = PAL[Math.min(n, i + 1)];
return [Math.round(lerp(c0[0], c1[0], f)), Math.round(lerp(c0[1], c1[1], f)), Math.round(lerp(c0[2], c1[2], f))];
}
function bodyRadius(b) {
if (b.type === "hole") return 7 + Math.sqrt(b.m) * 0.55;
if (b.type === "star") return 5 + Math.sqrt(b.m) * 0.55;
return 3.2 + Math.sqrt(b.m) * 0.7;
}
function bodyColor(b) {
if (b.type === "hole") return "#b47aff";
if (b.type === "star") return "#ffd257";
return "#5ea8ff";
}
// reusable offscreen buffer for the field layer (avoids per-frame alloc)
const offCanvas = document.createElement("canvas");
offCanvas.width = W; offCanvas.height = H;
const offCtx = offCanvas.getContext("2d");
function drawFieldLayer() {
const img = offCtx.createImageData(W, H);
const data = img.data;
let maxA = 0;
const N = 40;
for (let i = 0; i <= N; i++) for (let j = 0; j <= N; j++) {
const w = toWorld(i / N * W, j / N * H);
const s = speedAt(w.x, w.y);
if (isFinite(s) && s > maxA) maxA = s;
}
if (maxA === 0) maxA = 1;
const lmax = Math.log(1 + maxA);
const step = 4;
for (let py = 0; py < H; py += step) {
for (let px = 0; px < W; px += step) {
const w = toWorld(px, py);
const s = speedAt(w.x, w.y);
const u = isFinite(s) ? Math.log(1 + s) / lmax : 0;
const c = palColor(u * 0.85);
for (let dy = 0; dy < step && py + dy < H; dy++) {
for (let dx = 0; dx < step && px + dx < W; dx++) {
const idx = ((py + dy) * W + px + dx) * 4;
data[idx] = c[0]; data[idx + 1] = c[1]; data[idx + 2] = c[2]; data[idx + 3] = 255;
}
}
}
}
offCtx.putImageData(img, 0, 0);
ctx.drawImage(offCanvas, 0, 0);
}
function drawGlyphs() {
const n = 26;
const cell = Math.min(W / n, H / n);
const cols = Math.ceil(W / cell), rows = Math.ceil(H / cell);
const maxLen = cell * 0.8;
let amax = 1e-9;
const cells = [];
for (let i = 0; i < cols; i++) for (let j = 0; j < rows; j++) {
const sx = (i + 0.5) * cell, sy = (j + 0.5) * cell;
const w = toWorld(sx, sy);
const F = fieldAt(w.x, w.y);
const m = Math.hypot(F.f, F.g);
cells.push({ sx, sy, F, m });
if (isFinite(m) && m > amax) amax = m;
}
for (const c of cells) {
if (!isFinite(c.m) || c.m < 1e-7) continue;
const ang = Math.atan2(c.F.g, c.F.f);
const u = Math.pow(c.m / amax, 0.32);
const L = maxLen * u;
const ux = Math.cos(ang), uy = -Math.sin(ang);
const x0 = c.sx - ux * L * 0.5, y0 = c.sy - uy * L * 0.5;
const x1 = c.sx + ux * L * 0.5, y1 = c.sy + uy * L * 0.5;
let hue = ang * 180 / Math.PI; if (hue < 0) hue += 360;
const light = 32 + 40 * u, sat = 65 + 25 * u;
ctx.strokeStyle = `hsla(${hue}, ${sat}%, ${light}%, 0.85)`;
ctx.fillStyle = ctx.strokeStyle;
ctx.lineWidth = 1.2;
const dx = x1 - x0, dy = y1 - y0, len = Math.hypot(dx, dy);
if (len < 2) continue;
const vx = dx / len, vy = dy / len;
const head = Math.min(6, 2.4 + len * 0.22);
ctx.beginPath(); ctx.moveTo(x0, y0); ctx.lineTo(x1 - vx * head * 0.7, y1 - vy * head * 0.7); ctx.stroke();
ctx.beginPath();
ctx.moveTo(x1, y1);
ctx.lineTo(x1 - vx * head - vy * head * 0.5, y1 - vy * head + vx * head * 0.5);
ctx.lineTo(x1 - vx * head + vy * head * 0.5, y1 - vy * head - vx * head * 0.5);
ctx.closePath(); ctx.fill();
}
}
function traceStreamline(x0, y0, dir, color) {
let x = x0, y = y0;
const pts = [];
for (let i = 0; i < 240; i++) {
const a = accel(x, y);
const m = Math.hypot(a.ax, a.ay);
if (!isFinite(m) || m < 1e-9) break;
const stepLen = 0.04;
x += (a.ax / m) * stepLen * dir;
y += (a.ay / m) * stepLen * dir;
pts.push(toPx(x, y));
if (x < view.xmin - 1 || x > view.xmax + 1 || y < view.ymin - 1 || y > view.ymax + 1) break;
}
if (pts.length < 2) return;
ctx.strokeStyle = color; ctx.lineWidth = 1.2;
ctx.beginPath(); ctx.moveTo(pts[0].sx, pts[0].sy);
for (let i = 1; i < pts.length; i++) ctx.lineTo(pts[i].sx, pts[i].sy);
ctx.stroke();
}
function drawBodies() {
for (const b of bodies) {
const p = toPx(b.x, b.y);
const R = bodyRadius(b);
const col = bodyColor(b);
if (b.type === "hole") {
const g = ctx.createRadialGradient(p.sx, p.sy, R * 0.4, p.sx, p.sy, R * 3.2);
g.addColorStop(0, "rgba(180,122,255,0.55)");
g.addColorStop(1, "rgba(180,122,255,0)");
ctx.fillStyle = g;
ctx.beginPath(); ctx.arc(p.sx, p.sy, R * 3.2, 0, 2 * Math.PI); ctx.fill();
ctx.fillStyle = "#0a0612";
ctx.beginPath(); ctx.arc(p.sx, p.sy, R, 0, 2 * Math.PI); ctx.fill();
ctx.strokeStyle = col; ctx.lineWidth = 2;
ctx.beginPath(); ctx.arc(p.sx, p.sy, R, 0, 2 * Math.PI); ctx.stroke();
ctx.strokeStyle = "rgba(180,122,255,0.35)"; ctx.lineWidth = 1;
ctx.beginPath(); ctx.arc(p.sx, p.sy, R * 1.55, 0, 2 * Math.PI); ctx.stroke();
} else {
if (b.type === "star") {
const g = ctx.createRadialGradient(p.sx, p.sy, R * 0.3, p.sx, p.sy, R * 3.5);
g.addColorStop(0, "rgba(255,210,87,0.55)");
g.addColorStop(1, "rgba(255,160,40,0)");
ctx.fillStyle = g;
ctx.beginPath(); ctx.arc(p.sx, p.sy, R * 3.5, 0, 2 * Math.PI); ctx.fill();
}
ctx.fillStyle = col;
ctx.beginPath(); ctx.arc(p.sx, p.sy, R, 0, 2 * Math.PI); ctx.fill();
ctx.strokeStyle = "rgba(255,255,255,0.55)"; ctx.lineWidth = 1;
ctx.stroke();
}
ctx.fillStyle = "rgba(255,255,255,0.6)";
ctx.font = "9.5px ui-monospace, monospace";
ctx.fillText("m=" + b.m.toFixed(1), p.sx + R + 4, p.sy + 3);
}
}
function drawParticles() {
for (const p of particles) {
const tr = p.trail;
if (tr.length > 1) {
ctx.strokeStyle = "rgba(255,85,102,0.75)";
ctx.lineWidth = 1.3;
ctx.beginPath();
const s0 = toPx(tr[0][0], tr[0][1]);
ctx.moveTo(s0.sx, s0.sy);
for (let i = 1; i < tr.length; i++) {
const s = toPx(tr[i][0], tr[i][1]);
ctx.lineTo(s.sx, s.sy);
}
ctx.stroke();
}
const s = toPx(p.x, p.y);
const sp = Math.hypot(p.vx, p.vy);
if (sp > 1e-6) {
const ux = p.vx / sp, uy = -p.vy / sp;
const L = 12 + 8 * Math.log(1 + sp);
ctx.strokeStyle = "#ff8a99"; ctx.lineWidth = 1.6;
ctx.beginPath(); ctx.moveTo(s.sx, s.sy); ctx.lineTo(s.sx + ux * L, s.sy + uy * L); ctx.stroke();
}
ctx.fillStyle = "#ff5566";
ctx.beginPath(); ctx.arc(s.sx, s.sy, 3.4, 0, 2 * Math.PI); ctx.fill();
ctx.strokeStyle = "#fff"; ctx.lineWidth = 1; ctx.stroke();
}
}
function drawRingProbe(cx, cy, R) {
const p = toPx(cx, cy);
const rpx = R / (view.xmax - view.xmin) * W;
ctx.strokeStyle = "rgba(108,204,255,0.55)";
ctx.lineWidth = 1.4;
ctx.setLineDash([6, 5]);
ctx.beginPath(); ctx.arc(p.sx, p.sy, rpx, 0, 2 * Math.PI); ctx.stroke();
ctx.setLineDash([]);
const samples = 40;
let fluxSum = 0;
const dL = 2 * Math.PI * R / samples;
let maxN = 1e-9;
const vals = [];
for (let i = 0; i < samples; i++) {
const t = 2 * Math.PI * i / samples;
const nx = Math.cos(t), ny = Math.sin(t);
const x = cx + R * nx, y = cy + R * ny;
const F = fieldAt(x, y);
const ncomp = F.f * nx + F.g * ny;
fluxSum += ncomp * dL;
vals.push({ nx, ny, ncomp });
if (Math.abs(ncomp) > maxN) maxN = Math.abs(ncomp);
}
const Menc = enclosedMass(cx, cy, R);
const predicted = -2 * Math.PI * G_CONST * Menc;
const consistent = Math.abs(fluxSum - predicted) < 0.3 * Math.max(1, Math.abs(predicted));
for (const v of vals) {
const x = cx + R * v.nx, y = cy + R * v.ny;
const q = toPx(x, y);
const u = Math.abs(v.ncomp) / maxN;
const L = 4 + 13 * u;
const inward = v.ncomp < 0;
const ux = inward ? -v.nx : v.nx;
const uy = inward ? -v.ny : v.ny;
ctx.strokeStyle = inward ? "rgba(108,204,255,0.85)" : "rgba(76,175,80,0.9)";
ctx.fillStyle = ctx.strokeStyle;
ctx.lineWidth = 1.3;
ctx.beginPath();
ctx.moveTo(q.sx, q.sy);
ctx.lineTo(q.sx + ux * L, q.sy - uy * L);
ctx.stroke();
const hx = q.sx + ux * L, hy = q.sy - uy * L;
ctx.beginPath();
ctx.moveTo(hx, hy);
ctx.lineTo(hx - ux * 3 - uy * 2, hy + uy * 3 - ux * 2);
ctx.lineTo(hx - ux * 3 + uy * 2, hy + uy * 3 + ux * 2);
ctx.closePath(); ctx.fill();
}
ctx.fillStyle = "#6cf";
ctx.beginPath(); ctx.arc(p.sx, p.sy, 2.6, 0, 2 * Math.PI); ctx.fill();
return { flux: fluxSum, Menc, predicted, consistent, R, cx, cy };
}
// ================================================================ render
let lastProbe = null;
function render() {
ctx.fillStyle = "#04040a";
ctx.fillRect(0, 0, W, H);
if (showField) { drawFieldLayer(); drawGlyphs(); }
if (showStream && cursor) {
traceStreamline(cursor.x, cursor.y, 1, "rgba(108,204,255,0.28)");
traceStreamline(cursor.x, cursor.y, -1, "rgba(108,204,255,0.16)");
}
drawBodies();
if (showTrace) drawParticles();
if (showProbe && cursor) {
const host = heaviestBody();
if (host) {
const R = Math.hypot(cursor.x - host.x, cursor.y - host.y);
if (R > 0.15) lastProbe = drawRingProbe(host.x, host.y, R);
else lastProbe = null;
}
const c = toPx(cursor.x, cursor.y);
ctx.strokeStyle = "rgba(255,255,255,0.75)";
ctx.lineWidth = 1;
ctx.beginPath();
ctx.moveTo(c.sx - 12, c.sy); ctx.lineTo(c.sx - 4, c.sy);
ctx.moveTo(c.sx + 4, c.sy); ctx.lineTo(c.sx + 12, c.sy);
ctx.moveTo(c.sx, c.sy - 12); ctx.lineTo(c.sx, c.sy - 4);
ctx.moveTo(c.sx, c.sy + 4); ctx.lineTo(c.sx, c.sy + 12);
ctx.stroke();
}
}
// ================================================================ explanation
function fmt(x, d = 3) {
if (!isFinite(x)) return "∞";
if (Math.abs(x) < 1e-10) return "0";
if (Math.abs(x) >= 1e4 || Math.abs(x) < 1e-3) return x.toExponential(2);
return x.toFixed(d);
}
function buildExplanation() {
let html = "";
// ---- part 1: local field at cursor
if (cursor) {
const F = fieldAt(cursor.x, cursor.y);
const mag = Math.hypot(F.f, F.g);
const ang = Math.atan2(F.g, F.f) * 180 / Math.PI;
html += `<h4>At the cursor (${fmt(cursor.x, 2)}, ${fmt(cursor.y, 2)})</h4>`;
html += `<p>Acceleration <b>g = (${fmt(F.f, 3)}, ${fmt(F.g, 3)})</b>, magnitude <b>${fmt(mag, 3)}</b>, pointing ${ang.toFixed(1)}°.</p>`;
if (mag > 1e-9 && bodies.length) {
let best = null, bestD = Infinity;
for (const b of bodies) {
const d = Math.hypot(b.x - cursor.x, b.y - cursor.y);
if (d < bestD) { bestD = d; best = b; }
}
if (best && bestD > 0.05) {
const pred = G_CONST * best.m / (bestD * bestD);
const ratio = mag / pred;
let phrase;
if (ratio > 1.03) phrase = "the <i>other</i> bodies add to the pull here, so the field is stronger than one mass predicts.";
else if (ratio < 0.97) phrase = "other bodies pull the other way, reducing the net force.";
else phrase = "close to a single-mass field; other bodies roughly cancel here.";
html += `<p>The nearest body (m = ${fmt(best.m, 2)}, ${fmt(bestD, 3)} away) alone would give ${fmt(pred, 3)}. The actual value is <b>${fmt(ratio, 3)}×</b> that — ${phrase}</p>`;
}
}
html += `<div class="eq">g(r) = Σ G mᵢ (rᵢ − r) / |rᵢ − r|³</div>`;
} else {
html += `<p style="color:var(--dim)">Move the cursor over the space to inspect the field.</p>`;
}
// ---- part 2: Gauss law ring probe
if (lastProbe) {
const P = lastProbe;
html += `<h4>Gauss's law on the ring you drew</h4>`;
html += `<p>Ring of radius R = ${fmt(P.R, 3)} around the dominant mass.</p>`;
html += `<div class="verdict ${P.consistent ? "good" : "warn"}">Outward flux Φ = ${fmt(P.flux, 3)} &nbsp;vs&nbsp; −2πG·M<sub>enc</sub> = ${fmt(P.predicted, 3)} — ${P.consistent ? "consistent with Gauss's law" : "differing (mass outside the ring, or softening)"}</div>`;
html += `<p><b>M<sub>enc</sub></b> = ${fmt(P.Menc, 3)} (total mass strictly inside the ring). The cyan arrows on the ring are the inward normal component of the field; the green ones would be outward. Their integral is the flux.</p>`;
html += `<p>Notice: if you grow the ring through empty space, <b>Φ stays constant</b> — that is the 2D Gauss law, and it is the reason the <i>field</i> falls like 1/r while the <i>flux</i> does not fall at all. In 3D the same argument gives 1/r². The inverse-square law is not an extra assumption; it is what “flux is conserved” forces.</p>`;
} else if (cursor) {
html += `<h4>Gauss's law</h4><p style="color:var(--dim)">Move the cursor between 0.2 and a few units from a mass to draw the flux ring.</p>`;
}
// ---- part 3: the strongest particle's resonance counter
let p = null;
for (const q of particles) if (!p || q.trail.length > p.trail.length) p = q;
if (p && p.phiCycles > 0.12) {
const ratio = p.radialCycles / p.phiCycles;
const closed = ratio > 0.97 && ratio < 1.03;
html += `<h4>The orbit's two clocks (resonance counter)</h4>`;
html += `<p>This particle has completed <b>${fmt(p.phiCycles, 2)}</b> angular cycles and <b>${fmt(p.radialCycles, 2)}</b> radial cycles since it was dropped.</p>`;
html += `<table>
<tr><th>quantity</th><th>value</th><th>meaning</th></tr>
<tr><td>ω_φ cycles</td><td>${fmt(p.phiCycles, 3)}</td><td>angle wound around the host</td></tr>
<tr><td>ω_r cycles</td><td>${fmt(p.radialCycles, 3)}</td><td>radial in/out cycles</td></tr>
<tr><td>ratio ω_r/ω_φ</td><td><b>${fmt(ratio, 4)}</b></td><td>${closed ? "1:1 — orbit is CLOSED (Kepler degeneracy)" : "≠1 — orbit precesses into a rosette"}</td></tr>
<tr><td>periapsis</td><td>${fmt(p.near, 3)}</td><td>closest approach</td></tr>
<tr><td>apoapsis</td><td>${fmt(p.far, 3)}</td><td>farthest point</td></tr>
</table>`;
html += `<div class="verdict ${closed ? "good" : "info"}">${closed
? "The two frequencies lock at exactly 1:1 — this is the hidden symmetry (the Runge–Lenz vector) that makes Kepler orbits close."
: "ω_r ≠ ω_φ, so the ellipse's axis rotates a little each turn — this is orbital precession, the same effect seen as Mercury's perihelion advance."}</div>`;
html += `<p><b>Why 1:1 is special.</b> For a pure 1/r² force, the radial and angular clocks tick at the same rate — an accident of the force law that gives a conserved Runge–Lenz vector (a hidden extra symmetry). Break it — add GR near a black hole, or a third body — and the ratio drifts from 1. That drift <i>is</i> precession. In this sim, push the <code>GR</code> slider up with a black hole present and watch the ratio move away from 1.</p>`;
}
// ---- part 4: system resonance note
if (particles.length && bodies.length > 1) {
html += `<h4>Is this system resonantly stable?</h4>`;
if (bodies.length === 2) {
const m1 = bodies[0].m, m2 = bodies[1].m;
const ratioM = Math.max(m1, m2) / Math.max(1e-9, Math.min(m1, m2));
html += `<p>Two-body system with mass ratio ${fmt(ratioM, 2)}. A two-body orbit has only one meaningful clock pair, so its ω_r/ω_φ is fixed by geometry: 1:1 for the pure 1/r² law. There is no internal resonance to lock or unlock until you add a third body.</p>`;
} else {
html += `<p>You have ${bodies.length} massive bodies. Mean-motion resonances occur when orbital periods form simple integer ratios. Watch the ratio in the table above after you load the <i>binary</i> preset — the circumbinary particle's ratio wanders depending on how near it sits to a lock.</p>`;
}
}
html += `<div class="note"><b>What this sim does and does not model.</b> It solves Newtonian N-body gravity with a softening length (so forces stay finite at the centre of a mass). The "GR" slider is a <i>cartoon</i>: it adds a small 1/r³ extra attraction near black holes, which produces the right qualitative perihelion advance, not the exact Schwarzschild value — real GR gives a perihelion shift of 6πGM/(c²a(1−e²)) per orbit. Nothing here integrates null geodesics or the black-hole shadow.</div>`;
return html;
}
function updateReadout() {
if (lastProbe) {
document.getElementById("s-flux").textContent = fmt(lastProbe.flux, 3);
document.getElementById("s-menc").textContent = fmt(lastProbe.Menc, 3);
} else {
document.getElementById("s-flux").textContent = "—";
document.getElementById("s-menc").textContent = "—";
}
let p = null;
for (const q of particles) if (!p || q.trail.length > p.trail.length) p = q;
if (p && p.phiCycles > 0.12) {
const ratio = p.radialCycles / p.phiCycles;
const drift = Math.abs(1 - ratio);
document.getElementById("s-ratio").textContent = fmt(ratio, 4);
document.getElementById("s-prec").textContent = drift < 0.02 ? "none" : (drift * 360).toFixed(1) + "° / orbit";
} else {
document.getElementById("s-ratio").textContent = "—";
document.getElementById("s-prec").textContent = "—";
}
}
// ================================================================ interaction
function mouseWorld(e) {
const rect = stage.getBoundingClientRect();
const sx = (e.clientX - rect.left) / rect.width * W;
const sy = (e.clientY - rect.top) / rect.height * H;
return { w: toWorld(sx, sy), sx, sy, rect };
}
stage.addEventListener("mousemove", (e) => {
const m = mouseWorld(e);
const w = m.w;
if (dragBody) {
dragBody.x = w.x; dragBody.y = w.y;
return;
}
if (dragging) {
const dx = (e.clientX - dragStart.x) / m.rect.width * (dragStart.view.xmax - dragStart.view.xmin);
const dy = (e.clientY - dragStart.y) / m.rect.height * (dragStart.view.ymax - dragStart.view.ymin);
view.xmin = dragStart.view.xmin - dx;
view.xmax = dragStart.view.xmax - dx;
view.ymin = dragStart.view.ymin + dy;
view.ymax = dragStart.view.ymax + dy;
return;
}
cursor = w;
coordBadge.textContent = `(${w.x.toFixed(3)}, ${w.y.toFixed(3)})`;
explanationEl.innerHTML = buildExplanation();
updateReadout();
});
stage.addEventListener("mouseleave", () => { cursor = null; });
stage.addEventListener("mousedown", (e) => {
const m = mouseWorld(e);
const { w, sx, sy } = m;
let grabbed = null;
for (const b of bodies) {
const p = toPx(b.x, b.y);
if (Math.hypot(p.sx - sx, p.sy - sy) < bodyRadius(b) + 8) { grabbed = b; break; }
}
if (grabbed) { dragBody = grabbed; return; }
if (placingParticle) {
dropTestParticle(w.x, w.y, null);
explanationEl.innerHTML = buildExplanation();
} else {
let mm = newMass;
if (placing === "star") mm = Math.max(4, newMass * 1.6);
if (placing === "planet") mm = Math.max(0.4, newMass * 0.12);
if (placing === "hole") mm = Math.max(20, newMass * 4.2);
const b = { x: w.x, y: w.y, vx: 0, vy: 0, m: mm, type: placing };
const host = heaviestBody();
if (host && (host.x !== w.x || host.y !== w.y)) {
const dx = w.x - host.x, dy = w.y - host.y, r = Math.hypot(dx, dy);
const Menc = totalMassInside(host.x, host.y, r);
const vc = Math.sqrt(G_CONST * Math.max(Menc, 1e-9) / Math.max(r, 0.2));
b.vx = -dy / r * vc; b.vy = dx / r * vc;
}
bodies.push(b);
explanationEl.innerHTML = buildExplanation();
}
});
stage.addEventListener("mouseup", () => { dragBody = null; dragging = false; });
window.addEventListener("mouseup", () => { dragBody = null; dragging = false; });
stage.addEventListener("dblclick", () => {
view = { ...HOME_VIEW };
});
stage.addEventListener("wheel", (e) => {
e.preventDefault();
const rect = stage.getBoundingClientRect();
const pxFrac = (e.clientX - rect.left) / rect.width;
const pyFrac = (e.clientY - rect.top) / rect.height;
const cx = view.xmin + pxFrac * (view.xmax - view.xmin);
const cy = view.ymax - pyFrac * (view.ymax - view.ymin);
const factor = e.deltaY < 0 ? 0.82 : 1.22;
const nw = (view.xmax - view.xmin) * factor;
const nh = (view.ymax - view.ymin) * factor;
view.xmin = cx - pxFrac * nw; view.xmax = view.xmin + nw;
view.ymax = cy + pyFrac * nh; view.ymin = view.ymax - nh;
}, { passive: false });
// start a pan when clicking empty space with the particle tool off
stage.addEventListener("mousedown", (e) => {
const m = mouseWorld(e);
let overBody = false;
for (const b of bodies) {
const p = toPx(b.x, b.y);
if (Math.hypot(p.sx - m.sx, p.sy - m.sy) < bodyRadius(b) + 8) { overBody = true; break; }
}
if (!overBody && !placingParticle) {
dragging = true;
dragStart = { x: e.clientX, y: e.clientY, view: { ...view } };
}
});
// ================================================================ tools
function selectTool(which) {
placingParticle = (which === "particle");
if (!placingParticle) placing = which;
document.getElementById("btnStar").classList.toggle("on", which === "star");
document.getElementById("btnPlanet").classList.toggle("on", which === "planet");
document.getElementById("btnHole").classList.toggle("on", which === "hole");
document.getElementById("btnParticle").classList.toggle("on", which === "particle");
modeBadge.textContent = placingParticle ? "click to drop a test particle" : "click to place a " + which;
modeBadge.classList.add("armed");
}
document.getElementById("btnStar").addEventListener("click", () => selectTool("star"));
document.getElementById("btnPlanet").addEventListener("click", () => selectTool("planet"));
document.getElementById("btnHole").addEventListener("click", () => selectTool("hole"));
document.getElementById("btnParticle").addEventListener("click", () => selectTool("particle"));
document.getElementById("btnClear").addEventListener("click", () => {
bodies = []; particles = [];
lastProbe = null;
explanationEl.innerHTML = '<p style="color:var(--dim)">Cleared. Place a body to begin.</p>';
});
document.getElementById("btnPause").addEventListener("click", (e) => {
paused = !paused;
e.target.textContent = paused ? "Resume" : "Pause";
e.target.classList.toggle("on", paused);
});
document.getElementById("btnReset").addEventListener("click", () => {
particles = [];
const host = heaviestBody();
if (host) dropTestParticle(host.x + 2.2, host.y, null);
});
document.getElementById("btnPreset").addEventListener("click", () => { loadSunSystem(); lastProbe = null; });
document.getElementById("btnBinary").addEventListener("click", () => { loadBinary(); lastProbe = null; });
document.getElementById("btnBH").addEventListener("click", () => { loadBlackHole(); lastProbe = null; });
document.getElementById("massSlider").addEventListener("input", (e) => {
newMass = Number(e.target.value);
document.getElementById("massVal").textContent = e.target.value;
});
document.getElementById("grSlider").addEventListener("input", (e) => {
grMode = Number(e.target.value);
document.getElementById("grVal").textContent = grMode.toFixed(2);
});
document.getElementById("btnProbe").addEventListener("click", (e) => {
showProbe = !showProbe; e.target.classList.toggle("on", showProbe);
});
document.getElementById("btnField").addEventListener("click", (e) => {
showField = !showField; e.target.classList.toggle("on", showField);
});
document.getElementById("btnStream").addEventListener("click", (e) => {
showStream = !showStream; e.target.classList.toggle("on", showStream);
});
document.getElementById("btnTrace").addEventListener("click", (e) => {
showTrace = !showTrace; e.target.classList.toggle("on", showTrace);
});
// ================================================================ main loop
function loop() {
if (!paused) {
for (let s = 0; s < SUBS; s++) { stepBodies(); stepParticles(); }
}
render();
if (cursor) {
explanationEl.innerHTML = buildExplanation();
}
updateReadout();
requestAnimationFrame(loop);
}
// ================================================================ init
loadSunSystem();
selectTool("particle");
requestAnimationFrame(loop);
</script>
</body>
</html>