ConditionMgr Class Reference

#include "ConditionMgr.h"

Public Member Functions
void	LoadConditions (bool isReload=false)
bool	isConditionTypeValid (Condition *cond)
ConditionList	GetConditionReferences (uint32 refId)
uint32	GetSearcherTypeMaskForConditionList (ConditionList const &conditions)
bool	IsObjectMeetToConditions (WorldObject *object, ConditionList const &conditions)
bool	IsObjectMeetToConditions (WorldObject *object1, WorldObject *object2, ConditionList const &conditions)
bool	IsObjectMeetToConditions (ConditionSourceInfo &sourceInfo, ConditionList const &conditions)
bool	CanHaveSourceGroupSet (ConditionSourceType sourceType) const
bool	CanHaveSourceIdSet (ConditionSourceType sourceType) const
ConditionList	GetConditionsForNotGroupedEntry (ConditionSourceType sourceType, uint32 entry)
ConditionList	GetConditionsForSpellClickEvent (uint32 creatureId, uint32 spellId)
ConditionList	GetConditionsForSmartEvent (int32 entryOrGuid, uint32 eventId, uint32 sourceType)
ConditionList	GetConditionsForVehicleSpell (uint32 creatureId, uint32 spellId)
ConditionList	GetConditionsForNpcVendorEvent (uint32 creatureId, uint32 itemId)

Static Public Member Functions
static ConditionMgr *	instance ()

Private Member Functions
	ConditionMgr ()
	~ConditionMgr ()
bool	isSourceTypeValid (Condition *cond)
bool	addToLootTemplate (Condition *cond, LootTemplate *loot)
bool	addToGossipMenus (Condition *cond)
bool	addToGossipMenuItems (Condition *cond)
bool	addToSpellImplicitTargetConditions (Condition *cond)
bool	IsObjectMeetToConditionList (ConditionSourceInfo &sourceInfo, ConditionList const &conditions)
void	Clean ()

Private Attributes
std::list< Condition * >	AllocatedMemoryStore
ConditionContainer	ConditionStore
ConditionReferenceContainer	ConditionReferenceStore
CreatureSpellConditionContainer	VehicleSpellConditionStore
CreatureSpellConditionContainer	SpellClickEventConditionStore
NpcVendorConditionContainer	NpcVendorConditionContainerStore
SmartEventConditionContainer	SmartEventConditionStore

Detailed Description

Constructor & Destructor Documentation

ConditionMgr()

ConditionMgr::ConditionMgr ( )

private

{}

~ConditionMgr()

ConditionMgr::~ConditionMgr ( )

private

{
    Clean();
}

References Clean().

Member Function Documentation

addToGossipMenuItems()

bool ConditionMgr::addToGossipMenuItems ( Condition *  cond )

private

{
    GossipMenuItemsMapBoundsNonConst pMenuItemBounds = sObjectMgr->GetGossipMenuItemsMapBoundsNonConst(cond->SourceGroup);
    if (pMenuItemBounds.first != pMenuItemBounds.second)
    {
        for (GossipMenuItemsContainer::iterator itr = pMenuItemBounds.first; itr != pMenuItemBounds.second; ++itr)
        {
            if ((*itr).second.MenuID == cond->SourceGroup && (*itr).second.OptionID == uint32(cond->SourceEntry))
            {
                (*itr).second.Conditions.push_back(cond);
                return true;
            }
        }
    }
 
    LOG_ERROR("sql.sql", "addToGossipMenuItems: GossipMenuId {} Item {} not found", cond->SourceGroup, cond->SourceEntry);
    return false;
}

References LOG_ERROR, sObjectMgr, Condition::SourceEntry, and Condition::SourceGroup.

Referenced by LoadConditions().

addToGossipMenus()

bool ConditionMgr::addToGossipMenus ( Condition *  cond )

private

{
    GossipMenusMapBoundsNonConst pMenuBounds = sObjectMgr->GetGossipMenusMapBoundsNonConst(cond->SourceGroup);
 
    if (pMenuBounds.first != pMenuBounds.second)
    {
        for (GossipMenusContainer::iterator itr = pMenuBounds.first; itr != pMenuBounds.second; ++itr)
        {
            if ((*itr).second.MenuID == cond->SourceGroup && (*itr).second.TextID == uint32(cond->SourceEntry))
            {
                (*itr).second.Conditions.push_back(cond);
                return true;
            }
        }
    }
 
    LOG_ERROR("sql.sql", "addToGossipMenus: GossipMenu {} not found", cond->SourceGroup);
    return false;
}

References LOG_ERROR, sObjectMgr, Condition::SourceEntry, and Condition::SourceGroup.

Referenced by LoadConditions().

addToLootTemplate()

bool ConditionMgr::addToLootTemplate ( Condition *  cond, LootTemplate *  loot  )

private

{
    if (!loot)
    {
        LOG_ERROR("sql.sql", "ConditionMgr: LootTemplate {} not found", cond->SourceGroup);
        return false;
    }
 
    if (loot->addConditionItem(cond))
        return true;
 
    LOG_ERROR("sql.sql", "ConditionMgr: Item {} not found in LootTemplate {}", cond->SourceEntry, cond->SourceGroup);
    return false;
}

References LootTemplate::addConditionItem(), LOG_ERROR, Condition::SourceEntry, and Condition::SourceGroup.

Referenced by LoadConditions().

addToSpellImplicitTargetConditions()

bool ConditionMgr::addToSpellImplicitTargetConditions ( Condition *  cond )

private

{
    uint32            conditionEffMask = cond->SourceGroup;
    SpellInfo*        spellInfo        = const_cast<SpellInfo*>(sSpellMgr->AssertSpellInfo(cond->SourceEntry));
    std::list<uint32> sharedMasks;
    for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
    {
        // check if effect is already a part of some shared mask
        bool found = false;
        for (std::list<uint32>::iterator itr = sharedMasks.begin(); itr != sharedMasks.end(); ++itr)
        {
            if ((1 << i) & *itr)
            {
                found = true;
                break;
            }
        }
        if (found)
            continue;
 
        // build new shared mask with found effect
        uint32         sharedMask = (1 << i);
        ConditionList* cmp        = spellInfo->Effects[i].ImplicitTargetConditions;
        for (uint8 effIndex = i + 1; effIndex < MAX_SPELL_EFFECTS; ++effIndex)
        {
            if (spellInfo->Effects[effIndex].ImplicitTargetConditions == cmp)
                sharedMask |= 1 << effIndex;
        }
        sharedMasks.push_back(sharedMask);
    }
 
    for (std::list<uint32>::iterator itr = sharedMasks.begin(); itr != sharedMasks.end(); ++itr)
    {
        // some effect indexes should have same data
        if (uint32 commonMask = *itr & conditionEffMask)
        {
            uint8 firstEffIndex = 0;
            for (; firstEffIndex < MAX_SPELL_EFFECTS; ++firstEffIndex)
                if ((1 << firstEffIndex) & *itr)
                    break;
 
            if (firstEffIndex >= MAX_SPELL_EFFECTS)
                return false;
 
            // get shared data
            ConditionList* sharedList = spellInfo->Effects[firstEffIndex].ImplicitTargetConditions;
 
            // there's already data entry for that sharedMask
            if (sharedList)
            {
                // we have overlapping masks in db
                if (conditionEffMask != *itr)
                {
                    LOG_ERROR("sql.sql",
                              "SourceEntry {} in `condition` table, has incorrect SourceGroup {} (spell effectMask) set - "
                              "effect masks are overlapping (all SourceGroup values having given bit set must be equal) - ignoring.",
                              cond->SourceEntry, cond->SourceGroup);
                    return false;
                }
            }
            // no data for shared mask, we can create new submask
            else
            {
                // add new list, create new shared mask
                sharedList    = new ConditionList();
                bool assigned = false;
                for (uint8 i = firstEffIndex; i < MAX_SPELL_EFFECTS; ++i)
                {
                    if ((1 << i) & commonMask)
                    {
                        spellInfo->Effects[i].ImplicitTargetConditions = sharedList;
                        assigned                                       = true;
                    }
                }
 
                if (!assigned)
                    delete sharedList;
            }
            if (sharedList)
                sharedList->push_back(cond);
            break;
        }
    }
    return true;
}

References SpellInfo::Effects, LOG_ERROR, MAX_SPELL_EFFECTS, Condition::SourceEntry, Condition::SourceGroup, and sSpellMgr.

Referenced by LoadConditions().

CanHaveSourceGroupSet()

bool ConditionMgr::CanHaveSourceGroupSet

(

ConditionSourceType

sourceType

)

const

{
    return (sourceType == CONDITION_SOURCE_TYPE_CREATURE_LOOT_TEMPLATE || sourceType == CONDITION_SOURCE_TYPE_DISENCHANT_LOOT_TEMPLATE || sourceType == CONDITION_SOURCE_TYPE_FISHING_LOOT_TEMPLATE || sourceType == CONDITION_SOURCE_TYPE_GAMEOBJECT_LOOT_TEMPLATE || sourceType == CONDITION_SOURCE_TYPE_ITEM_LOOT_TEMPLATE || sourceType == CONDITION_SOURCE_TYPE_MAIL_LOOT_TEMPLATE || sourceType == CONDITION_SOURCE_TYPE_MILLING_LOOT_TEMPLATE ||
            sourceType == CONDITION_SOURCE_TYPE_PICKPOCKETING_LOOT_TEMPLATE || sourceType == CONDITION_SOURCE_TYPE_PROSPECTING_LOOT_TEMPLATE || sourceType == CONDITION_SOURCE_TYPE_REFERENCE_LOOT_TEMPLATE || sourceType == CONDITION_SOURCE_TYPE_SKINNING_LOOT_TEMPLATE || sourceType == CONDITION_SOURCE_TYPE_SPELL_LOOT_TEMPLATE || sourceType == CONDITION_SOURCE_TYPE_GOSSIP_MENU || sourceType == CONDITION_SOURCE_TYPE_GOSSIP_MENU_OPTION || sourceType == CONDITION_SOURCE_TYPE_VEHICLE_SPELL ||
            sourceType == CONDITION_SOURCE_TYPE_SPELL_IMPLICIT_TARGET || sourceType == CONDITION_SOURCE_TYPE_SPELL_CLICK_EVENT || sourceType == CONDITION_SOURCE_TYPE_SMART_EVENT || sourceType == CONDITION_SOURCE_TYPE_NPC_VENDOR || sourceType == CONDITION_SOURCE_TYPE_PLAYER_LOOT_TEMPLATE);
}

References CONDITION_SOURCE_TYPE_CREATURE_LOOT_TEMPLATE, CONDITION_SOURCE_TYPE_DISENCHANT_LOOT_TEMPLATE, CONDITION_SOURCE_TYPE_FISHING_LOOT_TEMPLATE, CONDITION_SOURCE_TYPE_GAMEOBJECT_LOOT_TEMPLATE, CONDITION_SOURCE_TYPE_GOSSIP_MENU, CONDITION_SOURCE_TYPE_GOSSIP_MENU_OPTION, CONDITION_SOURCE_TYPE_ITEM_LOOT_TEMPLATE, CONDITION_SOURCE_TYPE_MAIL_LOOT_TEMPLATE, CONDITION_SOURCE_TYPE_MILLING_LOOT_TEMPLATE, CONDITION_SOURCE_TYPE_NPC_VENDOR, CONDITION_SOURCE_TYPE_PICKPOCKETING_LOOT_TEMPLATE, CONDITION_SOURCE_TYPE_PLAYER_LOOT_TEMPLATE, CONDITION_SOURCE_TYPE_PROSPECTING_LOOT_TEMPLATE, CONDITION_SOURCE_TYPE_REFERENCE_LOOT_TEMPLATE, CONDITION_SOURCE_TYPE_SKINNING_LOOT_TEMPLATE, CONDITION_SOURCE_TYPE_SMART_EVENT, CONDITION_SOURCE_TYPE_SPELL_CLICK_EVENT, CONDITION_SOURCE_TYPE_SPELL_IMPLICIT_TARGET, CONDITION_SOURCE_TYPE_SPELL_LOOT_TEMPLATE, and CONDITION_SOURCE_TYPE_VEHICLE_SPELL.

Referenced by LoadConditions().

CanHaveSourceIdSet()

bool ConditionMgr::CanHaveSourceIdSet

(

ConditionSourceType

sourceType

)

const

{
    return (sourceType == CONDITION_SOURCE_TYPE_SMART_EVENT);
}

References CONDITION_SOURCE_TYPE_SMART_EVENT.

Referenced by LoadConditions().

Clean()

void ConditionMgr::Clean ( )

private

{
    for (ConditionReferenceContainer::iterator itr = ConditionReferenceStore.begin(); itr != ConditionReferenceStore.end(); ++itr)
    {
        for (ConditionList::const_iterator it = itr->second.begin(); it != itr->second.end(); ++it) delete *it;
        itr->second.clear();
    }
 
    ConditionReferenceStore.clear();
 
    for (ConditionContainer::iterator itr = ConditionStore.begin(); itr != ConditionStore.end(); ++itr)
    {
        for (ConditionTypeContainer::iterator it = itr->second.begin(); it != itr->second.end(); ++it)
        {
            for (ConditionList::const_iterator i = it->second.begin(); i != it->second.end(); ++i) delete *i;
            it->second.clear();
        }
        itr->second.clear();
    }
 
    ConditionStore.clear();
 
    for (CreatureSpellConditionContainer::iterator itr = VehicleSpellConditionStore.begin(); itr != VehicleSpellConditionStore.end(); ++itr)
    {
        for (ConditionTypeContainer::iterator it = itr->second.begin(); it != itr->second.end(); ++it)
        {
            for (ConditionList::const_iterator i = it->second.begin(); i != it->second.end(); ++i) delete *i;
            it->second.clear();
        }
        itr->second.clear();
    }
 
    VehicleSpellConditionStore.clear();
 
    for (SmartEventConditionContainer::iterator itr = SmartEventConditionStore.begin(); itr != SmartEventConditionStore.end(); ++itr)
    {
        for (ConditionTypeContainer::iterator it = itr->second.begin(); it != itr->second.end(); ++it)
        {
            for (ConditionList::const_iterator i = it->second.begin(); i != it->second.end(); ++i) delete *i;
            it->second.clear();
        }
        itr->second.clear();
    }
 
    SmartEventConditionStore.clear();
 
    for (CreatureSpellConditionContainer::iterator itr = SpellClickEventConditionStore.begin(); itr != SpellClickEventConditionStore.end(); ++itr)
    {
        for (ConditionTypeContainer::iterator it = itr->second.begin(); it != itr->second.end(); ++it)
        {
            for (ConditionList::const_iterator i = it->second.begin(); i != it->second.end(); ++i) delete *i;
            it->second.clear();
        }
        itr->second.clear();
    }
 
    SpellClickEventConditionStore.clear();
 
    for (NpcVendorConditionContainer::iterator itr = NpcVendorConditionContainerStore.begin(); itr != NpcVendorConditionContainerStore.end(); ++itr)
    {
        for (ConditionTypeContainer::iterator it = itr->second.begin(); it != itr->second.end(); ++it)
        {
            for (ConditionList::const_iterator i = it->second.begin(); i != it->second.end(); ++i) delete *i;
            it->second.clear();
        }
        itr->second.clear();
    }
 
    NpcVendorConditionContainerStore.clear();
 
    // this is a BIG hack, feel free to fix it if you can figure out the ConditionMgr ;)
    for (std::list<Condition*>::const_iterator itr = AllocatedMemoryStore.begin(); itr != AllocatedMemoryStore.end(); ++itr) delete *itr;
 
    AllocatedMemoryStore.clear();
}

References AllocatedMemoryStore, ConditionReferenceStore, ConditionStore, NpcVendorConditionContainerStore, SmartEventConditionStore, SpellClickEventConditionStore, and VehicleSpellConditionStore.

Referenced by LoadConditions(), and ~ConditionMgr().

GetConditionReferences()

ConditionList ConditionMgr::GetConditionReferences

(

uint32

refId

)

{
    ConditionList                               conditions;
    ConditionReferenceContainer::const_iterator ref = ConditionReferenceStore.find(refId);
    if (ref != ConditionReferenceStore.end())
        conditions = (*ref).second;
    return conditions;
}

References ConditionReferenceStore.

GetConditionsForNotGroupedEntry()

ConditionList ConditionMgr::GetConditionsForNotGroupedEntry	(	ConditionSourceType	sourceType,
		uint32	entry
	)

{
    ConditionList spellCond;
    if (sourceType > CONDITION_SOURCE_TYPE_NONE && sourceType < CONDITION_SOURCE_TYPE_MAX)
    {
        ConditionContainer::const_iterator itr = ConditionStore.find(sourceType);
        if (itr != ConditionStore.end())
        {
            ConditionTypeContainer::const_iterator i = (*itr).second.find(entry);
            if (i != (*itr).second.end())
            {
                spellCond = (*i).second;
                LOG_DEBUG("condition", "GetConditionsForNotGroupedEntry: found conditions for type {} and entry {}", uint32(sourceType), entry);
            }
        }
    }
    return spellCond;
}

References CONDITION_SOURCE_TYPE_MAX, CONDITION_SOURCE_TYPE_NONE, ConditionStore, and LOG_DEBUG.

GetConditionsForNpcVendorEvent()

ConditionList ConditionMgr::GetConditionsForNpcVendorEvent	(	uint32	creatureId,
		uint32	itemId
	)

{
    ConditionList                               cond;
    NpcVendorConditionContainer::const_iterator itr = NpcVendorConditionContainerStore.find(creatureId);
    if (itr != NpcVendorConditionContainerStore.end())
    {
        ConditionTypeContainer::const_iterator i = (*itr).second.find(itemId);
        if (i != (*itr).second.end())
        {
            cond = (*i).second;
            if (itemId)
            {
                LOG_DEBUG("condition", "GetConditionsForNpcVendorEvent: found conditions for creature entry {} item {}", creatureId, itemId);
            }
            else
            {
                LOG_DEBUG("condition", "GetConditionsForNpcVendorEvent: found conditions for creature entry {}", creatureId);
            }
        }
    }
    return cond;
}

References LOG_DEBUG, and NpcVendorConditionContainerStore.

GetConditionsForSmartEvent()

ConditionList ConditionMgr::GetConditionsForSmartEvent	(	int32	entryOrGuid,
		uint32	eventId,
		uint32	sourceType
	)

{
    ConditionList                                cond;
    SmartEventConditionContainer::const_iterator itr = SmartEventConditionStore.find(std::make_pair(entryOrGuid, sourceType));
    if (itr != SmartEventConditionStore.end())
    {
        ConditionTypeContainer::const_iterator i = (*itr).second.find(eventId + 1);
        if (i != (*itr).second.end())
        {
            cond = (*i).second;
            LOG_DEBUG("condition", "GetConditionsForSmartEvent: found conditions for Smart Event entry or guid {} event_id {}", entryOrGuid, eventId);
        }
    }
    return cond;
}

References LOG_DEBUG, and SmartEventConditionStore.

GetConditionsForSpellClickEvent()

ConditionList ConditionMgr::GetConditionsForSpellClickEvent	(	uint32	creatureId,
		uint32	spellId
	)

{
    ConditionList                                   cond;
    CreatureSpellConditionContainer::const_iterator itr = SpellClickEventConditionStore.find(creatureId);
    if (itr != SpellClickEventConditionStore.end())
    {
        ConditionTypeContainer::const_iterator i = (*itr).second.find(spellId);
        if (i != (*itr).second.end())
        {
            cond = (*i).second;
            LOG_DEBUG("condition", "GetConditionsForSpellClickEvent: found conditions for Vehicle entry {} spell {}", creatureId, spellId);
        }
    }
    return cond;
}

References LOG_DEBUG, and SpellClickEventConditionStore.

GetConditionsForVehicleSpell()

ConditionList ConditionMgr::GetConditionsForVehicleSpell	(	uint32	creatureId,
		uint32	spellId
	)

{
    ConditionList                                   cond;
    CreatureSpellConditionContainer::const_iterator itr = VehicleSpellConditionStore.find(creatureId);
    if (itr != VehicleSpellConditionStore.end())
    {
        ConditionTypeContainer::const_iterator i = (*itr).second.find(spellId);
        if (i != (*itr).second.end())
        {
            cond = (*i).second;
            LOG_DEBUG("condition", "GetConditionsForVehicleSpell: found conditions for Vehicle entry {} spell {}", creatureId, spellId);
        }
    }
    return cond;
}

References LOG_DEBUG, and VehicleSpellConditionStore.

GetSearcherTypeMaskForConditionList()

uint32 ConditionMgr::GetSearcherTypeMaskForConditionList

(

ConditionList const &

conditions

)

{
    if (conditions.empty())
        return GRID_MAP_TYPE_MASK_ALL;
    //     groupId, typeMask
    std::map<uint32, uint32> ElseGroupStore;
    for (ConditionList::const_iterator i = conditions.begin(); i != conditions.end(); ++i)
    {
        // no point of having not loaded conditions in list
        ASSERT((*i)->isLoaded() && "ConditionMgr::GetSearcherTypeMaskForConditionList - not yet loaded condition found in list");
        std::map<uint32, uint32>::const_iterator itr = ElseGroupStore.find((*i)->ElseGroup);
        // group not filled yet, fill with widest mask possible
        if (itr == ElseGroupStore.end())
            ElseGroupStore[(*i)->ElseGroup] = GRID_MAP_TYPE_MASK_ALL;
        // no point of checking anymore, empty mask
        else if (!(*itr).second)
            continue;
 
        if ((*i)->ReferenceId) // handle reference
        {
            ConditionReferenceContainer::const_iterator ref = ConditionReferenceStore.find((*i)->ReferenceId);
            ASSERT(ref != ConditionReferenceStore.end() && "ConditionMgr::GetSearcherTypeMaskForConditionList - incorrect reference");
            ElseGroupStore[(*i)->ElseGroup] &= GetSearcherTypeMaskForConditionList((*ref).second);
        }
        else // handle normal condition
        {
            // object will match conditions in one ElseGroupStore only when it matches all of them
            // so, let's find a smallest possible mask which satisfies all conditions
            ElseGroupStore[(*i)->ElseGroup] &= (*i)->GetSearcherTypeMaskForCondition();
        }
    }
    // object will match condition when one of the checks in ElseGroupStore is matching
    // so, let's include all possible masks
    uint32 mask = 0;
    for (std::map<uint32, uint32>::const_iterator i = ElseGroupStore.begin(); i != ElseGroupStore.end(); ++i) mask |= i->second;
 
    return mask;
}

References ASSERT, ConditionReferenceStore, GetSearcherTypeMaskForConditionList(), and GRID_MAP_TYPE_MASK_ALL.

Referenced by GetSearcherTypeMaskForConditionList().

instance()

ConditionMgr * ConditionMgr::instance ( )

static

{
    static ConditionMgr instance;
    return &instance;
}

References instance().

Referenced by instance().

isConditionTypeValid()

bool ConditionMgr::isConditionTypeValid

(

Condition *

cond

)

{
    if (cond->ConditionType == CONDITION_NONE || (cond->ConditionType >= CONDITION_TC_END && cond->ConditionType <= CONDITION_AC_START) || (cond->ConditionType >= CONDITION_AC_END))
    {
        LOG_ERROR("sql.sql", "SourceEntry {} in `condition` table has an invalid ConditionType ({}), ignoring.", cond->SourceEntry, uint32(cond->ConditionType));
        return false;
    }
    switch (cond->ConditionType)
    {
    case CONDITION_TERRAIN_SWAP:
        LOG_ERROR("sql.sql", "SourceEntry {} in `condition` table has a ConditionType that is not supported on 3.3.5a ({}), ignoring.", cond->SourceEntry, uint32(cond->ConditionType));
        return false;
    default:
        break;
    }
 
    if (cond->ConditionTarget >= cond->GetMaxAvailableConditionTargets())
    {
        LOG_ERROR("sql.sql", "SourceType {}, SourceEntry {} in `condition` table, has incorrect ConditionTarget set, ignoring.", cond->SourceType, cond->SourceEntry);
        return false;
    }
 
    switch (cond->ConditionType)
    {
    case CONDITION_AURA:
    {
        if (!sSpellMgr->GetSpellInfo(cond->ConditionValue1))
        {
            LOG_ERROR("sql.sql", "Aura condition has non existing spell (Id: {}), skipped", cond->ConditionValue1);
            return false;
        }
 
        if (cond->ConditionValue2 > EFFECT_2)
        {
            LOG_ERROR("sql.sql", "Aura condition has non existing effect index ({}) (must be 0..2), skipped", cond->ConditionValue2);
            return false;
        }
        if (cond->ConditionValue3)
            LOG_ERROR("sql.sql", "Aura condition has useless data in value3 ({})!", cond->ConditionValue3);
        break;
    }
    case CONDITION_ITEM:
    {
        ItemTemplate const* proto = sObjectMgr->GetItemTemplate(cond->ConditionValue1);
        if (!proto)
        {
            LOG_ERROR("sql.sql", "Item condition has non existing item ({}), skipped", cond->ConditionValue1);
            return false;
        }
 
        if (!cond->ConditionValue2)
        {
            LOG_ERROR("sql.sql", "Item condition has 0 set for item count in value2 ({}), skipped", cond->ConditionValue2);
            return false;
        }
        break;
    }
    case CONDITION_ITEM_EQUIPPED:
    {
        ItemTemplate const* proto = sObjectMgr->GetItemTemplate(cond->ConditionValue1);
        if (!proto)
        {
            LOG_ERROR("sql.sql", "ItemEquipped condition has non existing item ({}), skipped", cond->ConditionValue1);
            return false;
        }
 
        if (cond->ConditionValue2)
            LOG_ERROR("sql.sql", "ItemEquipped condition has useless data in value2 ({})!", cond->ConditionValue2);
        if (cond->ConditionValue3)
            LOG_ERROR("sql.sql", "ItemEquipped condition has useless data in value3 ({})!", cond->ConditionValue3);
        break;
    }
    case CONDITION_ZONEID:
    {
        AreaTableEntry const* areaEntry = sAreaTableStore.LookupEntry(cond->ConditionValue1);
        if (!areaEntry)
        {
            LOG_ERROR("sql.sql", "ZoneID condition has non existing area ({}), skipped", cond->ConditionValue1);
            return false;
        }
 
        if (areaEntry->zone != 0)
        {
            LOG_ERROR("sql.sql", "ZoneID condition requires to be in area ({}) which is a subzone but zone expected, skipped", cond->ConditionValue1);
            return false;
        }
 
        if (cond->ConditionValue2)
            LOG_ERROR("sql.sql", "ZoneID condition has useless data in value2 ({})!", cond->ConditionValue2);
        if (cond->ConditionValue3)
            LOG_ERROR("sql.sql", "ZoneID condition has useless data in value3 ({})!", cond->ConditionValue3);
        break;
    }
    case CONDITION_REPUTATION_RANK:
    {
        FactionEntry const* factionEntry = sFactionStore.LookupEntry(cond->ConditionValue1);
        if (!factionEntry)
        {
            LOG_ERROR("sql.sql", "Reputation condition has non existing faction ({}), skipped", cond->ConditionValue1);
            return false;
        }
        if (cond->ConditionValue3)
            LOG_ERROR("sql.sql", "Reputation condition has useless data in value3 ({})!", cond->ConditionValue3);
        break;
    }
    case CONDITION_TEAM:
    {
        if (cond->ConditionValue1 != ALLIANCE && cond->ConditionValue1 != HORDE)
        {
            LOG_ERROR("sql.sql", "Team condition specifies unknown team ({}), skipped", cond->ConditionValue1);
            return false;
        }
 
        if (cond->ConditionValue2)
            LOG_ERROR("sql.sql", "Team condition has useless data in value2 ({})!", cond->ConditionValue2);
        if (cond->ConditionValue3)
            LOG_ERROR("sql.sql", "Team condition has useless data in value3 ({})!", cond->ConditionValue3);
        break;
    }
    case CONDITION_SKILL:
    {
        SkillLineEntry const* pSkill = sSkillLineStore.LookupEntry(cond->ConditionValue1);
        if (!pSkill)
        {
            LOG_ERROR("sql.sql", "Skill condition specifies non-existing skill ({}), skipped", cond->ConditionValue1);
            return false;
        }
 
        if (cond->ConditionValue2 < 1 || cond->ConditionValue2 > sWorld->GetConfigMaxSkillValue())
        {
            LOG_ERROR("sql.sql", "Skill condition specifies invalid skill value ({}), skipped", cond->ConditionValue2);
            return false;
        }
        if (cond->ConditionValue3)
            LOG_ERROR("sql.sql", "Skill condition has useless data in value3 ({})!", cond->ConditionValue3);
        break;
    }
    case CONDITION_QUESTREWARDED:
    case CONDITION_QUESTTAKEN:
    case CONDITION_QUEST_NONE:
    case CONDITION_QUEST_COMPLETE:
    case CONDITION_DAILY_QUEST_DONE:
    case CONDITION_QUEST_SATISFY_EXCLUSIVE:
    {
        if (!sObjectMgr->GetQuestTemplate(cond->ConditionValue1))
        {
            LOG_ERROR("sql.sql", "Quest condition specifies non-existing quest ({}), skipped", cond->ConditionValue1);
            return false;
        }
 
        if (cond->ConditionValue2 > 1)
        {
            LOG_ERROR("sql.sql", "Quest condition has useless data in value2 ({})!", cond->ConditionValue2);
        }
        if (cond->ConditionValue3)
        {
            LOG_ERROR("sql.sql", "Quest condition has useless data in value3 ({})!", cond->ConditionValue3);
        }
        break;
    }
    case CONDITION_QUESTSTATE:
        if (cond->ConditionValue2 >= (1 << MAX_QUEST_STATUS))
        {
            LOG_ERROR("sql.sql", "ConditionType ({}) has invalid state mask ({}), skipped.", cond->ConditionType, cond->ConditionValue2);
            return false;
        }
        break;
    case CONDITION_ACTIVE_EVENT:
    {
        GameEventMgr::GameEventDataMap const& events = sGameEventMgr->GetEventMap();
        if (cond->ConditionValue1 >= events.size() || !events[cond->ConditionValue1].isValid())
        {
            LOG_ERROR("sql.sql", "ActiveEvent condition has non existing event id ({}), skipped", cond->ConditionValue1);
            return false;
        }
 
        if (cond->ConditionValue2)
            LOG_ERROR("sql.sql", "ActiveEvent condition has useless data in value2 ({})!", cond->ConditionValue2);
        if (cond->ConditionValue3)
            LOG_ERROR("sql.sql", "ActiveEvent condition has useless data in value3 ({})!", cond->ConditionValue3);
        break;
    }
    case CONDITION_ACHIEVEMENT:
    {
        AchievementEntry const* achievement = sAchievementStore.LookupEntry(cond->ConditionValue1);
        if (!achievement)
        {
            LOG_ERROR("sql.sql", "Achivement condition has non existing achivement id ({}), skipped", cond->ConditionValue1);
            return false;
        }
 
        if (cond->ConditionValue2)
            LOG_ERROR("sql.sql", "Achivement condition has useless data in value2 ({})!", cond->ConditionValue2);
        if (cond->ConditionValue3)
            LOG_ERROR("sql.sql", "Achivement condition has useless data in value3 ({})!", cond->ConditionValue3);
        break;
    }
    case CONDITION_CLASS:
    {
        if (!(cond->ConditionValue1 & CLASSMASK_ALL_PLAYABLE))
        {
            LOG_ERROR("sql.sql", "Class condition has non existing classmask ({}), skipped", cond->ConditionValue1 & ~CLASSMASK_ALL_PLAYABLE);
            return false;
        }
 
        if (cond->ConditionValue2)
            LOG_ERROR("sql.sql", "Class condition has useless data in value2 ({})!", cond->ConditionValue2);
        if (cond->ConditionValue3)
            LOG_ERROR("sql.sql", "Class condition has useless data in value3 ({})!", cond->ConditionValue3);
        break;
    }
    case CONDITION_RACE:
    {
        if (!(cond->ConditionValue1 & sRaceMgr->GetPlayableRaceMask()))
        {
            LOG_ERROR("sql.sql", "Race condition has non existing racemask ({}), skipped", cond->ConditionValue1 & ~sRaceMgr->GetPlayableRaceMask());
            return false;
        }
 
        if (cond->ConditionValue2)
            LOG_ERROR("sql.sql", "Race condition has useless data in value2 ({})!", cond->ConditionValue2);
        if (cond->ConditionValue3)
            LOG_ERROR("sql.sql", "Race condition has useless data in value3 ({})!", cond->ConditionValue3);
        break;
    }
    case CONDITION_GENDER:
    {
        if (!Player::IsValidGender(uint8(cond->ConditionValue1)))
        {
            LOG_ERROR("condition", "Gender condition has invalid gender ({}), skipped", cond->ConditionValue1);
            return false;
        }
 
        if (cond->ConditionValue2)
            LOG_ERROR("condition", "Gender condition has useless data in value2 ({})!", cond->ConditionValue2);
        if (cond->ConditionValue3)
            LOG_ERROR("condition", "Gender condition has useless data in value3 ({})!", cond->ConditionValue3);
        break;
    }
    case CONDITION_MAPID:
    {
        MapEntry const* mapId = sMapStore.LookupEntry(cond->ConditionValue1);
        if (!mapId)
        {
            LOG_ERROR("sql.sql", "Map condition has non existing map ({}), skipped", cond->ConditionValue1);
            return false;
        }
 
        if (cond->ConditionValue2)
            LOG_ERROR("sql.sql", "Map condition has useless data in value2 ({})!", cond->ConditionValue2);
        if (cond->ConditionValue3)
            LOG_ERROR("sql.sql", "Map condition has useless data in value3 ({})!", cond->ConditionValue3);
        break;
    }
    case CONDITION_SPELL:
    {
        if (!sSpellMgr->GetSpellInfo(cond->ConditionValue1))
        {
            LOG_ERROR("sql.sql", "Spell condition has non existing spell (Id: {}), skipped", cond->ConditionValue1);
            return false;
        }
 
        if (cond->ConditionValue2)
            LOG_ERROR("sql.sql", "Spell condition has useless data in value2 ({})!", cond->ConditionValue2);
        if (cond->ConditionValue3)
            LOG_ERROR("sql.sql", "Spell condition has useless data in value3 ({})!", cond->ConditionValue3);
        break;
    }
    case CONDITION_LEVEL:
    {
        if (cond->ConditionValue2 >= COMP_TYPE_MAX)
        {
            LOG_ERROR("sql.sql", "Level condition has invalid option ({}), skipped", cond->ConditionValue2);
            return false;
        }
        if (cond->ConditionValue3)
            LOG_ERROR("sql.sql", "Level condition has useless data in value3 ({})!", cond->ConditionValue3);
        break;
    }
    case CONDITION_DRUNKENSTATE:
    {
        if (cond->ConditionValue1 > DRUNKEN_SMASHED)
        {
            LOG_ERROR("sql.sql", "DrunkState condition has invalid state ({}), skipped", cond->ConditionValue1);
            return false;
        }
        if (cond->ConditionValue2)
        {
            LOG_ERROR("sql.sql", "DrunkState condition has useless data in value2 ({})!", cond->ConditionValue2);
            return false;
        }
        if (cond->ConditionValue3)
            LOG_ERROR("sql.sql", "DrunkState condition has useless data in value3 ({})!", cond->ConditionValue3);
        break;
    }
    case CONDITION_NEAR_CREATURE:
    {
        if (!sObjectMgr->GetCreatureTemplate(cond->ConditionValue1))
        {
            LOG_ERROR("sql.sql", "NearCreature condition has non existing creature template entry ({}), skipped", cond->ConditionValue1);
            return false;
        }
        break;
    }
    case CONDITION_NEAR_GAMEOBJECT:
    {
        if (!sObjectMgr->GetGameObjectTemplate(cond->ConditionValue1))
        {
            LOG_ERROR("sql.sql", "NearGameObject condition has non existing gameobject template entry ({}), skipped", cond->ConditionValue1);
            return false;
        }
        if (cond->ConditionValue3 > 2)
            LOG_ERROR("sql.sql", "NearGameObject condition for gameobject ID ({}) has data over 2 for value3 ({})!", cond->ConditionValue1, cond->ConditionValue3);
        break;
    }
    case CONDITION_OBJECT_ENTRY_GUID:
    {
        switch (cond->ConditionValue1)
        {
        case TYPEID_UNIT:
            if (cond->ConditionValue2 && !sObjectMgr->GetCreatureTemplate(cond->ConditionValue2))
            {
                LOG_ERROR("sql.sql", "ObjectEntryGuid condition has non existing creature template entry ({}), skipped", cond->ConditionValue2);
                return false;
            }
            if (cond->ConditionValue3 > 1)
            {
                if (CreatureData const* creatureData = sObjectMgr->GetCreatureData(cond->ConditionValue3))
                {
                    if (cond->ConditionValue2 && creatureData->id1 != cond->ConditionValue2)
                    {
                        LOG_ERROR("sql.sql", "ObjectEntryGuid condition has guid {} set but does not match creature entry ({}), skipped", cond->ConditionValue3, cond->ConditionValue2);
                        return false;
                    }
                }
                else
                {
                    LOG_ERROR("sql.sql", "ObjectEntryGuid condition has non existing creature guid ({}), skipped", cond->ConditionValue3);
                    return false;
                }
            }
            break;
        case TYPEID_GAMEOBJECT:
            if (cond->ConditionValue2 && !sObjectMgr->GetGameObjectTemplate(cond->ConditionValue2))
            {
                LOG_ERROR("sql.sql", "ObjectEntryGuid condition has non existing gameobject template entry ({}), skipped", cond->ConditionValue2);
                return false;
            }
            if (cond->ConditionValue3)
            {
                if (GameObjectData const* goData = sObjectMgr->GetGameObjectData(cond->ConditionValue3))
                {
                    if (cond->ConditionValue2 && goData->id != cond->ConditionValue2)
                    {
                        LOG_ERROR("sql.sql", "ObjectEntryGuid condition has guid {} set but does not match gameobject entry ({}), skipped", cond->ConditionValue3, cond->ConditionValue2);
                        return false;
                    }
                }
                else
                {
                    LOG_ERROR("sql.sql", "ObjectEntryGuid condition has non existing gameobject guid ({}), skipped", cond->ConditionValue3);
                    return false;
                }
            }
            break;
        case TYPEID_PLAYER:
        case TYPEID_CORPSE:
            if (cond->ConditionValue2)
                LOG_ERROR("sql.sql", "ObjectEntryGuid condition has useless data in value2 ({})!", cond->ConditionValue2);
            if (cond->ConditionValue3)
                LOG_ERROR("sql.sql", "ObjectEntryGuid condition has useless data in value3 ({})!", cond->ConditionValue3);
            break;
        default:
            LOG_ERROR("sql.sql", "ObjectEntryGuid condition has wrong typeid set ({}), skipped", cond->ConditionValue1);
            return false;
        }
        break;
    }
    case CONDITION_TYPE_MASK:
    {
        if (!cond->ConditionValue1 || (cond->ConditionValue1 & ~(TYPEMASK_UNIT | TYPEMASK_PLAYER | TYPEMASK_GAMEOBJECT | TYPEMASK_CORPSE)))
        {
            LOG_ERROR("sql.sql", "TypeMask condition has invalid typemask set ({}), skipped", cond->ConditionValue2);
            return false;
        }
        if (cond->ConditionValue2)
            LOG_ERROR("sql.sql", "TypeMask condition has useless data in value2 ({})!", cond->ConditionValue2);
        if (cond->ConditionValue3)
            LOG_ERROR("sql.sql", "TypeMask condition has useless data in value3 ({})!", cond->ConditionValue3);
        break;
    }
    case CONDITION_RELATION_TO:
    {
        if (cond->ConditionValue1 >= cond->GetMaxAvailableConditionTargets())
        {
            LOG_ERROR("sql.sql", "RelationTo condition has invalid ConditionValue1(ConditionTarget selection) ({}), skipped", cond->ConditionValue1);
            return false;
        }
        if (cond->ConditionValue1 == cond->ConditionTarget)
        {
            LOG_ERROR("sql.sql", "RelationTo condition has ConditionValue1(ConditionTarget selection) set to self ({}), skipped", cond->ConditionValue1);
            return false;
        }
        if (cond->ConditionValue2 >= RELATION_MAX)
        {
            LOG_ERROR("sql.sql", "RelationTo condition has invalid ConditionValue2(RelationType) ({}), skipped", cond->ConditionValue2);
            return false;
        }
        if (cond->ConditionValue3)
            LOG_ERROR("sql.sql", "RelationTo condition has useless data in value3 ({})!", cond->ConditionValue3);
        break;
    }
    case CONDITION_REACTION_TO:
    {
        if (cond->ConditionValue1 >= cond->GetMaxAvailableConditionTargets())
        {
            LOG_ERROR("sql.sql", "ReactionTo condition has invalid ConditionValue1(ConditionTarget selection) ({}), skipped", cond->ConditionValue1);
            return false;
        }
        if (cond->ConditionValue1 == cond->ConditionTarget)
        {
            LOG_ERROR("sql.sql", "ReactionTo condition has ConditionValue1(ConditionTarget selection) set to self ({}), skipped", cond->ConditionValue1);
            return false;
        }
        if (!cond->ConditionValue2)
        {
            LOG_ERROR("sql.sql", "mConditionValue2 condition has invalid ConditionValue2(rankMask) ({}), skipped", cond->ConditionValue2);
            return false;
        }
        break;
    }
    case CONDITION_DISTANCE_TO:
    {
        if (cond->ConditionValue1 >= cond->GetMaxAvailableConditionTargets())
        {
            LOG_ERROR("sql.sql", "DistanceTo condition has invalid ConditionValue1(ConditionTarget selection) ({}), skipped", cond->ConditionValue1);
            return false;
        }
        if (cond->ConditionValue1 == cond->ConditionTarget)
        {
            LOG_ERROR("sql.sql", "DistanceTo condition has ConditionValue1(ConditionTarget selection) set to self ({}), skipped", cond->ConditionValue1);
            return false;
        }
        if (cond->ConditionValue3 >= COMP_TYPE_MAX)
        {
            LOG_ERROR("sql.sql", "DistanceTo condition has invalid ComparisionType ({}), skipped", cond->ConditionValue3);
            return false;
        }
        break;
    }
    case CONDITION_ALIVE:
    {
        if (cond->ConditionValue1)
            LOG_ERROR("sql.sql", "Alive condition has useless data in value1 ({})!", cond->ConditionValue1);
        if (cond->ConditionValue2)
            LOG_ERROR("sql.sql", "Alive condition has useless data in value2 ({})!", cond->ConditionValue2);
        if (cond->ConditionValue3)
            LOG_ERROR("sql.sql", "Alive condition has useless data in value3 ({})!", cond->ConditionValue3);
        break;
    }
    case CONDITION_HP_VAL:
    {
        if (cond->ConditionValue2 >= COMP_TYPE_MAX)
        {
            LOG_ERROR("sql.sql", "HpVal condition has invalid ComparisionType ({}), skipped", cond->ConditionValue2);
            return false;
        }
        if (cond->ConditionValue3)
            LOG_ERROR("sql.sql", "HpVal condition has useless data in value3 ({})!", cond->ConditionValue3);
        break;
    }
    case CONDITION_HP_PCT:
    {
        if (cond->ConditionValue1 > 100)
        {
            LOG_ERROR("sql.sql", "HpPct condition has too big percent value ({}), skipped", cond->ConditionValue1);
            return false;
        }
        if (cond->ConditionValue2 >= COMP_TYPE_MAX)
        {
            LOG_ERROR("sql.sql", "HpPct condition has invalid ComparisionType ({}), skipped", cond->ConditionValue2);
            return false;
        }
        if (cond->ConditionValue3)
            LOG_ERROR("sql.sql", "HpPct condition has useless data in value3 ({})!", cond->ConditionValue3);
        break;
    }
    case CONDITION_AREAID:
    case CONDITION_INSTANCE_INFO:
        break;
    case CONDITION_WORLD_STATE:
    {
        if (cond->ConditionValue3)
            LOG_ERROR("sql.sql", "World state condition has useless data in value3 ({})!", cond->ConditionValue3);
        break;
    }
    case CONDITION_PHASEMASK:
    {
        if (cond->ConditionValue2)
            LOG_ERROR("sql.sql", "Phasemask condition has useless data in value2 ({})!", cond->ConditionValue2);
        if (cond->ConditionValue3)
            LOG_ERROR("sql.sql", "Phasemask condition has useless data in value3 ({})!", cond->ConditionValue3);
        break;
    }
    case CONDITION_TITLE:
    {
        CharTitlesEntry const* titleEntry = sCharTitlesStore.LookupEntry(cond->ConditionValue1);
        if (!titleEntry)
        {
            LOG_ERROR("sql.sql", "Title condition has non existing title in value1 ({}), skipped", cond->ConditionValue1);
            return false;
        }
        break;
    }
    case CONDITION_SPAWNMASK:
    {
        if (cond->ConditionValue1 > SPAWNMASK_RAID_ALL)
        {
            LOG_ERROR("condition", "SpawnMask condition has non existing SpawnMask in value1 ({}), skipped", cond->ConditionValue1);
            return false;
        }
        break;
    }
    case CONDITION_UNIT_STATE:
    {
        if (!(cond->ConditionValue1 & UNIT_STATE_ALL_STATE_SUPPORTED))
        {
            LOG_ERROR("condition", "UnitState condition has non existing UnitState in value1 ({}), skipped", cond->ConditionValue1);
            return false;
        }
        break;
    }
    case CONDITION_CREATURE_TYPE:
    {
        if (!cond->ConditionValue1 || cond->ConditionValue1 > CREATURE_TYPE_GAS_CLOUD)
        {
            LOG_ERROR("condition", "CreatureType condition has non existing CreatureType in value1 ({}), skipped", cond->ConditionValue1);
            return false;
        }
        break;
    }
    case CONDITION_REALM_ACHIEVEMENT:
    {
        AchievementEntry const* achievement = sAchievementStore.LookupEntry(cond->ConditionValue1);
        if (!achievement)
        {
            LOG_ERROR("condition", "CONDITION_REALM_ACHIEVEMENT has non existing realm first achivement id ({}), skipped.", cond->ConditionValue1);
            return false;
        }
        break;
    }
    case CONDITION_QUEST_OBJECTIVE_PROGRESS:
    {
        const Quest* quest = sObjectMgr->GetQuestTemplate(cond->ConditionValue1);
        if (!quest)
        {
            LOG_ERROR("sql.sql", "CONDITION_QUEST_OBJECTIVE_PROGRESS points to non-existing quest ({}), skipped.", cond->ConditionValue1);
            return false;
        }
 
        if (cond->ConditionValue2 > 3)
        {
            LOG_ERROR("sql.sql", "CONDITION_QUEST_OBJECTIVE_PROGRESS has out-of-range quest objective index specified ({}), it must be a number between 0 and 3. skipped.", cond->ConditionValue2);
            return false;
        }
 
        if (quest->RequiredNpcOrGo[cond->ConditionValue2] == 0)
        {
            LOG_ERROR("sql.sql", "CONDITION_QUEST_OBJECTIVE_PROGRESS has quest objective {} for quest {}, but the field RequiredNPCOrGo{} is 0, skipped.", cond->ConditionValue2, cond->ConditionValue1, cond->ConditionValue2);
            return false;
        }
 
        if (cond->ConditionValue3 > quest->RequiredNpcOrGoCount[cond->ConditionValue2])
        {
            LOG_ERROR("sql.sql", "CONDITION_QUEST_OBJECTIVE_PROGRESS has quest objective count {} in value3, but quest {} has a maximum objective count of {} in RequiredNPCOrGOCount{}, skipped.", cond->ConditionValue3, cond->ConditionValue2, quest->RequiredNpcOrGoCount[cond->ConditionValue2], cond->ConditionValue2);
            return false;
        }
        break;
    }
    case CONDITION_HAS_AURA_TYPE:
    {
        if (cond->ConditionValue1 == SPELL_AURA_NONE || cond->ConditionValue1 >= TOTAL_AURAS)
        {
            LOG_ERROR("sql.sql", "Has Aura Effect condition has non existing aura ({}), skipped", cond->ConditionValue1);
            return false;
        }
        break;
    }
    case CONDITION_STAND_STATE:
    {
        bool valid = false;
        switch (cond->ConditionValue1)
        {
            case 0:
                valid = cond->ConditionValue2 <= UNIT_STAND_STATE_SUBMERGED;
                break;
            case 1:
                valid = cond->ConditionValue2 <= 1;
                break;
            default:
                valid = false;
                break;
        }
        if (!valid)
        {
            LOG_ERROR("sql.sql", "CONDITION_STAND_STATE has non-existing stand state ({},{}), skipped.", cond->ConditionValue1, cond->ConditionValue2);
            return false;
        }
        break;
    }
    case CONDITION_DIFFICULTY_ID:
        if (cond->ConditionValue1 >= MAX_DIFFICULTY)
        {
            LOG_ERROR("sql.sql", "CONDITION_DIFFICULTY_ID has non existing difficulty in value1 ({}), skipped.", cond->ConditionValue1);
            return false;
        }
        break;
    case CONDITION_PLAYER_QUEUED_RANDOM_DUNGEON:
        if (cond->ConditionValue1 > 1)
        {
            LOG_ERROR("sql.sql", "RandomDungeon condition has useless data in value1 ({}).", cond->ConditionValue1);
            return false;
        }
        if (cond->ConditionValue2 >= MAX_DIFFICULTY)
        {
            LOG_ERROR("sql.sql", "RandomDungeon condition has invalid difficulty in value2 ({}).", cond->ConditionValue1);
            return false;
        }
        if (cond->ConditionValue3)
            LOG_ERROR("sql.sql", "RandomDungeon condition has useless data in value3 ({}).", cond->ConditionValue3);
        break;
    case CONDITION_PET_TYPE:
        if (cond->ConditionValue1 >= (1 << MAX_PET_TYPE))
        {
            LOG_ERROR("sql.sql", "CONDITION_PET_TYPE has non-existing pet type {}, skipped.", cond->ConditionValue1);
            return false;
        }
        break;
    case CONDITION_TAXI:
    case CONDITION_IN_WATER:
    case CONDITION_CHARMED:
    default:
        break;
    }
    return true;
}

References ALLIANCE, CLASSMASK_ALL_PLAYABLE, COMP_TYPE_MAX, CONDITION_AC_END, CONDITION_AC_START, CONDITION_ACHIEVEMENT, CONDITION_ACTIVE_EVENT, CONDITION_ALIVE, CONDITION_AREAID, CONDITION_AURA, CONDITION_CHARMED, CONDITION_CLASS, CONDITION_CREATURE_TYPE, CONDITION_DAILY_QUEST_DONE, CONDITION_DIFFICULTY_ID, CONDITION_DISTANCE_TO, CONDITION_DRUNKENSTATE, CONDITION_GENDER, CONDITION_HAS_AURA_TYPE, CONDITION_HP_PCT, CONDITION_HP_VAL, CONDITION_IN_WATER, CONDITION_INSTANCE_INFO, CONDITION_ITEM, CONDITION_ITEM_EQUIPPED, CONDITION_LEVEL, CONDITION_MAPID, CONDITION_NEAR_CREATURE, CONDITION_NEAR_GAMEOBJECT, CONDITION_NONE, CONDITION_OBJECT_ENTRY_GUID, CONDITION_PET_TYPE, CONDITION_PHASEMASK, CONDITION_PLAYER_QUEUED_RANDOM_DUNGEON, CONDITION_QUEST_COMPLETE, CONDITION_QUEST_NONE, CONDITION_QUEST_OBJECTIVE_PROGRESS, CONDITION_QUEST_SATISFY_EXCLUSIVE, CONDITION_QUESTREWARDED, CONDITION_QUESTSTATE, CONDITION_QUESTTAKEN, CONDITION_RACE, CONDITION_REACTION_TO, CONDITION_REALM_ACHIEVEMENT, CONDITION_RELATION_TO, CONDITION_REPUTATION_RANK, CONDITION_SKILL, CONDITION_SPAWNMASK, CONDITION_SPELL, CONDITION_STAND_STATE, CONDITION_TAXI, CONDITION_TC_END, CONDITION_TEAM, CONDITION_TERRAIN_SWAP, CONDITION_TITLE, CONDITION_TYPE_MASK, CONDITION_UNIT_STATE, CONDITION_WORLD_STATE, CONDITION_ZONEID, Condition::ConditionTarget, Condition::ConditionType, Condition::ConditionValue1, Condition::ConditionValue2, Condition::ConditionValue3, CREATURE_TYPE_GAS_CLOUD, creatureData, DRUNKEN_SMASHED, EFFECT_2, Condition::GetMaxAvailableConditionTargets(), HORDE, Player::IsValidGender(), LOG_ERROR, MAX_DIFFICULTY, MAX_PET_TYPE, MAX_QUEST_STATUS, RELATION_MAX, Quest::RequiredNpcOrGo, Quest::RequiredNpcOrGoCount, sAchievementStore, sAreaTableStore, sCharTitlesStore, sFactionStore, sGameEventMgr, sMapStore, sObjectMgr, Condition::SourceEntry, Condition::SourceType, SPAWNMASK_RAID_ALL, SPELL_AURA_NONE, sRaceMgr, sSkillLineStore, sSpellMgr, sWorld, TOTAL_AURAS, TYPEID_CORPSE, TYPEID_GAMEOBJECT, TYPEID_PLAYER, TYPEID_UNIT, TYPEMASK_CORPSE, TYPEMASK_GAMEOBJECT, TYPEMASK_PLAYER, TYPEMASK_UNIT, UNIT_STAND_STATE_SUBMERGED, UNIT_STATE_ALL_STATE_SUPPORTED, and AreaTableEntry::zone.

Referenced by LoadConditions().

IsObjectMeetToConditionList()

bool ConditionMgr::IsObjectMeetToConditionList ( ConditionSourceInfo &  sourceInfo, ConditionList const &  conditions  )

private

Find ElseGroup in ElseGroupStore

If not found, add an entry in the store and set to true (placeholder)

{
    //     groupId, groupCheckPassed
    std::map<uint32, bool> ElseGroupStore;
    for (ConditionList::const_iterator i = conditions.begin(); i != conditions.end(); ++i)
    {
        LOG_DEBUG("condition", "ConditionMgr::IsPlayerMeetToConditionList condType: {} val1: {}", (*i)->ConditionType, (*i)->ConditionValue1);
        if ((*i)->isLoaded())
        {
            std::map<uint32, bool>::const_iterator itr = ElseGroupStore.find((*i)->ElseGroup);
            if (itr == ElseGroupStore.end())
                ElseGroupStore[(*i)->ElseGroup] = true;
            else if (!(*itr).second)
                continue;
 
            if ((*i)->ReferenceId) // handle reference
            {
                ConditionReferenceContainer::const_iterator ref = ConditionReferenceStore.find((*i)->ReferenceId);
                if (ref != ConditionReferenceStore.end())
                {
                    if (!IsObjectMeetToConditionList(sourceInfo, (*ref).second))
                        ElseGroupStore[(*i)->ElseGroup] = false;
                }
                else
                {
                    LOG_DEBUG("condition", "IsPlayerMeetToConditionList: Reference template -{} not found", (*i)->ReferenceId);
                }
            }
            else // handle normal condition
            {
                if (!(*i)->Meets(sourceInfo))
                    ElseGroupStore[(*i)->ElseGroup] = false;
            }
        }
    }
    for (std::map<uint32, bool>::const_iterator i = ElseGroupStore.begin(); i != ElseGroupStore.end(); ++i)
        if (i->second)
            return true;
 
    return false;
}

References ConditionReferenceStore, IsObjectMeetToConditionList(), and LOG_DEBUG.

Referenced by IsObjectMeetToConditionList(), and IsObjectMeetToConditions().

IsObjectMeetToConditions() [1/3]

bool ConditionMgr::IsObjectMeetToConditions	(	ConditionSourceInfo &	sourceInfo,
		ConditionList const &	conditions
	)

{
    if (conditions.empty())
        return true;
 
    LOG_DEBUG("condition", "ConditionMgr::IsObjectMeetToConditions");
    return IsObjectMeetToConditionList(sourceInfo, conditions);
}

References IsObjectMeetToConditionList(), and LOG_DEBUG.

IsObjectMeetToConditions() [2/3]

bool ConditionMgr::IsObjectMeetToConditions	(	WorldObject *	object,
		ConditionList const &	conditions
	)

{
    ConditionSourceInfo srcInfo = ConditionSourceInfo(object);
    return IsObjectMeetToConditions(srcInfo, conditions);
}

References IsObjectMeetToConditions().

Referenced by IsObjectMeetToConditions(), and IsObjectMeetToConditions().

IsObjectMeetToConditions() [3/3]

bool ConditionMgr::IsObjectMeetToConditions	(	WorldObject *	object1,
		WorldObject *	object2,
		ConditionList const &	conditions
	)

{
    ConditionSourceInfo srcInfo = ConditionSourceInfo(object1, object2);
    return IsObjectMeetToConditions(srcInfo, conditions);
}

References IsObjectMeetToConditions().

isSourceTypeValid()

bool ConditionMgr::isSourceTypeValid ( Condition *  cond )

private

{
    if (cond->SourceType == CONDITION_SOURCE_TYPE_NONE || cond->SourceType >= CONDITION_SOURCE_TYPE_MAX)
    {
        LOG_ERROR("sql.sql", "Invalid ConditionSourceType {} in `condition` table, ignoring.", uint32(cond->SourceType));
        return false;
    }
 
    switch (cond->SourceType)
    {
    case CONDITION_SOURCE_TYPE_TERRAIN_SWAP:
    case CONDITION_SOURCE_TYPE_PHASE:
    case CONDITION_SOURCE_TYPE_GRAVEYARD:
    {
        LOG_ERROR("sql.sql", "ConditionSourceType {} in `condition` table is not supported on 3.3.5a, ignoring.", uint32(cond->SourceType));
        return false;
    }
    case CONDITION_SOURCE_TYPE_CREATURE_LOOT_TEMPLATE:
    {
        if (!LootTemplates_Creature.HaveLootFor(cond->SourceGroup))
        {
            LOG_ERROR("sql.sql", "SourceGroup {} in `condition` table, does not exist in `creature_loot_template`, ignoring.", cond->SourceGroup);
            return false;
        }
 
        LootTemplate*       loot       = LootTemplates_Creature.GetLootForConditionFill(cond->SourceGroup);
        ItemTemplate const* pItemProto = sObjectMgr->GetItemTemplate(cond->SourceEntry);
        if (!pItemProto && !loot->isReference(cond->SourceEntry))
        {
            LOG_ERROR("sql.sql", "SourceType {}, SourceEntry {} in `condition` table, does not exist in `item_template`, ignoring.", cond->SourceType, cond->SourceEntry);
            return false;
        }
        break;
    }
    case CONDITION_SOURCE_TYPE_DISENCHANT_LOOT_TEMPLATE:
    {
        if (!LootTemplates_Disenchant.HaveLootFor(cond->SourceGroup))
        {
            LOG_ERROR("sql.sql", "SourceGroup {} in `condition` table, does not exist in `disenchant_loot_template`, ignoring.", cond->SourceGroup);
            return false;
        }
 
        LootTemplate*       loot       = LootTemplates_Disenchant.GetLootForConditionFill(cond->SourceGroup);
        ItemTemplate const* pItemProto = sObjectMgr->GetItemTemplate(cond->SourceEntry);
        if (!pItemProto && !loot->isReference(cond->SourceEntry))
        {
            LOG_ERROR("sql.sql", "SourceType {}, SourceEntry {} in `condition` table, does not exist in `item_template`, ignoring.", cond->SourceType, cond->SourceEntry);
            return false;
        }
        break;
    }
    case CONDITION_SOURCE_TYPE_FISHING_LOOT_TEMPLATE:
    {
        if (!LootTemplates_Fishing.HaveLootFor(cond->SourceGroup))
        {
            LOG_ERROR("sql.sql", "SourceGroup {} in `condition` table, does not exist in `fishing_loot_template`, ignoring.", cond->SourceGroup);
            return false;
        }
 
        LootTemplate*       loot       = LootTemplates_Fishing.GetLootForConditionFill(cond->SourceGroup);
        ItemTemplate const* pItemProto = sObjectMgr->GetItemTemplate(cond->SourceEntry);
        if (!pItemProto && !loot->isReference(cond->SourceEntry))
        {
            LOG_ERROR("sql.sql", "SourceType {}, SourceEntry {} in `condition` table, does not exist in `item_template`, ignoring.", cond->SourceType, cond->SourceEntry);
            return false;
        }
        break;
    }
    case CONDITION_SOURCE_TYPE_GAMEOBJECT_LOOT_TEMPLATE:
    {
        if (!LootTemplates_Gameobject.HaveLootFor(cond->SourceGroup))
        {
            LOG_ERROR("sql.sql", "SourceGroup {} in `condition` table, does not exist in `gameobject_loot_template`, ignoring.", cond->SourceGroup);
            return false;
        }
 
        LootTemplate*       loot       = LootTemplates_Gameobject.GetLootForConditionFill(cond->SourceGroup);
        ItemTemplate const* pItemProto = sObjectMgr->GetItemTemplate(cond->SourceEntry);
        if (!pItemProto && !loot->isReference(cond->SourceEntry))
        {
            LOG_ERROR("sql.sql", "SourceType {}, SourceEntry {} in `condition` table, does not exist in `item_template`, ignoring.", cond->SourceType, cond->SourceEntry);
            return false;
        }
        break;
    }
    case CONDITION_SOURCE_TYPE_ITEM_LOOT_TEMPLATE:
    {
        if (!LootTemplates_Item.HaveLootFor(cond->SourceGroup))
        {
            LOG_ERROR("sql.sql", "SourceGroup {} in `condition` table, does not exist in `item_loot_template`, ignoring.", cond->SourceGroup);
            return false;
        }
 
        LootTemplate*       loot       = LootTemplates_Item.GetLootForConditionFill(cond->SourceGroup);
        ItemTemplate const* pItemProto = sObjectMgr->GetItemTemplate(cond->SourceEntry);
        if (!pItemProto && !loot->isReference(cond->SourceEntry))
        {
            LOG_ERROR("sql.sql", "SourceType {}, SourceEntry {} in `condition` table, does not exist in `item_template`, ignoring.", cond->SourceType, cond->SourceEntry);
            return false;
        }
        break;
    }
    case CONDITION_SOURCE_TYPE_MAIL_LOOT_TEMPLATE:
    {
        if (!LootTemplates_Mail.HaveLootFor(cond->SourceGroup))
        {
            LOG_ERROR("sql.sql", "SourceGroup {} in `condition` table, does not exist in `mail_loot_template`, ignoring.", cond->SourceGroup);
            return false;
        }
 
        LootTemplate*       loot       = LootTemplates_Mail.GetLootForConditionFill(cond->SourceGroup);
        ItemTemplate const* pItemProto = sObjectMgr->GetItemTemplate(cond->SourceEntry);
        if (!pItemProto && !loot->isReference(cond->SourceEntry))
        {
            LOG_ERROR("sql.sql", "SourceType {}, SourceEntry {} in `condition` table, does not exist in `item_template`, ignoring.", cond->SourceType, cond->SourceEntry);
            return false;
        }
        break;
    }
    case CONDITION_SOURCE_TYPE_MILLING_LOOT_TEMPLATE:
    {
        if (!LootTemplates_Milling.HaveLootFor(cond->SourceGroup))
        {
            LOG_ERROR("sql.sql", "SourceGroup {} in `condition` table, does not exist in `milling_loot_template`, ignoring.", cond->SourceGroup);
            return false;
        }
 
        LootTemplate*       loot       = LootTemplates_Milling.GetLootForConditionFill(cond->SourceGroup);
        ItemTemplate const* pItemProto = sObjectMgr->GetItemTemplate(cond->SourceEntry);
        if (!pItemProto && !loot->isReference(cond->SourceEntry))
        {
            LOG_ERROR("sql.sql", "SourceType {}, SourceEntry {} in `condition` table, does not exist in `item_template`, ignoring.", cond->SourceType, cond->SourceEntry);
            return false;
        }
        break;
    }
    case CONDITION_SOURCE_TYPE_PICKPOCKETING_LOOT_TEMPLATE:
    {
        if (!LootTemplates_Pickpocketing.HaveLootFor(cond->SourceGroup))
        {
            LOG_ERROR("sql.sql", "SourceGroup {} in `condition` table, does not exist in `pickpocketing_loot_template`, ignoring.", cond->SourceGroup);
            return false;
        }
 
        LootTemplate*       loot       = LootTemplates_Pickpocketing.GetLootForConditionFill(cond->SourceGroup);
        ItemTemplate const* pItemProto = sObjectMgr->GetItemTemplate(cond->SourceEntry);
        if (!pItemProto && !loot->isReference(cond->SourceEntry))
        {
            LOG_ERROR("sql.sql", "SourceType {}, SourceEntry {} in `condition` table, does not exist in `item_template`, ignoring.", cond->SourceType, cond->SourceEntry);
            return false;
        }
        break;
    }
    case CONDITION_SOURCE_TYPE_PROSPECTING_LOOT_TEMPLATE:
    {
        if (!LootTemplates_Prospecting.HaveLootFor(cond->SourceGroup))
        {
            LOG_ERROR("sql.sql", "SourceGroup {} in `condition` table, does not exist in `prospecting_loot_template`, ignoring.", cond->SourceGroup);
            return false;
        }
 
        LootTemplate*       loot       = LootTemplates_Prospecting.GetLootForConditionFill(cond->SourceGroup);
        ItemTemplate const* pItemProto = sObjectMgr->GetItemTemplate(cond->SourceEntry);
        if (!pItemProto && !loot->isReference(cond->SourceEntry))
        {
            LOG_ERROR("sql.sql", "SourceType {}, SourceEntry {} in `condition` table, does not exist in `item_template`, ignoring.", cond->SourceType, cond->SourceEntry);
            return false;
        }
        break;
    }
    case CONDITION_SOURCE_TYPE_REFERENCE_LOOT_TEMPLATE:
    {
        if (!LootTemplates_Reference.HaveLootFor(cond->SourceGroup))
        {
            LOG_ERROR("sql.sql", "SourceGroup {} in `condition` table, does not exist in `reference_loot_template`, ignoring.", cond->SourceGroup);
            return false;
        }
 
        LootTemplate*       loot       = LootTemplates_Reference.GetLootForConditionFill(cond->SourceGroup);
        ItemTemplate const* pItemProto = sObjectMgr->GetItemTemplate(cond->SourceEntry);
        if (!pItemProto && !loot->isReference(cond->SourceEntry))
        {
            LOG_ERROR("sql.sql", "SourceType {}, SourceEntry {} in `condition` table, does not exist in `item_template`, ignoring.", cond->SourceType, cond->SourceEntry);
            return false;
        }
        break;
    }
    case CONDITION_SOURCE_TYPE_SKINNING_LOOT_TEMPLATE:
    {
        if (!LootTemplates_Skinning.HaveLootFor(cond->SourceGroup))
        {
            LOG_ERROR("sql.sql", "SourceGroup {} in `condition` table, does not exist in `skinning_loot_template`, ignoring.", cond->SourceGroup);
            return false;
        }
 
        LootTemplate*       loot       = LootTemplates_Skinning.GetLootForConditionFill(cond->SourceGroup);
        ItemTemplate const* pItemProto = sObjectMgr->GetItemTemplate(cond->SourceEntry);
        if (!pItemProto && !loot->isReference(cond->SourceEntry))
        {
            LOG_ERROR("sql.sql", "SourceType {}, SourceEntry {} in `condition` table, does not exist in `item_template`, ignoring.", cond->SourceType, cond->SourceEntry);
            return false;
        }
        break;
    }
    case CONDITION_SOURCE_TYPE_SPELL_LOOT_TEMPLATE:
    {
        if (!LootTemplates_Spell.HaveLootFor(cond->SourceGroup))
        {
            LOG_ERROR("sql.sql", "SourceGroup {} in `condition` table, does not exist in `spell_loot_template`, ignoring.", cond->SourceGroup);
            return false;
        }
 
        LootTemplate*       loot       = LootTemplates_Spell.GetLootForConditionFill(cond->SourceGroup);
        ItemTemplate const* pItemProto = sObjectMgr->GetItemTemplate(cond->SourceEntry);
        if (!pItemProto && !loot->isReference(cond->SourceEntry))
        {
            LOG_ERROR("sql.sql", "SourceType {}, SourceEntry {} in `condition` table, does not exist in `item_template`, ignoring.", cond->SourceType, cond->SourceEntry);
            return false;
        }
        break;
    }
    case CONDITION_SOURCE_TYPE_SPELL_IMPLICIT_TARGET:
    {
        SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(cond->SourceEntry);
        if (!spellInfo)
        {
            LOG_ERROR("sql.sql", "SourceEntry {} in `condition` table, does not exist in `spell.dbc`, ignoring.", cond->SourceEntry);
            return false;
        }
 
        if ((cond->SourceGroup > MAX_EFFECT_MASK) || !cond->SourceGroup)
        {
            LOG_ERROR("sql.sql", "SourceEntry {} in `condition` table, has incorrect SourceGroup {} (spell effectMask) set , ignoring.", cond->SourceEntry, cond->SourceGroup);
            return false;
        }
 
        uint32 origGroup = cond->SourceGroup;
 
        for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
        {
            if (!((1 << i) & cond->SourceGroup))
                continue;
 
            switch (spellInfo->Effects[i].TargetA.GetSelectionCategory())
            {
            case TARGET_SELECT_CATEGORY_NEARBY:
            case TARGET_SELECT_CATEGORY_CONE:
            case TARGET_SELECT_CATEGORY_AREA:
            case TARGET_SELECT_CATEGORY_TRAJ:
                continue;
            default:
                break;
            }
 
            switch (spellInfo->Effects[i].TargetB.GetSelectionCategory())
            {
            case TARGET_SELECT_CATEGORY_NEARBY:
            case TARGET_SELECT_CATEGORY_CONE:
            case TARGET_SELECT_CATEGORY_AREA:
            case TARGET_SELECT_CATEGORY_TRAJ:
                continue;
            default:
                break;
            }
 
            switch (spellInfo->Effects[i].Effect)
            {
                case SPELL_EFFECT_PERSISTENT_AREA_AURA:
                case SPELL_EFFECT_APPLY_AREA_AURA_PARTY:
                case SPELL_EFFECT_APPLY_AREA_AURA_RAID:
                case SPELL_EFFECT_APPLY_AREA_AURA_FRIEND:
                case SPELL_EFFECT_APPLY_AREA_AURA_ENEMY:
                case SPELL_EFFECT_APPLY_AREA_AURA_PET:
                case SPELL_EFFECT_APPLY_AREA_AURA_OWNER:
                    continue;
                default:
                    break;
            }
 
            // Xinef: chain targets are treated as area targets! Apply conditions!
            if (spellInfo->Effects[i].ChainTarget > 1)
                continue;
 
            LOG_ERROR("sql.sql", "SourceEntry {} SourceGroup {} in `condition` table - spell {} does not have implicit targets of types: _AREA_, _CONE_, _NEARBY_ for effect {}, SourceGroup needs correction, ignoring.", cond->SourceEntry, origGroup, cond->SourceEntry, uint32(i));
            cond->SourceGroup &= ~(1 << i);
        }
        // all effects were removed, no need to add the condition at all
        if (!cond->SourceGroup)
            return false;
        break;
    }
    case CONDITION_SOURCE_TYPE_CREATURE_TEMPLATE_VEHICLE:
    {
        if (!sObjectMgr->GetCreatureTemplate(cond->SourceEntry))
        {
            LOG_ERROR("sql.sql", "SourceEntry {} in `condition` table, does not exist in `creature_template`, ignoring.", cond->SourceEntry);
            return false;
        }
        break;
    }
    case CONDITION_SOURCE_TYPE_SPELL:
    case CONDITION_SOURCE_TYPE_SPELL_PROC:
    {
        SpellInfo const* spellProto = sSpellMgr->GetSpellInfo(cond->SourceEntry);
        if (!spellProto)
        {
            LOG_ERROR("sql.sql", "SourceEntry {} in `condition` table, does not exist in `spell.dbc`, ignoring.", cond->SourceEntry);
            return false;
        }
        break;
    }
    case CONDITION_SOURCE_TYPE_QUEST_AVAILABLE:
        if (!sObjectMgr->GetQuestTemplate(cond->SourceEntry))
        {
            LOG_ERROR("sql.sql", "CONDITION_SOURCE_TYPE_QUEST_AVAILABLE specifies non-existing quest ({}), skipped", cond->SourceEntry);
            return false;
        }
        break;
    case CONDITION_SOURCE_TYPE_UNUSED_20:
        LOG_ERROR("sql.sql", "CONDITION_SOURCE_TYPE_UNUSED_20 is not in use. SourceEntry = ({}), skipped", cond->SourceEntry);
        break;
    case CONDITION_SOURCE_TYPE_VEHICLE_SPELL:
    case CONDITION_SOURCE_TYPE_SPELL_CLICK_EVENT:
        if (!sObjectMgr->GetCreatureTemplate(cond->SourceGroup))
        {
            LOG_ERROR("sql.sql", "SourceEntry {} in `condition` table, does not exist in `creature_template`, ignoring.", cond->SourceGroup);
            return false;
        }
 
        if (!sSpellMgr->GetSpellInfo(cond->SourceEntry))
        {
            LOG_ERROR("sql.sql", "SourceEntry {} in `condition` table, does not exist in `spell.dbc`, ignoring.", cond->SourceEntry);
            return false;
        }
        break;
    case CONDITION_SOURCE_TYPE_NPC_VENDOR:
    {
        if (!sObjectMgr->GetCreatureTemplate(cond->SourceGroup))
        {
            LOG_ERROR("condition", "SourceEntry {} in `condition` table, does not exist in `creature_template`, ignoring.", cond->SourceGroup);
            return false;
        }
        if (cond->SourceEntry)
        {
            ItemTemplate const* itemTemplate = sObjectMgr->GetItemTemplate(cond->SourceEntry);
            if (!itemTemplate)
            {
                LOG_ERROR("condition", "SourceEntry {} in `condition` table, does not exist in `item_template`, ignoring.", cond->SourceEntry);
                return false;
            }
        }
        break;
    }
    case CONDITION_SOURCE_TYPE_PLAYER_LOOT_TEMPLATE:
    {
        if (!LootTemplates_Player.HaveLootFor(cond->SourceGroup))
        {
            LOG_ERROR("sql.sql", "SourceGroup {} in `condition` table, does not exist in `player_loot_template`, ignoring.", cond->SourceGroup);
            return false;
        }
 
        LootTemplate* loot = LootTemplates_Player.GetLootForConditionFill(cond->SourceGroup);
        ItemTemplate const* pItemProto = sObjectMgr->GetItemTemplate(cond->SourceEntry);
        if (!pItemProto && !loot->isReference(cond->SourceEntry))
        {
            LOG_ERROR("sql.sql", "SourceType {}, SourceEntry {} in `condition` table, does not exist in `item_template`, ignoring.", cond->SourceType, cond->SourceEntry);
            return false;
        }
        break;
    }
    case CONDITION_SOURCE_TYPE_GOSSIP_MENU:
    case CONDITION_SOURCE_TYPE_GOSSIP_MENU_OPTION:
    case CONDITION_SOURCE_TYPE_SMART_EVENT:
    case CONDITION_SOURCE_TYPE_NONE:
    default:
        break;
    }
 
    return true;
}

References CONDITION_SOURCE_TYPE_CREATURE_LOOT_TEMPLATE, CONDITION_SOURCE_TYPE_CREATURE_TEMPLATE_VEHICLE, CONDITION_SOURCE_TYPE_DISENCHANT_LOOT_TEMPLATE, CONDITION_SOURCE_TYPE_FISHING_LOOT_TEMPLATE, CONDITION_SOURCE_TYPE_GAMEOBJECT_LOOT_TEMPLATE, CONDITION_SOURCE_TYPE_GOSSIP_MENU, CONDITION_SOURCE_TYPE_GOSSIP_MENU_OPTION, CONDITION_SOURCE_TYPE_GRAVEYARD, CONDITION_SOURCE_TYPE_ITEM_LOOT_TEMPLATE, CONDITION_SOURCE_TYPE_MAIL_LOOT_TEMPLATE, CONDITION_SOURCE_TYPE_MAX, CONDITION_SOURCE_TYPE_MILLING_LOOT_TEMPLATE, CONDITION_SOURCE_TYPE_NONE, CONDITION_SOURCE_TYPE_NPC_VENDOR, CONDITION_SOURCE_TYPE_PHASE, CONDITION_SOURCE_TYPE_PICKPOCKETING_LOOT_TEMPLATE, CONDITION_SOURCE_TYPE_PLAYER_LOOT_TEMPLATE, CONDITION_SOURCE_TYPE_PROSPECTING_LOOT_TEMPLATE, CONDITION_SOURCE_TYPE_QUEST_AVAILABLE, CONDITION_SOURCE_TYPE_REFERENCE_LOOT_TEMPLATE, CONDITION_SOURCE_TYPE_SKINNING_LOOT_TEMPLATE, CONDITION_SOURCE_TYPE_SMART_EVENT, CONDITION_SOURCE_TYPE_SPELL, CONDITION_SOURCE_TYPE_SPELL_CLICK_EVENT, CONDITION_SOURCE_TYPE_SPELL_IMPLICIT_TARGET, CONDITION_SOURCE_TYPE_SPELL_LOOT_TEMPLATE, CONDITION_SOURCE_TYPE_SPELL_PROC, CONDITION_SOURCE_TYPE_TERRAIN_SWAP, CONDITION_SOURCE_TYPE_UNUSED_20, CONDITION_SOURCE_TYPE_VEHICLE_SPELL, SpellInfo::Effects, LootStore::GetLootForConditionFill(), LootStore::HaveLootFor(), LootTemplate::isReference(), LOG_ERROR, LootTemplates_Creature, LootTemplates_Disenchant, LootTemplates_Fishing, LootTemplates_Gameobject, LootTemplates_Item, LootTemplates_Mail, LootTemplates_Milling, LootTemplates_Pickpocketing, LootTemplates_Player, LootTemplates_Prospecting, LootTemplates_Reference, LootTemplates_Skinning, LootTemplates_Spell, MAX_EFFECT_MASK, MAX_SPELL_EFFECTS, sObjectMgr, Condition::SourceEntry, Condition::SourceGroup, Condition::SourceType, SPELL_EFFECT_APPLY_AREA_AURA_ENEMY, SPELL_EFFECT_APPLY_AREA_AURA_FRIEND, SPELL_EFFECT_APPLY_AREA_AURA_OWNER, SPELL_EFFECT_APPLY_AREA_AURA_PARTY, SPELL_EFFECT_APPLY_AREA_AURA_PET, SPELL_EFFECT_APPLY_AREA_AURA_RAID, SPELL_EFFECT_PERSISTENT_AREA_AURA, sSpellMgr, TARGET_SELECT_CATEGORY_AREA, TARGET_SELECT_CATEGORY_CONE, TARGET_SELECT_CATEGORY_NEARBY, and TARGET_SELECT_CATEGORY_TRAJ.

Referenced by LoadConditions().

LoadConditions()

void ConditionMgr::LoadConditions

(

bool

isReload = false

)

TODO: PAIR_32 ?

{
    uint32 oldMSTime = getMSTime();
 
    Clean();
 
    // must clear all custom handled cases (groupped types) before reload
    if (isReload)
    {
        LOG_INFO("server.loading", "Reseting Loot Conditions...");
        LootTemplates_Creature.ResetConditions();
        LootTemplates_Fishing.ResetConditions();
        LootTemplates_Gameobject.ResetConditions();
        LootTemplates_Item.ResetConditions();
        LootTemplates_Mail.ResetConditions();
        LootTemplates_Milling.ResetConditions();
        LootTemplates_Pickpocketing.ResetConditions();
        LootTemplates_Reference.ResetConditions();
        LootTemplates_Skinning.ResetConditions();
        LootTemplates_Disenchant.ResetConditions();
        LootTemplates_Prospecting.ResetConditions();
        LootTemplates_Spell.ResetConditions();
        LootTemplates_Player.ResetConditions();
 
        LOG_INFO("server.loading", "Reloading `gossip_menu` Table for Conditions!");
        sObjectMgr->LoadGossipMenu();
 
        LOG_INFO("server.loading", "Reloading `gossip_menu_option` Table for Conditions!");
        sObjectMgr->LoadGossipMenuItems();
        sSpellMgr->UnloadSpellInfoImplicitTargetConditionLists();
    }
 
    QueryResult result = WorldDatabase.Query("SELECT SourceTypeOrReferenceId, SourceGroup, SourceEntry, SourceId, ElseGroup, ConditionTypeOrReference, ConditionTarget, "
                                             " ConditionValue1, ConditionValue2, ConditionValue3, NegativeCondition, ErrorType, ErrorTextId, ScriptName FROM conditions");
 
    if (!result)
    {
        LOG_WARN("server.loading", ">> Loaded 0 conditions. DB table `conditions` is empty!");
        return;
    }
 
    uint32 count = 0;
 
    do
    {
        Field* fields = result->Fetch();
 
        Condition* cond                     = new Condition();
        int32      iSourceTypeOrReferenceId = fields[0].Get<int32>();
        cond->SourceGroup                   = fields[1].Get<uint32>();
        cond->SourceEntry                   = fields[2].Get<int32>();
        cond->SourceId                      = fields[3].Get<int32>();
        cond->ElseGroup                     = fields[4].Get<uint32>();
        int32 iConditionTypeOrReference     = fields[5].Get<int32>();
        cond->ConditionTarget               = fields[6].Get<uint8>();
        cond->ConditionValue1               = fields[7].Get<uint32>();
        cond->ConditionValue2               = fields[8].Get<uint32>();
        cond->ConditionValue3               = fields[9].Get<uint32>();
        cond->NegativeCondition             = fields[10].Get<uint8>();
        cond->ErrorType                     = fields[11].Get<uint32>();
        cond->ErrorTextId                   = fields[12].Get<uint32>();
        cond->ScriptId                      = sObjectMgr->GetScriptId(fields[13].Get<std::string>());
 
        if (iConditionTypeOrReference >= 0)
            cond->ConditionType = ConditionTypes(iConditionTypeOrReference);
 
        if (iSourceTypeOrReferenceId >= 0)
            cond->SourceType = ConditionSourceType(iSourceTypeOrReferenceId);
 
        if (iConditionTypeOrReference < 0) // it has a reference
        {
            if (iConditionTypeOrReference == iSourceTypeOrReferenceId) // self referencing, skip
            {
                LOG_ERROR("sql.sql", "Condition reference {} is referencing self, skipped", iSourceTypeOrReferenceId);
                delete cond;
                continue;
            }
            cond->ReferenceId = uint32(std::abs(iConditionTypeOrReference));
 
            const char* rowType = "reference template";
            if (iSourceTypeOrReferenceId >= 0)
                rowType = "reference";
            // check for useless data
            if (cond->ConditionTarget)
                LOG_ERROR("sql.sql", "Condition {} {} has useless data in ConditionTarget ({})!", rowType, iSourceTypeOrReferenceId, cond->ConditionTarget);
            if (cond->ConditionValue1)
                LOG_ERROR("sql.sql", "Condition {} {} has useless data in value1 ({})!", rowType, iSourceTypeOrReferenceId, cond->ConditionValue1);
            if (cond->ConditionValue2)
                LOG_ERROR("sql.sql", "Condition {} {} has useless data in value2 ({})!", rowType, iSourceTypeOrReferenceId, cond->ConditionValue2);
            if (cond->ConditionValue3)
                LOG_ERROR("sql.sql", "Condition {} {} has useless data in value3 ({})!", rowType, iSourceTypeOrReferenceId, cond->ConditionValue3);
            if (cond->NegativeCondition)
                LOG_ERROR("sql.sql", "Condition {} {} has useless data in NegativeCondition ({})!", rowType, iSourceTypeOrReferenceId, cond->NegativeCondition);
            if (cond->SourceGroup && iSourceTypeOrReferenceId < 0)
                LOG_ERROR("sql.sql", "Condition {} {} has useless data in SourceGroup ({})!", rowType, iSourceTypeOrReferenceId, cond->SourceGroup);
            if (cond->SourceEntry && iSourceTypeOrReferenceId < 0)
                LOG_ERROR("sql.sql", "Condition {} {} has useless data in SourceEntry ({})!", rowType, iSourceTypeOrReferenceId, cond->SourceEntry);
        }
        else if (!isConditionTypeValid(cond)) // doesn't have reference, validate ConditionType
        {
            delete cond;
            continue;
        }
 
        if (iSourceTypeOrReferenceId < 0) // it is a reference template
        {
            uint32 uRefId = std::abs(iSourceTypeOrReferenceId);
            if (ConditionReferenceStore.find(uRefId) == ConditionReferenceStore.end()) // make sure we have a list for our conditions, based on reference id
            {
                ConditionList mCondList;
                ConditionReferenceStore[uRefId] = mCondList;
            }
            ConditionReferenceStore[uRefId].push_back(cond); // add to reference storage
            count++;
            continue;
        } // end of reference templates
 
        // if not a reference and SourceType is invalid, skip
        if (iConditionTypeOrReference >= 0 && !isSourceTypeValid(cond))
        {
            delete cond;
            continue;
        }
 
        // Grouping is only allowed for some types (loot templates, gossip menus, gossip items)
        if (cond->SourceGroup && !CanHaveSourceGroupSet(cond->SourceType))
        {
            LOG_ERROR("sql.sql", "Condition type {} has not allowed value of SourceGroup = {}!", uint32(cond->SourceType), cond->SourceGroup);
            delete cond;
            continue;
        }
        if (cond->SourceId && !CanHaveSourceIdSet(cond->SourceType))
        {
            LOG_ERROR("sql.sql", "Condition type {} has not allowed value of SourceId = {}!", uint32(cond->SourceType), cond->SourceId);
            delete cond;
            continue;
        }
 
        if (cond->ErrorType && cond->SourceType != CONDITION_SOURCE_TYPE_SPELL)
        {
            LOG_ERROR("condition", "Condition type {} entry {} can't have ErrorType ({}), set to 0!", uint32(cond->SourceType), cond->SourceEntry, cond->ErrorType);
            cond->ErrorType = 0;
        }
 
        if (cond->ErrorTextId && !cond->ErrorType)
        {
            LOG_ERROR("condition", "Condition type {} entry {} has any ErrorType, ErrorTextId ({}) is set, set to 0!", uint32(cond->SourceType), cond->SourceEntry, cond->ErrorTextId);
            cond->ErrorTextId = 0;
        }
 
        if (cond->SourceGroup || cond->SourceType == CONDITION_SOURCE_TYPE_PLAYER_LOOT_TEMPLATE)
        {
            bool valid = false;
            // handle grouped conditions
            switch (cond->SourceType)
            {
            case CONDITION_SOURCE_TYPE_CREATURE_LOOT_TEMPLATE:
                valid = addToLootTemplate(cond, LootTemplates_Creature.GetLootForConditionFill(cond->SourceGroup));
                break;
            case CONDITION_SOURCE_TYPE_DISENCHANT_LOOT_TEMPLATE:
                valid = addToLootTemplate(cond, LootTemplates_Disenchant.GetLootForConditionFill(cond->SourceGroup));
                break;
            case CONDITION_SOURCE_TYPE_FISHING_LOOT_TEMPLATE:
                valid = addToLootTemplate(cond, LootTemplates_Fishing.GetLootForConditionFill(cond->SourceGroup));
                break;
            case CONDITION_SOURCE_TYPE_GAMEOBJECT_LOOT_TEMPLATE:
                valid = addToLootTemplate(cond, LootTemplates_Gameobject.GetLootForConditionFill(cond->SourceGroup));
                break;
            case CONDITION_SOURCE_TYPE_ITEM_LOOT_TEMPLATE:
                valid = addToLootTemplate(cond, LootTemplates_Item.GetLootForConditionFill(cond->SourceGroup));
                break;
            case CONDITION_SOURCE_TYPE_MAIL_LOOT_TEMPLATE:
                valid = addToLootTemplate(cond, LootTemplates_Mail.GetLootForConditionFill(cond->SourceGroup));
                break;
            case CONDITION_SOURCE_TYPE_MILLING_LOOT_TEMPLATE:
                valid = addToLootTemplate(cond, LootTemplates_Milling.GetLootForConditionFill(cond->SourceGroup));
                break;
            case CONDITION_SOURCE_TYPE_PICKPOCKETING_LOOT_TEMPLATE:
                valid = addToLootTemplate(cond, LootTemplates_Pickpocketing.GetLootForConditionFill(cond->SourceGroup));
                break;
            case CONDITION_SOURCE_TYPE_PROSPECTING_LOOT_TEMPLATE:
                valid = addToLootTemplate(cond, LootTemplates_Prospecting.GetLootForConditionFill(cond->SourceGroup));
                break;
            case CONDITION_SOURCE_TYPE_REFERENCE_LOOT_TEMPLATE:
                valid = addToLootTemplate(cond, LootTemplates_Reference.GetLootForConditionFill(cond->SourceGroup));
                break;
            case CONDITION_SOURCE_TYPE_SKINNING_LOOT_TEMPLATE:
                valid = addToLootTemplate(cond, LootTemplates_Skinning.GetLootForConditionFill(cond->SourceGroup));
                break;
            case CONDITION_SOURCE_TYPE_SPELL_LOOT_TEMPLATE:
                valid = addToLootTemplate(cond, LootTemplates_Spell.GetLootForConditionFill(cond->SourceGroup));
                break;
            case CONDITION_SOURCE_TYPE_GOSSIP_MENU:
                valid = addToGossipMenus(cond);
                break;
            case CONDITION_SOURCE_TYPE_GOSSIP_MENU_OPTION:
                valid = addToGossipMenuItems(cond);
                break;
            case CONDITION_SOURCE_TYPE_SPELL_CLICK_EVENT:
            {
                SpellClickEventConditionStore[cond->SourceGroup][cond->SourceEntry].push_back(cond);
                valid = true;
                ++count;
                continue; // do not add to m_AllocatedMemory to avoid double deleting
            }
            case CONDITION_SOURCE_TYPE_SPELL_IMPLICIT_TARGET:
                valid = addToSpellImplicitTargetConditions(cond);
                break;
            case CONDITION_SOURCE_TYPE_VEHICLE_SPELL:
            {
                VehicleSpellConditionStore[cond->SourceGroup][cond->SourceEntry].push_back(cond);
                valid = true;
                ++count;
                continue; // do not add to m_AllocatedMemory to avoid double deleting
            }
            case CONDITION_SOURCE_TYPE_SMART_EVENT:
            {
                std::pair<int32, uint32> key = std::make_pair(cond->SourceEntry, cond->SourceId);
                SmartEventConditionStore[key][cond->SourceGroup].push_back(cond);
                valid = true;
                ++count;
                continue;
            }
            case CONDITION_SOURCE_TYPE_NPC_VENDOR:
            {
                NpcVendorConditionContainerStore[cond->SourceGroup][cond->SourceEntry].push_back(cond);
                valid = true;
                ++count;
                continue;
            }
            case CONDITION_SOURCE_TYPE_PLAYER_LOOT_TEMPLATE:
            {
                valid = addToLootTemplate(cond, LootTemplates_Player.GetLootForConditionFill(cond->SourceGroup));
                break;
            }
            default:
                break;
            }
 
            if (!valid)
            {
                LOG_ERROR("sql.sql", "Not handled grouped condition, SourceGroup {}", cond->SourceGroup);
                delete cond;
            }
            else
            {
                AllocatedMemoryStore.push_back(cond);
                ++count;
            }
            continue;
        }
 
        // handle not grouped conditions
        // make sure we have a storage list for our SourceType
        if (ConditionStore.find(cond->SourceType) == ConditionStore.end())
        {
            ConditionTypeContainer mTypeMap;
            ConditionStore[cond->SourceType] = mTypeMap; // add new empty list for SourceType
        }
 
        // make sure we have a condition list for our SourceType's entry
        if (ConditionStore[cond->SourceType].find(cond->SourceEntry) == ConditionStore[cond->SourceType].end())
        {
            ConditionList mCondList;
            ConditionStore[cond->SourceType][cond->SourceEntry] = mCondList;
        }
 
        // add new Condition to storage based on Type/Entry
        ConditionStore[cond->SourceType][cond->SourceEntry].push_back(cond);
        ++count;
    } while (result->NextRow());
 
    LOG_INFO("server.loading", ">> Loaded {} conditions in {} ms", count, GetMSTimeDiffToNow(oldMSTime));
    LOG_INFO("server.loading", " ");
}

References addToGossipMenuItems(), addToGossipMenus(), addToLootTemplate(), addToSpellImplicitTargetConditions(), AllocatedMemoryStore, CanHaveSourceGroupSet(), CanHaveSourceIdSet(), Clean(), CONDITION_SOURCE_TYPE_CREATURE_LOOT_TEMPLATE, CONDITION_SOURCE_TYPE_DISENCHANT_LOOT_TEMPLATE, CONDITION_SOURCE_TYPE_FISHING_LOOT_TEMPLATE, CONDITION_SOURCE_TYPE_GAMEOBJECT_LOOT_TEMPLATE, CONDITION_SOURCE_TYPE_GOSSIP_MENU, CONDITION_SOURCE_TYPE_GOSSIP_MENU_OPTION, CONDITION_SOURCE_TYPE_ITEM_LOOT_TEMPLATE, CONDITION_SOURCE_TYPE_MAIL_LOOT_TEMPLATE, CONDITION_SOURCE_TYPE_MILLING_LOOT_TEMPLATE, CONDITION_SOURCE_TYPE_NPC_VENDOR, CONDITION_SOURCE_TYPE_PICKPOCKETING_LOOT_TEMPLATE, CONDITION_SOURCE_TYPE_PLAYER_LOOT_TEMPLATE, CONDITION_SOURCE_TYPE_PROSPECTING_LOOT_TEMPLATE, CONDITION_SOURCE_TYPE_REFERENCE_LOOT_TEMPLATE, CONDITION_SOURCE_TYPE_SKINNING_LOOT_TEMPLATE, CONDITION_SOURCE_TYPE_SMART_EVENT, CONDITION_SOURCE_TYPE_SPELL, CONDITION_SOURCE_TYPE_SPELL_CLICK_EVENT, CONDITION_SOURCE_TYPE_SPELL_IMPLICIT_TARGET, CONDITION_SOURCE_TYPE_SPELL_LOOT_TEMPLATE, CONDITION_SOURCE_TYPE_VEHICLE_SPELL, ConditionReferenceStore, ConditionStore, Condition::ConditionTarget, Condition::ConditionType, Condition::ConditionValue1, Condition::ConditionValue2, Condition::ConditionValue3, Condition::ElseGroup, Condition::ErrorTextId, Condition::ErrorType, Field::Get(), LootStore::GetLootForConditionFill(), getMSTime(), GetMSTimeDiffToNow(), isConditionTypeValid(), isSourceTypeValid(), LOG_ERROR, LOG_INFO, LOG_WARN, LootTemplates_Creature, LootTemplates_Disenchant, LootTemplates_Fishing, LootTemplates_Gameobject, LootTemplates_Item, LootTemplates_Mail, LootTemplates_Milling, LootTemplates_Pickpocketing, LootTemplates_Player, LootTemplates_Prospecting, LootTemplates_Reference, LootTemplates_Skinning, LootTemplates_Spell, Condition::NegativeCondition, NpcVendorConditionContainerStore, Condition::ReferenceId, LootStore::ResetConditions(), Condition::ScriptId, SmartEventConditionStore, sObjectMgr, Condition::SourceEntry, Condition::SourceGroup, Condition::SourceId, Condition::SourceType, SpellClickEventConditionStore, sSpellMgr, VehicleSpellConditionStore, and WorldDatabase.

Member Data Documentation

AllocatedMemoryStore

std::list<Condition*> ConditionMgr::AllocatedMemoryStore

private

Referenced by Clean(), and LoadConditions().

ConditionReferenceStore

ConditionReferenceContainer ConditionMgr::ConditionReferenceStore

private

Referenced by Clean(), GetConditionReferences(), GetSearcherTypeMaskForConditionList(), IsObjectMeetToConditionList(), and LoadConditions().

ConditionStore

ConditionContainer ConditionMgr::ConditionStore

private

Referenced by Clean(), GetConditionsForNotGroupedEntry(), and LoadConditions().

NpcVendorConditionContainerStore

NpcVendorConditionContainer ConditionMgr::NpcVendorConditionContainerStore

private

Referenced by Clean(), GetConditionsForNpcVendorEvent(), and LoadConditions().

SmartEventConditionStore

SmartEventConditionContainer ConditionMgr::SmartEventConditionStore

private

Referenced by Clean(), GetConditionsForSmartEvent(), and LoadConditions().

SpellClickEventConditionStore

CreatureSpellConditionContainer ConditionMgr::SpellClickEventConditionStore

private

Referenced by Clean(), GetConditionsForSpellClickEvent(), and LoadConditions().

VehicleSpellConditionStore

CreatureSpellConditionContainer ConditionMgr::VehicleSpellConditionStore

private

Referenced by Clean(), GetConditionsForVehicleSpell(), and LoadConditions().

---

The documentation for this class was generated from the following files:

• azerothcore-wotlk/src/server/game/Conditions/ConditionMgr.h
• azerothcore-wotlk/src/server/game/Conditions/ConditionMgr.cpp