Condition Struct Reference

#include "ConditionMgr.h"

Public Member Functions
	Condition ()
bool	Meets (ConditionSourceInfo &sourceInfo)
uint32	GetSearcherTypeMaskForCondition ()
bool	isLoaded () const
uint32	GetMaxAvailableConditionTargets ()

Public Attributes
ConditionSourceType	SourceType
uint32	SourceGroup
int32	SourceEntry
uint32	SourceId
uint32	ElseGroup
ConditionTypes	ConditionType
uint32	ConditionValue1
uint32	ConditionValue2
uint32	ConditionValue3
uint32	ErrorType
uint32	ErrorTextId
uint32	ReferenceId
uint32	ScriptId
uint8	ConditionTarget
bool	NegativeCondition

Detailed Description

Constructor & Destructor Documentation

Condition()

Condition::Condition ( )

inline

    {
        SourceType         = CONDITION_SOURCE_TYPE_NONE;
        SourceGroup        = 0;
        SourceEntry        = 0;
        SourceId           = 0;
        ElseGroup          = 0;
        ConditionType      = CONDITION_NONE;
        ConditionTarget    = 0;
        ConditionValue1    = 0;
        ConditionValue2    = 0;
        ConditionValue3    = 0;
        ReferenceId        = 0;
        ErrorType          = 0;
        ErrorTextId        = 0;
        ScriptId           = 0;
        NegativeCondition  = false;
    }

References CONDITION_NONE, CONDITION_SOURCE_TYPE_NONE, ConditionTarget, ConditionType, ConditionValue1, ConditionValue2, ConditionValue3, ElseGroup, ErrorTextId, ErrorType, NegativeCondition, ReferenceId, ScriptId, SourceEntry, SourceGroup, SourceId, and SourceType.

Member Function Documentation

GetMaxAvailableConditionTargets()

uint32 Condition::GetMaxAvailableConditionTargets

(

)

{
    // returns number of targets which are available for given source type
    switch (SourceType)
    {
        case CONDITION_SOURCE_TYPE_SMART_EVENT:
            return 3;
        case CONDITION_SOURCE_TYPE_SPELL:
        case CONDITION_SOURCE_TYPE_SPELL_IMPLICIT_TARGET:
        case CONDITION_SOURCE_TYPE_CREATURE_TEMPLATE_VEHICLE:
        case CONDITION_SOURCE_TYPE_VEHICLE_SPELL:
        case CONDITION_SOURCE_TYPE_SPELL_CLICK_EVENT:
        case CONDITION_SOURCE_TYPE_GOSSIP_MENU:
        case CONDITION_SOURCE_TYPE_GOSSIP_MENU_OPTION:
        case CONDITION_SOURCE_TYPE_NPC_VENDOR:
        case CONDITION_SOURCE_TYPE_SPELL_PROC:
        case CONDITION_SOURCE_TYPE_CREATURE_VISIBILITY:
            return 2;
        default:
            break;
    }
 
    return 1;
}

References CONDITION_SOURCE_TYPE_CREATURE_TEMPLATE_VEHICLE, CONDITION_SOURCE_TYPE_CREATURE_VISIBILITY, CONDITION_SOURCE_TYPE_GOSSIP_MENU, CONDITION_SOURCE_TYPE_GOSSIP_MENU_OPTION, CONDITION_SOURCE_TYPE_NPC_VENDOR, 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_PROC, CONDITION_SOURCE_TYPE_VEHICLE_SPELL, and SourceType.

Referenced by ConditionMgr::isConditionTypeValid().

GetSearcherTypeMaskForCondition()

uint32 Condition::GetSearcherTypeMaskForCondition

(

)

{
    // build mask of types for which condition can return true
    // this is used for speeding up gridsearches
    if (NegativeCondition)
        return (GRID_MAP_TYPE_MASK_ALL);
    uint32 mask = 0;
    switch (ConditionType)
    {
    case CONDITION_NONE:
        mask |= GRID_MAP_TYPE_MASK_ALL;
        break;
    case CONDITION_AURA:
        mask |= GRID_MAP_TYPE_MASK_CREATURE | GRID_MAP_TYPE_MASK_PLAYER;
        break;
    case CONDITION_ITEM:
        mask |= GRID_MAP_TYPE_MASK_PLAYER;
        break;
    case CONDITION_ITEM_EQUIPPED:
        mask |= GRID_MAP_TYPE_MASK_PLAYER;
        break;
    case CONDITION_ZONEID:
        mask |= GRID_MAP_TYPE_MASK_ALL;
        break;
    case CONDITION_REPUTATION_RANK:
        mask |= GRID_MAP_TYPE_MASK_PLAYER;
        break;
    case CONDITION_ACHIEVEMENT:
        mask |= GRID_MAP_TYPE_MASK_PLAYER;
        break;
    case CONDITION_TEAM:
        mask |= GRID_MAP_TYPE_MASK_PLAYER;
        break;
    case CONDITION_CLASS:
        mask |= GRID_MAP_TYPE_MASK_CREATURE | GRID_MAP_TYPE_MASK_PLAYER;
        break;
    case CONDITION_RACE:
        mask |= GRID_MAP_TYPE_MASK_CREATURE | GRID_MAP_TYPE_MASK_PLAYER;
        break;
    case CONDITION_SKILL:
        mask |= GRID_MAP_TYPE_MASK_PLAYER;
        break;
    case CONDITION_QUESTREWARDED:
        mask |= GRID_MAP_TYPE_MASK_PLAYER;
        break;
    case CONDITION_QUESTTAKEN:
        mask |= GRID_MAP_TYPE_MASK_PLAYER;
        break;
    case CONDITION_QUEST_COMPLETE:
        mask |= GRID_MAP_TYPE_MASK_PLAYER;
        break;
    case CONDITION_QUEST_NONE:
        mask |= GRID_MAP_TYPE_MASK_PLAYER;
        break;
    case CONDITION_QUEST_SATISFY_EXCLUSIVE:
        mask |= GRID_MAP_TYPE_MASK_PLAYER;
        break;
    case CONDITION_ACTIVE_EVENT:
        mask |= GRID_MAP_TYPE_MASK_ALL;
        break;
    case CONDITION_INSTANCE_INFO:
        mask |= GRID_MAP_TYPE_MASK_ALL;
        break;
    case CONDITION_MAPID:
        mask |= GRID_MAP_TYPE_MASK_ALL;
        break;
    case CONDITION_AREAID:
        mask |= GRID_MAP_TYPE_MASK_ALL;
        break;
    case CONDITION_SPELL:
        mask |= GRID_MAP_TYPE_MASK_PLAYER;
        break;
    case CONDITION_LEVEL:
        mask |= GRID_MAP_TYPE_MASK_CREATURE | GRID_MAP_TYPE_MASK_PLAYER;
        break;
    case CONDITION_DRUNKENSTATE:
        mask |= GRID_MAP_TYPE_MASK_PLAYER;
        break;
    case CONDITION_NEAR_CREATURE:
        mask |= GRID_MAP_TYPE_MASK_ALL;
        break;
    case CONDITION_NEAR_GAMEOBJECT:
        mask |= GRID_MAP_TYPE_MASK_ALL;
        break;
    case CONDITION_OBJECT_ENTRY_GUID:
        switch (ConditionValue1)
        {
        case TYPEID_UNIT:
            mask |= GRID_MAP_TYPE_MASK_CREATURE;
            break;
        case TYPEID_PLAYER:
            mask |= GRID_MAP_TYPE_MASK_PLAYER;
            break;
        case TYPEID_GAMEOBJECT:
            mask |= GRID_MAP_TYPE_MASK_GAMEOBJECT;
            break;
        case TYPEID_CORPSE:
            mask |= GRID_MAP_TYPE_MASK_CORPSE;
            break;
        default:
            break;
        }
        break;
    case CONDITION_TYPE_MASK:
        if (ConditionValue1 & TYPEMASK_UNIT)
            mask |= GRID_MAP_TYPE_MASK_CREATURE | GRID_MAP_TYPE_MASK_PLAYER;
        if (ConditionValue1 & TYPEMASK_PLAYER)
            mask |= GRID_MAP_TYPE_MASK_PLAYER;
        if (ConditionValue1 & TYPEMASK_GAMEOBJECT)
            mask |= GRID_MAP_TYPE_MASK_GAMEOBJECT;
        if (ConditionValue1 & TYPEMASK_CORPSE)
            mask |= GRID_MAP_TYPE_MASK_CORPSE;
        break;
    case CONDITION_RELATION_TO:
        mask |= GRID_MAP_TYPE_MASK_CREATURE | GRID_MAP_TYPE_MASK_PLAYER;
        break;
    case CONDITION_REACTION_TO:
        mask |= GRID_MAP_TYPE_MASK_CREATURE | GRID_MAP_TYPE_MASK_PLAYER;
        break;
    case CONDITION_DISTANCE_TO:
        mask |= GRID_MAP_TYPE_MASK_ALL;
        break;
    case CONDITION_ALIVE:
        mask |= GRID_MAP_TYPE_MASK_CREATURE | GRID_MAP_TYPE_MASK_PLAYER;
        break;
    case CONDITION_HP_VAL:
        mask |= GRID_MAP_TYPE_MASK_CREATURE | GRID_MAP_TYPE_MASK_PLAYER;
        break;
    case CONDITION_HP_PCT:
        mask |= GRID_MAP_TYPE_MASK_CREATURE | GRID_MAP_TYPE_MASK_PLAYER;
        break;
    case CONDITION_WORLD_STATE:
        mask |= GRID_MAP_TYPE_MASK_ALL;
        break;
    case CONDITION_PHASEMASK:
        mask |= GRID_MAP_TYPE_MASK_ALL;
        break;
    case CONDITION_TITLE:
        mask |= GRID_MAP_TYPE_MASK_PLAYER;
        break;
    case CONDITION_SPAWNMASK:
        mask |= GRID_MAP_TYPE_MASK_ALL;
        break;
    case CONDITION_GENDER:
        mask |= GRID_MAP_TYPE_MASK_PLAYER;
        break;
    case CONDITION_UNIT_STATE:
        mask |= GRID_MAP_TYPE_MASK_CREATURE | GRID_MAP_TYPE_MASK_PLAYER;
        break;
    case CONDITION_CREATURE_TYPE:
        mask |= GRID_MAP_TYPE_MASK_CREATURE;
        break;
    case CONDITION_REALM_ACHIEVEMENT:
        mask |= GRID_MAP_TYPE_MASK_ALL;
        break;
    case CONDITION_IN_WATER:
        mask |= GRID_MAP_TYPE_MASK_CREATURE | GRID_MAP_TYPE_MASK_PLAYER;
        break;
    case CONDITION_QUESTSTATE:
        mask |= GRID_MAP_TYPE_MASK_PLAYER;
        break;
    case CONDITION_DAILY_QUEST_DONE:
        mask |= GRID_MAP_TYPE_MASK_PLAYER;
        break;
    case CONDITION_QUEST_OBJECTIVE_PROGRESS:
        mask |= GRID_MAP_TYPE_MASK_PLAYER;
        break;
    case CONDITION_HAS_AURA_TYPE:
        mask |= GRID_MAP_TYPE_MASK_CREATURE | GRID_MAP_TYPE_MASK_PLAYER;
        break;
    case CONDITION_STAND_STATE:
        mask |= GRID_MAP_TYPE_MASK_CREATURE | GRID_MAP_TYPE_MASK_PLAYER;
        break;
    case CONDITION_DIFFICULTY_ID:
        mask |= GRID_MAP_TYPE_MASK_ALL;
        break;
    case CONDITION_PET_TYPE:
        mask |= GRID_MAP_TYPE_MASK_PLAYER;
        break;
    case CONDITION_TAXI:
        mask |= GRID_MAP_TYPE_MASK_PLAYER;
        break;
    case CONDITION_CHARMED:
        mask |= GRID_MAP_TYPE_MASK_CREATURE | GRID_MAP_TYPE_MASK_PLAYER;
        break;
    case CONDITION_PLAYER_QUEUED_RANDOM_DUNGEON:
        mask |= GRID_MAP_TYPE_MASK_PLAYER;
        break;
    case CONDITION_WORLD_SCRIPT:
        mask |= GRID_MAP_TYPE_MASK_ALL;
        break;
    case CONDITION_AI_DATA:
        mask |= GRID_MAP_TYPE_MASK_CREATURE | GRID_MAP_TYPE_MASK_GAMEOBJECT;
        break;
    default:
        ASSERT(false && "Condition::GetSearcherTypeMaskForCondition - missing condition handling!");
        break;
    }
    return mask;
}

References ASSERT, CONDITION_ACHIEVEMENT, CONDITION_ACTIVE_EVENT, CONDITION_AI_DATA, 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_TEAM, CONDITION_TITLE, CONDITION_TYPE_MASK, CONDITION_UNIT_STATE, CONDITION_WORLD_SCRIPT, CONDITION_WORLD_STATE, CONDITION_ZONEID, ConditionType, ConditionValue1, GRID_MAP_TYPE_MASK_ALL, GRID_MAP_TYPE_MASK_CORPSE, GRID_MAP_TYPE_MASK_CREATURE, GRID_MAP_TYPE_MASK_GAMEOBJECT, GRID_MAP_TYPE_MASK_PLAYER, NegativeCondition, TYPEID_CORPSE, TYPEID_GAMEOBJECT, TYPEID_PLAYER, TYPEID_UNIT, TYPEMASK_CORPSE, TYPEMASK_GAMEOBJECT, TYPEMASK_PLAYER, and TYPEMASK_UNIT.

isLoaded()

bool Condition::isLoaded ( ) const

inline

{ return ConditionType > CONDITION_NONE || ReferenceId; }

References CONDITION_NONE, ConditionType, and ReferenceId.

Referenced by LootTemplate::addConditionItem().

Meets()

bool Condition::Meets

(

ConditionSourceInfo &

sourceInfo

)

{
    // ASSERT(ConditionTarget < MAX_CONDITION_TARGETS);
    if (ConditionTarget >= MAX_CONDITION_TARGETS)
    {
        LOG_ERROR("condition", "ConditionTarget {} for for condition (Entry: {} Type: {} Group: {}) is greater or equal than MAX_CONDITION_TARGETS", ConditionTarget, SourceEntry, SourceType, SourceGroup);
        return false;
    }
 
    WorldObject* object = sourceInfo.mConditionTargets[ConditionTarget];
    // object not present, return false
    if (!object)
    {
        LOG_DEBUG("condition", "Condition object not found for condition (Entry: {} Type: {} Group: {})", SourceEntry, SourceType, SourceGroup);
        return false;
    }
    bool condMeets = false;
    switch (ConditionType)
    {
    case CONDITION_NONE:
        condMeets = true; // empty condition, always met
        break;
    case CONDITION_AURA:
    {
        if (Unit* unit = object->ToUnit())
            condMeets = unit->HasAuraEffect(ConditionValue1, ConditionValue2);
        break;
    }
    case CONDITION_ITEM:
    {
        if (Unit* unit = object->ToUnit())
        {
            if (Player* player = unit->GetCharmerOrOwnerPlayerOrPlayerItself())
            {
                // don't allow 0 items (it's checked during table load)
                ASSERT(ConditionValue2);
                bool checkBank = ConditionValue3;
                condMeets = player->HasItemCount(ConditionValue1, ConditionValue2, checkBank);
            }
        }
        break;
    }
    case CONDITION_ITEM_EQUIPPED:
    {
        if (Unit* unit = object->ToUnit())
        {
            if (Player* player = unit->GetCharmerOrOwnerPlayerOrPlayerItself())
            {
                condMeets = player->HasItemOrGemWithIdEquipped(ConditionValue1, 1);
            }
        }
        break;
    }
    case CONDITION_ZONEID:
        condMeets = object->GetZoneId() == ConditionValue1;
        break;
    case CONDITION_REPUTATION_RANK:
    {
        if (Unit* unit = object->ToUnit())
        {
            if (Player* player = unit->GetCharmerOrOwnerPlayerOrPlayerItself())
            {
                if (FactionEntry const* faction = sFactionStore.LookupEntry(ConditionValue1))
                {
                    condMeets = (ConditionValue2 & (1 << player->GetReputationMgr().GetRank(faction)));
                }
            }
        }
        break;
    }
    case CONDITION_ACHIEVEMENT:
    {
        if (Unit* unit = object->ToUnit())
        {
            if (Player* player = unit->GetCharmerOrOwnerPlayerOrPlayerItself())
            {
                condMeets = player->HasAchieved(ConditionValue1);
            }
        }
        break;
    }
    case CONDITION_TEAM:
    {
        if (Unit* unit = object->ToUnit())
        {
            if (Player* player = unit->GetCharmerOrOwnerPlayerOrPlayerItself())
            {
                // Xinef: DB Data compatibility...
                uint32 teamOld = player->GetTeamId() == TEAM_ALLIANCE ? ALLIANCE : HORDE;
                condMeets = teamOld == ConditionValue1;
            }
        }
        break;
    }
    case CONDITION_CLASS:
    {
        if (Unit* unit = object->ToUnit())
            condMeets = unit->getClassMask() & ConditionValue1;
        break;
    }
    case CONDITION_RACE:
    {
        if (Unit* unit = object->ToUnit())
            condMeets = unit->getRaceMask() & ConditionValue1;
        break;
    }
    case CONDITION_GENDER:
    {
        if (Unit* unit = object->ToUnit())
        {
            if (Player* player = unit->GetCharmerOrOwnerPlayerOrPlayerItself())
            {
                condMeets = player->getGender() == ConditionValue1;
            }
        }
        break;
    }
    case CONDITION_SKILL:
    {
        if (Unit* unit = object->ToUnit())
        {
            if (Player* player = unit->GetCharmerOrOwnerPlayerOrPlayerItself())
            {
                condMeets = player->HasSkill(ConditionValue1) && player->GetBaseSkillValue(ConditionValue1) >= ConditionValue2;
            }
        }
        break;
    }
    case CONDITION_QUESTREWARDED:
    {
        if (Unit* unit = object->ToUnit())
        {
            if (Player* player = unit->GetCharmerOrOwnerPlayerOrPlayerItself())
            {
                condMeets = player->GetQuestRewardStatus(ConditionValue1);
            }
        }
        break;
    }
    case CONDITION_QUESTTAKEN:
    {
        if (Unit* unit = object->ToUnit())
        {
            if (Player* player = unit->GetCharmerOrOwnerPlayerOrPlayerItself())
            {
                QuestStatus status = player->GetQuestStatus(ConditionValue1);
                condMeets = (status == QUEST_STATUS_INCOMPLETE);
            }
        }
        break;
    }
    case CONDITION_QUEST_COMPLETE:
    {
        if (Unit* unit = object->ToUnit())
        {
            if (Player* player = unit->GetCharmerOrOwnerPlayerOrPlayerItself())
            {
                QuestStatus status = player->GetQuestStatus(ConditionValue1);
                condMeets = (status == QUEST_STATUS_COMPLETE && !player->GetQuestRewardStatus(ConditionValue1));
            }
        }
        break;
    }
    case CONDITION_QUEST_NONE:
    {
        if (Unit* unit = object->ToUnit())
        {
            if (Player* player = unit->GetCharmerOrOwnerPlayerOrPlayerItself())
            {
                QuestStatus status = player->GetQuestStatus(ConditionValue1);
                condMeets = (status == QUEST_STATUS_NONE);
            }
        }
        break;
    }
    case CONDITION_QUEST_SATISFY_EXCLUSIVE:
    {
        if (Unit* unit = object->ToUnit())
        {
            if (Player* player = unit->GetCharmerOrOwnerPlayerOrPlayerItself())
            {
                // Xinef: cannot be null, checked at loading
                const Quest* quest = sObjectMgr->GetQuestTemplate(ConditionValue1);
                condMeets = !player->IsQuestRewarded(ConditionValue1) && player->SatisfyQuestExclusiveGroup(quest, false);
            }
        }
        break;
    }
    case CONDITION_ACTIVE_EVENT:
        condMeets = sGameEventMgr->IsActiveEvent(ConditionValue1);
        break;
    case CONDITION_INSTANCE_INFO:
    {
        Map* map = object->GetMap();
        if (map->IsDungeon())
        {
            if (InstanceScript const* instance = map->ToInstanceMap()->GetInstanceScript())
            {
                switch (ConditionValue3)
                {
                    case INSTANCE_INFO_DATA:
                        condMeets = instance->GetData(ConditionValue1) == ConditionValue2;
                        break;
                    case INSTANCE_INFO_GUID_DATA:
                        condMeets = instance->GetGuidData(ConditionValue1) == ObjectGuid(uint64(ConditionValue2));
                        break;
                    case INSTANCE_INFO_BOSS_STATE:
                        condMeets = instance->GetBossState(ConditionValue1) == EncounterState(ConditionValue2);
                        break;
                    case INSTANCE_INFO_DATA64:
                        condMeets = instance->GetData64(ConditionValue1) == ConditionValue2;
                        break;
                }
            }
        }
        break;
    }
    case CONDITION_MAPID:
        condMeets = object->GetMapId() == ConditionValue1;
        break;
    case CONDITION_AREAID:
        condMeets = object->GetAreaId() == ConditionValue1;
        break;
    case CONDITION_SPELL:
    {
        if (Unit* unit = object->ToUnit())
        {
            if (Player* player = unit->GetCharmerOrOwnerPlayerOrPlayerItself())
            {
                condMeets = player->HasSpell(ConditionValue1);
            }
        }
        break;
    }
    case CONDITION_LEVEL:
    {
        if (Unit* unit = object->ToUnit())
            condMeets = CompareValues(static_cast<ComparisionType>(ConditionValue2), static_cast<uint32>(unit->GetLevel()), ConditionValue1);
        break;
    }
    case CONDITION_DRUNKENSTATE:
    {
        if (Unit* unit = object->ToUnit())
        {
            if (Player* player = unit->GetCharmerOrOwnerPlayerOrPlayerItself())
            {
                condMeets = (uint32)Player::GetDrunkenstateByValue(player->GetDrunkValue()) >= ConditionValue1;
            }
        }
        break;
    }
    case CONDITION_NEAR_CREATURE:
    {
        condMeets = static_cast<bool>(GetClosestCreatureWithEntry(object, ConditionValue1, static_cast<float>(ConditionValue2), !ConditionValue3));
        break;
    }
    case CONDITION_NEAR_GAMEOBJECT:
    {
        if (!ConditionValue3)
        {
            condMeets = static_cast<bool>(GetClosestGameObjectWithEntry(object, ConditionValue1, static_cast<float>(ConditionValue2)));
            break;
        }
        else
        {
            if (GameObject* go = GetClosestGameObjectWithEntry(object, ConditionValue1, static_cast<float>(ConditionValue2)))
            {
                if ((go->GetGoState() == GO_STATE_READY && ConditionValue3 == 1) || (go->GetGoState() != GO_STATE_READY && ConditionValue3 == 2))
                    condMeets = true;
                else
                    condMeets = false;
            }
            break;
        }
    }
    case CONDITION_OBJECT_ENTRY_GUID:
    {
        if (ConditionValue3 == 1 && object->ToUnit()) // pussywizard: if == 1, ignore not attackable/selectable targets
            if (object->ToUnit()->HasUnitFlag(UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_NOT_SELECTABLE))
                break;
 
        if (uint32(object->GetTypeId()) == ConditionValue1)
        {
            condMeets = !ConditionValue2 || (object->GetEntry() == ConditionValue2);
 
            if (ConditionValue3 > 1)
            {
                switch (object->GetTypeId())
                {
                    case TYPEID_UNIT:
                        condMeets &= object->ToCreature()->GetSpawnId() == ConditionValue3;
                        break;
                    case TYPEID_GAMEOBJECT:
                        condMeets &= object->ToGameObject()->GetSpawnId() == ConditionValue3;
                        break;
                    default:
                        break;
                }
            }
        }
        break;
    }
    case CONDITION_TYPE_MASK:
    {
        condMeets = object->isType(ConditionValue1);
        break;
    }
    case CONDITION_RELATION_TO:
    {
        if (WorldObject* toObject = sourceInfo.mConditionTargets[ConditionValue1])
        {
            Unit* toUnit = toObject->ToUnit();
            Unit* unit   = object->ToUnit();
            if (toUnit && unit)
            {
                switch (ConditionValue2)
                {
                    case RELATION_SELF:
                        condMeets = unit == toUnit;
                        break;
                    case RELATION_IN_PARTY:
                        condMeets = unit->IsInPartyWith(toUnit);
                        break;
                    case RELATION_IN_RAID_OR_PARTY:
                        condMeets = unit->IsInRaidWith(toUnit);
                        break;
                    case RELATION_OWNED_BY:
                        condMeets = unit->GetOwnerGUID() == toUnit->GetGUID();
                        break;
                    case RELATION_PASSENGER_OF:
                        condMeets = unit->IsOnVehicle(toUnit);
                        break;
                    case RELATION_CREATED_BY:
                        condMeets = unit->GetCreatorGUID() == toUnit->GetGUID();
                        break;
                }
            }
        }
        break;
    }
    case CONDITION_REACTION_TO:
    {
        if (WorldObject* toObject = sourceInfo.mConditionTargets[ConditionValue1])
        {
            Unit* toUnit = toObject->ToUnit();
            Unit* unit   = object->ToUnit();
            if (toUnit && unit)
                condMeets = (1 << unit->GetReactionTo(toUnit)) & ConditionValue2;
        }
        break;
    }
    case CONDITION_DISTANCE_TO:
    {
        if (WorldObject* toObject = sourceInfo.mConditionTargets[ConditionValue1])
            condMeets = CompareValues(static_cast<ComparisionType>(ConditionValue3), object->GetDistance(toObject), static_cast<float>(ConditionValue2));
        break;
    }
    case CONDITION_ALIVE:
    {
        if (Unit* unit = object->ToUnit())
            condMeets = unit->IsAlive();
        break;
    }
    case CONDITION_HP_VAL:
    {
        if (Unit* unit = object->ToUnit())
            condMeets = CompareValues(static_cast<ComparisionType>(ConditionValue2), unit->GetHealth(), static_cast<uint32>(ConditionValue1));
        break;
    }
    case CONDITION_HP_PCT:
    {
        if (Unit* unit = object->ToUnit())
            condMeets = CompareValues(static_cast<ComparisionType>(ConditionValue2), unit->GetHealthPct(), static_cast<float>(ConditionValue1));
        break;
    }
    case CONDITION_WORLD_STATE:
    {
        condMeets = ConditionValue2 == sWorldState->getWorldState(ConditionValue1);
        break;
    }
    case CONDITION_PHASEMASK:
    {
        condMeets = object->GetPhaseMask() & ConditionValue1;
        break;
    }
    case CONDITION_TITLE:
    {
        if (Unit* unit = object->ToUnit())
        {
            if (Player* player = unit->GetCharmerOrOwnerPlayerOrPlayerItself())
            {
                condMeets = player->HasTitle(ConditionValue1);
            }
        }
        break;
    }
    case CONDITION_SPAWNMASK:
    {
        condMeets = ((1 << object->GetMap()->GetSpawnMode()) & ConditionValue1);
        break;
    }
    case CONDITION_UNIT_STATE:
    {
        if (Unit* unit = object->ToUnit())
            condMeets = unit->HasUnitState(ConditionValue1);
        break;
    }
    case CONDITION_CREATURE_TYPE:
    {
        if (Creature* creature = object->ToCreature())
            condMeets = creature->GetCreatureTemplate()->type == ConditionValue1;
        break;
    }
    case CONDITION_REALM_ACHIEVEMENT:
    {
        AchievementEntry const* achievement = sAchievementStore.LookupEntry(ConditionValue1);
        if (achievement && sAchievementMgr->IsRealmCompleted(achievement))
            condMeets = true;
        break;
    }
    case CONDITION_IN_WATER:
    {
        if (Unit* unit = object->ToUnit())
            condMeets = unit->IsInWater();
        break;
    }
    case CONDITION_QUESTSTATE:
    {
        if (Unit* unit = object->ToUnit())
        {
            if (Player* player = unit->GetCharmerOrOwnerPlayerOrPlayerItself())
            {
                uint32 queststateConditionValue1 = player->GetQuestStatus(ConditionValue1);
                if (((ConditionValue2 & (1 << QUEST_STATUS_NONE)) && (queststateConditionValue1 == QUEST_STATUS_NONE)) ||
                    ((ConditionValue2 & (1 << QUEST_STATUS_COMPLETE)) && (queststateConditionValue1 == QUEST_STATUS_COMPLETE)) ||
                    ((ConditionValue2 & (1 << QUEST_STATUS_INCOMPLETE)) && (queststateConditionValue1 == QUEST_STATUS_INCOMPLETE)) ||
                    ((ConditionValue2 & (1 << QUEST_STATUS_FAILED)) && (queststateConditionValue1 == QUEST_STATUS_FAILED)) ||
                    ((ConditionValue2 & (1 << QUEST_STATUS_REWARDED)) && player->GetQuestRewardStatus(ConditionValue1)))
                {
                    condMeets = true;
                }
            }
        }
        break;
    }
    case CONDITION_DAILY_QUEST_DONE:
    {
        if (Unit* unit = object->ToUnit())
        {
            if (Player* player = unit->GetCharmerOrOwnerPlayerOrPlayerItself())
            {
                condMeets = player->IsDailyQuestDone(ConditionValue1);
            }
        }
        break;
    }
    case CONDITION_QUEST_OBJECTIVE_PROGRESS:
    {
        if (Unit* unit = object->ToUnit())
        {
            if (Player* player = unit->GetCharmerOrOwnerPlayerOrPlayerItself())
            {
                Quest const* quest = ASSERT_NOTNULL(sObjectMgr->GetQuestTemplate(ConditionValue1));
                uint16 log_slot = player->FindQuestSlot(quest->GetQuestId());
                if (log_slot >= MAX_QUEST_LOG_SIZE)
                {
                    break;
                }
 
                if (player->GetQuestSlotCounter(log_slot, ConditionValue2) == ConditionValue3)
                {
                    condMeets = true;
                }
            }
        }
        break;
    }
    case CONDITION_HAS_AURA_TYPE:
    {
        if (Unit* unit = object->ToUnit())
            condMeets = unit->HasAuraType(AuraType(ConditionValue1));
        break;
    }
    case CONDITION_STAND_STATE:
    {
        if (Unit* unit = object->ToUnit())
        {
            if (ConditionValue1 == 0)
            {
                condMeets = (unit->getStandState() == ConditionValue2);
            }
            else if (ConditionValue2 == 0)
            {
                condMeets = unit->IsStandState();
            }
            else if (ConditionValue2 == 1)
            {
                condMeets = unit->IsSitState();
            }
        }
 
        break;
    }
    case CONDITION_DIFFICULTY_ID:
    {
        condMeets = object->GetMap()->GetDifficulty() == ConditionValue1;
        break;
    }
    case CONDITION_PLAYER_QUEUED_RANDOM_DUNGEON:
    {
        if (Unit* unit = object->ToUnit())
        {
            if (Player* player = unit->ToPlayer())
            {
                if (sLFGMgr->IsPlayerQueuedForRandomDungeon(player->GetGUID()))
                {
                    if (!ConditionValue1)
                        condMeets = true;
                    else if (Map* map = player->GetMap())
                        condMeets = map->GetDifficulty() == Difficulty(ConditionValue2);
                }
            }
        }
        break;
    }
    case CONDITION_PET_TYPE:
    {
        if (Unit* unit = object->ToUnit())
        {
            if (Player* player = unit->GetCharmerOrOwnerPlayerOrPlayerItself())
            {
                if (Pet* pet = player->GetPet())
                {
                    condMeets = (((1 << pet->getPetType()) & ConditionValue1) != 0);
                }
            }
        }
        break;
    }
    case CONDITION_TAXI:
    {
        if (Unit* unit = object->ToUnit())
        {
            if (Player* player = unit->GetCharmerOrOwnerPlayerOrPlayerItself())
            {
                condMeets = player->IsInFlight();
            }
        }
        break;
    }
    case CONDITION_CHARMED:
    {
        if (Unit* unit = object->ToUnit())
            condMeets = unit->IsCharmed();
        break;
    }
    case CONDITION_WORLD_SCRIPT:
    {
        condMeets = sWorldState->IsConditionFulfilled(ConditionValue1, ConditionValue2);
        break;
    }
    case CONDITION_AI_DATA:
    {
        if (Creature* creature = object->ToCreature())
            condMeets = creature->AI() && creature->AI()->GetData(ConditionValue1) == ConditionValue2;
        else if (GameObject* go = object->ToGameObject())
            condMeets = go->AI() && go->AI()->GetData(ConditionValue1) == ConditionValue2;
        break;
    }
    default:
        condMeets = false;
        break;
    }
 
    if (NegativeCondition)
        condMeets = !condMeets;
 
    if (!condMeets)
        sourceInfo.mLastFailedCondition = this;
 
    // bool script = sScriptMgr->OnConditionCheck(this, sourceInfo); // Returns true by default. // pussywizard: optimization
    return condMeets; // && script;
}

References ALLIANCE, ASSERT, ASSERT_NOTNULL, CompareValues(), CONDITION_ACHIEVEMENT, CONDITION_ACTIVE_EVENT, CONDITION_AI_DATA, 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_TEAM, CONDITION_TITLE, CONDITION_TYPE_MASK, CONDITION_UNIT_STATE, CONDITION_WORLD_SCRIPT, CONDITION_WORLD_STATE, CONDITION_ZONEID, ConditionTarget, ConditionType, ConditionValue1, ConditionValue2, ConditionValue3, Unit::GetCharmerOrOwnerPlayerOrPlayerItself(), GetClosestCreatureWithEntry(), GetClosestGameObjectWithEntry(), Unit::GetCreatorGUID(), WorldObject::GetDistance(), Player::GetDrunkenstateByValue(), Object::GetGUID(), InstanceMap::GetInstanceScript(), Unit::GetOwnerGUID(), Quest::GetQuestId(), Unit::GetReactionTo(), Object::GetTypeId(), GO_STATE_READY, Unit::HasUnitFlag(), HORDE, INSTANCE_INFO_BOSS_STATE, INSTANCE_INFO_DATA, INSTANCE_INFO_DATA64, INSTANCE_INFO_GUID_DATA, Map::IsDungeon(), Unit::IsInPartyWith(), Unit::IsInRaidWith(), Unit::IsOnVehicle(), LOG_DEBUG, LOG_ERROR, MAX_CONDITION_TARGETS, MAX_QUEST_LOG_SIZE, ConditionSourceInfo::mConditionTargets, ConditionSourceInfo::mLastFailedCondition, NegativeCondition, QUEST_STATUS_COMPLETE, QUEST_STATUS_FAILED, QUEST_STATUS_INCOMPLETE, QUEST_STATUS_NONE, QUEST_STATUS_REWARDED, RELATION_CREATED_BY, RELATION_IN_PARTY, RELATION_IN_RAID_OR_PARTY, RELATION_OWNED_BY, RELATION_PASSENGER_OF, RELATION_SELF, sAchievementMgr, sAchievementStore, sFactionStore, sGameEventMgr, sLFGMgr, sObjectMgr, SourceEntry, SourceGroup, SourceType, sWorldState, TEAM_ALLIANCE, Object::ToCreature(), Object::ToGameObject(), Map::ToInstanceMap(), Object::ToPlayer(), Object::ToUnit(), TYPEID_GAMEOBJECT, TYPEID_UNIT, UNIT_FLAG_NON_ATTACKABLE, and UNIT_FLAG_NOT_SELECTABLE.

Member Data Documentation

ConditionTarget

uint8 Condition::ConditionTarget

Referenced by Spell::CheckCast(), Condition(), ConditionMgr::isConditionTypeValid(), ConditionMgr::LoadConditions(), and Meets().

ConditionType

ConditionTypes Condition::ConditionType

Referenced by Condition(), GetSearcherTypeMaskForCondition(), ConditionMgr::isConditionTypeValid(), isLoaded(), ConditionMgr::LoadConditions(), and Meets().

ConditionValue1

uint32 Condition::ConditionValue1

Referenced by Condition(), GetSearcherTypeMaskForCondition(), ConditionMgr::isConditionTypeValid(), ConditionMgr::LoadConditions(), and Meets().

ConditionValue2

uint32 Condition::ConditionValue2

Referenced by Condition(), ConditionMgr::isConditionTypeValid(), ConditionMgr::LoadConditions(), and Meets().

ConditionValue3

uint32 Condition::ConditionValue3

Referenced by Condition(), ConditionMgr::isConditionTypeValid(), ConditionMgr::LoadConditions(), and Meets().

ElseGroup

uint32 Condition::ElseGroup

Referenced by Condition(), and ConditionMgr::LoadConditions().

ErrorTextId

uint32 Condition::ErrorTextId

Referenced by Spell::CheckCast(), Condition(), and ConditionMgr::LoadConditions().

ErrorType

uint32 Condition::ErrorType

Referenced by Spell::CheckCast(), Condition(), and ConditionMgr::LoadConditions().

NegativeCondition

bool Condition::NegativeCondition

Referenced by Condition(), GetSearcherTypeMaskForCondition(), ConditionMgr::LoadConditions(), and Meets().

ReferenceId

uint32 Condition::ReferenceId

Referenced by Condition(), isLoaded(), and ConditionMgr::LoadConditions().

ScriptId

uint32 Condition::ScriptId

Referenced by Condition(), ConditionMgr::LoadConditions(), and ScriptMgr::OnConditionCheck().

SourceEntry

int32 Condition::SourceEntry

Referenced by LootTemplate::addConditionItem(), ConditionMgr::addToGossipMenuItems(), ConditionMgr::addToGossipMenus(), ConditionMgr::addToLootTemplate(), ConditionMgr::addToSpellImplicitTargetConditions(), Condition(), ConditionMgr::isConditionTypeValid(), ConditionMgr::isSourceTypeValid(), ConditionMgr::LoadConditions(), and Meets().

SourceGroup

uint32 Condition::SourceGroup

Referenced by ConditionMgr::addToGossipMenuItems(), ConditionMgr::addToGossipMenus(), ConditionMgr::addToLootTemplate(), ConditionMgr::addToSpellImplicitTargetConditions(), Condition(), ConditionMgr::isSourceTypeValid(), ConditionMgr::LoadConditions(), and Meets().

SourceId

uint32 Condition::SourceId

Referenced by Condition(), and ConditionMgr::LoadConditions().

SourceType

ConditionSourceType Condition::SourceType

Referenced by Condition(), GetMaxAvailableConditionTargets(), ConditionMgr::isConditionTypeValid(), ConditionMgr::isSourceTypeValid(), ConditionMgr::LoadConditions(), and Meets().

---

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

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