Actualizando el código

2022-09-27 13:06:04 +02:00
parent c8bebfd2d9
commit 8d56912765
13 changed files with 291 additions and 451 deletions
--- a/source/game.cpp
+++ b/source/game.cpp
@@ -38,30 +38,6 @@ Game::Game(int numPlayers, int currentStage, SDL_Renderer *renderer, Screen *scr
 		players.push_back(player1);
 		players.push_back(player2);
 	}
-	/*for (int i = 0; i < mNumPlayers; i++)
-	{
-		mPlayer[i] = new Player();
-	}
-
-	for (int i = 0; i < MAX_BALLOONS; i++)
-	{
-		mBalloon[i] = new Balloon();
-	}
-
-	for (int i = 0; i < MAX_BULLETS; i++)
-	{
-		mBullet[i] = new Bullet();
-	}
-
-	for (int i = 0; i < MAX_ITEMS; i++)
-	{
-		mItem[i] = new Item(mTextureItems, mRenderer);
-	}
-
-	for (int i = 0; i < MAX_SMART_SPRITES; i++)
-	{
-		mSmartSprite[i] = new SmartSprite(nullptr, mRenderer);
-	}*/

 	mTextureBalloon = new LTexture(mRenderer, mAsset->get("balloon.png"));
 	mTextureBullet = new LTexture(mRenderer, mAsset->get("bullet.png"));
@@ -126,7 +102,7 @@ Game::~Game()
 		delete player;
 	};

-	for (auto ballon : ballons)
+	for (auto ballon : balloons)
 	{
 		delete ballon;
 	};
@@ -441,26 +417,13 @@ void Game::init()
 	mSpriteScoreBoard->setSpriteClip(0, 160, 256, 32);
 	mSpritePowerMeter->setSpriteClip(256, 192 - 8, 40, 8);

-	// Establece a cero todos los valores del vector de objetos globo
-	resetBalloons();
-
 	// Con los globos creados, calcula el nivel de amenaza
 	evaluateAndSetMenace();

-	// Establece a cero todos los valores del vector de objetos bala
-	resetBullets();
-
-	// Establece a cero todos los valores del vector de objetos item
-	resetItems();
-
-	// Establece a cero todos los valores del vector de objetos SmafrtSprite
-	resetSmartSprites();
-
 	// Inicializa el bitmap de GetReady!
 	mSpriteGetReady->setSpriteClip(0, 0, 109, 20);

 	// Inicializa el bitmap de 1000 puntos
-	m1000Bitmap->init();
 	m1000Bitmap->setPosX(0);
 	m1000Bitmap->setPosY(0);
 	m1000Bitmap->setWidth(26);
@@ -476,7 +439,6 @@ void Game::init()
 	m1000Bitmap->setDestY(0);

 	// Inicializa el bitmap de 2500 puntos
-	m2500Bitmap->init();
 	m2500Bitmap->setPosX(0);
 	m2500Bitmap->setPosY(0);
 	m2500Bitmap->setWidth(28);
@@ -492,7 +454,6 @@ void Game::init()
 	m2500Bitmap->setDestY(0);

 	// Inicializa el bitmap de 5000 puntos
-	m5000Bitmap->init();
 	m5000Bitmap->setPosX(0);
 	m5000Bitmap->setPosY(0);
 	m5000Bitmap->setWidth(28);
@@ -1820,19 +1781,17 @@ void Game::renderDeathFade(int counter)
 void Game::updateBalloons()
 {
 	for (auto balloon : balloons)
-		// for (int i = 0; i < MAX_BALLOONS; i++)
+	{
 		balloon->update();
+	}
 }

 // Pinta en pantalla todos los globos activos
 void Game::renderBalloons()
 {
 	for (auto balloon : balloons)
-	// for (int i = 0; i < MAX_BALLOONS; i++)
 	{
 		balloon->render();
-		if ((mDebug.enabled) && (balloon->isPopping() == false))
-			mText->writeCentered(balloon->getPosX() + (balloon->getWidth() / 2), balloon->getPosY() - 8, std::to_string(i));
 	}
 }

@@ -1863,16 +1822,6 @@ void Game::createPowerBall()
 	mPowerBallCounter = POWERBALL_COUNTER;
 }

-// Establece a cero todos los valores del vector de objetos globo
-void Game::resetBalloons()
-{
-	for (auto balloon : balloons)
-	// for (int i = 0; i < MAX_BALLOONS; i++)
-	{
-		balloon->disable();
-	}
-}
-
 // Establece la velocidad de los globos
 void Game::setBalloonSpeed(float speed)
 {
@@ -1969,17 +1918,17 @@ void Game::popBalloon(Balloon *balloon)
 	increaseStageCurrentPower(1);
 	mBalloonsPopped++;

-	const Uint8 kind = mBalloon[index]->getKind();
+	const Uint8 kind = balloon->getKind();
 	Uint8 freeIndex = 0;
 	switch (kind)
 	{
 	// Si es del tipo más pequeño, simplemente elimina el globo
 	case BALLOON_1:
-		mBalloon[index]->pop();
+		balloon->pop();
 		break;

 	case HEXAGON_1:
-		mBalloon[index]->pop();
+		balloon->pop();
 		break;

 	// Si es del tipo PowerBall, destruye todos los globos
@@ -1991,32 +1940,32 @@ void Game::popBalloon(Balloon *balloon)

 	// En cualquier otro caso, crea dos globos de un tipo inferior
 	default:
-		freeIndex = getBalloonFreeIndex();
-		mBalloon[freeIndex]->init(0, mBalloon[index]->getPosY(), mBalloon[index]->getKind() - 1, BALLOON_VELX_NEGATIVE, mEnemySpeed, 0, mTextureBalloon, mRenderer);
-		mBalloon[freeIndex]->allignTo(mBalloon[index]->getPosX() + (mBalloon[index]->getWidth() / 2));
-		if (mBalloon[freeIndex]->getClass() == BALLOON_CLASS)
+		Balloon *b1 = new Balloon(0, balloon->getPosY(), balloon->getKind() - 1, BALLOON_VELX_NEGATIVE, mEnemySpeed, 0, mTextureBalloon, mRenderer);
+		balloons.push_back(b1);
+		b1->allignTo(balloon->getPosX() + (balloon->getWidth() / 2));
+		if (b1->getClass() == BALLOON_CLASS)
 		{
-			mBalloon[freeIndex]->setVelY(-2.50f);
+			b1->setVelY(-2.50f);
 		}
-		else if (mBalloon[freeIndex]->getClass() == HEXAGON_CLASS)
+		else if (b1->getClass() == HEXAGON_CLASS)
 		{
-			mBalloon[freeIndex]->setVelY(BALLOON_VELX_NEGATIVE);
+			b1->setVelY(BALLOON_VELX_NEGATIVE);
 		}

-		freeIndex = getBalloonFreeIndex();
-		mBalloon[freeIndex]->init(0, mBalloon[index]->getPosY(), mBalloon[index]->getKind() - 1, BALLOON_VELX_POSITIVE, mEnemySpeed, 0, mTextureBalloon, mRenderer);
-		mBalloon[freeIndex]->allignTo(mBalloon[index]->getPosX() + (mBalloon[index]->getWidth() / 2));
-		if (mBalloon[freeIndex]->getClass() == BALLOON_CLASS)
+		Balloon *b2 = new Balloon(0, balloon->getPosY(), balloon->getKind() - 1, BALLOON_VELX_POSITIVE, mEnemySpeed, 0, mTextureBalloon, mRenderer);
+		balloons.push_back(b2);
+		b2->allignTo(balloon->getPosX() + (balloon->getWidth() / 2));
+		if (b2->getClass() == BALLOON_CLASS)
 		{
-			mBalloon[freeIndex]->setVelY(-2.50f);
+			b2->setVelY(-2.50f);
 		}
-		else if (mBalloon[freeIndex]->getClass() == HEXAGON_CLASS)
+		else if (b2->getClass() == HEXAGON_CLASS)
 		{
-			mBalloon[freeIndex]->setVelY(BALLOON_VELX_NEGATIVE);
+			b2->setVelY(BALLOON_VELX_NEGATIVE);
 		}

 		// Elimina el globo
-		mBalloon[index]->pop();
+		balloon->pop();
 		break;
 	}

@@ -2025,13 +1974,13 @@ void Game::popBalloon(Balloon *balloon)
 }

 // Explosiona un globo. Lo destruye
-void Game::destroyBalloon(Uint8 index)
+void Game::destroyBalloon(Balloon *balloon)
 {
 	int score = 0;
 	Uint8 power = 0;

 	// Calcula la puntuación y el poder que generaria el globo en caso de romperlo a él y a sus hijos
-	switch (mBalloon[index]->getSize())
+	switch (balloon->getSize())
 	{
 	case BALLOON_SIZE_4:
 		score = BALLOON_SCORE_4 + (2 * BALLOON_SCORE_3) + (4 * BALLOON_SCORE_2) + (8 * BALLOON_SCORE_1);
@@ -2060,9 +2009,9 @@ void Game::destroyBalloon(Uint8 index)
 	}

 	// Otorga los puntos correspondientes al globo
-	for (int i = 0; i < mNumPlayers; i++)
+	for (auto player : players)
 	{
-		mPlayer[i]->addScore(Uint32(score * mPlayer[i]->getScoreMultiplier() * mDifficultyScoreMultiplier));
+		player->addScore(Uint32(score * player->getScoreMultiplier() * mDifficultyScoreMultiplier));
 	}
 	updateHiScore();

@@ -2071,7 +2020,7 @@ void Game::destroyBalloon(Uint8 index)
 	mBalloonsPopped += power;

 	// Destruye el globo
-	mBalloon[index]->pop();
+	balloon->pop();

 	// Recalcula el nivel de amenaza
 	evaluateAndSetMenace();
@@ -2080,11 +2029,11 @@ void Game::destroyBalloon(Uint8 index)
 // Explosiona todos los globos
 void Game::popAllBalloons()
 {
-	for (int i = 0; i < MAX_BALLOONS; i++)
+	for (auto balloon : balloons)
 	{
-		if ((mBalloon[i]->isEnabled()) && (!mBalloon[i]->isPopping()) && (!mBalloon[i]->isBeingCreated()))
+		if ((balloon->isEnabled()) && (!balloon->isPopping()) && (!balloon->isBeingCreated()))
 		{
-			popBalloon(i);
+			popBalloon(balloon);
 		}
 	}

@@ -2094,11 +2043,11 @@ void Game::popAllBalloons()
 // Destruye todos los globos
 void Game::destroyAllBalloons()
 {
-	for (int i = 0; i < MAX_BALLOONS; i++)
+	for (auto balloon : balloons)
 	{
-		if ((mBalloon[i]->isEnabled()) && (!mBalloon[i]->isPopping()))
+		if ((balloon->isEnabled()) && (!balloon->isPopping()))
 		{
-			destroyBalloon(i);
+			destroyBalloon(balloon);
 		}
 	}

@@ -2111,12 +2060,12 @@ void Game::destroyAllBalloons()
 // Detiene todos los globos
 void Game::stopAllBalloons(Uint16 time)
 {
-	for (int i = 0; i < MAX_BALLOONS; i++)
+	for (auto balloon : balloons)
 	{
-		if (mBalloon[i]->isEnabled())
+		if (balloon->isEnabled())
 		{
-			mBalloon[i]->setStop(true);
-			mBalloon[i]->setStoppedTimer(time);
+			balloon->setStop(true);
+			balloon->setStoppedTimer(time);
 		}
 	}
 }
@@ -2124,12 +2073,12 @@ void Game::stopAllBalloons(Uint16 time)
 // Pone en marcha todos los globos
 void Game::startAllBalloons()
 {
-	for (int i = 0; i < MAX_BALLOONS; i++)
+	for (auto balloon : balloons)
 	{
-		if ((mBalloon[i]->isEnabled()) && (!mBalloon[i]->isBeingCreated()))
+		if ((balloon->isEnabled()) && (!balloon->isBeingCreated()))
 		{
-			mBalloon[i]->setStop(false);
-			mBalloon[i]->setStoppedTimer(0);
+			balloon->setStop(false);
+			balloon->setStoppedTimer(0);
 		}
 	}
 }
@@ -2139,11 +2088,11 @@ Uint8 Game::countBalloons()
 {
 	Uint8 num = 0;

-	for (int i = 0; i < MAX_BALLOONS; i++)
+	for (auto balloon : balloons)
 	{
-		if (mBalloon[i]->isEnabled())
+		if (balloon->isEnabled())
 		{
-			if (!mBalloon[i]->isPopping())
+			if (!balloon->isPopping())
 			{
 				num++;
 			}
@@ -2154,13 +2103,13 @@ Uint8 Game::countBalloons()
 }

 // Comprueba la colisión entre el jugador y los globos activos
-bool Game::checkPlayerBalloonCollision(int index)
+bool Game::checkPlayerBalloonCollision(Player *player)
 {
-	for (int i = 0; i < MAX_BALLOONS; i++)
+	for (auto balloon : balloons)
 	{
-		if ((mBalloon[i]->isEnabled()) && !(mBalloon[i]->isStopped()) && !(mBalloon[i]->isInvulnerable()))
+		if ((balloon->isEnabled()) && !(balloon->isStopped()) && !(balloon->isInvulnerable()))
 		{
-			if (checkCollision(mPlayer[index]->getCollider(), mBalloon[i]->getCollider()))
+			if (checkCollision(player->getCollider(), balloon->getCollider()))
 			{
 				return true;
 			}
@@ -2237,22 +2186,22 @@ void Game::checkPlayerItemCollision(Player *player)
 // Comprueba y procesa la colisión entre las balas y los globos
 void Game::checkBulletBalloonCollision()
 {
-	for (int i = 0; i < MAX_BALLOONS; i++)
+	for (auto balloon : balloons)
 	{
-		for (int j = 0; j < MAX_BULLETS; j++)
+		for (auto bullet : bullets)
 		{
-			if (mBalloon[i]->isEnabled() && (!mBalloon[i]->isInvulnerable()) && mBullet[j]->isActive())
+			if (balloon->isEnabled() && (!balloon->isInvulnerable()) && bullet->isActive())
 			{
-				if (checkCollision(mBalloon[i]->getCollider(), mBullet[j]->getCollider()))
+				if (checkCollision(balloon->getCollider(), bullet->getCollider()))
 				{
 					// Otorga los puntos correspondientes al globo al jugador que disparó la bala
-					int index = mBullet[j]->getOwner();
-					mPlayer[index]->incScoreMultiplier();
-					mPlayer[index]->addScore(Uint32(mBalloon[i]->getScore() * mPlayer[index]->getScoreMultiplier() * mDifficultyScoreMultiplier));
+					int index = bullet->getOwner();
+					players[index]->incScoreMultiplier();
+					players[index]->addScore(Uint32(balloon->getScore() * players[index]->getScoreMultiplier() * mDifficultyScoreMultiplier));
 					updateHiScore();

 					// Explota el globo
-					popBalloon(i);
+					popBalloon(balloon);

 					// Si no es el modo demo, genera un sonido
 					if (!mDemo.enabled)
@@ -2261,7 +2210,7 @@ void Game::checkBulletBalloonCollision()
 					}

 					// Destruye la bala
-					mBullet[j]->erase();
+					delete bullet;

 					// Suelta el item en caso de que salga uno
 					const Uint8 droppeditem = dropItem();
@@ -2269,12 +2218,12 @@ void Game::checkBulletBalloonCollision()
 					{
 						if (droppeditem != ITEM_COFFEE_MACHINE)
 						{
-							createItem(mBalloon[i]->getPosX(), mBalloon[i]->getPosY(), droppeditem);
+							createItem(mTextureItems, mRenderer, balloon->getPosX(), balloon->getPosY(), droppeditem);
 							JA_PlaySound(mSoundItemDrop);
 						}
 						else
 						{
-							createItem(mPlayer[index]->getPosX(), 0, droppeditem);
+							createItem(mTextureItems, mRenderer, players[index]->getPosX(), 0, droppeditem);
 							mCoffeeMachineEnabled = true;
 						}
 					}
@@ -2288,13 +2237,13 @@ void Game::checkBulletBalloonCollision()
 // Mueve las balas activas
 void Game::moveBullets()
 {
-	for (int i = 0; i < MAX_BULLETS; i++)
+	for (auto bullet : bullets)
 	{
-		if (mBullet[i]->isActive())
+		if (bullet->isActive())
 		{
-			if (mBullet[i]->move() == BULLET_MOVE_OUT)
+			if (bullet->move() == BULLET_MOVE_OUT)
 			{
-				mPlayer[mBullet[i]->getOwner()]->decScoreMultiplier();
+				players[bullet->getOwner()]->decScoreMultiplier();
 			}
 		}
 	}
@@ -2303,51 +2252,28 @@ void Game::moveBullets()
 // Pinta las balas activas
 void Game::renderBullets()
 {
-	for (int i = 0; i < MAX_BULLETS; i++)
+	for (auto bullet : bullets)
 	{
-		if (mBullet[i]->isActive())
+		if (bullet->isActive())
 		{
-			mBullet[i]->render();
+			bullet->render();
 		}
 	}
 }

-// Devuelve el primer indice no activo del vector de balas
-Uint8 Game::getBulletFreeIndex()
-{
-	for (int i = 0; i < MAX_BULLETS; i++)
-	{
-		if (mBullet[i]->isActive() == false)
-		{
-			return i;
-		}
-	}
-
-	return 0;
-}
-
-// Establece a cero todos los valores del vector de objetos bala
-void Game::resetBullets()
-{
-	for (int i = 0; i < MAX_BULLETS; i++)
-	{
-		mBullet[i]->erase();
-	}
-}
-
 // Crea un objeto bala
 void Game::createBullet(int x, int y, Uint8 kind, bool poweredUp, int owner)
 {
-	mBullet[getBulletFreeIndex()]->init(x, y, kind, poweredUp, owner, mTextureBullet, mRenderer);
+	Bullet *b = new Bullet(x, y, kind, poweredUp, owner, mTextureBullet, mRenderer);
 }

 // Actualiza los items
 void Game::updateItems()
 {
-	for (int i = 0; i < MAX_ITEMS; i++)
+	for (auto item : items)
 	{
-		mItem[i]->update();
-		if (mItem[i]->floorCollision())
+		item->update();
+		if (item->floorCollision())
 		{
 			JA_PlaySound(mSoundCollision);
 			mEffect.shake = true;
@@ -2358,32 +2284,9 @@ void Game::updateItems()
 // Pinta los items activos
 void Game::renderItems()
 {
-	for (int i = 0; i < MAX_ITEMS; i++)
+	for (auto item : items)
 	{
-		mItem[i]->render();
-	}
-}
-
-// Devuelve el primer indice no activo del vector de items
-Uint8 Game::getItemFreeIndex()
-{
-	for (int i = 0; i < MAX_ITEMS; i++)
-	{
-		if (mItem[i]->getClass() == NO_KIND)
-		{
-			return i;
-		}
-	}
-
-	return 0;
-}
-
-// Establece a cero todos los valores del vector de objetos item
-void Game::resetItems()
-{
-	for (int i = 0; i < MAX_ITEMS; i++)
-	{
-		mItem[i]->erase();
+		item->render();
 	}
 }

@@ -2456,24 +2359,26 @@ Uint8 Game::dropItem()
 }

 // Crea un objeto item
-void Game::createItem(int x, int y, Uint8 kind)
+void Game::createItem(LTexture *texture, SDL_Renderer *renderer, Uint8 type, float x, float y)
 {
-	mItem[getItemFreeIndex()]->init(kind, x, y);
+	Item *i = new Item(texture, renderer, type, x, y);
+	items.push_back(i);
 }

 // Crea un objeto SmartSprite para mostrar la puntuación al coger un objeto
 void Game::createItemScoreSprite(int x, int y, SmartSprite *sprite)
 {
-	const Uint8 index = getSmartSpriteFreeIndex();
-
+	SmartSprite *ss = new SmartSprite(nullptr, mRenderer);
+	smartSprites.push_back(ss);
+	
 	// Crea una copia del objeto
-	*mSmartSprite[index] = *sprite;
-	mSmartSprite[index]->setPosX(x);
-	mSmartSprite[index]->setPosY(y);
-	mSmartSprite[index]->setDestX(x);
-	mSmartSprite[index]->setDestY(y - 15);
-	mSmartSprite[index]->setEnabled(true);
-	mSmartSprite[index]->setEnabledTimer(100);
+   *ss = *sprite;
+	ss->setPosX(x);
+	ss->setPosY(y);
+	ss->setDestX(x);
+	ss->setDestY(y - 15);
+	ss->setEnabled(true);
+	ss->setEnabledTimer(100);
 }

 // Dibuja el efecto de flash
@@ -2509,100 +2414,80 @@ void Game::updateShakeEffect()
 // Crea un SmartSprite para arrojar el item café al recibir un impacto
 void Game::throwCoffee(int x, int y)
 {
-	const Uint8 index = getSmartSpriteFreeIndex();
+	SmartSprite *ss = new SmartSprite(nullptr, mRenderer);
+	smartSprites.push_back(ss);

-	mSmartSprite[index]->init();
-	mSmartSprite[index]->setPosX(x - 8);
-	mSmartSprite[index]->setPosY(y - 8);
-	mSmartSprite[index]->setWidth(16);
-	mSmartSprite[index]->setHeight(16);
-	mSmartSprite[index]->setVelX(-1.0f + ((rand() % 5) * 0.5f));
-	mSmartSprite[index]->setVelY(-4.0f);
-	mSmartSprite[index]->setAccelX(0.0f);
-	mSmartSprite[index]->setAccelY(0.2f);
-	mSmartSprite[index]->setDestX(x + (mSmartSprite[index]->getVelX() * 50));
-	mSmartSprite[index]->setDestY(GAME_HEIGHT + 1);
-	mSmartSprite[index]->setEnabled(true);
-	mSmartSprite[index]->setEnabledTimer(1);
-	mSmartSprite[index]->setSpriteClip(80, 16, 16, 16);
-	mSmartSprite[index]->setRotate(true);
-	mSmartSprite[index]->setRotateSpeed(10);
-	mSmartSprite[index]->setRotateAmount(90.0);
+	ss->setPosX(x - 8);
+	ss->setPosY(y - 8);
+	ss->setWidth(16);
+	ss->setHeight(16);
+	ss->setVelX(-1.0f + ((rand() % 5) * 0.5f));
+	ss->setVelY(-4.0f);
+	ss->setAccelX(0.0f);
+	ss->setAccelY(0.2f);
+	ss->setDestX(x + (ss->getVelX() * 50));
+	ss->setDestY(GAME_HEIGHT + 1);
+	ss->setEnabled(true);
+	ss->setEnabledTimer(1);
+	ss->setSpriteClip(80, 16, 16, 16);
+	ss->setRotate(true);
+	ss->setRotateSpeed(10);
+	ss->setRotateAmount(90.0);
 }

 // Crea un SmartSprite para arrojar al jugador al morir
-void Game::throwPlayer(int x, int y, int index)
+void Game::throwPlayer(int x, int y, Player *player)
 {
 	const int sentit = ((rand() % 2) ? 1 : -1);

-	mPlayer[index]->mDeathIndex = getSmartSpriteFreeIndex();
-	// mSmartSprite[mPlayer[index]->mDeathIndex]->init(mPlayer[index]->getDeadTexture(), mRenderer);
-	mSmartSprite[mPlayer[index]->mDeathIndex]->setTexture(mPlayer[index]->getDeadTexture());
-	mSmartSprite[mPlayer[index]->mDeathIndex]->setPosX(x);
-	mSmartSprite[mPlayer[index]->mDeathIndex]->setPosY(y);
-	mSmartSprite[mPlayer[index]->mDeathIndex]->setWidth(24);
-	mSmartSprite[mPlayer[index]->mDeathIndex]->setHeight(24);
-	mSmartSprite[mPlayer[index]->mDeathIndex]->setVelX(2.0f * sentit);
-	mSmartSprite[mPlayer[index]->mDeathIndex]->setVelY(-5.0f);
-	mSmartSprite[mPlayer[index]->mDeathIndex]->setAccelX(0.0f);
-	mSmartSprite[mPlayer[index]->mDeathIndex]->setAccelY(0.2f);
-	mSmartSprite[mPlayer[index]->mDeathIndex]->setDestX(GAME_WIDTH * sentit);
-	mSmartSprite[mPlayer[index]->mDeathIndex]->setDestY(GAME_HEIGHT + 1);
-	mSmartSprite[mPlayer[index]->mDeathIndex]->setEnabled(true);
-	mSmartSprite[mPlayer[index]->mDeathIndex]->setEnabledTimer(1);
-	mSmartSprite[mPlayer[index]->mDeathIndex]->setSpriteClip(0, 0, 24, 24);
+	//player->mDeathIndex = getSmartSpriteFreeIndex();
+
+	SmartSprite *ss = new SmartSprite(nullptr, mRenderer);
+	smartSprites.push_back(ss);
+
+	ss->setTexture(player->getDeadTexture());
+	ss->setPosX(x);
+	ss->setPosY(y);
+	ss->setWidth(24);
+	ss->setHeight(24);
+	ss->setVelX(2.0f * sentit);
+	ss->setVelY(-5.0f);
+	ss->setAccelX(0.0f);
+	ss->setAccelY(0.2f);
+	ss->setDestX(GAME_WIDTH * sentit);
+	ss->setDestY(GAME_HEIGHT + 1);
+	ss->setEnabled(true);
+	ss->setEnabledTimer(1);
+	ss->setSpriteClip(0, 0, 24, 24);
 }

 // Actualiza los SmartSprites
 void Game::updateSmartSprites()
 {
-	for (int i = 0; i < MAX_SMART_SPRITES; i++)
+	for (auto ss:smartSprites)
 	{
-		mSmartSprite[i]->update();
+		ss->update();
 	}
 }

 // Pinta los SmartSprites activos
 void Game::renderSmartSprites()
 {
-	for (int i = 0; i < MAX_SMART_SPRITES; i++)
+	for (auto ss:smartSprites)
 	{
-		mSmartSprite[i]->render();
-	}
-}
-
-// Devuelve el primer indice no activo del vector de SmartSprites
-Uint8 Game::getSmartSpriteFreeIndex()
-{
-	for (int i = 0; i < MAX_SMART_SPRITES; i++)
-	{
-		if (!mSmartSprite[i]->isEnabled())
-		{
-			return i;
-		}
-	}
-
-	return 0;
-}
-
-// Establece a cero todos los valores del vector de objetos SmafrtSprite
-void Game::resetSmartSprites()
-{
-	for (int i = 0; i < MAX_SMART_SPRITES; i++)
-	{
-		mSmartSprite[i]->init();
+		ss->render();
 	}
 }

 // Acciones a realizar cuando el jugador muere
 void Game::killPlayer(Player *player)
 {
-	if (!mPlayer[index]->isInvulnerable())
+	if (!player->isInvulnerable())
 	{
-		if (mPlayer[index]->hasExtraHit())
+		if (player->hasExtraHit())
 		{
-			mPlayer[index]->removeExtraHit();
-			throwCoffee(mPlayer[index]->getPosX() + (mPlayer[index]->getWidth() / 2), mPlayer[index]->getPosY() + (mPlayer[index]->getHeight() / 2));
+			player->removeExtraHit();
+			throwCoffee(player->getPosX() + (player->getWidth() / 2), player->getPosY() + (player->getHeight() / 2));
 			JA_PlaySound(mSoundCoffeeOut);
 		}
 		else
@@ -2613,8 +2498,8 @@ void Game::killPlayer(Player *player)
 			shakeScreen();
 			SDL_Delay(500);
 			JA_PlaySound(mSoundCoffeeOut);
-			throwPlayer(mPlayer[index]->getPosX(), mPlayer[index]->getPosY(), index);
-			mPlayer[index]->setAlive(false);
+			throwPlayer(player->getPosX(), player->getPosY(), player);
+			player->setAlive(false);
 			if (allPlayersAreDead())
 			{
 				JA_StopMusic();
@@ -2631,11 +2516,11 @@ void Game::killPlayer(Player *player)
 void Game::evaluateAndSetMenace()
 {
 	mMenaceCurrent = 0;
-	for (int i = 0; i < MAX_BALLOONS; i++)
+	for (auto balloon:balloons)
 	{
-		if (mBalloon[i]->isEnabled())
+		if (balloon->isEnabled())
 		{
-			mMenaceCurrent += mBalloon[i]->getMenace();
+			mMenaceCurrent += balloon->getMenace();
 		}
 	}
 }
@@ -2828,12 +2713,12 @@ void Game::renderPlayField()
 	renderSmartSprites();
 	renderScoreBoard();

-	for (int i = 0; i < mNumPlayers; i++)
+	for (auto player:players)
 	{
-		mPlayer[i]->render();
+		player->render();
 	}

-	if ((mDeathCounter <= 150) && !mPlayer[0]->isAlive())
+	if ((mDeathCounter <= 150) && !players[0]->isAlive())
 	{
 		renderDeathFade(150 - mDeathCounter);
 	}
@@ -2882,45 +2767,45 @@ void Game::checkGameInput()
 		const int index = 0;
 		if (mDemo.dataFile[mDemo.counter].left == 1)
 		{
-			mPlayer[index]->setInput(INPUT_LEFT);
+			players[index]->setInput(INPUT_LEFT);
 		}

 		if (mDemo.dataFile[mDemo.counter].right == 1)
 		{
-			mPlayer[index]->setInput(INPUT_RIGHT);
+			players[index]->setInput(INPUT_RIGHT);
 		}

 		if (mDemo.dataFile[mDemo.counter].noInput == 1)
 		{
-			mPlayer[index]->setInput(INPUT_NULL);
+			players[index]->setInput(INPUT_NULL);
 		}

 		if (mDemo.dataFile[mDemo.counter].fire == 1)
 		{
-			if (mPlayer[index]->canFire())
+			if (players[index]->canFire())
 			{
-				mPlayer[index]->setInput(INPUT_BUTTON_2);
-				createBullet(mPlayer[index]->getPosX() + (mPlayer[index]->getWidth() / 2) - 4, mPlayer[index]->getPosY() + (mPlayer[index]->getHeight() / 2), BULLET_UP, mPlayer[index]->isPowerUp(), index);
-				mPlayer[index]->setFireCooldown(10);
+				players[index]->setInput(INPUT_BUTTON_2);
+				createBullet(players[index]->getPosX() + (players[index]->getWidth() / 2) - 4, players[index]->getPosY() + (players[index]->getHeight() / 2), BULLET_UP, players[index]->isPowerUp(), index);
+				players[index]->setFireCooldown(10);
 			}
 		}
 		if (mDemo.dataFile[mDemo.counter].fireLeft == 1)
 		{
-			if (mPlayer[index]->canFire())
+			if (players[index]->canFire())
 			{
-				mPlayer[index]->setInput(INPUT_BUTTON_1);
-				createBullet(mPlayer[index]->getPosX() + (mPlayer[index]->getWidth() / 2) - 4, mPlayer[index]->getPosY() + (mPlayer[index]->getHeight() / 2), BULLET_UP, mPlayer[index]->isPowerUp(), index);
-				mPlayer[index]->setFireCooldown(10);
+				players[index]->setInput(INPUT_BUTTON_1);
+				createBullet(players[index]->getPosX() + (players[index]->getWidth() / 2) - 4, players[index]->getPosY() + (players[index]->getHeight() / 2), BULLET_UP, players[index]->isPowerUp(), index);
+				players[index]->setFireCooldown(10);
 			}
 		}

 		if (mDemo.dataFile[mDemo.counter].fireRight == 1)
 		{
-			if (mPlayer[index]->canFire())
+			if (players[index]->canFire())
 			{
-				mPlayer[index]->setInput(INPUT_BUTTON_3);
-				createBullet(mPlayer[index]->getPosX() + (mPlayer[index]->getWidth() / 2) - 4, mPlayer[index]->getPosY() + (mPlayer[index]->getHeight() / 2), BULLET_UP, mPlayer[index]->isPowerUp(), index);
-				mPlayer[index]->setFireCooldown(10);
+				players[index]->setInput(INPUT_BUTTON_3);
+				createBullet(players[index]->getPosX() + (players[index]->getWidth() / 2) - 4, players[index]->getPosY() + (players[index]->getHeight() / 2), BULLET_UP, players[index]->isPowerUp(), index);
+				players[index]->setFireCooldown(10);
 			}
 		}

@@ -2943,14 +2828,15 @@ void Game::checkGameInput()
 	// Modo Demo no activo
 	else
 	{
-		for (int i = 0; i < mNumPlayers; i++)
+		int i = 0;
+		for (auto player:players)
 		{
-			if (mPlayer[i]->isAlive())
+			if (player->isAlive())
 			{
 				// Input a la izquierda
 				if (mInput->checkInput(INPUT_LEFT, REPEAT_TRUE, mOptions->input[i].deviceType, mOptions->input[i].id))
 				{
-					mPlayer[i]->setInput(INPUT_LEFT);
+					player->setInput(INPUT_LEFT);
 					mDemo.keys.left = 1;
 				}
 				else
@@ -2958,24 +2844,24 @@ void Game::checkGameInput()
 					// Input a la derecha
 					if (mInput->checkInput(INPUT_RIGHT, REPEAT_TRUE, mOptions->input[i].deviceType, mOptions->input[i].id))
 					{
-						mPlayer[i]->setInput(INPUT_RIGHT);
+						player->setInput(INPUT_RIGHT);
 						mDemo.keys.right = 1;
 					}
 					else
 					{
 						// Ninguno de los dos inputs anteriores
-						mPlayer[i]->setInput(INPUT_NULL);
+						player->setInput(INPUT_NULL);
 						mDemo.keys.noInput = 1;
 					}
 				}
 				// Comprueba el input de disparar al centro
 				if (mInput->checkInput(INPUT_BUTTON_2, REPEAT_TRUE, mOptions->input[i].deviceType, mOptions->input[i].id))
 				{
-					if (mPlayer[i]->canFire())
+					if (player->canFire())
 					{
-						mPlayer[i]->setInput(INPUT_BUTTON_2);
-						createBullet(mPlayer[i]->getPosX() + (mPlayer[i]->getWidth() / 2) - 4, mPlayer[i]->getPosY() + (mPlayer[i]->getHeight() / 2), BULLET_UP, mPlayer[i]->isPowerUp(), i);
-						mPlayer[i]->setFireCooldown(10);
+						player->setInput(INPUT_BUTTON_2);
+						createBullet(player->getPosX() + (player->getWidth() / 2) - 4, player->getPosY() + (player->getHeight() / 2), BULLET_UP, player->isPowerUp(), i);
+						player->setFireCooldown(10);

 						// Reproduce el sonido de disparo
 						JA_PlaySound(mSoundBullet);
@@ -2987,11 +2873,11 @@ void Game::checkGameInput()
 				// Comprueba el input de disparar a la izquierda
 				if (mInput->checkInput(INPUT_BUTTON_1, REPEAT_TRUE, mOptions->input[i].deviceType, mOptions->input[i].id))
 				{
-					if (mPlayer[i]->canFire())
+					if (player->canFire())
 					{
-						mPlayer[i]->setInput(INPUT_BUTTON_1);
-						createBullet(mPlayer[i]->getPosX() + (mPlayer[i]->getWidth() / 2) - 4, mPlayer[i]->getPosY() + (mPlayer[i]->getHeight() / 2), BULLET_LEFT, mPlayer[i]->isPowerUp(), i);
-						mPlayer[i]->setFireCooldown(10);
+						player->setInput(INPUT_BUTTON_1);
+						createBullet(player->getPosX() + (player->getWidth() / 2) - 4, player->getPosY() + (player->getHeight() / 2), BULLET_LEFT, player->isPowerUp(), i);
+						player->setFireCooldown(10);

 						// Reproduce el sonido de disparo
 						JA_PlaySound(mSoundBullet);
@@ -3003,11 +2889,11 @@ void Game::checkGameInput()
 				// Comprueba el input de disparar a la derecha
 				if (mInput->checkInput(INPUT_BUTTON_3, REPEAT_TRUE, mOptions->input[i].deviceType, mOptions->input[i].id))
 				{
-					if (mPlayer[i]->canFire())
+					if (player->canFire())
 					{
-						mPlayer[i]->setInput(INPUT_BUTTON_3);
-						createBullet(mPlayer[i]->getPosX() + (mPlayer[i]->getWidth() / 2) - 4, mPlayer[i]->getPosY() + (mPlayer[i]->getHeight() / 2), BULLET_RIGHT, mPlayer[i]->isPowerUp(), i);
-						mPlayer[i]->setFireCooldown(10);
+						player->setInput(INPUT_BUTTON_3);
+						createBullet(player->getPosX() + (player->getWidth() / 2) - 4, player->getPosY() + (player->getHeight() / 2), BULLET_RIGHT, player->isPowerUp(), i);
+						player->setFireCooldown(10);

 						// Reproduce el sonido de disparo
 						JA_PlaySound(mSoundBullet);
@@ -3039,6 +2925,8 @@ void Game::checkGameInput()
 				{
 					mSection.name = PROG_SECTION_QUIT;
 				}
+
+				i++;
 			}
 		}
 	}
@@ -3170,9 +3058,9 @@ void Game::shakeScreen()
 		renderBalloons();
 		renderBullets();
 		renderItems();
-		for (int i = 0; i < mNumPlayers; i++)
+		for (auto player:players)
 		{
-			mPlayer[i]->render();
+			player->render();
 		}
 		renderScoreBoard();

@@ -3210,7 +3098,7 @@ section_t Game::run()
 				// Reproduce la música
 				if (!mGameCompleted)
 				{
-					if (mPlayer[0]->isAlive())
+					if (players[0]->isAlive())
 					{
 						JA_PlayMusic(mMusicPlaying);
 					}
@@ -3420,13 +3308,13 @@ void Game::runGameOverScreen()
 		if (mNumPlayers == 1)
 		{
 			mTextBig->writeCentered(PLAY_AREA_CENTER_X, PLAY_AREA_CENTER_Y - (BLOCK * 4), mLang->getText(43));
-			mText->writeCentered(PLAY_AREA_CENTER_X, PLAY_AREA_CENTER_Y - (BLOCK * 1), mLang->getText(44) + std::to_string(mPlayer[0]->getScore()));
+			mText->writeCentered(PLAY_AREA_CENTER_X, PLAY_AREA_CENTER_Y - (BLOCK * 1), mLang->getText(44) + std::to_string(players[0]->getScore()));
 		}
 		else
 		{
 			mTextBig->writeCentered(PLAY_AREA_CENTER_X, PLAY_AREA_CENTER_Y - 36, mLang->getText(43));
-			mText->writeCentered(PLAY_AREA_CENTER_X, PLAY_AREA_CENTER_Y - 12, mLang->getText(77) + std::to_string(mPlayer[0]->getScore()));
-			mText->writeCentered(PLAY_AREA_CENTER_X, PLAY_AREA_CENTER_Y, mLang->getText(78) + std::to_string(mPlayer[1]->getScore()));
+			mText->writeCentered(PLAY_AREA_CENTER_X, PLAY_AREA_CENTER_Y - 12, mLang->getText(77) + std::to_string(players[0]->getScore()));
+			mText->writeCentered(PLAY_AREA_CENTER_X, PLAY_AREA_CENTER_Y, mLang->getText(78) + std::to_string(players[1]->getScore()));
 		}
 		mText->writeCentered(PLAY_AREA_CENTER_X, PLAY_AREA_CENTER_Y + BLOCK * 2, mLang->getText(45));
 		mMenuGameOver->render();
@@ -3470,7 +3358,7 @@ void Game::renderDebugInfo()
 		mText->writeShadowed(2, 2 + 3 * BLOCK, "mCounter:     " + std::to_string(mCounter), color);
 		mText->writeShadowed(2, 2 + 4 * BLOCK, "(R)enemyset:  " + std::to_string(mDebug.enemySet), color);
 		mText->writeShadowed(2, 2 + 5 * BLOCK, "RGB:          " + std::to_string(mDebug.gradR) + "," + std::to_string(mDebug.gradG) + "," + std::to_string(mDebug.gradB), color);
-		mText->writeShadowed(2, 2 + 6 * BLOCK, "(I)invuln:    " + std::to_string(mPlayer[0]->getInvulnerableCounter()), color);
+		mText->writeShadowed(2, 2 + 6 * BLOCK, "(I)invuln:    " + std::to_string(players[0]->getInvulnerableCounter()), color);
 		mText->writeShadowed(2, 2 + 7 * BLOCK, "balloons:     " + std::to_string(countBalloons()), color);
 		mText->writeShadowed(2, 2 + 8 * BLOCK, "balloonsPop:  " + std::to_string(mBalloonsPopped), color);
 		mText->writeShadowed(2, 2 + 9 * BLOCK, "(Z-X)ballSped:" + std::to_string(mEnemySpeed), color);
@@ -3494,11 +3382,11 @@ int Game::calculateScreenPower()
 {
 	int power = 0;

-	for (int i = 0; i < MAX_BALLOONS; i++)
+	for (auto balloon:balloons)
 	{
-		if (mBalloon[i]->isEnabled())
+		if (balloon->isEnabled())
 		{
-			power += mBalloon[i]->getPower();
+			power += balloon->getPower();
 		}
 	}

@@ -3585,9 +3473,9 @@ void Game::updateHelper()
 	// Solo ofrece ayuda cuando la amenaza es elevada
 	if (mMenaceCurrent > 15)
 	{
-		for (int i = 0; i < mNumPlayers; i++)
+		for (auto player:players)
 		{
-			if (mPlayer[i]->getCoffees() == 0)
+			if (player->getCoffees() == 0)
 			{
 				mHelper.needCoffee = true;
 			}
@@ -3596,7 +3484,7 @@ void Game::updateHelper()
 				mHelper.needCoffee = false;
 			}

-			if (!mPlayer[i]->isPowerUp())
+			if (!player->isPowerUp())
 			{
 				mHelper.needCoffeeMachine = true;
 			}
@@ -3617,9 +3505,9 @@ void Game::updateHelper()
 bool Game::allPlayersAreDead()
 {
 	bool success = true;
-	for (int i = 0; i < mNumPlayers; i++)
+	for (auto player:players)
 	{
-		success &= (!mPlayer[i]->isAlive());
+		success &= (!player->isAlive());
 	}

 	return success;