From 2b3d46bd4f52e8edf23ca77acca82ec51e9add08 Mon Sep 17 00:00:00 2001 From: Kargatum Date: Tue, 13 Apr 2021 18:26:39 +0700 Subject: feat(Core/Hooks): added collection of hooks to extends AC (#3047) This collection of hooks comes from the Maelstrom project. It allows to release modules such as : - 3v3-soloqueue - 1v1 arena - pvestats and many others --- src/server/game/Scripting/ScriptMgr.cpp | 1130 +++++++++++++++++++++++++++---- 1 file changed, 1007 insertions(+), 123 deletions(-) (limited to 'src/server/game/Scripting/ScriptMgr.cpp') diff --git a/src/server/game/Scripting/ScriptMgr.cpp b/src/server/game/Scripting/ScriptMgr.cpp index 2dda13f032..2a691b7ffd 100644 --- a/src/server/game/Scripting/ScriptMgr.cpp +++ b/src/server/game/Scripting/ScriptMgr.cpp @@ -64,6 +64,11 @@ template class ScriptRegistry; template class ScriptRegistry; template class ScriptRegistry; template class ScriptRegistry; +template class ScriptRegistry; +template class ScriptRegistry; +template class ScriptRegistry; +template class ScriptRegistry; +template class ScriptRegistry; #include "ScriptMgrMacros.h" @@ -124,10 +129,15 @@ void ScriptMgr::Unload() SCR_CLEAR(GlobalScript); SCR_CLEAR(ModuleScript); SCR_CLEAR(BGScript); + SCR_CLEAR(AchievementScript); SCR_CLEAR(ArenaTeamScript); SCR_CLEAR(SpellSC); SCR_CLEAR(GameEventScript); SCR_CLEAR(MailScript); + SCR_CLEAR(MiscScript); + SCR_CLEAR(PetScript); + SCR_CLEAR(ArenaScript); + SCR_CLEAR(CommandSC); #undef SCR_CLEAR } @@ -198,8 +208,13 @@ void ScriptMgr::CheckIfScriptsInDatabaseExist() !ScriptRegistry::GetScriptById(sid) && !ScriptRegistry::GetScriptById(sid) && !ScriptRegistry::GetScriptById(sid) && + !ScriptRegistry::GetScriptById(sid) && !ScriptRegistry::GetScriptById(sid) && !ScriptRegistry::GetScriptById(sid) && + !ScriptRegistry::GetScriptById(sid) && + !ScriptRegistry::GetScriptById(sid) && + !ScriptRegistry::GetScriptById(sid) && + !ScriptRegistry::GetScriptById(sid) && !ScriptRegistry::GetScriptById(sid)) sLog->outErrorDb("Script named '%s' is assigned in the database, but has no code!", (*itr).c_str()); } @@ -347,6 +362,11 @@ void ScriptMgr::CreateSpellScriptLoaders(uint32 spellId, std::vectorOnBeforeDurabilityRepair(player, npcGUID, itemGUID, discountMod, guildBank); +} + void ScriptMgr::OnNetworkStart() { FOREACH_SCRIPT(ServerScript)->OnNetworkStart(); @@ -1961,9 +1981,9 @@ void ScriptMgr::OnItemRoll(Player const* player, LootStoreItem const* LootStoreI FOREACH_SCRIPT(GlobalScript)->OnItemRoll(player, LootStoreItem, chance, loot, store); } -void ScriptMgr::OnInitializeLockedDungeons(Player* player, uint8& level, uint32& lockData) +void ScriptMgr::OnInitializeLockedDungeons(Player* player, uint8& level, uint32& lockData, lfg::LFGDungeonData const* dungeon) { - FOREACH_SCRIPT(GlobalScript)->OnInitializeLockedDungeons(player, level, lockData); + FOREACH_SCRIPT(GlobalScript)->OnInitializeLockedDungeons(player, level, lockData, dungeon); } void ScriptMgr::OnAfterInitializeLockedDungeons(Player* player) @@ -2037,7 +2057,7 @@ void ScriptMgr::OnBeforeBuyItemFromVendor(Player* player, uint64 vendorguid, uin FOREACH_SCRIPT(PlayerScript)->OnBeforeBuyItemFromVendor(player, vendorguid, vendorslot, item, count, bag, slot); } -void ScriptMgr::OnAfterStoreOrEquipNewItem(Player* player, uint32 vendorslot, uint32& item, uint8 count, uint8 bag, uint8 slot, ItemTemplate const* pProto, Creature* pVendor, VendorItem const* crItem, bool bStore) +void ScriptMgr::OnAfterStoreOrEquipNewItem(Player* player, uint32 vendorslot, Item* item, uint8 count, uint8 bag, uint8 slot, ItemTemplate const* pProto, Creature* pVendor, VendorItem const* crItem, bool bStore) { FOREACH_SCRIPT(PlayerScript)->OnAfterStoreOrEquipNewItem(player, vendorslot, item, count, bag, slot, pProto, pVendor, crItem, bStore); } @@ -2136,17 +2156,6 @@ void ScriptMgr::OnCheckNormalMatch(BattlegroundQueue* queue, uint32& Coef, Battl FOREACH_SCRIPT(BGScript)->OnCheckNormalMatch(queue, Coef, bgTemplate, bracket_id, minPlayers, maxPlayers); } -bool ScriptMgr::CanSendMessageQueue(BattlegroundQueue* queue, Player* leader, Battleground* bg, PvPDifficultyEntry const* bracketEntry) -{ - bool ret = true; - - FOR_SCRIPTS_RET(BGScript, itr, end, ret) // return true by default if not scripts - if (!itr->second->CanSendMessageQueue(queue, leader, bg, bracketEntry)) - ret = false; // we change ret value only when scripts return false - - return ret; -} - void ScriptMgr::OnGetSlotByType(const uint32 type, uint8& slot) { FOREACH_SCRIPT(ArenaTeamScript)->OnGetSlotByType(type, slot); @@ -2200,219 +2209,1094 @@ void ScriptMgr::OnBeforeMailDraftSendMailTo(MailDraft* mailDraft, MailReceiver c FOREACH_SCRIPT(MailScript)->OnBeforeMailDraftSendMailTo(mailDraft, receiver, sender, checked, deliver_delay, custom_expiration, deleteMailItemsFromDB, sendMail); } -AllMapScript::AllMapScript(const char* name) - : ScriptObject(name) +void ScriptMgr::OnBeforeUpdatingPersonalRating(int32& mod, uint32 type) { - ScriptRegistry::AddScript(this); + FOREACH_SCRIPT(FormulaScript)->OnBeforeUpdatingPersonalRating(mod, type); } -AllCreatureScript::AllCreatureScript(const char* name) - : ScriptObject(name) +bool ScriptMgr::OnBeforePlayerQuestComplete(Player* player, uint32 quest_id) { - ScriptRegistry::AddScript(this); + bool ret=true; + FOR_SCRIPTS_RET(PlayerScript, itr, end, ret) // return true by default if not scripts + if (!itr->second->OnBeforeQuestComplete(player, quest_id)) + ret=false; // we change ret value only when scripts return false + + return ret; } -UnitScript::UnitScript(const char* name, bool addToScripts) - : ScriptObject(name) +void ScriptMgr::OnBeforeStoreOrEquipNewItem(Player* player, uint32 vendorslot, uint32& item, uint8 count, uint8 bag, uint8 slot, ItemTemplate const* pProto, Creature* pVendor, VendorItem const* crItem, bool bStore) { - if (addToScripts) - ScriptRegistry::AddScript(this); + FOREACH_SCRIPT(PlayerScript)->OnBeforeStoreOrEquipNewItem(player, vendorslot, item, count, bag, slot, pProto, pVendor, crItem, bStore); } -MovementHandlerScript::MovementHandlerScript(const char* name) - : ScriptObject(name) +bool ScriptMgr::CanJoinInArenaQueue(Player* player, uint64 BattlemasterGuid, uint8 arenaslot, BattlegroundTypeId BGTypeID, uint8 joinAsGroup, uint8 IsRated, GroupJoinBattlegroundResult& err) { - ScriptRegistry::AddScript(this); + bool ret = true; + + FOR_SCRIPTS_RET(PlayerScript, itr, end, ret) // return true by default if not scripts + if (!itr->second->CanJoinInArenaQueue(player, BattlemasterGuid, arenaslot, BGTypeID, joinAsGroup, IsRated, err)) + ret = false; // we change ret value only when scripts return false + + return ret; } -SpellScriptLoader::SpellScriptLoader(const char* name) - : ScriptObject(name) +bool ScriptMgr::CanBattleFieldPort(Player* player, uint8 arenaType, BattlegroundTypeId BGTypeID, uint8 action) { - ScriptRegistry::AddScript(this); + bool ret = true; + + FOR_SCRIPTS_RET(PlayerScript, itr, end, ret) // return true by default if not scripts + if (!itr->second->CanBattleFieldPort(player, arenaType, BGTypeID, action)) + ret = false; // we change ret value only when scripts return false + + return ret; } -ServerScript::ServerScript(const char* name) - : ScriptObject(name) +bool ScriptMgr::CanGroupInvite(Player* player, std::string& membername) { - ScriptRegistry::AddScript(this); + bool ret = true; + + FOR_SCRIPTS_RET(PlayerScript, itr, end, ret) // return true by default if not scripts + if (!itr->second->CanGroupInvite(player, membername)) + ret = false; // we change ret value only when scripts return false + + return ret; } -WorldScript::WorldScript(const char* name) - : ScriptObject(name) +bool ScriptMgr::CanGroupAccept(Player* player, Group* group) { - ScriptRegistry::AddScript(this); + bool ret = true; + + FOR_SCRIPTS_RET(PlayerScript, itr, end, ret) // return true by default if not scripts + if (!itr->second->CanGroupAccept(player, group)) + ret = false; // we change ret value only when scripts return false + + return ret; } -FormulaScript::FormulaScript(const char* name) - : ScriptObject(name) +bool ScriptMgr::CanSellItem(Player* player, Item* item, Creature* creature) { - ScriptRegistry::AddScript(this); + bool ret = true; + + FOR_SCRIPTS_RET(PlayerScript, itr, end, ret) // return true by default if not scripts + if (!itr->second->CanSellItem(player, item, creature)) + ret = false; // we change ret value only when scripts return false + + return ret; } -WorldMapScript::WorldMapScript(const char* name, uint32 mapId) - : ScriptObject(name), MapScript(mapId) +bool ScriptMgr::CanSendMail(Player* player, uint64 receiverGuid, uint64 mailbox, std::string& subject, std::string& body, uint32 money, uint32 COD, Item* item) { - ScriptRegistry::AddScript(this); + bool ret = true; + + FOR_SCRIPTS_RET(PlayerScript, itr, end, ret) // return true by default if not scripts + if (!itr->second->CanSendMail(player, receiverGuid, mailbox, subject, body, money, COD, item)) + ret = false; // we change ret value only when scripts return false + + return ret; } -InstanceMapScript::InstanceMapScript(const char* name, uint32 mapId) - : ScriptObject(name), MapScript(mapId) +void ScriptMgr::PetitionBuy(Player* player, Creature* creature, uint32& charterid, uint32& cost, uint32& type) { - ScriptRegistry::AddScript(this); + FOREACH_SCRIPT(PlayerScript)->PetitionBuy(player, creature, charterid, cost, type); } -BattlegroundMapScript::BattlegroundMapScript(const char* name, uint32 mapId) - : ScriptObject(name), MapScript(mapId) +void ScriptMgr::PetitionShowList(Player* player, Creature* creature, uint32& CharterEntry, uint32& CharterDispayID, uint32& CharterCost) { - ScriptRegistry::AddScript(this); + FOREACH_SCRIPT(PlayerScript)->PetitionShowList(player, creature, CharterEntry, CharterDispayID, CharterCost); } -ItemScript::ItemScript(const char* name) - : ScriptObject(name) +void ScriptMgr::OnRewardKillRewarder(Player* player, bool isDungeon, float& rate) { - ScriptRegistry::AddScript(this); + FOREACH_SCRIPT(PlayerScript)->OnRewardKillRewarder(player, isDungeon, rate); } -CreatureScript::CreatureScript(const char* name) - : ScriptObject(name) +bool ScriptMgr::CanGiveMailRewardAtGiveLevel(Player* player, uint8 level) { - ScriptRegistry::AddScript(this); + bool ret = true; + + FOR_SCRIPTS_RET(PlayerScript, itr, end, ret) // return true by default if not scripts + if (!itr->second->CanGiveMailRewardAtGiveLevel(player, level)) + ret = false; // we change ret value only when scripts return false + + return ret; } -GameObjectScript::GameObjectScript(const char* name) - : ScriptObject(name) +void ScriptMgr::OnDeleteFromDB(SQLTransaction& trans, uint32 guid) { - ScriptRegistry::AddScript(this); + FOREACH_SCRIPT(PlayerScript)->OnDeleteFromDB(trans, guid); } -AreaTriggerScript::AreaTriggerScript(const char* name) - : ScriptObject(name) +bool ScriptMgr::CanRepopAtGraveyard(Player* player) { - ScriptRegistry::AddScript(this); + bool ret = true; + + FOR_SCRIPTS_RET(PlayerScript, itr, end, ret) // return true by default if not scripts + if (!itr->second->CanRepopAtGraveyard(player)) + ret = false; // we change ret value only when scripts return false + + return ret; } -BattlegroundScript::BattlegroundScript(const char* name) - : ScriptObject(name) +void ScriptMgr::OnGetMaxSkillValue(Player* player, uint32 skill, int32& result, bool IsPure) { - ScriptRegistry::AddScript(this); + FOREACH_SCRIPT(PlayerScript)->OnGetMaxSkillValue(player, skill, result, IsPure); } -OutdoorPvPScript::OutdoorPvPScript(const char* name) - : ScriptObject(name) +bool ScriptMgr::CanAreaExploreAndOutdoor(Player* player) { - ScriptRegistry::AddScript(this); + bool ret = true; + + FOR_SCRIPTS_RET(PlayerScript, itr, end, ret) // return true by default if not scripts + if (!itr->second->CanAreaExploreAndOutdoor(player)) + ret = false; // we change ret value only when scripts return false + + return ret; } -CommandScript::CommandScript(const char* name) - : ScriptObject(name) +void ScriptMgr::OnVictimRewardBefore(Player* player, Player* victim, uint32& killer_title, uint32& victim_title) { - ScriptRegistry::AddScript(this); + FOREACH_SCRIPT(PlayerScript)->OnVictimRewardBefore(player, victim, killer_title, victim_title); } -WeatherScript::WeatherScript(const char* name) - : ScriptObject(name) +void ScriptMgr::OnVictimRewardAfter(Player* player, Player* victim, uint32& killer_title, uint32& victim_rank, float& honor_f) { - ScriptRegistry::AddScript(this); + FOREACH_SCRIPT(PlayerScript)->OnVictimRewardAfter(player, victim, killer_title, victim_rank, honor_f); } -AuctionHouseScript::AuctionHouseScript(const char* name) - : ScriptObject(name) +void ScriptMgr::OnCustomScalingStatValueBefore(Player* player, ItemTemplate const* proto, uint8 slot, bool apply, uint32& CustomScalingStatValue) { - ScriptRegistry::AddScript(this); + FOREACH_SCRIPT(PlayerScript)->OnCustomScalingStatValueBefore(player, proto, slot, apply, CustomScalingStatValue); } -ConditionScript::ConditionScript(const char* name) - : ScriptObject(name) +void ScriptMgr::OnCustomScalingStatValue(Player* player, ItemTemplate const* proto, uint32& statType, int32& val, uint8 itemProtoStatNumber, uint32 ScalingStatValue, ScalingStatValuesEntry const* ssv) { - ScriptRegistry::AddScript(this); + FOREACH_SCRIPT(PlayerScript)->OnCustomScalingStatValue(player, proto, statType, val, itemProtoStatNumber, ScalingStatValue, ssv); } -VehicleScript::VehicleScript(const char* name) - : ScriptObject(name) +bool ScriptMgr::CanArmorDamageModifier(Player* player) { - ScriptRegistry::AddScript(this); + bool ret = true; + + FOR_SCRIPTS_RET(PlayerScript, itr, end, ret) // return true by default if not scripts + if (!itr->second->CanArmorDamageModifier(player)) + ret = false; // we change ret value only when scripts return false + + return ret; } -DynamicObjectScript::DynamicObjectScript(const char* name) - : ScriptObject(name) +void ScriptMgr::OnGetFeralApBonus(Player* player, int32& feral_bonus, int32 dpsMod, ItemTemplate const* proto, ScalingStatValuesEntry const* ssv) { - ScriptRegistry::AddScript(this); + FOREACH_SCRIPT(PlayerScript)->OnGetFeralApBonus(player, feral_bonus, dpsMod, proto, ssv); } -TransportScript::TransportScript(const char* name) - : ScriptObject(name) +bool ScriptMgr::CanApplyWeaponDependentAuraDamageMod(Player* player, Item* item, WeaponAttackType attackType, AuraEffect const* aura, bool apply) { - ScriptRegistry::AddScript(this); + bool ret = true; + + FOR_SCRIPTS_RET(PlayerScript, itr, end, ret) // return true by default if not scripts + if (!itr->second->CanApplyWeaponDependentAuraDamageMod(player, item, attackType, aura, apply)) + ret = false; // we change ret value only when scripts return false + + return ret; } -AchievementCriteriaScript::AchievementCriteriaScript(const char* name) - : ScriptObject(name) +bool ScriptMgr::CanApplyEquipSpell(Player* player, SpellInfo const* spellInfo, Item* item, bool apply, bool form_change) { - ScriptRegistry::AddScript(this); + bool ret = true; + + FOR_SCRIPTS_RET(PlayerScript, itr, end, ret) // return true by default if not scripts + if (!itr->second->CanApplyEquipSpell(player, spellInfo, item, apply, form_change)) + ret = false; // we change ret value only when scripts return false + + return ret; } -PlayerScript::PlayerScript(const char* name) - : ScriptObject(name) +bool ScriptMgr::CanApplyEquipSpellsItemSet(Player* player, ItemSetEffect* eff) { - ScriptRegistry::AddScript(this); + bool ret = true; + + FOR_SCRIPTS_RET(PlayerScript, itr, end, ret) // return true by default if not scripts + if (!itr->second->CanApplyEquipSpellsItemSet(player, eff)) + ret = false; // we change ret value only when scripts return false + + return ret; } -AccountScript::AccountScript(const char* name) - : ScriptObject(name) +bool ScriptMgr::CanCastItemCombatSpell(Player* player, Unit* target, WeaponAttackType attType, uint32 procVictim, uint32 procEx, Item* item, ItemTemplate const* proto) { - ScriptRegistry::AddScript(this); + bool ret = true; + + FOR_SCRIPTS_RET(PlayerScript, itr, end, ret) // return true by default if not scripts + if (!itr->second->CanCastItemCombatSpell(player, target, attType, procVictim, procEx, item, proto)) + ret = false; // we change ret value only when scripts return false + + return ret; } -GuildScript::GuildScript(const char* name) - : ScriptObject(name) +bool ScriptMgr::CanCastItemUseSpell(Player* player, Item* item, SpellCastTargets const& targets, uint8 cast_count, uint32 glyphIndex) { - ScriptRegistry::AddScript(this); + bool ret = true; + + FOR_SCRIPTS_RET(PlayerScript, itr, end, ret) // return true by default if not scripts + if (!itr->second->CanCastItemUseSpell(player, item, targets, cast_count, glyphIndex)) + ret = false; // we change ret value only when scripts return false + + return ret; } -GroupScript::GroupScript(const char* name) - : ScriptObject(name) +void ScriptMgr::OnApplyAmmoBonuses(Player* player, ItemTemplate const* proto, float& currentAmmoDPS) { - ScriptRegistry::AddScript(this); + FOREACH_SCRIPT(PlayerScript)->OnApplyAmmoBonuses(player, proto, currentAmmoDPS); } -GlobalScript::GlobalScript(const char* name) - : ScriptObject(name) +bool ScriptMgr::CanEquipItem(Player* player, uint8 slot, uint16& dest, Item* pItem, bool swap, bool not_loading) { - ScriptRegistry::AddScript(this); + bool ret = true; + + FOR_SCRIPTS_RET(PlayerScript, itr, end, ret) // return true by default if not scripts + if (!itr->second->CanEquipItem(player, slot, dest, pItem, swap, not_loading)) + ret = false; // we change ret value only when scripts return false + + return ret; } -BGScript::BGScript(char const* name) - : ScriptObject(name) +bool ScriptMgr::CanUnequipItem(Player* player, uint16 pos, bool swap) { - ScriptRegistry::AddScript(this); + bool ret = true; + + FOR_SCRIPTS_RET(PlayerScript, itr, end, ret) // return true by default if not scripts + if (!itr->second->CanUnequipItem(player, pos, swap)) + ret = false; // we change ret value only when scripts return false + + return ret; } -ArenaTeamScript::ArenaTeamScript(const char* name) - : ScriptObject(name) +bool ScriptMgr::CanUseItem(Player* player, ItemTemplate const* proto, InventoryResult& result) { - ScriptRegistry::AddScript(this); + bool ret = true; + + FOR_SCRIPTS_RET(PlayerScript, itr, end, ret) // return true by default if not scripts + if (!itr->second->CanUseItem(player, proto, result)) + ret = false; // we change ret value only when scripts return false + + return ret; } -SpellSC::SpellSC(char const* name) - : ScriptObject(name) +bool ScriptMgr::CanSaveEquipNewItem(Player* player, Item* item, uint16 pos, bool update) { - ScriptRegistry::AddScript(this); + bool ret = true; + + FOR_SCRIPTS_RET(PlayerScript, itr, end, ret) // return true by default if not scripts + if (!itr->second->CanSaveEquipNewItem(player, item, pos, update)) + ret = false; // we change ret value only when scripts return false + + return ret; } -ModuleScript::ModuleScript(const char* name) - : ScriptObject(name) +bool ScriptMgr::CanApplyEnchantment(Player* player, Item* item, EnchantmentSlot slot, bool apply, bool apply_dur, bool ignore_condition) { - ScriptRegistry::AddScript(this); + bool ret = true; + + FOR_SCRIPTS_RET(PlayerScript, itr, end, ret) // return true by default if not scripts + if (!itr->second->CanApplyEnchantment(player, item, slot, apply, apply_dur, ignore_condition)) + ret = false; // we change ret value only when scripts return false + + return ret; } -GameEventScript::GameEventScript(const char* name) - : ScriptObject(name) +void ScriptMgr::OnGetQuestRate(Player* player, float& result) { - ScriptRegistry::AddScript(this); + FOREACH_SCRIPT(PlayerScript)->OnGetQuestRate(player, result); } -MailScript::MailScript(const char* name) - : ScriptObject(name) +bool ScriptMgr::PassedQuestKilledMonsterCredit(Player* player, Quest const* qinfo, uint32 entry, uint32 real_entry, uint64 guid) { - ScriptRegistry::AddScript(this); + bool ret = true; + + FOR_SCRIPTS_RET(PlayerScript, itr, end, ret) // return true by default if not scripts + if (!itr->second->PassedQuestKilledMonsterCredit(player, qinfo, entry, real_entry, guid)) + ret = false; // we change ret value only when scripts return false + + return ret; +} + +bool ScriptMgr::CheckItemInSlotAtLoadInventory(Player* player, Item* item, uint8 slot, uint8& err, uint16& dest) +{ + bool ret = true; + + FOR_SCRIPTS_RET(PlayerScript, itr, end, ret) // return true by default if not scripts + if (!itr->second->CheckItemInSlotAtLoadInventory(player, item, slot, err, dest)) + ret = false; // we change ret value only when scripts return false + + return ret; +} + +bool ScriptMgr::NotAvoidSatisfy(Player* player, DungeonProgressionRequirements const* ar, uint32 target_map, bool report) +{ + bool ret = true; + + FOR_SCRIPTS_RET(PlayerScript, itr, end, ret) // return true by default if not scripts + if (!itr->second->NotAvoidSatisfy(player, ar, target_map, report)) + ret = false; // we change ret value only when scripts return false + + return ret; +} + +bool ScriptMgr::NotVisibleGloballyFor(Player* player, Player const* u) +{ + bool ret = true; + + FOR_SCRIPTS_RET(PlayerScript, itr, end, ret) // return true by default if not scripts + if (!itr->second->NotVisibleGloballyFor(player, u)) + ret = false; // we change ret value only when scripts return false + + return ret; +} + +void ScriptMgr::OnGetArenaPersonalRating(Player* player, uint8 slot, uint32& result) +{ + FOREACH_SCRIPT(PlayerScript)->OnGetArenaPersonalRating(player, slot, result); +} + +void ScriptMgr::OnGetArenaTeamId(Player* player, uint8 slot, uint32& result) +{ + FOREACH_SCRIPT(PlayerScript)->OnGetArenaTeamId(player, slot, result); +} + +void ScriptMgr::OnIsFFAPvP(Player* player, bool& result) +{ + FOREACH_SCRIPT(PlayerScript)->OnIsFFAPvP(player, result); +} + +void ScriptMgr::OnIsPvP(Player* player, bool& result) +{ + FOREACH_SCRIPT(PlayerScript)->OnIsPvP(player, result); +} + +void ScriptMgr::OnGetMaxSkillValueForLevel(Player* player, uint16& result) +{ + FOREACH_SCRIPT(PlayerScript)->OnGetMaxSkillValueForLevel(player, result); +} + +bool ScriptMgr::NotSetArenaTeamInfoField(Player* player, uint8 slot, ArenaTeamInfoType type, uint32 value) +{ + bool ret = true; + + FOR_SCRIPTS_RET(PlayerScript, itr, end, ret) // return true by default if not scripts + if (!itr->second->NotSetArenaTeamInfoField(player, slot, type, value)) + ret = false; // we change ret value only when scripts return false + + return ret; +} + +bool ScriptMgr::CanJoinLfg(Player* player, uint8 roles, lfg::LfgDungeonSet& dungeons, const std::string& comment) +{ + bool ret = true; + + FOR_SCRIPTS_RET(PlayerScript, itr, end, ret) // return true by default if not scripts + if (!itr->second->CanJoinLfg(player, roles, dungeons, comment)) + ret = false; // we change ret value only when scripts return false + + return ret; +} + +bool ScriptMgr::CanEnterMap(Player* player, MapEntry const* entry, InstanceTemplate const* instance, MapDifficulty const* mapDiff, bool loginCheck) +{ + bool ret = true; + + FOR_SCRIPTS_RET(PlayerScript, itr, end, ret) // return true by default if not scripts + if (!itr->second->CanEnterMap(player, entry, instance, mapDiff, loginCheck)) + ret = false; // we change ret value only when scripts return false + + return ret; +} + +bool ScriptMgr::CanInitTrade(Player* player, Player* target) +{ + bool ret = true; + + FOR_SCRIPTS_RET(PlayerScript, itr, end, ret) // return true by default if not scripts + if (!itr->second->CanInitTrade(player, target)) + ret = false; // we change ret value only when scripts return false + + return ret; +} + +void ScriptMgr::OnSetServerSideVisibility(Player* player, ServerSideVisibilityType& type, AccountTypes& sec) +{ + FOREACH_SCRIPT(PlayerScript)->OnSetServerSideVisibility(player, type, sec); +} + +void ScriptMgr::OnSetServerSideVisibilityDetect(Player* player, ServerSideVisibilityType& type, AccountTypes& sec) +{ + FOREACH_SCRIPT(PlayerScript)->OnSetServerSideVisibilityDetect(player, type, sec); +} + +bool ScriptMgr::CanGuildSendBankList(Guild const* guild, WorldSession* session, uint8 tabId, bool sendAllSlots) +{ + bool ret = true; + + FOR_SCRIPTS_RET(GuildScript, itr, end, ret) // return true by default if not scripts + if (!itr->second->CanGuildSendBankList(guild, session, tabId, sendAllSlots)) + ret = false; // we change ret value only when scripts return true + + return ret; +} + +bool ScriptMgr::CanGroupJoinBattlegroundQueue(Group const* group, Player* member, Battleground const* bgTemplate, uint32 MinPlayerCount, bool isRated, uint32 arenaSlot) +{ + bool ret = true; + + FOR_SCRIPTS_RET(GroupScript, itr, end, ret) // return true by default if not scripts + if (!itr->second->CanGroupJoinBattlegroundQueue(group, member, bgTemplate, MinPlayerCount, isRated, arenaSlot)) + ret = false; // we change ret value only when scripts return true + + return ret; +} + +void ScriptMgr::OnCreate(Group* group, Player* leader) +{ + FOREACH_SCRIPT(GroupScript)->OnCreate(group, leader); +} + +void ScriptMgr::OnAuraRemove(Unit* unit, AuraApplication* aurApp, AuraRemoveMode mode) +{ + FOREACH_SCRIPT(UnitScript)->OnAuraRemove(unit, aurApp, mode); +} + +bool ScriptMgr::IfNormalReaction(Unit const* unit, Unit const* target, ReputationRank& repRank) +{ + bool ret = true; + + FOR_SCRIPTS_RET(UnitScript, itr, end, ret) // return true by default if not scripts + if (!itr->second->IfNormalReaction(unit, target, repRank)) + ret = false; // we change ret value only when scripts return false + + return ret; +} + +bool ScriptMgr::IsNeedModSpellDamagePercent(Unit const* unit, AuraEffect* auraEff, float& doneTotalMod, SpellInfo const* spellProto) +{ + bool ret = true; + + FOR_SCRIPTS_RET(UnitScript, itr, end, ret) // return true by default if not scripts + if (!itr->second->IsNeedModSpellDamagePercent(unit, auraEff, doneTotalMod, spellProto)) + ret = false; // we change ret value only when scripts return false + + return ret; +} + +bool ScriptMgr::IsNeedModMeleeDamagePercent(Unit const* unit, AuraEffect* auraEff, float& doneTotalMod, SpellInfo const* spellProto) +{ + bool ret = true; + + FOR_SCRIPTS_RET(UnitScript, itr, end, ret) // return true by default if not scripts + if (!itr->second->IsNeedModMeleeDamagePercent(unit, auraEff, doneTotalMod, spellProto)) + ret = false; // we change ret value only when scripts return false + + return ret; +} + +bool ScriptMgr::IsNeedModHealPercent(Unit const* unit, AuraEffect* auraEff, float& doneTotalMod, SpellInfo const* spellProto) +{ + bool ret = true; + + FOR_SCRIPTS_RET(UnitScript, itr, end, ret) // return true by default if not scripts + if (!itr->second->IsNeedModHealPercent(unit, auraEff, doneTotalMod, spellProto)) + ret = false; // we change ret value only when scripts return false + + return ret; +} + +bool ScriptMgr::CanSetPhaseMask(Unit const* unit, uint32 newPhaseMask, bool update) +{ + bool ret = true; + + FOR_SCRIPTS_RET(UnitScript, itr, end, ret) // return true by default if not scripts + if (!itr->second->CanSetPhaseMask(unit, newPhaseMask, update)) + ret = false; // we change ret value only when scripts return false + + return ret; +} + +bool ScriptMgr::IsCustomBuildValuesUpdate(Unit const* unit, uint8 updateType, ByteBuffer& fieldBuffer, Player const* target, uint16 index) +{ + bool ret = false; + + FOR_SCRIPTS_RET(UnitScript, itr, end, ret) // return true by default if not scripts + if (itr->second->IsCustomBuildValuesUpdate(unit, updateType, fieldBuffer, target, index)) + ret = true; // we change ret value only when scripts return true + + return ret; +} + +void ScriptMgr::OnQueueUpdate(BattlegroundQueue* queue, BattlegroundBracketId bracket_id, bool isRated, uint32 arenaRatedTeamId) +{ + FOREACH_SCRIPT(BGScript)->OnQueueUpdate(queue, bracket_id, isRated, arenaRatedTeamId); +} + +bool ScriptMgr::CanSendMessageBGQueue(BattlegroundQueue* queue, Player* leader, Battleground* bg, PvPDifficultyEntry const* bracketEntry) +{ + bool ret = true; + + FOR_SCRIPTS_RET(BGScript, itr, end, ret) // return true by default if not scripts + if (!itr->second->CanSendMessageBGQueue(queue, leader, bg, bracketEntry)) + ret = false; // we change ret value only when scripts return false + + return ret; +} + +bool ScriptMgr::CanSendMessageArenaQueue(BattlegroundQueue* queue, GroupQueueInfo* ginfo, bool IsJoin) +{ + bool ret = true; + + FOR_SCRIPTS_RET(BGScript, itr, end, ret) // return true by default if not scripts + if (!itr->second->CanSendMessageArenaQueue(queue, ginfo, IsJoin)) + ret = false; // we change ret value only when scripts return false + + return ret; +} + +bool ScriptMgr::CanModAuraEffectDamageDone(AuraEffect const* auraEff, Unit* target, AuraApplication const* aurApp, uint8 mode, bool apply) +{ + bool ret = true; + + FOR_SCRIPTS_RET(SpellSC, itr, end, ret) // return true by default if not scripts + if (!itr->second->CanModAuraEffectDamageDone(auraEff, target, aurApp, mode, apply)) + ret = false; // we change ret value only when scripts return false + + return ret; +} + +bool ScriptMgr::CanModAuraEffectModDamagePercentDone(AuraEffect const* auraEff, Unit* target, AuraApplication const* aurApp, uint8 mode, bool apply) +{ + bool ret = true; + + FOR_SCRIPTS_RET(SpellSC, itr, end, ret) // return true by default if not scripts + if (!itr->second->CanModAuraEffectModDamagePercentDone(auraEff, target, aurApp, mode, apply)) + ret = false; // we change ret value only when scripts return false + + return ret; +} + +void ScriptMgr::OnSpellCheckCast(Spell* spell, bool strict, SpellCastResult& res) +{ + FOREACH_SCRIPT(SpellSC)->OnSpellCheckCast(spell, strict, res); +} + +bool ScriptMgr::CanPrepare(Spell* spell, SpellCastTargets const* targets, AuraEffect const* triggeredByAura) +{ + bool ret = true; + + FOR_SCRIPTS_RET(SpellSC, itr, end, ret) // return true by default if not scripts + if (!itr->second->CanPrepare(spell, targets, triggeredByAura)) + ret = false; // we change ret value only when scripts return false + + return ret; +} + +bool ScriptMgr::CanScalingEverything(Spell* spell) +{ + bool ret = false; + + FOR_SCRIPTS_RET(SpellSC, itr, end, ret) // return true by default if not scripts + if (itr->second->CanScalingEverything(spell)) + ret = true; // we change ret value only when scripts return false + + return ret; +} + +bool ScriptMgr::CanSelectSpecTalent(Spell* spell) +{ + bool ret = true; + + FOR_SCRIPTS_RET(SpellSC, itr, end, ret) // return true by default if not scripts + if (!itr->second->CanSelectSpecTalent(spell)) + ret = false; // we change ret value only when scripts return false + + return ret; +} + +void ScriptMgr::OnScaleAuraUnitAdd(Spell* spell, Unit* target, uint32 effectMask, bool checkIfValid, bool implicit, uint8 auraScaleMask, TargetInfo& targetInfo) +{ + FOREACH_SCRIPT(SpellSC)->OnScaleAuraUnitAdd(spell, target, effectMask, checkIfValid, implicit, auraScaleMask, targetInfo); +} + +void ScriptMgr::OnRemoveAuraScaleTargets(Spell* spell, TargetInfo& targetInfo, uint8 auraScaleMask, bool& needErase) +{ + FOREACH_SCRIPT(SpellSC)->OnRemoveAuraScaleTargets(spell, targetInfo, auraScaleMask, needErase); +} + +void ScriptMgr::OnBeforeAuraRankForLevel(SpellInfo const* spellInfo, SpellInfo const* latestSpellInfo, uint8 level) +{ + FOREACH_SCRIPT(SpellSC)->OnBeforeAuraRankForLevel(spellInfo, latestSpellInfo, level); +} + +void ScriptMgr::SetRealmCompleted(AchievementEntry const* achievement) +{ + FOREACH_SCRIPT(AchievementScript)->SetRealmCompleted(achievement); +} + +bool ScriptMgr::IsCompletedCriteria(AchievementMgr* mgr, AchievementCriteriaEntry const* achievementCriteria, AchievementEntry const* achievement, CriteriaProgress const* progress) +{ + bool ret = true; + + FOR_SCRIPTS_RET(AchievementScript, itr, end, ret) // return true by default if not scripts + if (!itr->second->IsCompletedCriteria(mgr, achievementCriteria, achievement, progress)) + ret = false; // we change ret value only when scripts return false + + return ret; +} + +bool ScriptMgr::IsRealmCompleted(AchievementGlobalMgr const* globalmgr, AchievementEntry const* achievement, std::chrono::system_clock::time_point completionTime) +{ + bool ret = true; + + FOR_SCRIPTS_RET(AchievementScript, itr, end, ret) // return true by default if not scripts + if (!itr->second->IsRealmCompleted(globalmgr, achievement, completionTime)) + ret = false; // we change ret value only when scripts return false + + return ret; +} + +void ScriptMgr::OnBeforeCheckCriteria(AchievementMgr* mgr, AchievementCriteriaEntryList const* achievementCriteriaList) +{ + FOREACH_SCRIPT(AchievementScript)->OnBeforeCheckCriteria(mgr, achievementCriteriaList); +} + +bool ScriptMgr::CanCheckCriteria(AchievementMgr* mgr, AchievementCriteriaEntry const* achievementCriteria) +{ + bool ret = true; + + FOR_SCRIPTS_RET(AchievementScript, itr, end, ret) // return true by default if not scripts + if (!itr->second->CanCheckCriteria(mgr, achievementCriteria)) + ret = false; // we change ret value only when scripts return false + + return ret; +} + +void ScriptMgr::OnInitStatsForLevel(Guardian* guardian, uint8 petlevel) +{ + FOREACH_SCRIPT(PetScript)->OnInitStatsForLevel(guardian, petlevel); +} + +void ScriptMgr::OnCalculateMaxTalentPointsForLevel(Pet* pet, uint8 level, uint8& points) +{ + FOREACH_SCRIPT(PetScript)->OnCalculateMaxTalentPointsForLevel(pet, level, points); +} + +bool ScriptMgr::CanUnlearnSpellSet(Pet* pet, uint32 level, uint32 spell) +{ + bool ret = true; + + FOR_SCRIPTS_RET(PetScript, itr, end, ret) // return true by default if not scripts + if (!itr->second->CanUnlearnSpellSet(pet, level, spell)) + ret = false; // we change ret value only when scripts return false + + return ret; +} + +bool ScriptMgr::CanUnlearnSpellDefault(Pet* pet, SpellInfo const* spellEntry) +{ + bool ret = true; + + FOR_SCRIPTS_RET(PetScript, itr, end, ret) // return true by default if not scripts + if (!itr->second->CanUnlearnSpellDefault(pet, spellEntry)) + ret = false; // we change ret value only when scripts return false + + return ret; +} + +bool ScriptMgr::CanResetTalents(Pet* pet) +{ + bool ret = true; + + FOR_SCRIPTS_RET(PetScript, itr, end, ret) // return true by default if not scripts + if (!itr->second->CanResetTalents(pet)) + ret = false; // we change ret value only when scripts return false + + return ret; +} + +bool ScriptMgr::CanAddMember(ArenaTeam* team, uint64 PlayerGuid) +{ + bool ret = true; + + FOR_SCRIPTS_RET(ArenaScript, itr, end, ret) // return true by default if not scripts + if (!itr->second->CanAddMember(team, PlayerGuid)) + ret = false; // we change ret value only when scripts return true + + return ret; +} + +void ScriptMgr::OnGetPoints(ArenaTeam* team, uint32 memberRating, float& points) +{ + FOREACH_SCRIPT(ArenaScript)->OnGetPoints(team, memberRating, points); +} + +bool ScriptMgr::CanSaveToDB(ArenaTeam* team) +{ + bool ret = true; + + FOR_SCRIPTS_RET(ArenaScript, itr, end, ret) // return true by default if not scripts + if (!itr->second->CanSaveToDB(team)) + ret = false; // we change ret value only when scripts return true + + return ret; +} + +void ScriptMgr::OnItemCreate(Item* item, ItemTemplate const* itemProto, Player const* owner) +{ + FOREACH_SCRIPT(MiscScript)->OnItemCreate(item, itemProto, owner); +} + +bool ScriptMgr::CanApplySoulboundFlag(Item* item, ItemTemplate const* proto) +{ + bool ret = true; + + FOR_SCRIPTS_RET(MiscScript, itr, end, ret) // return true by default if not scripts + if (!itr->second->CanApplySoulboundFlag(item, proto)) + ret = false; // we change ret value only when scripts return false + + return ret; +} + +void ScriptMgr::OnConstructObject(Object* origin) +{ + FOREACH_SCRIPT(MiscScript)->OnConstructObject(origin); +} + +void ScriptMgr::OnDestructObject(Object* origin) +{ + FOREACH_SCRIPT(MiscScript)->OnDestructObject(origin); +} + +void ScriptMgr::OnConstructPlayer(Player* origin) +{ + FOREACH_SCRIPT(MiscScript)->OnConstructPlayer(origin); +} + +void ScriptMgr::OnDestructPlayer(Player* origin) +{ + FOREACH_SCRIPT(MiscScript)->OnDestructPlayer(origin); +} + +void ScriptMgr::OnConstructGroup(Group* origin) +{ + FOREACH_SCRIPT(MiscScript)->OnConstructGroup(origin); +} + +void ScriptMgr::OnDestructGroup(Group* origin) +{ + FOREACH_SCRIPT(MiscScript)->OnDestructGroup(origin); +} + +void ScriptMgr::OnConstructInstanceSave(InstanceSave* origin) +{ + FOREACH_SCRIPT(MiscScript)->OnConstructInstanceSave(origin); +} + +void ScriptMgr::OnDestructInstanceSave(InstanceSave* origin) +{ + FOREACH_SCRIPT(MiscScript)->OnDestructInstanceSave(origin); +} + +bool ScriptMgr::CanItemApplyEquipSpell(Player* player, Item* item) +{ + bool ret = true; + + FOR_SCRIPTS_RET(MiscScript, itr, end, ret) // return true by default if not scripts + if (!itr->second->CanItemApplyEquipSpell(player, item)) + ret = false; // we change ret value only when scripts return false + + return ret; +} + +bool ScriptMgr::CanSendAuctionHello(WorldSession const* session, uint64 guid, Creature* creature) +{ + bool ret = true; + + FOR_SCRIPTS_RET(MiscScript, itr, end, ret) // return true by default if not scripts + if (!itr->second->CanSendAuctionHello(session, guid, creature)) + ret = false; // we change ret value only when scripts return false + + return ret; +} + +void ScriptMgr::ValidateSpellAtCastSpell(Player* player, uint32& oldSpellId, uint32& spellId, uint8& castCount, uint8& castFlags) +{ + FOREACH_SCRIPT(MiscScript)->ValidateSpellAtCastSpell(player, oldSpellId, spellId, castCount, castFlags); +} + +void ScriptMgr::ValidateSpellAtCastSpellResult(Player* player, Unit* mover, Spell* spell, uint32 oldSpellId, uint32 spellId) +{ + FOREACH_SCRIPT(MiscScript)->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) +{ + FOREACH_SCRIPT(MiscScript)->OnAfterLootTemplateProcess(loot, tab, store, lootOwner, personal, noEmptyError, lootMode); +} + +void ScriptMgr::OnInstanceSave(InstanceSave* instanceSave) +{ + FOREACH_SCRIPT(MiscScript)->OnInstanceSave(instanceSave); +} + +void ScriptMgr::OnPlayerSetPhase(const AuraEffect* auraEff, AuraApplication const* aurApp, uint8 mode, bool apply, uint32& newPhase) +{ + FOREACH_SCRIPT(MiscScript)->OnPlayerSetPhase(auraEff, aurApp, mode, apply, newPhase); +} + +void ScriptMgr::OnHandleDevCommand(Player* player, std::string& argstr) +{ + FOREACH_SCRIPT(CommandSC)->OnHandleDevCommand(player, argstr); +} + +///- +AllMapScript::AllMapScript(const char* name) + : ScriptObject(name) +{ + ScriptRegistry::AddScript(this); +} + +AllCreatureScript::AllCreatureScript(const char* name) + : ScriptObject(name) +{ + ScriptRegistry::AddScript(this); +} + +UnitScript::UnitScript(const char* name, bool addToScripts) + : ScriptObject(name) +{ + if (addToScripts) + ScriptRegistry::AddScript(this); +} + +MovementHandlerScript::MovementHandlerScript(const char* name) + : ScriptObject(name) +{ + ScriptRegistry::AddScript(this); +} + +SpellScriptLoader::SpellScriptLoader(const char* name) + : ScriptObject(name) +{ + ScriptRegistry::AddScript(this); +} + +ServerScript::ServerScript(const char* name) + : ScriptObject(name) +{ + ScriptRegistry::AddScript(this); +} + +WorldScript::WorldScript(const char* name) + : ScriptObject(name) +{ + ScriptRegistry::AddScript(this); +} + +FormulaScript::FormulaScript(const char* name) + : ScriptObject(name) +{ + ScriptRegistry::AddScript(this); +} + +WorldMapScript::WorldMapScript(const char* name, uint32 mapId) + : ScriptObject(name), MapScript(mapId) +{ + ScriptRegistry::AddScript(this); +} + +InstanceMapScript::InstanceMapScript(const char* name, uint32 mapId) + : ScriptObject(name), MapScript(mapId) +{ + ScriptRegistry::AddScript(this); +} + +BattlegroundMapScript::BattlegroundMapScript(const char* name, uint32 mapId) + : ScriptObject(name), MapScript(mapId) +{ + ScriptRegistry::AddScript(this); +} + +ItemScript::ItemScript(const char* name) + : ScriptObject(name) +{ + ScriptRegistry::AddScript(this); +} + +CreatureScript::CreatureScript(const char* name) + : ScriptObject(name) +{ + ScriptRegistry::AddScript(this); +} + +GameObjectScript::GameObjectScript(const char* name) + : ScriptObject(name) +{ + ScriptRegistry::AddScript(this); +} + +AreaTriggerScript::AreaTriggerScript(const char* name) + : ScriptObject(name) +{ + ScriptRegistry::AddScript(this); +} + +BattlegroundScript::BattlegroundScript(const char* name) + : ScriptObject(name) +{ + ScriptRegistry::AddScript(this); +} + +OutdoorPvPScript::OutdoorPvPScript(const char* name) + : ScriptObject(name) +{ + ScriptRegistry::AddScript(this); +} + +CommandScript::CommandScript(const char* name) + : ScriptObject(name) +{ + ScriptRegistry::AddScript(this); +} + +WeatherScript::WeatherScript(const char* name) + : ScriptObject(name) +{ + ScriptRegistry::AddScript(this); +} + +AuctionHouseScript::AuctionHouseScript(const char* name) + : ScriptObject(name) +{ + ScriptRegistry::AddScript(this); +} + +ConditionScript::ConditionScript(const char* name) + : ScriptObject(name) +{ + ScriptRegistry::AddScript(this); +} + +VehicleScript::VehicleScript(const char* name) + : ScriptObject(name) +{ + ScriptRegistry::AddScript(this); +} + +DynamicObjectScript::DynamicObjectScript(const char* name) + : ScriptObject(name) +{ + ScriptRegistry::AddScript(this); +} + +TransportScript::TransportScript(const char* name) + : ScriptObject(name) +{ + ScriptRegistry::AddScript(this); +} + +AchievementCriteriaScript::AchievementCriteriaScript(const char* name) + : ScriptObject(name) +{ + ScriptRegistry::AddScript(this); +} + +PlayerScript::PlayerScript(const char* name) + : ScriptObject(name) +{ + ScriptRegistry::AddScript(this); +} + +AccountScript::AccountScript(const char* name) + : ScriptObject(name) +{ + ScriptRegistry::AddScript(this); +} + +GuildScript::GuildScript(const char* name) + : ScriptObject(name) +{ + ScriptRegistry::AddScript(this); +} + +GroupScript::GroupScript(const char* name) + : ScriptObject(name) +{ + ScriptRegistry::AddScript(this); +} + +GlobalScript::GlobalScript(const char* name) + : ScriptObject(name) +{ + ScriptRegistry::AddScript(this); +} + +BGScript::BGScript(char const* name) + : ScriptObject(name) +{ + ScriptRegistry::AddScript(this); +} + +ArenaTeamScript::ArenaTeamScript(const char* name) + : ScriptObject(name) +{ + ScriptRegistry::AddScript(this); +} + +SpellSC::SpellSC(char const* name) + : ScriptObject(name) +{ + ScriptRegistry::AddScript(this); +} + +ModuleScript::ModuleScript(const char* name) + : ScriptObject(name) +{ + ScriptRegistry::AddScript(this); +} + +GameEventScript::GameEventScript(const char* name) + : ScriptObject(name) +{ + ScriptRegistry::AddScript(this); +} + +MailScript::MailScript(const char* name) + : ScriptObject(name) +{ + ScriptRegistry::AddScript(this); +} + +AchievementScript::AchievementScript(const char* name) + : ScriptObject(name) +{ + ScriptRegistry::AddScript(this); +} + +PetScript::PetScript(const char* name) + : ScriptObject(name) +{ + ScriptRegistry::AddScript(this); +} + +ArenaScript::ArenaScript(const char* name) + : ScriptObject(name) +{ + ScriptRegistry::AddScript(this); +} + +MiscScript::MiscScript(const char* name) + : ScriptObject(name) +{ + ScriptRegistry::AddScript(this); +} + +CommandSC::CommandSC(const char* name) + : ScriptObject(name) +{ + ScriptRegistry::AddScript(this); } -- cgit v1.2.3