FactorySelector Namespace Reference

Classes
struct	PermissibleOrderPred

Functions
template<class T , class Value >
int32	GetPermitFor (T const *obj, Value const &value)
template<class AI , class T >
FactoryHolder< AI, T > const *	SelectFactory (T *obj)
CreatureAI *	SelectAI (Creature *creature)
MovementGenerator *	SelectMovementGenerator (Unit *unit)
GameObjectAI *	SelectGameObjectAI (GameObject *go)

Function Documentation

GetPermitFor()

template<class T , class Value >

int32 FactorySelector::GetPermitFor ( T const *  obj, Value const &  value  )

inline

    {
        Permissible<T> const* const p = ASSERT_NOTNULL(dynamic_cast<Permissible<T> const*>(value.second.get()));
        return p->Permit(obj);
    }

References ASSERT_NOTNULL, and Permissible< T >::Permit().

Referenced by FactorySelector::PermissibleOrderPred< T >::operator()(), and SelectFactory().

SelectAI()

AC_GAME_API CreatureAI * FactorySelector::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
        if (CreatureAI* scriptedAI = sScriptMgr->GetCreatureAI(creature))
            return scriptedAI;
 
        return SelectFactory<CreatureAI>(creature)->Create(creature);
    }

References ASSERT_NOTNULL, Unit::IsPet(), sCreatureAIRegistry, and sScriptMgr.

Referenced by Creature::AIM_Initialize().

SelectFactory()

template<class AI , class T >

FactoryHolder< AI, T > const * FactorySelector::SelectFactory ( T *  obj )

inline

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

References ABORT, GetPermitFor(), and ObjectRegistry< T, Key >::GetRegistryItem().

SelectGameObjectAI()

AC_GAME_API GameObjectAI * FactorySelector::SelectGameObjectAI

(

GameObject *

go

)

    {
        // scriptname in db
        if (GameObjectAI* scriptedAI = sScriptMgr->GetGameObjectAI(go))
            return scriptedAI;
 
        return SelectFactory<GameObjectAI>(go)->Create(go);
    }

References sScriptMgr.

Referenced by GameObject::AIM_Initialize().

SelectMovementGenerator()

AC_GAME_API MovementGenerator * FactorySelector::SelectMovementGenerator

(

Unit *

unit

)

    {
        MovementGeneratorType type = IDLE_MOTION_TYPE;
        if (Creature* creature = unit->ToCreature())
            if (!creature->GetCharmerOrOwnerPlayerOrPlayerItself())
                type = creature->GetDefaultMovementType();
 
        MovementGeneratorCreator const* mv_factory = sMovementGeneratorRegistry->GetRegistryItem(type);
        return ASSERT_NOTNULL(mv_factory)->Create(unit);
    }

References ASSERT_NOTNULL, IDLE_MOTION_TYPE, sMovementGeneratorRegistry, and Object::ToCreature().

Referenced by MotionMaster::InitDefault().