EQ2EMu/EQ2/source/WorldServer/Player.cpp

/*  
    EQ2Emulator:  Everquest II Server Emulator
    Copyright (C) 2007  EQ2EMulator Development Team (http://www.eq2emulator.net)

    This file is part of EQ2Emulator.

    EQ2Emulator is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    EQ2Emulator is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with EQ2Emulator.  If not, see <http://www.gnu.org/licenses/>.
*/
#include "Player.h"
#include "../common/MiscFunctions.h"
#include "World.h"
#include "WorldDatabase.h"
#include <math.h>
#include "classes.h"
#include "LuaInterface.h"
#include "../common/Log.h"
#include "Rules/Rules.h"
#include "Titles.h"
#include "Languages.h"
#include "SpellProcess.h"
#include <algorithm>
#include <regex>
#include "ClientPacketFunctions.h"

extern Classes classes;
extern WorldDatabase database;
extern World world;
extern ConfigReader configReader;
extern MasterSkillList master_skill_list;
extern MasterSpellList master_spell_list;
extern MasterQuestList master_quest_list;
extern Variables variables;
extern LuaInterface* lua_interface;
extern MasterItemList master_item_list;
extern RuleManager rule_manager;
extern MasterTitlesList master_titles_list;
extern MasterLanguagesList master_languages_list;

Player::Player(){
	tutorial_step = 0;
	char_id = 0;
	group = 0;
	appearance.pos.grid_id = 0;
	spawn_index = 1;
	info = 0;
	movement_packet = 0;
	fully_logged_in = false;
	last_movement_activity = 0;
	//speed = 0;
	packet_num = 0;
	range_attack = false;
	old_movement_packet = 0;
	charsheet_changed = false;
	quickbar_updated = false;
	custNPC = false;
	spawn_tmp_vis_xor_packet = 0;
	spawn_tmp_pos_xor_packet = 0;
	spawn_tmp_info_xor_packet = 0;
	pending_collection_reward = 0;
	pos_packet_speed = 0;

	appearance.display_name = 1;
	appearance.show_command_icon = 1;
	appearance.player_flag = 1;
	appearance.targetable = 1;
	appearance.show_level = 1;
	spell_count = 0;
	spell_orig_packet = 0;
	spell_xor_packet = 0;
	resurrecting = false;
	spawn_id = 1;
	spawn_type = 4;
	player_spawn_id_map[1] = this;
	player_spawn_reverse_id_map[this] = 1;
	MPlayerQuests.SetName("Player::MPlayerQuests");
	test_time = 0;
	returning_from_ld = false;
	away_message = "Sorry, I am A.F.K. (Away From Keyboard)";
	AddSecondaryEntityCommand("Inspect", 10000, "inspect_player", "", 0, 0);
	AddSecondaryEntityCommand("Who", 10000, "who", "", 0, 0);
	//  commented out commands a player canNOT use on themselves... move these to Client::HandleVerbRequest()?
	//AddSecondaryEntityCommand("Assist", 10, "assist", "", 0, 0);
	//AddSecondaryEntityCommand("Duel", 10, "duel", "", 0, 0);
	//AddSecondaryEntityCommand("Duel Bet", 10, "duelbet", "", 0, 0);
	//AddSecondaryEntityCommand("Trade", 10, "trade", "", 0, 0);
	is_tracking = false;
	guild = 0;
	following = false;
	combat_target = 0;
	InitXPTable();
	pending_deletion = false;
	spawn_vis_struct = 0;
	spawn_pos_struct = 0;
	spawn_info_struct = 0;
	spawn_header_struct = 0;
	spawn_footer_struct = 0;
	widget_footer_struct = 0;
	sign_footer_struct = 0;
	pos_xor_size = 0;
	info_xor_size = 0;
	vis_xor_size = 0;
	pos_mutex.SetName("Player::pos_mutex");
	vis_mutex.SetName("Player::vis_mutex");
	info_mutex.SetName("Player::info_mutex");
	index_mutex.SetName("Player::index_mutex");
	spawn_mutex.SetName("Player::spawn_mutex");
	m_playerSpawnQuestsRequired.SetName("Player::player_spawn_quests_required");
	m_playerSpawnHistoryRequired.SetName("Player::player_spawn_history_required");
	gm_vision = false;
	SetSaveSpellEffects(true);
	reset_mentorship = false;
	all_spells_locked = false;
	current_language_id = 0;
	active_reward = false;
}
Player::~Player(){
	SetSaveSpellEffects(true);
	DeleteSpellEffects();
	for(int32 i=0;i<spells.size();i++){
		safe_delete(spells[i]);
	}
	for(int32 i=0;i<quickbar_items.size();i++){
		safe_delete(quickbar_items[i]);
	}
	map<int32, vector<int32>*>::iterator itr;
	for (itr = player_spawn_quests_required.begin(); itr != player_spawn_quests_required.end(); itr++){
		safe_delete(itr->second);
	}
	for (itr = player_spawn_history_required.begin(); itr != player_spawn_history_required.end(); itr++){
		safe_delete(itr->second);
	}

	map<int8, map<int8, vector<HistoryData*> > >::iterator itr1;
	map<int8, vector<HistoryData*> >::iterator itr2;
	vector<HistoryData*>::iterator itr3;
	// Type
	for (itr1 = m_characterHistory.begin(); itr1 != m_characterHistory.end(); itr1++) {
		// Sub type
		for (itr2 = itr1->second.begin(); itr2 != itr1->second.end(); itr2++) {
			// vector of data
			for (itr3 = itr2->second.begin(); itr3 != itr2->second.end(); itr3++) {
				safe_delete(*itr3);
			}
		}
	}

	mLUAHistory.writelock();
	map<int32, LUAHistory*>::iterator itr4;
	for (itr4 = m_charLuaHistory.begin(); itr4 != m_charLuaHistory.end(); itr4++) {
		safe_delete(itr4->second);
	}
	m_charLuaHistory.clear();
	mLUAHistory.releasewritelock();

	safe_delete_array(movement_packet);
	safe_delete_array(old_movement_packet);
	safe_delete_array(spawn_tmp_info_xor_packet);
	safe_delete_array(spawn_tmp_vis_xor_packet);
	safe_delete_array(spawn_tmp_pos_xor_packet);
	safe_delete_array(spell_xor_packet);
	safe_delete_array(spell_orig_packet);
	DestroyQuests();
	WritePlayerStatistics();
	RemovePlayerStatistics();
	DeleteMail();
	world.RemoveLottoPlayer(GetCharacterID());
	safe_delete(info);
	index_mutex.writelock(__FUNCTION__, __LINE__);
	player_spawn_reverse_id_map.clear();
	player_spawn_id_map.clear();
	index_mutex.releasewritelock(__FUNCTION__, __LINE__);

	info_mutex.writelock(__FUNCTION__, __LINE__);
	spawn_info_packet_list.clear();
	info_mutex.releasewritelock(__FUNCTION__, __LINE__);
	vis_mutex.writelock(__FUNCTION__, __LINE__);
	spawn_vis_packet_list.clear();
	vis_mutex.releasewritelock(__FUNCTION__, __LINE__);
	pos_mutex.writelock(__FUNCTION__, __LINE__);
	spawn_pos_packet_list.clear();
	pos_mutex.releasewritelock(__FUNCTION__, __LINE__);

	safe_delete(spawn_header_struct);
	safe_delete(spawn_footer_struct);
	safe_delete(sign_footer_struct);
	safe_delete(widget_footer_struct);
	safe_delete(spawn_info_struct);
	safe_delete(spawn_vis_struct);
	safe_delete(spawn_pos_struct);
	ClearPendingSelectableItemRewards(0, true);
	ClearPendingItemRewards();
}

EQ2Packet* Player::serialize(Player* player, int16 version){
	return spawn_serialize(player, version);
}

EQ2Packet* Player::Move(float x, float y, float z, int16 version, float heading){
	PacketStruct* packet = configReader.getStruct("WS_MoveClient", version);
	if(packet){
		packet->setDataByName("x", x);
		packet->setDataByName("y", y);
		packet->setDataByName("z", z);
		packet->setDataByName("unknown", 1);	// 1 seems to force the client to re-render the zone at the new location
		packet->setDataByName("location", 0xFFFFFFFF); //added in 869
		if (heading != -1.0f)
			packet->setDataByName("heading", heading);
		EQ2Packet* outapp = packet->serialize();
		safe_delete(packet);
		return outapp;
	}
	return 0;
}

void Player::DestroyQuests(){
	MPlayerQuests.writelock(__FUNCTION__, __LINE__);
	map<int32, Quest*>::iterator itr;
	for(itr = completed_quests.begin(); itr != completed_quests.end(); itr++){
		safe_delete(itr->second);
	}
	completed_quests.clear();
	for(itr = player_quests.begin(); itr != player_quests.end(); itr++){
		safe_delete(itr->second);
	}
	player_quests.clear();
	for(itr = pending_quests.begin(); itr != pending_quests.end(); itr++){
		safe_delete(itr->second);
	}
	pending_quests.clear();
	MPlayerQuests.releasewritelock(__FUNCTION__, __LINE__);
}

PlayerInfo* Player::GetPlayerInfo(){
	if(info == 0)
		info = new PlayerInfo(this);
	return info;
}

void PlayerInfo::CalculateXPPercentages(){
	int32 xp_needed = info_struct->get_xp_needed();
	if(xp_needed > 0){
		float percentage = ((double)info_struct->get_xp() / xp_needed) * 1000;
		info_struct->set_xp_yellow((int16)percentage);
		info_struct->set_xp_blue((int16)(percentage-info_struct->get_xp_yellow())*1000);
		info_struct->set_xp_blue_vitality_bar(0);
		info_struct->set_xp_yellow_vitality_bar(0);
		if(player->GetXPVitality() > 0){
			float vitality_total = player->GetXPVitality()*10 + percentage;
			vitality_total -= ((int)(percentage/100)*100);
			if(vitality_total < 100){ //10%
				info_struct->set_xp_blue_vitality_bar(info_struct->get_xp_blue() + (int16)(player->GetXPVitality() *10));
			}
			else
				info_struct->set_xp_yellow_vitality_bar(info_struct->get_xp_yellow() + (int16)(player->GetXPVitality() *10));
		}
	}
}

void PlayerInfo::CalculateTSXPPercentages(){
	int32 ts_xp_needed = info_struct->get_ts_xp_needed();
	if(ts_xp_needed > 0){
		float percentage = ((double)info_struct->get_ts_xp() / ts_xp_needed) * 1000;
		info_struct->set_tradeskill_exp_yellow((int16)percentage);
		info_struct->set_tradeskill_exp_blue((int16)((percentage - info_struct->get_tradeskill_exp_yellow()) * 1000));
		/*info_struct->xp_blue_vitality_bar = 0;
		info_struct->xp_yellow_vitality_bar = 0;
		if(player->GetXPVitality() > 0){
			float vitality_total = player->GetXPVitality()*10 + percentage;
			vitality_total -= ((int)(percentage/100)*100);
			if(vitality_total < 100){ //10%
				info_struct->xp_blue_vitality_bar = info_struct->xp_blue + (int16)(player->GetXPVitality() *10);
			}
			else
				info_struct->xp_yellow_vitality_bar = info_struct->xp_yellow + (int16)(player->GetXPVitality() *10);
		}*/
	}
}

void PlayerInfo::SetHouseZone(int32 id){
	house_zone_id = id;
}

void PlayerInfo::SetBindZone(int32 id){
	bind_zone_id = id;
}

void PlayerInfo::SetBindX(float x){
	bind_x = x;
}

void PlayerInfo::SetBindY(float y){
	bind_y = y;
}

void PlayerInfo::SetBindZ(float z){
	bind_z = z;
}

void PlayerInfo::SetBindHeading(float heading){
	bind_heading = heading;
}

int32 PlayerInfo::GetHouseZoneID(){
	return house_zone_id;
}

int32 PlayerInfo::GetBindZoneID(){
	return bind_zone_id;
}

float PlayerInfo::GetBindZoneX(){
	return bind_x;
}

float PlayerInfo::GetBindZoneY(){
	return bind_y;
}

float PlayerInfo::GetBindZoneZ(){
	return bind_z;
}

float PlayerInfo::GetBindZoneHeading(){
	return bind_heading;
}

PacketStruct* PlayerInfo::serialize2(int16 version){
	player->CalculateBonuses();
	PacketStruct* packet = configReader.getStruct("WS_CharacterSheet", version);
	if(packet){
		//TODO: 2021 FIX THIS CASTING
		char deity[32];
		strncpy(deity, info_struct->get_deity().c_str(), 32);
		packet->setDataByName("deity", deity);
		
		char name[40];
		strncpy(name, info_struct->get_name().c_str(), 40);
		packet->setDataByName("character_name", name);
		packet->setDataByName("race", info_struct->get_race());
		packet->setDataByName("gender", info_struct->get_gender());
		packet->setDataByName("class1", info_struct->get_class1());
		packet->setDataByName("class2", info_struct->get_class2());
		packet->setDataByName("class3", info_struct->get_class3());
		packet->setDataByName("tradeskill_class1", info_struct->get_tradeskill_class1());
		packet->setDataByName("tradeskill_class2", info_struct->get_tradeskill_class2());
		packet->setDataByName("tradeskill_class3", info_struct->get_tradeskill_class3());
		packet->setDataByName("level", info_struct->get_level());
		packet->setDataByName("effective_level", info_struct->get_effective_level() != 0 ? info_struct->get_effective_level() : info_struct->get_level());
		packet->setDataByName("tradeskill_level", info_struct->get_tradeskill_level());
		packet->setDataByName("account_age_base", info_struct->get_account_age_base());

//		for(int8 i=0;i<19;i++)
//		{
//			packet->setDataByName("account_age_bonus", info_struct->get_account_age_bonus(i));
//		}

		//
		packet->setDataByName("current_hp", player->GetHP());
		packet->setDataByName("max_hp",player-> GetTotalHP());
		packet->setDataByName("base_hp", player->GetTotalHPBase());
		float bonus_health = floor( (float)(info_struct->get_sta() * player->CalculateBonusMod()));
		packet->setDataByName("bonus_health", bonus_health);
		packet->setDataByName("stat_bonus_health", player->CalculateBonusMod());
		packet->setDataByName("current_power", player->GetPower());
		packet->setDataByName("max_power", player->GetTotalPower());
		packet->setDataByName("base_power", player->GetTotalPowerBase());
		packet->setDataByName("bonus_power", floor( (float)(player->GetPrimaryStat() * player->CalculateBonusMod())));
		packet->setDataByName("stat_bonus_power", player->CalculateBonusMod());
		packet->setDataByName("conc_used", info_struct->get_cur_concentration());
		packet->setDataByName("conc_max", info_struct->get_max_concentration());
		packet->setDataByName("attack", info_struct->get_cur_attack());
		packet->setDataByName("attack_base", info_struct->get_attack_base());
		packet->setDataByName("absorb", info_struct->get_absorb());
		packet->setDataByName("mitigation_skill1", info_struct->get_mitigation_skill1());
		packet->setDataByName("mitigation_skill2", info_struct->get_mitigation_skill2());
		packet->setDataByName("mitigation_skill3", info_struct->get_mitigation_skill3());
		CalculateXPPercentages();
		packet->setDataByName("exp_yellow", info_struct->get_xp_yellow());
		packet->setDataByName("exp_blue", info_struct->get_xp_blue());
		packet->setDataByName("tradeskill_exp_yellow", info_struct->get_tradeskill_exp_yellow());
		packet->setDataByName("tradeskill_exp_blue", info_struct->get_tradeskill_exp_blue());
		packet->setDataByName("flags", info_struct->get_flags());
		packet->setDataByName("flags2", info_struct->get_flags2());

		packet->setDataByName("avoidance_pct", (int16)info_struct->get_avoidance_display()*10.0f);//avoidance_pct 192 = 19.2% // confirmed DoV
		packet->setDataByName("avoidance_base", (int16)info_struct->get_avoidance_base()*10.0f); // confirmed DoV
		packet->setDataByName("avoidance", info_struct->get_cur_avoidance());
		packet->setDataByName("base_avoidance_pct", info_struct->get_base_avoidance_pct());// confirmed DoV
		float parry_pct = info_struct->get_parry(); // client works off of int16, but we use floats to track the actual x/100%
		packet->setDataByName("parry",(int16)(parry_pct*10.0f));// confirmed DoV

		float block_pct = info_struct->get_block()*10.0f;
		
		packet->setDataByName("block", (int16)block_pct);// confirmed DoV
		packet->setDataByName("uncontested_block", info_struct->get_uncontested_block());// confirmed DoV

		packet->setDataByName("str", info_struct->get_str());
		packet->setDataByName("sta", info_struct->get_sta());
		packet->setDataByName("agi", info_struct->get_agi());
		packet->setDataByName("wis", info_struct->get_wis());
		packet->setDataByName("int", info_struct->get_intel());
		packet->setDataByName("str_base", info_struct->get_str_base());
		packet->setDataByName("sta_base", info_struct->get_sta_base());
		packet->setDataByName("agi_base", info_struct->get_agi_base());
		packet->setDataByName("wis_base", info_struct->get_wis_base());
		packet->setDataByName("int_base", info_struct->get_intel_base());
		packet->setDataByName("mitigation_cur", info_struct->get_cur_mitigation());
		packet->setDataByName("mitigation_max", info_struct->get_max_mitigation());
		packet->setDataByName("mitigation_base", info_struct->get_mitigation_base());
		packet->setDataByName("heat", info_struct->get_heat());
		packet->setDataByName("cold", info_struct->get_cold());
		packet->setDataByName("magic", info_struct->get_magic());
		packet->setDataByName("mental", info_struct->get_mental());
		packet->setDataByName("divine", info_struct->get_divine());
		packet->setDataByName("disease", info_struct->get_disease());
		packet->setDataByName("poison", info_struct->get_poison());
		packet->setDataByName("heat_base", info_struct->get_heat_base());
		packet->setDataByName("cold_base", info_struct->get_cold_base());
		packet->setDataByName("magic_base", info_struct->get_magic_base());
		packet->setDataByName("mental_base", info_struct->get_mental_base());
		packet->setDataByName("divine_base", info_struct->get_divine_base());
		packet->setDataByName("disease_base", info_struct->get_disease_base());
		packet->setDataByName("poison_base", info_struct->get_poison_base());
		packet->setDataByName("mitigation_cur2", info_struct->get_cur_mitigation());
		packet->setDataByName("mitigation_max2", info_struct->get_max_mitigation());
		packet->setDataByName("mitigation_base2", info_struct->get_mitigation_base());
		packet->setDataByName("coins_copper", info_struct->get_coin_copper());
		packet->setDataByName("coins_silver", info_struct->get_coin_silver());
		packet->setDataByName("coins_gold", info_struct->get_coin_gold());
		packet->setDataByName("coins_plat", info_struct->get_coin_plat());
		packet->setDataByName("weight", info_struct->get_weight());
		packet->setDataByName("max_weight", info_struct->get_max_weight());
		
		if(info_struct->get_pet_id() != 0xFFFFFFFF) {
			char pet_name[32];
			strncpy(pet_name, info_struct->get_pet_name().c_str(), 32);
			packet->setDataByName("pet_name", pet_name);
		}
		else {
			packet->setDataByName("pet_name", "No Pet");
		}
		packet->setDataByName("status_points", info_struct->get_status_points());
		if(bind_zone_id > 0){
			string bind_name = database.GetZoneName(bind_zone_id);
			if (bind_name.length() > 0)
				packet->setDataByName("bind_zone", bind_name.c_str());
		}
		else
			packet->setDataByName("bind_zone", "None");
		if(house_zone_id > 0){
			string house_name = database.GetZoneName(house_zone_id);
			if (house_name.length() > 0)
				packet->setDataByName("house_zone", house_name.c_str());
		}
		else
			packet->setDataByName("house_zone", "None");
		//packet->setDataByName("account_age_base", 14);
		packet->setDataByName("hp_regen", info_struct->get_hp_regen());
		packet->setDataByName("power_regen", info_struct->get_power_regen());
		/*packet->setDataByName("unknown11", -1, 0);
		packet->setDataByName("unknown11", -1, 1);
		packet->setDataByName("unknown13", 201, 0);
		packet->setDataByName("unknown13", 201, 1);
		packet->setDataByName("unknown13", 234, 2);
		packet->setDataByName("unknown13", 201, 3);
		packet->setDataByName("unknown13", 214, 4);
		packet->setDataByName("unknown13", 234, 5);
		packet->setDataByName("unknown13", 234, 6);

		packet->setDataByName("unknown14", 78);
		*/
		packet->setDataByName("adventure_exp_vitality", (int16)(player->GetXPVitality() *10));
		//packet->setDataByName("unknown15b", 9911);
		packet->setDataByName("unknown15a", 78);
		packet->setDataByName("xp_yellow_vitality_bar", info_struct->get_xp_yellow_vitality_bar());
		packet->setDataByName("xp_blue_vitality_bar", info_struct->get_xp_blue_vitality_bar());
		packet->setDataByName("tradeskill_exp_vitality", 100);
		packet->setDataByName("unknown15c", 200);

		//packet->setDataByName("unknown15", 100, 10);
		packet->setDataByName("unknown18", 16880, 1);
		/*packet->setDataByName("unknown19", 1);
		packet->setDataByName("unknown19", 3, 1);
		packet->setDataByName("unknown19", 1074301064, 2);
		packet->setDataByName("unknown19", 1, 3);
		packet->setDataByName("unknown19", 3, 4);
		packet->setDataByName("unknown19", 1074301064, 5);
		packet->setDataByName("unknown19", 6, 6);
		packet->setDataByName("unknown19", 14, 7);
		packet->setDataByName("unknown19", 1083179008, 8);*/
		player->SetGroupInformation(packet);
		packet->setDataByName("unknown20", 1, 107);
		packet->setDataByName("unknown20", 1, 108);
		packet->setDataByName("unknown20", 1, 109);
		packet->setDataByName("unknown20", 1, 110);
		packet->setDataByName("unknown20", 1, 111);
		//packet->setDataByName("unknown20b", 255);
		//packet->setDataByName("unknown20b", 255, 1);
		//packet->setDataByName("unknown20b", 255, 2);
		packet->setDataByName("unknown11", 123);
		packet->setDataByName("unknown11", 234, 1);
		
		//packet->setDataByName("in_combat", 32768);	
		//make name flash red
		/*packet->setDataByName("unknown20", 8);
		packet->setDataByName("unknown20", 38, 70);
		packet->setDataByName("unknown20", 17, 77);
		packet->setDataByName("unknown20", 1, 112); //melee stats and such
		packet->setDataByName("unknown20", 1, 113);
		packet->setDataByName("unknown20", 1, 114);
		packet->setDataByName("unknown20", 1, 115);

		packet->setDataByName("unknown20", 4294967295, 309);
		packet->setDataByName("unknown22", 2, 4);
		packet->setDataByName("unknown23", 2, 29);
		*/
	//packet->setDataByName("unknown20b", 1, i); // pet bar in here
	//	for(int i=0;i<19;i++)
	//		packet->setDataByName("unknown7", 257, i);
		//packet->setDataByName("unknown21", info_struct->rain, 2);
		packet->setDataByName("rain", info_struct->get_rain());
		packet->setDataByName("rain2", info_struct->get_wind()); //-102.24);
		/*packet->setDataByName("unknown22", 3, 4);
		packet->setDataByName("unknown23", 3, 161);
		packet->setDataByName("unknown20", 103);
		packet->setDataByName("unknown20", 1280, 70);
		packet->setDataByName("unknown20", 9, 71);
		packet->setDataByName("unknown20", 5, 72);
		packet->setDataByName("unknown20", 4294967271, 73);
		packet->setDataByName("unknown20", 5, 75);
		packet->setDataByName("unknown20", 1051, 77);
		packet->setDataByName("unknown20", 3, 78);
		packet->setDataByName("unknown20", 6, 104);
		packet->setDataByName("unknown20", 1, 105);
		packet->setDataByName("unknown20", 20, 106);
		packet->setDataByName("unknown20", 3, 107);
		packet->setDataByName("unknown20", 1, 108);
		packet->setDataByName("unknown20", 1, 109);
		packet->setDataByName("unknown20", 4278190080, 494);
		packet->setDataByName("unknown20b", 255);
		packet->setDataByName("unknown20b", 255, 1);
		packet->setDataByName("unknown20b", 255, 2);
		packet->setDataByName("unknown20", 50, 75);
		*/
		//packet->setDataByName("rain2", -102.24);
		for(int i=0;i<45;i++){
			if(i < 30){
				packet->setSubstructDataByName("maintained_effects", "name", info_struct->maintained_effects[i].name, i, 0);
				packet->setSubstructDataByName("maintained_effects", "target", info_struct->maintained_effects[i].target, i, 0);
				packet->setSubstructDataByName("maintained_effects", "spell_id", info_struct->maintained_effects[i].spell_id, i, 0);
				packet->setSubstructDataByName("maintained_effects", "slot_pos", info_struct->maintained_effects[i].slot_pos, i, 0);
				packet->setSubstructDataByName("maintained_effects", "icon", info_struct->maintained_effects[i].icon, i, 0);
				packet->setSubstructDataByName("maintained_effects", "icon_type", info_struct->maintained_effects[i].icon_backdrop, i, 0);
				packet->setSubstructDataByName("maintained_effects", "conc_used", info_struct->maintained_effects[i].conc_used, i, 0);
				packet->setSubstructDataByName("maintained_effects", "unknown3", 1, i, 0);
				packet->setSubstructDataByName("maintained_effects", "total_time", info_struct->maintained_effects[i].total_time, i, 0);
				packet->setSubstructDataByName("maintained_effects", "expire_timestamp", info_struct->maintained_effects[i].expire_timestamp, i, 0);
			}
			else if(version < 942)//version 942 added 15 additional spell effect slots
				break;
			packet->setSubstructDataByName("spell_effects", "spell_id", info_struct->spell_effects[i].spell_id, i, 0);
			if(info_struct->spell_effects[i].spell_id > 0 && info_struct->spell_effects[i].spell_id < 0xFFFFFFFF)
				packet->setSubstructDataByName("spell_effects", "unknown2", 514, i, 0);
			packet->setSubstructDataByName("spell_effects", "total_time", info_struct->spell_effects[i].total_time, i, 0);
			packet->setSubstructDataByName("spell_effects", "expire_timestamp", info_struct->spell_effects[i].expire_timestamp, i, 0);
			packet->setSubstructDataByName("spell_effects", "icon", info_struct->spell_effects[i].icon, i, 0);
			packet->setSubstructDataByName("spell_effects", "icon_type", info_struct->spell_effects[i].icon_backdrop, i, 0);
		}
		return packet;	
	}
	return 0;
}

EQ2Packet* PlayerInfo::serialize3(PacketStruct* packet, int16 version){
	if(packet){
		string* data = packet->serializeString();
		int32 size = data->length();
		//DumpPacket((uchar*)data->c_str(), size);
		uchar* tmp = new uchar[size];
		if(!changes){
			orig_packet = new uchar[size];
			changes = new uchar[size];
			memcpy(orig_packet, (uchar*)data->c_str(), size);
			size = Pack(tmp, (uchar*)data->c_str(), size, size, version);
		}
		else{
			memcpy(changes, (uchar*)data->c_str(), size);
			Encode(changes, orig_packet, size);
			size = Pack(tmp, changes, size, size, version);
			//cout << "INFO HERE:\n";
			//DumpPacket(tmp, size);
		}
		EQ2Packet* ret_packet = new EQ2Packet(OP_UpdateCharacterSheetMsg, tmp, size+4);
		safe_delete_array(tmp);
		safe_delete(packet);
		return ret_packet;
	}
	return 0;
}

void PlayerInfo::SetAccountAge(int16 age){
	info_struct->set_account_age_base(age);
}

EQ2Packet* PlayerInfo::serialize(int16 version, int16 modifyPos, int32 modifyValue) {
	player->CalculateBonuses();

	int8 blah1 = 90;
	int8 blah2 = 120;

	PacketStruct* packet = configReader.getStruct("WS_CharacterSheet", version);
	//0-69, locked screen movement
	//30-69 normal movement
	//10-30 normal movement

	if (packet) {
		char name[40];
		strncpy(name,info_struct->get_name().c_str(),40);
		packet->setDataByName("character_name", name);
		packet->setDataByName("race", info_struct->get_race());
		packet->setDataByName("gender", info_struct->get_gender());
		packet->setDataByName("exiled", 0);  // need exiled data
		packet->setDataByName("class1", info_struct->get_class1());
		packet->setDataByName("class2", info_struct->get_class2());
		packet->setDataByName("class3", info_struct->get_class3());
		packet->setDataByName("tradeskill_class1", info_struct->get_tradeskill_class1());
		packet->setDataByName("tradeskill_class2", info_struct->get_tradeskill_class2());
		packet->setDataByName("tradeskill_class3", info_struct->get_tradeskill_class3());
		packet->setDataByName("level", info_struct->get_level());
		packet->setDataByName("effective_level", info_struct->get_effective_level() != 0 ? info_struct->get_effective_level() : info_struct->get_level());
		packet->setDataByName("tradeskill_level", info_struct->get_tradeskill_level());
		packet->setDataByName("account_age_base", info_struct->get_account_age_base());
		//TODO: 2021 FIX THIS CASTING
		for (int8 i = 0; i < 19; i++)
			packet->setDataByName("account_age_bonus", 0);
		//TODO: 2021 FIX THIS CASTING
		char deity[32];
		strncpy(deity, info_struct->get_deity().c_str(), 32);
		packet->setDataByName("deity", deity);
		
		packet->setDataByName("last_name", player->GetLastName());
		packet->setDataByName("current_hp", player->GetHP());
		packet->setDataByName("max_hp", player->GetTotalHP());
		packet->setDataByName("base_hp", player->GetTotalHPBase());

		packet->setDataByName("current_power", player->GetPower());
		packet->setDataByName("max_power", player->GetTotalPower());
		packet->setDataByName("base_power", player->GetTotalPowerBase());
		packet->setDataByName("conc_used", info_struct->get_cur_concentration());
		packet->setDataByName("conc_max", info_struct->get_max_concentration());
		packet->setDataByName("hp_regen", player->GetInfoStruct()->get_hp_regen());
		packet->setDataByName("power_regen", player->GetInfoStruct()->get_power_regen());

		packet->setDataByName("stat_bonus_health", player->CalculateBonusMod());//bonus health and bonus power getting same value?
		packet->setDataByName("stat_bonus_power", player->CalculateBonusMod());//bonus health and bonus power getting same value?
		float bonus_health = floor((float)(info_struct->get_sta() * player->CalculateBonusMod()));
		packet->setDataByName("bonus_health", bonus_health);
		packet->setDataByName("bonus_power", floor((float)(player->GetPrimaryStat() * player->CalculateBonusMod())));
		packet->setDataByName("stat_bonus_damage", 95); //stat_bonus_damage
		packet->setDataByName("mitigation_cur", info_struct->get_cur_mitigation());// confirmed DoV
		packet->setDataByName("mitigation_base", info_struct->get_mitigation_base());// confirmed DoV
		
		packet->setDataByName("mitigation_pct_pve", info_struct->get_mitigation_pve()); // % calculation Mitigation % vs PvE 392 = 39.2%// confirmed DoV
		packet->setDataByName("mitigation_pct_pvp", info_struct->get_mitigation_pvp()); // % calculation Mitigation % vs PvP 559 = 55.9%// confirmed DoV
		packet->setDataByName("toughness", 0);//toughness// confirmed DoV
		packet->setDataByName("toughness_resist_dmg_pvp", 0);//toughness_resist_dmg_pvp 73 = 7300% // confirmed DoV 
		packet->setDataByName("avoidance_pct", (int16)info_struct->get_avoidance_display()*10.0f);//avoidance_pct 192 = 19.2% // confirmed DoV
		packet->setDataByName("avoidance_base", (int16)info_struct->get_avoidance_base()*10.0f); // confirmed DoV
		packet->setDataByName("avoidance", info_struct->get_cur_avoidance());
		packet->setDataByName("base_avoidance_pct", info_struct->get_base_avoidance_pct());// confirmed DoV
		float parry_pct = info_struct->get_parry(); // client works off of int16, but we use floats to track the actual x/100%
		packet->setDataByName("parry",(int16)(parry_pct*10.0f));// confirmed DoV

		float block_pct = info_struct->get_block()*10.0f;
		
		packet->setDataByName("block", (int16)block_pct);// confirmed DoV
		packet->setDataByName("uncontested_block", info_struct->get_uncontested_block());// confirmed DoV
		packet->setDataByName("str", info_struct->get_str());// confirmed DoV
		packet->setDataByName("sta", info_struct->get_sta());// confirmed DoV
		packet->setDataByName("agi", info_struct->get_agi());// confirmed DoV
		packet->setDataByName("wis", info_struct->get_wis());// confirmed DoV
		packet->setDataByName("int", info_struct->get_intel());// confirmed DoV
		packet->setDataByName("str_base", info_struct->get_str_base());  // confirmed DoV
		packet->setDataByName("sta_base", info_struct->get_sta_base());// confirmed DoV
		packet->setDataByName("agi_base", info_struct->get_agi_base());// confirmed DoV
		packet->setDataByName("wis_base", info_struct->get_wis_base());// confirmed DoV
		packet->setDataByName("int_base", info_struct->get_intel_base());// confirmed DoV
		if (version <= 996) {
			packet->setDataByName("heat", info_struct->get_heat());
			packet->setDataByName("cold", info_struct->get_cold());
			packet->setDataByName("magic", info_struct->get_magic());
			packet->setDataByName("mental", info_struct->get_mental());
			packet->setDataByName("divine", info_struct->get_divine());
			packet->setDataByName("disease", info_struct->get_disease());
			packet->setDataByName("poison", info_struct->get_poison());
			packet->setDataByName("heat_base", info_struct->get_heat_base());
			packet->setDataByName("cold_base", info_struct->get_cold_base());
			packet->setDataByName("magic_base", info_struct->get_magic_base());
			packet->setDataByName("mental_base", info_struct->get_mental_base());
			packet->setDataByName("divine_base", info_struct->get_divine_base());
			packet->setDataByName("disease_base", info_struct->get_disease_base());
			packet->setDataByName("poison_base", info_struct->get_poison_base());
		}
		else {
			packet->setDataByName("elemental", info_struct->get_heat());// confirmed DoV
			packet->setDataByName("noxious", info_struct->get_poison());// confirmed DoV
			packet->setDataByName("arcane", info_struct->get_magic());// confirmed DoV
			packet->setDataByName("elemental_base", info_struct->get_elemental_base());// confirmed DoV
			packet->setDataByName("noxious_base", info_struct->get_noxious_base());// confirmed DoV
			packet->setDataByName("arcane_base", info_struct->get_arcane_base());// confirmed DoV
		}
		packet->setDataByName("elemental_absorb_pve", 0); //210 = 21.0% confirmed DoV
		packet->setDataByName("noxious_absorb_pve", 0);//210 = 21.0% confirmed DoV
		packet->setDataByName("arcane_absorb_pve", 0);//210 = 21.0% confirmed DoV
		packet->setDataByName("elemental_absorb_pvp", 0);//210 = 21.0% confirmed DoV
		packet->setDataByName("noxious_absorb_pvp", 0);//210 = 21.0% confirmed DoV
		packet->setDataByName("arcane_absorb_pvp", 0);//210 = 21.0% confirmed DoV
		packet->setDataByName("elemental_dmg_reduction", 0);// confirmed DoV
		packet->setDataByName("noxious_dmg_reduction", 0);// confirmed DoV
		packet->setDataByName("arcane_dmg_reduction", 0);// confirmed DoV
		packet->setDataByName("elemental_dmg_reduction_pct", 0);//210 = 21.0% confirmed DoV
		packet->setDataByName("noxious_dmg_reduction_pct", 0);//210 = 21.0% confirmed DoV
		packet->setDataByName("arcane_dmg_reduction_pct", 0);//210 = 21.0% confirmed DoV
		CalculateXPPercentages();
		packet->setDataByName("current_adv_xp", info_struct->get_xp()); // confirmed DoV
		packet->setDataByName("needed_adv_xp", info_struct->get_xp_needed());// confirmed DoV

		if(version >= 60114)
		{
			// AoM ends up the debt_adv_xp field is the percentage of xp to the next level needed to advance out of debt (WHYY CANT THIS JUST BE A PERCENTAGE LIKE DOV!)
			float currentPctOfLevel = (float)info_struct->get_xp() / (float)info_struct->get_xp_needed();
			float neededPctAdvanceOutOfDebt = currentPctOfLevel + (info_struct->get_xp_debt() / 100.0f);
			packet->setDataByName("debt_adv_xp", neededPctAdvanceOutOfDebt);
		}
		else
		{
			packet->setDataByName("exp_debt", (int16)(info_struct->get_xp_debt()/10.0f));//95= 9500% //confirmed DoV
		}
		
		packet->setDataByName("current_trade_xp", info_struct->get_ts_xp());// confirmed DoV
		packet->setDataByName("needed_trade_xp", info_struct->get_ts_xp_needed());// confirmed DoV

		packet->setDataByName("debt_trade_xp", 0);//95= 9500% //confirmed DoV
		packet->setDataByName("server_bonus", 0);//confirmed DoV
		packet->setDataByName("adventure_vet_bonus", 145);//confirmed DoV
		packet->setDataByName("tradeskill_vet_bonus", 123);//confirmed DoV
		packet->setDataByName("recruit_friend", 110);// 110 = 11000% //confirmed DoV
		packet->setDataByName("recruit_friend_bonus", 0);//confirmed DoV

		packet->setDataByName("adventure_vitality", (int16)(player->GetXPVitality() * 10)); // a %%
		packet->setDataByName("adventure_vitality_yellow_arrow", info_struct->get_xp_yellow_vitality_bar()); //change info_struct to match struct
		packet->setDataByName("adventure_vitality_blue_arrow", info_struct->get_xp_blue_vitality_bar());  //change info_struct to match struct

		packet->setDataByName("tradeskill_vitality", 300); //300 = 30%

		packet->setDataByName("tradeskill_vitality_purple_arrow", 0);// dov confirmed
		packet->setDataByName("tradeskill_vitality_blue_arrow", 0);// dov confirmed
		packet->setDataByName("mentor_bonus", 50);//mentor_bonus //this converts wrong says mentor bonus enabled but earning 0

		packet->setDataByName("assigned_aa", player->GetAssignedAA());
		packet->setDataByName("max_aa", rule_manager.GetGlobalRule(R_Player, MaxAA)->GetInt16());
		packet->setDataByName("unassigned_aa", player->GetUnassignedAA()); // dov confirmed
		packet->setDataByName("aa_green_bar", 0);// dov confirmed
		packet->setDataByName("adv_xp_to_aa_xp_slider", 0);  // aa slider max // dov confirmed
		packet->setDataByName("adv_xp_to_aa_xp_max", 100);  // aa slider position // dov confirmed
		packet->setDataByName("aa_blue_bar", 0);// dov confirmed
		packet->setDataByName("bonus_achievement_xp", 0); // dov confirmed

		packet->setDataByName("items_found", 62);// dov confirmed
		packet->setDataByName("named_npcs_killed", 192);// dov confirmed
		packet->setDataByName("quests_completed", 670);// dov confirmed
		packet->setDataByName("exploration_events", 435);// dov confirmed
		packet->setDataByName("completed_collections", 144);// dov confirmed
		packet->setDataByName("unknown_1096_13_MJ", 80);//unknown_1096_13_MJ
		packet->setDataByName("unknown_1096_14_MJ", 50);//unknown_1096_14_MJ
		packet->setDataByName("coins_copper", info_struct->get_coin_copper());// dov confirmed
		packet->setDataByName("coins_silver", info_struct->get_coin_silver());// dov confirmed
		packet->setDataByName("coins_gold", info_struct->get_coin_gold());// dov confirmed
		packet->setDataByName("coins_plat", info_struct->get_coin_plat());// dov confirmed
		
		Skill* skill = player->GetSkillByName("Swimming", false);
		float breath_modifier = rule_manager.GetGlobalRule(R_Player, SwimmingSkillMinBreathLength)->GetFloat();
		if(skill) {
			int32 max_val = 450;
			if(skill->max_val > 0)
				max_val = skill->max_val;
			float diff = (float)(skill->current_val + player->GetStat(ITEM_STAT_SWIMMING)) / (float)max_val;
			float max_breath_mod = rule_manager.GetGlobalRule(R_Player, SwimmingSkillMaxBreathLength)->GetFloat();
			float diff_mod = max_breath_mod * diff;
			if(diff_mod > max_breath_mod)
				breath_modifier = max_breath_mod;
			else if(diff_mod > breath_modifier)
				breath_modifier = diff_mod;
		}
		packet->setDataByName("breath", breath_modifier);

		packet->setDataByName("melee_pri_dmg_min", player->GetPrimaryWeaponMinDamage());// dov confirmed
		packet->setDataByName("melee_pri_dmg_max", player->GetPrimaryWeaponMaxDamage());// dov confirmed
		packet->setDataByName("melee_sec_dmg_min", player->GetSecondaryWeaponMinDamage());// dov confirmed
		packet->setDataByName("melee_sec_dmg_max", player->GetSecondaryWeaponMaxDamage());// dov confirmed // this is off when using 2 handed weapon
		packet->setDataByName("ranged_dmg_min", player->GetRangedWeaponMinDamage());// dov confirmed
		packet->setDataByName("ranged_dmg_max", player->GetRangedWeaponMaxDamage());// dov confirmed
		if (info_struct->get_attackspeed() > 0) {
			packet->setDataByName("melee_pri_delay", (((float)player->GetPrimaryWeaponDelay() * 1.33) / player->CalculateAttackSpeedMod()) * .001);// dov confirmed
			packet->setDataByName("melee_sec_delay", (((float)player->GetSecondaryWeaponDelay() * 1.33) / player->CalculateAttackSpeedMod()) * .001);// dov confirmed
			packet->setDataByName("ranged_delay", (((float)player->GetRangeWeaponDelay() * 1.33) / player->CalculateAttackSpeedMod()) * .001);// dov confirmed
		}
		else {
			packet->setDataByName("melee_pri_delay", (float)player->GetPrimaryWeaponDelay() * .001);// dov confirmed
			packet->setDataByName("melee_sec_delay", (float)player->GetSecondaryWeaponDelay() * .001);// dov confirmed
			packet->setDataByName("ranged_delay", (float)player->GetRangeWeaponDelay() * .001);// dov confirmed
		}

		packet->setDataByName("ability_mod_pve", info_struct->get_ability_modifier());// dov confirmed
		packet->setDataByName("base_melee_crit", 85);//85 = 8500% dov confirmed
		packet->setDataByName("base_spell_crit", 84);// dov confirmed
		packet->setDataByName("base_taunt_crit", 83);// dov confirmed
		packet->setDataByName("base_heal_crit", 82);// dov confirmed
		packet->setDataByName("flags", info_struct->get_flags());
		packet->setDataByName("flags2", info_struct->get_flags2());
		if (version == 546) {
			if (player->get_character_flag(CF_ANONYMOUS))
				packet->setDataByName("flags_anonymous", 1);
			if (player->get_character_flag(CF_ROLEPLAYING))
				packet->setDataByName("flags_roleplaying", 1);
			if (player->get_character_flag(CF_AFK))
				packet->setDataByName("flags_afk", 1);
			if (player->get_character_flag(CF_LFG))
				packet->setDataByName("flags_lfg", 1);
			if (player->get_character_flag(CF_LFW))
				packet->setDataByName("flags_lfw", 1);
			if (!player->get_character_flag(CF_HIDE_HOOD) && !player->get_character_flag(CF_HIDE_HELM))
				packet->setDataByName("flags_show_hood", 1);
			if (player->get_character_flag(CF_SHOW_ILLUSION))
				packet->setDataByName("flags_show_illusion_form", 1);
			if (player->get_character_flag(CF_ALLOW_DUEL_INVITES))
				packet->setDataByName("flags_show_duel_invites", 1);
			if (player->get_character_flag(CF_ALLOW_TRADE_INVITES))
				packet->setDataByName("flags_show_trade_invites", 1);
			if (player->get_character_flag(CF_ALLOW_GROUP_INVITES))
				packet->setDataByName("flags_show_group_invites", 1);
			if (player->get_character_flag(CF_ALLOW_RAID_INVITES))
				packet->setDataByName("flags_show_raid_invites", 1);
			if (player->get_character_flag(CF_ALLOW_GUILD_INVITES))
				packet->setDataByName("flags_show_guild_invites", 1);
		}

		packet->setDataByName("haste", info_struct->get_haste());// dov confirmed
		packet->setDataByName("drunk", info_struct->get_drunk());// dov confirmed

		packet->setDataByName("hate_mod", info_struct->get_hate_mod());// dov confirmed
		packet->setDataByName("adventure_effects_bonus", 55);// NEED an adventure_effects_bonus// dov confirmed
		packet->setDataByName("tradeskill_effects_bonus", 56);// NEED an tradeskill_effects_bonus// dov confirmed
		packet->setDataByName("dps", info_struct->get_dps());// dov confirmed
		packet->setDataByName("melee_ae", info_struct->get_melee_ae());// dov confirmed
		packet->setDataByName("multi_attack", info_struct->get_multi_attack());// dov confirmed
		packet->setDataByName("spell_multi_attack", info_struct->get_spell_multi_attack());// dov confirmed
		packet->setDataByName("block_chance", info_struct->get_block_chance());// dov confirmed
		packet->setDataByName("crit_chance", info_struct->get_crit_chance());// dov confirmed
		packet->setDataByName("crit_bonus", info_struct->get_crit_bonus());// dov confirmed

		packet->setDataByName("potency", info_struct->get_potency());//info_struct->get_potency);// dov confirmed

		packet->setDataByName("reuse_speed", info_struct->get_reuse_speed());// dov confirmed
		packet->setDataByName("recovery_speed", info_struct->get_recovery_speed());// dov confirmed
		packet->setDataByName("casting_speed", info_struct->get_casting_speed());// dov confirmed
		packet->setDataByName("spell_reuse_speed", info_struct->get_spell_reuse_speed());// dov confirmed
		packet->setDataByName("strikethrough", info_struct->get_strikethrough());//dov confirmed
		packet->setDataByName("accuracy", info_struct->get_accuracy());//dov confirmed
		packet->setDataByName("critical_mit", info_struct->get_critical_mitigation());//dov /confirmed

		((Entity*)player)->MStats.lock();
		packet->setDataByName("durability_mod", player->stats[ITEM_STAT_DURABILITY_MOD]);// dov confirmed
		packet->setDataByName("durability_add", player->stats[ITEM_STAT_DURABILITY_ADD]);// dov confirmed
		packet->setDataByName("progress_mod", player->stats[ITEM_STAT_PROGRESS_MOD]);// dov confirmed
		packet->setDataByName("progress_add", player->stats[ITEM_STAT_PROGRESS_ADD]);// dov confirmed
		packet->setDataByName("success_mod", player->stats[ITEM_STAT_SUCCESS_MOD]);// dov confirmed
		packet->setDataByName("crit_success_mod", player->stats[ITEM_STAT_CRIT_SUCCESS_MOD]);// dov confirmed
		((Entity*)player)->MStats.unlock();

		if (version <= 283 && info_struct->get_pet_id() == 0xFFFFFFFF)
			packet->setDataByName("pet_id", 0);
		else {
			packet->setDataByName("pet_id", info_struct->get_pet_id());
			char pet_name[32];
			strncpy(pet_name, info_struct->get_pet_name().c_str(), 32);
			packet->setDataByName("pet_name", pet_name);
		}

		packet->setDataByName("pet_health_pct", info_struct->get_pet_health_pct());
		packet->setDataByName("pet_power_pct", info_struct->get_pet_power_pct());

		packet->setDataByName("pet_movement", info_struct->get_pet_movement());
		packet->setDataByName("pet_behavior", info_struct->get_pet_behavior());
		packet->setDataByName("rain", info_struct->get_rain());
		packet->setDataByName("rain2", info_struct->get_wind()); //-102.24);
		packet->setDataByName("status_points", info_struct->get_status_points());
		packet->setDataByName("guild_status", 888888);

		if (house_zone_id > 0){
			string house_name = database.GetZoneName(house_zone_id);
			if(house_name.length() > 0)
				packet->setDataByName("house_zone", house_name.c_str());
		}
		else
			packet->setDataByName("house_zone", "None");

		if (bind_zone_id > 0){
			string bind_name = database.GetZoneName(bind_zone_id);
			if(bind_name.length() > 0)
				packet->setDataByName("bind_zone", bind_name.c_str());
		}
		else
			packet->setDataByName("bind_zone", "None");
			
			
		((Entity*)player)->MStats.lock();
		packet->setDataByName("rare_harvest_chance", player->stats[ITEM_STAT_RARE_HARVEST_CHANCE]);
		packet->setDataByName("max_crafting", player->stats[ITEM_STAT_MAX_CRAFTING]);
		packet->setDataByName("component_refund", player->stats[ITEM_STAT_COMPONENT_REFUND]);
		packet->setDataByName("ex_durability_mod", player->stats[ITEM_STAT_EX_DURABILITY_MOD]);
		packet->setDataByName("ex_durability_add", player->stats[ITEM_STAT_EX_DURABILITY_ADD]);
		packet->setDataByName("ex_crit_success_mod", player->stats[ITEM_STAT_EX_CRIT_SUCCESS_MOD]);
		packet->setDataByName("ex_crit_failure_mod", player->stats[ITEM_STAT_EX_CRIT_FAILURE_MOD]);
		packet->setDataByName("ex_progress_mod", player->stats[ITEM_STAT_EX_PROGRESS_MOD]);
		packet->setDataByName("ex_progress_add", player->stats[ITEM_STAT_EX_PROGRESS_ADD]);
		packet->setDataByName("ex_success_mod", player->stats[ITEM_STAT_EX_SUCCESS_MOD]);
		((Entity*)player)->MStats.unlock();

		packet->setDataByName("flurry", info_struct->get_flurry());
		packet->setDataByName("unknown153", 153);
		packet->setDataByName("bountiful_harvest", 0); // need bountiful harvest

		packet->setDataByName("unknown156", 156);
		packet->setDataByName("unknown157", 157);

		packet->setDataByName("unknown159", 159);
		packet->setDataByName("unknown160", 160);


		packet->setDataByName("unknown163", 163);


		packet->setDataByName("unknown168", 168);
		packet->setDataByName("decrease_falling_dmg", 169);


		info_struct->set_max_weight(200);

		if (version <= 546) {
			packet->setDataByName("exp_yellow", info_struct->get_xp_yellow() / 10);
			packet->setDataByName("exp_blue", info_struct->get_xp_blue()/10);
		}
		else {
			packet->setDataByName("exp_yellow", info_struct->get_xp_yellow());
			packet->setDataByName("exp_blue", info_struct->get_xp_blue());
		}
		
		if (version <= 546) {
			packet->setDataByName("tradeskill_exp_yellow", info_struct->get_tradeskill_exp_yellow() / 10);
			packet->setDataByName("tradeskill_exp_blue", info_struct->get_tradeskill_exp_blue() / 10);
		}
		else {
			packet->setDataByName("tradeskill_exp_yellow", info_struct->get_tradeskill_exp_yellow());
			packet->setDataByName("tradeskill_exp_blue", info_struct->get_tradeskill_exp_blue());
		}		

		packet->setDataByName("attack", info_struct->get_cur_attack());
		packet->setDataByName("attack_base", info_struct->get_attack_base());
		packet->setDataByName("absorb", info_struct->get_absorb());
		packet->setDataByName("mitigation_skill1", info_struct->get_mitigation_skill1());
		packet->setDataByName("mitigation_skill2", info_struct->get_mitigation_skill2());
		packet->setDataByName("mitigation_skill3", info_struct->get_mitigation_skill3());

		packet->setDataByName("mitigation_max", info_struct->get_max_mitigation());

		packet->setDataByName("savagery", 250);
		packet->setDataByName("max_savagery", 500);
		packet->setDataByName("savagery_level", 1);
		packet->setDataByName("max_savagery_level", 5);
		packet->setDataByName("dissonance", 5000);
		packet->setDataByName("max_dissonance", 10000);

		packet->setDataByName("mitigation_cur2", info_struct->get_cur_mitigation());
		packet->setDataByName("mitigation_max2", info_struct->get_max_mitigation());
		packet->setDataByName("mitigation_base2", info_struct->get_mitigation_base());

		packet->setDataByName("weight", info_struct->get_weight());
		packet->setDataByName("max_weight", info_struct->get_max_weight());
		packet->setDataByName("unknownint32a", 777777);
		packet->setDataByName("unknownint32b", 666666);
		packet->setDataByName("mitigation2_cur", 2367);
		packet->setDataByName("uncontested_riposte", info_struct->get_uncontested_riposte());
		packet->setDataByName("uncontested_dodge", info_struct->get_uncontested_dodge());
		packet->setDataByName("uncontested_parry", info_struct->get_uncontested_parry()); //????
		packet->setDataByName("uncontested_riposte_pve", 0); //????
		packet->setDataByName("uncontested_parry_pve", 0); //????
		packet->setDataByName("total_prestige_points", player->GetPrestigeAA());
		packet->setDataByName("unassigned_prestige_points", player->GetUnassignedPretigeAA());
		packet->setDataByName("total_tradeskill_points", player->GetTradeskillAA());
		packet->setDataByName("unassigned_tradeskill_points", player->GetUnassignedTradeskillAA());
		packet->setDataByName("total_tradeskill_prestige_points", player->GetTradeskillPrestigeAA());
		packet->setDataByName("unassigned_tradeskill_prestige_points", player->GetUnassignedTradeskillPrestigeAA());

		// unknown14c = percent aa exp to next level
		packet->setDataByName("unknown14d", 100, 0);
		packet->setDataByName("unknown20", 1084227584, 72);
		packet->setDataByName("unknown15c", 200);

		player->SetGroupInformation(packet);

		packet->setDataByName("in_combat_movement_speed", 125);

		packet->setDataByName("increase_max_power", 127);
		packet->setDataByName("increase_max_power2", 128);

		packet->setDataByName("vision", info_struct->get_vision());
		packet->setDataByName("breathe_underwater", info_struct->get_breathe_underwater());

		int32 expireTimestamp = 0;
		Spawn* maintained_target = 0;
		player->GetSpellEffectMutex()->readlock(__FUNCTION__, __LINE__);
		player->GetMaintainedMutex()->readlock(__FUNCTION__, __LINE__);
		for (int i = 0; i < 45; i++) {
			if (i < 30) {
				maintained_target = player->GetZone()->GetSpawnByID(info_struct->maintained_effects[i].target);
				packet->setSubstructDataByName("maintained_effects", "name", info_struct->maintained_effects[i].name, i, 0);
				if (maintained_target)
					packet->setSubstructDataByName("maintained_effects", "target", player->GetIDWithPlayerSpawn(maintained_target), i, 0);
				packet->setSubstructDataByName("maintained_effects", "target_type", info_struct->maintained_effects[i].target_type, i, 0);
				packet->setSubstructDataByName("maintained_effects", "spell_id", info_struct->maintained_effects[i].spell_id, i, 0);
				packet->setSubstructDataByName("maintained_effects", "slot_pos", info_struct->maintained_effects[i].slot_pos, i, 0);
				packet->setSubstructDataByName("maintained_effects", "icon", info_struct->maintained_effects[i].icon, i, 0);
				packet->setSubstructDataByName("maintained_effects", "icon_type", info_struct->maintained_effects[i].icon_backdrop, i, 0);
				packet->setSubstructDataByName("maintained_effects", "conc_used", info_struct->maintained_effects[i].conc_used, i, 0);
				packet->setSubstructDataByName("maintained_effects", "unknown3", 1, i, 0);
				packet->setSubstructDataByName("maintained_effects", "total_time", info_struct->maintained_effects[i].total_time, i, 0);
				expireTimestamp = info_struct->maintained_effects[i].expire_timestamp;
				if (expireTimestamp == 0xFFFFFFFF)
					expireTimestamp = 0;
				packet->setSubstructDataByName("maintained_effects", "expire_timestamp", expireTimestamp, i, 0);
			}
			else if (version < 942)//version 942 added 15 additional spell effect slots
				break;
			packet->setSubstructDataByName("spell_effects", "spell_id", info_struct->spell_effects[i].spell_id, i, 0);
			packet->setSubstructDataByName("spell_effects", "total_time", info_struct->spell_effects[i].total_time, i, 0);
			expireTimestamp = info_struct->spell_effects[i].expire_timestamp;
			if (expireTimestamp == 0xFFFFFFFF)
				expireTimestamp = 0;
			packet->setSubstructDataByName("spell_effects", "expire_timestamp", expireTimestamp, i, 0);
			packet->setSubstructDataByName("spell_effects", "icon", info_struct->spell_effects[i].icon, i, 0);
			packet->setSubstructDataByName("spell_effects", "icon_type", info_struct->spell_effects[i].icon_backdrop, i, 0);
			if(info_struct->spell_effects[i].spell && info_struct->spell_effects[i].spell->spell && info_struct->spell_effects[i].spell->spell->GetSpellData()->friendly_spell == 1)
				packet->setSubstructDataByName("spell_effects", "cancellable", 1, i); 
		}
		player->GetMaintainedMutex()->releasereadlock(__FUNCTION__, __LINE__);
		player->GetSpellEffectMutex()->releasereadlock(__FUNCTION__, __LINE__);

		int8 det_count = 0;
		//Send detriment counts as 255 if all dets of that type are incurable
		det_count = player->GetTraumaCount();
		if (det_count > 0) {
			if (!player->HasCurableDetrimentType(DET_TYPE_TRAUMA))
				det_count = 255;
		}
		packet->setDataByName("trauma_count", det_count);

		det_count = player->GetArcaneCount();
		if (det_count > 0) {
			if (!player->HasCurableDetrimentType(DET_TYPE_ARCANE))
				det_count = 255;
		}
		packet->setDataByName("arcane_count", det_count);

		det_count = player->GetNoxiousCount();
		if (det_count > 0) {
			if (!player->HasCurableDetrimentType(DET_TYPE_NOXIOUS))
				det_count = 255;
		}
		packet->setDataByName("noxious_count", det_count);

		det_count = player->GetElementalCount();
		if (det_count > 0) {
			if (!player->HasCurableDetrimentType(DET_TYPE_ELEMENTAL))
				det_count = 255;
		}
		packet->setDataByName("elemental_count", det_count);

		det_count = player->GetCurseCount();
		if (det_count > 0) {
			if (!player->HasCurableDetrimentType(DET_TYPE_CURSE))
				det_count = 255;
		}
		packet->setDataByName("curse_count", det_count);

		player->GetDetrimentMutex()->readlock(__FUNCTION__, __LINE__);
		vector<DetrimentalEffects>* det_list = player->GetDetrimentalSpellEffects();
		DetrimentalEffects det;
		int32 i = 0;
		for (i = 0; i < det_list->size(); i++) {
			det = det_list->at(i);
			packet->setSubstructDataByName("detrimental_spell_effects", "spell_id", det.spell_id, i);
			packet->setSubstructDataByName("detrimental_spell_effects", "total_time", det.total_time, i);
			packet->setSubstructDataByName("detrimental_spell_effects", "icon", det.icon, i);
			packet->setSubstructDataByName("detrimental_spell_effects", "icon_type", det.icon_backdrop, i);
			expireTimestamp = det.expire_timestamp;
			if (expireTimestamp == 0xFFFFFFFF)
				expireTimestamp = 0;
			packet->setSubstructDataByName("detrimental_spell_effects", "expire_timestamp", expireTimestamp, i);
			packet->setSubstructDataByName("detrimental_spell_effects", "unknown2", 2, i);
			if (i == 30) {
				if (version < 942)
					break;
			}
			else if (i == 45)
				break;
		}
		if (version < 942) {
			while (i < 30) {
				packet->setSubstructDataByName("detrimental_spell_effects", "spell_id", 0xFFFFFFFF, i);
				i++;
			}
		}
		else {
			while (i < 45) {
				packet->setSubstructDataByName("detrimental_spell_effects", "spell_id", 0xFFFFFFFF, i);
				i++;
			}
		}
		player->GetDetrimentMutex()->releasereadlock(__FUNCTION__, __LINE__);

		// disabling as not in use right now
		//packet->setDataByName("spirit_rank", 2);
		//packet->setDataByName("spirit", 1);
		//packet->setDataByName("spirit_progress", .67);

		packet->setDataByName("combat_exp_enabled", 1);
		
		string* data = packet->serializeString();
		int32 size = data->length();

		uchar* tmp = new uchar[size];
		bool reverse = version > 283;
		if (!changes) {
			orig_packet = new uchar[size];
			changes = new uchar[size];
			memcpy(orig_packet, (uchar*)data->c_str(), size);
			size = Pack(tmp, orig_packet, size, size, version, reverse);
		}
		else {
			memcpy(changes, (uchar*)data->c_str(), size);
			if (modifyPos > 0) {
				uchar* ptr2 = (uchar*)changes;
				ptr2 += modifyPos - 1;
				if (modifyValue > 0xFFFF) {
					memcpy(ptr2, (uchar*)&modifyValue, 4);
				}
				else if (modifyValue > 0xFF) {
					memcpy(ptr2, (uchar*)&modifyValue, 2);
				}
				else
					memcpy(ptr2, (uchar*)&modifyValue, 1);
			}
			Encode(changes, orig_packet, size);
			if (modifyPos > 0) {
				uchar* ptr2 = (uchar*)orig_packet;
				if (modifyPos > 64)
					ptr2 += modifyPos - 64;
				int16 tmpsize = modifyPos + 128;
				if (tmpsize > size)
					tmpsize = size;
			}
			size = Pack(tmp, changes, size, size, version, reverse);
		}

		if (version >= 546)
		{
			PacketStruct* control_packet = configReader.getStruct("WS_SetControlGhost", version);
			if (control_packet) {
				control_packet->setDataByName("spawn_id", 0xFFFFFFFF);
				control_packet->setDataByName("speed", player->GetSpeed());
				control_packet->setDataByName("air_speed", player->GetAirSpeed());
				control_packet->setDataByName("size", 0.51);
				Client* client = player->GetZone()->GetClientBySpawn(player);
				if (client)
					client->QueuePacket(control_packet->serialize());
				safe_delete(control_packet);
			}
		}

		EQ2Packet* ret_packet = new EQ2Packet(OP_UpdateCharacterSheetMsg, tmp, size);
		safe_delete(packet);
		safe_delete_array(tmp);
		return ret_packet;
	}
	return 0;
}

EQ2Packet* PlayerInfo::serializePet(int16 version) {
	PacketStruct* packet = configReader.getStruct("WS_CharacterPet", version);
	if(packet) {
		Spawn* pet = 0;
		pet = player->GetPet();
		if (!pet)
			pet = player->GetCharmedPet();

		if (pet) {
			packet->setDataByName("current_hp", pet->GetHP());
			packet->setDataByName("max_hp", pet->GetTotalHP());
			packet->setDataByName("base_hp", pet->GetTotalHPBase());

			packet->setDataByName("current_power", pet->GetPower());
			packet->setDataByName("max_power", pet->GetTotalPower());
			packet->setDataByName("base_power", pet->GetTotalPowerBase());

			packet->setDataByName("spawn_id", info_struct->get_pet_id());
			packet->setDataByName("spawn_id2", info_struct->get_pet_id());
			
			if(info_struct->get_pet_id() != 0xFFFFFFFF) {
				char pet_name[32];
				strncpy(pet_name, info_struct->get_pet_name().c_str(), 32);
				packet->setDataByName("name", pet_name);
			}
			else {
				packet->setDataByName("name", "No Pet");
				packet->setDataByName("no_pet", "No Pet");
			}

			if (version >= 57000) {
				packet->setDataByName("current_power3", pet->GetPower());
				packet->setDataByName("max_power3", pet->GetTotalPower());
				packet->setDataByName("health_pct_tooltip", (double)info_struct->get_pet_health_pct());
				packet->setDataByName("health_pct_bar", (double)info_struct->get_pet_health_pct());
			}
			else {
				packet->setDataByName("health_pct_tooltip", info_struct->get_pet_health_pct());
				packet->setDataByName("health_pct_bar", info_struct->get_pet_health_pct());
			}
			packet->setDataByName("power_pct_tooltip", info_struct->get_pet_power_pct());
			packet->setDataByName("power_pct_bar", info_struct->get_pet_power_pct());
			packet->setDataByName("unknown5", 255); // Hate % maybe
			packet->setDataByName("movement", info_struct->get_pet_movement());
			packet->setDataByName("behavior", info_struct->get_pet_behavior());
		}
		else {
			packet->setDataByName("current_hp", 0);
			packet->setDataByName("max_hp", 0);
			packet->setDataByName("base_hp", 0);
			packet->setDataByName("current_power", 0);
			packet->setDataByName("max_power", 0);
			packet->setDataByName("base_power", 0);

			packet->setDataByName("spawn_id", 0);
			packet->setDataByName("spawn_id2", 0xFFFFFFFF);
			packet->setDataByName("name", "");
			packet->setDataByName("no_pet", "No Pet");
			packet->setDataByName("health_pct_tooltip", 0);
			packet->setDataByName("health_pct_bar", 0);
			packet->setDataByName("power_pct_tooltip", 0);
			packet->setDataByName("power_pct_bar", 0);
			packet->setDataByName("unknown5", 0);
			packet->setDataByName("movement", 0);
			packet->setDataByName("behavior", 0);
		}


		string* data = packet->serializeString();
		int32 size = data->length();
		uchar* tmp = new uchar[size];
		// if this is the first time sending this packet create the buffers
		if(!pet_changes){
			pet_orig_packet = new uchar[size];
			pet_changes = new uchar[size];
			// copy the packet into the pet_orig_packet so we can xor against it in the future
			memcpy(pet_orig_packet, (uchar*)data->c_str(), size);
			// pack the packet, result ends up in tmp
			size = Pack(tmp, (uchar*)data->c_str(), size, size, version);
		}
		else{
			// copy the packet into pet_changes
			memcpy(pet_changes, (uchar*)data->c_str(), size);
			// XOR's the packet to the original, stores the new packet in the orig packet (will xor against that for the next update)
			// puts the xor packet into pet_changes.
			Encode(pet_changes, pet_orig_packet, size);
			// Pack the pet_changes packet, will put the packed size at the start, result ends up in tmp
			size = Pack(tmp, pet_changes, size, size, version);
		}

		// Create the packet that we will send
		EQ2Packet* ret_packet = new EQ2Packet(OP_CharacterPet, tmp, size+4);
		// Clean up
		safe_delete_array(tmp);
		safe_delete(packet);
		// Return the packet that will be sent to the client
		return ret_packet;
	}
	return 0;
}

bool Player::DamageEquippedItems(int8 amount, Client* client) {
	bool ret = false;
	int8 item_type;
	Item* item = 0;
	equipment_list.MEquipmentItems.readlock(__FUNCTION__, __LINE__);
	for(int8 i=0;i<NUM_SLOTS;i++){
		item = equipment_list.items[i];
		if(item) {
			item_type = item->generic_info.item_type;
			if (item->details.item_id > 0 && item_type != ITEM_TYPE_FOOD && item_type != ITEM_TYPE_BAUBLE && item_type != ITEM_TYPE_THROWN && 
			!item->CheckFlag2(INDESTRUCTABLE)){
				ret = true;
				if((item->generic_info.condition - amount) > 0)
					item->generic_info.condition -= amount;
				else
					item->generic_info.condition = 0;
				item->save_needed = true;
				if (client)
					client->QueuePacket(item->serialize(client->GetVersion(), false, this));
			}
		}
	}
	equipment_list.MEquipmentItems.releasereadlock(__FUNCTION__, __LINE__);

	return ret;
}

int8 Player::ConvertSlotToClient(int8 slot, int16 version) {
	if (version <= 283) {
		if (slot == EQ2_FOOD_SLOT)
			slot = EQ2_ORIG_FOOD_SLOT;
		else if (slot == EQ2_DRINK_SLOT)
			slot = EQ2_ORIG_DRINK_SLOT;
		else if (slot > EQ2_EARS_SLOT_1 && slot <= EQ2_WAIST_SLOT)
			slot -= 1;
	}
	else if (version <= 546) {
		if (slot == EQ2_FOOD_SLOT)
			slot = EQ2_DOF_FOOD_SLOT;
		else if (slot == EQ2_DRINK_SLOT)
			slot = EQ2_DOF_DRINK_SLOT;
		else if (slot > EQ2_EARS_SLOT_1 && slot <= EQ2_WAIST_SLOT)
			slot -= 1;
	}
	return slot;
}

int8 Player::ConvertSlotFromClient(int8 slot, int16 version) {
	if (version <= 283) {
		if (slot == EQ2_ORIG_FOOD_SLOT)
			slot = EQ2_FOOD_SLOT;
		else if (slot == EQ2_ORIG_DRINK_SLOT)
			slot = EQ2_DRINK_SLOT;
		else if (slot > EQ2_EARS_SLOT_1 && slot <= EQ2_WAIST_SLOT)
			slot += 1;
	}
	else if (version <= 546) {
		if (slot == EQ2_DOF_FOOD_SLOT)
			slot = EQ2_FOOD_SLOT;
		else if (slot == EQ2_DOF_DRINK_SLOT)
			slot = EQ2_DRINK_SLOT;
		else if (slot > EQ2_EARS_SLOT_1 && slot <= EQ2_WAIST_SLOT)
			slot += 1;
	}
	return slot;
}

vector<EQ2Packet*>	Player::UnequipItem(int16 index, sint32 bag_id, int8 slot, int16 version, int8 appearance_type, bool send_item_updates) {
	vector<EQ2Packet*>	packets;
	EquipmentItemList* equipList = &equipment_list;
	
	if(appearance_type)
		equipList = &appearance_equipment_list;
		
	if(index >= NUM_SLOTS) {
		LogWrite(PLAYER__ERROR, 0, "Player", "%u index is out of range for equip items, bag_id: %i, slot: %u, version: %u, appearance: %u", index, bag_id, slot, version, appearance_type);
		return packets;
	}
	equipList->MEquipmentItems.readlock(__FUNCTION__, __LINE__);
	Item* item = equipList->items[index];
	equipList->MEquipmentItems.releasereadlock(__FUNCTION__, __LINE__);

	if (item && bag_id == -999) {
		int8 old_slot = item->details.slot_id;
		if (item_list.AssignItemToFreeSlot(item)) {
			if(appearance_type)
				database.DeleteItem(GetCharacterID(), item, "APPEARANCE");
			else
				database.DeleteItem(GetCharacterID(), item, "EQUIPPED");

			if (item->GetItemScript() && lua_interface)
				lua_interface->RunItemScript(item->GetItemScript(), "unequipped", item, this);
			const char* zone_script = world.GetZoneScript(GetZone()->GetZoneID());
			if (zone_script && lua_interface)
				lua_interface->RunZoneScript(zone_script, "item_unequipped", GetZone(), this, item->details.item_id, item->name.c_str(), 0, item->details.unique_id);
			item->save_needed = true;
			EQ2Packet* outapp = item_list.serialize(this, version);
			if (outapp) {
				packets.push_back(outapp);
				packets.push_back(item->serialize(version, false));
				EQ2Packet* bag_packet = SendBagUpdate(item->details.inv_slot_id, version);
				if (bag_packet)
					packets.push_back(bag_packet);
			}
			equipList->RemoveItem(index);
			SetEquippedItemAppearances();
			packets.push_back(equipList->serialize(version, this));
			SetCharSheetChanged(true);
			SetEquipment(0, old_slot);
		}
		else {
			PacketStruct* packet = configReader.getStruct("WS_DisplayText", version);
			if (packet) {
				packet->setDataByName("color", CHANNEL_COLOR_YELLOW);
				packet->setMediumStringByName("text", "Unable to unequip item: no free inventory locations.");
				packet->setDataByName("unknown02", 0x00ff);
				packets.push_back(packet->serialize());
				safe_delete(packet);
			}
		}
	}
	else if (item) {
		Item* to_item = 0;
		if(appearance_type && slot == 255)
		{
			sint16 tmpSlot = 0;
			item_list.GetFirstFreeSlot(&bag_id, &tmpSlot);
			if(tmpSlot >= 0 && tmpSlot < 255)
				slot = tmpSlot;
			else
				bag_id = 0;
		}

		item_list.MPlayerItems.readlock(__FUNCTION__, __LINE__);
		if (item_list.items.count(bag_id) > 0 && item_list.items[bag_id][BASE_EQUIPMENT].count(slot) > 0)
			to_item = item_list.items[bag_id][BASE_EQUIPMENT][slot];

		bool canEquipToSlot = false;
		if (to_item && equipList->CanItemBeEquippedInSlot(to_item, ConvertSlotFromClient(item->details.slot_id, version))) {
			canEquipToSlot = true;
		}
		item_list.MPlayerItems.releasereadlock(__FUNCTION__, __LINE__);

		if (canEquipToSlot) {
			equipList->RemoveItem(index);
			if(item->details.appearance_type)
				database.DeleteItem(GetCharacterID(), item, "APPEARANCE");
			else
				database.DeleteItem(GetCharacterID(), item, "EQUIPPED");
			
			database.DeleteItem(GetCharacterID(), to_item, "NOT-EQUIPPED");

			if (item->GetItemScript() && lua_interface)
				lua_interface->RunItemScript(item->GetItemScript(), "unequipped", item, this);

			if (to_item->GetItemScript() && lua_interface)
				lua_interface->RunItemScript(to_item->GetItemScript(), "equipped", to_item, this);

			item_list.RemoveItem(to_item);
			equipList->SetItem(item->details.slot_id, to_item);
			to_item->save_needed = true;
			packets.push_back(to_item->serialize(version, false));
			SetEquipment(to_item);
			item->details.inv_slot_id = bag_id;
			item->details.slot_id = slot;
			item->details.appearance_type = 0;
			
			if(item_list.AddItem(item)) {
				item->save_needed = true;
				SetEquippedItemAppearances();
				// SerializeItemPackets serves item and equipList in opposite order is why we don't use that function here..
				packets.push_back(item->serialize(version, false));
				packets.push_back(equipList->serialize(version, this));
				packets.push_back(item_list.serialize(this, version));
			}
			else {
				LogWrite(PLAYER__ERROR, 0, "Player", "failed to add item to item_list during UnequipItem, index %u, bag id %i, slot %u, version %u, appearance type %u", index, bag_id, slot, version, appearance_type);
			}
		}
		else if (to_item && to_item->IsBag() && to_item->details.num_slots > 0) {
			bool free_slot = false;
			for (int8 i = 0; i < to_item->details.num_slots; i++) {
				item_list.MPlayerItems.readlock(__FUNCTION__, __LINE__);
				int32 count = item_list.items[to_item->details.bag_id][appearance_type].count(i);
				item_list.MPlayerItems.releasereadlock(__FUNCTION__, __LINE__);
				if (count == 0) {
					SetEquipment(0, item->details.slot_id);

					if(item->details.appearance_type)
						database.DeleteItem(GetCharacterID(), item, "APPEARANCE");
					else
						database.DeleteItem(GetCharacterID(), item, "EQUIPPED");

					if (item->GetItemScript() && lua_interface)
						lua_interface->RunItemScript(item->GetItemScript(), "unequipped", item, this);

					equipList->RemoveItem(index);
					item->details.inv_slot_id = to_item->details.bag_id;
					item->details.slot_id = i;
					item->details.appearance_type = to_item->details.appearance_type;
					
					SerializeItemPackets(equipList, &packets, item, version, to_item);
					free_slot = true;
					break;
				}
			}
			if (!free_slot) {
				PacketStruct* packet = configReader.getStruct("WS_DisplayText", version);
				if (packet) {
					packet->setDataByName("color", CHANNEL_COLOR_YELLOW);
					packet->setMediumStringByName("text", "Unable to unequip item: no free space in the bag.");
					packet->setDataByName("unknown02", 0x00ff);
					packets.push_back(packet->serialize());
					safe_delete(packet);
				}
			}
		}
		else if (to_item) {
			PacketStruct* packet = configReader.getStruct("WS_DisplayText", version);
			if (packet) {
				packet->setDataByName("color", CHANNEL_COLOR_YELLOW);
				packet->setMediumStringByName("text", "Unable to swap items: that item cannot be equipped there.");
				packet->setDataByName("unknown02", 0x00ff);
				packets.push_back(packet->serialize());
				safe_delete(packet);
			}
		}
		else {
			if ((bag_id == 0 && slot < NUM_INV_SLOTS) || (bag_id == -3 && slot < NUM_BANK_SLOTS) || (bag_id == -4 && slot < NUM_SHARED_BANK_SLOTS)) {
				if (bag_id == -4 && item->CheckFlag(NO_TRADE)) {
					PacketStruct* packet = configReader.getStruct("WS_DisplayText", version);
					if (packet) {
						packet->setDataByName("color", CHANNEL_COLOR_YELLOW);
						packet->setMediumStringByName("text", "Unable to unequip item: that item cannot be traded.");
						packet->setDataByName("unknown02", 0x00ff);
						packets.push_back(packet->serialize());
						safe_delete(packet);
					}
				}
				else {
					// need to check if appearance slot vs equipped
					SetEquipment(0, item->details.slot_id);
					if(item->details.appearance_type)
						database.DeleteItem(GetCharacterID(), item, "APPEARANCE");
					else
						database.DeleteItem(GetCharacterID(), item, "EQUIPPED");

					if (item->GetItemScript() && lua_interface)
						lua_interface->RunItemScript(item->GetItemScript(), "unequipped", item, this);

					equipList->RemoveItem(index);
					item->details.inv_slot_id = bag_id;
					item->details.slot_id = slot;
					item->details.appearance_type = 0;
					SerializeItemPackets(equipList, &packets, item, version);
				}
			}
			else {
				Item* bag = item_list.GetItemFromUniqueID(bag_id, true);
				if (bag && bag->IsBag() && slot < bag->details.num_slots) {
					SetEquipment(0, item->details.slot_id);
					if(item->details.appearance_type)
						database.DeleteItem(GetCharacterID(), item, "APPEARANCE");
					else
						database.DeleteItem(GetCharacterID(), item, "EQUIPPED");

					if (item->GetItemScript() && lua_interface)
						lua_interface->RunItemScript(item->GetItemScript(), "unequipped", item, this);

					equipList->RemoveItem(index);
					item->details.inv_slot_id = bag_id;
					item->details.slot_id = slot;
					item->details.appearance_type = 0;
					SerializeItemPackets(equipList, &packets, item, version);
				}
			}
		}
		Item* bag = item_list.GetItemFromUniqueID(bag_id, true);
		if (bag && bag->IsBag())
			packets.push_back(bag->serialize(version, false, this));
	}

	if(send_item_updates && GetClient())
	{
		GetClient()->UpdateSentSpellList();
		GetClient()->ClearSentSpellList();
	}

	return packets;
}

map<int32, Item*>* Player::GetItemList(){
	return item_list.GetAllItems();
}

vector<Item*>* Player::GetEquippedItemList(){
	return equipment_list.GetAllEquippedItems();
}

vector<Item*>* Player::GetAppearanceEquippedItemList(){
	return appearance_equipment_list.GetAllEquippedItems();
}

EQ2Packet*	Player::SendBagUpdate(int32 bag_unique_id, int16 version){
	Item* bag = 0;
	if(bag_unique_id > 0)
		bag = item_list.GetItemFromUniqueID(bag_unique_id, true);

	if(bag && bag->IsBag())
		return bag->serialize(version, false, this);
	return 0;
}

void Player::SetEquippedItemAppearances(){
	vector<Item*>* items = GetEquipmentList()->GetAllEquippedItems();
	vector<Item*>* appearance_items = GetAppearanceEquipmentList()->GetAllEquippedItems();
	if(items){
		for(int32 i=0;i<items->size();i++)
			SetEquipment(items->at(i));
		
		// just have appearance items brute force replace the slots after the fact
		for(int32 i=0;i<appearance_items->size();i++)
			SetEquipment(appearance_items->at(i));
	}
	safe_delete(items);
	safe_delete(appearance_items);
	info_changed = true;
	GetZone()->SendSpawnChanges(this);
}

EQ2Packet* Player::SwapEquippedItems(int8 slot1, int8 slot2, int16 version, int16 equip_type){
	EquipmentItemList* equipList = &equipment_list;
	
	// right now client seems to pass 3 for this? Not sure why when other fields has appearance equipment as type 1
	if(equip_type == 3)
		equipList = &appearance_equipment_list;
	
	equipList->MEquipmentItems.readlock(__FUNCTION__, __LINE__);
	Item* item_from = equipList->items[slot1];
	Item* item_to = equipList->items[slot2];
	equipList->MEquipmentItems.releasereadlock(__FUNCTION__, __LINE__);

	if(item_from && equipList->CanItemBeEquippedInSlot(item_from, slot2)){
		if(item_to){
			if(!equipList->CanItemBeEquippedInSlot(item_to, slot1))
				return 0;
		}
		equipList->MEquipmentItems.writelock(__FUNCTION__, __LINE__);
		equipList->items[slot1] = nullptr;
		equipList->MEquipmentItems.releasewritelock(__FUNCTION__, __LINE__);
		equipList->SetItem(slot2, item_from);
		if(item_to)
		{
			equipList->SetItem(slot1, item_to);
			item_to->save_needed = true;
		}
		item_from->save_needed = true;
		
		if (GetClient())
		{
			//EquipmentItemList* equipList = &equipment_list;
			
			//if(appearance_type)
			//	equipList = &appearance_equipment_list;
			
			if(item_to)
				GetClient()->QueuePacket(item_to->serialize(version, false, this));
			GetClient()->QueuePacket(item_from->serialize(version, false, this));
			GetClient()->QueuePacket(item_list.serialize(this, version));
		}
		return equipList->serialize(version, this);
	}
	return 0;
}
bool Player::CanEquipItem(Item* item, int8 slot) {
	if (item) {
		Client* client = GetZone()->GetClientBySpawn(this);
		if (client) {
			if (item->IsWeapon() && slot == 1) {
				bool dwable = item->IsDualWieldAble(client, item, slot);

				if (dwable == 0) {
					return false;
				}
			}

			if (item->CheckFlag(EVIL_ONLY) && GetAlignment() != ALIGNMENT_EVIL) {
					client->Message(0, "%s requires an evil race.", item->name.c_str());
			}
			else if (item->CheckFlag(GOOD_ONLY) && GetAlignment() != ALIGNMENT_GOOD) {
					client->Message(0, "%s requires a good race.", item->name.c_str());
			}
			else if (item->IsArmor() || item->IsWeapon() || item->IsFood() || item->IsRanged() || item->IsShield() || item->IsBauble() || item->IsAmmo() || item->IsThrown()) {
				if ((item->generic_info.skill_req1 == 0 || item->generic_info.skill_req1 == 0xFFFFFFFF || skill_list.HasSkill(item->generic_info.skill_req1)) && (item->generic_info.skill_req2 == 0 || item->generic_info.skill_req2 == 0xFFFFFFFF || skill_list.HasSkill(item->generic_info.skill_req2))) {
					int16 override_level = item->GetOverrideLevel(GetAdventureClass(), GetTradeskillClass());
					if (override_level > 0 && override_level <= GetLevel())
						return true;
					if (item->CheckClass(GetAdventureClass(), GetTradeskillClass()))
						if (item->CheckLevel(GetAdventureClass(), GetTradeskillClass(), GetLevel()))
							return true;
						else
							client->Message(CHANNEL_COLOR_RED, "You must be at least level %u to equip %s.", item->generic_info.adventure_default_level, item->CreateItemLink(client->GetVersion()).c_str());
					else
						client->Message(CHANNEL_COLOR_RED, "Your class may not equip %s.", item->CreateItemLink(client->GetVersion()).c_str());
				}
				else
					client->SimpleMessage(0, "You lack the skill required to equip this item.");
			}
			else
				client->Message(0, "Item %s isn't equipable.", item->name.c_str());
		}
	}
	return false;
}

vector<EQ2Packet*> Player::EquipItem(int16 index, int16 version, int8 appearance_type, int8 slot_id) {

	EquipmentItemList* equipList = &equipment_list;
	if(appearance_type)
		equipList = &appearance_equipment_list;

	vector<EQ2Packet*>	packets;
	item_list.MPlayerItems.readlock(__FUNCTION__, __LINE__);
	if (item_list.indexed_items.count(index) == 0) {
		item_list.MPlayerItems.releasereadlock(__FUNCTION__, __LINE__);
		return packets;
	}
	Item* item = item_list.indexed_items[index];
	int8 orig_slot_id = slot_id;
	slot_id = ConvertSlotFromClient(slot_id, version);
	if (item) {
		if(orig_slot_id == 255 && item->CheckFlag2(APPEARANCE_ONLY)) {
			appearance_type = 1;
			equipList = &appearance_equipment_list;
		}
		if (slot_id != 255 && !item->HasSlot(slot_id)) {
			item_list.MPlayerItems.releasereadlock(__FUNCTION__, __LINE__);
			return packets;
		}
		int8 slot = equipList->GetFreeSlot(item, slot_id);
		bool canEquip = CanEquipItem(item,slot);
		int32 conflictSlot = 0;
		
		if(canEquip && !appearance_type && item->CheckFlag2(APPEARANCE_ONLY))
		{
			item_list.MPlayerItems.releasereadlock(__FUNCTION__, __LINE__);
			if(GetClient()) {
				GetClient()->SimpleMessage(CHANNEL_COLOR_RED, "This item is for appearance slots only.");
			}
			return packets;
		}
		else if(canEquip && (conflictSlot = equipList->CheckSlotConflict(item)) > 0) {
			bool abort = true;
			switch(conflictSlot) {
				case LORE:
					if(GetClient())
						GetClient()->SimpleMessage(CHANNEL_COLOR_RED, "Lore conflict, cannot equip this item.");
					break;
				case LORE_EQUIP:
					if(GetClient())
						GetClient()->SimpleMessage(CHANNEL_COLOR_RED, "You already have this item equipped, you cannot equip another.");
					break;
				case STACK_LORE:
					if(GetClient())
						GetClient()->SimpleMessage(CHANNEL_COLOR_RED, "Cannot equip as it exceeds lore stack.");
					break;
				default:
					abort = false;
					break;
			}
			if(abort) {
				item_list.MPlayerItems.releasereadlock(__FUNCTION__, __LINE__);
				return packets;
			}
		}
		else if (canEquip && item->CheckFlag(ATTUNEABLE)) {
			PacketStruct* packet = configReader.getStruct("WS_ChoiceWindow", version);
			char text[255];
			sprintf(text, "%s must be attuned before it can be equipped. Would you like to attune it now?", item->name.c_str());
			char accept_command[25];
			sprintf(accept_command, "attune_inv %i 1 0 -1", index);
			packet->setDataByName("text", text);
			packet->setDataByName("accept_text", "Attune");
			packet->setDataByName("accept_command", accept_command);
			packet->setDataByName("cancel_text", "Cancel");
			// No clue if we even need the following 2 unknowns, just added them so the packet matches what live sends
			packet->setDataByName("max_length", 50);
			packet->setDataByName("unknown4", 1);
			packets.push_back(packet->serialize());
			safe_delete(packet);
			item_list.MPlayerItems.releasereadlock(__FUNCTION__, __LINE__);
			return packets;
		}
		if (canEquip && slot == 255)
		{
			if (slot_id == 255)
				slot = item->slot_data.at(0);
			else
				slot = slot_id;
			item_list.MPlayerItems.releasereadlock(__FUNCTION__, __LINE__);
			packets = UnequipItem(slot, item->details.inv_slot_id, item->details.slot_id, version, appearance_type, false);
			// grab player items lock again and assure item still present
			item_list.MPlayerItems.readlock(__FUNCTION__, __LINE__);
			if (item_list.indexed_items.count(index) == 0) {
				item_list.MPlayerItems.releasereadlock(__FUNCTION__, __LINE__);
				return packets;
			}
			// If item is a 2handed weapon and something is in the secondary, unequip the secondary
			if (item->IsWeapon() && item->weapon_info->wield_type == ITEM_WIELD_TYPE_TWO_HAND && equipList->GetItem(EQ2_SECONDARY_SLOT) != 0) {
				item_list.MPlayerItems.releasereadlock(__FUNCTION__, __LINE__);
				vector<EQ2Packet*> tmp_packets = UnequipItem(EQ2_SECONDARY_SLOT, -999, 0, version, appearance_type, false);
				//packets.reserve(packets.size() + tmp_packets.size());
				packets.insert(packets.end(), tmp_packets.begin(), tmp_packets.end());
			}
			else {
				// release for delete item / scripting etc
				item_list.MPlayerItems.releasereadlock(__FUNCTION__, __LINE__);
			}
		}
		else if (canEquip && slot < 255) {
			// If item is a 2handed weapon and something is in the secondary, unequip the secondary
			if (item->IsWeapon() && item->weapon_info->wield_type == ITEM_WIELD_TYPE_TWO_HAND && equipList->GetItem(EQ2_SECONDARY_SLOT) != 0) {
				item_list.MPlayerItems.releasereadlock(__FUNCTION__, __LINE__);
				vector<EQ2Packet*> tmp_packets = UnequipItem(EQ2_SECONDARY_SLOT, -999, 0, version, appearance_type, false);
				//packets.reserve(packets.size() + tmp_packets.size());
				packets.insert(packets.end(), tmp_packets.begin(), tmp_packets.end());
			}
			else {
				// release for delete item / scripting etc
				item_list.MPlayerItems.releasereadlock(__FUNCTION__, __LINE__);
			}

			database.DeleteItem(GetCharacterID(), item, "NOT-EQUIPPED");

			if (item->GetItemScript() && lua_interface)
				lua_interface->RunItemScript(item->GetItemScript(), "equipped", item, this);

			item_list.RemoveItem(item);
			equipList->SetItem(ConvertSlotToClient(slot, version), item);
			item->save_needed = true;
			packets.push_back(item->serialize(version, false));
			SetEquipment(item);
			const char* zone_script = world.GetZoneScript(GetZone()->GetZoneID());
			if (zone_script && lua_interface)
				lua_interface->RunZoneScript(zone_script, "item_equipped", GetZone(), this, item->details.item_id, item->name.c_str(), 0, item->details.unique_id);
			int32 bag_id = item->details.inv_slot_id;
			if (item->generic_info.condition == 0) {
				Client* client = GetZone()->GetClientBySpawn(this);
				if (client) {

					LogWrite(MISC__TODO, 1, "TODO", "Send popup text in red 'Some of your equipment is broken!'\n\t(%s, function: %s, line #: %i)", __FILE__, __FUNCTION__, __LINE__);

					client->Message(CHANNEL_COLOR_RED, "Your %s is worn out and will not be effective until repaired.", item->CreateItemLink(client->GetVersion(), true).c_str());
				}
			}
			SetEquippedItemAppearances();
			packets.push_back(equipList->serialize(version, this));
			EQ2Packet* outapp = item_list.serialize(this, version);
			if (outapp) {
				packets.push_back(outapp);
				EQ2Packet* bag_packet = SendBagUpdate(bag_id, version);
				if (bag_packet)
					packets.push_back(bag_packet);
			}
			SetCharSheetChanged(true);
		}
		else {
				// clear items lock
				item_list.MPlayerItems.releasereadlock(__FUNCTION__, __LINE__);
		}
	}
	else {
			// clear items lock
			item_list.MPlayerItems.releasereadlock(__FUNCTION__, __LINE__);
	}
	
	client->UpdateSentSpellList();
	client->ClearSentSpellList();

	return packets;
}
bool Player::AddItem(Item* item, AddItemType type) {
	int32 conflictItemList = 0, conflictequipmentList = 0, conflictAppearanceEquipmentList = 0;
	int16 lore_stack_count = 0;
	if (item && item->details.item_id > 0) {
		if( ((conflictItemList = item_list.CheckSlotConflict(item, true, true, &lore_stack_count)) == LORE ||
		   (conflictequipmentList = equipment_list.CheckSlotConflict(item, true, &lore_stack_count)) == LORE ||
		   (conflictAppearanceEquipmentList = appearance_equipment_list.CheckSlotConflict(item, true, &lore_stack_count)) == LORE) && !item->CheckFlag(STACK_LORE)) {
			   
			switch(type)
			{
				case AddItemType::BUY_FROM_BROKER:
				client->Message(CHANNEL_COLOR_CHAT_RELATIONSHIP, "You already own this item and cannot have another.");
				break;
				default:
				client->Message(CHANNEL_COLOR_CHAT_RELATIONSHIP, "You cannot obtain %s due to lore conflict.", item->name.c_str());
				break;			
			}
			return false;
		}
		else if(conflictItemList == STACK_LORE || conflictequipmentList == STACK_LORE || 
				conflictAppearanceEquipmentList == STACK_LORE) {
					switch(type)
					{
						default:
						client->Message(CHANNEL_COLOR_CHAT_RELATIONSHIP, "You already have one stack of the LORE item: %s.", item->name.c_str());
						break;			
					}
			return false;
		}
		else if (item_list.AssignItemToFreeSlot(item)) {
			item->save_needed = true;
			return true;
		}
		else if (item_list.AddOverflowItem(item))
			return true;
	}
	return false;
}
bool Player::AddItemToBank(Item* item) {

	if (item && item->details.item_id > 0) {

		sint32 bag = -3;
		sint16 slot = -1;
		if (item_list.GetFirstFreeBankSlot(&bag, &slot)) {
			item->details.inv_slot_id = bag;
			item->details.slot_id = slot;
			item->save_needed = true;

			return item_list.AddItem(item);
		}
		else if (item_list.AddOverflowItem(item))
			return true;
	}
	return false;
}
EQ2Packet* Player::SendInventoryUpdate(int16 version) {
	// assure any inventory updates are reflected in sell window
	if(GetClient() && GetClient()->GetMerchantTransaction())
		GetClient()->SendSellMerchantList();
	
	return item_list.serialize(this, version);
}

void Player::UpdateInventory(int32 bag_id) {

	EQ2Packet* outapp = client->GetPlayer()->SendInventoryUpdate(client->GetVersion());
	client->QueuePacket(outapp);

	outapp = client->GetPlayer()->SendBagUpdate(bag_id, client->GetVersion());

	if (outapp)
		client->QueuePacket(outapp);

}
EQ2Packet* Player::MoveInventoryItem(sint32 to_bag_id, int16 from_index, int8 new_slot, int8 charges, int8 appearance_type, bool* item_deleted, int16 version) {
	Item* item = item_list.GetItemFromIndex(from_index);
	int8 result = item_list.MoveItem(to_bag_id, from_index, new_slot, appearance_type, charges);
	if (result == 1) {
		if (item) {
			if (!item->needs_deletion)
				item->save_needed = true;
			else if (item->needs_deletion) {
				database.DeleteItem(GetCharacterID(), item, 0);
				client->GetPlayer()->item_list.DestroyItem(from_index);
				client->GetPlayer()->UpdateInventory(to_bag_id);
				if(item_deleted)
					*item_deleted = true;
			}
		}
		return item_list.serialize(this, version);
	}
	else {
		PacketStruct* packet = configReader.getStruct("WS_DisplayText", version);
		if (packet) {
			packet->setDataByName("color", CHANNEL_COLOR_YELLOW);
			packet->setMediumStringByName("text", "Could not move item to that location.");
			packet->setDataByName("unknown02", 0x00ff);
			EQ2Packet* outapp = packet->serialize();
			safe_delete(packet);
			return outapp;
		}
	}
	return 0;
}

int32 Player::GetCoinsCopper(){
	return GetInfoStruct()->get_coin_copper();
}

int32 Player::GetCoinsSilver(){
	return GetInfoStruct()->get_coin_silver();
}

int32 Player::GetCoinsGold(){
	return GetInfoStruct()->get_coin_gold();
}

int32 Player::GetCoinsPlat(){
	return GetInfoStruct()->get_coin_plat();
}

int32 Player::GetBankCoinsCopper(){
	return GetInfoStruct()->get_bank_coin_copper();
}

int32 Player::GetBankCoinsSilver(){
	return GetInfoStruct()->get_bank_coin_silver();
}

int32 Player::GetBankCoinsGold(){
	return GetInfoStruct()->get_bank_coin_gold();
}

int32 Player::GetBankCoinsPlat(){
	return GetInfoStruct()->get_bank_coin_plat();
}

int32 Player::GetStatusPoints(){
	return GetInfoStruct()->get_status_points();
}

vector<QuickBarItem*>* Player::GetQuickbar(){
	return &quickbar_items;
}

bool Player::UpdateQuickbarNeeded(){
	return quickbar_updated;
}

void Player::ResetQuickbarNeeded(){
	quickbar_updated = false;
}

void Player::AddQuickbarItem(int32 bar, int32 slot, int32 type, int16 icon, int16 icon_type, int32 id, int8 tier, int32 unique_id, const char* text, bool update){
	RemoveQuickbarItem(bar, slot, false);
	QuickBarItem* ability = new QuickBarItem;
	ability->deleted = false;
	ability->hotbar = bar;
	ability->slot = slot;
	ability->type = type;
	ability->icon = icon;
	ability->tier = tier;
	ability->icon_type = icon_type;
	ability->id = id;
	if(unique_id == 0)
		unique_id = database.NextUniqueHotbarID();
	ability->unique_id = unique_id;
	if(type == QUICKBAR_TEXT_CMD && text){
		ability->text.data = string(text);
		ability->text.size = ability->text.data.length();
	}
	else
		ability->text.size = 0;
	quickbar_items.push_back(ability);
	if(update)
		quickbar_updated = true;
}

void Player::RemoveQuickbarItem(int32 bar, int32 slot, bool update){
	vector<QuickBarItem*>::iterator itr;
	QuickBarItem* qbi = 0;
	for(itr=quickbar_items.begin();itr!=quickbar_items.end();itr++){
		qbi = *itr;
		if(qbi && qbi->deleted == false && qbi->hotbar == bar && qbi->slot == slot){
			qbi->deleted = true;
			break;
		}
	}
	if(update)
		quickbar_updated = true;
}

void Player::ClearQuickbarItems(){
	quickbar_items.clear();
}

EQ2Packet* Player::GetQuickbarPacket(int16 version){
	PacketStruct* packet = configReader.getStruct("WS_QuickBarInit", version);
	if(packet){
		vector<QuickBarItem*>::iterator itr;
		packet->setArrayLengthByName("num_abilities", quickbar_items.size());
		int16 i=0;
		for(itr=quickbar_items.begin();itr != quickbar_items.end(); itr++){
			QuickBarItem* ability = *itr;
			if(!ability || ability->deleted)
				continue;
			packet->setArrayDataByName("hotbar", ability->hotbar, i);
			packet->setArrayDataByName("slot", ability->slot, i);
			packet->setArrayDataByName("type", ability->type, i);
			packet->setArrayDataByName("icon", ability->icon, i);
			packet->setArrayDataByName("icon_type", ability->icon_type, i);
			packet->setArrayDataByName("id", ability->id, i);
			packet->setArrayDataByName("unique_id", ability->tier, i);
			packet->setArrayDataByName("text", &ability->text, i);
			i++;
		}
		EQ2Packet* app = packet->serialize();
		safe_delete(packet);
		return app;
	}
	return 0;
}

void Player::AddSpellBookEntry(int32 spell_id, int8 tier, sint32 slot, int32 type, int32 timer, bool save_needed){
	SpellBookEntry* spell = new SpellBookEntry;
	spell->status = 169;
	spell->slot = slot;
	spell->spell_id = spell_id;
	spell->type = type;
	spell->tier = tier;
	spell->timer = timer;
	spell->save_needed = save_needed;
	spell->recast = 0;
	spell->recast_available = 0;
	spell->player = this;
	spell->visible = true;
	spell->in_use = false;
	spell->in_remiss = false;
	MSpellsBook.lock();
	spells.push_back(spell);
	MSpellsBook.unlock();
	
	if (type == SPELL_BOOK_TYPE_NOT_SHOWN)
		AddPassiveSpell(spell_id, tier);
}

void Player::RemoveSpellBookEntry(int32 spell_id, bool remove_passives_from_list){
	MSpellsBook.lock();
	vector<SpellBookEntry*>::iterator itr;
	SpellBookEntry* spell = 0;
	for(itr = spells.begin(); itr != spells.end(); itr++){
		spell = *itr;
		if(spell->spell_id == spell_id){
			if (spell->type == SPELL_BOOK_TYPE_NOT_SHOWN)
				RemovePassive(spell->spell_id, spell->tier, remove_passives_from_list);
			spells.erase(itr);
			break;
		}
	}
	MSpellsBook.unlock();
}

void Player::ResortSpellBook(int32 sort_by, int32 order, int32 pattern, int32 maxlvl_only, int32 book_type)
{
	//sort_by : 0 - alpha, 1 - level, 2 - category
	//order : 0 - ascending, 1 - descending
	//pattern : 0 - zigzag, 1 - down, 2 - across
	MSpellsBook.lock();

	std::vector<SpellBookEntry*> sort_spells(spells);
	
	if (!maxlvl_only)
	{
		switch (sort_by)
		{
		case 0:
			if (!order)
				stable_sort(sort_spells.begin(), sort_spells.end(), SortSpellEntryByName);
			else
				stable_sort(sort_spells.begin(), sort_spells.end(), SortSpellEntryByNameReverse);
			break;
		case 1:
			if (!order)
				stable_sort(sort_spells.begin(), sort_spells.end(), SortSpellEntryByLevel);
			else
				stable_sort(sort_spells.begin(), sort_spells.end(), SortSpellEntryByLevelReverse);
			break;
		case 2:
			if (!order)
				stable_sort(sort_spells.begin(), sort_spells.end(), SortSpellEntryByCategory);
			else
				stable_sort(sort_spells.begin(), sort_spells.end(), SortSpellEntryByCategoryReverse);
			break;
		}
	}

	vector<SpellBookEntry*>::iterator itr;
	SpellBookEntry* spell = 0;
	map<string, SpellBookEntry*> tmpSpells;
	vector<SpellBookEntry*> resultSpells;
	
	int32 i = 0;
	int8 page_book_count = 0;
	int32 last_start_point = 0;
	
	for (itr = sort_spells.begin(); itr != sort_spells.end(); itr++) {
		spell = *itr;

		if (spell->type != book_type)
			continue;

		if (maxlvl_only)
		{
			Spell* actual_spell = 0;
			actual_spell = master_spell_list.GetSpell(spell->spell_id, spell->tier);

			std::regex re("^(.*?)(\\s(I{1,}[VX]{0,}|V{1,}[IVX]{0,})|X{1,}[IVX]{0,})$");
			std::string output = std::regex_replace(string(actual_spell->GetName()), re, "$1", std::regex_constants::format_no_copy);

			if ( output.size() < 1 )
				output = string(actual_spell->GetName());

			map<string, SpellBookEntry*>::iterator tmpItr = tmpSpells.find(output);
			if (tmpItr != tmpSpells.end())
			{
				Spell* tmpSpell = master_spell_list.GetSpell(tmpItr->second->spell_id, tmpItr->second->tier);
				if (actual_spell->GetLevelRequired(this) > tmpSpell->GetLevelRequired(this))
				{
					tmpItr->second->visible = false;
					tmpItr->second->slot = 0xFFFF;

					std::vector<SpellBookEntry*>::iterator it;
					it = find(resultSpells.begin(), resultSpells.end(), (SpellBookEntry*)tmpItr->second);
					if (it != resultSpells.end())
						resultSpells.erase(it);

					tmpSpells.erase(tmpItr);
				}
				else
					continue; // leave as-is we have the newer spell
			}
			
			spell->visible = true;
			tmpSpells.insert(make_pair(output, spell));
			resultSpells.push_back(spell);
		}
		spell->slot = i;
		
		GetSpellBookSlotSort(pattern, &i, &page_book_count, &last_start_point);
	} // end for loop for setting slots
	
	if (maxlvl_only)
	{
		switch (sort_by)
		{
		case 0:
			if (!order)
				stable_sort(resultSpells.begin(), resultSpells.end(), SortSpellEntryByName);
			else
				stable_sort(resultSpells.begin(), resultSpells.end(), SortSpellEntryByNameReverse);
			break;
		case 1:
			if (!order)
				stable_sort(resultSpells.begin(), resultSpells.end(), SortSpellEntryByLevel);
			else
				stable_sort(resultSpells.begin(), resultSpells.end(), SortSpellEntryByLevelReverse);
			break;
		case 2:
			if (!order)
				stable_sort(resultSpells.begin(), resultSpells.end(), SortSpellEntryByCategory);
			else
				stable_sort(resultSpells.begin(), resultSpells.end(), SortSpellEntryByCategoryReverse);
			break;
		}

		i = 0;
		page_book_count = 0;
		last_start_point = 0;
		vector<SpellBookEntry*>::iterator tmpItr;
		for (tmpItr = resultSpells.begin(); tmpItr != resultSpells.end(); tmpItr++) {
			((SpellBookEntry*)*tmpItr)->slot = i;
			GetSpellBookSlotSort(pattern, &i, &page_book_count, &last_start_point);
		}
	}
	
	MSpellsBook.unlock();
}

bool Player::SortSpellEntryByName(SpellBookEntry* s1, SpellBookEntry* s2)
{
	Spell* spell1 = master_spell_list.GetSpell(s1->spell_id, s1->tier);
	Spell* spell2 = master_spell_list.GetSpell(s2->spell_id, s2->tier);

	if (!spell1 || !spell2)
		return false;

	return (string(spell1->GetName()) < string(spell2->GetName()));
}

bool Player::SortSpellEntryByCategory(SpellBookEntry* s1, SpellBookEntry* s2)
{
	Spell* spell1 = master_spell_list.GetSpell(s1->spell_id, s1->tier);
	Spell* spell2 = master_spell_list.GetSpell(s2->spell_id, s2->tier);

	if (!spell1 || !spell2)
		return false;

	return (spell1->GetSpellIconBackdrop() < spell2->GetSpellIconBackdrop());
}

bool Player::SortSpellEntryByLevel(SpellBookEntry* s1, SpellBookEntry* s2)
{
	Spell* spell1 = master_spell_list.GetSpell(s1->spell_id, s1->tier);
	Spell* spell2 = master_spell_list.GetSpell(s2->spell_id, s2->tier);

	if (!spell1 || !spell2)
		return false;

	int16 lvl1 = spell1->GetLevelRequired(s1->player);
	int16 lvl2 = spell2->GetLevelRequired(s2->player);
	if (lvl1 == 0xFFFF)
		lvl1 = 0;
	if (lvl2 == 0xFFFF)
		lvl2 = 0;

	return (lvl1 < lvl2);
}

bool Player::SortSpellEntryByNameReverse(SpellBookEntry* s1, SpellBookEntry* s2)
{
	Spell* spell1 = master_spell_list.GetSpell(s1->spell_id, s1->tier);
	Spell* spell2 = master_spell_list.GetSpell(s2->spell_id, s2->tier);

	if (!spell1 || !spell2)
		return false;

	return (string(spell2->GetName()) < string(spell1->GetName()));
}

bool Player::SortSpellEntryByCategoryReverse(SpellBookEntry* s1, SpellBookEntry* s2)
{
	Spell* spell1 = master_spell_list.GetSpell(s1->spell_id, s1->tier);
	Spell* spell2 = master_spell_list.GetSpell(s2->spell_id, s2->tier);
	if (!spell1 || !spell2)
		return false;
	return (spell2->GetSpellIconBackdrop() < spell1->GetSpellIconBackdrop());
}

bool Player::SortSpellEntryByLevelReverse(SpellBookEntry* s1, SpellBookEntry* s2)
{
	Spell* spell1 = master_spell_list.GetSpell(s1->spell_id, s1->tier);
	Spell* spell2 = master_spell_list.GetSpell(s2->spell_id, s2->tier);

	if (!spell1 || !spell2)
		return false;

	int16 lvl1 = spell1->GetLevelRequired(s1->player);
	int16 lvl2 = spell2->GetLevelRequired(s2->player);
	if (lvl1 == 0xFFFF)
		lvl1 = 0;
	if (lvl2 == 0xFFFF)
		lvl2 = 0;

	return (lvl2 < lvl1);
}

int8 Player::GetSpellSlot(int32 spell_id){
	MSpellsBook.lock();
	vector<SpellBookEntry*>::iterator itr;
	SpellBookEntry* spell = 0;
	for(itr = spells.begin(); itr != spells.end(); itr++){
		spell = *itr;
		if(spell->spell_id == spell_id)
		{
			int8 slot = spell->slot;
			MSpellsBook.unlock();
			return slot;
		}
	}
	MSpellsBook.unlock();
	return 0;
}

void Player::AddSkill(int32 skill_id, int16 current_val, int16 max_val, bool save_needed){
	Skill* master_skill = master_skill_list.GetSkill(skill_id);
	if (master_skill) {
		Skill* skill = new Skill(master_skill);
		skill->current_val = current_val;
		skill->previous_val = current_val;
		skill->max_val = max_val;
		if (save_needed)
			skill->save_needed = true;
		skill_list.AddSkill(skill);
	}
}

void Player::RemovePlayerSkill(int32 skill_id, bool save) {
	Skill* skill = skill_list.GetSkill(skill_id);
	if (skill)
		RemoveSkillFromDB(skill, save);
}

void Player::RemoveSkillFromDB(Skill* skill, bool save) {
	skill_list.RemoveSkill(skill);
	if (save)
		database.DeleteCharacterSkill(GetCharacterID(), skill);
}

int16 Player::GetSpellSlotMappingCount(){
	int16 ret = 0;
	MSpellsBook.lock();
	for(int32 i=0;i<spells.size();i++){
		SpellBookEntry* spell = (SpellBookEntry*)spells[i];
		if(spell->slot >= 0 && spell->spell_id > 0)
			ret++;
	}
	MSpellsBook.unlock();
	return ret;
}

int8 Player::GetSpellTier(int32 id){
	int8 ret = 0;
	MSpellsBook.lock();
	for(int32 i=0;i<spells.size();i++){
		SpellBookEntry* spell = (SpellBookEntry*)spells[i];
		if(spell->spell_id == id){
			ret = spell->tier;
			break;
		}
	}
	MSpellsBook.unlock();
	return ret;
}

int16 Player::GetSpellPacketCount(){
	int16 ret = 0;
	MSpellsBook.lock();
	for(int32 i=0;i<spells.size();i++){
		SpellBookEntry* spell = (SpellBookEntry*)spells[i];
		if(spell->spell_id > 0)
			ret++;
	}
	MSpellsBook.unlock();
	return ret;
}

void Player::LockAllSpells() {
	vector<SpellBookEntry*>::iterator itr;

	MSpellsBook.writelock(__FUNCTION__, __LINE__);
	for (itr = spells.begin(); itr != spells.end(); itr++) {
		if ((*itr)->type != SPELL_BOOK_TYPE_TRADESKILL)
			RemoveSpellStatus((*itr), SPELL_STATUS_LOCK, false);
	}

	all_spells_locked = true;

	MSpellsBook.releasewritelock(__FUNCTION__, __LINE__);
}

void Player::UnlockAllSpells(bool modify_recast, Spell* exception) {
	vector<SpellBookEntry*>::iterator itr;
	int32 exception_spell_id = 0;
	if (exception)
		exception_spell_id = exception->GetSpellID();
	MSpellsBook.writelock(__FUNCTION__, __LINE__);
	for (itr = spells.begin(); itr != spells.end(); itr++) {
		MaintainedEffects* effect = 0;
		if((effect = GetMaintainedSpell((*itr)->spell_id)) && effect->spell->spell->GetSpellData()->duration_until_cancel)
			continue;

		if ((*itr)->in_use == false && 
			 (((*itr)->spell_id != exception_spell_id || 
			 (*itr)->timer > 0 && (*itr)->timer != exception->GetSpellData()->linked_timer)
		&& (*itr)->type != SPELL_BOOK_TYPE_TRADESKILL))
			AddSpellStatus((*itr), SPELL_STATUS_LOCK, modify_recast);
		else if((*itr)->in_remiss)
		{
			AddSpellStatus((*itr), SPELL_STATUS_LOCK);
			(*itr)->in_remiss = false;
		}
	}

	all_spells_locked = false;

	MSpellsBook.releasewritelock(__FUNCTION__, __LINE__);
}

void Player::LockSpell(Spell* spell, int16 recast) {
	vector<SpellBookEntry*>::iterator itr;
	SpellBookEntry* spell2;
	MSpellsBook.writelock(__FUNCTION__, __LINE__);
	for (itr = spells.begin(); itr != spells.end(); itr++) {
		spell2 = *itr;
		if (spell2->spell_id == spell->GetSpellID() || (spell->GetSpellData()->linked_timer > 0 && spell->GetSpellData()->linked_timer == spell2->timer))
		{
			spell2->in_use = true;
			RemoveSpellStatus(spell2, SPELL_STATUS_LOCK, true, recast);
		}
		else if(spell2->in_use)
			RemoveSpellStatus(spell2, SPELL_STATUS_LOCK, false, 0);
	}
	MSpellsBook.releasewritelock(__FUNCTION__, __LINE__);
}

void Player::UnlockSpell(Spell* spell) {
	if (spell->GetStayLocked())
		return;
	vector<SpellBookEntry*>::iterator itr;
	SpellBookEntry* spell2;	
	MSpellsBook.writelock(__FUNCTION__, __LINE__);
	for (itr = spells.begin(); itr != spells.end(); itr++) {
		spell2 = *itr;
		if (spell2->spell_id == spell->GetSpellID() || (spell->GetSpellData()->linked_timer > 0 && spell->GetSpellData()->linked_timer == spell2->timer))
		{
			spell2->in_use = false;
			if(all_spells_locked)
				spell2->in_remiss = true;
			else
				AddSpellStatus(spell2, SPELL_STATUS_LOCK);
		}
	}
	MSpellsBook.releasewritelock(__FUNCTION__, __LINE__);
}

void Player::LockTSSpells() {
	vector<SpellBookEntry*>::iterator itr;

	MSpellsBook.writelock(__FUNCTION__, __LINE__);
	for (itr = spells.begin(); itr != spells.end(); itr++) {
		if ((*itr)->type == SPELL_BOOK_TYPE_TRADESKILL)
			RemoveSpellStatus(*itr, SPELL_STATUS_LOCK);
	}

	MSpellsBook.releasewritelock(__FUNCTION__, __LINE__);
	// Unlock all other types
	UnlockAllSpells();
}

void Player::UnlockTSSpells() {
	vector<SpellBookEntry*>::iterator itr;

	MSpellsBook.writelock(__FUNCTION__, __LINE__);
	for (itr = spells.begin(); itr != spells.end(); itr++) {
		if ((*itr)->type == SPELL_BOOK_TYPE_TRADESKILL)
			AddSpellStatus(*itr, SPELL_STATUS_LOCK);
	}

	MSpellsBook.releasewritelock(__FUNCTION__, __LINE__);
	// Lock all other types
	LockAllSpells();
}

void Player::QueueSpell(Spell* spell) {
	vector<SpellBookEntry*>::iterator itr;
	SpellBookEntry* spell2;
	MSpellsBook.writelock(__FUNCTION__, __LINE__);
	for (itr = spells.begin(); itr != spells.end(); itr++) {
		spell2 = *itr;
		if (spell2->spell_id == spell->GetSpellID())
			AddSpellStatus(spell2, SPELL_STATUS_QUEUE, false);
	}
	MSpellsBook.releasewritelock(__FUNCTION__, __LINE__);
}

void Player::UnQueueSpell(Spell* spell) {
	vector<SpellBookEntry*>::iterator itr;
	SpellBookEntry* spell2;
	MSpellsBook.writelock(__FUNCTION__, __LINE__);
	for (itr = spells.begin(); itr != spells.end(); itr++) {
		spell2 = *itr;
		if (spell2->spell_id == spell->GetSpellID())
			RemoveSpellStatus(spell2, SPELL_STATUS_QUEUE, false);
	}
	MSpellsBook.releasewritelock(__FUNCTION__, __LINE__);
}

vector<Spell*> Player::GetSpellBookSpellsByTimer(int32 timerID) {
	vector<Spell*> ret;
	vector<SpellBookEntry*>::iterator itr;
	MSpellsBook.readlock(__FUNCTION__, __LINE__);
	for (itr = spells.begin(); itr != spells.end(); itr++) {
		if ((*itr)->timer == timerID)
			ret.push_back(master_spell_list.GetSpell((*itr)->spell_id, (*itr)->tier));
	}
	MSpellsBook.releasereadlock(__FUNCTION__, __LINE__);
	return ret;
}

void Player::ModifySpellStatus(SpellBookEntry* spell, sint16 value, bool modify_recast, int16 recast) {
	if (modify_recast) {
		spell->recast = recast;
		spell->recast_available = Timer::GetCurrentTime2()	+ (recast * 100);
	}
	if (modify_recast || spell->recast_available <= Timer::GetCurrentTime2() || value == 4) {
		spell->status += value; // use set/remove spell status now
	}
}
void Player::AddSpellStatus(SpellBookEntry* spell, sint16 value, bool modify_recast, int16 recast) {
	if (modify_recast) {
		spell->recast = recast;
		spell->recast_available = Timer::GetCurrentTime2() + (recast * 100);
	}
	if (modify_recast || spell->recast_available <= Timer::GetCurrentTime2() || value == 4) {
		spell->status = spell->status | value;
	}
}
void Player::RemoveSpellStatus(SpellBookEntry* spell, sint16 value, bool modify_recast, int16 recast) {
	if (modify_recast) {
		spell->recast = recast;
		spell->recast_available = Timer::GetCurrentTime2() + (recast * 100);
	}
	if (modify_recast || spell->recast_available <= Timer::GetCurrentTime2() || value == 4) {
		spell->status = spell->status & ~value;
	}

}
void Player::SetSpellStatus(Spell* spell, int8 status){
	MSpellsBook.lock();
	vector<SpellBookEntry*>::iterator itr;
	SpellBookEntry* spell2 = 0;
	for(itr = spells.begin(); itr != spells.end(); itr++){
		spell2 = *itr;
		if(spell2->spell_id == spell->GetSpellData()->id){
			spell2->status = spell2->status | status;
			break;
		}
	}
	MSpellsBook.unlock();
}

vector<SpellBookEntry*>* Player::GetSpellsSaveNeeded(){
	vector<SpellBookEntry*>* ret = 0;
	vector<SpellBookEntry*>::iterator itr;
	MSpellsBook.lock();
	SpellBookEntry* spell = 0;
	for(itr = spells.begin(); itr != spells.end(); itr++){
		spell = *itr;
		if(spell->save_needed){
			if(!ret)
				ret = new vector<SpellBookEntry*>;
			ret->push_back(spell);
		}
	}
	MSpellsBook.unlock();
	return ret;
}

int16 Player::GetTierUp(int16 tier)
{
	switch(tier)
	{
		case 0:
			break;
		case 7:
		case 9:
			tier -= 2;
			break;
		default:
			tier -= 1;
		break;
	}

	return tier;
}
bool Player::HasSpell(int32 spell_id, int8 tier, bool include_higher_tiers, bool include_possible_scribe){
	bool ret = false;
	vector<SpellBookEntry*>::iterator itr;
	MSpellsBook.lock();
	SpellBookEntry* spell = 0;
	for(itr = spells.begin(); itr != spells.end(); itr++){
		spell = *itr;
		if(spell->spell_id == spell_id && (tier == 255 || spell->tier == tier || (include_higher_tiers && spell->tier > tier) || (include_possible_scribe && tier <= spell->tier))){
			ret = true;
			break;
		}
	}
	MSpellsBook.unlock();
	return ret;
}

sint32 Player::GetFreeSpellBookSlot(int32 type){
	sint32 ret = 0;
	MSpellsBook.lock();
	vector<SpellBookEntry*>::iterator itr;
	SpellBookEntry* spell = 0;
	for(itr = spells.begin(); itr != spells.end(); itr++){
		spell = *itr;
		if(spell->type == type && spell->slot > ret) //get last slot (add 1 to it on return)
			ret = spell->slot;
	}
	MSpellsBook.unlock();
	return ret+1;
}

SpellBookEntry* Player::GetSpellBookSpell(int32 spell_id){
	MSpellsBook.lock();
	vector<SpellBookEntry*>::iterator itr;
	SpellBookEntry* ret = 0;
	SpellBookEntry* spell = 0;
	for(itr = spells.begin(); itr != spells.end(); itr++){
		spell = *itr;
		if(spell->spell_id == spell_id){
			ret = spell;
			break;
		}
	}
	MSpellsBook.unlock();
	return ret;
}

vector<int32> Player::GetSpellBookSpellIDBySkill(int32 skill_id) {
	vector<int32> ret;

	MSpellsBook.readlock(__FUNCTION__, __LINE__);
	vector<SpellBookEntry*>::iterator itr;
	Spell* spell = 0;
	for(itr = spells.begin(); itr != spells.end(); itr++){
		spell = master_spell_list.GetSpell((*itr)->spell_id, (*itr)->tier);
		if(spell && spell->GetSpellData()->mastery_skill == skill_id)
			ret.push_back(spell->GetSpellData()->id);
	}	
	MSpellsBook.releasereadlock(__FUNCTION__, __LINE__);

	return ret;
}


EQ2Packet* Player::GetSpellSlotMappingPacket(int16 version){
	PacketStruct* packet = configReader.getStruct("WS_SpellSlotMapping", version);
	if(packet){
		int16 count = GetSpellSlotMappingCount();
		int16 ptr = 0;
		if(count > 0){
			packet->setArrayLengthByName("spell_count", count);
			MSpellsBook.lock();
			for(int32 i=0;i<spells.size();i++){
				SpellBookEntry* spell = (SpellBookEntry*)spells[i];
				if(spell->slot < 0 || spell->spell_id == 0)
					continue;
				packet->setArrayDataByName("spell_id", spell->spell_id, ptr);
				packet->setArrayDataByName("slot_id", (int16)spell->slot, ptr);
				ptr++;
			}
			MSpellsBook.unlock();
			EQ2Packet* ret = packet->serialize();
			safe_delete(packet);
			return ret;
		}
		safe_delete(packet);
	}
	return 0;
}

EQ2Packet* Player::GetSpellBookUpdatePacket(int16 version) {
	PacketStruct* packet = configReader.getStruct("WS_UpdateSpellBook", version);
	EQ2Packet* ret = 0;
	if (packet) {
		Spell* spell = 0;
		SpellBookEntry* spell_entry = 0;
		int16 count = GetSpellPacketCount();
		int16 ptr = 0;
		// Get the packet size
		PacketStruct* packet2 = configReader.getStruct("SubStruct_UpdateSpellBook", version);
		int32 total_bytes = packet2->GetTotalPacketSize();
		safe_delete(packet2);
		packet->setArrayLengthByName("spell_count", count);
		
		if (count > 0) {
			if (count > spell_count) {
				uchar* tmp = 0;
				if (spell_orig_packet) {
					tmp = new uchar[count * total_bytes];
					memset(tmp, 0, total_bytes * count);
					memcpy(tmp, spell_orig_packet, spell_count * total_bytes);
					safe_delete_array(spell_orig_packet);
					safe_delete_array(spell_xor_packet);
					spell_orig_packet = tmp;
				}
				else {
					spell_orig_packet = new uchar[count * total_bytes];
					memset(spell_orig_packet, 0, total_bytes * count);
				}
				spell_xor_packet = new uchar[count * total_bytes];
				memset(spell_xor_packet, 0, count * total_bytes);
			}
			spell_count = count;
			MSpellsBook.lock();
			for (int32 i = 0; i < spells.size(); i++) {
				spell_entry = (SpellBookEntry*)spells[i];
				if (spell_entry->spell_id == 0)
					continue;
				spell = master_spell_list.GetSpell(spell_entry->spell_id, spell_entry->tier);
				if (spell) {			
					if (spell_entry->recast_available == 0 || Timer::GetCurrentTime2() > spell_entry->recast_available) {
						packet->setSubstructArrayDataByName("spells", "available", 1, 0, ptr);
					}
										
					packet->setSubstructArrayDataByName("spells", "spell_id", spell_entry->spell_id, 0, ptr);
					packet->setSubstructArrayDataByName("spells", "type", spell_entry->type, 0, ptr);
					packet->setSubstructArrayDataByName("spells", "recast_available", spell_entry->recast_available, 0, ptr);
					packet->setSubstructArrayDataByName("spells", "recast_time", spell_entry->recast, 0, ptr);
					packet->setSubstructArrayDataByName("spells", "status", spell_entry->status, 0, ptr);
					packet->setSubstructArrayDataByName("spells", "icon", (spell->GetSpellIcon() * -1) - 1, 0, ptr);
					packet->setSubstructArrayDataByName("spells", "icon_type", spell->GetSpellIconBackdrop(), 0, ptr);
					packet->setSubstructArrayDataByName("spells", "icon2", spell->GetSpellIconHeroicOp(), 0, ptr);
					packet->setSubstructArrayDataByName("spells", "unique_id", (spell_entry->tier + 1) * -1, 0, ptr); //this is actually GetSpellNameCrc(spell->GetName()), but hijacking it for spell tier
					packet->setSubstructArrayDataByName("spells", "charges", 255, 0, ptr);
					// Beastlord and Channeler spell support
					if (spell->GetSpellData()->savage_bar == 1)
						packet->setSubstructArrayDataByName("spells", "unknown6", 32, 0, ptr); // advantages
					else if (spell->GetSpellData()->savage_bar == 2)
						packet->setSubstructArrayDataByName("spells", "unknown6", 64, 0, ptr); // primal
					else if (spell->GetSpellData()->savage_bar == 3) {
						packet->setSubstructArrayDataByName("spells", "unknown6", 6, 1, ptr); // 6 = channeler
						// Slot req for channelers
						// bitmask for slots 1 = slot 1, 2 = slot 2, 4 = slot 3, 8 = slot 4, 16 = slot 5, 32 = slot 6, 64 = slot 7, 128 = slot 8
						packet->setSubstructArrayDataByName("spells", "savage_bar_slot", spell->GetSpellData()->savage_bar_slot, 0, ptr);
					}

					ptr++;
				}
			}
			MSpellsBook.unlock();
		}
		ret = packet->serializeCountPacket(version, 0, spell_orig_packet, spell_xor_packet);
		//packet->PrintPacket();
		//DumpPacket(ret);
		safe_delete(packet);
	}
	return ret;
}

PlayerInfo::~PlayerInfo(){
	RemoveOldPackets();
}

PlayerInfo::PlayerInfo(Player* in_player){
	orig_packet = 0;
	changes = 0;
	pet_orig_packet = 0;
	pet_changes = 0;
	player = in_player;
	info_struct = player->GetInfoStruct();
	info_struct->set_name(std::string(player->GetName()));
	info_struct->set_deity(std::string("None"));

	info_struct->set_class1(classes.GetBaseClass(player->GetAdventureClass()));
	info_struct->set_class2(classes.GetSecondaryBaseClass(player->GetAdventureClass()));
	info_struct->set_class3(player->GetAdventureClass());

	info_struct->set_race(player->GetRace());
	info_struct->set_gender(player->GetGender());
	info_struct->set_level(player->GetLevel());
	info_struct->set_tradeskill_level(player->GetTSLevel());
	info_struct->set_tradeskill_class1(classes.GetTSBaseClass(player->GetTradeskillClass()));
	info_struct->set_tradeskill_class2(classes.GetSecondaryTSBaseClass(player->GetTradeskillClass()));
	info_struct->set_tradeskill_class3(player->GetTradeskillClass());

	for(int i=0;i<45;i++){
		if(i<30){
			info_struct->maintained_effects[i].spell_id = 0xFFFFFFFF;
			info_struct->maintained_effects[i].icon = 0xFFFF;
			info_struct->maintained_effects[i].spell = nullptr;
		}
		info_struct->spell_effects[i].spell_id = 0xFFFFFFFF;	
		info_struct->spell_effects[i].spell = nullptr;	
	}
	
	house_zone_id = 0;
	bind_zone_id = 0;
	bind_x = 0;
	bind_y = 0;
	bind_z = 0;
	bind_heading = 0;
	boat_x_offset = 0;
	boat_y_offset = 0;
	boat_z_offset = 0;
	boat_spawn = 0;
}

MaintainedEffects* Player::GetFreeMaintainedSpellSlot(){
	MaintainedEffects* ret = 0;
	InfoStruct* info = GetInfoStruct();
	GetMaintainedMutex()->readlock(__FUNCTION__, __LINE__);
	for(int i=0;i<NUM_MAINTAINED_EFFECTS;i++){
		if(info->maintained_effects[i].spell_id == 0xFFFFFFFF){
			ret = &info->maintained_effects[i];
			ret->spell_id = 0;
			ret->slot_pos = i;
			break;
		}
	}
	GetMaintainedMutex()->releasereadlock(__FUNCTION__, __LINE__);
	return ret;
}

MaintainedEffects* Player::GetMaintainedSpell(int32 id){
	MaintainedEffects* ret = 0;
	InfoStruct* info = GetInfoStruct();
	GetMaintainedMutex()->readlock(__FUNCTION__, __LINE__);
	for(int i=0;i<NUM_MAINTAINED_EFFECTS;i++){
		if(info->maintained_effects[i].spell_id == id){
			ret = &info->maintained_effects[i];
			break;
		}
	}
	GetMaintainedMutex()->releasereadlock(__FUNCTION__, __LINE__);
	return ret;
}

MaintainedEffects* Player::GetMaintainedSpellBySlot(int8 slot){
	MaintainedEffects* ret = 0;
	InfoStruct* info = GetInfoStruct();
	GetMaintainedMutex()->readlock(__FUNCTION__, __LINE__);
	for(int i=0;i<NUM_MAINTAINED_EFFECTS;i++){
		if(info->maintained_effects[i].slot_pos == slot){
			ret = &info->maintained_effects[i];
			break;
		}
	}
	GetMaintainedMutex()->releasereadlock(__FUNCTION__, __LINE__);
	return ret;
}

MaintainedEffects* Player::GetMaintainedSpells() {
	return GetInfoStruct()->maintained_effects;
}

SpellEffects* Player::GetFreeSpellEffectSlot(){
	SpellEffects* ret = 0;
	InfoStruct* info = GetInfoStruct();
	GetSpellEffectMutex()->readlock(__FUNCTION__, __LINE__);
	for(int i=0;i<45;i++){
		if(info->spell_effects[i].spell_id == 0xFFFFFFFF){
			ret = &info->spell_effects[i];
			ret->spell_id = 0;
			break;
		}
	}
	GetSpellEffectMutex()->releasereadlock(__FUNCTION__, __LINE__);
	return ret;
}

SpellEffects* Player::GetSpellEffects() {
	return GetInfoStruct()->spell_effects;
}

// call inside info_mutex
void Player::ClearRemovalTimers(){
	map<int32, SpawnQueueState*>::iterator itr;
	for(itr = spawn_state_list.begin(); itr != spawn_state_list.end();) {
		SpawnQueueState* sr = itr->second;
		itr = spawn_state_list.erase(itr);
		safe_delete(sr);
	}
}

void Player::ClearEverything(){
	index_mutex.writelock(__FUNCTION__, __LINE__);
	player_spawn_id_map.clear();
	player_spawn_reverse_id_map.clear();
	index_mutex.releasewritelock(__FUNCTION__, __LINE__);
	map<int32, vector<int32>*>::iterator itr;
	m_playerSpawnQuestsRequired.writelock(__FUNCTION__, __LINE__);
	for (itr = player_spawn_quests_required.begin(); itr != player_spawn_quests_required.end(); itr++){
		safe_delete(itr->second);
	}
	player_spawn_quests_required.clear();
	m_playerSpawnQuestsRequired.releasewritelock(__FUNCTION__, __LINE__);

	m_playerSpawnHistoryRequired.writelock(__FUNCTION__, __LINE__);
	for (itr = player_spawn_history_required.begin(); itr != player_spawn_history_required.end(); itr++){
		safe_delete(itr->second);
	}
	player_spawn_history_required.clear();
	m_playerSpawnHistoryRequired.releasewritelock(__FUNCTION__, __LINE__);

	spawn_mutex.writelock(__FUNCTION__, __LINE__);
	ClearRemovalTimers();
	spawn_packet_sent.clear();
	spawn_mutex.releasewritelock(__FUNCTION__, __LINE__);

	info_mutex.writelock(__FUNCTION__, __LINE__);
	spawn_info_packet_list.clear();
	info_mutex.releasewritelock(__FUNCTION__, __LINE__);

	vis_mutex.writelock(__FUNCTION__, __LINE__);
	spawn_vis_packet_list.clear();
	vis_mutex.releasewritelock(__FUNCTION__, __LINE__);

	pos_mutex.writelock(__FUNCTION__, __LINE__);
	spawn_pos_packet_list.clear();
	pos_mutex.releasewritelock(__FUNCTION__, __LINE__);
}

bool Player::IsFullyLoggedIn() {
	return fully_logged_in;
}
void Player::SetFullyLoggedIn(bool val) {
	fully_logged_in = val;
}
bool Player::IsResurrecting(){
	return resurrecting;
}
void Player::SetResurrecting(bool val){
	resurrecting = val;
}
void Player::AddMaintainedSpell(LuaSpell* luaspell){
	if(!luaspell)
		return;

	Spell* spell = luaspell->spell;
	MaintainedEffects* effect = GetFreeMaintainedSpellSlot();
	int32 target_type = 0;
	Spawn* spawn = 0;

	if(effect){
		GetMaintainedMutex()->writelock(__FUNCTION__, __LINE__);
		strcpy(effect->name, spell->GetSpellData()->name.data.c_str());
		effect->target = luaspell->initial_target;

		spawn = luaspell->caster->GetZone()->GetSpawnByID(luaspell->initial_target);
		if (spawn){
			if (spawn == this)
				target_type = 0;
			else if (GetPet() == spawn || GetCharmedPet() == spawn)
				target_type = 1;
			else
				target_type = 2;
		}
		effect->target_type = target_type;

		effect->spell = luaspell;
		if(!luaspell->slot_pos)
			luaspell->slot_pos = effect->slot_pos;
		effect->spell_id = spell->GetSpellData()->id;
		LogWrite(PLAYER__DEBUG, 5, "Player", "AddMaintainedSpell Spell ID: %u, req concentration: %u", spell->GetSpellData()->id, spell->GetSpellData()->req_concentration);
		effect->icon = spell->GetSpellData()->icon;
		effect->icon_backdrop = spell->GetSpellData()->icon_backdrop;
		effect->conc_used = spell->GetSpellData()->req_concentration;
		effect->total_time = spell->GetSpellDuration()/10;
		effect->tier = spell->GetSpellData()->tier;
		if (spell->GetSpellData()->duration_until_cancel)
			effect->expire_timestamp = 0xFFFFFFFF;
		else
			effect->expire_timestamp = Timer::GetCurrentTime2() + (spell->GetSpellDuration()*100);
		GetMaintainedMutex()->releasewritelock(__FUNCTION__, __LINE__);
		charsheet_changed = true;
	}
}
void Player::AddSpellEffect(LuaSpell* luaspell, int32 override_expire_time){
	if(!luaspell || !luaspell->caster)
		return;

	Spell* spell = luaspell->spell;
	SpellEffects* old_effect = GetSpellEffect(spell->GetSpellID(), luaspell->caster);
	SpellEffects* effect = 0;
	if (old_effect){
		GetZone()->RemoveTargetFromSpell(old_effect->spell, this);
		RemoveSpellEffect(old_effect->spell);
	}
	effect = GetFreeSpellEffectSlot();

	if(effect){
		GetSpellEffectMutex()->writelock(__FUNCTION__, __LINE__);
		effect->spell = luaspell;
		effect->spell_id = spell->GetSpellData()->id;
		effect->caster = luaspell->caster;
		effect->total_time = spell->GetSpellDuration()/10;
		if (spell->GetSpellData()->duration_until_cancel)
			effect->expire_timestamp = 0xFFFFFFFF;
		else if(override_expire_time)
			effect->expire_timestamp = Timer::GetCurrentTime2() + override_expire_time;
		else
			effect->expire_timestamp = Timer::GetCurrentTime2() + (spell->GetSpellDuration()*100);
		effect->icon = spell->GetSpellData()->icon;
		effect->icon_backdrop = spell->GetSpellData()->icon_backdrop;
		effect->tier = spell->GetSpellTier();
		GetSpellEffectMutex()->releasewritelock(__FUNCTION__, __LINE__);
		charsheet_changed = true;

		if(luaspell->caster && luaspell->caster->IsPlayer() && luaspell->caster != this)
		{
			if(GetClient()) {
				GetClient()->TriggerSpellSave();
			}
			if(((Player*)luaspell->caster)->GetClient()) {
				((Player*)luaspell->caster)->GetClient()->TriggerSpellSave();
			}
		}
	}	
}

void Player::RemoveMaintainedSpell(LuaSpell* luaspell){
	if(!luaspell)
		return;

	bool found = false;
	Client* client = GetZone()->GetClientBySpawn(this);
	LuaSpell* old_spell = 0;
	LuaSpell* current_spell = 0;
	GetMaintainedMutex()->writelock(__FUNCTION__, __LINE__);
	for(int i=0;i<30;i++){
		// If we already found the spell then we are bumping all other up one so there are no gaps in the ui
		// This check needs to be first so found can never be true on the first iteration (i = 0)
		if (found) {
			old_spell = GetInfoStruct()->maintained_effects[i - 1].spell;
			current_spell = GetInfoStruct()->maintained_effects[i].spell;

		    //Update the maintained window uses_remaining and damage_remaining values
			if (current_spell && current_spell->num_triggers > 0)
				ClientPacketFunctions::SendMaintainedExamineUpdate(client, i - 1, current_spell->num_triggers, 0);
			else if (current_spell && current_spell->damage_remaining > 0)
				ClientPacketFunctions::SendMaintainedExamineUpdate(client, i - 1, current_spell->damage_remaining, 1);
			else if (old_spell && old_spell->had_triggers)
				ClientPacketFunctions::SendMaintainedExamineUpdate(client, i - 1, 0, 0);
			else if (old_spell && old_spell->had_dmg_remaining)
				ClientPacketFunctions::SendMaintainedExamineUpdate(client, i - 1, 0, 1);


			GetInfoStruct()->maintained_effects[i].slot_pos = i - 1;
			GetInfoStruct()->maintained_effects[i - 1] = GetInfoStruct()->maintained_effects[i];
			if (current_spell)
				current_spell->slot_pos = i - 1;
		}
		// Compare spells, if we found a match set the found flag
		if(GetInfoStruct()->maintained_effects[i].spell == luaspell)
			found = true;
	}
	// if we found the spell in the array then we need to flag the char sheet as changed and set the last element to empty
	if (found) {
		memset(&GetInfoStruct()->maintained_effects[29], 0, sizeof(MaintainedEffects));
		GetInfoStruct()->maintained_effects[29].spell_id = 0xFFFFFFFF;
		GetInfoStruct()->maintained_effects[29].icon = 0xFFFF;
		GetInfoStruct()->maintained_effects[29].spell = nullptr;
		charsheet_changed = true;
	}
	GetMaintainedMutex()->releasewritelock(__FUNCTION__, __LINE__);
}

void Player::RemoveSpellEffect(LuaSpell* spell){
	bool found = false;
	GetSpellEffectMutex()->writelock(__FUNCTION__, __LINE__);
	for(int i=0;i<45;i++){
		if (found) {
			GetInfoStruct()->spell_effects[i-1] = GetInfoStruct()->spell_effects[i];
		}
		if(GetInfoStruct()->spell_effects[i].spell == spell)
			found = true;
	}
	if (found) {
		memset(&GetInfoStruct()->spell_effects[44], 0, sizeof(SpellEffects));
		GetInfoStruct()->spell_effects[44].spell_id = 0xFFFFFFFF;
		changed = true;
		info_changed = true;
		AddChangedZoneSpawn();
		charsheet_changed = true;
	}
	GetSpellEffectMutex()->releasewritelock(__FUNCTION__, __LINE__);
}

void Player::PrepareIncomingMovementPacket(int32 len, uchar* data, int16 version)
{
	if(GetClient() && GetClient()->IsReloadingZone())
		return;

	LogWrite(PLAYER__DEBUG, 7, "Player", "Enter: %s", __FUNCTION__); // trace

	// XML structs may be to slow to use in this portion of the code as a single
	// client sends a LOT of these packets when they are moving.  I have commented
	// out all the code for xml structs, to switch to it just uncomment
	// the code and comment the 2 if/else if/else blocks, both have a comment
	// above them to let you know wich ones they are.

	//PacketStruct* update = configReader.getStruct("WS_PlayerPosUpdate", version);
	int16 total_bytes;		// = update->GetTotalPacketSize();

	// Comment out this if/else if/else block if you switch to xml structs
	if (version >= 1144)
		total_bytes = sizeof(Player_Update1144);
	else if (version >= 1096)
		total_bytes = sizeof(Player_Update1096);
	else if (version <= 283)
		total_bytes = sizeof(Player_Update283);
	else
		total_bytes = sizeof(Player_Update);

	if (!movement_packet)
		movement_packet = new uchar[total_bytes];
	else if (!old_movement_packet)
		old_movement_packet = new uchar[total_bytes];
	if (movement_packet && old_movement_packet)
		memcpy(old_movement_packet, movement_packet, total_bytes);
	bool reverse = version > 283;
	Unpack(len, data, movement_packet, total_bytes, 0, reverse);
	if (!movement_packet || !old_movement_packet)
		return;
	Decode(movement_packet, old_movement_packet, total_bytes);

	//update->LoadPacketData(movement_packet, total_bytes);

	int32 activity;		// = update->getType_int32_ByName("activity");
	int32 grid_id;		// = update->getType_int32_ByName("grid_location");
	float direction1;	// = update->getType_float_ByName("direction1");
	float direction2;	// = update->getType_float_ByName("direction2");;
	float speed;		// = update->getType_float_ByName("speed");;
	float side_speed;
	float x;			// = update->getType_float_ByName("x");;
	float y;			// = update->getType_float_ByName("y");;
	float z;			// = update->getType_float_ByName("z");;
	float x_speed;
	float y_speed;
	float z_speed;

	// comment out this if/else if/else block if you use xml structs
	if (version >= 1144) {
		Player_Update1144* update = (Player_Update1144*)movement_packet;
		activity = update->activity;
		grid_id = update->grid_location;
		direction1 = update->direction1;
		direction2 = update->direction2;
		speed = update->speed;
		side_speed = update->side_speed;
		x = update->x;
		y = update->y;
		z = update->z;
		x_speed = update->speed_x;
		y_speed = update->speed_y;
		z_speed = update->speed_z;

		SetPitch(180 + update->pitch);
	}
	else if (version >= 1096) {
		Player_Update1096* update = (Player_Update1096*)movement_packet;
		activity = update->activity;
		grid_id = update->grid_location;
		direction1 = update->direction1;
		direction2 = update->direction2;
		speed = update->speed;
		side_speed = update->side_speed;
		x = update->x;
		y = update->y;
		z = update->z;
		x_speed = update->speed_x;
		y_speed = update->speed_y;
		z_speed = update->speed_z;

		SetPitch(180 + update->pitch);
	}
	else if (version <= 283) {
		Player_Update283* update = (Player_Update283*)movement_packet;
		activity = update->activity;
		grid_id = update->grid_location;
		direction1 = update->direction1;
		direction2 = update->direction2;
		speed = update->speed;
		side_speed = update->side_speed;
		x = update->x;
		y = update->y;
		z = update->z;
		x_speed = update->speed_x;
		y_speed = update->speed_y;
		z_speed = update->speed_z;
		if (update->pitch != 0)
			SetPitch(180 + update->pitch);
	}
	else {
		Player_Update* update = (Player_Update*)movement_packet;
		activity = update->activity;
		grid_id = update->grid_location;
		direction1 = update->direction1;
		direction2 = update->direction2;
		speed = update->speed;
		side_speed = update->side_speed;
		x = update->x;
		y = update->y;
		z = update->z;
		x_speed = update->speed_x;
		y_speed = update->speed_y;
		z_speed = update->speed_z;
		appearance.pos.X2 = update->orig_x;
		appearance.pos.Y2 = update->orig_y;
		appearance.pos.Z2 = update->orig_z;
		appearance.pos.X3 = update->orig_x2;
		appearance.pos.Y3 = update->orig_y2;
		appearance.pos.Z3 = update->orig_z2;
		SetPitch(180 + update->pitch);
	}

	SetHeading((sint16)(direction1 * 64), (sint16)(direction2 * 64));
	if (activity != last_movement_activity) {
		switch(activity) {
			case UPDATE_ACTIVITY_RUNNING:
			case UPDATE_ACTIVITY_RUNNING_AOM:
			case UPDATE_ACTIVITY_IN_WATER_ABOVE:
			case UPDATE_ACTIVITY_IN_WATER_BELOW:
			case UPDATE_ACTIVITY_MOVE_WATER_ABOVE_AOM:
			case UPDATE_ACTIVITY_MOVE_WATER_BELOW_AOM: {
				if(GetZone() && GetZone()->GetDrowningVictim(this))
					GetZone()->RemoveDrowningVictim(this);
				
				break;
			}
			case UPDATE_ACTIVITY_DROWNING:
			case UPDATE_ACTIVITY_DROWNING2:
			case UPDATE_ACTIVITY_DROWNING_AOM:
			case UPDATE_ACTIVITY_DROWNING2_AOM: {
				if(GetZone() && !GetInvulnerable()) {
					GetZone()->AddDrowningVictim(this);
				}
				break;
			}
			case UPDATE_ACTIVITY_JUMPING:
			case UPDATE_ACTIVITY_JUMPING_AOM:
			case UPDATE_ACTIVITY_FALLING:
			case UPDATE_ACTIVITY_FALLING_AOM: {
				if(GetInitialState() != 1024) {
					SetInitialState(1024);
				}
				else if(GetInitialState() == 1024) {
					if(activity == UPDATE_ACTIVITY_JUMPING_AOM) {
						SetInitialState(UPDATE_ACTIVITY_JUMPING_AOM);
					}
					else {
						SetInitialState(16512);
					}	
				}
				break;
			}
		}
		
		last_movement_activity = activity;
	}

	//Player is riding a lift, update lift XYZ offsets and the lift's spawn pointer
	if (activity & UPDATE_ACTIVITY_RIDING_BOAT) {
		Spawn* boat = 0;

		float boat_x = x;
		float boat_y = y;
		float boat_z = z;

		if (GetBoatSpawn() == 0 && GetZone()) {
			boat = GetZone()->GetClosestTransportSpawn(GetX(), GetY(), GetZ());
			SetBoatSpawn(boat);
			if(boat)
			{
				LogWrite(PLAYER__DEBUG, 0, "Player", "Set Player %s (%u) on Boat: %s", 
					GetName(), GetCharacterID(), boat ? boat->GetName() : "notset");
				boat->AddRailPassenger(GetCharacterID());
				GetZone()->CallSpawnScript(boat, SPAWN_SCRIPT_BOARD, this);
			}
		}

		if (boat || (GetBoatSpawn() && GetZone())) {
			if (!boat)
				boat = GetZone()->GetSpawnByID(GetBoatSpawn());

			if (boat && boat->IsWidget() && ((Widget*)boat)->GetMultiFloorLift()) {
				boat_x -= boat->GetX();
				boat_y -= boat->GetY();
				boat_z -= boat->GetZ();

				//appearance.pos.grid_id = grid_id;
			}
		}

		SetBoatX(boat_x);
		SetBoatY(boat_y);
		SetBoatZ(boat_z);
		pos_packet_speed = speed;
		grid_id = appearance.pos.grid_id;
	}
	else if (GetBoatSpawn() > 0 && !lift_cooldown.Enabled())
	{
		lift_cooldown.Start(100, true);
	}
	else if(lift_cooldown.Check())
	{
		if(GetBoatSpawn())
		{
			Spawn* boat = GetZone()->GetSpawnByID(GetBoatSpawn());
			if(boat)
			{
				LogWrite(PLAYER__DEBUG, 0, "Player", "Remove Player %s (%u) from Boat: %s", 
					GetName(), GetCharacterID(), boat ? boat->GetName() : "notset");
				boat->RemoveRailPassenger(GetCharacterID());
				GetZone()->CallSpawnScript(boat, SPAWN_SCRIPT_DEBOARD, this);
			}
		}
		SetBoatSpawn(0);
		lift_cooldown.Disable();
	}

	if (!IsResurrecting() && !GetBoatSpawn())
	{
		if (!IsRooted() && !IsMezzedOrStunned()) {
			SetX(x);
			SetY(y);
			SetZ(z);
			SetSpeedX(x_speed);
			SetSpeedY(y_speed);
			SetSpeedZ(z_speed);
			SetSideSpeed(side_speed);
			pos_packet_speed = speed;
		}
		else {
			SetSpeedX(0);
			SetSpeedY(0);
			SetSpeedZ(0);
			SetSideSpeed(0);
			pos_packet_speed = 0;
		}
	}

	if (appearance.pos.grid_id != grid_id)
	{
		LogWrite(PLAYER__DEBUG, 0, "Player", "%s left grid %u and entered grid %u", appearance.name, appearance.pos.grid_id, grid_id);
		const char* zone_script = world.GetZoneScript(GetZone()->GetZoneID());

		if (zone_script && lua_interface)
		{
			lua_interface->RunZoneScript(zone_script, "enter_location", GetZone(), this, grid_id);
			lua_interface->RunZoneScript(zone_script, "leave_location", GetZone(), this, appearance.pos.grid_id);
		}

		appearance.pos.grid_id = grid_id;
	}
	if (activity == UPDATE_ACTIVITY_IN_WATER_ABOVE || activity == UPDATE_ACTIVITY_IN_WATER_BELOW) {
		if (MakeRandomFloat(0, 100) < 25 && InWater())
			GetSkillByName("Swimming", true);
	}
	// don't have to uncomment the print packet but you MUST uncomment the safe_delete() for xml structs
	//update->PrintPacket();
	//safe_delete(update);

	LogWrite(PLAYER__DEBUG, 7, "Player", "Exit: %s", __FUNCTION__); // trace
}

int16 Player::GetLastMovementActivity(){
	return last_movement_activity;
}

void Player::AddSpawnInfoPacketForXOR(int32 spawn_id, uchar* packet, int16 packet_size){
	spawn_info_packet_list[spawn_id] = string((char*)packet, packet_size);
}

void Player::AddSpawnPosPacketForXOR(int32 spawn_id, uchar* packet, int16 packet_size){
	spawn_pos_packet_list[spawn_id] = string((char*)packet, packet_size);
}

uchar* Player::GetSpawnPosPacketForXOR(int32 spawn_id){
	uchar* ret = 0;
	if(spawn_pos_packet_list.count(spawn_id) == 1)
		ret = (uchar*)spawn_pos_packet_list[spawn_id].c_str();
	return ret;
}
uchar* Player::GetSpawnInfoPacketForXOR(int32 spawn_id){
	uchar* ret = 0;
	if(spawn_info_packet_list.count(spawn_id) == 1)
		ret = (uchar*)spawn_info_packet_list[spawn_id].c_str();
	return ret;
}
void Player::AddSpawnVisPacketForXOR(int32 spawn_id, uchar* packet, int16 packet_size){
	spawn_vis_packet_list[spawn_id] = string((char*)packet, packet_size);
}

uchar* Player::GetSpawnVisPacketForXOR(int32 spawn_id){
	uchar* ret = 0;
	if(spawn_vis_packet_list.count(spawn_id) == 1)
		ret = (uchar*)spawn_vis_packet_list[spawn_id].c_str();
	return ret;
}

uchar* Player::GetTempInfoPacketForXOR(){
	return spawn_tmp_info_xor_packet;
}

uchar* Player::GetTempVisPacketForXOR(){
	return spawn_tmp_vis_xor_packet;
}

uchar* Player::GetTempPosPacketForXOR(){
	return spawn_tmp_pos_xor_packet;
}

uchar* Player::SetTempInfoPacketForXOR(int16 size){
	spawn_tmp_info_xor_packet = new uchar[size];
	info_xor_size = size;
	return spawn_tmp_info_xor_packet;
}

uchar* Player::SetTempVisPacketForXOR(int16 size){
	spawn_tmp_vis_xor_packet = new uchar[size];
	vis_xor_size = size;
	return spawn_tmp_vis_xor_packet;
}

uchar* Player::SetTempPosPacketForXOR(int16 size){
	spawn_tmp_pos_xor_packet = new uchar[size];
	pos_xor_size = size;
	return spawn_tmp_pos_xor_packet;
}

bool Player::CheckPlayerInfo(){
	return info != 0;
}

bool Player::SetSpawnSentState(Spawn* spawn, SpawnState state) {
	bool val = true;
	spawn_mutex.writelock(__FUNCTION__, __LINE__);
	int16 index = GetIndexForSpawn(spawn);
	if(index > 0 && (state == SpawnState::SPAWN_STATE_SENDING)) {
		LogWrite(PLAYER__WARNING, 0, "Player", "Spawn ALREADY INDEXED for Player %s (%u).  Spawn %s (index %u) attempted to state %u.", 
			GetName(), GetCharacterID(), spawn->GetName(), index, state);
			if(GetClient() && GetClient()->IsReloadingZone()) {
				spawn_packet_sent.insert(make_pair(spawn->GetID(), state));
				val = false;
			}
		// we don't do anything this spawn is already populated by the player 
	}
	else {
		LogWrite(PLAYER__DEBUG, 0, "Player", "Spawn for Player %s (%u).  Spawn %s (index %u) in state %u.", 
			GetName(), GetCharacterID(), spawn->GetName(), index, state);
		
		map<int32,int8>::iterator itr = spawn_packet_sent.find(spawn->GetID());
		if(itr != spawn_packet_sent.end())
			itr->second = state;
		else
			spawn_packet_sent.insert(make_pair(spawn->GetID(), state));
		if(state == SPAWN_STATE_SENT_WAIT) {
			map<int32,SpawnQueueState*>::iterator state_itr;
			if((state_itr = spawn_state_list.find(spawn->GetID())) != spawn_state_list.end()) {
				safe_delete(state_itr->second);
				spawn_state_list.erase(state_itr);
			}
			
			SpawnQueueState* removal = new SpawnQueueState;
			removal->index_id = index;
			removal->spawn_state_timer = Timer(500, true);
			removal->spawn_state_timer.Start();
			spawn_state_list.insert(make_pair(spawn->GetID(),removal));
		}
		else if(state == SpawnState::SPAWN_STATE_REMOVING && 
			spawn_state_list.count(spawn->GetID()) == 0) {
			SpawnQueueState* removal = new SpawnQueueState;
			removal->index_id = index;
			removal->spawn_state_timer = Timer(1000, true);
			removal->spawn_state_timer.Start();
			spawn_state_list.insert(make_pair(spawn->GetID(),removal));
		}
	}
	spawn_mutex.releasewritelock(__FUNCTION__, __LINE__);
	return val;
}

void Player::CheckSpawnStateQueue() {
	if(!GetClient() || !GetClient()->IsReadyForUpdates())
		return;

	spawn_mutex.writelock(__FUNCTION__, __LINE__);
	map<int32, SpawnQueueState*>::iterator itr;
	for(itr = spawn_state_list.begin(); itr != spawn_state_list.end();) {
		if(itr->second->spawn_state_timer.Check()) {
			map<int32, int8>::iterator sent_itr = spawn_packet_sent.find(itr->first);
			LogWrite(PLAYER__DEBUG, 0, "Player", "Spawn for Player %s (%u).  Spawn index %u in state %u.", 
				GetName(), GetCharacterID(), itr->second->index_id, sent_itr->second);
			switch(sent_itr->second) {
				case SpawnState::SPAWN_STATE_SENT_WAIT: {
					sent_itr->second = SpawnState::SPAWN_STATE_SENT;
					SpawnQueueState* sr = itr->second;
					itr = spawn_state_list.erase(itr);
					safe_delete(sr);
					break;
				}
				case SpawnState::SPAWN_STATE_REMOVING: {
					if(itr->first == GetID() && GetClient()->IsReloadingZone()) {
						itr->second->spawn_state_timer.Disable();
						continue;
					}
					
					if(itr->second->index_id) {
						PacketStruct* packet = packet = configReader.getStruct("WS_DestroyGhostCmd", GetClient()->GetVersion());
						packet->setDataByName("spawn_index", itr->second->index_id);
						packet->setDataByName("delete", 1);	
						GetClient()->QueuePacket(packet->serialize());
						safe_delete(packet);
					}
					sent_itr->second = SpawnState::SPAWN_STATE_REMOVING_SLEEP;
					itr++;
					break;
				}
				case SpawnState::SPAWN_STATE_REMOVING_SLEEP: {
					map<int32, int8>::iterator sent_itr = spawn_packet_sent.find(itr->first);
					sent_itr->second = SpawnState::SPAWN_STATE_REMOVED;
					SpawnQueueState* sr = itr->second;
					itr = spawn_state_list.erase(itr);
					safe_delete(sr);
					break;
				}
				default: {
					// reset
					itr->second->spawn_state_timer.Disable();
					break;
				}
			}
		}
		else
			itr++;
	}
	spawn_mutex.releasewritelock(__FUNCTION__, __LINE__);
}

bool Player::WasSentSpawn(int32 spawn_id){
	if(GetID() == spawn_id)
		return true;

	bool ret = false;
	spawn_mutex.readlock(__FUNCTION__, __LINE__);
	map<int32, int8>::iterator itr = spawn_packet_sent.find(spawn_id);
	if(itr != spawn_packet_sent.end() && itr->second == SpawnState::SPAWN_STATE_SENT) {
		ret = true;
	}
	spawn_mutex.releasereadlock(__FUNCTION__, __LINE__);
	return ret;
}

bool Player::IsSendingSpawn(int32 spawn_id){
	bool ret = false;
	spawn_mutex.readlock(__FUNCTION__, __LINE__);
	map<int32, int8>::iterator itr = spawn_packet_sent.find(spawn_id);
	if(itr != spawn_packet_sent.end() && (itr->second == SpawnState::SPAWN_STATE_SENDING || itr->second == SPAWN_STATE_SENT_WAIT)) {
		ret = true;
	}
	spawn_mutex.releasereadlock(__FUNCTION__, __LINE__);
	return ret;
}

bool Player::IsRemovingSpawn(int32 spawn_id){
	bool ret = false;
	spawn_mutex.readlock(__FUNCTION__, __LINE__);
	map<int32, int8>::iterator itr = spawn_packet_sent.find(spawn_id);
	if(itr != spawn_packet_sent.end() && 
		(itr->second == SpawnState::SPAWN_STATE_REMOVING || itr->second == SpawnState::SPAWN_STATE_REMOVING_SLEEP)) {
		ret = true;
	}
	spawn_mutex.releasereadlock(__FUNCTION__, __LINE__);
	return ret;
}

PlayerSkillList* Player::GetSkills(){
	return &skill_list;
}

void Player::InCombat(bool val, bool range) {
	if (val)
		GetInfoStruct()->set_flags(GetInfoStruct()->get_flags() | (1 << (range?CF_RANGED_AUTO_ATTACK:CF_AUTO_ATTACK)));
	else
		GetInfoStruct()->set_flags(GetInfoStruct()->get_flags() & ~(1 << (range?CF_RANGED_AUTO_ATTACK:CF_AUTO_ATTACK)));

	bool changeCombatState = false;
	
	if((in_combat && !val) || (!in_combat && val))
		changeCombatState = true;

	in_combat = val;
	if(in_combat)
		AddIconValue(64);
	else
		RemoveIconValue(64);

	if(changeCombatState)
		SetRegenValues(GetInfoStruct()->get_effective_level());

	charsheet_changed = true;
	info_changed = true;
}

void Player::SetCharSheetChanged(bool val){
	charsheet_changed = val;
}

bool Player::GetCharSheetChanged(){
	return charsheet_changed;
}

bool Player::AdventureXPEnabled(){
	return (GetInfoStruct()->get_flags() & (1 << CF_COMBAT_EXPERIENCE_ENABLED));
}

bool Player::TradeskillXPEnabled() {
	// TODO: need to identify the flag to togle tradeskill xp
	return true;
}

void Player::set_character_flag(int flag){
	LogWrite(PLAYER__DEBUG, 0, "Player", "Flag: %u", flag);
	LogWrite(PLAYER__DEBUG, 0, "Player", "Flags before: %u, Flags2: %u", GetInfoStruct()->get_flags(), GetInfoStruct()->get_flags2());

	if (flag > CF_MAXIMUM_FLAG) return;
	if (flag < 32) GetInfoStruct()->set_flags(GetInfoStruct()->get_flags() | (1 << flag));
	else GetInfoStruct()->set_flags2(GetInfoStruct()->get_flags2() | (1 << (flag - 32)));
	charsheet_changed = true;
	info_changed = true;

	LogWrite(PLAYER__DEBUG, 0, "Player", "Flags after: %u, Flags2: %u", GetInfoStruct()->get_flags(), GetInfoStruct()->get_flags2());
}

void Player::reset_character_flag(int flag){
	LogWrite(PLAYER__DEBUG, 0, "Player", "Flag: %u", flag);
	LogWrite(PLAYER__DEBUG, 0, "Player", "Flags before: %u, Flags2: %u", GetInfoStruct()->get_flags(), GetInfoStruct()->get_flags2());

	if (flag > CF_MAXIMUM_FLAG) return;
	if (flag < 32)
	{
		int8 origflag = GetInfoStruct()->get_flags();
		GetInfoStruct()->set_flags(origflag &= ~(1 << flag));
	}
	else
	{
		int8 flag2 = GetInfoStruct()->get_flags2();
		GetInfoStruct()->set_flags2(flag2  &= ~(1 << (flag - 32)));
	}
	charsheet_changed = true;
	info_changed = true;

	LogWrite(PLAYER__DEBUG, 0, "Player", "Flags after: %u, Flags2: %u", GetInfoStruct()->get_flags(), GetInfoStruct()->get_flags2());
}

void Player::toggle_character_flag(int flag){
	LogWrite(PLAYER__DEBUG, 0, "Player", "Flag: %u", flag);
	LogWrite(PLAYER__DEBUG, 0, "Player", "Flags before: %u, Flags2: %u", GetInfoStruct()->get_flags(), GetInfoStruct()->get_flags2());

	if (flag > CF_MAXIMUM_FLAG) return;
	if (flag < 32)
	{
		int32 origflag = GetInfoStruct()->get_flags();
		GetInfoStruct()->set_flags(origflag ^= (1 << flag));
	}
	else
	{
		int32 flag2 = GetInfoStruct()->get_flags2();
		GetInfoStruct()->set_flags2(flag2  ^= (1 << (flag - 32)));
	}
	charsheet_changed = true;
	info_changed = true;

	LogWrite(PLAYER__DEBUG, 0, "Player", "Flags after: %u, Flags2: %u", GetInfoStruct()->get_flags(), GetInfoStruct()->get_flags2());
}

bool Player::get_character_flag(int flag){
	bool ret = false;

	if (flag > CF_MAXIMUM_FLAG){
		LogWrite(PLAYER__DEBUG, 0, "Player", "Player::get_character_flag error: attempted to check flag %i", flag);
		return ret;
	}
	if (flag < 32) ret = ((GetInfoStruct()->get_flags()) >> flag & 1);
	else ret = ((GetInfoStruct()->get_flags2()) >> (flag - 32) & 1);

	return ret;
}

float Player::GetXPVitality(){
	return GetInfoStruct()->get_xp_vitality();
}

float Player::GetTSXPVitality() {
	return GetInfoStruct()->get_tradeskill_xp_vitality();
}

bool Player::DoubleXPEnabled(){
	return GetInfoStruct()->get_xp_vitality() > 0;
}

void Player::SetCharacterID(int32 new_id){
	char_id = new_id;
}

int32 Player::GetCharacterID(){
	return char_id;
}

float Player::CalculateXP(Spawn* victim){
	if(AdventureXPEnabled() == false || !victim)
		return 0;
	float multiplier = 0;

	float zone_xp_modifier = 1;				// let's be safe!!
	if( GetZone()->GetXPModifier() != 0 ) {
		zone_xp_modifier = GetZone()->GetXPModifier();
		LogWrite(PLAYER__DEBUG, 5, "XP", "Zone XP Modifier = %.2f", zone_xp_modifier);
	}

	switch(GetArrowColor(victim->GetLevel())){
		case ARROW_COLOR_GRAY:
			LogWrite(PLAYER__DEBUG, 5, "XP", "Gray Arrow = No XP");
			return 0.0f;
			break;
		case ARROW_COLOR_GREEN:
			multiplier = 3.25;
			LogWrite(PLAYER__DEBUG, 5, "XP", "Green Arrow Multiplier = %.2f", multiplier);
			break;
		case ARROW_COLOR_BLUE:
			multiplier = 3.5;
			LogWrite(PLAYER__DEBUG, 5, "XP", "Blue Arrow Multiplier = %.2f", multiplier);
			break;
		case ARROW_COLOR_WHITE:
			multiplier = 4;
			LogWrite(PLAYER__DEBUG, 5, "XP", "White Arrow Multiplier = %.2f", multiplier);
			break;
		case ARROW_COLOR_YELLOW:
			multiplier = 4.25;
			LogWrite(PLAYER__DEBUG, 5, "XP", "Yellow Arrow Multiplier = %.2f", multiplier);
			break;
		case ARROW_COLOR_ORANGE:
			multiplier = 4.5;
			LogWrite(PLAYER__DEBUG, 5, "XP", "Orange Arrow Multiplier = %.2f", multiplier);
			break;
		case ARROW_COLOR_RED:
			multiplier = 6;
			LogWrite(PLAYER__DEBUG, 5, "XP", "Red Arrow Multiplier = %.2f", multiplier);
			break;
	}
	float total = multiplier * 8;	
	LogWrite(PLAYER__DEBUG, 5, "XP", "Multiplier * 8 = %.2f", total);

	if(victim->GetEncounterLevel() > 6) { // no need to multiply by 1 if this is a normal mob
		total *= (victim->GetEncounterLevel() - 5);
		LogWrite(PLAYER__DEBUG, 5, "XP", "Encounter > 6, total = %.2f", total);
	}
	else if(victim->GetEncounterLevel() <= 5) {
		total /= (7 - victim->GetEncounterLevel()); //1 down mobs are worth half credit, 2 down worth .25, etc
		LogWrite(PLAYER__DEBUG, 5, "XP", "Encounter <= 5, total = %.2f", total);
	}

	if(victim->GetHeroic() > 1) {
		total *= victim->GetHeroic();
		LogWrite(PLAYER__DEBUG, 5, "XP", "Heroic, total = %.2f", total);
	}
	if(DoubleXPEnabled()) {
		LogWrite(PLAYER__DEBUG, 5, "XP", "Calculating Double XP!");

		float percent = (((float)(total))/GetNeededXP()) *100;
		LogWrite(PLAYER__DEBUG, 5, "XP", "Percent of total / XP Needed * 100, percent = %.2f", percent);
		float xp_vitality = GetXPVitality();
		if(xp_vitality >= percent) {
			GetInfoStruct()->set_xp_vitality(xp_vitality - percent);
			total *= 2;
			LogWrite(PLAYER__DEBUG, 5, "XP", "Vitality >= Percent, total = %.2f", total);
		}
		else {
			total += ((GetXPVitality() / percent) *2)*total;
			GetInfoStruct()->set_xp_vitality(0);
			LogWrite(PLAYER__DEBUG, 5, "XP", "Vitality < Percent, total = %.2f", total);
		}
	}
	LogWrite(PLAYER__DEBUG, 5, "XP", "Final total = %.2f", (total * world.GetXPRate() * zone_xp_modifier));
	return total * world.GetXPRate() * zone_xp_modifier;
}

float Player::CalculateTSXP(int8 level){
	if(TradeskillXPEnabled() == false)
		return 0;
	float multiplier = 0;

	float zone_xp_modifier = 1;				// let's be safe!!
	if( GetZone()->GetXPModifier() != 0 ) {
		zone_xp_modifier = GetZone()->GetXPModifier();
		LogWrite(PLAYER__DEBUG, 5, "XP", "Zone XP Modifier = %.2f", zone_xp_modifier);
	}

	sint16 diff = level - GetTSLevel();
	if(GetTSLevel() < 10)
		diff *= 3;
	else if(GetTSLevel() <= 20)
		diff *= 2;
	if(diff >= 9)
		multiplier = 6;
	else if(diff >= 5)
		multiplier = 4.5;
	else if(diff >= 1)
		multiplier = 4.25;
	else if(diff == 0)
		multiplier = 4;
	else if(diff <= -11)
		multiplier = 0;
	else if(diff <= -6)
		multiplier = 3.25;
	else //if(diff < 0)
		multiplier = 3.5;


	float total = multiplier * 8;	
	LogWrite(PLAYER__DEBUG, 5, "XP", "Multiplier * 8 = %.2f", total);

	if(DoubleXPEnabled()) {
		LogWrite(PLAYER__DEBUG, 5, "XP", "Calculating Double XP!");

		float percent = (((float)(total))/GetNeededTSXP()) *100;
		LogWrite(PLAYER__DEBUG, 5, "XP", "Percent of total / XP Needed * 100, percent = %.2f", percent);

		float ts_xp_vitality = GetTSXPVitality();
		if(ts_xp_vitality >= percent) {
			GetInfoStruct()->set_tradeskill_xp_vitality(ts_xp_vitality - percent);
			total *= 2;
			LogWrite(PLAYER__DEBUG, 5, "XP", "Vitality >= Percent, total = %.2f", total);
		}
		else {
			total += ((GetTSXPVitality() / percent) *2)*total;
			GetInfoStruct()->set_tradeskill_xp_vitality(0);
			LogWrite(PLAYER__DEBUG, 5, "XP", "Vitality < Percent, total = %.2f", total);
		}
	}
	LogWrite(PLAYER__DEBUG, 5, "XP", "Final total = %.2f", (total * world.GetXPRate() * zone_xp_modifier));
	return total * world.GetXPRate() * zone_xp_modifier;
}

void Player::CalculateOfflineDebtRecovery(int32 unix_timestamp)
{
	float xpDebt = GetXPDebt();
	// not a real timestamp to work with
	if(unix_timestamp < 1 || xpDebt == 0.0f)
		return;

	uint32 diff = (Timer::GetCurrentTime2() - unix_timestamp)/1000;
	
	float recoveryDebtPercentage = rule_manager.GetGlobalRule(R_Combat, ExperienceDebtRecoveryPercent)->GetFloat()/100.0f;
	int32 recoveryPeriodSeconds = rule_manager.GetGlobalRule(R_Combat, ExperienceDebtRecoveryPeriod)->GetInt32();
	if(recoveryDebtPercentage == 0.0f || recoveryPeriodSeconds < 1)
		return;


	float periodsPassed = (float)diff/(float)recoveryPeriodSeconds;

	// not enough time passed to calculate debt xp recovered
	if(periodsPassed < 1.0f)
		return;

	float debtToSubtract = xpDebt * ((recoveryDebtPercentage*periodsPassed)/100.0f);

	if(debtToSubtract >= xpDebt)
		GetInfoStruct()->set_xp_debt(0.0f);
	else
		GetInfoStruct()->set_xp_debt(xpDebt - debtToSubtract);
}

void Player::SetNeededXP(int32 val){
	GetInfoStruct()->set_xp_needed(val);
}

void Player::SetNeededXP(){
	//GetInfoStruct()->xp_needed = GetLevel() * 100;
	// Get xp needed to get to the next level
	int16 level = GetLevel() + 1;
	// If next level is beyond what we have in the map multiply the last value we have by how many levels we are over plus one
	if (level > 95)
		SetNeededXP(m_levelXPReq[95] * ((level - 95) + 1));
	else
		SetNeededXP(m_levelXPReq[level]);
}

void Player::SetXP(int32 val){
	GetInfoStruct()->set_xp(val);
}

void Player::SetNeededTSXP(int32 val) {
	GetInfoStruct()->set_ts_xp_needed(val);
}

void Player::SetNeededTSXP() {
	GetInfoStruct()->set_ts_xp_needed(GetTSLevel() * 100);
}

void Player::SetTSXP(int32 val) {
	GetInfoStruct()->set_ts_xp(val);
}

float Player::GetXPDebt(){
	return GetInfoStruct()->get_xp_debt();
}

int32 Player::GetNeededXP(){
	return GetInfoStruct()->get_xp_needed();
}

int32 Player::GetXP(){
	return GetInfoStruct()->get_xp();
}

int32 Player::GetNeededTSXP() {
	return GetInfoStruct()->get_ts_xp_needed();
}

int32 Player::GetTSXP() {
	return GetInfoStruct()->get_ts_xp();
}

bool Player::AddXP(int32 xp_amount){
	if(!GetClient()) // potential linkdead player
		return false;
	
	MStats.lock();
	xp_amount += (int32)(((float)xp_amount) * stats[ITEM_STAT_COMBATEXPMOD]) / 100;
	MStats.unlock();

	if(GetInfoStruct()->get_xp_debt())
	{
		float expRatioToDebt = rule_manager.GetGlobalRule(R_Combat, ExperienceToDebt)->GetFloat()/100.0f;
		int32 amountToTakeFromDebt = (int32)((float)expRatioToDebt * (float)xp_amount);
		int32 amountRequiredClearDebt = (GetInfoStruct()->get_xp_debt()/100.0f) * xp_amount;

		if(amountToTakeFromDebt > amountRequiredClearDebt)
		{
			GetInfoStruct()->set_xp_debt(0.0f);
			if(amountRequiredClearDebt > xp_amount)
				xp_amount = 0;
			else
				xp_amount -= amountRequiredClearDebt;
		}
		else
		{
			float amountRemovedPct = ((float)amountToTakeFromDebt/(float)amountRequiredClearDebt);
			GetInfoStruct()->set_xp_debt(GetInfoStruct()->get_xp_debt()-amountRemovedPct);
			if(amountToTakeFromDebt > xp_amount)
				xp_amount = 0;
			else
				xp_amount -= amountToTakeFromDebt;
		}
	}
	
	// used up in xp debt
	if(!xp_amount) {
		SetCharSheetChanged(true);
		return true;
	}

	int32 prev_level = GetLevel();
	float current_xp_percent = ((float)GetXP()/(float)GetNeededXP())*100;
	float miniding_min_percent = ((int)(current_xp_percent/10)+1)*10;
	while((xp_amount + GetXP()) >= GetNeededXP()){
		if (!CheckLevelStatus(GetLevel() + 1)) {
			GetZone()->GetClientBySpawn(this)->SimpleMessage(CHANNEL_COLOR_RED, "You do not have the required status to level up anymore!");
			SetCharSheetChanged(true);	
			return false;
		}
		xp_amount -= GetNeededXP() - GetXP();
		SetLevel(GetLevel() + 1);		
	}
	SetXP(GetXP() + xp_amount);
	GetPlayerInfo()->CalculateXPPercentages();
	current_xp_percent = ((float)GetXP()/(float)GetNeededXP())*100;
	if(current_xp_percent >= miniding_min_percent){
		SetHP(GetTotalHP());
		SetPower(GetTotalPower());
		GetZone()->SendCastSpellPacket(332, this, this); //send mini level up spell effect
	}
	
	if(GetClient()) {
		GetClient()->Message(CHANNEL_REWARD, "You gain %u experience!", (int32)xp_amount);
			
		if (prev_level != GetLevel())
			GetClient()->ChangeLevel(prev_level, GetLevel());
	}
		
	SetCharSheetChanged(true);			
	return true;
}

bool Player::AddTSXP(int32 xp_amount){
	MStats.lock();
	xp_amount += ((xp_amount)*stats[ITEM_STAT_TRADESKILLEXPMOD]) / 100;
	MStats.unlock();

	float current_xp_percent = ((float)GetTSXP()/(float)GetNeededTSXP())*100;
	float miniding_min_percent = ((int)(current_xp_percent/10)+1)*10;
	while((xp_amount + GetTSXP()) >= GetNeededTSXP()){
		if (!CheckLevelStatus(GetTSLevel() + 1)) {
			GetZone()->GetClientBySpawn(this)->SimpleMessage(CHANNEL_COLOR_RED, "You do not have the required status to level up anymore!");
			return false;
		}
		xp_amount -= GetNeededTSXP() - GetTSXP();
		SetTSLevel(GetTSLevel() + 1);
		SetTSXP(0);
		SetNeededTSXP();
	}
	SetTSXP(GetTSXP() + xp_amount);
	GetPlayerInfo()->CalculateXPPercentages();
	current_xp_percent = ((float)GetTSXP()/(float)GetNeededTSXP())*100;
	if(current_xp_percent >= miniding_min_percent){
		SetHP(GetTotalHP());
		SetPower(GetTotalPower());
	}

	if (GetTradeskillClass() == 0){
		SetTradeskillClass(1);
		GetInfoStruct()->set_tradeskill_class1(1);
		GetInfoStruct()->set_tradeskill_class2(1);
		GetInfoStruct()->set_tradeskill_class3(1);
	}
	return true;
}

void Player::CalculateLocation(){
	if(GetSpeed() > 0 ){
		if(GetHeading() >= 270 && GetHeading() <= 360){
			SetX(GetX() + (GetSpeed()*.5)*((360-GetHeading())/90));
			SetZ(GetZ() - (GetSpeed()*.5)*((GetHeading()-270)/90));
		}
		else if(GetHeading() >= 180 && GetHeading() < 270){
			SetX(GetX() + (GetSpeed()*.5)*((GetHeading()-180)/90));
			SetZ(GetZ() + (GetSpeed()*.5)*((270-GetHeading())/90));
		}
		else if(GetHeading() >= 90 && GetHeading() < 180){
			SetX(GetX() - (GetSpeed()*.5)*((180-GetHeading())/90));
			SetZ(GetZ() + (GetSpeed()*.5)*((GetHeading()-90)/90));
		}
		else if(GetHeading() >= 0 && GetHeading() < 90){
			SetX(GetX() - (GetSpeed()*.5)*(GetHeading()/90));
			SetZ(GetZ() - (GetSpeed()*.5)*((90-GetHeading())/90));
		}
	}
}

Spawn* Player::GetSpawnByIndex(int16 index){
	Spawn* spawn = 0;

	index_mutex.readlock(__FUNCTION__, __LINE__);
	if(player_spawn_id_map.count(index) > 0)
		spawn = player_spawn_id_map[index];
	index_mutex.releasereadlock(__FUNCTION__, __LINE__);

	return spawn;
}

int16 Player::GetIndexForSpawn(Spawn* spawn) {
	int16 val = 0;

	index_mutex.readlock(__FUNCTION__, __LINE__);
	if(player_spawn_reverse_id_map.count(spawn) > 0)
		val = player_spawn_reverse_id_map[spawn];
	index_mutex.releasereadlock(__FUNCTION__, __LINE__);

	return val;
}

bool Player::WasSpawnRemoved(Spawn* spawn){
	bool wasRemoved = false;

	if(IsRemovingSpawn(spawn->GetID()))
		return false;
	
	spawn_mutex.readlock(__FUNCTION__, __LINE__);
	map<int32, int8>::iterator itr = spawn_packet_sent.find(spawn_id);
	if(itr != spawn_packet_sent.end() && itr->second == SpawnState::SPAWN_STATE_REMOVED) {
		wasRemoved = true;
	}
	spawn_mutex.releasereadlock(__FUNCTION__, __LINE__);

	return wasRemoved;
}

void Player::RemoveSpawn(Spawn* spawn)
{
	LogWrite(PLAYER__DEBUG, 3, "Player", "Remove Spawn '%s' (%u)", spawn->GetName(), spawn->GetID());

	SetSpawnSentState(spawn, SpawnState::SPAWN_STATE_REMOVING);
	
	info_mutex.writelock(__FUNCTION__, __LINE__);
	vis_mutex.writelock(__FUNCTION__, __LINE__);
	pos_mutex.writelock(__FUNCTION__, __LINE__);

	index_mutex.writelock(__FUNCTION__, __LINE__);

	if (player_spawn_reverse_id_map[spawn] && player_spawn_id_map.count(player_spawn_reverse_id_map[spawn]) > 0)
		player_spawn_id_map.erase(player_spawn_reverse_id_map[spawn]);

	if (player_spawn_reverse_id_map.count(spawn) > 0)
		player_spawn_reverse_id_map.erase(spawn);

	if (player_spawn_id_map.count(spawn->GetID()) && player_spawn_id_map[spawn->GetID()] == spawn)
		player_spawn_id_map.erase(spawn->GetID());

	int32 id = spawn->GetID();
	if (spawn_info_packet_list.count(id))
		spawn_info_packet_list.erase(id);

	if (spawn_pos_packet_list.count(id))
		spawn_pos_packet_list.erase(id);

	if (spawn_vis_packet_list.count(id))
		spawn_vis_packet_list.erase(id);

	index_mutex.releasewritelock(__FUNCTION__, __LINE__);

	info_mutex.releasewritelock(__FUNCTION__, __LINE__);
	pos_mutex.releasewritelock(__FUNCTION__, __LINE__);
	vis_mutex.releasewritelock(__FUNCTION__, __LINE__);
}

vector<int32> Player::GetQuestIDs(){
	vector<int32> ret;
	map<int32, Quest*>::iterator itr;
	MPlayerQuests.readlock(__FUNCTION__, __LINE__);
	for(itr = player_quests.begin(); itr != player_quests.end(); itr++){
		if(itr->second)
			ret.push_back(itr->second->GetQuestID());
	}
	MPlayerQuests.releasereadlock(__FUNCTION__, __LINE__);
	return ret;
}

vector<Quest*>* Player::CheckQuestsItemUpdate(Item* item){
	vector<Quest*>* quest_updates = 0;
	map<int32, Quest*>::iterator itr;
	MPlayerQuests.readlock(__FUNCTION__, __LINE__);
	for(itr = player_quests.begin(); itr != player_quests.end(); itr++){
		if(itr->second && itr->second->CheckQuestItemUpdate(item->details.item_id, item->details.count)){
			if(!quest_updates)
				quest_updates = new vector<Quest*>();
			quest_updates->push_back(itr->second);
		}
	}
	MPlayerQuests.releasereadlock(__FUNCTION__, __LINE__);
	return quest_updates;
}

void Player::CheckQuestsCraftUpdate(Item* item, int32 qty){
	map<int32, Quest*>::iterator itr;
	vector<Quest*>* update_list = new vector<Quest*>;
	MPlayerQuests.readlock(__FUNCTION__, __LINE__);
	for(itr = player_quests.begin(); itr != player_quests.end(); itr++){
		if(itr->second){
			if(item && qty > 0){
				if(itr->second->CheckQuestRefIDUpdate(item->details.item_id, qty)){
					update_list->push_back(itr->second);
				}
			}
		}
	}
	MPlayerQuests.releasereadlock(__FUNCTION__, __LINE__);
	if(update_list && update_list->size() > 0){
		Client* client = GetZone()->GetClientBySpawn(this);
		if(client){
			for(int8 i=0;i<update_list->size(); i++){
				client->SendQuestUpdate(update_list->at(i));
				client->SendQuestFailure(update_list->at(i));
			}
		}
	}
	update_list->clear();
	safe_delete(update_list);
}

void Player::CheckQuestsHarvestUpdate(Item* item, int32 qty){
	map<int32, Quest*>::iterator itr;
	vector<Quest*>* update_list = new vector<Quest*>;
	MPlayerQuests.readlock(__FUNCTION__, __LINE__);
	for(itr = player_quests.begin(); itr != player_quests.end(); itr++){
		if(itr->second){
			if(item && qty > 0){
				if(itr->second->CheckQuestRefIDUpdate(item->details.item_id, qty)){
					update_list->push_back(itr->second);
				}
			}
		}
	}
	MPlayerQuests.releasereadlock(__FUNCTION__, __LINE__);
	if(update_list && update_list->size() > 0){
		Client* client = GetZone()->GetClientBySpawn(this);
		if(client){
			for(int8 i=0;i<update_list->size(); i++){
				client->SendQuestUpdate(update_list->at(i));
				client->SendQuestFailure(update_list->at(i));
			}
		}
	}
	update_list->clear();
	safe_delete(update_list);
}

vector<Quest*>* Player::CheckQuestsSpellUpdate(Spell* spell) {
	vector<Quest*>* quest_updates = 0;
	map<int32, Quest*>::iterator itr;
	MPlayerQuests.readlock(__FUNCTION__, __LINE__);
	for (itr = player_quests.begin(); itr != player_quests.end(); itr++){
		if (itr->second && itr->second->CheckQuestSpellUpdate(spell)) {
			if (!quest_updates)
				quest_updates = new vector<Quest*>();
			quest_updates->push_back(itr->second);
		}
	}
	MPlayerQuests.releasereadlock(__FUNCTION__, __LINE__);
	return quest_updates;
}

PacketStruct* Player::GetQuestJournalPacket(bool all_quests, int16 version, int32 crc, int32 current_quest_id, bool updated){
	PacketStruct* packet = configReader.getStruct("WS_QuestJournalUpdate", version);
	Quest* quest = 0;
	if(packet){
		int16 total_quests_num = 0;
		int16 total_completed_quests = 0;
		map<int32, Quest*> total_quests = player_quests;
		if(all_quests && completed_quests.size() > 0)
			total_quests.insert(completed_quests.begin(), completed_quests.end());
		MPlayerQuests.readlock(__FUNCTION__, __LINE__);
		if(total_quests.size() > 0){
			map<string, int16> quest_types;
			map<int32, Quest*>::iterator itr;
			int16 zone_id = 0;
			for(itr = total_quests.begin(); itr != total_quests.end(); itr++){
				if(itr->first && itr->second){
					if(current_quest_id == 0 && itr->second->GetTurnedIn() == false)
						current_quest_id = itr->first;
					if(itr->second->GetTurnedIn())
						total_completed_quests++;
					if(itr->second->GetType()){
						if(quest_types.count(itr->second->GetType()) == 0){
							quest_types[itr->second->GetType()] = zone_id;
							zone_id++;
						}
					}
					if(itr->second->GetZone()){
						if(quest_types.count(itr->second->GetType()) == 0){
							quest_types[itr->second->GetType()] = zone_id;
							zone_id++;
						}
					}
					total_quests_num++;
				}
				else
					continue;
			}
			packet->setArrayLengthByName("num_quests", total_quests_num);
			int16 i = 0;
			for(itr = total_quests.begin(); itr != total_quests.end(); itr++){
				if(i == 0 && quest_types.size() > 0){
					packet->setArrayLengthByName("num_quest_zones", quest_types.size());
					map<string, int16>::iterator type_itr;
					int16 x = 0;
					for(type_itr = quest_types.begin(); type_itr != quest_types.end(); type_itr++){
						packet->setArrayDataByName("quest_zones_zone", type_itr->first.c_str(), x);
						packet->setArrayDataByName("quest_zones_zone_id", type_itr->second, x);
						x++;
					}
				}
				if(itr->first == 0 || !itr->second)
					continue;
				if(!all_quests && !itr->second->GetUpdateRequired())
					continue;
				quest = itr->second;
				if(!quest->GetDeleted())
					packet->setArrayDataByName("active", 1, i);
				packet->setArrayDataByName("name", quest->GetName(), i);
				packet->setArrayDataByName("quest_type", quest->GetType(), i);
				packet->setArrayDataByName("quest_zone", quest->GetZone(), i);
				int8 display_status = QUEST_DISPLAY_STATUS_NORMAL;
				if(itr->second->GetCompleted())
					packet->setArrayDataByName("completed", 1, i);
				if(itr->second->GetTurnedIn()){
					packet->setArrayDataByName("turned_in", 1, i);
					packet->setArrayDataByName("completed", 1, i);
					packet->setArrayDataByName("visible", 1, i);
					packet->setArrayDataByName("unknown3", 1, i);
					display_status += QUEST_DISPLAY_STATUS_COMPLETED;					
				}
				if (updated) {
					packet->setArrayDataByName("quest_updated", 1, i);
					packet->setArrayDataByName("journal_updated", 1, i);
				}
				packet->setArrayDataByName("quest_id", quest->GetQuestID(), i);
				packet->setArrayDataByName("day", quest->GetDay(), i);
				packet->setArrayDataByName("month", quest->GetMonth(), i);
				packet->setArrayDataByName("year", quest->GetYear(), i);
				packet->setArrayDataByName("level", quest->GetQuestLevel(), i);
				int8 difficulty = 0;
				string category = quest->GetType();
				if(category == "Tradeskill")
					difficulty = GetTSArrowColor(quest->GetQuestLevel());
				else
					difficulty = GetArrowColor(quest->GetQuestLevel());
				packet->setArrayDataByName("difficulty", difficulty, i);
				if (itr->second->GetEncounterLevel() > 4)
					packet->setArrayDataByName("encounter_level", quest->GetEncounterLevel(), i);
				else
					packet->setArrayDataByName("encounter_level", 4, i);
				if(version >= 931 && quest_types.count(quest->GetType()) > 0)
					packet->setArrayDataByName("zonetype_id", quest_types[quest->GetType()], i);
				if(version >= 931 && quest_types.count(quest->GetZone()) > 0)
					packet->setArrayDataByName("zone_id", quest_types[quest->GetZone()], i);
				if(version >= 931 && quest->GetVisible()){
					if (quest->GetCompletedFlag())
						display_status += QUEST_DISPLAY_STATUS_COMPLETE_FLAG;
					else if (quest->IsRepeatable())
						display_status += QUEST_DISPLAY_STATUS_REPEATABLE;
					if (quest->GetYellowName() || quest->CheckCategoryYellow())
						display_status += QUEST_DISPLAY_STATUS_YELLOW;
					
					if (quest->IsTracked())
						display_status += QUEST_DISPLAY_STATUS_CHECK;
					else
						display_status += QUEST_DISPLAY_STATUS_NO_CHECK;

					if (quest->IsHidden() && !quest->GetTurnedIn())
						display_status = QUEST_DISPLAY_STATUS_HIDDEN;
				}
				else
					packet->setArrayDataByName("visible", quest->GetVisible(), i);
				if (itr->second->IsRepeatable())
					packet->setArrayDataByName("repeatable", 1, i);
				
				packet->setArrayDataByName("display_status", display_status, i);
				i++;
			}
			//packet->setDataByName("unknown4", 0);
			packet->setDataByName("visible_quest_id", current_quest_id);
		}
		MPlayerQuests.releasereadlock(__FUNCTION__, __LINE__);		
		packet->setDataByName("player_crc", crc);
		packet->setDataByName("player_name", GetName());
		packet->setDataByName("used_quests", total_quests_num - total_completed_quests);
		packet->setDataByName("max_quests", 75);

		LogWrite(PLAYER__PACKET, 0, "Player", "Dump/Print Packet in func: %s, line: %i", __FUNCTION__, __LINE__);
#if EQDEBUG >= 9
		packet->PrintPacket();
#endif

	}
	return packet;
}

PacketStruct* Player::GetQuestJournalPacket(Quest* quest, int16 version, int32 crc, bool updated) {
	if (!quest)
		return 0;

	PacketStruct* packet = configReader.getStruct("WS_QuestJournalUpdate", version);
	if (packet) {

		packet->setArrayLengthByName("num_quests", 1);
		packet->setArrayLengthByName("num_quest_zones", 1);
		packet->setArrayDataByName("quest_zones_zone", quest->GetType());
		packet->setArrayDataByName("quest_zones_zone_id", 0);
		
		if(!quest->GetDeleted() && !quest->GetCompleted())
			packet->setArrayDataByName("active", 1);

		packet->setArrayDataByName("name", quest->GetName());
		// don't see these two in the struct
		packet->setArrayDataByName("quest_type", quest->GetType());
		packet->setArrayDataByName("quest_zone", quest->GetZone());

		int8 display_status = QUEST_DISPLAY_STATUS_NORMAL;
		if(quest->GetCompleted())
			packet->setArrayDataByName("completed", 1);
		if(quest->GetTurnedIn()) {
			packet->setArrayDataByName("turned_in", 1);
			packet->setArrayDataByName("completed", 1);
			packet->setArrayDataByName("visible", 1);	
			display_status += QUEST_DISPLAY_STATUS_COMPLETED;
		}		
		packet->setArrayDataByName("quest_id", quest->GetQuestID());
		packet->setArrayDataByName("day", quest->GetDay());
		packet->setArrayDataByName("month", quest->GetMonth());
		packet->setArrayDataByName("year", quest->GetYear());
		packet->setArrayDataByName("level", quest->GetQuestLevel());
		int8 difficulty = 0;
		string category = quest->GetType();
		if(category == "Tradeskill")
			difficulty = GetTSArrowColor(quest->GetQuestLevel());
		else
			difficulty = GetArrowColor(quest->GetQuestLevel());

		packet->setArrayDataByName("difficulty", difficulty);
		if (quest->GetEncounterLevel() > 4)
			packet->setArrayDataByName("encounter_level", quest->GetEncounterLevel());
		else
			packet->setArrayDataByName("encounter_level", 4);

		if (version >= 931) {
			packet->setArrayDataByName("zonetype_id", 0);
			packet->setArrayDataByName("zone_id", 0);
		}
		if(version >= 931 && quest->GetVisible()){
			if (quest->GetCompletedFlag())
				display_status += QUEST_DISPLAY_STATUS_COMPLETE_FLAG;
			else if (quest->IsRepeatable())
				display_status += QUEST_DISPLAY_STATUS_REPEATABLE;
			if (quest->GetYellowName() || quest->CheckCategoryYellow())
				display_status += QUEST_DISPLAY_STATUS_YELLOW;

			if (quest->IsTracked())
				display_status += QUEST_DISPLAY_STATUS_CHECK;
			else
				display_status += QUEST_DISPLAY_STATUS_NO_CHECK;

			if (quest->IsHidden() && !quest->GetTurnedIn())
				display_status = QUEST_DISPLAY_STATUS_HIDDEN;
		}
		else
			packet->setArrayDataByName("visible", quest->GetVisible());
		if (quest->IsRepeatable())
			packet->setArrayDataByName("repeatable", 1);

		packet->setArrayDataByName("display_status", display_status);
		if (updated) {
			packet->setArrayDataByName("quest_updated", 1);
			packet->setArrayDataByName("journal_updated", 1);
		}		
		if(version >= 546)
			packet->setDataByName("unknown3", 1);
		packet->setDataByName("visible_quest_id", quest->GetQuestID());
		packet->setDataByName("player_crc", crc);
		packet->setDataByName("player_name", GetName());
		packet->setDataByName("used_quests", player_quests.size());
		packet->setDataByName("unknown4a", 1);
		packet->setDataByName("max_quests", 75);
	}

	return packet;
}

Quest* Player::SetStepComplete(int32 id, int32 step){
	Quest* ret = 0;
	MPlayerQuests.readlock(__FUNCTION__, __LINE__);
	if(player_quests.count(id) > 0){
		if(player_quests[id]->SetStepComplete(step))
			ret = player_quests[id];
	}
	MPlayerQuests.releasereadlock(__FUNCTION__, __LINE__);
	return ret;
}

Quest* Player::AddStepProgress(int32 quest_id, int32 step, int32 progress) {
	Quest* ret = 0;
	MPlayerQuests.readlock(__FUNCTION__, __LINE__);
	if (player_quests.count(quest_id) > 0) {
		if (player_quests[quest_id]->AddStepProgress(step, progress))
			ret = player_quests[quest_id];
	}
	MPlayerQuests.releasereadlock(__FUNCTION__, __LINE__);
	return ret;
}

int32 Player::GetStepProgress(int32 quest_id, int32 step_id) {
	int32 ret = 0;

	MPlayerQuests.readlock(__FUNCTION__, __LINE__);
	if (player_quests.count(quest_id) > 0)
		ret = player_quests[quest_id]->GetStepProgress(step_id);
	MPlayerQuests.releasereadlock(__FUNCTION__, __LINE__);

	return ret;
}

void Player::RemoveQuest(int32 id, bool delete_quest){
	MPlayerQuests.writelock(__FUNCTION__, __LINE__);
	if(delete_quest){
		safe_delete(player_quests[id]);
	}
	map<int32, Quest*>::iterator itr = player_quests.find(id);
	if(itr != player_quests.end()) {
		player_quests.erase(itr);
	}
	MPlayerQuests.releasewritelock(__FUNCTION__, __LINE__);
	SendQuestRequiredSpawns(id);
}

vector<Quest*>* Player::CheckQuestsLocationUpdate(){
	vector<Quest*>* quest_updates = 0;
	map<int32, Quest*>::iterator itr;
	MPlayerQuests.readlock(__FUNCTION__, __LINE__);
	for(itr = player_quests.begin(); itr != player_quests.end(); itr++){
		if(itr->second && itr->second->CheckQuestLocationUpdate(GetX(), GetY(), GetZ(), (GetZone() ? GetZone()->GetZoneID() : 0))){
			if(!quest_updates)
				quest_updates = new vector<Quest*>();
			quest_updates->push_back(itr->second);
		}
	}
	MPlayerQuests.releasereadlock(__FUNCTION__, __LINE__);
	return quest_updates;
}

vector<Quest*>* Player::CheckQuestsFailures(){
	vector<Quest*>* quest_failures = 0;
	map<int32, Quest*>::iterator itr;
	MPlayerQuests.readlock(__FUNCTION__, __LINE__);
	for(itr = player_quests.begin(); itr != player_quests.end(); itr++){
		if(itr->second && itr->second->GetQuestFailures()->size() > 0){
			if(!quest_failures)
				quest_failures = new vector<Quest*>();
			quest_failures->push_back(itr->second);
		}
	}
	MPlayerQuests.releasereadlock(__FUNCTION__, __LINE__);
	return quest_failures;
}

vector<Quest*>* Player::CheckQuestsKillUpdate(Spawn* spawn, bool update){
	vector<Quest*>* quest_updates = 0;
	map<int32, Quest*>::iterator itr;
	MPlayerQuests.readlock(__FUNCTION__, __LINE__);
	for(itr = player_quests.begin(); itr != player_quests.end(); itr++){
		if(itr->second && itr->second->CheckQuestKillUpdate(spawn, update)){
			if(!quest_updates)
				quest_updates = new vector<Quest*>();
			quest_updates->push_back(itr->second);
		}
	}
	MPlayerQuests.releasereadlock(__FUNCTION__, __LINE__);
	return quest_updates;
}

bool Player::HasQuestUpdateRequirement(Spawn* spawn){
	bool reqMet = false;
	map<int32, Quest*>::iterator itr;
	MPlayerQuests.readlock(__FUNCTION__, __LINE__);
	for(itr = player_quests.begin(); itr != player_quests.end(); itr++){
		if(itr->second && itr->second->CheckQuestReferencedSpawns(spawn)){
			reqMet = true;
			break;
		}
	}
	MPlayerQuests.releasereadlock(__FUNCTION__, __LINE__);
	return reqMet;
}

vector<Quest*>* Player::CheckQuestsChatUpdate(Spawn* spawn){
	vector<Quest*>* quest_updates = 0;
	map<int32, Quest*>::iterator itr;
	MPlayerQuests.readlock(__FUNCTION__, __LINE__);
	for(itr = player_quests.begin(); itr != player_quests.end(); itr++){
		if(itr->second && itr->second->CheckQuestChatUpdate(spawn->GetDatabaseID())){
			if(!quest_updates)
				quest_updates = new vector<Quest*>();
			quest_updates->push_back(itr->second);
		}
	}
	MPlayerQuests.releasereadlock(__FUNCTION__, __LINE__);
	return quest_updates;
}

int16 Player::GetTaskGroupStep(int32 quest_id){
	Quest* quest = 0;
	int16 step = 0;
	MPlayerQuests.readlock(__FUNCTION__, __LINE__);
	if(player_quests.count(quest_id) > 0){
		quest = player_quests[quest_id];
		if(quest) {
			step = quest->GetTaskGroupStep();
		}
	}
	MPlayerQuests.releasereadlock(__FUNCTION__, __LINE__);
	return step;
}

bool Player::GetQuestStepComplete(int32 quest_id, int32 step_id){
	bool ret = false;
	MPlayerQuests.readlock(__FUNCTION__, __LINE__);
	if(player_quests.count(quest_id) > 0){
		Quest* quest = player_quests[quest_id];
		if ( quest != NULL )
			ret = quest->GetQuestStepCompleted(step_id);
	}
	MPlayerQuests.releasereadlock(__FUNCTION__, __LINE__);
	return ret;
}

int16 Player::GetQuestStep(int32 quest_id){
	Quest* quest = 0;
	int16 step = 0;
	MPlayerQuests.readlock(__FUNCTION__, __LINE__);
	if(player_quests.count(quest_id) > 0){
		quest = player_quests[quest_id];
		if(quest) {
			step = quest->GetQuestStep();
		}
	}
	MPlayerQuests.releasereadlock(__FUNCTION__, __LINE__);
	return step;
}

map<int32, Quest*>*	Player::GetPlayerQuests(){
	return &player_quests;
}

map<int32, Quest*>*	Player::GetCompletedPlayerQuests(){
	return &completed_quests;
}

Quest* Player::GetAnyQuest(int32 quest_id) {
	if(player_quests.count(quest_id) > 0)
		return player_quests[quest_id];
	if(completed_quests.count(quest_id) > 0)
		return completed_quests[quest_id];
	
	return 0;
}
Quest* Player::GetCompletedQuest(int32 quest_id){
	if(completed_quests.count(quest_id) > 0)
		return completed_quests[quest_id];
	return 0;
}

Quest* Player::GetQuest(int32 quest_id){
	if(player_quests.count(quest_id) > 0)
		return player_quests[quest_id];
	return 0;
}

void Player::AddCompletedQuest(Quest* quest){
	completed_quests[quest->GetQuestID()] = quest;
	quest->SetSaveNeeded(true);
	quest->SetTurnedIn(true);
	if(quest->GetCompletedDescription())
		quest->SetDescription(string(quest->GetCompletedDescription()));
	quest->SetUpdateRequired(true);
}

bool Player::CheckQuestRemoveFlag(Spawn* spawn){
	if(current_quest_flagged.count(spawn) > 0){
		current_quest_flagged.erase(spawn);
		return true;
	}
	return false;
}

bool Player::CheckQuestRequired(Spawn* spawn){
	if(spawn)
		return spawn->MeetsSpawnAccessRequirements(this);
	return false;
}

int8 Player::CheckQuestFlag(Spawn* spawn){
	int8 ret = 0;

	if (!spawn) {
		LogWrite(PLAYER__ERROR, 0, "Player", "CheckQuestFlag() called with an invalid spawn");
		return ret;
	}
	if(spawn->HasProvidedQuests()){
		vector<int32>* quests = spawn->GetProvidedQuests();
		Quest* quest = 0;
		for(int32 i=0;i<quests->size();i++){
			MPlayerQuests.readlock(__FUNCTION__, __LINE__);
			if(player_quests.count(quests->at(i)) > 0){
				if(player_quests[quests->at(i)]->GetCompleted() && player_quests[quests->at(i)]->GetQuestReturnNPC() == spawn->GetDatabaseID()){
					ret = 2;
					MPlayerQuests.releasereadlock(__FUNCTION__, __LINE__);
					break;
				}
			}
			MPlayerQuests.releasereadlock(__FUNCTION__, __LINE__);
			int8 flag = 0;
			if (CanReceiveQuest(quests->at(i), &flag)){
				if(flag) {
					ret = flag;
					break;
				}
				master_quest_list.LockQuests();
				quest = master_quest_list.GetQuest(quests->at(i), false);
				master_quest_list.UnlockQuests();
				if(quest){
					int8 color = quest->GetFeatherColor();
					// purple
					if (color == 1)
						ret = 16;
					// green
					else if (color == 2)
						ret = 32;
					// blue
					else if (color == 3)
						ret = 64;
					// normal
					else
						ret = 1;
					break;
				}
			}
		}
	}
	map<int32, Quest*>::iterator itr;
	MPlayerQuests.readlock(__FUNCTION__, __LINE__);
	for(itr = player_quests.begin(); itr != player_quests.end(); itr++){
		if(itr->second->CheckQuestChatUpdate(spawn->GetDatabaseID(), false))
			ret = 2;
	}
	MPlayerQuests.releasereadlock(__FUNCTION__, __LINE__);
	if(ret > 0)
		current_quest_flagged[spawn] = true;
	return ret;
}

bool Player::CanReceiveQuest(int32 quest_id, int8* ret){
	bool passed = true;
	int32 x;
	master_quest_list.LockQuests();
	Quest* quest = master_quest_list.GetQuest(quest_id, false);
	master_quest_list.UnlockQuests();
	if (!quest)
		passed = false;
	//check if quest is already completed, and not repeatable
	else if (GetCompletedQuest(quest_id) && !quest->IsRepeatable())
		passed = false;
	//check if the player already has this quest
	else if (player_quests.count(quest_id) > 0)
		passed = false;
	//Check Prereq Adv Levels
	else if (quest->GetPrereqLevel() > GetLevel())
		passed = false;
	else if (quest->GetPrereqMaxLevel() > 0){
		if (GetLevel() > quest->GetPrereqMaxLevel())
			passed = false;
	}
	//Check Prereq TS Levels
	else if (quest->GetPrereqTSLevel() > GetTSLevel())
		passed = false;
	else if (quest->GetPrereqMaxTSLevel() > 0){
		if (GetTSLevel() > quest->GetPrereqMaxLevel())
			passed = false;
	}


	// Check quest pre req
	vector<int32>* prereq_quests = quest->GetPrereqQuests();
	if(passed && prereq_quests && prereq_quests->size() > 0){
		for(int32 x=0;x<prereq_quests->size();x++){
			if(completed_quests.count(prereq_quests->at(x)) == 0){
				passed = false;
				break;
			}
		}
	}

	//Check Prereq Classes
	vector<int8>* prereq_classes = quest->GetPrereqClasses();
	if(passed && prereq_classes && prereq_classes->size() > 0){
		for(int32 x=0;x<prereq_classes->size();x++){
			if(prereq_classes->at(x) == GetAdventureClass()){
				passed = true;
				break;
			}
			else
				passed = false;
		}
	}

	//Check Prereq TS Classes
	vector<int8>* prereq_tsclasses = quest->GetPrereqTradeskillClasses();
	if(passed && prereq_tsclasses && prereq_tsclasses->size() > 0){
		for( x=0;x<prereq_tsclasses->size();x++){
			if(prereq_tsclasses->at(x) == GetTradeskillClass()){
				passed = true;
				break;
			}
			else
				passed = false;
		}
	}


	// Check model prereq
	vector<int16>* prereq_model_types = quest->GetPrereqModelTypes();
	if(passed && prereq_model_types && prereq_model_types->size() > 0){
		for(x=0;x<prereq_model_types->size();x++){
			if(prereq_model_types->at(x) == GetModelType()){
				passed = true;
				break;
			}
			else
				passed = false;
		}
	}


	// Check faction pre req
	vector<QuestFactionPrereq>* prereq_factions = quest->GetPrereqFactions();
	if(passed && prereq_factions && prereq_factions->size() > 0){
		sint32 val = 0;
		for(x=0;x<prereq_factions->size();x++){
			val = GetFactions()->GetFactionValue(prereq_factions->at(x).faction_id);
			if(val >= prereq_factions->at(x).min && (prereq_factions->at(x).max == 0 || val <= prereq_factions->at(x).max)){
				passed = true;
				break;
			}
			else
				passed = false;
		}
	}

	LogWrite(MISC__TODO, 1, "TODO", "Check prereq items\n\t(%s, function: %s, line #: %i)", __FILE__, __FUNCTION__, __LINE__);

	// Check race pre req
	vector<int8>* prereq_races = quest->GetPrereqRaces();
	if(passed && prereq_races && prereq_races->size() > 0){
		for(x=0;x<prereq_races->size();x++){
			if(prereq_races->at(x) == GetRace()){
				passed = true;
				break;
			}
			else
				passed = false;
		}
	}
	
	int32 flag = 0;
	if(lua_interface->CallQuestFunction(quest, "ReceiveQuestCriteria", this, 0xFFFFFFFF, &flag)) {
		if(ret)
			*ret = flag;
		if(!flag) {
			passed = false;
		}
		else {
			passed = true;
		}
	}

	return passed;
}

bool Player::ShouldSendSpawn(Spawn* spawn){
	if(spawn->IsDeletedSpawn() || IsSendingSpawn(spawn->GetID()) || IsRemovingSpawn(spawn->GetID()))
		return false;
	else if((WasSentSpawn(spawn->GetID()) == false) && (!spawn->IsPrivateSpawn() || spawn->AllowedAccess(this)))
		return true;
	
	return false;
}

int8 Player::GetArrowColor(int8 spawn_level){
	int8 color = 0;
	sint16 diff = spawn_level - GetLevel();
	if(GetLevel() < 10)
		diff *= 3;
	else if(GetLevel() <= 20)
		diff *= 2;
	if(diff >= 9)
		color = ARROW_COLOR_RED;
	else if(diff >= 5)
		color = ARROW_COLOR_ORANGE;
	else if(diff >= 1)
		color = ARROW_COLOR_YELLOW;
	else if(diff == 0)
		color = ARROW_COLOR_WHITE;	
	else if(diff <= -11)
		color = ARROW_COLOR_GRAY;
	else if(diff <= -6)
		color = ARROW_COLOR_GREEN;
	else //if(diff < 0)
		color = ARROW_COLOR_BLUE;
	return color;
}

int8 Player::GetTSArrowColor(int8 level){
	int8 color = 0;
	sint16 diff = level - GetTSLevel();
	if(GetLevel() < 10)
		diff *= 3;
	else if(GetLevel() <= 20)
		diff *= 2;
	if(diff >= 9)
		color = ARROW_COLOR_RED;
	else if(diff >= 5)
		color = ARROW_COLOR_ORANGE;
	else if(diff >= 1)
		color = ARROW_COLOR_YELLOW;
	else if(diff == 0)
		color = ARROW_COLOR_WHITE;	
	else if(diff <= -11)
		color = ARROW_COLOR_GRAY;
	else if(diff <= -6)
		color = ARROW_COLOR_GREEN;
	else //if(diff < 0)
		color = ARROW_COLOR_BLUE;
	return color;
}

void Player::AddCoins(int64 val){
	int32 tmp = 0;
	UpdatePlayerStatistic(STAT_PLAYER_TOTAL_WEALTH, (GetCoinsCopper() + (GetCoinsSilver() * 100) + (GetCoinsGold() * 10000) + (GetCoinsPlat() * 1000000)) + val, true);
	if(val >= 1000000){
		tmp = val / 1000000;
		val -= tmp*1000000;
		GetInfoStruct()->add_coin_plat(tmp);
	}
	if(val >= 10000){
		tmp = val / 10000;
		val -= tmp*10000;
		GetInfoStruct()->add_coin_gold(tmp);
	}
	if(val >= 100){
		tmp = val / 100;
		val -= tmp*100;
		GetInfoStruct()->add_coin_silver(tmp);
	}
	GetInfoStruct()->add_coin_copper(val);
	int32 new_copper_value = GetInfoStruct()->get_coin_copper();
	if(new_copper_value >= 100){
		tmp = new_copper_value/100;
		GetInfoStruct()->set_coin_copper(new_copper_value - (100 * tmp));
		GetInfoStruct()->add_coin_silver(tmp);
	}
	int32 new_silver_value = GetInfoStruct()->get_coin_silver();
	if(new_silver_value >= 100){
		tmp = new_silver_value/100;
		GetInfoStruct()->set_coin_silver(new_silver_value - (100 * tmp));
		GetInfoStruct()->add_coin_gold(tmp);
	}
	int32 new_gold_value = GetInfoStruct()->get_coin_gold();
	if(new_gold_value >= 100){
		tmp = new_gold_value/100;
		GetInfoStruct()->set_coin_gold(new_gold_value - (100 * tmp));
		GetInfoStruct()->add_coin_plat(tmp);
	}
	charsheet_changed = true;
}

bool Player::RemoveCoins(int64 val){
	int64 total_coins = GetInfoStruct()->get_coin_plat()*1000000;
	total_coins += GetInfoStruct()->get_coin_gold()*10000;
	total_coins += GetInfoStruct()->get_coin_silver()*100;
	total_coins += GetInfoStruct()->get_coin_copper();
	if(total_coins >= val){
		total_coins -= val;
		GetInfoStruct()->set_coin_plat(0);
		GetInfoStruct()->set_coin_gold(0);
		GetInfoStruct()->set_coin_silver(0);
		GetInfoStruct()->set_coin_copper(0);
		AddCoins(total_coins);
		return true;
	}
	return false;
}

bool Player::HasCoins(int64 val) {
	int64 total_coins = GetInfoStruct()->get_coin_plat()*1000000;
	total_coins += GetInfoStruct()->get_coin_gold()*10000;
	total_coins += GetInfoStruct()->get_coin_silver()*100;
	total_coins += GetInfoStruct()->get_coin_copper();
	if(total_coins >= val)
		return true;

	return false;
}

bool Player::HasPendingLootItems(int32 id){
	return (pending_loot_items.count(id) > 0 && pending_loot_items[id].size() > 0);
}

bool Player::HasPendingLootItem(int32 id, int32 item_id){
	return (pending_loot_items.count(id) > 0 && pending_loot_items[id].count(item_id) > 0);
}
vector<Item*>* Player::GetPendingLootItems(int32 id){
	vector<Item*>* ret = 0;
	if(pending_loot_items.count(id) > 0){
		ret = new vector<Item*>();
		map<int32, bool>::iterator itr;
		for(itr = pending_loot_items[id].begin(); itr != pending_loot_items[id].end(); itr++){
			if(master_item_list.GetItem(itr->first))
				ret->push_back(master_item_list.GetItem(itr->first));
		}
	}
	return ret;
}

void Player::RemovePendingLootItem(int32 id, int32 item_id){
	if(pending_loot_items.count(id) > 0){
		pending_loot_items[id].erase(item_id);
		if(pending_loot_items[id].size() == 0)
			pending_loot_items.erase(id);
	}
}

void Player::RemovePendingLootItems(int32 id){
	if(pending_loot_items.count(id) > 0)
		pending_loot_items.erase(id);
}

void Player::AddPendingLootItems(int32 id, vector<Item*>* items){
	if(items){
		Item* item = 0;
		for(int32 i=0;i<items->size();i++){
			item = items->at(i);
			if(item)
				pending_loot_items[id][item->details.item_id] = true;
		}
	}
}

void Player::AddPlayerStatistic(int32 stat_id, sint32 stat_value, int32 stat_date) {
	if (statistics.count(stat_id) == 0) {
		Statistic* stat = new Statistic;
		stat->stat_id = stat_id;
		stat->stat_value = stat_value;
		stat->stat_date = stat_date;
		stat->save_needed = false;
		statistics[stat_id] = stat;
	}
}

void Player::UpdatePlayerStatistic(int32 stat_id, sint32 stat_value, bool overwrite) {
	if (statistics.count(stat_id) == 0)
		AddPlayerStatistic(stat_id, 0, 0);
	Statistic* stat = statistics[stat_id];
	overwrite == true ? stat->stat_value = stat_value : stat->stat_value += stat_value;
	stat->stat_date = Timer::GetUnixTimeStamp();
	stat->save_needed = true;
}

void Player::WritePlayerStatistics() {
	map<int32, Statistic*>::iterator stat_itr;
	for (stat_itr = statistics.begin(); stat_itr != statistics.end(); stat_itr++) {
		Statistic* stat = stat_itr->second;
		if (stat->save_needed) {
			stat->save_needed = false;
			database.WritePlayerStatistic(this, stat);
		}
	}
}

sint64 Player::GetPlayerStatisticValue(int32 stat_id) {
	if (stat_id >= 0 && statistics.count(stat_id) > 0)
		return statistics[stat_id]->stat_value;
	return 0;
}

void Player::RemovePlayerStatistics() {
	map<int32, Statistic*>::iterator stat_itr;
	for (stat_itr = statistics.begin(); stat_itr != statistics.end(); stat_itr++)
		safe_delete(stat_itr->second);
	statistics.clear();
}

void Player::SetGroup(PlayerGroup* new_group){
	group = new_group;
}

/*PlayerGroup* Player::GetGroup(){
	return group;
}*/

bool Player::IsGroupMember(Entity* player) {
	bool ret = false;
	if (GetGroupMemberInfo() && player) {
		//world.GetGroupManager()->GroupLock(__FUNCTION__, __LINE__);
		ret = world.GetGroupManager()->IsInGroup(GetGroupMemberInfo()->group_id, player);

		/*deque<GroupMemberInfo*>::iterator itr;
		deque<GroupMemberInfo*>* members = world.GetGroupManager()->GetGroupMembers(GetGroupMemberInfo()->group_id);
		for (itr = members->begin(); itr != members->end(); itr++) {
			GroupMemberInfo* gmi = *itr;
			if (gmi->client && gmi->client->GetPlayer() == player) {
				ret = true;
				break;
			}
		}

		world.GetGroupManager()->ReleaseGroupLock(__FUNCTION__, __LINE__);*/
	}
	return ret;
}





void Player::SetGroupInformation(PacketStruct* packet){
	int8 det_count = 0;
	Entity* member = 0;

	world.GetGroupManager()->GroupLock(__FUNCTION__, __LINE__);
	if (GetGroupMemberInfo()) {
		PlayerGroup* group = world.GetGroupManager()->GetGroup(GetGroupMemberInfo()->group_id);
		if (group)
		{
			group->MGroupMembers.readlock(__FUNCTION__, __LINE__);
			deque<GroupMemberInfo*>* members = group->GetMembers();
			deque<GroupMemberInfo*>::iterator itr;
			GroupMemberInfo* info = 0;
			int x = 0;

			for (itr = members->begin(); itr != members->end(); itr++) {
				info = *itr;

				if (info == GetGroupMemberInfo()) {
					if (info->leader)
						packet->setDataByName("group_leader_id", 0xFFFFFFFF);	// If this player is the group leader then fill this element with FF FF FF FF

					continue;
				}
				else {
					if (info->leader)
						packet->setDataByName("group_leader_id", x);			// If leader is some one else then fill with the slot number they are in
				}

				member = info->member;

				if (member && member->GetZone() == GetZone()) {
					packet->setSubstructDataByName("group_members", "unknown3", 1, x);
					packet->setSubstructDataByName("group_members", "spawn_id", GetIDWithPlayerSpawn(member), x);

					if (member->HasPet()) {
						if (member->GetPet())
							packet->setSubstructDataByName("group_members", "pet_id", GetIDWithPlayerSpawn(member->GetPet()), x);
						else
							packet->setSubstructDataByName("group_members", "pet_id", GetIDWithPlayerSpawn(member->GetCharmedPet()), x);
					}
					else
						packet->setSubstructDataByName("group_members", "pet_id", 0xFFFFFFFF, x);

					//Send detriment counts as 255 if all dets of that type are incurable
					det_count = member->GetTraumaCount();
					if (det_count > 0) {
						if (!member->HasCurableDetrimentType(DET_TYPE_TRAUMA))
							det_count = 255;
					}
					packet->setSubstructDataByName("group_members", "trauma_count", det_count, x);

					det_count = member->GetArcaneCount();
					if (det_count > 0) {
						if (!member->HasCurableDetrimentType(DET_TYPE_ARCANE))
							det_count = 255;
					}
					packet->setSubstructDataByName("group_members", "arcane_count", det_count, x);

					det_count = member->GetNoxiousCount();
					if (det_count > 0) {
						if (!member->HasCurableDetrimentType(DET_TYPE_NOXIOUS))
							det_count = 255;
					}
					packet->setSubstructDataByName("group_members", "noxious_count", det_count, x);

					det_count = member->GetElementalCount();
					if (det_count > 0) {
						if (!member->HasCurableDetrimentType(DET_TYPE_ELEMENTAL))
							det_count = 255;
					}
					packet->setSubstructDataByName("group_members", "elemental_count", det_count, x);

					det_count = member->GetCurseCount();
					if (det_count > 0) {
						if (!member->HasCurableDetrimentType(DET_TYPE_CURSE))
							det_count = 255;
					}
					packet->setSubstructDataByName("group_members", "curse_count", det_count, x);
				}
				else {
					packet->setSubstructDataByName("group_members", "unknown3", 2, x);
					packet->setSubstructDataByName("group_members", "pet_id", 0xFFFFFFFF, x);
					//packet->setSubstructDataByName("group_members", "unknown5", 1, x, 1); // unknown5 > 1 = name is blue
				}

				packet->setSubstructDataByName("group_members", "name", info->name.c_str(), x);
				packet->setSubstructDataByName("group_members", "hp_current", info->hp_current, x);
				packet->setSubstructDataByName("group_members", "hp_max", info->hp_max, x);
				packet->setSubstructDataByName("group_members", "power_current", info->power_current, x);
				packet->setSubstructDataByName("group_members", "power_max", info->power_max, x);
				packet->setSubstructDataByName("group_members", "level_current", info->level_current, x);
				packet->setSubstructDataByName("group_members", "level_max", info->level_max, x);
				packet->setSubstructDataByName("group_members", "zone", info->zone.c_str(), x);
				packet->setSubstructDataByName("group_members", "race_id", info->race_id, x);
				packet->setSubstructDataByName("group_members", "class_id", info->class_id, x);

				x++;
			}
		}
		group->MGroupMembers.releasereadlock(__FUNCTION__, __LINE__);
	}
	//packet->PrintPacket();
	world.GetGroupManager()->ReleaseGroupLock(__FUNCTION__, __LINE__);
}

PlayerItemList*	Player::GetPlayerItemList(){
	return &item_list;
}

void Player::ResetSavedSpawns(){
	spawn_mutex.writelock(__FUNCTION__, __LINE__);
	ClearRemovalTimers();
	spawn_packet_sent.clear();
	spawn_mutex.releasewritelock(__FUNCTION__, __LINE__);

	info_mutex.writelock(__FUNCTION__, __LINE__);
	spawn_info_packet_list.clear();
	info_mutex.releasewritelock(__FUNCTION__, __LINE__);

	vis_mutex.writelock(__FUNCTION__, __LINE__);
	spawn_vis_packet_list.clear();
	vis_mutex.releasewritelock(__FUNCTION__, __LINE__);

	pos_mutex.writelock(__FUNCTION__, __LINE__);
	spawn_pos_packet_list.clear();
	pos_mutex.releasewritelock(__FUNCTION__, __LINE__);

	index_mutex.writelock(__FUNCTION__, __LINE__);
	player_spawn_reverse_id_map.clear();
	player_spawn_id_map.clear();
	player_spawn_id_map[1] = this;
	player_spawn_reverse_id_map[this] = 1;
	spawn_index = 1;
	index_mutex.releasewritelock(__FUNCTION__, __LINE__);

	m_playerSpawnQuestsRequired.writelock(__FUNCTION__, __LINE__);
	player_spawn_quests_required.clear();
	m_playerSpawnQuestsRequired.releasewritelock(__FUNCTION__, __LINE__);
	if(info)
		info->RemoveOldPackets();
	
	safe_delete_array(movement_packet);
	safe_delete_array(old_movement_packet);
}

void Player::SetReturningFromLD(bool val){
	if(val && val != returning_from_ld)
	{
		if(GetPlayerItemList())
			GetPlayerItemList()->ResetPackets();
		
		GetEquipmentList()->ResetPackets();
		GetAppearanceEquipmentList()->ResetPackets();
		skill_list.ResetPackets();
		safe_delete_array(spell_orig_packet);
		safe_delete_array(spell_xor_packet);
		spell_orig_packet=0;
		spell_xor_packet=0;
		spell_count = 0;

		reset_character_flag(CF_IS_SITTING);
		if (GetActivityStatus() & ACTIVITY_STATUS_CAMPING)
			SetActivityStatus(GetActivityStatus() - ACTIVITY_STATUS_CAMPING);

		if (GetActivityStatus() & ACTIVITY_STATUS_LINKDEAD)
			SetActivityStatus(GetActivityStatus() - ACTIVITY_STATUS_LINKDEAD);
		
		SetTempVisualState(0);

		safe_delete_array(spawn_tmp_info_xor_packet);
		safe_delete_array(spawn_tmp_vis_xor_packet);
		safe_delete_array(spawn_tmp_pos_xor_packet);
		spawn_tmp_info_xor_packet = 0;
		spawn_tmp_vis_xor_packet = 0;
		spawn_tmp_pos_xor_packet = 0;
		pos_xor_size = 0;
		info_xor_size = 0;
		vis_xor_size = 0;
		
		index_mutex.writelock(__FUNCTION__, __LINE__);
		player_spawn_id_map[1] = this;
		player_spawn_reverse_id_map[this] = 1;
		spawn_index = 1;
		index_mutex.releasewritelock(__FUNCTION__, __LINE__);
	}
	
	returning_from_ld = val;
}

bool Player::IsReturningFromLD(){
	return returning_from_ld;
}

void Player::AddFriend(const char* name, bool save){
	if(name){
		if(save)
			friend_list[name] = 1;
		else
			friend_list[name] = 0;
	}
}

bool Player::IsFriend(const char* name){
	if(name && friend_list.count(name) > 0 && friend_list[name] < 2)
		return true;
	return false;
}

void Player::RemoveFriend(const char* name){
	if(friend_list.count(name) > 0)
		friend_list[name] = 2;
}

map<string, int8>* Player::GetFriends(){
	return &friend_list;
}

void Player::AddIgnore(const char* name, bool save){
	if(name){
		if(save)
			ignore_list[name] = 1;
		else
			ignore_list[name] = 0;
	}
}

bool Player::IsIgnored(const char* name){
	if(name && ignore_list.count(name) > 0 && ignore_list[name] < 2)
		return true;
	return false;
}

void Player::RemoveIgnore(const char* name){
	if(name && ignore_list.count(name) > 0)
		ignore_list[name] = 2;
}

map<string, int8>* Player::GetIgnoredPlayers(){
	return &ignore_list;
}

bool Player::CheckLevelStatus(int16 new_level) {
	int16 LevelCap					= rule_manager.GetGlobalRule(R_Player, MaxLevel)->GetInt16();
	int16 LevelCapOverrideStatus	= rule_manager.GetGlobalRule(R_Player, MaxLevelOverrideStatus)->GetInt16();
	if ( (LevelCap < new_level) && (LevelCapOverrideStatus > GetZone()->GetClientBySpawn(this)->GetAdminStatus()) )
			return false;
	return true;
}

Skill* Player::GetSkillByName(const char* name, bool check_update){
	Skill* ret = skill_list.GetSkillByName(name);
	if(check_update)
		{
			if(skill_list.CheckSkillIncrease(ret))
				CalculateBonuses();
		}
	return ret;
}

Skill* Player::GetSkillByID(int32 id, bool check_update){
	Skill* ret = skill_list.GetSkill(id);
	if(check_update)
		{
			if(skill_list.CheckSkillIncrease(ret))
				CalculateBonuses();
		}
	return ret;
}

void Player::SetRangeAttack(bool val){
	range_attack = val;
}

bool Player::GetRangeAttack(){
	return range_attack;
}

bool Player::AddMail(Mail* mail) {
	bool ret = false;
	if (mail) {
		mail_list.Put(mail->mail_id, mail);
		ret = true;
	}
	return ret;
}

MutexMap<int32, Mail*>* Player::GetMail() {
	return &mail_list;
}

Mail* Player::GetMail(int32 mail_id) {
	Mail* mail = 0;
	if (mail_list.count(mail_id) > 0)
		mail = mail_list.Get(mail_id);
	return mail;
}

void Player::DeleteMail(bool from_database) {
	MutexMap<int32, Mail*>::iterator itr = mail_list.begin();
	while (itr.Next())
		DeleteMail(itr->first, from_database);
	mail_list.clear();
}

void Player::DeleteMail(int32 mail_id, bool from_database) {
	if (mail_list.count(mail_id) > 0) {
		if (from_database)
			database.DeletePlayerMail(mail_list.Get(mail_id));
		mail_list.erase(mail_id);
	}
}

ZoneServer* Player::GetGroupMemberInZone(int32 zone_id) {
	//if ( GetGroup() == NULL )
		return NULL;

	/*GroupMemberInfo* info = 0;
	for(int32 i=0;i<GetGroup()->members.size(); i++){
		info = GetGroup()->members[i];
		if(info == group_member_info)
			continue;

		// if the client exists, they are attached to a player,
		// the player is currently in an instance, which has the same zone id (for that instance type)
		if ( info->client != NULL && info->client->GetPlayer() != NULL && 
			info->client->GetPlayer()->GetZone()->GetInstanceID() > 0 && 
			info->client->GetPlayer()->GetZone()->GetZoneID() == zone_id )
		{
			return info->client->GetPlayer()->GetZone();
		}
	}

	// no member is in an instance with this zone id
	return NULL;*/
}


/*			CharacterInstances			*/

CharacterInstances::CharacterInstances() {
	m_instanceList.SetName("Mutex::m_instanceList");
}

CharacterInstances::~CharacterInstances() {
	RemoveInstances();
}

void CharacterInstances::AddInstance(int32 db_id, int32 instance_id, int32 last_success_timestamp, int32 last_failure_timestamp, int32 success_lockout_time, int32 failure_lockout_time, int32 zone_id, int8 zone_instancetype, string zone_name) {
	InstanceData data;
	data.db_id = db_id;
	data.instance_id = instance_id;
	data.zone_id = zone_id;
	data.zone_instance_type = zone_instancetype;
	data.zone_name = zone_name;
	data.last_success_timestamp = last_success_timestamp;
	data.last_failure_timestamp = last_failure_timestamp;
	data.success_lockout_time = success_lockout_time;
	data.failure_lockout_time = failure_lockout_time;
	instanceList.push_back(data);
}

void CharacterInstances::RemoveInstances() {
	instanceList.clear();
}

bool CharacterInstances::RemoveInstanceByZoneID(int32 zone_id) {
	vector<InstanceData>::iterator itr;
	m_instanceList.writelock(__FUNCTION__, __LINE__);
	for(itr = instanceList.begin(); itr != instanceList.end(); itr++) {
		InstanceData* data = &(*itr);
		if (data->zone_id == zone_id) {
			instanceList.erase(itr);
			m_instanceList.releasewritelock(__FUNCTION__, __LINE__);
			return true;
		}
	}
	m_instanceList.releasewritelock(__FUNCTION__, __LINE__);
	return false;
}

bool CharacterInstances::RemoveInstanceByInstanceID(int32 instance_id) {
	vector<InstanceData>::iterator itr;
	m_instanceList.writelock(__FUNCTION__, __LINE__);
	for(itr = instanceList.begin(); itr != instanceList.end(); itr++) {
		InstanceData* data = &(*itr);
		if (data->instance_id == instance_id) {
			instanceList.erase(itr);
			m_instanceList.releasewritelock(__FUNCTION__, __LINE__);
			return true;
		}
	}
	m_instanceList.releasewritelock(__FUNCTION__, __LINE__);
	return false;
}

InstanceData* CharacterInstances::FindInstanceByZoneID(int32 zone_id) {
	m_instanceList.readlock(__FUNCTION__, __LINE__);
	for(int32 i = 0; i < instanceList.size(); i++) {
		InstanceData* data = &instanceList.at(i);
		if (data->zone_id == zone_id) {
			m_instanceList.releasereadlock(__FUNCTION__, __LINE__);
			return data;
		}
	}
	m_instanceList.releasereadlock(__FUNCTION__, __LINE__);

	return 0;
}

InstanceData* CharacterInstances::FindInstanceByDBID(int32 db_id) {
	m_instanceList.readlock(__FUNCTION__, __LINE__);
	for(int32 i = 0; i < instanceList.size(); i++) {
		InstanceData* data = &instanceList.at(i);
		if (data->db_id == db_id) {
			m_instanceList.releasereadlock(__FUNCTION__, __LINE__);
			return data;
		}
	}
	m_instanceList.releasereadlock(__FUNCTION__, __LINE__);

	return 0;
}

InstanceData* CharacterInstances::FindInstanceByInstanceID(int32 instance_id) {
	m_instanceList.readlock(__FUNCTION__, __LINE__);
	for(int32 i = 0; i < instanceList.size(); i++) {
		InstanceData* data = &instanceList.at(i);
		if (data->instance_id == instance_id) {
			m_instanceList.releasereadlock(__FUNCTION__, __LINE__);
			return data;
		}
	}
	m_instanceList.releasereadlock(__FUNCTION__, __LINE__);

	return 0;
}
vector<InstanceData> CharacterInstances::GetLockoutInstances() {
	vector<InstanceData> ret;
	m_instanceList.readlock(__FUNCTION__, __LINE__);
	for (int32 i = 0; i < instanceList.size(); i++) {
		InstanceData* data = &instanceList.at(i);
		if (data->zone_instance_type == SOLO_LOCKOUT_INSTANCE || data->zone_instance_type == GROUP_LOCKOUT_INSTANCE || data->zone_instance_type == RAID_LOCKOUT_INSTANCE)
			ret.push_back(*data);
	}
	m_instanceList.releasereadlock(__FUNCTION__, __LINE__);
	return ret;
}

vector<InstanceData> CharacterInstances::GetPersistentInstances() {
	vector<InstanceData> ret;
	m_instanceList.readlock(__FUNCTION__, __LINE__);
	for (int32 i = 0; i < instanceList.size(); i++) {
		InstanceData* data = &instanceList.at(i);
		if (data->zone_instance_type == SOLO_PERSIST_INSTANCE || data->zone_instance_type == GROUP_PERSIST_INSTANCE || data->zone_instance_type == RAID_PERSIST_INSTANCE)
			ret.push_back(*data);
	}
	m_instanceList.releasereadlock(__FUNCTION__, __LINE__);
	return ret;
}

void CharacterInstances::ProcessInstanceTimers(Player* player) {

	// Only need to check persistent instances here, lockout should be handled by zone shutting down

	// Check instance id, if > 0 check timers, if timers expired  set instance id to 0 and update the db `character_instance` to instance id 0,
	// delete instance from `instances` if no more characters assigned to it
	
	m_instanceList.readlock(__FUNCTION__, __LINE__);
	for (int32 i = 0; i < instanceList.size(); i++) {
		InstanceData* data = &instanceList.at(i);

		// Check to see if we have a valid instance and if it is persistant
		if (data->instance_id > 0) {
			
			if (data->zone_instance_type == SOLO_PERSIST_INSTANCE || data->zone_instance_type == GROUP_PERSIST_INSTANCE || data->zone_instance_type == RAID_PERSIST_INSTANCE) {
				// Check max duration (last success + success time)
				if (Timer::GetUnixTimeStamp() >= (data->last_success_timestamp + data->success_lockout_time)) {
					// Max duration has passed, instance has expired lets remove the player from it,
					// this will also delete the instace if all players have been removed from it
					database.DeleteCharacterFromInstance(player->GetCharacterID(), data->instance_id);
					data->instance_id = 0;
				}
			}

			if (data->zone_instance_type == SOLO_LOCKOUT_INSTANCE || data->zone_instance_type == GROUP_LOCKOUT_INSTANCE || data->zone_instance_type == RAID_LOCKOUT_INSTANCE) {
				// Need to check lockout instance ids to ensure they are still valid.
				if (!database.VerifyInstanceID(player->GetCharacterID(), data->instance_id))
					data->instance_id = 0;
			}
		}
	}
	m_instanceList.releasereadlock(__FUNCTION__, __LINE__);

	/*for(int32 i=0;i<instanceList->size();i++)
	{
		bool valuesUpdated = false;
		InstanceData data = instanceList->at(i);
		if ( data.grant_reenter_time_left > 0 )
		{
			if ( ( data.grant_reenter_time_left - msDiff ) < 1 )
				data.grant_reenter_time_left = 0;
			else
				data.grant_reenter_time_left -= msDiff;

			valuesUpdated = true;
		}
		if ( data.grant_reset_time_left > 0 )
		{
			if ( ( data.grant_reset_time_left - msDiff ) < 1 )
				data.grant_reset_time_left = 0;
			else
				data.grant_reset_time_left -= msDiff;

			valuesUpdated = true;
		}
		if ( data.lockout_time > 0 )
		{
			if ( ( data.lockout_time - msDiff ) < 1 )
			{
				data.lockout_time = 0;
				// this means that their timer ran out and we need to clear it from db and player
				RemoveInstanceByInstanceID(data.instance_id);
				database.DeleteCharacterFromInstance(player->GetCharacterID(),data.instance_id);
			}
			else
				data.lockout_time -= msDiff;

			valuesUpdated = true;
		}

		if ( valuesUpdated )
			database.UpdateCharacterInstanceTimers(player->GetCharacterID(),data.instance_id,data.lockout_time,data.grant_reset_time_left,data.grant_reenter_time_left);
	}*/
}

int32 CharacterInstances::GetInstanceCount() {
	return instanceList.size();
}

void Player::SetPlayerAdventureClass(int8 new_class){
	SetAdventureClass(new_class);
	GetInfoStruct()->set_class1(classes.GetBaseClass(new_class));
	GetInfoStruct()->set_class2(classes.GetSecondaryBaseClass(new_class));
	GetInfoStruct()->set_class3(new_class);
	charsheet_changed = true;
	if(GetZone())
		GetZone()->TriggerCharSheetTimer();
}

void Player::AddSkillBonus(int32 spell_id, int32 skill_id, float value) {
	GetSkills()->AddSkillBonus(spell_id, skill_id, value);
}

SkillBonus* Player::GetSkillBonus(int32 spell_id) {
	return GetSkills()->GetSkillBonus(spell_id);
}

void Player::RemoveSkillBonus(int32 spell_id) {
	GetSkills()->RemoveSkillBonus(spell_id);
}

bool Player::HasFreeBankSlot() {
	return item_list.HasFreeBankSlot();
}

int8 Player::FindFreeBankSlot() {
	return item_list.FindFreeBankSlot();
}

void Player::AddTitle(sint32 title_id, const char *name, int8 prefix, bool save_needed){
	Title* new_title = new Title;
	new_title->SetID(title_id);
	new_title->SetName(name);
	new_title->SetPrefix(prefix);
	new_title->SetSaveNeeded(save_needed);
	player_titles_list.Add(new_title);
}

void Player::AddAAEntry(int16 template_id, int8 tab_id, int32 aa_id, int16 order,int8 treeid) {
	
	
	
}
void Player::AddLanguage(int32 id, const char *name, bool save_needed){
	Skill* skill = master_skill_list.GetSkillByName(name);
	if(skill && !GetSkills()->HasSkill(skill->skill_id)) {
		AddSkill(skill->skill_id, 1, skill->max_val, true);
	}
	// Check to see if the player already has the language
	if (HasLanguage(id))
		return;

	// Doesn't already have the language so add it
	Language* new_language = new Language;
	new_language->SetID(id);
	new_language->SetName(name);
	player_languages_list.Add(new_language);

	if (save_needed)
		database.SaveCharacterLang(GetCharacterID(), id);
}

bool Player::HasLanguage(int32 id){
	list<Language*>* languages = player_languages_list.GetAllLanguages();
	list<Language*>::iterator itr;
	Language* language = 0;
	bool ret = false;
	for(itr = languages->begin(); itr != languages->end(); itr++){
		language = *itr;
		if(language->GetID() == id){
			ret = true;
			break;
		}
	}
	return ret;
}

bool Player::HasLanguage(const char* name){
	list<Language*>* languages = player_languages_list.GetAllLanguages();
	list<Language*>::iterator itr;
	Language* language = 0;
	bool ret = false;
	for(itr = languages->begin(); itr != languages->end(); itr++){
		language = *itr;
		if(!strncmp(language->GetName(), name, strlen(name))){
			ret = true;
			break;
		}
	}
	return ret;
}

void Player::AddPassiveSpell(int32 id, int8 tier)
{
	// Add the spell to the list of passives this player currently has
	// list is used for quickly going over only the passive spells the
	// player has instead of going through all their spells.
	passive_spells.push_back(id);

	Client* client = GetZone()->GetClientBySpawn(this);

	// Don not apply passives if the client is null, zoning, or reviving
	if (client == NULL || client->IsZoning() || IsResurrecting())
		return;

	Spell* spell = 0;
	spell = master_spell_list.GetSpell(id, tier);
	if (spell) {
		SpellProcess* spellProcess = 0;
		// Get the current zones spell process
		spellProcess = GetZone()->GetSpellProcess();
		// Cast the spell, CastPassives() bypasses the spell queue
		spellProcess->CastPassives(spell, this);
	}
}

void Player::ApplyPassiveSpells()
{
	Spell* spell = 0;
	SpellBookEntry* spell2 = 0;
	vector<int32>::iterator itr;
	SpellProcess* spellProcess = 0;
	spellProcess = GetZone()->GetSpellProcess();

	for (itr = passive_spells.begin(); itr != passive_spells.end(); itr++)
	{
		spell2 = GetSpellBookSpell((*itr));
		spell = master_spell_list.GetSpell(spell2->spell_id, spell2->tier);
		if (spell) {
			spellProcess->CastPassives(spell, this);
		}
	}
}

void Player::RemovePassive(int32 id, int8 tier, bool remove_from_list)
{
	Spell* spell = 0;
	spell = master_spell_list.GetSpell(id, tier);
	if (spell) {
		SpellProcess* spellProcess = 0;
		spellProcess = GetZone()->GetSpellProcess();
		spellProcess->CastPassives(spell, this, true);

		if (remove_from_list) {
			vector<int32>::iterator remove;
			remove = find(passive_spells.begin(), passive_spells.end(), id);
			if (remove != passive_spells.end())
				passive_spells.erase(remove);
		}

		database.DeleteCharacterSpell(GetCharacterID(), spell->GetSpellID());
	}
}

void Player::RemoveAllPassives()
{
	vector<int32>::iterator itr;
	for (itr = passive_spells.begin(); itr != passive_spells.end(); itr++)
		RemoveSpellBookEntry((*itr), false);

	passive_spells.clear();
}

void Player::ResetPetInfo() {
	GetInfoStruct()->set_pet_id(0xFFFFFFFF);
	GetInfoStruct()->set_pet_movement(0);
	GetInfoStruct()->set_pet_behavior(0);
	GetInfoStruct()->set_pet_health_pct(0.0f);
	GetInfoStruct()->set_pet_power_pct(0.0f);
	// Make sure the values get sent to the client
	SetCharSheetChanged(true);
}

bool Player::HasRecipeBook(int32 recipe_id){
	return recipebook_list.HasRecipeBook(recipe_id);
}

bool Player::DiscoveredLocation(int32 locationID) {
	bool ret = false;

	// No discovery type entry then return false
	if (m_characterHistory.count(HISTORY_TYPE_DISCOVERY) == 0)
		return false;

	// Is a discovery type entry but not a location subtype return false
	if (m_characterHistory[HISTORY_TYPE_DISCOVERY].count(HISTORY_SUBTYPE_LOCATION) == 0)
		return false;

	vector<HistoryData*>::iterator itr;

	for (itr = m_characterHistory[HISTORY_TYPE_DISCOVERY][HISTORY_SUBTYPE_LOCATION].begin(); itr != m_characterHistory[HISTORY_TYPE_DISCOVERY][HISTORY_SUBTYPE_LOCATION].end(); itr++) {
		if ((*itr)->Value == locationID) {
			ret = true;
			break;
		}
	}

	return ret;
}

void Player::UpdatePlayerHistory(int8 type, int8 subtype, int32 value, int32 value2) {
	switch (type) {
	case HISTORY_TYPE_NONE:
		HandleHistoryNone(subtype, value, value2);
		break;
	case HISTORY_TYPE_DEATH:
		HandleHistoryDeath(subtype, value, value2);
		break;
	case HISTORY_TYPE_DISCOVERY:
		HandleHistoryDiscovery(subtype, value, value2);
		break;
	case HISTORY_TYPE_XP:
		HandleHistoryXP(subtype, value, value2);
		break;
	default:
		// Not a valid history event so return out before trying to save into the db
		return;
	}
}

void Player::HandleHistoryNone(int8 subtype, int32 value, int32 value2) {
}

void Player::HandleHistoryDeath(int8 subtype, int32 value, int32 value2) {
}

void Player::HandleHistoryDiscovery(int8 subtype, int32 value, int32 value2) {
	switch (subtype) {
	case HISTORY_SUBTYPE_NONE:
		break;
	case HISTORY_SUBTYPE_ADVENTURE:
		break;
	case HISTORY_SUBTYPE_TRADESKILL:
		break;
	case HISTORY_SUBTYPE_QUEST:
		break;
	case HISTORY_SUBTYPE_AA:
		break;
	case HISTORY_SUBTYPE_ITEM:
		break;
	case HISTORY_SUBTYPE_LOCATION: {
		HistoryData* hd = new HistoryData;
		hd->Value = value;
		hd->Value2 = value2;
		hd->EventDate = Timer::GetUnixTimeStamp();
		strcpy(hd->Location, GetZone()->GetZoneName());

		m_characterHistory[HISTORY_TYPE_DISCOVERY][HISTORY_SUBTYPE_LOCATION].push_back(hd);
		break;
	}
	default:
		// Invalid subtype, default to NONE
		break;
	}
}

void Player::HandleHistoryXP(int8 subtype, int32 value, int32 value2) {
	switch (subtype) {
	case HISTORY_SUBTYPE_NONE:
		break;
	case HISTORY_SUBTYPE_ADVENTURE: {
		HistoryData* hd = new HistoryData;
		hd->Value = value;
		hd->Value2 = value2;
		hd->EventDate = Timer::GetUnixTimeStamp();
		strcpy(hd->Location, GetZone()->GetZoneName());

		m_characterHistory[HISTORY_TYPE_XP][HISTORY_SUBTYPE_ADVENTURE].push_back(hd);
	}
		break;
	case HISTORY_SUBTYPE_TRADESKILL:
		break;
	case HISTORY_SUBTYPE_QUEST:
		break;
	case HISTORY_SUBTYPE_AA:
		break;
	case HISTORY_SUBTYPE_ITEM:
		break;
	case HISTORY_SUBTYPE_LOCATION:
		break;
	default:
		// Invalid subtype, default to NONE
		break;
	}
}

void Player::LoadPlayerHistory(int8 type, int8 subtype, HistoryData* hd) {
	m_characterHistory[type][subtype].push_back(hd);
}

void Player::SaveHistory() {
	LogWrite(PLAYER__DEBUG, 0, "Player", "Saving History for Player: '%s'", GetName());

	map<int8, map<int8, vector<HistoryData*> > >::iterator itr;
	map<int8, vector<HistoryData*> >::iterator itr2;
	vector<HistoryData*>::iterator itr3;
	for (itr = m_characterHistory.begin(); itr != m_characterHistory.end(); itr++) {
		for (itr2 = itr->second.begin(); itr2 != itr->second.end(); itr2++) {
			for (itr3 = itr2->second.begin(); itr3 != itr2->second.end(); itr3++) {
				database.SaveCharacterHistory(this, itr->first, itr2->first, (*itr3)->Value, (*itr3)->Value2, (*itr3)->Location, (*itr3)->EventDate);
			}
		}
	}
}

void Player::InitXPTable() {
	m_levelXPReq[2] = 600;
	m_levelXPReq[3] = 800;
	m_levelXPReq[4] = 1000;
	m_levelXPReq[5] = 1400;
	m_levelXPReq[6] = 1800;
	m_levelXPReq[7] = 2200;
	m_levelXPReq[8] = 2600;
	m_levelXPReq[9] = 3000;
	m_levelXPReq[10] = 3400;
	m_levelXPReq[11] = 3800;
	m_levelXPReq[12] = 4200;
	m_levelXPReq[13] = 4600;
	m_levelXPReq[14] = 5000;
	m_levelXPReq[15] = 5500;
	m_levelXPReq[16] = 6000;
	m_levelXPReq[17] = 6500;
	m_levelXPReq[18] = 7000;
	m_levelXPReq[19] = 7500;
	m_levelXPReq[20] = 8000;
	m_levelXPReq[21] = 8500;
	m_levelXPReq[22] = 9000;
	m_levelXPReq[23] = 9500;
	m_levelXPReq[24] = 10000;
	m_levelXPReq[25] = 10500;
	m_levelXPReq[26] = 11000;
	m_levelXPReq[27] = 11750;
	m_levelXPReq[28] = 12500;
	m_levelXPReq[29] = 13250;
	m_levelXPReq[30] = 14000;
	m_levelXPReq[31] = 14750;
	m_levelXPReq[32] = 15500;
	m_levelXPReq[33] = 16250;
	m_levelXPReq[34] = 17000;
	m_levelXPReq[35] = 17750;
	m_levelXPReq[36] = 18500;
	m_levelXPReq[37] = 19250;
	m_levelXPReq[38] = 20000;
	m_levelXPReq[39] = 20750;
	m_levelXPReq[40] = 21500;
	m_levelXPReq[41] = 22250;
	m_levelXPReq[42] = 23000;
	m_levelXPReq[43] = 24000;
	m_levelXPReq[44] = 25000;
	m_levelXPReq[45] = 26000;
	m_levelXPReq[46] = 27000;
	m_levelXPReq[47] = 28000;
	m_levelXPReq[48] = 29250;
	m_levelXPReq[49] = 30500;
	m_levelXPReq[50] = 32000;
	m_levelXPReq[51] = 33750;
	m_levelXPReq[52] = 35750;
	m_levelXPReq[53] = 38000;
	m_levelXPReq[54] = 40500;
	m_levelXPReq[55] = 42500;
	m_levelXPReq[56] = 45500;
	m_levelXPReq[57] = 48500;
	m_levelXPReq[58] = 51500;
	m_levelXPReq[59] = 54500;
	m_levelXPReq[60] = 57500;
	m_levelXPReq[61] = 60500;
	m_levelXPReq[62] = 63500;
	m_levelXPReq[63] = 66500;
	m_levelXPReq[64] = 70000;
	m_levelXPReq[65] = 73500;
	m_levelXPReq[66] = 77000;
	m_levelXPReq[67] = 80500;
	m_levelXPReq[68] = 84000;
	m_levelXPReq[69] = 87500;
	m_levelXPReq[70] = 91000;
	m_levelXPReq[71] = 94500;
	m_levelXPReq[72] = 98000;
	m_levelXPReq[73] = 101500;
	m_levelXPReq[74] = 105000;
	m_levelXPReq[75] = 108500;
	m_levelXPReq[76] = 116500;
	m_levelXPReq[77] = 132500;
	m_levelXPReq[78] = 152500;
	m_levelXPReq[79] = 172500;
	m_levelXPReq[80] = 192500;
	m_levelXPReq[81] = 212500;
	m_levelXPReq[82] = 232500;
	m_levelXPReq[83] = 252500;
	m_levelXPReq[84] = 272500;
	m_levelXPReq[85] = 292500;
	m_levelXPReq[86] = 312500;
	m_levelXPReq[87] = 332500;
	m_levelXPReq[88] = 352500;
	m_levelXPReq[89] = 372500;
	m_levelXPReq[90] = 392500;
	m_levelXPReq[91] = 863550;
	m_levelXPReq[92] = 949905;
	m_levelXPReq[93] = 1044895;
	m_levelXPReq[94] = 1149385;
	m_levelXPReq[95] = 1264323;
}

void Player::SendQuestRequiredSpawns(int32 quest_id){
	bool locked = true;
	m_playerSpawnQuestsRequired.readlock(__FUNCTION__, __LINE__);
	if (player_spawn_quests_required.size() > 0 ) {
		ZoneServer* zone = GetZone();
		Client* client = zone->GetClientBySpawn(this);
		if (!client){
			m_playerSpawnQuestsRequired.releasereadlock(__FUNCTION__, __LINE__);
			return;
		}
		int xxx = player_spawn_quests_required.count(quest_id);
		if (player_spawn_quests_required.count(quest_id) > 0){
			vector<int32> spawns = *player_spawn_quests_required[quest_id];
			m_playerSpawnQuestsRequired.releasereadlock(__FUNCTION__, __LINE__);
			Spawn* spawn = 0;
			vector<int32>::iterator itr;
			for (itr = spawns.begin(); itr != spawns.end();){
				spawn = zone->GetSpawnByID(*itr);
				if (spawn)
					zone->SendSpawnChanges(spawn, client, false, true);
				else {
					itr = spawns.erase(itr);
					continue;
				}
				itr++;
			}
			locked = false;
		}
	}
	if (locked)
		m_playerSpawnQuestsRequired.releasereadlock(__FUNCTION__, __LINE__);
}

void Player::SendHistoryRequiredSpawns(int32 event_id){
	bool locked = true;
	m_playerSpawnHistoryRequired.readlock(__FUNCTION__, __LINE__);
	if (player_spawn_history_required.size() > 0) {
		ZoneServer* zone = GetZone();
		Client* client = zone->GetClientBySpawn(this);
		if (!client){
			m_playerSpawnHistoryRequired.releasereadlock(__FUNCTION__, __LINE__);
			return;
		}
		if (player_spawn_history_required.count(event_id) > 0){
			vector<int32> spawns = *player_spawn_history_required[event_id];
			m_playerSpawnHistoryRequired.releasereadlock(__FUNCTION__, __LINE__);
			Spawn* spawn = 0;
			vector<int32>::iterator itr;
			for (itr = spawns.begin(); itr != spawns.end();){
				spawn = zone->GetSpawnByID(*itr);
				if (spawn)
					zone->SendSpawnChanges(spawn, client, false, true);
				else {
					itr = spawns.erase(itr);
					continue;
				}
				itr++;
			}
			locked = false;
		}
	}
	if (locked)
		m_playerSpawnHistoryRequired.releasereadlock(__FUNCTION__, __LINE__);
}

void Player::AddQuestRequiredSpawn(Spawn* spawn, int32 quest_id){
	if(!spawn || !quest_id)
		return;
	m_playerSpawnQuestsRequired.writelock(__FUNCTION__, __LINE__);
	if(player_spawn_quests_required.count(quest_id) == 0)
		player_spawn_quests_required[quest_id] = new vector<int32>;
	vector<int32>* quest_spawns = player_spawn_quests_required[quest_id];
	int32 current_spawn = 0;
	for(int32 i=0;i<quest_spawns->size();i++){
		current_spawn = quest_spawns->at(i);
		if (current_spawn == spawn->GetID()){
			m_playerSpawnQuestsRequired.releasewritelock(__FUNCTION__, __LINE__);
			return;
		}
	}
	player_spawn_quests_required[quest_id]->push_back(spawn->GetID());
	m_playerSpawnQuestsRequired.releasewritelock(__FUNCTION__, __LINE__);
}

void Player::AddHistoryRequiredSpawn(Spawn* spawn, int32 event_id){
	if (!spawn || !event_id)
		return;
	m_playerSpawnHistoryRequired.writelock(__FUNCTION__, __LINE__);
	if (player_spawn_history_required.count(event_id) == 0)
		player_spawn_history_required[event_id] = new vector<int32>;
	vector<int32>* history_spawns = player_spawn_history_required[event_id];
	vector<int32>::iterator itr = find(history_spawns->begin(), history_spawns->end(), spawn->GetID());
	if (itr == history_spawns->end())
		history_spawns->push_back(spawn->GetID());
	m_playerSpawnHistoryRequired.releasewritelock(__FUNCTION__, __LINE__);
}

int32 PlayerInfo::GetBoatSpawn(){
	return boat_spawn;
}

void PlayerInfo::SetBoatSpawn(Spawn* spawn){
	if(spawn)
		boat_spawn = spawn->GetID();
	else
		boat_spawn = 0;
}

void PlayerInfo::RemoveOldPackets(){
	safe_delete_array(changes);
	safe_delete_array(orig_packet);
	safe_delete_array(pet_changes);
	safe_delete_array(pet_orig_packet);
	changes = 0;
	orig_packet = 0;
	pet_changes = 0;
	pet_orig_packet = 0;
}

PlayerControlFlags::PlayerControlFlags(){
	MControlFlags.SetName("PlayerControlFlags::MControlFlags");
	MFlagChanges.SetName("PlayerControlFlags::MFlagChanges");
	flags_changed = false;
	flag_changes.clear();
	current_flags.clear();
}

PlayerControlFlags::~PlayerControlFlags(){
	flag_changes.clear();
	current_flags.clear();
}

bool PlayerControlFlags::ControlFlagsChanged(){
	bool ret;
	MFlagChanges.writelock(__FUNCTION__, __LINE__);
	ret = flags_changed;
	MFlagChanges.releasewritelock(__FUNCTION__, __LINE__);
	return ret;
}

void PlayerControlFlags::SetPlayerControlFlag(int8 param, int8 param_value, bool is_active){
	if (!param || !param_value)
		return;

	bool active_changed = false;
	MControlFlags.writelock(__FUNCTION__, __LINE__);
	active_changed = (current_flags[param][param_value] != is_active);
	if (active_changed){
		current_flags[param][param_value] = is_active;
		MFlagChanges.writelock(__FUNCTION__, __LINE__);
		flag_changes[param][param_value] = is_active ? 1 : 0;
		flags_changed = true;
		MFlagChanges.releasewritelock(__FUNCTION__, __LINE__);
	}
	MControlFlags.releasewritelock(__FUNCTION__, __LINE__);
}

void PlayerControlFlags::SendControlFlagUpdates(Client* client){
	if (!client)
		return;

	map<int8, int8>* ptr = 0;
	map<int8, map<int8, int8> >::iterator itr;
	map<int8, int8>::iterator itr2;

	MFlagChanges.writelock(__FUNCTION__, __LINE__);
	for (itr = flag_changes.begin(); itr != flag_changes.end(); itr++){
		ptr = &itr->second;
		for (itr2 = ptr->begin(); itr2 != ptr->end(); itr2++){
			ClientPacketFunctions::SendServerControlFlags(client, itr->first, itr2->first, itr2->second);
		}
	}
	flag_changes.clear();
	flags_changed = false;
	MFlagChanges.releasewritelock(__FUNCTION__, __LINE__);
}

bool Player::ControlFlagsChanged(){
	return control_flags.ControlFlagsChanged();
}

void Player::SetPlayerControlFlag(int8 param, int8 param_value, bool is_active){
	control_flags.SetPlayerControlFlag(param, param_value, is_active);
}

void Player::SendControlFlagUpdates(Client* client){
	control_flags.SendControlFlagUpdates(client);
}

void Player::LoadLUAHistory(int32 event_id, LUAHistory* history) {
	mLUAHistory.writelock();
	if (m_charLuaHistory.count(event_id) > 0) {
		LogWrite(PLAYER__ERROR, 0, "Player", "Attempted to added a dupicate event (%u) to character LUA history", event_id);
		safe_delete(history);
		mLUAHistory.releasewritelock();
		return;
	}

	m_charLuaHistory.insert(make_pair(event_id,history));
	mLUAHistory.releasewritelock();
}

void Player::SaveLUAHistory() {
	mLUAHistory.readlock();
	LogWrite(PLAYER__DEBUG, 0, "Player", "Saving LUA History for Player: '%s'", GetName());

	map<int32, LUAHistory*>::iterator itr;
	for (itr = m_charLuaHistory.begin(); itr != m_charLuaHistory.end(); itr++) {
		if (itr->second->SaveNeeded) {
			database.SaveCharacterLUAHistory(this, itr->first, itr->second->Value, itr->second->Value2);
			itr->second->SaveNeeded = false;
		}
	}
	mLUAHistory.releasereadlock();
}

void Player::UpdateLUAHistory(int32 event_id, int32 value, int32 value2) {
	mLUAHistory.writelock();
	LUAHistory* hd = 0;

	if (m_charLuaHistory.count(event_id) > 0)
		hd = m_charLuaHistory[event_id];
	else {
		hd = new LUAHistory;
		m_charLuaHistory.insert(make_pair(event_id,hd));
	}

	hd->Value = value;
	hd->Value2 = value2;
	hd->SaveNeeded = true;
	mLUAHistory.releasewritelock();
	// release the mLUAHistory lock, we will maintain a readlock to avoid any further writes until we complete SendHistoryRequiredSpawns
	// through Spawn::SendSpawnChanges -> Spawn::InitializeVisPacketData -> Spawn::MeetsSpawnAccessRequirements-> Player::GetLUAHistory (this was causing a deadlock)
	mLUAHistory.readlock();
	SendHistoryRequiredSpawns(event_id);
	mLUAHistory.releasereadlock();
}

LUAHistory* Player::GetLUAHistory(int32 event_id) {
	LUAHistory* ret = 0;

	mLUAHistory.readlock();

	if (m_charLuaHistory.count(event_id) > 0)
		ret = m_charLuaHistory[event_id];

	mLUAHistory.releasereadlock();

	return ret;
}

bool Player::CanSeeInvis(Entity* target)
{
	if (!target->IsStealthed() && !target->IsInvis())
		return true;
	if (target->IsStealthed() && HasSeeHideSpell())
		return true;
	else if (target->IsInvis() && HasSeeInvisSpell())
		return true;

	sint32 radius = rule_manager.GetGlobalRule(R_PVP, InvisPlayerDiscoveryRange)->GetSInt32();

	if (radius == 0) // radius of 0 is always seen
		return true;
	// radius of -1 is never seen except through items/spells, radius > -1 means we will show the player if they get into the inner radius
	else if (radius > -1 && this->GetDistance((Spawn*)target) < (float)radius)
		return true;

	// TODO: Implement See Invis Spells! http://cutpon.com:3000/devn00b/EQ2EMu/issues/43

	Item* item = 0;
	vector<Item*>* equipped_list = GetEquippedItemList();
	bool seeInvis = false;
	bool seeStealth = false;
	for (int32 i = 0; i < equipped_list->size(); i++)
	{
		item = equipped_list->at(i);
		seeInvis = item->HasStat(ITEM_STAT_SEEINVIS);
		seeStealth = item->HasStat(ITEM_STAT_SEESTEALTH);
		if (target->IsStealthed() && seeStealth)
			return true;
		else if (target->IsInvis() && seeInvis)
			return true;
	}

	return false;
}

// returns true if we need to update target info due to see invis status change
bool Player::CheckChangeInvisHistory(Entity* target)
{
	std::map<int32, bool>::iterator it;

	it = target_invis_history.find(target->GetID());
	if (it != target_invis_history.end())
	{
		//canSeeStatus
		if (it->second)
		{
			if (!this->CanSeeInvis(target))
			{
				UpdateTargetInvisHistory(target->GetID(), false);
				return true;
			}
			else
				return false;
		}
		else
		{
			if (this->CanSeeInvis(target))
			{
				UpdateTargetInvisHistory(target->GetID(), true);
				return true;
			}
			else
				return false;
		}
	}

	if (!this->CanSeeInvis(target))
		UpdateTargetInvisHistory(target->GetID(), false);
	else
		UpdateTargetInvisHistory(target->GetID(), true);

	return true;
}

void Player::UpdateTargetInvisHistory(int32 targetID, bool canSeeStatus)
{
	target_invis_history[targetID] = canSeeStatus;
}

void Player::RemoveTargetInvisHistory(int32 targetID)
{
	target_invis_history.erase(targetID);
}

bool Player::SetSpawnMap(Spawn* spawn)
{
	if(!client->GetPlayer()->SetSpawnSentState(spawn, SpawnState::SPAWN_STATE_SENDING)) {
		/*index_mutex.writelock(__FUNCTION__, __LINE__);
		spawn_id += 1;
		if (spawn_index == 255)
			spawn_index += 1; //just so we dont have to worry about overloading

		map<int32, Spawn*>::iterator itr = player_spawn_id_map.find(player_spawn_reverse_id_map[this]);
		if(itr != player_spawn_id_map.end()) {
			player_spawn_id_map.erase(itr);
		}
		player_spawn_id_map[spawn_id] = spawn;
		player_spawn_reverse_id_map[this] = spawn_id;
		index_mutex.releasewritelock(__FUNCTION__, __LINE__);*/
		return false;
	}

	index_mutex.writelock(__FUNCTION__, __LINE__);
	spawn_id += 1;
	if (spawn_index == 255)
		spawn_index += 1; //just so we dont have to worry about overloading
	
	int32 tmp_id = spawn_id;

	player_spawn_id_map[tmp_id] = spawn;

	if(player_spawn_reverse_id_map.count(spawn))
		player_spawn_reverse_id_map.erase(spawn);

	player_spawn_reverse_id_map.insert(make_pair(spawn,tmp_id));
	index_mutex.releasewritelock(__FUNCTION__, __LINE__);
	return true;
}

NPC* Player::InstantiateSpiritShard(float origX, float origY, float origZ, float origHeading, int32 origGridID, ZoneServer* origZone)
{
		NPC* npc = new NPC();
		string newName(GetName());
		newName.append("'s spirit shard");

		strcpy(npc->appearance.name, newName.c_str());
		/*vector<EntityCommand*>* primary_command_list = zone->GetEntityCommandList(result.GetInt32(9));
		vector<EntityCommand*>* secondary_command_list = zone->GetEntityCommandList(result.GetInt32(10));
		if(primary_command_list){
			npc->SetPrimaryCommands(primary_command_list);
			npc->primary_command_list_id = result.GetInt32(9);
		}
		if(secondary_command_list){
			npc->SetSecondaryCommands(secondary_command_list);
			npc->secondary_command_list_id = result.GetInt32(10);
		}*/
		npc->appearance.level =	GetLevel();
		npc->appearance.race = GetRace();
		npc->appearance.gender = GetGender();
		npc->appearance.adventure_class = GetAdventureClass();
		
		npc->appearance.model_type = GetModelType();
		npc->appearance.soga_model_type = GetSogaModelType();
		npc->appearance.display_name = 1;
		npc->features.hair_type = GetHairType();
		npc->features.hair_face_type = GetFacialHairType();
		npc->features.wing_type = GetWingType();
		npc->features.chest_type = GetChestType();
		npc->features.legs_type = GetLegsType();
		npc->features.soga_hair_type = GetSogaHairType();
		npc->features.soga_hair_face_type = GetSogaFacialHairType();
		npc->appearance.attackable = 0;
		npc->appearance.show_level = 1;
		npc->appearance.targetable = 1;
		npc->appearance.show_command_icon = 1;
		npc->appearance.display_hand_icon = 0;
		npc->appearance.hide_hood = GetHideHood();
		npc->size = GetSize();
		npc->appearance.pos.collision_radius = appearance.pos.collision_radius;
		npc->appearance.action_state = appearance.action_state;
		npc->appearance.visual_state = 6193; // ghostly look
		npc->appearance.mood_state = appearance.mood_state;
		npc->appearance.emote_state = appearance.emote_state;
		npc->appearance.pos.state = appearance.pos.state;
		npc->appearance.activity_status = appearance.activity_status;
		strncpy(npc->appearance.sub_title, appearance.sub_title, sizeof(npc->appearance.sub_title));
		npc->SetPrefixTitle(GetPrefixTitle());
		npc->SetSuffixTitle(GetSuffixTitle());
		npc->SetLastName(GetLastName());
		npc->SetX(origX);
		npc->SetY(origY);
		npc->SetZ(origZ);
		npc->SetHeading(origHeading);
		npc->SetSpawnOrigX(origX);
		npc->SetSpawnOrigY(origY);
		npc->SetSpawnOrigZ(origZ);
		npc->SetSpawnOrigHeading(origHeading);
		npc->appearance.pos.grid_id = origGridID;
		const char* script = rule_manager.GetGlobalRule(R_Combat, SpiritShardSpawnScript)->GetString();

		int32 dbid = database.CreateSpiritShard(newName.c_str(), GetLevel(), GetRace(), GetGender(), GetAdventureClass(), GetModelType(), GetSogaModelType(), 
		GetHairType(), GetFacialHairType(), GetWingType(), GetChestType(), GetLegsType(), GetSogaHairType(), GetSogaFacialHairType(), GetHideHood(),
		GetSize(), npc->appearance.pos.collision_radius, npc->appearance.action_state, npc->appearance.visual_state, npc->appearance.mood_state, 
		npc->appearance.emote_state, npc->appearance.pos.state, npc->appearance.activity_status, npc->appearance.sub_title, GetPrefixTitle(), GetSuffixTitle(),
		GetLastName(), origX, origY, origZ, origHeading, origGridID, GetCharacterID(), origZone->GetZoneID(), origZone->GetInstanceID());

		npc->SetShardID(dbid);
		npc->SetShardCharID(GetCharacterID());
		npc->SetShardCreatedTimestamp(Timer::GetCurrentTime2());

		if(script)
			npc->SetSpawnScript(script);
		
		return npc;
}

void Player::SaveSpellEffects()
{
	if(stop_save_spell_effects)
	{
		LogWrite(PLAYER__WARNING, 0, "Player", "SaveSpellEffects called while player constructing / deconstructing!");
		return;
	}

	SpellProcess* spellProcess = 0;
	// Get the current zones spell process
	spellProcess = GetZone()->GetSpellProcess();

	Query savedEffects;
	savedEffects.AddQueryAsync(GetCharacterID(), &database, Q_DELETE, "delete from character_spell_effects where charid=%u", GetCharacterID());
	savedEffects.AddQueryAsync(GetCharacterID(), &database, Q_DELETE, "delete from character_spell_effect_targets where caster_char_id=%u", GetCharacterID());
	InfoStruct* info = GetInfoStruct();
	MSpellEffects.readlock(__FUNCTION__, __LINE__);
	MMaintainedSpells.readlock(__FUNCTION__, __LINE__);
	for(int i = 0; i < 45; i++) {
		if(info->spell_effects[i].spell_id != 0xFFFFFFFF)
		{
			Spawn* spawn = nullptr;
			int32 target_char_id = 0;
			if(info->spell_effects[i].spell->initial_target_char_id != 0)
				target_char_id = info->spell_effects[i].spell->initial_target_char_id;
			else if((spawn = GetZone()->GetSpawnByID(info->spell_effects[i].spell->initial_target)) != nullptr && spawn->IsPlayer())
				target_char_id = ((Player*)spawn)->GetCharacterID();

			int32 timestamp = 0xFFFFFFFF;
			if(!info->spell_effects[i].spell->spell->GetSpellData()->duration_until_cancel)
				timestamp = info->spell_effects[i].expire_timestamp - Timer::GetCurrentTime2();
			
			int32 caster_char_id = info->spell_effects[i].spell->initial_caster_char_id;

			if(caster_char_id == 0)
				continue;
			
			Query effectSave;
			effectSave.AddQueryAsync(GetCharacterID(), &database, Q_INSERT, 
			"insert into character_spell_effects (name, caster_char_id, target_char_id, target_type, db_effect_type, spell_id, effect_slot, slot_pos, icon, icon_backdrop, conc_used, tier, total_time, expire_timestamp, lua_file, custom_spell, charid, damage_remaining, effect_bitmask, num_triggers, had_triggers, cancel_after_triggers, crit, last_spellattack_hit, interrupted, resisted, custom_function) values ('%s', %u, %u, %u, %u, %u, %u, %u, %u, %u, %u, %u, %f, %u, '%s', %u, %u, %u, %u, %u, %u, %u, %u, %u, %u, %u, '%s')", 
			database.getSafeEscapeString(info->spell_effects[i].spell->spell->GetName()).c_str(), caster_char_id,
			target_char_id,  0 /*no target_type for spell_effects*/, DB_TYPE_SPELLEFFECTS /* db_effect_type for spell_effects */, info->spell_effects[i].spell_id, i, info->spell_effects[i].spell->slot_pos, 
			info->spell_effects[i].icon, info->spell_effects[i].icon_backdrop, 0 /* no conc_used for spell_effects */, info->spell_effects[i].tier, 
			info->spell_effects[i].total_time, timestamp, database.getSafeEscapeString(info->spell_effects[i].spell->file_name.c_str()).c_str(), info->spell_effects[i].spell->spell->IsCopiedSpell(), GetCharacterID(), 
			info->spell_effects[i].spell->damage_remaining, info->spell_effects[i].spell->effect_bitmask, info->spell_effects[i].spell->num_triggers, info->spell_effects[i].spell->had_triggers, info->spell_effects[i].spell->cancel_after_all_triggers,
			info->spell_effects[i].spell->crit, info->spell_effects[i].spell->last_spellattack_hit, info->spell_effects[i].spell->interrupted, info->spell_effects[i].spell->resisted, (info->maintained_effects[i].expire_timestamp) == 0xFFFFFFFF ? "" : database.getSafeEscapeString(spellProcess->SpellScriptTimerCustomFunction(info->spell_effects[i].spell).c_str()).c_str());
		}
		if (i < NUM_MAINTAINED_EFFECTS && info->maintained_effects[i].spell_id != 0xFFFFFFFF){
			Spawn* spawn = GetZone()->GetSpawnByID(info->maintained_effects[i].spell->initial_target);

			int32 target_char_id = 0;
		
			if(info->maintained_effects[i].spell->initial_target_char_id != 0)
				target_char_id = info->maintained_effects[i].spell->initial_target_char_id;
			else if(!info->maintained_effects[i].spell->initial_target)
				target_char_id = GetCharacterID();
			else if(spawn && spawn->IsPlayer())
				target_char_id = ((Player*)spawn)->GetCharacterID();
			else if (spawn && spawn->IsPet() && ((Entity*)spawn)->GetOwner() == (Entity*)this)
				target_char_id = 0xFFFFFFFF;

			int32 caster_char_id = (info->maintained_effects[i].spell->caster && info->maintained_effects[i].spell->caster->IsPlayer()) ? ((Player*)info->maintained_effects[i].spell->caster)->GetCharacterID() : 0;
			
			int32 timestamp = 0xFFFFFFFF;
			if(!info->maintained_effects[i].spell->spell->GetSpellData()->duration_until_cancel)
				timestamp = info->maintained_effects[i].expire_timestamp - Timer::GetCurrentTime2();
			Query effectSave;
			effectSave.AddQueryAsync(GetCharacterID(), &database, Q_INSERT, 
			"insert into character_spell_effects (name, caster_char_id, target_char_id, target_type, db_effect_type, spell_id, effect_slot, slot_pos, icon, icon_backdrop, conc_used, tier, total_time, expire_timestamp, lua_file, custom_spell, charid, damage_remaining, effect_bitmask, num_triggers, had_triggers, cancel_after_triggers, crit, last_spellattack_hit, interrupted, resisted, custom_function) values ('%s', %u, %u, %u, %u, %u, %u, %u, %u, %u, %u, %u, %f, %u, '%s', %u, %u, %u, %u, %u, %u, %u, %u, %u, %u, %u, '%s')", 
			database.getSafeEscapeString(info->maintained_effects[i].name).c_str(), caster_char_id, target_char_id,  info->maintained_effects[i].target_type, DB_TYPE_MAINTAINEDEFFECTS /* db_effect_type for maintained_effects */, info->maintained_effects[i].spell_id, i, info->maintained_effects[i].slot_pos, 
			info->maintained_effects[i].icon, info->maintained_effects[i].icon_backdrop, info->maintained_effects[i].conc_used, info->maintained_effects[i].tier, 
			info->maintained_effects[i].total_time, timestamp, database.getSafeEscapeString(info->maintained_effects[i].spell->file_name.c_str()).c_str(), info->maintained_effects[i].spell->spell->IsCopiedSpell(), GetCharacterID(), 
			info->maintained_effects[i].spell->damage_remaining, info->maintained_effects[i].spell->effect_bitmask, info->maintained_effects[i].spell->num_triggers, info->maintained_effects[i].spell->had_triggers, info->maintained_effects[i].spell->cancel_after_all_triggers,
			info->maintained_effects[i].spell->crit, info->maintained_effects[i].spell->last_spellattack_hit, info->maintained_effects[i].spell->interrupted, info->maintained_effects[i].spell->resisted, (info->maintained_effects[i].expire_timestamp) == 0xFFFFFFFF ? "" : database.getSafeEscapeString(spellProcess->SpellScriptTimerCustomFunction(info->maintained_effects[i].spell).c_str()).c_str());

			info->maintained_effects[i].spell->MSpellTargets.readlock(__FUNCTION__, __LINE__);
			std::string insertTargets = string("insert into character_spell_effect_targets (caster_char_id, target_char_id, target_type, db_effect_type, spell_id, effect_slot, slot_pos) values ");
			bool firstTarget = true;
			map<Spawn*, int8> targetsInserted;
			for (int8 t = 0; t < info->maintained_effects[i].spell->targets.size(); t++) {
				int32 spawn_id = info->maintained_effects[i].spell->targets.at(t);
					Spawn* spawn = GetZone()->GetSpawnByID(spawn_id);
					LogWrite(SPELL__DEBUG, 0, "Spell", "%s has target %u to identify for spell %s", GetName(), spawn_id, info->maintained_effects[i].spell->spell->GetName());
					if(spawn && (spawn->IsPlayer() || spawn->IsPet()))
					{
						int32 tmpCharID = 0;
						int8 type = 0;

						if(targetsInserted.find(spawn) != targetsInserted.end())
							continue;
						
						if(spawn->IsPlayer())
							tmpCharID = ((Player*)spawn)->GetCharacterID();
						else if (spawn->IsPet() && ((Entity*)spawn)->GetOwner() == (Entity*)this)
						{
							tmpCharID = 0xFFFFFFFF;
						}
						else if(spawn->IsPet() && ((Entity*)spawn)->GetOwner() && 
									((Entity*)spawn)->GetOwner()->IsPlayer())
						{
							type = ((Entity*)spawn)->GetPetType();
							Player* petOwner =  (Player*)((Entity*)spawn)->GetOwner();
							tmpCharID = petOwner->GetCharacterID();
						}

						if(!firstTarget)
							insertTargets.append(", ");
						
						targetsInserted.insert(make_pair(spawn, true));


						LogWrite(SPELL__DEBUG, 0, "Spell", "%s has target %s (%u) added to spell %s", GetName(), spawn ? spawn->GetName() : "NA", tmpCharID, info->maintained_effects[i].spell->spell->GetName());
						insertTargets.append("(" + std::to_string(caster_char_id) + ", " + std::to_string(tmpCharID) + ", " + std::to_string(type) + ", " + 
						std::to_string(DB_TYPE_MAINTAINEDEFFECTS) + ", " + std::to_string(info->maintained_effects[i].spell_id) + ", " + std::to_string(i) + 
						", " + std::to_string(info->maintained_effects[i].slot_pos) + ")");
						firstTarget = false;
					}
			}
			multimap<int32,int8>::iterator entries;
			for(entries = info->maintained_effects[i].spell->char_id_targets.begin(); entries != info->maintained_effects[i].spell->char_id_targets.end(); entries++)
			{
				if(!firstTarget)
					insertTargets.append(", ");

				LogWrite(SPELL__DEBUG, 0, "Spell", "%s has target %s (%u) added to spell %s", GetName(), spawn ? spawn->GetName() : "NA", entries->first, info->maintained_effects[i].spell->spell->GetName());
				insertTargets.append("(" + std::to_string(caster_char_id) + ", " + std::to_string(entries->first) + ", " + std::to_string(entries->second) + ", " + 
				std::to_string(DB_TYPE_MAINTAINEDEFFECTS) + ", " + std::to_string(info->maintained_effects[i].spell_id) + ", " + std::to_string(i) + 
				", " + std::to_string(info->maintained_effects[i].slot_pos) + ")");

				firstTarget = false;
			}
			info->maintained_effects[i].spell->MSpellTargets.releasereadlock(__FUNCTION__, __LINE__);
			if(!firstTarget)
			{
				Query targetSave;
				targetSave.AddQueryAsync(GetCharacterID(), &database, Q_INSERT, insertTargets.c_str());
			}
		}
	}
	MMaintainedSpells.releasereadlock(__FUNCTION__, __LINE__);
	MSpellEffects.releasereadlock(__FUNCTION__, __LINE__);
}

void Player::MentorTarget()
{
	if(client->GetPlayer()->GetGroupMemberInfo() && client->GetPlayer()->GetGroupMemberInfo()->mentor_target_char_id)
	{
		client->GetPlayer()->GetGroupMemberInfo()->mentor_target_char_id = 0;
		reset_mentorship = true;
		client->Message(CHANNEL_COMMAND_TEXT, "You stop mentoring, and return to level %u.", client->GetPlayer()->GetLevel());
	}
	else if(!reset_mentorship && client->GetPlayer()->GetTarget())
	{
		if(client->GetPlayer()->GetTarget()->IsPlayer())
		{
			Player* tmpPlayer = (Player*)client->GetPlayer()->GetTarget();
			if(tmpPlayer->GetGroupMemberInfo() && tmpPlayer->GetGroupMemberInfo()->mentor_target_char_id)
			{
				client->Message(CHANNEL_COMMAND_TEXT, "You cannot mentor %s at this time.",tmpPlayer->GetName());
				return;
			}
			if(client->GetPlayer()->group_id > 0 && client->GetPlayer()->GetTarget()->group_id == client->GetPlayer()->group_id)
			{
				if(client->GetPlayer()->GetGroupMemberInfo() && !client->GetPlayer()->GetGroupMemberInfo()->mentor_target_char_id && client->GetPlayer()->GetZone() == client->GetPlayer()->GetTarget()->GetZone() && client->GetPlayer()->GetTarget()->GetName() != client->GetPlayer()->GetName())
				{
					SetMentorStats(client->GetPlayer()->GetTarget()->GetLevel(), tmpPlayer->GetCharacterID());
					client->Message(CHANNEL_COMMAND_TEXT, "You are now mentoring %s, reducing your effective level to %u.",client->GetPlayer()->GetTarget()->GetName(), client->GetPlayer()->GetTarget()->GetLevel());
				}
				if(client->GetPlayer()->GetTarget()->GetName() == client->GetPlayer()->GetName()) {
					client->Message(CHANNEL_COMMAND_TEXT, "You cannot mentor yourself.");
				}
			}
		}
	}
}

void Player::SetMentorStats(int32 effective_level, int32 target_char_id)
{
	RemoveSpells();
	if(client->GetPlayer()->GetGroupMemberInfo())
		client->GetPlayer()->GetGroupMemberInfo()->mentor_target_char_id = target_char_id;
	InfoStruct* info = GetInfoStruct();
	info->set_effective_level(effective_level);
	client->GetPlayer()->SetTotalHPBase(effective_level * effective_level * 2 + 40);
	client->GetPlayer()->SetTotalPowerBase((sint32)(effective_level * effective_level * 2.1 + 45));
	client->GetPlayer()->CalculateBonuses();
	client->GetPlayer()->SetHP(GetTotalHP());
	client->GetPlayer()->SetPower(GetTotalPower());
	/*info->set_agi_base(effective_level * 2 + 15);
	info->set_intel_base(effective_level * 2 + 15);
	info->set_wis_base(effective_level * 2 + 15);
	info->set_str_base(effective_level * 2 + 15);
	info->set_sta_base(effective_level * 2 + 15);
	info->set_cold_base((int16)(effective_level * 1.5 + 10));
	info->set_heat_base((int16)(effective_level * 1.5 + 10));
	info->set_disease_base((int16)(effective_level * 1.5 + 10));
	info->set_mental_base((int16)(effective_level * 1.5 + 10));
	info->set_magic_base((int16)(effective_level * 1.5 + 10));
	info->set_divine_base((int16)(effective_level * 1.5 + 10));
	info->set_poison_base((int16)(effective_level * 1.5 + 10));*/
	GetClient()->ClearSentItemDetails();
	if(GetClient())
	{
		EQ2Packet* app = GetEquipmentList()->serialize(GetClient()->GetVersion(), this);
		if (app) {
			GetClient()->QueuePacket(app);
		}
	}
	GetEquipmentList()->SendEquippedItems(this);
}

void Player::SetLevel(int16 level, bool setUpdateFlags) {
	if(!GetGroupMemberInfo() || GetGroupMemberInfo()->mentor_target_char_id == 0) {
		GetInfoStruct()->set_effective_level(level);
	}
	SetInfo(&appearance.level, level, setUpdateFlags);
	SetXP(0);
	SetNeededXP();
}

bool Player::SerializeItemPackets(EquipmentItemList* equipList, vector<EQ2Packet*>* packets, Item* item, int16 version, Item* to_item) {
	if(item_list.AddItem(item)) {
		item->save_needed = true;
		SetEquippedItemAppearances();
		packets->push_back(equipList->serialize(version, this));
		packets->push_back(item->serialize(version, false));
		if(to_item)
			packets->push_back(to_item->serialize(version, false, this));
		packets->push_back(item_list.serialize(this, version));
		return true;
	}
	else {
		LogWrite(PLAYER__ERROR, 0, "Player", "failed to add item to item_list");
	}
	return false;
}

void Player::AddGMVisualFilter(int32 filter_type, int32 filter_value, char* filter_search_str, int16 visual_tag) {
	if(MatchGMVisualFilter(filter_type, filter_value, filter_search_str) > 0)
		return;

	vis_mutex.writelock(__FUNCTION__, __LINE__);
	GMTagFilter filter;
	filter.filter_type = filter_type;
	filter.filter_value = filter_value;
	memset(filter.filter_search_criteria, 0, sizeof(filter.filter_search_criteria));
	if(filter_search_str)
		memcpy(&filter.filter_search_criteria, filter_search_str, strnlen(filter_search_str, sizeof(filter.filter_search_criteria)));

	filter.visual_tag = visual_tag;
	gm_visual_filters.push_back(filter);
	vis_mutex.releasewritelock(__FUNCTION__, __LINE__);
}

int16 Player::MatchGMVisualFilter(int32 filter_type, int32 filter_value, char* filter_search_str, bool in_vismutex_lock) {
	if(!in_vismutex_lock)
		vis_mutex.readlock(__FUNCTION__, __LINE__);
	int16 tag_id = 0;
	vector<GMTagFilter>::iterator itr = gm_visual_filters.begin();
	for(;itr != gm_visual_filters.end();itr++) {
		if(itr->filter_type == filter_type && itr->filter_value == filter_value) {
			if(filter_search_str && !strcasecmp(filter_search_str, itr->filter_search_criteria)) {
				tag_id = itr->visual_tag;
				break;
			}
		}
	}
	if(!in_vismutex_lock)
		vis_mutex.releasereadlock(__FUNCTION__, __LINE__);
	return tag_id;
}
void Player::ClearGMVisualFilters() {
	vis_mutex.writelock(__FUNCTION__, __LINE__);
	gm_visual_filters.clear();
	vis_mutex.releasewritelock(__FUNCTION__, __LINE__);
}

int Player::GetPVPAlignment(){
	int bind_zone = GetPlayerInfo()->GetBindZoneID();
	int alignment = 0;

	if(bind_zone && bind_zone != 0){
	//0 is good.
	//1 is evil.
	//2 is neutral aka haven players.
			switch(bind_zone){
			//good zones
				case 114: //Gfay
				case 221: //Qeynos Harbor
				case 222: //North Qeynos
				case 231: //South Qeynos
				case 233: //Nettleville
				case 234: //Starcrest
				case 235: //Graystone
				case 236: //CastleView
				case 237: //Willowood
				case 238: //Baubbleshire
				case 470: //Frostfang
				case 589: //Qeynos Combined 1
				case 660: //Qeynos Combined 2
					alignment = 0; //good
					break;
				//evil zones				
				case 128: //East Freeport
				case 134: //Big Bend
				case 135: //Stonestair
				case 136: //Temple St.
				case 137: //Beggars Ct.
				case 138: //Longshadow
				case 139: //Scale Yard
				case 144: //North Freeport
				case 166: //South Freeport
				case 168: //West Freeport
				case 184: //Neriak
				case 644: //BigBend2
				case 645: //Stonestair2
				case 646: //Temple St2
				case 647: //Beggars Ct2
				case 648: //LongShadow2
				case 649: //Scale Yard2
					alignment = 1; //evil
					break;
				//Neutral (MajDul?)
				case 45: //haven
				case 46: //MajDul
					alignment = 2;
					break;
				
				default:
					alignment = -1; //error
			}
		//return -1 (error), 0 (good), 1 (evil), or 2 (Neutral)
		return alignment;
	}
	return -1; //error
}

void Player::GetSpellBookSlotSort(int32 pattern, int32* i, int8* page_book_count, int32* last_start_point) {
	switch(pattern) {
		case 1: { // down
			*i = (*i) + 2;
			(*page_book_count)++;
			if(*page_book_count > 3) {
				if(((*i) % 2) == 0) {
					(*i) = (*last_start_point) + 1;
				}
				else {
					(*last_start_point) = (*last_start_point) + 8;
					(*i) = (*last_start_point);
				}
				(*page_book_count) = 0;
			}
			break;
		}
		case 2: { // across
			(*page_book_count)++;
			switch(*page_book_count) {
				case 1:
				case 3:	{
					(*i)++;
					break;
				}
				case 2: {
					(*i) = (*i) + 7;
					break;
				}
				case 4: {
					(*last_start_point) = (*last_start_point) + 2;
					(*i) = (*last_start_point);
					(*page_book_count) = 0;
					break;
				}
			}
			break;
		}
		default: { // zig-zag
			(*i)++;
			break;
		}
	}
}