[jeany55]

Step 11 of the way off eudplib, part 3: unit events on a map of our own. The ledger's 15 rows of on.created,
on.died, on.killed, on.order and on.morphed are taken, so step 11 is done: 50 of 50. No row of another step
moved.

What it does

• The map's events pass runs once for the map, before every program's turn. It watches the game's unit places: a
  trigger for each place, whose conditions compare the place's record with what the trigger saw there last, held in
  its own conditions' numbers. That is the uniqueness byte, and, as the events need them, whether the unit is alive or
  which order it has, and its type.
• A place that hasn't changed costs that one trigger: its conditions hold, and its two actions put the trigger
  before it back and go on to the next. A place that changed goes through a stub of its own to the handler, laid out
  once. If the uniqueness byte differs and the unit is alive, a unit came on. If it was seen alive and isn't now, it
  died. If it took up another order or turned into another type, that is reported too. Then what it sees now goes back
  into the trigger's numbers.
• A place whose unit is dead or gone is watched by its uniqueness byte alone. The handler writes 0 into the kind of
  the second condition, and the game reads no further. That costs 48 ns a place, against 60 for a living unit.
• The places are walked newest first, as the simulator hands units on. The walk starts at the place the game will
  hand out next, goes up to 1,699, then does place 0. The game hands places out in that order, never-used ones last, so
  the starting point only moves down. When the handler sees that place handed out, the walk starts one further on from
  then on.
• A listener is a task that loops over what the pass found. A handler that waits starts a task for each unit.
• Replaced before this merge: the first commit walked the game's lists by their pointers, as eudplib's build does.
  It was slower than eudplib when units were dying (146 µs against 89) and with on.order (221 against 164). The table
  of plain dwords 336 bytes apart and pointAt went with it.
• Found on the way: an action whose number comes from a variable is found by its index in its trigger, and a write
  earlier in the same trigger moved it. A task's call (start) with a unit among its parameters was rewritten as an
  expression instead of as statements. An empty trigger whose next pointer gets written has to be kept.

Weighed (probes/own-events.ts, and the same probe without on.order; lifted game, Remastered's weights, µs a
frame)

	Ours	eudplib
nothing coming or going, on.order among the events	7.2	164
forty-six units dying, on.order among the events	9.0	224
forty units made / killed in a frame, on.order among the events	227 / 228	506 / 528
without on.order: forty-six units dying	8.7	89
without on.order: forty units made / killed in a frame	188 / 180	248 / 392
without on.order: nothing coming or going, about 80 places handed out	6.7	5.1
without on.order: the same, 128 places handed out	9.3	5.2
the first frame (the listeners started)	249	1,272
the map (CHK), on.order among the events / without	1.96 / 1.84 MB	1.78 / 1.27 MB

Still behind eudplib, listed in the plan's Open list

• Frames where nothing comes on and nothing is dying, without on.order. eudplib's build looks only at the heads
  of its lists then. The watch costs 48–60 ns for every place the game has handed out: 9.3 µs against 5.2 at 128
  places, and about 90 against 5 with the whole table in use. The way out is a gate that skips the watch when nothing
  can have changed: the head of the game's free list (it moves when a unit gets a place or one is freed) plus a count
  that moves when a unit starts to die. That has to be read in both games first, since Remastered links its lists
  differently.
• The map is larger: 1,700 places at two triggers each. A stub with fewer actions would pack tighter.
• The handler reads a changed place a bit at a time, about 4 µs for each unit made.

Checked

• tests/emitter.test.ts, "a map of our own, unit events": a unit table laid out as the game keeps it, changed between
  frames: a unit handed a place, an order taken up, a type changed, a unit dying in a fight, and its place handed to
  another unit. The payload is walked from its bytes frame after frame, each line checked at its frame. Also a handler
  that waits: a task each.
• Both probes built both ways in the lifted game: every line the same at the same frame, and "ok".
• Full suite: 1339 passed (72 files); the ledger unchanged (every row still takes). probes/own-tasks.ts and
  probes/own-errors.ts build byte for byte as before. The emitter's random-program tests take as long as before.

Played in Remastered: the first commit's map (recording 21.59.29): all 7 lines in order, each at the lifted game's
frame. To play: Maps/TrigScript/own-step11-events-watch.scx, the merged version, with its answer sheet.

🤖 Generated with Claude Code

https://claude.ai/code/session_01En4SHqafb1QFJ4xgbUkAe5