Optimize GameObjectIterator by using static_cast

`GameObjectIterator` is only initialized in `GameObjectRange`, where we only pass objects of the needed type index, thus we can safely `static_cast` them (granted that `T` inherits `GameObject`, otherwise a `dynamic_cast` would be needed to perform sidecasts).

src/supertux/game_object_iterator.hpp

@@ -22,7 +22,7 @@
 #include "game_object_manager.hpp"
 
 template<typename T>
-class GameObjectIterator
+class GameObjectIterator final
 {
 public:
   typedef std::vector<GameObject* >::const_iterator Iterator;
@@ -37,8 +37,10 @@ class GameObjectIterator
     {
       // A dynamic_cast is needed to perform sidecasts (a.k.a. crosscasts)
       // T may be one of multiple base classes of the object and need not inherit GameObject
-      m_object = dynamic_cast<T*>(*m_it);
-      assert(m_object);
+      if constexpr (std::is_base_of<GameObject, T>::value)
+        m_object = static_cast<T*>(*m_it);
+      else
+        m_object = dynamic_cast<T*>(*m_it);
     }
   }
 
@@ -47,8 +49,10 @@ class GameObjectIterator
     ++m_it;
     if (m_it != m_end)
     {
-      m_object = dynamic_cast<T*>(*m_it);
-      assert(m_object);
+      if constexpr (std::is_base_of<GameObject, T>::value)
+        m_object = static_cast<T*>(*m_it);
+      else
+        m_object = dynamic_cast<T*>(*m_it);
     }
     return *this;
   }
@@ -60,28 +64,30 @@ class GameObjectIterator
     return tmp;
   }
 
-  T* operator->() {
+  inline T* get() const { return m_object; }
+
+  inline T* operator->() {
     return m_object;
   }
 
-  const T* operator->() const {
+  inline const T* operator->() const {
     return m_object;
   }
 
-  T& operator*() const {
+  inline T& operator*() const {
     return *m_object;
   }
 
-  T& operator*() {
+  inline T& operator*() {
     return *m_object;
   }
 
-  bool operator==(const GameObjectIterator& other) const
+  inline bool operator==(const GameObjectIterator& other) const
   {
     return m_it == other.m_it;
   }
 
-  bool operator!=(const GameObjectIterator& other) const
+  inline bool operator!=(const GameObjectIterator& other) const
   {
     return !(*this == other);
   }
@@ -93,7 +99,7 @@ class GameObjectIterator
 };
 
 template<typename T>
-class GameObjectRange
+class GameObjectRange final
 {
 public:
   GameObjectRange(const GameObjectManager& manager) :

src/supertux/game_object_manager.cpp

@@ -310,11 +310,10 @@ GameObjectManager::update_tilemaps()
 {
   m_solid_tilemaps.clear();
   m_all_tilemaps.clear();
-  for (auto tilemap : get_objects_by_type_index(typeid(TileMap)))
+  for (auto& tm : get_objects_by_type<TileMap>())
   {
-    TileMap* tm = static_cast<TileMap*>(tilemap);
-    if (tm->is_solid()) m_solid_tilemaps.push_back(tm);
-    m_all_tilemaps.push_back(tm);
+    if (tm.is_solid()) m_solid_tilemaps.push_back(&tm);
+    m_all_tilemaps.push_back(&tm);
   }
 }
 

src/supertux/game_object_manager.hpp

@@ -244,12 +244,10 @@ class GameObjectManager : public ExposableClass
   int get_object_count(std::function<bool(const T&)> predicate = nullptr) const
   {
     int total = 0;
-    for (const auto& obj : get_objects_by_type_index(typeid(T))) {
-      auto object = static_cast<T*>(obj);
-      if (object && (predicate == nullptr || predicate(*object)))
-      {
+    for (auto& obj : get_objects_by_type<T>())
+    {
+      if (predicate == nullptr || predicate(obj))
         total += 1;
-      }
     }
     return total;
   }

src/supertux/level.cpp

@@ -307,8 +307,8 @@ Level::get_players() const
 {
   std::vector<Player*> players;
   for (const auto& sector : m_sectors)
-    for (const auto& player : sector->get_objects_by_type_index(typeid(Player)))
-      players.push_back(static_cast<Player*>(player));
+    for (auto& player : sector->get_objects_by_type<Player>())
+      players.push_back(&player);
 
   return players;
 }

src/supertux/sector.cpp

@@ -241,8 +241,8 @@ Sector::activate(const Vector& player_pos)
 
   // two-player hack: move other players to main player's position
   // Maybe specify 2 spawnpoints in the level?
-  for (auto player_ptr : get_objects_by_type_index(typeid(Player))) {
-    Player& player = *static_cast<Player*>(player_ptr);
+  const auto players = get_objects_by_type<Player>();
+  for (auto& player : players) {
     // spawn smalltux below spawnpoint
     if (!player.is_big()) {
       player.set_pos(player_pos + Vector(0,32));
@@ -259,9 +259,9 @@ Sector::activate(const Vector& player_pos)
   }
 
   //FIXME: This is a really dirty workaround for this strange camera jump
-  if (get_players().size() > 0)
+  if (players.begin() != players.end())
   {
-    Player& player = *(get_players()[0]);
+    Player& player = *players.begin();
     Camera& camera = get_camera();
     player.set_pos(player.get_pos()+Vector(-32, 0));
     camera.reset(player.get_pos());
@@ -607,8 +607,8 @@ Sector::free_line_of_sight(const Vector& line_start, const Vector& line_end, boo
 bool
 Sector::can_see_player(const Vector& eye) const
 {
-  for (auto player_ptr : get_objects_by_type_index(typeid(Player))) {
-    Player& player = *static_cast<Player*>(player_ptr);
+  for (auto& player : get_objects_by_type<Player>())
+  {
     // test for free line of sight to any of all four corners and the middle of the player's bounding box
     if (free_line_of_sight(eye, player.get_bbox().p1(), false, &player)) return true;
     if (free_line_of_sight(eye, Vector(player.get_bbox().get_right(), player.get_bbox().get_top()), false, &player)) return true;