refactor(Core/Misc): enforce east-const style and add codestyle check (#26492)

Co-authored-by: Ludwig <sudlud@users.noreply.github.com>

src/common/Collision/BoundingIntervalHierarchy.h

@@ -78,7 +78,7 @@ private:
 public:
     BIH() { init_empty(); }
     template< class BoundsFunc, class PrimArray >
-    void build(const PrimArray& primitives, BoundsFunc& GetBounds, uint32 leafSize = 3, bool printStats = false)
+    void build(PrimArray const& primitives, BoundsFunc& GetBounds, uint32 leafSize = 3, bool printStats = false)
     {
         if (primitives.size() == 0)
         {
@@ -120,7 +120,7 @@ public:
     G3D::AABox const& bound() const { return bounds; }
 
     template<typename RayCallback>
-    void intersectRay(const G3D::Ray& r, RayCallback& intersectCallback, float& maxDist, bool stopAtFirstHit) const
+    void intersectRay(G3D::Ray const& r, RayCallback& intersectCallback, float& maxDist, bool stopAtFirstHit) const
     {
         float intervalMin = -1.f;
         float intervalMax = -1.f;
@@ -283,7 +283,7 @@ public:
     }
 
     template<typename IsectCallback>
-    void intersectPoint(const G3D::Vector3& p, IsectCallback& intersectCallback) const
+    void intersectPoint(G3D::Vector3 const& p, IsectCallback& intersectCallback) const
     {
         if (!bounds.contains(p))
         {

src/common/Collision/BoundingIntervalHierarchyWrapper.h

@@ -29,20 +29,20 @@ class BIHWrap
     template<class RayCallback>
     struct MDLCallback
     {
-        const T* const* objects;
+        T const* const* objects;
         RayCallback& _callback;
         uint32 objects_size;
 
-        MDLCallback(RayCallback& callback, const T* const* objects_array, uint32 objects_size ) : objects(objects_array), _callback(callback), objects_size(objects_size) { }
+        MDLCallback(RayCallback& callback, T const* const* objects_array, uint32 objects_size ) : objects(objects_array), _callback(callback), objects_size(objects_size) { }
 
         /// Intersect ray
-        bool operator() (const G3D::Ray& ray, uint32 idx, float& maxDist, bool stopAtFirstHit)
+        bool operator() (G3D::Ray const& ray, uint32 idx, float& maxDist, bool stopAtFirstHit)
         {
             if (idx >= objects_size)
             {
                 return false;
             }
-            if (const T* obj = objects[idx])
+            if (T const* obj = objects[idx])
             {
                 return _callback(ray, *obj, maxDist, stopAtFirstHit);
             }
@@ -50,41 +50,41 @@ class BIHWrap
         }
 
         /// Intersect point
-        void operator() (const G3D::Vector3& p, uint32 idx)
+        void operator() (G3D::Vector3 const& p, uint32 idx)
         {
             if (idx >= objects_size)
             {
                 return;
             }
-            if (const T* obj = objects[idx])
+            if (T const* obj = objects[idx])
             {
                 _callback(p, *obj);
             }
         }
     };
 
-    typedef G3D::Array<const T*> ObjArray;
+    typedef G3D::Array<T const*> ObjArray;
 
     BIH m_tree;
     ObjArray m_objects;
-    G3D::Table<const T*, uint32> m_obj2Idx;
-    G3D::Set<const T*> m_objects_to_push;
+    G3D::Table<T const*, uint32> m_obj2Idx;
+    G3D::Set<T const*> m_objects_to_push;
     int unbalanced_times;
 
 public:
     BIHWrap() : unbalanced_times(0) { }
 
-    void insert(const T& obj)
+    void insert(T const& obj)
     {
         ++unbalanced_times;
         m_objects_to_push.insert(&obj);
     }
 
-    void remove(const T& obj)
+    void remove(T const& obj)
     {
         ++unbalanced_times;
         uint32 Idx = 0;
-        const T* temp;
+        T const* temp;
         if (m_obj2Idx.getRemove(&obj, temp, Idx))
         {
             m_objects[Idx] = nullptr;
@@ -112,7 +112,7 @@ public:
     }
 
     template<typename RayCallback>
-    void intersectRay(const G3D::Ray& ray, RayCallback& intersectCallback, float& maxDist, bool stopAtFirstHit)
+    void intersectRay(G3D::Ray const& ray, RayCallback& intersectCallback, float& maxDist, bool stopAtFirstHit)
     {
         balance();
         MDLCallback<RayCallback> temp_cb(intersectCallback, m_objects.getCArray(), m_objects.size());
@@ -120,7 +120,7 @@ public:
     }
 
     template<typename IsectCallback>
-    void intersectPoint(const G3D::Vector3& point, IsectCallback& intersectCallback)
+    void intersectPoint(G3D::Vector3 const& point, IsectCallback& intersectCallback)
     {
         balance();
         MDLCallback<IsectCallback> callback(intersectCallback, m_objects.getCArray(), m_objects.size());

src/common/Collision/DynamicTree.cpp

@@ -40,18 +40,18 @@ namespace
 
 template<> struct HashTrait< GameObjectModel>
 {
-    static std::size_t hashCode(const GameObjectModel& g) { return (size_t)(void*)&g; }
+    static std::size_t hashCode(GameObjectModel const& g) { return (size_t)(void*)&g; }
 };
 
 template<> struct PositionTrait< GameObjectModel>
 {
-    static void GetPosition(const GameObjectModel& g, G3D::Vector3& p) { p = g.GetPosition(); }
+    static void GetPosition(GameObjectModel const& g, G3D::Vector3& p) { p = g.GetPosition(); }
 };
 
 template<> struct BoundsTrait< GameObjectModel>
 {
-    static void GetBounds(const GameObjectModel& g, G3D::AABox& out) { out = g.GetBounds();}
-    static void GetBounds2(const GameObjectModel* g, G3D::AABox& out) { out = g->GetBounds();}
+    static void GetBounds(GameObjectModel const& g, G3D::AABox& out) { out = g.GetBounds();}
+    static void GetBounds2(GameObjectModel const* g, G3D::AABox& out) { out = g->GetBounds();}
 };
 
 typedef RegularGrid2D<GameObjectModel, BIHWrap<GameObjectModel>> ParentTree;
@@ -67,13 +67,13 @@ struct DynTreeImpl : public ParentTree
     {
     }
 
-    void insert(const Model& mdl)
+    void insert(Model const& mdl)
     {
         base::insert(mdl);
         ++unbalanced_times;
     }
 
-    void remove(const Model& mdl)
+    void remove(Model const& mdl)
     {
         base::remove(mdl);
         ++unbalanced_times;
@@ -114,17 +114,17 @@ DynamicMapTree::~DynamicMapTree()
     delete impl;
 }
 
-void DynamicMapTree::insert(const GameObjectModel& mdl)
+void DynamicMapTree::insert(GameObjectModel const& mdl)
 {
     impl->insert(mdl);
 }
 
-void DynamicMapTree::remove(const GameObjectModel& mdl)
+void DynamicMapTree::remove(GameObjectModel const& mdl)
 {
     impl->remove(mdl);
 }
 
-bool DynamicMapTree::contains(const GameObjectModel& mdl) const
+bool DynamicMapTree::contains(GameObjectModel const& mdl) const
 {
     return impl->contains(mdl);
 }
@@ -149,7 +149,7 @@ struct DynamicTreeIntersectionCallback
     DynamicTreeIntersectionCallback(uint32 phasemask, VMAP::ModelIgnoreFlags ignoreFlags) :
         _didHit(false), _phaseMask(phasemask), _ignoreFlags(ignoreFlags) { }
 
-    bool operator()(const G3D::Ray& r, const GameObjectModel& obj, float& distance, bool stopAtFirstHit)
+    bool operator()(G3D::Ray const& r, GameObjectModel const& obj, float& distance, bool stopAtFirstHit)
     {
         bool result = obj.intersectRay(r, distance, stopAtFirstHit, _phaseMask, _ignoreFlags);
         if (result)
@@ -196,7 +196,7 @@ private:
     GameObjectModel const* _hitModel;
 };
 
-bool DynamicMapTree::GetIntersectionTime(const uint32 phasemask, const G3D::Ray& ray, const G3D::Vector3& endPos, float& maxDist) const
+bool DynamicMapTree::GetIntersectionTime(const uint32 phasemask, G3D::Ray const& ray, G3D::Vector3 const& endPos, float& maxDist) const
 {
     float distance = maxDist;
     DynamicTreeIntersectionCallback callback(phasemask, VMAP::ModelIgnoreFlags::Nothing);
@@ -208,8 +208,8 @@ bool DynamicMapTree::GetIntersectionTime(const uint32 phasemask, const G3D::Ray&
     return callback.didHit();
 }
 
-bool DynamicMapTree::GetObjectHitPos(const uint32 phasemask, const G3D::Vector3& startPos,
-                                     const G3D::Vector3& endPos, G3D::Vector3& resultHit,
+bool DynamicMapTree::GetObjectHitPos(const uint32 phasemask, G3D::Vector3 const& startPos,
+                                     G3D::Vector3 const& endPos, G3D::Vector3& resultHit,
                                      float modifyDist) const
 {
     bool result = false;

src/common/Collision/DynamicTree.h

@@ -46,19 +46,19 @@ public:
 
     [[nodiscard]] bool isInLineOfSight(float x1, float y1, float z1, float x2, float y2, float z2, uint32 phasemask, VMAP::ModelIgnoreFlags ignoreFlags) const;
 
-    bool GetIntersectionTime(uint32 phasemask, const G3D::Ray& ray, const G3D::Vector3& endPos, float& maxDist) const;
+    bool GetIntersectionTime(uint32 phasemask, G3D::Ray const& ray, G3D::Vector3 const& endPos, float& maxDist) const;
 
     bool GetAreaAndLiquidData(float x, float y, float z, uint32 phasemask, Optional<uint8> reqLiquidType, VMAP::AreaAndLiquidData& data) const;
 
-    bool GetObjectHitPos(uint32 phasemask, const G3D::Vector3& pPos1,
-                         const G3D::Vector3& pPos2, G3D::Vector3& pResultHitPos,
+    bool GetObjectHitPos(uint32 phasemask, G3D::Vector3 const& pPos1,
+                         G3D::Vector3 const& pPos2, G3D::Vector3& pResultHitPos,
                          float pModifyDist) const;
 
     [[nodiscard]] float getHeight(float x, float y, float z, float maxSearchDist, uint32 phasemask) const;
 
-    void insert(const GameObjectModel&);
-    void remove(const GameObjectModel&);
-    [[nodiscard]] bool contains(const GameObjectModel&) const;
+    void insert(GameObjectModel const&);
+    void remove(GameObjectModel const&);
+    [[nodiscard]] bool contains(GameObjectModel const&) const;
     [[nodiscard]] int size() const;
 
     void balance();

src/common/Collision/Management/IVMapMgr.h

@@ -90,7 +90,7 @@ namespace VMAP
 
         virtual ~IVMapMgr() = default;
 
-        virtual LoadResult existsMap(const char* pBasePath, unsigned int pMapId, int x, int y) = 0;
+        virtual LoadResult existsMap(char const* pBasePath, unsigned int pMapId, int x, int y) = 0;
 
         /**
         send debug commands

src/common/Collision/Management/VMapMgr2.cpp

@@ -59,7 +59,7 @@ namespace VMAP
         return fname.str();
     }
 
-    LoadResult VMapMgr2::existsMap(const char* basePath, unsigned int mapId, int x, int y)
+    LoadResult VMapMgr2::existsMap(char const* basePath, unsigned int mapId, int x, int y)
     {
         return StaticMapTree::CanLoadMap(std::string(basePath), mapId, x, y);
     }

src/common/Collision/Management/VMapMgr2.h

@@ -72,7 +72,7 @@ namespace VMAP
         {
             return getMapFileName(mapId);
         }
-        LoadResult existsMap(const char* basePath, unsigned int mapId, int x, int y) override;
+        LoadResult existsMap(char const* basePath, unsigned int mapId, int x, int y) override;
 
         typedef uint32(*GetLiquidFlagsFn)(uint32 liquidType);
         GetLiquidFlagsFn GetLiquidFlagsPtr;

src/common/Collision/Maps/MapDefines.h

@@ -45,7 +45,7 @@ struct MmapTileRecastConfig
     float cellSizeVertical;
     float maxSimplificationError;
 
-    bool operator==(const MmapTileRecastConfig& b) const {
+    bool operator==(MmapTileRecastConfig const& b) const {
         return walkableSlopeAngle == b.walkableSlopeAngle &&
                walkableRadius == b.walkableRadius &&
                walkableHeight == b.walkableHeight &&

src/common/Collision/Maps/MapTree.cpp

@@ -36,7 +36,7 @@ namespace VMAP
     {
     public:
         MapRayCallback(ModelInstance* val, ModelIgnoreFlags ignoreFlags): prims(val), flags(ignoreFlags), hit(false) { }
-        bool operator()(const G3D::Ray& ray, uint32 entry, float& distance, bool StopAtFirstHit)
+        bool operator()(G3D::Ray const& ray, uint32 entry, float& distance, bool StopAtFirstHit)
         {
             bool result = prims[entry].intersectRay(ray, distance, StopAtFirstHit, flags);
             if (result)
@@ -56,7 +56,7 @@ namespace VMAP
     {
     public:
         LocationInfoCallback(ModelInstance* val, LocationInfo& info): prims(val), locInfo(info), result(false) {}
-        void operator()(const Vector3& point, uint32 entry)
+        void operator()(Vector3 const& point, uint32 entry)
         {
 #if defined(VMAP_DEBUG)
             LOG_DEBUG("maps", "LocationInfoCallback: trying to intersect '{}'", prims[entry].name);
@@ -84,14 +84,14 @@ namespace VMAP
         return tilefilename.str();
     }
 
-    bool StaticMapTree::GetLocationInfo(const Vector3& pos, LocationInfo& info) const
+    bool StaticMapTree::GetLocationInfo(Vector3 const& pos, LocationInfo& info) const
     {
         LocationInfoCallback intersectionCallBack(iTreeValues, info);
         iTree.intersectPoint(pos, intersectionCallBack);
         return intersectionCallBack.result;
     }
 
-    StaticMapTree::StaticMapTree(uint32 mapID, const std::string& basePath)
+    StaticMapTree::StaticMapTree(uint32 mapID, std::string const& basePath)
         : iMapID(mapID), iIsTiled(false), iTreeValues(0), iBasePath(basePath)
     {
         if (iBasePath.length() > 0 && iBasePath[iBasePath.length() - 1] != '/' && iBasePath[iBasePath.length() - 1] != '\\')
@@ -113,7 +113,7 @@ namespace VMAP
     Else, pMaxDist is not modified and returns false;
     */
 
-    bool StaticMapTree::GetIntersectionTime(const G3D::Ray& pRay, float& pMaxDist, bool StopAtFirstHit, ModelIgnoreFlags ignoreFlags) const
+    bool StaticMapTree::GetIntersectionTime(G3D::Ray const& pRay, float& pMaxDist, bool StopAtFirstHit, ModelIgnoreFlags ignoreFlags) const
     {
         float distance = pMaxDist;
         MapRayCallback intersectionCallBack(iTreeValues, ignoreFlags);
@@ -126,7 +126,7 @@ namespace VMAP
     }
     //=========================================================
 
-    bool StaticMapTree::isInLineOfSight(const Vector3& pos1, const Vector3& pos2, ModelIgnoreFlags ignoreFlags) const
+    bool StaticMapTree::isInLineOfSight(Vector3 const& pos1, Vector3 const& pos2, ModelIgnoreFlags ignoreFlags) const
     {
         float maxDist = (pos2 - pos1).magnitude();
         // return false if distance is over max float, in case of cheater teleporting to the end of the universe
@@ -153,7 +153,7 @@ namespace VMAP
     Return the hit pos or the original dest pos
     */
 
-    bool StaticMapTree::GetObjectHitPos(const Vector3& pPos1, const Vector3& pPos2, Vector3& pResultHitPos, float pModifyDist) const
+    bool StaticMapTree::GetObjectHitPos(Vector3 const& pPos1, Vector3 const& pPos2, Vector3& pResultHitPos, float pModifyDist) const
     {
         bool result = false;
         float maxDist = (pPos2 - pPos1).magnitude();
@@ -198,7 +198,7 @@ namespace VMAP
 
     //=========================================================
 
-    float StaticMapTree::getHeight(const Vector3& pPos, float maxSearchDist) const
+    float StaticMapTree::getHeight(Vector3 const& pPos, float maxSearchDist) const
     {
         float height = G3D::finf();
         Vector3 dir = Vector3(0, 0, -1);
@@ -213,7 +213,7 @@ namespace VMAP
 
     //=========================================================
 
-    LoadResult StaticMapTree::CanLoadMap(const std::string& vmapPath, uint32 mapID, uint32 tileX, uint32 tileY)
+    LoadResult StaticMapTree::CanLoadMap(std::string const& vmapPath, uint32 mapID, uint32 tileX, uint32 tileY)
     {
         std::string basePath = vmapPath;
         if (basePath.length() > 0 && basePath[basePath.length() - 1] != '/' && basePath[basePath.length() - 1] != '\\')
@@ -260,7 +260,7 @@ namespace VMAP
 
     //=========================================================
 
-    bool StaticMapTree::InitMap(const std::string& fname)
+    bool StaticMapTree::InitMap(std::string const& fname)
     {
         //VMAP_DEBUG_LOG(LOG_FILTER_MAPS, "StaticMapTree::InitMap() : initializing StaticMapTree '{}'", fname);
         bool success = false;

src/common/Collision/Maps/MapTree.h

@@ -32,15 +32,15 @@ namespace VMAP
 
     struct GroupLocationInfo
     {
-        const GroupModel* hitModel = nullptr;
+        GroupModel const* hitModel = nullptr;
         int32 rootId = -1;
     };
 
     struct LocationInfo
     {
         LocationInfo():  ground_Z(-G3D::inf()) { }
-        const ModelInstance* hitInstance{nullptr};
-        const GroupModel* hitModel{nullptr};
+        ModelInstance const* hitInstance{nullptr};
+        GroupModel const* hitModel{nullptr};
         float ground_Z;
         int32 rootId = -1;
     };
@@ -63,23 +63,23 @@ namespace VMAP
         std::string iBasePath;
 
     private:
-        bool GetIntersectionTime(const G3D::Ray& pRay, float& pMaxDist, bool StopAtFirstHit, ModelIgnoreFlags ignoreFlags) const;
+        bool GetIntersectionTime(G3D::Ray const& pRay, float& pMaxDist, bool StopAtFirstHit, ModelIgnoreFlags ignoreFlags) const;
         //bool containsLoadedMapTile(unsigned int pTileIdent) const { return(iLoadedMapTiles.containsKey(pTileIdent)); }
     public:
         static std::string getTileFileName(uint32 mapID, uint32 tileX, uint32 tileY);
         static uint32 packTileID(uint32 tileX, uint32 tileY) { return tileX << 16 | tileY; }
         static void unpackTileID(uint32 ID, uint32& tileX, uint32& tileY) { tileX = ID >> 16; tileY = ID & 0xFF; }
-        static LoadResult CanLoadMap(const std::string& basePath, uint32 mapID, uint32 tileX, uint32 tileY);
+        static LoadResult CanLoadMap(std::string const& basePath, uint32 mapID, uint32 tileX, uint32 tileY);
 
-        StaticMapTree(uint32 mapID, const std::string& basePath);
+        StaticMapTree(uint32 mapID, std::string const& basePath);
         ~StaticMapTree();
 
-        [[nodiscard]] bool isInLineOfSight(const G3D::Vector3& pos1, const G3D::Vector3& pos2, ModelIgnoreFlags ignoreFlags) const;
-        bool GetObjectHitPos(const G3D::Vector3& pos1, const G3D::Vector3& pos2, G3D::Vector3& pResultHitPos, float pModifyDist) const;
-        [[nodiscard]] float getHeight(const G3D::Vector3& pPos, float maxSearchDist) const;
-        bool GetLocationInfo(const G3D::Vector3& pos, LocationInfo& info) const;
+        [[nodiscard]] bool isInLineOfSight(G3D::Vector3 const& pos1, G3D::Vector3 const& pos2, ModelIgnoreFlags ignoreFlags) const;
+        bool GetObjectHitPos(G3D::Vector3 const& pos1, G3D::Vector3 const& pos2, G3D::Vector3& pResultHitPos, float pModifyDist) const;
+        [[nodiscard]] float getHeight(G3D::Vector3 const& pPos, float maxSearchDist) const;
+        bool GetLocationInfo(G3D::Vector3 const& pos, LocationInfo& info) const;
 
-        bool InitMap(const std::string& fname);
+        bool InitMap(std::string const& fname);
         void UnloadMap();
         bool LoadMapTile(uint32 tileX, uint32 tileY);
         void UnloadMapTile(uint32 tileX, uint32 tileY);

src/common/Collision/Maps/TileAssembler.cpp

@@ -32,18 +32,18 @@ using std::pair;
 
 template<> struct BoundsTrait<VMAP::ModelSpawn*>
 {
-    static void GetBounds(const VMAP::ModelSpawn* const& obj, G3D::AABox& out) { out = obj->GetBounds(); }
+    static void GetBounds(VMAP::ModelSpawn const* const& obj, G3D::AABox& out) { out = obj->GetBounds(); }
 };
 
 namespace VMAP
 {
-    bool readChunk(FILE* rf, char* dest, const char* compare, uint32 len)
+    bool readChunk(FILE* rf, char* dest, char const* compare, uint32 len)
     {
         if (fread(dest, sizeof(char), len, rf) != len) { return false; }
         return memcmp(dest, compare, len) == 0;
     }
 
-    Vector3 ModelPosition::transform(const Vector3& pIn) const
+    Vector3 ModelPosition::transform(Vector3 const& pIn) const
     {
         Vector3 out = pIn * iScale;
         out = iRotation * out;
@@ -52,7 +52,7 @@ namespace VMAP
 
     //=================================================================
 
-    TileAssembler::TileAssembler(const std::string& pSrcDirName, const std::string& pDestDirName)
+    TileAssembler::TileAssembler(std::string const& pSrcDirName, std::string const& pDestDirName)
         : iDestDir(pDestDirName), iSrcDir(pSrcDirName)
     {
         boost::filesystem::create_directory(iDestDir);
@@ -156,7 +156,7 @@ namespace VMAP
             TileMap::iterator tile;
             for (tile = tileEntries.begin(); tile != tileEntries.end(); ++tile)
             {
-                const ModelSpawn& spawn = map_iter->second->UniqueEntries[tile->second];
+                ModelSpawn const& spawn = map_iter->second->UniqueEntries[tile->second];
                 if (spawn.flags & MOD_WORLDSPAWN) // WDT spawn, saved as tile 65/65 currently...
                 {
                     continue;
@@ -181,7 +181,7 @@ namespace VMAP
                         {
                             ++tile;
                         }
-                        const ModelSpawn& spawn2 = map_iter->second->UniqueEntries[tile->second];
+                        ModelSpawn const& spawn2 = map_iter->second->UniqueEntries[tile->second];
                         success = success && ModelSpawn::writeToFile(tilefile, spawn2);
                         // MapTree nodes to update when loading tile:
                         std::map<uint32, uint32>::iterator nIdx = modelNodeIdx.find(spawn2.ID);
@@ -331,7 +331,7 @@ namespace VMAP
     };
 #pragma pack(pop)
     //=================================================================
-    bool TileAssembler::convertRawFile(const std::string& pModelFilename)
+    bool TileAssembler::convertRawFile(std::string const& pModelFilename)
     {
         bool success = true;
         std::string filename = iSrcDir;
@@ -566,7 +566,7 @@ namespace VMAP
         delete liquid;
     }
 
-    bool WorldModel_Raw::Read(const char* path)
+    bool WorldModel_Raw::Read(char const* path)
     {
         FILE* rf = fopen(path, "rb");
         if (!rf)

src/common/Collision/Maps/TileAssembler.h

@@ -47,8 +47,8 @@ namespace VMAP
         {
             iRotation = G3D::Matrix3::fromEulerAnglesZYX(G3D::pif() * iDir.y / 180.f, G3D::pif() * iDir.x / 180.f, G3D::pif() * iDir.z / 180.f);
         }
-        [[nodiscard]] G3D::Vector3 transform(const G3D::Vector3& pIn) const;
-        void moveToBasePos(const G3D::Vector3& pBasePos) { iPos -= pBasePos; }
+        [[nodiscard]] G3D::Vector3 transform(G3D::Vector3 const& pIn) const;
+        void moveToBasePos(G3D::Vector3 const& pBasePos) { iPos -= pBasePos; }
     };
 
     typedef std::map<uint32, ModelSpawn> UniqueEntryMap;
@@ -86,7 +86,7 @@ namespace VMAP
         uint32 RootWMOID;
         std::vector<GroupModel_Raw> groupsArray;
 
-        bool Read(const char* path);
+        bool Read(char const* path);
     };
 
     class TileAssembler
@@ -99,7 +99,7 @@ namespace VMAP
         std::set<std::string> spawnedModelFiles;
 
     public:
-        TileAssembler(const std::string& pSrcDirName, const std::string& pDestDirName);
+        TileAssembler(std::string const& pSrcDirName, std::string const& pDestDirName);
         virtual ~TileAssembler();
 
         bool convertWorld2();
@@ -107,7 +107,7 @@ namespace VMAP
         bool calculateTransformedBound(ModelSpawn& spawn);
         void exportGameobjectModels();
 
-        bool convertRawFile(const std::string& pModelFilename);
+        bool convertRawFile(std::string const& pModelFilename);
     };
 
 }                                                           // VMAP

src/common/Collision/Models/GameObjectModel.cpp

@@ -170,7 +170,7 @@ GameObjectModel* GameObjectModel::Create(std::unique_ptr<GameObjectModelOwnerBas
     return mdl;
 }
 
-bool GameObjectModel::intersectRay(const G3D::Ray& ray, float& MaxDist, bool StopAtFirstHit, uint32 ph_mask, VMAP::ModelIgnoreFlags ignoreFlags) const
+bool GameObjectModel::intersectRay(G3D::Ray const& ray, float& MaxDist, bool StopAtFirstHit, uint32 ph_mask, VMAP::ModelIgnoreFlags ignoreFlags) const
 {
     if (!(phasemask & ph_mask) || !owner->IsSpawned())
     {

src/common/Collision/Models/GameObjectModel.h

@@ -57,11 +57,11 @@ class GameObjectModel
 public:
     std::string name;
 
-    [[nodiscard]] const G3D::AABox& GetBounds() const { return iBound; }
+    [[nodiscard]] G3D::AABox const& GetBounds() const { return iBound; }
 
     ~GameObjectModel() = default;
 
-    [[nodiscard]] const G3D::Vector3& GetPosition() const { return iPos; }
+    [[nodiscard]] G3D::Vector3 const& GetPosition() const { return iPos; }
 
     /** Enables\disables collision. */
     void disable() { phasemask = 0; }
@@ -70,7 +70,7 @@ public:
     [[nodiscard]] bool isEnabled() const { return phasemask != 0; }
     [[nodiscard]] bool IsMapObject() const { return isWmo; }
 
-    bool intersectRay(const G3D::Ray& Ray, float& MaxDist, bool StopAtFirstHit, uint32 ph_mask, VMAP::ModelIgnoreFlags ignoreFlags) const;
+    bool intersectRay(G3D::Ray const& Ray, float& MaxDist, bool StopAtFirstHit, uint32 ph_mask, VMAP::ModelIgnoreFlags ignoreFlags) const;
     bool GetLocationInfo(G3D::Vector3 const& point, VMAP::LocationInfo& info, uint32 ph_mask) const;
     bool GetLiquidLevel(G3D::Vector3 const& point, VMAP::LocationInfo& info, float& liqHeight) const;
 

src/common/Collision/Models/ModelInstance.cpp

@@ -24,13 +24,13 @@ using G3D::Ray;
 
 namespace VMAP
 {
-    ModelInstance::ModelInstance(const ModelSpawn& spawn, std::shared_ptr<WorldModel> model): ModelSpawn(spawn), iModel(model)
+    ModelInstance::ModelInstance(ModelSpawn const& spawn, std::shared_ptr<WorldModel> model): ModelSpawn(spawn), iModel(model)
     {
         iInvRot = G3D::Matrix3::fromEulerAnglesZYX(G3D::pi() * iRot.y / 180.f, G3D::pi() * iRot.x / 180.f, G3D::pi() * iRot.z / 180.f).inverse();
         iInvScale = 1.f / iScale;
     }
 
-    bool ModelInstance::intersectRay(const G3D::Ray& pRay, float& pMaxDist, bool StopAtFirstHit, ModelIgnoreFlags ignoreFlags) const
+    bool ModelInstance::intersectRay(G3D::Ray const& pRay, float& pMaxDist, bool StopAtFirstHit, ModelIgnoreFlags ignoreFlags) const
     {
         if (!iModel)
         {
@@ -63,7 +63,7 @@ namespace VMAP
         return hit;
     }
 
-    bool ModelInstance::GetLocationInfo(const G3D::Vector3& p, LocationInfo& info) const
+    bool ModelInstance::GetLocationInfo(G3D::Vector3 const& p, LocationInfo& info) const
     {
         if (!iModel)
         {
@@ -107,7 +107,7 @@ namespace VMAP
         return false;
     }
 
-    bool ModelInstance::GetLiquidLevel(const G3D::Vector3& p, LocationInfo& info, float& liqHeight) const
+    bool ModelInstance::GetLiquidLevel(G3D::Vector3 const& p, LocationInfo& info, float& liqHeight) const
     {
         // child bounds are defined in object space:
         Vector3 pModel = iInvRot * (p - iPos) * iInvScale;
@@ -170,7 +170,7 @@ namespace VMAP
         return true;
     }
 
-    bool ModelSpawn::writeToFile(FILE* wf, const ModelSpawn& spawn)
+    bool ModelSpawn::writeToFile(FILE* wf, ModelSpawn const& spawn)
     {
         uint32 check = 0;
         check += fwrite(&spawn.flags, sizeof(uint32), 1, wf);

src/common/Collision/Models/ModelInstance.h

@@ -51,23 +51,23 @@ namespace VMAP
         float iScale;
         G3D::AABox iBound;
         std::string name;
-        bool operator==(const ModelSpawn& other) const { return ID == other.ID; }
+        bool operator==(ModelSpawn const& other) const { return ID == other.ID; }
         //uint32 hashCode() const { return ID; }
         // temp?
-        [[nodiscard]] const G3D::AABox& GetBounds() const { return iBound; }
+        [[nodiscard]] G3D::AABox const& GetBounds() const { return iBound; }
 
         static bool readFromFile(FILE* rf, ModelSpawn& spawn);
-        static bool writeToFile(FILE* rw, const ModelSpawn& spawn);
+        static bool writeToFile(FILE* rw, ModelSpawn const& spawn);
     };
 
     class ModelInstance: public ModelSpawn
     {
     public:
         ModelInstance() { }
-        ModelInstance(const ModelSpawn& spawn, std::shared_ptr<WorldModel> model);
-        bool intersectRay(const G3D::Ray& pRay, float& pMaxDist, bool StopAtFirstHit, ModelIgnoreFlags ignoreFlags) const;
-        bool GetLocationInfo(const G3D::Vector3& p, LocationInfo& info) const;
-        bool GetLiquidLevel(const G3D::Vector3& p, LocationInfo& info, float& liqHeight) const;
+        ModelInstance(ModelSpawn const& spawn, std::shared_ptr<WorldModel> model);
+        bool intersectRay(G3D::Ray const& pRay, float& pMaxDist, bool StopAtFirstHit, ModelIgnoreFlags ignoreFlags) const;
+        bool GetLocationInfo(G3D::Vector3 const& p, LocationInfo& info) const;
+        bool GetLiquidLevel(G3D::Vector3 const& p, LocationInfo& info, float& liqHeight) const;
         WorldModel* getWorldModel() { return iModel.get(); }
     protected:
         G3D::Matrix3 iInvRot;

src/common/Collision/Models/WorldModel.cpp

@@ -26,12 +26,12 @@ using G3D::Vector3;
 
 template<> struct BoundsTrait<VMAP::GroupModel>
 {
-    static void GetBounds(const VMAP::GroupModel& obj, G3D::AABox& out) { out = obj.GetBound(); }
+    static void GetBounds(VMAP::GroupModel const& obj, G3D::AABox& out) { out = obj.GetBound(); }
 };
 
 namespace VMAP
 {
-    bool IntersectTriangle(const MeshTriangle& tri, std::vector<Vector3>::const_iterator points, const G3D::Ray& ray, float& distance)
+    bool IntersectTriangle(MeshTriangle const& tri, std::vector<Vector3>::const_iterator points, G3D::Ray const& ray, float& distance)
     {
         static const float EPS = 1e-5f;
 
@@ -88,7 +88,7 @@ namespace VMAP
     {
     public:
         TriBoundFunc(std::vector<Vector3>& vert): vertices(vert.begin()) { }
-        void operator()(const MeshTriangle& tri, G3D::AABox& out) const
+        void operator()(MeshTriangle const& tri, G3D::AABox& out) const
         {
             G3D::Vector3 lo = vertices[tri.idx0];
             G3D::Vector3 hi = lo;
@@ -104,7 +104,7 @@ namespace VMAP
 
     // ===================== WmoLiquid ==================================
 
-    WmoLiquid::WmoLiquid(uint32 width, uint32 height, const Vector3& corner, uint32 type):
+    WmoLiquid::WmoLiquid(uint32 width, uint32 height, Vector3 const& corner, uint32 type):
         iTilesX(width), iTilesY(height), iCorner(corner), iType(type)
     {
         if (width && height)
@@ -119,7 +119,7 @@ namespace VMAP
         }
     }
 
-    WmoLiquid::WmoLiquid(const WmoLiquid& other): iHeight(0), iFlags(0)
+    WmoLiquid::WmoLiquid(WmoLiquid const& other): iHeight(0), iFlags(0)
     {
         *this = other; // use assignment operator...
     }
@@ -130,7 +130,7 @@ namespace VMAP
         delete[] iFlags;
     }
 
-    WmoLiquid& WmoLiquid::operator=(const WmoLiquid& other)
+    WmoLiquid& WmoLiquid::operator=(WmoLiquid const& other)
     {
         if (this == &other)
         {
@@ -163,7 +163,7 @@ namespace VMAP
         return *this;
     }
 
-    bool WmoLiquid::GetLiquidHeight(const Vector3& pos, float& liqHeight) const
+    bool WmoLiquid::GetLiquidHeight(Vector3 const& pos, float& liqHeight) const
     {
         // simple case
         if (!iFlags)
@@ -311,7 +311,7 @@ namespace VMAP
 
     // ===================== GroupModel ==================================
 
-    GroupModel::GroupModel(const GroupModel& other):
+    GroupModel::GroupModel(GroupModel const& other):
         iBound(other.iBound), iMogpFlags(other.iMogpFlags), iGroupWMOID(other.iGroupWMOID),
         vertices(other.vertices), triangles(other.triangles), meshTree(other.meshTree), iLiquid(0)
     {
@@ -426,9 +426,9 @@ namespace VMAP
 
     struct GModelRayCallback
     {
-        GModelRayCallback(const std::vector<MeshTriangle>& tris, const std::vector<Vector3>& vert):
+        GModelRayCallback(std::vector<MeshTriangle> const& tris, std::vector<Vector3> const& vert):
             vertices(vert.begin()), triangles(tris.begin()), hit(false) { }
-        bool operator()(const G3D::Ray& ray, uint32 entry, float& distance, bool /*StopAtFirstHit*/)
+        bool operator()(G3D::Ray const& ray, uint32 entry, float& distance, bool /*StopAtFirstHit*/)
         {
             bool result = IntersectTriangle(triangles[entry], vertices, ray, distance);
             if (result) { hit = true; }
@@ -439,7 +439,7 @@ namespace VMAP
         bool hit;
     };
 
-    bool GroupModel::IntersectRay(const G3D::Ray& ray, float& distance, bool stopAtFirstHit) const
+    bool GroupModel::IntersectRay(G3D::Ray const& ray, float& distance, bool stopAtFirstHit) const
     {
         if (triangles.empty())
         {
@@ -451,7 +451,7 @@ namespace VMAP
         return callback.hit;
     }
 
-    inline bool IsInsideOrAboveBound(G3D::AABox const& bounds, const G3D::Point3& point)
+    inline bool IsInsideOrAboveBound(G3D::AABox const& bounds, G3D::Point3 const& point)
     {
         return point.x >= bounds.low().x
             && point.y >= bounds.low().y
@@ -493,7 +493,7 @@ namespace VMAP
         return OUT_OF_BOUNDS;
     }
 
-    bool GroupModel::GetLiquidLevel(const Vector3& pos, float& liqHeight) const
+    bool GroupModel::GetLiquidLevel(Vector3 const& pos, float& liqHeight) const
     {
         if (iLiquid)
         {
@@ -528,8 +528,8 @@ namespace VMAP
 
     struct WModelRayCallBack
     {
-        WModelRayCallBack(const std::vector<GroupModel>& mod): models(mod.begin()), hit(false) { }
-        bool operator()(const G3D::Ray& ray, uint32 entry, float& distance, bool StopAtFirstHit)
+        WModelRayCallBack(std::vector<GroupModel> const& mod): models(mod.begin()), hit(false) { }
+        bool operator()(G3D::Ray const& ray, uint32 entry, float& distance, bool StopAtFirstHit)
         {
             bool result = models[entry].IntersectRay(ray, distance, StopAtFirstHit);
             if (result) { hit = true; }
@@ -539,7 +539,7 @@ namespace VMAP
         bool hit;
     };
 
-    bool WorldModel::IntersectRay(const G3D::Ray& ray, float& distance, bool stopAtFirstHit, ModelIgnoreFlags ignoreFlags) const
+    bool WorldModel::IntersectRay(G3D::Ray const& ray, float& distance, bool stopAtFirstHit, ModelIgnoreFlags ignoreFlags) const
     {
         // If the caller asked us to ignore certain objects we should check flags
         if ((ignoreFlags & ModelIgnoreFlags::M2) != ModelIgnoreFlags::Nothing)
@@ -591,7 +591,7 @@ namespace VMAP
         }
     };
 
-    bool WorldModel::GetLocationInfo(const G3D::Vector3& p, const G3D::Vector3& down, float& dist, GroupLocationInfo& info) const
+    bool WorldModel::GetLocationInfo(G3D::Vector3 const& p, G3D::Vector3 const& down, float& dist, GroupLocationInfo& info) const
     {
         if (groupModels.empty())
         {
@@ -623,7 +623,7 @@ namespace VMAP
         return false;
     }
 
-    bool WorldModel::writeFile(const std::string& filename)
+    bool WorldModel::writeFile(std::string const& filename)
     {
         FILE* wf = fopen(filename.c_str(), "wb");
         if (!wf)
@@ -660,7 +660,7 @@ namespace VMAP
         return result;
     }
 
-    bool WorldModel::readFile(const std::string& filename)
+    bool WorldModel::readFile(std::string const& filename)
     {
         FILE* rf = fopen(filename.c_str(), "rb");
         if (!rf)

src/common/Collision/Models/WorldModel.h

@@ -46,11 +46,11 @@ namespace VMAP
     class WmoLiquid
     {
     public:
-        WmoLiquid(uint32 width, uint32 height, const G3D::Vector3& corner, uint32 type);
-        WmoLiquid(const WmoLiquid& other);
+        WmoLiquid(uint32 width, uint32 height, G3D::Vector3 const& corner, uint32 type);
+        WmoLiquid(WmoLiquid const& other);
         ~WmoLiquid();
-        WmoLiquid& operator=(const WmoLiquid& other);
-        bool GetLiquidHeight(const G3D::Vector3& pos, float& liqHeight) const;
+        WmoLiquid& operator=(WmoLiquid const& other);
+        bool GetLiquidHeight(G3D::Vector3 const& pos, float& liqHeight) const;
         [[nodiscard]] uint32 GetType() const { return iType; }
         float* GetHeightStorage() { return iHeight; }
         uint8* GetFlagsStorage() { return iFlags; }
@@ -73,18 +73,18 @@ namespace VMAP
     {
     public:
         GroupModel() { }
-        GroupModel(const GroupModel& other);
-        GroupModel(uint32 mogpFlags, uint32 groupWMOID, const G3D::AABox& bound):
+        GroupModel(GroupModel const& other);
+        GroupModel(uint32 mogpFlags, uint32 groupWMOID, G3D::AABox const& bound):
             iBound(bound), iMogpFlags(mogpFlags), iGroupWMOID(groupWMOID), iLiquid(nullptr) { }
         ~GroupModel() { delete iLiquid; }
 
         //! pass mesh data to object and create BIH. Passed vectors get get swapped with old geometry!
         void setMeshData(std::vector<G3D::Vector3>& vert, std::vector<MeshTriangle>& tri);
         void setLiquidData(WmoLiquid*& liquid) { iLiquid = liquid; liquid = nullptr; }
-        bool IntersectRay(const G3D::Ray& ray, float& distance, bool stopAtFirstHit) const;
+        bool IntersectRay(G3D::Ray const& ray, float& distance, bool stopAtFirstHit) const;
         enum InsideResult { INSIDE = 0, MAYBE_INSIDE = 1, ABOVE = 2, OUT_OF_BOUNDS = -1 };
         InsideResult IsInsideObject(G3D::Ray const& ray, float& z_dist) const;
-        bool GetLiquidLevel(const G3D::Vector3& pos, float& liqHeight) const;
+        bool GetLiquidLevel(G3D::Vector3 const& pos, float& liqHeight) const;
         [[nodiscard]] uint32 GetLiquidType() const;
         bool writeToFile(FILE* wf);
         bool readFromFile(FILE* rf);
@@ -111,10 +111,10 @@ namespace VMAP
         //! pass group models to WorldModel and create BIH. Passed vector is swapped with old geometry!
         void setGroupModels(std::vector<GroupModel>& models);
         void setRootWmoID(uint32 id) { RootWMOID = id; }
-        bool IntersectRay(const G3D::Ray& ray, float& distance, bool stopAtFirstHit, ModelIgnoreFlags ignoreFlags) const;
-        bool GetLocationInfo(const G3D::Vector3& p, const G3D::Vector3& down, float& dist, GroupLocationInfo& info) const;
-        bool writeFile(const std::string& filename);
-        bool readFile(const std::string& filename);
+        bool IntersectRay(G3D::Ray const& ray, float& distance, bool stopAtFirstHit, ModelIgnoreFlags ignoreFlags) const;
+        bool GetLocationInfo(G3D::Vector3 const& p, G3D::Vector3 const& down, float& dist, GroupLocationInfo& info) const;
+        bool writeFile(std::string const& filename);
+        bool readFile(std::string const& filename);
         void GetGroupModels(std::vector<GroupModel>& outGroupModels);
         uint32 Flags;
     protected:

src/common/Collision/RegularGrid.h

@@ -51,7 +51,7 @@ public:
 #define HGRID_MAP_SIZE  (533.33333f * 64.f)     // shouldn't be changed
 #define CELL_SIZE       float(HGRID_MAP_SIZE/(float)CELL_NUMBER)
 
-    typedef G3D::Table<const T*, NodeArray<Node>> MemberTable;
+    typedef G3D::Table<T const*, NodeArray<Node>> MemberTable;
 
     MemberTable memberTable;
     Node* nodes[CELL_NUMBER][CELL_NUMBER];
@@ -70,7 +70,7 @@ public:
             }
     }
 
-    void insert(const T& value)
+    void insert(T const& value)
     {
         G3D::Vector3 pos[9];
         pos[0] = value.GetBounds().corner(0);
@@ -110,7 +110,7 @@ public:
         memberTable.set(&value, na);
     }
 
-    void remove(const T& value)
+    void remove(T const& value)
     {
         NodeArray<Node>& na = memberTable[&value];
         for (uint8 i = 0; i < 9; ++i)
@@ -139,13 +139,13 @@ public:
                 }
     }
 
-    bool contains(const T& value) const { return memberTable.containsKey(&value); }
+    bool contains(T const& value) const { return memberTable.containsKey(&value); }
     int size() const { return memberTable.size(); }
 
     struct Cell
     {
         int x, y;
-        bool operator == (const Cell& c2) const { return x == c2.x && y == c2.y;}
+        bool operator == (Cell const& c2) const { return x == c2.x && y == c2.y;}
 
         static Cell ComputeCell(float fx, float fy)
         {
@@ -173,13 +173,13 @@ public:
     }
 
     template<typename RayCallback>
-    void intersectRay(const G3D::Ray& ray, RayCallback& intersectCallback, float max_dist, bool stopAtFirstHit)
+    void intersectRay(G3D::Ray const& ray, RayCallback& intersectCallback, float max_dist, bool stopAtFirstHit)
     {
         intersectRay(ray, intersectCallback, max_dist, ray.origin() + ray.direction() * max_dist, stopAtFirstHit);
     }
 
     template<typename RayCallback>
-    void intersectRay(const G3D::Ray& ray, RayCallback& intersectCallback, float& max_dist, const G3D::Vector3& end, bool stopAtFirstHit)
+    void intersectRay(G3D::Ray const& ray, RayCallback& intersectCallback, float& max_dist, G3D::Vector3 const& end, bool stopAtFirstHit)
     {
         Cell cell = Cell::ComputeCell(ray.origin().x, ray.origin().y);
         if (!cell.isValid())
@@ -261,7 +261,7 @@ public:
     }
 
     template<typename IsectCallback>
-    void intersectPoint(const G3D::Vector3& point, IsectCallback& intersectCallback)
+    void intersectPoint(G3D::Vector3 const& point, IsectCallback& intersectCallback)
     {
         Cell cell = Cell::ComputeCell(point.x, point.y);
         if (!cell.isValid())
@@ -276,7 +276,7 @@ public:
 
     // Optimized verson of intersectRay function for rays with vertical directions
     template<typename RayCallback>
-    void intersectZAllignedRay(const G3D::Ray& ray, RayCallback& intersectCallback, float& max_dist)
+    void intersectZAllignedRay(G3D::Ray const& ray, RayCallback& intersectCallback, float& max_dist)
     {
         Cell cell = Cell::ComputeCell(ray.origin().x, ray.origin().y);
         if (!cell.isValid())

src/common/Collision/VMapDefinitions.h

@@ -27,6 +27,6 @@ namespace VMAP
     const char GAMEOBJECT_MODELS[] = "GameObjectModels.dtree";
 
     // defined in TileAssembler.cpp currently...
-    bool readChunk(FILE* rf, char* dest, const char* compare, uint32 len);
+    bool readChunk(FILE* rf, char* dest, char const* compare, uint32 len);
 }
 #endif

src/common/Collision/VMapTools.h

@@ -37,7 +37,7 @@ namespace VMAP
         G3D::Vector3 hitLocation;
         G3D::Vector3 hitNormal;
 
-        void operator()(const G3D::Ray& ray, const TValue* entity, bool StopAtFirstHit, float& distance)
+        void operator()(G3D::Ray const& ray, TValue const* entity, bool StopAtFirstHit, float& distance)
         {
             entity->intersect(ray, distance, StopAtFirstHit, hitLocation, hitNormal);
         }
@@ -51,9 +51,9 @@ namespace VMAP
     {
     public:
         static bool collisionLocationForMovingPointFixedAABox(
-            const G3D::Vector3&     origin,
-            const G3D::Vector3&     dir,
-            const G3D::AABox&       box,
+            G3D::Vector3 const&     origin,
+            G3D::Vector3 const&     dir,
+            G3D::AABox const&       box,
             G3D::Vector3&           location,
             bool&                   Inside)
         {
@@ -61,8 +61,8 @@ namespace VMAP
 #define IR(x)   (reinterpret_cast<G3D::uint32 const&>(x))
 
             Inside = true;
-            const G3D::Vector3& MinB = box.low();
-            const G3D::Vector3& MaxB = box.high();
+            G3D::Vector3 const& MinB = box.low();
+            G3D::Vector3 const& MaxB = box.high();
             G3D::Vector3 MaxT(-1.0f, -1.0f, -1.0f);
 
             // Find candidate planes.

src/common/Common.cpp

@@ -75,7 +75,7 @@ bool IsLocaleValid(std::string const& locale)
     return false;
 }
 
-LocaleConstant GetLocaleByName(const std::string& name)
+LocaleConstant GetLocaleByName(std::string const& name)
 {
     for (uint32 i = 0; i < TOTAL_LOCALES; ++i)
         if (name == localeNames[i])

src/common/Common.h

@@ -144,7 +144,7 @@ enum LocaleConstant
 AC_COMMON_API extern char const* localeNames[TOTAL_LOCALES];
 
 AC_COMMON_API bool IsLocaleValid(std::string const& locale);
-AC_COMMON_API LocaleConstant GetLocaleByName(const std::string& name);
+AC_COMMON_API LocaleConstant GetLocaleByName(std::string const& name);
 AC_COMMON_API const std::string GetNameByLocaleConstant(LocaleConstant localeConstant);
 AC_COMMON_API void CleanStringForMysqlQuery(std::string& str);
 

src/common/Configuration/Config.cpp

@@ -359,7 +359,7 @@ namespace
         {
             return ParseFile(file, isOptional, isReload);
         }
-        catch (const std::exception& e)
+        catch (std::exception const& e)
         {
             PrintError(file, "> {}", e.what());
         }
@@ -376,7 +376,7 @@ namespace
     {
         std::string result;
 
-        const char* str = key.c_str();
+        char const* str = key.c_str();
         std::size_t n = key.length();
 
         char curr;

src/common/DataStores/DBCFileLoader.cpp

@@ -307,7 +307,7 @@ char* DBCFileLoader::AutoProduceStrings(char const* format, char* dataTable)
                     char** slot = (char**)(&dataTable[offset]);
                     if (!*slot || !** slot)
                     {
-                        const char* st = getRecord(y).getString(x);
+                        char const* st = getRecord(y).getString(x);
                         *slot = stringPool + (st - (char const*)stringTable);
                     }
                     offset += sizeof(char*);

src/common/DataStores/DBCFileLoader.h

@@ -41,7 +41,7 @@ public:
     DBCFileLoader();
     ~DBCFileLoader();
 
-    bool Load(const char* filename, const char* fmt);
+    bool Load(char const* filename, char const* fmt);
 
     class Record
     {
@@ -68,7 +68,7 @@ public:
             return *reinterpret_cast<uint8*>(offset + file.GetOffset(field));
         }
 
-        [[nodiscard]] const char* getString(std::size_t field) const
+        [[nodiscard]] char const* getString(std::size_t field) const
         {
             ASSERT(field < file.fieldCount);
             std::size_t stringOffset = getUInt(field);
@@ -94,7 +94,7 @@ public:
     [[nodiscard]] bool IsLoaded() const { return data != nullptr; }
     char* AutoProduceData(char const* fmt, uint32& count, char**& indexTable);
     char* AutoProduceStrings(char const* fmt, char* dataTable);
-    static uint32 GetFormatRecordSize(const char* format, int32* index_pos = nullptr);
+    static uint32 GetFormatRecordSize(char const* format, int32* index_pos = nullptr);
 
 private:
     uint32 recordSize;

src/common/Debugging/WheatyExceptionReport.cpp

@@ -1589,7 +1589,7 @@ DWORD_PTR WheatyExceptionReport::DereferenceUnsafePointer(DWORD_PTR address)
 // Helper function that writes to the report file, and allows the user to use
 // printf style formating
 //============================================================================
-int __cdecl WheatyExceptionReport::Log(const TCHAR* format, ...)
+int __cdecl WheatyExceptionReport::Log(TCHAR const* format, ...)
 {
     int retValue;
     va_list argptr;
@@ -1609,7 +1609,7 @@ int __cdecl WheatyExceptionReport::Log(const TCHAR* format, ...)
     return retValue;
 }
 
-int __cdecl WheatyExceptionReport::StackLog(const TCHAR* format, va_list argptr)
+int __cdecl WheatyExceptionReport::StackLog(TCHAR const* format, va_list argptr)
 {
     int retValue;
     DWORD cbWritten;
@@ -1621,7 +1621,7 @@ int __cdecl WheatyExceptionReport::StackLog(const TCHAR* format, va_list argptr)
     return retValue;
 }
 
-int __cdecl WheatyExceptionReport::HeapLog(const TCHAR* format, va_list argptr)
+int __cdecl WheatyExceptionReport::HeapLog(TCHAR const* format, va_list argptr)
 {
     int retValue = 0;
     DWORD cbWritten;

src/common/Debugging/WheatyExceptionReport.h

@@ -169,9 +169,9 @@ private:
     static BasicType GetBasicType(DWORD typeIndex, DWORD64 modBase);
     static DWORD_PTR DereferenceUnsafePointer(DWORD_PTR address);
 
-    static int __cdecl Log(const TCHAR* format, ...);
-    static int __cdecl StackLog(const TCHAR* format, va_list argptr);
-    static int __cdecl HeapLog(const TCHAR* format, va_list argptr);
+    static int __cdecl Log(TCHAR const* format, ...);
+    static int __cdecl StackLog(TCHAR const* format, va_list argptr);
+    static int __cdecl HeapLog(TCHAR const* format, va_list argptr);
 
     static bool StoreSymbol(DWORD type, DWORD_PTR offset);
     static void ClearSymbols();

src/common/Dynamic/TypeContainer.h

@@ -136,7 +136,7 @@ public:
     //}
 
     ContainerMapList<OBJECT_TYPES>& GetElements() { return i_elements; }
-    [[nodiscard]] const ContainerMapList<OBJECT_TYPES>& GetElements() const { return i_elements;}
+    [[nodiscard]] ContainerMapList<OBJECT_TYPES> const& GetElements() const { return i_elements;}
 
 private:
     ContainerMapList<OBJECT_TYPES> i_elements;
@@ -163,7 +163,7 @@ public:
     }
 
     ContainerVector<OBJECT_TYPES>& GetElements() { return i_elements; }
-    [[nodiscard]] const ContainerVector<OBJECT_TYPES>& GetElements() const { return i_elements; }
+    [[nodiscard]] ContainerVector<OBJECT_TYPES> const& GetElements() const { return i_elements; }
 
 private:
     ContainerVector<OBJECT_TYPES> i_elements;

src/common/Dynamic/TypeContainerFunctions.h

@@ -156,31 +156,31 @@ namespace Acore
     /* ContainerMapList Helpers */
     // count functions
     template<class SPECIFIC_TYPE>
-    std::size_t Count(const ContainerMapList<SPECIFIC_TYPE>& elements, SPECIFIC_TYPE* /*fake*/)
+    std::size_t Count(ContainerMapList<SPECIFIC_TYPE> const& elements, SPECIFIC_TYPE* /*fake*/)
     {
         return elements._element.getSize();
     }
 
     template<class SPECIFIC_TYPE>
-    std::size_t Count(const ContainerMapList<TypeNull>& /*elements*/, SPECIFIC_TYPE* /*fake*/)
+    std::size_t Count(ContainerMapList<TypeNull> const& /*elements*/, SPECIFIC_TYPE* /*fake*/)
     {
         return 0;
     }
 
     template<class SPECIFIC_TYPE, class T>
-    std::size_t Count(const ContainerMapList<T>& /*elements*/, SPECIFIC_TYPE* /*fake*/)
+    std::size_t Count(ContainerMapList<T> const& /*elements*/, SPECIFIC_TYPE* /*fake*/)
     {
         return 0;
     }
 
     template<class SPECIFIC_TYPE, class T>
-    std::size_t Count(const ContainerMapList<TypeList<SPECIFIC_TYPE, T>>& elements, SPECIFIC_TYPE* fake)
+    std::size_t Count(ContainerMapList<TypeList<SPECIFIC_TYPE, T>> const& elements, SPECIFIC_TYPE* fake)
     {
         return Count(elements._elements, fake);
     }
 
     template<class SPECIFIC_TYPE, class H, class T>
-    std::size_t Count(const ContainerMapList<TypeList<H, T>>& elements, SPECIFIC_TYPE* fake)
+    std::size_t Count(ContainerMapList<TypeList<H, T>> const& elements, SPECIFIC_TYPE* fake)
     {
         return Count(elements._TailElements, fake);
     }
@@ -243,31 +243,31 @@ namespace Acore
     /* ContainerVector Helpers */
     // count functions
     template<class SPECIFIC_TYPE>
-    std::size_t Count(const ContainerVector<SPECIFIC_TYPE>& elements, SPECIFIC_TYPE* /*fake*/)
+    std::size_t Count(ContainerVector<SPECIFIC_TYPE> const& elements, SPECIFIC_TYPE* /*fake*/)
     {
         return elements._element.getSize();
     }
 
     template<class SPECIFIC_TYPE>
-    std::size_t Count(const ContainerVector<TypeNull>& /*elements*/, SPECIFIC_TYPE* /*fake*/)
+    std::size_t Count(ContainerVector<TypeNull> const& /*elements*/, SPECIFIC_TYPE* /*fake*/)
     {
         return 0;
     }
 
     template<class SPECIFIC_TYPE, class T>
-    std::size_t Count(const ContainerVector<T>& /*elements*/, SPECIFIC_TYPE* /*fake*/)
+    std::size_t Count(ContainerVector<T> const& /*elements*/, SPECIFIC_TYPE* /*fake*/)
     {
         return 0;
     }
 
     template<class SPECIFIC_TYPE, class T>
-    std::size_t Count(const ContainerVector<TypeList<SPECIFIC_TYPE, T>>& elements, SPECIFIC_TYPE* fake)
+    std::size_t Count(ContainerVector<TypeList<SPECIFIC_TYPE, T>> const& elements, SPECIFIC_TYPE* fake)
     {
         return Count(elements._elements, fake);
     }
 
     template<class SPECIFIC_TYPE, class H, class T>
-    std::size_t Count(const ContainerVector<TypeList<H, T>>& elements, SPECIFIC_TYPE* fake)
+    std::size_t Count(ContainerVector<TypeList<H, T>> const& elements, SPECIFIC_TYPE* fake)
     {
         return Count(elements._TailElements, fake);
     }

src/common/Dynamic/TypeContainerFunctionsPtr.h

@@ -81,23 +81,23 @@ namespace Acore
     }
 
     // const find functions
-    template<class SPECIFIC_TYPE> const CountedPtr<SPECIFIC_TYPE>& Find(const ContainerMapList<SPECIFIC_TYPE>& elements, OBJECT_HANDLE hdl, CountedPtr<SPECIFIC_TYPE>* /*fake*/)
+    template<class SPECIFIC_TYPE> CountedPtr<SPECIFIC_TYPE> const& Find(ContainerMapList<SPECIFIC_TYPE> const& elements, OBJECT_HANDLE hdl, CountedPtr<SPECIFIC_TYPE>* /*fake*/)
     {
         typename CountedPtr<SPECIFIC_TYPE>::iterator iter = elements._element.find(hdl);
         return (iter == elements._element.end() ? NullPtr<SPECIFIC_TYPE>((SPECIFIC_TYPE*)nullptr) : iter->second);
     };
 
-    template<class SPECIFIC_TYPE> const CountedPtr<SPECIFIC_TYPE>& Find(const ContainerMapList<TypeNull>& elements, OBJECT_HANDLE hdl, CountedPtr<SPECIFIC_TYPE>* /*fake*/)
+    template<class SPECIFIC_TYPE> CountedPtr<SPECIFIC_TYPE> const& Find(ContainerMapList<TypeNull> const& elements, OBJECT_HANDLE hdl, CountedPtr<SPECIFIC_TYPE>* /*fake*/)
     {
         return NullPtr<SPECIFIC_TYPE>((SPECIFIC_TYPE*)nullptr);
     }
 
-    template<class SPECIFIC_TYPE, class T> const CountedPtr<SPECIFIC_TYPE>& Find(const ContainerMapList<T>& elements, OBJECT_HANDLE hdl, CountedPtr<SPECIFIC_TYPE>* /*fake*/)
+    template<class SPECIFIC_TYPE, class T> CountedPtr<SPECIFIC_TYPE> const& Find(ContainerMapList<T> const& elements, OBJECT_HANDLE hdl, CountedPtr<SPECIFIC_TYPE>* /*fake*/)
     {
         return NullPtr<SPECIFIC_TYPE>((SPECIFIC_TYPE*)nullptr);
     }
 
-    template<class SPECIFIC_TYPE, class H, class T> CountedPtr<SPECIFIC_TYPE>& Find(const ContainerMapList<TypeList<H, T>>& elements, OBJECT_HANDLE hdl, CountedPtr<SPECIFIC_TYPE>* fake)
+    template<class SPECIFIC_TYPE, class H, class T> CountedPtr<SPECIFIC_TYPE>& Find(ContainerMapList<TypeList<H, T>> const& elements, OBJECT_HANDLE hdl, CountedPtr<SPECIFIC_TYPE>* fake)
     {
         CountedPtr<SPECIFIC_TYPE>& t = Find(elements._elements, hdl, fake);
         if (!t)

src/common/Dynamic/TypeContainerVisitor.h

@@ -111,7 +111,7 @@ public:
         VisitorHelper(i_visitor, c);
     }
 
-    void Visit(const TYPE_CONTAINER& c) const
+    void Visit(TYPE_CONTAINER const& c) const
     {
         VisitorHelper(i_visitor, c);
     }

src/common/Metric/Metric.cpp

@@ -315,7 +315,7 @@ void Metric::ScheduleOverallStatusLog()
     if (_enabled)
     {
         _overallStatusTimer->expires_at(Acore::Asio::SteadyTimer::GetExpirationTime(_overallStatusTimerInterval));
-        _overallStatusTimer->async_wait([this](const boost::system::error_code&)
+        _overallStatusTimer->async_wait([this](boost::system::error_code const&)
         {
             _overallStatusTimerTriggered = true;
             ScheduleOverallStatusLog();

src/common/Navigation/DetourExtended.cpp

@@ -6,10 +6,10 @@
 #include "DetourCommon.h"
 #include "Geometry.h"
 
-float dtQueryFilterExt::getCost(const float* pa, const float* pb,
-                const dtPolyRef /*prevRef*/, const dtMeshTile* /*prevTile*/, const dtPoly* /*prevPoly*/,
-                const dtPolyRef /*curRef*/, const dtMeshTile* /*curTile*/, const dtPoly* curPoly,
-                const dtPolyRef /*nextRef*/, const dtMeshTile* /*nextTile*/, const dtPoly* /*nextPoly*/) const
+float dtQueryFilterExt::getCost(float const* pa, float const* pb,
+                const dtPolyRef /*prevRef*/, dtMeshTile const* /*prevTile*/, dtPoly const* /*prevPoly*/,
+                const dtPolyRef /*curRef*/, dtMeshTile const* /*curTile*/, dtPoly const* curPoly,
+                const dtPolyRef /*nextRef*/, dtMeshTile const* /*nextTile*/, dtPoly const* /*nextPoly*/) const
 {
     float startX = pa[2], startY = pa[0], startZ = pa[1];
     float destX = pb[2], destY = pb[0], destZ = pb[1];

src/common/Navigation/DetourExtended.h

@@ -10,10 +10,10 @@
 class dtQueryFilterExt: public dtQueryFilter
 {
 public:
-    float getCost(const float* pa, const float* pb,
-        const dtPolyRef prevRef, const dtMeshTile* prevTile, const dtPoly* prevPoly,
-        const dtPolyRef curRef, const dtMeshTile* curTile, const dtPoly* curPoly,
-        const dtPolyRef nextRef, const dtMeshTile* nextTile, const dtPoly* nextPoly) const override;
+    float getCost(float const* pa, float const* pb,
+        const dtPolyRef prevRef, dtMeshTile const* prevTile, dtPoly const* prevPoly,
+        const dtPolyRef curRef, dtMeshTile const* curTile, dtPoly const* curPoly,
+        const dtPolyRef nextRef, dtMeshTile const* nextTile, dtPoly const* nextPoly) const override;
 };
 
 #endif // _ACORE_DETOUR_EXTENDED_H

src/common/Threading/LockedQueue.h

@@ -49,7 +49,7 @@ public:
      *
      * @param item The item to be added to the queue.
      */
-    void add(const T& item)
+    void add(T const& item)
     {
         std::lock_guard<std::mutex> lock(_lock);
         _queue.push_back(std::move(item));

src/common/Threading/PCQueue.h

@@ -36,7 +36,7 @@ private:
 public:
     ProducerConsumerQueue() = default;
 
-    void Push(const T& value)
+    void Push(T const& value)
     {
         {
             std::lock_guard<std::mutex> lock(_queueLock);

src/common/Threading/Threading.h

@@ -68,8 +68,8 @@ namespace Acore
         static std::thread::id currentId();
 
     private:
-        Thread(const Thread&);
-        Thread& operator=(const Thread&);
+        Thread(Thread const&);
+        Thread& operator=(Thread const&);
 
         static void ThreadTask(void* param);
 

src/common/Threading/ThreadingModel.h

@@ -41,8 +41,8 @@ namespace Acore
         }
 
     private:
-        GeneralLock(const GeneralLock&);
-        GeneralLock& operator=(const GeneralLock&);
+        GeneralLock(GeneralLock const&);
+        GeneralLock& operator=(GeneralLock const&);
         MUTEX& i_mutex;
     };
 
@@ -55,11 +55,11 @@ namespace Acore
             Lock()
             {
             }
-            Lock(const T&)
+            Lock(T const&)
             {
             }
 
-            Lock(const SingleThreaded<T>&)              // for single threaded we ignore this
+            Lock(SingleThreaded<T> const&)              // for single threaded we ignore this
             {
             }
         };
@@ -90,8 +90,8 @@ namespace Acore
 
     private:
         // prevent the compiler creating a copy construct
-        ObjectLevelLockable(const ObjectLevelLockable<T, MUTEX>&);
-        ObjectLevelLockable<T, MUTEX>& operator=(const ObjectLevelLockable<T, MUTEX>&);
+        ObjectLevelLockable(ObjectLevelLockable<T, MUTEX> const&);
+        ObjectLevelLockable<T, MUTEX>& operator=(ObjectLevelLockable<T, MUTEX> const&);
 
         MUTEX i_mtx;
     };
@@ -109,12 +109,12 @@ namespace Acore
         class Lock
         {
         public:
-            Lock(const T& /*host*/)
+            Lock(T const& /*host*/)
             {
                 ClassLevelLockable<T, MUTEX>::si_mtx.lock();
             }
 
-            Lock(const ClassLevelLockable<T, MUTEX>&)
+            Lock(ClassLevelLockable<T, MUTEX> const&)
             {
                 ClassLevelLockable<T, MUTEX>::si_mtx.lock();
             }

src/common/Utilities/SmartEnum.h

@@ -85,13 +85,13 @@ public:
         Iterator() : _index(EnumUtils::Count<Enum>()) {}
         explicit Iterator(std::size_t index) : _index(index) { }
 
-        bool operator==(const Iterator& other) const { return other._index == _index; }
-        bool operator!=(const Iterator& other) const { return !operator==(other); }
+        bool operator==(Iterator const& other) const { return other._index == _index; }
+        bool operator!=(Iterator const& other) const { return !operator==(other); }
         difference_type operator-(Iterator const& other) const { return _index - other._index; }
-        bool operator<(const Iterator& other) const { return _index < other._index; }
-        bool operator<=(const Iterator& other) const { return _index <= other._index; }
-        bool operator>(const Iterator& other) const { return _index > other._index; }
-        bool operator>=(const Iterator& other) const { return _index >= other._index; }
+        bool operator<(Iterator const& other) const { return _index < other._index; }
+        bool operator<=(Iterator const& other) const { return _index <= other._index; }
+        bool operator>(Iterator const& other) const { return _index > other._index; }
+        bool operator>=(Iterator const& other) const { return _index >= other._index; }
 
         value_type operator[](difference_type d) const { return FromIndex<Enum>(_index + d); }
         value_type operator*() const { return operator[](0); }

src/common/Utilities/StringFormat.cpp

@@ -19,7 +19,7 @@
 #include "Define.h"
 
 template<class Str>
-AC_COMMON_API Str Acore::String::Trim(const Str& s, const std::locale& loc /*= std::locale()*/)
+AC_COMMON_API Str Acore::String::Trim(Str const& s, std::locale const& loc /*= std::locale()*/)
 {
     typename Str::const_iterator first = s.begin();
     typename Str::const_iterator end = s.end();
@@ -78,4 +78,4 @@ std::string Acore::String::AddSuffixIfNotExists(std::string str, const char suff
 }
 
 // Template Trim
-template AC_COMMON_API std::string Acore::String::Trim<std::string>(const std::string& s, const std::locale& loc /*= std::locale()*/);
+template AC_COMMON_API std::string Acore::String::Trim<std::string>(std::string const& s, std::locale const& loc /*= std::locale()*/);

src/common/Utilities/StringFormat.h

@@ -110,7 +110,7 @@ namespace Acore
 namespace Acore::String
 {
     template<class Str>
-    AC_COMMON_API Str Trim(const Str& s, const std::locale& loc = std::locale());
+    AC_COMMON_API Str Trim(Str const& s, std::locale const& loc = std::locale());
 
     AC_COMMON_API std::string TrimRightInPlace(std::string& str);
 

src/common/Utilities/Util.cpp

@@ -160,7 +160,7 @@ Optional<int32> MoneyStringToMoney(std::string_view moneyString)
     return money;
 }
 
-uint32 TimeStringToSecs(const std::string& timestring)
+uint32 TimeStringToSecs(std::string const& timestring)
 {
     uint32 secs       = 0;
     uint32 buffer     = 0;
@@ -291,7 +291,7 @@ bool Utf8toWStr(char const* utf8str, std::size_t csize, wchar_t* wstr, std::size
     {
         // Replace the converted string with an error message if there is enough space
         // Otherwise just return an empty string
-        const wchar_t* errorMessage = L"An error occurred converting string from UTF-8 to WStr";
+        wchar_t const* errorMessage = L"An error occurred converting string from UTF-8 to WStr";
         std::size_t errorMessageLength = std::char_traits<wchar_t>::length(errorMessage);
         if (wsize >= errorMessageLength)
         {
@@ -421,7 +421,7 @@ std::wstring GetMainPartOfName(std::wstring const& wname, uint32_t declension)
 
     std::size_t const thisLen = wname.length();
     std::array<std::wstring const*, 7> const& endings = dropEnds[declension];
-    for (const std::wstring* endingPtr : endings)
+    for (std::wstring const* endingPtr : endings)
     {
         if (endingPtr == nullptr)
         {
@@ -498,7 +498,7 @@ bool Utf8FitTo(std::string_view str, std::wstring_view search)
     return true;
 }
 
-void utf8printf(FILE* out, const char* str, ...)
+void utf8printf(FILE* out, char const* str, ...)
 {
     va_list ap;
     va_start(ap, str);
@@ -506,7 +506,7 @@ void utf8printf(FILE* out, const char* str, ...)
     va_end(ap);
 }
 
-void vutf8printf(FILE* out, const char* str, va_list* ap)
+void vutf8printf(FILE* out, char const* str, va_list* ap)
 {
 #if AC_PLATFORM == AC_PLATFORM_WINDOWS
     char temp_buf[32 * 1024];

src/common/Utilities/Util.h

@@ -37,7 +37,7 @@ template<typename T, class S> struct Finder
     T S::* idMember_;
 
     Finder(T val, T S::* idMember) : val_(val), idMember_(idMember) {}
-    bool operator()(const std::pair<int, S>& obj) { return obj.second.*idMember_ == val_; }
+    bool operator()(std::pair<int, S> const& obj) { return obj.second.*idMember_ == val_; }
 };
 
 void stripLineInvisibleChars(std::string& src);
@@ -45,7 +45,7 @@ void stripLineInvisibleChars(std::string& src);
 AC_COMMON_API Optional<int32> MoneyStringToMoney(std::string_view moneyString);
 
 std::string secsToTimeString(uint64 timeInSecs, bool shortText = false);
-uint32 TimeStringToSecs(const std::string& timestring);
+uint32 TimeStringToSecs(std::string const& timestring);
 
 // Percentage calculation
 template <class T, class U>
@@ -353,13 +353,13 @@ std::wstring GetMainPartOfName(std::wstring const& wname, uint32 declension);
 AC_COMMON_API bool utf8ToConsole(std::string_view utf8str, std::string& conStr);
 AC_COMMON_API bool consoleToUtf8(std::string_view conStr, std::string& utf8str);
 AC_COMMON_API bool Utf8FitTo(std::string_view str, std::wstring_view search);
-AC_COMMON_API void utf8printf(FILE* out, const char* str, ...);
-AC_COMMON_API void vutf8printf(FILE* out, const char* str, va_list* ap);
+AC_COMMON_API void utf8printf(FILE* out, char const* str, ...);
+AC_COMMON_API void vutf8printf(FILE* out, char const* str, va_list* ap);
 AC_COMMON_API bool Utf8ToUpperOnlyLatin(std::string& utf8String);
 
 bool IsIPAddress(char const* ipaddress);
 
-uint32 CreatePIDFile(const std::string& filename);
+uint32 CreatePIDFile(std::string const& filename);
 uint32 GetPID();
 
 namespace Acore::Impl
@@ -506,7 +506,7 @@ public:
         part[2] = right.part[2];
         return *this;
     }
-    flag96(const flag96&) = default;
+    flag96(flag96 const&) = default;
     flag96(flag96&&) = default;
 
     inline flag96 operator&(flag96 const& right) const

src/server/apps/worldserver/ACSoap/ACSoap.cpp

@@ -23,7 +23,7 @@
 #include <chrono>
 #include <memory>
 
-void ACSoapThread(const std::string& host, uint16 port)
+void ACSoapThread(std::string const& host, uint16 port)
 {
     struct soap soap;
     soap_init(&soap);

src/server/apps/worldserver/ACSoap/ACSoap.h

@@ -23,7 +23,7 @@
 #include <memory>
 
 void process_message(struct soap* soap_message);
-void ACSoapThread(const std::string& host, uint16 port);
+void ACSoapThread(std::string const& host, uint16 port);
 
 class SOAPCommand
 {

src/server/apps/worldserver/RemoteAccess/RASession.cpp

@@ -120,7 +120,7 @@ std::string RASession::ReadString()
     return line;
 }
 
-bool RASession::CheckAccessLevel(const std::string& user)
+bool RASession::CheckAccessLevel(std::string const& user)
 {
     std::string safeUser = user;
 
@@ -152,7 +152,7 @@ bool RASession::CheckAccessLevel(const std::string& user)
     return true;
 }
 
-bool RASession::CheckPassword(const std::string& user, const std::string& pass)
+bool RASession::CheckPassword(std::string const& user, std::string const& pass)
 {
     std::string safe_user = user;
     std::transform(safe_user.begin(), safe_user.end(), safe_user.begin(), ::toupper);

src/server/apps/worldserver/RemoteAccess/RASession.h

@@ -38,8 +38,8 @@ public:
 private:
     int Send(std::string_view data);
     std::string ReadString();
-    bool CheckAccessLevel(const std::string& user);
-    bool CheckPassword(const std::string& user, const std::string& pass);
+    bool CheckAccessLevel(std::string const& user);
+    bool CheckPassword(std::string const& user, std::string const& pass);
     bool ProcessCommand(std::string& command);
 
     static void CommandPrint(void* callbackArg, std::string_view text);

src/server/database/Database/MySQLConnection.cpp

@@ -399,7 +399,7 @@ int MySQLConnection::ExecuteTransaction(std::shared_ptr<TransactionBase> transac
                 {
                     stmt = std::get<PreparedStatementBase*>(data.element);
                 }
-                catch (const std::bad_variant_access& ex)
+                catch (std::bad_variant_access const& ex)
                 {
                     LOG_FATAL("sql.sql", "> PreparedStatementBase not found in SQLElementData. {}", ex.what());
                     ABORT();
@@ -424,7 +424,7 @@ int MySQLConnection::ExecuteTransaction(std::shared_ptr<TransactionBase> transac
                 {
                     sql = std::get<std::string>(data.element);
                 }
-                catch (const std::bad_variant_access& ex)
+                catch (std::bad_variant_access const& ex)
                 {
                     LOG_FATAL("sql.sql", "> std::string not found in SQLElementData. {}", ex.what());
                     ABORT();
@@ -453,7 +453,7 @@ int MySQLConnection::ExecuteTransaction(std::shared_ptr<TransactionBase> transac
     return 0;
 }
 
-std::size_t MySQLConnection::EscapeString(char* to, const char* from, std::size_t length)
+std::size_t MySQLConnection::EscapeString(char* to, char const* from, std::size_t length)
 {
     return mysql_real_escape_string(m_Mysql, to, from, length);
 }

src/server/database/Database/MySQLConnection.h

@@ -79,7 +79,7 @@ public:
     void RollbackTransaction();
     void CommitTransaction();
     int ExecuteTransaction(std::shared_ptr<TransactionBase> transaction);
-    std::size_t EscapeString(char* to, const char* from, std::size_t length);
+    std::size_t EscapeString(char* to, char const* from, std::size_t length);
     void Ping();
 
     uint32 GetLastError();

src/server/database/Database/QueryResult.h

@@ -39,7 +39,7 @@ struct ResultIterator
     pointer operator->() { return _ptr; }
     ResultIterator& operator++() { if (!_ptr->NextRow()) _ptr = nullptr; return *this; }
 
-    bool operator!=(const ResultIterator& right) { return _ptr != right._ptr; }
+    bool operator!=(ResultIterator const& right) { return _ptr != right._ptr; }
 
 private:
     pointer _ptr;

src/server/database/Database/Transaction.cpp

@@ -66,7 +66,7 @@ void TransactionBase::Cleanup()
 
                     delete stmt;
                 }
-                catch (const std::bad_variant_access& ex)
+                catch (std::bad_variant_access const& ex)
                 {
                     LOG_FATAL("sql.sql", "> PreparedStatementBase not found in SQLElementData. {}", ex.what());
                     ABORT();
@@ -79,7 +79,7 @@ void TransactionBase::Cleanup()
                 {
                     std::get<std::string>(data.element).clear();
                 }
-                catch (const std::bad_variant_access& ex)
+                catch (std::bad_variant_access const& ex)
                 {
                     LOG_FATAL("sql.sql", "> std::string not found in SQLElementData. {}", ex.what());
                     ABORT();

src/server/database/Updater/DBUpdater.cpp

@@ -175,7 +175,7 @@ bool DBUpdater<T>::Create(DatabaseWorkerPool<T>& pool)
 {
     LOG_WARN("sql.updates", "Database \"{}\" does not exist", pool.GetConnectionInfo()->database);
 
-    const char* disableInteractive = std::getenv("AC_DISABLE_INTERACTIVE");
+    char const* disableInteractive = std::getenv("AC_DISABLE_INTERACTIVE");
 
     if (!sConfigMgr->isDryRun() && (disableInteractive == nullptr || std::strcmp(disableInteractive, "1") != 0))
     {
@@ -402,7 +402,7 @@ bool DBUpdater<T>::Populate(DatabaseWorkerPool<T>& pool)
 
     std::vector<std::filesystem::path> sqlFiles;
 
-    for (const auto &entry : std::filesystem::directory_iterator(DirPath))
+    for (auto const& entry : std::filesystem::directory_iterator(DirPath))
     {
         if (entry.path().extension() == ".sql")
             sqlFiles.push_back(entry.path());
@@ -410,7 +410,7 @@ bool DBUpdater<T>::Populate(DatabaseWorkerPool<T>& pool)
 
     std::sort(sqlFiles.begin(), sqlFiles.end());
 
-    for (const auto &file : sqlFiles)
+    for (auto const& file : sqlFiles)
     {
         LOG_INFO("sql.updates", ">> Applying \'{}\'...", file.filename().generic_string());
 

src/server/game/AI/CoreAI/PetAI.cpp

@@ -494,7 +494,7 @@ Unit* PetAI::SelectNextTarget(bool allowAutoSelect) const
     // Check pet's attackers first to prevent dragging mobs back to owner
     if (me->HasTauntAura())
     {
-        const Unit::AuraEffectList& tauntAuras = me->GetAuraEffectsByType(SPELL_AURA_MOD_TAUNT);
+        Unit::AuraEffectList const& tauntAuras = me->GetAuraEffectsByType(SPELL_AURA_MOD_TAUNT);
         if (!tauntAuras.empty())
             for (Unit::AuraEffectList::const_reverse_iterator itr = tauntAuras.rbegin(); itr != tauntAuras.rend(); ++itr)
                 if (Unit* caster = (*itr)->GetCaster())

src/server/game/AI/CreatureAI.cpp

@@ -625,7 +625,7 @@ void CreatureAI::SetBoundary(CreatureBoundary const* boundary, bool negateBounda
     me->DoImmediateBoundaryCheck();
 }
 
-Creature* CreatureAI::DoSummon(uint32 entry, const Position& pos, uint32 despawnTime, TempSummonType summonType)
+Creature* CreatureAI::DoSummon(uint32 entry, Position const& pos, uint32 despawnTime, TempSummonType summonType)
 {
     return me->SummonCreature(entry, pos, summonType, despawnTime);
 }

src/server/game/AI/ScriptedAI/ScriptedCreature.h

@@ -244,7 +244,7 @@ struct ScriptedAI : public CreatureAI
      * Hodir is in room until his Y position is below the Door position:
      * IsInRoom(doorPosition, AXIS_Y, false);
      */
-    bool IsInRoom(const Position* pos, Axis axis, bool above)
+    bool IsInRoom(Position const* pos, Axis axis, bool above)
     {
         if (!pos)
         {
@@ -389,7 +389,7 @@ struct ScriptedAI : public CreatureAI
     bool Is25ManRaid() const { return _difficulty & RAID_DIFFICULTY_MASK_25MAN; }
 
     template<class T> inline
-    const T& DUNGEON_MODE(const T& normal5, const T& heroic10) const
+    T const& DUNGEON_MODE(T const& normal5, T const& heroic10) const
     {
         switch (_difficulty)
         {
@@ -405,7 +405,7 @@ struct ScriptedAI : public CreatureAI
     }
 
     template<class T> inline
-    const T& RAID_MODE(const T& normal10, const T& normal25) const
+    T const& RAID_MODE(T const& normal10, T const& normal25) const
     {
         switch (_difficulty)
         {
@@ -421,7 +421,7 @@ struct ScriptedAI : public CreatureAI
     }
 
     template<class T> inline
-    const T& RAID_MODE(const T& normal10, const T& normal25, const T& heroic10, const T& heroic25) const
+    T const& RAID_MODE(T const& normal10, T const& normal25, T const& heroic10, T const& heroic25) const
     {
         switch (_difficulty)
         {

src/server/game/AI/ScriptedAI/ScriptedFollowerAI.cpp

@@ -257,7 +257,7 @@ void FollowerAI::MovementInform(uint32 motionType, uint32 pointId)
     }
 }
 
-void FollowerAI::StartFollow(Player* player, uint32 factionForFollower, const Quest* quest, bool inheritWalkState, bool inheritSpeed)
+void FollowerAI::StartFollow(Player* player, uint32 factionForFollower, Quest const* quest, bool inheritWalkState, bool inheritSpeed)
 {
     if (me->GetVictim())
     {

src/server/game/AI/ScriptedAI/ScriptedFollowerAI.h

@@ -55,7 +55,7 @@ public:
     void UpdateAI(uint32) override;                        //the "internal" update, calls UpdateFollowerAI()
     virtual void UpdateFollowerAI(uint32);        //used when it's needed to add code in update (abilities, scripted events, etc)
 
-    void StartFollow(Player* player, uint32 factionForFollower = 0, const Quest* quest = nullptr, bool inheritWalkState = true, bool inheritSpeed = true);
+    void StartFollow(Player* player, uint32 factionForFollower = 0, Quest const* quest = nullptr, bool inheritWalkState = true, bool inheritSpeed = true);
 
     void SetFollowPaused(bool bPaused);                 //if special event require follow mode to hold/resume during the follow
     void SetFollowComplete(bool bWithEndEvent = false);
@@ -75,7 +75,7 @@ private:
     uint32 m_uiUpdateFollowTimer;
     uint32 m_uiFollowState;
 
-    const Quest* m_pQuestForFollow;                     //normally we have a quest
+    Quest const* m_pQuestForFollow;                     //normally we have a quest
 };
 
 #endif

src/server/game/AI/SmartScripts/SmartAI.cpp

@@ -1151,7 +1151,7 @@ void SmartAI::sGossipSelect(Player* player, uint32 sender, uint32 action)
     GetScript()->ProcessEventsFor(SMART_EVENT_GOSSIP_SELECT, player, sender, action);
 }
 
-void SmartAI::sGossipSelectCode(Player* /*player*/, uint32 /*sender*/, uint32 /*action*/, const char* /*code*/)
+void SmartAI::sGossipSelectCode(Player* /*player*/, uint32 /*sender*/, uint32 /*action*/, char const* /*code*/)
 {
 }
 
@@ -1404,7 +1404,7 @@ bool SmartGameObjectAI::GossipSelect(Player* player, uint32 sender, uint32 actio
 }
 
 // Called when a player selects a gossip with a code in the gameobject's gossip menu.
-bool SmartGameObjectAI::GossipSelectCode(Player* /*player*/, uint32 /*sender*/, uint32 /*action*/, const char* /*code*/)
+bool SmartGameObjectAI::GossipSelectCode(Player* /*player*/, uint32 /*sender*/, uint32 /*action*/, char const* /*code*/)
 {
     return false;
 }

src/server/game/AI/SmartScripts/SmartAI.h

@@ -190,7 +190,7 @@ public:
 
     void sGossipHello(Player* player) override;
     void sGossipSelect(Player* player, uint32 sender, uint32 action) override;
-    void sGossipSelectCode(Player* player, uint32 sender, uint32 action, const char* code) override;
+    void sGossipSelectCode(Player* player, uint32 sender, uint32 action, char const* code) override;
     void sQuestAccept(Player* player, Quest const* quest) override;
     //void sQuestSelect(Player* player, Quest const* quest);
     //void sQuestComplete(Player* player, Quest const* quest);
@@ -298,7 +298,7 @@ public:
 
     bool GossipHello(Player* player, bool reportUse) override;
     bool GossipSelect(Player* player, uint32 sender, uint32 action) override;
-    bool GossipSelectCode(Player* /*player*/, uint32 /*sender*/, uint32 /*action*/, const char* /*code*/) override;
+    bool GossipSelectCode(Player* /*player*/, uint32 /*sender*/, uint32 /*action*/, char const* /*code*/) override;
     bool QuestAccept(Player* player, Quest const* quest) override;
     bool QuestReward(Player* player, Quest const* quest, uint32 opt) override;
     void Destroyed(Player* player, uint32 eventId) override;

src/server/game/Achievements/AchievementMgr.cpp

@@ -1085,7 +1085,7 @@ void AchievementMgr::UpdateAchievementCriteria(AchievementCriteriaTypes type, ui
 
                     uint32 counter = 0;
 
-                    const RewardedQuestSet& rewQuests = GetPlayer()->getRewardedQuests();
+                    RewardedQuestSet const& rewQuests = GetPlayer()->getRewardedQuests();
                     for (RewardedQuestSet::const_iterator itr = rewQuests.begin(); itr != rewQuests.end(); ++itr)
                     {
                         Quest const* quest = sObjectMgr->GetQuestTemplate(*itr);
@@ -2186,7 +2186,7 @@ void AchievementMgr::SetCriteriaProgress(AchievementCriteriaEntry const* entry,
     sScriptMgr->OnPlayerCriteriaProgress(GetPlayer(), entry);
 }
 
-void AchievementMgr::RemoveCriteriaProgress(const AchievementCriteriaEntry* entry)
+void AchievementMgr::RemoveCriteriaProgress(AchievementCriteriaEntry const* entry)
 {
     CriteriaProgressMap::iterator criteriaProgress = _criteriaProgress.find(entry->ID);
     if (criteriaProgress == _criteriaProgress.end())
@@ -2974,7 +2974,7 @@ void AchievementGlobalMgr::LoadCompletedAchievements()
         Field* fields = result->Fetch();
 
         uint16 achievementId = fields[0].Get<uint16>();
-        const AchievementEntry* achievement = sAchievementStore.LookupEntry(achievementId);
+        AchievementEntry const* achievement = sAchievementStore.LookupEntry(achievementId);
         if (!achievement)
         {
             // Remove non existent achievements from all characters

src/server/game/Addons/AddonMgr.cpp

@@ -104,7 +104,7 @@ namespace AddonMgr
         m_knownAddons.emplace_back(addon.Name, addon.CRC);
     }
 
-    SavedAddon const* GetAddonInfo(const std::string& name)
+    SavedAddon const* GetAddonInfo(std::string const& name)
     {
         for (auto const& addon : m_knownAddons)
         {

src/server/game/Addons/AddonMgr.h

@@ -60,7 +60,7 @@ namespace AddonMgr
 {
     void LoadFromDB();
     void SaveAddon(AddonInfo const& addon);
-    SavedAddon const* GetAddonInfo(const std::string& name);
+    SavedAddon const* GetAddonInfo(std::string const& name);
 
     typedef std::list<BannedAddon> BannedAddonList;
     BannedAddonList const* GetBannedAddons();

src/server/game/ArenaSpectator/ArenaSpectator.cpp

@@ -113,7 +113,7 @@ bool ArenaSpectator::HandleSpectatorSpectateCommand(ChatHandler* handler, std::s
     if (!player->m_Controlled.empty())
         errors.push_back("Can't be controlling creatures.");
 
-    const Unit::VisibleAuraMap* va = player->GetVisibleAuras();
+    Unit::VisibleAuraMap const* va = player->GetVisibleAuras();
     for (auto itr = va->begin(); itr != va->end(); ++itr)
         if (Aura* aura = itr->second->GetBase())
             if (!itr->second->IsPositive() && !aura->IsPermanent() && aura->GetDuration() < HOUR * IN_MILLISECONDS)
@@ -310,7 +310,7 @@ AC_GAME_API void ArenaSpectator::SendPacketTo(Player const* player, std::string&
 }
 
 template<>
-AC_GAME_API void ArenaSpectator::SendPacketTo(const Map* map, std::string&& message)
+AC_GAME_API void ArenaSpectator::SendPacketTo(Map const* map, std::string&& message)
 {
     if (!map->IsBattleArena())
         return;

src/server/game/ArenaSpectator/ArenaSpectator.h

@@ -41,7 +41,7 @@ class WorldPacket;
 namespace ArenaSpectator
 {
     template<class T>
-    AC_GAME_API void SendPacketTo(const T* object, std::string&& message);
+    AC_GAME_API void SendPacketTo(T const* object, std::string&& message);
 
     template<class T, typename Format, typename... Args>
     inline void SendCommand(T* o, Format&& fmt, Args&& ... args)
@@ -50,7 +50,7 @@ namespace ArenaSpectator
     }
 
     template<class T>
-    inline void SendCommand_String(T* o, ObjectGuid targetGUID, const char* prefix, const char* c)
+    inline void SendCommand_String(T* o, ObjectGuid targetGUID, char const* prefix, char const* c)
     {
         if (!targetGUID.IsPlayer())
             return;
@@ -59,7 +59,7 @@ namespace ArenaSpectator
     }
 
     template<class T>
-    inline void SendCommand_UInt32Value(T* o, ObjectGuid targetGUID, const char* prefix, uint32 t)
+    inline void SendCommand_UInt32Value(T* o, ObjectGuid targetGUID, char const* prefix, uint32 t)
     {
         if (!targetGUID.IsPlayer())
             return;
@@ -68,7 +68,7 @@ namespace ArenaSpectator
     }
 
     template<class T>
-    inline void SendCommand_GUID(T* o, ObjectGuid targetGUID, const char* prefix, ObjectGuid t)
+    inline void SendCommand_GUID(T* o, ObjectGuid targetGUID, char const* prefix, ObjectGuid t)
     {
         if (!targetGUID.IsPlayer())
             return;
@@ -77,7 +77,7 @@ namespace ArenaSpectator
     }
 
     template<class T>
-    inline void SendCommand_Spell(T* o, ObjectGuid targetGUID, const char* prefix, uint32 id, int32 casttime)
+    inline void SendCommand_Spell(T* o, ObjectGuid targetGUID, char const* prefix, uint32 id, int32 casttime)
     {
         if (!targetGUID.IsPlayer())
             return;
@@ -86,7 +86,7 @@ namespace ArenaSpectator
     }
 
     template<class T>
-    inline void SendCommand_Cooldown(T* o, ObjectGuid targetGUID, const char* prefix, uint32 id, uint32 dur, uint32 maxdur)
+    inline void SendCommand_Cooldown(T* o, ObjectGuid targetGUID, char const* prefix, uint32 id, uint32 dur, uint32 maxdur)
     {
         if (!targetGUID.IsPlayer())
             return;
@@ -99,7 +99,7 @@ namespace ArenaSpectator
     }
 
     template<class T>
-    inline void SendCommand_Aura(T* o, ObjectGuid targetGUID, const char* prefix, ObjectGuid caster, uint32 id, bool isDebuff, uint32 dispel, int32 dur, int32 maxdur, uint32 stack, bool remove)
+    inline void SendCommand_Aura(T* o, ObjectGuid targetGUID, char const* prefix, ObjectGuid caster, uint32 id, bool isDebuff, uint32 dispel, int32 dur, int32 maxdur, uint32 stack, bool remove)
     {
         if (!targetGUID.IsPlayer())
             return;

src/server/game/Battlegrounds/ArenaSeason/ArenaSeasonMgr.h

@@ -52,7 +52,7 @@ struct ArenaSeasonReward
     ArenaSeasonRewardType type{ARENA_SEASON_REWARD_TYPE_ITEM};
 
     // Used in unit tests.
-    bool operator==(const ArenaSeasonReward& other) const
+    bool operator==(ArenaSeasonReward const& other) const
     {
         return entry == other.entry && type == other.type;
     }
@@ -78,7 +78,7 @@ struct ArenaSeasonRewardGroup
     std::vector<ArenaSeasonReward> achievementRewards;
 
     // Used in unit tests.
-    bool operator==(const ArenaSeasonRewardGroup& other) const
+    bool operator==(ArenaSeasonRewardGroup const& other) const
     {
         return minCriteria == other.minCriteria &&
                maxCriteria == other.maxCriteria &&

src/server/game/Battlegrounds/ArenaSeason/ArenaSeasonRewardsDistributor.cpp

@@ -24,7 +24,7 @@
 
 constexpr float minPctTeamGamesForMemberToGetReward = 30;
 
-void ArenaSeasonTeamRewarderImpl::RewardTeamWithRewardGroup(ArenaTeam *arenaTeam, const ArenaSeasonRewardGroup &rewardGroup)
+void ArenaSeasonTeamRewarderImpl::RewardTeamWithRewardGroup(ArenaTeam *arenaTeam, ArenaSeasonRewardGroup const& rewardGroup)
 {
     RewardWithMail(arenaTeam, rewardGroup);
     RewardWithAchievements(arenaTeam, rewardGroup);

src/server/game/Battlegrounds/ArenaTeam.cpp

@@ -778,7 +778,7 @@ int32 ArenaTeam::GetRatingMod(uint32 ownRating, uint32 opponentRating, bool won
     return (int32)ceil(mod);
 }
 
-void ArenaTeam::FinishGame(int32 mod, const Map* bgMap)
+void ArenaTeam::FinishGame(int32 mod, Map const* bgMap)
 {
     // Rating can only drop to 0
     if (int32(Stats.Rating) + mod < 0)
@@ -808,7 +808,7 @@ void ArenaTeam::FinishGame(int32 mod, const Map* bgMap)
     }
 }
 
-int32 ArenaTeam::WonAgainst(uint32 Own_MMRating, uint32 Opponent_MMRating, int32& rating_change, const Map* bgMap)
+int32 ArenaTeam::WonAgainst(uint32 Own_MMRating, uint32 Opponent_MMRating, int32& rating_change, Map const* bgMap)
 {
     // Called when the team has won
     // Change in Matchmaker rating
@@ -828,7 +828,7 @@ int32 ArenaTeam::WonAgainst(uint32 Own_MMRating, uint32 Opponent_MMRating, int32
     return mod;
 }
 
-int32 ArenaTeam::LostAgainst(uint32 Own_MMRating, uint32 Opponent_MMRating, int32& rating_change, const Map* bgMap)
+int32 ArenaTeam::LostAgainst(uint32 Own_MMRating, uint32 Opponent_MMRating, int32& rating_change, Map const* bgMap)
 {
     // Called when the team has lost
     // Change in Matchmaker Rating
@@ -1013,7 +1013,7 @@ bool ArenaTeam::IsFighting() const
     return false;
 }
 
-ArenaTeamMember* ArenaTeam::GetMember(const std::string& name)
+ArenaTeamMember* ArenaTeam::GetMember(std::string const& name)
 {
     return GetMember(sCharacterCache->GetCharacterGuidByName(name));
 }

src/server/game/Battlegrounds/ArenaTeam.h

@@ -152,7 +152,7 @@ public:
     static uint8 GetReqPlayersForType(uint32 type);
     [[nodiscard]] ObjectGuid GetCaptain() const { return CaptainGuid; }
     [[nodiscard]] std::string const& GetName() const       { return TeamName; }
-    [[nodiscard]] const ArenaTeamStats& GetStats() const { return Stats; }
+    [[nodiscard]] ArenaTeamStats const& GetStats() const { return Stats; }
     void SetArenaTeamStats(ArenaTeamStats& stats) { Stats = stats; }
 
     [[nodiscard]] uint32 GetRating() const          { return Stats.Rating; }
@@ -198,15 +198,15 @@ public:
     int32  GetMatchmakerRatingMod(uint32 ownRating, uint32 opponentRating, bool won);
     int32  GetRatingMod(uint32 ownRating, uint32 opponentRating, bool won);
     float  GetChanceAgainst(uint32 ownRating, uint32 opponentRating);
-    int32  WonAgainst(uint32 Own_MMRating, uint32 Opponent_MMRating, int32& rating_change, const Map* bgMap);
+    int32  WonAgainst(uint32 Own_MMRating, uint32 Opponent_MMRating, int32& rating_change, Map const* bgMap);
     void   MemberWon(Player* player, uint32 againstMatchmakerRating, int32 MatchmakerRatingChange);
-    int32  LostAgainst(uint32 Own_MMRating, uint32 Opponent_MMRating, int32& rating_change, const Map* bgMap);
+    int32  LostAgainst(uint32 Own_MMRating, uint32 Opponent_MMRating, int32& rating_change, Map const* bgMap);
     void   MemberLost(Player* player, uint32 againstMatchmakerRating, int32 MatchmakerRatingChange = -12);
 
     void UpdateArenaPointsHelper(std::map<ObjectGuid, uint32>& PlayerPoints);
 
     bool FinishWeek(); // returns true if arena team played this week
-    void FinishGame(int32 mod, const Map* bgMap);
+    void FinishGame(int32 mod, Map const* bgMap);
 
     void SetPreviousOpponents(uint32 arenaTeamId) { PreviousOpponents = arenaTeamId; }
     uint32 GetPreviousOpponents() { return PreviousOpponents; }

src/server/game/Battlegrounds/ArenaTeamMgr.cpp

@@ -55,7 +55,7 @@ ArenaTeam* ArenaTeamMgr::GetArenaTeamById(uint32 arenaTeamId) const
     return nullptr;
 }
 
-ArenaTeam* ArenaTeamMgr::GetArenaTeamByName(const std::string& arenaTeamName) const
+ArenaTeam* ArenaTeamMgr::GetArenaTeamByName(std::string const& arenaTeamName) const
 {
     std::string search = arenaTeamName;
     std::transform(search.begin(), search.end(), search.begin(), ::toupper);

src/server/game/Battlegrounds/Battleground.h

@@ -404,7 +404,7 @@ public:
     void AddSpectator(Player* p) { m_Spectators.insert(p); }
     void RemoveSpectator(Player* p) { m_Spectators.erase(p); }
     bool HaveSpectators() { return !m_Spectators.empty(); }
-    [[nodiscard]] const SpectatorList& GetSpectators() const { return m_Spectators; }
+    [[nodiscard]] SpectatorList const& GetSpectators() const { return m_Spectators; }
     void AddToBeTeleported(ObjectGuid spectator, ObjectGuid participant) { m_ToBeTeleported[spectator] = participant; }
     void RemoveToBeTeleported(ObjectGuid spectator) { ToBeTeleportedMap::iterator itr = m_ToBeTeleported.find(spectator); if (itr != m_ToBeTeleported.end()) m_ToBeTeleported.erase(itr); }
     void SpectatorsSendPacket(WorldPacket& data);
@@ -456,7 +456,7 @@ public:
     virtual void FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& /*packet*/) { }
     void SendPacketToTeam(TeamId teamId, WorldPacket const* packet, Player* sender = nullptr, bool self = true);
     void SendPacketToAll(WorldPacket const* packet);
-    void YellToAll(Creature* creature, const char* text, uint32 language);
+    void YellToAll(Creature* creature, char const* text, uint32 language);
 
     void SendChatMessage(Creature* source, uint8 textId, WorldObject* target = nullptr);
     void SendBroadcastText(uint32 id, ChatMsg msgType, WorldObject const* target = nullptr);
@@ -576,37 +576,37 @@ public:
     [[nodiscard]] uint8 GetUniqueBracketId() const;
 
     BattlegroundAV* ToBattlegroundAV() { if (GetBgTypeID(true) == BATTLEGROUND_AV) return reinterpret_cast<BattlegroundAV*>(this); else return nullptr; }
-    [[nodiscard]] BattlegroundAV const* ToBattlegroundAV() const { if (GetBgTypeID(true) == BATTLEGROUND_AV) return reinterpret_cast<const BattlegroundAV*>(this); else return nullptr; }
+    [[nodiscard]] BattlegroundAV const* ToBattlegroundAV() const { if (GetBgTypeID(true) == BATTLEGROUND_AV) return reinterpret_cast<BattlegroundAV const*>(this); else return nullptr; }
 
     BattlegroundWS* ToBattlegroundWS() { if (GetBgTypeID(true) == BATTLEGROUND_WS) return reinterpret_cast<BattlegroundWS*>(this); else return nullptr; }
-    [[nodiscard]] BattlegroundWS const* ToBattlegroundWS() const { if (GetBgTypeID(true) == BATTLEGROUND_WS) return reinterpret_cast<const BattlegroundWS*>(this); else return nullptr; }
+    [[nodiscard]] BattlegroundWS const* ToBattlegroundWS() const { if (GetBgTypeID(true) == BATTLEGROUND_WS) return reinterpret_cast<BattlegroundWS const*>(this); else return nullptr; }
 
     BattlegroundAB* ToBattlegroundAB() { if (GetBgTypeID(true) == BATTLEGROUND_AB) return reinterpret_cast<BattlegroundAB*>(this); else return nullptr; }
-    [[nodiscard]] BattlegroundAB const* ToBattlegroundAB() const { if (GetBgTypeID(true) == BATTLEGROUND_AB) return reinterpret_cast<const BattlegroundAB*>(this); else return nullptr; }
+    [[nodiscard]] BattlegroundAB const* ToBattlegroundAB() const { if (GetBgTypeID(true) == BATTLEGROUND_AB) return reinterpret_cast<BattlegroundAB const*>(this); else return nullptr; }
 
     BattlegroundNA* ToBattlegroundNA() { if (GetBgTypeID(true) == BATTLEGROUND_NA) return reinterpret_cast<BattlegroundNA*>(this); else return nullptr; }
-    [[nodiscard]] BattlegroundNA const* ToBattlegroundNA() const { if (GetBgTypeID(true) == BATTLEGROUND_NA) return reinterpret_cast<const BattlegroundNA*>(this); else return nullptr; }
+    [[nodiscard]] BattlegroundNA const* ToBattlegroundNA() const { if (GetBgTypeID(true) == BATTLEGROUND_NA) return reinterpret_cast<BattlegroundNA const*>(this); else return nullptr; }
 
     BattlegroundBE* ToBattlegroundBE() { if (GetBgTypeID(true) == BATTLEGROUND_BE) return reinterpret_cast<BattlegroundBE*>(this); else return nullptr; }
-    [[nodiscard]] BattlegroundBE const* ToBattlegroundBE() const { if (GetBgTypeID(true) == BATTLEGROUND_BE) return reinterpret_cast<const BattlegroundBE*>(this); else return nullptr; }
+    [[nodiscard]] BattlegroundBE const* ToBattlegroundBE() const { if (GetBgTypeID(true) == BATTLEGROUND_BE) return reinterpret_cast<BattlegroundBE const*>(this); else return nullptr; }
 
     BattlegroundEY* ToBattlegroundEY() { if (GetBgTypeID(true) == BATTLEGROUND_EY) return reinterpret_cast<BattlegroundEY*>(this); else return nullptr; }
-    [[nodiscard]] BattlegroundEY const* ToBattlegroundEY() const { if (GetBgTypeID(true) == BATTLEGROUND_EY) return reinterpret_cast<const BattlegroundEY*>(this); else return nullptr; }
+    [[nodiscard]] BattlegroundEY const* ToBattlegroundEY() const { if (GetBgTypeID(true) == BATTLEGROUND_EY) return reinterpret_cast<BattlegroundEY const*>(this); else return nullptr; }
 
     BattlegroundRL* ToBattlegroundRL() { if (GetBgTypeID(true) == BATTLEGROUND_RL) return reinterpret_cast<BattlegroundRL*>(this); else return nullptr; }
-    [[nodiscard]] BattlegroundRL const* ToBattlegroundRL() const { if (GetBgTypeID(true) == BATTLEGROUND_RL) return reinterpret_cast<const BattlegroundRL*>(this); else return nullptr; }
+    [[nodiscard]] BattlegroundRL const* ToBattlegroundRL() const { if (GetBgTypeID(true) == BATTLEGROUND_RL) return reinterpret_cast<BattlegroundRL const*>(this); else return nullptr; }
 
     BattlegroundSA* ToBattlegroundSA() { if (GetBgTypeID(true) == BATTLEGROUND_SA) return reinterpret_cast<BattlegroundSA*>(this); else return nullptr; }
-    [[nodiscard]] BattlegroundSA const* ToBattlegroundSA() const { if (GetBgTypeID(true) == BATTLEGROUND_SA) return reinterpret_cast<const BattlegroundSA*>(this); else return nullptr; }
+    [[nodiscard]] BattlegroundSA const* ToBattlegroundSA() const { if (GetBgTypeID(true) == BATTLEGROUND_SA) return reinterpret_cast<BattlegroundSA const*>(this); else return nullptr; }
 
     BattlegroundDS* ToBattlegroundDS() { if (GetBgTypeID(true) == BATTLEGROUND_DS) return reinterpret_cast<BattlegroundDS*>(this); else return nullptr; }
-    [[nodiscard]] BattlegroundDS const* ToBattlegroundDS() const { if (GetBgTypeID(true) == BATTLEGROUND_DS) return reinterpret_cast<const BattlegroundDS*>(this); else return nullptr; }
+    [[nodiscard]] BattlegroundDS const* ToBattlegroundDS() const { if (GetBgTypeID(true) == BATTLEGROUND_DS) return reinterpret_cast<BattlegroundDS const*>(this); else return nullptr; }
 
     BattlegroundRV* ToBattlegroundRV() { if (GetBgTypeID(true) == BATTLEGROUND_RV) return reinterpret_cast<BattlegroundRV*>(this); else return nullptr; }
-    [[nodiscard]] BattlegroundRV const* ToBattlegroundRV() const { if (GetBgTypeID(true) == BATTLEGROUND_RV) return reinterpret_cast<const BattlegroundRV*>(this); else return nullptr; }
+    [[nodiscard]] BattlegroundRV const* ToBattlegroundRV() const { if (GetBgTypeID(true) == BATTLEGROUND_RV) return reinterpret_cast<BattlegroundRV const*>(this); else return nullptr; }
 
     BattlegroundIC* ToBattlegroundIC() { if (GetBgTypeID(true) == BATTLEGROUND_IC) return reinterpret_cast<BattlegroundIC*>(this); else return nullptr; }
-    [[nodiscard]] BattlegroundIC const* ToBattlegroundIC() const { if (GetBgTypeID(true) == BATTLEGROUND_IC) return reinterpret_cast<const BattlegroundIC*>(this); else return nullptr; }
+    [[nodiscard]] BattlegroundIC const* ToBattlegroundIC() const { if (GetBgTypeID(true) == BATTLEGROUND_IC) return reinterpret_cast<BattlegroundIC const*>(this); else return nullptr; }
 
 protected:
     // this method is called, when BG cannot spawn its own spirit guide, or something is wrong, It correctly ends Battleground

src/server/game/Battlegrounds/BattlegroundMgr.cpp

@@ -343,7 +343,7 @@ std::vector<Battleground const*> BattlegroundMgr::GetActiveBattlegrounds()
     for (auto const& [bgType, bgData] : bgDataStore)
         for (auto const& [id, bg] : bgData._Battlegrounds)
             if (bg->GetStatus() == STATUS_WAIT_JOIN || bg->GetStatus() == STATUS_IN_PROGRESS)
-                result.push_back(static_cast<const Battleground*>(bg));
+                result.push_back(static_cast<Battleground const*>(bg));
 
     return result;
 }

src/server/game/Battlegrounds/Zones/BattlegroundEY.cpp

@@ -135,7 +135,7 @@ void BattlegroundEY::UpdatePointsState()
         _capturePointInfo[point]._playersCount[TEAM_HORDE] = 0;
     }
 
-    const BattlegroundPlayerMap& bgPlayerMap = GetPlayers();
+    BattlegroundPlayerMap const& bgPlayerMap = GetPlayers();
     for (BattlegroundPlayerMap::const_iterator itr = bgPlayerMap.begin(); itr != bgPlayerMap.end(); ++itr)
     {
         itr->second->SendUpdateWorldState(WORLD_STATE_BATTLEGROUND_EY_PROGRESS_BAR_SHOW, BG_EY_PROGRESS_BAR_DONT_SHOW);

src/server/game/Calendar/CalendarMgr.h

@@ -171,7 +171,7 @@ public:
     void SetStatusTime(time_t statusTime) { _statusTime = statusTime; }
     time_t GetStatusTime() const { return _statusTime; }
 
-    void SetText(const std::string& text) { _text = text; }
+    void SetText(std::string const& text) { _text = text; }
     std::string GetText() const { return _text; }
 
     void SetStatus(CalendarInviteStatus status) { _status = status; }
@@ -228,10 +228,10 @@ public:
     void SetGuildId(uint32 guildId) { _guildId = guildId; }
     uint32 GetGuildId() const { return _guildId; }
 
-    void SetTitle(const std::string& title) { _title = title; }
+    void SetTitle(std::string const& title) { _title = title; }
     std::string GetTitle() const { return _title; }
 
-    void SetDescription(const std::string& description) { _description = description; }
+    void SetDescription(std::string const& description) { _description = description; }
     std::string GetDescription() const { return _description; }
 
     void SetType(CalendarEventType type) { _type = type; }

src/server/game/Chat/Channels/Channel.cpp

@@ -1083,7 +1083,7 @@ void Channel::MakePlayerUnbanned(WorldPacket* data, ObjectGuid bad, ObjectGuid g
     *data << good;
 }
 
-void Channel::MakePlayerNotBanned(WorldPacket* data, const std::string& name)
+void Channel::MakePlayerNotBanned(WorldPacket* data, std::string const& name)
 {
     MakeNotifyPacket(data, CHAT_PLAYER_NOT_BANNED_NOTICE);
     *data << name;
@@ -1121,13 +1121,13 @@ void Channel::MakeNotModerated(WorldPacket* data)
     MakeNotifyPacket(data, CHAT_NOT_MODERATED_NOTICE);
 }
 
-void Channel::MakePlayerInvited(WorldPacket* data, const std::string& name)
+void Channel::MakePlayerInvited(WorldPacket* data, std::string const& name)
 {
     MakeNotifyPacket(data, CHAT_PLAYER_INVITED_NOTICE);
     *data << name;
 }
 
-void Channel::MakePlayerInviteBanned(WorldPacket* data, const std::string& name)
+void Channel::MakePlayerInviteBanned(WorldPacket* data, std::string const& name)
 {
     MakeNotifyPacket(data, CHAT_PLAYER_INVITE_BANNED_NOTICE);
     *data << name;

src/server/game/Chat/Channels/Channel.h

@@ -119,7 +119,7 @@ class ChannelRights
 {
 public:
     ChannelRights()  = default;
-    ChannelRights(const uint32& f, const uint32& d, std::string  jm, std::string  sm, std::set<uint32>  ml) : flags(f), speakDelay(d), joinMessage(std::move(jm)), speakMessage(std::move(sm)), moderators(std::move(ml)) {}
+    ChannelRights(uint32 const& f, uint32 const& d, std::string  jm, std::string  sm, std::set<uint32>  ml) : flags(f), speakDelay(d), joinMessage(std::move(jm)), speakMessage(std::move(sm)), moderators(std::move(ml)) {}
     uint32 flags{0};
     uint32 speakDelay{0};
     std::string joinMessage;

src/server/game/Chat/Channels/ChannelMgr.cpp

@@ -205,7 +205,7 @@ void ChannelMgr::LoadChannelRights()
     LOG_INFO("server.loading", " ");
 }
 
-const ChannelRights& ChannelMgr::GetChannelRightsFor(const std::string& name)
+ChannelRights const& ChannelMgr::GetChannelRightsFor(std::string const& name)
 {
     std::string nameStr = name;
     std::transform(nameStr.begin(), nameStr.end(), nameStr.begin(), ::tolower);
@@ -215,7 +215,7 @@ const ChannelRights& ChannelMgr::GetChannelRightsFor(const std::string& name)
     return channelRightsEmpty;
 }
 
-void ChannelMgr::SetChannelRightsFor(const std::string& name, const uint32& flags, const uint32& speakDelay, const std::string& joinmessage, const std::string& speakmessage, const std::set<uint32>& moderators)
+void ChannelMgr::SetChannelRightsFor(std::string const& name, uint32 const& flags, uint32 const& speakDelay, std::string const& joinmessage, std::string const& speakmessage, std::set<uint32> const& moderators)
 {
     std::string nameStr = name;
     std::transform(nameStr.begin(), nameStr.end(), nameStr.begin(), ::tolower);

src/server/game/Chat/Channels/ChannelMgr.h

@@ -43,8 +43,8 @@ public:
     static void LoadChannels();
 
     static void LoadChannelRights();
-    static const ChannelRights& GetChannelRightsFor(const std::string& name);
-    static void SetChannelRightsFor(const std::string& name, const uint32& flags, const uint32& speakDelay, const std::string& joinmessage, const std::string& speakmessage, const std::set<uint32>& moderators);
+    static ChannelRights const& GetChannelRightsFor(std::string const& name);
+    static void SetChannelRightsFor(std::string const& name, uint32 const& flags, uint32 const& speakDelay, std::string const& joinmessage, std::string const& speakmessage, std::set<uint32> const& moderators);
     static uint32 _channelIdMax;
 
 private:

src/server/game/Chat/Chat.cpp

@@ -191,7 +191,7 @@ void ChatHandler::SendSysMessage(std::string_view str, bool escapeCharacters)
     }
 }
 
-void ChatHandler::SendGlobalSysMessage(const char* str)
+void ChatHandler::SendGlobalSysMessage(char const* str)
 {
     WorldPacket data;
     for (std::string_view line : Acore::Tokenize(str, '\n', true))
@@ -201,7 +201,7 @@ void ChatHandler::SendGlobalSysMessage(const char* str)
     }
 }
 
-void ChatHandler::SendGlobalGMSysMessage(const char* str)
+void ChatHandler::SendGlobalGMSysMessage(char const* str)
 {
     WorldPacket data;
     for (std::string_view line : Acore::Tokenize(str, '\n', true))
@@ -928,7 +928,7 @@ bool CliHandler::needReportToTarget(Player* /*chr*/) const
     return true;
 }
 
-bool ChatHandler::GetPlayerGroupAndGUIDByName(const char* cname, Player*& player, Group*& group, ObjectGuid& guid, bool offline)
+bool ChatHandler::GetPlayerGroupAndGUIDByName(char const* cname, Player*& player, Group*& group, ObjectGuid& guid, bool offline)
 {
     player = nullptr;
     guid = ObjectGuid::Empty;

src/server/game/Chat/Chat.h

@@ -191,7 +191,7 @@ public:
     bool _ParseCommands(std::string_view text);
     virtual bool ParseCommands(std::string_view text);
 
-    void SendGlobalSysMessage(const char* str);
+    void SendGlobalSysMessage(char const* str);
 
     // function with different implementation for chat/console
     virtual bool IsHumanReadable() const { return true; }
@@ -203,7 +203,7 @@ public:
     bool HasLowerSecurity(Player* target, ObjectGuid guid = ObjectGuid::Empty, bool strong = false);
     bool HasLowerSecurityAccount(WorldSession* target, uint32 account, bool strong = false);
 
-    void SendGlobalGMSysMessage(const char* str);
+    void SendGlobalGMSysMessage(char const* str);
     Player* getSelectedPlayer() const;
     Creature* getSelectedCreature() const;
     Unit* getSelectedUnit() const;
@@ -223,7 +223,7 @@ public:
 
     uint32    extractSpellIdFromLink(char* text);
     ObjectGuid::LowType extractLowGuidFromLink(char* text, HighGuid& guidHigh);
-    bool GetPlayerGroupAndGUIDByName(const char* cname, Player*& player, Group*& group, ObjectGuid& guid, bool offline = false);
+    bool GetPlayerGroupAndGUIDByName(char const* cname, Player*& player, Group*& group, ObjectGuid& guid, bool offline = false);
     std::string extractPlayerNameFromLink(char* text);
     // select by arg (name/link) or in-game selection online/offline player
     bool extractPlayerTarget(char* args, Player** player, ObjectGuid* player_guid = nullptr, std::string* player_name = nullptr);

src/server/game/Conditions/ConditionMgr.cpp

@@ -217,7 +217,7 @@ bool Condition::Meets(ConditionSourceInfo& sourceInfo)
             if (Player* player = unit->GetCharmerOrOwnerPlayerOrPlayerItself())
             {
                 // Xinef: cannot be null, checked at loading
-                const Quest* quest = sObjectMgr->GetQuestTemplate(ConditionValue1);
+                Quest const* quest = sObjectMgr->GetQuestTemplate(ConditionValue1);
                 condMeets = !player->IsQuestRewarded(ConditionValue1) && player->SatisfyQuestExclusiveGroup(quest, false);
             }
         }
@@ -1083,7 +1083,7 @@ ConditionList ConditionMgr::GetConditionsForNpcVendorEvent(uint32 creatureId, ui
     return cond;
 }
 
-ConditionList ConditionMgr::GetConditionsForObjectVisibility(const WorldObject* object) const
+ConditionList ConditionMgr::GetConditionsForObjectVisibility(WorldObject const* object) const
 {
     ConditionList cond;
 
@@ -1199,7 +1199,7 @@ void ConditionMgr::LoadConditions(bool isReload)
             }
             cond->ReferenceId = uint32(std::abs(iConditionTypeOrReference));
 
-            const char* rowType = "reference template";
+            char const* rowType = "reference template";
             if (iSourceTypeOrReferenceId >= 0)
                 rowType = "reference";
             // check for useless data
@@ -2546,7 +2546,7 @@ bool ConditionMgr::isConditionTypeValid(Condition* cond)
     }
     case CONDITION_QUEST_OBJECTIVE_PROGRESS:
     {
-        const Quest* quest = sObjectMgr->GetQuestTemplate(cond->ConditionValue1);
+        Quest const* quest = sObjectMgr->GetQuestTemplate(cond->ConditionValue1);
         if (!quest)
         {
             LOG_ERROR("sql.sql", "CONDITION_QUEST_OBJECTIVE_PROGRESS points to non-existing quest ({}), skipped.", cond->ConditionValue1);

src/server/game/Conditions/ConditionMgr.h

@@ -271,7 +271,7 @@ public:
     ConditionList GetConditionsForSmartEvent(int32 entryOrGuid, uint32 eventId, uint32 sourceType);
     ConditionList GetConditionsForVehicleSpell(uint32 creatureId, uint32 spellId);
     ConditionList GetConditionsForNpcVendorEvent(uint32 creatureId, uint32 itemId);
-    ConditionList GetConditionsForObjectVisibility(const WorldObject* object) const;
+    ConditionList GetConditionsForObjectVisibility(WorldObject const* object) const;
 
 private:
     bool isSourceTypeValid(Condition* cond);

src/server/game/DataStores/DBCStores.cpp

@@ -201,7 +201,7 @@ typedef std::list<std::string> StoreProblemList;
 
 uint32 DBCFileCount = 0;
 
-static bool LoadDBC_assert_print(uint32 fsize, uint32 rsize, const std::string& filename)
+static bool LoadDBC_assert_print(uint32 fsize, uint32 rsize, std::string const& filename)
 {
     LOG_ERROR("dbc", "Size of '{}' set by format string ({}) not equal size of C++ structure ({}).", filename, fsize, rsize);
 
@@ -258,7 +258,7 @@ inline void LoadDBC(uint32& availableDbcLocales, StoreProblemList& errors, DBCSt
     }
 }
 
-void LoadDBCStores(const std::string& dataPath)
+void LoadDBCStores(std::string const& dataPath)
 {
     uint32 oldMSTime = getMSTime();
 
@@ -913,7 +913,7 @@ SkillRaceClassInfoEntry const* GetSkillRaceClassInfo(uint32 skill, uint8 race, u
     return nullptr;
 }
 
-const std::vector<SkillLineAbilityEntry const*>& GetSkillLineAbilitiesBySkillLine(uint32 skillLine)
+std::vector<SkillLineAbilityEntry const*> const& GetSkillLineAbilitiesBySkillLine(uint32 skillLine)
 {
     auto it = sSkillLineAbilityIndexBySkillLine.find(skillLine);
     if (it == sSkillLineAbilityIndexBySkillLine.end())

src/server/game/DataStores/DBCStores.h

@@ -73,7 +73,7 @@ typedef std::pair<SkillRaceClassInfoMap::iterator, SkillRaceClassInfoMap::iterat
 SkillRaceClassInfoEntry const* GetSkillRaceClassInfo(uint32 skill, uint8 race, uint8 class_);
 
 typedef std::unordered_map<uint32 /* SkillLine */, std::vector<SkillLineAbilityEntry const*> > SkillLineAbilityIndexBySkillLine;
-const std::vector<SkillLineAbilityEntry const*>& GetSkillLineAbilitiesBySkillLine(uint32 skillLine);
+std::vector<SkillLineAbilityEntry const*> const& GetSkillLineAbilitiesBySkillLine(uint32 skillLine);
 
 extern DBCStorage <AchievementEntry>             sAchievementStore;
 extern DBCStorage <AchievementCriteriaEntry>     sAchievementCriteriaStore;
@@ -194,6 +194,6 @@ extern DBCStorage <WMOAreaTableEntry>            sWMOAreaTableStore;
 //extern DBCStorage <WorldMapAreaEntry>           sWorldMapAreaStore; -- use Zone2MapCoordinates and Map2ZoneCoordinates
 extern DBCStorage <WorldMapOverlayEntry>         sWorldMapOverlayStore;
 
-void LoadDBCStores(const std::string& dataPath);
+void LoadDBCStores(std::string const& dataPath);
 
 #endif

src/server/game/DungeonFinding/LFG.h

@@ -182,7 +182,7 @@ namespace lfg
             return 0;
         }
 
-        void insert(const ObjectGuid& g)
+        void insert(ObjectGuid const& g)
         {
             // avoid loops for performance
             if (!guids[0])
@@ -273,7 +273,7 @@ namespace lfg
             guids[4] = g;
         }
 
-        void force_insert_front(const ObjectGuid& g)
+        void force_insert_front(ObjectGuid const& g)
         {
             if (guids[3])
             {
@@ -294,7 +294,7 @@ namespace lfg
             guids[0] = g;
         }
 
-        void remove(const ObjectGuid& g)
+        void remove(ObjectGuid const& g)
         {
             // avoid loops for performance
             if (guids[0] == g)
@@ -427,12 +427,12 @@ namespace lfg
             }
         }
 
-        [[nodiscard]] bool hasGuid(const ObjectGuid& g) const
+        [[nodiscard]] bool hasGuid(ObjectGuid const& g) const
         {
             return g && (guids[0] == g || guids[1] == g || guids[2] == g || guids[3] == g || guids[4] == g);
         }
 
-        bool operator<(const Lfg5Guids& x) const
+        bool operator<(Lfg5Guids const& x) const
         {
             if (guids[0] <= x.guids[0])
             {
@@ -474,12 +474,12 @@ namespace lfg
             return false;
         }
 
-        bool operator==(const Lfg5Guids& x) const
+        bool operator==(Lfg5Guids const& x) const
         {
             return guids[0] == x.guids[0] && guids[1] == x.guids[1] && guids[2] == x.guids[2] && guids[3] == x.guids[3] && guids[4] == x.guids[4];
         }
 
-        void operator=(const Lfg5Guids& x)
+        void operator=(Lfg5Guids const& x)
         {
             guids = x.guids;
             delete roles;

src/server/game/DungeonFinding/LFGMgr.cpp

@@ -513,7 +513,7 @@ namespace lfg
             else if (ar)
             {
                 // Check required items
-                for (const ProgressionRequirement* itemRequirement : ar->items)
+                for (ProgressionRequirement const* itemRequirement : ar->items)
                 {
                     if (!itemRequirement->checkLeaderOnly || !group || group->GetLeaderGUID() == player->GetGUID())
                     {
@@ -529,7 +529,7 @@ namespace lfg
                 }
 
                 //Check for quests
-                for (const ProgressionRequirement* questRequirement : ar->quests)
+                for (ProgressionRequirement const* questRequirement : ar->quests)
                 {
                     if (!questRequirement->checkLeaderOnly || !group || group->GetLeaderGUID() == player->GetGUID())
                     {
@@ -551,7 +551,7 @@ namespace lfg
                 }
 
                 //Check if player has the required achievements
-                for (const ProgressionRequirement* achievementRequirement : ar->achievements)
+                for (ProgressionRequirement const* achievementRequirement : ar->achievements)
                 {
                     if (!achievementRequirement->checkLeaderOnly || !group || group->GetLeaderGUID() == player->GetGUID())
                     {
@@ -595,7 +595,7 @@ namespace lfg
        @param[in]     dungeons Dungeons the player/group is applying for
        @param[in]     comment Player selected comment
     */
-    void LFGMgr::JoinLfg(Player* player, uint8 roles, LfgDungeonSet& dungeons, const std::string& comment)
+    void LFGMgr::JoinLfg(Player* player, uint8 roles, LfgDungeonSet& dungeons, std::string const& comment)
     {
         if (!player || dungeons.empty())
             return;
@@ -919,7 +919,7 @@ namespace lfg
                     queue.RemoveFromQueue(gguid);
                     uint32 dungeonId = GetDungeon(gguid);
                     SetState(gguid, LFG_STATE_NONE);
-                    const LfgGuidSet& players = GetPlayers(gguid);
+                    LfgGuidSet const& players = GetPlayers(gguid);
                     for (LfgGuidSet::const_iterator it = players.begin(); it != players.end(); ++it)
                     {
                         SetState(*it, LFG_STATE_NONE);
@@ -1318,7 +1318,7 @@ namespace lfg
         }
     }
 
-    void LFGMgr::RBPacketAppendGroup(const RBInternalInfo& info, ByteBuffer& buffer)
+    void LFGMgr::RBPacketAppendGroup(RBInternalInfo const& info, ByteBuffer& buffer)
     {
         buffer << info.groupGuid;
         uint32 flags = LFG_UPDATE_FLAG_COMMENT | LFG_UPDATE_FLAG_ROLES | LFG_UPDATE_FLAG_BINDED;
@@ -1334,7 +1334,7 @@ namespace lfg
         buffer << (uint32)info.encounterMask;
     }
 
-    void LFGMgr::RBPacketAppendPlayer(const RBInternalInfo& info, ByteBuffer& buffer)
+    void LFGMgr::RBPacketAppendPlayer(RBInternalInfo const& info, ByteBuffer& buffer)
     {
         buffer << info.guid;
         uint32 flags = LFG_UPDATE_FLAG_CHARACTERINFO | LFG_UPDATE_FLAG_ROLES | LFG_UPDATE_FLAG_COMMENT | (info.groupGuid ? LFG_UPDATE_FLAG_GROUPGUID : LFG_UPDATE_FLAG_BINDED) | (info.isGroupLeader ? LFG_UPDATE_FLAG_GROUPLEADER : 0) | (!info.groupGuid || info.isGroupLeader ? LFG_UPDATE_FLAG_AREA : 0);
@@ -1467,7 +1467,7 @@ namespace lfg
             if (GetState(gguid) == LFG_STATE_QUEUED)
             {
                 SetState(gguid, LFG_STATE_NONE);
-                const LfgGuidSet& players = GetPlayers(gguid);
+                LfgGuidSet const& players = GetPlayers(gguid);
                 for (LfgGuidSet::const_iterator it = players.begin(); it != players.end(); ++it)
                 {
                     SetState(*it, LFG_STATE_NONE);
@@ -2315,7 +2315,7 @@ namespace lfg
        @param[in]     guid Group guid
        @param[in]     dungeonId Dungeonid
     */
-    void LFGMgr::FinishDungeon(ObjectGuid gguid, const uint32 dungeonId, const Map* currMap)
+    void LFGMgr::FinishDungeon(ObjectGuid gguid, const uint32 dungeonId, Map const* currMap)
     {
         uint32 gDungeonId = GetDungeon(gguid);
         if (gDungeonId != dungeonId)
@@ -2333,7 +2333,7 @@ namespace lfg
         SetState(gguid, LFG_STATE_FINISHED_DUNGEON);
         _SaveToDB(gguid); // pussywizard
 
-        const LfgGuidSet& players = GetPlayers(gguid);
+        LfgGuidSet const& players = GetPlayers(gguid);
         for (LfgGuidSet::const_iterator it = players.begin(); it != players.end(); ++it)
         {
             ObjectGuid guid = (*it);
@@ -2344,7 +2344,7 @@ namespace lfg
             }
 
             uint32 rDungeonId = 0;
-            const LfgDungeonSet& dungeons = GetSelectedDungeons(guid);
+            LfgDungeonSet const& dungeons = GetSelectedDungeons(guid);
             if (!dungeons.empty())
                 rDungeonId = (*dungeons.begin());
 
@@ -2522,7 +2522,7 @@ namespace lfg
         return roles;
     }
 
-    const std::string& LFGMgr::GetComment(ObjectGuid guid)
+    std::string const& LFGMgr::GetComment(ObjectGuid guid)
     {
         LOG_DEBUG("lfg", "LFGMgr::GetComment: [{}] = {}", guid.ToString(), PlayersStore[guid].GetComment());
         return PlayersStore[guid].GetComment();
@@ -2692,7 +2692,7 @@ namespace lfg
 
     void LFGMgr::AddPlayerQueuedForRandomDungeonToGroup(ObjectGuid gguid, ObjectGuid guid)
     {
-        const LfgDungeonSet& dungeons = GetSelectedDungeons(guid);
+        LfgDungeonSet const& dungeons = GetSelectedDungeons(guid);
         if (dungeons.empty())
             return;
 

src/server/game/DungeonFinding/LFGMgr.h

@@ -446,7 +446,7 @@ namespace lfg
 
         // World.cpp
         /// Finish the dungeon for the given group. All check are performed using internal lfg data
-        void FinishDungeon(ObjectGuid gguid, uint32 dungeonId, const Map* currMap);
+        void FinishDungeon(ObjectGuid gguid, uint32 dungeonId, Map const* currMap);
         /// Loads rewards for random dungeons
         void LoadRewards();
         /// Loads dungeons from dbc and adds teleport coords
@@ -561,8 +561,8 @@ namespace lfg
         void UpdateRaidBrowser(uint32 diff);
         void LfrSetComment(Player* p, std::string comment);
         void SendRaidBrowserJoinedPacket(Player* p, LfgDungeonSet& dungeons, std::string comment);
-        void RBPacketAppendGroup(const RBInternalInfo& info, ByteBuffer& buffer);
-        void RBPacketAppendPlayer(const RBInternalInfo& info, ByteBuffer& buffer);
+        void RBPacketAppendGroup(RBInternalInfo const& info, ByteBuffer& buffer);
+        void RBPacketAppendPlayer(RBInternalInfo const& info, ByteBuffer& buffer);
         void RBPacketBuildDifference(WorldPacket& differencePacket, uint32 dungeonId, uint32 deletedCounter, ByteBuffer const& bufferDeleted, uint32 groupCounter, ByteBuffer const& bufferGroups, uint32 playerCounter, ByteBuffer const& bufferPlayers);
         void RBPacketBuildFull(WorldPacket& fullPacket, uint32 dungeonId, RBInternalInfoMap const& infoMap);
 

src/server/game/DungeonFinding/LFGPlayerData.cpp

@@ -112,7 +112,7 @@ namespace lfg
         return m_OldState;
     }
 
-    const LfgLockMap& LfgPlayerData::GetLockedDungeons() const
+    LfgLockMap const& LfgPlayerData::GetLockedDungeons() const
     {
         return m_LockedDungeons;
     }

src/server/game/DungeonFinding/LFGPlayerData.h

@@ -45,7 +45,7 @@ namespace lfg
         // Queue
         void SetRoles(uint8 roles);
         void SetComment(std::string const& comment);
-        void SetSelectedDungeons(const LfgDungeonSet& dungeons);
+        void SetSelectedDungeons(LfgDungeonSet const& dungeons);
 
         // General
         [[nodiscard]] LfgState GetState() const;

src/server/game/DungeonFinding/LFGQueue.cpp

@@ -194,7 +194,7 @@ namespace lfg
         return newGroupsProcessed;
     }
 
-    LfgCompatibility LFGQueue::FindNewGroups(const ObjectGuid& newGuid)
+    LfgCompatibility LFGQueue::FindNewGroups(ObjectGuid const& newGuid)
     {
         // each combination of dps+heal+tank (tank*8 + heal+4 + dps) has a value assigned 0..15
         // first 16 bits of the mask are for marking if such combination was found once, second 16 bits for marking second occurence of that combination, etc
@@ -243,7 +243,7 @@ namespace lfg
         return selfCompatibility;
     }
 
-    LfgCompatibility LFGQueue::CheckCompatibility(Lfg5Guids const& checkWith, const ObjectGuid& newGuid, uint64& foundMask, uint32& foundCount, const std::set<Lfg5Guids>& currentCompatibles)
+    LfgCompatibility LFGQueue::CheckCompatibility(Lfg5Guids const& checkWith, ObjectGuid const& newGuid, uint64& foundMask, uint32& foundCount, std::set<Lfg5Guids> const& currentCompatibles)
     {
         LOG_DEBUG("lfg", "CHECK CheckCompatibility: {}, new guid: {}", checkWith.toString(), newGuid.ToString());
         Lfg5Guids check(checkWith, false); // here newGuid is at front
@@ -315,7 +315,7 @@ namespace lfg
         {
             for (uint8 i = 0; i < 5 && check.guids[i]; ++i)
             {
-                const LfgRolesMap& roles = QueueDataStore[check.guids[i]].roles;
+                LfgRolesMap const& roles = QueueDataStore[check.guids[i]].roles;
                 for (LfgRolesMap::const_iterator itRoles = roles.begin(); itRoles != roles.end(); ++itRoles)
                 {
                     LfgRolesMap::const_iterator itPlayer;
@@ -383,7 +383,7 @@ namespace lfg
         else
         {
             ObjectGuid gguid = check.front();
-            const LfgQueueData& queue = QueueDataStore[gguid];
+            LfgQueueData const& queue = QueueDataStore[gguid];
             proposalDungeons = queue.dungeons;
             proposalRoles = queue.roles;
             LFGMgr::CheckGroupRoles(proposalRoles);          // assing new roles

src/server/game/DungeonFinding/LFGQueue.h

@@ -103,8 +103,8 @@ namespace lfg
         uint32 FindBestCompatibleInQueue(LfgQueueDataContainer::iterator itrQueue);
         void UpdateBestCompatibleInQueue(LfgQueueDataContainer::iterator itrQueue, Lfg5Guids const& key);
 
-        LfgCompatibility FindNewGroups(const ObjectGuid& newGuid);
-        LfgCompatibility CheckCompatibility(Lfg5Guids const& checkWith, const ObjectGuid& newGuid, uint64& foundMask, uint32& foundCount, const std::set<Lfg5Guids>& currentCompatibles);
+        LfgCompatibility FindNewGroups(ObjectGuid const& newGuid);
+        LfgCompatibility CheckCompatibility(Lfg5Guids const& checkWith, ObjectGuid const& newGuid, uint64& foundMask, uint32& foundCount, std::set<Lfg5Guids> const& currentCompatibles);
 
         // Queue
         uint32 m_QueueStatusTimer;                         // used to check interval of sending queue status

src/server/game/Entities/Creature/Creature.cpp

@@ -474,7 +474,7 @@ void Creature::RemoveCorpse(bool setSpawnTime, bool skipVisibility)
 /**
  * change the entry of creature until respawn
  */
-bool Creature::InitEntry(uint32 Entry, const CreatureData* data)
+bool Creature::InitEntry(uint32 Entry, CreatureData const* data)
 {
     CreatureTemplate const* normalInfo = sObjectMgr->GetCreatureTemplate(Entry);
     if (!normalInfo)
@@ -578,7 +578,7 @@ bool Creature::InitEntry(uint32 Entry, const CreatureData* data)
     return true;
 }
 
-bool Creature::UpdateEntry(uint32 Entry, const CreatureData* data, bool changelevel, bool updateAI)
+bool Creature::UpdateEntry(uint32 Entry, CreatureData const* data, bool changelevel, bool updateAI)
 {
     if (!InitEntry(Entry, data))
         return false;
@@ -1148,7 +1148,7 @@ void Creature::Motion_Initialize()
         GetMotionMaster()->Initialize();
 }
 
-bool Creature::Create(ObjectGuid::LowType guidlow, Map* map, uint32 phaseMask, uint32 Entry, uint32 vehId, float x, float y, float z, float ang, const CreatureData* data)
+bool Creature::Create(ObjectGuid::LowType guidlow, Map* map, uint32 phaseMask, uint32 Entry, uint32 vehId, float x, float y, float z, float ang, CreatureData const* data)
 {
     ASSERT(map);
     SetMap(map);
@@ -1612,7 +1612,7 @@ float Creature::GetSpellDamageMod(int32 Rank)
     }
 }
 
-bool Creature::CreateFromProto(ObjectGuid::LowType guidlow, uint32 Entry, uint32 vehId, const CreatureData* data)
+bool Creature::CreateFromProto(ObjectGuid::LowType guidlow, uint32 Entry, uint32 vehId, CreatureData const* data)
 {
     SetZoneScript();
     if (GetZoneScript() && data)

src/server/game/Entities/Creature/Creature.h

@@ -61,7 +61,7 @@ public:
 
     [[nodiscard]] bool isVendorWithIconSpeak() const;
 
-    bool Create(ObjectGuid::LowType guidlow, Map* map, uint32 phaseMask, uint32 Entry, uint32 vehId, float x, float y, float z, float ang, const CreatureData* data = nullptr);
+    bool Create(ObjectGuid::LowType guidlow, Map* map, uint32 phaseMask, uint32 Entry, uint32 vehId, float x, float y, float z, float ang, CreatureData const* data = nullptr);
     bool LoadCreaturesAddon(bool reload = false);
     void SelectLevel(bool changelevel = true);
     void LoadEquipment(int8 id = 1, bool force = false);
@@ -175,7 +175,7 @@ public:
 
     void UpdateMovementFlags();
     uint32 GetRandomId(uint32 id1, uint32 id2, uint32 id3);
-    bool UpdateEntry(uint32 entry, const CreatureData* data = nullptr, bool changelevel = true, bool updateAI = false);
+    bool UpdateEntry(uint32 entry, CreatureData const* data = nullptr, bool changelevel = true, bool updateAI = false);
     bool UpdateEntry(uint32 entry, bool updateAI) { return UpdateEntry(entry, nullptr, true, updateAI); }
     bool UpdateStats(Stats stat) override;
     bool UpdateAllStats() override;
@@ -342,15 +342,15 @@ public:
     [[nodiscard]] bool IsNotReachableAndNeedRegen() const;
 
     void SetPosition(float x, float y, float z, float o);
-    void SetPosition(const Position& pos) { SetPosition(pos.GetPositionX(), pos.GetPositionY(), pos.GetPositionZ(), pos.GetOrientation()); }
+    void SetPosition(Position const& pos) { SetPosition(pos.GetPositionX(), pos.GetPositionY(), pos.GetPositionZ(), pos.GetOrientation()); }
 
     void SetHomePosition(float x, float y, float z, float o) { m_homePosition.Relocate(x, y, z, o); }
-    void SetHomePosition(const Position& pos) { m_homePosition.Relocate(pos); }
+    void SetHomePosition(Position const& pos) { m_homePosition.Relocate(pos); }
     void GetHomePosition(float& x, float& y, float& z, float& ori) const { m_homePosition.GetPosition(x, y, z, ori); }
     [[nodiscard]] Position const& GetHomePosition() const { return m_homePosition; }
 
     void SetTransportHomePosition(float x, float y, float z, float o) { m_transportHomePosition.Relocate(x, y, z, o); }
-    void SetTransportHomePosition(const Position& pos) { m_transportHomePosition.Relocate(pos); }
+    void SetTransportHomePosition(Position const& pos) { m_transportHomePosition.Relocate(pos); }
     void GetTransportHomePosition(float& x, float& y, float& z, float& ori) const { m_transportHomePosition.GetPosition(x, y, z, ori); }
     [[nodiscard]] Position const& GetTransportHomePosition() const { return m_transportHomePosition; }
 
@@ -460,8 +460,8 @@ public:
     bool IsUpdateNeeded() override;
 
 protected:
-    bool CreateFromProto(ObjectGuid::LowType guidlow, uint32 Entry, uint32 vehId, const CreatureData* data = nullptr);
-    bool InitEntry(uint32 entry, const CreatureData* data = nullptr);
+    bool CreateFromProto(ObjectGuid::LowType guidlow, uint32 Entry, uint32 vehId, CreatureData const* data = nullptr);
+    bool InitEntry(uint32 entry, CreatureData const* data = nullptr);
 
     // vendor items
     VendorItemCounts m_vendorItemCounts;

src/server/game/Entities/Creature/CreatureGroups.h

@@ -102,7 +102,7 @@ public:
     bool IsEmpty() const { return m_members.empty(); }
     bool IsFormed() const { return m_Formed; }
 
-    const CreatureGroupMemberType& GetMembers() const { return m_members; }
+    CreatureGroupMemberType const& GetMembers() const { return m_members; }
 
     void AddMember(Creature* member);
     void RemoveMember(Creature* member);

src/server/game/Entities/Creature/TemporarySummon.h

@@ -71,7 +71,7 @@ public:
     void SetVisibleBySummonerOnly(bool visibleBySummonerOnly) { _visibleBySummonerOnly = visibleBySummonerOnly; }
     [[nodiscard]] bool IsVisibleBySummonerOnly() const { return _visibleBySummonerOnly; }
 
-    const SummonPropertiesEntry* const m_Properties;
+    SummonPropertiesEntry const* const m_Properties;
 
     std::string GetDebugInfo() const override;
 

src/server/game/Entities/GameObject/GameObject.cpp

@@ -1031,7 +1031,7 @@ void GameObject::SaveToDB(bool saveAddon /*= false*/)
 
 void GameObject::SaveToDB(uint32 mapid, uint8 spawnMask, uint32 phaseMask, bool saveAddon /*= false*/)
 {
-    const GameObjectTemplate* goI = GetGOInfo();
+    GameObjectTemplate const* goI = GetGOInfo();
 
     if (!goI)
         return;
@@ -1431,7 +1431,7 @@ void GameObject::SetGoArtKit(uint8 kit)
 
 void GameObject::SetGoArtKit(uint8 artkit, GameObject* go, ObjectGuid::LowType lowguid)
 {
-    const GameObjectData* data = nullptr;
+    GameObjectData const* data = nullptr;
     if (go)
     {
         go->SetGoArtKit(artkit);
@@ -2815,7 +2815,7 @@ void GameObject::BuildValuesUpdate(uint8 updateType, ByteBuffer* data, Player* t
                             dynFlags |= GO_DYNFLAG_LO_SPARKLE;
                         break;
                     case GAMEOBJECT_TYPE_TRANSPORT:
-                        if (const StaticTransport* t = ToStaticTransport())
+                        if (StaticTransport const* t = ToStaticTransport())
                             if (t->GetPauseTime())
                             {
                                 if (GetGoState() == GO_STATE_READY)
@@ -2832,7 +2832,7 @@ void GameObject::BuildValuesUpdate(uint8 updateType, ByteBuffer* data, Player* t
                         // else it's ignored
                         break;
                     case GAMEOBJECT_TYPE_MO_TRANSPORT:
-                        if (const MotionTransport* t = ToMotionTransport())
+                        if (MotionTransport const* t = ToMotionTransport())
                             pathProgress = int16(float(t->GetPathProgress()) / float(t->GetPeriod()) * 65535.0f);
                         break;
                     default:

src/server/game/Entities/GameObject/GameObject.h

@@ -314,7 +314,7 @@ public:
     void GetRespawnPosition(float& x, float& y, float& z, float* ori = nullptr) const;
 
     void SetPosition(float x, float y, float z, float o);
-    void SetPosition(const Position& pos) { SetPosition(pos.GetPositionX(), pos.GetPositionY(), pos.GetPositionZ(), pos.GetOrientation()); }
+    void SetPosition(Position const& pos) { SetPosition(pos.GetPositionX(), pos.GetPositionY(), pos.GetPositionZ(), pos.GetOrientation()); }
 
     [[nodiscard]] bool IsStaticTransport() const { return GetGOInfo()->type == GAMEOBJECT_TYPE_TRANSPORT; }
     [[nodiscard]] bool IsMotionTransport() const { return GetGOInfo()->type == GAMEOBJECT_TYPE_MO_TRANSPORT; }

src/server/game/Entities/Item/Item.h

@@ -248,7 +248,7 @@ public:
     void DeleteRefundDataFromDB(CharacterDatabaseTransaction* trans);
 
     Bag* ToBag() { if (IsBag()) return reinterpret_cast<Bag*>(this); else return nullptr; }
-    [[nodiscard]] const Bag* ToBag() const { if (IsBag()) return reinterpret_cast<const Bag*>(this); else return nullptr; }
+    [[nodiscard]] Bag const* ToBag() const { if (IsBag()) return reinterpret_cast<Bag const*>(this); else return nullptr; }
 
     [[nodiscard]] bool IsLocked() const { return !HasFlag(ITEM_FIELD_FLAGS, ITEM_FIELD_FLAG_UNLOCKED); }
     [[nodiscard]] bool IsBag() const { return GetTemplate()->InventoryType == INVTYPE_BAG; }

src/server/game/Entities/Object/Object.cpp

@@ -1298,7 +1298,7 @@ float WorldObject::GetDistance(WorldObject const* obj) const
     return d > 0.0f ? d : 0.0f;
 }
 
-[[nodiscard]] float WorldObject::GetDistance(const Position& pos) const
+[[nodiscard]] float WorldObject::GetDistance(Position const& pos) const
 {
     float d = GetExactDist(&pos) - GetObjectSize();
     return d > 0.0f ? d : 0.0f;
@@ -1347,7 +1347,7 @@ bool WorldObject::IsInMap(WorldObject const* obj) const
     return IsInDist(x, y, z, dist + GetObjectSize());
 }
 
-bool WorldObject::IsWithinDist3d(const Position* pos, float dist) const
+bool WorldObject::IsWithinDist3d(Position const* pos, float dist) const
 {
     return IsInDist(pos, dist + GetObjectSize());
 }
@@ -1357,7 +1357,7 @@ bool WorldObject::IsWithinDist3d(const Position* pos, float dist) const
     return IsInDist2d(x, y, dist + GetObjectSize());
 }
 
-bool WorldObject::IsWithinDist2d(const Position* pos, float dist) const
+bool WorldObject::IsWithinDist2d(Position const* pos, float dist) const
 {
     return IsInDist2d(pos, dist + GetObjectSize());
 }
@@ -1555,7 +1555,7 @@ bool WorldObject::isInBack(WorldObject const* target, float arc) const
     return !HasInArc(2 * M_PI - arc, target);
 }
 
-void WorldObject::GetRandomPoint(const Position& pos, float distance, float& rand_x, float& rand_y, float& rand_z) const
+void WorldObject::GetRandomPoint(Position const& pos, float distance, float& rand_x, float& rand_y, float& rand_z) const
 {
     if (!distance)
     {
@@ -1576,7 +1576,7 @@ void WorldObject::GetRandomPoint(const Position& pos, float distance, float& ran
     UpdateGroundPositionZ(rand_x, rand_y, rand_z);            // update to LOS height if available
 }
 
-Position WorldObject::GetRandomPoint(const Position& srcPos, float distance) const
+Position WorldObject::GetRandomPoint(Position const& srcPos, float distance) const
 {
     float x, y, z;
     GetRandomPoint(srcPos, distance, x, y, z);
@@ -2441,7 +2441,7 @@ void WorldObject::ClearZoneScript()
     m_zoneScript = nullptr;
 }
 
-TempSummon* WorldObject::SummonCreature(uint32 entry, const Position& pos, TempSummonType spwtype, uint32 duration, uint32  /*vehId*/, SummonPropertiesEntry const* properties, bool visibleBySummonerOnly /*= false*/) const
+TempSummon* WorldObject::SummonCreature(uint32 entry, Position const& pos, TempSummonType spwtype, uint32 duration, uint32  /*vehId*/, SummonPropertiesEntry const* properties, bool visibleBySummonerOnly /*= false*/) const
 {
     if (Map* map = FindMap())
     {

src/server/game/Entities/Object/Object.h

@@ -280,7 +280,7 @@ private:
 
     // for output helpfull error messages from asserts
     [[nodiscard]] bool PrintIndexError(uint32 index, bool set) const;
-    Object(const Object&);                              // prevent generation copy constructor
+    Object(Object const&);                              // prevent generation copy constructor
     Object& operator=(Object const&);                   // prevent generation assigment operator
 };
 
@@ -507,8 +507,8 @@ public:
     void UpdateGroundPositionZ(float x, float y, float& z) const;
     void UpdateAllowedPositionZ(float x, float y, float& z, float* groundZ = nullptr) const;
 
-    void GetRandomPoint(const Position& srcPos, float distance, float& rand_x, float& rand_y, float& rand_z) const;
-    [[nodiscard]] Position GetRandomPoint(const Position& srcPos, float distance) const;
+    void GetRandomPoint(Position const& srcPos, float distance, float& rand_x, float& rand_y, float& rand_z) const;
+    [[nodiscard]] Position GetRandomPoint(Position const& srcPos, float distance) const;
 
     [[nodiscard]] uint32 GetInstanceId() const { return m_InstanceId; }
 
@@ -531,7 +531,7 @@ public:
     [[nodiscard]] virtual std::string const& GetNameForLocaleIdx(LocaleConstant /*locale_idx*/) const { return m_name; }
 
     float GetDistance(WorldObject const* obj) const;
-    [[nodiscard]] float GetDistance(const Position& pos) const;
+    [[nodiscard]] float GetDistance(Position const& pos) const;
     [[nodiscard]] float GetDistance(float x, float y, float z) const;
     float GetDistance2d(WorldObject const* obj) const;
     [[nodiscard]] float GetDistance2d(float x, float y) const;
@@ -540,9 +540,9 @@ public:
     bool IsSelfOrInSameMap(WorldObject const* obj) const;
     bool IsInMap(WorldObject const* obj) const;
     [[nodiscard]] bool IsWithinDist3d(float x, float y, float z, float dist) const;
-    bool IsWithinDist3d(const Position* pos, float dist) const;
+    bool IsWithinDist3d(Position const* pos, float dist) const;
     [[nodiscard]] bool IsWithinDist2d(float x, float y, float dist) const;
-    bool IsWithinDist2d(const Position* pos, float dist) const;
+    bool IsWithinDist2d(Position const* pos, float dist) const;
     virtual bool IsWithinSightRange(Position const& pos, float dist) const;
     // use only if you will sure about placing both object at same map
     bool IsWithinDist(WorldObject const* obj, float dist2compare, bool is3D = true, bool incOwnRadius = true, bool incTargetRadius = true) const;
@@ -635,7 +635,7 @@ public:
     void ClearZoneScript();
     [[nodiscard]] ZoneScript* GetZoneScript() const { return m_zoneScript; }
 
-    TempSummon* SummonCreature(uint32 id, const Position& pos, TempSummonType spwtype = TEMPSUMMON_MANUAL_DESPAWN, uint32 despwtime = 0, uint32 vehId = 0, SummonPropertiesEntry const* properties = nullptr, bool visibleBySummonerOnly = false) const;
+    TempSummon* SummonCreature(uint32 id, Position const& pos, TempSummonType spwtype = TEMPSUMMON_MANUAL_DESPAWN, uint32 despwtime = 0, uint32 vehId = 0, SummonPropertiesEntry const* properties = nullptr, bool visibleBySummonerOnly = false) const;
     TempSummon* SummonCreature(uint32 id, float x, float y, float z, float ang = 0, TempSummonType spwtype = TEMPSUMMON_MANUAL_DESPAWN, uint32 despwtime = 0, SummonPropertiesEntry const* properties = nullptr, bool visibleBySummonerOnly = false);
     GameObject* SummonGameObject(uint32 entry, float x, float y, float z, float ang, float rotation0, float rotation1, float rotation2, float rotation3, uint32 respawnTime, bool checkTransport = true, GOSummonType summonType = GO_SUMMON_TIMED_OR_CORPSE_DESPAWN);
     Creature*   SummonTrigger(float x, float y, float z, float ang, uint32 dur, bool setLevel = false, CreatureAI * (*GetAI)(Creature*) = nullptr);