for (iterate=0;iterate<vertices1;iterate++)	
		{
			temp1.x=vertex_buffer1[iterate].x;
			temp1.y=vertex_buffer1[iterate].z;
			temp1.z=vertex_buffer1[iterate].y;
			vec_rotate(temp1.x, source1.pan);
			
			merged_vertex_buffer[iterate].x=temp1.x;
			merged_vertex_buffer[iterate].y=temp1.z;
			merged_vertex_buffer[iterate].z=temp1.y;
			
			merged_vertex_buffer[iterate].u1=vertex_buffer1[iterate].u1;
			merged_vertex_buffer[iterate].v1=vertex_buffer1[iterate].v1;
			merged_vertex_buffer[iterate].u2=vertex_buffer1[iterate].u2;
			merged_vertex_buffer[iterate].v2=vertex_buffer1[iterate].v2;
			
		}
		
		offsetv+=vertices1;
		
		for (iterate=0;iterate<vertices2;iterate++)	
		{
			temp1.x=vertex_buffer1[iterate].x;
			temp1.y=vertex_buffer1[iterate].z;
			temp1.z=vertex_buffer1[iterate].y;
			vec_rotate(temp1.x, source2.pan);
			
			merged_vertex_buffer[iterate+offsetv].x=temp1.x;
			merged_vertex_buffer[iterate+offsetv].y=temp1.z;
			merged_vertex_buffer[iterate+offsetv].z=temp1.y;
			
			merged_vertex_buffer[iterate+offsetv].u1=vertex_buffer2[iterate].u1;
			merged_vertex_buffer[iterate+offsetv].v1=vertex_buffer2[iterate].v1;
			merged_vertex_buffer[iterate+offsetv].u2=vertex_buffer2[iterate].u2;
			merged_vertex_buffer[iterate+offsetv].v2=vertex_buffer2[iterate].v2;
			
		}

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


function demo_init()
{
//	vec_set(sky_color,vector(10,0,0));
 	video_switch(10,32,0);

	vec_set(camera.x,vector(0,-400, 100));
 	camera.arc=90;
 	camera.pan=90;
 	camera.clip_near=1;

   fps_min=60;
 
 	def_move();
 	def_debug();
 	def_debug();
}

VECTOR temp1;
VECTOR center;

ENTITY* merge_ent(ENTITY* source1,ENTITY* source2)
{
	int vertices1=ent_status(source1,1);
	int vertices2=ent_status(source2,1);
	
	LPD3DXMESH mesh1;
	
	short *triangle_buffer1;
	short *triangle_buffer2;
	
	D3DVERTEX* vertex_buffer1;
	D3DVERTEX* vertex_buffer2;
	
	int triangles1;
	int triangles2;

	triangles1=ent_buffers(source1,0,0,&vertex_buffer1,&triangle_buffer1,NULL);
	triangles2=ent_buffers(source2,0,0,&vertex_buffer2,&triangle_buffer2,NULL);
	
	short* merged_triangle_buffer;
	D3DVERTEX* merged_vertex_buffer;

	int merged_triangles=triangles1+triangles2;
	int merged_vertices=vertices1+vertices2;
	
	int iterate;
	int offsetv=0;
	int offsett=0;
	
	vec_lerp(center.x, source1.x, source2.x, 0.5);//set a center between the two models origins
	
	D3DXCreateMesh(merged_triangles,merged_vertices,D3DXMESH_MANAGED,pvertexdecl,pd3ddev,&mesh1);
	if(mesh1!=NULL)
	{
		mesh1->LockVertexBuffer(0, (void**)&merged_vertex_buffer);
		mesh1->LockIndexBuffer (0, (void**)&merged_triangle_buffer);
		
		for (iterate=0;iterate<vertices1;iterate++)	
		{
			temp1.x=vertex_buffer1[iterate].x;
			temp1.y=vertex_buffer1[iterate].z;
			temp1.z=vertex_buffer1[iterate].y;
			
			vec_rotate(temp1.x, source1.pan);
			vec_scale(temp1.x, source1.scale_x);
			
			temp1.x *=source1.scale_x;
			temp1.y *=source1.scale_y;
			temp1.z *=source1.scale_z;
			
			temp1.x +=source1.x - center.x;
			temp1.y +=source1.y - center.y;
			temp1.z +=source1.z - center.z;
			
			merged_vertex_buffer[iterate].x=temp1.x+center.x;
			merged_vertex_buffer[iterate].y=temp1.z+center.z;
			merged_vertex_buffer[iterate].z=temp1.y+center.y;
			
			merged_vertex_buffer[iterate].u1=vertex_buffer1[iterate].u1;
			merged_vertex_buffer[iterate].v1=vertex_buffer1[iterate].v1;
			merged_vertex_buffer[iterate].u2=vertex_buffer1[iterate].u2;
			merged_vertex_buffer[iterate].v2=vertex_buffer1[iterate].v2;
			
		}
		
		offsetv+=vertices1;
		
		for (iterate=0;iterate<vertices2;iterate++)	
		{
			temp1.x=vertex_buffer1[iterate].x;
			temp1.y=vertex_buffer1[iterate].z;
			temp1.z=vertex_buffer1[iterate].y;
			
			vec_rotate(temp1.x, source2.pan);
			vec_scale(temp1.x, source2.scale_x);
			
			temp1.x *=source2.scale_x;
			temp1.y *=source2.scale_y;
			temp1.z *=source2.scale_z;
			
			temp1.x +=source2.x - center.x;
			temp1.y +=source2.y - center.y;
			temp1.z +=source2.z - center.z;
			
			merged_vertex_buffer[iterate+offsetv].x=temp1.x+center.x;
			merged_vertex_buffer[iterate+offsetv].y=temp1.z+center.z;
			merged_vertex_buffer[iterate+offsetv].z=temp1.y+center.y;
			
			merged_vertex_buffer[iterate+offsetv].u1=vertex_buffer2[iterate].u1;
			merged_vertex_buffer[iterate+offsetv].v1=vertex_buffer2[iterate].v1;
			merged_vertex_buffer[iterate+offsetv].u2=vertex_buffer2[iterate].u2;
			merged_vertex_buffer[iterate+offsetv].v2=vertex_buffer2[iterate].v2;
			
		}
		
		for (iterate=0;iterate<triangles1;iterate++)	
		{
			merged_triangle_buffer[iterate*3]=triangle_buffer1[iterate*3];
			merged_triangle_buffer[iterate*3+1]=triangle_buffer1[iterate*3+1];
			merged_triangle_buffer[iterate*3+2]=triangle_buffer1[iterate*3+2];
		}

		offsett+=triangles1;
		
		for (iterate=0;iterate<triangles2;iterate++)	
		{
			merged_triangle_buffer[(iterate+offsett)*3]=triangle_buffer2[iterate*3]+offsetv;
			merged_triangle_buffer[(iterate+offsett)*3+1]=triangle_buffer2[iterate*3+1]+offsetv;
			merged_triangle_buffer[(iterate+offsett)*3+2]=triangle_buffer2[iterate*3+2]+offsetv;
		}
	
		mesh1->UnlockVertexBuffer();
		mesh1->UnlockIndexBuffer();
	
		ENTITY* temp=ent_create(CUBE_MDL,nullvector,0);
		BMAP* bmp_source1 = ent_getskin(source1, 1);
		BMAP* bmp_source2 = ent_getskin(source2, 1);
		ent_setmesh(temp,mesh1,0,0);
		ent_setskin(temp, bmp_source1, 1);
		ent_setskin(temp, bmp_source2, 2);
		return temp;
	}
	return NULL;
}

function main()
{
	level_load("");
	wait(4);
	demo_init();
	
	ENTITY* ent1=ent_create("p.mdl",nullvector,0);
	ENTITY* ent2=ent_create("p.mdl",vector(120,0,0),0);
	ent2.pan =45;
	ent2.roll =20;
	ent2.tilt =15;
	ent1.tilt =10;
	ent1.scale_z = 0.2;

	ENTITY* merged=merge_ent(ent1,ent2);

	merged.z+=200;//set this to zero, if you wanna see whether the result is identical in angle, scale and position
	
//	ent_remove(dozer1);
//	wait(1);
//	ent_remove(dozer2);
//	wait(1);

	while(1)
	{
//		merged.pan+=1*time_step;
		wait(1);
	}
	
}

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


function demo_init()
{
 	video_switch(10,32,0);

	vec_set(camera.x,vector(0,-400, 100));
 	camera.arc=90;
 	camera.pan=90;
 	camera.clip_near=1;

   fps_min=60;
 
 	def_move();
 	def_move();
 	def_debug();
 	def_debug();
}

VECTOR temp1;

ENTITY* merge_ent(ENTITY* source1,ENTITY* source2)
{
	int vertices_source1=ent_status(source1,1);
	int vertices_source2=ent_status(source2,1);
	
	LPD3DXMESH mesh;
	
	short *tbuffer_source1;
	short *tbuffer_source2;
	
	D3DVERTEX* vbuffer_source1;
	D3DVERTEX* vbuffer_source2;
	
	int triangles_source1;
	int triangles_source2;

	triangles_source1=ent_buffers(source1,0,0,&vbuffer_source1,&tbuffer_source1,NULL);
	triangles_source2=ent_buffers(source2,0,0,&vbuffer_source2,&tbuffer_source2,NULL);
	
	short* merged_tbuffer;
	D3DVERTEX* merged_vbuffer;

	int merged_triangles=triangles_source1+triangles_source2;
	int merged_vertices=vertices_source1+vertices_source2;
	
	int iterate;
	int offsetv=0;
	int offsett=0;
	
	D3DXCreateMesh(merged_triangles,merged_vertices,D3DXMESH_MANAGED,pvertexdecl,pd3ddev,&mesh);
	if(mesh!=NULL)
	{
		mesh->LockVertexBuffer(0, (void**)&merged_vbuffer);
		mesh->LockIndexBuffer (0, (void**)&merged_tbuffer);
		
		for (iterate=0;iterate<vertices_source1;iterate++)	
		{
			temp1.x=source1.x+vbuffer_source1[iterate].x*source1.scale_x;
			temp1.y=source1.y+vbuffer_source1[iterate].y*source1.scale_z;
			temp1.z=source1.z+vbuffer_source1[iterate].z*source1.scale_y;
			
			VECTOR final;
			final.x=temp1.x;
			final.y=temp1.z;
			final.z=temp1.y;
			vec_rotate(final.x,source1.pan);

			merged_vbuffer[iterate].x=final.x;
			merged_vbuffer[iterate].y=final.z;
			merged_vbuffer[iterate].z=final.y;
			
			merged_vbuffer[iterate].nx=vbuffer_source1[iterate].nx;
			merged_vbuffer[iterate].nz=vbuffer_source1[iterate].ny;
			merged_vbuffer[iterate].ny=vbuffer_source1[iterate].nz;

			merged_vbuffer[iterate].u1=vbuffer_source1[iterate].u1;
			merged_vbuffer[iterate].v1=vbuffer_source1[iterate].v1;
			merged_vbuffer[iterate].u2=vbuffer_source1[iterate].u2;
			merged_vbuffer[iterate].v2=vbuffer_source1[iterate].v2;
			
		}
		
		offsetv+=vertices_source1;
		
		for (iterate=0;iterate<vertices_source2;iterate++)	
		{
			temp1.x=source2.x+vbuffer_source2[iterate].x*source2.scale_x;
			temp1.y=source2.y+vbuffer_source2[iterate].y*source2.scale_z;
			temp1.z=source2.z+vbuffer_source2[iterate].z*source2.scale_y;
			
			VECTOR final;
			final.x=temp1.x;
			final.y=temp1.z;
			final.z=temp1.y;
			vec_rotate(final.x,source2.pan);
				
			merged_vbuffer[iterate+offsetv].x=final.x;
			merged_vbuffer[iterate+offsetv].y=final.z;
			merged_vbuffer[iterate+offsetv].z=final.y;
			
			merged_vbuffer[iterate+offsetv].nx=vbuffer_source2[iterate].nx;
			merged_vbuffer[iterate+offsetv].nz=vbuffer_source2[iterate].ny;
			merged_vbuffer[iterate+offsetv].ny=vbuffer_source2[iterate].nz;

			merged_vbuffer[iterate+offsetv].u1=vbuffer_source2[iterate].u1;
			merged_vbuffer[iterate+offsetv].v1=vbuffer_source2[iterate].v1;
			merged_vbuffer[iterate+offsetv].u2=vbuffer_source2[iterate].u2;
			merged_vbuffer[iterate+offsetv].v2=vbuffer_source2[iterate].v2;
			
		}
		
		for (iterate=0;iterate<triangles_source1;iterate++)	
		{
			merged_tbuffer[iterate*3]  =tbuffer_source1[iterate*3];
			merged_tbuffer[iterate*3+1]=tbuffer_source1[iterate*3+1];
			merged_tbuffer[iterate*3+2]=tbuffer_source1[iterate*3+2];
		}

		offsett+=triangles_source1;
		
		for (iterate=0;iterate<triangles_source2;iterate++)	
		{
			merged_tbuffer[(iterate+offsett)*3]  =tbuffer_source2[iterate*3]  +offsetv;
			merged_tbuffer[(iterate+offsett)*3+1]=tbuffer_source2[iterate*3+1]+offsetv;
			merged_tbuffer[(iterate+offsett)*3+2]=tbuffer_source2[iterate*3+2]+offsetv;
		}
	
		mesh->UnlockVertexBuffer();
		mesh->UnlockIndexBuffer();
	
		ENTITY* merged_entity=ent_create(CUBE_MDL,nullvector,0);
		BMAP* bmp_source1 = ent_getskin(source1, 1);
		BMAP* bmp_source2 = ent_getskin(source2, 1);
		ent_setmesh(merged_entity,mesh,0,0);
		ent_setskin(merged_entity, bmp_source1, 1);
		ent_setskin(merged_entity, bmp_source2, 2);
		return merged_entity;
	}
	return NULL;
}

function main()
{
	level_load("");
	wait(4);
	demo_init();
	
	ENTITY* ent1=ent_create("dozer.mdl",nullvector,0);
	ENTITY* ent2=ent_create("dozer.mdl",vector(120,0,0),0);
	ent2.pan =45;
	ent2.roll =20;
	ent2.tilt =15;
	ent1.tilt =10;
	ent1.scale_z = 0.5;

	ENTITY* merged=merge_ent(ent1,ent2);
	merged.z+=800;//set this to zero, if you wanna see whether the result is identical source2 angle, scale and position

//	ent_remove(ent1);
//	wait(1);
//	ent_remove(ent2);
//	wait(1);

	while(1)
	{
	//	merged.pan+=1*time_step;
		wait(1);
	}
	
}

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;
		}
	}
}

...
		for (iterate=0;iterate<vertices_source1;iterate++)	
		{
			temp1.x=source1.x+vbuffer_source1[iterate].x*source1.scale_x;
			temp1.y=source1.y+vbuffer_source1[iterate].y*source1.scale_z;
			temp1.z=source1.z+vbuffer_source1[iterate].z*source1.scale_y;
			
			VECTOR final;
			final.x=temp1.x;
			final.y=temp1.z;
			final.z=temp1.y;
			vec_rotate(final.x,source1.pan);

			merged_vbuffer[iterate].x=final.x;
			merged_vbuffer[iterate].y=final.z;
			merged_vbuffer[iterate].z=final.y;

			//	=========  START of EvilSOB's suggestion	===============
			VECTOR new_norm;
			new_norm.x = vbuffer_source1[iterate].nx;
			new_norm.y = vbuffer_source1[iterate].ny;
			new_norm.z = vbuffer_source1[iterate].nz;
			vec_rotate(new_norm, source1.pan);
			//  vec_normalize(new_norm, 1);   //maybe?!?
			//
			merged_vbuffer[iterate].nx = new_norm.nx;
			merged_vbuffer[iterate].ny = new_norm.ny;
			merged_vbuffer[iterate].nz = new_norm.nz;
			//	=========  END of EvilSOB's suggestion	===============
			
			merged_vbuffer[iterate].u1=vbuffer_source1[iterate].u1;
			merged_vbuffer[iterate].v1=vbuffer_source1[iterate].v1;
			merged_vbuffer[iterate].u2=vbuffer_source1[iterate].u2;
			merged_vbuffer[iterate].v2=vbuffer_source1[iterate].v2;
			
		}
...

for (iterate=0;iterate<vertices_source1;iterate++)	
		{
			temp1.x=source1.x+vbuffer_source1[iterate].x*source1.scale_x;
			temp1.y=source1.y+vbuffer_source1[iterate].y*source1.scale_z;
			temp1.z=source1.z+vbuffer_source1[iterate].z*source1.scale_y;
			
			//	=========  START of EvilSOB's suggestion	===============
			VECTOR new_norm;
			new_norm.x = vbuffer_source1[iterate].nx;
			new_norm.y = vbuffer_source1[iterate].ny;
			new_norm.z = vbuffer_source1[iterate].nz;
			vec_rotate(new_norm, source1.pan);
			//  vec_normalize(new_norm, 1);   //maybe?!?
			//
			merged_vbuffer[iterate].nx = new_norm.x;
			merged_vbuffer[iterate].ny = new_norm.z;
			merged_vbuffer[iterate].nz = new_norm.y;
			//	=========  END of EvilSOB's suggestion	===============
			VECTOR final;
			final.x=temp1.x;
			final.y=temp1.z;
			final.z=temp1.y;
			vec_rotate(final.x,source1.pan);

			merged_vbuffer[iterate].x=final.x;
			merged_vbuffer[iterate].y=final.z;
			merged_vbuffer[iterate].z=final.y;
			
//			merged_vbuffer[iterate].nx=vbuffer_source1[iterate].nx;
//			merged_vbuffer[iterate].nz=vbuffer_source1[iterate].ny;
//			merged_vbuffer[iterate].ny=vbuffer_source1[iterate].nz;

			merged_vbuffer[iterate].u1=vbuffer_source1[iterate].u1;
			merged_vbuffer[iterate].v1=vbuffer_source1[iterate].v1;
			merged_vbuffer[iterate].u2=vbuffer_source1[iterate].u2;
			merged_vbuffer[iterate].v2=vbuffer_source1[iterate].v2;
			
		}
		
		offsetv+=vertices_source1;
		
		for (iterate=0;iterate<vertices_source2;iterate++)	
		{
			temp1.x=source2.x+vbuffer_source2[iterate].x*source2.scale_x;
			temp1.y=source2.y+vbuffer_source2[iterate].y*source2.scale_z;
			temp1.z=source2.z+vbuffer_source2[iterate].z*source2.scale_y;
			
			//	=========  START of EvilSOB's suggestion	===============
			VECTOR new_norm;
			new_norm.x = vbuffer_source2[iterate+offsetv].nx;
			new_norm.y = vbuffer_source2[iterate+offsetv].ny;
			new_norm.z = vbuffer_source2[iterate+offsetv].nz;
			vec_rotate(new_norm, source2.pan);
			//  vec_normalize(new_norm, 1);   //maybe?!?
			//
			merged_vbuffer[iterate+offsetv].nx = new_norm.x;
			merged_vbuffer[iterate+offsetv].ny = new_norm.z;
			merged_vbuffer[iterate+offsetv].nz = new_norm.y;
			//	=========  END of EvilSOB's suggestion	===============
			VECTOR final;
			final.x=temp1.x;
			final.y=temp1.z;
			final.z=temp1.y;
			vec_rotate(final.x,source2.pan);
				
			merged_vbuffer[iterate+offsetv].x=final.x;
			merged_vbuffer[iterate+offsetv].y=final.z;
			merged_vbuffer[iterate+offsetv].z=final.y;
			
//			merged_vbuffer[iterate+offsetv].nx=vbuffer_source2[iterate].nx;
//			merged_vbuffer[iterate+offsetv].nz=vbuffer_source2[iterate].ny;
//			merged_vbuffer[iterate+offsetv].ny=vbuffer_source2[iterate].nz;

			merged_vbuffer[iterate+offsetv].u1=vbuffer_source2[iterate].u1;
			merged_vbuffer[iterate+offsetv].v1=vbuffer_source2[iterate].v1;
			merged_vbuffer[iterate+offsetv].u2=vbuffer_source2[iterate].u2;
			merged_vbuffer[iterate+offsetv].v2=vbuffer_source2[iterate].v2;
			
		}

Find the lines :
new_norm.x = vbuffer_source2[iterate+offsetv].nx;
new_norm.y = vbuffer_source2[iterate+offsetv].ny;
new_norm.z = vbuffer_source2[iterate+offsetv].nz;

and replace them with ::
new_norm.x = vbuffer_source2[iterate].nx;
new_norm.y = vbuffer_source2[iterate].ny;
new_norm.z = vbuffer_source2[iterate].nz;

function main()
{
	level_load("");
	wait(2);
	wait(1);
	demo_init();
	
	ENTITY* ent1=ent_create("p.mdl",nullvector,0);
	ENTITY* ent2=ent_create("p.mdl",vector(120,0,0),0);

	ENTITY* merged=merge_ent(ent1,ent2);
	merged.z+=200;//set this to zero, if you wanna see whether the result is identical in angle, scale and position
	int i;
	for(i=0;i<100;i++)
	{
		merged=merge_ent(merged,ent2);
		wait(1);	
	}
}

function main()
{
	level_load("");
	wait(2);
	collision_mode=0;
	wait(1);
	demo_init();
	
	ENTITY* ent1=ent_create("p.mdl",nullvector,0);
	ENTITY* ent2=ent_create("p.mdl",vector(120,0,0),0);

	ENTITY* merged=merge_ent(ent1,ent2);
	merged.z+=200;//set this to zero, if you wanna see whether the result is identical in angle, scale and position
	int i;
	for(i=0;i<100;i++)
	{
		merged=merge_ent(merged,ent2);
		wait(1);	
	}
}

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

#define PRAGMA_PATH "tust"
///////////////////////////////
#include "tust.h"

//max units
#define population 21000/12

//step in units of unit_space
var unit_space=16;

typedef struct cluster_unit
{
	VECTOR pos;
	LPD3DXMESH mesh;
	int uid;
}cluster_unit;


//build the model from the cluster models
void build_cluster_units(List* cluster,DynamicModel *model)
{
	if(model!=NULL && cluster!=NULL)
	{
		memset(model,0,sizeof(DynamicModel));
		ListItem *it = cluster->first;
		for(it = cluster->first; it != NULL; it = it->next)
		{
			cluster_unit* mycluster=(cluster_unit*)it.data;
			dmdl_add_mesh(model,mycluster.mesh,mycluster.pos);
		} 
		list_end_iterate(it);
	}
}

//add a unit to the cluster
//the cluster model must be re-build with build_cluster_units
void add_cluster_unit(List *cluster,ENTITY *ent,int uid)
{
	cluster_unit *mycluster=malloc(sizeof(cluster_unit));
	
	vec_set(mycluster.pos,ent.x);
	mycluster.mesh=ent_getmesh(ent,0,0);
	mycluster.uid=uid;
	
	list_add(cluster,(cluster_unit*)mycluster);
	sys_free(mycluster);
}

//remove a unit from the cluster 
//the cluster model has to be re-build with build_cluster_units after
void remove_cluster_unit(List *cluster,int uid)
{
	ListItem *it = cluster->first;
	for(it = cluster->first; it != NULL; it = it->next)
	{
		cluster_unit* mycluster=(cluster_unit*)it.data;
		
		if(mycluster.uid==uid)list_remove(cluster,it.data);
	} 
	list_end_iterate(it);
}

function main()
{
	max_entities =50000;
	max_particles=50000;
	
	vec_set(screen_size,vector(800,600,0));
	vec_set(screen_color,vector(1,1,1)); // dark blue
	vec_set(sky_color,vector(1,1,1)); // dark blue
	
	video_window(NULL,NULL,0,"random generator");
	 
	level_load("");
	
	random_seed(500);
	
	while(total_frames<1)wait(1);
	camera.x=-100;
	//camera.z=1000;
	//camera.tilt-=90;
	def_debug();def_debug();def_move();


////////////////////////////////////////////////
//populate the cluster list with entity data

	//position of placement
	VECTOR pos;
	vec_set(pos,nullvector);
	int i;	

	DynamicModel *model =dmdl_create();
	List *cluster=list_create();
	

	for(i=0;i<population;i+=1)
	{
		
		ENTITY* cube=ent_create(CUBE_MDL,pos,NULL);
		
		//store cluster_unit in the list 
		add_cluster_unit(cluster,cube,i);
		
		//remove entity
		ptr_remove(cube);
		
		if(pos.x<unit_space * 50)pos.x+=unit_space;
		else 
		{
			pos.y+=unit_space;
			pos.x=0;
		}
		
	}


////////////////////////////////////////////////
//merge and re-build cluster units into single model 
	build_cluster_units(cluster,model);

	//create merged entity
	ENTITY *cluster_ent=dmdl_create_instance(model,nullvector,NULL);
	
////////////////////////////////////////////////


//remove some units from cluster
for(i=0;i<100;i++)	remove_cluster_unit(cluster,integer(random(population)) );

////////////////////////////////////////////////
//merge and re-build cluster units into single model 
	build_cluster_units(cluster,model);

	//create merged entity
	ENTITY *cluster_ent1=dmdl_create_instance(model,vector(0,-600,0),NULL);
	
////////////////////////////////////////////////


	//remove dynamic model
	sys_free(model);
	//remove list
	sys_free(cluster);
	
}