nchebrov/azerothcore-wotlk
1
0
Fork 0
mirror of https://github.com/mod-playerbots/azerothcore-wotlk.git synced 2026-01-13 09:17:18 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'master' into Playerbot

Browse Source
This commit is contained in:
Yunfan Li
2024-04-14 21:08:07 +08:00
parent 65cb23b56a 6d35eafbac
commit ab9fe20600
74 changed files with 1482 additions and 2371 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
data/sql/updates/db_world/2024_04_13_00.sql Normal file
View File

@@ -0,0 +1,3 @@
-- DB update 2024_04_07_00 -> 2024_04_13_00
--
UPDATE `creature_template` SET `flags_extra` = `flags_extra` |256 WHERE `entry` = 17818;

3
data/sql/updates/db_world/2024_04_14_00.sql Normal file
View File

@@ -0,0 +1,3 @@
-- DB update 2024_04_13_00 -> 2024_04_14_00
--
UPDATE `creature_template` SET `flags_extra` = `flags_extra` |2147483648 WHERE `entry` = 19514;

4
data/sql/updates/db_world/2024_04_14_01.sql Normal file
View File

@@ -0,0 +1,4 @@
-- DB update 2024_04_14_00 -> 2024_04_14_01
--
UPDATE `creature_template` SET `mechanic_immune_mask` = `mechanic_immune_mask` &~ 8 WHERE `entry` IN (17767, 17808, 17888, 17842);
UPDATE `creature_template` SET `mechanic_immune_mask` = `mechanic_immune_mask` | 4 WHERE `entry` IN (17767, 17808, 17888, 17842);

10
data/sql/updates/db_world/2024_04_14_02.sql Normal file
View File

@@ -0,0 +1,10 @@
-- DB update 2024_04_14_01 -> 2024_04_14_02
--
DELETE FROM `creature_template_spell` WHERE (`CreatureID` = 17899);
INSERT INTO `creature_template_spell` (`CreatureID`, `Index`, `Spell`, `VerifiedBuild`) VALUES
(17899, 0, 2, 54205),
(17899, 1, 31626, 54205);
DELETE FROM `spell_cooldown_overrides` WHERE `Id` = 31626;
INSERT INTO `spell_cooldown_overrides` (`Id`, `RecoveryTime`, `CategoryRecoveryTime`, `Comment`) VALUES
(31626, 5000, 5000, 'Shadowy Necromancer - Unholy Frenzy');

19
docker-compose.yml
View File

@@ -36,6 +36,10 @@ services:
context: .
target: db-import
dockerfile: apps/docker/Dockerfile
args:
USER_ID: ${DOCKER_USER_ID:-1000}
GROUP_ID: ${DOCKER_GROUP_ID:-1000}
DOCKER_USER: ${DOCKER_USER:-acore}
environment:
AC_DATA_DIR: "/azerothcore/env/dist/data"
AC_LOGS_DIR: "/azerothcore/env/dist/logs"
@@ -57,6 +61,10 @@ services:
context: .
target: worldserver
dockerfile: apps/docker/Dockerfile
args:
USER_ID: ${DOCKER_USER_ID:-1000}
GROUP_ID: ${DOCKER_GROUP_ID:-1000}
DOCKER_USER: ${DOCKER_USER:-acore}
networks:
- ac-network
stdin_open: true
@@ -95,6 +103,10 @@ services:
context: .
target: authserver
dockerfile: apps/docker/Dockerfile
args:
USER_ID: ${DOCKER_USER_ID:-1000}
GROUP_ID: ${DOCKER_GROUP_ID:-1000}
DOCKER_USER: ${DOCKER_USER:-acore}
networks:
- ac-network
tty: true
@@ -120,7 +132,6 @@ services:
ac-client-data-init:
container_name: ac-client-data-init
image: acore/ac-wotlk-client-data:${DOCKER_IMAGE_TAG:-master}
user: ${DOCKER_USER:-root}
build:
context: .
target: client-data
@@ -137,11 +148,14 @@ services:
ac-tools:
container_name: ac-tools
image: acore/ac-wotlk-tools:${DOCKER_IMAGE_TAG:-master}
user: ${DOCKER_USER:-root}
build:
context: .
target: tools
dockerfile: apps/docker/Dockerfile
args:
USER_ID: ${DOCKER_USER_ID:-1000}
GROUP_ID: ${DOCKER_GROUP_ID:-1000}
DOCKER_USER: ${DOCKER_USER:-acore}
working_dir: /azerothcore/env/client/
volumes:
# this is not the directory of the extracted data! It's the client folder used by the extractors
@@ -160,7 +174,6 @@ services:
ac-dev-server:
tty: true
image: acore/ac-wotlk-dev-server:${DOCKER_IMAGE_TAG:-master}
user: ${DOCKER_USER:-root}
build:
context: .
dockerfile: ./apps/docker/Dockerfile.dev-server

4
src/server/game/AI/CoreAI/UnitAI.cpp
View File

@@ -253,9 +253,9 @@ SpellCastResult UnitAI::DoCastAOE(uint32 spellId, bool triggered)
return me->CastSpell((Unit*)nullptr, spellId, triggered);
}
SpellCastResult UnitAI::DoCastRandomTarget(uint32 spellId, uint32 threatTablePosition, float dist, bool playerOnly, bool triggered)
SpellCastResult UnitAI::DoCastRandomTarget(uint32 spellId, uint32 threatTablePosition, float dist, bool playerOnly, bool triggered, bool withTank)
{
if (Unit* target = SelectTarget(SelectTargetMethod::Random, threatTablePosition, dist, playerOnly))
if (Unit* target = SelectTarget(SelectTargetMethod::Random, threatTablePosition, dist, playerOnly, withTank))
{
return DoCast(target, spellId, triggered);
}

2
src/server/game/AI/CoreAI/UnitAI.h
View File

@@ -380,7 +380,7 @@ public:
SpellCastResult DoCastToAllHostilePlayers(uint32 spellid, bool triggered = false);
SpellCastResult DoCastVictim(uint32 spellId, bool triggered = false);
SpellCastResult DoCastAOE(uint32 spellId, bool triggered = false);
SpellCastResult DoCastRandomTarget(uint32 spellId, uint32 threatTablePosition = 0, float dist = 0.0f, bool playerOnly = true, bool triggered = false);
SpellCastResult DoCastRandomTarget(uint32 spellId, uint32 threatTablePosition = 0, float dist = 0.0f, bool playerOnly = true, bool triggered = false, bool withTank = true);
// Cast spell on the top threat target, which may not be the current victim.
SpellCastResult DoCastMaxThreat(uint32 spellId, uint32 threatTablePosition = 0, float dist = 0.0f, bool playerOnly = true, bool triggered = false);

22
src/server/game/DungeonFinding/LFGScripts.cpp
View File

@@ -29,7 +29,17 @@
namespace lfg
{
LFGPlayerScript::LFGPlayerScript() : PlayerScript("LFGPlayerScript") { }
LFGPlayerScript::LFGPlayerScript() :
PlayerScript("LFGPlayerScript",
{
PLAYERHOOK_ON_LEVEL_CHANGED,
PLAYERHOOK_ON_LOGOUT,
PLAYERHOOK_ON_LOGIN,
PLAYERHOOK_ON_BIND_TO_INSTANCE,
PLAYERHOOK_ON_MAP_CHANGED
})
{
}
void LFGPlayerScript::OnLevelChanged(Player* player, uint8 /*oldLevel*/)
{
@@ -130,7 +140,15 @@ namespace lfg
}
}
LFGGroupScript::LFGGroupScript() : GroupScript("LFGGroupScript")
LFGGroupScript::LFGGroupScript() :
GroupScript("LFGGroupScript",
{
GROUPHOOK_ON_ADD_MEMBER,
GROUPHOOK_ON_REMOVE_MEMBER,
GROUPHOOK_ON_DISBAND,
GROUPHOOK_ON_CHANGE_LEADER,
GROUPHOOK_ON_INVITE_MEMBER
})
{
}

7
src/server/game/Handlers/CharacterHandler.cpp
View File

@@ -635,6 +635,13 @@ void WorldSession::HandleCharDeleteOpcode(WorldPacket& recvData)
accountId = playerData->AccountId;
name = playerData->Name;
level = playerData->Level;
// check mailbox
if (playerData->MailCount)
{
SendCharDelete(CHAR_DELETE_FAILED);
return;
}
}
// prevent deleting other players' characters using cheating tools

66
src/server/game/Scripting/ScriptDefines/AccountScript.cpp
View File

@@ -21,90 +21,58 @@
void ScriptMgr::OnAccountLogin(uint32 accountId)
{
ExecuteScript<AccountScript>([&](AccountScript* script)
{
script->OnAccountLogin(accountId);
});
CALL_ENABLED_HOOKS(AccountScript, ACCOUNTHOOK_ON_ACCOUNT_LOGIN, script->OnAccountLogin(accountId));
}
void ScriptMgr::OnBeforeAccountDelete(uint32 accountId)
{
ExecuteScript<AccountScript>([&](AccountScript* script)
{
script->OnBeforeAccountDelete(accountId);
});
CALL_ENABLED_HOOKS(AccountScript, ACCOUNTHOOK_ON_BEFORE_ACCOUNT_DELETE, script->OnBeforeAccountDelete(accountId));
}
//void ScriptMgr::OnAccountLogout(uint32 accountId)
//{
// ExecuteScript<AccountScript>([&](AccountScript* script)
// {
// script->OnAccountLogout(accountId);
// });
//}
void ScriptMgr::OnLastIpUpdate(uint32 accountId, std::string ip)
{
ExecuteScript<AccountScript>([&](AccountScript* script)
{
script->OnLastIpUpdate(accountId, ip);
});
CALL_ENABLED_HOOKS(AccountScript, ACCOUNTHOOK_ON_LAST_IP_UPDATE, script->OnLastIpUpdate(accountId, ip));
}
void ScriptMgr::OnFailedAccountLogin(uint32 accountId)
{
ExecuteScript<AccountScript>([&](AccountScript* script)
{
script->OnFailedAccountLogin(accountId);
});
CALL_ENABLED_HOOKS(AccountScript, ACCOUNTHOOK_ON_FAILED_ACCOUNT_LOGIN, script->OnFailedAccountLogin(accountId));
}
void ScriptMgr::OnEmailChange(uint32 accountId)
{
ExecuteScript<AccountScript>([&](AccountScript* script)
{
script->OnEmailChange(accountId);
});
CALL_ENABLED_HOOKS(AccountScript, ACCOUNTHOOK_ON_EMAIL_CHANGE, script->OnEmailChange(accountId));
}
void ScriptMgr::OnFailedEmailChange(uint32 accountId)
{
ExecuteScript<AccountScript>([&](AccountScript* script)
{
script->OnFailedEmailChange(accountId);
});
CALL_ENABLED_HOOKS(AccountScript, ACCOUNTHOOK_ON_FAILED_EMAIL_CHANGE, script->OnFailedEmailChange(accountId));
}
void ScriptMgr::OnPasswordChange(uint32 accountId)
{
ExecuteScript<AccountScript>([&](AccountScript* script)
{
script->OnPasswordChange(accountId);
});
CALL_ENABLED_HOOKS(AccountScript, ACCOUNTHOOK_ON_PASSWORD_CHANGE, script->OnPasswordChange(accountId));
}
void ScriptMgr::OnFailedPasswordChange(uint32 accountId)
{
ExecuteScript<AccountScript>([&](AccountScript* script)
{
script->OnFailedPasswordChange(accountId);
});
CALL_ENABLED_HOOKS(AccountScript, ACCOUNTHOOK_ON_FAILED_PASSWORD_CHANGE, script->OnFailedPasswordChange(accountId));
}
bool ScriptMgr::CanAccountCreateCharacter(uint32 accountId, uint8 charRace, uint8 charClass)
{
auto ret = IsValidBoolScript<AccountScript>([&](AccountScript* script)
{
return !script->CanAccountCreateCharacter(accountId, charRace, charClass);
});
return ReturnValidBool(ret);
CALL_ENABLED_BOOLEAN_HOOKS(AccountScript, ACCOUNTHOOK_CAN_ACCOUNT_CREATE_CHARACTER, !script->CanAccountCreateCharacter(accountId, charRace, charClass));
}
AccountScript::AccountScript(char const* name) :
ScriptObject(name)
AccountScript::AccountScript(char const* name, std::vector<uint16> enabledHooks) :
ScriptObject(name, ACCOUNTHOOK_END)
{
ScriptRegistry<AccountScript>::AddScript(this);
// If empty - enable all available hooks.
if (enabledHooks.empty())
for (uint16 i = 0; i < ACCOUNTHOOK_END; ++i)
enabledHooks.emplace_back(i);
ScriptRegistry<AccountScript>::AddScript(this, std::move(enabledHooks));
}
template class AC_GAME_API ScriptRegistry<AccountScript>;

17
src/server/game/Scripting/ScriptDefines/AccountScript.h
View File

@@ -19,11 +19,26 @@
#define SCRIPT_OBJECT_ACCOUNT_SCRIPT_H_
#include "ScriptObject.h"
#include <vector>
enum AccountHook
{
ACCOUNTHOOK_ON_ACCOUNT_LOGIN,
ACCOUNTHOOK_ON_BEFORE_ACCOUNT_DELETE,
ACCOUNTHOOK_ON_LAST_IP_UPDATE,
ACCOUNTHOOK_ON_FAILED_ACCOUNT_LOGIN,
ACCOUNTHOOK_ON_EMAIL_CHANGE,
ACCOUNTHOOK_ON_FAILED_EMAIL_CHANGE,
ACCOUNTHOOK_ON_PASSWORD_CHANGE,
ACCOUNTHOOK_ON_FAILED_PASSWORD_CHANGE,
ACCOUNTHOOK_CAN_ACCOUNT_CREATE_CHARACTER,
ACCOUNTHOOK_END
};
class AccountScript : public ScriptObject
{
protected:
AccountScript(const char* name);
AccountScript(const char* name, std::vector<uint16> enabledHooks = std::vector<uint16>());
public:
// Called when an account logged in successfully

57
src/server/game/Scripting/ScriptDefines/AchievementScript.cpp
View File

@@ -21,69 +21,38 @@
void ScriptMgr::SetRealmCompleted(AchievementEntry const* achievement)
{
ExecuteScript<AchievementScript>([&](AchievementScript* script)
{
script->SetRealmCompleted(achievement);
});
CALL_ENABLED_HOOKS(AchievementScript, ACHIEVEMENTHOOK_SET_REALM_COMPLETED, script->SetRealmCompleted(achievement));
}
bool ScriptMgr::IsCompletedCriteria(AchievementMgr* mgr, AchievementCriteriaEntry const* achievementCriteria, AchievementEntry const* achievement, CriteriaProgress const* progress)
{
auto ret = IsValidBoolScript<AchievementScript>([&](AchievementScript* script)
{
return !script->IsCompletedCriteria(mgr, achievementCriteria, achievement, progress);
});
if (ret && *ret)
{
return false;
}
return true;
CALL_ENABLED_BOOLEAN_HOOKS(AchievementScript, ACHIEVEMENTHOOK_IS_COMPLETED_CRITERIA, !script->IsCompletedCriteria(mgr, achievementCriteria, achievement, progress));
}
bool ScriptMgr::IsRealmCompleted(AchievementGlobalMgr const* globalmgr, AchievementEntry const* achievement, SystemTimePoint completionTime)
{
auto ret = IsValidBoolScript<AchievementScript>([&](AchievementScript* script)
{
return !script->IsRealmCompleted(globalmgr, achievement, completionTime);
});
if (ret && *ret)
{
return false;
}
return true;
CALL_ENABLED_BOOLEAN_HOOKS(AchievementScript, ACHIEVEMENTHOOK_IS_REALM_COMPLETED, !script->IsRealmCompleted(globalmgr, achievement, completionTime));
}
void ScriptMgr::OnBeforeCheckCriteria(AchievementMgr* mgr, std::list<AchievementCriteriaEntry const*> const* achievementCriteriaList)
{
ExecuteScript<AchievementScript>([&](AchievementScript* script)
{
script->OnBeforeCheckCriteria(mgr, achievementCriteriaList);
});
CALL_ENABLED_HOOKS(AchievementScript, ACHIEVEMENTHOOK_ON_BEFORE_CHECK_CRITERIA, script->OnBeforeCheckCriteria(mgr, achievementCriteriaList));
}
bool ScriptMgr::CanCheckCriteria(AchievementMgr* mgr, AchievementCriteriaEntry const* achievementCriteria)
{
auto ret = IsValidBoolScript<AchievementScript>([&](AchievementScript* script)
{
return !script->CanCheckCriteria(mgr, achievementCriteria);
});
if (ret && *ret)
{
return false;
}
return true;
CALL_ENABLED_BOOLEAN_HOOKS(AchievementScript, ACHIEVEMENTHOOK_CAN_CHECK_CRITERIA, !script->CanCheckCriteria(mgr, achievementCriteria));
}
AchievementScript::AchievementScript(const char* name)
: ScriptObject(name)
AchievementScript::AchievementScript(const char* name, std::vector<uint16> enabledHooks)
: ScriptObject(name, ACHIEVEMENTHOOK_END)
{
ScriptRegistry<AchievementScript>::AddScript(this);
// If empty - enable all available hooks.
if (enabledHooks.empty())
for (uint16 i = 0; i < ACHIEVEMENTHOOK_END; ++i)
enabledHooks.emplace_back(i);
ScriptRegistry<AchievementScript>::AddScript(this, std::move(enabledHooks));
}
template class AC_GAME_API ScriptRegistry<AchievementScript>;

13
src/server/game/Scripting/ScriptDefines/AchievementScript.h
View File

@@ -21,11 +21,22 @@
#include "Duration.h"
#include "ScriptObject.h"
#include <list>
#include <vector>
enum AchievementHook
{
ACHIEVEMENTHOOK_SET_REALM_COMPLETED,
ACHIEVEMENTHOOK_IS_COMPLETED_CRITERIA,
ACHIEVEMENTHOOK_IS_REALM_COMPLETED,
ACHIEVEMENTHOOK_ON_BEFORE_CHECK_CRITERIA,
ACHIEVEMENTHOOK_CAN_CHECK_CRITERIA,
ACHIEVEMENTHOOK_END
};
class AchievementScript : public ScriptObject
{
protected:
AchievementScript(const char* name);
AchievementScript(const char* name, std::vector<uint16> enabledHooks = std::vector<uint16>());
public:
[[nodiscard]] bool IsDatabaseBound() const override { return false; }

127
src/server/game/Scripting/ScriptDefines/AllBattlegroundScript.cpp
View File

@@ -21,148 +21,93 @@
void ScriptMgr::OnBattlegroundStart(Battleground* bg)
{
ExecuteScript<AllBattlegroundScript>([&](AllBattlegroundScript* script)
{
script->OnBattlegroundStart(bg);
});
CALL_ENABLED_HOOKS(AllBattlegroundScript, ALLBATTLEGROUNDHOOK_ON_BATTLEGROUND_START, script->OnBattlegroundStart(bg));
}
void ScriptMgr::OnBattlegroundEndReward(Battleground* bg, Player* player, TeamId winnerTeamId)
{
ExecuteScript<AllBattlegroundScript>([&](AllBattlegroundScript* script)
{
script->OnBattlegroundEndReward(bg, player, winnerTeamId);
});
CALL_ENABLED_HOOKS(AllBattlegroundScript, ALLBATTLEGROUNDHOOK_ON_BATTLEGROUND_END_REWARD, script->OnBattlegroundEndReward(bg, player, winnerTeamId));
}
void ScriptMgr::OnBattlegroundUpdate(Battleground* bg, uint32 diff)
{
ExecuteScript<AllBattlegroundScript>([&](AllBattlegroundScript* script)
{
script->OnBattlegroundUpdate(bg, diff);
});
CALL_ENABLED_HOOKS(AllBattlegroundScript, ALLBATTLEGROUNDHOOK_ON_BATTLEGROUND_UPDATE, script->OnBattlegroundUpdate(bg, diff));
}
void ScriptMgr::OnBattlegroundAddPlayer(Battleground* bg, Player* player)
{
ExecuteScript<AllBattlegroundScript>([&](AllBattlegroundScript* script)
{
script->OnBattlegroundAddPlayer(bg, player);
});
CALL_ENABLED_HOOKS(AllBattlegroundScript, ALLBATTLEGROUNDHOOK_ON_BATTLEGROUND_ADD_PLAYER, script->OnBattlegroundAddPlayer(bg, player));
}
void ScriptMgr::OnBattlegroundBeforeAddPlayer(Battleground* bg, Player* player)
{
ExecuteScript<AllBattlegroundScript>([&](AllBattlegroundScript* script)
{
script->OnBattlegroundBeforeAddPlayer(bg, player);
});
CALL_ENABLED_HOOKS(AllBattlegroundScript, ALLBATTLEGROUNDHOOK_ON_BATTLEGROUND_BEFORE_ADD_PLAYER, script->OnBattlegroundBeforeAddPlayer(bg, player));
}
void ScriptMgr::OnBattlegroundRemovePlayerAtLeave(Battleground* bg, Player* player)
{
ExecuteScript<AllBattlegroundScript>([&](AllBattlegroundScript* script)
{
script->OnBattlegroundRemovePlayerAtLeave(bg, player);
});
}
void ScriptMgr::OnAddGroup(BattlegroundQueue* queue, GroupQueueInfo* ginfo, uint32& index, Player* leader, Group* group, BattlegroundTypeId bgTypeId, PvPDifficultyEntry const* bracketEntry,
uint8 arenaType, bool isRated, bool isPremade, uint32 arenaRating, uint32 matchmakerRating, uint32 arenaTeamId, uint32 opponentsArenaTeamId)
{
ExecuteScript<AllBattlegroundScript>([&](AllBattlegroundScript* script)
{
script->OnAddGroup(queue, ginfo, index, leader, group, bgTypeId, bracketEntry,
arenaType, isRated, isPremade, arenaRating, matchmakerRating, arenaTeamId, opponentsArenaTeamId);
});
}
bool ScriptMgr::CanFillPlayersToBG(BattlegroundQueue* queue, Battleground* bg, BattlegroundBracketId bracket_id)
{
auto ret = IsValidBoolScript<AllBattlegroundScript>([&](AllBattlegroundScript* script)
{
return !script->CanFillPlayersToBG(queue, bg, bracket_id);
});
return ReturnValidBool(ret);
}
bool ScriptMgr::IsCheckNormalMatch(BattlegroundQueue* queue, Battleground* bgTemplate, BattlegroundBracketId bracket_id, uint32 minPlayers, uint32 maxPlayers)
{
auto ret = IsValidBoolScript<AllBattlegroundScript>([&](AllBattlegroundScript* script)
{
return script->IsCheckNormalMatch(queue, bgTemplate, bracket_id, minPlayers, maxPlayers);
});
return ReturnValidBool(ret, true);
CALL_ENABLED_HOOKS(AllBattlegroundScript, ALLBATTLEGROUNDHOOK_ON_BATTLEGROUND_REMOVE_PLAYER_AT_LEAVE, script->OnBattlegroundRemovePlayerAtLeave(bg, player));
}
void ScriptMgr::OnQueueUpdate(BattlegroundQueue* queue, uint32 diff, BattlegroundTypeId bgTypeId, BattlegroundBracketId bracket_id, uint8 arenaType, bool isRated, uint32 arenaRating)
{
ExecuteScript<AllBattlegroundScript>([&](AllBattlegroundScript* script)
{
script->OnQueueUpdate(queue, diff, bgTypeId, bracket_id, arenaType, isRated, arenaRating);
});
CALL_ENABLED_HOOKS(AllBattlegroundScript, ALLBATTLEGROUNDHOOK_ON_QUEUE_UPDATE, script->OnQueueUpdate(queue, diff, bgTypeId, bracket_id, arenaType, isRated, arenaRating));
}
void ScriptMgr::OnAddGroup(BattlegroundQueue* queue, GroupQueueInfo* ginfo, uint32& index, Player* leader, Group* group, BattlegroundTypeId bgTypeId, PvPDifficultyEntry const* bracketEntry, uint8 arenaType, bool isRated, bool isPremade, uint32 arenaRating, uint32 matchmakerRating, uint32 arenaTeamId, uint32 opponentsArenaTeamId)
{
CALL_ENABLED_HOOKS(AllBattlegroundScript, ALLBATTLEGROUNDHOOK_ON_ADD_GROUP, script->OnAddGroup(queue, ginfo, index, leader, group, bgTypeId, bracketEntry, arenaType, isRated, isPremade, arenaRating, matchmakerRating, arenaTeamId, opponentsArenaTeamId));
}
bool ScriptMgr::CanFillPlayersToBG(BattlegroundQueue* queue, Battleground* bg, BattlegroundBracketId bracket_id)
{
CALL_ENABLED_BOOLEAN_HOOKS(AllBattlegroundScript, ALLBATTLEGROUNDHOOK_CAN_FILL_PLAYERS_TO_BG, !script->CanFillPlayersToBG(queue, bg, bracket_id));
}
bool ScriptMgr::IsCheckNormalMatch(BattlegroundQueue* queue, Battleground* bgTemplate, BattlegroundBracketId bracket_id, uint32 minPlayers, uint32 maxPlayers)
{
CALL_ENABLED_BOOLEAN_HOOKS_WITH_DEFAULT_FALSE(AllBattlegroundScript, ALLBATTLEGROUNDHOOK_IS_CHECK_NORMAL_MATCH, script->IsCheckNormalMatch(queue, bgTemplate, bracket_id, minPlayers, maxPlayers));
}
bool ScriptMgr::CanSendMessageBGQueue(BattlegroundQueue* queue, Player* leader, Battleground* bg, PvPDifficultyEntry const* bracketEntry)
{
auto ret = IsValidBoolScript<AllBattlegroundScript>([&](AllBattlegroundScript* script)
{
return !script->CanSendMessageBGQueue(queue, leader, bg, bracketEntry);
});
return ReturnValidBool(ret);
CALL_ENABLED_BOOLEAN_HOOKS(AllBattlegroundScript, ALLBATTLEGROUNDHOOK_CAN_SEND_MESSAGE_BG_QUEUE, !script->CanSendMessageBGQueue(queue, leader, bg, bracketEntry));
}
bool ScriptMgr::OnBeforeSendJoinMessageArenaQueue(BattlegroundQueue* queue, Player* leader, GroupQueueInfo* ginfo, PvPDifficultyEntry const* bracketEntry, bool isRated)
{
auto ret = IsValidBoolScript<AllBattlegroundScript>([&](AllBattlegroundScript* script)
{
return !script->OnBeforeSendJoinMessageArenaQueue(queue, leader, ginfo, bracketEntry, isRated);
});
return ReturnValidBool(ret);
CALL_ENABLED_BOOLEAN_HOOKS(AllBattlegroundScript, ALLBATTLEGROUNDHOOK_ON_BEFORE_SEND_JOIN_MESSAGE_ARENA_QUEUE, !script->OnBeforeSendJoinMessageArenaQueue(queue, leader, ginfo, bracketEntry, isRated));
}
bool ScriptMgr::OnBeforeSendExitMessageArenaQueue(BattlegroundQueue* queue, GroupQueueInfo* ginfo)
{
auto ret = IsValidBoolScript<AllBattlegroundScript>([&](AllBattlegroundScript* script)
{
return !script->OnBeforeSendExitMessageArenaQueue(queue, ginfo);
});
return ReturnValidBool(ret);
CALL_ENABLED_BOOLEAN_HOOKS(AllBattlegroundScript, ALLBATTLEGROUNDHOOK_ON_BEFORE_SEND_EXIT_MESSAGE_ARENA_QUEUE, !script->OnBeforeSendExitMessageArenaQueue(queue, ginfo));
}
void ScriptMgr::OnBattlegroundEnd(Battleground* bg, TeamId winnerTeam)
{
ExecuteScript<AllBattlegroundScript>([&](AllBattlegroundScript* script)
{
script->OnBattlegroundEnd(bg, winnerTeam);
});
CALL_ENABLED_HOOKS(AllBattlegroundScript, ALLBATTLEGROUNDHOOK_ON_BATTLEGROUND_END, script->OnBattlegroundEnd(bg, winnerTeam));
}
void ScriptMgr::OnBattlegroundDestroy(Battleground* bg)
{
ExecuteScript<AllBattlegroundScript>([&](AllBattlegroundScript* script)
{
script->OnBattlegroundDestroy(bg);
});
CALL_ENABLED_HOOKS(AllBattlegroundScript, ALLBATTLEGROUNDHOOK_ON_BATTLEGROUND_DESTROY, script->OnBattlegroundDestroy(bg));
}
void ScriptMgr::OnBattlegroundCreate(Battleground* bg)
{
ExecuteScript<AllBattlegroundScript>([&](AllBattlegroundScript* script)
{
script->OnBattlegroundCreate(bg);
});
CALL_ENABLED_HOOKS(AllBattlegroundScript, ALLBATTLEGROUNDHOOK_ON_BATTLEGROUND_CREATE, script->OnBattlegroundCreate(bg));
}
AllBattlegroundScript::AllBattlegroundScript(char const* name) :
ScriptObject(name)
AllBattlegroundScript::AllBattlegroundScript(char const* name, std::vector<uint16> enabledHooks) :
ScriptObject(name, ALLBATTLEGROUNDHOOK_END)
{
ScriptRegistry<AllBattlegroundScript>::AddScript(this);
// If empty - enable all available hooks.
if (enabledHooks.empty())
for (uint16 i = 0; i < ALLBATTLEGROUNDHOOK_END; ++i)
enabledHooks.emplace_back(i);
ScriptRegistry<AllBattlegroundScript>::AddScript(this, std::move(enabledHooks));
}
template class AC_GAME_API ScriptRegistry<AllBattlegroundScript>;

24
src/server/game/Scripting/ScriptDefines/AllBattlegroundScript.h
View File

@@ -19,6 +19,28 @@
#define SCRIPT_OBJECT_ALL_BATTLEGROUND_SCRIPT_H_
#include "ScriptObject.h"
#include <vector>
enum AllBattlegroundHook
{
ALLBATTLEGROUNDHOOK_ON_BATTLEGROUND_START,
ALLBATTLEGROUNDHOOK_ON_BATTLEGROUND_END_REWARD,
ALLBATTLEGROUNDHOOK_ON_BATTLEGROUND_UPDATE,
ALLBATTLEGROUNDHOOK_ON_BATTLEGROUND_ADD_PLAYER,
ALLBATTLEGROUNDHOOK_ON_BATTLEGROUND_BEFORE_ADD_PLAYER,
ALLBATTLEGROUNDHOOK_ON_BATTLEGROUND_REMOVE_PLAYER_AT_LEAVE,
ALLBATTLEGROUNDHOOK_ON_QUEUE_UPDATE,
ALLBATTLEGROUNDHOOK_ON_ADD_GROUP,
ALLBATTLEGROUNDHOOK_CAN_FILL_PLAYERS_TO_BG,
ALLBATTLEGROUNDHOOK_IS_CHECK_NORMAL_MATCH,
ALLBATTLEGROUNDHOOK_CAN_SEND_MESSAGE_BG_QUEUE,
ALLBATTLEGROUNDHOOK_ON_BEFORE_SEND_JOIN_MESSAGE_ARENA_QUEUE,
ALLBATTLEGROUNDHOOK_ON_BEFORE_SEND_EXIT_MESSAGE_ARENA_QUEUE,
ALLBATTLEGROUNDHOOK_ON_BATTLEGROUND_END,
ALLBATTLEGROUNDHOOK_ON_BATTLEGROUND_DESTROY,
ALLBATTLEGROUNDHOOK_ON_BATTLEGROUND_CREATE,
ALLBATTLEGROUNDHOOK_END
};
enum BattlegroundBracketId : uint8;
enum BattlegroundTypeId : uint8;
@@ -27,7 +49,7 @@ enum TeamId : uint8;
class AllBattlegroundScript : public ScriptObject
{
protected:
AllBattlegroundScript(const char* name);
AllBattlegroundScript(const char* name, std::vector<uint16> enabledHooks = std::vector<uint16>());
public:
[[nodiscard]] bool IsDatabaseBound() const override { return false; }

23
src/server/game/Scripting/ScriptDefines/AllCommandScript.cpp
View File

@@ -21,24 +21,21 @@
void ScriptMgr::OnHandleDevCommand(Player* player, bool& enable)
{
ExecuteScript<AllCommandScript>([&](AllCommandScript* script)
{
script->OnHandleDevCommand(player, enable);
});
CALL_ENABLED_HOOKS(AllCommandScript, ALLCOMMANDHOOK_ON_HANDLE_DEV_COMMAND, script->OnHandleDevCommand(player, enable));
}
bool ScriptMgr::CanExecuteCommand(ChatHandler& handler, std::string_view cmdStr)
{
auto ret = IsValidBoolScript<AllCommandScript>([&](AllCommandScript* script)
{
return !script->CanExecuteCommand(handler, cmdStr);
});
return ReturnValidBool(ret);
CALL_ENABLED_BOOLEAN_HOOKS(AllCommandScript, ALLCOMMANDHOOK_CAN_EXECUTE_COMMAND, !script->CanExecuteCommand(handler, cmdStr));
}
AllCommandScript::AllCommandScript(const char* name)
: ScriptObject(name)
AllCommandScript::AllCommandScript(const char* name, std::vector<uint16> enabledHooks)
: ScriptObject(name, ALLCOMMANDHOOK_END)
{
ScriptRegistry<AllCommandScript>::AddScript(this);
// If empty - enable all available hooks.
if (enabledHooks.empty())
for (uint16 i = 0; i < ALLCOMMANDHOOK_END; ++i)
enabledHooks.emplace_back(i);
ScriptRegistry<AllCommandScript>::AddScript(this, std::move(enabledHooks));
}

10
src/server/game/Scripting/ScriptDefines/AllCommandScript.h
View File

@@ -19,11 +19,19 @@
#define SCRIPT_OBJECT_ALL_COMMAND_SCRIPT_H_
#include "ScriptObject.h"
#include <vector>
enum AllCommandHook
{
ALLCOMMANDHOOK_ON_HANDLE_DEV_COMMAND,
ALLCOMMANDHOOK_CAN_EXECUTE_COMMAND,
ALLCOMMANDHOOK_END
};
class AllCommandScript : public ScriptObject
{
protected:
AllCommandScript(const char* name);
AllCommandScript(const char* name, std::vector<uint16> enabledHooks = std::vector<uint16>());
public:
[[nodiscard]] bool IsDatabaseBound() const override { return false; }

111
src/server/game/Scripting/ScriptDefines/AllSpellScript.cpp
View File

@@ -21,147 +21,78 @@
void ScriptMgr::OnCalcMaxDuration(Aura const* aura, int32& maxDuration)
{
ExecuteScript<AllSpellScript>([&](AllSpellScript* script)
{
script->OnCalcMaxDuration(aura, maxDuration);
});
CALL_ENABLED_HOOKS(AllSpellScript, ALLSPELLHOOK_ON_CALC_MAX_DURATION, script->OnCalcMaxDuration(aura, maxDuration));
}
bool ScriptMgr::CanModAuraEffectDamageDone(AuraEffect const* auraEff, Unit* target, AuraApplication const* aurApp, uint8 mode, bool apply)
{
auto ret = IsValidBoolScript<AllSpellScript>([&](AllSpellScript* script)
{
return !script->CanModAuraEffectDamageDone(auraEff, target, aurApp, mode, apply);
});
if (ret && *ret)
{
return false;
}
return true;
CALL_ENABLED_BOOLEAN_HOOKS(AllSpellScript, ALLSPELLHOOK_CAN_MOD_AURA_EFFECT_DAMAGE_DONE, !script->CanModAuraEffectDamageDone(auraEff, target, aurApp, mode, apply));
}
bool ScriptMgr::CanModAuraEffectModDamagePercentDone(AuraEffect const* auraEff, Unit* target, AuraApplication const* aurApp, uint8 mode, bool apply)
{
auto ret = IsValidBoolScript<AllSpellScript>([&](AllSpellScript* script)
{
return !script->CanModAuraEffectModDamagePercentDone(auraEff, target, aurApp, mode, apply);
});
if (ret && *ret)
{
return false;
}
return true;
CALL_ENABLED_BOOLEAN_HOOKS(AllSpellScript, ALLSPELLHOOK_CAN_MOD_AURA_EFFECT_MOD_DAMAGE_PERCENT_DONE, !script->CanModAuraEffectModDamagePercentDone(auraEff, target, aurApp, mode, apply));
}
void ScriptMgr::OnSpellCheckCast(Spell* spell, bool strict, SpellCastResult& res)
{
ExecuteScript<AllSpellScript>([&](AllSpellScript* script)
{
script->OnSpellCheckCast(spell, strict, res);
});
CALL_ENABLED_HOOKS(AllSpellScript, ALLSPELLHOOK_ON_SPELL_CHECK_CAST, script->OnSpellCheckCast(spell, strict, res));
}
bool ScriptMgr::CanPrepare(Spell* spell, SpellCastTargets const* targets, AuraEffect const* triggeredByAura)
{
auto ret = IsValidBoolScript<AllSpellScript>([&](AllSpellScript* script)
{
return !script->CanPrepare(spell, targets, triggeredByAura);
});
if (ret && *ret)
{
return false;
}
return true;
CALL_ENABLED_BOOLEAN_HOOKS(AllSpellScript, ALLSPELLHOOK_CAN_PREPARE, !script->CanPrepare(spell, targets, triggeredByAura));
}
bool ScriptMgr::CanScalingEverything(Spell* spell)
{
auto ret = IsValidBoolScript<AllSpellScript>([&](AllSpellScript* script)
{
return script->CanScalingEverything(spell);
});
if (ret && *ret)
{
return true;
}
return false;
CALL_ENABLED_BOOLEAN_HOOKS_WITH_DEFAULT_FALSE(AllSpellScript, ALLSPELLHOOK_CAN_SCALING_EVERYTHING, script->CanScalingEverything(spell));
}
bool ScriptMgr::CanSelectSpecTalent(Spell* spell)
{
auto ret = IsValidBoolScript<AllSpellScript>([&](AllSpellScript* script)
{
return !script->CanSelectSpecTalent(spell);
});
if (ret && *ret)
{
return false;
}
return true;
CALL_ENABLED_BOOLEAN_HOOKS(AllSpellScript, ALLSPELLHOOK_CAN_SELECT_SPEC_TALENT, !script->CanSelectSpecTalent(spell));
}
void ScriptMgr::OnScaleAuraUnitAdd(Spell* spell, Unit* target, uint32 effectMask, bool checkIfValid, bool implicit, uint8 auraScaleMask, TargetInfo& targetInfo)
{
ExecuteScript<AllSpellScript>([&](AllSpellScript* script)
{
script->OnScaleAuraUnitAdd(spell, target, effectMask, checkIfValid, implicit, auraScaleMask, targetInfo);
});
CALL_ENABLED_HOOKS(AllSpellScript, ALLSPELLHOOK_ON_SCALE_AURA_UNIT_ADD, script->OnScaleAuraUnitAdd(spell, target, effectMask, checkIfValid, implicit, auraScaleMask, targetInfo));
}
void ScriptMgr::OnRemoveAuraScaleTargets(Spell* spell, TargetInfo& targetInfo, uint8 auraScaleMask, bool& needErase)
{
ExecuteScript<AllSpellScript>([&](AllSpellScript* script)
{
script->OnRemoveAuraScaleTargets(spell, targetInfo, auraScaleMask, needErase);
});
CALL_ENABLED_HOOKS(AllSpellScript, ALLSPELLHOOK_ON_REMOVE_AURA_SCALE_TARGETS, script->OnRemoveAuraScaleTargets(spell, targetInfo, auraScaleMask, needErase));
}
void ScriptMgr::OnBeforeAuraRankForLevel(SpellInfo const* spellInfo, SpellInfo const* latestSpellInfo, uint8 level)
{
ExecuteScript<AllSpellScript>([&](AllSpellScript* script)
{
script->OnBeforeAuraRankForLevel(spellInfo, latestSpellInfo, level);
});
CALL_ENABLED_HOOKS(AllSpellScript, ALLSPELLHOOK_ON_BEFORE_AURA_RANK_FOR_LEVEL, script->OnBeforeAuraRankForLevel(spellInfo, latestSpellInfo, level));
}
void ScriptMgr::OnDummyEffect(WorldObject* caster, uint32 spellID, SpellEffIndex effIndex, GameObject* gameObjTarget)
{
ExecuteScript<AllSpellScript>([&](AllSpellScript* script)
{
script->OnDummyEffect(caster, spellID, effIndex, gameObjTarget);
});
CALL_ENABLED_HOOKS(AllSpellScript, ALLSPELLHOOK_ON_DUMMY_EFFECT_GAMEOBJECT, script->OnDummyEffect(caster, spellID, effIndex, gameObjTarget));
}
void ScriptMgr::OnDummyEffect(WorldObject* caster, uint32 spellID, SpellEffIndex effIndex, Creature* creatureTarget)
{
ExecuteScript<AllSpellScript>([&](AllSpellScript* script)
{
script->OnDummyEffect(caster, spellID, effIndex, creatureTarget);
});
CALL_ENABLED_HOOKS(AllSpellScript, ALLSPELLHOOK_ON_DUMMY_EFFECT_CREATURE, script->OnDummyEffect(caster, spellID, effIndex, creatureTarget));
}
void ScriptMgr::OnDummyEffect(WorldObject* caster, uint32 spellID, SpellEffIndex effIndex, Item* itemTarget)
{
ExecuteScript<AllSpellScript>([&](AllSpellScript* script)
{
script->OnDummyEffect(caster, spellID, effIndex, itemTarget);
});
CALL_ENABLED_HOOKS(AllSpellScript, ALLSPELLHOOK_ON_DUMMY_EFFECT_ITEM, script->OnDummyEffect(caster, spellID, effIndex, itemTarget));
}
AllSpellScript::AllSpellScript(char const* name)
: ScriptObject(name)
AllSpellScript::AllSpellScript(char const* name, std::vector<uint16> enabledHooks)
: ScriptObject(name, ALLSPELLHOOK_END)
{
ScriptRegistry<AllSpellScript>::AddScript(this);
// If empty - enable all available hooks.
if (enabledHooks.empty())
for (uint16 i = 0; i < ALLSPELLHOOK_END; ++i)
enabledHooks.emplace_back(i);
ScriptRegistry<AllSpellScript>::AddScript(this, std::move(enabledHooks));
}
template class AC_GAME_API ScriptRegistry<AllSpellScript>;

21
src/server/game/Scripting/ScriptDefines/AllSpellScript.h
View File

@@ -19,6 +19,25 @@
#define SCRIPT_OBJECT_ALL_SPELL_SCRIPT_H_
#include "ScriptObject.h"
#include <vector>
enum AllSpellHook
{
ALLSPELLHOOK_ON_CALC_MAX_DURATION,
ALLSPELLHOOK_CAN_MOD_AURA_EFFECT_DAMAGE_DONE,
ALLSPELLHOOK_CAN_MOD_AURA_EFFECT_MOD_DAMAGE_PERCENT_DONE,
ALLSPELLHOOK_ON_SPELL_CHECK_CAST,
ALLSPELLHOOK_CAN_PREPARE,
ALLSPELLHOOK_CAN_SCALING_EVERYTHING,
ALLSPELLHOOK_CAN_SELECT_SPEC_TALENT,
ALLSPELLHOOK_ON_SCALE_AURA_UNIT_ADD,
ALLSPELLHOOK_ON_REMOVE_AURA_SCALE_TARGETS,
ALLSPELLHOOK_ON_BEFORE_AURA_RANK_FOR_LEVEL,
ALLSPELLHOOK_ON_DUMMY_EFFECT_GAMEOBJECT,
ALLSPELLHOOK_ON_DUMMY_EFFECT_CREATURE,
ALLSPELLHOOK_ON_DUMMY_EFFECT_ITEM,
ALLSPELLHOOK_END
};
enum SpellCastResult : uint8;
enum SpellEffIndex : uint8;
@@ -26,7 +45,7 @@ enum SpellEffIndex : uint8;
class AllSpellScript : public ScriptObject
{
protected:
AllSpellScript(const char* name);
AllSpellScript(const char* name, std::vector<uint16> enabledHooks = std::vector<uint16>());
public:
[[nodiscard]] bool IsDatabaseBound() const override { return false; }

40
src/server/game/Scripting/ScriptDefines/ArenaScript.cpp
View File

@@ -21,46 +21,28 @@
bool ScriptMgr::CanAddMember(ArenaTeam* team, ObjectGuid PlayerGuid)
{
auto ret = IsValidBoolScript<ArenaScript>([&](ArenaScript* script)
{
return !script->CanAddMember(team, PlayerGuid);
});
if (ret && *ret)
{
return false;
}
return true;
CALL_ENABLED_BOOLEAN_HOOKS(ArenaScript, ARENAHOOK_CAN_ADD_MEMBER, !script->CanAddMember(team, PlayerGuid));
}
void ScriptMgr::OnGetPoints(ArenaTeam* team, uint32 memberRating, float& points)
{
ExecuteScript<ArenaScript>([&](ArenaScript* script)
{
script->OnGetPoints(team, memberRating, points);
});
CALL_ENABLED_HOOKS(ArenaScript, ARENAHOOK_ON_GET_POINTS, script->OnGetPoints(team, memberRating, points));
}
bool ScriptMgr::CanSaveToDB(ArenaTeam* team)
{
auto ret = IsValidBoolScript<ArenaScript>([&](ArenaScript* script)
{
return !script->CanSaveToDB(team);
});
if (ret && *ret)
{
return false;
}
return true;
CALL_ENABLED_BOOLEAN_HOOKS(ArenaScript, ARENAHOOK_CAN_SAVE_TO_DB, !script->CanSaveToDB(team));
}
ArenaScript::ArenaScript(const char* name)
: ScriptObject(name)
ArenaScript::ArenaScript(const char* name, std::vector<uint16> enabledHooks)
: ScriptObject(name, ARENAHOOK_END)
{
ScriptRegistry<ArenaScript>::AddScript(this);
// If empty - enable all available hooks.
if (enabledHooks.empty())
for (uint16 i = 0; i < ARENAHOOK_END; ++i)
enabledHooks.emplace_back(i);
ScriptRegistry<ArenaScript>::AddScript(this, std::move(enabledHooks));
}
template class AC_GAME_API ScriptRegistry<ArenaScript>;

11
src/server/game/Scripting/ScriptDefines/ArenaScript.h
View File

@@ -20,12 +20,21 @@
#include "ObjectGuid.h"
#include "ScriptObject.h"
#include <vector>
enum ArenaHook
{
ARENAHOOK_CAN_ADD_MEMBER,
ARENAHOOK_ON_GET_POINTS,
ARENAHOOK_CAN_SAVE_TO_DB,
ARENAHOOK_END
};
class ArenaScript : public ScriptObject
{
protected:
ArenaScript(const char* name);
ArenaScript(const char* name, std::vector<uint16> enabledHooks = std::vector<uint16>());
public:

36
src/server/game/Scripting/ScriptDefines/ArenaTeamScript.cpp
View File

@@ -21,48 +21,38 @@
void ScriptMgr::OnGetSlotByType(const uint32 type, uint8& slot)
{
ExecuteScript<ArenaTeamScript>([&](ArenaTeamScript* script)
{
script->OnGetSlotByType(type, slot);
});
CALL_ENABLED_HOOKS(ArenaTeamScript, ARENATEAMHOOK_ON_GET_SLOT_BY_TYPE, script->OnGetSlotByType(type, slot));
}
void ScriptMgr::OnGetArenaPoints(ArenaTeam* at, float& points)
{
ExecuteScript<ArenaTeamScript>([&](ArenaTeamScript* script)
{
script->OnGetArenaPoints(at, points);
});
CALL_ENABLED_HOOKS(ArenaTeamScript, ARENATEAMHOOK_ON_GET_ARENA_POINTS, script->OnGetArenaPoints(at, points));
}
void ScriptMgr::OnArenaTypeIDToQueueID(const BattlegroundTypeId bgTypeId, const uint8 arenaType, uint32& queueTypeID)
{
ExecuteScript<ArenaTeamScript>([&](ArenaTeamScript* script)
{
script->OnTypeIDToQueueID(bgTypeId, arenaType, queueTypeID);
});
CALL_ENABLED_HOOKS(ArenaTeamScript, ARENATEAMHOOK_ON_TYPEID_TO_QUEUEID, script->OnTypeIDToQueueID(bgTypeId, arenaType, queueTypeID));
}
void ScriptMgr::OnArenaQueueIdToArenaType(const BattlegroundQueueTypeId bgQueueTypeId, uint8& ArenaType)
{
ExecuteScript<ArenaTeamScript>([&](ArenaTeamScript* script)
{
script->OnQueueIdToArenaType(bgQueueTypeId, ArenaType);
});
CALL_ENABLED_HOOKS(ArenaTeamScript, ARENATEAMHOOK_ON_QUEUEID_TO_ARENA_TYPE, script->OnQueueIdToArenaType(bgQueueTypeId, ArenaType));
}
void ScriptMgr::OnSetArenaMaxPlayersPerTeam(const uint8 arenaType, uint32& maxPlayerPerTeam)
{
ExecuteScript<ArenaTeamScript>([&](ArenaTeamScript* script)
{
script->OnSetArenaMaxPlayersPerTeam(arenaType, maxPlayerPerTeam);
});
CALL_ENABLED_HOOKS(ArenaTeamScript, ARENATEAMHOOK_ON_SET_ARENA_MAX_PLAYERS_PER_TEAM, script->OnSetArenaMaxPlayersPerTeam(arenaType, maxPlayerPerTeam));
}
ArenaTeamScript::ArenaTeamScript(const char* name)
: ScriptObject(name)
ArenaTeamScript::ArenaTeamScript(const char* name, std::vector<uint16> enabledHooks)
: ScriptObject(name, ARENATEAMHOOK_END)
{
ScriptRegistry<ArenaTeamScript>::AddScript(this);
// If empty - enable all available hooks.
if (enabledHooks.empty())
for (uint16 i = 0; i < ARENATEAMHOOK_END; ++i)
enabledHooks.emplace_back(i);
ScriptRegistry<ArenaTeamScript>::AddScript(this, std::move(enabledHooks));
}
template class AC_GAME_API ScriptRegistry<ArenaTeamScript>;

13
src/server/game/Scripting/ScriptDefines/ArenaTeamScript.h
View File

@@ -20,11 +20,22 @@
#include "Battleground.h"
#include "ScriptObject.h"
#include <vector>
enum ArenaTeamHook
{
ARENATEAMHOOK_ON_GET_SLOT_BY_TYPE,
ARENATEAMHOOK_ON_GET_ARENA_POINTS,
ARENATEAMHOOK_ON_TYPEID_TO_QUEUEID,
ARENATEAMHOOK_ON_QUEUEID_TO_ARENA_TYPE,
ARENATEAMHOOK_ON_SET_ARENA_MAX_PLAYERS_PER_TEAM,
ARENATEAMHOOK_END
};
class ArenaTeamScript : public ScriptObject
{
protected:
ArenaTeamScript(const char* name);
ArenaTeamScript(const char* name, std::vector<uint16> enabledHooks = std::vector<uint16>());
public:
[[nodiscard]] bool IsDatabaseBound() const override { return false; };

66
src/server/game/Scripting/ScriptDefines/AuctionHouseScript.cpp
View File

@@ -24,10 +24,7 @@ void ScriptMgr::OnAuctionAdd(AuctionHouseObject* ah, AuctionEntry* entry)
ASSERT(ah);
ASSERT(entry);
ExecuteScript<AuctionHouseScript>([&](AuctionHouseScript* script)
{
script->OnAuctionAdd(ah, entry);
});
CALL_ENABLED_HOOKS(AuctionHouseScript, AUCTIONHOUSEHOOK_ON_AUCTION_ADD, script->OnAuctionAdd(ah, entry));
}
void ScriptMgr::OnAuctionRemove(AuctionHouseObject* ah, AuctionEntry* entry)
@@ -35,10 +32,7 @@ void ScriptMgr::OnAuctionRemove(AuctionHouseObject* ah, AuctionEntry* entry)
ASSERT(ah);
ASSERT(entry);
ExecuteScript<AuctionHouseScript>([&](AuctionHouseScript* script)
{
script->OnAuctionRemove(ah, entry);
});
CALL_ENABLED_HOOKS(AuctionHouseScript, AUCTIONHOUSEHOOK_ON_AUCTION_REMOVE, script->OnAuctionRemove(ah, entry));
}
void ScriptMgr::OnAuctionSuccessful(AuctionHouseObject* ah, AuctionEntry* entry)
@@ -46,10 +40,7 @@ void ScriptMgr::OnAuctionSuccessful(AuctionHouseObject* ah, AuctionEntry* entry)
ASSERT(ah);
ASSERT(entry);
ExecuteScript<AuctionHouseScript>([&](AuctionHouseScript* script)
{
script->OnAuctionSuccessful(ah, entry);
});
CALL_ENABLED_HOOKS(AuctionHouseScript, AUCTIONHOUSEHOOK_ON_AUCTION_SUCCESSFUL, script->OnAuctionSuccessful(ah, entry));
}
void ScriptMgr::OnAuctionExpire(AuctionHouseObject* ah, AuctionEntry* entry)
@@ -57,72 +48,53 @@ void ScriptMgr::OnAuctionExpire(AuctionHouseObject* ah, AuctionEntry* entry)
ASSERT(ah);
ASSERT(entry);
ExecuteScript<AuctionHouseScript>([&](AuctionHouseScript* script)
{
script->OnAuctionExpire(ah, entry);
});
CALL_ENABLED_HOOKS(AuctionHouseScript, AUCTIONHOUSEHOOK_ON_AUCTION_EXPIRE, script->OnAuctionExpire(ah, entry));
}
void ScriptMgr::OnBeforeAuctionHouseMgrSendAuctionWonMail(AuctionHouseMgr* auctionHouseMgr, AuctionEntry* auction, Player* bidder, uint32& bidder_accId, bool& sendNotification, bool& updateAchievementCriteria, bool& sendMail)
{
ExecuteScript<AuctionHouseScript>([&](AuctionHouseScript* script)
{
script->OnBeforeAuctionHouseMgrSendAuctionWonMail(auctionHouseMgr, auction, bidder, bidder_accId, sendNotification, updateAchievementCriteria, sendMail);
});
CALL_ENABLED_HOOKS(AuctionHouseScript, AUCTIONHOUSEHOOK_ON_BEFORE_AUCTIONHOUSEMGR_SEND_AUCTION_WON_MAIL, script->OnBeforeAuctionHouseMgrSendAuctionWonMail(auctionHouseMgr, auction, bidder, bidder_accId, sendNotification, updateAchievementCriteria, sendMail));
}
void ScriptMgr::OnBeforeAuctionHouseMgrSendAuctionSalePendingMail(AuctionHouseMgr* auctionHouseMgr, AuctionEntry* auction, Player* owner, uint32& owner_accId, bool& sendMail)
{
ExecuteScript<AuctionHouseScript>([&](AuctionHouseScript* script)
{
script->OnBeforeAuctionHouseMgrSendAuctionSalePendingMail(auctionHouseMgr, auction, owner, owner_accId, sendMail);
});
CALL_ENABLED_HOOKS(AuctionHouseScript, AUCTIONHOUSEHOOK_ON_BEFORE_AUCTIONHOUSEMGR_SEND_AUCTION_SALE_PENDING_MAIL, script->OnBeforeAuctionHouseMgrSendAuctionSalePendingMail(auctionHouseMgr, auction, owner, owner_accId, sendMail));
}
void ScriptMgr::OnBeforeAuctionHouseMgrSendAuctionSuccessfulMail(AuctionHouseMgr* auctionHouseMgr, AuctionEntry* auction, Player* owner, uint32& owner_accId, uint32& profit, bool& sendNotification, bool& updateAchievementCriteria, bool& sendMail)
{
ExecuteScript<AuctionHouseScript>([&](AuctionHouseScript* script)
{
script->OnBeforeAuctionHouseMgrSendAuctionSuccessfulMail(auctionHouseMgr, auction, owner, owner_accId, profit, sendNotification, updateAchievementCriteria, sendMail);
});
CALL_ENABLED_HOOKS(AuctionHouseScript, AUCTIONHOUSEHOOK_ON_BEFORE_AUCTIONHOUSEMGR_SEND_AUCTION_SUCCESSFUL_MAIL, script->OnBeforeAuctionHouseMgrSendAuctionSuccessfulMail(auctionHouseMgr, auction, owner, owner_accId, profit, sendNotification, updateAchievementCriteria, sendMail));
}
void ScriptMgr::OnBeforeAuctionHouseMgrSendAuctionExpiredMail(AuctionHouseMgr* auctionHouseMgr, AuctionEntry* auction, Player* owner, uint32& owner_accId, bool& sendNotification, bool& sendMail)
{
ExecuteScript<AuctionHouseScript>([&](AuctionHouseScript* script)
{
script->OnBeforeAuctionHouseMgrSendAuctionExpiredMail(auctionHouseMgr, auction, owner, owner_accId, sendNotification, sendMail);
});
CALL_ENABLED_HOOKS(AuctionHouseScript, AUCTIONHOUSEHOOK_ON_BEFORE_AUCTIONHOUSEMGR_SEND_AUCTION_EXPIRED_MAIL, script->OnBeforeAuctionHouseMgrSendAuctionExpiredMail(auctionHouseMgr, auction, owner, owner_accId, sendNotification, sendMail));
}
void ScriptMgr::OnBeforeAuctionHouseMgrSendAuctionOutbiddedMail(AuctionHouseMgr* auctionHouseMgr, AuctionEntry* auction, Player* oldBidder, uint32& oldBidder_accId, Player* newBidder, uint32& newPrice, bool& sendNotification, bool& sendMail)
{
ExecuteScript<AuctionHouseScript>([&](AuctionHouseScript* script)
{
script->OnBeforeAuctionHouseMgrSendAuctionOutbiddedMail(auctionHouseMgr, auction, oldBidder, oldBidder_accId, newBidder, newPrice, sendNotification, sendMail);
});
CALL_ENABLED_HOOKS(AuctionHouseScript, AUCTIONHOUSEHOOK_ON_BEFORE_AUCTIONHOUSEMGR_SEND_AUCTION_OUTBIDDED_MAIL, script->OnBeforeAuctionHouseMgrSendAuctionOutbiddedMail(auctionHouseMgr, auction, oldBidder, oldBidder_accId, newBidder, newPrice, sendNotification, sendMail));
}
void ScriptMgr::OnBeforeAuctionHouseMgrSendAuctionCancelledToBidderMail(AuctionHouseMgr* auctionHouseMgr, AuctionEntry* auction, Player* bidder, uint32& bidder_accId, bool& sendMail)
{
ExecuteScript<AuctionHouseScript>([&](AuctionHouseScript* script)
{
script->OnBeforeAuctionHouseMgrSendAuctionCancelledToBidderMail(auctionHouseMgr, auction, bidder, bidder_accId, sendMail);
});
CALL_ENABLED_HOOKS(AuctionHouseScript, AUCTIONHOUSEHOOK_ON_BEFORE_AUCTIONHOUSEMGR_SEND_AUCTION_CANCELLED_TO_BIDDER_MAIL, script->OnBeforeAuctionHouseMgrSendAuctionCancelledToBidderMail(auctionHouseMgr, auction, bidder, bidder_accId, sendMail));
}
void ScriptMgr::OnBeforeAuctionHouseMgrUpdate()
{
ExecuteScript<AuctionHouseScript>([&](AuctionHouseScript* script)
{
script->OnBeforeAuctionHouseMgrUpdate();
});
CALL_ENABLED_HOOKS(AuctionHouseScript, AUCTIONHOUSEHOOK_ON_BEFORE_AUCTIONHOUSEMGR_UPDATE, script->OnBeforeAuctionHouseMgrUpdate());
}
AuctionHouseScript::AuctionHouseScript(const char* name)
: ScriptObject(name)
AuctionHouseScript::AuctionHouseScript(const char* name, std::vector<uint16> enabledHooks)
: ScriptObject(name, AUCTIONHOUSEHOOK_END)
{
ScriptRegistry<AuctionHouseScript>::AddScript(this);
// If empty - enable all available hooks.
if (enabledHooks.empty())
for (uint16 i = 0; i < AUCTIONHOUSEHOOK_END; ++i)
enabledHooks.emplace_back(i);
ScriptRegistry<AuctionHouseScript>::AddScript(this, std::move(enabledHooks));
}
template class AC_GAME_API ScriptRegistry<AuctionHouseScript>;

19
src/server/game/Scripting/ScriptDefines/AuctionHouseScript.h
View File

@@ -19,11 +19,28 @@
#define SCRIPT_OBJECT_AUCTION_HOUSE_SCRIPT_H_
#include "ScriptObject.h"
#include <vector>
enum AuctionHouseHook
{
AUCTIONHOUSEHOOK_ON_AUCTION_ADD,
AUCTIONHOUSEHOOK_ON_AUCTION_REMOVE,
AUCTIONHOUSEHOOK_ON_AUCTION_SUCCESSFUL,
AUCTIONHOUSEHOOK_ON_AUCTION_EXPIRE,
AUCTIONHOUSEHOOK_ON_BEFORE_AUCTIONHOUSEMGR_SEND_AUCTION_WON_MAIL,
AUCTIONHOUSEHOOK_ON_BEFORE_AUCTIONHOUSEMGR_SEND_AUCTION_SALE_PENDING_MAIL,
AUCTIONHOUSEHOOK_ON_BEFORE_AUCTIONHOUSEMGR_SEND_AUCTION_SUCCESSFUL_MAIL,
AUCTIONHOUSEHOOK_ON_BEFORE_AUCTIONHOUSEMGR_SEND_AUCTION_EXPIRED_MAIL,
AUCTIONHOUSEHOOK_ON_BEFORE_AUCTIONHOUSEMGR_SEND_AUCTION_OUTBIDDED_MAIL,
AUCTIONHOUSEHOOK_ON_BEFORE_AUCTIONHOUSEMGR_SEND_AUCTION_CANCELLED_TO_BIDDER_MAIL,
AUCTIONHOUSEHOOK_ON_BEFORE_AUCTIONHOUSEMGR_UPDATE,
AUCTIONHOUSEHOOK_END
};
class AuctionHouseScript : public ScriptObject
{
protected:
AuctionHouseScript(const char* name);
AuctionHouseScript(const char* name, std::vector<uint16> enabledHooks = std::vector<uint16>());
public:
// Called when an auction is added to an auction house.

20
src/server/game/Scripting/ScriptDefines/DatabaseScript.cpp
View File

@@ -36,18 +36,12 @@ bool ScriptMgr::OnDatabasesLoading()
void ScriptMgr::OnAfterDatabasesLoaded(uint32 updateFlags)
{
ExecuteScript<DatabaseScript>([&](DatabaseScript* script)
{
script->OnAfterDatabasesLoaded(updateFlags);
});
CALL_ENABLED_HOOKS(DatabaseScript, DATABASEHOOK_ON_AFTER_DATABASES_LOADED, script->OnAfterDatabasesLoaded(updateFlags));
}
void ScriptMgr::OnAfterDatabaseLoadCreatureTemplates(std::vector<CreatureTemplate*> creatureTemplates)
{
ExecuteScript<DatabaseScript>([&](DatabaseScript* script)
{
script->OnAfterDatabaseLoadCreatureTemplates(creatureTemplates);
});
CALL_ENABLED_HOOKS(DatabaseScript, DATABASEHOOK_ON_AFTER_DATABASE_LOAD_CREATURETEMPLATES, script->OnAfterDatabaseLoadCreatureTemplates(creatureTemplates));
}
void ScriptMgr::OnDatabasesKeepAlive()
@@ -90,9 +84,15 @@ void ScriptMgr::OnDatabaseGetDBRevision(std::string& revision)
});
}
DatabaseScript::DatabaseScript(const char* name) : ScriptObject(name)
DatabaseScript::DatabaseScript(const char* name, std::vector<uint16> enabledHooks)
: ScriptObject(name, DATABASEHOOK_END)
{
ScriptRegistry<DatabaseScript>::AddScript(this);
// If empty - enable all available hooks.
if (enabledHooks.empty())
for (uint16 i = 0; i < DATABASEHOOK_END; ++i)
enabledHooks.emplace_back(i);
ScriptRegistry<DatabaseScript>::AddScript(this, std::move(enabledHooks));
}
template class AC_GAME_API ScriptRegistry<DatabaseScript>;

9
src/server/game/Scripting/ScriptDefines/DatabaseScript.h
View File

@@ -21,11 +21,18 @@
#include "ScriptObject.h"
#include <vector>
enum DatabaseHook
{
DATABASEHOOK_ON_AFTER_DATABASES_LOADED,
DATABASEHOOK_ON_AFTER_DATABASE_LOAD_CREATURETEMPLATES,
DATABASEHOOK_END
};
class DatabaseScript : public ScriptObject
{
protected:
DatabaseScript(const char* name);
DatabaseScript(const char* name, std::vector<uint16> enabledHooks = std::vector<uint16>());
public:

56
src/server/game/Scripting/ScriptDefines/FormulaScript.cpp
View File

@@ -21,42 +21,27 @@
void ScriptMgr::OnHonorCalculation(float& honor, uint8 level, float multiplier)
{
ExecuteScript<FormulaScript>([&](FormulaScript* script)
{
script->OnHonorCalculation(honor, level, multiplier);
});
CALL_ENABLED_HOOKS(FormulaScript, FORMULAHOOK_ON_HONOR_CALCULATION, script->OnHonorCalculation(honor, level, multiplier));
}
void ScriptMgr::OnGrayLevelCalculation(uint8& grayLevel, uint8 playerLevel)
{
ExecuteScript<FormulaScript>([&](FormulaScript* script)
{
script->OnGrayLevelCalculation(grayLevel, playerLevel);
});
CALL_ENABLED_HOOKS(FormulaScript, FORMULAHOOK_ON_GRAY_LEVEL_CALCULATION, script->OnGrayLevelCalculation(grayLevel, playerLevel));
}
void ScriptMgr::OnColorCodeCalculation(XPColorChar& color, uint8 playerLevel, uint8 mobLevel)
{
ExecuteScript<FormulaScript>([&](FormulaScript* script)
{
script->OnColorCodeCalculation(color, playerLevel, mobLevel);
});
CALL_ENABLED_HOOKS(FormulaScript, FORMULAHOOK_ON_COLOR_CODE_CALCULATION, script->OnColorCodeCalculation(color, playerLevel, mobLevel));
}
void ScriptMgr::OnZeroDifferenceCalculation(uint8& diff, uint8 playerLevel)
{
ExecuteScript<FormulaScript>([&](FormulaScript* script)
{
script->OnZeroDifferenceCalculation(diff, playerLevel);
});
CALL_ENABLED_HOOKS(FormulaScript, FORMULAHOOK_ON_ZERO_DIFFERENCE_CALCULATION, script->OnZeroDifferenceCalculation(diff, playerLevel));
}
void ScriptMgr::OnBaseGainCalculation(uint32& gain, uint8 playerLevel, uint8 mobLevel, ContentLevels content)
{
ExecuteScript<FormulaScript>([&](FormulaScript* script)
{
script->OnBaseGainCalculation(gain, playerLevel, mobLevel, content);
});
CALL_ENABLED_HOOKS(FormulaScript, FORMULAHOOK_ON_BASE_GAIN_CALCULATION, script->OnBaseGainCalculation(gain, playerLevel, mobLevel, content));
}
void ScriptMgr::OnGainCalculation(uint32& gain, Player* player, Unit* unit)
@@ -64,40 +49,33 @@ void ScriptMgr::OnGainCalculation(uint32& gain, Player* player, Unit* unit)
ASSERT(player);
ASSERT(unit);
ExecuteScript<FormulaScript>([&](FormulaScript* script)
{
script->OnGainCalculation(gain, player, unit);
});
CALL_ENABLED_HOOKS(FormulaScript, FORMULAHOOK_ON_GAIN_CALCULATION, script->OnGainCalculation(gain, player, unit));
}
void ScriptMgr::OnGroupRateCalculation(float& rate, uint32 count, bool isRaid)
{
ExecuteScript<FormulaScript>([&](FormulaScript* script)
{
script->OnGroupRateCalculation(rate, count, isRaid);
});
CALL_ENABLED_HOOKS(FormulaScript, FORMULAHOOK_ON_GROUP_RATE_CALCULATION, script->OnGroupRateCalculation(rate, count, isRaid));
}
void ScriptMgr::OnAfterArenaRatingCalculation(Battleground* const bg, int32& winnerMatchmakerChange, int32& loserMatchmakerChange, int32& winnerChange, int32& loserChange)
{
ExecuteScript<FormulaScript>([&](FormulaScript* script)
{
script->OnAfterArenaRatingCalculation(bg, winnerMatchmakerChange, loserMatchmakerChange, winnerChange, loserChange);
});
CALL_ENABLED_HOOKS(FormulaScript, FORMULAHOOK_ON_AFTER_ARENA_RATING_CALCULATION, script->OnAfterArenaRatingCalculation(bg, winnerMatchmakerChange, loserMatchmakerChange, winnerChange, loserChange));
}
void ScriptMgr::OnBeforeUpdatingPersonalRating(int32& mod, uint32 type)
{
ExecuteScript<FormulaScript>([&](FormulaScript* script)
{
script->OnBeforeUpdatingPersonalRating(mod, type);
});
CALL_ENABLED_HOOKS(FormulaScript, FORMULAHOOK_ON_BEFORE_UPDATING_PERSONAL_RATING, script->OnBeforeUpdatingPersonalRating(mod, type));
}
FormulaScript::FormulaScript(const char* name)
: ScriptObject(name)
FormulaScript::FormulaScript(const char* name, std::vector<uint16> enabledHooks)
: ScriptObject(name, FORMULAHOOK_END)
{
ScriptRegistry<FormulaScript>::AddScript(this);
// If empty - enable all available hooks.
if (enabledHooks.empty())
for (uint16 i = 0; i < FORMULAHOOK_END; ++i)
enabledHooks.emplace_back(i);
ScriptRegistry<FormulaScript>::AddScript(this, std::move(enabledHooks));
}
template class AC_GAME_API ScriptRegistry<FormulaScript>;

17
src/server/game/Scripting/ScriptDefines/FormulaScript.h
View File

@@ -19,13 +19,28 @@
#define SCRIPT_OBJECT_FORMULA_SCRIPT_H_
#include "ScriptObject.h"
#include <vector>
enum FormulaHook
{
FORMULAHOOK_ON_HONOR_CALCULATION,
FORMULAHOOK_ON_GRAY_LEVEL_CALCULATION,
FORMULAHOOK_ON_COLOR_CODE_CALCULATION,
FORMULAHOOK_ON_ZERO_DIFFERENCE_CALCULATION,
FORMULAHOOK_ON_BASE_GAIN_CALCULATION,
FORMULAHOOK_ON_GAIN_CALCULATION,
FORMULAHOOK_ON_GROUP_RATE_CALCULATION,
FORMULAHOOK_ON_AFTER_ARENA_RATING_CALCULATION,
FORMULAHOOK_ON_BEFORE_UPDATING_PERSONAL_RATING,
FORMULAHOOK_END
};
enum XPColorChar : uint8;
class FormulaScript : public ScriptObject
{
protected:
FormulaScript(const char* name);
FormulaScript(const char* name, std::vector<uint16> enabledHooks = std::vector<uint16>());
public:
// Called after calculating honor.

26
src/server/game/Scripting/ScriptDefines/GameEventScript.cpp
View File

@@ -21,32 +21,28 @@
void ScriptMgr::OnGameEventStart(uint16 EventID)
{
ExecuteScript<GameEventScript>([&](GameEventScript* script)
{
script->OnStart(EventID);
});
CALL_ENABLED_HOOKS(GameEventScript, GAMEEVENTHOOK_ON_START, script->OnStart(EventID));
}
void ScriptMgr::OnGameEventStop(uint16 EventID)
{
ExecuteScript<GameEventScript>([&](GameEventScript* script)
{
script->OnStop(EventID);
});
CALL_ENABLED_HOOKS(GameEventScript, GAMEEVENTHOOK_ON_STOP, script->OnStop(EventID));
}
void ScriptMgr::OnGameEventCheck(uint16 EventID)
{
ExecuteScript<GameEventScript>([&](GameEventScript* script)
{
script->OnEventCheck(EventID);
});
CALL_ENABLED_HOOKS(GameEventScript, GAMEEVENTHOOK_ON_EVENT_CHECK, script->OnEventCheck(EventID));
}
GameEventScript::GameEventScript(const char* name)
: ScriptObject(name)
GameEventScript::GameEventScript(const char* name, std::vector<uint16> enabledHooks)
: ScriptObject(name, GAMEEVENTHOOK_END)
{
ScriptRegistry<GameEventScript>::AddScript(this);
// If empty - enable all available hooks.
if (enabledHooks.empty())
for (uint16 i = 0; i < GAMEEVENTHOOK_END; ++i)
enabledHooks.emplace_back(i);
ScriptRegistry<GameEventScript>::AddScript(this, std::move(enabledHooks));
}
template class AC_GAME_API ScriptRegistry<GameEventScript>;

11
src/server/game/Scripting/ScriptDefines/GameEventScript.h
View File

@@ -19,11 +19,20 @@
#define SCRIPT_OBJECT_GAME_EVENT_SCRIPT_H_
#include "ScriptObject.h"
#include <vector>
enum GameEventHook
{
GAMEEVENTHOOK_ON_START,
GAMEEVENTHOOK_ON_STOP,
GAMEEVENTHOOK_ON_EVENT_CHECK,
GAMEEVENTHOOK_END
};
class GameEventScript : public ScriptObject
{
protected:
GameEventScript(const char* name);
GameEventScript(const char* name, std::vector<uint16> enabledHooks = std::vector<uint16>());
public:
// Runs on start event

161
src/server/game/Scripting/ScriptDefines/GlobalScript.cpp
View File

@@ -26,180 +26,87 @@ void ScriptMgr::OnGlobalItemDelFromDB(CharacterDatabaseTransaction trans, Object
ASSERT(trans);
ASSERT(itemGuid);
ExecuteScript<GlobalScript>([&](GlobalScript* script)
{
script->OnItemDelFromDB(trans, itemGuid);
});
CALL_ENABLED_HOOKS(GlobalScript, GLOBALHOOK_ON_ITEM_DEL_FROM_DB, script->OnItemDelFromDB(trans, itemGuid));
}
void ScriptMgr::OnGlobalMirrorImageDisplayItem(Item const* item, uint32& display)
{
ExecuteScript<GlobalScript>([&](GlobalScript* script)
{
script->OnMirrorImageDisplayItem(item, display);
});
}
void ScriptMgr::OnBeforeUpdateArenaPoints(ArenaTeam* at, std::map<ObjectGuid, uint32>& ap)
{
ExecuteScript<GlobalScript>([&](GlobalScript* script)
{
script->OnBeforeUpdateArenaPoints(at, ap);
});
CALL_ENABLED_HOOKS(GlobalScript, GLOBALHOOK_ON_MIRRORIMAGE_DISPLAY_ITEM, script->OnMirrorImageDisplayItem(item, display));
}
void ScriptMgr::OnAfterRefCount(Player const* player, Loot& loot, bool canRate, uint16 lootMode, LootStoreItem* LootStoreItem, uint32& maxcount, LootStore const& store)
{
ExecuteScript<GlobalScript>([&](GlobalScript* script)
{
script->OnAfterRefCount(player, LootStoreItem, loot, canRate, lootMode, maxcount, store);
});
CALL_ENABLED_HOOKS(GlobalScript, GLOBALHOOK_ON_AFTER_REF_COUNT, script->OnAfterRefCount(player, LootStoreItem, loot, canRate, lootMode, maxcount, store));
}
void ScriptMgr::OnAfterCalculateLootGroupAmount(Player const* player, Loot& loot, uint16 lootMode, uint32& groupAmount, LootStore const& store)
{
ExecuteScript<GlobalScript>([&](GlobalScript* script)
{
script->OnAfterCalculateLootGroupAmount(player, loot, lootMode, groupAmount, store);
});
CALL_ENABLED_HOOKS(GlobalScript, GLOBALHOOK_ON_AFTER_CALCULATE_LOOT_GROUP_AMOUNT, script->OnAfterCalculateLootGroupAmount(player, loot, lootMode, groupAmount, store));
}
void ScriptMgr::OnBeforeDropAddItem(Player const* player, Loot& loot, bool canRate, uint16 lootMode, LootStoreItem* LootStoreItem, LootStore const& store)
{
ExecuteScript<GlobalScript>([&](GlobalScript* script)
{
script->OnBeforeDropAddItem(player, loot, canRate, lootMode, LootStoreItem, store);
});
CALL_ENABLED_HOOKS(GlobalScript, GLOBALHOOK_ON_BEFORE_DROP_ADD_ITEM, script->OnBeforeDropAddItem(player, loot, canRate, lootMode, LootStoreItem, store));
}
bool ScriptMgr::OnItemRoll(Player const* player, LootStoreItem const* lootStoreItem, float& chance, Loot& loot, LootStore const& store)
{
auto ret = IsValidBoolScript<GlobalScript>([&](GlobalScript* script)
{
return !script->OnItemRoll(player, lootStoreItem, chance, loot, store);
});
if (ret && *ret)
{
return false;
}
return true;
CALL_ENABLED_BOOLEAN_HOOKS(GlobalScript, GLOBALHOOK_ON_ITEM_ROLL, !script->OnItemRoll(player, lootStoreItem, chance, loot, store));
}
bool ScriptMgr::OnBeforeLootEqualChanced(Player const* player, LootStoreItemList equalChanced, Loot& loot, LootStore const& store)
{
auto ret = IsValidBoolScript<GlobalScript>([&](GlobalScript* script)
{
return !script->OnBeforeLootEqualChanced(player, equalChanced, loot, store);
});
if (ret && *ret)
{
return false;
}
return true;
CALL_ENABLED_BOOLEAN_HOOKS(GlobalScript, GLOBALHOOK_ON_BEFORE_LOOT_EQUAL_CHANCED, !script->OnBeforeLootEqualChanced(player, equalChanced, loot, store));
}
void ScriptMgr::OnInitializeLockedDungeons(Player* player, uint8& level, uint32& lockData, lfg::LFGDungeonData const* dungeon)
{
ExecuteScript<GlobalScript>([&](GlobalScript* script)
{
script->OnInitializeLockedDungeons(player, level, lockData, dungeon);
});
CALL_ENABLED_HOOKS(GlobalScript, GLOBALHOOK_ON_INITIALIZE_LOCKED_DUNGEONS, script->OnInitializeLockedDungeons(player, level, lockData, dungeon));
}
void ScriptMgr::OnAfterInitializeLockedDungeons(Player* player)
{
ExecuteScript<GlobalScript>([&](GlobalScript* script)
{
script->OnAfterInitializeLockedDungeons(player);
});
CALL_ENABLED_HOOKS(GlobalScript, GLOBALHOOK_ON_AFTER_INITIALIZE_LOCKED_DUNGEONS, script->OnAfterInitializeLockedDungeons(player));
}
void ScriptMgr::OnBeforeUpdateArenaPoints(ArenaTeam* at, std::map<ObjectGuid, uint32>& ap)
{
CALL_ENABLED_HOOKS(GlobalScript, GLOBALHOOK_ON_BEFORE_UPDATE_ARENA_POINTS, script->OnBeforeUpdateArenaPoints(at, ap));
}
void ScriptMgr::OnAfterUpdateEncounterState(Map* map, EncounterCreditType type, uint32 creditEntry, Unit* source, Difficulty difficulty_fixed, DungeonEncounterList const* encounters, uint32 dungeonCompleted, bool updated)
{
ExecuteScript<GlobalScript>([&](GlobalScript* script)
{
script->OnAfterUpdateEncounterState(map, type, creditEntry, source, difficulty_fixed, encounters, dungeonCompleted, updated);
});
CALL_ENABLED_HOOKS(GlobalScript, GLOBALHOOK_ON_AFTER_UPDATE_ENCOUNTER_STATE, script->OnAfterUpdateEncounterState(map, type, creditEntry, source, difficulty_fixed, encounters, dungeonCompleted, updated));
}
void ScriptMgr::OnBeforeWorldObjectSetPhaseMask(WorldObject const* worldObject, uint32& oldPhaseMask, uint32& newPhaseMask, bool& useCombinedPhases, bool& update)
{
ExecuteScript<GlobalScript>([&](GlobalScript* script)
{
script->OnBeforeWorldObjectSetPhaseMask(worldObject, oldPhaseMask, newPhaseMask, useCombinedPhases, update);
});
CALL_ENABLED_HOOKS(GlobalScript, GLOBALHOOK_ON_BEFORE_WORLDOBJECT_SET_PHASEMASK, script->OnBeforeWorldObjectSetPhaseMask(worldObject, oldPhaseMask, newPhaseMask, useCombinedPhases, update));
}
bool ScriptMgr::OnIsAffectedBySpellModCheck(SpellInfo const* affectSpell, SpellInfo const* checkSpell, SpellModifier const* mod)
{
auto ret = IsValidBoolScript<GlobalScript>([&](GlobalScript* script)
{
return !script->OnIsAffectedBySpellModCheck(affectSpell, checkSpell, mod);
});
if (ret && *ret)
{
return false;
}
return true;
CALL_ENABLED_BOOLEAN_HOOKS(GlobalScript, GLOBALHOOK_ON_IS_AFFECTED_BY_SPELL_MOD_CHECK, !script->OnIsAffectedBySpellModCheck(affectSpell, checkSpell, mod));
}
bool ScriptMgr::OnSpellHealingBonusTakenNegativeModifiers(Unit const* target, Unit const* caster, SpellInfo const* spellInfo, float& val)
{
auto ret = IsValidBoolScript<GlobalScript>([&](GlobalScript* script)
{
return script->OnSpellHealingBonusTakenNegativeModifiers(target, caster, spellInfo, val);
});
if (ret && *ret)
{
return true;
}
return false;
CALL_ENABLED_BOOLEAN_HOOKS_WITH_DEFAULT_FALSE(GlobalScript, GLOBALHOOK_ON_SPELL_HEALING_BONUS_TAKEN_NEGATIVE_MODIFIERS, script->OnSpellHealingBonusTakenNegativeModifiers(target, caster, spellInfo, val));
}
void ScriptMgr::OnLoadSpellCustomAttr(SpellInfo* spell)
{
ExecuteScript<GlobalScript>([&](GlobalScript* script)
{
script->OnLoadSpellCustomAttr(spell);
});
CALL_ENABLED_HOOKS(GlobalScript, GLOBALHOOK_ON_LOAD_SPELL_CUSTOM_ATTR, script->OnLoadSpellCustomAttr(spell));
}
bool ScriptMgr::OnAllowedForPlayerLootCheck(Player const* player, ObjectGuid source)
{
auto ret = IsValidBoolScript<GlobalScript>([&](GlobalScript* script)
{
return script->OnAllowedForPlayerLootCheck(player, source);
});
if (ret && *ret)
{
return false;
}
return true;
CALL_ENABLED_BOOLEAN_HOOKS(GlobalScript, GLOBALHOOK_ON_ALLOWED_FOR_PLAYER_LOOT_CHECK, script->OnAllowedForPlayerLootCheck(player, source));
}
bool ScriptMgr::OnAllowedToLootContainerCheck(Player const* player, ObjectGuid source)
{
auto ret = IsValidBoolScript<GlobalScript>([&](GlobalScript* script)
{
return script->OnAllowedToLootContainerCheck(player, source);
});
if (ret && *ret)
{
return false;
}
return true;
CALL_ENABLED_BOOLEAN_HOOKS(GlobalScript, GLOBALHOOK_ON_ALLOWED_TO_LOOT_CONTAINER_CHECK, script->OnAllowedToLootContainerCheck(player, source));
}
/**
@@ -209,10 +116,7 @@ bool ScriptMgr::OnAllowedToLootContainerCheck(Player const* player, ObjectGuid s
*/
void ScriptMgr::OnInstanceIdRemoved(uint32 instanceId)
{
ExecuteScript<GlobalScript>([&](GlobalScript* script)
{
script->OnInstanceIdRemoved(instanceId);
});
CALL_ENABLED_HOOKS(GlobalScript, GLOBALHOOK_ON_INSTANCEID_REMOVED, script->OnInstanceIdRemoved(instanceId));
}
/**
@@ -226,10 +130,7 @@ void ScriptMgr::OnInstanceIdRemoved(uint32 instanceId)
*/
void ScriptMgr::OnBeforeSetBossState(uint32 id, EncounterState newState, EncounterState oldState, Map* instance)
{
ExecuteScript<GlobalScript>([&](GlobalScript* script)
{
script->OnBeforeSetBossState(id, newState, oldState, instance);
});
CALL_ENABLED_HOOKS(GlobalScript, GLOBALHOOK_ON_BEFORE_SET_BOSS_STATE, script->OnBeforeSetBossState(id, newState, oldState, instance));
}
/**
@@ -240,16 +141,18 @@ void ScriptMgr::OnBeforeSetBossState(uint32 id, EncounterState newState, Encount
*/
void ScriptMgr::AfterInstanceGameObjectCreate(Map* instance, GameObject* go)
{
ExecuteScript<GlobalScript>([&](GlobalScript* script)
{
script->AfterInstanceGameObjectCreate(instance, go);
});
CALL_ENABLED_HOOKS(GlobalScript, GLOBALHOOK_AFTER_INSTANCE_GAME_OBJECT_CREATE, script->AfterInstanceGameObjectCreate(instance, go));
}
GlobalScript::GlobalScript(const char* name)
: ScriptObject(name)
GlobalScript::GlobalScript(const char* name, std::vector<uint16> enabledHooks)
: ScriptObject(name, GLOBALHOOK_END)
{
ScriptRegistry<GlobalScript>::AddScript(this);
// If empty - enable all available hooks.
if (enabledHooks.empty())
for (uint16 i = 0; i < GLOBALHOOK_END; ++i)
enabledHooks.emplace_back(i);
ScriptRegistry<GlobalScript>::AddScript(this, std::move(enabledHooks));
}
template class AC_GAME_API ScriptRegistry<GlobalScript>;

28
src/server/game/Scripting/ScriptDefines/GlobalScript.h
View File

@@ -22,12 +22,38 @@
#include "ObjectGuid.h"
#include "ScriptObject.h"
#include <map>
#include <vector>
enum GlobalHook
{
GLOBALHOOK_ON_ITEM_DEL_FROM_DB,
GLOBALHOOK_ON_MIRRORIMAGE_DISPLAY_ITEM,
GLOBALHOOK_ON_AFTER_REF_COUNT,
GLOBALHOOK_ON_AFTER_CALCULATE_LOOT_GROUP_AMOUNT,
GLOBALHOOK_ON_BEFORE_DROP_ADD_ITEM,
GLOBALHOOK_ON_ITEM_ROLL,
GLOBALHOOK_ON_BEFORE_LOOT_EQUAL_CHANCED,
GLOBALHOOK_ON_INITIALIZE_LOCKED_DUNGEONS,
GLOBALHOOK_ON_AFTER_INITIALIZE_LOCKED_DUNGEONS,
GLOBALHOOK_ON_BEFORE_UPDATE_ARENA_POINTS,
GLOBALHOOK_ON_AFTER_UPDATE_ENCOUNTER_STATE,
GLOBALHOOK_ON_BEFORE_WORLDOBJECT_SET_PHASEMASK,
GLOBALHOOK_ON_IS_AFFECTED_BY_SPELL_MOD_CHECK,
GLOBALHOOK_ON_SPELL_HEALING_BONUS_TAKEN_NEGATIVE_MODIFIERS,
GLOBALHOOK_ON_LOAD_SPELL_CUSTOM_ATTR,
GLOBALHOOK_ON_ALLOWED_FOR_PLAYER_LOOT_CHECK,
GLOBALHOOK_ON_ALLOWED_TO_LOOT_CONTAINER_CHECK,
GLOBALHOOK_ON_INSTANCEID_REMOVED,
GLOBALHOOK_ON_BEFORE_SET_BOSS_STATE,
GLOBALHOOK_AFTER_INSTANCE_GAME_OBJECT_CREATE,
GLOBALHOOK_END
};
// following hooks can be used anywhere and are not db bounded
class GlobalScript : public ScriptObject
{
protected:
GlobalScript(const char* name);
GlobalScript(const char* name, std::vector<uint16> enabledHooks = std::vector<uint16>());
public:
// items

53
src/server/game/Scripting/ScriptDefines/GroupScript.cpp
View File

@@ -23,79 +23,56 @@ void ScriptMgr::OnGroupAddMember(Group* group, ObjectGuid guid)
{
ASSERT(group);
ExecuteScript<GroupScript>([&](GroupScript* script)
{
script->OnAddMember(group, guid);
});
CALL_ENABLED_HOOKS(GroupScript, GROUPHOOK_ON_ADD_MEMBER, script->OnAddMember(group, guid));
}
void ScriptMgr::OnGroupInviteMember(Group* group, ObjectGuid guid)
{
ASSERT(group);
ExecuteScript<GroupScript>([&](GroupScript* script)
{
script->OnInviteMember(group, guid);
});
CALL_ENABLED_HOOKS(GroupScript, GROUPHOOK_ON_INVITE_MEMBER, script->OnInviteMember(group, guid));
}
void ScriptMgr::OnGroupRemoveMember(Group* group, ObjectGuid guid, RemoveMethod method, ObjectGuid kicker, const char* reason)
{
ASSERT(group);
ExecuteScript<GroupScript>([&](GroupScript* script)
{
script->OnRemoveMember(group, guid, method, kicker, reason);
});
CALL_ENABLED_HOOKS(GroupScript, GROUPHOOK_ON_REMOVE_MEMBER, script->OnRemoveMember(group, guid, method, kicker, reason));
}
void ScriptMgr::OnGroupChangeLeader(Group* group, ObjectGuid newLeaderGuid, ObjectGuid oldLeaderGuid)
{
ASSERT(group);
ExecuteScript<GroupScript>([&](GroupScript* script)
{
script->OnChangeLeader(group, newLeaderGuid, oldLeaderGuid);
});
CALL_ENABLED_HOOKS(GroupScript, GROUPHOOK_ON_CHANGE_LEADER, script->OnChangeLeader(group, newLeaderGuid, oldLeaderGuid));
}
void ScriptMgr::OnGroupDisband(Group* group)
{
ASSERT(group);
ExecuteScript<GroupScript>([&](GroupScript* script)
{
script->OnDisband(group);
});
CALL_ENABLED_HOOKS(GroupScript, GROUPHOOK_ON_DISBAND, script->OnDisband(group));
}
bool ScriptMgr::CanGroupJoinBattlegroundQueue(Group const* group, Player* member, Battleground const* bgTemplate, uint32 MinPlayerCount, bool isRated, uint32 arenaSlot)
{
auto ret = IsValidBoolScript<GroupScript>([&](GroupScript* script)
{
return !script->CanGroupJoinBattlegroundQueue(group, member, bgTemplate, MinPlayerCount, isRated, arenaSlot);
});
if (ret && *ret)
{
return false;
}
return true;
CALL_ENABLED_BOOLEAN_HOOKS(GroupScript, GROUPHOOK_CAN_GROUP_JOIN_BATTLEGROUND_QUEUE, !script->CanGroupJoinBattlegroundQueue(group, member, bgTemplate, MinPlayerCount, isRated, arenaSlot));
}
void ScriptMgr::OnCreate(Group* group, Player* leader)
{
ExecuteScript<GroupScript>([&](GroupScript* script)
{
script->OnCreate(group, leader);
});
CALL_ENABLED_HOOKS(GroupScript, GROUPHOOK_ON_CREATE, script->OnCreate(group, leader));
}
GroupScript::GroupScript(const char* name)
: ScriptObject(name)
GroupScript::GroupScript(const char* name, std::vector<uint16> enabledHooks)
: ScriptObject(name, GROUPHOOK_END)
{
ScriptRegistry<GroupScript>::AddScript(this);
// If empty - enable all available hooks.
if (enabledHooks.empty())
for (uint16 i = 0; i < GROUPHOOK_END; ++i)
enabledHooks.emplace_back(i);
ScriptRegistry<GroupScript>::AddScript(this, std::move(enabledHooks));
}
template class AC_GAME_API ScriptRegistry<GroupScript>;

15
src/server/game/Scripting/ScriptDefines/GroupScript.h
View File

@@ -20,13 +20,26 @@
#include "ObjectGuid.h"
#include "ScriptObject.h"
#include <vector>
enum GroupHook
{
GROUPHOOK_ON_ADD_MEMBER,
GROUPHOOK_ON_INVITE_MEMBER,
GROUPHOOK_ON_REMOVE_MEMBER,
GROUPHOOK_ON_CHANGE_LEADER,
GROUPHOOK_ON_DISBAND,
GROUPHOOK_CAN_GROUP_JOIN_BATTLEGROUND_QUEUE,
GROUPHOOK_ON_CREATE,
GROUPHOOK_END
};
enum RemoveMethod : uint8;
class GroupScript : public ScriptObject
{
protected:
GroupScript(const char* name);
GroupScript(const char* name, std::vector<uint16> enabledHooks = std::vector<uint16>());
public:
[[nodiscard]] bool IsDatabaseBound() const override { return false; }

81
src/server/game/Scripting/ScriptDefines/GuildScript.cpp
View File

@@ -21,112 +21,73 @@
void ScriptMgr::OnGuildAddMember(Guild* guild, Player* player, uint8& plRank)
{
ExecuteScript<GuildScript>([&](GuildScript* script)
{
script->OnAddMember(guild, player, plRank);
});
CALL_ENABLED_HOOKS(GuildScript, GUILDHOOK_ON_ADD_MEMBER, script->OnAddMember(guild, player, plRank));
}
void ScriptMgr::OnGuildRemoveMember(Guild* guild, Player* player, bool isDisbanding, bool isKicked)
{
ExecuteScript<GuildScript>([&](GuildScript* script)
{
script->OnRemoveMember(guild, player, isDisbanding, isKicked);
});
CALL_ENABLED_HOOKS(GuildScript, GUILDHOOK_ON_REMOVE_MEMBER, script->OnRemoveMember(guild, player, isDisbanding, isKicked));
}
void ScriptMgr::OnGuildMOTDChanged(Guild* guild, const std::string& newMotd)
{
ExecuteScript<GuildScript>([&](GuildScript* script)
{
script->OnMOTDChanged(guild, newMotd);
});
CALL_ENABLED_HOOKS(GuildScript, GUILDHOOK_ON_MOTD_CHANGED, script->OnMOTDChanged(guild, newMotd));
}
void ScriptMgr::OnGuildInfoChanged(Guild* guild, const std::string& newInfo)
{
ExecuteScript<GuildScript>([&](GuildScript* script)
{
script->OnInfoChanged(guild, newInfo);
});
CALL_ENABLED_HOOKS(GuildScript, GUILDHOOK_ON_INFO_CHANGED, script->OnInfoChanged(guild, newInfo));
}
void ScriptMgr::OnGuildCreate(Guild* guild, Player* leader, const std::string& name)
{
ExecuteScript<GuildScript>([&](GuildScript* script)
{
script->OnCreate(guild, leader, name);
});
CALL_ENABLED_HOOKS(GuildScript, GUILDHOOK_ON_CREATE, script->OnCreate(guild, leader, name));
}
void ScriptMgr::OnGuildDisband(Guild* guild)
{
ExecuteScript<GuildScript>([&](GuildScript* script)
{
script->OnDisband(guild);
});
CALL_ENABLED_HOOKS(GuildScript, GUILDHOOK_ON_DISBAND, script->OnDisband(guild));
}
void ScriptMgr::OnGuildMemberWitdrawMoney(Guild* guild, Player* player, uint32& amount, bool isRepair)
{
ExecuteScript<GuildScript>([&](GuildScript* script)
{
script->OnMemberWitdrawMoney(guild, player, amount, isRepair);
});
CALL_ENABLED_HOOKS(GuildScript, GUILDHOOK_ON_MEMBER_WITDRAW_MONEY, script->OnMemberWitdrawMoney(guild, player, amount, isRepair));
}
void ScriptMgr::OnGuildMemberDepositMoney(Guild* guild, Player* player, uint32& amount)
{
ExecuteScript<GuildScript>([&](GuildScript* script)
{
script->OnMemberDepositMoney(guild, player, amount);
});
CALL_ENABLED_HOOKS(GuildScript, GUILDHOOK_ON_MEMBER_DEPOSIT_MONEY, script->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)
void ScriptMgr::OnGuildItemMove(Guild* guild, Player* player, Item* pItem, bool isSrcBank, uint8 srcContainer, uint8 srcSlotId, bool isDestBank, uint8 destContainer, uint8 destSlotId)
{
ExecuteScript<GuildScript>([&](GuildScript* script)
{
script->OnItemMove(guild, player, pItem, isSrcBank, srcContainer, srcSlotId, isDestBank, destContainer, destSlotId);
});
CALL_ENABLED_HOOKS(GuildScript, GUILDHOOK_ON_ITEM_MOVE, script->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)
{
ExecuteScript<GuildScript>([&](GuildScript* script)
{
script->OnEvent(guild, eventType, playerGuid1, playerGuid2, newRank);
});
CALL_ENABLED_HOOKS(GuildScript, GUILDHOOK_ON_EVENT, script->OnEvent(guild, eventType, playerGuid1, playerGuid2, newRank));
}
void ScriptMgr::OnGuildBankEvent(Guild* guild, uint8 eventType, uint8 tabId, ObjectGuid::LowType playerGuid, uint32 itemOrMoney, uint16 itemStackCount, uint8 destTabId)
{
ExecuteScript<GuildScript>([&](GuildScript* script)
{
script->OnBankEvent(guild, eventType, tabId, playerGuid, itemOrMoney, itemStackCount, destTabId);
});
CALL_ENABLED_HOOKS(GuildScript, GUILDHOOK_ON_BANK_EVENT, script->OnBankEvent(guild, eventType, tabId, playerGuid, itemOrMoney, itemStackCount, destTabId));
}
bool ScriptMgr::CanGuildSendBankList(Guild const* guild, WorldSession* session, uint8 tabId, bool sendAllSlots)
{
auto ret = IsValidBoolScript<GuildScript>([&](GuildScript* script)
{
return !script->CanGuildSendBankList(guild, session, tabId, sendAllSlots);
});
if (ret && *ret)
{
return false;
}
return true;
CALL_ENABLED_BOOLEAN_HOOKS(GuildScript, GUILDHOOK_CAN_GUILD_SEND_BANK_LIST, !script->CanGuildSendBankList(guild, session, tabId, sendAllSlots));
}
GuildScript::GuildScript(const char* name)
: ScriptObject(name)
GuildScript::GuildScript(const char* name, std::vector<uint16> enabledHooks)
: ScriptObject(name, GUILDHOOK_END)
{
ScriptRegistry<GuildScript>::AddScript(this);
// If empty - enable all available hooks.
if (enabledHooks.empty())
for (uint16 i = 0; i < GUILDHOOK_END; ++i)
enabledHooks.emplace_back(i);
ScriptRegistry<GuildScript>::AddScript(this, std::move(enabledHooks));
}
template class AC_GAME_API ScriptRegistry<GuildScript>;

23
src/server/game/Scripting/ScriptDefines/GuildScript.h
View File

@@ -20,11 +20,29 @@
#include "ObjectGuid.h"
#include "ScriptObject.h"
#include <vector>
enum GuildHook
{
GUILDHOOK_ON_ADD_MEMBER,
GUILDHOOK_ON_REMOVE_MEMBER,
GUILDHOOK_ON_MOTD_CHANGED,
GUILDHOOK_ON_INFO_CHANGED,
GUILDHOOK_ON_CREATE,
GUILDHOOK_ON_DISBAND,
GUILDHOOK_ON_MEMBER_WITDRAW_MONEY,
GUILDHOOK_ON_MEMBER_DEPOSIT_MONEY,
GUILDHOOK_ON_ITEM_MOVE,
GUILDHOOK_ON_EVENT,
GUILDHOOK_ON_BANK_EVENT,
GUILDHOOK_CAN_GUILD_SEND_BANK_LIST,
GUILDHOOK_END
};
class GuildScript : public ScriptObject
{
protected:
GuildScript(const char* name);
GuildScript(const char* name, std::vector<uint16> enabledHooks = std::vector<uint16>());
public:
[[nodiscard]] bool IsDatabaseBound() const override { return false; }
@@ -54,8 +72,7 @@ public:
virtual void OnMemberDepositMoney(Guild* /*guild*/, Player* /*player*/, uint32& /*amount*/) { }
// Called when a guild member moves an item in a guild bank.
virtual void OnItemMove(Guild* /*guild*/, Player* /*player*/, Item* /*pItem*/, bool /*isSrcBank*/, uint8 /*srcContainer*/, uint8 /*srcSlotId*/,
bool /*isDestBank*/, uint8 /*destContainer*/, uint8 /*destSlotId*/) { }
virtual void OnItemMove(Guild* /*guild*/, Player* /*player*/, Item* /*pItem*/, bool /*isSrcBank*/, uint8 /*srcContainer*/, uint8 /*srcSlotId*/, bool /*isDestBank*/, uint8 /*destContainer*/, uint8 /*destSlotId*/) { }
virtual void OnEvent(Guild* /*guild*/, uint8 /*eventType*/, ObjectGuid::LowType /*playerGuid1*/, ObjectGuid::LowType /*playerGuid2*/, uint8 /*newRank*/) { }

15
src/server/game/Scripting/ScriptDefines/LootScript.cpp
View File

@@ -23,13 +23,16 @@ void ScriptMgr::OnLootMoney(Player* player, uint32 gold)
{
ASSERT(player);
ExecuteScript<LootScript>([&](LootScript* script)
{
script->OnLootMoney(player, gold);
});
CALL_ENABLED_HOOKS(LootScript, LOOTHOOK_ON_LOOT_MONEY, script->OnLootMoney(player, gold));
}
LootScript::LootScript(const char* name) : ScriptObject(name)
LootScript::LootScript(const char* name, std::vector<uint16> enabledHooks)
: ScriptObject(name, LOOTHOOK_END)
{
ScriptRegistry<LootScript>::AddScript(this);
// If empty - enable all available hooks.
if (enabledHooks.empty())
for (uint16 i = 0; i < LOOTHOOK_END; ++i)
enabledHooks.emplace_back(i);
ScriptRegistry<LootScript>::AddScript(this, std::move(enabledHooks));
}

9
src/server/game/Scripting/ScriptDefines/LootScript.h
View File

@@ -19,11 +19,18 @@
#define SCRIPT_OBJECT_LOOT_SCRIPT_H_
#include "ScriptObject.h"
#include <vector>
enum LootHook
{
LOOTHOOK_ON_LOOT_MONEY,
LOOTHOOK_END
};
class LootScript : public ScriptObject
{
protected:
LootScript(const char* name);
LootScript(const char* name, std::vector<uint16> enabledHooks = std::vector<uint16>());
public:
[[nodiscard]] bool IsDatabaseBound() const override { return false; }

16
src/server/game/Scripting/ScriptDefines/MailScript.cpp
View File

@@ -21,16 +21,18 @@
void ScriptMgr::OnBeforeMailDraftSendMailTo(MailDraft* mailDraft, MailReceiver const& receiver, MailSender const& sender, MailCheckMask& checked, uint32& deliver_delay, uint32& custom_expiration, bool& deleteMailItemsFromDB, bool& sendMail)
{
ExecuteScript<MailScript>([&](MailScript* script)
{
script->OnBeforeMailDraftSendMailTo(mailDraft, receiver, sender, checked, deliver_delay, custom_expiration, deleteMailItemsFromDB, sendMail);\
});
CALL_ENABLED_HOOKS(MailScript, MAILHOOK_ON_BEFORE_MAIL_DRAFT_SEND_MAIL_TO, script->OnBeforeMailDraftSendMailTo(mailDraft, receiver, sender, checked, deliver_delay, custom_expiration, deleteMailItemsFromDB, sendMail));
}
MailScript::MailScript(const char* name)
: ScriptObject(name)
MailScript::MailScript(const char* name, std::vector<uint16> enabledHooks)
: ScriptObject(name, MAILHOOK_END)
{
ScriptRegistry<MailScript>::AddScript(this);
// If empty - enable all available hooks.
if (enabledHooks.empty())
for (uint16 i = 0; i < MAILHOOK_END; ++i)
enabledHooks.emplace_back(i);
ScriptRegistry<MailScript>::AddScript(this, std::move(enabledHooks));
}
template class AC_GAME_API ScriptRegistry<MailScript>;

9
src/server/game/Scripting/ScriptDefines/MailScript.h
View File

@@ -19,11 +19,18 @@
#define SCRIPT_OBJECT_MAIL_SCRIPT_H_
#include "ScriptObject.h"
#include <vector>
enum MailHook
{
MAILHOOK_ON_BEFORE_MAIL_DRAFT_SEND_MAIL_TO,
MAILHOOK_END
};
class MailScript : public ScriptObject
{
protected:
MailScript(const char* name);
MailScript(const char* name, std::vector<uint16> enabledHooks = std::vector<uint16>());
public:
// Called before mail is sent

146
src/server/game/Scripting/ScriptDefines/MiscScript.cpp
View File

@@ -19,175 +19,105 @@
#include "ScriptMgr.h"
#include "ScriptMgrMacros.h"
void ScriptMgr::OnItemCreate(Item* item, ItemTemplate const* itemProto, Player const* owner)
{
ExecuteScript<MiscScript>([&](MiscScript* script)
{
script->OnItemCreate(item, itemProto, owner);
});
}
bool ScriptMgr::CanApplySoulboundFlag(Item* item, ItemTemplate const* proto)
{
auto ret = IsValidBoolScript<MiscScript>([&](MiscScript* script)
{
return !script->CanApplySoulboundFlag(item, proto);
});
if (ret && *ret)
{
return false;
}
return true;
}
void ScriptMgr::OnConstructObject(Object* origin)
{
ExecuteScript<MiscScript>([&](MiscScript* script)
{
script->OnConstructObject(origin);
});
CALL_ENABLED_HOOKS(MiscScript, MISCHOOK_ON_CONSTRUCT_OBJECT, script->OnConstructObject(origin));
}
void ScriptMgr::OnDestructObject(Object* origin)
{
ExecuteScript<MiscScript>([&](MiscScript* script)
{
script->OnDestructObject(origin);
});
CALL_ENABLED_HOOKS(MiscScript, MISCHOOK_ON_DESTRUCT_OBJECT, script->OnDestructObject(origin));
}
void ScriptMgr::OnConstructPlayer(Player* origin)
{
ExecuteScript<MiscScript>([&](MiscScript* script)
{
script->OnConstructPlayer(origin);
});
CALL_ENABLED_HOOKS(MiscScript, MISCHOOK_ON_CONSTRUCT_PLAYER, script->OnConstructPlayer(origin));
}
void ScriptMgr::OnDestructPlayer(Player* origin)
{
ExecuteScript<MiscScript>([&](MiscScript* script)
{
script->OnDestructPlayer(origin);
});
CALL_ENABLED_HOOKS(MiscScript, MISCHOOK_ON_DESTRUCT_PLAYER, script->OnDestructPlayer(origin));
}
void ScriptMgr::OnConstructGroup(Group* origin)
{
ExecuteScript<MiscScript>([&](MiscScript* script)
{
script->OnConstructGroup(origin);
});
CALL_ENABLED_HOOKS(MiscScript, MISCHOOK_ON_CONSTRUCT_GROUP, script->OnConstructGroup(origin));
}
void ScriptMgr::OnDestructGroup(Group* origin)
{
ExecuteScript<MiscScript>([&](MiscScript* script)
{
script->OnDestructGroup(origin);
});
CALL_ENABLED_HOOKS(MiscScript, MISCHOOK_ON_DESTRUCT_GROUP, script->OnDestructGroup(origin));
}
void ScriptMgr::OnConstructInstanceSave(InstanceSave* origin)
{
ExecuteScript<MiscScript>([&](MiscScript* script)
{
script->OnConstructInstanceSave(origin);
});
CALL_ENABLED_HOOKS(MiscScript, MISCHOOK_ON_CONSTRUCT_INSTANCE_SAVE, script->OnConstructInstanceSave(origin));
}
void ScriptMgr::OnDestructInstanceSave(InstanceSave* origin)
{
ExecuteScript<MiscScript>([&](MiscScript* script)
{
script->OnDestructInstanceSave(origin);
});
CALL_ENABLED_HOOKS(MiscScript, MISCHOOK_ON_DESTRUCT_INSTANCE_SAVE, script->OnDestructInstanceSave(origin));
}
void ScriptMgr::OnItemCreate(Item* item, ItemTemplate const* itemProto, Player const* owner)
{
CALL_ENABLED_HOOKS(MiscScript, MISCHOOK_ON_ITEM_CREATE, script->OnItemCreate(item, itemProto, owner));
}
bool ScriptMgr::CanApplySoulboundFlag(Item* item, ItemTemplate const* proto)
{
CALL_ENABLED_BOOLEAN_HOOKS(MiscScript, MISCHOOK_CAN_APPLY_SOULBOUND_FLAG, !script->CanApplySoulboundFlag(item, proto));
}
bool ScriptMgr::CanItemApplyEquipSpell(Player* player, Item* item)
{
auto ret = IsValidBoolScript<MiscScript>([&](MiscScript* script)
{
return !script->CanItemApplyEquipSpell(player, item);
});
if (ret && *ret)
{
return false;
}
return true;
CALL_ENABLED_BOOLEAN_HOOKS(MiscScript, MISCHOOK_CAN_ITEM_APPLY_EQUIP_SPELL, !script->CanItemApplyEquipSpell(player, item));
}
bool ScriptMgr::CanSendAuctionHello(WorldSession const* session, ObjectGuid guid, Creature* creature)
{
auto ret = IsValidBoolScript<MiscScript>([&](MiscScript* script)
{
return !script->CanSendAuctionHello(session, guid, creature);
});
if (ret && *ret)
{
return false;
}
return true;
CALL_ENABLED_BOOLEAN_HOOKS(MiscScript, MISCHOOK_CAN_SEND_AUCTIONHELLO, !script->CanSendAuctionHello(session, guid, creature));
}
void ScriptMgr::ValidateSpellAtCastSpell(Player* player, uint32& oldSpellId, uint32& spellId, uint8& castCount, uint8& castFlags)
{
ExecuteScript<MiscScript>([&](MiscScript* script)
{
script->ValidateSpellAtCastSpell(player, oldSpellId, spellId, castCount, castFlags);
});
CALL_ENABLED_HOOKS(MiscScript, MISCHOOK_VALIDATE_SPELL_AT_CAST_SPELL, script->ValidateSpellAtCastSpell(player, oldSpellId, spellId, castCount, castFlags));
}
void ScriptMgr::ValidateSpellAtCastSpellResult(Player* player, Unit* mover, Spell* spell, uint32 oldSpellId, uint32 spellId)
{
ExecuteScript<MiscScript>([&](MiscScript* script)
{
script->ValidateSpellAtCastSpellResult(player, mover, spell, oldSpellId, spellId);
});
CALL_ENABLED_HOOKS(MiscScript, MISCHOOK_VALIDATE_SPELL_AT_CAST_SPELL_RESULT, script->ValidateSpellAtCastSpellResult(player, mover, spell, oldSpellId, spellId));
}
void ScriptMgr::OnAfterLootTemplateProcess(Loot* loot, LootTemplate const* tab, LootStore const& store, Player* lootOwner, bool personal, bool noEmptyError, uint16 lootMode)
{
ExecuteScript<MiscScript>([&](MiscScript* script)
{
script->OnAfterLootTemplateProcess(loot, tab, store, lootOwner, personal, noEmptyError, lootMode);
});
}
void ScriptMgr::OnInstanceSave(InstanceSave* instanceSave)
{
ExecuteScript<MiscScript>([&](MiscScript* script)
{
script->OnInstanceSave(instanceSave);
});
CALL_ENABLED_HOOKS(MiscScript, MISCHOOK_ON_AFTER_LOOT_TEMPLATE_PROCESS, script->OnAfterLootTemplateProcess(loot, tab, store, lootOwner, personal, noEmptyError, lootMode));
}
void ScriptMgr::OnPlayerSetPhase(const AuraEffect* auraEff, AuraApplication const* aurApp, uint8 mode, bool apply, uint32& newPhase)
{
ExecuteScript<MiscScript>([&](MiscScript* script)
{
script->OnPlayerSetPhase(auraEff, aurApp, mode, apply, newPhase);
});
CALL_ENABLED_HOOKS(MiscScript, MISCHOOK_ON_PLAYER_SET_PHASE, script->OnPlayerSetPhase(auraEff, aurApp, mode, apply, newPhase));
}
void ScriptMgr::OnInstanceSave(InstanceSave* instanceSave)
{
CALL_ENABLED_HOOKS(MiscScript, MISCHOOK_ON_INSTANCE_SAVE, script->OnInstanceSave(instanceSave));
}
void ScriptMgr::GetDialogStatus(Player* player, Object* questgiver)
{
ExecuteScript<MiscScript>([&](MiscScript* script)
{
script->GetDialogStatus(player, questgiver);
});
CALL_ENABLED_HOOKS(MiscScript, MISCHOOK_GET_DIALOG_STATUS, script->GetDialogStatus(player, questgiver));
}
MiscScript::MiscScript(const char* name)
: ScriptObject(name)
MiscScript::MiscScript(const char* name, std::vector<uint16> enabledHooks)
: ScriptObject(name, MISCHOOK_END)
{
ScriptRegistry<MiscScript>::AddScript(this);
// If empty - enable all available hooks.
if (enabledHooks.empty())
for (uint16 i = 0; i < MISCHOOK_END; ++i)
enabledHooks.emplace_back(i);
ScriptRegistry<MiscScript>::AddScript(this, std::move(enabledHooks));
}
template class AC_GAME_API ScriptRegistry<MiscScript>;

26
src/server/game/Scripting/ScriptDefines/MiscScript.h
View File

@@ -20,11 +20,35 @@
#include "ObjectGuid.h"
#include "ScriptObject.h"
#include <vector>
enum MiscHook
{
MISCHOOK_ON_CONSTRUCT_OBJECT,
MISCHOOK_ON_DESTRUCT_OBJECT,
MISCHOOK_ON_CONSTRUCT_PLAYER,
MISCHOOK_ON_DESTRUCT_PLAYER,
MISCHOOK_ON_CONSTRUCT_GROUP,
MISCHOOK_ON_DESTRUCT_GROUP,
MISCHOOK_ON_CONSTRUCT_INSTANCE_SAVE,
MISCHOOK_ON_DESTRUCT_INSTANCE_SAVE,
MISCHOOK_ON_ITEM_CREATE,
MISCHOOK_CAN_APPLY_SOULBOUND_FLAG,
MISCHOOK_CAN_ITEM_APPLY_EQUIP_SPELL,
MISCHOOK_CAN_SEND_AUCTIONHELLO,
MISCHOOK_VALIDATE_SPELL_AT_CAST_SPELL,
MISCHOOK_VALIDATE_SPELL_AT_CAST_SPELL_RESULT,
MISCHOOK_ON_AFTER_LOOT_TEMPLATE_PROCESS,
MISCHOOK_ON_PLAYER_SET_PHASE,
MISCHOOK_ON_INSTANCE_SAVE,
MISCHOOK_GET_DIALOG_STATUS,
MISCHOOK_END
};
class MiscScript : public ScriptObject
{
protected:
MiscScript(const char* name);
MiscScript(const char* name, std::vector<uint16> enabledHooks = std::vector<uint16>());
public:
[[nodiscard]] bool IsDatabaseBound() const override { return false; }

16
src/server/game/Scripting/ScriptDefines/MovementHandlerScript.cpp
View File

@@ -21,16 +21,18 @@
void ScriptMgr::OnPlayerMove(Player* player, MovementInfo movementInfo, uint32 opcode)
{
ExecuteScript<MovementHandlerScript>([&](MovementHandlerScript* script)
{
script->OnPlayerMove(player, movementInfo, opcode);
});
CALL_ENABLED_HOOKS(MovementHandlerScript, MOVEMENTHOOK_ON_PLAYER_MOVE, script->OnPlayerMove(player, movementInfo, opcode));
}
MovementHandlerScript::MovementHandlerScript(const char* name) :
ScriptObject(name)
MovementHandlerScript::MovementHandlerScript(const char* name, std::vector<uint16> enabledHooks) :
ScriptObject(name, MOVEMENTHOOK_END)
{
ScriptRegistry<MovementHandlerScript>::AddScript(this);
// If empty - enable all available hooks.
if (enabledHooks.empty())
for (uint16 i = 0; i < MOVEMENTHOOK_END; ++i)
enabledHooks.emplace_back(i);
ScriptRegistry<MovementHandlerScript>::AddScript(this, std::move(enabledHooks));
}
template class AC_GAME_API ScriptRegistry<MovementHandlerScript>;

9
src/server/game/Scripting/ScriptDefines/MovementHandlerScript.h
View File

@@ -20,11 +20,18 @@
#include "Object.h"
#include "ScriptObject.h"
#include <vector>
enum MovementHook
{
MOVEMENTHOOK_ON_PLAYER_MOVE,
MOVEMENTHOOK_END
};
class MovementHandlerScript : public ScriptObject
{
protected:
MovementHandlerScript(const char* name);
MovementHandlerScript(const char* name, std::vector<uint16> enabledHooks = std::vector<uint16>());
public:
//Called whenever a player moves

62
src/server/game/Scripting/ScriptDefines/PetScript.cpp
View File

@@ -21,79 +21,45 @@
void ScriptMgr::OnInitStatsForLevel(Guardian* guardian, uint8 petlevel)
{
ExecuteScript<PetScript>([&](PetScript* script)
{
script->OnInitStatsForLevel(guardian, petlevel);
});
CALL_ENABLED_HOOKS(PetScript, PETHOOK_ON_INIT_STATS_FOR_LEVEL, script->OnInitStatsForLevel(guardian, petlevel));
}
void ScriptMgr::OnCalculateMaxTalentPointsForLevel(Pet* pet, uint8 level, uint8& points)
{
ExecuteScript<PetScript>([&](PetScript* script)
{
script->OnCalculateMaxTalentPointsForLevel(pet, level, points);
});
CALL_ENABLED_HOOKS(PetScript, PETHOOK_ON_CALCULATE_MAX_TALENT_POINTS_FOR_LEVEL, script->OnCalculateMaxTalentPointsForLevel(pet, level, points));
}
bool ScriptMgr::CanUnlearnSpellSet(Pet* pet, uint32 level, uint32 spell)
{
auto ret = IsValidBoolScript<PetScript>([&](PetScript* script)
{
return !script->CanUnlearnSpellSet(pet, level, spell);
});
if (ret && *ret)
{
return false;
}
return true;
CALL_ENABLED_BOOLEAN_HOOKS(PetScript, PETHOOK_CAN_UNLEARN_SPELL_SET, !script->CanUnlearnSpellSet(pet, level, spell));
}
bool ScriptMgr::CanUnlearnSpellDefault(Pet* pet, SpellInfo const* spellInfo)
{
auto ret = IsValidBoolScript<PetScript>([&](PetScript* script)
{
return !script->CanUnlearnSpellDefault(pet, spellInfo);
});
if (ret && *ret)
{
return false;
}
return true;
CALL_ENABLED_BOOLEAN_HOOKS(PetScript, PETHOOK_CAN_UNLEARN_SPELL_DEFAULT, !script->CanUnlearnSpellDefault(pet, spellInfo));
}
bool ScriptMgr::CanResetTalents(Pet* pet)
{
auto ret = IsValidBoolScript<PetScript>([&](PetScript* script)
{
return !script->CanResetTalents(pet);
});
if (ret && *ret)
{
return false;
}
return true;
CALL_ENABLED_BOOLEAN_HOOKS(PetScript, PETHOOK_CAN_RESET_TALENTS, !script->CanResetTalents(pet));
}
void ScriptMgr::OnPetAddToWorld(Pet* pet)
{
ASSERT(pet);
ExecuteScript<PetScript>([&](PetScript* script)
{
script->OnPetAddToWorld(pet);
});
CALL_ENABLED_HOOKS(PetScript, PETHOOK_ON_PET_ADD_TO_WORLD, script->OnPetAddToWorld(pet));
}
PetScript::PetScript(const char* name)
: ScriptObject(name)
PetScript::PetScript(const char* name, std::vector<uint16> enabledHooks)
: ScriptObject(name, PETHOOK_END)
{
ScriptRegistry<PetScript>::AddScript(this);
// If empty - enable all available hooks.
if (enabledHooks.empty())
for (uint16 i = 0; i < PETHOOK_END; ++i)
enabledHooks.emplace_back(i);
ScriptRegistry<PetScript>::AddScript(this, std::move(enabledHooks));
}
template class AC_GAME_API ScriptRegistry<PetScript>;

14
src/server/game/Scripting/ScriptDefines/PetScript.h
View File

@@ -19,11 +19,23 @@
#define SCRIPT_OBJECT_PET_SCRIPT_H_
#include "ScriptObject.h"
#include <vector>
enum PetHook
{
PETHOOK_ON_INIT_STATS_FOR_LEVEL,
PETHOOK_ON_CALCULATE_MAX_TALENT_POINTS_FOR_LEVEL,
PETHOOK_CAN_UNLEARN_SPELL_SET,
PETHOOK_CAN_UNLEARN_SPELL_DEFAULT,
PETHOOK_CAN_RESET_TALENTS,
PETHOOK_ON_PET_ADD_TO_WORLD,
PETHOOK_END
};
class PetScript : public ScriptObject
{
protected:
PetScript(const char* name);
PetScript(const char* name, std::vector<uint16> enabledHooks = std::vector<uint16>());
public:
[[nodiscard]] bool IsDatabaseBound() const override { return false; }

1235
src/server/game/Scripting/ScriptDefines/PlayerScript.cpp
View File

File diff suppressed because it is too large Load Diff

180
src/server/game/Scripting/ScriptDefines/PlayerScript.h
View File

@@ -19,15 +19,193 @@
#define SCRIPT_OBJECT_PLAYER_SCRIPT_H_
#include "ScriptObject.h"
#include <vector>
// TODO to remove
#include "AchievementMgr.h"
#include "KillRewarder.h"
enum PlayerHook
{
PLAYERHOOK_ON_PLAYER_JUST_DIED,
PLAYERHOOK_ON_PLAYER_RELEASED_GHOST,
PLAYERHOOK_ON_SEND_INITIAL_PACKETS_BEFORE_ADD_TO_MAP,
PLAYERHOOK_ON_BATTLEGROUND_DESERTION,
PLAYERHOOK_ON_PLAYER_COMPLETE_QUEST,
PLAYERHOOK_ON_PVP_KILL,
PLAYERHOOK_ON_PLAYER_PVP_FLAG_CHANGE,
PLAYERHOOK_ON_CREATURE_KILL,
PLAYERHOOK_ON_CREATURE_KILLED_BY_PET,
PLAYERHOOK_ON_PLAYER_KILLED_BY_CREATURE,
PLAYERHOOK_ON_LEVEL_CHANGED,
PLAYERHOOK_ON_FREE_TALENT_POINTS_CHANGED,
PLAYERHOOK_ON_TALENTS_RESET,
PLAYERHOOK_ON_AFTER_SPEC_SLOT_CHANGED,
PLAYERHOOK_ON_BEFORE_UPDATE,
PLAYERHOOK_ON_UPDATE,
PLAYERHOOK_ON_MONEY_CHANGED,
PLAYERHOOK_ON_BEFORE_LOOT_MONEY,
PLAYERHOOK_ON_GIVE_EXP,
PLAYERHOOK_ON_REPUTATION_CHANGE,
PLAYERHOOK_ON_REPUTATION_RANK_CHANGE,
PLAYERHOOK_ON_LEARN_SPELL,
PLAYERHOOK_ON_FORGOT_SPELL,
PLAYERHOOK_ON_DUEL_REQUEST,
PLAYERHOOK_ON_DUEL_START,
PLAYERHOOK_ON_DUEL_END,
PLAYERHOOK_ON_CHAT,
PLAYERHOOK_ON_BEFORE_SEND_CHAT_MESSAGE,
PLAYERHOOK_ON_CHAT_WITH_RECEIVER,
PLAYERHOOK_ON_CHAT_WITH_GROUP,
PLAYERHOOK_ON_CHAT_WITH_GUILD,
PLAYERHOOK_ON_CHAT_WITH_CHANNEL,
PLAYERHOOK_ON_EMOTE,
PLAYERHOOK_ON_TEXT_EMOTE,
PLAYERHOOK_ON_SPELL_CAST,
PLAYERHOOK_ON_LOAD_FROM_DB,
PLAYERHOOK_ON_LOGIN,
PLAYERHOOK_ON_BEFORE_LOGOUT,
PLAYERHOOK_ON_LOGOUT,
PLAYERHOOK_ON_CREATE,
PLAYERHOOK_ON_DELETE,
PLAYERHOOK_ON_FAILED_DELETE,
PLAYERHOOK_ON_SAVE,
PLAYERHOOK_ON_BIND_TO_INSTANCE,
PLAYERHOOK_ON_UPDATE_ZONE,
PLAYERHOOK_ON_UPDATE_AREA,
PLAYERHOOK_ON_MAP_CHANGED,
PLAYERHOOK_ON_BEFORE_TELEPORT,
PLAYERHOOK_ON_UPDATE_FACTION,
PLAYERHOOK_ON_ADD_TO_BATTLEGROUND,
PLAYERHOOK_ON_QUEUE_RANDOM_DUNGEON,
PLAYERHOOK_ON_REMOVE_FROM_BATTLEGROUND,
PLAYERHOOK_ON_ACHI_COMPLETE,
PLAYERHOOK_ON_BEFORE_ACHI_COMPLETE,
PLAYERHOOK_ON_CRITERIA_PROGRESS,
PLAYERHOOK_ON_BEFORE_CRITERIA_PROGRESS,
PLAYERHOOK_ON_ACHI_SAVE,
PLAYERHOOK_ON_CRITERIA_SAVE,
PLAYERHOOK_ON_GOSSIP_SELECT,
PLAYERHOOK_ON_GOSSIP_SELECT_CODE,
PLAYERHOOK_ON_BEING_CHARMED,
PLAYERHOOK_ON_AFTER_SET_VISIBLE_ITEM_SLOT,
PLAYERHOOK_ON_AFTER_MOVE_ITEM_FROM_INVENTORY,
PLAYERHOOK_ON_EQUIP,
PLAYERHOOK_ON_PLAYER_JOIN_BG,
PLAYERHOOK_ON_PLAYER_JOIN_ARENA,
PLAYERHOOK_GET_CUSTOM_GET_ARENA_TEAM_ID,
PLAYERHOOK_GET_CUSTOM_ARENA_PERSONAL_RATING,
PLAYERHOOK_ON_GET_MAX_PERSONAL_ARENA_RATING_REQUIREMENT,
PLAYERHOOK_ON_LOOT_ITEM,
PLAYERHOOK_ON_BEFORE_FILL_QUEST_LOOT_ITEM,
PLAYERHOOK_ON_STORE_NEW_ITEM,
PLAYERHOOK_ON_CREATE_ITEM,
PLAYERHOOK_ON_QUEST_REWARD_ITEM,
PLAYERHOOK_CAN_PLACE_AUCTION_BID,
PLAYERHOOK_ON_GROUP_ROLL_REWARD_ITEM,
PLAYERHOOK_ON_BEFORE_OPEN_ITEM,
PLAYERHOOK_ON_BEFORE_QUEST_COMPLETE,
PLAYERHOOK_ON_QUEST_COMPUTE_EXP,
PLAYERHOOK_ON_BEFORE_DURABILITY_REPAIR,
PLAYERHOOK_ON_BEFORE_BUY_ITEM_FROM_VENDOR,
PLAYERHOOK_ON_BEFORE_STORE_OR_EQUIP_NEW_ITEM,
PLAYERHOOK_ON_AFTER_STORE_OR_EQUIP_NEW_ITEM,
PLAYERHOOK_ON_AFTER_UPDATE_MAX_POWER,
PLAYERHOOK_ON_AFTER_UPDATE_MAX_HEALTH,
PLAYERHOOK_ON_BEFORE_UPDATE_ATTACK_POWER_AND_DAMAGE,
PLAYERHOOK_ON_AFTER_UPDATE_ATTACK_POWER_AND_DAMAGE,
PLAYERHOOK_ON_BEFORE_INIT_TALENT_FOR_LEVEL,
PLAYERHOOK_ON_FIRST_LOGIN,
PLAYERHOOK_ON_SET_MAX_LEVEL,
PLAYERHOOK_CAN_JOIN_IN_BATTLEGROUND_QUEUE,
PLAYERHOOK_SHOULD_BE_REWARDED_WITH_MONEY_INSTEAD_OF_EXP,
PLAYERHOOK_ON_BEFORE_TEMP_SUMMON_INIT_STATS,
PLAYERHOOK_ON_BEFORE_GUARDIAN_INIT_STATS_FOR_LEVEL,
PLAYERHOOK_ON_AFTER_GUARDIAN_INIT_STATS_FOR_LEVEL,
PLAYERHOOK_ON_BEFORE_LOAD_PET_FROM_DB,
PLAYERHOOK_CAN_JOIN_IN_ARENA_QUEUE,
PLAYERHOOK_CAN_BATTLEFIELD_PORT,
PLAYERHOOK_CAN_GROUP_INVITE,
PLAYERHOOK_CAN_GROUP_ACCEPT,
PLAYERHOOK_CAN_SELL_ITEM,
PLAYERHOOK_CAN_SEND_MAIL,
PLAYERHOOK_PETITION_BUY,
PLAYERHOOK_PETITION_SHOW_LIST,
PLAYERHOOK_ON_REWARD_KILL_REWARDER,
PLAYERHOOK_CAN_GIVE_MAIL_REWARD_AT_GIVE_LEVEL,
PLAYERHOOK_ON_DELETE_FROM_DB,
PLAYERHOOK_CAN_REPOP_AT_GRAVEYARD,
PLAYERHOOK_ON_PLAYER_IS_CLASS,
PLAYERHOOK_ON_GET_MAX_SKILL_VALUE,
PLAYERHOOK_ON_PLAYER_HAS_ACTIVE_POWER_TYPE,
PLAYERHOOK_ON_UPDATE_GATHERING_SKILL,
PLAYERHOOK_ON_UPDATE_CRAFTING_SKILL,
PLAYERHOOK_ON_UPDATE_FISHING_SKILL,
PLAYERHOOK_CAN_AREA_EXPLORE_AND_OUTDOOR,
PLAYERHOOK_ON_VICTIM_REWARD_BEFORE,
PLAYERHOOK_ON_VICTIM_REWARD_AFTER,
PLAYERHOOK_ON_CUSTOM_SCALING_STAT_VALUE_BEFORE,
PLAYERHOOK_ON_CUSTOM_SCALING_STAT_VALUE,
PLAYERHOOK_CAN_ARMOR_DAMAGE_MODIFIER,
PLAYERHOOK_ON_GET_FERAL_AP_BONUS,
PLAYERHOOK_CAN_APPLY_WEAPON_DEPENDENT_AURA_DAMAGE_MOD,
PLAYERHOOK_CAN_APPLY_EQUIP_SPELL,
PLAYERHOOK_CAN_APPLY_EQUIP_SPELLS_ITEM_SET,
PLAYERHOOK_CAN_CAST_ITEM_COMBAT_SPELL,
PLAYERHOOK_CAN_CAST_ITEM_USE_SPELL,
PLAYERHOOK_ON_APPLY_AMMO_BONUSES,
PLAYERHOOK_CAN_EQUIP_ITEM,
PLAYERHOOK_CAN_UNEQUIP_ITEM,
PLAYERHOOK_CAN_USE_ITEM,
PLAYERHOOK_CAN_SAVE_EQUIP_NEW_ITEM,
PLAYERHOOK_CAN_APPLY_ENCHANTMENT,
PLAYERHOOK_PASSED_QUEST_KILLED_MONSTER_CREDIT,
PLAYERHOOK_CHECK_ITEM_IN_SLOT_AT_LOAD_INVENTORY,
PLAYERHOOK_NOT_AVOID_SATISFY,
PLAYERHOOK_NOT_VISIBLE_GLOBALLY_FOR,
PLAYERHOOK_ON_GET_ARENA_PERSONAL_RATING,
PLAYERHOOK_ON_GET_ARENA_TEAM_ID,
PLAYERHOOK_ON_IS_FFA_PVP,
PLAYERHOOK_ON_FFA_PVP_STATE_UPDATE,
PLAYERHOOK_ON_IS_PVP,
PLAYERHOOK_ON_GET_MAX_SKILL_VALUE_FOR_LEVEL,
PLAYERHOOK_NOT_SET_ARENA_TEAM_INFO_FIELD,
PLAYERHOOK_CAN_JOIN_LFG,
PLAYERHOOK_CAN_ENTER_MAP,
PLAYERHOOK_CAN_INIT_TRADE,
PLAYERHOOK_CAN_SET_TRADE_ITEM,
PLAYERHOOK_ON_SET_SERVER_SIDE_VISIBILITY,
PLAYERHOOK_ON_SET_SERVER_SIDE_VISIBILITY_DETECT,
PLAYERHOOK_ON_PLAYER_RESURRECT,
PLAYERHOOK_ON_BEFORE_CHOOSE_GRAVEYARD,
PLAYERHOOK_CAN_PLAYER_USE_CHAT,
PLAYERHOOK_CAN_PLAYER_USE_PRIVATE_CHAT,
PLAYERHOOK_CAN_PLAYER_USE_GROUP_CHAT,
PLAYERHOOK_CAN_PLAYER_USE_GUILD_CHAT,
PLAYERHOOK_CAN_PLAYER_USE_CHANNEL_CHAT,
PLAYERHOOK_ON_PLAYER_LEARN_TALENTS,
PLAYERHOOK_ON_PLAYER_ENTER_COMBAT,
PLAYERHOOK_ON_PLAYER_LEAVE_COMBAT,
PLAYERHOOK_ON_QUEST_ABANDON,
PLAYERHOOK_ON_GET_QUEST_RATE,
PLAYERHOOK_ON_CAN_PLAYER_FLY_IN_ZONE,
PLAYERHOOK_ANTICHEAT_SET_CAN_FLY_BY_SERVER,
PLAYERHOOK_ANTICHEAT_SET_UNDER_ACK_MOUNT,
PLAYERHOOK_ANTICHEAT_SET_ROOT_ACK_UPD,
PLAYERHOOK_ANTICHEAT_SET_JUMPING_BY_OPCODE,
PLAYERHOOK_ANTICHEAT_UPDATE_MOVEMENT_INFO,
PLAYERHOOK_ANTICHEAT_HANDLE_DOUBLE_JUMP,
PLAYERHOOK_ANTICHEAT_CHECK_MOVEMENT_INFO,
PLAYERHOOK_CAN_SEND_ERROR_ALREADY_LOOTED,
PLAYERHOOK_ON_AFTER_CREATURE_LOOT,
PLAYERHOOK_ON_AFTER_CREATURE_LOOT_MONEY,
PLAYERHOOK_END
};
class PlayerScript : public ScriptObject
{
protected:
PlayerScript(const char* name);
PlayerScript(const char* name, std::vector<uint16> enabledHooks = std::vector<uint16>());
public:
// Called when a player dies

73
src/server/game/Scripting/ScriptDefines/ServerScript.cpp
View File

@@ -21,58 +21,26 @@
void ScriptMgr::OnNetworkStart()
{
ExecuteScript<ServerScript>([&](ServerScript* script)
{
script->OnNetworkStart();
});
CALL_ENABLED_HOOKS(ServerScript, SERVERHOOK_ON_NETWORK_START, script->OnNetworkStart());
}
void ScriptMgr::OnNetworkStop()
{
ExecuteScript<ServerScript>([&](ServerScript* script)
{
script->OnNetworkStop();
});
CALL_ENABLED_HOOKS(ServerScript, SERVERHOOK_ON_NETWORK_STOP, script->OnNetworkStop());
}
void ScriptMgr::OnSocketOpen(std::shared_ptr<WorldSocket> socket)
{
ASSERT(socket);
ExecuteScript<ServerScript>([&](ServerScript* script)
{
script->OnSocketOpen(socket);
});
CALL_ENABLED_HOOKS(ServerScript, SERVERHOOK_ON_SOCKET_OPEN, script->OnSocketOpen(socket));
}
void ScriptMgr::OnSocketClose(std::shared_ptr<WorldSocket> socket)
{
ASSERT(socket);
ExecuteScript<ServerScript>([&](ServerScript* script)
{
script->OnSocketClose(socket);
});
}
bool ScriptMgr::CanPacketReceive(WorldSession* session, WorldPacket const& packet)
{
if (ScriptRegistry<ServerScript>::ScriptPointerList.empty())
return true;
WorldPacket copy(packet);
auto ret = IsValidBoolScript<ServerScript>([&](ServerScript* script)
{
return !script->CanPacketReceive(session, copy);
});
if (ret && *ret)
{
return false;
}
return true;
CALL_ENABLED_HOOKS(ServerScript, SERVERHOOK_ON_SOCKET_CLOSE, script->OnSocketClose(socket));
}
void ScriptMgr::OnPacketReceived(WorldSession* session, WorldPacket const& packet)
@@ -93,23 +61,28 @@ bool ScriptMgr::CanPacketSend(WorldSession* session, WorldPacket const& packet)
WorldPacket copy(packet);
auto ret = IsValidBoolScript<ServerScript>([&](ServerScript* script)
{
return !script->CanPacketSend(session, copy);
});
if (ret && *ret)
{
return false;
}
return true;
CALL_ENABLED_BOOLEAN_HOOKS(ServerScript, SERVERHOOK_CAN_PACKET_SEND, !script->CanPacketSend(session, copy));
}
ServerScript::ServerScript(const char* name)
: ScriptObject(name)
bool ScriptMgr::CanPacketReceive(WorldSession* session, WorldPacket const& packet)
{
ScriptRegistry<ServerScript>::AddScript(this);
if (ScriptRegistry<ServerScript>::ScriptPointerList.empty())
return true;
WorldPacket copy(packet);
CALL_ENABLED_BOOLEAN_HOOKS(ServerScript, SERVERHOOK_CAN_PACKET_RECEIVE, !script->CanPacketReceive(session, copy));
}
ServerScript::ServerScript(const char* name, std::vector<uint16> enabledHooks)
: ScriptObject(name, SERVERHOOK_END)
{
// If empty - enable all available hooks.
if (enabledHooks.empty())
for (uint16 i = 0; i < SERVERHOOK_END; ++i)
enabledHooks.emplace_back(i);
ScriptRegistry<ServerScript>::AddScript(this, std::move(enabledHooks));
}
template class AC_GAME_API ScriptRegistry<ServerScript>;

14
src/server/game/Scripting/ScriptDefines/ServerScript.h
View File

@@ -19,11 +19,23 @@
#define SCRIPT_OBJECT_SERVER_SCRIPT_H_
#include "ScriptObject.h"
#include <vector>
enum ServerHook
{
SERVERHOOK_ON_NETWORK_START,
SERVERHOOK_ON_NETWORK_STOP,
SERVERHOOK_ON_SOCKET_OPEN,
SERVERHOOK_ON_SOCKET_CLOSE,
SERVERHOOK_CAN_PACKET_SEND,
SERVERHOOK_CAN_PACKET_RECEIVE,
SERVERHOOK_END
};
class ServerScript : public ScriptObject
{
protected:
ServerScript(const char* name);
ServerScript(const char* name, std::vector<uint16> enabledHooks = std::vector<uint16>());
public:
// Called when reactive socket I/O is started (WorldSocketMgr).

327
src/server/game/Scripting/ScriptDefines/UnitScript.cpp
View File

@@ -19,6 +19,36 @@
#include "ScriptMgr.h"
#include "ScriptMgrMacros.h"
void ScriptMgr::OnHeal(Unit* healer, Unit* reciever, uint32& gain)
{
CALL_ENABLED_HOOKS(UnitScript, UNITHOOK_ON_HEAL, script->OnHeal(healer, reciever, gain));
}
void ScriptMgr::OnDamage(Unit* attacker, Unit* victim, uint32& damage)
{
CALL_ENABLED_HOOKS(UnitScript, UNITHOOK_ON_DAMAGE, script->OnDamage(attacker, victim, damage));
}
void ScriptMgr::ModifyPeriodicDamageAurasTick(Unit* target, Unit* attacker, uint32& damage, SpellInfo const* spellInfo)
{
CALL_ENABLED_HOOKS(UnitScript, UNITHOOK_MODIFY_PERIODIC_DAMAGE_AURAS_TICK, script->ModifyPeriodicDamageAurasTick(target, attacker, damage, spellInfo));
}
void ScriptMgr::ModifyMeleeDamage(Unit* target, Unit* attacker, uint32& damage)
{
CALL_ENABLED_HOOKS(UnitScript, UNITHOOK_MODIFY_MELEE_DAMAGE, script->ModifyMeleeDamage(target, attacker, damage));
}
void ScriptMgr::ModifySpellDamageTaken(Unit* target, Unit* attacker, int32& damage, SpellInfo const* spellInfo)
{
CALL_ENABLED_HOOKS(UnitScript, UNITHOOK_MODIFY_SPELL_DAMAGE_TAKEN, script->ModifySpellDamageTaken(target, attacker, damage, spellInfo));
}
void ScriptMgr::ModifyHealReceived(Unit* target, Unit* healer, uint32& heal, SpellInfo const* spellInfo)
{
CALL_ENABLED_HOOKS(UnitScript, UNITHOOK_MODIFY_HEAL_RECEIVED, script->ModifyHealReceived(target, healer, heal, spellInfo));
}
uint32 ScriptMgr::DealDamage(Unit* AttackerUnit, Unit* pVictim, uint32 damage, DamageEffectType damagetype)
{
if (ScriptRegistry<UnitScript>::ScriptPointerList.empty())
@@ -38,231 +68,98 @@ uint32 ScriptMgr::DealDamage(Unit* AttackerUnit, Unit* pVictim, uint32 damage, D
return damage;
}
void ScriptMgr::OnHeal(Unit* healer, Unit* reciever, uint32& gain)
{
ExecuteScript<UnitScript>([&](UnitScript* script)
{
script->OnHeal(healer, reciever, gain);
});
}
void ScriptMgr::OnDamage(Unit* attacker, Unit* victim, uint32& damage)
{
ExecuteScript<UnitScript>([&](UnitScript* script)
{
script->OnDamage(attacker, victim, damage);
});
}
void ScriptMgr::ModifyPeriodicDamageAurasTick(Unit* target, Unit* attacker, uint32& damage, SpellInfo const* spellInfo)
{
ExecuteScript<UnitScript>([&](UnitScript* script)
{
script->ModifyPeriodicDamageAurasTick(target, attacker, damage, spellInfo);
});
}
void ScriptMgr::ModifyMeleeDamage(Unit* target, Unit* attacker, uint32& damage)
{
ExecuteScript<UnitScript>([&](UnitScript* script)
{
script->ModifyMeleeDamage(target, attacker, damage);
});
}
void ScriptMgr::ModifySpellDamageTaken(Unit* target, Unit* attacker, int32& damage, SpellInfo const* spellInfo)
{
ExecuteScript<UnitScript>([&](UnitScript* script)
{
script->ModifySpellDamageTaken(target, attacker, damage, spellInfo);
});
}
void ScriptMgr::ModifyHealReceived(Unit* target, Unit* healer, uint32& heal, SpellInfo const* spellInfo)
{
ExecuteScript<UnitScript>([&](UnitScript* script)
{
script->ModifyHealReceived(target, healer, heal, spellInfo);
});
}
void ScriptMgr::OnBeforeRollMeleeOutcomeAgainst(Unit const* attacker, Unit const* victim, WeaponAttackType attType, int32& attackerMaxSkillValueForLevel, int32& victimMaxSkillValueForLevel, int32& attackerWeaponSkill, int32& victimDefenseSkill, int32& crit_chance, int32& miss_chance, int32& dodge_chance, int32& parry_chance, int32& block_chance)
{
ExecuteScript<UnitScript>([&](UnitScript* script)
{
script->OnBeforeRollMeleeOutcomeAgainst(attacker, victim, attType, attackerMaxSkillValueForLevel, victimMaxSkillValueForLevel, attackerWeaponSkill, victimDefenseSkill, crit_chance, miss_chance, dodge_chance, parry_chance, block_chance);
});
}
void ScriptMgr::OnAuraRemove(Unit* unit, AuraApplication* aurApp, AuraRemoveMode mode)
{
ExecuteScript<UnitScript>([&](UnitScript* script)
{
script->OnAuraRemove(unit, aurApp, mode);
});
}
bool ScriptMgr::IfNormalReaction(Unit const* unit, Unit const* target, ReputationRank& repRank)
{
auto ret = IsValidBoolScript<UnitScript>([&](UnitScript* script)
{
return !script->IfNormalReaction(unit, target, repRank);
});
if (ret && *ret)
{
return false;
}
return true;
}
bool ScriptMgr::IsNeedModSpellDamagePercent(Unit const* unit, AuraEffect* auraEff, float& doneTotalMod, SpellInfo const* spellProto)
{
auto ret = IsValidBoolScript<UnitScript>([&](UnitScript* script)
{
return !script->IsNeedModSpellDamagePercent(unit, auraEff, doneTotalMod, spellProto);
});
if (ret && *ret)
{
return false;
}
return true;
}
bool ScriptMgr::IsNeedModMeleeDamagePercent(Unit const* unit, AuraEffect* auraEff, float& doneTotalMod, SpellInfo const* spellProto)
{
auto ret = IsValidBoolScript<UnitScript>([&](UnitScript* script)
{
return !script->IsNeedModMeleeDamagePercent(unit, auraEff, doneTotalMod, spellProto);
});
if (ret && *ret)
{
return false;
}
return true;
}
bool ScriptMgr::IsNeedModHealPercent(Unit const* unit, AuraEffect* auraEff, float& doneTotalMod, SpellInfo const* spellProto)
{
auto ret = IsValidBoolScript<UnitScript>([&](UnitScript* script)
{
return !script->IsNeedModHealPercent(unit, auraEff, doneTotalMod, spellProto);
});
if (ret && *ret)
{
return false;
}
return true;
}
bool ScriptMgr::CanSetPhaseMask(Unit const* unit, uint32 newPhaseMask, bool update)
{
auto ret = IsValidBoolScript<UnitScript>([&](UnitScript* script)
{
return !script->CanSetPhaseMask(unit, newPhaseMask, update);
});
if (ret && *ret)
{
return false;
}
return true;
}
bool ScriptMgr::IsCustomBuildValuesUpdate(Unit const* unit, uint8 updateType, ByteBuffer& fieldBuffer, Player const* target, uint16 index)
{
auto ret = IsValidBoolScript<UnitScript>([&](UnitScript* script)
{
return script->IsCustomBuildValuesUpdate(unit, updateType, fieldBuffer, target, index);
});
if (ret && *ret)
{
return true;
}
return false;
}
bool ScriptMgr::ShouldTrackValuesUpdatePosByIndex(Unit const* unit, uint8 updateType, uint16 index)
{
auto ret = IsValidBoolScript<UnitScript>([&](UnitScript* script) { return script->ShouldTrackValuesUpdatePosByIndex(unit, updateType, index); });
if (ret && *ret)
return true;
return false;
}
void ScriptMgr::OnPatchValuesUpdate(Unit const* unit, ByteBuffer& valuesUpdateBuf, BuildValuesCachePosPointers& posPointers, Player* target)
{
ExecuteScript<UnitScript>([&](UnitScript* script)
{
script->OnPatchValuesUpdate(unit, valuesUpdateBuf, posPointers, target);
});
}
void ScriptMgr::OnUnitUpdate(Unit* unit, uint32 diff)
{
ExecuteScript<UnitScript>([&](UnitScript* script)
{
script->OnUnitUpdate(unit, diff);
});
}
void ScriptMgr::OnDisplayIdChange(Unit* unit, uint32 displayId)
{
ExecuteScript<UnitScript>([&](UnitScript* script)
{
script->OnDisplayIdChange(unit, displayId);
});
}
void ScriptMgr::OnUnitEnterEvadeMode(Unit* unit, uint8 evadeReason)
{
ExecuteScript<UnitScript>([&](UnitScript* script)
{
script->OnUnitEnterEvadeMode(unit, evadeReason);
});
}
void ScriptMgr::OnUnitEnterCombat(Unit* unit, Unit* victim)
{
ExecuteScript<UnitScript>([&](UnitScript* script)
{
script->OnUnitEnterCombat(unit, victim);
});
}
void ScriptMgr::OnUnitDeath(Unit* unit, Unit* killer)
{
ExecuteScript<UnitScript>([&](UnitScript* script)
{
script->OnUnitDeath(unit, killer);
});
CALL_ENABLED_HOOKS(UnitScript, UNITHOOK_ON_BEFORE_ROLL_MELEE_OUTCOME_AGAINST, script->OnBeforeRollMeleeOutcomeAgainst(attacker, victim, attType, attackerMaxSkillValueForLevel, victimMaxSkillValueForLevel, attackerWeaponSkill, victimDefenseSkill, crit_chance, miss_chance, dodge_chance, parry_chance, block_chance));
}
void ScriptMgr::OnAuraApply(Unit* unit, Aura* aura)
{
ExecuteScript<UnitScript>([&](UnitScript* script)
{
script->OnAuraApply(unit, aura);
});
CALL_ENABLED_HOOKS(UnitScript, UNITHOOK_ON_AURA_APPLY, script->OnAuraApply(unit, aura));
}
UnitScript::UnitScript(const char* name, bool addToScripts) :
ScriptObject(name)
void ScriptMgr::OnAuraRemove(Unit* unit, AuraApplication* aurApp, AuraRemoveMode mode)
{
CALL_ENABLED_HOOKS(UnitScript, UNITHOOK_ON_AURA_REMOVE, script->OnAuraRemove(unit, aurApp, mode));
}
bool ScriptMgr::IfNormalReaction(Unit const* unit, Unit const* target, ReputationRank& repRank)
{
CALL_ENABLED_BOOLEAN_HOOKS(UnitScript, UNITHOOK_IF_NORMAL_REACTION, !script->IfNormalReaction(unit, target, repRank));
}
bool ScriptMgr::IsNeedModSpellDamagePercent(Unit const* unit, AuraEffect* auraEff, float& doneTotalMod, SpellInfo const* spellProto)
{
CALL_ENABLED_BOOLEAN_HOOKS(UnitScript, UNITHOOK_IS_NEEDMOD_SPELL_DAMAGE_PERCENT, !script->IsNeedModSpellDamagePercent(unit, auraEff, doneTotalMod, spellProto));
}
bool ScriptMgr::IsNeedModMeleeDamagePercent(Unit const* unit, AuraEffect* auraEff, float& doneTotalMod, SpellInfo const* spellProto)
{
CALL_ENABLED_BOOLEAN_HOOKS(UnitScript, UNITHOOK_IS_NEEDMOD_MELEE_DAMAGE_PERCENT, !script->IsNeedModMeleeDamagePercent(unit, auraEff, doneTotalMod, spellProto));
}
bool ScriptMgr::IsNeedModHealPercent(Unit const* unit, AuraEffect* auraEff, float& doneTotalMod, SpellInfo const* spellProto)
{
CALL_ENABLED_BOOLEAN_HOOKS(UnitScript, UNITHOOK_IS_NEEDMOD_HEAL_PERCENT, !script->IsNeedModHealPercent(unit, auraEff, doneTotalMod, spellProto));
}
bool ScriptMgr::CanSetPhaseMask(Unit const* unit, uint32 newPhaseMask, bool update)
{
CALL_ENABLED_BOOLEAN_HOOKS(UnitScript, UNITHOOK_CAN_SET_PHASE_MASK, !script->CanSetPhaseMask(unit, newPhaseMask, update));
}
bool ScriptMgr::IsCustomBuildValuesUpdate(Unit const* unit, uint8 updateType, ByteBuffer& fieldBuffer, Player const* target, uint16 index)
{
CALL_ENABLED_BOOLEAN_HOOKS_WITH_DEFAULT_FALSE(UnitScript, UNITHOOK_IS_CUSTOM_BUILD_VALUES_UPDATE, script->IsCustomBuildValuesUpdate(unit, updateType, fieldBuffer, target, index));
}
bool ScriptMgr::ShouldTrackValuesUpdatePosByIndex(Unit const* unit, uint8 updateType, uint16 index)
{
CALL_ENABLED_BOOLEAN_HOOKS_WITH_DEFAULT_FALSE(UnitScript, UNITHOOK_SHOULD_TRACK_VALUES_UPDATE_POS_BY_INDEX, script->ShouldTrackValuesUpdatePosByIndex(unit, updateType, index));
}
void ScriptMgr::OnPatchValuesUpdate(Unit const* unit, ByteBuffer& valuesUpdateBuf, BuildValuesCachePosPointers& posPointers, Player* target)
{
CALL_ENABLED_HOOKS(UnitScript, UNITHOOK_ON_PATCH_VALUES_UPDATE, script->OnPatchValuesUpdate(unit, valuesUpdateBuf, posPointers, target));
}
void ScriptMgr::OnUnitUpdate(Unit* unit, uint32 diff)
{
CALL_ENABLED_HOOKS(UnitScript, UNITHOOK_ON_UNIT_UPDATE, script->OnUnitUpdate(unit, diff));
}
void ScriptMgr::OnDisplayIdChange(Unit* unit, uint32 displayId)
{
CALL_ENABLED_HOOKS(UnitScript, UNITHOOK_ON_DISPLAYID_CHANGE, script->OnDisplayIdChange(unit, displayId));
}
void ScriptMgr::OnUnitEnterEvadeMode(Unit* unit, uint8 evadeReason)
{
CALL_ENABLED_HOOKS(UnitScript, UNITHOOK_ON_UNIT_ENTER_EVADE_MODE, script->OnUnitEnterEvadeMode(unit, evadeReason));
}
void ScriptMgr::OnUnitEnterCombat(Unit* unit, Unit* victim)
{
CALL_ENABLED_HOOKS(UnitScript, UNITHOOK_ON_UNIT_ENTER_COMBAT, script->OnUnitEnterCombat(unit, victim));
}
void ScriptMgr::OnUnitDeath(Unit* unit, Unit* killer)
{
CALL_ENABLED_HOOKS(UnitScript, UNITHOOK_ON_UNIT_DEATH, script->OnUnitDeath(unit, killer));
}
UnitScript::UnitScript(const char* name, bool addToScripts, std::vector<uint16> enabledHooks)
: ScriptObject(name, UNITHOOK_END)
{
if (addToScripts)
ScriptRegistry<UnitScript>::AddScript(this);
{
// If empty - enable all available hooks.
if (enabledHooks.empty())
for (uint16 i = 0; i < UNITHOOK_END; ++i)
enabledHooks.emplace_back(i);
ScriptRegistry<UnitScript>::AddScript(this, std::move(enabledHooks));
}
}
template class AC_GAME_API ScriptRegistry<UnitScript>;

30
src/server/game/Scripting/ScriptDefines/UnitScript.h
View File

@@ -19,6 +19,34 @@
#define SCRIPT_OBJECT_UNIT_SCRIPT_H_
#include "ScriptObject.h"
#include <vector>
enum UnitHook
{
UNITHOOK_ON_HEAL,
UNITHOOK_ON_DAMAGE,
UNITHOOK_MODIFY_PERIODIC_DAMAGE_AURAS_TICK,
UNITHOOK_MODIFY_MELEE_DAMAGE,
UNITHOOK_MODIFY_SPELL_DAMAGE_TAKEN,
UNITHOOK_MODIFY_HEAL_RECEIVED,
UNITHOOK_ON_BEFORE_ROLL_MELEE_OUTCOME_AGAINST,
UNITHOOK_ON_AURA_APPLY,
UNITHOOK_ON_AURA_REMOVE,
UNITHOOK_IF_NORMAL_REACTION,
UNITHOOK_IS_NEEDMOD_SPELL_DAMAGE_PERCENT,
UNITHOOK_IS_NEEDMOD_MELEE_DAMAGE_PERCENT,
UNITHOOK_IS_NEEDMOD_HEAL_PERCENT,
UNITHOOK_CAN_SET_PHASE_MASK,
UNITHOOK_IS_CUSTOM_BUILD_VALUES_UPDATE,
UNITHOOK_SHOULD_TRACK_VALUES_UPDATE_POS_BY_INDEX,
UNITHOOK_ON_PATCH_VALUES_UPDATE,
UNITHOOK_ON_UNIT_UPDATE,
UNITHOOK_ON_DISPLAYID_CHANGE,
UNITHOOK_ON_UNIT_ENTER_EVADE_MODE,
UNITHOOK_ON_UNIT_ENTER_COMBAT,
UNITHOOK_ON_UNIT_DEATH,
UNITHOOK_END
};
enum ReputationRank : uint8;
class ByteBuffer;
@@ -27,7 +55,7 @@ struct BuildValuesCachePosPointers;
class UnitScript : public ScriptObject
{
protected:
UnitScript(const char* name, bool addToScripts = true);
UnitScript(const char* name, bool addToScripts = true, std::vector<uint16> enabledHooks = std::vector<uint16>());
public:
// Called when a unit deals healing to another unit

35
src/server/game/Scripting/ScriptDefines/WorldObjectScript.cpp
View File

@@ -23,55 +23,46 @@ void ScriptMgr::OnWorldObjectDestroy(WorldObject* object)
{
ASSERT(object);
ExecuteScript<WorldObjectScript>([&](WorldObjectScript* script)
{
script->OnWorldObjectDestroy(object);
});
CALL_ENABLED_HOOKS(WorldObjectScript, WORLDOBJECTHOOK_ON_WORLD_OBJECT_DESTROY, script->OnWorldObjectDestroy(object));
}
void ScriptMgr::OnWorldObjectCreate(WorldObject* object)
{
ASSERT(object);
ExecuteScript<WorldObjectScript>([&](WorldObjectScript* script)
{
script->OnWorldObjectCreate(object);
});
CALL_ENABLED_HOOKS(WorldObjectScript, WORLDOBJECTHOOK_ON_WORLD_OBJECT_CREATE, script->OnWorldObjectCreate(object));
}
void ScriptMgr::OnWorldObjectSetMap(WorldObject* object, Map* map)
{
ASSERT(object);
ExecuteScript<WorldObjectScript>([&](WorldObjectScript* script)
{
script->OnWorldObjectSetMap(object, map);
});
CALL_ENABLED_HOOKS(WorldObjectScript, WORLDOBJECTHOOK_ON_WORLD_OBJECT_SET_MAP, script->OnWorldObjectSetMap(object, map));
}
void ScriptMgr::OnWorldObjectResetMap(WorldObject* object)
{
ASSERT(object);
ExecuteScript<WorldObjectScript>([&](WorldObjectScript* script)
{
script->OnWorldObjectResetMap(object);
});
CALL_ENABLED_HOOKS(WorldObjectScript, WORLDOBJECTHOOK_ON_WORLD_OBJECT_RESET_MAP, script->OnWorldObjectResetMap(object));
}
void ScriptMgr::OnWorldObjectUpdate(WorldObject* object, uint32 diff)
{
ASSERT(object);
ExecuteScript<WorldObjectScript>([&](WorldObjectScript* script)
{
script->OnWorldObjectUpdate(object, diff);
});
CALL_ENABLED_HOOKS(WorldObjectScript, WORLDOBJECTHOOK_ON_WORLD_OBJECT_UPDATE, script->OnWorldObjectUpdate(object, diff));
}
WorldObjectScript::WorldObjectScript(const char* name) : ScriptObject(name)
WorldObjectScript::WorldObjectScript(const char* name, std::vector<uint16> enabledHooks)
: ScriptObject(name, WORLDOBJECTHOOK_END)
{
ScriptRegistry<WorldObjectScript>::AddScript(this);
// If empty - enable all available hooks.
if (enabledHooks.empty())
for (uint16 i = 0; i < WORLDOBJECTHOOK_END; ++i)
enabledHooks.emplace_back(i);
ScriptRegistry<WorldObjectScript>::AddScript(this, std::move(enabledHooks));
}
template class AC_GAME_API ScriptRegistry<WorldObjectScript>;

13
src/server/game/Scripting/ScriptDefines/WorldObjectScript.h
View File

@@ -19,11 +19,22 @@
#define SCRIPT_OBJECT_WORLD_OBJECT_SCRIPT_H_
#include "ScriptObject.h"
#include <vector>
enum WorldObjectHook
{
WORLDOBJECTHOOK_ON_WORLD_OBJECT_DESTROY,
WORLDOBJECTHOOK_ON_WORLD_OBJECT_CREATE,
WORLDOBJECTHOOK_ON_WORLD_OBJECT_SET_MAP,
WORLDOBJECTHOOK_ON_WORLD_OBJECT_RESET_MAP,
WORLDOBJECTHOOK_ON_WORLD_OBJECT_UPDATE,
WORLDOBJECTHOOK_END
};
class WorldObjectScript : public ScriptObject
{
protected:
WorldObjectScript(const char* name);
WorldObjectScript(const char* name, std::vector<uint16> enabledHooks = std::vector<uint16>());
public:
[[nodiscard]] bool IsDatabaseBound() const override { return false; }

102
src/server/game/Scripting/ScriptDefines/WorldScript.cpp
View File

@@ -21,112 +21,78 @@
void ScriptMgr::OnOpenStateChange(bool open)
{
ExecuteScript<WorldScript>([&](WorldScript* script)
{
script->OnOpenStateChange(open);
});
}
void ScriptMgr::OnLoadCustomDatabaseTable()
{
ExecuteScript<WorldScript>([&](WorldScript* script)
{
script->OnLoadCustomDatabaseTable();
});
}
void ScriptMgr::OnBeforeConfigLoad(bool reload)
{
ExecuteScript<WorldScript>([&](WorldScript* script)
{
script->OnBeforeConfigLoad(reload);
});
CALL_ENABLED_HOOKS(WorldScript, WORLDHOOK_ON_OPEN_STATE_CHANGE, script->OnOpenStateChange(open));
}
void ScriptMgr::OnAfterConfigLoad(bool reload)
{
ExecuteScript<WorldScript>([&](WorldScript* script)
{
script->OnAfterConfigLoad(reload);
});
CALL_ENABLED_HOOKS(WorldScript, WORLDHOOK_ON_AFTER_CONFIG_LOAD, script->OnAfterConfigLoad(reload));
}
void ScriptMgr::OnBeforeFinalizePlayerWorldSession(uint32& cacheVersion)
void ScriptMgr::OnLoadCustomDatabaseTable()
{
ExecuteScript<WorldScript>([&](WorldScript* script)
{
script->OnBeforeFinalizePlayerWorldSession(cacheVersion);
});
CALL_ENABLED_HOOKS(WorldScript, WORLDHOOK_ON_LOAD_CUSTOM_DATABASE_TABLE, script->OnLoadCustomDatabaseTable());
}
void ScriptMgr::OnBeforeConfigLoad(bool reload)
{
CALL_ENABLED_HOOKS(WorldScript, WORLDHOOK_ON_BEFORE_CONFIG_LOAD, script->OnBeforeConfigLoad(reload));
}
void ScriptMgr::OnMotdChange(std::string& newMotd)
{
ExecuteScript<WorldScript>([&](WorldScript* script)
{
script->OnMotdChange(newMotd);
});
CALL_ENABLED_HOOKS(WorldScript, WORLDHOOK_ON_MOTD_CHANGE, script->OnMotdChange(newMotd));
}
void ScriptMgr::OnShutdownInitiate(ShutdownExitCode code, ShutdownMask mask)
{
ExecuteScript<WorldScript>([&](WorldScript* script)
{
script->OnShutdownInitiate(code, mask);
});
CALL_ENABLED_HOOKS(WorldScript, WORLDHOOK_ON_SHUTDOWN_INITIATE, script->OnShutdownInitiate(code, mask));
}
void ScriptMgr::OnShutdownCancel()
{
ExecuteScript<WorldScript>([&](WorldScript* script)
{
script->OnShutdownCancel();
});
CALL_ENABLED_HOOKS(WorldScript, WORLDHOOK_ON_SHUTDOWN_CANCEL, script->OnShutdownCancel());
}
void ScriptMgr::OnWorldUpdate(uint32 diff)
{
ExecuteScript<WorldScript>([&](WorldScript* script)
{
script->OnUpdate(diff);
});
CALL_ENABLED_HOOKS(WorldScript, WORLDHOOK_ON_UPDATE, script->OnUpdate(diff));
}
void ScriptMgr::OnStartup()
{
ExecuteScript<WorldScript>([&](WorldScript* script)
{
script->OnStartup();
});
CALL_ENABLED_HOOKS(WorldScript, WORLDHOOK_ON_STARTUP, script->OnStartup());
}
void ScriptMgr::OnShutdown()
{
ExecuteScript<WorldScript>([&](WorldScript* script)
{
script->OnShutdown();
});
}
void ScriptMgr::OnBeforeWorldInitialized()
{
ExecuteScript<WorldScript>([&](WorldScript* script)
{
script->OnBeforeWorldInitialized();
});
CALL_ENABLED_HOOKS(WorldScript, WORLDHOOK_ON_SHUTDOWN, script->OnShutdown());
}
void ScriptMgr::OnAfterUnloadAllMaps()
{
ExecuteScript<WorldScript>([](WorldScript* script)
{
script->OnAfterUnloadAllMaps();
});
CALL_ENABLED_HOOKS(WorldScript, WORLDHOOK_ON_AFTER_UNLOAD_ALL_MAPS, script->OnAfterUnloadAllMaps());
}
WorldScript::WorldScript(const char* name) :
ScriptObject(name)
void ScriptMgr::OnBeforeFinalizePlayerWorldSession(uint32& cacheVersion)
{
ScriptRegistry<WorldScript>::AddScript(this);
CALL_ENABLED_HOOKS(WorldScript, WORLDHOOK_ON_BEFORE_FINALIZE_PLAYER_WORLD_SESSION, script->OnBeforeFinalizePlayerWorldSession(cacheVersion));
}
void ScriptMgr::OnBeforeWorldInitialized()
{
CALL_ENABLED_HOOKS(WorldScript, WORLDHOOK_ON_BEFORE_WORLD_INITIALIZED, script->OnBeforeWorldInitialized());
}
WorldScript::WorldScript(const char* name, std::vector<uint16> enabledHooks)
: ScriptObject(name, WORLDHOOK_END)
{
// If empty - enable all available hooks.
if (enabledHooks.empty())
for (uint16 i = 0; i < WORLDHOOK_END; ++i)
enabledHooks.emplace_back(i);
ScriptRegistry<WorldScript>::AddScript(this, std::move(enabledHooks));
}
template class AC_GAME_API ScriptRegistry<WorldScript>;

21
src/server/game/Scripting/ScriptDefines/WorldScript.h
View File

@@ -19,11 +19,30 @@
#define SCRIPT_OBJECT_WORLD_SCRIPT_H_
#include "ScriptObject.h"
#include <vector>
enum WorldHook
{
WORLDHOOK_ON_OPEN_STATE_CHANGE,
WORLDHOOK_ON_AFTER_CONFIG_LOAD,
WORLDHOOK_ON_LOAD_CUSTOM_DATABASE_TABLE,
WORLDHOOK_ON_BEFORE_CONFIG_LOAD,
WORLDHOOK_ON_MOTD_CHANGE,
WORLDHOOK_ON_SHUTDOWN_INITIATE,
WORLDHOOK_ON_SHUTDOWN_CANCEL,
WORLDHOOK_ON_UPDATE,
WORLDHOOK_ON_STARTUP,
WORLDHOOK_ON_SHUTDOWN,
WORLDHOOK_ON_AFTER_UNLOAD_ALL_MAPS,
WORLDHOOK_ON_BEFORE_FINALIZE_PLAYER_WORLD_SESSION,
WORLDHOOK_ON_BEFORE_WORLD_INITIALIZED,
WORLDHOOK_END
};
class WorldScript : public ScriptObject
{
protected:
WorldScript(const char* name);
WorldScript(const char* name, std::vector<uint16> enabledHooks = std::vector<uint16>());
public:
// Called when the open/closed state of the world changes.

25
src/server/game/Scripting/ScriptMgr.cpp
View File

@@ -88,6 +88,31 @@ void ScriptMgr::Initialize()
_script_loader_callback();
_modules_loader_callback();
ScriptRegistry<AccountScript>::InitEnabledHooksIfNeeded(ACCOUNTHOOK_END);
ScriptRegistry<AchievementScript>::InitEnabledHooksIfNeeded(ACHIEVEMENTHOOK_END);
ScriptRegistry<ArenaScript>::InitEnabledHooksIfNeeded(ARENAHOOK_END);
ScriptRegistry<ArenaTeamScript>::InitEnabledHooksIfNeeded(ARENATEAMHOOK_END);
ScriptRegistry<AuctionHouseScript>::InitEnabledHooksIfNeeded(AUCTIONHOUSEHOOK_END);
ScriptRegistry<BGScript>::InitEnabledHooksIfNeeded(ALLBATTLEGROUNDHOOK_END);
ScriptRegistry<CommandSC>::InitEnabledHooksIfNeeded(ALLCOMMANDHOOK_END);
ScriptRegistry<DatabaseScript>::InitEnabledHooksIfNeeded(DATABASEHOOK_END);
ScriptRegistry<FormulaScript>::InitEnabledHooksIfNeeded(FORMULAHOOK_END);
ScriptRegistry<GameEventScript>::InitEnabledHooksIfNeeded(GAMEEVENTHOOK_END);
ScriptRegistry<GlobalScript>::InitEnabledHooksIfNeeded(GLOBALHOOK_END);
ScriptRegistry<GroupScript>::InitEnabledHooksIfNeeded(GROUPHOOK_END);
ScriptRegistry<GuildScript>::InitEnabledHooksIfNeeded(GUILDHOOK_END);
ScriptRegistry<LootScript>::InitEnabledHooksIfNeeded(LOOTHOOK_END);
ScriptRegistry<MailScript>::InitEnabledHooksIfNeeded(MAILHOOK_END);
ScriptRegistry<MiscScript>::InitEnabledHooksIfNeeded(MISCHOOK_END);
ScriptRegistry<MovementHandlerScript>::InitEnabledHooksIfNeeded(MOVEMENTHOOK_END);
ScriptRegistry<PetScript>::InitEnabledHooksIfNeeded(PETHOOK_END);
ScriptRegistry<PlayerScript>::InitEnabledHooksIfNeeded(PLAYERHOOK_END);
ScriptRegistry<ServerScript>::InitEnabledHooksIfNeeded(SERVERHOOK_END);
ScriptRegistry<SpellSC>::InitEnabledHooksIfNeeded(ALLSPELLHOOK_END);
ScriptRegistry<UnitScript>::InitEnabledHooksIfNeeded(UNITHOOK_END);
ScriptRegistry<WorldObjectScript>::InitEnabledHooksIfNeeded(WORLDOBJECTHOOK_END);
ScriptRegistry<WorldScript>::InitEnabledHooksIfNeeded(WORLDHOOK_END);
}
void ScriptMgr::Unload()

41
src/server/game/Scripting/ScriptMgr.h
View File

@@ -764,30 +764,47 @@ public:
typedef std::map<uint32, TScript*> ScriptMap;
typedef typename ScriptMap::iterator ScriptMapIterator;
typedef std::vector<TScript*> ScriptVector;
typedef std::vector<std::pair<TScript*,std::vector<uint16>>> ScriptVector;
typedef typename ScriptVector::iterator ScriptVectorIterator;
typedef std::vector<std::vector<TScript*>> EnabledHooksVector;
typedef typename EnabledHooksVector::iterator EnabledHooksVectorIterator;
// The actual list of scripts. This will be accessed concurrently, so it must not be modified
// after server startup.
static ScriptMap ScriptPointerList;
// After database load scripts
static ScriptVector ALScripts;
// The list of hook types with the list of enabled scripts for this specific hook.
// With this approach, we wouldn't call all available hooks in case if we override just one hook.
static EnabledHooksVector EnabledHooks;
static void AddScript(TScript* const script)
static void InitEnabledHooksIfNeeded(uint16 totalAvailableHooks)
{
EnabledHooks.resize(totalAvailableHooks);
}
static void AddScript(TScript* const script, std::vector<uint16> enabledHooks = {})
{
ASSERT(script);
if (!_checkMemory(script))
return;
if (EnabledHooks.empty())
InitEnabledHooksIfNeeded(script->GetTotalAvailableHooks());
if (script->isAfterLoadScript())
{
ALScripts.push_back(script);
ALScripts.emplace_back(script, std::move(enabledHooks));
}
else
{
script->checkValidity();
for (uint16 v : enabledHooks)
EnabledHooks[v].emplace_back(script);
// We're dealing with a code-only script; just add it.
ScriptPointerList[_scriptIdCounter++] = script;
sScriptMgr->IncreaseScriptCount();
@@ -796,9 +813,9 @@ public:
static void AddALScripts()
{
for(ScriptVectorIterator it = ALScripts.begin(); it != ALScripts.end(); ++it)
for (ScriptVectorIterator it = ALScripts.begin(); it != ALScripts.end(); ++it)
{
TScript* const script = *it;
TScript* const script = (*it).first;
script->checkValidity();
@@ -830,6 +847,14 @@ public:
// If the script is already assigned -> delete it!
if (oldScript)
{
for (auto& vIt : EnabledHooks)
for (size_t i = 0; i < vIt.size(); ++i)
if (vIt[i] == oldScript)
{
vIt.erase(vIt.begin() + i);
break;
}
delete oldScript;
}
@@ -852,6 +877,9 @@ public:
}
else
{
for (uint16 v : (*it).second)
EnabledHooks[v].emplace_back(script);
// We're dealing with a code-only script; just add it.
ScriptPointerList[_scriptIdCounter++] = script;
sScriptMgr->IncreaseScriptCount();
@@ -896,7 +924,8 @@ private:
// Instantiate static members of ScriptRegistry.
template<class TScript> std::map<uint32, TScript*> ScriptRegistry<TScript>::ScriptPointerList;
template<class TScript> std::vector<TScript*> ScriptRegistry<TScript>::ALScripts;
template<class TScript> std::vector<std::pair<TScript*,std::vector<uint16>>> ScriptRegistry<TScript>::ALScripts;
template<class TScript> std::vector<std::vector<TScript*>> ScriptRegistry<TScript>::EnabledHooks;
template<class TScript> uint32 ScriptRegistry<TScript>::_scriptIdCounter = 0;
#endif

16
src/server/game/Scripting/ScriptMgrMacros.h
View File

@@ -69,4 +69,20 @@ inline bool ReturnValidBool(Optional<bool> ret, bool need = false)
return ret && *ret ? need : !need;
}
#define CALL_ENABLED_HOOKS(scriptType, hookType, action) \
if (!ScriptRegistry<scriptType>::EnabledHooks[hookType].empty()) \
for (auto const& script : ScriptRegistry<scriptType>::EnabledHooks[hookType]) { action; }
#define CALL_ENABLED_BOOLEAN_HOOKS(scriptType, hookType, action) \
if (ScriptRegistry<scriptType>::EnabledHooks[hookType].empty()) \
return true; \
for (auto const& script : ScriptRegistry<scriptType>::EnabledHooks[hookType]) { if (action) return false; } \
return true;
#define CALL_ENABLED_BOOLEAN_HOOKS_WITH_DEFAULT_FALSE(scriptType, hookType, action) \
if (ScriptRegistry<scriptType>::EnabledHooks[hookType].empty()) \
return false; \
for (auto const& script : ScriptRegistry<scriptType>::EnabledHooks[hookType]) { if (action) return true; } \
return false;
#endif // _SCRIPT_MGR_MACRO_H_

5
src/server/game/Scripting/ScriptObject.h
View File

@@ -53,8 +53,10 @@ public:
[[nodiscard]] const std::string& GetName() const { return _name; }
[[nodiscard]] uint16 GetTotalAvailableHooks() { return _totalAvailableHooks; }
protected:
ScriptObject(const char* name) : _name(std::string(name))
ScriptObject(const char* name, uint16 totalAvailableHooks = 0) : _name(std::string(name)), _totalAvailableHooks(totalAvailableHooks)
{
}
@@ -62,6 +64,7 @@ protected:
private:
const std::string _name;
const uint16 _totalAvailableHooks;
};
template<class TObject>

1
src/server/game/Spells/SpellInfoCorrections.cpp
View File

@@ -126,7 +126,6 @@ void SpellMgr::LoadSpellInfoCorrections()
ApplySpellFix({
63665, // Charge (Argent Tournament emote on riders)
31298, // Sleep (needs target selection script)
2895, // Wrath of Air Totem rank 1 (Aura)
68933, // Wrath of Air Totem rank 2 (Aura)
29200 // Purify Helboar Meat

1
src/server/game/Spells/SpellMgr.cpp
View File

@@ -3238,7 +3238,6 @@ void SpellMgr::LoadSpellInfoCustomAttributes()
case 57467: // Meteor
case 26789: // Shard of the Fallen Star
case 31436: // Malevolent Cleave
case 35181: // Dive Bomb
case 40810: // Saber Lash
case 43267: // Saber Lash
case 43268: // Saber Lash

109
src/server/scripts/EasternKingdoms/Karazhan/boss_chess_event.cpp
View File

@@ -395,88 +395,85 @@ struct npc_echo_of_medivh : public ScriptedAI
for (uint8 col = 0; col < MAX_COL; ++col)
{
BoardCell const& cell = _boards[row][col];
if (cell.pieceGUID == piece->GetGUID())
if (cell.pieceGUID != piece->GetGUID())
continue;
std::vector<KarazhanChessOrientationType> orientations;
switch (orientation)
{
std::vector<KarazhanChessOrientationType> orientations;
switch (orientation)
case ORI_SE:
orientations = { ORI_NE, ORI_E, ORI_S, ORI_SW };
break;
case ORI_S:
orientations = { ORI_E, ORI_SE, ORI_SW, ORI_W };
break;
case ORI_SW:
orientations = { ORI_SE, ORI_S, ORI_W, ORI_NW };
break;
case ORI_W:
orientations = { ORI_NE, ORI_SW, ORI_NW, ORI_N };
break;
case ORI_NW:
orientations = { ORI_SW, ORI_W, ORI_N, ORI_NE };
break;
case ORI_N:
orientations = { ORI_W, ORI_NW, ORI_NE, ORI_E };
break;
case ORI_NE:
orientations = { ORI_NW, ORI_N, ORI_E, ORI_SE };
break;
case ORI_E:
orientations = { ORI_N, ORI_NE, ORI_SE, ORI_S };
break;
default:
break;
}
for (KarazhanChessOrientationType orient : orientations)
{
uint8 newRow = row;
uint8 newCol = col;
switch (orient)
{
case ORI_SE:
orientations = { ORI_NE, ORI_E, ORI_S, ORI_SW };
newRow -= 1;
break;
case ORI_S:
orientations = { ORI_E, ORI_SE, ORI_SW, ORI_W };
newRow -= 1;
newCol -= 1;
break;
case ORI_SW:
orientations = { ORI_SE, ORI_S, ORI_W, ORI_NW };
newCol -= 1;
break;
case ORI_W:
orientations = { ORI_NE, ORI_SW, ORI_NW, ORI_N };
newRow += 1;
newCol -= 1;
break;
case ORI_NW:
orientations = { ORI_SW, ORI_W, ORI_N, ORI_NE };
newRow += 1;
break;
case ORI_N:
orientations = { ORI_W, ORI_NW, ORI_NE, ORI_E };
newRow += 1;
newCol += 1;
break;
case ORI_NE:
orientations = { ORI_NW, ORI_N, ORI_E, ORI_SE };
newCol += 1;
break;
case ORI_E:
orientations = { ORI_N, ORI_NE, ORI_SE, ORI_S };
newRow -= 1;
newCol += 1;
break;
default:
break;
}
for (KarazhanChessOrientationType orient : orientations)
{
uint8 newRow = row;
uint8 newCol = col;
switch (orient)
{
case ORI_SE:
newRow -= 1;
break;
case ORI_S:
newRow -= 1;
newCol -= 1;
break;
case ORI_SW:
newCol -= 1;
break;
case ORI_W:
newRow += 1;
newCol -= 1;
break;
case ORI_NW:
newRow += 1;
break;
case ORI_N:
newRow += 1;
newCol += 1;
break;
case ORI_NE:
newCol += 1;
break;
case ORI_E:
newRow -= 1;
newCol += 1;
break;
default:
break;
}
if (newRow < MAX_ROW && newCol < MAX_COL && newRow >= 0 && newCol >= 0)
if (Creature* targetPiece = ObjectAccessor::GetCreature(*me, _boards[newRow][newCol].pieceGUID))
{
if (!IsFriendly(piece, targetPiece))
{
return targetPiece;
}
}
}
return nullptr;
}
return nullptr;
}
}

2
src/server/scripts/Events/midsummer.cpp
View File

@@ -153,7 +153,7 @@ uint32 const GoBonfireCity[COUNT_GO_BONFIRE_CITY] = { 181332, 181333, 181334, 18
class MidsummerPlayerScript : public PlayerScript
{
public:
MidsummerPlayerScript() : PlayerScript("MidsummerPlayerScript")
MidsummerPlayerScript() : PlayerScript("MidsummerPlayerScript", {PLAYERHOOK_ON_UPDATE_ZONE})
{
}

30
src/server/scripts/Kalimdor/CavernsOfTime/BattleForMountHyjal/boss_archimonde.cpp
View File

@@ -66,6 +66,7 @@ enum Summons
CREATURE_DOOMFIRE_SPIRIT = 18104,
CREATURE_ANCIENT_WISP = 17946,
CREATURE_CHANNEL_TARGET = 22418,
DISPLAY_ID_TRIGGER = 11686
};
enum Events
@@ -279,13 +280,6 @@ struct boss_archimonde : public BossAI
DoCastVictim(SPELL_RED_SKY_EFFECT);
DoCastVictim(SPELL_HAND_OF_DEATH);
}, 3s);
ScheduleTimedEvent(2500ms, [&]
{
if (!(me->GetVictim() && me->IsWithinMeleeRange(me->GetVictim())))
{
DoCastRandomTarget(SPELL_FINGER_OF_DEATH);
}
}, 3500ms);
});
}
@@ -301,7 +295,7 @@ struct boss_archimonde : public BossAI
if (Creature* nordrassil = me->SummonCreature(CREATURE_CHANNEL_TARGET, nordrassilPosition, TEMPSUMMON_TIMED_DESPAWN, 1200000))
{
nordrassil->SetUnitFlag(UNIT_FLAG_NOT_SELECTABLE);
nordrassil->SetDisplayId(11686); //TODO: make enum
nordrassil->SetDisplayId(DISPLAY_ID_TRIGGER);
DoCast(nordrassil, SPELL_DRAIN_WORLD_TREE);
_isChanneling = true;
nordrassil->AI()->DoCast(me, SPELL_DRAIN_WORLD_TREE_2, true);
@@ -365,6 +359,26 @@ struct boss_archimonde : public BossAI
}
}
}, 5s);
ScheduleTimedEvent(5000ms, [&]
{
bool noPlayersInRange = true;
if (Map* map = me->GetMap())
{
map->DoForAllPlayers([&noPlayersInRange, this](Player* player)
{
if (me->IsWithinMeleeRange(player))
{
noPlayersInRange = false;
return false;
}
return true;
});
}
if (noPlayersInRange)
{
DoCastRandomTarget(SPELL_FINGER_OF_DEATH);
}
}, 3500ms);
instance->SetData(DATA_SPAWN_WAVES, 1);
}

2
src/server/scripts/Kalimdor/CavernsOfTime/BattleForMountHyjal/boss_azgalor.cpp
View File

@@ -68,7 +68,7 @@ public:
context.Repeat(18s, 20s);
}).Schedule(45s, 55s, [this](TaskContext context)
{
DoCastRandomTarget(SPELL_DOOM, 0, 100.f);
DoCastRandomTarget(SPELL_DOOM, 0, 100.f, true, false, false);
Talk(SAY_DOOM);
context.Repeat();
}).Schedule(10min, [this](TaskContext context)

2
src/server/scripts/Kalimdor/CavernsOfTime/BattleForMountHyjal/boss_kazrogal.cpp
View File

@@ -160,7 +160,7 @@ public:
{
Unit* target = GetTarget();
if (target->GetPower(POWER_MANA) == 0)
if (target->GetPower(POWER_MANA) < aurEff->GetBaseAmount())
{
target->CastSpell(target, SPELL_MARK_DAMAGE, true, nullptr, aurEff);
// Remove aura

2
src/server/scripts/Outland/TempestKeep/Eye/boss_alar.cpp
View File

@@ -163,7 +163,7 @@ struct boss_alar : public BossAI
if (me->isMoving())
return true;
return me->IsWithinMeleeRange(victim);
return _hasPretendedToDie || me->IsWithinMeleeRange(victim);
}
void EnterEvadeMode(EvadeReason why) override

2
src/server/scripts/Outland/TempestKeep/Eye/boss_kaelthas.cpp
View File

@@ -807,7 +807,7 @@ struct npc_lord_sanguinar : public ScriptedAI
{
Talk(SAY_SANGUINAR_AGGRO);
}
ScheduleTimedEvent(6s, 20s, [&]{
ScheduleTimedEvent(0s, 2s, [&]{
DoCastSelf(SPELL_BELLOWING_ROAR);
}, 30s, 40s);
}

19
src/server/scripts/World/action_ip_logger.cpp
View File

@@ -169,7 +169,15 @@ public:
class CharacterActionIpLogger : public PlayerScript
{
public:
CharacterActionIpLogger() : PlayerScript("CharacterActionIpLogger") { }
CharacterActionIpLogger() :
PlayerScript("CharacterActionIpLogger",
{
PLAYERHOOK_ON_CREATE,
PLAYERHOOK_ON_LOGIN,
PLAYERHOOK_ON_LOGOUT
})
{
}
// CHARACTER_CREATE = 7
void OnCreate(Player* player) override
@@ -256,7 +264,14 @@ public:
class CharacterDeleteActionIpLogger : public PlayerScript
{
public:
CharacterDeleteActionIpLogger() : PlayerScript("CharacterDeleteActionIpLogger") { }
CharacterDeleteActionIpLogger() :
PlayerScript("CharacterDeleteActionIpLogger",
{
PLAYERHOOK_ON_DELETE,
PLAYERHOOK_ON_FAILED_DELETE
})
{
}
// CHARACTER_DELETE = 10
void OnDelete(ObjectGuid guid, uint32 accountId) override

12
src/server/scripts/World/chat_log.cpp
View File

@@ -25,7 +25,17 @@
class ChatLogScript : public PlayerScript
{
public:
ChatLogScript() : PlayerScript("ChatLogScript") { }
ChatLogScript() :
PlayerScript("ChatLogScript",
{
PLAYERHOOK_ON_CHAT,
PLAYERHOOK_ON_CHAT_WITH_GROUP,
PLAYERHOOK_ON_CHAT_WITH_GUILD,
PLAYERHOOK_ON_CHAT_WITH_CHANNEL,
PLAYERHOOK_ON_CHAT_WITH_RECEIVER
})
{
}
void OnChat(Player* player, uint32 type, uint32 lang, std::string& msg) override
{

2
src/server/scripts/World/player_scripts.cpp
View File

@@ -27,7 +27,7 @@ enum ApprenticeAnglerQuestEnum
class QuestApprenticeAnglerPlayerScript : public PlayerScript
{
public:
QuestApprenticeAnglerPlayerScript() : PlayerScript("QuestApprenticeAnglerPlayerScript")
QuestApprenticeAnglerPlayerScript() : PlayerScript("QuestApprenticeAnglerPlayerScript", {PLAYERHOOK_ON_PLAYER_COMPLETE_QUEST})
{
}

2
src/server/scripts/World/server_mail.cpp
View File

@@ -24,7 +24,7 @@
class ServerMailReward : public PlayerScript
{
public:
ServerMailReward() : PlayerScript("ServerMailReward") { }
ServerMailReward() : PlayerScript("ServerMailReward", {PLAYERHOOK_ON_LOGIN}) { }
// CHARACTER_LOGIN = 8
void OnLogin(Player* player) override