Everything that moves in Ant Attack -- the player, the person to be rescued, the grenade and the ants -- is moved by one routine, MOVE_OBJECT, reached through MOVE_OR_RESPAWN. Positions are whole cells and whole blocks: a step is a cell and a drop is a block, one a frame, and there is nothing in between. This page sets out the record, what counts as solid, and the order in which MOVE_OBJECT decides what an object does, then runs the game's own code on a set of situations to show what it makes of each.

The record

Eight records of 16 bytes at PLAYER, in the order GAME_FRAME (GAME_FRAME) moves them after the player: the rescued person (MOVE_RESCUEE), the grenade (MOVE_GRENADE), the five ants (MOVE_ANTS). BASIC fills them at the start of every level from the DATA in lines 110 to 180, and these are the values it sets, read from the program as it loads (a dash is -1 in the DATA: that byte is left alone):

• Flags, +$07: bit 0 may stand on the other person (the player and the rescued person each have it), bit 1 jump and bit 2 move (set from the keys for the player, by FOLLOW_PLAYER for the rescued person and at the throw for the grenade; the ants have bit 2 set for good), bit 3 never falls (no one has it, and nothing sets it), bit 4 steps up a one-block rise by itself.
• The explosion countdown at +$09 starts at 1 for the player, the grenade and the ants: on the first frame each goes home, to +$0A to +$0C. That is how the player starts at the gate and the ants in their nest.
• The two people's first frames are left alone by the DATA: lines 610 and 620 poke them once, when the boy or the girl is chosen ($DC for the boy, $6C for the girl), and the other one is the person to be rescued.
• +$0D and +$0E are the ants' speed and count (see the ants) and the rescued person's state and last distance (see the rescue).

What is solid

Only the map. TEST_MAP_BIT answers whether a cell has a block at a height, and everything asks it. The people are not in the map, so nothing collides with them; the ants are, put there by TOGGLE_MAP_BIT, so everything collides with the ants. Its answers, run on a cell with blocks at heights 0 and 2 inside the walls, and on a cell outside:

Height -1 is always solid, which is what the ground is; 6, one above the tallest block, is always empty; 7 and above are solid, a ceiling no jump gets through. Outside the walls, with x or y below $80, there is nothing but the ground.

One frame of MOVE_OBJECT

The questions are asked in this order, and the first that applies decides the frame:

1. Anything to stand on? TEST_BELOW asks about the height below. If not, FALL: count a frame of falling at +$05; on the first frame the object may still walk -- the grace frame -- and after that it drops a block a frame.
2. Something in its own cell? Only an ant can have walked in: bitten (BITTEN), and RISE pushes the object up a block.
3. Stunned? Count the stun down (STUNNED), clear the fall count, and do nothing else.
4. Just landed? A fall count of 2 or more means it was falling last frame: LANDED.
5. Jump? Bit 1: RISE goes up a block if the cell above is free, and otherwise carries on as a walk.
6. Walk? Bit 2: the next cell the way it faces (STEP), at its own height. Free: step there, and an event of 1 for the click. Blocked: STEP_UP, which for an object with bit 4 rises a block in its own cell if there is room, to walk on next frame.

The player's keys are read into the flags first (READ_CONTROLS): V is bit 2 and C bit 1, every frame, so they act only while held. SYMBOL SHIFT and M turn a quarter each frame they are held -- not while stunned. And after the move, CHOOSE_FRAME picks the picture from the state: the blast, lying down for a long stun, arms out for a short one, arms up falling, legs moving walking.

The code, tried

Each row is a situation built on a patch of open ground inside the walls, with the ants moved out of the way, and then left to the game: the frames are the game's own, run in the simulator when this page was built, and read after each frame's drawing (before the events are cleared). Positions are cells along the way the one followed faces, from where it started, and heights.

Climbing a one-block wall with V and C held, a frame a picture: up, onto the wall, up again, forward into the air, and down.

An ant walks into the player's cell: the frame after, he is bitten and pushed up a block, and then drops back.

The rescued person following the player up a step on her own.

Falls

A fall is counted in frames at +$05, the grace frame included, so a drop of n blocks is n + 1 frames. LANDED makes it a step if it was under five frames, and stuns for as many frames as it lasted; five or more is a bad fall -- “NASTY FALL !” for the player, “HELP! I FELL!” for the rescued person (HANDLE_EVENTS) -- and stuns for eight frames for every frame of it. So four blocks is the most that is safe to drop. The expected figures are worked out from those rules; the others are what the game did, dropping the player from each height over open ground:

Every figure is as expected. A stunned person does nothing at all, and at six or seven frames a second a six-block fall costs the player the best part of ten seconds. A short fall is not quite free either: every landing, even from a jump, stuns for two frames or more.

Two ways out of a landing, both in the table above. A fall that ends while the stun count is still running is never landed: the stunned branch comes before the landing and clears the fall count. And two people in one cell a block apart are never falling: SHARE_CELL, run every frame for the rescued person once she follows, clears the player's fall count and both stuns. BASIC starts the rescued person stunned for four frames, enough to swallow a short drop. A landing at height 1 has one more job: it may be on an ant's back, and PARALYSE_ANT looks for one (see the ants).

Standing on each other

Bit 0 of the flags lets TEST_BELOW count the other person -- the one IY points at, which for the player is the rescued person and the other way round -- as something to stand on, if they are exactly one block below in the same cell. That is all: nothing carries anyone. Walk out from under someone and they are left standing on air, and fall; walk off someone's head and you fall. The rescued person in the player's own cell is handled by ON_TOP: on top of him she takes his facing and walks on, underneath she stops.

What is confirmed and what is inferred

• Confirmed by running: every row of the tables above -- the situations, the falls, TEST_MAP_BIT's answers -- is the game's code run in the simulator on a staged scene. The staging is the starting positions and the walls; the rest is the game.
• Read from the code: the order of the questions in MOVE_OBJECT, and the fields of the record. The DATA values are read from the BASIC as loaded.
• Not run: bit 3 of the flags, never falls. Nothing in the game or its BASIC sets it, so the three instructions behind it in FALL have never been seen to run; what they would do is read from the code (clear the fall count and carry on as if standing).