diff --git a/source/animatedsprite.cpp b/source/animatedsprite.cpp
index 3e22cda..b1ea650 100644
--- a/source/animatedsprite.cpp
+++ b/source/animatedsprite.cpp
@@ -151,6 +151,12 @@ SDL_Rect AnimatedSprite::getAnimationClip(std::string name, Uint8 index)
 	return animation[getIndex(name)].frames[index];
 }
 
+// Devuelve el rectangulo de una animación y frame concreto
+SDL_Rect AnimatedSprite::getAnimationClip(int indexA, Uint8 indexF)
+{
+	return animation[indexA].frames[indexF];
+}
+
 // Carga la animación desde un fichero
 bool AnimatedSprite::load(std::string filePath)
 {
diff --git a/source/animatedsprite.h b/source/animatedsprite.h
index 4d843a3..4776b65 100644
--- a/source/animatedsprite.h
+++ b/source/animatedsprite.h
@@ -60,6 +60,7 @@ public:
 
     // Devuelve el rectangulo de una animación y frame concreto
     SDL_Rect getAnimationClip(std::string name, Uint8 index);
+    SDL_Rect getAnimationClip(int indexA, Uint8 indexF);
 
     // Obtiene el indice de la animación a partir del nombre
     int getIndex(std::string name);
diff --git a/source/bullet.cpp b/source/bullet.cpp
index 73e10ed..2b58743 100644
--- a/source/bullet.cpp
+++ b/source/bullet.cpp
@@ -2,22 +2,10 @@
 #include "bullet.h"
 
 // Constructor
-Bullet::Bullet()
+Bullet::Bullet(int x, int y, int kind, bool poweredUp, int owner, LTexture *texture, SDL_Renderer *renderer)
 {
-	mSprite = new Sprite();
-	mKind = NO_KIND;
-}
+	mSprite = new Sprite({x,y,10,10},texture, renderer);
 
-// Destructor
-Bullet::~Bullet()
-{
-	delete mSprite;
-	mSprite = nullptr;
-}
-
-// Iniciador
-void Bullet::init(int x, int y, int kind, bool poweredUp, int owner, LTexture *texture, SDL_Renderer *renderer)
-{
 	// Posición inicial del objeto
 	mPosX = x;
 	mPosY = y;
@@ -35,20 +23,6 @@ void Bullet::init(int x, int y, int kind, bool poweredUp, int owner, LTexture *t
 	// Identificador del dueño del objeto
 	mOwner = owner;
 
-	// Textura con los gráficos del objeto
-	mSprite->setTexture(texture);
-
-	// Renderizador
-	mSprite->setRenderer(renderer);
-
-	// Alto y ancho del sprite
-	mSprite->setWidth(mWidth);
-	mSprite->setHeight(mHeight);
-
-	// Posición inicial del sprite
-	mSprite->setPosX(mPosX);
-	mSprite->setPosY(mPosY);
-
 	// Valores especificos según el tipo
 	switch (kind)
 	{
@@ -96,6 +70,13 @@ void Bullet::init(int x, int y, int kind, bool poweredUp, int owner, LTexture *t
 	shiftColliders();
 }
 
+// Destructor
+Bullet::~Bullet()
+{
+	delete mSprite;
+	mSprite = nullptr;
+}
+
 // Pinta el objeto en pantalla
 void Bullet::render()
 {
@@ -144,12 +125,6 @@ Uint8 Bullet::move()
 	return msg;
 }
 
-// Deshabilita el objeto
-void Bullet::erase()
-{
-	init(0, 0, 0, false, -1, nullptr, nullptr);
-}
-
 // Comprueba si el objeto está activo
 bool Bullet::isActive()
 {
diff --git a/source/bullet.h b/source/bullet.h
index 5077242..730a978 100644
--- a/source/bullet.h
+++ b/source/bullet.h
@@ -36,23 +36,17 @@ private:
 
 public:
 	// Constructor
-	Bullet();
+	Bullet(int x, int y, int kind, bool poweredUp, int owner, LTexture *texture, SDL_Renderer *renderer);
 
 	// Destructor
 	~Bullet();
 
-	// Iniciador
-	void init(int x, int y, int kind, bool poweredUp, int owner, LTexture *texture, SDL_Renderer *renderer);
-
 	// Pinta el objeto en pantalla
 	void render();
 
 	// Actualiza la posición y estado del objeto
 	Uint8 move();
 
-	// Deshabilita el objeto
-	void erase();
-
 	// Comprueba si el objeto está activo
 	bool isActive();
 
diff --git a/source/game.cpp b/source/game.cpp
index 72eff4c..22d5e6e 100644
--- 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;
diff --git a/source/game.h b/source/game.h
index ec06ff6..4fa0720 100644
--- a/source/game.h
+++ b/source/game.h
@@ -134,15 +134,9 @@ private:
 	Lang *mLang;			 // Objeto para gestionar los textos en diferentes idiomas
 	Input *mInput;			 // Manejador de entrada
 
-	// Player *mPlayer[2]; // Vector con los jugadores jugador
-	// Balloon *mBalloon[MAX_BALLOONS];			  // Vector con los objetos globo
-	// Bullet *mBullet[MAX_BULLETS];				  // Vector con los objetos bala
-	// Item *mItem[MAX_ITEMS];						  // Vector con los objetos item
-	// SmartSprite *mSmartSprite[MAX_SMART_SPRITES]; // Vector para almacenar y gestionar SmartSprites
-
 	int mNumPlayers;						 // Numero de jugadores
 	std::vector<Player *> players;			 // Vector con los jugadores
-	std::vector<Balloon *> balloons;			 // Vector con los globos
+	std::vector<Balloon *> balloons;		 // Vector con los globos
 	std::vector<Bullet *> bullets;			 // Vector con las balas
 	std::vector<Item *> items;				 // Vector con los items
 	std::vector<SmartSprite *> smartSprites; // Vector con los smartsprites
@@ -322,9 +316,6 @@ private:
 	// Crea una PowerBall
 	void createPowerBall();
 
-	// Establece a cero todos los valores del vector de objetos globo
-	void resetBalloons();
-
 	// Establece la velocidad de los globos
 	void setBalloonSpeed(float speed);
 
@@ -373,9 +364,6 @@ private:
 	// Pinta las balas activas
 	void renderBullets();
 
-	// Establece a cero todos los valores del vector de objetos bala
-	void resetBullets();
-
 	// Crea un objeto bala
 	void createBullet(int x, int y, Uint8 kind, bool poweredUp, int owner);
 
@@ -385,14 +373,11 @@ private:
 	// Pinta los items activos
 	void renderItems();
 
-	// Establece a cero todos los valores del vector de objetos item
-	void resetItems();
-
 	// Devuelve un item en función del azar
 	Uint8 dropItem();
 
 	// Crea un objeto item
-	void createItem(int x, int y, Uint8 kind);
+	void createItem(LTexture *texture, SDL_Renderer *renderer, Uint8 type, float x, float y);
 
 	// Crea un objeto SmartSprite
 	void createItemScoreSprite(int x, int y, SmartSprite *sprite);
@@ -407,7 +392,7 @@ private:
 	void throwCoffee(int x, int y);
 
 	// Crea un SmartSprite para arrojar al jugador al morir
-	void throwPlayer(int x, int y, int index);
+	void throwPlayer(int x, int y, Player *player);
 
 	// Actualiza los SmartSprites
 	void updateSmartSprites();
@@ -415,9 +400,6 @@ private:
 	// Pinta los SmartSprites activos
 	void renderSmartSprites();
 
-	// Establece a cero todos los valores del vector de objetos SmafrtSprite
-	void resetSmartSprites();
-
 	// Acciones a realizar cuando el jugador muere
 	void killPlayer(Player *player);
 
diff --git a/source/intro.cpp b/source/intro.cpp
index ece060c..d84a278 100644
--- a/source/intro.cpp
+++ b/source/intro.cpp
@@ -74,7 +74,6 @@ void Intro::init()
 	// Inicializa los bitmaps de la intro
 	for (int i = 0; i < INTRO_TOTAL_BITMAPS; i++)
 	{
-		mBitmap[i]->init();
 		mBitmap[i]->setId(i);
 		mBitmap[i]->setIntroEvents(&mEvents[0]);
 		mBitmap[i]->setWidth(128);
diff --git a/source/item.cpp b/source/item.cpp
index 173c598..52f08b9 100644
--- a/source/item.cpp
+++ b/source/item.cpp
@@ -2,22 +2,10 @@
 #include "item.h"
 
 // Constructor
-Item::Item(LTexture *texture, SDL_Renderer *renderer)
+Item::Item(LTexture *texture, SDL_Renderer *renderer, Uint8 type, float x, float y)
 {
 	mSprite = new AnimatedSprite(texture, renderer);
-	init(NO_KIND, 0.0f, 0.0f);
-}
 
-// Destructor
-Item::~Item()
-{
-	delete mSprite;
-	mSprite = nullptr;
-}
-
-// Inicializador
-void Item::init(Uint8 type, float x, float y)
-{
 	mClass = type;
 	mEnabled = true;
 	mTimeToLive = 600;
@@ -104,6 +92,13 @@ void Item::init(Uint8 type, float x, float y)
 	}
 }
 
+// Destructor
+Item::~Item()
+{
+	delete mSprite;
+	mSprite = nullptr;
+}
+
 // Centra el objeto en la posición X
 void Item::allignTo(int x)
 {
diff --git a/source/item.h b/source/item.h
index d7c9eaf..fda6bbb 100644
--- a/source/item.h
+++ b/source/item.h
@@ -43,14 +43,11 @@ public:
     Uint16 mTimeToLive; // Temporizador con el tiempo que el objeto está presente
 
     // Constructor
-    Item(LTexture *texture, SDL_Renderer *renderer);
+    Item(LTexture *texture, SDL_Renderer *renderer, Uint8 type, float x, float y);
 
     // Destructor
     ~Item();
 
-    // Inicializador
-    void init(Uint8 type, float x, float y);
-
     // Centra el objeto en la posición X
     void allignTo(int x);
 
diff --git a/source/player.cpp b/source/player.cpp
index eb8f7bf..c9a0c40 100644
--- a/source/player.cpp
+++ b/source/player.cpp
@@ -75,11 +75,6 @@ void Player::init()
 	// Inicia el contador para la cadencia de disparo
 	mCooldown = 10;
 
-	// Inicia el sprite
-	mSpriteLegs->init();
-	mSpriteBody->init();
-	mSpriteHead->init();
-
 	// Establece el alto y ancho del sprite
 	mSpriteLegs->setWidth(mWidth);
 	mSpriteLegs->setHeight(mHeight);
@@ -110,25 +105,6 @@ void Player::init()
 	mSpriteHead->setCurrentFrame(0);
 	mSpriteHead->setAnimationCounter(0);
 
-	// Establece el numero de frames de cada animacion
-	mSpriteLegs->setAnimationNumFrames(PLAYER_ANIMATION_LEGS_WALKING_STOP, 4);
-	mSpriteLegs->setAnimationNumFrames(PLAYER_ANIMATION_LEGS_WALKING_LEFT, 4);
-	mSpriteLegs->setAnimationNumFrames(PLAYER_ANIMATION_LEGS_WALKING_RIGHT, 4);
-
-	mSpriteBody->setAnimationNumFrames(PLAYER_ANIMATION_BODY_WALKING_LEFT, 4);
-	mSpriteBody->setAnimationNumFrames(PLAYER_ANIMATION_BODY_FIRING_LEFT, 4);
-	mSpriteBody->setAnimationNumFrames(PLAYER_ANIMATION_BODY_WALKING_RIGHT, 4);
-	mSpriteBody->setAnimationNumFrames(PLAYER_ANIMATION_BODY_FIRING_RIGHT, 4);
-	mSpriteBody->setAnimationNumFrames(PLAYER_ANIMATION_BODY_WALKING_STOP, 4);
-	mSpriteBody->setAnimationNumFrames(PLAYER_ANIMATION_BODY_FIRING_UP, 4);
-
-	mSpriteHead->setAnimationNumFrames(PLAYER_ANIMATION_HEAD_WALKING_LEFT, 4);
-	mSpriteHead->setAnimationNumFrames(PLAYER_ANIMATION_HEAD_FIRING_LEFT, 4);
-	mSpriteHead->setAnimationNumFrames(PLAYER_ANIMATION_HEAD_WALKING_RIGHT, 4);
-	mSpriteHead->setAnimationNumFrames(PLAYER_ANIMATION_HEAD_FIRING_RIGHT, 4);
-	mSpriteHead->setAnimationNumFrames(PLAYER_ANIMATION_HEAD_WALKING_STOP, 4);
-	mSpriteHead->setAnimationNumFrames(PLAYER_ANIMATION_HEAD_FIRING_UP, 4);
-
 	// Establece la velocidad de cada animación
 	mSpriteLegs->setAnimationSpeed(PLAYER_ANIMATION_LEGS_WALKING_STOP, 10);
 	mSpriteLegs->setAnimationSpeed(PLAYER_ANIMATION_LEGS_WALKING_LEFT, 5);
@@ -381,100 +357,134 @@ void Player::setAnimation()
 	switch (mStatusWalking)
 	{
 	case PLAYER_STATUS_WALKING_LEFT:
-		mSpriteLegs->animate(PLAYER_ANIMATION_LEGS_WALKING_LEFT);
+		mSpriteLegs->setCurrentAnimation(PLAYER_ANIMATION_LEGS_WALKING_LEFT);
+		mSpriteLegs->animate();
 		switch (mStatusFiring)
 		{
 		case PLAYER_STATUS_FIRING_UP:
-			mSpriteBody->animate(PLAYER_ANIMATION_BODY_FIRING_UP);
-			mSpriteHead->animate(PLAYER_ANIMATION_HEAD_FIRING_UP);
+			mSpriteBody->setCurrentAnimation(PLAYER_ANIMATION_BODY_FIRING_UP);
+			mSpriteBody->animate();
+			mSpriteHead->setCurrentAnimation(PLAYER_ANIMATION_HEAD_FIRING_UP);
+			mSpriteHead->animate();
 			break;
 
 		case PLAYER_STATUS_FIRING_LEFT:
-			mSpriteBody->animate(PLAYER_ANIMATION_BODY_FIRING_LEFT);
-			mSpriteHead->animate(PLAYER_ANIMATION_HEAD_FIRING_LEFT);
+			mSpriteBody->setCurrentAnimation(PLAYER_ANIMATION_BODY_FIRING_LEFT);
+			mSpriteBody->animate();
+			mSpriteHead->setCurrentAnimation(PLAYER_ANIMATION_HEAD_FIRING_LEFT);
+			mSpriteHead->animate();
 			break;
 
 		case PLAYER_STATUS_FIRING_RIGHT:
-			mSpriteBody->animate(PLAYER_ANIMATION_BODY_FIRING_RIGHT);
-			mSpriteHead->animate(PLAYER_ANIMATION_HEAD_FIRING_RIGHT);
+			mSpriteBody->setCurrentAnimation(PLAYER_ANIMATION_BODY_FIRING_RIGHT);
+			mSpriteBody->animate();
+			mSpriteHead->setCurrentAnimation(PLAYER_ANIMATION_HEAD_FIRING_RIGHT);
+			mSpriteHead->animate();
 			break;
 
 		case PLAYER_STATUS_FIRING_NO:
-			mSpriteBody->animate(PLAYER_ANIMATION_BODY_WALKING_LEFT);
-			mSpriteHead->animate(PLAYER_ANIMATION_HEAD_WALKING_LEFT);
+			mSpriteBody->setCurrentAnimation(PLAYER_ANIMATION_BODY_WALKING_LEFT);
+			mSpriteBody->animate();
+			mSpriteHead->setCurrentAnimation(PLAYER_ANIMATION_HEAD_WALKING_LEFT);
+			mSpriteHead->animate();
 			break;
 
 		default:
-			mSpriteBody->animate(PLAYER_ANIMATION_BODY_WALKING_STOP);
-			mSpriteHead->animate(PLAYER_ANIMATION_HEAD_WALKING_STOP);
+			mSpriteBody->setCurrentAnimation(PLAYER_ANIMATION_BODY_WALKING_STOP);
+			mSpriteBody->animate();
+			mSpriteHead->setCurrentAnimation(PLAYER_ANIMATION_HEAD_WALKING_STOP);
+			mSpriteHead->animate();
 			break;
 		}
 		break;
 
 	case PLAYER_STATUS_WALKING_RIGHT:
-		mSpriteLegs->animate(PLAYER_ANIMATION_LEGS_WALKING_RIGHT);
+		mSpriteLegs->setCurrentAnimation(PLAYER_ANIMATION_LEGS_WALKING_RIGHT);
+		mSpriteLegs->animate();
 		switch (mStatusFiring)
 		{
 		case PLAYER_STATUS_FIRING_UP:
-			mSpriteBody->animate(PLAYER_ANIMATION_BODY_FIRING_UP);
-			mSpriteHead->animate(PLAYER_ANIMATION_HEAD_FIRING_UP);
+			mSpriteBody->setCurrentAnimation(PLAYER_ANIMATION_BODY_FIRING_UP);
+			mSpriteBody->animate();
+			mSpriteHead->setCurrentAnimation(PLAYER_ANIMATION_HEAD_FIRING_UP);
+			mSpriteHead->animate();
 			break;
 
 		case PLAYER_STATUS_FIRING_LEFT:
-			mSpriteBody->animate(PLAYER_ANIMATION_BODY_FIRING_LEFT);
-			mSpriteHead->animate(PLAYER_ANIMATION_HEAD_FIRING_LEFT);
+			mSpriteBody->setCurrentAnimation(PLAYER_ANIMATION_BODY_FIRING_LEFT);
+			mSpriteBody->animate();
+			mSpriteHead->setCurrentAnimation(PLAYER_ANIMATION_HEAD_FIRING_LEFT);
+			mSpriteHead->animate();
 			break;
 
 		case PLAYER_STATUS_FIRING_RIGHT:
-			mSpriteBody->animate(PLAYER_ANIMATION_BODY_FIRING_RIGHT);
-			mSpriteHead->animate(PLAYER_ANIMATION_HEAD_FIRING_RIGHT);
+			mSpriteBody->setCurrentAnimation(PLAYER_ANIMATION_BODY_FIRING_RIGHT);
+			mSpriteBody->animate();
+			mSpriteHead->setCurrentAnimation(PLAYER_ANIMATION_HEAD_FIRING_RIGHT);
+			mSpriteHead->animate();
 			break;
 
 		case PLAYER_STATUS_FIRING_NO:
-			mSpriteBody->animate(PLAYER_ANIMATION_BODY_WALKING_RIGHT);
-			mSpriteHead->animate(PLAYER_ANIMATION_HEAD_WALKING_RIGHT);
+			mSpriteBody->setCurrentAnimation(PLAYER_ANIMATION_BODY_WALKING_RIGHT);
+			mSpriteBody->animate();
+			mSpriteHead->setCurrentAnimation(PLAYER_ANIMATION_HEAD_WALKING_RIGHT);
+			mSpriteHead->animate();
 			break;
 
 		default:
-			mSpriteBody->animate(PLAYER_ANIMATION_BODY_WALKING_STOP);
-			mSpriteHead->animate(PLAYER_ANIMATION_HEAD_WALKING_STOP);
+			mSpriteBody->setCurrentAnimation(PLAYER_ANIMATION_BODY_WALKING_STOP);
+			mSpriteBody->animate();
+			mSpriteHead->setCurrentAnimation(PLAYER_ANIMATION_HEAD_WALKING_STOP);
+			mSpriteHead->animate();
 			break;
 		}
 		break;
 
 	case PLAYER_STATUS_WALKING_STOP:
-		mSpriteLegs->animate(PLAYER_ANIMATION_LEGS_WALKING_STOP);
+		mSpriteLegs->setCurrentAnimation(PLAYER_ANIMATION_LEGS_WALKING_STOP);
+		mSpriteLegs->animate();
 		switch (mStatusFiring)
 		{
 		case PLAYER_STATUS_FIRING_UP:
-			mSpriteBody->animate(PLAYER_ANIMATION_BODY_FIRING_UP);
-			mSpriteHead->animate(PLAYER_ANIMATION_HEAD_FIRING_UP);
+			mSpriteBody->setCurrentAnimation(PLAYER_ANIMATION_BODY_FIRING_UP);
+			mSpriteBody->animate();
+			mSpriteHead->setCurrentAnimation(PLAYER_ANIMATION_HEAD_FIRING_UP);
+			mSpriteHead->animate();
 			break;
 
 		case PLAYER_STATUS_FIRING_LEFT:
-			mSpriteBody->animate(PLAYER_ANIMATION_BODY_FIRING_LEFT);
-			mSpriteHead->animate(PLAYER_ANIMATION_HEAD_FIRING_LEFT);
+			mSpriteBody->setCurrentAnimation(PLAYER_ANIMATION_BODY_FIRING_LEFT);
+			mSpriteBody->animate();
+			mSpriteHead->setCurrentAnimation(PLAYER_ANIMATION_HEAD_FIRING_LEFT);
+			mSpriteHead->animate();
 			break;
 
 		case PLAYER_STATUS_FIRING_RIGHT:
-			mSpriteBody->animate(PLAYER_ANIMATION_BODY_FIRING_RIGHT);
-			mSpriteHead->animate(PLAYER_ANIMATION_HEAD_FIRING_RIGHT);
+			mSpriteBody->setCurrentAnimation(PLAYER_ANIMATION_BODY_FIRING_RIGHT);
+			mSpriteBody->animate();
+			mSpriteHead->setCurrentAnimation(PLAYER_ANIMATION_HEAD_FIRING_RIGHT);
+			mSpriteHead->animate();
 			break;
 
 		case PLAYER_STATUS_FIRING_NO:
-			mSpriteBody->animate(PLAYER_ANIMATION_BODY_WALKING_STOP);
-			mSpriteHead->animate(PLAYER_ANIMATION_HEAD_WALKING_STOP);
+			mSpriteBody->setCurrentAnimation(PLAYER_ANIMATION_BODY_WALKING_STOP);
+			mSpriteBody->animate();
+			mSpriteHead->setCurrentAnimation(PLAYER_ANIMATION_HEAD_WALKING_STOP);
+			mSpriteHead->animate();
 			break;
 
 		default:
-			mSpriteBody->animate(PLAYER_ANIMATION_BODY_WALKING_STOP);
-			mSpriteHead->animate(PLAYER_ANIMATION_HEAD_WALKING_STOP);
+			mSpriteBody->setCurrentAnimation(PLAYER_ANIMATION_BODY_WALKING_STOP);
+			mSpriteBody->animate();
+			mSpriteHead->setCurrentAnimation(PLAYER_ANIMATION_HEAD_WALKING_STOP);
+			mSpriteHead->animate();
 			break;
 		}
 		break;
 
 	default:
-		mSpriteLegs->animate(PLAYER_ANIMATION_LEGS_WALKING_STOP);
+		mSpriteLegs->setCurrentAnimation(PLAYER_ANIMATION_LEGS_WALKING_STOP);
+		mSpriteLegs->animate();
 		break;
 	}
 }
diff --git a/source/smartsprite.cpp b/source/smartsprite.cpp
index 13f922f..4936319 100644
--- a/source/smartsprite.cpp
+++ b/source/smartsprite.cpp
@@ -6,16 +6,7 @@ SmartSprite::SmartSprite(LTexture *texture, SDL_Renderer *renderer)
 {
 	setTexture(texture);
 	setRenderer(renderer);
-}
 
-// Destructor
-SmartSprite::~SmartSprite()
-{
-}
-
-// Inicializador
-void SmartSprite::init()
-{
 	setPosX(0);
 	setPosY(0);
 	setWidth(0);
@@ -47,6 +38,11 @@ void SmartSprite::init()
 	introEvents = nullptr;
 }
 
+// Destructor
+SmartSprite::~SmartSprite()
+{
+}
+
 // Obtiene el valor de la variable
 bool SmartSprite::isEnabled()
 {
diff --git a/source/smartsprite.h b/source/smartsprite.h
index cf4d740..3719a40 100644
--- a/source/smartsprite.h
+++ b/source/smartsprite.h
@@ -26,9 +26,6 @@ public:
 	// Destructor
 	~SmartSprite();
 
-	// Inicializador
-	void init();
-
 	// Obtiene el valor de la variable
 	bool isEnabled();
 
diff --git a/source/title.cpp b/source/title.cpp
index eb6150f..62b4c91 100644
--- a/source/title.cpp
+++ b/source/title.cpp
@@ -28,7 +28,7 @@ Title::Title(SDL_Window *window, SDL_Renderer *renderer, Screen *screen, Input *
 	mGradient = new Sprite();
 	mText = new Text(mAsset->get("smb2.png"), mAsset->get("smb2.txt"), mRenderer);
 	mText2 = new Text(mAsset->get("8bithud.png"), mAsset->get("8bithud.txt"), mRenderer);
-	mMenu.title = new Menu(mRenderer, mInput, mAsset);
+	mMenu.title = new Menu(this->mRenderer, this->mInput, this->mAsset);
 	mMenu.options = new Menu(mRenderer, mInput, mAsset);
 
 	// Crea la textura para el mosaico de fondo