<?xml version="1.0" encoding="UTF-8"?>
<commit>
  <added type="array">
    <added>
      <filename>sql/updates/8723_01_mangos_achievement_criteria_requirement.sql</filename>
    </added>
  </added>
  <modified type="array">
    <modified>
      <diff>@@ -24,7 +24,7 @@ CREATE TABLE `db_version` (
   `version` varchar(120) default NULL,
   `creature_ai_version` varchar(120) default NULL,
   `cache_id` int(10) default '0',
-  `required_8693_01_mangos_spell_proc_event` bit(1) default NULL
+  `required_8723_01_mangos_achievement_criteria_requirement` bit(1) default NULL
 ) ENGINE=MyISAM DEFAULT CHARSET=utf8 ROW_FORMAT=FIXED COMMENT='Used DB version notes';
 
 --
@@ -39,11 +39,11 @@ INSERT INTO `db_version` VALUES
 UNLOCK TABLES;
 
 --
--- Table structure for table `achievement_criteria_data`
+-- Table structure for table `achievement_criteria_requirement`
 --
 
-DROP TABLE IF EXISTS `achievement_criteria_data`;
-CREATE TABLE `achievement_criteria_data` (
+DROP TABLE IF EXISTS `achievement_criteria_requirement`;
+CREATE TABLE `achievement_criteria_requirement` (
   `criteria_id` mediumint(8) NOT NULL,
   `type` tinyint(3) unsigned NOT NULL DEFAULT '0',
   `value1` mediumint(8) unsigned NOT NULL DEFAULT '0',
@@ -52,12 +52,12 @@ CREATE TABLE `achievement_criteria_data` (
 ) ENGINE=MyISAM DEFAULT CHARSET=utf8 ROW_FORMAT=FIXED COMMENT='Achievment system';
 
 --
--- Dumping data for table `achievement_criteria_data`
+-- Dumping data for table `achievement_criteria_requirement`
 --
 
-LOCK TABLES `achievement_criteria_data` WRITE;
-/*!40000 ALTER TABLE `achievement_criteria_data` DISABLE KEYS */;
-/*!40000 ALTER TABLE `achievement_criteria_data` ENABLE KEYS */;
+LOCK TABLES `achievement_criteria_requirement` WRITE;
+/*!40000 ALTER TABLE `achievement_criteria_requirement` DISABLE KEYS */;
+/*!40000 ALTER TABLE `achievement_criteria_requirement` ENABLE KEYS */;
 UNLOCK TABLES;
 
 --</diff>
      <filename>sql/mangos.sql</filename>
    </modified>
    <modified>
      <diff>@@ -127,6 +127,7 @@ pkgdata_DATA = \
 	8693_01_mangos_spell_proc_event.sql \
 	8702_01_characters_character_reputation.sql \
 	8721_01_characters_guild.sql \
+	8723_01_mangos_achievement_criteria_requirement.sql \
 	README
 
 ## Additional files to include when running 'make dist'
@@ -234,4 +235,5 @@ EXTRA_DIST = \
 	8693_01_mangos_spell_proc_event.sql \
 	8702_01_characters_character_reputation.sql \
 	8721_01_characters_guild.sql \
+	8723_01_mangos_achievement_criteria_requirement.sql \
 	README</diff>
      <filename>sql/updates/Makefile.am</filename>
    </modified>
    <modified>
      <diff>@@ -71,11 +71,11 @@ namespace MaNGOS
 }                                                           // namespace MaNGOS
 
 
-bool AchievementCriteriaData::IsValid(AchievementCriteriaEntry const* criteria)
+bool AchievementCriteriaRequirement::IsValid(AchievementCriteriaEntry const* criteria)
 {
-    if(dataType &gt;= MAX_ACHIEVEMENT_CRITERIA_DATA_TYPE)
+    if(requirementType &gt;= MAX_ACHIEVEMENT_CRITERIA_REQUIREMENT_TYPE)
     {
-        sLog.outErrorDb( &quot;Table `achievement_criteria_data` for criteria (Entry: %u) have wrong data type (%u), ignore.&quot;, criteria-&gt;ID,dataType);
+        sLog.outErrorDb( &quot;Table `achievement_criteria_requirement` for criteria (Entry: %u) have wrong requirement type (%u), ignore.&quot;, criteria-&gt;ID,requirementType);
         return false;
     }
 
@@ -93,168 +93,168 @@ bool AchievementCriteriaData::IsValid(AchievementCriteriaEntry const* criteria)
         case ACHIEVEMENT_CRITERIA_TYPE_CAST_SPELL2:
             break;
         default:
-            sLog.outErrorDb( &quot;Table `achievement_criteria_data` have data for not supported criteria type (Entry: %u Type: %u), ignore.&quot;, criteria-&gt;ID, criteria-&gt;requiredType);
+            sLog.outErrorDb( &quot;Table `achievement_criteria_requirement` have data for not supported criteria type (Entry: %u Type: %u), ignore.&quot;, criteria-&gt;ID, criteria-&gt;requiredType);
             return false;
     }
 
-    switch(dataType)
+    switch(requirementType)
     {
-        case ACHIEVEMENT_CRITERIA_DATA_TYPE_NONE:
-        case ACHIEVEMENT_CRITERIA_DATA_TYPE_VALUE:
-        case ACHIEVEMENT_CRITERIA_DATA_TYPE_DISABLED:
+        case ACHIEVEMENT_CRITERIA_REQUIRE_NONE:
+        case ACHIEVEMENT_CRITERIA_REQUIRE_VALUE:
+        case ACHIEVEMENT_CRITERIA_REQUIRE_DISABLED:
             return true;
-        case ACHIEVEMENT_CRITERIA_DATA_TYPE_T_CREATURE:
+        case ACHIEVEMENT_CRITERIA_REQUIRE_T_CREATURE:
             if (!creature.id || !objmgr.GetCreatureTemplate(creature.id))
             {
-                sLog.outErrorDb( &quot;Table `achievement_criteria_data` (Entry: %u Type: %u) for data type ACHIEVEMENT_CRITERIA_DATA_TYPE_CREATURE (%u) have not existed creature id in value1 (%u), ignore.&quot;,
-                    criteria-&gt;ID, criteria-&gt;requiredType,dataType,creature.id);
+                sLog.outErrorDb( &quot;Table `achievement_criteria_requirement` (Entry: %u Type: %u) for requirement ACHIEVEMENT_CRITERIA_REQUIRE_CREATURE (%u) have not existed creature id in value1 (%u), ignore.&quot;,
+                    criteria-&gt;ID, criteria-&gt;requiredType,requirementType,creature.id);
                 return false;
             }
             return true;
-        case ACHIEVEMENT_CRITERIA_DATA_TYPE_T_PLAYER_CLASS_RACE:
+        case ACHIEVEMENT_CRITERIA_REQUIRE_T_PLAYER_CLASS_RACE:
             if (!classRace.class_id &amp;&amp; !classRace.race_id)
             {
-                sLog.outErrorDb( &quot;Table `achievement_criteria_data` (Entry: %u Type: %u) for data type ACHIEVEMENT_CRITERIA_DATA_TYPE_PLAYER_CLASS_RACE (%u) must have not 0 in one from value fields, ignore.&quot;,
-                    criteria-&gt;ID, criteria-&gt;requiredType,dataType);
+                sLog.outErrorDb( &quot;Table `achievement_criteria_requirement` (Entry: %u Type: %u) for requirement ACHIEVEMENT_CRITERIA_REQUIRE_PLAYER_CLASS_RACE (%u) must have not 0 in one from value fields, ignore.&quot;,
+                    criteria-&gt;ID, criteria-&gt;requiredType,requirementType);
                 return false;
             }
             if (classRace.class_id &amp;&amp; ((1 &lt;&lt; (classRace.class_id-1)) &amp; CLASSMASK_ALL_PLAYABLE)==0)
             {
-                sLog.outErrorDb( &quot;Table `achievement_criteria_data` (Entry: %u Type: %u) for data type ACHIEVEMENT_CRITERIA_DATA_TYPE_CREATURE (%u) have not existed class in value1 (%u), ignore.&quot;,
-                    criteria-&gt;ID, criteria-&gt;requiredType,dataType,classRace.class_id);
+                sLog.outErrorDb( &quot;Table `achievement_criteria_requirement` (Entry: %u Type: %u) for requirement ACHIEVEMENT_CRITERIA_REQUIRE_CREATURE (%u) have not existed class in value1 (%u), ignore.&quot;,
+                    criteria-&gt;ID, criteria-&gt;requiredType,requirementType,classRace.class_id);
                 return false;
             }
             if (classRace.race_id &amp;&amp; ((1 &lt;&lt; (classRace.race_id-1)) &amp; RACEMASK_ALL_PLAYABLE)==0)
             {
-                sLog.outErrorDb( &quot;Table `achievement_criteria_data` (Entry: %u Type: %u) for data type ACHIEVEMENT_CRITERIA_DATA_TYPE_CREATURE (%u) have not existed race in value2 (%u), ignore.&quot;,
-                    criteria-&gt;ID, criteria-&gt;requiredType,dataType,classRace.race_id);
+                sLog.outErrorDb( &quot;Table `achievement_criteria_requirement` (Entry: %u Type: %u) for requirement ACHIEVEMENT_CRITERIA_REQUIRE_CREATURE (%u) have not existed race in value2 (%u), ignore.&quot;,
+                    criteria-&gt;ID, criteria-&gt;requiredType,requirementType,classRace.race_id);
                 return false;
             }
             return true;
-        case ACHIEVEMENT_CRITERIA_DATA_TYPE_T_PLAYER_LESS_HEALTH:
+        case ACHIEVEMENT_CRITERIA_REQUIRE_T_PLAYER_LESS_HEALTH:
             if (health.percent &lt; 1 || health.percent &gt; 100)
             {
-                sLog.outErrorDb( &quot;Table `achievement_criteria_data` (Entry: %u Type: %u) for data type ACHIEVEMENT_CRITERIA_DATA_TYPE_PLAYER_LESS_HEALTH (%u) have wrong percent value in value1 (%u), ignore.&quot;,
-                    criteria-&gt;ID, criteria-&gt;requiredType,dataType,health.percent);
+                sLog.outErrorDb( &quot;Table `achievement_criteria_requirement` (Entry: %u Type: %u) for requirement ACHIEVEMENT_CRITERIA_REQUIRE_PLAYER_LESS_HEALTH (%u) have wrong percent value in value1 (%u), ignore.&quot;,
+                    criteria-&gt;ID, criteria-&gt;requiredType,requirementType,health.percent);
                 return false;
             }
             return true;
-        case ACHIEVEMENT_CRITERIA_DATA_TYPE_T_PLAYER_DEAD:
+        case ACHIEVEMENT_CRITERIA_REQUIRE_T_PLAYER_DEAD:
             if (player_dead.own_team_flag &gt; 1)
             {
-                sLog.outErrorDb( &quot;Table `achievement_criteria_data` (Entry: %u Type: %u) for data type ACHIEVEMENT_CRITERIA_DATA_TYPE_T_PLAYER_DEAD (%u) have wrong boolean value1 (%u).&quot;,
-                    criteria-&gt;ID, criteria-&gt;requiredType,dataType,player_dead.own_team_flag);
+                sLog.outErrorDb( &quot;Table `achievement_criteria_requirement` (Entry: %u Type: %u) for requirement ACHIEVEMENT_CRITERIA_REQUIRE_T_PLAYER_DEAD (%u) have wrong boolean value1 (%u).&quot;,
+                    criteria-&gt;ID, criteria-&gt;requiredType,requirementType,player_dead.own_team_flag);
                 return false;
             }
             return true;
-        case ACHIEVEMENT_CRITERIA_DATA_TYPE_S_AURA:
-        case ACHIEVEMENT_CRITERIA_DATA_TYPE_T_AURA:
+        case ACHIEVEMENT_CRITERIA_REQUIRE_S_AURA:
+        case ACHIEVEMENT_CRITERIA_REQUIRE_T_AURA:
         {
             SpellEntry const* spellEntry = sSpellStore.LookupEntry(aura.spell_id);
             if (!spellEntry)
             {
-                sLog.outErrorDb( &quot;Table `achievement_criteria_data` (Entry: %u Type: %u) for data type %s (%u) have wrong spell id in value1 (%u), ignore.&quot;,
-                    criteria-&gt;ID, criteria-&gt;requiredType,(dataType==ACHIEVEMENT_CRITERIA_DATA_TYPE_S_AURA?&quot;ACHIEVEMENT_CRITERIA_DATA_TYPE_S_AURA&quot;:&quot;ACHIEVEMENT_CRITERIA_DATA_TYPE_T_AURA&quot;),dataType,aura.spell_id);
+                sLog.outErrorDb( &quot;Table `achievement_criteria_requirement` (Entry: %u Type: %u) for requirement %s (%u) have wrong spell id in value1 (%u), ignore.&quot;,
+                    criteria-&gt;ID, criteria-&gt;requiredType,(requirementType==ACHIEVEMENT_CRITERIA_REQUIRE_S_AURA?&quot;ACHIEVEMENT_CRITERIA_REQUIRE_S_AURA&quot;:&quot;ACHIEVEMENT_CRITERIA_REQUIRE_T_AURA&quot;),requirementType,aura.spell_id);
                 return false;
             }
             if (aura.effect_idx &gt;= 3)
             {
-                sLog.outErrorDb( &quot;Table `achievement_criteria_data` (Entry: %u Type: %u) for data type %s (%u) have wrong spell effect index in value2 (%u), ignore.&quot;,
-                    criteria-&gt;ID, criteria-&gt;requiredType,(dataType==ACHIEVEMENT_CRITERIA_DATA_TYPE_S_AURA?&quot;ACHIEVEMENT_CRITERIA_DATA_TYPE_S_AURA&quot;:&quot;ACHIEVEMENT_CRITERIA_DATA_TYPE_T_AURA&quot;),dataType,aura.effect_idx);
+                sLog.outErrorDb( &quot;Table `achievement_criteria_requirement` (Entry: %u Type: %u) for requirement %s (%u) have wrong spell effect index in value2 (%u), ignore.&quot;,
+                    criteria-&gt;ID, criteria-&gt;requiredType,(requirementType==ACHIEVEMENT_CRITERIA_REQUIRE_S_AURA?&quot;ACHIEVEMENT_CRITERIA_REQUIRE_S_AURA&quot;:&quot;ACHIEVEMENT_CRITERIA_REQUIRE_T_AURA&quot;),requirementType,aura.effect_idx);
                 return false;
             }
             if (!spellEntry-&gt;EffectApplyAuraName[aura.effect_idx])
             {
-                sLog.outErrorDb( &quot;Table `achievement_criteria_data` (Entry: %u Type: %u) for data type %s (%u) have non-aura spell effect (ID: %u Effect: %u), ignore.&quot;,
-                    criteria-&gt;ID, criteria-&gt;requiredType,(dataType==ACHIEVEMENT_CRITERIA_DATA_TYPE_S_AURA?&quot;ACHIEVEMENT_CRITERIA_DATA_TYPE_S_AURA&quot;:&quot;ACHIEVEMENT_CRITERIA_DATA_TYPE_T_AURA&quot;),dataType,aura.spell_id,aura.effect_idx);
+                sLog.outErrorDb( &quot;Table `achievement_criteria_requirement` (Entry: %u Type: %u) for requirement %s (%u) have non-aura spell effect (ID: %u Effect: %u), ignore.&quot;,
+                    criteria-&gt;ID, criteria-&gt;requiredType,(requirementType==ACHIEVEMENT_CRITERIA_REQUIRE_S_AURA?&quot;ACHIEVEMENT_CRITERIA_REQUIRE_S_AURA&quot;:&quot;ACHIEVEMENT_CRITERIA_REQUIRE_T_AURA&quot;),requirementType,aura.spell_id,aura.effect_idx);
                 return false;
             }
             return true;
         }
-        case ACHIEVEMENT_CRITERIA_DATA_TYPE_S_AREA:
+        case ACHIEVEMENT_CRITERIA_REQUIRE_S_AREA:
             if (!GetAreaEntryByAreaID(area.id))
             {
-                sLog.outErrorDb( &quot;Table `achievement_criteria_data` (Entry: %u Type: %u) for data type ACHIEVEMENT_CRITERIA_DATA_TYPE_S_AREA (%u) have wrong area id in value1 (%u), ignore.&quot;,
-                    criteria-&gt;ID, criteria-&gt;requiredType,dataType,area.id);
+                sLog.outErrorDb( &quot;Table `achievement_criteria_requirement` (Entry: %u Type: %u) for requirement ACHIEVEMENT_CRITERIA_REQUIRE_S_AREA (%u) have wrong area id in value1 (%u), ignore.&quot;,
+                    criteria-&gt;ID, criteria-&gt;requiredType,requirementType,area.id);
                 return false;
             }
             return true;
-        case ACHIEVEMENT_CRITERIA_DATA_TYPE_T_LEVEL:
+        case ACHIEVEMENT_CRITERIA_REQUIRE_T_LEVEL:
             if (level.minlevel &lt; 0 || level.minlevel &gt; STRONG_MAX_LEVEL)
             {
-                sLog.outErrorDb( &quot;Table `achievement_criteria_data` (Entry: %u Type: %u) for data type ACHIEVEMENT_CRITERIA_DATA_TYPE_T_LEVEL (%u) have wrong minlevel in value1 (%u), ignore.&quot;,
-                    criteria-&gt;ID, criteria-&gt;requiredType,dataType,level.minlevel);
+                sLog.outErrorDb( &quot;Table `achievement_criteria_requirement` (Entry: %u Type: %u) for requirement ACHIEVEMENT_CRITERIA_REQUIRE_T_LEVEL (%u) have wrong minlevel in value1 (%u), ignore.&quot;,
+                    criteria-&gt;ID, criteria-&gt;requiredType,requirementType,level.minlevel);
                 return false;
             }
             return true;
-        case ACHIEVEMENT_CRITERIA_DATA_TYPE_T_GENDER:
+        case ACHIEVEMENT_CRITERIA_REQUIRE_T_GENDER:
             if (gender.gender &gt; GENDER_NONE)
             {
-                sLog.outErrorDb( &quot;Table `achievement_criteria_data` (Entry: %u Type: %u) for data type ACHIEVEMENT_CRITERIA_DATA_TYPE_T_GENDER (%u) have wrong gender in value1 (%u), ignore.&quot;,
-                    criteria-&gt;ID, criteria-&gt;requiredType,dataType,gender.gender);
+                sLog.outErrorDb( &quot;Table `achievement_criteria_requirement` (Entry: %u Type: %u) for requirement ACHIEVEMENT_CRITERIA_REQUIRE_T_GENDER (%u) have wrong gender in value1 (%u), ignore.&quot;,
+                    criteria-&gt;ID, criteria-&gt;requiredType,requirementType,gender.gender);
                 return false;
             }
             return true;
-        case ACHIEVEMENT_CRITERIA_DATA_TYPE_MAP_DIFFICULTY:
-            if (difficalty.difficalty &gt;= TOTAL_DIFFICULTIES)
+        case ACHIEVEMENT_CRITERIA_REQUIRE_MAP_DIFFICULTY:
+            if (difficulty.difficulty &gt;= TOTAL_DIFFICULTIES)
             {
-                sLog.outErrorDb( &quot;Table `achievement_criteria_data` (Entry: %u Type: %u) for data type ACHIEVEMENT_CRITERIA_DATA_TYPE_MAP_DIFFICULTY (%u) have wrong difficulty in value1 (%u), ignore.&quot;,
-                    criteria-&gt;ID, criteria-&gt;requiredType,dataType,difficalty.difficalty);
+                sLog.outErrorDb( &quot;Table `achievement_criteria_requirement` (Entry: %u Type: %u) for requirement ACHIEVEMENT_CRITERIA_REQUIRE_MAP_DIFFICULTY (%u) have wrong difficulty in value1 (%u), ignore.&quot;,
+                    criteria-&gt;ID, criteria-&gt;requiredType,requirementType,difficulty.difficulty);
                 return false;
             }
             return true;
-        case ACHIEVEMENT_CRITERIA_DATA_TYPE_MAP_PLAYER_COUNT:
+        case ACHIEVEMENT_CRITERIA_REQUIRE_MAP_PLAYER_COUNT:
             if (map_players.maxcount &lt;= 0)
             {
-                sLog.outErrorDb( &quot;Table `achievement_criteria_data` (Entry: %u Type: %u) for data type ACHIEVEMENT_CRITERIA_DATA_TYPE_MAP_PLAYER_COUNT (%u) have wrong max players count in value1 (%u), ignore.&quot;,
-                    criteria-&gt;ID, criteria-&gt;requiredType,dataType,map_players.maxcount);
+                sLog.outErrorDb( &quot;Table `achievement_criteria_requirement` (Entry: %u Type: %u) for requirement ACHIEVEMENT_CRITERIA_REQUIRE_MAP_PLAYER_COUNT (%u) have wrong max players count in value1 (%u), ignore.&quot;,
+                    criteria-&gt;ID, criteria-&gt;requiredType,requirementType,map_players.maxcount);
                 return false;
             }
             return true;
-        case ACHIEVEMENT_CRITERIA_DATA_TYPE_T_TEAM:
+        case ACHIEVEMENT_CRITERIA_REQUIRE_T_TEAM:
             if (team.team != ALLIANCE &amp;&amp; team.team != HORDE)
             {
-                sLog.outErrorDb( &quot;Table `achievement_criteria_data` (Entry: %u Type: %u) for data type ACHIEVEMENT_CRITERIA_DATA_TYPE_T_TEAM (%u) have unknown team in value1 (%u), ignore.&quot;,
-                    criteria-&gt;ID, criteria-&gt;requiredType,dataType,team.team);
+                sLog.outErrorDb( &quot;Table `achievement_criteria_requirement` (Entry: %u Type: %u) for requirement ACHIEVEMENT_CRITERIA_REQUIRE_T_TEAM (%u) have unknown team in value1 (%u), ignore.&quot;,
+                    criteria-&gt;ID, criteria-&gt;requiredType,requirementType,team.team);
                 return false;
             }
             return true;
-        case ACHIEVEMENT_CRITERIA_DATA_TYPE_S_DRUNK:
+        case ACHIEVEMENT_CRITERIA_REQUIRE_S_DRUNK:
             if(drunk.state &gt;= MAX_DRUNKEN)
             {
-                sLog.outErrorDb( &quot;Table `achievement_criteria_data` (Entry: %u Type: %u) for data type ACHIEVEMENT_CRITERIA_DATA_TYPE_S_DRUNK (%u) have unknown drunken state in value1 (%u), ignore.&quot;,
-                    criteria-&gt;ID, criteria-&gt;requiredType,dataType,drunk.state);
+                sLog.outErrorDb( &quot;Table `achievement_criteria_requirement` (Entry: %u Type: %u) for requirement ACHIEVEMENT_CRITERIA_REQUIRE_S_DRUNK (%u) have unknown drunken state in value1 (%u), ignore.&quot;,
+                    criteria-&gt;ID, criteria-&gt;requiredType,requirementType,drunk.state);
                 return false;
             }
             return true;
-        case ACHIEVEMENT_CRITERIA_DATA_TYPE_HOLIDAY:
+        case ACHIEVEMENT_CRITERIA_REQUIRE_HOLIDAY:
             if (!sHolidaysStore.LookupEntry(holiday.id))
             {
-                sLog.outErrorDb( &quot;Table `achievement_criteria_data` (Entry: %u Type: %u) for data type ACHIEVEMENT_CRITERIA_DATA_TYPE_HOLIDAY (%u) have unknown holiday in value1 (%u), ignore.&quot;,
-                    criteria-&gt;ID, criteria-&gt;requiredType,dataType,holiday.id);
+                sLog.outErrorDb( &quot;Table `achievement_criteria_requirement` (Entry: %u Type: %u) for requirement ACHIEVEMENT_CRITERIA_REQUIRE_HOLIDAY (%u) have unknown holiday in value1 (%u), ignore.&quot;,
+                    criteria-&gt;ID, criteria-&gt;requiredType,requirementType,holiday.id);
                 return false;
             }
             return true;
-        case ACHIEVEMENT_CRITERIA_DATA_TYPE_BG_LOSS_TEAM_SCORE:
+        case ACHIEVEMENT_CRITERIA_REQUIRE_BG_LOSS_TEAM_SCORE:
             return true;                                    // not check correctness node indexes
         default:
-            sLog.outErrorDb( &quot;Table `achievement_criteria_data` (Entry: %u Type: %u) have data for not supported data type (%u), ignore.&quot;, criteria-&gt;ID, criteria-&gt;requiredType,dataType);
+            sLog.outErrorDb( &quot;Table `achievement_criteria_requirement` (Entry: %u Type: %u) have data for not supported data type (%u), ignore.&quot;, criteria-&gt;ID, criteria-&gt;requiredType,requirementType);
             return false;
     }
     return false;
 }
 
-bool AchievementCriteriaData::Meets(Player const* source, Unit const* target, uint32 miscvalue1 /*= 0*/) const
+bool AchievementCriteriaRequirement::Meets(Player const* source, Unit const* target, uint32 miscvalue1 /*= 0*/) const
 {
-    switch(dataType)
+    switch(requirementType)
     {
-        case ACHIEVEMENT_CRITERIA_DATA_TYPE_NONE:
+        case ACHIEVEMENT_CRITERIA_REQUIRE_NONE:
             return true;
-        case ACHIEVEMENT_CRITERIA_DATA_TYPE_T_CREATURE:
+        case ACHIEVEMENT_CRITERIA_REQUIRE_T_CREATURE:
             if (!target || target-&gt;GetTypeId()!=TYPEID_UNIT)
                 return false;
             return target-&gt;GetEntry() == creature.id;
-        case ACHIEVEMENT_CRITERIA_DATA_TYPE_T_PLAYER_CLASS_RACE:
+        case ACHIEVEMENT_CRITERIA_REQUIRE_T_PLAYER_CLASS_RACE:
             if (!target || target-&gt;GetTypeId()!=TYPEID_PLAYER)
                 return false;
             if(classRace.class_id &amp;&amp; classRace.class_id != ((Player*)target)-&gt;getClass())
@@ -262,50 +262,50 @@ bool AchievementCriteriaData::Meets(Player const* source, Unit const* target, ui
             if(classRace.race_id &amp;&amp; classRace.race_id != ((Player*)target)-&gt;getRace())
                 return false;
             return true;
-        case ACHIEVEMENT_CRITERIA_DATA_TYPE_T_PLAYER_LESS_HEALTH:
+        case ACHIEVEMENT_CRITERIA_REQUIRE_T_PLAYER_LESS_HEALTH:
             if (!target || target-&gt;GetTypeId()!=TYPEID_PLAYER)
                 return false;
             return target-&gt;GetHealth()*100 &lt;= health.percent*target-&gt;GetMaxHealth();
-        case ACHIEVEMENT_CRITERIA_DATA_TYPE_T_PLAYER_DEAD:
+        case ACHIEVEMENT_CRITERIA_REQUIRE_T_PLAYER_DEAD:
             if (!target || target-&gt;GetTypeId() != TYPEID_PLAYER || target-&gt;isAlive() || ((Player*)target)-&gt;GetDeathTimer() == 0)
                 return false;
             // flag set == must be same team, not set == different team
             return (((Player*)target)-&gt;GetTeam() == source-&gt;GetTeam()) == (player_dead.own_team_flag != 0);
-        case ACHIEVEMENT_CRITERIA_DATA_TYPE_S_AURA:
+        case ACHIEVEMENT_CRITERIA_REQUIRE_S_AURA:
             return source-&gt;HasAura(aura.spell_id,aura.effect_idx);
-        case ACHIEVEMENT_CRITERIA_DATA_TYPE_S_AREA:
+        case ACHIEVEMENT_CRITERIA_REQUIRE_S_AREA:
         {
             uint32 zone_id,area_id;
             source-&gt;GetZoneAndAreaId(zone_id,area_id);
             return area.id==zone_id || area.id==area_id;
         }
-        case ACHIEVEMENT_CRITERIA_DATA_TYPE_T_AURA:
+        case ACHIEVEMENT_CRITERIA_REQUIRE_T_AURA:
             return target &amp;&amp; target-&gt;HasAura(aura.spell_id,aura.effect_idx);
-        case ACHIEVEMENT_CRITERIA_DATA_TYPE_VALUE:
+        case ACHIEVEMENT_CRITERIA_REQUIRE_VALUE:
             return miscvalue1 &gt;= value.minvalue;
-        case ACHIEVEMENT_CRITERIA_DATA_TYPE_T_LEVEL:
+        case ACHIEVEMENT_CRITERIA_REQUIRE_T_LEVEL:
             if (!target)
                 return false;
             return target-&gt;getLevel() &gt;= level.minlevel;
-        case ACHIEVEMENT_CRITERIA_DATA_TYPE_T_GENDER:
+        case ACHIEVEMENT_CRITERIA_REQUIRE_T_GENDER:
             if (!target)
                 return false;
             return target-&gt;getGender() == gender.gender;
-        case ACHIEVEMENT_CRITERIA_DATA_TYPE_DISABLED:
+        case ACHIEVEMENT_CRITERIA_REQUIRE_DISABLED:
             return false;                                   // always fail
-        case ACHIEVEMENT_CRITERIA_DATA_TYPE_MAP_DIFFICULTY:
-            return source-&gt;GetMap()-&gt;GetSpawnMode()==difficalty.difficalty;
-        case ACHIEVEMENT_CRITERIA_DATA_TYPE_MAP_PLAYER_COUNT:
+        case ACHIEVEMENT_CRITERIA_REQUIRE_MAP_DIFFICULTY:
+            return source-&gt;GetMap()-&gt;GetSpawnMode()==difficulty.difficulty;
+        case ACHIEVEMENT_CRITERIA_REQUIRE_MAP_PLAYER_COUNT:
             return source-&gt;GetMap()-&gt;GetPlayersCountExceptGMs() &lt;= map_players.maxcount;
-        case ACHIEVEMENT_CRITERIA_DATA_TYPE_T_TEAM:
+        case ACHIEVEMENT_CRITERIA_REQUIRE_T_TEAM:
             if (!target || target-&gt;GetTypeId() != TYPEID_PLAYER)
                 return false;
             return ((Player*)target)-&gt;GetTeam() == team.team;
-        case ACHIEVEMENT_CRITERIA_DATA_TYPE_S_DRUNK:
+        case ACHIEVEMENT_CRITERIA_REQUIRE_S_DRUNK:
             return Player::GetDrunkenstateByValue(source-&gt;GetDrunkValue()) &gt;= drunk.state;
-        case ACHIEVEMENT_CRITERIA_DATA_TYPE_HOLIDAY:
+        case ACHIEVEMENT_CRITERIA_REQUIRE_HOLIDAY:
             return IsHolidayActive(HolidayIds(holiday.id));
-        case ACHIEVEMENT_CRITERIA_DATA_TYPE_BG_LOSS_TEAM_SCORE:
+        case ACHIEVEMENT_CRITERIA_REQUIRE_BG_LOSS_TEAM_SCORE:
         {
             BattleGround* bg = source-&gt;GetBattleGround();
             if(!bg)
@@ -316,7 +316,7 @@ bool AchievementCriteriaData::Meets(Player const* source, Unit const* target, ui
     return false;
 }
 
-bool AchievementCriteriaDataSet::Meets(Player const* source, Unit const* target, uint32 miscvalue /*= 0*/) const
+bool AchievementCriteriaRequirementSet::Meets(Player const* source, Unit const* target, uint32 miscvalue /*= 0*/) const
 {
     for(Storage::const_iterator itr = storage.begin(); itr != storage.end(); ++itr)
         if(!itr-&gt;Meets(source,target,miscvalue))
@@ -741,7 +741,7 @@ void AchievementMgr::UpdateAchievementCriteria(AchievementCriteriaTypes type, ui
                 if (achievementCriteria-&gt;win_bg.additionalRequirement1_type)
                 {
                     // those requirements couldn't be found in the dbc
-                    AchievementCriteriaDataSet const* data = achievementmgr.GetCriteriaDataSet(achievementCriteria);
+                    AchievementCriteriaRequirementSet const* data = achievementmgr.GetCriteriaRequirementSet(achievementCriteria);
                     if (!data || !data-&gt;Meets(GetPlayer(),unit))
                         continue;
                 }
@@ -787,7 +787,7 @@ void AchievementMgr::UpdateAchievementCriteria(AchievementCriteriaTypes type, ui
                     continue;
 
                 // those requirements couldn't be found in the dbc
-                AchievementCriteriaDataSet const* data = achievementmgr.GetCriteriaDataSet(achievementCriteria);
+                AchievementCriteriaRequirementSet const* data = achievementmgr.GetCriteriaRequirementSet(achievementCriteria);
                 if(!data || !data-&gt;Meets(GetPlayer(),unit))
                     continue;
 
@@ -955,7 +955,7 @@ void AchievementMgr::UpdateAchievementCriteria(AchievementCriteriaTypes type, ui
                     continue;
 
                 // those requirements couldn't be found in the dbc
-                AchievementCriteriaDataSet const* data = achievementmgr.GetCriteriaDataSet(achievementCriteria);
+                AchievementCriteriaRequirementSet const* data = achievementmgr.GetCriteriaRequirementSet(achievementCriteria);
                 if(!data || !data-&gt;Meets(GetPlayer(),unit))
                     continue;
 
@@ -997,7 +997,7 @@ void AchievementMgr::UpdateAchievementCriteria(AchievementCriteriaTypes type, ui
                     case 1789:
                     {
                         // those requirements couldn't be found in the dbc
-                        AchievementCriteriaDataSet const* data = achievementmgr.GetCriteriaDataSet(achievementCriteria);
+                        AchievementCriteriaRequirementSet const* data = achievementmgr.GetCriteriaRequirementSet(achievementCriteria);
                         if(!data || !data-&gt;Meets(GetPlayer(),unit))
                             continue;
                         break;
@@ -1023,7 +1023,7 @@ void AchievementMgr::UpdateAchievementCriteria(AchievementCriteriaTypes type, ui
                     continue;
 
                 // those requirements couldn't be found in the dbc
-                AchievementCriteriaDataSet const* data = achievementmgr.GetCriteriaDataSet(achievementCriteria);
+                AchievementCriteriaRequirementSet const* data = achievementmgr.GetCriteriaRequirementSet(achievementCriteria);
                 if(!data)
                     continue;
 
@@ -1053,7 +1053,7 @@ void AchievementMgr::UpdateAchievementCriteria(AchievementCriteriaTypes type, ui
                 if(achievementCriteria-&gt;loot_type.lootTypeCount==1)
                 {
                     // those requirements couldn't be found in the dbc
-                    AchievementCriteriaDataSet const* data = achievementmgr.GetCriteriaDataSet(achievementCriteria);
+                    AchievementCriteriaRequirementSet const* data = achievementmgr.GetCriteriaRequirementSet(achievementCriteria);
                     if(!data || !data-&gt;Meets(GetPlayer(),unit))
                         continue;
                 }
@@ -1076,7 +1076,7 @@ void AchievementMgr::UpdateAchievementCriteria(AchievementCriteriaTypes type, ui
                 if(achievementCriteria-&gt;win_rated_arena.flag==ACHIEVEMENT_CRITERIA_CONDITION_NO_LOOSE)
                 {
                     // those requirements couldn't be found in the dbc
-                    AchievementCriteriaDataSet const* data = achievementmgr.GetCriteriaDataSet(achievementCriteria);
+                    AchievementCriteriaRequirementSet const* data = achievementmgr.GetCriteriaRequirementSet(achievementCriteria);
                     if(!data || !data-&gt;Meets(GetPlayer(),unit,miscvalue1))
                     {
                         // reset the progress as we have a win without the requirement.
@@ -1191,7 +1191,7 @@ void AchievementMgr::UpdateAchievementCriteria(AchievementCriteriaTypes type, ui
                 if(achievementCriteria-&gt;do_emote.count)
                 {
                     // those requirements couldn't be found in the dbc
-                    AchievementCriteriaDataSet const* data = achievementmgr.GetCriteriaDataSet(achievementCriteria);
+                    AchievementCriteriaRequirementSet const* data = achievementmgr.GetCriteriaRequirementSet(achievementCriteria);
                     if(!data || !data-&gt;Meets(GetPlayer(),unit))
                         continue;
                 }
@@ -1272,7 +1272,7 @@ void AchievementMgr::UpdateAchievementCriteria(AchievementCriteriaTypes type, ui
                 if (achievementCriteria-&gt;win_duel.duelCount)
                 {
                     // those requirements couldn't be found in the dbc
-                    AchievementCriteriaDataSet const* data = achievementmgr.GetCriteriaDataSet(achievementCriteria);
+                    AchievementCriteriaRequirementSet const* data = achievementmgr.GetCriteriaRequirementSet(achievementCriteria);
                     if (!data)
                         continue;
 
@@ -1848,11 +1848,11 @@ void AchievementGlobalMgr::LoadAchievementReferenceList()
     sLog.outString(&quot;&gt;&gt; Loaded %u achievement references.&quot;,count);
 }
 
-void AchievementGlobalMgr::LoadAchievementCriteriaData()
+void AchievementGlobalMgr::LoadAchievementCriteriaRequirements()
 {
-    m_criteriaDataMap.clear();                              // need for reload case
+    m_criteriaRequirementMap.clear();                       // need for reload case
 
-    QueryResult *result = WorldDatabase.Query(&quot;SELECT criteria_id, type, value1, value2 FROM achievement_criteria_data&quot;);
+    QueryResult *result = WorldDatabase.Query(&quot;SELECT criteria_id, type, value1, value2 FROM achievement_criteria_requirement&quot;);
 
     if(!result)
     {
@@ -1860,7 +1860,7 @@ void AchievementGlobalMgr::LoadAchievementCriteriaData()
         bar.step();
 
         sLog.outString();
-        sLog.outString(&quot;&gt;&gt; Loaded 0 additional achievement criteria data. DB table `achievement_criteria_data` is empty.&quot;);
+        sLog.outString(&quot;&gt;&gt; Loaded 0 additional achievement criteria data. DB table `achievement_criteria_requirement` is empty.&quot;);
         return;
     }
 
@@ -1877,11 +1877,11 @@ void AchievementGlobalMgr::LoadAchievementCriteriaData()
 
         if (!criteria)
         {
-            sLog.outErrorDb( &quot;Table `achievement_criteria_data` have data for not existed criteria (Entry: %u), ignore.&quot;, criteria_id);
+            sLog.outErrorDb( &quot;Table `achievement_criteria_requirement` have data for not existed criteria (Entry: %u), ignore.&quot;, criteria_id);
             continue;
         }
 
-        AchievementCriteriaData data(fields[1].GetUInt32(),fields[2].GetUInt32(),fields[3].GetUInt32());
+        AchievementCriteriaRequirement data(fields[1].GetUInt32(),fields[2].GetUInt32(),fields[3].GetUInt32());
 
         if (!data.IsValid(criteria))
         {
@@ -1889,16 +1889,17 @@ void AchievementGlobalMgr::LoadAchievementCriteriaData()
         }
 
         // this will allocate empty data set storage
-        AchievementCriteriaDataSet&amp; dataSet = m_criteriaDataMap[criteria_id];
+        AchievementCriteriaRequirementSet&amp; dataSet = m_criteriaRequirementMap[criteria_id];
 
-        if (data.dataType == ACHIEVEMENT_CRITERIA_DATA_TYPE_DISABLED)
+        // counting disable criteria requirements
+        if (data.requirementType == ACHIEVEMENT_CRITERIA_REQUIRE_DISABLED)
             ++disabled_count;
 
-        // add real data only for not NONE data types
-        if (data.dataType != ACHIEVEMENT_CRITERIA_DATA_TYPE_NONE)
+        // add real data only for not NONE requirements
+        if (data.requirementType != ACHIEVEMENT_CRITERIA_REQUIRE_NONE)
             dataSet.Add(data);
 
-        // counting data by and data types
+        // counting requirements
         ++count;
     } while(result-&gt;NextRow());
 
@@ -1965,8 +1966,8 @@ void AchievementGlobalMgr::LoadAchievementCriteriaData()
                 continue;
         }
 
-        if(!GetCriteriaDataSet(criteria))
-            sLog.outErrorDb( &quot;Table `achievement_criteria_data` not have expected data for criteria (Entry: %u Type: %u) for achievement %u.&quot;, criteria-&gt;ID, criteria-&gt;requiredType, criteria-&gt;referredAchievement);
+        if(!GetCriteriaRequirementSet(criteria))
+            sLog.outErrorDb( &quot;Table `achievement_criteria_requirement` not have expected data for criteria (Entry: %u Type: %u) for achievement %u.&quot;, criteria-&gt;ID, criteria-&gt;requiredType, criteria-&gt;referredAchievement);
     }
 
     sLog.outString();</diff>
      <filename>src/game/AchievementMgr.cpp</filename>
    </modified>
    <modified>
      <diff>@@ -40,114 +40,114 @@ struct CriteriaProgress
     bool changed;
 };
 
-enum AchievementCriteriaDataType
+enum AchievementCriteriaRequirementType
 {                                                           // value1         value2        comment
-    ACHIEVEMENT_CRITERIA_DATA_TYPE_NONE                = 0, // 0              0
-    ACHIEVEMENT_CRITERIA_DATA_TYPE_T_CREATURE          = 1, // creature_id    0
-    ACHIEVEMENT_CRITERIA_DATA_TYPE_T_PLAYER_CLASS_RACE = 2, // class_id       race_id
-    ACHIEVEMENT_CRITERIA_DATA_TYPE_T_PLAYER_LESS_HEALTH= 3, // health_percent 0
-    ACHIEVEMENT_CRITERIA_DATA_TYPE_T_PLAYER_DEAD       = 4, // own_team       0             not corpse (not released body), own_team==false if enemy team expected
-    ACHIEVEMENT_CRITERIA_DATA_TYPE_S_AURA              = 5, // spell_id       effect_idx
-    ACHIEVEMENT_CRITERIA_DATA_TYPE_S_AREA              = 6, // area id        0
-    ACHIEVEMENT_CRITERIA_DATA_TYPE_T_AURA              = 7, // spell_id       effect_idx
-    ACHIEVEMENT_CRITERIA_DATA_TYPE_VALUE               = 8, // minvalue                     value provided with achievement update must be not less that limit
-    ACHIEVEMENT_CRITERIA_DATA_TYPE_T_LEVEL             = 9, // minlevel                     minlevel of target
-    ACHIEVEMENT_CRITERIA_DATA_TYPE_T_GENDER            = 10,// gender                       0=male; 1=female
-    ACHIEVEMENT_CRITERIA_DATA_TYPE_DISABLED            = 11,//                              used to prevent achievement creteria complete if not all requirement implemented and listed in table
-    ACHIEVEMENT_CRITERIA_DATA_TYPE_MAP_DIFFICULTY      = 12,// difficulty                   normal/heroic difficulty for current event map
-    ACHIEVEMENT_CRITERIA_DATA_TYPE_MAP_PLAYER_COUNT    = 13,// count                        &quot;with less than %u people in the zone&quot;
-    ACHIEVEMENT_CRITERIA_DATA_TYPE_T_TEAM              = 14,// team                         HORDE(67), ALLIANCE(469)
-    ACHIEVEMENT_CRITERIA_DATA_TYPE_S_DRUNK             = 15,// drunken_state  0             (enum DrunkenState) of player
-    ACHIEVEMENT_CRITERIA_DATA_TYPE_HOLIDAY             = 16,// holiday_id     0             event in holiday time
-    ACHIEVEMENT_CRITERIA_DATA_TYPE_BG_LOSS_TEAM_SCORE  = 17,// min_score      max_score     player's team win bg and opposition team have team score in range
+    ACHIEVEMENT_CRITERIA_REQUIRE_NONE                = 0,   // 0              0
+    ACHIEVEMENT_CRITERIA_REQUIRE_T_CREATURE          = 1,   // creature_id    0
+    ACHIEVEMENT_CRITERIA_REQUIRE_T_PLAYER_CLASS_RACE = 2,   // class_id       race_id
+    ACHIEVEMENT_CRITERIA_REQUIRE_T_PLAYER_LESS_HEALTH= 3,   // health_percent 0
+    ACHIEVEMENT_CRITERIA_REQUIRE_T_PLAYER_DEAD       = 4,   // own_team       0             not corpse (not released body), own_team==false if enemy team expected
+    ACHIEVEMENT_CRITERIA_REQUIRE_S_AURA              = 5,   // spell_id       effect_idx
+    ACHIEVEMENT_CRITERIA_REQUIRE_S_AREA              = 6,   // area id        0
+    ACHIEVEMENT_CRITERIA_REQUIRE_T_AURA              = 7,   // spell_id       effect_idx
+    ACHIEVEMENT_CRITERIA_REQUIRE_VALUE               = 8,   // minvalue                     value provided with achievement update must be not less that limit
+    ACHIEVEMENT_CRITERIA_REQUIRE_T_LEVEL             = 9,   // minlevel                     minlevel of target
+    ACHIEVEMENT_CRITERIA_REQUIRE_T_GENDER            = 10,  // gender                       0=male; 1=female
+    ACHIEVEMENT_CRITERIA_REQUIRE_DISABLED            = 11,  //                              used to prevent achievement creteria complete if not all requirement implemented and listed in table
+    ACHIEVEMENT_CRITERIA_REQUIRE_MAP_DIFFICULTY      = 12,  // difficulty                   normal/heroic difficulty for current event map
+    ACHIEVEMENT_CRITERIA_REQUIRE_MAP_PLAYER_COUNT    = 13,  // count                        &quot;with less than %u people in the zone&quot;
+    ACHIEVEMENT_CRITERIA_REQUIRE_T_TEAM              = 14,  // team                         HORDE(67), ALLIANCE(469)
+    ACHIEVEMENT_CRITERIA_REQUIRE_S_DRUNK             = 15,  // drunken_state  0             (enum DrunkenState) of player
+    ACHIEVEMENT_CRITERIA_REQUIRE_HOLIDAY             = 16,  // holiday_id     0             event in holiday time
+    ACHIEVEMENT_CRITERIA_REQUIRE_BG_LOSS_TEAM_SCORE  = 17,  // min_score      max_score     player's team win bg and opposition team have team score in range
 };
 
-#define MAX_ACHIEVEMENT_CRITERIA_DATA_TYPE               18 // maximum value in AchievementCriteriaDataType enum
+#define MAX_ACHIEVEMENT_CRITERIA_REQUIREMENT_TYPE      18 // maximum value in AchievementCriteriaRequirementType enum
 
 class Player;
 class Unit;
 
-struct AchievementCriteriaData
+struct AchievementCriteriaRequirement
 {
-    AchievementCriteriaDataType dataType;
+    AchievementCriteriaRequirementType requirementType;
     union
     {
-        // ACHIEVEMENT_CRITERIA_DATA_TYPE_NONE              = 0 (no data)
-        // ACHIEVEMENT_CRITERIA_DATA_TYPE_T_CREATURE        = 1
+        // ACHIEVEMENT_CRITERIA_REQUIRE_NONE              = 0 (no data)
+        // ACHIEVEMENT_CRITERIA_REQUIRE_T_CREATURE        = 1
         struct
         {
             uint32 id;
         } creature;
-        // ACHIEVEMENT_CRITERIA_DATA_TYPE_T_PLAYER_CLASS_RACE = 2
+        // ACHIEVEMENT_CRITERIA_REQUIRE_T_PLAYER_CLASS_RACE = 2
         struct
         {
             uint32 class_id;
             uint32 race_id;
         } classRace;
-        // ACHIEVEMENT_CRITERIA_DATA_TYPE_T_PLAYER_LESS_HEALTH = 3
+        // ACHIEVEMENT_CRITERIA_REQUIRE_T_PLAYER_LESS_HEALTH = 3
         struct
         {
             uint32 percent;
         } health;
-        // ACHIEVEMENT_CRITERIA_DATA_TYPE_T_PLAYER_DEAD     = 4
+        // ACHIEVEMENT_CRITERIA_REQUIRE_T_PLAYER_DEAD     = 4
         struct
         {
             uint32 own_team_flag;
         } player_dead;
-        // ACHIEVEMENT_CRITERIA_DATA_TYPE_S_AURA            = 5
-        // ACHIEVEMENT_CRITERIA_DATA_TYPE_T_AURA            = 7
+        // ACHIEVEMENT_CRITERIA_REQUIRE_S_AURA            = 5
+        // ACHIEVEMENT_CRITERIA_REQUIRE_T_AURA            = 7
         struct
         {
             uint32 spell_id;
             uint32 effect_idx;
         } aura;
-        // ACHIEVEMENT_CRITERIA_DATA_TYPE_S_AREA            = 6
+        // ACHIEVEMENT_CRITERIA_REQUIRE_S_AREA            = 6
         struct
         {
             uint32 id;
         } area;
-        // ACHIEVEMENT_CRITERIA_DATA_TYPE_VALUE             = 8
+        // ACHIEVEMENT_CRITERIA_REQUIRE_VALUE             = 8
         struct
         {
             uint32 minvalue;
         } value;
-        // ACHIEVEMENT_CRITERIA_DATA_TYPE_T_LEVEL           = 9
+        // ACHIEVEMENT_CRITERIA_REQUIRE_T_LEVEL           = 9
         struct
         {
             uint32 minlevel;
         } level;
-        // ACHIEVEMENT_CRITERIA_DATA_TYPE_T_GENDER          = 10
+        // ACHIEVEMENT_CRITERIA_REQUIRE_T_GENDER          = 10
         struct
         {
             uint32 gender;
         } gender;
-        // ACHIEVEMENT_CRITERIA_DATA_TYPE_DISABLED          = 11 (no data)
-        // ACHIEVEMENT_CRITERIA_DATA_TYPE_MAP_DIFFICULTY    = 12
+        // ACHIEVEMENT_CRITERIA_REQUIRE_DISABLED          = 11 (no data)
+        // ACHIEVEMENT_CRITERIA_REQUIRE_MAP_DIFFICULTY    = 12
         struct
         {
-            uint32 difficalty;
-        } difficalty;
-        // ACHIEVEMENT_CRITERIA_DATA_TYPE_MAP_PLAYER_COUNT  = 13
+            uint32 difficulty;
+        } difficulty;
+        // ACHIEVEMENT_CRITERIA_REQUIRE_MAP_PLAYER_COUNT  = 13
         struct
         {
             uint32 maxcount;
         } map_players;
-        // ACHIEVEMENT_CRITERIA_DATA_TYPE_T_TEAM            = 14
+        // ACHIEVEMENT_CRITERIA_REQUIRE_T_TEAM            = 14
         struct
         {
             uint32 team;
         } team;
-        // ACHIEVEMENT_CRITERIA_DATA_TYPE_S_DRUNK           = 15
+        // ACHIEVEMENT_CRITERIA_REQUIRE_S_DRUNK           = 15
         struct
         {
             uint32 state;
         } drunk;
-        // ACHIEVEMENT_CRITERIA_DATA_TYPE_HOLIDAY           = 16
+        // ACHIEVEMENT_CRITERIA_REQUIRE_HOLIDAY           = 16
         struct
         {
             uint32 id;
         } holiday;
-        // ACHIEVEMENT_CRITERIA_DATA_TYPE_BG_LOSS_TEAM_SCORE= 17
+        // ACHIEVEMENT_CRITERIA_REQUIRE_BG_LOSS_TEAM_SCORE= 17
         struct
         {
             uint32 min_score;
@@ -161,13 +161,14 @@ struct AchievementCriteriaData
         } raw;
     };
 
-    AchievementCriteriaData() : dataType(ACHIEVEMENT_CRITERIA_DATA_TYPE_NONE)
+    AchievementCriteriaRequirement() : requirementType(ACHIEVEMENT_CRITERIA_REQUIRE_NONE)
     {
         raw.value1 = 0;
         raw.value2 = 0;
     }
 
-    AchievementCriteriaData(uint32 _dataType, uint32 _value1, uint32 _value2) : dataType(AchievementCriteriaDataType(_dataType))
+    AchievementCriteriaRequirement(uint32 reqType, uint32 _value1, uint32 _value2)
+        : requirementType(AchievementCriteriaRequirementType(reqType))
     {
         raw.value1 = _value1;
         raw.value2 = _value2;
@@ -177,17 +178,16 @@ struct AchievementCriteriaData
     bool Meets(Player const* source, Unit const* target, uint32 miscvalue1 = 0) const;
 };
 
-struct AchievementCriteriaDataSet
+struct AchievementCriteriaRequirementSet
 {
-        typedef std::vector&lt;AchievementCriteriaData&gt; Storage;
-        void Add(AchievementCriteriaData const&amp; data) { storage.push_back(data); }
+        typedef std::vector&lt;AchievementCriteriaRequirement&gt; Storage;
+        void Add(AchievementCriteriaRequirement const&amp; data) { storage.push_back(data); }
         bool Meets(Player const* source, Unit const* target, uint32 miscvalue = 0) const;
     private:
         Storage storage;
 };
 
-
-typedef std::map&lt;uint32,AchievementCriteriaDataSet&gt; AchievementCriteriaDataMap;
+typedef std::map&lt;uint32,AchievementCriteriaRequirementSet&gt; AchievementCriteriaRequirementMap;
 
 struct AchievementReward
 {
@@ -284,10 +284,10 @@ class AchievementGlobalMgr
             return iter!=m_achievementRewardLocales.end() ? &amp;iter-&gt;second : NULL;
         }
 
-        AchievementCriteriaDataSet const* GetCriteriaDataSet(AchievementCriteriaEntry const *achievementCriteria)
+        AchievementCriteriaRequirementSet const* GetCriteriaRequirementSet(AchievementCriteriaEntry const *achievementCriteria)
         {
-            AchievementCriteriaDataMap::const_iterator iter = m_criteriaDataMap.find(achievementCriteria-&gt;ID);
-            return iter!=m_criteriaDataMap.end() ? &amp;iter-&gt;second : NULL;
+            AchievementCriteriaRequirementMap::const_iterator iter = m_criteriaRequirementMap.find(achievementCriteria-&gt;ID);
+            return iter!=m_criteriaRequirementMap.end() ? &amp;iter-&gt;second : NULL;
         }
 
         bool IsRealmCompleted(AchievementEntry const* achievement) const
@@ -301,13 +301,13 @@ class AchievementGlobalMgr
         }
 
         void LoadAchievementCriteriaList();
-        void LoadAchievementCriteriaData();
+        void LoadAchievementCriteriaRequirements();
         void LoadAchievementReferenceList();
         void LoadCompletedAchievements();
         void LoadRewards();
         void LoadRewardLocales();
     private:
-        AchievementCriteriaDataMap m_criteriaDataMap;
+        AchievementCriteriaRequirementMap m_criteriaRequirementMap;
 
         // store achievement criterias by type to speed up lookup
         AchievementCriteriaEntryList m_AchievementCriteriasByType[ACHIEVEMENT_CRITERIA_TYPE_TOTAL];</diff>
      <filename>src/game/AchievementMgr.h</filename>
    </modified>
    <modified>
      <diff>@@ -395,7 +395,7 @@ ChatCommand * ChatHandler::getCommandTable()
 
         { &quot;config&quot;,         SEC_ADMINISTRATOR,  true,  &amp;ChatHandler::HandleReloadConfigCommand,        &quot;&quot;, NULL },
 
-        { &quot;achievement_criteria_data&quot;,   SEC_ADMINISTRATOR, true,  &amp;ChatHandler::HandleReloadAchievementCriteriaDataCommand, &quot;&quot;, NULL },
+        { &quot;achievement_criteria_requirement&quot;,SEC_ADMINISTRATOR,true,&amp;ChatHandler::HandleReloadAchievementCriteriaRequirementCommand,&quot;&quot;,NULL },
         { &quot;achievement_reward&quot;,          SEC_ADMINISTRATOR, true,  &amp;ChatHandler::HandleReloadAchievementRewardCommand,       &quot;&quot;, NULL },
         { &quot;areatrigger_involvedrelation&quot;,SEC_ADMINISTRATOR, true,  &amp;ChatHandler::HandleReloadQuestAreaTriggersCommand,       &quot;&quot;, NULL },
         { &quot;areatrigger_tavern&quot;,          SEC_ADMINISTRATOR, true,  &amp;ChatHandler::HandleReloadAreaTriggerTavernCommand,       &quot;&quot;, NULL },</diff>
      <filename>src/game/Chat.cpp</filename>
    </modified>
    <modified>
      <diff>@@ -317,7 +317,7 @@ class ChatHandler
 
         bool HandleReloadConfigCommand(const char* args);
 
-        bool HandleReloadAchievementCriteriaDataCommand(const char* args);
+        bool HandleReloadAchievementCriteriaRequirementCommand(const char* args);
         bool HandleReloadAchievementRewardCommand(const char* args);
         bool HandleReloadAreaTriggerTavernCommand(const char* args);
         bool HandleReloadAreaTriggerTeleportCommand(const char* args);</diff>
      <filename>src/game/Chat.h</filename>
    </modified>
    <modified>
      <diff>@@ -75,7 +75,7 @@ bool ChatHandler::HandleReloadAllCommand(const char*)
 
 bool ChatHandler::HandleReloadAllAchievementCommand(const char*)
 {
-    HandleReloadAchievementCriteriaDataCommand(&quot;&quot;);
+    HandleReloadAchievementCriteriaRequirementCommand(&quot;&quot;);
     HandleReloadAchievementRewardCommand(&quot;&quot;);
     return true;
 }
@@ -195,11 +195,11 @@ bool ChatHandler::HandleReloadConfigCommand(const char* /*args*/)
     return true;
 }
 
-bool ChatHandler::HandleReloadAchievementCriteriaDataCommand(const char*)
+bool ChatHandler::HandleReloadAchievementCriteriaRequirementCommand(const char*)
 {
-    sLog.outString( &quot;Re-Loading Additional Achievement Criteria Data...&quot; );
-    achievementmgr.LoadAchievementCriteriaData();
-    SendGlobalSysMessage(&quot;DB table `achievement_criteria_data` reloaded.&quot;);
+    sLog.outString( &quot;Re-Loading Additional Achievement Criteria Requirements Data...&quot; );
+    achievementmgr.LoadAchievementCriteriaRequirements();
+    SendGlobalSysMessage(&quot;DB table `achievement_criteria_requirement` reloaded.&quot;);
     return true;
 }
 </diff>
      <filename>src/game/Level3.cpp</filename>
    </modified>
    <modified>
      <diff>@@ -1343,7 +1343,7 @@ void World::SetInitialWorldSettings()
     sLog.outString();
     achievementmgr.LoadAchievementReferenceList();
     achievementmgr.LoadAchievementCriteriaList();
-    achievementmgr.LoadAchievementCriteriaData();
+    achievementmgr.LoadAchievementCriteriaRequirements();
     achievementmgr.LoadRewards();
     achievementmgr.LoadRewardLocales();
     achievementmgr.LoadCompletedAchievements();</diff>
      <filename>src/game/World.cpp</filename>
    </modified>
    <modified>
      <diff>@@ -1,4 +1,4 @@
 #ifndef __REVISION_NR_H__
 #define __REVISION_NR_H__
- #define REVISION_NR &quot;8722&quot;
+ #define REVISION_NR &quot;8723&quot;
 #endif // __REVISION_NR_H__</diff>
      <filename>src/shared/revision_nr.h</filename>
    </modified>
    <modified>
      <diff>@@ -1,6 +1,6 @@
 #ifndef __REVISION_SQL_H__
 #define __REVISION_SQL_H__
  #define REVISION_DB_CHARACTERS &quot;required_8721_01_characters_guild&quot;
- #define REVISION_DB_MANGOS &quot;required_8720_01_mangos_quest_template&quot;
+ #define REVISION_DB_MANGOS &quot;required_8723_01_mangos_achievement_criteria_requirement&quot;
  #define REVISION_DB_REALMD &quot;required_8332_01_realmd_realmcharacters&quot;
 #endif // __REVISION_SQL_H__</diff>
      <filename>src/shared/revision_sql.h</filename>
    </modified>
  </modified>
  <removed type="array"/>
  <parents type="array">
    <parent>
      <id>3ad46591d4e03f1aabe0c2f0f40a2045aa647511</id>
    </parent>
  </parents>
  <author>
    <name>ApoC</name>
    <email>apoc@nymfe.net</email>
  </author>
  <url>http://github.com/apoc/mangos/commit/b6b94944059ce04c2471a73c3b85543155b519e7</url>
  <id>b6b94944059ce04c2471a73c3b85543155b519e7</id>
  <committed-date>2009-10-24T16:01:06-07:00</committed-date>
  <authored-date>2009-10-24T16:01:06-07:00</authored-date>
  <message>[8723] Rename table `achievement_criteria_data` =&gt; `achievement_criteria_requirement`

And make related renames in code for types, variables and functions.
To make more clear difference achievement createria type from old achievment criteria data type
in DB and code.

Conflicts:

	sql/mangos.sql
	src/game/AchievementMgr.cpp
	src/game/AchievementMgr.h

Signed-off-by: ApoC &lt;apoc@nymfe.net&gt;</message>
  <tree>57a6067b400468c763d0480db696cdd4cf90f60e</tree>
  <committer>
    <name>ApoC</name>
    <email>apoc@nymfe.net</email>
  </committer>
</commit>
