Condition Struct Reference

#include <ConditionMgr.h>

Public Member Functions
	Condition ()
bool	Meets (ConditionSourceInfo &sourceInfo) const
uint32	GetSearcherTypeMaskForCondition () const
bool	isLoaded () const
uint32	GetMaxAvailableConditionTargets () const
std::string	ToString (bool ext=false) const

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

Constructor & Destructor Documentation

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

Member Function Documentation

uint32 Condition::GetMaxAvailableConditionTargets

(

)

const

{
 // returns number of targets which are available for given source type
 switch (SourceType)
 {
 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_SMART_EVENT:
 case CONDITION_SOURCE_TYPE_NPC_VENDOR:
 case CONDITION_SOURCE_TYPE_SPELL_PROC:
 return 2;
 default:
 return 1;
 }
}

Here is the caller graph for this function:

uint32 Condition::GetSearcherTypeMaskForCondition

(

)

const

{
 // 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_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;
 case TYPEID_AREATRIGGER:
 mask |= GRID_MAP_TYPE_MASK_AREATRIGGER;
 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;
 if (ConditionValue1 & TYPEMASK_AREATRIGGER)
 mask |= GRID_MAP_TYPE_MASK_AREATRIGGER;
 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_PHASEID:
 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_TERRAIN_SWAP:
 mask |= GRID_MAP_TYPE_MASK_ALL;
 break;
 default:
 ASSERT(false && "Condition::GetSearcherTypeMaskForCondition - missing condition handling!");
 break;
 }
 return mask;
}

bool Condition::isLoaded ( ) const

inline

{ return ConditionType > CONDITION_NONE || ReferenceId; }

Here is the caller graph for this function:

bool Condition::Meets

(

ConditionSourceInfo &

sourceInfo

)

const

{
 ASSERT(ConditionTarget < MAX_CONDITION_TARGETS);
 WorldObject* object = sourceInfo.mConditionTargets[ConditionTarget];
 // object not present, return false
 if (!object)
 {
 TC_LOG_DEBUG("condition", "Condition object not found for %s", ToString().c_str());
 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 (Player* player = object->ToPlayer())
 {
 // don't allow 0 items (it's checked during table load)
 ASSERT(ConditionValue2);
 bool checkBank = ConditionValue3 ? true : false;
 condMeets = player->HasItemCount(ConditionValue1, ConditionValue2, checkBank);
 }
 break;
 }
 case CONDITION_ITEM_EQUIPPED:
 {
 if (Player* player = object->ToPlayer())
 condMeets = player->HasItemOrGemWithIdEquipped(ConditionValue1, 1);
 break;
 }
 case CONDITION_ZONEID:
 condMeets = object->GetZoneId() == ConditionValue1;
 break;
 case CONDITION_REPUTATION_RANK:
 {
 if (Player* player = object->ToPlayer())
 {
 if (FactionEntry const* faction = sFactionStore.LookupEntry(ConditionValue1))
 condMeets = (ConditionValue2 & (1 << player->GetReputationMgr().GetRank(faction))) != 0;
 }
 break;
 }
 case CONDITION_ACHIEVEMENT:
 {
 if (Player* player = object->ToPlayer())
 condMeets = player->HasAchieved(ConditionValue1);
 break;
 }
 case CONDITION_TEAM:
 {
 if (Player* player = object->ToPlayer())
 condMeets = player->GetTeam() == ConditionValue1;
 break;
 }
 case CONDITION_CLASS:
 {
 if (Unit* unit = object->ToUnit())
 condMeets = (unit->getClassMask() & ConditionValue1) != 0;
 break;
 }
 case CONDITION_RACE:
 {
 if (Unit* unit = object->ToUnit())
 condMeets = (unit->getRaceMask() & ConditionValue1) != 0;
 break;
 }
 case CONDITION_GENDER:
 {
 if (Player* player = object->ToPlayer())
 condMeets = player->getGender() == ConditionValue1;
 break;
 }
 case CONDITION_SKILL:
 {
 if (Player* player = object->ToPlayer())
 condMeets = player->HasSkill(ConditionValue1) && player->GetBaseSkillValue(ConditionValue1) >= ConditionValue2;
 break;
 }
 case CONDITION_QUESTREWARDED:
 {
 if (Player* player = object->ToPlayer())
 condMeets = player->GetQuestRewardStatus(ConditionValue1);
 break;
 }
 case CONDITION_QUESTTAKEN:
 {
 if (Player* player = object->ToPlayer())
 {
 QuestStatus status = player->GetQuestStatus(ConditionValue1);
 condMeets = (status == QUEST_STATUS_INCOMPLETE);
 }
 break;
 }
 case CONDITION_QUEST_COMPLETE:
 {
 if (Player* player = object->ToPlayer())
 {
 QuestStatus status = player->GetQuestStatus(ConditionValue1);
 condMeets = (status == QUEST_STATUS_COMPLETE && !player->GetQuestRewardStatus(ConditionValue1));
 }
 break;
 }
 case CONDITION_QUEST_NONE:
 {
 if (Player* player = object->ToPlayer())
 {
 QuestStatus status = player->GetQuestStatus(ConditionValue1);
 condMeets = (status == QUEST_STATUS_NONE);
 }
 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 = ((InstanceMap*)map)->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 (Player* player = object->ToPlayer())
 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 (Player* player = object->ToPlayer())
 condMeets = (uint32)Player::GetDrunkenstateByValue(player->GetDrunkValue()) >= ConditionValue1;
 break;
 }
 case CONDITION_NEAR_CREATURE:
 {
 condMeets = GetClosestCreatureWithEntry(object, ConditionValue1, (float)ConditionValue2, bool(!ConditionValue3)) ? true : false;
 break;
 }
 case CONDITION_NEAR_GAMEOBJECT:
 {
 condMeets = GetClosestGameObjectWithEntry(object, ConditionValue1, (float)ConditionValue2) ? true : false;
 break;
 }
 case CONDITION_OBJECT_ENTRY_GUID:
 {
 if (uint32(object->GetTypeId()) == ConditionValue1)
 {
 condMeets = !ConditionValue2 || (object->GetEntry() == ConditionValue2);

 if (ConditionValue3)
 {
 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 (static_cast<RelationType>(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;
 default:
 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) != 0;
 }
 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 == sWorld->getWorldState(ConditionValue1);
 break;
 }
 case CONDITION_PHASEID:
 {
 condMeets = object->IsInPhase(ConditionValue1);
 break;
 }
 case CONDITION_TITLE:
 {
 if (Player* player = object->ToPlayer())
 condMeets = player->HasTitle(ConditionValue1);
 break;
 }
 case CONDITION_SPAWNMASK:
 {
 condMeets = ((1 << object->GetMap()->GetSpawnMode()) & ConditionValue1) != 0;
 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 = sAchievementMgr->GetAchievement(ConditionValue1);
 if (achievement && sAchievementMgr->IsRealmCompleted(achievement, std::numeric_limits<uint32>::max()))
 condMeets = true;
 break;
 }
 case CONDITION_IN_WATER:
 {
 if (Unit* unit = object->ToUnit())
 condMeets = unit->IsInWater();
 break;
 }
 case CONDITION_TERRAIN_SWAP:
 {
 condMeets = object->IsInTerrainSwap(ConditionValue1);
 break;
 }
 default:
 condMeets = false;
 break;
 }

 if (NegativeCondition)
 condMeets = !condMeets;

 if (!condMeets)
 sourceInfo.mLastFailedCondition = this;

 bool script = sScriptMgr->OnConditionCheck(this, sourceInfo); // Returns true by default.
 return condMeets && script;
}

Here is the call graph for this function:

std::string Condition::ToString

(

bool

ext = false

)

const

{
 std::ostringstream ss;
 ss << "[Condition ";
 ss << "SourceType: " << SourceType;
 if (SourceType < CONDITION_SOURCE_TYPE_MAX)
 ss << " (" << ConditionMgr::StaticSourceTypeData[SourceType] << ")";
 else
 ss << " (Unknown)";
 if (ConditionMgr::CanHaveSourceGroupSet(SourceType))
 ss << ", SourceGroup: " << SourceGroup;
 ss << ", SourceEntry: " << SourceEntry;
 if (ConditionMgr::CanHaveSourceIdSet(SourceType))
 ss << ", SourceId: " << SourceId;

 if (ext)
 {
 ss << ", ConditionType: " << ConditionType;
 if (ConditionType < CONDITION_MAX)
 ss << " (" << ConditionMgr::StaticConditionTypeData[ConditionType].Name << ")";
 else
 ss << " (Unknown)";
 }

 ss << "]";
 return ss.str();
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

uint8 Condition::ConditionTarget

ConditionTypes Condition::ConditionType

uint32 Condition::ConditionValue1

uint32 Condition::ConditionValue2

uint32 Condition::ConditionValue3

uint32 Condition::ElseGroup

uint32 Condition::ErrorTextId

uint32 Condition::ErrorType

bool Condition::NegativeCondition

uint32 Condition::ReferenceId

uint32 Condition::ScriptId

int32 Condition::SourceEntry

uint32 Condition::SourceGroup

uint32 Condition::SourceId

ConditionSourceType Condition::SourceType

---

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

• src/server/game/Conditions/ConditionMgr.h
• src/server/game/Conditions/ConditionMgr.cpp