renomena tipus niats a CamelCase (Bouncing, Stage, Item, Selector, ...)

source/core/input/input.cpp

@@ -62,12 +62,12 @@ auto Input::get() -> Input * {
 Input::Input(std::string file)
     : dbPath(std::move(file)) {
     // Inicializa las variables
-    keyBindings_t kb;
+    KeyBindings kb;
     kb.scancode = 0;
     kb.active = false;
     keyBindings.resize(input_number_of_inputs, kb);
 
-    GameControllerBindings_t gcb;
+    GameControllerBindings gcb;
     gcb.button = SDL_GAMEPAD_BUTTON_INVALID;
     gcb.active = false;
     gameControllerBindings.resize(input_number_of_inputs, gcb);

source/core/input/input.h

@@ -52,12 +52,12 @@ enum InputDisable : std::uint8_t {
 
 class Input {
    private:
-    struct keyBindings_t {
+    struct KeyBindings {
         Uint8 scancode;  // Scancode asociado
         bool active;     // Indica si está activo
     };
 
-    struct GameControllerBindings_t {
+    struct GameControllerBindings {
         SDL_GamepadButton button;  // GameControllerButton asociado
         bool active;               // Indica si está activo
     };
@@ -67,8 +67,8 @@ class Input {
     std::vector<SDL_JoystickID> connectedControllerIds;  // Instance IDs paralelos para mapear eventos
 
     // Variables
-    std::vector<keyBindings_t> keyBindings;                        // Vector con las teclas asociadas a los inputs predefinidos
+    std::vector<KeyBindings> keyBindings;                        // Vector con las teclas asociadas a los inputs predefinidos
-    std::vector<GameControllerBindings_t> gameControllerBindings;  // Vector con las teclas asociadas a los inputs predefinidos
+    std::vector<GameControllerBindings> gameControllerBindings;  // Vector con las teclas asociadas a los inputs predefinidos
     std::vector<std::string> controllerNames;                      // Vector con los nombres de los mandos
     int numGamepads{0};                                            // Numero de mandos conectados
     std::string dbPath;                                            // Ruta al archivo gamecontrollerdb.txt

source/core/resources/asset.cpp

@@ -31,7 +31,7 @@ Asset::Asset(const std::string &executablePath)
 
 // Añade un elemento a la lista
 void Asset::add(const std::string &file, enum AssetType type, bool required, bool absolute) {
-    item_t temp;
+    Item temp;
     temp.file = absolute ? file : executablePath + file;
     temp.type = type;
     temp.required = required;

source/core/resources/asset.h

@@ -21,7 +21,7 @@ enum AssetType : std::uint8_t {
 class Asset {
    public:
     // Estructura para definir un item
-    struct item_t {
+    struct Item {
         std::string file;     // Ruta del fichero desde la raiz del directorio
         enum AssetType type;  // Indica el tipo de recurso
         bool required;        // Indica si es un fichero que debe de existir
@@ -30,7 +30,7 @@ class Asset {
    private:
     // Variables
     int longestName{0};            // Contiene la longitud del nombre de fichero mas largo
-    std::vector<item_t> fileList;  // Listado con todas las rutas a los ficheros
+    std::vector<Item> fileList;  // Listado con todas las rutas a los ficheros
     std::string executablePath;    // Ruta al ejecutable
     bool verbose{true};            // Indica si ha de mostrar información por pantalla
 
@@ -59,7 +59,7 @@ class Asset {
     auto get(const std::string &text) -> std::string;
 
     // Devuelve toda la lista de items registrados
-    [[nodiscard]] auto getAll() const -> const std::vector<item_t> & { return fileList; }
+    [[nodiscard]] auto getAll() const -> const std::vector<Item> & { return fileList; }
 
     // Comprueba que existen todos los elementos
     auto check() -> bool;

source/game/entities/balloon.h

@@ -72,7 +72,7 @@ constexpr int POWERBALL_COUNTER = 8;
 class Balloon {
    private:
     // Estructura para las variables para el efecto de los rebotes
-    struct bouncing {
+    struct Bouncing {
         bool enabled;          // Si el efecto está activo
         Uint8 counter;         // Countador para el efecto
         Uint8 speed;           // Velocidad a la que transcurre el efecto
@@ -116,7 +116,7 @@ class Balloon {
     float speed;                // Velocidad a la que se mueven los globos
     Uint8 size;                 // Tamaño del globo
     Uint8 power;                // Cantidad de poder que alberga el globo
-    bouncing bouncing;          // Contiene las variables para el efecto de rebote
+    Bouncing bouncing;          // Contiene las variables para el efecto de rebote
 
     // Alinea el circulo de colisión con la posición del objeto globo
     void updateColliders();

source/game/game.h

@@ -52,7 +52,7 @@ constexpr int TIME_STOPPED_COUNTER = 300;
 // Clase Game
 class Game {
    private:
-    struct enemyInits_t {
+    struct EnemyInit {
         int x;                   // Posición en el eje X donde crear al enemigo
         int y;                   // Posición en el eje Y donde crear al enemigo
         float velX;              // Velocidad inicial en el eje X
@@ -60,19 +60,19 @@ class Game {
         Uint16 creationCounter;  // Temporizador para la creación del enemigo
     };
 
-    struct enemyFormation_t  // Contiene la información de una formación enemiga
+    struct EnemyFormation  // Contiene la información de una formación enemiga
     {
         Uint8 numberOfEnemies;                                    // Cantidad de enemigos que forman la formación
-        enemyInits_t init[MAX_NUMBER_OF_ENEMIES_IN_A_FORMATION];  // Vector con todas las inicializaciones de los enemigos de la formación
+        EnemyInit init[MAX_NUMBER_OF_ENEMIES_IN_A_FORMATION];  // Vector con todas las inicializaciones de los enemigos de la formación
     };
 
-    struct enemyPool_t {
+    struct EnemyPool {
-        enemyFormation_t *set[10];  // Conjunto de formaciones enemigas
+        EnemyFormation *set[10];  // Conjunto de formaciones enemigas
     };
 
-    struct stage_t  // Contiene todas las variables relacionadas con una fase
+    struct Stage  // Contiene todas las variables relacionadas con una fase
     {
-        enemyPool_t *enemyPool;  // El conjunto de formaciones enemigas de la fase
+        EnemyPool *enemyPool;  // El conjunto de formaciones enemigas de la fase
         Uint16 currentPower;     // Cantidad actual de poder
         Uint16 powerToComplete;  // Cantidad de poder que se necesita para completar la fase
         Uint8 maxMenace;         // Umbral máximo de amenaza de la fase
@@ -80,14 +80,14 @@ class Game {
         Uint8 number;            // Numero de fase
     };
 
-    struct effect_t {
+    struct Effect {
         bool flash;          // Indica si se ha de pintar la pantalla de blanco
         bool shake;          // Indica si se ha de agitar la pantalla
         Uint8 shakeCounter;  // Contador para medir el tiempo que dura el efecto
     };
 
     // Estado para el efecto de agitación intensa (muerte del jugador)
-    struct deathShake_t {
+    struct DeathShake {
         bool active;           // Indica si el efecto está activo
         Uint8 step;            // Paso actual del efecto (0-7)
         Uint32 lastStepTicks;  // Ticks del último paso
@@ -100,13 +100,13 @@ class Game {
         Done };
 
     // Estado de la secuencia de muerte del jugador
-    struct deathSequence_t {
+    struct DeathSequence {
         DeathPhase phase;        // Fase actual
         Uint32 phaseStartTicks;  // Ticks del inicio de la fase actual
         Player *player;          // Jugador que está muriendo
     };
 
-    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
@@ -119,7 +119,7 @@ class Game {
         int itemCoffeeMachineOdds;  // 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
         Uint16 counter;                        // Contador para el modo demo
@@ -209,7 +209,7 @@ class Game {
     Uint32 hiScore;                                               // Puntuación máxima
     bool hiScoreAchieved;                                         // Indica si se ha superado la puntuación máxima
     std::string hiScoreName;                                      // Nombre del jugador que ostenta la máxima puntuación
-    stage_t stage[10];                                            // Variable con los datos de cada pantalla
+    Stage stage[10];                                            // Variable con los datos de cada pantalla
     Uint8 currentStage;                                           // Indica la fase actual
     Uint8 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
@@ -227,10 +227,10 @@ class Game {
     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
-    effect_t effect;                                              // Variable para gestionar los efectos visuales
+    Effect effect;                                              // Variable para gestionar los efectos visuales
-    deathShake_t deathShake;                                      // Variable para gestionar el efecto de agitación intensa
+    DeathShake deathShake;                                      // Variable para gestionar el efecto de agitación intensa
-    deathSequence_t deathSequence;                                // Variable para gestionar la secuencia de muerte
+    DeathSequence deathSequence;                                // Variable para gestionar la secuencia de muerte
-    helper_t helper;                                              // Variable para gestionar las ayudas
+    Helper helper;                                              // Variable para gestionar las ayudas
     bool powerBallEnabled;                                        // Indica si hay una powerball ya activa
     Uint8 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
@@ -240,10 +240,10 @@ class Game {
     float difficultyScoreMultiplier;                              // Multiplicador de puntos en función de la dificultad
     Color difficultyColor;                                      // Color asociado a la dificultad
     Uint8 onePlayerControl;                                       // Variable para almacenar el valor de las opciones
-    enemyFormation_t enemyFormation[NUMBER_OF_ENEMY_FORMATIONS];  // Vector con todas las formaciones enemigas
+    EnemyFormation enemyFormation[NUMBER_OF_ENEMY_FORMATIONS];  // Vector con todas las formaciones enemigas
-    enemyPool_t enemyPool[10];                                    // Variable con los diferentes conjuntos de formaciones enemigas
+    EnemyPool enemyPool[10];                                    // Variable con los diferentes conjuntos de formaciones enemigas
     Uint8 lastStageReached;                                       // Contiene el numero de la última pantalla que se ha alcanzado
-    demo_t demo;                                                  // Variable con todas las variables relacionadas con el modo demo
+    Demo demo;                                                  // Variable con todas las variables relacionadas con el modo demo
     int totalPowerToCompleteGame;                                 // La suma del poder necesario para completar todas las fases
     int cloudsSpeed{0};                                           // Velocidad a la que se desplazan las nubes
     int pauseCounter;                                             // Contador para salir del menu de pausa y volver al juego

source/game/scenes/title.h

@@ -29,7 +29,7 @@ constexpr int TITLE_TOTAL_EVENTS = 2;
 
 class Title {
    private:
-    struct menu_t {
+    struct MenuData {
         Menu *title;         // Menu de la pantalla de título
         Menu *options;       // Menú de la pantalla de opciones
         Menu *playerSelect;  // Menu para elegir jugador
@@ -77,7 +77,7 @@ class Title {
     Section nextSection;   // Indica cual es la siguiente sección a cargar cuando termine el contador del titulo
     Uint32 ticksSpeed;       // Velocidad a la que se repiten los bucles del programa
     Uint8 postFade;          // Opción a realizar cuando termina el fundido
-    menu_t menu;             // Variable con todos los objetos menus y sus variables
+    MenuData menu;             // Variable con todos los objetos menus y sus variables
     // Snapshot per a permetre CANCEL al menú d'opcions.
     Options::Video prevVideo;
     Options::Window prevWindow;

source/game/ui/menu.cpp

@@ -107,7 +107,7 @@ auto Menu::parseFromStream(std::istream &file, const std::string &filename) -> b
     while (std::getline(file, line)) {
         strip_cr(line);
         if (line == "[item]") {
-            item_t newItem;
+            Item newItem;
             newItem.label = "";
             newItem.hPaddingDown = 1;
             newItem.selectable = true;
@@ -171,7 +171,7 @@ auto Menu::loadFromBytes(const std::vector<uint8_t> &bytes, const std::string &n
 }
 
 // Asigna variables a partir de dos cadenas
-auto Menu::setItem(item_t *item, const std::string &var, const std::string &value) -> bool {
+auto Menu::setItem(Item *item, const std::string &var, const std::string &value) -> bool {
     // Indicador de éxito en la asignación
     bool success = true;
 
@@ -449,7 +449,7 @@ void Menu::setSelectorPos(int index) {
 
 // Obtiene la anchura del elemento más ancho del menu
 auto Menu::getWidestItem() -> int {
-    return std::accumulate(item.begin(), item.end(), 0, [](int acc, const item_t &i) { return std::max(acc, i.rect.w); });
+    return std::accumulate(item.begin(), item.end(), 0, [](int acc, const Item &i) { return std::max(acc, i.rect.w); });
 }
 
 // Deja el menu apuntando al primer elemento
@@ -737,7 +737,7 @@ void Menu::centerMenuElementsOnX() {
 }
 
 // Añade un item al menu
-void Menu::addItem(item_t new_item) {
+void Menu::addItem(Item new_item) {
     if (item.empty()) {  // Si es el primer item coge la posición en el eje Y del propio menu
         new_item.rect.y = y;
     } else {  // En caso contrario, coge la posición en el eje Y a partir del último elemento
@@ -811,7 +811,7 @@ auto Menu::findWidth() -> int {
 
 // Calcula el alto del menu
 auto Menu::findHeight() -> int {
-    const int height = std::accumulate(item.begin(), item.end(), 0, [](int acc, const item_t &i) { return acc + i.rect.h + i.hPaddingDown; });
+    const int height = std::accumulate(item.begin(), item.end(), 0, [](int acc, const Item &i) { return acc + i.rect.h + i.hPaddingDown; });
 
     return height - item.back().hPaddingDown;
 }

source/game/ui/menu.h

@@ -25,13 +25,13 @@ constexpr int MENU_NO_OPTION = -1;
 // Clase Menu
 class Menu {
    private:
-    struct rectangle_t {
+    struct Rectangle {
         SDL_Rect rect;  // Rectangulo
         Color color;  // Color
         int a;          // Transparencia
     };
 
-    struct item_t {
+    struct Item {
         std::string label;  // Texto
         SDL_Rect rect;      // Rectangulo que delimita el elemento
         int hPaddingDown;   // Espaciado bajo el elemento
@@ -43,7 +43,7 @@ class Menu {
         bool line;          // Indica si el elemento lleva una linea a continuación
     };
 
-    struct selector_t {
+    struct Selector {
         float originY;              // Coordenada de origen
         float targetY;              // Coordenada de destino
         float despY;                // Cantidad de pixeles que se desplaza el selector en cada salto: (target - origin) / numJumps
@@ -89,9 +89,9 @@ class Menu {
     JA_Sound_t *soundCancel;      // Sonido al cancelar el menu
     JA_Sound_t *soundMove;        // Sonido al mover el selector
     Color colorGreyed;          // Color para los elementos agrisados
-    rectangle_t rectBG;           // Rectangulo de fondo del menu
+    Rectangle rectBG;           // Rectangulo de fondo del menu
-    std::vector<item_t> item;     // Estructura para cada elemento del menu
+    std::vector<Item> item;     // Estructura para cada elemento del menu
-    selector_t selector;          // Variables para pintar el selector del menu
+    Selector selector;          // Variables para pintar el selector del menu
     std::string font_png;
     std::string font_txt;
 
@@ -105,7 +105,7 @@ class Menu {
     auto setVars(const std::string &var, const std::string &value) -> bool;
 
     // Asigna variables a partir de dos cadenas
-    static auto setItem(item_t *item, const std::string &var, const std::string &value) -> bool;
+    static auto setItem(Item *item, const std::string &var, const std::string &value) -> bool;
 
     // Actualiza el menu para recolocarlo correctamente y establecer el tamaño
     void reorganize();
@@ -190,7 +190,7 @@ class Menu {
     void centerMenuElementsOnX();
 
     // Añade un item al menu
-    void addItem(item_t new_item);
+    void addItem(Item new_item);
 
     // Cambia el texto de un item
     void setItemCaption(int index, const std::string &text);