Code Like It's 198x

Approach a Target Without Overshoot on NES

An enemy can move towards a waypoint without orbiting it forever.

An enemy can move towards a waypoint without orbiting it forever. Move by the smaller of the remaining distance and your allowed step, then report arrival. That last short step matters when the target is not an exact multiple of the speed.

NES shows the working result FF FF 0A 01 00 00 00 00.
The completed native caller shows hexadecimal state bytes. The field order below explains the result; the full verification packet retains every call.

Include, initialise and call

Bind POSITION, TARGET, STEP, ARRIVED as 4 contiguous private bytes in that order. Include the helper once. Call approach_target_init at the deliberate reset boundary: it clears all named bytes, including inputs. Set your starting values afterwards. Call approach_target_step when this service is needed.

Initialise, then set the position, target and allowed step. Call once per simulation update. Change TARGET to follow a moving goal, or choose the next waypoint only after ARRIVED. Use another state block for the second axis if independent axis movement is the intended policy.

POSITION, TARGET and STEP are unsigned bytes. Step moves POSITION towards TARGET by at most STEP, without wrapping or overshooting, and replaces ARRIVED with 1 exactly when the resulting position equals TARGET. STEP zero stops movement but still reports an already reached target. TARGET and STEP survive.

Reusable initialisation and service

6502.inc
; SPDX-License-Identifier: MIT
; Approach a Target Without Overshoot. Bind these contiguous private bytes: POSITION, TARGET, STEP, ARRIVED.
; init clears the whole block; step uses current inputs. No I/O, waits or IRQ owner.
; A/X/flags may change; Y and decimal mode survive. Binary arithmetic requires D=0.
approach_target_init:
    lda #0
    sta POSITION
    sta TARGET
    sta STEP
    sta ARRIVED
    rts
approach_target_step:
    lda #0
    sta ARRIVED
    lda POSITION
    cmp TARGET
    beq approach_arrived
    bcc approach_up
    sec
    sbc TARGET
    cmp STEP
    bcc approach_snap
    beq approach_snap
    lda POSITION
    sec
    sbc STEP
    sta POSITION
    rts
approach_up:
    lda TARGET
    sec
    sbc POSITION
    cmp STEP
    bcc approach_snap
    beq approach_snap
    lda POSITION
    clc
    adc STEP
    sta POSITION
    rts
approach_snap:
    lda TARGET
    sta POSITION
approach_arrived:
    inc ARRIVED
    rts
component_end:

State and ownership

POSITION persists. TARGET and STEP are inputs. ARRIVED describes the resulting position and stays true on repeated calls at the target; it is not a one-time arrival event. Detect its edge if an action should occur only once.

A/X/flags may change; Y and decimal mode survive. Clear decimal mode before binary arithmetic; the standalone caller uses CLD. A direct call pushes a two-byte return address.

This implementation has fixed symbol bindings and one mutation owner. Independent users need distinct state blocks and scoped/renamed bindings; including another copy with the same global labels is not sufficient. Sequential queries may reuse a scratch block only after the previous result has been consumed. Do not let an interrupt and the main loop mutate the same block without a separately designed ownership policy.

The standalone cartridge owns its background, CHR font and RAM layout. Its diagnostic packet is bounded below the end of the NES’s 2 KiB internal RAM; the component owns no PPU or audio registers.

A small caller you can adapt

The standalone program includes the helper and a separate client. Its read-only table exercises 96 valid inputs, then this client initialises once and retains state between calls. Replace the supplied input changes with your own game values; the display and packet machinery are diagnostics rather than dependencies of the component.

Buildable caller, bindings and include order

demo.asm
.segment "HEADER"
.byte "NES",$1a,2,1,0,0,0,0,0,0,0,0,0,0
POSITION=$80
TARGET=$81
STEP=$82
ARRIVED=$83
STATE=$80
input_ptr=$70
cases_left=$72
ptr=$74
saved_y=$76
OUTPUT=$0200
preview=OUTPUT+1400
ready=OUTPUT+1408
CUSTOM=0
BROKEN=0
SCORE_CAP=65535
QUEUE_CAP=4
REPEAT_DELAY=4
REPEAT_RATE=2
.include "caller.inc"
.include "exercise.inc"
component_start:
.include "component.inc"
.include "cases.inc"
code_end:
.segment "VECTORS"
.word nmi,reset,irq
.segment "CHARS"
.include "../../input/controller-reading/edges-font.inc"
.res 8192-272,0

A separate client retaining state between calls

exercise.inc, excerpt
preview_rules:
.if CUSTOM
    lda #250
    sta POSITION
    lda #255
    sta TARGET
    lda #2
    sta STEP
.if BROKEN
    lda POSITION
    clc
    adc STEP
    sta POSITION
    lda #0
    sta ARRIVED
    lda POSITION
    cmp TARGET
    bne trace_bad_end_0_custom
    inc ARRIVED
trace_bad_end_0_custom:
.else
    jsr checked_step
.endif
    jsr emit_state
.if BROKEN
    lda POSITION
    clc
    adc STEP
    sta POSITION
    lda #0
    sta ARRIVED
    lda POSITION
    cmp TARGET
    bne trace_bad_end_1_custom
    inc ARRIVED
trace_bad_end_1_custom:
.else
    jsr checked_step
.endif
    jsr emit_state
.else
    lda #250
    sta POSITION
    lda #255
    sta TARGET
    lda #10
    sta STEP
.if BROKEN
    lda POSITION
    clc
    adc STEP
    sta POSITION
    lda #0
    sta ARRIVED
    lda POSITION
    cmp TARGET
    bne trace_bad_end_0
    inc ARRIVED
trace_bad_end_0:
.else
    jsr checked_step
.endif
    jsr emit_state
.if BROKEN
    lda POSITION
    clc
    adc STEP
    sta POSITION
    lda #0
    sta ARRIVED
    lda POSITION
    cmp TARGET
    bne trace_bad_end_1
    inc ARRIVED
trace_bad_end_1:
.else
    jsr checked_step
.endif
    jsr emit_state
.endif
    rts

The eight display fields follow POSITION, TARGET, STEP, ARRIVED; unused display fields are zero. Each field is a hexadecimal byte. The working row is FF FF 0A 01 00 00 00 00. The output is a completed diagnostic state, not a recording of movement, input or sound hardware.

Make it your own

The custom caller reduces STEP from ten to two. Starting at 250 with target 255, the two calls end at 254 without arrival; a later call would take the last one-unit step.

Maintained custom configuration or caller

custom.asm
.segment "HEADER"
.byte "NES",$1a,2,1,0,0,0,0,0,0,0,0,0,0
POSITION=$80
TARGET=$81
STEP=$82
ARRIVED=$83
STATE=$80
input_ptr=$70
cases_left=$72
ptr=$74
saved_y=$76
OUTPUT=$0200
preview=OUTPUT+1400
ready=OUTPUT+1408
CUSTOM=1
BROKEN=0
SCORE_CAP=999
QUEUE_CAP=2
REPEAT_DELAY=6
REPEAT_RATE=3
.include "caller.inc"
.include "exercise.inc"
component_start:
.include "component.inc"
.include "cases.inc"
code_end:
.segment "VECTORS"
.word nmi,reset,irq
.segment "CHARS"
.include "../../input/controller-reading/edges-font.inc"
.res 8192-272,0

The observed custom row is FE FF 02 00 00 00 00 00. The retained records qualify these named configurations; a new input domain or larger layout needs its own bounds and fresh execution checks.

Common mistake and repair

The wrong client replaces the helper with an unconditional byte addition. Starting at 250, adding ten wraps to 4, then 14, moving away from target 255. Compare the remaining distance before adding or subtracting; increasing the target tolerance does not fix byte overflow.

Deliberately wrong client selection

wrong.asm
.segment "HEADER"
.byte "NES",$1a,2,1,0,0,0,0,0,0,0,0,0,0
POSITION=$80
TARGET=$81
STEP=$82
ARRIVED=$83
STATE=$80
input_ptr=$70
cases_left=$72
ptr=$74
saved_y=$76
OUTPUT=$0200
preview=OUTPUT+1400
ready=OUTPUT+1408
CUSTOM=0
BROKEN=1
SCORE_CAP=65535
QUEUE_CAP=4
REPEAT_DELAY=4
REPEAT_RATE=2
.include "caller.inc"
.include "exercise.inc"
component_start:
.include "component.inc"
.include "cases.inc"
code_end:
.segment "VECTORS"
.word nmi,reset,irq
.segment "CHARS"
.include "../../input/controller-reading/edges-font.inc"
.res 8192-272,0
NES shows the deliberate fault result 0E FF 0A 00 00 00 00 00.
The wrong client completes and records 0E FF 0A 00 00 00 00 00. Compare its state with the working row and the explained failure.

The wrong branch is in the displayed client above, selected by BROKEN. repaired.asm selects the original client again. Its executable matches demo exactly; Spectrum tape filenames can differ while loaded CODE is identical. The bad caller is a labelled experiment, not an alternative recommended implementation.

Cost and verification

The measured helper occupies 66 code bytes plus 4 named state bytes in this layout. Return addresses, alignment, tables and display diagnostics are additional. The sizes cover init and step together, not the whole standalone program.

One comparison chooses direction, then a distance comparison chooses a full or short step. No multiplication, division or path search occurs. This is straight-axis pursuit, not obstacle-aware navigation.

Signed coordinates, wider worlds and fixed-point subpixels need wider arithmetic and explicit bounds. Moving both axes by the same maximum gives faster diagonal travel in Euclidean distance; normalisation or an axis budget is a separate movement policy. Collision may still block a proposed position.

Four native runs use NTSC NES with a mapper-0 cartridge, CHR-ROM diagnostic font, NMI and DMC disabled; Asm198x 0.0.72 and Emu198x 0.44.2. Every run checks 96 table results, dirty initialisation and every state in a separate sequential trace against an independent integer model. This is boundary/varied-input qualification, not exhaustive coverage of every byte combination. Source/tool/firmware hashes, native startup and completion, preserved-register sentinels, immutable loaded code, actual helper extent, capture bytes and pixels, and exact repair are checked. Deliberately changed observations must fail. Firmware is hashed, never distributed.

Related reusable technique · Maths for Games · The Craft.

Source and native evidence.