View difference between Paste ID: Nf9pE6gp and hTVu9wBy

 #include "ScriptPCH.h"
 #include "DatabaseEnv.h"
 #include "Util.h"
 #include "World.h"
 #include "ObjectMgr.h"
 
 #include <unordered_map>
 #include <memory>
 #include <boost/any.hpp>
 #include <functional>
 
 
 constexpr bool LoadNonFreeSpells = true;
 
 namespace LevelUpActions
 {
     const std::unordered_map<uint32, std::array<uint32, 2>> trainers =
     {
         {CLASS_WARRIOR, {26332, 26332}},
         {CLASS_PALADIN, {20406, 20406}},
         {CLASS_DRUID, {26324, 12042}},
         {CLASS_MAGE, {26326, 28956}},
         {CLASS_WARLOCK, {23534, 16266}},
         {CLASS_PRIEST, {16660, 17510}},
         {CLASS_HUNTER, {17505, 16673}},
         {CLASS_ROGUE, {26329, 26329}},
         {CLASS_SHAMAN, {17520, 17520}},
         {CLASS_DEATH_KNIGHT, {31084, 31084}}
     };
 
 
     enum class ActionType : uint16
     {
         LearnSpell = 1,
         LearnAllSpells,
         ApplyAura,
         ModifyMoney,
         AddItem
     };
 
 
     class Action
     {
     public:
         virtual void Process(Player*) = 0;
         virtual ~Action() {};
     };
 
     namespace detail
     {
 
 
         template <typename D>
         class Action_Impl : public Action
         {
         public:
             Action_Impl(std::vector<boost::any>&& params) : params(params) {}
 
             void Process(Player* player)
             {
                 static_cast<D*>(this)->Process(player);
             }
 
         protected:
             std::vector<boost::any> params;
         };
 
 
 #define DEFINE_TAG(x) \
         struct x {} x##_;
 
 
         DEFINE_TAG(float_tag);
         DEFINE_TAG(int32_tag);
         DEFINE_TAG(uint32_tag);
         DEFINE_TAG(vector_uint32_tag);
 
 
 #define EXTRACT_F(x) void ExtractOne(std::vector<boost::any>& v, Tokenizer& tok, std::size_t i, x)
 
         EXTRACT_F(float_tag)
         {
             v.push_back(boost::any{ std::stof(tok[i]) });
         }
 
         EXTRACT_F(int32_tag)
         {
             v.push_back(boost::any{ std::stoi(tok[i]) });
         }
 
         EXTRACT_F(uint32_tag)
         {
             auto res = std::stoi(tok[i]);
             if (res < 0)
                 res = 0;
             v.push_back(boost::any{ static_cast<uint32>(res) });
         }
 
         EXTRACT_F(vector_uint32_tag)
         {
             std::vector<uint32> vec;
             for (uint32 k = i; k < tok.size(); ++k, ++i)
             {
                 vec.push_back(std::stoi(tok[k]));
             }
             v.push_back(boost::any{ vec });
         }
 
 
         template <typename Type, typename... Types>
         void Extract(std::vector<boost::any>& v, Tokenizer& tok, std::size_t i, Type type, Types... types)
         {
             ExtractOne(v, tok, i++, type);
             Extract(v, tok, i, types...);
         }
 
         template <typename... Types>
         void Extract(std::vector<boost::any>& v, Tokenizer& tok, std::size_t i) {}
 
 
         template <typename... Types>
         std::vector<boost::any> ExtractTypes(std::string params, std::size_t i, Types... types)
         {
             Tokenizer tokenizer{ params, ' ' };
             std::vector<boost::any> ret;
             if(tokenizer.size())
                 Extract<Types...>(ret, tokenizer, 0, types...);
             return ret;
         }
     }
 
 #define CLASS_IMPL(x) class x : public detail::Action_Impl<x>
 
 
     CLASS_IMPL(LearnSpellAction)
     {
     public:
         using Action_Impl::Action_Impl;
 
         void Process(Player* player)
         {
             uint32 spellId = boost::any_cast<uint32>(params[0]);
             if (!player->HasSpell(spellId))
                 player->LearnSpell(spellId, false);
         }
     };
 
     CLASS_IMPL(LearnAllSpellsAction)
     {
     public:
         using Action_Impl::Action_Impl;
 
         void Process(Player* player)
         {
             auto itr = trainers.find(player->getClass());
             if(itr != trainers.end())
             {
                 for (const auto& trainerId : itr->second)
                 {
                     auto spells = sObjectMgr->GetNpcTrainerSpells(trainerId);
                     if (spells)
                     {
                         for (const auto& spell : spells->spellList)
                         {
                             const auto& sp = spell.second;
                             if (sp.MoneyCost && !LoadNonFreeSpells)
                                 continue;
 
                             if (!sp.ReqSkillLine && !sp.ReqSkillRank && sp.ReqLevel <= player->getLevel() && !player->HasSpell(sp.SpellID))
                                 player->LearnSpell(sp.SpellID, false);
                         }
                     }
                 }
             }
         }
     };
 
     CLASS_IMPL(ApplyAuraAction)
     {
     public:
         using Action_Impl::Action_Impl;
 
         void Process(Player* player)
         {
             uint32 spellId = boost::any_cast<uint32>(params[0]);
             player->AddAura(spellId, player);
         }
     };
 
     CLASS_IMPL(ModifyMoneyAction)
     {
     public:
         using Action_Impl::Action_Impl;
 
         void Process(Player* player)
         {
             int32 money = boost::any_cast<int32>(params[0]);
             player->ModifyMoney(money);
         }
     };
 
     CLASS_IMPL(AddItemAction)
     {
     public:
         using Action_Impl::Action_Impl;
 
         void Process(Player* player)
         {
             uint32 itemId = boost::any_cast<uint32>(params[0]);
             uint32 count = boost::any_cast<uint32>(params[1]);
             player->AddItem(itemId, count);
         }
     };
 
     const std::unordered_map<ActionType, std::function<std::unique_ptr<Action>(std::string params)>> typeFactory =
     {
         {
           ActionType::LearnSpell, [] (std::string params) {
             auto vec = detail::ExtractTypes(params, 0, detail::uint32_tag_);
             return std::unique_ptr<Action>(new LearnSpellAction(std::move(vec))); }
         },
 
         {
           ActionType::LearnAllSpells, [] (std::string params) {
             auto vec = detail::ExtractTypes(params, 0, detail::vector_uint32_tag_);
             return std::unique_ptr<Action>(new LearnAllSpellsAction(std::move(vec))); }
         },
 
         {
           ActionType::ApplyAura, [] (std::string params) {
             auto vec = detail::ExtractTypes(params, 0, detail::uint32_tag_);
             return std::unique_ptr<Action>(new ApplyAuraAction(std::move(vec))); }
         },
 
         {
           ActionType::ModifyMoney, [] (std::string params) {
             auto vec = detail::ExtractTypes(params, 0, detail::int32_tag_);
             return std::unique_ptr<Action>(new ModifyMoneyAction(std::move(vec))); }
         },
 
         {
           ActionType::AddItem, [] (std::string params) {
             auto vec = detail::ExtractTypes(params, 0, detail::uint32_tag_, detail::uint32_tag_);
             return std::unique_ptr<Action>(new AddItemAction(std::move(vec))); }
         }
     };
 
 
 
 
     std::unordered_multimap<int32, std::unique_ptr<Action>> actionHolder;
 
     class OnLevelupActions : public PlayerScript
     {
     public:
         OnLevelupActions() : PlayerScript("OnLevelupSpells") {}
 
         void OnLevelChanged(Player* player, uint8 oldLevel) override
         {
             int32 newLevel = player->getLevel();
             auto levelPairItr = actionHolder.equal_range(newLevel);
             auto autoPairItr = actionHolder.equal_range(-1);
 
             if (levelPairItr.first != levelPairItr.second)
             {
                 while (levelPairItr.first != levelPairItr.second)
                 {
                     levelPairItr.first->second->Process(player);
                     ++levelPairItr.first;
                 }
             }
 
             if (autoPairItr.first != autoPairItr.second)
             {
                 while (autoPairItr.first != autoPairItr.second)
                 {
                     autoPairItr.first->second->Process(player);
                     ++autoPairItr.first;
                 }
             }
         }
     };
 
     class LoadActions : public WorldScript
     {
     public:
         LoadActions() : WorldScript("LoadActionsLevelup") {}
 
 
         void OnStartup() override
         {
             const auto actionResult = WorldDatabase.Query("SELECT `Level`, `Action`, `Params` FROM `levelup_actions`");
 
             if (!actionResult)
                 return;
 
 
             do {
                 Field* fields = actionResult->Fetch();
 
                 int32 level = fields[0].GetInt32();
                 uint32 action = fields[1].GetUInt32();
                 std::string params = fields[2].GetString();
 
 
                 auto itr = typeFactory.find(static_cast<ActionType>(action));
                 if (itr != typeFactory.end())
                     actionHolder.insert({ level, itr->second(params) });
 
             } while (actionResult->NextRow());
         }
 
     };
 }
 
 void AddSC_LevelUpActions()
 {
     new LevelUpActions::OnLevelupActions;
     new LevelUpActions::LoadActions;
 }