WebSVN – Kolibri OS – Diff – /programs/media/log_el/trunk/le_pole.inc


;
; äã­ªæ¨ ¤«ï á®§¤ ­¨ï ¨ à¥¤ ªâ¨à®¢ ­¨ï ¯à®¢®¤®¢
;
 
;--------------------------------------
struct Cell
	x dd ? ;+0
	y dd ? ;+4
	liv db ? ;+8
	napr db ? ;+9
ends
 
offs_cell_x equ 0
offs_cell_y equ 4
offs_cell_liv equ 8
offs_cell_napr equ 9
 
;áâàãªâãà  ¤«ï á®§¤ ­¨ï ¯®«ï
align 4
pole:
.index dd 0
cell dd 0 ;ãª § â¥«ì ­  ¯ ¬ïâì á® áâàãªâãà ¬¨ ïç¥¥ª
.max_cell dd 90000
.b_sort dd 0 ;£à ­¨æ  ¤«ï á®àâ¨à®¢ ­­ëå ïç¥¥ª
 
pole_index    equ dword[edi]
pole_data     equ dword[edi +4] ;ãª § â¥«ì ­  ¯ ¬ïâì á® áâàãªâãà ¬¨ ïç¥¥ª
pole_max_cell equ dword[edi +8]
pole_b_sort   equ dword[edi+12] ;£à ­¨æ  ¤«ï á®àâ¨à®¢ ­­ëå ïç¥¥ª
offs_pole_b_sort equ 12
 
macro get_cell_offset reg,ind
{
	mov reg,ind
	imul reg,sizeof.Cell
	add reg,dword[cell]
}
 
er_oom db 0 ;­  á«ãç © ¨áç¥à¯ ­¨ï ¯ ¬ïâ¨
Cor_x dd 0
Cor_y dd 0
zoom db 3 ;¬ áèâ ¡ ¯®«ï
txt_zoom db ' áèâ ¡:',0
txt_osob db '®ç¥ª:',0
txt_info: db ' §¬¥à: '
.size: rb 16
txt_mull db '*',0
txt_space db ' ',0
txt_nl db 13,10,0
txt_buf rb 32
 
 
align 4
proc pole_init uses eax ebx edi, pole:dword
	mov edi,dword[pole]
 
	;*** ª®¤ á ®¤­®© ®¡« áâìî ¢ ¯ ¬ïâ¨ ***
	mov ebx,4
	add ebx,sizeof.Cell
	imul ebx,pole_max_cell
	stdcall mem.Alloc,ebx
	mov pole_index,eax
 
	mov ebx,pole_max_cell
	shl ebx,2
	add eax,ebx
	mov pole_data,eax
 
	stdcall pole_clear, edi
	stdcall pole_paint, edi ;à¨á®¢ ­¨¥ ¯®«ï ¢ ¡ãä¥à¥ (­¥ ­  íªà ­¥)
	ret
endp
 
align 4
proc pole_delete uses edi, pole:dword
	mov edi,dword[pole]
	stdcall mem.Free,pole_index
	ret
endp
 
;ç¨áâª  ¯à®¢®¤®¢ ­  áå¥¬¥
align 4
proc pole_clear uses eax ecx edi, pole:dword
	mov edi,dword[pole]
 
	xor eax,eax
	mov pole_b_sort,eax
	mov byte[er_oom],al
	cld
	mov ecx,pole_max_cell
	imul ecx,sizeof.Cell
	mov edi,pole_data
	repne stosb ;memset(cell,0,sizeof(Cell)*pole_max_cell);
 
	mov edi,dword[pole]
	mov ecx,pole_max_cell
	mov edi,pole_index
	@@:
		stosd ;for(i=0;i
 
 
		inc eax
		loop @b
	ret
endp
 
align 4
proc pole_cell_creat, pole:dword, x:dword, y:dword, li:dword
	pushad
	mov edi,dword[pole]
	mov esi,pole_index
 
	; *** ¥á«¨ ª«¥âª  ã¦¥ ¡ë«  á®§¤ ­ 
	stdcall pole_cell_find, [pole], [x],[y]
	cmp eax,0
	je @f
		get_cell_offset ebx,eax
		jmp .change
	@@:
 
	; *** á®§¤ ­¨¥ ­®¢®© ïç¥©ª¨
	; ­ å®¤¨¬ ­®¬¥à á¢®¡®¤­®© ïç¥©ª¨ (i) ¤«ï ¤®¡ ¢«¥­¨ï ­®¢®©
	;mov esi,pole_index
	inc dword[esi]
	mov ebx,pole_max_cell
	cmp dword[esi],ebx
	jne @f
		dec dword[esi]
		;... need call message: "eror out of memory" ...
		;... ¢ë¢®¤ á®®¡é¥­¨ï ¯¥à¥¯®«­¥­¨ï ­ ¤® ¤®¡ ¢¨âì  ...
		mov byte[er_oom],0
		jmp .fun_e ;return;
	@@:
	mov eax,dword[esi] ;eax - ­®¬¥à ¤«ï ¯®á«¥¤­¥© ïç¥©ª¨
	shl eax,2
	add eax,pole_index ;eax - ãª § â¥«ì ­  ¤®¡ ¢«ï¥¬ãî ïç¥©ªã (¢ ª®­¥æ ¬ áá¨¢ )
	get_cell_offset ebx,dword[eax]
	mov ecx,dword[x]
	mov dword[ebx],ecx ;+0 = .x
	mov edx,dword[y]
	mov dword[ebx+4],edx ;+4 = .y
	.change:
		mov ecx,[li]
		mov byte[ebx+offs_cell_liv],cl
	.fun_e:
	popad
	ret
endp
 
;ã¤ «¥­¨¥ ïç¥©ª¨
align 4
proc pole_cell_delete, pole:dword, x:dword, y:dword
	pushad
	mov edi,dword[pole]
	mov ebx,edi
	add ebx,offs_pole_b_sort
	mov esi,pole_index
 
	mov ecx,[esi]
	cmp ecx,1
	jl .fun_e
 
	stdcall pole_cell_find, [pole], [x],[y]
	cmp eax,0
	je .fun_e ;¥á«¨ ª«¥âª  ­¥ ¡ë«  á®§¤ ­ 
 
	dec dword[esi]
 
	mov edi,esi
	add edi,4
	mov edx,ecx
	cld
	repnz scasd ;¯®¨áª
	sub edi,4
 
	cmp dword[ebx],1 ;[ebx]=pole_b_sort
	jl @f
	mov eax,edi
	sub eax,esi ;esi=pole_index
	shr eax,2
	dec eax
	cmp [ebx],eax ;eax - ¯®§¨æ¨ï ãª § â¥«ï ã¤ «ï¥¬®© ïç¥©ª¨
	jle @f ;¡ë«® jl @f
		dec dword[ebx]
	@@:
 
	shl edx,2
	add edx,esi ;ª®­¥ç­ë© í«¥¬¥­â ¬ áá¨¢ 
	sub edx,edi
	shr edx,2
	mov ecx,edx
 
	bt ecx,31
	jc .fun_e
		mov esi,edi
		add esi,4
		mov edx,[edi] ;á®åà ­¥­¨¥ â¥ªãé¥£® ãª § â¥«ï
		cld
		rep movsd
		mov [edi],edx ;¢®ááâ ­®¢«¥­¨¥ â¥ªãé¥£® ãª § â¥«ï (¢ ª®­æ¥ ¬ áá¨¢ )
	.fun_e:
	popad
	ret
endp
 
if debug
align 4
proc but_test_pole, pole:dword
	pushad
	stdcall [buf2d_clear], buf_0, [buf_0.color]
 
	mov edi,dword[pole]
	stdcall pole_paint,edi
	mov ebx,5
 
	mov esi,pole_index
	mov ecx,[esi]
 
	mov eax,pole_b_sort
	mov edi,open_file_lif
	stdcall convert_int_to_str
	stdcall [buf2d_draw_text], buf_0, buf_font,edi,5,ebx,[shem_colors] ;à¨áã¥¬ b_sort
	add ebx,18
 
	mov eax,[esi]
	add esi,4
	stdcall convert_int_to_str
	stdcall [buf2d_draw_text], buf_0, buf_font,edi,5,ebx,[shem_colors] ;à¨áã¥¬ ç¨á«® â®ç¥ª
	add ebx,9
 
	cmp ecx,1
	jl .end_dr
	cld
	@@:
		mov eax,[esi]
		add esi,4
		stdcall convert_int_to_str
		stdcall [buf2d_draw_text], buf_0, buf_font,edi,5,ebx,[color_captions] ;à¨áã¥¬ ãª § â¥«¨ ­  ¬ áá¨¢ë â®ç¥ª
		add ebx,9
		loop @b
	.end_dr:
	mov ecx,4
	cld
	@@:
		mov eax,[esi]
		add esi,4
		stdcall convert_int_to_str
		stdcall [buf2d_draw_text], buf_0, buf_font,edi,5,ebx,[color_border] ;à¨áã¥¬ 4 áâà®ª¨ ãª § â¥«¥©
		add ebx,9
		loop @b
 
	stdcall [buf2d_draw], buf_0
 
	;call redraw_pole
	popad
	ret
endp
end if
 
;output:
; eax - index
align 4
proc pole_cell_find uses edi, pole:dword, x:dword, y:dword
	mov edi,dword[pole]
 
	mov eax,pole_index
	cmp dword[eax],0
	jne @f
		xor eax,eax ;if(!fristC) return 0;
		jmp .fun_e
	@@:
 
	xor eax,eax ;fnd=0;
	cmp pole_b_sort,0
	je @f
		stdcall pole_bin_find, pole_index, [x],[y], pole_b_sort ;i=BinFind(pole_index, x,y, pole_b_sort);
		cmp eax,0
		je @f
			shl eax,2
			add eax,pole_index
			mov eax,dword[eax] ;if(i) fnd=pole_index[i];
			jmp .fun_e
	@@:
 
	cmp eax,0
	jne @f ;¯®¨áª ïç¥©ª¨ §  ¡¨­ à­ë¬ ¤¥à¥¢®¬
		push ebx ecx edx esi
		;ebx -> i
		;ecx -> firstC
		;edx -> &pole_index[i]
		;esi -> cell[pole_index[i]]
		mov ecx,pole_index
		mov ebx,pole_b_sort
		mov edx,ebx
		shl edx,2
		add edx,ecx
		mov ecx,dword[ecx]
		.cycle_b: ;for(i=pole_b_sort+1;i<=fristC;i++)
			inc ebx
			cmp ebx,ecx
			jg .not_found
			add edx,4
			get_cell_offset esi,dword[edx]
			mov eax,dword[x]
			cmp dword[esi],eax ;+0 = .x
			jne .if_e
			mov eax,dword[y]
			cmp dword[esi+4],eax ;+4 = .y
			jne .if_e
				;if(cell[pole_index[i]].x==x && cell[pole_index[i]].y==y){
				mov eax,dword[edx] ;fnd=pole_index[i];
				jmp .cycle_e ;break;
			.if_e:
			jmp .cycle_b
			.not_found:
		xor eax,eax ;¢®ááâ ­ ¢«¨¢ ¥¬ ­ã«¥¢®¥ §­ ç¥­¨¥ ¥á«¨ ­¥ ­ è«¨ ïç¥©ªã (¢ æ¨ª«¥ eax ¯®àâ¨âáï ¯à¨ ¯à®¢¥àª¥ ª®®à¤¨­ â)
		.cycle_e:
		pop esi edx ecx ebx
	@@:
	.fun_e:
	ret
endp
 
;output:
; eax - index
align 4
proc pole_bin_find uses ebx ecx edx edi, mas:dword, fx:dword, fy:dword, k:dword
	xor eax,eax
	mov ebx,1 ;ebx - ¬ ªá¨¬ «ì­ë© ¯®àï¤®ª ¤«ï ¤¥à¥¢ 
	@@:
	cmp dword[k],ebx
	jle @f ;while(k>por)
		shl ebx,1 ;por<<=1;
		jmp @b
	@@:
	cmp dword[k],ebx
	jge @f ;if(k
		shr ebx,1 ;por>>=1;
	@@:
	mov ecx,ebx ;i=por;
 
	;ecx -> i
	;edi -> mas[i]
	.cycle_b: ;do{
		shr ebx,1 ;por>>=1;
 
		mov edi,ecx
		shl edi,2
		add edi,dword[mas]
		;if(compare_cells_mb(mas[i],fx,fy)){
		stdcall pole_compare_cells_mb_coords, dword[edi],[fx],[fy]
		cmp dl,0
		je .if_u0_e
			@@: ;while(i+por>k)
			mov edx,ecx
			add edx,ebx
			cmp edx,dword[k] ;i+por>k
			jle @f
				shr ebx,1 ;por>>=1;
				jmp @b
			@@:
			add ecx,ebx ;i+=por;
			jmp .if_e
		.if_u0_e:
		;else if(compare_cells_bm(mas[i],fx,fy))i-=por;
		stdcall pole_compare_cells_bm_coords, dword[edi],[fx],[fy]
		cmp dl,0
		je .if_u1_e
			sub ecx,ebx
			jmp .if_e
		.if_u1_e:
		;else { m=i; por=0; }
			mov eax,ecx
			xor ebx,ebx
		.if_e:
	cmp ebx,0
	jne .cycle_b ;}while(por);
 
	ret
endp
 
;á¤¢¨£ ¢á¥å ïç¥¥ª (¨ ®¡ê¥ªâ®¢)
align 4
proc pole_move_all, pole:dword, m_d_x:dword, m_d_y:dword
pushad
	mov edi,dword[pole]
	mov edx,[m_d_x]
	mov esi,[m_d_y]
 
	mov eax,pole_index
	cmp dword[eax],0
	je .end_0 ;¥á«¨ ­¥â ïç¥¥ª (¯à®¢®¤®¢) â® ¢ëå®¤
 
	mov ecx,dword[eax]
	cld
	@@: ;æ¨ª« ¯® ¢á¥¬ ïç¥©ª ¬
		add eax,4
		mov ebx,[eax]
		imul ebx,sizeof.Cell
		add ebx,pole_data
 
		add dword[ebx+offs_cell_x],edx
		add dword[ebx+offs_cell_y],esi
		loop @b
	.end_0:
 
	;æ¨ª« ¯® «®£¨ç¥áª¨¬ í«¥¬¥­â ¬ ¨ ¯®¤¯¨áï¬
	stdcall dword[tl_node_poi_get_info], tree1,0
	@@:
		cmp eax,0
		je .end_1
		cmp word[eax],el_icon_elems ;¯®«ãç¥­¨¥ ç¥à¥§ eax â¨¯ ¨ª®­ª¨
		je .mov_1
		cmp word[eax],el_icon_captions
		je .mov_1
			jmp .end_mov_1
		.mov_1:
			mov ecx,eax
			stdcall [tl_node_poi_get_data], tree1,eax
			add [eax],edx ;coord x
			add [eax+4],esi ;coord y
			mov eax,ecx
		.end_mov_1:
		stdcall dword[tl_node_poi_get_next_info], tree1,eax ;¯¥à¥å®¤¨¬ ª á«¥¤ãé¥¬ã ã§«ã
		jmp @b
	.end_1:
 
popad
	ret
endp
 
;output:
; dl
align 4
proc pole_compare_cells_bm_coords uses eax ebx ecx, i0:dword, fx:dword, fy:dword
	get_cell_offset eax,[i0]
	;eax -> cell[i0]
	mov ebx,dword[fx]
	cmp dword[eax],ebx
	jle @f
		mov dl,1
		jmp .fun_e
	@@:
	mov ecx,dword[fy]
	cmp dword[eax+4],ecx
	jle @f
	cmp dword[eax],ebx
	jne @f
		mov dl,1
		jmp .fun_e
	@@:
	xor dl,dl
	.fun_e:
	ret
endp
 
;output:
; dl
align 4
proc pole_compare_cells_mb_coords uses eax ebx ecx, i0:dword, fx:dword, fy:dword
	get_cell_offset eax,[i0]
	;eax -> cell[i0]
	mov ebx,dword[fx]
	cmp dword[eax],ebx
	jge @f
		mov dl,1
		jmp .fun_e
	@@:
	mov ecx,dword[fy]
	cmp dword[eax+4],ecx
	jge @f
	cmp dword[eax],ebx
	jne @f
		mov dl,1
		jmp .fun_e
	@@:
	xor dl,dl
	.fun_e:
	ret
endp
 
;output:
; dl
align 4
proc pole_compare_cells_bm, i0:dword, i1:dword
	push eax ebx ecx
	get_cell_offset eax,[i0] ;eax -> cell[i0]
	get_cell_offset ebx,[i1] ;ebx -> cell[i1]
	mov ecx,dword[ebx] ;+0 = .x
	cmp dword[eax],ecx
	jle @f ;x0>x1
		mov dl,1
		jmp .fun_e
	@@:
	jne @f ;x0==x1
	mov ecx,dword[ebx+4] ;+4 = .y
	cmp dword[eax+4],ecx
	jle @f ;y0>y1
		mov dl,1
		jmp .fun_e
	@@:
	xor dl,dl
	.fun_e:
	pop ecx ebx eax
	ret
endp
 
;description:
; ç¨áâª  ïç¥¥ª (¯à®¢®¤®¢), ãáâ ­®¢ª  ­  ¢á¥å ¯à®¢®¤ å 0-£® á¨£­ « 
; ­ã¦­® ¢ë§ë¢ âì ¯à¨ ä®à¬¨à®¢ ­¨¨ ¨«¨ ¯¥à¥¤ § ¯ãáª®¬ áå¥¬ë
align 4
proc pole_reset_cells uses eax ebx ecx edi, pole:dword
	mov edi,dword[pole]
	mov eax,pole_index
	cmp dword[eax],0
	je .fun_e ;¥á«¨ ­¥â ïç¥¥ª (¯à®¢®¤®¢) â® ¢ëå®¤
 
	mov ecx,dword[eax]
	cld
	@@: ;æ¨ª« ¯® ¢á¥¬ ïç¥©ª ¬
		add eax,4
		mov ebx,[eax]
		imul ebx,sizeof.Cell
		add ebx,pole_data
		;and byte[ebx+offs_cell_liv],0xfe ;á¡à®á ¬« ¤è¥£® ¡¨â 
		cmp byte[ebx+offs_cell_liv],2
		je .no_clear
			mov byte[ebx+offs_cell_liv],0
		.no_clear:
		loop @b
	.fun_e:
	ret
endp
 
align 4
proc p_paint_elems uses eax esi
	stdcall dword[tl_node_poi_get_info], tree1,0
	@@:
		cmp eax,0
		je @f
		mov esi,eax
		cmp word[esi],el_icon_elems ;¯®«ãç¥­¨¥ ç¥à¥§ esi â¨¯ ¨ª®­ª¨
		jne .end_element
			stdcall [tl_node_poi_get_data], tree1,esi
			stdcall el_draw, eax
		.end_element:
		cmp word[esi],el_icon_captions ;¯®«ãç¥­¨¥ ç¥à¥§ esi â¨¯ ¨ª®­ª¨
		jne .end_caption
			stdcall [tl_node_poi_get_data], tree1,esi
			stdcall capt_draw, eax
		.end_caption:
		stdcall dword[tl_node_poi_get_next_info], tree1,esi
		jmp @b
	@@:
	ret
endp
 
;description:
; äã­ªæ¨ï à¨á®¢ ­¨ï í«¥¬¥­â  ­  ¯®«¥
align 4
proc el_draw, h_elem:dword
	pushad
 
	mov edi,[h_elem]
	mov eax,[edi] ;coord x
	mov ebx,[edi+4] ;coord y
 
	movzx edi,byte[edi+sp_offs_el_type]
	imul edi,size_el_opt
	add edi,el_opt_beg ;edi - ãª § â¥«ì ­  áâàãªâãàã á® á¢®©áâ¢ ¬¨ í«¥¬¥­â 
 
	movzx ecx,byte[edi+el_offs_box_x]
	movzx edx,byte[edi+el_offs_box_y]
	dec ecx
	dec edx
 
	push eax ebx
		mov esi,[h_elem]
		movzx esi,byte[esi+8]
		push dword[edi+el_offs_col]
		push ebx
		push eax
		stdcall move_rotate_n90, ecx,edx,esi
		stdcall draw_scaled_rect, eax,ebx ;à¨á®¢ ­¨ ª®à¯ãá  í«¥¬¥­â 
	pop ebx eax
 
	;***  «£®à¨â¬ à¨á®¢ ­¨ï ­®£ ***
	movzx esi,byte[zoom]
	cmp esi,1
	jne .end_m1
		;*** à¨á®¢ ­¨¥ ­®£ ¯à¨ 1-¬ ¬ áèâ ¡¥ ***
		;¢å®¤­ë¥ ­®£¨
		mov esi,[h_elem]
		stdcall el_get_leg_coords,esi,0 ;ãáâ ­®¢ª  ¯ à ¬¥âà®¢ 0-© ­®£¨
		add eax,[Cor_x]
		add ebx,[Cor_y]
		movzx esi,byte[esi+8]
		stdcall move_rotate_n90, 1,0,esi
		mov edx,1
		@@:
			stdcall [buf2d_set_pixel], buf_0, eax,ebx,dword[edi+el_offs_col]
			mov ecx,[edi+el_offs_legs_inp]
			movzx ecx,byte[ecx+edx]
			cmp ecx,0
			je @f
			stdcall move_rotate_n90, 0,ecx,esi
			inc edx
			jmp @b
		@@:
 
		;¢ëå®¤­ë¥ ­®£¨
		mov esi,[h_elem]
		stdcall el_get_leg_coords,esi,(1 shl 16) ;ãáâ ­®¢ª  ¯ à ¬¥âà®¢ 0-© ­®£¨
		add eax,[Cor_x] ;¤«ï à ¡®âë á buf2d_line
		add ebx,[Cor_y] ;¤«ï à ¡®âë á buf2d_line
		movzx esi,byte[esi+8]
		stdcall move_rotate_n90, -2,0,esi
		mov edx,el_offs_legs_out
		inc edx
		@@:
			push dword[edi+el_offs_col]
			stdcall move_rotate_n90, 1,0,esi
			push ebx
			push eax
			stdcall move_rotate_n90, -1,0,esi
			;stdcall draw_scaled_rect, eax,ebx
			stdcall [buf2d_line], buf_0, eax,ebx
			movzx ecx,byte[edi+edx]
			cmp ecx,0
			je @f
			stdcall move_rotate_n90, 0,ecx,esi
			inc edx
			jmp @b
		@@:
 
		jmp .end_mn
	.end_m1:
		;*** à¨á®¢ ­¨¥ ­®£ ¯à¨ n-¬ ¬ áèâ ¡¥ ***
		;¢å®¤­ë¥ ­®£¨
		xor edx,edx
		@@:
			stdcall el_get_leg_coords,[h_elem],edx
			mov ecx,eax
			or ecx,ebx
			jz @f
			mov ecx,[h_elem]
			movzx ecx,byte[ecx+8]
			stdcall move_rotate_n90, 1,0,ecx
			add eax,[Cor_x]
			add ebx,[Cor_y]
			imul eax,esi
			imul ebx,esi
			stdcall [buf2d_filled_rect_by_size], buf_0, eax,ebx,esi,esi, dword[edi+el_offs_col]
			inc edx
			jmp @b
		@@:
 
		;¢ëå®¤­ë¥ ­®£¨
		mov edx,(1 shl 16)
		@@:
			stdcall el_get_leg_coords,[h_elem],edx
			mov ecx,eax
			or ecx,ebx
			jz @f
			mov ecx,[h_elem]
			movzx ecx,byte[ecx+8]
 
			push dword[edi+el_offs_col]
			stdcall move_rotate_n90, -2,0,ecx
			push ebx
			push eax
			stdcall move_rotate_n90, 1,0,ecx
			stdcall draw_scaled_rect, eax,ebx
 
			inc edx
			jmp @b
		@@:		
	.end_mn:
	popad
	ret
endp
 
;description:
;à¨á®¢ ­¨¥ ¯®¤¯¨á¥©
align 4
proc capt_draw uses eax ebx edi esi, h_capt:dword
	mov edi,[h_capt]
	mov eax,[edi] ;coord x
	mov ebx,[edi+4] ;coord y
 
	movzx esi,byte[zoom]
	cmp esi,3
	jl @f
		;à¨á®¢ ­¨¥ à ¬ª¨, ¢®ªàã£ § ­ïâ®© â®çª¨
		stdcall draw_point_border, eax,ebx, [color_captions]
	@@:
 
	add eax,[Cor_x]
	add ebx,[Cor_y]
 
	cmp esi,1
	jle @f
		imul eax,esi
		imul ebx,esi
	@@:
 
	cmp esi,3
	jl @f
		;á¤¢¨£ ­ ¤¯¨á¨ á ãç¥â®¬ à ¬ª¨
		add eax,esi
		inc eax
	@@:
 
	add edi,capt_offs ;edi - ãª § â¥«ì ­  ¯®«­ãî ¯®¤¯¨áì (á ª®®à¤¨­ â ¬¨)
	call str_next_val
	call str_next_val
	stdcall [buf2d_draw_text], buf_0, buf_font,edi,eax,ebx,[color_captions] ;à¨áã¥¬ áâà®ªã á â¥ªáâ®¬
	ret
endp
 
;description:
; äã­ªæ¨ï ¤«ï ¢ë¤¥«¥­¨ï â®ç¥ç­ëå ®¡ê¥ªâ®¢ ­  ªàã¯­ëå ¬ áèâ ¡ å
; ¤ ­­ ï äã­ªæ¨ï ®ç¥­ì ¯®å®¦  ­  draw_signal_rect
align 4
proc draw_point_border uses eax ebx edi, x0:dword,y0:dword, color:dword
	movzx edi,byte[zoom]
	mov ebx,[y0]
	mov eax,[x0]
 
	add ebx,[Cor_y]
	imul ebx,edi
	add eax,[Cor_x]
	imul eax,edi
 
	stdcall [buf2d_rect_by_size], buf_0, eax,ebx,edi,edi, dword[color]
	ret
endp
 
;description:
; ¯®¤äã­ªæ¨ï ¤«ï à¨á®¢ ­¨ï ã¢¥«¨ç¥­­ëå ¯àï¬®ã£®«ì­¨ª®¢ ­  áå¥¬¥
align 4
proc draw_scaled_rect uses eax ebx ecx edx edi, x0:dword,y0:dword,x1:dword,y1:dword, color:dword
	movzx edi,byte[zoom]
	mov edx,[y1]
	mov ecx,[x1]
	mov ebx,[y0]
	mov eax,[x0]
 
	cmp eax,ecx
	jle @f
		xchg eax,ecx
	@@:
	sub ecx,eax
	cmp ebx,edx
	jle @f
		xchg ebx,edx
	@@:
	sub edx,ebx
 
	inc ecx
	inc edx
 
	imul edx,edi
	imul ecx,edi
	add ebx,[Cor_y]
	imul ebx,edi
	add eax,[Cor_x]
	imul eax,edi
 
	stdcall [buf2d_filled_rect_by_size], buf_0, eax,ebx,ecx,edx, dword[color]
	ret
endp
 
align 4
proc pole_paint, pole:dword
	pushad
 
	;*** à®¨á®¢ ­¨¥ à ¬ª¨
	mov eax,[Cor_x]
	mov ebx,[Cor_y]
	mov ecx,[shem_w]
	mov edx,[shem_h]
	movzx esi,byte[zoom]
	cmp esi,1
	jle @f
		imul eax,esi
		imul ebx,esi
		imul ecx,esi
		imul edx,esi
	@@:
	dec eax
	dec ebx
	add ecx,2
	add edx,2
	stdcall [buf2d_rect_by_size], buf_0, eax,ebx, ecx,edx, [color_border]
 
	;eax -> firstC
	;ebx -> i
	;ecx -> cell[pole_index[i]]
	;edx -> color
 
	mov edi,dword[pole]
	mov eax,pole_index
	cmp dword[eax],0
	je .no_draw
 
	mov eax,dword[eax]
	mov ebx,1
 
;---
	@@: ;while(i
		cmp ebx,pole_b_sort
		jge @f ;¯¥à¥å®¤¨¬ ­  ­ ç «® ­¨¦­¥£® æ¨ª« 
		mov ecx,ebx
		shl ecx,2
		add ecx,pole_index
		get_cell_offset ecx,dword[ecx]
		mov edx,dword[ecx] ;+0 = .x
		add edx,dword[Cor_x]
		cmp edx,0
		jge @f ;¯¥à¥å®¤¨¬ ­  ­ ç «® ­¨¦­¥£® æ¨ª« 
			inc ebx ;i++; // ¤«ï ¯à®¯ãáª  ïç¥¥ª §  ®ª­®¬ á«¥¢ 
		jmp @b
	@@:
 
	;eax -> pole_index[firstC]
	;ebx -> pole_index[i]
	;edi -> coord_x
	;esi -> coord_y
	shl eax,2
	shl ebx,2
	add eax,pole_index
	add ebx,pole_index
 
	cmp byte[zoom],2
	jge .zoom2
	@@: ;for(;i<=fristC;i++){
		get_cell_offset ecx,dword[ebx]
;...
		mov edi,dword[Cor_x]
		add edi,dword[ecx] ;+0 = .x
		mov esi,dword[Cor_y]
		add esi,dword[ecx+4] ;+4 = .y
		movzx edx,byte[ecx+offs_cell_liv]
		and edx,3 ;®£à ­¨ç¥­¨¥
		shl edx,2
		add edx,shem_colors
		stdcall [buf2d_set_pixel], buf_0, edi, esi, [edx]
;...
		add ebx,4
		cmp ebx,eax
		jle @b
 
	jmp .no_draw
	.zoom2:
 
	@@: ;for(;i<=fristC;i++){
		get_cell_offset ecx,dword[ebx]
 
		movzx edx,byte[zoom] ;edx ¨á¯®«ì§ã¥âáï ¤«ï ¢­¥á¥­¨ï zoom ¢ 4 ¡ ©â­®¥ ç¨á«®
		mov edi,dword[ecx] ;+0 = .x
		add edi,dword[Cor_x]
		imul edi,edx
		mov esi,dword[ecx+4] ;+4 = .y
		add esi,dword[Cor_y]
		imul esi,edx
 
		movzx edx,byte[ecx+offs_cell_liv]
		and edx,3 ;®£à ­¨ç¥­¨¥
		shl edx,2
		add edx,shem_colors
 
		movzx ecx,byte[zoom]
		;;;dec ecx
		stdcall [buf2d_filled_rect_by_size], buf_0, edi, esi, ecx, ecx, [edx]
		add ebx,4
		cmp ebx,eax
		jle @b
 
	.no_draw:
	popad
	call p_paint_elems
	ret
endp
 
;®àâ¨à®¢ª  ïç¥¥ª ¯®«ï, ­ã¦­  ¤«ï ¡®«¥¥ ¡ëáâà®£® ¯®¨áª 
align 4
proc pole_sort uses eax edi, pole:dword
	mov edi,dword[pole]
	mov eax,pole_index
	mov eax,dword[eax] ;firstC -> eax
	stdcall pole_fl_sort, pole_index,eax ;á®àâ¨àã¥¬ ¢á¥ ïç¥©ª¨
	mov pole_b_sort,eax ;áâ ¢¨¬ ç¨á«® ®âá®àâ¨à®¢ ­­ëå ïç¥¥ª à ¢­®¥ ç¨á«ã ¢á¥å áãé¥áâ¢ãîé¨å ïç¥¥ª
	ret
endp
 
;®àâ¨à®¢ª  ¢¥ªâ®à  a[1..n] ¬¥â®¤®¬ «®©¤ 
;«¥¬¥­â a[0] ¢ á®àâ¨à®¢ª¥ ­¥ ãç áâ¢ã¥â
align 4
proc pole_fl_sort uses eax ecx edx edi esi, a:dword, n:dword
	mov ecx,dword[a]
	;®à¬¨à®¢ âì ¨áå®¤­®¥ ç áâ¨ç­® ã¯®àï¤®ç¥­­®¥ ¤¥à¥¢®
	mov eax,dword[n]
	shr eax,1
	@@: ;for(i=n>>1; i>=2; i--)
		stdcall pole_fl_surface, ecx,eax,[n] ;(a,i,n)
		dec eax
		cmp eax,2
		jge @b
	;ë¯®«­¨âì ¯à®æ¥¤ãàã ¢á¯«ëâ¨ï «®©¤  ¤«ï ª ¦¤®£® ¯®¤¤¥à¥¢ 
	mov eax,dword[n]
	@@: ;for(i=n; i>=2; i--){
		stdcall pole_fl_surface, ecx,1,eax ;(a,1,i)
		;®¬¥áâ¨âì ­ ©¤¥­­ë© ¬ ªá¨¬ «ì­ë© í«¥¬¥­â ¢ ª®­¥æ á¯¨áª 
		mov edi,eax
		shl edi,2
		add edi,ecx ;edi -> &a[i]
		mov esi,dword[edi] ;w=a[i];
		mov edx,dword[ecx+4]
		mov dword[edi],edx ;a[i]=a[1];
		mov dword[ecx+4],esi ;a[1]=w;
 
		dec eax
		cmp eax,2
		jge @b
	ret
endp
 
;à®æ¥¤ãà  ¢á¯«ëâ¨ï «®©¤  ¯® ¤¥à¥¢ã a[1..k]
align 4
proc pole_fl_surface, a:dword, i:dword, k:dword
locals
	copy dd ?
endl
	pushad
	;edx -> ...
	;edi -> m
	;esi -> j
	mov eax,dword[a]
	mov ebx,dword[i]
	mov ecx,dword[k]
 
	mov edx,ebx
	shl edx,2
	add edx,eax
	mov edx,dword[edx]
	mov dword[copy],edx ;copy=a[i];
	mov edi,ebx
	shl edi,1 ;m=i<<1;
	.cycle_b: ;while (m<=k) {
		cmp edi,ecx
		jg .cycle_e
		jne @f ;if (m==k) j=m;
			mov esi,edi
			jmp .else_e
		@@: ;else if (pole_compare_cells_bm(a[m],a[m+1])) j=m;
		mov edx,edi
		shl edx,2
		add edx,eax
		stdcall pole_compare_cells_bm, dword[edx],dword[edx+4]
		cmp dl,0
		je @f
			mov esi,edi
			jmp .else_e
		@@: ;else j=m+1;
			mov esi,edi
			inc esi
		.else_e:
 
		;if (pole_compare_cells_bm(a[j],copy)) {
		mov edx,esi
		shl edx,2
		add edx,eax
		stdcall pole_compare_cells_bm, dword[edx],dword[copy]
		cmp dl,0
		je .cycle_e ;} else break; //¢ëå®¤ ¨§ æ¨ª« 
 
		mov edx,esi
		shl edx,2
		add edx,eax
		push dword[edx] ;push a[j];
		mov edx,ebx
		shl edx,2
		add edx,eax
		pop dword[edx] ;a[i]=a[j];
		mov ebx,esi ;i=j;
		mov edi,ebx
		shl edi,1 ;m=i<<1;
 
		jmp .cycle_b
	.cycle_e:
 
	;§­ ç¥­¨ï ¬­®£¨å à¥£¨áâà®¢ ã¦¥ ­¥ ¢ ¦­ë â. ª. ª®­¥æ äã­ªæ¨¨
	shl ebx,2
	add eax,ebx
	mov edx,dword[copy]
	mov dword[eax],edx ;a[i]=copy;
 
	popad
	ret
endp
;--------------------------------------
 
align 4
proc pole_draw_pok, pole:dword
pushad
	;mov edi,dword[pole]
 
 
 
	mov ecx,[sc.work_text]
 
	or  ecx,0x80000000 ;or (1 shl 30)
	;mov edi,[sc.work]
	mcall SF_DRAW_TEXT,(400 shl 16)+5,,txt_zoom
 
	add bx,9
	mov edx,txt_osob
	int 0x40
 
	add bx,9
	mov edx,txt_info
	int 0x40
 
 
 
	movzx ecx,byte[zoom]
	mov edx,(400+6*9)*65536+5
	mov esi,[sc.work_button_text]
	or  esi,(1 shl 30)
	mov edi,[sc.work_button]
	mcall SF_DRAW_NUMBER,(2 shl 16) ;¬ áèâ ¡
 
	mov edi,dword[pole]
	mov ecx,pole_index
	mov ecx,[ecx]
	mov edi,[sc.work_button]
 
	add edx,(6*0)*65536+9
	mcall ,(5 shl 16) ;ç¨á«® â®ç¥ª
popad
	ret
endp
 
align 4
but_zoom_p:
	cmp byte[zoom],16
	jge @f
		pushad
		;¢ëç¨á«¥­¨¥ á¤¢¨£®¢ ¤«ï ¯®«ï, ª®â®àë¥ ®¡¥á¯¥ç â æ¥­âà®¢ªã ¯®«ï ¯à¨ ã¢¥«¨ç¥­¨¨ ¬ áèâ ¡ 
		movzx ecx,byte[zoom]
		xor edx,edx
		mov eax,dword[buf_0.w]
		shr eax,1 ;¢ eax ¯®«®¢¨­  è¨à¨­ë ¯®«ï
		mov ebx,eax ;¤¥« ¥¬ à¥§¥à¢­ãî ª®¯¨î eax
		div ecx ;¤¥«¨¬ eax ­  â¥ªãé¨© ¬ áèâ ¡
		xchg eax,ebx
		xor edx,edx
		inc ecx
		div ecx ;¤¥«¨¬ eax ­  ­®¢ë© ¬ áèâ ¡
		sub ebx,eax ;¢ëç¨á«ï¥âáï á¤¢¨£ ¯®«ï ª®â®àë© ®¡¥á¯¥ç¨â æ¥­âà®¢ªã ¯®«ï
		sub dword[Cor_x],ebx ;á¤¢¨£ ¥¬ ¯®«¥ §à¥­¨ï ¯® ®á¨ x
		xor ecx,ecx
		mov cl,byte[zoom]
		xor edx,edx
		mov eax,dword[buf_0.h]
		shr eax,1
		mov ebx,eax
		div ecx
		xchg eax,ebx
		xor edx,edx
		inc ecx
		div ecx
		sub ebx,eax
		sub dword[Cor_y],ebx ;á¤¢¨£ ¥¬ ¯®«¥ §à¥­¨ï ¯® ®á¨ y
 
		inc byte[zoom]
		stdcall pole_draw_pok, pole
		popad
 
		.buf_clear:
			call redraw_pole
	@@:
	ret
 
align 4
but_zoom_m:
	cmp byte[zoom],1
	jle @f
		pushad
		;¢ëç¨á«¥­¨¥ á¤¢¨£®¢ ¤«ï ¯®«ï, ª®â®àë¥ ®¡¥á¯¥ç â æ¥­âà®¢ªã ¯®«ï ¯à¨ ã¬¥­ìè¥­¨¨ ¬ áèâ ¡ 
		movzx ecx,byte[zoom]
		xor edx,edx
		mov eax,dword[buf_0.w]
		shr eax,1 ;¢ eax ¯®«®¢¨­  è¨à¨­ë ¯®«ï
		mov ebx,eax ;¤¥« ¥¬ à¥§¥à¢­ãî ª®¯¨î eax
		div ecx ;¤¥«¨¬ eax ­  â¥ªãé¨© ¬ áèâ ¡
		xchg eax,ebx
		xor edx,edx
		dec ecx
		div ecx ;¤¥«¨¬ eax ­  ­®¢ë© ¬ áèâ ¡
		sub ebx,eax ;¢ëç¨á«ï¥âáï á¤¢¨£ ¯®«ï ª®â®àë© ®¡¥á¯¥ç¨â æ¥­âà®¢ªã ¯®«ï
		sub dword[Cor_x],ebx ;á¤¢¨£ ¥¬ ¯®«¥ §à¥­¨ï ¯® ®á¨ x
		xor ecx,ecx
		mov cl,byte[zoom]
		xor edx,edx
		mov eax,dword[buf_0.h]
		shr eax,1
		mov ebx,eax
		div ecx
		xchg eax,ebx
		xor edx,edx
		dec ecx
		div ecx
		sub ebx,eax
		sub dword[Cor_y],ebx ;á¤¢¨£ ¥¬ ¯®«¥ §à¥­¨ï ¯® ®á¨ y
 
		dec byte[zoom]
		stdcall pole_draw_pok, pole
		popad
 
		.buf_clear:
			call redraw_pole
	@@:
	ret
 
;æ¥­âà®¢ª  áå¥¬ë ¯® æ¥­âàã íªà ­ 
align 4
proc but_center uses eax ebx ecx edx
	movzx ecx,byte[zoom]
	cmp ecx,1
	jle .end_m_1
		mov eax,[buf_0.w]
		mov ebx,[shem_w]
		imul ebx,ecx
 
		sub eax,ebx
		xor edx,edx
		shl ecx,1
		cmp eax,0
		jge @f
			neg eax
			inc eax
			div ecx
			neg eax
			inc eax
			jmp .set_x
		@@:
			div ecx
		.set_x:
		mov [Cor_x],eax
		mov eax,[buf_0.h]
		mov ebx,[shem_h]
		shr ecx,1
		imul ebx,ecx
		sub eax,ebx
		xor edx,edx
		shl ecx,1
		cmp eax,0
		jge @f
			neg eax
			inc eax
			div ecx
			neg eax
			inc eax
			jmp .set_y
		@@:
			div ecx
		.set_y:
		mov [Cor_y],eax
		jmp .end_m_n
	.end_m_1:
		mov eax,[buf_0.w]
		sub eax,[shem_w]
		shr eax,1
		bt eax,30
		jnc @f
			bts eax,31
		@@:
		mov [Cor_x],eax
		mov eax,[buf_0.h]
		sub eax,[shem_h]
		shr eax,1
		bt eax,30
		jnc @f
			bts eax,31
		@@:
		mov [Cor_y],eax
	.end_m_n:
	call redraw_pole
	ret
endp
 
align 4
but_pole_up:
	push eax ecx edx
	mov eax,dword[buf_0.h]
	shr eax,2
	movzx ecx,byte[zoom]
	cmp cx,2
	jl @f ;¤¥«¥­¨¥ ­  ¢¥«¨ç¨­ã zoom
		xor edx,edx
		div ecx
	@@:
	add dword[Cor_y],eax
	pop edx ecx eax
	call redraw_pole
	ret
 
align 4
but_pole_dn:
	push eax ecx edx
	mov eax,dword[buf_0.h]
	shr eax,2
	xor ecx,ecx
	mov cl,byte[zoom]
	cmp cx,2
	jl @f ;¤¥«¥­¨¥ ­  ¢¥«¨ç¨­ã zoom
		xor edx,edx
		div ecx
	@@:
	sub dword[Cor_y],eax
	pop edx ecx eax
	call redraw_pole
	ret
 
align 4
but_pole_left:
	push eax ecx edx
	mov eax,dword[buf_0.w]
	shr eax,2
	xor ecx,ecx
	mov cl,byte[zoom]
	cmp cx,2
	jl @f ;¤¥«¥­¨¥ ­  ¢¥«¨ç¨­ã zoom
		xor edx,edx
		div ecx
	@@:
	add dword[Cor_x],eax
	pop edx ecx eax
	call redraw_pole
	ret
 
align 4
but_pole_right:
	push eax ecx edx
	mov eax,dword[buf_0.w]
	shr eax,2
	xor ecx,ecx
	mov cl,byte[zoom]
	cmp cx,2
	jl @f ;¤¥«¥­¨¥ ­  ¢¥«¨ç¨­ã zoom
		xor edx,edx
		div ecx
	@@:
	sub dword[Cor_x],eax
	pop edx ecx eax
	call redraw_pole
	ret
 
;output:
; edx - count created points
align 4
proc shem_create_line uses eax ebx ecx edi, x:dword, y:dword, opt:dword
	mov edi,pole
	xor edx,edx
 
	mov ebx,[x]
	mov ecx,[y]
	bt dword[opt],0
	jnc @f
	.line_lr:
		inc ebx
		cmp ebx,[shem_w]
		jge @f
		stdcall pole_cell_find, pole,ebx,ecx
		cmp eax,0
		je .u0
			imul eax,sizeof.Cell
			add eax,pole_data
			cmp byte[eax+offs_cell_liv],1
			jne @f
		.u0:
		stdcall pole_cell_creat, pole,ebx,ecx,1
		inc edx
		jmp .line_lr
	@@:
 
	mov ebx,[x]
	;mov ecx,[y]
	bt dword[opt],2
	jnc @f
	.line_rl:
		dec ebx
		cmp ebx,0
		jl @f
		stdcall pole_cell_find, pole,ebx,ecx
		cmp eax,0
		je .u1
			imul eax,sizeof.Cell
			add eax,pole_data
			cmp byte[eax+offs_cell_liv],1
			jne @f
		.u1:
		stdcall pole_cell_creat, pole,ebx,ecx,1
		inc edx
		jmp .line_rl
	@@:
 
	mov ebx,[x]
	mov ecx,[y]
	bt dword[opt],3
	jnc @f
	.line_du:
		dec ecx
		cmp ecx,0
		jl @f
		stdcall pole_cell_find, pole,ebx,ecx
		cmp eax,0
		je .u2
			imul eax,sizeof.Cell
			add eax,pole_data
			cmp byte[eax+offs_cell_liv],1
			jne @f
		.u2:
		stdcall pole_cell_creat, pole,ebx,ecx,1
		inc edx
		jmp .line_du
	@@:
 
	;mov ebx,[x]
	mov ecx,[y]
	bt dword[opt],1
	jnc @f
	.line_ud:
		inc ecx
		cmp ecx,[shem_h]
		jge @f
		stdcall pole_cell_find, pole,ebx,ecx
		cmp eax,0
		je .u3
			imul eax,sizeof.Cell
			add eax,pole_data
			cmp byte[eax+offs_cell_liv],1
			jne @f
		.u3:
		stdcall pole_cell_creat, pole,ebx,ecx,1
		inc edx
		jmp .line_ud
	@@:
 
	ret
endp
 
align 4
redraw_pole:
	stdcall [buf2d_clear], buf_0, [buf_0.color]
	stdcall pole_paint, pole
	stdcall [buf2d_draw], buf_0
	ret
 
>
 
>
>
>
>
>
>
>
>
>
>

Rev 5916	Rev 6213
1	;	1	;
2	; äãªæ¨ ¤«ï á®§¤ ¨ï ¨ à¥¤ ªâ¨à®¢ ¨ï ¯à®¢®¤®¢	2	; äãªæ¨ ¤«ï á®§¤ ¨ï ¨ à¥¤ ªâ¨à®¢ ¨ï ¯à®¢®¤®¢
3	;	3	;
4		4
5	;--------------------------------------	5	;--------------------------------------
6	struct Cell	6	struct Cell
7	x dd ? ;+0	7	x dd ? ;+0
8	y dd ? ;+4	8	y dd ? ;+4
9	liv db ? ;+8	9	liv db ? ;+8
10	napr db ? ;+9	10	napr db ? ;+9
11	ends	11	ends
12		12
13	offs_cell_x equ 0	13	offs_cell_x equ 0
14	offs_cell_y equ 4	14	offs_cell_y equ 4
15	offs_cell_liv equ 8	15	offs_cell_liv equ 8
16	offs_cell_napr equ 9	16	offs_cell_napr equ 9
17		17
18	;áâàãªâãà ¤«ï á®§¤ ¨ï ¯®«ï	18	;áâàãªâãà ¤«ï á®§¤ ¨ï ¯®«ï
19	align 4	19	align 4
20	pole:	20	pole:
21	.index dd 0	21	.index dd 0
22	cell dd 0 ;ãª § â¥«ì ¯ ¬ïâì á® áâàãªâãà ¬¨ ïç¥¥ª	22	cell dd 0 ;ãª § â¥«ì ¯ ¬ïâì á® áâàãªâãà ¬¨ ïç¥¥ª
23	.max_cell dd 90000	23	.max_cell dd 90000
24	.b_sort dd 0 ;£à ¨æ ¤«ï á®àâ¨à®¢ ëå ïç¥¥ª	24	.b_sort dd 0 ;£à ¨æ ¤«ï á®àâ¨à®¢ ëå ïç¥¥ª
25		25
26	pole_index equ dword[edi]	26	pole_index equ dword[edi]
27	pole_data equ dword[edi +4] ;ãª § â¥«ì ¯ ¬ïâì á® áâàãªâãà ¬¨ ïç¥¥ª	27	pole_data equ dword[edi +4] ;ãª § â¥«ì ¯ ¬ïâì á® áâàãªâãà ¬¨ ïç¥¥ª
28	pole_max_cell equ dword[edi +8]	28	pole_max_cell equ dword[edi +8]
29	pole_b_sort equ dword[edi+12] ;£à ¨æ ¤«ï á®àâ¨à®¢ ëå ïç¥¥ª	29	pole_b_sort equ dword[edi+12] ;£à ¨æ ¤«ï á®àâ¨à®¢ ëå ïç¥¥ª
30	offs_pole_b_sort equ 12	30	offs_pole_b_sort equ 12
31		31
32	macro get_cell_offset reg,ind	32	macro get_cell_offset reg,ind
33	{	33	{
34	mov reg,ind	34	mov reg,ind
35	imul reg,sizeof.Cell	35	imul reg,sizeof.Cell
36	add reg,dword[cell]	36	add reg,dword[cell]
37	}	37	}
38		38
39	er_oom db 0 ; á«ãç © ¨áç¥à¯ ¨ï ¯ ¬ïâ¨	39	er_oom db 0 ; á«ãç © ¨áç¥à¯ ¨ï ¯ ¬ïâ¨
40	Cor_x dd 0	40	Cor_x dd 0
41	Cor_y dd 0	41	Cor_y dd 0
42	zoom db 3 ;¬ áèâ ¡ ¯®«ï	42	zoom db 3 ;¬ áèâ ¡ ¯®«ï
43	txt_zoom db ' áèâ ¡:',0	43	txt_zoom db ' áèâ ¡:',0
44	txt_osob db '®ç¥ª:',0	44	txt_osob db '®ç¥ª:',0
45	txt_info: db ' §¬¥à: '	45	txt_info: db ' §¬¥à: '
46	.size: rb 16	46	.size: rb 16
47	txt_mull db '*',0	47	txt_mull db '*',0
48	txt_space db ' ',0	48	txt_space db ' ',0
49	txt_nl db 13,10,0	49	txt_nl db 13,10,0
50	txt_buf rb 32	50	txt_buf rb 32
51		51
52		52
53	align 4	53	align 4
54	proc pole_init uses eax ebx edi, pole:dword	54	proc pole_init uses eax ebx edi, pole:dword
55	mov edi,dword[pole]	55	mov edi,dword[pole]
56		56
57	;* ª®¤ á ®¤®© ®¡« áâìî ¢ ¯ ¬ïâ¨ *	57	;* ª®¤ á ®¤®© ®¡« áâìî ¢ ¯ ¬ïâ¨ *
58	mov ebx,4	58	mov ebx,4
59	add ebx,sizeof.Cell	59	add ebx,sizeof.Cell
60	imul ebx,pole_max_cell	60	imul ebx,pole_max_cell
61	stdcall mem.Alloc,ebx	61	stdcall mem.Alloc,ebx
62	mov pole_index,eax	62	mov pole_index,eax
63		63
64	mov ebx,pole_max_cell	64	mov ebx,pole_max_cell
65	shl ebx,2	65	shl ebx,2
66	add eax,ebx	66	add eax,ebx
67	mov pole_data,eax	67	mov pole_data,eax
68		68
69	stdcall pole_clear, edi	69	stdcall pole_clear, edi
70	stdcall pole_paint, edi ;à¨á®¢ ¨¥ ¯®«ï ¢ ¡ãä¥à¥ (¥ íªà ¥)	70	stdcall pole_paint, edi ;à¨á®¢ ¨¥ ¯®«ï ¢ ¡ãä¥à¥ (¥ íªà ¥)
71	ret	71	ret
72	endp	72	endp
73		73
74	align 4	74	align 4
75	proc pole_delete uses edi, pole:dword	75	proc pole_delete uses edi, pole:dword
76	mov edi,dword[pole]	76	mov edi,dword[pole]
77	stdcall mem.Free,pole_index	77	stdcall mem.Free,pole_index
78	ret	78	ret
79	endp	79	endp
80		80
81	;ç¨áâª ¯à®¢®¤®¢ áå¥¬¥	81	;ç¨áâª ¯à®¢®¤®¢ áå¥¬¥
82	align 4	82	align 4
83	proc pole_clear uses eax ecx edi, pole:dword	83	proc pole_clear uses eax ecx edi, pole:dword
84	mov edi,dword[pole]	84	mov edi,dword[pole]
85		85
86	xor eax,eax	86	xor eax,eax
87	mov pole_b_sort,eax	87	mov pole_b_sort,eax
88	mov byte[er_oom],al	88	mov byte[er_oom],al
89	cld	89	cld
90	mov ecx,pole_max_cell	90	mov ecx,pole_max_cell
91	imul ecx,sizeof.Cell	91	imul ecx,sizeof.Cell
92	mov edi,pole_data	92	mov edi,pole_data
93	repne stosb ;memset(cell,0,sizeof(Cell)*pole_max_cell);	93	repne stosb ;memset(cell,0,sizeof(Cell)*pole_max_cell);
94		94
95	mov edi,dword[pole]	95	mov edi,dword[pole]
96	mov ecx,pole_max_cell	96	mov ecx,pole_max_cell
97	mov edi,pole_index	97	mov edi,pole_index
98	@@:	98	@@:
99	stosd ;for(i=0;i	99	stosd ;for(i=0;i
100	;mov dword[edi],eax	-
101	;add edi,4	-
102	inc eax	100	inc eax
103	loop @b	101	loop @b
104	ret	102	ret
105	endp	103	endp
106		104
107	align 4	105	align 4
108	proc pole_cell_creat, pole:dword, x:dword, y:dword, li:dword	106	proc pole_cell_creat, pole:dword, x:dword, y:dword, li:dword
109	pushad	107	pushad
110	mov edi,dword[pole]	108	mov edi,dword[pole]
111	mov esi,pole_index	109	mov esi,pole_index
112		110
113	; *** ¥á«¨ ª«¥âª ã¦¥ ¡ë« á®§¤	111	; *** ¥á«¨ ª«¥âª ã¦¥ ¡ë« á®§¤
114	stdcall pole_cell_find, [pole], [x],[y]	112	stdcall pole_cell_find, [pole], [x],[y]
115	cmp eax,0	113	cmp eax,0
116	je @f	114	je @f
117	get_cell_offset ebx,eax	115	get_cell_offset ebx,eax
118	jmp .change	116	jmp .change
119	@@:	117	@@:
120		118
121	; *** á®§¤ ¨¥ ®¢®© ïç¥©ª¨	119	; *** á®§¤ ¨¥ ®¢®© ïç¥©ª¨
122	; å®¤¨¬ ®¬¥à á¢®¡®¤®© ïç¥©ª¨ (i) ¤«ï ¤®¡ ¢«¥¨ï ®¢®©	120	; å®¤¨¬ ®¬¥à á¢®¡®¤®© ïç¥©ª¨ (i) ¤«ï ¤®¡ ¢«¥¨ï ®¢®©
123	;mov esi,pole_index	121	;mov esi,pole_index
124	inc dword[esi]	122	inc dword[esi]
125	mov ebx,pole_max_cell	123	mov ebx,pole_max_cell
126	cmp dword[esi],ebx	124	cmp dword[esi],ebx
127	jne @f	125	jne @f
128	dec dword[esi]	126	dec dword[esi]
129	;... need call message: "eror out of memory" ...	127	;... need call message: "eror out of memory" ...
130	;... ¢ë¢®¤ á®®¡é¥¨ï ¯¥à¥¯®«¥¨ï ¤® ¤®¡ ¢¨âì ...	128	;... ¢ë¢®¤ á®®¡é¥¨ï ¯¥à¥¯®«¥¨ï ¤® ¤®¡ ¢¨âì ...
131	mov byte[er_oom],0	129	mov byte[er_oom],0
132	jmp .fun_e ;return;	130	jmp .fun_e ;return;
133	@@:	131	@@:
134	mov eax,dword[esi] ;eax - ®¬¥à ¤«ï ¯®á«¥¤¥© ïç¥©ª¨	132	mov eax,dword[esi] ;eax - ®¬¥à ¤«ï ¯®á«¥¤¥© ïç¥©ª¨
135	shl eax,2	133	shl eax,2
136	add eax,pole_index ;eax - ãª § â¥«ì ¤®¡ ¢«ï¥¬ãî ïç¥©ªã (¢ ª®¥æ ¬ áá¨¢ )	134	add eax,pole_index ;eax - ãª § â¥«ì ¤®¡ ¢«ï¥¬ãî ïç¥©ªã (¢ ª®¥æ ¬ áá¨¢ )
137	get_cell_offset ebx,dword[eax]	135	get_cell_offset ebx,dword[eax]
138	mov ecx,dword[x]	136	mov ecx,dword[x]
139	mov dword[ebx],ecx ;+0 = .x	137	mov dword[ebx],ecx ;+0 = .x
140	mov edx,dword[y]	138	mov edx,dword[y]
141	mov dword[ebx+4],edx ;+4 = .y	139	mov dword[ebx+4],edx ;+4 = .y
142	.change:	140	.change:
143	mov ecx,[li]	141	mov ecx,[li]
144	mov byte[ebx+offs_cell_liv],cl	142	mov byte[ebx+offs_cell_liv],cl
145	.fun_e:	143	.fun_e:
146	popad	144	popad
147	ret	145	ret
148	endp	146	endp
149		147
150	;ã¤ «¥¨¥ ïç¥©ª¨	148	;ã¤ «¥¨¥ ïç¥©ª¨
151	align 4	149	align 4
152	proc pole_cell_delete, pole:dword, x:dword, y:dword	150	proc pole_cell_delete, pole:dword, x:dword, y:dword
153	pushad	151	pushad
154	mov edi,dword[pole]	152	mov edi,dword[pole]
155	mov ebx,edi	153	mov ebx,edi
156	add ebx,offs_pole_b_sort	154	add ebx,offs_pole_b_sort
157	mov esi,pole_index	155	mov esi,pole_index
158		156
159	mov ecx,[esi]	157	mov ecx,[esi]
160	cmp ecx,1	158	cmp ecx,1
161	jl .fun_e	159	jl .fun_e
162		160
163	stdcall pole_cell_find, [pole], [x],[y]	161	stdcall pole_cell_find, [pole], [x],[y]
164	cmp eax,0	162	cmp eax,0
165	je .fun_e ;¥á«¨ ª«¥âª ¥ ¡ë« á®§¤	163	je .fun_e ;¥á«¨ ª«¥âª ¥ ¡ë« á®§¤
166		164
167	dec dword[esi]	165	dec dword[esi]
168		166
169	mov edi,esi	167	mov edi,esi
170	add edi,4	168	add edi,4
171	mov edx,ecx	169	mov edx,ecx
172	cld	170	cld
173	repnz scasd ;¯®¨áª	171	repnz scasd ;¯®¨áª
174	sub edi,4	172	sub edi,4
175		173
176	cmp dword[ebx],1 ;[ebx]=pole_b_sort	174	cmp dword[ebx],1 ;[ebx]=pole_b_sort
177	jl @f	175	jl @f
178	mov eax,edi	176	mov eax,edi
179	sub eax,esi ;esi=pole_index	177	sub eax,esi ;esi=pole_index
180	shr eax,2	178	shr eax,2
181	dec eax	179	dec eax
182	cmp [ebx],eax ;eax - ¯®§¨æ¨ï ãª § â¥«ï ã¤ «ï¥¬®© ïç¥©ª¨	180	cmp [ebx],eax ;eax - ¯®§¨æ¨ï ãª § â¥«ï ã¤ «ï¥¬®© ïç¥©ª¨
183	jle @f ;¡ë«® jl @f	181	jle @f ;¡ë«® jl @f
184	dec dword[ebx]	182	dec dword[ebx]
185	@@:	183	@@:
186		184
187	shl edx,2	185	shl edx,2
188	add edx,esi ;ª®¥çë© í«¥¬¥â ¬ áá¨¢	186	add edx,esi ;ª®¥çë© í«¥¬¥â ¬ áá¨¢
189	sub edx,edi	187	sub edx,edi
190	shr edx,2	188	shr edx,2
191	mov ecx,edx	189	mov ecx,edx
192		190
193	bt ecx,31	191	bt ecx,31
194	jc .fun_e	192	jc .fun_e
195	mov esi,edi	193	mov esi,edi
196	add esi,4	194	add esi,4
197	mov edx,[edi] ;á®åà ¥¨¥ â¥ªãé¥£® ãª § â¥«ï	195	mov edx,[edi] ;á®åà ¥¨¥ â¥ªãé¥£® ãª § â¥«ï
198	cld	196	cld
199	rep movsd	197	rep movsd
200	mov [edi],edx ;¢®ááâ ®¢«¥¨¥ â¥ªãé¥£® ãª § â¥«ï (¢ ª®æ¥ ¬ áá¨¢ )	198	mov [edi],edx ;¢®ááâ ®¢«¥¨¥ â¥ªãé¥£® ãª § â¥«ï (¢ ª®æ¥ ¬ áá¨¢ )
201	.fun_e:	199	.fun_e:
202	popad	200	popad
203	ret	201	ret
204	endp	202	endp
205		203
206	if debug	204	if debug
207	align 4	205	align 4
208	proc but_test_pole, pole:dword	206	proc but_test_pole, pole:dword
209	pushad	207	pushad
210	stdcall [buf2d_clear], buf_0, [buf_0.color]	208	stdcall [buf2d_clear], buf_0, [buf_0.color]
211		209
212	mov edi,dword[pole]	210	mov edi,dword[pole]
213	stdcall pole_paint,edi	211	stdcall pole_paint,edi
214	mov ebx,5	212	mov ebx,5
215		213
216	mov esi,pole_index	214	mov esi,pole_index
217	mov ecx,[esi]	215	mov ecx,[esi]
218		216
219	mov eax,pole_b_sort	217	mov eax,pole_b_sort
220	mov edi,open_file_lif	218	mov edi,open_file_lif
221	stdcall convert_int_to_str	219	stdcall convert_int_to_str
222	stdcall [buf2d_draw_text], buf_0, buf_font,edi,5,ebx,[shem_colors] ;à¨áã¥¬ b_sort	220	stdcall [buf2d_draw_text], buf_0, buf_font,edi,5,ebx,[shem_colors] ;à¨áã¥¬ b_sort
223	add ebx,18	221	add ebx,18
224		222
225	mov eax,[esi]	223	mov eax,[esi]
226	add esi,4	224	add esi,4
227	stdcall convert_int_to_str	225	stdcall convert_int_to_str
228	stdcall [buf2d_draw_text], buf_0, buf_font,edi,5,ebx,[shem_colors] ;à¨áã¥¬ ç¨á«® â®ç¥ª	226	stdcall [buf2d_draw_text], buf_0, buf_font,edi,5,ebx,[shem_colors] ;à¨áã¥¬ ç¨á«® â®ç¥ª
229	add ebx,9	227	add ebx,9
230		228
231	cmp ecx,1	229	cmp ecx,1
232	jl .end_dr	230	jl .end_dr
233	cld	231	cld
234	@@:	232	@@:
235	mov eax,[esi]	233	mov eax,[esi]
236	add esi,4	234	add esi,4
237	stdcall convert_int_to_str	235	stdcall convert_int_to_str
238	stdcall [buf2d_draw_text], buf_0, buf_font,edi,5,ebx,[color_captions] ;à¨áã¥¬ ãª § â¥«¨ ¬ áá¨¢ë â®ç¥ª	236	stdcall [buf2d_draw_text], buf_0, buf_font,edi,5,ebx,[color_captions] ;à¨áã¥¬ ãª § â¥«¨ ¬ áá¨¢ë â®ç¥ª
239	add ebx,9	237	add ebx,9
240	loop @b	238	loop @b
241	.end_dr:	239	.end_dr:
242	mov ecx,4	240	mov ecx,4
243	cld	241	cld
244	@@:	242	@@:
245	mov eax,[esi]	243	mov eax,[esi]
246	add esi,4	244	add esi,4
247	stdcall convert_int_to_str	245	stdcall convert_int_to_str
248	stdcall [buf2d_draw_text], buf_0, buf_font,edi,5,ebx,[color_border] ;à¨áã¥¬ 4 áâà®ª¨ ãª § â¥«¥©	246	stdcall [buf2d_draw_text], buf_0, buf_font,edi,5,ebx,[color_border] ;à¨áã¥¬ 4 áâà®ª¨ ãª § â¥«¥©
249	add ebx,9	247	add ebx,9
250	loop @b	248	loop @b
251		249
252	stdcall [buf2d_draw], buf_0	250	stdcall [buf2d_draw], buf_0
253		251
254	;call redraw_pole	252	;call redraw_pole
255	popad	253	popad
256	ret	254	ret
257	endp	255	endp
258	end if	256	end if
259		257
260	;output:	258	;output:
261	; eax - index	259	; eax - index
262	align 4	260	align 4
263	proc pole_cell_find uses edi, pole:dword, x:dword, y:dword	261	proc pole_cell_find uses edi, pole:dword, x:dword, y:dword
264	mov edi,dword[pole]	262	mov edi,dword[pole]
265		263
266	mov eax,pole_index	264	mov eax,pole_index
267	cmp dword[eax],0	265	cmp dword[eax],0
268	jne @f	266	jne @f
269	xor eax,eax ;if(!fristC) return 0;	267	xor eax,eax ;if(!fristC) return 0;
270	jmp .fun_e	268	jmp .fun_e
271	@@:	269	@@:
272		270
273	xor eax,eax ;fnd=0;	271	xor eax,eax ;fnd=0;
274	cmp pole_b_sort,0	272	cmp pole_b_sort,0
275	je @f	273	je @f
276	stdcall pole_bin_find, pole_index, [x],[y], pole_b_sort ;i=BinFind(pole_index, x,y, pole_b_sort);	274	stdcall pole_bin_find, pole_index, [x],[y], pole_b_sort ;i=BinFind(pole_index, x,y, pole_b_sort);
277	cmp eax,0	275	cmp eax,0
278	je @f	276	je @f
279	shl eax,2	277	shl eax,2
280	add eax,pole_index	278	add eax,pole_index
281	mov eax,dword[eax] ;if(i) fnd=pole_index[i];	279	mov eax,dword[eax] ;if(i) fnd=pole_index[i];
282	jmp .fun_e	280	jmp .fun_e
283	@@:	281	@@:
284		282
285	cmp eax,0	283	cmp eax,0
286	jne @f ;¯®¨áª ïç¥©ª¨ § ¡¨ àë¬ ¤¥à¥¢®¬	284	jne @f ;¯®¨áª ïç¥©ª¨ § ¡¨ àë¬ ¤¥à¥¢®¬
287	push ebx ecx edx esi	285	push ebx ecx edx esi
288	;ebx -> i	286	;ebx -> i
289	;ecx -> firstC	287	;ecx -> firstC
290	;edx -> &pole_index[i]	288	;edx -> &pole_index[i]
291	;esi -> cell[pole_index[i]]	289	;esi -> cell[pole_index[i]]
292	mov ecx,pole_index	290	mov ecx,pole_index
293	mov ebx,pole_b_sort	291	mov ebx,pole_b_sort
294	mov edx,ebx	292	mov edx,ebx
295	shl edx,2	293	shl edx,2
296	add edx,ecx	294	add edx,ecx
297	mov ecx,dword[ecx]	295	mov ecx,dword[ecx]
298	.cycle_b: ;for(i=pole_b_sort+1;i<=fristC;i++)	296	.cycle_b: ;for(i=pole_b_sort+1;i<=fristC;i++)
299	inc ebx	297	inc ebx
300	cmp ebx,ecx	298	cmp ebx,ecx
301	jg .not_found	299	jg .not_found
302	add edx,4	300	add edx,4
303	get_cell_offset esi,dword[edx]	301	get_cell_offset esi,dword[edx]
304	mov eax,dword[x]	302	mov eax,dword[x]
305	cmp dword[esi],eax ;+0 = .x	303	cmp dword[esi],eax ;+0 = .x
306	jne .if_e	304	jne .if_e
307	mov eax,dword[y]	305	mov eax,dword[y]
308	cmp dword[esi+4],eax ;+4 = .y	306	cmp dword[esi+4],eax ;+4 = .y
309	jne .if_e	307	jne .if_e
310	;if(cell[pole_index[i]].x==x && cell[pole_index[i]].y==y){	308	;if(cell[pole_index[i]].x==x && cell[pole_index[i]].y==y){
311	mov eax,dword[edx] ;fnd=pole_index[i];	309	mov eax,dword[edx] ;fnd=pole_index[i];
312	jmp .cycle_e ;break;	310	jmp .cycle_e ;break;
313	.if_e:	311	.if_e:
314	jmp .cycle_b	312	jmp .cycle_b
315	.not_found:	313	.not_found:
316	xor eax,eax ;¢®ááâ ¢«¨¢ ¥¬ ã«¥¢®¥ § ç¥¨¥ ¥á«¨ ¥ è«¨ ïç¥©ªã (¢ æ¨ª«¥ eax ¯®àâ¨âáï ¯à¨ ¯à®¢¥àª¥ ª®®à¤¨ â)	314	xor eax,eax ;¢®ááâ ¢«¨¢ ¥¬ ã«¥¢®¥ § ç¥¨¥ ¥á«¨ ¥ è«¨ ïç¥©ªã (¢ æ¨ª«¥ eax ¯®àâ¨âáï ¯à¨ ¯à®¢¥àª¥ ª®®à¤¨ â)
317	.cycle_e:	315	.cycle_e:
318	pop esi edx ecx ebx	316	pop esi edx ecx ebx
319	@@:	317	@@:
320	.fun_e:	318	.fun_e:
321	ret	319	ret
322	endp	320	endp
323		321
324	;output:	322	;output:
325	; eax - index	323	; eax - index
326	align 4	324	align 4
327	proc pole_bin_find uses ebx ecx edx edi, mas:dword, fx:dword, fy:dword, k:dword	325	proc pole_bin_find uses ebx ecx edx edi, mas:dword, fx:dword, fy:dword, k:dword
328	xor eax,eax	326	xor eax,eax
329	mov ebx,1 ;ebx - ¬ ªá¨¬ «ìë© ¯®àï¤®ª ¤«ï ¤¥à¥¢	327	mov ebx,1 ;ebx - ¬ ªá¨¬ «ìë© ¯®àï¤®ª ¤«ï ¤¥à¥¢
330	@@:	328	@@:
331	cmp dword[k],ebx	329	cmp dword[k],ebx
332	jle @f ;while(k>por)	330	jle @f ;while(k>por)
333	shl ebx,1 ;por<<=1;	331	shl ebx,1 ;por<<=1;
334	jmp @b	332	jmp @b
335	@@:	333	@@:
336	cmp dword[k],ebx	334	cmp dword[k],ebx
337	jge @f ;if(k	335	jge @f ;if(k
338	shr ebx,1 ;por>>=1;	336	shr ebx,1 ;por>>=1;
339	@@:	337	@@:
340	mov ecx,ebx ;i=por;	338	mov ecx,ebx ;i=por;
341		339
342	;ecx -> i	340	;ecx -> i
343	;edi -> mas[i]	341	;edi -> mas[i]
344	.cycle_b: ;do{	342	.cycle_b: ;do{
345	shr ebx,1 ;por>>=1;	343	shr ebx,1 ;por>>=1;
346		344
347	mov edi,ecx	345	mov edi,ecx
348	shl edi,2	346	shl edi,2
349	add edi,dword[mas]	347	add edi,dword[mas]
350	;if(compare_cells_mb(mas[i],fx,fy)){	348	;if(compare_cells_mb(mas[i],fx,fy)){
351	stdcall pole_compare_cells_mb_coords, dword[edi],[fx],[fy]	349	stdcall pole_compare_cells_mb_coords, dword[edi],[fx],[fy]
352	cmp dl,0	350	cmp dl,0
353	je .if_u0_e	351	je .if_u0_e
354	@@: ;while(i+por>k)	352	@@: ;while(i+por>k)
355	mov edx,ecx	353	mov edx,ecx
356	add edx,ebx	354	add edx,ebx
357	cmp edx,dword[k] ;i+por>k	355	cmp edx,dword[k] ;i+por>k
358	jle @f	356	jle @f
359	shr ebx,1 ;por>>=1;	357	shr ebx,1 ;por>>=1;
360	jmp @b	358	jmp @b
361	@@:	359	@@:
362	add ecx,ebx ;i+=por;	360	add ecx,ebx ;i+=por;
363	jmp .if_e	361	jmp .if_e
364	.if_u0_e:	362	.if_u0_e:
365	;else if(compare_cells_bm(mas[i],fx,fy))i-=por;	363	;else if(compare_cells_bm(mas[i],fx,fy))i-=por;
366	stdcall pole_compare_cells_bm_coords, dword[edi],[fx],[fy]	364	stdcall pole_compare_cells_bm_coords, dword[edi],[fx],[fy]
367	cmp dl,0	365	cmp dl,0
368	je .if_u1_e	366	je .if_u1_e
369	sub ecx,ebx	367	sub ecx,ebx
370	jmp .if_e	368	jmp .if_e
371	.if_u1_e:	369	.if_u1_e:
372	;else { m=i; por=0; }	370	;else { m=i; por=0; }
373	mov eax,ecx	371	mov eax,ecx
374	xor ebx,ebx	372	xor ebx,ebx
375	.if_e:	373	.if_e:
376	cmp ebx,0	374	cmp ebx,0
377	jne .cycle_b ;}while(por);	375	jne .cycle_b ;}while(por);
378		376
379	ret	377	ret
380	endp	378	endp
381		379
382	;á¤¢¨£ ¢á¥å ïç¥¥ª (¨ ®¡ê¥ªâ®¢)	380	;á¤¢¨£ ¢á¥å ïç¥¥ª (¨ ®¡ê¥ªâ®¢)
383	align 4	381	align 4
384	proc pole_move_all, pole:dword, m_d_x:dword, m_d_y:dword	382	proc pole_move_all, pole:dword, m_d_x:dword, m_d_y:dword
385	pushad	383	pushad
386	mov edi,dword[pole]	384	mov edi,dword[pole]
387	mov edx,[m_d_x]	385	mov edx,[m_d_x]
388	mov esi,[m_d_y]	386	mov esi,[m_d_y]
389		387
390	mov eax,pole_index	388	mov eax,pole_index
391	cmp dword[eax],0	389	cmp dword[eax],0
392	je .end_0 ;¥á«¨ ¥â ïç¥¥ª (¯à®¢®¤®¢) â® ¢ëå®¤	390	je .end_0 ;¥á«¨ ¥â ïç¥¥ª (¯à®¢®¤®¢) â® ¢ëå®¤
393		391
394	mov ecx,dword[eax]	392	mov ecx,dword[eax]
395	cld	393	cld
396	@@: ;æ¨ª« ¯® ¢á¥¬ ïç¥©ª ¬	394	@@: ;æ¨ª« ¯® ¢á¥¬ ïç¥©ª ¬
397	add eax,4	395	add eax,4
398	mov ebx,[eax]	396	mov ebx,[eax]
399	imul ebx,sizeof.Cell	397	imul ebx,sizeof.Cell
400	add ebx,pole_data	398	add ebx,pole_data
401		399
402	add dword[ebx+offs_cell_x],edx	400	add dword[ebx+offs_cell_x],edx
403	add dword[ebx+offs_cell_y],esi	401	add dword[ebx+offs_cell_y],esi
404	loop @b	402	loop @b
405	.end_0:	403	.end_0:
406		404
407	;æ¨ª« ¯® «®£¨ç¥áª¨¬ í«¥¬¥â ¬ ¨ ¯®¤¯¨áï¬	405	;æ¨ª« ¯® «®£¨ç¥áª¨¬ í«¥¬¥â ¬ ¨ ¯®¤¯¨áï¬
408	stdcall dword[tl_node_poi_get_info], tree1,0	406	stdcall dword[tl_node_poi_get_info], tree1,0
409	@@:	407	@@:
410	cmp eax,0	408	cmp eax,0
411	je .end_1	409	je .end_1
412	cmp word[eax],el_icon_elems ;¯®«ãç¥¨¥ ç¥à¥§ eax â¨¯ ¨ª®ª¨	410	cmp word[eax],el_icon_elems ;¯®«ãç¥¨¥ ç¥à¥§ eax â¨¯ ¨ª®ª¨
413	je .mov_1	411	je .mov_1
414	cmp word[eax],el_icon_captions	412	cmp word[eax],el_icon_captions
415	je .mov_1	413	je .mov_1
416	jmp .end_mov_1	414	jmp .end_mov_1
417	.mov_1:	415	.mov_1:
418	mov ecx,eax	416	mov ecx,eax
419	stdcall [tl_node_poi_get_data], tree1,eax	417	stdcall [tl_node_poi_get_data], tree1,eax
420	add [eax],edx ;coord x	418	add [eax],edx ;coord x
421	add [eax+4],esi ;coord y	419	add [eax+4],esi ;coord y
422	mov eax,ecx	420	mov eax,ecx
423	.end_mov_1:	421	.end_mov_1:
424	stdcall dword[tl_node_poi_get_next_info], tree1,eax ;¯¥à¥å®¤¨¬ ª á«¥¤ãé¥¬ã ã§«ã	422	stdcall dword[tl_node_poi_get_next_info], tree1,eax ;¯¥à¥å®¤¨¬ ª á«¥¤ãé¥¬ã ã§«ã
425	jmp @b	423	jmp @b
426	.end_1:	424	.end_1:
427		425
428	popad	426	popad
429	ret	427	ret
430	endp	428	endp
431		429
432	;output:	430	;output:
433	; dl	431	; dl
434	align 4	432	align 4
435	proc pole_compare_cells_bm_coords uses eax ebx ecx, i0:dword, fx:dword, fy:dword	433	proc pole_compare_cells_bm_coords uses eax ebx ecx, i0:dword, fx:dword, fy:dword
436	get_cell_offset eax,[i0]	434	get_cell_offset eax,[i0]
437	;eax -> cell[i0]	435	;eax -> cell[i0]
438	mov ebx,dword[fx]	436	mov ebx,dword[fx]
439	cmp dword[eax],ebx	437	cmp dword[eax],ebx
440	jle @f	438	jle @f
441	mov dl,1	439	mov dl,1
442	jmp .fun_e	440	jmp .fun_e
443	@@:	441	@@:
444	mov ecx,dword[fy]	442	mov ecx,dword[fy]
445	cmp dword[eax+4],ecx	443	cmp dword[eax+4],ecx
446	jle @f	444	jle @f
447	cmp dword[eax],ebx	445	cmp dword[eax],ebx
448	jne @f	446	jne @f
449	mov dl,1	447	mov dl,1
450	jmp .fun_e	448	jmp .fun_e
451	@@:	449	@@:
452	xor dl,dl	450	xor dl,dl
453	.fun_e:	451	.fun_e:
454	ret	452	ret
455	endp	453	endp
456		454
457	;output:	455	;output:
458	; dl	456	; dl
459	align 4	457	align 4
460	proc pole_compare_cells_mb_coords uses eax ebx ecx, i0:dword, fx:dword, fy:dword	458	proc pole_compare_cells_mb_coords uses eax ebx ecx, i0:dword, fx:dword, fy:dword
461	get_cell_offset eax,[i0]	459	get_cell_offset eax,[i0]
462	;eax -> cell[i0]	460	;eax -> cell[i0]
463	mov ebx,dword[fx]	461	mov ebx,dword[fx]
464	cmp dword[eax],ebx	462	cmp dword[eax],ebx
465	jge @f	463	jge @f
466	mov dl,1	464	mov dl,1
467	jmp .fun_e	465	jmp .fun_e
468	@@:	466	@@:
469	mov ecx,dword[fy]	467	mov ecx,dword[fy]
470	cmp dword[eax+4],ecx	468	cmp dword[eax+4],ecx
471	jge @f	469	jge @f
472	cmp dword[eax],ebx	470	cmp dword[eax],ebx
473	jne @f	471	jne @f
474	mov dl,1	472	mov dl,1
475	jmp .fun_e	473	jmp .fun_e
476	@@:	474	@@:
477	xor dl,dl	475	xor dl,dl
478	.fun_e:	476	.fun_e:
479	ret	477	ret
480	endp	478	endp
481		479
482	;output:	480	;output:
483	; dl	481	; dl
484	align 4	482	align 4
485	proc pole_compare_cells_bm, i0:dword, i1:dword	483	proc pole_compare_cells_bm, i0:dword, i1:dword
486	push eax ebx ecx	484	push eax ebx ecx
487	get_cell_offset eax,[i0] ;eax -> cell[i0]	485	get_cell_offset eax,[i0] ;eax -> cell[i0]
488	get_cell_offset ebx,[i1] ;ebx -> cell[i1]	486	get_cell_offset ebx,[i1] ;ebx -> cell[i1]
489	mov ecx,dword[ebx] ;+0 = .x	487	mov ecx,dword[ebx] ;+0 = .x
490	cmp dword[eax],ecx	488	cmp dword[eax],ecx
491	jle @f ;x0>x1	489	jle @f ;x0>x1
492	mov dl,1	490	mov dl,1
493	jmp .fun_e	491	jmp .fun_e
494	@@:	492	@@:
495	jne @f ;x0==x1	493	jne @f ;x0==x1
496	mov ecx,dword[ebx+4] ;+4 = .y	494	mov ecx,dword[ebx+4] ;+4 = .y
497	cmp dword[eax+4],ecx	495	cmp dword[eax+4],ecx
498	jle @f ;y0>y1	496	jle @f ;y0>y1
499	mov dl,1	497	mov dl,1
500	jmp .fun_e	498	jmp .fun_e

Subversion Repositories Kolibri OS

(root)/programs/media/log_el/trunk/le_pole.inc – Rev 5916 → 6213