proc ScaleBlendImage, .ImgSrc, .xSrc, .ySrc, .wSrc, .hSrc, .ImgDst, .xDst, .yDst, .wDst, .hDst    

struct TImage
  .width   dd ?  ; width in pixels.
  .height  dd ?  ; height in pixels.
  .pPixels dd ?  ; pointer to the pixel memory buffer.
ends    

; $$$$$$$$$$$$$$$$$$$ ABAKIS $$$$$$$$$$$$$$$$$$$$$
; *************** STAR^2 SOFTWARE ****************
; ?????????????????? DRAW.INC ????????????????????

; fast portable graphics

include 'color.inc'
include 'box.inc'

;;;;;;;;;;;;;;;;;;;;; SCREEN ;;;;;;;;;;;;;;;;;;;;;

align

void vga.p

integer os.w, os.h, os.bpp,\
 screen.x, screen.y, screen.w, screen.h,\
 screen.n, screen.bpp, screen.size,\
 screen.pw, screen.pitch

void palette.p

BOX g.box

function set.screen, w, h, bpp
  alias n=r0, pw=r1
  . screen.w=w, screen.h=h   ; size
  . r0=os.w, r0/2, r1=w
  . r1/2, r0-r1, screen.x=r0
  . r0=os.h, r0/2, r1=h
  . r1/2, r0-r1, screen.x=r0
  . n=w, n*h, screen.n=n     ; # pixels
  . pw=bpp, pw/8             ; pixel width
  . screen.pw=pw, n*pw       ; screen size
  . screen.size=n            ; in bytes
  . n=w, n*pw                ; screen pitch
  . screen.pitch=n           ; w in bytes
  . screen.bpp=bpp           ; bits per pixel
endf

;;;;;;;;;;;;;;;;;;;; DRAWING ;;;;;;;;;;;;;;;;;;;;;

; erase screen with color

function clear.screen, c
  alias p=r0, n=r1, z=r2
  . p=vga.p, n=screen.n, z=c
  loop n, (u32) *p++=z, endl
endf

; calculate x/y offset: (y*screen.w+x)*4

macro get.xy x, y
  { . r0=y, r0*screen.w, r0+x, r0*4 }

; address &vga[(y*screen.w+x)*4]

function vga.xy, x, y
  get.xy x, y
  . r0+vga.p
endf

; draw pixel

function draw.pixel, x, y, c
  alias p=r0, z=r1
  try clip.pixel x, y
  vga.xy x, y
  . z=c, (u32) *p=z
endf 1

; draw horizontal line

function draw.line.h, x, y, n, c
  alias p=r0, z=r1, w=r2
  . p=&x, z=&y, w=&n
  try clip.line 0, p, z, w
  vga.xy x, y
  . z=c
  loop n, (u32) *p++=z, endl
endf 1

; draw vertical line

function draw.line.v, x, y, n, c
  locals swb
  alias p=r0, z=r1, h=r2
  . p=&x, z=&y, h=&n
  try clip.line 1, p, z, h
  vga.xy x, y
  . z=c, swb=screen.pitch
  loop n, (u32) *p=z, p+swb, endl
endf 1

; draw solid rectangle

function draw.box, x, y, w, h, c
  locals i
  try visible x, y, w, h
  . i=y, i--
  loop h, i++
    draw.line.h x, i, w, c
  endl
endf 1

; draw rectangle outline

function draw.outline, x, y, w, h, c
  try visible x, y, w, h
  draw.line.h x, y, w, c    ; top
  . r0=y, r0+h, r0--        ; bottom
  draw.line.h x, r0, w, c
  . r0=y, r0++, r1=h, r1-2  ; left
  draw.line.v x, r0, r1, c
  . r0=x, r0+w, r0--
  . r2=y, r2++, r1=h, r1-2  ; right
  draw.line.v r0, r2, r1, c
endf 1

macro draw.box.s b, c
 { draw.box b#.x, b#.y, b#.w, b#.h, c }
macro draw.box.o b, c
 { draw.outline b#.x, b#.y, b#.w, b#.h, c }

macro draw.box a, b, c, d, e {
  IF ~e eq
    draw.box a, b, c, d, e
  ELSE IF ~d eq
    'Unsupported'
  ELSE IF ~c eq
    draw.box.s a, b
    draw.box.o a, c
  ELSE IF ~b eq
    draw.box.s a, b
  END IF
}

; draw scanline

function draw.scanline, pixels, x, y, w
  locals i
  alias p=r0, s=r1
  . r0=&i, r1=&x, r2=&y, r3=&w
  try clip.scanline r0, r1, r2, r3
  vga.xy x, y
  . s=pixels, s+i
  loop w, (u32) *p++=*s++, endl
endf 1

; draw scanline with transparent key

function draw.scanline.t, pixels, x, y, w, key
  locals i
  alias p=r0, s=r1, c=r2
  . r0=&i, r1=&x, r2=&y, r3=&w
  try clip.scanline r0, r1, r2, r3
  vga.xy x, y
  . s=pixels, s+i
  loop w, (u32) c=*s++
    if c<>key, (u32) *p=c, end, p+4
  endl
endf 1

; draw scanline with inverted x

function draw.scanline.ix, pixels, x, y, w
  locals i
  alias p=r0, s=r1
  . r0=x, r0+w
  vga.xy r0, y
  . p-4, s=pixels
  loop w, (u32) *p--=*s++, endl
endf 1

; draw variant scanline. pixels are
; grayscale, alpha intensity of co=color.
; for brushes and special effects

function draw.scanline.v, pixels, x, y, w, co
  locals a, i
  alias p=r0, s=r1, c=r2, c2=r3
  . r0=&i, r1=&x, r2=&y, r3=&w
  try clip.scanline r0, r1, r2, r3
  vga.xy x, y
  . s=pixels, s+i
  loop w, (u32) c=*s++
    . a=c, a&0FFh
    if a=0, go .next, end
    if a=0FFh, c=co, go .draw, end
    . (u32) c2=*p
    push p s
    get c=mix co, c2, a
    pop s p
    .draw: . (u32) *p=c
    .next: . p+4
  endl
endf 1

; draw bitmap

function draw.bitmap, pixels, x, y, w, h
  locals i, p
  try visible x, y, w, h
  . i=y, p=pixels
  loop h
    draw.scanline p, x, i, w
    . r0=w, r0*4, p+r0, i++
  endl
endf 1

; draw bitmap with transparency by
; upper left pixel color (X=0, Y=0)

function draw.bitmap.t, pixels, x, y, w, h
  locals i, p, key
  try visible x, y, w, h
  . i=y, r0=pixels, p=r0
  . (u32) r0=*r0, key=r0
  loop h
    draw.scanline.t p, x, i, w, key
    . r0=w, r0*4, p+r0, i++
  endl
endf 1

; draw bitmap with inverted x

function draw.bitmap.ix, pixels, x, y, w, h
  locals i, p
  try visible x, y, w, h
  . p=pixels
  loop h
    draw.scanline.ix p, x, y, w
    . r0=w, r0*4, p+r0, y++
  endl
endf 1

; draw bitmap with inverted y

function draw.bitmap.iy, pixels, x, y, w, h
  locals i, p
  try visible x, y, w, h
  . r0=h, r0--, y+r0, p=pixels
  loop h
    draw.scanline p, x, y, w
    . r0=w, r0*4, p+r0, y--
  endl
endf 1

; draw bitmap with both inverted

function draw.bitmap.ixy, pixels, x, y, w, h
  locals i, p, n
  try visible x, y, w, h
  . p=pixels
  loop h
    draw.scanline.ix p, x, y, w
    . r0=w, r0*4, p+r0, y--
  endl
endf 1

; draw variant bitmap

function draw.bitmap.v, pixels, x, y, w, h, c
  locals i, p
  try visible x, y, w, h
  . i=y, r0=pixels, p=r0
  loop h
    draw.scanline.v p, x, i, w, c
    . r0=w, r0*4, p+r0, i++
  endl
endf 1

; draw gradual vertical fade from
; color a to b. o/rient:
; 'h'=horizontal, 'v'=vertical

function draw.fade, bo, c1, c2
  locals x, y, w, h, i, n, c,\
   r, g, b, red, green, blue,\
   nr, ng, nb, first, last
  . r0=bo,\
   x=[?box.x+r0], y=[?box.y+r0],\
   w=[?box.w+r0], h=[?box.h+r0]

  . r0=y, first=r0, r1=h
  . n=r1, r0+r1, last=r0

  . r0=&r, r1=&g, r2=&b
  get.rgb c1, r0, r1, r2
  . r0=&red, r1=&green, r2=&blue
  get.rgb c2, r0, r1, r2

  . r<<8, g<<8, b<<8, r1=n
  if r1=0, r1++, end
  . r0=red, r0<<8, r0-r, r0/r1, nr=r0
  . r0=green, r0<<8, r0-g, r0/r1, ng=r0
  . r0=blue, r0<<8, r0-b, r0/r1, nb=r0

  . i=first
  forever
    . r0=r, r0>>8, r1=g, r1>>8, r2=b, r2>>8
    get c=rgb r0, r1, r2
    draw.line.h x, i, w, c
    . r0=nr, r+r0, r1=ng, g+r1, r2=nb, b+r2
    . i++, r0=last
    if i>r0, go .out, end
  endfv
  .out:
endf

; draw with vertical center fade:
; a to b then b to a

function draw.shade, bo, a, b
  memory.copy g.box, bo, 16
  . g.box.h>>>1
  draw.fade g.box, a, b
  . r0=g.box.h, g.box.y+r0
  draw.fade g.box, b, a
endf

;;;;;;;;;;;;;;;;; PALETTE PIXELS ;;;;;;;;;;;;;;;;;

; 8BPP versions with pa/lette. no clipping

function draw.scanline.8, pixels, x, y, w
  alias p=r0, s=r1, c=r2, q=r3
  vga.xy x, y
  . s=pixels
  loop w, q=*s++, q*4, q+palette.p
    . (u32) c=*q, (u32) *p++=c
  endl
endf 1

function draw.bitmap.8, pixels, x, y, w, h
  locals i, p
  try visible x, y, w, h
  . i=y, i--, p=pixels
  loop h, i++
    draw.scanline.8 p, x, i, w
    . r0=w, p+r0
  endl
endf 1

;;;;;;;;;;;;;;;;;;;;; SPECIAL ;;;;;;;;;;;;;;;;;;;;

; special variant 8BPP with alpha bias for
; fonts and sketching effects (example:
; chalkboard)

A.LIGHTEST=128
A.LIGHTER=96
A.LIGHT=64
A.DARK=-32
A.DARKER=-64
A.DARKEST=-96

align
integer alpha.bias=0 ; A.DARKEST

function draw.scanline.v.8, pixels, x, y, w, co
  locals a, i
  alias p=r0, s=r1, c=r2, c2=r3, q=r3
  vga.xy x, y
  . s=pixels
  loop w, q=*s++, q*4, q+palette.p
    . (u32) c=*q, a=c, a&0FFh
    if a=0, go .next, end
    . (u32) c2=*p
    push p s
    . r0=a
    if alpha.bias, r0+alpha.bias
      if r0<0, r0=0
      else.if r0>255, r0=255, end
    end
    get c=mix co, c2, r0
    pop s p
    .draw: . (u32) *p=c
    .next: . p+4
  endl
endf 1

function draw.bitmap.v.8, pixels, x, y, w, h, c
  locals i, p
  try visible x, y, w, h
  . i=y, i--, p=pixels
  loop h, i++
    draw.scanline.v.8 p, x, i, w, c
    . r0=w, p+r0
  endl
endf 1    

;;;;;;;;;;;;;;;;;;;;; SYSTEM ;;;;;;;;;;;;;;;;;;;;;

; menuet interrupt: eax, ebx, ecx, edx

macro mint a, b, c, d {
 IF ~a eq
  . r0=a
 END IF
 IF ~b eq
  . r3=b
 END IF
 IF ~c eq
  . r1=c
 END IF
 IF ~d eq
  . r2=d
 END IF
 db 0CDh, 40h
}

; events

EVENT.REDRAW=1
EVENT.KEY=2
EVENT.BUTTON=3

align
integer timer.speed=-1,\
 timer.counter, event.delay=1

macro set.timer n {
  . r0=n, r1=10, r0/r1
  . timer.speed=r0, timer.counter=r0
}

macro get.timer { mint 26, 9 }

macro delay x {
  . r0=x, r0/100, r3=r0
  mint 5
}

macro wait.event { mint 23, event.delay }

;;;;;;;;;;;;;;;;;;;;; MEMORY ;;;;;;;;;;;;;;;;;;;;;

macro create.heap        { mint 68, 11 }
macro os.allocate n      { mint 68, 12, n }
macro os.reallocate p, n { mint 68, 20, p, n }
macro os.destroy p       { mint 68, 13, p }

;;;;;;;;;;;;;;; ALLOCATE, DESTROY ;;;;;;;;;;;;;;;;

; allocate n
; allocate.p &p, n
; destroy &p

; example: try p=allocate 4*KB

function allocate, n
  os.allocate n
endf

function allocate.p, p, n
  if p=0
    allocate n
    return
  end
  os.reallocate p, n
endf

function destroy, p
  if p
    os.destroy p
  end
endf

macro destroy [p] { forward destroy p }

;;;;;;;;;;;;;;;;;;;;; INPUT ;;;;;;;;;;;;;;;;;;;;;;

align integer event.type

; keyboard

integer key, old.key, key.event
text keys.t(128)

numeric KEY.ESCAPE=27, KEY.SPACE=' ',\
 KEY.UP=0B2h, KEY.RIGHT=0B3h, KEY.DOWN=0B1h,\
 KEY.LEFT=0B0h, KEY.A='a', KEY.S='s',\
 KEY.D='d', KEY.W='w'

macro get.key.buffer { mint 26, 2, 1, keys.t }

; mouse

integer mouse.event,\
 mouse.1, mouse.2, mouse.x, mouse.y,\
 mouse.drag, mouse.drag.x, mouse.drag.y,\
 mouse.drop, mouse.drop.x, mouse.drop.y,\
 old.mouse.1, old.mouse.2,\
 old.mouse.x, old.mouse.y

macro get.mouse.xy      { mint 37, 0 }
macro get.mouse.buttons { mint 37, 2 }
macro get.mouse.wheel   { mint 37, 3 }

function update.mouse
  . mouse.event=0
  . old.mouse.1=mouse.1, old.mouse.2=mouse.2
  . old.mouse.x=mouse.x, old.mouse.y=mouse.y

  get.mouse.xy
  . r1=r0, r1&0FFFFh, r0>>>16, r0&0FFFFh
  . mouse.x=r0, mouse.y=r1
  get.mouse.buttons
  . r1=r0, r1&1, mouse.1=r1
  . r1=r0, r1&2, mouse.2=r1

  if mouse.1
    if not old.mouse.1, mouse.event='c'
      . mouse.drop=NO
      callf on.mouse
      return 1
    end
  else.if old.mouse.1, mouse.event='r'
    callf on.mouse
    if mouse.drag
      . mouse.drop=YES,\
      mouse.drop.x=mouse.x,\
      mouse.drop.y=mouse.y,\
      mouse.drag=NO
      . mouse.event='d'
      callf on.mouse
    end
    return 1
  end
  . r0=mouse.x, r1=old.mouse.x
  if r0<>r1
    .mouse.move:
    . mouse.event='m'
    callf on.mouse
    if mouse.1
      if not mouse.drag
        . mouse.drag=YES,\
        mouse.drag.x=mouse.x,\
        mouse.drag.y=mouse.y
      end
    else
      . mouse.drop=NO
    end
    return 1
  else
    . r0=mouse.y, r1=old.mouse.y
    if r0<>r1
      go .mouse.move
    end
  end
endf 0

align

integer window.x, window.y

function select.box, box
  . r0=mouse.x, r1=mouse.y
  . r0-window.x, r1-window.y
  callf point.inside, box, r0, r1
endf

macro if.select box { !if select.box, box }
macro else.if.select box
 { !else.if select.box, box }

;;;;;;;;;;;;;;;;;;;;; RANDOM ;;;;;;;;;;;;;;;;;;;;;

align integer @seed

; generate unique random number: 0-n

function random, n
  . r0=@seed
  if false
    rdtsc
    . @seed=r0
  end
  . r0*343FDh, r0+269EC3h,\
  @seed=r0, r0>>16, r0&7FFFh,\
  r1=n, r1+1, r0/r1, r0=r2
endf

; random(from-to-2)+from

function random.x, from, to
  . r0=from, r0-to, r0-2
  random r0
  . r0+from
endf

;;;;;;;;;;;;;;;;;;;;; IMAGE ;;;;;;;;;;;;;;;;;;;;;;

function os.draw.image, pixels, x, y, w, h
  pusha
  . r1=w, r1<<16, r1|h
  . r2=x, r2<<16, r2|y
  . r3=pixels, r6=32, r7=0, ebp=w, ebp*4, ebp-ebp
  mint 65
  popa
endf

;;;;;;;;;;;;;;;;;;;;; SCREEN ;;;;;;;;;;;;;;;;;;;;;;

; align void vga.p

function get.screen.w
  mint 14
  . r0>>16, os.w=r0
endf

function get.screen.h
  mint 14
  . r0&0FFFFh, os.h=r0
endf

function show.vga
  os.draw.image vga.p, 0, 0, WINDOW.W, WINDOW.H
endf

function create.vga, w, h, c
  if vga.p=0, r0=w, r0*h, r0*4
    try vga.p=allocate r0
  end
  call !clear.screen, c
endf 1


function set.vga, w, h
  ; ...
endf

function end.vga
  destroy vga.p
endf

;;;;;;;;;;;;;;;;;;;;; WINDOW ;;;;;;;;;;;;;;;;;;;;;

function os.draw.window
  . r2=0, r6=0, r7=0FFFFFFh
  . r3=window.x, r3<<16, r3|screen.w
  . r1=window.y, r1<<16, r1|screen.h
  mint 0
endf

macro draw.begin { mint 12, 1 }
macro draw.end   { mint 12, 2 }
macro render     { call !on.draw }
macro retrace    { mint 18, 14 }

;;;;;;;;;;;;;;;;;;;;;; MAIN ;;;;;;;;;;;;;;;;;;;;;;

; main entry. detect current input states,
; translate and redirect to on.event handlers.

!main!:
  create.heap
  get.screen.w
  get.screen.h
  callf set.screen,\
   SCREEN.W, SCREEN.H, SCREEN.BPP
  create.vga WINDOW.W, WINDOW.H, 0
  callf on.create

  . r0=os.w, r0/2, r1=screen.w
  . r1/2, r0-r1, window.x=r0
  . r0=os.h, r0/2, r1=screen.h
  . r1/2, r0-r1, window.y=r0


  get.event:
  wait.event
  . event.type=r0

  update.mouse

  if timer.speed<>-1
    . timer.counter--
    if timer.counter<=0
      . timer.counter=timer.speed
      callf on.timer
    end
  end

  if event.type=EVENT.REDRAW
    draw.begin
    callf os.draw.window
    callf on.draw
    draw.end

  else.if event.type=EVENT.KEY
    mint 2
    if r0<>1, r0>>8, r0&0FFh, key=r0
      . key.event='k'
      callf on.key
      . key.event='c'
      callf on.key
      if key=KEY.ESCAPE
        callf exit
      end
    end

  else.if event.type=EVENT.BUTTON
    callf exit
  end
go get.event

function exit
  callf end.vga
  callf on.exit
  mint -1
endf    

; BINARY MASTER

WINDOW.W=360
WINDOW.H=492

include 'kolibri.inc'

text t(256), title.t='Binary Master: %hh'

text help.t=+\
 'Fun Game for Programmers.' RET\
 'Click BITs. Count in binary.' RET\
 'Match the decimal number' RET\
 'in the red box to make rows' RET\
 'disappear. Press any key.' RET\
 'r=Reset. p=Pause. Esc=exit'

text pause.t=+\
 'Paused. Press p to continue' RET\
 'or r=Reset. Esc=exit'

text game.over.t=+\
 'Game over. Score: %hh.' RET\
 'Press any key'

align

integer scene, score
numeric SCENE.*, TITLE, PLAY,\
 PAUSE, GAME.OVER
numeric EASY=5000, NORMAL=4000, HARD=2000

BOX board, my.box
integer my.n, red.n, magic.n=10101101b
integer cbit.x, cbit.y, bits.h
numeric BIT.*, W=32, H=48

text my.numbers(8+4), red.numbers(8+4)

FONT main.font='font'

IMAGE bits.i='bits', bit1.i='1',\
 bit0.i='0', close.i='x'

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

function random.byte
  locals n
  .r:
  random 3
  if r0<2
    random 16
  else.if r0=2
    random 128
  else.if r0=3
    random 255
  end
  . n=r0
  text.find red.numbers, n
  if true, go .r, end
  . r0=n
  if false, r0++, end
endf

function reset.game
  locals n, p
  . score=0, bits.h=1
  memory.zero my.numbers, 12
  memory.zero red.numbers, 12
  . n=8, p=red.numbers
  loop n
    random.byte
    . r1=p, *r1++=r0, p=r1
  endl
  set.box board, 4, 70, BIT.W*8, BIT.H*8
  . scene=SCENE.TITLE
endf

function on.create
  set.font main.font
  set.timer NORMAL
  reset.game
endf

function remove.byte, t, i
  locals n
  alias p=r0, q=r1, x=r2
  if i=7, go .new, end
  . p=t, p+i, q=p, q++, x=7, x-i, n=x
  loop n, *p++=*q++, endl
  .new:
  . p=my.numbers, *(p+7)=0
  random.byte
  . q=red.numbers, *(q+7)=r0
endf

function remove.row, i
  remove.byte my.numbers, i
  remove.byte red.numbers, i
  . bits.h--
  if bits.h<1, bits.h=1, end
endf

function check.numbers
  locals i
  . i=0
  while i<8, r0=my.numbers, r0+i
    . r1=*r0, r0=red.numbers
    . r0+i, r2=*r0
    if r1=r2, score+r1
      remove.row i
      return 1
    end
    . i++
  endw
endf 0

function draw.board
  locals i, n, x, y, w, h
  draw.image bits.i, 4, 35
  draw.image bits.i, 4, 457
   . x=0, y=0, w=32, h=48
  while y<8, x=0
    while x<8
      . r0=x, r0*w, r0+board.x
      . r1=y, r1*h, r1+board.y
      set.box my.box, r0, r1, w, h
      draw.box my.box, WHITE, GRAY
      . x++
    endw
    . r0=x, r0*w, r0+board.x
    . r1=y, r1*h, r1+board.y
    set.box my.box, r0, r1, 48, h
    draw.box.o my.box, WHITE
    . my.box.x+48
    draw.box.o my.box, RED
    . r0=y, r1=8, r1-bits.h
    if r0>=r1
      . r0=my.numbers, r1=y, r2=8
      . r2-bits.h, r1-r2, r0+r1
      . r1=*r0, my.n=r1
      . r0=red.numbers, r1=y, r2=8
      . r2-bits.h, r1-r2, r0+r1
      . r1=*r0, red.n=r1
      u2t my.n, t
      . my.box.x-40, my.box.y+11
      draw.text t, my.box.x, my.box.y
      . my.box.x+44
      u2t red.n, t
      draw.text t, my.box.x, my.box.y
    end
    . y++
  endw
endf

function draw.bit, n, x, y
  if n
    draw.image bit1.i, x, y
  else
    draw.image bit0.i, x, y
  end
endf

function draw.byte, n, x, y
  locals i
  . i=8
  loop i, r0=n, r1=i, r1--, r0>>cl, r0&1
    draw.bit r0, x, y
    . x+BIT.W
  endl
endf

function draw.my.numbers
  locals i, n, y
  . i=bits.h, y=404
  loop i, r0=my.numbers, r0+i, r0--
    . r0=*r0, n=r0
    draw.byte n, 4, y
    . y-BIT.H
  endl
endf

function draw.title.scene
  draw.text help.t, 16, 130
  draw.byte magic.n, 50, 300
endf

function draw.play.scene
  draw.board
  draw.my.numbers
endf

function draw.pause.scene
  draw.text pause.t, 16, 130
  draw.byte magic.n, 50, 300
endf

function draw.game.over
  print t, game.over.t, score
  draw.text t, 44, 170
  draw.byte magic.n, 50, 300
endf

function on.draw
  locals x, y, w, h
  clear.screen BLACK
  print t, title.t, score
  draw.text t, 4, 4
  draw.image close.i, 324, 4
  . r0=screen.w, r0--
  . r1=screen.h, r1--
  draw.outline 0, 0, r0, r1, GRAY
  if scene=SCENE.TITLE
    draw.title.scene
  else.if scene=SCENE.PLAY
    draw.play.scene
  else.if scene=SCENE.PAUSE
    draw.pause.scene
  else.if scene=SCENE.GAME.OVER
    draw.game.over
  end
  show.vga
endf

function on.key
  if key.event='c'
    if scene=SCENE.TITLE
      . scene=SCENE.PLAY
      go .draw
    end
    if scene=SCENE.GAME.OVER
      go .reset
    end
    if key='r'
      .reset:
      reset.game
      go .draw
    end
    if key='p'
      .pause:
      if scene=SCENE.PLAY
        . scene=SCENE.PAUSE
      else.if scene=SCENE.PAUSE
        . scene=SCENE.PLAY
      end
      go .draw
    end
    .draw:
    render
  end
endf

function on.mouse
  if.select board
    . r0=mouse.x, r0-window.x, r0-board.x
    . r1=BIT.W, r0/r1, cbit.x=r0
    . r0=mouse.y, r0-window.y, r0-board.y
    . r1=BIT.H, r0/r1, cbit.y=r0
    if mouse.event='c'
      . r0=cbit.y, r1=8, r1-bits.h
      if r0>=r1, r0=my.numbers, r1=cbit.y
        . r2=8, r2-bits.h, r1-r2, r0+r1
        . r3=*r0, r2=1, r1=7, r1-cbit.x
        . r2<<cl, r3><r2, *r0=r3
      end
    end
  end
  if mouse.event='r'
    check.numbers
    go .draw
  end
  if mouse.event='c'
    . r0=&close.i.x
    if.select r0
      exit
    end
    if scene<>SCENE.PLAY
      reset.game
      . scene=SCENE.PLAY
    end
    .draw:
    render
  end
endf

function on.timer
  if scene<>SCENE.PLAY
    return
  end
  if mouse.1, return, end
  if bits.h<8, bits.h++
  else
    . scene=SCENE.GAME.OVER
  end
  render
endf

function on.exit
  ; ...
endf