//GLITCHES
//OCCASIONAL draw of objects with edges crossing the 0z coordinate when at higher abs x values


//TODO
//draw order



PROGRAM divbattlearenazone;


global
obj_count=0;
file0;
scr_w;
scr_h;
scr_cx;
scr_cy;

box_id[100];


IED;
TOWER;

SHELL[1];
TANK[1];
HULL[1];
TURRET[1];
SHAFT[1];
BARREL[1];


tank_id[1];

SHELL_ID[1];
HULL_ID[1];
TURRET_ID[1];
SHAFT_ID[1];
BARREL_ID[1];


/*
struct tank_data[1]
self;
part[6];
turret;
barrel;
hull;
shaft;
END
*/

struct part[4]
Nverts;
struct vert[8]
x,y,z; xi,yl,zl;
END
struct edge[12]
v0;v1;col;
END
END

tank_draw[1];
radar_id[1];
tank_count;
box_count;


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


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;
anglez;
anglex;
angley=0;
vel; vely;
col0;
struct vertex[100]
x,y,z;
xl, yl,zl;
sX,sy; sz;

END

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

END


//-------


struct tmp_vertex[100]
x,y,z;

END


struct tmp_edge[100]
v0; v1;
END






LOCAL
c;

PRIVATE
i; j; x0; y0; z0;

struct vertex[40]
x,y,z;

END

struct edge[30]
v0; v1;
END



BEGIN
set_fps(60,0);
scr_w=1200;
scr_h=800;
//scr_w=1000;
//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);

//camera_control();



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=600;  //Gives a FOV of 45^ for defined screen width  of1200

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

END


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


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

camera_control();


moon(1,101);
moon(2,101);


//radar(1);
//radar(2);



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

draw(1,34,15,0,0,cam[1].cy,scr_w,cam[1].cy);
draw(1,34,15,0,0,cam[2].cy,scr_w,cam[2].cy);






init_objects();


 write_int(0,10,10,0,&fps);

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,56);
 TANK[1]=obj_Count;
 init_tank(0,0,-1000,180000,_w,_s,_a,_d,_l_shift,24);


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



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



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


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),16*rand(2,8)+10);

END


IED=obj_count;
obj[ied].col0=40;
init_box(100,100,100,600,2000,0,0,40);






SHELL[0]=obj_count;
init_box(5,5,5,100,400,100,0,56);


SHELL[1]=obj_count;
init_box(5,5,5,100,400,100,0,26);





//init_logo();

//TODO

//init flag
//init_radardish

/*

*/

update_objs();
END





//--------------------------------------------------------------------------------
PROCESS init_logo()
   PRIVATE
   parts[7];
  i;
BEGIN

 parts[0]=obj_count;
 init_prism(40,22,0,40,-300,0,10,5,0,0);
 parts[1]=obj_count;
 init_prism(41,16,0,40,-300,0,58,10,0,0);
 parts[2]=obj_count;
  init_prism(42,24,0,40,-300,0,58,10,0,0);
 parts[3]=obj_count;
 init_prism(43,22,0,40,-300,0,70,10,0,0);
 parts[4]=obj_count;
 init_prism(44,22,0,40,-300,0,70,10,0,0);
 parts[5]=obj_count;
 init_prism(45,22,0,40,-300,0,70,10,0,0);


LOOP
for(i=0; i<=5; i+=1)
rotate_obj(parts[i],0,1000,0);
END
FRAME;
END
END





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

PRIVATE x0; y0; z0; i; j; k;  l;
verts;
edges;
g;
half_v;
v;
BEGIN
verts=11;
v=8;  //number of verts on draw edges
half_v=v/2;
edges=12;
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);
getpoint(11,26,g);

For(i=1;i<=half_v; i+=1)
tmp_edge[i].v0=i; tmp_edge[i].v1=i+half_v;
tmp_edge[i+half_v].v0=i; tmp_edge[i+half_v].v1=i+1; IF(I==half_v) tmp_edge[i+half_v].v1=1;      END
tmp_edge[i+v].v0=i+half_v; tmp_edge[i+v].v1=i+half_v+1; IF(I==half_v) tmp_edge[i+v].v1=half_v+1;    END
END
build_object(obj_count,verts,edges,col);


obj[obj_count].col0=col;

tankobj(obj_count,verts,edges,x0,y0,z0,ang,up,dn,lf,rt,ctrl,col);


obj_count+=1;
tank_count+=1;




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


 col=obj[n].col0;
//-------------------------------------------


verts=8;
v=8;  //number of verts on draw edges
half_v=v/2;
edges=12;
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);

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

For(i=1;i<=half_v; i+=1)
tmp_edge[i].v0=i; tmp_edge[i].v1=i+half_v;
tmp_edge[i+half_v].v0=i; tmp_edge[i+half_v].v1=i+1; IF(I==half_v) tmp_edge[i+half_v].v1=1;      END
tmp_edge[i+v].v0=i+half_v; tmp_edge[i+v].v1=i+half_v+1; IF(I==half_v) tmp_edge[i+v].v1=half_v+1;    END
END
build_object(obj_count,verts,edges,col);

 fix=9; parent=n;
//tank_data[n].hull=
hull_id[n]=tank_part(obj_count,verts,edges,x0,y0,z0,ang,n,1,parent,fix,col);
HULL[n]=obj_count;
obj_count+=1;
//-------------------------------------------


verts=7;
v=6;;  //number of verts on draw edges
half_v=v/2;
edges=9;
graph=20;    g=graph;
getpoint(0,25,g);
getpoint(1,3,g);
getpoint(2,4,g);
getpoint(3,5,g);
getpoint(4,10,g);
getpoint(5,11,g);
getpoint(6,12,g);
getpoint(7,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




For(i=1;i<=half_v; i+=1)
tmp_edge[i].v0=i; tmp_edge[i].v1=i+half_v;
tmp_edge[i+half_v].v0=i; tmp_edge[i+half_v].v1=i+1; IF(I==half_v) tmp_edge[i+half_v].v1=1;      END
tmp_edge[i+v].v0=i+half_v; tmp_edge[i+v].v1=i+half_v+1; IF(I==half_v) tmp_edge[i+v].v1=half_v+1;    END
END
build_object(obj_count,verts,edges,col);
 fix=10;  parent=n;
//tank_data[n].turret=
turret_id[n]=tank_part(obj_count,verts,edges,x0,y0,z0,ang,n,2,parent,fix,col);
TURRET[n]=obj_count;
obj_count+=1;
//-------------------------------------------

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_object(obj_count,verts,edges,col);
 fix=7;  parent=obj_count-1;
//tank_data[n].shaft=
shaft_id[n]=tank_part(obj_count,verts,edges,x0,y0,z0,ang,n,3,parent,fix,col);
SHAFT[n]=obj_count;
obj_count+=1;



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

verts=8;
v=8;  //number of verts on draw edges
half_v=v/2;
edges=12;
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




For(i=1;i<=half_v; i+=1)
tmp_edge[i].v0=i; tmp_edge[i].v1=i+half_v;
tmp_edge[i+half_v].v0=i; tmp_edge[i+half_v].v1=i+1; IF(I==half_v) tmp_edge[i+half_v].v1=1;      END
tmp_edge[i+v].v0=i+half_v; tmp_edge[i+v].v1=i+half_v+1; IF(I==half_v) tmp_edge[i+v].v1=half_v+1;    END
END
build_object(obj_count,verts,edges,col);
 fix=1;  parent =obj_count-1;
//tank_data[n].barrel=
barrel_id[n]=tank_part(obj_count,verts,edges,x0,y0,z0,ang,n,4,parent,fix,col);
BARREL[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;
 ang;
 rad;
BEGIN

obj[obj_count].col0=col;


verts=8;
edges=12;

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;


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;



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



  build_object(obj_count,verts,edges,col);
  box_id[box_count]=box(obj_count,verts,edges,x0,h,z0,ang,col);
obj_count+=1;
box_count+=1;



END //PROC

//---------------------------------------------------------------------------------------
PROCESS init_gem(order,x0,y0,z0,col,size)
PRIVATE
i; j; k;  l;
verts;
edges;
 ang;
BEGIN




verts=order*2;
edges=verts*2;

tmp_vertex[0].x=0: tmp_vertex[0].y=0; tmp_vertex[0].z=0;

For(i=1; i<=order; i+=1)
tmp_vertex[i].x=get_distx(i*360000/order,size); tmp_vertex[i+order].x=get_distx(i*360000/order,size/2);
tmp_vertex[i].y=size;  tmp_vertex[i+order].y=3*size/2;
tmp_vertex[i].z=get_disty(i*360000/order,size); tmp_vertex[i+order].z=get_disty(i*360000/order,size/2);
tmp_vertex[i].y=-tmp_vertex[i].y;
tmp_vertex[i+order].y=-tmp_vertex[i+order].y;
END

//For(i=0; i<=order; i+=1)
//tmp_vertex[i].y=-tmp_vertex[i].y;
//tmp_vertex[i+order].y=-tmp_vertex[i+order].y;
//END


for(i=1;i<=order; i+=1)
tmp_edge[i].v0=0; tmp_edge[i].v1=i;
j=i+order;
tmp_edge[j].v0=i; tmp_edge[j].v1=j;
k=i+order*2;
tmp_edge[k].v0=i; tmp_edge[k].v1=i+1;  if(i%order==0) tmp_edge[k].v1=i+1-order; END
l=i+order*3;
tmp_edge[l].v0=j; tmp_edge[l].v1=j+1;  if(i%order==0) tmp_edge[l].v1=j+1-order; END

END

  build_object(obj_count,verts,edges,col);

position_obj(obj_count,x0,y0,z0);
box_id[box_count]=draw_obj(obj_count,verts,edges,x0,3*size/2,z0);
obj_count+=1;
box_count+=1;



END //PROC

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

PRocess init_prism(graph,verts,x0,y0,z0,ang,col,depth,axis,cp0)

PRIVATE x0; y0; z0; i; j; k;  l;   v;
edges;
ang;

BEGIN




v=verts/2;
edges=verts+v;

get_real_point(0,&tmp_vertex[0].x,&tmp_vertex[0].y);
tmp_vertex[0].z=0;

if(axis==0)
For(i=0; i<=v; i+=1)
get_real_point(i,&tmp_vertex[i].x,&tmp_vertex[i].y);
END


For(i=1; i<=v; i+=1)
tmp_vertex[i].y=-tmp_vertex[i].y ;
tmp_vertex[i+v].x= tmp_vertex[i].x;
tmp_vertex[i+v].y =tmp_vertex[i].y;
tmp_vertex[i].z =depth; tmp_vertex[i+v].z=-depth;

END

ELSE
For(i=cp0; i<=v; i+=1)
get_real_point(i,&tmp_vertex[i].x,&tmp_vertex[i].z);
END
tmp_vertex[0].y=0;
For(i=1; i<=v; i+=1)
tmp_vertex[i].y=-tmp_vertex[i].y ;

tmp_vertex[i+v].x= tmp_vertex[i].x;
tmp_vertex[i+v].z =tmp_vertex[i].z;
tmp_vertex[i].y =depth; tmp_vertex[i+v].y=-depth;

END




END

FOR(i=1; i<=v; i+=1)
tmp_edge[i].v0=i; tmp_edge[i].v1=i+1;  if(i==v) tmp_edge[i].v1-=v; END
tmp_edge[i+v].v0=i; tmp_edge[i+v].v1=i+v;
tmp_edge[i+verts].v0=i+v; tmp_edge[i+verts].v1=i+v+1;  if(i==v) tmp_edge[i+verts].v1-=v; END

END



build_object(obj_count,verts,edges,col);
position_obj(obj_count,x0,y0,z0);
box_id[box_count]=draw_obj(obj_count,verts,edges,x0,y0,z0);
obj_count+=1;
box_count+=1;

END  //proc


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

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


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





FRAME;
END
END


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

PROCESS update_shell(n,fire)
PRIVATE
status;
velh;
velv;
col0;
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_obj(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;
ELSE
velv=0;
if(velv==0)
status=0;


END
END

END
default:
END

END




frame;
END
END

//---------------------------------------------------------------------------------------
PROCESS rotate_obj(n,angX, angy, angz)
PRIVATE i;
dh;

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:

//obj[n].vertex[i].y=obj[n].vertex[i].yl;

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


END





//--------------------------------------------------------------------------------
PROCESS angle_obj(n,angX,angY,angZ)
PRIVATE
i;
BEGIN

obj[n].anglez=angz;


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

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

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


//obj[n].vertex[i].y=obj[n].vertex[i].yl;


obj[n].vertex[i].x+=obj[n].vertex[0].x;
obj[n].vertex[i].z+=obj[n].vertex[0].z;

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;



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

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



END


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


PROCESS tankobj(index,verts,edges,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;
draw_obj(index,verts,edges,x0,y0,z0);



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_obj(index,0,ang,0);
END
turret_id[index].angle+=twist;



FRAME;
END

END




//--------------------------------------------------------------------------------
PROCESS tank_part(objNum,verts,edges,x0,y0,z0,ang,n,part,parent,fix,col)
private i;
turret_angle;
shaft_angle;
BEGIN
if(part<>3)
     draw_obj(objNum,verts,edges,x0,y0,z0);
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_obj(objNum,0,0,0);
if(id==turret_id[n])
rotate_obj(objNum,0,angle,0);
END

if(id==shaft_id[n])
rotate_obj(objNum,angle,0,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,x0,h,z0,ang,col)

BEGIN

  position_obj(objNum,x0,h,z0);
  draw_obj(objNum,verts,edges,x0,h,z0);
LOOP

//rotate_obj2(objNum,1000,0,0);
FRAME;
END

END





//--------------------------------------------------------------------------------
PROCESS moon(cam_id,graph)
BEGIN
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=1; c<=2; c+=1)
cam[c].angle=-obj[c-1].angley-turret_id[c-1].angle;
cam[c].posX= obj[turret[c-1]].vertex[0].x-get_Disty(obj[turret[c-1]].angley,400);
cam[c].posY= obj[turret[c-1]].vertex[0].y+60;
cam[c].posZ= obj[turret[c-1]].vertex[0].z+get_Distx(obj[turret[c-1]].angley,400);

end


FRAME;
END
END


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


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

PROCESS build_object(obj_count,verts,edges,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

FRAME;
END








//--------------------------------------------------------------------------------
process draw_obj(n,verts,edges,x0,y0,z0)


PRIVATE
 i;j; k;
 ds;
struct cv[100]
 x;
 y;
 z;
END

draw_edge[100];
tmp;
col;
draw_me[2];
clip=-150;


BEGIN
priority=-200;
LOOP





for (k=1; k<=2; 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

draw_me[k]=false;
if(cv[0].z<clip)
draw_me[k]=true;

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

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

 //col=obj[n].col0;
draw_edge[c+edges*(k-1)]=draw(1,col+rand(0,3),15,k,
             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);

END
END
END

FRAME;



for(k=1; k<=2; k+=1)
if(draw_me[k]==True)
for(c=1; c<=edges; c+=1)
delete_draw(draw_edge[c+edges*(k-1)]);
END
END
END


END


END

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



    /*


    */

PROCESS radar(index)
private r;
cvx; cvy; cvz;
blipx;
blipy;
n;  i;
col;
inrad;
k;
tmp;
BEGIN
k=index;
priority=-300;
r=scr_cy/4;

x=scr_W-r; y=cam[index].cy+r;
draw(4,30,15,0,x-r,y-r,x+r,y+r);
draw(5,30,15,0,x-1,y-1,x+1,y+1);


LOOP


FRAME;

 end

END


//--------------------------------------------------------------------------------
  PROCESS blip(x,y,col)
     PRIVATE
     draw_id;
     r=2;
  BEGIN
       draw_id=draw(4,col,15,0,x-r,y-r,x+r,y+r);

  FRAME;

    delete_draw(draw_id);
  END
//--------------------------------------------------------------------------------