# Convoy route investigation: 04_009 / 7 (level 80)

Objects 6–17 fan out onto translated paths rather than following one convoy
route. **Retail playtesting confirms both the unusual movement and vehicles
driving through solid buildings, sometimes drawing over them.** This is an
original-game defect, not evidence that the route decoder needs road snapping.
Complete trajectories and predicted off-map endpoints remain unverified. The
viewer retains the decoded routes and identifies the remaining uncertainty.

## What was checked

The [reproducible audit](../analysis/missions/convoy-route-audit.json) checks:

- Original `BE07` setup constructs all 17 routed vehicles with the exported positions, headings and route pointers. Their initial repeat state is zero and time field is F000h, matching the preview's initialisation.
- The original image and saved DOSBox memory capture agree byte-for-byte across `8F3B–924F`, covering the interpreter, action table and movement/effect handlers. This excludes a mismatch against that captured version, not later mission-specific changes.
- Sampling at 256 and 512 ticks gives the same first vehicle's operation sequence and endpoint. This is not an arrow-density or coarse-sampling problem.
- The existing Wrecker and first-flatbed checks still pass; they do not validate this convoy's live behaviour.

At resource offset **42B5**, the source stream begins:

```
C1 B1 A1 71 61 51 41 31 21 11 01 F1 03 ...
```

Vehicles 6–17 enter at successive bytes in this prefix. Their starting rows are 62, 63, 64, 67, 68, 69, 70, 71, 72, 73, 74 and 75, all in column 22 heading south. In isolated execution, vehicle 6 consumes C1 for 13 cells, then B1 for another 12, then A1 for another 11, and so on. The first three fetches occur at ticks 0, 53,248 and 102,400. Its final predicted position is (62.5,159), outside the city. Later vehicles skip increasing portions of that cumulative prefix, hence the fan of translated routes.

The data has a suggestive pattern: each vehicle's initial forward count alone brings it to row 75, and F1 would then move all of them through a common 16-cell section. This is evidence of a possible intended convergence, **not evidence that we should skip the intermediate bytes**. The inspected native interpreter advances its saved pointer one byte per fetched instruction and does not perform that skip. Introducing one in the exporter would currently be an unsupported correction.

Vehicles 18–22 use other shared entries and converge to the same predicted endpoint, approximately (66.496,95.996). That does not independently prove their live paths, but localises the conspicuous discrepancy to the earlier shared prefix.

## Live DOSBox checks (5 October 2026)

Four controlled starts reached this mission in a temporary game copy. The
[capture notes](../analysis/missions/convoy-live/README.md) describe the debugger
interventions and failures; the [decoded dumps](../analysis/missions/convoy-live/captures.json)
retain the object fields and memory hashes.

- At the first vehicle callback, the loaded prefix is still `C1 B1 A1 ...` and
  `8F3B–924F` still matches the unpacked executable. The first truck is at
  `(22.5,62.5)`, heading `8000h`, with next-route pointer `F136h`, action zero
  and phase start `F000h`.
- The first fetch advances its route pointer to `F137h` (resource `42B6`),
  consistent with reading `C1`. Captures at `8F78` precede storing the fetched
  action, so their action byte is **still zero**, not a completed run.
- Attempts then became unstable, logging illegal instructions or unhandled
  interrupt 1 repeatedly. Removing memory watchpoints did not prevent this.
  No reliable second fetch or long-running vehicle position was captured.

This establishes that the suspicious prefix survives loading and is entered
as predicted. It does **not** establish that `B1` is subsequently executed,
or that any vehicle actually leaves the map. The startup shortcuts are also
an unresolved source of interference; these failures are not evidence of a
bug in normal gameplay.

## Retail playtest follow-up (8 October 2026)

We observed the level-80 convoy in the original game and confirmed that its
initial movement follows the unusual plotted routes. Further playtesting
confirmed that the vehicles drive through solid buildings and can remain visible
through them because of drawing order. The bad route therefore affects both
physical placement and visible overlap in retail.

Together with the shared-prefix pattern, this strongly suggests an authoring
mistake: the staggered vehicles were intended to join a single convoy path, but
instead accumulate the preceding vehicles' forward runs. That intended path is
an inference; the observed building traversal and overdraw are confirmed.

The faithful reconstruction must retain the original route interpreter and data,
including these defects. Any corrected convoy route belongs to a separately
labelled optional fix, not the baseline or the analysis route preview.

Behaviour after leaving the map area has **not** yet been confirmed. These
observations do not validate every plotted segment or predicted endpoint; the
viewer warning now distinguishes those limits from the confirmed retail bug.

Previous native checks established behaviour of an isolated interpreter with stated substitutions. They were insufficient evidence to call every plotted route faithful to the complete game.

```sh
PYTHONPATH=/tmp/darker-python python3 tools/audit_convoy_routes.py
```