#include "ScriptMgr.h"

Public Types
typedef void(*	ScriptLoaderCallbackType) ()

typedef void(*	ModulesLoaderCallbackType) ()

Public Member Functions
void	Initialize ()

void	LoadDatabase ()

void	FillSpellSummary ()

void	CheckIfScriptsInDatabaseExist ()

std::string_view	ScriptsVersion () const

void	IncreaseScriptCount ()

void	DecreaseScriptCount ()

uint32	GetScriptCount () const

void	SetScriptLoader (ScriptLoaderCallbackType script_loader_callback)

void	SetModulesLoader (ModulesLoaderCallbackType script_loader_callback)

void	Unload ()

void	CreateSpellScripts (uint32 spellId, std::list< SpellScript * > &scriptVector)

void	CreateAuraScripts (uint32 spellId, std::list< AuraScript * > &scriptVector)

void	CreateSpellScriptLoaders (uint32 spellId, std::vector< std::pair< SpellScriptLoader *, std::multimap< uint32, uint32 >::iterator > > &scriptVector)

void	OnNetworkStart ()

void	OnNetworkStop ()

void	OnSocketOpen (std::shared_ptr< WorldSocket > socket)

void	OnSocketClose (std::shared_ptr< WorldSocket > socket)

bool	CanPacketReceive (WorldSession *session, WorldPacket const &packet)

bool	CanPacketSend (WorldSession *session, WorldPacket const &packet)

void	OnLoadCustomDatabaseTable ()

void	OnOpenStateChange (bool open)

void	OnBeforeConfigLoad (bool reload)

void	OnAfterConfigLoad (bool reload)

void	OnBeforeFinalizePlayerWorldSession (uint32 &cacheVersion)

void	OnMotdChange (std::string &newMotd)

void	OnShutdownInitiate (ShutdownExitCode code, ShutdownMask mask)

void	OnShutdownCancel ()

void	OnWorldUpdate (uint32 diff)

void	OnStartup ()

void	OnShutdown ()

void	OnBeforeWorldInitialized ()

void	OnAfterUnloadAllMaps ()

void	OnHonorCalculation (float &honor, uint8 level, float multiplier)

void	OnGrayLevelCalculation (uint8 &grayLevel, uint8 playerLevel)

void	OnColorCodeCalculation (XPColorChar &color, uint8 playerLevel, uint8 mobLevel)

void	OnZeroDifferenceCalculation (uint8 &diff, uint8 playerLevel)

void	OnBaseGainCalculation (uint32 &gain, uint8 playerLevel, uint8 mobLevel, ContentLevels content)

void	OnGainCalculation (uint32 &gain, Player player, Unit unit)

void	OnGroupRateCalculation (float &rate, uint32 count, bool isRaid)

void	OnAfterArenaRatingCalculation (Battleground *const bg, int32 &winnerMatchmakerChange, int32 &loserMatchmakerChange, int32 &winnerChange, int32 &loserChange)

void	OnBeforeUpdatingPersonalRating (int32 &mod, uint32 type)

void	OnCreateMap (Map *map)

void	OnDestroyMap (Map *map)

void	OnLoadGridMap (Map map, GridMap gmap, uint32 gx, uint32 gy)

void	OnUnloadGridMap (Map map, GridMap gmap, uint32 gx, uint32 gy)

void	OnPlayerEnterMap (Map map, Player player)

void	OnPlayerLeaveMap (Map map, Player player)

void	OnMapUpdate (Map *map, uint32 diff)

InstanceScript *	CreateInstanceScript (InstanceMap *map)

bool	OnQuestAccept (Player player, Item item, Quest const *quest)

bool	OnItemUse (Player player, Item item, SpellCastTargets const &targets)

bool	OnItemExpire (Player player, ItemTemplate const proto)

bool	OnItemRemove (Player player, Item item)

bool	OnCastItemCombatSpell (Player player, Unit victim, SpellInfo const spellInfo, Item item)

void	OnGossipSelect (Player player, Item item, uint32 sender, uint32 action)

void	OnGossipSelectCode (Player player, Item item, uint32 sender, uint32 action, const char *code)

bool	OnGossipHello (Player player, Creature creature)

bool	OnGossipSelect (Player player, Creature creature, uint32 sender, uint32 action)

bool	OnGossipSelectCode (Player player, Creature creature, uint32 sender, uint32 action, const char *code)

bool	OnQuestAccept (Player player, Creature creature, Quest const *quest)

bool	OnQuestSelect (Player player, Creature creature, Quest const *quest)

bool	OnQuestComplete (Player player, Creature creature, Quest const *quest)

bool	OnQuestReward (Player player, Creature creature, Quest const *quest, uint32 opt)

uint32	GetDialogStatus (Player player, Creature creature)

CreatureAI *	GetCreatureAI (Creature *creature)

void	OnCreatureUpdate (Creature *creature, uint32 diff)

void	OnCreatureAddWorld (Creature *creature)

void	OnCreatureRemoveWorld (Creature *creature)

void	OnFfaPvpStateUpdate (Creature *creature, bool InPvp)

bool	OnGossipHello (Player player, GameObject go)

bool	OnGossipSelect (Player player, GameObject go, uint32 sender, uint32 action)

bool	OnGossipSelectCode (Player player, GameObject go, uint32 sender, uint32 action, const char *code)

bool	OnQuestAccept (Player player, GameObject go, Quest const *quest)

bool	OnQuestReward (Player player, GameObject go, Quest const *quest, uint32 opt)

uint32	GetDialogStatus (Player player, GameObject go)

void	OnGameObjectDestroyed (GameObject go, Player player)

void	OnGameObjectDamaged (GameObject go, Player player)

void	OnGameObjectModifyHealth (GameObject go, Unit attackerOrHealer, int32 &change, SpellInfo const *spellInfo)

void	OnGameObjectLootStateChanged (GameObject go, uint32 state, Unit unit)

void	OnGameObjectStateChanged (GameObject *go, uint32 state)

void	OnGameObjectUpdate (GameObject *go, uint32 diff)

GameObjectAI *	GetGameObjectAI (GameObject *go)

void	OnGameObjectAddWorld (GameObject *go)

void	OnGameObjectRemoveWorld (GameObject *go)

bool	OnAreaTrigger (Player player, AreaTrigger const trigger)

Battleground *	CreateBattleground (BattlegroundTypeId typeId)

OutdoorPvP *	CreateOutdoorPvP (OutdoorPvPData const *data)

std::vector< Acore::ChatCommands::ChatCommandBuilder >	GetChatCommands ()

void	OnWeatherChange (Weather *weather, WeatherState state, float grade)

void	OnWeatherUpdate (Weather *weather, uint32 diff)

void	OnAuctionAdd (AuctionHouseObject ah, AuctionEntry entry)

void	OnAuctionRemove (AuctionHouseObject ah, AuctionEntry entry)

void	OnAuctionSuccessful (AuctionHouseObject ah, AuctionEntry entry)

void	OnAuctionExpire (AuctionHouseObject ah, AuctionEntry entry)

void	OnBeforeAuctionHouseMgrSendAuctionWonMail (AuctionHouseMgr auctionHouseMgr, AuctionEntry auction, Player *bidder, uint32 &bidder_accId, bool &sendNotification, bool &updateAchievementCriteria, bool &sendMail)

void	OnBeforeAuctionHouseMgrSendAuctionSalePendingMail (AuctionHouseMgr auctionHouseMgr, AuctionEntry auction, Player *owner, uint32 &owner_accId, bool &sendMail)

void	OnBeforeAuctionHouseMgrSendAuctionSuccessfulMail (AuctionHouseMgr auctionHouseMgr, AuctionEntry auction, Player *owner, uint32 &owner_accId, uint32 &profit, bool &sendNotification, bool &updateAchievementCriteria, bool &sendMail)

void	OnBeforeAuctionHouseMgrSendAuctionExpiredMail (AuctionHouseMgr auctionHouseMgr, AuctionEntry auction, Player *owner, uint32 &owner_accId, bool &sendNotification, bool &sendMail)

void	OnBeforeAuctionHouseMgrSendAuctionOutbiddedMail (AuctionHouseMgr auctionHouseMgr, AuctionEntry auction, Player oldBidder, uint32 &oldBidder_accId, Player newBidder, uint32 &newPrice, bool &sendNotification, bool &sendMail)

void	OnBeforeAuctionHouseMgrSendAuctionCancelledToBidderMail (AuctionHouseMgr auctionHouseMgr, AuctionEntry auction, Player *bidder, uint32 &bidder_accId, bool &sendMail)

void	OnBeforeAuctionHouseMgrUpdate ()

bool	OnConditionCheck (Condition *condition, ConditionSourceInfo &sourceInfo)

void	OnInstall (Vehicle *veh)

void	OnUninstall (Vehicle *veh)

void	OnReset (Vehicle *veh)

void	OnInstallAccessory (Vehicle veh, Creature accessory)

void	OnAddPassenger (Vehicle veh, Unit passenger, int8 seatId)

void	OnRemovePassenger (Vehicle veh, Unit passenger)

void	OnDynamicObjectUpdate (DynamicObject *dynobj, uint32 diff)

void	OnAddPassenger (Transport transport, Player player)

void	OnAddCreaturePassenger (Transport transport, Creature creature)

void	OnRemovePassenger (Transport transport, Player player)

void	OnTransportUpdate (Transport *transport, uint32 diff)

void	OnRelocate (Transport *transport, uint32 waypointId, uint32 mapId, float x, float y, float z)

bool	OnCriteriaCheck (uint32 scriptId, Player source, Unit target, uint32 criteria_id)

void	OnBeforePlayerUpdate (Player *player, uint32 p_time)

void	OnPlayerUpdate (Player *player, uint32 p_time)

void	OnSendInitialPacketsBeforeAddToMap (Player *player, WorldPacket &data)

void	OnPlayerReleasedGhost (Player *player)

void	OnPVPKill (Player killer, Player killed)

void	OnPlayerPVPFlagChange (Player *player, bool state)

void	OnCreatureKill (Player killer, Creature killed)

void	OnCreatureKilledByPet (Player petOwner, Creature killed)

void	OnPlayerKilledByCreature (Creature killer, Player killed)

void	OnPlayerLevelChanged (Player *player, uint8 oldLevel)

void	OnPlayerFreeTalentPointsChanged (Player *player, uint32 newPoints)

void	OnPlayerTalentsReset (Player *player, bool noCost)

void	OnAfterSpecSlotChanged (Player *player, uint8 newSlot)

void	OnPlayerMoneyChanged (Player *player, int32 &amount)

void	OnBeforeLootMoney (Player player, Loot loot)

void	OnGivePlayerXP (Player player, uint32 &amount, Unit victim, uint8 xpSource)

bool	OnPlayerReputationChange (Player *player, uint32 factionID, int32 &standing, bool incremental)

void	OnPlayerReputationRankChange (Player *player, uint32 factionID, ReputationRank newRank, ReputationRank oldRank, bool increased)

void	OnPlayerLearnSpell (Player *player, uint32 spellID)

void	OnPlayerForgotSpell (Player *player, uint32 spellID)

void	OnPlayerDuelRequest (Player target, Player challenger)

void	OnPlayerDuelStart (Player player1, Player player2)

void	OnPlayerDuelEnd (Player winner, Player loser, DuelCompleteType type)

void	OnPlayerChat (Player *player, uint32 type, uint32 lang, std::string &msg)

void	OnBeforeSendChatMessage (Player *player, uint32 &type, uint32 &lang, std::string &msg)

void	OnPlayerChat (Player player, uint32 type, uint32 lang, std::string &msg, Player receiver)

void	OnPlayerChat (Player player, uint32 type, uint32 lang, std::string &msg, Group group)

void	OnPlayerChat (Player player, uint32 type, uint32 lang, std::string &msg, Guild guild)

void	OnPlayerChat (Player player, uint32 type, uint32 lang, std::string &msg, Channel channel)

void	OnPlayerEmote (Player *player, uint32 emote)

void	OnPlayerTextEmote (Player *player, uint32 textEmote, uint32 emoteNum, ObjectGuid guid)

void	OnPlayerSpellCast (Player player, Spell spell, bool skipCheck)

void	OnPlayerLogin (Player *player)

void	OnPlayerLoadFromDB (Player *player)

void	OnPlayerLogout (Player *player)

void	OnPlayerCreate (Player *player)

void	OnPlayerSave (Player *player)

void	OnPlayerDelete (ObjectGuid guid, uint32 accountId)

void	OnPlayerFailedDelete (ObjectGuid guid, uint32 accountId)

void	OnPlayerBindToInstance (Player *player, Difficulty difficulty, uint32 mapid, bool permanent)

void	OnPlayerUpdateZone (Player *player, uint32 newZone, uint32 newArea)

void	OnPlayerUpdateArea (Player *player, uint32 oldArea, uint32 newArea)

bool	OnBeforePlayerTeleport (Player player, uint32 mapid, float x, float y, float z, float orientation, uint32 options, Unit target)

void	OnPlayerUpdateFaction (Player *player)

void	OnPlayerAddToBattleground (Player player, Battleground bg)

void	OnPlayerQueueRandomDungeon (Player *player, uint32 &rDungeonId)

void	OnPlayerRemoveFromBattleground (Player player, Battleground bg)

void	OnAchievementComplete (Player player, AchievementEntry const achievement)

bool	OnBeforeAchievementComplete (Player player, AchievementEntry const achievement)

void	OnCriteriaProgress (Player player, AchievementCriteriaEntry const criteria)

bool	OnBeforeCriteriaProgress (Player player, AchievementCriteriaEntry const criteria)

void	OnAchievementSave (CharacterDatabaseTransaction trans, Player *player, uint16 achiId, CompletedAchievementData achiData)

void	OnCriteriaSave (CharacterDatabaseTransaction trans, Player *player, uint16 critId, CriteriaProgress criteriaData)

void	OnGossipSelect (Player *player, uint32 menu_id, uint32 sender, uint32 action)

void	OnGossipSelectCode (Player player, uint32 menu_id, uint32 sender, uint32 action, const char code)

void	OnPlayerBeingCharmed (Player player, Unit charmer, uint32 oldFactionId, uint32 newFactionId)

void	OnAfterPlayerSetVisibleItemSlot (Player player, uint8 slot, Item item)

void	OnAfterPlayerMoveItemFromInventory (Player player, Item it, uint8 bag, uint8 slot, bool update)

void	OnEquip (Player player, Item it, uint8 bag, uint8 slot, bool update)

void	OnPlayerJoinBG (Player *player)

void	OnPlayerJoinArena (Player *player)

void	GetCustomGetArenaTeamId (Player const *player, uint8 slot, uint32 &teamID) const

void	GetCustomArenaPersonalRating (Player const *player, uint8 slot, uint32 &rating) const

void	OnGetMaxPersonalArenaRatingRequirement (Player const *player, uint32 minSlot, uint32 &maxArenaRating) const

void	OnLootItem (Player player, Item item, uint32 count, ObjectGuid lootguid)

void	OnBeforeFillQuestLootItem (Player *player, LootItem &item)

void	OnStoreNewItem (Player player, Item item, uint32 count)

void	OnCreateItem (Player player, Item item, uint32 count)

void	OnQuestRewardItem (Player player, Item item, uint32 count)

bool	CanPlaceAuctionBid (Player player, AuctionEntry auction)

void	OnGroupRollRewardItem (Player player, Item item, uint32 count, RollVote voteType, Roll *roll)

bool	OnBeforeOpenItem (Player player, Item item)

bool	OnBeforePlayerQuestComplete (Player *player, uint32 quest_id)

void	OnQuestComputeXP (Player player, Quest const quest, uint32 &xpValue)

void	OnBeforePlayerDurabilityRepair (Player *player, ObjectGuid npcGUID, ObjectGuid itemGUID, float &discountMod, uint8 guildBank)

void	OnBeforeBuyItemFromVendor (Player *player, ObjectGuid vendorguid, uint32 vendorslot, uint32 &item, uint8 count, uint8 bag, uint8 slot)

void	OnBeforeStoreOrEquipNewItem (Player player, uint32 vendorslot, uint32 &item, uint8 count, uint8 bag, uint8 slot, ItemTemplate const pProto, Creature pVendor, VendorItem const crItem, bool bStore)

void	OnAfterStoreOrEquipNewItem (Player player, uint32 vendorslot, Item item, uint8 count, uint8 bag, uint8 slot, ItemTemplate const pProto, Creature pVendor, VendorItem const *crItem, bool bStore)

void	OnAfterUpdateMaxPower (Player *player, Powers &power, float &value)

void	OnAfterUpdateMaxHealth (Player *player, float &value)

void	OnBeforeUpdateAttackPowerAndDamage (Player *player, float &level, float &val2, bool ranged)

void	OnAfterUpdateAttackPowerAndDamage (Player *player, float &level, float &base_attPower, float &attPowerMod, float &attPowerMultiplier, bool ranged)

void	OnBeforeInitTalentForLevel (Player *player, uint8 &level, uint32 &talentPointsForLevel)

void	OnFirstLogin (Player *player)

void	OnSetMaxLevel (Player *player, uint32 &maxPlayerLevel)

void	OnPlayerCompleteQuest (Player player, Quest const quest)

void	OnBattlegroundDesertion (Player *player, BattlegroundDesertionType const desertionType)

bool	CanJoinInBattlegroundQueue (Player *player, ObjectGuid BattlemasterGuid, BattlegroundTypeId BGTypeID, uint8 joinAsGroup, GroupJoinBattlegroundResult &err)

bool	ShouldBeRewardedWithMoneyInsteadOfExp (Player *player)

void	OnBeforeTempSummonInitStats (Player player, TempSummon tempSummon, uint32 &duration)

void	OnBeforeGuardianInitStatsForLevel (Player player, Guardian guardian, CreatureTemplate const *cinfo, PetType &petType)

void	OnAfterGuardianInitStatsForLevel (Player player, Guardian guardian)

void	OnBeforeLoadPetFromDB (Player *player, uint32 &petentry, uint32 &petnumber, bool &current, bool &forceLoadFromDB)

bool	CanJoinInArenaQueue (Player *player, ObjectGuid BattlemasterGuid, uint8 arenaslot, BattlegroundTypeId BGTypeID, uint8 joinAsGroup, uint8 IsRated, GroupJoinBattlegroundResult &err)

bool	CanBattleFieldPort (Player *player, uint8 arenaType, BattlegroundTypeId BGTypeID, uint8 action)

bool	CanGroupInvite (Player *player, std::string &membername)

bool	CanGroupAccept (Player player, Group group)

bool	CanSellItem (Player player, Item item, Creature *creature)

bool	CanSendMail (Player player, ObjectGuid receiverGuid, ObjectGuid mailbox, std::string &subject, std::string &body, uint32 money, uint32 COD, Item item)

void	PetitionBuy (Player player, Creature creature, uint32 &charterid, uint32 &cost, uint32 &type)

void	PetitionShowList (Player player, Creature creature, uint32 &CharterEntry, uint32 &CharterDispayID, uint32 &CharterCost)

void	OnRewardKillRewarder (Player *player, bool isDungeon, float &rate)

bool	CanGiveMailRewardAtGiveLevel (Player *player, uint8 level)

void	OnDeleteFromDB (CharacterDatabaseTransaction trans, uint32 guid)

bool	CanRepopAtGraveyard (Player *player)

void	OnGetMaxSkillValue (Player *player, uint32 skill, int32 &result, bool IsPure)

void	OnUpdateGatheringSkill (Player *player, uint32 skillId, uint32 currentLevel, uint32 gray, uint32 green, uint32 yellow, uint32 &gain)

void	OnUpdateCraftingSkill (Player player, SkillLineAbilityEntry const skill, uint32 currentLevel, uint32 &gain)

bool	OnUpdateFishingSkill (Player *player, int32 skill, int32 zone_skill, int32 chance, int32 roll)

bool	CanAreaExploreAndOutdoor (Player *player)

void	OnVictimRewardBefore (Player player, Player victim, uint32 &killer_title, uint32 &victim_title)

void	OnVictimRewardAfter (Player player, Player victim, uint32 &killer_title, uint32 &victim_rank, float &honor_f)

void	OnCustomScalingStatValueBefore (Player player, ItemTemplate const proto, uint8 slot, bool apply, uint32 &CustomScalingStatValue)

void	OnCustomScalingStatValue (Player player, ItemTemplate const proto, uint32 &statType, int32 &val, uint8 itemProtoStatNumber, uint32 ScalingStatValue, ScalingStatValuesEntry const *ssv)

bool	CanArmorDamageModifier (Player *player)

void	OnGetFeralApBonus (Player player, int32 &feral_bonus, int32 dpsMod, ItemTemplate const proto, ScalingStatValuesEntry const *ssv)

bool	CanApplyWeaponDependentAuraDamageMod (Player player, Item item, WeaponAttackType attackType, AuraEffect const *aura, bool apply)

bool	CanApplyEquipSpell (Player player, SpellInfo const spellInfo, Item *item, bool apply, bool form_change)

bool	CanApplyEquipSpellsItemSet (Player player, ItemSetEffect eff)

bool	CanCastItemCombatSpell (Player player, Unit target, WeaponAttackType attType, uint32 procVictim, uint32 procEx, Item item, ItemTemplate const proto)

bool	CanCastItemUseSpell (Player player, Item item, SpellCastTargets const &targets, uint8 cast_count, uint32 glyphIndex)

void	OnApplyAmmoBonuses (Player player, ItemTemplate const proto, float &currentAmmoDPS)

bool	CanEquipItem (Player player, uint8 slot, uint16 &dest, Item pItem, bool swap, bool not_loading)

bool	CanUnequipItem (Player *player, uint16 pos, bool swap)

bool	CanUseItem (Player player, ItemTemplate const proto, InventoryResult &result)

bool	CanSaveEquipNewItem (Player player, Item item, uint16 pos, bool update)

bool	CanApplyEnchantment (Player player, Item item, EnchantmentSlot slot, bool apply, bool apply_dur, bool ignore_condition)

void	OnGetQuestRate (Player *player, float &result)

bool	PassedQuestKilledMonsterCredit (Player player, Quest const qinfo, uint32 entry, uint32 real_entry, ObjectGuid guid)

bool	CheckItemInSlotAtLoadInventory (Player player, Item item, uint8 slot, uint8 &err, uint16 &dest)

bool	NotAvoidSatisfy (Player player, DungeonProgressionRequirements const ar, uint32 target_map, bool report)

bool	NotVisibleGloballyFor (Player player, Player const u)

void	OnGetArenaPersonalRating (Player *player, uint8 slot, uint32 &result)

void	OnFfaPvpStateUpdate (Player *player, bool result)

void	OnGetArenaTeamId (Player *player, uint8 slot, uint32 &result)

void	OnIsFFAPvP (Player *player, bool &result)

void	OnIsPvP (Player *player, bool &result)

void	OnGetMaxSkillValueForLevel (Player *player, uint16 &result)

bool	NotSetArenaTeamInfoField (Player *player, uint8 slot, ArenaTeamInfoType type, uint32 value)

bool	CanJoinLfg (Player *player, uint8 roles, lfg::LfgDungeonSet &dungeons, const std::string &comment)

bool	CanEnterMap (Player player, MapEntry const entry, InstanceTemplate const instance, MapDifficulty const mapDiff, bool loginCheck)

bool	CanInitTrade (Player player, Player target)

void	OnSetServerSideVisibility (Player *player, ServerSideVisibilityType &type, AccountTypes &sec)

void	OnSetServerSideVisibilityDetect (Player *player, ServerSideVisibilityType &type, AccountTypes &sec)

void	OnPlayerResurrect (Player *player, float restore_percent, bool applySickness)

void	OnBeforeChooseGraveyard (Player *player, TeamId teamId, bool nearCorpse, uint32 &graveyardOverride)

bool	CanPlayerUseChat (Player *player, uint32 type, uint32 language, std::string &msg)

bool	CanPlayerUseChat (Player player, uint32 type, uint32 language, std::string &msg, Player receiver)

bool	CanPlayerUseChat (Player player, uint32 type, uint32 language, std::string &msg, Group group)

bool	CanPlayerUseChat (Player player, uint32 type, uint32 language, std::string &msg, Guild guild)

bool	CanPlayerUseChat (Player player, uint32 type, uint32 language, std::string &msg, Channel channel)

void	OnPlayerLearnTalents (Player *player, uint32 talentId, uint32 talentRank, uint32 spellid)

void	OnPlayerEnterCombat (Player player, Unit enemy)

void	OnPlayerLeaveCombat (Player *player)

void	OnQuestAbandon (Player *player, uint32 questId)

bool	CanSendErrorAlreadyLooted (Player *player)

void	OnAfterCreatureLoot (Player *player)

void	OnAfterCreatureLootMoney (Player *player)

bool	OnCanPlayerFlyInZone (Player player, uint32 mapId, uint32 zoneId, SpellInfo const bySpell)

void	AnticheatSetSkipOnePacketForASH (Player *player, bool apply)

void	AnticheatSetCanFlybyServer (Player *player, bool apply)

void	AnticheatSetUnderACKmount (Player *player)

void	AnticheatSetRootACKUpd (Player *player)

void	AnticheatUpdateMovementInfo (Player *player, MovementInfo const &movementInfo)

void	AnticheatSetJumpingbyOpcode (Player *player, bool jump)

bool	AnticheatHandleDoubleJump (Player player, Unit mover)

bool	AnticheatCheckMovementInfo (Player player, MovementInfo const &movementInfo, Unit mover, bool jump)

void	OnAccountLogin (uint32 accountId)

void	OnLastIpUpdate (uint32 accountId, std::string ip)

void	OnFailedAccountLogin (uint32 accountId)

void	OnEmailChange (uint32 accountId)

void	OnFailedEmailChange (uint32 accountId)

void	OnPasswordChange (uint32 accountId)

void	OnFailedPasswordChange (uint32 accountId)

bool	CanAccountCreateCharacter (uint32 accountId, uint8 charRace, uint8 charClass)

void	OnGuildAddMember (Guild guild, Player player, uint8 &plRank)

void	OnGuildRemoveMember (Guild guild, Player player, bool isDisbanding, bool isKicked)

void	OnGuildMOTDChanged (Guild *guild, const std::string &newMotd)

void	OnGuildInfoChanged (Guild *guild, const std::string &newInfo)

void	OnGuildCreate (Guild guild, Player leader, const std::string &name)

void	OnGuildDisband (Guild *guild)

void	OnGuildMemberWitdrawMoney (Guild guild, Player player, uint32 &amount, bool isRepair)

void	OnGuildMemberDepositMoney (Guild guild, Player player, uint32 &amount)

void	OnGuildItemMove (Guild guild, Player player, Item *pItem, bool isSrcBank, uint8 srcContainer, uint8 srcSlotId, bool isDestBank, uint8 destContainer, uint8 destSlotId)

void	OnGuildEvent (Guild *guild, uint8 eventType, ObjectGuid::LowType playerGuid1, ObjectGuid::LowType playerGuid2, uint8 newRank)

void	OnGuildBankEvent (Guild *guild, uint8 eventType, uint8 tabId, ObjectGuid::LowType playerGuid, uint32 itemOrMoney, uint16 itemStackCount, uint8 destTabId)

bool	CanGuildSendBankList (Guild const guild, WorldSession session, uint8 tabId, bool sendAllSlots)

void	OnGroupAddMember (Group *group, ObjectGuid guid)

void	OnGroupInviteMember (Group *group, ObjectGuid guid)

void	OnGroupRemoveMember (Group group, ObjectGuid guid, RemoveMethod method, ObjectGuid kicker, const char reason)

void	OnGroupChangeLeader (Group *group, ObjectGuid newLeaderGuid, ObjectGuid oldLeaderGuid)

void	OnGroupDisband (Group *group)

bool	CanGroupJoinBattlegroundQueue (Group const group, Player member, Battleground const *bgTemplate, uint32 MinPlayerCount, bool isRated, uint32 arenaSlot)

void	OnCreate (Group group, Player leader)

void	OnGlobalItemDelFromDB (CharacterDatabaseTransaction trans, ObjectGuid::LowType itemGuid)

void	OnGlobalMirrorImageDisplayItem (Item const *item, uint32 &display)

void	OnBeforeUpdateArenaPoints (ArenaTeam *at, std::map< ObjectGuid, uint32 > &ap)

void	OnAfterRefCount (Player const player, Loot &loot, bool canRate, uint16 lootMode, LootStoreItem LootStoreItem, uint32 &maxcount, LootStore const &store)

void	OnAfterCalculateLootGroupAmount (Player const *player, Loot &loot, uint16 lootMode, uint32 &groupAmount, LootStore const &store)

void	OnBeforeDropAddItem (Player const player, Loot &loot, bool canRate, uint16 lootMode, LootStoreItem LootStoreItem, LootStore const &store)

bool	OnItemRoll (Player const player, LootStoreItem const LootStoreItem, float &chance, Loot &loot, LootStore const &store)

bool	OnBeforeLootEqualChanced (Player const *player, LootStoreItemList EqualChanced, Loot &loot, LootStore const &store)

void	OnInitializeLockedDungeons (Player player, uint8 &level, uint32 &lockData, lfg::LFGDungeonData const dungeon)

void	OnAfterInitializeLockedDungeons (Player *player)

void	OnAfterUpdateEncounterState (Map map, EncounterCreditType type, uint32 creditEntry, Unit source, Difficulty difficulty_fixed, DungeonEncounterList const *encounters, uint32 dungeonCompleted, bool updated)

void	OnBeforeWorldObjectSetPhaseMask (WorldObject const *worldObject, uint32 &oldPhaseMask, uint32 &newPhaseMask, bool &useCombinedPhases, bool &update)

bool	OnIsAffectedBySpellModCheck (SpellInfo const affectSpell, SpellInfo const checkSpell, SpellModifier const *mod)

bool	OnSpellHealingBonusTakenNegativeModifiers (Unit const target, Unit const caster, SpellInfo const *spellInfo, float &val)

void	OnLoadSpellCustomAttr (SpellInfo *spell)

bool	OnAllowedForPlayerLootCheck (Player const *player, ObjectGuid source)

bool	OnAllowedToLootContainerCheck (Player const *player, ObjectGuid source)

void	OnInstanceIdRemoved (uint32 instanceId)
	Called when an instance Id is deleted, usually because it expired or no players are bound to it anymore.

void	OnBeforeSetBossState (uint32 id, EncounterState newState, EncounterState oldState, Map *instance)
	Called when any raid boss has their state updated (e.g. pull, reset, kill).

void	AfterInstanceGameObjectCreate (Map instance, GameObject go)
	Called when a game object is created inside an instance.

uint32	IncreaseScheduledScriptsCount ()

uint32	DecreaseScheduledScriptCount ()

uint32	DecreaseScheduledScriptCount (size_t count)

bool	IsScriptScheduled () const

void	OnHeal (Unit healer, Unit reciever, uint32 &gain)

void	OnDamage (Unit attacker, Unit victim, uint32 &damage)

void	ModifyPeriodicDamageAurasTick (Unit target, Unit attacker, uint32 &damage, SpellInfo const *spellInfo)

void	ModifyMeleeDamage (Unit target, Unit attacker, uint32 &damage)

void	ModifySpellDamageTaken (Unit target, Unit attacker, int32 &damage, SpellInfo const *spellInfo)

void	ModifyHealReceived (Unit target, Unit healer, uint32 &addHealth, SpellInfo const *spellInfo)

uint32	DealDamage (Unit AttackerUnit, Unit pVictim, uint32 damage, DamageEffectType damagetype)

void	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)

void	OnAuraApply (Unit , Aura )

void	OnAuraRemove (Unit unit, AuraApplication aurApp, AuraRemoveMode mode)

bool	IfNormalReaction (Unit const unit, Unit const target, ReputationRank &repRank)

bool	IsNeedModSpellDamagePercent (Unit const unit, AuraEffect auraEff, float &doneTotalMod, SpellInfo const *spellProto)

bool	IsNeedModMeleeDamagePercent (Unit const unit, AuraEffect auraEff, float &doneTotalMod, SpellInfo const *spellProto)

bool	IsNeedModHealPercent (Unit const unit, AuraEffect auraEff, float &doneTotalMod, SpellInfo const *spellProto)

bool	CanSetPhaseMask (Unit const *unit, uint32 newPhaseMask, bool update)

bool	IsCustomBuildValuesUpdate (Unit const unit, uint8 updateType, ByteBuffer &fieldBuffer, Player const target, uint16 index)

bool	OnBuildValuesUpdate (Unit const unit, uint8 updateType, ByteBuffer &fieldBuffer, Player target, uint16 index)

void	OnUnitUpdate (Unit *unit, uint32 diff)

void	OnDisplayIdChange (Unit *unit, uint32 displayId)

void	OnUnitEnterEvadeMode (Unit *unit, uint8 why)

void	OnUnitEnterCombat (Unit unit, Unit victim)

void	OnUnitDeath (Unit unit, Unit killer)

void	OnPlayerMove (Player *player, MovementInfo movementInfo, uint32 opcode)

void	OnBeforeCreatureSelectLevel (const CreatureTemplate cinfo, Creature creature, uint8 &level)

void	Creature_SelectLevel (const CreatureTemplate cinfo, Creature creature)

void	OnCreatureSaveToDB (Creature *creature)

void	OnGameObjectSaveToDB (GameObject *go)

void	OnBeforeCreateInstanceScript (InstanceMap instanceMap, InstanceScript instanceData, bool load, std::string data, uint32 completedEncounterMask)

void	OnDestroyInstance (MapInstanced mapInstanced, Map map)

void	OnBattlegroundStart (Battleground *bg)

void	OnBattlegroundEndReward (Battleground bg, Player player, TeamId winnerTeamId)

void	OnBattlegroundUpdate (Battleground *bg, uint32 diff)

void	OnBattlegroundAddPlayer (Battleground bg, Player player)

void	OnBattlegroundBeforeAddPlayer (Battleground bg, Player player)

void	OnBattlegroundRemovePlayerAtLeave (Battleground bg, Player player)

void	OnQueueUpdate (BattlegroundQueue *queue, uint32 diff, BattlegroundTypeId bgTypeId, BattlegroundBracketId bracket_id, uint8 arenaType, bool isRated, uint32 arenaRating)

void	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)

bool	CanFillPlayersToBG (BattlegroundQueue queue, Battleground bg, BattlegroundBracketId bracket_id)

bool	IsCheckNormalMatch (BattlegroundQueue queue, Battleground bgTemplate, BattlegroundBracketId bracket_id, uint32 minPlayers, uint32 maxPlayers)

bool	CanSendMessageBGQueue (BattlegroundQueue queue, Player leader, Battleground bg, PvPDifficultyEntry const bracketEntry)

bool	OnBeforeSendJoinMessageArenaQueue (BattlegroundQueue queue, Player leader, GroupQueueInfo ginfo, PvPDifficultyEntry const bracketEntry, bool isRated)

bool	OnBeforeSendExitMessageArenaQueue (BattlegroundQueue queue, GroupQueueInfo ginfo)

void	OnBattlegroundEnd (Battleground *bg, TeamId winnerTeamId)

void	OnBattlegroundDestroy (Battleground *bg)

void	OnBattlegroundCreate (Battleground *bg)

void	OnGetSlotByType (const uint32 type, uint8 &slot)

void	OnGetArenaPoints (ArenaTeam *at, float &points)

void	OnArenaTypeIDToQueueID (const BattlegroundTypeId bgTypeId, const uint8 arenaType, uint32 &queueTypeID)

void	OnArenaQueueIdToArenaType (const BattlegroundQueueTypeId bgQueueTypeId, uint8 &ArenaType)

void	OnSetArenaMaxPlayersPerTeam (const uint8 arenaType, uint32 &maxPlayerPerTeam)

void	OnCalcMaxDuration (Aura const *aura, int32 &maxDuration)

bool	CanModAuraEffectDamageDone (AuraEffect const auraEff, Unit target, AuraApplication const *aurApp, uint8 mode, bool apply)

bool	CanModAuraEffectModDamagePercentDone (AuraEffect const auraEff, Unit target, AuraApplication const *aurApp, uint8 mode, bool apply)

void	OnSpellCheckCast (Spell *spell, bool strict, SpellCastResult &res)

bool	CanPrepare (Spell spell, SpellCastTargets const targets, AuraEffect const *triggeredByAura)

bool	CanScalingEverything (Spell *spell)

bool	CanSelectSpecTalent (Spell *spell)

void	OnScaleAuraUnitAdd (Spell spell, Unit target, uint32 effectMask, bool checkIfValid, bool implicit, uint8 auraScaleMask, TargetInfo &targetInfo)

void	OnRemoveAuraScaleTargets (Spell *spell, TargetInfo &targetInfo, uint8 auraScaleMask, bool &needErase)

void	OnBeforeAuraRankForLevel (SpellInfo const spellInfo, SpellInfo const latestSpellInfo, uint8 level)

void	OnDummyEffect (WorldObject caster, uint32 spellID, SpellEffIndex effIndex, GameObject gameObjTarget)

void	OnDummyEffect (WorldObject caster, uint32 spellID, SpellEffIndex effIndex, Creature creatureTarget)

void	OnDummyEffect (WorldObject caster, uint32 spellID, SpellEffIndex effIndex, Item itemTarget)

void	OnGameEventStart (uint16 EventID)

void	OnGameEventStop (uint16 EventID)

void	OnGameEventCheck (uint16 EventID)

void	OnBeforeMailDraftSendMailTo (MailDraft *mailDraft, MailReceiver const &receiver, MailSender const &sender, MailCheckMask &checked, uint32 &deliver_delay, uint32 &custom_expiration, bool &deleteMailItemsFromDB, bool &sendMail)

void	SetRealmCompleted (AchievementEntry const *achievement)

bool	IsCompletedCriteria (AchievementMgr mgr, AchievementCriteriaEntry const achievementCriteria, AchievementEntry const achievement, CriteriaProgress const progress)

bool	IsRealmCompleted (AchievementGlobalMgr const globalmgr, AchievementEntry const achievement, std::chrono::system_clock::time_point completionTime)

void	OnBeforeCheckCriteria (AchievementMgr mgr, AchievementCriteriaEntryList const achievementCriteriaList)

bool	CanCheckCriteria (AchievementMgr mgr, AchievementCriteriaEntry const achievementCriteria)

void	OnInitStatsForLevel (Guardian *guardian, uint8 petlevel)

void	OnCalculateMaxTalentPointsForLevel (Pet *pet, uint8 level, uint8 &points)

bool	CanUnlearnSpellSet (Pet *pet, uint32 level, uint32 spell)

bool	CanUnlearnSpellDefault (Pet pet, SpellInfo const spellInfo)

bool	CanResetTalents (Pet *pet)

bool	CanAddMember (ArenaTeam *team, ObjectGuid PlayerGuid)

void	OnGetPoints (ArenaTeam *team, uint32 memberRating, float &points)

bool	CanSaveToDB (ArenaTeam *team)

void	OnConstructObject (Object *origin)

void	OnDestructObject (Object *origin)

void	OnConstructPlayer (Player *origin)

void	OnDestructPlayer (Player *origin)

void	OnConstructGroup (Group *origin)

void	OnDestructGroup (Group *origin)

void	OnConstructInstanceSave (InstanceSave *origin)

void	OnDestructInstanceSave (InstanceSave *origin)

void	OnItemCreate (Item item, ItemTemplate const itemProto, Player const *owner)

bool	CanApplySoulboundFlag (Item item, ItemTemplate const proto)

bool	CanItemApplyEquipSpell (Player player, Item item)

bool	CanSendAuctionHello (WorldSession const session, ObjectGuid guid, Creature creature)

void	ValidateSpellAtCastSpell (Player *player, uint32 &oldSpellId, uint32 &spellId, uint8 &castCount, uint8 &castFlags)

void	OnPlayerSetPhase (const AuraEffect auraEff, AuraApplication const aurApp, uint8 mode, bool apply, uint32 &newPhase)

void	ValidateSpellAtCastSpellResult (Player player, Unit mover, Spell *spell, uint32 oldSpellId, uint32 spellId)

void	OnAfterLootTemplateProcess (Loot loot, LootTemplate const tab, LootStore const &store, Player *lootOwner, bool personal, bool noEmptyError, uint16 lootMode)

void	OnInstanceSave (InstanceSave *instanceSave)

void	GetDialogStatus (Player player, Object questgiver)

void	OnHandleDevCommand (Player *player, bool &enable)

bool	CanExecuteCommand (ChatHandler &handler, std::string_view cmdStr)

void	OnAfterDatabasesLoaded (uint32 updateFlags)

void	OnAfterDatabaseLoadCreatureTemplates (std::vector< CreatureTemplate * > creatureTemplateStore)

void	OnWorldObjectDestroy (WorldObject *object)

void	OnWorldObjectCreate (WorldObject *object)

void	OnWorldObjectSetMap (WorldObject object, Map map)

void	OnWorldObjectResetMap (WorldObject *object)

void	OnWorldObjectUpdate (WorldObject *object, uint32 diff)

void	OnPetAddToWorld (Pet *pet)

void	OnLootMoney (Player *player, uint32 gold)

Static Public Member Functions
static ScriptMgr *	instance ()

Private Member Functions
	ScriptMgr ()

virtual	~ScriptMgr ()

Private Attributes
uint32	_scriptCount

std::atomic< long >	_scheduledScripts

ScriptLoaderCallbackType	_script_loader_callback

ModulesLoaderCallbackType	_modules_loader_callback

Friends
class	ScriptObject

Detailed Description

Member Typedef Documentation

◆ ModulesLoaderCallbackType

typedef void(* ScriptMgr::ModulesLoaderCallbackType) ()

◆ ScriptLoaderCallbackType

typedef void(* ScriptMgr::ScriptLoaderCallbackType) ()

Constructor & Destructor Documentation

◆ ScriptMgr()

ScriptMgr::ScriptMgr ( )

private

    : _scriptCount(0),
    _scheduledScripts(0),
    _script_loader_callback(nullptr),
    _modules_loader_callback(nullptr) { }

Member Function Documentation

◆ AfterInstanceGameObjectCreate()

void ScriptMgr::AfterInstanceGameObjectCreate	(	Map *	instance,
		GameObject *	go
	)

Called when a game object is created inside an instance.

Parameters

instance	A pointer to the [map] object of the instance
go	The object being added

{
    ExecuteScript<GlobalScript>([&](GlobalScript* script)
    {
        script->AfterInstanceGameObjectCreate(instance, go);
    });
}

References GlobalScript::AfterInstanceGameObjectCreate(), and instance().

◆ AnticheatCheckMovementInfo()

bool ScriptMgr::AnticheatCheckMovementInfo	(	Player *	player,
		MovementInfo const &	movementInfo,
		Unit *	mover,
		bool	jump
	)

{
    auto ret = IsValidBoolScript<PlayerScript>([&](PlayerScript* script)
    {
        return !script->AnticheatCheckMovementInfo(player, movementInfo, mover, jump);
    });
 
    if (ret && *ret)
    {
        return false;
    }
 
    return true;
}

References PlayerScript::AnticheatCheckMovementInfo().

◆ AnticheatHandleDoubleJump()

bool ScriptMgr::AnticheatHandleDoubleJump	(	Player *	player,
		Unit *	mover
	)

{
    auto ret = IsValidBoolScript<PlayerScript>([&](PlayerScript* script)
    {
        return !script->AnticheatHandleDoubleJump(player, mover);
    });
 
    if (ret && *ret)
    {
        return false;
    }
 
    return true;
}

References PlayerScript::AnticheatHandleDoubleJump().

◆ AnticheatSetCanFlybyServer()

void ScriptMgr::AnticheatSetCanFlybyServer	(	Player *	player,
		bool	apply
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->AnticheatSetCanFlybyServer(player, apply);
    });
}

References PlayerScript::AnticheatSetCanFlybyServer().

◆ AnticheatSetJumpingbyOpcode()

void ScriptMgr::AnticheatSetJumpingbyOpcode	(	Player *	player,
		bool	jump
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->AnticheatSetJumpingbyOpcode(player, jump);
    });
}

References PlayerScript::AnticheatSetJumpingbyOpcode().

◆ AnticheatSetRootACKUpd()

void ScriptMgr::AnticheatSetRootACKUpd ( Player * player )

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->AnticheatSetRootACKUpd(player);
    });
}

References PlayerScript::AnticheatSetRootACKUpd().

◆ AnticheatSetSkipOnePacketForASH()

void ScriptMgr::AnticheatSetSkipOnePacketForASH	(	Player *	player,
		bool	apply
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->AnticheatSetSkipOnePacketForASH(player, apply);
    });
}

References PlayerScript::AnticheatSetSkipOnePacketForASH().

◆ AnticheatSetUnderACKmount()

void ScriptMgr::AnticheatSetUnderACKmount ( Player * player )

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->AnticheatSetUnderACKmount(player);
    });
}

References PlayerScript::AnticheatSetUnderACKmount().

◆ AnticheatUpdateMovementInfo()

void ScriptMgr::AnticheatUpdateMovementInfo	(	Player *	player,
		MovementInfo const &	movementInfo
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->AnticheatUpdateMovementInfo(player, movementInfo);
    });
}

References PlayerScript::AnticheatUpdateMovementInfo().

◆ CanAccountCreateCharacter()

bool ScriptMgr::CanAccountCreateCharacter	(	uint32	accountId,
		uint8	charRace,
		uint8	charClass
	)

{
    auto ret = IsValidBoolScript<AccountScript>([&](AccountScript* script)
    {
        return !script->CanAccountCreateCharacter(accountId, charRace, charClass);
    });
 
    return ReturnValidBool(ret);
}

References AccountScript::CanAccountCreateCharacter(), and ReturnValidBool().

◆ CanAddMember()

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;
}

References ArenaScript::CanAddMember().

◆ CanApplyEnchantment()

bool ScriptMgr::CanApplyEnchantment	(	Player *	player,
		Item *	item,
		EnchantmentSlot	slot,
		bool	apply,
		bool	apply_dur,
		bool	ignore_condition
	)

{
    auto ret = IsValidBoolScript<PlayerScript>([&](PlayerScript* script)
    {
        return !script->CanApplyEnchantment(player, item, slot, apply, apply_dur, ignore_condition);
    });
 
    if (ret && *ret)
    {
        return false;
    }
 
    return true;
}

References PlayerScript::CanApplyEnchantment().

◆ CanApplyEquipSpell()

bool ScriptMgr::CanApplyEquipSpell	(	Player *	player,
		SpellInfo const *	spellInfo,
		Item *	item,
		bool	apply,
		bool	form_change
	)

{
    auto ret = IsValidBoolScript<PlayerScript>([&](PlayerScript* script)
    {
        return !script->CanApplyEquipSpell(player, spellInfo, item, apply, form_change);
    });
 
    if (ret && *ret)
    {
        return false;
    }
 
    return true;
}

References PlayerScript::CanApplyEquipSpell().

◆ CanApplyEquipSpellsItemSet()

bool ScriptMgr::CanApplyEquipSpellsItemSet	(	Player *	player,
		ItemSetEffect *	eff
	)

{
    auto ret = IsValidBoolScript<PlayerScript>([&](PlayerScript* script)
    {
        return !script->CanApplyEquipSpellsItemSet(player, eff);
    });
 
    if (ret && *ret)
    {
        return false;
    }
 
    return true;
}

References PlayerScript::CanApplyEquipSpellsItemSet().

◆ CanApplySoulboundFlag()

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;
}

References MiscScript::CanApplySoulboundFlag().

◆ CanApplyWeaponDependentAuraDamageMod()

bool ScriptMgr::CanApplyWeaponDependentAuraDamageMod	(	Player *	player,
		Item *	item,
		WeaponAttackType	attackType,
		AuraEffect const *	aura,
		bool	apply
	)

{
    auto ret = IsValidBoolScript<PlayerScript>([&](PlayerScript* script)
    {
        return !script->CanApplyWeaponDependentAuraDamageMod(player, item, attackType, aura, apply);
    });
 
    if (ret && *ret)
    {
        return false;
    }
 
    return true;
}

References PlayerScript::CanApplyWeaponDependentAuraDamageMod().

◆ CanAreaExploreAndOutdoor()

bool ScriptMgr::CanAreaExploreAndOutdoor ( Player * player )

{
    auto ret = IsValidBoolScript<PlayerScript>([&](PlayerScript* script)
    {
        return !script->CanAreaExploreAndOutdoor(player);
    });
 
    if (ret && *ret)
    {
        return false;
    }
 
    return true;
}

References PlayerScript::CanAreaExploreAndOutdoor().

◆ CanArmorDamageModifier()

bool ScriptMgr::CanArmorDamageModifier ( Player * player )

{
    auto ret = IsValidBoolScript<PlayerScript>([&](PlayerScript* script)
    {
        return !script->CanArmorDamageModifier(player);
    });
 
    if (ret && *ret)
    {
        return false;
    }
 
    return true;
}

References PlayerScript::CanArmorDamageModifier().

◆ CanBattleFieldPort()

bool ScriptMgr::CanBattleFieldPort	(	Player *	player,
		uint8	arenaType,
		BattlegroundTypeId	BGTypeID,
		uint8	action
	)

{
    auto ret = IsValidBoolScript<PlayerScript>([&](PlayerScript* script)
    {
        return !script->CanBattleFieldPort(player, arenaType, BGTypeID, action);
    });
 
    if (ret && *ret)
    {
        return false;
    }
 
    return true;
}

References PlayerScript::CanBattleFieldPort().

◆ CanCastItemCombatSpell()

bool ScriptMgr::CanCastItemCombatSpell	(	Player *	player,
		Unit *	target,
		WeaponAttackType	attType,
		uint32	procVictim,
		uint32	procEx,
		Item *	item,
		ItemTemplate const *	proto
	)

{
    auto ret = IsValidBoolScript<PlayerScript>([&](PlayerScript* script)
    {
        return !script->CanCastItemCombatSpell(player, target, attType, procVictim, procEx, item, proto);
    });
 
    if (ret && *ret)
    {
        return false;
    }
 
    return true;
}

References PlayerScript::CanCastItemCombatSpell().

◆ CanCastItemUseSpell()

bool ScriptMgr::CanCastItemUseSpell	(	Player *	player,
		Item *	item,
		SpellCastTargets const &	targets,
		uint8	cast_count,
		uint32	glyphIndex
	)

{
    auto ret = IsValidBoolScript<PlayerScript>([&](PlayerScript* script)
    {
        return !script->CanCastItemUseSpell(player, item, targets, cast_count, glyphIndex);
    });
 
    if (ret && *ret)
    {
        return false;
    }
 
    return true;
}

References PlayerScript::CanCastItemUseSpell().

◆ CanCheckCriteria()

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;
}

References AchievementScript::CanCheckCriteria().

◆ CanEnterMap()

bool ScriptMgr::CanEnterMap	(	Player *	player,
		MapEntry const *	entry,
		InstanceTemplate const *	instance,
		MapDifficulty const *	mapDiff,
		bool	loginCheck
	)

{
    auto ret = IsValidBoolScript<PlayerScript>([&](PlayerScript* script)
    {
        return !script->CanEnterMap(player, entry, instance, mapDiff, loginCheck);
    });
 
    if (ret && *ret)
    {
        return false;
    }
 
    return true;
}

References PlayerScript::CanEnterMap(), and instance().

◆ CanEquipItem()

bool ScriptMgr::CanEquipItem	(	Player *	player,
		uint8	slot,
		uint16 &	dest,
		Item *	pItem,
		bool	swap,
		bool	not_loading
	)

{
    auto ret = IsValidBoolScript<PlayerScript>([&](PlayerScript* script)
    {
        return !script->CanEquipItem(player, slot, dest, pItem, swap, not_loading);
    });
 
    if (ret && *ret)
    {
        return false;
    }
 
    return true;
}

References PlayerScript::CanEquipItem().

◆ CanExecuteCommand()

bool ScriptMgr::CanExecuteCommand	(	ChatHandler &	handler,
		std::string_view	cmdStr
	)

{
    auto ret = IsValidBoolScript<AllCommandScript>([&](AllCommandScript* script)
    {
        return !script->CanExecuteCommand(handler, cmdStr);
    });
 
    return ReturnValidBool(ret);
}

References AllCommandScript::CanExecuteCommand(), and ReturnValidBool().

◆ CanFillPlayersToBG()

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);
}

References AllBattlegroundScript::CanFillPlayersToBG(), and ReturnValidBool().

◆ CanGiveMailRewardAtGiveLevel()

bool ScriptMgr::CanGiveMailRewardAtGiveLevel	(	Player *	player,
		uint8	level
	)

{
    auto ret = IsValidBoolScript<PlayerScript>([&](PlayerScript* script)
    {
        return !script->CanGiveMailRewardAtGiveLevel(player, level);
    });
 
    if (ret && *ret)
    {
        return false;
    }
 
    return true;
}

References PlayerScript::CanGiveMailRewardAtGiveLevel().

◆ CanGroupAccept()

bool ScriptMgr::CanGroupAccept	(	Player *	player,
		Group *	group
	)

{
    auto ret = IsValidBoolScript<PlayerScript>([&](PlayerScript* script)
    {
        return !script->CanGroupAccept(player, group);
    });
 
    if (ret && *ret)
    {
        return false;
    }
 
    return true;
}

References PlayerScript::CanGroupAccept().

◆ CanGroupInvite()

bool ScriptMgr::CanGroupInvite	(	Player *	player,
		std::string &	membername
	)

{
    auto ret = IsValidBoolScript<PlayerScript>([&](PlayerScript* script)
    {
        return !script->CanGroupInvite(player, membername);
    });
 
    if (ret && *ret)
    {
        return false;
    }
 
    return true;
}

References PlayerScript::CanGroupInvite().

◆ CanGroupJoinBattlegroundQueue()

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;
}

References GroupScript::CanGroupJoinBattlegroundQueue().

◆ CanGuildSendBankList()

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;
}

References GuildScript::CanGuildSendBankList().

◆ CanInitTrade()

bool ScriptMgr::CanInitTrade	(	Player *	player,
		Player *	target
	)

{
    auto ret = IsValidBoolScript<PlayerScript>([&](PlayerScript* script)
    {
        return !script->CanInitTrade(player, target);
    });
 
    if (ret && *ret)
    {
        return false;
    }
 
    return true;
}

References PlayerScript::CanInitTrade().

◆ CanItemApplyEquipSpell()

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;
}

References MiscScript::CanItemApplyEquipSpell().

◆ CanJoinInArenaQueue()

bool ScriptMgr::CanJoinInArenaQueue	(	Player *	player,
		ObjectGuid	BattlemasterGuid,
		uint8	arenaslot,
		BattlegroundTypeId	BGTypeID,
		uint8	joinAsGroup,
		uint8	IsRated,
		GroupJoinBattlegroundResult &	err
	)

{
    auto ret = IsValidBoolScript<PlayerScript>([&](PlayerScript* script)
    {
        return !script->CanJoinInArenaQueue(player, BattlemasterGuid, arenaslot, BGTypeID, joinAsGroup, IsRated, err);
    });
 
    if (ret && *ret)
    {
        return false;
    }
 
    return true;
}

References PlayerScript::CanJoinInArenaQueue().

◆ CanJoinInBattlegroundQueue()

bool ScriptMgr::CanJoinInBattlegroundQueue	(	Player *	player,
		ObjectGuid	BattlemasterGuid,
		BattlegroundTypeId	BGTypeID,
		uint8	joinAsGroup,
		GroupJoinBattlegroundResult &	err
	)

{
    auto ret = IsValidBoolScript<PlayerScript>([&](PlayerScript* script)
    {
        return !script->CanJoinInBattlegroundQueue(player, BattlemasterGuid, BGTypeID, joinAsGroup, err);
    });
 
    if (ret && *ret)
    {
        return false;
    }
 
    return true;
}

References PlayerScript::CanJoinInBattlegroundQueue().

◆ CanJoinLfg()

bool ScriptMgr::CanJoinLfg	(	Player *	player,
		uint8	roles,
		lfg::LfgDungeonSet &	dungeons,
		const std::string &	comment
	)

{
    auto ret = IsValidBoolScript<PlayerScript>([&](PlayerScript* script)
    {
        return !script->CanJoinLfg(player, roles, dungeons, comment);
    });
 
    if (ret && *ret)
    {
        return false;
    }
 
    return true;
}

References PlayerScript::CanJoinLfg().

◆ CanModAuraEffectDamageDone()

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;
}

References AllSpellScript::CanModAuraEffectDamageDone().

◆ CanModAuraEffectModDamagePercentDone()

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;
}

References AllSpellScript::CanModAuraEffectModDamagePercentDone().

◆ CanPacketReceive()

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;
}

References ServerScript::CanPacketReceive().

◆ CanPacketSend()

bool ScriptMgr::CanPacketSend	(	WorldSession *	session,
		WorldPacket const &	packet
	)

{
    ASSERT(session);
 
    if (ScriptRegistry<ServerScript>::ScriptPointerList.empty())
        return true;
 
    WorldPacket copy(packet);
 
    auto ret = IsValidBoolScript<ServerScript>([&](ServerScript* script)
    {
        return !script->CanPacketSend(session, copy);
    });
 
    if (ret && *ret)
    {
        return false;
    }
 
    return true;
}

References ASSERT, and ServerScript::CanPacketSend().

◆ CanPlaceAuctionBid()

bool ScriptMgr::CanPlaceAuctionBid	(	Player *	player,
		AuctionEntry *	auction
	)

{
    auto ret = IsValidBoolScript<PlayerScript>([&](PlayerScript *script)
    {
       return !script->CanPlaceAuctionBid(player, auction);
    });
 
    if (ret && *ret)
    {
        return false;
    }
 
    return true;
}

References PlayerScript::CanPlaceAuctionBid().

◆ CanPlayerUseChat() [1/5]

bool ScriptMgr::CanPlayerUseChat	(	Player *	player,
		uint32	type,
		uint32	language,
		std::string &	msg
	)

{
    auto ret = IsValidBoolScript<PlayerScript>([&](PlayerScript* script)
    {
        return !script->CanPlayerUseChat(player, type, language, msg);
    });
 
    if (ret && *ret)
    {
        return false;
    }
 
    return true;
}

References PlayerScript::CanPlayerUseChat().

◆ CanPlayerUseChat() [2/5]

bool ScriptMgr::CanPlayerUseChat	(	Player *	player,
		uint32	type,
		uint32	language,
		std::string &	msg,
		Channel *	channel
	)

{
    auto ret = IsValidBoolScript<PlayerScript>([&](PlayerScript* script)
    {
        return !script->CanPlayerUseChat(player, type, language, msg, channel);
    });
 
    if (ret && *ret)
    {
        return false;
    }
 
    return true;
}

References PlayerScript::CanPlayerUseChat().

◆ CanPlayerUseChat() [3/5]

bool ScriptMgr::CanPlayerUseChat	(	Player *	player,
		uint32	type,
		uint32	language,
		std::string &	msg,
		Group *	group
	)

{
    auto ret = IsValidBoolScript<PlayerScript>([&](PlayerScript* script)
    {
        return !script->CanPlayerUseChat(player, type, language, msg, group);
    });
 
    if (ret && *ret)
    {
        return false;
    }
 
    return true;
}

References PlayerScript::CanPlayerUseChat().

◆ CanPlayerUseChat() [4/5]

bool ScriptMgr::CanPlayerUseChat	(	Player *	player,
		uint32	type,
		uint32	language,
		std::string &	msg,
		Guild *	guild
	)

{
    auto ret = IsValidBoolScript<PlayerScript>([&](PlayerScript* script)
    {
        return !script->CanPlayerUseChat(player, type, language, msg, guild);
    });
 
    if (ret && *ret)
    {
        return false;
    }
 
    return true;
}

References PlayerScript::CanPlayerUseChat().

◆ CanPlayerUseChat() [5/5]

bool ScriptMgr::CanPlayerUseChat	(	Player *	player,
		uint32	type,
		uint32	language,
		std::string &	msg,
		Player *	receiver
	)

{
    auto ret = IsValidBoolScript<PlayerScript>([&](PlayerScript* script)
    {
        return !script->CanPlayerUseChat(player, type, language, msg, receiver);
    });
 
    if (ret && *ret)
    {
        return false;
    }
 
    return true;
}

References PlayerScript::CanPlayerUseChat().

◆ CanPrepare()

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;
}

References AllSpellScript::CanPrepare().

◆ CanRepopAtGraveyard()

bool ScriptMgr::CanRepopAtGraveyard ( Player * player )

{
    auto ret = IsValidBoolScript<PlayerScript>([&](PlayerScript* script)
    {
        return !script->CanRepopAtGraveyard(player);
    });
 
    if (ret && *ret)
    {
        return false;
    }
 
    return true;
}

References PlayerScript::CanRepopAtGraveyard().

◆ CanResetTalents()

bool ScriptMgr::CanResetTalents ( Pet * pet )

{
    auto ret = IsValidBoolScript<PetScript>([&](PetScript* script)
    {
        return !script->CanResetTalents(pet);
    });
 
    if (ret && *ret)
    {
        return false;
    }
 
    return true;
}

References PetScript::CanResetTalents().

◆ CanSaveEquipNewItem()

bool ScriptMgr::CanSaveEquipNewItem	(	Player *	player,
		Item *	item,
		uint16	pos,
		bool	update
	)

{
    auto ret = IsValidBoolScript<PlayerScript>([&](PlayerScript* script)
    {
        return !script->CanSaveEquipNewItem(player, item, pos, update);
    });
 
    if (ret && *ret)
    {
        return false;
    }
 
    return true;
}

References PlayerScript::CanSaveEquipNewItem().

◆ CanSaveToDB()

bool ScriptMgr::CanSaveToDB ( ArenaTeam * team )

{
    auto ret = IsValidBoolScript<ArenaScript>([&](ArenaScript* script)
    {
        return !script->CanSaveToDB(team);
    });
 
    if (ret && *ret)
    {
        return false;
    }
 
    return true;
}

References ArenaScript::CanSaveToDB().

◆ CanScalingEverything()

bool ScriptMgr::CanScalingEverything ( Spell * spell )

{
    auto ret = IsValidBoolScript<AllSpellScript>([&](AllSpellScript* script)
    {
        return script->CanScalingEverything(spell);
    });
 
    if (ret && *ret)
    {
        return true;
    }
 
    return false;
}

References AllSpellScript::CanScalingEverything().

◆ CanSelectSpecTalent()

bool ScriptMgr::CanSelectSpecTalent ( Spell * spell )

{
    auto ret = IsValidBoolScript<AllSpellScript>([&](AllSpellScript* script)
    {
        return !script->CanSelectSpecTalent(spell);
    });
 
    if (ret && *ret)
    {
        return false;
    }
 
    return true;
}

References AllSpellScript::CanSelectSpecTalent().

◆ CanSellItem()

bool ScriptMgr::CanSellItem	(	Player *	player,
		Item *	item,
		Creature *	creature
	)

{
    auto ret = IsValidBoolScript<PlayerScript>([&](PlayerScript* script)
    {
        return !script->CanSellItem(player, item, creature);
    });
 
    if (ret && *ret)
    {
        return false;
    }
 
    return true;
}

References PlayerScript::CanSellItem().

◆ CanSendAuctionHello()

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;
}

References MiscScript::CanSendAuctionHello().

◆ CanSendErrorAlreadyLooted()

bool ScriptMgr::CanSendErrorAlreadyLooted ( Player * player )

{
    auto ret = IsValidBoolScript<PlayerScript>([&](PlayerScript* script)
    {
        return !script->CanSendErrorAlreadyLooted(player);
    });
 
    if (ret && *ret)
    {
        return false;
    }
 
    return true;
}

References PlayerScript::CanSendErrorAlreadyLooted().

◆ CanSendMail()

bool ScriptMgr::CanSendMail	(	Player *	player,
		ObjectGuid	receiverGuid,
		ObjectGuid	mailbox,
		std::string &	subject,
		std::string &	body,
		uint32	money,
		uint32	COD,
		Item *	item
	)

{
    auto ret = IsValidBoolScript<PlayerScript>([&](PlayerScript* script)
    {
        return !script->CanSendMail(player, receiverGuid, mailbox, subject, body, money, COD, item);
    });
 
    if (ret && *ret)
    {
        return false;
    }
 
    return true;
}

References PlayerScript::CanSendMail().

◆ CanSendMessageBGQueue()

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);
}

References AllBattlegroundScript::CanSendMessageBGQueue(), and ReturnValidBool().

◆ CanSetPhaseMask()

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;
}

References UnitScript::CanSetPhaseMask().

◆ CanUnequipItem()

bool ScriptMgr::CanUnequipItem	(	Player *	player,
		uint16	pos,
		bool	swap
	)

{
    auto ret = IsValidBoolScript<PlayerScript>([&](PlayerScript* script)
    {
        return !script->CanUnequipItem(player, pos, swap);
    });
 
    if (ret && *ret)
    {
        return false;
    }
 
    return true;
}

References PlayerScript::CanUnequipItem().

◆ CanUnlearnSpellDefault()

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;
}

References PetScript::CanUnlearnSpellDefault().

◆ CanUnlearnSpellSet()

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;
}

References PetScript::CanUnlearnSpellSet().

◆ CanUseItem()

bool ScriptMgr::CanUseItem	(	Player *	player,
		ItemTemplate const *	proto,
		InventoryResult &	result
	)

{
    auto ret = IsValidBoolScript<PlayerScript>([&](PlayerScript* script)
    {
        return !script->CanUseItem(player, proto, result);
    });
 
    if (ret && *ret)
    {
        return false;
    }
 
    return true;
}

References PlayerScript::CanUseItem().

◆ CheckIfScriptsInDatabaseExist()

void ScriptMgr::CheckIfScriptsInDatabaseExist ( )

{
    for (auto const& scriptName : sObjectMgr->GetScriptNames())
    {
        if (uint32 sid = sObjectMgr->GetScriptId(scriptName))
        {
            if (!ScriptRegistry<SpellScriptLoader>::GetScriptById(sid) &&
                !ScriptRegistry<ServerScript>::GetScriptById(sid) &&
                !ScriptRegistry<WorldScript>::GetScriptById(sid) &&
                !ScriptRegistry<FormulaScript>::GetScriptById(sid) &&
                !ScriptRegistry<WorldMapScript>::GetScriptById(sid) &&
                !ScriptRegistry<InstanceMapScript>::GetScriptById(sid) &&
                !ScriptRegistry<BattlegroundMapScript>::GetScriptById(sid) &&
                !ScriptRegistry<ItemScript>::GetScriptById(sid) &&
                !ScriptRegistry<CreatureScript>::GetScriptById(sid) &&
                !ScriptRegistry<GameObjectScript>::GetScriptById(sid) &&
                !ScriptRegistry<AreaTriggerScript>::GetScriptById(sid) &&
                !ScriptRegistry<BattlegroundScript>::GetScriptById(sid) &&
                !ScriptRegistry<OutdoorPvPScript>::GetScriptById(sid) &&
                !ScriptRegistry<CommandScript>::GetScriptById(sid) &&
                !ScriptRegistry<WeatherScript>::GetScriptById(sid) &&
                !ScriptRegistry<AuctionHouseScript>::GetScriptById(sid) &&
                !ScriptRegistry<ConditionScript>::GetScriptById(sid) &&
                !ScriptRegistry<VehicleScript>::GetScriptById(sid) &&
                !ScriptRegistry<DynamicObjectScript>::GetScriptById(sid) &&
                !ScriptRegistry<TransportScript>::GetScriptById(sid) &&
                !ScriptRegistry<AchievementCriteriaScript>::GetScriptById(sid) &&
                !ScriptRegistry<PlayerScript>::GetScriptById(sid) &&
                !ScriptRegistry<GuildScript>::GetScriptById(sid) &&
                !ScriptRegistry<BGScript>::GetScriptById(sid) &&
                !ScriptRegistry<AchievementScript>::GetScriptById(sid) &&
                !ScriptRegistry<ArenaTeamScript>::GetScriptById(sid) &&
                !ScriptRegistry<SpellSC>::GetScriptById(sid) &&
                !ScriptRegistry<MiscScript>::GetScriptById(sid) &&
                !ScriptRegistry<PetScript>::GetScriptById(sid) &&
                !ScriptRegistry<CommandSC>::GetScriptById(sid) &&
                !ScriptRegistry<ArenaScript>::GetScriptById(sid) &&
                !ScriptRegistry<GroupScript>::GetScriptById(sid) &&
                !ScriptRegistry<DatabaseScript>::GetScriptById(sid))
                {
                    LOG_ERROR("sql.sql", "Script named '{}' is assigned in the database, but has no code!", scriptName);
                }
        }
    }
}

References LOG_ERROR, and sObjectMgr.

Referenced by LoadDatabase().

◆ CheckItemInSlotAtLoadInventory()

bool ScriptMgr::CheckItemInSlotAtLoadInventory	(	Player *	player,
		Item *	item,
		uint8	slot,
		uint8 &	err,
		uint16 &	dest
	)

{
    auto ret = IsValidBoolScript<PlayerScript>([&](PlayerScript* script)
    {
        return !script->CheckItemInSlotAtLoadInventory(player, item, slot, err, dest);
    });
 
    if (ret && *ret)
    {
        return false;
    }
 
    return true;
}

References PlayerScript::CheckItemInSlotAtLoadInventory().

◆ CreateAuraScripts()

void ScriptMgr::CreateAuraScripts	(	uint32	spellId,
		std::list< AuraScript * > &	scriptVector
	)

{
    SpellScriptsBounds bounds = sObjectMgr->GetSpellScriptsBounds(spellId);
 
    for (SpellScriptsContainer::iterator itr = bounds.first; itr != bounds.second; ++itr)
    {
        SpellScriptLoader* tempScript = ScriptRegistry<SpellScriptLoader>::GetScriptById(itr->second);
        if (!tempScript)
            continue;
 
        AuraScript* script = tempScript->GetAuraScript();
 
        if (!script)
            continue;
 
        script->_Init(&tempScript->GetName(), spellId);
 
        scriptVector.push_back(script);
    }
}

References _SpellScript::_Init(), SpellScriptLoader::GetAuraScript(), ScriptObject::GetName(), ScriptRegistry< TScript >::GetScriptById(), and sObjectMgr.

◆ CreateBattleground()

Battleground * ScriptMgr::CreateBattleground ( BattlegroundTypeId typeId )

Todo:: : Implement script-side battlegrounds.

{
    ABORT();
    return nullptr;
}

References ABORT.

◆ CreateInstanceScript()

InstanceScript * ScriptMgr::CreateInstanceScript ( InstanceMap * map )

{
    ASSERT(map);
 
    auto tempScript = ScriptRegistry<InstanceMapScript>::GetScriptById(map->GetScriptId());
    return tempScript ? tempScript->GetInstanceScript(map) : nullptr;
}

References ASSERT, ScriptRegistry< TScript >::GetScriptById(), and InstanceMap::GetScriptId().

◆ CreateOutdoorPvP()

OutdoorPvP * ScriptMgr::CreateOutdoorPvP ( OutdoorPvPData const * data )

{
    ASSERT(data);
 
    auto tempScript = ScriptRegistry<OutdoorPvPScript>::GetScriptById(data->ScriptId);
    return tempScript ? tempScript->GetOutdoorPvP() : nullptr;
}

References ASSERT, ScriptRegistry< TScript >::GetScriptById(), and OutdoorPvPData::ScriptId.

◆ CreateSpellScriptLoaders()

void ScriptMgr::CreateSpellScriptLoaders	(	uint32	spellId,
		std::vector< std::pair< SpellScriptLoader *, std::multimap< uint32, uint32 >::iterator > > &	scriptVector
	)

{
    SpellScriptsBounds bounds = sObjectMgr->GetSpellScriptsBounds(spellId);
    scriptVector.reserve(std::distance(bounds.first, bounds.second));
 
    for (SpellScriptsContainer::iterator itr = bounds.first; itr != bounds.second; ++itr)
    {
        SpellScriptLoader* tempScript = ScriptRegistry<SpellScriptLoader>::GetScriptById(itr->second);
        if (!tempScript)
            continue;
 
        scriptVector.emplace_back(tempScript, itr);
    }
}

References ScriptRegistry< TScript >::GetScriptById(), and sObjectMgr.

◆ CreateSpellScripts()

void ScriptMgr::CreateSpellScripts	(	uint32	spellId,
		std::list< SpellScript * > &	scriptVector
	)

{
    SpellScriptsBounds bounds = sObjectMgr->GetSpellScriptsBounds(spellId);
 
    for (SpellScriptsContainer::iterator itr = bounds.first; itr != bounds.second; ++itr)
    {
        SpellScriptLoader* tempScript = ScriptRegistry<SpellScriptLoader>::GetScriptById(itr->second);
        if (!tempScript)
            continue;
 
        SpellScript* script = tempScript->GetSpellScript();
 
        if (!script)
            continue;
 
        script->_Init(&tempScript->GetName(), spellId);
 
        scriptVector.push_back(script);
    }
}

References _SpellScript::_Init(), ScriptObject::GetName(), ScriptRegistry< TScript >::GetScriptById(), SpellScriptLoader::GetSpellScript(), and sObjectMgr.

◆ Creature_SelectLevel()

void ScriptMgr::Creature_SelectLevel	(	const CreatureTemplate *	cinfo,
		Creature *	creature
	)

{
    ExecuteScript<AllCreatureScript>([&](AllCreatureScript* script)
    {
        script->Creature_SelectLevel(cinfo, creature);
    });
}

References AllCreatureScript::Creature_SelectLevel().

◆ DealDamage()

uint32 ScriptMgr::DealDamage	(	Unit *	AttackerUnit,
		Unit *	pVictim,
		uint32	damage,
		DamageEffectType	damagetype
	)

{
    if (ScriptRegistry<UnitScript>::ScriptPointerList.empty())
    {
        return damage;
    }
 
    for (auto const& [scriptID, script] : ScriptRegistry<UnitScript>::ScriptPointerList)
    {
        auto const& dmg = script->DealDamage(AttackerUnit, pVictim, damage, damagetype);
        if (dmg != damage)
        {
            return damage;
        }
    }
 
    return damage;
}

◆ DecreaseScheduledScriptCount() [1/2]

uint32 ScriptMgr::DecreaseScheduledScriptCount ( )

inline

525{ return --_scheduledScripts; }

References _scheduledScripts.

◆ DecreaseScheduledScriptCount() [2/2]

uint32 ScriptMgr::DecreaseScheduledScriptCount ( size_t count )

inline

526{ return _scheduledScripts -= count; }

References _scheduledScripts.

◆ DecreaseScriptCount()

void ScriptMgr::DecreaseScriptCount ( )

inline

128{ --_scriptCount; }

References _scriptCount.

◆ FillSpellSummary()

void ScriptMgr::FillSpellSummary ( )

{
    UnitAI::FillAISpellInfo();
 
    SpellSummary = new TSpellSummary[sSpellMgr->GetSpellInfoStoreSize()];
 
    SpellInfo const* pTempSpell;
 
    for (uint32 i = 0; i < sSpellMgr->GetSpellInfoStoreSize(); ++i)
    {
        SpellSummary[i].Effects = 0;
        SpellSummary[i].Targets = 0;
 
        pTempSpell = sSpellMgr->GetSpellInfo(i);
        // This spell doesn't exist.
        if (!pTempSpell)
            continue;
 
        for (uint32 j = 0; j < MAX_SPELL_EFFECTS; ++j)
        {
            // Spell targets self.
            if (pTempSpell->Effects[j].TargetA.GetTarget() == TARGET_UNIT_CASTER)
                SpellSummary[i].Targets |= 1 << (SELECT_TARGET_SELF - 1);
 
            // Spell targets a single enemy.
            if (pTempSpell->Effects[j].TargetA.GetTarget() == TARGET_UNIT_TARGET_ENEMY ||
                    pTempSpell->Effects[j].TargetA.GetTarget() == TARGET_DEST_TARGET_ENEMY)
                SpellSummary[i].Targets |= 1 << (SELECT_TARGET_SINGLE_ENEMY - 1);
 
            // Spell targets AoE at enemy.
            if (pTempSpell->Effects[j].TargetA.GetTarget() == TARGET_UNIT_SRC_AREA_ENEMY ||
                    pTempSpell->Effects[j].TargetA.GetTarget() == TARGET_UNIT_DEST_AREA_ENEMY ||
                    pTempSpell->Effects[j].TargetA.GetTarget() == TARGET_SRC_CASTER ||
                    pTempSpell->Effects[j].TargetA.GetTarget() == TARGET_DEST_DYNOBJ_ENEMY)
                SpellSummary[i].Targets |= 1 << (SELECT_TARGET_AOE_ENEMY - 1);
 
            // Spell targets an enemy.
            if (pTempSpell->Effects[j].TargetA.GetTarget() == TARGET_UNIT_TARGET_ENEMY ||
                    pTempSpell->Effects[j].TargetA.GetTarget() == TARGET_DEST_TARGET_ENEMY ||
                    pTempSpell->Effects[j].TargetA.GetTarget() == TARGET_UNIT_SRC_AREA_ENEMY ||
                    pTempSpell->Effects[j].TargetA.GetTarget() == TARGET_UNIT_DEST_AREA_ENEMY ||
                    pTempSpell->Effects[j].TargetA.GetTarget() == TARGET_SRC_CASTER ||
                    pTempSpell->Effects[j].TargetA.GetTarget() == TARGET_DEST_DYNOBJ_ENEMY)
                SpellSummary[i].Targets |= 1 << (SELECT_TARGET_ANY_ENEMY - 1);
 
            // Spell targets a single friend (or self).
            if (pTempSpell->Effects[j].TargetA.GetTarget() == TARGET_UNIT_CASTER ||
                    pTempSpell->Effects[j].TargetA.GetTarget() == TARGET_UNIT_TARGET_ALLY ||
                    pTempSpell->Effects[j].TargetA.GetTarget() == TARGET_UNIT_TARGET_PARTY)
                SpellSummary[i].Targets |= 1 << (SELECT_TARGET_SINGLE_FRIEND - 1);
 
            // Spell targets AoE friends.
            if (pTempSpell->Effects[j].TargetA.GetTarget() == TARGET_UNIT_CASTER_AREA_PARTY ||
                    pTempSpell->Effects[j].TargetA.GetTarget() == TARGET_UNIT_LASTTARGET_AREA_PARTY ||
                    pTempSpell->Effects[j].TargetA.GetTarget() == TARGET_SRC_CASTER)
                SpellSummary[i].Targets |= 1 << (SELECT_TARGET_AOE_FRIEND - 1);
 
            // Spell targets any friend (or self).
            if (pTempSpell->Effects[j].TargetA.GetTarget() == TARGET_UNIT_CASTER ||
                    pTempSpell->Effects[j].TargetA.GetTarget() == TARGET_UNIT_TARGET_ALLY ||
                    pTempSpell->Effects[j].TargetA.GetTarget() == TARGET_UNIT_TARGET_PARTY ||
                    pTempSpell->Effects[j].TargetA.GetTarget() == TARGET_UNIT_CASTER_AREA_PARTY ||
                    pTempSpell->Effects[j].TargetA.GetTarget() == TARGET_UNIT_LASTTARGET_AREA_PARTY ||
                    pTempSpell->Effects[j].TargetA.GetTarget() == TARGET_SRC_CASTER)
                SpellSummary[i].Targets |= 1 << (SELECT_TARGET_ANY_FRIEND - 1);
 
            // Make sure that this spell includes a damage effect.
            if (pTempSpell->Effects[j].Effect == SPELL_EFFECT_SCHOOL_DAMAGE ||
                    pTempSpell->Effects[j].Effect == SPELL_EFFECT_INSTAKILL ||
                    pTempSpell->Effects[j].Effect == SPELL_EFFECT_ENVIRONMENTAL_DAMAGE ||
                    pTempSpell->Effects[j].Effect == SPELL_EFFECT_HEALTH_LEECH)
                SpellSummary[i].Effects |= 1 << (SELECT_EFFECT_DAMAGE - 1);
 
            // Make sure that this spell includes a healing effect (or an apply aura with a periodic heal).
            if (pTempSpell->Effects[j].Effect == SPELL_EFFECT_HEAL ||
                    pTempSpell->Effects[j].Effect == SPELL_EFFECT_HEAL_MAX_HEALTH ||
                    pTempSpell->Effects[j].Effect == SPELL_EFFECT_HEAL_MECHANICAL ||
                    (pTempSpell->Effects[j].Effect == SPELL_EFFECT_APPLY_AURA  && pTempSpell->Effects[j].ApplyAuraName == 8))
                SpellSummary[i].Effects |= 1 << (SELECT_EFFECT_HEALING - 1);
 
            // Make sure that this spell applies an aura.
            if (pTempSpell->Effects[j].Effect == SPELL_EFFECT_APPLY_AURA)
                SpellSummary[i].Effects |= 1 << (SELECT_EFFECT_AURA - 1);
        }
    }
}

References TSpellSummary::Effects, SpellInfo::Effects, UnitAI::FillAISpellInfo(), MAX_SPELL_EFFECTS, SELECT_EFFECT_AURA, SELECT_EFFECT_DAMAGE, SELECT_EFFECT_HEALING, SELECT_TARGET_ANY_ENEMY, SELECT_TARGET_ANY_FRIEND, SELECT_TARGET_AOE_ENEMY, SELECT_TARGET_AOE_FRIEND, SELECT_TARGET_SELF, SELECT_TARGET_SINGLE_ENEMY, SELECT_TARGET_SINGLE_FRIEND, SPELL_EFFECT_APPLY_AURA, SPELL_EFFECT_ENVIRONMENTAL_DAMAGE, SPELL_EFFECT_HEAL, SPELL_EFFECT_HEAL_MAX_HEALTH, SPELL_EFFECT_HEAL_MECHANICAL, SPELL_EFFECT_HEALTH_LEECH, SPELL_EFFECT_INSTAKILL, SPELL_EFFECT_SCHOOL_DAMAGE, SpellSummary, sSpellMgr, TARGET_DEST_DYNOBJ_ENEMY, TARGET_DEST_TARGET_ENEMY, TARGET_SRC_CASTER, TARGET_UNIT_CASTER, TARGET_UNIT_CASTER_AREA_PARTY, TARGET_UNIT_DEST_AREA_ENEMY, TARGET_UNIT_LASTTARGET_AREA_PARTY, TARGET_UNIT_SRC_AREA_ENEMY, TARGET_UNIT_TARGET_ALLY, TARGET_UNIT_TARGET_ENEMY, TARGET_UNIT_TARGET_PARTY, and TSpellSummary::Targets.

Referenced by LoadDatabase().

◆ GetChatCommands()

Acore::ChatCommands::ChatCommandTable ScriptMgr::GetChatCommands ( )

{
    Acore::ChatCommands::ChatCommandTable table;
 
    for (auto const& [scriptID, script] : ScriptRegistry<CommandScript>::ScriptPointerList)
    {
        Acore::ChatCommands::ChatCommandTable cmds = script->GetCommands();
        std::move(cmds.begin(), cmds.end(), std::back_inserter(table));
    }
 
    return table;
}

◆ GetCreatureAI()

CreatureAI * ScriptMgr::GetCreatureAI ( Creature * creature )

{
    ASSERT(creature);
 
    auto retAI = GetReturnAIScript<AllCreatureScript, CreatureAI>([creature](AllCreatureScript* script)
    {
        return script->GetCreatureAI(creature);
    });
 
    if (retAI)
    {
        return retAI;
    }
 
    auto tempScript = ScriptRegistry<CreatureScript>::GetScriptById(creature->GetScriptId());
    return tempScript ? tempScript->GetAI(creature) : nullptr;
}

References ASSERT, AllCreatureScript::GetCreatureAI(), ScriptRegistry< TScript >::GetScriptById(), and Creature::GetScriptId().

◆ GetCustomArenaPersonalRating()

void ScriptMgr::GetCustomArenaPersonalRating	(	Player const *	player,
		uint8	slot,
		uint32 &	rating
	)		const

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->GetCustomArenaPersonalRating(player, slot, rating);
    });
}

References PlayerScript::GetCustomArenaPersonalRating().

◆ GetCustomGetArenaTeamId()

void ScriptMgr::GetCustomGetArenaTeamId	(	Player const *	player,
		uint8	slot,
		uint32 &	teamID
	)		const

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->GetCustomGetArenaTeamId(player, slot, teamID);
    });
}

References PlayerScript::GetCustomGetArenaTeamId().

◆ GetDialogStatus() [1/3]

uint32 ScriptMgr::GetDialogStatus	(	Player *	player,
		Creature *	creature
	)

{
    ASSERT(player);
    ASSERT(creature);
 
    auto tempScript = ScriptRegistry<CreatureScript>::GetScriptById(creature->GetScriptId());
    return tempScript ? tempScript->GetDialogStatus(player, creature) : DIALOG_STATUS_SCRIPTED_NO_STATUS;
}

References ASSERT, DIALOG_STATUS_SCRIPTED_NO_STATUS, ScriptRegistry< TScript >::GetScriptById(), and Creature::GetScriptId().

◆ GetDialogStatus() [2/3]

uint32 ScriptMgr::GetDialogStatus	(	Player *	player,
		GameObject *	go
	)

{
    ASSERT(player);
    ASSERT(go);
 
    auto tempScript = ScriptRegistry<GameObjectScript>::GetScriptById(go->GetScriptId());
    ClearGossipMenuFor(player);
    return tempScript ? tempScript->GetDialogStatus(player, go) : DIALOG_STATUS_SCRIPTED_NO_STATUS;
}

References ASSERT, ClearGossipMenuFor(), DIALOG_STATUS_SCRIPTED_NO_STATUS, ScriptRegistry< TScript >::GetScriptById(), and GameObject::GetScriptId().

◆ GetDialogStatus() [3/3]

void ScriptMgr::GetDialogStatus	(	Player *	player,
		Object *	questgiver
	)

{
    ExecuteScript<MiscScript>([&](MiscScript* script)
    {
        script->GetDialogStatus(player, questgiver);
    });
}

References MiscScript::GetDialogStatus().

◆ GetGameObjectAI()

GameObjectAI * ScriptMgr::GetGameObjectAI ( GameObject * go )

{
    ASSERT(go);
 
    auto retAI = GetReturnAIScript<AllGameObjectScript, GameObjectAI>([go](AllGameObjectScript* script)
    {
        return script->GetGameObjectAI(go);
    });
 
    if (retAI)
    {
        return retAI;
    }
 
    auto tempScript = ScriptRegistry<GameObjectScript>::GetScriptById(go->GetScriptId());
    return tempScript ? tempScript->GetAI(go) : nullptr;
}

References ASSERT, AllGameObjectScript::GetGameObjectAI(), ScriptRegistry< TScript >::GetScriptById(), and GameObject::GetScriptId().

◆ GetScriptCount()

uint32 ScriptMgr::GetScriptCount ( ) const

inline

129{ return _scriptCount; }

References _scriptCount.

Referenced by LoadDatabase().

◆ IfNormalReaction()

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;
}

References UnitScript::IfNormalReaction().

◆ IncreaseScheduledScriptsCount()

uint32 ScriptMgr::IncreaseScheduledScriptsCount ( )

inline

524{ return ++_scheduledScripts; }

References _scheduledScripts.

◆ IncreaseScriptCount()

void ScriptMgr::IncreaseScriptCount ( )

inline

127{ ++_scriptCount; }

References _scriptCount.

◆ Initialize()

void ScriptMgr::Initialize ( )

{
    LOG_INFO("server.loading", "> Loading C++ scripts");
    LOG_INFO("server.loading", " ");
 
    AddSC_SmartScripts();
 
    // LFGScripts
    lfg::AddSC_LFGScripts();
 
    ASSERT(_script_loader_callback,
        "Script loader callback wasn't registered!");
 
    ASSERT(_modules_loader_callback,
        "Modules loader callback wasn't registered!");
 
    _script_loader_callback();
    _modules_loader_callback();
}

References _modules_loader_callback, _script_loader_callback, lfg::AddSC_LFGScripts(), AddSC_SmartScripts(), ASSERT, and LOG_INFO.

◆ instance()

ScriptMgr * ScriptMgr::instance ( )

static

{
    static ScriptMgr instance;
    return &instance;
}

References instance().

Referenced by AfterInstanceGameObjectCreate(), CanEnterMap(), instance(), and OnBeforeSetBossState().

◆ IsCheckNormalMatch()

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);
}

References AllBattlegroundScript::IsCheckNormalMatch(), and ReturnValidBool().

◆ IsCompletedCriteria()

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;
}

References AchievementScript::IsCompletedCriteria().

◆ IsCustomBuildValuesUpdate()

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;
}

References UnitScript::IsCustomBuildValuesUpdate().

◆ IsNeedModHealPercent()

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;
}

References UnitScript::IsNeedModHealPercent().

◆ IsNeedModMeleeDamagePercent()

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;
}

References UnitScript::IsNeedModMeleeDamagePercent().

◆ IsNeedModSpellDamagePercent()

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;
}

References UnitScript::IsNeedModSpellDamagePercent().

◆ IsRealmCompleted()

bool ScriptMgr::IsRealmCompleted	(	AchievementGlobalMgr const *	globalmgr,
		AchievementEntry const *	achievement,
		std::chrono::system_clock::time_point	completionTime
	)

{
    auto ret = IsValidBoolScript<AchievementScript>([&](AchievementScript* script)
    {
        return !script->IsRealmCompleted(globalmgr, achievement, completionTime);
    });
 
    if (ret && *ret)
    {
        return false;
    }
 
    return true;
}

References AchievementScript::IsRealmCompleted().

◆ IsScriptScheduled()

bool ScriptMgr::IsScriptScheduled ( ) const

inline

527{ return _scheduledScripts > 0; }

References _scheduledScripts.

◆ LoadDatabase()

void ScriptMgr::LoadDatabase ( )

{
    uint32 oldMSTime = getMSTime();
 
    sScriptSystemMgr->LoadScriptWaypoints();
 
    // Add all scripts that must be loaded after db/maps
    ScriptRegistry<WorldMapScript>::AddALScripts();
    ScriptRegistry<BattlegroundMapScript>::AddALScripts();
    ScriptRegistry<InstanceMapScript>::AddALScripts();
    ScriptRegistry<SpellScriptLoader>::AddALScripts();
    ScriptRegistry<ItemScript>::AddALScripts();
    ScriptRegistry<CreatureScript>::AddALScripts();
    ScriptRegistry<GameObjectScript>::AddALScripts();
    ScriptRegistry<AreaTriggerScript>::AddALScripts();
    ScriptRegistry<BattlegroundScript>::AddALScripts();
    ScriptRegistry<OutdoorPvPScript>::AddALScripts();
    ScriptRegistry<WeatherScript>::AddALScripts();
    ScriptRegistry<ConditionScript>::AddALScripts();
    ScriptRegistry<TransportScript>::AddALScripts();
    ScriptRegistry<AchievementCriteriaScript>::AddALScripts();
 
    FillSpellSummary();
 
    CheckIfScriptsInDatabaseExist();
 
    LOG_INFO("server.loading", ">> Loaded {} C++ scripts in {} ms", GetScriptCount(), GetMSTimeDiffToNow(oldMSTime));
    LOG_INFO("server.loading", " ");
}

References ScriptRegistry< TScript >::AddALScripts(), CheckIfScriptsInDatabaseExist(), FillSpellSummary(), getMSTime(), GetMSTimeDiffToNow(), GetScriptCount(), LOG_INFO, and sScriptSystemMgr.

◆ ModifyHealReceived()

void ScriptMgr::ModifyHealReceived	(	Unit *	target,
		Unit *	healer,
		uint32 &	addHealth,
		SpellInfo const *	spellInfo
	)

{
    ExecuteScript<UnitScript>([&](UnitScript* script)
    {
        script->ModifyHealReceived(target, healer, heal, spellInfo);
    });
}

References UnitScript::ModifyHealReceived().

◆ ModifyMeleeDamage()

void ScriptMgr::ModifyMeleeDamage	(	Unit *	target,
		Unit *	attacker,
		uint32 &	damage
	)

{
    ExecuteScript<UnitScript>([&](UnitScript* script)
    {
        script->ModifyMeleeDamage(target, attacker, damage);
    });
}

References UnitScript::ModifyMeleeDamage().

◆ ModifyPeriodicDamageAurasTick()

void ScriptMgr::ModifyPeriodicDamageAurasTick	(	Unit *	target,
		Unit *	attacker,
		uint32 &	damage,
		SpellInfo const *	spellInfo
	)

{
    ExecuteScript<UnitScript>([&](UnitScript* script)
    {
        script->ModifyPeriodicDamageAurasTick(target, attacker, damage, spellInfo);
    });
}

References UnitScript::ModifyPeriodicDamageAurasTick().

◆ ModifySpellDamageTaken()

void ScriptMgr::ModifySpellDamageTaken	(	Unit *	target,
		Unit *	attacker,
		int32 &	damage,
		SpellInfo const *	spellInfo
	)

{
    ExecuteScript<UnitScript>([&](UnitScript* script)
    {
        script->ModifySpellDamageTaken(target, attacker, damage, spellInfo);
    });
}

References UnitScript::ModifySpellDamageTaken().

◆ NotAvoidSatisfy()

bool ScriptMgr::NotAvoidSatisfy	(	Player *	player,
		DungeonProgressionRequirements const *	ar,
		uint32	target_map,
		bool	report
	)

{
    auto ret = IsValidBoolScript<PlayerScript>([&](PlayerScript* script)
    {
        return !script->NotAvoidSatisfy(player, ar, target_map, report);
    });
 
    if (ret && *ret)
    {
        return false;
    }
 
    return true;
}

References PlayerScript::NotAvoidSatisfy().

◆ NotSetArenaTeamInfoField()

bool ScriptMgr::NotSetArenaTeamInfoField	(	Player *	player,
		uint8	slot,
		ArenaTeamInfoType	type,
		uint32	value
	)

{
    auto ret = IsValidBoolScript<PlayerScript>([&](PlayerScript* script)
    {
        return !script->NotSetArenaTeamInfoField(player, slot, type, value);
    });
 
    if (ret && *ret)
    {
        return false;
    }
 
    return true;
}

References PlayerScript::NotSetArenaTeamInfoField().

◆ NotVisibleGloballyFor()

bool ScriptMgr::NotVisibleGloballyFor	(	Player *	player,
		Player const *	u
	)

{
    auto ret = IsValidBoolScript<PlayerScript>([&](PlayerScript* script)
    {
        return !script->NotVisibleGloballyFor(player, u);
    });
 
    if (ret && *ret)
    {
        return false;
    }
 
    return true;
}

References PlayerScript::NotVisibleGloballyFor().

◆ OnAccountLogin()

void ScriptMgr::OnAccountLogin ( uint32 accountId )

{
    ExecuteScript<AccountScript>([&](AccountScript* script)
    {
        script->OnAccountLogin(accountId);
    });
}

References AccountScript::OnAccountLogin().

◆ OnAchievementComplete()

void ScriptMgr::OnAchievementComplete	(	Player *	player,
		AchievementEntry const *	achievement
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnAchiComplete(player, achievement);
    });
}

References PlayerScript::OnAchiComplete().

◆ OnAchievementSave()

void ScriptMgr::OnAchievementSave	(	CharacterDatabaseTransaction	trans,
		Player *	player,
		uint16	achiId,
		CompletedAchievementData	achiData
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnAchiSave(trans, player, achiId, achiData);
    });
}

References PlayerScript::OnAchiSave().

◆ OnAddCreaturePassenger()

void ScriptMgr::OnAddCreaturePassenger	(	Transport *	transport,
		Creature *	creature
	)

{
    ASSERT(transport);
    ASSERT(creature);
 
    if (auto tempScript = ScriptRegistry<TransportScript>::GetScriptById(transport->GetScriptId()))
    {
        tempScript->OnAddCreaturePassenger(transport, creature);
    }
}

References ASSERT, and GameObject::GetScriptId().

◆ OnAddGroup()

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);
    });
}

References AllBattlegroundScript::OnAddGroup().

◆ OnAddPassenger() [1/2]

void ScriptMgr::OnAddPassenger	(	Transport *	transport,
		Player *	player
	)

{
    ASSERT(transport);
    ASSERT(player);
 
    if (auto tempScript = ScriptRegistry<TransportScript>::GetScriptById(transport->GetScriptId()))
    {
        tempScript->OnAddPassenger(transport, player);
    }
}

References ASSERT, and GameObject::GetScriptId().

◆ OnAddPassenger() [2/2]

void ScriptMgr::OnAddPassenger	(	Vehicle *	veh,
		Unit *	passenger,
		int8	seatId
	)

{
    ASSERT(veh);
    ASSERT(veh->GetBase()->GetTypeId() == TYPEID_UNIT);
    ASSERT(passenger);
 
    if (auto tempScript = ScriptRegistry<VehicleScript>::GetScriptById(veh->GetBase()->ToCreature()->GetScriptId()))
    {
        tempScript->OnAddPassenger(veh, passenger, seatId);
    }
}

References ASSERT, Vehicle::GetBase(), Creature::GetScriptId(), Object::GetTypeId(), Object::ToCreature(), and TYPEID_UNIT.

◆ OnAfterArenaRatingCalculation()

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);
    });
}

References FormulaScript::OnAfterArenaRatingCalculation().

◆ OnAfterCalculateLootGroupAmount()

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);
    });
}

References GlobalScript::OnAfterCalculateLootGroupAmount().

◆ OnAfterConfigLoad()

void ScriptMgr::OnAfterConfigLoad ( bool reload )

{
    ExecuteScript<WorldScript>([&](WorldScript* script)
    {
        script->OnAfterConfigLoad(reload);
    });
}

References WorldScript::OnAfterConfigLoad().

◆ OnAfterCreatureLoot()

void ScriptMgr::OnAfterCreatureLoot ( Player * player )

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnAfterCreatureLoot(player);
    });
}

References PlayerScript::OnAfterCreatureLoot().

◆ OnAfterCreatureLootMoney()

void ScriptMgr::OnAfterCreatureLootMoney ( Player * player )

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnAfterCreatureLootMoney(player);
    });
}

References PlayerScript::OnAfterCreatureLootMoney().

◆ OnAfterDatabaseLoadCreatureTemplates()

void ScriptMgr::OnAfterDatabaseLoadCreatureTemplates ( std::vector< CreatureTemplate * > creatureTemplateStore )

{
    ExecuteScript<DatabaseScript>([&](DatabaseScript* script)
    {
        script->OnAfterDatabaseLoadCreatureTemplates(creatureTemplates);
    });
}

References DatabaseScript::OnAfterDatabaseLoadCreatureTemplates().

◆ OnAfterDatabasesLoaded()

void ScriptMgr::OnAfterDatabasesLoaded ( uint32 updateFlags )

{
    ExecuteScript<DatabaseScript>([&](DatabaseScript* script)
    {
        script->OnAfterDatabasesLoaded(updateFlags);
    });
}

References DatabaseScript::OnAfterDatabasesLoaded().

◆ OnAfterGuardianInitStatsForLevel()

void ScriptMgr::OnAfterGuardianInitStatsForLevel	(	Player *	player,
		Guardian *	guardian
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnAfterGuardianInitStatsForLevel(player, guardian);
    });
}

References PlayerScript::OnAfterGuardianInitStatsForLevel().

◆ OnAfterInitializeLockedDungeons()

void ScriptMgr::OnAfterInitializeLockedDungeons ( Player * player )

{
    ExecuteScript<GlobalScript>([&](GlobalScript* script)
    {
        script->OnAfterInitializeLockedDungeons(player);
    });
}

References GlobalScript::OnAfterInitializeLockedDungeons().

◆ OnAfterLootTemplateProcess()

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);
    });
}

References MiscScript::OnAfterLootTemplateProcess().

◆ OnAfterPlayerMoveItemFromInventory()

void ScriptMgr::OnAfterPlayerMoveItemFromInventory	(	Player *	player,
		Item *	it,
		uint8	bag,
		uint8	slot,
		bool	update
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnAfterMoveItemFromInventory(player, it, bag, slot, update);
    });
}

References PlayerScript::OnAfterMoveItemFromInventory().

◆ OnAfterPlayerSetVisibleItemSlot()

void ScriptMgr::OnAfterPlayerSetVisibleItemSlot	(	Player *	player,
		uint8	slot,
		Item *	item
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnAfterSetVisibleItemSlot(player, slot, item);
    });
}

References PlayerScript::OnAfterSetVisibleItemSlot().

◆ OnAfterRefCount()

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);
    });
}

References GlobalScript::OnAfterRefCount().

◆ OnAfterSpecSlotChanged()

void ScriptMgr::OnAfterSpecSlotChanged	(	Player *	player,
		uint8	newSlot
	)

{
    ExecuteScript<PlayerScript>([=](PlayerScript* script)
    {
        script->OnAfterSpecSlotChanged(player, newSlot);
    });
}

References PlayerScript::OnAfterSpecSlotChanged().

◆ OnAfterStoreOrEquipNewItem()

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
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnAfterStoreOrEquipNewItem(player, vendorslot, item, count, bag, slot, pProto, pVendor, crItem, bStore);
    });
}

References PlayerScript::OnAfterStoreOrEquipNewItem().

◆ OnAfterUnloadAllMaps()

void ScriptMgr::OnAfterUnloadAllMaps ( )

{
    ExecuteScript<WorldScript>([](WorldScript* script)
    {
        script->OnAfterUnloadAllMaps();
    });
}

References WorldScript::OnAfterUnloadAllMaps().

◆ OnAfterUpdateAttackPowerAndDamage()

void ScriptMgr::OnAfterUpdateAttackPowerAndDamage	(	Player *	player,
		float &	level,
		float &	base_attPower,
		float &	attPowerMod,
		float &	attPowerMultiplier,
		bool	ranged
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnAfterUpdateAttackPowerAndDamage(player, level, base_attPower, attPowerMod, attPowerMultiplier, ranged);
    });
}

References PlayerScript::OnAfterUpdateAttackPowerAndDamage().

◆ OnAfterUpdateEncounterState()

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);
    });
}

References GlobalScript::OnAfterUpdateEncounterState().

◆ OnAfterUpdateMaxHealth()

void ScriptMgr::OnAfterUpdateMaxHealth	(	Player *	player,
		float &	value
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnAfterUpdateMaxHealth(player, value);
    });
}

References PlayerScript::OnAfterUpdateMaxHealth().

◆ OnAfterUpdateMaxPower()

void ScriptMgr::OnAfterUpdateMaxPower	(	Player *	player,
		Powers &	power,
		float &	value
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnAfterUpdateMaxPower(player, power, value);
    });
}

References PlayerScript::OnAfterUpdateMaxPower().

◆ OnAllowedForPlayerLootCheck()

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;
}

References GlobalScript::OnAllowedForPlayerLootCheck().

◆ OnAllowedToLootContainerCheck()

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;
}

References GlobalScript::OnAllowedToLootContainerCheck().

◆ OnApplyAmmoBonuses()

void ScriptMgr::OnApplyAmmoBonuses	(	Player *	player,
		ItemTemplate const *	proto,
		float &	currentAmmoDPS
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnApplyAmmoBonuses(player, proto, currentAmmoDPS);
    });
}

References PlayerScript::OnApplyAmmoBonuses().

◆ OnAreaTrigger()

bool ScriptMgr::OnAreaTrigger	(	Player *	player,
		AreaTrigger const *	trigger
	)

{
    ASSERT(player);
    ASSERT(trigger);
 
    auto ret = IsValidBoolScript<ElunaScript>([&](ElunaScript* script)
    {
        return script->CanAreaTrigger(player, trigger);
    });
 
    if (ret && *ret)
    {
        return false;
    }
 
    auto tempScript = ScriptRegistry<AreaTriggerScript>::GetScriptById(sObjectMgr->GetAreaTriggerScriptId(trigger->entry));
    return tempScript ? tempScript->OnTrigger(player, trigger) : false;
}

◆ OnArenaQueueIdToArenaType()

void ScriptMgr::OnArenaQueueIdToArenaType	(	const BattlegroundQueueTypeId	bgQueueTypeId,
		uint8 &	ArenaType
	)

{
    ExecuteScript<ArenaTeamScript>([&](ArenaTeamScript* script)
    {
        script->OnQueueIdToArenaType(bgQueueTypeId, ArenaType);
    });
}

References ArenaTeamScript::OnQueueIdToArenaType().

◆ OnArenaTypeIDToQueueID()

void ScriptMgr::OnArenaTypeIDToQueueID	(	const BattlegroundTypeId	bgTypeId,
		const uint8	arenaType,
		uint32 &	queueTypeID
	)

{
    ExecuteScript<ArenaTeamScript>([&](ArenaTeamScript* script)
    {
        script->OnTypeIDToQueueID(bgTypeId, arenaType, queueTypeID);
    });
}

References ArenaTeamScript::OnTypeIDToQueueID().

◆ OnAuctionAdd()

void ScriptMgr::OnAuctionAdd	(	AuctionHouseObject *	ah,
		AuctionEntry *	entry
	)

{
    ASSERT(ah);
    ASSERT(entry);
 
    ExecuteScript<AuctionHouseScript>([&](AuctionHouseScript* script)
    {
        script->OnAuctionAdd(ah, entry);
    });
}

References ASSERT, and AuctionHouseScript::OnAuctionAdd().

◆ OnAuctionExpire()

void ScriptMgr::OnAuctionExpire	(	AuctionHouseObject *	ah,
		AuctionEntry *	entry
	)

{
    ASSERT(ah);
    ASSERT(entry);
 
    ExecuteScript<AuctionHouseScript>([&](AuctionHouseScript* script)
    {
        script->OnAuctionExpire(ah, entry);
    });
}

References ASSERT, and AuctionHouseScript::OnAuctionExpire().

◆ OnAuctionRemove()

void ScriptMgr::OnAuctionRemove	(	AuctionHouseObject *	ah,
		AuctionEntry *	entry
	)

{
    ASSERT(ah);
    ASSERT(entry);
 
    ExecuteScript<AuctionHouseScript>([&](AuctionHouseScript* script)
    {
        script->OnAuctionRemove(ah, entry);
    });
}

References ASSERT, and AuctionHouseScript::OnAuctionRemove().

◆ OnAuctionSuccessful()

void ScriptMgr::OnAuctionSuccessful	(	AuctionHouseObject *	ah,
		AuctionEntry *	entry
	)

{
    ASSERT(ah);
    ASSERT(entry);
 
    ExecuteScript<AuctionHouseScript>([&](AuctionHouseScript* script)
    {
        script->OnAuctionSuccessful(ah, entry);
    });
}

References ASSERT, and AuctionHouseScript::OnAuctionSuccessful().

◆ OnAuraApply()

void ScriptMgr::OnAuraApply	(	Unit *	unit,
		Aura *	aura
	)

{
    ExecuteScript<UnitScript>([&](UnitScript* script)
    {
        script->OnAuraApply(unit, aura);
    });
}

References UnitScript::OnAuraApply().

◆ OnAuraRemove()

void ScriptMgr::OnAuraRemove	(	Unit *	unit,
		AuraApplication *	aurApp,
		AuraRemoveMode	mode
	)

{
    ExecuteScript<UnitScript>([&](UnitScript* script)
    {
        script->OnAuraRemove(unit, aurApp, mode);
    });
}

References UnitScript::OnAuraRemove().

◆ OnBaseGainCalculation()

void ScriptMgr::OnBaseGainCalculation	(	uint32 &	gain,
		uint8	playerLevel,
		uint8	mobLevel,
		ContentLevels	content
	)

{
    ExecuteScript<FormulaScript>([&](FormulaScript* script)
    {
        script->OnBaseGainCalculation(gain, playerLevel, mobLevel, content);
    });
}

References FormulaScript::OnBaseGainCalculation().

◆ OnBattlegroundAddPlayer()

void ScriptMgr::OnBattlegroundAddPlayer	(	Battleground *	bg,
		Player *	player
	)

{
    ExecuteScript<AllBattlegroundScript>([&](AllBattlegroundScript* script)
    {
        script->OnBattlegroundAddPlayer(bg, player);
    });
}

References AllBattlegroundScript::OnBattlegroundAddPlayer().

◆ OnBattlegroundBeforeAddPlayer()

void ScriptMgr::OnBattlegroundBeforeAddPlayer	(	Battleground *	bg,
		Player *	player
	)

{
    ExecuteScript<AllBattlegroundScript>([&](AllBattlegroundScript* script)
    {
        script->OnBattlegroundBeforeAddPlayer(bg, player);
    });
}

References AllBattlegroundScript::OnBattlegroundBeforeAddPlayer().

◆ OnBattlegroundCreate()

void ScriptMgr::OnBattlegroundCreate ( Battleground * bg )

{
    ExecuteScript<AllBattlegroundScript>([&](AllBattlegroundScript* script)
    {
        script->OnBattlegroundCreate(bg);
    });
}

References AllBattlegroundScript::OnBattlegroundCreate().

◆ OnBattlegroundDesertion()

void ScriptMgr::OnBattlegroundDesertion	(	Player *	player,
		BattlegroundDesertionType const	desertionType
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnBattlegroundDesertion(player, desertionType);
    });
}

References PlayerScript::OnBattlegroundDesertion().

◆ OnBattlegroundDestroy()

void ScriptMgr::OnBattlegroundDestroy ( Battleground * bg )

{
    ExecuteScript<AllBattlegroundScript>([&](AllBattlegroundScript* script)
    {
        script->OnBattlegroundDestroy(bg);
    });
}

References AllBattlegroundScript::OnBattlegroundDestroy().

◆ OnBattlegroundEnd()

void ScriptMgr::OnBattlegroundEnd	(	Battleground *	bg,
		TeamId	winnerTeamId
	)

{
    ExecuteScript<AllBattlegroundScript>([&](AllBattlegroundScript* script)
    {
        script->OnBattlegroundEnd(bg, winnerTeam);
    });
}

References AllBattlegroundScript::OnBattlegroundEnd().

◆ OnBattlegroundEndReward()

void ScriptMgr::OnBattlegroundEndReward	(	Battleground *	bg,
		Player *	player,
		TeamId	winnerTeamId
	)

{
    ExecuteScript<AllBattlegroundScript>([&](AllBattlegroundScript* script)
    {
        script->OnBattlegroundEndReward(bg, player, winnerTeamId);
    });
}

References AllBattlegroundScript::OnBattlegroundEndReward().

◆ OnBattlegroundRemovePlayerAtLeave()

void ScriptMgr::OnBattlegroundRemovePlayerAtLeave	(	Battleground *	bg,
		Player *	player
	)

{
    ExecuteScript<AllBattlegroundScript>([&](AllBattlegroundScript* script)
    {
        script->OnBattlegroundRemovePlayerAtLeave(bg, player);
    });
}

References AllBattlegroundScript::OnBattlegroundRemovePlayerAtLeave().

◆ OnBattlegroundStart()

void ScriptMgr::OnBattlegroundStart ( Battleground * bg )

{
    ExecuteScript<AllBattlegroundScript>([&](AllBattlegroundScript* script)
    {
        script->OnBattlegroundStart(bg);
    });
}

References AllBattlegroundScript::OnBattlegroundStart().

◆ OnBattlegroundUpdate()

void ScriptMgr::OnBattlegroundUpdate	(	Battleground *	bg,
		uint32	diff
	)

{
    ExecuteScript<AllBattlegroundScript>([&](AllBattlegroundScript* script)
    {
        script->OnBattlegroundUpdate(bg, diff);
    });
}

References AllBattlegroundScript::OnBattlegroundUpdate().

◆ OnBeforeAchievementComplete()

bool ScriptMgr::OnBeforeAchievementComplete	(	Player *	player,
		AchievementEntry const *	achievement
	)

{
    auto ret = IsValidBoolScript<PlayerScript>([&](PlayerScript* script)
    {
        return !script->OnBeforeAchiComplete(player, achievement);
    });
 
    if (ret && *ret)
    {
        return false;
    }
 
    return true;
}

References PlayerScript::OnBeforeAchiComplete().

◆ OnBeforeAuctionHouseMgrSendAuctionCancelledToBidderMail()

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);
    });
}

References AuctionHouseScript::OnBeforeAuctionHouseMgrSendAuctionCancelledToBidderMail().

◆ OnBeforeAuctionHouseMgrSendAuctionExpiredMail()

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);
    });
}

References AuctionHouseScript::OnBeforeAuctionHouseMgrSendAuctionExpiredMail().

◆ OnBeforeAuctionHouseMgrSendAuctionOutbiddedMail()

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);
    });
}

References AuctionHouseScript::OnBeforeAuctionHouseMgrSendAuctionOutbiddedMail().

◆ OnBeforeAuctionHouseMgrSendAuctionSalePendingMail()

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);
    });
}

References AuctionHouseScript::OnBeforeAuctionHouseMgrSendAuctionSalePendingMail().

◆ OnBeforeAuctionHouseMgrSendAuctionSuccessfulMail()

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);
    });
}

References AuctionHouseScript::OnBeforeAuctionHouseMgrSendAuctionSuccessfulMail().

◆ OnBeforeAuctionHouseMgrSendAuctionWonMail()

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);
    });
}

References AuctionHouseScript::OnBeforeAuctionHouseMgrSendAuctionWonMail().

◆ OnBeforeAuctionHouseMgrUpdate()

void ScriptMgr::OnBeforeAuctionHouseMgrUpdate ( )

{
    ExecuteScript<AuctionHouseScript>([&](AuctionHouseScript* script)
    {
        script->OnBeforeAuctionHouseMgrUpdate();
    });
}

References AuctionHouseScript::OnBeforeAuctionHouseMgrUpdate().

◆ OnBeforeAuraRankForLevel()

void ScriptMgr::OnBeforeAuraRankForLevel	(	SpellInfo const *	spellInfo,
		SpellInfo const *	latestSpellInfo,
		uint8	level
	)

{
    ExecuteScript<AllSpellScript>([&](AllSpellScript* script)
    {
        script->OnBeforeAuraRankForLevel(spellInfo, latestSpellInfo, level);
    });
}

References AllSpellScript::OnBeforeAuraRankForLevel().

◆ OnBeforeBuyItemFromVendor()

void ScriptMgr::OnBeforeBuyItemFromVendor	(	Player *	player,
		ObjectGuid	vendorguid,
		uint32	vendorslot,
		uint32 &	item,
		uint8	count,
		uint8	bag,
		uint8	slot
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnBeforeBuyItemFromVendor(player, vendorguid, vendorslot, item, count, bag, slot);
    });
}

References PlayerScript::OnBeforeBuyItemFromVendor().

◆ OnBeforeCheckCriteria()

void ScriptMgr::OnBeforeCheckCriteria	(	AchievementMgr *	mgr,
		AchievementCriteriaEntryList const *	achievementCriteriaList
	)

{
    ExecuteScript<AchievementScript>([&](AchievementScript* script)
    {
        script->OnBeforeCheckCriteria(mgr, achievementCriteriaList);
    });
}

References AchievementScript::OnBeforeCheckCriteria().

◆ OnBeforeChooseGraveyard()

void ScriptMgr::OnBeforeChooseGraveyard	(	Player *	player,
		TeamId	teamId,
		bool	nearCorpse,
		uint32 &	graveyardOverride
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnBeforeChooseGraveyard(player, teamId, nearCorpse, graveyardOverride);
    });
}

References PlayerScript::OnBeforeChooseGraveyard().

◆ OnBeforeConfigLoad()

void ScriptMgr::OnBeforeConfigLoad ( bool reload )

{
    ExecuteScript<WorldScript>([&](WorldScript* script)
    {
        script->OnBeforeConfigLoad(reload);
    });
}

References WorldScript::OnBeforeConfigLoad().

◆ OnBeforeCreateInstanceScript()

void ScriptMgr::OnBeforeCreateInstanceScript	(	InstanceMap *	instanceMap,
		InstanceScript *	instanceData,
		bool	load,
		std::string	data,
		uint32	completedEncounterMask
	)

{
    ExecuteScript<AllMapScript>([&](AllMapScript* script)
    {
        script->OnBeforeCreateInstanceScript(instanceMap, instanceData, load, data, completedEncounterMask);
    });
}

References AllMapScript::OnBeforeCreateInstanceScript().

◆ OnBeforeCreatureSelectLevel()

void ScriptMgr::OnBeforeCreatureSelectLevel	(	const CreatureTemplate *	cinfo,
		Creature *	creature,
		uint8 &	level
	)

{
    ExecuteScript<AllCreatureScript>([&](AllCreatureScript* script)
    {
        script->OnBeforeCreatureSelectLevel(cinfo, creature, level);
    });
 
}

References AllCreatureScript::OnBeforeCreatureSelectLevel().

◆ OnBeforeCriteriaProgress()

bool ScriptMgr::OnBeforeCriteriaProgress	(	Player *	player,
		AchievementCriteriaEntry const *	criteria
	)

{
    auto ret = IsValidBoolScript<PlayerScript>([&](PlayerScript* script)
    {
        return !script->OnBeforeCriteriaProgress(player, criteria);
    });
 
    if (ret && *ret)
    {
        return false;
    }
 
    return true;
}

References PlayerScript::OnBeforeCriteriaProgress().

◆ OnBeforeDropAddItem()

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);
    });
}

References GlobalScript::OnBeforeDropAddItem().

◆ OnBeforeFillQuestLootItem()

void ScriptMgr::OnBeforeFillQuestLootItem	(	Player *	player,
		LootItem &	item
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnBeforeFillQuestLootItem(player, item);
    });
}

References PlayerScript::OnBeforeFillQuestLootItem().

◆ OnBeforeFinalizePlayerWorldSession()

void ScriptMgr::OnBeforeFinalizePlayerWorldSession ( uint32 & cacheVersion )

{
    ExecuteScript<WorldScript>([&](WorldScript* script)
    {
        script->OnBeforeFinalizePlayerWorldSession(cacheVersion);
    });
}

References WorldScript::OnBeforeFinalizePlayerWorldSession().

◆ OnBeforeGuardianInitStatsForLevel()

void ScriptMgr::OnBeforeGuardianInitStatsForLevel	(	Player *	player,
		Guardian *	guardian,
		CreatureTemplate const *	cinfo,
		PetType &	petType
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnBeforeGuardianInitStatsForLevel(player, guardian, cinfo, petType);
    });
}

References PlayerScript::OnBeforeGuardianInitStatsForLevel().

◆ OnBeforeInitTalentForLevel()

void ScriptMgr::OnBeforeInitTalentForLevel	(	Player *	player,
		uint8 &	level,
		uint32 &	talentPointsForLevel
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnBeforeInitTalentForLevel(player, level, talentPointsForLevel);
    });
}

References PlayerScript::OnBeforeInitTalentForLevel().

◆ OnBeforeLoadPetFromDB()

void ScriptMgr::OnBeforeLoadPetFromDB	(	Player *	player,
		uint32 &	petentry,
		uint32 &	petnumber,
		bool &	current,
		bool &	forceLoadFromDB
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnBeforeLoadPetFromDB(player, petentry, petnumber, current, forceLoadFromDB);
    });
}

References PlayerScript::OnBeforeLoadPetFromDB().

◆ OnBeforeLootEqualChanced()

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;
}

References GlobalScript::OnBeforeLootEqualChanced().

◆ OnBeforeLootMoney()

void ScriptMgr::OnBeforeLootMoney	(	Player *	player,
		Loot *	loot
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnBeforeLootMoney(player, loot);
    });
}

References PlayerScript::OnBeforeLootMoney().

◆ OnBeforeMailDraftSendMailTo()

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);\
    });
}

References MailScript::OnBeforeMailDraftSendMailTo().

◆ OnBeforeOpenItem()

bool ScriptMgr::OnBeforeOpenItem	(	Player *	player,
		Item *	item
	)

{
    auto ret = IsValidBoolScript<PlayerScript>([&](PlayerScript* script)
        {
            return !script->OnBeforeOpenItem(player, item);
        });
 
    if (ret && *ret)
    {
        return false;
    }
 
    return true;
}

References PlayerScript::OnBeforeOpenItem().

◆ OnBeforePlayerDurabilityRepair()

void ScriptMgr::OnBeforePlayerDurabilityRepair	(	Player *	player,
		ObjectGuid	npcGUID,
		ObjectGuid	itemGUID,
		float &	discountMod,
		uint8	guildBank
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnBeforeDurabilityRepair(player, npcGUID, itemGUID, discountMod, guildBank);
    });
}

References PlayerScript::OnBeforeDurabilityRepair().

◆ OnBeforePlayerQuestComplete()

bool ScriptMgr::OnBeforePlayerQuestComplete	(	Player *	player,
		uint32	quest_id
	)

{
    auto ret = IsValidBoolScript<PlayerScript>([&](PlayerScript* script)
    {
        return !script->OnBeforeQuestComplete(player, quest_id);
    });
 
    if (ret && *ret)
    {
        return false;
    }
 
    return true;
}

References PlayerScript::OnBeforeQuestComplete().

◆ OnBeforePlayerTeleport()

bool ScriptMgr::OnBeforePlayerTeleport	(	Player *	player,
		uint32	mapid,
		float	x,
		float	y,
		float	z,
		float	orientation,
		uint32	options,
		Unit *	target
	)

{
    auto ret = IsValidBoolScript<PlayerScript>([&](PlayerScript* script)
    {
        return !script->OnBeforeTeleport(player, mapid, x, y, z, orientation, options, target);
    });
 
    if (ret && *ret)
    {
        return false;
    }
 
    return true;
}

References PlayerScript::OnBeforeTeleport().

◆ OnBeforePlayerUpdate()

void ScriptMgr::OnBeforePlayerUpdate	(	Player *	player,
		uint32	p_time
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnBeforeUpdate(player, p_time);
    });
}

References PlayerScript::OnBeforeUpdate().

◆ OnBeforeRollMeleeOutcomeAgainst()

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);
    });
}

References UnitScript::OnBeforeRollMeleeOutcomeAgainst().

◆ OnBeforeSendChatMessage()

void ScriptMgr::OnBeforeSendChatMessage	(	Player *	player,
		uint32 &	type,
		uint32 &	lang,
		std::string &	msg
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnBeforeSendChatMessage(player, type, lang, msg);
    });
}

References PlayerScript::OnBeforeSendChatMessage().

◆ OnBeforeSendExitMessageArenaQueue()

bool ScriptMgr::OnBeforeSendExitMessageArenaQueue	(	BattlegroundQueue *	queue,
		GroupQueueInfo *	ginfo
	)

{
    auto ret = IsValidBoolScript<AllBattlegroundScript>([&](AllBattlegroundScript* script)
    {
        return !script->OnBeforeSendExitMessageArenaQueue(queue, ginfo);
    });
 
    return ReturnValidBool(ret);
}

References AllBattlegroundScript::OnBeforeSendExitMessageArenaQueue(), and ReturnValidBool().

◆ OnBeforeSendJoinMessageArenaQueue()

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);
}

References AllBattlegroundScript::OnBeforeSendJoinMessageArenaQueue(), and ReturnValidBool().

◆ OnBeforeSetBossState()

void ScriptMgr::OnBeforeSetBossState	(	uint32	id,
		EncounterState	newState,
		EncounterState	oldState,
		Map *	instance
	)

Called when any raid boss has their state updated (e.g. pull, reset, kill).

Careful checks for old- and newState are required, since it can fire multiple times and not only when combat starts/ends.

Parameters

id	The id of the boss in the [instance]
newState	The new boss state to be applied to this boss
oldState	The previously assigned state of this boss
instance	A pointer to the [map] object of the instance

{
    ExecuteScript<GlobalScript>([&](GlobalScript* script)
    {
        script->OnBeforeSetBossState(id, newState, oldState, instance);
    });
}

References instance(), and GlobalScript::OnBeforeSetBossState().

◆ OnBeforeStoreOrEquipNewItem()

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
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnBeforeStoreOrEquipNewItem(player, vendorslot, item, count, bag, slot, pProto, pVendor, crItem, bStore);
    });
}

References PlayerScript::OnBeforeStoreOrEquipNewItem().

◆ OnBeforeTempSummonInitStats()

void ScriptMgr::OnBeforeTempSummonInitStats	(	Player *	player,
		TempSummon *	tempSummon,
		uint32 &	duration
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnBeforeTempSummonInitStats(player, tempSummon, duration);
    });
}

References PlayerScript::OnBeforeTempSummonInitStats().

◆ OnBeforeUpdateArenaPoints()

void ScriptMgr::OnBeforeUpdateArenaPoints	(	ArenaTeam *	at,
		std::map< ObjectGuid, uint32 > &	ap
	)

{
    ExecuteScript<GlobalScript>([&](GlobalScript* script)
    {
        script->OnBeforeUpdateArenaPoints(at, ap);
    });
}

References GlobalScript::OnBeforeUpdateArenaPoints().

◆ OnBeforeUpdateAttackPowerAndDamage()

void ScriptMgr::OnBeforeUpdateAttackPowerAndDamage	(	Player *	player,
		float &	level,
		float &	val2,
		bool	ranged
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnBeforeUpdateAttackPowerAndDamage(player, level, val2, ranged);
    });
}

References PlayerScript::OnBeforeUpdateAttackPowerAndDamage().

◆ OnBeforeUpdatingPersonalRating()

void ScriptMgr::OnBeforeUpdatingPersonalRating	(	int32 &	mod,
		uint32	type
	)

{
    ExecuteScript<FormulaScript>([&](FormulaScript* script)
    {
        script->OnBeforeUpdatingPersonalRating(mod, type);
    });
}

References FormulaScript::OnBeforeUpdatingPersonalRating().

◆ OnBeforeWorldInitialized()

void ScriptMgr::OnBeforeWorldInitialized ( )

{
    ExecuteScript<WorldScript>([&](WorldScript* script)
    {
        script->OnBeforeWorldInitialized();
    });
}

References WorldScript::OnBeforeWorldInitialized().

◆ OnBeforeWorldObjectSetPhaseMask()

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);
    });
}

References GlobalScript::OnBeforeWorldObjectSetPhaseMask().

◆ OnBuildValuesUpdate()

bool ScriptMgr::OnBuildValuesUpdate	(	Unit const *	unit,
		uint8	updateType,
		ByteBuffer &	fieldBuffer,
		Player *	target,
		uint16	index
	)

{
    auto ret = IsValidBoolScript<UnitScript>([&](UnitScript* script) { return script->OnBuildValuesUpdate(unit, updateType, fieldBuffer, target, index); });
 
    if (ret && *ret)
    {
        return true;
    }
 
    return false;
}

References UnitScript::OnBuildValuesUpdate().

◆ OnCalcMaxDuration()

void ScriptMgr::OnCalcMaxDuration	(	Aura const *	aura,
		int32 &	maxDuration
	)

{
    ExecuteScript<AllSpellScript>([&](AllSpellScript* script)
    {
        script->OnCalcMaxDuration(aura, maxDuration);
    });
}

References AllSpellScript::OnCalcMaxDuration().

◆ OnCalculateMaxTalentPointsForLevel()

void ScriptMgr::OnCalculateMaxTalentPointsForLevel	(	Pet *	pet,
		uint8	level,
		uint8 &	points
	)

{
    ExecuteScript<PetScript>([&](PetScript* script)
    {
        script->OnCalculateMaxTalentPointsForLevel(pet, level, points);
    });
}

References PetScript::OnCalculateMaxTalentPointsForLevel().

◆ OnCanPlayerFlyInZone()

bool ScriptMgr::OnCanPlayerFlyInZone	(	Player *	player,
		uint32	mapId,
		uint32	zoneId,
		SpellInfo const *	bySpell
	)

{
    auto ret = IsValidBoolScript<PlayerScript>([player, mapId, zoneId, bySpell](PlayerScript* script)
        {
            return !script->OnCanPlayerFlyInZone(player, mapId, zoneId, bySpell);
        });
 
    if (ret && *ret)
    {
        return false;
    }
 
    return true;
}

References PlayerScript::OnCanPlayerFlyInZone().

◆ OnCastItemCombatSpell()

bool ScriptMgr::OnCastItemCombatSpell	(	Player *	player,
		Unit *	victim,
		SpellInfo const *	spellInfo,
		Item *	item
	)

{
    ASSERT(player);
    ASSERT(victim);
    ASSERT(spellInfo);
    ASSERT(item);
 
    auto tempScript = ScriptRegistry<ItemScript>::GetScriptById(item->GetScriptId());
    return tempScript ? tempScript->OnCastItemCombatSpell(player, victim, spellInfo, item) : true;
}

References ASSERT, ScriptRegistry< TScript >::GetScriptById(), and Item::GetScriptId().

◆ OnColorCodeCalculation()

void ScriptMgr::OnColorCodeCalculation	(	XPColorChar &	color,
		uint8	playerLevel,
		uint8	mobLevel
	)

{
    ExecuteScript<FormulaScript>([&](FormulaScript* script)
    {
        script->OnColorCodeCalculation(color, playerLevel, mobLevel);
    });
}

References FormulaScript::OnColorCodeCalculation().

◆ OnConditionCheck()

bool ScriptMgr::OnConditionCheck	(	Condition *	condition,
		ConditionSourceInfo &	sourceInfo
	)

{
    ASSERT(condition);
 
    auto tempScript = ScriptRegistry<ConditionScript>::GetScriptById(condition->ScriptId);
    return tempScript ? tempScript->OnConditionCheck(condition, sourceInfo) : true;
}

References ASSERT, ScriptRegistry< TScript >::GetScriptById(), and Condition::ScriptId.

◆ OnConstructGroup()

void ScriptMgr::OnConstructGroup ( Group * origin )

{
    ExecuteScript<MiscScript>([&](MiscScript* script)
    {
        script->OnConstructGroup(origin);
    });
}

References MiscScript::OnConstructGroup().

◆ OnConstructInstanceSave()

void ScriptMgr::OnConstructInstanceSave ( InstanceSave * origin )

{
    ExecuteScript<MiscScript>([&](MiscScript* script)
    {
        script->OnConstructInstanceSave(origin);
    });
}

References MiscScript::OnConstructInstanceSave().

◆ OnConstructObject()

void ScriptMgr::OnConstructObject ( Object * origin )

{
    ExecuteScript<MiscScript>([&](MiscScript* script)
    {
        script->OnConstructObject(origin);
    });
}

References MiscScript::OnConstructObject().

◆ OnConstructPlayer()

void ScriptMgr::OnConstructPlayer ( Player * origin )

{
    ExecuteScript<MiscScript>([&](MiscScript* script)
    {
        script->OnConstructPlayer(origin);
    });
}

References MiscScript::OnConstructPlayer().

◆ OnCreate()

void ScriptMgr::OnCreate	(	Group *	group,
		Player *	leader
	)

{
    ExecuteScript<GroupScript>([&](GroupScript* script)
    {
        script->OnCreate(group, leader);
    });
}

References GroupScript::OnCreate().

◆ OnCreateItem()

void ScriptMgr::OnCreateItem	(	Player *	player,
		Item *	item,
		uint32	count
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnCreateItem(player, item, count);
    });
}

References PlayerScript::OnCreateItem().

◆ OnCreateMap()

void ScriptMgr::OnCreateMap ( Map * map )

{
    ASSERT(map);
 
    ExecuteScript<AllMapScript>([&](AllMapScript* script)
    {
        script->OnCreateMap(map);
    });
 
    ForeachMaps<WorldMapScript>(map,
    [&](WorldMapScript* script)
    {
        script->OnCreate(map);
    });
 
    ForeachMaps<InstanceMapScript>(map,
    [&](InstanceMapScript* script)
    {
        script->OnCreate((InstanceMap*)map);
    });
 
    ForeachMaps<BattlegroundMapScript>(map,
    [&](BattlegroundMapScript* script)
    {
        script->OnCreate((BattlegroundMap*)map);
    });
}

References ASSERT, and AllMapScript::OnCreateMap().

◆ OnCreatureAddWorld()

void ScriptMgr::OnCreatureAddWorld ( Creature * creature )

{
    ASSERT(creature);
 
    ExecuteScript<AllCreatureScript>([&](AllCreatureScript* script)
    {
        script->OnCreatureAddWorld(creature);
    });
}

References ASSERT, and AllCreatureScript::OnCreatureAddWorld().

◆ OnCreatureKill()

void ScriptMgr::OnCreatureKill	(	Player *	killer,
		Creature *	killed
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnCreatureKill(killer, killed);
    });
}

References PlayerScript::OnCreatureKill().

◆ OnCreatureKilledByPet()

void ScriptMgr::OnCreatureKilledByPet	(	Player *	petOwner,
		Creature *	killed
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnCreatureKilledByPet(petOwner, killed);
    });
}

References PlayerScript::OnCreatureKilledByPet().

◆ OnCreatureRemoveWorld()

void ScriptMgr::OnCreatureRemoveWorld ( Creature * creature )

{
    ASSERT(creature);
 
    ExecuteScript<AllCreatureScript>([&](AllCreatureScript* script)
    {
        script->OnCreatureRemoveWorld(creature);
    });
}

References ASSERT, and AllCreatureScript::OnCreatureRemoveWorld().

◆ OnCreatureSaveToDB()

void ScriptMgr::OnCreatureSaveToDB ( Creature * creature )

{
    ASSERT(creature);
 
    ExecuteScript<AllCreatureScript>([&](AllCreatureScript* script)
    {
        script->OnCreatureSaveToDB(creature);
    });
}

References ASSERT, and AllCreatureScript::OnCreatureSaveToDB().

◆ OnCreatureUpdate()

void ScriptMgr::OnCreatureUpdate	(	Creature *	creature,
		uint32	diff
	)

{
    ASSERT(creature);
 
    ExecuteScript<AllCreatureScript>([&](AllCreatureScript* script)
    {
        script->OnAllCreatureUpdate(creature, diff);
    });
 
    if (auto tempScript = ScriptRegistry<CreatureScript>::GetScriptById(creature->GetScriptId()))
    {
        tempScript->OnUpdate(creature, diff);
    }
}

References ASSERT, Creature::GetScriptId(), and AllCreatureScript::OnAllCreatureUpdate().

◆ OnCriteriaCheck()

bool ScriptMgr::OnCriteriaCheck	(	uint32	scriptId,
		Player *	source,
		Unit *	target,
		uint32	criteria_id
	)

{
    ASSERT(source);
    // target can be nullptr.
 
    auto tempScript = ScriptRegistry<AchievementCriteriaScript>::GetScriptById(scriptId);
    return tempScript ? tempScript->OnCheck(source, target, criteria_id) : false;
}

References ASSERT, and ScriptRegistry< TScript >::GetScriptById().

◆ OnCriteriaProgress()

void ScriptMgr::OnCriteriaProgress	(	Player *	player,
		AchievementCriteriaEntry const *	criteria
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnCriteriaProgress(player, criteria);
    });
}

References PlayerScript::OnCriteriaProgress().

◆ OnCriteriaSave()

void ScriptMgr::OnCriteriaSave	(	CharacterDatabaseTransaction	trans,
		Player *	player,
		uint16	critId,
		CriteriaProgress	criteriaData
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnCriteriaSave(trans, player, critId, criteriaData);
    });
}

References PlayerScript::OnCriteriaSave().

◆ OnCustomScalingStatValue()

void ScriptMgr::OnCustomScalingStatValue	(	Player *	player,
		ItemTemplate const *	proto,
		uint32 &	statType,
		int32 &	val,
		uint8	itemProtoStatNumber,
		uint32	ScalingStatValue,
		ScalingStatValuesEntry const *	ssv
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnCustomScalingStatValue(player, proto, statType, val, itemProtoStatNumber, ScalingStatValue, ssv);
    });
}

References PlayerScript::OnCustomScalingStatValue().

◆ OnCustomScalingStatValueBefore()

void ScriptMgr::OnCustomScalingStatValueBefore	(	Player *	player,
		ItemTemplate const *	proto,
		uint8	slot,
		bool	apply,
		uint32 &	CustomScalingStatValue
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnCustomScalingStatValueBefore(player, proto, slot, apply, CustomScalingStatValue);
    });
}

References PlayerScript::OnCustomScalingStatValueBefore().

◆ OnDamage()

void ScriptMgr::OnDamage	(	Unit *	attacker,
		Unit *	victim,
		uint32 &	damage
	)

{
    ExecuteScript<UnitScript>([&](UnitScript* script)
    {
        script->OnDamage(attacker, victim, damage);
    });
}

References UnitScript::OnDamage().

◆ OnDeleteFromDB()

void ScriptMgr::OnDeleteFromDB	(	CharacterDatabaseTransaction	trans,
		uint32	guid
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnDeleteFromDB(trans, guid);
    });
}

References PlayerScript::OnDeleteFromDB().

◆ OnDestroyInstance()

void ScriptMgr::OnDestroyInstance	(	MapInstanced *	mapInstanced,
		Map *	map
	)

{
    ExecuteScript<AllMapScript>([&](AllMapScript* script)
    {
        script->OnDestroyInstance(mapInstanced, map);
    });
}

References AllMapScript::OnDestroyInstance().

◆ OnDestroyMap()

void ScriptMgr::OnDestroyMap ( Map * map )

{
    ASSERT(map);
 
    ExecuteScript<AllMapScript>([&](AllMapScript* script)
    {
        script->OnDestroyMap(map);
    });
 
    ForeachMaps<WorldMapScript>(map,
    [&](WorldMapScript* script)
    {
        script->OnDestroy(map);
    });
 
    ForeachMaps<InstanceMapScript>(map,
    [&](InstanceMapScript* script)
    {
        script->OnDestroy((InstanceMap*)map);
    });
 
    ForeachMaps<BattlegroundMapScript>(map,
    [&](BattlegroundMapScript* script)
    {
        script->OnDestroy((BattlegroundMap*)map);
    });
}

References ASSERT, and AllMapScript::OnDestroyMap().

◆ OnDestructGroup()

void ScriptMgr::OnDestructGroup ( Group * origin )

{
    ExecuteScript<MiscScript>([&](MiscScript* script)
    {
        script->OnDestructGroup(origin);
    });
}

References MiscScript::OnDestructGroup().

◆ OnDestructInstanceSave()

void ScriptMgr::OnDestructInstanceSave ( InstanceSave * origin )

{
    ExecuteScript<MiscScript>([&](MiscScript* script)
    {
        script->OnDestructInstanceSave(origin);
    });
}

References MiscScript::OnDestructInstanceSave().

◆ OnDestructObject()

void ScriptMgr::OnDestructObject ( Object * origin )

{
    ExecuteScript<MiscScript>([&](MiscScript* script)
    {
        script->OnDestructObject(origin);
    });
}

References MiscScript::OnDestructObject().

◆ OnDestructPlayer()

void ScriptMgr::OnDestructPlayer ( Player * origin )

{
    ExecuteScript<MiscScript>([&](MiscScript* script)
    {
        script->OnDestructPlayer(origin);
    });
}

References MiscScript::OnDestructPlayer().

◆ OnDisplayIdChange()

void ScriptMgr::OnDisplayIdChange	(	Unit *	unit,
		uint32	displayId
	)

{
    ExecuteScript<UnitScript>([&](UnitScript* script)
    {
        script->OnDisplayIdChange(unit, displayId);
    });
}

References UnitScript::OnDisplayIdChange().

◆ OnDummyEffect() [1/3]

void ScriptMgr::OnDummyEffect	(	WorldObject *	caster,
		uint32	spellID,
		SpellEffIndex	effIndex,
		Creature *	creatureTarget
	)

{
    ExecuteScript<AllSpellScript>([&](AllSpellScript* script)
    {
        script->OnDummyEffect(caster, spellID, effIndex, creatureTarget);
    });
}

References AllSpellScript::OnDummyEffect().

◆ OnDummyEffect() [2/3]

void ScriptMgr::OnDummyEffect	(	WorldObject *	caster,
		uint32	spellID,
		SpellEffIndex	effIndex,
		GameObject *	gameObjTarget
	)

{
    ExecuteScript<AllSpellScript>([&](AllSpellScript* script)
    {
        script->OnDummyEffect(caster, spellID, effIndex, gameObjTarget);
    });
}

References AllSpellScript::OnDummyEffect().

◆ OnDummyEffect() [3/3]

void ScriptMgr::OnDummyEffect	(	WorldObject *	caster,
		uint32	spellID,
		SpellEffIndex	effIndex,
		Item *	itemTarget
	)

{
    ExecuteScript<AllSpellScript>([&](AllSpellScript* script)
    {
        script->OnDummyEffect(caster, spellID, effIndex, itemTarget);
    });
}

References AllSpellScript::OnDummyEffect().

◆ OnDynamicObjectUpdate()

void ScriptMgr::OnDynamicObjectUpdate	(	DynamicObject *	dynobj,
		uint32	diff
	)

{
    ASSERT(dynobj);
 
    for (auto const& [scriptID, script] : ScriptRegistry<DynamicObjectScript>::ScriptPointerList)
    {
        script->OnUpdate(dynobj, diff);
    }
}

References ASSERT.

◆ OnEmailChange()

void ScriptMgr::OnEmailChange ( uint32 accountId )

{
    ExecuteScript<AccountScript>([&](AccountScript* script)
    {
        script->OnEmailChange(accountId);
    });
}

References AccountScript::OnEmailChange().

◆ OnEquip()

void ScriptMgr::OnEquip	(	Player *	player,
		Item *	it,
		uint8	bag,
		uint8	slot,
		bool	update
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnEquip(player, it, bag, slot, update);
    });
}

References PlayerScript::OnEquip().

◆ OnFailedAccountLogin()

void ScriptMgr::OnFailedAccountLogin ( uint32 accountId )

{
    ExecuteScript<AccountScript>([&](AccountScript* script)
    {
        script->OnFailedAccountLogin(accountId);
    });
}

References AccountScript::OnFailedAccountLogin().

◆ OnFailedEmailChange()

void ScriptMgr::OnFailedEmailChange ( uint32 accountId )

{
    ExecuteScript<AccountScript>([&](AccountScript* script)
    {
        script->OnFailedEmailChange(accountId);
    });
}

References AccountScript::OnFailedEmailChange().

◆ OnFailedPasswordChange()

void ScriptMgr::OnFailedPasswordChange ( uint32 accountId )

{
    ExecuteScript<AccountScript>([&](AccountScript* script)
    {
        script->OnFailedPasswordChange(accountId);
    });
}

References AccountScript::OnFailedPasswordChange().

◆ OnFfaPvpStateUpdate() [1/2]

void ScriptMgr::OnFfaPvpStateUpdate	(	Creature *	creature,
		bool	InPvp
	)

{
    ExecuteScript<AllCreatureScript>([&](AllCreatureScript* script)
        {
            script->OnFfaPvpStateUpdate(creature, InPvp);
        });
}

References AllCreatureScript::OnFfaPvpStateUpdate().

◆ OnFfaPvpStateUpdate() [2/2]

void ScriptMgr::OnFfaPvpStateUpdate	(	Player *	player,
		bool	result
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
        {
            script->OnFfaPvpStateUpdate(player, result);
        });
}

References PlayerScript::OnFfaPvpStateUpdate().

◆ OnFirstLogin()

void ScriptMgr::OnFirstLogin ( Player * player )

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnFirstLogin(player);
    });
}

References PlayerScript::OnFirstLogin().

◆ OnGainCalculation()

void ScriptMgr::OnGainCalculation	(	uint32 &	gain,
		Player *	player,
		Unit *	unit
	)

{
    ASSERT(player);
    ASSERT(unit);
 
    ExecuteScript<FormulaScript>([&](FormulaScript* script)
    {
        script->OnGainCalculation(gain, player, unit);
    });
}

References ASSERT, and FormulaScript::OnGainCalculation().

◆ OnGameEventCheck()

void ScriptMgr::OnGameEventCheck ( uint16 EventID )

{
    ExecuteScript<GameEventScript>([&](GameEventScript* script)
    {
        script->OnEventCheck(EventID);
    });
}

References GameEventScript::OnEventCheck().

◆ OnGameEventStart()

void ScriptMgr::OnGameEventStart ( uint16 EventID )

{
    ExecuteScript<GameEventScript>([&](GameEventScript* script)
    {
        script->OnStart(EventID);
    });
}

References GameEventScript::OnStart().

◆ OnGameEventStop()

void ScriptMgr::OnGameEventStop ( uint16 EventID )

{
    ExecuteScript<GameEventScript>([&](GameEventScript* script)
    {
        script->OnStop(EventID);
    });
}

References GameEventScript::OnStop().

◆ OnGameObjectAddWorld()

void ScriptMgr::OnGameObjectAddWorld ( GameObject * go )

{
    ASSERT(go);
 
    ExecuteScript<AllGameObjectScript>([&](AllGameObjectScript* script)
    {
        script->OnGameObjectAddWorld(go);
    });
}

References ASSERT, and AllGameObjectScript::OnGameObjectAddWorld().

◆ OnGameObjectDamaged()

void ScriptMgr::OnGameObjectDamaged	(	GameObject *	go,
		Player *	player
	)

{
    ASSERT(go);
 
    ExecuteScript<AllGameObjectScript>([&](AllGameObjectScript* script)
    {
        script->OnGameObjectDamaged(go, player);
    });
 
    if (auto tempScript = ScriptRegistry<GameObjectScript>::GetScriptById(go->GetScriptId()))
    {
        tempScript->OnDamaged(go, player);
    }
}

References ASSERT, GameObject::GetScriptId(), and AllGameObjectScript::OnGameObjectDamaged().

◆ OnGameObjectDestroyed()

void ScriptMgr::OnGameObjectDestroyed	(	GameObject *	go,
		Player *	player
	)

{
    ASSERT(go);
 
    ExecuteScript<AllGameObjectScript>([&](AllGameObjectScript* script)
    {
        script->OnGameObjectDestroyed(go, player);
    });
 
    if (auto tempScript = ScriptRegistry<GameObjectScript>::GetScriptById(go->GetScriptId()))
    {
        tempScript->OnDestroyed(go, player);
    }
}

References ASSERT, GameObject::GetScriptId(), and AllGameObjectScript::OnGameObjectDestroyed().

◆ OnGameObjectLootStateChanged()

void ScriptMgr::OnGameObjectLootStateChanged	(	GameObject *	go,
		uint32	state,
		Unit *	unit
	)

{
    ASSERT(go);
 
    ExecuteScript<AllGameObjectScript>([&](AllGameObjectScript* script)
    {
        script->OnGameObjectLootStateChanged(go, state, unit);
    });
 
    if (auto tempScript = ScriptRegistry<GameObjectScript>::GetScriptById(go->GetScriptId()))
    {
        tempScript->OnLootStateChanged(go, state, unit);
    }
}

References ASSERT, GameObject::GetScriptId(), and AllGameObjectScript::OnGameObjectLootStateChanged().

◆ OnGameObjectModifyHealth()

void ScriptMgr::OnGameObjectModifyHealth	(	GameObject *	go,
		Unit *	attackerOrHealer,
		int32 &	change,
		SpellInfo const *	spellInfo
	)

{
    ASSERT(go);
 
    ExecuteScript<AllGameObjectScript>([&](AllGameObjectScript* script)
    {
        script->OnGameObjectModifyHealth(go, attackerOrHealer, change, spellInfo);
    });
 
    if (auto tempScript = ScriptRegistry<GameObjectScript>::GetScriptById(go->GetScriptId()))
    {
        tempScript->OnModifyHealth(go, attackerOrHealer, change, spellInfo);
    }
}

References ASSERT, GameObject::GetScriptId(), and AllGameObjectScript::OnGameObjectModifyHealth().

◆ OnGameObjectRemoveWorld()

void ScriptMgr::OnGameObjectRemoveWorld ( GameObject * go )

{
    ASSERT(go);
 
    ExecuteScript<AllGameObjectScript>([&](AllGameObjectScript* script)
    {
        script->OnGameObjectRemoveWorld(go);
    });
}

References ASSERT, and AllGameObjectScript::OnGameObjectRemoveWorld().

◆ OnGameObjectSaveToDB()

void ScriptMgr::OnGameObjectSaveToDB ( GameObject * go )

{
    ASSERT(go);
 
    ExecuteScript<AllGameObjectScript>([&](AllGameObjectScript* script)
    {
        script->OnGameObjectSaveToDB(go);
    });
}

References ASSERT, and AllGameObjectScript::OnGameObjectSaveToDB().

◆ OnGameObjectStateChanged()

void ScriptMgr::OnGameObjectStateChanged	(	GameObject *	go,
		uint32	state
	)

{
    ASSERT(go);
 
    ExecuteScript<AllGameObjectScript>([&](AllGameObjectScript* script)
    {
        script->OnGameObjectStateChanged(go, state);
    });
 
    if (auto tempScript = ScriptRegistry<GameObjectScript>::GetScriptById(go->GetScriptId()))
    {
        tempScript->OnGameObjectStateChanged(go, state);
    }
}

References ASSERT, GameObject::GetScriptId(), and AllGameObjectScript::OnGameObjectStateChanged().

◆ OnGameObjectUpdate()

void ScriptMgr::OnGameObjectUpdate	(	GameObject *	go,
		uint32	diff
	)

{
    ASSERT(go);
 
    ExecuteScript<AllGameObjectScript>([&](AllGameObjectScript* script)
    {
        script->OnGameObjectUpdate(go, diff);
    });
 
    if (auto tempScript = ScriptRegistry<GameObjectScript>::GetScriptById(go->GetScriptId()))
    {
        tempScript->OnUpdate(go, diff);
    }
}

References ASSERT, GameObject::GetScriptId(), and AllGameObjectScript::OnGameObjectUpdate().

◆ OnGetArenaPersonalRating()

void ScriptMgr::OnGetArenaPersonalRating	(	Player *	player,
		uint8	slot,
		uint32 &	result
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnGetArenaPersonalRating(player, slot, result);
    });
}

References PlayerScript::OnGetArenaPersonalRating().

◆ OnGetArenaPoints()

void ScriptMgr::OnGetArenaPoints	(	ArenaTeam *	at,
		float &	points
	)

{
    ExecuteScript<ArenaTeamScript>([&](ArenaTeamScript* script)
    {
        script->OnGetArenaPoints(at, points);
    });
}

References ArenaTeamScript::OnGetArenaPoints().

◆ OnGetArenaTeamId()

void ScriptMgr::OnGetArenaTeamId	(	Player *	player,
		uint8	slot,
		uint32 &	result
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnGetArenaTeamId(player, slot, result);
    });
}

References PlayerScript::OnGetArenaTeamId().

◆ OnGetFeralApBonus()

void ScriptMgr::OnGetFeralApBonus	(	Player *	player,
		int32 &	feral_bonus,
		int32	dpsMod,
		ItemTemplate const *	proto,
		ScalingStatValuesEntry const *	ssv
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnGetFeralApBonus(player, feral_bonus, dpsMod, proto, ssv);
    });
}

References PlayerScript::OnGetFeralApBonus().

◆ OnGetMaxPersonalArenaRatingRequirement()

void ScriptMgr::OnGetMaxPersonalArenaRatingRequirement	(	Player const *	player,
		uint32	minSlot,
		uint32 &	maxArenaRating
	)		const

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnGetMaxPersonalArenaRatingRequirement(player, minSlot, maxArenaRating);
    });
}

References PlayerScript::OnGetMaxPersonalArenaRatingRequirement().

◆ OnGetMaxSkillValue()

void ScriptMgr::OnGetMaxSkillValue	(	Player *	player,
		uint32	skill,
		int32 &	result,
		bool	IsPure
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnGetMaxSkillValue(player, skill, result, IsPure);
    });
}

References PlayerScript::OnGetMaxSkillValue().

◆ OnGetMaxSkillValueForLevel()

void ScriptMgr::OnGetMaxSkillValueForLevel	(	Player *	player,
		uint16 &	result
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnGetMaxSkillValueForLevel(player, result);
    });
}

References PlayerScript::OnGetMaxSkillValueForLevel().

◆ OnGetPoints()

void ScriptMgr::OnGetPoints	(	ArenaTeam *	team,
		uint32	memberRating,
		float &	points
	)

{
    ExecuteScript<ArenaScript>([&](ArenaScript* script)
    {
        script->OnGetPoints(team, memberRating, points);
    });
}

References ArenaScript::OnGetPoints().

◆ OnGetQuestRate()

void ScriptMgr::OnGetQuestRate	(	Player *	player,
		float &	result
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnGetQuestRate(player, result);
    });
}

References PlayerScript::OnGetQuestRate().

◆ OnGetSlotByType()

void ScriptMgr::OnGetSlotByType	(	const uint32	type,
		uint8 &	slot
	)

{
    ExecuteScript<ArenaTeamScript>([&](ArenaTeamScript* script)
    {
        script->OnGetSlotByType(type, slot);
    });
}

References ArenaTeamScript::OnGetSlotByType().

◆ OnGivePlayerXP()

void ScriptMgr::OnGivePlayerXP	(	Player *	player,
		uint32 &	amount,
		Unit *	victim,
		uint8	xpSource
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnGiveXP(player, amount, victim, xpSource);
    });
}

References PlayerScript::OnGiveXP().

◆ OnGlobalItemDelFromDB()

void ScriptMgr::OnGlobalItemDelFromDB	(	CharacterDatabaseTransaction	trans,
		ObjectGuid::LowType	itemGuid
	)

{
    ASSERT(trans);
    ASSERT(itemGuid);
 
    ExecuteScript<GlobalScript>([&](GlobalScript* script)
    {
        script->OnItemDelFromDB(trans, itemGuid);
    });
}

References ASSERT, and GlobalScript::OnItemDelFromDB().

◆ OnGlobalMirrorImageDisplayItem()

void ScriptMgr::OnGlobalMirrorImageDisplayItem	(	Item const *	item,
		uint32 &	display
	)

{
    ExecuteScript<GlobalScript>([&](GlobalScript* script)
    {
        script->OnMirrorImageDisplayItem(item, display);
    });
}

References GlobalScript::OnMirrorImageDisplayItem().

◆ OnGossipHello() [1/2]

bool ScriptMgr::OnGossipHello	(	Player *	player,
		Creature *	creature
	)

{
    ASSERT(player);
    ASSERT(creature);
 
    auto ret = IsValidBoolScript<AllCreatureScript>([&](AllCreatureScript* script)
    {
        return script->CanCreatureGossipHello(player, creature);
    });
 
    if (ret && *ret)
    {
        return true;
    }
 
    auto tempScript = ScriptRegistry<CreatureScript>::GetScriptById(creature->GetScriptId());
    ClearGossipMenuFor(player);
    return tempScript ? tempScript->OnGossipHello(player, creature) : false;
}

References ASSERT, AllCreatureScript::CanCreatureGossipHello(), ClearGossipMenuFor(), ScriptRegistry< TScript >::GetScriptById(), and Creature::GetScriptId().

◆ OnGossipHello() [2/2]

bool ScriptMgr::OnGossipHello	(	Player *	player,
		GameObject *	go
	)

{
    ASSERT(player);
    ASSERT(go);
 
    auto ret = IsValidBoolScript<AllGameObjectScript>([&](AllGameObjectScript* script)
    {
        return script->CanGameObjectGossipHello(player, go);
    });
 
    if (ret && *ret)
    {
        return true;
    }
 
    auto tempScript = ScriptRegistry<GameObjectScript>::GetScriptById(go->GetScriptId());
    ClearGossipMenuFor(player);
    return tempScript && tempScript->OnGossipHello(player, go);
}

References ASSERT, AllGameObjectScript::CanGameObjectGossipHello(), ClearGossipMenuFor(), ScriptRegistry< TScript >::GetScriptById(), and GameObject::GetScriptId().

◆ OnGossipSelect() [1/4]

bool ScriptMgr::OnGossipSelect	(	Player *	player,
		Creature *	creature,
		uint32	sender,
		uint32	action
	)

{
    ASSERT(player);
    ASSERT(creature);
 
    auto ret = IsValidBoolScript<AllCreatureScript>([&](AllCreatureScript* script)
    {
        return script->CanCreatureGossipSelect(player, creature, sender, action);
    });
 
    if (ret && *ret)
    {
        return true;
    }
 
    auto tempScript = ScriptRegistry<CreatureScript>::GetScriptById(creature->GetScriptId());
    return tempScript ? tempScript->OnGossipSelect(player, creature, sender, action) : false;
}

References ASSERT, AllCreatureScript::CanCreatureGossipSelect(), ScriptRegistry< TScript >::GetScriptById(), and Creature::GetScriptId().

◆ OnGossipSelect() [2/4]

bool ScriptMgr::OnGossipSelect	(	Player *	player,
		GameObject *	go,
		uint32	sender,
		uint32	action
	)

{
    ASSERT(player);
    ASSERT(go);
 
    auto ret = IsValidBoolScript<AllGameObjectScript>([&](AllGameObjectScript* script)
    {
        return script->CanGameObjectGossipSelect(player, go, sender, action);
    });
 
    if (ret && *ret)
    {
        return true;
    }
 
    auto tempScript = ScriptRegistry<GameObjectScript>::GetScriptById(go->GetScriptId());
    return tempScript ? tempScript->OnGossipSelect(player, go, sender, action) : false;
}

References ASSERT, AllGameObjectScript::CanGameObjectGossipSelect(), ScriptRegistry< TScript >::GetScriptById(), and GameObject::GetScriptId().

◆ OnGossipSelect() [3/4]

void ScriptMgr::OnGossipSelect	(	Player *	player,
		Item *	item,
		uint32	sender,
		uint32	action
	)

{
    ASSERT(player);
    ASSERT(item);
 
    ExecuteScript<AllItemScript>([&](AllItemScript* script)
    {
        script->OnItemGossipSelect(player, item, sender, action);
    });
 
    if (auto tempScript = ScriptRegistry<ItemScript>::GetScriptById(item->GetScriptId()))
    {
        tempScript->OnGossipSelect(player, item, sender, action);
    }
}

References ASSERT, Item::GetScriptId(), and AllItemScript::OnItemGossipSelect().

◆ OnGossipSelect() [4/4]

void ScriptMgr::OnGossipSelect	(	Player *	player,
		uint32	menu_id,
		uint32	sender,
		uint32	action
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnGossipSelect(player, menu_id, sender, action);
    });
}

References PlayerScript::OnGossipSelect().

◆ OnGossipSelectCode() [1/4]

bool ScriptMgr::OnGossipSelectCode	(	Player *	player,
		Creature *	creature,
		uint32	sender,
		uint32	action,
		const char *	code
	)

{
    ASSERT(player);
    ASSERT(creature);
    ASSERT(code);
 
    auto ret = IsValidBoolScript<AllCreatureScript>([&](AllCreatureScript* script)
    {
        return script->CanCreatureGossipSelectCode(player, creature, sender, action, code);
    });
 
    if (ret && *ret)
    {
        return true;
    }
 
    auto tempScript = ScriptRegistry<CreatureScript>::GetScriptById(creature->GetScriptId());
    return tempScript ? tempScript->OnGossipSelectCode(player, creature, sender, action, code) : false;
}

References ASSERT, AllCreatureScript::CanCreatureGossipSelectCode(), ScriptRegistry< TScript >::GetScriptById(), and Creature::GetScriptId().

◆ OnGossipSelectCode() [2/4]

bool ScriptMgr::OnGossipSelectCode	(	Player *	player,
		GameObject *	go,
		uint32	sender,
		uint32	action,
		const char *	code
	)

{
    ASSERT(player);
    ASSERT(go);
    ASSERT(code);
 
    auto ret = IsValidBoolScript<AllGameObjectScript>([&](AllGameObjectScript* script)
    {
        return script->CanGameObjectGossipSelectCode(player, go, sender, action, code);
    });
 
    if (ret && *ret)
    {
        return true;
    }
 
    auto tempScript = ScriptRegistry<GameObjectScript>::GetScriptById(go->GetScriptId());
    return tempScript ? tempScript->OnGossipSelectCode(player, go, sender, action, code) : false;
}

References ASSERT, AllGameObjectScript::CanGameObjectGossipSelectCode(), ScriptRegistry< TScript >::GetScriptById(), and GameObject::GetScriptId().

◆ OnGossipSelectCode() [3/4]

void ScriptMgr::OnGossipSelectCode	(	Player *	player,
		Item *	item,
		uint32	sender,
		uint32	action,
		const char *	code
	)

{
    ASSERT(player);
    ASSERT(item);
 
    ExecuteScript<AllItemScript>([&](AllItemScript* script)
    {
        script->OnItemGossipSelectCode(player, item, sender, action, code);
    });
 
    if (auto tempScript = ScriptRegistry<ItemScript>::GetScriptById(item->GetScriptId()))
    {
        tempScript->OnGossipSelectCode(player, item, sender, action, code);
    }
}

References ASSERT, Item::GetScriptId(), and AllItemScript::OnItemGossipSelectCode().

◆ OnGossipSelectCode() [4/4]

void ScriptMgr::OnGossipSelectCode	(	Player *	player,
		uint32	menu_id,
		uint32	sender,
		uint32	action,
		const char *	code
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnGossipSelectCode(player, menu_id, sender, action, code);
    });
}

References PlayerScript::OnGossipSelectCode().

◆ OnGrayLevelCalculation()

void ScriptMgr::OnGrayLevelCalculation	(	uint8 &	grayLevel,
		uint8	playerLevel
	)

{
    ExecuteScript<FormulaScript>([&](FormulaScript* script)
    {
        script->OnGrayLevelCalculation(grayLevel, playerLevel);
    });
}

References FormulaScript::OnGrayLevelCalculation().

◆ OnGroupAddMember()

void ScriptMgr::OnGroupAddMember	(	Group *	group,
		ObjectGuid	guid
	)

{
    ASSERT(group);
 
    ExecuteScript<GroupScript>([&](GroupScript* script)
    {
        script->OnAddMember(group, guid);
    });
}

References ASSERT, and GroupScript::OnAddMember().

◆ OnGroupChangeLeader()

void ScriptMgr::OnGroupChangeLeader	(	Group *	group,
		ObjectGuid	newLeaderGuid,
		ObjectGuid	oldLeaderGuid
	)

{
    ASSERT(group);
 
    ExecuteScript<GroupScript>([&](GroupScript* script)
    {
        script->OnChangeLeader(group, newLeaderGuid, oldLeaderGuid);
    });
}

References ASSERT, and GroupScript::OnChangeLeader().

◆ OnGroupDisband()

void ScriptMgr::OnGroupDisband ( Group * group )

{
    ASSERT(group);
 
    ExecuteScript<GroupScript>([&](GroupScript* script)
    {
        script->OnDisband(group);
    });
}

References ASSERT, and GroupScript::OnDisband().

◆ OnGroupInviteMember()

void ScriptMgr::OnGroupInviteMember	(	Group *	group,
		ObjectGuid	guid
	)

{
    ASSERT(group);
 
    ExecuteScript<GroupScript>([&](GroupScript* script)
    {
        script->OnInviteMember(group, guid);
    });
}

References ASSERT, and GroupScript::OnInviteMember().

◆ OnGroupRateCalculation()

void ScriptMgr::OnGroupRateCalculation	(	float &	rate,
		uint32	count,
		bool	isRaid
	)

{
    ExecuteScript<FormulaScript>([&](FormulaScript* script)
    {
        script->OnGroupRateCalculation(rate, count, isRaid);
    });
}

References FormulaScript::OnGroupRateCalculation().

◆ OnGroupRemoveMember()

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);
    });
}

References ASSERT, and GroupScript::OnRemoveMember().

◆ OnGroupRollRewardItem()

void ScriptMgr::OnGroupRollRewardItem	(	Player *	player,
		Item *	item,
		uint32	count,
		RollVote	voteType,
		Roll *	roll
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnGroupRollRewardItem(player, item, count, voteType, roll);
    });
}

References PlayerScript::OnGroupRollRewardItem().

◆ OnGuildAddMember()

void ScriptMgr::OnGuildAddMember	(	Guild *	guild,
		Player *	player,
		uint8 &	plRank
	)

{
    ExecuteScript<GuildScript>([&](GuildScript* script)
    {
        script->OnAddMember(guild, player, plRank);
    });
}

References GuildScript::OnAddMember().

◆ OnGuildBankEvent()

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);
    });
}

References GuildScript::OnBankEvent().

◆ OnGuildCreate()

void ScriptMgr::OnGuildCreate	(	Guild *	guild,
		Player *	leader,
		const std::string &	name
	)

{
    ExecuteScript<GuildScript>([&](GuildScript* script)
    {
        script->OnCreate(guild, leader, name);
    });
}

References GuildScript::OnCreate().

◆ OnGuildDisband()

void ScriptMgr::OnGuildDisband ( Guild * guild )

{
    ExecuteScript<GuildScript>([&](GuildScript* script)
    {
        script->OnDisband(guild);
    });
}

References GuildScript::OnDisband().

◆ OnGuildEvent()

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);
    });
}

References GuildScript::OnEvent().

◆ OnGuildInfoChanged()

void ScriptMgr::OnGuildInfoChanged	(	Guild *	guild,
		const std::string &	newInfo
	)

{
    ExecuteScript<GuildScript>([&](GuildScript* script)
    {
        script->OnInfoChanged(guild, newInfo);
    });
}

References GuildScript::OnInfoChanged().

◆ OnGuildItemMove()

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);
    });
}

References GuildScript::OnItemMove().

◆ OnGuildMemberDepositMoney()

void ScriptMgr::OnGuildMemberDepositMoney	(	Guild *	guild,
		Player *	player,
		uint32 &	amount
	)

{
    ExecuteScript<GuildScript>([&](GuildScript* script)
    {
        script->OnMemberDepositMoney(guild, player, amount);
    });
}

References GuildScript::OnMemberDepositMoney().

◆ OnGuildMemberWitdrawMoney()

void ScriptMgr::OnGuildMemberWitdrawMoney	(	Guild *	guild,
		Player *	player,
		uint32 &	amount,
		bool	isRepair
	)

{
    ExecuteScript<GuildScript>([&](GuildScript* script)
    {
        script->OnMemberWitdrawMoney(guild, player, amount, isRepair);
    });
}

References GuildScript::OnMemberWitdrawMoney().

◆ OnGuildMOTDChanged()

void ScriptMgr::OnGuildMOTDChanged	(	Guild *	guild,
		const std::string &	newMotd
	)

{
    ExecuteScript<GuildScript>([&](GuildScript* script)
    {
        script->OnMOTDChanged(guild, newMotd);
    });
}

References GuildScript::OnMOTDChanged().

◆ OnGuildRemoveMember()

void ScriptMgr::OnGuildRemoveMember	(	Guild *	guild,
		Player *	player,
		bool	isDisbanding,
		bool	isKicked
	)

{
    ExecuteScript<GuildScript>([&](GuildScript* script)
    {
        script->OnRemoveMember(guild, player, isDisbanding, isKicked);
    });
}

References GuildScript::OnRemoveMember().

◆ OnHandleDevCommand()

void ScriptMgr::OnHandleDevCommand	(	Player *	player,
		bool &	enable
	)

{
    ExecuteScript<AllCommandScript>([&](AllCommandScript* script)
    {
        script->OnHandleDevCommand(player, enable);
    });
}

References AllCommandScript::OnHandleDevCommand().

◆ OnHeal()

void ScriptMgr::OnHeal	(	Unit *	healer,
		Unit *	reciever,
		uint32 &	gain
	)

{
    ExecuteScript<UnitScript>([&](UnitScript* script)
    {
        script->OnHeal(healer, reciever, gain);
    });
}

References UnitScript::OnHeal().

◆ OnHonorCalculation()

void ScriptMgr::OnHonorCalculation	(	float &	honor,
		uint8	level,
		float	multiplier
	)

{
    ExecuteScript<FormulaScript>([&](FormulaScript* script)
    {
        script->OnHonorCalculation(honor, level, multiplier);
    });
}

References FormulaScript::OnHonorCalculation().

◆ OnInitializeLockedDungeons()

void ScriptMgr::OnInitializeLockedDungeons	(	Player *	player,
		uint8 &	level,
		uint32 &	lockData,
		lfg::LFGDungeonData const *	dungeon
	)

{
    ExecuteScript<GlobalScript>([&](GlobalScript* script)
    {
        script->OnInitializeLockedDungeons(player, level, lockData, dungeon);
    });
}

References GlobalScript::OnInitializeLockedDungeons().

◆ OnInitStatsForLevel()

void ScriptMgr::OnInitStatsForLevel	(	Guardian *	guardian,
		uint8	petlevel
	)

{
    ExecuteScript<PetScript>([&](PetScript* script)
    {
        script->OnInitStatsForLevel(guardian, petlevel);
    });
}

References PetScript::OnInitStatsForLevel().

◆ OnInstall()

void ScriptMgr::OnInstall ( Vehicle * veh )

{
    ASSERT(veh);
    ASSERT(veh->GetBase()->GetTypeId() == TYPEID_UNIT);
 
    if (auto tempScript = ScriptRegistry<VehicleScript>::GetScriptById(veh->GetBase()->ToCreature()->GetScriptId()))
    {
        tempScript->OnInstall(veh);
    }
}

References ASSERT, Vehicle::GetBase(), Creature::GetScriptId(), Object::GetTypeId(), Object::ToCreature(), and TYPEID_UNIT.

◆ OnInstallAccessory()

void ScriptMgr::OnInstallAccessory	(	Vehicle *	veh,
		Creature *	accessory
	)

{
    ASSERT(veh);
    ASSERT(veh->GetBase()->GetTypeId() == TYPEID_UNIT);
    ASSERT(accessory);
 
    if (auto tempScript = ScriptRegistry<VehicleScript>::GetScriptById(veh->GetBase()->ToCreature()->GetScriptId()))
    {
        tempScript->OnInstallAccessory(veh, accessory);
    }
}

References ASSERT, Vehicle::GetBase(), Creature::GetScriptId(), Object::GetTypeId(), Object::ToCreature(), and TYPEID_UNIT.

◆ OnInstanceIdRemoved()

void ScriptMgr::OnInstanceIdRemoved ( uint32 instanceId )

Called when an instance Id is deleted, usually because it expired or no players are bound to it anymore.

Parameters

instanceId The unique id of the instance

{
    ExecuteScript<GlobalScript>([&](GlobalScript* script)
    {
        script->OnInstanceIdRemoved(instanceId);
    });
}

References GlobalScript::OnInstanceIdRemoved().

◆ OnInstanceSave()

void ScriptMgr::OnInstanceSave ( InstanceSave * instanceSave )

{
    ExecuteScript<MiscScript>([&](MiscScript* script)
    {
        script->OnInstanceSave(instanceSave);
    });
}

References MiscScript::OnInstanceSave().

◆ OnIsAffectedBySpellModCheck()

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;
}

References GlobalScript::OnIsAffectedBySpellModCheck().

◆ OnIsFFAPvP()

void ScriptMgr::OnIsFFAPvP	(	Player *	player,
		bool &	result
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnIsFFAPvP(player, result);
    });
}

References PlayerScript::OnIsFFAPvP().

◆ OnIsPvP()

void ScriptMgr::OnIsPvP	(	Player *	player,
		bool &	result
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnIsPvP(player, result);
    });
}

References PlayerScript::OnIsPvP().

◆ OnItemCreate()

void ScriptMgr::OnItemCreate	(	Item *	item,
		ItemTemplate const *	itemProto,
		Player const *	owner
	)

{
    ExecuteScript<MiscScript>([&](MiscScript* script)
    {
        script->OnItemCreate(item, itemProto, owner);
    });
}

References MiscScript::OnItemCreate().

◆ OnItemExpire()

bool ScriptMgr::OnItemExpire	(	Player *	player,
		ItemTemplate const *	proto
	)

{
    ASSERT(player);
    ASSERT(proto);
 
    auto ret = IsValidBoolScript<AllItemScript>([&](AllItemScript* script)
    {
        return !script->CanItemExpire(player, proto);
    });
 
    if (ret && *ret)
    {
        return false;
    }
 
    auto tempScript = ScriptRegistry<ItemScript>::GetScriptById(proto->ScriptId);
    return tempScript ? tempScript->OnExpire(player, proto) : false;
}

References ASSERT, AllItemScript::CanItemExpire(), ScriptRegistry< TScript >::GetScriptById(), and ItemTemplate::ScriptId.

◆ OnItemRemove()

bool ScriptMgr::OnItemRemove	(	Player *	player,
		Item *	item
	)

{
    ASSERT(player);
    ASSERT(item);
 
    auto ret = IsValidBoolScript<AllItemScript>([&](AllItemScript* script)
    {
        return !script->CanItemRemove(player, item);
    });
 
    if (ret && *ret)
    {
        return false;
    }
 
    auto tempScript = ScriptRegistry<ItemScript>::GetScriptById(item->GetScriptId());
    return tempScript ? tempScript->OnRemove(player, item) : false;
}

References ASSERT, AllItemScript::CanItemRemove(), ScriptRegistry< TScript >::GetScriptById(), and Item::GetScriptId().

◆ OnItemRoll()

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;
}

References GlobalScript::OnItemRoll().

◆ OnItemUse()

bool ScriptMgr::OnItemUse	(	Player *	player,
		Item *	item,
		SpellCastTargets const &	targets
	)

{
    ASSERT(player);
    ASSERT(item);
 
    auto ret = IsValidBoolScript<AllItemScript>([&](AllItemScript* script)
    {
        return script->CanItemUse(player, item, targets);
    });
 
    if (ret && *ret)
    {
        return true;
    }
 
    auto tempScript = ScriptRegistry<ItemScript>::GetScriptById(item->GetScriptId());
    return tempScript ? tempScript->OnUse(player, item, targets) : false;
}

References ASSERT, AllItemScript::CanItemUse(), ScriptRegistry< TScript >::GetScriptById(), and Item::GetScriptId().

◆ OnLastIpUpdate()

void ScriptMgr::OnLastIpUpdate	(	uint32	accountId,
		std::string	ip
	)

{
    ExecuteScript<AccountScript>([&](AccountScript* script)
    {
        script->OnLastIpUpdate(accountId, ip);
    });
}

References AccountScript::OnLastIpUpdate().

◆ OnLoadCustomDatabaseTable()

void ScriptMgr::OnLoadCustomDatabaseTable ( )

{
    ExecuteScript<WorldScript>([&](WorldScript* script)
    {
        script->OnLoadCustomDatabaseTable();
    });
}

References WorldScript::OnLoadCustomDatabaseTable().

◆ OnLoadGridMap()

void ScriptMgr::OnLoadGridMap	(	Map *	map,
		GridMap *	gmap,
		uint32	gx,
		uint32	gy
	)

{
    ASSERT(map);
    ASSERT(gmap);
 
    ForeachMaps<WorldMapScript>(map,
    [&](WorldMapScript* script)
    {
        script->OnLoadGridMap(map, gmap, gx, gy);
    });
 
    ForeachMaps<InstanceMapScript>(map,
    [&](InstanceMapScript* script)
    {
        script->OnLoadGridMap((InstanceMap*)map, gmap, gx, gy);
    });
 
    ForeachMaps<BattlegroundMapScript>(map,
    [&](BattlegroundMapScript* script)
    {
        script->OnLoadGridMap((BattlegroundMap*)map, gmap, gx, gy);
    });
}

References ASSERT, and MapScript< TMap >::OnLoadGridMap().

◆ OnLoadSpellCustomAttr()

void ScriptMgr::OnLoadSpellCustomAttr ( SpellInfo * spell )

{
    ExecuteScript<GlobalScript>([&](GlobalScript* script)
    {
        script->OnLoadSpellCustomAttr(spell);
    });
}

References GlobalScript::OnLoadSpellCustomAttr().

◆ OnLootItem()

void ScriptMgr::OnLootItem	(	Player *	player,
		Item *	item,
		uint32	count,
		ObjectGuid	lootguid
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnLootItem(player, item, count, lootguid);
    });
}

References PlayerScript::OnLootItem().

◆ OnLootMoney()

void ScriptMgr::OnLootMoney	(	Player *	player,
		uint32	gold
	)

{
    ASSERT(player);
 
    ExecuteScript<LootScript>([&](LootScript* script)
    {
        script->OnLootMoney(player, gold);
    });
}

References ASSERT, and LootScript::OnLootMoney().

◆ OnMapUpdate()

void ScriptMgr::OnMapUpdate	(	Map *	map,
		uint32	diff
	)

{
    ASSERT(map);
 
    ExecuteScript<AllMapScript>([&](AllMapScript* script)
    {
        script->OnMapUpdate(map, diff);
    });
 
    ForeachMaps<WorldMapScript>(map,
    [&](WorldMapScript* script)
    {
        script->OnUpdate(map, diff);
    });
 
    ForeachMaps<InstanceMapScript>(map,
    [&](InstanceMapScript* script)
    {
        script->OnUpdate((InstanceMap*)map, diff);
    });
 
    ForeachMaps<BattlegroundMapScript>(map,
    [&](BattlegroundMapScript* script)
    {
        script->OnUpdate((BattlegroundMap*)map, diff);
    });
}

References ASSERT, and AllMapScript::OnMapUpdate().

◆ OnMotdChange()

void ScriptMgr::OnMotdChange ( std::string & newMotd )

{
    ExecuteScript<WorldScript>([&](WorldScript* script)
    {
        script->OnMotdChange(newMotd);
    });
}

References WorldScript::OnMotdChange().

◆ OnNetworkStart()

void ScriptMgr::OnNetworkStart ( )

{
    ExecuteScript<ServerScript>([&](ServerScript* script)
    {
        script->OnNetworkStart();
    });
}

References ServerScript::OnNetworkStart().

◆ OnNetworkStop()

void ScriptMgr::OnNetworkStop ( )

{
    ExecuteScript<ServerScript>([&](ServerScript* script)
    {
        script->OnNetworkStop();
    });
}

References ServerScript::OnNetworkStop().

◆ OnOpenStateChange()

void ScriptMgr::OnOpenStateChange ( bool open )

{
    ExecuteScript<WorldScript>([&](WorldScript* script)
    {
        script->OnOpenStateChange(open);
    });
}

References WorldScript::OnOpenStateChange().

◆ OnPasswordChange()

void ScriptMgr::OnPasswordChange ( uint32 accountId )

{
    ExecuteScript<AccountScript>([&](AccountScript* script)
    {
        script->OnPasswordChange(accountId);
    });
}

References AccountScript::OnPasswordChange().

◆ OnPetAddToWorld()

void ScriptMgr::OnPetAddToWorld ( Pet * pet )

{
    ASSERT(pet);
 
    ExecuteScript<PetScript>([&](PetScript* script)
    {
        script->OnPetAddToWorld(pet);
    });
}

References ASSERT, and PetScript::OnPetAddToWorld().

◆ OnPlayerAddToBattleground()

void ScriptMgr::OnPlayerAddToBattleground	(	Player *	player,
		Battleground *	bg
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnAddToBattleground(player, bg);
    });
}

References PlayerScript::OnAddToBattleground().

◆ OnPlayerBeingCharmed()

void ScriptMgr::OnPlayerBeingCharmed	(	Player *	player,
		Unit *	charmer,
		uint32	oldFactionId,
		uint32	newFactionId
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnBeingCharmed(player, charmer, oldFactionId, newFactionId);
    });
}

References PlayerScript::OnBeingCharmed().

◆ OnPlayerBindToInstance()

void ScriptMgr::OnPlayerBindToInstance	(	Player *	player,
		Difficulty	difficulty,
		uint32	mapid,
		bool	permanent
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnBindToInstance(player, difficulty, mapid, permanent);
    });
}

References PlayerScript::OnBindToInstance().

◆ OnPlayerChat() [1/5]

void ScriptMgr::OnPlayerChat	(	Player *	player,
		uint32	type,
		uint32	lang,
		std::string &	msg
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnChat(player, type, lang, msg);
    });
}

References PlayerScript::OnChat().

◆ OnPlayerChat() [2/5]

void ScriptMgr::OnPlayerChat	(	Player *	player,
		uint32	type,
		uint32	lang,
		std::string &	msg,
		Channel *	channel
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnChat(player, type, lang, msg, channel);
    });
}

References PlayerScript::OnChat().

◆ OnPlayerChat() [3/5]

void ScriptMgr::OnPlayerChat	(	Player *	player,
		uint32	type,
		uint32	lang,
		std::string &	msg,
		Group *	group
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnChat(player, type, lang, msg, group);
    });
}

References PlayerScript::OnChat().

◆ OnPlayerChat() [4/5]

void ScriptMgr::OnPlayerChat	(	Player *	player,
		uint32	type,
		uint32	lang,
		std::string &	msg,
		Guild *	guild
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnChat(player, type, lang, msg, guild);
    });
}

References PlayerScript::OnChat().

◆ OnPlayerChat() [5/5]

void ScriptMgr::OnPlayerChat	(	Player *	player,
		uint32	type,
		uint32	lang,
		std::string &	msg,
		Player *	receiver
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnChat(player, type, lang, msg, receiver);
    });
}

References PlayerScript::OnChat().

◆ OnPlayerCompleteQuest()

void ScriptMgr::OnPlayerCompleteQuest	(	Player *	player,
		Quest const *	quest
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnPlayerCompleteQuest(player, quest);
    });
}

References PlayerScript::OnPlayerCompleteQuest().

◆ OnPlayerCreate()

void ScriptMgr::OnPlayerCreate ( Player * player )

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnCreate(player);
    });
}

References PlayerScript::OnCreate().

◆ OnPlayerDelete()

void ScriptMgr::OnPlayerDelete	(	ObjectGuid	guid,
		uint32	accountId
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnDelete(guid, accountId);
    });
}

References PlayerScript::OnDelete().

◆ OnPlayerDuelEnd()

void ScriptMgr::OnPlayerDuelEnd	(	Player *	winner,
		Player *	loser,
		DuelCompleteType	type
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnDuelEnd(winner, loser, type);
    });
}

References PlayerScript::OnDuelEnd().

◆ OnPlayerDuelRequest()

void ScriptMgr::OnPlayerDuelRequest	(	Player *	target,
		Player *	challenger
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnDuelRequest(target, challenger);
    });
}

References PlayerScript::OnDuelRequest().

◆ OnPlayerDuelStart()

void ScriptMgr::OnPlayerDuelStart	(	Player *	player1,
		Player *	player2
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnDuelStart(player1, player2);
    });
}

References PlayerScript::OnDuelStart().

◆ OnPlayerEmote()

void ScriptMgr::OnPlayerEmote	(	Player *	player,
		uint32	emote
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnEmote(player, emote);
    });
}

References PlayerScript::OnEmote().

◆ OnPlayerEnterCombat()

void ScriptMgr::OnPlayerEnterCombat	(	Player *	player,
		Unit *	enemy
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnPlayerEnterCombat(player, enemy);
    });
}

References PlayerScript::OnPlayerEnterCombat().

◆ OnPlayerEnterMap()

void ScriptMgr::OnPlayerEnterMap	(	Map *	map,
		Player *	player
	)

{
    ASSERT(map);
    ASSERT(player);
 
    ExecuteScript<AllMapScript>([&](AllMapScript* script)
    {
        script->OnPlayerEnterAll(map, player);
    });
 
    ExecuteScript<PlayerScript>([=](PlayerScript* script)
    {
        script->OnMapChanged(player);
    });
 
    ForeachMaps<WorldMapScript>(map,
    [&](WorldMapScript* script)
    {
        script->OnPlayerEnter(map, player);
    });
 
    ForeachMaps<InstanceMapScript>(map,
    [&](InstanceMapScript* script)
    {
        script->OnPlayerEnter((InstanceMap*)map, player);
    });
 
    ForeachMaps<BattlegroundMapScript>(map,
    [&](BattlegroundMapScript* script)
    {
        script->OnPlayerEnter((BattlegroundMap*)map, player);
    });
}

References ASSERT, and AllMapScript::OnPlayerEnterAll().

◆ OnPlayerFailedDelete()

void ScriptMgr::OnPlayerFailedDelete	(	ObjectGuid	guid,
		uint32	accountId
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnFailedDelete(guid, accountId);
    });
}

References PlayerScript::OnFailedDelete().

◆ OnPlayerForgotSpell()

void ScriptMgr::OnPlayerForgotSpell	(	Player *	player,
		uint32	spellID
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnForgotSpell(player, spellID);
    });
}

References PlayerScript::OnForgotSpell().

◆ OnPlayerFreeTalentPointsChanged()

void ScriptMgr::OnPlayerFreeTalentPointsChanged	(	Player *	player,
		uint32	newPoints
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnFreeTalentPointsChanged(player, points);
    });
}

References PlayerScript::OnFreeTalentPointsChanged().

◆ OnPlayerJoinArena()

void ScriptMgr::OnPlayerJoinArena ( Player * player )

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnPlayerJoinArena(player);
    });
}

References PlayerScript::OnPlayerJoinArena().

◆ OnPlayerJoinBG()

void ScriptMgr::OnPlayerJoinBG ( Player * player )

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnPlayerJoinBG(player);
    });
}

References PlayerScript::OnPlayerJoinBG().

◆ OnPlayerKilledByCreature()

void ScriptMgr::OnPlayerKilledByCreature	(	Creature *	killer,
		Player *	killed
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnPlayerKilledByCreature(killer, killed);
    });
}

References PlayerScript::OnPlayerKilledByCreature().

◆ OnPlayerLearnSpell()

void ScriptMgr::OnPlayerLearnSpell	(	Player *	player,
		uint32	spellID
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnLearnSpell(player, spellID);
    });
}

References PlayerScript::OnLearnSpell().

◆ OnPlayerLearnTalents()

void ScriptMgr::OnPlayerLearnTalents	(	Player *	player,
		uint32	talentId,
		uint32	talentRank,
		uint32	spellid
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnPlayerLearnTalents(player, talentId, talentRank, spellid);
    });
}

References PlayerScript::OnPlayerLearnTalents().

◆ OnPlayerLeaveCombat()

void ScriptMgr::OnPlayerLeaveCombat ( Player * player )

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnPlayerLeaveCombat(player);
    });
}

References PlayerScript::OnPlayerLeaveCombat().

◆ OnPlayerLeaveMap()

void ScriptMgr::OnPlayerLeaveMap	(	Map *	map,
		Player *	player
	)

{
    ASSERT(map);
    ASSERT(player);
 
    ExecuteScript<AllMapScript>([&](AllMapScript* script)
    {
        script->OnPlayerLeaveAll(map, player);
    });
 
    ForeachMaps<WorldMapScript>(map,
    [&](WorldMapScript* script)
    {
        script->OnPlayerLeave(map, player);
    });
 
    ForeachMaps<InstanceMapScript>(map,
    [&](InstanceMapScript* script)
    {
        script->OnPlayerLeave((InstanceMap*)map, player);
    });
 
    ForeachMaps<BattlegroundMapScript>(map,
    [&](BattlegroundMapScript* script)
    {
        script->OnPlayerLeave((BattlegroundMap*)map, player);
    });
}

References ASSERT, and AllMapScript::OnPlayerLeaveAll().

◆ OnPlayerLevelChanged()

void ScriptMgr::OnPlayerLevelChanged	(	Player *	player,
		uint8	oldLevel
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnLevelChanged(player, oldLevel);
    });
}

References PlayerScript::OnLevelChanged().

◆ OnPlayerLoadFromDB()

void ScriptMgr::OnPlayerLoadFromDB ( Player * player )

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnLoadFromDB(player);
    });
}

References PlayerScript::OnLoadFromDB().

◆ OnPlayerLogin()

void ScriptMgr::OnPlayerLogin ( Player * player )

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnLogin(player);
    });
}

References PlayerScript::OnLogin().

◆ OnPlayerLogout()

void ScriptMgr::OnPlayerLogout ( Player * player )

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnLogout(player);
    });
}

References PlayerScript::OnLogout().

◆ OnPlayerMoneyChanged()

void ScriptMgr::OnPlayerMoneyChanged	(	Player *	player,
		int32 &	amount
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnMoneyChanged(player, amount);
    });
}

References PlayerScript::OnMoneyChanged().

◆ OnPlayerMove()

void ScriptMgr::OnPlayerMove	(	Player *	player,
		MovementInfo	movementInfo,
		uint32	opcode
	)

{
    ExecuteScript<MovementHandlerScript>([&](MovementHandlerScript* script)
    {
        script->OnPlayerMove(player, movementInfo, opcode);
    });
}

References MovementHandlerScript::OnPlayerMove().

◆ OnPlayerPVPFlagChange()

void ScriptMgr::OnPlayerPVPFlagChange	(	Player *	player,
		bool	state
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnPlayerPVPFlagChange(player, state);
    });
}

References PlayerScript::OnPlayerPVPFlagChange().

◆ OnPlayerQueueRandomDungeon()

void ScriptMgr::OnPlayerQueueRandomDungeon	(	Player *	player,
		uint32 &	rDungeonId
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnQueueRandomDungeon(player, rDungeonId);
    });
}

References PlayerScript::OnQueueRandomDungeon().

◆ OnPlayerReleasedGhost()

void ScriptMgr::OnPlayerReleasedGhost ( Player * player )

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnPlayerReleasedGhost(player);
    });
}

References PlayerScript::OnPlayerReleasedGhost().

◆ OnPlayerRemoveFromBattleground()

void ScriptMgr::OnPlayerRemoveFromBattleground	(	Player *	player,
		Battleground *	bg
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnRemoveFromBattleground(player, bg);
    });
}

References PlayerScript::OnRemoveFromBattleground().

◆ OnPlayerReputationChange()

bool ScriptMgr::OnPlayerReputationChange	(	Player *	player,
		uint32	factionID,
		int32 &	standing,
		bool	incremental
	)

{
    auto ret = IsValidBoolScript<PlayerScript>([&](PlayerScript* script)
        {
            return !script->OnReputationChange(player, factionID, standing, incremental);
        });
 
    if (ret && *ret)
    {
        return false;
    }
 
    return true;
}

References PlayerScript::OnReputationChange().

◆ OnPlayerReputationRankChange()

void ScriptMgr::OnPlayerReputationRankChange	(	Player *	player,
		uint32	factionID,
		ReputationRank	newRank,
		ReputationRank	oldRank,
		bool	increased
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnReputationRankChange(player, factionID, newRank, oldRank, increased);
    });
}

References PlayerScript::OnReputationRankChange().

◆ OnPlayerResurrect()

void ScriptMgr::OnPlayerResurrect	(	Player *	player,
		float	restore_percent,
		bool	applySickness
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnPlayerResurrect(player, restore_percent, applySickness);
    });
}

References PlayerScript::OnPlayerResurrect().

◆ OnPlayerSave()

void ScriptMgr::OnPlayerSave ( Player * player )

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnSave(player);
    });
}

References PlayerScript::OnSave().

◆ OnPlayerSetPhase()

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);
    });
}

References MiscScript::OnPlayerSetPhase().

◆ OnPlayerSpellCast()

void ScriptMgr::OnPlayerSpellCast	(	Player *	player,
		Spell *	spell,
		bool	skipCheck
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnSpellCast(player, spell, skipCheck);
    });
}

References PlayerScript::OnSpellCast().

◆ OnPlayerTalentsReset()

void ScriptMgr::OnPlayerTalentsReset	(	Player *	player,
		bool	noCost
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnTalentsReset(player, noCost);
    });
}

References PlayerScript::OnTalentsReset().

◆ OnPlayerTextEmote()

void ScriptMgr::OnPlayerTextEmote	(	Player *	player,
		uint32	textEmote,
		uint32	emoteNum,
		ObjectGuid	guid
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnTextEmote(player, textEmote, emoteNum, guid);
    });
}

References PlayerScript::OnTextEmote().

◆ OnPlayerUpdate()

void ScriptMgr::OnPlayerUpdate	(	Player *	player,
		uint32	p_time
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnUpdate(player, p_time);
    });
}

References PlayerScript::OnUpdate().

◆ OnPlayerUpdateArea()

void ScriptMgr::OnPlayerUpdateArea	(	Player *	player,
		uint32	oldArea,
		uint32	newArea
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnUpdateArea(player, oldArea, newArea);
    });
}

References PlayerScript::OnUpdateArea().

◆ OnPlayerUpdateFaction()

void ScriptMgr::OnPlayerUpdateFaction ( Player * player )

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnUpdateFaction(player);
    });
}

References PlayerScript::OnUpdateFaction().

◆ OnPlayerUpdateZone()

void ScriptMgr::OnPlayerUpdateZone	(	Player *	player,
		uint32	newZone,
		uint32	newArea
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnUpdateZone(player, newZone, newArea);
    });
}

References PlayerScript::OnUpdateZone().

◆ OnPVPKill()

void ScriptMgr::OnPVPKill	(	Player *	killer,
		Player *	killed
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnPVPKill(killer, killed);
    });
}

References PlayerScript::OnPVPKill().

◆ OnQuestAbandon()

void ScriptMgr::OnQuestAbandon	(	Player *	player,
		uint32	questId
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnQuestAbandon(player, questId);
    });
}

References PlayerScript::OnQuestAbandon().

◆ OnQuestAccept() [1/3]

bool ScriptMgr::OnQuestAccept	(	Player *	player,
		Creature *	creature,
		Quest const *	quest
	)

{
    ASSERT(player);
    ASSERT(creature);
    ASSERT(quest);
 
    auto ret = IsValidBoolScript<AllCreatureScript>([&](AllCreatureScript* script)
    {
        return script->CanCreatureQuestAccept(player, creature, quest);
    });
 
    if (ret && *ret)
    {
        return true;
    }
 
    auto tempScript = ScriptRegistry<CreatureScript>::GetScriptById(creature->GetScriptId());
    ClearGossipMenuFor(player);
    return tempScript ? tempScript->OnQuestAccept(player, creature, quest) : false;
}

References ASSERT, AllCreatureScript::CanCreatureQuestAccept(), ClearGossipMenuFor(), ScriptRegistry< TScript >::GetScriptById(), and Creature::GetScriptId().

◆ OnQuestAccept() [2/3]

bool ScriptMgr::OnQuestAccept	(	Player *	player,
		GameObject *	go,
		Quest const *	quest
	)

{
    ASSERT(player);
    ASSERT(go);
    ASSERT(quest);
 
    auto ret = IsValidBoolScript<AllGameObjectScript>([&](AllGameObjectScript* script)
    {
        return script->CanGameObjectQuestAccept(player, go, quest);
    });
 
    if (ret && *ret)
    {
        return true;
    }
 
    auto tempScript = ScriptRegistry<GameObjectScript>::GetScriptById(go->GetScriptId());
    ClearGossipMenuFor(player);
    return tempScript ? tempScript->OnQuestAccept(player, go, quest) : false;
}

References ASSERT, AllGameObjectScript::CanGameObjectQuestAccept(), ClearGossipMenuFor(), ScriptRegistry< TScript >::GetScriptById(), and GameObject::GetScriptId().

◆ OnQuestAccept() [3/3]

bool ScriptMgr::OnQuestAccept	(	Player *	player,
		Item *	item,
		Quest const *	quest
	)

{
    ASSERT(player);
    ASSERT(item);
    ASSERT(quest);
 
    auto ret = IsValidBoolScript<AllItemScript>([&](AllItemScript* script)
    {
        return !script->CanItemQuestAccept(player, item, quest);
    });
 
    if (ret && *ret)
    {
        return false;
    }
 
    auto tempScript = ScriptRegistry<ItemScript>::GetScriptById(item->GetScriptId());
    ClearGossipMenuFor(player);
    return tempScript ? tempScript->OnQuestAccept(player, item, quest) : false;
}

References ASSERT, AllItemScript::CanItemQuestAccept(), ClearGossipMenuFor(), ScriptRegistry< TScript >::GetScriptById(), and Item::GetScriptId().

◆ OnQuestComplete()

bool ScriptMgr::OnQuestComplete	(	Player *	player,
		Creature *	creature,
		Quest const *	quest
	)

{
    ASSERT(player);
    ASSERT(creature);
    ASSERT(quest);
 
    auto tempScript = ScriptRegistry<CreatureScript>::GetScriptById(creature->GetScriptId());
    ClearGossipMenuFor(player);
    return tempScript ? tempScript->OnQuestComplete(player, creature, quest) : false;
}

References ASSERT, ClearGossipMenuFor(), ScriptRegistry< TScript >::GetScriptById(), and Creature::GetScriptId().

◆ OnQuestComputeXP()

void ScriptMgr::OnQuestComputeXP	(	Player *	player,
		Quest const *	quest,
		uint32 &	xpValue
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnQuestComputeXP(player, quest, xpValue);
    });
}

References PlayerScript::OnQuestComputeXP().

◆ OnQuestReward() [1/2]

bool ScriptMgr::OnQuestReward	(	Player *	player,
		Creature *	creature,
		Quest const *	quest,
		uint32	opt
	)

{
    ASSERT(player);
    ASSERT(creature);
    ASSERT(quest);
 
    auto ret = IsValidBoolScript<AllCreatureScript>([&](AllCreatureScript* script)
    {
        return script->CanCreatureQuestReward(player, creature, quest, opt);
    });
 
    if (ret && *ret)
    {
        return false;
    }
 
    auto tempScript = ScriptRegistry<CreatureScript>::GetScriptById(creature->GetScriptId());
    ClearGossipMenuFor(player);
    return tempScript ? tempScript->OnQuestReward(player, creature, quest, opt) : false;
}

References ASSERT, AllCreatureScript::CanCreatureQuestReward(), ClearGossipMenuFor(), ScriptRegistry< TScript >::GetScriptById(), and Creature::GetScriptId().

◆ OnQuestReward() [2/2]

bool ScriptMgr::OnQuestReward	(	Player *	player,
		GameObject *	go,
		Quest const *	quest,
		uint32	opt
	)

{
    ASSERT(player);
    ASSERT(go);
    ASSERT(quest);
 
    auto ret = IsValidBoolScript<AllGameObjectScript>([&](AllGameObjectScript* script)
    {
        return script->CanGameObjectQuestReward(player, go, quest, opt);
    });
 
    if (ret && *ret)
    {
        return false;
    }
 
    auto tempScript = ScriptRegistry<GameObjectScript>::GetScriptById(go->GetScriptId());
    ClearGossipMenuFor(player);
    return tempScript ? tempScript->OnQuestReward(player, go, quest, opt) : false;
}

References ASSERT, AllGameObjectScript::CanGameObjectQuestReward(), ClearGossipMenuFor(), ScriptRegistry< TScript >::GetScriptById(), and GameObject::GetScriptId().

◆ OnQuestRewardItem()

void ScriptMgr::OnQuestRewardItem	(	Player *	player,
		Item *	item,
		uint32	count
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnQuestRewardItem(player, item, count);
    });
}

References PlayerScript::OnQuestRewardItem().

◆ OnQuestSelect()

bool ScriptMgr::OnQuestSelect	(	Player *	player,
		Creature *	creature,
		Quest const *	quest
	)

{
    ASSERT(player);
    ASSERT(creature);
    ASSERT(quest);
 
    auto tempScript = ScriptRegistry<CreatureScript>::GetScriptById(creature->GetScriptId());
    ClearGossipMenuFor(player);
    return tempScript ? tempScript->OnQuestSelect(player, creature, quest) : false;
}

References ASSERT, ClearGossipMenuFor(), ScriptRegistry< TScript >::GetScriptById(), and Creature::GetScriptId().

◆ OnQueueUpdate()

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);
    });
}

References AllBattlegroundScript::OnQueueUpdate().

◆ OnRelocate()

void ScriptMgr::OnRelocate	(	Transport *	transport,
		uint32	waypointId,
		uint32	mapId,
		float	x,
		float	y,
		float	z
	)

{
    if (auto tempScript = ScriptRegistry<TransportScript>::GetScriptById(transport->GetScriptId()))
    {
        tempScript->OnRelocate(transport, waypointId, mapId, x, y, z);
    }
}

References GameObject::GetScriptId().

◆ OnRemoveAuraScaleTargets()

void ScriptMgr::OnRemoveAuraScaleTargets	(	Spell *	spell,
		TargetInfo &	targetInfo,
		uint8	auraScaleMask,
		bool &	needErase
	)

{
    ExecuteScript<AllSpellScript>([&](AllSpellScript* script)
    {
        script->OnRemoveAuraScaleTargets(spell, targetInfo, auraScaleMask, needErase);
    });
}

References AllSpellScript::OnRemoveAuraScaleTargets().

◆ OnRemovePassenger() [1/2]

void ScriptMgr::OnRemovePassenger	(	Transport *	transport,
		Player *	player
	)

{
    ASSERT(transport);
    ASSERT(player);
 
    if (auto tempScript = ScriptRegistry<TransportScript>::GetScriptById(transport->GetScriptId()))
    {
        tempScript->OnRemovePassenger(transport, player);
    }
}

References ASSERT, and GameObject::GetScriptId().

◆ OnRemovePassenger() [2/2]

void ScriptMgr::OnRemovePassenger	(	Vehicle *	veh,
		Unit *	passenger
	)

{
    ASSERT(veh);
    ASSERT(veh->GetBase()->GetTypeId() == TYPEID_UNIT);
    ASSERT(passenger);
 
    if (auto tempScript = ScriptRegistry<VehicleScript>::GetScriptById(veh->GetBase()->ToCreature()->GetScriptId()))
    {
        tempScript->OnRemovePassenger(veh, passenger);
    }
}

References ASSERT, Vehicle::GetBase(), Creature::GetScriptId(), Object::GetTypeId(), Object::ToCreature(), and TYPEID_UNIT.

◆ OnReset()

void ScriptMgr::OnReset ( Vehicle * veh )

{
    ASSERT(veh);
    ASSERT(veh->GetBase()->GetTypeId() == TYPEID_UNIT);
 
    if (auto tempScript = ScriptRegistry<VehicleScript>::GetScriptById(veh->GetBase()->ToCreature()->GetScriptId()))
    {
        tempScript->OnReset(veh);
    }
}

References ASSERT, Vehicle::GetBase(), Creature::GetScriptId(), Object::GetTypeId(), Object::ToCreature(), and TYPEID_UNIT.

◆ OnRewardKillRewarder()

void ScriptMgr::OnRewardKillRewarder	(	Player *	player,
		bool	isDungeon,
		float &	rate
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnRewardKillRewarder(player, isDungeon, rate);
    });
}

References PlayerScript::OnRewardKillRewarder().

◆ OnScaleAuraUnitAdd()

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);
    });
}

References AllSpellScript::OnScaleAuraUnitAdd().

◆ OnSendInitialPacketsBeforeAddToMap()

void ScriptMgr::OnSendInitialPacketsBeforeAddToMap	(	Player *	player,
		WorldPacket &	data
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnSendInitialPacketsBeforeAddToMap(player, data);
    });
}

References PlayerScript::OnSendInitialPacketsBeforeAddToMap().

◆ OnSetArenaMaxPlayersPerTeam()

void ScriptMgr::OnSetArenaMaxPlayersPerTeam	(	const uint8	arenaType,
		uint32 &	maxPlayerPerTeam
	)

{
    ExecuteScript<ArenaTeamScript>([&](ArenaTeamScript* script)
    {
        script->OnSetArenaMaxPlayersPerTeam(arenaType, maxPlayerPerTeam);
    });
}

References ArenaTeamScript::OnSetArenaMaxPlayersPerTeam().

◆ OnSetMaxLevel()

void ScriptMgr::OnSetMaxLevel	(	Player *	player,
		uint32 &	maxPlayerLevel
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnSetMaxLevel(player, maxPlayerLevel);
    });
}

References PlayerScript::OnSetMaxLevel().

◆ OnSetServerSideVisibility()

void ScriptMgr::OnSetServerSideVisibility	(	Player *	player,
		ServerSideVisibilityType &	type,
		AccountTypes &	sec
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnSetServerSideVisibility(player, type, sec);
    });
}

References PlayerScript::OnSetServerSideVisibility().

◆ OnSetServerSideVisibilityDetect()

void ScriptMgr::OnSetServerSideVisibilityDetect	(	Player *	player,
		ServerSideVisibilityType &	type,
		AccountTypes &	sec
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnSetServerSideVisibilityDetect(player, type, sec);
    });
}

References PlayerScript::OnSetServerSideVisibilityDetect().

◆ OnShutdown()

void ScriptMgr::OnShutdown ( )

{
    ExecuteScript<WorldScript>([&](WorldScript* script)
    {
        script->OnShutdown();
    });
}

References WorldScript::OnShutdown().

◆ OnShutdownCancel()

void ScriptMgr::OnShutdownCancel ( )

{
    ExecuteScript<WorldScript>([&](WorldScript* script)
    {
        script->OnShutdownCancel();
    });
}

References WorldScript::OnShutdownCancel().

◆ OnShutdownInitiate()

void ScriptMgr::OnShutdownInitiate	(	ShutdownExitCode	code,
		ShutdownMask	mask
	)

{
    ExecuteScript<WorldScript>([&](WorldScript* script)
    {
        script->OnShutdownInitiate(code, mask);
    });
}

References WorldScript::OnShutdownInitiate().

◆ OnSocketClose()

void ScriptMgr::OnSocketClose ( std::shared_ptr< WorldSocket > socket )

{
    ASSERT(socket);
 
    ExecuteScript<ServerScript>([&](ServerScript* script)
    {
        script->OnSocketClose(socket);
    });
}

References ASSERT, and ServerScript::OnSocketClose().

◆ OnSocketOpen()

void ScriptMgr::OnSocketOpen ( std::shared_ptr< WorldSocket > socket )

{
    ASSERT(socket);
 
    ExecuteScript<ServerScript>([&](ServerScript* script)
    {
        script->OnSocketOpen(socket);
    });
}

References ASSERT, and ServerScript::OnSocketOpen().

◆ OnSpellCheckCast()

void ScriptMgr::OnSpellCheckCast	(	Spell *	spell,
		bool	strict,
		SpellCastResult &	res
	)

{
    ExecuteScript<AllSpellScript>([&](AllSpellScript* script)
    {
        script->OnSpellCheckCast(spell, strict, res);
    });
}

References AllSpellScript::OnSpellCheckCast().

◆ OnSpellHealingBonusTakenNegativeModifiers()

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;
}

References GlobalScript::OnSpellHealingBonusTakenNegativeModifiers().

◆ OnStartup()

void ScriptMgr::OnStartup ( )

{
    ExecuteScript<WorldScript>([&](WorldScript* script)
    {
        script->OnStartup();
    });
}

References WorldScript::OnStartup().

◆ OnStoreNewItem()

void ScriptMgr::OnStoreNewItem	(	Player *	player,
		Item *	item,
		uint32	count
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnStoreNewItem(player, item, count);
    });
}

References PlayerScript::OnStoreNewItem().

◆ OnTransportUpdate()

void ScriptMgr::OnTransportUpdate	(	Transport *	transport,
		uint32	diff
	)

{
    ASSERT(transport);
 
    if (auto tempScript = ScriptRegistry<TransportScript>::GetScriptById(transport->GetScriptId()))
    {
        tempScript->OnUpdate(transport, diff);
    }
}

References ASSERT, and GameObject::GetScriptId().

◆ OnUninstall()

void ScriptMgr::OnUninstall ( Vehicle * veh )

{
    ASSERT(veh);
    ASSERT(veh->GetBase()->GetTypeId() == TYPEID_UNIT);
 
    if (auto tempScript = ScriptRegistry<VehicleScript>::GetScriptById(veh->GetBase()->ToCreature()->GetScriptId()))
    {
        tempScript->OnUninstall(veh);
    }
}

References ASSERT, Vehicle::GetBase(), Creature::GetScriptId(), Object::GetTypeId(), Object::ToCreature(), and TYPEID_UNIT.

◆ OnUnitDeath()

void ScriptMgr::OnUnitDeath	(	Unit *	unit,
		Unit *	killer
	)

{
    ExecuteScript<UnitScript>([&](UnitScript* script)
    {
        script->OnUnitDeath(unit, killer);
    });
}

References UnitScript::OnUnitDeath().

◆ OnUnitEnterCombat()

void ScriptMgr::OnUnitEnterCombat	(	Unit *	unit,
		Unit *	victim
	)

{
    ExecuteScript<UnitScript>([&](UnitScript* script)
    {
        script->OnUnitEnterCombat(unit, victim);
    });
}

References UnitScript::OnUnitEnterCombat().

◆ OnUnitEnterEvadeMode()

void ScriptMgr::OnUnitEnterEvadeMode	(	Unit *	unit,
		uint8	why
	)

{
    ExecuteScript<UnitScript>([&](UnitScript* script)
    {
        script->OnUnitEnterEvadeMode(unit, evadeReason);
    });
}

References UnitScript::OnUnitEnterEvadeMode().

◆ OnUnitUpdate()

void ScriptMgr::OnUnitUpdate	(	Unit *	unit,
		uint32	diff
	)

{
    ExecuteScript<UnitScript>([&](UnitScript* script)
    {
        script->OnUnitUpdate(unit, diff);
    });
}

References UnitScript::OnUnitUpdate().

◆ OnUnloadGridMap()

void ScriptMgr::OnUnloadGridMap	(	Map *	map,
		GridMap *	gmap,
		uint32	gx,
		uint32	gy
	)

{
    ASSERT(map);
    ASSERT(gmap);
 
    ForeachMaps<WorldMapScript>(map,
    [&](WorldMapScript* script)
    {
        script->OnUnloadGridMap(map, gmap, gx, gy);
    });
 
    ForeachMaps<InstanceMapScript>(map,
    [&](InstanceMapScript* script)
    {
        script->OnUnloadGridMap((InstanceMap*)map, gmap, gx, gy);
    });
 
    ForeachMaps<BattlegroundMapScript>(map,
    [&](BattlegroundMapScript* script)
    {
        script->OnUnloadGridMap((BattlegroundMap*)map, gmap, gx, gy);
    });
}

References ASSERT, and MapScript< TMap >::OnUnloadGridMap().

◆ OnUpdateCraftingSkill()

void ScriptMgr::OnUpdateCraftingSkill	(	Player *	player,
		SkillLineAbilityEntry const *	skill,
		uint32	currentLevel,
		uint32 &	gain
	)

                                                                                                                           {
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnUpdateCraftingSkill(player, skill, currentLevel, gain);
    });
}

References PlayerScript::OnUpdateCraftingSkill().

◆ OnUpdateFishingSkill()

bool ScriptMgr::OnUpdateFishingSkill	(	Player *	player,
		int32	skill,
		int32	zone_skill,
		int32	chance,
		int32	roll
	)

{
    auto ret = IsValidBoolScript<PlayerScript>([&](PlayerScript* script)
    {
        return !script->OnUpdateFishingSkill(player, skill, zone_skill, chance, roll);
    });
 
    if (ret && *ret)
    {
        return false;
    }
 
    return true;
}

References PlayerScript::OnUpdateFishingSkill().

◆ OnUpdateGatheringSkill()

void ScriptMgr::OnUpdateGatheringSkill	(	Player *	player,
		uint32	skillId,
		uint32	currentLevel,
		uint32	gray,
		uint32	green,
		uint32	yellow,
		uint32 &	gain
	)

                                                                                                                                                  {
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnUpdateGatheringSkill(player, skillId, currentLevel, gray, green, yellow, gain);
    });
}

References PlayerScript::OnUpdateGatheringSkill().

◆ OnVictimRewardAfter()

void ScriptMgr::OnVictimRewardAfter	(	Player *	player,
		Player *	victim,
		uint32 &	killer_title,
		uint32 &	victim_rank,
		float &	honor_f
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnVictimRewardAfter(player, victim, killer_title, victim_rank, honor_f);
    });
}

References PlayerScript::OnVictimRewardAfter().

◆ OnVictimRewardBefore()

void ScriptMgr::OnVictimRewardBefore	(	Player *	player,
		Player *	victim,
		uint32 &	killer_title,
		uint32 &	victim_title
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->OnVictimRewardBefore(player, victim, killer_title, victim_title);
    });
}

References PlayerScript::OnVictimRewardBefore().

◆ OnWeatherChange()

void ScriptMgr::OnWeatherChange	(	Weather *	weather,
		WeatherState	state,
		float	grade
	)

{
    ASSERT(weather);
 
    ExecuteScript<ElunaScript>([&](ElunaScript* script)
    {
        script->OnWeatherChange(weather, state, grade);
    });
 
    if (auto tempScript = ScriptRegistry<WeatherScript>::GetScriptById(weather->GetScriptId()))
    {
        tempScript->OnChange(weather, state, grade);
    }
}

References ASSERT, Weather::GetScriptId(), and ElunaScript::OnWeatherChange().

◆ OnWeatherUpdate()

void ScriptMgr::OnWeatherUpdate	(	Weather *	weather,
		uint32	diff
	)

{
    ASSERT(weather);
 
    if (auto tempScript = ScriptRegistry<WeatherScript>::GetScriptById(weather->GetScriptId()))
    {
        tempScript->OnUpdate(weather, diff);
    }
}

References ASSERT, and Weather::GetScriptId().

◆ OnWorldObjectCreate()

void ScriptMgr::OnWorldObjectCreate ( WorldObject * object )

{
    ASSERT(object);
 
    ExecuteScript<WorldObjectScript>([&](WorldObjectScript* script)
    {
        script->OnWorldObjectCreate(object);
    });
}

References ASSERT, and WorldObjectScript::OnWorldObjectCreate().

◆ OnWorldObjectDestroy()

void ScriptMgr::OnWorldObjectDestroy ( WorldObject * object )

{
    ASSERT(object);
 
    ExecuteScript<WorldObjectScript>([&](WorldObjectScript* script)
    {
        script->OnWorldObjectDestroy(object);
    });
}

References ASSERT, and WorldObjectScript::OnWorldObjectDestroy().

◆ OnWorldObjectResetMap()

void ScriptMgr::OnWorldObjectResetMap ( WorldObject * object )

{
    ASSERT(object);
 
    ExecuteScript<WorldObjectScript>([&](WorldObjectScript* script)
    {
        script->OnWorldObjectResetMap(object);
    });
}

References ASSERT, and WorldObjectScript::OnWorldObjectResetMap().

◆ OnWorldObjectSetMap()

void ScriptMgr::OnWorldObjectSetMap	(	WorldObject *	object,
		Map *	map
	)

{
    ASSERT(object);
 
    ExecuteScript<WorldObjectScript>([&](WorldObjectScript* script)
    {
        script->OnWorldObjectSetMap(object, map);
    });
}

References ASSERT, and WorldObjectScript::OnWorldObjectSetMap().

◆ OnWorldObjectUpdate()

void ScriptMgr::OnWorldObjectUpdate	(	WorldObject *	object,
		uint32	diff
	)

{
    ASSERT(object);
 
    ExecuteScript<WorldObjectScript>([&](WorldObjectScript* script)
    {
        script->OnWorldObjectUpdate(object, diff);
    });
}

References ASSERT, and WorldObjectScript::OnWorldObjectUpdate().

◆ OnWorldUpdate()

void ScriptMgr::OnWorldUpdate ( uint32 diff )

{
    ExecuteScript<WorldScript>([&](WorldScript* script)
    {
        script->OnUpdate(diff);
    });
}

References WorldScript::OnUpdate().

◆ OnZeroDifferenceCalculation()

void ScriptMgr::OnZeroDifferenceCalculation	(	uint8 &	diff,
		uint8	playerLevel
	)

{
    ExecuteScript<FormulaScript>([&](FormulaScript* script)
    {
        script->OnZeroDifferenceCalculation(diff, playerLevel);
    });
}

References FormulaScript::OnZeroDifferenceCalculation().

◆ PassedQuestKilledMonsterCredit()

bool ScriptMgr::PassedQuestKilledMonsterCredit	(	Player *	player,
		Quest const *	qinfo,
		uint32	entry,
		uint32	real_entry,
		ObjectGuid	guid
	)

{
    auto ret = IsValidBoolScript<PlayerScript>([&](PlayerScript* script)
    {
        return !script->PassedQuestKilledMonsterCredit(player, qinfo, entry, real_entry, guid);
    });
 
    if (ret && *ret)
    {
        return false;
    }
 
    return true;
}

References PlayerScript::PassedQuestKilledMonsterCredit().

◆ PetitionBuy()

void ScriptMgr::PetitionBuy	(	Player *	player,
		Creature *	creature,
		uint32 &	charterid,
		uint32 &	cost,
		uint32 &	type
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->PetitionBuy(player, creature, charterid, cost, type);
    });
}

References PlayerScript::PetitionBuy().

◆ PetitionShowList()

void ScriptMgr::PetitionShowList	(	Player *	player,
		Creature *	creature,
		uint32 &	CharterEntry,
		uint32 &	CharterDispayID,
		uint32 &	CharterCost
	)

{
    ExecuteScript<PlayerScript>([&](PlayerScript* script)
    {
        script->PetitionShowList(player, creature, CharterEntry, CharterDispayID, CharterCost);
    });
}

References PlayerScript::PetitionShowList().

◆ ScriptsVersion()

std::string_view ScriptMgr::ScriptsVersion ( ) const

inline

125{ return "Integrated Azeroth Scripts"; }

◆ SetModulesLoader()

void ScriptMgr::SetModulesLoader ( ModulesLoaderCallbackType script_loader_callback )

inline

Sets the modules loader callback which is invoked to load modules (Workaround for circular dependency game <-> modules)

    {
        _modules_loader_callback = script_loader_callback;
    }

References _modules_loader_callback.

◆ SetRealmCompleted()

void ScriptMgr::SetRealmCompleted ( AchievementEntry const * achievement )

{
    ExecuteScript<AchievementScript>([&](AchievementScript* script)
    {
        script->SetRealmCompleted(achievement);
    });
}

References AchievementScript::SetRealmCompleted().

◆ SetScriptLoader()

void ScriptMgr::SetScriptLoader ( ScriptLoaderCallbackType script_loader_callback )

inline

Sets the script loader callback which is invoked to load scripts (Workaround for circular dependency game <-> scripts)

    {
        _script_loader_callback = script_loader_callback;
    }

References _script_loader_callback.

◆ ShouldBeRewardedWithMoneyInsteadOfExp()

bool ScriptMgr::ShouldBeRewardedWithMoneyInsteadOfExp ( Player * player )

{
    auto ret = IsValidBoolScript<PlayerScript>([&](PlayerScript* script)
    {
        return script->ShouldBeRewardedWithMoneyInsteadOfExp(player);
    });
 
    if (ret && *ret)
    {
        return true;
    }
 
    return false;
}

References PlayerScript::ShouldBeRewardedWithMoneyInsteadOfExp().

◆ Unload()

void ScriptMgr::Unload ( )

{
    SCR_CLEAR<AccountScript>();
    SCR_CLEAR<AchievementCriteriaScript>();
    SCR_CLEAR<AchievementScript>();
    SCR_CLEAR<AllCreatureScript>();
    SCR_CLEAR<AllGameObjectScript>();
    SCR_CLEAR<AllItemScript>();
    SCR_CLEAR<AllMapScript>();
    SCR_CLEAR<AreaTriggerScript>();
    SCR_CLEAR<ArenaScript>();
    SCR_CLEAR<ArenaTeamScript>();
    SCR_CLEAR<AuctionHouseScript>();
    SCR_CLEAR<BGScript>();
    SCR_CLEAR<BattlegroundMapScript>();
    SCR_CLEAR<BattlegroundScript>();
    SCR_CLEAR<CommandSC>();
    SCR_CLEAR<CommandScript>();
    SCR_CLEAR<ConditionScript>();
    SCR_CLEAR<CreatureScript>();
    SCR_CLEAR<DatabaseScript>();
    SCR_CLEAR<DynamicObjectScript>();
    SCR_CLEAR<ElunaScript>();
    SCR_CLEAR<FormulaScript>();
    SCR_CLEAR<GameEventScript>();
    SCR_CLEAR<GameObjectScript>();
    SCR_CLEAR<GlobalScript>();
    SCR_CLEAR<GroupScript>();
    SCR_CLEAR<GuildScript>();
    SCR_CLEAR<InstanceMapScript>();
    SCR_CLEAR<ItemScript>();
    SCR_CLEAR<LootScript>();
    SCR_CLEAR<MailScript>();
    SCR_CLEAR<MiscScript>();
    SCR_CLEAR<MovementHandlerScript>();
    SCR_CLEAR<OutdoorPvPScript>();
    SCR_CLEAR<PetScript>();
    SCR_CLEAR<PlayerScript>();
    SCR_CLEAR<ServerScript>();
    SCR_CLEAR<SpellSC>();
    SCR_CLEAR<SpellScriptLoader>();
    SCR_CLEAR<TransportScript>();
    SCR_CLEAR<UnitScript>();
    SCR_CLEAR<VehicleScript>();
    SCR_CLEAR<WeatherScript>();
    SCR_CLEAR<WorldMapScript>();
    SCR_CLEAR<WorldObjectScript>();
    SCR_CLEAR<WorldScript>();
 
    delete[] SpellSummary;
}

References SpellSummary.

◆ ValidateSpellAtCastSpell()

void ScriptMgr::ValidateSpellAtCastSpell	(	Player *	player,
		uint32 &	oldSpellId,
		uint32 &	spellId,
		uint8 &	castCount,
		uint8 &	castFlags
	)

{
    ExecuteScript<MiscScript>([&](MiscScript* script)
    {
        script->ValidateSpellAtCastSpell(player, oldSpellId, spellId, castCount, castFlags);
    });
}

References MiscScript::ValidateSpellAtCastSpell().

◆ ValidateSpellAtCastSpellResult()

void ScriptMgr::ValidateSpellAtCastSpellResult	(	Player *	player,
		Unit *	mover,
		Spell *	spell,
		uint32	oldSpellId,
		uint32	spellId
	)

{
    ExecuteScript<MiscScript>([&](MiscScript* script)
    {
        script->ValidateSpellAtCastSpellResult(player, mover, spell, oldSpellId, spellId);
    });
}

References MiscScript::ValidateSpellAtCastSpellResult().

◆ ~ScriptMgr()

ScriptMgr::~ScriptMgr ( )

privatevirtual

54{ }

Friends And Related Function Documentation

◆ ScriptObject

friend class ScriptObject

friend

Member Data Documentation

◆ _modules_loader_callback

ModulesLoaderCallbackType ScriptMgr::_modules_loader_callback

private

Referenced by Initialize(), and SetModulesLoader().

◆ _scheduledScripts

std::atomic<long> ScriptMgr::_scheduledScripts

private

Referenced by DecreaseScheduledScriptCount(), IncreaseScheduledScriptsCount(), and IsScriptScheduled().

◆ _script_loader_callback

ScriptLoaderCallbackType ScriptMgr::_script_loader_callback

private

Referenced by Initialize(), and SetScriptLoader().

◆ _scriptCount

uint32 ScriptMgr::_scriptCount

private

Referenced by DecreaseScriptCount(), GetScriptCount(), and IncreaseScriptCount().

Public Types

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Friends

Detailed Description

Member Typedef Documentation

◆ ModulesLoaderCallbackType

◆ ScriptLoaderCallbackType

Constructor & Destructor Documentation

◆ ScriptMgr()

Member Function Documentation

◆ AfterInstanceGameObjectCreate()

◆ AnticheatCheckMovementInfo()

◆ AnticheatHandleDoubleJump()

◆ AnticheatSetCanFlybyServer()

◆ AnticheatSetJumpingbyOpcode()

◆ AnticheatSetRootACKUpd()

◆ AnticheatSetSkipOnePacketForASH()

◆ AnticheatSetUnderACKmount()

◆ AnticheatUpdateMovementInfo()

◆ CanAccountCreateCharacter()

◆ CanAddMember()

◆ CanApplyEnchantment()

◆ CanApplyEquipSpell()

◆ CanApplyEquipSpellsItemSet()

◆ CanApplySoulboundFlag()

◆ CanApplyWeaponDependentAuraDamageMod()

◆ CanAreaExploreAndOutdoor()

◆ CanArmorDamageModifier()

◆ CanBattleFieldPort()

◆ CanCastItemCombatSpell()

◆ CanCastItemUseSpell()

◆ CanCheckCriteria()

◆ CanEnterMap()

◆ CanEquipItem()

◆ CanExecuteCommand()

◆ CanFillPlayersToBG()

◆ CanGiveMailRewardAtGiveLevel()

◆ CanGroupAccept()

◆ CanGroupInvite()

◆ CanGroupJoinBattlegroundQueue()

◆ CanGuildSendBankList()

◆ CanInitTrade()

◆ CanItemApplyEquipSpell()

◆ CanJoinInArenaQueue()

◆ CanJoinInBattlegroundQueue()

◆ CanJoinLfg()

◆ CanModAuraEffectDamageDone()

◆ CanModAuraEffectModDamagePercentDone()

◆ CanPacketReceive()

◆ CanPacketSend()

◆ CanPlaceAuctionBid()

◆ CanPlayerUseChat() [1/5]

◆ CanPlayerUseChat() [2/5]

◆ CanPlayerUseChat() [3/5]

◆ CanPlayerUseChat() [4/5]

◆ CanPlayerUseChat() [5/5]

◆ CanPrepare()

◆ CanRepopAtGraveyard()

◆ CanResetTalents()

◆ CanSaveEquipNewItem()

◆ CanSaveToDB()

◆ CanScalingEverything()

◆ CanSelectSpecTalent()

◆ CanSellItem()

◆ CanSendAuctionHello()

◆ CanSendErrorAlreadyLooted()

◆ CanSendMail()

◆ CanSendMessageBGQueue()

◆ CanSetPhaseMask()

◆ CanUnequipItem()

◆ CanUnlearnSpellDefault()

◆ CanUnlearnSpellSet()

◆ CanUseItem()

◆ CheckIfScriptsInDatabaseExist()

◆ CheckItemInSlotAtLoadInventory()

◆ CreateAuraScripts()

◆ CreateBattleground()