#include "DarkGDK.h";
#include "EZrotate.h";

#include "windows.h";
#include <stdio.h>;
#include <string>;
#include <stdlib.h>;
#include <sstream>;
#include <iostream>;
#include "math.h";

int const youWon=202;
int const gameover=201;
int const missileLife=250;
int const gamePaused=200;
int const preloader=100;
int const overlay=101;
int const smokeobject=500;
int const maxOpponents=10;
int const playermissile=301;
int const computermissile=302;
int const computermove=4;
int const computermissilemove=5;
int const computerexplosion=6;
int const particleImage=5;
int const underwaterTime=50;
//constants for image numbers
int const guages=4;
int const compasndle=1;
int const scoreImage=5;
//Load the Radar
int const HUD=2;
int const OLDHUD=3;
int const sky=10;
int const minPDist=75;
//camera constants for console camera
float const cdist=500.0f;
float const chght=200.0f;
float const csmth=50.0f;
int const playerexplosionobj=420;
int const computerexplosionobj=400;
int const playerexplosionimage=2020;
int const computerexplosionimage=2000;
int const playerexplosionanimation=20;
int const computerexplosionanimation=1;
int const powerImage=1900;
int const powerBitmap=11;
int const powerSprite=4;

//set some default colour constants for quicker calling
DWORD const black=dbRGB(0,0,0);
DWORD const red=dbRGB(255,0,0);
DWORD const green=dbRGB(0,255,0);
DWORD const blue=dbRGB(0,0,255);
DWORD const white=dbRGB(255,255,255);
int const sideviewimage=900;
int const sideviewend=65;
int const sideviewspr=5;
int const sideview=1;
int const misscam=2;
//sound constants
int const playermove=1;
int const playermissilemove=2;
int const playerexplosion=3;
int const maxLives=10;
int const levelImage=300;
//Number of smoke particles
int const numSmokeParticles=10;

int const monl_first = 52500;
int const monl_max = 3;
int const monl_min = 1;
int const monl_width=300;
int const mapsize=2048;
int const hudsize=mapsize;
int const maxplants=100;

//define a computer opponent
typedef struct opponent {
   int cobject;             //holds object number
   int missileObject;       //holds missile object number
   int moveSound;           //holds move sound
   int missileMoveSound;    //holds missile move sound
   int explosionSound;      //missile explosion sound
   int missileFlag;     //missile fired true false
   int frame;               //animation Frame
   int tempFrame;           //temporary frame
   float angle; 
   double oldAngle;
   int frameCounter;
   int explode ;           //holds exploded true or false
   float x ;               //comp x location
   float y ;               //comp y location
   float z ;               //comp z location
   float oldx;
   float oldy;
   float oldz;
   float mx;               //missile x location
   float my;               //missile y location
   float mz;               //missile z location
   float power;            //missile power
   int particleFrequency;  //particle frequency
   BOOLEAN cpitch;         //holds direction of missile pitch
   int cmissileLife;       //missile Life
   int explosionobjnum;    
   int explodeobj;
   double move;
   int kills;
   int lives;
   BOOLEAN died;
   float smokex;
   float smokey;
   float smokez;
   int timer;
   int timerFlag;
   float oxygenUsed;
   float oxygenLeft;
   int hit;
}opponent;

int monl_ypos[monl_max+monl_min];
int loadobjectmap(char* continent);
void GetOpponentStruct(opponent* opponent,int id, int obj, int sounds);
void calctilt( int id, float angle, double move);
void createWater(int* water,int* waterheight);
void positionSmoke(int t,int count,float smokex,float smokey,float smokez,float ang,float smokeParticlesPos[((maxOpponents*10)+10)+(numSmokeParticles)][3],float smokeParticlesVel[((maxOpponents*10)+10)+(numSmokeParticles)][3],float smokeParticlesSize[((maxOpponents*10)+10)+(numSmokeParticles)][3],float smokeParticlesFade[((maxOpponents*10)+10)+(numSmokeParticles)][2],int particleCount[maxOpponents+1],int currentParticle[maxOpponents+1]);
void setupSmoke(void);
void monitor_lines_on(int monl_ypos[]);
void monitor_lines_update(int monl_ypos[],int alphamin,int alphamax);
void fadeIn(opponent* player,opponent computers[],int computer,int level,int waterheight);
void placeAllComp(opponent computers[],opponent player,int level,int waterheight);
void placePlayer(opponent* player,int computer,int waterheight);
void placeComp(opponent computers[],int t,int level,opponent player,int waterheight);
void showRadar(opponent player,opponent computers[],int level);
void calcmissiletilt( int id);
void movemissile( int id, double move, double rot);
void ItoC(char * Buffer, int theNum);
void CPushR(char * theChars, char pushChar, int strLen);
void SlidingCollisionPlayer(opponent* player,int level);
EZro_Vec FindSurfaceNormal(int id,double move);
void compAI(opponent computers[],opponent* player,int level);
void computershoot(opponent computers[],int t,opponent* player,int level);
void calcaimframe(opponent computers[],int t,opponent player);
void SlidingCollisionComputer(opponent computers[],int t,opponent player);
float calcDistance(float x1,float y1,float z1,float x2,float y2,float z2);
void pauseScreen(opponent computers[],opponent player,int level);
void YouWon(opponent computers[],opponent player,int level);
void endGame(opponent computers[],opponent player,int level);
void createLevel(int level);
void doNewLevel(opponent* player,int computer,opponent computers[],int waterHeight,int level);
int levelChange(int num);
using namespace std;
float leftprec(float x,float y);
string toString(float num,int precision);
string toString(int num);

void DarkGDK ( void )
{ 
dbSetWindowOff ();
dbSetDisplayMode(800,600,32);

dbSyncOn();
dbSyncRate(40);
char continent[11];
if (strcmp(dbCL(),"/0")==0 ){
	strcpy(continent,dbCL());
}else
{
	strcpy(continent,"Australia");
}
dbRandomize(dbTimer());
dbSetTextFont("Times New Roman");dbSetTextToBold();
dbCLS();
//create a loading screen

dbInk(dbRGB(200,0,0),dbRGB(5,5,5));
dbCreateBitmap(1,800,600);
dbSetTextSize(20);
dbSetCurrentBitmap(1); dbCLS(dbRGB(5,5,5));

dbSetCursor(5,270);dbPrint("Creating Terrain");
dbSetCursor(5,290);dbPrint("Creating Gauges");
dbSetCursor(5,310);dbPrint("Creating Heads Up");
dbSetCursor(5,330);dbPrint("Loading Objects");
dbSetCursor(5,350);dbPrint("Creating Sky");
dbSetCursor(5,370);dbPrint("Loading Explosions");
dbSetCursor(5,390);dbPrint("Creating Camera's");
dbSetCursor(5,410);dbPrint("Setting Boundaries");
dbSetCursor(5,430);dbPrint("Setting Collisions");
dbSetCursor(5,450);dbPrint("Loading Sounds");
dbGetImage(overlay,400,0,800,300);
dbSetTextSize(50);
dbCenterText(dbScreenWidth()/2,20,"Killer Scuds");
dbGetImage(preloader,0,0,800,600);

dbSetCurrentBitmap(0);dbDeleteBitmap(1);
dbSprite(preloader,0,0,preloader);dbSetSpritePriority(preloader,65534);
dbSprite(overlay,0,280,overlay);dbSetSpritePriority(overlay,65535);dbSync();

//dbSetDir("C:\\Program Files\\The Game Creators\\Dark GDK - FREEWARE Edition\\Projects\\KillerScuds\\KillerScuds");
dbSetupTerrain     ();								    // set up terrain library
dbMakeObjectTerrain(1);									// make a new terrain
char loadthis[MAX_PATH];
strcpy(loadthis,"Graphics\\");strcat(loadthis,continent);strcat(loadthis,"Height.png");
dbSetTerrainHeightMap(1,loadthis);						// set the terrain height map
dbSetTerrainScale(1,4,.6f,4);							// set the scale
dbSetTerrainSplit(1,16);								// set the split value       
dbSetTerrainTiling(1,2);								// set the detail tiling                    
dbSetTerrainLight(1,1.0f,-0.25f,0.0f,1,1,0.78f,0.5f);   // set the light
strcpy(loadthis,"Graphics\\");strcat(loadthis,continent); strcat(loadthis,"Texture.png");
dbSetCurrentBitmap(0);dbSetCursor(5,450);dbPrint(loadthis);
dbLoadImage(loadthis,1000,0);
dbLoadImage("Graphics\\detail.tga",1001,0);
dbSetTerrainTexture(1,1000,1001);						// Set The Terrain Textures

dbBuildTerrain(1);// build the terrain                              
dbUpdateTerrain();
dbPositionObject(1,0,0,0);
dbRotateObject(1,0,0,0);

int plantcount;
opponent player;
plantcount=loadobjectmap(continent);
//int player1=(106+plantcount)+1;
player.cobject=(106+plantcount)+1;
player.explodeobj=player.cobject+1;
player.explode=0;
player.missileFlag=0;  //player missile flag holds whether missile fired
player.frame=0;      //player animation frame of object
player.explosionobjnum=playerexplosionobj;
player.missileObject=playermissile;
player.kills=0;
player.lives=maxLives;
player.died=0;
player.explode=0;
player.moveSound=playermove;
player.missileMoveSound=playermissilemove;
player.explosionSound=playerexplosion;
player.mx=0;player.my=0;player.mz=0;
player.hit=0;

int computer=player.cobject+2;
int computerExplode=player.cobject+3;

opponent computers[maxOpponents];
int compsounds=computermove;
for (int t = 0;t<maxOpponents-1;t++){
   GetOpponentStruct(&computers[t],t,computer,compsounds);
   compsounds=compsounds+3; 
}
dbHideMouse();
//the score image number
dbLoadBitmap("Graphics\\Console5.bmp",1);
dbSetCurrentBitmap(1);
dbGetImage(guages,0,0,104,334,1);//console image
dbGetImage(compasndle,106,0,107,30,1);
dbSetCurrentBitmap(0);
dbDeleteBitmap(1);

dbSprite(overlay,0,320,overlay);dbSync();

dbSync();
dbCreateBitmap(1,100,100);
dbCreateBitmap(5,220,140);
strcpy(loadthis,"Graphics\\");strcat(loadthis,continent);strcat(loadthis,"Hud.png");
dbLoadImage(loadthis,OLDHUD,1);
dbSetCurrentBitmap(0);

dbLoadObject("Objects\\Scud Launcher\\L-Scud Launcher-Attack1.x",player.cobject);
dbAppendObject("Objects\\Scud Launcher\\L-Scud Launcher-Move.x",player.cobject,65);
dbRotateObject(player.cobject,0,180,0);
dbFixObjectPivot(player.cobject);
dbCloneObject(player.explodeobj,player.cobject);
dbHideObject(player.explodeobj);

dbLoadObject("Objects\\Scud Launcher 2\\L-Scud Launcher 2-Attack1.x",computers[0].cobject);
dbAppendObject("Objects\\Scud Launcher 2\\L-Scud Launcher 2-Move.x",computers[0].cobject,65);
for (int t= 1;t<maxOpponents-1;t++){
   dbCloneObject(computers[t].cobject,computers[0].cobject);
   //ensure object is rotated and fix the rotation pivot must be done for point to work
   dbRotateObject(computers[t].cobject,0,180,0);
   dbFixObjectPivot(computers[t].cobject);
}
//ensure object is rotated and fix the rotation pivot must be done for point to work
dbRotateObject(computers[0].cobject,0,180,0);
dbFixObjectPivot(computers[0].cobject);
dbSprite(overlay,0,340,overlay);dbSync();
int water,waterheight;
createWater(&water,&waterheight);
dbSprite(overlay,0,360,overlay);dbSync();
dbSync();

//load the skybox here
dbLoadObject("Objects\\sky02\\Sky02.3ds",sky);
dbSetObjectLight(sky,0);
dbSetObjectTexture(sky,0,1);
//float x,y,z,oldx,oldy,oldz,smokex,smokey,smokez;
player.x=mapsize/2;player.y=dbGetTerrainGroundHeight(1,player.x,player.z);player.z=mapsize/2;
dbPositionObject(sky,player.x,0,player.z);
dbScaleObject(sky,(mapsize*10),(mapsize*10),(mapsize*10));
dbSetObjectCollisionOff(sky);

int count;//x=mapsize/2;z=mapsize/2;y=dbGetTerrainGroundHeight(1,x,z);
float scale=100;
//minimum distance for scuds to be apart
dbSprite(overlay,0,380,overlay);dbSync();
//Make the missiles
dbScaleObject(player.cobject,scale,scale,scale);
dbScaleObject(computer,scale,scale,scale);
dbMakeObjectFromLimb(player.missileObject,player.cobject,11);
dbRotateObject(player.missileObject,0,180,0);
dbGlueObjectToLimb(player.missileObject,player.cobject,11);
dbHideLimb(player.cobject,11);

for (int t = 0;t<maxOpponents-1;t++){
   dbMakeObjectFromLimb(computers[t].missileObject,computers[t].cobject,11);
   //ensure computer missile is facing the right way
   dbRotateObject(computers[t].missileObject,0,180,0);
   //FIX OBJECT PIVOT computers[t].missileObject)//fix the rotation
   //glue the missiles to the scud launchers
   dbGlueObjectToLimb(computers[t].missileObject,computers[t].cobject,11);

   dbHideLimb(computers[t].cobject,11);
   //hide object computers[t).cobject;hide object computers[t).missileObject
}

dbSprite(overlay,0,400,overlay);dbSync();
//`Make the particles explosion for player missile
dbLoadAnimation("Animations\\explosion.avi",playerexplosionanimation);
dbSetAnimationSpeed(playerexplosionanimation,25);
dbPlayAnimationToImage(playerexplosionanimation,playerexplosionimage,0,0,dbAnimationWidth(20),dbAnimationWidth(20));
dbMakeObjectPlain(player.explosionobjnum,8,8);
dbTextureObject(player.explosionobjnum,playerexplosionimage);
dbSetObjectTransparency(player.explosionobjnum,1);
//dbGhostObjectOn(player.explosionobjnum);
dbSetObjectAmbient(player.explosionobjnum,0);
dbHideObject(player.explosionobjnum);

for (int t = 0;t<maxOpponents-1;t++){
   dbLoadAnimation("Animations\\explosion.avi",computers[t].explosionobjnum+1);
   dbSetAnimationSpeed(computers[t].explosionobjnum+1,25);
   dbPlayAnimationToImage(computers[t].explosionobjnum+1,computers[t].explosionobjnum+computerexplosionimage,0,0,dbAnimationWidth(computers[t].explosionobjnum+1),dbAnimationHeight(computers[t].explosionobjnum+1));
   dbMakeObjectPlain(computerexplosionobj+computers[t].explosionobjnum,8,8);
   dbTextureObject(computerexplosionobj+computers[t].explosionobjnum,computerexplosionimage+computers[t].explosionobjnum);
   dbSetObjectTransparency(computerexplosionobj+computers[t].explosionobjnum,1);
   //dbGhostObjectOn(computerexplosionobj+computers[t].explosionobjnum);
   dbSetObjectAmbient(computerexplosionobj+computers[t].explosionobjnum,0);
   dbHideObject(computerexplosionobj+computers[t].explosionobjnum);
}
dbLoadBitmap("Graphics\\PowerImage.jpg",powerBitmap);
//dbLoadImage("Graphics\\PowerImage.jpg",powerImage,1);
int pfrequency=0;
float smokeParticlesPos[((maxOpponents*10)+10)+(numSmokeParticles)][3];
float smokeParticlesVel[((maxOpponents*10)+10)+(numSmokeParticles)][3];
float smokeParticlesSize[((maxOpponents*10)+10)+(numSmokeParticles)][3];
float smokeParticlesFade[((maxOpponents*10)+10)+(numSmokeParticles)][2];

//Particle value arrays
int particleCount[maxOpponents+1];
int currentParticle[maxOpponents+1];
//int particleCount[maxOpponents+1];int currentParticle[maxOpponents+1]
setupSmoke();
player.y=dbGetTerrainGroundHeight(1,player.x,player.z);
dbPositionObject(player.cobject,player.x,player.y,player.z);

dbSprite(overlay,0,400,overlay);dbSync();
//set camera so as the sky can be seen
//float ang;
//float power;
dbSetCameraRange(1,((mapsize*1.4142)+10));
dbPositionCamera(player.x,player.y,player.z);
dbSetCameraToFollow(player.x,player.y,player.z,player.angle+180,cdist,chght,csmth,1);

//night time effect
//Fog on
//Fog distance 500
//Fog color dbRGB(10,10,10)
//Color Backdrop dbRGB(10,10,10)

//rem if noscreen skip
char* MyChar;
for (int t=sideviewimage;t<(sideviewimage+36);t++){
	strcpy(loadthis,"Graphics\\Sideview\\");strcat(loadthis,"ScudSide");
	MyChar=dbStr((t-sideviewimage)+1);strcat(loadthis,MyChar);strcat(loadthis,".bmp");
	dbLoadImage(loadthis,t,1);
	//dbLoadImage("Graphics\\Sideview\\ScudSide1.bmp",t,1);
}

//make a camera to put in console for sideview
/*
dbMakeCamera(sideview);
dbSetCameraRange(sideview,1,500);
dbSetCameraView(sideview,2,179,102,239);
*/

//make a camera to put in console for missile cam
/*
dbMakeCamera(misscam);
dbSetCameraView(misscam,2,244,102,304);
dbSetCameraRange(misscam,1,mapsize/2);
*/

dbSprite(overlay,0,420,overlay);dbSync();
dbSprite(overlay,0,440,overlay);dbSync();
//set object collision on player
dbSetObjectCollisionOn(player.explodeobj);
dbSetObjectCollisionOn(player.missileObject);
//set object collision off sky
dbSetObjectCollisionToBoxes(player.cobject);
dbSetObjectCollisionToBoxes(player.explodeobj);
dbSetObjectCollisionToPolygons(player.missileObject);

for (int t=0;t<maxOpponents-1;t++) {
   dbSetObjectCollisionOn(computers[t].cobject);
   dbSetObjectCollisionToBoxes(computers[t].cobject);
   dbSetObjectCollisionOn(computers[t].missileObject);
   dbSetObjectCollisionToPolygons(computers[t].missileObject);
}
int level=1,nextLevel=1;
dbSprite(overlay,0,460,overlay);dbSync();

dbLoad3DSound("Sounds\\Tank.wav",player.moveSound);
dbLoad3DSound("Sounds\\Missile.wav",player.missileMoveSound);
dbLoad3DSound("Sounds\\Explosion.wav",player.explosionSound);
dbSetSoundVolume(player.move,85);

for (int t = 0;t<maxOpponents-1;t++) {
   dbCloneSound(computers[t].moveSound,player.moveSound);
   dbSetSoundVolume(computers[t].moveSound,85);
   dbCloneSound(computers[t].missileMoveSound,player.missileMoveSound);
   dbCloneSound(computers[t].explosionSound,player.explosionSound);
}

dbLoopSound(player.moveSound);
//loop sound computermove

dbPositionListener(player.x,player.y,player.z);
dbLoadImage("graphics\\monline.png",monl_first,1);
int monl_ypos[monl_max];
//use this comand to apply random starting values to the lines before you start updating
monitor_lines_on(monl_ypos);
//`set timer variables for underwater play
//int myTimer=0,myTimerFlag=0,OxygenUsed=0,OxygenLeft;
player.move=.65;
player.timer=0;
player.timerFlag=0;
//fadeIn(int player1,int player.explodeobj,float* ang,float* x,float* y,float *z,float* mx,float *mz,int mflag,opponent computers[],int computer,BOOLEAN myTimerFlag,int plives,int pkills,int OxygenUsed,int OxygenLeft,int level,int waterheight); 
fadeIn(&player,computers,computer,level,waterheight);
dbSetCurrentBitmap(0);
BOOLEAN DISPLAYFLAG=1,MISSILECAMFLAG=0,SIDEVIEWFLAG=1;
char* key=dbUpper(dbInKey());
//float oldang;
float theight;
//int pmlife,mhit,
int t;
while ( LoopGDK ( ) )
 {
 if (dbLeftKey() && player.explode==0)  {
   player.oldAngle=player.angle;//store the old angle for collisions
   if (dbDownKey()==0){
	   player.angle=dbWrapValue(player.angle-.65);
   }else{
	   player.angle=dbWrapValue(player.angle+.65);
   }
  }
  if (dbRightKey() && player.explode==0) {
    player.oldAngle=player.angle;//store the old angle for collisions
	if (dbDownKey()==0) {
	  player.angle=dbWrapValue(player.angle+.65);
    }else{
      player.angle=dbWrapValue(player.angle-.65);
	}
   }

  if (dbUpKey () && player.explode==0) {
	  if (player.frame<=40) {
         player.frame--;
		 if (player.frame<0){player.frame=90;}//;show limb 200,11
         dbSetObjectFrame(player.cobject,player.frame);
	  }else{
		 if (player.frame>65) {player.frame--;}
         dbSetObjectFrame(player.cobject,player.frame);
		 if (player.frame==65) {player.frame=90;}
         player.x=dbNewXValue(player.x,player.angle,.65);
         player.z=dbNewZValue(player.z,player.angle,.65);
         player.move=.65f;
	   }
   }
  if (dbDownKey() && player.explode==0) {
	  if (player.frame<=40){
         player.frame--;
		 if (player.frame<0){player.frame=90;}//;show limb 200,11
		 dbSetObjectFrame(player.cobject,player.frame);
      }else{
		 if (player.frame<90){player.frame++;}
         dbSetObjectFrame(player.cobject,player.frame);
		 if (player.frame==90){player.frame=65;}
         player.x=dbNewXValue(player.x,player.angle,-.65);
         player.z=dbNewZValue(player.z,player.angle,-.65);
         player.move=.65f;
	  }
  }
  
  key=dbUpper(dbInKey());

  if (*key=='A' && player.explode==0){
	  if (player.frame<40) {player.frame++;}
	  if (player.frame>40) {player.frame=1;}
      dbSetObjectFrame(player.cobject,player.frame);
  }
  if (*key=='Z' && player.explode==0) {
	  if (player.frame>0) {player.frame--;}
	  if (player.frame>40) {player.frame=1;}
      dbSetObjectFrame(player.cobject,player.frame);
  }
  dbYRotateObject(player.cobject,player.angle);
  //these lines are testing code only
  //void calctilt( int id, float angle, float move)
  //void calctilt( int id, float angle, double move);

  calctilt(player.cobject,player.angle,player.move);

  //dbPositionObject(player1,x,y,z);
  dbPositionObject(player.cobject,player.x,dbGetTerrainGroundHeight(1,player.x,player.z),player.z);
  player.x=dbObjectPositionX(player.cobject);
  player.y=dbGetTerrainGroundHeight(1,player.x,player.z);
  player.z=dbObjectPositionZ(player.cobject);
     
  if (*key=='1' || *key=='!'){
	  if(DISPLAYFLAG==1){DISPLAYFLAG=0;}
	  else{
         DISPLAYFLAG=1;
		 if (dbSpriteExist(1)){dbShowSprite(1);}
		 if (dbSpriteExist(2)){dbShowSprite(2);}
		 if (dbSpriteExist(3)){dbShowSprite(3);}
		 if (dbSpriteExist(sideviewspr)){dbHideSprite(sideviewspr);}
	  }
  }

  if (*key=='2' || *key=='@'){
	  if (SIDEVIEWFLAG==1){
         SIDEVIEWFLAG=0;
		 dbHideSprite(sideviewspr);		
		 //if (dbCameraExist(sideview)){dbDeleteCamera(sideview);}
	  }else{
		  SIDEVIEWFLAG=1;
     	  dbShowSprite(sideviewspr);
		 //if (dbCameraExist(sideview)==0){dbMakeCamera(sideview);}
         //dbSetCameraRange(sideview,1,500);
         //dbSetCameraView(sideview,2,179,102,239);
         //dbSetCameraToFollow(sideview,x,y,z,ang-90,cdist,chght,csmth,1);
	  }
  }

  if (*key=='3' || *key=='#'){
	  if (MISSILECAMFLAG==1){
         MISSILECAMFLAG=0;
		 //if (dbCameraExist(misscam)){dbDeleteCamera(misscam);}
	  }else{
         MISSILECAMFLAG=1;
		 //if (dbCameraExist(misscam)==0){dbMakeCamera(misscam);}
         dbSetCameraView(misscam,2,244,102,304);
         dbSetCameraRange(misscam,1,mapsize/2);
	  }
   }
//void pauseScreen(opponent computers[],opponent player,int level)
  if (*key=='P'){pauseScreen(computers,player,level);}

  if (dbSpaceKey() && player.missileFlag==0 && player.explode==0){
      player.power=.2f;
      player.missileFlag=1;
	  
  }
  
  if (player.missileFlag==1){//get the power from user
    
	if (dbSpaceKey() && player.power<1 && player.explode==0){
      player.power=player.power+.025f;
      dbSetCurrentBitmap(powerBitmap);
	  dbGetImage(powerImage,0,0,(player.power*100.00f),23,1);
	  dbSetCurrentBitmap(0);
	  dbPasteImage(powerImage,0,309);
	  dbDeleteImage(powerImage);
	}else{
	  player.missileFlag=2;//reposition the missile and unglue
      // dochange
      //mflag=0;
      calcmissiletilt(player.missileObject);
      player.power=player.power+1.00f;
      player.cmissileLife=0;
      dbPlaySound(player.missileMoveSound);
	  //dbHideSprite(powerSprite);
	}
  }

  if (player.missileFlag==2){//missile has fired move it
      player.cmissileLife++;
      //movemissile(int id,float move,float rot)
	  movemissile(player.missileObject,(player.power+1.00),(1.01-player.power)+1.00);
      player.mx=dbObjectPositionX(player.missileObject);
      player.my=dbObjectPositionY(player.missileObject);
      player.mz=dbObjectPositionZ(player.missileObject);
      theight=dbGetTerrainGroundHeight(1,player.mx,player.mz);
      dbPositionSound(player.missileMoveSound,player.mx,player.my,player.mz);

      player.hit=dbObjectCollision(player.missileObject,0);
	  t=0;do{
	     //player.hit=dbObjectCollision(player.missileObject,0);
	     if (theight>player.my || dbObjectVisible(player.missileObject)==0 || player.hit==computers[t].cobject || player.cmissileLife>missileLife){
         player.missileFlag=0;//;player.hit=dbObjectCollision(player.missileObject,0);
         dbPositionSound (player.explosionSound,player.mx,player.my,player.mz);
         // explosion animation
		 dbShowObject(player.explosionobjnum);
		 if (player.hit==0){
            dbScaleObject(player.explosionobjnum,40,40,40);
            dbPositionObject(player.explosionobjnum,player.mx,player.my+2,player.mz);
		 }else{
            dbScaleObject(player.explosionobjnum,100,100,100);
            dbPositionObject(player.explosionobjnum,player.mx,player.my+4,player.mz);
		 }
         dbRotateObject(player.explosionobjnum,0,player.angle,0);
		 dbPlayAnimation(playerexplosionanimation);
         dbPlaySound(playerexplosion);
		 dbGlueObjectToLimb(player.missileObject,player.cobject,11);
         
		 //reposition the scud on the launcher
         dbPositionObject(player.missileObject,0,0,0);
         dbRotateObject(player.missileObject,0,180,0);
		 if (player.hit==computers[t].cobject && computers[t].explode==0){
            dbPositionObject(computers[t].cobject,computers[t].x,computers[t].y,computers[t].z);
            dbYRotateObject(computers[t].cobject,dbINT(dbRND(360)));
            //void calctilt( int id, float angle, float move)
			calctilt(computers[t].cobject,dbObjectAngleY(computers[t].cobject),computers[t].move);

            //`try and scatter limbs
			for (int doit = 4;doit<11;doit++){
               dbOffsetLimb(computers[t].cobject, doit, dbINT(dbRND(4)),0,dbINT(dbRND(4)));
			}

            computers[t].explode=1;player.kills++;
			
			if (player.kills==levelChange(level)){
				if (level<maxOpponents){
                  nextLevel++;
				}else{
				  //void YouWon(opponent computers[],int pfrequency,int level)
                  YouWon(computers,player,level);
					break;
				}
			}
			}

		 }

	  t++;}while(t<level-1);
   }
 
   //the computer has exploded reposition him
  //this code needs moving
  if (nextLevel>level){
      level++;
//void doNewLevel(opponent* player,computer,opponent computers[],int level)
doNewLevel(&player,computer,computers,waterheight,level);
  }

 t=0;do{
   //needed to check if computer shot himself or
      if (computers[t].explode==2){
	     //void placeComp(opponent computers[],int t,int level,opponent player,int waterheight)
         placeComp(computers,t,level,player,waterheight);
		 dbShowObject(computers[t].cobject);computers[t].explode=0;
      }
 t++;}while (t<level-1);
	  
  //the player has exploded reposition him/her
 
  if (player.explode==1){
      player.explode=0;
      if (player.lives>0){
         player.oldx=player.x;player.oldz=player.z;player.oldy=player.y;
         player.angle=dbObjectAngleY(player.cobject);
         //placePlayer(int player1,int player.explodeobj,float* ang,float* x,float* y,float* z,int computer,int waterheight){
		 //void placePlayer(opponent* player,int computer,int waterheight)
		 placePlayer(&player,computer,waterheight);
		 dbShowObject(player.cobject);
		 //void showRadar(float x,float z,float mx,float mz,int mflag,opponent computers[],int level,int plives,int pkills,BOOLEAN myTimerFlag, int OxygenUsed,int OxygenLeft)
		//void showRadar(opponent player,opponent computers[],int level)
		 //showRadar(player,computers,level);
         if (DISPLAYFLAG==1) {showRadar(player,computers,level);}  
		 player.died=1;
         do{
            if (player.oldx>player.x){player.oldx--;}
            if (player.oldz>player.z){player.oldz--;}
			if (player.oldx<player.x){player.oldx++;}
            if (player.oldz<player.z){player.oldz++;}
            player.y=dbGetTerrainGroundHeight(1,player.oldx,player.oldz);
            dbPositionCamera(player.oldx,player.y,player.oldz);
            dbSetCameraToFollow(player.oldx,player.y,player.oldz,player.angle,cdist,chght,csmth,1);
            if (DISPLAYFLAG==1) {dbPasteImage(HUD,2,2);}
            t=0;do{
               if (computers[t].particleFrequency>0) {
					computers[t].particleFrequency=computers[t].particleFrequency-5;
					dbSetParticleEmissions(computers[t].missileObject,computers[t].particleFrequency);
				}
			t++;}while (t<level-1);
            dbPositionListener(player.oldx,player.y,player.oldz);
            //dbSync();
         }while(player.oldx>(player.x+1) || player.oldx<(player.x-1) || player.oldz>(player.z+1) || player.oldz<(player.z-1));
      }else{
         //void endGame(opponent computers[],int pfrequency,int level)
		 endGame(computers,player,level);
         break;
	  }
	  }
  
  if (pfrequency>0){
	//pfrequency=pfrequency-5;dbSetParticleEmissions(playermissile,pfrequency);
  }	
  if (player.died==1){
      count=1500;
      player.smokex=dbObjectPositionX(player.explodeobj);
      player.smokey=dbObjectPositionY(player.explodeobj);
      player.smokez=dbObjectPositionZ(player.explodeobj);
      t=11;
	  //void positionSmoke(int t,int count,float smokex,float smokey,float smokez,float ang,float smokeParticlesPos[((maxOpponents*10)+10)+(numSmokeParticles)][3],float smokeParticlesVel[((maxOpponents*10)+10)+(numSmokeParticles)][3],float smokeParticlesSize[((maxOpponents*10)+10)+(numSmokeParticles)][3],float smokeParticlesFade[((maxOpponents*10)+10)+(numSmokeParticles)][2],int particleCount[maxOpponents+1],int currentParticle[maxOpponents+1])
	  positionSmoke(t,count,player.smokex,player.smokey,player.smokez,player.angle,smokeParticlesPos,smokeParticlesVel,smokeParticlesSize,smokeParticlesFade,particleCount,currentParticle);
  }
  
  t=0;do{
      if (computers[t].particleFrequency>0){
			computers[t].particleFrequency=computers[t].particleFrequency-5;
			dbSetParticleEmissions(computers[t].missileObject,computers[t].particleFrequency);
      }
	  //smoke testing
      if (computers[t].explode>=1){
         count=(100*t)+smokeobject;
         player.smokex=computers[t].x;
         player.smokey=computers[t].y;
         player.smokez=computers[t].z;
		 //void positionSmoke(int t,int count,float smokex,float smokey,float smokez,float ang,float smokeParticlesPos[((maxOpponents*10)+10)+(numSmokeParticles)][3],float smokeParticlesVel[((maxOpponents*10)+10)+(numSmokeParticles)][3],float smokeParticlesSize[((maxOpponents*10)+10)+(numSmokeParticles)][3],float smokeParticlesFade[((maxOpponents*10)+10)+(numSmokeParticles)][2],int particleCount[maxOpponents+1],int currentParticle[maxOpponents+1])
		 positionSmoke(t,count,player.smokex,player.smokey,player.smokez,player.angle,smokeParticlesPos,smokeParticlesVel,smokeParticlesSize,smokeParticlesFade,particleCount,currentParticle);
      }
      //end smoke testing
  
  t++;}while(t<level-1);
  //void SlidingCollisionPlayer(int player1,float* x,float* y,float* z,float ang,double move,int level)
  SlidingCollisionPlayer(&player,level);
  ////gosub SlidingCollisionComputer

  
if (SIDEVIEWFLAG==1){
   //the console camera
   //dbPositionCamera(sideview,x,y,z);
   //dbSetCameraToFollow(sideview,x,y,z,ang-90,cdist,chght,csmth,1);
	if (player.frame<sideviewend){
		if (player.frame<36){
			dbSprite(sideviewspr,2,179,sideviewimage+player.frame);
		}else{
			dbSprite(sideviewspr,2,179,sideviewimage+35);
		}
	}else{
		dbSprite(sideviewspr,2,179,sideviewimage);
	}
}
if (MISSILECAMFLAG==1){
   //missile camera
   dbPositionCamera(misscam,player.mx,player.my,player.mz);
   //ca2=dbLimbAngleY(playermissile,0);
   dbSetCameraToFollow(misscam,player.mx,player.my,player.mz,dbObjectAngleY(player.missileObject),cdist,player.my,csmth,0);
}

//make radar
dbSprite(1,0,0,guages);//console
dbSprite(2,52,137,compasndle);//needle for console
dbSprite(3,550,0,scoreImage);
//dbSprite(powerSprite,2,309,powerImage2);
dbRotateSprite(2,player.angle+180);

// if noscreen skip
if (DISPLAYFLAG==0){
   dbHideAllSprites();
}else{
	//void showRadar(opponent player,opponent computers[],int level)
   showRadar(player,computers,level);
}
//void compAI(opponent computers[],int player1,float x,float y,float z,float ang,double pmove,int player.explodeobj,int pexplode,int plives,int level)
compAI(computers,&player,level);
  //check if player is underwater
  if (player.timerFlag==0 && dbObjectPositionY(player.cobject)<=waterheight){
	player.timer=dbTimer();
	player.oxygenUsed=(dbTimer()-player.timer)/1000;
	player.timerFlag=1;
  }
  if (player.timerFlag==1){
   if (dbObjectPositionY(player.cobject)>=waterheight){
      player.timer=0;
      player.timerFlag=0;
   }else{
	   if ((player.timer+(underwaterTime*1000))<dbTimer()){
        //player has drowned
        dbPositionObject(player.explodeobj,player.x,player.y,player.z);
		//void calctilt( int id, float angle, float move)
        calctilt(player.explodeobj,dbObjectAngleY(player.explodeobj),player.move);
		dbHideObject(player.cobject);dbShowObject(player.explodeobj);
        player.lives--;player.oldx=player.x;player.oldz=player.z;player.oldy=player.y;
        player.angle=dbObjectAngleY(player.cobject);
        //placePlayer(int player1,int player.explodeobj,float* ang,float* x,float* y,float* z,int computer,int waterheight){
		placePlayer(&player,computer,waterheight);
   		dbShowObject(player.cobject);
        if (DISPLAYFLAG==1){
			//void showRadar(float x,float z,float mx,float mz,int mflag,opponent computers[],int level,int plives,int pkills,BOOLEAN myTimerFlag, int OxygenUsed,int OxygenLeft)
			showRadar(player,computers,level);
		}
		player.died=1;
		}
      }
   }
  
  player.oxygenUsed=(dbTimer()-player.timer)/1000;
  if (dbAnimationPlaying(playerexplosionanimation)==0){
      dbHideObject(player.explosionobjnum);
  }
  for (int tt = 0;tt<maxOpponents-1;tt++){
      if (dbAnimationPlaying(computers[tt].explosionobjnum+1)==0){
         dbHideObject(computerexplosionobj+computers[tt].explosionobjnum);
      }
   }
//position where the sounds will be heard from in the 3dworld
  dbPositionListener(player.x,player.y,player.z);
  dbPositionSound(player.moveSound,player.x,player.y,player.z);

  //the screen camera
  dbUpdateTerrain();
  //dbPositionObject(1,0,0,0);
  //dbRotateObject(1,0,0,0);
  dbPositionCamera(player.x,player.y,player.z);
  dbSetCameraToFollow(player.x,player.y,player.z,player.angle,cdist,chght,csmth,1);
  dbSync();
 }

}
int loadobjectmap(char* continent){
FILE* fpin;
char string [20];
char planttemp[20]="";
char file[30]="";
int plantcount;
int plants[maxplants][3];
int t=1;
strcpy(file,"Objectmaps\\");strcat(file,continent);strcat(file,"plantmap.txt");
//dbSetDir("C:\\Program Files\\The Game Creators\\Dark GDK - FREEWARE Edition\\Projects\\KillerScuds\\KillerScuds");
fpin = fopen (file,"r");
   if (fpin == NULL) perror ("Error opening file");
   else {
	   if (fgets(string,100,fpin) != NULL){
			strcpy(planttemp,string);		
		if (fgets(string,100,fpin) != NULL){
		   plantcount=dbVal(string);	
	   	   while (fgets(string,100,fpin) != NULL){
			plants[t][0]=dbVal(string);
			if (fgets(string,100,fpin) != NULL){plants[t][1]=dbVal(string);}
			if (fgets(string,100,fpin) != NULL){plants[t][2]=dbVal(string);}
			dbPrint(dbStr(plants[t][0]));
			dbPrint(dbStr(plants[t][1]));
			dbPrint(dbStr(plants[t][2]));
			t++;
			dbSync();
	   }
	   }
	   }
  }
fclose (fpin);
int yRot;
int plantScale;
yRot=dbRND(360);
plantScale=dbRND(3);
dbLoadObject("Objects\\OldTree1\\OldTree1.3DS",96+1);
dbPositionObject(96+1,plants[1][0],dbGetTerrainGroundHeight(1,plants[1][0],plants[1][1]),plants[1][1]);
dbYRotateObject(96+1,yRot);dbHideObject(96+1);dbSetObjectCollisionOn(96+1);
dbSetObjectCollisionToPolygons(96+1);
dbLoadObject("Objects\\OldTree2\\OldTree2.3DS",96+2);
dbPositionObject(96+2,plants[2][0],dbGetTerrainGroundHeight(1,plants[2][0],plants[2][1]),plants[2][1]);
dbYRotateObject(96+2,yRot);dbHideObject(96+2);dbSetObjectCollisionOn(96+2);
dbSetObjectCollisionToPolygons(96+2);
dbLoadObject("Objects\\OldTree3\\OldTree3.3DS",96+3);
dbPositionObject(96+3,plants[3][0],dbGetTerrainGroundHeight(1,plants[3][0],plants[3][1]),plants[3][1]);
dbYRotateObject(96+3,yRot);dbHideObject(96+3);dbSetObjectCollisionOn(96+3);
dbSetObjectCollisionToPolygons(96+3);
dbLoadObject("Objects\\OldTree4\\OldTree4.3DS",96+4);
dbPositionObject(96+4,plants[4][0],dbGetTerrainGroundHeight(1,plants[4][0],plants[4][1]),plants[4][1]);
dbYRotateObject(96+4,yRot);dbHideObject(96+4);dbSetObjectCollisionOn(96+4);
dbSetObjectCollisionToPolygons(96+4);
dbLoadObject("Objects\\OldTreeStump\\OldTreeStump.3DS",96+5);
dbPositionObject(96+5,plants[5][0],dbGetTerrainGroundHeight(1,plants[5][0],plants[5][1]),plants[5][1]);
dbYRotateObject(96+5,yRot);dbHideObject(96+5);dbSetObjectCollisionOn(96+5);
dbSetObjectCollisionToPolygons(96+5);
dbLoadObject("Objects\\MilitaryTent3ds\\tent1.3DS",96+6);
dbPositionObject(96+6,plants[6][0],dbGetTerrainGroundHeight(1,plants[6][0],plants[6][1]),plants[6][1]);
dbScaleObject(96+6,25,25,25);dbYRotateObject(96+6,yRot);
dbHideObject(96+6);dbSetObjectCollisionOn(96+6); 
dbSetObjectCollisionToBoxes(96+6);
dbLoadObject("Objects\\MilitaryTent3ds\\tent2.3DS",96+7);
dbPositionObject(96+7,plants[7][0],dbGetTerrainGroundHeight(1,plants[7][0],plants[7][1]),plants[7][1]);
dbScaleObject(96+7,25,25,25);dbYRotateObject(96+7,yRot);
dbHideObject(96+7);dbSetObjectCollisionOn(96+7);
dbSetObjectCollisionToBoxes(96+7);
dbLoadObject("Objects\\MilitaryTent3ds\\tent3.3DS",96+8);
dbPositionObject(96+8,plants[8][0],dbGetTerrainGroundHeight(1,plants[8][0],plants[8][1]),plants[8][1]);
dbScaleObject(96+8,25,25,25);dbYRotateObject(96+8,yRot);
dbHideObject(96+8);dbSetObjectCollisionOn(96+8);
dbSetObjectCollisionToBoxes(96+8);
dbLoadObject("Objects\\MilitaryTent3ds\\tent4.3DS",96+9);
dbPositionObject(96+9,plants[9][0],dbGetTerrainGroundHeight(1,plants[9][0],plants[9][1]),plants[9][1]);
dbScaleObject(96+9,25,25,25);dbYRotateObject(96+9,yRot);
dbHideObject(96+9);dbSetObjectCollisionOn(96+9);
dbSetObjectCollisionToBoxes(96+9);
dbLoadObject("Objects\\MilitaryTent3ds\\Tent5.3DS",96+10);
dbPositionObject(96+10,plants[10][0],dbGetTerrainGroundHeight(1,plants[10][0],plants[10][1]),plants[10][1]);
dbScaleObject(96+10,25,25,25);dbYRotateObject(96+10,yRot);
dbHideObject(96+10);dbSetObjectCollisionOn(96+10);
dbSetObjectCollisionToBoxes(96+10);

//place objects
for (int t = 1;t<plantcount;t++){
   yRot=dbRND(360);
   plantScale=dbRND(1000);
   dbInstanceObject(106+t,96+plants[t][2]);
   dbPositionObject(106+t,plants[t][0],dbGetTerrainGroundHeight(1,plants[t][0],plants[t][1]),plants[t][1]);
   dbShowObject(106+t);
   dbYRotateObject(106+t,yRot);
   if (plants[t][2]<6) {
	  dbScaleObject(106+t,5000+plantScale,5000+plantScale,5000+plantScale);
      dbSetObjectCollisionOn(106+t);
      dbSetObjectCollisionToPolygons(106+t);
   }
   else {
      dbScaleObject(106+t,40,40,40);
      dbFixObjectPivot(106+t);
	  //void calctilt( int id, float angle, float move)
      calctilt(106+t,dbObjectAngleY(106+t),.01f);
	  dbSetObjectCollisionOn(106+t);
      dbSetObjectCollisionToBoxes(106+t);
   }
}

return plantcount;
}

void GetOpponentStruct(opponent* opponent,int id, int obj, int sounds) // call-by-reference parameter
{
   (*opponent).cobject=obj+id;
   (*opponent).missileObject=computermissile+id;
   (*opponent).moveSound=sounds;
   (*opponent).missileMoveSound=sounds+1;
   (*opponent).explosionSound=sounds+2;
   (*opponent).frame=0;
   (*opponent).frameCounter=1;
   (*opponent).tempFrame=(*opponent).frame;
   (*opponent).x=0;
   (*opponent).y=0;
   (*opponent).z=0;
   (*opponent).explode=0;
   (*opponent).missileFlag=0;
   (*opponent).mx=0;
   (*opponent).my=0;
   (*opponent).mz=0;
   (*opponent).particleFrequency=0;
   (*opponent).cpitch=0;
   (*opponent).power=0;
   (*opponent).cmissileLife=0;
   (*opponent).explosionobjnum=id;
   (*opponent).move=.65f; 
   (*opponent).hit=0;
}

void calctilt( int id, float angle, double move)
{ 
 if (move == 0)
 { move = 0.65f;}
 EZro_Vec EulerAngles;
 EZro_Vec Point1;
 EZro_Vec Point2;
 EZro_Vec Point3;
 EZro_Vec SurfNormal;
 
 EZro_Mat objectMatrix;
 
 // Object Positioning
 //-----------------------------------------
 //Point 1 = object position
 Point1.x =  dbObjectPositionX( id );
 Point1.y =  dbObjectPositionY( id );
 Point1.z =  dbObjectPositionZ( id );
 //Point 2 = object position + 1Z
 Point2.x =  Point1.x;
 Point2.y =  dbGetTerrainGroundHeight( 1, Point1.x, Point1.z + move);
 Point2.z =  Point1.z + move;
 //Point 3 = object position + 1X
 Point3.x =  Point1.x + move;
 Point3.y =  dbGetTerrainGroundHeight( 1, Point1.x + move, Point1.z);
 Point3.z =  Point1.z;
    //Use FIND NORMAL Feature to find the normal of the surface
    //--------------------------------------------------------
 SurfNormal = EZro_FindNormal(Point1, Point2, Point3);
    //Use Poly Align Feature to calculate angle
    //-------------------------------------------
 objectMatrix =  EZro_AlignToPoly(angle, SurfNormal);
 // Rotate object correctly
 EulerAngles = EZro_Matrix2Euler(objectMatrix);
 dbRotateObject(id, EulerAngles.x, EulerAngles.y, EulerAngles.z);
}

void createWater(int* water,int* waterheight){
*water=5000;
//`load effect path$+"Objects\pocean.fx", 1, 1
dbMakeObjectPlain(*water,mapsize/4,mapsize/4);//We make it as big as our map, to ensure all areas
dbScaleObject(*water,400,400,400);
dbXRotateObject(*water,-90);//                `Rotate our water.

dbLoadImage("Graphics\\water2.jpg",*water);//          `Load our image we'll use to texture our water.
dbTextureObject(*water,*water);
*waterheight=10;                          //This is where we'll position our water on the


//set object effect water,1
dbPositionObject(*water,mapsize/2,*waterheight,mapsize/2);//   `We position our water.
dbSetObjectTransparency(*water,2);

dbSetAlphaMappingOn(*water,85);//           `We give our water transparency.
}
void setupSmoke(void){

//Create smoke image
dbCreateBitmap(4,50,50);
dbCLS(dbRGB(0,0,0));
dbInk(dbRGB(130,130,130),dbRGB(0,0,0));
//Draw random dots in a circle shape
float ang,rad;
for (int px=1;px<1000;px++){
   ang=dbRND(360);
   rad=dbRND(20);
   dbDot(25+sin(ang)*rad,25+cos(ang)*rad);
}
//Blur smoke image
dbBlurBitmap(4,8);
dbGetImage(6,0,0,50,50);
dbDeleteBitmap(4);

//Make particles
int t=0,count=smokeobject;
do{
for (int px=count;px<(count+numSmokeParticles);px++) {
      dbMakeObjectPlain(px,10,10);
      dbTextureObject(px,6);
      dbHideObject(px);
      //Deactivate ambient light
      dbSetObjectAmbient(px,0);
      //Make black areas see through
      dbSetObjectTransparency(px,1);
      //dbGhostObjectOn(px);
      dbSetObjectCollisionOff(px);
}
t=t+1;count=count+100;
}while (t<maxOpponents-1);

count=1500;
for (int px=count;px<(count+numSmokeParticles);px++){
   dbMakeObjectPlain(px,10,10);
   dbTextureObject(px,6);
   dbHideObject(px);
   //Deactivate ambient light
   dbSetObjectAmbient(px,0);
   //Make black areas see through
   dbSetObjectTransparency(px,1);
   //dbGhostObjectOn(px);
   dbSetObjectCollisionOff(px);
}
}

void positionSmoke(int t,int count,float smokex,float smokey,float smokez,float ang,float smokeParticlesPos[((maxOpponents*10)+10)+(numSmokeParticles)][3],float smokeParticlesVel[((maxOpponents*10)+10)+(numSmokeParticles)][3],float smokeParticlesSize[((maxOpponents*10)+10)+(numSmokeParticles)][3],float smokeParticlesFade[((maxOpponents*10)+10)+(numSmokeParticles)][2],int particleCount[maxOpponents+1],int currentParticle[maxOpponents+1]){

//Position new particle at origin every nth time
particleCount[t]=particleCount[t]+1;
if (particleCount[t]=2) {particleCount[t]=0;}
if (particleCount[t]=0) {
   //Increase number of particle to reset
   currentParticle[t]=currentParticle[t]+1;
   //Loop round if you reach the end of the particles
   if (currentParticle[t]>numSmokeParticles) {currentParticle[t]=1;}
   //Reset particle values
   //Position
   smokeParticlesPos[t*10+currentParticle[t]][1]=0;
   smokeParticlesPos[t*10+currentParticle[t]][2]=0;
   smokeParticlesPos[t*10+currentParticle[t]][3]=0;
   //Scale
   smokeParticlesSize[t*10+currentParticle[t]][1]=75;
   smokeParticlesSize[t*10+currentParticle[t]][2]=75;
   //Velocity (randomize)
   smokeParticlesVel[t*10+currentParticle[t]][1]=dbRND(1000)/1000.0-0.2f;
   smokeParticlesVel[t*10+currentParticle[t]][2]=dbRND(500)/1000.0+0.2f;
   smokeParticlesVel[t*10+currentParticle[t]][3]=dbRND(1000)/1000.0-0.2f;
   smokeParticlesFade[t*10+currentParticle[t]][1]=200;
   //Show the particle
   dbShowObject(count+currentParticle[t]);
}
//Loop through particles
for (int px=1;px<numSmokeParticles;px++){
   //Re-position and scale particle values
	for (int py=1;py<3;py++) {
      smokeParticlesSize[t*10+px][py]=smokeParticlesSize[t*10+px][py]+0.5;
      smokeParticlesPos[t*10+px][py]=smokeParticlesPos[t*10+px][py]+smokeParticlesVel[t*10+px][py];
	}
   //Fade particle value
   smokeParticlesFade[t*10+px][1]=smokeParticlesFade[t*10+px][1]-1.0;
   //Position, scale and fade particle object
   //check bottom three
   dbPositionObject(count+px,smokeParticlesPos[t*10+px][1]+smokex,smokeParticlesPos[t*10+px][2]+smokey,smokeParticlesPos[t*10+px][3]+smokez);
   dbScaleObject(count+px,smokeParticlesSize[t*10+px][1],smokeParticlesSize[t*10+px][2],100);
   dbFadeObject(count+px,smokeParticlesFade[t*10+px][1]);
   //Point at camera
   dbSetObjectToCameraOrientation(count+px);
   dbRotateObject(count+px,0,ang,0);
}
}

void monitor_lines_on(int monl_ypos[]){
	for (int j = 1;j<monl_max;j++)  {
      monl_ypos[j] = int(dbRND(100));
	}
}

void monitor_lines_update(int monl_ypos[],int alphamin,int alphamax){
   int max=dbINT(dbRND(monl_max))+monl_min;
   for (int j = 1;j<max;j++){
	   if (monl_ypos[j] > 100) {
         monl_ypos[j] = 0;
	   }
      monl_ypos[j] = (dbRND(100));
      dbSprite(monl_first,0,monl_ypos[j],monl_first);
      dbSetSprite(monl_first,0,1);
      dbSetSpriteAlpha(monl_first,dbRND(alphamax)+alphamin);
      dbStretchSprite(monl_first,100,dbRND(monl_width)+100);
      dbPasteSprite(monl_first,0,monl_ypos[j]);
   }
   dbDeleteSprite(monl_first);
}
void fadeIn(opponent* player,opponent computers[],int computer,int level,int waterheight) {
   
   dbSyncOn();
   dbSyncRate(1000);
   //position all sprites
   dbSprite(1,0,0,guages);//console
   dbSprite(2,52,137,compasndle);//needle for console
   dbSprite(overlay,0,490,overlay);dbSync();
   //void placeAllComp(opponent computers[],int player1,int player.explodeobj,int level,int waterheight){
   placeAllComp(computers,*player,level,waterheight);
   //placePlayer(int player1,int player.explodeobj,float* ang,float* x,float* y,float* z,int computer,int waterheight){
   //placePlayer(player1,player.explodeobj,ang,x,y,z,computer,waterheight);
   //void showRadar(float x,float z,float mx,float mz,int mflag,opponent computers[],int level,int plives,int pkills,BOOLEAN myTimerFlag, int OxygenUsed,int OxygenLeft)
   showRadar(*player,computers,level);
   player->angle=dbObjectAngleY(player->cobject);dbRotateSprite(2,player->angle);
   if (dbImageExist(scoreImage)==1) {dbSprite(3,550,0,scoreImage);}
   player->angle=dbObjectAngleY(player->cobject);
   //void SlidingCollisionPlayer(int player1,float* x,float* y,float* z,float ang,double move,int level){
   //SlidingCollisionPlayer(player1,x,y,z,*ang,0,level);
   //the screen camera
   dbPositionCamera(player->x,player->y,player->z);
   dbSetCameraToFollow(player->x,player->y,player->z,player->angle+180,cdist,chght,csmth,1);
   dbDeleteSprite(overlay);//cleanup after loader
   //perform a clean smooth in effect
   float volume=0;
   //gosub createLevel;
   for (int t = 255;t>1;t=t-2) {
   volume=volume+.5f;int temp;
   dbSetSpriteAlpha(preloader,t);
   if (volume<86) {
      dbSetSoundVolume(player->moveSound,int(volume));
	  temp=0;do {
         dbSetSoundVolume(computers[temp].moveSound,int(volume));
		 temp=temp+1;}while (temp<level-1);
   }
   if (t<=180) {
      dbPositionCamera(player->x,player->y,player->z);
      dbSetCameraToFollow(player->x,player->y,player->z,player->angle+t,cdist,chght,csmth,1);
	  dbUpdateTerrain();
   }
   dbSprite(levelImage,250,200,levelImage);
   dbSetSpriteAlpha(levelImage,255-t);
   dbPasteImage(HUD,2,2);
   dbSync();dbWait(10);}
   for (int t= 255;t>0;t--) {
   dbSprite(levelImage,250,200,levelImage);dbSetSpriteAlpha(levelImage,t);
   dbPasteImage(HUD,2,2);
   dbSync();dbWait(5);}
   dbDeleteSprite(preloader);dbSync();dbDeleteImage(preloader);dbDeleteImage(overlay);
   dbSetTextOpaque();dbSetTextSize(16);
   dbSyncRate(40);
}
void placeAllComp(opponent computers[],opponent player,int level,int waterheight){
int t=0;
do{
   //placeComp(opponent computers[],int t,int level,int player1,int player.explodeobj,int waterheight)
   placeComp(computers,t,level,player,waterheight);
   dbShowObject(computers[t].cobject);dbShowObject(computers[t].missileObject);
   for (int doit = 4;doit<11;doit++){
      dbOffsetLimb(computers[t].cobject,doit,0,0,0);
   }
   computers[t].explode=0;
   t=t+1;
}while (t<level-1);
}
void placePlayer(opponent* player,int computer,int waterheight){
	
	do{
      player->x=dbRND(mapsize-40)+20;
      player->z=dbRND(mapsize-40)+20;
	  player->y=dbGetTerrainGroundHeight(1,player->x,player->z);
	  player->angle=dbObjectAngleY(player->cobject);
      dbPositionObject(player->cobject,player->x,player->y,player->z);
	  //void calctilt( int id, float angle, float move)
	  //calctilt(player1,*ang,move); 	
	}while (dbObjectCollision(player->cobject,computer)!=0 || dbObjectCollision(player->cobject,player->explosionobjnum)!=0 || dbObjectPositionY(player->cobject)<waterheight);
   dbUpdateTerrain();
   dbPositionObject(1,0,0,0);
   dbRotateObject(1,0,0,0);
}
void placeComp(opponent computers[],int t,int level,opponent player,int waterheight){
   int collide=1;int temp=0;if (t>level-1){t=0;}
   EZro_Vec SurfNormalcomp[maxOpponents];
   do {
	  computers[t].explode=0;
      computers[t].x=dbRND(mapsize-40)+20;
      computers[t].z=dbRND(mapsize-40)+20;
      computers[t].y=dbGetTerrainGroundHeight(1,computers[t].x,computers[t].z);
      dbPositionObject(computers[t].cobject,computers[t].x,computers[t].y,computers[t].z);
      //void calctilt( int id, float angle, float move)
	  calctilt(computers[t].cobject,dbObjectAngleY(computers[t].cobject),computers[t].move);
      temp = 0;collide=0;
	  do{
		  if (temp!=t){
			  if (dbObjectCollision(computers[t].cobject,player.cobject)==1 || dbObjectCollision(computers[t].cobject,player.explodeobj)==1 || dbObjectCollision(computers[temp].cobject,computers[t].cobject)==1){
               collide=1;
		    }
			  if (dbObjectPositionY(computers[t].cobject)<=waterheight){
               collide=1;
	        }
		  }
         temp++;
		}while (temp<level-1);
   }while (collide!=0);
}

void showRadar(opponent player,opponent computers[],int level){
char MyChar[15];
// make radar
dbSetCurrentBitmap(1);
dbPasteImage(OLDHUD,0,0);//wipe old radar settings
//monitor_lines_update(int monl_ypos[],int alphamin,int alphamax)
monitor_lines_update(monl_ypos,32,8);
//position player on radar
dbInk(blue,black);
dbBox((player.x/hudsize)*100,100-((player.z/hudsize)*100),((player.x/hudsize)*100)+4,(100-((player.z/hudsize)*100))+4);

//position computer on radar
int t = 0 ;do {
   dbInk(black,black);
   dbBox((computers[t].x/hudsize)*100,(100-((computers[t].z/hudsize)*100)),((computers[t].x/hudsize)*100)+4,(100-((computers[t].z/hudsize)*100))+4);
   //position computer missile on radar
   if (computers[t].missileFlag==1){
      dbInk(red,black);
      dbCircle((computers[t].mx/hudsize)*100,(100-((computers[t].mz/hudsize)*100)),1);
   }
   t++;}while (t<level-1);
//position player missile on radar
   if (player.missileFlag==2){
  dbInk(red,black);
  dbCircle((player.mx/hudsize)*100,(100-((player.mz/hudsize)*100)),1);
}
dbGetImage(HUD,0,0,100,100,1);
//now display the player details
dbSetCurrentBitmap(5);
dbInk(black,white);dbBox(0,0,220,140);//wipe old text
dbInk(white,black);
dbSetTextSize(16);
MyChar[0]='\0';dbSetCursor(0,0);dbPrint("Player Kills");
dbSetCursor(70,0);dbPrint((char*)(toString(player.kills).c_str()));
MyChar[0]='\0';dbSetCursor(0,15);dbPrint("Player Lives");
dbSetCursor(70,15);dbPrint((char*)(toString(player.lives).c_str()));
MyChar[0]='\0';dbSetCursor(0,30);dbPrint("FPS");
dbSetCursor(70,30);dbPrint((char*)(toString(dbScreenFPS()).c_str()));
//dbSetCursor(0,30;print "PDist"
//dbSetCursor(0,30;print PDist
if (player.timerFlag==1){
   player.oxygenLeft=(100.00-((player.oxygenUsed/underwaterTime)*100.00));
   dbInk(red,black);
   dbSetCursor(0,30);dbPrint("Oxygen Left:");
   dbSetCursor(70,30);dbPrint((char*)(toString(player.oxygenLeft,3).c_str()));
}
dbGetImage(scoreImage,0,0,220,140,1);
dbSetCurrentBitmap(0);
dbPasteImage(HUD,2,2);
}
void calcmissiletilt( int id)
{
 EZro_Vec LimbDir;
 EZro_Vec EulerAngles;
 EZro_Mat objectMatrix;
 
 LimbDir.x = dbLimbDirectionX( id, 0);
 LimbDir.y = dbLimbDirectionY( id, 0);
 LimbDir.z = dbLimbDirectionZ( id, 0);
 
 objectMatrix = EZro_Euler2Matrix(LimbDir); 
 
 //unglue object
 dbUnGlueObject( id );
 //Rotate Missile at new values
 EulerAngles = EZro_Matrix2Euler(objectMatrix);
 dbRotateObject(id, EulerAngles.x, EulerAngles.y, EulerAngles.z);
}


// WOLFs Method
//void movemissile(int id,float move,float rot)
void movemissile( int id, double move, double rot)
{
 EZro_Vec EulerAngles;
 EZro_Mat objectMatrix;
 EZro_Vec PointBelow;
 //Setup EZrotate with the objects current rotation
 EulerAngles.x = dbObjectAngleX( id );
 EulerAngles.y = dbObjectAngleY( id );
 EulerAngles.z = dbObjectAngleZ( id );
 objectMatrix = EZro_Euler2Matrix(EulerAngles);
 //Setup EZrotate with the objects position
 objectMatrix.pos.x = dbObjectPositionX( id );
 objectMatrix.pos.y = dbObjectPositionY( id );
 objectMatrix.pos.z = dbObjectPositionZ( id );
 //Use "PITCH TO" to slowly rotate the missile to a point directly below the missile:
 PointBelow.x = objectMatrix.pos.x;
 PointBelow.y = objectMatrix.pos.y - 1;
 PointBelow.z = objectMatrix.pos.z;
 objectMatrix =  EZro_PitchTo(objectMatrix, PointBelow, rot);
 //Find new Euler angles and apply to object
 EulerAngles =  EZro_Matrix2Euler(objectMatrix);
 dbRotateObject(id, EulerAngles.x, EulerAngles.y, EulerAngles.z);
 
 //Move object forward
 dbMoveObject( id, move);
}


void ItoC(char * Buffer, int theNum)
{
        // convert int to char[] array
        
        int Rema = 0;
        while (theNum > 0) {
                Rema = theNum % 10;
                theNum /= 10;
                CPushR(Buffer, '0' + Rema, 15);
        }
        
}

void CPushR(char * theChars, char pushChar, int strLen)
{
        // push the characters in an array right, insert new val at beginning
        // characters that fall beyond the limit of theChars are lost
        
        int Pos = 0;
        char TempChar;
        while (Pos < strLen){
                TempChar = theChars[Pos];
                theChars[Pos] = pushChar;
                //if (pushChar == '\0') break;
                pushChar = TempChar;
                Pos++;
        }
        theChars[strLen-1] = '\0'; // always terminate string at end
}
void SlidingCollisionPlayer(opponent* player,int level){
/*EZro_Vec SurfNormal;
EZro_Vec EulerAngles;
EZro_Mat objectMatrix;*/
float oldang;

dbYRotateObject(player->cobject,player->angle);
//void calctilt( int id, float angle, float move)
calctilt(player->cobject,player->angle,player->move);
//dbPositionObject(player1,*x,*y,*z);
//SurfNormal=FindSurfaceNormal(player1,move);
dbPositionObject(player->cobject,player->x,dbGetTerrainGroundHeight(1,player->x,player->z),player->z);
player->x=dbObjectPositionX(player->cobject);
player->y=dbGetTerrainGroundHeight(1,player->x,player->z);
player->z=dbObjectPositionZ(player->cobject);
/*
//ensure player is at terrain height
//objectMatrix=EZro_AlignToPoly(ang,SurfNormal);
//EulerAngles = EZro_Matrix2Euler(objectMatrix);
//dbRotateObject(player1, EulerAngles.x, EulerAngles.y, EulerAngles.z);

for (int id=97;id<(player1+level);id++){
	if (player1!=id && dbObjectCollision(player1,id)>0){
      *x=*x-dbGetObjectCollisionX();
      *y=*y-dbGetObjectCollisionY();
      *z=*z-dbGetObjectCollisionZ();
	  //SurfNormal=FindSurfaceNormal(player1,move);
      dbPositionObject(player1,*x,*y,*z);
      
	  //EZro_LY(objectMatrix,ang);    
		//yrotate object player1,ang#
	}
    //check to make sure still no collision and player hasn't rotated on the spot
	if (player1!=id && dbObjectCollision(player1,id)>0){
      ang=oldang;//restore the angles
	  //calctilt(player1,ang,move);
      //SurfNormal=FindSurfaceNormal(player1,move);
	  dbPositionObject(player1,*x,*y,*z);
      //objectMatrix=EZro_AlignToPoly(ang,SurfNormal);
      //EulerAngles = EZro_Matrix2Euler(objectMatrix);
      //dbRotateObject(player1, EulerAngles.x, EulerAngles.y, EulerAngles.z);
      //EZro_LY(objectMatrix,ang);    
	  //check for collision
	  if (player1!=id && dbObjectCollision(player1,id)>0){
		*x=*x-dbGetObjectCollisionX();
		*y=*y-dbGetObjectCollisionY();
		*z=*z-dbGetObjectCollisionZ();
		//calctilt(player1,ang,move);
		dbPositionObject(player1,*x,*y,*z);
	}
	}
}*/
}

EZro_Vec FindSurfaceNormal(int id,double move){
EZro_Vec Point1;
EZro_Vec Point2;
EZro_Vec Point3;
//Point 1 = object position
 Point1.x =  dbObjectPositionX( id );
 Point1.y =  dbObjectPositionY( id );
 Point1.z =  dbObjectPositionZ( id );
 //Point 2 = object position + 1Z
 Point2.x =  Point1.x;
 Point2.y =  dbGetTerrainGroundHeight( 1, Point1.x, Point1.z + move);
 Point2.z =  Point1.z + move;
 //Point 3 = object position + 1X
 Point3.x =  Point1.x + move;
 Point3.y =  dbGetTerrainGroundHeight( 1, Point1.x + move, Point1.z);
 Point3.z =  Point1.z;
    //Use FIND NORMAL Feature to find the normal of the surface
    //--------------------------------------------------------
return EZro_FindNormal(Point1, Point2, Point3);
}

//Simple AI
void compAI(opponent computers[],opponent* player,int level){

int t=0;float PDist;do {
if (computers[t].explode==0 && player->explode==0){
   //position computer scud at new location
   dbPositionObject(computers[t].cobject,computers[t].x,computers[t].y,computers[t].z);
   PDist=calcDistance(computers[t].x,computers[t].y,computers[t].z,player->x,player->y,player->z);
   computers[t].angle=dbObjectAngleY(computers[t].cobject);
   if (PDist<=180){
	   if (PDist<=minPDist){
         computers[t].x=dbNewXValue(computers[t].x,computers[t].angle,-.65);
         computers[t].z=dbNewZValue(computers[t].z,computers[t].angle,-.65);
         //void calctilt( int id, float angle, float move)
		 calctilt(computers[t].cobject,dbObjectAngleY(computers[t].cobject),computers[t].move);
         computers[t].move=-.65;
	  }
      //aim computer scud
	  //void calcaimframe(opponent computers[],int t,int player1)
	  if (computers[t].missileFlag==0){calcaimframe(computers,t,*player);}
	  if (computers[t].frame<computers[t].tempFrame){computers[t].frame++;}
	  if (computers[t].frame>40){computers[t].frame=1;}
      dbSetObjectFrame(computers[t].cobject,computers[t].frame);
   }
   //gohere
   if (PDist >180){
	   if (computers[t].frame<=40){
         computers[t].frame--;
		 if (computers[t].frame<0){computers[t].frame=90;}
         dbSetObjectFrame(computers[t].cobject,computers[t].frame);
	   }else{
		 if (computers[t].frame>65){computers[t].frame--;}
         dbSetObjectFrame(computers[t].cobject,computers[t].frame);
		 if (computers[t].frame=65){computers[t].frame=90;}
         computers[t].x=dbNewXValue(computers[t].x,computers[t].angle,.65);
         computers[t].z=dbNewZValue(computers[t].z,computers[t].angle,.65);
         computers[t].move=.65;
         computers[t].frameCounter=-1;//;computers[t)->computerUp=1
	   }
   }
   //setup missile if none fired
   if (computers[t].missileFlag==0 && computers[t].frame==computers[t].tempFrame && computers[t].explode==0){
      //computers[t].power = (PDist/((float)sqrt((float)PDist)*(500)+dbRND(200)));
	  //computers[t].power = (PDist/((float)sqrt((float)PDist)*(500->00f)+((float)(rand()*200->0f))));//player chasing
      computers[t].power=(PDist/((float)sqrt((float)PDist)*(12.231f+(dbRND(8)))));
	  //computers[t].power=1->02f;
	  computers[t].missileFlag=1;
      calcmissiletilt(computers[t].missileObject);
      dbPlaySound(computers[t].missileMoveSound);
      computers[t].cmissileLife=0;//catch computer stuff ups
   }
   //void SlidingCollisionComputer(opponent computers[],int t,opponent player)
   SlidingCollisionComputer(computers,t,*player);
}
if (computers[t].missileFlag==1){computershoot(computers,t,player,level);}
t++;}while (t<=level-1);

}

//shoot computer missile
void computershoot(opponent computers[],int t,opponent* player,int level){
float theight;
int temp;
//the missile now fires
//position computer scud at new location
   //movemissile(player.missileObject,(player.power+1.00),(1.01-player.power)+1.00); 
   movemissile(computers[t].missileObject,(computers[t].power+1.00),(1.01-computers[t].power)+1.00);
   computers[t].cmissileLife++;
   computers[t].mx=dbObjectPositionX(computers[t].missileObject);
   computers[t].my=dbObjectPositionY(computers[t].missileObject);
   computers[t].mz=dbObjectPositionZ(computers[t].missileObject);
   dbPositionSound(computers[t].missileMoveSound,computers[t].mx,computers[t].my,computers[t].mz);

   theight=dbGetTerrainGroundHeight(1,computers[t].mx,computers[t].mz);
   computers[t].hit=dbObjectCollision(computers[t].missileObject,0);
   temp=0;do{//rem need to check if computer shot himself
   if(theight>computers[t].my || dbObjectVisible(computers[t].missileObject)==0 || computers[t].hit==player->cobject || computers[t].cmissileLife>missileLife || computers[t].hit==computers[temp].cobject && temp!=t){
	  // if(theight>computers[t].my || dbObjectVisible(computers[t].missileObject)==0 || computers[t].hit==player.cobject || computers[t].cmissileLife>missileLife){// || computers[t].hit==computers[temp].cobject && temp!=t){  
	   computers[t].missileFlag=0;
      dbPositionSound(computers[t].explosionSound,computers[t].mx,computers[t].my,computers[t].mz);
      dbPlaySound(computers[t].explosionSound);
      //explosion animation
      dbShowObject(computerexplosionobj+computers[t].explosionobjnum);
      if(computers[t].hit==0){
         dbScaleObject(computerexplosionobj+computers[t].explosionobjnum,40,40,40);
         dbPositionObject(computerexplosionobj+computers[t].explosionobjnum,computers[t].mx,computers[t].my+2,computers[t].mz);

	  }else{
         dbScaleObject(computerexplosionobj+computers[t].explosionobjnum,100,100,100);
         dbPositionObject(computerexplosionobj+computers[t].explosionobjnum,computers[t].mx,computers[t].my+4,computers[t].mz);
      }
      dbRotateObject(computerexplosionobj+computers[t].explosionobjnum,0,player->angle,0);
      dbPlayAnimation(computerexplosionanimation+computers[t].explosionobjnum);

      dbGlueObjectToLimb(computers[t].missileObject,computers[t].cobject,11);
      //reposition the scud on the launcher
      dbPositionObject(computers[t].missileObject,0,0,0);
      dbRotateObject(computers[t].missileObject,0,180,0);
      if(computers[t].hit==computers[temp].cobject && computers[temp].explode==0){
         dbPositionObject(computers[temp].cobject,computers[temp].x,computers[temp].y,computers[temp].z);
         dbYRotateObject(computers[temp].cobject,dbRND(360));
         //void calctilt(int id, float angle, float move)
		 calctilt(computers[temp].cobject,dbObjectAngleY(computers[temp].cobject),computers[t].move);
         computers[temp].explode=2;//shot one of his own
      }
   }
   temp++;}while(temp<=(level-1));
   if(computers[t].hit==player->cobject){
      dbPositionObject(player->explodeobj,player->x,player->y,player->z);
	  //void calctilt( int id, float angle, float move)
      calctilt(player->explodeobj,dbObjectAngleY(player->explodeobj),player->move);
      dbHideObject(player->cobject);dbShowObject(player->explodeobj);
      //try and return limbs so not too scattered
      for(int doit = 4;doit<11;doit ++){
         dbOffsetLimb(player->explodeobj,doit,0,0,0);
      }
      //try and scatter limbs
      for(int doit = 4;doit<11;doit ++){
         dbOffsetLimb(player->explodeobj,doit,dbRND(4),0,dbRND(4));
      }
      player->explode=1;player->lives--;
   }
}

void calcaimframe(opponent computers[],int t,opponent player){
float tempaim;
tempaim=dbLimbAngleY(computers[t].cobject,11);
if (tempaim>=0){
   computers[t].frame=35+computers[t].frameCounter;
   computers[t].frameCounter++;computers[t].frame=35+(computers[t].frameCounter % 6);
}
if (tempaim<=35){
   computers[t].frame=35+computers[t].frameCounter;
   computers[t].frameCounter--;computers[t].frame=35+(computers[t].frameCounter % 6);
}

   if (computers[t].frameCounter>4){
      computers[t].frameCounter=0;
      //move object computers[t].cobject,-.65
      computers[t].x=dbNewXValue(computers[t].x,computers[t].angle,-.65);
      computers[t].z=dbNewZValue(computers[t].z,computers[t].angle,-.65);
      computers[t].move = .65;
	  //void SlidingCollisionComputer(opponent computers[],int t,int player1)
      SlidingCollisionComputer(computers,t,player);
   }
   computers[t].tempFrame=computers[t].frame;
}

void SlidingCollisionComputer(opponent computers[],int t,opponent player){
//dbYRotateObject(computers[t].cobject,ang);
//void calctilt( int id, float angle, float move)
calctilt(computers[t].cobject,computers[t].angle,computers[t].move);
dbPositionObject(computers[t].cobject,computers[t].x,dbGetTerrainGroundHeight(1,computers[t].x,computers[t].z),computers[t].z);
computers[t].x=dbObjectPositionX(computers[t].cobject);
computers[t].y=dbGetTerrainGroundHeight(1,computers[t].x,computers[t].z);
computers[t].z=dbObjectPositionZ(computers[t].cobject);

/*
`ensure computer is at terrain height
computers[t).y=get terrain ground height(1,computers[t).x,computers[t).z)
computers[t).angle=object angle y(computers[t).cobject)
//void calctilt( int id, float angle, float move)
calctilt(computers[t].cobject,computers[t].angle,computers[t].move)
position object computers[t).cobject,computers[t).x,computers[t).y,computers[t).z
for id=97 to ((player1+1)+level)`103
   if computers[t).explode=0
      if computers[t).cobject<>id and object collision(computers[t).cobject,id)>0
         dec computers[t).x,get object collision x()
         dec computers[t).y,get object collision y()
         dec computers[t).z,get object collision z()
         //void calctilt( int id, float angle, float move)
		 calctilt(computers[t].cobject,computers[t].angle,computers[t].move)
         position object computers[t).cobject,computers[t).x,computers[t).y,computers[t).z
         yrotate object computers[t).cobject,computers[t).angle
      endif
      `check to make sure still no collision and player hasn't rotated on the spot
      if computers[t).cobject<>id and object collision(computers[t).cobject,id)>0
         computers[t).angle=computers[t).oldAngle`restore the angles
         //void calctilt( int id, float angle, float move)
		 calctilt(computers[t].cobject,computers[t].angle,computers[t].move)
         position object computers[t).cobject,computers[t).x,computers[t).y,computers[t).z
         yrotate object computers[t).cobject,computers[t).angle
         `check for collision
         if computers[t).cobject<>id and object collision(computers[t).cobject,id)>0
            dec computers[t).x,get object collision x()
            dec computers[t).y,get object collision y()
            dec computers[t).z,get object collision z()
            position object computers[t).cobject,computers[t).x,computers[t).y,computers[t).z
         endif
      endif
   endif
next id
computers[t).oldAngle=computers[t).angle`store the angle
*/
if (computers[t].explode==0){
   dbPointObject(computers[t].cobject,dbObjectPositionX(player.cobject),dbObjectPositionY(player.cobject),dbObjectPositionZ(player.cobject));
}
}

float calcDistance(float x1,float y1,float z1,float x2,float y2,float z2){
	float Distance;int a;
	int VectorResult=dbMakeVector3(1);
    dbSetVector3(1,(x2-x1),(y2-y1),(z2-z1));
    Distance=dbLengthVector3(1);
    a=dbDeleteVector3(VectorResult);
    return Distance;
}


void pauseScreen(opponent computers[],opponent player,int level){
int temp;
dbStopSound(player.moveSound);
dbPauseSound(player.missileMoveSound);
dbPauseSound(player.explosionSound);
int t=0;do{
   dbStopSound(computers[t].moveSound);
   dbPauseSound(computers[t].missileMoveSound);
   dbPauseSound(computers[t].explosionSound);
t++;}while(t<level-1);
dbSync();dbInk(red,black);
dbCreateBitmap(3,800,600);
dbSetCurrentBitmap(3);
dbCLS(black);dbSetTextSize(50);
dbPrint("Game Paused");
dbGetImage(gamePaused,0,0,265,50,1);
dbSetCurrentBitmap(0);
dbSprite(gamePaused,200,200,gamePaused);
dbShowSprite(gamePaused);
dbPasteImage(HUD,2,2);
dbSync();do{dbSuspendForKey();}while(dbUpper(dbInKey())!="P");
dbDeleteBitmap(3);dbSetTextSize(16);
dbLoopSound(player.moveSound);
dbResumeSound(player.missileMoveSound);
dbResumeSound(player.explosionSound);
t=0;do{
   dbLoopSound(computers[t].moveSound);
   dbResumeSound(computers[t].missileMoveSound);
   dbResumeSound(computers[t].explosionSound);
   t++;}while(t<=level-1);
 float volume=0;for(t = 255;t>1;t=t-2){
   volume=volume+.5;
   dbSetSpriteAlpha(gamePaused,t);
   if (volume<86){
      dbSetSoundVolume(player.moveSound,dbINT(volume));
   }
   if (volume<101){
      dbSetSoundVolume(player.missileMoveSound,dbINT(volume));
      dbSetSoundVolume(player.explosionSound,dbINT(volume));
   }
   temp=0;do{
	  if (volume<86){
         dbSetSoundVolume(computers[temp].moveSound,dbINT(volume));
	  }
	  if (volume<101){
         dbSetSoundVolume(computers[temp].missileMoveSound,dbINT(volume));
         dbSetSoundVolume(computers[temp].explosionSound,dbINT(volume));
	  }
	  temp++;}while(temp<=(level-1));
   dbPasteImage(HUD,2,2);
   dbPositionCamera(player.x,player.y,player.z);
   dbSetCameraToFollow(player.x,player.y,player.z,player.angle,cdist,chght,csmth,1);
   dbSync();
  }
dbDeleteSprite(gamePaused);dbDeleteImage(gamePaused);
}


void YouWon(opponent computers[],opponent player,int level){
float volume;
dbCreateBitmap(3,800,600);
dbSetCurrentBitmap(3);
dbCLS(black);dbInk(red,black);
dbSetTextSize(50);
dbPrint("You Won!!");
dbGetImage(youWon,0,0,220,50,1);
dbSetCurrentBitmap(0);
dbSprite(youWon,220,200,youWon);dbSetSpritePriority(youWon,65535);
dbSetSpriteAlpha(youWon,1);
volume=100;
for (int t = 1;t<255;t++){
   dbSync();dbSprite(youWon,220,200,youWon);
   dbSetSpriteAlpha(youWon,t);
   if (player.particleFrequency>0){player.particleFrequency--;dbSetParticleEmissions(player.missileObject,player.particleFrequency);}
   if (volume<86 && volume>0){
      dbSetSoundVolume(player.moveSound,dbINT(volume));
   }
   if (volume<101 && volume>0){
      dbSetSoundVolume(player.missileMoveSound,dbINT(volume));
      dbSetSoundVolume(player.explosionSound,dbINT(volume));
   }
   int temp = 0 ;do{
      if (computers[temp].particleFrequency>0){computers[temp].particleFrequency--;dbSetParticleEmissions(computers[temp].missileObject,computers[temp].particleFrequency);}
      if (volume<86 && volume>0){
         dbSetSoundVolume(computers[temp].moveSound,dbINT(volume));
      }
      if (volume<101 && volume>0){
         dbSetSoundVolume(computers[temp].missileMoveSound,dbINT(volume));
         dbSetSoundVolume(computers[temp].explosionSound,dbINT(volume));
      }
   temp++;}while(temp<=level-1);
   volume=volume-.5;
}
for (int t=255;t>1;t--){
   dbSync();dbSprite(youWon,220,200,youWon);
   dbSetSpriteAlpha(youWon,t);
}
}

void endGame(opponent computers[],opponent player,int level){
int temp;
dbCreateBitmap(3,800,600);
dbSetCurrentBitmap(3);
dbCLS(black);dbInk(red,black);
dbSetTextSize(50);
dbPrint("Game Over");
dbGetImage(gameover,0,0,220,50,1);
dbSetCurrentBitmap(0);
dbSprite(gameover,200,200,gameover);
dbSetSpritePriority(gameover,65535);
dbSetSpriteAlpha(gameover,1);
float volume=100.0f;
for (int t = 1;t<255;t++){
   dbSync();dbSprite(gameover,200,200,gameover);
   dbSetSpriteAlpha(gameover,t);
   if (player.particleFrequency>0){player.particleFrequency--;dbSetParticleEmissions(player.missileObject,player.particleFrequency);}
   if (volume<86 && volume>0){
      dbSetSoundVolume(player.move,dbINT(volume));
   }
   if (volume<101 && volume>0){
      dbSetSoundVolume(player.missileMoveSound,dbINT(volume));
      dbSetSoundVolume(player.explosionSound,dbINT(volume));
   }
   temp=0;do{
	   if (computers[temp].particleFrequency>0){computers[temp].particleFrequency--;dbSetParticleEmissions(computers[temp].missileObject,computers[temp].particleFrequency);}
      if (volume<86 && volume>0){
         dbSetSoundVolume(computers[temp].moveSound,dbINT(volume));
      }
      if (volume<101 && volume>0){
         dbSetSoundVolume(computers[temp].missileMoveSound,dbINT(volume));
         dbSetSoundVolume(computers[temp].explosionSound,dbINT(volume));
      }
   temp++;}while (temp<=level-1);
   volume=volume-.5;
}
}


void createLevel(int level){
char MyChar[16]="Level ";
dbInk(red,black);
dbCreateBitmap(4,800,600);
dbSetCurrentBitmap(4);
dbCLS(black);
dbSetTextSize(50);

strcat(MyChar,(char*)(toString(level).c_str()));
dbPrint(MyChar);
dbGetImage(levelImage,0,0,200,50,1);
dbSetCurrentBitmap(0);
dbSprite(levelImage,250,200,levelImage);
dbSetSpritePriority(levelImage,65535);
dbDeleteBitmap(4);dbShowSprite(levelImage);
}

void doNewLevel(opponent* player,int computer,opponent computers[],int waterHeight,int level){
//set timer variables for underwater play

player->timer=0;player->timerFlag=0;player->oxygenUsed=0;
createLevel(level);
for (int t= 0;t<255;t++){
   dbSprite(levelImage,250,200,levelImage);
   dbSetSpriteAlpha(levelImage,t);
   dbPasteImage(HUD,2,2);
dbSync();dbWait(5);}
//void placePlayer(int player1,int player.explodeobj,float* ang,float* x,float* y,float* z,int computer,int waterheight)
//placePlayer(player1,player.explodeobj,ang,x,y,z,computer,waterheight);dbShowObject(player1);
player->angle=dbObjectAngleY(player->cobject);
//void calctilt( int id, float angle, double move)
calctilt(player->cobject,dbObjectAngleY(player->cobject),player->move);
//void placeAllComp(opponent computers[],int player1,int player.explodeobj,int level,int waterheight)
placeAllComp(computers,*player,level,waterHeight);
dbPositionCamera(player->x,player->y,player->z);
dbSetCameraToFollow(player->x,player->y,player->z,player->angle+180,cdist,chght,csmth,1);

//hide all smoke objects
int t=0,count=smokeobject;do{
   for (int px=count;px<(count+numSmokeParticles);px++){
      dbHideObject(px);
   }
t++;count=count+100;}while(t<=maxOpponents-1);
count=1500;for (int px=count;px<(count+numSmokeParticles);px++){
   dbHideObject(px);
}
//end hide smoke objects

//show sprite for the level number and fade away
for(int t= 255;t>0;t--){
   dbSprite(levelImage,250,200,levelImage);
   dbSetSpriteAlpha(levelImage,t);
   dbPasteImage(HUD,2,2);
dbSync();dbWait(5);}

}

int levelChange(int num){
   int result=1,i=1;
   while (i<=num){
      result=result+i;i++;
   }
   result=result-1;
   return result;
}
// returns the string representation of a number
string toString(int num) {
	ostringstream myStream;

	myStream<<num<<endl;
	return myStream.str();
}
string toString(float num,int precision){
ostringstream myStream;

	myStream<<leftprec(num,precision)<<endl;
	return myStream.str();
}

float leftprec(float x,float y) 
{
	return(x - (((int)floor(x) - (((int)floor(x))% ((int)(pow(10,y)))))));
}