Dumb terrain question.. Cannot get it to move...

#include <default.c>

function main()
{
   d3d_lines = 3; level_load("");
	
   vec_set(camera.x,vector(-150,0,100));
   vec_set(camera.pan,vector(0,-30,0));
	
   ENTITY* terrain = ent_createterrain(NULL,nullvector,10,10,10);
   ent_setskin(terrain, bmap_fill(bmap_createblack(32,32,16),COLOR_WHITE,100), 1);
	
   you = ent_create(SPHERE_MDL,nullvector,NULL); vec_scale (you.scale_x, 2);
   ent_setskin(you, bmap_fill(bmap_createblack(32,32,16),COLOR_GREEN,100), 1);
	
   while(1){
      int i = ent_status(terrain,0);
      for (; i>0; i--) { 
         CONTACT* c = ent_getvertex(terrain,NULL,i);
         c.v.x += 10 * (key_w - key_s) * time_frame;
         c.v.z += 10 * (key_a - key_d) * time_frame; // Y = Z (DX coordinate system)
         ent_setvertex(terrain,c,i); 
      }
   c_setminmax(terrain);
   wait(1);
   }
}

typedef struct StackNode
{
	ENTITY* StoredEnt;
	struct StackNode* prev;
} StackNode;

StackNode* StackFirst = NULL;//needed pointer to start of list
StackNode* StackLast = NULL;//needed pointer to end of list
int StackCount=0;//counter of items in list

void StackAdd(ENTITY* myent)
{
	StackNode* StackNew;//new pointer
	StackNew = malloc(sizeof(StackNode));//reserve memory
	StackNew.StoredEnt = myent;//assign values
	
	if(StackCount==0)//if the list is empty
	{
		StackFirst=StackNew;
		StackNew.prev=NULL;
	}
	else
	{
		StackNew.prev=StackLast;
	}
	StackLast=StackNew;
	
	StackCount++;
}

void StackPop()
{
	StackNode* StackCurrent;
	
	StackCurrent=StackLast;
	if(StackCurrent!=NULL)//if the list is NOT empty
	{
		StackLast=StackCurrent.prev;
		free(StackCurrent);
		StackCount--;
	}
}

ENTITY* Ent_Create2(STRING model, VECTOR pos, ANGLE angle)
{
   ENTITY* myent;
	if(StackLast!=NULL)//if there are availabe entities to recycle in our list
	{
	   myent=StackLast.StoredEnt;
		ent_morph(myent,model);
		vec_set(myent.x,pos);
		vec_set(myent.pan,angle);
		reset(myent, PASSABLE| INVISIBLE);
		c_setminmax(myent);
		StackPop();
		return(myent);
	}
	else
	{
	   myent=ent_create(model,pos,NULL);
	   vec_set(myent.pan,angle);
	   c_setminmax(myent);
	   return(myent);
	}
}

void Ent_Remove2(ENTITY* myent)
{
   set(myent, PASSABLE| INVISIBLE);
   vec_set(myent.x,vector(0,0,-1000000));
   ent_morph(myent,"DummyEnt.mdl");
   StackAdd(myent);
}

void My_Action(ENTITY* ME)
{
   me = ME;
   ...
   everything else as normal

void False_Action(ENTITY* ME)
{
   me=ME;
   my.emask |= (ENABLE_BLOCK | ENABLE_ENTITY);
   my.event = blablabla_event;

   while(my.skill25==1)
   {
      //do whatever the action would do
      wait(1);
   }

}

void action_ptr(ENTITY* ME);	//an empty function pointer

...


ENTITY* ent_create_2(STRING* filename, VECTOR* position,  EVENT my_action)
{
	ENTITY*  entity_to_reuse = something;
	...
	action_ptr=my_action;	action_ptr( entity_to_reuse );	action_ptr=NULL;
}

void False_Action(ENTITY* ME)
{
   me=ME;
   my.emask |= (ENABLE_BLOCK | ENABLE_ENTITY);
   my.event = blablabla_event;

   while(my.skill25==1)
   {
      //do whatever the action would do
      wait(1);
   }

   my.emask &= ~(ENABLE_BLOCK | ENABLE_ENTITY);  
   my.event = NULL;
}

void avg_normals_N(int x, int y)//NORTH EDGE SMOOTH NORMALS (SHADOWS)
{
	int tx; //vector counter
	VECTOR nml[2];
	VECTOR mid_nml; //average height of touching vertex's
	CONTACT* c1; //contact vertex for Terrain
	
	
	if(y<TERRAIN_COUNT-1)
	{
		for(tx=1;tx<32;tx++)
		{
			vec_set(mid_nml,nullvector);
			vec_for_normal(nml[0],Terrain[x][y],1+tx);
			vec_for_normal(nml[1],Terrain[x][y+1],1057+tx);
			vec_add(mid_nml,nml[0]);
			vec_add(mid_nml,nml[1]);
			vec_normalize(mid_nml,1);
			
			c1 = ent_getvertex(Terrain[x][y],NULL,1+tx);
			//vec_set(c1.v.nx,mid_nml);
			c1.v.nx=mid_nml.x;
			c1.v.ny=mid_nml.z;
			c1.v.nz=mid_nml.y;
			ent_setvertex(Terrain[x][y],c1,1+tx);
			
			c1 = ent_getvertex(Terrain[x][y+1],NULL,1057+tx);
			//vec_set(c1.v.nx,mid_nml);
			c1.v.nx=mid_nml.x;
			c1.v.ny=mid_nml.z;
			c1.v.nz=mid_nml.y;
			ent_setvertex(Terrain[x][y+1],c1,1057+tx);
		}
	}
}

high detail terrain viewed from side:
.    .    .
 .  . .  .
  ..   ..

low detail terrain viewed from side:
.    .    .

both terrains spliced/sewn:
.____.____.
 .  . .  .
  ..   ..
(lines represent low vertex count terrain result)

Low detail terrain:
.  .  .  .  .  .

.  .  .  .  .  .

.  .  .  .  .  .

.  .  .  .  .  .

Mid terrain (used for between HighLOD and LowLOD for splicing):
.  .  .  .  .  .

. . . .  . . . .

. . . .  . . . .
................
................

High detail terrain:
................
................
................
................
................
................
................
................

LOD_0 =    * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
LOD_1 =    *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *
LOD_2 =    *       *       *       *       *       *       *       *       *
LOD_3 =    *               *               *               *               *

Side View...

       /            _    /--\___     ____   _____     /---
camera*        ____/ \__/       \___/      /     \___/    \_____  
       \                                  /                 
               +------ high poly -------+ +------ low poly ----+
                                          ^^ left-most vertex dragged downward

var get_height(VECTOR P, int SW, ENTITY* Terrain)
{
	//P = point that we want the height of (x,y,0)
	//SW = vertex number of terrain ent closest towards the lower left corner of the square
	//Terrain we are calculating for
	
	CONTACT* c1;
	VECTOR Triangle[3];
	VECTOR temp_vec;
	ANGLE temp_ang;
	VECTOR Director[2];
	
	VECTOR formula;
	var ind_term;
	
	//retrieve first point of containing triangle (base corner)
	c1= ent_getvertex(Terrain,NULL,SW);
	Triangle[0].x=c1.v.x;
	Triangle[0].y=c1.v.z;
	Triangle[0].z=c1.v.y;
	
	//retrieve second point of containing triangle (diagonal to base)
	c1= ent_getvertex(Terrain,NULL,SW-32);
	Triangle[1].x=c1.v.x;
	Triangle[1].y=c1.v.z;
	Triangle[1].z=c1.v.y;
	
	//determine third point of containing triangle (varying point)
	vec_set (temp_vec, P);
	vec_sub (temp_vec,Triangle[0].x);
	vec_to_angle (temp_ang.pan,temp_vec);
   
   //retrieve third point of containing triangle (varying point)
	if(temp_ang.pan>45)
	{
		c1= ent_getvertex(Terrain,NULL,SW-33);
	}
	else
	{
		c1= ent_getvertex(Terrain,NULL,SW+1);
	}
	Triangle[2].x=c1.v.x;
	Triangle[2].y=c1.v.z;
	Triangle[2].z=c1.v.y;
	
	//calculate the triangle's plane normal for the formula coeficients
	vec_set(Director[0],Triangle[1]);
	vec_sub(Director[0],Triangle[0]);
	vec_set(Director[1],Triangle[2]);
	vec_sub(Director[1],Triangle[0]);
	vec_cross(formula,Director[0],Director[1]);
	//set the independant term of the formula
	ind_term=(-1*formula.x*Triangle[0].x)+(-1*formula.y*Triangle[0].y)+(-1*formula.z*Triangle[0].z);
	//calculate our point's height plugging our values into the formula
	P.z=(-1*((formula.x*P.x)+(formula.y*P.y)+ind_term))/formula.z;
	return(P.z);
}

double STOPWATCH;

//pixel_source = pixel_for_bmap(Source_BM,Pixel_pos.x,Pixel_pos.y);
//pixel_to_bmap(NewSkin,Pixel_pos.x,Pixel_pos.y,pixel_dest);

//t_color = pixel_to_vec(NULL, t_alpha ,t_format2,pixel_source);
//pixel_dest=pixel_for_vec(t_color,t_alpha,t_format1);

//height = get_height(Pixel_pos.x,Pixel_pos.y,i,Terr);
height=random(200);

//retrieve first point of containing triangle (base corner)
	c1= ent_getvertex(Terrain,NULL,SW);
	Triangle[0].x=c1.v.x;
	Triangle[0].y=c1.v.z;
	Triangle[0].z=c1.v.y;
	
	//retrieve second point of containing triangle (diagonal to base)
	c1= ent_getvertex(Terrain,NULL,SW-32);
	Triangle[1].x=c1.v.x;
	Triangle[1].y=c1.v.z;
	Triangle[1].z=c1.v.y;
	
	//determine third point of containing triangle (varying point)
	vec_set (temp_vec, P);
	vec_sub (temp_vec,Triangle[0].x);
	vec_to_angle (temp_ang.pan,temp_vec);
	
	//retrieve third point of containing triangle (varying point)
	if(temp_ang.pan>45)
	{
		c1= ent_getvertex(Terrain,NULL,SW-33);
	}
	else
	{
		c1= ent_getvertex(Terrain,NULL,SW+1);
	}
	Triangle[2].x=c1.v.x;
	Triangle[2].y=c1.v.z;
	Triangle[2].z=c1.v.y;

//retrieve the three points of containing triangle

	//first, open the buffer
	ent_getvertex(Terrain,c1, 1);	ent_setvertex(Terrain,c1, 1);

	//retrieve the first point of containing triangle (diagonal to base)
	Triangle[0].x = c1.v[SW].x;
	Triangle[0].y = c1.v[SW].z;
	Triangle[0].z = c1.v[SW].y;
	
	//retrieve second point of containing triangle (diagonal to base)
	Triangle[1].x = c1.v[SW-32].x;
	Triangle[1].y = c1.v[SW-32].z;
	Triangle[1].z = c1.v[SW-32].y;
	
	//determine third point of containing triangle (varying point)
	vec_to_angle(temp_ang.pan, vec_sub( vec_set(temp_vec, P),Triangle[0].x));
	
	//retrieve third point of containing triangle (varying point)
	if(temp_ang.pan>45)
	{
		Triangle[2].x = c1.v[SW-33].x;
		Triangle[2].y = c1.v[SW-33].z;
		Triangle[2].z = c1.v[SW-33].y;
	}
	else
	{
		Triangle[2].x = c1.v[SW+1].x;
		Triangle[2].y = c1.v[SW+1].z;
		Triangle[2].z = c1.v[SW+1].y;
	}

this format
...  c1.v[SW].x  ...
may need changing to
...  (c1.v)[SW].x  ...

void Terrain_Paint(int x, int y)
{
	ENTITY* Terr = Terrain[x][y];
	CONTACT* c1;
	int i; //vertex info for terrain
	
	BMAP* Source_BM;
	
	BMAP* OldSkin;
	VECTOR Pixel_pos; //pixel coordinates for skin bmap
	
	var height;
	
	var pixel_source; var pixel_dest;
	//var t_format1; var t_format2;
	COLOR* t_color; var t_alpha; 
	
	BMAP* NewSkin = bmap_create("Terrain_Sand.tga");
	t_format1=bmap_lock(NewSkin,0);
	
	c1 = ent_getvertex(Terr,NULL,1);
	
	for(Pixel_pos.y=0;Pixel_pos.y<512;Pixel_pos.y++)
	{
		for(Pixel_pos.x=0;Pixel_pos.x<512;Pixel_pos.x++)
		{
			i = (integer((Pixel_pos.x)/16)+1) + (((integer((Pixel_pos.y)/16)+1)*33));
			height = get_height(Pixel_pos.x,Pixel_pos.y,i,c1);
			
			if(height>16)
			{
				if(height<=16)//sand
				{
					Source_BM=Sand_BM;
				}
				else if(height<75)//grass
				{
					Source_BM=Grass_BM;
				}
				else if(height<150)//stone
				{
					Source_BM=Rock_BM;
				}
				else//snow
				{
					Source_BM=Snow_BM;
				}
				pixel_source = pixel_for_bmap(Source_BM,Pixel_pos.x,Pixel_pos.y);
				t_color = pixel_to_vec(NULL, t_alpha ,t_format2,pixel_source);
				
				//paint pixel on selected terrain's texture
				pixel_dest=pixel_for_vec(t_color,t_alpha,t_format1);
				pixel_to_bmap(NewSkin,Pixel_pos.x,Pixel_pos.y,pixel_dest);
			}
		}
	}

	bmap_unlock(NewSkin);
	OldSkin=ent_getskin(Terr,1);
	ptr_remove(OldSkin);
	ent_setskin(Terr,NewSkin,1);
}

var get_height(var Px, var Py, int SW, CONTACT* c1)
{
	//P = point that we want the height of (x,y,0)
	//SW = vertex number of terrain ent closest towards the lower left corner of the square
	//c1 = pointer to our terrain vertex info
	
	
	VECTOR P;
	//TRANSFORM SKIN PIXEL COORDS TO LOCAL ENT COORD SYSTEM
	vec_set(P,vector(Px,Py,0));
	P.x-= 256;
	P.y = 256-P.y;
	
	VECTOR Triangle[3];
	VECTOR temp_vec;
	ANGLE temp_ang;
	VECTOR Director[2];
	
	VECTOR formula;
	var ind_term;
	
	//retrieve first point of containing triangle (base corner)
	Triangle[0].x=(c1.v)[SW].x;
	Triangle[0].y=(c1.v)[SW].z;
	Triangle[0].z=(c1.v)[SW].y;
	
	//retrieve second point of containing triangle (diagonal to base)
	Triangle[1].x=(c1.v)[SW-32].x;
	Triangle[1].y=(c1.v)[SW-32].z;
	Triangle[1].z=(c1.v)[SW-32].y;
	
	//determine third point of containing triangle (varying point)
	vec_set (temp_vec, P);
	vec_sub (temp_vec,Triangle[0].x);
	vec_to_angle (temp_ang.pan,temp_vec);
	
	//retrieve third point of containing triangle (varying point)
	if(temp_ang.pan>45)
	{
		Triangle[2].x = (c1.v)[SW-33].x;
		Triangle[2].y = (c1.v)[SW-33].z;
		Triangle[2].z = (c1.v)[SW-33].y;
		
	}
	else
	{
		Triangle[2].x = (c1.v)[SW+1].x;
		Triangle[2].y = (c1.v)[SW+1].z;
		Triangle[2].z = (c1.v)[SW+1].y;
		
	}
	
	//calculate the triangle's plane normal for the formula coeficients
	vec_set(Director[0],Triangle[1]);
	vec_sub(Director[0],Triangle[0]);
	vec_set(Director[1],Triangle[2]);
	vec_sub(Director[1],Triangle[0]);
	vec_cross(formula,Director[0],Director[1]);
	//set the independant term of the formula
	ind_term=(-1*formula.x*Triangle[0].x)+(-1*formula.y*Triangle[0].y)+(-1*formula.z*Triangle[0].z);
	//calculate our point's height plugging our values into the formula
	P.z=(-1*((formula.x*P.x)+(formula.y*P.y)+ind_term))/formula.z;
	return(P.z);
}

var get_height(var Px, var Py, int SW, CONTACT* c1)
{
//P = point that we want the height of (x,y,0) 
//SW = vertex number of terrain ent closest towards the lower left corner of the square
//c1 = pointer to our terrain vertex info

VECTOR P, Triangle[3], temp_vec, Director[2], formula;
ANGLE temp_ang;
var ind_term;


// ###  NOTE  ###  All VECTOR calculations are working in D3D Vertex format!
//							That is X-Z-Y instead of X-Y-Z


//TRANSFORM SKIN PIXEL COORDS TO LOCAL ENT COORD SYSTEM
vec_set(P,vector(Px-256,0,256-Py));

//retrieve first point of containing triangle (base corner)
vec_set(Triangle[0], (c1.v)[SW].x);

//retrieve second point of containing triangle (diagonal to base)
vec_set(Triangle[1], (c1.v)[SW-32].x);

//determine third point of containing triangle (varying point)
vec_to_angle (temp_ang.pan, vec_sub( vec_set(temp_vec, P) , Triangle[0]) );

//retrieve third point of containing triangle (varying point)
if(temp_ang.pan>45)		vec_set(Triangle[2], (c1.v)[SW-33].x);
else							vec_set(Triangle[2], (c1.v)[SW+1].x);

//calculate the triangle's plane normal for the formula coeficients
vec_sub( vec_set(Director[0],Triangle[1]) ,Triangle[0]);
vec_sub( vec_set(Director[1],Triangle[2]) ,Triangle[0]);

vec_cross(formula, Director[0], Director[1]);

//set the independant term of the formula
ind_term=(-1*formula.x*Triangle[0].x)+(-1*formula.y*Triangle[0].y)+(-1*formula.z*Triangle[0].z);

//calculate our point's height plugging our values into the formula
P.y=(-1*((formula.x*P.x)+(formula.z*P.z)+ind_term))/formula.y;
 
return(P.y);
}

//Application fed data
const float4x4 matWorld; // World matrix
texture Sand_BM, Grass_BM, Rock_BM, Snow_BM;

// ColorMap Samplers
sampler SandSampler = sampler_state 
{ 
	Texture = <Sand_BM>;
	MipFilter = Linear; 
	AddressU  = Wrap; 
	AddressV  = Wrap; 
}; 

sampler GrassSampler = sampler_state 
{ 
	Texture = <Grass_BM>;
	MipFilter = Linear; 
	AddressU  = Wrap; 
	AddressV  = Wrap; 
};  

sampler RockSampler = sampler_state 
{ 
	Texture = <Rock_BM>;
	MipFilter = Linear; 
	AddressU  = Wrap; 
	AddressV  = Wrap; 
};  

sampler SnowSampler = sampler_state 
{ 
	Texture = <Snow_BM>;
	MipFilter = Linear; 
	AddressU  = Wrap; 
	AddressV  = Wrap; 
};  

// Vertex Shader: 
void TerrPaintVS( 
in float4 InPos: POSITION, 
in float2 InTex: TEXCOORD0, 
out float4 OutPos: POSITION, 
out float2 OutTex: TEXCOORD0) 
{ 
	// Transform the vertex from object space to world space: 
	OutPos = mul(InPos, matWorld); 
	// Pass the texture coordinate to the pixel shader: 
	OutTex = InTex; 
}

// Pixel Shader: 
float4 TerrPaintPS(
in float4 InPos: POSITION, 
in float2 InTex: TEXCOORD0): COLOR 
{
	float4 Color;
	if(InPos.y<16)	Color = tex2D(SandSampler, InTex); 
	else if(InPos.y<50)	Color = tex2D(GrassSampler, InTex); 
	else if(InPos.y<75)	Color = tex2D(RockSampler, InTex); 
	else Color = tex2D(SnowSampler, InTex);
	
	return Color; 
} 

// Technique: 
technique AmbientTechnique 
{ 
	pass P0 
	{ 
		VertexShader = compile vs_2_0 TerrPaintVS(); 
		PixelShader  = compile ps_2_0 TerrPaintPS(); 
	} 
}

MATERIAL* mtlTerrain =
{
   effect = "TerrainPainter.fx";
   flags = AUTORELOAD; // allows to edit the shader at runtime
}

int x; int y;
for(x=0;x<TERRAIN_COUNT;x++)
{
	for(y=0;y<TERRAIN_COUNT;y++)
	{
		Terrain[x][y]=ent_create("Terrain33.mdl",vector(x*512,y*512,0),NULL);
		ent_clone(Terrain[x][y]);
		Terrain[x][y].material = mtlTerrain;
		//ent_cloneskin(Terrain[x][y]);
	}
}

//Application fed data
const float4x4 matWorld; // World matrix
texture Sand_BM, Grass_BM, Rock_BM, Snow_BM;

// ColorMap Samplers
sampler SandSampler = sampler_state 
{ 
	Texture = <Sand_BM>;
	MipFilter = Linear; 
	AddressU  = Wrap; 
	AddressV  = Wrap; 
}; 

sampler GrassSampler = sampler_state 
{ 
	Texture = <Grass_BM>;
	MipFilter = Linear; 
	AddressU  = Wrap; 
	AddressV  = Wrap; 
};  

sampler RockSampler = sampler_state 
{ 
	Texture = <Rock_BM>;
	MipFilter = Linear; 
	AddressU  = Wrap; 
	AddressV  = Wrap; 
};  

sampler SnowSampler = sampler_state 
{ 
	Texture = <Snow_BM>;
	MipFilter = Linear; 
	AddressU  = Wrap; 
	AddressV  = Wrap; 
};  

// Vertex Shader: 
void TerrPaintVS( 
in float4 InPos: POSITION, 
in float2 InTex: TEXCOORD0, 
out float2 OutTex: TEXCOORD0,
out float4 OutPos: TEXCOORD1) 
{ 
	// Transform the vertex from object space to world space: 
	OutPos = mul(InPos, matWorld); 
	// Pass the texture coordinate to the pixel shader: 
	OutTex = InTex; 
}

// Pixel Shader: 
float4 TerrPaintPS(
in float2 InTex: TEXCOORD0,
in float4 InPos: TEXCOORD1): COLOR 
{
	float4 Color;
	if(InPos.y<16)	Color = tex2D(SandSampler, InTex); 
	else if(InPos.y<50)	Color = tex2D(GrassSampler, InTex); 
	else if(InPos.y<75)	Color = tex2D(RockSampler, InTex); 
	else Color = tex2D(SnowSampler, InTex);
	
	return Color; 
} 

// Technique: 
technique AmbientTechnique 
{ 
	pass P0 
	{ 
		VertexShader = compile vs_2_0 TerrPaintVS(); 
		PixelShader  = compile ps_2_0 TerrPaintPS(); 
	} 
}

// Vertex Shader: 
void TerrPaintVS( 
in float4 InPos: POSITION, 
in float2 InTex: TEXCOORD0, 
out float2 OutTex: TEXCOORD0,
out float4 OutPos: POSITION,
out float4 OutCoords: TEXCOORD1) 
{ 
	// Transform the vertex from object space to world space: 
	OutPos = mul(InPos, matWorld); 
	OutCoords=OutPos;
	// Pass the texture coordinate to the pixel shader: 
	OutTex = InTex; 
}

// Pixel Shader: 
float4 TerrPaintPS(
in float2 InTex: TEXCOORD0,
in float4 InCoords: TEXCOORD1): COLOR 
{
	float4 Color;
	if(InCoords.y<16)	Color = tex2D(SandSampler, InTex); 
	else if(InCoords.y<50)	Color = tex2D(GrassSampler, InTex); 
	else if(InCoords.y<75)	Color = tex2D(RockSampler, InTex); 
	else Color = tex2D(SnowSampler, InTex);
	
	return Color; 
}

Height = 1-(OutPos.y/OutPos.w);

Height = OutPos.y;

float4 Color;	
			if(Height < 16)		Color = tex2D(SandSampler,  InTex); 
	else	if(Height < 50)		Color = tex2D(GrassSampler, InTex); 
	else	if(Height < 75)		Color = tex2D(RockSampler,  InTex); 
	else 								Color = tex2D(SnowSampler,  InTex);

float4  Color = tex2D(SandSampler, InTex); 
        Color = lerp(Color, tex2D(GrassSampler,InTex), [insert evil formula here]);
        Color = lerp(Color, tex2D(RockSampler,InTex),  [insert evil formula here]);
        Color = lerp(Color, tex2D(SnowSampler, InTex), [insert evil formula here]);