
PROGRAM divbattlearenazone;




CONST
red=192;
green=128;
blue=231;
white=63;
yellow=202;
magenta=240;
cyan=224;



global
obj_count=0;
tank_count=0;;
box_count=0;;
shell_count=0;


ctank_graph[1];
cshell_graph[1];
chull_graph;



file0;
scr_w;
scr_h;
scr_cx;
scr_cy;
box_id;




//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];




snd_rolling;
snd_tilting;
snd_twisting;






struct score
kills[1];
END





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;
c_id;
struct vertex[100]
x,y,z;
xl, yl,zl;
sX[1],sy[1]; sz[1];
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


snd_rolling=load_wav("rolling.wav",1);
snd_tilting=load_wav("tilting.wav",1);
snd_twisting=load_wav("twisting.wav",1);


//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);

huds(0,scr_cx,scr_cy/2);
huds(1,scr_cx,3*scr_cy/2);



draw(2,70,15,0,0,0,scr_w-1,scr_cy-1);
draw(2,70,15,0,0,scr_cy+1,scr_w-1,scr_h-1);




 write_int(0,10,10,0,&fps);
 write(0,10,20,0,"hits:");
 write_int(0,10,30,0,&score.kills[0]);
 write_int(0,10,40,0,&score.kills[1]);

init_objects();


borderforce();


physworld();

 /*


*/

END


//============================================================================================
Process physworld()
PRIVATE
s_back;
BEGIN
s_back=new_map(256,256,0,0,64);
START_Scroll(0,0,s_back,0,0,15);
z=draw_z+1;
scroll.z=z+1;

graph=new_map(scr_w,scr_h,0,0,64);
loop

frame;
end
END
//-----------------------------------------------------------------


PRocess c_box(n,w,d,h,x,y0,y,angLE);

BEGIN
height=h;
ctype=c_scroll;
graph=new_map(2*w,2*d,w,d,240);


Loop
if(id==obj[shell[0]].c_id)
write_int(0,100,15,0,&x);
END
frame;
end

END


//============================================================================================



PROCESS borderforce()
PRIVATE
w=10000;
x0; z0; x1; z1;  i;  d;
lx0; lz0; lx1; lz1;
struct pst[48]
x,y,z,col;
END

BEGIN
x0=-w;
z0=-w;
x1=w;
z1=w;

pst[0].x=0;
pst[0].y=0;
pst[0].z=0;
 pst[0].col=white;




init_box(100,100,4000,pst[0].x,pst[0].y,pst[c].z,0,white);


for(c=1; c<=48; c+=1)
pst[c].x=get_distx(c*7500,w);
pst[c].y=0;
pst[c].z=get_disty(c*7500,w);
pst[c].col=green+1;

init_plane(600,50,pst[c].x,pst[c].y,pst[c].z,c*7500,green);
rotate_objxyz(obj_count-1,0,90000+c*7500,0);

END



LOOP





//for(c=0; c<=12; c+=1)
//draw_3dline (pst[c].x,0,pst[c].z,pst[c].x,200,pst[c].z,1,1,pst[c].col);
//END

FRAME;
END


END
//-------------------------------------------------------------------------------------------
PROCESS huds(index,x,y);
PRIVATE
h1; w1; col0=100;  col;
h2;  w2;
h3;  K; l; j; m;    h;
d_id[20];
BEGIN
priority=1000;
h1=(scr_cy/2)*8/12;
h2=scr_cy/2;
h3=scr_cy/2*4/12;
w1=80;
w2=60;
h=10;
col=col0;

d_id[1]=draw(1,col,15,0,x,y+h1,x,y+h2);
d_id[2]=draw(1,col,15,0,x,y-h1,x,y-h2);

d_id[3]=draw(1,col,15,0,x-w1,y-h1,x+w1,y-h1);
d_id[4]=draw(1,col,15,0,x-w1,y+h1,x+w1,y+h1);

d_id[5]=draw(1,col,15,0,x-w1,y+h1,x-w1,y+h3);
d_id[6]=draw(1,col,15,0,x-w1,y-h1,x-w1,y-h3);

d_id[7]=draw(1,col,15,0,x+w1,y+h1,x+w1,y+h3);
d_id[8]=draw(1,col,15,0,x+w1,y-h1,x+w1,y-h3);



for(c=0; c<9; c+=1)

if(c<12)
draw(1,col-10,15,0,x-w2+c,y+20+get_disty(c*5000,h1+h),x-w2-10,y+20+get_disty(c*5000,h1+h));
END
END
d_id[0]=draw(1,col,15,0,x-w2+2,y-11,x-w2-12,y-9);


//compass(index,x,y-h1+20,&obj[index].angley,1);
while(not turret[index])
frame;
END
dial(index,x,y-h1+20,&obj[index].angley,&obj[turret[index]].angley);
compass(index,x,y+h1-20,&obj[turret[index]].angley,1);




LOOP

col=col0;

if(shaft_id[index])
move_draw(d_id[0],col+32,15,x-w2+8,y+20+get_disty(shaft_id[index].angle,100),x-w2-10,y+20+get_disty(shaft_id[index].angle,100));
END



FRAME;


END
END





process dial(index,x,y,angley,angley1)

private
h1; w1; col0=100;  col;
h2;  w2;
h3;  K; l; j; m;             h;
d_id[20];
BEGIN
priority=1000;
h1=(scr_cy/2)*8/12;
h2=scr_cy/2;
h3=scr_cy/2*4/12;
w1=40;
w2=30;
col=col0;
 for(c=1; c<=18; c+=1)
d_id[c]=draw(1,col-10,15,0,x+get_disty(c*10000-90000,w2),y+h1-10,x+get_disty(c*10000-90000,w2),y+h1-h);
END

LOOP


for(c=1; c<=18; c+=1)
j=get_disty(*angley-*angley1-20000*c,w2);
l=get_distx((*angley-*angley1-20000*c)/2,6);
//m=get_distx((*angley-*angley1-20000*c),12);

 if(c==18) h=20; col=white; else h=14; col=100; END

move_draw(d_id[c],col-16,15,x+j,y-l-m,x+j,y+l-m);
END

 FRAME;

 END
END

 //-----------------------------------------------------------------------------------------------------
 PROCESS compass(index,x,y,angley,points)


PRIVATE
h1; w1; col0=100;  col;
h2;  w2;
h3;  K; l; j; m;
d_id[20];
BEGIN
priority=1000;
h1=(scr_cy/2)*8/12;
h2=scr_cy/2;
h3=scr_cy/2*4/12;
w1=60;
w2=40;

col=col0;




 for(c=1; c<=18; c+=1)
d_id[c]=draw(1,col-10,15,0,x+get_disty(c*10000-90000,w2),y+h1-10,x+get_disty(c*10000-90000,w2),y+h1-16);
END



LOOP

col=col0;




if(turret[index])



for(c=1; c<=4; c+=1)
j=get_disty(*angley-45000-90000*c,w2);
l=get_distx((*angley-45000-90000*c)/2,6);
move_draw(d_id[c],col-16,15,x-j,y+l,x-j,y-l);
END


j=get_disty(*angley-5000,w2);
l=get_distx(*angley/2,10);
k=get_disty(*angley+5000,w2);
if(*angley<=90000 or *angley>=270000) col=col0; else col-=16; END

if(*angley>180000) l=-l; END
move_draw(d_id[13],col,7,x-j,y+l,x-j,y-l);
move_draw(d_id[14],col,7,x-k,y+l,x-k,y-l);
move_draw(d_id[15],col,7,x-k,y+l,x-j,y-l);

j=get_disty(*angley-5000-180000,w2);
l=get_distx((*angley-180000)/2,6);
k=get_disty(*angley+5000-180000,w2);
if(*angley>=90000 and *angley<=270000) col=col0; else col-=16; END
move_draw(d_id[16],col,7,x-j,y-l,x-k,y-l);
move_draw(d_id[17],col,7,x-j,y+l,x-k,y+l);
move_draw(d_id[18],col,7,x-k,y+l,x-j,y-l);
j=get_disty(*angley-5000+90000,w2);
l=get_distx((*angley+90000)/2,6);
k=get_disty(*angley+5000+90000,w2);
if(*angley>=0 and *angley>=180000) col=col0; else col-=16; END
move_draw(d_id[5],col,7,x-j,y+l,x-j,y-l);
move_draw(d_id[6],col,7,x-j,y+l,x-k,y+l);
move_draw(d_id[7],col,7,x-j,y-l,x-k,y-l);
move_draw(d_id[8],col,7,x-j,y-1,x-k,y-1);
j=get_disty(*angley-5000+270000,w2);
k=get_disty(*angley+5000+270000,w2);
l=get_distx((*angley+270000)/2,6);
m=get_disty(*angley+270000,w2);
if(*angley>=0 and *angley<=180000) col=col0; else col-=16; END
move_draw(d_id[9],col,7,x-j,y+l,x-j,y-l);
move_draw(d_id[10],col,7,x-k,y+l,x-k,y-l);
move_draw(d_id[11],col,7,x-j,y-l,x-m,y);
move_draw(d_id[12],col,7,x-k,y-l,x-m,y);

 END


FRAME;


END


 END





////_________________________________________________________________________________
PROCESS init_objects()
 private n;
BEGIN

  //TANKS MUSTCOME FIRST

 TAnk[0]=obj_count;
 init_tank(0,0,2000,0,_up,_down,_left,_right,_r_shift,green);
 TANK[1]=obj_Count;
 init_tank(0,0,-2000,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,200,0,0,10000,0,white);


from c=0 to 10;
init_box(rand(100,200),rand(100,200),rand(100,300),rand(-5000,5000),0,rand(-5000,5000),rand(-180000,180000),green);
END


//IED=obj_count;
//init_box(100,100,100,00,5000,0,0,green);

//init_plane(100,100,200,200,200,0,magenta);




SHELL[0]=obj_count;
init_shell(5,5,5,00,10000,00,0,green);
 obj[shell[0]].inradar=0;
SHELL[1]=obj_count;
init_shell(5,5,5,0,10000,00,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;
sx; sz;
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;


sz=tmp_vertex[2].z-tmp_vertex[3].z;
sx=tmp_vertex[2].x-tmp_vertex[6].x;
sz=222;
sx=174;

if(tank_count==0)

ctank_graph[tank_count]=new_map(sx,sz,87,125,202);
ELSE
ctank_graph[tank_count]=new_map(sx,sz,87,125,230);

END


tank_id[tank_count]=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;
sx; sz;
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);


sz=85;
sx=72;



chull_graph=new_map(sx,sz,36,28,63);
//ctank_graph[tank_count]=new_map(sx,sz,87,125,230);


 fix=9; parent=n;

hull_id[n]=tank_part(obj_count,verts,edges,faces,x0,y0,z0,ang,n,1,parent,fix,col,chull_graph);
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,100);
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,100);
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,100);
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;
faces=0;
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,100);
POST[n]=obj_count;
obj_count+=1;



//-------------------------------------------
 //RADAR DISH
verts=8;
v=8;
half_v=v/2;

verts=20;
edges=16;
faces=6;

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;

tmp_edge[11].v0=9 ; tmp_edge[11].v1=10;
tmp_edge[12].v0=11 ; tmp_edge[12].v1=12;
tmp_edge[13].v0=13 ; tmp_edge[13].v1=14;

tmp_edge[14].v0=15 ; tmp_edge[14].v1=16;
tmp_edge[15].v0=17; tmp_edge[15].v1=18;
tmp_edge[16].v0=19 ; tmp_edge[16].v1=20;




makeface(1,11,1,9,7,8,4);
makeface(2,12,2,10,6,9,4);
makeface(3,13,3,4,5,10,4);
makeface(4,14,3,10,5,4,4);
makeface(5,15,2,9,6,10,4);
makeface(6,16,1,8,7,9,4);



getfacecentrevertex(9,1,2,7,8);
getfacecentrevertex(11,2,3,6,7);
getfacecentrevertex(13,3,4,5,6);
getfacecentrevertex(15,3,4,5,6);
getfacecentrevertex(17,2,3,6,7);
getfacecentrevertex(19,1,2,7,8);


getfacenormalvector(9,10,1,2,7,8);
getfacenormalvector(11,12,2,3,6,7);
getfacenormalvector(13,14,3,4,5,6);
getfacenormalvector(15,16,3,6,5,4);
getfacenormalvector(17,18,2,7,6,3);
getfacenormalvector(19,20,1,8,7,2);




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,100);
dish[n]=obj_count;
obj_count+=1;





END

//----------------------------------------------------------------------------------------------------------------------

 PRocess init_plane(w,h,x0,y0,z0,ang,col)
PRIVATE
i; j; k;  l;
verts;
edges;
faces;
 ang;
 rad;
BEGIN

obj[obj_count].col0=col;


verts=5;
edges=5;
FACES=1;
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=0;
tmp_vertex[2].x=-w: tmp_vertex[2].y=h; tmp_vertex[2].z=0;
tmp_vertex[3].x=-w: tmp_vertex[3].y=-h; tmp_vertex[3].z=0;
tmp_vertex[4].x=w: tmp_vertex[4].y=-h; tmp_vertex[4].z=0;
tmp_vertex[5].x=0: tmp_vertex[5].y=0; tmp_vertex[5].z=-100;


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=0; tmp_edge[5].v1=5;


tmp_face[1].e[0]=5;
tmp_face[1].e[1]=1;
tmp_face[1].e[2]=2;
tmp_face[1].e[3]=3;
tmp_face[1].e[4]=4;


build_objectf(obj_count,verts,edges,faces,col);
plane(obj_count,verts,edges,faces,x0,y0+h/2,z0,ang,col);


obj_count+=1;

END
//____________________________________________________________________________


PROCESS init_shell(w,d,h,x0,y0,z0,ang,col)
PRIVATE
i; j; k;  l;
verts;
edges;
faces;
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();



  build_objectf(obj_count,verts,edges,faces,col);

  y0=h;

 shell_id[shell_count]=shellobj(shell_count);

  obj[obj_count].inradar=1;
  obj[obj_count].x0=x0;
  obj[obj_count].y0=y0;
  obj[obj_count].z0=z0;
obj_count+=1;
shell_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();



  //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].c_id=c_box(obj_count,w,d,h,x0,y0,z0,ang);

  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


//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 shellobj(n)

PRIVATE
status;
velh;
velv;
col0;
travel;
x0; z0;y0;
x1; z1;y1;
 dist;
 vel;
fire;
hit_box;
hit_tank;
BEGIN

  renderme=draw_objf(shell[n],1,1);

vel=30;
//vel=400;
status=0;
col0=obj[shell[n]].col0;
graph=100;
ctype=c_scroll;
if(n==0) fire=_enter; else fire=_tab;  END

Position_obj(SHELL[n],obj[BARREL[n]].vertex[0].x,obj[BARREL[n]].vertex[0].y+10000,obj[BARREL[n]].vertex[0].z);
y=10000;

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+50,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);
obj[shell[n]].angley=obj[turret[n]].angley;
obj[shell[n]].anglex=obj[barrel[n]].anglex;
rotate_objxyz(SHELL[n],0,0,0);


dist=0;
velh= get_distx(obj[shell[n]].anglex,vel);
velv= -get_disty(obj[shell[n]].anglex,vel);
status=1;
x=obj[shell[n]].posx;
y=obj[shell[n]].posz;
z=obj[shell[n]].posy;
col0=green;
END


END


case 1:
FLAGS=0;
dist+=velh;


if(obj[shell[n]].vertex[0].y>0)

move_objxz(shell[n],velh);
move_objy(shell[n],velv);

x=obj[shell[n]].posx;
y=obj[shell[n]].posz;
z=obj[shell[n]].posy;

hit_box=(collision(type c_box));
if(hit_box)
write_int(0,100,100,0,&hit_box.height);
if(hit_box.height>z/2)
move_objxz(shell[n],-velh/2);
explosion(n,4,obj[shell[n]].vertex[0].sx[n],obj[shell[n]].vertex[0].sy[n],obj[shell[n]].vertex[0].sz[n],n);
explosion(n,4,obj[shell[n]].vertex[0].sx[1-n],obj[shell[n]].vertex[0].sy[1-n],obj[shell[n]].vertex[0].sz[1-n],1-n);
Position_obj(SHELL[n],obj[BARREL[n]].vertex[0].x,obj[BARREL[n]].vertex[0].y-10000,obj[BARREL[n]].vertex[0].z);
velh=0;
END
END


hit_tank=collision(type tankobj);
if(hit_tank)
if(hit_tank<>tank_id[n] and z<55)
move_objxz(shell[n],-velh/2);
explosion(n,4,obj[shell[n]].vertex[0].sx[n],obj[shell[n]].vertex[0].sy[n],obj[shell[n]].vertex[0].sz[n],n);
Position_obj(SHELL[n],obj[BARREL[n]].vertex[0].x,obj[BARREL[n]].vertex[0].y-10000,obj[BARREL[n]].vertex[0].z);
score.kills[n]+=1;
velh=0;
END
END


 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 8 ==0)

  x1=obj[shell[n]].vertex[0].x;
  y1=obj[shell[n]].vertex[0].y;
  z1=obj[shell[n]].vertex[0].z;

  if(velh<>0) tracer(x0,y0,z0,x1,y1,z1,col0+32); END
 //   IF(Travel mod 2 ==0)
 // END
    IF(Travel mod 32 ==0)
    if(velh>0)velh-=1; END

    velv-=1;  END

  x0=x1; y0=y1; z0=z1;


 END




ELSE
explosion(n,4,obj[shell[n]].vertex[0].sx[n],obj[shell[n]].vertex[0].sy[n],obj[shell[n]].vertex[0].sz[n],n);
explosion(n,4,obj[shell[n]].vertex[0].sx[1-n],obj[shell[n]].vertex[0].sy[1-n],obj[shell[n]].vertex[0].sz[1-n],1-n);

velv=0;
if(velv==0)
status=0;
travel=0;
Position_obj(SHELL[n],obj[BARREL[n]].vertex[0].x,obj[BARREL[n]].vertex[0].y+10000,obj[BARREL[n]].vertex[0].z);
  hit_box=0;
x=obj[shell[n]].posx;
y=obj[shell[n]].posz;
z=obj[shell[n]].posy;

END
END

END


default:
END

END  //Switch


FRAME(25);
END


END
//___________________________________________________________________________________
PROCESS explosion(n,graph0,x,y,sz,k)

BEGIN
graph=graph0;
z=draw_z-10;
region=k+1;
if(sz<-100)
size=100*cam[k].depth/(cam[k].depth-sz);
while(graph<graph0+5)
graph+=1;
frame;
END
END
END
//---------------------------------------------------------------------------------------


  PROCESS tracer(x0,y0,z0,x1,y1,z1,col);
  private
  time;
  life=16;
  BEGIN

   LOOP

  if(time<life)
         draw_3dline(x0,y0,z0,x1,y1,z1,1,1,col-time*5,0);
  time+=4;
  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].anglex>360000) obj[n].anglex-=360000; END
if(obj[n].anglex<=0000) obj[n].anglex+=360000; END
if(obj[n].angley>360000) obj[n].angley-=360000; END
if(obj[n].angley<=0000) obj[n].angley+=360000; END
if(obj[n].anglez>360000) obj[n].anglez-=360000; END
if(obj[n].anglez<=0000) obj[n].anglez+=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].anglex>360000) obj[n].anglex-=360000; END
if(obj[n].anglex<=0000) obj[n].anglex+=360000; END
if(obj[n].angley>360000) obj[n].angley-=360000; END
if(obj[n].angley<=0000) obj[n].angley+=360000; END
if(obj[n].anglez>360000) obj[n].anglez-=360000; END
if(obj[n].anglez<=0000) obj[n].anglez+=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].posy=obj[n].vertex[0].y;
obj[n].posz=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;
 rolling_sound=16;
 tilting_sound=16;
 twisting_Sound=16;
 twistspeed;
 txt;
BEGIN
flags=4;
if(n==0) scroll.camera=id; END
graph=ctank_graph[n];
ctype=c_scroll;


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


if(vel<>0)
if( not is_playing_sound(rolling_sound))
rolling_sound=sound(snd_rolling,256,256);
END
ELSE

if(is_playing_sound(rolling_sound)) stop_sound(rolling_sound); rolling_sound=16; END

END





move_objxz(n,vel);

txt=abs(fget_dist(0,0,obj[n].posx,obj[n].posz));
if(txt>9900)
move_objxz(n,-vel);
END


    x=obj[n].posx;
    y=obj[n].posz;
    angle=obj[n].angley;


if(collision(type c_box)or collision(type tankobj))
move_objxz(n,-vel);
END



if(tilt<>0)
if( not is_playing_sound(tilting_sound))
tilting_sound=sound(snd_tilting,64,512);
END
ELSE

if(is_playing_sound(tilting_sound)) stop_sound(tilting_sound); tilting_sound=16; END

END







shaft_id[index].angle+=tilt;




if(key(ctrl))
if(abs(twistspeed)<5000) twistspeed+=100*(key(lf)-key(rt)); END
twist=twistspeed;
if(key(lf)-key(rt)==0) twistspeed=0; END
ELSE
ang= (key(lf)-key(rt))*3000;
twistspeed=0;
rotate_objxyz(index,0,ang,0);
END

if(key(lf)and key(rt))
c=SIN(turret_id[index].angle);
//If(c>0) rotate_objxyz(index,0,1000,0); twist=-1000; END
//If(c<0) rotate_objxyz(index,0,-1000,0); twist=1000; END

If(c>0)  twist=-3000; END
If(c<0)  twist=3000; END


if(abs(asin(c))=<3000) turret_id[index].angle=0;  twist=0; END
END

turret_id[index].angle+=twist;




if(twist<>0)
if( not is_playing_sound(twisting_sound))
twisting_sound=sound(snd_twisting,64,256);
END
ELSE

if(is_playing_sound(twisting_sound)) stop_sound(twisting_sound); twisting_sound=16; END

END







FRAME;
END

END




//--------------------------------------------------------------------------------
PROCESS tank_part(objNum,verts,edges,faces,x0,y0,z0,ang,n,part,parent,fix,col,graph0)
private i;
turret_angle;
shaft_angle;
BEGIN
    if( part<>3 and part<>5)
      renderme=draw_objf(objNum,n,1-n);
    END
ctype=c_scroll;

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);



switch (id)


case hull_id[n];
angle=obj[parent].angley;
//graph=chull_graph;
//x=obj[objNum].vertex[0].x;
//z=obj[objNum].vertex[0].y;
//y=obj[objNum].vertex[0].z;

END

case turret_id[n];
rotate_objxyz(objNum,0,angle,0);
angle=(angle+360000) mod 360000;
END

case shaft_id[n];
if(angle>45000)  angle=45000; END
if(angle<0) angle=0; END
rotate_objxyz(objNum,angle,0,0);


END

case barrel_id[n];
END

case dish_id[n];
angle=(angle-9000) mod 360000;
rotate_objxyz(objNum,0,angle,0);

END


default; end
END



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 plane(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,100);
cam[c].posY= obj[turret[c]].vertex[0].y+20;
cam[c].posZ= obj[turret[c]].vertex[0].z+get_Distx(obj[turret[c]].angley,100);

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,c0,c1,col,fadeout)
PRIVATE

k;  i;
DS;
draw_edge[2];
px[1];
py[1];
pz[1];
draw_me[2];
colfade;
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(fadeout==1)
    colfade=cv[0].z/100;
     if(colfade<=-64) 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

            col+=colfade;
        draw_edge[k]=draw(1,col,7,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;
cosine;
sine;

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,70,0,0,0,cam[n].cy,scr_w,cam[n].cy);
END

LOOP

if(FACES==0) break; end


for (k=0; k<=1; k+=1)
if(incam[k]==1)
DS=cam[k].depth;
cosine=cos(cam[k].angle);
sine=sin(cam[k].angle);

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=(cosine*cv[i].x+sine*cv[i].z)/1000;

cv[i].z=(cosine*cv[i].z-sine*cv[i].X)/1000;

cv[i].x=tmp;

if(cv[i].z==0)cv[i].z=1; END
obj[n].vertex[i].sx[k]=cam[k].cx-cv[i].x*DS/cv[i].z;
obj[n].vertex[i].sy[k]=cam[k].cy+cv[i].y*DS/cv[i].z;
obj[n].vertex[i].sz[k]=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




     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,7,k+1,
                                    obj[n].vertex[obj[n].edge[c].v0].sx[k],
                                    obj[n].vertex[obj[n].edge[c].v0].sy[k],
                                    obj[n].vertex[obj[n].edge[c].v1].sx[k],
                                    obj[n].vertex[obj[n].edge[c].v1].sy[k]);

    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;  m; o;
col;
//inrad;
ang;
ang2;
dist;
rx; ry;
ang1;
BEGIN
draw(4,15,15,0,x-r,y-r,x+r,y+r);

LOOP
angle=((angle-6000) +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[turret[index]].angley;


//ang=fget_angle(obj[index].vertex[0].x,obj[index].vertex[0].z,obj[n].vertex[0].x,obj[n].vertex[0].z);




rx=get_distx(ang,dist);
ry=get_disty(ang,dist);


ang2=(abs(angle-fget_angle(0,0,rx,ry)))mod 360000;




if(abs(ang2)<12000)
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[index].angley,r-2),
                     y+get_disty(93000+obj[index].angley,r-2),

                     x+get_distx(93000+obj[index].angley,r+2),
                     y+get_disty(93000+obj[index].angley,r+2));



j=draw(1,32,15,0,//x,y,
                     x+get_distx(87000+obj[index].angley,r-2),
                     y+get_disty(87000+obj[index].angley,r-2),

                     x+get_distx(87000+obj[index].angley,r+2),
                     y+get_disty(87000+obj[index].angley,r+2));



*/

/*
k=draw(1,32,15,0,x,y,
                     x+get_distx(120000+obj[turret[index]].angley,r),
                     y+get_disty(120000+obj[turret[index]].Angley,r));
l=draw(1,32,15,0,x,y,
                     x+get_distx(60000+obj[turret[index]].angley,r),
                     y+get_disty(60000+obj[turret[index]].Angley,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(90000+obj[turret[index]].angley-obj[index].angley,r),
                     y+get_disty(90000+obj[turret[index]].Angley-obj[index].angley,r));
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(90000+obj[turret[index]].angley-obj[index].angley,r),
                     y+get_disty(90000+obj[turret[index]].Angley-obj[index].angley,r));

  /*
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));


    */


k=draw(1,32,15,0,x,y,

                     x+get_distx(120000,r),
                     y+get_disty(120000,r));
l=draw(1,32,15,0,x,y,
                     x+get_distx(60000,r),
                     y+get_disty(60000,r));



m=draw(1,32,15,0,//x,y,
                     x-get_distx(93000+obj[turret[index]].angley,r-4),
                     y+get_disty(93000+obj[turret[index]].Angley,r-4),
                     x-get_distx(93000+obj[turret[index]].angley,r),
                     y+get_disty(93000+obj[turret[index]].Angley,r));

n=draw(1,32,15,0,//x,y,
                     x-get_distx(87000+obj[turret[index]].angley,r-4),
                     y+get_disty(87000+obj[turret[index]].Angley,r-4),
                     x-get_distx(87000+obj[turret[index]].angley,r),
                     y+get_disty(87000+obj[turret[index]].Angley,r));



o=draw(1,32,15,0,//x,y,
                     x-get_distx(93000+obj[turret[index]].angley,r-4),
                     y+get_disty(93000+obj[turret[index]].Angley,r-4),
                     x-get_distx(87000+obj[turret[index]].angley,r),
                     y+get_disty(87000+obj[turret[index]].Angley,r));




FRAME;
delete_draw(renderme);
delete_draw(i);
delete_draw(j);
delete_draw(K);
delete_draw(L);
delete_draw(m);
delete_draw(n);
delete_draw(o);
 end

END

//--------------------------------------------------------------------------------
  PROCESS blip(x,y,col)
     PRIVATE
     draw_id;
     r=1;
     life=64;
  BEGIN

       while(life>0)
       draw_id=draw(3,col+life,15,0,x-r,y-r,x+r,y+r);
       life-=2;

  FRAME;

    delete_draw(draw_id);

    END
  END
//--------------------------------------------------------------------------------
