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

Subversion Repositories Kolibri OS

(root)/programs/media/log_el/trunk/le_pole.inc – Rev 2523 → 2574