| /programs/games/invaders/ASCGL.INC |
|---|
| 0,0 → 1,1388 |
| ; |
| ; Assembler |
| ; SMALL |
| ; CODE |
| ; Graphics |
| ; Libary |
| ; |
| ; Ver 0.18 By Pavlushin Evgeni (RUSSIA) |
| ; www.waptap@mail.ru |
| ;InfoList |
| ;0.01 LoadImage |
| ;0.02 SetBmp |
| ;0.03 Bmptoimg, Setimg ~01.03.2004 |
| ;0.04 Bug deleted, copyimg ~03.05.2004 |
| ;0.05 fullimg, collimg ~05.05.2004 |
| ;0.06 getimg ~09.05.2004 |
| ;0.07 convbmp ~13.05.2004 |
| ;0.08 fps ~14.05.2004 |
| ;0.09 drawfbox ~03.06.2004 |
| ;0.10 all macros optimized by halyavin, add at ~07.06.2004 |
| ;0.11 many macros optimized by halyavin, add at ~30.08.2004 |
| ;0.12 bmptoimg ~07.09.2004 |
| ;0.13 imgtoimg ~08.09.2004 |
| ;0.14 imgtoimg modify not brake bmp pict! ~09.09.2004 |
| ;0.15 giftoimg, giftoani ~10.09.2004 |
| ;0.16 setframe, rgbtobgr, setbmp deleted ~20.09.2004 |
| ;0.17 modification giftoimg, giftoani, getframeoff ~01.10.2004 |
| ;0.18 aframetoimg,aimgtoimg,frametoimg ~03.10.2004 |
| aframetoimg_use_count=0 |
| macro aframetoimg img, x, y, canvas,acol |
| { |
| local loo,loo2,acolor |
| aframetoimg_use_count=aframetoimg_use_count+1 |
| if aframetoimg_use_count = 1 |
| jmp end_aframetoimg_proc |
| acolor dd 0 |
| aframetoimg_proc: |
| ;getout coord |
| mov [acolor],ebp |
| mov edx,ebx ;img ;xsize |
| movzx eax,word [edx] |
| add eax,esi ;y cor |
| ; mov eax,esi ;y cor |
| mul dword [ecx] ;canvas xsize |
| add eax,edi ;x cor |
| mov ebp,ebx ;img ;xsize |
| movzx edx,word [ebp] |
| add eax,edx |
| mov ebp,eax |
| shl eax,1 |
| add ebp,eax |
| add ebp,ecx ;canvas+8;start |
| add ebp,8 |
| ;get img size |
| add ebx,4 |
| mov eax,ebx ;img ;xsize |
| movzx esi,word [eax] |
| movzx edi,word [eax+2] |
| add ebx,4 |
| mov edx,ebx ;img+8 |
| loo2: |
| push esi |
| loo: |
| ;test on alpha color |
| mov eax,[edx] |
| shl eax,8 |
| shr eax,8 |
| cmp eax,[acolor] |
| jne yx |
| add edx,3 |
| add ebp,3 |
| jmp nx |
| yx: |
| mov al,byte [edx] |
| mov byte [ebp],al |
| inc ebp |
| inc edx |
| mov al,byte [edx] |
| mov byte [ebp],al |
| inc ebp |
| inc edx |
| mov al,byte [edx] |
| mov byte [ebp],al |
| inc ebp |
| inc edx |
| nx: |
| dec esi |
| jnz loo |
| pop esi |
| sub ebp,3 |
| mov eax,[ecx] ;offset = offset+((canxsize-imgxsize)*3) |
| sub eax,esi |
| add ebp,eax |
| shl eax,1 |
| add ebp,eax |
| add ebp,3 |
| dec edi |
| jnz loo2 |
| ret |
| end_aframetoimg_proc: |
| end if |
| push img |
| push canvas |
| push x |
| push y |
| push acol |
| pop ebp |
| pop esi |
| pop edi |
| pop ecx |
| pop ebx |
| call aframetoimg_proc |
| } |
| frametoimg_use_count=0 |
| macro frametoimg img, x, y, canvas |
| { |
| local loo,loo2 |
| frametoimg_use_count=frametoimg_use_count+1 |
| if frametoimg_use_count = 1 |
| jmp end_frametoimg_proc |
| frametoimg_proc: |
| ;getout coord |
| mov edx,ebx ;img ;xsize |
| movzx eax,word [edx] |
| add eax,esi ;y cor |
| ; mov eax,esi ;y cor |
| mul dword [ecx] ;canvas xsize |
| add eax,edi ;x cor |
| mov ebp,ebx ;img ;xsize |
| movzx edx,word [ebp] |
| add eax,edx |
| mov ebp,eax |
| shl eax,1 |
| add ebp,eax |
| add ebp,ecx ;canvas+8;start |
| add ebp,8 |
| ;get img size |
| add ebx,4 |
| mov eax,ebx ;img ;xsize |
| movzx esi,word [eax] |
| movzx edi,word [eax+2] |
| add ebx,4 |
| mov edx,ebx ;img+8 |
| loo2: |
| push esi |
| loo: |
| mov al,byte [edx] |
| mov byte [ebp],al |
| inc ebp |
| inc edx |
| mov al,byte [edx] |
| mov byte [ebp],al |
| inc ebp |
| inc edx |
| mov al,byte [edx] |
| mov byte [ebp],al |
| inc ebp |
| inc edx |
| dec esi |
| jnz loo |
| pop esi |
| sub ebp,3 |
| mov eax,[ecx] ;offset = offset+((canxsize-imgxsize)*3) |
| sub eax,esi |
| add ebp,eax |
| shl eax,1 |
| add ebp,eax |
| add ebp,3 |
| dec edi |
| jnz loo2 |
| ret |
| end_frametoimg_proc: |
| end if |
| push img |
| push canvas |
| push x |
| push y |
| pop esi |
| pop edi |
| pop ecx |
| pop ebx |
| call frametoimg_proc |
| } |
| aimgtoimg_use_count=0 |
| macro aimgtoimg img, x, y, canvas,acol,offset |
| { |
| local loo,loo2,acolor |
| aimgtoimg_use_count=aimgtoimg_use_count+1 |
| if aimgtoimg_use_count = 1 |
| jmp end_aimgtoimg_proc |
| acolor dd 0 |
| aimgtoimg_proc: |
| ;getout coord |
| mov [acolor],ebp |
| push eax ;;;;;;;;;;;;;;;;;;; |
| mov eax,esi ;y cor |
| mul dword [ecx] ;canvas xsize |
| add eax,edi ;x cor |
| mov ebp,eax |
| shl eax,1 |
| add ebp,eax |
| add ebp,ecx ;canvas+8;start |
| add ebp,8 |
| ;get img size |
| mov eax,ebx ;img ;xsize |
| mov esi,[eax] |
| add ebx,4 |
| mov eax,ebx ; img+4 ;ysize |
| mov edi,[eax] |
| add ebx,4 |
| mov edx,ebx ;img+8 |
| pop eax |
| add edx,eax |
| loo2: |
| push esi |
| loo: |
| ;test on alpha color |
| mov eax,[edx] |
| shl eax,8 |
| shr eax,8 |
| cmp eax,[acolor] |
| jne yx |
| add edx,3 |
| add ebp,3 |
| jmp nx |
| yx: |
| mov al,byte [edx] |
| mov byte [ebp],al |
| inc ebp |
| inc edx |
| mov al,byte [edx] |
| mov byte [ebp],al |
| inc ebp |
| inc edx |
| mov al,byte [edx] |
| mov byte [ebp],al |
| inc ebp |
| inc edx |
| nx: |
| dec esi |
| jnz loo |
| pop esi |
| sub ebp,3 |
| mov eax,[ecx] ;offset = offset+((canxsize-imgxsize)*3) |
| sub eax,esi |
| add ebp,eax |
| shl eax,1 |
| add ebp,eax |
| add ebp,3 |
| dec edi |
| jnz loo2 |
| ret |
| end_aimgtoimg_proc: |
| end if |
| push img |
| push canvas |
| push x |
| push y |
| push acol |
| push offset |
| pop eax |
| pop ebp |
| pop esi |
| pop edi |
| pop ecx |
| pop ebx |
| call aimgtoimg_proc |
| } |
| imgtoimg_use_count=0 |
| macro imgtoimg img, x, y, canvas |
| { |
| local loo,loo2 |
| imgtoimg_use_count=imgtoimg_use_count+1 |
| if imgtoimg_use_count = 1 |
| jmp end_imgtoimg_proc |
| imgtoimg_proc: |
| ;getout coord |
| mov eax,esi ;y cor |
| mul dword [ecx] ;canvas xsize |
| add eax,edi ;x cor |
| mov ebp,eax |
| shl eax,1 |
| add ebp,eax |
| add ebp,ecx ;canvas+8;start |
| add ebp,8 |
| ;get img size |
| mov eax,ebx ;img ;xsize |
| mov esi,[eax] |
| add ebx,4 |
| mov eax,ebx ; img+4 ;ysize |
| mov edi,[eax] |
| add ebx,4 |
| mov edx,ebx ;img+8 |
| loo2: |
| push esi |
| loo: |
| mov al,byte [edx] |
| mov byte [ebp],al |
| inc ebp |
| inc edx |
| mov al,byte [edx] |
| mov byte [ebp],al |
| inc ebp |
| inc edx |
| mov al,byte [edx] |
| mov byte [ebp],al |
| inc ebp |
| inc edx |
| dec esi |
| jnz loo |
| pop esi |
| sub ebp,3 |
| mov eax,[ecx] ;offset = offset+((canxsize-imgxsize)*3) |
| sub eax,esi |
| add ebp,eax |
| shl eax,1 |
| add ebp,eax |
| add ebp,3 |
| dec edi |
| jnz loo2 |
| ret |
| end_imgtoimg_proc: |
| end if |
| push img |
| push canvas |
| push x |
| push y |
| pop esi |
| pop edi |
| pop ecx |
| pop ebx |
| call imgtoimg_proc |
| } |
| ;DrawBox |
| macro drawfbox x,y,xs,ys,color |
| { |
| words2reg ebx,x,xs ;x*65536+xs |
| words2reg ecx,y,ys ;y*65536+ys |
| mov edx,color |
| mov eax,13 |
| int 0x40 |
| } |
| ; FPS - Set Frame Per Second Display |
| fps_show_frequency=40 |
| macro fps x,y,color,delcolor |
| { |
| local spdat,savetime,new_time,fps,fps_cntr,out_fps,new_time,ttt |
| local no_out_fps |
| jmp spdat |
| savetime dd 0 |
| fps_cntr dd 0 |
| fps dd 0 |
| ttt dd 0 |
| spdat: |
| get_time: |
| mov eax,3 |
| int 0x40 |
| cmp eax,[savetime] |
| jne new_time |
| inc [fps_cntr] |
| cmp dword [ttt],0 |
| je out_fps |
| dec dword [ttt] |
| jmp no_out_fps |
| new_time: |
| mov [savetime],eax |
| mov ebx,[fps_cntr] |
| mov [fps],ebx |
| mov [fps_cntr],0 |
| out_fps: |
| if ~(delcolor eq ) |
| mov ebx,x*65536+30 |
| mov ecx,y*65536+7 |
| mov edx,delcolor |
| mov eax,13 |
| int 0x40 |
| end if |
| mov dword [ttt],fps_show_frequency |
| mov eax,47 |
| mov ebx,5*65536 |
| ; mov bl,0 |
| mov edx,x*65536+y |
| mov esi,color |
| mov ecx,[fps] |
| int 0x40 |
| no_out_fps: |
| } |
| ; COLLIMG - Collusion image's |
| _1dbounce_count=0; |
| macro collimg img1_off,x1,y1,img2_off,x2,y2,otv |
| { |
| local bounce,exit,anot,bc,nbc |
| mov esi,[img1_off] ;xs1 |
| mov edi,[img2_off] ;ys2 |
| mov eax,x1 ; |
| mov ebx,x2 ; |
| call _1dbounce |
| mov edx,ecx |
| mov esi,[img1_off+4] ;ys1 |
| mov edi,[img2_off+4] ;ys2 |
| mov eax,y1 ; |
| mov ebx,y2 ; |
| call _1dbounce |
| add edx,ecx |
| cmp edx,2 |
| je bounce |
| mov otv,0 |
| jmp exit |
| _1dbounce_count=_1dbounce_count+1 |
| if _1dbounce_count = 1 |
| _1dbounce: |
| cmp ebx,eax |
| jb anot |
| add eax,esi |
| cmp eax,ebx |
| jbe nbc |
| bc: |
| mov ecx,1 |
| ret |
| anot: |
| add ebx,edi |
| cmp ebx,eax |
| ja bc |
| nbc: |
| xor ecx,ecx |
| ret |
| end if |
| bounce: |
| mov otv,1 |
| exit: |
| } |
| macro rgbtobgr image |
| { |
| local loo |
| mov eax,[image] |
| mul dword [image+4] |
| mov ecx,eax |
| mov esi,image+8 |
| ; add esi,8 |
| loo: |
| mov al,[esi] |
| mov bl,[esi+2] |
| mov [esi],bl |
| mov [esi+2],al |
| add esi,3 |
| dec ecx |
| jnz loo |
| } |
| macro setimg x , y ,arg3 |
| { |
| mov eax,7 |
| mov ebx,arg3 |
| add ebx,8 |
| mov cx,[arg3] |
| shl ecx,16 |
| add cx,[arg3+4] |
| ; wordstoreg ecx,[arg3],[arg3+4] |
| words2reg edx, x , y ;arg1*65536+arg2 |
| int 0x40 |
| } |
| macro setframe x , y ,arg3 |
| { |
| mov eax,7 |
| mov ebx,arg3 |
| add ebx,8 |
| words2reg edx, x , y ;arg1*65536+arg2 |
| add edx,dword [arg3] |
| mov ecx,dword [arg3+4] |
| int 0x40 |
| } |
| macro getimg imgsrc,x,y,xs,ys,imgdest |
| { |
| local cyc |
| if xs eqtype 0 |
| mov dword [imgdest],xs |
| else |
| mov eax,xs |
| mov dword [imgdest],eax |
| end if |
| if ys eqtype 0 |
| mov dword [imgdest+4],ys |
| else |
| mov eax,ys |
| mov dword [imgdest+4],eax |
| end if |
| mov eax,dword [imgsrc] ;getx size |
| ; lea ecx,[eax+2*eax] |
| mov ecx,eax |
| shl ecx,1 |
| add ecx,eax |
| mov ebx,y |
| mul ebx |
| add eax,x |
| mov edx,ecx |
| lea eax,[eax+2*eax] ;eax=offset on imsrc |
| ; mov ebp,eax |
| ; shl eax,1 |
| ; add eax,ebp |
| mov ecx,xs |
| mov ebx,ys |
| mov edi,8+imgdest |
| lea esi,[eax+8+imgsrc] |
| ; mov esi,eax |
| ; add esi,8 |
| ; add esi,imgsrc |
| cld |
| cyc: |
| movsw |
| movsb |
| dec ecx |
| jne cyc |
| add esi,edx |
| mov ecx,xs |
| sub esi,ecx |
| sub esi,ecx |
| sub esi,ecx |
| dec ebx |
| jne cyc |
| } |
| macro copyimg img2_off,img1_off |
| { |
| mov eax,dword [img1_off] |
| mov ebx,dword [img1_off+4] |
| mul ebx |
| lea ecx,[eax+2*eax] |
| lea esi,[img1_off+8] |
| lea edi,[img2_off+8] |
| cld |
| rep movsb |
| } |
| macro fullimg img_off,xs,ys,color |
| { |
| local cop |
| mov eax,xs |
| mov ebx,ys |
| mov dword [img_off],eax |
| mov dword [img_off+4],ebx |
| mul ebx |
| lea ebp,[eax+2*eax] |
| mov esi,color |
| if color eqtype 0 |
| mov ecx,color/65536 |
| else |
| mov ecx,esi |
| shr ecx,16 |
| end if |
| xor edi,edi |
| cop: |
| mov word [img_off+8+edi],si |
| add edi,2 |
| mov byte [img_off+8+edi],cl |
| inc edi |
| cmp edi,ebp |
| jne cop |
| } |
| ; number of frame in ecx |
| ; callculatin offset of raw data |
| macro getframeoff num_of_frame,offset_of_animation,offset_of_frame |
| { |
| local loo,setpic |
| mov ebp,num_of_frame ;ecx |
| mov esi,offset_of_animation;Image |
| loo: |
| cmp ebp,0 |
| je setpic |
| movzx eax,word [esi+4] |
| movzx ebx,word [esi+6] |
| mul ebx ;dword [esi+4] |
| mov ebx,3 |
| mul ebx |
| add eax,8 |
| add esi,eax |
| dec ebp |
| jmp loo |
| setpic: |
| mov dword offset_of_frame,esi |
| } |
| ; BMPTOIMG -Convert BMP format TO IMG format |
| ; (SYNTAX) BMPTOIMG BMP_source_offset,IMG_dest_ofset |
| ; (SAMPLE) View BMPLS.ASM sample. |
| ; ( NOTE ) This is macros is not brake bmp structure! Tested in 32,8,4 bits |
| bmptoimg_data_area_count=0 |
| macro bmptoimg bmp_load_area,img_dest_area |
| { |
| local fileinfo,string,end_bmp,nodix |
| local converttable,noaddelem,nextbit,convert1bpp,convert4bpp,convert2 |
| local nextelem,convertno32,nomorestring,convert1,nextstring,yespicsize |
| ;local qwe,bmpfn |
| ; convert: |
| movzx eax,word [bmp_load_area+28] |
| mul dword [bmp_load_area+18] |
| add eax,31 |
| shr eax,5 |
| mov dword [bmptoimg_data_area_dwps],eax ;dwps-doublewords per string |
| shl eax,2 |
| mov dword [bmptoimg_data_area_bps],eax ;bps-bytes per string |
| cmp dword [bmp_load_area+34],0 |
| jne yespicsize ;if picture size is defined |
| mul dword [bmp_load_area+22] |
| mov dword [bmp_load_area+34],eax |
| yespicsize: |
| mov ebp,img_dest_area+8 |
| mov eax,bmp_load_area |
| mov ebx,eax |
| add ebx, [bmp_load_area+2];file size |
| inc ebx |
| mov dword [bmptoimg_soi],ebx ;soi-start of image area for drawing |
| add eax, [bmp_load_area+10] |
| mov dword [bmptoimg_data_area_sop],eax ;sop-start of picture in file |
| add eax, [bmp_load_area+34] |
| mov dword [bmptoimg_data_area_eop],eax ;eop-end of picture in file |
| mov eax, [bmp_load_area+18] |
| lea eax,[eax+2*eax] ;3x pixels in eax |
| mov edi,dword [bmptoimg_soi] ;initializing |
| mov esi,dword [bmptoimg_data_area_eop] |
| sub esi,dword [bmptoimg_data_area_bps] |
| nextstring: |
| push edi |
| push ebp |
| cmp word [bmp_load_area+28],24 |
| jne convertno32 |
| mov edi,ebp |
| mov ecx,[bmptoimg_data_area_dwps] |
| cld |
| rep movsd |
| convert1: |
| pop ebp |
| pop edi |
| sub esi,dword [bmptoimg_data_area_bps] |
| sub esi,dword [bmptoimg_data_area_bps] |
| cmp esi,dword [bmptoimg_data_area_sop] |
| jb end_bmp |
| add edi,eax |
| add ebp,eax |
| jmp nextstring |
| convertno32: |
| mov ebx,bmp_load_area |
| add ebx, [bmp_load_area+14] |
| add ebx,14 ;start of color table |
| push esi |
| add esi,dword [bmptoimg_data_area_bps] |
| mov dword [bmptoimg_data_area_eos],esi |
| pop esi |
| nextelem: |
| push eax |
| movzx eax,byte [esi] |
| cmp word [bmp_load_area+28],4 |
| je convert4bpp |
| cmp word [bmp_load_area+28],1 |
| je convert1bpp |
| call converttable |
| convert2: |
| pop eax |
| inc esi |
| cmp esi,dword [bmptoimg_data_area_eos] |
| jae convert1 |
| add edi,3 |
| add ebp,3 |
| jmp nextelem |
| convert4bpp: |
| shl ax,4 |
| shr al,4 |
| push ax |
| movzx eax,ah |
| call converttable |
| add edi,3 |
| add ebp,3 |
| pop ax |
| movzx eax,al |
| call converttable |
| jmp convert2 |
| convert1bpp: |
| mov ecx,eax |
| mov edx,7 |
| nextbit: |
| xor eax,eax |
| bt ecx,edx |
| jnc noaddelem |
| inc eax |
| noaddelem: |
| push edx |
| call converttable |
| pop edx |
| dec edx |
| js convert2 |
| add edi,3 |
| add ebp,3 |
| jmp nextbit |
| converttable: |
| shl eax,2 |
| add eax,ebx |
| mov edx, dword [eax] |
| ; mov dword [edi],edx |
| mov [ebp],edx |
| ret |
| bmptoimg_data_area_count=bmptoimg_data_area_count+1 |
| if bmptoimg_data_area_count = 1 |
| ; DATA AREA |
| bmptoimg_soi dd 0 |
| bmptoimg_data_area_bps dd 0 |
| bmptoimg_data_area_dwps dd 0 |
| bmptoimg_data_area_sop dd 0 |
| bmptoimg_data_area_eop dd 0 |
| bmptoimg_data_area_eos dd 0 |
| end if |
| end_bmp: |
| mov eax,dword [bmp_load_area+18] |
| mov ebx,dword [bmp_load_area+22] |
| mov dword [img_dest_area],eax |
| mov dword [img_dest_area+4],ebx |
| } |
| ; For convert RGB to BGR |
| COLOR_ORDER equ MENUETOS |
| macro giftoani gifsrc,imgsrc,num_of_frames |
| { |
| local hasharea, ReadGIF, nextblock,_null |
| local globalColor, img_count, cur_info, img_start |
| local codesize, compsize, bit_count, CC, EOI, Palette |
| local block_ofs, table_ptr, gifmacend |
| local no_gc, block_skip, no_comm, noextblock, uselocal |
| local setPal, filltable, reinit, cycle, zadd, noinc |
| local notintable, er, zend, nxt, continue, ex, Gif_skipmap |
| local Gif_get_sym, shift, nextbl, noblock, loop1, exx |
| local Gif_output, next, loop2 |
| _null fix 1000h ; 0x1000 |
| ; jmp sss |
| ; if defined gif_hash_offset |
| ; else |
| ; hasharea: |
| ; times 4096 dd 0 ;4096 |
| ; end if |
| ;sss: |
| mov esi,gifsrc ;ª § ⥫ì ä ¨« ¢ ¯ ¬ï⨠|
| mov edi,imgsrc ;ª § ⥫ì ᯨ᮪ ª à⨮ª |
| if defined gif_hash_offset |
| mov eax,gif_hash_offset ; ¡®ç ï ®¡« áâì ¬¨¨¬ã¬ 4096*4 ¡ ©â |
| else |
| mov eax,hasharea ; ¡®ç ï ®¡« áâì ¬¨¨¬ã¬ 4096*4 ¡ ©â |
| end if |
| call ReadGIF |
| push ecx |
| pop dword num_of_frames |
| jmp gifmacend |
| if defined gif_hash_offset |
| else |
| hasharea: |
| times 4096 dd 0 ;4096 |
| end if |
| ReadGIF: |
| push esi edi |
| mov [table_ptr],eax |
| mov [cur_info],edi |
| xor eax,eax |
| mov [globalColor],eax |
| mov [img_count],eax |
| inc eax |
| cmp dword[esi],'GIF8' |
| jne er ; signature |
| mov ecx,[esi+0xa] |
| inc eax |
| add esi,0xd |
| mov edi,esi |
| bt ecx,7 |
| jnc nextblock |
| mov [globalColor],esi |
| call Gif_skipmap |
| nextblock: |
| cmp byte[edi],0x21 |
| jne noextblock |
| inc edi |
| cmp byte[edi],0xf9 ; Graphic Control Ext |
| jne no_gc |
| add edi,7 |
| jmp nextblock |
| no_gc: |
| cmp byte[edi],0xfe ; Comment Ext |
| jne no_comm |
| inc edi |
| block_skip: |
| movzx eax,byte[edi] |
| lea edi,[edi+eax+1] |
| cmp byte[edi],0 |
| jnz block_skip |
| inc edi |
| jmp nextblock |
| no_comm: |
| cmp byte[edi],0xff ; Application Ext |
| jne nextblock |
| add edi,13 |
| jmp block_skip |
| noextblock: |
| cmp byte[edi],0x2c ; image beginning |
| jne er |
| inc [img_count] |
| inc edi |
| mov esi,[cur_info] |
| xchg esi,edi |
| movsd |
| movsd |
| push edi |
| movzx ecx,word[esi] |
| inc esi |
| bt ecx,7 |
| jc uselocal |
| push [globalColor] |
| mov edi,esi |
| jmp setPal |
| uselocal: |
| call Gif_skipmap |
| push esi |
| setPal: |
| movzx ecx,byte[edi] |
| inc ecx |
| mov [codesize],ecx |
| dec ecx |
| pop [Palette] |
| lea esi,[edi+1] |
| mov edi,[table_ptr] |
| xor eax,eax |
| cld |
| lodsb ; eax - block_count |
| add eax,esi |
| mov [block_ofs],eax |
| mov [bit_count],8 |
| mov eax,1 |
| shl eax,cl |
| mov [CC],eax |
| inc eax |
| mov [EOI],eax |
| lea ecx,[eax-1] |
| mov eax, _null shl 16 |
| filltable: |
| stosd |
| inc eax |
| loop filltable |
| pop edi |
| mov [img_start],edi |
| reinit: |
| mov edx,[EOI] |
| inc edx |
| push [codesize] |
| pop [compsize] |
| call Gif_get_sym |
| cmp eax,[CC] |
| je reinit |
| call Gif_output |
| cycle: |
| movzx ebx,ax |
| call Gif_get_sym |
| cmp eax,edx |
| jae notintable |
| cmp eax,[CC] |
| je reinit |
| cmp eax,[EOI] |
| je zend |
| call Gif_output |
| zadd: |
| push eax |
| mov eax,[table_ptr] |
| mov [eax+edx*4],ebx |
| pop eax |
| cmp edx,0xFFF |
| jae cycle |
| inc edx |
| bsr ebx,edx |
| cmp ebx,[compsize] |
| jne noinc |
| inc [compsize] |
| noinc: |
| jmp cycle |
| notintable: |
| push eax |
| mov eax,ebx |
| call Gif_output |
| push ebx |
| movzx eax,bx |
| call Gif_output |
| pop ebx eax |
| jmp zadd |
| er: |
| pop edi |
| jmp ex |
| zend: |
| ; mov eax,[.cur_info] ; skip offset to next frame |
| ; mov [eax],edi |
| mov [cur_info],edi |
| add esi,2 |
| xchg esi,edi |
| nxt: |
| cmp byte[edi],0 |
| jnz continue |
| inc edi |
| jmp nxt |
| continue: |
| cmp byte[edi],0x3b ;read next frame |
| jne nextblock |
| xor eax,eax |
| stosd |
| mov ecx,[img_count] |
| ex: |
| pop edi esi |
| ret |
| Gif_skipmap: |
| ; in: ecx - image descriptor, esi - pointer to colormap |
| ; out: edi - pointer to area after colormap |
| and ecx,111b |
| inc ecx ; color map size |
| mov ebx,1 |
| shl ebx,cl |
| lea ebx,[ebx*2+ebx] |
| lea edi,[esi+ebx] |
| ret |
| Gif_get_sym: |
| mov ecx,[compsize] |
| push ecx |
| xor eax,eax |
| shift: |
| ror byte[esi],1 |
| rcr eax,1 |
| dec [bit_count] |
| jnz loop1 |
| inc esi |
| cmp esi,[block_ofs] |
| jb noblock |
| push eax |
| xor eax,eax |
| lodsb |
| test eax,eax |
| jnz nextbl |
| mov eax,[EOI] |
| sub esi,2 |
| add esp,8 |
| jmp exx |
| nextbl: |
| add eax,esi |
| mov [block_ofs],eax |
| pop eax |
| noblock: |
| mov [bit_count],8 |
| loop1: |
| loop shift |
| pop ecx |
| rol eax,cl |
| exx: |
| xor ecx,ecx |
| ret |
| Gif_output: |
| push esi eax edx |
| mov edx,[table_ptr] |
| next: |
| push word[edx+eax*4] |
| mov ax,word[edx+eax*4+2] |
| inc ecx |
| cmp ax,_null |
| jnz next |
| shl ebx,16 |
| mov bx,[esp] |
| loop2: |
| pop ax |
| lea esi,[eax+eax*2] |
| add esi,[Palette] |
| if COLOR_ORDER eq MENUETOS |
| mov esi,[esi] |
| bswap esi |
| shr esi,8 |
| mov [edi],esi |
| add edi,3 |
| else |
| movsw |
| movsb |
| end if |
| loop loop2 |
| pop edx eax esi |
| ret |
| globalColor dd 1 |
| img_count dd 1 |
| cur_info dd 1 ; image table pointer |
| img_start dd 1 |
| codesize dd 1 |
| compsize dd 1 |
| bit_count dd 1 |
| CC dd 1 |
| EOI dd 1 |
| Palette dd 1 |
| block_ofs dd 1 |
| table_ptr dd 1 |
| gifmacend: |
| } |
| macro giftoimg gifsrc,imgsrc |
| { |
| local hasharea, ReadGIF, nextblock,_null |
| local globalColor, img_count, cur_info, img_start |
| local codesize, compsize, bit_count, CC, EOI, Palette |
| local block_ofs, table_ptr, gifmacend |
| local no_gc, block_skip, no_comm, noextblock, uselocal |
| local setPal, filltable, reinit, cycle, zadd, noinc |
| local notintable, er, zend, nxt, continue, ex, Gif_skipmap |
| local Gif_get_sym, shift, nextbl, noblock, loop1, exx |
| local Gif_output, next, loop2 |
| _null fix 0x1000 ; 0x1000 |
| mov esi,gifsrc ;ª § ⥫ì ä ¨« ¢ ¯ ¬ï⨠|
| mov edi,imgsrc ;ª § ⥫ì ᯨ᮪ ª à⨮ª |
| if defined gif_hash_offset |
| mov eax,gif_hash_offset ; ¡®ç ï ®¡« áâì ¬¨¨¬ã¬ 4096*4 ¡ ©â |
| else |
| mov eax,hasharea ; ¡®ç ï ®¡« áâì ¬¨¨¬ã¬ 4096*4 ¡ ©â |
| end if |
| call ReadGIF |
| jmp gifmacend |
| if defined gif_hash_offset |
| else |
| hasharea: |
| times 4096 dd 0 ;4096 |
| end if |
| ReadGIF: |
| push esi edi |
| mov [table_ptr],eax |
| mov [cur_info],edi |
| xor eax,eax |
| mov [globalColor],eax |
| mov [img_count],eax |
| inc eax |
| cmp dword[esi],'GIF8' |
| jne er ; signature |
| mov ecx,[esi+0xa] |
| inc eax |
| add esi,0xd |
| mov edi,esi |
| bt ecx,7 |
| jnc nextblock |
| mov [globalColor],esi |
| call Gif_skipmap |
| nextblock: |
| cmp byte[edi],0x21 |
| jne noextblock |
| inc edi |
| cmp byte[edi],0xf9 ; Graphic Control Ext |
| jne no_gc |
| add edi,7 |
| jmp nextblock |
| no_gc: |
| cmp byte[edi],0xfe ; Comment Ext |
| jne no_comm |
| inc edi |
| block_skip: |
| movzx eax,byte[edi] |
| lea edi,[edi+eax+1] |
| cmp byte[edi],0 |
| jnz block_skip |
| inc edi |
| jmp nextblock |
| no_comm: |
| cmp byte[edi],0xff ; Application Ext |
| jne nextblock |
| add edi,13 |
| jmp block_skip |
| noextblock: |
| cmp byte[edi],0x2c ; image beginning |
| jne er |
| inc [img_count] |
| inc edi |
| mov esi,[cur_info] |
| xchg esi,edi |
| ; movsd |
| ; movsd |
| mov bp,word[esi+4] |
| movzx ebx,bp |
| mov [edi],ebx |
| mov bp,word[esi+6] |
| movzx ebx,bp |
| mov [edi+4],ebx |
| add edi,8 |
| add esi,8 |
| push edi |
| movzx ecx,word[esi] |
| inc esi |
| bt ecx,7 |
| jc uselocal |
| push [globalColor] |
| mov edi,esi |
| jmp setPal |
| uselocal: |
| call Gif_skipmap |
| push esi |
| setPal: |
| movzx ecx,byte[edi] |
| inc ecx |
| mov [codesize],ecx |
| dec ecx |
| pop [Palette] |
| lea esi,[edi+1] |
| mov edi,[table_ptr] |
| xor eax,eax |
| cld |
| lodsb ; eax - block_count |
| add eax,esi |
| mov [block_ofs],eax |
| mov [bit_count],8 |
| mov eax,1 |
| shl eax,cl |
| mov [CC],eax |
| inc eax |
| mov [EOI],eax |
| lea ecx,[eax-1] |
| mov eax, _null shl 16 |
| filltable: |
| stosd |
| inc eax |
| loop filltable |
| pop edi |
| mov [img_start],edi |
| reinit: |
| mov edx,[EOI] |
| inc edx |
| push [codesize] |
| pop [compsize] |
| call Gif_get_sym |
| cmp eax,[CC] |
| je reinit |
| call Gif_output |
| cycle: |
| movzx ebx,ax |
| call Gif_get_sym |
| cmp eax,edx |
| jae notintable |
| cmp eax,[CC] |
| je reinit |
| cmp eax,[EOI] |
| je zend |
| call Gif_output |
| zadd: |
| push eax |
| mov eax,[table_ptr] |
| mov [eax+edx*4],ebx |
| pop eax |
| cmp edx,0xFFF |
| jae cycle |
| inc edx |
| bsr ebx,edx |
| cmp ebx,[compsize] |
| jne noinc |
| inc [compsize] |
| noinc: |
| jmp cycle |
| notintable: |
| push eax |
| mov eax,ebx |
| call Gif_output |
| push ebx |
| movzx eax,bx |
| call Gif_output |
| pop ebx eax |
| jmp zadd |
| er: |
| pop edi |
| jmp ex |
| zend: |
| ; mov eax,[.cur_info] ; skip offset to next frame |
| ; mov [eax],edi |
| mov [cur_info],edi |
| add esi,2 |
| xchg esi,edi |
| nxt: |
| cmp byte[edi],0 |
| jnz continue |
| inc edi |
| jmp nxt |
| continue: |
| ; cmp byte[edi],0x3b ;read next frame |
| ; jne nextblock |
| xor eax,eax |
| stosd |
| mov ecx,[img_count] |
| ex: |
| pop edi esi |
| ret |
| Gif_skipmap: |
| ; in: ecx - image descriptor, esi - pointer to colormap |
| ; out: edi - pointer to area after colormap |
| and ecx,111b |
| inc ecx ; color map size |
| mov ebx,1 |
| shl ebx,cl |
| lea ebx,[ebx*2+ebx] |
| lea edi,[esi+ebx] |
| ret |
| Gif_get_sym: |
| mov ecx,[compsize] |
| push ecx |
| xor eax,eax |
| shift: |
| ror byte[esi],1 |
| rcr eax,1 |
| dec [bit_count] |
| jnz loop1 |
| inc esi |
| cmp esi,[block_ofs] |
| jb noblock |
| push eax |
| xor eax,eax |
| lodsb |
| test eax,eax |
| jnz nextbl |
| mov eax,[EOI] |
| sub esi,2 |
| add esp,8 |
| jmp exx |
| nextbl: |
| add eax,esi |
| mov [block_ofs],eax |
| pop eax |
| noblock: |
| mov [bit_count],8 |
| loop1: |
| loop shift |
| pop ecx |
| rol eax,cl |
| exx: |
| xor ecx,ecx |
| ret |
| Gif_output: |
| push esi eax edx |
| mov edx,[table_ptr] |
| next: |
| push word[edx+eax*4] |
| mov ax,word[edx+eax*4+2] |
| inc ecx |
| cmp ax,_null |
| jnz next |
| shl ebx,16 |
| mov bx,[esp] |
| loop2: |
| pop ax |
| lea esi,[eax+eax*2] |
| add esi,[Palette] |
| if COLOR_ORDER eq MENUETOS |
| mov esi,[esi] |
| bswap esi |
| shr esi,8 |
| mov [edi],esi |
| add edi,3 |
| else |
| movsw |
| movsb |
| end if |
| loop loop2 |
| pop edx eax esi |
| ret |
| globalColor dd 1 |
| img_count dd 1 |
| cur_info dd 1 ; image table pointer |
| img_start dd 1 |
| codesize dd 1 |
| compsize dd 1 |
| bit_count dd 1 |
| CC dd 1 |
| EOI dd 1 |
| Palette dd 1 |
| block_ofs dd 1 |
| table_ptr dd 1 |
| gifmacend: |
| } |
| /programs/games/invaders/alien.gif |
|---|
| Cannot display: file marked as a binary type. |
| svn:mime-type = application/octet-stream |
| Property changes: |
| Added: svn:mime-type |
| +application/octet-stream |
| \ No newline at end of property |
| /programs/games/invaders/bullet.gif |
|---|
| Cannot display: file marked as a binary type. |
| svn:mime-type = application/octet-stream |
| Property changes: |
| Added: svn:mime-type |
| +application/octet-stream |
| \ No newline at end of property |
| /programs/games/invaders/bullet2.gif |
|---|
| Cannot display: file marked as a binary type. |
| svn:mime-type = application/octet-stream |
| Property changes: |
| Added: svn:mime-type |
| +application/octet-stream |
| \ No newline at end of property |
| /programs/games/invaders/enemy1.gif |
|---|
| Cannot display: file marked as a binary type. |
| svn:mime-type = application/octet-stream |
| Property changes: |
| Added: svn:mime-type |
| +application/octet-stream |
| \ No newline at end of property |
| /programs/games/invaders/enemy2.gif |
|---|
| Cannot display: file marked as a binary type. |
| svn:mime-type = application/octet-stream |
| Property changes: |
| Added: svn:mime-type |
| +application/octet-stream |
| \ No newline at end of property |
| /programs/games/invaders/enemy3.gif |
|---|
| Cannot display: file marked as a binary type. |
| svn:mime-type = application/octet-stream |
| Property changes: |
| Added: svn:mime-type |
| +application/octet-stream |
| \ No newline at end of property |
| /programs/games/invaders/enemy4.gif |
|---|
| Cannot display: file marked as a binary type. |
| svn:mime-type = application/octet-stream |
| Property changes: |
| Added: svn:mime-type |
| +application/octet-stream |
| \ No newline at end of property |
| /programs/games/invaders/enemy5.gif |
|---|
| Cannot display: file marked as a binary type. |
| svn:mime-type = application/octet-stream |
| Property changes: |
| Added: svn:mime-type |
| +application/octet-stream |
| \ No newline at end of property |
| /programs/games/invaders/font_capital.gif |
|---|
| Cannot display: file marked as a binary type. |
| svn:mime-type = application/octet-stream |
| Property changes: |
| Added: svn:mime-type |
| +application/octet-stream |
| \ No newline at end of property |
| /programs/games/invaders/font_small.gif |
|---|
| Cannot display: file marked as a binary type. |
| svn:mime-type = application/octet-stream |
| Property changes: |
| Added: svn:mime-type |
| +application/octet-stream |
| \ No newline at end of property |
| /programs/games/invaders/gameover.gif |
|---|
| Cannot display: file marked as a binary type. |
| svn:mime-type = application/octet-stream |
| Property changes: |
| Added: svn:mime-type |
| +application/octet-stream |
| \ No newline at end of property |
| /programs/games/invaders/highscores.gif |
|---|
| Cannot display: file marked as a binary type. |
| svn:mime-type = application/octet-stream |
| Property changes: |
| Added: svn:mime-type |
| +application/octet-stream |
| \ No newline at end of property |
| /programs/games/invaders/invaders.asm |
|---|
| 0,0 → 1,1408 |
| ;=============================================================================; |
| ; 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,'DexOS 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' |
| /programs/games/invaders/invaders.dat |
|---|
| Cannot display: file marked as a binary type. |
| svn:mime-type = application/octet-stream |
| Property changes: |
| Added: svn:mime-type |
| +application/octet-stream |
| \ No newline at end of property |
| /programs/games/invaders/invaders_kolibri.inc |
|---|
| 0,0 → 1,108 |
| 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_Icon |
| KEY_RIGHT equ 179 |
| KEY_LEFT equ 176 |
| KEY_UP equ 178 |
| KEY_P equ 'p' |
| KEY_DOWN equ 177 |
| KEY_ENTER equ 13 |
| KEY_ESC equ 27 |
| START: |
| mov [drawroutine], draw_picture_kolibri |
| call draw_window |
| jmp decodegif |
| draw_picture_kolibri: |
| mov eax,7 ; Draw buffer to screen |
| mov ebx,vscreen+8 |
| mov ecx,SCREEN_X*65536+SCREEN_Y |
| mov edx,SCREEN_X_POS*65536+SCREEN_Y_POS |
| int 0x40 |
| ret |
| waitandgetkey: |
| mov eax, 5 |
| mov ebx, 1 |
| int 0x40 |
| mov eax, 11 ; check for event (no wait) |
| int 0x40 |
| cmp eax,1 ; redraw request ? |
| je red |
| cmp eax,2 ; key in buffer ? |
| je key |
| cmp eax,3 ; button in buffer ? |
| je button |
| xor ax,ax |
| ret |
| red: ; redraw |
| call draw_window |
| jmp waitandgetkey |
| key: ; key |
| mov eax,2 ; read it |
| int 0x40 |
| mov al, ah |
| ret |
| button: ; button |
| mov eax,17 ; get id |
| int 0x40 |
| cmp ah,1 ; button id=1 ? |
| jne noclose |
| exit: |
| mov eax,-1 ; close this program |
| int 0x40 |
| noclose: |
| jmp waitandgetkey |
| draw_window: |
| mov eax,12 ; function 12:tell os about windowdraw |
| mov ebx,1 ; 1, start of draw |
| int 0x40 |
| ; DRAW WINDOW |
| mov eax,0 ; function 0 : define and draw window |
| mov ebx,WINDOW_X*65536+10+SCREEN_X ; [x start] *65536 + [x size] |
| mov ecx,WINDOW_Y*65536+30+SCREEN_Y ; [y start] *65536 + [y size] |
| mov edx,0x04000000 ; color of work area RRGGBB,8->color gl |
| mov esi,0x805080d0 ; color of grab bar RRGGBB,8->color gl |
| mov edi,0x005080d0 ; color of frames RRGGBB |
| int 0x40 |
| call [drawroutine] |
| mov eax,12 ; function 12:tell os about windowdraw |
| mov ebx,2 ; 2, end of draw |
| int 0x40 |
| ret |
| load_highscores: |
| ret |
| save_highscores: |
| ret |
| /programs/games/invaders/logo.gif |
|---|
| Cannot display: file marked as a binary type. |
| svn:mime-type = application/octet-stream |
| Property changes: |
| Added: svn:mime-type |
| +application/octet-stream |
| \ No newline at end of property |
| /programs/games/invaders/menu1.gif |
|---|
| Cannot display: file marked as a binary type. |
| svn:mime-type = application/octet-stream |
| Property changes: |
| Added: svn:mime-type |
| +application/octet-stream |
| \ No newline at end of property |
| /programs/games/invaders/menu2.gif |
|---|
| Cannot display: file marked as a binary type. |
| svn:mime-type = application/octet-stream |
| Property changes: |
| Added: svn:mime-type |
| +application/octet-stream |
| \ No newline at end of property |
| /programs/games/invaders/menu3.gif |
|---|
| Cannot display: file marked as a binary type. |
| svn:mime-type = application/octet-stream |
| Property changes: |
| Added: svn:mime-type |
| +application/octet-stream |
| \ No newline at end of property |
| /programs/games/invaders/menu4.gif |
|---|
| Cannot display: file marked as a binary type. |
| svn:mime-type = application/octet-stream |
| Property changes: |
| Added: svn:mime-type |
| +application/octet-stream |
| \ No newline at end of property |
| /programs/games/invaders/nextlevel.gif |
|---|
| Cannot display: file marked as a binary type. |
| svn:mime-type = application/octet-stream |
| Property changes: |
| Added: svn:mime-type |
| +application/octet-stream |
| \ No newline at end of property |
| /programs/games/invaders/numbers.gif |
|---|
| Cannot display: file marked as a binary type. |
| svn:mime-type = application/octet-stream |
| Property changes: |
| Added: svn:mime-type |
| +application/octet-stream |
| \ No newline at end of property |
| /programs/games/invaders/pause.gif |
|---|
| Cannot display: file marked as a binary type. |
| svn:mime-type = application/octet-stream |
| Property changes: |
| Added: svn:mime-type |
| +application/octet-stream |
| \ No newline at end of property |
| /programs/games/invaders/ship.gif |
|---|
| Cannot display: file marked as a binary type. |
| svn:mime-type = application/octet-stream |
| Property changes: |
| Added: svn:mime-type |
| +application/octet-stream |
| \ No newline at end of property |
| /programs/games/invaders/. |
|---|
| Property changes: |
| Added: tsvn:logminsize |
| +5 |
| \ No newline at end of property |
