PROGRAM divbattlearenazone;




CONST
red=192;
green=128;
blue=231;
white=63;




global
obj_count=0;
tank_count;
box_count;





file0;
scr_w;
scr_h;
scr_cx;
scr_cy;




//Object index names
IED;
TOWER;
SHELL[1];
TANK[1];
HULL[1];
TURRET[1];
SHAFT[1];
BARREL[1];
post[1];
dish[1];
RUBY;



//Object process handles
tank_id[1];
SHELL_ID[1];
HULL_ID[1];
TURRET_ID[1];
SHAFT_ID[1];
BARREL_ID[1];
POST_id[1];
dish_id[1];

radar_id[1];




Struct pool
vertCount;
edgeCount;
faceCount;
Vnext;
Enext;
Fnext;

END


//----------------------------

Struct Poolvert[2000];
x,y;
visible;
scr_x;
scr_y;
END

Struct Pooledge[2000];
    struct   V[1]
        index;
        visible;
    END
END


Struct Poolface[2000];
    index;
    visible;
    struct E[5];
    index;
        struct V[1];
        index;

        END
    END
END


VIsibleEdgeCount;
//----------------------------
struct visibleEdge[2000]
   struct V[1]
   x;
   y;
   z;
   scr_x;
   scr_y;
   END
END

//----------------------------
VisibleVertCount;

Struct
visibleVert[2000]
x;y; z;
scr_x:
scr_y;
END


//----------------------------



struct flag[1];
wide=10;
high=8;
#verts=99;
#springs=240;
    struct vert[99]
    x,y,z,
    x0,y0,z0,
    END
    struct spring[240]
    length;
    restlength;
    v1;
    v2;
    END
END

//----------------------------



struct cam[2]
distance;
posX;
posY;
posZ;
depth;
fov;
angle;
vx; vy; vz;
cx;
cy;
h,
w,
END


//----------------------
struct obj[100]
vertex_count ;
edge_count;
face_count;
anglez;
anglex;
angley=0;
vel; vely;
col0;
X0; y0: z0;
posx; posy; posz;
inradar;
struct vertex[100]
x,y,z;
xl, yl,zl;
sX,sy; sz;
END

struct edge[100]
v0;
v1;
col;
draw_me;
END



struct face[100]
e[5];
col;

END


END


//-------


struct tmp_vertex[100]
x,y,z;

END


struct tmp_edge[100]
v0; v1;
END

struct tmp_face[100]
e[5];
END





LOCAL
c;
renderme;
PRIVATE
i; j; x0; y0; z0;  k;

struct vertex[40]
x,y,z;

END

struct edge[30]
v0; v1;
END



BEGIN



//mouse.graph=4;
//mouse.flags=4;
set_fps(60,0);
scr_w=1200;
scr_h=800;
scr_w=800;
scr_h=600;

scr_cx=scr_w/2;
scr_cy=scr_h/2;
set_mode(scr_w*1000+scr_h);
file0=load_fpg("battlezone.FPG");
define_region(1, 0, 0, scr_w, scr_h/2);
define_region(2, 0, scr_h/2, scr_w, scr_h/2);



for(i=0; i<3; i+=1)
cam[i].posX=0;
cam[i].posY=0;
cam[i].posZ=600;
cam[i].angle=0;
cam[i].cx=scr_cx;
cam[i].w=scr_w;
cam[i].h=scr_h/2;

cam[i].depth=scr_w;

cam[i].fov=atan2(scr_cx,cam[i].depth);

END


cam[2].cx=50;
cam[2].cy=50;
cam[2].w=25;
cam[2].h=25;


cam[0].cy=scr_cy/2;
cam[1].cy=3*scr_cy/2;

camera_control();


moon(0,101);
moon(1,101);


radar(0,scr_w-scr_Cy/4,scr_cy-scr_cy/4,scr_cy/4);
radar(1,scr_w-scr_cy/4,scr_h-scr_cy/4,scr_cy/4);



draw(2,green,15,0,0,0,scr_w-1,scr_cy-1);
draw(2,green,15,0,0,scr_cy+1,scr_w-1,scr_h-1);






init_objects();



END


//============================================================================================
//============================================================================================
//_________________________________________________________________________________
PROCESS init_objects()
 private n;
BEGIN

  //TANKS MUSTCOME FIRST

 TAnk[0]=obj_count;
 init_tank(0,0,1000,0,_up,_down,_left,_right,_r_shift,green);
 TANK[1]=obj_Count;
 init_tank(0,0,-1000,180000,_w,_s,_a,_d,_l_shift,green);


  add_tank_parts(tank[0]);
  add_tank_parts(tank[1]);



//init_gem(4,-200,0,0,86,40);



TOWER=obj_count;
obj[tower].col0=160;
init_box(100,200,300,0,0,0,0,white);

/*
from c=0 to 10;
init_box(rand(100,200),rand(100,200),rand(100,300),rand(-10000,10000),0,rand(-10000,10000),rand(-180000,180000),green);
END
*/

IED=obj_count;
init_box(100,100,100,600,100,0,0,green);






SHELL[0]=obj_count;
init_box(5,5,5,100,400,100,0,green);
 obj[shell[0]].inradar=0;

SHELL[1]=obj_count;
init_box(5,5,5,100,400,100,0,green);
 obj[shell[1]].inradar=0;



update_objs();
     END







//--------------------------------------------------------------------------------
process init_tank(x0,y0,z0,ang,up,dn,lf,rt,ctrl,col)

PRIVATE x0; y0; z0; i; j; k;  l;
verts;
edges;
faces;  f=0;
g;
half_v;
v;
BEGIN
verts=22;
v=8;  //number of verts on draw edges
half_v=v/2;
edges=12;

faces=4;
edges=18;



graph=20;    g=graph;
getpoint(0,0,g);
getpoint(1,1,g);
getpoint(2,2,g);
getpoint(3,6,g);
getpoint(4,7,g);
getpoint(5,8,g);
getpoint(6,9,g);
getpoint(7,13,g);
getpoint(8,14,g);
getpoint(9,24,g);
getpoint(10,25,g);

assignFaceEdgeIndices();

build_objectf(obj_count,verts,edges,faces,col);

// END



obj[obj_count].col0=col;
obj[obj_count].inradar=1;
tankobj(obj_count,tank_count,verts,edges,faces,x0,y0,z0,ang,up,dn,lf,rt,ctrl,col);


obj_count+=1;
tank_count+=1;




END




 //---------------------------------------------------------------------------------------------------

PROCESS assignFaceEdgeIndices()
private
f;

BEGIN





tmp_edge[1].v0=1; tmp_edge[1].v1=2;
tmp_edge[2].v0=2; tmp_edge[2].v1=3;
tmp_edge[3].v0=3; tmp_edge[3].v1=4;
tmp_edge[4].v0=4; tmp_edge[4].v1=1;
tmp_edge[5].v0=5; tmp_edge[5].v1=6;
tmp_edge[6].v0=6; tmp_edge[6].v1=7;
tmp_edge[7].v0=7; tmp_edge[7].v1=8;
tmp_edge[8].v0=8; tmp_edge[8].v1=5;
tmp_edge[9].v0=1; tmp_edge[9].v1=5;
tmp_edge[10].v0=2; tmp_edge[10].v1=6;
tmp_edge[11].v0=3; tmp_edge[11].v1=7;
tmp_edge[12].v0=4; tmp_edge[12].v1=8;


tmp_edge[13].v0=17; tmp_edge[13].v1=11;
tmp_edge[14].v0=18; tmp_edge[14].v1=12;
tmp_edge[15].v0=19; tmp_edge[15].v1=13;
tmp_edge[16].v0=20; tmp_edge[16].v1=14;
tmp_edge[17].v0=21; tmp_edge[17].v1=15;
tmp_edge[18].v0=22; tmp_edge[18].v1=16;





f=0;

f+=1;
makeface(f,14,8,7,6,5,4);

f+=1;
makeface(f,13,1,4,3,2,4);

f+=1;
makeface(f,15,1,10,5,9,4);

f+=1;
makeface(f,17,3,12,7,11,4);


f+=1;
makeface(f,16,2,11,6,10,4);


f+=1;
makeface(f,18,4,9,8,12,4);


getfacenormalvector(17,11,1,2,3,4);
getfacenormalvector(18,12,8,7,6,5);
getfacenormalvector(19,13,1,5,6,2);
getfacenormalvector(20,14,2,6,7,3);
getfacenormalvector(21,15,3,7,8,4);
getfacenormalvector(22,16,4,8,5,1);



END


//---------------------------------------------------------------------------------------------------

process makeface(f,a,b,c,d,e,n)

BEGIN

tmp_face[f].e[0]=a;
tmp_face[f].e[1]=b;
tmp_face[f].e[2]=c;
tmp_face[f].e[3]=d;
if(n==4)
tmp_face[f].e[4]=e;
END
END


//---------------------------------------------------------------------------------------------------


PROCESS getfacenormalvector(v0,v1,a,b,c,d)
PRIVATE
x1,y1,z1,x2,y2,z2;
BEGIN
getfacecentrevertex(v1,a,b,c,d);

x1=tmp_vertex[a].x-tmp_vertex[b].x;
y1=tmp_vertex[a].y-tmp_vertex[b].y;
z1=tmp_vertex[a].z-tmp_vertex[b].z;

x2=tmp_vertex[c].x-tmp_vertex[b].x;
y2=tmp_vertex[c].y-tmp_vertex[b].y;
z2=tmp_vertex[c].z-tmp_vertex[b].z;


tmp_vertex[v0].x=tmp_vertex[v1].x-(y1*z2-z1*y2)/100;
tmp_vertex[v0].y=tmp_vertex[v1].y-(z1*x2-x1*z2)/100;
tmp_vertex[v0].z=tmp_vertex[v1].z-(x1*y2-y1*x2)/100;

END



//--------------------------------------------------------------------------------
PROCESS getfacecentrevertex(v,a,b,c,d);
BEGIN
 tmp_vertex[v].x=(tmp_vertex[a].x+tmp_vertex[b].x+tmp_vertex[c].x+tmp_vertex[d].x)/4;
 tmp_vertex[v].y=(tmp_vertex[a].y+tmp_vertex[b].y+tmp_vertex[c].y+tmp_vertex[d].y)/4;
 tmp_vertex[v].z=(tmp_vertex[a].z+tmp_vertex[b].z+tmp_vertex[c].z+tmp_vertex[d].z)/4;

END
//--------------------------------------------------------------------------------


PROCESS getpoint(v,cp,graph)
PRIVATE
empty;
BEGIN
x=0; y=0;

get_real_point(cp,&tmp_vertex[v].z,&tmp_vertex[v].y);
tmp_vertex[v].y=-tmp_vertex[v].y;
graph+=1;
get_real_point(cp,&tmp_vertex[v].x,&empty);
END



//--------------------------------------------------------------------------------

PROCESS add_tank_parts(n)

PRIVATE x0; y0; z0; i; j; k;  l; ang; col;
verts;
edges;
g;
half_v;
v;
fix;
dx; dy; dz;
parent;
faces;
BEGIN


 col=obj[n].col0;


//_______HULL_______________________________________




v=8;  //number of verts on draw edges
half_v=v/2;




verts=22;
edges=18;
faces=5;
graph=20;    g=graph;
getpoint(0,24,g);
getpoint(1,2,g);
getpoint(2,3,g);
getpoint(3,5,g);
getpoint(4,6,g);
getpoint(5,9,g);
getpoint(6,10,g);
getpoint(7,12,g);
getpoint(8,13,g);






//TRANSFORS THE VERT COORRDNIATES TO HAVE v0 AT LOCAL 0,0,0
dx=tmp_vertex[0].x;
dy=tmp_vertex[0].y;
dz=tmp_vertex[0].z;
for(i=0; i<=verts; i+=1)
tmp_vertex[i].x-=dx;
tmp_vertex[i].y-=dy;
tmp_vertex[i].z-=dz;
END




AssignFaceEdgeIndices();





build_objectf(obj_count,verts,edges,faces,col);


 fix=9; parent=n;

hull_id[n]=tank_part(obj_count,verts,edges,faces,x0,y0,z0,ang,n,1,parent,fix,col);
HULL[n]=obj_count;
obj_count+=1;




//-TURRET------------------------------------------





verts=9;
v=6;;  //number of verts on draw edges
half_v=v/2;
edges=12;


verts=22;
edges=18;
faces=6;

graph=20;    g=graph;

getpoint(0,25,g);
getpoint(1,3,g);
getpoint(2,28,g);
getpoint(3,4,g);
getpoint(4,5,g);
getpoint(5,10,g);
getpoint(6,29,g);
getpoint(7,11,g);
getpoint(8,12,g);
getpoint(9,27,g);



x=tmp_vertex[0].x;
dy=tmp_vertex[0].y;
dz=tmp_vertex[0].z;
for(i=0; i<=verts; i+=1)
tmp_vertex[i].x-=dx;
tmp_vertex[i].y-=dy;
tmp_vertex[i].z-=dz;
END



AssignFaceEdgeIndices();



build_objectf(obj_count,verts,edges,faces,col);


 fix=10;  parent=n;
turret_id[n]=tank_part(obj_count,verts,edges,faces,x0,y0,z0,ang,n,2,parent,fix,col);
TURRET[n]=obj_count;
obj_count+=1;





//-----SHAFT--------------------------------------

verts=2;
v=verts;;  //number of verts on draw edges
half_v=v/2;
edges=1;
graph=20;    g=graph;
getpoint(0,27,g);
getpoint(1,26,g);

x=tmp_vertex[0].x;
dy=tmp_vertex[0].y;
dz=tmp_vertex[0].z;
for(i=0; i<=verts; i+=1)
tmp_vertex[i].x-=dx;
tmp_vertex[i].y-=dy;
tmp_vertex[i].z-=dz;

END

tmp_edge[1].v0=0; tmp_edge[1].v1=1;

build_objectf(obj_count,verts,edges,faces,col);
 fix=9;  parent=obj_count-1;
shaft_id[n]=tank_part(obj_count,verts,edges,faces,x0,y0,z0,ang,n,3,parent,fix,col);
SHAFT[n]=obj_count;
obj_count+=1;



//-BARREL------------------------------------------

verts=16;
v=8;  //number of verts on draw edges
half_v=v/2;


verts=22;
edges=18;
faces=6;
graph=20;    g=graph;
getpoint(0,26,g);
getpoint(1,15,g);
getpoint(2,16,g);
getpoint(3,17,g);
getpoint(4,18,g);
getpoint(5,19,g);
getpoint(6,20,g);
getpoint(7,21,g);
getpoint(8,22,g);


x=tmp_vertex[0].x;
dy=tmp_vertex[0].y;
dz=tmp_vertex[0].z;
for(i=0; i<=verts; i+=1)
tmp_vertex[i].x-=dx;
tmp_vertex[i].y-=dy;
tmp_vertex[i].z-=dz;

END


AssignFaceEdgeIndices();

build_objectf(obj_count,verts,edges,faces,col);



 fix=1;  parent =obj_count-1;
barrel_id[n]=tank_part(obj_count,verts,edges,faces,x0,y0,z0,ang,n,4,parent,fix,col);
BARREL[n]=obj_count;
obj_count+=1;




//-------------------------------------------
//RADAR POST


verts=2;
v=verts;;  //number of verts on draw edges
half_v=v/2;
edges=1;
graph=20;    g=graph;
getpoint(0,4,g);

tmp_vertex[1].x=tmp_vertex[0].x;
tmp_vertex[1].y=tmp_vertex[0].y+10;
tmp_vertex[1].z=tmp_vertex[0].z;

dx=tmp_vertex[0].x;
dy=tmp_vertex[0].y;
dz=tmp_vertex[0].z;
for(i=0; i<=verts; i+=1)
tmp_vertex[i].x-=dx;
tmp_vertex[i].y-=dy;
tmp_vertex[i].z-=dz;

END

tmp_edge[1].v0=0; tmp_edge[1].v1=1;

build_objectf(obj_count,verts,edges,faces,col);
 fix=2;  parent=turret[n];
post_id[n]=tank_part(obj_count,verts,edges,faces,x0,y0,z0,ang,n,5,parent,fix,col);
POST[n]=obj_count;
obj_count+=1;



//-------------------------------------------
 //RADAR DISH
verts=8;
v=8;
half_v=v/2;

verts=8;
edges=10;


graph=22; g=graph;

getpoint(0,0,g);
getpoint(1,1,g);
getpoint(2,2,g);
getpoint(3,3,g);
getpoint(4,4,g);
getpoint(5,5,g);
getpoint(6,6,g);
getpoint(7,7,g);
getpoint(8,8,g);

tmp_edge[1].v0=1 ; tmp_edge[1].v1=2;
tmp_edge[2].v0=2 ; tmp_edge[2].v1=3;
tmp_edge[3].v0=3 ; tmp_edge[3].v1=4;
tmp_edge[4].v0=4 ; tmp_edge[4].v1=5;
tmp_edge[5].v0=5 ; tmp_edge[5].v1=6;
tmp_edge[6].v0=6 ; tmp_edge[6].v1=7;
tmp_edge[7].v0=7 ; tmp_edge[7].v1=8;
tmp_edge[8].v0=8 ; tmp_edge[8].v1=1;
tmp_edge[9].v0=2 ; tmp_edge[9].v1=7;
tmp_edge[10].v0=3 ; tmp_edge[10].v1=6;

build_objectf(obj_count,verts,edges,faces,col);
fix=1; parent =post[n];
dish_id[n]= tank_part(obj_count,verts,edges,faces,x0,y0,z0,ang,n,6,parent,fix,col);
dish[n]=obj_count;
obj_count+=1;





END







PROCESS init_box(w,d,h,x0,y0,z0,ang,col)
PRIVATE
i; j; k;  l;
verts;
edges;
faces;
 ang;
 rad;
BEGIN

obj[obj_count].col0=col;


verts=22;
edges=18;
FACES=6;
tmp_vertex[0].x=0: tmp_vertex[0].y=0; tmp_vertex[0].z=0;


tmp_vertex[1].x=w: tmp_vertex[1].y=h; tmp_vertex[1].z=-d;
tmp_vertex[2].x=-w: tmp_vertex[2].y=h; tmp_vertex[2].z=-d;
tmp_vertex[3].x=-w: tmp_vertex[3].y=-h; tmp_vertex[3].z=-d;
tmp_vertex[4].x=w: tmp_vertex[4].y=-h; tmp_vertex[4].z=-d;

tmp_vertex[5].x=w: tmp_vertex[5].y=h; tmp_vertex[5].z=d;
tmp_vertex[6].x=-w: tmp_vertex[6].y=h; tmp_vertex[6].z=d;
tmp_vertex[7].x=-w: tmp_vertex[7].y=-h; tmp_vertex[7].z=d;
tmp_vertex[8].x=w: tmp_vertex[8].y=-h; tmp_vertex[8].z=d;
l=0;
tmp_vertex[9].x=0:  tmp_vertex[9].y=0;   tmp_vertex[9].z=-(d+l);
tmp_vertex[10].x=0:  tmp_vertex[10].y=0;  tmp_vertex[10].z=(d+l);
tmp_vertex[11].x=0:  tmp_vertex[11].y=(h+l); tmp_vertex[11].z=0;
tmp_vertex[12].x=0: tmp_vertex[12].y=-(h+l); tmp_vertex[12].z=0;
tmp_vertex[13].x=(w+l):  tmp_vertex[13].y=0; tmp_vertex[13].z=0;
tmp_vertex[14].x=-(w+l): tmp_vertex[14].y=0; tmp_vertex[14].z=0;





assignFaceEdgeIndices();

   if(obj_count==shell[0] or obj_count==shell[1]) rad=0; END



  //build_object(obj_count,verts,edges,col);
  build_objectf(obj_count,verts,edges,faces,col);

  y0=h;
  box(obj_count,verts,edges,faces,x0,y0,z0,ang,col);
  obj[obj_count].inradar=1;
  obj[obj_count].x0=x0;
  obj[obj_count].y0=y0;
  obj[obj_count].z0=z0;
obj_count+=1;
box_count+=1;



END //PROC





//--------------------------------------------------------------------------------
PROCESS update_objs();
PRIVATE
vel;

shrap;
BEGIN
z=0;

update_shell(0,_enter);
update_shell(1,_tab);

LOOP

// draw_3dline(obj[0].vertex[0].x,obj[0].vertex[0].y,obj[0].vertex[0].z,
  //                  obj[1].vertex[0].x,obj[1].vertex[0].y,obj[1].vertex[0].z,200);

//if( mouse.left and z==0) shrapnel(ied); z=1; END

//rotate_obj(TOWER,0,1000,0);
//rotate_obj(IED,1000,1000,0);

 shrap=ruby;
if(key(_i))   rotate_objzyx(shrap,1000,0,0); END
if(key(_k))   rotate_objzyx(shrap,-1000,0,0);END
if(key(_j))   rotate_objzyx(shrap,0,1000,0);END
if(key(_l))   rotate_objzyx(shrap,0,-1000,0);END
if(key(_y))   rotate_objzyx(shrap,0,0,1000);END
if(key(_h))   rotate_objzyx(shrap,0,0,-1000);END



FRAME;
END
END






//---------------------------------------------------------------------------------------
Process shrapnel(shrap)
PRIVATE
velh;
velv;
omg;
dist;
BEGIN
omg=rand(-3000,3000);

velv=20;
//LOOP
//if(velv>0)velv-=1;; END
LOOP
//rotate_objxyz(shrap,0,omg,0);
velv-=1;
move_objy(shrap,velv);
if(obj[shrap].vertex[0].y<40)
position_obj(shrap,obj[shrap].x0,obj[shrap].y0,obj[shrap].z0);
father.z=0;
//break;



END
FRAME;
    END


END



//---------------------------------------------------------------------------------------




PROCESS update_shell(n,fire)
PRIVATE
status;
velh;
velv;
col0;
travel;
x0; z0;y0;
x1; z1;y1;

BEGIN
status=0;
col0=obj[shell[n]].col0;
loop

switch (status)
case 0:

obj[shell[n]].angley=obj[turret[n]].angley;
obj[shell[n]].anglex=obj[barrel[n]].anglex;
Position_obj(SHELL[n],obj[BARREL[n]].vertex[0].x,obj[BARREL[n]].vertex[0].y+10000,obj[BARREL[n]].vertex[0].z);
rotate_objxyz(SHELL[n],0,0,0);



if(key(fire))
Position_obj(SHELL[n],obj[BARREL[n]].vertex[0].x,obj[BARREL[n]].vertex[0].y,obj[BARREL[n]].vertex[0].z);

velh= get_distx(obj[shell[n]].anglex,160);
velv= -get_disty(obj[shell[n]].anglex,160);
status=1;
END

END
case 1:
FLAGS=0;
move_objxz(shell[n],velh);
move_objy(shell[n],velv);
if(obj[shell[n]].vertex[0].y>0)
velv-=1;
 travel+=1;
 If( travel==1)
  x0=obj[shell[n]].vertex[0].x;
  y0=obj[shell[n]].vertex[0].y;
  z0=obj[shell[n]].vertex[0].z;



 END


 IF(Travel mod 2 ==0)


  x1=obj[shell[n]].vertex[0].x;
  y1=obj[shell[n]].vertex[0].y;
  z1=obj[shell[n]].vertex[0].z;

  tracer(x0,y0,z0,x1,y1,z1,144,16);

  x0=x1; y0=y1; z0=z1;


 END


 write_int(0,100,200+n*10,0,&travel);

ELSE
velv=0;
if(velv==0)
status=0;
travel=0;

END
END

END
default:
END

END




frame;
END
END

//---------------------------------------------------------------------------------------


  PROCESS tracer(x0,y0,z0,x1,y1,z1,col,life);
  private
  time;
  BEGIN
   LOOP

  if(time<life)
         draw_3dline(x0,y0,z0,x1,y1,z1,col-time*5);
  time+=1;
  ELSE
  break;
  END

  FRAME;

  END
  END

                //---------------------------------------------------------------------------------------
PROCESS rotate_objxyz(n,angX, angy, angz)
PRIVATE i; tmp;
BEGIN
obj[n].anglex+=angx;
obj[n].angley+=angy;
obj[n].anglez+=angz;


for( i=1; i<=obj[n].vertex_count; i+=1)

    obj[n].vertex[i].y=get_distx(obj[n].anglex,obj[n].vertex[i].yl)
                        +get_disty(obj[n].anglex,obj[n].vertex[i].zl);

    obj[n].vertex[i].z=get_distx(obj[n].anglex,obj[n].vertex[i].zl)
                        -get_disty(obj[n].anglex,obj[n].vertex[i].yl);

    obj[n].vertex[i].x=obj[n].vertex[i].xl;

END


for( i=1; i<=obj[n].vertex_count; i+=1)

    tmp=get_distx(obj[n].angley,obj[n].vertex[i].x)
                        -get_disty(obj[n].angley,obj[n].vertex[i].z);

    obj[n].vertex[i].z=get_distx(obj[n].angley,obj[n].vertex[i].z)
                        +get_disty(obj[n].angley,obj[n].vertex[i].x);

    obj[n].vertex[i].x=tmp:


END

for( i=1; i<=obj[n].vertex_count; i+=1)
    obj[n].vertex[i].y+=obj[n].vertex[0].y;
    obj[n].vertex[i].x+=obj[n].vertex[0].x;
    obj[n].vertex[i].z+=obj[n].vertex[0].z;
END


if(obj[n].angley>180000) obj[n].angley-=360000; END
if(obj[n].angley<=-180000) obj[n].angley+=360000; END

if(obj[n].angley>180000) obj[n].angley-=360000; END
if(obj[n].angley<=-180000) obj[n].angley+=360000; END

if(obj[n].angley>180000) obj[n].angley-=360000; END
if(obj[n].angley<=-180000) obj[n].angley+=360000; END


END

//--------------------------------------------------------------------------------

PROCESS rotate_objzyx(n,angX, angy, angz)
PRIVATE i; tmp;
BEGIN
obj[n].anglex+=angx;
obj[n].angley+=angy;
obj[n].anglez+=angz;


for( i=1; i<=obj[n].vertex_count; i+=1)

    obj[n].vertex[i].x=get_distx(obj[n].anglez,obj[n].vertex[i].xl)
                        +get_disty(obj[n].anglez,obj[n].vertex[i].yl);

    obj[n].vertex[i].y=get_distx(obj[n].anglez,obj[n].vertex[i].yl)
                        -get_disty(obj[n].anglez,obj[n].vertex[i].xl);

    obj[n].vertex[i].z=obj[n].vertex[i].zl;

END


for( i=1; i<=obj[n].vertex_count; i+=1)

    tmp=get_distx(obj[n].angley,obj[n].vertex[i].x)
                        -get_disty(obj[n].angley,obj[n].vertex[i].z);

    obj[n].vertex[i].z=get_distx(obj[n].angley,obj[n].vertex[i].z)
                        +get_disty(obj[n].angley,obj[n].vertex[i].x);

    obj[n].vertex[i].x=tmp:

END


for( i=1; i<=obj[n].vertex_count; i+=1)

    tmp=get_distx(obj[n].anglex,obj[n].vertex[i].y)
                        -get_disty(obj[n].anglex,obj[n].vertex[i].z);

    obj[n].vertex[i].z=get_distx(obj[n].anglex,obj[n].vertex[i].z)
                        +get_disty(obj[n].anglex,obj[n].vertex[i].y);

    obj[n].vertex[i].y=tmp:

END








for( i=1; i<=obj[n].vertex_count; i+=1)
    obj[n].vertex[i].y+=obj[n].vertex[0].y;
    obj[n].vertex[i].x+=obj[n].vertex[0].x;
    obj[n].vertex[i].z+=obj[n].vertex[0].z;
END


if(obj[n].angley>180000) obj[n].angley-=360000; END
if(obj[n].angley<=-180000) obj[n].angley+=360000; END


if(obj[n].angley>180000) obj[n].angley-=360000; END
if(obj[n].angley<=-180000) obj[n].angley+=360000; END

if(obj[n].angley>180000) obj[n].angley-=360000; END
if(obj[n].angley<=-180000) obj[n].angley+=360000; END

END



//--------------------------------------------------------------------------------



//--------------------------------------------------------------------------------
PROCESS position_obj(n,posx,posy,posz)
private i;
BEGIN
FOR(I=1; I<=obj[n].vertex_count; i+=1)
obj[n].vertex[i].x+=posx-obj[n].vertex[0].x;
obj[n].vertex[i].y+=posy-obj[n].vertex[0].y;
obj[n].vertex[i].z+=posz-obj[n].vertex[0].z;

END
obj[n].vertex[0].x+=posx-obj[n].vertex[0].x;
obj[n].vertex[0].y+=posy-obj[n].vertex[0].y;
obj[n].vertex[0].z+=posz-obj[n].vertex[0].z;


obj[n].posx=posx;
obj[n].posy=posy;
obj[n].posz=posz;

END

//--------------------------------------------------------------------------------

PROCESS move_objxz(n,vel)
PRIVATE i;
BEGIN

obj[n].vel=vel;

FOR(I=0; I<=obj[n].vertex_count; i+=1)
obj[n].vertex[i].x+=get_disty(obj[n].angley,obj[n].vel);
obj[n].vertex[i].z-=get_distx(obj[n].angley,obj[n].vel);
END


obj[n].posx=obj[n].vertex[0].x;
obj[n].posx=obj[n].vertex[0].y;
obj[n].posx=obj[n].vertex[0].z;




FRAME;

END



//--------------------------------------------------------------------------------


PROCESS move_objy(n,vel)
PRIVATE i;
BEGIN

obj[n].vely=vel;

FOR(I=0; I<=obj[n].vertex_count; i+=1)
obj[n].vertex[i].y+=obj[n].vely;
END


obj[n].posx=obj[n].vertex.x;
obj[n].posy=obj[n].vertex.y;
obj[n].posz=obj[n].vertex.z;


END


//--------------------------------------------------------------------------------


PROCESS tankobj(index,n,verts,edges,faces,x0,y0,z0,ang,up,dn,lf,rt,ctrl,col)
PRIVATE
i; n;  velx; velz;
tilt;
twist;
vel;

BEGIN
n=index;
obj[index].angley=ang;

renderme=draw_objf(index,n,1-n);

position_obj(n,x0,y0,z0);

frame;
LOOP
 tilt=0; twist=0;  vel=0;  ang=0;
if(key(ctrl))
tilt=(key(up)-key(dn))*1000;
ELSE
//obj[n].vel=(key(up)-key(dn))*10;
vel=(key(up)-key(dn))*30;

END

shaft_id[index].angle+=tilt;


move_objxz(n,vel);
if(key(ctrl))
twist=(key(lf)-key(rt))*1000;
ELSE
ang= (key(lf)-key(rt))*3000;

rotate_objxyz(index,0,ang,0);
END
turret_id[index].angle+=twist;



FRAME;
END

END




//--------------------------------------------------------------------------------
PROCESS tank_part(objNum,verts,edges,faces,x0,y0,z0,ang,n,part,parent,fix,col)
private i;
turret_angle;
shaft_angle;
BEGIN
    if( part<>3 and part<5)
      renderme=draw_objf(objNum,n,1-n);
    END

FOR(i=0; i<=verts; i+=1)
obj[objNum].vertex[i].x+=x0;
obj[objNum].vertex[i].y+=y0;
obj[objNum].vertex[i].z+=z0;

END


LOOP
obj[objnum].angley=obj[parent].angley;
obj[objnum].anglex=obj[parent].anglex;

position_obj(objNum,obj[parent].vertex[fix].x,obj[parent].vertex[fix].y,obj[parent].vertex[fix].z);

rotate_objxyz(objNum,0,0,0);
if(id==turret_id[n])
rotate_objxyz(objNum,0,angle,0);
END

if(id==shaft_id[n])
rotate_objxyz(objNum,angle,0,0);
END

if(id==dish_id[n])
angle=(angle-9000) mod 360000;
rotate_objxyz(objNum,0,angle,0);
END



x=obj[objNum].vertex[0].x;
y=obj[objNum].vertex[0].y;
z=obj[objNum].vertex[0].z;

FRAME;


END



END

//--------------------------------------------------------------------------------

//--------------------------------------------------------------------------------
PROCESS box(objNum,verts,edges,faces,x0,h,z0,ang,col)

BEGIN

  position_obj(objNum,x0,h,z0);


  renderme=draw_objf(objNum,1,1);


LOOP
FRAME;
END

END





//--------------------------------------------------------------------------------
PROCESS moon(cam_id,graph)
BEGIN
z=100;

LOOP
y=cam[cam_id].cy-scr_cy/4;

x=scr_cx-scr_cx*(cam[cam_id].angle)/cam[cam_id].fov;
FRAME:
END
END


//--------------------------------------------------------------------------------


//--------------------------------------------------------------------------------
PROCESS camera_control();

private
move[2];
BEGIN
priority=-100;
frame;
LOOP
for(c=0; c<=1; c+=1)
cam[c].angle=-obj[c].angley-turret_id[c].angle;
cam[c].posX= obj[turret[c]].vertex[0].x-get_Disty(obj[turret[c]].angley,300);
cam[c].posY= obj[turret[c]].vertex[0].y+60;
cam[c].posZ= obj[turret[c]].vertex[0].z+get_Distx(obj[turret[c]].angley,300);

end


FRAME;
END
END


//--------------------------------------------------------------------------------

PROCESS build_objectf(obj_count,verts,edges,faces,col);
PRIVATE
i;
BEGIN
obj[obj_count].vertex_count=verts;


for(i=0; i<=verts; i+=1)
obj[obj_count].vertex[i].x=tmp_vertex[i].x;
obj[obj_count].vertex[i].y=tmp_vertex[i].y;
obj[obj_count].vertex[i].z=tmp_vertex[i].z;

    obj[obj_count].vertex[i].xl=tmp_vertex[i].x;
    obj[obj_count].vertex[i].yl=tmp_vertex[i].y;
    obj[obj_count].vertex[i].zl=tmp_vertex[i].z;
END


obj[obj_count].edge_count=edges;
for(i=1; i<=edges; i+=1)
    obj[obj_count].edge[i].v0=tmp_edge[i].v0;
    obj[obj_count].edge[i].v1=tmp_edge[i].v1;
     obj[obj_count].edge[i].col=col;

END
      obj[obj_count].edge[i].col=col;

obj[obj_count].face_count=faces;
for(i=1; i<=faces; i+=1)
    obj[obj_count].face[i].e[0]=tmp_face[i].e[0];
    obj[obj_count].face[i].e[1]=tmp_face[i].e[1];
    obj[obj_count].face[i].e[2]=tmp_face[i].e[2];
    obj[obj_count].face[i].e[3]=tmp_face[i].e[3];
    obj[obj_count].face[i].e[4]=tmp_face[i].e[4];


END


FRAME;
END








//____DRAW 3DLINE___DRAW3D LINE_________________________




PROCESS draw_3dLine(x0,y0,z0,x1,y1,z1,col)
PRIVATE

k;  i;
DS;
draw_edge[2];
px[1];
py[1];
pz[1];
draw_me[2];
struct cv[1]
x,y,z,
END;

sx[1];
sy[1];
tmp;
BEGIN
px[0]=x0; py[0]=y0; pz[0]=z0;
px[1]=x1; py[1]=y1; pz[1]=z1;


for (k=0; k<=1; k+=1)
DS=cam[k].depth;
draw_me[k]=1;
FOR(i=0; i<=1; i+=1)
cv[i].x=px[i]-cam[k].posX;
cv[i].y=py[i]-cam[k].posy;
cv[i].Z=pz[i]-cam[k].posZ;

tmp=(cos(cam[k].angle)*cv[i].x+sin(cam[k].angle)*cv[i].z)/1000;
cv[i].z=(cos(cam[k].angle)*cv[i].z-sin(cam[k].angle)*cv[i].X)/1000;
cv[i].x=tmp;

    if(cv[i].z>=0)
    draw_me[k]=0;
    END

END

    if( draw_me[k]==1)
        FOR(i=0; i<=1; i+=1)
        sx[i]=cam[k].cx-cv[i].x*DS/cv[i].z;
        sy[i]=cam[k].cy+cv[i].y*DS/cv[i].z;
        END

        draw_edge[k]=draw(1,col,15,k+1,sx[0],sy[0],sx[1],sy[1]);


          END
END
FRAME;


for(k=0; k<=1; k+=1)
if(draw_me[k]==1)
delete_draw(draw_edge[k]);
draw_edge[k]=0;
END
draw_me[k]=1;
END

END



//______________________________________________________________________________________________


   //DRAWF_____DRAWF_______DRAWF___________________
//--------------------------------------------------------------------------------
process draw_objf(n,c0,c1)

PRIVATE
 i;j; k;  e;
 v1; v2;  eN;
 ds;
colfade;
colN;
normy; normx; normz;
sightx; sighty; sightz;
facing;
p1x,p1y,p1z,p0x,p0y,p0z,p2x,p2y,p2z;
draw_count;
nx; ny; nz;
verts; edges; faces;


incam[1];

struct cv[100]
 x;
 y;
 z;
END

draw_edge[100];
tmp;
col;
clip=-100;


BEGIN
priority=-200;

faces=obj[n].face_count;
edges=obj[n].edge_count;
verts=obj[n].vertex_count;


incam[0]=c0;
incam[1]=c1;
if(n<=1)

draw(1,green-29,15,0,0,cam[n].cy,scr_w,cam[n].cy);
END

LOOP



for (k=0; k<=1; k+=1)
if(incam[k]==1)
DS=cam[k].depth;

FOR(i=0; i<=verts; i+=1)
 cv[i].x=obj[n].vertex[i].x-cam[k].posX;
cv[i].y=obj[n].vertex[i].y-cam[k].posy;
cv[i].Z=obj[n].vertex[i].z-cam[k].posZ;

tmp=(cos(cam[k].angle)*cv[i].x+sin(cam[k].angle)*cv[i].z)/1000;
cv[i].z=(cos(cam[k].angle)*cv[i].z-sin(cam[k].angle)*cv[i].X)/1000;
cv[i].x=tmp;

if(cv[i].z==0)cv[i].z=1; END
obj[n].vertex[i].sx=cam[k].cx-cv[i].x*DS/cv[i].z;
obj[n].vertex[i].sy=cam[k].cy+cv[i].y*DS/cv[i].z;

END



for(c=1; c<=edges; c+=1)
   obj[n].edge[c].draw_me=0;
   obj[n].edge[c].draw_me=0;
   obj[n].edge[c].draw_me=0;
   obj[n].edge[c].draw_me=0;

END







for(c=1; c<=faces; c+=1)




p1x=    obj[n].vertex[obj[n].edge[obj[n].face[c].e[0]].v1].x;
p1y=    obj[n].vertex[obj[n].edge[obj[n].face[c].e[0]].v1].y;
p1z=    obj[n].vertex[obj[n].edge[obj[n].face[c].e[0]].v1].z;

p0x=    obj[n].vertex[obj[n].edge[obj[n].face[c].e[0]].v0].x;
p0y=    obj[n].vertex[obj[n].edge[obj[n].face[c].e[0]].v0].y;
p0z=    obj[n].vertex[obj[n].edge[obj[n].face[c].e[0]].v0].z;





       normx=p1x-p0x;
       normy=p1y-p0y;
       normz=p1z-p0z;
       sightx =cam[k].posx-p1x;
       sighty =cam[k].posy-p1y;
       sightz =cam[k].posz-p1z;


     facing=(normx*sightx+normy*sighty+normz*sightz);



    IF(facing>0)
        obj[n].edge[obj[n].face[c].e[1]].draw_me=1;
        obj[n].edge[obj[n].face[c].e[2]].draw_me=1;
        obj[n].edge[obj[n].face[c].e[3]].draw_me=1;
        obj[n].edge[obj[n].face[c].e[4]].draw_me=1;

    END

      if(n==-1)
        if(facing>0)colN=240; ELSE colN=223;  END
        draw_3dline(p1x,p1y,p1z,2*p1x-p0x,2*p1y-p0y,2*p1z-p0z,colN);
           END



     END




for(c=1; c<=edges; c+=1)




//-----------------------------------------------------------------
if(cv[obj[n].edge[c].v0].z<clip and cv[obj[n].edge[c].v1].z<clip and obj[n].edge[c].draw_me==1)


    if(obj[n].edge[c].col<>0)
        col=obj[n].edge[c].col;
    else
        col=obj[n].col0;
    END


colfade=cv[obj[n].edge[c].v0].z/100;
    if(colfade>-64)
        col+=colfade;
        draw_count+=1;
        draw_edge[draw_count]=draw(1,col,15,k+1,
                                    obj[n].vertex[obj[n].edge[c].v0].sx,
                                    obj[n].vertex[obj[n].edge[c].v0].sy,
                                    obj[n].vertex[obj[n].edge[c].v1].sx,
                                    obj[n].vertex[obj[n].edge[c].v1].sy);

    ELSE
        col=0;

    END

END  // EDGE LOOP
END  //Z>CLIP

END
END  //K LOOP

FRAME;





if(draw_count>0)
for(c=1; c<=draw_count; c+=1)
delete_draw(draw_edge[c]);
END
draw_count=0;
END



END //LOOP
END //PROC

//--------------------------------------------------------------------------------



PROCESS radar(index,x,y,r)
private
n;  i;   j; k; l;
col;
//inrad;
ang;
ang2;
dist;
rx; ry;

BEGIN
draw(4,15,15,0,x-r,y-r,x+r,y+r);

LOOP
angle=((angle-4000) +360000) mod 360000;
for(n=0; n<=obj_count; n+=1)
if( obj[n].inradar==1)
dist=fget_dist(obj[n].vertex[0].x,obj[n].vertex[0].z,obj[index].vertex[0].x,obj[index].vertex[0].z)/100;
if(dist<r)
ang=fget_angle(obj[index].vertex[0].x,obj[index].vertex[0].z,obj[n].vertex[0].x,obj[n].vertex[0].z)-
        obj[index].angley;



rx=get_distx(ang,dist);
ry=get_disty(ang,dist);


ang2=(abs(angle-fget_angle(0,0,rx,ry)))mod 360000;


if(index==0 and n==1)
write_int(0,100+index*100,100+n*10,0,&ang);
write_int(0,100+index*100,80+n*10,0,&angle);
write_int(0,100+index*100,120+n*10,0,&ang2);

END


if(abs(ang2)<5000)
blip(x+rx,y+ry,obj[n].col0-64);
END

END
END
END


renderme=draw(1,32,15,0,x,y,x+get_distx(angle,r),y+get_disty(Angle,r));



i=draw(1,32,15,0,//x,y,
                     x+get_distx(93000+obj[turret[index]].angley-obj[index].angley,r-4),
                     y+get_disty(93000+obj[turret[index]].Angley-obj[index].angley,r-4),

                     x+get_distx(93000+obj[turret[index]].angley-obj[index].angley,r+4),
                     y+get_disty(93000+obj[turret[index]].Angley-obj[index].angley,r+4));



j=draw(1,32,15,0,//x,y,
                     x+get_distx(87000+obj[turret[index]].angley-obj[index].angley,r-4),
                     y+get_disty(87000+obj[turret[index]].Angley-obj[index].angley,r-4),

                     x+get_distx(87000+obj[turret[index]].angley-obj[index].angley,r+4),
                     y+get_disty(87000+obj[turret[index]].Angley-obj[index].angley,r+4));






k=draw(1,32,15,0,x,y,

                     x+get_distx(120000+obj[turret[index]].angley-obj[index].angley,r),
                     y+get_disty(120000+obj[turret[index]].Angley-obj[index].angley,r));



l=draw(1,32,15,0,x,y,

                     x+get_distx(60000+obj[turret[index]].angley-obj[index].angley,r),
                     y+get_disty(60000+obj[turret[index]].Angley-obj[index].angley,r));







FRAME;
delete_draw(renderme);
delete_draw(i);
delete_draw(j);
delete_draw(K);
delete_draw(L);

 end

END


//--------------------------------------------------------------------------------
  PROCESS blip(x,y,col)
     PRIVATE
     draw_id;
     r=2;
     life=64;
  BEGIN

       while(life>0)
       draw_id=draw(4,col+life,15,0,x-r,y-r,x+r,y+r);
       life-=2;

  FRAME;

    delete_draw(draw_id);

    END
  END
//--------------------------------------------------------------------------------