kolibrios-gitea/programs/games/invaders/invaders.asm

;=============================================================================;
; Hidnplayr's invaders, Compilable for DexOs and Kolibrios                    ;
;-----------------------------------------------------------------------------;
;                                                                             ;
; Copyright (C) hidnplayr 2007. All rights reserved.                          ;
;                                                                             ;
; Invaders is distributed in the hope that it will be useful, but WITHOUT ANY ;
; WARRANTY. No author or distributor accepts responsibility to anyone for the ;
; consequences of using it or for whether it serves any particular purpose or ;
; works at all, unless he says so in writing. Refer to the GNU General Public ;
; License (the "GPL") for full details.                                       ;
; Everyone is granted permission to copy, modify and redistribute KolibriOS,  ;
; but only under the conditions described in the GPL. A copy of this license  ;
; is supposed to have been given to you along with KolibriOS so you can know  ;
; your rights and responsibilities. It should be in a file named COPYING.     ;
; Among other things, the copyright notice and this notice must be preserved  ;
; on all copies.                                                              ;
;                                                                             ;
; see copying.txt                                                             ;
;                                                                             ;
; contact me on hidnplayr@gmail.com                                           ;
;                                                                             ;
;-----------------------------------------------------------------------------;


SCREEN_X equ 640
SCREEN_Y equ 480

SHIP_X equ 32
SHIP_Y equ 32

SHIP_X_POS equ (SCREEN_X-SHIP_X)/2
SHIP_Y_POS equ SCREEN_Y-SHIP_Y-27

ENEMY_X equ 32
ENEMY_Y equ 32

ALIEN_X equ 48
ALIEN_Y equ 38
ALIEN_Y_POS equ 1

BOUNDARY equ 10
MOVEMENT equ 7

TRANSPARENCY equ 0x00000000

WINDOW_X equ 100
WINDOW_Y equ 100

BULLET_X equ 10
BULLET_Y equ 10

STARS_   equ 226
STARLEVELS equ 3

ENEMY_STARTING_X equ 25
ENEMY_STARTING_Y equ 50

BULLETSPEED equ 12

SCREEN_X_POS equ 5
SCREEN_Y_POS equ 25

gif_hash_offset = gif_hash_area

include 'ascgl.inc'
include 'invaders_kolibri.inc'

decodegif:
        giftoimg gif_bullet,bullet
        giftoimg gif_bullet2,bullet2
        giftoimg gif_ship,ship
        giftoimg gif_enemy1,enemy1
        giftoimg gif_enemy2,enemy2
        giftoimg gif_enemy3,enemy3
        giftoimg gif_enemy4,enemy4
        giftoimg gif_enemy5,enemy5
        giftoimg gif_alien,alien
        giftoimg gif_menu1,menu1
        giftoimg gif_menu2,menu2
        giftoimg gif_menu3,menu3
        giftoimg gif_menu4,menu4
        giftoimg gif_logo,logo
        giftoimg gif_pause,pause_
        giftoimg gif_levelup,levelup
        giftoimg gif_gameover,gameover
        giftoimg gif_highscore,highscore
        giftoimg gif_smallfont,smallfont
        giftoimg gif_bigfont,bigfont
        giftoimg gif_numbers,numbers

        call  createstars
        call  drawit
        call  [drawroutine]

mainloop:

    cmp  byte[status],3 ; if game is paused,...
    je   waitfordraw

    call drawit
    call [drawroutine]
    call checkbullet

   waitfordraw:

    call waitandgetkey ;;;
    test ah,ah
    jz   mainloop

    cmp  byte[status],1      ;
    jne  nogame

         cmp  ah, KEY_RIGHT
         jnz  noright
         cmp  dword[ship_x],SCREEN_X-SHIP_X-BOUNDARY
         jge  mainloop
         add  dword[ship_x],MOVEMENT

         jmp  mainloop

       noright:
         cmp  ah, KEY_LEFT
         jnz  noleft
         cmp  dword[ship_x],BOUNDARY
         jle  mainloop
         sub  dword[ship_x],MOVEMENT

         jmp  mainloop

       noleft:
         cmp  ah, KEY_UP
         jnz  noup

         cmp  dword[bullet_y],1
         jg   mainloop

         mov  eax,dword[ship_x]
         add  eax,(SHIP_X-BULLET_X)/2
         mov  dword[bullet_x],eax
         mov  dword[bullet_y],SHIP_Y_POS;-BULLET_Y

         jmp  mainloop

       noup:
         cmp  ah,KEY_P
         jnz  no_pause1

         mov  byte[status],3
         aimgtoimg pause_,150,180,vscreen,TRANSPARENCY,0
         call [drawroutine]

         jmp  mainloop

       no_pause1:

nogame:
    cmp  byte[status],0
    jne  nomenu

         cmp  ah, KEY_DOWN
         jnz  no_down

         cmp  byte[menu],3
         jne  no_menu1

         mov  byte[menu],0
         jmp  nomenu

       no_menu1:
         inc  byte[menu]

       no_down:
         cmp  ah, KEY_UP
         jnz  no_up

         cmp  byte[menu],0
         jne  no_menu0

         mov  byte[menu],3
         jmp  nomenu

       no_menu0:
         dec  byte[menu]

       no_up:

         cmp  ah, KEY_ESC
         je   exit

       no_esc:
         cmp  ah, KEY_ENTER
         jnz  no_enter

        exemenu:
                cmp  byte[menu],0  ;start
                jne  exemenu1

              new_game:
                        mov  dword[score],0
                        mov  eax,[score]
                        call convertscore

                        mov  esi, level1
                        mov  word[levelnumb],'01'
              load_level:
                        mov  byte[enemy_speed],1
                        mov  dword[enemy_x], ENEMY_STARTING_X
                        mov  dword[enemy_y], ENEMY_STARTING_Y

                        mov  edi, enemy_table
                        mov  ecx, 5
                        rep  movsd

                        mov  byte[status],1

                        jmp  mainloop

        exemenu1:
                cmp  byte[menu],1  ;about
                jne  exemenu2
                mov  byte[status],4
                jmp  mainloop

        exemenu2:
                cmp  byte[menu],2  ;highscores
                jne  exemenu3
                mov  byte[status],5
                call load_highscores
                jmp  mainloop

        exemenu3:
                cmp  byte[menu],3  ;exit
                je   exit

      no_enter:
nomenu:
    cmp  byte[status],3
    jne  nopause

    cmp  ah, KEY_P
    jnz  nopause

    mov  byte[status],1

nopause:
    cmp  byte[status],6
    jne  nolevelup

    cmp  ah, KEY_ENTER
    jne  nolevelup

        inc  byte[level]

;        cmp  byte[level],5
;        jne  @f
;        mov  byte[level],0

;@@:
        inc  byte[levelnumb+1]
        cmp  byte[levelnumb+1],'9'
        jle  @f
        mov  byte[levelnumb+1],'0'
        inc  byte[levelnumb]

       @@:
        mov  eax,20
        mov  ah,byte[level]
        and  ah,7
        mul  ah
        add  eax,level1
        mov  esi,eax
        jmp  load_level

nolevelup:
    cmp  byte[status],7
    jne  nohighscore

        cmp   ah, KEY_ENTER
        jne   @f

        call  load_highscores
        mov   eax,dword[score]
        mov   ebx,gif_hash_area+140
    .findscore:
        cmp   ebx,gif_hash_area+100
        je    .topscore
        sub   ebx,4
        cmp   eax,dword[ebx]
        jg    .findscore

    .topscore:
        mov   esi,name
        mov   edi,gif_hash_area
        mov   ecx,10
        rep   movsb

        mov   eax,dword[score]
        mov   dword[gif_hash_area+100],eax

        call  save_highscores
        mov   byte[status],5

@@:
        cmp   ah,14
        jne   @f

        cmp   byte[namepos],0
        je    @f

        dec   byte[namepos]
        movzx ebx,byte[namepos]
        add   ebx,name
        mov   byte[ebx],0x11  ; this is a character we dont print

@@:
        cmp   byte[namepos],10
        jge   nohighscore

        cmp   al,'0'
        jl    nohighscore
        cmp   al,'9'
        jle   @f

        cmp   al,'z'
        jg    nohighscore
        cmp   al,'a'
        jge   @f

        cmp   al,'Z'
        jg    nohighscore
        cmp   al,'A'
        jl    nohighscore
@@:

        movzx ebx,byte[namepos]
        add   ebx,name
        mov   byte[ebx],al

        inc   byte[namepos]

        jmp   mainloop

nohighscore:
    cmp  byte[status],2 ; gameover
    jne  nogameover

    cmp  ah, KEY_ENTER
    jne  nogameover

        ; test if score is high enough to put in highscore list...
        mov   byte[status],7

        jmp   mainloop

nogameover:
    cmp  byte[status],0
    je   mainloop

    cmp  ah, KEY_ESC
    jnz  mainloop

    mov  byte[status],0
    mov  word[intro],0

    jmp  mainloop

 ;----------------------------------------------------;
 ; Drawing routine: create image in buffer            ;
 ;----------------------------------------------------;
drawit:
    mov  eax,0x00000000
    call fillscreen
    call drawstars

    cmp  byte[status],1
    jne  @f

        call drawbullet
        call drawenemys                                               ; Draw the enemy's to buffer
        aimgtoimg ship,dword[ship_x],SHIP_Y_POS,vscreen,TRANSPARENCY,0  ; Draw the ship to buffer

        mov  esi,scoretext
        mov  ebx,0
        mov  ecx,SCREEN_Y-24
        call printtext

        mov  esi,leveltext
        mov  ebx,300
        call printtext

    ret

@@:
    cmp  byte[status],2 ; game over, dude !
    jne  @f

        aimgtoimg ship,dword[ship_x],SHIP_Y_POS,vscreen,TRANSPARENCY,0  ; Draw the ship to buffer

        mov  esi,scoretext
        mov  ebx,0
        mov  ecx,SCREEN_Y-24
        call printtext

        mov  esi,leveltext
        mov  ebx,300
        call printtext
        aimgtoimg gameover,150,180,vscreen,TRANSPARENCY,0

        ret

@@:
    cmp  byte[status],4 ; about screen
    jne  @f

        mov  esi,msgAbout
        mov  ebx,50
        mov  ecx,100
        call printtext

        ret

@@:
    cmp  byte[status],6 ; level up!
    jne  @f
        aimgtoimg ship,dword[ship_x],SHIP_Y_POS,vscreen,TRANSPARENCY,0  ; Draw the ship to buffer

        mov  esi,scoretext
        mov  ebx,0
        mov  ecx,SCREEN_Y-24
        call printtext

        mov  esi,leveltext
        mov  ebx,300
        call printtext
        aimgtoimg levelup,150,180,vscreen,TRANSPARENCY,0

        ret

@@:
    cmp  byte[status],0 ; menu!
    jne  @f

        aimgtoimg logo,50,80,vscreen,TRANSPARENCY,0


        cmp  byte[menu],0
        jne  .menu_0
        aimgtoimg menu1,30,200,vscreen,TRANSPARENCY,1
        jmp  .menu_1
    .menu_0:
        aimgtoimg menu1,30,200,vscreen,TRANSPARENCY,0
    .menu_1:
        cmp  byte[menu],1
        jne  .menu_2
        aimgtoimg menu2,80,250,vscreen,TRANSPARENCY,1
        jmp  .menu_3
    .menu_2:
        aimgtoimg menu2,80,250,vscreen,TRANSPARENCY,0
    .menu_3:
        cmp  byte[menu],2
        jne  .menu_4
        aimgtoimg menu3,120,300,vscreen,TRANSPARENCY,1
        jmp  .menu_5
    .menu_4:
        aimgtoimg menu3,120,300,vscreen,TRANSPARENCY,0
    .menu_5:
        cmp  byte[menu],3
        jne  .menu_6
        aimgtoimg menu4,150,350,vscreen,TRANSPARENCY,1
        jmp  .menu_7
    .menu_6:
        aimgtoimg menu4,150,350,vscreen,TRANSPARENCY,0
    .menu_7:

        cmp  word[intro],200
        je   .menu_75
        inc  word[intro]

    .menu_75:
        cmp  word[intro],0
        jl   .menu_8
        aimgtoimg enemy1,390,180,vscreen,TRANSPARENCY,0

        cmp  word[intro],15
        jl   .menu_8
        mov  esi,points_50
        mov  ebx,470
        mov  ecx,180
        call printtext

        cmp  word[intro],30
        jl   .menu_8
        aimgtoimg enemy2,390,220,vscreen,TRANSPARENCY,0

        cmp  word[intro],45
        jl   .menu_8
        mov  esi,points_100
        mov  ebx,450
        mov  ecx,220
        call printtext

        cmp  word[intro],60
        jl   .menu_8
        aimgtoimg enemy3,390,260,vscreen,TRANSPARENCY,0

        cmp  word[intro],75
        jl   .menu_8
        mov  esi,points_150
        mov  ebx,450
        mov  ecx,260
        call printtext

        cmp  word[intro],90
        jl   .menu_8
        aimgtoimg enemy4,390,300,vscreen,TRANSPARENCY,0

        cmp  word[intro],105
        jl   .menu_8
        mov  esi,points_200
        mov  ebx,450
        mov  ecx,300
        call printtext

        cmp  word[intro],120
        jl   .menu_8
        aimgtoimg enemy5,390,340,vscreen,TRANSPARENCY,0

        cmp  word[intro],135
        jl   .menu_8
        mov  esi,points_250
        mov  ebx,450
        mov  ecx,340
        call printtext

        cmp  word[intro],150
        jl   .menu_8
        aimgtoimg alien,380,380,vscreen,TRANSPARENCY,0

        cmp  word[intro],165
        jl   .menu_8
        mov  esi,points_1000
        mov  ebx,430
        mov  ecx,380
        call printtext

    .menu_8:
        ret
@@:
    cmp  byte[status],5 ;highscorelist
    jne  @f

        aimgtoimg highscore,60,40,vscreen,TRANSPARENCY,0

        mov  ebx,100                ; print names
        mov  ecx,120
        mov  esi,gif_hash_area
        call printtext

        mov  edi,gif_hash_area+100  ; print scores
        mov  esi,scorenumb
        mov  ebx,420
        mov  ecx,120

.highscoreloop:
        mov  eax,[edi]
        push ecx
        call convertscore
        pop  ecx
        push esi
        call printtext
        pop  esi
        add  ecx,26
        add  edi,4
        cmp  edi,gif_hash_area+140
        jl  .highscoreloop

@@:
    cmp  byte[status],7 ;highscore
    jne  @f

        aimgtoimg highscore,60,40,vscreen,TRANSPARENCY,0

        mov  ebx,60
        mov  ecx,200
        mov  esi,entername
        call printtext

        mov  ebx,250
        mov  ecx,250
        mov  esi,name
        call printtext

        mov  esi,scoretext
        mov  ebx,0
        mov  ecx,SCREEN_Y-24
        call printtext

        mov  esi,leveltext
        mov  ebx,300
        call printtext
@@:

    ret


drawenemys:
; check if direction should change
        test byte[enemy_d],2
        jz   @f

        add  dword[enemy_y],5

        mov  eax,[enemy_y]
        shr  eax,5
        add  al, byte[level]
        mov  byte[enemy_speed],al

        and  byte[enemy_d],1

       @@:
; move the aliens to left or right
        movzx eax,byte[enemy_speed]
        test byte[enemy_d],1
        jz   other_dir

        sub  dword[enemy_x],eax
        jmp  no_other_dir

     other_dir:
        add  dword[enemy_x],eax
     no_other_dir:

; initialization
        mov  byte[alldeadb],1
        mov  edi,enemy_table
        mov  eax,dword[enemy_x]
        mov  dword[current_enemy_x],eax
        mov  eax,dword[enemy_y]
        mov  dword[current_enemy_y],eax

     loopit:
        cmp  byte[edi],1
        je   drawenemy1

        cmp  byte[edi],2
        je   drawenemy2

        cmp  byte[edi],3
        je   drawenemy3

        cmp  byte[edi],4
        je   drawenemy4

        cmp  byte[edi],5
        je   drawenemy5

        jmp  dead_alien

     drawenemy1:
        mov  byte[alldeadb],0
        pusha
        aimgtoimg enemy1,dword[current_enemy_x],dword[current_enemy_y],vscreen,TRANSPARENCY,0
        popa

        jmp  checknext

     drawenemy2:
        mov  byte[alldeadb],0
        pusha
        aimgtoimg enemy2,dword[current_enemy_x],dword[current_enemy_y],vscreen,TRANSPARENCY,0
        popa

        jmp  checknext

     drawenemy3:
        mov  byte[alldeadb],0
        pusha
        aimgtoimg enemy3,dword[current_enemy_x],dword[current_enemy_y],vscreen,TRANSPARENCY,0
        popa

        jmp  checknext

     drawenemy4:
        mov  byte[alldeadb],0
        pusha
        aimgtoimg enemy4,dword[current_enemy_x],dword[current_enemy_y],vscreen,TRANSPARENCY,0
        popa

        jmp  checknext

     drawenemy5:
        mov  byte[alldeadb],0
        pusha
        aimgtoimg enemy5,dword[current_enemy_x],dword[current_enemy_y],vscreen,TRANSPARENCY,0
        popa

;        jmp  checknext

     checknext:
        cmp  byte[enemy_d],2
        jge  dont_change_dir

           movzx eax,byte[enemy_speed]

           cmp  byte[enemy_d],0
           jbe  change_dir

           cmp  dword[current_enemy_x],eax
           jg   dont_change_dir

           mov  byte[enemy_d],2

           jmp  dont_change_dir

        change_dir:
           mov  ebx, SCREEN_X-ENEMY_X
           sub  ebx, eax
           cmp  dword[current_enemy_x],ebx
           jl   dont_change_dir

           mov  byte[enemy_d],3

        dont_change_dir:
           cmp  dword[current_enemy_y],SHIP_Y_POS-ENEMY_Y-BOUNDARY
           je   gameover_

     dead_alien:
        cmp  edi,enemy_table+20
        jge  alldead

        inc  edi
        add  dword[current_enemy_x],ENEMY_X+BOUNDARY
        mov  eax,dword[current_enemy_x]
        sub  eax,dword[enemy_x]
        cmp  eax,5*(ENEMY_X+BOUNDARY)
        jl   no_newline

        sub  dword[current_enemy_x],5*(ENEMY_X+BOUNDARY)
        add  dword[current_enemy_y],ENEMY_Y+BOUNDARY
      no_newline:
        jmp  loopit

     alldead:
        cmp  byte[alldeadb],0
        je   enemy_end

        mov  byte[status],6
        jmp  mainloop

     enemy_end:
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
        cmp  dword[alien_x],5                                                     ;
        jge  @f

        call random_generator
        cmp  eax,0xffffffff/50 ; one out of 500 chances that it appears during this frame
        jl   alien_end

        mov  dword [alien_x],SCREEN_X-ALIEN_X

       @@:
        push  eax

        mov  eax, SCREEN_X                                                                                                                                                                                                                                 ;        mov  eax, SCREEN_X
        sub  eax, dword [alien_x]

        cmp  eax, ALIEN_X
        jle  @f
        mov  eax, ALIEN_X
       @@:

        getimg alien,0,0,10,ALIEN_Y,alienpiece
        aimgtoimg alien,dword [alien_x],ALIEN_Y_POS,vscreen,TRANSPARENCY,0
        sub  dword[alien_x],5                                                     ;
                                                                                  ;
        pop  eax                                                                  ;
                                                                                  ;
      alien_end:                                                                  ;
                                                                                  ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
        ret

drawbullet:
        cmp  dword[bullet_y],BULLETSPEED
        jl   nobullet
        sub  dword[bullet_y],BULLETSPEED

        aimgtoimg bullet,dword[bullet_x],dword[bullet_y],vscreen,TRANSPARENCY,0

      nobullet:
        ret

checkbullet:
        cmp  dword[bullet_y],BULLETSPEED                              ; does the bullet hit top of the screen?
        jle  hidebullet                                               ; yes, hide bullet

;        ; check if bullet is inside the enemy field (you can disble this if you want)
;        mov  eax,dword[enemy_y]
;        cmp  dword[bullet_y],eax
;        jl   nohit
;
;        add  eax,4*(ENEMY_Y+BOUNDARY)
;        cmp  dword[bullet_y],eax
;        jg   nohit
;
;        mov  eax,dword[enemy_x]
;        cmp  dword[bullet_x],eax
;        jl   nohit
;
;        add  eax,5*(ENEMY_Y+BOUNDARY)
;        cmp  dword[bullet_x],eax
;        jg   nohit
;
        mov  edi,enemy_table
        mov  eax,dword[enemy_x]
        mov  dword[current_enemy_x],eax
        mov  eax,dword[enemy_y]
        mov  dword[current_enemy_y],eax

       check:
        cmp  byte[edi],0                 ; is the enemy at this position alive?
        je   nextcheck                   ; no, try next enemy
        ; check if bullet hits current enemy

        mov  eax,dword[current_enemy_y]  ; move the enemy y position into eax
        cmp  dword[bullet_y],eax         ; is the bullet's y position less than eax (enemy y pos)
        jl   nextcheck                   ; yes, bullet can't be colliding, check next enemy

        add  eax,ENEMY_Y                 ; add the width of the enemy to the enemy's y position (wich is still stored in eax)
        cmp  dword[bullet_y],eax         ; is the bullet's y position greater than eax (the end of the enemy)
        jg   nextcheck                   ; yes, bullet can't be colliding, check next enemy

        mov  eax,dword[current_enemy_x]  ; now do the same but for the x positions
        cmp  dword[bullet_x],eax         ;
        jl   nextcheck                   ;
                                         ;
        add  eax,ENEMY_Y                 ;
        cmp  dword[bullet_x],eax         ;
        jg   nextcheck                   ;

        jmp  hit

      nextcheck:
        inc  edi
        add  dword[current_enemy_x],ENEMY_X+BOUNDARY
        mov  eax,dword[current_enemy_x]
        sub  eax,dword[enemy_x]
        cmp  eax,5*(ENEMY_X+BOUNDARY)
        jl   no_newline_

        sub  dword[current_enemy_x],5*(ENEMY_X+BOUNDARY)
        add  dword[current_enemy_y],ENEMY_Y+BOUNDARY
      no_newline_:

        cmp  edi,enemy_table+20         ; is this the last enemy?
        jg   nohit                      ; yes, none of them was hit
        jmp  check                      ; no, check if enemy is alive and draw it

      hit:
        movzx ebx,byte[edi]             ; mov the enemy number onto ebx
        add  dword[score],ebx           ; add this number to the score dword

        mov  eax,[score]
        call convertscore

        mov  byte[edi],0                ; hide the enemy
     hidebullet:
        mov  dword[bullet_y],1          ; mov the bullet to top of screen (hide it)
        jmp  noalienhit

     nohit:
        mov  eax,[alien_x]              ; check if we hit the big alien in the ufo
        cmp  [bullet_x],eax
        jl   noalienhit
        add  eax,ALIEN_X-BULLET_X
        cmp  [bullet_x],eax
        jg   noalienhit
        cmp  [bullet_y],ALIEN_Y_POS+ALIEN_Y
        jg   noalienhit

        add  dword[score],100/5
        mov  eax,[score]
        call convertscore

        mov  [alien_x],0

     noalienhit:

ret

convertscore:
        test al,1
        jz   .1
        mov  byte[scorenumb+5],'5'
        jmp  .2
.1:
        mov  byte[scorenumb+5],'0'
.2:
        shr  eax,1
        mov  ecx,10
        xor  edx,edx
        div  ecx
        add  dl,'0'
        mov  byte[scorenumb+4],dl
        xor  edx,edx
        div  ecx
        add  dl,'0'
        mov  byte[scorenumb+3],dl
        xor  edx,edx
        div  ecx
        add  dl,'0'
        mov  byte[scorenumb+2],dl
        xor  edx,edx
        div  ecx
        add  dl,'0'
        mov  byte[scorenumb+1],dl
        xor  edx,edx
        div  ecx
        add  dl,'0'
        mov  byte[scorenumb+0],dl

ret


fillscreen: ; eax - screen color ( 0x00RRGGBB )

        mov  edi,vscreen+8
        cld
        mov  ecx,SCREEN_X*SCREEN_Y
    .lab1:
        mov  [edi],eax
        add  edi,3
        loop .lab1

        ret


printtext:
        push  ebx

     loadbyte:
        movzx eax, byte[esi]
        test  eax, eax
        jnz   checkbyte

        pop   ebx

        ret

    checkbyte:
        cmp  al,13
        je   nextline
        cmp  al,' '
        je   space

        cmp  al,'0'
        jl   nextchar
        cmp  al,'9'
        jle  usenumbers

        cmp  al,'z'
        jg   nextchar
        cmp  al,'a'
        jge  usesmallfont

        cmp  al,'Z'
        jg   nextchar
        cmp  al,'A'
        jge  usebigfont

        jmp  nextchar


    usesmallfont:
        mov  edx,eax
        sub  edx,'a'
        mov  eax,12
        mul  edx
        mov  edx,eax

        pusha
        getimg smallfont,0,edx,20,12,char
        popa

        pusha
        add  ecx,4
        aimgtoimg char,ebx,ecx,vscreen,TRANSPARENCY,0
        popa

        add  ebx,20

        jmp  nextchar

    usebigfont:
        mov  edx,eax
        sub  edx,'A'
        mov  eax,20
        mul  edx
        mov  edx,eax

        pusha
        getimg bigfont,0,edx,28,20,char
        popa

        pusha
        aimgtoimg char,ebx,ecx,vscreen,TRANSPARENCY,0
        popa

        add  ebx,28

        jmp  nextchar

    usenumbers:
        mov  edx,eax
        sub  edx,'0'
        mov  eax,20
        mul  edx
        mov  edx,eax

        pusha
        getimg numbers,0,edx,16,20,char
        popa

        pusha
        aimgtoimg char,ebx,ecx,vscreen,TRANSPARENCY,0
        popa

        add  ebx,20

        jmp  nextchar

    space:
        add  ebx,20

    nextchar:
        inc  esi

        jmp  loadbyte

    nextline:
        pop  ebx
        push ebx
        add  ecx,26
        inc  esi

        jmp  loadbyte

gameover_:
    mov  byte[status],2

    ret


drawstars:
    mov   esi, STARS

.loop:
    cmp   esi, STARS+(STARS_*5)
    jge   .done

    movzx eax, byte[esi]    ; z (speed, brightness)
    movzx ebx, word[esi+1]  ; x
    movzx ecx, word[esi+3]  ; y
    add   bx , ax
    cmp   bx , SCREEN_X
    jl    .moveit

    xor   ebx,ebx
    inc   ebx

    call  random_generator
    mov   ecx, [generator]
    and   ecx, SCREEN_Y-1
    inc   ecx
    mov   word[esi+3],cx

    call  random_generator
    and   al, STARLEVELS
    test  al,al
    jnz   @f
    inc   al
   @@:
    mov   [esi],al

.moveit:
    mov   word [esi+1],bx

    movzx eax, byte[esi]
    inc   eax
    mov   edx, 0xff/(STARLEVELS+1)
    mul   edx

    mov   ah,al
    shl   eax,8
    mov   al,ah
    mov   ebp, eax

    mov   eax, SCREEN_X
    mul   ecx
    add   eax, ebx
    mov   edx, 3
    mul   edx

    cmp   eax, SCREEN_X*SCREEN_Y*3
    jg    @f
    add   eax, vscreen+8
    and   dword[eax],0xff000000
    or    dword[eax],ebp
   @@:

    add   esi, 5
    jmp   .loop
.done:

    ret


createstars:

    mov   ebx, STARS
.loop:
    cmp   ebx, STARS+(STARS_*5)
    jge   .done

    call  random_generator
    and   al, STARLEVELS
    test  al,al
    jnz   @f
    inc   al
   @@:
    mov   byte[ebx],al

    call  random_generator
    and   eax, SCREEN_X-1
    inc   eax
    mov   word[ebx+1],ax

    call  random_generator
    and   eax, SCREEN_Y-1
    inc   eax
    mov   word[ebx+3],ax

    add   ebx, 5
    jmp   .loop
.done:

    ret


random_generator:  ; (pseudo random, actually :)

    xor   eax,[generator]
    imul  eax,214013
    xor   eax,0xdeadbeef
    rol   eax,9
    mov   [generator],eax
    ror   eax,16
    and   eax,0x7fff

    ret




level1:
db 4,4,4,4,4
db 3,3,3,3,3
db 2,2,2,2,2
db 1,1,1,1,1

level2:
db 4,1,3,1,4
db 4,3,2,3,4
db 0,4,1,4,0
db 0,0,2,0,0

level3:
db 1,5,5,5,1
db 1,2,2,2,1
db 3,1,2,1,3
db 4,3,1,3,4

level4:
db 4,5,2,5,4
db 5,3,3,3,5
db 4,5,4,5,4
db 1,5,5,5,1

level5:
db 5,4,3,4,5
db 5,4,4,4,5
db 4,5,4,5,4
db 3,5,1,5,3

level6:
db 1,2,5,4,5
db 5,4,5,2,1
db 1,2,5,4,5
db 1,1,5,1,1

level7:
db 1,2,3,2,1
db 1,3,3,3,1
db 3,4,3,4,3
db 5,5,5,5,5

level8:
db 1,2,3,4,5
db 3,5,3,5,4
db 4,2,3,2,3
db 5,4,3,2,1

enemy_table:
db 0,0,0,0,0
db 0,0,0,0,0
db 0,0,0,0,0
db 0,0,0,0,0


msg1            db 'Vesa mode not supported',13,'Press any key to exit.',13,0
msgAbout        db 'Hidnplayrs invaders',13,'KolibriOS version',13,13,'released under GPL',13,'make this game better',13,'if you want to',0
msgdone         db 'You have saved the planet!',0
entername       db 'Enter your name highscorer!',0
highscorefile   db 'invaders.dat',0
points_50       db '5 pt',0
points_100      db '10 pt',0
points_150      db '15 pt',0
points_200      db '20 pt',0
points_250      db '25 pt',0
points_1000     db '100 pt',0
ship_x          dd SHIP_X_POS
enemy_x         dd 0
enemy_y         dd 0
enemy_d         db 0
current_enemy_x dd 0
current_enemy_y dd 0
bullet_x        dd 0
bullet_y        dd 1
score           dd 0
alldeadb        db 0
status          db 0        ; status: 0=menu  1=game  2=gameover   3=paused  4=about 5=highscorelist 6=levelup 7=highscore...
menu            db 0        ; menu:   0=start 1=about 2=highscores 3=exit...
generator       dd 0x45dd4d15
alien_x         dd 0
drawroutine     dd 0
returnaddr      dd 0
intro           dw 0
scoretext       db 'score '
scorenumb       db 0,0,0,0,0,0,0
leveltext       db 'level '
levelnumb       db 0,0,0
lives           db 0
level           db 1
enemy_speed     db 1
namepos         db 0
name            db 0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x0d,0x00


gif_bullet    file 'bullet2.gif'
rb 4

gif_bullet2   file 'bullet2.gif'
rb 4

gif_ship      file 'ship.gif'
rb 4

gif_enemy1    file 'enemy1.gif'
rb 4

gif_enemy2    file 'enemy2.gif'
rb 4

gif_enemy3    file 'enemy3.gif'
rb 4

gif_enemy4    file 'enemy4.gif'
rb 4

gif_enemy5    file 'enemy5.gif'
rb 4

gif_alien     file 'alien.gif'
rb 4

gif_menu1     file 'menu1.gif'
rb 4

gif_menu2     file 'menu2.gif'
rb 4

gif_menu3     file 'menu3.gif'
rb 4

gif_menu4     file 'menu4.gif'
rb 4

gif_logo      file 'logo.gif'
rb 4

gif_pause     file 'pause.gif'
rb 4

gif_highscore file 'highscores.gif'
rb 4

gif_smallfont file 'font_small.gif'
rb 4

gif_bigfont   file 'font_capital.gif'
rb 4

gif_numbers   file 'numbers.gif'
rb 4

gif_levelup   file 'nextlevel.gif'
rb 4

gif_gameover  file 'gameover.gif'
rb 4

vscreen:
dd SCREEN_X
dd SCREEN_Y
rb SCREEN_X*SCREEN_Y*3+10

IM_END:

STARS:
rb STARS_*5

bullet:
rb BULLET_X*BULLET_Y*3+8+10

bullet2:
rb BULLET_X*BULLET_Y*3+8+10

ship:
rb SHIP_X*SHIP_Y*3+10

enemy1:
rb ENEMY_X*ENEMY_Y*3+10

enemy2:
rb ENEMY_X*ENEMY_Y*3+10

enemy3:
rb ENEMY_X*ENEMY_Y*3+10

enemy4:
rb ENEMY_X*ENEMY_Y*3+10

enemy5:
rb ENEMY_X*ENEMY_Y*3+10

alien:
rb ALIEN_X*ALIEN_Y*3+10

menu1:
rb 220*18*3+10

menu2:
rb 135*18*3+10

menu3:
rb 245*18*3+10

menu4:
rb 110*18*3+10

logo:
rb 40*540*3+10

pause_:
rb 40*320*3+10

levelup:
rb 40*320*3+10

gameover:
rb 40*320*3+10

highscore:
rb 40*530*3+10

smallfont:
rb 20*312*3+10

bigfont:
rb 28*520*3+10

numbers:
rb 16*200*3+10

char:
rb 28*20*3+20 ; biggest char's are 28x20

alienpiece:
rb ALIEN_X*ALIEN_Y*3+20

gif_hash_area:
rd 4096+1                          ;hash area size for unpacking GIF

I_END:

;include 'dex.inc'