//it appears to me that when altering the
	//vertices buffer all that happens is 
	//the vertices alone are manipulated 
	//and not the normals because
	//when i tested your code it became
	//aparent to me that ent_fixnormals resets the vertices
	//back to their original states (which is kinda weird (bug)?)
	for(i=0; i<ent_status(test,0); i++)
		{
			vbuff0[i].y += random(10)-5;	
		}
	//but when manipulating the normals directly 
	//ent_fixnormals then fixes the altered normals
	for(i=0; i<ent_status(test,0); i++)
		{	
			vbuff0[i].nx += random(10)-5;	
		}

LPD3DXMESH dx_mesh;
	for (i=0; i<(var)(ent_status(terrain_entity,16)); i++)
		{
			dx_mesh = ent_getmesh(terrain_entity,i,0);		// ent , chunk start with 0 , lod
			D3DXComputeNormals(dx_mesh,NULL);
			ent_setmesh(terrain_entity,dx_mesh,i,0);			
		}

c_setminmax(terrain_entity);
	wait(1);
	c_updatehull(terrain_entity,0);
	//	c_updatehull(terrain_entity,my.frame);
	wait(3);	
		
	for (i=1; i<=(var)(ent_status(terrain_entity,0)); i++)
		{	
			CONTACT* c = ent_getvertex(terrain_entity,NULL,i);   			// vertex number begins with 1 !			
			c_trace( vector((var)c.v.x,(var)c.v.z,vgroundmax.z+500), vector((var)c.v.x,(var)c.v.z,vgroundmin.z-500), IGNORE_ME | IGNORE_SPRITES | IGNORE_MODELS | IGNORE_MAPS | IGNORE_PASSABLE ); 			
			if (HIT_TARGET)	
				{
					// normal 
//					c.v.nx = (float)normal.x; 			
//					c.v.nz = (float)normal.y; 
//					c.v.ny = (float)normal.z; 	
					// or the same with hit
					c.v.nx = (float)hit.nx; 			
					c.v.nz = (float)hit.ny; 
					c.v.ny = (float)hit.nz; 																													
					ent_setvertex(terrain_entity,c,i);
					// or more precisely it should be the average of normals of all neighbouring faceces !!! 
					// it is stored in hmp in an approximated value of 162 stored normal vectors !!!
				}
			
		}

normalize ( vec_cross ( vec_diff ( B.x, A.x ), vec_diff ( C.x, A.x ) ) );

#include <acknex.h>
#include <default.c>

D3DVERTEX *vbuff0;
short *tbuff;

VECTOR vtemp;

TEXT* debug_txt =	
{  pos_x = 10;	  pos_y = 10;	  strings = 5;		font="courier#18";		flags = SHOW;	}


function show_normals ( ENTITY *ent )
{
	D3DVERTEX *vb;
	int vnum = ent_status ( ent, 0 );
	int i;
	
	ent_buffers ( ent, 0, 0, &vb, NULL, NULL );
	
	for ( i=0; i<vnum; i++ )
	{
		vec_set ( vtemp, vector ( vb[i].nx, vb[i].nz, vb[i].ny ) );
		vec_scale ( vtemp, 10 );
		vec_add ( vtemp, vector ( vb[i].x, vb[i].z, vb[i].y ) );
		
		draw_line3d ( vector ( vb[i].x, vb[i].z, vb[i].y ), COLOR_WHITE, 0 );
		draw_line3d ( vector ( vb[i].x, vb[i].z, vb[i].y ), COLOR_WHITE, 100 );
		draw_line3d ( vtemp, COLOR_RED, 100 );
		draw_line3d ( vtemp, COLOR_RED, 0 );
	}
}

function true_fixnormals ( ENTITY *ent )
{
	D3DVERTEX *vb;
	short *tb;
	long *at;
	int i, ii;
	VECTOR vNormal, vOldNormal, v1, v2, v3;
	
	int tnum = ent_status ( ent, 4 );
	int vnum = ent_status ( ent, 1 );
	
	ent_buffers ( ent, 0, 0, &vb, &tb, &at );
	
	for ( i=0; i<vnum; i++ ) // reset normals
	{
		vb[i].nx = vb[i].ny = vb[i].nz = 0;
	}
	
	for ( i=0; i<tnum*3; i+=3 ) // compute normals
	{
		vec_set ( v1, vector ( vb[tb[i]].x, vb[tb[i]].z, vb[tb[i]].y ) ); // we can't operate with floats as vectors
		vec_set ( v2, vector ( vb[tb[i+1]].x, vb[tb[i+1]].z, vb[tb[i+1]].y ) );
		vec_set ( v3, vector ( vb[tb[i+2]].x, vb[tb[i+2]].z, vb[tb[i+2]].y ) );
		
		vec_cross ( vNormal, vec_diff ( NULL, v3, v1 ), vec_diff ( NULL, v2, v1 ) );
		vec_normalize ( vNormal, 1 );
		
		for ( ii=0; ii<3; ii++ ) // add the new normal to each vertex
		{
			vec_set ( vOldNormal, vector ( vb[tb[i+ii]].nx, vb[tb[i+ii]].nz, vb[tb[i+ii]].ny ) );
			vec_add ( vOldNormal, vNormal );
			vec_normalize ( vOldNormal, 1 );
			vb[tb[i+ii]].nx = vOldNormal.x;
			vb[tb[i+ii]].ny = vOldNormal.z;
			vb[tb[i+ii]].nz = vOldNormal.y;
		}
	}
}

void main()
{
	int i=0;
	
	random_seed ( 0 );
	
	wait(1);
	level_load(NULL);
	wait(1);
	
	ENTITY* test = ent_create("ball.mdl", nullvector, NULL);
	camera.x = -300;
	camera.z = 300;
	camera.tilt = -45;
	
	while ( !key_space )
	{
		draw_text ( "Press space to continue...", 10, 10, COLOR_WHITE );
		show_normals ( test );
		wait(1);
	}
	
	ent_buffers ( test, 0,0, &vbuff0, NULL, NULL );
	
	for(i=0; i<ent_status(test,0); i++)		{	vbuff0[i].y += random(10)-5;	vbuff0[i].x += random(10)-5;	vbuff0[i].z += random(10)-5;	}
	true_fixnormals ( test );
	
	while ( 1 )
	{
		show_normals ( test );
		wait(1);
	}
}

#define PRAGMA_API D3DXComputeNormals;D3DX9_30!D3DXComputeNormals
void __stdcall D3DXComputeNormals(void* pMesh, DWORD *pAdjacency);
void ent_normals(ENTITY* ent)
{	void* mesh_ptr;	D3DXComputeNormals(mesh_ptr=ent_getmesh(ent,0,0), 0);
	ent_setmesh(ent, mesh_ptr, 0, 0);                                   }