move lobby to Sapphire::Lobby, move common lib to Sapphire::Common

src/common/Config/ConfigMgr.cpp

@@ -5,12 +5,14 @@
 
 namespace fs = std::experimental::filesystem;
 
+using namespace Sapphire::Common;
+
 /**
  * Loads an ini file and parses it
  * @param configName the name of ini file relative to m_configFolderRoot to load alongside global.ini
  * @return true if loading was successful
  */
-bool Sapphire::ConfigMgr::loadConfig( const std::string& configName )
+bool ConfigMgr::loadConfig( const std::string& configName )
 {
   // get global config
   auto configFile = fs::path( fs::path( m_configFolderRoot ) / configName );
@@ -29,7 +31,7 @@ bool Sapphire::ConfigMgr::loadConfig( const std::string& configName )
   return true;
 }
 
-bool Sapphire::ConfigMgr::loadGlobalConfig( Common::Config::GlobalConfig& config, const std::string& configName )
+bool ConfigMgr::loadGlobalConfig( Common::Config::GlobalConfig& config, const std::string& configName )
 {
   auto configFile = fs::path( fs::path( m_configFolderRoot ) / configName );
 
@@ -71,7 +73,7 @@ bool Sapphire::ConfigMgr::loadGlobalConfig( Common::Config::GlobalConfig& config
   return true;
 }
 
-bool Sapphire::ConfigMgr::copyDefaultConfig( const std::string& configName )
+bool ConfigMgr::copyDefaultConfig( const std::string& configName )
 {
   fs::path configPath( m_configFolderRoot );
   configPath /= configName;

src/common/Config/ConfigMgr.h

@@ -8,7 +8,7 @@
 #include <stdint.h>
 #include "ConfigDef.h"
 
-namespace Sapphire
+namespace Sapphire::Common
 {
     class ConfigMgr
     {

src/common/Crypt/base64.cpp

@@ -41,7 +41,7 @@ static inline bool is_base64( uint8_t c )
   return ( isalnum( c ) || ( c == '+' ) || ( c == '/' ) );
 }
 
-std::string Sapphire::Util::base64Encode( uint8_t const* bytes_to_encode, uint32_t in_len )
+std::string Sapphire::Common::Util::base64Encode( uint8_t const* bytes_to_encode, uint32_t in_len )
 {
   std::string ret;
   int32_t i = 0;
@@ -87,7 +87,7 @@ std::string Sapphire::Util::base64Encode( uint8_t const* bytes_to_encode, uint32
 
 }
 
-std::string Sapphire::Util::base64Decode( std::string const& encoded_string )
+std::string Sapphire::Common::Util::base64Decode( std::string const& encoded_string )
 {
   int32_t in_len = encoded_string.size();
   int32_t i = 0;

src/common/Crypt/base64.h

@@ -1,6 +1,6 @@
 #include <string>
 
-namespace Sapphire::Util
+namespace Sapphire::Common::Util
 {
   std::string base64Encode( uint8_t const*, uint32_t len );
 

src/common/Crypt/md5.cpp

@@ -37,7 +37,7 @@
   (b)[(i) + 3] = (uint8_t) ( (n) >> 24 );       \
 }
 
-void Sapphire::Util::md5_starts( md5_context* ctx )
+void Sapphire::Common::Util::md5_starts( md5_context* ctx )
 {
   ctx->total[ 0 ] = 0;
   ctx->total[ 1 ] = 0;
@@ -48,7 +48,7 @@ void Sapphire::Util::md5_starts( md5_context* ctx )
   ctx->state[ 3 ] = 0x10325476;
 }
 
-void md5_process( Sapphire::Util::md5_context* ctx, uint8_t data[64] )
+void md5_process( Sapphire::Common::Util::md5_context* ctx, uint8_t data[64] )
 {
   uint32_t X[16], A, B, C, D;
 
@@ -171,7 +171,7 @@ void md5_process( Sapphire::Util::md5_context* ctx, uint8_t data[64] )
   ctx->state[ 3 ] += D;
 }
 
-void Sapphire::Util::md5_update( md5_context* ctx, uint8_t* input, uint32_t length )
+void Sapphire::Common::Util::md5_update( md5_context* ctx, uint8_t* input, uint32_t length )
 {
   uint32_t left, fill;
 
@@ -219,7 +219,7 @@ static uint8_t md5_padding[64] =
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
   };
 
-void Sapphire::Util::md5_finish( md5_context* ctx, uint8_t digest[16] )
+void Sapphire::Common::Util::md5_finish( md5_context* ctx, uint8_t digest[16] )
 {
   uint32_t last, padn;
   uint32_t high, low;
@@ -248,7 +248,7 @@ void Sapphire::Util::md5_finish( md5_context* ctx, uint8_t digest[16] )
 * those are the standard RFC 1321 test vectors
 */
 
-void Sapphire::Util::md5( uint8_t* text, uint8_t* hash, int32_t size )
+void Sapphire::Common::Util::md5( uint8_t* text, uint8_t* hash, int32_t size )
 {
   md5_context ctx;
   md5_starts( &ctx );

src/common/Crypt/md5.h

@@ -3,7 +3,7 @@
 
 #include <stdint.h>
 
-namespace Sapphire::Util
+namespace Sapphire::Common::Util
 {
   using md5_context = struct
   {

src/common/Forwards.h

@@ -3,7 +3,7 @@
 
 #include <memory>
 
-namespace Sapphire
+namespace Sapphire::Common
 {
   class ConfigMgr;
   class Framework;
@@ -11,7 +11,7 @@ namespace Sapphire
   using FrameworkPtr = std::shared_ptr< Framework >;
 }
 
-namespace Sapphire::Network
+namespace Sapphire::Common::Network
 {
   class Hive;
   class Acceptor;
@@ -21,7 +21,7 @@ namespace Sapphire::Network
   using ConnectionPtr = std::shared_ptr< Connection >;
 }
 
-namespace Sapphire::Network::Packets
+namespace Sapphire::Common::Network::Packets
 {
   class GamePacket;
   class FFXIVPacketBase;

src/common/Framework.h

@@ -7,7 +7,7 @@
 #include <memory>
 #include <cassert>
 
-namespace Sapphire
+namespace Sapphire::Common
 {
 
   class Framework

src/common/Network/Acceptor.cpp

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

src/common/Network/Acceptor.h

@@ -13,7 +13,7 @@
 #include <vector>
 
 
-namespace Sapphire::Network
+namespace Sapphire::Common::Network
 {
 
   class Connection;

src/common/Network/CommonActorControl.h

@@ -10,7 +10,7 @@
 // The following enumerations are structures to require their type be included.
 // They are also defined within the Sapphire::Common namespace to avoid collisions.
 // +---------------------------------------------------------------------------
-namespace Sapphire::Network::ActorControl
+namespace Sapphire::Common::Network::ActorControl
 {
 
 enum ActorControlType : uint16_t

src/common/Network/CommonNetwork.h

@@ -5,7 +5,7 @@
 #include <vector>
 #include "PacketDef/Ipcs.h"
 
-namespace Sapphire::Network::Packets
+namespace Sapphire::Common::Network::Packets
 {
 
   /**

src/common/Network/Connection.cpp

@@ -3,7 +3,9 @@
 #include <functional>
 #include "Framework.h"
 
-Sapphire::Network::Connection::Connection( HivePtr hive, FrameworkPtr pFw ) :
+using namespace Sapphire::Common;
+
+Network::Connection::Connection( HivePtr hive, FrameworkPtr pFw ) :
   m_hive( hive ),
   m_socket( hive->getService() ),
   m_io_strand( hive->getService() ),
@@ -13,11 +15,9 @@ Sapphire::Network::Connection::Connection( HivePtr hive, FrameworkPtr pFw ) :
 {
 }
 
-Sapphire::Network::Connection::~Connection()
+Network::Connection::~Connection() = default;
-{
-}
 
-void Sapphire::Network::Connection::bind( const std::string& ip, uint16_t port )
+void 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() );
@@ -25,7 +25,7 @@ void Sapphire::Network::Connection::bind( const std::string& ip, uint16_t port )
   m_socket.bind( endpoint );
 }
 
-void Sapphire::Network::Connection::startSend()
+void Network::Connection::startSend()
 {
   if( !m_pending_sends.empty() )
   {
@@ -38,7 +38,7 @@ void Sapphire::Network::Connection::startSend()
   }
 }
 
-void Sapphire::Network::Connection::startRecv( int32_t total_bytes )
+void Network::Connection::startRecv( int32_t total_bytes )
 {
   if( total_bytes > 0 )
   {
@@ -61,7 +61,7 @@ void Sapphire::Network::Connection::startRecv( int32_t total_bytes )
   }
 }
 
-void Sapphire::Network::Connection::startError( const asio::error_code& error )
+void Network::Connection::startError( const asio::error_code& error )
 {
   uint32_t v1 = 1;
   uint32_t v2 = 0;
@@ -74,7 +74,7 @@ void Sapphire::Network::Connection::startError( const asio::error_code& error )
   }
 }
 
-void Sapphire::Network::Connection::handleConnect( const asio::error_code& error )
+void Network::Connection::handleConnect( const asio::error_code& error )
 {
   if( error || hasError() || m_hive->hasStopped() )
   {
@@ -94,7 +94,7 @@ void Sapphire::Network::Connection::handleConnect( const asio::error_code& error
   }
 }
 
-void Sapphire::Network::Connection::handleSend( const asio::error_code& error,
+void Network::Connection::handleSend( const asio::error_code& error,
                                       std::list< std::vector< uint8_t > >::iterator itr )
 {
   if( error || hasError() || m_hive->hasStopped() )
@@ -109,7 +109,7 @@ void Sapphire::Network::Connection::handleSend( const asio::error_code& error,
   }
 }
 
-void Sapphire::Network::Connection::handleRecv( const asio::error_code& error, int32_t actual_bytes )
+void Network::Connection::handleRecv( const asio::error_code& error, int32_t actual_bytes )
 {
   if( error || hasError() || m_hive->hasStopped() )
   {
@@ -128,7 +128,7 @@ void Sapphire::Network::Connection::handleRecv( const asio::error_code& error, i
   }
 }
 
-void Sapphire::Network::Connection::dispatchSend( std::vector< uint8_t > buffer )
+void Network::Connection::dispatchSend( std::vector< uint8_t > buffer )
 {
   bool should_start_send = m_pending_sends.empty();
   m_pending_sends.push_back( buffer );
@@ -138,7 +138,7 @@ void Sapphire::Network::Connection::dispatchSend( std::vector< uint8_t > buffer
   }
 }
 
-void Sapphire::Network::Connection::dispatchRecv( int32_t total_bytes )
+void Network::Connection::dispatchRecv( int32_t total_bytes )
 {
   bool should_start_receive = m_pending_recvs.empty();
   m_pending_recvs.push_back( total_bytes );
@@ -149,7 +149,7 @@ void Sapphire::Network::Connection::dispatchRecv( int32_t total_bytes )
 }
 
 
-void Sapphire::Network::Connection::connect( const std::string& host, uint16_t port )
+void 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 ) );
@@ -160,48 +160,48 @@ void Sapphire::Network::Connection::connect( const std::string& host, uint16_t p
 
 }
 
-void Sapphire::Network::Connection::disconnect()
+void Network::Connection::disconnect()
 {
   onDisconnect();
   m_socket.close();
 }
 
-void Sapphire::Network::Connection::recv( int32_t total_bytes )
+void Network::Connection::recv( int32_t total_bytes )
 {
   m_io_strand.post( std::bind( &Connection::dispatchRecv, shared_from_this(), total_bytes ) );
 }
 
-void Sapphire::Network::Connection::send( const std::vector< uint8_t >& buffer )
+void 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& Sapphire::Network::Connection::getSocket()
+asio::ip::tcp::socket& Network::Connection::getSocket()
 {
   return m_socket;
 }
 
-asio::strand& Sapphire::Network::Connection::getStrand()
+asio::strand& Network::Connection::getStrand()
 {
   return m_io_strand;
 }
 
-Sapphire::Network::HivePtr Sapphire::Network::Connection::getHive()
+Network::HivePtr Network::Connection::getHive()
 {
   return m_hive;
 }
 
-void Sapphire::Network::Connection::setReceiveBufferSize( int32_t size )
+void Network::Connection::setReceiveBufferSize( int32_t size )
 {
   m_receive_buffer_size = size;
 }
 
-int32_t Sapphire::Network::Connection::getReceiveBufferSize() const
+int32_t Network::Connection::getReceiveBufferSize() const
 {
   return m_receive_buffer_size;
 }
 
-bool Sapphire::Network::Connection::hasError()
+bool Network::Connection::hasError()
 {
   uint32_t v1 = 1;
   uint32_t v2 = 1;

src/common/Network/Connection.h

@@ -12,13 +12,13 @@
 #include "Acceptor.h"
 #include <memory>
 
-namespace Sapphire
+namespace Sapphire::Common
 {
   class Framework;
   using FrameworkPtr = std::shared_ptr< Framework >;
 }
 
-namespace Sapphire::Network
+namespace Sapphire::Common::Network
 {
 
   class Hive;
@@ -41,7 +41,7 @@ namespace Sapphire::Network
     std::list< std::vector< uint8_t > > m_pending_sends;
     int32_t m_receive_buffer_size;
     std::atomic< uint32_t > m_error_state;
-    Sapphire::FrameworkPtr m_pFw;
+    FrameworkPtr m_pFw;
 
     Connection( HivePtr hive, FrameworkPtr pFw );
 

src/common/Network/GamePacket.h

@@ -14,7 +14,7 @@
 #include "CommonNetwork.h"
 #include "PacketDef/Ipcs.h"
 
-namespace Sapphire::Network::Packets
+namespace Sapphire::Common::Network::Packets
 {
 
   // Must forward define these in order to enable the compiler to produce the

src/common/Network/GamePacketParser.cpp

@@ -3,9 +3,10 @@
 
 #include <string.h>   // memcpy
 
-using namespace Sapphire::Network::Packets;
+using namespace Sapphire::Common;
+using namespace Sapphire::Common::Network::Packets;
 
-PacketParseResult Sapphire::Network::Packets::getHeader( const std::vector< uint8_t >& buffer,
+PacketParseResult Network::Packets::getHeader( const std::vector< uint8_t >& buffer,
                                                          const uint32_t offset,
                                                          FFXIVARR_PACKET_HEADER& header )
 {
@@ -25,7 +26,7 @@ PacketParseResult Sapphire::Network::Packets::getHeader( const std::vector< uint
   return Success;
 }
 
-PacketParseResult Sapphire::Network::Packets::getSegmentHeader( const std::vector< uint8_t >& buffer,
+PacketParseResult Network::Packets::getSegmentHeader( const std::vector< uint8_t >& buffer,
                                                                 const uint32_t offset,
                                                                 FFXIVARR_PACKET_SEGMENT_HEADER& header )
 {
@@ -42,7 +43,7 @@ PacketParseResult Sapphire::Network::Packets::getSegmentHeader( const std::vecto
   return Success;
 }
 
-PacketParseResult Sapphire::Network::Packets::getPackets( const std::vector< uint8_t >& buffer,
+PacketParseResult Network::Packets::getPackets( const std::vector< uint8_t >& buffer,
                                                           const uint32_t offset,
                                                           const FFXIVARR_PACKET_HEADER& packetHeader,
                                                           std::vector< FFXIVARR_PACKET_RAW >& packets )
@@ -81,7 +82,7 @@ PacketParseResult Sapphire::Network::Packets::getPackets( const std::vector< uin
   return Success;
 }
 
-PacketParseResult Sapphire::Network::Packets::getPacket( const std::vector< uint8_t >& buffer, const uint32_t offset,
+PacketParseResult Network::Packets::getPacket( const std::vector< uint8_t >& buffer, const uint32_t offset,
                                                          FFXIVARR_PACKET_RAW& packet )
 {
   // Copy segment header
@@ -103,7 +104,7 @@ PacketParseResult Sapphire::Network::Packets::getPacket( const std::vector< uint
   return Success;
 }
 
-bool Sapphire::Network::Packets::checkHeader( const FFXIVARR_PACKET_HEADER& header )
+bool Network::Packets::checkHeader( const FFXIVARR_PACKET_HEADER& header )
 {
   // Max size of the packet is capped at 1MB for now.
   if( header.size > 1 * 1024 * 1024 )
@@ -116,7 +117,7 @@ bool Sapphire::Network::Packets::checkHeader( const FFXIVARR_PACKET_HEADER& head
   return true;
 }
 
-bool Sapphire::Network::Packets::checkSegmentHeader( const FFXIVARR_PACKET_SEGMENT_HEADER& header )
+bool Network::Packets::checkSegmentHeader( const FFXIVARR_PACKET_SEGMENT_HEADER& header )
 {
   // Max size of individual message is capped at 256KB for now.
   if( header.size > 256 * 1024 )

src/common/Network/GamePacketParser.h

@@ -3,7 +3,7 @@
 
 #include "CommonNetwork.h"
 
-namespace Sapphire::Network::Packets
+namespace Sapphire::Common::Network::Packets
 {
 
   enum PacketParseResult

src/common/Network/Hive.cpp

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

src/common/Network/Hive.h

@@ -5,7 +5,7 @@
 #include <atomic>
 #include <memory>
 
-namespace Sapphire:: Network
+namespace Sapphire::Common::Network
 {
 
   class Hive : public std::enable_shared_from_this< Hive >

src/common/Network/PacketContainer.cpp

@@ -7,7 +7,9 @@
 #include <string.h>
 #include <memory>
 
-Sapphire::Network::Packets::PacketContainer::PacketContainer( uint32_t segmentTargetOverride ) :
+using namespace Sapphire::Common;
+
+Network::Packets::PacketContainer::PacketContainer( uint32_t segmentTargetOverride ) :
   m_segmentTargetOverride( segmentTargetOverride )
 {
   memset( &m_ipcHdr, 0, sizeof( FFXIVARR_PACKET_HEADER ) );
@@ -15,12 +17,12 @@ Sapphire::Network::Packets::PacketContainer::PacketContainer( uint32_t segmentTa
   m_ipcHdr.count = 0;
 }
 
-Sapphire::Network::Packets::PacketContainer::~PacketContainer()
+Network::Packets::PacketContainer::~PacketContainer()
 {
   m_entryList.clear();
 }
 
-void Sapphire::Network::Packets::PacketContainer::addPacket( Sapphire::Network::Packets::FFXIVPacketBasePtr entry )
+void Network::Packets::PacketContainer::addPacket( Network::Packets::FFXIVPacketBasePtr entry )
 {
   m_entryList.push_back( entry );
 
@@ -28,7 +30,7 @@ void Sapphire::Network::Packets::PacketContainer::addPacket( Sapphire::Network::
   m_ipcHdr.count++;
 }
 
-void Sapphire::Network::Packets::PacketContainer::fillSendBuffer( std::vector< uint8_t >& sendBuffer )
+void Network::Packets::PacketContainer::fillSendBuffer( std::vector< uint8_t >& sendBuffer )
 {
   std::vector< uint8_t > tempBuffer( m_ipcHdr.size );
   memset( &tempBuffer[ 0 ], 0, m_ipcHdr.size );
@@ -67,7 +69,7 @@ void Sapphire::Network::Packets::PacketContainer::fillSendBuffer( std::vector< u
 
 }
 
-std::string Sapphire::Network::Packets::PacketContainer::toString()
+std::string Network::Packets::PacketContainer::toString()
 {
   std::vector< uint8_t > tmpBuffer;
 

src/common/Network/PacketContainer.h

@@ -8,7 +8,7 @@
 #include "GamePacket.h"
 #include "Forwards.h"
 
-namespace Sapphire::Network::Packets
+namespace Sapphire::Common::Network::Packets
 {
 
   using FFXIVPacketBasePtr = std::shared_ptr< FFXIVPacketBase >;

src/common/Network/PacketDef/Chat/ServerChatDef.h

@@ -4,10 +4,8 @@
 #include <Common.h>
 #include <Network/CommonNetwork.h>
 
-namespace Sapphire {
+namespace Sapphire::Common::Network::Packets::Server
-namespace Network {
+{
-namespace Packets {
-namespace Server {
 
 /**
 * Structural representation of the packet sent by the server as response
@@ -31,10 +29,7 @@ struct FFXIVIpcTellErrNotFound : FFXIVIpcBasePacket< TellErrNotFound >
   char receipientName[32];
 };
 
-} /* Server */
+} /* Sapphire::Common::Network::Packets::Server */
-} /* Packets */
-} /* Network */
-} /* Sapphire */
 
 
 

src/common/Network/PacketDef/Ipcs.h

@@ -3,7 +3,7 @@
 
 #include <stdint.h>
 
-namespace Sapphire::Network::Packets
+namespace Sapphire::Common::Network::Packets
 {
 
   ////////////////////////////////////////////////////////////////////////////////

src/common/Network/PacketDef/Lobby/ServerLobbyDef.h

@@ -4,10 +4,7 @@
 #include <Common.h>
 #include <Network/CommonNetwork.h>
 
-namespace Sapphire {
+namespace Sapphire::Common::Network::Packets::Server {
-namespace Network {
-namespace Packets {
-namespace Server {
 
 struct FFXIVIpcRetainerList :
   FFXIVIpcBasePacket< LobbyRetainerList >
@@ -152,7 +149,5 @@ struct FFXIVIpcLobbyError : FFXIVIpcBasePacket< LobbyError >
 };
 
 }
-}
+
-}
-}
 #endif

src/common/Network/PacketDef/Zone/ClientZoneDef.h

@@ -4,10 +4,8 @@
 #include <Common.h>
 #include <Network/CommonNetwork.h>
 
-namespace Sapphire {
+namespace Sapphire::Common::Network::Packets::Client
-namespace Network {
+{
-namespace Packets {
-namespace Client {
 
 struct FFXIVIpcGmCommand1 :
   FFXIVIpcBasePacket< GMCommand1 >
@@ -325,9 +323,6 @@ struct FFXIVIpcMarketBoardRequestItemListingInfo :
   /* 0000 */ uint32_t requestId;
 };
 
-}
-}
-}
 }
 
 #endif //_CORE_NETWORK_PACKETS_ZONE_CLIENT_IPC_H

src/common/Network/PacketDef/Zone/ServerZoneDef.h

@@ -10,7 +10,7 @@
 #include <Common.h>
 #include <Network/CommonNetwork.h>
 
-namespace Sapphire::Network::Packets::Server
+namespace Sapphire::Common::Network::Packets::Server
 {
 
   /**

src/lobby/Forwards.h

@@ -12,20 +12,24 @@ x ## Ptr make_ ## x( Args &&...args ) { \
 return std::make_shared< x >( std::forward< Args >( args ) ... ); }\
 typedef std::vector< x > x ## PtrList;
 
-namespace Sapphire
+namespace Sapphire::Lobby
 {
   TYPE_FORWARD( LobbySession );
 }
 
-namespace Sapphire::Network
+namespace Sapphire::Lobby::Network
+{
+  TYPE_FORWARD( GameConnection );
+}
+
+namespace Sapphire::Common::Network
 {
   TYPE_FORWARD( Hive );
   TYPE_FORWARD( Acceptor );
   TYPE_FORWARD( Connection );
-  TYPE_FORWARD( GameConnection );
 }
 
-namespace Sapphire::Network::Packets
+namespace Sapphire::Common::Network::Packets
 {
   TYPE_FORWARD( GamePacket );
   TYPE_FORWARD( FFXIVPacketBase );

src/lobby/GameConnection.cpp

@@ -15,30 +15,30 @@
 #include "RestConnector.h"
 #include "LobbySession.h"
 
-extern Sapphire::ServerLobby g_serverLobby;
+using namespace Sapphire;
-extern Sapphire::Network::RestConnector g_restConnector;
+using namespace Sapphire::Common::Network::Packets;
+using namespace Sapphire::Common::Network::Packets::Server;
 
-using namespace Sapphire::Common;
+extern Lobby::ServerLobby g_serverLobby;
-using namespace Sapphire::Network::Packets;
+extern Lobby::Network::RestConnector g_restConnector;
-using namespace Sapphire::Network::Packets::Server;
 
-Sapphire::Network::GameConnection::GameConnection( Sapphire::Network::HivePtr pHive,
+Lobby::Network::GameConnection::GameConnection( Common::Network::HivePtr pHive,
-                                                   Sapphire::Network::AcceptorPtr pAcceptor,
+                                                Common::Network::AcceptorPtr pAcceptor,
-                                                   FrameworkPtr pFw ) :
+                                                Common::FrameworkPtr pFw ) :
-  Connection( pHive, pFw ),
+  Common::Network::Connection( pHive, pFw ),
   m_pAcceptor( pAcceptor ),
   m_bEncryptionInitialized( false )
 {
 }
 
-Sapphire::Network::GameConnection::~GameConnection()
+Lobby::Network::GameConnection::~GameConnection()
 {
 
 }
 
 
 // overwrite the parents onConnect for our game socket needs
-void Sapphire::Network::GameConnection::onAccept( const std::string& host, uint16_t port )
+void Lobby::Network::GameConnection::onAccept( const std::string& host, uint16_t port )
 {
   auto connection = make_GameConnection( m_hive, m_pAcceptor, m_pFw );
   m_pAcceptor->accept( connection );
@@ -47,17 +47,17 @@ void Sapphire::Network::GameConnection::onAccept( const std::string& host, uint1
 }
 
 
-void Sapphire::Network::GameConnection::onDisconnect()
+void Lobby::Network::GameConnection::onDisconnect()
 {
   Logger::debug( "DISCONNECT" );
 }
 
-void Sapphire::Network::GameConnection::onRecv( std::vector< uint8_t >& buffer )
+void Lobby::Network::GameConnection::onRecv( std::vector< uint8_t >& buffer )
 {
   m_packets.insert( std::end( m_packets ), std::begin( buffer ), std::end( buffer ) );
   // This is assumed packet always start with valid FFXIVARR_PACKET_HEADER for now.
-  Packets::FFXIVARR_PACKET_HEADER packetHeader{};
+  Common::Network::Packets::FFXIVARR_PACKET_HEADER packetHeader{};
-  const auto headerResult = Packets::getHeader( m_packets, 0, packetHeader );
+  const auto headerResult = Common::Network::Packets::getHeader( m_packets, 0, packetHeader );
 
   if( headerResult == Incomplete )
     return;
@@ -70,8 +70,8 @@ void Sapphire::Network::GameConnection::onRecv( std::vector< uint8_t >& buffer )
   }
 
   // Dissect packet list
-  std::vector< Packets::FFXIVARR_PACKET_RAW > packetList;
+  std::vector< Common::Network::Packets::FFXIVARR_PACKET_RAW > packetList;
-  const auto packetResult = Packets::getPackets( m_packets, sizeof( struct FFXIVARR_PACKET_HEADER ),
+  const auto packetResult = Common::Network::Packets::getPackets( m_packets, sizeof( struct FFXIVARR_PACKET_HEADER ),
                                                                   packetHeader, packetList );
 
   if( packetResult == Incomplete )
@@ -90,13 +90,13 @@ void Sapphire::Network::GameConnection::onRecv( std::vector< uint8_t >& buffer )
 
 }
 
-void Sapphire::Network::GameConnection::onError( const asio::error_code& error )
+void Lobby::Network::GameConnection::onError( const asio::error_code& error )
 {
   Logger::info( "GameConnection closed: {0}", error.message() );
 }
 
 void
-Sapphire::Network::GameConnection::sendError( uint64_t sequence, uint32_t errorcode, uint16_t messageId, uint32_t tmpId )
+Lobby::Network::GameConnection::sendError( uint64_t sequence, uint32_t errorcode, uint16_t messageId, uint32_t tmpId )
 {
   auto errorPacket = makeLobbyPacket< FFXIVIpcLobbyError >( tmpId );
   errorPacket->data().seq = sequence;
@@ -108,7 +108,7 @@ Sapphire::Network::GameConnection::sendError( uint64_t sequence, uint32_t errorc
   sendPacket( pRP );
 }
 
-void Sapphire::Network::GameConnection::getCharList( FFXIVARR_PACKET_RAW& packet, uint32_t tmpId )
+void Lobby::Network::GameConnection::getCharList( FFXIVARR_PACKET_RAW& packet, uint32_t tmpId )
 {
   uint64_t sequence = *reinterpret_cast< uint64_t* >( &packet.data[ 0 ] + 0x10 );
   Logger::info( "Sequence [{0}]", sequence );
@@ -192,7 +192,7 @@ void Sapphire::Network::GameConnection::getCharList( FFXIVARR_PACKET_RAW& packet
   }
 }
 
-void Sapphire::Network::GameConnection::enterWorld( FFXIVARR_PACKET_RAW& packet, uint32_t tmpId )
+void Lobby::Network::GameConnection::enterWorld( FFXIVARR_PACKET_RAW& packet, uint32_t tmpId )
 {
   uint64_t sequence = *reinterpret_cast< uint64_t* >( &packet.data[ 0 ] + 0x10 );
   Logger::info( "Sequence [{0}]", sequence );
@@ -234,7 +234,7 @@ void Sapphire::Network::GameConnection::enterWorld( FFXIVARR_PACKET_RAW& packet,
   sendPacket( pRP );
 }
 
-bool Sapphire::Network::GameConnection::sendServiceAccountList( FFXIVARR_PACKET_RAW& packet, uint32_t tmpId )
+bool Lobby::Network::GameConnection::sendServiceAccountList( FFXIVARR_PACKET_RAW& packet, uint32_t tmpId )
 {
   LobbySessionPtr pSession = g_serverLobby.getSession( ( char* ) &packet.data[ 0 ] + 0x22 );
 
@@ -273,7 +273,7 @@ bool Sapphire::Network::GameConnection::sendServiceAccountList( FFXIVARR_PACKET_
   return false;
 }
 
-bool Sapphire::Network::GameConnection::createOrModifyChar( FFXIVARR_PACKET_RAW& packet, uint32_t tmpId )
+bool Lobby::Network::GameConnection::createOrModifyChar( FFXIVARR_PACKET_RAW& packet, uint32_t tmpId )
 {
   uint64_t sequence = *reinterpret_cast< uint64_t* >( &packet.data[ 0 ] + 0x10 );
   uint8_t type = *reinterpret_cast< uint8_t* >( &packet.data[ 0 ] + 0x29 );
@@ -381,7 +381,7 @@ bool Sapphire::Network::GameConnection::createOrModifyChar( FFXIVARR_PACKET_RAW&
   return false;
 }
 
-void Sapphire::Network::GameConnection::handleGamePacket( Packets::FFXIVARR_PACKET_RAW& packet )
+void Lobby::Network::GameConnection::handleGamePacket( Common::Network::Packets::FFXIVARR_PACKET_RAW& packet )
 {
 
   uint32_t tmpId = packet.segHdr.target_actor;
@@ -419,7 +419,7 @@ void Sapphire::Network::GameConnection::handleGamePacket( Packets::FFXIVARR_PACK
 
 }
 
-void Sapphire::Network::GameConnection::sendPacket( Packets::LobbyPacketContainer& pLpc )
+void Lobby::Network::GameConnection::sendPacket( Packets::LobbyPacketContainer& pLpc )
 {
   uint16_t size = pLpc.getSize();
   uint8_t* dataPtr = pLpc.getRawData( false );
@@ -428,7 +428,7 @@ void Sapphire::Network::GameConnection::sendPacket( Packets::LobbyPacketContaine
   send( sendBuffer );
 }
 
-void Sapphire::Network::GameConnection::sendPackets( Packets::PacketContainer* pPacket )
+void Lobby::Network::GameConnection::sendPackets( Common::Network::Packets::PacketContainer* pPacket )
 {
   std::vector< uint8_t > sendBuffer;
 
@@ -436,14 +436,14 @@ void Sapphire::Network::GameConnection::sendPackets( Packets::PacketContainer* p
   send( sendBuffer );
 }
 
-void Sapphire::Network::GameConnection::sendSinglePacket( FFXIVPacketBasePtr pPacket )
+void Lobby::Network::GameConnection::sendSinglePacket( FFXIVPacketBasePtr pPacket )
 {
   PacketContainer pRP = PacketContainer();
   pRP.addPacket( pPacket );
   sendPackets( &pRP );
 }
 
-void Sapphire::Network::GameConnection::generateEncryptionKey( uint32_t key, const std::string& keyPhrase )
+void Lobby::Network::GameConnection::generateEncryptionKey( uint32_t key, const std::string& keyPhrase )
 {
   memset( m_baseKey, 0, 0x2C );
   m_baseKey[ 0 ] = 0x78;
@@ -454,11 +454,11 @@ void Sapphire::Network::GameConnection::generateEncryptionKey( uint32_t key, con
   m_baseKey[ 8 ] = 0xC6;
   m_baseKey[ 9 ] = 0x11;
   memcpy( ( char* ) m_baseKey + 0x0C, keyPhrase.c_str(), keyPhrase.size() );
-  Sapphire::Util::md5( m_baseKey, m_encKey, 0x2C );
+  Common::Util::md5( m_baseKey, m_encKey, 0x2C );
 }
 
-void Sapphire::Network::GameConnection::handlePackets( const Sapphire::Network::Packets::FFXIVARR_PACKET_HEADER& ipcHeader,
+void Lobby::Network::GameConnection::handlePackets( const Common::Network::Packets::FFXIVARR_PACKET_HEADER& ipcHeader,
-                                                       const std::vector< Sapphire::Network::Packets::FFXIVARR_PACKET_RAW >& packetData )
+                                                    const std::vector< Common::Network::Packets::FFXIVARR_PACKET_RAW >& packetData )
 {
 
   for( auto inPacket : packetData )

src/lobby/GameConnection.h

@@ -16,10 +16,10 @@
 
 #define DECLARE_HANDLER( x ) void x( Packets::GamePacketPtr pInPacket, Entity::PlayerPtr pPlayer )
 
-namespace Sapphire::Network
+namespace Sapphire::Lobby::Network
 {
 
-  class GameConnection : public Connection
+  class GameConnection : public Common::Network::Connection
   {
 
   private:
@@ -32,16 +32,16 @@ namespace Sapphire::Network
 
     bool m_bEncryptionInitialized;
 
-    AcceptorPtr m_pAcceptor;
+    Common::Network::AcceptorPtr m_pAcceptor;
 
     LobbySessionPtr m_pSession;
 
-    Common::Util::LockedQueue< Packets::GamePacketPtr > m_inQueue;
+    Common::Util::LockedQueue< Common::Network::Packets::GamePacketPtr > m_inQueue;
-    Common::Util::LockedQueue< Packets::GamePacketPtr > m_outQueue;
+    Common::Util::LockedQueue< Common::Network::Packets::GamePacketPtr > m_outQueue;
     std::vector< uint8_t > m_packets;
 
   public:
-    GameConnection( HivePtr pHive, AcceptorPtr pAcceptor, FrameworkPtr pFw );
+    GameConnection( Common::Network::HivePtr pHive, Common::Network::AcceptorPtr pAcceptor, Common::FrameworkPtr pFw );
 
     ~GameConnection();
 
@@ -58,26 +58,26 @@ namespace Sapphire::Network
 
     void sendError( uint64_t sequence, uint32_t errorcode, uint16_t messageId, uint32_t tmpId );
 
-    void getCharList( Packets::FFXIVARR_PACKET_RAW& packet, uint32_t tmpId );
+    void getCharList( Common::Network::Packets::FFXIVARR_PACKET_RAW& packet, uint32_t tmpId );
 
-    void enterWorld( Packets::FFXIVARR_PACKET_RAW& packet, uint32_t tmpId );
+    void enterWorld( Common::Network::Packets::FFXIVARR_PACKET_RAW& packet, uint32_t tmpId );
 
-    bool sendServiceAccountList( Packets::FFXIVARR_PACKET_RAW& packet, uint32_t tmpId );
+    bool sendServiceAccountList( Common::Network::Packets::FFXIVARR_PACKET_RAW& packet, uint32_t tmpId );
 
-    bool createOrModifyChar( Packets::FFXIVARR_PACKET_RAW& packet, uint32_t tmpId );
+    bool createOrModifyChar( Common::Network::Packets::FFXIVARR_PACKET_RAW& packet, uint32_t tmpId );
 
-    void handlePackets( const Packets::FFXIVARR_PACKET_HEADER& ipcHeader,
+    void handlePackets( const Common::Network::Packets::FFXIVARR_PACKET_HEADER& ipcHeader,
-                        const std::vector< Packets::FFXIVARR_PACKET_RAW >& packetData );
+                        const std::vector< Common::Network::Packets::FFXIVARR_PACKET_RAW >& packetData );
 
-    void handleGamePacket( Packets::FFXIVARR_PACKET_RAW& pPacket );
+    void handleGamePacket( Common::Network::Packets::FFXIVARR_PACKET_RAW& pPacket );
 
-    void handlePacket( Packets::FFXIVPacketBasePtr pPacket );
+    void handlePacket( Common::Network::Packets::FFXIVPacketBasePtr pPacket );
 
-    void sendPackets( Packets::PacketContainer* pPacket );
+    void sendPackets( Common::Network::Packets::PacketContainer* pPacket );
 
     void sendPacket( Packets::LobbyPacketContainer& pLpc );
 
-    void sendSinglePacket( Packets::FFXIVPacketBasePtr pPacket );
+    void sendSinglePacket( Common::Network::Packets::FFXIVPacketBasePtr pPacket );
 
 
   };

src/lobby/LobbyPacketContainer.cpp

@@ -4,25 +4,26 @@
 #include <Crypt/blowfish.h>
 #include <Common.h>
 
+using namespace Sapphire;
 using namespace Sapphire::Common;
-using namespace Sapphire::Network::Packets;
+using namespace Sapphire::Common::Network::Packets;
 
-Sapphire::Network::Packets::LobbyPacketContainer::LobbyPacketContainer( uint8_t* encKey )
+Lobby::Network::Packets::LobbyPacketContainer::LobbyPacketContainer( uint8_t* encKey )
 {
-  memset( &m_header, 0, sizeof( Sapphire::Network::Packets::FFXIVARR_PACKET_HEADER ) );
+  memset( &m_header, 0, sizeof( Common::Network::Packets::FFXIVARR_PACKET_HEADER ) );
-  m_header.size = sizeof( Sapphire::Network::Packets::FFXIVARR_PACKET_HEADER );
+  m_header.size = sizeof( Common::Network::Packets::FFXIVARR_PACKET_HEADER );
 
   m_encKey = encKey;
 
   memset( m_dataBuf, 0, 0x1570 );
 }
 
-Sapphire::Network::Packets::LobbyPacketContainer::~LobbyPacketContainer()
+Lobby::Network::Packets::LobbyPacketContainer::~LobbyPacketContainer()
 {
   m_entryList.clear();
 }
 
-void Sapphire::Network::Packets::LobbyPacketContainer::addPacket( FFXIVPacketBasePtr pEntry )
+void Lobby::Network::Packets::LobbyPacketContainer::addPacket( FFXIVPacketBasePtr pEntry )
 {
   memcpy( m_dataBuf + m_header.size, &pEntry->getData()[ 0 ], pEntry->getSize() );
 
@@ -38,18 +39,18 @@ void Sapphire::Network::Packets::LobbyPacketContainer::addPacket( FFXIVPacketBas
   m_header.count++;
 }
 
-uint16_t Sapphire::Network::Packets::LobbyPacketContainer::getSize() const
+uint16_t Lobby::Network::Packets::LobbyPacketContainer::getSize() const
 {
   return m_header.size;
 }
 
-uint8_t* Sapphire::Network::Packets::LobbyPacketContainer::getRawData( bool addstuff )
+uint8_t* Lobby::Network::Packets::LobbyPacketContainer::getRawData( bool addstuff )
 {
   if( addstuff )
   {
     m_header.unknown_0 = 0xff41a05252;
     m_header.timestamp = Common::Util::getTimeMs();
   }
-  memcpy( m_dataBuf, &m_header, sizeof( Sapphire::Network::Packets::FFXIVARR_PACKET_HEADER ) );
+  memcpy( m_dataBuf, &m_header, sizeof( Common::Network::Packets::FFXIVARR_PACKET_HEADER ) );
   return m_dataBuf;
 }

src/lobby/LobbyPacketContainer.h

@@ -9,10 +9,10 @@
 
 #include "Forwards.h"
 
-namespace Sapphire::Network::Packets
+namespace Sapphire::Lobby::Network::Packets
 {
 
-  using FFXIVPacketBasePtr = std::shared_ptr< FFXIVPacketBase >;
+  using FFXIVPacketBasePtr = std::shared_ptr< Common::Network::Packets::FFXIVPacketBase >;
 
   class LobbyPacketContainer
   {
@@ -28,7 +28,7 @@ namespace Sapphire::Network::Packets
     uint8_t* getRawData( bool addstuff = true );
 
   private:
-    Sapphire::Network::Packets::FFXIVARR_PACKET_HEADER m_header;
+    Common::Network::Packets::FFXIVARR_PACKET_HEADER m_header;
 
     uint8_t* m_encKey;
 

src/lobby/LobbySession.cpp

@@ -1,6 +1,7 @@
 #include "LobbySession.h"
 
-namespace Sapphire {
+using namespace Sapphire::Lobby;
+
 LobbySession::LobbySession( void )
 {
   //setSocket(NULL);
@@ -11,5 +12,4 @@ LobbySession::~LobbySession( void )
 {
 
 }
-}
 

src/lobby/LobbySession.h

@@ -7,7 +7,7 @@
 #include <string>
 #include <string.h>
 
-namespace Sapphire
+namespace Sapphire::Lobby
 {
 
   class LobbySession

src/lobby/RestConnector.cpp

@@ -8,19 +8,21 @@
 
 #include <nlohmann/json.hpp>
 
+using namespace Sapphire;
+
 typedef std::vector< std::tuple< std::string, uint32_t, uint64_t, std::string > > CharList;
 
-Sapphire::Network::RestConnector::RestConnector()
+Lobby::Network::RestConnector::RestConnector()
 {
 
 }
 
-Sapphire::Network::RestConnector::~RestConnector()
+Lobby::Network::RestConnector::~RestConnector()
 {
 
 }
 
-HttpResponse Sapphire::Network::RestConnector::requestApi( std::string endpoint, std::string data )
+HttpResponse Lobby::Network::RestConnector::requestApi( std::string endpoint, std::string data )
 {
   HttpClient client( restHost );
 
@@ -39,7 +41,7 @@ HttpResponse Sapphire::Network::RestConnector::requestApi( std::string endpoint,
   return r;
 }
 
-Sapphire::LobbySessionPtr Sapphire::Network::RestConnector::getSession( char* sId )
+Lobby::LobbySessionPtr Lobby::Network::RestConnector::getSession( char* sId )
 {
   std::string json_string = "{\"sId\": \"" + std::string( sId ) + "\",\"secret\": \"" + serverSecret + "\"}";
 
@@ -65,7 +67,7 @@ Sapphire::LobbySessionPtr Sapphire::Network::RestConnector::getSession( char* sI
 
     if( content.find( "invalid" ) == std::string::npos )
     {
-      LobbySessionPtr pSession( new Sapphire::LobbySession() );
+      LobbySessionPtr pSession( new Lobby::LobbySession() );
       pSession->setAccountID( json["result"].get< uint32_t >() );
       pSession->setSessionId( ( uint8_t* ) sId );
       return pSession;
@@ -81,7 +83,7 @@ Sapphire::LobbySessionPtr Sapphire::Network::RestConnector::getSession( char* sI
   }
 }
 
-bool Sapphire::Network::RestConnector::checkNameTaken( std::string name )
+bool Lobby::Network::RestConnector::checkNameTaken( std::string name )
 {
   std::string json_string = "{\"name\": \"" + name + "\",\"secret\": \"" + serverSecret + "\"}";
 
@@ -115,7 +117,7 @@ bool Sapphire::Network::RestConnector::checkNameTaken( std::string name )
   }
 }
 
-uint32_t Sapphire::Network::RestConnector::getNextCharId()
+uint32_t Lobby::Network::RestConnector::getNextCharId()
 {
   std::string json_string = "{\"secret\": \"" + serverSecret + "\"}";
 
@@ -154,7 +156,7 @@ uint32_t Sapphire::Network::RestConnector::getNextCharId()
   }
 }
 
-uint64_t Sapphire::Network::RestConnector::getNextContentId()
+uint64_t Lobby::Network::RestConnector::getNextContentId()
 {
   std::string json_string = "{\"secret\": \"" + serverSecret + "\"}";
 
@@ -193,7 +195,7 @@ uint64_t Sapphire::Network::RestConnector::getNextContentId()
   }
 }
 
-CharList Sapphire::Network::RestConnector::getCharList( char* sId )
+CharList Lobby::Network::RestConnector::getCharList( char* sId )
 {
   std::string json_string = "{\"sId\": \"" + std::string( sId, 56 ) + "\",\"secret\": \"" + serverSecret + "\"}";
 
@@ -249,7 +251,7 @@ CharList Sapphire::Network::RestConnector::getCharList( char* sId )
   }
 }
 
-bool Sapphire::Network::RestConnector::deleteCharacter( char* sId, std::string name )
+bool Lobby::Network::RestConnector::deleteCharacter( char* sId, std::string name )
 {
   std::string json_string =
     "{\"sId\": \"" + std::string( sId, 56 ) + "\",\"secret\": \"" + serverSecret + "\",\"name\": \"" + name + "\"}";
@@ -283,11 +285,11 @@ bool Sapphire::Network::RestConnector::deleteCharacter( char* sId, std::string n
   }
 }
 
-int Sapphire::Network::RestConnector::createCharacter( char* sId, std::string name, std::string infoJson )
+int Lobby::Network::RestConnector::createCharacter( char* sId, std::string name, std::string infoJson )
 {
   std::string json_string =
     "{\"sId\": \"" + std::string( sId, 56 ) + "\",\"secret\": \"" + serverSecret + "\",\"name\": \"" + name +
-    "\",\"infoJson\": \"" + Sapphire::Util::base64Encode( ( uint8_t* ) infoJson.c_str(), infoJson.length() ) + "\"}";
+    "\",\"infoJson\": \"" + Common::Util::base64Encode( ( uint8_t* ) infoJson.c_str(), infoJson.length() ) + "\"}";
 
   HttpResponse r = requestApi( "createCharacter", json_string );
 

src/lobby/RestConnector.h

@@ -15,7 +15,7 @@ namespace Sapphire
   class Session;
 }
 
-namespace Sapphire::Network
+namespace Sapphire::Lobby::Network
 {
   class LobbySession;
 

src/lobby/ServerLobby.cpp

@@ -21,9 +21,9 @@
 
 #include <thread>
 
-Sapphire::Network::RestConnector g_restConnector;
+Sapphire::Lobby::Network::RestConnector g_restConnector;
 
-namespace Sapphire
+namespace Sapphire::Lobby
 {
 
 
@@ -31,7 +31,7 @@ namespace Sapphire
     m_configPath( configPath ),
     m_numConnections( 0 )
   {
-    m_pConfig = std::make_shared< ConfigMgr >();
+    m_pConfig = std::make_shared< Sapphire::Common::ConfigMgr >();
   }
 
   LobbySessionPtr ServerLobby::getSession( char* sessionId )
@@ -63,15 +63,15 @@ namespace Sapphire
 
     Logger::setLogLevel( m_config.global.general.logLevel );
 
-    auto pFw = std::make_shared< Framework >();
+    auto pFw = std::make_shared< Common::Framework >();
-    Network::HivePtr hive( new Network::Hive() );
+    Common::Network::HivePtr hive( new Common::Network::Hive() );
-    Network::addServerToHive< Network::GameConnection >( m_ip, m_port, hive, pFw );
+    Common::Network::addServerToHive< Network::GameConnection >( m_ip, m_port, hive, pFw );
 
     Logger::info( "Lobby server running on {0}:{1}", m_ip, m_port );
 
     std::vector< std::thread > threadGroup;
 
-    threadGroup.emplace_back( std::bind( &Network::Hive::run, hive.get() ) );
+    threadGroup.emplace_back( std::bind( &Common::Network::Hive::run, hive.get() ) );
 
     for( auto& thread : threadGroup )
       if( thread.joinable() )

src/lobby/ServerLobby.h

@@ -9,10 +9,14 @@
 
 const std::string LOBBY_VERSION = "0.0.5";
 
-namespace Sapphire
+namespace Sapphire::Common
+{
+  class ConfigMgr;
+}
+
+namespace Sapphire::Lobby
 {
   class LobbySession;
-  class ConfigMgr;
 
   using LobbySessionMap = std::map< std::string, LobbySessionPtr >;
 
@@ -29,7 +33,7 @@ namespace Sapphire
     uint16_t m_port;
     std::string m_ip;
 
-    std::shared_ptr< ConfigMgr > m_pConfig;
+    std::shared_ptr< Sapphire::Common::ConfigMgr > m_pConfig;
 
   public:
     ServerLobby( const std::string& configPath );

src/lobby/mainLobbyServer.cpp

@@ -4,7 +4,7 @@
 
 Sapphire::Common::Util::CrashHandler crashHandler;
 
-Sapphire::ServerLobby g_serverLobby( "lobby.ini" );
+Sapphire::Lobby::ServerLobby g_serverLobby( "lobby.ini" );
 
 int main( int32_t argc, char* argv[] )
 {

src/world/Action/Action.h

@@ -130,8 +130,6 @@ namespace Sapphire::World::Action
 
   protected:
 
-    void calculateActionCost();
-
     bool primaryCostCheck( bool subtractCosts );
     bool secondaryCostCheck( bool subtractCosts );
 

src/world/Network/GameConnection.h

@@ -28,12 +28,12 @@ namespace Sapphire::Network
     None
   };
 
-  class GameConnection : public Connection
+  class GameConnection : public Common::Network::Connection
   {
 
   private:
     typedef void ( GameConnection::* Handler )( FrameworkPtr pFw,
-                                                const Sapphire::Network::Packets::FFXIVARR_PACKET_RAW& inPacket,
+                                                const Common::Network::Packets::FFXIVARR_PACKET_RAW& inPacket,
                                                 Entity::Player& player );
 
     using HandlerMap = std::map< uint16_t, Handler >;
@@ -51,7 +51,7 @@ namespace Sapphire::Network
 
     World::SessionPtr m_pSession;
 
-    Common::Util::LockedQueue< Sapphire::Network::Packets::FFXIVARR_PACKET_RAW > m_inQueue;
+    Common::Util::LockedQueue< Common::Network::Packets::FFXIVARR_PACKET_RAW > m_inQueue;
     Common::Util::LockedQueue< Packets::FFXIVPacketBasePtr > m_outQueue;
     std::vector< uint8_t > m_packets;