My programming style :(

        
void moveEnemies()
{
  vector gravity;
  vector enemyVel;
  vector enemyAccel;
  vector oldPos;

  previousTime = thisTime;
  thisTime = timeGetTime()*0.001 ;
  timeDifference = thisTime-previousTime;
  if (previousTime == 0) timeDifference = 0;

  for (int a=0;a<numEnemies;a++)
  {
    enemies[a].accel.x = 0;  
    enemies[a].accel.y = 0;  
    enemies[a].accel.z = 0;
    
    for(int x=0;x<numPlanets;x++)
    {
         gravity = substract(planets[x].pos, enemies[a].pos);
         EPDdistance = distance3D(enemies[a].pos, planets[x].pos); //EPDistance = Enemy Planet Distance

         if (EPDistance < planets[x].size)  EPDistance = sqrtplanets[x].size;
         gravity = normalize(gravity);
         gravity = multiplyBy(gravity, enemies[a].mass*planets[x].mass/(EPDistance*EPDistance));
         //if (gravity.x < 1 && gravity.y < 1 && gravity.z < 1)

         enemies[a].accel = add(gravity, enemies[a].accel);
    }


    enemyAccel = multiplyBy(enemies[a].accel, (timeDifference)); //the accel in m/t² with t = time since last frame

    enemies[a].vel = add(enemyAccel, enemies[a].vel);
    enemyVel = multiplyBy(enemies[a].vel, (timeDifference)); //the vel in m/t with t = time since last frame

    oldPos = enemies[a].pos;
    enemies[a].pos = add(enemies[a].pos, enemyVel);
    enemies[a].dir = normalize(substract(enemies[a].pos, oldPos));
    if ( enemies[a].dir.x == 0  &&  enemies[a].dir.y == 0 && enemies[a].dir.z == 0)
    {
       enemies[a].dir = defaultEnemyDir;
    }

  }
}
         

          
void moveEnemies()
{
  vector gravity;
  vector enemyVel;
  vector enemyAccel;
  vector oldPos;

  previousTime = thisTime;
  thisTime = timeGetTime()*0.001 ;
  timeDifference = thisTime-previousTime;
  if (previousTime == 0) timeDifference = 0;

  for (int a=0;a<numEnemies;a++)
  {
    enemies[a].accel.x = 0;  
    enemies[a].accel.y = 0;  
    enemies[a].accel.z = 0;
    
    for(int x=0;x<numPlanets;x++)
    {
         gravity = substract(planets[x].pos, enemies[a].pos);
         EPDdistance = distance3D(enemies[a].pos, planets[x].pos); //EPDistance = Enemy Planet Distance

         if (EPDistance < planets[x].size)  EPDistance = sqrtplanets[x].size;
         gravity = normalize(gravity);
         gravity = multiplyBy(gravity, enemies[a].mass*planets[x].mass/(EPDistance*EPDistance));
         //if (gravity.x < 1 && gravity.y < 1 && gravity.z < 1)

         enemies[a].accel = add(gravity, enemies[a].accel);
    }


    enemyAccel = multiplyBy(enemies[a].accel, (timeDifference)); //the accel in m/t² with t = time since last frame

    enemies[a].vel = add(enemyAccel, enemies[a].vel);
    enemyVel = multiplyBy(enemies[a].vel, (timeDifference)); //the vel in m/t with t = time since last frame

    oldPos = enemies[a].pos;
    enemies[a].pos = add(enemies[a].pos, enemyVel);
    enemies[a].dir = normalize(substract(enemies[a].pos, oldPos));
    if ( enemies[a].dir.x == 0  &&  enemies[a].dir.y == 0 && enemies[a].dir.z == 0)
    {
       enemies[a].dir = defaultEnemyDir;
    }

  }
}
           

              
  void moveEnemies() {
    //don't put too much code in one block. Use more methods

    calculateTimeDifference();

    for (int a = 0; a < numEnemies; a++) {
      //I don't know the type of "enemies".. but make it clear that you're dealing

      //with a single enemy at a time. Better yet, use STL containers

      Enemy* enemy = &enemies[a];
      //implement moveTo() to your vector class. It should be helpful later on too

      enemy->accel.moveTo(0, 0, 0);
			
      //this is wrong way, sorry.. You should actually do a function call to

      //enemy->calculateAcceleration(planets);

      //which would look nicer. But I'm not touching your enemy class here

      calculateAccelerationForEnemy(enemy);

      //i'm not gonna touch the following stuff. But it needs work :). Mostly operator overloading

      vector enemyAccel = multiplyBy(enemy->accel, timeDifference);
      enemy->vel = add(enemyAccel, enemy->vel);
      vector enemyVel = multiplyBy(enemy->vel, timeDifference);
      vector oldPos = enemy->pos;
      enemy->pos = add(enemy->pos, enemyVel);
      enemy->dir = normalize(substract(enemy->pos, oldPos));
      //I have a feeling that your vectors will never be 0. Something is wrong here:

      if (enemy->dir.x == 0 && enemy->dir.y == 0 && enemy->dir.z == 0) {
        enemy->dir = defaultEnemyDir;
      }
    }
  }
	
  void calculateAccelerationForEnemy(Enemy* enemy) {
    for (int x = 0; x < numPlanets; x++) {
      //once again, deal with a planet, not with planet array

      Planet* planet = &planets[x];
      //don't give variables too much scope. Instantiate them where they're needed (I moved "vector gravity" to here)

      //Learn about operator overloading and fix this then.

      //Could be written: vector gravity = planet->pos - enemy->pos;

      vector gravity = substract(planet->pos, enemy->pos);
      //where is EPDdistance instantiated? Instantiate it here where it's needed, thanks ;)

      //also, implement distanceTo() in your vector class

      EPDdistance = enemy->pos.distanceTo(planet->pos);
      //sqrtplanets?

      if (EPDistance < planet->size) EPDistance = sqrtplanets[x].size;
      //implement normalize in the vector class

      gravity.normalize();
      //once again, operator overloading will make these rows look cleaner

      gravity = multiplyBy(gravity, enemy->mass * planet->mass / (EPDistance * EPDistance));
      enemy->accel = add(gravity, enemy->accel);
    }
  }
	
  void calculateTimeDifference() {
    previousTime = thisTime;
    thisTime = timeGetTime() * 0.001;
    timeDifference = thisTime - previousTime;
    if (previousTime == 0) timeDifference = 0;
  }
              

  
std::vector<Ship> g_ships;
std::vector<Planet> g_planets;
std::vector<Bullets> g_bullets;
std::vector<Powerups> g_powerups;

bool load_level(char* _levelfile) {
  //fills the 4 dynamic arrays..

}

int main() {
 levelscript script("scriptname");
 while(script.has_next()&&load_level(script.next())) {
  mainloop();
 }
}