From 774d16667df9d3858663748dbf9536dddaf51536 Mon Sep 17 00:00:00 2001
From: Taezen <86413840+Taezen@users.noreply.github.com>
Date: Tue, 7 Sep 2021 16:50:13 +0200
Subject: [PATCH] little map manager rework

---
 src/common/Exd/ExdDataGenerated.cpp         |  13 +-
 src/common/Exd/ExdDataGenerated.h           |  11 +-
 src/world/Event/EventHandler.h              |   7 +
 src/world/Manager/MapMgr.cpp                | 929 ++++++++------------
 src/world/Manager/MapMgr.h                  |  95 +-
 src/world/Script/NativeScriptApi.cpp        |   6 +-
 src/world/Script/NativeScriptApi.h          |   3 +
 src/world/ServerMgr.cpp                     |   2 +-
 src/world/Territory/InstanceObjectCache.cpp |  63 +-
 src/world/Territory/InstanceObjectCache.h   |  24 +
 10 files changed, 501 insertions(+), 652 deletions(-)

diff --git a/src/common/Exd/ExdDataGenerated.cpp b/src/common/Exd/ExdDataGenerated.cpp
index 130023d6..b6f845ca 100644
--- a/src/common/Exd/ExdDataGenerated.cpp
+++ b/src/common/Exd/ExdDataGenerated.cpp
@@ -4582,9 +4582,11 @@ Sapphire::Data::GuildleveAssignment::GuildleveAssignment( uint32_t row_id, Sapph
 {
   auto row = exdData->m_GuildleveAssignmentDat.get_row( row_id );
   type = exdData->getField< std::string >( row, 0 );
+  typeId = exdData->getField< uint8_t >( row, 1 );
   assignmentTalk = exdData->getField< uint32_t >( row, 2 );
   quest.push_back( exdData->getField< uint32_t >( row, 3 ) );
   quest.push_back( exdData->getField< uint32_t >( row, 4 ) );
+  grandCompanyRank = exdData->getField< uint8_t >( row, 10 );
 }
 
 Sapphire::Data::GuildleveAssignmentCategory::GuildleveAssignmentCategory( uint32_t row_id, Sapphire::Data::ExdDataGenerated* exdData )
@@ -7669,13 +7671,16 @@ Sapphire::Data::Quest::Quest( uint32_t row_id, Sapphire::Data::ExdDataGenerated*
   classJobCategory1 = exdData->getField< uint8_t >( row, 6 );
   classJobLevel1 = exdData->getField< uint16_t >( row, 7 );
   previousQuestJoin = exdData->getField< uint8_t >( row, 8 );
-  previousQuest0 = exdData->getField< uint32_t >( row, 9 );
-  previousQuest1 = exdData->getField< uint32_t >( row, 11 );
-  previousQuest2 = exdData->getField< uint32_t >( row, 12 );
+  previousQuest.push_back( exdData->getField< uint32_t >( row, 9 ) );
+  previousQuest0Sequence = exdData->getField< uint8_t >( row, 10 );
+  previousQuest.push_back( exdData->getField< uint32_t >( row, 11 ) );
+  previousQuest.push_back( exdData->getField< uint32_t >( row, 12 ) );
   questLockJoin = exdData->getField< uint8_t >( row, 13 );
   questLock.push_back( exdData->getField< uint32_t >( row, 14 ) );
   questLock.push_back( exdData->getField< uint32_t >( row, 15 ) );
   header = exdData->getField< uint16_t >( row, 16 );
+  startTown = exdData->getField< uint8_t >( row, 17 );
+  classJobUnlockFlag = exdData->getField< uint8_t >( row, 18 );
   classJobUnlock = exdData->getField< uint8_t >( row, 19 );
   grandCompany = exdData->getField< uint8_t >( row, 20 );
   grandCompanyRank = exdData->getField< uint8_t >( row, 21 );
@@ -7691,6 +7696,8 @@ Sapphire::Data::Quest::Quest( uint32_t row_id, Sapphire::Data::ExdDataGenerated*
   beastTribe = exdData->getField< uint8_t >( row, 31 );
   beastReputationRank = exdData->getField< uint8_t >( row, 32 );
   beastReputationValue = exdData->getField< uint16_t >( row, 33 );
+  satisfactionNpc = exdData->getField< uint8_t >( row, 34 );
+  satisfactionLevel = exdData->getField< uint8_t >( row, 35 );
   mountRequired = exdData->getField< int32_t >( row, 36 );
   isHouseRequired = exdData->getField< bool >( row, 37 );
   deliveryQuest = exdData->getField< uint8_t >( row, 38 );
diff --git a/src/common/Exd/ExdDataGenerated.h b/src/common/Exd/ExdDataGenerated.h
index b670239f..7f890fdd 100644
--- a/src/common/Exd/ExdDataGenerated.h
+++ b/src/common/Exd/ExdDataGenerated.h
@@ -4366,8 +4366,10 @@ struct GuideTitle
 struct GuildleveAssignment
 {
   std::string type;
+  uint8_t typeId;
   uint32_t assignmentTalk;
   std::vector< uint32_t > quest;
+  uint8_t grandCompanyRank;
 
   GuildleveAssignment( uint32_t row_id, Sapphire::Data::ExdDataGenerated* exdData );
 };
@@ -6324,12 +6326,13 @@ struct Quest
   uint8_t classJobCategory1;
   uint16_t classJobLevel1;
   uint8_t previousQuestJoin;
-  uint32_t previousQuest0;
-  uint32_t previousQuest1;
-  uint32_t previousQuest2;
+  std::vector< uint32_t > previousQuest;
+  uint8_t previousQuest0Sequence;
   uint8_t questLockJoin;
   std::vector< uint32_t > questLock;
   uint16_t header;
+  uint8_t startTown;
+  uint8_t classJobUnlockFlag;
   uint8_t classJobUnlock;
   uint8_t grandCompany;
   uint8_t grandCompanyRank;
@@ -6343,6 +6346,8 @@ struct Quest
   uint8_t beastTribe;
   uint8_t beastReputationRank;
   uint16_t beastReputationValue;
+  uint8_t satisfactionNpc;
+  uint8_t satisfactionLevel;
   int32_t mountRequired;
   bool isHouseRequired;
   uint8_t deliveryQuest;
diff --git a/src/world/Event/EventHandler.h b/src/world/Event/EventHandler.h
index cec7d9a2..86c0856a 100644
--- a/src/world/Event/EventHandler.h
+++ b/src/world/Event/EventHandler.h
@@ -85,6 +85,13 @@ namespace Sapphire::Event
       QuestBattleDirector = 0x8006,
     };
 
+    enum class EventState : uint8_t
+    {
+      Invisible,
+      Available,
+      Locked
+    };
+
     using SceneReturnCallback = std::function< void( Entity::Player&, const SceneResult& ) >;
     using SceneChainCallback = std::function< void( Entity::Player& ) >;
     using EventFinishCallback = std::function< void( Entity::Player&, uint64_t ) >;
diff --git a/src/world/Manager/MapMgr.cpp b/src/world/Manager/MapMgr.cpp
index f204020f..29ae7684 100644
--- a/src/world/Manager/MapMgr.cpp
+++ b/src/world/Manager/MapMgr.cpp
@@ -1,27 +1,27 @@
 #include <Common.h>
 #include <Service.h>
 
-#include <datReader/DatCategories/bg/lgb.h>
 #include <Exd/ExdDataGenerated.h>
 
 #include <Event/EventHandler.h>
 
 #include <Network/CommonActorControl.h>
-#include <Network/GameConnection.h>
 #include <Network/PacketDef/Zone/ServerZoneDef.h>
 #include <Network/PacketWrappers/ActorControlSelfPacket.h>
 
-#include <Logging/Logger.h>
 #include <Util/Util.cpp>
 
 #include <Actor/Player.h>
-#include <Inventory/Item.h>
+
+#include <Script/ScriptMgr.h>
+#include <Script/NativeScriptMgr.h>
+
+#include <Territory/InstanceObjectCache.h>
+#include <datReader/DatCategories/bg/lgb.h>
 
 #include "MapMgr.h"
 #include "TerritoryMgr.h"
 
-#include "ServerMgr.h"
-
 using namespace Sapphire::Event;
 using namespace Sapphire::Network::Packets;
 using namespace Sapphire::Network::Packets::Server;
@@ -30,411 +30,402 @@ Sapphire::World::Manager::MapMgr::MapMgr()
 {  
   auto& exdData = Common::Service< Data::ExdDataGenerated >::ref();
 
-  size_t count = 0;
-
-  for( auto quest : exdData.m_QuestDat.get_rows() )
-  {
-    if( exdData.getField< std::string >( quest.second, 1 ).empty() ) // id
-      continue;
-
-    auto& questData = m_questData[ quest.first ];
-
-    questData.previousQuestJoin = exdData.getField< uint8_t >( quest.second, 8 );
-    questData.previousQuestKeys[ 0 ] = exdData.getField< uint32_t >( quest.second, 9 );
-    questData.previousQuest0Sequence = exdData.getField< uint8_t >( quest.second, 10 );
-    questData.previousQuestKeys[ 1 ] = exdData.getField< uint32_t >( quest.second, 11 );
-    questData.previousQuestKeys[ 2 ] = exdData.getField< uint32_t >( quest.second, 12 );
-
-    questData.questLockJoin = exdData.getField< uint8_t >( quest.second, 13 );
-    questData.questLockKeys[ 0 ] = exdData.getField< uint32_t >( quest.second, 14 );
-    questData.questLockKeys[ 1 ] = exdData.getField< uint32_t >( quest.second, 15 );
-
-    questData.classJobRequirements[ 0 ].classJobLevel = exdData.getField< uint16_t >( quest.second, 4 );
-    auto classJobsCategory = exdData.get< Data::ClassJobCategory >( exdData.getField< uint8_t >( quest.second, 3 ) );
-    for( int32_t i = 0; i <= Common::CLASSJOB_TOTAL; i++ )
-      questData.classJobRequirements[ 0 ].classJobCategoryMask.set( i, ( &classJobsCategory->aDV )[ i ] );
-      
-    questData.classJobRequirements[ 1 ].classJobLevel = exdData.getField< uint16_t >( quest.second, 7 );
-    classJobsCategory = exdData.get< Data::ClassJobCategory >( exdData.getField< uint8_t >( quest.second, 6 ) );
-    for( int32_t i = 0; i <= Common::CLASSJOB_TOTAL; i++ )
-      questData.classJobRequirements[ 1 ].classJobCategoryMask.set( i, ( &classJobsCategory->aDV )[ i ] );
-
-    questData.classJobUnlockFlag = exdData.getField< uint8_t >( quest.second, 18 );
-    questData.classJobUnlock = exdData.getField< uint8_t >( quest.second, 19 );
-
-    questData.requiredGC = exdData.getField< uint8_t >( quest.second, 20 );
-    questData.requiredGCRank = exdData.getField< uint8_t >( quest.second, 21 );
-
-    questData.startTown = exdData.getField< uint8_t >( quest.second, 17 );
-
-    questData.header = exdData.getField< uint16_t >( quest.second, 16 );
-
-    questData.instanceContentJoin = exdData.getField< uint8_t >( quest.second, 22 );
-    questData.instanceContent[ 0 ] = exdData.getField< uint32_t >( quest.second, 23 );
-    questData.instanceContent[ 1 ] = exdData.getField< uint32_t >( quest.second, 24 );
-    questData.instanceContent[ 2 ] = exdData.getField< uint32_t >( quest.second, 25 );
-
-    questData.festival = exdData.getField< uint8_t >( quest.second, 26 );
-    questData.festivalBegin = exdData.getField< uint8_t >( quest.second, 27 );
-    questData.festivalEnd = exdData.getField< uint8_t >( quest.second, 28 );
-    questData.bellStart = exdData.getField< uint16_t >( quest.second, 29 );
-    questData.bellEnd = exdData.getField< uint16_t >( quest.second, 30 );   
-
-    questData.repeatIntervalType = exdData.getField< uint8_t >( quest.second, 44 );
-    questData.questRepeatFlag = exdData.getField< uint8_t >( quest.second, 45 ); 
-
-    questData.beastTribe = exdData.getField< uint8_t >( quest.second, 31 );
-    questData.beastReputationRank = exdData.getField< uint8_t >( quest.second, 32 );
-    questData.beastReputationValue = exdData.getField< uint16_t >( quest.second, 33 );
-
-    questData.mount = exdData.getField< int32_t >( quest.second, 36 );
-
-    questData.satisfactionNpc = exdData.getField< uint8_t >( quest.second, 34 );
-    questData.satisfactionRank = exdData.getField< uint8_t >( quest.second, 35 );
-
-    questData.issuer = exdData.getField< uint32_t >( quest.second, 39 );
-
-    questData.deliveryQuest = exdData.getField< uint8_t >( quest.second, 38 );
-
-    questData.expansion = exdData.getField< uint8_t >( quest.second, 2 );
-
-    questData.type = exdData.getField< uint8_t >(quest.second, 47);
-
-    questData.isRepeatable = exdData.getField< bool >( quest.second, 43 );
-    questData.isHouseRequired = exdData.getField< bool >( quest.second, 37 );
-
-    questData.iconValid = exdData.get< Data::EventIconType >( exdData.getField< uint8_t >( quest.second, 1512 ) )->mapIconAvailable + 1 + questData.isRepeatable;
-    questData.iconInvalid = exdData.get< Data::EventIconType >( exdData.getField< uint8_t >( quest.second, 1512 ) )->mapIconInvalid + 1 + questData.isRepeatable;
-
-    uint32_t issuerLevelId = exdData.getField< uint32_t >( quest.second, 40 );
-    if( issuerLevelId != 0 )
-    {
-      if( count++ % 100 == 0 )
-        std::cout << ".";
-
-      auto level = exdData.get< Data::Level >( issuerLevelId );
-      auto territory = level->territory;
-
-      if( territory == 0 )
-        territory = exdData.get< Data::Map >( level->map )->territoryType;
-
-      EventData eventData;
-      eventData.iconId = questData.iconValid;
-      eventData.levelId = issuerLevelId;
-      eventData.actorId = questData.issuer;
-
-      m_mapData[ territory ].emplace( quest.first, eventData );
-    }
-  }
-  
-  auto& serverMgr = Common::Service< World::ServerMgr >::ref();
-  auto m_gameData = new xiv::dat::GameData( serverMgr.getConfig().global.general.dataPath );
-
-  std::set< std::string > bgSet;
-
-  for( auto territoryTypeId : exdData.getTerritoryTypeIdList() )
-  {
-    auto territoryType = exdData.get< Data::TerritoryType >( territoryTypeId );
-    if( territoryType->bg.empty() )
-      continue;
-
-    if( bgSet.find( territoryType->bg ) != bgSet.end() )
-      continue;
-    else
-      bgSet.insert( territoryType->bg );
-
-    std::string planeventLgbPath( "bg/" + territoryType->bg.substr( 0, territoryType->bg.rfind( '/' ) ) + "/planevent.lgb" );
-    auto planeventFile = m_gameData->getFile( planeventLgbPath );
-    auto planeventData = planeventFile->access_data_sections().at( 0 );
-    LGB_FILE planeventLgb( &planeventData[ 0 ], "planevent" );
-
-    for( const auto& group : planeventLgb.groups )
-    {
-      for( const auto& pEntry : group.entries )
-      {
-        if( pEntry->getType() == LgbEntryType::EventNpc )
-        {
-          auto pNpc = reinterpret_cast< LGB_ENPC_ENTRY* >( pEntry.get() );
-
-          auto eNpcData = exdData.get< Data::ENpcBase >( pNpc->data.enpcId )->eNpcData;
-
-          for( auto npcData : eNpcData )
-          {
-            if( npcData == 0 )
-              continue; // Some npcs have data gaps, so we have to iterate through the entire array
-
-            if( count++ % 1000 == 0 )
-              std::cout << ".";
-
-            EventData eventData;
-            eventData.levelId = pNpc->data.instanceId;
-            eventData.actorId = pNpc->data.enpcId;
-
-            auto eventHandlerType = static_cast< EventHandler::EventHandlerType >( npcData >> 16 );
-
-            switch( eventHandlerType )
-            {
-              case EventHandler::EventHandlerType::GuildLeveAssignment:
-              {
-                eventData.iconId = exdData.get< Data::EventIconType >( 5 )->mapIconAvailable + 1;
-
-                m_mapData[ territoryTypeId ].insert( std::make_pair( npcData, eventData ) );
-                break;
-              }
-
-              case EventHandler::EventHandlerType::CustomTalk:
-              {
-                // Include only the beginner arena icon yet. There a few other ones, that aren't referenced in the game files (Some examples are: The Triple Triad Tournament npc which has multiple icons and the ocean fishing icon)
-                if( npcData == 721223 )
-                {
-                  auto customTalk = exdData.get< Data::CustomTalk >( npcData );
-
-                  eventData.iconId = customTalk->iconMap;
-
-                  m_mapData[ territoryTypeId ].insert( std::make_pair( npcData, eventData ) );
-                }
-                break;
-              }
-
-              case EventHandler::EventHandlerType::GuildOrderGuide:
-              {
-                eventData.iconId = exdData.get< Data::EventIconType >( 6 )->mapIconAvailable + 1;
-
-                m_mapData[ territoryTypeId ].insert( std::make_pair( npcData, eventData ) );
-                break;
-              }
-
-              case EventHandler::EventHandlerType::TripleTriad:
-              {
-                eventData.iconId = exdData.get< Data::EventIconType >( 7 )->mapIconAvailable + 1;
-
-                m_mapData[ territoryTypeId ].insert( std::make_pair( npcData, eventData ) );
-                break;
-              }
-
-              case EventHandler::EventHandlerType::PreHandler:
-              {
-                //I think this is used in Bozja and Zadnor, need evidence
-                //m_mapData[ territoryTypeId ].insert( std::make_pair( eventData, 0 ) );
-                break;
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  std::cout << "\n";
+  for( uint32_t questId = 65536; auto curQuest = exdData.get< Data::Quest >( questId ); questId++ )
+    m_quests.emplace( questId, curQuest );
 }
 
 void Sapphire::World::Manager::MapMgr::updateAll( Entity::Player& player )
 {
-  auto& mapData = m_mapData[ player.getTerritoryTypeId() ];
-  std::multimap< uint32_t, EventData, less > newMapData;
+  auto& exdData = Common::Service< Data::ExdDataGenerated >::ref();
+  auto& objectCache = Common::Service< Sapphire::InstanceObjectCache >::ref();
 
-  for( auto eventData : mapData )
+  EventSet mapData;
+
+  auto eventNpcs = objectCache.getAllEventNpc( player.getZoneId() );
+  if( eventNpcs )
   {
-    switch( static_cast< EventHandler::EventHandlerType >( eventData.first >> 16 ) )
+    for( const auto& eventNpc : *eventNpcs )
     {
-      case EventHandler::EventHandlerType::Quest:
+      auto eNpc = exdData.get< Data::ENpcBase >( eventNpc.second->data.enpcId );
+      if( eNpc )
       {
-        if( isQuestAvailable( player, eventData ) )
-          newMapData.insert( eventData );
-
-        break;
-      }
-
-      case EventHandler::EventHandlerType::GuildLeveAssignment:
-      {
-        auto& exdData = Common::Service< Data::ExdDataGenerated >::ref();
-        auto guildLeve = exdData.get< Data::GuildleveAssignment >( eventData.first );
-
-        if( player.isActionLearned( 5 )  )
+        auto eNpcData = eNpc->eNpcData;
+        for( auto npcData : eNpcData )
         {
-          if( player.isQuestCompleted( guildLeve->quest[ 0 ] ) )
+          if( npcData == 0 )
+            continue; // Some npcs have data gaps, so we have to iterate through the entire array
+
+          EventData eventData;
+          eventData.eventId = npcData;
+          eventData.levelId = eventNpc.first;
+        
+          auto eventHandlerType = static_cast< EventHandler::EventHandlerType >( npcData >> 16 );
+
+          switch( eventHandlerType )
           {
-            if( eventData.first >= 393239 && eventData.first <= 393247 )
+            case EventHandler::EventHandlerType::Quest:
             {
-              if( player.getGc() != 0 )
-                newMapData.insert( eventData );
+              auto quest = m_quests[ npcData ];
+
+              if( quest->issuerLocation == eventNpc.first )
+              {
+                insertQuest( player, npcData, mapData );
+              }
+              break;
             }
-            else
+            case EventHandler::EventHandlerType::GuildLeveAssignment:
             {
-              newMapData.insert( eventData );
+              if( player.isActionLearned( 5 ) )
+              {
+                auto guildLeve = exdData.get< Data::GuildleveAssignment >( npcData );
+
+                eventData.iconId = exdData.get< Data::EventIconType >( 5 )->mapIconAvailable + 1;
+
+                if( player.isQuestCompleted( guildLeve->quest[ 0 ] ) ||
+                    ( ( guildLeve->typeId == 2 || npcData == 393217 || npcData == 393223 || npcData == 393225 ) && // Leve npc locations: Bentbranch / Horizon / Swiftperch
+                    ( player.isQuestCompleted( 220 ) || player.isQuestCompleted( 687 ) || player.isQuestCompleted( 693 ) ) ) )
+                {
+                  if( guildLeve->typeId == 2 )
+                  {
+                    if( player.getGc() != 0 )
+                    {
+                      for( int8_t i = 0; i < 3; i++ )
+                      {
+                        if( player.getGcRankArray()[ i ] >= guildLeve->grandCompanyRank )
+                        {
+                          mapData.insert( eventData );
+                          break;
+                        }
+                      }
+                    }
+                  }
+                  else
+                  {
+                    mapData.insert( eventData );
+                  }
+                }
+              }              
+              break;
+            }
+          
+            case EventHandler::EventHandlerType::CustomTalk:
+            {
+              // Include only the beginner arena icon yet. There a few other ones, that aren't referenced in the game files (Some examples are: The Triple Triad Tournament npc which has multiple icons and the ocean fishing icon)
+              if( npcData == 721223 )
+              {
+                auto customTalk = exdData.get< Data::CustomTalk >( npcData );
+                
+                eventData.iconId = customTalk->iconMap;
+                
+                mapData.insert( eventData );
+              }
+              break;
+            }
+          
+            case EventHandler::EventHandlerType::GuildOrderGuide:
+            {
+              if( player.isActionLearned( 7 ) )
+              {
+                eventData.iconId = exdData.get< Data::EventIconType >( 6 )->mapIconAvailable + 1;
+                
+                mapData.insert( eventData );
+              }
+              break;
+            }
+
+            case EventHandler::EventHandlerType::TripleTriad:
+            {
+              if( npcData == 2293771 ) // Triple Triad Master npc for now only
+              {
+                eventData.iconId = exdData.get< Data::EventIconType >( 7 )->mapIconAvailable + 1;
+                
+                mapData.insert( eventData );
+              }
+              break;
+            }
+          
+            case EventHandler::EventHandlerType::PreHandler:
+            {
+              //I think this is used in Bozja and Zadnor, need evidence
+              break;
             }
-          }
-          else if( eventData.first == 393217 || eventData.first == 393223 || eventData.first == 393225 ) // Leve npc locations: Bentbranch / Horizon / Swiftperch
-          {
-            if( player.isQuestCompleted( 220 ) || player.isQuestCompleted( 687 ) || player.isQuestCompleted( 693 ) )
-              newMapData.insert( eventData );
           }
         }
-
-        break;
-      }
-
-      case EventHandler::EventHandlerType::CustomTalk:
-      {
-        newMapData.insert( eventData );
-
-        break;
-      }
-
-      case EventHandler::EventHandlerType::GuildOrderGuide:
-      {
-        if( player.isActionLearned( 7 ) )
-          newMapData.insert( eventData );
-
-        break;
-      }
-
-      case EventHandler::EventHandlerType::TripleTriad:
-      {
-        if( eventData.first == 2293771 ) // Triple Triad Master npc for now only
-          newMapData.insert( eventData );
-
-        break;
       }
     }
   }
   
-  sendPackets( player, newMapData, All );
+  auto eventObjs = objectCache.getAllEventObj( player.getZoneId() );
+  if( eventObjs )
+  {
+    for( const auto& eventObj : *eventObjs )
+    {
+      auto eObj = exdData.get< Data::EObj >( eventObj.second->data.eobjId );
+      if( eObj )
+      {
+        auto eObjData = eObj->data;
+        if( eObjData )
+        {
+          EventData eventData;
+          eventData.eventId = eObjData;
+          eventData.levelId = eventObj.first;
+        
+          auto eventHandlerType = static_cast< EventHandler::EventHandlerType >( eObjData >> 16 );
+
+          if( eventHandlerType == EventHandler::EventHandlerType::Quest )
+          {
+            auto quest = m_quests[ eObjData ];
+
+            if( quest->issuerLocation == eventObj.first )
+            {
+              insertQuest( player, eObjData, mapData );
+            }
+          }
+        }
+      }
+    }
+  }
+
+  
+  sendPackets( player, mapData, All );
 }
 
 void Sapphire::World::Manager::MapMgr::updateQuests( Entity::Player& player )
 {
-  auto& mapData = m_mapData[ player.getTerritoryTypeId() ];
-  std::multimap< uint32_t, EventData, less > newMapData;
+  auto& exdData = Common::Service< Data::ExdDataGenerated >::ref();
+  auto& objectCache = Common::Service< Sapphire::InstanceObjectCache >::ref();
 
-  for( auto& eventData : mapData )
+  EventSet mapData;
+
+  auto eventNpcs = objectCache.getAllEventNpc( player.getZoneId() );
+  if( eventNpcs )
   {
-    if( ( eventData.first >> 16 ) == static_cast< uint16_t >( EventHandler::EventHandlerType::Quest ) )
+    for( const auto& eventNpc : *eventNpcs )
     {
-      if( isQuestAvailable( player, eventData ) )
-        newMapData.insert( eventData );
+      auto eNpcData = exdData.get< Data::ENpcBase >( eventNpc.second->data.enpcId )->eNpcData;
+
+      for( auto npcData : eNpcData )
+      {
+        if( npcData == 0 )
+          continue; // Some npcs have data gaps, so we have to iterate through the entire array
+
+        EventData eventData;
+        eventData.eventId = npcData;
+        eventData.levelId = eventNpc.first;
+        
+        auto eventHandlerType = static_cast< EventHandler::EventHandlerType >( npcData >> 16 );
+
+        if( eventHandlerType == EventHandler::EventHandlerType::Quest )
+        {
+          auto quest = m_quests[ npcData ];
+
+          if( quest->issuerLocation == eventNpc.first )
+          {
+            insertQuest( player, npcData, mapData );
+          }
+        }
+      }
     }
   }
-  
-  sendPackets( player, newMapData, Quest );;
+
+  auto eventObjs = objectCache.getAllEventObj( player.getZoneId() );
+  if( eventObjs )
+  {
+    for( const auto& eventObj : *eventObjs )
+    {
+      auto eObj = exdData.get< Data::EObj >( eventObj.second->data.eobjId );
+      if( eObj )
+      {
+        auto eObjData = eObj->data;
+        if( eObjData )
+        {
+          EventData eventData;
+          eventData.eventId = eObjData;
+          eventData.levelId = eventObj.first;
+        
+          auto eventHandlerType = static_cast< EventHandler::EventHandlerType >( eObjData >> 16 );
+
+          if( eventHandlerType == EventHandler::EventHandlerType::Quest )
+          {
+            auto quest = m_quests[ eObjData ];
+
+            if( quest->issuerLocation == eventObj.first )
+            {
+              insertQuest( player, eObjData, mapData );
+            }
+          }
+        }
+      }
+    }
+  }
+
+  sendPackets( player, mapData, Quest );
 }
 
-bool Sapphire::World::Manager::MapMgr::isQuestAvailable( Entity::Player& player, std::pair< const uint32_t, EventData >& eventData )
+void Sapphire::World::Manager::MapMgr::insertQuest( Entity::Player& player, uint32_t questId, EventSet& mapData )
+{
+  auto& exdData = Common::Service< Data::ExdDataGenerated >::ref();
+  auto& scriptMgr = Common::Service< Scripting::ScriptMgr >::ref();
+
+  auto quest = m_quests[ questId ];
+
+  if( isQuestVisible( player, questId, quest ) )
+  {
+    auto script = scriptMgr.getNativeScriptHandler().getScript< Sapphire::ScriptAPI::EventScript >( questId );
+
+    // Just don't show quests on map, that aren't implemented yet
+    if( script )
+    {                        
+      EventData eventData;
+      eventData.eventId = questId;
+
+      auto eventState = script->checkExtraConditions( player, questId );
+
+      if( eventState == Event::EventHandler::EventState::Available || eventState == Event::EventHandler::EventState::Locked )
+      {
+        if( eventState == Event::EventHandler::EventState::Available && isQuestAvailable( player, questId, quest ) )
+        {
+          eventData.iconId = exdData.get< Data::EventIconType >( quest->eventIconType )->mapIconAvailable + 1 + quest->isRepeatable;
+          eventData.levelId = quest->issuerLocation;
+        }
+        else
+        {
+          eventData.iconId = exdData.get< Data::EventIconType >( quest->eventIconType )->mapIconInvalid + 1 + quest->isRepeatable;
+          eventData.levelId = quest->issuerLocation;
+        }
+
+        mapData.insert( eventData );
+      }
+    }
+  }
+}
+
+bool Sapphire::World::Manager::MapMgr::isQuestAvailable( Entity::Player& player, uint32_t questId, Data::ExdDataGenerated::QuestPtr questPtr )
 {
   auto& exdData = Common::Service< Data::ExdDataGenerated >::ref();
 
-  auto& quest = m_questData[ eventData.first ];
+  if( questPtr->grandCompany || questPtr->grandCompanyRank )
+  {
+    if( questPtr->grandCompany != player.getGc() )
+    {
+      if( questPtr->grandCompanyRank > player.getGcRankArray()[ player.getGc() - 1 ] )
+        return false;
+    }
+  }  
 
-  if( ( player.isQuestCompleted( eventData.first ) && ( !quest.isRepeatable && eventData.first != 67114 ) ) || player.hasQuest( eventData.first ) ||
-      ( quest.repeatIntervalType == 1 && quest.questRepeatFlag == 0 ) ) // Don't show daily beast tribe quests on the map yet.
+  if( questPtr->instanceContentJoin == 1 )
+  {
+    for( int32_t i = 0; i < 3; i++ )
+    {
+      if( questPtr->instanceContent[ i ] == 0 )
+        continue;
+
+      return false;
+    }
+
+    return true;
+  }
+  else if( questPtr->instanceContentJoin == 2 )
+  {
+    for( int32_t i = 0; i < 3; i++ )
+    {
+      if( questPtr->instanceContent[ i ] == 0 )
+        continue;
+
+      return false;
+    }
+  }  
+
+  if( questPtr->bellStart || questPtr->bellEnd )
+  {
+    uint64_t curEorzeaTime = Util::getEorzeanTimeStamp();
+    uint32_t convTime = 100 * ( curEorzeaTime / 3600 % 24 ) + curEorzeaTime / 60 % 60;
+
+    if( questPtr->bellStart <= questPtr->bellEnd )
+    {
+      if( convTime < questPtr->bellStart || convTime >= questPtr->bellEnd )
+        return false;
+    }
+    else
+    {
+      if( convTime < questPtr->bellStart && convTime >= questPtr->bellEnd )
+        return false;
+    }
+  }  
+
+  auto classJobCategory = &exdData.get< Data::ClassJobCategory >( questPtr->classJobCategory0 )->aDV;
+  if( !classJobCategory[ static_cast< uint8_t >( player.getClass() ) ] )
     return false;
 
-  if( quest.classJobUnlock )
+  if( questPtr->classJobCategory1 > 1 )
   {
-    if( quest.classJobUnlockFlag == 3 )
-      if( static_cast< uint8_t >( player.getClass() ) != quest.classJobUnlock )
+    classJobCategory = &exdData.get< Data::ClassJobCategory >( questPtr->classJobCategory1 )->aDV;
+    if( !classJobCategory[ static_cast< uint8_t >( player.getClass() ) ] )
+      return false;
+  }
+
+  return true;
+}
+
+bool Sapphire::World::Manager::MapMgr::isQuestVisible( Entity::Player& player, uint32_t questId, Data::ExdDataGenerated::QuestPtr questPtr )
+{
+  auto& exdData = Common::Service< Data::ExdDataGenerated >::ref();
+
+  if( ( player.isQuestCompleted( questId ) && ( !questPtr->isRepeatable && questId != 67114 ) ) || player.hasQuest( questId ) )
+    return false;
+
+  if( questPtr->classJobUnlock )
+  {
+    if( questPtr->classJobUnlockFlag == 3 )
+      if( static_cast< uint8_t >( player.getClass() ) != questPtr->classJobUnlock )
         return false;
-    else if( quest.classJobUnlockFlag == 4 )
-      if ( static_cast< uint8_t >( player.getClass() ) == quest.classJobUnlock )
+    else if( questPtr->classJobUnlockFlag == 4 )
+      if ( static_cast< uint8_t >( player.getClass() ) == questPtr->classJobUnlock )
         return false;
     else
       return false;
   }
 
   // Was this really ever used?
-  if( quest.startTown )
+  if( questPtr->startTown )
   {
-    if( quest.startTown != player.getStartTown() )
+    if( questPtr->startTown != player.getStartTown() )
       return false;
   }
 
-  if( Common::CURRENT_EXPANSION_ID < quest.expansion )
+  if( Common::CURRENT_EXPANSION_ID < questPtr->expansion )
     return false;
 
-  if( quest.mount )
+  if( questPtr->mountRequired )
   {
-    if( !player.hasMount( quest.mount ) )
+    if( !player.hasMount( questPtr->mountRequired ) )
       return false;
   }
 
-  if( eventData.first == 65968 ) // Quest: A Legend for a Legend
+  if( questPtr->grandCompany )
   {
-    uint32_t requiredMounts[] = { 28, 29, 30, 31, 40, 43 };
-
-    for( int32_t i = 0; i < 6; i++ )
-    {
-      if( !player.hasMount( requiredMounts[ i ] ) )
-        return false;
-    }
-  }
-  else if( eventData.first == 67086 ) // Quest: Fiery Wings, Fiery Hearts
-  {
-    uint32_t requiredMounts[] = { 75, 76, 77, 78, 90, 98, 104 };
-
-    for( int32_t i = 0; i < 6; i++ )
-    {
-      if( !player.hasMount( requiredMounts[ i ] ) )
-        return false;
-    }
-  }
-  else if( eventData.first == 68736 ) // Quest: A Lone Wolf No More
-  {
-    uint32_t requiredMounts[] = { 115, 116, 133, 144, 158, 172, 182 };
-
-    for( int32_t i = 0; i < 6; i++ )
-    {
-      if( !player.hasMount( requiredMounts[ i ] ) )
-        return false;
-    }
-  }
-
-  if( quest.requiredGC || quest.requiredGCRank )
-  {
-    if( quest.requiredGC != player.getGc() )
-      return false;
-
-    if( quest.requiredGCRank > player.getGcRankArray()[ player.getGc() - 1 ] )
-      eventData.second.iconId = quest.iconInvalid;
-  }
-
-  if( quest.header != 0 )
-  {
-    if ( !player.isActionLearned( quest.header ) )
+    if( questPtr->grandCompany != player.getGc() )
       return false;
   }
 
-  //Required previous quests for ARR relic
-  if( eventData.first == 66971 ) // Quest: Up in Arms
+  if( questPtr->header != 0 )
   {
-    for( int32_t i = 0; i <= Common::CLASSJOB_TOTAL; i++ )
-    {
-      auto classJob = exdData.get< Data::ClassJob >( i );
-
-      if( player.isQuestCompleted( classJob->relicQuest ) )
-        break;
-
-      if( i == Common::CLASSJOB_TOTAL )
-        return false;
-    }
-  }
-  else if( eventData.first == 65897 ) // Quest: His Dark Materia
-  {
-    // Quests in the following order: A Ponze of Flesh, Labor of Love, Method in His Malice, A Treasured Mother
-    if( !player.isQuestCompleted( 357 ) || !player.isQuestCompleted( 358 ) || !player.isQuestCompleted( 359 ) || !player.isQuestCompleted( 360 ) )
+    if ( !player.isActionLearned( questPtr->header ) )
       return false;
   }
 
-  if( quest.previousQuestJoin == 1 )
+  if( questPtr->previousQuestJoin == 1 )
   {
     for( int32_t i = 0; i < 3; i++ )
     {
-      if( quest.previousQuestKeys[ i ] == 0 )
+      if( questPtr->previousQuest[ i ] == 0 )
         continue;
 
-      if( !player.isQuestCompleted( quest.previousQuestKeys[ i ] ) )
+      if( !player.isQuestCompleted( questPtr->previousQuest[ i ] ) )
       {
-        if( i == 0 && quest.previousQuest0Sequence != 0 )
+        if( i == 0 && questPtr->previousQuest0Sequence != 0 )
         {
-          if( player.getQuestSeq( quest.previousQuestKeys[ i ] ) < quest.previousQuest0Sequence )
+          if( player.getQuestSeq( questPtr->previousQuest[ i ] ) < questPtr->previousQuest0Sequence )
             return false;
         }
         else
@@ -444,14 +435,14 @@ bool Sapphire::World::Manager::MapMgr::isQuestAvailable( Entity::Player& player,
       }
     }
   }
-  else if( quest.previousQuestJoin == 2 )
+  else if( questPtr->previousQuestJoin == 2 )
   {
     for( int32_t i = 0; i < 3; i++ )
     {
-      if( quest.previousQuestKeys[ i ] == 0 )
+      if( questPtr->previousQuest[ i ] == 0 )
         continue;
 
-      if( player.isQuestCompleted( quest.previousQuestKeys[ i ] ) )
+      if( player.isQuestCompleted( questPtr->previousQuest[ i ] ) )
         break;
 
       if( i == 2 )
@@ -459,93 +450,54 @@ bool Sapphire::World::Manager::MapMgr::isQuestAvailable( Entity::Player& player,
     }
   }
 
-  if( quest.questLockJoin == 1 )
+  if( questPtr->questLockJoin == 1 )
   {
     for( int32_t i = 0; i < 2; i++ )
     {
-      if( quest.questLockKeys[ i ] == 0 )
+      if( questPtr->questLock[ i ] == 0 )
         continue;
 
-      if( !player.isQuestCompleted( quest.questLockKeys[ i ] ) && !player.hasQuest( quest.questLockKeys[ i ] ) )
+      if( !player.isQuestCompleted( questPtr->questLock[ i ] ) && !player.hasQuest( questPtr->questLock[ i ] ) )
         break;
 
       if( i == 1 )
         return false;
     }
   }
-  else if( quest.questLockJoin == 2 )
+  else if( questPtr->questLockJoin == 2 )
   {
     for( int32_t i = 0; i < 2; i++ )
     {
-      if( quest.questLockKeys[ i ] == 0 )
+      if( questPtr->questLock[ i ] == 0 )
         continue;
 
-      if( player.isQuestCompleted( quest.questLockKeys[ i ] ) || player.hasQuest( quest.questLockKeys[ i ] ) )
+      if( player.isQuestCompleted( questPtr->questLock[ i ] ) || player.hasQuest( questPtr->questLock[ i ] ) )
         return false;
     }
   }
 
-  if( quest.instanceContentJoin == 1 )
-  {
-    for( int32_t i = 0; i < 3; i++ )
-    {
-      if( quest.instanceContent[ i ] == 0 )
-        continue;
-
-      eventData.second.iconId = quest.iconInvalid;
-    }
-  }
-  else if( quest.instanceContentJoin == 2 )
-  {
-    for( int32_t i = 0; i < 3; i++ )
-    {
-      if( quest.instanceContent[ i ] == 0 )
-        continue;
-
-      eventData.second.iconId = quest.iconInvalid;
-    }
-  }
-
-  if( quest.festival )
+  if( questPtr->festival )
   {
     auto& territoryMgr = Common::Service< Manager::TerritoryMgr >::ref();
     auto& festival = territoryMgr.getCurrentFestival();
 
-    if( quest.festival != festival.first && quest.festival != festival.second )
+    if( questPtr->festival != festival.first && questPtr->festival != festival.second )
       return false;
 
     // Don't show festivals with begin state other than 0 yet
-    if( quest.festivalBegin != 0 )
+    if( questPtr->festivalBegin != 0 )
       return false;
   }
 
-  if( quest.bellStart || quest.bellEnd )
+  if( ( questPtr->type & 1 ) == 0 )
   {
-    uint64_t curEorzeaTime = Util::getEorzeanTimeStamp();
-    uint32_t convTime = 100 * (curEorzeaTime / 3600 % 24) + curEorzeaTime / 60 % 60;
+    auto classJobCategory = &exdData.get< Data::ClassJobCategory >( questPtr->classJobCategory0 )->aDV;
 
-    if( quest.bellStart <= quest.bellEnd )
-    {
-      if( convTime < quest.bellStart || convTime >= quest.bellEnd )
-        eventData.second.iconId = quest.iconInvalid;
-    }
-    else
-    {
-      if( convTime < quest.bellStart && convTime >= quest.bellEnd )
-        eventData.second.iconId = quest.iconInvalid;
-    }
-  }
-
-  if( !quest.classJobRequirements[0].classJobCategoryMask.test( static_cast< uint8_t >( player.getClass() ) ) )
-    eventData.second.iconId = quest.iconInvalid;
-
-  if( player.getQuestSeq( eventData.first ) || ( quest.type & 1 ) == 0 )
-  {
     for( int32_t i = 1; i <= Common::CLASSJOB_TOTAL; i++ )
     {
-      if( quest.classJobRequirements[0].classJobCategoryMask.test( i ) )
+      if( classJobCategory[ i ] )
       {
-        if( player.getLevelForClass( static_cast< Common::ClassJob >( i ) ) >=  quest.classJobRequirements[0].classJobLevel )
+        if( player.getLevelForClass( static_cast< Common::ClassJob >( i ) ) >=  questPtr->classJobLevel0 )
           break;
       }
 
@@ -555,30 +507,15 @@ bool Sapphire::World::Manager::MapMgr::isQuestAvailable( Entity::Player& player,
   }
   else
   {
-    if( player.getLevel() < quest.classJobRequirements[0].classJobLevel )
+    if( player.getLevel() < questPtr->classJobLevel0 )
       return false;
   }
 
-  if( quest.classJobRequirements[1].classJobCategoryMask.any() )
-  {
-    for( int32_t i = 1; i <= Common::CLASSJOB_TOTAL; i++ )
-    {
-      if( quest.classJobRequirements[1].classJobCategoryMask.test( i ) )
-      {
-        if( player.getLevelForClass( static_cast< Common::ClassJob >( i ) ) >=  quest.classJobRequirements[1].classJobLevel )
-          break;
-      }
-
-      if( i == Common::CLASSJOB_TOTAL )
-        return false;
-    }
-  }
-
   for( int32_t i = 0; i <= Common::CLASSJOB_TOTAL; i++ )
   {
     auto classJob = exdData.get< Data::ClassJob >( i );
 
-    if( classJob->relicQuest == eventData.first )
+    if( classJob->relicQuest == questId )
     {
       for( int32_t j = 0; i <= Common::CLASSJOB_TOTAL; i++ )
       {
@@ -592,157 +529,21 @@ bool Sapphire::World::Manager::MapMgr::isQuestAvailable( Entity::Player& player,
     }
   }
 
-  if( quest.beastTribe )
+  if( questPtr->beastTribe )
     return false;
 
-  if( quest.satisfactionNpc )
+  if( questPtr->satisfactionNpc )
     return false;
-
-  auto isRelicEquipped = [ &player, &eventData ]( uint32_t* mainWeaponId, uint32_t secondaryWeaponId )
-  {
-    for( int32_t i = 0; i < 10; i++ )
-    {
-      if( i == 0 )
-      {
-        if( player.getEquippedSecondaryWeapon() == nullptr )
-        {
-          if( player.getEquippedWeapon()->getId() == mainWeaponId[ i ] && secondaryWeaponId == 0 )
-            return true;
-        }
-        else if( player.getEquippedWeapon()->getId() == mainWeaponId[ i ] && player.getEquippedSecondaryWeapon()->getId() == secondaryWeaponId )
-        {
-          return true;
-        }
-      }
-      else
-      {
-        if( player.getEquippedWeapon()->getId() == mainWeaponId[ i ] )
-          return true;
-      }
-    }
-
-    return false;
-  };
-
-  switch( eventData.first )
-  {
-    case 65742: // Quest: Mmmmmm, Soulglazed Relics
-    {
-      uint32_t relicItemIds[] = { 7863, 7864, 7865, 7866, 7867, 9253, 7868, 7869, 7870, 7871 };
-
-      if( !isRelicEquipped( relicItemIds, 7872 ) )
-        eventData.second.iconId = quest.iconInvalid;
-
-      break;
-    }
-
-    case 65892: // Quest: Wherefore Art Thou, Zodiac
-    case 65897: // Quest: His Dark Materia
-    {
-      uint32_t relicItemIds[] = { 8649, 8650, 8651, 8652, 8653, 9254, 8654, 8655, 8656, 8657 };
-
-      if( !isRelicEquipped( relicItemIds, 8658 ) )
-        eventData.second.iconId = quest.iconInvalid;
-
-      break;
-    }
-
-    case 66096: // Quest: Rise and Shine
-    {
-      uint32_t relicItemIds[] = { 9491, 9492, 9493, 9494, 9495, 9501, 9496, 9497, 9498, 9499 };
-
-      if( !isRelicEquipped( relicItemIds, 9500 ) )
-        eventData.second.iconId = quest.iconInvalid;
-
-      break;
-    }
-
-    case 66097: // Quest: The Vital Title
-    {
-      uint32_t relicItemIds[] = { 10054, 10055, 10056, 10057, 10058, 10064, 10059, 10060, 10061, 10062 };
-
-      if( !isRelicEquipped( relicItemIds, 10063 ) )
-        eventData.second.iconId = quest.iconInvalid;
-
-      break;
-    }
-
-    case 66971: // Quest: Up in Arms
-    {
-      uint32_t relicItemIds[] = { 6257, 6258, 6259, 6260, 6261, 9250, 6262, 6263, 6264, 6265 };
-
-      if( !isRelicEquipped( relicItemIds, 0 ) )
-        eventData.second.iconId = quest.iconInvalid;
-
-      break;
-    }
-
-    case 66972: // Quest: Trials of the Braves
-    {
-      uint32_t relicItemIds[] = { 7824, 7825, 7826, 7827, 7828, 9251, 7829, 7830, 7831, 7832 };
-
-      if( !isRelicEquipped( relicItemIds, 7833 ) )
-        eventData.second.iconId = quest.iconInvalid;
-
-      break;
-    }
-
-    case 66998: // Quest: Celestial Radiance
-    case 67000: // Quest: Star Light, Star Bright
-    {
-      uint32_t relicItemIds[] = { 7834, 7835, 7836, 7837, 7838, 9252, 7839, 7840, 7841, 7842 };
-
-      if( !isRelicEquipped( relicItemIds, 7843 ) )
-        eventData.second.iconId = quest.iconInvalid;
-
-      break;
-    }
-
-    case 67823: // Quest: The Vital Title
-    {
-      uint32_t relicItemIds[] = { 12124, 12133, 12142, 12151, 12160, 12169, 12178, 12187, 12196 };
-
-      if( !isRelicEquipped( relicItemIds, 12213 ) )
-        eventData.second.iconId = quest.iconInvalid;
-
-      break;
-    }
-  }
     
-  if( eventData.first >= 67001 && eventData.first <= 67003 ) // Quest: Call of the Wild
-  {
-    // Quests in the following order: Martial Perfection / Feathers and Folly / Like Clutchfather, Like Son / Revenge of the Furred / Spread Your Wings and Soar
-    if( !player.isQuestCompleted( 1221 ) || !player.isQuestCompleted( 1256 ) || !player.isQuestCompleted( 1378 ) || !player.isQuestCompleted( 1324 ) || !player.isQuestCompleted( 1493 ) )
-      return false;
-  }
-  else if( eventData.first == 67918 ) // Quest: When Good Dragons Go Bad
-  {
-    // Quests in the following order: The Nest of Honor / A Symbiotic Friendship / The Zenith of Craftsmanship / Heavensward
-    if( !player.isQuestCompleted( 2225 ) || !player.isQuestCompleted( 2260 ) || !player.isQuestCompleted( 2327 ) || !player.isQuestCompleted( 1669 ) )
-      return false;
-  }
-
-  if( eventData.first >= 66968 && eventData.first <= 66970 ) // Quest: An Ill-conceived Venture
+  if( questPtr->isHouseRequired )
     return false;
 
-  if( quest.isHouseRequired )
+  if( questPtr->deliveryQuest )
     return false;
 
-  if( quest.deliveryQuest )
-    return false;
-
-  if( eventData.first == 67114 ) // Quest: The Ties That Bind
-    return false;
-
-  if( eventData.first == 66112 ) // Quest: Like Sire Like Fledgling
+  if( player.getQuestSeq( questId ) == 0 )
   {
-    if( !( player.getHowToArray()[ 198 / 8 ] & ( 1 << ( 198 % 8 ) ) ) )
-      return false;
-  }
-
-  if( player.getQuestSeq( eventData.first ) == 0 )
-  {
-    auto questAccept = exdData.get< Data::QuestAcceptAdditionCondition >( eventData.first );
+    auto questAccept = exdData.get< Data::QuestAcceptAdditionCondition >( questId );
 
     if( questAccept )
     {
@@ -762,17 +563,13 @@ bool Sapphire::World::Manager::MapMgr::isQuestAvailable( Entity::Player& player,
     }
   }
 
-  // Quests in the following order: Open and Inviting / The Adventurer with All the Cards
-  if( eventData.first == 69566 || eventData.first == 69617 )
-    return false;
-
   return true;
 }
 
-bool Sapphire::World::Manager::MapMgr::isTripleTriadAvailable( Entity::Player& player, std::pair< const uint32_t, EventData >& eventData )
+bool Sapphire::World::Manager::MapMgr::isTripleTriadAvailable( Entity::Player& player, uint32_t tripleTriadId )
 {
   auto& exdData = Common::Service< Data::ExdDataGenerated >::ref();
-  auto tripleTriad = exdData.get< Data::TripleTriad >( eventData.first );
+  auto tripleTriad = exdData.get< Data::TripleTriad >( tripleTriadId );
 
   if( tripleTriad->previousQuestJoin == 1 )
   {
@@ -803,20 +600,20 @@ bool Sapphire::World::Manager::MapMgr::isTripleTriadAvailable( Entity::Player& p
   return true;
 }
 
-void Sapphire::World::Manager::MapMgr::fillPacket( std::multimap< uint32_t, EventData, less >& mapData, uint32_t* iconIds, uint32_t* levelIds, uint32_t* eventIds )
+void Sapphire::World::Manager::MapMgr::fillPacket( EventSet& mapData, uint32_t* iconIds, uint32_t* levelIds, uint32_t* eventIds )
 {
   int32_t i = 0;
   for( auto& eventData : mapData )
   {
-    iconIds[ i ] = eventData.second.iconId;
-    levelIds[ i ] = eventData.second.levelId;
-    eventIds[ i ] = eventData.first;
+    iconIds[ i ] = eventData.iconId;
+    levelIds[ i ] = eventData.levelId;
+    eventIds[ i ] = eventData.eventId;
 
     i++;
   }
 }
 
-void Sapphire::World::Manager::MapMgr::sendPackets( Entity::Player& player, std::multimap< uint32_t, EventData, less >& mapData, UpdateMode updateMode )
+void Sapphire::World::Manager::MapMgr::sendPackets( Entity::Player& player, EventSet& mapData, UpdateMode updateMode )
 {
   player.queuePacket( makeActorControlSelf( player.getId(), Network::ActorControl::BeginMapUpdate, updateMode ) );
 
diff --git a/src/world/Manager/MapMgr.h b/src/world/Manager/MapMgr.h
index 92e4eb8f..949ca699 100644
--- a/src/world/Manager/MapMgr.h
+++ b/src/world/Manager/MapMgr.h
@@ -3,12 +3,14 @@
 
 #include "ForwardsZone.h"
 
-#include <bitset>
-#include <map>
+#include <set>
+#include <unordered_map>
 
 namespace Sapphire::World::Manager
 {
 
+  using QuestMap = std::unordered_map< uint32_t, Data::ExdDataGenerated::QuestPtr >;
+
   class MapMgr
   {
   public:
@@ -34,81 +36,20 @@ namespace Sapphire::World::Manager
     {
       uint32_t iconId;
       uint32_t levelId;
-      uint32_t actorId;
-    };
-
-    struct QuestData
-    {
-      uint8_t previousQuestJoin; // 1 = requires all previous quest, 2 = requires any previous quest
-      uint32_t previousQuestKeys[3];
-      uint8_t previousQuest0Sequence;
-
-      uint8_t questLockJoin; // 1 = only locks when all previous quests are done, 2 = locks when any previous quest is done
-      uint32_t questLockKeys[2];
-
-      struct
-      {
-        std::bitset< Common::CLASSJOB_TOTAL + 1 > classJobCategoryMask;
-        uint16_t classJobLevel;
-      } classJobRequirements[2];
-
-      uint8_t classJobUnlockFlag;
-      uint8_t classJobUnlock;
-
-      uint8_t requiredGC;
-      uint8_t requiredGCRank;
-
-      uint8_t startTown;
-
-      uint16_t header;
-
-      uint8_t instanceContentJoin; // 1 = requires all needed instances to be completed, 2 = requires any needed instance to be completed
-      uint32_t instanceContent[3];
-
-      uint8_t festival;
-      uint8_t festivalBegin;
-      uint8_t festivalEnd;
-      uint16_t bellStart;
-      uint16_t bellEnd;
-
-      uint8_t repeatIntervalType;
-      uint8_t questRepeatFlag;
-
-      uint8_t beastTribe;
-      uint8_t beastReputationRank;
-      uint16_t beastReputationValue;
-
-      int32_t mount;
-
-      uint8_t satisfactionNpc;
-      uint8_t satisfactionRank;
-
-      uint32_t issuer;
-
-      uint8_t deliveryQuest;
-
-      uint8_t expansion;
-
-      uint8_t type;
-
-      bool isRepeatable;
-      bool isHouseRequired;
-
-      uint32_t iconValid;
-      uint32_t iconInvalid;
+      uint32_t eventId;
     };
 
     struct less
     {
-      constexpr bool operator()( const uint32_t& _Left, const uint32_t& _Right ) const
+      constexpr bool operator()( const EventData& _Left, const EventData& _Right ) const
       {
-        const uint16_t left = _Left;
-        const uint16_t right = _Right;
+        const uint16_t left = _Left.eventId;
+        const uint16_t right = _Right.eventId;
 
         if( left == right )
         {
-          const uint16_t typeLeft = _Left >> 16;
-          const uint16_t typeRight = _Right >> 16;
+          const uint16_t typeLeft = _Left.eventId >> 16;
+          const uint16_t typeRight = _Right.eventId >> 16;
 
           return typeLeft < typeRight;
         }
@@ -117,14 +58,18 @@ namespace Sapphire::World::Manager
       }
     };
 
-    std::map< uint16_t, std::multimap< uint32_t, EventData, less > > m_mapData;
-    std::map< uint32_t, QuestData > m_questData;
+    using EventSet = std::multiset< EventData, less >;
 
-    bool isQuestAvailable( Entity::Player& player, std::pair< const uint32_t, EventData >& eventData );
-    bool isTripleTriadAvailable( Entity::Player& player, std::pair< const uint32_t, EventData >& eventData );
+    QuestMap m_quests;
 
-    void fillPacket( std::multimap< uint32_t, EventData, less >& mapData, uint32_t* iconIds, uint32_t* levelIds, uint32_t* eventIds );
-    void sendPackets( Entity::Player& player, std::multimap< uint32_t, EventData, less >& mapData, UpdateMode updateMode );
+    void insertQuest( Entity::Player& player, uint32_t questId, EventSet& mapData );
+
+    bool isQuestVisible( Entity::Player& player, uint32_t questId, Data::ExdDataGenerated::QuestPtr questPtr );
+    bool isQuestAvailable( Entity::Player& player, uint32_t questId, Data::ExdDataGenerated::QuestPtr questPtr );
+    bool isTripleTriadAvailable( Entity::Player& player, uint32_t tripleTriadId );
+
+    void fillPacket( EventSet& mapData, uint32_t* iconIds, uint32_t* levelIds, uint32_t* eventIds );
+    void sendPackets( Entity::Player& player, EventSet& mapData, UpdateMode updateMode );
   };
 
 }
diff --git a/src/world/Script/NativeScriptApi.cpp b/src/world/Script/NativeScriptApi.cpp
index 5238af65..de8dbf22 100644
--- a/src/world/Script/NativeScriptApi.cpp
+++ b/src/world/Script/NativeScriptApi.cpp
@@ -1,7 +1,6 @@
 #include <string>
 #include <typeinfo>
 #include <typeindex>
-#include <Event/EventHandler.h>
 #include "NativeScriptApi.h"
 #include <cassert>
 
@@ -138,6 +137,11 @@ namespace Sapphire::ScriptAPI
   {
   }
 
+  Event::EventHandler::EventState EventScript::checkExtraConditions( Sapphire::Entity::Player& player, uint32_t eventId )
+  {
+    return Event::EventHandler::EventState::Available;
+  }
+
   ///////////////////////////////////////////////////////////////////
 
   EventObjectScript::EventObjectScript( uint32_t eobjId ) :
diff --git a/src/world/Script/NativeScriptApi.h b/src/world/Script/NativeScriptApi.h
index f1ea4ba7..6d07c617 100644
--- a/src/world/Script/NativeScriptApi.h
+++ b/src/world/Script/NativeScriptApi.h
@@ -2,6 +2,7 @@
 #define NATIVE_SCRIPT_API
 
 #include <string>
+#include <Event/EventHandler.h>
 #include "ForwardsZone.h"
 
 #ifdef _MSC_VER
@@ -168,6 +169,8 @@ namespace Sapphire::ScriptAPI
     virtual void onEObjHit( Sapphire::Entity::Player& player, uint64_t actorId, uint32_t actionId );
 
     virtual void onEventYield( Sapphire::Entity::Player& player, uint16_t scene, std::vector< uint32_t > param );
+
+    virtual Event::EventHandler::EventState checkExtraConditions( Sapphire::Entity::Player& player, uint32_t eventId );
   };
 
   /*!
diff --git a/src/world/ServerMgr.cpp b/src/world/ServerMgr.cpp
index 4033f7c2..c600b0d6 100644
--- a/src/world/ServerMgr.cpp
+++ b/src/world/ServerMgr.cpp
@@ -174,7 +174,7 @@ void Sapphire::World::ServerMgr::run( int32_t argc, char* argv[] )
   auto pInstanceObjCache = std::make_shared< Sapphire::InstanceObjectCache >();
   Common::Service< Sapphire::InstanceObjectCache >::set( pInstanceObjCache );
 
-  Logger::info( "MapMgr: Caching map data" );
+  Logger::info( "MapMgr: Caching quests" );
   auto pMapMgr = std::make_shared< Manager::MapMgr >();
   Common::Service< Manager::MapMgr >::set( pMapMgr );
 
diff --git a/src/world/Territory/InstanceObjectCache.cpp b/src/world/Territory/InstanceObjectCache.cpp
index 202d6010..d117df96 100644
--- a/src/world/Territory/InstanceObjectCache.cpp
+++ b/src/world/Territory/InstanceObjectCache.cpp
@@ -41,16 +41,23 @@ Sapphire::InstanceObjectCache::InstanceObjectCache()
     // TODO: it does feel like this needs to be streamlined into the datReader instead of being done here...
     std::string bgLgbPath( path + "/level/bg.lgb" );
     std::string planmapLgbPath( path + "/level/planmap.lgb" );
+    std::string planeventLgbPath( path + "/level/planevent.lgb" );
+    std::string plannerLgbPath( path + "/level/planner.lgb" );
     std::vector< char > bgSection;
     std::vector< char > planmapSection;
+    std::vector< char > planeventSection;
+    std::vector< char > plannerSection;
 
     std::unique_ptr< xiv::dat::File > bgFile;
     std::unique_ptr< xiv::dat::File > planmap_file;
+    std::unique_ptr< xiv::dat::File > planevent_file;
+    std::unique_ptr< xiv::dat::File > planner_file;
 
     try
     {
       bgFile = exdData.getGameData()->getFile( bgLgbPath );
       planmap_file = exdData.getGameData()->getFile( planmapLgbPath );
+      planevent_file = exdData.getGameData()->getFile( planeventLgbPath );
     }
     catch( std::runtime_error& )
     {
@@ -60,6 +67,7 @@ Sapphire::InstanceObjectCache::InstanceObjectCache()
 
     bgSection = bgFile->access_data_sections().at( 0 );
     planmapSection = planmap_file->access_data_sections().at( 0 );
+    planeventSection = planevent_file->access_data_sections().at( 0 );
 
     std::vector< std::string > stringList;
 
@@ -67,8 +75,23 @@ Sapphire::InstanceObjectCache::InstanceObjectCache()
 
     LGB_FILE bgLgb( &bgSection[ 0 ], "bg" );
     LGB_FILE planmapLgb( &planmapSection[ 0 ], "planmap" );
+    LGB_FILE planeventLgb( &planeventSection[ 0 ], "planevent" );
+
+    std::vector< LGB_FILE > lgbList;
+
+    try
+    {      
+      planner_file = exdData.getGameData()->getFile( plannerLgbPath );
+      plannerSection = planner_file->access_data_sections().at( 0 );
+      LGB_FILE plannerLgb( &plannerSection[ 0 ], "planner" );
+
+      lgbList = { bgLgb, planmapLgb, planeventLgb, plannerLgb };
+    }
+    catch( std::runtime_error& )
+    {
+      lgbList = { bgLgb, planmapLgb, planeventLgb };
+    }
 
-    std::vector< LGB_FILE > lgbList{ bgLgb, planmapLgb };
     uint32_t max_index = 0;
 
     for( const auto& lgb : lgbList )
@@ -92,6 +115,16 @@ Sapphire::InstanceObjectCache::InstanceObjectCache()
             auto pPopRange = std::reinterpret_pointer_cast< LGB_POP_RANGE_ENTRY >( pEntry );
             m_popRangeCache.insert( id, pPopRange );
           }
+          else if( pEntry->getType() == LgbEntryType::EventNpc )
+          {
+            auto pEventNpc = std::reinterpret_pointer_cast< LGB_ENPC_ENTRY >( pEntry );
+            m_eventNpcCache.insert( id, pEventNpc );
+          }
+          else if( pEntry->getType() == LgbEntryType::EventObject )
+          {
+            auto pEventObj = std::reinterpret_pointer_cast< LGB_EOBJ_ENTRY >( pEntry );
+            m_eventObjCache.insert( id, pEventObj );
+          }
         }
       }
     }
@@ -99,8 +132,8 @@ Sapphire::InstanceObjectCache::InstanceObjectCache()
   std::cout << "\n";
 
   Logger::debug(
-    "InstanceObjectCache Cached: MapRange: {} ExitRange: {} PopRange: {}",
-    m_mapRangeCache.size(), m_exitRangeCache.size(), m_popRangeCache.size()
+    "InstanceObjectCache Cached: MapRange: {} ExitRange: {} PopRange: {} ENpc: {} Eobj: {}",
+    m_mapRangeCache.size(), m_exitRangeCache.size(), m_popRangeCache.size(), m_eventNpcCache.size(), m_eventObjCache.size()
   );
 }
 
@@ -121,4 +154,28 @@ Sapphire::InstanceObjectCache::PopRangePtr
   Sapphire::InstanceObjectCache::getPopRange( uint16_t zoneId, uint32_t popRangeId )
 {
   return m_popRangeCache.get( zoneId, popRangeId );
+}
+
+Sapphire::InstanceObjectCache::EventNpcPtr
+  Sapphire::InstanceObjectCache::getEventNpc( uint16_t zoneId, uint32_t eventNpcId )
+{
+  return m_eventNpcCache.get( zoneId, eventNpcId );
+}
+
+Sapphire::InstanceObjectCache::EventObjPtr
+  Sapphire::InstanceObjectCache::getEventObj( uint16_t zoneId, uint32_t eventObjId )
+{
+  return m_eventObjCache.get( zoneId, eventObjId );
+}
+
+Sapphire::InstanceObjectCache::EventNpcMapPtr
+  Sapphire::InstanceObjectCache::getAllEventNpc( uint16_t zoneId )
+{
+  return m_eventNpcCache.getAll( zoneId );
+}
+
+Sapphire::InstanceObjectCache::EventObjMapPtr
+  Sapphire::InstanceObjectCache::getAllEventObj( uint16_t zoneId )
+{
+  return m_eventObjCache.getAll( zoneId );
 }
\ No newline at end of file
diff --git a/src/world/Territory/InstanceObjectCache.h b/src/world/Territory/InstanceObjectCache.h
index efb448c4..7f8bd17c 100644
--- a/src/world/Territory/InstanceObjectCache.h
+++ b/src/world/Territory/InstanceObjectCache.h
@@ -7,6 +7,8 @@
 struct LGB_MAP_RANGE_ENTRY;
 struct LGB_EXIT_RANGE_ENTRY;
 struct LGB_POP_RANGE_ENTRY;
+struct LGB_ENPC_ENTRY;
+struct LGB_EOBJ_ENTRY;
 
 
 namespace Sapphire
@@ -37,6 +39,16 @@ namespace Sapphire
       }
       return nullptr;
     }
+    
+    ObjectMap* getAll( uint16_t zoneId )
+    {
+      auto it = m_objectCache.find( zoneId );
+      if( it != m_objectCache.end() )
+      {
+        return &it->second;
+      }
+      return nullptr;
+    }
 
     void insert( uint16_t zoneId, std::shared_ptr< T > entry )
     {
@@ -65,6 +77,11 @@ namespace Sapphire
     using MapRangePtr = std::shared_ptr< LGB_MAP_RANGE_ENTRY >;
     using ExitRangePtr = std::shared_ptr< LGB_EXIT_RANGE_ENTRY >;
     using PopRangePtr = std::shared_ptr< LGB_POP_RANGE_ENTRY >;
+    using EventNpcPtr = std::shared_ptr< LGB_ENPC_ENTRY >;
+    using EventObjPtr = std::shared_ptr< LGB_EOBJ_ENTRY >;
+
+    using EventNpcMapPtr = std::unordered_map< uint32_t, EventNpcPtr >*;
+    using EventObjMapPtr = std::unordered_map< uint32_t, EventObjPtr >*;
 
     InstanceObjectCache();
     ~InstanceObjectCache() = default;
@@ -72,11 +89,18 @@ namespace Sapphire
     MapRangePtr getMapRange( uint16_t zoneId, uint32_t mapRangeId );
     ExitRangePtr getExitRange( uint16_t zoneId, uint32_t exitRangeId );
     PopRangePtr getPopRange( uint16_t zoneId, uint32_t popRangeId );
+    EventNpcPtr getEventNpc( uint16_t zoneId, uint32_t eventNpcId );
+    EventObjPtr getEventObj( uint16_t zoneId, uint32_t eventObjId );
+        
+    EventNpcMapPtr getAllEventNpc( uint16_t zoneId );
+    EventObjMapPtr getAllEventObj( uint16_t zoneId );
 
   private:
     ObjectCache< LGB_MAP_RANGE_ENTRY > m_mapRangeCache;
     ObjectCache< LGB_EXIT_RANGE_ENTRY > m_exitRangeCache;
     ObjectCache< LGB_POP_RANGE_ENTRY > m_popRangeCache;
+    ObjectCache< LGB_ENPC_ENTRY > m_eventNpcCache;
+    ObjectCache< LGB_EOBJ_ENTRY > m_eventObjCache;
     std::shared_ptr< Framework > m_pFramework;
 
   };