Plenty more cleanup and code quality adjustments.

src/api/LoginSession.cpp

@@ -4,7 +4,6 @@ namespace Sapphire {
   LoginSession::LoginSession( void )
   {
     //setSocket(NULL);
-
   }
 
   LoginSession::~LoginSession( void )

src/api/LoginSession.h

@@ -14,8 +14,8 @@ namespace Sapphire
   {
 
   private:
-    uint32_t m_IP;
-    uint32_t m_accountID;
+    uint32_t m_ip;
+    uint32_t m_accountId;
     uint8_t m_sessionId[56];
 
   public:
@@ -25,9 +25,9 @@ namespace Sapphire
 
     ~LoginSession( void );
 
-    uint32_t getIP()
+    uint32_t getIp()
     {
-      return m_IP;
+      return m_ip;
     }
 
     void setSessionId( uint8_t* sessionId )
@@ -35,29 +35,21 @@ namespace Sapphire
       memcpy( m_sessionId, sessionId, 56 );
     }
 
-    void setIP( uint32_t iP )
+    void setIp( uint32_t ip )
     {
-      m_IP = iP;
+      m_ip = ip;
     }
 
-    uint32_t getAccountID()
+    uint32_t getAccountId()
     {
-      return m_accountID;
+      return m_accountId;
     }
 
-    void setAccountID( uint32_t iD )
+    void setAccountId( uint32_t id )
     {
-      m_accountID = iD;
+      m_accountId = id;
     }
 
-    /*INLINE CLobbySocket* getSocket() {
-    return m_pGS;
-    }
-
-    INLINE void setSocket(CLobbySocket * pS) {
-    m_pGS = pS;
-    }*/
-
   };
 
 }

src/common/Config/ConfigDef.h

@@ -33,7 +33,6 @@ namespace Sapphire::Common::Config
     } network;
   };
 
-
   struct WorldConfig
   {
     GlobalConfig global;

src/common/Crypt/md5.h

@@ -29,8 +29,7 @@ namespace Sapphire::Util
     "message digest",
     "abcdefghijklmnopqrstuvwxyz",
     "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
-    "12345678901234567890123456789012345678901234567890123456789012" \
-         "345678901234567890"
+    "12345678901234567890123456789012345678901234567890123456789012345678901234567890"
   };
 
   static const char* val[] =

src/common/Database/DbConnection.cpp

@@ -209,7 +209,9 @@ std::shared_ptr< Mysql::PreparedStatement > Sapphire::Db::DbConnection::getPrepa
   return ret;
 }
 
-void Sapphire::Db::DbConnection::prepareStatement( uint32_t index, const std::string& sql, Sapphire::Db::ConnectionFlags flags )
+void Sapphire::Db::DbConnection::prepareStatement( uint32_t index,
+                                                   const std::string& sql,
+                                                   Sapphire::Db::ConnectionFlags flags )
 {
   m_queries.insert( PreparedStatementMap::value_type( index, std::make_pair( sql, flags ) ) );
 

src/common/Database/DbWorker.cpp

@@ -2,7 +2,8 @@
 #include "Operation.h"
 #include "Util/LockedWaitQueue.h"
 
-Sapphire::Db::DbWorker::DbWorker( Sapphire::LockedWaitQueue< std::shared_ptr< Operation > >* newQueue, DbConnection* pConn )
+Sapphire::Db::DbWorker::DbWorker( Sapphire::LockedWaitQueue< std::shared_ptr< Operation > >* newQueue,
+                                  DbConnection* pConn )
 {
   m_pConn = pConn;
   m_queue = newQueue;

src/common/Database/DbWorkerPool.cpp

@@ -10,8 +10,7 @@
 #include "Logging/Logger.h"
 #include <mysql.h>
 
-class PingOperation :
-  public Sapphire::Db::Operation
+class PingOperation : public Sapphire::Db::Operation
 {
   bool execute() override
   {
@@ -256,25 +255,5 @@ void Sapphire::Db::DbWorkerPool< T >::directExecute( std::shared_ptr< PreparedSt
   connection->unlock();
 }
 
-/*
-template <class T>
-void DatabaseWorkerPool<T>::ExecuteOrAppend(SQLTransaction& trans, const char* sql)
-{
-   if (!trans)
-      Execute(sql);
-   else
-      trans->Append(sql);
-}
-
-template <class T>
-void DatabaseWorkerPool<T>::ExecuteOrAppend(SQLTransaction& trans, PreparedStatement* stmt)
-{
-   if (!trans)
-      Execute(stmt);
-   else
-      trans->Append(stmt);
-}
-*/
-
 template
 class Sapphire::Db::DbWorkerPool< Sapphire::Db::ZoneDbConnection >;

src/common/Database/DbWorkerPool.h

@@ -44,7 +44,7 @@ namespace Sapphire::Db
 
     bool prepareStatements();
 
-    inline ConnectionInfo getConnectionInfo() const
+    const ConnectionInfo& getConnectionInfo() const
     {
       return m_connectionInfo;
     }

src/common/Database/StatementTask.cpp

@@ -41,7 +41,6 @@ bool Sapphire::Db::StatementTask::execute()
 Sapphire::Db::PreparedStatementTask::PreparedStatementTask( std::shared_ptr< Sapphire::Db::PreparedStatement > stmt,
                                                             bool async ) :
   m_stmt( stmt )
-//, m_result(nullptr)
 {
   m_hasResult = async; // If the operation is async, then there's a result
 }

src/common/Database/StatementTask.h

@@ -9,8 +9,7 @@ namespace Sapphire::Db
 {
   class PreparedStatement;
 
-  class StatementTask :
-    public Operation
+  class StatementTask : public Operation
   {
   public:
 
@@ -20,15 +19,9 @@ namespace Sapphire::Db
 
     bool execute() override;
 
-    //   QueryResultFuture getFuture() const
-    //   {
-    //      return m_result->get_future();
-    //   }
-
   private:
     std::string m_sql;
     bool m_hasResult;
-  //      QueryResultPromise *m_result;
   };
 
   class PreparedStatementTask :
@@ -40,12 +33,10 @@ namespace Sapphire::Db
     ~PreparedStatementTask();
 
     bool execute() override;
-    //PreparedQueryResultFuture getFuture() { return m_result->get_future(); }
 
   protected:
     std::shared_ptr< PreparedStatement > m_stmt;
     bool m_hasResult;
-    //PreparedQueryResultPromise* m_result;
   };
 
 }

src/common/Forwards.h

@@ -5,13 +5,13 @@
 
 namespace Sapphire
 {
-
   class ConfigMgr;
-  using ConfigMgrPtr = std::shared_ptr< ConfigMgr >;
   class Framework;
+  using ConfigMgrPtr = std::shared_ptr< ConfigMgr >;
   using FrameworkPtr = std::shared_ptr< Framework >;
+}
 
-  namespace Network
+namespace Sapphire::Network
 {
   class Hive;
   class Acceptor;
@@ -19,8 +19,9 @@ namespace Sapphire
   using HivePtr = std::shared_ptr< Hive >;
   using AcceptorPtr = std::shared_ptr< Acceptor >;
   using ConnectionPtr = std::shared_ptr< Connection >;
+}
 
-    namespace Packets
+namespace Sapphire::Network::Packets
 {
   class GamePacket;
   class FFXIVPacketBase;
@@ -28,10 +29,4 @@ namespace Sapphire
   using FFXIVPacketBasePtr = std::shared_ptr< FFXIVPacketBase >;
 }
 
-  }
-
-
-}
-
-
 #endif

src/common/Logging/Logger.cpp

@@ -10,20 +10,17 @@
 
 namespace fs = std::experimental::filesystem;
 
-namespace Sapphire
-{
-
-  Logger::Logger()
+Sapphire::Logger::Logger()
 {
 
 }
 
-  Logger::~Logger()
+Sapphire::Logger::~Logger()
 {
 
 }
 
-  void Logger::init( const std::string& logPath )
+void Sapphire::Logger::init( const std::string& logPath )
 {
   auto pos = logPath.find_last_of( fs::path::preferred_separator );
 
@@ -53,39 +50,38 @@ namespace Sapphire
   spdlog::flush_on( spdlog::level::critical );
 }
 
-  void Logger::setLogLevel( uint8_t logLevel )
+void Sapphire::Logger::setLogLevel( uint8_t logLevel )
 {
   spdlog::set_level( static_cast< spdlog::level::level_enum >( logLevel ) );
 }
 
-  void Logger::error( const std::string& text )
+void Sapphire::Logger::error( const std::string& text )
 {
   spdlog::get( "logger" )->error( text );
 }
 
-  void Logger::warn( const std::string& text )
+void Sapphire::Logger::warn( const std::string& text )
 {
   spdlog::get( "logger" )->warn( text );
 }
 
-  void Logger::info( const std::string& text )
+void Sapphire::Logger::info( const std::string& text )
 {
   spdlog::get( "logger" )->info( text );
 }
 
-  void Logger::debug( const std::string& text )
+void Sapphire::Logger::debug( const std::string& text )
 {
   spdlog::get( "logger" )->debug( text );
 }
 
-  void Logger::fatal( const std::string& text )
+void Sapphire::Logger::fatal( const std::string& text )
 {
   spdlog::get( "logger" )->critical( text );
 }
 
-  void Logger::trace( const std::string& text )
+void Sapphire::Logger::trace( const std::string& text )
 {
   spdlog::get( "logger" )->trace( text );
 }
 
-}

src/common/Network/Acceptor.cpp

@@ -2,12 +2,7 @@
 #include "Acceptor.h"
 #include "Connection.h"
 
-namespace Sapphire::Network 
-{
-
-//-----------------------------------------------------------------------------
-
-Acceptor::Acceptor( HivePtr hive ) :
+Sapphire::Network::Acceptor::Acceptor( HivePtr hive ) :
   m_hive( hive ),
   m_acceptor( hive->getService() ),
   m_io_strand( hive->getService() ),
@@ -15,22 +10,21 @@ Acceptor::Acceptor( HivePtr hive ) :
 {
 }
 
-Acceptor::~Acceptor()
+Sapphire::Network::Acceptor::~Acceptor()
 {
 }
 
-
-bool Acceptor::onAccept( ConnectionPtr connection, const std::string& host, uint16_t port )
+bool Sapphire::Network::Acceptor::onAccept( ConnectionPtr connection, const std::string& host, uint16_t port )
 {
   return true;
 }
 
-void Acceptor::onError( const asio::error_code& error )
+void Sapphire::Network::Acceptor::onError( const asio::error_code& error )
 {
 
 }
 
-void Acceptor::startError( const asio::error_code& error )
+void Sapphire::Network::Acceptor::startError( const asio::error_code& error )
 {
   uint32_t v1 = 1;
   uint32_t v2 = 0;
@@ -43,7 +37,7 @@ void Acceptor::startError( const asio::error_code& error )
   }
 }
 
-void Acceptor::dispatchAccept( ConnectionPtr connection )
+void Sapphire::Network::Acceptor::dispatchAccept( ConnectionPtr connection )
 {
   m_acceptor.async_accept( connection->getSocket(),
                            connection->getStrand().wrap( std::bind( &Acceptor::handleAccept,
@@ -52,7 +46,7 @@ void Acceptor::dispatchAccept( ConnectionPtr connection )
                                                                     connection ) ) );
 }
 
-void Acceptor::handleAccept( const asio::error_code& error, ConnectionPtr connection )
+void Sapphire::Network::Acceptor::handleAccept( const asio::error_code& error, ConnectionPtr connection )
 {
   if( error || hasError() || m_hive->hasStopped() )
   {
@@ -78,17 +72,17 @@ void Acceptor::handleAccept( const asio::error_code& error, ConnectionPtr connec
   }
 }
 
-void Acceptor::stop()
+void Sapphire::Network::Acceptor::stop()
 {
 
 }
 
-void Acceptor::accept( ConnectionPtr connection )
+void Sapphire::Network::Acceptor::accept( ConnectionPtr connection )
 {
   m_io_strand.post( std::bind( &Acceptor::dispatchAccept, shared_from_this(), connection ) );
 }
 
-void Acceptor::listen( const std::string& host, const uint16_t& port )
+void Sapphire::Network::Acceptor::listen( const std::string& host, const uint16_t& port )
 {
   try
   {
@@ -109,21 +103,19 @@ void Acceptor::listen( const std::string& host, const uint16_t& port )
 
 }
 
-HivePtr Acceptor::getHive()
+Sapphire::Network::HivePtr Sapphire::Network::Acceptor::getHive()
 {
   return m_hive;
 }
 
-asio::ip::tcp::acceptor& Acceptor::getAcceptor()
+asio::ip::tcp::acceptor& Sapphire::Network::Acceptor::getAcceptor()
 {
   return m_acceptor;
 }
 
-bool Acceptor::hasError()
+bool Sapphire::Network::Acceptor::hasError()
 {
   uint32_t v1 = 1;
   uint32_t v2 = 1;
   return ( m_error_state.compare_exchange_strong( v1, v2 ) );
 }
-
-}

src/common/Network/Connection.cpp

@@ -3,11 +3,7 @@
 #include <functional>
 #include "Framework.h"
 
-namespace Sapphire::Network 
-{
-//-----------------------------------------------------------------------------
-
-Connection::Connection( HivePtr hive, FrameworkPtr pFw ) :
+Sapphire::Network::Connection::Connection( HivePtr hive, FrameworkPtr pFw ) :
   m_hive( hive ),
   m_socket( hive->getService() ),
   m_io_strand( hive->getService() ),
@@ -17,11 +13,11 @@ Connection::Connection( HivePtr hive, FrameworkPtr pFw ) :
 {
 }
 
-Connection::~Connection()
+Sapphire::Network::Connection::~Connection()
 {
 }
 
-void Connection::bind( const std::string& ip, uint16_t port )
+void Sapphire::Network::Connection::bind( const std::string& ip, uint16_t port )
 {
   asio::ip::tcp::endpoint endpoint( asio::ip::address::from_string( ip ), port );
   m_socket.open( endpoint.protocol() );
@@ -29,7 +25,7 @@ void Connection::bind( const std::string& ip, uint16_t port )
   m_socket.bind( endpoint );
 }
 
-void Connection::startSend()
+void Sapphire::Network::Connection::startSend()
 {
   if( !m_pending_sends.empty() )
   {
@@ -42,7 +38,7 @@ void Connection::startSend()
   }
 }
 
-void Connection::startRecv( int32_t total_bytes )
+void Sapphire::Network::Connection::startRecv( int32_t total_bytes )
 {
   if( total_bytes > 0 )
   {
@@ -65,7 +61,7 @@ void Connection::startRecv( int32_t total_bytes )
   }
 }
 
-void Connection::startError( const asio::error_code& error )
+void Sapphire::Network::Connection::startError( const asio::error_code& error )
 {
   uint32_t v1 = 1;
   uint32_t v2 = 0;
@@ -78,7 +74,7 @@ void Connection::startError( const asio::error_code& error )
   }
 }
 
-void Connection::handleConnect( const asio::error_code& error )
+void Sapphire::Network::Connection::handleConnect( const asio::error_code& error )
 {
   if( error || hasError() || m_hive->hasStopped() )
   {
@@ -98,8 +94,8 @@ void Connection::handleConnect( const asio::error_code& error )
   }
 }
 
-void
-Connection::handleSend( const asio::error_code& error, std::list< std::vector< uint8_t > >::iterator itr )
+void Sapphire::Network::Connection::handleSend( const asio::error_code& error,
+                                                std::list< std::vector< uint8_t > >::iterator itr )
 {
   if( error || hasError() || m_hive->hasStopped() )
   {
@@ -113,7 +109,7 @@ Connection::handleSend( const asio::error_code& error, std::list< std::vector< u
   }
 }
 
-void Connection::handleRecv( const asio::error_code& error, int32_t actual_bytes )
+void Sapphire::Network::Connection::handleRecv( const asio::error_code& error, int32_t actual_bytes )
 {
   if( error || hasError() || m_hive->hasStopped() )
   {
@@ -132,7 +128,7 @@ void Connection::handleRecv( const asio::error_code& error, int32_t actual_bytes
   }
 }
 
-void Connection::dispatchSend( std::vector< uint8_t > buffer )
+void Sapphire::Network::Connection::dispatchSend( std::vector< uint8_t > buffer )
 {
   bool should_start_send = m_pending_sends.empty();
   m_pending_sends.push_back( buffer );
@@ -142,7 +138,7 @@ void Connection::dispatchSend( std::vector< uint8_t > buffer )
   }
 }
 
-void Connection::dispatchRecv( int32_t total_bytes )
+void Sapphire::Network::Connection::dispatchRecv( int32_t total_bytes )
 {
   bool should_start_receive = m_pending_recvs.empty();
   m_pending_recvs.push_back( total_bytes );
@@ -153,61 +149,61 @@ void Connection::dispatchRecv( int32_t total_bytes )
 }
 
 
-void Connection::connect( const std::string& host, uint16_t port )
+void Sapphire::Network::Connection::connect( const std::string& host, uint16_t port )
 {
   asio::ip::tcp::resolver resolver( m_hive->getService() );
   asio::ip::tcp::resolver::query query( host, std::to_string( port ) );
   asio::ip::tcp::resolver::iterator iterator = resolver.resolve( query );
   m_socket.async_connect( *iterator,
-                          m_io_strand.wrap( std::bind( &Connection::handleConnect, shared_from_this(), std::placeholders::_1 ) ) );
+                          m_io_strand.wrap( std::bind( &Connection::handleConnect,
+                          shared_from_this(), std::placeholders::_1 ) ) );
 
 }
 
-void Connection::disconnect()
+void Sapphire::Network::Connection::disconnect()
 {
   onDisconnect();
   m_socket.close();
 }
 
-void Connection::recv( int32_t total_bytes )
+void Sapphire::Network::Connection::recv( int32_t total_bytes )
 {
   m_io_strand.post( std::bind( &Connection::dispatchRecv, shared_from_this(), total_bytes ) );
 }
 
-void Connection::send( const std::vector< uint8_t >& buffer )
+void Sapphire::Network::Connection::send( const std::vector< uint8_t >& buffer )
 {
   m_io_strand.post( std::bind( &Connection::dispatchSend, shared_from_this(), buffer ) );
 }
 
-asio::ip::tcp::socket& Connection::getSocket()
+asio::ip::tcp::socket& Sapphire::Network::Connection::getSocket()
 {
   return m_socket;
 }
 
-asio::strand& Connection::getStrand()
+asio::strand& Sapphire::Network::Connection::getStrand()
 {
   return m_io_strand;
 }
 
-HivePtr Connection::getHive()
+Sapphire::Network::HivePtr Sapphire::Network::Connection::getHive()
 {
   return m_hive;
 }
 
-void Connection::setReceiveBufferSize( int32_t size )
+void Sapphire::Network::Connection::setReceiveBufferSize( int32_t size )
 {
   m_receive_buffer_size = size;
 }
 
-int32_t Connection::getReceiveBufferSize() const
+int32_t Sapphire::Network::Connection::getReceiveBufferSize() const
 {
   return m_receive_buffer_size;
 }
 
-bool Connection::hasError()
+bool Sapphire::Network::Connection::hasError()
 {
   uint32_t v1 = 1;
   uint32_t v2 = 1;
   return ( m_error_state.compare_exchange_strong( v1, v2 ) );
 }
-}

src/common/Network/Connection.h

@@ -22,9 +22,7 @@ namespace Sapphire::Network
 {
 
   class Hive;
-
   class Acceptor;
-
   class Connection;
 
   //-----------------------------------------------------------------------------
@@ -32,7 +30,6 @@ namespace Sapphire::Network
   class Connection : public std::enable_shared_from_this< Connection >
   {
     friend class Acceptor;
-
     friend class Hive;
 
   protected:

src/common/Network/GamePacket.h

@@ -1,5 +1,5 @@
-#ifndef _GAMEPACKET_NEW_H
-#define _GAMEPACKET_NEW_H
+#ifndef _GAMEPACKET_H
+#define _GAMEPACKET_H
 
 #include <stdint.h>
 #include <iostream>
@@ -19,7 +19,6 @@ namespace Sapphire::Network::Packets
 
   // Must forward define these in order to enable the compiler to produce the
   // correct template functions.
-
   template< typename T, typename T1 >
   class FFXIVIpcPacket;
 
@@ -330,7 +329,6 @@ protected:
     std::vector< uint8_t > m_data;
   };
 
-
 }
 
-#endif /*_CORE_NETWORK_PACKETS_CGAMEPACKETNEW_H*/
+#endif

src/common/Network/Hive.cpp

@@ -2,44 +2,41 @@
 #include <functional>
 #include "Hive.h"
 
-namespace Sapphire::Network
-{
-
 //-----------------------------------------------------------------------------
 
-Hive::Hive() :
+Sapphire::Network::Hive::Hive() :
   m_work_ptr( new asio::io_service::work( m_io_service ) ),
   m_shutdown( 0 )
 {
 }
 
-Hive::~Hive()
+Sapphire::Network::Hive::~Hive()
 {
 }
 
-asio::io_service& Hive::getService()
+asio::io_service& Sapphire::Network::Hive::getService()
 {
   return m_io_service;
 }
 
-bool Hive::hasStopped()
+bool Sapphire::Network::Hive::hasStopped()
 {
   uint32_t v1 = 1;
   uint32_t v2 = 1;
   return m_shutdown.compare_exchange_strong( v1, v2 );
 }
 
-void Hive::poll()
+void Sapphire::Network::Hive::poll()
 {
   m_io_service.poll();
 }
 
-void Hive::run()
+void Sapphire::Network::Hive::run()
 {
   m_io_service.run();
 }
 
-void Hive::stop()
+void Sapphire::Network::Hive::stop()
 {
   uint32_t v1 = 1;
   uint32_t v2 = 0;
@@ -51,7 +48,7 @@ void Hive::stop()
   }
 }
 
-void Hive::reset()
+void Sapphire::Network::Hive::reset()
 {
   uint32_t v1 = 0;
   uint32_t v2 = 1;
@@ -61,5 +58,3 @@ void Hive::reset()
     m_work_ptr.reset( new asio::io_service::work( m_io_service ) );
   }
 }
-
-}

src/common/Network/PacketContainer.h

@@ -12,7 +12,6 @@ namespace Sapphire::Network::Packets
 {
 
   using FFXIVPacketBasePtr = std::shared_ptr< FFXIVPacketBase >;
-
   class PacketContainer
   {
   public:

src/common/Util/SpawnIndexAllocator.h

@@ -9,7 +9,6 @@ namespace Sapphire::Util
 {
 
   template< typename T, typename ActorIdType = uint32_t >
-
   class SpawnIndexAllocator
   {
   public:

src/world/Actor/BNpc.h

@@ -13,11 +13,11 @@
 namespace Sapphire::Entity
 {
 
-  typedef struct
+  using HateListEntry = struct
   {
     uint32_t m_hateAmount;
     CharaPtr m_pChara;
-  } HateListEntry;
+  };
 
   enum class BNpcState
   {

src/world/Actor/BNpcTemplate.h

@@ -25,7 +25,7 @@ namespace Sapphire::Entity
     uint8_t m_customize[26];
 
   public:
-    BNpcTemplate() {};
+    BNpcTemplate() = default;
 
     BNpcTemplate( uint32_t id, uint32_t baseId, uint32_t nameId, uint64_t weaponMain, uint64_t weaponSub, uint8_t aggressionMode,
                   uint8_t enemyType, uint8_t onlineStatus, uint8_t pose, uint16_t modelChara,

src/world/Actor/Player.h

@@ -60,8 +60,7 @@ namespace Sapphire::Entity
                                Action::ActionCallback interruptCallback, uint64_t additional );
 
     /*! start/register a normal event */
-    void
-    eventStart( uint64_t actorId, uint32_t eventId, Event::EventHandler::EventType eventParam, uint8_t eventParam1,
+    void eventStart( uint64_t actorId, uint32_t eventId, Event::EventHandler::EventType eventParam, uint8_t eventParam1,
                      uint32_t eventParam2, Event::EventHandler::EventFinishCallback callback = nullptr );
 
     /*! play a subevent */
@@ -70,9 +69,8 @@ namespace Sapphire::Entity
     void playGilShop( uint32_t eventId, uint32_t flags,
                       Event::EventHandler::SceneReturnCallback eventCallback );
 
-    void
-    directorPlayScene( uint32_t eventId, uint32_t scene, uint32_t flags, uint32_t eventParam3, uint32_t eventParam4,
-                       uint32_t eventParam5 = 0 );
+    void directorPlayScene( uint32_t eventId, uint32_t scene, uint32_t flags, uint32_t eventParam3,
+                            uint32_t eventParam4, uint32_t eventParam5 = 0 );
 
     /*! play a subevent */
     void playScene( uint32_t eventId, uint32_t scene, uint32_t flags,