Sorry your browser is not supported!

Enemy1 enemy1;
Enemy1 enemy2;
Enemy1 enemy3;

enemy1.LoadEnemy(1);
	enemy1.Spawn(200, 100, enemy1.id);

enemy2.LoadEnemy(1);
	enemy2.Spawn(200, 200, enemy2.id);

enemy3.LoadEnemy(1);
	enemy3.Spawn(200, 200, enemy3.id);

void Enemy1::Move(int id, int speed, int LastX, int LastY)
{
	PointSprite(id, LastX, LastY);
	dbMoveSprite(id, speed);	
}

enemy1.Move(enemy1.id, enemy1.speed, 500, 500);

if(dbSpriteX(enemy1.id) == 500 && dbSpriteY(enemy1.id) == 500)
{
//reached destiny
Path1 = true;
}
else if(dbSpriteX(enemy1.id) == 500 && dbSpriteY(enemy1.id) == 500 && Path1 != false)
{
//it has moved to the first path and now the second
Path2 = true;
}

struct TARGETPOINT
{
int x;
int y;
};
vector<TARGETPOINT> wayPointV; //this should be a member of the Enemy1 struct

to set up your way points, do this:
TAGETPOINT points[] = {
{ x, y }, //some x/y points
{ x, y },
{ x, y },
{ x, y },
{ x, y },
{ x, y },
{ x, y }
};
for ( int i = 0; i < sizeof ( points ) / sizeof ( TAGETPOINT ); i++ )
wayPointV.push_back ( points[i] );

now for every loop, probably in the Update function of every enemy
if ( wayPointV.size ( ) > 0 ) //like: "if we have any way points"
{
dbPointSprite ( id, wayPointV[0].x, wayPointV[0].y ); //use the first element of the vector, this is our "next" way point to reach
dbMoveSprite ( id, speed );
if ( check if the sprite reached the point (wayPointV[0].x, wayPointV[0].y) )
wayPointV.erase ( wayPointV.begin ( ) ); //delete the first element, which is the point we currently are at
}

	vector<Path1> path1V;

Path1 points[] = {
	{ 100, 300 },
	{ 465, 120 },
	{ 222, 333 },
	{ 444, 222 },
	{ 178, 433 },
	{ 390, 50 },
	{ 100, 100 }
};

	for( int i = 0; i < sizeof(points) / sizeof (Path1); i++)
	path1V.push_back (points[i]);

Path1 points[] = {
	{ 100, 300 },
	{ 465, 120 },
	{ 222, 333 },
	{ 444, 222 },
	{ 178, 433 },
	{ 390, 50 },
	{ 100, 100 }
};

	for( int i = 0; i < sizeof(points) / sizeof (Path1); i++)
	path1V.push_back (points[i]);

struct Enemy1
{
..
...
vector<> <--- here
..
..
};

void Enemy1::whatever ( whatever )
{
used here
}

struct Enemy1
{
	void LoadEnemy(int dificulty);
	void Spawn(int SpawnX, int SpawnY, int id);
	void Move(int id, int speed, int LastX, int LastY);
	void Update(int id, int speed);


	int image_id;
	int speed;
	int health;
	int id;
	int level;
	int money;
	int score;

        vector<Path1> path1V;

	Path1 points[] = {
	{ 100, 300 },
	{ 465, 120 },
	{ 222, 333 },
	{ 444, 222 },
	{ 178, 433 },
	{ 390, 50 },
	{ 100, 100 }
	};

	for( int i = 0; i < sizeof(points) / sizeof (Path1); i++)
	path1V.push_back (points[i]);
};

 vector<Path1> path1V;

	Path1 points[] = {
	{ 100, 300 },
	{ 465, 120 },
	{ 222, 333 },
	{ 444, 222 },
	{ 178, 433 },
	{ 390, 50 },
	{ 100, 100 }
	};

	for( int i = 0; i < sizeof(points) / sizeof (Path1); i++)
	path1V.push_back (points[i]);

Map1 points[] = {
	{ -100, 160 }, 
	{ 318, 160 }, 
	{ 318, 311 }, 
	{ 560, 311 },
	{ 560, 151 },
	{ 750, 151 },
	{ 750, 677 },
	{ 611, 677 },
	{ 611, 432 },
	{ 112, 432 },
	{ 109, 686 },
	{ 438, 694 },
	{ 438, 800 }
	};

if( Map1V.size() > 0 ) 
	{
		PointSprite(id, Map1V[0].x, Map1V[0].y);
		dbMoveSprite(id, speed);
		if(dbSpriteX(id) == Map1V[0].x && dbSpriteY(id) == Map1V[0].y)
		{
			Map1V.erase (Map1V.begin ());
		}
	}
	else
	{
		dbDeleteSprite(id);
		cSpawn = true;
	}

else
	{
		dbDeleteSprite(id);
		cSpawn = true;
	}

bool Enemy1::PathFinished ( void ) const
{
   return (Map1V.size ( ) == 0);
}

while ( LoopGDK ( ) )
{
//..
if ( enemy1.PathFinished ( ) )
{
//path is over, no more waypoints, reduce player lives and re-initialize
player1.RemoveLife ( ); //whatever
enemy1.Initialize ( whateverID, startX, startY );
}
//...
}

bool PathFinished(void) const;

PathFinished() = false;
cSpawn = true;

if( Map1V.size() > 0 ) 
	{
		PointSprite(id, Map1V[0].x, Map1V[0].y);
		dbMoveSprite(id, speed);
		if(dbSpriteX(id) == Map1V[0].x && dbSpriteY(id) == Map1V[0].y)
		{
			Map1V.erase (Map1V.begin ());
		}
	}
	else
	{
		PathFinished() = true;
	}

void Enemy1::Update(int id, int speed)
{
	if(cSpawn)
	{
		Spawn(Map1V[0].x, Map1V[0].y, id);
		cSpawn = false;

	}

	if( Map1V.size() > 0 ) 
	{
		PointSprite(id, Map1V[0].x, Map1V[0].y);
		dbMoveSprite(id, speed);
		if(dbSpriteX(id) == Map1V[0].x && dbSpriteY(id) == Map1V[0].y)
		{
			Map1V.erase (Map1V.begin ());
		}
	}
	else
	{
		PathFinished();
	}

if(PathFinished())
{
//delete one life to player
LoadEnemy(difficulty); 
}
}

struct Enemy1
{
//.....
bool PathFinished(void) const;
//.....
};
/*
this is a member function of the class Enemy1, it will just tell whether
Map1V (the vector) is empty or not, from now on the struct is not responsible
for re-filling itself with points, instead, the USER (your DarkGDK function,
in your GAME LOOP) is going to do this, it will simply ask the structure, did
you finish your path? if so, decrease player life and re-fill enemy path
*/
bool Enemy1::PathFinished ( void ) const
{
   return (Map1V.size ( ) == 0);
}

while ( LoopGDK ( ) )
{
//..
if ( enemy1.PathFinished ( ) ) //did you finish the path, enemy1?
{ //yes?
player1.RemoveLife ( ); //well reduce player lives
enemy1.Initialize ( whateverID, startX, startY ); //ok there you go enemy1, re-fill your path for re-use
}
//...
}

int distX = dbSpriteX(id) - Map1V[0].x;
		int distY = dbSpriteY(id) - Map1V[0].y;
		if(distX > speed && distY > speed)
		{
			Map1V.erase (Map1V.begin ());
		}

		int distX = abs ( dbSpriteX(id) - Map1V[0].x );
		int distY = abs ( dbSpriteY(id) - Map1V[0].y );
		if(distX*distX + distY*distY < speed*speed) //to avoid using sqrt
		{
			dbSprite ( id, Map1V[0].x, Map1V[0].y, image_id );//not necessary, but it's better to have(more accurate)
			Map1V.erase (Map1V.begin ());
		}