From 4ef759772a67316e2420da48a8dc1d2095154d0e Mon Sep 17 00:00:00 2001
From: Sergio Valor <jaildesigner@gmail.com>
Date: Sat, 12 Oct 2024 09:15:20 +0200
Subject: [PATCH] game.cpp renombrat

---
 source/game.cpp | 1392 ++++++++++++++++++++++++-----------------------
 source/game.h   |  253 ++++-----
 2 files changed, 832 insertions(+), 813 deletions(-)

diff --git a/source/game.cpp b/source/game.cpp
index 64ffbd9..c653cdd 100644
--- a/source/game.cpp
+++ b/source/game.cpp
@@ -34,69 +34,65 @@
 struct JA_Music_t;
 struct JA_Sound_t;
 
-#define GAME_OVER_COUNTER 350
-
 // Constructor
-Game::Game(int playerID, int currentStage, bool demo, JA_Music_t *music)
-	: music(music)
+Game::Game(int player_id, int current_stage, bool demo, JA_Music_t *music)
+	: music_(music), current_stage_(current_stage)
 {
 	// Copia los punteros
-	asset = Asset::get();
-	input = Input::get();
-	screen = Screen::get();
-	renderer = screen->getRenderer();
+	asset_ = Asset::get();
+	input_ = Input::get();
+	screen_ = Screen::get();
+	renderer_ = screen_->getRenderer();
 
 	// Pasa variables
-	this->demo.enabled = demo;
-	this->currentStage = currentStage;
-	lastStageReached = currentStage;
-	difficulty = options.game.difficulty;
+	demo_.enabled = demo;
+	last_stage_reached_ = current_stage_;
+	difficulty_ = options.game.difficulty;
 
 	// Crea los objetos
-	Scoreboard::init(renderer);
-	scoreboard = Scoreboard::get();
-	eventHandler = std::make_unique<SDL_Event>();
-	fade = std::make_unique<Fade>(renderer);
+	Scoreboard::init(renderer_);
+	scoreboard_ = Scoreboard::get();
+	fade_ = std::make_unique<Fade>(renderer_);
 
-	background = std::make_unique<Background>(renderer);
-	explosions = std::make_unique<Explosions>();
-	enemyFormations = std::make_unique<EnemyFormations>();
+	background_ = std::make_unique<Background>(renderer_);
+	explosions_ = std::make_unique<Explosions>();
+	enemy_formations_ = std::make_unique<EnemyFormations>();
 
 	// Carga los recursos
 	loadMedia();
 
 	// Inicializa los vectores con los datos para la demo
-	if (demo)
+	if (demo_.enabled)
 	{ // Aleatoriza la asignación del fichero
 		const auto index1 = rand() % 2;
 		const auto index2 = (index1 + 1) % 2;
-		loadDemoFile(asset->get("demo1.bin"), &this->demo.dataFile[index1]);
-		loadDemoFile(asset->get("demo2.bin"), &this->demo.dataFile[index2]);
+		loadDemoFile(asset_->get("demo1.bin"), &this->demo_.data_file[index1]);
+		loadDemoFile(asset_->get("demo2.bin"), &this->demo_.data_file[index2]);
 	}
 
-	background->setPos(param.game.play_area.rect);
+	background_->setPos(param.game.play_area.rect);
 
-	n1000Sprite = std::make_shared<SmartSprite>(gameTextTexture);
-	n2500Sprite = std::make_shared<SmartSprite>(gameTextTexture);
-	n5000Sprite = std::make_shared<SmartSprite>(gameTextTexture);
+	p1000_sprite_ = std::make_shared<SmartSprite>(game_text_texture_);
+	p2500_sprite_ = std::make_shared<SmartSprite>(game_text_texture_);
+	p5000_sprite_ = std::make_shared<SmartSprite>(game_text_texture_);
 
-	explosions->addTexture(1, explosionsTextures[0], explosionsAnimations[0]);
-	explosions->addTexture(2, explosionsTextures[1], explosionsAnimations[1]);
-	explosions->addTexture(3, explosionsTextures[2], explosionsAnimations[2]);
-	explosions->addTexture(4, explosionsTextures[3], explosionsAnimations[3]);
+	explosions_->addTexture(1, explosions_textures_[0], explosions_animations_[0]);
+	explosions_->addTexture(2, explosions_textures_[1], explosions_animations_[1]);
+	explosions_->addTexture(3, explosions_textures_[2], explosions_animations_[2]);
+	explosions_->addTexture(4, explosions_textures_[3], explosions_animations_[3]);
 
-	canvas = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, param.game.play_area.rect.w, param.game.play_area.rect.h);
-	SDL_SetTextureBlendMode(canvas, SDL_BLENDMODE_BLEND);
+	canvas_ = SDL_CreateTexture(renderer_, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, param.game.play_area.rect.w, param.game.play_area.rect.h);
+	SDL_SetTextureBlendMode(canvas_, SDL_BLENDMODE_BLEND);
 
 	// Inicializa las variables necesarias para la sección 'Game'
-	init(playerID);
+	init(player_id);
 }
 
 Game::~Game()
 {
 	// Guarda las puntuaciones en un fichero
 	auto manager = std::make_unique<ManageHiScoreTable>(&options.game.hi_score_table);
-	manager->saveToFile(asset->get("score.bin"));
+	manager->saveToFile(asset_->get("score.bin"));
 #ifdef RECORDING
 	saveDemoFile(asset->get("demo1.bin"));
 #endif
@@ -109,35 +105,35 @@ Game::~Game()
 
 	Scoreboard::destroy();
 
-	SDL_DestroyTexture(canvas);
+	SDL_DestroyTexture(canvas_);
 }
 
 // Inicializa las variables necesarias para la sección 'Game'
-void Game::init(int playerID)
+void Game::init(int player_id)
 {
-	ticks = 0;
-	ticksSpeed = 15;
+	ticks_ = 0;
+	ticks_speed_ = 15;
 
 	// Elimina qualquier jugador que hubiese antes de crear los nuevos
-	players.clear();
+	players_.clear();
 
 	// Crea los dos jugadores
-	auto player1 = std::make_unique<Player>(1, (param.game.play_area.first_quarter_x * ((0 * 2) + 1)) - 11, param.game.play_area.rect.h - 30, demo.enabled, &param.game.play_area.rect, playerTextures[0], playerAnimations);
+	auto player1 = std::make_unique<Player>(1, (param.game.play_area.first_quarter_x * ((0 * 2) + 1)) - 11, param.game.play_area.rect.h - 30, demo_.enabled, &param.game.play_area.rect, player_textures_[0], player_animations_);
 	player1->setScoreBoardPanel(SCOREBOARD_LEFT_PANEL);
 	player1->setName(lang::getText(53));
 	const auto controller1 = getController(player1->getId());
 	player1->setController(controller1);
-	players.push_back(std::move(player1));
+	players_.push_back(std::move(player1));
 
-	auto player2 = std::make_unique<Player>(2, (param.game.play_area.first_quarter_x * ((1 * 2) + 1)) - 11, param.game.play_area.rect.h - 30, demo.enabled, &param.game.play_area.rect, playerTextures[1], playerAnimations);
+	auto player2 = std::make_unique<Player>(2, (param.game.play_area.first_quarter_x * ((1 * 2) + 1)) - 11, param.game.play_area.rect.h - 30, demo_.enabled, &param.game.play_area.rect, player_textures_[1], player_animations_);
 	player2->setScoreBoardPanel(SCOREBOARD_RIGHT_PANEL);
 	player2->setName(lang::getText(54));
 	const auto controller2 = getController(player2->getId());
 	player2->setController(controller2);
-	players.push_back(std::move(player2));
+	players_.push_back(std::move(player2));
 
 	// Obtiene mediante "playerID" el jugador que va a empezar jugar
-	auto player = getPlayer(playerID);
+	auto player = getPlayer(player_id);
 
 	// Cambia el estado del jugador seleccionado
 	player->setStatusPlaying(PlayerStatus::PLAYING);
@@ -146,32 +142,32 @@ void Game::init(int playerID)
 	player->setInvulnerable(false);
 
 	// Variables relacionadas con la dificultad
-	switch (difficulty)
+	switch (difficulty_)
 	{
 	case GameDifficulty::EASY:
 	{
-		defaultEnemySpeed = BALLOON_SPEED_1;
-		difficultyScoreMultiplier = 0.5f;
-		difficultyColor = difficulty_easy_color;
-		scoreboard->setColor(difficultyColor);
+		default_enemy_speed_ = BALLOON_SPEED_1;
+		difficulty_score_multiplier_ = 0.5f;
+		difficulty_color_ = difficulty_easy_color;
+		scoreboard_->setColor(difficulty_color_);
 		break;
 	}
 
 	case GameDifficulty::NORMAL:
 	{
-		defaultEnemySpeed = BALLOON_SPEED_1;
-		difficultyScoreMultiplier = 1.0f;
-		difficultyColor = difficulty_normal_color;
-		scoreboard->setColor(scoreboard_color);
+		default_enemy_speed_ = BALLOON_SPEED_1;
+		difficulty_score_multiplier_ = 1.0f;
+		difficulty_color_ = difficulty_normal_color;
+		scoreboard_->setColor(scoreboard_color);
 		break;
 	}
 
 	case GameDifficulty::HARD:
 	{
-		defaultEnemySpeed = BALLOON_SPEED_5;
-		difficultyScoreMultiplier = 1.5f;
-		difficultyColor = difficulty_hard_color;
-		scoreboard->setColor(difficultyColor);
+		default_enemy_speed_ = BALLOON_SPEED_5;
+		difficulty_score_multiplier_ = 1.5f;
+		difficulty_color_ = difficulty_hard_color;
+		scoreboard_->setColor(difficulty_color_);
 		break;
 	}
 
@@ -180,79 +176,79 @@ void Game::init(int playerID)
 	}
 
 	// Variables para el marcador
-	scoreboard->setPos({param.scoreboard.x, param.scoreboard.y, param.scoreboard.w, param.scoreboard.h});
-	for (auto &player : players)
+	scoreboard_->setPos({param.scoreboard.x, param.scoreboard.y, param.scoreboard.w, param.scoreboard.h});
+	for (auto &player : players_)
 	{
-		scoreboard->setName(player->getScoreBoardPanel(), player->getName());
+		scoreboard_->setName(player->getScoreBoardPanel(), player->getName());
 		if (player->isWaiting())
 		{
-			scoreboard->setMode(player->getScoreBoardPanel(), ScoreboardMode::WAITING);
+			scoreboard_->setMode(player->getScoreBoardPanel(), ScoreboardMode::WAITING);
 		}
 	}
-	scoreboard->setMode(SCOREBOARD_CENTER_PANEL, ScoreboardMode::STAGE_INFO);
+	scoreboard_->setMode(SCOREBOARD_CENTER_PANEL, ScoreboardMode::STAGE_INFO);
 
 	// Resto de variables
-	hiScore.score = options.game.hi_score_table[0].score;
-	hiScore.name = options.game.hi_score_table[0].name;
-	paused = false;
-	gameCompleted = false;
-	gameCompletedCounter = 0;
+	hi_score_.score = options.game.hi_score_table[0].score;
+	hi_score_.name = options.game.hi_score_table[0].name;
+	paused_ = false;
+	game_completed_ = false;
+	game_completed_counter_ = 0;
 	section::name = section::Name::GAME;
 	section::options = section::Options::GAME_PLAY_1P;
-	currentPower = 0;
-	menaceCurrent = 0;
-	menaceThreshold = 0;
-	hiScoreAchieved = false;
-	stageBitmapCounter = STAGE_COUNTER;
-	gameOverCounter = GAME_OVER_COUNTER;
-	timeStopped = false;
-	timeStoppedCounter = 0;
-	counter = 0;
-	lastEnemyDeploy = 0;
-	enemyDeployCounter = 0;
-	enemySpeed = defaultEnemySpeed;
-	helper.needCoffee = false;
-	helper.needCoffeeMachine = false;
-	helper.needPowerBall = false;
-	helper.counter = HELP_COUNTER;
-	helper.itemPoints1Odds = ITEM_POINTS_1_DISK_ODDS;
-	helper.itemPoints2Odds = ITEM_POINTS_2_GAVINA_ODDS;
-	helper.itemPoints3Odds = ITEM_POINTS_3_PACMAR_ODDS;
-	helper.itemClockOdds = ITEM_CLOCK_ODDS;
-	helper.itemCoffeeOdds = ITEM_COFFEE_ODDS;
-	helper.itemCoffeeMachineOdds = ITEM_COFFEE_MACHINE_ODDS;
-	powerBallEnabled = false;
-	powerBallCounter = 0;
-	coffeeMachineEnabled = false;
-	balloonsPopped = 0;
+	current_power_ = 0;
+	menace_current_ = 0;
+	menace_threshold_ = 0;
+	hi_score_achieved_ = false;
+	stage_bitmap_counter_ = STAGE_COUNTER;
+	game_over_counter_ = GAME_OVER_COUNTER;
+	time_stopped_ = false;
+	time_stopped_counter_ = 0;
+	counter_ = 0;
+	last_enemy_deploy_ = 0;
+	enemy_deploy_counter_ = 0;
+	enemy_speed_ = default_enemy_speed_;
+	helper_.need_coffee = false;
+	helper_.need_coffee_machine = false;
+	helper_.need_power_ball = false;
+	helper_.counter = HELP_COUNTER;
+	helper_.item_disk_odds = ITEM_POINTS_1_DISK_ODDS;
+	helper_.item_gavina_odds = ITEM_POINTS_2_GAVINA_ODDS;
+	helper_.item_pacmar_odds = ITEM_POINTS_3_PACMAR_ODDS;
+	helper_.item_clock_odds = ITEM_CLOCK_ODDS;
+	helper_.item_coffee_odds = ITEM_COFFEE_ODDS;
+	helper_.item_coffee_machine_odds = ITEM_COFFEE_MACHINE_ODDS;
+	power_ball_enabled_ = false;
+	power_ball_counter_ = 0;
+	coffee_machine_enabled_ = false;
+	balloons_popped_ = 0;
 #ifdef DEBUG
-	autoPopBalloons = false;
+	auto_pop_balloons_ = false;
 #endif
 
 	// Inicializa las variables para el modo DEMO
-	if (demo.enabled)
+	if (demo_.enabled)
 	{
 		// Selecciona una pantalla al azar
 		constexpr auto demos = 3;
 		const auto demo = rand() % demos;
 		const int stages[demos] = {0, 3, 5};
-		currentStage = stages[demo];
+		current_stage_ = stages[demo];
 
 		// Actualiza el numero de globos explotados según la fase de la demo
-		for (int i = 0; i < currentStage; ++i)
+		for (int i = 0; i < current_stage_; ++i)
 		{
-			balloonsPopped += enemyFormations->getStage(i).power_to_complete;
+			balloons_popped_ += enemy_formations_->getStage(i).power_to_complete;
 		}
 
 		// Activa o no al otro jugador
 		if (rand() % 2 == 0)
 		{
-			const auto otherPlayer = playerID == 1 ? 2 : 1;
+			const auto otherPlayer = player_id == 1 ? 2 : 1;
 			auto player = getPlayer(otherPlayer);
 			player->setStatusPlaying(PlayerStatus::PLAYING);
 		}
 
-		for (auto &player : players)
+		for (auto &player : players_)
 		{
 			// Añade 0, 1 o 2 cafes al jugador
 			for (int i = 0; i < rand() % 3; ++i)
@@ -268,282 +264,301 @@ void Game::init(int playerID)
 		JA_EnableSound(false);
 
 		// Configura los marcadores
-		scoreboard->setMode(SCOREBOARD_LEFT_PANEL, ScoreboardMode::DEMO);
-		scoreboard->setMode(SCOREBOARD_RIGHT_PANEL, ScoreboardMode::DEMO);
+		scoreboard_->setMode(SCOREBOARD_LEFT_PANEL, ScoreboardMode::DEMO);
+		scoreboard_->setMode(SCOREBOARD_RIGHT_PANEL, ScoreboardMode::DEMO);
 	}
 
 	initPaths();
 
-	totalPowerToCompleteGame = 0;
+	total_power_to_complete_game_ = 0;
 	for (int i = 0; i < 10; ++i)
 	{
-		totalPowerToCompleteGame += enemyFormations->getStage(i).power_to_complete;
+		total_power_to_complete_game_ += enemy_formations_->getStage(i).power_to_complete;
 	}
 
 	// Modo grabar demo
 #ifdef RECORDING
 	demo.recording = true;
 #else
-	demo.recording = false;
+	demo_.recording = false;
 #endif
-	demo.counter = 0;
+	demo_.counter = 0;
 
 	// Inicializa el objeto para el fundido
-	fade->setColor(fade_color.r, fade_color.g, fade_color.b);
-	fade->setPost(param.fade.post_duration);
-	fade->setType(FadeType::VENETIAN);
+	fade_->setColor(fade_color.r, fade_color.g, fade_color.b);
+	fade_->setPost(param.fade.post_duration);
+	fade_->setType(FadeType::VENETIAN);
 
 	// Con los globos creados, calcula el nivel de amenaza
 	evaluateAndSetMenace();
 
 	// Inicializa el bitmap de 1000 puntos
 	constexpr auto height = 15;
-	constexpr auto sprite1Width = 35;
-	constexpr auto sprite2Width = 38;
-	constexpr auto sprite3Width = 39;
-	n1000Sprite->setPosX(0);
-	n1000Sprite->setPosY(0);
-	n1000Sprite->setWidth(sprite1Width);
-	n1000Sprite->setHeight(height);
-	n1000Sprite->setVelX(0.0f);
-	n1000Sprite->setVelY(-0.5f);
-	n1000Sprite->setAccelX(0.0f);
-	n1000Sprite->setAccelY(-0.1f);
-	n1000Sprite->setSpriteClip(0, 0, sprite1Width, height);
-	n1000Sprite->setEnabled(false);
-	n1000Sprite->setFinishedCounter(0);
-	n1000Sprite->setDestX(0);
-	n1000Sprite->setDestY(0);
+	constexpr auto sprite1_width = 35;
+	constexpr auto sprite2_width = 38;
+	constexpr auto sprite3_width = 39;
+	p1000_sprite_->setPosX(0);
+	p1000_sprite_->setPosY(0);
+	p1000_sprite_->setWidth(sprite1_width);
+	p1000_sprite_->setHeight(height);
+	p1000_sprite_->setVelX(0.0f);
+	p1000_sprite_->setVelY(-0.5f);
+	p1000_sprite_->setAccelX(0.0f);
+	p1000_sprite_->setAccelY(-0.1f);
+	p1000_sprite_->setSpriteClip(0, 0, sprite1_width, height);
+	p1000_sprite_->setEnabled(false);
+	p1000_sprite_->setFinishedCounter(0);
+	p1000_sprite_->setDestX(0);
+	p1000_sprite_->setDestY(0);
 
 	// Inicializa el bitmap de 2500 puntos
-	n2500Sprite->setPosX(0);
-	n2500Sprite->setPosY(0);
-	n2500Sprite->setWidth(sprite2Width);
-	n2500Sprite->setHeight(height);
-	n2500Sprite->setVelX(0.0f);
-	n2500Sprite->setVelY(-0.5f);
-	n2500Sprite->setAccelX(0.0f);
-	n2500Sprite->setAccelY(-0.1f);
-	n2500Sprite->setSpriteClip(sprite1Width, 0, sprite2Width, height);
-	n2500Sprite->setEnabled(false);
-	n2500Sprite->setFinishedCounter(0);
-	n2500Sprite->setDestX(0);
-	n2500Sprite->setDestY(0);
+	p2500_sprite_->setPosX(0);
+	p2500_sprite_->setPosY(0);
+	p2500_sprite_->setWidth(sprite2_width);
+	p2500_sprite_->setHeight(height);
+	p2500_sprite_->setVelX(0.0f);
+	p2500_sprite_->setVelY(-0.5f);
+	p2500_sprite_->setAccelX(0.0f);
+	p2500_sprite_->setAccelY(-0.1f);
+	p2500_sprite_->setSpriteClip(sprite1_width, 0, sprite2_width, height);
+	p2500_sprite_->setEnabled(false);
+	p2500_sprite_->setFinishedCounter(0);
+	p2500_sprite_->setDestX(0);
+	p2500_sprite_->setDestY(0);
 
 	// Inicializa el bitmap de 5000 puntos
-	n5000Sprite->setPosX(0);
-	n5000Sprite->setPosY(0);
-	n5000Sprite->setWidth(sprite3Width);
-	n5000Sprite->setHeight(height);
-	n5000Sprite->setVelX(0.0f);
-	n5000Sprite->setVelY(-0.5f);
-	n5000Sprite->setAccelX(0.0f);
-	n5000Sprite->setAccelY(-0.1f);
-	n5000Sprite->setSpriteClip(sprite1Width + sprite2Width, 0, sprite3Width, height);
-	n5000Sprite->setEnabled(false);
-	n5000Sprite->setFinishedCounter(0);
-	n5000Sprite->setDestX(0);
-	n5000Sprite->setDestY(0);
+	p5000_sprite_->setPosX(0);
+	p5000_sprite_->setPosY(0);
+	p5000_sprite_->setWidth(sprite3_width);
+	p5000_sprite_->setHeight(height);
+	p5000_sprite_->setVelX(0.0f);
+	p5000_sprite_->setVelY(-0.5f);
+	p5000_sprite_->setAccelX(0.0f);
+	p5000_sprite_->setAccelY(-0.1f);
+	p5000_sprite_->setSpriteClip(sprite1_width + sprite2_width, 0, sprite3_width, height);
+	p5000_sprite_->setEnabled(false);
+	p5000_sprite_->setFinishedCounter(0);
+	p5000_sprite_->setDestX(0);
+	p5000_sprite_->setDestY(0);
 }
 
 // Carga los recursos necesarios para la sección 'Game'
 void Game::loadMedia()
 {
 #ifdef VERBOSE
-	std::cout << std::endl
-			  << "** LOADING RESOURCES FOR GAME SECTION" << std::endl;
+	std::cout << "\n** LOADING RESOURCES FOR GAME SECTION" << std::endl;
 #endif
 
-	playerAnimations.clear();
-	balloonAnimations.clear();
-	itemAnimations.clear();
-	player1Textures.clear();
-	player2Textures.clear();
-	itemTextures.clear();
-	balloonTextures.clear();
-	explosionsTextures.clear();
+	// Limpia
+	{
+		player_animations_.clear();
+		balloon_animations_.clear();
+		item_animations_.clear();
+		player1_textures_.clear();
+		player2_textures_.clear();
+		item_textures_.clear();
+		balloon_textures_.clear();
+		explosions_textures_.clear();
+	}
 
 	// Texturas
-	bulletTexture = std::make_shared<Texture>(renderer, asset->get("bullet.png"));
-	gameTextTexture = std::make_shared<Texture>(renderer, asset->get("game_text.png"));
+	{
+		bullet_texture_ = std::make_shared<Texture>(renderer_, asset_->get("bullet.png"));
+		game_text_texture_ = std::make_shared<Texture>(renderer_, asset_->get("game_text.png"));
+	}
 
 	// Texturas - Globos
-	auto balloon1Texture = std::make_shared<Texture>(renderer, asset->get("balloon1.png"));
-	balloonTextures.push_back(balloon1Texture);
+	{
+		auto balloon1_texture = std::make_shared<Texture>(renderer_, asset_->get("balloon1.png"));
+		balloon_textures_.push_back(balloon1_texture);
 
-	auto balloon2Texture = std::make_shared<Texture>(renderer, asset->get("balloon2.png"));
-	balloonTextures.push_back(balloon2Texture);
+		auto balloon2_texture = std::make_shared<Texture>(renderer_, asset_->get("balloon2.png"));
+		balloon_textures_.push_back(balloon2_texture);
 
-	auto balloon3Texture = std::make_shared<Texture>(renderer, asset->get("balloon3.png"));
-	balloonTextures.push_back(balloon3Texture);
+		auto balloon3_texture = std::make_shared<Texture>(renderer_, asset_->get("balloon3.png"));
+		balloon_textures_.push_back(balloon3_texture);
 
-	auto balloon4Texture = std::make_shared<Texture>(renderer, asset->get("balloon4.png"));
-	balloonTextures.push_back(balloon4Texture);
+		auto balloon4_texture = std::make_shared<Texture>(renderer_, asset_->get("balloon4.png"));
+		balloon_textures_.push_back(balloon4_texture);
 
-	auto balloon5Texture = std::make_shared<Texture>(renderer, asset->get("powerball.png"));
-	balloonTextures.push_back(balloon5Texture);
+		auto balloon5_texture = std::make_shared<Texture>(renderer_, asset_->get("powerball.png"));
+		balloon_textures_.push_back(balloon5_texture);
 
-	// Texturas - Explosiones
-	auto explosion1Texture = std::make_shared<Texture>(renderer, asset->get("explosion1.png"));
-	explosionsTextures.push_back(explosion1Texture);
+		// Texturas - Explosiones
+		auto explosion1_texture = std::make_shared<Texture>(renderer_, asset_->get("explosion1.png"));
+		explosions_textures_.push_back(explosion1_texture);
 
-	auto explosion2Texture = std::make_shared<Texture>(renderer, asset->get("explosion2.png"));
-	explosionsTextures.push_back(explosion2Texture);
+		auto explosion2_texture = std::make_shared<Texture>(renderer_, asset_->get("explosion2.png"));
+		explosions_textures_.push_back(explosion2_texture);
 
-	auto explosion3Texture = std::make_shared<Texture>(renderer, asset->get("explosion3.png"));
-	explosionsTextures.push_back(explosion3Texture);
+		auto explosion3_texture = std::make_shared<Texture>(renderer_, asset_->get("explosion3.png"));
+		explosions_textures_.push_back(explosion3_texture);
 
-	auto explosion4Texture = std::make_shared<Texture>(renderer, asset->get("explosion4.png"));
-	explosionsTextures.push_back(explosion4Texture);
+		auto explosion4_texture = std::make_shared<Texture>(renderer_, asset_->get("explosion4.png"));
+		explosions_textures_.push_back(explosion4_texture);
+	}
 
 	// Texturas - Items
-	auto item1 = std::make_shared<Texture>(renderer, asset->get("item_points1_disk.png"));
-	itemTextures.push_back(item1);
+	{
+		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"));
-	itemTextures.push_back(item2);
+		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"));
-	itemTextures.push_back(item3);
+		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"));
-	itemTextures.push_back(item4);
+		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"));
-	itemTextures.push_back(item5);
+		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"));
-	itemTextures.push_back(item6);
+		auto item6 = std::make_shared<Texture>(renderer_, asset_->get("item_coffee_machine.png"));
+		item_textures_.push_back(item6);
+	}
 
 	// Texturas - Player1
-	auto player1 = std::make_shared<Texture>(renderer, asset->get("player1.gif"));
-	player1->addPalette(asset->get("player1_pal1.gif"));
-	player1->addPalette(asset->get("player1_pal2.gif"));
-	player1->addPalette(asset->get("player1_pal3.gif"));
-	player1Textures.push_back(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);
 
-	auto player1Power = std::make_shared<Texture>(renderer, asset->get("player_power.gif"));
-	player1Power->addPalette(asset->get("player_power_pal.gif"));
-	player1Textures.push_back(player1Power);
+		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);
 
-	playerTextures.push_back(player1Textures);
+		player_textures_.push_back(player1_textures_);
+	}
 
 	// Texturas - Player2
-	auto player2 = std::make_shared<Texture>(renderer, asset->get("player2.gif"));
-	player2->addPalette(asset->get("player2_pal1.gif"));
-	player2->addPalette(asset->get("player2_pal2.gif"));
-	player2->addPalette(asset->get("player2_pal3.gif"));
-	player2Textures.push_back(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);
 
-	auto player2Power = std::make_shared<Texture>(renderer, asset->get("player_power.gif"));
-	player2Power->addPalette(asset->get("player_power_pal.gif"));
-	player2Power->setPalette(1);
-	player2Textures.push_back(player2Power);
+		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);
 
-	playerTextures.push_back(player2Textures);
+		player_textures_.push_back(player2_textures_);
+	}
 
 	// Animaciones -- Jugador
 	{
-		std::vector<std::string> *playerAnimation = new std::vector<std::string>;
-		loadAnimations(asset->get("player.ani"), playerAnimation);
-		playerAnimations.push_back(playerAnimation);
+		std::vector<std::string> *player_animations = new std::vector<std::string>;
+		loadAnimations(asset_->get("player.ani"), player_animations);
+		player_animations_.push_back(player_animations);
 
-		std::vector<std::string> *playerPowerAnimation = new std::vector<std::string>;
-		loadAnimations(asset->get("player_power.ani"), playerPowerAnimation);
-		playerAnimations.push_back(playerPowerAnimation);
+		std::vector<std::string> *player_power_animations = new std::vector<std::string>;
+		loadAnimations(asset_->get("player_power.ani"), player_power_animations);
+		player_animations_.push_back(player_power_animations);
 	}
 
 	// Animaciones -- Globos
 	{
-		std::vector<std::string> *balloon1Animation = new std::vector<std::string>;
-		loadAnimations(asset->get("balloon1.ani"), balloon1Animation);
-		balloonAnimations.push_back(balloon1Animation);
+		std::vector<std::string> *balloon1_animations = new std::vector<std::string>;
+		loadAnimations(asset_->get("balloon1.ani"), balloon1_animations);
+		balloon_animations_.push_back(balloon1_animations);
 
-		std::vector<std::string> *balloon2Animation = new std::vector<std::string>;
-		loadAnimations(asset->get("balloon2.ani"), balloon2Animation);
-		balloonAnimations.push_back(balloon2Animation);
+		std::vector<std::string> *balloon2_animations = new std::vector<std::string>;
+		loadAnimations(asset_->get("balloon2.ani"), balloon2_animations);
+		balloon_animations_.push_back(balloon2_animations);
 
-		std::vector<std::string> *balloon3Animation = new std::vector<std::string>;
-		loadAnimations(asset->get("balloon3.ani"), balloon3Animation);
-		balloonAnimations.push_back(balloon3Animation);
+		std::vector<std::string> *balloon3_animations = new std::vector<std::string>;
+		loadAnimations(asset_->get("balloon3.ani"), balloon3_animations);
+		balloon_animations_.push_back(balloon3_animations);
 
-		std::vector<std::string> *balloon4Animation = new std::vector<std::string>;
-		loadAnimations(asset->get("balloon4.ani"), balloon4Animation);
-		balloonAnimations.push_back(balloon4Animation);
+		std::vector<std::string> *balloon4_animations = new std::vector<std::string>;
+		loadAnimations(asset_->get("balloon4.ani"), balloon4_animations);
+		balloon_animations_.push_back(balloon4_animations);
 
-		std::vector<std::string> *balloon5Animation = new std::vector<std::string>;
-		loadAnimations(asset->get("powerball.ani"), balloon5Animation);
-		balloonAnimations.push_back(balloon5Animation);
+		std::vector<std::string> *balloon5_animations = new std::vector<std::string>;
+		loadAnimations(asset_->get("powerball.ani"), balloon5_animations);
+		balloon_animations_.push_back(balloon5_animations);
 	}
 
 	// Animaciones -- Explosiones
-	std::vector<std::string> *explosions1Animation = new std::vector<std::string>;
-	loadAnimations(asset->get("explosion1.ani"), explosions1Animation);
-	explosionsAnimations.push_back(explosions1Animation);
+	{
+		std::vector<std::string> *explosions1_animations = new std::vector<std::string>;
+		loadAnimations(asset_->get("explosion1.ani"), explosions1_animations);
+		explosions_animations_.push_back(explosions1_animations);
 
-	std::vector<std::string> *explosions2Animation = new std::vector<std::string>;
-	loadAnimations(asset->get("explosion2.ani"), explosions2Animation);
-	explosionsAnimations.push_back(explosions2Animation);
+		std::vector<std::string> *explosions2_animations = new std::vector<std::string>;
+		loadAnimations(asset_->get("explosion2.ani"), explosions2_animations);
+		explosions_animations_.push_back(explosions2_animations);
 
-	std::vector<std::string> *explosions3Animation = new std::vector<std::string>;
-	loadAnimations(asset->get("explosion3.ani"), explosions3Animation);
-	explosionsAnimations.push_back(explosions3Animation);
+		std::vector<std::string> *explosions3_animations = new std::vector<std::string>;
+		loadAnimations(asset_->get("explosion3.ani"), explosions3_animations);
+		explosions_animations_.push_back(explosions3_animations);
 
-	std::vector<std::string> *explosions4Animation = new std::vector<std::string>;
-	loadAnimations(asset->get("explosion4.ani"), explosions4Animation);
-	explosionsAnimations.push_back(explosions4Animation);
+		std::vector<std::string> *explosions4_animations = new std::vector<std::string>;
+		loadAnimations(asset_->get("explosion4.ani"), explosions4_animations);
+		explosions_animations_.push_back(explosions4_animations);
+	}
 
 	// Animaciones -- Items
-	std::vector<std::string> *item1Animation = new std::vector<std::string>;
-	loadAnimations(asset->get("item_points1_disk.ani"), item1Animation);
-	itemAnimations.push_back(item1Animation);
+	{
+		std::vector<std::string> *item1_animations = new std::vector<std::string>;
+		loadAnimations(asset_->get("item_points1_disk.ani"), item1_animations);
+		item_animations_.push_back(item1_animations);
 
-	std::vector<std::string> *item2Animation = new std::vector<std::string>;
-	loadAnimations(asset->get("item_points2_gavina.ani"), item2Animation);
-	itemAnimations.push_back(item2Animation);
+		std::vector<std::string> *item2_animations = new std::vector<std::string>;
+		loadAnimations(asset_->get("item_points2_gavina.ani"), item2_animations);
+		item_animations_.push_back(item2_animations);
 
-	std::vector<std::string> *item3Animation = new std::vector<std::string>;
-	loadAnimations(asset->get("item_points3_pacmar.ani"), item3Animation);
-	itemAnimations.push_back(item3Animation);
+		std::vector<std::string> *item3_animations = new std::vector<std::string>;
+		loadAnimations(asset_->get("item_points3_pacmar.ani"), item3_animations);
+		item_animations_.push_back(item3_animations);
 
-	std::vector<std::string> *item4Animation = new std::vector<std::string>;
-	loadAnimations(asset->get("item_clock.ani"), item4Animation);
-	itemAnimations.push_back(item4Animation);
+		std::vector<std::string> *item4_animations = new std::vector<std::string>;
+		loadAnimations(asset_->get("item_clock.ani"), item4_animations);
+		item_animations_.push_back(item4_animations);
 
-	std::vector<std::string> *item5Animation = new std::vector<std::string>;
-	loadAnimations(asset->get("item_coffee.ani"), item5Animation);
-	itemAnimations.push_back(item5Animation);
+		std::vector<std::string> *item5_animations = new std::vector<std::string>;
+		loadAnimations(asset_->get("item_coffee.ani"), item5_animations);
+		item_animations_.push_back(item5_animations);
 
-	std::vector<std::string> *item6Animation = new std::vector<std::string>;
-	loadAnimations(asset->get("item_coffee_machine.ani"), item6Animation);
-	itemAnimations.push_back(item6Animation);
+		std::vector<std::string> *item6_animations = new std::vector<std::string>;
+		loadAnimations(asset_->get("item_coffee_machine.ani"), item6_animations);
+		item_animations_.push_back(item6_animations);
+	}
 
 	// Texto
-	text = std::make_unique<Text>(asset->get("smb2.gif"), asset->get("smb2.txt"), renderer);
-	textBig = std::make_unique<Text>(asset->get("smb2_big.png"), asset->get("smb2_big.txt"), renderer);
-	textNokia2 = std::make_unique<Text>(asset->get("nokia2.png"), asset->get("nokia2.txt"), renderer);
-	textNokiaBig2 = std::make_unique<Text>(asset->get("nokia_big2.png"), asset->get("nokia_big2.txt"), renderer);
+	{
+		text_ = std::make_unique<Text>(asset_->get("smb2.gif"), asset_->get("smb2.txt"), renderer_);
+		text_big_ = std::make_unique<Text>(asset_->get("smb2_big.png"), asset_->get("smb2_big.txt"), renderer_);
+		text_nokia2_ = std::make_unique<Text>(asset_->get("nokia2.png"), asset_->get("nokia2.txt"), renderer_);
+		text_nokia2_big_ = std::make_unique<Text>(asset_->get("nokia_big2.png"), asset_->get("nokia_big2.txt"), renderer_);
+	}
 
 	// Sonidos
-	balloonSound = JA_LoadSound(asset->get("balloon.wav").c_str());
-	bubble1Sound = JA_LoadSound(asset->get("bubble1.wav").c_str());
-	bubble2Sound = JA_LoadSound(asset->get("bubble2.wav").c_str());
-	bubble3Sound = JA_LoadSound(asset->get("bubble3.wav").c_str());
-	bubble4Sound = JA_LoadSound(asset->get("bubble4.wav").c_str());
-	bulletSound = JA_LoadSound(asset->get("bullet.wav").c_str());
-	clockSound = JA_LoadSound(asset->get("clock.wav").c_str());
-	coffeeOutSound = JA_LoadSound(asset->get("coffeeout.wav").c_str());
-	hiScoreSound = JA_LoadSound(asset->get("hiscore.wav").c_str());
-	itemDropSound = JA_LoadSound(asset->get("itemdrop.wav").c_str());
-	itemPickUpSound = JA_LoadSound(asset->get("itempickup.wav").c_str());
-	playerCollisionSound = JA_LoadSound(asset->get("player_collision.wav").c_str());
-	powerBallSound = JA_LoadSound(asset->get("powerball.wav").c_str());
-	stageChangeSound = JA_LoadSound(asset->get("stage_change.wav").c_str());
-	coffeeMachineSound = JA_LoadSound(asset->get("title.wav").c_str());
+	{
+		balloon_sound_ = JA_LoadSound(asset_->get("balloon.wav").c_str());
+		bubble1_sound_ = JA_LoadSound(asset_->get("bubble1.wav").c_str());
+		bubble2_sound_ = JA_LoadSound(asset_->get("bubble2.wav").c_str());
+		bubble3_sound_ = JA_LoadSound(asset_->get("bubble3.wav").c_str());
+		bubble4_sound_ = JA_LoadSound(asset_->get("bubble4.wav").c_str());
+		bullet_sound_ = JA_LoadSound(asset_->get("bullet.wav").c_str());
+		clock_sound_ = JA_LoadSound(asset_->get("clock.wav").c_str());
+		coffee_out_sound_ = JA_LoadSound(asset_->get("coffeeout.wav").c_str());
+		hi_score_sound_ = JA_LoadSound(asset_->get("hiscore.wav").c_str());
+		item_drop_sound_ = JA_LoadSound(asset_->get("itemdrop.wav").c_str());
+		item_pick_up_sound_ = JA_LoadSound(asset_->get("itempickup.wav").c_str());
+		player_collision_sound_ = JA_LoadSound(asset_->get("player_collision.wav").c_str());
+		power_ball_sound_ = JA_LoadSound(asset_->get("powerball.wav").c_str());
+		stage_change_sound_ = JA_LoadSound(asset_->get("stage_change.wav").c_str());
+		coffee_machine_sound_ = JA_LoadSound(asset_->get("title.wav").c_str());
+	}
 
 #ifdef VERBOSE
-	std::cout << "** RESOURCES FOR GAME SECTION LOADED" << std::endl
-			  << std::endl;
+	std::cout << "** RESOURCES FOR GAME SECTION LOADED\n"  << std::endl;
 #endif
 }
 
@@ -551,58 +566,58 @@ void Game::loadMedia()
 void Game::unloadMedia()
 {
 	// Texturas
-	player1Textures.clear();
-	player2Textures.clear();
-	itemTextures.clear();
-	balloonTextures.clear();
-	explosionsTextures.clear();
+	player1_textures_.clear();
+	player2_textures_.clear();
+	item_textures_.clear();
+	balloon_textures_.clear();
+	explosions_textures_.clear();
 
 	// Animaciones
-	playerAnimations.clear();
-	balloonAnimations.clear();
-	explosionsAnimations.clear();
-	itemAnimations.clear();
+	player_animations_.clear();
+	balloon_animations_.clear();
+	explosions_animations_.clear();
+	item_animations_.clear();
 
 	// Sonidos
-	JA_DeleteSound(balloonSound);
-	JA_DeleteSound(bulletSound);
-	JA_DeleteSound(playerCollisionSound);
-	JA_DeleteSound(hiScoreSound);
-	JA_DeleteSound(itemDropSound);
-	JA_DeleteSound(itemPickUpSound);
-	JA_DeleteSound(coffeeOutSound);
-	JA_DeleteSound(stageChangeSound);
-	JA_DeleteSound(bubble1Sound);
-	JA_DeleteSound(bubble2Sound);
-	JA_DeleteSound(bubble3Sound);
-	JA_DeleteSound(bubble4Sound);
-	JA_DeleteSound(clockSound);
-	JA_DeleteSound(powerBallSound);
-	JA_DeleteSound(coffeeMachineSound);
+	JA_DeleteSound(balloon_sound_);
+	JA_DeleteSound(bullet_sound_);
+	JA_DeleteSound(player_collision_sound_);
+	JA_DeleteSound(hi_score_sound_);
+	JA_DeleteSound(item_drop_sound_);
+	JA_DeleteSound(item_pick_up_sound_);
+	JA_DeleteSound(coffee_out_sound_);
+	JA_DeleteSound(stage_change_sound_);
+	JA_DeleteSound(bubble1_sound_);
+	JA_DeleteSound(bubble2_sound_);
+	JA_DeleteSound(bubble3_sound_);
+	JA_DeleteSound(bubble4_sound_);
+	JA_DeleteSound(clock_sound_);
+	JA_DeleteSound(power_ball_sound_);
+	JA_DeleteSound(coffee_machine_sound_);
 }
 
 // Carga el fichero de datos para la demo
-bool Game::loadDemoFile(std::string filePath, DemoKeys (*dataFile)[TOTAL_DEMO_DATA])
+bool Game::loadDemoFile(std::string file_path, DemoKeys (*data_file)[TOTAL_DEMO_DATA])
 {
 	// Indicador de éxito en la carga
 	auto success = true;
-	const std::string fileName = filePath.substr(filePath.find_last_of("\\/") + 1);
+	const std::string file_name = file_path.substr(file_path.find_last_of("\\/") + 1);
 
-	auto file = SDL_RWFromFile(filePath.c_str(), "r+b");
+	auto file = SDL_RWFromFile(file_path.c_str(), "r+b");
 	if (!file)
 	{ // El fichero no existe
 #ifdef VERBOSE
-		std::cout << "Warning: Unable to open " << fileName.c_str() << " file" << std::endl;
+		std::cout << "Warning: Unable to open " << file_name.c_str() << " file" << std::endl;
 #endif
 
 		// Creamos el fichero para escritura
-		file = SDL_RWFromFile(filePath.c_str(), "w+b");
+		file = SDL_RWFromFile(file_path.c_str(), "w+b");
 
 		// Si ha creado el fichero
 		if (file)
 		{
 #ifdef VERBOSE
-			std::cout << "New file (" << fileName.c_str() << ") created!" << std::endl;
+			std::cout << "New file (" << file_name.c_str() << ") created!" << std::endl;
 #endif
 
 			// Inicializas los datos y los guarda en el fichero
@@ -615,7 +630,7 @@ bool Game::loadDemoFile(std::string filePath, DemoKeys (*dataFile)[TOTAL_DEMO_DA
 				dk.fire = 0;
 				dk.fire_left = 0;
 				dk.fire_right = 0;
-				(*dataFile)[i] = dk;
+				(*data_file)[i] = dk;
 				SDL_RWwrite(file, &dk, sizeof(DemoKeys), 1);
 			}
 
@@ -625,7 +640,7 @@ bool Game::loadDemoFile(std::string filePath, DemoKeys (*dataFile)[TOTAL_DEMO_DA
 		else
 		{ // Si no puede crear el fichero
 #ifdef VERBOSE
-			std::cout << "Error: Unable to create file " << fileName.c_str() << std::endl;
+			std::cout << "Error: Unable to create file " << file_name.c_str() << std::endl;
 #endif
 			success = false;
 		}
@@ -635,7 +650,7 @@ bool Game::loadDemoFile(std::string filePath, DemoKeys (*dataFile)[TOTAL_DEMO_DA
 	{
 // Mensaje de proceder a la carga de los datos
 #ifdef VERBOSE
-		std::cout << "Reading file: " << fileName.c_str() << std::endl;
+		std::cout << "Reading file: " << file_name.c_str() << std::endl;
 #endif
 
 		// Lee todos los datos del fichero y los deja en el destino
@@ -643,7 +658,7 @@ bool Game::loadDemoFile(std::string filePath, DemoKeys (*dataFile)[TOTAL_DEMO_DA
 		{
 			DemoKeys tmp;
 			SDL_RWread(file, &tmp, sizeof(DemoKeys), 1);
-			(*dataFile)[i] = tmp;
+			(*data_file)[i] = tmp;
 		}
 
 		// Cierra el fichero
@@ -655,31 +670,31 @@ bool Game::loadDemoFile(std::string filePath, DemoKeys (*dataFile)[TOTAL_DEMO_DA
 
 #ifdef RECORDING
 // Guarda el fichero de datos para la demo
-bool Game::saveDemoFile(std::string filePath)
+bool Game::saveDemoFile(std::string file_path)
 {
 	auto success = true;
-	const std::string filename = filePath.substr(filePath.find_last_of("\\/") + 1);
+	const std::string file_name = file_path.substr(file_path.find_last_of("\\/") + 1);
 
-	auto file = SDL_RWFromFile(filePath.c_str(), "w+b");
+	auto file = SDL_RWFromFile(file_path.c_str(), "w+b");
 	if (file)
 	{
-		// Guardamos los datos
+		// Guarda los datos
 		for (int i = 0; i < TOTAL_DEMO_DATA; ++i)
 		{
 			SDL_RWwrite(file, &demo.dataFile[0][i], sizeof(DemoKeys), 1);
 		}
 
 #ifdef VERBOSE
-		std::cout << "Writing file " << filename.c_str() << std::endl;
+		std::cout << "Writing file " << file_name.c_str() << std::endl;
 #endif // VERBOSE
 
-		// Cerramos el fichero
+		// Cierra el fichero
 		SDL_RWclose(file);
 	}
 	else
 	{
 #ifdef VERBOSE
-		std::cout << "Error: Unable to save " << filename.c_str() << " file! " << SDL_GetError() << std::endl;
+		std::cout << "Error: Unable to save " << file_name.c_str() << " file! " << SDL_GetError() << std::endl;
 #endif // VERBOSE
 	}
 
@@ -691,7 +706,7 @@ bool Game::saveDemoFile(std::string filePath)
 void Game::deployEnemyFormation()
 {
 	// Solo despliega una formación enemiga si ha pasado cierto tiempo desde la última
-	if (enemyDeployCounter == 0)
+	if (enemy_deploy_counter_ == 0)
 	{
 
 		// En este punto se decide entre crear una powerball o una formación enemiga
@@ -701,25 +716,25 @@ void Game::deployEnemyFormation()
 			createPowerBall();
 
 			// Da un poco de margen para que se creen mas enemigos
-			enemyDeployCounter = 300;
+			enemy_deploy_counter_ = 300;
 		}
 		else
 		{
 			// Decrementa el contador de despliegues enemigos de la PowerBall
-			powerBallCounter > 0 ? powerBallCounter-- : powerBallCounter = 0;
+			power_ball_counter_ > 0 ? power_ball_counter_-- : power_ball_counter_ = 0;
 
 			// Elige una formación enemiga la azar
 			auto set = rand() % 10;
 
 			// Evita repetir la ultima formación enemiga desplegada
-			if (set == lastEnemyDeploy)
+			if (set == last_enemy_deploy_)
 			{
 				++set %= 10;
 			}
 
-			lastEnemyDeploy = set;
+			last_enemy_deploy_ = set;
 
-			const Stage stage = enemyFormations->getStage(currentStage);
+			const Stage stage = enemy_formations_->getStage(current_stage_);
 			const auto numEnemies = stage.enemy_pool->set[set]->number_of_enemies;
 			for (int i = 0; i < numEnemies; ++i)
 			{
@@ -727,11 +742,11 @@ void Game::deployEnemyFormation()
 							  stage.enemy_pool->set[set]->init[i].y,
 							  stage.enemy_pool->set[set]->init[i].kind,
 							  stage.enemy_pool->set[set]->init[i].vel_x,
-							  enemySpeed,
+							  enemy_speed_,
 							  stage.enemy_pool->set[set]->init[i].creation_counter);
 			}
 
-			enemyDeployCounter = 300;
+			enemy_deploy_counter_ = 300;
 		}
 	}
 }
@@ -739,25 +754,25 @@ void Game::deployEnemyFormation()
 // Aumenta el poder de la fase
 void Game::increaseStageCurrentPower(int power)
 {
-	currentPower += power;
+	current_power_ += power;
 }
 
 // Actualiza el valor de hiScore en caso necesario
 void Game::updateHiScore()
 {
 	// Si la puntuación actual es mayor que la máxima puntuación
-	for (auto &player : players)
+	for (auto &player : players_)
 	{
-		if (player->getScore() > hiScore.score)
+		if (player->getScore() > hi_score_.score)
 		{
 			// Actualiza la máxima puntuación
-			hiScore.score = player->getScore();
+			hi_score_.score = player->getScore();
 
 			// Si se supera la máxima puntuación emite sonido
-			if (hiScoreAchieved == false)
+			if (hi_score_achieved_ == false)
 			{
-				hiScoreAchieved = true;
-				JA_PlaySound(hiScoreSound);
+				hi_score_achieved_ = true;
+				JA_PlaySound(hi_score_sound_);
 			}
 		}
 	}
@@ -766,7 +781,7 @@ void Game::updateHiScore()
 // Actualiza las variables del jugador
 void Game::updatePlayers()
 {
-	for (auto &player : players)
+	for (auto &player : players_)
 	{
 		player->update();
 
@@ -777,10 +792,10 @@ void Game::updatePlayers()
 			{
 				killPlayer(player);
 
-				if (demo.enabled && allPlayersAreNotPlaying())
+				if (demo_.enabled && allPlayersAreNotPlaying())
 				{
-					fade->setType(FadeType::RANDOM_SQUARE);
-					fade->activate();
+					fade_->setType(FadeType::RANDOM_SQUARE);
+					fade_->activate();
 				}
 			}
 
@@ -793,7 +808,7 @@ void Game::updatePlayers()
 // Dibuja a los jugadores
 void Game::renderPlayers()
 {
-	for (auto &player : players)
+	for (auto &player : players_)
 	{
 		if (!player->isWaiting())
 		{
@@ -810,20 +825,20 @@ void Game::renderPlayers()
 // Comprueba si hay cambio de fase y actualiza las variables
 void Game::updateStage()
 {
-	if (currentPower >= enemyFormations->getStage(currentStage).power_to_complete)
+	if (current_power_ >= enemy_formations_->getStage(current_stage_).power_to_complete)
 	{
 		// Cambio de fase
-		currentStage++;
-		currentPower = 0;
-		lastStageReached = currentStage;
-		if (currentStage == 10)
-		{						  // Ha llegado al final el juego
-			gameCompleted = true; // Marca el juego como completado
-			currentStage = 9;	  // Deja el valor dentro de los limites
-			destroyAllBalloons(); // Destruye a todos los enemigos
-			currentPower = 0;	  // Vuelve a dejar el poder a cero, por lo que hubiera podido subir al destruir todos lo globos
-			menaceCurrent = 255;  // Sube el nivel de amenaza para que no cree mas globos
-			for (auto &player : players)
+		current_stage_++;
+		current_power_ = 0;
+		last_stage_reached_ = current_stage_;
+		if (current_stage_ == 10)
+		{							// Ha llegado al final el juego
+			game_completed_ = true; // Marca el juego como completado
+			current_stage_ = 9;		// Deja el valor dentro de los limites
+			destroyAllBalloons();	// Destruye a todos los enemigos
+			current_power_ = 0;		// Vuelve a dejar el poder a cero, por lo que hubiera podido subir al destruir todos lo globos
+			menace_current_ = 255;	// Sube el nivel de amenaza para que no cree mas globos
+			for (auto &player : players_)
 			{ // Añade un millon de puntos a los jugadores que queden vivos
 				if (player->isPlaying())
 				{
@@ -833,26 +848,26 @@ void Game::updateStage()
 			updateHiScore();
 			JA_StopMusic();
 		}
-		JA_PlaySound(stageChangeSound);
-		stageBitmapCounter = 0;
-		enemySpeed = defaultEnemySpeed;
-		setBalloonSpeed(enemySpeed);
-		screen->flash(flash_color, 5);
-		screen->shake();
+		JA_PlaySound(stage_change_sound_);
+		stage_bitmap_counter_ = 0;
+		enemy_speed_ = default_enemy_speed_;
+		setBalloonSpeed(enemy_speed_);
+		screen_->flash(flash_color, 5);
+		screen_->shake();
 	}
 
 	// Incrementa el contador del bitmap que aparece mostrando el cambio de fase
-	if (stageBitmapCounter < STAGE_COUNTER)
+	if (stage_bitmap_counter_ < STAGE_COUNTER)
 	{
-		stageBitmapCounter++;
+		stage_bitmap_counter_++;
 	}
 
 	// Si el juego se ha completado, el bitmap se detiene en el centro de la pantalla
-	if (gameCompleted)
+	if (game_completed_)
 	{
-		if (stageBitmapCounter > 100)
+		if (stage_bitmap_counter_ > 100)
 		{
-			stageBitmapCounter = 100;
+			stage_bitmap_counter_ = 100;
 		}
 	}
 }
@@ -863,25 +878,25 @@ void Game::updateGameOver()
 	// Si todos estan en estado de Game Over
 	if (allPlayersAreGameOver())
 	{
-		if (gameOverCounter > 0)
+		if (game_over_counter_ > 0)
 		{
-			gameOverCounter--;
+			game_over_counter_--;
 
-			if ((gameOverCounter == 250) || (gameOverCounter == 200) || (gameOverCounter == 180) || (gameOverCounter == 120) || (gameOverCounter == 60))
+			if ((game_over_counter_ == 250) || (game_over_counter_ == 200) || (game_over_counter_ == 180) || (game_over_counter_ == 120) || (game_over_counter_ == 60))
 			{
 				// Hace sonar aleatoriamente uno de los 4 sonidos de burbujas
 				const auto index = rand() % 4;
-				JA_Sound_t *sound[4] = {bubble1Sound, bubble2Sound, bubble3Sound, bubble4Sound};
+				JA_Sound_t *sound[4] = {bubble1_sound_, bubble2_sound_, bubble3_sound_, bubble4_sound_};
 				JA_PlaySound(sound[index], 0);
 			}
 
-			if (gameOverCounter == 150)
+			if (game_over_counter_ == 150)
 			{
-				fade->activate();
+				fade_->activate();
 			}
 		}
 
-		if (fade->hasEnded())
+		if (fade_->hasEnded())
 		{
 			section::name = section::Name::HI_SCORE_TABLE;
 		}
@@ -891,7 +906,7 @@ void Game::updateGameOver()
 // Actualiza los globos
 void Game::updateBalloons()
 {
-	for (auto balloon : balloons)
+	for (auto balloon : balloons_)
 	{
 		balloon->update();
 	}
@@ -900,18 +915,18 @@ void Game::updateBalloons()
 // Pinta en pantalla todos los globos activos
 void Game::renderBalloons()
 {
-	for (auto &balloon : balloons)
+	for (auto &balloon : balloons_)
 	{
 		balloon->render();
 	}
 }
 
 // Crea un globo nuevo en el vector de globos
-std::shared_ptr<Balloon> Game::createBalloon(float x, int y, int kind, float velx, float speed, int creationtimer)
+std::shared_ptr<Balloon> Game::createBalloon(float x, int y, int kind, float velx, float speed, int creation_timer)
 {
 	const auto index = (kind - 1) % 4;
-	auto b = std::make_shared<Balloon>(x, y, kind, velx, speed, creationtimer, balloonTextures[index], balloonAnimations[index]);
-	balloons.push_back(b);
+	auto b = std::make_shared<Balloon>(x, y, kind, velx, speed, creation_timer, balloon_textures_[index], balloon_animations_[index]);
+	balloons_.push_back(b);
 	return b;
 }
 
@@ -925,24 +940,24 @@ void Game::createPowerBall()
 	const auto center = param.game.play_area.center_x - (BALLOON_WIDTH_4 / 2);
 	const auto right = param.game.play_area.rect.w - BALLOON_WIDTH_4;
 
-	const auto vpos = BALLOON_VELX_POSITIVE;
-	const auto vneg = BALLOON_VELX_NEGATIVE;
+	const auto vel_pos = BALLOON_VELX_POSITIVE;
+	const auto vel_neg = BALLOON_VELX_NEGATIVE;
 
 	const auto luck = rand() % values;
 	const int x[values] = {left, left, center, center, right, right};
-	const float vx[values] = {vpos, vpos, vpos, vneg, vneg, vneg};
+	const float vx[values] = {vel_pos, vel_pos, vel_pos, vel_neg, vel_neg, vel_neg};
 
-	auto b = std::make_unique<Balloon>(x[luck], posY, POWER_BALL, vx[luck], enemySpeed, 300, balloonTextures[4], balloonAnimations[4]);
-	balloons.push_back(std::move(b));
+	auto b = std::make_unique<Balloon>(x[luck], posY, POWER_BALL, vx[luck], enemy_speed_, 300, balloon_textures_[4], balloon_animations_[4]);
+	balloons_.push_back(std::move(b));
 
-	powerBallEnabled = true;
-	powerBallCounter = POWERBALL_COUNTER;
+	power_ball_enabled_ = true;
+	power_ball_counter_ = POWERBALL_COUNTER;
 }
 
 // Establece la velocidad de los globos
 void Game::setBalloonSpeed(float speed)
 {
-	for (auto &balloon : balloons)
+	for (auto &balloon : balloons_)
 	{
 		if (balloon->isEnabled())
 		{
@@ -955,29 +970,29 @@ void Game::setBalloonSpeed(float speed)
 void Game::incBalloonSpeed()
 {
 	// La velocidad solo se incrementa en el modo normal
-	if (difficulty == GameDifficulty::NORMAL)
+	if (difficulty_ == GameDifficulty::NORMAL)
 	{
-		if (enemySpeed == BALLOON_SPEED_1)
+		if (enemy_speed_ == BALLOON_SPEED_1)
 		{
-			enemySpeed = BALLOON_SPEED_2;
+			enemy_speed_ = BALLOON_SPEED_2;
 		}
 
-		else if (enemySpeed == BALLOON_SPEED_2)
+		else if (enemy_speed_ == BALLOON_SPEED_2)
 		{
-			enemySpeed = BALLOON_SPEED_3;
+			enemy_speed_ = BALLOON_SPEED_3;
 		}
 
-		else if (enemySpeed == BALLOON_SPEED_3)
+		else if (enemy_speed_ == BALLOON_SPEED_3)
 		{
-			enemySpeed = BALLOON_SPEED_4;
+			enemy_speed_ = BALLOON_SPEED_4;
 		}
 
-		else if (enemySpeed == BALLOON_SPEED_4)
+		else if (enemy_speed_ == BALLOON_SPEED_4)
 		{
-			enemySpeed = BALLOON_SPEED_5;
+			enemy_speed_ = BALLOON_SPEED_5;
 		}
 
-		setBalloonSpeed(enemySpeed);
+		setBalloonSpeed(enemy_speed_);
 	}
 }
 
@@ -985,37 +1000,37 @@ void Game::incBalloonSpeed()
 void Game::decBalloonSpeed()
 {
 	// La velocidad solo se decrementa en el modo normal
-	if (difficulty == GameDifficulty::NORMAL)
+	if (difficulty_ == GameDifficulty::NORMAL)
 	{
-		if (enemySpeed == BALLOON_SPEED_5)
+		if (enemy_speed_ == BALLOON_SPEED_5)
 		{
-			enemySpeed = BALLOON_SPEED_4;
+			enemy_speed_ = BALLOON_SPEED_4;
 		}
 
-		else if (enemySpeed == BALLOON_SPEED_4)
+		else if (enemy_speed_ == BALLOON_SPEED_4)
 		{
-			enemySpeed = BALLOON_SPEED_3;
+			enemy_speed_ = BALLOON_SPEED_3;
 		}
 
-		else if (enemySpeed == BALLOON_SPEED_3)
+		else if (enemy_speed_ == BALLOON_SPEED_3)
 		{
-			enemySpeed = BALLOON_SPEED_2;
+			enemy_speed_ = BALLOON_SPEED_2;
 		}
 
-		else if (enemySpeed == BALLOON_SPEED_2)
+		else if (enemy_speed_ == BALLOON_SPEED_2)
 		{
-			enemySpeed = BALLOON_SPEED_1;
+			enemy_speed_ = BALLOON_SPEED_1;
 		}
 
-		setBalloonSpeed(enemySpeed);
+		setBalloonSpeed(enemy_speed_);
 	}
 }
 
 // Actualiza la velocidad de los globos en funcion del poder acumulado de la fase
 void Game::updateBalloonSpeed()
 {
-	const float percent = (float)currentPower / (float)enemyFormations->getStage(currentStage).power_to_complete;
-	if (enemySpeed == BALLOON_SPEED_1)
+	const float percent = (float)current_power_ / (float)enemy_formations_->getStage(current_stage_).power_to_complete;
+	if (enemy_speed_ == BALLOON_SPEED_1)
 	{
 		if (percent > 0.2f)
 		{
@@ -1023,7 +1038,7 @@ void Game::updateBalloonSpeed()
 		}
 	}
 
-	else if (enemySpeed == BALLOON_SPEED_2)
+	else if (enemy_speed_ == BALLOON_SPEED_2)
 	{
 		if (percent > 0.4f)
 		{
@@ -1031,7 +1046,7 @@ void Game::updateBalloonSpeed()
 		}
 	}
 
-	else if (enemySpeed == BALLOON_SPEED_3)
+	else if (enemy_speed_ == BALLOON_SPEED_3)
 	{
 		if (percent > 0.6f)
 		{
@@ -1039,7 +1054,7 @@ void Game::updateBalloonSpeed()
 		}
 	}
 
-	else if (enemySpeed == BALLOON_SPEED_4)
+	else if (enemy_speed_ == BALLOON_SPEED_4)
 	{
 		if (percent > 0.8f)
 		{
@@ -1053,35 +1068,35 @@ void Game::popBalloon(std::shared_ptr<Balloon> balloon)
 {
 	// Aumenta el poder de la fase
 	increaseStageCurrentPower(1);
-	balloonsPopped++;
+	balloons_popped_++;
 
 	const auto kind = balloon->getKind();
 	if (kind == POWER_BALL)
 	{
 		destroyAllBalloons();
-		powerBallEnabled = false;
-		enemyDeployCounter = 20;
+		power_ball_enabled_ = false;
+		enemy_deploy_counter_ = 20;
 	}
 	else
 	{
 		const auto size = balloon->getSize();
 		if (size == BALLOON_SIZE_1)
 		{ // Si es del tipo más pequeño, simplemente elimina el globo
-			explosions->add(balloon->getPosX(), balloon->getPosY(), size);
+			explosions_->add(balloon->getPosX(), balloon->getPosY(), size);
 			balloon->pop();
 		}
 		else
 		{ // En cualquier otro caso, crea dos globos de un tipo inferior
-			auto bLeft = createBalloon(0, balloon->getPosY(), balloon->getKind() - 1, BALLOON_VELX_NEGATIVE, enemySpeed, 0);
-			bLeft->allignTo(balloon->getPosX() + (balloon->getWidth() / 2));
-			bLeft->setVelY(bLeft->getClass() == BALLOON_CLASS ? -2.50f : BALLOON_VELX_NEGATIVE);
+			auto balloon_left = createBalloon(0, balloon->getPosY(), balloon->getKind() - 1, BALLOON_VELX_NEGATIVE, enemy_speed_, 0);
+			balloon_left->allignTo(balloon->getPosX() + (balloon->getWidth() / 2));
+			balloon_left->setVelY(balloon_left->getClass() == BALLOON_CLASS ? -2.50f : BALLOON_VELX_NEGATIVE);
 
-			auto bRight = createBalloon(0, balloon->getPosY(), balloon->getKind() - 1, BALLOON_VELX_POSITIVE, enemySpeed, 0);
-			bRight->allignTo(balloon->getPosX() + (balloon->getWidth() / 2));
-			bRight->setVelY(bRight->getClass() == BALLOON_CLASS ? -2.50f : BALLOON_VELX_NEGATIVE);
+			auto balloon_right = createBalloon(0, balloon->getPosY(), balloon->getKind() - 1, BALLOON_VELX_POSITIVE, enemy_speed_, 0);
+			balloon_right->allignTo(balloon->getPosX() + (balloon->getWidth() / 2));
+			balloon_right->setVelY(balloon_right->getClass() == BALLOON_CLASS ? -2.50f : BALLOON_VELX_NEGATIVE);
 
 			// Elimina el globo
-			explosions->add(balloon->getPosX(), balloon->getPosY(), size);
+			explosions_->add(balloon->getPosX(), balloon->getPosY(), size);
 			balloon->pop();
 		}
 	}
@@ -1131,19 +1146,19 @@ void Game::destroyBalloon(std::shared_ptr<Balloon> &balloon)
 	}
 
 	// Otorga los puntos correspondientes al globo
-	for (auto &player : players)
+	for (auto &player : players_)
 	{
-		player->addScore(score * player->getScoreMultiplier() * difficultyScoreMultiplier);
+		player->addScore(score * player->getScoreMultiplier() * difficulty_score_multiplier_);
 	}
 	updateHiScore();
 
 	// Aumenta el poder de la fase
 	const auto power = balloon->getPower();
 	increaseStageCurrentPower(power);
-	balloonsPopped += power;
+	balloons_popped_ += power;
 
 	// Destruye el globo
-	explosions->add(balloon->getPosX(), balloon->getPosY(), size);
+	explosions_->add(balloon->getPosX(), balloon->getPosY(), size);
 	balloon->pop();
 
 	// Recalcula el nivel de amenaza
@@ -1153,7 +1168,7 @@ void Game::destroyBalloon(std::shared_ptr<Balloon> &balloon)
 // Explosiona todos los globos
 void Game::popAllBalloons()
 {
-	for (auto &balloon : balloons)
+	for (auto &balloon : balloons_)
 	{
 		if (balloon->canBePopped())
 		{
@@ -1161,13 +1176,13 @@ void Game::popAllBalloons()
 		}
 	}
 
-	JA_PlaySound(balloonSound);
+	JA_PlaySound(balloon_sound_);
 }
 
 // Destruye todos los globos
 void Game::destroyAllBalloons()
 {
-	for (auto &balloon : balloons)
+	for (auto &balloon : balloons_)
 	{
 		if (balloon->canBeDestroyed())
 		{
@@ -1175,16 +1190,16 @@ void Game::destroyAllBalloons()
 		}
 	}
 
-	enemyDeployCounter = 300;
-	JA_PlaySound(powerBallSound);
-	screen->flash(flash_color, 5);
-	screen->shake();
+	enemy_deploy_counter_ = 300;
+	JA_PlaySound(power_ball_sound_);
+	screen_->flash(flash_color, 5);
+	screen_->shake();
 }
 
 // Detiene todos los globos
 void Game::stopAllBalloons(int time)
 {
-	for (auto &balloon : balloons)
+	for (auto &balloon : balloons_)
 	{
 		if (balloon->isEnabled())
 		{
@@ -1197,7 +1212,7 @@ void Game::stopAllBalloons(int time)
 // Pone en marcha todos los globos
 void Game::startAllBalloons()
 {
-	for (auto &balloon : balloons)
+	for (auto &balloon : balloons_)
 	{
 		if ((balloon->isEnabled()) && (!balloon->isBeingCreated()))
 		{
@@ -1212,7 +1227,7 @@ int Game::countBalloons()
 {
 	auto num = 0;
 
-	for (auto &balloon : balloons)
+	for (auto &balloon : balloons_)
 	{
 		if (balloon->isEnabled())
 		{
@@ -1226,16 +1241,16 @@ int Game::countBalloons()
 // Vacia del vector de globos los globos que ya no sirven
 void Game::freeBalloons()
 {
-	auto it = std::remove_if(balloons.begin(), balloons.end(),
+	auto it = std::remove_if(balloons_.begin(), balloons_.end(),
 							 [](const auto &balloon)
 							 { return !balloon->isEnabled(); });
-	balloons.erase(it, balloons.end());
+	balloons_.erase(it, balloons_.end());
 }
 
 // Comprueba la colisión entre el jugador y los globos activos
 bool Game::checkPlayerBalloonCollision(std::shared_ptr<Player> &player)
 {
-	for (auto &balloon : balloons)
+	for (auto &balloon : balloons_)
 	{
 		if ((balloon->isEnabled()) && !(balloon->isStopped()) && !(balloon->isInvulnerable()))
 		{
@@ -1257,7 +1272,7 @@ void Game::checkPlayerItemCollision(std::shared_ptr<Player> &player)
 		return;
 	}
 
-	for (auto &item : items)
+	for (auto &item : items_)
 	{
 		if (item->isEnabled())
 		{
@@ -1268,21 +1283,21 @@ void Game::checkPlayerItemCollision(std::shared_ptr<Player> &player)
 				case ITEM_POINTS_1_DISK:
 				{
 					player->addScore(1000);
-					createItemScoreSprite(item->getPosX() + (item->getWidth() / 2) - (n1000Sprite->getWidth() / 2), player->getPosY(), n1000Sprite);
+					createItemScoreSprite(item->getPosX() + (item->getWidth() / 2) - (p1000_sprite_->getWidth() / 2), player->getPosY(), p1000_sprite_);
 					break;
 				}
 
 				case ITEM_POINTS_2_GAVINA:
 				{
 					player->addScore(2500);
-					createItemScoreSprite(item->getPosX() + (item->getWidth() / 2) - (n2500Sprite->getWidth() / 2), player->getPosY(), n2500Sprite);
+					createItemScoreSprite(item->getPosX() + (item->getWidth() / 2) - (p2500_sprite_->getWidth() / 2), player->getPosY(), p2500_sprite_);
 					break;
 				}
 
 				case ITEM_POINTS_3_PACMAR:
 				{
 					player->addScore(5000);
-					createItemScoreSprite(item->getPosX() + (item->getWidth() / 2) - (n5000Sprite->getWidth() / 2), player->getPosY(), n5000Sprite);
+					createItemScoreSprite(item->getPosX() + (item->getWidth() / 2) - (p5000_sprite_->getWidth() / 2), player->getPosY(), p5000_sprite_);
 					break;
 				}
 
@@ -1297,7 +1312,7 @@ void Game::checkPlayerItemCollision(std::shared_ptr<Player> &player)
 					if (player->getCoffees() == 2)
 					{
 						player->addScore(5000);
-						createItemScoreSprite(item->getPosX() + (item->getWidth() / 2) - (n5000Sprite->getWidth() / 2), player->getPosY(), n5000Sprite);
+						createItemScoreSprite(item->getPosX() + (item->getWidth() / 2) - (p5000_sprite_->getWidth() / 2), player->getPosY(), p5000_sprite_);
 					}
 					player->giveExtraHit();
 					break;
@@ -1306,7 +1321,7 @@ void Game::checkPlayerItemCollision(std::shared_ptr<Player> &player)
 				case ITEM_COFFEE_MACHINE:
 				{
 					player->setPowerUp();
-					coffeeMachineEnabled = false;
+					coffee_machine_enabled_ = false;
 					break;
 				}
 
@@ -1315,7 +1330,7 @@ void Game::checkPlayerItemCollision(std::shared_ptr<Player> &player)
 				}
 
 				updateHiScore();
-				JA_PlaySound(itemPickUpSound);
+				JA_PlaySound(item_pick_up_sound_);
 				item->disable();
 			}
 		}
@@ -1325,9 +1340,9 @@ void Game::checkPlayerItemCollision(std::shared_ptr<Player> &player)
 // Comprueba y procesa la colisión entre las balas y los globos
 void Game::checkBulletBalloonCollision()
 {
-	for (auto &bullet : bullets)
+	for (auto &bullet : bullets_)
 	{
-		for (auto &balloon : balloons)
+		for (auto &balloon : balloons_)
 		{
 			if (balloon->isEnabled() && (!balloon->isInvulnerable()) && bullet->isEnabled())
 			{
@@ -1340,22 +1355,22 @@ void Game::checkBulletBalloonCollision()
 						return;
 					}
 					player->incScoreMultiplier();
-					player->addScore(balloon->getScore() * player->getScoreMultiplier() * difficultyScoreMultiplier);
+					player->addScore(balloon->getScore() * player->getScoreMultiplier() * difficulty_score_multiplier_);
 					updateHiScore();
 
 					// Suelta el item si se da el caso
 					const auto droppeditem = dropItem();
-					if (droppeditem != ITEM_NULL && !demo.recording)
+					if (droppeditem != ITEM_NULL && !demo_.recording)
 					{
 						if (droppeditem != ITEM_COFFEE_MACHINE)
 						{
 							createItem(droppeditem, balloon->getPosX(), balloon->getPosY());
-							JA_PlaySound(itemDropSound);
+							JA_PlaySound(item_drop_sound_);
 						}
 						else
 						{
 							createItem(droppeditem, player->getPosX(), 0);
-							coffeeMachineEnabled = true;
+							coffee_machine_enabled_ = true;
 						}
 					}
 
@@ -1363,7 +1378,7 @@ void Game::checkBulletBalloonCollision()
 					popBalloon(balloon);
 
 					// Sonido de explosión
-					JA_PlaySound(balloonSound);
+					JA_PlaySound(balloon_sound_);
 
 					// Deshabilita la bala
 					bullet->disable();
@@ -1378,7 +1393,7 @@ void Game::checkBulletBalloonCollision()
 // Mueve las balas activas
 void Game::moveBullets()
 {
-	for (auto &bullet : bullets)
+	for (auto &bullet : bullets_)
 	{
 		if (bullet->isEnabled())
 		{
@@ -1393,7 +1408,7 @@ void Game::moveBullets()
 // Pinta las balas activas
 void Game::renderBullets()
 {
-	for (auto &bullet : bullets)
+	for (auto &bullet : bullets_)
 	{
 		if (bullet->isEnabled())
 		{
@@ -1403,22 +1418,22 @@ void Game::renderBullets()
 }
 
 // Crea un objeto bala
-void Game::createBullet(int x, int y, BulletType kind, bool poweredUp, int owner)
+void Game::createBullet(int x, int y, BulletType kind, bool powered_up, int owner)
 {
-	auto b = std::make_unique<Bullet>(x, y, kind, poweredUp, owner, &(param.game.play_area.rect), bulletTexture);
-	bullets.push_back(std::move(b));
+	auto b = std::make_unique<Bullet>(x, y, kind, powered_up, owner, &(param.game.play_area.rect), bullet_texture_);
+	bullets_.push_back(std::move(b));
 }
 
 // Vacia el vector de balas
 void Game::freeBullets()
 {
-	if (!bullets.empty())
+	if (!bullets_.empty())
 	{
-		for (int i = bullets.size() - 1; i >= 0; --i)
+		for (int i = bullets_.size() - 1; i >= 0; --i)
 		{
-			if (!bullets[i]->isEnabled())
+			if (!bullets_[i]->isEnabled())
 			{
-				bullets.erase(bullets.begin() + i);
+				bullets_.erase(bullets_.begin() + i);
 			}
 		}
 	}
@@ -1427,15 +1442,15 @@ void Game::freeBullets()
 // Actualiza los items
 void Game::updateItems()
 {
-	for (auto &item : items)
+	for (auto &item : items_)
 	{
 		if (item->isEnabled())
 		{
 			item->update();
 			if (item->isOnFloor())
 			{
-				JA_PlaySound(coffeeMachineSound);
-				screen->shake();
+				JA_PlaySound(coffee_machine_sound_);
+				screen_->shake();
 			}
 		}
 	}
@@ -1444,7 +1459,7 @@ void Game::updateItems()
 // Pinta los items activos
 void Game::renderItems()
 {
-	for (auto &item : items)
+	for (auto &item : items_)
 	{
 		item->render();
 	}
@@ -1453,68 +1468,68 @@ void Game::renderItems()
 // Devuelve un item al azar y luego segun sus probabilidades
 int Game::dropItem()
 {
-	const auto luckyNumber = rand() % 100;
+	const auto lucky_number = rand() % 100;
 	const auto item = rand() % 6;
 
 	switch (item)
 	{
 	case 0:
-		if (luckyNumber < helper.itemPoints1Odds)
+		if (lucky_number < helper_.item_disk_odds)
 		{
 			return ITEM_POINTS_1_DISK;
 		}
 		break;
 
 	case 1:
-		if (luckyNumber < helper.itemPoints2Odds)
+		if (lucky_number < helper_.item_gavina_odds)
 		{
 			return ITEM_POINTS_2_GAVINA;
 		}
 		break;
 
 	case 2:
-		if (luckyNumber < helper.itemPoints3Odds)
+		if (lucky_number < helper_.item_pacmar_odds)
 		{
 			return ITEM_POINTS_3_PACMAR;
 		}
 		break;
 
 	case 3:
-		if (luckyNumber < helper.itemClockOdds)
+		if (lucky_number < helper_.item_clock_odds)
 		{
 			return ITEM_CLOCK;
 		}
 		break;
 
 	case 4:
-		if (luckyNumber < helper.itemCoffeeOdds)
+		if (lucky_number < helper_.item_coffee_odds)
 		{
-			helper.itemCoffeeOdds = ITEM_COFFEE_ODDS;
+			helper_.item_coffee_odds = ITEM_COFFEE_ODDS;
 			return ITEM_COFFEE;
 		}
 		else
 		{
-			if (helper.needCoffee)
+			if (helper_.need_coffee)
 			{
-				helper.itemCoffeeOdds++;
+				helper_.item_coffee_odds++;
 			}
 		}
 		break;
 
 	case 5:
-		if (luckyNumber < helper.itemCoffeeMachineOdds)
+		if (lucky_number < helper_.item_coffee_machine_odds)
 		{
-			helper.itemCoffeeMachineOdds = ITEM_COFFEE_MACHINE_ODDS;
-			if (!coffeeMachineEnabled && helper.needCoffeeMachine)
+			helper_.item_coffee_machine_odds = ITEM_COFFEE_MACHINE_ODDS;
+			if (!coffee_machine_enabled_ && helper_.need_coffee_machine)
 			{
 				return ITEM_COFFEE_MACHINE;
 			}
 		}
 		else
 		{
-			if (helper.needCoffeeMachine)
+			if (helper_.need_coffee_machine)
 			{
-				helper.itemCoffeeMachineOdds++;
+				helper_.item_coffee_machine_odds++;
 			}
 		}
 		break;
@@ -1529,20 +1544,20 @@ int Game::dropItem()
 // Crea un objeto item
 void Game::createItem(int kind, float x, float y)
 {
-	auto item = std::make_unique<Item>(kind, x, y, &(param.game.play_area.rect), itemTextures[kind - 1], itemAnimations[kind - 1]);
-	items.push_back(std::move(item));
+	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));
 }
 
 // Vacia el vector de items
 void Game::freeItems()
 {
-	if (!items.empty())
+	if (!items_.empty())
 	{
-		for (int i = items.size() - 1; i >= 0; --i)
+		for (int i = items_.size() - 1; i >= 0; --i)
 		{
-			if (!items[i]->isEnabled())
+			if (!items_[i]->isEnabled())
 			{
-				items.erase(items.begin() + i);
+				items_.erase(items_.begin() + i);
 			}
 		}
 	}
@@ -1552,7 +1567,7 @@ void Game::freeItems()
 void Game::createItemScoreSprite(int x, int y, std::shared_ptr<SmartSprite> sprite)
 {
 	auto ss = new SmartSprite(nullptr);
-	smartSprites.push_back(ss);
+	smart_sprites_.push_back(ss);
 
 	// Crea una copia del objeto
 	*ss = *sprite;
@@ -1567,13 +1582,13 @@ void Game::createItemScoreSprite(int x, int y, std::shared_ptr<SmartSprite> spri
 // Vacia el vector de smartsprites
 void Game::freeSmartSprites()
 {
-	if (!smartSprites.empty())
+	if (!smart_sprites_.empty())
 	{
-		for (int i = smartSprites.size() - 1; i >= 0; --i)
+		for (int i = smart_sprites_.size() - 1; i >= 0; --i)
 		{
-			if (smartSprites[i]->hasFinished())
+			if (smart_sprites_[i]->hasFinished())
 			{
-				smartSprites.erase(smartSprites.begin() + i);
+				smart_sprites_.erase(smart_sprites_.begin() + i);
 			}
 		}
 	}
@@ -1582,8 +1597,8 @@ 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(itemTextures[4]);
-	smartSprites.push_back(ss);
+	auto ss = new SmartSprite(item_textures_[4]);
+	smart_sprites_.push_back(ss);
 
 	ss->setPosX(x - 8);
 	ss->setPosY(y - 8);
@@ -1606,7 +1621,7 @@ void Game::throwCoffee(int x, int y)
 // Actualiza los SmartSprites
 void Game::updateSmartSprites()
 {
-	for (auto ss : smartSprites)
+	for (auto ss : smart_sprites_)
 	{
 		ss->update();
 	}
@@ -1615,7 +1630,7 @@ void Game::updateSmartSprites()
 // Pinta los SmartSprites activos
 void Game::renderSmartSprites()
 {
-	for (auto ss : smartSprites)
+	for (auto ss : smart_sprites_)
 	{
 		ss->render();
 	}
@@ -1631,25 +1646,28 @@ void Game::killPlayer(std::shared_ptr<Player> &player)
 
 	// Si tiene cafes
 	if (player->hasExtraHit())
-	{ // Lo pierde
+	{ 
+		// Lo pierde
 		player->removeExtraHit();
 		throwCoffee(player->getPosX() + (player->getWidth() / 2), player->getPosY() + (player->getHeight() / 2));
-		JA_PlaySound(coffeeOutSound);
-		screen->shake();
+		JA_PlaySound(coffee_out_sound_);
+		screen_->shake();
 	}
 	else
-	{ // Si no tiene cafes, muere
-		if (!demo.enabled)
+	{ 
+		// Si no tiene cafes, muere
+		if (!demo_.enabled)
 		{
 			JA_PauseMusic();
 		}
 		stopAllBalloons(10);
-		JA_PlaySound(playerCollisionSound);
-		screen->shake();
-		JA_PlaySound(coffeeOutSound);
+		JA_PlaySound(player_collision_sound_);
+		screen_->shake();
+		JA_PlaySound(coffee_out_sound_);
 		player->setStatusPlaying(PlayerStatus::DYING);
-		if (!demo.enabled)
-		{ // En el modo DEMO ni se para la musica ni se añade la puntuación a la tabla
+		if (!demo_.enabled)
+		{ 
+			// En el modo DEMO ni se para la musica ni se añade la puntuación a la tabla
 			allPlayersAreNotPlaying() ? JA_StopMusic() : JA_ResumeMusic();
 		}
 	}
@@ -1658,12 +1676,12 @@ void Game::killPlayer(std::shared_ptr<Player> &player)
 // Calcula y establece el valor de amenaza en funcion de los globos activos
 void Game::evaluateAndSetMenace()
 {
-	menaceCurrent = 0;
-	for (auto &balloon : balloons)
+	menace_current_ = 0;
+	for (auto &balloon : balloons_)
 	{
 		if (balloon->isEnabled())
 		{
-			menaceCurrent += balloon->getMenace();
+			menace_current_ += balloon->getMenace();
 		}
 	}
 }
@@ -1671,31 +1689,31 @@ void Game::evaluateAndSetMenace()
 // Obtiene el valor de la variable
 int Game::getMenace() const
 {
-	return menaceCurrent;
+	return menace_current_;
 }
 
 // Establece el valor de la variable
 void Game::setTimeStopped(bool value)
 {
-	timeStopped = value;
+	time_stopped_ = value;
 }
 
 // Obtiene el valor de la variable
 bool Game::isTimeStopped() const
 {
-	return timeStopped;
+	return time_stopped_;
 }
 
 // Establece el valor de la variable
 void Game::setTimeStoppedCounter(int value)
 {
-	timeStoppedCounter = value;
+	time_stopped_counter_ = value;
 }
 
 // Incrementa el valor de la variable
 void Game::incTimeStoppedCounter(int value)
 {
-	timeStoppedCounter += value;
+	time_stopped_counter_ += value;
 }
 
 // Actualiza y comprueba el valor de la variable
@@ -1703,9 +1721,9 @@ void Game::updateTimeStoppedCounter()
 {
 	if (isTimeStopped())
 	{
-		if (timeStoppedCounter > 0)
+		if (time_stopped_counter_ > 0)
 		{
-			timeStoppedCounter--;
+			time_stopped_counter_--;
 			stopAllBalloons(TIME_STOPPED_COUNTER);
 		}
 		else
@@ -1718,9 +1736,9 @@ void Game::updateTimeStoppedCounter()
 // Actualiza la variable enemyDeployCounter
 void Game::updateEnemyDeployCounter()
 {
-	if (enemyDeployCounter > 0)
+	if (enemy_deploy_counter_ > 0)
 	{
-		enemyDeployCounter--;
+		enemy_deploy_counter_--;
 	}
 }
 
@@ -1728,31 +1746,31 @@ void Game::updateEnemyDeployCounter()
 void Game::update()
 {
 	// Comprueba que la diferencia de ticks sea mayor a la velocidad del juego
-	if (SDL_GetTicks() - ticks > ticksSpeed)
+	if (SDL_GetTicks() - ticks_ > ticks_speed_)
 	{
 		// Actualiza el contador de ticks
-		ticks = SDL_GetTicks();
+		ticks_ = SDL_GetTicks();
 
 		// Actualiza el contador de juego
-		counter++;
+		counter_++;
 
-		if (demo.enabled)
+		if (demo_.enabled)
 		{
 			// Incrementa el contador de la demo
-			if (demo.counter < TOTAL_DEMO_DATA)
+			if (demo_.counter < TOTAL_DEMO_DATA)
 			{
-				demo.counter++;
+				demo_.counter++;
 			}
 
 			// Activa el fundido antes de acabar con los datos de la demo
-			if (demo.counter == TOTAL_DEMO_DATA - 200)
+			if (demo_.counter == TOTAL_DEMO_DATA - 200)
 			{
-				fade->setType(FadeType::RANDOM_SQUARE);
-				fade->activate();
+				fade_->setType(FadeType::RANDOM_SQUARE);
+				fade_->activate();
 			}
 
 			// Si ha terminado el fundido, cambia de sección
-			if (fade->hasEnded())
+			if (fade_->hasEnded())
 			{
 				section::name = section::Name::HI_SCORE_TABLE;
 				return;
@@ -1777,16 +1795,16 @@ void Game::update()
 		}
 #endif
 #ifdef DEBUG
-		if (autoPopBalloons && !gameCompleted)
+		if (auto_pop_balloons_ && !game_completed_)
 		{
-			balloonsPopped++;
+			balloons_popped_++;
 			increaseStageCurrentPower(1);
 		}
 #endif
-		if (!paused)
+		if (!paused_)
 		{
 			// Actualiza el objeto fade
-			fade->update();
+			fade_->update();
 
 			// Actualiza las variables del jugador
 			updatePlayers();
@@ -1802,7 +1820,7 @@ void Game::update()
 			updateBalloons();
 
 			// Actualiza el objeto encargado de las explosiones
-			explosions->update();
+			explosions_->update();
 
 			// Mueve las balas
 			moveBullets();
@@ -1849,7 +1867,7 @@ void Game::update()
 		checkMusicStatus();
 
 		// Actualiza el objeto screen
-		screen->update();
+		screen_->update();
 
 		// Dibuja los graficos de la zona de juego en la textura
 		fillCanvas();
@@ -1860,84 +1878,84 @@ void Game::update()
 void Game::updateBackground()
 {
 	// Si el juego está completado, se reduce la velocidad de las nubes
-	if (gameCompleted)
+	if (game_completed_)
 	{
-		balloonsPopped = (balloonsPopped > 400) ? (balloonsPopped - 25) : 200;
+		balloons_popped_ = (balloons_popped_ > 400) ? (balloons_popped_ - 25) : 200;
 	}
 
 	// Calcula la velocidad en función de los globos explotados y el total de globos a explotar para acabar el juego
-	constexpr auto cloudsInitialSpeed = 0.05f;
-	constexpr auto cloudsFinalSpeed = 2.00f - cloudsInitialSpeed;
-	const float cloudsSpeed = (-cloudsInitialSpeed) + (-cloudsFinalSpeed * ((float)balloonsPopped / (float)totalPowerToCompleteGame));
-	background->setCloudsSpeed(cloudsSpeed);
+	constexpr auto clouds_initial_speed = 0.05f;
+	constexpr auto clouds_final_speed = 2.00f - clouds_initial_speed;
+	const float cloudsSpeed = (-clouds_initial_speed) + (-clouds_final_speed * ((float)balloons_popped_ / (float)total_power_to_complete_game_));
+	background_->setCloudsSpeed(cloudsSpeed);
 
 	// Calcula la transición de los diferentes fondos
-	const float gradientNumber = std::min(((float)balloonsPopped / 1250.0f), 3.0f);
-	const float percent = gradientNumber - (int)gradientNumber;
-	background->setGradientNumber((int)gradientNumber);
-	background->setTransition(percent);
+	const float gradient_number = std::min(((float)balloons_popped_ / 1250.0f), 3.0f);
+	const float percent = gradient_number - (int)gradient_number;
+	background_->setGradientNumber((int)gradient_number);
+	background_->setTransition(percent);
 
 	// Actualiza el objeto
-	background->update();
+	background_->update();
 }
 
 // Dibuja los elementos de la zona de juego en su textura
 void Game::fillCanvas()
 {
 	// Dibujamos el contenido de la zona de juego en su textura
-	auto temp = SDL_GetRenderTarget(renderer);
-	SDL_SetRenderTarget(renderer, canvas);
+	auto temp = SDL_GetRenderTarget(renderer_);
+	SDL_SetRenderTarget(renderer_, canvas_);
 
 	// Dibuja los objetos
-	background->render();
+	background_->render();
 	renderItems();
 	renderSmartSprites();
-	explosions->render();
+	explosions_->render();
 	renderBalloons();
 	renderBullets();
 	renderMessages();
 	renderPlayers();
 
 	// Deja el renderizador apuntando donde estaba
-	SDL_SetRenderTarget(renderer, temp);
+	SDL_SetRenderTarget(renderer_, temp);
 }
 
 // Dibuja el juego
 void Game::render()
 {
 	// Prepara para empezar a dibujar en la textura de juego
-	screen->start();
+	screen_->start();
 
 	// Copia la textura con la zona de juego a la pantalla
-	SDL_RenderCopy(renderer, canvas, nullptr, &param.game.play_area.rect);
+	SDL_RenderCopy(renderer_, canvas_, nullptr, &param.game.play_area.rect);
 
 	// Dibuja el marcador
-	scoreboard->render();
+	scoreboard_->render();
 
 	// Dibuja el fade
-	fade->render();
+	fade_->render();
 
 	// Vuelca el contenido del renderizador en pantalla
-	screen->blit();
+	screen_->blit();
 }
 
 // Gestiona el nivel de amenaza
 void Game::updateMenace()
 {
-	if (gameCompleted)
+	if (game_completed_)
 	{
 		return;
 	}
 
-	const auto stage = enemyFormations->getStage(currentStage);
-	const float percent = currentPower / stage.power_to_complete;
+	const auto stage = enemy_formations_->getStage(current_stage_);
+	const float percent = current_power_ / stage.power_to_complete;
 	const int difference = stage.max_menace - stage.min_menace;
 
 	// Aumenta el nivel de amenaza en función de la puntuación
-	menaceThreshold = stage.min_menace + (difference * percent);
+	menace_threshold_ = stage.min_menace + (difference * percent);
 
 	// Si el nivel de amenza es inferior al umbral
-	if (menaceCurrent < menaceThreshold)
+	if (menace_current_ < menace_threshold_)
 	{
 		// Crea una formación de enemigos
 		deployEnemyFormation();
@@ -1951,42 +1969,42 @@ void Game::updateMenace()
 void Game::checkInput()
 {
 	// Comprueba si se pulsa el botón de pausa
-	for (int i = 0; i < input->getNumControllers(); ++i)
+	for (int i = 0; i < input_->getNumControllers(); ++i)
 	{
 		// Comprueba si se va a pausar el juego
-		if (input->checkModInput(input_service, input_pause, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_GAMECONTROLLER, i))
+		if (input_->checkModInput(input_service, input_pause, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_GAMECONTROLLER, i))
 		{
-			pause(!paused);
+			pause(!paused_);
 			return;
 		}
 	}
 
 	// Modo Demo activo
-	if (demo.enabled)
+	if (demo_.enabled)
 	{
 		auto i = 0;
-		for (auto &player : players)
+		for (auto &player : players_)
 		{
 			if (player->isPlaying())
 			{
 				// Comprueba direcciones
-				if (demo.dataFile[i][demo.counter].left == 1)
+				if (demo_.data_file[i][demo_.counter].left == 1)
 				{
 					player->setInput(input_left);
 				}
 
-				else if (demo.dataFile[i][demo.counter].right == 1)
+				else if (demo_.data_file[i][demo_.counter].right == 1)
 				{
 					player->setInput(input_right);
 				}
 
-				else if (demo.dataFile[i][demo.counter].no_input == 1)
+				else if (demo_.data_file[i][demo_.counter].no_input == 1)
 				{
 					player->setInput(input_null);
 				}
 
 				// Comprueba botones
-				if (demo.dataFile[i][demo.counter].fire == 1)
+				if (demo_.data_file[i][demo_.counter].fire == 1)
 				{
 					if (player->canFire())
 					{
@@ -1996,7 +2014,7 @@ void Game::checkInput()
 					}
 				}
 
-				else if (demo.dataFile[i][demo.counter].fire_left == 1)
+				else if (demo_.data_file[i][demo_.counter].fire_left == 1)
 				{
 					if (player->canFire())
 					{
@@ -2006,7 +2024,7 @@ void Game::checkInput()
 					}
 				}
 
-				else if (demo.dataFile[i][demo.counter].fire_right == 1)
+				else if (demo_.data_file[i][demo_.counter].fire_right == 1)
 				{
 					if (player->canFire())
 					{
@@ -2017,7 +2035,7 @@ void Game::checkInput()
 				}
 
 				// Si se pulsa cualquier tecla, se sale del modo demo
-				if (input->checkAnyButtonPressed())
+				if (input_->checkAnyButtonPressed())
 				{
 					section::name = section::Name::TITLE;
 					return;
@@ -2039,14 +2057,14 @@ void Game::checkInput()
 		demo.keys.fire_left = 0;
 		demo.keys.fire_right = 0;
 #endif
-		for (auto &player : players)
+		for (auto &player : players_)
 		{
 			const auto controllerIndex = player->getController();
 			const auto autofire = player->isPowerUp() || options.game.autofire;
 			if (player->isPlaying())
 			{
 				// Input a la izquierda
-				if (input->checkInput(input_left, INPUT_ALLOW_REPEAT, options.controller[controllerIndex].device_type, options.controller[controllerIndex].index))
+				if (input_->checkInput(input_left, INPUT_ALLOW_REPEAT, options.controller[controllerIndex].device_type, options.controller[controllerIndex].index))
 				{
 					player->setInput(input_left);
 #ifdef RECORDING
@@ -2056,7 +2074,7 @@ void Game::checkInput()
 				else
 				{
 					// Input a la derecha
-					if (input->checkInput(input_right, INPUT_ALLOW_REPEAT, options.controller[controllerIndex].device_type, options.controller[controllerIndex].index))
+					if (input_->checkInput(input_right, INPUT_ALLOW_REPEAT, options.controller[controllerIndex].device_type, options.controller[controllerIndex].index))
 					{
 						player->setInput(input_right);
 #ifdef RECORDING
@@ -2073,7 +2091,7 @@ void Game::checkInput()
 					}
 				}
 				// Comprueba el input de disparar al centro
-				if (input->checkInput(input_fire_center, autofire, options.controller[controllerIndex].device_type, options.controller[controllerIndex].index))
+				if (input_->checkInput(input_fire_center, autofire, options.controller[controllerIndex].device_type, options.controller[controllerIndex].index))
 				{
 					if (player->canFire())
 					{
@@ -2082,7 +2100,7 @@ void Game::checkInput()
 						player->setFireCooldown(10);
 
 						// Reproduce el sonido de disparo
-						JA_PlaySound(bulletSound);
+						JA_PlaySound(bullet_sound_);
 #ifdef RECORDING
 						demo.keys.fire = 1;
 #endif
@@ -2090,7 +2108,7 @@ void Game::checkInput()
 				}
 
 				// Comprueba el input de disparar a la izquierda
-				else if (input->checkInput(input_fire_left, autofire, options.controller[controllerIndex].device_type, options.controller[controllerIndex].index))
+				else if (input_->checkInput(input_fire_left, autofire, options.controller[controllerIndex].device_type, options.controller[controllerIndex].index))
 				{
 					if (player->canFire())
 					{
@@ -2099,7 +2117,7 @@ void Game::checkInput()
 						player->setFireCooldown(10);
 
 						// Reproduce el sonido de disparo
-						JA_PlaySound(bulletSound);
+						JA_PlaySound(bullet_sound_);
 #ifdef RECORDING
 						demo.keys.fire_left = 1;
 #endif
@@ -2107,7 +2125,7 @@ void Game::checkInput()
 				}
 
 				// Comprueba el input de disparar a la derecha
-				else if (input->checkInput(input_fire_right, autofire, options.controller[controllerIndex].device_type, options.controller[controllerIndex].index))
+				else if (input_->checkInput(input_fire_right, autofire, options.controller[controllerIndex].device_type, options.controller[controllerIndex].index))
 				{
 					if (player->canFire())
 					{
@@ -2116,7 +2134,7 @@ void Game::checkInput()
 						player->setFireCooldown(10);
 
 						// Reproduce el sonido de disparo
-						JA_PlaySound(bulletSound);
+						JA_PlaySound(bullet_sound_);
 #ifdef RECORDING
 						demo.keys.fire_right = 1;
 #endif
@@ -2135,15 +2153,15 @@ void Game::checkInput()
 			else if (player->isContinue() || player->isWaiting())
 			{
 				// Si no está jugando, el botón de start le permite continuar jugando
-				if (input->checkInput(input_start, INPUT_DO_NOT_ALLOW_REPEAT, options.controller[controllerIndex].device_type, options.controller[controllerIndex].index))
+				if (input_->checkInput(input_start, INPUT_DO_NOT_ALLOW_REPEAT, options.controller[controllerIndex].device_type, options.controller[controllerIndex].index))
 				{
 					player->setStatusPlaying(PlayerStatus::PLAYING);
 				}
 
 				// Si está continuando, los botones de fuego hacen decrementar el contador
-				const auto fire1 = input->checkInput(input_fire_left, INPUT_DO_NOT_ALLOW_REPEAT, options.controller[controllerIndex].device_type, options.controller[controllerIndex].index);
-				const auto fire2 = input->checkInput(input_fire_center, INPUT_DO_NOT_ALLOW_REPEAT, options.controller[controllerIndex].device_type, options.controller[controllerIndex].index);
-				const auto fire3 = input->checkInput(input_fire_right, INPUT_DO_NOT_ALLOW_REPEAT, options.controller[controllerIndex].device_type, options.controller[controllerIndex].index);
+				const auto fire1 = input_->checkInput(input_fire_left, INPUT_DO_NOT_ALLOW_REPEAT, options.controller[controllerIndex].device_type, options.controller[controllerIndex].index);
+				const auto fire2 = input_->checkInput(input_fire_center, INPUT_DO_NOT_ALLOW_REPEAT, options.controller[controllerIndex].device_type, options.controller[controllerIndex].index);
+				const auto fire3 = input_->checkInput(input_fire_right, INPUT_DO_NOT_ALLOW_REPEAT, options.controller[controllerIndex].device_type, options.controller[controllerIndex].index);
 				if (fire1 || fire2 || fire3)
 				{
 					player->decContinueCounter();
@@ -2151,9 +2169,9 @@ void Game::checkInput()
 			}
 			else if (player->isEnteringName())
 			{
-				const auto fire1 = input->checkInput(input_fire_left, INPUT_DO_NOT_ALLOW_REPEAT, options.controller[controllerIndex].device_type, options.controller[controllerIndex].index);
-				const auto fire2 = input->checkInput(input_fire_center, INPUT_DO_NOT_ALLOW_REPEAT, options.controller[controllerIndex].device_type, options.controller[controllerIndex].index);
-				const auto fire3 = input->checkInput(input_fire_right, INPUT_DO_NOT_ALLOW_REPEAT, options.controller[controllerIndex].device_type, options.controller[controllerIndex].index);
+				const auto fire1 = input_->checkInput(input_fire_left, INPUT_DO_NOT_ALLOW_REPEAT, options.controller[controllerIndex].device_type, options.controller[controllerIndex].index);
+				const auto fire2 = input_->checkInput(input_fire_center, INPUT_DO_NOT_ALLOW_REPEAT, options.controller[controllerIndex].device_type, options.controller[controllerIndex].index);
+				const auto fire3 = input_->checkInput(input_fire_right, INPUT_DO_NOT_ALLOW_REPEAT, options.controller[controllerIndex].device_type, options.controller[controllerIndex].index);
 				if (fire1 || fire2 || fire3)
 				{
 					if (player->getRecordNamePos() == 7)
@@ -2167,23 +2185,23 @@ void Game::checkInput()
 						player->setInput(input_right);
 					}
 				}
-				else if (input->checkInput(input_up, INPUT_DO_NOT_ALLOW_REPEAT, options.controller[controllerIndex].device_type, options.controller[controllerIndex].index))
+				else if (input_->checkInput(input_up, INPUT_DO_NOT_ALLOW_REPEAT, options.controller[controllerIndex].device_type, options.controller[controllerIndex].index))
 				{
 					player->setInput(input_up);
 				}
-				else if (input->checkInput(input_down, INPUT_DO_NOT_ALLOW_REPEAT, options.controller[controllerIndex].device_type, options.controller[controllerIndex].index))
+				else if (input_->checkInput(input_down, INPUT_DO_NOT_ALLOW_REPEAT, options.controller[controllerIndex].device_type, options.controller[controllerIndex].index))
 				{
 					player->setInput(input_down);
 				}
-				else if (input->checkInput(input_left, INPUT_DO_NOT_ALLOW_REPEAT, options.controller[controllerIndex].device_type, options.controller[controllerIndex].index))
+				else if (input_->checkInput(input_left, INPUT_DO_NOT_ALLOW_REPEAT, options.controller[controllerIndex].device_type, options.controller[controllerIndex].index))
 				{
 					player->setInput(input_left);
 				}
-				else if (input->checkInput(input_right, INPUT_DO_NOT_ALLOW_REPEAT, options.controller[controllerIndex].device_type, options.controller[controllerIndex].index))
+				else if (input_->checkInput(input_right, INPUT_DO_NOT_ALLOW_REPEAT, options.controller[controllerIndex].device_type, options.controller[controllerIndex].index))
 				{
 					player->setInput(input_right);
 				}
-				else if (input->checkInput(input_start, INPUT_DO_NOT_ALLOW_REPEAT, options.controller[controllerIndex].device_type, options.controller[controllerIndex].index))
+				else if (input_->checkInput(input_start, INPUT_DO_NOT_ALLOW_REPEAT, options.controller[controllerIndex].device_type, options.controller[controllerIndex].index))
 				{
 					player->setInput(input_start);
 					addScoreToScoreBoard(player->getRecordName(), player->getScore());
@@ -2194,7 +2212,7 @@ void Game::checkInput()
 	}
 
 	// Comprueba el input para el resto de objetos
-	screen->checkInput();
+	screen_->checkInput();
 
 	// Comprueba los inputs que se pueden introducir en cualquier sección del juego
 	globalInputs::check();
@@ -2204,59 +2222,59 @@ void Game::checkInput()
 void Game::renderMessages()
 {
 	// GetReady
-	if (counter < STAGE_COUNTER && !demo.enabled)
+	if (counter_ < STAGE_COUNTER && !demo_.enabled)
 	{
-		textNokiaBig2->write((int)getReadyBitmapPath[counter], param.game.play_area.center_y - 8, lang::getText(75), -2);
+		text_nokia2_big_->write((int)get_ready_bitmap_path_[counter_], param.game.play_area.center_y - 8, lang::getText(75), -2);
 	}
 
 	// Time Stopped
-	if (timeStopped)
+	if (time_stopped_)
 	{
-		if (timeStoppedCounter > 100 || timeStoppedCounter % 10 > 4)
+		if (time_stopped_counter_ > 100 || time_stopped_counter_ % 10 > 4)
 		{
-			textNokia2->writeDX(TEXT_CENTER, param.game.play_area.center_x, param.game.play_area.first_quarter_y, lang::getText(36) + std::to_string(timeStoppedCounter / 10), -1, no_color, 1, shdw_txt_color);
+			text_nokia2_->writeDX(TEXT_CENTER, param.game.play_area.center_x, param.game.play_area.first_quarter_y, lang::getText(36) + std::to_string(time_stopped_counter_ / 10), -1, no_color, 1, shdw_txt_color);
 		}
 
-		if (timeStoppedCounter > 100)
+		if (time_stopped_counter_ > 100)
 		{
-			if (timeStoppedCounter % 30 == 0)
+			if (time_stopped_counter_ % 30 == 0)
 			{
-				JA_PlaySound(clockSound);
+				JA_PlaySound(clock_sound_);
 			}
 		}
 		else
 		{
-			if (timeStoppedCounter % 15 == 0)
+			if (time_stopped_counter_ % 15 == 0)
 			{
-				JA_PlaySound(clockSound);
+				JA_PlaySound(clock_sound_);
 			}
 		}
 	}
 
 	// STAGE NUMBER
-	if (stageBitmapCounter < STAGE_COUNTER)
+	if (stage_bitmap_counter_ < STAGE_COUNTER)
 	{
-		const auto stageNum = enemyFormations->getStage(currentStage).number;
+		const auto stage_number = enemy_formations_->getStage(current_stage_).number;
 		std::string text = "";
 
-		if (stageNum == 10)
+		if (stage_number == 10)
 		{ // Ultima fase
 			text = lang::getText(79);
 		}
 		else
 		{ // X fases restantes
-			text = std::to_string(11 - stageNum) + lang::getText(38);
+			text = std::to_string(11 - stage_number) + lang::getText(38);
 		}
 
-		if (!gameCompleted)
+		if (!game_completed_)
 		{ // Escribe el número de fases restantes
-			textNokiaBig2->writeDX(TEXT_CENTER, param.game.play_area.center_x, stageBitmapPath[stageBitmapCounter], text, -2, no_color, 2, shdw_txt_color);
+			text_nokia2_big_->writeDX(TEXT_CENTER, param.game.play_area.center_x, stage_bitmap_path_[stage_bitmap_counter_], text, -2, no_color, 2, shdw_txt_color);
 		}
 		else
 		{ // Escribe el texto de juego completado
 			text = lang::getText(50);
-			textNokiaBig2->writeDX(TEXT_CENTER, param.game.play_area.center_x, stageBitmapPath[stageBitmapCounter], text, -2, no_color, 1, shdw_txt_color);
-			textNokia2->writeDX(TEXT_CENTER, param.game.play_area.center_x, stageBitmapPath[stageBitmapCounter] + textNokiaBig2->getCharacterSize() + 2, lang::getText(76), -1, no_color, 1, shdw_txt_color);
+			text_nokia2_big_->writeDX(TEXT_CENTER, param.game.play_area.center_x, stage_bitmap_path_[stage_bitmap_counter_], text, -2, no_color, 1, shdw_txt_color);
+			text_nokia2_->writeDX(TEXT_CENTER, param.game.play_area.center_x, stage_bitmap_path_[stage_bitmap_counter_] + text_nokia2_big_->getCharacterSize() + 2, lang::getText(76), -1, no_color, 1, shdw_txt_color);
 		}
 	}
 }
@@ -2267,7 +2285,7 @@ void Game::enableTimeStopItem()
 	stopAllBalloons(TIME_STOPPED_COUNTER);
 	setTimeStopped(true);
 	incTimeStoppedCounter(TIME_STOPPED_COUNTER);
-	if (JA_GetMusicState() == JA_MUSIC_PLAYING && !demo.enabled)
+	if (JA_GetMusicState() == JA_MUSIC_PLAYING && !demo_.enabled)
 	{
 		JA_PauseMusic();
 	}
@@ -2276,10 +2294,10 @@ void Game::enableTimeStopItem()
 // Deshabilita el efecto del item de detener el tiempo
 void Game::disableTimeStopItem()
 {
-	timeStopped = false;
+	time_stopped_ = false;
 	setTimeStoppedCounter(0);
 	startAllBalloons();
-	if (JA_GetMusicState() == JA_MUSIC_PAUSED && !demo.enabled)
+	if (JA_GetMusicState() == JA_MUSIC_PAUSED && !demo_.enabled)
 	{
 		JA_ResumeMusic();
 	}
@@ -2292,7 +2310,7 @@ void Game::checkMusicStatus()
 	if (JA_GetMusicState() == JA_MUSIC_INVALID || JA_GetMusicState() == JA_MUSIC_STOPPED)
 	{
 		// Si se ha completado el juego o los jugadores han terminado, detiene la música
-		gameCompleted || allPlayersAreGameOver() ? JA_StopMusic() : JA_PlayMusic(music);
+		game_completed_ || allPlayersAreGameOver() ? JA_StopMusic() : JA_PlayMusic(music_);
 	}
 }
 
@@ -2310,13 +2328,13 @@ void Game::run()
 	}
 
 	// Vuelve a dejar el sonido como estaba
-	(demo.enabled) ? JA_EnableSound(options.audio.sound.enabled) : JA_StopMusic();
+	(demo_.enabled) ? JA_EnableSound(options.audio.sound.enabled) : JA_StopMusic();
 }
 
 // Indica si se puede crear una powerball
 bool Game::canPowerBallBeCreated()
 {
-	if ((!powerBallEnabled) && (calculateScreenPower() > POWERBALL_SCREENPOWER_MINIMUM) && (powerBallCounter == 0))
+	if ((!power_ball_enabled_) && (calculateScreenPower() > POWERBALL_SCREENPOWER_MINIMUM) && (power_ball_counter_ == 0))
 	{
 		return true;
 	}
@@ -2329,7 +2347,7 @@ int Game::calculateScreenPower()
 {
 	auto power = 0;
 
-	for (auto &balloon : balloons)
+	for (auto &balloon : balloons_)
 	{
 		if (balloon->isEnabled())
 		{
@@ -2351,31 +2369,31 @@ void Game::initPaths()
 	}
 
 	// Letrero de STAGE #
-	constexpr auto firstPart = STAGE_COUNTER / 4; // 50
-	constexpr auto secondPart = firstPart * 3;	  // 150
-	const auto centerPoint = param.game.play_area.center_y - (BLOCK * 2);
+	constexpr auto first_part = STAGE_COUNTER / 4; // 50
+	constexpr auto second_part = first_part * 3;	  // 150
+	const auto center_point = param.game.play_area.center_y - (BLOCK * 2);
 	const auto distance = (param.game.play_area.rect.h) - (param.game.play_area.center_y - 16);
 
 	for (int i = 0; i < STAGE_COUNTER; ++i)
 	{
-		if (i < firstPart)
+		if (i < first_part)
 		{
-			stageBitmapPath[i] = (sin[(int)((i * 1.8f) + 90)] * (distance) + centerPoint);
+			stage_bitmap_path_[i] = (sin[(int)((i * 1.8f) + 90)] * (distance) + center_point);
 		}
 
-		else if (i < secondPart)
+		else if (i < second_part)
 		{
-			stageBitmapPath[i] = (int)centerPoint;
+			stage_bitmap_path_[i] = (int)center_point;
 		}
 
 		else
 		{
-			stageBitmapPath[i] = (sin[(int)(((i - 149) * 1.8f) + 90)] * (centerPoint + 17) - 17);
+			stage_bitmap_path_[i] = (sin[(int)(((i - 149) * 1.8f) + 90)] * (center_point + 17) - 17);
 		}
 	}
 
 	// Letrero de GetReady
-	const auto size = textNokiaBig2->lenght(lang::getText(75), -2);
+	const auto size = text_nokia2_big_->lenght(lang::getText(75), -2);
 
 	const float start1 = param.game.play_area.rect.x - size;
 	const float finish1 = param.game.play_area.center_x - (size / 2);
@@ -2388,23 +2406,23 @@ void Game::initPaths()
 
 	for (int i = 0; i < STAGE_COUNTER; ++i)
 	{
-		if (i < firstPart)
+		if (i < first_part)
 		{
-			getReadyBitmapPath[i] = sin[(int)(i * 1.8f)];
-			getReadyBitmapPath[i] *= distance1;
-			getReadyBitmapPath[i] -= size;
+			get_ready_bitmap_path_[i] = sin[(int)(i * 1.8f)];
+			get_ready_bitmap_path_[i] *= distance1;
+			get_ready_bitmap_path_[i] -= size;
 		}
 
-		else if (i < secondPart)
+		else if (i < second_part)
 		{
-			getReadyBitmapPath[i] = (int)finish1;
+			get_ready_bitmap_path_[i] = (int)finish1;
 		}
 
 		else
 		{
-			getReadyBitmapPath[i] = sin[(int)((i - 150) * 1.8f)];
-			getReadyBitmapPath[i] *= distance2;
-			getReadyBitmapPath[i] += finish1;
+			get_ready_bitmap_path_[i] = sin[(int)((i - 150) * 1.8f)];
+			get_ready_bitmap_path_[i] *= distance2;
+			get_ready_bitmap_path_[i] += finish1;
 		}
 	}
 }
@@ -2412,12 +2430,12 @@ void Game::initPaths()
 // Actualiza el tramo final de juego, una vez completado
 void Game::updateGameCompleted()
 {
-	if (gameCompleted)
+	if (game_completed_)
 	{
-		gameCompletedCounter++;
+		game_completed_counter_++;
 	}
 
-	if (gameCompletedCounter == GAME_COMPLETED_END)
+	if (game_completed_counter_ == GAME_COMPLETED_END)
 	{
 		section::name = section::Name::TITLE;
 		section::options = section::Options::TITLE_1;
@@ -2428,17 +2446,17 @@ void Game::updateGameCompleted()
 void Game::updateHelper()
 {
 	// Solo ofrece ayuda cuando la amenaza es elevada
-	if (menaceCurrent > 15)
+	if (menace_current_ > 15)
 	{
-		for (auto &player : players)
+		for (auto &player : players_)
 		{
-			helper.needCoffee = (player->getCoffees() == 0);
-			helper.needCoffeeMachine = (!player->isPowerUp());
+			helper_.need_coffee = (player->getCoffees() == 0);
+			helper_.need_coffee_machine = (!player->isPowerUp());
 		}
 	}
 	else
 	{
-		helper.needCoffee = helper.needCoffeeMachine = false;
+		helper_.need_coffee = helper_.need_coffee_machine = false;
 	}
 }
 
@@ -2446,7 +2464,7 @@ void Game::updateHelper()
 bool Game::allPlayersAreWaitingOrGameOver()
 {
 	auto success = true;
-	for (auto &player : players)
+	for (auto &player : players_)
 	{
 		success &= player->isWaiting() || player->isGameOver();
 	}
@@ -2458,7 +2476,7 @@ bool Game::allPlayersAreWaitingOrGameOver()
 bool Game::allPlayersAreGameOver()
 {
 	auto success = true;
-	for (auto &player : players)
+	for (auto &player : players_)
 	{
 		success &= player->isGameOver();
 	}
@@ -2470,7 +2488,7 @@ bool Game::allPlayersAreGameOver()
 bool Game::allPlayersAreNotPlaying()
 {
 	auto success = true;
-	for (auto &player : players)
+	for (auto &player : players_)
 	{
 		success &= !player->isPlaying();
 	}
@@ -2497,7 +2515,7 @@ void Game::checkEvents()
 			{
 			case SDL_WINDOWEVENT_FOCUS_LOST:
 			{
-				if (!demo.enabled)
+				if (!demo_.enabled)
 				{
 					pause(true);
 				}
@@ -2537,7 +2555,7 @@ void Game::checkEvents()
 			case SDLK_2:
 			{
 				const auto set = 0;
-				const auto stage = enemyFormations->getStage(0);
+				const auto stage = enemy_formations_->getStage(0);
 				const auto numEnemies = stage.enemy_pool->set[set]->number_of_enemies;
 				for (int i = 0; i < numEnemies; ++i)
 				{
@@ -2545,7 +2563,7 @@ void Game::checkEvents()
 								  stage.enemy_pool->set[set]->init[i].y,
 								  stage.enemy_pool->set[set]->init[i].kind,
 								  stage.enemy_pool->set[set]->init[i].vel_x,
-								  enemySpeed,
+								  enemy_speed_,
 								  stage.enemy_pool->set[set]->init[i].creation_counter);
 				}
 			}
@@ -2554,22 +2572,22 @@ void Game::checkEvents()
 			// Activa el modo para pasar el juego automaticamente
 			case SDLK_3:
 			{
-				autoPopBalloons = !autoPopBalloons;
-				screen->showNotification("autoPopBalloons " + boolToString(autoPopBalloons));
+				auto_pop_balloons_ = !auto_pop_balloons_;
+				screen_->showNotification("auto_pop_balloons_ " + boolToString(auto_pop_balloons_));
 				break;
 			}
 
 			// Ralentiza mucho la lógica
 			case SDLK_4:
 			{
-				ticksSpeed *= 10;
+				ticks_speed_ *= 10;
 				break;
 			}
 
 			// Acelera mucho la lógica
 			case SDLK_5:
 			{
-				ticksSpeed /= 10;
+				ticks_speed_ /= 10;
 				break;
 			}
 
@@ -2604,65 +2622,65 @@ void Game::loadAnimations(std::string filePath, std::vector<std::string> *buffer
 // Elimina todos los objetos contenidos en vectores
 void Game::deleteAllVectorObjects()
 {
-	players.clear();
-	balloons.clear();
-	bullets.clear();
-	items.clear();
-	smartSprites.clear();
+	players_.clear();
+	balloons_.clear();
+	bullets_.clear();
+	items_.clear();
+	smart_sprites_.clear();
 }
 
 // Recarga las texturas
 void Game::reloadTextures()
 {
-	for (auto texture : itemTextures)
+	for (auto &texture : item_textures_)
 	{
 		texture->reLoad();
 	}
 
-	for (auto texture : balloonTextures)
+	for (auto &texture : balloon_textures_)
 	{
 		texture->reLoad();
 	}
 
-	for (auto texture : player1Textures)
+	for (auto &texture : player1_textures_)
 	{
 		texture->reLoad();
 	}
 
-	for (auto texture : player2Textures)
+	for (auto &texture : player2_textures_)
 	{
 		texture->reLoad();
 	}
 
-	bulletTexture->reLoad();
-	gameTextTexture->reLoad();
-	background->reloadTextures();
+	bullet_texture_->reLoad();
+	game_text_texture_->reLoad();
+	background_->reloadTextures();
 }
 
 // Actualiza el marcador
 void Game::updateScoreboard()
 {
-	for (auto &player : players)
+	for (auto &player : players_)
 	{
-		scoreboard->setScore(player->getScoreBoardPanel(), player->getScore());
-		scoreboard->setMult(player->getScoreBoardPanel(), player->getScoreMultiplier());
+		scoreboard_->setScore(player->getScoreBoardPanel(), player->getScore());
+		scoreboard_->setMult(player->getScoreBoardPanel(), player->getScoreMultiplier());
 	}
 
 	// Resto de marcador
-	scoreboard->setStage(enemyFormations->getStage(currentStage).number);
-	scoreboard->setPower((float)currentPower / (float)enemyFormations->getStage(currentStage).power_to_complete);
-	scoreboard->setHiScore(hiScore.score);
-	scoreboard->setHiScoreName(hiScore.name);
+	scoreboard_->setStage(enemy_formations_->getStage(current_stage_).number);
+	scoreboard_->setPower((float)current_power_ / (float)enemy_formations_->getStage(current_stage_).power_to_complete);
+	scoreboard_->setHiScore(hi_score_.score);
+	scoreboard_->setHiScoreName(hi_score_.name);
 
 	// Lógica del marcador
-	scoreboard->update();
+	scoreboard_->update();
 }
 
 // Pausa el juego
 void Game::pause(bool value)
 {
-	paused = value;
-	screen->attenuate(paused);
+	paused_ = value;
+	screen_->attenuate(paused_);
 }
 
 // Añade una puntuación a la tabla de records
@@ -2671,24 +2689,24 @@ void Game::addScoreToScoreBoard(std::string name, int score)
 	const auto entry = (HiScoreEntry){trim(name), score};
 	auto manager = std::make_unique<ManageHiScoreTable>(&options.game.hi_score_table);
 	manager->add(entry);
-	manager->saveToFile(asset->get("score.bin"));
+	manager->saveToFile(asset_->get("score.bin"));
 }
 
 // Saca del estado de GAME OVER al jugador si el otro está activo
 void Game::checkAndUpdatePlayerStatus(int activePlayerIndex, int inactivePlayerIndex)
 {
-	if (players[activePlayerIndex]->isGameOver() &&
-		!players[inactivePlayerIndex]->isGameOver() &&
-		!players[inactivePlayerIndex]->isWaiting())
+	if (players_[activePlayerIndex]->isGameOver() &&
+		!players_[inactivePlayerIndex]->isGameOver() &&
+		!players_[inactivePlayerIndex]->isWaiting())
 	{
-		players[activePlayerIndex]->setStatusPlaying(PlayerStatus::WAITING);
+		players_[activePlayerIndex]->setStatusPlaying(PlayerStatus::WAITING);
 	}
 }
 
 // Comprueba el estado de los jugadores
 void Game::checkPlayersStatusPlaying()
 {
-	if (demo.enabled)
+	if (demo_.enabled)
 	{
 		return;
 	}
@@ -2697,7 +2715,7 @@ void Game::checkPlayersStatusPlaying()
 	if (allPlayersAreWaitingOrGameOver())
 	{
 		// Entonces los pone en estado de Game Over
-		for (auto &player : players)
+		for (auto &player : players_)
 		{
 			player->setStatusPlaying(PlayerStatus::GAME_OVER);
 		}
@@ -2711,7 +2729,7 @@ void Game::checkPlayersStatusPlaying()
 // Obtiene un jugador a partir de su "id"
 std::shared_ptr<Player> Game::getPlayer(int id)
 {
-	for (auto &player : players)
+	for (auto &player : players_)
 	{
 		if (player->getId() == id)
 		{
diff --git a/source/game.h b/source/game.h
index 32d9400..fec94ae 100644
--- a/source/game.h
+++ b/source/game.h
@@ -27,30 +27,32 @@ enum class BulletType;
 struct JA_Music_t; // lines 26-26
 struct JA_Sound_t; // lines 27-27
 
-#define GAME_MODE_DEMO_OFF false
-#define GAME_MODE_DEMO_ON true
+// Modo demo
+constexpr bool GAME_MODE_DEMO_OFF = false;
+constexpr bool GAME_MODE_DEMO_ON = true;
 
 // Cantidad de elementos a escribir en los ficheros de datos
-#define TOTAL_SCORE_DATA 3
-#define TOTAL_DEMO_DATA 2000
+constexpr int TOTAL_SCORE_DATA = 3;
+constexpr int TOTAL_DEMO_DATA = 2000;
 
 // Contadores
-#define STAGE_COUNTER 200
-#define HELP_COUNTER 1000
-#define GAME_COMPLETED_START_FADE 500
-#define GAME_COMPLETED_END 700
+constexpr int STAGE_COUNTER = 200;
+constexpr int HELP_COUNTER = 1000;
+constexpr int GAME_COMPLETED_START_FADE = 500;
+constexpr int GAME_COMPLETED_END = 700;
+constexpr int GAME_OVER_COUNTER = 350;
 
 // Porcentaje de aparición de los objetos
-#define ITEM_POINTS_1_DISK_ODDS 10
-#define ITEM_POINTS_2_GAVINA_ODDS 6
-#define ITEM_POINTS_3_PACMAR_ODDS 3
-#define ITEM_CLOCK_ODDS 5
-#define ITEM_COFFEE_ODDS 5
-#define ITEM_POWER_BALL_ODDS 0
-#define ITEM_COFFEE_MACHINE_ODDS 4
+constexpr int ITEM_POINTS_1_DISK_ODDS = 10;
+constexpr int ITEM_POINTS_2_GAVINA_ODDS = 6;
+constexpr int ITEM_POINTS_3_PACMAR_ODDS = 3;
+constexpr int ITEM_CLOCK_ODDS = 5;
+constexpr int ITEM_COFFEE_ODDS = 5;
+constexpr int ITEM_POWER_BALL_ODDS = 0;
+constexpr int ITEM_COFFEE_MACHINE_ODDS = 4;
 
 // Valores para las variables asociadas a los objetos
-#define TIME_STOPPED_COUNTER 300
+constexpr int TIME_STOPPED_COUNTER = 300;
 
 /*
 	Esta clase gestiona un estado del programa. Se encarga de toda la parte en la
@@ -82,129 +84,128 @@ struct JA_Sound_t; // lines 27-27
 class Game
 {
 private:
-	struct helper_t
+	struct Helper
 	{
-		bool needCoffee;		   // Indica si se necesitan cafes
-		bool needCoffeeMachine;	   // Indica si se necesita PowerUp
-		bool needPowerBall;		   // Indica si se necesita una PowerBall
-		int counter;			   // Contador para no dar ayudas consecutivas
-		int itemPoints1Odds;	   // Probabilidad de aparición del objeto
-		int itemPoints2Odds;	   // Probabilidad de aparición del objeto
-		int itemPoints3Odds;	   // Probabilidad de aparición del objeto
-		int itemClockOdds;		   // Probabilidad de aparición del objeto
-		int itemCoffeeOdds;		   // Probabilidad de aparición del objeto
-		int itemCoffeeMachineOdds; // Probabilidad de aparición del objeto
+		bool need_coffee;			  // Indica si se necesitan cafes
+		bool need_coffee_machine;	  // Indica si se necesita PowerUp
+		bool need_power_ball;		  // Indica si se necesita una PowerBall
+		int counter;				  // Contador para no dar ayudas consecutivas
+		int item_disk_odds;			  // Probabilidad de aparición del objeto
+		int item_gavina_odds;		  // Probabilidad de aparición del objeto
+		int item_pacmar_odds;		  // Probabilidad de aparición del objeto
+		int item_clock_odds;		  // Probabilidad de aparición del objeto
+		int item_coffee_odds;		  // Probabilidad de aparición del objeto
+		int item_coffee_machine_odds; // Probabilidad de aparición del objeto
 	};
 
-	struct demo_t
+	struct Demo
 	{
-		bool enabled;						   // Indica si está activo el modo demo
-		bool recording;						   // Indica si está activado el modo para grabar la demo
-		int counter;						   // Contador para el modo demo
-		DemoKeys keys;						   // Variable con las pulsaciones de teclas del modo demo
-		DemoKeys dataFile[2][TOTAL_DEMO_DATA]; // Vector con diferentes sets de datos con los movimientos para la demo
+		bool enabled;							// Indica si está activo el modo demo
+		bool recording;							// Indica si está activado el modo para grabar la demo
+		int counter;							// Contador para el modo demo
+		DemoKeys keys;							// Variable con las pulsaciones de teclas del modo demo
+		DemoKeys data_file[2][TOTAL_DEMO_DATA]; // Vector con diferentes sets de datos con los movimientos para la demo
 	};
 
 	// Objetos y punteros
-	SDL_Renderer *renderer; // El renderizador de la ventana
-	Screen *screen;			// Objeto encargado de dibujar en pantalla
-	Asset *asset;			// Objeto que gestiona todos los ficheros de recursos
-	Input *input;			// Manejador de entrada
-	Scoreboard *scoreboard; // Objeto para dibujar el marcador
+	SDL_Renderer *renderer_; // El renderizador de la ventana
+	Screen *screen_;		 // Objeto encargado de dibujar en pantalla
+	Asset *asset_;			 // Objeto que gestiona todos los ficheros de recursos
+	Input *input_;			 // Manejador de entrada
+	Scoreboard *scoreboard_; // Objeto para dibujar el marcador
 
-	std::unique_ptr<Background> background;			  // Objeto para dibujar el fondo del juego
-	std::unique_ptr<Explosions> explosions;			  // Objeto para dibujar explosiones
-	std::unique_ptr<EnemyFormations> enemyFormations; // Objeto para gestionar las oleadas enemigas
+	std::unique_ptr<Background> background_;			// Objeto para dibujar el fondo del juego
+	std::unique_ptr<Explosions> explosions_;			// Objeto para dibujar explosiones
+	std::unique_ptr<EnemyFormations> enemy_formations_; // Objeto para gestionar las oleadas enemigas
 
-	SDL_Texture *canvas; // Textura para dibujar la zona de juego
+	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 *> smartSprites;		// 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<SmartSprite *> smart_sprites_;		 // Vector con los smartsprites
 
-	std::shared_ptr<Texture> bulletTexture;							   // Textura para las balas
-	std::vector<std::shared_ptr<Texture>> itemTextures;				   // Vector con las texturas de los items
-	std::vector<std::shared_ptr<Texture>> balloonTextures;			   // Vector con las texturas de los globos
-	std::vector<std::shared_ptr<Texture>> explosionsTextures;		   // Vector con las texturas de las explosiones
-	std::vector<std::shared_ptr<Texture>> player1Textures;			   // Vector con las texturas del jugador
-	std::vector<std::shared_ptr<Texture>> player2Textures;			   // Vector con las texturas del jugador
-	std::vector<std::vector<std::shared_ptr<Texture>>> playerTextures; // Vector con todas las texturas de los jugadores;
+	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
+	std::vector<std::shared_ptr<Texture>> balloon_textures_;			 // Vector con las texturas de los globos
+	std::vector<std::shared_ptr<Texture>> explosions_textures_;			 // Vector con las texturas de las explosiones
+	std::vector<std::shared_ptr<Texture>> player1_textures_;			 // Vector con las texturas del jugador
+	std::vector<std::shared_ptr<Texture>> player2_textures_;			 // Vector con las texturas del jugador
+	std::vector<std::vector<std::shared_ptr<Texture>>> player_textures_; // Vector con todas las texturas de los jugadores;
 
-	std::shared_ptr<Texture> gameTextTexture; // Textura para los sprites con textos
+	std::shared_ptr<Texture> game_text_texture_; // Textura para los sprites con textos
 
-	std::vector<std::vector<std::string> *> itemAnimations;		  // Vector con las animaciones de los items
-	std::vector<std::vector<std::string> *> playerAnimations;	  // Vector con las animaciones del jugador
-	std::vector<std::vector<std::string> *> balloonAnimations;	  // Vector con las animaciones de los globos
-	std::vector<std::vector<std::string> *> explosionsAnimations; // Vector con las animaciones de las explosiones
+	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
+	std::vector<std::vector<std::string> *> balloon_animations_;	// Vector con las animaciones de los globos
+	std::vector<std::vector<std::string> *> explosions_animations_; // Vector con las animaciones de las explosiones
 
-	std::unique_ptr<Text> text;			 // Fuente para los textos del juego
-	std::unique_ptr<Text> textBig;		 // Fuente de texto grande
-	std::unique_ptr<Text> textNokia2;	 // Otra fuente de texto para mensajes
-	std::unique_ptr<Text> textNokiaBig2; // Y la versión en grande
+	std::unique_ptr<Text> text_;			// Fuente para los textos del juego
+	std::unique_ptr<Text> text_big_;		// Fuente de texto grande
+	std::unique_ptr<Text> text_nokia2_;		// Otra fuente de texto para mensajes
+	std::unique_ptr<Text> text_nokia2_big_; // Y la versión en grande
 
-	std::unique_ptr<Fade> fade;				 // Objeto para renderizar fades
-	std::unique_ptr<SDL_Event> eventHandler; // Manejador de eventos
+	std::unique_ptr<Fade> fade_; // Objeto para renderizar fades
 
-	std::shared_ptr<SmartSprite> n1000Sprite; // Sprite con el texto 1.000
-	std::shared_ptr<SmartSprite> n2500Sprite; // Sprite con el texto 2.500
-	std::shared_ptr<SmartSprite> n5000Sprite; // Sprite con el texto 5.000
+	std::shared_ptr<SmartSprite> p1000_sprite_; // Sprite con el texto 1.000
+	std::shared_ptr<SmartSprite> p2500_sprite_; // Sprite con el texto 2.500
+	std::shared_ptr<SmartSprite> p5000_sprite_; // Sprite con el texto 5.000
 
-	JA_Sound_t *balloonSound;		  // Sonido para la explosión del globo
-	JA_Sound_t *bulletSound;		  // Sonido para los disparos
-	JA_Sound_t *playerCollisionSound; // Sonido para la colisión del jugador con un enemigo
-	JA_Sound_t *hiScoreSound;		  // Sonido para cuando se alcanza la máxima puntuación
-	JA_Sound_t *itemDropSound;		  // Sonido para cuando se genera un item
-	JA_Sound_t *itemPickUpSound;	  // Sonido para cuando se recoge un item
-	JA_Sound_t *coffeeOutSound;		  // Sonido para cuando el jugador pierde el café al recibir un impacto
-	JA_Sound_t *stageChangeSound;	  // Sonido para cuando se cambia de fase
-	JA_Sound_t *bubble1Sound;		  // Sonido para cuando el jugador muere
-	JA_Sound_t *bubble2Sound;		  // Sonido para cuando el jugador muere
-	JA_Sound_t *bubble3Sound;		  // Sonido para cuando el jugador muere
-	JA_Sound_t *bubble4Sound;		  // Sonido para cuando el jugador muere
-	JA_Sound_t *clockSound;			  // Sonido para cuando se detiene el tiempo con el item reloj
-	JA_Sound_t *powerBallSound;		  // Sonido para cuando se explota una Power Ball
-	JA_Sound_t *coffeeMachineSound;	  // Sonido para cuando la máquina de café toca el suelo
+	JA_Sound_t *balloon_sound_;			 // Sonido para la explosión del globo
+	JA_Sound_t *bullet_sound_;			 // Sonido para los disparos
+	JA_Sound_t *player_collision_sound_; // Sonido para la colisión del jugador con un enemigo
+	JA_Sound_t *hi_score_sound_;		 // Sonido para cuando se alcanza la máxima puntuación
+	JA_Sound_t *item_drop_sound_;		 // Sonido para cuando se genera un item
+	JA_Sound_t *item_pick_up_sound_;	 // Sonido para cuando se recoge un item
+	JA_Sound_t *coffee_out_sound_;		 // Sonido para cuando el jugador pierde el café al recibir un impacto
+	JA_Sound_t *stage_change_sound_;	 // Sonido para cuando se cambia de fase
+	JA_Sound_t *bubble1_sound_;			 // Sonido para cuando el jugador muere
+	JA_Sound_t *bubble2_sound_;			 // Sonido para cuando el jugador muere
+	JA_Sound_t *bubble3_sound_;			 // Sonido para cuando el jugador muere
+	JA_Sound_t *bubble4_sound_;			 // Sonido para cuando el jugador muere
+	JA_Sound_t *clock_sound_;			 // Sonido para cuando se detiene el tiempo con el item reloj
+	JA_Sound_t *power_ball_sound_;		 // Sonido para cuando se explota una Power Ball
+	JA_Sound_t *coffee_machine_sound_;	 // Sonido para cuando la máquina de café toca el suelo
 
-	JA_Music_t *music; // Musica de fondo
+	JA_Music_t *music_; // Musica de fondo
 
 	// Variables
-	Uint32 ticks;							 // Contador de ticks para ajustar la velocidad del programa
-	Uint32 ticksSpeed;						 // Velocidad a la que se repiten los bucles del programa
-	bool hiScoreAchieved;					 // Indica si se ha superado la puntuación máxima
-	HiScoreEntry hiScore;					 // Máxima puntuación y nombre de quien la ostenta
-	int currentStage;						 // Indica la fase actual
-	int stageBitmapCounter;					 // Contador para el tiempo visible del texto de Stage
-	float stageBitmapPath[STAGE_COUNTER];	 // Vector con los puntos Y por donde se desplaza el texto
-	float getReadyBitmapPath[STAGE_COUNTER]; // Vector con los puntos X por donde se desplaza el texto
-	int gameOverCounter;					 // Contador para el estado de fin de partida
-	int menaceCurrent;						 // Nivel de amenaza actual
-	int menaceThreshold;					 // Umbral del nivel de amenaza. Si el nivel de amenaza cae por debajo del umbral, se generan más globos. Si el umbral aumenta, aumenta el número de globos
-	bool timeStopped;						 // Indica si el tiempo está detenido
-	int timeStoppedCounter;					 // Temporizador para llevar la cuenta del tiempo detenido
-	int counter;							 // Contador para el juego
-	int balloonsPopped;						 // Lleva la cuenta de los globos explotados
-	int lastEnemyDeploy;					 // Guarda cual ha sido la última formación desplegada para no repetir;
-	int enemyDeployCounter;					 // Cuando se lanza una formación, se le da un valor y no sale otra hasta que llegue a cero
-	float enemySpeed;						 // Velocidad a la que se mueven los enemigos
-	float defaultEnemySpeed;				 // Velocidad base de los enemigos, sin incrementar
-	helper_t helper;						 // Variable para gestionar las ayudas
-	bool powerBallEnabled;					 // Indica si hay una powerball ya activa
-	int powerBallCounter;					 // Contador de formaciones enemigas entre la aparicion de una PowerBall y otra
-	bool coffeeMachineEnabled;				 // Indica si hay una máquina de café en el terreno de juego
-	bool gameCompleted;						 // Indica si se ha completado la partida, llegando al final de la ultima pantalla
-	int gameCompletedCounter;				 // Contador para el tramo final, cuando se ha completado la partida y ya no aparecen más enemigos
-	GameDifficulty difficulty;				 // Dificultad del juego
-	float difficultyScoreMultiplier;		 // Multiplicador de puntos en función de la dificultad
-	Color difficultyColor;					 // Color asociado a la dificultad
-	int lastStageReached;					 // Contiene el número de la última pantalla que se ha alcanzado
-	demo_t demo;							 // Variable con todas las variables relacionadas con el modo demo
-	int totalPowerToCompleteGame;			 // La suma del poder necesario para completar todas las fases
-	bool paused;							 // Indica si el juego está pausado (no se deberia de poder utilizar en el modo arcade)
-	int currentPower;						 // Poder actual almacenado para completar la fase
+	Uint32 ticks_;								 // Contador de ticks para ajustar la velocidad del programa
+	Uint32 ticks_speed_;						 // Velocidad a la que se repiten los bucles del programa
+	bool hi_score_achieved_;					 // Indica si se ha superado la puntuación máxima
+	HiScoreEntry hi_score_;						 // Máxima puntuación y nombre de quien la ostenta
+	int current_stage_;							 // Indica la fase actual
+	int stage_bitmap_counter_;					 // Contador para el tiempo visible del texto de Stage
+	float stage_bitmap_path_[STAGE_COUNTER];	 // Vector con los puntos Y por donde se desplaza el texto
+	float get_ready_bitmap_path_[STAGE_COUNTER]; // Vector con los puntos X por donde se desplaza el texto
+	int game_over_counter_;						 // Contador para el estado de fin de partida
+	int menace_current_;						 // Nivel de amenaza actual
+	int menace_threshold_;						 // Umbral del nivel de amenaza. Si el nivel de amenaza cae por debajo del umbral, se generan más globos. Si el umbral aumenta, aumenta el número de globos
+	bool time_stopped_;							 // Indica si el tiempo está detenido
+	int time_stopped_counter_;					 // Temporizador para llevar la cuenta del tiempo detenido
+	int counter_;								 // Contador para el juego
+	int balloons_popped_;						 // Lleva la cuenta de los globos explotados
+	int last_enemy_deploy_;						 // Guarda cual ha sido la última formación desplegada para no repetir;
+	int enemy_deploy_counter_;					 // Cuando se lanza una formación, se le da un valor y no sale otra hasta que llegue a cero
+	float enemy_speed_;							 // Velocidad a la que se mueven los enemigos
+	float default_enemy_speed_;					 // Velocidad base de los enemigos, sin incrementar
+	Helper helper_;								 // Variable para gestionar las ayudas
+	bool power_ball_enabled_;					 // Indica si hay una powerball ya activa
+	int power_ball_counter_;					 // Contador de formaciones enemigas entre la aparicion de una PowerBall y otra
+	bool coffee_machine_enabled_;				 // Indica si hay una máquina de café en el terreno de juego
+	bool game_completed_;						 // Indica si se ha completado la partida, llegando al final de la ultima pantalla
+	int game_completed_counter_;				 // Contador para el tramo final, cuando se ha completado la partida y ya no aparecen más enemigos
+	GameDifficulty difficulty_;					 // Dificultad del juego
+	float difficulty_score_multiplier_;			 // Multiplicador de puntos en función de la dificultad
+	Color difficulty_color_;					 // Color asociado a la dificultad
+	int last_stage_reached_;					 // Contiene el número de la última pantalla que se ha alcanzado
+	Demo demo_;									 // Variable con todas las variables relacionadas con el modo demo
+	int total_power_to_complete_game_;			 // La suma del poder necesario para completar todas las fases
+	bool paused_;								 // Indica si el juego está pausado (no se deberia de poder utilizar en el modo arcade)
+	int current_power_;							 // Poder actual almacenado para completar la fase
 #ifdef DEBUG
-	bool autoPopBalloons; // Si es true, incrementa automaticamente los globos explotados
+	bool auto_pop_balloons_; // Si es true, incrementa automaticamente los globos explotados
 #endif
 
 	// Actualiza el juego
@@ -217,7 +218,7 @@ private:
 	void checkEvents();
 
 	// Inicializa las variables necesarias para la sección 'Game'
-	void init(int playerID);
+	void init(int player_id);
 
 	// Carga los recursos necesarios para la sección 'Game'
 	void loadMedia();
@@ -226,10 +227,10 @@ private:
 	void unloadMedia();
 
 	// Carga el fichero de datos para la demo
-	bool loadDemoFile(std::string filePath, DemoKeys (*dataFile)[TOTAL_DEMO_DATA]);
+	bool loadDemoFile(std::string file_path, DemoKeys (*data_file)[TOTAL_DEMO_DATA]);
 #ifdef RECORDING
 	// Guarda el fichero de datos para la demo
-	bool saveDemoFile(std::string filePath);
+	bool saveDemoFile(std::string file_path);
 #endif
 	// Crea una formación de enemigos
 	void deployEnemyFormation();
@@ -259,7 +260,7 @@ private:
 	void renderBalloons();
 
 	// Crea un globo nuevo en el vector de globos
-	std::shared_ptr<Balloon> createBalloon(float x, int y, int kind, float velx, float speed, int stoppedcounter);
+	std::shared_ptr<Balloon> createBalloon(float x, int y, int kind, float velx, float speed, int stopped_counter);
 
 	// Crea una PowerBall
 	void createPowerBall();
@@ -316,7 +317,7 @@ private:
 	void renderBullets();
 
 	// Crea un objeto bala
-	void createBullet(int x, int y, BulletType kind, bool poweredUp, int owner);
+	void createBullet(int x, int y, BulletType kind, bool powered_up, int owner);
 
 	// Vacia el vector de balas
 	void freeBullets();
@@ -421,7 +422,7 @@ private:
 	bool allPlayersAreNotPlaying();
 
 	// Carga las animaciones
-	void loadAnimations(std::string filePath, std::vector<std::string> *buffer);
+	void loadAnimations(std::string file_path, std::vector<std::string> *buffer);
 
 	// Elimina todos los objetos contenidos en vectores
 	void deleteAllVectorObjects();
@@ -445,7 +446,7 @@ private:
 	void addScoreToScoreBoard(std::string name, int score);
 
 	// Saca del estado de GAME OVER al jugador si el otro está activo
-	void checkAndUpdatePlayerStatus(int activePlayerIndex, int inactivePlayerIndex);
+	void checkAndUpdatePlayerStatus(int active_player_index, int inactive_player_index);
 
 	// Comprueba el estado de juego de los jugadores
 	void checkPlayersStatusPlaying();
@@ -458,7 +459,7 @@ private:
 
 public:
 	// Constructor
-	Game(int playerID, int currentStage, bool demo, JA_Music_t *music);
+	Game(int playerID, int current_stage, bool demo, JA_Music_t *music);
 
 	// Destructor
 	~Game();