A key collected, a door unlocked, a conversation finished: eight yes/no facts fit in one byte. A mask lets you change one fact without erasing its neighbours, or ask whether a group of requirements has been met.
Include, initialise and call
Bind FLAGS, MASK, MODE, ALL_SET as 4 contiguous private bytes in that order. Include the helper once. Call quest_flags_init at the deliberate reset boundary: it clears all named bytes, including inputs. Set your starting values afterwards. Call quest_flags_step when this service is needed.
Initialise once for a fresh world. Assign a power-of-two mask to each independent fact: 1, 2, 4, 8 and so on. Use MODE 0 to query without changing the world. A combined mask such as 12 asks for bits 4 and 8 together; the result means all, not any.
FLAGS stores eight independent bits. MASK selects any subset of them. MODE 1 sets those bits, MODE 2 clears them; other modes only query. After the optional change, ALL_SET is 1 exactly when every bit in MASK is present in FLAGS. An empty mask is satisfied. MASK and MODE survive.
Reusable initialisation and service
; SPDX-License-Identifier: MIT
; Quest and Inventory Flags. Bind these contiguous private bytes: FLAGS, MASK, MODE, ALL_SET.
; 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.
quest_flags_init:
clr.b FLAGS
clr.b MASK
clr.b MODE
clr.b ALL_SET
rts
quest_flags_step:
move.b MODE,d0
cmp.b #1,d0
beq.s flags_set
cmp.b #2,d0
bne.s flags_test
move.b MASK,d0
not.b d0
and.b d0,FLAGS
bra.s flags_test
flags_set:
move.b MASK,d0
or.b d0,FLAGS
flags_test:
clr.b ALL_SET
move.b FLAGS,d0
and.b MASK,d0
cmp.b MASK,d0
bne.s flags_done
move.b #1,ALL_SET
flags_done:
rts
component_end:State and ownership
FLAGS persists across calls. MASK and MODE are inputs. ALL_SET is replaced on each call and describes the state after any set or clear operation.
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
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:
FLAGS: dc.b 0
MASK: dc.b 0
MODE: dc.b 0
ALL_SET: 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,0A separate client retaining state between calls
preview_rules:
ifne CUSTOM
move.b #1,FLAGS
move.b #16,MASK
move.b #1,MODE
ifne BROKEN
move.b #3,MASK
bsr checked_step
else
bsr checked_step
endif
bsr emit_state
move.b #0,MODE
ifne BROKEN
move.b #3,MASK
bsr checked_step
else
bsr checked_step
endif
bsr emit_state
move.b #2,MODE
ifne BROKEN
move.b #3,MASK
bsr checked_step
else
bsr checked_step
endif
bsr emit_state
else
move.b #1,FLAGS
move.b #8,MASK
move.b #1,MODE
ifne BROKEN
move.b #3,MASK
bsr checked_step
else
bsr checked_step
endif
bsr emit_state
move.b #0,MODE
ifne BROKEN
move.b #3,MASK
bsr checked_step
else
bsr checked_step
endif
bsr emit_state
move.b #2,MODE
ifne BROKEN
move.b #3,MASK
bsr checked_step
else
bsr checked_step
endif
bsr emit_state
endif
rtsThe eight display fields follow FLAGS, MASK, MODE, ALL_SET; unused display fields are zero. Each field is a hexadecimal byte. The working row is 01 08 02 00 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 moves its example fact from mask 8 to mask 16. It leaves the unrelated mask-1 fact intact. Changing the bit assignment needs matching definitions in every user of that save/world data.
Maintained custom configuration or caller
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:
FLAGS: dc.b 0
MASK: dc.b 0
MODE: dc.b 0
ALL_SET: 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,0The observed custom row is 01 10 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 passes 3, the intended bit number, where the API expects mask 8. The binary value 3 selects the two lowest bits. Setting and later clearing it destroys the unrelated mask-1 fact. Pass a mask, not an ordinal bit number.
Deliberately wrong client selection
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:
FLAGS: dc.b 0
MASK: dc.b 0
MODE: dc.b 0
ALL_SET: 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 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 96 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.
At most one byte of world state changes. Mask operations take bounded paths and no scan. A byte per fact costs more RAM but may make an early project easier to inspect.
More than eight facts need a larger byte array plus an index/mask lookup. Counters belong in counters: a flag cannot hold three arrows. Shared interrupt/main-loop updates need an ownership or critical-section policy because these read/modify/write sequences are not atomic transactions.
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.