/* * This file is part of the AzerothCore Project. See AUTHORS file for Copyright information * * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License as published by the * Free Software Foundation; either version 2 of the License, or (at your * option) any later version. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for * more details. * * You should have received a copy of the GNU General Public License along * with this program. If not, see . */ #include "Chat.h" #include "ElunaEventMgr.h" #include "ElunaScript.h" #include "Log.h" #include "LuaEngine.h" #include "Pet.h" #include "Player.h" #include "ScriptMgr.h" #include "ScriptedGossip.h" class Eluna_AllCreatureScript : public AllCreatureScript { public: Eluna_AllCreatureScript() : AllCreatureScript("Eluna_AllCreatureScript") {} // Creature bool CanCreatureGossipHello(Player *player, Creature *creature) override { if (sEluna->OnGossipHello(player, creature)) return true; return false; } bool CanCreatureGossipSelect(Player *player, Creature *creature, uint32 sender, uint32 action) override { if (sEluna->OnGossipSelect(player, creature, sender, action)) return true; return false; } bool CanCreatureGossipSelectCode(Player *player, Creature *creature, uint32 sender, uint32 action, const char *code) override { if (sEluna->OnGossipSelectCode(player, creature, sender, action, code)) return true; return false; } void OnCreatureAddWorld(Creature *creature) override { sEluna->OnAddToWorld(creature); if (creature->IsGuardian() && creature->ToTempSummon() && creature->ToTempSummon()->GetSummonerGUID().IsPlayer()) sEluna->OnPetAddedToWorld(creature->ToTempSummon()->GetSummonerUnit()->ToPlayer(), creature); } void OnCreatureRemoveWorld(Creature *creature) override { sEluna->OnRemoveFromWorld(creature); } bool CanCreatureQuestAccept(Player *player, Creature *creature, Quest const *quest) override { sEluna->OnPlayerQuestAccept(player, quest); sEluna->OnQuestAccept(player, creature, quest); return false; } bool CanCreatureQuestReward(Player *player, Creature *creature, Quest const *quest, uint32 opt) override { if (sEluna->OnQuestReward(player, creature, quest, opt)) { ClearGossipMenuFor(player); return true; } return false; } CreatureAI *GetCreatureAI(Creature *creature) const override { if (CreatureAI *luaAI = sEluna->GetAI(creature)) return luaAI; return nullptr; } }; class Eluna_AllGameObjectScript : public AllGameObjectScript { public: Eluna_AllGameObjectScript() : AllGameObjectScript("Eluna_AllGameObjectScript") {} void OnGameObjectAddWorld(GameObject *go) override { sEluna->OnAddToWorld(go); } void OnGameObjectRemoveWorld(GameObject *go) override { sEluna->OnRemoveFromWorld(go); } void OnGameObjectUpdate(GameObject *go, uint32 diff) override { sEluna->UpdateAI(go, diff); } bool CanGameObjectGossipHello(Player *player, GameObject *go) override { if (sEluna->OnGossipHello(player, go)) return true; if (sEluna->OnGameObjectUse(player, go)) return true; return false; } void OnGameObjectDamaged(GameObject *go, Player *player) override { sEluna->OnDamaged(go, player); } void OnGameObjectDestroyed(GameObject *go, Player *player) override { sEluna->OnDestroyed(go, player); } void OnGameObjectLootStateChanged(GameObject *go, uint32 state, Unit * /*unit*/) override { sEluna->OnLootStateChanged(go, state); } void OnGameObjectStateChanged(GameObject *go, uint32 state) override { sEluna->OnGameObjectStateChanged(go, state); } bool CanGameObjectQuestAccept(Player *player, GameObject *go, Quest const *quest) override { sEluna->OnPlayerQuestAccept(player, quest); sEluna->OnQuestAccept(player, go, quest); return false; } bool CanGameObjectGossipSelect(Player *player, GameObject *go, uint32 sender, uint32 action) override { if (sEluna->OnGossipSelect(player, go, sender, action)) return true; return false; } bool CanGameObjectGossipSelectCode(Player *player, GameObject *go, uint32 sender, uint32 action, const char *code) override { if (sEluna->OnGossipSelectCode(player, go, sender, action, code)) return true; return false; } bool CanGameObjectQuestReward(Player *player, GameObject *go, Quest const *quest, uint32 opt) override { if (sEluna->OnQuestAccept(player, go, quest)) { sEluna->OnPlayerQuestAccept(player, quest); return false; } if (sEluna->OnQuestReward(player, go, quest, opt)) return false; return true; } GameObjectAI *GetGameObjectAI(GameObject *go) const override { sEluna->OnSpawn(go); return nullptr; } }; class Eluna_AllItemScript : public AllItemScript { public: Eluna_AllItemScript() : AllItemScript("Eluna_AllItemScript") {} bool CanItemQuestAccept(Player *player, Item *item, Quest const *quest) override { if (sEluna->OnQuestAccept(player, item, quest)) { sEluna->OnPlayerQuestAccept(player, quest); return false; } return true; } bool CanItemUse(Player *player, Item *item, SpellCastTargets const &targets) override { if (!sEluna->OnUse(player, item, targets)) return true; return false; } bool CanItemExpire(Player *player, ItemTemplate const *proto) override { if (sEluna->OnExpire(player, proto)) return false; return true; } bool CanItemRemove(Player *player, Item *item) override { if (sEluna->OnRemove(player, item)) return false; return true; } void OnItemGossipSelect(Player *player, Item *item, uint32 sender, uint32 action) override { sEluna->HandleGossipSelectOption(player, item, sender, action, ""); } void OnItemGossipSelectCode(Player *player, Item *item, uint32 sender, uint32 action, const char *code) override { sEluna->HandleGossipSelectOption(player, item, sender, action, code); } }; class Eluna_AllMapScript : public AllMapScript { public: Eluna_AllMapScript() : AllMapScript("Eluna_AllMapScript", {ALLMAPHOOK_ON_BEFORE_CREATE_INSTANCE_SCRIPT, ALLMAPHOOK_ON_DESTROY_INSTANCE, ALLMAPHOOK_ON_CREATE_MAP, ALLMAPHOOK_ON_DESTROY_MAP, ALLMAPHOOK_ON_PLAYER_ENTER_ALL, ALLMAPHOOK_ON_PLAYER_LEAVE_ALL, ALLMAPHOOK_ON_MAP_UPDATE}) {} void OnBeforeCreateInstanceScript(InstanceMap *instanceMap, InstanceScript **instanceData, bool /*load*/, std::string /*data*/, uint32 /*completedEncounterMask*/) override { if (instanceData) *instanceData = sEluna->GetInstanceData(instanceMap); } void OnDestroyInstance(MapInstanced * /*mapInstanced*/, Map *map) override { sEluna->FreeInstanceId(map->GetInstanceId()); } void OnCreateMap(Map *map) override { sEluna->OnCreate(map); } void OnDestroyMap(Map *map) override { sEluna->OnDestroy(map); } void OnPlayerEnterAll(Map *map, Player *player) override { sEluna->OnPlayerEnter(map, player); } void OnPlayerLeaveAll(Map *map, Player *player) override { sEluna->OnPlayerLeave(map, player); } void OnMapUpdate(Map *map, uint32 diff) override { sEluna->OnUpdate(map, diff); } }; class Eluna_AuctionHouseScript : public AuctionHouseScript { public: Eluna_AuctionHouseScript() : AuctionHouseScript("Eluna_AuctionHouseScript", {AUCTIONHOUSEHOOK_ON_AUCTION_ADD, AUCTIONHOUSEHOOK_ON_AUCTION_REMOVE, AUCTIONHOUSEHOOK_ON_AUCTION_SUCCESSFUL, AUCTIONHOUSEHOOK_ON_AUCTION_EXPIRE}) {} void OnAuctionAdd(AuctionHouseObject *ah, AuctionEntry *entry) override { sEluna->OnAdd(ah, entry); } void OnAuctionRemove(AuctionHouseObject *ah, AuctionEntry *entry) override { sEluna->OnRemove(ah, entry); } void OnAuctionSuccessful(AuctionHouseObject *ah, AuctionEntry *entry) override { sEluna->OnSuccessful(ah, entry); } void OnAuctionExpire(AuctionHouseObject *ah, AuctionEntry *entry) override { sEluna->OnExpire(ah, entry); } }; class Eluna_BGScript : public BGScript { public: Eluna_BGScript() : BGScript("Eluna_BGScript", {ALLBATTLEGROUNDHOOK_ON_BATTLEGROUND_START, ALLBATTLEGROUNDHOOK_ON_BATTLEGROUND_END, ALLBATTLEGROUNDHOOK_ON_BATTLEGROUND_DESTROY, ALLBATTLEGROUNDHOOK_ON_BATTLEGROUND_CREATE}) {} void OnBattlegroundStart(Battleground *bg) override { sEluna->OnBGStart(bg, bg->GetBgTypeID(), bg->GetInstanceID()); } void OnBattlegroundEnd(Battleground *bg, TeamId winnerTeam) override { sEluna->OnBGEnd(bg, bg->GetBgTypeID(), bg->GetInstanceID(), winnerTeam); } void OnBattlegroundDestroy(Battleground *bg) override { sEluna->OnBGDestroy(bg, bg->GetBgTypeID(), bg->GetInstanceID()); } void OnBattlegroundCreate(Battleground *bg) override { sEluna->OnBGCreate(bg, bg->GetBgTypeID(), bg->GetInstanceID()); } }; class Eluna_CommandSC : public CommandSC { public: Eluna_CommandSC() : CommandSC("Eluna_CommandSC", {ALLCOMMANDHOOK_ON_TRY_EXECUTE_COMMAND}) {} bool OnTryExecuteCommand(ChatHandler &handler, std::string_view cmdStr) override { if (!sEluna->OnCommand(handler, std::string(cmdStr).c_str())) { return false; } return true; } }; class Eluna_ElunaScript : public ElunaScript { public: Eluna_ElunaScript() : ElunaScript("Eluna_ElunaScript") {} // Weather void OnWeatherChange(Weather *weather, WeatherState state, float grade) override { sEluna->OnChange(weather, weather->GetZone(), state, grade); } // AreaTriger bool CanAreaTrigger(Player *player, AreaTrigger const *trigger) override { if (sEluna->OnAreaTrigger(player, trigger)) return true; return false; } }; class Eluna_GameEventScript : public GameEventScript { public: Eluna_GameEventScript() : GameEventScript("Eluna_GameEventScript", {GAMEEVENTHOOK_ON_START, GAMEEVENTHOOK_ON_STOP}) {} void OnStart(uint16 eventID) override { sEluna->OnGameEventStart(eventID); } void OnStop(uint16 eventID) override { sEluna->OnGameEventStop(eventID); } }; class Eluna_GroupScript : public GroupScript { public: Eluna_GroupScript() : GroupScript("Eluna_GroupScript", {GROUPHOOK_ON_ADD_MEMBER, GROUPHOOK_ON_INVITE_MEMBER, GROUPHOOK_ON_REMOVE_MEMBER, GROUPHOOK_ON_CHANGE_LEADER, GROUPHOOK_ON_DISBAND, GROUPHOOK_ON_CREATE}) {} void OnAddMember(Group *group, ObjectGuid guid) override { sEluna->OnAddMember(group, guid); } void OnInviteMember(Group *group, ObjectGuid guid) override { sEluna->OnInviteMember(group, guid); } void OnRemoveMember(Group *group, ObjectGuid guid, RemoveMethod method, ObjectGuid /* kicker */, const char * /* reason */) override { sEluna->OnRemoveMember(group, guid, method); } void OnChangeLeader(Group *group, ObjectGuid newLeaderGuid, ObjectGuid oldLeaderGuid) override { sEluna->OnChangeLeader(group, newLeaderGuid, oldLeaderGuid); } void OnDisband(Group *group) override { sEluna->OnDisband(group); } void OnCreate(Group *group, Player *leader) override { sEluna->OnCreate(group, leader->GetGUID(), group->GetGroupType()); } }; class Eluna_GuildScript : public GuildScript { public: Eluna_GuildScript() : GuildScript("Eluna_GuildScript", {GUILDHOOK_ON_ADD_MEMBER, GUILDHOOK_ON_REMOVE_MEMBER, GUILDHOOK_ON_MOTD_CHANGED, GUILDHOOK_ON_INFO_CHANGED, GUILDHOOK_ON_CREATE, GUILDHOOK_ON_DISBAND, GUILDHOOK_ON_MEMBER_WITDRAW_MONEY, GUILDHOOK_ON_MEMBER_DEPOSIT_MONEY, GUILDHOOK_ON_ITEM_MOVE, GUILDHOOK_ON_EVENT, GUILDHOOK_ON_BANK_EVENT}) {} void OnAddMember(Guild *guild, Player *player, uint8 &plRank) override { sEluna->OnAddMember(guild, player, plRank); } void OnRemoveMember(Guild *guild, Player *player, bool isDisbanding, bool /*isKicked*/) override { sEluna->OnRemoveMember(guild, player, isDisbanding); } void OnMOTDChanged(Guild *guild, const std::string &newMotd) override { sEluna->OnMOTDChanged(guild, newMotd); } void OnInfoChanged(Guild *guild, const std::string &newInfo) override { sEluna->OnInfoChanged(guild, newInfo); } void OnCreate(Guild *guild, Player *leader, const std::string &name) override { sEluna->OnCreate(guild, leader, name); } void OnDisband(Guild *guild) override { sEluna->OnDisband(guild); } void OnMemberWitdrawMoney(Guild *guild, Player *player, uint32 &amount, bool isRepair) override { sEluna->OnMemberWitdrawMoney(guild, player, amount, isRepair); } void OnMemberDepositMoney(Guild *guild, Player *player, uint32 &amount) override { sEluna->OnMemberDepositMoney(guild, player, amount); } void OnItemMove(Guild *guild, Player *player, Item *pItem, bool isSrcBank, uint8 srcContainer, uint8 srcSlotId, bool isDestBank, uint8 destContainer, uint8 destSlotId) override { sEluna->OnItemMove(guild, player, pItem, isSrcBank, srcContainer, srcSlotId, isDestBank, destContainer, destSlotId); } void OnEvent(Guild *guild, uint8 eventType, ObjectGuid::LowType playerGuid1, ObjectGuid::LowType playerGuid2, uint8 newRank) override { sEluna->OnEvent(guild, eventType, playerGuid1, playerGuid2, newRank); } void OnBankEvent(Guild *guild, uint8 eventType, uint8 tabId, ObjectGuid::LowType playerGuid, uint32 itemOrMoney, uint16 itemStackCount, uint8 destTabId) override { sEluna->OnBankEvent(guild, eventType, tabId, playerGuid, itemOrMoney, itemStackCount, destTabId); } }; class Eluna_LootScript : public LootScript { public: Eluna_LootScript() : LootScript("Eluna_LootScript", {LOOTHOOK_ON_LOOT_MONEY}) {} void OnLootMoney(Player *player, uint32 gold) override { sEluna->OnLootMoney(player, gold); } }; class Eluna_MiscScript : public MiscScript { public: Eluna_MiscScript() : MiscScript("Eluna_MiscScript", {MISCHOOK_GET_DIALOG_STATUS}) {} void GetDialogStatus(Player *player, Object *questgiver) override { if (questgiver->GetTypeId() == TYPEID_GAMEOBJECT) sEluna->GetDialogStatus(player, questgiver->ToGameObject()); else if (questgiver->GetTypeId() == TYPEID_UNIT) sEluna->GetDialogStatus(player, questgiver->ToCreature()); } }; class Eluna_PetScript : public PetScript { public: Eluna_PetScript() : PetScript("Eluna_PetScript", {PETHOOK_ON_PET_ADD_TO_WORLD}) {} void OnPetAddToWorld(Pet *pet) override { sEluna->OnPetAddedToWorld(pet->GetOwner(), pet); } }; class Eluna_PlayerScript : public PlayerScript { public: Eluna_PlayerScript() : PlayerScript("Eluna_PlayerScript", {PLAYERHOOK_ON_PLAYER_RESURRECT, PLAYERHOOK_CAN_PLAYER_USE_CHAT, PLAYERHOOK_CAN_PLAYER_USE_PRIVATE_CHAT, PLAYERHOOK_CAN_PLAYER_USE_GROUP_CHAT, PLAYERHOOK_CAN_PLAYER_USE_GUILD_CHAT, PLAYERHOOK_CAN_PLAYER_USE_CHANNEL_CHAT, PLAYERHOOK_ON_LOOT_ITEM, PLAYERHOOK_ON_PLAYER_LEARN_TALENTS, PLAYERHOOK_CAN_USE_ITEM, PLAYERHOOK_ON_EQUIP, PLAYERHOOK_ON_PLAYER_ENTER_COMBAT, PLAYERHOOK_ON_PLAYER_LEAVE_COMBAT, PLAYERHOOK_CAN_REPOP_AT_GRAVEYARD, PLAYERHOOK_ON_QUEST_ABANDON, PLAYERHOOK_ON_MAP_CHANGED, PLAYERHOOK_ON_GOSSIP_SELECT, PLAYERHOOK_ON_GOSSIP_SELECT_CODE, PLAYERHOOK_ON_PVP_KILL, PLAYERHOOK_ON_CREATURE_KILL, PLAYERHOOK_ON_PLAYER_KILLED_BY_CREATURE, PLAYERHOOK_ON_LEVEL_CHANGED, PLAYERHOOK_ON_FREE_TALENT_POINTS_CHANGED, PLAYERHOOK_ON_TALENTS_RESET, PLAYERHOOK_ON_MONEY_CHANGED, PLAYERHOOK_ON_GIVE_EXP, PLAYERHOOK_ON_REPUTATION_CHANGE, PLAYERHOOK_ON_DUEL_REQUEST, PLAYERHOOK_ON_DUEL_START, PLAYERHOOK_ON_DUEL_END, PLAYERHOOK_ON_EMOTE, PLAYERHOOK_ON_TEXT_EMOTE, PLAYERHOOK_ON_SPELL_CAST, PLAYERHOOK_ON_LOGIN, PLAYERHOOK_ON_LOGOUT, PLAYERHOOK_ON_CREATE, PLAYERHOOK_ON_SAVE, PLAYERHOOK_ON_DELETE, PLAYERHOOK_ON_BIND_TO_INSTANCE, PLAYERHOOK_ON_UPDATE_AREA, PLAYERHOOK_ON_UPDATE_ZONE, PLAYERHOOK_ON_FIRST_LOGIN, PLAYERHOOK_ON_LEARN_SPELL, PLAYERHOOK_ON_ACHI_COMPLETE, PLAYERHOOK_ON_FFA_PVP_STATE_UPDATE, PLAYERHOOK_CAN_INIT_TRADE, PLAYERHOOK_CAN_SEND_MAIL, PLAYERHOOK_CAN_JOIN_LFG, PLAYERHOOK_ON_QUEST_REWARD_ITEM, PLAYERHOOK_ON_GROUP_ROLL_REWARD_ITEM, PLAYERHOOK_ON_CREATE_ITEM, PLAYERHOOK_ON_STORE_NEW_ITEM, PLAYERHOOK_ON_PLAYER_COMPLETE_QUEST, PLAYERHOOK_CAN_GROUP_INVITE, PLAYERHOOK_ON_BATTLEGROUND_DESERTION, PLAYERHOOK_ON_CREATURE_KILLED_BY_PET, PLAYERHOOK_ON_CAN_UPDATE_SKILL, PLAYERHOOK_ON_BEFORE_UPDATE_SKILL, PLAYERHOOK_ON_UPDATE_SKILL, PLAYERHOOK_CAN_RESURRECT, PLAYERHOOK_ON_BEFORE_TELEPORT}) {} void OnPlayerResurrect(Player *player, float /*restore_percent*/, bool & /*applySickness*/) override { sEluna->OnResurrect(player); } bool OnPlayerCanUseChat(Player *player, uint32 type, uint32 lang, std::string &msg) override { if (type != CHAT_MSG_SAY && type != CHAT_MSG_YELL && type != CHAT_MSG_EMOTE) return true; if (!sEluna->OnChat(player, type, lang, msg)) return false; return true; } bool OnPlayerCanUseChat(Player *player, uint32 type, uint32 lang, std::string &msg, Player *target) override { if (!sEluna->OnChat(player, type, lang, msg, target)) return false; return true; } bool OnPlayerCanUseChat(Player *player, uint32 type, uint32 lang, std::string &msg, Group *group) override { if (!sEluna->OnChat(player, type, lang, msg, group)) return false; return true; } bool OnPlayerCanUseChat(Player *player, uint32 type, uint32 lang, std::string &msg, Guild *guild) override { if (!sEluna->OnChat(player, type, lang, msg, guild)) return false; return true; } bool OnPlayerCanUseChat(Player *player, uint32 type, uint32 lang, std::string &msg, Channel *channel) override { if (!sEluna->OnChat(player, type, lang, msg, channel)) return false; return true; } void OnPlayerLootItem(Player *player, Item *item, uint32 count, ObjectGuid lootguid) override { sEluna->OnLootItem(player, item, count, lootguid); } void OnPlayerLearnTalents(Player *player, uint32 talentId, uint32 talentRank, uint32 spellid) override { sEluna->OnLearnTalents(player, talentId, talentRank, spellid); } bool OnPlayerCanUseItem(Player *player, ItemTemplate const *proto, InventoryResult &result) override { result = sEluna->OnCanUseItem(player, proto->ItemId); return result != EQUIP_ERR_OK ? false : true; } void OnPlayerEquip(Player *player, Item *it, uint8 bag, uint8 slot, bool /*update*/) override { sEluna->OnEquip(player, it, bag, slot); } void OnPlayerEnterCombat(Player *player, Unit *enemy) override { sEluna->OnPlayerEnterCombat(player, enemy); } void OnPlayerLeaveCombat(Player *player) override { sEluna->OnPlayerLeaveCombat(player); } bool OnPlayerCanRepopAtGraveyard(Player *player) override { sEluna->OnRepop(player); return true; } void OnPlayerQuestAbandon(Player *player, uint32 questId) override { sEluna->OnQuestAbandon(player, questId); } void OnPlayerMapChanged(Player *player) override { sEluna->OnMapChanged(player); } void OnPlayerGossipSelect(Player *player, uint32 menu_id, uint32 sender, uint32 action) override { sEluna->HandleGossipSelectOption(player, menu_id, sender, action, ""); } void OnPlayerGossipSelectCode(Player *player, uint32 menu_id, uint32 sender, uint32 action, const char *code) override { sEluna->HandleGossipSelectOption(player, menu_id, sender, action, code); } void OnPlayerPVPKill(Player *killer, Player *killed) override { sEluna->OnPVPKill(killer, killed); } void OnPlayerCreatureKill(Player *killer, Creature *killed) override { sEluna->OnCreatureKill(killer, killed); } void OnPlayerKilledByCreature(Creature *killer, Player *killed) override { sEluna->OnPlayerKilledByCreature(killer, killed); } void OnPlayerLevelChanged(Player *player, uint8 oldLevel) override { sEluna->OnLevelChanged(player, oldLevel); } void OnPlayerFreeTalentPointsChanged(Player *player, uint32 points) override { sEluna->OnFreeTalentPointsChanged(player, points); } void OnPlayerTalentsReset(Player *player, bool noCost) override { sEluna->OnTalentsReset(player, noCost); } void OnPlayerMoneyChanged(Player *player, int32 &amount) override { sEluna->OnMoneyChanged(player, amount); } void OnPlayerGiveXP(Player *player, uint32 &amount, Unit *victim, uint8 xpSource) override { sEluna->OnGiveXP(player, amount, victim, xpSource); } bool OnPlayerReputationChange(Player *player, uint32 factionID, int32 &standing, bool incremental) override { return sEluna->OnReputationChange(player, factionID, standing, incremental); } void OnPlayerDuelRequest(Player *target, Player *challenger) override { sEluna->OnDuelRequest(target, challenger); } void OnPlayerDuelStart(Player *player1, Player *player2) override { sEluna->OnDuelStart(player1, player2); } void OnPlayerDuelEnd(Player *winner, Player *loser, DuelCompleteType type) override { sEluna->OnDuelEnd(winner, loser, type); } void OnPlayerEmote(Player *player, uint32 emote) override { sEluna->OnEmote(player, emote); } void OnPlayerTextEmote(Player *player, uint32 textEmote, uint32 emoteNum, ObjectGuid guid) override { sEluna->OnTextEmote(player, textEmote, emoteNum, guid); } void OnPlayerSpellCast(Player *player, Spell *spell, bool skipCheck) override { sEluna->OnPlayerSpellCast(player, spell, skipCheck); } void OnPlayerLogin(Player *player) override { sEluna->OnLogin(player); } void OnPlayerLogout(Player *player) override { sEluna->OnLogout(player); } void OnPlayerCreate(Player *player) override { sEluna->OnCreate(player); } void OnPlayerSave(Player *player) override { sEluna->OnSave(player); } void OnPlayerDelete(ObjectGuid guid, uint32 /*accountId*/) override { sEluna->OnDelete(guid.GetCounter()); } void OnPlayerBindToInstance(Player *player, Difficulty difficulty, uint32 mapid, bool permanent) override { sEluna->OnBindToInstance(player, difficulty, mapid, permanent); } void OnPlayerUpdateArea(Player *player, uint32 oldArea, uint32 newArea) override { sEluna->OnUpdateArea(player, oldArea, newArea); } void OnPlayerUpdateZone(Player *player, uint32 newZone, uint32 newArea) override { sEluna->OnUpdateZone(player, newZone, newArea); } void OnPlayerFirstLogin(Player *player) override { sEluna->OnFirstLogin(player); } void OnPlayerLearnSpell(Player *player, uint32 spellId) override { sEluna->OnLearnSpell(player, spellId); } void OnPlayerAchievementComplete(Player *player, AchievementEntry const *achievement) override { sEluna->OnAchiComplete(player, achievement); } void OnPlayerFfaPvpStateUpdate(Player *player, bool IsFlaggedForFfaPvp) override { sEluna->OnFfaPvpStateUpdate(player, IsFlaggedForFfaPvp); } bool OnPlayerCanInitTrade(Player *player, Player *target) override { return sEluna->OnCanInitTrade(player, target); } bool OnPlayerCanSendMail(Player *player, ObjectGuid receiverGuid, ObjectGuid mailbox, std::string &subject, std::string &body, uint32 money, uint32 cod, Item *item) override { return sEluna->OnCanSendMail(player, receiverGuid, mailbox, subject, body, money, cod, item); } bool OnPlayerCanJoinLfg(Player *player, uint8 roles, lfg::LfgDungeonSet &dungeons, const std::string &comment) override { return sEluna->OnCanJoinLfg(player, roles, dungeons, comment); } void OnPlayerQuestRewardItem(Player *player, Item *item, uint32 count) override { sEluna->OnQuestRewardItem(player, item, count); } void OnPlayerGroupRollRewardItem(Player *player, Item *item, uint32 count, RollVote voteType, Roll *roll) override { sEluna->OnGroupRollRewardItem(player, item, count, voteType, roll); } void OnPlayerCreateItem(Player *player, Item *item, uint32 count) override { sEluna->OnCreateItem(player, item, count); } void OnPlayerStoreNewItem(Player *player, Item *item, uint32 count) override { sEluna->OnStoreNewItem(player, item, count); } void OnPlayerCompleteQuest(Player *player, Quest const *quest) override { sEluna->OnPlayerCompleteQuest(player, quest); } bool OnPlayerCanGroupInvite(Player *player, std::string &memberName) override { return sEluna->OnCanGroupInvite(player, memberName); } void OnPlayerBattlegroundDesertion(Player *player, const BattlegroundDesertionType type) override { sEluna->OnBattlegroundDesertion(player, type); } void OnPlayerCreatureKilledByPet(Player *player, Creature *killed) override { sEluna->OnCreatureKilledByPet(player, killed); } bool OnPlayerCanUpdateSkill(Player *player, uint32 skill_id) override { return sEluna->OnPlayerCanUpdateSkill(player, skill_id); } void OnPlayerBeforeUpdateSkill(Player *player, uint32 skill_id, uint32 &value, uint32 max, uint32 step) override { sEluna->OnPlayerBeforeUpdateSkill(player, skill_id, value, max, step); } void OnPlayerUpdateSkill(Player *player, uint32 skill_id, uint32 value, uint32 max, uint32 step, uint32 new_value) override { sEluna->OnPlayerUpdateSkill(player, skill_id, value, max, step, new_value); } bool OnPlayerCanResurrect(Player *player) override { return sEluna->CanPlayerResurrect(player); } bool OnPlayerBeforeTeleport(Player *player, uint32 mapid, float x, float y, float z, float orientation, uint32 options, Unit *target) override { return sEluna->OnPlayerBeforeTeleport(player, mapid, x, y, z, orientation, options, target); } }; class Eluna_ServerScript : public ServerScript { public: Eluna_ServerScript() : ServerScript("Eluna_ServerScript", {SERVERHOOK_CAN_PACKET_SEND, SERVERHOOK_CAN_PACKET_RECEIVE}) {} bool CanPacketSend(WorldSession *session, WorldPacket const &packet) override { if (!sEluna->OnPacketSend(session, packet)) return false; return true; } bool CanPacketReceive(WorldSession *session, WorldPacket &packet) override { if (!sEluna->OnPacketReceive(session, packet)) return false; return true; } }; class Eluna_SpellSC : public SpellSC { public: Eluna_SpellSC() : SpellSC("Eluna_SpellSC", {ALLSPELLHOOK_ON_DUMMY_EFFECT_GAMEOBJECT, ALLSPELLHOOK_ON_DUMMY_EFFECT_CREATURE, ALLSPELLHOOK_ON_DUMMY_EFFECT_ITEM, ALLSPELLHOOK_ON_CAST_CANCEL, ALLSPELLHOOK_ON_CAST, ALLSPELLHOOK_ON_PREPARE}) {} void OnDummyEffect(WorldObject *caster, uint32 spellID, SpellEffIndex effIndex, GameObject *gameObjTarget) override { sEluna->OnDummyEffect(caster, spellID, effIndex, gameObjTarget); } void OnDummyEffect(WorldObject *caster, uint32 spellID, SpellEffIndex effIndex, Creature *creatureTarget) override { sEluna->OnDummyEffect(caster, spellID, effIndex, creatureTarget); } void OnDummyEffect(WorldObject *caster, uint32 spellID, SpellEffIndex effIndex, Item *itemTarget) override { sEluna->OnDummyEffect(caster, spellID, effIndex, itemTarget); } void OnSpellCastCancel(Spell *spell, Unit *caster, SpellInfo const *spellInfo, bool bySelf) override { sEluna->OnSpellCastCancel(caster, spell, spellInfo, bySelf); } void OnSpellCast(Spell *spell, Unit *caster, SpellInfo const *spellInfo, bool skipCheck) override { sEluna->OnSpellCast(caster, spell, spellInfo, skipCheck); } void OnSpellPrepare(Spell *spell, Unit *caster, SpellInfo const *spellInfo) override { sEluna->OnSpellPrepare(caster, spell, spellInfo); } }; class Eluna_VehicleScript : public VehicleScript { public: Eluna_VehicleScript() : VehicleScript("Eluna_VehicleScript") {} void OnInstall(Vehicle *veh) override { sEluna->OnInstall(veh); } void OnUninstall(Vehicle *veh) override { sEluna->OnUninstall(veh); } void OnInstallAccessory(Vehicle *veh, Creature *accessory) override { sEluna->OnInstallAccessory(veh, accessory); } void OnAddPassenger(Vehicle *veh, Unit *passenger, int8 seatId) override { sEluna->OnAddPassenger(veh, passenger, seatId); } void OnRemovePassenger(Vehicle *veh, Unit *passenger) override { sEluna->OnRemovePassenger(veh, passenger); } }; class Eluna_WorldObjectScript : public WorldObjectScript { public: Eluna_WorldObjectScript() : WorldObjectScript("Eluna_WorldObjectScript", {WORLDOBJECTHOOK_ON_WORLD_OBJECT_DESTROY, WORLDOBJECTHOOK_ON_WORLD_OBJECT_CREATE, WORLDOBJECTHOOK_ON_WORLD_OBJECT_SET_MAP, WORLDOBJECTHOOK_ON_WORLD_OBJECT_UPDATE}) {} void OnWorldObjectDestroy(WorldObject *object) override { ResetElunaEventProcessor(object); } void OnWorldObjectCreate(WorldObject *object) override { ResetElunaEventProcessor(object); } void OnWorldObjectSetMap(WorldObject *object, Map * /*map*/) override { EnsureElunaEventProcessor(object, &Eluna::GEluna); } void OnWorldObjectUpdate(WorldObject *object, uint32 diff) override { if (ElunaEventProcessor *processor = GetElunaEventProcessor(object)) processor->Update(diff); } }; class Eluna_WorldScript : public WorldScript { public: Eluna_WorldScript() : WorldScript("Eluna_WorldScript", {WORLDHOOK_ON_OPEN_STATE_CHANGE, WORLDHOOK_ON_BEFORE_CONFIG_LOAD, WORLDHOOK_ON_AFTER_CONFIG_LOAD, WORLDHOOK_ON_SHUTDOWN_INITIATE, WORLDHOOK_ON_SHUTDOWN_CANCEL, WORLDHOOK_ON_UPDATE, WORLDHOOK_ON_STARTUP, WORLDHOOK_ON_SHUTDOWN, WORLDHOOK_ON_AFTER_UNLOAD_ALL_MAPS, WORLDHOOK_ON_BEFORE_WORLD_INITIALIZED}) {} void OnOpenStateChange(bool open) override { sEluna->OnOpenStateChange(open); } void OnBeforeConfigLoad(bool reload) override { ElunaConfig::GetInstance().Initialize(reload); if (!reload) { ///- Initialize Lua Engine LOG_INFO("eluna", "Initialize Eluna Lua Engine..."); Eluna::Initialize(); if (sEluna->IsInitialized()) sEluna->RunScripts(); } sEluna->OnBeforeConfigLoad(reload); } void OnAfterConfigLoad(bool reload) override { sEluna->OnAfterConfigLoad(reload); } void OnShutdownInitiate(ShutdownExitCode code, ShutdownMask mask) override { sEluna->OnShutdownInitiate(code, mask); } void OnShutdownCancel() override { sEluna->OnShutdownCancel(); } void OnUpdate(uint32 diff) override { sEluna->OnWorldUpdate(diff); } void OnStartup() override { sEluna->OnStartup(); } void OnShutdown() override { sEluna->OnShutdown(); } void OnAfterUnloadAllMaps() override { Eluna::Uninitialize(); } void OnBeforeWorldInitialized() override { sEluna->OnBeforeWorldInitialized(); } }; class Eluna_TicketScript : public TicketScript { public: Eluna_TicketScript() : TicketScript("Eluna_TicketScript", {TICKETHOOK_ON_TICKET_CREATE, TICKETHOOK_ON_TICKET_UPDATE_LAST_CHANGE, TICKETHOOK_ON_TICKET_CLOSE, TICKETHOOK_ON_TICKET_RESOLVE}) {} void OnTicketCreate(GmTicket *ticket) override { sEluna->OnTicketCreate(ticket); } void OnTicketUpdateLastChange(GmTicket *ticket) override { sEluna->OnTicketUpdateLastChange(ticket); } void OnTicketClose(GmTicket *ticket) override { sEluna->OnTicketClose(ticket); } void OnTicketResolve(GmTicket *ticket) override { sEluna->OnTicketResolve(ticket); } }; class Eluna_UnitScript : public UnitScript { public: Eluna_UnitScript() : UnitScript("Eluna_UnitScript") {} void OnAuraApply(Unit *unit, Aura *aura) override { if (unit->IsPlayer()) sEluna->OnPlayerAuraApply(unit->ToPlayer(), aura); if (unit->IsCreature()) sEluna->OnCreatureAuraApply(unit->ToCreature(), aura); } void OnHeal(Unit *healer, Unit *receiver, uint32 &gain) override { if (!healer) return; if (healer->IsPlayer()) sEluna->OnPlayerHeal(healer->ToPlayer(), receiver, gain); if (healer->IsCreature()) sEluna->OnCreatureHeal(healer->ToCreature(), receiver, gain); } void OnDamage(Unit *attacker, Unit *receiver, uint32 &damage) override { if (!attacker) return; if (attacker->IsPlayer()) sEluna->OnPlayerDamage(attacker->ToPlayer(), receiver, damage); if (attacker->IsCreature()) sEluna->OnCreatureDamage(attacker->ToCreature(), receiver, damage); } }; // Group all custom scripts void AddSC_ElunaLuaEngine() { new Eluna_AllCreatureScript(); new Eluna_AllGameObjectScript(); new Eluna_AllItemScript(); new Eluna_AllMapScript(); new Eluna_AuctionHouseScript(); new Eluna_BGScript(); new Eluna_CommandSC(); new Eluna_ElunaScript(); new Eluna_GameEventScript(); new Eluna_GroupScript(); new Eluna_GuildScript(); new Eluna_LootScript(); new Eluna_MiscScript(); new Eluna_PetScript(); new Eluna_PlayerScript(); new Eluna_ServerScript(); new Eluna_SpellSC(); new Eluna_TicketScript(); new Eluna_VehicleScript(); new Eluna_WorldObjectScript(); new Eluna_WorldScript(); new Eluna_UnitScript(); }