kolibrios-fun/programs/games/pipes/pipes.asm

;
;   pipes kolibri
;   v1.21
;   2006 by Mario Birkner
;
;   l.mod. 27.08.06/15:11
;
;   Compile with FASM
;
bgcolor  equ  0x0074744A      ;thx
fgcolor  equ  0x00E7C750      ;to
fg2color equ  0x00E0B0A0      ;colorref
fg3color equ  0x007F7F55
btcolor  equ  0x005B6200

include '..\..\macros.inc'
include 'lang.inc'
; fetch the UTF-8 character in string+offs to char
; common part for all encodings: translate pseudographics
; Pseudographics for the boot screen:
; 0x2500 -> 0xC4, 0x2502 -> 0xB3, 0x250C -> 0xDA, 0x2510 -> 0xBF,
; 0x2514 -> 0xC0, 0x2518 -> 0xD9, 0x252C -> 0xC2, 0x2534 -> 0xC1, 0x2551 -> 0xBA
macro fetch_utf8_char string, offs, char, graph
{ local first_byte, b
  virtual at 0
    db string
    if offs >= $
      char = -1
    else
      ; fetch first byte
      load first_byte byte from offs
      if first_byte < 0x80
        char = first_byte
        offs = offs + 1
      else if first_byte < 0xC0
        .err Invalid UTF-8 string
      else if first_byte < 0xE0
        char = first_byte and 0x1F
        load b byte from offs + 1
        char = (char shl 6) + (b and 0x3F)
        offs = offs + 2
      else if first_byte < 0xF0
        char = first_byte and 0xF
        load b byte from offs + 1
        char = (char shl 6) + (b and 0x3F)
        load b byte from offs + 2
        char = (char shl 6) + (b and 0x3F)
        offs = offs + 3
      else if first_byte < 0xF8
        char = first_byte and 0x7
        load b byte from offs + 1
        char = (char shl 6) + (b and 0x3F)
        load b byte from offs + 2
        char = (char shl 6) + (b and 0x3F)
        load b byte from offs + 3
        char = (char shl 6) + (b and 0x3F)
        offs = offs + 4
      else
        .err Invalid UTF-8 string
      end if
    end if
  end virtual
  if char = 0x2500
    graph = 0xC4
  else if char = 0x2502
    graph = 0xB3
  else if char = 0x250C
    graph = 0xDA
  else if char = 0x2510
    graph = 0xBF
  else if char = 0x2514
    graph = 0xC0
  else if char = 0x2518
    graph = 0xD9
  else if char = 0x252C
    graph = 0xC2
  else if char = 0x2534
    graph = 0xC1
  else if char = 0x2551
    graph = 0xBA
  else
    graph = 0
  end if
}
; Latin-1 encoding
; 0x00-0xFF - trivial map
macro latin1 [arg]
{ local offs, char, graph
  offs = 0
  while 1
    fetch_utf8_char arg, offs, char, graph
    if char = -1
      break
    end if
    if graph
      db graph
    else if char < 0x100
      db char
    else
      .err Failed to convert to Latin-1
    end if
  end while
}
use32

	       org    0x0

	       db     'MENUET01'	      ; 8 byte id
	       dd     0x01		      ; header version
	       dd     START		      ; start of code
	       dd     I_END		      ; size of image
	       dd     0x100000		      ; memory for app
	       dd     0x7fff0		      ; esp
	       dd     0x0 , 0x0 	      ; I_Param , I_Icon

START:				; start of execution
     jmp red

still:
    mcall 10            ; wait here for event
    cmp  eax,1			; redraw request ?
     je  red
    cmp  eax,2			; key in buffer ?
     je  key
    cmp  eax,3			; button in buffer ?
     je  button
    jmp  still

  red:				; redraw
    call draw_window
    call draw_board
    call draw_message
    jmp  still

  key:				; key
    mcall 2			; just read it and ignore
    jmp  still
  button:			; button
    call get_input
    jmp  still



get_input:
pusha
    mcall 17			; get id

    cmp  ah,1			; button id=1 ?
    jne  .noclose
    mcall -1			; close this program
  .noclose:
    cmp  ah,4
    jne  .moderate
    mov  [diffic],1
    jmp  .enddiffic
   .moderate:
    cmp  ah,3
    jne  .easy
    mov  [diffic],3
    jmp  .enddiffic
   .easy:
    cmp  ah,2
    jne  .board
    mov  [diffic],5
   .enddiffic:
    mov  [score],0
    mov  [speed],40
    mov  [level],1
    mov  [stat],0
    mov  [time],0
    call draw_window
    call scramble_board
    call draw_board
    call countdown
    call wassermarsch
    jmp  .getno
  .board:
    cmp  [stat],2
    jge  .getno
    shr  eax,8			; -> 24bit id
    cmp  eax,10
    jle  .getno
    cmp  eax,150
    jg	 .getno
    sub  eax,10
    mov  edi,eax
    add   edi,map
    cmp   [edi], byte 1
    jg	  .nogerade
    xor   byte [edi], 1
    call  draw_board
    jmp   .getno
  .nogerade:
    cmp   [edi], byte 6
    jge   .getno
    cmp   [edi], byte 5
    jne   .rota
    sub   byte [edi],4
  .rota:
    inc   byte [edi]
    call  draw_board
  .getno:
popa
ret
;//// end of event detection
get_direction:		    ;Setzt Richtungs-Konstanten
pusha			    ;IN:
mov eax,[esp+28]	    ;eax  -  Richtung IN
mov ebx,[esp+16]	    ;ebx  -  Teilchen (Map-Wert)
cmp ebx,0		    ;OUT:
jne .no0		    ;eax  -  Richtung OUT
  cmp eax,14
  jne .o0
  jmp .setout
  .o0:
  cmp eax,-14
  jne .col
  jmp .setout
.no0:
cmp ebx,1
jne .no1
  cmp eax,1
  jne .o1
  jmp .setout
  .o1:
  cmp eax,-1
  jne .col
  jmp .setout
.no1:
cmp ebx,2
jne .no2
  cmp eax,14
  jne .o2
  sub eax,13
  jmp .setout
 .o2:
  cmp eax,-1
  jne .col
  sub eax,13
  jmp .setout
.no2:
cmp ebx,3
jne .no3
  cmp eax,-14
  jne .o3
  add eax,15
  jmp .setout
 .o3:
  cmp eax,-1
  jne .col
  add eax,15
  jmp .setout
.no3:
cmp ebx,4
jne .no4
  cmp eax,-14
  jne .o4
  add eax,13
  jmp .setout
 .o4:
  cmp eax,1
  jne .col
  add eax,13
  jmp .setout
.no4:
cmp ebx,5
jne .no5
  cmp eax,14
  jne .o5
  sub eax,15
  jmp .setout
 .o5:
  cmp eax,1
  jne .col
  sub eax,15
  jmp .setout
.no5:
cmp ebx,6
jne .no6
  jmp .setout
.no6:
cmp ebx,7
jne .no7
  mov eax,14
  jmp .setout
.no7:
cmp ebx,8
jne .no8
  cmp eax,14
  jne .col
  mov [stat],1
  jmp .setout
.no8:
cmp ebx,16	  ; cross 2x
jne .col
  add [score],10  ; + 10 bonus points
  jmp .setout
.col:
xor eax,eax
.setout:
xor ebx,ebx
mov [esp+28],eax
mov [esp+16],ebx
popa
ret

countdown:
pusha
xor  eax,eax
mov  al,[diffic]
imul eax,10
mov  [time],eax
.udown:
call show_score
mov  ecx,10
.down:
mov  eax,5
mov  ebx,10
mcall
mov  eax,11
mcall
cmp  eax,1
jne  .nored
call draw_window
call draw_board
jmp  .nothing
.nored:
cmp  eax,3
jne  .nothing
call get_input
.nothing:
cmp  [stat],0	      ;bugfix 210806
jnz  .exitsub	      ;bugfix 210806
dec  ecx
jnz  .down
dec  [time]
jnz   .udown
.exitsub:	      ;bugfix 210806
popa
ret

wassermarsch:
pusha
   .restart:
     mov  esi,map+16	      ;start position
     mov  eax, 14	      ;start-richtung
   .findway:
     movzx ebx, byte [esi]
     call  get_direction
     test  eax,eax
     jz   .collision
     push  eax
      xor   eax,eax
      mov   al,6
      sub   al,[diffic]
      add   [score],eax 	 ;points/item = 6 - difficulty
      mov   ecx,dword [speed]
      add   byte [esi],10
      .down:
      mov   eax,5
      mov   ebx,2
      mcall
      mov   eax,11
      mcall
      cmp   eax,1
      jne   .nored
      call  draw_window
      .nored:
      cmp   eax,3
      jne   .noevnt
      call  get_input
      .noevnt:
      dec   ecx
      jnz   .down
     pop   eax

     add   esi,eax
     call  draw_board
     call  show_score
     jmp   .findway
   .collision:
    cmp [stat],1
    jne .loose
    call draw_message
    mov   eax,5
    mov   ebx,500
    mcall
    mov [stat],0
    inc [level]
    cmp [speed],6		 ;waterflowdelay < 6 ?
    jle .skipsub
    sub [speed],2
   .skipsub:
    call draw_window
    call scramble_board
    call draw_board
    call countdown
    jmp  .restart
   .loose:
    mov  [stat],2
    call draw_message
popa
ret

show_score:
pusha
mov  eax,13			 ;clear time and score area
mov  ebx,50 shl 16 +15
mov  ecx,395 shl 16 +15
mov  edx,bgcolor
mcall
if lang eq et
add  ebx,60 shl 16 + 30
else
add  ebx,60 shl 16 + 20
end if
mcall
add  ebx,80 shl 16
mcall
mov  eax,47
mov  ebx,0x20000
mov  ecx,[time]
mov  edx,50*65536+398
mov  esi,fg2color
mcall
mov  ebx,0x50000
mov  ecx,[score]
if lang eq et
add  edx,70 shl 16
else
add  edx,60 shl 16
end if
mcall
mov  ebx,0x20000
mov  ecx,[level]
add  edx,80 shl 16
mcall

popa
ret



scramble_board:
pusha
mov edi,map+16 ;startpunkt
mov eax,7      ;wieder-
stosb	       ;herstellen

mov ebx, 0x00000007  ;modul         m max-wert
.loop_through:
mov   esi,edi
lodsb
cmp   eax, 9
 je   .skip
inc   eax
xor   edx, edx
div   ebx	    ;modulo -> edx
mov   eax, edx
cmp   eax,6
jne   .skip
dec   [half]
movzx eax, byte [half]
jnz   .skip
mov   [half], byte 7
.skip:
stosb
cmp edi,map+125 ;endpunkt erhalten
jge .exit
jmp .loop_through
.exit:
mov  eax,8
stosb
popa
ret


gen_image:
pusha
    xor   ebx,ebx	   ;default: kein wasser
    movzx eax,byte [map]   ;erstes byte der map lesen (position)
    inc   byte [map]	   ;position inkrementieren
    add   eax,map	   ;zur position die map-adresse addieren
    movzx  esi,byte [eax]
    cmp   esi,10
    jl	  .nowater
    sub   esi,10	  ;map-werte+10 sind mit wasser gefuellt
    mov   ebx,1
    cmp   esi,16
    jne   .nowater
    sub   esi,10
 .nowater:
   imul  esi,3072	  ;mapwert * 32*32*3 = image-adresse
    add  esi,images
    mov  edi,0x10000
    mov  ecx,32*32*3
 .gendd:		  ;RGB-Image im Speicher generieren
    mov   eax,dword [esi] ;byte aus imagemap lesen
    shl   eax,8
    shr   eax,8
    cmp   ebx,0
    jz	  .nowcolor
    mov   ebx,eax
    cmp   ebx,0x00B0B5B0
    jne   .nog1
    jmp   .wcolor
 .nog1:
    cmp   ebx,0x00A0A5A0
    jne   .nog2
    jmp   .wcolor
 .nog2:
    cmp   ebx,0x00909590
    jne   .nog3
    jmp   .wcolor
 .nog3:
    cmp   ebx,0x00808580
    jne   .nog4
    jmp   .wcolor
 .nog4:
    cmp   ebx,0x00707570
    jne   .nowcolor
    jmp   .wcolor
 .wcolor:
    add   eax,0x40
 .nowcolor:
    add  esi,3
    stosd
    dec  edi
    loop .gendd
popa
ret



;   *********************************************
;   *******  WINDOW DEFINITIONS AND DRAW ********
;   *********************************************
draw_message:
pusha
    cmp  [stat],0
	je .nomessage
    mov  eax,13
    mov  ebx,146 shl 16 + 200
    mov  ecx,190 shl 16 + 40
    mov  edx,0x0
    mcall
    add  ebx,2 shl 16 - 4
    add  ecx,2 shl 16 - 4
    mov  edx,fgcolor
    mcall

	cmp  [stat],3
	jne .stat1
    mov   eax,4
    mov   ebx,174 shl 16 +206
    mov   edx,lbl_start_a_new_game+1
    movzx esi,byte [lbl_start_a_new_game]
    mov   ecx,btcolor
    add   ecx,0x10000000
    mcall
    jmp	.nomessage

  .stat1:	
    cmp   [stat],1
     je   .winmessage
    mov   eax,4
    mov   ebx,186 shl 16 +200
    mov   edx,lbl_gameover+1
    movzx esi,byte [lbl_gameover]
    mov   ecx,btcolor
    add   ecx,0x10000000
    mcall
    add   ebx,8 shl 16 +17
    mov   edx,lbl_yscore+1
    movzx esi,byte [lbl_yscore]
    mov   ecx,btcolor
    mcall
    mov   esi,ecx	;color
    mov   edx,ebx	;pos
    add   edx,80 shl 16
    mov   ebx,0x50000	 ;type
    mov   ecx,[score]	 ;inp
    mov   eax,47
    mcall
    jmp   .nomessage
   .winmessage:
    mov   eax,4
    mov   ebx,152 shl 16 +200
    mov   edx,lbl_win+1
    movzx esi,byte [lbl_win]
    mov   ecx,btcolor
    add   ecx,0x10000000
    mcall
    mov   ebx,152 shl 16 +217
    add   edx,esi
    mov   ecx,btcolor
    mcall
   .nomessage:
popa
ret

draw_board:
pusha
 mov  ebx,15*65536+32
 mov  ecx,50*65536+32
 mov  edx,15*65536+50		 ;Spielfeldposition
 mov  esi,10			  ;Spielfeldgroesse Y
 .vloop:
  mov  edi,14			 ;Spielfeldgroesse X
  .hloop:
    call gen_image
    push edx
    mov  eax,8
    movsx edx, byte [map]
    add  edx,9		    ;button-id = map-pos + 10;gen_image inkrements
    add  edx,0x80000000     ;first delete previous button
	mcall
    sub  edx,0x30000000     ;first delete previous button
    mcall
    pop  edx
    push ebx
    push ecx
    mov  eax,7
    mov  ebx,0x10000
    mov  ecx,32 shl 16 +32
    mcall
    pop  ecx
    pop  ebx
    add  edx,33 shl 16
    add  ebx,33 shl 16
    dec  edi
    jnz  .hloop
  sub  edx,14*(33 shl 16)	 ;Spielfeldgroesse X
  sub  ebx,14*(33 shl 16)
  add  edx,33
  add  ecx,33 shl 16
  dec  esi
  jnz  .vloop
  mov  [map], byte 1		 ;Map-Position zuruecksetzen
popa
ret


draw_window:
pusha

    mcall 12,1
	
    mov  eax,0			   ; function 0 : define and draw window
    mov  ebx,100*65536+492	   ; [x start] *65536 + [x size]
    mov  ecx,100*65536+420	   ; [y start] *65536 + [y size]
    mov  edx,bgcolor		   ; color of work area RRGGBB,8->color gl
    or   edx,0x14000000
    mov  edi,title
    mcall

    mov   eax,8
    mov   ebx,84*65536+72
    mov   ecx,28*65536+15
    mov   edx,2
    mov   esi,btcolor
    mcall
    add   ebx,76 shl 16
    inc   edx
    mcall
    add   ebx,76 shl 16
    inc   edx
    mcall

    mov   eax,4
    mov   ebx,26 shl 16 +32
    mov   ecx,fgcolor
    mov   edx,lbl_toolbar+1
    movsx esi, byte [lbl_toolbar]
    mcall
    mov   ebx,18 shl 16 +398
    mov   edx,lbl_score+1
    movsx esi, byte [lbl_score]
    mcall
    mov   ebx,340 shl 16 +405
    mov   ecx,fg3color
    mov   edx,lbl_copy+1
    movsx esi,byte [lbl_copy]
    mcall

    mcall 12,2

    popa
    ret


; DATA AREA
if lang eq et
title  db  'Torud',0
lbl_gameover:
     db 19
     latin1 'M ä n g   L ä b i !'
lbl_start_a_new_game:
     db 21
     latin1 'Alusta enne uut mängu'
lbl_win:
     db 32
     latin1 '          T u b l i !           '
     latin1 '          Lähme edasi!          '
lbl_yscore:
     db 12
     latin1 'Sinu tulemus:'
lbl_toolbar:
     db 43
     latin1 'Uus mäng:     Lihtne     Keskmine     Raske'
lbl_copy:
     db 24
     latin1 'v1.21 2006,Mario Birkner'
lbl_score:
     db 28
     latin1   'Aeg:    Tulemus:       Tase:'
else
title  db   'Pipes',0
lbl_gameover:
     db 19
     db 'G a m e   O v e r !'
lbl_start_a_new_game:
     db 22
     db 'Start a new game first'
lbl_win:
     db 32
     db '          G r e a t !           '
     db "        Let's goin'on!          "
lbl_yscore:
     db 11
     db 'Your Score:'
lbl_toolbar:
     db 43
     db 'New Game:     Easy       Moderate      Hard'
lbl_copy:
     db 24
     db 'v1.21 2006,Mario Birkner'
lbl_score:
     db 28
     db   'Time:    Score:       Level:'
end if
stat	db 3  ;0=gameplay 1=won 2-lost 3=stopped
speed	db 0
time	dd 0
diffic	db 0  ;1=hard 3=moderate 5=easy 8=dedicated to Wildwest - try it out!
score	dd 0
level	dd 1
half	db 1  ;reduces the random-crosses

map:	   ;14*10 blocks + position
     db 1  ;<- act. position
     db 9,9,9,9,9,9,9,9,9,9,9,9,9,9
     db 9,7,1,3,2,0,1,1,0,3,4,4,3,9
     db 9,5,0,2,2,1,3,0,3,1,1,6,4,9
     db 9,4,0,4,6,0,3,3,2,6,0,1,2,9
     db 9,3,0,1,2,4,6,4,5,1,2,4,1,9
     db 9,5,3,2,6,3,2,1,2,1,2,6,0,9
     db 9,4,0,2,3,0,4,1,2,3,2,3,4,9
     db 9,2,0,4,5,6,3,1,3,0,4,1,0,9
     db 9,1,0,3,5,4,2,2,4,1,6,0,8,9
     db 9,9,9,9,9,9,9,9,9,9,9,9,9,9
images:
file 'pipes.raw'
I_END: