AchievementCriteriaData Struct Reference

#include "AchievementMgr.h"

Public Member Functions
	AchievementCriteriaData ()
	AchievementCriteriaData (uint32 _dataType, uint32 _value1, uint32 _value2, uint32 _scriptId)
bool	IsValid (AchievementCriteriaEntry const *criteria)
bool	Meets (uint32 criteria_id, Player const *source, Unit const *target, uint32 miscvalue1=0) const

Public Attributes
AchievementCriteriaDataType	dataType {ACHIEVEMENT_CRITERIA_DATA_TYPE_NONE}
union {
struct {
uint32   id
}   creature
struct {
uint32   class_id
uint32   race_id
}   classRace
struct {
uint32   percent
}   health
struct {
uint32   own_team_flag
}   player_dead
struct {
uint32   spell_id
uint32   effect_idx
}   aura
struct {
uint32   id
}   area
struct {
uint32   value
uint32   compType
}   value
struct {
uint32   minlevel
}   level
struct {
uint32   gender
}   gender
struct {
uint32   difficulty
}   difficulty
struct {
uint32   maxcount
}   map_players
struct {
uint32   team
}   team
struct {
uint32   state
}   drunk
struct {
uint32   id
}   holiday
struct {
uint32   min_score
uint32   max_score
}   bg_loss_team_score
struct {
uint32   item_level
uint32   item_quality
}   equipped_item
struct {
uint32   mapId
}   map_id
struct {
uint32   nth_birthday
}   birthday_login
struct {
uint32   title_id
}   known_title
struct {
uint32   winner_score
uint32   loser_score
}   teams_scores
struct {
uint32   item_quality
}   item
struct {
uint32   value1
uint32   value2
}   raw
};
uint32	ScriptId

Detailed Description

Constructor & Destructor Documentation

AchievementCriteriaData() [1/2]

AchievementCriteriaData::AchievementCriteriaData ( )

inline

    {
        raw.value1 = 0;
        raw.value2 = 0;
        ScriptId = 0;
    }

References raw, and ScriptId.

AchievementCriteriaData() [2/2]

AchievementCriteriaData::AchievementCriteriaData ( uint32  _dataType, uint32  _value1, uint32  _value2, uint32  _scriptId  )

inline

                                                                                                : dataType(AchievementCriteriaDataType(_dataType))
    {
        raw.value1 = _value1;
        raw.value2 = _value2;
        ScriptId = _scriptId;
    }

References raw, and ScriptId.

Member Function Documentation

IsValid()

bool AchievementCriteriaData::IsValid

(

AchievementCriteriaEntry const *

criteria

)

{
    if (dataType >= MAX_ACHIEVEMENT_CRITERIA_DATA_TYPE)
    {
        LOG_ERROR("sql.sql", "Table `achievement_criteria_data` for criteria (Entry: {}) has wrong data type ({}), ignored.", criteria->ID, dataType);
        return false;
    }
 
    switch (criteria->requiredType)
    {
        case ACHIEVEMENT_CRITERIA_TYPE_KILL_CREATURE:
        case ACHIEVEMENT_CRITERIA_TYPE_KILL_CREATURE_TYPE:
        case ACHIEVEMENT_CRITERIA_TYPE_WIN_BG:
        case ACHIEVEMENT_CRITERIA_TYPE_FALL_WITHOUT_DYING:
        case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_QUEST:          // only hardcoded list
        case ACHIEVEMENT_CRITERIA_TYPE_CAST_SPELL:
        case ACHIEVEMENT_CRITERIA_TYPE_WIN_RATED_ARENA:
        case ACHIEVEMENT_CRITERIA_TYPE_WIN_ARENA:
        case ACHIEVEMENT_CRITERIA_TYPE_DO_EMOTE:
        case ACHIEVEMENT_CRITERIA_TYPE_SPECIAL_PVP_KILL:
        case ACHIEVEMENT_CRITERIA_TYPE_WIN_DUEL:
        case ACHIEVEMENT_CRITERIA_TYPE_LOOT_TYPE:
        case ACHIEVEMENT_CRITERIA_TYPE_CAST_SPELL2:
        case ACHIEVEMENT_CRITERIA_TYPE_BE_SPELL_TARGET:
        case ACHIEVEMENT_CRITERIA_TYPE_BE_SPELL_TARGET2:
        case ACHIEVEMENT_CRITERIA_TYPE_EQUIP_EPIC_ITEM:
        case ACHIEVEMENT_CRITERIA_TYPE_ROLL_NEED_ON_LOOT:
        case ACHIEVEMENT_CRITERIA_TYPE_ROLL_GREED_ON_LOOT:
        case ACHIEVEMENT_CRITERIA_TYPE_BG_OBJECTIVE_CAPTURE:
        case ACHIEVEMENT_CRITERIA_TYPE_HONORABLE_KILL:
        case ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_DAILY_QUEST:    // only Children's Week achievements
        case ACHIEVEMENT_CRITERIA_TYPE_USE_ITEM:                // only Children's Week achievements
        case ACHIEVEMENT_CRITERIA_TYPE_GET_KILLING_BLOWS:
        case ACHIEVEMENT_CRITERIA_TYPE_REACH_LEVEL:
        case ACHIEVEMENT_CRITERIA_TYPE_ON_LOGIN:
        case ACHIEVEMENT_CRITERIA_TYPE_LOOT_EPIC_ITEM:
        case ACHIEVEMENT_CRITERIA_TYPE_RECEIVE_EPIC_ITEM:
        case ACHIEVEMENT_CRITERIA_TYPE_OWN_RANK:
            break;
        default:
            if (dataType != ACHIEVEMENT_CRITERIA_DATA_TYPE_SCRIPT)
            {
                LOG_ERROR("sql.sql", "Table `achievement_criteria_data` has data for non-supported criteria type (Entry: {} Type: {}), ignored.", criteria->ID, criteria->requiredType);
                return false;
            }
            break;
    }
 
    switch (dataType)
    {
        case ACHIEVEMENT_CRITERIA_DATA_TYPE_NONE:
        case ACHIEVEMENT_CRITERIA_DATA_TYPE_INSTANCE_SCRIPT:
        case ACHIEVEMENT_CRITERIA_DATA_TYPE_NTH_BIRTHDAY:
            return true;
        case ACHIEVEMENT_CRITERIA_DATA_TYPE_T_CREATURE:
            if (!creature.id || !sObjectMgr->GetCreatureTemplate(creature.id))
            {
                LOG_ERROR("sql.sql", "Table `achievement_criteria_data` (Entry: {} Type: {}) for data type ACHIEVEMENT_CRITERIA_DATA_TYPE_CREATURE ({}) has non-existing creature id in value1 ({}), ignored.",
                                 criteria->ID, criteria->requiredType, dataType, creature.id);
                return false;
            }
            return true;
        case ACHIEVEMENT_CRITERIA_DATA_TYPE_T_PLAYER_CLASS_RACE:
            if (classRace.class_id && ((1 << (classRace.class_id - 1)) & CLASSMASK_ALL_PLAYABLE) == 0)
            {
                LOG_ERROR("sql.sql", "Table `achievement_criteria_data` (Entry: {} Type: {}) for data type ACHIEVEMENT_CRITERIA_DATA_TYPE_T_PLAYER_CLASS_RACE ({}) has non-existing class in value1 ({}), ignored.",
                                 criteria->ID, criteria->requiredType, dataType, classRace.class_id);
                return false;
            }
            if (classRace.race_id && ((1 << (classRace.race_id - 1)) & sRaceMgr->GetPlayableRaceMask()) == 0)
            {
                LOG_ERROR("sql.sql", "Table `achievement_criteria_data` (Entry: {} Type: {}) for data type ACHIEVEMENT_CRITERIA_DATA_TYPE_T_PLAYER_CLASS_RACE ({}) has non-existing race in value2 ({}), ignored.",
                                 criteria->ID, criteria->requiredType, dataType, classRace.race_id);
                return false;
            }
            return true;
        case ACHIEVEMENT_CRITERIA_DATA_TYPE_T_PLAYER_LESS_HEALTH:
            if (health.percent < 1 || health.percent > 100)
            {
                LOG_ERROR("sql.sql", "Table `achievement_criteria_data` (Entry: {} Type: {}) for data type ACHIEVEMENT_CRITERIA_DATA_TYPE_PLAYER_LESS_HEALTH ({}) has wrong percent value in value1 ({}), ignored.",
                                 criteria->ID, criteria->requiredType, dataType, health.percent);
                return false;
            }
            return true;
        case ACHIEVEMENT_CRITERIA_DATA_TYPE_T_PLAYER_DEAD:
            if (player_dead.own_team_flag > 1)
            {
                LOG_ERROR("sql.sql", "Table `achievement_criteria_data` (Entry: {} Type: {}) for data type ACHIEVEMENT_CRITERIA_DATA_TYPE_T_PLAYER_DEAD ({}) has wrong boolean value1 ({}).",
                                 criteria->ID, criteria->requiredType, dataType, player_dead.own_team_flag);
                return false;
            }
            return true;
        case ACHIEVEMENT_CRITERIA_DATA_TYPE_S_AURA:
        case ACHIEVEMENT_CRITERIA_DATA_TYPE_T_AURA:
            {
                SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(aura.spell_id);
                if (!spellInfo)
                {
                    LOG_ERROR("sql.sql", "Table `achievement_criteria_data` (Entry: {} Type: {}) for data type {} ({}) has wrong spell id in value1 ({}), ignored.",
                                     criteria->ID, criteria->requiredType, (dataType == ACHIEVEMENT_CRITERIA_DATA_TYPE_S_AURA ? "ACHIEVEMENT_CRITERIA_DATA_TYPE_S_AURA" : "ACHIEVEMENT_CRITERIA_DATA_TYPE_T_AURA"), dataType, aura.spell_id);
                    return false;
                }
                if (aura.effect_idx >= 3)
                {
                    LOG_ERROR("sql.sql", "Table `achievement_criteria_data` (Entry: {} Type: {}) for data type {} ({}) has wrong spell effect index in value2 ({}), ignored.",
                                     criteria->ID, criteria->requiredType, (dataType == ACHIEVEMENT_CRITERIA_DATA_TYPE_S_AURA ? "ACHIEVEMENT_CRITERIA_DATA_TYPE_S_AURA" : "ACHIEVEMENT_CRITERIA_DATA_TYPE_T_AURA"), dataType, aura.effect_idx);
                    return false;
                }
                if (!spellInfo->Effects[aura.effect_idx].ApplyAuraName)
                {
                    LOG_ERROR("sql.sql", "Table `achievement_criteria_data` (Entry: {} Type: {}) for data type {} ({}) has non-aura spell effect (ID: {} Effect: {}), ignores.",
                                     criteria->ID, criteria->requiredType, (dataType == ACHIEVEMENT_CRITERIA_DATA_TYPE_S_AURA ? "ACHIEVEMENT_CRITERIA_DATA_TYPE_S_AURA" : "ACHIEVEMENT_CRITERIA_DATA_TYPE_T_AURA"), dataType, aura.spell_id, aura.effect_idx);
                    return false;
                }
                return true;
            }
        case ACHIEVEMENT_CRITERIA_DATA_TYPE_S_AREA:
            if (!sAreaTableStore.LookupEntry(area.id))
            {
                LOG_ERROR("sql.sql", "Table `achievement_criteria_data` (Entry: {} Type: {}) for data type ACHIEVEMENT_CRITERIA_DATA_TYPE_S_AREA ({}) has wrong area id in value1 ({}), ignored.",
                                 criteria->ID, criteria->requiredType, dataType, area.id);
                return false;
            }
            return true;
        case ACHIEVEMENT_CRITERIA_DATA_TYPE_VALUE:
            if (value.compType >= COMP_TYPE_MAX)
            {
                LOG_ERROR("sql.sql", "Table `achievement_criteria_data` (Entry: {} Type: {}) for data type ACHIEVEMENT_CRITERIA_DATA_TYPE_VALUE ({}) has wrong ComparisionType in value2 ({}), ignored.",
                                 value.compType, criteria->requiredType, dataType, value.value);
                return false;
            }
            return true;
        case ACHIEVEMENT_CRITERIA_DATA_TYPE_T_LEVEL:
            if (level.minlevel > STRONG_MAX_LEVEL)
            {
                LOG_ERROR("sql.sql", "Table `achievement_criteria_data` (Entry: {} Type: {}) for data type ACHIEVEMENT_CRITERIA_DATA_TYPE_T_LEVEL ({}) has wrong minlevel in value1 ({}), ignored.",
                                 criteria->ID, criteria->requiredType, dataType, level.minlevel);
                return false;
            }
            return true;
        case ACHIEVEMENT_CRITERIA_DATA_TYPE_T_GENDER:
            if (gender.gender > GENDER_NONE)
            {
                LOG_ERROR("sql.sql", "Table `achievement_criteria_data` (Entry: {} Type: {}) for data type ACHIEVEMENT_CRITERIA_DATA_TYPE_T_GENDER ({}) has wrong gender in value1 ({}), ignored.",
                                 criteria->ID, criteria->requiredType, dataType, gender.gender);
                return false;
            }
            return true;
        case ACHIEVEMENT_CRITERIA_DATA_TYPE_SCRIPT:
            if (!ScriptId)
            {
                LOG_ERROR("sql.sql", "Table `achievement_criteria_data` (Entry: {} Type: {}) for data type ACHIEVEMENT_CRITERIA_DATA_TYPE_SCRIPT ({}) does not have ScriptName set, ignored.",
                                 criteria->ID, criteria->requiredType, dataType);
                return false;
            }
            return true;
        case ACHIEVEMENT_CRITERIA_DATA_TYPE_MAP_DIFFICULTY:
            if (difficulty.difficulty >= MAX_DIFFICULTY)
            {
                LOG_ERROR("sql.sql", "Table `achievement_criteria_data` (Entry: {} Type: {}) for data type ACHIEVEMENT_CRITERIA_DATA_TYPE_MAP_DIFFICULTY ({}) has wrong difficulty in value1 ({}), ignored.",
                                 criteria->ID, criteria->requiredType, dataType, difficulty.difficulty);
                return false;
            }
            return true;
        case ACHIEVEMENT_CRITERIA_DATA_TYPE_MAP_PLAYER_COUNT:
            if (map_players.maxcount <= 0)
            {
                LOG_ERROR("sql.sql", "Table `achievement_criteria_data` (Entry: {} Type: {}) for data type ACHIEVEMENT_CRITERIA_DATA_TYPE_MAP_PLAYER_COUNT ({}) has wrong max players count in value1 ({}), ignored.",
                                 criteria->ID, criteria->requiredType, dataType, map_players.maxcount);
                return false;
            }
            return true;
        case ACHIEVEMENT_CRITERIA_DATA_TYPE_T_TEAM:
            if (team.team != ALLIANCE && team.team != HORDE)
            {
                LOG_ERROR("sql.sql", "Table `achievement_criteria_data` (Entry: {} Type: {}) for data type ACHIEVEMENT_CRITERIA_DATA_TYPE_T_TEAM ({}) has unknown team in value1 ({}), ignored.",
                                 criteria->ID, criteria->requiredType, dataType, team.team);
                return false;
            }
            return true;
        case ACHIEVEMENT_CRITERIA_DATA_TYPE_S_DRUNK:
            if (drunk.state >= MAX_DRUNKEN)
            {
                LOG_ERROR("sql.sql", "Table `achievement_criteria_data` (Entry: {} Type: {}) for data type ACHIEVEMENT_CRITERIA_DATA_TYPE_S_DRUNK ({}) has unknown drunken state in value1 ({}), ignored.",
                                 criteria->ID, criteria->requiredType, dataType, drunk.state);
                return false;
            }
            return true;
        case ACHIEVEMENT_CRITERIA_DATA_TYPE_HOLIDAY:
            if (!sHolidaysStore.LookupEntry(holiday.id))
            {
                LOG_ERROR("sql.sql", "Table `achievement_criteria_data` (Entry: {} Type: {}) for data type ACHIEVEMENT_CRITERIA_DATA_TYPE_HOLIDAY ({}) has unknown holiday in value1 ({}), ignored.",
                                 criteria->ID, criteria->requiredType, dataType, holiday.id);
                return false;
            }
            return true;
        case ACHIEVEMENT_CRITERIA_DATA_TYPE_BG_LOSS_TEAM_SCORE:
        case ACHIEVEMENT_CRITERIA_DATA_TYPE_BG_TEAMS_SCORES:
            return true;                                    // not check correctness node indexes
        case ACHIEVEMENT_CRITERIA_DATA_TYPE_S_EQUIPPED_ITEM:
        case ACHIEVEMENT_CRITERIA_DATA_TYPE_S_ITEM_QUALITY:
            if (equipped_item.item_quality >= MAX_ITEM_QUALITY)
            {
                LOG_ERROR("sql.sql", "Table `achievement_criteria_requirement` (Entry: {} Type: {}) for requirement ACHIEVEMENT_CRITERIA_REQUIRE_S_EQUIPPED_ITEM ({}) has unknown quality state in value1 ({}), ignored.",
                                 criteria->ID, criteria->requiredType, dataType, equipped_item.item_quality);
                return false;
            }
            return true;
        case ACHIEVEMENT_CRITERIA_DATA_TYPE_MAP_ID:
            if (!sMapStore.LookupEntry(map_id.mapId))
            {
                LOG_ERROR("sql.sql", "Table `achievement_criteria_requirement` (Entry: {} Type: {}) for requirement ACHIEVEMENT_CRITERIA_DATA_TYPE_MAP_ID ({}) has unknown map id in value1 ({}), ignored.",
                                 criteria->ID, criteria->requiredType, dataType, map_id.mapId);
                return false;
            }
            return true;
        case ACHIEVEMENT_CRITERIA_DATA_TYPE_S_PLAYER_CLASS_RACE:
            if (!classRace.class_id && !classRace.race_id)
            {
                LOG_ERROR("sql.sql", "Table `achievement_criteria_data` (Entry: {} Type: {}) for data type ACHIEVEMENT_CRITERIA_DATA_TYPE_S_PLAYER_CLASS_RACE ({}) must not have 0 in either value field, ignored.",
                                 criteria->ID, criteria->requiredType, dataType);
                return false;
            }
            if (classRace.class_id && ((1 << (classRace.class_id - 1)) & CLASSMASK_ALL_PLAYABLE) == 0)
            {
                LOG_ERROR("sql.sql", "Table `achievement_criteria_data` (Entry: {} Type: {}) for data type ACHIEVEMENT_CRITERIA_DATA_TYPE_S_PLAYER_CLASS_RACE ({}) has non-existing class in value1 ({}), ignored.",
                                 criteria->ID, criteria->requiredType, dataType, classRace.class_id);
                return false;
            }
            if (classRace.race_id && ((1 << (classRace.race_id - 1)) & sRaceMgr->GetPlayableRaceMask()) == 0)
            {
                LOG_ERROR("sql.sql", "Table `achievement_criteria_data` (Entry: {} Type: {}) for data type ACHIEVEMENT_CRITERIA_DATA_TYPE_S_PLAYER_CLASS_RACE ({}) has non-existing race in value2 ({}), ignored.",
                                 criteria->ID, criteria->requiredType, dataType, classRace.race_id);
                return false;
            }
            return true;
        case ACHIEVEMENT_CRITERIA_DATA_TYPE_S_KNOWN_TITLE:
            {
                if (!sCharTitlesStore.LookupEntry(known_title.title_id))
                {
                    LOG_ERROR("sql.sql", "Table `achievement_criteria_requirement` (Entry: {} Type: {}) for requirement ACHIEVEMENT_CRITERIA_DATA_TYPE_S_KNOWN_TITLE ({}) have unknown title_id in value1 ({}), ignore.",
                                     criteria->ID, criteria->requiredType, dataType, known_title.title_id);
                    return false;
                }
                return true;
            }
        default:
            LOG_ERROR("sql.sql", "Table `achievement_criteria_data` (Entry: {} Type: {}) has data for non-supported data type ({}), ignored.", criteria->ID, criteria->requiredType, dataType);
            return false;
    }
}

References ACHIEVEMENT_CRITERIA_DATA_TYPE_BG_LOSS_TEAM_SCORE, ACHIEVEMENT_CRITERIA_DATA_TYPE_BG_TEAMS_SCORES, ACHIEVEMENT_CRITERIA_DATA_TYPE_HOLIDAY, ACHIEVEMENT_CRITERIA_DATA_TYPE_INSTANCE_SCRIPT, ACHIEVEMENT_CRITERIA_DATA_TYPE_MAP_DIFFICULTY, ACHIEVEMENT_CRITERIA_DATA_TYPE_MAP_ID, ACHIEVEMENT_CRITERIA_DATA_TYPE_MAP_PLAYER_COUNT, ACHIEVEMENT_CRITERIA_DATA_TYPE_NONE, ACHIEVEMENT_CRITERIA_DATA_TYPE_NTH_BIRTHDAY, ACHIEVEMENT_CRITERIA_DATA_TYPE_S_AREA, ACHIEVEMENT_CRITERIA_DATA_TYPE_S_AURA, ACHIEVEMENT_CRITERIA_DATA_TYPE_S_DRUNK, ACHIEVEMENT_CRITERIA_DATA_TYPE_S_EQUIPPED_ITEM, ACHIEVEMENT_CRITERIA_DATA_TYPE_S_ITEM_QUALITY, ACHIEVEMENT_CRITERIA_DATA_TYPE_S_KNOWN_TITLE, ACHIEVEMENT_CRITERIA_DATA_TYPE_S_PLAYER_CLASS_RACE, ACHIEVEMENT_CRITERIA_DATA_TYPE_SCRIPT, ACHIEVEMENT_CRITERIA_DATA_TYPE_T_AURA, ACHIEVEMENT_CRITERIA_DATA_TYPE_T_CREATURE, ACHIEVEMENT_CRITERIA_DATA_TYPE_T_GENDER, ACHIEVEMENT_CRITERIA_DATA_TYPE_T_LEVEL, ACHIEVEMENT_CRITERIA_DATA_TYPE_T_PLAYER_CLASS_RACE, ACHIEVEMENT_CRITERIA_DATA_TYPE_T_PLAYER_DEAD, ACHIEVEMENT_CRITERIA_DATA_TYPE_T_PLAYER_LESS_HEALTH, ACHIEVEMENT_CRITERIA_DATA_TYPE_T_TEAM, ACHIEVEMENT_CRITERIA_DATA_TYPE_VALUE, ACHIEVEMENT_CRITERIA_TYPE_BE_SPELL_TARGET, ACHIEVEMENT_CRITERIA_TYPE_BE_SPELL_TARGET2, ACHIEVEMENT_CRITERIA_TYPE_BG_OBJECTIVE_CAPTURE, ACHIEVEMENT_CRITERIA_TYPE_CAST_SPELL, ACHIEVEMENT_CRITERIA_TYPE_CAST_SPELL2, ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_DAILY_QUEST, ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_QUEST, ACHIEVEMENT_CRITERIA_TYPE_DO_EMOTE, ACHIEVEMENT_CRITERIA_TYPE_EQUIP_EPIC_ITEM, ACHIEVEMENT_CRITERIA_TYPE_FALL_WITHOUT_DYING, ACHIEVEMENT_CRITERIA_TYPE_GET_KILLING_BLOWS, ACHIEVEMENT_CRITERIA_TYPE_HONORABLE_KILL, ACHIEVEMENT_CRITERIA_TYPE_KILL_CREATURE, ACHIEVEMENT_CRITERIA_TYPE_KILL_CREATURE_TYPE, ACHIEVEMENT_CRITERIA_TYPE_LOOT_EPIC_ITEM, ACHIEVEMENT_CRITERIA_TYPE_LOOT_TYPE, ACHIEVEMENT_CRITERIA_TYPE_ON_LOGIN, ACHIEVEMENT_CRITERIA_TYPE_OWN_RANK, ACHIEVEMENT_CRITERIA_TYPE_REACH_LEVEL, ACHIEVEMENT_CRITERIA_TYPE_RECEIVE_EPIC_ITEM, ACHIEVEMENT_CRITERIA_TYPE_ROLL_GREED_ON_LOOT, ACHIEVEMENT_CRITERIA_TYPE_ROLL_NEED_ON_LOOT, ACHIEVEMENT_CRITERIA_TYPE_SPECIAL_PVP_KILL, ACHIEVEMENT_CRITERIA_TYPE_USE_ITEM, ACHIEVEMENT_CRITERIA_TYPE_WIN_ARENA, ACHIEVEMENT_CRITERIA_TYPE_WIN_BG, ACHIEVEMENT_CRITERIA_TYPE_WIN_DUEL, ACHIEVEMENT_CRITERIA_TYPE_WIN_RATED_ARENA, ALLIANCE, area, aura, CLASSMASK_ALL_PLAYABLE, classRace, COMP_TYPE_MAX, creature, dataType, difficulty, drunk, SpellInfo::Effects, equipped_item, gender, GENDER_NONE, health, holiday, HORDE, AchievementCriteriaEntry::ID, known_title, level, LOG_ERROR, map_players, MAX_ACHIEVEMENT_CRITERIA_DATA_TYPE, MAX_DIFFICULTY, MAX_DRUNKEN, MAX_ITEM_QUALITY, player_dead, AchievementCriteriaEntry::requiredType, sAreaTableStore, sCharTitlesStore, ScriptId, sHolidaysStore, sMapStore, sObjectMgr, sRaceMgr, sSpellMgr, STRONG_MAX_LEVEL, team, and value.

Referenced by AchievementGlobalMgr::LoadAchievementCriteriaData().

Meets()

bool AchievementCriteriaData::Meets	(	uint32	criteria_id,
		Player const *	source,
		Unit const *	target,
		uint32	miscvalue1 = 0
	)		const

{
    switch (dataType)
    {
        case ACHIEVEMENT_CRITERIA_DATA_TYPE_NONE:
            return true;
        case ACHIEVEMENT_CRITERIA_DATA_TYPE_T_CREATURE:
            if (!target || !target->IsCreature())
                return false;
            return target->GetEntry() == creature.id;
        case ACHIEVEMENT_CRITERIA_DATA_TYPE_T_PLAYER_CLASS_RACE:
            if (!target || !target->IsPlayer())
                return false;
            if (classRace.class_id && classRace.class_id != target->ToPlayer()->getClass())
                return false;
            if (classRace.race_id && classRace.race_id != target->ToPlayer()->getRace())
                return false;
            return true;
        case ACHIEVEMENT_CRITERIA_DATA_TYPE_S_PLAYER_CLASS_RACE:
            if (!source || !source->IsPlayer())
                return false;
            if (classRace.class_id && classRace.class_id != source->ToPlayer()->getClass())
                return false;
            if (classRace.race_id && classRace.race_id != source->ToPlayer()->getRace())
                return false;
            return true;
        case ACHIEVEMENT_CRITERIA_DATA_TYPE_T_PLAYER_LESS_HEALTH:
            if (!target || !target->IsPlayer())
                return false;
            return !target->HealthAbovePct(health.percent);
        case ACHIEVEMENT_CRITERIA_DATA_TYPE_T_PLAYER_DEAD:
            if (target && !target->IsAlive())
                if (Player const* player = target->ToPlayer())
                    if (player->GetDeathTimer() != 0)
                        // flag set == must be same team, not set == different team
                        return (player->GetTeamId() == source->GetTeamId()) == (player_dead.own_team_flag != 0);
            return false;
        case ACHIEVEMENT_CRITERIA_DATA_TYPE_S_AURA:
            return source->HasAuraEffect(aura.spell_id, aura.effect_idx);
        case ACHIEVEMENT_CRITERIA_DATA_TYPE_S_AREA:
        {
            uint32 zone_id, area_id;
            source->GetZoneAndAreaId(zone_id, area_id);
            return area.id == zone_id || area.id == area_id;
        }
        case ACHIEVEMENT_CRITERIA_DATA_TYPE_T_AURA:
            return target && target->HasAuraEffect(aura.spell_id, aura.effect_idx);
        case ACHIEVEMENT_CRITERIA_DATA_TYPE_VALUE:
            return CompareValues(ComparisionType(value.compType), miscvalue1, value.value);
        case ACHIEVEMENT_CRITERIA_DATA_TYPE_T_LEVEL:
            if (!target)
                return false;
            return target->GetLevel() >= level.minlevel;
        case ACHIEVEMENT_CRITERIA_DATA_TYPE_T_GENDER:
            if (!target)
                return false;
            return target->getGender() == gender.gender;
        case ACHIEVEMENT_CRITERIA_DATA_TYPE_SCRIPT:
            return sScriptMgr->OnCriteriaCheck(ScriptId, const_cast<Player*>(source), const_cast<Unit*>(target), criteria_id);
        case ACHIEVEMENT_CRITERIA_DATA_TYPE_MAP_DIFFICULTY:
        {
            if (source->GetMap()->IsRaid())
                if (source->GetMap()->Is25ManRaid() != ((difficulty.difficulty & RAID_DIFFICULTY_MASK_25MAN) != 0))
                    return false;
 
            AchievementCriteriaEntry const* criteria = sAchievementCriteriaStore.LookupEntry(criteria_id);
            uint8 spawnMode = source->GetMap()->GetSpawnMode();
            // Dungeons completed on heroic mode count towards both in general achievement, but not in statistics.
            return sAchievementMgr->IsStatisticCriteria(criteria) ? spawnMode == difficulty.difficulty : spawnMode >= difficulty.difficulty;
        }
        case ACHIEVEMENT_CRITERIA_DATA_TYPE_MAP_PLAYER_COUNT:
            return source->GetMap()->GetPlayersCountExceptGMs() <= map_players.maxcount;
        case ACHIEVEMENT_CRITERIA_DATA_TYPE_T_TEAM:
        {
            if (!target || !target->IsPlayer())
                return false;
 
            // DB data compatibility...
            uint32 teamOld = target->ToPlayer()->GetTeamId() == TEAM_ALLIANCE ? ALLIANCE : HORDE;
            return teamOld == team.team;
        }
        case ACHIEVEMENT_CRITERIA_DATA_TYPE_S_DRUNK:
            return Player::GetDrunkenstateByValue(source->GetDrunkValue()) >= DrunkenState(drunk.state);
        case ACHIEVEMENT_CRITERIA_DATA_TYPE_HOLIDAY:
            return IsHolidayActive(HolidayIds(holiday.id));
        case ACHIEVEMENT_CRITERIA_DATA_TYPE_BG_LOSS_TEAM_SCORE:
        {
            Battleground* bg = source->GetBattleground();
            if (!bg)
                return false;
 
            uint32 score = bg->GetTeamScore(source->GetTeamId() == TEAM_ALLIANCE ? TEAM_HORDE : TEAM_ALLIANCE);
            return score >= bg_loss_team_score.min_score && score <= bg_loss_team_score.max_score;
        }
        case ACHIEVEMENT_CRITERIA_DATA_TYPE_INSTANCE_SCRIPT:
        {
            if (!source->IsInWorld())
                return false;
            Map* map = source->GetMap();
            if (!map->IsDungeon())
            {
                LOG_ERROR("sql.sql", "Achievement system call ACHIEVEMENT_CRITERIA_DATA_TYPE_INSTANCE_SCRIPT ({}) for achievement criteria {} for non-dungeon/non-raid map {}",
                                    ACHIEVEMENT_CRITERIA_DATA_TYPE_INSTANCE_SCRIPT, criteria_id, map->GetId());
                return false;
            }
            InstanceScript* instance = map->ToInstanceMap()->GetInstanceScript();
            if (!instance)
            {
                LOG_ERROR("sql.sql", "Achievement system call ACHIEVEMENT_CRITERIA_DATA_TYPE_INSTANCE_SCRIPT ({}) for achievement criteria {} for map {} but map does not have a instance script",
                                    ACHIEVEMENT_CRITERIA_DATA_TYPE_INSTANCE_SCRIPT, criteria_id, map->GetId());
                return false;
            }
            return instance->CheckAchievementCriteriaMeet(criteria_id, source, target, miscvalue1);
        }
        case ACHIEVEMENT_CRITERIA_DATA_TYPE_S_EQUIPPED_ITEM:
        {
            ItemTemplate const* pProto = sObjectMgr->GetItemTemplate(miscvalue1);
            if (!pProto)
                return false;
            return pProto->ItemLevel >= equipped_item.item_level && pProto->Quality >= equipped_item.item_quality;
        }
        case ACHIEVEMENT_CRITERIA_DATA_TYPE_MAP_ID:
            return source->GetMapId() == map_id.mapId;
        case ACHIEVEMENT_CRITERIA_DATA_TYPE_NTH_BIRTHDAY:
        {
            tm birthday_tm = Acore::Time::TimeBreakdown(sWorld->getIntConfig(CONFIG_BIRTHDAY_TIME));
 
            // exactly N birthday
            birthday_tm.tm_year += birthday_login.nth_birthday;
 
            time_t birthday = mktime(&birthday_tm);
            time_t now = GameTime::GetGameTime().count();
            return now <= birthday + DAY && now >= birthday;
        }
        case ACHIEVEMENT_CRITERIA_DATA_TYPE_S_KNOWN_TITLE:
        {
            if (CharTitlesEntry const* titleInfo = sCharTitlesStore.LookupEntry(known_title.title_id))
                return source && source->HasTitle(titleInfo->bit_index);
 
            return false;
        }
        case ACHIEVEMENT_CRITERIA_DATA_TYPE_S_ITEM_QUALITY:
        {
            ItemTemplate const* pProto = sObjectMgr->GetItemTemplate(miscvalue1);
            if (!pProto)
                return false;
            return pProto->Quality == item.item_quality;
        }
        case ACHIEVEMENT_CRITERIA_DATA_TYPE_BG_TEAMS_SCORES:
        {
            Battleground* bg = source->GetBattleground();
            if (!bg)
            {
                return false;
            }
 
            TeamId winnerTeam = GetTeamId(bg->GetWinner());
            if (winnerTeam == TEAM_NEUTRAL)
            {
                return false;
            }
 
            uint32 winnnerScore = bg->GetTeamScore(winnerTeam);
            uint32 loserScore = bg->GetTeamScore(TeamId(!uint32(winnerTeam)));
            return source->GetTeamId() == winnerTeam && winnnerScore == teams_scores.winner_score && loserScore == teams_scores.loser_score;
        }
        default:
            break;
    }
    return false;
}

References ACHIEVEMENT_CRITERIA_DATA_TYPE_BG_LOSS_TEAM_SCORE, ACHIEVEMENT_CRITERIA_DATA_TYPE_BG_TEAMS_SCORES, ACHIEVEMENT_CRITERIA_DATA_TYPE_HOLIDAY, ACHIEVEMENT_CRITERIA_DATA_TYPE_INSTANCE_SCRIPT, ACHIEVEMENT_CRITERIA_DATA_TYPE_MAP_DIFFICULTY, ACHIEVEMENT_CRITERIA_DATA_TYPE_MAP_ID, ACHIEVEMENT_CRITERIA_DATA_TYPE_MAP_PLAYER_COUNT, ACHIEVEMENT_CRITERIA_DATA_TYPE_NONE, ACHIEVEMENT_CRITERIA_DATA_TYPE_NTH_BIRTHDAY, ACHIEVEMENT_CRITERIA_DATA_TYPE_S_AREA, ACHIEVEMENT_CRITERIA_DATA_TYPE_S_AURA, ACHIEVEMENT_CRITERIA_DATA_TYPE_S_DRUNK, ACHIEVEMENT_CRITERIA_DATA_TYPE_S_EQUIPPED_ITEM, ACHIEVEMENT_CRITERIA_DATA_TYPE_S_ITEM_QUALITY, ACHIEVEMENT_CRITERIA_DATA_TYPE_S_KNOWN_TITLE, ACHIEVEMENT_CRITERIA_DATA_TYPE_S_PLAYER_CLASS_RACE, ACHIEVEMENT_CRITERIA_DATA_TYPE_SCRIPT, ACHIEVEMENT_CRITERIA_DATA_TYPE_T_AURA, ACHIEVEMENT_CRITERIA_DATA_TYPE_T_CREATURE, ACHIEVEMENT_CRITERIA_DATA_TYPE_T_GENDER, ACHIEVEMENT_CRITERIA_DATA_TYPE_T_LEVEL, ACHIEVEMENT_CRITERIA_DATA_TYPE_T_PLAYER_CLASS_RACE, ACHIEVEMENT_CRITERIA_DATA_TYPE_T_PLAYER_DEAD, ACHIEVEMENT_CRITERIA_DATA_TYPE_T_PLAYER_LESS_HEALTH, ACHIEVEMENT_CRITERIA_DATA_TYPE_T_TEAM, ACHIEVEMENT_CRITERIA_DATA_TYPE_VALUE, ALLIANCE, area, aura, bg_loss_team_score, birthday_login, InstanceScript::CheckAchievementCriteriaMeet(), classRace, CompareValues(), CONFIG_BIRTHDAY_TIME, creature, dataType, difficulty, drunk, equipped_item, gender, Player::GetBattleground(), Unit::getClass(), Player::GetDrunkenstateByValue(), Player::GetDrunkValue(), Object::GetEntry(), GameTime::GetGameTime(), Unit::getGender(), Map::GetId(), InstanceMap::GetInstanceScript(), Unit::GetLevel(), WorldObject::GetMap(), WorldLocation::GetMapId(), Map::GetPlayersCountExceptGMs(), Unit::getRace(), Map::GetSpawnMode(), Player::GetTeamId(), GetTeamId(), Battleground::GetTeamScore(), Battleground::GetWinner(), WorldObject::GetZoneAndAreaId(), Unit::HasAuraEffect(), Player::HasTitle(), health, Unit::HealthAbovePct(), holiday, HORDE, Map::Is25ManRaid(), Unit::IsAlive(), Object::IsCreature(), Map::IsDungeon(), IsHolidayActive(), Object::IsInWorld(), Object::IsPlayer(), Map::IsRaid(), item, ItemTemplate::ItemLevel, known_title, level, LOG_ERROR, map_players, player_dead, ItemTemplate::Quality, RAID_DIFFICULTY_MASK_25MAN, sAchievementCriteriaStore, sAchievementMgr, sCharTitlesStore, ScriptId, sObjectMgr, sScriptMgr, sWorld, team, TEAM_ALLIANCE, TEAM_HORDE, TEAM_NEUTRAL, teams_scores, Acore::Time::TimeBreakdown(), Map::ToInstanceMap(), Object::ToPlayer(), and value.

Member Data Documentation

[union]

union { ... } AchievementCriteriaData

[struct]

struct { ... } AchievementCriteriaData::area

Referenced by IsValid(), and Meets().

[struct]

struct { ... } AchievementCriteriaData::aura

Referenced by IsValid(), and Meets().

[struct]

struct { ... } AchievementCriteriaData::bg_loss_team_score

Referenced by Meets().

[struct]

struct { ... } AchievementCriteriaData::birthday_login

Referenced by Meets().

class_id

uint32 AchievementCriteriaData::class_id

[struct]

struct { ... } AchievementCriteriaData::classRace

Referenced by IsValid(), and Meets().

compType

uint32 AchievementCriteriaData::compType

[struct]

struct { ... } AchievementCriteriaData::creature

Referenced by IsValid(), and Meets().

dataType

AchievementCriteriaDataType AchievementCriteriaData::dataType {ACHIEVEMENT_CRITERIA_DATA_TYPE_NONE}

{ACHIEVEMENT_CRITERIA_DATA_TYPE_NONE};

Referenced by IsValid(), AchievementGlobalMgr::LoadAchievementCriteriaData(), and Meets().

difficulty [1/2]

uint32 AchievementCriteriaData::difficulty

Referenced by IsValid(), and Meets().

[struct] [2/2]

struct { ... } AchievementCriteriaData::difficulty

[struct]

struct { ... } AchievementCriteriaData::drunk

Referenced by IsValid(), and Meets().

effect_idx

uint32 AchievementCriteriaData::effect_idx

[struct]

struct { ... } AchievementCriteriaData::equipped_item

Referenced by IsValid(), and Meets().

gender [1/2]

uint32 AchievementCriteriaData::gender

Referenced by IsValid(), and Meets().

[struct] [2/2]

struct { ... } AchievementCriteriaData::gender

[struct]

struct { ... } AchievementCriteriaData::health

Referenced by IsValid(), and Meets().

[struct]

struct { ... } AchievementCriteriaData::holiday

Referenced by IsValid(), and Meets().

id

uint32 AchievementCriteriaData::id

[struct]

struct { ... } AchievementCriteriaData::item

Referenced by Meets().

item_level

uint32 AchievementCriteriaData::item_level

item_quality

uint32 AchievementCriteriaData::item_quality

[struct]

struct { ... } AchievementCriteriaData::known_title

Referenced by IsValid(), and Meets().

[struct]

struct { ... } AchievementCriteriaData::level

Referenced by IsValid(), and Meets().

loser_score

uint32 AchievementCriteriaData::loser_score

[struct]

struct { ... } AchievementCriteriaData::map_id

[struct]

struct { ... } AchievementCriteriaData::map_players

Referenced by IsValid(), and Meets().

mapId

uint32 AchievementCriteriaData::mapId

max_score

uint32 AchievementCriteriaData::max_score

maxcount

uint32 AchievementCriteriaData::maxcount

min_score

uint32 AchievementCriteriaData::min_score

minlevel

uint32 AchievementCriteriaData::minlevel

nth_birthday

uint32 AchievementCriteriaData::nth_birthday

own_team_flag

uint32 AchievementCriteriaData::own_team_flag

percent

uint32 AchievementCriteriaData::percent

[struct]

struct { ... } AchievementCriteriaData::player_dead

Referenced by IsValid(), and Meets().

race_id

uint32 AchievementCriteriaData::race_id

[struct]

struct { ... } AchievementCriteriaData::raw

Referenced by AchievementCriteriaData(), and AchievementCriteriaData().

ScriptId

uint32 AchievementCriteriaData::ScriptId

Referenced by AchievementCriteriaData(), AchievementCriteriaData(), IsValid(), and Meets().

spell_id

uint32 AchievementCriteriaData::spell_id

state

uint32 AchievementCriteriaData::state

team [1/2]

uint32 AchievementCriteriaData::team

Referenced by IsValid(), and Meets().

[struct] [2/2]

struct { ... } AchievementCriteriaData::team

[struct]

struct { ... } AchievementCriteriaData::teams_scores

Referenced by Meets().

title_id

uint32 AchievementCriteriaData::title_id

value [1/2]

uint32 AchievementCriteriaData::value

Referenced by IsValid(), and Meets().

[struct] [2/2]

struct { ... } AchievementCriteriaData::value

value1

uint32 AchievementCriteriaData::value1

value2

uint32 AchievementCriteriaData::value2

winner_score

uint32 AchievementCriteriaData::winner_score

---

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

• azerothcore-wotlk/src/server/game/Achievements/AchievementMgr.h
• azerothcore-wotlk/src/server/game/Achievements/AchievementMgr.cpp