| /programs/games/megamaze/trunk/tam.INC |
|---|
| File deleted |
| /programs/games/megamaze/trunk/debug.inc |
|---|
| File deleted |
| \ No newline at end of file |
| /programs/games/megamaze/trunk/MACROS.INC |
|---|
| File deleted |
| /programs/games/megamaze/trunk/GIF_LITE.INC |
|---|
| File deleted |
| /programs/games/megamaze/trunk/gif_lite.inc |
|---|
| 0,0 → 1,318 |
| ; GIF LITE v2.0 by Willow |
| ; Written in pure assembler by Ivushkin Andrey aka Willow |
| ; |
| ; This include file will contain functions to handle GIF image format |
| ; |
| ; Created: August 15, 2004 |
| ; Last changed: September 9, 2004 |
| ; Change COLOR_ORDER in your program |
| ; if colors are displayed improperly |
| if ~ (COLOR_ORDER in <MENUETOS,OTHER>) |
| ; This message may not appear under MenuetOS, so watch... |
| display 'Please define COLOR_ORDER: MENUETOS or OTHER',13,10 |
| end if |
| struc GIF_info |
| { |
| ; .NextImg rd 1 ; used internally |
| .Left rw 1 |
| .Top rw 1 |
| .Width rw 1 |
| .Height rw 1 |
| } |
| _null fix 0x1000 |
| ; **************************************** |
| ; FUNCTION GetGIFinfo - retrieve Nth image info |
| ; **************************************** |
| ; in: |
| ; esi - pointer to image list header |
| ; ecx - image_index (0...img_count-1) |
| ; edi - pointer to GIF_info structure to be filled |
| ; out: |
| ; eax - pointer to RAW data, or 0, if error |
| GetGIFinfo: |
| push esi ecx edi |
| xor eax,eax |
| jecxz .eloop |
| .lp: |
| mov esi,[esi] |
| test esi,esi |
| jz .error |
| loop .lp |
| .eloop: |
| add esi,4 |
| movsd |
| movsd |
| mov eax,esi |
| .error: |
| pop edi ecx esi |
| ret |
| ; **************************************** |
| ; FUNCTION ReadGIF - unpacks GIF image |
| ; **************************************** |
| ; in: |
| ; esi - pointer to GIF file in memory |
| ; edi - pointer to output image list |
| ; eax - pointer to work area (MIN 16 KB!) |
| ; out: |
| ; eax - 0, all OK; |
| ; eax - 1, invalid signature; |
| ; eax >=8, unsupported image attributes |
| ; |
| ; ecx - number of images |
| 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] |
| add esi,4 |
| 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 .end |
| call .Gif_output |
| .add: |
| 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 .add |
| .er: |
| pop edi |
| jmp .ex |
| .end: |
| mov eax,[.cur_info] |
| 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 |
| 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 rd 1 |
| .img_count rd 1 |
| .cur_info rd 1 ; image table pointer |
| .img_start rd 1 |
| .codesize rd 1 |
| .compsize rd 1 |
| .bit_count rd 1 |
| .CC rd 1 |
| .EOI rd 1 |
| .Palette rd 1 |
| .block_ofs rd 1 |
| .table_ptr rd 1 |
| /programs/games/megamaze/trunk/macros.inc |
|---|
| 0,0 → 1,264 |
| ; new application structure |
| macro meos_app_start |
| { |
| use32 |
| org 0x0 |
| db 'MENUET01' |
| dd 0x01 |
| dd __start |
| dd __end |
| dd __memory |
| dd __stack |
| if used __params & ~defined __params |
| dd __params |
| else |
| dd 0x0 |
| end if |
| dd 0x0 |
| } |
| MEOS_APP_START fix meos_app_start |
| macro code |
| { |
| __start: |
| } |
| CODE fix code |
| macro data |
| { |
| __data: |
| } |
| DATA fix data |
| macro udata |
| { |
| if used __params & ~defined __params |
| __params: |
| db 0 |
| __end: |
| rb 255 |
| else |
| __end: |
| end if |
| __udata: |
| } |
| UDATA fix udata |
| macro meos_app_end |
| { |
| align 32 |
| rb 2048 |
| __stack: |
| __memory: |
| } |
| MEOS_APP_END fix meos_app_end |
| ; macro for defining multiline text data |
| struc mstr [sstring] |
| { |
| forward |
| local ssize |
| virtual at 0 |
| db sstring |
| ssize = $ |
| end virtual |
| dd ssize |
| db sstring |
| common |
| dd -1 |
| } |
| ; strings |
| macro sz name,[data] { ; from MFAR [mike.dld] |
| common |
| if used name |
| label name |
| end if |
| forward |
| if used name |
| db data |
| end if |
| common |
| if used name |
| .size = $-name |
| end if |
| } |
| macro lsz name,[lng,data] { ; from MFAR [mike.dld] |
| common |
| label name |
| forward |
| if lang eq lng |
| db data |
| end if |
| common |
| .size = $-name |
| } |
| ; easy system call macro |
| macro mpack dest, hsrc, lsrc |
| { |
| if (hsrc eqtype 0) & (lsrc eqtype 0) |
| mov dest, (hsrc) shl 16 + lsrc |
| else |
| if (hsrc eqtype 0) & (~lsrc eqtype 0) |
| mov dest, (hsrc) shl 16 |
| add dest, lsrc |
| else |
| mov dest, hsrc |
| shl dest, 16 |
| add dest, lsrc |
| end if |
| end if |
| } |
| macro __mov reg,a,b { ; mike.dld |
| if (~a eq)&(~b eq) |
| mpack reg,a,b |
| else if (~a eq)&(b eq) |
| mov reg,a |
| end if |
| } |
| macro mcall a,b,c,d,e,f { ; mike.dld |
| __mov eax,a |
| __mov ebx,b |
| __mov ecx,c |
| __mov edx,d |
| __mov esi,e |
| __mov edi,f |
| int 0x40 |
| } |
| ; language for programs |
| ;lang fix ru ; ru en fr ge fi |
| ; optimize the code for size |
| __regs fix <eax,ebx,ecx,edx,esi,edi,ebp,esp> |
| macro add arg1,arg2 |
| { |
| if (arg2 eqtype 0) |
| if (arg2) = 1 |
| inc arg1 |
| else |
| add arg1,arg2 |
| end if |
| else |
| add arg1,arg2 |
| end if |
| } |
| macro sub arg1,arg2 |
| { |
| if (arg2 eqtype 0) |
| if (arg2) = 1 |
| dec arg1 |
| else |
| sub arg1,arg2 |
| end if |
| else |
| sub arg1,arg2 |
| end if |
| } |
| macro mov arg1,arg2 |
| { |
| if (arg1 in __regs) & (arg2 eqtype 0) |
| if (arg2) = 0 |
| xor arg1,arg1 |
| else if (arg2) = 1 |
| xor arg1,arg1 |
| inc arg1 |
| else if (arg2) = -1 |
| or arg1,-1 |
| else if (arg2) > -128 & (arg2) < 128 |
| push arg2 |
| pop arg1 |
| else |
| mov arg1,arg2 |
| end if |
| else |
| mov arg1,arg2 |
| end if |
| } |
| macro struct name |
| { |
| virtual at 0 |
| name name |
| sizeof.#name = $ - name |
| end virtual |
| } |
| ; structures used in MeOS |
| struc process_information |
| { |
| .cpu_usage dd ? ; +0 |
| .window_stack_position dw ? ; +4 |
| .window_stack_value dw ? ; +6 |
| .not_used1 dw ? ; +8 |
| .process_name rb 12 ; +10 |
| .memory_start dd ? ; +22 |
| .used_memory dd ? ; +26 |
| .PID dd ? ; +30 |
| .x_start dd ? ; +34 |
| .y_start dd ? ; +38 |
| .x_size dd ? ; +42 |
| .y_size dd ? ; +46 |
| .slot_state dw ? ; +50 |
| rb (1024-52) |
| } |
| struct process_information |
| struc system_colors |
| { |
| .frame dd ? |
| .grab dd ? |
| .grab_button dd ? |
| .grab_button_text dd ? |
| .grab_text dd ? |
| .work dd ? |
| .work_button dd ? |
| .work_button_text dd ? |
| .work_text dd ? |
| .work_graph dd ? |
| } |
| struct system_colors |
| ; constants |
| ; events |
| EV_IDLE = 0 |
| EV_TIMER = 0 |
| EV_REDRAW = 1 |
| EV_KEY = 2 |
| EV_BUTTON = 3 |
| EV_EXIT = 4 |
| EV_BACKGROUND = 5 |
| EV_MOUSE = 6 |
| EV_IPC = 7 |
| EV_STACK = 8 |
| ; event mask bits for function 40 |
| EVM_REDRAW = 1b |
| EVM_KEY = 10b |
| EVM_BUTTON = 100b |
| EVM_EXIT = 1000b |
| EVM_BACKGROUND = 10000b |
| EVM_MOUSE = 100000b |
| EVM_IPC = 1000000b |
| EVM_STACK = 10000000b |
| /programs/games/megamaze/trunk/megamaze.asm |
|---|
| 25,9 → 25,9 |
| dd stack_end ; esp |
| dd 0x0 , 0x0 ; I_Param , I_Icon |
| lang fix ru |
| include "MACROS.INC" |
| include "macros.inc" |
| purge mov |
| ;include "DEBUG.INC" |
| ;include "../../../debug.inc" |
| COLOR_ORDER equ MENUETOS |
| include 'gif_lite.inc' |
| /programs/games/megamaze/trunk/tam.inc |
|---|
| 0,0 → 1,164 |
| TM_levelp: |
| call get_xy_sf |
| mov [levptr],esi |
| call unpack_level |
| ret |
| TM_key: |
| cmp eax,' ' |
| je .mm |
| cmp eax,176 |
| jb .still |
| cmp eax,179 |
| ja .still |
| lea ebx,[eax-176] |
| mov eax,[teseus] |
| call check_move |
| jc .still |
| call move_teseus |
| cmp [win_flag],0 |
| jne .ex |
| .nowin: |
| call drwfld |
| .mm: |
| call move_minotaur |
| cmp eax,[teseus] |
| jne .still |
| mov [win_flag],2 |
| jmp .ex |
| .still: |
| mov [jump],still |
| .ex: |
| ret |
| move_minotaur: |
| xor esi,esi |
| mov eax,[teseus] |
| mov ebx,[fx] |
| div bl |
| mov ecx,eax ;teseus: ch-x, cl-y |
| mov eax,[minotaur] |
| .again: |
| call mino_xy |
| xor ebx,ebx |
| cmp dh,ch |
| je .stand2 |
| ja .ok1 |
| add ebx,3 |
| .ok1: |
| call check_move |
| jc .stand2 |
| add eax,[dirs+ebx*4] |
| mov [minotaur],eax |
| inc esi |
| call delay |
| call drwfld |
| cmp esi,2 |
| jb .again |
| jmp .ex |
| .stand1: |
| call mino_xy |
| .stand2: |
| mov ebx,2 |
| cmp dl,cl |
| je .ex |
| ja .ok2 |
| dec ebx |
| .ok2: |
| call check_move |
| jc .ex |
| add eax,[dirs+ebx*4] |
| mov [minotaur],eax |
| inc esi |
| call delay |
| call drwfld |
| cmp esi,2 |
| jb .again |
| .ex: |
| ret |
| mino_xy: |
| push eax |
| div byte[fx] |
| mov edx,eax ;minotaur: dh-x, dl-y |
| pop eax |
| ret |
| move_teseus: |
| pusha |
| cdq |
| mov ecx,[fx] |
| div cl |
| add ax,1 shl 8+1 |
| test ebx,ebx |
| jne .no0 |
| cmp ah,1 |
| jne .move |
| .win: |
| inc [win_flag] |
| jmp .ex |
| .no0: |
| cmp ebx,1 |
| jne .no1 |
| cmp al,byte[fy] |
| je .win |
| jmp .move |
| .no1: |
| cmp ebx,2 |
| jne .no2 |
| cmp al,1 |
| je .win |
| jmp .move |
| .no2: |
| cmp ebx,3 |
| jne .move |
| cmp ah,byte[fx] |
| je .win |
| .move: |
| mov eax,[esp+28] |
| add eax,[dirs+ebx*4] |
| mov [teseus],eax |
| .ex: |
| popa |
| ret |
| TM_drawm: |
| mov eax,[teseus] |
| call get_xy |
| mcall 13,[lx],[ly],0xff00 |
| mov eax,[minotaur] |
| call get_xy |
| mcall 13,[lx],[ly],0xff0000 |
| ret |
| TM_level: |
| file 'tam.bin' |
| if lang eq ru |
| TM_help mstr \ |
| ' ¥á¥© (§¥«¥ë© ª¢ ¤à â) ¤®«¦¥ ã¡¥¦ âì ¨§',\ |
| '« ¡¨à¨â . ¨¬ £®¨âáï ¬¥å ¨ç¥áª¨© ¨®â ¢à',\ |
| '(ªà áë© ª¢ ¤à â). ª ¦¤ë© 室 ¥á¥© ¨®â ¢à',\ |
| '¤¥« ¥â 2 室 ¯® â ª®© á奬¥:',\ |
| ' ç « ® ¯ëâ ¥âáï ¯à¨¡«¨§¨âìáï ª ¥á¥î ¯®',\ |
| '£®à¨§®â «¨ 1 ª¢ ¤à â. ᫨ íâ® ¥¢®§¬®¦®,',\ |
| '® ¯ëâ ¥âáï ¯®¤®©â¨ ¯® ¢¥à⨪ «¨ 1 ª¢ ¤à â.',\ |
| ' ᫨ ¥¢®§¬®¦® ᤥ« âì ¨ ⮣®, ¨ ¤à㣮£®,',\ |
| '¨®â ¢à ¯à®¯ã᪠¥â ¤ ë© å®¤.','',\ |
| 'http://puzzleprograms.narod.ru' |
| else |
| TM_help mstr \ |
| ' Theseus (the green dot) must escape from a maze.',\ |
| 'There is also a mechanical Minotaur (the red',\ |
| 'dot) in each maze. For every turn that Theseus',\ |
| 'takes, the Minotaur takes two turns.',\ |
| ' Each turn he decides following:',\ |
| 'First he tests if he can move horizontally and',\ |
| 'get closer to Theseus. If he can, he will move',\ |
| "one square horizontally. If he can't, he will",\ |
| 'test if he could move vertically and get closer',\ |
| 'to Theseus. If he can, he will move one square',\ |
| "vertically. If he can't move either horizontally",\ |
| 'or vertically, then he just skips that turn.','',\ |
| 'http://puzzleprograms.narod.ru' |
| end if |