coffee_crisis_arcade_edition/source/scoreboard.h

#pragma once

#include <SDL2/SDL_rect.h>	 // Para SDL_Point, SDL_Rect
#include <SDL2/SDL_render.h> // Para SDL_Texture, SDL_Renderer
#include <SDL2/SDL_stdinc.h> // Para Uint32
#include <SDL2/SDL_timer.h>	 // Para SDL_GetTicks
#include <stddef.h>			 // Para size_t
#include <memory>			 // Para unique_ptr, shared_ptr
#include <string>			 // Para string
#include <vector>			 // Para vector
#include "utils.h"			 // Para Color
class Sprite;				 // lines 11-11
class Text;					 // lines 12-12
class Texture;				 // lines 13-13

// Defines
constexpr int SCOREBOARD_LEFT_PANEL = 0;
constexpr int SCOREBOARD_CENTER_PANEL = 1;
constexpr int SCOREBOARD_RIGHT_PANEL = 2;
constexpr int SCOREBOARD_MAX_PANELS = 3;

// Enums
enum class ScoreboardMode : int
{
	SCORE,
	STAGE_INFO,
	CONTINUE,
	WAITING,
	GAME_OVER,
	DEMO,
	ENTER_NAME,
	SHOW_NAME,
	GAME_COMPLETED,
	NUM_MODES,
};

// Structs
struct Panel
{
	ScoreboardMode mode; // Modo en el que se encuentra el panel
	SDL_Rect pos;		 // Posición donde dibujar el panel dentro del marcador
};

// Clase Scoreboard
class Scoreboard
{
private:
	// [SINGLETON] Objeto scoreboard privado para Don Melitón
	static Scoreboard *scoreboard_;

	// Objetos y punteros
	SDL_Renderer *renderer_; // El renderizador de la ventana

	std::shared_ptr<Texture> game_power_meter_texture_; // Textura con el marcador de poder de la fase
	std::unique_ptr<Sprite> power_meter_sprite_;		// Sprite para el medidor de poder de la fase
	std::shared_ptr<Text> text_scoreboard_;				// Fuente para el marcador del juego

	SDL_Texture *background_ = nullptr;		   // Textura para dibujar el marcador
	std::vector<SDL_Texture *> panel_texture_; // Texturas para dibujar cada panel

	// Variables
	std::string name_[SCOREBOARD_MAX_PANELS] = {};		  // Nom de cada jugador
	std::string record_name_[SCOREBOARD_MAX_PANELS] = {}; // Nombre introducido para la tabla de records
	size_t selector_pos_[SCOREBOARD_MAX_PANELS] = {};	  // Posición del selector de letra para introducir el nombre
	int score_[SCOREBOARD_MAX_PANELS] = {};				  // Puntuación de los jugadores
	float mult_[SCOREBOARD_MAX_PANELS] = {};			  // Multiplicador de los jugadores
	int continue_counter_[SCOREBOARD_MAX_PANELS] = {};	  // Tiempo para continuar de los jugadores
	Panel panel_[SCOREBOARD_MAX_PANELS] = {};			  // Lista con todos los paneles del marcador
	int stage_ = 1;										  // Número de fase actual
	int hi_score_ = 0;									  // Máxima puntuación
	float power_ = 0;									  // Poder actual de la fase
	std::string hi_score_name_ = std::string();			  // Nombre del jugador con la máxima puntuación
	Color color_ = Color();								  // Color del marcador
	SDL_Rect rect_ = {0, 0, 320, 40};					  // Posición y dimensiones del marcador
	Uint32 ticks_ = SDL_GetTicks();						  // Variable donde almacenar el valor de SDL_GetTiks()
	int time_counter_ = 0;								  // Contador de segundos
	int loop_counter_ = 0;								  // Contador de bucle
	std::vector<Color> name_colors_;					  // Colores para destacar el nombre una vez introducido

	// Puntos predefinidos para colocar elementos en los paneles
	SDL_Point slot4_1_, slot4_2_, slot4_3_, slot4_4_;
	SDL_Point enter_name_pos_;

	// Recalcula las anclas de los elementos
	void recalculateAnchors();

	// Transforma un valor numérico en una cadena de 7 cifras
	std::string updateScoreText(int num);

	// Crea la textura de fondo
	void createBackgroundTexture();

	// Crea las texturas de los paneles
	void createPanelTextures();

	// Rellena los diferentes paneles del marcador
	void fillPanelTextures();

	// Rellena la textura de fondo
	void fillBackgroundTexture();

	// Actualiza el contador
	void updateTimeCounter();

	// Dibuja la linea que separa la zona de juego del marcador
	void renderSeparator();

	// Inicializa el vector de colores para el nombre
	void iniNameColors();

	// [SINGLETON] Ahora el constructor y el destructor son privados

	// Constructor
	Scoreboard();

	// Destructor
	~Scoreboard();

public:
	// [SINGLETON] Crearemos el objeto scoreboard con esta función estática
	static void init();

	// [SINGLETON] Destruiremos el objeto scoreboard con esta función estática
	static void destroy();

	// [SINGLETON] Con este método obtenemos el objeto scoreboard y podemos trabajar con él
	static Scoreboard *get();

	// Actualiza la lógica del marcador
	void update();

	// Pinta el marcador
	void render();

	// Establece el valor de la variable
	void setColor(Color color);

	// Establece el valor de la variable
	void setPos(SDL_Rect rect);

	void setContinue(int panel, int continue_counter) { continue_counter_[panel] = continue_counter; }
	void setHiScore(int hi_score) { hi_score_ = hi_score; }
	void setHiScoreName(const std::string &name) { hi_score_name_ = name; }
	void setMode(int index, ScoreboardMode mode) { panel_[index].mode = mode; }
	void setMult(int panel, float mult) { mult_[panel] = mult; }
	void setName(int panel, const std::string &name) { name_[panel] = name; }
	void setPower(float power) { power_ = power; }
	void setRecordName(int panel, const std::string &record_name) { record_name_[panel] = record_name; }
	void setScore(int panel, int score) { score_[panel] = score; }
	void setSelectorPos(int panel, int pos) { selector_pos_[panel] = pos; }
	void setStage(int stage) { stage_ = stage; }
};