blockyard 0.1.1 → 0.1.2

package/CHANGELOG.md

@@ -6,7 +6,7 @@ All notable changes to this project are documented here. The format follows
 
 ## [Unreleased]
 
-## [0.1.1] — 2026-09-17
+## [0.1.2] — 2026-09-17
 
 A day of hardening, and a new game. The headline is the **third AI security audit**, run on
 2026-09-16 over the whole codebase by four auditors in parallel, and every one of its findings
@@ -18,9 +18,10 @@ implementation; property tests over Bitcoin Core's file formats found and fixed
 reading undo data. The **skies** were made clear: every board picks the Galaxy or the Earth sky in
 one place, and the Earth sky gained a warm sun with a halo, a moon that glows through its real
 phases, and softer clouds. And under Diversions, **Scorched Yard**: Scorched Earth on the block
-engine, with the manual's weapons and computer players, up to eight tanks, a cheat mode that draws
+engine, with the manual's weapons and computer players who each wear their own colour and aim like
+people, up to eight tanks, a cheat mode that draws
 the firing solution, and wind that is a real fluid simulation flowing over the hills. The games now
-load only when their page is first opened. 1,068 tests, from 945.
+load only when their page is first opened. 1,070 tests, from 945.
 
 ### Upgrading from 0.1.0
 
@@ -73,6 +74,9 @@ load only when their page is first opened. 1,068 tests, from 945.
 
 ### Scorched Yard
 
+- **Fixed: Scorched Yard's Shooter and Chooser were far too accurate.** Both fired the exact shot the physics search found, with no error: over 200 simulated games the Shooter hit with 60% of its first shots and the Chooser with 95%, as often as the Spoiler the manual calls nearly perfect. Every personality that searches now aims the way a person does, off by an error that grows with the distance and shrinks with each shot at the same target. First-shot hit rates now: Moron and Tosser about 5%, Shooter and Poolshark about 23%, Chooser about 43%, Spoiler about 84%, Cyborg about 76%, and the Shooter closes from 23% to 32% by its third shot. A test holds the order and the bands
+- **Scorched Yard: each personality has its own colour.** A tank took its colour from its seat, so the first opponent was blue and the second green whatever played there. Now You are orange, the Moron yellow, the Shooter blue, the Poolshark cyan, the Tosser green, the Chooser purple, the Spoiler red, the Cyborg pink and the Unknown grey (which gives nothing away about the personality it draws), and a second or third of one kind is a lighter or darker shade. The scoreboard's dot follows the tank's colour too; it had been a colour per seat, so a red Spoiler was listed with a blue dot
+- **Scorched Yard's opponents are shuffled every game.** With the shipped mix, the seats were filled from a fixed list in order, so two opponents were a Shooter and a Tosser in every game. Each new game now deals the six personalities (Shooter, Tosser, Chooser, Spoiler, Cyborg, Poolshark) in a fresh order: two opponents are a different pair each time, up to six are all different kinds, and a seventh starts a new deal. Naming one kind in *Their kind* still fills every seat with it
 - **Scorched Yard: the rest of the control plan.** *Correcting*: click an enemy tank to mark it; after your shot the panel says how it did against it (*10 over*, *6 short*, *close*, *hit*) and **C** sets the power that miss implies, from your own last shot. *Weapons*: **W** opens a grid of what you own, biggest blast first, with counts and keys; **1–9** pick in the shop's order; **Q** picks your last weapon; the item pills are buttons. *The aim guide*: a ghost of the first fifth of the flight while you aim, or the whole flight, or off. *The fire button* names what it will send, and the last of a weapon sold one at a time asks once before it goes. A press on your own tank turns the barrel without touching the power. The keys are a table. Three new settings: Aim guide, Correction helper, Confirm the last of a weapon
 - **Scorched Yard: the old wind code is gone.** The four earlier wind pictures (marching particles, dashed currents, a plasma wash, bowing bands), the smoke dye the fluid first carried, and the air clock only they used are deleted, with the tests that covered only them: the wind module drops from about 400 lines to 69, and the air module loses its dye grid. What is drawn is unchanged — the simulated air, its flow lines, and the sky's faint ripple
 - **Fixed: Scorched Yard's computer players seemed to aim at tanks already destroyed.** A computer player chose its shot only when its thinking pause ran out, so for the whole pause its gauge (and, in cheat mode, its trajectory) still showed its previous shot, usually aimed at the tank it had just destroyed. It now plans the moment its turn begins, against the tanks alive then, and its barrel and power ease from the old aim to the new one while it thinks. Cheat mode draws only your own firing solution. And the random shot that the Moron fires, and that the Shooter and Poolshark fall back on, heads toward a living enemy instead of the middle of the field, which had kept shelling the empty half once the tanks there were gone: in 4,357 simulated shots none now fires away from every tank still standing, against 20 before

package/README.md

@@ -47,7 +47,7 @@ top of the node's own ~875 GB of block files.
 ```bash
 git clone https://github.com/BobClawblaw/blockyard.git
 cd blockyard
-npm test            # optional: 1068 unit tests, all built in
+npm test            # optional: 1070 unit tests, all built in
 npm run setup       # reads the node's bitcoin.conf, checks the node, writes config/local.json
 npm start           # builds the address index in the background (a few hours); open https://127.0.0.1:21000
                     # and sign in as admin with the password the first start prints once
@@ -136,7 +136,7 @@ Details in [docs/SECURITY.md](docs/SECURITY.md). To report a vulnerability, see
 npm run dev          # fake node doing a simulated sync, port 18088
 npm run setup        # interactive install: read bitcoin.conf, check the node, write config/local.json
 npm run check        # the same checks (every call timed) against every configured node; exits 1 on a FAIL
-npm test             # 1068 unit tests (node:test, no dependencies)
+npm test             # 1070 unit tests (node:test, no dependencies)
 npm run smoke        # boots the real server and checks the HTTP contract
 npm run counts:fix   # keep the documented test count in step with the suite
 ```
@@ -146,7 +146,7 @@ RPC etiquette) and [docs/ARCHITECTURE.md](docs/ARCHITECTURE.md) for how it fits
 
 ## Status
 
-Version **0.1.1** (2026-09-17) — a hardening release after 0.1.0: the third security audit with
+Version **0.1.2** (2026-09-17) — a hardening release after 0.1.0: the third security audit with
 every finding fixed, a resumable address index build, and Scorched Yard. Pre-release software: the
 word is meant literally. Releases are published on [npm](https://www.npmjs.com/package/blockyard)
 as `blockyard`, as [GitHub releases](https://github.com/BobClawblaw/blockyard/releases),
@@ -157,7 +157,7 @@ It ships **hardened**: bound to this machine, sign-in on, HTTPS with a certifica
 and **zero telemetry** — no outbound connection to anyone but your node until you tick the market
 polling switch yourself.
 The test suite is
-comprehensive (1068 tests, plus a live smoke run), the monitoring side is solid, and the
+comprehensive (1070 tests, plus a live smoke run), the monitoring side is solid, and the
 explorer's biggest gap is closed: **address history and balances**, which Bitcoin Core cannot
 answer at any setting, now come from an **address index BlockYard builds itself** from the
 node's block and undo files and keeps current as blocks arrive. It is checked against the node

package/docs/GETTING-STARTED.md

@@ -165,7 +165,7 @@ it is not echoed.
 npm start
 ```
 
-The log says `BlockYard 0.1.1 listening on https://127.0.0.1:21000` (its own self-signed
+The log says `BlockYard 0.1.2 listening on https://127.0.0.1:21000` (its own self-signed
 certificate, made on this first start; the browser warns once and remembers it), then `created the
 first admin account (admin)` with a generated password **shown once** — copy it, or set
 `BLOCKYARD_ADMIN_PASSWORD` before the first start to choose it — then `address index: building

package/docs/USER-GUIDE.md

@@ -724,7 +724,8 @@ Scorched Earth, the 1991 DOS artillery game, on the block engine: a landscape of
 craters and falls, tanks that aim by angle and power, wind, and a round that ends when one tank is
 left. Under **Diversions**, after Blockanoid. You play against two computer opponents out of the
 box (**Display settings → Scorched Yard → Computer players** fields up to seven, for the original's
-eight seats; every tank has its own colour).
+eight seats). Every personality has its own colour, so you can see who you are up against; a second
+or third of one kind is a lighter or darker shade of it.
 
 The rules are the original's (docs/PLAN-SCORCHED-YARD.md is the whole plan): the manual's roster
 of thirty-three weapons and eleven accessories at the manual's prices, packs and blast radii,
@@ -786,21 +787,28 @@ and 5% interest, which the settings allow.
 
 ![Scorched Yard](images/scorched.jpg)
 
-Out of the box you face a **mix**, climbing from the easy ones: a Shooter and a Tosser, then a
-Chooser, a Spoiler, a Cyborg and a Poolshark as you add seats. **Display settings → Scorched Yard
+Out of the box you face a **mix**: every new game deals a Shooter, a Tosser, a Chooser, a Spoiler,
+a Cyborg and a Poolshark in a fresh order, so two opponents are a different pair each time, and up
+to six opponents are all different kinds (a seventh starts a new deal). **Display settings → Scorched Yard
 → Their kind** fields one kind in every seat instead. They are the manual's eight, and they
 behave as it says:
 
-| kind | how it plays |
-|---|---|
-| Moron | picks an angle and a power, and shoots; buys at random |
-| Shooter | takes low, straight shots when it has a line of fire, and shoots like a Moron when it does not |
-| Poolshark | a Shooter, except that under rubber or spring walls it looks for the bank shot too |
-| Tosser | lobs high, then corrects its power from each miss, by halves, until it hits |
-| Chooser | tries the straight shot, the lob and the bank, and takes whichever lands closest |
-| Spoiler | works the shot out from the wind and gravity and is nearly perfect, with a wobble now and then |
-| Cyborg | a Spoiler with a grudge: it fires at whoever hit it last, else at the weakest, else at the leader |
-| Unknown | one of the others, drawn afresh each round and never announced |
+| kind | colour | how it plays |
+|---|---|---|
+| Moron | yellow | picks an angle and a power, and shoots; buys at random |
+| Shooter | blue | takes low, straight shots when it has a line of fire, and shoots like a Moron when it does not; its aim is rough at first and closes in on the same target |
+| Poolshark | cyan | a Shooter, except that under rubber or spring walls it looks for the bank shot too |
+| Tosser | green | lobs high, then corrects its power from each miss, by halves, until it hits |
+| Chooser | purple | tries the straight shot, the lob and the bank, and takes whichever lands closest; a steadier hand than the Shooter's, not a perfect one |
+| Spoiler | red | works the shot out from the wind and gravity and is nearly perfect |
+| Cyborg | pink | a Spoiler with a grudge: it fires at whoever hit it last, else at the weakest, else at the leader |
+| Unknown | grey | one of the others, drawn afresh each round and never announced |
+
+How often each lands its first shot at a target, measured over hundreds of simulated games: the
+Moron and the Tosser about one in twenty, the Shooter and the Poolshark about one in four, the
+Chooser about two in five, and the Spoiler and the Cyborg about four in five. The Shooter, the
+Poolshark, the Chooser, the Spoiler and the Cyborg aim better with each shot at the same target and
+start afresh each round; the Tosser corrects in its own way. You are orange.
 
 All but the Moron use a battery when hurt and raise a shield before firing, and each shops to its
 own taste between rounds: Shooters buy missiles, Tossers MIRVs and Funky Bombs, Cyborgs the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "blockyard",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Live web monitor, 3D block-space viewer, block explorer and markets view for a Bitcoin Core node",
   "license": "Apache-2.0",
   "keywords": [

package/public/css/app.css

@@ -2001,8 +2001,8 @@ table.sykeys td { padding: 2px 0; }
   padding: 4px 9px; border-radius: 10px; background: rgba(14, 16, 22, .88); border: 1px solid var(--line); color: var(--fg);
   font-size: 12px; white-space: nowrap; pointer-events: none; }
 .sytalk.hidden { display: none; }
-.sydot-0 { background: #f7931a; } .sydot-1 { background: #4d8dff; } .sydot-2 { background: #2ecc8f; }
-.sydot-3 { background: #ef5a5a; } .sydot-4 { background: #c78bff; } .sydot-5 { background: #f0c419; }
+/* each dot takes its tank's own colour, set through the CSSOM by scorchedyard.js drawTanks (the
+   colour follows the personality, and a class per seat painted the seat's old colour instead) */
 /* the items line: pills, lit when armed */
 .syitems { display: flex; flex-wrap: wrap; gap: 4px; margin-bottom: 10px; font-size: 11px; min-height: 18px; }
 .sypill { padding: 2px 7px; border-radius: 999px; border: 1px solid var(--line); color: var(--fg-dim); }

package/public/js/scorched.js

@@ -34,6 +34,25 @@ const UNKNOWN_POOL = Object.freeze(['moron', 'shooter', 'poolshark', 'tosser', '
 // EIGHT SEATS, EIGHT COLOURS (operator, 2026-09-16: "I would like to add up to 8 players total like
 // the original"). Distinct at a glance on dirt, and none of them the dirt's own browns.
 export const TANK_COLOURS = Object.freeze(['#f7931a', '#4d8dff', '#2ecc8f', '#ef5a5a', '#c78bff', '#f0c419', '#32d4e0', '#ff86b8']);
+// A COLOUR FOR EACH PERSONALITY (operator, 2026-09-17: "assign a color to each personality"). A tank
+// used to take its colour from its seat, so the first opponent was blue and the second green whatever
+// played there. Now the colour says who you are up against: you are BlockYard orange, and each of
+// the manual's eight has its own. The Unknown has one too, so its colour gives nothing away about
+// the personality it draws each round. A second or third of one kind is a lighter, then a darker,
+// shade of the same colour.
+export const PERSONA_COLOURS = Object.freeze({
+  human: '#f7931a', moron: '#f0c419', shooter: '#4d8dff', poolshark: '#32d4e0', tosser: '#2ecc8f',
+  chooser: '#c78bff', spoiler: '#ef5a5a', cyborg: '#ff86b8', unknown: '#b7c0cc',
+});
+const mixHex = (hex, to, k) => `#${[1, 3, 5].map((i) => Math.round(parseInt(hex.slice(i, i + 2), 16) * (1 - k) + to * k).toString(16).padStart(2, '0')).join('')}`;
+/** The colour of the `nth` tank (1 = the first) of a kind: its own colour, then shades of it. */
+export function colourFor(kind, nth = 1) {
+  const base = PERSONA_COLOURS[kind] ?? TANK_COLOURS[0];
+  if (nth <= 1) return base;
+  const shades = [[255, 0.35], [0, 0.35], [255, 0.6], [0, 0.55], [255, 0.8], [0, 0.7]];
+  const [to, k] = shades[(nth - 2) % shades.length];
+  return mixHex(base, to, k);
+}
 export const MAX_PLAYERS = 8;
 export const MAX_HEALTH = 100;
 export const V_MAX = 56;              // cells/s at power 1000
@@ -192,6 +211,7 @@ export function newGame(players, opts = {}) {
       kills: 0, score: 0, cash: Number.isFinite(opts.cash) ? opts.cash : START_CASH, damageDealt: 0,
       lastHitBy: null,                    // who hurt this tank last (the Cyborg holds a grudge)
       memory: null,                       // a computer player's last shot at its target, for correcting
+      aimAt: null,                        // a computer player's shots so far at one target: its aim tightens (scorchedai.js AIM)
       persona: p.kind ?? 'human',         // what an Unknown is playing as this round
     })),
     round: 1, rounds: Math.max(1, Math.round(opts.rounds ?? 5)),
@@ -216,7 +236,7 @@ export function startRound(g) {
   placeTanks(g);
   for (const t of g.tanks) {
     t.health = MAX_HEALTH; t.alive = true; t.shield = null; t.armed = { contactTrigger: false, heatGuidance: false };
-    t.lastHitBy = null; t.memory = null;
+    t.lastHitBy = null; t.memory = null; t.aimAt = null;
     // an Unknown is one of the others, drawn each round and never announced (the manual)
     t.persona = t.kind === 'unknown' ? UNKNOWN_POOL[Math.floor(g.rnd() * UNKNOWN_POOL.length)] : t.kind;
   }

package/public/js/scorchedai.js

@@ -77,6 +77,48 @@ function pickWeapon(tank, target, { thrifty = false } = {}) {
   return owned.sort((a, b) => WEAPONS[b].damage - WEAPONS[a].damage)[0];
 }
 
+// ------------------------------------------------------------------- the aim, as a person aims
+/**
+ * HOW WELL EACH OF THEM AIMS (operator, 2026-09-17: "Chooser and Shoot are both too fucking accurate").
+ * The search above finds the shot the physics says lands closest, and the Shooter and the Chooser
+ * fired exactly that: measured over 200 games, the Shooter hit with 60% of its first shots (every
+ * miss was a game with no low line of fire) and the Chooser with 95%, more than the Spoiler the
+ * manual calls the one that "gets a perfect shot almost every time". So each personality now
+ * aims the way a person does: the found angle and power, off by an error drawn from the game's own
+ * stream. The error grows with the distance to the target and shrinks with every shot at the same
+ * target, down to a floor, so they close in on you instead of starting perfect.
+ *
+ *   angle   standard deviation of the angle error, degrees, at middle distance
+ *   power   standard deviation of the power error, as a fraction of the power
+ *   learn   how much of the error each earlier shot at this target removes
+ *   floor   the least of the error that remains, however many shots
+ *
+ * Tuned by simulation to first-shot hit rates of about 5% Moron and Tosser, 25-30% Shooter and
+ * Poolshark, 40% Chooser and 85% Spoiler and Cyborg (test/scorched.test.js holds the bands).
+ */
+export const AIM = Object.freeze({
+  shooter:   Object.freeze({ angle: 3.5, power: 0.07, learn: 0.22, floor: 0.35 }),
+  poolshark: Object.freeze({ angle: 3.5, power: 0.07, learn: 0.22, floor: 0.35 }),
+  chooser:   Object.freeze({ angle: 2.9, power: 0.055, learn: 0.25, floor: 0.3 }),
+  spoiler:   Object.freeze({ angle: 0.5, power: 0.008, learn: 0.3, floor: 0.4 }),
+});
+function gauss(rnd) {
+  let u = 0;
+  while (u === 0) u = rnd();
+  return Math.sqrt(-2 * Math.log(u)) * Math.cos(2 * Math.PI * rnd());
+}
+/** `shot` as this tank would really fire it at `target`, with its personality's error; counts the shot. */
+export function aimed(g, tank, target, shot, profile, rnd = g.rnd) {
+  if (!profile) return shot;
+  const dist = Math.abs(centreX(target) - centreX(tank)) / COLS;               // 0 .. 1
+  const before = tank.aimAt?.target === target.id ? tank.aimAt.shots : 0;
+  tank.aimAt = { target: target.id, shots: before + 1 };
+  const scale = (0.5 + dist) * Math.max(profile.floor, 1 - profile.learn * before);
+  const angle = Math.max(0, Math.min(180, shot.angle + gauss(rnd) * profile.angle * scale));
+  const power = Math.max(50, Math.min(1000, Math.round(shot.power * (1 + gauss(rnd) * profile.power * scale))));
+  return { ...shot, angle, power };
+}
+
 // ------------------------------------------------------------------- the personalities
 /** The Moron: "pick an angle and power, and shoot". Whatever it happens to own. */
 export function moron(g, tank, rnd = g.rnd) {
@@ -98,7 +140,7 @@ export function shooter(g, tank, rnd = g.rnd) {
   if (!target) return moron(g, tank, rnd);
   const best = solve(g, tank, target, [12, 20, 28, 36], 25);
   if (!best || best.miss > 12) return { ...moron(g, tank, rnd), weapon: 'babyMissile', fallback: true };   // no line of fire: a Moron's shot
-  return { angle: best.angle, power: best.power, weapon: pickWeapon(tank, target, { thrifty: best.miss > 4 }) };
+  return aimed(g, tank, target, { angle: best.angle, power: best.power, weapon: pickWeapon(tank, target, { thrifty: best.miss > 4 }) }, AIM.shooter, rnd);
 }
 
 /** The Poolshark: a Shooter, unless the walls rebound -- then it looks for the bank shot as well. */
@@ -111,7 +153,7 @@ export function poolshark(g, tank, rnd = g.rnd) {
   const bank = solve(g, tank, target, [110, 125, 140, 155], 25);
   const best = [direct, bank].filter(Boolean).sort((a, b) => a.miss - b.miss)[0];
   if (!best || best.miss > 12) return { ...moron(g, tank, rnd), weapon: 'babyMissile', fallback: true };
-  return { angle: best.angle, power: best.power, weapon: pickWeapon(tank, target, { thrifty: best.miss > 4 }) };
+  return aimed(g, tank, target, { angle: best.angle, power: best.power, weapon: pickWeapon(tank, target, { thrifty: best.miss > 4 }) }, AIM.poolshark, rnd);
 }
 
 /**
@@ -147,7 +189,7 @@ export function chooser(g, tank, rnd = g.rnd) {
   const bank = (g.walls === 'rubber' || g.walls === 'spring') ? solve(g, tank, target, [115, 135, 155], 25) : null;
   const best = [low, lob, bank].filter(Boolean).sort((a, b) => a.miss - b.miss)[0];
   if (!best) return moron(g, tank, rnd);
-  return { angle: best.angle, power: best.power, weapon: pickWeapon(tank, target) };
+  return aimed(g, tank, target, { angle: best.angle, power: best.power, weapon: pickWeapon(tank, target) }, AIM.chooser, rnd);
 }
 
 /** The Spoiler: "taking into account the wind factor and gravity, they will get a perfect shot almost every time". */
@@ -156,9 +198,8 @@ export function spoiler(g, tank, rnd = g.rnd, target = nearest(g, tank)) {
   const coarse = solve(g, tank, target, [15, 25, 35, 45, 55, 65, 75], 20);
   const best = coarse ? refine(g, tank, target, coarse) : null;
   if (!best) return moron(g, tank, rnd);
-  // "almost": a degree or two of error, drawn from the game's own stream
-  const wobble = rnd() < 0.15 ? (rnd() - 0.5) * 4 : 0;
-  return { angle: Math.max(0, Math.min(180, best.angle + wobble)), power: best.power, weapon: pickWeapon(tank, target) };
+  // "almost": a small error, drawn from the game's own stream, that tightens as it keeps firing at you
+  return aimed(g, tank, target, { angle: best.angle, power: best.power, weapon: pickWeapon(tank, target) }, AIM.spoiler, rnd);
 }
 
 /** The Cyborg: a Spoiler that "attacks tanks who are weakened, winning, or have attacked them". */

package/public/js/scorchedyard.js

@@ -14,7 +14,7 @@ import { paintRipple, skyBrightness } from './scorchedwind.js';
 import { makeFluid, stepFluid, setSolid, warmFluid, makeTracers, stepTracers, paintTracers } from './scorchedair.js';
 import {
   newGame, current, aim, fire, step, settled, nextRound, cycleWeapon, useItem, drive, landTiles, actorTiles, leader, buy,
-  trajectory, dirtAt, shellLook, simulateShot,
+  trajectory, dirtAt, shellLook, simulateShot, colourFor,
   WEAPONS, WEAPON_ORDER, ITEMS, COLS, ROWS, TANK_W,
 } from './scorched.js';
 import { SHOP } from './scorchedshop.js';
@@ -605,11 +605,21 @@ function drawTanks() {
   if (!box) return;
   const html = g ? g.tanks.map((t) => {
     const cur = g.phase !== 'over' && current(g) === t;
-    return `<div class="sytank${t.alive ? '' : ' dead'}${cur ? ' now' : ''}"><i class="sydot sydot-${t.id}"></i><b>${t.name}</b>`
+    return `<div class="sytank${t.alive ? '' : ' dead'}${cur ? ' now' : ''}"><i class="sydot" data-tank="${t.id}"></i><b>${t.name}</b>`
       + `<meter min="0" max="100" low="34" high="67" optimum="100" value="${t.health}" title="${t.health} health"></meter>`
       + `<span>${t.alive ? `${t.health}${t.shield ? '🛡' : ''}` : '☠'}</span><small>${t.score} pts · ${t.kills} kills · ${money(t.cash)}</small></div>`;
   }).join('') : '';
   setHtml(box, html, 'tanks');
+  // THE DOT IS THE TANK'S OWN COLOUR (operator, 2026-09-17, with a capture: the red Spoiler listed
+  // with a blue dot). The CSP forbids a style attribute in markup, so the colour was a class per
+  // SEAT, which kept painting the seat's old colour once colours followed the personality. The
+  // CSSOM is allowed, and it is the tank's colour whatever seat it sits in.
+  if (g && box.querySelectorAll) {
+    for (const dot of box.querySelectorAll('.sydot[data-tank]')) {
+      const colour = g.tanks[Number(dot.dataset.tank)]?.colour;
+      if (colour && dot.dataset.colour !== colour) { dot.style?.setProperty?.('background-color', colour); dot.dataset.colour = colour; }
+    }
+  }
 }
 
 function drawScores(highlightAt = null) {
@@ -902,8 +912,14 @@ function frame(t) {
   if (g.phase !== 'over') G.raf = requestAnimationFrame(frame);
 }
 
-// THE OPPONENTS (M3): a mix climbs from the easy ones -- Shooter, Tosser, Chooser, Spoiler,
-// Cyborg -- or every seat the one kind the setting names. Named for what they are, the manual's way.
+// THE OPPONENTS (M3): a mix of the manual's personalities, or every seat the one kind the setting
+// names. Named for what they are, the manual's way.
+//
+// THE MIX IS SHUFFLED EACH GAME (operator, 2026-09-17: "the enemies I play against in Scorched Yard
+// are always the same and never randomized"). It used to fill the seats from this list in order, so
+// the shipped two opponents were a Shooter and a Tosser in every game ever played. Now each new game
+// deals the six in a fresh order: the first seats get six different kinds, and a table bigger than
+// the pool deals again from a new shuffle.
 const MIX = ['shooter', 'tosser', 'chooser', 'spoiler', 'cyborg', 'poolshark'];
 const NAMES = { moron: 'Moron', shooter: 'Shooter', poolshark: 'Poolshark', tosser: 'Tosser', chooser: 'Chooser', spoiler: 'Spoiler', cyborg: 'Cyborg', unknown: 'Unknown' };
 /**
@@ -911,14 +927,21 @@ const NAMES = { moron: 'Moron', shooter: 'Shooter', poolshark: 'Poolshark', toss
  * taken by another computer player, so the war plays itself on a wall. Everything else is the
  * same game: the same shop, the same rounds, the same rules.
  */
-export function players(t = scorchedOptions(loadSettings())) {
-  const list = t.demo ? [] : [{ name: 'You', kind: 'human' }];
+export function shuffled(list, rnd = Math.random) {
+  const a = list.slice();
+  for (let i = a.length - 1; i > 0; i--) { const j = Math.floor(rnd() * (i + 1)); [a[i], a[j]] = [a[j], a[i]]; }
+  return a;
+}
+export function players(t = scorchedOptions(loadSettings()), rnd = Math.random) {
+  const list = t.demo ? [] : [{ name: 'You', kind: 'human', colour: colourFor('human') }];
   const seen = {};
   const seats = t.opponents + (t.demo ? 1 : 0);
+  let deck = [];
   for (let i = 0; i < seats; i++) {
-    const kind = t.opponentKind === 'mix' ? MIX[i % MIX.length] : t.opponentKind;
+    if (t.opponentKind === 'mix' && deck.length === 0) deck = shuffled(MIX, rnd);
+    const kind = t.opponentKind === 'mix' ? deck.shift() : t.opponentKind;
     seen[kind] = (seen[kind] ?? 0) + 1;
-    list.push({ name: seen[kind] > 1 ? `${NAMES[kind] ?? kind} ${seen[kind]}` : (NAMES[kind] ?? kind), kind });
+    list.push({ name: seen[kind] > 1 ? `${NAMES[kind] ?? kind} ${seen[kind]}` : (NAMES[kind] ?? kind), kind, colour: colourFor(kind, seen[kind]) });
   }
   return list;
 }

package/public/js/settings.js

@@ -315,7 +315,7 @@ export const DEFAULTS = Object.freeze({
     gridColour: '#2a5a8f',
     gridBrightness: 1,
     opponents: 2,         // computer players against the one human; up to seven, for the original's eight seats
-    opponentKind: 'mix',  // 'mix' (Shooter, Tosser, Chooser, Spoiler, Cyborg, Poolshark in turn) or one of the manual's eight
+    opponentKind: 'mix',  // 'mix' (Shooter, Tosser, Chooser, Spoiler, Cyborg and Poolshark, shuffled each game) or one of the manual's eight
     rounds: 5,
     walls: 'none',        // the manual's default: 'none' | 'concrete' | 'padded' | 'rubber' | 'spring' | 'wrap'
     wind: 'round',        // 'round' (one wind a round, the shipped mode) | 'turn' | 'shot' | 'none'
@@ -705,7 +705,7 @@ const PANEL_GROUPS = Object.freeze([
       Object.freeze({ key: 'gridBrightness', label: 'Grid intensity', kind: 'range', min: 0, max: 2, step: 0.05, hint: 'How strongly the grid shows; 0 hides it' }),
       Object.freeze({ key: 'opponents', label: 'Computer players', kind: 'range', min: 1, max: 7, step: 1, hint: 'How many tanks the computer fields against you. Two is the shipped game; seven fills the original\u2019s eight seats' }),
       Object.freeze({
-        key: 'opponentKind', label: 'Their kind', kind: 'choice', hint: 'The manual\u2019s personalities: a mix climbs from the easy ones, or every seat the one you name. Moron fires at random; Shooter takes straight shots; Poolshark banks off rubber walls; Tosser lobs and corrects; Chooser picks its method; Spoiler nearly never misses; Cyborg is a Spoiler with a grudge; Unknown is one of them, drawn each round',
+        key: 'opponentKind', label: 'Their kind', kind: 'choice', hint: 'The manual\u2019s personalities: a mix dealt in a new order every game, or every seat the one you name. Moron fires at random; Shooter takes straight shots; Poolshark banks off rubber walls; Tosser lobs and corrects; Chooser picks its method; Spoiler nearly never misses; Cyborg is a Spoiler with a grudge; Unknown is one of them, drawn each round',
         options: Object.freeze([['mix', 'A mix'], ['moron', 'Morons'], ['shooter', 'Shooters'], ['poolshark', 'Poolsharks'], ['tosser', 'Tossers'], ['chooser', 'Choosers'], ['spoiler', 'Spoilers'], ['cyborg', 'Cyborgs'], ['unknown', 'Unknowns']]),
       }),
       Object.freeze({ key: 'rounds', label: 'Rounds', kind: 'range', min: 1, max: 10, step: 1, hint: 'A game is this many rounds; the highest score at the end wins' }),

package/scripts/shots.mjs

@@ -243,6 +243,12 @@ if (doing('scorched')) {
     await metrics(1000);
     await evl(`document.getElementById('syResume')?.click()`);
     await sleep(1500);
+    // A DAYTIME ROUND (2026-09-17). Each round draws its sky hour from the seed (scorchedyard.js
+    // ROUND_HOURS[(seed + round*7) % 8]), so a shot taken at whatever the seed gave was as likely
+    // night as day; the Earth sky's sun, clouds and the wind's flow lines read best at 15:00 (index 3).
+    // The land is already generated, so only the sky's hour follows the new seed.
+    await evl(`import('/js/scorchedyard.js').then((m) => { const g = m.currentGame(); if (g) g.seed = g.seed - ((g.seed + g.round * 7) % 8 + 8) % 8 + 3; })`);
+    await sleep(2500);
     await evl(`import('/js/scorchedyard.js').then(async (m) => { const g = m.currentGame(); const t = g.tanks[0]; const ai = await import('/js/scorchedai.js'); const target = ai.nearest(g, t); t.inventory.nuke = 1; t.weapon = 'nuke'; const s = ai.spoiler(g, t, () => 0.9, target); t.angle = s.angle; t.power = s.power; })`);
     await sleep(300);
     await evl(`document.getElementById('syFire')?.click()`);