The Valley as the landing page: dragons first, routes on demand

- New tab order: The Valley, The Odds, The Dragons, Deep Dive, Data & Methods
  (Route Flow and Blue & Black fold into Deep Dive; methods into Data &
  Methods; old #links redirect).
- explorer.js replaces the trails map and the route planner, with progressive
  disclosure: the painted valley shows landmarks and the dragons where riders
  meet them (faint = rarely met), no routes and no deaths; hover for a note;
  choose a dragon to draw every route to every place it can be bonded, with
  width = chance of still being on the route, and solid / dashed / dotted and
  opacity for how a route compares with the best; click a choice point to
  branch off and re-plan; "Why this route?" holds intervals and risks; a
  toggle shows the community's actual traffic; #valley/blue/meadow-Blue links.
- dragons.js: original dragon silhouettes in six poses, built from simple
  parts.
- Solver: route to one specific encounter (only: [...]); ENCOUNTERS per
  colour, including the Greens rescue for Orange and Brown.
- The Odds rewritten for all six dragons, ranked easiest to hardest.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01UCzTd31GphpMXDhQqWrCMQ
This commit is contained in:
ekcSchiano
2026-11-02 14:24:47 +00:00
co-authored by Claude Opus 5.5
parent bdf66afabc
commit de80e99c74
9 changed files with 1009 additions and 519 deletions
+504
View File
@@ -0,0 +1,504 @@
/* explorer.js — The Valley: the landing page.
*
* Progressive disclosure, in four levels:
* 0 the painted valley, its landmarks, and the dragons where riders meet them (faint = rarely met). No routes.
* 1 hover or focus a dragon or landmark: a short note (riders who met it, bond chance there).
* 2 choose a dragon: every route to every place that dragon can be bonded, drawn at once. Line width = chance you
* are still on the route at that point (it narrows at every roll of the dice and every risk); the better route
* is solid and opaque, weaker ones fade and turn dashed, then dotted.
* 3 click a choice point on the highlighted route: its other options branch off, each with the chance it gives.
* Picking one re-plans the route from there.
* 4 "Why this route?" in the side panel: intervals, how often the choice stays best, low-bias numbers, risks.
* A toggle adds the community's actual traffic underneath. The URL keeps the selection (#valley/blue/meadow-Blue).
*/
(function () {
"use strict";
const S = window.ThreshSolver, V = window.ValleyMap, D = window.DragonArt;
if (!S || !V || !D) return;
const $ = (q, el = document) => el.querySelector(q);
const $$ = (q, el = document) => [...el.querySelectorAll(q)];
const NS = "http://www.w3.org/2000/svg";
const esc = (x) => String(x ?? "").replace(/[&<>"]/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;" }[c]));
const pct = (p) => (p == null || isNaN(p) ? "–" : p === 0 ? "0%" : p < 0.001 ? "<0.1%" : (p * 100).toFixed(p < 0.1 ? 1 : 0) + "%");
const L = V.places, INK = V.INK, PAPER = V.PAPER;
const DV = { Red: "--dr-red", Green: "--dr-green", Orange: "--dr-orange", Brown: "--dr-brown", Blue: "--dr-blue", Black: "--dr-black" };
const COLOURS = ["Red", "Orange", "Brown", "Green", "Blue", "Black"];
const GATE = { x: 500, y: 770, name: "The entrance" };
function el(tag, attrs = {}, parent) {
const e = document.createElementNS(NS, tag);
for (const [k, v] of Object.entries(attrs)) if (v !== null && v !== undefined) e.setAttribute(k, v);
if (parent) parent.appendChild(e);
return e;
}
/* ---------- the cast: where each dragon is met, in what pose ---------- */
const ENC_NAME = {
"valley-Red": "The valley Red", "tree-Red": "The Red below the tree", "tree-Greens": "The two Greens",
"meadow-Orange": "The meadow Orange", "meadow-Brown": "The meadow Brown", "meadow-Blue": "The meadow Blue",
"shadow-Blue": "The Blue at the redwood", "shadow-Black": "The Black (the shadow)",
};
const RESCUE = { Orange: "tree-Greens", Brown: "tree-Greens" };
const SPOTS = [
{ place: "treeRed", enc: "tree-Red", colour: "Red", pose: "prowling", flip: true, sc: 0.36 },
{ place: "greens", enc: "tree-Greens", colour: "Green", pose: "resting", sc: 0.3, dx: -16 },
{ place: "greens", enc: "tree-Greens", colour: "Green", pose: "sitting", flip: true, sc: 0.27, dx: 20, dy: -4, twin: true },
{ place: "black", enc: "shadow-Black", colour: "Black", pose: "flying", flip: true, sc: 0.38 },
{ place: "redwood", enc: "shadow-Blue", colour: "Blue", pose: "coiled", sc: 0.3 },
{ place: "valleyRed", enc: "valley-Red", colour: "Red", pose: "roaring", sc: 0.36, dy: -12 },
{ place: "meadow:Orange", enc: "meadow-Orange", colour: "Orange", pose: "sitting", flip: true, sc: 0.3 },
{ place: "meadow:Brown", enc: "meadow-Brown", colour: "Brown", pose: "resting", sc: 0.32 },
{ place: "meadow:Blue", enc: "meadow-Blue", colour: "Blue", pose: "sitting", sc: 0.32 },
];
const FIRST_POSE = { Red: "roaring", Brown: "sitting", Green: "prowling", Orange: "flying" };
Object.keys(L).filter((k) => k.startsWith("see:")).forEach((k) => {
const c = L[k].colour;
SPOTS.push({ place: k, first: true, colour: c, pose: FIRST_POSE[c], sc: 0.2, flip: L[k].x > 500 });
});
const LANDMARKS = ["dir:West", "dir:Center", "dir:East", "scream", "bully", "wounded", "fork:Forest", "hour", "tree", "valley", "meadow", "stream"];
const LANDMARK_NAME = { "dir:West": "West, toward the scent", "dir:Center": "Forest centre", "dir:East": "East, toward the roar", "fork:Forest": "The fork" };
/* ---------- state ---------- */
const st = {
policy: null, runs: null, counts: {}, colour: null, focus: null, expanded: null, over: {},
objective: "eventually", sample: "all", traffic: false, cache: new Map(), pendingHash: null, info: null,
};
const model = () => st.policy.samples[st.sample];
function advisorFor(enc) {
const k = `${st.sample}|${st.colour}|${st.objective}|${enc}`;
if (!st.cache.has(k)) st.cache.set(k, S.advisor(model(), st.colour, st.objective, { only: [enc] }));
return st.cache.get(k);
}
let encParams = null;
const encOutcome = (enc) => {
if (!encParams || encParams.sample !== st.sample) encParams = { sample: st.sample, p: S.makeParams(model().model.tables, { alphas: model().model.alphas }) };
return encParams.p.encounter(enc);
};
/* ---------- walking one route ---------- */
const encColour = (enc) => (enc === "tree-Greens" ? "Green" : enc.split("-")[1]);
function defaultOutcome(s, enc) {
const ent = Object.entries(s.probs).sort((a, b) => b[1] - a[1]);
if (s.var === "shadow") return enc.startsWith("shadow-") ? "yes" : "no";
if (s.var === "shadowColour" || s.var === "meadow") { const c = encColour(enc); if (s.probs[c] != null) return c; }
return ent[0][0];
}
function walk(enc) {
const adv = advisorFor(enc), over = st.over[enc] || {}, steps = [], h = {};
for (let i = 0; i < 20; i++) {
const s = adv.step(h);
s.before = { ...h };
steps.push(s);
if (s.kind === "end") break;
const key = s.var;
const ok = s.kind === "decision" ? over[key] && s.options[over[key]] : over[key] && s.probs[over[key]] != null;
s.taken = ok ? over[key] : s.kind === "decision" ? s.choice : defaultOutcome(s, enc);
s.userSet = !!ok;
h[key] = s.taken;
}
return { enc, adv, steps, value: Object.keys(over).length ? routeValue(adv, over) : adv.value };
}
/**
* Value of a route when the rider follows their own choices (overrides) and plays the best route everywhere else:
* expectimax over the rolls, using the overridden option where one is set. Option values already include the
* best play after them, so recursion stops as soon as no override is left to apply.
*/
function routeValue(adv, over) {
const keys = Object.keys(over);
const rec = (h) => {
const s = adv.step(h);
if (s.kind === "end") return { x: 0, o: 0 };
const live = s.risk ? 1 - s.risk.p : 1;
if (s.kind === "chance") {
return Object.entries(s.probs).reduce((acc, [b, p]) => {
if (!p) return acc;
const v = rec({ ...h, [s.var]: b });
return { x: acc.x + p * v.x, o: acc.o + p * v.o };
}, { x: 0, o: 0 });
}
const o = over[s.var] && s.options[over[s.var]] ? over[s.var] : s.choice;
const pending = keys.some((k) => h[k] == null && k !== s.var);
if (!pending) { const v = s.options[o]; return { x: live * v.pX, o: live * v.pOther }; }
const v = rec({ ...h, [s.var]: o });
return { x: live * v.x, o: live * v.o };
};
return rec({});
}
/** The route as points on the map, each with the chance of still being on it, plus where decisions are made. */
function routePoints(route) {
const pts = [{ id: "gate", P: GATE, flow: 1 }], marks = [], rolls = [];
let flow = 1;
const push = (id) => { if (L[id]) pts.push({ id, P: L[id], flow }); };
const last = () => pts[pts.length - 1];
route.steps.forEach((s, i) => {
if (s.risk) flow *= 1 - s.risk.p;
if (s.kind === "chance") flow *= s.probs[s.taken] || 0;
if (s.kind === "end") return;
if (s.kind === "decision") marks.push({ i, s, at: last() });
const before = pts.length;
const v = s.taken, h = s.before;
switch (s.var) {
case "company": push("comp:" + v); break;
case "direction": push("dir:" + v); break;
case "fs": push(`see:${h.direction}:${v}`); break;
case "cadet":
push("scream");
if (v === "Left them to it") push("away");
else { push(["Tourniquet", "Left injured cadet", "Took their weapons"].includes(v) ? "wounded" : "bully"); push("res:" + v); }
break;
case "post": push("fork:" + v); break;
case "hour": push("hour"); marks[marks.length - 1].at = last(); push(v === "Tree" ? "tree" : "valley"); break;
case "shadow": if (v === "yes") push("stream"); break;
case "shadowColour": push(v === "Black" ? "black" : "redwood"); break;
case "descend": push(v.startsWith("Quickly") ? "treeRed" : "greens"); break;
case "valley": push(v === "Face the Red" ? "valleyRed" : "meadow"); break;
case "meadow": push("meadow:" + v); break;
default: break;
}
// a roll is labelled on the segment it leads into (or at the current point when nothing moves)
if (s.kind === "chance") rolls.push({ s, at: pts.length > before ? pts.length - 1 : null, P: last().P });
});
return { pts, marks, rolls, endFlow: flow };
}
// where each option of a decision leads on the map (for expanded choice points)
const optionPlace = (s, v) => ({
company: "comp:" + v, direction: "dir:" + v, post: "fork:" + v,
cadet: v === "Left them to it" ? "away" : "res:" + v,
hour: v === "Tree" ? "tree" : "valley", descend: v.startsWith("Quickly") ? "treeRed" : "greens",
valley: v === "Face the Red" ? "valleyRed" : "meadow",
}[s.var]);
/* ---------- drawing ---------- */
let base = null; // painted valley, cached as markup
function paintBase(svg) {
if (!base) {
const tmp = document.createElementNS(NS, "svg");
V.paintBase(tmp);
base = tmp.innerHTML.replace(/vm-/g, "ex-");
}
svg.innerHTML = base;
}
function curve(A, B, bend = 0.08, off = 0) {
const dx = B.x - A.x, dy = B.y - A.y, len = Math.hypot(dx, dy) || 1, nx = -dy / len * off, ny = dx / len * off;
const a = { x: A.x + nx, y: A.y + ny }, b = { x: B.x + nx, y: B.y + ny };
return `M${a.x} ${a.y} Q${(a.x + b.x) / 2 - dy * bend} ${(a.y + b.y) / 2 + dx * bend} ${b.x} ${b.y}`;
}
const mid = (A, B, t = 0.5, bend = 0.08) => {
const mx = (A.x + B.x) / 2 - (B.y - A.y) * bend, my = (A.y + B.y) / 2 + (B.x - A.x) * bend;
return { x: (1 - t) ** 2 * A.x + 2 * (1 - t) * t * mx + t * t * B.x, y: (1 - t) ** 2 * A.y + 2 * (1 - t) * t * my + t * t * B.y };
};
function pill(g, x, y, text, { ink = PAPER.ink, strong = false, bg = PAPER.halo } = {}) {
const w = 10 + text.length * (strong ? 7.2 : 6.4), h = strong ? 20 : 17;
el("rect", { x: x - w / 2, y: y - h / 2, width: w, height: h, rx: h / 2, fill: bg, "fill-opacity": 0.95, stroke: ink, "stroke-opacity": 0.4 }, g);
el("text", { x, y: y + (strong ? 4.5 : 4), "text-anchor": "middle", "font-size": strong ? 12.5 : 11, "font-weight": strong ? 700 : 500, fill: ink, "font-family": "var(--font-data)" }, g).textContent = text;
}
function drawDragons(g, routesOn) {
const maxN = Math.max(1, ...SPOTS.filter((s) => !s.first).map((s) => st.counts[s.place] || 0));
const maxF = Math.max(1, ...SPOTS.filter((s) => s.first).map((s) => st.counts[s.place] || 0));
SPOTS.forEach((sp) => {
const P = L[sp.place];
if (!P) return;
const n = st.counts[sp.place];
let op = n == null ? 0.85 : 0.22 + 0.78 * Math.sqrt(n / (sp.first ? maxF : maxN));
const isTarget = st.colour && !sp.first && (encColour(sp.enc) === st.colour || RESCUE[st.colour] === sp.enc);
if (st.colour && !isTarget) op *= 0.35;
if (isTarget) op = Math.max(op, 0.9);
const w = 200 * sp.sc, hgt = 160 * sp.sc;
const x = P.x - w / 2 + (sp.dx || 0), y = P.y - hgt * 0.7 + (sp.dy || 0);
const gg = el("g", { class: "ex-dragon", transform: `translate(${x} ${y}) scale(${sp.sc})`, opacity: op.toFixed(2), tabindex: sp.twin ? null : 0, role: sp.twin ? null : "button",
"aria-label": sp.first ? `${sp.colour} dragon, first sighting` : `${ENC_NAME[sp.enc]}. Show the routes to it.` }, g);
if (isTarget && routesOn) el("ellipse", { cx: 100, cy: 140, rx: 80, ry: 16, fill: INK[sp.colour], "fill-opacity": 0.25 }, gg);
gg.innerHTML += D.svg(sp.pose, { fill: INK[sp.colour], flip: sp.flip });
el("rect", { x: 0, y: 0, width: 200, height: 160, fill: "transparent" }, gg);
if (sp.twin) return;
const tipHtml = () => {
if (sp.first) return `<b>${sp.colour} dragon</b><br>One of the first dragons you can meet here. This is a roll of the dice, not a bonding.${n != null ? `<br>${n.toLocaleString()} riders met it here` : ""}`;
const o = st.policy ? encOutcome(sp.enc) : null;
const c = encColour(sp.enc);
const bond = o ? (sp.enc === "tree-Greens" ? `Green ${pct(o.Green)}, rescue by Orange ${pct(o.Orange || 0)} or Brown ${pct(o.Brown || 0)}` : pct(o[c])) : "–";
return `<b>${ENC_NAME[sp.enc]}</b>${n != null ? `<br>${n.toLocaleString()} riders met it here` : ""}<br>Bond chance when attempted: ${bond}`;
};
gg.addEventListener("mouseenter", (e) => showTip(e, tipHtml()));
gg.addEventListener("mousemove", (e) => moveTip(e));
gg.addEventListener("mouseleave", hideTip);
gg.addEventListener("focus", () => { const r = gg.getBoundingClientRect(); showTip({ clientX: r.right, clientY: r.top }, tipHtml()); });
gg.addEventListener("blur", hideTip);
const go = () => {
hideTip();
if (sp.first) { st.info = sp; render(); return; }
select(encColour(sp.enc) === "Green" && st.colour && RESCUE[st.colour] === sp.enc ? st.colour : encColour(sp.enc), sp.enc);
};
gg.addEventListener("click", go);
gg.addEventListener("keydown", (e) => { if (e.key === "Enter" || e.key === " ") { e.preventDefault(); go(); } });
});
}
function drawLandmarks(g, onRoute) {
const ids = new Set(LANDMARKS);
onRoute.forEach((id) => { if (L[id] && L[id].kind !== "dragon") ids.add(id); });
ids.forEach((id) => {
const P = L[id];
if (!P || P.kind === "dragon") return;
const strong = onRoute.has(id);
el("circle", { cx: P.x, cy: P.y, r: strong ? 6 : 4.5, fill: PAPER.ink, "fill-opacity": strong ? 0.95 : 0.7, stroke: PAPER.halo, "stroke-width": 2 }, g);
const right = (P.lab || "right") !== "left";
const t = el("text", { x: P.x + (right ? 10 : -10), y: P.y + 4, "text-anchor": right ? "start" : "end", "font-family": "var(--font-display)", "font-size": strong ? 14 : 13,
fill: PAPER.ink, "fill-opacity": strong ? 1 : 0.8, "paint-order": "stroke", stroke: PAPER.halo, "stroke-width": 3.5, "stroke-linejoin": "round" }, g);
t.textContent = LANDMARK_NAME[id] || P.name;
});
el("text", { x: GATE.x, y: GATE.y + 14, "text-anchor": "middle", "font-size": 11, "letter-spacing": "0.16em", fill: PAPER.ink, "font-family": "var(--font-label)", "paint-order": "stroke", stroke: PAPER.halo, "stroke-width": 3 }, g).textContent = "ENTER THE VALLEY";
}
function drawTraffic(g) {
if (!st.runs) return;
const edges = new Map();
st.runs.forEach((r) => {
const seq = V.path(r);
for (let i = 1; i < seq.length; i++) {
const k = seq[i - 1] + ">" + seq[i];
edges.set(k, (edges.get(k) || 0) + 1);
}
});
const max = Math.max(1, ...edges.values());
[...edges.entries()].sort((a, b) => b[1] - a[1]).forEach(([k, n]) => {
const [a, b] = k.split(">");
if (!L[a] || !L[b]) return;
el("path", { d: curve(L[a], L[b], 0.05), fill: "none", stroke: "#6b4a33", "stroke-opacity": 0.32, "stroke-width": 1.5 + 18 * Math.sqrt(n / max), "stroke-linecap": "round" }, g);
});
}
function drawRoutes(gRoute, gLab, routes) {
const best = Math.max(1e-12, ...routes.map((r) => r.value.x));
const onRoute = new Set();
const tc = INK[st.colour];
// weaker routes first so the best one sits on top
[...routes].sort((a, b) => a.value.x - b.value.x).forEach((r) => {
const rel = r.value.x / best;
const focus = r.enc === st.focus;
const dash = rel >= 0.5 ? null : rel >= 0.1 ? "14 9" : "3 9";
const op = (0.3 + 0.65 * rel) * (focus ? 1 : 0.85);
const off = (routes.indexOf(r) - (routes.length - 1) / 2) * 7;
const { pts, marks } = r.geo;
pts.forEach((p) => onRoute.add(p.id));
for (let i = 1; i < pts.length; i++) {
const A = pts[i - 1].P, B = pts[i].P, w = 3 + 22 * pts[i].flow;
const d = curve(A, B, 0.08, off);
if (focus) el("path", { d, fill: "none", stroke: "#fff1c9", "stroke-width": w + 6, "stroke-opacity": 0.55, "stroke-linecap": "round" }, gRoute);
el("path", { d, fill: "none", stroke: tc, "stroke-width": w, "stroke-opacity": op, "stroke-linecap": dash ? "butt" : "round", "stroke-dasharray": dash, class: "ex-route" }, gRoute);
}
// rolls of the dice: the odds where the route narrows (focused route only)
if (focus) r.geo.rolls.forEach((ro) => {
const p = ro.s.probs[ro.s.taken];
if (p > 0.995) return;
// the last roll leads straight into the dragon, whose own label sits there: put the roll under the fork point
const at = !ro.at ? { x: ro.P.x + 34, y: ro.P.y - 22 } : ro.at === pts.length - 1 ? { x: pts[ro.at - 1].P.x, y: pts[ro.at - 1].P.y + 24 } : mid(pts[ro.at - 1].P, pts[ro.at].P, 0.38);
pill(gLab, at.x, at.y, ro.s.var === "shadow" ? `shadow ${pct(p)}` : `roll ${pct(p)}`);
});
// destination label
const end = pts[pts.length - 1];
pill(gLab, end.P.x, end.P.y + 30, `${pct(r.value.x)} per attempt`, { ink: tc, strong: rel === 1 });
// choice points on the focused route
if (focus) marks.forEach((m) => {
if (!m.at || m.s.var === "encounter") return;
const P = m.at.P, open = st.expanded === m.s.var;
const g = el("g", { class: "ex-mark", tabindex: 0, role: "button", "aria-label": `${m.s.label}: ${m.s.taken}. Show the other options.`, "aria-expanded": open }, gLab);
el("path", { d: `M${P.x} ${P.y - 9} L${P.x + 9} ${P.y} L${P.x} ${P.y + 9} L${P.x - 9} ${P.y} Z`, fill: open ? tc : PAPER.halo, stroke: tc, "stroke-width": 2.5 }, g);
el("title", {}, g).textContent = `${m.s.label}: ${m.s.taken} (click for the other options)`;
const go = () => { st.expanded = open ? null : m.s.var; render(); };
g.addEventListener("click", go);
g.addEventListener("keydown", (e) => { if (e.key === "Enter" || e.key === " ") { e.preventDefault(); go(); } });
if (open) {
const best2 = Math.max(1e-12, ...Object.values(m.s.options).map((v) => v.pX));
Object.entries(m.s.options).forEach(([v, val]) => {
const pid = optionPlace(m.s, v);
if (!pid || !L[pid] || v === m.s.taken) return;
const B = L[pid], rel2 = val.pX / best2;
const p = el("path", { d: curve(P, B, 0.1), fill: "none", stroke: tc, "stroke-width": 2 + 4 * rel2, "stroke-opacity": 0.35 + 0.5 * rel2, "stroke-dasharray": "6 6", "stroke-linecap": "round", class: "ex-alt", tabindex: 0, role: "button", "aria-label": `${v}: ${pct(val.pX)}. Take this instead.` }, gLab);
const m2 = mid(P, B, 0.72, 0.1);
pill(gLab, m2.x, m2.y, `${v.length > 18 ? v.slice(0, 17) + "…" : v} ${pct(val.pX)}`);
const pick = () => choose(m.s.var, v);
p.addEventListener("click", pick);
p.addEventListener("keydown", (e) => { if (e.key === "Enter" || e.key === " ") { e.preventDefault(); pick(); } });
});
}
});
});
return onRoute;
}
/* ---------- tooltip ---------- */
function showTip(e, html) { const t = $("#ex-tip"); t.innerHTML = html; t.hidden = false; moveTip(e); }
function moveTip(e) {
const t = $("#ex-tip"), box = $(".ex-map-wrap").getBoundingClientRect(), r = t.getBoundingClientRect();
t.style.left = Math.min(box.width - r.width - 8, Math.max(8, e.clientX - box.left + 14)) + "px";
t.style.top = Math.min(box.height - r.height - 8, Math.max(8, e.clientY - box.top + 14)) + "px";
}
const hideTip = () => { const t = $("#ex-tip"); if (t) t.hidden = true; };
/* ---------- panel ---------- */
const mini = (c, pose = "sitting") => `<svg viewBox="0 0 200 160" aria-hidden="true">${D.svg(pose, { fill: `var(${DV[c]})`, eyeFill: "var(--bg)" })}</svg>`;
const POSE_OF = { Red: "roaring", Orange: "flying", Brown: "resting", Green: "prowling", Blue: "coiled", Black: "flying" };
const trafficToggle = () => `<label class="ex-toggle"><input type="checkbox" id="ex-traffic"${st.traffic ? " checked" : ""}> Show where riders actually went</label>`;
function chooser() {
return `<div class="ex-choose">${COLOURS.map((c) => `<button type="button" class="ex-dchip" data-c="${c}" aria-pressed="${st.colour === c}" style="--c: var(${DV[c]})">${mini(c, POSE_OF[c])}<span>${c}</span></button>`).join("")}</div>`;
}
function panelIdle() {
let info = "";
if (st.info) {
const sp = st.info, dir = sp.place.split(":")[1];
const fs = st.policy ? S.makeParams(model().model.tables, { alphas: model().model.alphas }).chance("fs", { direction: dir }) : null;
info = `<div class="ex-card"><span class="eyebrow">First sighting · ${dir === "Center" ? "forest centre" : dir.toLowerCase()}</span>
<p class="small">The first dragon is a roll of the dice: nobody bonds here, it decides what you face next.${fs ? ` Going ${dir === "Center" ? "to the forest centre" : dir.toLowerCase()}, riders met: ${Object.entries(fs).sort((a, b) => b[1] - a[1]).filter(([, p]) => p > 0.005).map(([k, p]) => `${k} ${pct(p)}`).join(", ")}.` : ""}</p></div>`;
}
return `<span class="eyebrow">Unofficial atlas · built from ${st.runs ? st.runs.length.toLocaleString() : "thousands of"} logged runs</span>
<h2 id="h-valley">The valley</h2>
<p class="small muted">Every dragon is drawn where riders meet it. The fainter it is, the fewer riders reach it. Choose one to see every way to it, and how likely each is.</p>
${chooser()}${info}
${trafficToggle()}
<p class="small muted">Prefer the numbers? <a href="#odds">The Odds</a> has the statistics behind the map.</p>`;
}
function panelRoutes(routes) {
const best = Math.max(1e-12, ...routes.map((r) => r.value.x));
const T = model().targets[st.colour], b = T[st.objective];
const focus = routes.find((r) => r.enc === st.focus) || routes[0];
const card = (r) => {
const rel = r.value.x / best, o = encOutcome(r.enc), c = encColour(r.enc);
const n = r.adv.attempts(r.enc);
const bond = r.enc === "tree-Greens" && st.colour !== "Green" ? `rescue by ${st.colour}: ${pct(o[st.colour] || 0)}` : `bond chance there: ${pct(o[c])}`;
const style = rel >= 0.5 ? "solid" : rel >= 0.1 ? "dashed" : "dotted";
return `<button type="button" class="ex-route-card${r.enc === focus.enc ? " on" : ""}" data-enc="${r.enc}" aria-pressed="${r.enc === focus.enc}">
<i class="ex-swatch ${style}" style="--c: var(${DV[st.colour]}); opacity:${(0.3 + 0.7 * rel).toFixed(2)}"></i>
<span class="nm">${esc(ENC_NAME[r.enc])}${RESCUE[st.colour] === r.enc && st.colour !== "Green" ? " <em>(rescue)</em>" : ""}</span>
<b>${pct(r.value.x)}</b><small>per attempt · ${bond}${n < 30 ? ` · only ${n} attempts logged` : ""}${r.value.o > 0.005 ? ` · ends on another dragon ${pct(r.value.o)}` : ""}</small></button>`;
};
const steps = focus.steps.filter((s) => s.kind === "decision" || s.kind === "chance").map((s) => {
if (s.kind === "chance") return `<li class="chance"><span>${esc(s.label)}</span><b>${esc(String(s.taken))}</b><small>roll ${pct(s.probs[s.taken])}</small></li>`;
const open = st.expanded === s.var;
const opts = open ? `<div class="ex-opts">${Object.entries(s.options).sort((a, c) => c[1].pX - a[1].pX).map(([v, val]) =>
`<button type="button" class="ex-opt${v === s.taken ? " on" : ""}" data-var="${s.var}" data-v="${esc(v)}"><span>${esc(v)}${v === s.choice ? ' <em class="rec">best</em>' : ""}</span><b>${pct(val.pX)}</b></button>`).join("")}</div>` : "";
return `<li class="dec${open ? " open" : ""}"><button type="button" class="ex-step" data-var="${s.var}" aria-expanded="${open}"><span>${esc(s.label)}</span><b>${esc(String(s.taken))}</b><small>${s.userSet ? "your choice" : "best"} · ${s.var === "encounter" ? pct(s.options[s.taken].pX) : pct(s.options[s.taken].pX)}</small></button>${opts}</li>`;
}).join("");
const risks = focus.steps.filter((s) => s.risk && s.risk.p > 0.0005).map((s) => `${s.risk.label.toLowerCase()} ${pct(s.risk.p)}`);
const lb = st.policy.samples.lowBias.targets[st.colour].thisAttempt;
return `<div class="ex-head" style="--c: var(${DV[st.colour]})">${mini(st.colour, POSE_OF[st.colour])}<div><span class="eyebrow">Routes to a</span><h2 id="h-valley">${st.colour} dragon</h2></div>
<button type="button" class="ex-close" id="ex-clear" aria-label="Back to the whole valley">×</button></div>
${chooser()}
<div class="seg" role="group" aria-label="Goal"><button type="button" data-o="eventually" aria-pressed="${st.objective === "eventually"}" title="Die on purpose and try again whenever it goes wrong; never risk ending on another dragon">Only this dragon</button><button type="button" data-o="thisAttempt" aria-pressed="${st.objective === "thisAttempt"}" title="Best chance on this one run">Best odds this run</button></div>
<div class="ex-routes">${routes.map(card).join("")}</div>
<p class="small muted ex-key"><span class="solid"></span> best route <span class="dashed"></span> under half as likely <span class="dotted"></span> under a tenth · line width: chance you are still on the route</p>
<span class="eyebrow">${esc(ENC_NAME[focus.enc])}: step by step</span>
<ol class="ex-steps">${steps}</ol>
<p class="small muted">Diamonds on the map are choices: click one to see where the other options lead. Changed your mind? <button type="button" class="linklike" id="ex-reset-route">Reset this route</button></p>
<details class="ex-why"><summary>Why this route?</summary>
<p class="small">Best route for any ${st.colour}: <b>${pct(b.pX.mean)}</b> per attempt (95% interval ${pct(b.pX.lo)}–${pct(b.pX.hi)}), about ${isFinite(b.expectedAttempts.mean) ? Math.round(b.expectedAttempts.mean) : "–"} attempts. Riders who logged every run suggest ${pct(lb.pX.mean)}.</p>
<p class="small">Each roll's odds may depend on your earlier choices, as far as the data support it. Choices marked "no clear winner" in <a href="#deep">Deep Dive</a> are within the noise.${risks.length ? ` Risks on this route: ${risks.join(", ")}.` : ""}</p>
<p class="small">The bond chance at each encounter is the community average: the form does not record the answers riders gave there.</p>
<div class="seg" role="group" aria-label="Data"><button type="button" data-s="all" aria-pressed="${st.sample === "all"}">All runs</button><button type="button" data-s="lowBias" aria-pressed="${st.sample === "lowBias"}">Low-bias</button></div>
</details>
${trafficToggle()}`;
}
function bindPanel() {
const p = $("#ex-panel");
$$(".ex-dchip", p).forEach((b) => b.addEventListener("click", () => select(b.dataset.c === st.colour ? null : b.dataset.c)));
$$(".ex-route-card", p).forEach((b) => b.addEventListener("click", () => { st.focus = b.dataset.enc; st.expanded = null; render(); }));
$$(".ex-step", p).forEach((b) => b.addEventListener("click", () => { st.expanded = st.expanded === b.dataset.var ? null : b.dataset.var; render(); }));
$$(".ex-opt", p).forEach((b) => b.addEventListener("click", () => choose(b.dataset.var, b.dataset.v)));
$$("[data-o]", p).forEach((b) => b.addEventListener("click", () => { st.objective = b.dataset.o; render(); }));
$$("[data-s]", p).forEach((b) => b.addEventListener("click", () => { st.sample = b.dataset.s; render(); }));
const tr = $("#ex-traffic", p); if (tr) tr.addEventListener("change", () => { st.traffic = tr.checked; render(); });
const cl = $("#ex-clear", p); if (cl) cl.addEventListener("click", () => select(null));
const rr = $("#ex-reset-route", p); if (rr) rr.addEventListener("click", () => { delete st.over[st.focus]; st.expanded = null; render(); });
}
/* ---------- actions ---------- */
function select(colour, enc) {
st.colour = colour; st.info = null; st.expanded = null;
st.focus = colour ? enc || null : null;
writeHash();
render();
}
function choose(v, val) {
const route = walk(st.focus);
const order = route.steps.map((s) => s.var);
const over = { ...(st.over[st.focus] || {}) };
// keep choices before this one, drop the ones after it
const idx = order.indexOf(v);
order.slice(idx + 1).forEach((k) => delete over[k]);
over[v] = val;
st.over[st.focus] = over;
render();
}
function writeHash() {
if (!$("#panel-valley") || $("#panel-valley").hidden) return;
const h = "#valley" + (st.colour ? "/" + st.colour.toLowerCase() + (st.focus ? "/" + st.focus : "") : "");
try { history.replaceState(null, "", h); } catch (e) { /* ignore */ }
}
function fromHash() {
const parts = (location.hash || "").replace(/^#/, "").split("/");
if (parts[0] !== "valley") return;
const c = parts[1] ? COLOURS.find((x) => x.toLowerCase() === parts[1].toLowerCase()) : null;
const enc = parts[2] && c && S.ENCOUNTERS[c].includes(parts[2]) ? parts[2] : null;
if (!st.policy) { st.pendingHash = { c, enc }; return; }
if (c !== st.colour || (enc && enc !== st.focus)) { st.colour = c; st.focus = enc; st.expanded = null; render(); }
}
/* ---------- render ---------- */
function render() {
const svg = $("#ex-map");
if (!svg) return;
paintBase(svg);
el("rect", { x: 0, y: 0, width: 1000, height: 790, fill: "#f6e6c4", "fill-opacity": st.colour ? 0.32 : 0.12 }, svg);
const gTraffic = el("g", { filter: "url(#ex-brush)" }, svg);
const gRoute = el("g", { filter: "url(#ex-brush)" }, svg);
const gLand = el("g", {}, svg), gDrag = el("g", {}, svg), gLab = el("g", {}, svg);
if (st.traffic) drawTraffic(gTraffic);
let routes = [], onRoute = new Set();
if (st.colour && st.policy) {
routes = S.ENCOUNTERS[st.colour].map((enc) => {
const r = walk(enc);
r.geo = routePoints(r);
return r;
}).sort((a, b) => b.value.x - a.value.x);
if (!st.focus || !routes.some((r) => r.enc === st.focus)) st.focus = routes[0].enc;
onRoute = drawRoutes(gRoute, gLab, routes);
}
drawLandmarks(gLand, onRoute);
drawDragons(gDrag, !!st.colour);
// the paper texture and vignette go on top
const fin = document.createElementNS(NS, "svg");
V.finish(fin);
svg.insertAdjacentHTML("beforeend", fin.innerHTML.replace(/vm-/g, "ex-"));
$("#ex-hint").hidden = !!st.colour || !st.policy;
$("#ex-shell").style.setProperty("--vt", st.colour ? `var(${DV[st.colour]})` : "var(--accent)");
// the panel scrolls inside the map's height on wide screens (see .ex-scroll)
$("#ex-panel").innerHTML = `<div class="ex-scroll">${st.colour && st.policy ? panelRoutes(routes) : panelIdle()}</div>`;
bindPanel();
writeHash();
// on narrow screens the map scrolls sideways: start centred rather than at the far west
const wrap = $(".ex-map-wrap");
if (wrap && !wrap.dataset.centred && wrap.scrollWidth > wrap.clientWidth) { wrap.scrollLeft = (wrap.scrollWidth - wrap.clientWidth) / 2; wrap.dataset.centred = "1"; }
}
function setRuns(state) {
st.runs = state.runs;
st.counts = {};
state.runs.forEach((r) => V.path(r).forEach((id) => (st.counts[id] = (st.counts[id] || 0) + 1)));
render();
}
function init() {
render();
fetch("data/policy.json").then((r) => r.json()).then((p) => {
st.policy = p;
if (st.pendingHash) { st.colour = st.pendingHash.c; st.focus = st.pendingHash.enc; st.pendingHash = null; }
render();
}).catch(() => { $("#ex-panel").innerHTML = '<p class="small muted">The route model (data/policy.json) could not be loaded.</p>'; });
}
window.ValleyExplorer = { setRuns, fromHash, state: st, render };
if (document.readyState === "loading") document.addEventListener("DOMContentLoaded", init); else init();
})();