diff --git a/source/game.cpp b/source/game.cpp
index 6fcd1c5..0d7e440 100644
--- a/source/game.cpp
+++ b/source/game.cpp
@@ -21,7 +21,7 @@
 #include "fade.h"				  // for Fade, FadeType
 #include "global_inputs.h"		  // for check
 #include "input.h"				  // for InputType, Input, INPUT_DO_NOT_ALL...
-#include "item.h"				  // for Item, ITEM_COFFEE_MACHINE, ITEM_CLOCK
+#include "item.h"				  // for Item, ItemType::COFFEE_MACHINE, ItemType::CLOCK
 #include "jail_audio.h"			  // for JA_PlaySound, JA_DeleteSound, JA_L...
 #include "lang.h"				  // for getText
 #include "manage_hiscore_table.h" // for ManageHiScoreTable
@@ -39,7 +39,8 @@ struct JA_Sound_t;				  // lines 36-36
 
 // Constructor
 Game::Game(int player_id, int current_stage, bool demo, JA_Music_t *music)
-	: music_(music), current_stage_(current_stage)
+	: music_(music),
+	  current_stage_(current_stage)
 {
 	// Copia los punteros
 	asset_ = Asset::get();
@@ -75,11 +76,11 @@ Game::Game(int player_id, int current_stage, bool demo, JA_Music_t *music)
 
 	background_->setPos(param.game.play_area.rect);
 
-	game_text_sprites_.emplace_back(std::make_shared<SmartSprite>(game_text_textures_.at(0)));
-	game_text_sprites_.emplace_back(std::make_shared<SmartSprite>(game_text_textures_.at(1)));
-	game_text_sprites_.emplace_back(std::make_shared<SmartSprite>(game_text_textures_.at(2)));
-	game_text_sprites_.emplace_back(std::make_shared<SmartSprite>(game_text_textures_.at(3)));
-	game_text_sprites_.emplace_back(std::make_shared<SmartSprite>(game_text_textures_.at(4)));
+	// game_text_sprites_.emplace_back(std::make_shared<SmartSprite>(game_text_textures_.at(0)));
+	// game_text_sprites_.emplace_back(std::make_shared<SmartSprite>(game_text_textures_.at(1)));
+	// game_text_sprites_.emplace_back(std::make_shared<SmartSprite>(game_text_textures_.at(2)));
+	// game_text_sprites_.emplace_back(std::make_shared<SmartSprite>(game_text_textures_.at(3)));
+	// game_text_sprites_.emplace_back(std::make_shared<SmartSprite>(game_text_textures_.at(4)));
 
 	explosions_->addTexture(1, explosions_textures_[0], explosions_animations_[0]);
 	explosions_->addTexture(2, explosions_textures_[1], explosions_animations_[1]);
@@ -298,11 +299,7 @@ void Game::init(int player_id)
 	evaluateAndSetMenace();
 
 	// Inicializa los sprites con los textos que aparecen al coger items
-	for (auto &sprite : game_text_sprites_)
-	{
-		sprite->setVelY(-0.5f);
-		sprite->setAccelY(-0.1f);
-	}
+	smart_sprites_.clear();
 }
 
 // Carga los recursos necesarios para la sección 'Game'
@@ -341,83 +338,54 @@ void Game::loadMedia()
 
 	// Texturas - Globos
 	{
-		auto balloon1_texture = std::make_shared<Texture>(renderer_, asset_->get("balloon1.png"));
-		balloon_textures_.push_back(balloon1_texture);
+		balloon_textures_.emplace_back(std::make_shared<Texture>(renderer_, asset_->get("balloon1.png")));
+		balloon_textures_.emplace_back(std::make_shared<Texture>(renderer_, asset_->get("balloon2.png")));
+		balloon_textures_.emplace_back(std::make_shared<Texture>(renderer_, asset_->get("balloon3.png")));
+		balloon_textures_.emplace_back(std::make_shared<Texture>(renderer_, asset_->get("balloon4.png")));
+		balloon_textures_.emplace_back(std::make_shared<Texture>(renderer_, asset_->get("powerball.png")));
+	}
 
-		auto balloon2_texture = std::make_shared<Texture>(renderer_, asset_->get("balloon2.png"));
-		balloon_textures_.push_back(balloon2_texture);
-
-		auto balloon3_texture = std::make_shared<Texture>(renderer_, asset_->get("balloon3.png"));
-		balloon_textures_.push_back(balloon3_texture);
-
-		auto balloon4_texture = std::make_shared<Texture>(renderer_, asset_->get("balloon4.png"));
-		balloon_textures_.push_back(balloon4_texture);
-
-		auto balloon5_texture = std::make_shared<Texture>(renderer_, asset_->get("powerball.png"));
-		balloon_textures_.push_back(balloon5_texture);
-
-		// Texturas - Explosiones
-		auto explosion1_texture = std::make_shared<Texture>(renderer_, asset_->get("explosion1.png"));
-		explosions_textures_.push_back(explosion1_texture);
-
-		auto explosion2_texture = std::make_shared<Texture>(renderer_, asset_->get("explosion2.png"));
-		explosions_textures_.push_back(explosion2_texture);
-
-		auto explosion3_texture = std::make_shared<Texture>(renderer_, asset_->get("explosion3.png"));
-		explosions_textures_.push_back(explosion3_texture);
-
-		auto explosion4_texture = std::make_shared<Texture>(renderer_, asset_->get("explosion4.png"));
-		explosions_textures_.push_back(explosion4_texture);
+	// Texturas - Explosiones
+	{
+		explosions_textures_.emplace_back(std::make_shared<Texture>(renderer_, asset_->get("explosion1.png")));
+		explosions_textures_.emplace_back(std::make_shared<Texture>(renderer_, asset_->get("explosion2.png")));
+		explosions_textures_.emplace_back(std::make_shared<Texture>(renderer_, asset_->get("explosion3.png")));
+		explosions_textures_.emplace_back(std::make_shared<Texture>(renderer_, asset_->get("explosion4.png")));
 	}
 
 	// Texturas - Items
 	{
-		auto item1 = std::make_shared<Texture>(renderer_, asset_->get("item_points1_disk.png"));
-		item_textures_.push_back(item1);
-
-		auto item2 = std::make_shared<Texture>(renderer_, asset_->get("item_points2_gavina.png"));
-		item_textures_.push_back(item2);
-
-		auto item3 = std::make_shared<Texture>(renderer_, asset_->get("item_points3_pacmar.png"));
-		item_textures_.push_back(item3);
-
-		auto item4 = std::make_shared<Texture>(renderer_, asset_->get("item_clock.png"));
-		item_textures_.push_back(item4);
-
-		auto item5 = std::make_shared<Texture>(renderer_, asset_->get("item_coffee.png"));
-		item_textures_.push_back(item5);
-
-		auto item6 = std::make_shared<Texture>(renderer_, asset_->get("item_coffee_machine.png"));
-		item_textures_.push_back(item6);
+		item_textures_.emplace_back(std::make_shared<Texture>(renderer_, asset_->get("item_points1_disk.png")));
+		item_textures_.emplace_back(std::make_shared<Texture>(renderer_, asset_->get("item_points2_gavina.png")));
+		item_textures_.emplace_back(std::make_shared<Texture>(renderer_, asset_->get("item_points3_pacmar.png")));
+		item_textures_.emplace_back(std::make_shared<Texture>(renderer_, asset_->get("item_clock.png")));
+		item_textures_.emplace_back(std::make_shared<Texture>(renderer_, asset_->get("item_coffee.png")));
+		item_textures_.emplace_back(std::make_shared<Texture>(renderer_, asset_->get("item_coffee_machine.png")));
 	}
 
 	// Texturas - Player1
 	{
-		auto player1_texture = std::make_shared<Texture>(renderer_, asset_->get("player1.gif"));
-		player1_texture->addPalette(asset_->get("player1_pal1.gif"));
-		player1_texture->addPalette(asset_->get("player1_pal2.gif"));
-		player1_texture->addPalette(asset_->get("player1_pal3.gif"));
-		player1_textures_.push_back(player1_texture);
+		player1_textures_.emplace_back(std::make_shared<Texture>(renderer_, asset_->get("player1.gif")));
+		player1_textures_.back()->addPalette(asset_->get("player1_pal1.gif"));
+		player1_textures_.back()->addPalette(asset_->get("player1_pal2.gif"));
+		player1_textures_.back()->addPalette(asset_->get("player1_pal3.gif"));
 
-		auto player1_power_texture = std::make_shared<Texture>(renderer_, asset_->get("player_power.gif"));
-		player1_power_texture->addPalette(asset_->get("player_power_pal.gif"));
-		player1_textures_.push_back(player1_power_texture);
+		player1_textures_.emplace_back(std::make_shared<Texture>(renderer_, asset_->get("player_power.gif")));
+		player1_textures_.back()->addPalette(asset_->get("player_power_pal.gif"));
 
 		player_textures_.push_back(player1_textures_);
 	}
 
 	// Texturas - Player2
 	{
-		auto player2_texture = std::make_shared<Texture>(renderer_, asset_->get("player2.gif"));
-		player2_texture->addPalette(asset_->get("player2_pal1.gif"));
-		player2_texture->addPalette(asset_->get("player2_pal2.gif"));
-		player2_texture->addPalette(asset_->get("player2_pal3.gif"));
-		player2_textures_.push_back(player2_texture);
+		player2_textures_.emplace_back(std::make_shared<Texture>(renderer_, asset_->get("player2.gif")));
+		player2_textures_.back()->addPalette(asset_->get("player2_pal1.gif"));
+		player2_textures_.back()->addPalette(asset_->get("player2_pal2.gif"));
+		player2_textures_.back()->addPalette(asset_->get("player2_pal3.gif"));
 
-		auto player2_power_texture = std::make_shared<Texture>(renderer_, asset_->get("player_power.gif"));
-		player2_power_texture->addPalette(asset_->get("player_power_pal.gif"));
-		player2_power_texture->setPalette(1);
-		player2_textures_.push_back(player2_power_texture);
+		player2_textures_.emplace_back(std::make_shared<Texture>(renderer_, asset_->get("player_power.gif")));
+		player2_textures_.back()->addPalette(asset_->get("player_power_pal.gif"));
+		player2_textures_.back()->setPalette(1);
 
 		player_textures_.push_back(player2_textures_);
 	}
@@ -1161,55 +1129,55 @@ void Game::checkPlayerItemCollision(std::shared_ptr<Player> &player)
 		{
 			if (checkCollision(player->getCollider(), item->getCollider()))
 			{
-				switch (item->getClass())
+				switch (item->getType())
 				{
-				case ITEM_POINTS_1_DISK:
+				case ItemType::DISK:
 				{
 					player->addScore(1000);
-					createItemScoreSprite(item->getPosX() + (item->getWidth() / 2) - (game_text_sprites_[0]->getWidth() / 2), player->getPosY(), game_text_sprites_[0]);
+					createItemScoreSprite(item->getPosX() + (item->getWidth() / 2) - (game_text_textures_[0]->getWidth() / 2), player->getPosY(), game_text_textures_[0]);
 					break;
 				}
 
-				case ITEM_POINTS_2_GAVINA:
+				case ItemType::GAVINA:
 				{
 					player->addScore(2500);
-					createItemScoreSprite(item->getPosX() + (item->getWidth() / 2) - (game_text_sprites_[1]->getWidth() / 2), player->getPosY(), game_text_sprites_[1]);
+					createItemScoreSprite(item->getPosX() + (item->getWidth() / 2) - (game_text_textures_[1]->getWidth() / 2), player->getPosY(), game_text_textures_[1]);
 					break;
 				}
 
-				case ITEM_POINTS_3_PACMAR:
+				case ItemType::PACMAR:
 				{
 					player->addScore(5000);
-					createItemScoreSprite(item->getPosX() + (item->getWidth() / 2) - (game_text_sprites_[2]->getWidth() / 2), player->getPosY(), game_text_sprites_[2]);
+					createItemScoreSprite(item->getPosX() + (item->getWidth() / 2) - (game_text_textures_[2]->getWidth() / 2), player->getPosY(), game_text_textures_[2]);
 					break;
 				}
 
-				case ITEM_CLOCK:
+				case ItemType::CLOCK:
 				{
 					enableTimeStopItem();
 					break;
 				}
 
-				case ITEM_COFFEE:
+				case ItemType::COFFEE:
 				{
 					if (player->getCoffees() == 2)
 					{
 						player->addScore(5000);
-						createItemScoreSprite(item->getPosX() + (item->getWidth() / 2) - (game_text_sprites_[2]->getWidth() / 2), player->getPosY(), game_text_sprites_[2]);
+						createItemScoreSprite(item->getPosX() + (item->getWidth() / 2) - (game_text_textures_[2]->getWidth() / 2), player->getPosY(), game_text_textures_[2]);
 					}
 					else
 					{
 						player->giveExtraHit();
-						createItemScoreSprite(item->getPosX() + (item->getWidth() / 2) - (game_text_sprites_[4]->getWidth() / 2), player->getPosY(), game_text_sprites_[4]);
+						createItemScoreSprite(item->getPosX() + (item->getWidth() / 2) - (game_text_textures_[4]->getWidth() / 2), player->getPosY(), game_text_textures_[4]);
 					}
 					break;
 				}
 
-				case ITEM_COFFEE_MACHINE:
+				case ItemType::COFFEE_MACHINE:
 				{
 					player->setPowerUp();
 					coffee_machine_enabled_ = false;
-					createItemScoreSprite(item->getPosX() + (item->getWidth() / 2) - (game_text_sprites_[3]->getWidth() / 2), player->getPosY(), game_text_sprites_[3]);
+					createItemScoreSprite(item->getPosX() + (item->getWidth() / 2) - (game_text_textures_[3]->getWidth() / 2), player->getPosY(), game_text_textures_[3]);
 					break;
 				}
 
@@ -1248,9 +1216,9 @@ void Game::checkBulletBalloonCollision()
 
 					// Suelta el item si se da el caso
 					const auto droppeditem = dropItem();
-					if (droppeditem != ITEM_NULL && !demo_.recording)
+					if (droppeditem != ItemType::NONE && !demo_.recording)
 					{
-						if (droppeditem != ITEM_COFFEE_MACHINE)
+						if (droppeditem != ItemType::COFFEE_MACHINE)
 						{
 							createItem(droppeditem, balloon->getPosX(), balloon->getPosY());
 							JA_PlaySound(item_drop_sound_);
@@ -1354,7 +1322,7 @@ void Game::renderItems()
 }
 
 // Devuelve un item al azar y luego segun sus probabilidades
-int Game::dropItem()
+ItemType Game::dropItem()
 {
 	const auto lucky_number = rand() % 100;
 	const auto item = rand() % 6;
@@ -1364,28 +1332,28 @@ int Game::dropItem()
 	case 0:
 		if (lucky_number < helper_.item_disk_odds)
 		{
-			return ITEM_POINTS_1_DISK;
+			return ItemType::DISK;
 		}
 		break;
 
 	case 1:
 		if (lucky_number < helper_.item_gavina_odds)
 		{
-			return ITEM_POINTS_2_GAVINA;
+			return ItemType::GAVINA;
 		}
 		break;
 
 	case 2:
 		if (lucky_number < helper_.item_pacmar_odds)
 		{
-			return ITEM_POINTS_3_PACMAR;
+			return ItemType::GAVINA;
 		}
 		break;
 
 	case 3:
 		if (lucky_number < helper_.item_clock_odds)
 		{
-			return ITEM_CLOCK;
+			return ItemType::CLOCK;
 		}
 		break;
 
@@ -1393,7 +1361,7 @@ int Game::dropItem()
 		if (lucky_number < helper_.item_coffee_odds)
 		{
 			helper_.item_coffee_odds = ITEM_COFFEE_ODDS;
-			return ITEM_COFFEE;
+			return ItemType::COFFEE;
 		}
 		else
 		{
@@ -1410,7 +1378,7 @@ int Game::dropItem()
 			helper_.item_coffee_machine_odds = ITEM_COFFEE_MACHINE_ODDS;
 			if (!coffee_machine_enabled_ && helper_.need_coffee_machine)
 			{
-				return ITEM_COFFEE_MACHINE;
+				return ItemType::COFFEE_MACHINE;
 			}
 		}
 		else
@@ -1426,14 +1394,13 @@ int Game::dropItem()
 		break;
 	}
 
-	return ITEM_NULL;
+	return ItemType::NONE;
 }
 
 // Crea un objeto item
-void Game::createItem(int kind, float x, float y)
+void Game::createItem(ItemType type, float x, float y)
 {
-	auto item = std::make_unique<Item>(kind, x, y, &(param.game.play_area.rect), item_textures_[kind - 1], item_animations_[kind - 1]);
-	items_.push_back(std::move(item));
+	items_.emplace_back(std::make_unique<Item>(type, x, y, &(param.game.play_area.rect), item_textures_[static_cast<int>(type) - 1], item_animations_[static_cast<int>(type) - 1]));
 }
 
 // Vacia el vector de items
@@ -1452,19 +1419,22 @@ void Game::freeItems()
 }
 
 // Crea un objeto SmartSprite para mostrar la puntuación al coger un objeto
-void Game::createItemScoreSprite(int x, int y, std::shared_ptr<SmartSprite> sprite)
+void Game::createItemScoreSprite(int x, int y, std::shared_ptr<Texture> texture)
 {
-	auto ss = sprite.get();
-	smart_sprites_.push_back(ss);
+	smart_sprites_.emplace_back(std::make_unique<SmartSprite>(texture));
 
-	// Crea una copia del objeto
-	*ss = *sprite;
-	ss->setPosX(x);
-	ss->setPosY(y);
-	ss->setDestX(x);
-	ss->setDestY(y - 25);
-	ss->setEnabled(true);
-	ss->setFinishedCounter(100);
+	// Inicializa
+	smart_sprites_.back()->init();
+	smart_sprites_.back()->setPos({0, 0, texture->getWidth(), texture->getHeight()});
+	smart_sprites_.back()->setSpriteClip(smart_sprites_.back()->getPos());
+	smart_sprites_.back()->setPosX(x);
+	smart_sprites_.back()->setPosY(y);
+	smart_sprites_.back()->setDestX(x);
+	smart_sprites_.back()->setDestY(y - 25);
+	smart_sprites_.back()->setVelY(-0.5f);
+	smart_sprites_.back()->setAccelY(-0.1f);
+	smart_sprites_.back()->setEnabled(true);
+	smart_sprites_.back()->setFinishedCounter(100);
 }
 
 // Vacia el vector de smartsprites
@@ -1485,31 +1455,30 @@ void Game::freeSmartSprites()
 // Crea un SmartSprite para arrojar el item café al recibir un impacto
 void Game::throwCoffee(int x, int y)
 {
-	auto ss = new SmartSprite(item_textures_[4]);
-	smart_sprites_.push_back(ss);
+	smart_sprites_.emplace_back(std::make_unique<SmartSprite>(item_textures_[4]));
 
-	ss->setPosX(x - 8);
-	ss->setPosY(y - 8);
-	ss->setWidth(param.game.item_size);
-	ss->setHeight(param.game.item_size);
-	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(param.game.height + 1);
-	ss->setEnabled(true);
-	ss->setFinishedCounter(1);
-	ss->setSpriteClip(0, param.game.item_size, param.game.item_size, param.game.item_size);
-	ss->setRotate(true);
-	ss->setRotateSpeed(10);
-	ss->setRotateAmount(90.0);
+	smart_sprites_.back()->setPosX(x - 8);
+	smart_sprites_.back()->setPosY(y - 8);
+	smart_sprites_.back()->setWidth(param.game.item_size);
+	smart_sprites_.back()->setHeight(param.game.item_size);
+	smart_sprites_.back()->setVelX(-1.0f + ((rand() % 5) * 0.5f));
+	smart_sprites_.back()->setVelY(-4.0f);
+	smart_sprites_.back()->setAccelX(0.0f);
+	smart_sprites_.back()->setAccelY(0.2f);
+	smart_sprites_.back()->setDestX(x + (smart_sprites_.back()->getVelX() * 50));
+	smart_sprites_.back()->setDestY(param.game.height + 1);
+	smart_sprites_.back()->setEnabled(true);
+	smart_sprites_.back()->setFinishedCounter(1);
+	smart_sprites_.back()->setSpriteClip(0, param.game.item_size, param.game.item_size, param.game.item_size);
+	smart_sprites_.back()->setRotate(true);
+	smart_sprites_.back()->setRotateSpeed(10);
+	smart_sprites_.back()->setRotateAmount(90.0);
 }
 
 // Actualiza los SmartSprites
 void Game::updateSmartSprites()
 {
-	for (auto ss : smart_sprites_)
+	for (auto &ss : smart_sprites_)
 	{
 		ss->update();
 	}
@@ -1518,7 +1487,7 @@ void Game::updateSmartSprites()
 // Pinta los SmartSprites activos
 void Game::renderSmartSprites()
 {
-	for (auto ss : smart_sprites_)
+	for (auto &ss : smart_sprites_)
 	{
 		ss->render();
 	}
diff --git a/source/game.h b/source/game.h
index ba9083b..197ee4e 100644
--- a/source/game.h
+++ b/source/game.h
@@ -24,6 +24,7 @@ class Texture;
 enum class BulletType; // lines 26-26
 struct JA_Music_t;	   // lines 27-27
 struct JA_Sound_t;	   // lines 28-28
+enum class ItemType;
 
 // Modo demo
 constexpr bool GAME_MODE_DEMO_OFF = false;
@@ -118,11 +119,11 @@ private:
 
 	SDL_Texture *canvas_; // Textura para dibujar la zona de juego
 
-	std::vector<std::shared_ptr<Player>> players_;	 // Vector con los jugadores
-	std::vector<std::shared_ptr<Balloon>> balloons_; // Vector con los globos
-	std::vector<std::unique_ptr<Bullet>> bullets_;	 // Vector con las balas
-	std::vector<std::unique_ptr<Item>> items_;		 // Vector con los items
-	std::vector<SmartSprite *> smart_sprites_;		 // Vector con los smartsprites
+	std::vector<std::shared_ptr<Player>> players_;			  // Vector con los jugadores
+	std::vector<std::shared_ptr<Balloon>> balloons_;		  // Vector con los globos
+	std::vector<std::unique_ptr<Bullet>> bullets_;			  // Vector con las balas
+	std::vector<std::unique_ptr<Item>> items_;				  // Vector con los items
+	std::vector<std::unique_ptr<SmartSprite>> smart_sprites_; // Vector con los smartsprites
 
 	std::shared_ptr<Texture> bullet_texture_;							 // Textura para las balas
 	std::vector<std::shared_ptr<Texture>> item_textures_;				 // Vector con las texturas de los items
@@ -133,7 +134,7 @@ private:
 	std::vector<std::vector<std::shared_ptr<Texture>>> player_textures_; // Vector con todas las texturas de los jugadores;
 
 	std::vector<std::shared_ptr<Texture>> game_text_textures_;	  // Vector con las texturas para los sprites con textos
-	std::vector<std::shared_ptr<SmartSprite>> game_text_sprites_; // Sprite con el textos que aparecen al coger items
+	//std::vector<std::shared_ptr<SmartSprite>> game_text_sprites_; // Sprite con el textos que aparecen al coger items
 
 	std::vector<std::vector<std::string> *> item_animations_;		// Vector con las animaciones de los items
 	std::vector<std::vector<std::string> *> player_animations_;		// Vector con las animaciones del jugador
@@ -312,16 +313,16 @@ private:
 	void renderItems();
 
 	// Devuelve un item en función del azar
-	int dropItem();
+	ItemType dropItem();
 
 	// Crea un objeto item
-	void createItem(int kind, float x, float y);
+	void createItem(ItemType type, float x, float y);
 
 	// Vacia el vector de items
 	void freeItems();
 
 	// Crea un objeto SmartSprite
-	void createItemScoreSprite(int x, int y, std::shared_ptr<SmartSprite> sprite);
+	void createItemScoreSprite(int x, int y, std::shared_ptr<Texture> texture);
 
 	// Vacia el vector de smartsprites
 	void freeSmartSprites();
diff --git a/source/item.cpp b/source/item.cpp
index a86c2a1..0a8d98d 100644
--- a/source/item.cpp
+++ b/source/item.cpp
@@ -5,16 +5,16 @@
 class Texture;
 
 // Constructor
-Item::Item(int kind, float x, float y, SDL_Rect *play_area, std::shared_ptr<Texture> texture, std::vector<std::string> *animation)
+Item::Item(ItemType type, float x, float y, SDL_Rect *play_area, std::shared_ptr<Texture> texture, std::vector<std::string> *animation)
 	: sprite_(std::make_unique<AnimatedSprite>(texture, "", animation)),
 	  accel_x_(0.0f),
 	  floor_collision_(false),
-	  kind_(kind),
+	  type_(type),
 	  enabled_(true),
 	  play_area_(play_area),
 	  time_to_live_(600)
 {
-	if (kind == ITEM_COFFEE_MACHINE)
+	if (type == ItemType::COFFEE_MACHINE)
 	{
 		width_ = 28;
 		height_ = 37;
@@ -104,7 +104,7 @@ void Item::move()
 	}
 
 	// Si se sale por arriba rebota (excepto la maquina de café)
-	if ((pos_y_ < param.game.play_area.rect.y) && !(kind_ == ITEM_COFFEE_MACHINE))
+	if ((pos_y_ < param.game.play_area.rect.y) && !(type_ == ItemType::COFFEE_MACHINE))
 	{
 		// Corrige
 		pos_y_ = param.game.play_area.rect.y;
@@ -122,7 +122,7 @@ void Item::move()
 		accel_x_ = 0;
 		accel_y_ = 0;
 		pos_y_ = play_area_->h - height_;
-		if (kind_ == ITEM_COFFEE_MACHINE)
+		if (type_ == ItemType::COFFEE_MACHINE)
 		{
 			floor_collision_ = true;
 		}
@@ -190,9 +190,9 @@ int Item::getHeight()
 }
 
 // Obtiene del valor de la variable
-int Item::getClass()
+ItemType Item::getType()
 {
-	return kind_;
+	return type_;
 }
 
 // Obtiene el valor de la variable
diff --git a/source/item.h b/source/item.h
index d8b461e..7e63067 100644
--- a/source/item.h
+++ b/source/item.h
@@ -1,22 +1,25 @@
 #pragma once
 
-#include <SDL2/SDL_rect.h>    // for SDL_Rect
-#include <SDL2/SDL_stdinc.h>  // for Uint16
-#include <memory>             // for shared_ptr, unique_ptr
-#include <string>             // for string
-#include <vector>             // for vector
-#include "animated_sprite.h"  // for AnimatedSprite
-#include "utils.h"            // for Circle
+#include <SDL2/SDL_rect.h>   // for SDL_Rect
+#include <SDL2/SDL_stdinc.h> // for Uint16
+#include <memory>            // for shared_ptr, unique_ptr
+#include <string>            // for string
+#include <vector>            // for vector
+#include "animated_sprite.h" // for AnimatedSprite
+#include "utils.h"           // for Circle
 class Texture;
 
 // Tipos de objetos
-constexpr int ITEM_POINTS_1_DISK = 1;
-constexpr int ITEM_POINTS_2_GAVINA = 2;
-constexpr int ITEM_POINTS_3_PACMAR = 3;
-constexpr int ITEM_CLOCK = 4;
-constexpr int ITEM_COFFEE = 5;
-constexpr int ITEM_COFFEE_MACHINE = 6;
-constexpr int ITEM_NULL = 7;
+enum class ItemType : int
+{
+    DISK = 1,
+    GAVINA = 2,
+    PACMAR = 3,
+    CLOCK = 4,
+    COFFEE = 5,
+    COFFEE_MACHINE = 6,
+    NONE = 7,
+};
 
 // Clase Item
 class Item
@@ -35,7 +38,7 @@ private:
     float accel_x_;        // Aceleración en el eje X
     float accel_y_;        // Aceleración en el eje Y
     bool floor_collision_; // Indica si el objeto colisiona con el suelo
-    int kind_;             // Especifica el tipo de objeto que es
+    ItemType type_;             // Especifica el tipo de objeto que es
     bool enabled_;         // Especifica si el objeto está habilitado
     Circle collider_;      // Circulo de colisión del objeto
     SDL_Rect *play_area_;  // Rectangulo con la zona de juego
@@ -55,7 +58,7 @@ private:
 
 public:
     // Constructor
-    Item(int kind, float x, float y, SDL_Rect *play_area, std::shared_ptr<Texture> texture, std::vector<std::string> *animation);
+    Item(ItemType type, float x, float y, SDL_Rect *play_area, std::shared_ptr<Texture> texture, std::vector<std::string> *animation);
 
     // Destructor
     ~Item() = default;
@@ -85,7 +88,7 @@ public:
     int getHeight();
 
     // Obtiene del valor de la variable
-    int getClass();
+    ItemType getType();
 
     // Obtiene el valor de la variable
     bool isEnabled();
diff --git a/source/smart_sprite.cpp b/source/smart_sprite.cpp
index 11ea74e..041c648 100644
--- a/source/smart_sprite.cpp
+++ b/source/smart_sprite.cpp
@@ -127,7 +127,7 @@ void SmartSprite::checkMove()
 void SmartSprite::checkFinished()
 {
 	// Comprueba si ha llegado a su destino
-	on_destination_ = (getPosX() == dest_x_ && getPosY() == dest_y_) ? true : false;
+	on_destination_ = (getPosX() == dest_x_ && getPosY() == dest_y_);
 
 	if (on_destination_)
 	{