mirrors/sapphire
1
Fork 0
mirror of https://github.com/SapphireServer/Sapphire.git synced 2025-04-25 22:17:45 +00:00
Code Activity

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

Browse source
This commit is contained in:
mordred 2019-01-24 12:10:31 +01:00
parent f1580813d3
commit e54d546b56
6 changed files with 487 additions and 474 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
src/world/Actor/BNpc.cpp
View file

@ -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"

5
src/world/ForwardsZone.h
View file

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

7
src/world/Manager/NaviMgr.cpp
View file

@ -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 ];

9
src/world/Manager/NaviMgr.h
View file

@ -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 );
NaviProvider* getNaviProvider( std::string internalName );
bool setupTerritory( const 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;
};
}

107
src/world/Navi/NaviProvider.cpp
View file

@ -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,
const dtPolyRef* visited, const int nvisited )
int32_t Sapphire::World::Navi::NaviProvider::fixupCorridor( dtPolyRef* path, const int32_t npath, const int32_t maxPath,
const dtPolyRef* visited, const int32_t nvisited )
{
int furthestPath = -1;
int furthestVisited = -1;
int32_t furthestPath = -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 int orig = rcMin( furthestPath + 1, npath );
int size = rcMax( 0, npath - orig );
const int32_t req = nvisited - furthestVisited;
const int32_t orig = rcMin( furthestPath + 1, npath );
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;
int cut = 0;
for( int i = dtMin( maxLookAhead, npath ) - 1; i > 1 && cut == 0; i-- ) {
for( int j = 0; j < nneis; j++ )
static const int32_t maxLookAhead = 6;
int32_t cut = 0;
for( int32_t i = dtMin( maxLookAhead, npath ) - 1; i > 1 && cut == 0; i-- )
{
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,
const float minTargetDist,
const dtPolyRef* path, const int pathSize,
bool Sapphire::World::Navi::NaviProvider::getSteerTarget( dtNavMeshQuery* navQuery, const float* startPos, const float* endPos,
const float minTargetDist, const dtPolyRef* path, const int32_t 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 );
if( !data ) break;
uint8_t* data = reinterpret_cast< uint8_t* >( dtAlloc( tileHeader.dataSize, DT_ALLOC_PERM ) );
if( !data )
break;
memset( data, 0, tileHeader.dataSize );
readLen = fread( data, tileHeader.dataSize, 1, fp );
if( readLen != 1 )

36
src/world/Navi/NaviProvider.h
View file

@ -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 int NAVMESHSET_VERSION = 1;
static const int32_t NAVMESHSET_MAGIC = 'M' << 24 | 'S' << 16 | 'E' << 8 | 'T'; //'MSET'
static const int32_t NAVMESHSET_VERSION = 1;
struct NavMeshSetHeader
{
int magic;
int version;
int numTiles;
int32_t magic;
int32_t version;
int32_t numTiles;
dtNavMeshParams params;
};
struct NavMeshTileHeader
{
dtTileRef tileRef;
int dataSize;
int32_t dataSize;
};
static const int MAX_POLYS = 256;
static const int MAX_SMOOTH = 2048;
static const int32_t MAX_POLYS = 256;
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);
Sapphire::Common::FFXIVARR_POSITION3 toGamePos( float* pos );
void toDetourPos( const Common::FFXIVARR_POSITION3& position, float* out );
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 int fixupShortcuts( dtPolyRef* path, int npath, dtNavMeshQuery* navQuery );
static int32_t fixupCorridor( dtPolyRef* path, int32_t npath, int32_t maxPath, const dtPolyRef* visited, int32_t nvisited );
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 );
};