style: canvis en Player

source/player.cpp

@@ -223,7 +223,6 @@ void Player::switchBorders()
         break;
 
     default:
-        // Manejo para casos no previstos (opcional)
         break;
     }
 
@@ -235,13 +234,13 @@ void Player::switchBorders()
 // Aplica gravedad al jugador
 void Player::applyGravity()
 {
-    constexpr float GF = 0.035f;
+    constexpr float GRAVITY_FORCE = 0.035f;
 
     // La gravedad solo se aplica cuando el jugador esta saltando
     // Nunca mientras cae o esta de pie
     if (state_ == PlayerState::JUMPING)
     {
-        vy_ += GF;
+        vy_ += GRAVITY_FORCE;
         if (vy_ > MAX_VY_)
         {
             vy_ = MAX_VY_;
@@ -275,10 +274,10 @@ void Player::move()
 #endif
 
         // Comprueba la colisión con las superficies
-        const int pos = room_->checkRightSurfaces(&proj);
+        const int POS = room_->checkRightSurfaces(&proj);
 
         // Calcula la nueva posición
-        if (pos == -1)
+        if (POS == -1)
         {
             // Si no hay colisión
             x_ += vx_;
@@ -286,14 +285,14 @@ void Player::move()
         else
         {
             // Si hay colisión lo mueve hasta donde no colisiona
-            x_ = pos + 1;
+            x_ = POS + 1;
         }
 
         // Si ha tocado alguna rampa mientras camina (sin saltar), asciende
         if (state_ != PlayerState::JUMPING)
         {
-            LineVertical leftSide = {static_cast<int>(x_), static_cast<int>(y_) + HEIGHT_ - 2, static_cast<int>(y_) + HEIGHT_ - 1}; // Comprueba solo los dos pixels de abajo
+            const LineVertical LEFT_SIDE = {static_cast<int>(x_), static_cast<int>(y_) + HEIGHT_ - 2, static_cast<int>(y_) + HEIGHT_ - 1}; // Comprueba solo los dos pixels de abajo
-            const int ly = room_->checkLeftSlopes(&leftSide);
+            const int ly = room_->checkLeftSlopes(&LEFT_SIDE);
             if (ly > -1)
             {
                 y_ = ly - HEIGHT_;
@@ -322,10 +321,10 @@ void Player::move()
 #endif
 
         // Comprueba la colisión
-        const int pos = room_->checkLeftSurfaces(&proj);
+        const int POS = room_->checkLeftSurfaces(&proj);
 
         // Calcula la nueva posición
-        if (pos == -1)
+        if (POS == -1)
         {
             // Si no hay colisión
             x_ += vx_;
@@ -333,17 +332,17 @@ void Player::move()
         else
         {
             // Si hay colisión lo mueve hasta donde no colisiona
-            x_ = pos - WIDTH_;
+            x_ = POS - WIDTH_;
         }
 
         // Si ha tocado alguna rampa mientras camina (sin saltar), asciende
         if (state_ != PlayerState::JUMPING)
         {
-            LineVertical rightSide = {static_cast<int>(x_) + WIDTH_ - 1, static_cast<int>(y_) + HEIGHT_ - 2, static_cast<int>(y_) + HEIGHT_ - 1}; // Comprueba solo los dos pixels de abajo
+            const LineVertical RIGHT_SIDE = {static_cast<int>(x_) + WIDTH_ - 1, static_cast<int>(y_) + HEIGHT_ - 2, static_cast<int>(y_) + HEIGHT_ - 1}; // Comprueba solo los dos pixels de abajo
-            const int ry = room_->checkRightSlopes(&rightSide);
+            const int RY = room_->checkRightSlopes(&RIGHT_SIDE);
-            if (ry > -1)
+            if (RY > -1)
             {
-                y_ = ry - HEIGHT_;
+                y_ = RY - HEIGHT_;
             }
         }
 
@@ -385,10 +384,10 @@ void Player::move()
 #endif
 
         // Comprueba la colisión
-        const int pos = room_->checkBottomSurfaces(&proj);
+        const int POS = room_->checkBottomSurfaces(&proj);
 
         // Calcula la nueva posición
-        if (pos == -1)
+        if (POS == -1)
         {
             // Si no hay colisión
             y_ += vy_;
@@ -396,7 +395,7 @@ void Player::move()
         else
         {
             // Si hay colisión lo mueve hasta donde no colisiona y entra en caída
-            y_ = pos + 1;
+            y_ = POS + 1;
             setState(PlayerState::FALLING);
         }
     }
@@ -416,11 +415,11 @@ void Player::move()
 #endif
 
         // Comprueba la colisión con las superficies normales y las automáticas
-        const int pos = std::max(room_->checkTopSurfaces(&proj), room_->checkAutoSurfaces(&proj));
+        const int POS = std::max(room_->checkTopSurfaces(&proj), room_->checkAutoSurfaces(&proj));
-        if (pos > -1)
+        if (POS > -1)
         {
             // Si hay colisión lo mueve hasta donde no colisiona y pasa a estar sobre la superficie
-            y_ = pos - HEIGHT_;
+            y_ = POS - HEIGHT_;
             setState(PlayerState::STANDING);
 
             // Deja de estar enganchado a la superficie automatica
@@ -431,18 +430,18 @@ void Player::move()
             // Si no hay colisión con los muros, comprueba la colisión con las rampas
             if (state_ != PlayerState::JUMPING)
             { // Las rampas no se miran si se está saltando
-                LineVertical leftSide = {proj.x, proj.y, proj.y + proj.h - 1};
+                const LineVertical LEFT_SIDE = {proj.x, proj.y, proj.y + proj.h - 1};
-                LineVertical rightSide = {proj.x + proj.w - 1, proj.y, proj.y + proj.h - 1};
+                const LineVertical RIGHT_SIDE = {proj.x + proj.w - 1, proj.y, proj.y + proj.h - 1};
-                const int p = std::max(room_->checkRightSlopes(&rightSide), room_->checkLeftSlopes(&leftSide));
+                const int POINT = std::max(room_->checkRightSlopes(&RIGHT_SIDE), room_->checkLeftSlopes(&LEFT_SIDE));
-                if (p > -1)
+                if (POINT > -1)
                 {
                     // No está saltando y hay colisión con una rampa
                     // Calcula la nueva posición
-                    y_ = p - HEIGHT_;
+                    y_ = POINT - HEIGHT_;
                     setState(PlayerState::STANDING);
 #ifdef DEBUG
                     debug_color_ = {255, 255, 0};
-                    debug_point_ = {(int)x_ + (WIDTH_ / 2), p};
+                    debug_point_ = {(int)x_ + (WIDTH_ / 2), POINT};
 #endif
                 }
                 else
@@ -529,70 +528,70 @@ void Player::playFallSound()
 // Comprueba si el jugador tiene suelo debajo de los pies
 bool Player::isOnFloor()
 {
-    bool onFloor = false;
+    bool on_floor = false;
-    bool onSlopeL = false;
+    bool on_slope_l = false;
-    bool onSlopeR = false;
+    bool on_slope_r = false;
 
     updateFeet();
 
     // Comprueba las superficies
     for (auto f : under_feet_)
     {
-        onFloor |= room_->checkTopSurfaces(&f);
+        on_floor |= room_->checkTopSurfaces(&f);
-        onFloor |= room_->checkAutoSurfaces(&f);
+        on_floor |= room_->checkAutoSurfaces(&f);
     }
 
     // Comprueba las rampas
-    onSlopeL = room_->checkLeftSlopes(&under_feet_[0]);
+    on_slope_l = room_->checkLeftSlopes(&under_feet_[0]);
-    onSlopeR = room_->checkRightSlopes(&under_feet_[1]);
+    on_slope_r = room_->checkRightSlopes(&under_feet_[1]);
 
 #ifdef DEBUG
-    if (onFloor)
+    if (on_floor)
     {
         Debug::get()->add("ON_FLOOR");
     }
 
-    if (onSlopeL)
+    if (on_slope_l)
     {
         Debug::get()->add("ON_SLOPE_L: " + std::to_string(under_feet_[0].x) + "," + std::to_string(under_feet_[0].y));
     }
 
-    if (onSlopeR)
+    if (on_slope_r)
     {
         Debug::get()->add("ON_SLOPE_R: " + std::to_string(under_feet_[1].x) + "," + std::to_string(under_feet_[1].y));
     }
 #endif
 
-    return onFloor || onSlopeL || onSlopeR;
+    return on_floor || on_slope_l || on_slope_r;
 }
 
 // Comprueba si el jugador esta sobre una superficie automática
 bool Player::isOnAutoSurface()
 {
-    bool onAutoSurface = false;
+    bool on_auto_surface = false;
 
     updateFeet();
 
     // Comprueba las superficies
     for (auto f : under_feet_)
     {
-        onAutoSurface |= room_->checkAutoSurfaces(&f);
+        on_auto_surface |= room_->checkAutoSurfaces(&f);
     }
 
 #ifdef DEBUG
-    if (onAutoSurface)
+    if (on_auto_surface)
     {
         Debug::get()->add("ON_AUTO_SURFACE");
     }
 #endif
 
-    return onAutoSurface;
+    return on_auto_surface;
 }
 
 // Comprueba si el jugador está sobre una rampa hacia abajo
 bool Player::isOnDownSlope()
 {
-    bool onSlope = false;
+    bool on_slope = false;
 
     updateFeet();
 
@@ -602,17 +601,17 @@ bool Player::isOnDownSlope()
     under_feet_[1].y += 1;
 
     // Comprueba las rampas
-    onSlope |= room_->checkLeftSlopes(&under_feet_[0]);
+    on_slope |= room_->checkLeftSlopes(&under_feet_[0]);
-    onSlope |= room_->checkRightSlopes(&under_feet_[1]);
+    on_slope |= room_->checkRightSlopes(&under_feet_[1]);
 
 #ifdef DEBUG
-    if (onSlope)
+    if (on_slope)
     {
         Debug::get()->add("ON_DOWN_SLOPE");
     }
 #endif
 
-    return onSlope;
+    return on_slope;
 }
 
 // Comprueba que el jugador no toque ningun tile de los que matan