; ======================================================================
; GIG RUSH — a 21st-century arcade game for the 1982 ZX Spectrum
; From https://thespeccy.com — original game, code and art.
;
; You are a food delivery rider. Collect orders from the GRUB HUT at the
; top, deliver them to the flashing door at the bottom, and try not to
; get flattened by six lanes of traffic. Your phone battery is your
; life AND your clock: it drains constantly, crashes cost you a chunk,
; deliveries top it up. When it dies, the shift is over.
;
; Keys: Q = up, A = down, O = left, P = right, S = start.
;
; Build:  pasmo --tapbas gigrush.asm gigrush.tap
; ======================================================================

        org 32768

; --- layout ---
; row 0        HUD (score / hi / orders)
; band 0       rows  1-2   top pavement, GRUB HUT door at col 15
; bands 1-3    rows  3-8   traffic lanes
; band 4       rows  9-10  grass median
; bands 5-7    rows 11-16  traffic lanes
; band 8       rows 17-18  bottom pavement, customer doors appear here
; row 19       battery bar
; row 21       status message

RESTX:  equ 15                  ; restaurant door column
BATTMAX: equ 96

; ======================================================================
start:
        ld sp,0                 ; own stack at the top of RAM
        call newtitle
mainloop:
        halt
        ld a,(state)
        or a
        jr z,frame_title
        cp 1
        jr z,frame_play
        call frame_over
        jr mainloop

frame_title:
        call steplanes          ; attract mode: traffic keeps flowing
        call key_s
        jr nz,mainloop
        call newgame
        jr mainloop

frame_play:
        ld hl,tick
        inc (hl)
        call steplanes
        call moverider
        call checkcars
        call drawrider
        call targets
        call battery
        call hud
        jr mainloop

frame_over:
        call key_s
        ret nz
        jp newgame

; ----------------------------------------------------------------------
; state setup
; ----------------------------------------------------------------------
newtitle:
        xor a
        ld (state),a
        call initlanes
        call drawfield
        ld b,1                ; top pavement band — no traffic here
        ld c,10
        ld de,t_title
        ld a,0x47
        call print
        ld b,9                ; grass median — safe, no traffic
        ld c,4
        ld de,t_sub1
        ld a,0x46
        call print
        ld b,10
        ld c,3
        ld de,t_sub2
        ld a,0x46
        call print
        ld b,17               ; bottom pavement — safe, no traffic
        ld c,8
        ld de,t_keys1
        ld a,0x45
        call print
        ld b,18
        ld c,8
        ld de,t_keys2
        ld a,0x45
        call print
        ld b,21
        ld c,8
        ld de,t_press
        ld a,0xC7            ; flashing bright white
        call print
        ret

newgame:
        ld a,1
        ld (state),a
        xor a
        ld (phase),a
        ld (orders),a
        ld (tick),a
        ld h,a
        ld l,a
        ld (score),hl
        ld a,BATTMAX
        ld (battval),a
        ld a,15
        ld (riderx),a
        ld a,8
        ld (riderb),a
        call initlanes
        call drawfield
        call drawrest
        ld de,t_collect
        call message
        call drawrider
        call hudnow
        call battdraw
        ret

gameover:
        ld a,2
        ld (state),a
        ld hl,(score)
        ld de,(hiscore)
        or a
        sbc hl,de
        jr c,nothi
        ld hl,(score)
        ld (hiscore),hl
nothi:
        call hudnow
        ld b,9                ; grass median — safe, no traffic
        ld c,9
        ld de,t_dead
        ld a,0xD6            ; flashing bright yellow
        call print
        ld b,10
        ld c,5
        ld de,t_shift
        ld a,0x47
        call print
        ld de,t_press
        call message
        ld b,30              ; sad descending tones
        ld c,40
        call beep
        ld b,20
        ld c,80
        call beep
        ld b,10
        ld c,160
        call beep
        ret

; ----------------------------------------------------------------------
; playfield drawing
; ----------------------------------------------------------------------
drawfield:
        ld hl,16384          ; clear bitmap
        ld de,16385
        ld bc,6143
        ld (hl),0
        ldir
        ld hl,22528          ; all attrs black
        ld de,22529
        ld bc,767
        ld (hl),0
        ldir
        xor a
        out (254),a
        ; pavements and median
        ld d,0
        call bgband
        ld d,8
        call bgband
        ld d,4
        call bgband
        ; lane colours
        ld d,1
        call laneattr
        ld d,2
        call laneattr
        ld d,3
        call laneattr
        ld d,5
        call laneattr
        ld d,6
        call laneattr
        ld d,7
        call laneattr
        ; draw all lanes once
        ld ix,lanes
        ld b,6
dfl:    push bc
        call drawlane
        ld de,8
        add ix,de
        pop bc
        djnz dfl
        ; HUD labels
        ld b,0
        ld c,0
        ld de,t_hud
        ld a,0x47
        call print
        ld b,19
        ld c,0
        ld de,t_batt
        ld a,0x47
        call print
        ret

; paint full-width background band D
bgband:
        ld e,0
bgb1:   call bgcell2
        inc e
        ld a,e
        cp 32
        jr nz,bgb1
        ret

; background for band D at col E, both cell rows (preserves D,E)
bgcell2:
        ld a,d
        add a,a
        inc a
        ld b,a               ; row = 1 + 2*band
        ld c,e
        call bgcell
        ld a,d
        add a,a
        add a,2
        ld b,a
        ld c,e
        ; fall through
bgcell: ; band D, row B, col C: texture + attr (preserves B,C,D,E)
        push bc
        push de
        ld a,d
        or a
        jr z,bgp
        cp 8
        jr z,bgp
        cp 4
        jr z,bgg
        ld de,z_cell
        jr bgd
bgp:    ld de,pave_cell
        jr bgd
bgg:    ld de,grass_cell
bgd:    call putcell
        pop de
        pop bc
        call attr_of_band    ; A = attr for band D (preserves B,C,D,E)
        push bc
        push af
        call attradr_rc
        pop af
        ld (hl),a
        pop bc
        ret

attr_of_band:                 ; D = band -> A = attr
        push hl
        push de
        ld hl,bandattr
        ld e,d
        ld d,0
        add hl,de
        ld a,(hl)
        pop de
        pop hl
        ret

; set the two attr rows of lane band D to the lane colour
laneattr:
        call attr_of_band
        ld c,a
        ld a,d
        add a,a
        inc a               ; first row
        call attrrow
        inc a
attrrow:                    ; fill attr row A with colour C (returns A)
        push af
        push bc
        ld b,a
        ld a,b
        and 0x18
        rrca
        rrca
        rrca
        add a,0x58
        ld h,a
        ld a,b
        and 7
        rrca
        rrca
        rrca
        ld l,a
        ld b,32
ar1:    ld (hl),c
        inc hl
        djnz ar1
        pop bc
        pop af
        ret

; ----------------------------------------------------------------------
; lanes: 6 entries x 8 bytes: band, dir, speed, counter, mask[4]
; mask bit7 of byte0 = column 0 ... bit0 of byte3 = column 31
; ----------------------------------------------------------------------
initlanes:
        ld hl,laneinit
        ld de,lanes
        ld bc,48
        ldir
        ret

steplanes:
        ld ix,lanes
        ld b,6
stl1:   push bc
        dec (ix+3)
        jr nz,stl2
        ld a,(ix+2)
        ld (ix+3),a
        call rotlane
        call drawlane
stl2:   ld de,8
        add ix,de
        pop bc
        djnz stl1
        ret

rotlane:
        ld a,(ix+1)
        or a
        jr nz,rotl
        ; cars move right: rotate mask right with wraparound
        ld a,(ix+7)
        rra                  ; old col31 -> carry
        ld a,(ix+4)
        rra
        ld (ix+4),a
        ld a,(ix+5)
        rra
        ld (ix+5),a
        ld a,(ix+6)
        rra
        ld (ix+6),a
        ld a,(ix+7)
        rra
        ld (ix+7),a
        ret
rotl:   ; cars move left: rotate mask left with wraparound
        ld a,(ix+4)
        rla                  ; old col0 -> carry
        ld a,(ix+7)
        rla
        ld (ix+7),a
        ld a,(ix+6)
        rla
        ld (ix+6),a
        ld a,(ix+5)
        rla
        ld (ix+5),a
        ld a,(ix+4)
        rla
        ld (ix+4),a
        ret

; redraw lane (ix): 32 columns of road or car
drawlane:
        xor a
        ld (lcol),a
dl1:    ld a,(lcol)
        ld e,a
        call lanebit
        jr c,dlcar
        ld a,(ix+0)
        ld d,a
        call bgcell2
        jr dlnext
dlcar:  ; pick end-cap variant from the neighbouring columns
        ld a,(lcol)
        dec a
        and 31
        ld e,a
        call lanebit
        jr nc,dlleft
        ld a,(lcol)
        inc a
        and 31
        ld e,a
        call lanebit
        jr nc,dlright
        ld de,car_mid
        jr dlgo
dlleft: ld de,car_left
        jr dlgo
dlright:
        ld de,car_right
dlgo:   ld a,(ix+0)
        add a,a
        inc a
        ld b,a
        ld a,(lcol)
        ld c,a
        call putcell         ; top quadrant (DE advances 8)
        inc b
        call putcell         ; bottom quadrant
dlnext: ld a,(lcol)
        inc a
        ld (lcol),a
        cp 32
        jr nz,dl1
        ret

; carry = mask bit of lane (ix) at column E (preserves D,E)
lanebit:
        ld a,e
        rrca
        rrca
        rrca
        and 3
        add a,4
        push de
        ld d,0
        ld e,a
        push ix
        pop hl
        add hl,de
        pop de
        ld a,e
        and 7
        inc a
        ld b,a
        ld a,(hl)
lb1:    rlca                 ; rotate target bit into carry
        djnz lb1
        ret

; ----------------------------------------------------------------------
; rider
; ----------------------------------------------------------------------
moverider:
        ld a,(tick)
        and 3
        ret nz
        ; P = right
        ld a,0xDF
        in a,(0xFE)
        rra
        jr c,mvno_p
        ld a,(riderx)
        cp 30
        jr nc,mvno_p
        call eraserider
        ld hl,riderx
        inc (hl)
mvno_p: ; O = left
        ld a,0xDF
        in a,(0xFE)
        rra
        rra
        jr c,mvno_o
        ld a,(riderx)
        or a
        jr z,mvno_o
        call eraserider
        ld hl,riderx
        dec (hl)
mvno_o: ; Q = up
        ld a,0xFB
        in a,(0xFE)
        rra
        jr c,mvno_q
        ld a,(riderb)
        or a
        jr z,mvno_q
        call eraserider
        ld hl,riderb
        dec (hl)
mvno_q: ; A = down
        ld a,0xFD
        in a,(0xFE)
        rra
        ret c
        ld a,(riderb)
        cp 8
        ret nc
        call eraserider
        ld hl,riderb
        inc (hl)
        ret

eraserider:
        ld a,(riderx)
        ld e,a
        ld a,(riderb)
        ld d,a
        call bgcell2
        inc e
        call bgcell2
        ; the doors may have been chewed: restore them
        call drawrest
        ld a,(phase)
        or a
        ret z
        jp drawcust

drawrider:
        ld a,(riderb)
        add a,a
        inc a
        ld b,a
        ld a,(riderx)
        ld c,a
        ld de,rider_spr
        call blit16
        ld a,(riderb)
        add a,a
        inc a
        ld b,a
        ld a,(riderx)
        ld c,a
        call attradr_rc
        ld a,0x46            ; bright yellow rider...
        ld (hl),a
        inc hl
        ld (hl),a
        ld de,31
        add hl,de
        ld a,0x47            ; ...bright white bike
        ld (hl),a
        inc hl
        ld (hl),a
        ret

; collision: rider band on a lane whose mask has a bit under the rider
checkcars:
        ld a,(riderb)
        or a
        ret z
        cp 4
        ret z
        cp 8
        ret z
        ld ix,lanes
        ld b,6
cc1:    cp (ix+0)
        jr z,cc2
        push de
        ld de,8
        add ix,de
        pop de
        djnz cc1
        ret
cc2:    ld a,(riderx)
        ld e,a
        call lanebit
        jr c,crash
        ld a,(riderx)
        inc a
        ld e,a
        call lanebit
        ret nc
crash:
        ld a,2
        out (254),a          ; red border flash
        ld b,120
        ld c,20
        call beep
        xor a
        out (254),a
        ld a,(battval)       ; battery penalty
        sub 20
        jr nc,cr1
        xor a
cr1:    ld (battval),a
        call battdraw
        call eraserider      ; respawn on the bottom pavement
        ld a,15
        ld (riderx),a
        ld a,8
        ld (riderb),a
        call drawrider
        ld a,(battval)
        or a
        ret nz
        jp gameover

; ----------------------------------------------------------------------
; collect / deliver
; ----------------------------------------------------------------------
targets:
        ld a,(phase)
        or a
        jr nz,tgdeliver
        ; collecting: touching the restaurant door on band 0?
        ld a,(riderb)
        or a
        ret nz
        ld a,(riderx)
        sub RESTX
        add a,1
        cp 3                 ; |riderx-RESTX| <= 1 ?
        ret nc
        ; picked up!
        ld a,1
        ld (phase),a
        call rand
        and 31
        cp 29
        jr c,tg1
        sub 12
tg1:    ld (custx),a
        call drawrest        ; door stops flashing
        call drawcust
        ld de,t_deliver
        call message
        ld b,40
        ld c,30
        call beep
        ret
tgdeliver:
        ld a,(riderb)
        cp 8
        ret nz
        ld a,(custx)
        ld d,a
        ld a,(riderx)
        sub d
        add a,1
        cp 3                 ; |riderx-custx| <= 1 ?
        ret nc
        ; delivered!
        xor a
        ld (phase),a
        ld a,(custx)         ; door back to pavement
        ld e,a
        ld d,8
        call bgcell2
        inc e
        call bgcell2
        call drawrest        ; flashing again
        call drawrider
        ld hl,(score)
        ld de,25
        add hl,de
        ld (score),hl
        ld hl,orders
        inc (hl)
        ld a,(battval)
        add a,16
        cp BATTMAX+1
        jr c,tg2
        ld a,BATTMAX
tg2:    ld (battval),a
        call battdraw
        call hudnow
        ld de,t_collect
        call message
        ld b,40
        ld c,20
        call beep
        ld b,40
        ld c,15
        call beep
        ; every 3rd delivery the traffic gets angrier
        ld a,(orders)
        and 3
        cp 3
        ret nz
        ld ix,lanes
        ld b,6
tg3:    ld a,(ix+2)
        cp 5
        jr c,tg4
        dec a
        ld (ix+2),a
tg4:    push de
        ld de,8
        add ix,de
        pop de
        djnz tg3
        ret

drawrest:
        ld b,1
        ld c,RESTX
        ld de,door_spr
        call blit16
        ld a,(phase)
        or a
        ld a,0xC2            ; flashing red when it's the target
        jr z,dr1
        ld a,0x42            ; steady red otherwise
dr1:    ld b,1
        ld c,RESTX
        jp setattr2x2

drawcust:
        ld a,(custx)
        ld c,a
        ld b,17
        ld de,door_spr
        call blit16
        ld a,(custx)
        ld c,a
        ld b,17
        ld a,0xC4            ; flashing green
        jp setattr2x2

; ----------------------------------------------------------------------
; battery
; ----------------------------------------------------------------------
battery:
        ld a,(tick)
        and 15
        ret nz
        ld a,(battval)
        or a
        jr z,battdead
        dec a
        ld (battval),a
        call battdraw
        ld a,(battval)
        or a
        ret nz
battdead:
        jp gameover

battdraw:
        ; 24-cell bar on row 19, cols 6-29; colour follows the charge
        ld a,(battval)
        cp 48
        ld c,0x44            ; green
        jr nc,bd0
        cp 24
        ld c,0x46            ; yellow
        jr nc,bd0
        ld c,0x42            ; red
bd0:    ld a,c
        ld (battattr),a
        xor a
        ld (lcol),a
bd1:    ld a,(lcol)
        add a,a
        add a,a              ; 4 * index
        ld hl,battval
        cp (hl)              ; carry set when 4*index < battery
        jr c,bdf
        ld de,z_cell
        ld a,0x07
        jr bdg
bdf:    ld de,bar_cell
        ld a,(battattr)
bdg:    push af
        ld b,19
        ld a,(lcol)
        add a,6
        ld c,a
        call putcell
        call attradr_rc
        pop af
        ld (hl),a
        ld a,(lcol)
        inc a
        ld (lcol),a
        cp 24
        jr nz,bd1
        ret

; ----------------------------------------------------------------------
; HUD (score / hi / orders)
; ----------------------------------------------------------------------
hud:
        ld a,(tick)
        and 15
        ret nz
hudnow:
        ld hl,(score)
        ld b,0
        ld c,6
        call prnum
        ld hl,(hiscore)
        ld b,0
        ld c,16
        call prnum
        ld a,(orders)
        ld l,a
        ld h,0
        ld b,0
        ld c,26
        ; fall through
; print HL as 5 decimal digits at row B col C (uses current textattr)
prnum:
        ld a,0x47
        ld (textattr),a
        ld de,10000
        call prdig
        ld de,1000
        call prdig
        ld de,100
        call prdig
        ld de,10
        call prdig
        ld de,1
        ; fall through
prdig:  ld a,'0'-1
pd1:    inc a
        or a
        sbc hl,de
        jr nc,pd1
        add hl,de
        push hl
        push de
        call printch
        inc c
        pop de
        pop hl
        ret

; ----------------------------------------------------------------------
; text
; ----------------------------------------------------------------------
; print 0-terminated string DE at row B col C with attr A
print:
        ld (textattr),a
pr1:    ld a,(de)
        or a
        ret z
        push de
        call printch
        pop de
        inc de
        inc c
        jr pr1

; print char A at row B col C, attr from (textattr); preserves B,C
printch:
        push bc
        sub 32
        ld l,a
        ld h,0
        add hl,hl
        add hl,hl
        add hl,hl
        ld de,font
        add hl,de
        ex de,hl             ; DE = glyph
        call scradr_rc
        ld b,8
pch1:   ld a,(de)
        ld (hl),a
        inc de
        inc h
        djnz pch1
        pop bc
        push bc
        call attradr_rc
        ld a,(textattr)
        ld (hl),a
        pop bc
        ret

; status message on row 21 (clears the row first)
message:
        push de
        ld b,21
        ld c,0
mg1:    ld de,z_cell
        call putcell
        inc c
        ld a,c
        cp 32
        jr nz,mg1
        pop de
        ld b,21
        ld c,2
        ld a,0x45
        jp print

; set 2x2 attr block at row B col C to A
setattr2x2:
        push af
        call attradr_rc
        pop af
        ld (hl),a
        inc hl
        ld (hl),a
        ld de,31
        add hl,de
        ld (hl),a
        inc hl
        ld (hl),a
        ret

; ----------------------------------------------------------------------
; low level
; ----------------------------------------------------------------------
; HL = bitmap address of cell row B (0-23), col C
scradr_rc:
        ld a,b
        and 0x18
        or 0x40
        ld h,a
        ld a,b
        and 7
        rrca
        rrca
        rrca
        or c
        ld l,a
        ret

; HL = attr address of cell row B, col C
attradr_rc:
        ld a,b
        rrca
        rrca
        rrca
        and 3
        add a,0x58
        ld h,a
        ld a,b
        and 7
        rrca
        rrca
        rrca
        or c
        ld l,a
        ret

; copy 8 bytes DE -> cell at row B col C; preserves B,C; DE advances
putcell:
        push bc
        call scradr_rc
        ld b,8
put1:   ld a,(de)
        ld (hl),a
        inc de
        inc h
        djnz put1
        pop bc
        ret

; draw 16x16 sprite DE at cell rows B,B+1, col C
blit16:
        push bc
        call scradr_rc
        call cell8
        pop bc
        inc b
        call scradr_rc
cell8:
        ld b,8
c81:    push hl
        ld a,(de)
        ld (hl),a
        inc de
        inc l
        ld a,(de)
        ld (hl),a
        inc de
        pop hl
        inc h
        djnz c81
        ret

key_s:                       ; Z set if S is pressed
        ld a,0xFD
        in a,(0xFE)
        and 2
        ret

rand:
        ld a,(seed)
        ld b,a
        add a,a
        add a,b
        add a,7
        ld (seed),a
        ret

; beep: B = cycles, C = pitch (delay)
beep:
        ld a,0x10
bp1:    out (254),a
        xor 0x10
        push bc
bp2:    dec c
        jr nz,bp2
        pop bc
        djnz bp1
        xor a
        out (254),a
        ret

; ----------------------------------------------------------------------
; data
; ----------------------------------------------------------------------
state:  defb 0
tick:   defb 0
riderx: defb 15
riderb: defb 8
phase:  defb 0
custx:  defb 20
orders: defb 0
battval: defb BATTMAX
seed:   defb 91
score:  defw 0
hiscore: defw 0
textattr: defb 0x47
lcol:   defb 0
battattr: defb 0x44

; band -> attr (pavement, 3 lanes, grass, 3 lanes, pavement)
bandattr:
        defb 0x07, 0x42,0x45,0x43, 0x44, 0x46,0x47,0x43, 0x07

; lanes: band, dir(0=right), speed, counter, mask x4
laneinit:
        defb 1,0,14,14, 0xC0,0x30,0x0C,0x03
        defb 2,1,10,10, 0x18,0xC0,0x60,0x06
        defb 3,0,16,16, 0x06,0x0C,0xC0,0x18
        defb 5,1,12,12, 0x30,0x03,0x18,0xC0
        defb 6,0,8,8,   0xC0,0x06,0x30,0x0C
        defb 7,1,15,15, 0x0C,0x60,0x06,0x60
lanes:  defs 48,0

; cell textures
z_cell:     defs 8,0
pave_cell:  defb 0xAA,0x00,0x55,0x00,0xAA,0x00,0x55,0x00
grass_cell: defb 0x00,0x44,0x00,0x11,0x00,0x44,0x00,0x11
bar_cell:   defb 0x00,0x7E,0x7E,0x7E,0x7E,0x7E,0x7E,0x00

; car quadrants: a squat rectangular car body, centred in its lane with
; a margin of open road above and below, plus two wheel nubs. Each car
; is 2 columns (16px) wide; left/right are its two halves; mid is a
; straight-sided infill for wider (3+ column) traffic.
; top cell then bottom cell, 8 bytes each.
car_left:
        defb 0x00,0x00,0x7F,0xFF,0xFF,0xFF,0xFF,0xFF
        defb 0xFF,0xFF,0xFF,0x7F,0x00,0x20,0x20,0x00
car_mid:
        defb 0x00,0x00,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF
        defb 0xFF,0xFF,0xFF,0xFF,0x00,0x66,0x66,0x00
car_right:
        defb 0x00,0x00,0xFE,0xFF,0xFF,0xFF,0xFF,0xFF
        defb 0xFF,0xFF,0xFF,0xFE,0x00,0x10,0x10,0x00

; the rider, 16x16
rider_spr:
        defb 0x03,0xC0       ; helmet
        defb 0x07,0xE0
        defb 0xF3,0xC0       ; backpack + head
        defb 0xF1,0x80
        defb 0xF3,0xC0       ; torso
        defb 0xF3,0xF0       ; arms to the bars
        defb 0x03,0xC0
        defb 0x07,0x60       ; legs
        defb 0x1F,0xE0       ; frame
        defb 0x30,0x30       ; forks
        defb 0x78,0x1E       ; wheels
        defb 0xCC,0x33
        defb 0x84,0x21
        defb 0x84,0x21
        defb 0xCC,0x33
        defb 0x78,0x1E

; a doorway, 16x16 (restaurant and customer share it, colours differ)
door_spr:
        defb 0xFF,0xFF       ; awning
        defb 0xAA,0xAA
        defb 0xFF,0xFF
        defb 0x00,0x00
        defb 0x3F,0xFC       ; shop front
        defb 0x20,0x04
        defb 0x27,0xE4       ; door frame
        defb 0x24,0x24
        defb 0x24,0x24
        defb 0x24,0x24
        defb 0x24,0x64       ; handle
        defb 0x24,0x24
        defb 0x24,0x24
        defb 0x24,0x24
        defb 0x27,0xE4
        defb 0xFF,0xFF       ; ground

; strings
t_title:   defb "* GIG RUSH *",0
t_sub1:    defb "COLLECT AT THE GRUB HUT",0
t_sub2:    defb "DELIVER TO FLASHING DOORS",0
t_keys1:   defb "Q A O P TO MOVE",0
t_keys2:   defb "MIND THE TRAFFIC",0
t_press:   defb "PRESS S TO START",0
t_hud:     defb "SCORE       HI        ORD",0
t_batt:    defb "BATT",0
t_collect: defb "COLLECT FROM THE GRUB HUT",0
t_deliver: defb "DELIVER TO THE FLASHING DOOR",0
t_dead:    defb "OUT OF BATTERY",0
t_shift:   defb "SHIFT OVER. NO STARS.",0

        include "fontdata.inc"

        end start