Subversion Repositories Kolibri OS

Compare Revisions

Regard whitespace Rev 5098 → Rev 5188

/programs/games/invaders/ascgl.inc
File deleted
/programs/games/invaders/invaders_kolibri.inc
File deleted
\ No newline at end of file
/programs/games/invaders/invaders.asm
1,8 → 1,8
;=============================================================================;
; Hidnplayr's invaders, Compilable for DexOs and Kolibrios ;
; Hidnplayr's invaders for Kolibrios ;
;-----------------------------------------------------------------------------;
; ;
; Copyright (C) hidnplayr 2007. All rights reserved. ;
; Copyright (C) hidnplayr 2007-2014. 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 ;
22,241 → 22,466
; ;
;-----------------------------------------------------------------------------;
 
format binary as ""
 
SCREEN_X equ 640
SCREEN_Y equ 480
; Screen size
SCREEN_X = 640
SCREEN_Y = 480
 
SHIP_X equ 32
SHIP_Y equ 32
; Ship size
SHIP_X = 32
SHIP_Y = 32
 
SHIP_X_POS equ (SCREEN_X-SHIP_X)/2
SHIP_Y_POS equ SCREEN_Y-SHIP_Y-27
; Ship begin position
SHIP_X_POS = (SCREEN_X-SHIP_X)/2
SHIP_Y_POS = SCREEN_Y-SHIP_Y-27
 
ENEMY_X equ 32
ENEMY_Y equ 32
; Enemy size
ENEMY_X = 32
ENEMY_Y = 32
 
ALIEN_X equ 48
ALIEN_Y equ 38
ALIEN_Y_POS equ 1
; Alien size and position
ALIEN_X = 48
ALIEN_Y = 38
ALIEN_Y_POS = 1
 
BOUNDARY equ 10
MOVEMENT equ 7
;
BOUNDARY = 10
MOVEMENT = 7 ; pixels/frame
 
TRANSPARENCY equ 0x00000000
TRANSPARENCY = 0x00ffffff ; color used as transparant
 
WINDOW_X equ 100
WINDOW_Y equ 100
; Window start position
WINDOW_X = 100
WINDOW_Y = 100
 
BULLET_X equ 10
BULLET_Y equ 10
; Bullet size
BULLET_X = 10
BULLET_Y = 10
 
STARS_ equ 226
STARLEVELS equ 3
; Number of stars
STARS_ = 226
 
ENEMY_STARTING_X equ 25
ENEMY_STARTING_Y equ 50
; Number of star levels (depth)
STARLEVELS = 3
 
BULLETSPEED equ 12
ENEMY_STARTING_X = 25
ENEMY_STARTING_Y = 50
 
SCREEN_X_POS equ 5
SCREEN_Y_POS equ 25
BULLETSPEED = 12 ; pixels/frame
 
gif_hash_offset = gif_hash_area
use32
org 0x0
db 'MENUET01' ; 8 byte id
dd 0x01 ; header version
dd START ; start of code
dd IM_END ; size of image
dd I_END+1000 ; memory for app
dd I_END+1000 ; esp
dd 0x0, 0x0 ; I_Param , I_Path
 
include 'ascgl.inc'
include 'invaders_kolibri.inc'
include '../../macros.inc'
include '../../proc32.inc'
include '../../dll.inc'
include '../../develop/libraries/libs-dev/libimg/libimg.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
KEY_RIGHT = 179
KEY_LEFT = 176
KEY_UP = 178
KEY_P = 'p'
KEY_DOWN = 177
KEY_ENTER = 13
KEY_ESC = 27
 
call createstars
call drawit
call [drawroutine]
proc aimgtoimg img, x, y, canvas, acolor
 
pusha
; Calculate offset on canvas in edi
mov eax, [y]
mov ecx, [canvas]
mul dword[ecx] ; canvas xsize
add eax, [x]
 
lea edi, [eax*2 + eax + 8]
add edi, [canvas]
 
; get img size in ecx and edx
mov esi, [img]
mov ecx, dword[esi+0] ; img x size
mov edx, dword[esi+4] ; img y size
 
; caluclate number of bytes between 2 lines in ebx
mov ebx, [canvas]
mov ebx, [ebx] ; canvas xsize
sub ebx, [esi] ; img xsize
lea ebx, [ebx*2 + ebx]
 
; get image start ptr in esi
add esi, 8
 
.loop2:
push ecx edx
mov edx, [acolor]
.loop:
mov eax, [esi]
and eax, 0x00ffffff
cmp eax, edx
je @f
mov word[edi], ax
shr eax, 16
mov byte[edi+2], al
@@:
add esi, 3
add edi, 3
dec ecx
jnz .loop
pop edx ecx
 
add edi, ebx
dec edx
jnz .loop2
 
popa
ret
 
endp
 
proc aimgtoimg2 img, x, y, canvas, acolor
 
pusha
; Calculate offset on canvas in edi
mov eax, [y]
mov ecx, [canvas]
mul dword[ecx] ; canvas xsize
add eax, [x]
 
lea edi, [eax*2 + eax + 8]
add edi, [canvas]
 
; get img size in ecx and edx
mov esi, [img]
mov ecx, dword[esi+0] ; img x size
mov edx, dword[esi+4] ; img y size
 
; caluclate number of bytes between 2 lines in ebx
mov ebx, [canvas]
mov ebx, [ebx] ; canvas xsize
sub ebx, [esi] ; img xsize
lea ebx, [ebx*2 + ebx]
 
; get image start ptr in esi
add esi, 8
 
.loop2:
push ecx edx
mov edx, [acolor]
.loop:
mov eax, [esi]
and eax, 0x00ffffff
cmp eax, edx
je @f
mov byte[edi+2], al
shr eax, 8
mov word[edi], ax
@@:
add esi, 3
add edi, 3
dec ecx
jnz .loop
pop edx ecx
 
add edi, ebx
dec edx
jnz .loop2
 
popa
ret
 
endp
 
proc getimg imgsrc, x, y, xs, ys, imgdest
 
pusha
 
mov esi, [imgsrc]
mov eax, dword[esi+0] ; xsize
mov ebx, [y]
mul ebx ; xsize*y
add eax, [x] ; xsize*y+x
lea eax, [eax+2*eax] ; (xsize*y+x)*3
 
mov edx, dword[esi+0] ; xsize
sub edx, [xs] ; xsize-xs
lea edx, [edx*2+edx] ; (xsize-xs)*3
 
lea esi, [esi + eax + 8] ; imgsrc + (xsize*y+x)*3 + 8
 
mov edi, [imgdest]
mov ecx, [xs]
mov dword[edi+0], ecx ; xsize
mov ebx, [ys]
mov dword[edi+4], ebx ; ysize
add edi, 8 ; imgdest + 8
 
cld
.loop:
movsw
movsb
dec ecx
jnz .loop
 
add esi, edx
mov ecx, [xs]
dec ebx
jnz .loop
 
popa
ret
 
endp
 
macro decodeimg source, size, dest {
 
invoke img.decode, source, size, 0
or eax, eax
jz exit
push [eax + Image.Width]
pop dword[dest+0]
push [eax + Image.Height]
pop dword[dest+4]
push eax
invoke img.to_rgb2, eax, dest+8
pop eax
invoke img.destroy, eax
}
 
 
START:
mcall 68, 11
 
stdcall dll.Load, @IMPORT
or eax, eax
jz @f
exit:
mcall -1
@@:
 
call draw_window
 
decodeimg gif_bullet,gif_bullet.size,img_bullet
decodeimg gif_bullet2,gif_bullet2.size,img_bullet2
decodeimg gif_ship,gif_ship.size,img_ship
decodeimg gif_enemy1,gif_enemy1.size,img_enemy1
decodeimg gif_enemy2,gif_enemy2.size,img_enemy2
decodeimg gif_enemy3,gif_enemy3.size,img_enemy3
decodeimg gif_enemy4,gif_enemy4.size,img_enemy4
decodeimg gif_enemy5,gif_enemy5.size,img_enemy5
decodeimg gif_alien,gif_alien.size,img_alien
decodeimg gif_menu1,gif_menu1.size,img_menu1
decodeimg gif_menu2,gif_menu2.size,img_menu2
decodeimg gif_menu3,gif_menu3.size,img_menu3
decodeimg gif_menu4,gif_menu4.size,img_menu4
decodeimg gif_logo,gif_logo.size,img_logo
decodeimg gif_pause,gif_pause.size,img_pause
decodeimg gif_levelup,gif_levelup.size,img_levelup
decodeimg gif_gameover,gif_gameover.size,img_gameover
decodeimg gif_highscore,gif_highscore.size,img_highscore
decodeimg gif_smallfont,gif_smallfont.size,img_smallfont
decodeimg gif_bigfont,gif_bigfont.size,img_bigfont
decodeimg gif_numbers,gif_numbers.size,img_numbers
 
call init_starfield
call render_frame
call draw_to_screen
 
mainloop:
 
cmp byte[status],3 ; if game is paused,...
je waitfordraw
call render_frame
call draw_to_screen
call bullet_collision_detection
 
call drawit
call [drawroutine]
call checkbullet
cmp [status], 3 ; if game is paused,...
jne .wait
 
waitfordraw:
mcall 10
jmp .switch
 
call waitandgetkey ;;;
.wait:
mcall 5, 1 ; wait 1/100 s
 
mcall 11 ; check for events
.switch:
test eax, eax
jz mainloop
dec eax
jz .redraw
dec eax
jz .key
dec eax
jz .button
 
.redraw:
call draw_window
jmp .wait
 
.button:
mcall 17 ; get button id
 
cmp ah, 1
jne .wait
mcall -1
 
.key:
mcall 2 ; get key code
test ah,ah
jz mainloop
 
cmp byte[status],1 ;
jne nogame
cmp [status], 1
je key_game
cmp [status], 0
je key_menu
cmp [status], 3
je key_pause
cmp [status], 6
je key_levelup
cmp [status], 7
je key_highscore
cmp [status], 2
je key_gameover
 
cmp ah, KEY_ESC
jne .no_escape
 
mov [status], 0
mov [intro], 0
.no_escape:
 
jmp mainloop
 
 
key_game:
cmp ah, KEY_RIGHT
jnz noright
cmp dword[ship_x],SCREEN_X-SHIP_X-BOUNDARY
jnz .no_right
 
cmp [ship_x], SCREEN_X-SHIP_X-BOUNDARY
jge mainloop
add dword[ship_x],MOVEMENT
 
add [ship_x], MOVEMENT
jmp mainloop
.no_right:
 
noright:
cmp ah, KEY_LEFT
jnz noleft
cmp dword[ship_x],BOUNDARY
jne .no_left
 
cmp [ship_x], BOUNDARY
jle mainloop
sub dword[ship_x],MOVEMENT
 
sub [ship_x], MOVEMENT
jmp mainloop
.no_left:
 
noleft:
cmp ah, KEY_UP
jnz noup
jne .no_up
 
cmp dword[bullet_y],1
cmp [bullet_y], 1
jg mainloop
 
mov eax,dword[ship_x]
mov eax, [ship_x]
add eax,(SHIP_X-BULLET_X)/2
mov dword[bullet_x],eax
mov dword[bullet_y],SHIP_Y_POS;-BULLET_Y
 
mov [bullet_x], eax
mov [bullet_y], SHIP_Y_POS;-BULLET_Y
jmp mainloop
.no_up:
 
noup:
cmp ah,KEY_P
jnz no_pause1
jne no_pause
 
mov byte[status],3
aimgtoimg pause_,150,180,vscreen,TRANSPARENCY,0
call [drawroutine]
mov [status], 3
stdcall aimgtoimg, img_pause, 150, 180, vscreen, TRANSPARENCY
call draw_to_screen
 
jmp mainloop
no_pause:
cmp ah, KEY_ESC
jne .no_escape
 
no_pause1:
mov [status], 0
mov [intro], 0
.no_escape:
jmp mainloop
 
nogame:
cmp byte[status],0
jne nomenu
 
key_menu:
cmp ah, KEY_DOWN
jnz no_down
jne .no_down
 
cmp byte[menu],3
jne no_menu1
cmp [menu], 3
jne @f
mov [menu], 0
jmp mainloop
@@:
inc [menu]
jmp mainloop
.no_down:
 
mov byte[menu],0
jmp nomenu
 
no_menu1:
inc byte[menu]
 
no_down:
cmp ah, KEY_UP
jnz no_up
jnz .no_up
 
cmp byte[menu],0
jne no_menu0
cmp [menu], 0
jne @f
mov [menu], 3
jmp mainloop
@@:
dec [menu]
jmp mainloop
.no_up:
 
mov byte[menu],3
jmp nomenu
 
no_menu0:
dec byte[menu]
 
no_up:
 
cmp ah, KEY_ESC
je exit
jne @f
mcall -1
@@:
 
no_esc:
cmp ah, KEY_ENTER
jnz no_enter
jnz .no_enter
 
exemenu:
cmp byte[menu],0 ;start
jne exemenu1
cmp [menu], 0 ;start
je new_game
 
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
 
cmp [menu], 1 ;about
jne @f
mov [status], 4
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
cmp [menu], 2 ;highscores
jne @f
mov [status], 5
call load_highscores
jmp mainloop
@@:
 
exemenu3:
cmp byte[menu],3 ;exit
je exit
jne @f
mcall -1
@@:
.no_enter:
jmp mainloop
 
no_enter:
nomenu:
cmp byte[status],3
jne nopause
 
key_pause:
cmp ah, KEY_P
jnz nopause
jnz no_pause
 
mov byte[status],1
mov [status], 1
.nopause:
jmp mainloop
 
nopause:
cmp byte[status],6
jne nolevelup
 
key_levelup:
 
cmp ah, KEY_ENTER
jne nolevelup
jne .no_enter
 
inc byte[level]
inc [level]
 
; cmp byte[level],5
; jne @f
; mov byte[level],0
 
;@@:
inc byte[levelnumb+1]
cmp byte[levelnumb+1],'9'
jle @f
272,18 → 497,26
mov esi,eax
jmp load_level
 
nolevelup:
cmp byte[status],7
jne nohighscore
.no_enter:
cmp ah, KEY_ESC
jne .no_escape
 
mov [status], 0
mov [intro], 0
.no_escape:
jmp mainloop
 
 
key_highscore:
 
cmp ah, KEY_ENTER
jne @f
 
call load_highscores
mov eax,dword[score]
mov ebx,gif_hash_area+140
mov eax, [score]
mov ebx, highscorebuffer+140
.findscore:
cmp ebx,gif_hash_area+100
cmp ebx, highscorebuffer+100
je .topscore
sub ebx,4
cmp eax,dword[ebx]
291,15 → 524,15
 
.topscore:
mov esi,name
mov edi,gif_hash_area
mov edi, highscorebuffer
mov ecx,10
rep movsb
 
mov eax,dword[score]
mov dword[gif_hash_area+100],eax
mov eax, [score]
mov dword[highscorebuffer+100], eax
 
call save_highscores
mov byte[status],5
mov [status], 5
 
@@:
cmp ah,14
315,22 → 548,22
 
@@:
cmp byte[namepos],10
jge nohighscore
jge mainloop
 
cmp al,'0'
jl nohighscore
jl mainloop
cmp al,'9'
jle @f
 
cmp al,'z'
jg nohighscore
jg mainloop
cmp al,'a'
jge @f
 
cmp al,'Z'
jg nohighscore
jg mainloop
cmp al,'A'
jl nohighscore
jl mainloop
@@:
 
movzx ebx,byte[namepos]
341,45 → 574,114
 
jmp mainloop
 
nohighscore:
cmp byte[status],2 ; gameover
jne nogameover
 
key_gameover:
cmp ah, KEY_ENTER
jne nogameover
jne .no_enter
 
; test if score is high enough to put in highscore list...
mov byte[status],7
; TODO: test if score is high enough to put in highscore list...
mov [status],7
jmp mainloop
 
.no_enter:
jmp mainloop
 
nogameover:
cmp byte[status],0
je mainloop
 
cmp ah, KEY_ESC
jnz mainloop
new_game:
 
mov byte[status],0
mov word[intro],0
mov [score], 0
mov eax, [score]
call convertscore
 
mov word[levelnumb], '01'
mov esi, level1
 
load_level:
mov [enemy_speed], 1
mov [enemy_x], ENEMY_STARTING_X
mov [enemy_y], ENEMY_STARTING_Y
 
mov edi, enemy_table
mov ecx, 5
rep movsd
 
mov [status],1
 
jmp mainloop
 
;----------------------------------------------------;
; Drawing routine: create image in buffer ;
;----------------------------------------------------;
drawit:
 
draw_window:
 
mcall 12, 1 ; Start of window draw
 
mov ebx, WINDOW_X shl 16 + 9 + SCREEN_X ; [x start] shl 16 + [x size]
mov ecx, WINDOW_Y shl 16 + 25 + SCREEN_Y ; [y start] shl 16 + [y size]
mov edx, 0x64000000 ; color of work area RRGGBB
mov esi, 0x805080d0 ; color of grab bar RRGGBB
mov edi, 0x005080d0 ; color of frames RRGGBB
mcall 0
 
mcall 71, 1, title
 
call draw_to_screen
 
mcall 12, 2 ; End of window draw
 
ret
 
 
 
draw_to_screen:
 
; Draw buffer to the screen
mov ebx, vscreen+8
mov ecx, SCREEN_X shl 16 + SCREEN_Y
mov edx, 0 shl 16 + 0
mcall 7
 
ret
 
 
load_highscores:
 
ret
 
 
save_highscores:
 
ret
 
 
render_frame:
 
mov eax,0x00000000
call fillscreen
call drawstars
call render_starfield
 
cmp byte[status],1
jne @f
cmp [status], 1
je render_game
cmp [status], 2
je render_gameover
cmp [status], 4
je render_about
cmp [status], 6
je render_levelup
cmp [status], 0
je render_menu
cmp [status], 5
je render_highscorelist
cmp [status], 7
je render_highscore
 
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
ret
 
 
render_game:
 
call render_bullet
call render_enemies ; Draw the enemies to buffer
stdcall aimgtoimg, img_ship, [ship_x], SHIP_Y_POS, vscreen, TRANSPARENCY; Draw the ship to buffer
 
mov esi,scoretext
mov ebx,0
mov ecx,SCREEN_Y-24
391,12 → 693,11
 
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
render_gameover:
 
stdcall aimgtoimg, img_ship, [ship_x], SHIP_Y_POS, vscreen, TRANSPARENCY; Draw the ship to buffer
 
mov esi,scoretext
mov ebx,0
mov ecx,SCREEN_Y-24
405,14 → 706,13
mov esi,leveltext
mov ebx,300
call printtext
aimgtoimg gameover,150,180,vscreen,TRANSPARENCY,0
stdcall aimgtoimg, img_gameover, 150, 180, vscreen, TRANSPARENCY
 
ret
 
@@:
cmp byte[status],4 ; about screen
jne @f
 
render_about:
 
mov esi,msgAbout
mov ebx,50
mov ecx,100
420,11 → 720,11
 
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
 
render_levelup:
 
stdcall aimgtoimg, img_ship, [ship_x], SHIP_Y_POS, vscreen, TRANSPARENCY; Draw the ship to buffer
 
mov esi,scoretext
mov ebx,0
mov ecx,SCREEN_Y-24
433,56 → 733,54
mov esi,leveltext
mov ebx,300
call printtext
aimgtoimg levelup,150,180,vscreen,TRANSPARENCY,0
stdcall aimgtoimg, img_levelup, 150, 180, vscreen, TRANSPARENCY
 
ret
 
@@:
cmp byte[status],0 ; menu!
jne @f
 
aimgtoimg logo,50,80,vscreen,TRANSPARENCY,0
render_menu:
 
stdcall aimgtoimg, img_logo, 50, 80, vscreen, TRANSPARENCY
 
cmp byte[menu],0
cmp [menu], 0
jne .menu_0
aimgtoimg menu1,30,200,vscreen,TRANSPARENCY,1
stdcall aimgtoimg2, img_menu1, 30, 200, vscreen, TRANSPARENCY
jmp .menu_1
.menu_0:
aimgtoimg menu1,30,200,vscreen,TRANSPARENCY,0
stdcall aimgtoimg, img_menu1, 30, 200, vscreen, TRANSPARENCY
.menu_1:
cmp byte[menu],1
cmp [menu], 1
jne .menu_2
aimgtoimg menu2,80,250,vscreen,TRANSPARENCY,1
stdcall aimgtoimg2, img_menu2, 80, 250, vscreen, TRANSPARENCY
jmp .menu_3
.menu_2:
aimgtoimg menu2,80,250,vscreen,TRANSPARENCY,0
stdcall aimgtoimg, img_menu2, 80, 250, vscreen, TRANSPARENCY
.menu_3:
cmp byte[menu],2
cmp [menu], 2
jne .menu_4
aimgtoimg menu3,120,300,vscreen,TRANSPARENCY,1
stdcall aimgtoimg2, img_menu3, 120, 300, vscreen, TRANSPARENCY
jmp .menu_5
.menu_4:
aimgtoimg menu3,120,300,vscreen,TRANSPARENCY,0
stdcall aimgtoimg, img_menu3, 120, 300, vscreen,TRANSPARENCY
.menu_5:
cmp byte[menu],3
cmp [menu], 3
jne .menu_6
aimgtoimg menu4,150,350,vscreen,TRANSPARENCY,1
stdcall aimgtoimg2, img_menu4, 150, 350, vscreen, TRANSPARENCY
jmp .menu_7
.menu_6:
aimgtoimg menu4,150,350,vscreen,TRANSPARENCY,0
stdcall aimgtoimg, img_menu4, 150, 350, vscreen, TRANSPARENCY
.menu_7:
 
cmp word[intro],200
cmp [intro], 200
je .menu_75
inc word[intro]
inc [intro]
 
.menu_75:
cmp word[intro],0
cmp [intro], 0
jl .menu_8
aimgtoimg enemy1,390,180,vscreen,TRANSPARENCY,0
stdcall aimgtoimg, img_enemy1, 390, 180, vscreen, TRANSPARENCY
 
cmp word[intro],15
cmp [intro], 15
jl .menu_8
mov esi,points_50
mov ebx,470
489,11 → 787,11
mov ecx,180
call printtext
 
cmp word[intro],30
cmp [intro],30
jl .menu_8
aimgtoimg enemy2,390,220,vscreen,TRANSPARENCY,0
stdcall aimgtoimg, img_enemy2, 390, 220, vscreen, TRANSPARENCY
 
cmp word[intro],45
cmp [intro], 45
jl .menu_8
mov esi,points_100
mov ebx,450
500,11 → 798,11
mov ecx,220
call printtext
 
cmp word[intro],60
cmp [intro], 60
jl .menu_8
aimgtoimg enemy3,390,260,vscreen,TRANSPARENCY,0
stdcall aimgtoimg, img_enemy3, 390, 260, vscreen, TRANSPARENCY
 
cmp word[intro],75
cmp [intro], 75
jl .menu_8
mov esi,points_150
mov ebx,450
511,11 → 809,11
mov ecx,260
call printtext
 
cmp word[intro],90
cmp [intro],90
jl .menu_8
aimgtoimg enemy4,390,300,vscreen,TRANSPARENCY,0
stdcall aimgtoimg, img_enemy4, 390, 300, vscreen, TRANSPARENCY
 
cmp word[intro],105
cmp [intro], 105
jl .menu_8
mov esi,points_200
mov ebx,450
522,11 → 820,11
mov ecx,300
call printtext
 
cmp word[intro],120
cmp [intro], 120
jl .menu_8
aimgtoimg enemy5,390,340,vscreen,TRANSPARENCY,0
stdcall aimgtoimg, img_enemy5, 390, 340, vscreen, TRANSPARENCY
 
cmp word[intro],135
cmp [intro],135
jl .menu_8
mov esi,points_250
mov ebx,450
533,11 → 831,11
mov ecx,340
call printtext
 
cmp word[intro],150
cmp [intro],150
jl .menu_8
aimgtoimg alien,380,380,vscreen,TRANSPARENCY,0
stdcall aimgtoimg, img_alien, 380, 380, vscreen, TRANSPARENCY
 
cmp word[intro],165
cmp [intro],165
jl .menu_8
mov esi,points_1000
mov ebx,430
546,23 → 844,23
 
.menu_8:
ret
@@:
cmp byte[status],5 ;highscorelist
jne @f
 
aimgtoimg highscore,60,40,vscreen,TRANSPARENCY,0
 
render_highscorelist:
 
stdcall aimgtoimg, img_highscore, 60, 40, vscreen, TRANSPARENCY
 
mov ebx,100 ; print names
mov ecx,120
mov esi,gif_hash_area
mov esi, highscorebuffer
call printtext
 
mov edi,gif_hash_area+100 ; print scores
mov edi, highscorebuffer+100 ; print scores
mov esi,scorenumb
mov ebx,420
mov ecx,120
 
.highscoreloop:
.loop:
mov eax,[edi]
push ecx
call convertscore
572,15 → 870,16
pop esi
add ecx,26
add edi,4
cmp edi,gif_hash_area+140
jl .highscoreloop
cmp edi, highscorebuffer+140
jl .loop
 
@@:
cmp byte[status],7 ;highscore
jne @f
ret
 
aimgtoimg highscore,60,40,vscreen,TRANSPARENCY,0
 
render_highscore:
 
stdcall aimgtoimg, img_highscore, 60, 40, vscreen, TRANSPARENCY
 
mov ebx,60
mov ecx,200
mov esi,entername
599,135 → 898,92
mov esi,leveltext
mov ebx,300
call printtext
@@:
 
ret
 
 
drawenemys:
render_enemies:
; check if direction should change
test byte[enemy_d],2
test [enemy_d], 2
jz @f
 
add dword[enemy_y],5
add [enemy_y], 5
 
mov eax,[enemy_y]
shr eax,5
add al, byte[level]
mov byte[enemy_speed],al
add al, [level]
mov [enemy_speed], al
 
and byte[enemy_d],1
and [enemy_d], 1
 
@@:
; move the aliens to left or right
movzx eax,byte[enemy_speed]
test byte[enemy_d],1
jz other_dir
movzx eax, [enemy_speed]
test [enemy_d], 1
jz .other_dir
 
sub dword[enemy_x],eax
jmp no_other_dir
sub [enemy_x], eax
jmp .no_other_dir
 
other_dir:
add dword[enemy_x],eax
no_other_dir:
.other_dir:
add [enemy_x], eax
.no_other_dir:
 
; initialization
mov byte[alldeadb],1
mov [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
mov eax, [enemy_x]
mov [current_enemy_x], eax
mov eax, [enemy_y]
mov [current_enemy_y], eax
 
loopit:
cmp byte[edi],1
je drawenemy1
.loopit:
movzx eax, byte[edi]
test al, al
jz .next_alien
cmp al, 5
ja .next_alien
dec eax
mov eax, [enemy_img_list+eax*4]
 
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
 
.drawenemy:
mov [alldeadb], 0
stdcall aimgtoimg, eax, [current_enemy_x], [current_enemy_y], vscreen, TRANSPARENCY
; jmp checknext
 
checknext:
cmp byte[enemy_d],2
jge dont_change_dir
.checknext:
cmp [enemy_d], 2
jge .dont_change_dir
 
movzx eax,byte[enemy_speed]
movzx eax, [enemy_speed]
 
cmp byte[enemy_d],0
jbe change_dir
cmp [enemy_d], 0
jbe .change_dir
 
cmp dword[current_enemy_x],eax
jg dont_change_dir
jg .dont_change_dir
 
mov byte[enemy_d],2
mov [enemy_d], 2
jmp .dont_change_dir
 
jmp dont_change_dir
 
change_dir:
.change_dir:
mov ebx, SCREEN_X-ENEMY_X
sub ebx, eax
cmp dword[current_enemy_x],ebx
jl dont_change_dir
jl .dont_change_dir
 
mov byte[enemy_d],3
mov [enemy_d], 3
 
dont_change_dir:
cmp dword[current_enemy_y],SHIP_Y_POS-ENEMY_Y-BOUNDARY
je gameover_
.dont_change_dir:
cmp [current_enemy_y], SHIP_Y_POS-ENEMY_Y-BOUNDARY
jle .next_alien ;;;;;;
 
dead_alien:
mov [status], 2
ret
 
.next_alien:
cmp edi,enemy_table+20
jge alldead
jge .alldead
 
inc edi
add dword[current_enemy_x],ENEMY_X+BOUNDARY
734,31 → 990,28
mov eax,dword[current_enemy_x]
sub eax,dword[enemy_x]
cmp eax,5*(ENEMY_X+BOUNDARY)
jl no_newline
jl .no_newline
 
sub dword[current_enemy_x],5*(ENEMY_X+BOUNDARY)
add dword[current_enemy_y],ENEMY_Y+BOUNDARY
no_newline:
jmp loopit
sub [current_enemy_x], 5*(ENEMY_X+BOUNDARY)
add [current_enemy_y], ENEMY_Y+BOUNDARY
.no_newline:
jmp .loopit
 
alldead:
cmp byte[alldeadb],0
je enemy_end
.alldead:
cmp [alldeadb], 0
je .enemy_end
 
mov byte[status],6
jmp mainloop
mov [status], 6
ret
 
enemy_end:
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
cmp dword[alien_x],5 ;
.enemy_end:
cmp [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
 
jl .alien_end
mov [alien_x], SCREEN_X-ALIEN_X
@@:
push eax
 
770,126 → 1023,114
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: ;
;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; stdcall getimg, img_alien, 0, 0, 10, ALIEN_Y, img_alienpiece
stdcall aimgtoimg, img_alien, [alien_x], ALIEN_Y_POS, vscreen, TRANSPARENCY
sub [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:
render_bullet:
cmp [bullet_y], BULLETSPEED
jl .nobullet
sub [bullet_y], BULLETSPEED
 
stdcall aimgtoimg, img_bullet, [bullet_x], [bullet_y], vscreen, TRANSPARENCY
 
.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
;
 
bullet_collision_detection:
 
cmp [bullet_y], BULLETSPEED ; does the bullet hit top of the screen?
jle .hidebullet ; yes, hide bullet
 
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
mov eax, [enemy_x]
mov [current_enemy_x], eax
mov eax, [enemy_y]
mov [current_enemy_y], eax
 
check:
.check:
cmp byte[edi],0 ; is the enemy at this position alive?
je nextcheck ; no, try next enemy
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
mov eax, [current_enemy_y] ; move the enemy y position into eax
cmp [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
cmp [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 ;
mov eax, [current_enemy_x] ; now do the same but for the x positions
cmp [bullet_x], eax ;
jl .nextcheck ;
;
add eax,ENEMY_Y ;
cmp dword[bullet_x],eax ;
jg nextcheck ;
cmp [bullet_x], eax ;
jg .nextcheck ;
 
jmp hit
jmp .hit
 
nextcheck:
.nextcheck:
inc edi
add dword[current_enemy_x],ENEMY_X+BOUNDARY
mov eax,dword[current_enemy_x]
sub eax,dword[enemy_x]
add [current_enemy_x], ENEMY_X+BOUNDARY
mov eax, [current_enemy_x]
sub eax, [enemy_x]
cmp eax,5*(ENEMY_X+BOUNDARY)
jl no_newline_
jl .no_newline
 
sub dword[current_enemy_x],5*(ENEMY_X+BOUNDARY)
add dword[current_enemy_y],ENEMY_Y+BOUNDARY
no_newline_:
sub [current_enemy_x], 5*(ENEMY_X+BOUNDARY)
add [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
jg .nohit ; yes, none of them was hit
jmp .check ; no, check if enemy is alive and draw it
 
hit:
.hit:
movzx ebx,byte[edi] ; mov the enemy number onto ebx
add dword[score],ebx ; add this number to the score dword
add [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
.hidebullet:
mov [bullet_y], 1 ; mov the bullet to top of screen (hide it)
jmp .noalienhit
 
nohit:
.nohit:
mov eax,[alien_x] ; check if we hit the big alien in the ufo
cmp [bullet_x],eax
jl noalienhit
jl .noalienhit
add eax,ALIEN_X-BULLET_X
cmp [bullet_x],eax
jg noalienhit
jg .noalienhit
cmp [bullet_y],ALIEN_Y_POS+ALIEN_Y
jg noalienhit
jg .noalienhit
 
add dword[score],100/5
add [score], 100/5
mov eax,[score]
call convertscore
 
mov [alien_x],0
 
noalienhit:
 
.noalienhit:
ret
 
 
 
convertscore:
 
test al,1
jz .1
mov byte[scorenumb+5],'5'
937,124 → 1178,119
 
 
printtext:
 
push ebx
 
loadbyte:
movzx eax, byte[esi]
test eax, eax
jnz checkbyte
 
pop ebx
 
ret
 
checkbyte:
.loop:
lodsb
test al, al
jz .done
cmp al,13
je nextline
je .nextline
cmp al,' '
je space
je .space
 
cmp al,'0'
jl nextchar
jl .loop
cmp al,'9'
jle usenumbers
jle .usenumbers
 
cmp al,'z'
jg nextchar
jg .loop
cmp al,'a'
jge usesmallfont
jge .usesmallfont
 
cmp al,'Z'
jg nextchar
jg .loop
cmp al,'A'
jge usebigfont
jge .usebigfont
jmp .loop
 
jmp nextchar
 
 
usesmallfont:
mov edx,eax
.usesmallfont:
movzx edx, al
sub edx,'a'
mov eax,12
mul edx
mov edx,eax
 
pusha
getimg smallfont,0,edx,20,12,char
popa
 
pusha
stdcall getimg, img_smallfont, 0, eax, 20, 12, img_char
push ecx
add ecx,4
aimgtoimg char,ebx,ecx,vscreen,TRANSPARENCY,0
popa
 
stdcall aimgtoimg, img_char, ebx, ecx, vscreen, TRANSPARENCY
pop ecx
add ebx,20
jmp .loop
 
jmp nextchar
 
usebigfont:
mov edx,eax
.usebigfont:
movzx edx, al
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
 
stdcall getimg, img_bigfont, 0, eax, 28, 20, img_char
stdcall aimgtoimg, img_char, ebx, ecx, vscreen, TRANSPARENCY
add ebx,28
jmp .loop
 
jmp nextchar
 
usenumbers:
mov edx,eax
.usenumbers:
movzx edx, al
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
 
stdcall getimg, img_numbers, 0, eax, 16, 20, img_char
stdcall aimgtoimg, img_char, ebx, ecx, vscreen, TRANSPARENCY
add ebx,20
jmp .loop
 
jmp nextchar
 
space:
.space:
add ebx,20
jmp .loop
 
nextchar:
inc esi
 
jmp loadbyte
 
nextline:
.nextline:
pop ebx
push ebx
add ecx,26
inc esi
jmp .loop
 
jmp loadbyte
.done:
pop ebx
ret
 
gameover_:
mov byte[status],2
 
init_starfield:
 
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
 
 
drawstars:
render_starfield:
 
mov esi, STARS
 
.loop:
cmp esi, STARS+(STARS_*5)
jge .done
1111,43 → 1347,10
 
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]
1217,9 → 1420,8
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
title db 'Invaders',0
msgdone db 'You have saved the planet!',0
entername db 'Enter your name highscorer!',0
highscorefile db 'invaders.dat',0
1243,7 → 1445,7
menu db 0 ; menu: 0=start 1=about 2=highscores 3=exit...
generator dd 0x45dd4d15
alien_x dd 0
drawroutine dd 0
;drawroutine dd 0
returnaddr dd 0
intro dw 0
scoretext db 'score '
1256,153 → 1458,104
namepos db 0
name db 0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x0d,0x00
 
enemy_img_list:
dd img_enemy1
dd img_enemy2
dd img_enemy3
dd img_enemy4
dd img_enemy5
 
 
gif_bullet file 'bullet2.gif'
rb 4
 
.size = $ - gif_bullet
gif_bullet2 file 'bullet2.gif'
rb 4
 
.size = $ - gif_bullet2
gif_ship file 'ship.gif'
rb 4
 
.size = $ - gif_ship
gif_enemy1 file 'enemy1.gif'
rb 4
 
.size = $ - gif_enemy1
gif_enemy2 file 'enemy2.gif'
rb 4
 
.size = $ - gif_enemy2
gif_enemy3 file 'enemy3.gif'
rb 4
 
.size = $ - gif_enemy3
gif_enemy4 file 'enemy4.gif'
rb 4
 
.size = $ - gif_enemy4
gif_enemy5 file 'enemy5.gif'
rb 4
 
.size = $ - gif_enemy5
gif_alien file 'alien.gif'
rb 4
 
.size = $ - gif_alien
gif_menu1 file 'menu1.gif'
rb 4
 
.size = $ - gif_menu1
gif_menu2 file 'menu2.gif'
rb 4
 
.size = $ - gif_menu2
gif_menu3 file 'menu3.gif'
rb 4
 
.size = $ - gif_menu3
gif_menu4 file 'menu4.gif'
rb 4
 
.size = $ - gif_menu3
gif_logo file 'logo.gif'
rb 4
 
.size = $ - gif_logo
gif_pause file 'pause.gif'
rb 4
 
.size = $ - gif_pause
gif_highscore file 'highscores.gif'
rb 4
 
.size = $ - gif_highscore
gif_smallfont file 'font_small.gif'
rb 4
 
.size = $ - gif_smallfont
gif_bigfont file 'font_capital.gif'
rb 4
 
.size = $ - gif_bigfont
gif_numbers file 'numbers.gif'
rb 4
 
.size = $ - gif_numbers
gif_levelup file 'nextlevel.gif'
rb 4
 
.size = $ - gif_levelup
gif_gameover file 'gameover.gif'
rb 4
.size = $ - gif_gameover
 
align 16
@IMPORT:
 
library \
libimg , 'libimg.obj'
 
import libimg , \
libimg.init , 'lib_init' , \
img.decode , 'img_decode' , \
img.to_rgb2 , 'img_to_rgb2', \
img.destroy , 'img_destroy'
 
 
vscreen:
dd SCREEN_X
dd SCREEN_Y
rb SCREEN_X*SCREEN_Y*3+10
rb SCREEN_X*SCREEN_Y*3
 
IM_END:
 
STARS:
rb STARS_*5
STARS rb STARS_*5
 
bullet:
rb BULLET_X*BULLET_Y*3+8+10
img_bullet rb BULLET_X*BULLET_Y*3+8
img_bullet2 rb BULLET_X*BULLET_Y*3+8
img_ship rb SHIP_X*SHIP_Y*3+8
img_enemy1 rb ENEMY_X*ENEMY_Y*3+8
img_enemy2 rb ENEMY_X*ENEMY_Y*3+8
img_enemy3 rb ENEMY_X*ENEMY_Y*3+8
img_enemy4 rb ENEMY_X*ENEMY_Y*3+8
img_enemy5 rb ENEMY_X*ENEMY_Y*3+8
img_alien rb ALIEN_X*ALIEN_Y*3+8
img_menu1 rb 220*18*3+8
img_menu2 rb 135*18*3+8
img_menu3 rb 245*18*3+8
img_menu4 rb 110*18*3+8
img_logo rb 40*540*3+8
img_pause rb 40*320*3+8
img_levelup rb 40*320*3+8
img_gameover rb 40*320*3+8
img_highscore rb 40*530*3+8
img_smallfont rb 20*312*3+8
img_bigfont rb 28*520*3+8
img_numbers rb 16*200*3+8
 
bullet2:
rb BULLET_X*BULLET_Y*3+8+10
img_char rb 28*20*3+8
img_alienpiece rb ALIEN_X*ALIEN_Y*3+8
 
ship:
rb SHIP_X*SHIP_Y*3+10
highscorebuffer rb 1024
 
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'
 
I_END: