Fixing code for consistency, const correctness, include tree and style.

src/world/Actor/BNpc.cpp

@@ -20,6 +20,7 @@
 #include "Network/PacketWrappers/UpdateHpMpTpPacket.h"
 #include "Network/PacketWrappers/NpcSpawnPacket.h"
 #include "Network/PacketWrappers/MoveActorPacket.h"
+#include "Navi/NaviProvider.h"
 
 #include "StatusEffect/StatusEffect.h"
 #include "Action/ActionCollision.h"

src/world/ForwardsZone.h

@@ -35,6 +35,11 @@ namespace World
 TYPE_FORWARD( Session );
 }
 
+namespace World::Navi
+{
+TYPE_FORWARD( NaviProvider );
+}
+
 namespace World::Territory::Housing
 {
 TYPE_FORWARD( HousingInteriorTerritory );

src/world/Manager/NaviMgr.cpp

@@ -1,4 +1,5 @@
 #include "NaviMgr.h"
+#include "Navi/NaviProvider.h"
 #include <Logging/Logger.h>
 
 Sapphire::World::Manager::NaviMgr::NaviMgr( FrameworkPtr pFw ) :
@@ -7,9 +8,9 @@ Sapphire::World::Manager::NaviMgr::NaviMgr( FrameworkPtr pFw ) :
 {
 }
 
-bool Sapphire::World::Manager::NaviMgr::setupTerritory( std::string internalName )
+bool Sapphire::World::Manager::NaviMgr::setupTerritory( const std::string& internalName )
 {
-  auto provider = new NaviProvider( internalName );
+  auto provider = Navi::make_NaviProvider( internalName );
 
   if( provider->init() )
   {
@@ -20,7 +21,7 @@ bool Sapphire::World::Manager::NaviMgr::setupTerritory( std::string internalName
   return false;
 }
 
-Sapphire::NaviProvider* Sapphire::World::Manager::NaviMgr::getNaviProvider( std::string internalName )
+Sapphire::World::Navi::NaviProviderPtr Sapphire::World::Manager::NaviMgr::getNaviProvider( const std::string& internalName )
 {
   if( m_naviProviderTerritoryMap.find( internalName ) != m_naviProviderTerritoryMap.end() )
     return m_naviProviderTerritoryMap[ internalName ];

src/world/Manager/NaviMgr.h

@@ -1,11 +1,10 @@
 #ifndef SAPPHIRE_NAVIMGR_H
 #define SAPPHIRE_NAVIMGR_H
 
-#include "Forwards.h"
+#include "ForwardsZone.h"
 #include "BaseManager.h"
 
 #include <array>
-#include <Navi/NaviProvider.h>
 
 namespace Sapphire::World::Manager
 {
@@ -17,13 +16,13 @@ namespace Sapphire::World::Manager
     NaviMgr( FrameworkPtr pFw );
     virtual ~NaviMgr() = default;
 
-    bool setupTerritory( std::string internalName );
+    bool setupTerritory( const std::string& internalName );
-    NaviProvider* getNaviProvider( std::string internalName );
+    Navi::NaviProviderPtr getNaviProvider( const std::string& internalName );
 
   private:
     FrameworkPtr m_pFw;
 
-    std::unordered_map<std::string, NaviProvider*> m_naviProviderTerritoryMap;
+    std::unordered_map< std::string, Navi::NaviProviderPtr > m_naviProviderTerritoryMap;
   };
 
 }

src/world/Navi/NaviProvider.cpp

@@ -12,7 +12,7 @@
 #include <experimental/filesystem>
 
 
-Sapphire::NaviProvider::NaviProvider( std::string internalName ) :
+Sapphire::World::Navi::NaviProvider::NaviProvider( const std::string& internalName ) :
   m_naviMesh( nullptr ),
   m_naviMeshQuery( nullptr ),
   m_internalName( internalName )
@@ -23,7 +23,7 @@ Sapphire::NaviProvider::NaviProvider( std::string internalName ) :
   m_polyFindRange[2] = 10;
 }
 
-bool Sapphire::NaviProvider::init()
+bool Sapphire::World::Navi::NaviProvider::init()
 {
   auto meshesFolder = std::experimental::filesystem::path( "navi" );
   auto meshFolder = meshesFolder / std::experimental::filesystem::path( m_internalName );
@@ -42,31 +42,31 @@ bool Sapphire::NaviProvider::init()
   return false;
 }
 
-bool Sapphire::NaviProvider::hasNaviMesh() const
+bool Sapphire::World::Navi::NaviProvider::hasNaviMesh() const
 {
   return m_naviMesh != nullptr;
 }
 
-void Sapphire::NaviProvider::initQuery()
+void Sapphire::World::Navi::NaviProvider::initQuery()
 {
-  if( m_naviMeshQuery != nullptr )
+  if( m_naviMeshQuery )
     dtFreeNavMeshQuery( m_naviMeshQuery );
 
   m_naviMeshQuery = dtAllocNavMeshQuery();
   m_naviMeshQuery->init( m_naviMesh, 2048 );
 }
 
-int Sapphire::NaviProvider::fixupCorridor( dtPolyRef* path, const int npath, const int maxPath,
+int32_t Sapphire::World::Navi::NaviProvider::fixupCorridor( dtPolyRef* path, const int32_t npath, const int32_t maxPath,
-                          const dtPolyRef* visited, const int nvisited )
+                                                            const dtPolyRef* visited, const int32_t nvisited )
 {
-  int furthestPath = -1;
+  int32_t furthestPath = -1;
-  int furthestVisited = -1;
+  int32_t furthestVisited = -1;
 
   // Find furthest common polygon.
-  for( int i = npath - 1; i >= 0; --i )
+  for( int32_t i = npath - 1; i >= 0; --i )
   {
     bool found = false;
-    for( int j = nvisited - 1; j >= 0; --j )
+    for( int32_t j = nvisited - 1; j >= 0; --j )
     {
       if( path[ i ] == visited[ j ] )
       {
@@ -86,37 +86,37 @@ int Sapphire::NaviProvider::fixupCorridor( dtPolyRef* path, const int npath, con
   // Concatenate paths.	
 
   // Adjust beginning of the buffer to include the visited.
-  const int req = nvisited - furthestVisited;
+  const int32_t req = nvisited - furthestVisited;
-  const int orig = rcMin( furthestPath + 1, npath );
+  const int32_t orig = rcMin( furthestPath + 1, npath );
-  int size = rcMax( 0, npath - orig );
+  int32_t size = rcMax( 0, npath - orig );
   if( req + size > maxPath )
     size = maxPath - req;
   if( size )
     memmove( path + req, path + orig, size * sizeof( dtPolyRef ) );
 
   // Store visited
-  for( int i = 0; i < req; ++i )
+  for( int32_t i = 0; i < req; ++i )
     path[i] = visited[( nvisited - 1 ) - i];
 
   return req + size;
 }
 
-int Sapphire::NaviProvider::fixupShortcuts( dtPolyRef* path, int npath, dtNavMeshQuery* navQuery )
+int32_t Sapphire::World::Navi::NaviProvider::fixupShortcuts( dtPolyRef* path, int32_t npath, dtNavMeshQuery* navQuery )
 {
   if( npath < 3 )
     return npath;
 
   // Get connected polygons
-  static const int maxNeis = 16;
+  static const int32_t maxNeis = 16;
   dtPolyRef neis[ maxNeis ];
-  int nneis = 0;
+  int32_t nneis = 0;
 
   const dtMeshTile* tile = 0;
   const dtPoly* poly = 0;
   if( dtStatusFailed( navQuery->getAttachedNavMesh()->getTileAndPolyByRef( path[ 0 ], &tile, &poly ) ) )
     return npath;
 
-  for( unsigned int k = poly->firstLink; k != DT_NULL_LINK; k = tile->links[k].next )
+  for( uint32_t k = poly->firstLink; k != DT_NULL_LINK; k = tile->links[ k ].next )
   {
     const dtLink* link = &tile->links[ k ];
     if( link->ref != 0 )
@@ -128,12 +128,14 @@ int Sapphire::NaviProvider::fixupShortcuts( dtPolyRef* path, int npath, dtNavMes
 
   // If any of the neighbour polygons is within the next few polygons
   // in the path, short cut to that polygon directly.
-  static const int maxLookAhead = 6;
+  static const int32_t maxLookAhead = 6;
-  int cut = 0;
+  int32_t cut = 0;
-  for( int i = dtMin( maxLookAhead, npath ) - 1; i > 1 && cut == 0; i-- ) {
+  for( int32_t i = dtMin( maxLookAhead, npath ) - 1; i > 1 && cut == 0; i-- ) 
-    for( int j = 0; j < nneis; j++ )
+  {
+    for( int32_t j = 0; j < nneis; j++ )
+    {
+      if( path[ i ] == neis[ j ] ) 
       {
-      if( path[i] == neis[j] ) {
         cut = i;
         break;
       }
@@ -141,16 +143,16 @@ int Sapphire::NaviProvider::fixupShortcuts( dtPolyRef* path, int npath, dtNavMes
   }
   if( cut > 1 )
   {
-    int offset = cut - 1;
+    int32_t offset = cut - 1;
     npath -= offset;
-    for( int i = 1; i < npath; i++ )
+    for( int32_t i = 1; i < npath; i++ )
       path[ i ] = path[ i + offset ];
   }
 
   return npath;
 }
 
-bool Sapphire::NaviProvider::inRange( const float* v1, const float* v2, const float r, const float h )
+bool Sapphire::World::Navi::NaviProvider::inRange( const float* v1, const float* v2, const float r, const float h )
 {
   const float dx = v2[ 0 ] - v1[ 0 ];
   const float dy = v2[ 1 ] - v1[ 1 ];
@@ -158,18 +160,17 @@ bool Sapphire::NaviProvider::inRange( const float* v1, const float* v2, const fl
   return ( dx * dx + dz * dz ) < r * r && fabsf( dy ) < h;
 }
 
-bool Sapphire::NaviProvider::getSteerTarget( dtNavMeshQuery* navQuery, const float* startPos, const float* endPos,
+bool Sapphire::World::Navi::NaviProvider::getSteerTarget( dtNavMeshQuery* navQuery, const float* startPos, const float* endPos,
-                            const float minTargetDist,
+                                                          const float minTargetDist, const dtPolyRef* path, const int32_t pathSize,
-                            const dtPolyRef* path, const int pathSize,
                                                           float* steerPos, unsigned char& steerPosFlag, dtPolyRef& steerPosRef,
-                            float* outPoints, int* outPointCount )
+                                                          float* outPoints, int32_t* outPointCount )
 {
   // Find steer target.
-  static const int MAX_STEER_POINTS = 3;
+  static const int32_t MAX_STEER_POINTS = 3;
   float steerPath[ MAX_STEER_POINTS * 3 ];
-  unsigned char steerPathFlags[MAX_STEER_POINTS];
+  uint8_t steerPathFlags[ MAX_STEER_POINTS ];
   dtPolyRef steerPathPolys[ MAX_STEER_POINTS ];
-  int nsteerPath = 0;
+  int32_t nsteerPath = 0;
   navQuery->findStraightPath( startPos, endPos, path, pathSize,
                               steerPath, steerPathFlags, steerPathPolys, &nsteerPath, MAX_STEER_POINTS );
   if( !nsteerPath )
@@ -178,13 +179,12 @@ bool Sapphire::NaviProvider::getSteerTarget( dtNavMeshQuery* navQuery, const flo
   if( outPoints && outPointCount )
   {
     *outPointCount = nsteerPath;
-    for( int i = 0; i < nsteerPath; ++i )
+    for( int32_t i = 0; i < nsteerPath; ++i )
       dtVcopy( &outPoints[ i * 3 ], &steerPath[ i * 3 ] );
   }
 
-
   // Find vertex far enough to steer to.
-  int ns = 0;
+  int32_t ns = 0;
   while( ns < nsteerPath )
   {
     // Stop at Off-Mesh link or when point is further than slop away.
@@ -205,7 +205,9 @@ bool Sapphire::NaviProvider::getSteerTarget( dtNavMeshQuery* navQuery, const flo
   return true;
 }
 
-std::vector< Sapphire::Common::FFXIVARR_POSITION3 > Sapphire::NaviProvider::findFollowPath( Common::FFXIVARR_POSITION3 startPos, Common::FFXIVARR_POSITION3 endPos )
+std::vector< Sapphire::Common::FFXIVARR_POSITION3 > 
+  Sapphire::World::Navi::NaviProvider::findFollowPath( const Common::FFXIVARR_POSITION3& startPos,
+                                                       const Common::FFXIVARR_POSITION3& endPos )
 {
   if( !m_naviMesh || !m_naviMeshQuery )
     throw std::runtime_error( "No navimesh loaded" );
@@ -229,7 +231,7 @@ std::vector< Sapphire::Common::FFXIVARR_POSITION3 > Sapphire::NaviProvider::find
     return resultCoords;
 
   dtPolyRef polys[ MAX_POLYS ];
-  int numPolys = 0;
+  int32_t numPolys = 0;
 
   m_naviMeshQuery->findPath( startRef, endRef, spos, epos, &filter, polys, &numPolys, MAX_POLYS );
 
@@ -238,18 +240,20 @@ std::vector< Sapphire::Common::FFXIVARR_POSITION3 > Sapphire::NaviProvider::find
   {
     // Iterate over the path to find smooth path on the detail mesh surface.
     memcpy( polys, polys, sizeof( dtPolyRef )*numPolys );
-    int npolys = numPolys;
+    int32_t npolys = numPolys;
 
     float iterPos[3], targetPos[3];
     m_naviMeshQuery->closestPointOnPoly( startRef, spos, iterPos, 0 );
     m_naviMeshQuery->closestPointOnPoly( polys[ npolys - 1 ], epos, targetPos, 0 );
 
-    Logger::debug("IterPos: {0} {1} {2}; TargetPos: {3} {4} {5}", iterPos[0], iterPos[1], iterPos[2], targetPos[0], targetPos[1], targetPos[2]);
+    Logger::debug( "IterPos: {0} {1} {2}; TargetPos: {3} {4} {5}",
+                   iterPos[ 0 ], iterPos[ 1 ], iterPos[ 2 ],
+                   targetPos[ 0 ], targetPos[ 1 ], targetPos[ 2 ] );
 
     static const float STEP_SIZE = 1.2f;
     static const float SLOP = 0.15f;
 
-    int numSmoothPath = 0;
+    int32_t numSmoothPath = 0;
     float smoothPath[ MAX_SMOOTH * 3 ];
 
     dtVcopy( &smoothPath[ numSmoothPath * 3 ], iterPos );
@@ -261,7 +265,7 @@ std::vector< Sapphire::Common::FFXIVARR_POSITION3 > Sapphire::NaviProvider::find
     {
       // Find location to steer towards.
       float steerPos[ 3 ];
-      unsigned char steerPosFlag;
+      uint8_t steerPosFlag;
       dtPolyRef steerPosRef;
 
       if( !getSteerTarget( m_naviMeshQuery, iterPos, targetPos, SLOP,
@@ -286,7 +290,7 @@ std::vector< Sapphire::Common::FFXIVARR_POSITION3 > Sapphire::NaviProvider::find
       // Move
       float result[ 3 ];
       dtPolyRef visited[ 16 ];
-      int nvisited = 0;
+      int32_t nvisited = 0;
       m_naviMeshQuery->moveAlongSurface( polys[ 0 ], iterPos, moveTgt, &filter,
                                          result, visited, &nvisited, 16 );
 
@@ -317,14 +321,14 @@ std::vector< Sapphire::Common::FFXIVARR_POSITION3 > Sapphire::NaviProvider::find
 
         // Advance the path up to and over the off-mesh connection.
         dtPolyRef prevRef = 0, polyRef = polys[ 0 ];
-        int npos = 0;
+        int32_t npos = 0;
         while( npos < npolys && polyRef != steerPosRef )
         {
           prevRef = polyRef;
           polyRef = polys[ npos ];
           npos++;
         }
-        for( int i = npos; i < npolys; ++i )
+        for( int32_t i = npos; i < npolys; ++i )
           polys[ i - npos ] = polys[ i ];
         npolys -= npos;
 
@@ -359,7 +363,7 @@ std::vector< Sapphire::Common::FFXIVARR_POSITION3 > Sapphire::NaviProvider::find
       }
     }
 
-    for( int i = 0; i < numSmoothPath; i += 3 )
+    for( int32_t i = 0; i < numSmoothPath; i += 3 )
     {
       resultCoords.push_back( Common::FFXIVARR_POSITION3{ smoothPath[ i ], smoothPath[ i + 1 ], smoothPath[ i + 2 ] } );
     }
@@ -368,7 +372,7 @@ std::vector< Sapphire::Common::FFXIVARR_POSITION3 > Sapphire::NaviProvider::find
   return resultCoords;
 }
 
-void Sapphire::NaviProvider::loadMesh( std::string path )
+void Sapphire::World::Navi::NaviProvider::loadMesh( const std::string& path )
 {
   FILE* fp = fopen( path.c_str(), "rb" );
   if( !fp )
@@ -414,7 +418,7 @@ void Sapphire::NaviProvider::loadMesh( std::string path )
   }
 
   // Read tiles.
-  for( int i = 0; i < header.numTiles; ++i )
+  for( int32_t i = 0; i < header.numTiles; ++i )
   {
     NavMeshTileHeader tileHeader;
     readLen = fread( &tileHeader, sizeof( tileHeader ), 1, fp );
@@ -427,8 +431,9 @@ void Sapphire::NaviProvider::loadMesh( std::string path )
     if( !tileHeader.tileRef || !tileHeader.dataSize )
       break;
 
-    unsigned char* data = (unsigned char*)dtAlloc( tileHeader.dataSize, DT_ALLOC_PERM );
+    uint8_t* data = reinterpret_cast< uint8_t* >( dtAlloc( tileHeader.dataSize, DT_ALLOC_PERM ) );
-    if( !data ) break;
+    if( !data ) 
+      break;
     memset( data, 0, tileHeader.dataSize );
     readLen = fread( data, tileHeader.dataSize, 1, fp );
     if( readLen != 1 )

src/world/Navi/NaviProvider.h

@@ -6,43 +6,43 @@
 #include <recastnavigation/Detour/Include/DetourNavMesh.h>
 #include <recastnavigation/Detour/Include/DetourNavMeshQuery.h>
 
-namespace Sapphire
+namespace Sapphire::World::Navi
 {
 
   class NaviProvider
   {
 
-    static const int NAVMESHSET_MAGIC = 'M' << 24 | 'S' << 16 | 'E' << 8 | 'T'; //'MSET';
+    static const int32_t NAVMESHSET_MAGIC = 'M' << 24 | 'S' << 16 | 'E' << 8 | 'T'; //'MSET'
-    static const int NAVMESHSET_VERSION = 1;
+    static const int32_t NAVMESHSET_VERSION = 1;
 
     struct NavMeshSetHeader
     {
-      int magic;
+      int32_t magic;
-      int version;
+      int32_t version;
-      int numTiles;
+      int32_t numTiles;
       dtNavMeshParams params;
     };
 
     struct NavMeshTileHeader
     {
       dtTileRef tileRef;
-      int dataSize;
+      int32_t dataSize;
     };
 
-    static const int MAX_POLYS = 256;
+    static const int32_t MAX_POLYS = 256;
-	  static const int MAX_SMOOTH = 2048;
+    static const int32_t MAX_SMOOTH = 2048;
 
   public:
-    NaviProvider( const std::string internalName );
+    NaviProvider( const std::string& internalName );
 
     bool init();
-    void loadMesh( std::string path );
+    void loadMesh( const std::string& path );
     void initQuery();
 
-    void toDetourPos(const Common::FFXIVARR_POSITION3 position, float* out);
+    void toDetourPos( const Common::FFXIVARR_POSITION3& position, float* out );
-    Sapphire::Common::FFXIVARR_POSITION3 toGamePos( float* pos );
+    Common::FFXIVARR_POSITION3 toGamePos( float* pos );
 
-    std::vector< Sapphire::Common::FFXIVARR_POSITION3 > findFollowPath(Common::FFXIVARR_POSITION3 startPos, Common::FFXIVARR_POSITION3 endPos);
+    std::vector< Common::FFXIVARR_POSITION3 > findFollowPath( const Common::FFXIVARR_POSITION3& startPos, const Common::FFXIVARR_POSITION3& endPos );
 
     bool hasNaviMesh() const;
 
@@ -55,10 +55,12 @@ namespace Sapphire
     float m_polyFindRange[ 3 ];
 
   private:
-    static int fixupCorridor( dtPolyRef* path, const int npath, const int maxPath, const dtPolyRef* visited, const int nvisited );
+    static int32_t fixupCorridor( dtPolyRef* path, int32_t npath, int32_t maxPath, const dtPolyRef* visited, int32_t nvisited );
-    static int fixupShortcuts( dtPolyRef* path, int npath, dtNavMeshQuery* navQuery );
+    static int32_t fixupShortcuts( dtPolyRef* path, int32_t npath, dtNavMeshQuery* navQuery );
     inline static bool inRange( const float* v1, const float* v2, const float r, const float h );
-    static bool getSteerTarget( dtNavMeshQuery* navQuery, const float* startPos, const float* endPos, const float minTargetDist, const dtPolyRef* path, const int pathSize, float* steerPos, unsigned char& steerPosFlag, dtPolyRef& steerPosRef, float* outPoints = 0, int* outPointCount = 0 );
+    static bool getSteerTarget( dtNavMeshQuery* navQuery, const float* startPos, const float* endPos, const float minTargetDist,
+		                const dtPolyRef* path, const int32_t pathSize, float* steerPos, uint8_t& steerPosFlag,
+			       	dtPolyRef& steerPosRef, float* outPoints = 0, int32_t* outPointCount = 0 );
 
   };