Subversion Repositories Kolibri OS

IDA equ 1 ; We're running debugida.exe

STRIP  equ 40

LEVNUM equ 500

 XFOFS equ 10

 YFOFS equ 55

 MSGXO equ 32

GAMES_ALL equ 12

WNDCOLOR equ 0x03c0c0c0;0x03f6f6f6;

MINCS equ 40

MAXCS equ 80

macro icall lbl

{

	call [lbl+ebp*4]

}

  use32

  org	  0x0

  db	 'MENUET01'		 ; 8 byte id

  dd	 0x01			 ; header version

  dd	 run			 ; start of code

  dd	 I_END			 ; size of image

  dd	 end_mem		 ; memory for app

  dd	 stack_end		  ; esp

  dd	 0x0 , 0x0		 ; I_Param , I_Icon

lang fix ru

include "MACROS.INC"

purge mov

;include "DEBUG.INC"

COLOR_ORDER equ MENUETOS

include 'gif_lite.inc'

include 'tam.inc'

include 'smz.inc'

include 'tilt.inc'

include 'tilt2.inc'

include 'fhouse.inc'

include 'loops.inc'

include 'wriggle.inc'

include 'blackbox.inc'

include 'marble.inc'

include 'cstep.inc'

include 'orient.inc'

include 'nolt.inc'

include 'colzone.inc'

run:

		mov  [Ces],STRIP;20

    mcall 3

    mov  cl,16

    ror  eax,cl

    mov  [generator],eax    ; random generator from Tetris

		and [mpress_flag],0

		and [gif_unp],0

    xor  ebp,ebp ; game_t

;    mov  ebp,10

    mcall 64,1,end_mem

    mov  [pause_time],40

    call resize

  .game1:

    mov  [levnum],LEVNUM

  .game:

    and  [win_flag],0

    and  [drag_flag],0

    mov  ecx,[levnum]

    mov  esi,[levels+ebp*4]

    jecxz .skip

  .nxt:

    movzx eax,byte[esi]

    add  esi,eax

    xor  eax,eax

    cmp  al,byte[esi]

    jne  .noz

    mov  esi,LEVNUM;500

    sub  esi,ecx

    mov  [levcount],esi

    and  [levnum],0

    jmp  .game

  .noz:

    loop .nxt

  .skip:

		mcall 40,111b

	  mov  [mouse_processed],1

    xor  eax,eax

    icall prepare_level

wnd_size:

  	mov  eax,[Ces]

	  shr  eax,2

	  sub  eax,2

    mov  [sq_size],eax

  if ~ IDA eq 1

    mov   edx,[fx]

    imul  edx,[Ces]

    add   edx,XFOFS*2+20

    mov   esi,[fy]

    imul  esi,[Ces]

    add   esi,YFOFS+30

    mov   ecx,-1

    mcall 67,ecx

  end if

red:

    call  draw_window

drw:

		call  drwfld

still:

    mcall 2

    test al,al

    jz	 still

    mcall 10

    cmp  eax,2

    je	 key

    cmp  eax,1			; redraw request ?

    je	 red

    cmp  eax,3			; button in buffer ?

    je	 button

    cmp  eax,6			; mouse event ?

    je	 mouse

key:

    mcall 2

;    movzx ebx,ah

;    dpd  ebx

		cmp  ebp,10

		je   .noplus

    mov  ebx,5

    cmp  ah,184

    jne  .nomin

    cmp  [Ces],MINCS

    je	 still

  .ces:

    sub  [Ces],ebx

    call resize

    jmp  wnd_size

  .nomin:

    cmp  ah,183

    jne  .noplus

    cmp  [Ces],MAXCS

    je	 still

    neg  ebx

    jmp  .ces

	.noplus:

    cmp  ah,'h'

    jne  .nohlp

;  if IDA eq 1

;    cmp  [child],0

;    jne  still

;  else

    call kill_help

;  end if

    mov  [pack],ebp

    mcall 51,1,show_help,chs_end

;    dpd  eax

    mov  [child],eax

    jmp  still

  .nohlp:

    cmp  [win_flag],10

    je	 .levover

    cmp  [win_flag],2

    je	 .no_win

    cmp  [win_flag],1

    jne  .now

  .levover:

    call lev_next

  .no_win:

    and  [win_flag],al

    jmp  run.game

  .now:

    shr  eax,8

    mov  [jump],drw;red

    cmp  eax,13

    je	 run.game

    icall key_handler

    jmp  [jump]

button:

    mcall 17

    cmp  ah,1

    je	 close

    cmp  ah,2

    je	 .game_type

    cmp  ah,4

    je	 .inclev

    cmp  ah,3

    je	 .declev

    jmp  still

  .declev:

    dec  [levnum]

    cmp  [levnum],0

    jge  run.game

    push [levcount]

    pop  [levnum]

    jmp  run.game

  .inclev:

    call lev_next

    jmp  run.game

  .game_type:

    inc  ebp

    cmp  ebp,GAMES_ALL

    jbe  run.game1

    xor  ebp,ebp

    jmp  run.game1

  close:

  if ~ IDA eq 1

    call kill_help

  end if

    mcall -1

;if ~ IDA eq 1

kill_help:

		mcall 9,prc_info2,-1

		mov  edx,[child]

		mov  ecx,eax

	.lp:

		mcall 9

		cmp  edx,[ebx+30]

		jne   .nochild

		mcall 18,2

    and  [child],0

		ret

	.nochild:

		loop .lp

		ret

;end if

mouse:

		cmp  [mouse_processed],1

		jne  .ex

		mcall 37,1

		sub  eax,XFOFS shl 16+YFOFS

		xor  edx,edx

		mov  ebx,[Ces]

		mov  ecx,eax

		and  eax,0xffff

		div  ebx

		xor  edx,edx

		mov  [mouse_y],eax

		cmp  eax,[fy]

		jae  .ex

		mov  eax,ecx

		shr  eax,16

		div  ebx

		mov  [mouse_x],eax

		cmp  eax,[fx]

		jae  .ex

		mcall 37,2 ; get buttons

		cmp  [drag_flag],0

		je   .nodrag

		mov  ebx,eax

		cmp  eax,[mpress_flag]

		mov  eax,-1

		je   .nochg

		dec  eax

	.nochg:

		mov  [mpress_flag],ebx

		jmp  .call_hnd

	.nodrag:

		test eax,eax

		jz  .ex1

		cmp  eax,[mpress_flag]

		je   .ex

		mov  [mpress_flag],eax

		mov  eax,-1

	.call_hnd:

		mov  [mouse_processed],0

		icall key_handler

		jmp  [jump]

	.ex1:

		mov  [mpress_flag],0

	.ex:

		jmp  still

lev_next:

    push eax

    inc  [levnum]

    mov  eax,[levnum]

    cmp  eax,[levcount]

    jbe  .ex

    and  [levnum],0

  .ex:

    pop  eax

    ret

;   *********************************************

;   *******  WINDOW DEFINITIONS AND DRAW ********

;   *********************************************

draw_window:

    pusha

    mcall 12,1

    mov   ebx,[fx]

    imul  ebx,[Ces]

    push  ebx

    add   ebx,50 shl 16+XFOFS*2+20

    mov   ecx,[fy]

    imul  ecx,[Ces]

    add   ecx,10 shl 16+YFOFS+30

    mcall 0,,,WNDCOLOR

    mov   esi,edx

    and   esi,0xffffff

    mcall 9,prc_info,-1

    mov   ebx,[esp]

    pop   ebx

    add   ebx,XFOFS shl 16+XFOFS*2

    mcall 8,,<25,12>,2

    mcall 8,,<40,12>,3

    add   ebx,14 shl 16

    inc   edx

    mcall

    mcall 4,<8,8>,0x10ffffff,header,header.size

    mov   ecx,ebp

    mov   edx,game_names+4

    call  get_mstr

    mcall ,,0x8000

    imul  esi,6

    add   esi,3

    shl   esi,16

    lea   edx,[ebx+esi]

    mcall 47,0x020001,levnum,,0x8000

    mcall 4,,0x108000,next_msg,3

    mcall 12,2

    popa

    ret

unpack_level:

    mov   ecx,[cell_count]

    mov   edi,field

  .lp:

    movzx eax,byte[esi]

    inc   esi

    shl   ax,4

    shr   al,4

    stosw

    loop  .lp

    ret

get_xy:

; eax-coord

; out: [lx]-[x+2][CS-4],[ly]-[y+2][CS-4]

    pusha

    xor   edx,edx

    mov   esi,[sq_size]

    lea   edi,[esi*2]

    neg   edi

    add   edi,[Ces]

    mov   [lx],edi

    mov   [ly],edi

    mov   ebx,[fx]

    div   bx

    imul  eax,[Ces]

    imul  edx,[Ces]

    lea   edx,[edx+XFOFS+esi]

    lea   eax,[eax+YFOFS+esi]

    mov   word[ly+2],ax

    mov   word[lx+2],dx

    popa

    ret

check_move:

; eax-coord, ebx-direction

; CF=0 if move is valid

    bt	 dword[field+eax],ebx

    ret

delay:

    pusha

    mcall 5,[pause_time]

    popa

    ret

get_mstr:

; in:  edx,ecx

; out: edx,esi

    mov   esi,[edx-4]

    jecxz .ex

    lea   edx,[edx+esi+4]

    dec   ecx

    jmp   get_mstr

  .ex:

    ret

maze_field:

    mov   edi,field

    mov   [ly],YFOFS shl 16+YFOFS

    mov   eax,38

    mov   ecx,[fy]

  .lp1:

    push  ecx

    mov   [lx],XFOFS shl 16+XFOFS

    mov   ecx,[fx]

  .lp2:

    push  ecx

    xor   esi,esi

  .lp3:

    mov   edx,0xd0d0d0

    bt	  dword[edi],esi

    jnc   .gray

    mov   edx,0

  .gray:

    mov   ebx,[lx]

    add   ebx,[dir_ofs+esi*4]

    mov   ecx,[ly]

    add   ecx,[dir_ofs+esi*4+8]

    mcall

    inc   esi

    cmp   esi,4

    jb	  .lp3

    inc   edi

    mov   ecx,[Ces]

    add   word[lx],cx

    add   word[lx+2],cx

    pop   ecx

    loop  .lp2

    mov   ecx,[Ces]

    add   word[ly],cx

    add   word[ly+2],cx

    pop   ecx

    loop  .lp1

    ret

grid_field:

    mov   edx,0xa0a0a0

    mov   eax,38

    mov   ecx,[fy]

    mov   ebx,[fx]

    imul  ebx,[Ces]

    add   ebx,XFOFS shl 16+XFOFS

    mov   esi,YFOFS shl 16+YFOFS

    inc   ecx

  .lp1:

    push  ecx

    mov   ecx,esi

    mcall

    mov   ecx,[Ces]

    add   esi,ecx

    shl   ecx,16

    add   esi,ecx

    pop   ecx

    loop  .lp1

    mov   ecx,[fx]

    mov   esi,[fy]

    imul  esi,[Ces]

    add   esi,YFOFS shl 16+YFOFS

    mov   ebx,XFOFS shl 16+XFOFS

    inc   ecx

  .lp2:

    push  ecx

    mov   ecx,esi

    mcall

    mov   ecx,[Ces]

    add   ebx,ecx

    shl   ecx,16

    add   ebx,ecx

    pop   ecx

    loop  .lp2

    ret

get_xy_sf:

		xor  eax,eax

		and  [player],eax

    mov  [fx],eax

    mov  [fy],eax

    lodsb

    lodsb

    mov  ah,al

    shr  ah,4

    and  al,0xf

    mov  byte[fx],ah

    mov  byte[fy],al

    lodsb

    mov  byte[player],al

    lodsb

    mov  byte[finish],al

  .count:

    mov  eax,[fx]

    mov  [dirs+4],eax

    neg  eax

    mov  [dirs+8],eax

    mov  eax,[fx]

    imul eax,[fy]

    mov  [cell_count],eax

    ret

get_last_mclick:

; out - eax=0 no click or outside field

;                               eax>0 button pressed, ebx=[xy]

		mov  [mouse_processed],1

		mov  eax,[mpress_flag]

		mov  ebx,[mouse_y]

		imul ebx,[fx]

		add  ebx,[mouse_x]

		ret

erase_field:

		pusha

		mov  ecx,[cell_count]

		xor  eax,eax

		mov  edi,field

		rep  stosb

		popa

		ret

get_pxy:

; in: [pack] - cell#, out: word[pack] - packed  [xy]

		pusha

		mov  eax,[pack]

		cdq

		mov  ebx,[fx]

		div  ebx

		shl edx,8

		add  eax,edx

		mov  [pack],eax

		popa

		ret

check_bounds:

; in: eax - cell, ebx - dir

; out: ebx=-1 if bounds crossed

		push eax ecx

		mov  ecx,eax

		add  ecx,[dirs+ebx*4]

		mov  ebx,ecx

		call get_offset

		mov  ebx,eax

		pop  ecx eax

    cmp  ebx,-1

		ret

get_offset:

; in: eax - start, ebx-end

; out: eax - dir or -1 if not straight

;      ebx - distance

		push ecx edx

		mov  ecx,-1

		mov  edx,[cell_count]

		cmp  eax,edx

		jae  .ex

		cmp  ebx,edx

		jae  .ex

		mov  [pack],eax

		call get_pxy

		mov  eax,[pack]

		mov  [pack],ebx

		call get_pxy

		mov  ebx,[pack]

		cmp  ah,bh ; compare X

		jne  .noX

		mov  ecx,1

		sub  bl,al

		ja   .ok

		inc  ecx

	.ok2:

		neg  bl

		jmp  .ok

	.noX:

		cmp  al,bl ; compare Y

		jne  .ex

		inc  ecx

		sub  bh,ah

		mov  bl,bh

		jb   .ok2

		add  ecx,3

	.ok:

		movzx ebx,bl

	.ex:

		mov  eax,ecx

		pop edx ecx

		ret

show_help:

		mov   ebp,[pack]

	.red:

    mcall 12,1

    mov   ebx,[prc_info.x_start]

    add   ebx,[prc_info.x_size]

    shl   ebx,16

    add   ebx,310

    mov   ecx,[prc_info.y_start]

    shl   ecx,16

    add   ecx,220

    mcall 0,,,0x03c0c0c0

    mcall 4,<8,8>,0x00ffffff,help_hdr,help_hdr.size

    mov   ecx,ebp

    mov   edx,game_names+4

    call  get_mstr

    sub   esi,2

    mcall 4,<6*help_hdr.size+15,8>,0x00ffffff

    mov   edx,[help_msg+ebp*4]

    add   edx,4

    xor   ecx,ecx

    mov   ebx,10 shl 16+30

  .nxt:

    mov   esi,[edx-4]

    jecxz .drw

    dec   ecx

    lea   edx,[edx+esi+4]

    jmp   .nxt

  .drw:

    cmp   esi,-1

    je	  .edraw

    mcall ,,0x000000ff

    mov   ecx,1

    add   ebx,12

    jmp    .nxt

  .edraw:

    mcall 12,2

	.still:

    mcall 10

    cmp  eax,2

    jne  .nokey

    mcall

    jmp  .close

  .nokey:

    cmp  eax,1			; redraw request ?

    je	 .red

    cmp  eax,3			; button in buffer ?

    jne  .still

    mcall 17

    cmp  ah,1

    jne  .still

  .close:

    and  [child],0

    mcall -1

getline:

; in: esi,edi

		pusha

    mov  eax,esi

    call get_xy

    mov  ebx,[lx]

    mov  ecx,[ly]

    mov  eax,edi

    call get_xy

    mov  bx,word[lx+2]

    mov  cx,word[ly+2]

    mov  eax,[Ces]

    shr  eax,1

    sub  eax,[sq_size]

    add  ebx,eax

    add  ecx,eax

    shl  eax,16

    add  ebx,eax

    add  ecx,eax

    mov  [lx],ebx

    mov  [ly],ecx

		mcall 38

		popa

		ret

bold_line:

  WGSPC equ 1

    pusha

		mov  edi,WGSPC shl 16+WGSPC

    add  [lx],edi

    add  [ly],edi

		mcall 38,[lx],[ly]

		shl  edi,1

    sub  ebx,edi

    sub  ecx,edi

		mcall

		popa

		ret

get_rnd:

		mov  eax, [generator]

    sub  eax,0x43ab45b5    ; next random number

    ror  eax,1

    xor  eax,0x32c4324f

    ror  eax,1

    mov  [generator],eax

    ret

drwfld:

		pusha

    mov   ebx,[fx]

    imul  ebx,[Ces]

    add   ebx,XFOFS shl 16

    mov   ecx,[fy]

    imul  ecx,[Ces]

    add   ecx,YFOFS shl 16

    mcall 13,,,WNDCOLOR

    add   ebx,26 shl 16-26

    sub   ecx,16 shl 16

    mov   cx,16

    mcall

    icall draw_field

    icall draw_more

    cmp   [win_flag],0

    jz	  .edraw

    movzx ecx,[win_flag]

    mov   edx,msgs+4

    call  get_mstr

    mcall 4,,0x100000ff

  .edraw:

    popa

    ret

resize:

    mov  eax,[Ces]

    mov  edi,dir_ofs+4

    stosd

    stosd

    stosw

    stosw

    mov  [edi+4],eax

		ret

need_image:

; in: eax - gif pointer

		cmp  [gif_unp],0

		jne  .skip

		push esi edi

		mov  esi,eax

		mov  eax,field

		mov  edi,raw_area

		call ReadGIF

		mov  [gif_unp],1

		pop  edi esi

	.skip:

		ret

out_image:

; in: eax - coord, ebx - image #

STRIP2 = STRIP-2

	pusha

  call get_xy

  mov  edx,[lx]

  mov  dx,word[ly+2]

  add  edx,1 shl 16+1

  imul ebx,STRIP2*STRIP2*3

	add  ebx,raw_area+12

  mcall 7,,STRIP2 shl 16+STRIP2

  popa

	ret

OR_strip:

;file 'orient2.gif'

file 'orientg2.gif'

	rd 2

	gif_unp dd 0

; DATA AREA

help_hdr db 'MegaMaze Help -'

	.size=$-help_hdr

dirs dd -1,0,0,1

dir_ofs dd 0, 1, 1, 1 shl 16+1, 0, 1

dir_rotate db 2,0,3,1,1,3,0,2

w_colors dd 0x0404CA,0xCC0404,0x00CC00

f_colors dd 0x9494FC,0xFC9494,0x99FF99,0xFFFF00

levnum	 dd LEVNUM

prepare_level dd TM_levelp,SMZ_levelp,TILT_levelp,TILT2_levelp,FH_levelp,\

	 LP_levelp,WG_levelp,BB_levelp,MAR_levelp,TM_levelp,OR_levelp,NLT_levelp,\

	 CZ_levelp

key_handler   dd TM_key,SMZ_key,TILT_key,TILT2_key,FH_key,LP_key,WG_key,BB_key,\

	 MAR_key,CSTEP_key,OR_key,NLT_key,CZ_key

draw_more     dd TM_drawm,SMZ_drawm,TILT_drawm,TILT2_drawm,FH_drawm,LP_drawm,\

	 WG_drawm,BB_drawm,MAR_drawm,CSTEP_drawm,OR_drawm,NLT_drawm,CZ_drawm

draw_field    dd maze_field,maze_field,maze_field,maze_field,grid_field,\

	 grid_field,grid_field,grid_field,maze_field,maze_field,OR_drawf,maze_field,\

	 grid_field

levels	      dd TM_level,SMZ_level,TILT_level,TILT2_level,FH_level,LP_level,\

	 WG_level,BB_level,MAR_level,CSTEP_level,OR_level,NLT_level,CZ_level

help_msg      dd TM_help,SMZ_help,TILT_help,TILT2_help,FH_help,LP_help,WG_help,\

	 BB_help,MAR_help,CSTEP_help,OR_help,NLT_help,CZ_help

if lang eq ru

  header db 'Mega Maze'

else

  header db 'Mega Maze'

end if

   .size = $ - header

next_msg db '< >'

game_names mstr \

	'Teseus & Minotaur #',\

	'1-2-3 Maze #',\

	'Tilt Maze #',\

	'Double Tilt #',\

	'Full-house #',\

	'Loops #',\

	'Wriggle #',\

	'BlackBox #',\

	'Marble #',\

	'Counter Step #',\

	'Orientation #',\

	'No left turn #',\

	'Colour-zone #'

msgs mstr ' ','You win!!!','Game over.','Start cell?','Dead end!',\

	"  atoms hidden.",'Ray emerged.','Ray absorbed.','Ray reflected.',\

	'Mark exactly    guesses','Your score is','Guess mark toggled'

I_END:

main_pid dd ?

child_stack rb 256

	chs_end:

drag_flag db ?

sq_size dd ?

mouse_processed dd ?

mpress_flag dd ?

mouse_x dd ?

mouse_y dd ?

Ces dd ?

pack dd ?

fy dd ?

fx dd ?

lx dd ?

ly dd ?

generator dd ?

cell_count dd ?

levptr	 dd ?

levcount dd ?

score	 dd ?

player:

teseus	 dd ?

finish:

minotaur dd ?

stepptr  dd ?

cur_step dd ?

win_flag db ?

jump	 dd ?

pause_time dd ?

child	 dd ?

area rb 1024

stak rb 1024

stack_end:

prc_info process_information

prc_info2 process_information

field:

    rb 128*128

raw_area:

		rb STRIP*STRIP*12*3+16

end_mem: