#include <ScriptMgr.h>

Public Types
typedef void(*	ScriptLoaderCallbackType )()

Public Member Functions
void	Initialize ()

void	LoadDatabase ()

void	FillSpellSummary ()

const char *	ScriptsVersion () const

void	IncrementScriptCount ()

uint32	GetScriptCount () const

void	SetScriptLoader (ScriptLoaderCallbackType 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)

void	OnPacketReceive (WorldSession *session, WorldPacket const &packet)

void	OnPacketSend (WorldSession *session, WorldPacket const &packet)

void	OnOpenStateChange (bool open)

void	OnConfigLoad (bool reload)

void	OnMotdChange (std::string &newMotd)

void	OnShutdownInitiate (ShutdownExitCode code, ShutdownMask mask)

void	OnShutdownCancel ()

void	OnWorldUpdate (uint32 diff)

void	OnStartup ()

void	OnShutdown ()

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)

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

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

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 *	CreateInstanceData (InstanceMap *map)

bool	OnDummyEffect (Unit caster, uint32 spellId, SpellEffIndex effIndex, Item target)

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	OnDummyEffect (Unit caster, uint32 spellId, SpellEffIndex effIndex, Creature target)

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

bool	OnDummyEffect (Unit caster, uint32 spellId, SpellEffIndex effIndex, GameObject target)

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	OnGameObjectLootStateChanged (GameObject go, uint32 state, Unit unit)

void	OnGameObjectStateChanged (GameObject *go, uint32 state)

void	OnGameObjectUpdate (GameObject *go, uint32 diff)

GameObjectAI *	GetGameObjectAI (GameObject *go)

bool	OnAreaTrigger (Player player, AreaTriggerEntry const trigger, bool entered)

Battleground *	CreateBattleground (BattlegroundTypeId typeId)

OutdoorPvP *	CreateOutdoorPvP (OutdoorPvPData const *data)

std::vector< ChatCommand >	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)

bool	OnConditionCheck (Condition const *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)

void	OnPVPKill (Player killer, Player killed)

void	OnCreatureKill (Player killer, 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	OnPlayerMoneyChanged (Player *player, int64 &amount)

void	OnPlayerMoneyLimit (Player *player, int64 amount)

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

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

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	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	OnPlayerClearEmote (Player *player)

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

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

void	OnPlayerLogin (Player *player, bool firstLogin)

void	OnPlayerLogout (Player *player)

void	OnPlayerCreate (Player *player)

void	OnPlayerDelete (ObjectGuid guid, uint32 accountId)

void	OnPlayerFailedDelete (ObjectGuid guid, uint32 accountId)

void	OnPlayerSave (Player *player)

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

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

void	OnQuestStatusChange (Player *player, uint32 questId, QuestStatus status)

void	OnAccountLogin (uint32 accountId)

void	OnFailedAccountLogin (uint32 accountId)

void	OnEmailChange (uint32 accountId)

void	OnFailedEmailChange (uint32 accountId)

void	OnPasswordChange (uint32 accountId)

void	OnFailedPasswordChange (uint32 accountId)

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

void	OnGuildRemoveMember (Guild *guild, ObjectGuid guid, 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, uint64 &amount, bool isRepair)

void	OnGuildMemberDepositMoney (Guild guild, Player player, uint64 &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, uint64 itemOrMoney, uint16 itemStackCount, uint8 destTabId)

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)

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

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

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

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

void	ModifySpellDamageTaken (Unit target, Unit attacker, int32 &damage)

uint64	IncreaseScheduledScriptsCount ()

uint64	DecreaseScheduledScriptCount ()

uint64	DecreaseScheduledScriptCount (uint64 count)

bool	IsScriptScheduled () const

Static Public Member Functions
static ScriptMgr *	instance ()

Private Member Functions
	ScriptMgr ()

virtual	~ScriptMgr ()

Private Attributes
uint32	_scriptCount

std::atomic< uint64 >	_scheduledScripts

ScriptLoaderCallbackType	_script_loader_callback

Friends
class	ScriptObject

Member Typedef Documentation

typedef void(* ScriptMgr::ScriptLoaderCallbackType)()

Constructor & Destructor Documentation

ScriptMgr::ScriptMgr ( )

private

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

ScriptMgr::~ScriptMgr ( )

privatevirtual

248 { }

Member Function Documentation

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* tmpscript = ScriptRegistry<SpellScriptLoader>::GetScriptById(itr->second);
  if (!tmpscript)
  continue;
 
  AuraScript* script = tmpscript->GetAuraScript();
 
  if (!script)
  continue;
 
  script->_Init(&tmpscript->GetName(), spellId);
 
  scriptVector.push_back(script);
  }
 }

Here is the call graph for this function:

Battleground * ScriptMgr::CreateBattleground ( BattlegroundTypeId typeId )

Todo:: Implement script-side battlegrounds.

 {
  ABORT();
  return NULL;
 }

InstanceScript * ScriptMgr::CreateInstanceData ( InstanceMap * map )

 {
  ASSERT(map);
 
  GET_SCRIPT_RET(InstanceMapScript, map->GetScriptId(), tmpscript, NULL);
  return tmpscript->GetInstanceScript(map);
 }

Here is the call graph for this function:

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

 {
  ASSERT(data);
 
  GET_SCRIPT_RET(OutdoorPvPScript, data->ScriptId, tmpscript, NULL);
  return tmpscript->GetOutdoorPvP();
 }

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* tmpscript = ScriptRegistry<SpellScriptLoader>::GetScriptById(itr->second);
  if (!tmpscript)
  continue;
 
  scriptVector.push_back(std::make_pair(tmpscript, itr));
  }
 }

Here is the call graph for this function:

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* tmpscript = ScriptRegistry<SpellScriptLoader>::GetScriptById(itr->second);
  if (!tmpscript)
  continue;
 
  SpellScript* script = tmpscript->GetSpellScript();
 
  if (!script)
  continue;
 
  script->_Init(&tmpscript->GetName(), spellId);
 
  scriptVector.push_back(script);
  }
 }

Here is the call graph for this function:

uint64 ScriptMgr::DecreaseScheduledScriptCount ( )

inline

1099 { return --_scheduledScripts; }

ScriptMgr::_scheduledScripts

std::atomic< uint64 > _scheduledScripts

Definition: ScriptMgr.h:1108

uint64 ScriptMgr::DecreaseScheduledScriptCount ( uint64 count )

inline

1100 { return _scheduledScripts -= count; }

ScriptMgr::_scheduledScripts

std::atomic< uint64 > _scheduledScripts

Definition: ScriptMgr.h:1108

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 (SpellEffectInfo const* effect : pTempSpell->GetEffectsForDifficulty(DIFFICULTY_NONE))
  {
  if (!effect)
  continue;
 
  // Spell targets self.
  if (effect->TargetA.GetTarget() == TARGET_UNIT_CASTER)
  SpellSummary[i].Targets |= 1 << (SELECT_TARGET_SELF-1);
 
  // Spell targets a single enemy.
  if (effect->TargetA.GetTarget() == TARGET_UNIT_TARGET_ENEMY ||
  effect->TargetA.GetTarget() == TARGET_DEST_TARGET_ENEMY)
  SpellSummary[i].Targets |= 1 << (SELECT_TARGET_SINGLE_ENEMY-1);
 
  // Spell targets AoE at enemy.
  if (effect->TargetA.GetTarget() == TARGET_UNIT_SRC_AREA_ENEMY ||
  effect->TargetA.GetTarget() == TARGET_UNIT_DEST_AREA_ENEMY ||
  effect->TargetA.GetTarget() == TARGET_SRC_CASTER ||
  effect->TargetA.GetTarget() == TARGET_DEST_DYNOBJ_ENEMY)
  SpellSummary[i].Targets |= 1 << (SELECT_TARGET_AOE_ENEMY-1);
 
  // Spell targets an enemy.
  if (effect->TargetA.GetTarget() == TARGET_UNIT_TARGET_ENEMY ||
  effect->TargetA.GetTarget() == TARGET_DEST_TARGET_ENEMY ||
  effect->TargetA.GetTarget() == TARGET_UNIT_SRC_AREA_ENEMY ||
  effect->TargetA.GetTarget() == TARGET_UNIT_DEST_AREA_ENEMY ||
  effect->TargetA.GetTarget() == TARGET_SRC_CASTER ||
  effect->TargetA.GetTarget() == TARGET_DEST_DYNOBJ_ENEMY)
  SpellSummary[i].Targets |= 1 << (SELECT_TARGET_ANY_ENEMY-1);
 
  // Spell targets a single friend (or self).
  if (effect->TargetA.GetTarget() == TARGET_UNIT_CASTER ||
  effect->TargetA.GetTarget() == TARGET_UNIT_TARGET_ALLY ||
  effect->TargetA.GetTarget() == TARGET_UNIT_TARGET_PARTY)
  SpellSummary[i].Targets |= 1 << (SELECT_TARGET_SINGLE_FRIEND-1);
 
  // Spell targets AoE friends.
  if (effect->TargetA.GetTarget() == TARGET_UNIT_CASTER_AREA_PARTY ||
  effect->TargetA.GetTarget() == TARGET_UNIT_LASTTARGET_AREA_PARTY ||
  effect->TargetA.GetTarget() == TARGET_SRC_CASTER)
  SpellSummary[i].Targets |= 1 << (SELECT_TARGET_AOE_FRIEND-1);
 
  // Spell targets any friend (or self).
  if (effect->TargetA.GetTarget() == TARGET_UNIT_CASTER ||
  effect->TargetA.GetTarget() == TARGET_UNIT_TARGET_ALLY ||
  effect->TargetA.GetTarget() == TARGET_UNIT_TARGET_PARTY ||
  effect->TargetA.GetTarget() == TARGET_UNIT_CASTER_AREA_PARTY ||
  effect->TargetA.GetTarget() == TARGET_UNIT_LASTTARGET_AREA_PARTY ||
  effect->TargetA.GetTarget() == TARGET_SRC_CASTER)
  SpellSummary[i].Targets |= 1 << (SELECT_TARGET_ANY_FRIEND-1);
 
  // Make sure that this spell includes a damage effect.
  if (effect->Effect == SPELL_EFFECT_SCHOOL_DAMAGE ||
  effect->Effect == SPELL_EFFECT_INSTAKILL ||
  effect->Effect == SPELL_EFFECT_ENVIRONMENTAL_DAMAGE ||
  effect->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 (effect->Effect == SPELL_EFFECT_HEAL ||
  effect->Effect == SPELL_EFFECT_HEAL_MAX_HEALTH ||
  effect->Effect == SPELL_EFFECT_HEAL_MECHANICAL ||
  (effect->Effect == SPELL_EFFECT_APPLY_AURA && effect->ApplyAuraName == 8))
  SpellSummary[i].Effects |= 1 << (SELECT_EFFECT_HEALING-1);
 
  // Make sure that this spell applies an aura.
  if (effect->Effect == SPELL_EFFECT_APPLY_AURA)
  SpellSummary[i].Effects |= 1 << (SELECT_EFFECT_AURA-1);
  }
  }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector< ChatCommand > ScriptMgr::GetChatCommands ( )

 {
  std::vector<ChatCommand> table;
 
  FOR_SCRIPTS_RET(CommandScript, itr, end, table)
  {
  std::vector<ChatCommand> cmds = itr->second->GetCommands();
  table.insert(table.end(), cmds.begin(), cmds.end());
  }
 
  // Sort commands in alphabetical order
  std::sort(table.begin(), table.end(), [](const ChatCommand& a, const ChatCommand&b)
  {
  return strcmp(a.Name, b.Name) < 0;
  });
 
  return table;
 }

CreatureAI * ScriptMgr::GetCreatureAI ( Creature * creature )

 {
  ASSERT(creature);
 
  GET_SCRIPT_RET(CreatureScript, creature->GetScriptId(), tmpscript, NULL);
  return tmpscript->GetAI(creature);
 }

Here is the call graph for this function:

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

 {
  ASSERT(player);
  ASSERT(creature);
 
  GET_SCRIPT_RET(CreatureScript, creature->GetScriptId(), tmpscript, DIALOG_STATUS_SCRIPTED_NO_STATUS);
  player->PlayerTalkClass->ClearMenus();
  return tmpscript->GetDialogStatus(player, creature);
 }

Here is the call graph for this function:

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

 {
  ASSERT(player);
  ASSERT(go);
 
  GET_SCRIPT_RET(GameObjectScript, go->GetScriptId(), tmpscript, DIALOG_STATUS_SCRIPTED_NO_STATUS);
  player->PlayerTalkClass->ClearMenus();
  return tmpscript->GetDialogStatus(player, go);
 }

Here is the call graph for this function:

GameObjectAI * ScriptMgr::GetGameObjectAI ( GameObject * go )

 {
  ASSERT(gameobject);
 
  GET_SCRIPT_RET(GameObjectScript, gameobject->GetScriptId(), tmpscript, NULL);
  return tmpscript->GetAI(gameobject);
 }

Here is the call graph for this function:

uint32 ScriptMgr::GetScriptCount ( ) const

inline

864 { return _scriptCount; }

ScriptMgr::_scriptCount

uint32 _scriptCount

Definition: ScriptMgr.h:1105

Here is the caller graph for this function:

uint64 ScriptMgr::IncreaseScheduledScriptsCount ( )

inline

1098 { return ++_scheduledScripts; }

ScriptMgr::_scheduledScripts

std::atomic< uint64 > _scheduledScripts

Definition: ScriptMgr.h:1108

void ScriptMgr::IncrementScriptCount ( )

inline

863 { ++_scriptCount; }

ScriptMgr::_scriptCount

uint32 _scriptCount

Definition: ScriptMgr.h:1105

void ScriptMgr::Initialize ( void )

 {
  uint32 oldMSTime = getMSTime();
 
  LoadDatabase();
 
  TC_LOG_INFO("server.loading", "Loading C++ scripts");
 
  FillSpellSummary();
 
  AddSC_SmartScripts();
 
  ASSERT(_script_loader_callback,
  "Script loader callback wasn't registered!");
 
  _script_loader_callback();
 
 #ifdef SCRIPTS
  for (std::string const& scriptName : UnusedScriptNames)
  {
  TC_LOG_ERROR("sql.sql", "ScriptName '%s' exists in database, but no core script found!", scriptName.c_str());
  }
 #endif
 
  TC_LOG_INFO("server.loading", ">> Loaded %u C++ scripts in %u ms", GetScriptCount(), GetMSTimeDiffToNow(oldMSTime));
 }

Here is the call graph for this function:

ScriptMgr * ScriptMgr::instance ( )

static

 {
  static ScriptMgr instance;
  return &instance;
 }

bool ScriptMgr::IsScriptScheduled ( ) const

inline

1101 { return _scheduledScripts > 0; }

ScriptMgr::_scheduledScripts

std::atomic< uint64 > _scheduledScripts

Definition: ScriptMgr.h:1108

void ScriptMgr::LoadDatabase ( )

 {
  sScriptSystemMgr->LoadScriptWaypoints();
 }

Here is the caller graph for this function:

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

 {
  FOREACH_SCRIPT(UnitScript)->ModifyMeleeDamage(target, attacker, damage);
 }

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

 {
  FOREACH_SCRIPT(UnitScript)->ModifyPeriodicDamageAurasTick(target, attacker, damage);
 }

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

 {
  FOREACH_SCRIPT(UnitScript)->ModifySpellDamageTaken(target, attacker, damage);
 }

void ScriptMgr::OnAccountLogin ( uint32 accountId )

 {
  FOREACH_SCRIPT(AccountScript)->OnAccountLogin(accountId);
 }

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

 {
  ASSERT(transport);
  ASSERT(creature);
 
  GET_SCRIPT(TransportScript, transport->GetScriptId(), tmpscript);
  tmpscript->OnAddCreaturePassenger(transport, creature);
 }

Here is the call graph for this function:

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

 {
  ASSERT(veh);
  ASSERT(veh->GetBase()->GetTypeId() == TYPEID_UNIT);
  ASSERT(passenger);
 
  GET_SCRIPT(VehicleScript, veh->GetBase()->ToCreature()->GetScriptId(), tmpscript);
  tmpscript->OnAddPassenger(veh, passenger, seatId);
 }

Here is the call graph for this function:

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

 {
  ASSERT(transport);
  ASSERT(player);
 
  GET_SCRIPT(TransportScript, transport->GetScriptId(), tmpscript);
  tmpscript->OnAddPassenger(transport, player);
 }

Here is the call graph for this function:

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

 {
  ASSERT(player);
  ASSERT(trigger);
 
  GET_SCRIPT_RET(AreaTriggerScript, sObjectMgr->GetAreaTriggerScriptId(trigger->ID), tmpscript, false);
  return tmpscript->OnTrigger(player, trigger, entered);
 }

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

 {
  ASSERT(ah);
  ASSERT(entry);
 
  FOREACH_SCRIPT(AuctionHouseScript)->OnAuctionAdd(ah, entry);
 }

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

 {
  ASSERT(ah);
  ASSERT(entry);
 
  FOREACH_SCRIPT(AuctionHouseScript)->OnAuctionExpire(ah, entry);
 }

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

 {
  ASSERT(ah);
  ASSERT(entry);
 
  FOREACH_SCRIPT(AuctionHouseScript)->OnAuctionRemove(ah, entry);
 }

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

 {
  ASSERT(ah);
  ASSERT(entry);
 
  FOREACH_SCRIPT(AuctionHouseScript)->OnAuctionSuccessful(ah, entry);
 }

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

 {
  FOREACH_SCRIPT(FormulaScript)->OnBaseGainCalculation(gain, playerLevel, mobLevel);
 }

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

 {
  FOREACH_SCRIPT(FormulaScript)->OnColorCodeCalculation(color, playerLevel, mobLevel);
 }

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

 {
  ASSERT(condition);
 
  GET_SCRIPT_RET(ConditionScript, condition->ScriptId, tmpscript, true);
  return tmpscript->OnConditionCheck(condition, sourceInfo);
 }

void ScriptMgr::OnConfigLoad ( bool reload )

 {
  FOREACH_SCRIPT(WorldScript)->OnConfigLoad(reload);
 }

void ScriptMgr::OnCreateMap ( Map * map )

 {
  ASSERT(map);
 
  SCR_MAP_BGN(WorldMapScript, map, itr, end, entry, IsWorldMap);
  itr->second->OnCreate(map);
  SCR_MAP_END;
 
  SCR_MAP_BGN(InstanceMapScript, map, itr, end, entry, IsDungeon);
  itr->second->OnCreate((InstanceMap*)map);
  SCR_MAP_END;
 
  SCR_MAP_BGN(BattlegroundMapScript, map, itr, end, entry, IsBattleground);
  itr->second->OnCreate((BattlegroundMap*)map);
  SCR_MAP_END;
 }

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

 {
  FOREACH_SCRIPT(PlayerScript)->OnCreatureKill(killer, killed);
 }

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

 {
  ASSERT(creature);
 
  GET_SCRIPT(CreatureScript, creature->GetScriptId(), tmpscript);
  tmpscript->OnUpdate(creature, diff);
 }

Here is the call graph for this function:

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

 {
  ASSERT(source);
  // target can be NULL.
 
  GET_SCRIPT_RET(AchievementCriteriaScript, scriptId, tmpscript, false);
  return tmpscript->OnCheck(source, target);
 }

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

 {
  FOREACH_SCRIPT(UnitScript)->OnDamage(attacker, victim, damage);
 }

void ScriptMgr::OnDestroyMap ( Map * map )

 {
  ASSERT(map);
 
  SCR_MAP_BGN(WorldMapScript, map, itr, end, entry, IsWorldMap);
  itr->second->OnDestroy(map);
  SCR_MAP_END;
 
  SCR_MAP_BGN(InstanceMapScript, map, itr, end, entry, IsDungeon);
  itr->second->OnDestroy((InstanceMap*)map);
  SCR_MAP_END;
 
  SCR_MAP_BGN(BattlegroundMapScript, map, itr, end, entry, IsBattleground);
  itr->second->OnDestroy((BattlegroundMap*)map);
  SCR_MAP_END;
 }

bool ScriptMgr::OnDummyEffect	(	Unit *	caster,
		uint32	spellId,
		SpellEffIndex	effIndex,
		Item *	target
	)

 {
  ASSERT(caster);
  ASSERT(target);
 
  GET_SCRIPT_RET(ItemScript, target->GetScriptId(), tmpscript, false);
  return tmpscript->OnDummyEffect(caster, spellId, effIndex, target);
 }

Here is the call graph for this function:

bool ScriptMgr::OnDummyEffect	(	Unit *	caster,
		uint32	spellId,
		SpellEffIndex	effIndex,
		Creature *	target
	)

 {
  ASSERT(caster);
  ASSERT(target);
 
  GET_SCRIPT_RET(CreatureScript, target->GetScriptId(), tmpscript, false);
  return tmpscript->OnDummyEffect(caster, spellId, effIndex, target);
 }

Here is the call graph for this function:

bool ScriptMgr::OnDummyEffect	(	Unit *	caster,
		uint32	spellId,
		SpellEffIndex	effIndex,
		GameObject *	target
	)

 {
  ASSERT(caster);
  ASSERT(target);
 
  GET_SCRIPT_RET(GameObjectScript, target->GetScriptId(), tmpscript, false);
  return tmpscript->OnDummyEffect(caster, spellId, effIndex, target);
 }

Here is the call graph for this function:

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

 {
  ASSERT(dynobj);
 
  FOR_SCRIPTS(DynamicObjectScript, itr, end)
  itr->second->OnUpdate(dynobj, diff);
 }

void ScriptMgr::OnEmailChange ( uint32 accountId )

 {
  FOREACH_SCRIPT(AccountScript)->OnEmailChange(accountId);
 }

void ScriptMgr::OnFailedAccountLogin ( uint32 accountId )

 {
  FOREACH_SCRIPT(AccountScript)->OnFailedAccountLogin(accountId);
 }

void ScriptMgr::OnFailedEmailChange ( uint32 accountId )

 {
  FOREACH_SCRIPT(AccountScript)->OnFailedEmailChange(accountId);
 }

void ScriptMgr::OnFailedPasswordChange ( uint32 accountId )

 {
  FOREACH_SCRIPT(AccountScript)->OnFailedPasswordChange(accountId);
 }

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

 {
  ASSERT(player);
  ASSERT(unit);
 
  FOREACH_SCRIPT(FormulaScript)->OnGainCalculation(gain, player, unit);
 }

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

 {
  ASSERT(go);
 
  GET_SCRIPT(GameObjectScript, go->GetScriptId(), tmpscript);
  tmpscript->OnDamaged(go, player);
 }

Here is the call graph for this function:

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

 {
  ASSERT(go);
 
  GET_SCRIPT(GameObjectScript, go->GetScriptId(), tmpscript);
  tmpscript->OnDestroyed(go, player);
 }

Here is the call graph for this function:

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

 {
  ASSERT(go);
 
  GET_SCRIPT(GameObjectScript, go->GetScriptId(), tmpscript);
  tmpscript->OnLootStateChanged(go, state, unit);
 }

Here is the call graph for this function:

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

 {
  ASSERT(go);
 
  GET_SCRIPT(GameObjectScript, go->GetScriptId(), tmpscript);
  tmpscript->OnGameObjectStateChanged(go, state);
 }

Here is the call graph for this function:

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

 {
  ASSERT(go);
 
  GET_SCRIPT(GameObjectScript, go->GetScriptId(), tmpscript);
  tmpscript->OnUpdate(go, diff);
 }

Here is the call graph for this function:

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

 {
  FOREACH_SCRIPT(PlayerScript)->OnGiveXP(player, amount, victim);
 }

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

 {
  ASSERT(player);
  ASSERT(creature);
 
  GET_SCRIPT_RET(CreatureScript, creature->GetScriptId(), tmpscript, false);
  player->PlayerTalkClass->ClearMenus();
  return tmpscript->OnGossipHello(player, creature);
 }

Here is the call graph for this function:

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

 {
  ASSERT(player);
  ASSERT(go);
 
  GET_SCRIPT_RET(GameObjectScript, go->GetScriptId(), tmpscript, false);
     player->PlayerTalkClass->ClearMenus();
     return tmpscript->OnGossipHello(player, go);
 }

Here is the call graph for this function:

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

 {
     ASSERT(player);
     ASSERT(creature);
 
     GET_SCRIPT_RET(CreatureScript, creature->GetScriptId(), tmpscript, false);
     return tmpscript->OnGossipSelect(player, creature, sender, action);
 }

Here is the call graph for this function:

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

 {
     ASSERT(player);
     ASSERT(go);
 
     GET_SCRIPT_RET(GameObjectScript, go->GetScriptId(), tmpscript, false);
     return tmpscript->OnGossipSelect(player, go, sender, action);
 }

Here is the call graph for this function:

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

 {
     ASSERT(player);
     ASSERT(creature);
     ASSERT(code);
 
     GET_SCRIPT_RET(CreatureScript, creature->GetScriptId(), tmpscript, false);
     return tmpscript->OnGossipSelectCode(player, creature, sender, action, code);
 }

Here is the call graph for this function:

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

 {
     ASSERT(player);
     ASSERT(go);
     ASSERT(code);
 
     GET_SCRIPT_RET(GameObjectScript, go->GetScriptId(), tmpscript, false);
     return tmpscript->OnGossipSelectCode(player, go, sender, action, code);
 }

Here is the call graph for this function:

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

 {
     FOREACH_SCRIPT(FormulaScript)->OnGrayLevelCalculation(grayLevel, playerLevel);
 }

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

 {
     ASSERT(group);
     FOREACH_SCRIPT(GroupScript)->OnAddMember(group, guid);
 }

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

 {
     ASSERT(group);
     FOREACH_SCRIPT(GroupScript)->OnChangeLeader(group, newLeaderGuid, oldLeaderGuid);
 }

void ScriptMgr::OnGroupDisband ( Group * group )

 {
     ASSERT(group);
     FOREACH_SCRIPT(GroupScript)->OnDisband(group);
 }

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

 {
     ASSERT(group);
     FOREACH_SCRIPT(GroupScript)->OnInviteMember(group, guid);
 }

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

 {
     FOREACH_SCRIPT(FormulaScript)->OnGroupRateCalculation(rate, count, isRaid);
 }

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

 {
     ASSERT(group);
     FOREACH_SCRIPT(GroupScript)->OnRemoveMember(group, guid, method, kicker, reason);
 }

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

 {
     FOREACH_SCRIPT(GuildScript)->OnAddMember(guild, player, plRank);
 }

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

 {
     FOREACH_SCRIPT(GuildScript)->OnBankEvent(guild, eventType, tabId, playerGuid, itemOrMoney, itemStackCount, destTabId);
 }

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

 {
     FOREACH_SCRIPT(GuildScript)->OnCreate(guild, leader, name);
 }

void ScriptMgr::OnGuildDisband ( Guild * guild )

 {
     FOREACH_SCRIPT(GuildScript)->OnDisband(guild);
 }

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

 {
     FOREACH_SCRIPT(GuildScript)->OnEvent(guild, eventType, playerGuid1, playerGuid2, newRank);
 }

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

 {
     FOREACH_SCRIPT(GuildScript)->OnInfoChanged(guild, newInfo);
 }

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

 {
     FOREACH_SCRIPT(GuildScript)->OnItemMove(guild, player, pItem, isSrcBank, srcContainer, srcSlotId, isDestBank, destContainer, destSlotId);
 }

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

 {
     FOREACH_SCRIPT(GuildScript)->OnMemberDepositMoney(guild, player, amount);
 }

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

 {
     FOREACH_SCRIPT(GuildScript)->OnMemberWitdrawMoney(guild, player, amount, isRepair);
 }

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

 {
     FOREACH_SCRIPT(GuildScript)->OnMOTDChanged(guild, newMotd);
 }

void ScriptMgr::OnGuildRemoveMember	(	Guild *	guild,
		ObjectGuid	guid,
		bool	isDisbanding,
		bool	isKicked
	)

 {
     FOREACH_SCRIPT(GuildScript)->OnRemoveMember(guild, guid, isDisbanding, isKicked);
 }

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

 {
     FOREACH_SCRIPT(UnitScript)->OnHeal(healer, reciever, gain);
 }

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

 {
     FOREACH_SCRIPT(FormulaScript)->OnHonorCalculation(honor, level, multiplier);
 }

void ScriptMgr::OnInstall ( Vehicle * veh )

 {
     ASSERT(veh);
     ASSERT(veh->GetBase()->GetTypeId() == TYPEID_UNIT);
 
     GET_SCRIPT(VehicleScript, veh->GetBase()->ToCreature()->GetScriptId(), tmpscript);
     tmpscript->OnInstall(veh);
 }

Here is the call graph for this function:

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

 {
     ASSERT(veh);
     ASSERT(veh->GetBase()->GetTypeId() == TYPEID_UNIT);
     ASSERT(accessory);
 
     GET_SCRIPT(VehicleScript, veh->GetBase()->ToCreature()->GetScriptId(), tmpscript);
     tmpscript->OnInstallAccessory(veh, accessory);
 }

Here is the call graph for this function:

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

 {
     ASSERT(player);
     ASSERT(proto);
 
     GET_SCRIPT_RET(ItemScript, proto->ScriptId, tmpscript, false);
     return tmpscript->OnExpire(player, proto);
 }

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

 {
     ASSERT(player);
     ASSERT(item);
 
     GET_SCRIPT_RET(ItemScript, item->GetScriptId(), tmpscript, false);
     return tmpscript->OnRemove(player, item);
 }

Here is the call graph for this function:

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

 {
     ASSERT(player);
     ASSERT(item);
 
     GET_SCRIPT_RET(ItemScript, item->GetScriptId(), tmpscript, false);
     return tmpscript->OnUse(player, item, targets);
 }

Here is the call graph for this function:

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

 {
     ASSERT(map);
     ASSERT(gmap);
 
     SCR_MAP_BGN(WorldMapScript, map, itr, end, entry, IsWorldMap);
         itr->second->OnLoadGridMap(map, gmap, gx, gy);
     SCR_MAP_END;
 
     SCR_MAP_BGN(InstanceMapScript, map, itr, end, entry, IsDungeon);
         itr->second->OnLoadGridMap((InstanceMap*)map, gmap, gx, gy);
     SCR_MAP_END;
 
     SCR_MAP_BGN(BattlegroundMapScript, map, itr, end, entry, IsBattleground);
         itr->second->OnLoadGridMap((BattlegroundMap*)map, gmap, gx, gy);
     SCR_MAP_END;
 }

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

 {
     ASSERT(map);
 
     SCR_MAP_BGN(WorldMapScript, map, itr, end, entry, IsWorldMap);
         itr->second->OnUpdate(map, diff);
     SCR_MAP_END;
 
     SCR_MAP_BGN(InstanceMapScript, map, itr, end, entry, IsDungeon);
         itr->second->OnUpdate((InstanceMap*)map, diff);
     SCR_MAP_END;
 
     SCR_MAP_BGN(BattlegroundMapScript, map, itr, end, entry, IsBattleground);
         itr->second->OnUpdate((BattlegroundMap*)map, diff);
     SCR_MAP_END;
 }

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

 {
     FOREACH_SCRIPT(WorldScript)->OnMotdChange(newMotd);
 }

void ScriptMgr::OnNetworkStart ( )

 {
     FOREACH_SCRIPT(ServerScript)->OnNetworkStart();
 }

void ScriptMgr::OnNetworkStop ( )

 {
     FOREACH_SCRIPT(ServerScript)->OnNetworkStop();
 }

void ScriptMgr::OnOpenStateChange ( bool open )

 {
     FOREACH_SCRIPT(WorldScript)->OnOpenStateChange(open);
 }

void ScriptMgr::OnPacketReceive	(	WorldSession *	session,
		WorldPacket const &	packet
	)

 {
     if (SCR_REG_LST(ServerScript).empty())
         return;
 
     WorldPacket copy(packet);
     FOREACH_SCRIPT(ServerScript)->OnPacketReceive(session, copy);
 }

void ScriptMgr::OnPacketSend	(	WorldSession *	session,
		WorldPacket const &	packet
	)

 {
     ASSERT(session);
 
     if (SCR_REG_LST(ServerScript).empty())
         return;
 
     WorldPacket copy(packet);
     FOREACH_SCRIPT(ServerScript)->OnPacketSend(session, copy);
 }

void ScriptMgr::OnPasswordChange ( uint32 accountId )

 {
     FOREACH_SCRIPT(AccountScript)->OnPasswordChange(accountId);
 }

void ScriptMgr::OnPlayerBindToInstance	(	Player *	player,
		Difficulty	difficulty,
		uint32	mapid,
		bool	permanent,
		uint8	extendState
	)

 {
     FOREACH_SCRIPT(PlayerScript)->OnBindToInstance(player, difficulty, mapid, permanent, extendState);
 }

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

 {
     FOREACH_SCRIPT(PlayerScript)->OnChat(player, type, lang, msg);
 }

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

 {
     FOREACH_SCRIPT(PlayerScript)->OnChat(player, type, lang, msg, receiver);
 }

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

 {
     FOREACH_SCRIPT(PlayerScript)->OnChat(player, type, lang, msg, group);
 }

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

 {
     FOREACH_SCRIPT(PlayerScript)->OnChat(player, type, lang, msg, guild);
 }

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

 {
     FOREACH_SCRIPT(PlayerScript)->OnChat(player, type, lang, msg, channel);
 }

void ScriptMgr::OnPlayerClearEmote ( Player * player )

 {
     FOREACH_SCRIPT(PlayerScript)->OnClearEmote(player);
 }

void ScriptMgr::OnPlayerCreate ( Player * player )

 {
     FOREACH_SCRIPT(PlayerScript)->OnCreate(player);
 }

void ScriptMgr::OnPlayerDelete	(	ObjectGuid	guid,
		uint32	accountId
	)

 {
     FOREACH_SCRIPT(PlayerScript)->OnDelete(guid, accountId);
 }

void ScriptMgr::OnPlayerDuelEnd	(	Player *	winner,
		Player *	loser,
		DuelCompleteType	type
	)

 {
     FOREACH_SCRIPT(PlayerScript)->OnDuelEnd(winner, loser, type);
 }

void ScriptMgr::OnPlayerDuelRequest	(	Player *	target,
		Player *	challenger
	)

 {
     FOREACH_SCRIPT(PlayerScript)->OnDuelRequest(target, challenger);
 }

void ScriptMgr::OnPlayerDuelStart	(	Player *	player1,
		Player *	player2
	)

 {
     FOREACH_SCRIPT(PlayerScript)->OnDuelStart(player1, player2);
 }

void ScriptMgr::OnPlayerEnterMap	(	Map *	map,
		Player *	player
	)

 {
     ASSERT(map);
     ASSERT(player);
 
     FOREACH_SCRIPT(PlayerScript)->OnMapChanged(player);
 
     SCR_MAP_BGN(WorldMapScript, map, itr, end, entry, IsWorldMap);
         itr->second->OnPlayerEnter(map, player);
     SCR_MAP_END;
 
     SCR_MAP_BGN(InstanceMapScript, map, itr, end, entry, IsDungeon);
         itr->second->OnPlayerEnter((InstanceMap*)map, player);
     SCR_MAP_END;
 
     SCR_MAP_BGN(BattlegroundMapScript, map, itr, end, entry, IsBattleground);
         itr->second->OnPlayerEnter((BattlegroundMap*)map, player);
     SCR_MAP_END;
 }

void ScriptMgr::OnPlayerFailedDelete	(	ObjectGuid	guid,
		uint32	accountId
	)

 {
     FOREACH_SCRIPT(PlayerScript)->OnFailedDelete(guid, accountId);
 }

void ScriptMgr::OnPlayerFreeTalentPointsChanged	(	Player *	player,
		uint32	newPoints
	)

 {
     FOREACH_SCRIPT(PlayerScript)->OnFreeTalentPointsChanged(player, points);
 }

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

 {
     FOREACH_SCRIPT(PlayerScript)->OnPlayerKilledByCreature(killer, killed);
 }

void ScriptMgr::OnPlayerLeaveMap	(	Map *	map,
		Player *	player
	)

 {
     ASSERT(map);
     ASSERT(player);
 
     SCR_MAP_BGN(WorldMapScript, map, itr, end, entry, IsWorldMap);
         itr->second->OnPlayerLeave(map, player);
     SCR_MAP_END;
 
     SCR_MAP_BGN(InstanceMapScript, map, itr, end, entry, IsDungeon);
         itr->second->OnPlayerLeave((InstanceMap*)map, player);
     SCR_MAP_END;
 
     SCR_MAP_BGN(BattlegroundMapScript, map, itr, end, entry, IsBattleground);
         itr->second->OnPlayerLeave((BattlegroundMap*)map, player);
     SCR_MAP_END;
 }

void ScriptMgr::OnPlayerLevelChanged	(	Player *	player,
		uint8	oldLevel
	)

 {
     FOREACH_SCRIPT(PlayerScript)->OnLevelChanged(player, oldLevel);
 }

void ScriptMgr::OnPlayerLogin	(	Player *	player,
		bool	firstLogin
	)

 {
     FOREACH_SCRIPT(PlayerScript)->OnLogin(player, firstLogin);
 }

void ScriptMgr::OnPlayerLogout ( Player * player )

 {
     FOREACH_SCRIPT(PlayerScript)->OnLogout(player);
 }

void ScriptMgr::OnPlayerMoneyChanged	(	Player *	player,
		int64 &	amount
	)

 {
     FOREACH_SCRIPT(PlayerScript)->OnMoneyChanged(player, amount);
 }

void ScriptMgr::OnPlayerMoneyLimit	(	Player *	player,
		int64	amount
	)

 {
     FOREACH_SCRIPT(PlayerScript)->OnMoneyLimit(player, amount);
 }

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

 {
     FOREACH_SCRIPT(PlayerScript)->OnReputationChange(player, factionID, standing, incremental);
 }

void ScriptMgr::OnPlayerSave ( Player * player )

 {
     FOREACH_SCRIPT(PlayerScript)->OnSave(player);
 }

void ScriptMgr::OnPlayerSpellCast	(	Player *	player,
		Spell *	spell,
		bool	skipCheck
	)

 {
     FOREACH_SCRIPT(PlayerScript)->OnSpellCast(player, spell, skipCheck);
 }

void ScriptMgr::OnPlayerTalentsReset	(	Player *	player,
		bool	noCost
	)

 {
     FOREACH_SCRIPT(PlayerScript)->OnTalentsReset(player, noCost);
 }

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

 {
     FOREACH_SCRIPT(PlayerScript)->OnTextEmote(player, textEmote, emoteNum, guid);
 }

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

 {
     FOREACH_SCRIPT(PlayerScript)->OnUpdateZone(player, newZone, newArea);
 }

void ScriptMgr::OnPVPKill	(	Player *	killer,
		Player *	killed
	)

 {
     FOREACH_SCRIPT(PlayerScript)->OnPVPKill(killer, killed);
 }

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

 {
     ASSERT(player);
     ASSERT(item);
     ASSERT(quest);
 
     GET_SCRIPT_RET(ItemScript, item->GetScriptId(), tmpscript, false);
     player->PlayerTalkClass->ClearMenus();
     return tmpscript->OnQuestAccept(player, item, quest);
 }

Here is the call graph for this function:

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

 {
     ASSERT(player);
     ASSERT(creature);
     ASSERT(quest);
 
     GET_SCRIPT_RET(CreatureScript, creature->GetScriptId(), tmpscript, false);
     player->PlayerTalkClass->ClearMenus();
     return tmpscript->OnQuestAccept(player, creature, quest);
 }

Here is the call graph for this function:

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

 {
     ASSERT(player);
     ASSERT(go);
     ASSERT(quest);
 
     GET_SCRIPT_RET(GameObjectScript, go->GetScriptId(), tmpscript, false);
     player->PlayerTalkClass->ClearMenus();
     return tmpscript->OnQuestAccept(player, go, quest);
 }

Here is the call graph for this function:

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

 {
     ASSERT(player);
     ASSERT(creature);
     ASSERT(quest);
 
     GET_SCRIPT_RET(CreatureScript, creature->GetScriptId(), tmpscript, false);
     player->PlayerTalkClass->ClearMenus();
     return tmpscript->OnQuestReward(player, creature, quest, opt);
 }

Here is the call graph for this function:

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

 {
     ASSERT(player);
     ASSERT(go);
     ASSERT(quest);
 
     GET_SCRIPT_RET(GameObjectScript, go->GetScriptId(), tmpscript, false);
     player->PlayerTalkClass->ClearMenus();
     return tmpscript->OnQuestReward(player, go, quest, opt);
 }

Here is the call graph for this function:

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

 {
     ASSERT(player);
     ASSERT(creature);
     ASSERT(quest);
 
     GET_SCRIPT_RET(CreatureScript, creature->GetScriptId(), tmpscript, false);
     player->PlayerTalkClass->ClearMenus();
     return tmpscript->OnQuestSelect(player, creature, quest);
 }

Here is the call graph for this function:

void ScriptMgr::OnQuestStatusChange	(	Player *	player,
		uint32	questId,
		QuestStatus	status
	)

 {
     FOREACH_SCRIPT(PlayerScript)->OnQuestStatusChange(player, questId, status);
 }

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

 {
     GET_SCRIPT(TransportScript, transport->GetScriptId(), tmpscript);
     tmpscript->OnRelocate(transport, waypointId, mapId, x, y, z);
 }

Here is the call graph for this function:

void ScriptMgr::OnRemovePassenger	(	Vehicle *	veh,
		Unit *	passenger
	)

 {
     ASSERT(veh);
     ASSERT(veh->GetBase()->GetTypeId() == TYPEID_UNIT);
     ASSERT(passenger);
 
     GET_SCRIPT(VehicleScript, veh->GetBase()->ToCreature()->GetScriptId(), tmpscript);
     tmpscript->OnRemovePassenger(veh, passenger);
 }

Here is the call graph for this function:

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

 {
     ASSERT(transport);
     ASSERT(player);
 
     GET_SCRIPT(TransportScript, transport->GetScriptId(), tmpscript);
     tmpscript->OnRemovePassenger(transport, player);
 }

Here is the call graph for this function:

void ScriptMgr::OnReset ( Vehicle * veh )

 {
     ASSERT(veh);
     ASSERT(veh->GetBase()->GetTypeId() == TYPEID_UNIT);
 
     GET_SCRIPT(VehicleScript, veh->GetBase()->ToCreature()->GetScriptId(), tmpscript);
     tmpscript->OnReset(veh);
 }

Here is the call graph for this function:

void ScriptMgr::OnShutdown ( )

 {
     FOREACH_SCRIPT(WorldScript)->OnShutdown();
 }

void ScriptMgr::OnShutdownCancel ( )

 {
     FOREACH_SCRIPT(WorldScript)->OnShutdownCancel();
 }

void ScriptMgr::OnShutdownInitiate	(	ShutdownExitCode	code,
		ShutdownMask	mask
	)

 {
     FOREACH_SCRIPT(WorldScript)->OnShutdownInitiate(code, mask);
 }

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

 {
     ASSERT(socket);
 
     FOREACH_SCRIPT(ServerScript)->OnSocketClose(socket);
 }

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

 {
     ASSERT(socket);
 
     FOREACH_SCRIPT(ServerScript)->OnSocketOpen(socket);
 }

void ScriptMgr::OnStartup ( )

 {
     FOREACH_SCRIPT(WorldScript)->OnStartup();
 }

void ScriptMgr::OnTransportUpdate	(	Transport *	transport,
		uint32	diff
	)

 {
     ASSERT(transport);
 
     GET_SCRIPT(TransportScript, transport->GetScriptId(), tmpscript);
     tmpscript->OnUpdate(transport, diff);
 }

Here is the call graph for this function:

void ScriptMgr::OnUninstall ( Vehicle * veh )

 {
     ASSERT(veh);
     ASSERT(veh->GetBase()->GetTypeId() == TYPEID_UNIT);
 
     GET_SCRIPT(VehicleScript, veh->GetBase()->ToCreature()->GetScriptId(), tmpscript);
     tmpscript->OnUninstall(veh);
 }

Here is the call graph for this function:

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

 {
     ASSERT(map);
     ASSERT(gmap);
 
     SCR_MAP_BGN(WorldMapScript, map, itr, end, entry, IsWorldMap);
         itr->second->OnUnloadGridMap(map, gmap, gx, gy);
     SCR_MAP_END;
 
     SCR_MAP_BGN(InstanceMapScript, map, itr, end, entry, IsDungeon);
         itr->second->OnUnloadGridMap((InstanceMap*)map, gmap, gx, gy);
     SCR_MAP_END;
 
     SCR_MAP_BGN(BattlegroundMapScript, map, itr, end, entry, IsBattleground);
         itr->second->OnUnloadGridMap((BattlegroundMap*)map, gmap, gx, gy);
     SCR_MAP_END;
 }

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

 {
     ASSERT(weather);
 
     GET_SCRIPT(WeatherScript, weather->GetScriptId(), tmpscript);
     tmpscript->OnChange(weather, state, grade);
 }

Here is the call graph for this function:

void ScriptMgr::OnWeatherUpdate	(	Weather *	weather,
		uint32	diff
	)

 {
     ASSERT(weather);
 
     GET_SCRIPT(WeatherScript, weather->GetScriptId(), tmpscript);
     tmpscript->OnUpdate(weather, diff);
 }

Here is the call graph for this function:

void ScriptMgr::OnWorldUpdate ( uint32 diff )

 {
     FOREACH_SCRIPT(WorldScript)->OnUpdate(diff);
 }

void ScriptMgr::OnZeroDifferenceCalculation	(	uint8 &	diff,
		uint8	playerLevel
	)

 {
     FOREACH_SCRIPT(FormulaScript)->OnZeroDifferenceCalculation(diff, playerLevel);
 }

const char* ScriptMgr::ScriptsVersion ( ) const

inline

861 { return "Integrated Trinity Scripts"; }

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

void ScriptMgr::Unload ( )

 {
     #define SCR_CLEAR(T) \
         for (T* scr : SCR_REG_VEC(T)) \
             delete scr; \
         SCR_REG_VEC(T).clear();
 
     // Clear scripts for every script type.
     SCR_CLEAR(SpellScriptLoader);
     SCR_CLEAR(ServerScript);
     SCR_CLEAR(WorldScript);
     SCR_CLEAR(FormulaScript);
     SCR_CLEAR(WorldMapScript);
     SCR_CLEAR(InstanceMapScript);
     SCR_CLEAR(BattlegroundMapScript);
     SCR_CLEAR(ItemScript);
     SCR_CLEAR(CreatureScript);
     SCR_CLEAR(GameObjectScript);
     SCR_CLEAR(AreaTriggerScript);
     SCR_CLEAR(BattlegroundScript);
     SCR_CLEAR(OutdoorPvPScript);
     SCR_CLEAR(CommandScript);
     SCR_CLEAR(WeatherScript);
     SCR_CLEAR(AuctionHouseScript);
     SCR_CLEAR(ConditionScript);
     SCR_CLEAR(VehicleScript);
     SCR_CLEAR(DynamicObjectScript);
     SCR_CLEAR(TransportScript);
     SCR_CLEAR(AchievementCriteriaScript);
     SCR_CLEAR(PlayerScript);
     SCR_CLEAR(AccountScript);
     SCR_CLEAR(GuildScript);
     SCR_CLEAR(GroupScript);
     SCR_CLEAR(UnitScript);
 
     #undef SCR_CLEAR
 
     delete[] SpellSummary;
     delete[] UnitAI::AISpellInfo;
 }

Friends And Related Function Documentation

friend class ScriptObject

friend

Member Data Documentation

std::atomic<uint64> ScriptMgr::_scheduledScripts

private

ScriptLoaderCallbackType ScriptMgr::_script_loader_callback

private

uint32 ScriptMgr::_scriptCount

private

The documentation for this class was generated from the following files:

src/server/game/Scripting/ScriptMgr.h
src/server/game/Scripting/ScriptMgr.cpp

Public Types

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Friends

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation