diff --git a/source/enemy_formations.cpp b/source/enemy_formations.cpp
new file mode 100644
index 0000000..ca06841
--- /dev/null
+++ b/source/enemy_formations.cpp
@@ -0,0 +1,722 @@
+#include "enemy_formations.h"
+
+// Constructor
+EnemyFormations::EnemyFormations()
+{
+	initEnemyFormations();
+	initEnemyPools();
+	initGameStages();
+}
+
+// Destructor
+EnemyFormations::~EnemyFormations()
+{
+}
+
+// Inicializa las formaciones enemigas
+void EnemyFormations::initEnemyFormations()
+{
+	const int y4 = PLAY_AREA_TOP - BLOCK;
+	const int x4_0 = PLAY_AREA_LEFT;
+	const int x4_100 = PLAY_AREA_RIGHT - BALLOON_WIDTH_4;
+
+	const int y3 = PLAY_AREA_TOP - BLOCK;
+	const int x3_0 = PLAY_AREA_LEFT;
+	const int x3_100 = PLAY_AREA_RIGHT - BALLOON_WIDTH_3;
+
+	const int y2 = PLAY_AREA_TOP - BLOCK;
+	const int x2_0 = PLAY_AREA_LEFT;
+	const int x2_100 = PLAY_AREA_RIGHT - BALLOON_WIDTH_2;
+
+	const int y1 = PLAY_AREA_TOP - BLOCK;
+	const int x1_0 = PLAY_AREA_LEFT;
+	const int x1_50 = PLAY_AREA_CENTER_X - (BALLOON_WIDTH_1 / 2);
+	const int x1_100 = PLAY_AREA_RIGHT - BALLOON_WIDTH_1;
+
+	// Inicializa a cero las variables
+	for (int i = 0; i < NUMBER_OF_ENEMY_FORMATIONS; i++)
+	{
+		enemyFormation[i].numberOfEnemies = 0;
+		for (int j = 0; j < MAX_NUMBER_OF_ENEMIES_IN_A_FORMATION; j++)
+		{
+			enemyFormation[i].init[j].x = 0;
+			enemyFormation[i].init[j].y = 0;
+			enemyFormation[i].init[j].velX = 0;
+			enemyFormation[i].init[j].kind = 0;
+			enemyFormation[i].init[j].creationCounter = 0;
+		}
+	}
+
+	const int creationTime = 300;
+	int incX = 0;
+	int incTime = 0;
+	int j = 0;
+
+	// #00 - Dos enemigos BALLOON4 uno a cada extremo
+	j = 0;
+	enemyFormation[j].numberOfEnemies = 2;
+	incX = x4_100;
+	incTime = 0;
+	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
+	{
+		enemyFormation[j].init[i].x = x4_0 + (i * incX);
+		enemyFormation[j].init[i].y = y4;
+		enemyFormation[j].init[i].velX = BALLOON_VELX_NEGATIVE * (((i % 2) * 2) - 1);
+		enemyFormation[j].init[i].kind = BALLOON_4;
+		enemyFormation[j].init[i].creationCounter = creationTime + (incTime * i);
+	}
+
+	// #01 - Dos enemigos BALLOON4 uno a cada cuarto. Ambos van hacia el centro
+	j = 1;
+	enemyFormation[j].numberOfEnemies = 2;
+	incX = PLAY_AREA_CENTER_X;
+	incTime = 0;
+	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
+	{
+		enemyFormation[j].init[i].x = PLAY_AREA_CENTER_FIRST_QUARTER_X - (BALLOON_WIDTH_4 / 2) + (i * incX);
+		enemyFormation[j].init[i].y = y4;
+		enemyFormation[j].init[i].velX = BALLOON_VELX_NEGATIVE * (((i % 2) * 2) - 1);
+		enemyFormation[j].init[i].kind = BALLOON_4;
+		enemyFormation[j].init[i].creationCounter = creationTime + (incTime * i);
+	}
+
+	// #02 - Cuatro enemigos BALLOON2 uno detras del otro. A la izquierda y hacia el centro
+	j = 2;
+	enemyFormation[j].numberOfEnemies = 4;
+	incX = BALLOON_WIDTH_2 + 1;
+	incTime = 10;
+	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
+	{
+		enemyFormation[j].init[i].x = x2_0 + (i * incX);
+		enemyFormation[j].init[i].y = y2;
+		enemyFormation[j].init[i].velX = BALLOON_VELX_POSITIVE;
+		enemyFormation[j].init[i].kind = BALLOON_2;
+		enemyFormation[j].init[i].creationCounter = creationTime - (incTime * i);
+	}
+
+	// #03 - Cuatro enemigos BALLOON2 uno detras del otro. A la derecha y hacia el centro
+	j = 3;
+	enemyFormation[j].numberOfEnemies = 4;
+	incX = BALLOON_WIDTH_2 + 1;
+	incTime = 10;
+	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
+	{
+		enemyFormation[j].init[i].x = x2_100 - (i * incX);
+		enemyFormation[j].init[i].y = y2;
+		enemyFormation[j].init[i].velX = BALLOON_VELX_NEGATIVE;
+		enemyFormation[j].init[i].kind = BALLOON_2;
+		enemyFormation[j].init[i].creationCounter = creationTime - (incTime * i);
+	}
+
+	// #04 - Tres enemigos BALLOON3. 0, 25, 50. Hacia la derecha
+	j = 4;
+	enemyFormation[j].numberOfEnemies = 3;
+	incX = BALLOON_WIDTH_3 * 2;
+	incTime = 10;
+	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
+	{
+		enemyFormation[j].init[i].x = x3_0 + (i * incX);
+		enemyFormation[j].init[i].y = y3;
+		enemyFormation[j].init[i].velX = BALLOON_VELX_POSITIVE;
+		enemyFormation[j].init[i].kind = BALLOON_3;
+		enemyFormation[j].init[i].creationCounter = creationTime - (incTime * i);
+	}
+
+	// #05 - Tres enemigos BALLOON3. 50, 75, 100. Hacia la izquierda
+	j = 5;
+	enemyFormation[j].numberOfEnemies = 3;
+	incX = BALLOON_WIDTH_3 * 2;
+	incTime = 10;
+	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
+	{
+		enemyFormation[j].init[i].x = x3_100 - (i * incX);
+		enemyFormation[j].init[i].y = y3;
+		enemyFormation[j].init[i].velX = BALLOON_VELX_NEGATIVE;
+		enemyFormation[j].init[i].kind = BALLOON_3;
+		enemyFormation[j].init[i].creationCounter = creationTime - (incTime * i);
+	}
+
+	// #06 - Tres enemigos BALLOON3. 0, 0, 0. Hacia la derecha
+	j = 6;
+	enemyFormation[j].numberOfEnemies = 3;
+	incX = BALLOON_WIDTH_3 + 1;
+	incTime = 10;
+	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
+	{
+		enemyFormation[j].init[i].x = x3_0 + (i * incX);
+		enemyFormation[j].init[i].y = y3;
+		enemyFormation[j].init[i].velX = BALLOON_VELX_POSITIVE;
+		enemyFormation[j].init[i].kind = BALLOON_3;
+		enemyFormation[j].init[i].creationCounter = creationTime - (incTime * i);
+	}
+
+	// #07 - Tres enemigos BALLOON3. 100, 100, 100. Hacia la izquierda
+	j = 7;
+	enemyFormation[j].numberOfEnemies = 3;
+	incX = BALLOON_WIDTH_3 + 1;
+	incTime = 10;
+	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
+	{
+		enemyFormation[j].init[i].x = x3_100 - (i * incX);
+		enemyFormation[j].init[i].y = y3;
+		enemyFormation[j].init[i].velX = BALLOON_VELX_NEGATIVE;
+		enemyFormation[j].init[i].kind = BALLOON_3;
+		enemyFormation[j].init[i].creationCounter = creationTime - (incTime * i);
+	}
+
+	// #08 - Seis enemigos BALLOON1. 0, 0, 0, 0, 0, 0. Hacia la derecha
+	j = 8;
+	enemyFormation[j].numberOfEnemies = 6;
+	incX = BALLOON_WIDTH_1 + 1;
+	incTime = 10;
+	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
+	{
+		enemyFormation[j].init[i].x = x1_0 + (i * incX);
+		enemyFormation[j].init[i].y = 13;
+		enemyFormation[j].init[i].velX = BALLOON_VELX_POSITIVE;
+		enemyFormation[j].init[i].kind = BALLOON_1;
+		enemyFormation[j].init[i].creationCounter = creationTime - (incTime * i);
+	}
+
+	// #09 - Seis enemigos BALLOON1. 100, 100, 100, 100, 100, 100. Hacia la izquierda
+	j = 9;
+	enemyFormation[j].numberOfEnemies = 6;
+	incX = BALLOON_WIDTH_1 + 1;
+	incTime = 10;
+	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
+	{
+		enemyFormation[j].init[i].x = x1_100 - (i * incX);
+		enemyFormation[j].init[i].y = 13;
+		enemyFormation[j].init[i].velX = BALLOON_VELX_NEGATIVE;
+		enemyFormation[j].init[i].kind = BALLOON_1;
+		enemyFormation[j].init[i].creationCounter = creationTime - (incTime * i);
+	}
+
+	// #10 - Tres enemigos BALLOON4 seguidos desde la izquierda
+	j = 10;
+	enemyFormation[j].numberOfEnemies = 3;
+	incX = BALLOON_WIDTH_4 + 1;
+	incTime = 15;
+	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
+	{
+		enemyFormation[j].init[i].x = x4_0 + (i * incX);
+		enemyFormation[j].init[i].y = y4;
+		enemyFormation[j].init[i].velX = BALLOON_VELX_POSITIVE;
+		enemyFormation[j].init[i].kind = BALLOON_4;
+		enemyFormation[j].init[i].creationCounter = creationTime - (incTime * i);
+	}
+
+	// #11 - Tres enemigos BALLOON4 seguidos desde la derecha
+	j = 11;
+	enemyFormation[j].numberOfEnemies = 3;
+	incX = BALLOON_WIDTH_4 + 1;
+	incTime = 15;
+	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
+	{
+		enemyFormation[j].init[i].x = x4_100 - (i * incX);
+		enemyFormation[j].init[i].y = y4;
+		enemyFormation[j].init[i].velX = BALLOON_VELX_NEGATIVE;
+		enemyFormation[j].init[i].kind = BALLOON_4;
+		enemyFormation[j].init[i].creationCounter = creationTime - (incTime * i);
+	}
+
+	// #12 - Seis enemigos BALLOON2 uno detras del otro. A la izquierda y hacia el centro
+	j = 12;
+	enemyFormation[j].numberOfEnemies = 6;
+	incX = BALLOON_WIDTH_2 + 1;
+	incTime = 10;
+	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
+	{
+		enemyFormation[j].init[i].x = x2_0 + (i * incX);
+		enemyFormation[j].init[i].y = y2;
+		enemyFormation[j].init[i].velX = BALLOON_VELX_POSITIVE;
+		enemyFormation[j].init[i].kind = BALLOON_2;
+		enemyFormation[j].init[i].creationCounter = creationTime - (incTime * i);
+	}
+
+	// #13 - Seis enemigos BALLOON2 uno detras del otro. A la derecha y hacia el centro
+	j = 13;
+	enemyFormation[j].numberOfEnemies = 6;
+	incX = BALLOON_WIDTH_2 + 1;
+	incTime = 10;
+	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
+	{
+		enemyFormation[j].init[i].x = x2_100 - (i * incX);
+		enemyFormation[j].init[i].y = y2;
+		enemyFormation[j].init[i].velX = BALLOON_VELX_NEGATIVE;
+		enemyFormation[j].init[i].kind = BALLOON_2;
+		enemyFormation[j].init[i].creationCounter = creationTime - (incTime * i);
+	}
+
+	// #14 - Cinco enemigos BALLOON3. Hacia la derecha. Separados
+	j = 14;
+	enemyFormation[j].numberOfEnemies = 5;
+	incX = BALLOON_WIDTH_3 * 2;
+	incTime = 10;
+	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
+	{
+		enemyFormation[j].init[i].x = x3_0 + (i * incX);
+		enemyFormation[j].init[i].y = y3;
+		enemyFormation[j].init[i].velX = BALLOON_VELX_POSITIVE;
+		enemyFormation[j].init[i].kind = BALLOON_3;
+		enemyFormation[j].init[i].creationCounter = creationTime - (incTime * i);
+	}
+
+	// #15 - Cinco enemigos BALLOON3. Hacia la izquierda. Separados
+	j = 15;
+	enemyFormation[j].numberOfEnemies = 5;
+	incX = BALLOON_WIDTH_3 * 2;
+	incTime = 10;
+	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
+	{
+		enemyFormation[j].init[i].x = x3_100 - (i * incX);
+		enemyFormation[j].init[i].y = y3;
+		enemyFormation[j].init[i].velX = BALLOON_VELX_NEGATIVE;
+		enemyFormation[j].init[i].kind = BALLOON_3;
+		enemyFormation[j].init[i].creationCounter = creationTime - (incTime * i);
+	}
+
+	// #16 - Cinco enemigos BALLOON3. Hacia la derecha. Juntos
+	j = 16;
+	enemyFormation[j].numberOfEnemies = 5;
+	incX = BALLOON_WIDTH_3 + 1;
+	incTime = 10;
+	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
+	{
+		enemyFormation[j].init[i].x = x3_0 + (i * incX);
+		enemyFormation[j].init[i].y = y3;
+		enemyFormation[j].init[i].velX = BALLOON_VELX_POSITIVE;
+		enemyFormation[j].init[i].kind = BALLOON_3;
+		enemyFormation[j].init[i].creationCounter = creationTime - (incTime * i);
+	}
+
+	// #17 - Cinco enemigos BALLOON3. Hacia la izquierda. Juntos
+	j = 17;
+	enemyFormation[j].numberOfEnemies = 5;
+	incX = BALLOON_WIDTH_3 + 1;
+	incTime = 10;
+	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
+	{
+		enemyFormation[j].init[i].x = x3_100 - (i * incX);
+		enemyFormation[j].init[i].y = y3;
+		enemyFormation[j].init[i].velX = BALLOON_VELX_NEGATIVE;
+		enemyFormation[j].init[i].kind = BALLOON_3;
+		enemyFormation[j].init[i].creationCounter = creationTime - (incTime * i);
+	}
+
+	// #18 - Doce enemigos BALLOON1. Hacia la derecha. Juntos
+	j = 18;
+	enemyFormation[j].numberOfEnemies = 12;
+	incX = BALLOON_WIDTH_1 + 1;
+	incTime = 10;
+	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
+	{
+		enemyFormation[j].init[i].x = x1_0 + (i * incX);
+		enemyFormation[j].init[i].y = y1;
+		enemyFormation[j].init[i].velX = BALLOON_VELX_POSITIVE;
+		enemyFormation[j].init[i].kind = BALLOON_1;
+		enemyFormation[j].init[i].creationCounter = creationTime - (incTime * i);
+	}
+
+	// #19 - Doce enemigos BALLOON1. Hacia la izquierda. Juntos
+	j = 19;
+	enemyFormation[j].numberOfEnemies = 12;
+	incX = BALLOON_WIDTH_1 + 1;
+	incTime = 10;
+	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
+	{
+		enemyFormation[j].init[i].x = x1_100 - (i * incX);
+		enemyFormation[j].init[i].y = y1;
+		enemyFormation[j].init[i].velX = BALLOON_VELX_NEGATIVE;
+		enemyFormation[j].init[i].kind = BALLOON_1;
+		enemyFormation[j].init[i].creationCounter = creationTime - (incTime * i);
+	}
+
+	// #20 - Dos enemigos BALLOON4 seguidos desde la izquierda/derecha. Simetricos
+	j = 20;
+	enemyFormation[j].numberOfEnemies = 4;
+	incX = BALLOON_WIDTH_4 + 1;
+	incTime = 0;
+	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
+	{
+		const int half = enemyFormation[j].numberOfEnemies / 2;
+		if (i < half)
+		{
+			enemyFormation[j].init[i].x = x4_0 + (i * incX);
+			enemyFormation[j].init[i].velX = BALLOON_VELX_POSITIVE;
+		}
+		else
+		{
+			enemyFormation[j].init[i].x = x4_100 - ((i - half) * incX);
+			enemyFormation[j].init[i].velX = BALLOON_VELX_NEGATIVE;
+		}
+		enemyFormation[j].init[i].y = y4;
+		enemyFormation[j].init[i].kind = BALLOON_4;
+		enemyFormation[j].init[i].creationCounter = creationTime + (incTime * i);
+	}
+
+	// #21 - Diez enemigos BALLOON2 uno detras del otro. Izquierda/derecha. Simetricos
+	j = 21;
+	enemyFormation[j].numberOfEnemies = 10;
+	incX = BALLOON_WIDTH_2 + 1;
+	incTime = 3;
+	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
+	{
+		const int half = enemyFormation[j].numberOfEnemies / 2;
+		if (i < half)
+		{
+			enemyFormation[j].init[i].x = x2_0 + (i * incX);
+			enemyFormation[j].init[i].velX = BALLOON_VELX_POSITIVE;
+			enemyFormation[j].init[i].creationCounter = (creationTime) - (incTime * i);
+		}
+		else
+		{
+			enemyFormation[j].init[i].x = x2_100 - ((i - half) * incX);
+			enemyFormation[j].init[i].velX = BALLOON_VELX_NEGATIVE;
+			enemyFormation[j].init[i].creationCounter = (creationTime) - (incTime * (i - half));
+		}
+		enemyFormation[j].init[i].y = y2;
+		enemyFormation[j].init[i].kind = BALLOON_2;
+	}
+
+	// #22 - Diez enemigos BALLOON3. Hacia la derecha/izquierda. Separados. Simetricos
+	j = 22;
+	enemyFormation[j].numberOfEnemies = 10;
+	incX = BALLOON_WIDTH_3 * 2;
+	incTime = 10;
+	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
+	{
+		const int half = enemyFormation[j].numberOfEnemies / 2;
+		if (i < half)
+		{
+			enemyFormation[j].init[i].x = x3_0 + (i * incX);
+			enemyFormation[j].init[i].velX = BALLOON_VELX_POSITIVE;
+			enemyFormation[j].init[i].creationCounter = (creationTime) - (incTime * i);
+		}
+		else
+		{
+			enemyFormation[j].init[i].x = x3_100 - ((i - half) * incX);
+			enemyFormation[j].init[i].velX = BALLOON_VELX_NEGATIVE;
+			enemyFormation[j].init[i].creationCounter = (creationTime) - (incTime * (i - half));
+		}
+		enemyFormation[j].init[i].y = y3;
+		enemyFormation[j].init[i].kind = BALLOON_3;
+	}
+
+	// #23 - Diez enemigos BALLOON3. Hacia la derecha. Juntos. Simetricos
+	j = 23;
+	enemyFormation[j].numberOfEnemies = 10;
+	incX = BALLOON_WIDTH_3 + 1;
+	incTime = 10;
+	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
+	{
+		const int half = enemyFormation[j].numberOfEnemies / 2;
+		if (i < half)
+		{
+			enemyFormation[j].init[i].x = x3_0 + (i * incX);
+			enemyFormation[j].init[i].velX = BALLOON_VELX_POSITIVE;
+			enemyFormation[j].init[i].creationCounter = (creationTime) - (incTime * i);
+		}
+		else
+		{
+			enemyFormation[j].init[i].x = x3_100 - ((i - half) * incX);
+			enemyFormation[j].init[i].velX = BALLOON_VELX_NEGATIVE;
+			enemyFormation[j].init[i].creationCounter = (creationTime) - (incTime * (i - half));
+		}
+		enemyFormation[j].init[i].y = y3;
+		enemyFormation[j].init[i].kind = BALLOON_3;
+	}
+
+	// #24 - Treinta enemigos BALLOON1. Del centro hacia los extremos. Juntos. Simetricos
+	j = 24;
+	enemyFormation[j].numberOfEnemies = 30;
+	incX = 0;
+	incTime = 5;
+	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
+	{
+		const int half = enemyFormation[j].numberOfEnemies / 2;
+		if (i < half)
+		{
+			enemyFormation[j].init[i].x = x1_50;
+			enemyFormation[j].init[i].velX = BALLOON_VELX_POSITIVE;
+			enemyFormation[j].init[i].creationCounter = (creationTime) + (incTime * i);
+		}
+		else
+		{
+			enemyFormation[j].init[i].x = x1_50;
+			enemyFormation[j].init[i].velX = BALLOON_VELX_NEGATIVE;
+			enemyFormation[j].init[i].creationCounter = (creationTime) + (incTime * (i - half));
+		}
+		enemyFormation[j].init[i].y = y1;
+		enemyFormation[j].init[i].kind = BALLOON_1;
+	}
+
+	// #25 - Treinta enemigos BALLOON1. Del centro hacia adentro. Juntos. Simetricos
+	j = 25;
+	enemyFormation[j].numberOfEnemies = 30;
+	incX = BALLOON_WIDTH_1 + 1;
+	incTime = 5;
+	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
+	{
+		const int half = enemyFormation[j].numberOfEnemies / 2;
+		if (i < half)
+		{
+			enemyFormation[j].init[i].x = x1_50 + 20;
+			enemyFormation[j].init[i].velX = BALLOON_VELX_NEGATIVE;
+			enemyFormation[j].init[i].creationCounter = (creationTime) - (incTime * i);
+		}
+		else
+		{
+			enemyFormation[j].init[i].x = x1_50 - 20;
+			enemyFormation[j].init[i].velX = BALLOON_VELX_POSITIVE;
+			enemyFormation[j].init[i].creationCounter = (creationTime) - (incTime * (i - half));
+		}
+		enemyFormation[j].init[i].y = y1;
+		enemyFormation[j].init[i].kind = BALLOON_1;
+	}
+
+	// Crea las mismas formaciones pero con hexagonos a partir de la posición 50 del vector
+	for (int k = 0; k < j + 1; k++)
+	{
+		enemyFormation[k + 50].numberOfEnemies = enemyFormation[k].numberOfEnemies;
+		for (int i = 0; i < enemyFormation[k + 50].numberOfEnemies; i++)
+		{
+			enemyFormation[k + 50].init[i].x = enemyFormation[k].init[i].x;
+			enemyFormation[k + 50].init[i].y = enemyFormation[k].init[i].y;
+			enemyFormation[k + 50].init[i].velX = enemyFormation[k].init[i].velX;
+			enemyFormation[k + 50].init[i].creationCounter = enemyFormation[k].init[i].creationCounter;
+			enemyFormation[k + 50].init[i].kind = enemyFormation[k].init[i].kind + 4;
+		}
+	}
+
+	// TEST
+	enemyFormation[99].numberOfEnemies = 4;
+
+	enemyFormation[99].init[0].x = 10;
+	enemyFormation[99].init[0].y = y1;
+	enemyFormation[99].init[0].velX = 0;
+	enemyFormation[99].init[0].kind = BALLOON_1;
+	enemyFormation[99].init[0].creationCounter = 200;
+
+	enemyFormation[99].init[1].x = 50;
+	enemyFormation[99].init[1].y = y1;
+	enemyFormation[99].init[1].velX = 0;
+	enemyFormation[99].init[1].kind = BALLOON_2;
+	enemyFormation[99].init[1].creationCounter = 200;
+
+	enemyFormation[99].init[2].x = 90;
+	enemyFormation[99].init[2].y = y1;
+	enemyFormation[99].init[2].velX = 0;
+	enemyFormation[99].init[2].kind = BALLOON_3;
+	enemyFormation[99].init[2].creationCounter = 200;
+
+	enemyFormation[99].init[3].x = 140;
+	enemyFormation[99].init[3].y = y1;
+	enemyFormation[99].init[3].velX = 0;
+	enemyFormation[99].init[3].kind = BALLOON_4;
+	enemyFormation[99].init[3].creationCounter = 200;
+}
+
+// Inicializa los conjuntos de formaciones
+void EnemyFormations::initEnemyPools()
+{
+	// EnemyPool #0
+	enemyPool[0].set[0] = &enemyFormation[0];
+	enemyPool[0].set[1] = &enemyFormation[1];
+	enemyPool[0].set[2] = &enemyFormation[2];
+	enemyPool[0].set[3] = &enemyFormation[3];
+	enemyPool[0].set[4] = &enemyFormation[4];
+	enemyPool[0].set[5] = &enemyFormation[5];
+	enemyPool[0].set[6] = &enemyFormation[6];
+	enemyPool[0].set[7] = &enemyFormation[7];
+	enemyPool[0].set[8] = &enemyFormation[8];
+	enemyPool[0].set[9] = &enemyFormation[9];
+
+	// EnemyPool #1
+	enemyPool[1].set[0] = &enemyFormation[10];
+	enemyPool[1].set[1] = &enemyFormation[11];
+	enemyPool[1].set[2] = &enemyFormation[12];
+	enemyPool[1].set[3] = &enemyFormation[13];
+	enemyPool[1].set[4] = &enemyFormation[14];
+	enemyPool[1].set[5] = &enemyFormation[15];
+	enemyPool[1].set[6] = &enemyFormation[16];
+	enemyPool[1].set[7] = &enemyFormation[17];
+	enemyPool[1].set[8] = &enemyFormation[18];
+	enemyPool[1].set[9] = &enemyFormation[19];
+
+	// EnemyPool #2
+	enemyPool[2].set[0] = &enemyFormation[0];
+	enemyPool[2].set[1] = &enemyFormation[1];
+	enemyPool[2].set[2] = &enemyFormation[2];
+	enemyPool[2].set[3] = &enemyFormation[3];
+	enemyPool[2].set[4] = &enemyFormation[4];
+	enemyPool[2].set[5] = &enemyFormation[55];
+	enemyPool[2].set[6] = &enemyFormation[56];
+	enemyPool[2].set[7] = &enemyFormation[57];
+	enemyPool[2].set[8] = &enemyFormation[58];
+	enemyPool[2].set[9] = &enemyFormation[59];
+
+	// EnemyPool #3
+	enemyPool[3].set[0] = &enemyFormation[50];
+	enemyPool[3].set[1] = &enemyFormation[51];
+	enemyPool[3].set[2] = &enemyFormation[52];
+	enemyPool[3].set[3] = &enemyFormation[53];
+	enemyPool[3].set[4] = &enemyFormation[54];
+	enemyPool[3].set[5] = &enemyFormation[5];
+	enemyPool[3].set[6] = &enemyFormation[6];
+	enemyPool[3].set[7] = &enemyFormation[7];
+	enemyPool[3].set[8] = &enemyFormation[8];
+	enemyPool[3].set[9] = &enemyFormation[9];
+
+	// EnemyPool #4
+	enemyPool[4].set[0] = &enemyFormation[60];
+	enemyPool[4].set[1] = &enemyFormation[61];
+	enemyPool[4].set[2] = &enemyFormation[62];
+	enemyPool[4].set[3] = &enemyFormation[63];
+	enemyPool[4].set[4] = &enemyFormation[64];
+	enemyPool[4].set[5] = &enemyFormation[65];
+	enemyPool[4].set[6] = &enemyFormation[66];
+	enemyPool[4].set[7] = &enemyFormation[67];
+	enemyPool[4].set[8] = &enemyFormation[68];
+	enemyPool[4].set[9] = &enemyFormation[69];
+
+	// EnemyPool #5
+	enemyPool[5].set[0] = &enemyFormation[10];
+	enemyPool[5].set[1] = &enemyFormation[61];
+	enemyPool[5].set[2] = &enemyFormation[12];
+	enemyPool[5].set[3] = &enemyFormation[63];
+	enemyPool[5].set[4] = &enemyFormation[14];
+	enemyPool[5].set[5] = &enemyFormation[65];
+	enemyPool[5].set[6] = &enemyFormation[16];
+	enemyPool[5].set[7] = &enemyFormation[67];
+	enemyPool[5].set[8] = &enemyFormation[18];
+	enemyPool[5].set[9] = &enemyFormation[69];
+
+	// EnemyPool #6
+	enemyPool[6].set[0] = &enemyFormation[60];
+	enemyPool[6].set[1] = &enemyFormation[11];
+	enemyPool[6].set[2] = &enemyFormation[62];
+	enemyPool[6].set[3] = &enemyFormation[13];
+	enemyPool[6].set[4] = &enemyFormation[64];
+	enemyPool[6].set[5] = &enemyFormation[15];
+	enemyPool[6].set[6] = &enemyFormation[66];
+	enemyPool[6].set[7] = &enemyFormation[17];
+	enemyPool[6].set[8] = &enemyFormation[68];
+	enemyPool[6].set[9] = &enemyFormation[19];
+
+	// EnemyPool #7
+	enemyPool[7].set[0] = &enemyFormation[20];
+	enemyPool[7].set[1] = &enemyFormation[21];
+	enemyPool[7].set[2] = &enemyFormation[22];
+	enemyPool[7].set[3] = &enemyFormation[23];
+	enemyPool[7].set[4] = &enemyFormation[24];
+	enemyPool[7].set[5] = &enemyFormation[65];
+	enemyPool[7].set[6] = &enemyFormation[66];
+	enemyPool[7].set[7] = &enemyFormation[67];
+	enemyPool[7].set[8] = &enemyFormation[68];
+	enemyPool[7].set[9] = &enemyFormation[69];
+
+	// EnemyPool #8
+	enemyPool[8].set[0] = &enemyFormation[70];
+	enemyPool[8].set[1] = &enemyFormation[71];
+	enemyPool[8].set[2] = &enemyFormation[72];
+	enemyPool[8].set[3] = &enemyFormation[73];
+	enemyPool[8].set[4] = &enemyFormation[74];
+	enemyPool[8].set[5] = &enemyFormation[15];
+	enemyPool[8].set[6] = &enemyFormation[16];
+	enemyPool[8].set[7] = &enemyFormation[17];
+	enemyPool[8].set[8] = &enemyFormation[18];
+	enemyPool[8].set[9] = &enemyFormation[19];
+
+	// EnemyPool #9
+	enemyPool[9].set[0] = &enemyFormation[20];
+	enemyPool[9].set[1] = &enemyFormation[21];
+	enemyPool[9].set[2] = &enemyFormation[22];
+	enemyPool[9].set[3] = &enemyFormation[23];
+	enemyPool[9].set[4] = &enemyFormation[24];
+	enemyPool[9].set[5] = &enemyFormation[70];
+	enemyPool[9].set[6] = &enemyFormation[71];
+	enemyPool[9].set[7] = &enemyFormation[72];
+	enemyPool[9].set[8] = &enemyFormation[73];
+	enemyPool[9].set[9] = &enemyFormation[74];
+}
+
+// Inicializa las fases del juego
+void EnemyFormations::initGameStages()
+{
+	// STAGE 1
+	stage[0].number = 1;
+	stage[0].powerToComplete = 200;
+	stage[0].minMenace = 7 + (4 * 1);
+	stage[0].maxMenace = 7 + (4 * 3);
+	stage[0].enemyPool = &enemyPool[0];
+
+	// STAGE 2
+	stage[1].number = 2;
+	stage[1].powerToComplete = 300;
+	stage[1].minMenace = 7 + (4 * 2);
+	stage[1].maxMenace = 7 + (4 * 4);
+	stage[1].enemyPool = &enemyPool[1];
+
+	// STAGE 3
+	stage[2].number = 3;
+	stage[2].powerToComplete = 600;
+	stage[2].minMenace = 7 + (4 * 3);
+	stage[2].maxMenace = 7 + (4 * 5);
+	stage[2].enemyPool = &enemyPool[2];
+
+	// STAGE 4
+	stage[3].number = 4;
+	stage[3].powerToComplete = 600;
+	stage[3].minMenace = 7 + (4 * 3);
+	stage[3].maxMenace = 7 + (4 * 5);
+	stage[3].enemyPool = &enemyPool[3];
+
+	// STAGE 5
+	stage[4].number = 5;
+	stage[4].powerToComplete = 600;
+	stage[4].minMenace = 7 + (4 * 4);
+	stage[4].maxMenace = 7 + (4 * 6);
+	stage[4].enemyPool = &enemyPool[4];
+
+	// STAGE 6
+	stage[5].number = 6;
+	stage[5].powerToComplete = 600;
+	stage[5].minMenace = 7 + (4 * 4);
+	stage[5].maxMenace = 7 + (4 * 6);
+	stage[5].enemyPool = &enemyPool[5];
+
+	// STAGE 7
+	stage[6].number = 7;
+	stage[6].powerToComplete = 650;
+	stage[6].minMenace = 7 + (4 * 5);
+	stage[6].maxMenace = 7 + (4 * 7);
+	stage[6].enemyPool = &enemyPool[6];
+
+	// STAGE 8
+	stage[7].number = 8;
+	stage[7].powerToComplete = 750;
+	stage[7].minMenace = 7 + (4 * 5);
+	stage[7].maxMenace = 7 + (4 * 7);
+	stage[7].enemyPool = &enemyPool[7];
+
+	// STAGE 9
+	stage[8].number = 9;
+	stage[8].powerToComplete = 850;
+	stage[8].minMenace = 7 + (4 * 6);
+	stage[8].maxMenace = 7 + (4 * 8);
+	stage[8].enemyPool = &enemyPool[8];
+
+	// STAGE 10
+	stage[9].number = 10;
+	stage[9].powerToComplete = 950;
+	stage[9].minMenace = 7 + (4 * 7);
+	stage[9].maxMenace = 7 + (4 * 10);
+	stage[9].enemyPool = &enemyPool[9];
+}
+
+// Devuelve una fase
+stage_t EnemyFormations::getStage(int index)
+{
+	return stage[index];
+}
\ No newline at end of file
diff --git a/source/enemy_formations.h b/source/enemy_formations.h
new file mode 100644
index 0000000..7b1e521
--- /dev/null
+++ b/source/enemy_formations.h
@@ -0,0 +1,68 @@
+#pragma once
+
+#include <SDL2/SDL.h>
+#include "common/utils.h"
+#include "const.h"
+#include "balloon.h"
+
+#define NUMBER_OF_ENEMY_FORMATIONS 100
+#define MAX_NUMBER_OF_ENEMIES_IN_A_FORMATION 50
+
+// Estructuras
+struct enemyInits_t
+{
+    int x;               // Posición en el eje X donde crear al enemigo
+    int y;               // Posición en el eje Y donde crear al enemigo
+    float velX;          // Velocidad inicial en el eje X
+    int kind;            // Tipo de enemigo
+    int creationCounter; // Temporizador para la creación del enemigo
+};
+
+struct enemyFormation_t // Contiene la información de una formación enemiga
+{
+    int numberOfEnemies;                                     // Cantidad de enemigos que forman la formación
+    enemyInits_t init[MAX_NUMBER_OF_ENEMIES_IN_A_FORMATION]; // Vector con todas las inicializaciones de los enemigos de la formación
+};
+
+struct enemyPool_t
+{
+    enemyFormation_t *set[10]; // Conjunto de formaciones enemigas
+};
+
+struct stage_t // Contiene todas las variables relacionadas con una fase
+{
+    enemyPool_t *enemyPool; // El conjunto de formaciones enemigas de la fase
+    int powerToComplete;    // Cantidad de poder que se necesita para completar la fase
+    int maxMenace;          // Umbral máximo de amenaza de la fase
+    int minMenace;          // Umbral mínimo de amenaza de la fase
+    int number;             // Número de fase
+};
+
+// Clase EnemyFormations, para gestionar las formaciones enemigas
+class EnemyFormations
+{
+private:
+    // Variables
+    stage_t stage[10];                                           // Variable con los datos de cada pantalla
+    enemyFormation_t enemyFormation[NUMBER_OF_ENEMY_FORMATIONS]; // Vector con todas las formaciones enemigas
+    enemyPool_t enemyPool[10];                                   // Variable con los diferentes conjuntos de formaciones enemigas
+
+    // Inicializa las formaciones enemigas
+    void initEnemyFormations();
+
+    // Inicializa los conjuntos de formaciones
+    void initEnemyPools();
+
+    // Inicializa las fases del juego
+    void initGameStages();
+
+public:
+    // Constructor
+    EnemyFormations();
+
+    // Destructor
+    ~EnemyFormations();
+
+    // Devuelve una fase
+    stage_t getStage(int index);
+};
\ No newline at end of file
diff --git a/source/game.cpp b/source/game.cpp
index 3c48ed4..6366b00 100644
--- a/source/game.cpp
+++ b/source/game.cpp
@@ -28,6 +28,7 @@ Game::Game(int playerID, int currentStage, SDL_Renderer *renderer, Screen *scree
 	scoreboard = new Scoreboard(renderer, screen, asset, lang, options);
 	background = new Background(renderer, screen, asset, param);
 	explosions = new Explosions();
+	enemyFormations = new EnemyFormations();
 
 	// Carga los recursos
 	loadMedia();
@@ -77,6 +78,7 @@ Game::~Game()
 	delete scoreboard;
 	delete background;
 	delete explosions;
+	delete enemyFormations;
 
 	delete fade;
 	delete eventHandler;
@@ -228,21 +230,18 @@ void Game::init(int playerID)
 	}
 
 	initPaths();
-	initEnemyFormations();
-	initEnemyPools();
-	initGameStages();
 
-	// Mas variables
+	// En caso de continuar o empezar en una fase que no sea la primera, actualiza las variables siguientes
 	balloonsPopped = 0;
 	for (int i = 0; i < currentStage; ++i)
 	{
-		balloonsPopped += stage[i].powerToComplete;
+		balloonsPopped += enemyFormations->getStage(i).powerToComplete;
 	}
 
 	totalPowerToCompleteGame = 0;
 	for (int i = 0; i < 10; ++i)
 	{
-		totalPowerToCompleteGame += stage[i].powerToComplete;
+		totalPowerToCompleteGame += enemyFormations->getStage(i).powerToComplete;
 	}
 
 	// Modo grabar demo
@@ -869,718 +868,6 @@ bool Game::saveDemoFile()
 }
 #endif
 
-// Inicializa las formaciones enemigas
-void Game::initEnemyFormations()
-{
-	const int y4 = (PLAY_AREA_TOP - BLOCK);
-	const int x4_0 = PLAY_AREA_LEFT;
-	const int x4_100 = (PLAY_AREA_RIGHT)-BALLOON_WIDTH_4;
-
-	const int y3 = (PLAY_AREA_TOP - BLOCK);
-	const int x3_0 = PLAY_AREA_LEFT;
-	const int x3_100 = (PLAY_AREA_RIGHT)-BALLOON_WIDTH_3;
-
-	const int y2 = (PLAY_AREA_TOP - BLOCK);
-	const int x2_0 = PLAY_AREA_LEFT;
-	const int x2_100 = (PLAY_AREA_RIGHT)-BALLOON_WIDTH_2;
-
-	const int y1 = (PLAY_AREA_TOP - BLOCK);
-	const int x1_0 = PLAY_AREA_LEFT;
-	const int x1_50 = PLAY_AREA_CENTER_X - (BALLOON_WIDTH_1 / 2);
-	const int x1_100 = (PLAY_AREA_RIGHT)-BALLOON_WIDTH_1;
-
-	// Inicializa a cero las variables
-	for (int i = 0; i < NUMBER_OF_ENEMY_FORMATIONS; i++)
-	{
-		enemyFormation[i].numberOfEnemies = 0;
-		for (int j = 0; j < MAX_NUMBER_OF_ENEMIES_IN_A_FORMATION; j++)
-		{
-			enemyFormation[i].init[j].x = 0;
-			enemyFormation[i].init[j].y = 0;
-			enemyFormation[i].init[j].velX = 0;
-			enemyFormation[i].init[j].kind = 0;
-			enemyFormation[i].init[j].creationCounter = 0;
-		}
-	}
-
-	const int creationTime = 300;
-	int incX = 0;
-	int incTime = 0;
-	int j = 0;
-
-	// #00 - Dos enemigos BALLOON4 uno a cada extremo
-	j = 0;
-	enemyFormation[j].numberOfEnemies = 2;
-	incX = x4_100;
-	incTime = 0;
-	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
-	{
-		enemyFormation[j].init[i].x = x4_0 + (i * incX);
-		enemyFormation[j].init[i].y = y4;
-		enemyFormation[j].init[i].velX = BALLOON_VELX_NEGATIVE * (((i % 2) * 2) - 1);
-		enemyFormation[j].init[i].kind = BALLOON_4;
-		enemyFormation[j].init[i].creationCounter = creationTime + (incTime * i);
-	}
-
-	// #01 - Dos enemigos BALLOON4 uno a cada cuarto. Ambos van hacia el centro
-	j = 1;
-	enemyFormation[j].numberOfEnemies = 2;
-	incX = PLAY_AREA_CENTER_X;
-	incTime = 0;
-	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
-	{
-		enemyFormation[j].init[i].x = PLAY_AREA_CENTER_FIRST_QUARTER_X - (BALLOON_WIDTH_4 / 2) + (i * incX);
-		enemyFormation[j].init[i].y = y4;
-		enemyFormation[j].init[i].velX = BALLOON_VELX_NEGATIVE * (((i % 2) * 2) - 1);
-		enemyFormation[j].init[i].kind = BALLOON_4;
-		enemyFormation[j].init[i].creationCounter = creationTime + (incTime * i);
-	}
-
-	// #02 - Cuatro enemigos BALLOON2 uno detras del otro. A la izquierda y hacia el centro
-	j = 2;
-	enemyFormation[j].numberOfEnemies = 4;
-	incX = BALLOON_WIDTH_2 + 1;
-	incTime = 10;
-	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
-	{
-		enemyFormation[j].init[i].x = x2_0 + (i * incX);
-		enemyFormation[j].init[i].y = y2;
-		enemyFormation[j].init[i].velX = BALLOON_VELX_POSITIVE;
-		enemyFormation[j].init[i].kind = BALLOON_2;
-		enemyFormation[j].init[i].creationCounter = creationTime - (incTime * i);
-	}
-
-	// #03 - Cuatro enemigos BALLOON2 uno detras del otro. A la derecha y hacia el centro
-	j = 3;
-	enemyFormation[j].numberOfEnemies = 4;
-	incX = BALLOON_WIDTH_2 + 1;
-	incTime = 10;
-	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
-	{
-		enemyFormation[j].init[i].x = x2_100 - (i * incX);
-		enemyFormation[j].init[i].y = y2;
-		enemyFormation[j].init[i].velX = BALLOON_VELX_NEGATIVE;
-		enemyFormation[j].init[i].kind = BALLOON_2;
-		enemyFormation[j].init[i].creationCounter = creationTime - (incTime * i);
-	}
-
-	// #04 - Tres enemigos BALLOON3. 0, 25, 50. Hacia la derecha
-	j = 4;
-	enemyFormation[j].numberOfEnemies = 3;
-	incX = BALLOON_WIDTH_3 * 2;
-	incTime = 10;
-	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
-	{
-		enemyFormation[j].init[i].x = x3_0 + (i * incX);
-		enemyFormation[j].init[i].y = y3;
-		enemyFormation[j].init[i].velX = BALLOON_VELX_POSITIVE;
-		enemyFormation[j].init[i].kind = BALLOON_3;
-		enemyFormation[j].init[i].creationCounter = creationTime - (incTime * i);
-	}
-
-	// #05 - Tres enemigos BALLOON3. 50, 75, 100. Hacia la izquierda
-	j = 5;
-	enemyFormation[j].numberOfEnemies = 3;
-	incX = BALLOON_WIDTH_3 * 2;
-	incTime = 10;
-	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
-	{
-		enemyFormation[j].init[i].x = x3_100 - (i * incX);
-		enemyFormation[j].init[i].y = y3;
-		enemyFormation[j].init[i].velX = BALLOON_VELX_NEGATIVE;
-		enemyFormation[j].init[i].kind = BALLOON_3;
-		enemyFormation[j].init[i].creationCounter = creationTime - (incTime * i);
-	}
-
-	// #06 - Tres enemigos BALLOON3. 0, 0, 0. Hacia la derecha
-	j = 6;
-	enemyFormation[j].numberOfEnemies = 3;
-	incX = BALLOON_WIDTH_3 + 1;
-	incTime = 10;
-	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
-	{
-		enemyFormation[j].init[i].x = x3_0 + (i * incX);
-		enemyFormation[j].init[i].y = y3;
-		enemyFormation[j].init[i].velX = BALLOON_VELX_POSITIVE;
-		enemyFormation[j].init[i].kind = BALLOON_3;
-		enemyFormation[j].init[i].creationCounter = creationTime - (incTime * i);
-	}
-
-	// #07 - Tres enemigos BALLOON3. 100, 100, 100. Hacia la izquierda
-	j = 7;
-	enemyFormation[j].numberOfEnemies = 3;
-	incX = BALLOON_WIDTH_3 + 1;
-	incTime = 10;
-	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
-	{
-		enemyFormation[j].init[i].x = x3_100 - (i * incX);
-		enemyFormation[j].init[i].y = y3;
-		enemyFormation[j].init[i].velX = BALLOON_VELX_NEGATIVE;
-		enemyFormation[j].init[i].kind = BALLOON_3;
-		enemyFormation[j].init[i].creationCounter = creationTime - (incTime * i);
-	}
-
-	// #08 - Seis enemigos BALLOON1. 0, 0, 0, 0, 0, 0. Hacia la derecha
-	j = 8;
-	enemyFormation[j].numberOfEnemies = 6;
-	incX = BALLOON_WIDTH_1 + 1;
-	incTime = 10;
-	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
-	{
-		enemyFormation[j].init[i].x = x1_0 + (i * incX);
-		enemyFormation[j].init[i].y = 13;
-		enemyFormation[j].init[i].velX = BALLOON_VELX_POSITIVE;
-		enemyFormation[j].init[i].kind = BALLOON_1;
-		enemyFormation[j].init[i].creationCounter = creationTime - (incTime * i);
-	}
-
-	// #09 - Seis enemigos BALLOON1. 100, 100, 100, 100, 100, 100. Hacia la izquierda
-	j = 9;
-	enemyFormation[j].numberOfEnemies = 6;
-	incX = BALLOON_WIDTH_1 + 1;
-	incTime = 10;
-	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
-	{
-		enemyFormation[j].init[i].x = x1_100 - (i * incX);
-		enemyFormation[j].init[i].y = 13;
-		enemyFormation[j].init[i].velX = BALLOON_VELX_NEGATIVE;
-		enemyFormation[j].init[i].kind = BALLOON_1;
-		enemyFormation[j].init[i].creationCounter = creationTime - (incTime * i);
-	}
-
-	// #10 - Tres enemigos BALLOON4 seguidos desde la izquierda
-	j = 10;
-	enemyFormation[j].numberOfEnemies = 3;
-	incX = BALLOON_WIDTH_4 + 1;
-	incTime = 15;
-	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
-	{
-		enemyFormation[j].init[i].x = x4_0 + (i * incX);
-		enemyFormation[j].init[i].y = y4;
-		enemyFormation[j].init[i].velX = BALLOON_VELX_POSITIVE;
-		enemyFormation[j].init[i].kind = BALLOON_4;
-		enemyFormation[j].init[i].creationCounter = creationTime - (incTime * i);
-	}
-
-	// #11 - Tres enemigos BALLOON4 seguidos desde la derecha
-	j = 11;
-	enemyFormation[j].numberOfEnemies = 3;
-	incX = BALLOON_WIDTH_4 + 1;
-	incTime = 15;
-	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
-	{
-		enemyFormation[j].init[i].x = x4_100 - (i * incX);
-		enemyFormation[j].init[i].y = y4;
-		enemyFormation[j].init[i].velX = BALLOON_VELX_NEGATIVE;
-		enemyFormation[j].init[i].kind = BALLOON_4;
-		enemyFormation[j].init[i].creationCounter = creationTime - (incTime * i);
-	}
-
-	// #12 - Seis enemigos BALLOON2 uno detras del otro. A la izquierda y hacia el centro
-	j = 12;
-	enemyFormation[j].numberOfEnemies = 6;
-	incX = BALLOON_WIDTH_2 + 1;
-	incTime = 10;
-	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
-	{
-		enemyFormation[j].init[i].x = x2_0 + (i * incX);
-		enemyFormation[j].init[i].y = y2;
-		enemyFormation[j].init[i].velX = BALLOON_VELX_POSITIVE;
-		enemyFormation[j].init[i].kind = BALLOON_2;
-		enemyFormation[j].init[i].creationCounter = creationTime - (incTime * i);
-	}
-
-	// #13 - Seis enemigos BALLOON2 uno detras del otro. A la derecha y hacia el centro
-	j = 13;
-	enemyFormation[j].numberOfEnemies = 6;
-	incX = BALLOON_WIDTH_2 + 1;
-	incTime = 10;
-	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
-	{
-		enemyFormation[j].init[i].x = x2_100 - (i * incX);
-		enemyFormation[j].init[i].y = y2;
-		enemyFormation[j].init[i].velX = BALLOON_VELX_NEGATIVE;
-		enemyFormation[j].init[i].kind = BALLOON_2;
-		enemyFormation[j].init[i].creationCounter = creationTime - (incTime * i);
-	}
-
-	// #14 - Cinco enemigos BALLOON3. Hacia la derecha. Separados
-	j = 14;
-	enemyFormation[j].numberOfEnemies = 5;
-	incX = BALLOON_WIDTH_3 * 2;
-	incTime = 10;
-	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
-	{
-		enemyFormation[j].init[i].x = x3_0 + (i * incX);
-		enemyFormation[j].init[i].y = y3;
-		enemyFormation[j].init[i].velX = BALLOON_VELX_POSITIVE;
-		enemyFormation[j].init[i].kind = BALLOON_3;
-		enemyFormation[j].init[i].creationCounter = creationTime - (incTime * i);
-	}
-
-	// #15 - Cinco enemigos BALLOON3. Hacia la izquierda. Separados
-	j = 15;
-	enemyFormation[j].numberOfEnemies = 5;
-	incX = BALLOON_WIDTH_3 * 2;
-	incTime = 10;
-	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
-	{
-		enemyFormation[j].init[i].x = x3_100 - (i * incX);
-		enemyFormation[j].init[i].y = y3;
-		enemyFormation[j].init[i].velX = BALLOON_VELX_NEGATIVE;
-		enemyFormation[j].init[i].kind = BALLOON_3;
-		enemyFormation[j].init[i].creationCounter = creationTime - (incTime * i);
-	}
-
-	// #16 - Cinco enemigos BALLOON3. Hacia la derecha. Juntos
-	j = 16;
-	enemyFormation[j].numberOfEnemies = 5;
-	incX = BALLOON_WIDTH_3 + 1;
-	incTime = 10;
-	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
-	{
-		enemyFormation[j].init[i].x = x3_0 + (i * incX);
-		enemyFormation[j].init[i].y = y3;
-		enemyFormation[j].init[i].velX = BALLOON_VELX_POSITIVE;
-		enemyFormation[j].init[i].kind = BALLOON_3;
-		enemyFormation[j].init[i].creationCounter = creationTime - (incTime * i);
-	}
-
-	// #17 - Cinco enemigos BALLOON3. Hacia la izquierda. Juntos
-	j = 17;
-	enemyFormation[j].numberOfEnemies = 5;
-	incX = BALLOON_WIDTH_3 + 1;
-	incTime = 10;
-	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
-	{
-		enemyFormation[j].init[i].x = x3_100 - (i * incX);
-		enemyFormation[j].init[i].y = y3;
-		enemyFormation[j].init[i].velX = BALLOON_VELX_NEGATIVE;
-		enemyFormation[j].init[i].kind = BALLOON_3;
-		enemyFormation[j].init[i].creationCounter = creationTime - (incTime * i);
-	}
-
-	// #18 - Doce enemigos BALLOON1. Hacia la derecha. Juntos
-	j = 18;
-	enemyFormation[j].numberOfEnemies = 12;
-	incX = BALLOON_WIDTH_1 + 1;
-	incTime = 10;
-	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
-	{
-		enemyFormation[j].init[i].x = x1_0 + (i * incX);
-		enemyFormation[j].init[i].y = y1;
-		enemyFormation[j].init[i].velX = BALLOON_VELX_POSITIVE;
-		enemyFormation[j].init[i].kind = BALLOON_1;
-		enemyFormation[j].init[i].creationCounter = creationTime - (incTime * i);
-	}
-
-	// #19 - Doce enemigos BALLOON1. Hacia la izquierda. Juntos
-	j = 19;
-	enemyFormation[j].numberOfEnemies = 12;
-	incX = BALLOON_WIDTH_1 + 1;
-	incTime = 10;
-	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
-	{
-		enemyFormation[j].init[i].x = x1_100 - (i * incX);
-		enemyFormation[j].init[i].y = y1;
-		enemyFormation[j].init[i].velX = BALLOON_VELX_NEGATIVE;
-		enemyFormation[j].init[i].kind = BALLOON_1;
-		enemyFormation[j].init[i].creationCounter = creationTime - (incTime * i);
-	}
-
-	// #20 - Dos enemigos BALLOON4 seguidos desde la izquierda/derecha. Simetricos
-	j = 20;
-	enemyFormation[j].numberOfEnemies = 4;
-	incX = BALLOON_WIDTH_4 + 1;
-	incTime = 0;
-	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
-	{
-		const int half = enemyFormation[j].numberOfEnemies / 2;
-		if (i < half)
-		{
-			enemyFormation[j].init[i].x = x4_0 + (i * incX);
-			enemyFormation[j].init[i].velX = BALLOON_VELX_POSITIVE;
-		}
-		else
-		{
-			enemyFormation[j].init[i].x = x4_100 - ((i - half) * incX);
-			enemyFormation[j].init[i].velX = BALLOON_VELX_NEGATIVE;
-		}
-		enemyFormation[j].init[i].y = y4;
-		enemyFormation[j].init[i].kind = BALLOON_4;
-		enemyFormation[j].init[i].creationCounter = creationTime + (incTime * i);
-	}
-
-	// #21 - Diez enemigos BALLOON2 uno detras del otro. Izquierda/derecha. Simetricos
-	j = 21;
-	enemyFormation[j].numberOfEnemies = 10;
-	incX = BALLOON_WIDTH_2 + 1;
-	incTime = 3;
-	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
-	{
-		const int half = enemyFormation[j].numberOfEnemies / 2;
-		if (i < half)
-		{
-			enemyFormation[j].init[i].x = x2_0 + (i * incX);
-			enemyFormation[j].init[i].velX = BALLOON_VELX_POSITIVE;
-			enemyFormation[j].init[i].creationCounter = (creationTime) - (incTime * i);
-		}
-		else
-		{
-			enemyFormation[j].init[i].x = x2_100 - ((i - half) * incX);
-			enemyFormation[j].init[i].velX = BALLOON_VELX_NEGATIVE;
-			enemyFormation[j].init[i].creationCounter = (creationTime) - (incTime * (i - half));
-		}
-		enemyFormation[j].init[i].y = y2;
-		enemyFormation[j].init[i].kind = BALLOON_2;
-	}
-
-	// #22 - Diez enemigos BALLOON3. Hacia la derecha/izquierda. Separados. Simetricos
-	j = 22;
-	enemyFormation[j].numberOfEnemies = 10;
-	incX = BALLOON_WIDTH_3 * 2;
-	incTime = 10;
-	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
-	{
-		const int half = enemyFormation[j].numberOfEnemies / 2;
-		if (i < half)
-		{
-			enemyFormation[j].init[i].x = x3_0 + (i * incX);
-			enemyFormation[j].init[i].velX = BALLOON_VELX_POSITIVE;
-			enemyFormation[j].init[i].creationCounter = (creationTime) - (incTime * i);
-		}
-		else
-		{
-			enemyFormation[j].init[i].x = x3_100 - ((i - half) * incX);
-			enemyFormation[j].init[i].velX = BALLOON_VELX_NEGATIVE;
-			enemyFormation[j].init[i].creationCounter = (creationTime) - (incTime * (i - half));
-		}
-		enemyFormation[j].init[i].y = y3;
-		enemyFormation[j].init[i].kind = BALLOON_3;
-	}
-
-	// #23 - Diez enemigos BALLOON3. Hacia la derecha. Juntos. Simetricos
-	j = 23;
-	enemyFormation[j].numberOfEnemies = 10;
-	incX = BALLOON_WIDTH_3 + 1;
-	incTime = 10;
-	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
-	{
-		const int half = enemyFormation[j].numberOfEnemies / 2;
-		if (i < half)
-		{
-			enemyFormation[j].init[i].x = x3_0 + (i * incX);
-			enemyFormation[j].init[i].velX = BALLOON_VELX_POSITIVE;
-			enemyFormation[j].init[i].creationCounter = (creationTime) - (incTime * i);
-		}
-		else
-		{
-			enemyFormation[j].init[i].x = x3_100 - ((i - half) * incX);
-			enemyFormation[j].init[i].velX = BALLOON_VELX_NEGATIVE;
-			enemyFormation[j].init[i].creationCounter = (creationTime) - (incTime * (i - half));
-		}
-		enemyFormation[j].init[i].y = y3;
-		enemyFormation[j].init[i].kind = BALLOON_3;
-	}
-
-	// #24 - Treinta enemigos BALLOON1. Del centro hacia los extremos. Juntos. Simetricos
-	j = 24;
-	enemyFormation[j].numberOfEnemies = 30;
-	incX = 0;
-	incTime = 5;
-	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
-	{
-		const int half = enemyFormation[j].numberOfEnemies / 2;
-		if (i < half)
-		{
-			enemyFormation[j].init[i].x = x1_50;
-			enemyFormation[j].init[i].velX = BALLOON_VELX_POSITIVE;
-			enemyFormation[j].init[i].creationCounter = (creationTime) + (incTime * i);
-		}
-		else
-		{
-			enemyFormation[j].init[i].x = x1_50;
-			enemyFormation[j].init[i].velX = BALLOON_VELX_NEGATIVE;
-			enemyFormation[j].init[i].creationCounter = (creationTime) + (incTime * (i - half));
-		}
-		enemyFormation[j].init[i].y = y1;
-		enemyFormation[j].init[i].kind = BALLOON_1;
-	}
-
-	// #25 - Treinta enemigos BALLOON1. Del centro hacia adentro. Juntos. Simetricos
-	j = 25;
-	enemyFormation[j].numberOfEnemies = 30;
-	incX = BALLOON_WIDTH_1 + 1;
-	incTime = 5;
-	for (int i = 0; i < enemyFormation[j].numberOfEnemies; i++)
-	{
-		const int half = enemyFormation[j].numberOfEnemies / 2;
-		if (i < half)
-		{
-			enemyFormation[j].init[i].x = x1_50 + 20;
-			enemyFormation[j].init[i].velX = BALLOON_VELX_NEGATIVE;
-			enemyFormation[j].init[i].creationCounter = (creationTime) - (incTime * i);
-		}
-		else
-		{
-			enemyFormation[j].init[i].x = x1_50 - 20;
-			enemyFormation[j].init[i].velX = BALLOON_VELX_POSITIVE;
-			enemyFormation[j].init[i].creationCounter = (creationTime) - (incTime * (i - half));
-		}
-		enemyFormation[j].init[i].y = y1;
-		enemyFormation[j].init[i].kind = BALLOON_1;
-	}
-
-	// Crea las mismas formaciones pero con hexagonos a partir de la posición 50 del vector
-	for (int k = 0; k < j + 1; k++)
-	{
-		enemyFormation[k + 50].numberOfEnemies = enemyFormation[k].numberOfEnemies;
-		for (int i = 0; i < enemyFormation[k + 50].numberOfEnemies; i++)
-		{
-			enemyFormation[k + 50].init[i].x = enemyFormation[k].init[i].x;
-			enemyFormation[k + 50].init[i].y = enemyFormation[k].init[i].y;
-			enemyFormation[k + 50].init[i].velX = enemyFormation[k].init[i].velX;
-			enemyFormation[k + 50].init[i].creationCounter = enemyFormation[k].init[i].creationCounter;
-			enemyFormation[k + 50].init[i].kind = enemyFormation[k].init[i].kind + 4;
-		}
-	}
-
-	// TEST
-	enemyFormation[99].numberOfEnemies = 4;
-
-	enemyFormation[99].init[0].x = 10;
-	enemyFormation[99].init[0].y = y1;
-	enemyFormation[99].init[0].velX = 0;
-	enemyFormation[99].init[0].kind = BALLOON_1;
-	enemyFormation[99].init[0].creationCounter = 200;
-
-	enemyFormation[99].init[1].x = 50;
-	enemyFormation[99].init[1].y = y1;
-	enemyFormation[99].init[1].velX = 0;
-	enemyFormation[99].init[1].kind = BALLOON_2;
-	enemyFormation[99].init[1].creationCounter = 200;
-
-	enemyFormation[99].init[2].x = 90;
-	enemyFormation[99].init[2].y = y1;
-	enemyFormation[99].init[2].velX = 0;
-	enemyFormation[99].init[2].kind = BALLOON_3;
-	enemyFormation[99].init[2].creationCounter = 200;
-
-	enemyFormation[99].init[3].x = 140;
-	enemyFormation[99].init[3].y = y1;
-	enemyFormation[99].init[3].velX = 0;
-	enemyFormation[99].init[3].kind = BALLOON_4;
-	enemyFormation[99].init[3].creationCounter = 200;
-}
-
-// Inicializa los conjuntos de formaciones
-void Game::initEnemyPools()
-{
-	// EnemyPool #0
-	enemyPool[0].set[0] = &enemyFormation[0];
-	enemyPool[0].set[1] = &enemyFormation[1];
-	enemyPool[0].set[2] = &enemyFormation[2];
-	enemyPool[0].set[3] = &enemyFormation[3];
-	enemyPool[0].set[4] = &enemyFormation[4];
-	enemyPool[0].set[5] = &enemyFormation[5];
-	enemyPool[0].set[6] = &enemyFormation[6];
-	enemyPool[0].set[7] = &enemyFormation[7];
-	enemyPool[0].set[8] = &enemyFormation[8];
-	enemyPool[0].set[9] = &enemyFormation[9];
-
-	// EnemyPool #1
-	enemyPool[1].set[0] = &enemyFormation[10];
-	enemyPool[1].set[1] = &enemyFormation[11];
-	enemyPool[1].set[2] = &enemyFormation[12];
-	enemyPool[1].set[3] = &enemyFormation[13];
-	enemyPool[1].set[4] = &enemyFormation[14];
-	enemyPool[1].set[5] = &enemyFormation[15];
-	enemyPool[1].set[6] = &enemyFormation[16];
-	enemyPool[1].set[7] = &enemyFormation[17];
-	enemyPool[1].set[8] = &enemyFormation[18];
-	enemyPool[1].set[9] = &enemyFormation[19];
-
-	// EnemyPool #2
-	enemyPool[2].set[0] = &enemyFormation[0];
-	enemyPool[2].set[1] = &enemyFormation[1];
-	enemyPool[2].set[2] = &enemyFormation[2];
-	enemyPool[2].set[3] = &enemyFormation[3];
-	enemyPool[2].set[4] = &enemyFormation[4];
-	enemyPool[2].set[5] = &enemyFormation[55];
-	enemyPool[2].set[6] = &enemyFormation[56];
-	enemyPool[2].set[7] = &enemyFormation[57];
-	enemyPool[2].set[8] = &enemyFormation[58];
-	enemyPool[2].set[9] = &enemyFormation[59];
-
-	// EnemyPool #3
-	enemyPool[3].set[0] = &enemyFormation[50];
-	enemyPool[3].set[1] = &enemyFormation[51];
-	enemyPool[3].set[2] = &enemyFormation[52];
-	enemyPool[3].set[3] = &enemyFormation[53];
-	enemyPool[3].set[4] = &enemyFormation[54];
-	enemyPool[3].set[5] = &enemyFormation[5];
-	enemyPool[3].set[6] = &enemyFormation[6];
-	enemyPool[3].set[7] = &enemyFormation[7];
-	enemyPool[3].set[8] = &enemyFormation[8];
-	enemyPool[3].set[9] = &enemyFormation[9];
-
-	// EnemyPool #4
-	enemyPool[4].set[0] = &enemyFormation[60];
-	enemyPool[4].set[1] = &enemyFormation[61];
-	enemyPool[4].set[2] = &enemyFormation[62];
-	enemyPool[4].set[3] = &enemyFormation[63];
-	enemyPool[4].set[4] = &enemyFormation[64];
-	enemyPool[4].set[5] = &enemyFormation[65];
-	enemyPool[4].set[6] = &enemyFormation[66];
-	enemyPool[4].set[7] = &enemyFormation[67];
-	enemyPool[4].set[8] = &enemyFormation[68];
-	enemyPool[4].set[9] = &enemyFormation[69];
-
-	// EnemyPool #5
-	enemyPool[5].set[0] = &enemyFormation[10];
-	enemyPool[5].set[1] = &enemyFormation[61];
-	enemyPool[5].set[2] = &enemyFormation[12];
-	enemyPool[5].set[3] = &enemyFormation[63];
-	enemyPool[5].set[4] = &enemyFormation[14];
-	enemyPool[5].set[5] = &enemyFormation[65];
-	enemyPool[5].set[6] = &enemyFormation[16];
-	enemyPool[5].set[7] = &enemyFormation[67];
-	enemyPool[5].set[8] = &enemyFormation[18];
-	enemyPool[5].set[9] = &enemyFormation[69];
-
-	// EnemyPool #6
-	enemyPool[6].set[0] = &enemyFormation[60];
-	enemyPool[6].set[1] = &enemyFormation[11];
-	enemyPool[6].set[2] = &enemyFormation[62];
-	enemyPool[6].set[3] = &enemyFormation[13];
-	enemyPool[6].set[4] = &enemyFormation[64];
-	enemyPool[6].set[5] = &enemyFormation[15];
-	enemyPool[6].set[6] = &enemyFormation[66];
-	enemyPool[6].set[7] = &enemyFormation[17];
-	enemyPool[6].set[8] = &enemyFormation[68];
-	enemyPool[6].set[9] = &enemyFormation[19];
-
-	// EnemyPool #7
-	enemyPool[7].set[0] = &enemyFormation[20];
-	enemyPool[7].set[1] = &enemyFormation[21];
-	enemyPool[7].set[2] = &enemyFormation[22];
-	enemyPool[7].set[3] = &enemyFormation[23];
-	enemyPool[7].set[4] = &enemyFormation[24];
-	enemyPool[7].set[5] = &enemyFormation[65];
-	enemyPool[7].set[6] = &enemyFormation[66];
-	enemyPool[7].set[7] = &enemyFormation[67];
-	enemyPool[7].set[8] = &enemyFormation[68];
-	enemyPool[7].set[9] = &enemyFormation[69];
-
-	// EnemyPool #8
-	enemyPool[8].set[0] = &enemyFormation[70];
-	enemyPool[8].set[1] = &enemyFormation[71];
-	enemyPool[8].set[2] = &enemyFormation[72];
-	enemyPool[8].set[3] = &enemyFormation[73];
-	enemyPool[8].set[4] = &enemyFormation[74];
-	enemyPool[8].set[5] = &enemyFormation[15];
-	enemyPool[8].set[6] = &enemyFormation[16];
-	enemyPool[8].set[7] = &enemyFormation[17];
-	enemyPool[8].set[8] = &enemyFormation[18];
-	enemyPool[8].set[9] = &enemyFormation[19];
-
-	// EnemyPool #9
-	enemyPool[9].set[0] = &enemyFormation[20];
-	enemyPool[9].set[1] = &enemyFormation[21];
-	enemyPool[9].set[2] = &enemyFormation[22];
-	enemyPool[9].set[3] = &enemyFormation[23];
-	enemyPool[9].set[4] = &enemyFormation[24];
-	enemyPool[9].set[5] = &enemyFormation[70];
-	enemyPool[9].set[6] = &enemyFormation[71];
-	enemyPool[9].set[7] = &enemyFormation[72];
-	enemyPool[9].set[8] = &enemyFormation[73];
-	enemyPool[9].set[9] = &enemyFormation[74];
-}
-
-// Inicializa las fases del juego
-void Game::initGameStages()
-{
-	// STAGE 1
-	stage[0].number = 1;
-	stage[0].currentPower = 0;
-	stage[0].powerToComplete = 200;
-	stage[0].minMenace = 7 + (4 * 1);
-	stage[0].maxMenace = 7 + (4 * 3);
-	stage[0].enemyPool = &enemyPool[0];
-
-	// STAGE 2
-	stage[1].number = 2;
-	stage[1].currentPower = 0;
-	stage[1].powerToComplete = 300;
-	stage[1].minMenace = 7 + (4 * 2);
-	stage[1].maxMenace = 7 + (4 * 4);
-	stage[1].enemyPool = &enemyPool[1];
-
-	// STAGE 3
-	stage[2].number = 3;
-	stage[2].currentPower = 0;
-	stage[2].powerToComplete = 600;
-	stage[2].minMenace = 7 + (4 * 3);
-	stage[2].maxMenace = 7 + (4 * 5);
-	stage[2].enemyPool = &enemyPool[2];
-
-	// STAGE 4
-	stage[3].number = 4;
-	stage[3].currentPower = 0;
-	stage[3].powerToComplete = 600;
-	stage[3].minMenace = 7 + (4 * 3);
-	stage[3].maxMenace = 7 + (4 * 5);
-	stage[3].enemyPool = &enemyPool[3];
-
-	// STAGE 5
-	stage[4].number = 5;
-	stage[4].currentPower = 0;
-	stage[4].powerToComplete = 600;
-	stage[4].minMenace = 7 + (4 * 4);
-	stage[4].maxMenace = 7 + (4 * 6);
-	stage[4].enemyPool = &enemyPool[4];
-
-	// STAGE 6
-	stage[5].number = 6;
-	stage[5].currentPower = 0;
-	stage[5].powerToComplete = 600;
-	stage[5].minMenace = 7 + (4 * 4);
-	stage[5].maxMenace = 7 + (4 * 6);
-	stage[5].enemyPool = &enemyPool[5];
-
-	// STAGE 7
-	stage[6].number = 7;
-	stage[6].currentPower = 0;
-	stage[6].powerToComplete = 650;
-	stage[6].minMenace = 7 + (4 * 5);
-	stage[6].maxMenace = 7 + (4 * 7);
-	stage[6].enemyPool = &enemyPool[6];
-
-	// STAGE 8
-	stage[7].number = 8;
-	stage[7].currentPower = 0;
-	stage[7].powerToComplete = 750;
-	stage[7].minMenace = 7 + (4 * 5);
-	stage[7].maxMenace = 7 + (4 * 7);
-	stage[7].enemyPool = &enemyPool[7];
-
-	// STAGE 9
-	stage[8].number = 9;
-	stage[8].currentPower = 0;
-	stage[8].powerToComplete = 850;
-	stage[8].minMenace = 7 + (4 * 6);
-	stage[8].maxMenace = 7 + (4 * 8);
-	stage[8].enemyPool = &enemyPool[8];
-
-	// STAGE 10
-	stage[9].number = 10;
-	stage[9].currentPower = 0;
-	stage[9].powerToComplete = 950;
-	stage[9].minMenace = 7 + (4 * 7);
-	stage[9].maxMenace = 7 + (4 * 10);
-	stage[9].enemyPool = &enemyPool[9];
-}
-
 // Crea una formación de enemigos
 void Game::deployEnemyFormation()
 {
@@ -1611,15 +898,16 @@ void Game::deployEnemyFormation()
 
 			lastEnemyDeploy = set;
 
-			const int numEnemies = stage[currentStage].enemyPool->set[set]->numberOfEnemies;
+			const stage_t stage = enemyFormations->getStage(currentStage)
+			const int numEnemies = enemyFormations->stage[currentStage].enemyPool->set[set]->numberOfEnemies;
 			for (int i = 0; i < numEnemies; ++i)
 			{
-				createBalloon(stage[currentStage].enemyPool->set[set]->init[i].x,
-							  stage[currentStage].enemyPool->set[set]->init[i].y,
-							  stage[currentStage].enemyPool->set[set]->init[i].kind,
-							  stage[currentStage].enemyPool->set[set]->init[i].velX,
+				createBalloon(enemyFormations->stage[currentStage].enemyPool->set[set]->init[i].x,
+							  enemyFormations->stage[currentStage].enemyPool->set[set]->init[i].y,
+							  enemyFormations->stage[currentStage].enemyPool->set[set]->init[i].kind,
+							  enemyFormations->stage[currentStage].enemyPool->set[set]->init[i].velX,
 							  enemySpeed,
-							  stage[currentStage].enemyPool->set[set]->init[i].creationCounter);
+							  enemyFormations->stage[currentStage].enemyPool->set[set]->init[i].creationCounter);
 			}
 
 			enemyDeployCounter = 300;
@@ -1630,7 +918,7 @@ void Game::deployEnemyFormation()
 // Aumenta el poder de la fase
 void Game::increaseStageCurrentPower(int power)
 {
-	stage[currentStage].currentPower += power;
+	enemyFormations->stage[currentStage].currentPower += power;
 }
 
 // Actualiza el valor de hiScore en caso necesario
@@ -1697,7 +985,7 @@ void Game::renderPlayers()
 // Actualiza las variables de la fase
 void Game::updateStage()
 {
-	if (stage[currentStage].currentPower >= stage[currentStage].powerToComplete)
+	if (enemyFormations->stage[currentStage].currentPower >= enemyFormations->stage[currentStage].powerToComplete)
 	{
 		// Cambio de fase
 		currentStage++;
@@ -1706,9 +994,9 @@ void Game::updateStage()
 		{										  // Ha llegado al final el juego
 			gameCompleted = true;				  // Marca el juego como completado
 			currentStage = 9;					  // Deja el valor dentro de los limites
-			stage[currentStage].currentPower = 0; // Deja el poder a cero para que no vuelva a entrar en esta condición
+			enemyFormations->stage[currentStage].currentPower = 0; // Deja el poder a cero para que no vuelva a entrar en esta condición
 			destroyAllBalloons();				  // Destruye a todos los enemigos
-			stage[currentStage].currentPower = 0; // Vuelve a dejar el poder a cero, por lo que hubiera podido subir al destruir todos lo globos
+			enemyFormations->stage[currentStage].currentPower = 0; // Vuelve a dejar el poder a cero, por lo que hubiera podido subir al destruir todos lo globos
 			menaceCurrent = 255;				  // Sube el nivel de amenaza para que no cree mas globos
 			for (auto player : players)
 			{ // Añade un millon de puntos a los jugadores que queden vivos
@@ -1898,7 +1186,7 @@ void Game::decBalloonSpeed()
 // Actualiza la velocidad de los globos en funcion del poder acumulado de la fase
 void Game::updateBalloonSpeed()
 {
-	const float percent = (float)stage[currentStage].currentPower / (float)stage[currentStage].powerToComplete;
+	const float percent = (float)enemyFormations->stage[currentStage].currentPower / (float)enemyFormations->stage[currentStage].powerToComplete;
 	if (enemySpeed == BALLOON_SPEED_1)
 	{
 		if (percent > 0.2f)
@@ -2829,11 +2117,12 @@ void Game::updateMenace()
 		return;
 	}
 
-	const float percent = stage[currentStage].currentPower / stage[currentStage].powerToComplete;
-	const int difference = stage[currentStage].maxMenace - stage[currentStage].minMenace;
+	const stage_t stage = enemyFormations->getStage(currentStage);
+	const float percent = currentPower / stage.powerToComplete;
+	const int difference = stage.maxMenace - stage.minMenace;
 
 	// Aumenta el nivel de amenaza en función de la puntuación
-	menaceThreshold = stage[currentStage].minMenace + (difference * percent);
+	menaceThreshold = stage.minMenace + (difference * percent);
 
 	// Si el nivel de amenza es inferior al umbral
 	if (menaceCurrent < menaceThreshold)
@@ -3085,7 +2374,7 @@ void Game::renderMessages()
 	// STAGE NUMBER
 	if (stageBitmapCounter < STAGE_COUNTER)
 	{
-		const int stageNum = stage[currentStage].number;
+		const int stageNum = enemyFormations->stage[currentStage].number;
 		std::string text;
 
 		if (stageNum == 10)
@@ -3094,7 +2383,7 @@ void Game::renderMessages()
 		}
 		else
 		{ // X fases restantes
-			text = std::to_string(11 - stage[currentStage].number) + lang->getText(38);
+			text = std::to_string(11 - enemyFormations->stage[currentStage].number) + lang->getText(38);
 		}
 
 		if (!gameCompleted)
@@ -3474,8 +2763,8 @@ void Game::updateScoreboard()
 	scoreboard->setMult2(players[1]->getScoreMultiplier());
 
 	// Resto de marcador
-	scoreboard->setStage(stage[currentStage].number);
-	scoreboard->setPower((float)stage[currentStage].currentPower / (float)stage[currentStage].powerToComplete);
+	scoreboard->setStage(enemyFormations->stage[currentStage].number);
+	scoreboard->setPower((float)enemyFormations->stage[currentStage].currentPower / (float)enemyFormations->stage[currentStage].powerToComplete);
 	scoreboard->setHiScore(hiScore);
 	scoreboard->setHiScoreName(hiScoreName);
 
diff --git a/source/game.h b/source/game.h
index dbb3191..1140264 100644
--- a/source/game.h
+++ b/source/game.h
@@ -21,6 +21,7 @@
 #include "lang.h"
 #include "manage_hiscore_table.h"
 #include "explosions.h"
+#include "enemy_formations.h"
 #include <iostream>
 
 // Cantidad de elementos a escribir en los ficheros de datos
@@ -33,10 +34,6 @@
 #define GAME_COMPLETED_START_FADE 500
 #define GAME_COMPLETED_END 700
 
-// Formaciones enemigas
-#define NUMBER_OF_ENEMY_FORMATIONS 100
-#define MAX_NUMBER_OF_ENEMIES_IN_A_FORMATION 50
-
 // Porcentaje de aparición de los objetos
 #define ITEM_POINTS_1_DISK_ODDS 10
 #define ITEM_POINTS_2_GAVINA_ODDS 6
@@ -53,36 +50,6 @@
 class Game
 {
 private:
-	struct enemyInits_t
-	{
-		int x;				 // Posición en el eje X donde crear al enemigo
-		int y;				 // Posición en el eje Y donde crear al enemigo
-		float velX;			 // Velocidad inicial en el eje X
-		int kind;			 // Tipo de enemigo
-		int creationCounter; // Temporizador para la creación del enemigo
-	};
-
-	struct enemyFormation_t // Contiene la información de una formación enemiga
-	{
-		int numberOfEnemies;									 // Cantidad de enemigos que forman la formación
-		enemyInits_t init[MAX_NUMBER_OF_ENEMIES_IN_A_FORMATION]; // Vector con todas las inicializaciones de los enemigos de la formación
-	};
-
-	struct enemyPool_t
-	{
-		enemyFormation_t *set[10]; // Conjunto de formaciones enemigas
-	};
-
-	struct stage_t // Contiene todas las variables relacionadas con una fase
-	{
-		enemyPool_t *enemyPool; // El conjunto de formaciones enemigas de la fase
-		int currentPower;		// Cantidad actual de poder
-		int powerToComplete;	// Cantidad de poder que se necesita para completar la fase
-		int maxMenace;			// Umbral máximo de amenaza de la fase
-		int minMenace;			// Umbral mínimo de amenaza de la fase
-		int number;				// Número de fase
-	};
-
 	struct helper_t
 	{
 		bool needCoffee;		   // Indica si se necesitan cafes
@@ -107,16 +74,17 @@ private:
 	};
 
 	// Objetos y punteros
-	SDL_Renderer *renderer; // El renderizador de la ventana
-	Screen *screen;			// Objeto encargado de dibujar en pantalla
-	Asset *asset;			// Objeto que gestiona todos los ficheros de recursos
-	Lang *lang;				// Objeto para gestionar los textos en diferentes idiomas
-	Input *input;			// Manejador de entrada
-	section_t *section;		// Seccion actual dentro del juego
-	Scoreboard *scoreboard; // Objeto para dibujar el marcador
-	Background *background; // Objeto para dibujar el fondo del juego
-	Explosions *explosions; // Objeto para dibujar explosiones
-	SDL_Texture *canvas;	// Textura para dibujar la zona de juego
+	SDL_Renderer *renderer;			  // El renderizador de la ventana
+	Screen *screen;					  // Objeto encargado de dibujar en pantalla
+	Asset *asset;					  // Objeto que gestiona todos los ficheros de recursos
+	Lang *lang;						  // Objeto para gestionar los textos en diferentes idiomas
+	Input *input;					  // Manejador de entrada
+	section_t *section;				  // Seccion actual dentro del juego
+	Scoreboard *scoreboard;			  // Objeto para dibujar el marcador
+	Background *background;			  // Objeto para dibujar el fondo del juego
+	Explosions *explosions;			  // Objeto para dibujar explosiones
+	EnemyFormations *enemyFormations; // Objeto para gestionar las oleadas enemigas
+	SDL_Texture *canvas;			  // Textura para dibujar la zona de juego
 
 	std::vector<Player *> players;			 // Vector con los jugadores
 	std::vector<Balloon *> balloons;		 // Vector con los globos
@@ -172,45 +140,43 @@ private:
 	JA_Music_t *music; // Musica de fondo
 
 	// Variables
-	Uint32 ticks;												 // Contador de ticks para ajustar la velocidad del programa
-	Uint32 ticksSpeed;											 // Velocidad a la que se repiten los bucles del programa
-	int hiScore;												 // Puntuación máxima
-	bool hiScoreAchieved;										 // Indica si se ha superado la puntuación máxima
-	std::string hiScoreName;									 // Nombre del jugador que ostenta la máxima puntuación
-	stage_t stage[10];											 // Variable con los datos de cada pantalla
-	int currentStage;											 // Indica la fase actual
-	int stageBitmapCounter;										 // Contador para el tiempo visible del texto de Stage
-	float stageBitmapPath[STAGE_COUNTER];						 // Vector con los puntos Y por donde se desplaza el texto
-	float getReadyBitmapPath[STAGE_COUNTER];					 // Vector con los puntos X por donde se desplaza el texto
-	int deathCounter;											 // Contador para la animación de muerte del jugador
-	int menaceCurrent;											 // Nivel de amenaza actual
-	int menaceThreshold;										 // Umbral del nivel de amenaza. Si el nivel de amenaza cae por debajo del umbral, se generan más globos. Si el umbral aumenta, aumenta el número de globos
-	bool timeStopped;											 // Indica si el tiempo está detenido
-	int timeStoppedCounter;										 // Temporizador para llevar la cuenta del tiempo detenido
-	int counter;												 // Contador para el juego
-	int scoreDataFile[TOTAL_SCORE_DATA];						 // Datos del fichero de puntos
-	int balloonsPopped;											 // Lleva la cuenta de los globos explotados
-	int lastEnemyDeploy;										 // Guarda cual ha sido la última formación desplegada para no repetir;
-	int enemyDeployCounter;										 // Cuando se lanza una formación, se le da un valor y no sale otra hasta que llegue a cero
-	float enemySpeed;											 // Velocidad a la que se mueven los enemigos
-	float defaultEnemySpeed;									 // Velocidad base de los enemigos, sin incrementar
-	helper_t helper;											 // Variable para gestionar las ayudas
-	bool powerBallEnabled;										 // Indica si hay una powerball ya activa
-	int powerBallCounter;										 // Contador de formaciones enemigas entre la aparicion de una PowerBall y otra
-	bool coffeeMachineEnabled;									 // Indica si hay una máquina de café en el terreno de juego
-	bool gameCompleted;											 // Indica si se ha completado la partida, llegando al final de la ultima pantalla
-	int gameCompletedCounter;									 // Contador para el tramo final, cuando se ha completado la partida y ya no aparecen más enemigos
-	int difficulty;												 // Dificultad del juego
-	float difficultyScoreMultiplier;							 // Multiplicador de puntos en función de la dificultad
-	color_t difficultyColor;									 // Color asociado a la dificultad
-	options_t *options;											 // Variable con todas las opciones del programa
-	param_t *param;												 // Puntero con todos los parametros del programa
-	enemyFormation_t enemyFormation[NUMBER_OF_ENEMY_FORMATIONS]; // Vector con todas las formaciones enemigas
-	enemyPool_t enemyPool[10];									 // Variable con los diferentes conjuntos de formaciones enemigas
-	int lastStageReached;										 // Contiene el número de la última pantalla que se ha alcanzado
-	demo_t demo;												 // Variable con todas las variables relacionadas con el modo demo
-	int totalPowerToCompleteGame;								 // La suma del poder necesario para completar todas las fases
-	bool paused;												 // Indica si el juego está pausado (no se deberia de poder utilizar en el modo arcade)
+	Uint32 ticks;							 // Contador de ticks para ajustar la velocidad del programa
+	Uint32 ticksSpeed;						 // Velocidad a la que se repiten los bucles del programa
+	int hiScore;							 // Puntuación máxima
+	bool hiScoreAchieved;					 // Indica si se ha superado la puntuación máxima
+	std::string hiScoreName;				 // Nombre del jugador que ostenta la máxima puntuación
+	int currentStage;						 // Indica la fase actual
+	int stageBitmapCounter;					 // Contador para el tiempo visible del texto de Stage
+	float stageBitmapPath[STAGE_COUNTER];	 // Vector con los puntos Y por donde se desplaza el texto
+	float getReadyBitmapPath[STAGE_COUNTER]; // Vector con los puntos X por donde se desplaza el texto
+	int deathCounter;						 // Contador para la animación de muerte del jugador
+	int menaceCurrent;						 // Nivel de amenaza actual
+	int menaceThreshold;					 // Umbral del nivel de amenaza. Si el nivel de amenaza cae por debajo del umbral, se generan más globos. Si el umbral aumenta, aumenta el número de globos
+	bool timeStopped;						 // Indica si el tiempo está detenido
+	int timeStoppedCounter;					 // Temporizador para llevar la cuenta del tiempo detenido
+	int counter;							 // Contador para el juego
+	int scoreDataFile[TOTAL_SCORE_DATA];	 // Datos del fichero de puntos
+	int balloonsPopped;						 // Lleva la cuenta de los globos explotados
+	int lastEnemyDeploy;					 // Guarda cual ha sido la última formación desplegada para no repetir;
+	int enemyDeployCounter;					 // Cuando se lanza una formación, se le da un valor y no sale otra hasta que llegue a cero
+	float enemySpeed;						 // Velocidad a la que se mueven los enemigos
+	float defaultEnemySpeed;				 // Velocidad base de los enemigos, sin incrementar
+	helper_t helper;						 // Variable para gestionar las ayudas
+	bool powerBallEnabled;					 // Indica si hay una powerball ya activa
+	int powerBallCounter;					 // Contador de formaciones enemigas entre la aparicion de una PowerBall y otra
+	bool coffeeMachineEnabled;				 // Indica si hay una máquina de café en el terreno de juego
+	bool gameCompleted;						 // Indica si se ha completado la partida, llegando al final de la ultima pantalla
+	int gameCompletedCounter;				 // Contador para el tramo final, cuando se ha completado la partida y ya no aparecen más enemigos
+	int difficulty;							 // Dificultad del juego
+	float difficultyScoreMultiplier;		 // Multiplicador de puntos en función de la dificultad
+	color_t difficultyColor;				 // Color asociado a la dificultad
+	options_t *options;						 // Variable con todas las opciones del programa
+	param_t *param;							 // Puntero con todos los parametros del programa
+	int lastStageReached;					 // Contiene el número de la última pantalla que se ha alcanzado
+	demo_t demo;							 // Variable con todas las variables relacionadas con el modo demo
+	int totalPowerToCompleteGame;			 // La suma del poder necesario para completar todas las fases
+	bool paused;							 // Indica si el juego está pausado (no se deberia de poder utilizar en el modo arcade)
+	int currentPower;						 // Poder actual almacenado para completar la fase
 
 	// Actualiza el juego
 	void update();
@@ -242,14 +208,6 @@ private:
 	// Guarda el fichero de datos para la demo
 	bool saveDemoFile();
 #endif
-	// Inicializa las formaciones enemigas
-	void initEnemyFormations();
-
-	// Inicializa los conjuntos de formaciones
-	void initEnemyPools();
-
-	// Inicializa las fases del juego
-	void initGameStages();
 
 	// Crea una formación de enemigos
 	void deployEnemyFormation();