Context Navigation

Player.h @ 12

Revision 12, 96.8 kB (checked in by yumileroy, 17 years ago)

[svn] * PlaySound? changed to SendPlaySound?, moved to WorldObject? and used everywhere instead of hard-coding packet

Original author: Neo2003
Date: 2008-10-05 11:38:24-05:00

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

Note: See TracBrowser for help on using the browser.

Context Navigation

root/trunk/src/game/Player.h @ 12

Download in other formats: