CreatureAISelector.cpp

Go to the documentation of this file.

/*
 * This file is part of the TrinityCore Project. See AUTHORS file for Copyright information
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation; either version 2 of the License, or (at your
 * option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program. If not, see <http://www.gnu.org/licenses/>.
 */
 
#include "AIException.h"
#include "AreaTrigger.h"
#include "Creature.h"
#include "CreatureAISelector.h"
#include "CreatureAIFactory.h"
#include "Log.h"
#include "MovementGenerator.h"
 
#include "GameObject.h"
#include "GameObjectAIFactory.h"
 
#include "AreaTriggerAI.h"
 
#include "ScriptMgr.h"
 
namespace FactorySelector
{
 template <class T, class Value>
 inline int32 GetPermitFor(T const* obj, Value const& value)
 {
 Permissible<T> const* const p = ASSERT_NOTNULL(dynamic_cast<Permissible<T> const*>(value.second.get()));
 return p->Permit(obj);
 }
 
 template <class T>
 struct PermissibleOrderPred
 {
 public:
 PermissibleOrderPred(T const* obj) : _obj(obj) { }
 
 template <class Value>
 bool operator()(Value const& left, Value const& right) const
 {
 return GetPermitFor(_obj, left) < GetPermitFor(_obj, right);
 }
 
 private:
 T const* const _obj;
 };
 
 template <class AI, class T>
 inline FactoryHolder<AI, T> const* SelectFactory(T const* obj)
 {
 static_assert(std::is_same<AI, CreatureAI>::value || std::is_same<AI, GameObjectAI>::value, "Invalid template parameter");
 static_assert(std::is_same<AI, CreatureAI>::value == std::is_same<T, Creature>::value, "Incompatible AI for type");
 static_assert(std::is_same<AI, GameObjectAI>::value == std::is_same<T, GameObject>::value, "Incompatible AI for type");
 
 using AIRegistry = typename FactoryHolder<AI, T>::FactoryHolderRegistry;
 
 // AIName in db
 std::string const& aiName = obj->GetAIName();
 if (!aiName.empty())
 return AIRegistry::instance()->GetRegistryItem(aiName);
 
 // select by permit check
 typename AIRegistry::RegistryMapType const& items = AIRegistry::instance()->GetRegisteredItems();
 auto itr = std::max_element(items.begin(), items.end(), PermissibleOrderPred<T>(obj));
 if (itr != items.end() && GetPermitFor(obj, *itr) >= 0)
 return itr->second.get();
 
 // should _never_ happen, Null AI types defined as PERMIT_BASE_IDLE, it must've been found
 ABORT();
 return nullptr;
 }
 
 CreatureAI* SelectAI(Creature* creature)
 {
 // special pet case, if a tamed creature uses AIName (example SmartAI) we need to override it
 if (creature->IsPet())
 return ASSERT_NOTNULL(sCreatureAIRegistry->GetRegistryItem("PetAI"))->Create(creature);
 
 // scriptname in db
 try
 {
 if (CreatureAI* scriptedAI = sScriptMgr->GetCreatureAI(creature))
 return scriptedAI;
 }
 catch (InvalidAIException const& e)
 {
 TC_LOG_ERROR("entities.unit", "Exception trying to assign script '{}' to Creature (Entry: {}), this Creature will have a default AI. Exception message: {}",
 creature->GetScriptName(), creature->GetEntry(), e.what());
 }
 
 return SelectFactory<CreatureAI>(creature)->Create(creature);
 }
 
 uint32 GetSelectedAIId(Creature const* creature)
 {
 if (creature->IsPet())
 {
 auto const* registry = ASSERT_NOTNULL(sCreatureAIRegistry->GetRegistryItem("PetAI"));
 auto const* factory = dynamic_cast<SelectableAI<Creature, CreatureAI> const*>(registry);
 ASSERT(factory);
 
 return factory->GetScriptId();
 }
 
 if (uint32 id = creature->GetScriptId())
 {
 if (sScriptMgr->CanCreateCreatureAI(id))
 {
 return id;
 }
 }
 
 auto const* factory = dynamic_cast<SelectableAI<Creature, CreatureAI> const*>(SelectFactory<CreatureAI>(creature));
 ASSERT(factory);
 
 return factory->GetScriptId();
 }
 
 MovementGenerator* SelectMovementGenerator(Unit* unit)
 {
 MovementGeneratorType type = unit->GetDefaultMovementType();
 if (Creature* creature = unit->ToCreature())
 if (!creature->GetPlayerMovingMe())
 type = creature->GetDefaultMovementType();
 
 MovementGeneratorCreator const* mv_factory = sMovementGeneratorRegistry->GetRegistryItem(type);
 return ASSERT_NOTNULL(mv_factory)->Create(unit);
 }
 
 GameObjectAI* SelectGameObjectAI(GameObject* go)
 {
 // scriptname in db
 if (GameObjectAI* scriptedAI = sScriptMgr->GetGameObjectAI(go))
 return scriptedAI;
 
 return SelectFactory<GameObjectAI>(go)->Create(go);
 }
 
 uint32 GetSelectedAIId(GameObject const* go)
 {
 if (uint32 id = go->GetScriptId())
 {
 if (sScriptMgr->CanCreateGameObjectAI(id))
 {
 return id;
 }
 }
 
 auto const* factory = dynamic_cast<SelectableAI<GameObject, GameObjectAI> const*>(SelectFactory<GameObjectAI>(go));
 ASSERT(factory);
 
 return factory->GetScriptId();
 }
 
 static uint32 GetNullAreaTriggerAIScriptId()
 {
 return sObjectMgr->GetScriptId("NullAreaTriggerAI", false);
 }
 
 AreaTriggerAI* SelectAreaTriggerAI(AreaTrigger* at)
 {
 if (AreaTriggerAI* ai = sScriptMgr->GetAreaTriggerAI(at))
 return ai;
 else
 return new NullAreaTriggerAI(at, GetNullAreaTriggerAIScriptId());
 }
 
 uint32 GetSelectedAIId(AreaTrigger const* at)
 {
 if (uint32 id = at->GetScriptId())
 {
 if (sScriptMgr->CanCreateAreaTriggerAI(id))
 {
 return id;
 }
 }
 
 return GetNullAreaTriggerAIScriptId();
 }
}