Root Sapling (a.k.a. Corrupted Mole)

src/badguy/root.cpp

@@ -19,8 +19,8 @@
 #include "audio/sound_manager.hpp"
 #include "math/random.hpp"
 #include "object/sprite_particle.hpp"
-#include "util/reader_mapping.hpp"
 #include "supertux/sector.hpp"
+#include "util/reader_mapping.hpp"
 
 static const float HATCH_TIME = 0.7f;
 static const float APPEAR_TIME = 0.5f;
@@ -29,6 +29,7 @@ static const float RETREAT_TIME = 1.f;
 Root::Root(const ReaderMapping& reader) :
   BadGuy(reader, "images/creatures/mole/corrupted/root.sprite" , LAYER_TILES-10),
   m_base_surface(nullptr),
+  m_timer(),
   m_state(STATE_HATCHING),
   m_delay(HATCH_TIME),
   m_maxheight(0.f),
@@ -41,8 +42,9 @@ Root::Root(const ReaderMapping& reader) :
 
 Root::Root(const Vector& pos, Direction dir, const std::string& sprite,
            float delay, bool play_sound) :
-  BadGuy(pos, dir, sprite, LAYER_TILES-10),
+  BadGuy(pos, dir, sprite, LAYER_TILES - 10),
   m_base_surface(nullptr),
+  m_timer(),
   m_state(STATE_HATCHING),
   m_delay(delay == -1 ? HATCH_TIME : delay),
   m_maxheight(0.f),
@@ -133,7 +135,7 @@ Root::initialize()
 }
 
 void
-Root::draw(DrawingContext &context)
+Root::draw(DrawingContext& context)
 {
   BadGuy::draw(context);
 
@@ -252,7 +254,7 @@ Root::active_update(float dt_sec)
 }
 
 HitResponse
-Root::collision_badguy(BadGuy &other, const CollisionHit &hit)
+Root::collision_badguy(BadGuy& other, const CollisionHit& hit)
 {
   if (other.get_group() == COLGROUP_MOVING && other.is_snipable())
   {

src/badguy/root.hpp

@@ -18,6 +18,7 @@
 #define HEADER_SUPERTUX_BADGUY_ROOT_HPP
 
 #include "badguy/badguy.hpp"
+
 #include "supertux/timer.hpp"
 
 class Root final : public BadGuy
@@ -28,9 +29,9 @@ class Root final : public BadGuy
        float delay = -1, bool play_sound = true);
 
   virtual void initialize() override;
-  virtual void draw(DrawingContext &context) override;
+  virtual void draw(DrawingContext& context) override;
   virtual void active_update(float dt_sec) override;
-  virtual HitResponse collision_badguy(BadGuy &other, const CollisionHit &hit) override;
+  virtual HitResponse collision_badguy(BadGuy& other, const CollisionHit& hit) override;
   virtual void kill_fall() override;
 
   static std::string class_name() { return "root"; }
@@ -40,21 +41,26 @@ class Root final : public BadGuy
 
   virtual bool is_flammable() const override { return false; }
   virtual bool is_freezable() const override { return false; }
-  virtual bool is_snipable () const override { return false; }
+  virtual bool is_snipable() const override { return false; }
 
   virtual std::vector<Direction> get_allowed_directions() const override;
 
 private:
-  enum State { STATE_HATCHING, STATE_APPEARING, STATE_RETREATING };
-
   void construct(float delay = -1, bool play_sound = true);
 
+  enum State { STATE_HATCHING, STATE_APPEARING, STATE_RETREATING };
+
+private:
   SurfacePtr m_base_surface;
   Timer m_timer;
   State m_state;
   float m_delay;
   float m_maxheight;
   bool m_play_sound;
+
+private:
+  Root(const Root&) = delete;
+  Root& operator=(const Root&) = delete;
 };
 
 #endif

src/badguy/root_sapling.cpp

@@ -27,12 +27,12 @@
 #include "supertux/sector.hpp"
 #include "util/reader_mapping.hpp"
 
-static const float ROOT_SAPLING_RANGE = 32.f*20;
+static const float ROOT_SAPLING_RANGE = 32.f * 20;
 static const float ROOT_SAPLING_SPAWN_TIME = 2.f;
 
 RootSapling::RootSapling(const ReaderMapping& reader) :
   BadGuy(reader, "images/creatures/mole/corrupted/root_sapling.sprite", Direction::UP,
-         LAYER_TILES-15, "images/creatures/mole/corrupted/core_glow/core_glow.sprite"),
+         LAYER_TILES - 15, "images/creatures/mole/corrupted/core_glow/core_glow.sprite"),
   m_root_timer(),
   m_dead(false)
 {
@@ -84,15 +84,15 @@ RootSapling::collision_squished(GameObject& object)
   set_colgroup_active(COLGROUP_DISABLED);
 
   auto player = dynamic_cast<Player*>(&object);
-  if (player) {
+  if (player)
     player->bounce(*this);
-  }
 
   run_dead_script();
   return true;
 }
 
-HitResponse RootSapling::collision_player(Player &player, const CollisionHit &hit)
+HitResponse
+RootSapling::collision_player(Player& player, const CollisionHit& hit)
 {
   if (m_dir != Direction::DOWN || !hit.bottom)
     return BadGuy::collision_player(player, hit);
@@ -158,9 +158,9 @@ RootSapling::summon_root()
     (*axis) = player->get_bbox().get_bottom() + 1;
 
     bool should_summon = false;
-    for (TileMap* map : Sector::get().get_solid_tilemaps())
+    for (TileMap* tilemap : Sector::get().get_solid_tilemaps())
     {
-      const Tile& tile = map->get_tile_at(pos);
+      const Tile& tile = tilemap->get_tile_at(pos);
       if (tile.is_solid())
       {
         should_summon = true;
@@ -177,23 +177,23 @@ RootSapling::summon_root()
     switch (m_dir)
     {
       case Direction::UP:
-        eye = {player->get_bbox().get_middle().x, player->get_bbox().get_bottom() + 1};
-        end = {eye.x, eye.y + ROOT_SAPLING_RANGE};
+        eye = { player->get_bbox().get_middle().x, player->get_bbox().get_bottom() + 1 };
+        end = { eye.x, eye.y + ROOT_SAPLING_RANGE };
         break;
 
       case Direction::DOWN:
-        eye = {player->get_bbox().get_middle().x, player->get_bbox().get_top() - 1};
-        end = {eye.x, eye.y - ROOT_SAPLING_RANGE};
+        eye = { player->get_bbox().get_middle().x, player->get_bbox().get_top() - 1 };
+        end = { eye.x, eye.y - ROOT_SAPLING_RANGE };
         break;
 
       case Direction::LEFT:
-        eye = {player->get_bbox().get_right() + 1, player->get_bbox().get_middle().y};
-        end = {eye.x + ROOT_SAPLING_RANGE, eye.y};
+        eye = { player->get_bbox().get_right() + 1, player->get_bbox().get_middle().y };
+        end = { eye.x + ROOT_SAPLING_RANGE, eye.y };
         break;
 
       case Direction::RIGHT:
-        eye = {player->get_bbox().get_left() - 1, player->get_bbox().get_middle().y};
-        end = {eye.x - ROOT_SAPLING_RANGE, eye.y};
+        eye = { player->get_bbox().get_left() - 1, player->get_bbox().get_middle().y };
+        end = { eye.x - ROOT_SAPLING_RANGE, eye.y };
         break;
 
       default: assert(false); break;
@@ -204,37 +204,33 @@ RootSapling::summon_root()
                            reverse_raycast(eye, end);
 
     auto tile_p = std::get_if<const Tile*>(&result.hit);
-    if (tile_p && !result.box.empty())
-    {
-      switch (m_dir)
-      {
-        case Direction::UP:
-        case Direction::DOWN:
-          if ((*tile_p)->is_unisolid())
-            return;
-          (*axis) = result.box.p1().y;
-          break;
-
-        case Direction::LEFT:
-        case Direction::RIGHT:
-          if ((*tile_p)->is_unisolid())
-            return;
-          (*axis) = result.box.p1().x;
-          break;
-
-        /*
-        case Direction::DOWN:
-        case Direction::RIGHT:
-          (*axis) = reverse_raycast(result.box);
-          break;
-        */
-
-        default: assert(false); break;
-      }
-    }
-    else
-    {
+    if (!tile_p || result.box.empty())
       return;
+
+    switch (m_dir)
+    {
+      case Direction::UP:
+      case Direction::DOWN:
+        if ((*tile_p)->is_unisolid())
+          return;
+        (*axis) = result.box.p1().y;
+        break;
+
+      case Direction::LEFT:
+      case Direction::RIGHT:
+        if ((*tile_p)->is_unisolid())
+          return;
+        (*axis) = result.box.p1().x;
+        break;
+
+      /*
+      case Direction::DOWN:
+      case Direction::RIGHT:
+        (*axis) = reverse_raycast(result.box);
+        break;
+      */
+
+      default: assert(false); break;
     }
   }
 
@@ -280,22 +276,22 @@ RootSapling::summon_root()
 bool
 RootSapling::should_summon_root(const Rectf& bbox)
 {
-  for (const auto& solids : Sector::get().get_solid_tilemaps()) {
+  for (const auto& solids : Sector::get().get_solid_tilemaps())
+  {
     if (solids->get_path())
-      // Do not support moving tilemaps. Not planned.
-      continue;
+      continue; // Do not support moving tilemaps. Not planned.
 
     // Test with all tiles in the root's hitbox
     const Rect test_tiles = solids->get_tiles_overlapping(bbox);
 
-    for (int x = test_tiles.left; x < test_tiles.right; ++x) {
-      for (int y = test_tiles.top; y < test_tiles.bottom; ++y) {
+    for (int x = test_tiles.left; x < test_tiles.right; ++x)
+    {
+      for (int y = test_tiles.top; y < test_tiles.bottom; ++y)
+      {
         const Tile& tile = solids->get_tile(x, y);
 
         if (!(tile.get_attributes() & Tile::SOLID))
-        {
           goto next_tilemap;
-        }
       }
     }
 

src/badguy/root_sapling.hpp

@@ -24,17 +24,17 @@
 class RootSapling final : public BadGuy
 {
 public:
-  RootSapling(const ReaderMapping& );
+  RootSapling(const ReaderMapping& reader);
 
   virtual void kill_fall() override;
-  virtual HitResponse collision_badguy(BadGuy&other, const CollisionHit&hit) override;
+  virtual HitResponse collision_badguy(BadGuy& other, const CollisionHit& hit) override;
   virtual bool collision_squished(GameObject& object) override;
-  virtual HitResponse collision_player(Player &player, const CollisionHit &hit) override;
+  virtual HitResponse collision_player(Player& player, const CollisionHit& hit) override;
   virtual void active_update(float) override;
 
   virtual bool is_flammable() const override { return false; }
   virtual bool is_freezable() const override { return false; }
-  virtual bool is_snipable () const override { return false; }
+  virtual bool is_snipable() const override { return false; }
 
   static std::string class_name() { return "root_sapling"; }
   virtual std::string get_class_name() const override { return class_name(); }
@@ -53,6 +53,7 @@ class RootSapling final : public BadGuy
   /** Fix raycasting down/right. More info in the implementation. */
   CollisionSystem::RaycastResult reverse_raycast(const Vector& line_start, const Vector& line_end);
 
+private:
   Timer m_root_timer;
   bool m_dead;
 

src/sprite/sprite.cpp

@@ -202,7 +202,8 @@ Sprite::get_height() const
   return static_cast<int>(m_action->surfaces[m_frameidx]->get_height());
 }
 
-const std::optional<std::vector<SurfacePtr>> Sprite::get_action_surfaces(const std::string& name) const
+const std::optional<std::vector<SurfacePtr>>
+Sprite::get_action_surfaces(const std::string& name) const
 {
   const SpriteData::Action* action = m_data.get_action(name);
   if (!action) return std::nullopt;

src/sprite/sprite.hpp

@@ -124,8 +124,7 @@ class Sprite final
   Blend get_blend() const;
 
   bool has_action (const std::string& name) const { return (m_data.get_action(name) != nullptr); }
-
-  std::size_t get_actions_count() { return m_data.actions.size(); }
+  size_t get_actions_count() const { return m_data.actions.size(); }
 
 private:
   void update();

src/supertux/direction.cpp

@@ -104,12 +104,18 @@ string_to_dir(const std::string& dir_str)
 Direction
 invert_dir(const Direction& dir)
 {
-  switch (dir) {
-    case Direction::RIGHT: return Direction::LEFT;
-    case Direction::LEFT: return Direction::RIGHT;
-    case Direction::DOWN: return Direction::UP;
-    case Direction::UP: return Direction::DOWN;
-    default: return Direction::NONE;
+  switch (dir)
+  {
+    case Direction::RIGHT:
+      return Direction::LEFT;
+    case Direction::LEFT:
+      return Direction::RIGHT;
+    case Direction::DOWN:
+      return Direction::UP;
+    case Direction::UP:
+      return Direction::DOWN;
+    default:
+      return Direction::NONE;
   }
 }