diff --git a/src/Tank.cpp b/src/Tank.cpp
index bcaee58..4bb9d87 100644
--- a/src/Tank.cpp
+++ b/src/Tank.cpp
@@ -40,7 +40,7 @@ void Tank::setType(TankType tankType)
 {
     type_ = tankType;
     stats_ = typesStats_[tankType];
-    stats_.speed = getCalculatedSpeed(Config::getInstance().getSpeedFactor());
+    stats_.speed_ = getCalculatedSpeed(Config::getInstance().getSpeedFactor());
 }
 
 void Tank::setDirection(Direction direction) { direction_ = direction; }
@@ -55,26 +55,26 @@ bool Tank::canFire(TimePoint currentTime) const
 
 bool Tank::hit(unsigned int power)
 {
-    if (power > stats_.shield)
-        stats_.shield = 0;
+    if (power > stats_.shield_)
+        stats_.shield_ = 0;
     else
-        stats_.shield -= power;
+        stats_.shield_ -= power;
 
-    if (stats_.shield == 0)
+    if (stats_.shield_ == 0)
     {
-        if (stats_.lives <= 1)
+        if (stats_.lives_ <= 1)
         {
-            stats_.lives = 0;
+            stats_.lives_ = 0;
             return true;
         }
-        const unsigned int livesLeft = stats_.lives - 1;
+        const unsigned int livesLeft = stats_.lives_ - 1;
         respawn();
-        stats_.lives = livesLeft;
+        stats_.lives_ = livesLeft;
     }
     return false;
 }
 
-void Tank::setSpeedUp() { stats_.speed++; }
+void Tank::setSpeedUp() { stats_.speed_++; }
 
 Direction Tank::getDirection() const { return direction_; }
 
@@ -112,27 +112,27 @@ TankStats Tank::getStats() const { return stats_; }
 Bullet Tank::fire(TimePoint currentTime)
 {
     lastFire_ = currentTime;
-    return {getCenter(), stats_.speed + 2, isPlayerControlled(),
-            stats_.attackPower, getDirection()};
+    return {getCenter(), stats_.speed_ + 2, isPlayerControlled(),
+            stats_.attackPower_, getDirection()};
 }
 
 std::pair<int, int> Tank::getNextExpectedPosition()
 {
-    const int speed{static_cast<int>(stats_.speed)};
+    const int speed{static_cast<int>(stats_.speed_)};
     std::pair<int, int> nextPosition{
         static_cast<int>(getX()) + getDirectionX() * speed,
         static_cast<int>(getY()) + getDirectionY() * speed};
     return nextPosition;
 }
 
-void Tank::addLife() { stats_.lives++; }
+void Tank::addLife() { stats_.lives_++; }
 
 void Tank::applyPowerUp(ResourceType powerUpType)
 {
     switch (powerUpType)
     {
         case ResourceType::SHIELD_UP:
-            stats_.shield = typesStats_[type_].shield;
+            stats_.shield_ = typesStats_[type_].shield_;
             break;
 
         case ResourceType::TIER_UP:
@@ -140,8 +140,8 @@ void Tank::applyPowerUp(ResourceType powerUpType)
             {
                 const TankStats oldStats{stats_};
                 setType(static_cast<TankType>(static_cast<int>(type_) + 1));
-                stats_.lives = oldStats.lives;
-                stats_.speed = std::max(oldStats.speed, stats_.speed);
+                stats_.lives_ = oldStats.lives_;
+                stats_.speed_ = std::max(oldStats.speed_, stats_.speed_);
             }
             break;
 
@@ -183,7 +183,7 @@ void Tank::respawn()
 unsigned int Tank::getCalculatedSpeed(float speedFactor) const
 {
     const unsigned int tileSize{Config::getInstance().getTileSize()};
-    float speed{std::round(static_cast<float>(stats_.speed) * speedFactor)};
+    float speed{std::round(static_cast<float>(stats_.speed_) * speedFactor)};
     if (!isPlayerControlled())
         while (speed >= 1 && tileSize % static_cast<unsigned int>(speed) != 0)
             speed -= 1;
diff --git a/src/TankStats.h b/src/TankStats.h
index de1a3ee..6ae00ce 100644
--- a/src/TankStats.h
+++ b/src/TankStats.h
@@ -2,8 +2,8 @@
 
 struct TankStats
 {
-    unsigned int attackPower;
-    unsigned int shield;
-    unsigned int speed;
-    unsigned int lives;
+    unsigned int attackPower_;
+    unsigned int shield_;
+    unsigned int speed_;
+    unsigned int lives_;
 };
diff --git a/test/TankTest.cpp b/test/TankTest.cpp
index e3f6570..23e8c83 100644
--- a/test/TankTest.cpp
+++ b/test/TankTest.cpp
@@ -162,10 +162,10 @@ namespace
 {
 void statsAreSame(TankStats left, TankStats right)
 {
-    REQUIRE(left.attackPower == right.attackPower);
-    REQUIRE(left.shield == right.shield);
-    REQUIRE(left.lives == right.lives);
-    REQUIRE(left.speed == right.speed);
+    REQUIRE(left.attackPower_ == right.attackPower_);
+    REQUIRE(left.shield_ == right.shield_);
+    REQUIRE(left.lives_ == right.lives_);
+    REQUIRE(left.speed_ == right.speed_);
 }
 }  // namespace
 
@@ -175,13 +175,13 @@ TEST_CASE("statistics", "[tank]")
     SECTION("getting initial basic enemy statistics")
     {
         const Tank tank(TankType::ENEMY_TIER_1, point);
-        statsAreSame(tank.getStats(), {1, 1, tank.getStats().speed, 1});
+        statsAreSame(tank.getStats(), {1, 1, tank.getStats().speed_, 1});
     }
 
     SECTION("getting initial basic player statistics")
     {
         const Tank tank(TankType::PLAYER_TIER_1, point);
-        statsAreSame(tank.getStats(), {1, 1, tank.getStats().speed, 2});
+        statsAreSame(tank.getStats(), {1, 1, tank.getStats().speed_, 2});
     }
 }
 
@@ -191,33 +191,33 @@ TEST_CASE("hitting", "[tank]")
     SECTION("single hit, not destroying")
     {
         Tank tank(TankType::ENEMY_TIER_2, point);
-        CHECK(tank.getStats().shield == 2);
+        CHECK(tank.getStats().shield_ == 2);
         tank.hit(1);
-        REQUIRE(tank.getStats().shield == 1);
+        REQUIRE(tank.getStats().shield_ == 1);
     }
 
     SECTION("double hit, not destroying")
     {
         Tank tank(TankType::ENEMY_TIER_3, point);
-        CHECK(tank.getStats().shield == 3);
+        CHECK(tank.getStats().shield_ == 3);
         tank.hit(1);
         tank.hit(1);
-        REQUIRE(tank.getStats().shield == 1);
+        REQUIRE(tank.getStats().shield_ == 1);
     }
 
     SECTION("single hit, destroying, no more lives")
     {
         Tank tank(TankType::ENEMY_TIER_1, point);
         tank.hit(1);
-        REQUIRE(tank.getStats().shield == 0);
+        REQUIRE(tank.getStats().shield_ == 0);
     }
 
     SECTION("single hit, destroying, 1 more life")
     {
         Tank tank(TankType::PLAYER_TIER_1, point);
-        CHECK(tank.getStats().lives == 2);
+        CHECK(tank.getStats().lives_ == 2);
         tank.hit(1);
-        REQUIRE(tank.getStats().lives == 1);
+        REQUIRE(tank.getStats().lives_ == 1);
     }
 }
 
@@ -228,7 +228,7 @@ TEST_CASE("respawn", "[tank]")
     {
         Tank tank(TankType::PLAYER_TIER_3, point);
         tank.hit(3);
-        REQUIRE(tank.getStats().shield == 1);
+        REQUIRE(tank.getStats().shield_ == 1);
     }
 
     SECTION("check positions after respawn")
@@ -250,9 +250,9 @@ TEST_CASE("respawn", "[tank]")
     SECTION("check speed after respawn")
     {
         Tank tank(TankType::PLAYER_TIER_1, point);
-        const unsigned int speed{tank.getStats().speed};
+        const unsigned int speed{tank.getStats().speed_};
         tank.hit(3);
-        REQUIRE(tank.getStats().speed == speed);
+        REQUIRE(tank.getStats().speed_ == speed);
     }
 }
 
@@ -320,9 +320,9 @@ TEST_CASE("power-ups", "[tank]")
     SECTION("life-up")
     {
         Tank tank(TankType::PLAYER_TIER_4, point);
-        const unsigned int initialLives{tank.getStats().lives};
+        const unsigned int initialLives{tank.getStats().lives_};
         tank.applyPowerUp(ResourceType::LIFE_UP);
-        REQUIRE(tank.getStats().lives == initialLives + 1);
+        REQUIRE(tank.getStats().lives_ == initialLives + 1);
     }
 
     SECTION("tier-up basic tank")
@@ -343,9 +343,9 @@ TEST_CASE("power-ups", "[tank]")
     {
         Tank tank(TankType::PLAYER_TIER_1, point);
         tank.applyPowerUp(ResourceType::LIFE_UP);
-        const unsigned int initialLives{tank.getStats().lives};
+        const unsigned int initialLives{tank.getStats().lives_};
         tank.applyPowerUp(ResourceType::TIER_UP);
-        REQUIRE(tank.getStats().lives == initialLives);
+        REQUIRE(tank.getStats().lives_ == initialLives);
     }
 
     SECTION("tier-up keep speed new tier slower")
@@ -353,26 +353,26 @@ TEST_CASE("power-ups", "[tank]")
         Tank tank(TankType::PLAYER_TIER_2, point);
         tank.applyPowerUp(ResourceType::SPEED_UP);
         tank.applyPowerUp(ResourceType::SPEED_UP);
-        const unsigned int initialSpeed{tank.getStats().speed};
+        const unsigned int initialSpeed{tank.getStats().speed_};
         tank.applyPowerUp(ResourceType::TIER_UP);
-        REQUIRE(tank.getStats().speed == initialSpeed);
+        REQUIRE(tank.getStats().speed_ == initialSpeed);
     }
 
     SECTION("tier-up keep speed new tier faster")
     {
         Tank tank(TankType::PLAYER_TIER_2, point);
         tank.applyPowerUp(ResourceType::SPEED_UP);
-        const unsigned int initialSpeed{tank.getStats().speed};
+        const unsigned int initialSpeed{tank.getStats().speed_};
         tank.applyPowerUp(ResourceType::TIER_UP);
         tank.applyPowerUp(ResourceType::TIER_UP);
-        REQUIRE(tank.getStats().speed > initialSpeed);
+        REQUIRE(tank.getStats().speed_ > initialSpeed);
     }
 
     SECTION("speed-up")
     {
         Tank tank(TankType::PLAYER_TIER_1, point);
-        const unsigned int initialSpeed{tank.getStats().speed};
+        const unsigned int initialSpeed{tank.getStats().speed_};
         tank.applyPowerUp(ResourceType::SPEED_UP);
-        REQUIRE(tank.getStats().speed > initialSpeed);
+        REQUIRE(tank.getStats().speed_ > initialSpeed);
     }
 }