src/game/Player.h

   1 /*
   2  * Copyright (C) 2005-2008 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
  19 #ifndef _PLAYER_H
  20 #define _PLAYER_H
  21
  22 #include "Common.h"
  23 #include "ItemPrototype.h"
  24 #include "Unit.h"
  25 #include "Item.h"
  26
  27 #include "Database/DatabaseEnv.h"
  28 #include "NPCHandler.h"
  29 #include "QuestDef.h"
  30 #include "Group.h"
  31 #include "Bag.h"
  32 #include "WorldSession.h"
  33 #include "Pet.h"
  34 #include "MapReference.h"
  35 #include "Util.h"                                           // for Tokens typedef
  36
  37 #include<string>
  38 #include<vector>
  39
  40 struct Mail;
  41 class Channel;
  42 class DynamicObject;
  43 class Creature;
  44 class Pet;
  45 class PlayerMenu;
  46 class Transport;
  47 class UpdateMask;
  48 class PlayerSocial;
  49
  50 typedef std::deque<Mail*> PlayerMails;
  51
  52 #define PLAYER_MAX_SKILLS       127
  53 #define PLAYER_MAX_DAILY_QUESTS 25
  54
  55 // Note: SPELLMOD_* values is aura types in fact
  56 enum SpellModType
  57 {
  58     SPELLMOD_FLAT         = 107,                            // SPELL_AURA_ADD_FLAT_MODIFIER
  59     SPELLMOD_PCT          = 108                             // SPELL_AURA_ADD_PCT_MODIFIER
  60 };
  61
  62 enum PlayerSpellState
  63 {
  64     PLAYERSPELL_UNCHANGED = 0,
  65     PLAYERSPELL_CHANGED   = 1,
  66     PLAYERSPELL_NEW       = 2,
  67     PLAYERSPELL_REMOVED   = 3
  68 };
  69
  70 struct PlayerSpell
  71 {
  72     uint16 slotId          : 16;
  73     PlayerSpellState state : 8;
  74     bool active            : 1;
  75     bool disabled          : 1;
  76 };
  77
  78 #define SPELL_WITHOUT_SLOT_ID uint16(-1)
  79
  80 struct SpellModifier
  81 {
  82     SpellModOp   op   : 8;
  83     SpellModType type : 8;
  84     int16 charges     : 16;
  85     int32 value;
  86     uint64 mask;
  87     uint32 spellId;
  88     uint32 effectId;
  89     Spell const* lastAffected;
  90 };
  91
  92 typedef UNORDERED_MAP<uint16, PlayerSpell*> PlayerSpellMap;
  93 typedef std::list<SpellModifier*> SpellModList;
  94
  95 struct SpellCooldown
  96 {
  97     time_t end;
  98     uint16 itemid;
  99 };
 100
 101 typedef std::map<uint32, SpellCooldown> SpellCooldowns;
 102
 103 enum TrainerSpellState
 104 {
 105     TRAINER_SPELL_GREEN = 0,
 106     TRAINER_SPELL_RED   = 1,
 107     TRAINER_SPELL_GRAY  = 2
 108 };
 109
 110 enum ActionButtonUpdateState
 111 {
 112     ACTIONBUTTON_UNCHANGED = 0,
 113     ACTIONBUTTON_CHANGED   = 1,
 114     ACTIONBUTTON_NEW       = 2,
 115     ACTIONBUTTON_DELETED   = 3
 116 };
 117
 118 struct ActionButton
 119 {
 120     ActionButton() : action(0), type(0), misc(0), uState( ACTIONBUTTON_NEW ) {}
 121     ActionButton(uint16 _action, uint8 _type, uint8 _misc) : action(_action), type(_type), misc(_misc), uState( ACTIONBUTTON_NEW ) {}
 122
 123     uint16 action;
 124     uint8 type;
 125     uint8 misc;
 126     ActionButtonUpdateState uState;
 127 };
 128
 129 enum ActionButtonType
 130 {
 131     ACTION_BUTTON_SPELL = 0,
 132     ACTION_BUTTON_MACRO = 64,
 133     ACTION_BUTTON_CMACRO= 65,
 134     ACTION_BUTTON_ITEM  = 128
 135 };
 136
 137 #define  MAX_ACTION_BUTTONS 132                             //checked in 2.3.0
 138
 139 typedef std::map<uint8,ActionButton> ActionButtonList;
 140
 141 typedef std::pair<uint16, uint8> CreateSpellPair;
 142
 143 struct PlayerCreateInfoItem
 144 {
 145     PlayerCreateInfoItem(uint32 id, uint32 amount) : item_id(id), item_amount(amount) {}
 146
 147     uint32 item_id;
 148     uint32 item_amount;
 149 };
 150
 151 typedef std::list<PlayerCreateInfoItem> PlayerCreateInfoItems;
 152
 153 struct PlayerClassLevelInfo
 154 {
 155     PlayerClassLevelInfo() : basehealth(0), basemana(0) {}
 156     uint16 basehealth;
 157     uint16 basemana;
 158 };
 159
 160 struct PlayerClassInfo
 161 {
 162     PlayerClassInfo() : levelInfo(NULL) { }
 163
 164     PlayerClassLevelInfo* levelInfo;                        //[level-1] 0..MaxPlayerLevel-1
 165 };
 166
 167 struct PlayerLevelInfo
 168 {
 169     PlayerLevelInfo() { for(int i=0; i < MAX_STATS; ++i ) stats[i] = 0; }
 170
 171     uint8 stats[MAX_STATS];
 172 };
 173
 174 struct PlayerInfo
 175 {
 176                                                             // existence checked by displayId != 0             // existence checked by displayId != 0
 177     PlayerInfo() : displayId_m(0),displayId_f(0),levelInfo(NULL)
 178     {
 179     }
 180
 181     uint32 mapId;
 182     uint32 zoneId;
 183     float positionX;
 184     float positionY;
 185     float positionZ;
 186     uint16 displayId_m;
 187     uint16 displayId_f;
 188     PlayerCreateInfoItems item;
 189     std::list<CreateSpellPair> spell;
 190     std::list<uint16> action[4];
 191
 192     PlayerLevelInfo* levelInfo;                             //[level-1] 0..MaxPlayerLevel-1
 193 };
 194
 195 struct PvPInfo
 196 {
 197     PvPInfo() : inHostileArea(false), endTimer(0) {}
 198
 199     bool inHostileArea;
 200     time_t endTimer;
 201 };
 202
 203 struct DuelInfo
 204 {
 205     DuelInfo() : initiator(NULL), opponent(NULL), startTimer(0), startTime(0), outOfBound(0) {}
 206
 207     Player *initiator;
 208     Player *opponent;
 209     time_t startTimer;
 210     time_t startTime;
 211     time_t outOfBound;
 212 };
 213
 214 struct Areas
 215 {
 216     uint32 areaID;
 217     uint32 areaFlag;
 218     float x1;
 219     float x2;
 220     float y1;
 221     float y2;
 222 };
 223
 224 enum FactionFlags
 225 {
 226     FACTION_FLAG_VISIBLE            = 0x01,                 // makes visible in client (set or can be set at interaction with target of this faction)
 227     FACTION_FLAG_AT_WAR             = 0x02,                 // enable AtWar-button in client. player controlled (except opposition team always war state), Flag only set on initial creation
 228     FACTION_FLAG_HIDDEN             = 0x04,                 // hidden faction from reputation pane in client (player can gain reputation, but this update not sent to client)
 229     FACTION_FLAG_INVISIBLE_FORCED   = 0x08,                 // always overwrite FACTION_FLAG_VISIBLE and hide faction in rep.list, used for hide opposite team factions
 230     FACTION_FLAG_PEACE_FORCED       = 0x10,                 // always overwrite FACTION_FLAG_AT_WAR, used for prevent war with own team factions
 231     FACTION_FLAG_INACTIVE           = 0x20,                 // player controlled, state stored in characters.data ( CMSG_SET_FACTION_INACTIVE )
 232     FACTION_FLAG_RIVAL              = 0x40                  // flag for the two competing outland factions
 233 };
 234
 235 typedef uint32 RepListID;
 236 struct FactionState
 237 {
 238     uint32 ID;
 239     RepListID ReputationListID;
 240     uint32 Flags;
 241     int32  Standing;
 242     bool Changed;
 243 };
 244
 245 typedef std::map<RepListID,FactionState> FactionStateList;
 246
 247 typedef std::map<uint32,ReputationRank> ForcedReactions;
 248
 249 typedef std::set<uint64> GuardianPetList;
 250
 251 struct EnchantDuration
 252 {
 253     EnchantDuration() : item(NULL), slot(MAX_ENCHANTMENT_SLOT), leftduration(0) {};
 254     EnchantDuration(Item * _item, EnchantmentSlot _slot, uint32 _leftduration) : item(_item), slot(_slot), leftduration(_leftduration) { assert(item); };
 255
 256     Item * item;
 257     EnchantmentSlot slot;
 258     uint32 leftduration;
 259 };
 260
 261 typedef std::list<EnchantDuration> EnchantDurationList;
 262 typedef std::list<Item*> ItemDurationList;
 263
 264 struct LookingForGroupSlot
 265 {
 266     LookingForGroupSlot() : entry(0), type(0) {}
 267     bool Empty() const { return !entry && !type; }
 268     void Clear() { entry = 0; type = 0; }
 269     void Set(uint32 _entry, uint32 _type ) { entry = _entry; type = _type; }
 270     bool Is(uint32 _entry, uint32 _type) const { return entry==_entry && type==_type; }
 271     bool canAutoJoin() const { return entry && (type == 1 || type == 5); }
 272
 273     uint32 entry;
 274     uint32 type;
 275 };
 276
 277 #define MAX_LOOKING_FOR_GROUP_SLOT 3
 278
 279 struct LookingForGroup
 280 {
 281     LookingForGroup() {}
 282     bool HaveInSlot(LookingForGroupSlot const& slot) const { return HaveInSlot(slot.entry,slot.type); }
 283     bool HaveInSlot(uint32 _entry, uint32 _type) const
 284     {
 285         for(int i = 0; i < MAX_LOOKING_FOR_GROUP_SLOT; ++i)
 286             if(slots[i].Is(_entry,_type))
 287                 return true;
 288         return false;
 289     }
 290
 291     bool canAutoJoin() const
 292     {
 293         for(int i = 0; i < MAX_LOOKING_FOR_GROUP_SLOT; ++i)
 294             if(slots[i].canAutoJoin())
 295                 return true;
 296         return false;
 297     }
 298
 299     bool Empty() const
 300     {
 301         for(int i = 0; i < MAX_LOOKING_FOR_GROUP_SLOT; ++i)
 302             if(!slots[i].Empty())
 303                 return false;
 304         return more.Empty();
 305     }
 306
 307     LookingForGroupSlot slots[MAX_LOOKING_FOR_GROUP_SLOT];
 308     LookingForGroupSlot more;
 309     std::string comment;
 310 };
 311
 312 enum PlayerMovementType
 313 {
 314     MOVE_ROOT       = 1,
 315     MOVE_UNROOT     = 2,
 316     MOVE_WATER_WALK = 3,
 317     MOVE_LAND_WALK  = 4
 318 };
 319
 320 enum DrunkenState
 321 {
 322     DRUNKEN_SOBER   = 0,
 323     DRUNKEN_TIPSY   = 1,
 324     DRUNKEN_DRUNK   = 2,
 325     DRUNKEN_SMASHED = 3
 326 };
 327
 328 enum PlayerStateType
 329 {
 330     /*
 331         PLAYER_STATE_DANCE
 332         PLAYER_STATE_SLEEP
 333         PLAYER_STATE_SIT
 334         PLAYER_STATE_STAND
 335         PLAYER_STATE_READYUNARMED
 336         PLAYER_STATE_WORK
 337         PLAYER_STATE_POINT(DNR)
 338         PLAYER_STATE_NONE // not used or just no state, just standing there?
 339         PLAYER_STATE_STUN
 340         PLAYER_STATE_DEAD
 341         PLAYER_STATE_KNEEL
 342         PLAYER_STATE_USESTANDING
 343         PLAYER_STATE_STUN_NOSHEATHE
 344         PLAYER_STATE_USESTANDING_NOSHEATHE
 345         PLAYER_STATE_WORK_NOSHEATHE
 346         PLAYER_STATE_SPELLPRECAST
 347         PLAYER_STATE_READYRIFLE
 348         PLAYER_STATE_WORK_NOSHEATHE_MINING
 349         PLAYER_STATE_WORK_NOSHEATHE_CHOPWOOD
 350         PLAYER_STATE_AT_EASE
 351         PLAYER_STATE_READY1H
 352         PLAYER_STATE_SPELLKNEELSTART
 353         PLAYER_STATE_SUBMERGED
 354     */
 355
 356     PLAYER_STATE_NONE              = 0,
 357     PLAYER_STATE_SIT               = 1,
 358     PLAYER_STATE_SIT_CHAIR         = 2,
 359     PLAYER_STATE_SLEEP             = 3,
 360     PLAYER_STATE_SIT_LOW_CHAIR     = 4,
 361     PLAYER_STATE_SIT_MEDIUM_CHAIR  = 5,
 362     PLAYER_STATE_SIT_HIGH_CHAIR    = 6,
 363     PLAYER_STATE_DEAD              = 7,
 364     PLAYER_STATE_KNEEL             = 8,
 365
 366     PLAYER_STATE_FORM_ALL          = 0x00FF0000,
 367
 368     PLAYER_STATE_FLAG_ALWAYS_STAND = 0x01,                  // byte 4
 369     PLAYER_STATE_FLAG_CREEP        = 0x02000000,
 370     PLAYER_STATE_FLAG_UNTRACKABLE  = 0x04000000,
 371     PLAYER_STATE_FLAG_ALL          = 0xFF000000,
 372 };
 373
 374 enum PlayerFlags
 375 {
 376     PLAYER_FLAGS_GROUP_LEADER   = 0x00000001,
 377     PLAYER_FLAGS_AFK            = 0x00000002,
 378     PLAYER_FLAGS_DND            = 0x00000004,
 379     PLAYER_FLAGS_GM             = 0x00000008,
 380     PLAYER_FLAGS_GHOST          = 0x00000010,
 381     PLAYER_FLAGS_RESTING        = 0x00000020,
 382     PLAYER_FLAGS_FFA_PVP        = 0x00000080,
 383     PLAYER_FLAGS_CONTESTED_PVP  = 0x00000100,               // Player has been involved in a PvP combat and will be attacked by contested guards
 384     PLAYER_FLAGS_IN_PVP         = 0x00000200,
 385     PLAYER_FLAGS_HIDE_HELM      = 0x00000400,
 386     PLAYER_FLAGS_HIDE_CLOAK     = 0x00000800,
 387     PLAYER_FLAGS_UNK1           = 0x00001000,               // played long time
 388     PLAYER_FLAGS_UNK2           = 0x00002000,               // played too long time
 389     PLAYER_FLAGS_UNK3           = 0x00008000,               // strange visual effect (2.0.1), looks like PLAYER_FLAGS_GHOST flag
 390     PLAYER_FLAGS_SANCTUARY      = 0x00010000,               // player entered sanctuary
 391     PLAYER_FLAGS_UNK4           = 0x00020000,               // taxi benchmark mode (on/off) (2.0.1)
 392     PLAYER_UNK                  = 0x00040000,               // 2.0.8...
 393 };
 394
 395 // used for PLAYER__FIELD_KNOWN_TITLES field (uint64), (1<<bit_index) without (-1)
 396 // can't use enum for uint64 values
 397 #define PLAYER_TITLE_DISABLED              0x0000000000000000LL
 398 #define PLAYER_TITLE_NONE                  0x0000000000000001LL
 399 #define PLAYER_TITLE_PRIVATE               0x0000000000000002LL // 1
 400 #define PLAYER_TITLE_CORPORAL              0x0000000000000004LL // 2
 401 #define PLAYER_TITLE_SERGEANT_A            0x0000000000000008LL // 3
 402 #define PLAYER_TITLE_MASTER_SERGEANT       0x0000000000000010LL // 4
 403 #define PLAYER_TITLE_SERGEANT_MAJOR        0x0000000000000020LL // 5
 404 #define PLAYER_TITLE_KNIGHT                0x0000000000000040LL // 6
 405 #define PLAYER_TITLE_KNIGHT_LIEUTENANT     0x0000000000000080LL // 7
 406 #define PLAYER_TITLE_KNIGHT_CAPTAIN        0x0000000000000100LL // 8
 407 #define PLAYER_TITLE_KNIGHT_CHAMPION       0x0000000000000200LL // 9
 408 #define PLAYER_TITLE_LIEUTENANT_COMMANDER  0x0000000000000400LL // 10
 409 #define PLAYER_TITLE_COMMANDER             0x0000000000000800LL // 11
 410 #define PLAYER_TITLE_MARSHAL               0x0000000000001000LL // 12
 411 #define PLAYER_TITLE_FIELD_MARSHAL         0x0000000000002000LL // 13
 412 #define PLAYER_TITLE_GRAND_MARSHAL         0x0000000000004000LL // 14
 413 #define PLAYER_TITLE_SCOUT                 0x0000000000008000LL // 15
 414 #define PLAYER_TITLE_GRUNT                 0x0000000000010000LL // 16
 415 #define PLAYER_TITLE_SERGEANT_H            0x0000000000020000LL // 17
 416 #define PLAYER_TITLE_SENIOR_SERGEANT       0x0000000000040000LL // 18
 417 #define PLAYER_TITLE_FIRST_SERGEANT        0x0000000000080000LL // 19
 418 #define PLAYER_TITLE_STONE_GUARD           0x0000000000100000LL // 20
 419 #define PLAYER_TITLE_BLOOD_GUARD           0x0000000000200000LL // 21
 420 #define PLAYER_TITLE_LEGIONNAIRE           0x0000000000400000LL // 22
 421 #define PLAYER_TITLE_CENTURION             0x0000000000800000LL // 23
 422 #define PLAYER_TITLE_CHAMPION              0x0000000001000000LL // 24
 423 #define PLAYER_TITLE_LIEUTENANT_GENERAL    0x0000000002000000LL // 25
 424 #define PLAYER_TITLE_GENERAL               0x0000000004000000LL // 26
 425 #define PLAYER_TITLE_WARLORD               0x0000000008000000LL // 27
 426 #define PLAYER_TITLE_HIGH_WARLORD          0x0000000010000000LL // 28
 427 #define PLAYER_TITLE_GLADIATOR             0x0000000020000000LL // 29
 428 #define PLAYER_TITLE_DUELIST               0x0000000040000000LL // 30
 429 #define PLAYER_TITLE_RIVAL                 0x0000000080000000LL // 31
 430 #define PLAYER_TITLE_CHALLENGER            0x0000000100000000LL // 32
 431 #define PLAYER_TITLE_SCARAB_LORD           0x0000000200000000LL // 33
 432 #define PLAYER_TITLE_CONQUEROR             0x0000000400000000LL // 34
 433 #define PLAYER_TITLE_JUSTICAR              0x0000000800000000LL // 35
 434 #define PLAYER_TITLE_CHAMPION_OF_THE_NAARU 0x0000001000000000LL // 36
 435 #define PLAYER_TITLE_MERCILESS_GLADIATOR   0x0000002000000000LL // 37
 436 #define PLAYER_TITLE_OF_THE_SHATTERED_SUN  0x0000004000000000LL // 38
 437 #define PLAYER_TITLE_HAND_OF_ADAL          0x0000008000000000LL // 39
 438 #define PLAYER_TITLE_VENGEFUL_GLADIATOR    0x0000010000000000LL // 40
 439
 440 // used in PLAYER_FIELD_BYTES values
 441 enum PlayerFieldByteFlags
 442 {
 443     PLAYER_FIELD_BYTE_TRACK_STEALTHED   = 0x00000002,
 444     PLAYER_FIELD_BYTE_RELEASE_TIMER     = 0x00000008,       // Display time till auto release spirit
 445     PLAYER_FIELD_BYTE_NO_RELEASE_WINDOW = 0x00000010        // Display no "release spirit" window at all
 446 };
 447
 448 // used in PLAYER_FIELD_BYTES2 values
 449 enum PlayerFieldByte2Flags
 450 {
 451     PLAYER_FIELD_BYTE2_NONE              = 0x0000,
 452     PLAYER_FIELD_BYTE2_INVISIBILITY_GLOW = 0x4000
 453 };
 454
 455 enum ActivateTaxiReplies
 456 {
 457     ERR_TAXIOK                      = 0,
 458     ERR_TAXIUNSPECIFIEDSERVERERROR  = 1,
 459     ERR_TAXINOSUCHPATH              = 2,
 460     ERR_TAXINOTENOUGHMONEY          = 3,
 461     ERR_TAXITOOFARAWAY              = 4,
 462     ERR_TAXINOVENDORNEARBY          = 5,
 463     ERR_TAXINOTVISITED              = 6,
 464     ERR_TAXIPLAYERBUSY              = 7,
 465     ERR_TAXIPLAYERALREADYMOUNTED    = 8,
 466     ERR_TAXIPLAYERSHAPESHIFTED      = 9,
 467     ERR_TAXIPLAYERMOVING            = 10,
 468     ERR_TAXISAMENODE                = 11,
 469     ERR_TAXINOTSTANDING             = 12
 470 };
 471
 472 enum LootType
 473 {
 474     LOOT_CORPSE                 = 1,
 475     LOOT_SKINNING               = 2,
 476     LOOT_FISHING                = 3,
 477     LOOT_PICKPOCKETING          = 4,                        // unsupported by client, sending LOOT_SKINNING instead
 478     LOOT_DISENCHANTING          = 5,                        // unsupported by client, sending LOOT_SKINNING instead
 479     LOOT_PROSPECTING            = 6,                        // unsupported by client, sending LOOT_SKINNING instead
 480     LOOT_INSIGNIA               = 7,                        // unsupported by client, sending LOOT_SKINNING instead
 481     LOOT_FISHINGHOLE            = 8                         // unsupported by client, sending LOOT_FISHING instead
 482 };
 483
 484 enum MirrorTimerType
 485 {
 486     FATIGUE_TIMER      = 0,
 487     BREATH_TIMER       = 1,
 488     FIRE_TIMER         = 2
 489 };
 490
 491 // 2^n values
 492 enum PlayerExtraFlags
 493 {
 494     // gm abilities
 495     PLAYER_EXTRA_GM_ON              = 0x0001,
 496     PLAYER_EXTRA_GM_ACCEPT_TICKETS  = 0x0002,
 497     PLAYER_EXTRA_ACCEPT_WHISPERS    = 0x0004,
 498     PLAYER_EXTRA_TAXICHEAT          = 0x0008,
 499     PLAYER_EXTRA_GM_INVISIBLE       = 0x0010,
 500     PLAYER_EXTRA_GM_CHAT            = 0x0020,               // Show GM badge in chat messages
 501
 502     // other states
 503     PLAYER_EXTRA_PVP_DEATH          = 0x0100                // store PvP death status until corpse creating.
 504 };
 505
 506 // 2^n values
 507 enum AtLoginFlags
 508 {
 509     AT_LOGIN_NONE          = 0,
 510     AT_LOGIN_RENAME        = 1,
 511     AT_LOGIN_RESET_SPELLS  = 2,
 512     AT_LOGIN_RESET_TALENTS = 4
 513 };
 514
 515 typedef std::map<uint32, QuestStatusData> QuestStatusMap;
 516
 517 enum QuestSlotOffsets
 518 {
 519     QUEST_ID_OFFSET     = 0,
 520     QUEST_STATE_OFFSET  = 1,
 521     QUEST_COUNTS_OFFSET = 2,
 522     QUEST_TIME_OFFSET   = 3
 523 };
 524
 525 #define MAX_QUEST_OFFSET 4
 526
 527 enum QuestSlotStateMask
 528 {
 529     QUEST_STATE_NONE     = 0x0000,
 530     QUEST_STATE_COMPLETE = 0x0001,
 531     QUEST_STATE_FAIL     = 0x0002
 532 };
 533
 534 class Quest;
 535 class Spell;
 536 class Item;
 537 class WorldSession;
 538
 539 enum PlayerSlots
 540 {
 541     // first slot for item stored (in any way in player m_items data)
 542     PLAYER_SLOT_START           = 0,
 543     // last+1 slot for item stored (in any way in player m_items data)
 544     PLAYER_SLOT_END             = 118,
 545     PLAYER_SLOTS_COUNT          = (PLAYER_SLOT_END - PLAYER_SLOT_START)
 546 };
 547
 548 enum EquipmentSlots
 549 {
 550     EQUIPMENT_SLOT_START        = 0,
 551     EQUIPMENT_SLOT_HEAD         = 0,
 552     EQUIPMENT_SLOT_NECK         = 1,
 553     EQUIPMENT_SLOT_SHOULDERS    = 2,
 554     EQUIPMENT_SLOT_BODY         = 3,
 555     EQUIPMENT_SLOT_CHEST        = 4,
 556     EQUIPMENT_SLOT_WAIST        = 5,
 557     EQUIPMENT_SLOT_LEGS         = 6,
 558     EQUIPMENT_SLOT_FEET         = 7,
 559     EQUIPMENT_SLOT_WRISTS       = 8,
 560     EQUIPMENT_SLOT_HANDS        = 9,
 561     EQUIPMENT_SLOT_FINGER1      = 10,
 562     EQUIPMENT_SLOT_FINGER2      = 11,
 563     EQUIPMENT_SLOT_TRINKET1     = 12,
 564     EQUIPMENT_SLOT_TRINKET2     = 13,
 565     EQUIPMENT_SLOT_BACK         = 14,
 566     EQUIPMENT_SLOT_MAINHAND     = 15,
 567     EQUIPMENT_SLOT_OFFHAND      = 16,
 568     EQUIPMENT_SLOT_RANGED       = 17,
 569     EQUIPMENT_SLOT_TABARD       = 18,
 570     EQUIPMENT_SLOT_END          = 19
 571 };
 572
 573 enum InventorySlots
 574 {
 575     INVENTORY_SLOT_BAG_0        = 255,
 576     INVENTORY_SLOT_BAG_START    = 19,
 577     INVENTORY_SLOT_BAG_1        = 19,
 578     INVENTORY_SLOT_BAG_2        = 20,
 579     INVENTORY_SLOT_BAG_3        = 21,
 580     INVENTORY_SLOT_BAG_4        = 22,
 581     INVENTORY_SLOT_BAG_END      = 23,
 582
 583     INVENTORY_SLOT_ITEM_START   = 23,
 584     INVENTORY_SLOT_ITEM_1       = 23,
 585     INVENTORY_SLOT_ITEM_2       = 24,
 586     INVENTORY_SLOT_ITEM_3       = 25,
 587     INVENTORY_SLOT_ITEM_4       = 26,
 588     INVENTORY_SLOT_ITEM_5       = 27,
 589     INVENTORY_SLOT_ITEM_6       = 28,
 590     INVENTORY_SLOT_ITEM_7       = 29,
 591     INVENTORY_SLOT_ITEM_8       = 30,
 592     INVENTORY_SLOT_ITEM_9       = 31,
 593     INVENTORY_SLOT_ITEM_10      = 32,
 594     INVENTORY_SLOT_ITEM_11      = 33,
 595     INVENTORY_SLOT_ITEM_12      = 34,
 596     INVENTORY_SLOT_ITEM_13      = 35,
 597     INVENTORY_SLOT_ITEM_14      = 36,
 598     INVENTORY_SLOT_ITEM_15      = 37,
 599     INVENTORY_SLOT_ITEM_16      = 38,
 600     INVENTORY_SLOT_ITEM_END     = 39
 601 };
 602
 603 enum BankSlots
 604 {
 605     BANK_SLOT_ITEM_START        = 39,
 606     BANK_SLOT_ITEM_1            = 39,
 607     BANK_SLOT_ITEM_2            = 40,
 608     BANK_SLOT_ITEM_3            = 41,
 609     BANK_SLOT_ITEM_4            = 42,
 610     BANK_SLOT_ITEM_5            = 43,
 611     BANK_SLOT_ITEM_6            = 44,
 612     BANK_SLOT_ITEM_7            = 45,
 613     BANK_SLOT_ITEM_8            = 46,
 614     BANK_SLOT_ITEM_9            = 47,
 615     BANK_SLOT_ITEM_10           = 48,
 616     BANK_SLOT_ITEM_11           = 49,
 617     BANK_SLOT_ITEM_12           = 50,
 618     BANK_SLOT_ITEM_13           = 51,
 619     BANK_SLOT_ITEM_14           = 52,
 620     BANK_SLOT_ITEM_15           = 53,
 621     BANK_SLOT_ITEM_16           = 54,
 622     BANK_SLOT_ITEM_17           = 55,
 623     BANK_SLOT_ITEM_18           = 56,
 624     BANK_SLOT_ITEM_19           = 57,
 625     BANK_SLOT_ITEM_20           = 58,
 626     BANK_SLOT_ITEM_21           = 59,
 627     BANK_SLOT_ITEM_22           = 60,
 628     BANK_SLOT_ITEM_23           = 61,
 629     BANK_SLOT_ITEM_24           = 62,
 630     BANK_SLOT_ITEM_25           = 63,
 631     BANK_SLOT_ITEM_26           = 64,
 632     BANK_SLOT_ITEM_27           = 65,
 633     BANK_SLOT_ITEM_28           = 66,
 634     BANK_SLOT_ITEM_END          = 67,
 635
 636     BANK_SLOT_BAG_START         = 67,
 637     BANK_SLOT_BAG_1             = 67,
 638     BANK_SLOT_BAG_2             = 68,
 639     BANK_SLOT_BAG_3             = 69,
 640     BANK_SLOT_BAG_4             = 70,
 641     BANK_SLOT_BAG_5             = 71,
 642     BANK_SLOT_BAG_6             = 72,
 643     BANK_SLOT_BAG_7             = 73,
 644     BANK_SLOT_BAG_END           = 74
 645 };
 646
 647 enum BuyBackSlots
 648 {
 649     // stored in m_buybackitems
 650     BUYBACK_SLOT_START          = 74,
 651     BUYBACK_SLOT_1              = 74,
 652     BUYBACK_SLOT_2              = 75,
 653     BUYBACK_SLOT_3              = 76,
 654     BUYBACK_SLOT_4              = 77,
 655     BUYBACK_SLOT_5              = 78,
 656     BUYBACK_SLOT_6              = 79,
 657     BUYBACK_SLOT_7              = 80,
 658     BUYBACK_SLOT_8              = 81,
 659     BUYBACK_SLOT_9              = 82,
 660     BUYBACK_SLOT_10             = 83,
 661     BUYBACK_SLOT_11             = 84,
 662     BUYBACK_SLOT_12             = 85,
 663     BUYBACK_SLOT_END            = 86
 664 };
 665
 666 enum KeyRingSlots
 667 {
 668     KEYRING_SLOT_START          = 86,
 669     KEYRING_SLOT_END            = 118
 670 };
 671
 672 struct ItemPosCount
 673 {
 674     ItemPosCount(uint16 _pos, uint8 _count) : pos(_pos), count(_count) {}
 675     bool isContainedIn(std::vector<ItemPosCount> const& vec) const;
 676     uint16 pos;
 677     uint8 count;
 678 };
 679 typedef std::vector<ItemPosCount> ItemPosCountVec;
 680
 681 enum TradeSlots
 682 {
 683     TRADE_SLOT_COUNT            = 7,
 684     TRADE_SLOT_TRADED_COUNT     = 6,
 685     TRADE_SLOT_NONTRADED        = 6
 686 };
 687
 688 enum TransferAbortReason
 689 {
 690     TRANSFER_ABORT_MAX_PLAYERS          = 0x0001,           // Transfer Aborted: instance is full
 691     TRANSFER_ABORT_NOT_FOUND            = 0x0002,           // Transfer Aborted: instance not found
 692     TRANSFER_ABORT_TOO_MANY_INSTANCES   = 0x0003,           // You have entered too many instances recently.
 693     TRANSFER_ABORT_ZONE_IN_COMBAT       = 0x0005,           // Unable to zone in while an encounter is in progress.
 694     TRANSFER_ABORT_INSUF_EXPAN_LVL1     = 0x0106,           // You must have TBC expansion installed to access this area.
 695     TRANSFER_ABORT_DIFFICULTY1          = 0x0007,           // Normal difficulty mode is not available for %s.
 696     TRANSFER_ABORT_DIFFICULTY2          = 0x0107,           // Heroic difficulty mode is not available for %s.
 697     TRANSFER_ABORT_DIFFICULTY3          = 0x0207            // Epic difficulty mode is not available for %s.
 698 };
 699
 700 enum InstanceResetWarningType
 701 {
 702     RAID_INSTANCE_WARNING_HOURS     = 1,                    // WARNING! %s is scheduled to reset in %d hour(s).
 703     RAID_INSTANCE_WARNING_MIN       = 2,                    // WARNING! %s is scheduled to reset in %d minute(s)!
 704     RAID_INSTANCE_WARNING_MIN_SOON  = 3,                    // WARNING! %s is scheduled to reset in %d minute(s). Please exit the zone or you will be returned to your bind location!
 705     RAID_INSTANCE_WELCOME           = 4                     // Welcome to %s. This raid instance is scheduled to reset in %s.
 706 };
 707
 708 struct MovementInfo
 709 {
 710     // common
 711     //uint32  flags;
 712     uint8   unk1;
 713     uint32  time;
 714     float   x, y, z, o;
 715     // transport
 716     uint64  t_guid;
 717     float   t_x, t_y, t_z, t_o;
 718     uint32  t_time;
 719     // swimming and unk
 720     float   s_pitch;
 721     // last fall time
 722     uint32  fallTime;
 723     // jumping
 724     float   j_unk, j_sinAngle, j_cosAngle, j_xyspeed;
 725     // spline
 726     float   u_unk1;
 727
 728     MovementInfo()
 729     {
 730         //flags =
 731         time = t_time = fallTime = 0;
 732         unk1 = 0;
 733         x = y = z = o = t_x = t_y = t_z = t_o = s_pitch = j_unk = j_sinAngle = j_cosAngle = j_xyspeed = u_unk1 = 0.0f;
 734         t_guid = 0;
 735     }
 736
 737     /*void SetMovementFlags(uint32 _flags)
 738     {
 739         flags = _flags;
 740     }*/
 741 };
 742
 743 // flags that use in movement check for example at spell casting
 744 MovementFlags const movementFlagsMask = MovementFlags(
 745     MOVEMENTFLAG_FORWARD |MOVEMENTFLAG_BACKWARD  |MOVEMENTFLAG_STRAFE_LEFT|MOVEMENTFLAG_STRAFE_RIGHT|
 746     MOVEMENTFLAG_PITCH_UP|MOVEMENTFLAG_PITCH_DOWN|MOVEMENTFLAG_FLY_UNK1    |
 747     MOVEMENTFLAG_JUMPING |MOVEMENTFLAG_FALLING   |MOVEMENTFLAG_FLY_UP      |
 748     MOVEMENTFLAG_FLYING  |MOVEMENTFLAG_SPLINE
 749 );
 750
 751 MovementFlags const movementOrTurningFlagsMask = MovementFlags(
 752     movementFlagsMask | MOVEMENTFLAG_LEFT | MOVEMENTFLAG_RIGHT
 753 );
 754 class InstanceSave;
 755
 756 enum RestType
 757 {
 758     REST_TYPE_NO        = 0,
 759     REST_TYPE_IN_TAVERN = 1,
 760     REST_TYPE_IN_CITY   = 2
 761 };
 762
 763 enum DuelCompleteType
 764 {
 765     DUEL_INTERUPTED = 0,
 766     DUEL_WON        = 1,
 767     DUEL_FLED       = 2
 768 };
 769
 770 enum TeleportToOptions
 771 {
 772     TELE_TO_GM_MODE             = 0x01,
 773     TELE_TO_NOT_LEAVE_TRANSPORT = 0x02,
 774     TELE_TO_NOT_LEAVE_COMBAT    = 0x04,
 775     TELE_TO_NOT_UNSUMMON_PET    = 0x08,
 776     TELE_TO_SPELL               = 0x10,
 777 };
 778
 779 /// Type of environmental damages
 780 enum EnviromentalDamage
 781 {
 782     DAMAGE_EXHAUSTED = 0,
 783     DAMAGE_DROWNING  = 1,
 784     DAMAGE_FALL      = 2,
 785     DAMAGE_LAVA      = 3,
 786     DAMAGE_SLIME     = 4,
 787     DAMAGE_FIRE      = 5,
 788     DAMAGE_FALL_TO_VOID = 6                                 // custom case for fall without durability loss
 789 };
 790
 791 // used at player loading query list preparing, and later result selection
 792 enum PlayerLoginQueryIndex
 793 {
 794     PLAYER_LOGIN_QUERY_LOADFROM                 = 0,
 795     PLAYER_LOGIN_QUERY_LOADGROUP                = 1,
 796     PLAYER_LOGIN_QUERY_LOADBOUNDINSTANCES       = 2,
 797     PLAYER_LOGIN_QUERY_LOADAURAS                = 3,
 798     PLAYER_LOGIN_QUERY_LOADSPELLS               = 4,
 799     PLAYER_LOGIN_QUERY_LOADQUESTSTATUS          = 5,
 800     PLAYER_LOGIN_QUERY_LOADDAILYQUESTSTATUS     = 6,
 801     PLAYER_LOGIN_QUERY_LOADTUTORIALS            = 7,        // common for all characters for some account at specific realm
 802     PLAYER_LOGIN_QUERY_LOADREPUTATION           = 8,
 803     PLAYER_LOGIN_QUERY_LOADINVENTORY            = 9,
 804     PLAYER_LOGIN_QUERY_LOADACTIONS              = 10,
 805     PLAYER_LOGIN_QUERY_LOADMAILCOUNT            = 11,
 806     PLAYER_LOGIN_QUERY_LOADMAILDATE             = 12,
 807     PLAYER_LOGIN_QUERY_LOADSOCIALLIST           = 13,
 808     PLAYER_LOGIN_QUERY_LOADHOMEBIND             = 14,
 809     PLAYER_LOGIN_QUERY_LOADSPELLCOOLDOWNS       = 15,
 810     PLAYER_LOGIN_QUERY_LOADDECLINEDNAMES        = 16,
 811     PLAYER_LOGIN_QUERY_LOADGUILD                = 17,
 812     PLAYER_LOGIN_QUERY_LOADARENAINFO            = 18,
 813
 814     MAX_PLAYER_LOGIN_QUERY
 815 };
 816
 817 // Player summoning auto-decline time (in secs)
 818 #define MAX_PLAYER_SUMMON_DELAY                   (2*MINUTE)
 819 #define MAX_MONEY_AMOUNT                       (0x7FFFFFFF-1)
 820
 821 struct InstancePlayerBind
 822 {
 823     InstanceSave *save;
 824     bool perm;
 825     /* permanent PlayerInstanceBinds are created in Raid/Heroic instances for players
 826        that aren't already permanently bound when they are inside when a boss is killed
 827        or when they enter an instance that the group leader is permanently bound to. */
 828     InstancePlayerBind() : save(NULL), perm(false) {}
 829 };
 830
 831 class MANGOS_DLL_SPEC PlayerTaxi
 832 {
 833     public:
 834         PlayerTaxi();
 835         ~PlayerTaxi() {}
 836         // Nodes
 837         void InitTaxiNodesForLevel(uint32 race, uint32 level);
 838         void LoadTaxiMask(const char* data);
 839         void SaveTaxiMask(const char* data);
 840
 841         uint32 GetTaximask( uint8 index ) const { return m_taximask[index]; }
 842         bool IsTaximaskNodeKnown(uint32 nodeidx) const
 843         {
 844             uint8  field   = uint8((nodeidx - 1) / 32);
 845             uint32 submask = 1<<((nodeidx-1)%32);
 846             return (m_taximask[field] & submask) == submask;
 847         }
 848         bool SetTaximaskNode(uint32 nodeidx)
 849         {
 850             uint8  field   = uint8((nodeidx - 1) / 32);
 851             uint32 submask = 1<<((nodeidx-1)%32);
 852             if ((m_taximask[field] & submask) != submask )
 853             {
 854                 m_taximask[field] |= submask;
 855                 return true;
 856             }
 857             else
 858                 return false;
 859         }
 860         void AppendTaximaskTo(ByteBuffer& data,bool all);
 861
 862         // Destinations
 863         bool LoadTaxiDestinationsFromString(const std::string& values);
 864         std::string SaveTaxiDestinationsToString();
 865
 866         void ClearTaxiDestinations() { m_TaxiDestinations.clear(); }
 867         void AddTaxiDestination(uint32 dest) { m_TaxiDestinations.push_back(dest); }
 868         uint32 GetTaxiSource() const { return m_TaxiDestinations.empty() ? 0 : m_TaxiDestinations.front(); }
 869         uint32 GetTaxiDestination() const { return m_TaxiDestinations.size() < 2 ? 0 : m_TaxiDestinations[1]; }
 870         uint32 GetCurrentTaxiPath() const;
 871         uint32 NextTaxiDestination()
 872         {
 873             m_TaxiDestinations.pop_front();
 874             return GetTaxiDestination();
 875         }
 876         bool empty() const { return m_TaxiDestinations.empty(); }
 877     private:
 878         TaxiMask m_taximask;
 879         std::deque<uint32> m_TaxiDestinations;
 880 };
 881
 882 class MANGOS_DLL_SPEC Player : public Unit
 883 {
 884     friend class WorldSession;
 885     friend void Item::AddToUpdateQueueOf(Player *player);
 886     friend void Item::RemoveFromUpdateQueueOf(Player *player);
 887     public:
 888         explicit Player (WorldSession *session);
 889         ~Player ( );
 890
 891         void CleanupsBeforeDelete();
 892
 893         static UpdateMask updateVisualBits;
 894         static void InitVisibleBits();
 895
 896         void AddToWorld();
 897         void RemoveFromWorld();
 898
 899         bool TeleportTo(uint32 mapid, float x, float y, float z, float orientation, uint32 options = 0);
 900
 901         bool TeleportTo(WorldLocation const &loc, uint32 options = 0)
 902         {
 903             return TeleportTo(loc.mapid, loc.x, loc.y, loc.z, options);
 904         }
 905
 906         void SetSummonPoint(uint32 mapid, float x, float y, float z)
 907         {
 908             m_summon_expire = time(NULL) + MAX_PLAYER_SUMMON_DELAY;
 909             m_summon_mapid = mapid;
 910             m_summon_x = x;
 911             m_summon_y = y;
 912             m_summon_z = z;
 913         }
 914         void SummonIfPossible(bool agree);
 915
 916         bool Create( uint32 guidlow, const std::string& name, uint8 race, uint8 class_, uint8 gender, uint8 skin, uint8 face, uint8 hairStyle, uint8 hairColor, uint8 facialHair, uint8 outfitId );
 917
 918         void Update( uint32 time );
 919
 920         void BuildEnumData( QueryResult * result,  WorldPacket * p_data );
 921
 922         void SetInWater(bool apply);
 923
 924         bool IsInWater() const { return m_isInWater; }
 925         bool IsUnderWater() const;
 926
 927         void SendInitialPacketsBeforeAddToMap();
 928         void SendInitialPacketsAfterAddToMap();
 929         void SendTransferAborted(uint32 mapid, uint16 reason);
 930         void SendInstanceResetWarning(uint32 mapid, uint32 time);
 931
 932         bool CanInteractWithNPCs(bool alive = true) const;
 933
 934         bool ToggleAFK();
 935         bool ToggleDND();
 936         bool isAFK() const { return HasFlag(PLAYER_FLAGS,PLAYER_FLAGS_AFK); };
 937         bool isDND() const { return HasFlag(PLAYER_FLAGS,PLAYER_FLAGS_DND); };
 938         uint8 chatTag() const;
 939         std::string afkMsg;
 940         std::string dndMsg;
 941
 942         PlayerSocial *GetSocial() { return m_social; }
 943
 944         PlayerTaxi m_taxi;
 945         void InitTaxiNodesForLevel() { m_taxi.InitTaxiNodesForLevel(getRace(),getLevel()); }
 946         bool ActivateTaxiPathTo(std::vector<uint32> const& nodes, uint32 mount_id = 0 , Creature* npc = NULL);
 947                                                             // mount_id can be used in scripting calls
 948         bool isAcceptTickets() const { return GetSession()->GetSecurity() >= SEC_GAMEMASTER && (m_ExtraFlags & PLAYER_EXTRA_GM_ACCEPT_TICKETS); }
 949         void SetAcceptTicket(bool on) { if(on) m_ExtraFlags |= PLAYER_EXTRA_GM_ACCEPT_TICKETS; else m_ExtraFlags &= ~PLAYER_EXTRA_GM_ACCEPT_TICKETS; }
 950         bool isAcceptWhispers() const { return m_ExtraFlags & PLAYER_EXTRA_ACCEPT_WHISPERS; }
 951         void SetAcceptWhispers(bool on) { if(on) m_ExtraFlags |= PLAYER_EXTRA_ACCEPT_WHISPERS; else m_ExtraFlags &= ~PLAYER_EXTRA_ACCEPT_WHISPERS; }
 952         bool isGameMaster() const { return m_ExtraFlags & PLAYER_EXTRA_GM_ON; }
 953         void SetGameMaster(bool on);
 954         bool isGMChat() const { return GetSession()->GetSecurity() >= SEC_MODERATOR && (m_ExtraFlags & PLAYER_EXTRA_GM_CHAT); }
 955         void SetGMChat(bool on) { if(on) m_ExtraFlags |= PLAYER_EXTRA_GM_CHAT; else m_ExtraFlags &= ~PLAYER_EXTRA_GM_CHAT; }
 956         bool isTaxiCheater() const { return m_ExtraFlags & PLAYER_EXTRA_TAXICHEAT; }
 957         void SetTaxiCheater(bool on) { if(on) m_ExtraFlags |= PLAYER_EXTRA_TAXICHEAT; else m_ExtraFlags &= ~PLAYER_EXTRA_TAXICHEAT; }
 958         bool isGMVisible() const { return !(m_ExtraFlags & PLAYER_EXTRA_GM_INVISIBLE); }
 959         void SetGMVisible(bool on);
 960         void SetPvPDeath(bool on) { if(on) m_ExtraFlags |= PLAYER_EXTRA_PVP_DEATH; else m_ExtraFlags &= ~PLAYER_EXTRA_PVP_DEATH; }
 961
 962         void GiveXP(uint32 xp, Unit* victim);
 963         void GiveLevel(uint32 level);
 964         void InitStatsForLevel(bool reapplyMods = false);
 965
 966         // Played Time Stuff
 967         time_t m_logintime;
 968         time_t m_Last_tick;
 969         uint32 m_Played_time[2];
 970         uint32 GetTotalPlayedTime() { return m_Played_time[0]; };
 971         uint32 GetLevelPlayedTime() { return m_Played_time[1]; };
 972
 973         void setDeathState(DeathState s);                   // overwrite Unit::setDeathState
 974
 975         void InnEnter (int time,uint32 mapid, float x,float y,float z)
 976         {
 977             inn_pos_mapid = mapid;
 978             inn_pos_x = x;
 979             inn_pos_y = y;
 980             inn_pos_z = z;
 981             time_inn_enter = time;
 982         };
 983
 984         float GetRestBonus() const { return m_rest_bonus; };
 985         void SetRestBonus(float rest_bonus_new);
 986
 987         RestType GetRestType() const { return rest_type; };
 988         void SetRestType(RestType n_r_type) { rest_type = n_r_type; };
 989
 990         uint32 GetInnPosMapId() const { return inn_pos_mapid; };
 991         float GetInnPosX() const { return inn_pos_x; };
 992         float GetInnPosY() const { return inn_pos_y; };
 993         float GetInnPosZ() const { return inn_pos_z; };
 994
 995         int GetTimeInnEnter() const { return time_inn_enter; };
 996         void UpdateInnerTime (int time) { time_inn_enter = time; };
 997
 998         void RemovePet(Pet* pet, PetSaveMode mode, bool returnreagent = false);
 999         void RemoveMiniPet();
1000         Pet* GetMiniPet();
1001         void SetMiniPet(Pet* pet) { m_miniPet = pet->GetGUID(); }
1002         void RemoveGuardians();
1003         bool HasGuardianWithEntry(uint32 entry);
1004         void AddGuardian(Pet* pet) { m_guardianPets.insert(pet->GetGUID()); }
1005         GuardianPetList const& GetGuardians() const { return m_guardianPets; }
1006         void Uncharm();
1007
1008         void Say(const std::string& text, const uint32 language);
1009         void Yell(const std::string& text, const uint32 language);
1010         void TextEmote(const std::string& text);
1011         void Whisper(const std::string& text, const uint32 language,uint64 receiver);
1012         void BuildPlayerChat(WorldPacket *data, uint8 msgtype, const std::string& text, uint32 language) const;
1013
1014         /*********************************************************/
1015         /***                    STORAGE SYSTEM                 ***/
1016         /*********************************************************/
1017
1018         void SetVirtualItemSlot( uint8 i, Item* item);
1019         void SetSheath( uint32 sheathed );
1020         uint8 FindEquipSlot( ItemPrototype const* proto, uint32 slot, bool swap ) const;
1021         uint32 GetItemCount( uint32 item, bool inBankAlso = false, Item* skipItem = NULL ) const;
1022         Item* GetItemByGuid( uint64 guid ) const;
1023         Item* GetItemByPos( uint16 pos ) const;
1024         Item* GetItemByPos( uint8 bag, uint8 slot ) const;
1025         Item* GetWeaponForAttack(WeaponAttackType attackType, bool useable = false) const;
1026         Item* GetShield(bool useable = false) const;
1027         static uint32 GetAttackBySlot( uint8 slot );        // MAX_ATTACK if not weapon slot
1028         std::vector<Item *> &GetItemUpdateQueue() { return m_itemUpdateQueue; }
1029         static bool IsInventoryPos( uint16 pos ) { return IsInventoryPos(pos >> 8,pos & 255); }
1030         static bool IsInventoryPos( uint8 bag, uint8 slot );
1031         static bool IsEquipmentPos( uint16 pos ) { return IsEquipmentPos(pos >> 8,pos & 255); }
1032         static bool IsEquipmentPos( uint8 bag, uint8 slot );
1033         static bool IsBagPos( uint16 pos );
1034         static bool IsBankPos( uint16 pos ) { return IsBankPos(pos >> 8,pos & 255); }
1035         static bool IsBankPos( uint8 bag, uint8 slot );
1036         bool IsValidPos( uint16 pos ) { return IsBankPos(pos >> 8,pos & 255); }
1037         bool IsValidPos( uint8 bag, uint8 slot );
1038         bool HasBankBagSlot( uint8 slot ) const;
1039         bool HasItemCount( uint32 item, uint32 count, bool inBankAlso = false ) const;
1040         bool HasItemFitToSpellReqirements(SpellEntry const* spellInfo, Item const* ignoreItem = NULL);
1041         Item* GetItemOrItemWithGemEquipped( uint32 item ) const;
1042         uint8 CanTakeMoreSimilarItems(Item* pItem) const { return _CanTakeMoreSimilarItems(pItem->GetEntry(),pItem->GetCount(),pItem); }
1043         uint8 CanTakeMoreSimilarItems(uint32 entry, uint32 count) const { return _CanTakeMoreSimilarItems(entry,count,NULL); }
1044         uint8 CanStoreNewItem( uint8 bag, uint8 slot, ItemPosCountVec& dest, uint32 item, uint32 count, uint32* no_space_count = NULL ) const
1045         {
1046             return _CanStoreItem(bag, slot, dest, item, count, NULL, false, no_space_count );
1047         }
1048         uint8 CanStoreItem( uint8 bag, uint8 slot, ItemPosCountVec& dest, Item *pItem, bool swap = false ) const
1049         {
1050             if(!pItem)
1051                 return EQUIP_ERR_ITEM_NOT_FOUND;
1052             uint32 count = pItem->GetCount();
1053             return _CanStoreItem( bag, slot, dest, pItem->GetEntry(), count, pItem, swap, NULL );
1054
1055         }
1056         uint8 CanStoreItems( Item **pItem,int count) const;
1057         uint8 CanEquipNewItem( uint8 slot, uint16 &dest, uint32 item, bool swap ) const;
1058         uint8 CanEquipItem( uint8 slot, uint16 &dest, Item *pItem, bool swap, bool not_loading = true ) const;
1059         uint8 CanUnequipItems( uint32 item, uint32 count ) const;
1060         uint8 CanUnequipItem( uint16 src, bool swap ) const;
1061         uint8 CanBankItem( uint8 bag, uint8 slot, ItemPosCountVec& dest, Item *pItem, bool swap, bool not_loading = true ) const;
1062         uint8 CanUseItem( Item *pItem, bool not_loading = true ) const;
1063         bool HasItemTotemCategory( uint32 TotemCategory ) const;
1064         bool CanUseItem( ItemPrototype const *pItem );
1065         uint8 CanUseAmmo( uint32 item ) const;
1066         Item* StoreNewItem( ItemPosCountVec const& pos, uint32 item, bool update,int32 randomPropertyId = 0 );
1067         Item* StoreItem( ItemPosCountVec const& pos, Item *pItem, bool update );
1068         Item* EquipNewItem( uint16 pos, uint32 item, bool update );
1069         Item* EquipItem( uint16 pos, Item *pItem, bool update );
1070         void AutoUnequipOffhandIfNeed();
1071         bool StoreNewItemInBestSlots(uint32 item_id, uint32 item_count);
1072
1073         uint8 _CanTakeMoreSimilarItems(uint32 entry, uint32 count, Item* pItem, uint32* no_space_count = NULL) const;
1074         uint8 _CanStoreItem( uint8 bag, uint8 slot, ItemPosCountVec& dest, uint32 entry, uint32 count, Item *pItem = NULL, bool swap = false, uint32* no_space_count = NULL ) const;
1075
1076         void ApplyEquipCooldown( Item * pItem );
1077         void SetAmmo( uint32 item );
1078         void RemoveAmmo();
1079         float GetAmmoDPS() const { return m_ammoDPS; }
1080         bool CheckAmmoCompatibility(const ItemPrototype *ammo_proto) const;
1081         void QuickEquipItem( uint16 pos, Item *pItem);
1082         void VisualizeItem( uint8 slot, Item *pItem);
1083         void SetVisibleItemSlot(uint8 slot, Item *pItem);
1084         Item* BankItem( ItemPosCountVec const& dest, Item *pItem, bool update )
1085         {
1086             return StoreItem( dest, pItem, update);
1087         }
1088         Item* BankItem( uint16 pos, Item *pItem, bool update );
1089         void RemoveItem( uint8 bag, uint8 slot, bool update );
1090         void MoveItemFromInventory(uint8 bag, uint8 slot, bool update);
1091                                                             // in trade, auction, guild bank, mail....
1092         void MoveItemToInventory(ItemPosCountVec const& dest, Item* pItem, bool update, bool in_characterInventoryDB = false);
1093                                                             // in trade, guild bank, mail....
1094         void RemoveItemDependentAurasAndCasts( Item * pItem );
1095         void DestroyItem( uint8 bag, uint8 slot, bool update );
1096         void DestroyItemCount( uint32 item, uint32 count, bool update, bool unequip_check = false);
1097         void DestroyItemCount( Item* item, uint32& count, bool update );
1098         void DestroyConjuredItems( bool update );
1099         void DestroyZoneLimitedItem( bool update, uint32 new_zone );
1100         void SplitItem( uint16 src, uint16 dst, uint32 count );
1101         void SwapItem( uint16 src, uint16 dst );
1102         void AddItemToBuyBackSlot( Item *pItem );
1103         Item* GetItemFromBuyBackSlot( uint32 slot );
1104         void RemoveItemFromBuyBackSlot( uint32 slot, bool del );
1105         uint32 GetMaxKeyringSize() const { return KEYRING_SLOT_END-KEYRING_SLOT_START; }
1106         void SendEquipError( uint8 msg, Item* pItem, Item *pItem2 );
1107         void SendBuyError( uint8 msg, Creature* pCreature, uint32 item, uint32 param );
1108         void SendSellError( uint8 msg, Creature* pCreature, uint64 guid, uint32 param );
1109         void AddWeaponProficiency(uint32 newflag) { m_WeaponProficiency |= newflag; }
1110         void AddArmorProficiency(uint32 newflag) { m_ArmorProficiency |= newflag; }
1111         uint32 GetWeaponProficiency() const { return m_WeaponProficiency; }
1112         uint32 GetArmorProficiency() const { return m_ArmorProficiency; }
1113         bool IsInFeralForm() const { return m_form == FORM_CAT || m_form == FORM_BEAR || m_form == FORM_DIREBEAR; }
1114         bool IsUseEquipedWeapon( bool mainhand ) const
1115         {
1116             // disarm applied only to mainhand weapon
1117             return !IsInFeralForm() && (!mainhand || !HasFlag(UNIT_FIELD_FLAGS,UNIT_FLAG_DISARMED) );
1118         }
1119         void SendNewItem( Item *item, uint32 count, bool received, bool created, bool broadcast = false );
1120         bool BuyItemFromVendor(uint64 vendorguid, uint32 item, uint8 count, uint64 bagguid, uint8 slot);
1121
1122         float GetReputationPriceDiscount( Creature const* pCreature ) const;
1123         Player* GetTrader() const { return pTrader; }
1124         void ClearTrade();
1125         void TradeCancel(bool sendback);
1126         uint16 GetItemPosByTradeSlot(uint32 slot) const { return tradeItems[slot]; }
1127
1128         void UpdateEnchantTime(uint32 time);
1129         void UpdateItemDuration(uint32 time, bool realtimeonly=false);
1130         void AddEnchantmentDurations(Item *item);
1131         void RemoveEnchantmentDurations(Item *item);
1132         void RemoveAllEnchantments(EnchantmentSlot slot);
1133         void AddEnchantmentDuration(Item *item,EnchantmentSlot slot,uint32 duration);
1134         void ApplyEnchantment(Item *item,EnchantmentSlot slot,bool apply, bool apply_dur = true, bool ignore_condition = false);
1135         void ApplyEnchantment(Item *item,bool apply);
1136         void SendEnchantmentDurations();
1137         void AddItemDurations(Item *item);
1138         void RemoveItemDurations(Item *item);
1139         void SendItemDurations();
1140         void LoadCorpse();
1141         void LoadPet();
1142
1143         uint32 m_stableSlots;
1144
1145         /*********************************************************/
1146         /***                    QUEST SYSTEM                   ***/
1147         /*********************************************************/
1148
1149         void PrepareQuestMenu( uint64 guid );
1150         void SendPreparedQuest( uint64 guid );
1151         bool IsActiveQuest( uint32 quest_id ) const;
1152         Quest const *GetNextQuest( uint64 guid, Quest const *pQuest );
1153         bool CanSeeStartQuest( Quest const *pQuest );
1154         bool CanTakeQuest( Quest const *pQuest, bool msg );
1155         bool CanAddQuest( Quest const *pQuest, bool msg );
1156         bool CanCompleteQuest( uint32 quest_id );
1157         bool CanCompleteRepeatableQuest(Quest const *pQuest);
1158         bool CanRewardQuest( Quest const *pQuest, bool msg );
1159         bool CanRewardQuest( Quest const *pQuest, uint32 reward, bool msg );
1160         void AddQuest( Quest const *pQuest, Object *questGiver );
1161         void CompleteQuest( uint32 quest_id );
1162         void IncompleteQuest( uint32 quest_id );
1163         void RewardQuest( Quest const *pQuest, uint32 reward, Object* questGiver, bool announce = true );
1164         void FailQuest( uint32 quest_id );
1165         void FailTimedQuest( uint32 quest_id );
1166         bool SatisfyQuestSkillOrClass( Quest const* qInfo, bool msg );
1167         bool SatisfyQuestLevel( Quest const* qInfo, bool msg );
1168         bool SatisfyQuestLog( bool msg );
1169         bool SatisfyQuestPreviousQuest( Quest const* qInfo, bool msg );
1170         bool SatisfyQuestRace( Quest const* qInfo, bool msg );
1171         bool SatisfyQuestReputation( Quest const* qInfo, bool msg );
1172         bool SatisfyQuestStatus( Quest const* qInfo, bool msg );
1173         bool SatisfyQuestTimed( Quest const* qInfo, bool msg );
1174         bool SatisfyQuestExclusiveGroup( Quest const* qInfo, bool msg );
1175         bool SatisfyQuestNextChain( Quest const* qInfo, bool msg );
1176         bool SatisfyQuestPrevChain( Quest const* qInfo, bool msg );
1177         bool SatisfyQuestDay( Quest const* qInfo, bool msg );
1178         bool GiveQuestSourceItem( Quest const *pQuest );
1179         bool TakeQuestSourceItem( uint32 quest_id, bool msg );
1180         bool GetQuestRewardStatus( uint32 quest_id ) const;
1181         QuestStatus GetQuestStatus( uint32 quest_id ) const;
1182         void SetQuestStatus( uint32 quest_id, QuestStatus status );
1183
1184         void SetDailyQuestStatus( uint32 quest_id );
1185         void ResetDailyQuestStatus();
1186
1187         uint16 FindQuestSlot( uint32 quest_id ) const;
1188         uint32 GetQuestSlotQuestId(uint16 slot) const { return GetUInt32Value(PLAYER_QUEST_LOG_1_1 + slot*MAX_QUEST_OFFSET + QUEST_ID_OFFSET); }
1189         uint32 GetQuestSlotState(uint16 slot)   const { return GetUInt32Value(PLAYER_QUEST_LOG_1_1 + slot*MAX_QUEST_OFFSET + QUEST_STATE_OFFSET); }
1190         uint32 GetQuestSlotCounters(uint16 slot)const { return GetUInt32Value(PLAYER_QUEST_LOG_1_1 + slot*MAX_QUEST_OFFSET + QUEST_COUNTS_OFFSET); }
1191         uint8 GetQuestSlotCounter(uint16 slot,uint8 counter) const { return GetByteValue(PLAYER_QUEST_LOG_1_1 + slot*MAX_QUEST_OFFSET + QUEST_COUNTS_OFFSET,counter); }
1192         uint32 GetQuestSlotTime(uint16 slot)    const { return GetUInt32Value(PLAYER_QUEST_LOG_1_1 + slot*MAX_QUEST_OFFSET + QUEST_TIME_OFFSET); }
1193         void SetQuestSlot(uint16 slot,uint32 quest_id, uint32 timer = 0)
1194         {
1195             SetUInt32Value(PLAYER_QUEST_LOG_1_1 + slot*MAX_QUEST_OFFSET + QUEST_ID_OFFSET,quest_id);
1196             SetUInt32Value(PLAYER_QUEST_LOG_1_1 + slot*MAX_QUEST_OFFSET + QUEST_STATE_OFFSET,0);
1197             SetUInt32Value(PLAYER_QUEST_LOG_1_1 + slot*MAX_QUEST_OFFSET + QUEST_COUNTS_OFFSET,0);
1198             SetUInt32Value(PLAYER_QUEST_LOG_1_1 + slot*MAX_QUEST_OFFSET + QUEST_TIME_OFFSET,timer);
1199         }
1200         void SetQuestSlotCounter(uint16 slot,uint8 counter,uint8 count) { SetByteValue(PLAYER_QUEST_LOG_1_1 + slot*MAX_QUEST_OFFSET + QUEST_COUNTS_OFFSET,counter,count); }
1201         void SetQuestSlotState(uint16 slot,uint32 state) { SetFlag(PLAYER_QUEST_LOG_1_1 + slot*MAX_QUEST_OFFSET + QUEST_STATE_OFFSET,state); }
1202         void RemoveQuestSlotState(uint16 slot,uint32 state) { RemoveFlag(PLAYER_QUEST_LOG_1_1 + slot*MAX_QUEST_OFFSET + QUEST_STATE_OFFSET,state); }
1203         void SetQuestSlotTimer(uint16 slot,uint32 timer) { SetUInt32Value(PLAYER_QUEST_LOG_1_1 + slot*MAX_QUEST_OFFSET + QUEST_TIME_OFFSET,timer); }
1204         void SwapQuestSlot(uint16 slot1,uint16 slot2)
1205         {
1206             for (int i = 0; i < MAX_QUEST_OFFSET ; ++i )
1207             {
1208                 uint32 temp1 = GetUInt32Value(PLAYER_QUEST_LOG_1_1 + MAX_QUEST_OFFSET *slot1 + i);
1209                 uint32 temp2 = GetUInt32Value(PLAYER_QUEST_LOG_1_1 + MAX_QUEST_OFFSET *slot2 + i);
1210
1211                 SetUInt32Value(PLAYER_QUEST_LOG_1_1 + MAX_QUEST_OFFSET *slot1 + i, temp2);
1212                 SetUInt32Value(PLAYER_QUEST_LOG_1_1 + MAX_QUEST_OFFSET *slot2 + i, temp1);
1213             }
1214         }
1215         uint32 GetReqKillOrCastCurrentCount(uint32 quest_id, int32 entry);
1216         void AdjustQuestReqItemCount( Quest const* pQuest );
1217         void AreaExploredOrEventHappens( uint32 questId );
1218         void GroupEventHappens( uint32 questId, WorldObject const* pEventObject );
1219         void ItemAddedQuestCheck( uint32 entry, uint32 count );
1220         void ItemRemovedQuestCheck( uint32 entry, uint32 count );
1221         void KilledMonster( uint32 entry, uint64 guid );
1222         void CastedCreatureOrGO( uint32 entry, uint64 guid, uint32 spell_id );
1223         void TalkedToCreature( uint32 entry, uint64 guid );
1224         void MoneyChanged( uint32 value );
1225         bool HasQuestForItem( uint32 itemid ) const;
1226         bool HasQuestForGO(int32 GOId);
1227         void UpdateForQuestsGO();
1228         bool CanShareQuest(uint32 quest_id) const;
1229
1230         void SendQuestComplete( uint32 quest_id );
1231         void SendQuestReward( Quest const *pQuest, uint32 XP, Object* questGiver );
1232         void SendQuestFailed( uint32 quest_id );
1233         void SendQuestTimerFailed( uint32 quest_id );
1234         void SendCanTakeQuestResponse( uint32 msg );
1235         void SendPushToPartyResponse( Player *pPlayer, uint32 msg );
1236         void SendQuestUpdateAddItem( Quest const* pQuest, uint32 item_idx, uint32 count );
1237         void SendQuestUpdateAddCreatureOrGo( Quest const* pQuest, uint64 guid, uint32 creatureOrGO_idx, uint32 old_count, uint32 add_count );
1238
1239         uint64 GetDivider() { return m_divider; };
1240         void SetDivider( uint64 guid ) { m_divider = guid; };
1241
1242         uint32 GetInGameTime() { return m_ingametime; };
1243
1244         void SetInGameTime( uint32 time ) { m_ingametime = time; };
1245
1246         void AddTimedQuest( uint32 quest_id ) { m_timedquests.insert(quest_id); }
1247
1248         /*********************************************************/
1249         /***                   LOAD SYSTEM                     ***/
1250         /*********************************************************/
1251
1252         bool LoadFromDB(uint32 guid, SqlQueryHolder *holder);
1253         bool MinimalLoadFromDB(QueryResult *result, uint32 guid);
1254         static bool   LoadValuesArrayFromDB(Tokens& data,uint64 guid);
1255         static uint32 GetUInt32ValueFromArray(Tokens const& data, uint16 index);
1256         static float  GetFloatValueFromArray(Tokens const& data, uint16 index);
1257         static uint32 GetUInt32ValueFromDB(uint16 index, uint64 guid);
1258         static float  GetFloatValueFromDB(uint16 index, uint64 guid);
1259         static uint32 GetZoneIdFromDB(uint64 guid);
1260         static bool   LoadPositionFromDB(uint32& mapid, float& x,float& y,float& z,float& o, bool& in_flight, uint64 guid);
1261
1262         /*********************************************************/
1263         /***                   SAVE SYSTEM                     ***/
1264         /*********************************************************/
1265
1266         void SaveToDB();
1267         void SaveInventoryAndGoldToDB();                    // fast save function for item/money cheating preventing
1268         void SaveDataFieldToDB();
1269         static bool SaveValuesArrayInDB(Tokens const& data,uint64 guid);
1270         static void SetUInt32ValueInArray(Tokens& data,uint16 index, uint32 value);
1271         static void SetFloatValueInArray(Tokens& data,uint16 index, float value);
1272         static void SetUInt32ValueInDB(uint16 index, uint32 value, uint64 guid);
1273         static void SetFloatValueInDB(uint16 index, float value, uint64 guid);
1274         static void SavePositionInDB(uint32 mapid, float x,float y,float z,float o,uint32 zone,uint64 guid);
1275
1276         bool m_mailsLoaded;
1277         bool m_mailsUpdated;
1278
1279         void SetBindPoint(uint64 guid);
1280         void SendTalentWipeConfirm(uint64 guid);
1281         void RewardRage( uint32 damage, uint32 weaponSpeedHitFactor, bool attacker );
1282         void SendPetSkillWipeConfirm();
1283         void CalcRage( uint32 damage,bool attacker );
1284         void RegenerateAll();
1285         void Regenerate(Powers power);
1286         void RegenerateHealth();
1287         void setRegenTimer(uint32 time) {m_regenTimer = time;}
1288         void setWeaponChangeTimer(uint32 time) {m_weaponChangeTimer = time;}
1289
1290         uint32 GetMoney() { return GetUInt32Value (PLAYER_FIELD_COINAGE); }
1291         void ModifyMoney( int32 d )
1292         {
1293             if(d < 0)
1294                 SetMoney (GetMoney() > uint32(-d) ? GetMoney() + d : 0);
1295             else
1296                 SetMoney (GetMoney() < uint32(MAX_MONEY_AMOUNT - d) ? GetMoney() + d : MAX_MONEY_AMOUNT);
1297
1298             // "At Gold Limit"
1299             if(GetMoney() >= MAX_MONEY_AMOUNT)
1300                 SendEquipError(EQUIP_ERR_TOO_MUCH_GOLD,NULL,NULL);
1301         }
1302         void SetMoney( uint32 value )
1303         {
1304             SetUInt32Value (PLAYER_FIELD_COINAGE, value);
1305             MoneyChanged( value );
1306         }
1307
1308         uint32 GetTutorialInt(uint32 intId )
1309         {
1310             ASSERT( (intId < 8) );
1311             return m_Tutorials[intId];
1312         }
1313
1314         void SetTutorialInt(uint32 intId, uint32 value)
1315         {
1316             ASSERT( (intId < 8) );
1317             if(m_Tutorials[intId]!=value)
1318             {
1319                 m_Tutorials[intId] = value;
1320                 m_TutorialsChanged = true;
1321             }
1322         }
1323
1324         QuestStatusMap& getQuestStatusMap() { return mQuestStatus; };
1325
1326         const uint64& GetSelection( ) const { return m_curSelection; }
1327         void SetSelection(const uint64 &guid) { m_curSelection = guid; SetUInt64Value(UNIT_FIELD_TARGET, guid); }
1328
1329         uint8 GetComboPoints() { return m_comboPoints; }
1330         uint64 GetComboTarget() { return m_comboTarget; }
1331
1332         void AddComboPoints(Unit* target, int8 count);
1333         void ClearComboPoints();
1334         void SendComboPoints();
1335
1336         void SendMailResult(uint32 mailId, uint32 mailAction, uint32 mailError, uint32 equipError = 0, uint32 item_guid = 0, uint32 item_count = 0);
1337         void SendNewMail();
1338         void UpdateNextMailTimeAndUnreads();
1339         void AddNewMailDeliverTime(time_t deliver_time);
1340         bool IsMailsLoaded() const { return m_mailsLoaded; }
1341
1342         //void SetMail(Mail *m);
1343         void RemoveMail(uint32 id);
1344
1345         void AddMail(Mail* mail) { m_mail.push_front(mail);}// for call from WorldSession::SendMailTo
1346         uint32 GetMailSize() { return m_mail.size();};
1347         Mail* GetMail(uint32 id);
1348
1349         PlayerMails::iterator GetmailBegin() { return m_mail.begin();};
1350         PlayerMails::iterator GetmailEnd() { return m_mail.end();};
1351
1352         /*********************************************************/
1353         /*** MAILED ITEMS SYSTEM ***/
1354         /*********************************************************/
1355
1356         uint8 unReadMails;
1357         time_t m_nextMailDelivereTime;
1358
1359         typedef UNORDERED_MAP<uint32, Item*> ItemMap;
1360
1361         ItemMap mMitems;                                    //template defined in objectmgr.cpp
1362
1363         Item* GetMItem(uint32 id)
1364         {
1365             ItemMap::const_iterator itr = mMitems.find(id);
1366             if (itr != mMitems.end())
1367                 return itr->second;
1368
1369             return NULL;
1370         }
1371
1372         void AddMItem(Item* it)
1373         {
1374             ASSERT( it );
1375             //assert deleted, because items can be added before loading
1376             mMitems[it->GetGUIDLow()] = it;
1377         }
1378
1379         bool RemoveMItem(uint32 id)
1380         {
1381             ItemMap::iterator i = mMitems.find(id);
1382             if (i == mMitems.end())
1383                 return false;
1384
1385             mMitems.erase(i);
1386             return true;
1387         }
1388
1389         void PetSpellInitialize();
1390         void CharmSpellInitialize();
1391         void PossessSpellInitialize();
1392         bool HasSpell(uint32 spell) const;
1393         TrainerSpellState GetTrainerSpellState(TrainerSpell const* trainer_spell) const;
1394         bool IsSpellFitByClassAndRace( uint32 spell_id ) const;
1395
1396         void SendProficiency(uint8 pr1, uint32 pr2);
1397         void SendInitialSpells();
1398         bool addSpell(uint32 spell_id, bool active, bool learning = true, bool loading = false, uint16 slot_id=SPELL_WITHOUT_SLOT_ID, bool disabled = false);
1399         void learnSpell(uint32 spell_id);
1400         void removeSpell(uint32 spell_id, bool disabled = false);
1401         void resetSpells();
1402         void learnDefaultSpells(bool loading = false);
1403         void learnQuestRewardedSpells();
1404         void learnQuestRewardedSpells(Quest const* quest);
1405
1406         uint32 GetFreeTalentPoints() const { return GetUInt32Value(PLAYER_CHARACTER_POINTS1); }
1407         void SetFreeTalentPoints(uint32 points) { SetUInt32Value(PLAYER_CHARACTER_POINTS1,points); }
1408         bool resetTalents(bool no_cost = false);
1409         uint32 resetTalentsCost() const;
1410         void InitTalentForLevel();
1411
1412         uint32 GetFreePrimaryProffesionPoints() const { return GetUInt32Value(PLAYER_CHARACTER_POINTS2); }
1413         void SetFreePrimaryProffesions(uint16 profs) { SetUInt32Value(PLAYER_CHARACTER_POINTS2,profs); }
1414         void InitPrimaryProffesions();
1415
1416         PlayerSpellMap const& GetSpellMap() const { return m_spells; }
1417         PlayerSpellMap      & GetSpellMap()       { return m_spells; }
1418
1419         void AddSpellMod(SpellModifier* mod, bool apply);
1420         int32 GetTotalFlatMods(uint32 spellId, SpellModOp op);
1421         int32 GetTotalPctMods(uint32 spellId, SpellModOp op);
1422         bool IsAffectedBySpellmod(SpellEntry const *spellInfo, SpellModifier *mod, Spell const* spell = NULL);
1423         template <class T> T ApplySpellMod(uint32 spellId, SpellModOp op, T &basevalue, Spell const* spell = NULL);
1424         void RemoveSpellMods(Spell const* spell);
1425
1426         bool HasSpellCooldown(uint32 spell_id) const
1427         {
1428             SpellCooldowns::const_iterator itr = m_spellCooldowns.find(spell_id);
1429             return itr != m_spellCooldowns.end() && itr->second.end > time(NULL);
1430         }
1431         uint32 GetSpellCooldownDelay(uint32 spell_id) const
1432         {
1433             SpellCooldowns::const_iterator itr = m_spellCooldowns.find(spell_id);
1434             time_t t = time(NULL);
1435             return itr != m_spellCooldowns.end() && itr->second.end > t ? itr->second.end - t : 0;
1436         }
1437         void AddSpellCooldown(uint32 spell_id, uint32 itemid, time_t end_time);
1438         void SendCooldownEvent(SpellEntry const *spellInfo);
1439         void ProhibitSpellScholl(SpellSchoolMask idSchoolMask, uint32 unTimeMs );
1440         void RemoveSpellCooldown(uint32 spell_id) { m_spellCooldowns.erase(spell_id); }
1441         void RemoveArenaSpellCooldowns();
1442         void RemoveAllSpellCooldown();
1443         void _LoadSpellCooldowns(QueryResult *result);
1444         void _SaveSpellCooldowns();
1445
1446         void setResurrectRequestData(uint64 guid, uint32 mapId, float X, float Y, float Z, uint32 health, uint32 mana)
1447         {
1448             m_resurrectGUID = guid;
1449             m_resurrectMap = mapId;
1450             m_resurrectX = X;
1451             m_resurrectY = Y;
1452             m_resurrectZ = Z;
1453             m_resurrectHealth = health;
1454             m_resurrectMana = mana;
1455         };
1456         void clearResurrectRequestData() { setResurrectRequestData(0,0,0.0f,0.0f,0.0f,0,0); }
1457         bool isRessurectRequestedBy(uint64 guid) const { return m_resurrectGUID == guid; }
1458         bool isRessurectRequested() const { return m_resurrectGUID != 0; }
1459         void ResurectUsingRequestData();
1460
1461         int getCinematic()
1462         {
1463             return m_cinematic;
1464         }
1465         void setCinematic(int cine)
1466         {
1467             m_cinematic = cine;
1468         }
1469
1470         void addActionButton(uint8 button, uint16 action, uint8 type, uint8 misc);
1471         void removeActionButton(uint8 button);
1472         void SendInitialActionButtons();
1473
1474         PvPInfo pvpInfo;
1475         void UpdatePvP(bool state, bool ovrride=false);
1476         void UpdateZone(uint32 newZone);
1477         void UpdateArea(uint32 newArea);
1478
1479         void UpdateZoneDependentAuras( uint32 zone_id );    // zones
1480         void UpdateAreaDependentAuras( uint32 area_id );    // subzones
1481
1482         void UpdateAfkReport(time_t currTime);
1483         void UpdatePvPFlag(time_t currTime);
1484         void UpdateContestedPvP(uint32 currTime);
1485         void SetContestedPvPTimer(uint32 newTime) {m_contestedPvPTimer = newTime;}
1486         void ResetContestedPvP()
1487         {
1488             clearUnitState(UNIT_STAT_ATTACK_PLAYER);
1489             RemoveFlag(PLAYER_FLAGS, PLAYER_FLAGS_CONTESTED_PVP);
1490             m_contestedPvPTimer = 0;
1491         }
1492
1493         /** todo: -maybe move UpdateDuelFlag+DuelComplete to independent DuelHandler.. **/
1494         DuelInfo *duel;
1495         void UpdateDuelFlag(time_t currTime);
1496         void CheckDuelDistance(time_t currTime);
1497         void DuelComplete(DuelCompleteType type);
1498
1499         bool IsGroupVisibleFor(Player* p) const;
1500         bool IsInSameGroupWith(Player const* p) const;
1501         bool IsInSameRaidWith(Player const* p) const { return p==this || (GetGroup() != NULL && GetGroup() == p->GetGroup()); }
1502         void UninviteFromGroup();
1503         static void RemoveFromGroup(Group* group, uint64 guid);
1504         void RemoveFromGroup() { RemoveFromGroup(GetGroup(),GetGUID()); }
1505         void SendUpdateToOutOfRangeGroupMembers();
1506
1507         void SetInGuild(uint32 GuildId) { SetUInt32Value(PLAYER_GUILDID, GuildId); }
1508         void SetRank(uint32 rankId){ SetUInt32Value(PLAYER_GUILDRANK, rankId); }
1509         void SetGuildIdInvited(uint32 GuildId) { m_GuildIdInvited = GuildId; }
1510         uint32 GetGuildId() { return GetUInt32Value(PLAYER_GUILDID);  }
1511         static uint32 GetGuildIdFromDB(uint64 guid);
1512         uint32 GetRank(){ return GetUInt32Value(PLAYER_GUILDRANK); }
1513         static uint32 GetRankFromDB(uint64 guid);
1514         int GetGuildIdInvited() { return m_GuildIdInvited; }
1515         static void RemovePetitionsAndSigns(uint64 guid, uint32 type);
1516
1517         // Arena Team
1518         void SetInArenaTeam(uint32 ArenaTeamId, uint8 slot)
1519         {
1520             SetUInt32Value(PLAYER_FIELD_ARENA_TEAM_INFO_1_1 + (slot * 6), ArenaTeamId);
1521         }
1522         uint32 GetArenaTeamId(uint8 slot) { return GetUInt32Value(PLAYER_FIELD_ARENA_TEAM_INFO_1_1 + (slot * 6)); }
1523         static uint32 GetArenaTeamIdFromDB(uint64 guid, uint8 slot);
1524         void SetArenaTeamIdInvited(uint32 ArenaTeamId) { m_ArenaTeamIdInvited = ArenaTeamId; }
1525         uint32 GetArenaTeamIdInvited() { return m_ArenaTeamIdInvited; }
1526
1527         void SetDifficulty(uint32 dungeon_difficulty) { m_dungeonDifficulty = dungeon_difficulty; }
1528         uint8 GetDifficulty() { return m_dungeonDifficulty; }
1529
1530         bool UpdateSkill(uint32 skill_id, uint32 step);
1531         bool UpdateSkillPro(uint16 SkillId, int32 Chance, uint32 step);
1532
1533         bool UpdateCraftSkill(uint32 spellid);
1534         bool UpdateGatherSkill(uint32 SkillId, uint32 SkillValue, uint32 RedLevel, uint32 Multiplicator = 1);
1535         bool UpdateFishingSkill();
1536
1537         uint32 GetBaseDefenseSkillValue() const { return GetBaseSkillValue(SKILL_DEFENSE); }
1538         uint32 GetBaseWeaponSkillValue(WeaponAttackType attType) const;
1539
1540         uint32 GetSpellByProto(ItemPrototype *proto);
1541
1542         float GetHealthBonusFromStamina();
1543         float GetManaBonusFromIntellect();
1544
1545         bool UpdateStats(Stats stat);
1546         bool UpdateAllStats();
1547         void UpdateResistances(uint32 school);
1548         void UpdateArmor();
1549         void UpdateMaxHealth();
1550         void UpdateMaxPower(Powers power);
1551         void UpdateAttackPowerAndDamage(bool ranged = false);
1552         void UpdateShieldBlockValue();
1553         void UpdateDamagePhysical(WeaponAttackType attType);
1554         void UpdateSpellDamageAndHealingBonus();
1555
1556         void CalculateMinMaxDamage(WeaponAttackType attType, bool normalized, float& min_damage, float& max_damage);
1557
1558         void UpdateDefenseBonusesMod();
1559         void ApplyRatingMod(CombatRating cr, int32 value, bool apply);
1560         float GetMeleeCritFromAgility();
1561         float GetDodgeFromAgility();
1562         float GetSpellCritFromIntellect();
1563         float OCTRegenHPPerSpirit();
1564         float OCTRegenMPPerSpirit();
1565         float GetRatingCoefficient(CombatRating cr) const;
1566         float GetRatingBonusValue(CombatRating cr) const;
1567         uint32 GetMeleeCritDamageReduction(uint32 damage) const;
1568         uint32 GetRangedCritDamageReduction(uint32 damage) const;
1569         uint32 GetSpellCritDamageReduction(uint32 damage) const;
1570         uint32 GetDotDamageReduction(uint32 damage) const;
1571
1572         float GetExpertiseDodgeOrParryReduction(WeaponAttackType attType) const;
1573         void UpdateBlockPercentage();
1574         void UpdateCritPercentage(WeaponAttackType attType);
1575         void UpdateAllCritPercentages();
1576         void UpdateParryPercentage();
1577         void UpdateDodgePercentage();
1578         void UpdateAllSpellCritChances();
1579         void UpdateSpellCritChance(uint32 school);
1580         void UpdateExpertise(WeaponAttackType attType);
1581         void UpdateManaRegen();
1582
1583         const uint64& GetLootGUID() const { return m_lootGuid; }
1584         void SetLootGUID(const uint64 &guid) { m_lootGuid = guid; }
1585
1586         void RemovedInsignia(Player* looterPlr);
1587
1588         WorldSession* GetSession() const { return m_session; }
1589         void SetSession(WorldSession *s) { m_session = s; }
1590
1591         void BuildCreateUpdateBlockForPlayer( UpdateData *data, Player *target ) const;
1592         void DestroyForPlayer( Player *target ) const;
1593         void SendDelayResponse(const uint32);
1594         void SendLogXPGain(uint32 GivenXP,Unit* victim,uint32 RestXP);
1595
1596         //Low Level Packets
1597         void PlaySound(uint32 Sound, bool OnlySelf);
1598         //notifiers
1599         void SendAttackSwingCantAttack();
1600         void SendAttackSwingCancelAttack();
1601         void SendAttackSwingDeadTarget();
1602         void SendAttackSwingNotStanding();
1603         void SendAttackSwingNotInRange();
1604         void SendAttackSwingBadFacingAttack();
1605         void SendAutoRepeatCancel();
1606         void SendExplorationExperience(uint32 Area, uint32 Experience);
1607
1608         void SendDungeonDifficulty(bool IsInGroup);
1609         void ResetInstances(uint8 method);
1610         void SendResetInstanceSuccess(uint32 MapId);
1611         void SendResetInstanceFailed(uint32 reason, uint32 MapId);
1612         void SendResetFailedNotify(uint32 mapid);
1613
1614         bool SetPosition(float x, float y, float z, float orientation, bool teleport = false);
1615         void UpdateUnderwaterState( Map * m, float x, float y, float z );
1616
1617         void SendMessageToSet(WorldPacket *data, bool self);// overwrite Object::SendMessageToSet
1618         void SendMessageToSetInRange(WorldPacket *data, float fist, bool self);
1619                                                             // overwrite Object::SendMessageToSetInRange
1620         void SendMessageToSetInRange(WorldPacket *data, float dist, bool self, bool own_team_only);
1621
1622         static void DeleteFromDB(uint64 playerguid, uint32 accountId, bool updateRealmChars = true);
1623
1624         Corpse *GetCorpse() const;
1625         void SpawnCorpseBones();
1626         void CreateCorpse();
1627         void KillPlayer();
1628         uint32 GetResurrectionSpellId();
1629         void ResurrectPlayer(float restore_percent, bool applySickness = false);
1630         void BuildPlayerRepop();
1631         void RepopAtGraveyard();
1632
1633         void DurabilityLossAll(double percent, bool inventory);
1634         void DurabilityLoss(Item* item, double percent);
1635         void DurabilityPointsLossAll(int32 points, bool inventory);
1636         void DurabilityPointsLoss(Item* item, int32 points);
1637         void DurabilityPointLossForEquipSlot(EquipmentSlots slot);
1638         uint32 DurabilityRepairAll(bool cost, float discountMod, bool guildBank);
1639         uint32 DurabilityRepair(uint16 pos, bool cost, float discountMod, bool guildBank);
1640
1641         void StopMirrorTimers()
1642         {
1643             StopMirrorTimer(FATIGUE_TIMER);
1644             StopMirrorTimer(BREATH_TIMER);
1645             StopMirrorTimer(FIRE_TIMER);
1646         }
1647
1648         void SetMovement(PlayerMovementType pType);
1649
1650         void JoinedChannel(Channel *c);
1651         void LeftChannel(Channel *c);
1652         void CleanupChannels();
1653         void UpdateLocalChannels( uint32 newZone );
1654         void LeaveLFGChannel();
1655
1656         void UpdateDefense();
1657         void UpdateWeaponSkill (WeaponAttackType attType);
1658         void UpdateCombatSkills(Unit *pVictim, WeaponAttackType attType, MeleeHitOutcome outcome, bool defence);
1659
1660         void SetSkill(uint32 id, uint16 currVal, uint16 maxVal);
1661         uint16 GetMaxSkillValue(uint32 skill) const;        // max + perm. bonus
1662         uint16 GetPureMaxSkillValue(uint32 skill) const;    // max
1663         uint16 GetSkillValue(uint32 skill) const;           // skill value + perm. bonus + temp bonus
1664         uint16 GetBaseSkillValue(uint32 skill) const;       // skill value + perm. bonus
1665         uint16 GetPureSkillValue(uint32 skill) const;       // skill value
1666         int16 GetSkillTempBonusValue(uint32 skill) const;
1667         bool HasSkill(uint32 skill) const;
1668         void learnSkillRewardedSpells( uint32 id );
1669         void learnSkillRewardedSpells();
1670
1671         void SetDontMove(bool dontMove);
1672         bool GetDontMove() const { return m_dontMove; }
1673
1674         void CheckExploreSystem(void);
1675
1676         static uint32 TeamForRace(uint8 race);
1677         uint32 GetTeam() const { return m_team; }
1678         static uint32 getFactionForRace(uint8 race);
1679         void setFactionForRace(uint8 race);
1680
1681         bool IsAtGroupRewardDistance(WorldObject const* pRewardSource) const;
1682         bool RewardPlayerAndGroupAtKill(Unit* pVictim);
1683
1684         FactionStateList m_factions;
1685         ForcedReactions m_forcedReactions;
1686         FactionStateList const& GetFactionStateList() { return m_factions; }
1687         uint32 GetDefaultReputationFlags(const FactionEntry *factionEntry) const;
1688         int32 GetBaseReputation(const FactionEntry *factionEntry) const;
1689         int32 GetReputation(uint32 faction_id) const;
1690         int32 GetReputation(const FactionEntry *factionEntry) const;
1691         ReputationRank GetReputationRank(uint32 faction) const;
1692         ReputationRank GetReputationRank(const FactionEntry *factionEntry) const;
1693         ReputationRank GetBaseReputationRank(const FactionEntry *factionEntry) const;
1694         ReputationRank ReputationToRank(int32 standing) const;
1695         const static int32 ReputationRank_Length[MAX_REPUTATION_RANK];
1696         const static int32 Reputation_Cap    =  42999;
1697         const static int32 Reputation_Bottom = -42000;
1698         bool ModifyFactionReputation(uint32 FactionTemplateId, int32 DeltaReputation);
1699         bool ModifyFactionReputation(FactionEntry const* factionEntry, int32 standing);
1700         bool ModifyOneFactionReputation(FactionEntry const* factionEntry, int32 standing);
1701         bool SetFactionReputation(uint32 FactionTemplateId, int32 standing);
1702         bool SetFactionReputation(FactionEntry const* factionEntry, int32 standing);
1703         bool SetOneFactionReputation(FactionEntry const* factionEntry, int32 standing);
1704         int32 CalculateReputationGain(uint32 creatureOrQuestLevel, int32 rep, bool for_quest);
1705         void RewardReputation(Unit *pVictim, float rate);
1706         void RewardReputation(Quest const *pQuest);
1707         void SetInitialFactions();
1708         void UpdateReputation() const;
1709         void SendFactionState(FactionState const* faction) const;
1710         void SendInitialReputations();
1711         FactionState const* GetFactionState( FactionEntry const* factionEntry) const;
1712         void SetFactionAtWar(FactionState* faction, bool atWar);
1713         void SetFactionInactive(FactionState* faction, bool inactive);
1714         void SetFactionVisible(FactionState* faction);
1715         void SetFactionVisibleForFactionTemplateId(uint32 FactionTemplateId);
1716         void SetFactionVisibleForFactionId(uint32 FactionId);
1717         void UpdateSkillsForLevel();
1718         void UpdateSkillsToMaxSkillsForLevel();             // for .levelup
1719         void ModifySkillBonus(uint32 skillid,int32 val, bool talent);
1720
1721         /*********************************************************/
1722         /***                  PVP SYSTEM                       ***/
1723         /*********************************************************/
1724         void UpdateArenaFields();
1725         void UpdateHonorFields();
1726         bool RewardHonor(Unit *pVictim, uint32 groupsize, float honor = -1);
1727         uint32 GetHonorPoints() { return GetUInt32Value(PLAYER_FIELD_HONOR_CURRENCY); }
1728         uint32 GetArenaPoints() { return GetUInt32Value(PLAYER_FIELD_ARENA_CURRENCY); }
1729         void ModifyHonorPoints( int32 value );
1730         void ModifyArenaPoints( int32 value );
1731         uint32 GetMaxPersonalArenaRatingRequirement();
1732
1733         //End of PvP System
1734
1735         void SetDrunkValue(uint16 newDrunkValue, uint32 itemid=0);
1736         uint16 GetDrunkValue() const { return m_drunk; }
1737         static DrunkenState GetDrunkenstateByValue(uint16 value);
1738
1739         uint32 GetDeathTimer() const { return m_deathTimer; }
1740         uint32 GetCorpseReclaimDelay(bool pvp) const;
1741         void UpdateCorpseReclaimDelay();
1742         void SendCorpseReclaimDelay(bool load = false);
1743
1744         uint32 GetShieldBlockValue() const;                 // overwrite Unit version (virtual)
1745         bool CanParry() const { return m_canParry; }
1746         void SetCanParry(bool value);
1747         bool CanBlock() const { return m_canBlock; }
1748         void SetCanBlock(bool value);
1749         bool CanDualWield() const { return m_canDualWield; }
1750         void SetCanDualWield(bool value) { m_canDualWield = value; }
1751
1752         void SetRegularAttackTime();
1753         void SetBaseModValue(BaseModGroup modGroup, BaseModType modType, float value) { m_auraBaseMod[modGroup][modType] = value; }
1754         void HandleBaseModValue(BaseModGroup modGroup, BaseModType modType, float amount, bool apply);
1755         float GetBaseModValue(BaseModGroup modGroup, BaseModType modType) const;
1756         float GetTotalBaseModValue(BaseModGroup modGroup) const;
1757         float GetTotalPercentageModValue(BaseModGroup modGroup) const { return m_auraBaseMod[modGroup][FLAT_MOD] + m_auraBaseMod[modGroup][PCT_MOD]; }
1758         void _ApplyAllStatBonuses();
1759         void _RemoveAllStatBonuses();
1760
1761         void _ApplyWeaponDependentAuraMods(Item *item, WeaponAttackType attackType, bool apply);
1762         void _ApplyWeaponDependentAuraCritMod(Item *item, WeaponAttackType attackType, Aura* aura, bool apply);
1763         void _ApplyWeaponDependentAuraDamageMod(Item *item, WeaponAttackType attackType, Aura* aura, bool apply);
1764
1765         void _ApplyItemMods(Item *item,uint8 slot,bool apply);
1766         void _RemoveAllItemMods();
1767         void _ApplyAllItemMods();
1768         void _ApplyItemBonuses(ItemPrototype const *proto,uint8 slot,bool apply);
1769         void _ApplyAmmoBonuses();
1770         bool EnchantmentFitsRequirements(uint32 enchantmentcondition, int8 slot);
1771         void ToggleMetaGemsActive(uint8 exceptslot, bool apply);
1772         void CorrectMetaGemEnchants(uint8 slot, bool apply);
1773         void InitDataForForm(bool reapplyMods = false);
1774
1775         void ApplyItemEquipSpell(Item *item, bool apply, bool form_change = false);
1776         void ApplyEquipSpell(SpellEntry const* spellInfo, Item* item, bool apply, bool form_change = false);
1777         void UpdateEquipSpellsAtFormChange();
1778         void CastItemCombatSpell(Item *item,Unit* Target, WeaponAttackType attType);
1779
1780         void SendInitWorldStates();
1781         void SendUpdateWorldState(uint32 Field, uint32 Value);
1782         void SendDirectMessage(WorldPacket *data);
1783
1784         void SendAuraDurationsForTarget(Unit* target);
1785
1786         PlayerMenu* PlayerTalkClass;
1787         std::vector<ItemSetEffect *> ItemSetEff;
1788
1789         void SendLoot(uint64 guid, LootType loot_type);
1790         void SendLootRelease( uint64 guid );
1791         void SendNotifyLootItemRemoved(uint8 lootSlot);
1792         void SendNotifyLootMoneyRemoved();
1793
1794         /*********************************************************/
1795         /***               BATTLEGROUND SYSTEM                 ***/
1796         /*********************************************************/
1797
1798         bool InBattleGround() const { return m_bgBattleGroundID != 0; }
1799         uint32 GetBattleGroundId() const    { return m_bgBattleGroundID; }
1800         BattleGround* GetBattleGround() const;
1801         bool InArena() const;
1802
1803         static uint32 GetMinLevelForBattleGroundQueueId(uint32 queue_id);
1804         static uint32 GetMaxLevelForBattleGroundQueueId(uint32 queue_id);
1805         uint32 GetBattleGroundQueueIdFromLevel() const;
1806
1807         bool InBattleGroundQueue() const
1808         {
1809             for (int i=0; i < PLAYER_MAX_BATTLEGROUND_QUEUES; i++)
1810                 if (m_bgBattleGroundQueueID[i].bgQueueType != 0)
1811                     return true;
1812             return false;
1813         }
1814
1815         uint32 GetBattleGroundQueueId(uint32 index) const { return m_bgBattleGroundQueueID[index].bgQueueType; }
1816         uint32 GetBattleGroundQueueIndex(uint32 bgQueueType) const
1817         {
1818             for (int i=0; i < PLAYER_MAX_BATTLEGROUND_QUEUES; i++)
1819                 if (m_bgBattleGroundQueueID[i].bgQueueType == bgQueueType)
1820                     return i;
1821             return PLAYER_MAX_BATTLEGROUND_QUEUES;
1822         }
1823         bool IsInvitedForBattleGroundQueueType(uint32 bgQueueType) const
1824         {
1825             for (int i=0; i < PLAYER_MAX_BATTLEGROUND_QUEUES; i++)
1826                 if (m_bgBattleGroundQueueID[i].bgQueueType == bgQueueType)
1827                     return m_bgBattleGroundQueueID[i].invitedToInstance != 0;
1828             return PLAYER_MAX_BATTLEGROUND_QUEUES;
1829         }
1830         bool InBattleGroundQueueForBattleGroundQueueType(uint32 bgQueueType) const
1831         {
1832             return GetBattleGroundQueueIndex(bgQueueType) < PLAYER_MAX_BATTLEGROUND_QUEUES;
1833         }
1834
1835         void SetBattleGroundId(uint32 val)  { m_bgBattleGroundID = val; }
1836         uint32 AddBattleGroundQueueId(uint32 val)
1837         {
1838             for (int i=0; i < PLAYER_MAX_BATTLEGROUND_QUEUES; i++)
1839             {
1840                 if (m_bgBattleGroundQueueID[i].bgQueueType == 0 || m_bgBattleGroundQueueID[i].bgQueueType == val)
1841                 {
1842                     m_bgBattleGroundQueueID[i].bgQueueType = val;
1843                     m_bgBattleGroundQueueID[i].invitedToInstance = 0;
1844                     return i;
1845                 }
1846             }
1847             return PLAYER_MAX_BATTLEGROUND_QUEUES;
1848         }
1849         bool HasFreeBattleGroundQueueId()
1850         {
1851             for (int i=0; i < PLAYER_MAX_BATTLEGROUND_QUEUES; i++)
1852                 if (m_bgBattleGroundQueueID[i].bgQueueType == 0)
1853                     return true;
1854             return false;
1855         }
1856         void RemoveBattleGroundQueueId(uint32 val)
1857         {
1858             for (int i=0; i < PLAYER_MAX_BATTLEGROUND_QUEUES; i++)
1859             {
1860                 if (m_bgBattleGroundQueueID[i].bgQueueType == val)
1861                 {
1862                     m_bgBattleGroundQueueID[i].bgQueueType = 0;
1863                     m_bgBattleGroundQueueID[i].invitedToInstance = 0;
1864                     return;
1865                 }
1866             }
1867         }
1868         void SetInviteForBattleGroundQueueType(uint32 bgQueueType, uint32 instanceId)
1869         {
1870             for (int i=0; i < PLAYER_MAX_BATTLEGROUND_QUEUES; i++)
1871                 if (m_bgBattleGroundQueueID[i].bgQueueType == bgQueueType)
1872                     m_bgBattleGroundQueueID[i].invitedToInstance = instanceId;
1873         }
1874         bool IsInvitedForBattleGroundInstance(uint32 instanceId) const
1875         {
1876             for (int i=0; i < PLAYER_MAX_BATTLEGROUND_QUEUES; i++)
1877                 if (m_bgBattleGroundQueueID[i].invitedToInstance == instanceId)
1878                     return true;
1879             return false;
1880         }
1881         uint32 GetBattleGroundEntryPointMap() const { return m_bgEntryPointMap; }
1882         float GetBattleGroundEntryPointX() const { return m_bgEntryPointX; }
1883         float GetBattleGroundEntryPointY() const { return m_bgEntryPointY; }
1884         float GetBattleGroundEntryPointZ() const { return m_bgEntryPointZ; }
1885         float GetBattleGroundEntryPointO() const { return m_bgEntryPointO; }
1886         void SetBattleGroundEntryPoint(uint32 Map, float PosX, float PosY, float PosZ, float PosO )
1887         {
1888             m_bgEntryPointMap = Map;
1889             m_bgEntryPointX = PosX;
1890             m_bgEntryPointY = PosY;
1891             m_bgEntryPointZ = PosZ;
1892             m_bgEntryPointO = PosO;
1893         }
1894
1895         void SetBGTeam(uint32 team) { m_bgTeam = team; }
1896         uint32 GetBGTeam() const { return m_bgTeam ? m_bgTeam : GetTeam(); }
1897
1898         void LeaveBattleground(bool teleportToEntryPoint = true);
1899         bool CanJoinToBattleground() const;
1900         bool CanReportAfkDueToLimit();
1901         void ReportedAfkBy(Player* reporter);
1902         void ClearAfkReports() { m_bgAfkReporter.clear(); }
1903
1904         bool GetBGAccessByLevel(uint32 bgTypeId) const;
1905         bool isAllowUseBattleGroundObject();
1906
1907         /*********************************************************/
1908         /***                    REST SYSTEM                    ***/
1909         /*********************************************************/
1910
1911         bool isRested() const { return GetRestTime() >= 10000; }
1912         uint32 GetXPRestBonus(uint32 xp);
1913         uint32 GetRestTime() const { return m_restTime;};
1914         void SetRestTime(uint32 v) { m_restTime = v;};
1915
1916         /*********************************************************/
1917         /***              ENVIROMENTAL SYSTEM                  ***/
1918         /*********************************************************/
1919
1920         void EnvironmentalDamage(uint64 guid, EnviromentalDamage type, uint32 damage);
1921
1922         /*********************************************************/
1923         /***               FLOOD FILTER SYSTEM                 ***/
1924         /*********************************************************/
1925
1926         void UpdateSpeakTime();
1927         bool CanSpeak() const;
1928         void ChangeSpeakTime(int utime);
1929
1930         /*********************************************************/
1931         /***                 VARIOUS SYSTEMS                   ***/
1932         /*********************************************************/
1933         MovementInfo m_movementInfo;
1934         uint32 m_lastFallTime;
1935         float  m_lastFallZ;
1936         void SetFallInformation(uint32 time, float z)
1937         {
1938             m_lastFallTime = time;
1939             m_lastFallZ = z;
1940         }
1941         bool isMoving() const { return HasUnitMovementFlag(movementFlagsMask); }
1942         bool isMovingOrTurning() const { return HasUnitMovementFlag(movementOrTurningFlagsMask); }
1943
1944         bool CanFly() const { return HasUnitMovementFlag(MOVEMENTFLAG_CAN_FLY); }
1945         bool IsFlying() const { return HasUnitMovementFlag(MOVEMENTFLAG_FLYING); }
1946
1947         void HandleDrowning();
1948
1949         void SetClientControl(Unit* target, uint8 allowMove);
1950
1951         uint64 GetFarSight() const { return GetUInt64Value(PLAYER_FARSIGHT); }
1952         void SetFarSight(uint64 guid) { SetUInt64Value(PLAYER_FARSIGHT, guid); }
1953
1954         // Transports
1955         Transport * GetTransport() const { return m_transport; }
1956         void SetTransport(Transport * t) { m_transport = t; }
1957
1958         float GetTransOffsetX() const { return m_movementInfo.t_x; }
1959         float GetTransOffsetY() const { return m_movementInfo.t_y; }
1960         float GetTransOffsetZ() const { return m_movementInfo.t_z; }
1961         float GetTransOffsetO() const { return m_movementInfo.t_o; }
1962         uint32 GetTransTime() const { return m_movementInfo.t_time; }
1963
1964         uint32 GetSaveTimer() const { return m_nextSave; }
1965         void   SetSaveTimer(uint32 timer) { m_nextSave = timer; }
1966
1967         // Recall position
1968         uint32 m_recallMap;
1969         float  m_recallX;
1970         float  m_recallY;
1971         float  m_recallZ;
1972         float  m_recallO;
1973         void   SaveRecallPosition();
1974
1975         // Homebind coordinates
1976         uint32 m_homebindMapId;
1977         uint16 m_homebindZoneId;
1978         float m_homebindX;
1979         float m_homebindY;
1980         float m_homebindZ;
1981
1982         // currently visible objects at player client
1983         typedef std::set<uint64> ClientGUIDs;
1984         ClientGUIDs m_clientGUIDs;
1985
1986         bool HaveAtClient(WorldObject const* u) { return u==this || m_clientGUIDs.find(u->GetGUID())!=m_clientGUIDs.end(); }
1987
1988         bool IsVisibleInGridForPlayer(Player* pl) const;
1989         bool IsVisibleGloballyFor(Player* pl) const;
1990
1991         void UpdateVisibilityOf(WorldObject* target);
1992
1993         template<class T>
1994             void UpdateVisibilityOf(T* target, UpdateData& data, UpdateDataMapType& data_updates, std::set<WorldObject*>& visibleNow);
1995
1996         // Stealth detection system
1997         uint32 m_DetectInvTimer;
1998         void HandleStealthedUnitsDetection();
1999
2000         uint8 m_forced_speed_changes[MAX_MOVE_TYPE];
2001
2002         bool HasAtLoginFlag(AtLoginFlags f) const { return m_atLoginFlags & f; }
2003         void SetAtLoginFlag(AtLoginFlags f) { m_atLoginFlags |= f; }
2004
2005         LookingForGroup m_lookingForGroup;
2006
2007         // Temporarily removed pet cache
2008         uint32 GetTemporaryUnsummonedPetNumber() const { return m_temporaryUnsummonedPetNumber; }
2009         void SetTemporaryUnsummonedPetNumber(uint32 petnumber) { m_temporaryUnsummonedPetNumber = petnumber; }
2010         uint32 GetOldPetSpell() const { return m_oldpetspell; }
2011         void SetOldPetSpell(uint32 petspell) { m_oldpetspell = petspell; }
2012
2013         /*********************************************************/
2014         /***                 INSTANCE SYSTEM                   ***/
2015         /*********************************************************/
2016
2017         typedef UNORDERED_MAP< uint32 /*mapId*/, InstancePlayerBind > BoundInstancesMap;
2018
2019         void UpdateHomebindTime(uint32 time);
2020
2021         uint32 m_HomebindTimer;
2022         bool m_InstanceValid;
2023         // permanent binds and solo binds by difficulty
2024         BoundInstancesMap m_boundInstances[TOTAL_DIFFICULTIES];
2025         InstancePlayerBind* GetBoundInstance(uint32 mapid, uint8 difficulty);
2026         BoundInstancesMap& GetBoundInstances(uint8 difficulty) { return m_boundInstances[difficulty]; }
2027         void UnbindInstance(uint32 mapid, uint8 difficulty, bool unload = false);
2028         void UnbindInstance(BoundInstancesMap::iterator &itr, uint8 difficulty, bool unload = false);
2029         InstancePlayerBind* BindToInstance(InstanceSave *save, bool permanent, bool load = false);
2030         void SendRaidInfo();
2031         void SendSavedInstances();
2032         static void ConvertInstancesToGroup(Player *player, Group *group = NULL, uint64 player_guid = 0);
2033
2034         /*********************************************************/
2035         /***                   GROUP SYSTEM                    ***/
2036         /*********************************************************/
2037
2038         Group * GetGroupInvite() { return m_groupInvite; }
2039         void SetGroupInvite(Group *group) { m_groupInvite = group; }
2040         Group * GetGroup() { return m_group.getTarget(); }
2041         const Group * GetGroup() const { return (const Group*)m_group.getTarget(); }
2042         GroupReference& GetGroupRef() { return m_group; }
2043         void SetGroup(Group *group, int8 subgroup = -1);
2044         uint8 GetSubGroup() const { return m_group.getSubGroup(); }
2045         uint32 GetGroupUpdateFlag() { return m_groupUpdateMask; }
2046         void SetGroupUpdateFlag(uint32 flag) { m_groupUpdateMask |= flag; }
2047         uint64 GetAuraUpdateMask() { return m_auraUpdateMask; }
2048         void SetAuraUpdateMask(uint8 slot) { m_auraUpdateMask |= (uint64(1) << slot); }
2049         Player* GetNextRandomRaidMember(float radius);
2050         PartyResult CanUninviteFromGroup() const;
2051
2052         GridReference<Player> &GetGridRef() { return m_gridRef; }
2053         MapReference &GetMapRef() { return m_mapRef; }
2054
2055         bool isAllowedToLoot(Creature* creature);
2056
2057         WorldLocation& GetTeleportDest() { return m_teleport_dest; }
2058
2059         DeclinedName const* GetDeclinedNames() const { return m_declinedname; }
2060         bool HasTitle(uint32 bitIndex);
2061         bool HasTitle(CharTitlesEntry const* title) { return HasTitle(title->bit_index); }
2062         void SetTitle(CharTitlesEntry const* title);
2063
2064     protected:
2065
2066         /*********************************************************/
2067         /***               BATTLEGROUND SYSTEM                 ***/
2068         /*********************************************************/
2069
2070         /* this variable is set to bg->m_InstanceID, when player is teleported to BG - (it is battleground's GUID)*/
2071         uint32 m_bgBattleGroundID;
2072         /*
2073         this is an array of BG queues (BgTypeIDs) in which is player
2074         */
2075         struct BgBattleGroundQueueID_Rec
2076         {
2077             uint32 bgQueueType;
2078             uint32 invitedToInstance;
2079         };
2080         BgBattleGroundQueueID_Rec m_bgBattleGroundQueueID[PLAYER_MAX_BATTLEGROUND_QUEUES];
2081         uint32 m_bgEntryPointMap;
2082         float m_bgEntryPointX;
2083         float m_bgEntryPointY;
2084         float m_bgEntryPointZ;
2085         float m_bgEntryPointO;
2086
2087         std::set<uint32> m_bgAfkReporter;
2088         uint8 m_bgAfkReportedCount;
2089         time_t m_bgAfkReportedTimer;
2090         uint32 m_contestedPvPTimer;
2091
2092         uint32 m_bgTeam;                                    // what side the player will be added to
2093
2094         /*********************************************************/
2095         /***                    QUEST SYSTEM                   ***/
2096         /*********************************************************/
2097
2098         std::set<uint32> m_timedquests;
2099
2100         uint64 m_divider;
2101         uint32 m_ingametime;
2102
2103         /*********************************************************/
2104         /***                   LOAD SYSTEM                     ***/
2105         /*********************************************************/
2106
2107         void _LoadActions(QueryResult *result);
2108         void _LoadAuras(QueryResult *result, uint32 timediff);
2109         void _LoadBoundInstances(QueryResult *result);
2110         void _LoadInventory(QueryResult *result, uint32 timediff);
2111         void _LoadMailInit(QueryResult *resultUnread, QueryResult *resultDelivery);
2112         void _LoadMail();
2113         void _LoadMailedItems(Mail *mail);
2114         void _LoadQuestStatus(QueryResult *result);
2115         void _LoadDailyQuestStatus(QueryResult *result);
2116         void _LoadGroup(QueryResult *result);
2117         void _LoadReputation(QueryResult *result);
2118         void _LoadSpells(QueryResult *result);
2119         void _LoadTutorials(QueryResult *result);
2120         void _LoadFriendList(QueryResult *result);
2121         bool _LoadHomeBind(QueryResult *result);
2122         void _LoadDeclinedNames(QueryResult *result);
2123         void _LoadArenaTeamInfo(QueryResult *result);
2124
2125         /*********************************************************/
2126         /***                   SAVE SYSTEM                     ***/
2127         /*********************************************************/
2128
2129         void _SaveActions();
2130         void _SaveAuras();
2131         void _SaveInventory();
2132         void _SaveMail();
2133         void _SaveQuestStatus();
2134         void _SaveDailyQuestStatus();
2135         void _SaveReputation();
2136         void _SaveSpells();
2137         void _SaveTutorials();
2138
2139         void _SetCreateBits(UpdateMask *updateMask, Player *target) const;
2140         void _SetUpdateBits(UpdateMask *updateMask, Player *target) const;
2141
2142         /*********************************************************/
2143         /***              ENVIRONMENTAL SYSTEM                 ***/
2144         /*********************************************************/
2145         void HandleLava();
2146         void HandleSobering();
2147         void StartMirrorTimer(MirrorTimerType Type, uint32 MaxValue);
2148         void ModifyMirrorTimer(MirrorTimerType Type, uint32 MaxValue, uint32 CurrentValue, uint32 Regen);
2149         void StopMirrorTimer(MirrorTimerType Type);
2150         uint8 m_isunderwater;
2151         bool m_isInWater;
2152
2153         /*********************************************************/
2154         /***                  HONOR SYSTEM                     ***/
2155         /*********************************************************/
2156         time_t m_lastHonorUpdateTime;
2157
2158         void outDebugValues() const;
2159         bool _removeSpell(uint16 spell_id);
2160         uint64 m_lootGuid;
2161
2162         uint32 m_race;
2163         uint32 m_class;
2164         uint32 m_team;
2165         uint32 m_nextSave;
2166         time_t m_speakTime;
2167         uint32 m_speakCount;
2168         uint32 m_dungeonDifficulty;
2169
2170         uint32 m_atLoginFlags;
2171
2172         Item* m_items[PLAYER_SLOTS_COUNT];
2173         uint32 m_currentBuybackSlot;
2174
2175         std::vector<Item*> m_itemUpdateQueue;
2176         bool m_itemUpdateQueueBlocked;
2177
2178         uint32 m_ExtraFlags;
2179         uint64 m_curSelection;
2180
2181         uint64 m_comboTarget;
2182         int8 m_comboPoints;
2183
2184         QuestStatusMap mQuestStatus;
2185
2186         uint32 m_GuildIdInvited;
2187         uint32 m_ArenaTeamIdInvited;
2188
2189         PlayerMails m_mail;
2190         PlayerSpellMap m_spells;
2191         SpellCooldowns m_spellCooldowns;
2192
2193         ActionButtonList m_actionButtons;
2194
2195         float m_auraBaseMod[BASEMOD_END][MOD_END];
2196
2197         SpellModList m_spellMods[MAX_SPELLMOD];
2198         int32 m_SpellModRemoveCount;
2199         EnchantDurationList m_enchantDuration;
2200         ItemDurationList m_itemDuration;
2201
2202         uint64 m_resurrectGUID;
2203         uint32 m_resurrectMap;
2204         float m_resurrectX, m_resurrectY, m_resurrectZ;
2205         uint32 m_resurrectHealth, m_resurrectMana;
2206
2207         WorldSession *m_session;
2208
2209         typedef std::list<Channel*> JoinedChannelsList;
2210         JoinedChannelsList m_channels;
2211
2212         bool m_dontMove;
2213
2214         int m_cinematic;
2215
2216         Player *pTrader;
2217         bool acceptTrade;
2218         uint16 tradeItems[TRADE_SLOT_COUNT];
2219         uint32 tradeGold;
2220
2221         time_t m_nextThinkTime;
2222
2223         uint32 m_Tutorials[8];
2224         bool   m_TutorialsChanged;
2225
2226         bool   m_DailyQuestChanged;
2227         time_t m_lastDailyQuestTime;
2228
2229         uint32 m_regenTimer;
2230         uint32 m_breathTimer;
2231         uint32 m_drunkTimer;
2232         uint16 m_drunk;
2233         uint32 m_weaponChangeTimer;
2234
2235         uint32 m_zoneUpdateId;
2236         uint32 m_zoneUpdateTimer;
2237         uint32 m_areaUpdateId;
2238
2239         uint32 m_deathTimer;
2240         time_t m_deathExpireTime;
2241
2242         uint32 m_restTime;
2243
2244         uint32 m_WeaponProficiency;
2245         uint32 m_ArmorProficiency;
2246         bool m_canParry;
2247         bool m_canBlock;
2248         bool m_canDualWield;
2249         uint8 m_swingErrorMsg;
2250         float m_ammoDPS;
2251         ////////////////////Rest System/////////////////////
2252         int time_inn_enter;
2253         uint32 inn_pos_mapid;
2254         float  inn_pos_x;
2255         float  inn_pos_y;
2256         float  inn_pos_z;
2257         float m_rest_bonus;
2258         RestType rest_type;
2259         ////////////////////Rest System/////////////////////
2260
2261         // Transports
2262         Transport * m_transport;
2263
2264         uint32 m_resetTalentsCost;
2265         time_t m_resetTalentsTime;
2266         uint32 m_usedTalentCount;
2267
2268         // Social
2269         PlayerSocial *m_social;
2270
2271         // Groups
2272         GroupReference m_group;
2273         Group *m_groupInvite;
2274         uint32 m_groupUpdateMask;
2275         uint64 m_auraUpdateMask;
2276
2277         // Temporarily removed pet cache
2278         uint32 m_temporaryUnsummonedPetNumber;
2279         uint32 m_oldpetspell;
2280
2281         uint64 m_miniPet;
2282         GuardianPetList m_guardianPets;
2283
2284         // Player summoning
2285         time_t m_summon_expire;
2286         uint32 m_summon_mapid;
2287         float  m_summon_x;
2288         float  m_summon_y;
2289         float  m_summon_z;
2290
2291         // Far Teleport
2292         WorldLocation m_teleport_dest;
2293
2294         DeclinedName *m_declinedname;
2295     private:
2296         // internal common parts for CanStore/StoreItem functions
2297         uint8 _CanStoreItem_InSpecificSlot( uint8 bag, uint8 slot, ItemPosCountVec& dest, ItemPrototype const *pProto, uint32& count, bool swap, Item *pSrcItem ) const;
2298         uint8 _CanStoreItem_InBag( uint8 bag, ItemPosCountVec& dest, ItemPrototype const *pProto, uint32& count, bool merge, bool non_specialized, Item *pSrcItem, uint8 skip_bag, uint8 skip_slot ) const;
2299         uint8 _CanStoreItem_InInventorySlots( uint8 slot_begin, uint8 slot_end, ItemPosCountVec& dest, ItemPrototype const *pProto, uint32& count, bool merge, Item *pSrcItem, uint8 skip_bag, uint8 skip_slot ) const;
2300         Item* _StoreItem( uint16 pos, Item *pItem, uint32 count, bool clone, bool update );
2301
2302         GridReference<Player> m_gridRef;
2303         MapReference m_mapRef;
2304 };
2305
2306 void AddItemsSetItem(Player*player,Item *item);
2307 void RemoveItemsSetItem(Player*player,ItemPrototype const *proto);
2308
2309 // "the bodies of template functions must be made available in a header file"
2310 template <class T> T Player::ApplySpellMod(uint32 spellId, SpellModOp op, T &basevalue, Spell const* spell)
2311 {
2312     SpellEntry const *spellInfo = sSpellStore.LookupEntry(spellId);
2313     if (!spellInfo) return 0;
2314     int32 totalpct = 0;
2315     int32 totalflat = 0;
2316     for (SpellModList::iterator itr = m_spellMods[op].begin(); itr != m_spellMods[op].end(); ++itr)
2317     {
2318         SpellModifier *mod = *itr;
2319
2320         if(!IsAffectedBySpellmod(spellInfo,mod,spell))
2321             continue;
2322         if (mod->type == SPELLMOD_FLAT)
2323             totalflat += mod->value;
2324         else if (mod->type == SPELLMOD_PCT)
2325         {
2326             // skip percent mods for null basevalue (most important for spell mods with charges )
2327             if(basevalue == T(0))
2328                 continue;
2329
2330             // special case (skip >10sec spell casts for instant cast setting)
2331             if( mod->op==SPELLMOD_CASTING_TIME  && basevalue >= T(10000) && mod->value <= -100)
2332                 continue;
2333
2334             totalpct += mod->value;
2335         }
2336
2337         if (mod->charges > 0 )
2338         {
2339             --mod->charges;
2340             if (mod->charges == 0)
2341             {
2342                 mod->charges = -1;
2343                 mod->lastAffected = spell;
2344                 if(!mod->lastAffected)
2345                     mod->lastAffected = FindCurrentSpellBySpellId(spellId);
2346                 ++m_SpellModRemoveCount;
2347             }
2348         }
2349     }
2350
2351     float diff = (float)basevalue*(float)totalpct/100.0f + (float)totalflat;
2352     basevalue = T((float)basevalue + diff);
2353     return T(diff);
2354 }
2355 #endif