feat(Core/Modules): add separated lib for modules (#9281)

1 files changed, 457 insertions, 288 deletions

diff --git a/src/server/game/Scripting/ScriptMgr.cpp b/src/server/game/Scripting/ScriptMgr.cpp
index 1ff0d7c3fe..ceb73d5503 100644
--- a/src/server/game/Scripting/ScriptMgr.cpp
+++ b/src/server/game/Scripting/ScriptMgr.cpp
@@ -35,11 +35,6 @@
 #include "Vehicle.h"
 #include "WorldPacket.h"
 
-#ifdef ELUNA
-#include "ElunaUtility.h"
-#include "LuaEngine.h"
-#endif
-
 struct TSpellSummary
 {
     uint8 Targets; // set of enum SelectTarget
@@ -49,7 +44,10 @@ struct TSpellSummary
 #include "ScriptMgrMacros.h"
 
 ScriptMgr::ScriptMgr()
-    : _scriptCount(0), _scheduledScripts(0), _script_loader_callback(nullptr) { }
+    : _scriptCount(0),
+    _scheduledScripts(0),
+    _script_loader_callback(nullptr),
+    _modules_loader_callback(nullptr) { }
 
 ScriptMgr::~ScriptMgr() { }
 
@@ -69,7 +67,11 @@ void ScriptMgr::Initialize()
     ASSERT(_script_loader_callback,
         "Script loader callback wasn't registered!");
 
+    ASSERT(_modules_loader_callback,
+        "Modules loader callback wasn't registered!");
+
     _script_loader_callback();
+    _modules_loader_callback();
 }
 
 void ScriptMgr::Unload()
@@ -373,31 +375,40 @@ void ScriptMgr::OnSocketClose(std::shared_ptr<WorldSocket> socket)
     FOREACH_SCRIPT(ServerScript)->OnSocketClose(socket);
 }
 
-void ScriptMgr::OnPacketReceive(WorldSession* session, WorldPacket const& packet)
+bool ScriptMgr::CanPacketReceive(WorldSession* session, WorldPacket const& packet)
 {
     if (SCR_REG_LST(ServerScript).empty())
-        return;
+        return true;
 
     WorldPacket copy(packet);
-    FOREACH_SCRIPT(ServerScript)->OnPacketReceive(session, copy);
+
+    bool ret = true;
+    FOR_SCRIPTS_RET(ServerScript, itr, end, ret) // return true by default if not scripts
+        if (!itr->second->CanPacketReceive(session, copy))
+            ret = false; // we change ret value only when scripts return false
+
+    return ret;
 }
 
-void ScriptMgr::OnPacketSend(WorldSession* session, WorldPacket const& packet)
+bool ScriptMgr::CanPacketSend(WorldSession* session, WorldPacket const& packet)
 {
     ASSERT(session);
 
     if (SCR_REG_LST(ServerScript).empty())
-        return;
+        return true;
 
     WorldPacket copy(packet);
-    FOREACH_SCRIPT(ServerScript)->OnPacketSend(session, copy);
+
+    bool ret = true;
+    FOR_SCRIPTS_RET(ServerScript, itr, end, ret) // return true by default if not scripts
+        if (!itr->second->CanPacketSend(session, copy))
+            ret = false; // we change ret value only when scripts return false
+
+    return ret;
 }
 
 void ScriptMgr::OnOpenStateChange(bool open)
 {
-#ifdef ELUNA
-    sEluna->OnOpenStateChange(open);
-#endif
     FOREACH_SCRIPT(WorldScript)->OnOpenStateChange(open);
 }
 
@@ -408,17 +419,11 @@ void ScriptMgr::OnLoadCustomDatabaseTable()
 
 void ScriptMgr::OnBeforeConfigLoad(bool reload)
 {
-#ifdef ELUNA
-    sEluna->OnConfigLoad(reload, true);
-#endif
     FOREACH_SCRIPT(WorldScript)->OnBeforeConfigLoad(reload);
 }
 
 void ScriptMgr::OnAfterConfigLoad(bool reload)
 {
-#ifdef ELUNA
-    sEluna->OnConfigLoad(reload, false);
-#endif
     FOREACH_SCRIPT(WorldScript)->OnAfterConfigLoad(reload);
 }
 
@@ -434,25 +439,16 @@ void ScriptMgr::OnMotdChange(std::string& newMotd)
 
 void ScriptMgr::OnShutdownInitiate(ShutdownExitCode code, ShutdownMask mask)
 {
-#ifdef ELUNA
-    sEluna->OnShutdownInitiate(code, mask);
-#endif
     FOREACH_SCRIPT(WorldScript)->OnShutdownInitiate(code, mask);
 }
 
 void ScriptMgr::OnShutdownCancel()
 {
-#ifdef ELUNA
-    sEluna->OnShutdownCancel();
-#endif
     FOREACH_SCRIPT(WorldScript)->OnShutdownCancel();
 }
 
 void ScriptMgr::OnWorldUpdate(uint32 diff)
 {
-#ifdef ELUNA
-    sEluna->OnWorldUpdate(diff);
-#endif
     FOREACH_SCRIPT(WorldScript)->OnUpdate(diff);
 }
 
@@ -514,9 +510,7 @@ void ScriptMgr::OnCreateMap(Map* map)
 {
     ASSERT(map);
 
-#ifdef ELUNA
-    sEluna->OnCreate(map);
-#endif
+    FOREACH_SCRIPT(AllMapScript)->OnCreateMap(map);
 
     SCR_MAP_BGN(WorldMapScript, map, itr, end, entry, IsWorldMap);
     itr->second->OnCreate(map);
@@ -535,9 +529,7 @@ void ScriptMgr::OnDestroyMap(Map* map)
 {
     ASSERT(map);
 
-#ifdef ELUNA
-    sEluna->OnDestroy(map);
-#endif
+    FOREACH_SCRIPT(AllMapScript)->OnDestroyMap(map);
 
     SCR_MAP_BGN(WorldMapScript, map, itr, end, entry, IsWorldMap);
     itr->second->OnDestroy(map);
@@ -593,11 +585,6 @@ void ScriptMgr::OnPlayerEnterMap(Map* map, Player* player)
     ASSERT(map);
     ASSERT(player);
 
-#ifdef ELUNA
-    sEluna->OnMapChanged(player);
-    sEluna->OnPlayerEnter(map, player);
-#endif
-
     FOREACH_SCRIPT(AllMapScript)->OnPlayerEnterAll(map, player);
 
     FOREACH_SCRIPT(PlayerScript)->OnMapChanged(player);
@@ -620,10 +607,6 @@ void ScriptMgr::OnPlayerLeaveMap(Map* map, Player* player)
     ASSERT(map);
     ASSERT(player);
 
-#ifdef ELUNA
-    sEluna->OnPlayerLeave(map, player);
-#endif
-
     FOREACH_SCRIPT(AllMapScript)->OnPlayerLeaveAll(map, player);
 
     SCR_MAP_BGN(WorldMapScript, map, itr, end, entry, IsWorldMap);
@@ -643,9 +626,7 @@ void ScriptMgr::OnMapUpdate(Map* map, uint32 diff)
 {
     ASSERT(map);
 
-#ifdef ELUNA
-    sEluna->OnUpdate(map, diff);
-#endif
+    FOREACH_SCRIPT(AllMapScript)->OnMapUpdate(map, diff);
 
     SCR_MAP_BGN(WorldMapScript, map, itr, end, entry, IsWorldMap);
     itr->second->OnUpdate(map, diff);
@@ -677,10 +658,15 @@ bool ScriptMgr::OnQuestAccept(Player* player, Item* item, Quest const* quest)
     ASSERT(item);
     ASSERT(quest);
 
-#ifdef ELUNA
-    if (sEluna->OnQuestAccept(player, item, quest))
+    bool ret = true;
+    FOR_SCRIPTS_RET(AllItemScript, itr, end, ret) // return true by default if not scripts
+        if (!itr->second->CanItemQuestAccept(player, item, quest))
+            ret = false; // we change ret value only when scripts return false
+
+    if (!ret)
+    {
         return false;
-#endif
+    }
 
     GET_SCRIPT_RET(ItemScript, item->GetScriptId(), tmpscript, false);
     ClearGossipMenuFor(player);
@@ -692,10 +678,15 @@ bool ScriptMgr::OnItemUse(Player* player, Item* item, SpellCastTargets const& ta
     ASSERT(player);
     ASSERT(item);
 
-#ifdef ELUNA
-    if (!sEluna->OnUse(player, item, targets))
+    bool ret = false;
+    FOR_SCRIPTS_RET(AllItemScript, itr, end, ret) // return true by default if not scripts
+        if (itr->second->CanItemUse(player, item, targets))
+            ret = true; // we change ret value only when scripts return false
+
+    if (ret)
+    {
         return true;
-#endif
+    }
 
     GET_SCRIPT_RET(ItemScript, item->GetScriptId(), tmpscript, false);
     return tmpscript->OnUse(player, item, targets);
@@ -706,10 +697,15 @@ bool ScriptMgr::OnItemExpire(Player* player, ItemTemplate const* proto)
     ASSERT(player);
     ASSERT(proto);
 
-#ifdef ELUNA
-    if (sEluna->OnExpire(player, proto))
+    bool ret = true;
+    FOR_SCRIPTS_RET(AllItemScript, itr, end, ret) // return true by default if not scripts
+        if (!itr->second->CanItemExpire(player, proto))
+            ret = false; // we change ret value only when scripts return false
+
+    if (!ret)
+    {
         return false;
-#endif
+    }
 
     GET_SCRIPT_RET(ItemScript, proto->ScriptId, tmpscript, false);
     return tmpscript->OnExpire(player, proto);
@@ -719,10 +715,17 @@ bool ScriptMgr::OnItemRemove(Player* player, Item* item)
 {
     ASSERT(player);
     ASSERT(item);
-#ifdef ELUNA
-    if (sEluna->OnRemove(player, item))
+
+    bool ret = true;
+    FOR_SCRIPTS_RET(AllItemScript, itr, end, ret) // return true by default if not scripts
+        if (!itr->second->CanItemRemove(player, item))
+            ret = false; // we change ret value only when scripts return false
+
+    if (!ret)
+    {
         return false;
-#endif
+    }
+
     GET_SCRIPT_RET(ItemScript, item->GetScriptId(), tmpscript, false);
     return tmpscript->OnRemove(player, item);
 }
@@ -742,9 +745,9 @@ void ScriptMgr::OnGossipSelect(Player* player, Item* item, uint32 sender, uint32
 {
     ASSERT(player);
     ASSERT(item);
-#ifdef ELUNA
-    sEluna->HandleGossipSelectOption(player, item, sender, action, "");
-#endif
+
+    FOREACH_SCRIPT(AllItemScript)->OnItemGossipSelect(player, item, sender, action);
+
     GET_SCRIPT(ItemScript, item->GetScriptId(), tmpscript);
     tmpscript->OnGossipSelect(player, item, sender, action);
 }
@@ -753,26 +756,20 @@ void ScriptMgr::OnGossipSelectCode(Player* player, Item* item, uint32 sender, ui
 {
     ASSERT(player);
     ASSERT(item);
-#ifdef ELUNA
-    sEluna->HandleGossipSelectOption(player, item, sender, action, code);
-#endif
+
+    FOREACH_SCRIPT(AllItemScript)->OnItemGossipSelectCode(player, item, sender, action, code);
+
     GET_SCRIPT(ItemScript, item->GetScriptId(), tmpscript);
     tmpscript->OnGossipSelectCode(player, item, sender, action, code);
 }
 
 void ScriptMgr::OnGossipSelect(Player* player, uint32 menu_id, uint32 sender, uint32 action)
 {
-#ifdef ELUNA
-    sEluna->HandleGossipSelectOption(player, menu_id, sender, action, "");
-#endif
     FOREACH_SCRIPT(PlayerScript)->OnGossipSelect(player, menu_id, sender, action);
 }
 
 void ScriptMgr::OnGossipSelectCode(Player* player, uint32 menu_id, uint32 sender, uint32 action, const char* code)
 {
-#ifdef ELUNA
-    sEluna->HandleGossipSelectOption(player, menu_id, sender, action, code);
-#endif
     FOREACH_SCRIPT(PlayerScript)->OnGossipSelectCode(player, menu_id, sender, action, code);
 }
 
@@ -780,10 +777,17 @@ bool ScriptMgr::OnGossipHello(Player* player, Creature* creature)
 {
     ASSERT(player);
     ASSERT(creature);
-#ifdef ELUNA
-    if (sEluna->OnGossipHello(player, creature))
+
+    bool ret = false;
+    FOR_SCRIPTS_RET(AllCreatureScript, itr, end, ret) // return true by default if not scripts
+        if (itr->second->CanCreatureGossipHello(player, creature))
+            ret = true; // we change ret value only when scripts return false
+
+    if (ret)
+    {
         return true;
-#endif
+    }
+
     GET_SCRIPT_RET(CreatureScript, creature->GetScriptId(), tmpscript, false);
     ClearGossipMenuFor(player);
     return tmpscript->OnGossipHello(player, creature);
@@ -793,10 +797,17 @@ bool ScriptMgr::OnGossipSelect(Player* player, Creature* creature, uint32 sender
 {
     ASSERT(player);
     ASSERT(creature);
-#ifdef ELUNA
-    if (sEluna->OnGossipSelect(player, creature, sender, action))
+
+    bool ret = false;
+    FOR_SCRIPTS_RET(AllCreatureScript, itr, end, ret) // return true by default if not scripts
+        if (itr->second->CanCreatureGossipSelect(player, creature, sender, action))
+            ret = true; // we change ret value only when scripts return false
+
+    if (ret)
+    {
         return true;
-#endif
+    }
+
     GET_SCRIPT_RET(CreatureScript, creature->GetScriptId(), tmpscript, false);
     return tmpscript->OnGossipSelect(player, creature, sender, action);
 }
@@ -806,10 +817,17 @@ bool ScriptMgr::OnGossipSelectCode(Player* player, Creature* creature, uint32 se
     ASSERT(player);
     ASSERT(creature);
     ASSERT(code);
-#ifdef ELUNA
-    if (sEluna->OnGossipSelectCode(player, creature, sender, action, code))
+
+    bool ret = false;
+    FOR_SCRIPTS_RET(AllCreatureScript, itr, end, ret) // return true by default if not scripts
+        if (itr->second->CanCreatureGossipSelectCode(player, creature, sender, action, code))
+            ret = true; // we change ret value only when scripts return false
+
+    if (ret)
+    {
         return true;
-#endif
+    }
+
     GET_SCRIPT_RET(CreatureScript, creature->GetScriptId(), tmpscript, false);
     return tmpscript->OnGossipSelectCode(player, creature, sender, action, code);
 }
@@ -820,6 +838,16 @@ bool ScriptMgr::OnQuestAccept(Player* player, Creature* creature, Quest const* q
     ASSERT(creature);
     ASSERT(quest);
 
+    bool ret = false;
+    FOR_SCRIPTS_RET(AllCreatureScript, itr, end, ret) // return true by default if not scripts
+        if (itr->second->CanCreatureQuestAccept(player, creature, quest))
+            ret = true; // we change ret value only when scripts return false
+
+    if (ret)
+    {
+        return true;
+    }
+
     GET_SCRIPT_RET(CreatureScript, creature->GetScriptId(), tmpscript, false);
     ClearGossipMenuFor(player);
     return tmpscript->OnQuestAccept(player, creature, quest);
@@ -852,13 +880,17 @@ bool ScriptMgr::OnQuestReward(Player* player, Creature* creature, Quest const* q
     ASSERT(player);
     ASSERT(creature);
     ASSERT(quest);
-#ifdef ELUNA
-    if (sEluna->OnQuestReward(player, creature, quest, opt))
+
+    bool ret = false;
+    FOR_SCRIPTS_RET(AllCreatureScript, itr, end, ret) // return true by default if not scripts
+        if (itr->second->CanCreatureQuestReward(player, creature, quest, opt))
+            ret = true; // we change ret value only when scripts return false
+
+    if (ret)
     {
-        ClearGossipMenuFor(player);
-        return false;
+        return true;
     }
-#endif
+
     GET_SCRIPT_RET(CreatureScript, creature->GetScriptId(), tmpscript, false);
     ClearGossipMenuFor(player);
     return tmpscript->OnQuestReward(player, creature, quest, opt);
@@ -878,10 +910,14 @@ CreatureAI* ScriptMgr::GetCreatureAI(Creature* creature)
 {
     ASSERT(creature);
 
-#ifdef ELUNA
-    if (CreatureAI* luaAI = sEluna->GetAI(creature))
-        return luaAI;
-#endif
+    CreatureAI* ret = nullptr;
+    FOR_SCRIPTS_RET(AllCreatureScript, itr, end, ret) // return true by default if not scripts
+        ret = itr->second->GetCreatureAI(creature); // we change ret value only when scripts return false
+
+    if (ret)
+    {
+        return ret;
+    }
 
     GET_SCRIPT_RET(CreatureScript, creature->GetScriptId(), tmpscript, nullptr);
     return tmpscript->GetAI(creature);
@@ -897,16 +933,33 @@ void ScriptMgr::OnCreatureUpdate(Creature* creature, uint32 diff)
     tmpscript->OnUpdate(creature, diff);
 }
 
+void ScriptMgr::OnCreatureAddWorld(Creature* creature)
+{
+    ASSERT(creature);
+    FOREACH_SCRIPT(AllCreatureScript)->OnCreatureAddWorld(creature);
+}
+
+void ScriptMgr::OnCreatureRemoveWorld(Creature* creature)
+{
+    ASSERT(creature);
+    FOREACH_SCRIPT(AllCreatureScript)->OnCreatureRemoveWorld(creature);
+}
+
 bool ScriptMgr::OnGossipHello(Player* player, GameObject* go)
 {
     ASSERT(player);
     ASSERT(go);
-#ifdef ELUNA
-    if (sEluna->OnGossipHello(player, go))
-        return true;
-    if (sEluna->OnGameObjectUse(player, go))
+
+    bool ret = false;
+    FOR_SCRIPTS_RET(AllGameObjectScript, itr, end, ret)
+        if (itr->second->CanGameObjectGossipHello(player, go))
+            ret = true;
+
+    if (ret)
+    {
         return true;
-#endif
+    }
+
     GET_SCRIPT_RET(GameObjectScript, go->GetScriptId(), tmpscript, false);
     ClearGossipMenuFor(player);
     return tmpscript->OnGossipHello(player, go);
@@ -916,10 +969,17 @@ bool ScriptMgr::OnGossipSelect(Player* player, GameObject* go, uint32 sender, ui
 {
     ASSERT(player);
     ASSERT(go);
-#ifdef ELUNA
-    if (sEluna->OnGossipSelect(player, go, sender, action))
+
+    bool ret = false;
+    FOR_SCRIPTS_RET(AllGameObjectScript, itr, end, ret)
+        if (itr->second->CanGameObjectGossipSelect(player, go, sender, action))
+            ret = true;
+
+    if (ret)
+    {
         return true;
-#endif
+    }
+
     GET_SCRIPT_RET(GameObjectScript, go->GetScriptId(), tmpscript, false);
     return tmpscript->OnGossipSelect(player, go, sender, action);
 }
@@ -929,10 +989,17 @@ bool ScriptMgr::OnGossipSelectCode(Player* player, GameObject* go, uint32 sender
     ASSERT(player);
     ASSERT(go);
     ASSERT(code);
-#ifdef ELUNA
-    if (sEluna->OnGossipSelectCode(player, go, sender, action, code))
+
+    bool ret = false;
+    FOR_SCRIPTS_RET(AllGameObjectScript, itr, end, ret)
+        if (itr->second->CanGameObjectGossipSelectCode(player, go, sender, action, code))
+            ret = true;
+
+    if (ret)
+    {
         return true;
-#endif
+    }
+
     GET_SCRIPT_RET(GameObjectScript, go->GetScriptId(), tmpscript, false);
     return tmpscript->OnGossipSelectCode(player, go, sender, action, code);
 }
@@ -943,6 +1010,16 @@ bool ScriptMgr::OnQuestAccept(Player* player, GameObject* go, Quest const* quest
     ASSERT(go);
     ASSERT(quest);
 
+    bool ret = false;
+    FOR_SCRIPTS_RET(AllGameObjectScript, itr, end, ret)
+        if (itr->second->CanGameObjectQuestAccept(player, go, quest))
+            ret = true;
+
+    if (ret)
+    {
+        return true;
+    }
+
     GET_SCRIPT_RET(GameObjectScript, go->GetScriptId(), tmpscript, false);
     ClearGossipMenuFor(player);
     return tmpscript->OnQuestAccept(player, go, quest);
@@ -953,14 +1030,17 @@ bool ScriptMgr::OnQuestReward(Player* player, GameObject* go, Quest const* quest
     ASSERT(player);
     ASSERT(go);
     ASSERT(quest);
-#ifdef ELUNA
-    if (sEluna->OnQuestAccept(player, go, quest))
-        return false;
-#endif
-#ifdef ELUNA
-    if (sEluna->OnQuestReward(player, go, quest, opt))
-        return false;
-#endif
+
+    bool ret = false;
+    FOR_SCRIPTS_RET(AllGameObjectScript, itr, end, ret)
+        if (itr->second->CanGameObjectQuestReward(player, go, quest, opt))
+            ret = true;
+
+    if (ret)
+    {
+        return true;
+    }
+
     GET_SCRIPT_RET(GameObjectScript, go->GetScriptId(), tmpscript, false);
     ClearGossipMenuFor(player);
     return tmpscript->OnQuestReward(player, go, quest, opt);
@@ -980,6 +1060,8 @@ void ScriptMgr::OnGameObjectDestroyed(GameObject* go, Player* player)
 {
     ASSERT(go);
 
+    FOREACH_SCRIPT(AllGameObjectScript)->OnGameObjectDestroyed(go, player);
+
     GET_SCRIPT(GameObjectScript, go->GetScriptId(), tmpscript);
     tmpscript->OnDestroyed(go, player);
 }
@@ -988,6 +1070,8 @@ void ScriptMgr::OnGameObjectDamaged(GameObject* go, Player* player)
 {
     ASSERT(go);
 
+    FOREACH_SCRIPT(AllGameObjectScript)->OnGameObjectDamaged(go, player);
+
     GET_SCRIPT(GameObjectScript, go->GetScriptId(), tmpscript);
     tmpscript->OnDamaged(go, player);
 }
@@ -996,6 +1080,8 @@ void ScriptMgr::OnGameObjectLootStateChanged(GameObject* go, uint32 state, Unit*
 {
     ASSERT(go);
 
+    FOREACH_SCRIPT(AllGameObjectScript)->OnGameObjectLootStateChanged(go, state, unit);
+
     GET_SCRIPT(GameObjectScript, go->GetScriptId(), tmpscript);
     tmpscript->OnLootStateChanged(go, state, unit);
 }
@@ -1004,6 +1090,8 @@ void ScriptMgr::OnGameObjectStateChanged(GameObject* go, uint32 state)
 {
     ASSERT(go);
 
+    FOREACH_SCRIPT(AllGameObjectScript)->OnGameObjectStateChanged(go, state);
+
     GET_SCRIPT(GameObjectScript, go->GetScriptId(), tmpscript);
     tmpscript->OnGameObjectStateChanged(go, state);
 }
@@ -1012,9 +1100,7 @@ void ScriptMgr::OnGameObjectUpdate(GameObject* go, uint32 diff)
 {
     ASSERT(go);
 
-#ifdef ELUNA
-    sEluna->UpdateAI(go, diff);
-#endif
+    FOREACH_SCRIPT(AllGameObjectScript)->OnGameObjectUpdate(go, diff);
 
     GET_SCRIPT(GameObjectScript, go->GetScriptId(), tmpscript);
     tmpscript->OnUpdate(go, diff);
@@ -1024,22 +1110,46 @@ GameObjectAI* ScriptMgr::GetGameObjectAI(GameObject* go)
 {
     ASSERT(go);
 
-#ifdef ELUNA
-    sEluna->OnSpawn(go);
-#endif
+    GameObjectAI* ret = nullptr;
+    FOR_SCRIPTS_RET(AllGameObjectScript, itr, end, ret)
+        ret = itr->second->GetGameObjectAI(go);
+
+    if (ret)
+    {
+        return ret;
+    }
 
     GET_SCRIPT_RET(GameObjectScript, go->GetScriptId(), tmpscript, nullptr);
     return tmpscript->GetAI(go);
 }
 
+void ScriptMgr::OnGameObjectAddWorld(GameObject* go)
+{
+    ASSERT(go);
+    FOREACH_SCRIPT(AllGameObjectScript)->OnGameObjectAddWorld(go);
+}
+
+void ScriptMgr::OnGameObjectRemoveWorld(GameObject* go)
+{
+    ASSERT(go);
+    FOREACH_SCRIPT(AllGameObjectScript)->OnGameObjectRemoveWorld(go);
+}
+
 bool ScriptMgr::OnAreaTrigger(Player* player, AreaTrigger const* trigger)
 {
     ASSERT(player);
     ASSERT(trigger);
-#ifdef ELUNA
-    if (sEluna->OnAreaTrigger(player, trigger))
+
+    bool ret = true;
+    FOR_SCRIPTS_RET(ElunaScript, itr, end, ret) // return true by default if not scripts
+        if (!itr->second->CanAreaTrigger(player, trigger))
+            ret = false; // we change ret value only when scripts return false
+
+    if (!ret)
+    {
         return false;
-#endif
+    }
+
     GET_SCRIPT_RET(AreaTriggerScript, sObjectMgr->GetAreaTriggerScriptId(trigger->entry), tmpscript, false);
     return tmpscript->OnTrigger(player, trigger);
 }
@@ -1076,9 +1186,7 @@ void ScriptMgr::OnWeatherChange(Weather* weather, WeatherState state, float grad
 {
     ASSERT(weather);
 
-#ifdef ELUNA
-    sEluna->OnChange(weather, weather->GetZone(), state, grade);
-#endif
+    FOREACH_SCRIPT(ElunaScript)->OnWeatherChange(weather, state, grade);
 
     GET_SCRIPT(WeatherScript, weather->GetScriptId(), tmpscript);
     tmpscript->OnChange(weather, state, grade);
@@ -1097,10 +1205,6 @@ void ScriptMgr::OnAuctionAdd(AuctionHouseObject* ah, AuctionEntry* entry)
     ASSERT(ah);
     ASSERT(entry);
 
-#ifdef ELUNA
-    sEluna->OnAdd(ah, entry);
-#endif
-
     FOREACH_SCRIPT(AuctionHouseScript)->OnAuctionAdd(ah, entry);
 }
 
@@ -1109,10 +1213,6 @@ void ScriptMgr::OnAuctionRemove(AuctionHouseObject* ah, AuctionEntry* entry)
     ASSERT(ah);
     ASSERT(entry);
 
-#ifdef ELUNA
-    sEluna->OnRemove(ah, entry);
-#endif
-
     FOREACH_SCRIPT(AuctionHouseScript)->OnAuctionRemove(ah, entry);
 }
 
@@ -1121,10 +1221,6 @@ void ScriptMgr::OnAuctionSuccessful(AuctionHouseObject* ah, AuctionEntry* entry)
     ASSERT(ah);
     ASSERT(entry);
 
-#ifdef ELUNA
-    sEluna->OnSuccessful(ah, entry);
-#endif
-
     FOREACH_SCRIPT(AuctionHouseScript)->OnAuctionSuccessful(ah, entry);
 }
 
@@ -1133,10 +1229,6 @@ void ScriptMgr::OnAuctionExpire(AuctionHouseObject* ah, AuctionEntry* entry)
     ASSERT(ah);
     ASSERT(entry);
 
-#ifdef ELUNA
-    sEluna->OnExpire(ah, entry);
-#endif
-
     FOREACH_SCRIPT(AuctionHouseScript)->OnAuctionExpire(ah, entry);
 }
 
@@ -1188,10 +1280,6 @@ void ScriptMgr::OnInstall(Vehicle* veh)
     ASSERT(veh);
     ASSERT(veh->GetBase()->GetTypeId() == TYPEID_UNIT);
 
-#ifdef ELUNA
-    sEluna->OnInstall(veh);
-#endif
-
     GET_SCRIPT(VehicleScript, veh->GetBase()->ToCreature()->GetScriptId(), tmpscript);
     tmpscript->OnInstall(veh);
 }
@@ -1201,10 +1289,6 @@ void ScriptMgr::OnUninstall(Vehicle* veh)
     ASSERT(veh);
     ASSERT(veh->GetBase()->GetTypeId() == TYPEID_UNIT);
 
-#ifdef ELUNA
-    sEluna->OnUninstall(veh);
-#endif
-
     GET_SCRIPT(VehicleScript, veh->GetBase()->ToCreature()->GetScriptId(), tmpscript);
     tmpscript->OnUninstall(veh);
 }
@@ -1224,10 +1308,6 @@ void ScriptMgr::OnInstallAccessory(Vehicle* veh, Creature* accessory)
     ASSERT(veh->GetBase()->GetTypeId() == TYPEID_UNIT);
     ASSERT(accessory);
 
-#ifdef ELUNA
-    sEluna->OnInstallAccessory(veh, accessory);
-#endif
-
     GET_SCRIPT(VehicleScript, veh->GetBase()->ToCreature()->GetScriptId(), tmpscript);
     tmpscript->OnInstallAccessory(veh, accessory);
 }
@@ -1238,10 +1318,6 @@ void ScriptMgr::OnAddPassenger(Vehicle* veh, Unit* passenger, int8 seatId)
     ASSERT(veh->GetBase()->GetTypeId() == TYPEID_UNIT);
     ASSERT(passenger);
 
-#ifdef ELUNA
-    sEluna->OnAddPassenger(veh, passenger, seatId);
-#endif
-
     GET_SCRIPT(VehicleScript, veh->GetBase()->ToCreature()->GetScriptId(), tmpscript);
     tmpscript->OnAddPassenger(veh, passenger, seatId);
 }
@@ -1252,10 +1328,6 @@ void ScriptMgr::OnRemovePassenger(Vehicle* veh, Unit* passenger)
     ASSERT(veh->GetBase()->GetTypeId() == TYPEID_UNIT);
     ASSERT(passenger);
 
-#ifdef ELUNA
-    sEluna->OnRemovePassenger(veh, passenger);
-#endif
-
     GET_SCRIPT(VehicleScript, veh->GetBase()->ToCreature()->GetScriptId(), tmpscript);
     tmpscript->OnRemovePassenger(veh, passenger);
 }
@@ -1311,20 +1383,19 @@ void ScriptMgr::OnRelocate(Transport* transport, uint32 waypointId, uint32 mapId
 
 void ScriptMgr::OnStartup()
 {
-#ifdef ELUNA
-    sEluna->OnStartup();
-#endif
     FOREACH_SCRIPT(WorldScript)->OnStartup();
 }
 
 void ScriptMgr::OnShutdown()
 {
-#ifdef ELUNA
-    sEluna->OnShutdown();
-#endif
     FOREACH_SCRIPT(WorldScript)->OnShutdown();
 }
 
+void ScriptMgr::OnBeforeWorldInitialized()
+{
+    FOREACH_SCRIPT(WorldScript)->OnBeforeWorldInitialized();
+}
+
 bool ScriptMgr::OnCriteriaCheck(uint32 scriptId, Player* source, Unit* target, uint32 criteria_id)
 {
     ASSERT(source);
@@ -1357,9 +1428,6 @@ void ScriptMgr::OnPlayerReleasedGhost(Player* player)
 
 void ScriptMgr::OnPVPKill(Player* killer, Player* killed)
 {
-#ifdef ELUNA
-    sEluna->OnPVPKill(killer, killed);
-#endif
     FOREACH_SCRIPT(PlayerScript)->OnPVPKill(killer, killed);
 }
 
@@ -1370,9 +1438,6 @@ void ScriptMgr::OnPlayerPVPFlagChange(Player* player, bool state)
 
 void ScriptMgr::OnCreatureKill(Player* killer, Creature* killed)
 {
-#ifdef ELUNA
-    sEluna->OnCreatureKill(killer, killed);
-#endif
     FOREACH_SCRIPT(PlayerScript)->OnCreatureKill(killer, killed);
 }
 
@@ -1383,57 +1448,36 @@ void ScriptMgr::OnCreatureKilledByPet(Player* petOwner, Creature* killed)
 
 void ScriptMgr::OnPlayerKilledByCreature(Creature* killer, Player* killed)
 {
-#ifdef ELUNA
-    sEluna->OnPlayerKilledByCreature(killer, killed);
-#endif
     FOREACH_SCRIPT(PlayerScript)->OnPlayerKilledByCreature(killer, killed);
 }
 
 void ScriptMgr::OnPlayerLevelChanged(Player* player, uint8 oldLevel)
 {
-#ifdef ELUNA
-    sEluna->OnLevelChanged(player, oldLevel);
-#endif
     FOREACH_SCRIPT(PlayerScript)->OnLevelChanged(player, oldLevel);
 }
 
 void ScriptMgr::OnPlayerFreeTalentPointsChanged(Player* player, uint32 points)
 {
-#ifdef ELUNA
-    sEluna->OnFreeTalentPointsChanged(player, points);
-#endif
     FOREACH_SCRIPT(PlayerScript)->OnFreeTalentPointsChanged(player, points);
 }
 
 void ScriptMgr::OnPlayerTalentsReset(Player* player, bool noCost)
 {
-#ifdef ELUNA
-    sEluna->OnTalentsReset(player, noCost);
-#endif
     FOREACH_SCRIPT(PlayerScript)->OnTalentsReset(player, noCost);
 }
 
 void ScriptMgr::OnPlayerMoneyChanged(Player* player, int32& amount)
 {
-#ifdef ELUNA
-    sEluna->OnMoneyChanged(player, amount);
-#endif
     FOREACH_SCRIPT(PlayerScript)->OnMoneyChanged(player, amount);
 }
 
 void ScriptMgr::OnGivePlayerXP(Player* player, uint32& amount, Unit* victim)
 {
-#ifdef ELUNA
-    sEluna->OnGiveXP(player, amount, victim);
-#endif
     FOREACH_SCRIPT(PlayerScript)->OnGiveXP(player, amount, victim);
 }
 
 void ScriptMgr::OnPlayerReputationChange(Player* player, uint32 factionID, int32& standing, bool incremental)
 {
-#ifdef ELUNA
-    sEluna->OnReputationChange(player, factionID, standing, incremental);
-#endif
     FOREACH_SCRIPT(PlayerScript)->OnReputationChange(player, factionID, standing, incremental);
 }
 
@@ -1454,25 +1498,16 @@ void ScriptMgr::OnPlayerForgotSpell(Player* player, uint32 spellID)
 
 void ScriptMgr::OnPlayerDuelRequest(Player* target, Player* challenger)
 {
-#ifdef ELUNA
-    sEluna->OnDuelRequest(target, challenger);
-#endif
     FOREACH_SCRIPT(PlayerScript)->OnDuelRequest(target, challenger);
 }
 
 void ScriptMgr::OnPlayerDuelStart(Player* player1, Player* player2)
 {
-#ifdef ELUNA
-    sEluna->OnDuelStart(player1, player2);
-#endif
     FOREACH_SCRIPT(PlayerScript)->OnDuelStart(player1, player2);
 }
 
 void ScriptMgr::OnPlayerDuelEnd(Player* winner, Player* loser, DuelCompleteType type)
 {
-#ifdef ELUNA
-    sEluna->OnDuelEnd(winner, loser, type);
-#endif
     FOREACH_SCRIPT(PlayerScript)->OnDuelEnd(winner, loser, type);
 }
 
@@ -1508,25 +1543,16 @@ void ScriptMgr::OnPlayerChat(Player* player, uint32 type, uint32 lang, std::stri
 
 void ScriptMgr::OnPlayerEmote(Player* player, uint32 emote)
 {
-#ifdef ELUNA
-    sEluna->OnEmote(player, emote);
-#endif
     FOREACH_SCRIPT(PlayerScript)->OnEmote(player, emote);
 }
 
 void ScriptMgr::OnPlayerTextEmote(Player* player, uint32 textEmote, uint32 emoteNum, ObjectGuid guid)
 {
-#ifdef ELUNA
-    sEluna->OnTextEmote(player, textEmote, emoteNum, guid);
-#endif
     FOREACH_SCRIPT(PlayerScript)->OnTextEmote(player, textEmote, emoteNum, guid);
 }
 
 void ScriptMgr::OnPlayerSpellCast(Player* player, Spell* spell, bool skipCheck)
 {
-#ifdef ELUNA
-    sEluna->OnSpellCast(player, spell, skipCheck);
-#endif
     FOREACH_SCRIPT(PlayerScript)->OnSpellCast(player, spell, skipCheck);
 }
 
@@ -1542,9 +1568,6 @@ void ScriptMgr::OnPlayerUpdate(Player* player, uint32 p_time)
 
 void ScriptMgr::OnPlayerLogin(Player* player)
 {
-#ifdef ELUNA
-    sEluna->OnLogin(player);
-#endif
     FOREACH_SCRIPT(PlayerScript)->OnLogin(player);
 }
 
@@ -1555,33 +1578,21 @@ void ScriptMgr::OnPlayerLoadFromDB(Player* player)
 
 void ScriptMgr::OnPlayerLogout(Player* player)
 {
-#ifdef ELUNA
-    sEluna->OnLogout(player);
-#endif
     FOREACH_SCRIPT(PlayerScript)->OnLogout(player);
 }
 
 void ScriptMgr::OnPlayerCreate(Player* player)
 {
-#ifdef ELUNA
-    sEluna->OnCreate(player);
-#endif
     FOREACH_SCRIPT(PlayerScript)->OnCreate(player);
 }
 
 void ScriptMgr::OnPlayerSave(Player* player)
 {
-#ifdef ELUNA
-    sEluna->OnSave(player);
-#endif
     FOREACH_SCRIPT(PlayerScript)->OnSave(player);
 }
 
 void ScriptMgr::OnPlayerDelete(ObjectGuid guid, uint32 accountId)
 {
-#ifdef ELUNA
-    sEluna->OnDelete(guid.GetCounter());
-#endif
     FOREACH_SCRIPT(PlayerScript)->OnDelete(guid, accountId);
 }
 
@@ -1592,17 +1603,11 @@ void ScriptMgr::OnPlayerFailedDelete(ObjectGuid guid, uint32 accountId)
 
 void ScriptMgr::OnPlayerBindToInstance(Player* player, Difficulty difficulty, uint32 mapid, bool permanent)
 {
-#ifdef ELUNA
-    sEluna->OnBindToInstance(player, difficulty, mapid, permanent);
-#endif
     FOREACH_SCRIPT(PlayerScript)->OnBindToInstance(player, difficulty, mapid, permanent);
 }
 
 void ScriptMgr::OnPlayerUpdateZone(Player* player, uint32 newZone, uint32 newArea)
 {
-#ifdef ELUNA
-    sEluna->OnUpdateZone(player, newZone, newArea);
-#endif
     FOREACH_SCRIPT(PlayerScript)->OnUpdateZone(player, newZone, newArea);
 }
 
@@ -1745,9 +1750,6 @@ void ScriptMgr::OnQuestRewardItem(Player* player, Item* item, uint32 count)
 
 void ScriptMgr::OnFirstLogin(Player* player)
 {
-#ifdef ELUNA
-    sEluna->OnFirstLogin(player);
-#endif
     FOREACH_SCRIPT(PlayerScript)->OnFirstLogin(player);
 }
 
@@ -1832,90 +1834,57 @@ void ScriptMgr::OnFailedPasswordChange(uint32 accountId)
 // Guild
 void ScriptMgr::OnGuildAddMember(Guild* guild, Player* player, uint8& plRank)
 {
-#ifdef ELUNA
-    sEluna->OnAddMember(guild, player, plRank);
-#endif
     FOREACH_SCRIPT(GuildScript)->OnAddMember(guild, player, plRank);
 }
 
 void ScriptMgr::OnGuildRemoveMember(Guild* guild, Player* player, bool isDisbanding, bool isKicked)
 {
-#ifdef ELUNA
-    sEluna->OnRemoveMember(guild, player, isDisbanding);
-#endif
     FOREACH_SCRIPT(GuildScript)->OnRemoveMember(guild, player, isDisbanding, isKicked);
 }
 
 void ScriptMgr::OnGuildMOTDChanged(Guild* guild, const std::string& newMotd)
 {
-#ifdef ELUNA
-    sEluna->OnMOTDChanged(guild, newMotd);
-#endif
     FOREACH_SCRIPT(GuildScript)->OnMOTDChanged(guild, newMotd);
 }
 
 void ScriptMgr::OnGuildInfoChanged(Guild* guild, const std::string& newInfo)
 {
-#ifdef ELUNA
-    sEluna->OnInfoChanged(guild, newInfo);
-#endif
     FOREACH_SCRIPT(GuildScript)->OnInfoChanged(guild, newInfo);
 }
 
 void ScriptMgr::OnGuildCreate(Guild* guild, Player* leader, const std::string& name)
 {
-#ifdef ELUNA
-    sEluna->OnCreate(guild, leader, name);
-#endif
     FOREACH_SCRIPT(GuildScript)->OnCreate(guild, leader, name);
 }
 
 void ScriptMgr::OnGuildDisband(Guild* guild)
 {
-#ifdef ELUNA
-    sEluna->OnDisband(guild);
-#endif
     FOREACH_SCRIPT(GuildScript)->OnDisband(guild);
 }
 
 void ScriptMgr::OnGuildMemberWitdrawMoney(Guild* guild, Player* player, uint32& amount, bool isRepair)
 {
-#ifdef ELUNA
-    sEluna->OnMemberWitdrawMoney(guild, player, amount, isRepair);
-#endif
     FOREACH_SCRIPT(GuildScript)->OnMemberWitdrawMoney(guild, player, amount, isRepair);
 }
 
 void ScriptMgr::OnGuildMemberDepositMoney(Guild* guild, Player* player, uint32& amount)
 {
-#ifdef ELUNA
-    sEluna->OnMemberDepositMoney(guild, player, amount);
-#endif
     FOREACH_SCRIPT(GuildScript)->OnMemberDepositMoney(guild, player, amount);
 }
 
 void ScriptMgr::OnGuildItemMove(Guild* guild, Player* player, Item* pItem, bool isSrcBank, uint8 srcContainer, uint8 srcSlotId,
                                 bool isDestBank, uint8 destContainer, uint8 destSlotId)
 {
-#ifdef ELUNA
-    sEluna->OnItemMove(guild, player, pItem, isSrcBank, srcContainer, srcSlotId, isDestBank, destContainer, destSlotId);
-#endif
     FOREACH_SCRIPT(GuildScript)->OnItemMove(guild, player, pItem, isSrcBank, srcContainer, srcSlotId, isDestBank, destContainer, destSlotId);
 }
 
 void ScriptMgr::OnGuildEvent(Guild* guild, uint8 eventType, ObjectGuid::LowType playerGuid1, ObjectGuid::LowType playerGuid2, uint8 newRank)
 {
-#ifdef ELUNA
-    sEluna->OnEvent(guild, eventType, playerGuid1, playerGuid2, newRank);
-#endif
     FOREACH_SCRIPT(GuildScript)->OnEvent(guild, eventType, playerGuid1, playerGuid2, newRank);
 }
 
 void ScriptMgr::OnGuildBankEvent(Guild* guild, uint8 eventType, uint8 tabId, ObjectGuid::LowType playerGuid, uint32 itemOrMoney, uint16 itemStackCount, uint8 destTabId)
 {
-#ifdef ELUNA
-    sEluna->OnBankEvent(guild, eventType, tabId, playerGuid, itemOrMoney, itemStackCount, destTabId);
-#endif
     FOREACH_SCRIPT(GuildScript)->OnBankEvent(guild, eventType, tabId, playerGuid, itemOrMoney, itemStackCount, destTabId);
 }
 
@@ -1923,45 +1892,30 @@ void ScriptMgr::OnGuildBankEvent(Guild* guild, uint8 eventType, uint8 tabId, Obj
 void ScriptMgr::OnGroupAddMember(Group* group, ObjectGuid guid)
 {
     ASSERT(group);
-#ifdef ELUNA
-    sEluna->OnAddMember(group, guid);
-#endif
     FOREACH_SCRIPT(GroupScript)->OnAddMember(group, guid);
 }
 
 void ScriptMgr::OnGroupInviteMember(Group* group, ObjectGuid guid)
 {
     ASSERT(group);
-#ifdef ELUNA
-    sEluna->OnInviteMember(group, guid);
-#endif
     FOREACH_SCRIPT(GroupScript)->OnInviteMember(group, guid);
 }
 
 void ScriptMgr::OnGroupRemoveMember(Group* group, ObjectGuid guid, RemoveMethod method, ObjectGuid kicker, const char* reason)
 {
     ASSERT(group);
-#ifdef ELUNA
-    sEluna->OnRemoveMember(group, guid, method);
-#endif
     FOREACH_SCRIPT(GroupScript)->OnRemoveMember(group, guid, method, kicker, reason);
 }
 
 void ScriptMgr::OnGroupChangeLeader(Group* group, ObjectGuid newLeaderGuid, ObjectGuid oldLeaderGuid)
 {
     ASSERT(group);
-#ifdef ELUNA
-    sEluna->OnChangeLeader(group, newLeaderGuid, oldLeaderGuid);
-#endif
     FOREACH_SCRIPT(GroupScript)->OnChangeLeader(group, newLeaderGuid, oldLeaderGuid);
 }
 
 void ScriptMgr::OnGroupDisband(Group* group)
 {
     ASSERT(group);
-#ifdef ELUNA
-    sEluna->OnDisband(group);
-#endif
     FOREACH_SCRIPT(GroupScript)->OnDisband(group);
 }
 
@@ -2223,17 +2177,11 @@ void ScriptMgr::OnCalcMaxDuration(Aura const* aura, int32& maxDuration)
 
 void ScriptMgr::OnGameEventStart(uint16 EventID)
 {
-#ifdef ELUNA
-    sEluna->OnGameEventStart(EventID);
-#endif
     FOREACH_SCRIPT(GameEventScript)->OnStart(EventID);
 }
 
 void ScriptMgr::OnGameEventStop(uint16 EventID)
 {
-#ifdef ELUNA
-    sEluna->OnGameEventStop(EventID);
-#endif
     FOREACH_SCRIPT(GameEventScript)->OnStop(EventID);
 }
 
@@ -2666,6 +2614,87 @@ void ScriptMgr::OnSetServerSideVisibilityDetect(Player* player, ServerSideVisibi
     FOREACH_SCRIPT(PlayerScript)->OnSetServerSideVisibilityDetect(player, type, sec);
 }
 
+void ScriptMgr::OnPlayerResurrect(Player* player, float restore_percent, bool applySickness)
+{
+    FOREACH_SCRIPT(PlayerScript)->OnPlayerResurrect(player, restore_percent, applySickness);
+}
+
+bool ScriptMgr::CanPlayerUseChat(Player* player, uint32 type, uint32 language, std::string& msg)
+{
+    bool ret = true;
+
+    FOR_SCRIPTS_RET(PlayerScript, itr, end, ret) // return true by default if not scripts
+        if (!itr->second->CanPlayerUseChat(player, type, language, msg))
+            ret = false; // we change ret value only when scripts return false
+
+    return ret;
+}
+
+bool ScriptMgr::CanPlayerUseChat(Player* player, uint32 type, uint32 language, std::string& msg, Player* receiver)
+{
+    bool ret = true;
+
+    FOR_SCRIPTS_RET(PlayerScript, itr, end, ret) // return true by default if not scripts
+        if (!itr->second->CanPlayerUseChat(player, type, language, msg, receiver))
+            ret = false; // we change ret value only when scripts return false
+
+    return ret;
+}
+
+bool ScriptMgr::CanPlayerUseChat(Player* player, uint32 type, uint32 language, std::string& msg, Group* group)
+{
+    bool ret = true;
+
+    FOR_SCRIPTS_RET(PlayerScript, itr, end, ret) // return true by default if not scripts
+        if (!itr->second->CanPlayerUseChat(player, type, language, msg, group))
+            ret = false; // we change ret value only when scripts return false
+
+    return ret;
+}
+
+bool ScriptMgr::CanPlayerUseChat(Player* player, uint32 type, uint32 language, std::string& msg, Guild* guild)
+{
+    bool ret = true;
+
+    FOR_SCRIPTS_RET(PlayerScript, itr, end, ret) // return true by default if not scripts
+        if (!itr->second->CanPlayerUseChat(player, type, language, msg, guild))
+            ret = false; // we change ret value only when scripts return false
+
+    return ret;
+}
+
+bool ScriptMgr::CanPlayerUseChat(Player* player, uint32 type, uint32 language, std::string& msg, Channel* channel)
+{
+    bool ret = true;
+
+    FOR_SCRIPTS_RET(PlayerScript, itr, end, ret) // return true by default if not scripts
+        if (!itr->second->CanPlayerUseChat(player, type, language, msg, channel))
+            ret = false; // we change ret value only when scripts return false
+
+    return ret;
+}
+
+void ScriptMgr::OnPlayerLearnTalents(Player* player, uint32 talentId, uint32 talentRank, uint32 spellid)
+{
+    FOREACH_SCRIPT(PlayerScript)->OnPlayerLearnTalents(player, talentId, talentRank, spellid);
+}
+
+void ScriptMgr::OnPlayerEnterCombat(Player* player, Unit* enemy)
+{
+    FOREACH_SCRIPT(PlayerScript)->OnPlayerEnterCombat(player, enemy);
+}
+
+void ScriptMgr::OnPlayerLeaveCombat(Player* player)
+{
+    FOREACH_SCRIPT(PlayerScript)->OnPlayerLeaveCombat(player);
+}
+
+void ScriptMgr::OnQuestAbandon(Player* player, uint32 questId)
+{
+    FOREACH_SCRIPT(PlayerScript)->OnQuestAbandon(player, questId);
+}
+
+// Player anti cheat
 void ScriptMgr::AnticheatSetSkipOnePacketForASH(Player* player, bool apply)
 {
     FOREACH_SCRIPT(PlayerScript)->AnticheatSetSkipOnePacketForASH(player, apply);
@@ -2816,6 +2845,12 @@ bool ScriptMgr::IsCustomBuildValuesUpdate(Unit const* unit, uint8 updateType, By
     return ret;
 }
 
+void ScriptMgr::OnUnitUpdate(Unit* unit, uint32 diff)
+{
+    FOREACH_SCRIPT(UnitScript)->OnUnitUpdate(unit, diff);
+}
+
+// BG scripts
 void ScriptMgr::OnQueueUpdate(BattlegroundQueue* queue, BattlegroundBracketId bracket_id, bool isRated, uint32 arenaRatedTeamId)
 {
     FOREACH_SCRIPT(BGScript)->OnQueueUpdate(queue, bracket_id, isRated, arenaRatedTeamId);
@@ -2854,6 +2889,21 @@ bool ScriptMgr::OnBeforeSendExitMessageArenaQueue(BattlegroundQueue* queue, Grou
     return ret;
 }
 
+void ScriptMgr::OnBattlegroundEnd(Battleground* bg, TeamId winnerTeam)
+{
+    FOREACH_SCRIPT(BGScript)->OnBattlegroundEnd(bg, winnerTeam);
+}
+
+void ScriptMgr::OnBattlegroundDestroy(Battleground* bg)
+{
+    FOREACH_SCRIPT(BGScript)->OnBattlegroundDestroy(bg);
+}
+
+void ScriptMgr::OnBattlegroundCreate(Battleground* bg)
+{
+    FOREACH_SCRIPT(BGScript)->OnBattlegroundCreate(bg);
+}
+
 bool ScriptMgr::CanModAuraEffectDamageDone(AuraEffect const* auraEff, Unit* target, AuraApplication const* aurApp, uint8 mode, bool apply)
 {
     bool ret = true;
@@ -2929,6 +2979,22 @@ void ScriptMgr::OnBeforeAuraRankForLevel(SpellInfo const* spellInfo, SpellInfo c
     FOREACH_SCRIPT(SpellSC)->OnBeforeAuraRankForLevel(spellInfo, latestSpellInfo, level);
 }
 
+void ScriptMgr::OnDummyEffect(WorldObject* caster, uint32 spellID, SpellEffIndex effIndex, GameObject* gameObjTarget)
+{
+    FOREACH_SCRIPT(SpellSC)->OnDummyEffect(caster, spellID, effIndex, gameObjTarget);
+}
+
+void ScriptMgr::OnDummyEffect(WorldObject* caster, uint32 spellID, SpellEffIndex effIndex, Creature* creatureTarget)
+{
+    FOREACH_SCRIPT(SpellSC)->OnDummyEffect(caster, spellID, effIndex, creatureTarget);
+}
+
+void ScriptMgr::OnDummyEffect(WorldObject* caster, uint32 spellID, SpellEffIndex effIndex, Item* itemTarget)
+{
+    FOREACH_SCRIPT(SpellSC)->OnDummyEffect(caster, spellID, effIndex, itemTarget);
+}
+
+// AchievementScript
 void ScriptMgr::SetRealmCompleted(AchievementEntry const* achievement)
 {
     FOREACH_SCRIPT(AchievementScript)->SetRealmCompleted(achievement);
@@ -3145,9 +3211,9 @@ void ScriptMgr::OnPlayerSetPhase(const AuraEffect* auraEff, AuraApplication cons
     FOREACH_SCRIPT(MiscScript)->OnPlayerSetPhase(auraEff, aurApp, mode, apply, newPhase);
 }
 
-void ScriptMgr::OnHandleDevCommand(Player* player, std::string& argstr)
+void ScriptMgr::GetDialogStatus(Player* player, Object* questgiver)
 {
-    FOREACH_SCRIPT(CommandSC)->OnHandleDevCommand(player, argstr);
+    FOREACH_SCRIPT(MiscScript)->GetDialogStatus(player, questgiver);
 }
 
 void ScriptMgr::OnAfterDatabasesLoaded(uint32 updateFlags)
@@ -3155,6 +3221,79 @@ void ScriptMgr::OnAfterDatabasesLoaded(uint32 updateFlags)
     FOREACH_SCRIPT(DatabaseScript)->OnAfterDatabasesLoaded(updateFlags);
 }
 
+// Command script custom
+void ScriptMgr::OnHandleDevCommand(Player* player, std::string& argstr)
+{
+    FOREACH_SCRIPT(CommandSC)->OnHandleDevCommand(player, argstr);
+}
+
+bool ScriptMgr::CanExecuteCommand(ChatHandler& handler, std::string_view cmdStr)
+{
+    bool ret = true;
+
+    FOR_SCRIPTS_RET(CommandSC, itr, end, ret) // return true by default if not scripts
+        if (!itr->second->CanExecuteCommand(handler, cmdStr))
+            ret = false; // we change ret value only when scripts return false
+
+    return ret;
+}
+
+// World object
+void ScriptMgr::OnWorldObjectDestroy(WorldObject* object)
+{
+    ASSERT(object);
+    FOREACH_SCRIPT(WorldObjectScript)->OnWorldObjectDestroy(object);
+}
+
+void ScriptMgr::OnWorldObjectCreate(WorldObject* object)
+{
+    ASSERT(object);
+    FOREACH_SCRIPT(WorldObjectScript)->OnWorldObjectCreate(object);
+}
+
+void ScriptMgr::OnWorldObjectSetMap(WorldObject* object, Map* map)
+{
+    ASSERT(object);
+    FOREACH_SCRIPT(WorldObjectScript)->OnWorldObjectSetMap(object, map);
+}
+
+void ScriptMgr::OnWorldObjectResetMap(WorldObject* object)
+{
+    ASSERT(object);
+    FOREACH_SCRIPT(WorldObjectScript)->OnWorldObjectResetMap(object);
+}
+
+void ScriptMgr::OnWorldObjectUpdate(WorldObject* object, uint32 diff)
+{
+    ASSERT(object);
+    FOREACH_SCRIPT(WorldObjectScript)->OnWorldObjectUpdate(object, diff);
+}
+
+// Pet
+void ScriptMgr::OnPetAddToWorld(Pet* pet)
+{
+    ASSERT(pet);
+    FOREACH_SCRIPT(PetScript)->OnPetAddToWorld(pet);
+}
+
+// Loot
+void ScriptMgr::OnLootMoney(Player* player, uint32 gold)
+{
+    ASSERT(player);
+    FOREACH_SCRIPT(LootScript)->OnLootMoney(player, gold);
+}
+
+// Map script
+void ScriptMgr::OnBeforeCreateInstanceScript(InstanceMap* instanceMap, InstanceScript* instanceData, bool load, std::string data, uint32 completedEncounterMask)
+{
+    FOREACH_SCRIPT(AllMapScript)->OnBeforeCreateInstanceScript(instanceMap, instanceData, load, data, completedEncounterMask);
+}
+
+void ScriptMgr::OnDestroyInstance(MapInstanced* mapInstanced, Map* map)
+{
+    FOREACH_SCRIPT(AllMapScript)->OnDestroyInstance(mapInstanced, map);
+}
+
 ///-
 AllMapScript::AllMapScript(const char* name)
     : ScriptObject(name)
@@ -3438,6 +3577,31 @@ DatabaseScript::DatabaseScript(const char* name) : ScriptObject(name)
     ScriptRegistry<DatabaseScript>::AddScript(this);
 }
 
+WorldObjectScript::WorldObjectScript(const char* name) : ScriptObject(name)
+{
+    ScriptRegistry<WorldObjectScript>::AddScript(this);
+}
+
+LootScript::LootScript(const char* name) : ScriptObject(name)
+{
+    ScriptRegistry<LootScript>::AddScript(this);
+}
+
+ElunaScript::ElunaScript(const char* name) : ScriptObject(name)
+{
+    ScriptRegistry<ElunaScript>::AddScript(this);
+}
+
+AllItemScript::AllItemScript(const char* name) : ScriptObject(name)
+{
+    ScriptRegistry<AllItemScript>::AddScript(this);
+}
+
+AllGameObjectScript::AllGameObjectScript(const char* name) : ScriptObject(name)
+{
+    ScriptRegistry<AllGameObjectScript>::AddScript(this);
+}
+
 // Specialize for each script type class like so:
 template class ScriptRegistry<SpellScriptLoader>;
 template class ScriptRegistry<ServerScript>;
@@ -3480,3 +3644,8 @@ template class ScriptRegistry<PetScript>;
 template class ScriptRegistry<ArenaScript>;
 template class ScriptRegistry<CommandSC>;
 template class ScriptRegistry<DatabaseScript>;
+template class ScriptRegistry<WorldObjectScript>;
+template class ScriptRegistry<LootScript>;
+template class ScriptRegistry<ElunaScript>;
+template class ScriptRegistry<AllItemScript>;
+template class ScriptRegistry<AllGameObjectScript>;