Manhattan Distance on Amiga | Pattern Library

On a four-way grid, distance is the horizontal gap plus the vertical gap. That makes a useful cheap measure for a guard choosing a nearby target, or a turn-based game showing a movement budget. Two byte coordinates can produce a result larger than a byte.

Amiga shows the working result 00 00 FF FF FE 01 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 AX, AY, BX, BY, DIST_LO, DIST_HI as 6 contiguous private bytes in that order. Include the helper once. Call manhattan_distance_init at the deliberate reset boundary: it clears all named bytes, including inputs. Set your starting values afterwards. Call manhattan_distance_step when this service is needed.

Fill both coordinate pairs and call step when the decision needs the distance. Compare both result bytes when selecting a threshold or nearest target. Ties need a separate stable rule. Reusing one scratch block for successive independent queries is safe under a single owner.

AX/AY and BX/BY are unsigned coordinates from 0–255. Step preserves all four inputs and writes DIST_LO/DIST_HI as a little-endian result |AX − BX| + |AY − BY|, from 0–510. A wider result is needed even though each coordinate fits in one byte.

Reusable initialisation and service

component.inc

; SPDX-License-Identifier: MIT
; Manhattan Distance. Bind these contiguous private bytes: AX, AY, BX, BY, DIST_LO, DIST_HI.
; init clears the whole block; step uses current inputs. No I/O, waits or IRQ owner.
; D0-D3/A0-A1/CCR may change; D4-D7/A2-A6 survive.
manhattan_distance_init:
    clr.b AX
    clr.b AY
    clr.b BX
    clr.b BY
    clr.b DIST_LO
    clr.b DIST_HI
    rts
manhattan_distance_step:
    moveq #0,d0
    move.b AX,d0
    moveq #0,d1
    move.b BX,d1
    sub.w d1,d0
    bpl.s distance_x
    neg.w d0
distance_x:
    moveq #0,d1
    move.b AY,d1
    moveq #0,d2
    move.b BY,d2
    sub.w d2,d1
    bpl.s distance_y
    neg.w d1
distance_y:
    add.w d1,d0
    move.b d0,DIST_LO
    lsr.w #8,d0
    move.b d0,DIST_HI
    rts
component_end:

State and ownership

Four input bytes and a two-byte output. There is no map, actor state or movement inside this helper. Byte order is explicit on every target, including 68000.

D0–D3/A0–A1/CCR may change; D4–D7/A2–A6 survive. A direct BSR/JSR uses four return-address stack bytes. The program is a 68000 implementation with no division instruction requirement.

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 boot program takes over Copper/bitplane/interrupt/DMA resources, explicitly disarms all eight sprites, and does not restore Workbench. Those are diagnostic presentation choices; the helper itself owns no chipset 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

    section code,code_c
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"
    include "display.inc"
    include "../turn-deadline/font.inc"
code_end:
STATE:
AX: dc.b 0
AY: dc.b 0
BX: dc.b 0
BY: dc.b 0
DIST_LO: dc.b 0
DIST_HI: dc.b 0
    even
ready: dc.w 0
preview: dcb.b 8,0
OUTPUT: dcb.b 1300,0
    even
signature: dc.b "198XGAMEPLAY000",0
    even
copperlist:
    dc.w $08e,$2c81,$090,$2cc1,$092,$0038,$094,$00d0
    dc.w $100,$1200,$102,0,$104,0,$108,0,$10a,0
    dc.w $180,$012,$182,$fff
copbpl:
    dc.w $0e0,0,$0e2,0
    dc.w $ffff,$fffe
plane: dcb.b 10240,0

A separate client retaining state between calls

exercise.inc, excerpt

preview_rules:
    ifne CUSTOM
    move.b #0,AX
    move.b #0,AY
    move.b #200,BX
    move.b #255,BY
    ifne BROKEN
    bsr checked_step
    move.b #0,DIST_HI
    else
    bsr checked_step
    endif
    bsr emit_state
    else
    move.b #0,AX
    move.b #0,AY
    move.b #255,BX
    move.b #255,BY
    ifne BROKEN
    bsr checked_step
    move.b #0,DIST_HI
    else
    bsr checked_step
    endif
    bsr emit_state
    endif
    rts

The eight display fields follow AX, AY, BX, BY, DIST_LO, DIST_HI; unused display fields are zero. Each field is a hexadecimal byte. The working row is 00 00 FF FF FE 01 00 00. The output is a completed diagnostic state, not a recording of movement, input or sound hardware.

Make it your own

The custom query moves BX from 255 to 200 while BY stays 255 and A remains at the origin. The result is 455, encoded C7 01, rather than 510, encoded FE 01.

Maintained custom configuration or caller

custom.asm

    section code,code_c
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"
    include "display.inc"
    include "../turn-deadline/font.inc"
code_end:
STATE:
AX: dc.b 0
AY: dc.b 0
BX: dc.b 0
BY: dc.b 0
DIST_LO: dc.b 0
DIST_HI: dc.b 0
    even
ready: dc.w 0
preview: dcb.b 8,0
OUTPUT: dcb.b 1300,0
    even
signature: dc.b "198XGAMEPLAY000",0
    even
copperlist:
    dc.w $08e,$2c81,$090,$2cc1,$092,$0038,$094,$00d0
    dc.w $100,$1200,$102,0,$104,0,$108,0,$10a,0
    dc.w $180,$012,$182,$fff
copbpl:
    dc.w $0e0,0,$0e2,0
    dc.w $ffff,$fffe
plane: dcb.b 10240,0

The observed custom row is 00 00 C8 FF C7 01 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 discards DIST_HI after computing the distance. The opposite corners now look 254 units apart rather than 510. Keep the carry byte through both the storage and comparison paths.

Deliberately wrong client selection

wrong.asm

    section code,code_c
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"
    include "display.inc"
    include "../turn-deadline/font.inc"
code_end:
STATE:
AX: dc.b 0
AY: dc.b 0
BX: dc.b 0
BY: dc.b 0
DIST_LO: dc.b 0
DIST_HI: dc.b 0
    even
ready: dc.w 0
preview: dcb.b 8,0
OUTPUT: dcb.b 1300,0
    even
signature: dc.b "198XGAMEPLAY000",0
    even
copperlist:
    dc.w $08e,$2c81,$090,$2cc1,$092,$0038,$094,$00d0
    dc.w $100,$1200,$102,0,$104,0,$108,0,$10a,0
    dc.w $180,$012,$182,$fff
copbpl:
    dc.w $0e0,0,$0e2,0
    dc.w $ffff,$fffe
plane: dcb.b 10240,0

Amiga shows the deliberate fault result 00 00 FF FF FE 00 00 00. — The wrong client completes and records 00 00 FF FF FE 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 92 code bytes plus 6 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.

Two absolute differences and one wide sum, with no multiply or square root. That makes the result cheap for grid decisions, but it does not make it an interchangeable estimate for every movement model.

This is the shortest distance on an unobstructed four-way grid. Walls can make the actual route longer or unreachable. Eight-way movement may call for Chebyshev or octile distance; Euclidean movement needs a different metric. Wider or signed coordinates need wider differences before taking absolute values.

Four native runs use A500 OCS PAL with Kickstart 1.3 and an OFS boot disk; Asm198x 0.0.72 and Emu198x 0.44.2, with Build198x 0.2.9 for disk mastering. 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.

Source and native evidence.