An aimed shot keeps its direction: the scatter can push it wider, never back past centre

Second round on the service-line flick report. The crossing-fired swing
alone did not move the feel, and Oliver's sharpened observation — the
flick only lands left when the opponent already stands left — pointed at
a magnet that does not exist: measured with the body teleported at
contact, the aim never tracks it. The real mechanism: at rushed quality
the symmetric scatter (aimError x (1-q)) outweighs the quality-shrunk
aim, so a mistimed left flick landed anywhere in a ~4 m blob around
'slightly left' — usually centre — and the eye anchors that on the
opponent. Its position was a proxy for preparation time all along.

TUNE.aimTrust: an outward scatter roll is untouched — the committed
swipe's chance of sailing keeps its exact tuned shape, flickReach stays
the only out dial — but an inward roll keeps only 0.3 of itself. Bad
timing costs width, never direction. Player lane shots only; the
opponent's symmetric scatter is its width mechanic. Verified at
worst-case q~0.08: 14/14 rushed left flicks landed left, 9/9 right
flicks right, where before it was a coin toss. The suite pins the
direction guarantee and the aimTrust/aimError/flickReach relationship.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

src/config.js

@@ -64,6 +64,14 @@ export const TUNE = {
                            // send the ball longer — solveShot still lands it on the same spot — it
                            // gets there flatter and sooner, which is what a smash is.
   aimError: 2.4,           // m of scatter at quality 0
+  aimTrust: 0.3,           // an aimed rally shot TRUSTS its flick: the scatter may still push the
+                           // ball further OUT (the chosen out-risk keeps its exact shape) but only
+                           // this fraction of an INWARD roll survives, so a mistimed left flick
+                           // lands SHORTER LEFT rather than center-or-right "wherever the dice
+                           // said". Player's lane shots only — the opponent's symmetric scatter is
+                           // its width mechanic, and the gore free-aim never used lanes. Must stay
+                           // under 0.5*flickWidth*flickReach/aimError (~0.43) or a committed
+                           // mistimed swipe can cross back past centre (pinned by the suite).
   // NOT `aimReach` — that name is taken further down by the slingshot's aim-ray LENGTH (22 m), and
   // the duplicate key silently won: every aimed shot reached 22x its width until a test caught it.
   flickWidth: 3.95,        // m off centre a PERFECTLY timed flick reaches. The singles line is 4.115,

src/gameplay.js

@@ -178,7 +178,18 @@ function doHit(ch, quality, aim) {
     // it just stops being a coin toss you are punished for calling.
     const reach = ch.side === 'P' ? TUNE.flickReach + (1 - TUNE.flickReach) * quality : 1;
     sway = swayOf(aim);   // -1..1, continuous on touch — see swayOf
-    tx = sway * (toFar ? TUNE.flickWidth : 2.7) * reach + err();
+    // AN AIMED SHOT KEEPS ITS DIRECTION. The scatter used to be symmetric, and at rushed quality
+    // it was BIGGER than the quality-shrunk aim — a mistimed left flick landed anywhere in a 4 m
+    // blob around "slightly left", i.e. usually centre and sometimes right. It read as the ball
+    // landing wherever the opponent stood (2026-08-20, "trying to move the approaching ball with
+    // a flick to the left is almost impossible"). An OUTWARD roll is untouched — the committed
+    // swipe's chance of sailing wide is a chosen risk with a tuned shape (flickReach) and this
+    // must not soften it — but an inward roll now keeps only TUNE.aimTrust of itself, so bad
+    // timing costs WIDTH, never the direction that was asked for. Player only: the opponent's
+    // symmetric scatter is its width mechanic (matchWide clamps it, not this).
+    let e = err();
+    if (ch.side === 'P' && sway && e * Math.sign(sway) < 0) e *= TUNE.aimTrust;
+    tx = sway * (toFar ? TUNE.flickWidth : 2.7) * reach + e;
     const tzBase = aim.az < 0 ? SHOT_DEPTH.deep : aim.az > 0 ? SHOT_DEPTH.short : SHOT_DEPTH.mid;
     tz = (toFar ? tzBase : COURT.L - tzBase) + err() * 0.8;
     // A FORWARD FLICK IS A SMASH. Up-screen is the far court, so flicking INTO the court asked for