Basic Task system, proper zone initializing

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

@@ -334,6 +334,18 @@ struct FFXIVIpcPingHandler : FFXIVIpcBasePacket< Sync >
   ZoneProtoUpClientPos position;
 };
 
+struct FFXIVIpcLoginHandler : FFXIVIpcBasePacket< Login >
+{
+  uint32_t clientTimeValue;
+  uint32_t arg2;
+  uint64_t arg3;
+  uint64_t arg4;
+  int32_t contentFinderStatus;
+  int32_t contentFinderFlags;
+  char name[32];
+  char arg1[48];
+};
+
 struct FFXIVIpcFindContent : FFXIVIpcBasePacket< FindContent >
 {
   uint16_t territoryType;

src/world/CMakeLists.txt

@@ -23,6 +23,7 @@ file( GLOB SERVER_SOURCE_FILES RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}
         Territory/Housing/*.cpp
         Util/*.cpp
         Navi/*.cpp
+        Task/*.cpp
         Quest/*.cpp )
 
 add_executable( world ${SERVER_SOURCE_FILES} )

src/world/ForwardsZone.h

@@ -33,6 +33,7 @@ namespace World
 {
 TYPE_FORWARD( Session );
 TYPE_FORWARD( Quest );
+TYPE_FORWARD( Task );
 }
 
 namespace World::Navi

src/world/Manager/TaskMgr.cpp

@@ -0,0 +1,34 @@
+#include <Logging/Logger.h>
+#include <Service.h>
+
+#include "TaskMgr.h"
+#include "Task/Task.h"
+
+using namespace Sapphire::World::Manager;
+using namespace Sapphire::World;
+
+void TaskMgr::update( uint64_t tickCount )
+{
+
+  for( auto it = m_taskList.begin(); it != m_taskList.end();  )
+  {
+    auto pTask = *it;
+    // is the task ready for execution?
+    if( ( tickCount - pTask->getQueueTimeMs() ) >= pTask->getDelayTimeMs() )
+    {
+      pTask->execute();
+      it = m_taskList.erase( it );
+    }
+    else
+      ++it;
+  }
+
+  m_lastTick = tickCount;
+
+}
+
+void TaskMgr::queueTask( const TaskPtr& pTask )
+{
+  pTask->onQueue();
+  m_taskList.push_back( pTask );
+}

src/world/Manager/TaskMgr.h

@@ -3,9 +3,12 @@
 #include <cstdint>
 #include <string>
 #include <ForwardsZone.h>
+#include <Util/Util.h>
 
 namespace Sapphire::World::Manager
 {
+
+
   struct QueuedWarp
   {
     Common::WarpType m_warpType;
@@ -13,7 +16,8 @@ namespace Sapphire::World::Manager
     uint16_t m_targetZoneId;
     Common::FFXIVARR_POSITION3 m_targetPosition;
     float m_targetRotation;
-    uint64_t m_delayTime;
+    uint64_t m_delayTimeMs;
+    uint64_t m_timeQueuedMs;
 
     QueuedWarp( uint64_t characterId, Common::WarpType warpType, uint16_t targetZoneId,
                 const Common::FFXIVARR_POSITION3& targetPosition, float targetRotation, uint64_t delayTime ) :
@@ -22,25 +26,25 @@ namespace Sapphire::World::Manager
       m_targetZoneId( targetZoneId ),
       m_targetPosition( targetPosition ),
       m_targetRotation( targetRotation ),
-      m_delayTime( delayTime ),
+      m_delayTimeMs( delayTime ),
+      m_timeQueuedMs( Common::Util::getTimeMs() )
     {
     }
   };
 
-  class WarpMgr
+  class TaskMgr
   {
   public:
-    WarpMgr() = default;
+    TaskMgr() = default;
 
     // queue a new warp process to be executed when the delaytime (ms) expired
-    void queueWarp( uint64_t characterId, Common::WarpType warpType, uint16_t targetZoneId,
-                    const Common::FFXIVARR_POSITION3& targetPosition, float targetRotation, uint64_t delayTime );
+    void queueTask( const TaskPtr& pTask );
 
     void update( uint64_t tickCount );
 
   private:
-    uint64_t m_lastTick;
-    std::vector< std::shared_ptr< QueuedWarp > > m_warpQueue;
+    uint64_t m_lastTick{};
+    std::vector< TaskPtr > m_taskList;
 
   };
 

src/world/Manager/TerritoryMgr.cpp

@@ -486,16 +486,15 @@ Sapphire::TerritoryPtr Sapphire::World::Manager::TerritoryMgr::getZoneByTerritor
 
 void Sapphire::World::Manager::TerritoryMgr::updateTerritoryInstances( uint64_t tickCount )
 {
+
   for( auto& zone : m_territorySet )
   {
     zone->update( tickCount );
   }
-
   for( auto& zone : m_instanceZoneSet )
   {
     zone->update( tickCount );
   }
-
   // remove internal house zones with nobody in them
   for( auto it = m_landIdentToTerritoryPtrMap.begin(); it != m_landIdentToTerritoryPtrMap.end(); )
   {

src/world/Network/GameConnection.cpp

@@ -481,7 +481,7 @@ void Sapphire::Network::GameConnection::handlePackets( const Sapphire::Network::
           m_pSession = session;
 
         auto pe = std::make_shared< FFXIVRawPacket >( 0x07, 0x18, 0, 0 );
-        *reinterpret_cast< unsigned int* >( &pe->data()[ 0 ] ) = 0xE0037603;
+        *reinterpret_cast< unsigned int* >( &pe->data()[ 0 ] ) = 0xE0001027;
         *reinterpret_cast< unsigned int* >( &pe->data()[ 4 ] ) = Common::Util::getTimeSeconds();
         sendSinglePacket( pe );
 
@@ -490,6 +490,11 @@ void Sapphire::Network::GameConnection::handlePackets( const Sapphire::Network::
         {
           auto pe1 = std::make_shared< FFXIVRawPacket >( 0x02, 0x38, 0, 0 );
           *reinterpret_cast< unsigned int* >( &pe1->data()[ 0 ] ) = entityId;
+          *reinterpret_cast< unsigned int* >( &pe1->data()[ 0x20 ] ) = entityId;
+          *reinterpret_cast< unsigned int* >( &pe1->data()[ 0x24 ] ) = Common::Util::getTimeSeconds();
+          *reinterpret_cast< unsigned int* >( &pe1->data()[ 0x0C ] ) = Common::Util::getTimeSeconds();
+          *reinterpret_cast< unsigned int* >( &pe1->data()[ 0x1C ] ) = Common::Util::getTimeSeconds();
+          *reinterpret_cast< unsigned int* >( &pe1->data()[ 0x18 ] ) = Common::Util::getTimeSeconds();
           sendSinglePacket( pe1 );
           Logger::info( "[{0}] Setting session for world connection", id );
           session->setZoneConnection( pCon );

src/world/Network/Handlers/PacketHandlers.cpp

@@ -390,6 +390,7 @@ void Sapphire::Network::GameConnection::newDiscoveryHandler( const Packets::FFXI
 
 void Sapphire::Network::GameConnection::loginHandler( const Packets::FFXIVARR_PACKET_RAW& inPacket, Entity::Player& player )
 {
+  const auto packet = ZoneChannelPacket< Client::FFXIVIpcLoginHandler >( inPacket );
   auto& teriMgr = Common::Service< World::Manager::TerritoryMgr >::ref();
   // init handler means this is a login procedure
   player.setIsLogin( true );

src/world/Task/Task.cpp

@@ -0,0 +1,20 @@
+#include <cstdint>
+#include <Util/Util.h>
+#include "Task.h"
+
+Sapphire::World::Task::Task( uint64_t delayTime ) :
+  m_delayTimeMs( delayTime ),
+  m_timeQueuedMs( Common::Util::getTimeMs() )
+{
+
+}
+
+uint64_t Sapphire::World::Task::getQueueTimeMs() const
+{
+  return m_timeQueuedMs;
+}
+
+uint64_t Sapphire::World::Task::getDelayTimeMs() const
+{
+  return m_delayTimeMs;
+}

src/world/Task/Task.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include <cstdint>
+#include <string>
+#include <ForwardsZone.h>
+
+namespace Sapphire::World
+{
+
+  class Task
+  {
+  public:
+    Task( uint64_t delayTime );
+
+    uint64_t getQueueTimeMs() const;
+    uint64_t getDelayTimeMs() const;
+
+    virtual void onQueue() = 0;
+    virtual void execute() = 0;
+    virtual std::string toString() = 0;
+
+  protected:
+    uint64_t m_delayTimeMs;
+    uint64_t m_timeQueuedMs;
+  };
+
+}

src/world/Task/TestTask.cpp

@@ -0,0 +1,26 @@
+#include "TestTask.h"
+
+#include <Logging/Logger.h>
+
+using namespace Sapphire::World;
+
+TestTask::TestTask( uint64_t delayTime ) : Task( delayTime )
+{
+}
+
+void TestTask::onQueue()
+{
+  Logger::debug( "Queueing a TestTask!" );
+}
+
+void TestTask::execute()
+{
+  Logger::debug( "Executing a TestTask after {}ms", getDelayTimeMs() );
+}
+
+std::string TestTask::toString()
+{
+  return "TestTask";
+}
+
+

src/world/Task/TestTask.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include <cstdint>
+#include <string>
+#include <ForwardsZone.h>
+#include "Task.h"
+
+namespace Sapphire::World
+{
+
+class TestTask : public Task
+{
+public:
+  TestTask( uint64_t delayTime );
+
+  void onQueue() override;
+  void execute() override;
+  std::string toString() override;
+};
+
+}

src/world/Territory/Territory.cpp

@@ -138,6 +138,8 @@ bool Sapphire::Territory::init()
     Logger::warn( "No navmesh found for TerritoryType#{}", getTerritoryTypeId() );
   }
 
+  onUpdate( 0 );
+
   return true;
 }
 
@@ -200,7 +202,7 @@ Weather Sapphire::Territory::getNextWeather()
   return Weather::FairSkies;
 }
 
-void Sapphire::Territory::pushActor( Entity::GameObjectPtr pActor )
+void Sapphire::Territory::pushActor( const Entity::GameObjectPtr& pActor )
 {
   float mx = pActor->getPos().x;
   float my = pActor->getPos().z;
@@ -248,7 +250,7 @@ void Sapphire::Territory::pushActor( Entity::GameObjectPtr pActor )
     pPlayer->setAgentId( agentId );
 
     m_playerMap[ pPlayer->getId() ] = pPlayer;
-    updateCellActivity( cx, cy, 2 );
+    updateCellActivity( cx, cy, 1 );
   }
   else if( pActor->isBattleNpc() )
   {
@@ -259,7 +261,7 @@ void Sapphire::Territory::pushActor( Entity::GameObjectPtr pActor )
     pBNpc->setAgentId( agentId );
 
     m_bNpcMap[ pBNpc->getId() ] = pBNpc;
-    updateCellActivity( cx, cy, 2 );
+    updateCellActivity( cx, cy, 1 );
 
   }
   else if( pActor->isEventObj() )
@@ -270,7 +272,7 @@ void Sapphire::Territory::pushActor( Entity::GameObjectPtr pActor )
   }
 }
 
-void Sapphire::Territory::removeActor( Entity::GameObjectPtr pActor )
+void Sapphire::Territory::removeActor( const Entity::GameObjectPtr& pActor )
 {
   auto cellId = pActor->getCellId();
   CellPtr pCell = getCellPtr( cellId.x, cellId.y );
@@ -820,15 +822,12 @@ std::shared_ptr< Component::Excel::ExcelStruct< Component::Excel::TerritoryType
 
 void Sapphire::Territory::updateSpawnPoints()
 {
-
-  auto& RNGMgr = Common::Service< World::Manager::RNGMgr >::ref();
-  auto rng = RNGMgr.getRandGenerator< float >( 0.f, PI * 2 );
+  auto& server = Common::Service< World::WorldServer >::ref();
 
   for( auto& spawn : m_spawnInfo )
   {
     if( !spawn.bnpcPtr && ( Util::getTimeSeconds() - spawn.timeOfDeath ) > spawn.infoPtr->PopInterval )
     {
-      auto& server = Common::Service< World::WorldServer >::ref();
       auto pBNpc = std::make_shared< Entity::BNpc >( getNextActorId(), spawn.infoPtr, shared_from_this() );
       pBNpc->init();
       spawn.bnpcPtr = pBNpc;
@@ -839,7 +838,6 @@ void Sapphire::Territory::updateSpawnPoints()
     {
       spawn.timeOfDeath = Util::getTimeSeconds();
       spawn.bnpcPtr.reset();
-
     }
   }
 }

src/world/Territory/Territory.h

@@ -121,9 +121,9 @@ namespace Sapphire
 
     Common::Weather getNextWeather();
 
-    void pushActor( Entity::GameObjectPtr pActor );
+    void pushActor( const Entity::GameObjectPtr& pActor );
 
-    void removeActor( Entity::GameObjectPtr pActor );
+    void removeActor( const Entity::GameObjectPtr &pActor );
 
     void updateActorPosition( Entity::GameObject& pActor );
 

src/world/WorldServer.cpp

@@ -20,6 +20,9 @@
 
 #include "Manager/TerritoryMgr.h"
 #include "Manager/LinkshellMgr.h"
+#include "Manager/TaskMgr.h"
+
+#include "Task/TestTask.h"
 
 #include "Script/ScriptMgr.h"
 
@@ -49,9 +52,10 @@
 
 #include "Territory/InstanceObjectCache.h"
 
+using namespace Sapphire::World;
 using namespace Sapphire::World::Manager;
 
-Sapphire::World::WorldServer::WorldServer( const std::string& configName ) :
+WorldServer::WorldServer( const std::string& configName ) :
   m_configName( configName ),
   m_bRunning( true ),
   m_lastDBPingTime( 0 ),
@@ -59,16 +63,16 @@ Sapphire::World::WorldServer::WorldServer( const std::string& configName ) :
 {
 }
 
-Sapphire::World::WorldServer::~WorldServer()
+WorldServer::~WorldServer()
 {
 }
 
-size_t Sapphire::World::WorldServer::getSessionCount() const
+size_t WorldServer::getSessionCount() const
 {
   return m_sessionMapById.size();
 }
 
-bool Sapphire::World::WorldServer::loadSettings( int32_t argc, char* argv[] )
+bool WorldServer::loadSettings( int32_t argc, char* argv[] )
 {
   auto& configMgr = Common::Service< Common::ConfigMgr >::ref();
 
@@ -119,10 +123,9 @@ bool Sapphire::World::WorldServer::loadSettings( int32_t argc, char* argv[] )
   return true;
 }
 
-void Sapphire::World::WorldServer::run( int32_t argc, char* argv[] )
+void WorldServer::run( int32_t argc, char* argv[] )
 {
   using namespace Sapphire;
-  using namespace Sapphire::World;
 
   Logger::init( "log/world" );
 
@@ -188,6 +191,9 @@ void Sapphire::World::WorldServer::run( int32_t argc, char* argv[] )
   auto pNaviMgr = std::make_shared< Manager::NaviMgr >();
   Common::Service< Manager::NaviMgr >::set( pNaviMgr );
 
+  auto pRNGMgr = std::make_shared< Manager::RNGMgr >();
+  Common::Service< Manager::RNGMgr >::set( pRNGMgr );
+
   Logger::info( "TerritoryMgr: Setting up zones" );
   auto pTeriMgr = std::make_shared< Manager::TerritoryMgr >();
   auto pHousingMgr = std::make_shared< Manager::HousingMgr >();
@@ -235,12 +241,12 @@ void Sapphire::World::WorldServer::run( int32_t argc, char* argv[] )
   auto pInventoryMgr = std::make_shared< Manager::InventoryMgr >();
   auto pEventMgr = std::make_shared< Manager::EventMgr >();
   auto pItemMgr = std::make_shared< Manager::ItemMgr >();
-  auto pRNGMgr = std::make_shared< Manager::RNGMgr >();
   auto pQuestMgr = std::make_shared< Manager::QuestMgr >();
   auto pPartyMgr = std::make_shared< Manager::PartyMgr >();
   auto pFriendMgr = std::make_shared< Manager::FriendListMgr >();
   auto pBlacklistMgr = std::make_shared< Manager::BlacklistMgr >();
   auto contentFinder = std::make_shared< ContentFinder >();
+  auto taskMgr = std::make_shared< Manager::TaskMgr >();
 
   Common::Service< DebugCommandMgr >::set( pDebugCom );
   Common::Service< Manager::PlayerMgr >::set( pPlayerMgr );
@@ -248,15 +254,19 @@ void Sapphire::World::WorldServer::run( int32_t argc, char* argv[] )
   Common::Service< Manager::InventoryMgr >::set( pInventoryMgr );
   Common::Service< Manager::EventMgr >::set( pEventMgr );
   Common::Service< Manager::ItemMgr >::set( pItemMgr );
-  Common::Service< Manager::RNGMgr >::set( pRNGMgr );
   Common::Service< Manager::QuestMgr >::set( pQuestMgr );
   Common::Service< Manager::PartyMgr >::set( pPartyMgr );
   Common::Service< Manager::FriendListMgr >::set( pFriendMgr );
   Common::Service< Manager::BlacklistMgr >::set( pBlacklistMgr );
   Common::Service< ContentFinder >::set( contentFinder );
+  Common::Service< Manager::TaskMgr >::set( taskMgr );
 
   Logger::info( "World server running on {0}:{1}", m_ip, m_port );
 
+  taskMgr->queueTask( std::make_shared< Sapphire::World::TestTask >( 10000 ) );
+  taskMgr->queueTask( std::make_shared< Sapphire::World::TestTask >( 5000 ) );
+  taskMgr->queueTask( std::make_shared< Sapphire::World::TestTask >( 2000 ) );
+
   mainLoop();
 
   for( auto& thread_entry : thread_list )
@@ -266,17 +276,17 @@ void Sapphire::World::WorldServer::run( int32_t argc, char* argv[] )
 
 }
 
-uint16_t Sapphire::World::WorldServer::getWorldId() const
+uint16_t WorldServer::getWorldId() const
 {
   return m_worldId;
 }
 
-void Sapphire::World::WorldServer::setWorldId( uint16_t worldId )
+void WorldServer::setWorldId( uint16_t worldId )
 {
   m_worldId = worldId;
 }
 
-void Sapphire::World::WorldServer::printBanner() const
+void WorldServer::printBanner() const
 {
   Logger::info( "===========================================================" );
   Logger::info( "Sapphire Server Project " );
@@ -286,13 +296,15 @@ void Sapphire::World::WorldServer::printBanner() const
   Logger::info( "===========================================================" );
 }
 
-void Sapphire::World::WorldServer::mainLoop()
+void WorldServer::mainLoop()
 {
   auto& terriMgr = Common::Service< TerritoryMgr >::ref();
   auto& scriptMgr = Common::Service< Scripting::ScriptMgr >::ref();
 
   auto& contentFinder = Common::Service< ContentFinder >::ref();
 
+  auto& taskMgr = Common::Service< World::Manager::TaskMgr >::ref();
+
   while( isRunning() )
   {
     std::this_thread::sleep_for( std::chrono::milliseconds( 50 ) );
@@ -300,19 +312,19 @@ void Sapphire::World::WorldServer::mainLoop()
     auto currTime = Common::Util::getTimeSeconds();
     auto tickCount = Common::Util::getTimeMs();
 
+    taskMgr.update( tickCount );
     terriMgr.updateTerritoryInstances( tickCount );
-
     scriptMgr.update();
-
     contentFinder.update();
-
     updateSessions( currTime );
 
     DbKeepAlive( currTime );
+
+
   }
 }
 
-void Sapphire::World::WorldServer::DbKeepAlive( uint32_t currTime )
+void WorldServer::DbKeepAlive( uint32_t currTime )
 {
   auto& db = Common::Service< Db::DbWorkerPool< Db::ZoneDbConnection > >::ref();
   if( currTime - m_lastDBPingTime > 3 )
@@ -322,7 +334,7 @@ void Sapphire::World::WorldServer::DbKeepAlive( uint32_t currTime )
   }
 }
 
-void Sapphire::World::WorldServer::updateSessions( uint32_t currTime )
+void WorldServer::updateSessions( uint32_t currTime )
 {
   std::queue< uint32_t > sessionRemovalQueue;
   std::lock_guard< std::mutex > lock( m_sessionMutex );
@@ -356,7 +368,7 @@ void Sapphire::World::WorldServer::updateSessions( uint32_t currTime )
   }
 }
 
-bool Sapphire::World::WorldServer::createSession( uint32_t sessionId )
+bool WorldServer::createSession( uint32_t sessionId )
 {
   std::lock_guard< std::mutex > lock( m_sessionMutex );
 
@@ -386,7 +398,7 @@ bool Sapphire::World::WorldServer::createSession( uint32_t sessionId )
   return true;
 }
 
-void Sapphire::World::WorldServer::removeSession( uint32_t sessionId )
+void WorldServer::removeSession( uint32_t sessionId )
 {
   auto pSession = getSession( sessionId );
   if( !pSession )
@@ -397,7 +409,7 @@ void Sapphire::World::WorldServer::removeSession( uint32_t sessionId )
   m_sessionMapByCharacterId.erase( pSession->getPlayer()->getCharacterId() );
 }
 
-Sapphire::World::SessionPtr Sapphire::World::WorldServer::getSession( uint32_t id )
+SessionPtr WorldServer::getSession( uint32_t id )
 {
   //std::lock_guard<std::mutex> lock( m_sessionMutex );
   auto it = m_sessionMapById.find( id );
@@ -408,7 +420,7 @@ Sapphire::World::SessionPtr Sapphire::World::WorldServer::getSession( uint32_t i
   return nullptr;
 }
 
-Sapphire::World::SessionPtr Sapphire::World::WorldServer::getSession( uint64_t id )
+SessionPtr WorldServer::getSession( uint64_t id )
 {
   //std::lock_guard<std::mutex> lock( m_sessionMutex );
   auto it = m_sessionMapByCharacterId.find( id );
@@ -419,7 +431,7 @@ Sapphire::World::SessionPtr Sapphire::World::WorldServer::getSession( uint64_t i
   return nullptr;
 }
 
-Sapphire::World::SessionPtr Sapphire::World::WorldServer::getSession( const std::string& playerName )
+SessionPtr WorldServer::getSession( const std::string& playerName )
 {
   //std::lock_guard<std::mutex> lock( m_sessionMutex );
 
@@ -431,7 +443,7 @@ Sapphire::World::SessionPtr Sapphire::World::WorldServer::getSession( const std:
   return nullptr;
 }
 
-void Sapphire::World::WorldServer::removeSession( const Entity::Player& player )
+void WorldServer::removeSession( const Entity::Player& player )
 {
   auto session = getSession( player.getCharacterId() );
   if( session )
@@ -441,16 +453,16 @@ void Sapphire::World::WorldServer::removeSession( const Entity::Player& player )
   m_sessionMapByCharacterId.erase( player.getCharacterId() );
 }
 
-bool Sapphire::World::WorldServer::isRunning() const
+bool WorldServer::isRunning() const
 {
   return m_bRunning;
 }
 
-std::vector< Sapphire::World::SessionPtr > Sapphire::World::WorldServer::searchSessionByName( const std::string& playerName )
+std::vector< SessionPtr > WorldServer::searchSessionByName( const std::string& playerName )
 {
   //std::lock_guard<std::mutex> lock( m_sessionMutex );
 
-  std::vector< Sapphire::World::SessionPtr > results{};
+  std::vector< SessionPtr > results{};
 
   for( auto it = m_sessionMapByName.begin(); it != m_sessionMapByName.end(); ++it ) {
     if( it->first.find( playerName ) != std::string::npos ) {
@@ -461,7 +473,7 @@ std::vector< Sapphire::World::SessionPtr > Sapphire::World::WorldServer::searchS
   return results;
 }
 
-Sapphire::Entity::PlayerPtr Sapphire::World::WorldServer::getPlayer( uint32_t entityId )
+Sapphire::Entity::PlayerPtr WorldServer::getPlayer( uint32_t entityId )
 {
   //std::lock_guard<std::mutex> lock( m_sessionMutex );
   auto it = m_playerMapById.find( entityId );
@@ -473,7 +485,7 @@ Sapphire::Entity::PlayerPtr Sapphire::World::WorldServer::getPlayer( uint32_t en
   return loadPlayer( entityId );
 }
 
-Sapphire::Entity::PlayerPtr Sapphire::World::WorldServer::getPlayer( uint64_t characterId )
+Sapphire::Entity::PlayerPtr WorldServer::getPlayer( uint64_t characterId )
 {
   //std::lock_guard<std::mutex> lock( m_sessionMutex );
   auto it = m_playerMapByCharacterId.find( characterId );
@@ -485,7 +497,7 @@ Sapphire::Entity::PlayerPtr Sapphire::World::WorldServer::getPlayer( uint64_t ch
   return loadPlayer( characterId );
 }
 
-Sapphire::Entity::PlayerPtr Sapphire::World::WorldServer::getPlayer( const std::string& playerName )
+Sapphire::Entity::PlayerPtr WorldServer::getPlayer( const std::string& playerName )
 {
   //std::lock_guard<std::mutex> lock( m_sessionMutex );
   auto it = m_playerMapByName.find( playerName );
@@ -498,7 +510,7 @@ Sapphire::Entity::PlayerPtr Sapphire::World::WorldServer::getPlayer( const std::
 }
 
 
-std::string Sapphire::World::WorldServer::getPlayerNameFromDb( uint64_t characterId, bool forceDbLoad )
+std::string WorldServer::getPlayerNameFromDb( uint64_t characterId, bool forceDbLoad )
 {
   if( !forceDbLoad )
   {
@@ -519,7 +531,7 @@ std::string Sapphire::World::WorldServer::getPlayerNameFromDb( uint64_t characte
   return playerName;
 }
 
-Sapphire::Entity::PlayerPtr Sapphire::World::WorldServer::addPlayer( uint64_t characterId )
+Sapphire::Entity::PlayerPtr WorldServer::addPlayer( uint64_t characterId )
 {
   auto pPlayer = Entity::make_Player();
 
@@ -533,7 +545,7 @@ Sapphire::Entity::PlayerPtr Sapphire::World::WorldServer::addPlayer( uint64_t ch
   return pPlayer;
 }
 
-Sapphire::Entity::PlayerPtr Sapphire::World::WorldServer::loadPlayer( uint32_t entityId )
+Sapphire::Entity::PlayerPtr WorldServer::loadPlayer( uint32_t entityId )
 {
   auto& db = Common::Service< Db::DbWorkerPool< Db::ZoneDbConnection > >::ref();
   auto res = db.query( "SELECT CharacterId FROM charainfo WHERE EntityId = " + std::to_string( entityId ) );
@@ -545,12 +557,12 @@ Sapphire::Entity::PlayerPtr Sapphire::World::WorldServer::loadPlayer( uint32_t e
   return addPlayer( characterId );
 }
 
-Sapphire::Entity::PlayerPtr Sapphire::World::WorldServer::loadPlayer( uint64_t characterId )
+Sapphire::Entity::PlayerPtr WorldServer::loadPlayer( uint64_t characterId )
 {
   return addPlayer( characterId );
 }
 
-Sapphire::Entity::PlayerPtr Sapphire::World::WorldServer::loadPlayer( const std::string& playerName )
+Sapphire::Entity::PlayerPtr WorldServer::loadPlayer( const std::string& playerName )
 {
   auto& db = Common::Service< Db::DbWorkerPool< Db::ZoneDbConnection > >::ref();
   auto res = db.query( "SELECT CharacterId FROM charainfo WHERE Name = " + playerName );
@@ -562,7 +574,7 @@ Sapphire::Entity::PlayerPtr Sapphire::World::WorldServer::loadPlayer( const std:
   return addPlayer( characterId );
 }
 
-bool Sapphire::World::WorldServer::loadPlayers()
+bool WorldServer::loadPlayers()
 {
   auto& db = Common::Service< Db::DbWorkerPool< Db::ZoneDbConnection > >::ref();
   auto res = db.query( "SELECT CharacterId FROM charainfo" );
@@ -578,7 +590,7 @@ bool Sapphire::World::WorldServer::loadPlayers()
   return true;
 }
 
-Sapphire::Entity::PlayerPtr Sapphire::World::WorldServer::syncPlayer( uint64_t characterId )
+Sapphire::Entity::PlayerPtr WorldServer::syncPlayer( uint64_t characterId )
 {
   auto pPlayer = getPlayer( characterId );
   if( !pPlayer )
@@ -615,17 +627,17 @@ Sapphire::Entity::PlayerPtr Sapphire::World::WorldServer::syncPlayer( uint64_t c
   return pPlayer;
 }
 
-std::map< int32_t, Sapphire::World::WorldServer::BNPCMap >& Sapphire::World::WorldServer::getBNpcTeriMap()
+std::map< int32_t, WorldServer::BNPCMap >& Sapphire::World::WorldServer::getBNpcTeriMap()
 {
   return m_bNpcTerritoryMap;
 }
 
-Sapphire::Common::Config::WorldConfig& Sapphire::World::WorldServer::getConfig()
+Sapphire::Common::Config::WorldConfig& WorldServer::getConfig()
 {
   return m_config;
 }
 
-void Sapphire::World::WorldServer::queueForPlayer( uint64_t characterId, Sapphire::Network::Packets::FFXIVPacketBasePtr pPacket )
+void WorldServer::queueForPlayer( uint64_t characterId, Sapphire::Network::Packets::FFXIVPacketBasePtr pPacket )
 {
   auto pSession = getSession( characterId );
   if( !pSession )
@@ -637,7 +649,7 @@ void Sapphire::World::WorldServer::queueForPlayer( uint64_t characterId, Sapphir
 
 }
 
-void Sapphire::World::WorldServer::queueForPlayer( uint64_t characterId, std::vector< Sapphire::Network::Packets::FFXIVPacketBasePtr > packets )
+void WorldServer::queueForPlayer( uint64_t characterId, std::vector< Sapphire::Network::Packets::FFXIVPacketBasePtr > packets )
 {
   auto pSession = getSession( characterId );
   if( !pSession )