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: |