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 AchievementCriteriaRequirementType
  44 {                                                           // value1         value2        comment
  45     ACHIEVEMENT_CRITERIA_REQUIRE_NONE                = 0,   // 0              0
  46     ACHIEVEMENT_CRITERIA_REQUIRE_T_CREATURE          = 1,   // creature_id    0
  47     ACHIEVEMENT_CRITERIA_REQUIRE_T_PLAYER_CLASS_RACE = 2,   // class_id       race_id
  48     ACHIEVEMENT_CRITERIA_REQUIRE_T_PLAYER_LESS_HEALTH= 3,   // health_percent 0
  49     ACHIEVEMENT_CRITERIA_REQUIRE_T_PLAYER_DEAD       = 4,   // own_team       0             not corpse (not released body), own_team==false if enemy team expected
  50     ACHIEVEMENT_CRITERIA_REQUIRE_S_AURA              = 5,   // spell_id       effect_idx
  51     ACHIEVEMENT_CRITERIA_REQUIRE_S_AREA              = 6,   // area id        0
  52     ACHIEVEMENT_CRITERIA_REQUIRE_T_AURA              = 7,   // spell_id       effect_idx
  53     ACHIEVEMENT_CRITERIA_REQUIRE_VALUE               = 8,   // minvalue                     value provided with achievement update must be not less that limit
  54     ACHIEVEMENT_CRITERIA_REQUIRE_T_LEVEL             = 9,   // minlevel                     minlevel of target
  55     ACHIEVEMENT_CRITERIA_REQUIRE_T_GENDER            = 10,  // gender                       0=male; 1=female
  56     ACHIEVEMENT_CRITERIA_REQUIRE_DISABLED            = 11,  //                              used to prevent achievement creteria complete if not all requirement implemented and listed in table
  57     ACHIEVEMENT_CRITERIA_REQUIRE_MAP_DIFFICULTY      = 12,  // difficulty                   normal/heroic difficulty for current event map
  58     ACHIEVEMENT_CRITERIA_REQUIRE_MAP_PLAYER_COUNT    = 13,  // count                        "with less than %u people in the zone"
  59     ACHIEVEMENT_CRITERIA_REQUIRE_T_TEAM              = 14,  // team                         HORDE(67), ALLIANCE(469)
  60     ACHIEVEMENT_CRITERIA_REQUIRE_S_DRUNK             = 15,  // drunken_state  0             (enum DrunkenState) of player
  61     ACHIEVEMENT_CRITERIA_REQUIRE_HOLIDAY             = 16,  // holiday_id     0             event in holiday time
  62     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
  63     ACHIEVEMENT_CRITERIA_REQUIRE_INSTANCE_SCRIPT     = 18,  // 0              0             maker instance script call for check curent criteria requirements fit
  64 };
  65
  66 #define MAX_ACHIEVEMENT_CRITERIA_REQUIREMENT_TYPE      19 // maximum value in AchievementCriteriaRequirementType enum
  67
  68 class Player;
  69 class Unit;
  70
  71 struct AchievementCriteriaRequirement
  72 {
  73     AchievementCriteriaRequirementType requirementType;
  74     union
  75     {
  76         // ACHIEVEMENT_CRITERIA_REQUIRE_NONE              = 0 (no data)
  77         // ACHIEVEMENT_CRITERIA_REQUIRE_T_CREATURE        = 1
  78         struct
  79         {
  80             uint32 id;
  81         } creature;
  82         // ACHIEVEMENT_CRITERIA_REQUIRE_T_PLAYER_CLASS_RACE = 2
  83         struct
  84         {
  85             uint32 class_id;
  86             uint32 race_id;
  87         } classRace;
  88         // ACHIEVEMENT_CRITERIA_REQUIRE_T_PLAYER_LESS_HEALTH = 3
  89         struct
  90         {
  91             uint32 percent;
  92         } health;
  93         // ACHIEVEMENT_CRITERIA_REQUIRE_T_PLAYER_DEAD     = 4
  94         struct
  95         {
  96             uint32 own_team_flag;
  97         } player_dead;
  98         // ACHIEVEMENT_CRITERIA_REQUIRE_S_AURA            = 5
  99         // ACHIEVEMENT_CRITERIA_REQUIRE_T_AURA            = 7
 100         struct
 101         {
 102             uint32 spell_id;
 103             uint32 effect_idx;
 104         } aura;
 105         // ACHIEVEMENT_CRITERIA_REQUIRE_S_AREA            = 6
 106         struct
 107         {
 108             uint32 id;
 109         } area;
 110         // ACHIEVEMENT_CRITERIA_REQUIRE_VALUE             = 8
 111         struct
 112         {
 113             uint32 minvalue;
 114         } value;
 115         // ACHIEVEMENT_CRITERIA_REQUIRE_T_LEVEL           = 9
 116         struct
 117         {
 118             uint32 minlevel;
 119         } level;
 120         // ACHIEVEMENT_CRITERIA_REQUIRE_T_GENDER          = 10
 121         struct
 122         {
 123             uint32 gender;
 124         } gender;
 125         // ACHIEVEMENT_CRITERIA_REQUIRE_DISABLED          = 11 (no data)
 126         // ACHIEVEMENT_CRITERIA_REQUIRE_MAP_DIFFICULTY    = 12
 127         struct
 128         {
 129             uint32 difficulty;
 130         } difficulty;
 131         // ACHIEVEMENT_CRITERIA_REQUIRE_MAP_PLAYER_COUNT  = 13
 132         struct
 133         {
 134             uint32 maxcount;
 135         } map_players;
 136         // ACHIEVEMENT_CRITERIA_REQUIRE_T_TEAM            = 14
 137         struct
 138         {
 139             uint32 team;
 140         } team;
 141         // ACHIEVEMENT_CRITERIA_REQUIRE_S_DRUNK           = 15
 142         struct
 143         {
 144             uint32 state;
 145         } drunk;
 146         // ACHIEVEMENT_CRITERIA_REQUIRE_HOLIDAY           = 16
 147         struct
 148         {
 149             uint32 id;
 150         } holiday;
 151         // ACHIEVEMENT_CRITERIA_REQUIRE_BG_LOSS_TEAM_SCORE= 17
 152         struct
 153         {
 154             uint32 min_score;
 155             uint32 max_score;
 156         } bg_loss_team_score;
 157         // ...
 158         struct
 159         {
 160             uint32 value1;
 161             uint32 value2;
 162         } raw;
 163     };
 164
 165     AchievementCriteriaRequirement() : requirementType(ACHIEVEMENT_CRITERIA_REQUIRE_NONE)
 166     {
 167         raw.value1 = 0;
 168         raw.value2 = 0;
 169     }
 170
 171     AchievementCriteriaRequirement(uint32 reqType, uint32 _value1, uint32 _value2)
 172         : requirementType(AchievementCriteriaRequirementType(reqType))
 173     {
 174         raw.value1 = _value1;
 175         raw.value2 = _value2;
 176     }
 177
 178     bool IsValid(AchievementCriteriaEntry const* criteria);
 179     bool Meets(uint32 criteria_id, Player const* source, Unit const* target, uint32 miscvalue1 = 0) const;
 180 };
 181
 182 struct AchievementCriteriaRequirementSet
 183 {
 184         AchievementCriteriaRequirementSet() : criteria_id(0) {}
 185         typedef std::vector<AchievementCriteriaRequirement> Storage;
 186         void Add(AchievementCriteriaRequirement const& data) { storage.push_back(data); }
 187         bool Meets(Player const* source, Unit const* target, uint32 miscvalue = 0) const;
 188         void SetCriteriaId(uint32 id) {criteria_id = id;}
 189     private:
 190         uint32 criteria_id;
 191         Storage storage;
 192 };
 193
 194 typedef std::map<uint32,AchievementCriteriaRequirementSet> AchievementCriteriaRequirementMap;
 195
 196 struct AchievementReward
 197 {
 198     uint32 titleId[2];
 199     uint32 itemId;
 200     uint32 sender;
 201     std::string subject;
 202     std::string text;
 203 };
 204
 205 typedef std::map<uint32,AchievementReward> AchievementRewards;
 206
 207 struct AchievementRewardLocale
 208 {
 209     std::vector<std::string> subject;
 210     std::vector<std::string> text;
 211 };
 212
 213 typedef std::map<uint32,AchievementRewardLocale> AchievementRewardLocales;
 214
 215
 216 struct CompletedAchievementData
 217 {
 218     time_t date;
 219     bool changed;
 220 };
 221
 222 typedef UNORDERED_MAP<uint32, CriteriaProgress> CriteriaProgressMap;
 223 typedef UNORDERED_MAP<uint32, CompletedAchievementData> CompletedAchievementMap;
 224
 225 class Unit;
 226 class Player;
 227 class WorldPacket;
 228
 229 class AchievementMgr
 230 {
 231     public:
 232         AchievementMgr(Player* pl);
 233         ~AchievementMgr();
 234
 235         void Reset();
 236         static void DeleteFromDB(uint32 lowguid);
 237         void LoadFromDB(QueryResult *achievementResult, QueryResult *criteriaResult);
 238         void SaveToDB();
 239         void ResetAchievementCriteria(AchievementCriteriaTypes type, uint32 miscvalue1=0, uint32 miscvalue2=0);
 240         void UpdateAchievementCriteria(AchievementCriteriaTypes type, uint32 miscvalue1=0, uint32 miscvalue2=0, Unit *unit=NULL, uint32 time=0);
 241         void CheckAllAchievementCriteria();
 242         void SendAllAchievementData();
 243         void SendRespondInspectAchievements(Player* player);
 244         Player* GetPlayer() { return m_player;}
 245
 246     private:
 247         enum ProgressType { PROGRESS_SET, PROGRESS_ACCUMULATE, PROGRESS_HIGHEST };
 248         void SendAchievementEarned(AchievementEntry const* achievement);
 249         void SendCriteriaUpdate(uint32 id, CriteriaProgress const* progress);
 250         void SetCriteriaProgress(AchievementCriteriaEntry const* entry, uint32 changeValue, ProgressType ptype = PROGRESS_SET);
 251         void CompletedCriteriaFor(AchievementEntry const* achievement);
 252         void CompletedAchievement(AchievementEntry const* entry);
 253         bool IsCompletedCriteria(AchievementCriteriaEntry const* criteria, AchievementEntry const* achievement);
 254         bool IsCompletedAchievement(AchievementEntry const* entry);
 255         void CompleteAchievementsWithRefs(AchievementEntry const* entry);
 256         void BuildAllDataPacket(WorldPacket *data);
 257
 258         Player* m_player;
 259         CriteriaProgressMap m_criteriaProgress;
 260         CompletedAchievementMap m_completedAchievements;
 261 };
 262
 263 class AchievementGlobalMgr
 264 {
 265     public:
 266         AchievementCriteriaEntryList const& GetAchievementCriteriaByType(AchievementCriteriaTypes type);
 267         AchievementCriteriaEntryList const* GetAchievementCriteriaByAchievement(uint32 id)
 268         {
 269             AchievementCriteriaListByAchievement::const_iterator itr = m_AchievementCriteriaListByAchievement.find(id);
 270             return itr != m_AchievementCriteriaListByAchievement.end() ? &itr->second : NULL;
 271         }
 272
 273         AchievementEntryList const* GetAchievementByReferencedId(uint32 id) const
 274         {
 275             AchievementListByReferencedId::const_iterator itr = m_AchievementListByReferencedId.find(id);
 276             return itr != m_AchievementListByReferencedId.end() ? &itr->second : NULL;
 277         }
 278
 279         AchievementReward const* GetAchievementReward(AchievementEntry const* achievement) const
 280         {
 281             AchievementRewards::const_iterator iter = m_achievementRewards.find(achievement->ID);
 282             return iter!=m_achievementRewards.end() ? &iter->second : NULL;
 283         }
 284
 285         AchievementRewardLocale const* GetAchievementRewardLocale(AchievementEntry const* achievement) const
 286         {
 287             AchievementRewardLocales::const_iterator iter = m_achievementRewardLocales.find(achievement->ID);
 288             return iter!=m_achievementRewardLocales.end() ? &iter->second : NULL;
 289         }
 290
 291         AchievementCriteriaRequirementSet const* GetCriteriaRequirementSet(AchievementCriteriaEntry const *achievementCriteria)
 292         {
 293             AchievementCriteriaRequirementMap::const_iterator iter = m_criteriaRequirementMap.find(achievementCriteria->ID);
 294             return iter!=m_criteriaRequirementMap.end() ? &iter->second : NULL;
 295         }
 296
 297         bool IsRealmCompleted(AchievementEntry const* achievement) const
 298         {
 299             return m_allCompletedAchievements.find(achievement->ID) != m_allCompletedAchievements.end();
 300         }
 301
 302         void SetRealmCompleted(AchievementEntry const* achievement)
 303         {
 304             m_allCompletedAchievements.insert(achievement->ID);
 305         }
 306
 307         void LoadAchievementCriteriaList();
 308         void LoadAchievementCriteriaRequirements();
 309         void LoadAchievementReferenceList();
 310         void LoadCompletedAchievements();
 311         void LoadRewards();
 312         void LoadRewardLocales();
 313     private:
 314         AchievementCriteriaRequirementMap m_criteriaRequirementMap;
 315
 316         // store achievement criterias by type to speed up lookup
 317         AchievementCriteriaEntryList m_AchievementCriteriasByType[ACHIEVEMENT_CRITERIA_TYPE_TOTAL];
 318         // store achievement criterias by achievement to speed up lookup
 319         AchievementCriteriaListByAchievement m_AchievementCriteriaListByAchievement;
 320         // store achievements by referenced achievement id to speed up lookup
 321         AchievementListByReferencedId m_AchievementListByReferencedId;
 322
 323         typedef std::set<uint32> AllCompletedAchievements;
 324         AllCompletedAchievements m_allCompletedAchievements;
 325
 326         AchievementRewards m_achievementRewards;
 327         AchievementRewardLocales m_achievementRewardLocales;
 328 };
 329
 330 #define sAchievementMgr MaNGOS::Singleton<AchievementGlobalMgr>::Instance()
 331
 332 #endif