Core/Scripts: unified scripted gossip/quest api

- Changed self-accessor on GameObjectAI to "me", like UnitAI
- Moved all related functions to AI, now Unit and GameObject have the same function names with identical behaviour
- Remove "OnUpdate" from CreatureScript/GameObjectScript, was never used and we already have AI Update method
- Quest methods no longer return a bool, the return value was used to call the AI version if the ScriptMgr one returned false
- Implemented GameObjectAI::Destroyed hook (was never called), implemented Damaged method
- Rename OnStateChanged to OnLootStateChanged to reflect when it's really called, and created a new hook OnStateChanged that only gets called on GOState change
- Since the functions are now only getting called from AI, made GetAI methods full virtual. (CanSpawn method is anyways going to be used on creatures with AI)

(cherry picked from commit f913f3bb8977c127d200d5d4a608ab434b21bbcd)

4 files changed, 1603 insertions, 1188 deletions

diff --git a/src/server/scripts/World/go_scripts.cpp b/src/server/scripts/World/go_scripts.cpp
index 8e63c84fe2a..8cba4c1a6b4 100644
--- a/src/server/scripts/World/go_scripts.cpp
+++ b/src/server/scripts/World/go_scripts.cpp
@@ -74,10 +74,20 @@ class go_cat_figurine : public GameObjectScript
 public:
     go_cat_figurine() : GameObjectScript("go_cat_figurine") { }
 
-    bool OnGossipHello(Player* player, GameObject* /*go*/) override
+    struct go_cat_figurineAI : public GameObjectAI
     {
-        player->CastSpell(player, SPELL_SUMMON_GHOST_SABER, true);
-        return false;
+        go_cat_figurineAI(GameObject* go) : GameObjectAI(go) { }
+
+        bool GossipHello(Player* player, bool /*reportUse*/) override
+        {
+            player->CastSpell(player, SPELL_SUMMON_GHOST_SABER, true);
+            return false;
+        }
+    };
+
+    GameObjectAI* GetAI(GameObject* go) const override
+    {
+        return new go_cat_figurineAI(go);
     }
 };
 
@@ -90,12 +100,22 @@ class go_barov_journal : public GameObjectScript
 public:
     go_barov_journal() : GameObjectScript("go_barov_journal") { }
 
-    bool OnGossipHello(Player* player, GameObject* /*go*/) override
+    struct go_barov_journalAI : public GameObjectAI
     {
-        if (player->HasSkill(SKILL_TAILORING) && player->GetBaseSkillValue(SKILL_TAILORING) >= 280 && !player->HasSpell(26086))
-            player->CastSpell(player, 26095, false);
+        go_barov_journalAI(GameObject* go) : GameObjectAI(go) { }
+
+        bool GossipHello(Player* player, bool /*reportUse*/) override
+        {
+            if (player->HasSkill(SKILL_TAILORING) && player->GetBaseSkillValue(SKILL_TAILORING) >= 280 && !player->HasSpell(26086))
+                player->CastSpell(player, 26095, false);
+
+            return true;
+        }
+    };
 
-        return true;
+    GameObjectAI* GetAI(GameObject* go) const override
+    {
+        return new go_barov_journalAI(go);
     }
 };
 
@@ -114,17 +134,27 @@ class go_gilded_brazier : public GameObjectScript
 public:
     go_gilded_brazier() : GameObjectScript("go_gilded_brazier") { }
 
-    bool OnGossipHello(Player* player, GameObject* go) override
+    struct go_gilded_brazierAI : public GameObjectAI
     {
-        if (go->GetGoType() == GAMEOBJECT_TYPE_GOOBER)
+        go_gilded_brazierAI(GameObject* go) : GameObjectAI(go) { }
+
+        bool GossipHello(Player* player, bool /*reportUse*/) override
         {
-            if (player->GetQuestStatus(QUEST_THE_FIRST_TRIAL) == QUEST_STATUS_INCOMPLETE)
+            if (me->GetGoType() == GAMEOBJECT_TYPE_GOOBER)
             {
-                if (Creature* Stillblade = player->SummonCreature(NPC_STILLBLADE, 8106.11f, -7542.06f, 151.775f, 3.02598f, TEMPSUMMON_DEAD_DESPAWN, 60000))
-                    Stillblade->AI()->AttackStart(player);
+                if (player->GetQuestStatus(QUEST_THE_FIRST_TRIAL) == QUEST_STATUS_INCOMPLETE)
+                {
+                    if (Creature* Stillblade = player->SummonCreature(NPC_STILLBLADE, 8106.11f, -7542.06f, 151.775f, 3.02598f, TEMPSUMMON_DEAD_DESPAWN, 60000))
+                        Stillblade->AI()->AttackStart(player);
+                }
             }
+            return true;
         }
-        return true;
+    };
+
+    GameObjectAI* GetAI(GameObject* go) const override
+    {
+        return new go_gilded_brazierAI(go);
     }
 };
 
@@ -137,12 +167,22 @@ class go_orb_of_command : public GameObjectScript
 public:
     go_orb_of_command() : GameObjectScript("go_orb_of_command") { }
 
-    bool OnGossipHello(Player* player, GameObject* /*go*/) override
+    struct go_orb_of_commandAI : public GameObjectAI
     {
-        if (player->GetQuestRewardStatus(7761))
-            player->CastSpell(player, 23460, true);
+        go_orb_of_commandAI(GameObject* go) : GameObjectAI(go) { }
+
+        bool GossipHello(Player* player, bool /*reportUse*/) override
+        {
+            if (player->GetQuestRewardStatus(7761))
+                player->CastSpell(player, 23460, true);
 
-        return true;
+            return true;
+        }
+    };
+
+    GameObjectAI* GetAI(GameObject* go) const override
+    {
+        return new go_orb_of_commandAI(go);
     }
 };
 
@@ -155,12 +195,22 @@ class go_tablet_of_madness : public GameObjectScript
 public:
     go_tablet_of_madness() : GameObjectScript("go_tablet_of_madness") { }
 
-    bool OnGossipHello(Player* player, GameObject* /*go*/) override
+    struct go_tablet_of_madnessAI : public GameObjectAI
     {
-        if (player->HasSkill(SKILL_ALCHEMY) && player->GetSkillValue(SKILL_ALCHEMY) >= 300 && !player->HasSpell(24266))
-            player->CastSpell(player, 24267, false);
+        go_tablet_of_madnessAI(GameObject* go) : GameObjectAI(go) { }
 
-        return true;
+        bool GossipHello(Player* player, bool /*reportUse*/) override
+        {
+            if (player->HasSkill(SKILL_ALCHEMY) && player->GetSkillValue(SKILL_ALCHEMY) >= 300 && !player->HasSpell(24266))
+                player->CastSpell(player, 24267, false);
+
+            return true;
+        }
+    };
+
+    GameObjectAI* GetAI(GameObject* go) const override
+    {
+        return new go_tablet_of_madnessAI(go);
     }
 };
 
@@ -173,16 +223,26 @@ class go_tablet_of_the_seven : public GameObjectScript
 public:
     go_tablet_of_the_seven() : GameObjectScript("go_tablet_of_the_seven") { }
 
-    /// @todo use gossip option ("Transcript the Tablet") instead, if Trinity adds support.
-    bool OnGossipHello(Player* player, GameObject* go) override
+    struct go_tablet_of_the_sevenAI : public GameObjectAI
     {
-        if (go->GetGoType() != GAMEOBJECT_TYPE_QUESTGIVER)
-            return true;
+        go_tablet_of_the_sevenAI(GameObject* go) : GameObjectAI(go) { }
+
+        /// @todo use gossip option ("Transcript the Tablet") instead, if Trinity adds support.
+        bool GossipHello(Player* player, bool /*reportUse*/) override
+        {
+            if (me->GetGoType() != GAMEOBJECT_TYPE_QUESTGIVER)
+                return true;
 
-        if (player->GetQuestStatus(4296) == QUEST_STATUS_INCOMPLETE)
-            player->CastSpell(player, 15065, false);
+            if (player->GetQuestStatus(4296) == QUEST_STATUS_INCOMPLETE)
+                player->CastSpell(player, 15065, false);
 
-        return true;
+            return true;
+        }
+    };
+
+    GameObjectAI* GetAI(GameObject* go) const override
+    {
+        return new go_tablet_of_the_sevenAI(go);
     }
 };
 
@@ -195,12 +255,22 @@ class go_jump_a_tron : public GameObjectScript
 public:
     go_jump_a_tron() : GameObjectScript("go_jump_a_tron") { }
 
-    bool OnGossipHello(Player* player, GameObject* /*go*/) override
+    struct go_jump_a_tronAI : public GameObjectAI
     {
-        if (player->GetQuestStatus(10111) == QUEST_STATUS_INCOMPLETE)
-            player->CastSpell(player, 33382, true);
+        go_jump_a_tronAI(GameObject* go) : GameObjectAI(go) { }
+
+        bool GossipHello(Player* player, bool /*reportUse*/) override
+        {
+            if (player->GetQuestStatus(10111) == QUEST_STATUS_INCOMPLETE)
+                player->CastSpell(player, 33382, true);
+
+            return true;
+        }
+    };
 
-        return true;
+    GameObjectAI* GetAI(GameObject* go) const override
+    {
+        return new go_jump_a_tronAI(go);
     }
 };
 
@@ -229,39 +299,49 @@ class go_ethereum_prison : public GameObjectScript
 public:
     go_ethereum_prison() : GameObjectScript("go_ethereum_prison") { }
 
-    bool OnGossipHello(Player* player, GameObject* go) override
+    struct go_ethereum_prisonAI : public GameObjectAI
     {
-        go->UseDoorOrButton();
-        int Random = rand32() % (sizeof(NpcPrisonEntry) / sizeof(uint32));
+        go_ethereum_prisonAI(GameObject* go) : GameObjectAI(go) { }
 
-        if (Creature* creature = player->SummonCreature(NpcPrisonEntry[Random], go->GetPositionX(), go->GetPositionY(), go->GetPositionZ(), go->GetAngle(player),
-            TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 30000))
+        bool GossipHello(Player* player, bool /*reportUse*/) override
         {
-            if (!creature->IsHostileTo(player))
+            me->UseDoorOrButton();
+            int Random = rand32() % (sizeof(NpcPrisonEntry) / sizeof(uint32));
+
+            if (Creature* creature = player->SummonCreature(NpcPrisonEntry[Random], me->GetPositionX(), me->GetPositionY(), me->GetPositionZ(), me->GetAngle(player),
+                TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 30000))
             {
-                if (FactionTemplateEntry const* pFaction = creature->GetFactionTemplateEntry())
+                if (!creature->IsHostileTo(player))
                 {
-                    uint32 Spell = 0;
-
-                    switch (pFaction->Faction)
+                    if (FactionTemplateEntry const* pFaction = creature->GetFactionTemplateEntry())
                     {
-                        case 1011: Spell = SPELL_REP_LC; break;
-                        case 935: Spell = SPELL_REP_SHAT; break;
-                        case 942: Spell = SPELL_REP_CE; break;
-                        case 933: Spell = SPELL_REP_CON; break;
-                        case 989: Spell = SPELL_REP_KT; break;
-                        case 970: Spell = SPELL_REP_SPOR; break;
-                    }
+                        uint32 Spell = 0;
 
-                    if (Spell)
-                        creature->CastSpell(player, Spell, false);
-                    else
-                        TC_LOG_ERROR("scripts", "go_ethereum_prison summoned Creature (entry %u) but faction (%u) are not expected by script.", creature->GetEntry(), creature->GetFaction());
+                        switch (pFaction->Faction)
+                        {
+                            case 1011: Spell = SPELL_REP_LC; break;
+                            case 935: Spell = SPELL_REP_SHAT; break;
+                            case 942: Spell = SPELL_REP_CE; break;
+                            case 933: Spell = SPELL_REP_CON; break;
+                            case 989: Spell = SPELL_REP_KT; break;
+                            case 970: Spell = SPELL_REP_SPOR; break;
+                        }
+
+                        if (Spell)
+                            creature->CastSpell(player, Spell, false);
+                        else
+                            TC_LOG_ERROR("scripts", "go_ethereum_prison summoned Creature (entry %u) but faction (%u) are not expected by script.", creature->GetEntry(), creature->GetFaction());
+                    }
                 }
             }
+
+            return false;
         }
+    };
 
-        return false;
+    GameObjectAI* GetAI(GameObject* go) const override
+    {
+        return new go_ethereum_prisonAI(go);
     }
 };
 
@@ -279,15 +359,25 @@ class go_ethereum_stasis : public GameObjectScript
 public:
     go_ethereum_stasis() : GameObjectScript("go_ethereum_stasis") { }
 
-    bool OnGossipHello(Player* player, GameObject* go) override
+    struct go_ethereum_stasisAI : public GameObjectAI
     {
-        go->UseDoorOrButton();
-        int Random = rand32() % (sizeof(NpcStasisEntry) / sizeof(uint32));
+        go_ethereum_stasisAI(GameObject* go) : GameObjectAI(go) { }
 
-        player->SummonCreature(NpcStasisEntry[Random], go->GetPositionX(), go->GetPositionY(), go->GetPositionZ(), go->GetAngle(player),
-            TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 30000);
+        bool GossipHello(Player* player, bool /*reportUse*/) override
+        {
+            me->UseDoorOrButton();
+            int Random = rand32() % (sizeof(NpcStasisEntry) / sizeof(uint32));
+
+            player->SummonCreature(NpcStasisEntry[Random], me->GetPositionX(), me->GetPositionY(), me->GetPositionZ(), me->GetAngle(player),
+                TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 30000);
 
-        return false;
+            return false;
+        }
+    };
+
+    GameObjectAI* GetAI(GameObject* go) const override
+    {
+        return new go_ethereum_stasisAI(go);
     }
 };
 
@@ -305,12 +395,22 @@ class go_resonite_cask : public GameObjectScript
 public:
     go_resonite_cask() : GameObjectScript("go_resonite_cask") { }
 
-    bool OnGossipHello(Player* /*player*/, GameObject* go) override
+    struct go_resonite_caskAI : public GameObjectAI
     {
-        if (go->GetGoType() == GAMEOBJECT_TYPE_GOOBER)
-            go->SummonCreature(NPC_GOGGEROC, 0.0f, 0.0f, 0.0f, 0.0f, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 300000);
+        go_resonite_caskAI(GameObject* go) : GameObjectAI(go) { }
+
+        bool GossipHello(Player* /*player*/, bool /*reportUse*/) override
+        {
+            if (me->GetGoType() == GAMEOBJECT_TYPE_GOOBER)
+                me->SummonCreature(NPC_GOGGEROC, 0.0f, 0.0f, 0.0f, 0.0f, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 300000);
 
-        return false;
+            return false;
+        }
+    };
+
+    GameObjectAI* GetAI(GameObject* go) const override
+    {
+        return new go_resonite_caskAI(go);
     }
 };
 
@@ -328,12 +428,22 @@ class go_sacred_fire_of_life : public GameObjectScript
 public:
     go_sacred_fire_of_life() : GameObjectScript("go_sacred_fire_of_life") { }
 
-    bool OnGossipHello(Player* player, GameObject* go) override
+    struct go_sacred_fire_of_lifeAI : public GameObjectAI
     {
-        if (go->GetGoType() == GAMEOBJECT_TYPE_GOOBER)
-            player->SummonCreature(NPC_ARIKARA, -5008.338f, -2118.894f, 83.657f, 0.874f, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 30000);
+        go_sacred_fire_of_lifeAI(GameObject* go) : GameObjectAI(go) { }
+
+        bool GossipHello(Player* player, bool /*reportUse*/) override
+        {
+            if (me->GetGoType() == GAMEOBJECT_TYPE_GOOBER)
+                player->SummonCreature(NPC_ARIKARA, -5008.338f, -2118.894f, 83.657f, 0.874f, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 30000);
 
-        return true;
+            return true;
+        }
+    };
+
+    GameObjectAI* GetAI(GameObject* go) const override
+    {
+        return new go_sacred_fire_of_lifeAI(go);
     }
 };
 
@@ -356,30 +466,40 @@ class go_shrine_of_the_birds : public GameObjectScript
 public:
     go_shrine_of_the_birds() : GameObjectScript("go_shrine_of_the_birds") { }
 
-    bool OnGossipHello(Player* player, GameObject* go) override
+    struct go_shrine_of_the_birdsAI : public GameObjectAI
     {
-        uint32 BirdEntry = 0;
+        go_shrine_of_the_birdsAI(GameObject* go) : GameObjectAI(go) { }
 
-        float fX, fY, fZ;
-        go->GetClosePoint(fX, fY, fZ, go->GetCombatReach(), INTERACTION_DISTANCE);
-
-        switch (go->GetEntry())
+        bool GossipHello(Player* player, bool /*reportUse*/) override
         {
-            case GO_SHRINE_HAWK:
-                BirdEntry = NPC_HAWK_GUARD;
-                break;
-            case GO_SHRINE_EAGLE:
-                BirdEntry = NPC_EAGLE_GUARD;
-                break;
-            case GO_SHRINE_FALCON:
-                BirdEntry = NPC_FALCON_GUARD;
-                break;
-        }
+            uint32 BirdEntry = 0;
 
-        if (BirdEntry)
-            player->SummonCreature(BirdEntry, fX, fY, fZ, go->GetOrientation(), TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 60000);
+            float fX, fY, fZ;
+            me->GetClosePoint(fX, fY, fZ, me->GetCombatReach(), INTERACTION_DISTANCE);
+
+            switch (me->GetEntry())
+            {
+                case GO_SHRINE_HAWK:
+                    BirdEntry = NPC_HAWK_GUARD;
+                    break;
+                case GO_SHRINE_EAGLE:
+                    BirdEntry = NPC_EAGLE_GUARD;
+                    break;
+                case GO_SHRINE_FALCON:
+                    BirdEntry = NPC_FALCON_GUARD;
+                    break;
+            }
+
+            if (BirdEntry)
+                player->SummonCreature(BirdEntry, fX, fY, fZ, me->GetOrientation(), TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 60000);
+
+            return false;
+        }
+    };
 
-        return false;
+    GameObjectAI* GetAI(GameObject* go) const override
+    {
+        return new go_shrine_of_the_birdsAI(go);
     }
 };
 
@@ -399,15 +519,25 @@ class go_southfury_moonstone : public GameObjectScript
 public:
     go_southfury_moonstone() : GameObjectScript("go_southfury_moonstone") { }
 
-    bool OnGossipHello(Player* player, GameObject* /*go*/) override
+    struct go_southfury_moonstoneAI : public GameObjectAI
     {
-        //implicitTarget=48 not implemented as of writing this code, and manual summon may be just ok for our purpose
-        //player->CastSpell(player, SPELL_SUMMON_RIZZLE, false);
+        go_southfury_moonstoneAI(GameObject* go) : GameObjectAI(go) { }
+
+        bool GossipHello(Player* player, bool /*reportUse*/) override
+        {
+            //implicitTarget=48 not implemented as of writing this code, and manual summon may be just ok for our purpose
+            //player->CastSpell(player, SPELL_SUMMON_RIZZLE, false);
 
-        if (Creature* creature = player->SummonCreature(NPC_RIZZLE, 0.0f, 0.0f, 0.0f, 0.0f, TEMPSUMMON_DEAD_DESPAWN, 0))
-            creature->CastSpell(player, SPELL_BLACKJACK, false);
+            if (Creature* creature = player->SummonCreature(NPC_RIZZLE, 0.0f, 0.0f, 0.0f, 0.0f, TEMPSUMMON_DEAD_DESPAWN, 0))
+                creature->CastSpell(player, SPELL_BLACKJACK, false);
 
-        return false;
+            return false;
+        }
+    };
+
+    GameObjectAI* GetAI(GameObject* go) const override
+    {
+        return new go_southfury_moonstoneAI(go);
     }
 };
 
@@ -428,14 +558,23 @@ class go_tele_to_dalaran_crystal : public GameObjectScript
 public:
     go_tele_to_dalaran_crystal() : GameObjectScript("go_tele_to_dalaran_crystal") { }
 
-    bool OnGossipHello(Player* player, GameObject* /*go*/) override
+    struct go_tele_to_dalaran_crystalAI : public GameObjectAI
     {
-        if (player->GetQuestRewardStatus(QUEST_TELE_CRYSTAL_FLAG))
-            return false;
+        go_tele_to_dalaran_crystalAI(GameObject* go) : GameObjectAI(go) { }
 
-        player->GetSession()->SendNotification(GO_TELE_TO_DALARAN_CRYSTAL_FAILED);
+        bool GossipHello(Player* player, bool /*reportUse*/) override
+        {
+            if (player->GetQuestRewardStatus(QUEST_TELE_CRYSTAL_FLAG))
+                return false;
+
+            player->GetSession()->SendNotification(GO_TELE_TO_DALARAN_CRYSTAL_FAILED);
+            return true;
+        }
+    };
 
-        return true;
+    GameObjectAI* GetAI(GameObject* go) const override
+    {
+        return new go_tele_to_dalaran_crystalAI(go);
     }
 };
 
@@ -448,12 +587,22 @@ class go_tele_to_violet_stand : public GameObjectScript
 public:
     go_tele_to_violet_stand() : GameObjectScript("go_tele_to_violet_stand") { }
 
-    bool OnGossipHello(Player* player, GameObject* /*go*/) override
+    struct go_tele_to_violet_standAI : public GameObjectAI
     {
-        if (player->GetQuestRewardStatus(QUEST_LEARN_LEAVE_RETURN) || player->GetQuestStatus(QUEST_LEARN_LEAVE_RETURN) == QUEST_STATUS_INCOMPLETE)
-            return false;
+        go_tele_to_violet_standAI(GameObject* go) : GameObjectAI(go) { }
+
+        bool GossipHello(Player* player, bool /*reportUse*/) override
+        {
+            if (player->GetQuestRewardStatus(QUEST_LEARN_LEAVE_RETURN) || player->GetQuestStatus(QUEST_LEARN_LEAVE_RETURN) == QUEST_STATUS_INCOMPLETE)
+                return false;
+
+            return true;
+        }
+    };
 
-        return true;
+    GameObjectAI* GetAI(GameObject* go) const override
+    {
+        return new go_tele_to_violet_standAI(go);
     }
 };
 
@@ -478,41 +627,52 @@ class go_fel_crystalforge : public GameObjectScript
 public:
     go_fel_crystalforge() : GameObjectScript("go_fel_crystalforge") { }
 
-    bool OnGossipHello(Player* player, GameObject* go) override
+    struct go_fel_crystalforgeAI : public GameObjectAI
     {
-        if (go->GetGoType() == GAMEOBJECT_TYPE_QUESTGIVER) /* != GAMEOBJECT_TYPE_QUESTGIVER) */
-            player->PrepareQuestMenu(go->GetGUID()); /* return true*/
+        go_fel_crystalforgeAI(GameObject* go) : GameObjectAI(go) { }
 
-        AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_FEL_CRYSTALFORGE_ITEM_1, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF);
-        AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_FEL_CRYSTALFORGE_ITEM_5, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF + 1);
+        bool GossipHello(Player* player, bool /*reportUse*/) override
+        {
+            if (me->GetGoType() == GAMEOBJECT_TYPE_QUESTGIVER) /* != GAMEOBJECT_TYPE_QUESTGIVER) */
+                player->PrepareQuestMenu(me->GetGUID()); /* return true*/
 
-        SendGossipMenuFor(player, GOSSIP_FEL_CRYSTALFORGE_TEXT, go->GetGUID());
+            AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_FEL_CRYSTALFORGE_ITEM_1, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF);
+            AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_FEL_CRYSTALFORGE_ITEM_5, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF + 1);
 
-        return true;
-    }
+            SendGossipMenuFor(player, GOSSIP_FEL_CRYSTALFORGE_TEXT, me->GetGUID());
 
-    bool OnGossipSelect(Player* player, GameObject* go, uint32 /*sender*/, uint32 action) override
-    {
-        ClearGossipMenuFor(player);
-        switch (action)
+            return true;
+        }
+
+        bool GossipSelect(Player* player, uint32 /*menuId*/, uint32 gossipListId) override
         {
-            case GOSSIP_ACTION_INFO_DEF:
-                player->CastSpell(player, SPELL_CREATE_1_FLASK_OF_BEAST, false);
-                AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_FEL_CRYSTALFORGE_ITEM_RETURN, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF+2);
-                SendGossipMenuFor(player, GOSSIP_FEL_CRYSTALFORGE_ITEM_TEXT_RETURN, go->GetGUID());
-                break;
-            case GOSSIP_ACTION_INFO_DEF + 1:
-                player->CastSpell(player, SPELL_CREATE_5_FLASK_OF_BEAST, false);
-                AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_FEL_CRYSTALFORGE_ITEM_RETURN, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF+2);
-                SendGossipMenuFor(player, GOSSIP_FEL_CRYSTALFORGE_ITEM_TEXT_RETURN, go->GetGUID());
-                break;
-            case GOSSIP_ACTION_INFO_DEF + 2:
-                AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_FEL_CRYSTALFORGE_ITEM_1, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF);
-                AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_FEL_CRYSTALFORGE_ITEM_5, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF + 1);
-                SendGossipMenuFor(player, GOSSIP_FEL_CRYSTALFORGE_TEXT, go->GetGUID());
-                break;
+            uint32 const action = player->PlayerTalkClass->GetGossipOptionAction(gossipListId);
+            ClearGossipMenuFor(player);
+            switch (action)
+            {
+                case GOSSIP_ACTION_INFO_DEF:
+                    player->CastSpell(player, SPELL_CREATE_1_FLASK_OF_BEAST, false);
+                    AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_FEL_CRYSTALFORGE_ITEM_RETURN, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF + 2);
+                    SendGossipMenuFor(player, GOSSIP_FEL_CRYSTALFORGE_ITEM_TEXT_RETURN, me->GetGUID());
+                    break;
+                case GOSSIP_ACTION_INFO_DEF + 1:
+                    player->CastSpell(player, SPELL_CREATE_5_FLASK_OF_BEAST, false);
+                    AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_FEL_CRYSTALFORGE_ITEM_RETURN, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF + 2);
+                    SendGossipMenuFor(player, GOSSIP_FEL_CRYSTALFORGE_ITEM_TEXT_RETURN, me->GetGUID());
+                    break;
+                case GOSSIP_ACTION_INFO_DEF + 2:
+                    AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_FEL_CRYSTALFORGE_ITEM_1, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF);
+                    AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_FEL_CRYSTALFORGE_ITEM_5, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF + 1);
+                    SendGossipMenuFor(player, GOSSIP_FEL_CRYSTALFORGE_TEXT, me->GetGUID());
+                    break;
+            }
+            return true;
         }
-        return true;
+    };
+
+    GameObjectAI* GetAI(GameObject* go) const override
+    {
+        return new go_fel_crystalforgeAI(go);
     }
 };
 
@@ -537,41 +697,52 @@ class go_bashir_crystalforge : public GameObjectScript
 public:
     go_bashir_crystalforge() : GameObjectScript("go_bashir_crystalforge") { }
 
-    bool OnGossipHello(Player* player, GameObject* go) override
+    struct go_bashir_crystalforgeAI : public GameObjectAI
     {
-        if (go->GetGoType() == GAMEOBJECT_TYPE_QUESTGIVER) /* != GAMEOBJECT_TYPE_QUESTGIVER) */
-            player->PrepareQuestMenu(go->GetGUID()); /* return true*/
+        go_bashir_crystalforgeAI(GameObject* go) : GameObjectAI(go) { }
 
-        AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_BASHIR_CRYSTALFORGE_ITEM_1, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF);
-        AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_BASHIR_CRYSTALFORGE_ITEM_5, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF + 1);
+        bool GossipHello(Player* player, bool /*reportUse*/) override
+        {
+            if (me->GetGoType() == GAMEOBJECT_TYPE_QUESTGIVER) /* != GAMEOBJECT_TYPE_QUESTGIVER) */
+                player->PrepareQuestMenu(me->GetGUID()); /* return true*/
 
-        SendGossipMenuFor(player, GOSSIP_BASHIR_CRYSTALFORGE_TEXT, go->GetGUID());
+            AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_BASHIR_CRYSTALFORGE_ITEM_1, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF);
+            AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_BASHIR_CRYSTALFORGE_ITEM_5, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF + 1);
 
-        return true;
-    }
+            SendGossipMenuFor(player, GOSSIP_BASHIR_CRYSTALFORGE_TEXT, me->GetGUID());
 
-    bool OnGossipSelect(Player* player, GameObject* go, uint32 /*sender*/, uint32 action) override
-    {
-        ClearGossipMenuFor(player);
-        switch (action)
+            return true;
+        }
+
+        bool GossipSelect(Player* player, uint32 /*menuId*/, uint32 gossipListId) override
         {
-            case GOSSIP_ACTION_INFO_DEF:
-                player->CastSpell(player, SPELL_CREATE_1_FLASK_OF_SORCERER, false);
-                AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_BASHIR_CRYSTALFORGE_ITEM_RETURN, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF+2);
-                SendGossipMenuFor(player, GOSSIP_BASHIR_CRYSTALFORGE_ITEM_TEXT_RETURN, go->GetGUID());
-                break;
-            case GOSSIP_ACTION_INFO_DEF + 1:
-                player->CastSpell(player, SPELL_CREATE_5_FLASK_OF_SORCERER, false);
-                AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_BASHIR_CRYSTALFORGE_ITEM_RETURN, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF+2);
-                SendGossipMenuFor(player, GOSSIP_BASHIR_CRYSTALFORGE_ITEM_TEXT_RETURN, go->GetGUID());
-                break;
-            case GOSSIP_ACTION_INFO_DEF + 2:
-                AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_BASHIR_CRYSTALFORGE_ITEM_1, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF);
-                AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_BASHIR_CRYSTALFORGE_ITEM_5, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF + 1);
-                SendGossipMenuFor(player, GOSSIP_BASHIR_CRYSTALFORGE_TEXT, go->GetGUID());
-                break;
+            uint32 const action = player->PlayerTalkClass->GetGossipOptionAction(gossipListId);
+            ClearGossipMenuFor(player);
+            switch (action)
+            {
+                case GOSSIP_ACTION_INFO_DEF:
+                    player->CastSpell(player, SPELL_CREATE_1_FLASK_OF_SORCERER, false);
+                    AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_BASHIR_CRYSTALFORGE_ITEM_RETURN, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF + 2);
+                    SendGossipMenuFor(player, GOSSIP_BASHIR_CRYSTALFORGE_ITEM_TEXT_RETURN, me->GetGUID());
+                    break;
+                case GOSSIP_ACTION_INFO_DEF + 1:
+                    player->CastSpell(player, SPELL_CREATE_5_FLASK_OF_SORCERER, false);
+                    AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_BASHIR_CRYSTALFORGE_ITEM_RETURN, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF + 2);
+                    SendGossipMenuFor(player, GOSSIP_BASHIR_CRYSTALFORGE_ITEM_TEXT_RETURN, me->GetGUID());
+                    break;
+                case GOSSIP_ACTION_INFO_DEF + 2:
+                    AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_BASHIR_CRYSTALFORGE_ITEM_1, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF);
+                    AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_BASHIR_CRYSTALFORGE_ITEM_5, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF + 1);
+                    SendGossipMenuFor(player, GOSSIP_BASHIR_CRYSTALFORGE_TEXT, me->GetGUID());
+                    break;
+            }
+            return true;
         }
-        return true;
+    };
+
+    GameObjectAI* GetAI(GameObject* go) const override
+    {
+        return new go_bashir_crystalforgeAI(go);
     }
 };
 
@@ -601,42 +772,52 @@ class go_matrix_punchograph : public GameObjectScript
 public:
     go_matrix_punchograph() : GameObjectScript("go_matrix_punchograph") { }
 
-    bool OnGossipHello(Player* player, GameObject* go) override
+    struct go_matrix_punchographAI : public GameObjectAI
     {
-        switch (go->GetEntry())
+        go_matrix_punchographAI(GameObject* go) : GameObjectAI(go) { }
+
+        bool GossipHello(Player* player, bool /*reportUse*/) override
         {
-            case MATRIX_PUNCHOGRAPH_3005_A:
-                if (player->HasItemCount(ITEM_WHITE_PUNCH_CARD))
-                {
-                    player->DestroyItemCount(ITEM_WHITE_PUNCH_CARD, 1, true);
-                    player->CastSpell(player, SPELL_YELLOW_PUNCH_CARD, true);
-                }
-                break;
-            case MATRIX_PUNCHOGRAPH_3005_B:
-                if (player->HasItemCount(ITEM_YELLOW_PUNCH_CARD))
-                {
-                    player->DestroyItemCount(ITEM_YELLOW_PUNCH_CARD, 1, true);
-                    player->CastSpell(player, SPELL_BLUE_PUNCH_CARD, true);
-                }
-                break;
-            case MATRIX_PUNCHOGRAPH_3005_C:
-                if (player->HasItemCount(ITEM_BLUE_PUNCH_CARD))
-                {
-                    player->DestroyItemCount(ITEM_BLUE_PUNCH_CARD, 1, true);
-                    player->CastSpell(player, SPELL_RED_PUNCH_CARD, true);
-                }
-                break;
-            case MATRIX_PUNCHOGRAPH_3005_D:
-                if (player->HasItemCount(ITEM_RED_PUNCH_CARD))
-                {
-                    player->DestroyItemCount(ITEM_RED_PUNCH_CARD, 1, true);
-                    player->CastSpell(player, SPELL_PRISMATIC_PUNCH_CARD, true);
-                }
-                break;
-            default:
-                break;
+            switch (me->GetEntry())
+            {
+                case MATRIX_PUNCHOGRAPH_3005_A:
+                    if (player->HasItemCount(ITEM_WHITE_PUNCH_CARD))
+                    {
+                        player->DestroyItemCount(ITEM_WHITE_PUNCH_CARD, 1, true);
+                        player->CastSpell(player, SPELL_YELLOW_PUNCH_CARD, true);
+                    }
+                    break;
+                case MATRIX_PUNCHOGRAPH_3005_B:
+                    if (player->HasItemCount(ITEM_YELLOW_PUNCH_CARD))
+                    {
+                        player->DestroyItemCount(ITEM_YELLOW_PUNCH_CARD, 1, true);
+                        player->CastSpell(player, SPELL_BLUE_PUNCH_CARD, true);
+                    }
+                    break;
+                case MATRIX_PUNCHOGRAPH_3005_C:
+                    if (player->HasItemCount(ITEM_BLUE_PUNCH_CARD))
+                    {
+                        player->DestroyItemCount(ITEM_BLUE_PUNCH_CARD, 1, true);
+                        player->CastSpell(player, SPELL_RED_PUNCH_CARD, true);
+                    }
+                    break;
+                case MATRIX_PUNCHOGRAPH_3005_D:
+                    if (player->HasItemCount(ITEM_RED_PUNCH_CARD))
+                    {
+                        player->DestroyItemCount(ITEM_RED_PUNCH_CARD, 1, true);
+                        player->CastSpell(player, SPELL_PRISMATIC_PUNCH_CARD, true);
+                    }
+                    break;
+                default:
+                    break;
+            }
+            return false;
         }
-        return false;
+    };
+
+    GameObjectAI* GetAI(GameObject* go) const override
+    {
+        return new go_matrix_punchographAI(go);
     }
 };
 
@@ -654,16 +835,26 @@ class go_scourge_cage : public GameObjectScript
 public:
     go_scourge_cage() : GameObjectScript("go_scourge_cage") { }
 
-    bool OnGossipHello(Player* player, GameObject* go) override
+    struct go_scourge_cageAI : public GameObjectAI
     {
-        go->UseDoorOrButton();
-        if (Creature* pNearestPrisoner = go->FindNearestCreature(NPC_SCOURGE_PRISONER, 5.0f, true))
+        go_scourge_cageAI(GameObject* go) : GameObjectAI(go) { }
+
+        bool GossipHello(Player* player, bool /*reportUse*/) override
         {
-            player->KilledMonsterCredit(NPC_SCOURGE_PRISONER, pNearestPrisoner->GetGUID());
-            pNearestPrisoner->DisappearAndDie();
+            me->UseDoorOrButton();
+            if (Creature* pNearestPrisoner = me->FindNearestCreature(NPC_SCOURGE_PRISONER, 5.0f, true))
+            {
+                player->KilledMonsterCredit(NPC_SCOURGE_PRISONER, pNearestPrisoner->GetGUID());
+                pNearestPrisoner->DisappearAndDie();
+            }
+
+            return true;
         }
+    };
 
-        return true;
+    GameObjectAI* GetAI(GameObject* go) const override
+    {
+        return new go_scourge_cageAI(go);
     }
 };
 
@@ -682,15 +873,25 @@ class go_arcane_prison : public GameObjectScript
 public:
     go_arcane_prison() : GameObjectScript("go_arcane_prison") { }
 
-    bool OnGossipHello(Player* player, GameObject* go) override
+    struct go_arcane_prisonAI : public GameObjectAI
     {
-        if (player->GetQuestStatus(QUEST_PRISON_BREAK) == QUEST_STATUS_INCOMPLETE)
+        go_arcane_prisonAI(GameObject* go) : GameObjectAI(go) { }
+
+        bool GossipHello(Player* player, bool /*reportUse*/) override
         {
-            go->SummonCreature(25318, 3485.089844f, 6115.7422188f, 70.966812f, 0, TEMPSUMMON_TIMED_DESPAWN, 60000);
-            player->CastSpell(player, SPELL_ARCANE_PRISONER_KILL_CREDIT, true);
-            return true;
+            if (player->GetQuestStatus(QUEST_PRISON_BREAK) == QUEST_STATUS_INCOMPLETE)
+            {
+                me->SummonCreature(25318, 3485.089844f, 6115.7422188f, 70.966812f, 0, TEMPSUMMON_TIMED_DESPAWN, 60000);
+                player->CastSpell(player, SPELL_ARCANE_PRISONER_KILL_CREDIT, true);
+                return true;
+            }
+            return false;
         }
-        return false;
+    };
+
+    GameObjectAI* GetAI(GameObject* go) const override
+    {
+        return new go_arcane_prisonAI(go);
     }
 };
 
@@ -709,12 +910,22 @@ class go_blood_filled_orb : public GameObjectScript
 public:
     go_blood_filled_orb() : GameObjectScript("go_blood_filled_orb") { }
 
-    bool OnGossipHello(Player* player, GameObject* go) override
+    struct go_blood_filled_orbAI : public GameObjectAI
     {
-        if (go->GetGoType() == GAMEOBJECT_TYPE_GOOBER)
-            player->SummonCreature(NPC_ZELEMAR, -369.746f, 166.759f, -21.50f, 5.235f, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 30000);
+        go_blood_filled_orbAI(GameObject* go) : GameObjectAI(go) { }
+
+        bool GossipHello(Player* player, bool /*reportUse*/) override
+        {
+            if (me->GetGoType() == GAMEOBJECT_TYPE_GOOBER)
+                player->SummonCreature(NPC_ZELEMAR, -369.746f, 166.759f, -21.50f, 5.235f, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 30000);
 
-        return true;
+            return true;
+        }
+    };
+
+    GameObjectAI* GetAI(GameObject* go) const override
+    {
+        return new go_blood_filled_orbAI(go);
     }
 };
 
@@ -740,41 +951,51 @@ class go_jotunheim_cage : public GameObjectScript
 public:
     go_jotunheim_cage() : GameObjectScript("go_jotunheim_cage") { }
 
-    bool OnGossipHello(Player* player, GameObject* go) override
+    struct go_jotunheim_cageAI : public GameObjectAI
     {
-        go->UseDoorOrButton();
-        Creature* pPrisoner = go->FindNearestCreature(NPC_EBON_BLADE_PRISONER_HUMAN, 5.0f, true);
-        if (!pPrisoner)
+        go_jotunheim_cageAI(GameObject* go) : GameObjectAI(go) { }
+
+        bool GossipHello(Player* player, bool /*reportUse*/) override
         {
-            pPrisoner = go->FindNearestCreature(NPC_EBON_BLADE_PRISONER_TROLL, 5.0f, true);
+            me->UseDoorOrButton();
+            Creature* pPrisoner = me->FindNearestCreature(NPC_EBON_BLADE_PRISONER_HUMAN, 5.0f, true);
             if (!pPrisoner)
             {
-                pPrisoner = go->FindNearestCreature(NPC_EBON_BLADE_PRISONER_ORC, 5.0f, true);
+                pPrisoner = me->FindNearestCreature(NPC_EBON_BLADE_PRISONER_TROLL, 5.0f, true);
                 if (!pPrisoner)
-                    pPrisoner = go->FindNearestCreature(NPC_EBON_BLADE_PRISONER_NE, 5.0f, true);
+                {
+                    pPrisoner = me->FindNearestCreature(NPC_EBON_BLADE_PRISONER_ORC, 5.0f, true);
+                    if (!pPrisoner)
+                        pPrisoner = me->FindNearestCreature(NPC_EBON_BLADE_PRISONER_NE, 5.0f, true);
+                }
             }
-        }
-        if (!pPrisoner || !pPrisoner->IsAlive())
-            return false;
+            if (!pPrisoner || !pPrisoner->IsAlive())
+                return false;
 
-        pPrisoner->DisappearAndDie();
-        player->KilledMonsterCredit(NPC_EBON_BLADE_PRISONER_HUMAN);
-        switch (pPrisoner->GetEntry())
-        {
-            case NPC_EBON_BLADE_PRISONER_HUMAN:
-                player->CastSpell(player, SPELL_SUMMON_BLADE_KNIGHT_H, true);
-                break;
-            case NPC_EBON_BLADE_PRISONER_NE:
-                player->CastSpell(player, SPELL_SUMMON_BLADE_KNIGHT_NE, true);
-                break;
-            case NPC_EBON_BLADE_PRISONER_TROLL:
-                player->CastSpell(player, SPELL_SUMMON_BLADE_KNIGHT_TROLL, true);
-                break;
-            case NPC_EBON_BLADE_PRISONER_ORC:
-                player->CastSpell(player, SPELL_SUMMON_BLADE_KNIGHT_ORC, true);
-                break;
+            pPrisoner->DisappearAndDie();
+            player->KilledMonsterCredit(NPC_EBON_BLADE_PRISONER_HUMAN);
+            switch (pPrisoner->GetEntry())
+            {
+                case NPC_EBON_BLADE_PRISONER_HUMAN:
+                    player->CastSpell(player, SPELL_SUMMON_BLADE_KNIGHT_H, true);
+                    break;
+                case NPC_EBON_BLADE_PRISONER_NE:
+                    player->CastSpell(player, SPELL_SUMMON_BLADE_KNIGHT_NE, true);
+                    break;
+                case NPC_EBON_BLADE_PRISONER_TROLL:
+                    player->CastSpell(player, SPELL_SUMMON_BLADE_KNIGHT_TROLL, true);
+                    break;
+                case NPC_EBON_BLADE_PRISONER_ORC:
+                    player->CastSpell(player, SPELL_SUMMON_BLADE_KNIGHT_ORC, true);
+                    break;
+            }
+            return true;
         }
-        return true;
+    };
+
+    GameObjectAI* GetAI(GameObject* go) const override
+    {
+        return new go_jotunheim_cageAI(go);
     }
 };
 
@@ -790,14 +1011,23 @@ class go_table_theka : public GameObjectScript
 public:
     go_table_theka() : GameObjectScript("go_table_theka") { }
 
-    bool OnGossipHello(Player* player, GameObject* go) override
+    struct go_table_thekaAI : public GameObjectAI
     {
-        if (player->GetQuestStatus(QUEST_SPIDER_GOLD) == QUEST_STATUS_INCOMPLETE)
-            player->AreaExploredOrEventHappens(QUEST_SPIDER_GOLD);
+        go_table_thekaAI(GameObject* go) : GameObjectAI(go) { }
 
-        SendGossipMenuFor(player, GOSSIP_TABLE_THEKA, go->GetGUID());
+        bool GossipHello(Player* player, bool /*reportUse*/) override
+        {
+            if (player->GetQuestStatus(QUEST_SPIDER_GOLD) == QUEST_STATUS_INCOMPLETE)
+                player->AreaExploredOrEventHappens(QUEST_SPIDER_GOLD);
 
-        return true;
+            SendGossipMenuFor(player, GOSSIP_TABLE_THEKA, me->GetGUID());
+            return true;
+        }
+    };
+
+    GameObjectAI* GetAI(GameObject* go) const override
+    {
+        return new go_table_thekaAI(go);
     }
 };
 
@@ -816,14 +1046,23 @@ class go_inconspicuous_landmark : public GameObjectScript
 public:
     go_inconspicuous_landmark() : GameObjectScript("go_inconspicuous_landmark") { }
 
-    bool OnGossipHello(Player* player, GameObject* /*go*/) override
+    struct go_inconspicuous_landmarkAI : public GameObjectAI
     {
-        if (player->HasItemCount(ITEM_CUERGOS_KEY))
-            return false;
+        go_inconspicuous_landmarkAI(GameObject* go) : GameObjectAI(go) { }
+
+        bool GossipHello(Player* player, bool /*reportUse*/) override
+        {
+            if (player->HasItemCount(ITEM_CUERGOS_KEY))
+                return false;
 
-        player->CastSpell(player, SPELL_SUMMON_PIRATES_TREASURE_AND_TRIGGER_MOB, true);
+            player->CastSpell(player, SPELL_SUMMON_PIRATES_TREASURE_AND_TRIGGER_MOB, true);
+            return true;
+        }
+    };
 
-        return true;
+    GameObjectAI* GetAI(GameObject* go) const override
+    {
+        return new go_inconspicuous_landmarkAI(go);
     }
 };
 
@@ -844,7 +1083,7 @@ class go_soulwell : public GameObjectScript
 
             bool GossipHello(Player* player, bool /*reportUse*/) override
             {
-                Unit* owner = go->GetOwner();
+                Unit* owner = me->GetOwner();
                 if (!owner || owner->GetTypeId() != TYPEID_PLAYER || !player->IsInSameRaidWith(owner->ToPlayer()))
                     return true;
                 return false;
@@ -877,31 +1116,41 @@ class go_dragonflayer_cage : public GameObjectScript
 public:
     go_dragonflayer_cage() : GameObjectScript("go_dragonflayer_cage") { }
 
-    bool OnGossipHello(Player* player, GameObject* go) override
+    struct go_dragonflayer_cageAI : public GameObjectAI
     {
-        go->UseDoorOrButton();
-        if (player->GetQuestStatus(QUEST_PRISONERS_OF_WYRMSKULL) != QUEST_STATUS_INCOMPLETE)
-            return true;
+        go_dragonflayer_cageAI(GameObject* go) : GameObjectAI(go) { }
 
-        Creature* pPrisoner = go->FindNearestCreature(NPC_PRISONER_PRIEST, 2.0f);
-        if (!pPrisoner)
+        bool GossipHello(Player* player, bool /*reportUse*/) override
         {
-            pPrisoner = go->FindNearestCreature(NPC_PRISONER_MAGE, 2.0f);
+            me->UseDoorOrButton();
+            if (player->GetQuestStatus(QUEST_PRISONERS_OF_WYRMSKULL) != QUEST_STATUS_INCOMPLETE)
+                return true;
+
+            Creature* pPrisoner = me->FindNearestCreature(NPC_PRISONER_PRIEST, 2.0f);
             if (!pPrisoner)
             {
-                pPrisoner = go->FindNearestCreature(NPC_PRISONER_WARRIOR, 2.0f);
+                pPrisoner = me->FindNearestCreature(NPC_PRISONER_MAGE, 2.0f);
                 if (!pPrisoner)
-                    pPrisoner = go->FindNearestCreature(NPC_PRISONER_PALADIN, 2.0f);
+                {
+                    pPrisoner = me->FindNearestCreature(NPC_PRISONER_WARRIOR, 2.0f);
+                    if (!pPrisoner)
+                        pPrisoner = me->FindNearestCreature(NPC_PRISONER_PALADIN, 2.0f);
+                }
             }
-        }
 
-        if (!pPrisoner || !pPrisoner->IsAlive())
+            if (!pPrisoner || !pPrisoner->IsAlive())
+                return true;
+
+            /// @todo prisoner should help player for a short period of time
+            player->KilledMonsterCredit(NPC_CAPTURED_VALGARDE_PRISONER_PROXY);
+            pPrisoner->DespawnOrUnsummon();
             return true;
+        }
+    };
 
-        /// @todo prisoner should help player for a short period of time
-        player->KilledMonsterCredit(NPC_CAPTURED_VALGARDE_PRISONER_PROXY);
-        pPrisoner->DespawnOrUnsummon();
-        return true;
+    GameObjectAI* GetAI(GameObject* go) const override
+    {
+        return new go_dragonflayer_cageAI(go);
     }
 };
 
@@ -921,20 +1170,30 @@ class go_tadpole_cage : public GameObjectScript
 public:
     go_tadpole_cage() : GameObjectScript("go_tadpole_cage") { }
 
-    bool OnGossipHello(Player* player, GameObject* go) override
+    struct go_tadpole_cageAI : public GameObjectAI
     {
-        go->UseDoorOrButton();
-        if (player->GetQuestStatus(QUEST_OH_NOES_THE_TADPOLES) == QUEST_STATUS_INCOMPLETE)
+        go_tadpole_cageAI(GameObject* go) : GameObjectAI(go) { }
+
+        bool GossipHello(Player* player, bool /*reportUse*/) override
         {
-            Creature* pTadpole = go->FindNearestCreature(NPC_WINTERFIN_TADPOLE, 1.0f);
-            if (pTadpole)
+            me->UseDoorOrButton();
+            if (player->GetQuestStatus(QUEST_OH_NOES_THE_TADPOLES) == QUEST_STATUS_INCOMPLETE)
             {
-                pTadpole->DisappearAndDie();
-                player->KilledMonsterCredit(NPC_WINTERFIN_TADPOLE);
-                //FIX: Summon minion tadpole
+                Creature* pTadpole = me->FindNearestCreature(NPC_WINTERFIN_TADPOLE, 1.0f);
+                if (pTadpole)
+                {
+                    pTadpole->DisappearAndDie();
+                    player->KilledMonsterCredit(NPC_WINTERFIN_TADPOLE);
+                    //FIX: Summon minion tadpole
+                }
             }
+            return true;
         }
-        return true;
+    };
+
+    GameObjectAI* GetAI(GameObject* go) const override
+    {
+        return new go_tadpole_cageAI(go);
     }
 };
 
@@ -962,43 +1221,54 @@ class go_amberpine_outhouse : public GameObjectScript
 public:
     go_amberpine_outhouse() : GameObjectScript("go_amberpine_outhouse") { }
 
-    bool OnGossipHello(Player* player, GameObject* go) override
+    struct go_amberpine_outhouseAI : public GameObjectAI
     {
-        QuestStatus status = player->GetQuestStatus(QUEST_DOING_YOUR_DUTY);
-        if (status == QUEST_STATUS_INCOMPLETE || status == QUEST_STATUS_COMPLETE || status == QUEST_STATUS_REWARDED)
-        {
-            AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_USE_OUTHOUSE, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF + 1);
-            SendGossipMenuFor(player, GOSSIP_OUTHOUSE_VACANT, go->GetGUID());
-        }
-        else
-            SendGossipMenuFor(player, GOSSIP_OUTHOUSE_INUSE, go->GetGUID());
-
-        return true;
-    }
+        go_amberpine_outhouseAI(GameObject* go) : GameObjectAI(go) { }
 
-    bool OnGossipSelect(Player* player, GameObject* go, uint32 /*sender*/, uint32 action) override
-    {
-        ClearGossipMenuFor(player);
-        if (action == GOSSIP_ACTION_INFO_DEF +1)
+        bool GossipHello(Player* player, bool /*reportUse*/) override
         {
-            CloseGossipMenuFor(player);
-            Creature* target = GetClosestCreatureWithEntry(player, NPC_OUTHOUSE_BUNNY, 3.0f);
-            if (target)
+            QuestStatus status = player->GetQuestStatus(QUEST_DOING_YOUR_DUTY);
+            if (status == QUEST_STATUS_INCOMPLETE || status == QUEST_STATUS_COMPLETE || status == QUEST_STATUS_REWARDED)
             {
-                target->AI()->SetData(1, player->getGender());
-                go->CastSpell(target, SPELL_INDISPOSED_III);
+                AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_USE_OUTHOUSE, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF + 1);
+                SendGossipMenuFor(player, GOSSIP_OUTHOUSE_VACANT, me->GetGUID());
             }
-            go->CastSpell(player, SPELL_INDISPOSED);
-            if (player->HasItemCount(ITEM_ANDERHOLS_SLIDER_CIDER))
-                go->CastSpell(player, SPELL_CREATE_AMBERSEEDS);
+            else
+                SendGossipMenuFor(player, GOSSIP_OUTHOUSE_INUSE, me->GetGUID());
+
             return true;
         }
-        else
+
+        bool GossipSelect(Player* player, uint32 /*menuId*/, uint32 gossipListId) override
         {
-            CloseGossipMenuFor(player);
-            player->GetSession()->SendNotification(GO_ANDERHOLS_SLIDER_CIDER_NOT_FOUND);
-            return false;
+            uint32 const action = player->PlayerTalkClass->GetGossipOptionAction(gossipListId);
+            ClearGossipMenuFor(player);
+            if (action == GOSSIP_ACTION_INFO_DEF + 1)
+            {
+                CloseGossipMenuFor(player);
+                Creature* target = GetClosestCreatureWithEntry(player, NPC_OUTHOUSE_BUNNY, 3.0f);
+                if (target)
+                {
+                    target->AI()->SetData(1, player->getGender());
+                    me->CastSpell(target, SPELL_INDISPOSED_III);
+                }
+                me->CastSpell(player, SPELL_INDISPOSED);
+                if (player->HasItemCount(ITEM_ANDERHOLS_SLIDER_CIDER))
+                    me->CastSpell(player, SPELL_CREATE_AMBERSEEDS);
+                return true;
+            }
+            else
+            {
+                CloseGossipMenuFor(player);
+                player->GetSession()->SendNotification(GO_ANDERHOLS_SLIDER_CIDER_NOT_FOUND);
+                return false;
+            }
         }
+    };
+
+    GameObjectAI* GetAI(GameObject* go) const override
+    {
+        return new go_amberpine_outhouseAI(go);
     }
 };
 
@@ -1018,12 +1288,22 @@ class go_hive_pod : public GameObjectScript
 public:
     go_hive_pod() : GameObjectScript("go_hive_pod") { }
 
-    bool OnGossipHello(Player* player, GameObject* go) override
+    struct go_hive_podAI : public GameObjectAI
     {
-        player->SendLoot(go->GetGUID(), LOOT_CORPSE);
-        go->SummonCreature(NPC_HIVE_AMBUSHER, go->GetPositionX()+1, go->GetPositionY(), go->GetPositionZ(), go->GetAngle(player), TEMPSUMMON_TIMED_OR_DEAD_DESPAWN, 60000);
-        go->SummonCreature(NPC_HIVE_AMBUSHER, go->GetPositionX(), go->GetPositionY()+1, go->GetPositionZ(), go->GetAngle(player), TEMPSUMMON_TIMED_OR_DEAD_DESPAWN, 60000);
-        return true;
+        go_hive_podAI(GameObject* go) : GameObjectAI(go) { }
+
+        bool GossipHello(Player* player, bool /*reportUse*/) override
+        {
+            player->SendLoot(me->GetGUID(), LOOT_CORPSE);
+            me->SummonCreature(NPC_HIVE_AMBUSHER, me->GetPositionX() + 1, me->GetPositionY(), me->GetPositionZ(), me->GetAngle(player), TEMPSUMMON_TIMED_OR_DEAD_DESPAWN, 60000);
+            me->SummonCreature(NPC_HIVE_AMBUSHER, me->GetPositionX(), me->GetPositionY() + 1, me->GetPositionZ(), me->GetAngle(player), TEMPSUMMON_TIMED_OR_DEAD_DESPAWN, 60000);
+            return true;
+        }
+    };
+
+    GameObjectAI* GetAI(GameObject* go) const override
+    {
+        return new go_hive_podAI(go);
     }
 };
 
@@ -1032,10 +1312,20 @@ class go_massive_seaforium_charge : public GameObjectScript
     public:
         go_massive_seaforium_charge() : GameObjectScript("go_massive_seaforium_charge") { }
 
-        bool OnGossipHello(Player* /*player*/, GameObject* go) override
+        struct go_massive_seaforium_chargeAI : public GameObjectAI
         {
-            go->SetLootState(GO_JUST_DEACTIVATED);
-            return true;
+            go_massive_seaforium_chargeAI(GameObject* go) : GameObjectAI(go) { }
+
+            bool GossipHello(Player* /*player*/, bool /*reportUse*/) override
+            {
+                me->SetLootState(GO_JUST_DEACTIVATED);
+                return true;
+            }
+        };
+
+        GameObjectAI* GetAI(GameObject* go) const override
+        {
+            return new go_massive_seaforium_chargeAI(go);
         }
 };
 
@@ -1055,23 +1345,33 @@ class go_veil_skith_cage : public GameObjectScript
     public:
        go_veil_skith_cage() : GameObjectScript("go_veil_skith_cage") { }
 
-       bool OnGossipHello(Player* player, GameObject* go) override
+       struct go_veil_skith_cageAI : public GameObjectAI
        {
-           go->UseDoorOrButton();
-           if (player->GetQuestStatus(QUEST_MISSING_FRIENDS) == QUEST_STATUS_INCOMPLETE)
+           go_veil_skith_cageAI(GameObject* go) : GameObjectAI(go) { }
+
+           bool GossipHello(Player* player, bool /*reportUse*/) override
            {
-               std::list<Creature*> childrenList;
-               GetCreatureListWithEntryInGrid(childrenList, go, NPC_CAPTIVE_CHILD, INTERACTION_DISTANCE);
-               for (std::list<Creature*>::const_iterator itr = childrenList.begin(); itr != childrenList.end(); ++itr)
+               me->UseDoorOrButton();
+               if (player->GetQuestStatus(QUEST_MISSING_FRIENDS) == QUEST_STATUS_INCOMPLETE)
                {
-                   player->KilledMonsterCredit(NPC_CAPTIVE_CHILD, (*itr)->GetGUID());
-                   (*itr)->DespawnOrUnsummon(5000);
-                   (*itr)->GetMotionMaster()->MovePoint(1, go->GetPositionX()+5, go->GetPositionY(), go->GetPositionZ());
-                   (*itr)->AI()->Talk(SAY_FREE_0);
-                   (*itr)->GetMotionMaster()->Clear();
+                   std::vector<Creature*> childrenList;
+                   GetCreatureListWithEntryInGrid(childrenList, me, NPC_CAPTIVE_CHILD, INTERACTION_DISTANCE);
+                   for (Creature* creature : childrenList)
+                   {
+                       player->KilledMonsterCredit(NPC_CAPTIVE_CHILD, creature->GetGUID());
+                       creature->DespawnOrUnsummon(5000);
+                       creature->GetMotionMaster()->MovePoint(1, me->GetPositionX() + 5, me->GetPositionY(), me->GetPositionZ());
+                       creature->AI()->Talk(SAY_FREE_0);
+                       creature->GetMotionMaster()->Clear();
+                   }
                }
+               return false;
            }
-           return false;
+       };
+
+       GameObjectAI* GetAI(GameObject* go) const override
+       {
+           return new go_veil_skith_cageAI(go);
        }
 };
 
@@ -1092,16 +1392,28 @@ class go_frostblade_shrine : public GameObjectScript
 public:
     go_frostblade_shrine() : GameObjectScript("go_frostblade_shrine") { }
 
-    bool OnGossipHello(Player* player, GameObject* go) override
+    struct go_frostblade_shrineAI : public GameObjectAI
     {
-        go->UseDoorOrButton(10);
-        if (!player->HasAura(SPELL_RECENT_MEDITATION))
-            if (player->GetQuestStatus(QUEST_THE_CLEANSING_HORDE) == QUEST_STATUS_INCOMPLETE || player->GetQuestStatus(QUEST_THE_CLEANSING_ALLIANCE) == QUEST_STATUS_INCOMPLETE)
+        go_frostblade_shrineAI(GameObject* go) : GameObjectAI(go) { }
+
+        bool GossipHello(Player* player, bool /*reportUse*/) override
+        {
+            me->UseDoorOrButton(10);
+            if (!player->HasAura(SPELL_RECENT_MEDITATION))
             {
-                player->CastSpell(player, SPELL_CLEANSING_SOUL);
-                player->SetStandState(UNIT_STAND_STATE_SIT);
+                if (player->GetQuestStatus(QUEST_THE_CLEANSING_HORDE) == QUEST_STATUS_INCOMPLETE || player->GetQuestStatus(QUEST_THE_CLEANSING_ALLIANCE) == QUEST_STATUS_INCOMPLETE)
+                {
+                    player->CastSpell(player, SPELL_CLEANSING_SOUL);
+                    player->SetStandState(UNIT_STAND_STATE_SIT);
+                }
             }
-        return true;
+            return true;
+        }
+    };
+
+    GameObjectAI* GetAI(GameObject* go) const override
+    {
+        return new go_frostblade_shrineAI(go);
     }
 };
 
@@ -1119,11 +1431,21 @@ class go_midsummer_bonfire : public GameObjectScript
 public:
     go_midsummer_bonfire() : GameObjectScript("go_midsummer_bonfire") { }
 
-    bool OnGossipSelect(Player* player, GameObject* /*go*/, uint32 /*sender*/, uint32 /*action*/) override
+    struct go_midsummer_bonfireAI : public GameObjectAI
     {
-        player->CastSpell(player, STAMP_OUT_BONFIRE_QUEST_COMPLETE, true);
-        CloseGossipMenuFor(player);
-        return false;
+        go_midsummer_bonfireAI(GameObject* go) : GameObjectAI(go) { }
+
+        bool GossipSelect(Player* player, uint32 /*menuId*/, uint32 /*gossipListId*/) override
+        {
+            player->CastSpell(player, STAMP_OUT_BONFIRE_QUEST_COMPLETE, true);
+            CloseGossipMenuFor(player);
+            return false;
+        }
+    };
+
+    GameObjectAI* GetAI(GameObject* go) const override
+    {
+        return new go_midsummer_bonfireAI(go);
     }
 };
 
@@ -1140,14 +1462,24 @@ class go_midsummer_ribbon_pole : public GameObjectScript
 public:
     go_midsummer_ribbon_pole() : GameObjectScript("go_midsummer_ribbon_pole") { }
 
-    bool OnGossipHello(Player* player, GameObject* go) override
+    struct go_midsummer_ribbon_poleAI : public GameObjectAI
     {
-        if (Creature* creature = go->FindNearestCreature(NPC_POLE_RIBBON_BUNNY, 10.0f))
+        go_midsummer_ribbon_poleAI(GameObject* go) : GameObjectAI(go) { }
+
+        bool GossipHello(Player* player, bool /*reportUse*/) override
         {
-            creature->GetAI()->DoAction(ACTION_COSMETIC_FIRES);
-            player->CastSpell(creature, SPELL_POLE_DANCE, true);
+            if (Creature* creature = me->FindNearestCreature(NPC_POLE_RIBBON_BUNNY, 10.0f))
+            {
+                creature->GetAI()->DoAction(ACTION_COSMETIC_FIRES);
+                player->CastSpell(creature, SPELL_POLE_DANCE, true);
+            }
+            return true;
         }
-        return true;
+    };
+
+    GameObjectAI* GetAI(GameObject* go) const override
+    {
+        return new go_midsummer_ribbon_poleAI(go);
     }
 };
 
@@ -1171,7 +1503,7 @@ class go_toy_train_set : public GameObjectScript
                     _pulseTimer -= diff;
                 else
                 {
-                    go->CastSpell(nullptr, SPELL_TOY_TRAIN_PULSE, true);
+                    me->CastSpell(nullptr, SPELL_TOY_TRAIN_PULSE, true);
                     _pulseTimer = 6 * IN_MILLISECONDS;
                 }
             }
@@ -1179,7 +1511,7 @@ class go_toy_train_set : public GameObjectScript
             // triggered on wrecker'd
             void DoAction(int32 /*action*/) override
             {
-                go->Delete();
+                me->Delete();
             }
 
         private:
@@ -1271,39 +1603,39 @@ public:
                     if (!IsHolidayActive(HOLIDAY_BREWFEST)) // Check if Brewfest is active
                         break;
                     // Check if gob is correct area, play music, set time of music
-                    if (go->GetAreaId() == SILVERMOON || go->GetAreaId() == UNDERCITY || go->GetAreaId() == ORGRIMMAR_1 || go->GetAreaId() == ORGRIMMAR_2 || go->GetAreaId() == THUNDERBLUFF || go->GetAreaId() == SHATTRATH)
+                    if (me->GetAreaId() == SILVERMOON || me->GetAreaId() == UNDERCITY || me->GetAreaId() == ORGRIMMAR_1 || me->GetAreaId() == ORGRIMMAR_2 || me->GetAreaId() == THUNDERBLUFF || me->GetAreaId() == SHATTRATH)
                     {
                         if (rnd == 0)
                         {
-                            go->PlayDirectMusic(EVENT_BREWFESTGOBLIN01);
+                            me->PlayDirectMusic(EVENT_BREWFESTGOBLIN01);
                             musicTime = EVENT_BREWFESTGOBLIN01_TIME;
                         }
                         else if (rnd == 1)
                         {
-                            go->PlayDirectMusic(EVENT_BREWFESTGOBLIN02);
+                            me->PlayDirectMusic(EVENT_BREWFESTGOBLIN02);
                             musicTime = EVENT_BREWFESTGOBLIN02_TIME;
                         }
                         else
                         {
-                            go->PlayDirectMusic(EVENT_BREWFESTGOBLIN03);
+                            me->PlayDirectMusic(EVENT_BREWFESTGOBLIN03);
                             musicTime = EVENT_BREWFESTGOBLIN03_TIME;
                         }
                     }
-                    if (go->GetAreaId() == IRONFORGE_1 || go->GetAreaId() == IRONFORGE_2 || go->GetAreaId() == STORMWIND || go->GetAreaId() == EXODAR || go->GetAreaId() == DARNASSUS || go->GetAreaId() == SHATTRATH)
+                    if (me->GetAreaId() == IRONFORGE_1 || me->GetAreaId() == IRONFORGE_2 || me->GetAreaId() == STORMWIND || me->GetAreaId() == EXODAR || me->GetAreaId() == DARNASSUS || me->GetAreaId() == SHATTRATH)
                     {
                         if (rnd == 0)
                         {
-                            go->PlayDirectMusic(EVENT_BREWFESTDWARF01);
+                            me->PlayDirectMusic(EVENT_BREWFESTDWARF01);
                             musicTime = EVENT_BREWFESTDWARF01_TIME;
                         }
                         else if (rnd == 1)
                         {
-                            go->PlayDirectMusic(EVENT_BREWFESTDWARF02);
+                            me->PlayDirectMusic(EVENT_BREWFESTDWARF02);
                             musicTime = EVENT_BREWFESTDWARF02_TIME;
                         }
                         else
                         {
-                            go->PlayDirectMusic(EVENT_BREWFESTDWARF03);
+                            me->PlayDirectMusic(EVENT_BREWFESTDWARF03);
                             musicTime = EVENT_BREWFESTDWARF03_TIME;
                         }
                     }
@@ -1364,13 +1696,13 @@ public:
                             break;
 
                         std::vector<Player*> playersNearby;
-                        go->GetPlayerListInGrid(playersNearby, go->GetMap()->GetVisibilityRange());
+                        me->GetPlayerListInGrid(playersNearby, me->GetMap()->GetVisibilityRange());
                         for (Player* player : playersNearby)
                         {
                             if (player->GetTeamId() == TEAM_HORDE)
-                                go->PlayDirectMusic(EVENTMIDSUMMERFIREFESTIVAL_H, player);
+                                me->PlayDirectMusic(EVENTMIDSUMMERFIREFESTIVAL_H, player);
                             else
-                                go->PlayDirectMusic(EVENTMIDSUMMERFIREFESTIVAL_A, player);
+                                me->PlayDirectMusic(EVENTMIDSUMMERFIREFESTIVAL_A, player);
                         }
                         _events.ScheduleEvent(EVENT_MM_START_MUSIC, 5000); // Every 5 second's SMSG_PLAY_MUSIC packet (PlayDirectMusic) is pushed to the client (sniffed value)
                         break;
@@ -1426,7 +1758,7 @@ public:
                 case EVENT_DFM_START_MUSIC:
                     if (!IsHolidayActive(HOLIDAY_DARKMOON_FAIRE_ELWYNN) || !IsHolidayActive(HOLIDAY_DARKMOON_FAIRE_THUNDER) || !IsHolidayActive(HOLIDAY_DARKMOON_FAIRE_SHATTRATH))
                         break;
-                    go->PlayDirectMusic(MUSIC_DARKMOON_FAIRE_MUSIC);
+                    me->PlayDirectMusic(MUSIC_DARKMOON_FAIRE_MUSIC);
                     _events.ScheduleEvent(EVENT_DFM_START_MUSIC, 5000);  // Every 5 second's SMSG_PLAY_MUSIC packet (PlayDirectMusic) is pushed to the client (sniffed value)
                     break;
                 default:
@@ -1480,7 +1812,7 @@ public:
                 case EVENT_PDM_START_MUSIC:
                     if (!IsHolidayActive(HOLIDAY_PIRATES_DAY))
                         break;
-                    go->PlayDirectMusic(MUSIC_PIRATE_DAY_MUSIC);
+                    me->PlayDirectMusic(MUSIC_PIRATE_DAY_MUSIC);
                     _events.ScheduleEvent(EVENT_PDM_START_MUSIC, 5000);  // Every 5 second's SMSG_PLAY_MUSIC packet (PlayDirectMusic) is pushed to the client (sniffed value)
                     break;
                 default:
@@ -1546,16 +1878,16 @@ public:
 
         void InitializeAI() override
         {
-            switch (go->GetEntry())
+            switch (me->GetEntry())
             {
                 case GO_HORDE_BELL:
-                    _soundId = go->GetAreaId() == UNDERCITY_AREA ? BELLTOLLHORDE : BELLTOLLTRIBAL;
+                    _soundId = me->GetAreaId() == UNDERCITY_AREA ? BELLTOLLHORDE : BELLTOLLTRIBAL;
                     break;
                 case GO_ALLIANCE_BELL:
                 {
-                    if (go->GetAreaId() == IRONFORGE_1_AREA || go->GetAreaId() == IRONFORGE_2_AREA)
+                    if (me->GetAreaId() == IRONFORGE_1_AREA || me->GetAreaId() == IRONFORGE_2_AREA)
                         _soundId = BELLTOLLDWARFGNOME;
-                    else if (go->GetAreaId() == DARNASSUS_AREA || go->GetZoneId() == TELDRASSIL_ZONE)
+                    else if (me->GetAreaId() == DARNASSUS_AREA || me->GetZoneId() == TELDRASSIL_ZONE)
                         _soundId = BELLTOLLNIGHTELF;
                     else
                         _soundId = BELLTOLLALLIANCE;
@@ -1591,7 +1923,7 @@ public:
                 switch (eventId)
                 {
                     case EVENT_RING_BELL:
-                        go->PlayDirectSound(_soundId);
+                        me->PlayDirectSound(_soundId);
                         break;
                     default:
                         break;
diff --git a/src/server/scripts/World/npc_innkeeper.cpp b/src/server/scripts/World/npc_innkeeper.cpp
index 3fc1cf6525c..f4e0f3b9361 100644
--- a/src/server/scripts/World/npc_innkeeper.cpp
+++ b/src/server/scripts/World/npc_innkeeper.cpp
@@ -49,86 +49,97 @@ class npc_innkeeper : public CreatureScript
 public:
     npc_innkeeper() : CreatureScript("npc_innkeeper") { }
 
-    bool OnGossipHello(Player* player, Creature* creature) override
+    struct npc_innkeeperAI : public ScriptedAI
     {
-        if (IsHolidayActive(HOLIDAY_HALLOWS_END) && !player->HasAura(SPELL_TRICK_OR_TREATED))
+        npc_innkeeperAI(Creature* creature) : ScriptedAI(creature) { }
+
+        bool GossipHello(Player* player) override
         {
-            const char* localizedEntry;
-            switch (player->GetSession()->GetSessionDbcLocale())
+            if (IsHolidayActive(HOLIDAY_HALLOWS_END) && !player->HasAura(SPELL_TRICK_OR_TREATED))
             {
-                case LOCALE_frFR: localizedEntry = LOCALE_TRICK_OR_TREAT_2; break;
-                case LOCALE_deDE: localizedEntry = LOCALE_TRICK_OR_TREAT_3; break;
-                case LOCALE_esES: localizedEntry = LOCALE_TRICK_OR_TREAT_6; break;
-                case LOCALE_enUS: default: localizedEntry = LOCALE_TRICK_OR_TREAT_0;
+                const char* localizedEntry;
+                switch (player->GetSession()->GetSessionDbcLocale())
+                {
+                    case LOCALE_frFR: localizedEntry = LOCALE_TRICK_OR_TREAT_2; break;
+                    case LOCALE_deDE: localizedEntry = LOCALE_TRICK_OR_TREAT_3; break;
+                    case LOCALE_esES: localizedEntry = LOCALE_TRICK_OR_TREAT_6; break;
+                    case LOCALE_enUS: default: localizedEntry = LOCALE_TRICK_OR_TREAT_0;
+                }
+                AddGossipItemFor(player, GOSSIP_ICON_CHAT, localizedEntry, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF + 1);
             }
-            AddGossipItemFor(player, GOSSIP_ICON_CHAT, localizedEntry, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF + 1);
-        }
 
-        if (creature->IsQuestGiver())
-            player->PrepareQuestMenu(creature->GetGUID());
+            if (me->IsQuestGiver())
+                player->PrepareQuestMenu(me->GetGUID());
 
-        if (creature->IsVendor())
-            AddGossipItemFor(player, GOSSIP_ICON_VENDOR, GOSSIP_TEXT_BROWSE_GOODS, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_TRADE);
+            if (me->IsVendor())
+                AddGossipItemFor(player, GOSSIP_ICON_VENDOR, GOSSIP_TEXT_BROWSE_GOODS, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_TRADE);
 
-        if (creature->IsInnkeeper())
-        {
-            const char* localizedEntry;
-            switch (player->GetSession()->GetSessionDbcLocale())
+            if (me->IsInnkeeper())
             {
-                case LOCALE_deDE: localizedEntry = LOCALE_INNKEEPER_3; break;
-                case LOCALE_enUS: default: localizedEntry = LOCALE_INNKEEPER_0;
+                const char* localizedEntry;
+                switch (player->GetSession()->GetSessionDbcLocale())
+                {
+                    case LOCALE_deDE: localizedEntry = LOCALE_INNKEEPER_3; break;
+                    case LOCALE_enUS: default: localizedEntry = LOCALE_INNKEEPER_0;
+                }
+                AddGossipItemFor(player, GOSSIP_ICON_INTERACT_1, localizedEntry, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INN);
             }
-            AddGossipItemFor(player, GOSSIP_ICON_INTERACT_1, localizedEntry, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INN);
-        }
 
-        player->TalkedToCreature(creature->GetEntry(), creature->GetGUID());
-        SendGossipMenuFor(player, player->GetGossipTextId(creature), creature->GetGUID());
-        return true;
-    }
+            player->TalkedToCreature(me->GetEntry(), me->GetGUID());
+            SendGossipMenuFor(player, player->GetGossipTextId(me), me->GetGUID());
+            return true;
+        }
 
-    bool OnGossipSelect(Player* player, Creature* creature, uint32 /*sender*/, uint32 action) override
-    {
-        ClearGossipMenuFor(player);
-        if (action == GOSSIP_ACTION_INFO_DEF + 1 && IsHolidayActive(HOLIDAY_HALLOWS_END) && !player->HasAura(SPELL_TRICK_OR_TREATED))
+        bool GossipSelect(Player* player, uint32 /*menuId*/, uint32 gossipListId) override
         {
-            player->CastSpell(player, SPELL_TRICK_OR_TREATED, true);
-
-            if (urand(0, 1))
-                player->CastSpell(player, SPELL_TREAT, true);
-            else
+            uint32 const action = player->PlayerTalkClass->GetGossipOptionAction(gossipListId);
+            ClearGossipMenuFor(player);
+            if (action == GOSSIP_ACTION_INFO_DEF + 1 && IsHolidayActive(HOLIDAY_HALLOWS_END) && !player->HasAura(SPELL_TRICK_OR_TREATED))
             {
-                uint32 trickspell = 0;
-                switch (urand(0, 13))
+                player->CastSpell(player, SPELL_TRICK_OR_TREATED, true);
+
+                if (urand(0, 1))
+                    player->CastSpell(player, SPELL_TREAT, true);
+                else
                 {
-                    case 0: trickspell = 24753; break; // cannot cast, random 30sec
-                    case 1: trickspell = 24713; break; // lepper gnome costume
-                    case 2: trickspell = 24735; break; // male ghost costume
-                    case 3: trickspell = 24736; break; // female ghostcostume
-                    case 4: trickspell = 24710; break; // male ninja costume
-                    case 5: trickspell = 24711; break; // female ninja costume
-                    case 6: trickspell = 24708; break; // male pirate costume
-                    case 7: trickspell = 24709; break; // female pirate costume
-                    case 8: trickspell = 24723; break; // skeleton costume
-                    case 9: trickspell = 24753; break; // Trick
-                    case 10: trickspell = 24924; break; // Hallow's End Candy
-                    case 11: trickspell = 24925; break; // Hallow's End Candy
-                    case 12: trickspell = 24926; break; // Hallow's End Candy
-                    case 13: trickspell = 24927; break; // Hallow's End Candy
+                    uint32 trickspell = 0;
+                    switch (urand(0, 13))
+                    {
+                        case 0: trickspell = 24753; break; // cannot cast, random 30sec
+                        case 1: trickspell = 24713; break; // lepper gnome costume
+                        case 2: trickspell = 24735; break; // male ghost costume
+                        case 3: trickspell = 24736; break; // female ghostcostume
+                        case 4: trickspell = 24710; break; // male ninja costume
+                        case 5: trickspell = 24711; break; // female ninja costume
+                        case 6: trickspell = 24708; break; // male pirate costume
+                        case 7: trickspell = 24709; break; // female pirate costume
+                        case 8: trickspell = 24723; break; // skeleton costume
+                        case 9: trickspell = 24753; break; // Trick
+                        case 10: trickspell = 24924; break; // Hallow's End Candy
+                        case 11: trickspell = 24925; break; // Hallow's End Candy
+                        case 12: trickspell = 24926; break; // Hallow's End Candy
+                        case 13: trickspell = 24927; break; // Hallow's End Candy
+                    }
+                    player->CastSpell(player, trickspell, true);
                 }
-                player->CastSpell(player, trickspell, true);
+                CloseGossipMenuFor(player);
+                return true;
             }
+
             CloseGossipMenuFor(player);
+
+            switch (action)
+            {
+                case GOSSIP_ACTION_TRADE: player->GetSession()->SendListInventory(me->GetGUID()); break;
+                case GOSSIP_ACTION_INN: player->SetBindPoint(me->GetGUID()); break;
+            }
             return true;
         }
+    };
 
-        CloseGossipMenuFor(player);
-
-        switch (action)
-        {
-            case GOSSIP_ACTION_TRADE: player->GetSession()->SendListInventory(creature->GetGUID()); break;
-            case GOSSIP_ACTION_INN: player->SetBindPoint(creature->GetGUID()); break;
-        }
-        return true;
+    CreatureAI* GetAI(Creature* creature) const override
+    {
+        return new npc_innkeeperAI(creature);
     }
 };
 
diff --git a/src/server/scripts/World/npc_professions.cpp b/src/server/scripts/World/npc_professions.cpp
index a28a0e38abf..0d5bd2a29dc 100644
--- a/src/server/scripts/World/npc_professions.cpp
+++ b/src/server/scripts/World/npc_professions.cpp
@@ -432,159 +432,171 @@ class npc_prof_alchemy : public CreatureScript
 public:
     npc_prof_alchemy() : CreatureScript("npc_prof_alchemy") { }
 
-    inline bool HasAlchemySpell(Player* player)
+    struct npc_prof_alchemyAI : public ScriptedAI
     {
-        return (player->HasSpell(S_TRANSMUTE) || player->HasSpell(S_ELIXIR) || player->HasSpell(S_POTION));
-    }
+        npc_prof_alchemyAI(Creature* creature) : ScriptedAI(creature) { }
 
-    bool OnGossipHello(Player* player, Creature* creature) override
-    {
-        if (creature->IsQuestGiver())
-            player->PrepareQuestMenu(creature->GetGUID());
+        inline bool HasAlchemySpell(Player* player)
+        {
+            return (player->HasSpell(S_TRANSMUTE) || player->HasSpell(S_ELIXIR) || player->HasSpell(S_POTION));
+        }
 
-        if (creature->IsVendor())
-            AddGossipItemFor(player, GOSSIP_ICON_VENDOR, GOSSIP_TEXT_BROWSE_GOODS, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_TRADE);
+        bool GossipHello(Player* player) override
+        {
+            if (me->IsQuestGiver())
+                player->PrepareQuestMenu(me->GetGUID());
 
-        if (creature->IsTrainer())
-            AddGossipItemFor(player, GOSSIP_ICON_TRAINER, GOSSIP_TEXT_TRAIN, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_TRAIN);
+            if (me->IsVendor())
+                AddGossipItemFor(player, GOSSIP_ICON_VENDOR, GOSSIP_TEXT_BROWSE_GOODS, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_TRADE);
 
-        if (player->HasSkill(SKILL_ALCHEMY) && player->GetBaseSkillValue(SKILL_ALCHEMY) >= 350 && player->getLevel() > 67)
-        {
-            if (player->GetQuestRewardStatus(Q_MASTER_TRANSMUTE) || player->GetQuestRewardStatus(Q_MASTER_ELIXIR) || player->GetQuestRewardStatus(Q_MASTER_POTION))
+            if (me->IsTrainer())
+                AddGossipItemFor(player, GOSSIP_ICON_TRAINER, GOSSIP_TEXT_TRAIN, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_TRAIN);
+
+            if (player->HasSkill(SKILL_ALCHEMY) && player->GetBaseSkillValue(SKILL_ALCHEMY) >= 350 && player->getLevel() > 67)
             {
-                switch (creature->GetEntry())
+                if (player->GetQuestRewardStatus(Q_MASTER_TRANSMUTE) || player->GetQuestRewardStatus(Q_MASTER_ELIXIR) || player->GetQuestRewardStatus(Q_MASTER_POTION))
                 {
-                    case N_TRAINER_TRANSMUTE:                                 //Zarevhi
-                        if (!HasAlchemySpell(player))
-                            AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_LEARN_TRANSMUTE,    GOSSIP_SENDER_LEARN,    GOSSIP_ACTION_INFO_DEF + 1);
-                        if (player->HasSpell(S_TRANSMUTE))
-                            AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_UNLEARN_TRANSMUTE,  GOSSIP_SENDER_UNLEARN,  GOSSIP_ACTION_INFO_DEF + 4);
-                        break;
-                    case N_TRAINER_ELIXIR:                                 //Lorokeem
-                        if (!HasAlchemySpell(player))
-                            AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_LEARN_ELIXIR,       GOSSIP_SENDER_LEARN,    GOSSIP_ACTION_INFO_DEF + 2);
-                        if (player->HasSpell(S_ELIXIR))
-                            AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_UNLEARN_ELIXIR,     GOSSIP_SENDER_UNLEARN,  GOSSIP_ACTION_INFO_DEF + 5);
-                        break;
-                    case N_TRAINER_POTION:                                 //Lauranna Thar'well
-                        if (!HasAlchemySpell(player))
-                            AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_LEARN_POTION,       GOSSIP_SENDER_LEARN,    GOSSIP_ACTION_INFO_DEF + 3);
-                        if (player->HasSpell(S_POTION))
-                            AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_UNLEARN_POTION,     GOSSIP_SENDER_UNLEARN,  GOSSIP_ACTION_INFO_DEF + 6);
-                        break;
+                    switch (me->GetEntry())
+                    {
+                        case N_TRAINER_TRANSMUTE:                                 //Zarevhi
+                            if (!HasAlchemySpell(player))
+                                AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_LEARN_TRANSMUTE, GOSSIP_SENDER_LEARN, GOSSIP_ACTION_INFO_DEF + 1);
+                            if (player->HasSpell(S_TRANSMUTE))
+                                AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_UNLEARN_TRANSMUTE, GOSSIP_SENDER_UNLEARN, GOSSIP_ACTION_INFO_DEF + 4);
+                            break;
+                        case N_TRAINER_ELIXIR:                                 //Lorokeem
+                            if (!HasAlchemySpell(player))
+                                AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_LEARN_ELIXIR, GOSSIP_SENDER_LEARN, GOSSIP_ACTION_INFO_DEF + 2);
+                            if (player->HasSpell(S_ELIXIR))
+                                AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_UNLEARN_ELIXIR, GOSSIP_SENDER_UNLEARN, GOSSIP_ACTION_INFO_DEF + 5);
+                            break;
+                        case N_TRAINER_POTION:                                 //Lauranna Thar'well
+                            if (!HasAlchemySpell(player))
+                                AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_LEARN_POTION, GOSSIP_SENDER_LEARN, GOSSIP_ACTION_INFO_DEF + 3);
+                            if (player->HasSpell(S_POTION))
+                                AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_UNLEARN_POTION, GOSSIP_SENDER_UNLEARN, GOSSIP_ACTION_INFO_DEF + 6);
+                            break;
+                    }
                 }
             }
-        }
-
-        SendGossipMenuFor(player, player->GetGossipTextId(creature), creature->GetGUID());
-        return true;
-    }
 
-    void SendActionMenu(Player* player, Creature* creature, uint32 action)
-    {
-        switch (action)
-        {
-            case GOSSIP_ACTION_TRADE:
-                player->GetSession()->SendListInventory(creature->GetGUID());
-                break;
-            case GOSSIP_ACTION_TRAIN:
-                player->GetSession()->SendTrainerList(creature, TRAINER_ID_ALCHEMY);
-                break;
-                //Learn Alchemy
-            case GOSSIP_ACTION_INFO_DEF + 1:
-                ProcessCastaction(player, creature, S_TRANSMUTE, S_LEARN_TRANSMUTE, DoLearnCost(player));
-                break;
-            case GOSSIP_ACTION_INFO_DEF + 2:
-                ProcessCastaction(player, creature, S_ELIXIR, S_LEARN_ELIXIR, DoLearnCost(player));
-                break;
-            case GOSSIP_ACTION_INFO_DEF + 3:
-                ProcessCastaction(player, creature, S_POTION, S_LEARN_POTION, DoLearnCost(player));
-                break;
-                //Unlearn Alchemy
-            case GOSSIP_ACTION_INFO_DEF + 4:
-                ProcessCastaction(player, creature, 0, S_UNLEARN_TRANSMUTE, DoHighUnlearnCost(player));
-                break;
-            case GOSSIP_ACTION_INFO_DEF + 5:
-                ProcessCastaction(player, creature, 0, S_UNLEARN_ELIXIR, DoHighUnlearnCost(player));
-                break;
-            case GOSSIP_ACTION_INFO_DEF + 6:
-                ProcessCastaction(player, creature, 0, S_UNLEARN_POTION, DoHighUnlearnCost(player));
-                break;
+            SendGossipMenuFor(player, player->GetGossipTextId(me), me->GetGUID());
+            return true;
         }
-    }
 
-    void SendConfirmLearn(Player* player, Creature* creature, uint32 action)
-    {
-        if (action)
+        void SendActionMenu(Player* player, uint32 action)
         {
-            switch (creature->GetEntry())
+            switch (action)
             {
-                case N_TRAINER_TRANSMUTE:
-                    AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_LEARN_TRANSMUTE, GOSSIP_SENDER_CHECK, action);
-                                                                //unknown textID ()
-                    SendGossipMenuFor(player, player->GetGossipTextId(creature), creature->GetGUID());
+                case GOSSIP_ACTION_TRADE:
+                    player->GetSession()->SendListInventory(me->GetGUID());
+                    break;
+                case GOSSIP_ACTION_TRAIN:
+                    player->GetSession()->SendTrainerList(me, TRAINER_ID_ALCHEMY);
+                    break;
+                    //Learn Alchemy
+                case GOSSIP_ACTION_INFO_DEF + 1:
+                    ProcessCastaction(player, me, S_TRANSMUTE, S_LEARN_TRANSMUTE, DoLearnCost(player));
                     break;
-                case N_TRAINER_ELIXIR:
-                    AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_LEARN_ELIXIR,    GOSSIP_SENDER_CHECK, action);
-                                                                //unknown textID ()
-                    SendGossipMenuFor(player, player->GetGossipTextId(creature), creature->GetGUID());
+                case GOSSIP_ACTION_INFO_DEF + 2:
+                    ProcessCastaction(player, me, S_ELIXIR, S_LEARN_ELIXIR, DoLearnCost(player));
                     break;
-                case N_TRAINER_POTION:
-                    AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_LEARN_POTION,    GOSSIP_SENDER_CHECK, action);
-                                                                //unknown textID ()
-                    SendGossipMenuFor(player, player->GetGossipTextId(creature), creature->GetGUID());
+                case GOSSIP_ACTION_INFO_DEF + 3:
+                    ProcessCastaction(player, me, S_POTION, S_LEARN_POTION, DoLearnCost(player));
+                    break;
+                    //Unlearn Alchemy
+                case GOSSIP_ACTION_INFO_DEF + 4:
+                    ProcessCastaction(player, me, 0, S_UNLEARN_TRANSMUTE, DoHighUnlearnCost(player));
+                    break;
+                case GOSSIP_ACTION_INFO_DEF + 5:
+                    ProcessCastaction(player, me, 0, S_UNLEARN_ELIXIR, DoHighUnlearnCost(player));
+                    break;
+                case GOSSIP_ACTION_INFO_DEF + 6:
+                    ProcessCastaction(player, me, 0, S_UNLEARN_POTION, DoHighUnlearnCost(player));
                     break;
             }
         }
-    }
 
-    void SendConfirmUnlearn(Player* player, Creature* creature, uint32 action)
-    {
-        if (action)
+        void SendConfirmLearn(Player* player, uint32 action)
         {
-            switch (creature->GetEntry())
+            if (action)
             {
-                case N_TRAINER_TRANSMUTE:
-                    AddGossipItemFor(player, 0, GOSSIP_UNLEARN_TRANSMUTE, GOSSIP_SENDER_CHECK, action, BOX_UNLEARN_ALCHEMY_SPEC, DoHighUnlearnCost(player), false);
-                                                                //unknown textID ()
-                    SendGossipMenuFor(player, player->GetGossipTextId(creature), creature->GetGUID());
-                    break;
-                case N_TRAINER_ELIXIR:
-                    AddGossipItemFor(player, 0, GOSSIP_UNLEARN_ELIXIR, GOSSIP_SENDER_CHECK, action,    BOX_UNLEARN_ALCHEMY_SPEC, DoHighUnlearnCost(player), false);
-                                                                //unknown textID ()
-                    SendGossipMenuFor(player, player->GetGossipTextId(creature), creature->GetGUID());
-                    break;
-                case N_TRAINER_POTION:
-                    AddGossipItemFor(player, 0, GOSSIP_UNLEARN_POTION, GOSSIP_SENDER_CHECK, action,    BOX_UNLEARN_ALCHEMY_SPEC, DoHighUnlearnCost(player), false);
-                                                                //unknown textID ()
-                    SendGossipMenuFor(player, player->GetGossipTextId(creature), creature->GetGUID());
-                    break;
+                switch (me->GetEntry())
+                {
+                    case N_TRAINER_TRANSMUTE:
+                        AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_LEARN_TRANSMUTE, GOSSIP_SENDER_CHECK, action);
+                        //unknown textID ()
+                        SendGossipMenuFor(player, player->GetGossipTextId(me), me->GetGUID());
+                        break;
+                    case N_TRAINER_ELIXIR:
+                        AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_LEARN_ELIXIR, GOSSIP_SENDER_CHECK, action);
+                        //unknown textID ()
+                        SendGossipMenuFor(player, player->GetGossipTextId(me), me->GetGUID());
+                        break;
+                    case N_TRAINER_POTION:
+                        AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_LEARN_POTION, GOSSIP_SENDER_CHECK, action);
+                        //unknown textID ()
+                        SendGossipMenuFor(player, player->GetGossipTextId(me), me->GetGUID());
+                        break;
+                }
             }
         }
-    }
 
-    bool OnGossipSelect(Player* player, Creature* creature, uint32 sender, uint32 action) override
-    {
-        ClearGossipMenuFor(player);
-        switch (sender)
+        void SendConfirmUnlearn(Player* player, uint32 action)
+        {
+            if (action)
+            {
+                switch (me->GetEntry())
+                {
+                    case N_TRAINER_TRANSMUTE:
+                        AddGossipItemFor(player, 0, GOSSIP_UNLEARN_TRANSMUTE, GOSSIP_SENDER_CHECK, action, BOX_UNLEARN_ALCHEMY_SPEC, DoHighUnlearnCost(player), false);
+                        //unknown textID ()
+                        SendGossipMenuFor(player, player->GetGossipTextId(me), me->GetGUID());
+                        break;
+                    case N_TRAINER_ELIXIR:
+                        AddGossipItemFor(player, 0, GOSSIP_UNLEARN_ELIXIR, GOSSIP_SENDER_CHECK, action, BOX_UNLEARN_ALCHEMY_SPEC, DoHighUnlearnCost(player), false);
+                        //unknown textID ()
+                        SendGossipMenuFor(player, player->GetGossipTextId(me), me->GetGUID());
+                        break;
+                    case N_TRAINER_POTION:
+                        AddGossipItemFor(player, 0, GOSSIP_UNLEARN_POTION, GOSSIP_SENDER_CHECK, action, BOX_UNLEARN_ALCHEMY_SPEC, DoHighUnlearnCost(player), false);
+                        //unknown textID ()
+                        SendGossipMenuFor(player, player->GetGossipTextId(me), me->GetGUID());
+                        break;
+                }
+            }
+        }
+
+        bool GossipSelect(Player* player, uint32 /*menuId*/, uint32 gossipListId) override
         {
-            case GOSSIP_SENDER_MAIN:
-                SendActionMenu(player, creature, action);
-                break;
+            uint32 const sender = player->PlayerTalkClass->GetGossipOptionSender(gossipListId);
+            uint32 const action = player->PlayerTalkClass->GetGossipOptionAction(gossipListId);
+            ClearGossipMenuFor(player);
+            switch (sender)
+            {
+                case GOSSIP_SENDER_MAIN:
+                    SendActionMenu(player, action);
+                    break;
 
-            case GOSSIP_SENDER_LEARN:
-                SendConfirmLearn(player, creature, action);
-                break;
+                case GOSSIP_SENDER_LEARN:
+                    SendConfirmLearn(player, action);
+                    break;
 
-            case GOSSIP_SENDER_UNLEARN:
-                SendConfirmUnlearn(player, creature, action);
-                break;
+                case GOSSIP_SENDER_UNLEARN:
+                    SendConfirmUnlearn(player, action);
+                    break;
 
-            case GOSSIP_SENDER_CHECK:
-                SendActionMenu(player, creature, action);
-                break;
+                case GOSSIP_SENDER_CHECK:
+                    SendActionMenu(player, action);
+                    break;
+            }
+            return true;
         }
-        return true;
+    };
+
+    CreatureAI* GetAI(Creature* creature) const override
+    {
+        return new npc_prof_alchemyAI(creature);
     }
 };
 
@@ -597,224 +609,236 @@ class npc_prof_blacksmith : public CreatureScript
 public:
     npc_prof_blacksmith() : CreatureScript("npc_prof_blacksmith") { }
 
-    inline bool HasWeaponSub(Player* player)
+    struct npc_prof_blacksmithAI : public ScriptedAI
     {
-        return (player->HasSpell(S_HAMMER) || player->HasSpell(S_AXE) || player->HasSpell(S_SWORD));
-    }
+        npc_prof_blacksmithAI(Creature* creature) : ScriptedAI(creature) { }
 
-    bool OnGossipHello(Player* player, Creature* creature) override
-    {
-        if (creature->IsQuestGiver())
-            player->PrepareQuestMenu(creature->GetGUID());
+        inline bool HasWeaponSub(Player* player)
+        {
+            return (player->HasSpell(S_HAMMER) || player->HasSpell(S_AXE) || player->HasSpell(S_SWORD));
+        }
 
-        if (creature->IsVendor())
-            AddGossipItemFor(player, GOSSIP_ICON_VENDOR, GOSSIP_TEXT_BROWSE_GOODS, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_TRADE);
+        bool GossipHello(Player* player) override
+        {
+            if (me->IsQuestGiver())
+                player->PrepareQuestMenu(me->GetGUID());
 
-        if (creature->IsTrainer())
-            AddGossipItemFor(player, GOSSIP_ICON_TRAINER, GOSSIP_TEXT_TRAIN, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_TRAIN);
+            if (me->IsVendor())
+                AddGossipItemFor(player, GOSSIP_ICON_VENDOR, GOSSIP_TEXT_BROWSE_GOODS, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_TRADE);
 
-        uint32 creatureId = creature->GetEntry();
-        //WEAPONSMITH & ARMORSMITH
-        if (player->GetBaseSkillValue(SKILL_BLACKSMITHING) >= 225)
-        {
-            switch (creatureId)
+            if (me->IsTrainer())
+                AddGossipItemFor(player, GOSSIP_ICON_TRAINER, GOSSIP_TEXT_TRAIN, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_TRAIN);
+
+            uint32 creatureId = me->GetEntry();
+            //WEAPONSMITH & ARMORSMITH
+            if (player->GetBaseSkillValue(SKILL_BLACKSMITHING) >= 225)
             {
-                case N_TRAINER_SMITHOMNI1:
-                case N_TRAINER_SMITHOMNI2:
-                    if (!player->HasSpell(S_ARMOR) && !player->HasSpell(S_WEAPON) && player->GetReputationRank(REP_ARMOR) >= REP_FRIENDLY)
-                        AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_ARMOR_LEARN,   GOSSIP_SENDER_MAIN,          GOSSIP_ACTION_INFO_DEF + 1);
-                    if (!player->HasSpell(S_WEAPON) && !player->HasSpell(S_ARMOR) && player->GetReputationRank(REP_WEAPON) >= REP_FRIENDLY)
-                        AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_WEAPON_LEARN,  GOSSIP_SENDER_MAIN,          GOSSIP_ACTION_INFO_DEF + 2);
-                    break;
-                case N_TRAINER_WEAPON1:
-                case N_TRAINER_WEAPON2:
-                    if (player->HasSpell(S_WEAPON))
-                        AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_WEAPON_UNLEARN,    GOSSIP_SENDER_UNLEARN,   GOSSIP_ACTION_INFO_DEF + 3);
-                    break;
-                case N_TRAINER_ARMOR1:
-                case N_TRAINER_ARMOR2:
-                    if (player->HasSpell(S_ARMOR))
-                        AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_ARMOR_UNLEARN,     GOSSIP_SENDER_UNLEARN,   GOSSIP_ACTION_INFO_DEF + 4);
-                    break;
+                switch (creatureId)
+                {
+                    case N_TRAINER_SMITHOMNI1:
+                    case N_TRAINER_SMITHOMNI2:
+                        if (!player->HasSpell(S_ARMOR) && !player->HasSpell(S_WEAPON) && player->GetReputationRank(REP_ARMOR) >= REP_FRIENDLY)
+                            AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_ARMOR_LEARN, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF + 1);
+                        if (!player->HasSpell(S_WEAPON) && !player->HasSpell(S_ARMOR) && player->GetReputationRank(REP_WEAPON) >= REP_FRIENDLY)
+                            AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_WEAPON_LEARN, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF + 2);
+                        break;
+                    case N_TRAINER_WEAPON1:
+                    case N_TRAINER_WEAPON2:
+                        if (player->HasSpell(S_WEAPON))
+                            AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_WEAPON_UNLEARN, GOSSIP_SENDER_UNLEARN, GOSSIP_ACTION_INFO_DEF + 3);
+                        break;
+                    case N_TRAINER_ARMOR1:
+                    case N_TRAINER_ARMOR2:
+                        if (player->HasSpell(S_ARMOR))
+                            AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_ARMOR_UNLEARN, GOSSIP_SENDER_UNLEARN, GOSSIP_ACTION_INFO_DEF + 4);
+                        break;
+                }
+            }
+            //WEAPONSMITH SPEC
+            if (player->HasSpell(S_WEAPON) && player->getLevel() > 49 && player->GetBaseSkillValue(SKILL_BLACKSMITHING) >= 250)
+            {
+                switch (creatureId)
+                {
+                    case N_TRAINER_HAMMER:
+                        if (!HasWeaponSub(player))
+                            AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_LEARN_HAMMER, GOSSIP_SENDER_LEARN, GOSSIP_ACTION_INFO_DEF + 5);
+                        if (player->HasSpell(S_HAMMER))
+                            AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_UNLEARN_HAMMER, GOSSIP_SENDER_UNLEARN, GOSSIP_ACTION_INFO_DEF + 8);
+                        break;
+                    case N_TRAINER_AXE:
+                        if (!HasWeaponSub(player))
+                            AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_LEARN_AXE, GOSSIP_SENDER_LEARN, GOSSIP_ACTION_INFO_DEF + 6);
+                        if (player->HasSpell(S_AXE))
+                            AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_UNLEARN_AXE, GOSSIP_SENDER_UNLEARN, GOSSIP_ACTION_INFO_DEF + 9);
+                        break;
+                    case N_TRAINER_SWORD:
+                        if (!HasWeaponSub(player))
+                            AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_LEARN_SWORD, GOSSIP_SENDER_LEARN, GOSSIP_ACTION_INFO_DEF + 7);
+                        if (player->HasSpell(S_SWORD))
+                            AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_UNLEARN_SWORD, GOSSIP_SENDER_UNLEARN, GOSSIP_ACTION_INFO_DEF + 10);
+                        break;
+                }
             }
+
+            SendGossipMenuFor(player, player->GetGossipTextId(me), me->GetGUID());
+            return true;
         }
-        //WEAPONSMITH SPEC
-        if (player->HasSpell(S_WEAPON) && player->getLevel() > 49 && player->GetBaseSkillValue(SKILL_BLACKSMITHING) >= 250)
+
+        void SendActionMenu(Player* player, uint32 action)
         {
-            switch (creatureId)
+            switch (action)
             {
-                case N_TRAINER_HAMMER:
-                    if (!HasWeaponSub(player))
-                        AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_LEARN_HAMMER,       GOSSIP_SENDER_LEARN,    GOSSIP_ACTION_INFO_DEF + 5);
-                    if (player->HasSpell(S_HAMMER))
-                        AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_UNLEARN_HAMMER,     GOSSIP_SENDER_UNLEARN,  GOSSIP_ACTION_INFO_DEF + 8);
+                case GOSSIP_ACTION_TRADE:
+                    player->GetSession()->SendListInventory(me->GetGUID());
+                    break;
+                case GOSSIP_ACTION_TRAIN:
+                    player->GetSession()->SendTrainerList(me, TRAINER_ID_BLACKSMITHING);
                     break;
-                case N_TRAINER_AXE:
-                    if (!HasWeaponSub(player))
-                        AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_LEARN_AXE,          GOSSIP_SENDER_LEARN,    GOSSIP_ACTION_INFO_DEF + 6);
-                    if (player->HasSpell(S_AXE))
-                        AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_UNLEARN_AXE,        GOSSIP_SENDER_UNLEARN,  GOSSIP_ACTION_INFO_DEF + 9);
+                    //Learn Armor/Weapon
+                case GOSSIP_ACTION_INFO_DEF + 1:
+                    if (!player->HasSpell(S_ARMOR))
+                    {
+                        player->CastSpell(player, S_LEARN_ARMOR, true);
+                        //_Creature->CastSpell(player, S_REP_ARMOR, true);
+                    }
+                    CloseGossipMenuFor(player);
                     break;
-                case N_TRAINER_SWORD:
-                    if (!HasWeaponSub(player))
-                        AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_LEARN_SWORD,        GOSSIP_SENDER_LEARN,    GOSSIP_ACTION_INFO_DEF + 7);
-                    if (player->HasSpell(S_SWORD))
-                        AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_UNLEARN_SWORD,      GOSSIP_SENDER_UNLEARN,  GOSSIP_ACTION_INFO_DEF + 10);
+                case GOSSIP_ACTION_INFO_DEF + 2:
+                    if (!player->HasSpell(S_WEAPON))
+                    {
+                        player->CastSpell(player, S_LEARN_WEAPON, true);
+                        //_Creature->CastSpell(player, S_REP_WEAPON, true);
+                    }
+                    CloseGossipMenuFor(player);
+                    break;
+                    //Unlearn Armor/Weapon
+                case GOSSIP_ACTION_INFO_DEF + 3:
+                    if (HasWeaponSub(player))
+                    {
+                        //unknown textID (TALK_MUST_UNLEARN_WEAPON)
+                        SendGossipMenuFor(player, player->GetGossipTextId(me), me->GetGUID());
+                    }
+                    else
+                        ProcessUnlearnAction(player, me, S_UNLEARN_WEAPON, S_REP_ARMOR, DoLowUnlearnCost(player));
+                    break;
+                case GOSSIP_ACTION_INFO_DEF + 4:
+                    ProcessUnlearnAction(player, me, S_UNLEARN_ARMOR, S_REP_WEAPON, DoLowUnlearnCost(player));
+                    break;
+                    //Learn Hammer/Axe/Sword
+                case GOSSIP_ACTION_INFO_DEF + 5:
+                    player->CastSpell(player, S_LEARN_HAMMER, true);
+                    CloseGossipMenuFor(player);
+                    break;
+                case GOSSIP_ACTION_INFO_DEF + 6:
+                    player->CastSpell(player, S_LEARN_AXE, true);
+                    CloseGossipMenuFor(player);
+                    break;
+                case GOSSIP_ACTION_INFO_DEF + 7:
+                    player->CastSpell(player, S_LEARN_SWORD, true);
+                    CloseGossipMenuFor(player);
+                    break;
+                    //Unlearn Hammer/Axe/Sword
+                case GOSSIP_ACTION_INFO_DEF + 8:
+                    ProcessUnlearnAction(player, me, S_UNLEARN_HAMMER, 0, DoMedUnlearnCost(player));
+                    break;
+                case GOSSIP_ACTION_INFO_DEF + 9:
+                    ProcessUnlearnAction(player, me, S_UNLEARN_AXE, 0, DoMedUnlearnCost(player));
+                    break;
+                case GOSSIP_ACTION_INFO_DEF + 10:
+                    ProcessUnlearnAction(player, me, S_UNLEARN_SWORD, 0, DoMedUnlearnCost(player));
                     break;
             }
         }
 
-        SendGossipMenuFor(player, player->GetGossipTextId(creature), creature->GetGUID());
-        return true;
-    }
-
-    void SendActionMenu(Player* player, Creature* creature, uint32 action)
-    {
-        switch (action)
+        void SendConfirmLearn(Player* player, uint32 action)
         {
-            case GOSSIP_ACTION_TRADE:
-                player->GetSession()->SendListInventory(creature->GetGUID());
-                break;
-            case GOSSIP_ACTION_TRAIN:
-                player->GetSession()->SendTrainerList(creature, TRAINER_ID_BLACKSMITHING);
-                break;
-                //Learn Armor/Weapon
-            case GOSSIP_ACTION_INFO_DEF + 1:
-                if (!player->HasSpell(S_ARMOR))
-                {
-                    player->CastSpell(player, S_LEARN_ARMOR, true);
-                    //_Creature->CastSpell(player, S_REP_ARMOR, true);
-                }
-                CloseGossipMenuFor(player);
-                break;
-            case GOSSIP_ACTION_INFO_DEF + 2:
-                if (!player->HasSpell(S_WEAPON))
-                {
-                    player->CastSpell(player, S_LEARN_WEAPON, true);
-                    //_Creature->CastSpell(player, S_REP_WEAPON, true);
-                }
-                CloseGossipMenuFor(player);
-                break;
-                //Unlearn Armor/Weapon
-            case GOSSIP_ACTION_INFO_DEF + 3:
-                if (HasWeaponSub(player))
+            if (action)
+            {
+                switch (me->GetEntry())
                 {
-                                                                //unknown textID (TALK_MUST_UNLEARN_WEAPON)
-                    SendGossipMenuFor(player, player->GetGossipTextId(creature), creature->GetGUID());
+                    case N_TRAINER_HAMMER:
+                        AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_LEARN_HAMMER, GOSSIP_SENDER_CHECK, action);
+                        //unknown textID (TALK_HAMMER_LEARN)
+                        SendGossipMenuFor(player, player->GetGossipTextId(me), me->GetGUID());
+                        break;
+                    case N_TRAINER_AXE:
+                        AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_LEARN_AXE, GOSSIP_SENDER_CHECK, action);
+                        //unknown textID (TALK_AXE_LEARN)
+                        SendGossipMenuFor(player, player->GetGossipTextId(me), me->GetGUID());
+                        break;
+                    case N_TRAINER_SWORD:
+                        AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_LEARN_SWORD, GOSSIP_SENDER_CHECK, action);
+                        //unknown textID (TALK_SWORD_LEARN)
+                        SendGossipMenuFor(player, player->GetGossipTextId(me), me->GetGUID());
+                        break;
                 }
-                else
-                    ProcessUnlearnAction(player, creature, S_UNLEARN_WEAPON, S_REP_ARMOR, DoLowUnlearnCost(player));
-                break;
-            case GOSSIP_ACTION_INFO_DEF + 4:
-                ProcessUnlearnAction(player, creature, S_UNLEARN_ARMOR, S_REP_WEAPON, DoLowUnlearnCost(player));
-                break;
-                //Learn Hammer/Axe/Sword
-            case GOSSIP_ACTION_INFO_DEF + 5:
-                player->CastSpell(player, S_LEARN_HAMMER, true);
-                CloseGossipMenuFor(player);
-                break;
-            case GOSSIP_ACTION_INFO_DEF + 6:
-                player->CastSpell(player, S_LEARN_AXE, true);
-                CloseGossipMenuFor(player);
-                break;
-            case GOSSIP_ACTION_INFO_DEF + 7:
-                player->CastSpell(player, S_LEARN_SWORD, true);
-                CloseGossipMenuFor(player);
-                break;
-                //Unlearn Hammer/Axe/Sword
-            case GOSSIP_ACTION_INFO_DEF + 8:
-                ProcessUnlearnAction(player, creature, S_UNLEARN_HAMMER, 0, DoMedUnlearnCost(player));
-                break;
-            case GOSSIP_ACTION_INFO_DEF + 9:
-                ProcessUnlearnAction(player, creature, S_UNLEARN_AXE, 0, DoMedUnlearnCost(player));
-                break;
-            case GOSSIP_ACTION_INFO_DEF + 10:
-                ProcessUnlearnAction(player, creature, S_UNLEARN_SWORD, 0, DoMedUnlearnCost(player));
-                break;
+            }
         }
-    }
 
-    void SendConfirmLearn(Player* player, Creature* creature, uint32 action)
-    {
-        if (action)
+        void SendConfirmUnlearn(Player* player, uint32 action)
         {
-            switch (creature->GetEntry())
+            if (action)
             {
-                case N_TRAINER_HAMMER:
-                    AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_LEARN_HAMMER, GOSSIP_SENDER_CHECK, action);
-                                                                //unknown textID (TALK_HAMMER_LEARN)
-                    SendGossipMenuFor(player, player->GetGossipTextId(creature), creature->GetGUID());
-                    break;
-                case N_TRAINER_AXE:
-                    AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_LEARN_AXE,    GOSSIP_SENDER_CHECK, action);
-                                                                //unknown textID (TALK_AXE_LEARN)
-                    SendGossipMenuFor(player, player->GetGossipTextId(creature), creature->GetGUID());
-                    break;
-                case N_TRAINER_SWORD:
-                    AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_LEARN_SWORD,  GOSSIP_SENDER_CHECK, action);
-                                                                //unknown textID (TALK_SWORD_LEARN)
-                    SendGossipMenuFor(player, player->GetGossipTextId(creature), creature->GetGUID());
-                    break;
+                switch (me->GetEntry())
+                {
+                    case N_TRAINER_WEAPON1:
+                    case N_TRAINER_WEAPON2:
+                    case N_TRAINER_ARMOR1:
+                    case N_TRAINER_ARMOR2:
+                        AddGossipItemFor(player, 0, GOSSIP_UNLEARN_SMITH_SPEC, GOSSIP_SENDER_CHECK, action, BOX_UNLEARN_ARMORORWEAPON, DoLowUnlearnCost(player), false);
+                        //unknown textID (TALK_UNLEARN_AXEORWEAPON)
+                        SendGossipMenuFor(player, player->GetGossipTextId(me), me->GetGUID());
+                        break;
+
+                    case N_TRAINER_HAMMER:
+                        AddGossipItemFor(player, 0, GOSSIP_UNLEARN_HAMMER, GOSSIP_SENDER_CHECK, action, BOX_UNLEARN_WEAPON_SPEC, DoMedUnlearnCost(player), false);
+                        //unknown textID (TALK_HAMMER_UNLEARN)
+                        SendGossipMenuFor(player, player->GetGossipTextId(me), me->GetGUID());
+                        break;
+                    case N_TRAINER_AXE:
+                        AddGossipItemFor(player, 0, GOSSIP_UNLEARN_AXE, GOSSIP_SENDER_CHECK, action, BOX_UNLEARN_WEAPON_SPEC, DoMedUnlearnCost(player), false);
+                        //unknown textID (TALK_AXE_UNLEARN)
+                        SendGossipMenuFor(player, player->GetGossipTextId(me), me->GetGUID());
+                        break;
+                    case N_TRAINER_SWORD:
+                        AddGossipItemFor(player, 0, GOSSIP_UNLEARN_SWORD, GOSSIP_SENDER_CHECK, action, BOX_UNLEARN_WEAPON_SPEC, DoMedUnlearnCost(player), false);
+                        //unknown textID (TALK_SWORD_UNLEARN)
+                        SendGossipMenuFor(player, player->GetGossipTextId(me), me->GetGUID());
+                        break;
+                }
             }
         }
-    }
 
-    void SendConfirmUnlearn(Player* player, Creature* creature, uint32 action)
-    {
-        if (action)
+        bool GossipSelect(Player* player, uint32 /*menuId*/, uint32 gossipListId) override
         {
-            switch (creature->GetEntry())
+            uint32 const sender = player->PlayerTalkClass->GetGossipOptionSender(gossipListId);
+            uint32 const action = player->PlayerTalkClass->GetGossipOptionAction(gossipListId);
+            ClearGossipMenuFor(player);
+            switch (sender)
             {
-                case N_TRAINER_WEAPON1:
-                case N_TRAINER_WEAPON2:
-                case N_TRAINER_ARMOR1:
-                case N_TRAINER_ARMOR2:
-                    AddGossipItemFor(player, 0, GOSSIP_UNLEARN_SMITH_SPEC, GOSSIP_SENDER_CHECK, action, BOX_UNLEARN_ARMORORWEAPON, DoLowUnlearnCost(player), false);
-                                                                //unknown textID (TALK_UNLEARN_AXEORWEAPON)
-                    SendGossipMenuFor(player, player->GetGossipTextId(creature), creature->GetGUID());
+                case GOSSIP_SENDER_MAIN:
+                    SendActionMenu(player, action);
                     break;
 
-                case N_TRAINER_HAMMER:
-                    AddGossipItemFor(player, 0, GOSSIP_UNLEARN_HAMMER, GOSSIP_SENDER_CHECK, action,    BOX_UNLEARN_WEAPON_SPEC, DoMedUnlearnCost(player), false);
-                                                                //unknown textID (TALK_HAMMER_UNLEARN)
-                    SendGossipMenuFor(player, player->GetGossipTextId(creature), creature->GetGUID());
+                case GOSSIP_SENDER_LEARN:
+                    SendConfirmLearn(player, action);
                     break;
-                case N_TRAINER_AXE:
-                    AddGossipItemFor(player, 0, GOSSIP_UNLEARN_AXE, GOSSIP_SENDER_CHECK, action,       BOX_UNLEARN_WEAPON_SPEC, DoMedUnlearnCost(player), false);
-                                                                //unknown textID (TALK_AXE_UNLEARN)
-                    SendGossipMenuFor(player, player->GetGossipTextId(creature), creature->GetGUID());
+
+                case GOSSIP_SENDER_UNLEARN:
+                    SendConfirmUnlearn(player, action);
                     break;
-                case N_TRAINER_SWORD:
-                    AddGossipItemFor(player, 0, GOSSIP_UNLEARN_SWORD, GOSSIP_SENDER_CHECK, action,     BOX_UNLEARN_WEAPON_SPEC, DoMedUnlearnCost(player), false);
-                                                                //unknown textID (TALK_SWORD_UNLEARN)
-                    SendGossipMenuFor(player, player->GetGossipTextId(creature), creature->GetGUID());
+
+                case GOSSIP_SENDER_CHECK:
+                    SendActionMenu(player, action);
                     break;
             }
+            return true;
         }
-    }
+    };
 
-    bool OnGossipSelect(Player* player, Creature* creature, uint32 sender, uint32 action) override
+    CreatureAI* GetAI(Creature* creature) const override
     {
-        ClearGossipMenuFor(player);
-        switch (sender)
-        {
-            case GOSSIP_SENDER_MAIN:
-                SendActionMenu(player, creature, action);
-                break;
-
-            case GOSSIP_SENDER_LEARN:
-                SendConfirmLearn(player, creature, action);
-                break;
-
-            case GOSSIP_SENDER_UNLEARN:
-                SendConfirmUnlearn(player, creature, action);
-                break;
-
-            case GOSSIP_SENDER_CHECK:
-                SendActionMenu(player, creature, action);
-                break;
-        }
-        return true;
+        return new npc_prof_blacksmithAI(creature);
     }
 };
 
@@ -849,86 +873,98 @@ class npc_engineering_tele_trinket : public CreatureScript
 public:
     npc_engineering_tele_trinket() : CreatureScript("npc_engineering_tele_trinket") { }
 
-    bool CanLearn(Player* player, uint32 textId, uint32 altTextId, uint32 skillValue, uint32 reqSpellId, uint32 spellId, uint32& npcTextId)
+    struct npc_engineering_tele_trinketAI : public ScriptedAI
     {
-        bool res = false;
-        npcTextId = textId;
-        if (player->GetBaseSkillValue(SKILL_ENGINEERING) >= skillValue && player->HasSpell(reqSpellId))
+        npc_engineering_tele_trinketAI(Creature* creature) : ScriptedAI(creature) { }
+
+        bool CanLearn(Player* player, uint32 textId, uint32 altTextId, uint32 skillValue, uint32 reqSpellId, uint32 spellId, uint32& npcTextId)
         {
-            if (!player->HasSpell(spellId))
-                res = true;
-            else
-                npcTextId = altTextId;
+            bool res = false;
+            npcTextId = textId;
+            if (player->GetBaseSkillValue(SKILL_ENGINEERING) >= skillValue && player->HasSpell(reqSpellId))
+            {
+                if (!player->HasSpell(spellId))
+                    res = true;
+                else
+                    npcTextId = altTextId;
+            }
+            return res;
         }
-        return res;
-    }
 
-    bool OnGossipHello(Player* player, Creature* creature) override
-    {
-        uint32 npcTextId = 0;
-        std::string gossipItem;
-        bool canLearn = false;
+        bool GossipHello(Player* player) override
+        {
+            uint32 npcTextId = 0;
+            std::string gossipItem;
+            bool canLearn = false;
+
+            if (player->HasSkill(SKILL_ENGINEERING))
+            {
+                switch (me->GetEntry())
+                {
+                    case NPC_ZAP:
+                        canLearn = CanLearn(player, 6092, 0, 260, S_GOBLIN, SPELL_TO_EVERLOOK, npcTextId);
+                        if (canLearn)
+                            gossipItem = GOSSIP_ITEM_ZAP;
+                        break;
+                    case NPC_JHORDY:
+                        canLearn = CanLearn(player, 7251, 7252, 260, S_GNOMISH, SPELL_TO_GADGET, npcTextId);
+                        if (canLearn)
+                            gossipItem = GOSSIP_ITEM_JHORDY;
+                        break;
+                    case NPC_KABLAM:
+                        canLearn = CanLearn(player, 10365, 0, 350, S_GOBLIN, SPELL_TO_AREA52, npcTextId);
+                        if (canLearn)
+                            gossipItem = GOSSIP_ITEM_KABLAM;
+                        break;
+                    case NPC_SMILES:
+                        canLearn = CanLearn(player, 10363, 0, 350, S_GNOMISH, SPELL_TO_TOSHLEY, npcTextId);
+                        if (canLearn)
+                            gossipItem = GOSSIP_ITEM_KABLAM;
+                        break;
+                }
+            }
+
+            if (canLearn)
+                AddGossipItemFor(player, GOSSIP_ICON_CHAT, gossipItem, me->GetEntry(), GOSSIP_ACTION_INFO_DEF + 1);
+
+            SendGossipMenuFor(player, npcTextId ? npcTextId : player->GetGossipTextId(me), me->GetGUID());
+            return true;
+        }
 
-        if (player->HasSkill(SKILL_ENGINEERING))
+        bool GossipSelect(Player* player, uint32 /*menuId*/, uint32 gossipListId) override
         {
-            switch (creature->GetEntry())
+            uint32 const sender = player->PlayerTalkClass->GetGossipOptionSender(gossipListId);
+            uint32 const action = player->PlayerTalkClass->GetGossipOptionAction(gossipListId);
+            ClearGossipMenuFor(player);
+            if (action == GOSSIP_ACTION_INFO_DEF + 1)
+                CloseGossipMenuFor(player);
+
+            if (sender != me->GetEntry())
+                return true;
+
+            switch (sender)
             {
                 case NPC_ZAP:
-                    canLearn = CanLearn(player, 6092, 0, 260, S_GOBLIN, SPELL_TO_EVERLOOK, npcTextId);
-                    if (canLearn)
-                        gossipItem = GOSSIP_ITEM_ZAP;
+                    player->CastSpell(player, SPELL_LEARN_TO_EVERLOOK, false);
                     break;
                 case NPC_JHORDY:
-                    canLearn = CanLearn(player, 7251, 7252, 260, S_GNOMISH, SPELL_TO_GADGET, npcTextId);
-                    if (canLearn)
-                        gossipItem = GOSSIP_ITEM_JHORDY;
+                    player->CastSpell(player, SPELL_LEARN_TO_GADGET, false);
                     break;
                 case NPC_KABLAM:
-                    canLearn = CanLearn(player, 10365, 0, 350, S_GOBLIN, SPELL_TO_AREA52, npcTextId);
-                    if (canLearn)
-                        gossipItem = GOSSIP_ITEM_KABLAM;
+                    player->CastSpell(player, SPELL_LEARN_TO_AREA52, false);
                     break;
                 case NPC_SMILES:
-                    canLearn = CanLearn(player, 10363, 0, 350, S_GNOMISH, SPELL_TO_TOSHLEY, npcTextId);
-                    if (canLearn)
-                        gossipItem = GOSSIP_ITEM_KABLAM;
+                    player->CastSpell(player, SPELL_LEARN_TO_TOSHLEY, false);
                     break;
             }
-        }
-
-        if (canLearn)
-            AddGossipItemFor(player, GOSSIP_ICON_CHAT, gossipItem, creature->GetEntry(), GOSSIP_ACTION_INFO_DEF + 1);
-
-        SendGossipMenuFor(player, npcTextId ? npcTextId : player->GetGossipTextId(creature), creature->GetGUID());
-        return true;
-    }
 
-    bool OnGossipSelect(Player* player, Creature* creature, uint32 sender, uint32 action) override
-    {
-        ClearGossipMenuFor(player);
-        if (action == GOSSIP_ACTION_INFO_DEF + 1)
-            CloseGossipMenuFor(player);
-
-        if (sender != creature->GetEntry())
             return true;
-
-        switch (sender)
-        {
-            case NPC_ZAP:
-                player->CastSpell(player, SPELL_LEARN_TO_EVERLOOK, false);
-                break;
-            case NPC_JHORDY:
-                player->CastSpell(player, SPELL_LEARN_TO_GADGET, false);
-                break;
-            case NPC_KABLAM:
-                player->CastSpell(player, SPELL_LEARN_TO_AREA52, false);
-                break;
-            case NPC_SMILES:
-                player->CastSpell(player, SPELL_LEARN_TO_TOSHLEY, false);
-                break;
         }
+    };
 
-        return true;
+    CreatureAI* GetAI(Creature* creature) const override
+    {
+        return new npc_engineering_tele_trinketAI(creature);
     }
 };
 
@@ -941,112 +977,124 @@ class npc_prof_leather : public CreatureScript
 public:
     npc_prof_leather() : CreatureScript("npc_prof_leather") { }
 
-    bool OnGossipHello(Player* player, Creature* creature) override
+    struct npc_prof_leatherAI : public ScriptedAI
     {
-        if (creature->IsQuestGiver())
-            player->PrepareQuestMenu(creature->GetGUID());
+        npc_prof_leatherAI(Creature* creature) : ScriptedAI(creature) { }
+
+        bool GossipHello(Player* player) override
+        {
+            if (me->IsQuestGiver())
+                player->PrepareQuestMenu(me->GetGUID());
+
+            if (me->IsVendor())
+                AddGossipItemFor(player, GOSSIP_ICON_VENDOR, GOSSIP_TEXT_BROWSE_GOODS, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_TRADE);
 
-        if (creature->IsVendor())
-            AddGossipItemFor(player, GOSSIP_ICON_VENDOR, GOSSIP_TEXT_BROWSE_GOODS, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_TRADE);
+            if (me->IsTrainer())
+                AddGossipItemFor(player, GOSSIP_ICON_TRAINER, GOSSIP_TEXT_TRAIN, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_TRAIN);
+
+            if (player->HasSkill(SKILL_LEATHERWORKING) && player->GetBaseSkillValue(SKILL_LEATHERWORKING) >= 250 && player->getLevel() > 49)
+            {
+                switch (me->GetEntry())
+                {
+                    case N_TRAINER_DRAGON1:
+                    case N_TRAINER_DRAGON2:
+                        if (player->HasSpell(S_DRAGON))
+                            AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_UNLEARN_DRAGON, GOSSIP_SENDER_UNLEARN, GOSSIP_ACTION_INFO_DEF + 1);
+                        break;
+                    case N_TRAINER_ELEMENTAL1:
+                    case N_TRAINER_ELEMENTAL2:
+                        if (player->HasSpell(S_ELEMENTAL))
+                            AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_UNLEARN_ELEMENTAL, GOSSIP_SENDER_UNLEARN, GOSSIP_ACTION_INFO_DEF + 2);
+                        break;
+                    case N_TRAINER_TRIBAL1:
+                    case N_TRAINER_TRIBAL2:
+                        if (player->HasSpell(S_TRIBAL))
+                            AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_UNLEARN_TRIBAL, GOSSIP_SENDER_UNLEARN, GOSSIP_ACTION_INFO_DEF + 3);
+                        break;
+                }
+            }
 
-        if (creature->IsTrainer())
-            AddGossipItemFor(player, GOSSIP_ICON_TRAINER, GOSSIP_TEXT_TRAIN, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_TRAIN);
+            SendGossipMenuFor(player, player->GetGossipTextId(me), me->GetGUID());
+            return true;
+        }
 
-        if (player->HasSkill(SKILL_LEATHERWORKING) && player->GetBaseSkillValue(SKILL_LEATHERWORKING) >= 250 && player->getLevel() > 49)
+        void SendActionMenu(Player* player, uint32 action)
         {
-            switch (creature->GetEntry())
+            switch (action)
             {
-                case N_TRAINER_DRAGON1:
-                case N_TRAINER_DRAGON2:
-                    if (player->HasSpell(S_DRAGON))
-                        AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_UNLEARN_DRAGON,      GOSSIP_SENDER_UNLEARN, GOSSIP_ACTION_INFO_DEF + 1);
+                case GOSSIP_ACTION_TRADE:
+                    player->GetSession()->SendListInventory(me->GetGUID());
+                    break;
+                case GOSSIP_ACTION_TRAIN:
+                    player->GetSession()->SendTrainerList(me, TRAINER_ID_LEATHERWORKING);
+                    break;
+                    //Unlearn Leather
+                case GOSSIP_ACTION_INFO_DEF + 1:
+                    ProcessUnlearnAction(player, me, S_UNLEARN_DRAGON, 0, DoMedUnlearnCost(player));
                     break;
-                case N_TRAINER_ELEMENTAL1:
-                case N_TRAINER_ELEMENTAL2:
-                    if (player->HasSpell(S_ELEMENTAL))
-                        AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_UNLEARN_ELEMENTAL,   GOSSIP_SENDER_UNLEARN, GOSSIP_ACTION_INFO_DEF + 2);
+                case GOSSIP_ACTION_INFO_DEF + 2:
+                    ProcessUnlearnAction(player, me, S_UNLEARN_ELEMENTAL, 0, DoMedUnlearnCost(player));
                     break;
-                case N_TRAINER_TRIBAL1:
-                case N_TRAINER_TRIBAL2:
-                    if (player->HasSpell(S_TRIBAL))
-                        AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_UNLEARN_TRIBAL,      GOSSIP_SENDER_UNLEARN, GOSSIP_ACTION_INFO_DEF + 3);
+                case GOSSIP_ACTION_INFO_DEF + 3:
+                    ProcessUnlearnAction(player, me, S_UNLEARN_TRIBAL, 0, DoMedUnlearnCost(player));
                     break;
             }
         }
 
-        SendGossipMenuFor(player, player->GetGossipTextId(creature), creature->GetGUID());
-        return true;
-    }
-
-    void SendActionMenu(Player* player, Creature* creature, uint32 action)
-    {
-        switch (action)
+        void SendConfirmUnlearn(Player* player, uint32 action)
         {
-            case GOSSIP_ACTION_TRADE:
-                player->GetSession()->SendListInventory(creature->GetGUID());
-                break;
-            case GOSSIP_ACTION_TRAIN:
-                player->GetSession()->SendTrainerList(creature, TRAINER_ID_LEATHERWORKING);
-                break;
-                //Unlearn Leather
-            case GOSSIP_ACTION_INFO_DEF + 1:
-                ProcessUnlearnAction(player, creature, S_UNLEARN_DRAGON, 0, DoMedUnlearnCost(player));
-                break;
-            case GOSSIP_ACTION_INFO_DEF + 2:
-                ProcessUnlearnAction(player, creature, S_UNLEARN_ELEMENTAL, 0, DoMedUnlearnCost(player));
-                break;
-            case GOSSIP_ACTION_INFO_DEF + 3:
-                ProcessUnlearnAction(player, creature, S_UNLEARN_TRIBAL, 0, DoMedUnlearnCost(player));
-                break;
+            if (action)
+            {
+                switch (me->GetEntry())
+                {
+                    case N_TRAINER_DRAGON1:
+                    case N_TRAINER_DRAGON2:
+                        AddGossipItemFor(player, 0, GOSSIP_UNLEARN_DRAGON, GOSSIP_SENDER_CHECK, action, BOX_UNLEARN_LEATHER_SPEC, DoMedUnlearnCost(player), false);
+                        //unknown textID ()
+                        SendGossipMenuFor(player, player->GetGossipTextId(me), me->GetGUID());
+                        break;
+                    case N_TRAINER_ELEMENTAL1:
+                    case N_TRAINER_ELEMENTAL2:
+                        AddGossipItemFor(player, 0, GOSSIP_UNLEARN_ELEMENTAL, GOSSIP_SENDER_CHECK, action, BOX_UNLEARN_LEATHER_SPEC, DoMedUnlearnCost(player), false);
+                        //unknown textID ()
+                        SendGossipMenuFor(player, player->GetGossipTextId(me), me->GetGUID());
+                        break;
+                    case N_TRAINER_TRIBAL1:
+                    case N_TRAINER_TRIBAL2:
+                        AddGossipItemFor(player, 0, GOSSIP_UNLEARN_TRIBAL, GOSSIP_SENDER_CHECK, action, BOX_UNLEARN_LEATHER_SPEC, DoMedUnlearnCost(player), false);
+                        //unknown textID ()
+                        SendGossipMenuFor(player, player->GetGossipTextId(me), me->GetGUID());
+                        break;
+                }
+            }
         }
-    }
 
-    void SendConfirmUnlearn(Player* player, Creature* creature, uint32 action)
-    {
-        if (action)
+        bool GossipSelect(Player* player, uint32 /*menuId*/, uint32 gossipListId) override
         {
-            switch (creature->GetEntry())
+            uint32 const sender = player->PlayerTalkClass->GetGossipOptionSender(gossipListId);
+            uint32 const action = player->PlayerTalkClass->GetGossipOptionAction(gossipListId);
+            ClearGossipMenuFor(player);
+            switch (sender)
             {
-                case N_TRAINER_DRAGON1:
-                case N_TRAINER_DRAGON2:
-                    AddGossipItemFor(player, 0, GOSSIP_UNLEARN_DRAGON, GOSSIP_SENDER_CHECK, action,    BOX_UNLEARN_LEATHER_SPEC, DoMedUnlearnCost(player), false);
-                                                                //unknown textID ()
-                    SendGossipMenuFor(player, player->GetGossipTextId(creature), creature->GetGUID());
+                case GOSSIP_SENDER_MAIN:
+                    SendActionMenu(player, action);
                     break;
-                case N_TRAINER_ELEMENTAL1:
-                case N_TRAINER_ELEMENTAL2:
-                    AddGossipItemFor(player, 0, GOSSIP_UNLEARN_ELEMENTAL, GOSSIP_SENDER_CHECK, action, BOX_UNLEARN_LEATHER_SPEC, DoMedUnlearnCost(player), false);
-                                                                //unknown textID ()
-                    SendGossipMenuFor(player, player->GetGossipTextId(creature), creature->GetGUID());
+
+                case GOSSIP_SENDER_UNLEARN:
+                    SendConfirmUnlearn(player, action);
                     break;
-                case N_TRAINER_TRIBAL1:
-                case N_TRAINER_TRIBAL2:
-                    AddGossipItemFor(player, 0, GOSSIP_UNLEARN_TRIBAL, GOSSIP_SENDER_CHECK, action,    BOX_UNLEARN_LEATHER_SPEC, DoMedUnlearnCost(player), false);
-                                                                //unknown textID ()
-                    SendGossipMenuFor(player, player->GetGossipTextId(creature), creature->GetGUID());
+
+                case GOSSIP_SENDER_CHECK:
+                    SendActionMenu(player, action);
                     break;
             }
+            return true;
         }
-    }
+    };
 
-    bool OnGossipSelect(Player* player, Creature* creature, uint32 sender, uint32 action) override
+    CreatureAI* GetAI(Creature* creature) const override
     {
-        ClearGossipMenuFor(player);
-        switch (sender)
-        {
-            case GOSSIP_SENDER_MAIN:
-                SendActionMenu(player, creature, action);
-                break;
-
-            case GOSSIP_SENDER_UNLEARN:
-                SendConfirmUnlearn(player, creature, action);
-                break;
-
-            case GOSSIP_SENDER_CHECK:
-                SendActionMenu(player, creature, action);
-                break;
-        }
-        return true;
+        return new npc_prof_leatherAI(creature);
     }
 };
 
@@ -1059,160 +1107,172 @@ class npc_prof_tailor : public CreatureScript
 public:
     npc_prof_tailor() : CreatureScript("npc_prof_tailor") { }
 
-    inline bool HasTailorSpell(Player* player)
+    struct npc_prof_tailorAI : public ScriptedAI
     {
-        return (player->HasSpell(S_MOONCLOTH) || player->HasSpell(S_SHADOWEAVE) || player->HasSpell(S_SPELLFIRE));
-    }
+        npc_prof_tailorAI(Creature* creature) : ScriptedAI(creature) { }
 
-    bool OnGossipHello(Player* player, Creature* creature) override
-    {
-        if (creature->IsQuestGiver())
-            player->PrepareQuestMenu(creature->GetGUID());
+        inline bool HasTailorSpell(Player* player)
+        {
+            return (player->HasSpell(S_MOONCLOTH) || player->HasSpell(S_SHADOWEAVE) || player->HasSpell(S_SPELLFIRE));
+        }
+
+        bool GossipHello(Player* player) override
+        {
+            if (me->IsQuestGiver())
+                player->PrepareQuestMenu(me->GetGUID());
+
+            if (me->IsVendor())
+                AddGossipItemFor(player, GOSSIP_ICON_VENDOR, GOSSIP_TEXT_BROWSE_GOODS, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_TRADE);
+
+            if (me->IsTrainer())
+                AddGossipItemFor(player, GOSSIP_ICON_TRAINER, GOSSIP_TEXT_TRAIN, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_TRAIN);
+
+            //TAILORING SPEC
+            if (player->HasSkill(SKILL_TAILORING) && player->GetBaseSkillValue(SKILL_TAILORING) >= 350 && player->getLevel() > 59)
+            {
+                if (player->GetQuestRewardStatus(10831) || player->GetQuestRewardStatus(10832) || player->GetQuestRewardStatus(10833))
+                {
+                    switch (me->GetEntry())
+                    {
+                        case N_TRAINER_SPELLFIRE:
+                            if (!HasTailorSpell(player))
+                                AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_LEARN_SPELLFIRE, GOSSIP_SENDER_LEARN, GOSSIP_ACTION_INFO_DEF + 1);
+                            if (player->HasSpell(S_SPELLFIRE))
+                                AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_UNLEARN_SPELLFIRE, GOSSIP_SENDER_UNLEARN, GOSSIP_ACTION_INFO_DEF + 4);
+                            break;
+                        case N_TRAINER_MOONCLOTH:
+                            if (!HasTailorSpell(player))
+                                AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_LEARN_MOONCLOTH, GOSSIP_SENDER_LEARN, GOSSIP_ACTION_INFO_DEF + 2);
+                            if (player->HasSpell(S_MOONCLOTH))
+                                AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_UNLEARN_MOONCLOTH, GOSSIP_SENDER_UNLEARN, GOSSIP_ACTION_INFO_DEF + 5);
+                            break;
+                        case N_TRAINER_SHADOWEAVE:
+                            if (!HasTailorSpell(player))
+                                AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_LEARN_SHADOWEAVE, GOSSIP_SENDER_LEARN, GOSSIP_ACTION_INFO_DEF + 3);
+                            if (player->HasSpell(S_SHADOWEAVE))
+                                AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_UNLEARN_SHADOWEAVE, GOSSIP_SENDER_UNLEARN, GOSSIP_ACTION_INFO_DEF + 6);
+                            break;
+                    }
+                }
+            }
 
-        if (creature->IsVendor())
-            AddGossipItemFor(player, GOSSIP_ICON_VENDOR, GOSSIP_TEXT_BROWSE_GOODS, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_TRADE);
+            SendGossipMenuFor(player, player->GetGossipTextId(me), me->GetGUID());
+            return true;
+        }
 
-        if (creature->IsTrainer())
-            AddGossipItemFor(player, GOSSIP_ICON_TRAINER, GOSSIP_TEXT_TRAIN, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_TRAIN);
+        void SendActionMenu(Player* player, uint32 action)
+        {
+            switch (action)
+            {
+                case GOSSIP_ACTION_TRADE:
+                    player->GetSession()->SendListInventory(me->GetGUID());
+                    break;
+                case GOSSIP_ACTION_TRAIN:
+                    player->GetSession()->SendTrainerList(me, TRAINER_ID_TAILORING);
+                    break;
+                    //Learn Tailor
+                case GOSSIP_ACTION_INFO_DEF + 1:
+                    ProcessCastaction(player, me, S_SPELLFIRE, S_LEARN_SPELLFIRE, DoLearnCost(player));
+                    break;
+                case GOSSIP_ACTION_INFO_DEF + 2:
+                    ProcessCastaction(player, me, S_MOONCLOTH, S_LEARN_MOONCLOTH, DoLearnCost(player));
+                    break;
+                case GOSSIP_ACTION_INFO_DEF + 3:
+                    ProcessCastaction(player, me, S_SHADOWEAVE, S_LEARN_SHADOWEAVE, DoLearnCost(player));
+                    break;
+                    //Unlearn Tailor
+                case GOSSIP_ACTION_INFO_DEF + 4:
+                    ProcessUnlearnAction(player, me, S_UNLEARN_SPELLFIRE, 0, DoHighUnlearnCost(player));
+                    break;
+                case GOSSIP_ACTION_INFO_DEF + 5:
+                    ProcessUnlearnAction(player, me, S_UNLEARN_MOONCLOTH, 0, DoHighUnlearnCost(player));
+                    break;
+                case GOSSIP_ACTION_INFO_DEF + 6:
+                    ProcessUnlearnAction(player, me, S_UNLEARN_SHADOWEAVE, 0, DoHighUnlearnCost(player));
+                    break;
+            }
+        }
 
-                                                                //TAILORING SPEC
-        if (player->HasSkill(SKILL_TAILORING) && player->GetBaseSkillValue(SKILL_TAILORING) >= 350 && player->getLevel() > 59)
+        void SendConfirmLearn(Player* player, uint32 action)
         {
-            if (player->GetQuestRewardStatus(10831) || player->GetQuestRewardStatus(10832) || player->GetQuestRewardStatus(10833))
+            if (action)
             {
-                switch (creature->GetEntry())
+                switch (me->GetEntry())
                 {
                     case N_TRAINER_SPELLFIRE:
-                        if (!HasTailorSpell(player))
-                            AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_LEARN_SPELLFIRE,    GOSSIP_SENDER_LEARN,    GOSSIP_ACTION_INFO_DEF + 1);
-                        if (player->HasSpell(S_SPELLFIRE))
-                            AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_UNLEARN_SPELLFIRE,  GOSSIP_SENDER_UNLEARN,  GOSSIP_ACTION_INFO_DEF + 4);
+                        AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_LEARN_SPELLFIRE, GOSSIP_SENDER_CHECK, action);
+                        //unknown textID ()
+                        SendGossipMenuFor(player, player->GetGossipTextId(me), me->GetGUID());
                         break;
                     case N_TRAINER_MOONCLOTH:
-                        if (!HasTailorSpell(player))
-                            AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_LEARN_MOONCLOTH,    GOSSIP_SENDER_LEARN,    GOSSIP_ACTION_INFO_DEF + 2);
-                        if (player->HasSpell(S_MOONCLOTH))
-                            AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_UNLEARN_MOONCLOTH,  GOSSIP_SENDER_UNLEARN,  GOSSIP_ACTION_INFO_DEF + 5);
+                        AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_LEARN_MOONCLOTH, GOSSIP_SENDER_CHECK, action);
+                        //unknown textID ()
+                        SendGossipMenuFor(player, player->GetGossipTextId(me), me->GetGUID());
                         break;
                     case N_TRAINER_SHADOWEAVE:
-                        if (!HasTailorSpell(player))
-                            AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_LEARN_SHADOWEAVE,   GOSSIP_SENDER_LEARN,    GOSSIP_ACTION_INFO_DEF + 3);
-                        if (player->HasSpell(S_SHADOWEAVE))
-                            AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_UNLEARN_SHADOWEAVE, GOSSIP_SENDER_UNLEARN,  GOSSIP_ACTION_INFO_DEF + 6);
+                        AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_LEARN_SHADOWEAVE, GOSSIP_SENDER_CHECK, action);
+                        //unknown textID ()
+                        SendGossipMenuFor(player, player->GetGossipTextId(me), me->GetGUID());
                         break;
                 }
             }
         }
 
-        SendGossipMenuFor(player, player->GetGossipTextId(creature), creature->GetGUID());
-        return true;
-    }
-
-    void SendActionMenu(Player* player, Creature* creature, uint32 action)
-    {
-        switch (action)
-        {
-            case GOSSIP_ACTION_TRADE:
-                player->GetSession()->SendListInventory(creature->GetGUID());
-                break;
-            case GOSSIP_ACTION_TRAIN:
-                player->GetSession()->SendTrainerList(creature, TRAINER_ID_TAILORING);
-                break;
-                //Learn Tailor
-            case GOSSIP_ACTION_INFO_DEF + 1:
-                ProcessCastaction(player, creature, S_SPELLFIRE, S_LEARN_SPELLFIRE, DoLearnCost(player));
-                break;
-            case GOSSIP_ACTION_INFO_DEF + 2:
-                ProcessCastaction(player, creature, S_MOONCLOTH, S_LEARN_MOONCLOTH, DoLearnCost(player));
-                break;
-            case GOSSIP_ACTION_INFO_DEF + 3:
-                ProcessCastaction(player, creature, S_SHADOWEAVE, S_LEARN_SHADOWEAVE, DoLearnCost(player));
-                break;
-                //Unlearn Tailor
-            case GOSSIP_ACTION_INFO_DEF + 4:
-                ProcessUnlearnAction(player, creature, S_UNLEARN_SPELLFIRE, 0, DoHighUnlearnCost(player));
-                break;
-            case GOSSIP_ACTION_INFO_DEF + 5:
-                ProcessUnlearnAction(player, creature, S_UNLEARN_MOONCLOTH, 0, DoHighUnlearnCost(player));
-                break;
-            case GOSSIP_ACTION_INFO_DEF + 6:
-                ProcessUnlearnAction(player, creature, S_UNLEARN_SHADOWEAVE, 0, DoHighUnlearnCost(player));
-                break;
-        }
-    }
-
-    void SendConfirmLearn(Player* player, Creature* creature, uint32 action)
-    {
-        if (action)
+        void SendConfirmUnlearn(Player* player, uint32 action)
         {
-            switch (creature->GetEntry())
+            if (action)
             {
-                case N_TRAINER_SPELLFIRE:
-                    AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_LEARN_SPELLFIRE, GOSSIP_SENDER_CHECK, action);
-                                                                //unknown textID ()
-                    SendGossipMenuFor(player, player->GetGossipTextId(creature), creature->GetGUID());
-                    break;
-                case N_TRAINER_MOONCLOTH:
-                    AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_LEARN_MOONCLOTH,    GOSSIP_SENDER_CHECK, action);
-                                                                //unknown textID ()
-                    SendGossipMenuFor(player, player->GetGossipTextId(creature), creature->GetGUID());
-                    break;
-                case N_TRAINER_SHADOWEAVE:
-                    AddGossipItemFor(player, GOSSIP_ICON_CHAT, GOSSIP_LEARN_SHADOWEAVE,  GOSSIP_SENDER_CHECK, action);
-                                                                //unknown textID ()
-                    SendGossipMenuFor(player, player->GetGossipTextId(creature), creature->GetGUID());
-                    break;
+                switch (me->GetEntry())
+                {
+                    case N_TRAINER_SPELLFIRE:
+                        AddGossipItemFor(player, 0, GOSSIP_UNLEARN_SPELLFIRE, GOSSIP_SENDER_CHECK, action, BOX_UNLEARN_TAILOR_SPEC, DoHighUnlearnCost(player), false);
+                        //unknown textID ()
+                        SendGossipMenuFor(player, player->GetGossipTextId(me), me->GetGUID());
+                        break;
+                    case N_TRAINER_MOONCLOTH:
+                        AddGossipItemFor(player, 0, GOSSIP_UNLEARN_MOONCLOTH, GOSSIP_SENDER_CHECK, action, BOX_UNLEARN_TAILOR_SPEC, DoHighUnlearnCost(player), false);
+                        //unknown textID ()
+                        SendGossipMenuFor(player, player->GetGossipTextId(me), me->GetGUID());
+                        break;
+                    case N_TRAINER_SHADOWEAVE:
+                        AddGossipItemFor(player, 0, GOSSIP_UNLEARN_SHADOWEAVE, GOSSIP_SENDER_CHECK, action, BOX_UNLEARN_TAILOR_SPEC, DoHighUnlearnCost(player), false);
+                        //unknown textID ()
+                        SendGossipMenuFor(player, player->GetGossipTextId(me), me->GetGUID());
+                        break;
+                }
             }
         }
-    }
 
-    void SendConfirmUnlearn(Player* player, Creature* creature, uint32 action)
-    {
-        if (action)
+        bool GossipSelect(Player* player, uint32 /*menuId*/, uint32 gossipListId) override
         {
-            switch (creature->GetEntry())
+            uint32 const sender = player->PlayerTalkClass->GetGossipOptionSender(gossipListId);
+            uint32 const action = player->PlayerTalkClass->GetGossipOptionAction(gossipListId);
+            ClearGossipMenuFor(player);
+            switch (sender)
             {
-                case N_TRAINER_SPELLFIRE:
-                    AddGossipItemFor(player, 0, GOSSIP_UNLEARN_SPELLFIRE, GOSSIP_SENDER_CHECK, action, BOX_UNLEARN_TAILOR_SPEC, DoHighUnlearnCost(player), false);
-                                                                //unknown textID ()
-                    SendGossipMenuFor(player, player->GetGossipTextId(creature), creature->GetGUID());
+                case GOSSIP_SENDER_MAIN:
+                    SendActionMenu(player, action);
                     break;
-                case N_TRAINER_MOONCLOTH:
-                    AddGossipItemFor(player, 0, GOSSIP_UNLEARN_MOONCLOTH, GOSSIP_SENDER_CHECK, action, BOX_UNLEARN_TAILOR_SPEC, DoHighUnlearnCost(player), false);
-                                                                //unknown textID ()
-                    SendGossipMenuFor(player, player->GetGossipTextId(creature), creature->GetGUID());
+
+                case GOSSIP_SENDER_LEARN:
+                    SendConfirmLearn(player, action);
+                    break;
+
+                case GOSSIP_SENDER_UNLEARN:
+                    SendConfirmUnlearn(player, action);
                     break;
-                case N_TRAINER_SHADOWEAVE:
-                    AddGossipItemFor(player, 0, GOSSIP_UNLEARN_SHADOWEAVE, GOSSIP_SENDER_CHECK, action, BOX_UNLEARN_TAILOR_SPEC, DoHighUnlearnCost(player), false);
-                                                                //unknown textID ()
-                    SendGossipMenuFor(player, player->GetGossipTextId(creature), creature->GetGUID());
+
+                case GOSSIP_SENDER_CHECK:
+                    SendActionMenu(player, action);
                     break;
             }
+            return true;
         }
-    }
+    };
 
-    bool OnGossipSelect(Player* player, Creature* creature, uint32 sender, uint32 action) override
+    CreatureAI* GetAI(Creature* creature) const override
     {
-        ClearGossipMenuFor(player);
-        switch (sender)
-        {
-            case GOSSIP_SENDER_MAIN:
-                SendActionMenu(player, creature, action);
-                break;
-
-            case GOSSIP_SENDER_LEARN:
-                SendConfirmLearn(player, creature, action);
-                break;
-
-            case GOSSIP_SENDER_UNLEARN:
-                SendConfirmUnlearn(player, creature, action);
-                break;
-
-            case GOSSIP_SENDER_CHECK:
-                SendActionMenu(player, creature, action);
-                break;
-        }
-        return true;
+        return new npc_prof_tailorAI(creature);
     }
 };
 
diff --git a/src/server/scripts/World/npcs_special.cpp b/src/server/scripts/World/npcs_special.cpp
index 7c367705d36..8bc2fe634c0 100644
--- a/src/server/scripts/World/npcs_special.cpp
+++ b/src/server/scripts/World/npcs_special.cpp
@@ -331,28 +331,24 @@ public:
                     break;
             }
         }
+
+        void QuestAccept(Player* /*player*/, Quest const* quest) override
+        {
+            if (quest->GetQuestId() == QUEST_CLUCK)
+                Reset();
+        }
+
+        void QuestReward(Player* /*player*/, Quest const* quest, uint32 /*opt*/) override
+        {
+            if (quest->GetQuestId() == QUEST_CLUCK)
+                Reset();
+        }
     };
 
     CreatureAI* GetAI(Creature* creature) const override
     {
         return new npc_chicken_cluckAI(creature);
     }
-
-    bool OnQuestAccept(Player* /*player*/, Creature* creature, Quest const* quest) override
-    {
-        if (quest->GetQuestId() == QUEST_CLUCK)
-            ENSURE_AI(npc_chicken_cluck::npc_chicken_cluckAI, creature->AI())->Reset();
-
-        return true;
-    }
-
-    bool OnQuestReward(Player* /*player*/, Creature* creature, Quest const* quest, uint32 /*opt*/) override
-    {
-        if (quest->GetQuestId() == QUEST_CLUCK)
-            ENSURE_AI(npc_chicken_cluck::npc_chicken_cluckAI, creature->AI())->Reset();
-
-        return true;
-    }
 };
 
 /*######
@@ -815,15 +811,13 @@ public:
         void UpdateAI(uint32 diff) override;
 
         void EnterCombat(Unit* /*who*/) override { }
-    };
-
-    bool OnQuestAccept(Player* player, Creature* creature, Quest const* quest) override
-    {
-        if ((quest->GetQuestId() == 6624) || (quest->GetQuestId() == 6622))
-            ENSURE_AI(npc_doctor::npc_doctorAI, creature->AI())->BeginEvent(player);
 
-        return true;
-    }
+        void QuestAccept(Player* player, Quest const* quest) override
+        {
+            if ((quest->GetQuestId() == 6624) || (quest->GetQuestId() == 6622))
+                BeginEvent(player);
+        }
+    };
 
     CreatureAI* GetAI(Creature* creature) const override
     {
@@ -1278,117 +1272,129 @@ class npc_sayge : public CreatureScript
 public:
     npc_sayge() : CreatureScript("npc_sayge") { }
 
-    bool OnGossipHello(Player* player, Creature* creature) override
+    struct npc_saygeAI : public ScriptedAI
     {
-        if (creature->IsQuestGiver())
-            player->PrepareQuestMenu(creature->GetGUID());
-
-        if (player->GetSpellHistory()->HasCooldown(SPELL_STRENGTH)  ||
-            player->GetSpellHistory()->HasCooldown(SPELL_AGILITY)   ||
-            player->GetSpellHistory()->HasCooldown(SPELL_STAMINA)   ||
-            player->GetSpellHistory()->HasCooldown(SPELL_SPIRIT)    ||
-            player->GetSpellHistory()->HasCooldown(SPELL_INTELLECT) ||
-            player->GetSpellHistory()->HasCooldown(SPELL_ARMOR)     ||
-            player->GetSpellHistory()->HasCooldown(SPELL_DAMAGE)    ||
-            player->GetSpellHistory()->HasCooldown(SPELL_RESISTANCE))
-            SendGossipMenuFor(player, GOSSIP_MENU_CANT_GIVE_YOU_YOUR, creature->GetGUID());
-        else
+        npc_saygeAI(Creature* creature) : ScriptedAI(creature) { }
+
+        bool GossipHello(Player* player) override
+        {
+            if (me->IsQuestGiver())
+                player->PrepareQuestMenu(me->GetGUID());
+
+            if (player->GetSpellHistory()->HasCooldown(SPELL_STRENGTH) ||
+                player->GetSpellHistory()->HasCooldown(SPELL_AGILITY) ||
+                player->GetSpellHistory()->HasCooldown(SPELL_STAMINA) ||
+                player->GetSpellHistory()->HasCooldown(SPELL_SPIRIT) ||
+                player->GetSpellHistory()->HasCooldown(SPELL_INTELLECT) ||
+                player->GetSpellHistory()->HasCooldown(SPELL_ARMOR) ||
+                player->GetSpellHistory()->HasCooldown(SPELL_DAMAGE) ||
+                player->GetSpellHistory()->HasCooldown(SPELL_RESISTANCE))
+                SendGossipMenuFor(player, GOSSIP_MENU_CANT_GIVE_YOU_YOUR, me->GetGUID());
+            else
+            {
+                AddGossipItemFor(player, GOSSIP_I_AM_READY_TO_DISCOVER, GOSSIP_MENU_OPTION_ID_ANSWER_1, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF + 1);
+                SendGossipMenuFor(player, GOSSIP_MENU_I_HAVE_LONG_KNOWN, me->GetGUID());
+            }
+
+            return true;
+        }
+
+        void SendAction(Player* player, uint32 action)
         {
-            AddGossipItemFor(player, GOSSIP_I_AM_READY_TO_DISCOVER, GOSSIP_MENU_OPTION_ID_ANSWER_1, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF + 1);
-            SendGossipMenuFor(player, GOSSIP_MENU_I_HAVE_LONG_KNOWN, creature->GetGUID());
+            switch (action)
+            {
+                case GOSSIP_ACTION_INFO_DEF + 1:
+                    AddGossipItemFor(player, GOSSIP_MENU_OPTION_SAYGE1, GOSSIP_MENU_OPTION_ID_ANSWER_1, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF + 2);
+                    AddGossipItemFor(player, GOSSIP_MENU_OPTION_SAYGE2, GOSSIP_MENU_OPTION_ID_ANSWER_2, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF + 3);
+                    AddGossipItemFor(player, GOSSIP_MENU_OPTION_SAYGE3, GOSSIP_MENU_OPTION_ID_ANSWER_3, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF + 4);
+                    AddGossipItemFor(player, GOSSIP_MENU_OPTION_SAYGE4, GOSSIP_MENU_OPTION_ID_ANSWER_4, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF + 5);
+                    SendGossipMenuFor(player, GOSSIP_MENU_YOU_HAVE_BEEN_TASKED, me->GetGUID());
+                    break;
+                case GOSSIP_ACTION_INFO_DEF + 2:
+                    AddGossipItemFor(player, GOSSIP_MENU_OPTION_SAYGE5, GOSSIP_MENU_OPTION_ID_ANSWER_1, GOSSIP_SENDER_MAIN + 1, GOSSIP_ACTION_INFO_DEF);
+                    AddGossipItemFor(player, GOSSIP_MENU_OPTION_SAYGE6, GOSSIP_MENU_OPTION_ID_ANSWER_2, GOSSIP_SENDER_MAIN + 2, GOSSIP_ACTION_INFO_DEF);
+                    AddGossipItemFor(player, GOSSIP_MENU_OPTION_SAYGE7, GOSSIP_MENU_OPTION_ID_ANSWER_3, GOSSIP_SENDER_MAIN + 3, GOSSIP_ACTION_INFO_DEF);
+                    SendGossipMenuFor(player, GOSSIP_MENU_SWORN_EXECUTIONER, me->GetGUID());
+                    break;
+                case GOSSIP_ACTION_INFO_DEF + 3:
+                    AddGossipItemFor(player, GOSSIP_MENU_OPTION_SAYGE8, GOSSIP_MENU_OPTION_ID_ANSWER_1, GOSSIP_SENDER_MAIN + 4, GOSSIP_ACTION_INFO_DEF);
+                    AddGossipItemFor(player, GOSSIP_MENU_OPTION_SAYGE9, GOSSIP_MENU_OPTION_ID_ANSWER_2, GOSSIP_SENDER_MAIN + 5, GOSSIP_ACTION_INFO_DEF);
+                    AddGossipItemFor(player, GOSSIP_MENU_OPTION_SAYGE10, GOSSIP_MENU_OPTION_ID_ANSWER_3, GOSSIP_SENDER_MAIN + 2, GOSSIP_ACTION_INFO_DEF);
+                    SendGossipMenuFor(player, GOSSIP_MENU_DIPLOMATIC_MISSION, me->GetGUID());
+                    break;
+                case GOSSIP_ACTION_INFO_DEF + 4:
+                    AddGossipItemFor(player, GOSSIP_MENU_OPTION_SAYGE11, GOSSIP_MENU_OPTION_ID_ANSWER_1, GOSSIP_SENDER_MAIN + 6, GOSSIP_ACTION_INFO_DEF);
+                    AddGossipItemFor(player, GOSSIP_MENU_OPTION_SAYGE12, GOSSIP_MENU_OPTION_ID_ANSWER_2, GOSSIP_SENDER_MAIN + 7, GOSSIP_ACTION_INFO_DEF);
+                    AddGossipItemFor(player, GOSSIP_MENU_OPTION_SAYGE13, GOSSIP_MENU_OPTION_ID_ANSWER_3, GOSSIP_SENDER_MAIN + 8, GOSSIP_ACTION_INFO_DEF);
+                    SendGossipMenuFor(player, GOSSIP_MENU_YOUR_BROTHER_SEEKS, me->GetGUID());
+                    break;
+                case GOSSIP_ACTION_INFO_DEF + 5:
+                    AddGossipItemFor(player, GOSSIP_MENU_OPTION_SAYGE14, GOSSIP_MENU_OPTION_ID_ANSWER_1, GOSSIP_SENDER_MAIN + 5, GOSSIP_ACTION_INFO_DEF);
+                    AddGossipItemFor(player, GOSSIP_MENU_OPTION_SAYGE15, GOSSIP_MENU_OPTION_ID_ANSWER_2, GOSSIP_SENDER_MAIN + 4, GOSSIP_ACTION_INFO_DEF);
+                    AddGossipItemFor(player, GOSSIP_MENU_OPTION_SAYGE16, GOSSIP_MENU_OPTION_ID_ANSWER_3, GOSSIP_SENDER_MAIN + 3, GOSSIP_ACTION_INFO_DEF);
+                    SendGossipMenuFor(player, GOSSIP_MENU_A_TERRIBLE_BEAST, me->GetGUID());
+                    break;
+                case GOSSIP_ACTION_INFO_DEF:
+                    AddGossipItemFor(player, GOSSIP_MENU_OPTION_SAYGE17, GOSSIP_MENU_OPTION_ID_ANSWER_1, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF + 6);
+                    SendGossipMenuFor(player, GOSSIP_MENU_YOUR_FORTUNE_IS_CAST, me->GetGUID());
+                    break;
+                case GOSSIP_ACTION_INFO_DEF + 6:
+                    DoCast(player, SPELL_FORTUNE, false);
+                    SendGossipMenuFor(player, GOSSIP_MENU_HERE_IS_YOUR_FORTUNE, me->GetGUID());
+                    break;
+            }
         }
 
-        return true;
-    }
+        bool GossipSelect(Player* player, uint32 /*menuId*/, uint32 gossipListId) override
+        {
+            uint32 const sender = player->PlayerTalkClass->GetGossipOptionSender(gossipListId);
+            uint32 const action = player->PlayerTalkClass->GetGossipOptionAction(gossipListId);
+            ClearGossipMenuFor(player);
+            uint32 spellId = 0;
+            switch (sender)
+            {
+                case GOSSIP_SENDER_MAIN:
+                    SendAction(player, action);
+                    break;
+                case GOSSIP_SENDER_MAIN + 1:
+                    spellId = SPELL_DAMAGE;
+                    break;
+                case GOSSIP_SENDER_MAIN + 2:
+                    spellId = SPELL_RESISTANCE;
+                    break;
+                case GOSSIP_SENDER_MAIN + 3:
+                    spellId = SPELL_ARMOR;
+                    break;
+                case GOSSIP_SENDER_MAIN + 4:
+                    spellId = SPELL_SPIRIT;
+                    break;
+                case GOSSIP_SENDER_MAIN + 5:
+                    spellId = SPELL_INTELLECT;
+                    break;
+                case GOSSIP_SENDER_MAIN + 6:
+                    spellId = SPELL_STAMINA;
+                    break;
+                case GOSSIP_SENDER_MAIN + 7:
+                    spellId = SPELL_STRENGTH;
+                    break;
+                case GOSSIP_SENDER_MAIN + 8:
+                    spellId = SPELL_AGILITY;
+                    break;
+            }
 
-    void SendAction(Player* player, Creature* creature, uint32 action)
-    {
-        switch (action)
-        {
-            case GOSSIP_ACTION_INFO_DEF + 1:
-                AddGossipItemFor(player, GOSSIP_MENU_OPTION_SAYGE1, GOSSIP_MENU_OPTION_ID_ANSWER_1, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF + 2);
-                AddGossipItemFor(player, GOSSIP_MENU_OPTION_SAYGE2, GOSSIP_MENU_OPTION_ID_ANSWER_2, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF + 3);
-                AddGossipItemFor(player, GOSSIP_MENU_OPTION_SAYGE3, GOSSIP_MENU_OPTION_ID_ANSWER_3, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF + 4);
-                AddGossipItemFor(player, GOSSIP_MENU_OPTION_SAYGE4, GOSSIP_MENU_OPTION_ID_ANSWER_4, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF + 5);
-                SendGossipMenuFor(player, GOSSIP_MENU_YOU_HAVE_BEEN_TASKED, creature->GetGUID());
-                break;
-            case GOSSIP_ACTION_INFO_DEF + 2:
-                AddGossipItemFor(player, GOSSIP_MENU_OPTION_SAYGE5, GOSSIP_MENU_OPTION_ID_ANSWER_1, GOSSIP_SENDER_MAIN + 1, GOSSIP_ACTION_INFO_DEF);
-                AddGossipItemFor(player, GOSSIP_MENU_OPTION_SAYGE6, GOSSIP_MENU_OPTION_ID_ANSWER_2, GOSSIP_SENDER_MAIN + 2, GOSSIP_ACTION_INFO_DEF);
-                AddGossipItemFor(player, GOSSIP_MENU_OPTION_SAYGE7, GOSSIP_MENU_OPTION_ID_ANSWER_3, GOSSIP_SENDER_MAIN + 3, GOSSIP_ACTION_INFO_DEF);
-                SendGossipMenuFor(player, GOSSIP_MENU_SWORN_EXECUTIONER, creature->GetGUID());
-                break;
-            case GOSSIP_ACTION_INFO_DEF + 3:
-                AddGossipItemFor(player, GOSSIP_MENU_OPTION_SAYGE8, GOSSIP_MENU_OPTION_ID_ANSWER_1, GOSSIP_SENDER_MAIN + 4, GOSSIP_ACTION_INFO_DEF);
-                AddGossipItemFor(player, GOSSIP_MENU_OPTION_SAYGE9, GOSSIP_MENU_OPTION_ID_ANSWER_2, GOSSIP_SENDER_MAIN + 5, GOSSIP_ACTION_INFO_DEF);
-                AddGossipItemFor(player, GOSSIP_MENU_OPTION_SAYGE10,GOSSIP_MENU_OPTION_ID_ANSWER_3, GOSSIP_SENDER_MAIN + 2, GOSSIP_ACTION_INFO_DEF);
-                SendGossipMenuFor(player, GOSSIP_MENU_DIPLOMATIC_MISSION, creature->GetGUID());
-                break;
-            case GOSSIP_ACTION_INFO_DEF + 4:
-                AddGossipItemFor(player, GOSSIP_MENU_OPTION_SAYGE11, GOSSIP_MENU_OPTION_ID_ANSWER_1, GOSSIP_SENDER_MAIN + 6, GOSSIP_ACTION_INFO_DEF);
-                AddGossipItemFor(player, GOSSIP_MENU_OPTION_SAYGE12, GOSSIP_MENU_OPTION_ID_ANSWER_2, GOSSIP_SENDER_MAIN + 7, GOSSIP_ACTION_INFO_DEF);
-                AddGossipItemFor(player, GOSSIP_MENU_OPTION_SAYGE13, GOSSIP_MENU_OPTION_ID_ANSWER_3, GOSSIP_SENDER_MAIN + 8, GOSSIP_ACTION_INFO_DEF);
-                SendGossipMenuFor(player, GOSSIP_MENU_YOUR_BROTHER_SEEKS, creature->GetGUID());
-                break;
-            case GOSSIP_ACTION_INFO_DEF + 5:
-                AddGossipItemFor(player, GOSSIP_MENU_OPTION_SAYGE14, GOSSIP_MENU_OPTION_ID_ANSWER_1, GOSSIP_SENDER_MAIN + 5, GOSSIP_ACTION_INFO_DEF);
-                AddGossipItemFor(player, GOSSIP_MENU_OPTION_SAYGE15, GOSSIP_MENU_OPTION_ID_ANSWER_2, GOSSIP_SENDER_MAIN + 4, GOSSIP_ACTION_INFO_DEF);
-                AddGossipItemFor(player, GOSSIP_MENU_OPTION_SAYGE16, GOSSIP_MENU_OPTION_ID_ANSWER_3, GOSSIP_SENDER_MAIN + 3, GOSSIP_ACTION_INFO_DEF);
-                SendGossipMenuFor(player, GOSSIP_MENU_A_TERRIBLE_BEAST, creature->GetGUID());
-                break;
-            case GOSSIP_ACTION_INFO_DEF:
-                AddGossipItemFor(player, GOSSIP_MENU_OPTION_SAYGE17, GOSSIP_MENU_OPTION_ID_ANSWER_1, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF + 6);
-                SendGossipMenuFor(player, GOSSIP_MENU_YOUR_FORTUNE_IS_CAST, creature->GetGUID());
-                break;
-            case GOSSIP_ACTION_INFO_DEF + 6:
-                creature->CastSpell(player, SPELL_FORTUNE, false);
-                SendGossipMenuFor(player, GOSSIP_MENU_HERE_IS_YOUR_FORTUNE, creature->GetGUID());
-                break;
+            if (spellId)
+            {
+                DoCast(player, spellId, false);
+                player->GetSpellHistory()->AddCooldown(spellId, 0, std::chrono::hours(2));
+                SendAction(player, action);
+            }
+            return true;
         }
-    }
+    };
 
-    bool OnGossipSelect(Player* player, Creature* creature, uint32 sender, uint32 action) override
+    CreatureAI* GetAI(Creature* creature) const override
     {
-        ClearGossipMenuFor(player);
-        uint32 spellId = 0;
-        switch (sender)
-        {
-            case GOSSIP_SENDER_MAIN:
-                SendAction(player, creature, action);
-                break;
-            case GOSSIP_SENDER_MAIN + 1:
-                spellId = SPELL_DAMAGE;
-                break;
-            case GOSSIP_SENDER_MAIN + 2:
-                spellId = SPELL_RESISTANCE;
-                break;
-            case GOSSIP_SENDER_MAIN + 3:
-                spellId = SPELL_ARMOR;
-                break;
-            case GOSSIP_SENDER_MAIN + 4:
-                spellId = SPELL_SPIRIT;
-                break;
-            case GOSSIP_SENDER_MAIN + 5:
-                spellId = SPELL_INTELLECT;
-                break;
-            case GOSSIP_SENDER_MAIN + 6:
-                spellId = SPELL_STAMINA;
-                break;
-            case GOSSIP_SENDER_MAIN + 7:
-                spellId = SPELL_STRENGTH;
-                break;
-            case GOSSIP_SENDER_MAIN + 8:
-                spellId = SPELL_AGILITY;
-                break;
-        }
-
-        if (spellId)
-        {
-            creature->CastSpell(player, spellId, false);
-            player->GetSpellHistory()->AddCooldown(spellId, 0, std::chrono::hours(2));
-            SendAction(player, creature, action);
-        }
-        return true;
+        return new npc_saygeAI(creature);
     }
 };
 
@@ -1863,8 +1869,6 @@ public:
 
 enum NPC_Wormhole
 {
-    DATA_SHOW_UNDERGROUND = 1,     // -> Random 0 or 1
-
     MENU_ID_WORMHOLE      = 10668, // "This tear in the fabric of time and space looks ominous."
     NPC_TEXT_WORMHOLE     = 14785, // (not 907 "What brings you to this part of the world, $n?")
     GOSSIP_OPTION_1       = 0,     // "Borean Tundra"
@@ -1904,71 +1908,67 @@ class npc_wormhole : public CreatureScript
                 Initialize();
             }
 
-            uint32 GetData(uint32 type) const override
-            {
-                return (type == DATA_SHOW_UNDERGROUND && _showUnderground) ? 1 : 0;
-            }
-
-        private:
-            bool _showUnderground;
-        };
-
-        bool OnGossipHello(Player* player, Creature* creature) override
-        {
-            if (creature->IsSummon())
+            bool GossipHello(Player* player) override
             {
-                if (player == creature->ToTempSummon()->GetSummoner())
+                if (me->IsSummon())
                 {
-                    AddGossipItemFor(player, MENU_ID_WORMHOLE, GOSSIP_OPTION_1, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF + 1);
-                    AddGossipItemFor(player, MENU_ID_WORMHOLE, GOSSIP_OPTION_2, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF + 2);
-                    AddGossipItemFor(player, MENU_ID_WORMHOLE, GOSSIP_OPTION_3, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF + 3);
-                    AddGossipItemFor(player, MENU_ID_WORMHOLE, GOSSIP_OPTION_4, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF + 4);
-                    AddGossipItemFor(player, MENU_ID_WORMHOLE, GOSSIP_OPTION_5, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF + 5);
+                    if (player == me->ToTempSummon()->GetSummoner())
+                    {
+                        AddGossipItemFor(player, MENU_ID_WORMHOLE, GOSSIP_OPTION_1, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF + 1);
+                        AddGossipItemFor(player, MENU_ID_WORMHOLE, GOSSIP_OPTION_2, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF + 2);
+                        AddGossipItemFor(player, MENU_ID_WORMHOLE, GOSSIP_OPTION_3, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF + 3);
+                        AddGossipItemFor(player, MENU_ID_WORMHOLE, GOSSIP_OPTION_4, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF + 4);
+                        AddGossipItemFor(player, MENU_ID_WORMHOLE, GOSSIP_OPTION_5, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF + 5);
 
-                    if (creature->AI()->GetData(DATA_SHOW_UNDERGROUND))
-                        AddGossipItemFor(player, MENU_ID_WORMHOLE, GOSSIP_OPTION_6, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF + 6);
+                        if (_showUnderground)
+                            AddGossipItemFor(player, MENU_ID_WORMHOLE, GOSSIP_OPTION_6, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF + 6);
 
-                    SendGossipMenuFor(player, NPC_TEXT_WORMHOLE, creature->GetGUID());
+                        SendGossipMenuFor(player, NPC_TEXT_WORMHOLE, me->GetGUID());
+                    }
                 }
+
+                return true;
             }
 
-            return true;
-        }
+            bool GossipSelect(Player* player, uint32 /*menuId*/, uint32 gossipListId) override
+            {
+                uint32 const action = player->PlayerTalkClass->GetGossipOptionAction(gossipListId);
+                ClearGossipMenuFor(player);
 
-        bool OnGossipSelect(Player* player, Creature* creature, uint32 /*sender*/, uint32 action) override
-        {
-            ClearGossipMenuFor(player);
+                switch (action)
+                {
+                    case GOSSIP_ACTION_INFO_DEF + 1: // Borean Tundra
+                        CloseGossipMenuFor(player);
+                        DoCast(player, SPELL_BOREAN_TUNDRA, false);
+                        break;
+                    case GOSSIP_ACTION_INFO_DEF + 2: // Howling Fjord
+                        CloseGossipMenuFor(player);
+                        DoCast(player, SPELL_HOWLING_FJORD, false);
+                        break;
+                    case GOSSIP_ACTION_INFO_DEF + 3: // Sholazar Basin
+                        CloseGossipMenuFor(player);
+                        DoCast(player, SPELL_SHOLAZAR_BASIN, false);
+                        break;
+                    case GOSSIP_ACTION_INFO_DEF + 4: // Icecrown
+                        CloseGossipMenuFor(player);
+                        DoCast(player, SPELL_ICECROWN, false);
+                        break;
+                    case GOSSIP_ACTION_INFO_DEF + 5: // Storm peaks
+                        CloseGossipMenuFor(player);
+                        DoCast(player, SPELL_STORM_PEAKS, false);
+                        break;
+                    case GOSSIP_ACTION_INFO_DEF + 6: // Underground
+                        CloseGossipMenuFor(player);
+                        DoCast(player, SPELL_UNDERGROUND, false);
+                        break;
+                }
 
-            switch (action)
-            {
-                case GOSSIP_ACTION_INFO_DEF + 1: // Borean Tundra
-                    CloseGossipMenuFor(player);
-                    creature->CastSpell(player, SPELL_BOREAN_TUNDRA, false);
-                    break;
-                case GOSSIP_ACTION_INFO_DEF + 2: // Howling Fjord
-                    CloseGossipMenuFor(player);
-                    creature->CastSpell(player, SPELL_HOWLING_FJORD, false);
-                    break;
-                case GOSSIP_ACTION_INFO_DEF + 3: // Sholazar Basin
-                    CloseGossipMenuFor(player);
-                    creature->CastSpell(player, SPELL_SHOLAZAR_BASIN, false);
-                    break;
-                case GOSSIP_ACTION_INFO_DEF + 4: // Icecrown
-                    CloseGossipMenuFor(player);
-                    creature->CastSpell(player, SPELL_ICECROWN, false);
-                    break;
-                case GOSSIP_ACTION_INFO_DEF + 5: // Storm peaks
-                    CloseGossipMenuFor(player);
-                    creature->CastSpell(player, SPELL_STORM_PEAKS, false);
-                    break;
-                case GOSSIP_ACTION_INFO_DEF + 6: // Underground
-                    CloseGossipMenuFor(player);
-                    creature->CastSpell(player, SPELL_UNDERGROUND, false);
-                    break;
+                return true;
             }
 
-            return true;
-        }
+        private:
+            bool _showUnderground;
+        };
 
         CreatureAI* GetAI(Creature* creature) const override
         {
@@ -1993,36 +1993,47 @@ class npc_experience : public CreatureScript
 public:
     npc_experience() : CreatureScript("npc_experience") { }
 
-    bool OnGossipHello(Player* player, Creature* creature) override
+    struct npc_experienceAI : public ScriptedAI
     {
-        if (player->HasPlayerFlag(PLAYER_FLAGS_NO_XP_GAIN)) // not gaining XP
+        npc_experienceAI(Creature* creature) : ScriptedAI(creature) { }
+
+        bool GossipHello(Player* player) override
         {
-            AddGossipItemFor(player, MENU_ID_XP_ON_OFF, OPTION_ID_XP_ON, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF + 1);
-            SendGossipMenuFor(player, NPC_TEXT_XP_ON_OFF, creature->GetGUID());
+            if (player->HasPlayerFlag(PLAYER_FLAGS_NO_XP_GAIN)) // not gaining XP
+            {
+                AddGossipItemFor(player, MENU_ID_XP_ON_OFF, OPTION_ID_XP_ON, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF + 1);
+                SendGossipMenuFor(player, NPC_TEXT_XP_ON_OFF, me->GetGUID());
+            }
+            else // currently gaining XP
+            {
+                AddGossipItemFor(player, MENU_ID_XP_ON_OFF, OPTION_ID_XP_OFF, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF + 2);
+                SendGossipMenuFor(player, NPC_TEXT_XP_ON_OFF, me->GetGUID());
+            }
+            return true;
         }
-        else // currently gaining XP
+
+        bool GossipSelect(Player* player, uint32 /*menuId*/, uint32 gossipListId) override
         {
-            AddGossipItemFor(player, MENU_ID_XP_ON_OFF, OPTION_ID_XP_OFF, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF + 2);
-            SendGossipMenuFor(player, NPC_TEXT_XP_ON_OFF, creature->GetGUID());
+            uint32 const action = player->PlayerTalkClass->GetGossipOptionAction(gossipListId);
+            ClearGossipMenuFor(player);
+
+            switch (action)
+            {
+                case GOSSIP_ACTION_INFO_DEF + 1: // XP ON selected
+                    player->RemovePlayerFlag(PLAYER_FLAGS_NO_XP_GAIN); // turn on XP gain
+                    break;
+                case GOSSIP_ACTION_INFO_DEF + 2: // XP OFF selected
+                    player->AddPlayerFlag(PLAYER_FLAGS_NO_XP_GAIN); // turn off XP gain
+                    break;
+            }
+            CloseGossipMenuFor(player);
+            return true;
         }
-        return true;
-    }
+    };
 
-    bool OnGossipSelect(Player* player, Creature* /*creature*/, uint32 /*sender*/, uint32 action) override
+    CreatureAI* GetAI(Creature* creature) const override
     {
-        ClearGossipMenuFor(player);
-
-        switch (action)
-        {
-            case GOSSIP_ACTION_INFO_DEF + 1: // XP ON selected
-                player->RemovePlayerFlag(PLAYER_FLAGS_NO_XP_GAIN); // turn on XP gain
-                break;
-            case GOSSIP_ACTION_INFO_DEF + 2: // XP OFF selected
-                player->AddPlayerFlag(PLAYER_FLAGS_NO_XP_GAIN); // turn off XP gain
-                break;
-        }
-        CloseGossipMenuFor(player);
-        return true;
+        return new npc_experienceAI(creature);
     }
 };
 
@@ -2675,7 +2686,7 @@ public:
                 });
         }
 
-        void sGossipSelect(Player* player, uint32 /*menuId*/, uint32 gossipListId) override
+        bool GossipSelect(Player* player, uint32 /*menuId*/, uint32 gossipListId) override
         {
             switch (gossipListId)
             {
@@ -2726,6 +2737,7 @@ public:
                     break;
             }
             player->PlayerTalkClass->SendCloseGossip();
+            return false;
         }
 
         void UpdateAI(uint32 diff) override