src/game/AchievementMgr.h

   1 /*
   2  * Copyright (C) 2005-2009 MaNGOS <http://getmangos.com/>
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17  */
  18 #ifndef __MANGOS_ACHIEVEMENTMGR_H
  19 #define __MANGOS_ACHIEVEMENTMGR_H
  20
  21 #include "Common.h"
  22 #include "Policies/Singleton.h"
  23 #include "Database/DatabaseEnv.h"
  24 #include "DBCEnums.h"
  25 #include "DBCStores.h"
  26
  27 #include <map>
  28 #include <string>
  29
  30 typedef std::list<AchievementCriteriaEntry const*> AchievementCriteriaEntryList;
  31 typedef std::list<AchievementEntry const*>         AchievementEntryList;
  32
  33 typedef std::map<uint32,AchievementCriteriaEntryList> AchievementCriteriaListByAchievement;
  34 typedef std::map<uint32,AchievementEntryList>         AchievementListByReferencedId;
  35
  36 struct CriteriaProgress
  37 {
  38     uint32 counter;
  39     time_t date;
  40     bool changed;
  41 };
  42
  43 enum AchievementCriteriaDataType
  44 {                                                           // value1         value2        comment
  45     ACHIEVEMENT_CRITERIA_DATA_TYPE_NONE                = 0, // 0              0
  46     ACHIEVEMENT_CRITERIA_DATA_TYPE_T_CREATURE          = 1, // creature_id    0
  47     ACHIEVEMENT_CRITERIA_DATA_TYPE_T_PLAYER_CLASS_RACE = 2, // class_id       race_id
  48     ACHIEVEMENT_CRITERIA_DATA_TYPE_T_PLAYER_LESS_HEALTH= 3, // health_percent 0
  49     ACHIEVEMENT_CRITERIA_DATA_TYPE_T_PLAYER_DEAD       = 4, // own_team       0             not corpse (not released body), own_team==false if enemy team expected
  50     ACHIEVEMENT_CRITERIA_DATA_TYPE_S_AURA              = 5, // spell_id       effect_idx
  51     ACHIEVEMENT_CRITERIA_DATA_TYPE_S_AREA              = 6, // area id        0
  52     ACHIEVEMENT_CRITERIA_DATA_TYPE_T_AURA              = 7, // spell_id       effect_idx
  53     ACHIEVEMENT_CRITERIA_DATA_TYPE_VALUE               = 8, // minvalue                     value provided with achievement update must be not less that limit
  54     ACHIEVEMENT_CRITERIA_DATA_TYPE_T_LEVEL             = 9, // minlevel                     minlevel of target
  55     ACHIEVEMENT_CRITERIA_DATA_TYPE_T_GENDER            = 10,// gender                       0=male; 1=female
  56     ACHIEVEMENT_CRITERIA_DATA_TYPE_DISABLED            = 11,//                              used to prevent achievement creteria complete if not all requirement implemented and listed in table
  57     ACHIEVEMENT_CRITERIA_DATA_TYPE_MAP_DIFFICULTY      = 12,// difficulty                   normal/heroic difficulty for current event map
  58     ACHIEVEMENT_CRITERIA_DATA_TYPE_MAP_PLAYER_COUNT    = 13,// count                        "with less than %u people in the zone"
  59     ACHIEVEMENT_CRITERIA_DATA_TYPE_T_TEAM              = 14,// team                         HORDE(67), ALLIANCE(469)
  60     ACHIEVEMENT_CRITERIA_DATA_TYPE_S_DRUNK             = 15,// drunken_state  0             (enum DrunkenState) of player
  61     ACHIEVEMENT_CRITERIA_DATA_TYPE_HOLIDAY             = 16,// holiday_id     0             event in holiday time
  62     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
  63 };
  64
  65 #define MAX_ACHIEVEMENT_CRITERIA_DATA_TYPE               18 // maximum value in AchievementCriteriaDataType enum
  66
  67 class Player;
  68 class Unit;
  69
  70 struct AchievementCriteriaData
  71 {
  72     AchievementCriteriaDataType dataType;
  73     union
  74     {
  75         // ACHIEVEMENT_CRITERIA_DATA_TYPE_NONE              = 0 (no data)
  76         // ACHIEVEMENT_CRITERIA_DATA_TYPE_T_CREATURE        = 1
  77         struct
  78         {
  79             uint32 id;
  80         } creature;
  81         // ACHIEVEMENT_CRITERIA_DATA_TYPE_T_PLAYER_CLASS_RACE = 2
  82         struct
  83         {
  84             uint32 class_id;
  85             uint32 race_id;
  86         } classRace;
  87         // ACHIEVEMENT_CRITERIA_DATA_TYPE_T_PLAYER_LESS_HEALTH = 3
  88         struct
  89         {
  90             uint32 percent;
  91         } health;
  92         // ACHIEVEMENT_CRITERIA_DATA_TYPE_T_PLAYER_DEAD     = 4
  93         struct
  94         {
  95             uint32 own_team_flag;
  96         } player_dead;
  97         // ACHIEVEMENT_CRITERIA_DATA_TYPE_S_AURA            = 5
  98         // ACHIEVEMENT_CRITERIA_DATA_TYPE_T_AURA            = 7
  99         struct
 100         {
 101             uint32 spell_id;
 102             uint32 effect_idx;
 103         } aura;
 104         // ACHIEVEMENT_CRITERIA_DATA_TYPE_S_AREA            = 6
 105         struct
 106         {
 107             uint32 id;
 108         } area;
 109         // ACHIEVEMENT_CRITERIA_DATA_TYPE_VALUE             = 8
 110         struct
 111         {
 112             uint32 minvalue;
 113         } value;
 114         // ACHIEVEMENT_CRITERIA_DATA_TYPE_T_LEVEL           = 9
 115         struct
 116         {
 117             uint32 minlevel;
 118         } level;
 119         // ACHIEVEMENT_CRITERIA_DATA_TYPE_T_GENDER          = 10
 120         struct
 121         {
 122             uint32 gender;
 123         } gender;
 124         // ACHIEVEMENT_CRITERIA_DATA_TYPE_DISABLED          = 11 (no data)
 125         // ACHIEVEMENT_CRITERIA_DATA_TYPE_MAP_DIFFICULTY    = 12
 126         struct
 127         {
 128             uint32 difficalty;
 129         } difficalty;
 130         // ACHIEVEMENT_CRITERIA_DATA_TYPE_MAP_PLAYER_COUNT  = 13
 131         struct
 132         {
 133             uint32 maxcount;
 134         } map_players;
 135         // ACHIEVEMENT_CRITERIA_DATA_TYPE_T_TEAM            = 14
 136         struct
 137         {
 138             uint32 team;
 139         } team;
 140         // ACHIEVEMENT_CRITERIA_DATA_TYPE_S_DRUNK           = 15
 141         struct
 142         {
 143             uint32 state;
 144         } drunk;
 145         // ACHIEVEMENT_CRITERIA_DATA_TYPE_HOLIDAY           = 16
 146         struct
 147         {
 148             uint32 id;
 149         } holiday;
 150         // ACHIEVEMENT_CRITERIA_DATA_TYPE_BG_LOSS_TEAM_SCORE= 17
 151         struct
 152         {
 153             uint32 min_score;
 154             uint32 max_score;
 155         } bg_loss_team_score;
 156         // ...
 157         struct
 158         {
 159             uint32 value1;
 160             uint32 value2;
 161         } raw;
 162     };
 163
 164     AchievementCriteriaData() : dataType(ACHIEVEMENT_CRITERIA_DATA_TYPE_NONE)
 165     {
 166         raw.value1 = 0;
 167         raw.value2 = 0;
 168     }
 169
 170     AchievementCriteriaData(uint32 _dataType, uint32 _value1, uint32 _value2) : dataType(AchievementCriteriaDataType(_dataType))
 171     {
 172         raw.value1 = _value1;
 173         raw.value2 = _value2;
 174     }
 175
 176     bool IsValid(AchievementCriteriaEntry const* criteria);
 177     bool Meets(Player const* source, Unit const* target, uint32 miscvalue1 = 0) const;
 178 };
 179
 180 struct AchievementCriteriaDataSet
 181 {
 182         typedef std::vector<AchievementCriteriaData> Storage;
 183         void Add(AchievementCriteriaData const& data) { storage.push_back(data); }
 184         bool Meets(Player const* source, Unit const* target, uint32 miscvalue = 0) const;
 185     private:
 186         Storage storage;
 187 };
 188
 189
 190 typedef std::map<uint32,AchievementCriteriaDataSet> AchievementCriteriaDataMap;
 191
 192 struct AchievementReward
 193 {
 194     uint32 titleId[2];
 195     uint32 itemId;
 196     uint32 sender;
 197     std::string subject;
 198     std::string text;
 199 };
 200
 201 typedef std::map<uint32,AchievementReward> AchievementRewards;
 202
 203 struct AchievementRewardLocale
 204 {
 205     std::vector<std::string> subject;
 206     std::vector<std::string> text;
 207 };
 208
 209 typedef std::map<uint32,AchievementRewardLocale> AchievementRewardLocales;
 210
 211
 212 struct CompletedAchievementData
 213 {
 214     time_t date;
 215     bool changed;
 216 };
 217
 218 typedef UNORDERED_MAP<uint32, CriteriaProgress> CriteriaProgressMap;
 219 typedef UNORDERED_MAP<uint32, CompletedAchievementData> CompletedAchievementMap;
 220
 221 class Unit;
 222 class Player;
 223 class WorldPacket;
 224
 225 class AchievementMgr
 226 {
 227     public:
 228         AchievementMgr(Player* pl);
 229         ~AchievementMgr();
 230
 231         void Reset();
 232         static void DeleteFromDB(uint32 lowguid);
 233         void LoadFromDB(QueryResult *achievementResult, QueryResult *criteriaResult);
 234         void SaveToDB();
 235         void ResetAchievementCriteria(AchievementCriteriaTypes type, uint32 miscvalue1=0, uint32 miscvalue2=0);
 236         void UpdateAchievementCriteria(AchievementCriteriaTypes type, uint32 miscvalue1=0, uint32 miscvalue2=0, Unit *unit=NULL, uint32 time=0);
 237         void CheckAllAchievementCriteria();
 238         void SendAllAchievementData();
 239         void SendRespondInspectAchievements(Player* player);
 240         Player* GetPlayer() { return m_player;}
 241
 242     private:
 243         enum ProgressType { PROGRESS_SET, PROGRESS_ACCUMULATE, PROGRESS_HIGHEST };
 244         void SendAchievementEarned(AchievementEntry const* achievement);
 245         void SendCriteriaUpdate(uint32 id, CriteriaProgress const* progress);
 246         void SetCriteriaProgress(AchievementCriteriaEntry const* entry, uint32 changeValue, ProgressType ptype = PROGRESS_SET);
 247         void CompletedCriteriaFor(AchievementEntry const* achievement);
 248         void CompletedAchievement(AchievementEntry const* entry);
 249         bool IsCompletedCriteria(AchievementCriteriaEntry const* criteria, AchievementEntry const* achievement);
 250         bool IsCompletedAchievement(AchievementEntry const* entry);
 251         void CompleteAchievementsWithRefs(AchievementEntry const* entry);
 252         void BuildAllDataPacket(WorldPacket *data);
 253
 254         Player* m_player;
 255         CriteriaProgressMap m_criteriaProgress;
 256         CompletedAchievementMap m_completedAchievements;
 257 };
 258
 259 class AchievementGlobalMgr
 260 {
 261     public:
 262         AchievementCriteriaEntryList const& GetAchievementCriteriaByType(AchievementCriteriaTypes type);
 263         AchievementCriteriaEntryList const* GetAchievementCriteriaByAchievement(uint32 id)
 264         {
 265             AchievementCriteriaListByAchievement::const_iterator itr = m_AchievementCriteriaListByAchievement.find(id);
 266             return itr != m_AchievementCriteriaListByAchievement.end() ? &itr->second : NULL;
 267         }
 268
 269         AchievementEntryList const* GetAchievementByReferencedId(uint32 id) const
 270         {
 271             AchievementListByReferencedId::const_iterator itr = m_AchievementListByReferencedId.find(id);
 272             return itr != m_AchievementListByReferencedId.end() ? &itr->second : NULL;
 273         }
 274
 275         AchievementReward const* GetAchievementReward(AchievementEntry const* achievement) const
 276         {
 277             AchievementRewards::const_iterator iter = m_achievementRewards.find(achievement->ID);
 278             return iter!=m_achievementRewards.end() ? &iter->second : NULL;
 279         }
 280
 281         AchievementRewardLocale const* GetAchievementRewardLocale(AchievementEntry const* achievement) const
 282         {
 283             AchievementRewardLocales::const_iterator iter = m_achievementRewardLocales.find(achievement->ID);
 284             return iter!=m_achievementRewardLocales.end() ? &iter->second : NULL;
 285         }
 286
 287         AchievementCriteriaDataSet const* GetCriteriaDataSet(AchievementCriteriaEntry const *achievementCriteria)
 288         {
 289             AchievementCriteriaDataMap::const_iterator iter = m_criteriaDataMap.find(achievementCriteria->ID);
 290             return iter!=m_criteriaDataMap.end() ? &iter->second : NULL;
 291         }
 292
 293         bool IsRealmCompleted(AchievementEntry const* achievement) const
 294         {
 295             return m_allCompletedAchievements.find(achievement->ID) != m_allCompletedAchievements.end();
 296         }
 297
 298         void SetRealmCompleted(AchievementEntry const* achievement)
 299         {
 300             m_allCompletedAchievements.insert(achievement->ID);
 301         }
 302
 303         void LoadAchievementCriteriaList();
 304         void LoadAchievementCriteriaData();
 305         void LoadAchievementReferenceList();
 306         void LoadCompletedAchievements();
 307         void LoadRewards();
 308         void LoadRewardLocales();
 309     private:
 310         AchievementCriteriaDataMap m_criteriaDataMap;
 311
 312         // store achievement criterias by type to speed up lookup
 313         AchievementCriteriaEntryList m_AchievementCriteriasByType[ACHIEVEMENT_CRITERIA_TYPE_TOTAL];
 314         // store achievement criterias by achievement to speed up lookup
 315         AchievementCriteriaListByAchievement m_AchievementCriteriaListByAchievement;
 316         // store achievements by referenced achievement id to speed up lookup
 317         AchievementListByReferencedId m_AchievementListByReferencedId;
 318
 319         typedef std::set<uint32> AllCompletedAchievements;
 320         AllCompletedAchievements m_allCompletedAchievements;
 321
 322         AchievementRewards m_achievementRewards;
 323         AchievementRewardLocales m_achievementRewardLocales;
 324 };
 325
 326 #define achievementmgr MaNGOS::Singleton<AchievementGlobalMgr>::Instance()
 327
 328 #endif