/* 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 . */ #include "Player.h" #include "../common/MiscFunctions.h" #include "World.h" #include "WorldDatabase.h" #include #include "classes.h" #include "LuaInterface.h" #include "../common/Log.h" #include "Rules/Rules.h" #include "Titles.h" #include "Languages.h" #include "SpellProcess.h" #include #include #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(){ char_id = 0; group = 0; appearance.pos.grid_id = 0; spawn_index = 0; 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; LogWrite(MISC__TODO, 1, "TODO", "Add player commands here\n\t(%s, function: %s, line #: %i)", __FILE__, __FUNCTION__, __LINE__); 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"); m_playerSpawnQuestsRequired.SetName("Player::player_spawn_quests_required"); m_playerSpawnHistoryRequired.SetName("Player::player_spawn_history_required"); gm_vision = false; } Player::~Player(){ for(int32 i=0;i*>::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 > >::iterator itr1; map >::iterator itr2; vector::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); } } } map::iterator itr4; for (itr4 = m_charLuaHistory.begin(); itr4 != m_charLuaHistory.end(); itr4++) { safe_delete(itr4->second); } 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); player_spawn_index_map.clear(); player_spawn_map.clear(); player_spawn_reverse_id_map.clear(); player_removed_spawns.clear(); player_spawn_id_map.clear(); 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); } 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.lock(); map::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.unlock(); } PlayerInfo* Player::GetPlayerInfo(){ if(info == 0) info = new PlayerInfo(this); return info; } void PlayerInfo::CalculateXPPercentages(){ if(info_struct->xp_needed > 0){ float percentage = ((double)info_struct->xp / info_struct->xp_needed) * 1000; info_struct->xp_yellow = (int16)percentage; info_struct->xp_blue = (int16)(100-((ceil(percentage/100) - (percentage/100)) * 100)); 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::CalculateTSXPPercentages(){ if(info_struct->ts_xp_needed > 0){ float percentage = ((double)info_struct->ts_xp / info_struct->ts_xp_needed) * 1000; info_struct->tradeskill_exp_yellow = (int16)percentage; info_struct->tradeskill_exp_blue = (int16)(100-((ceil(percentage/100) - (percentage/100)) * 100)); /*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){ packet->setDataByName("deity", "None"); packet->setDataByName("character_name", info_struct->name); packet->setDataByName("race", info_struct->race); packet->setDataByName("gender", info_struct->gender); packet->setDataByName("class1", info_struct->class1); packet->setDataByName("class2", info_struct->class2); packet->setDataByName("class3", info_struct->class3); packet->setDataByName("tradeskill_class1", info_struct->tradeskill_class1); packet->setDataByName("tradeskill_class2", info_struct->tradeskill_class2); packet->setDataByName("tradeskill_class3", info_struct->tradeskill_class3); packet->setDataByName("level", info_struct->level); packet->setDataByName("effective_level", info_struct->level); packet->setDataByName("tradeskill_level", info_struct->tradeskill_level); packet->setDataByName("account_age_base", info_struct->account_age_base); for(int8 i=0;iaccount_age_bonus);i++) packet->setDataByName("account_age_bonus", info_struct->account_age_bonus[i]); packet->setDataByName("deity", info_struct->deity); 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->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->cur_concentration); packet->setDataByName("conc_max", info_struct->max_concentration); packet->setDataByName("attack", info_struct->cur_attack); packet->setDataByName("attack_base", info_struct->attack_base); packet->setDataByName("absorb", info_struct->absorb); packet->setDataByName("mitigation_skill1", info_struct->mitigation_skill1); packet->setDataByName("mitigation_skill2", info_struct->mitigation_skill2); packet->setDataByName("mitigation_skill3", info_struct->mitigation_skill3); CalculateXPPercentages(); packet->setDataByName("exp_yellow", info_struct->xp_yellow); packet->setDataByName("exp_blue", info_struct->xp_blue); packet->setDataByName("tradeskill_exp_yellow", info_struct->tradeskill_exp_yellow); packet->setDataByName("tradeskill_exp_blue", info_struct->tradeskill_exp_blue); packet->setDataByName("flags", info_struct->flags); packet->setDataByName("flags2", info_struct->flags2); packet->setDataByName("str", info_struct->str); packet->setDataByName("sta", info_struct->sta); packet->setDataByName("agi", info_struct->agi); packet->setDataByName("wis", info_struct->wis); packet->setDataByName("int", info_struct->intel); packet->setDataByName("str_base", info_struct->str_base); packet->setDataByName("sta_base", info_struct->sta_base); packet->setDataByName("agi_base", info_struct->agi_base); packet->setDataByName("wis_base", info_struct->wis_base); packet->setDataByName("int_base", info_struct->intel_base); packet->setDataByName("mitigation_cur", info_struct->cur_mitigation); packet->setDataByName("mitigation_max", info_struct->max_mitigation); packet->setDataByName("mitigation_base", info_struct->mitigation_base); packet->setDataByName("heat", info_struct->heat); packet->setDataByName("cold", info_struct->cold); packet->setDataByName("magic", info_struct->magic); packet->setDataByName("mental", info_struct->mental); packet->setDataByName("divine", info_struct->divine); packet->setDataByName("disease", info_struct->disease); packet->setDataByName("poison", info_struct->poison); packet->setDataByName("heat_base", info_struct->heat_base); packet->setDataByName("cold_base", info_struct->cold_base); packet->setDataByName("magic_base", info_struct->magic_base); packet->setDataByName("mental_base", info_struct->mental_base); packet->setDataByName("divine_base", info_struct->divine_base); packet->setDataByName("disease_base", info_struct->disease_base); packet->setDataByName("poison_base", info_struct->poison_base); packet->setDataByName("mitigation_cur2", info_struct->cur_mitigation); packet->setDataByName("mitigation_max2", info_struct->max_mitigation); packet->setDataByName("mitigation_base2", info_struct->mitigation_base); packet->setDataByName("coins_copper", info_struct->coin_copper); packet->setDataByName("coins_silver", info_struct->coin_silver); packet->setDataByName("coins_gold", info_struct->coin_gold); packet->setDataByName("coins_plat", info_struct->coin_plat); packet->setDataByName("weight", info_struct->weight); packet->setDataByName("max_weight", info_struct->max_weight); packet->setDataByName("pet_name", info_struct->pet_name); packet->setDataByName("status_points", info_struct->status_points); string* bind_name = 0; if(bind_zone_id > 0) bind_name = database.GetZoneName(bind_zone_id); if(bind_name){ packet->setDataByName("bind_zone", bind_name->c_str()); safe_delete(bind_name); } else packet->setDataByName("bind_zone", "None"); string* house_name = 0; if(house_zone_id > 0) house_name = database.GetZoneName(house_zone_id); if(house_name){ packet->setDataByName("house_zone", house_name->c_str()); safe_delete(house_name); } else packet->setDataByName("house_zone", "None"); //packet->setDataByName("account_age_base", 14); if(player->GetHPRegen() == 0) player->SetHPRegen((int)(info_struct->level*.75)+(int)(info_struct->level/10)+3); if(player->GetPowerRegen() == 0) player->SetPowerRegen(info_struct->level+(int)(info_struct->level/10)+4); packet->setDataByName("hp_regen", player->GetHPRegen()); packet->setDataByName("power_regen", player->GetPowerRegen()); /*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->xp_yellow_vitality_bar); packet->setDataByName("xp_blue_vitality_bar", info_struct->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->rain); packet->setDataByName("rain2", info_struct->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->account_age_base = age; } EQ2Packet* PlayerInfo::serialize(int16 version, int16 modifyPos, int32 modifyValue) { player->CalculateBonuses(); /* info_struct->heat = 15; info_struct->heat_base = 13; info_struct->divine = 14; info_struct->divine_base = 11; info_struct->cur_attack = 5; info_struct->attack_base = 5; info_struct->coin_copper = 1; info_struct->coin_silver = 2; info_struct->coin_gold = 3; info_struct->coin_plat = 4;*/ int8 blah1 = 90; int8 blah2 = 120; /*for (int i = 0; i < 12; i++) { info_struct->maintained_effects[i].icon = 8+i; info_struct->maintained_effects[i].icon_backdrop = 315+i; strcpy(info_struct->maintained_effects[i].name, "Testing Spell"); info_struct->maintained_effects[i].spell_id = 3000+i; info_struct->maintained_effects[i].slot_pos = i; info_struct->maintained_effects[i].expire_timestamp = Timer::GetCurrentTime2() + 72000; if(i<2) info_struct->maintained_effects[i].conc_used = 1; info_struct->maintained_effects[i].total_time = 60+i; }*/ PacketStruct* packet = configReader.getStruct("WS_CharacterSheet", version); /*for (int i = 0; i < 1; i++) { info_struct->spell_effects[i].icon = 303; info_struct->spell_effects[i].icon_backdrop = 317; info_struct->spell_effects[i].spell_id = 8308; info_struct->spell_effects[i].expire_timestamp = Timer::GetCurrentTime2() + 72000; if (i < 5) packet->setSubstructDataByName("spell_effects", "cancellable", 1, i); }*/ //0-69, locked screen movement //30-69 normal movement //10-30 normal movement //for (int i = 5; i < 10; i++) //packet->setDataByName("unknown19", 1+i, i); //Sleep(5000); if (packet) { packet->setDataByName("character_name", info_struct->name); // packet->setDataByName("unknown_1_1_MJ", 99);//unknown_1_1_MJ packet->setDataByName("race", info_struct->race); packet->setDataByName("gender", info_struct->gender); packet->setDataByName("exiled", 0); // need exiled data packet->setDataByName("class1", info_struct->class1); packet->setDataByName("class2", info_struct->class2); packet->setDataByName("class3", info_struct->class3); packet->setDataByName("tradeskill_class1", info_struct->tradeskill_class1); packet->setDataByName("tradeskill_class2", info_struct->tradeskill_class2); packet->setDataByName("tradeskill_class3", info_struct->tradeskill_class3); packet->setDataByName("level", info_struct->level); packet->setDataByName("effective_level", info_struct->level); packet->setDataByName("tradeskill_level", info_struct->tradeskill_level); // packet->setDataByName("unknown_1_2_MJ", 98); //unknown_1_2_MJ packet->setDataByName("account_age_base", info_struct->account_age_base); for (int8 i = 0; i < sizeof(info_struct->account_age_bonus); i++) packet->setDataByName("account_age_bonus", info_struct->account_age_bonus[i]); packet->setDataByName("deity", "None"); packet->setDataByName("deity", info_struct->deity); packet->setDataByName("last_name", player->GetLastName()); // packet->setDataByName("unknown_1_3_MJ", 97);//unknown_1_3_MJ 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->cur_concentration); packet->setDataByName("conc_max", info_struct->max_concentration); if (player->GetHPRegen() == 0) player->SetHPRegen((int)(info_struct->level * .75) + (int)(info_struct->level / 10) + 1); if (player->GetPowerRegen() == 0) player->SetPowerRegen(info_struct->level + (int)(info_struct->level / 10) + 4); packet->setDataByName("hp_regen", player->GetHPRegen() + player->stats[ITEM_STAT_HPREGEN]); packet->setDataByName("power_regen", player->GetPowerRegen() + player->stats[ITEM_STAT_MANAREGEN]); // packet->setDataByName("unknown_1_4a_MJ", 96); //-1// was unknown11 // packet->setDataByName("unknown_1_4b_MJ", 96); //-1 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->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->cur_mitigation);// confirmed DoV packet->setDataByName("mitigation_base", info_struct->mitigation_base);// confirmed DoV packet->setDataByName("mitigation_pct_pve", 392); // % calculation Mitigation % vs PvE 392 = 39.2%// confirmed DoV packet->setDataByName("mitigation_pct_pvp", 559); // % 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", 0);//avoidance_pct 192 = 19.2% // confirmed DoV packet->setDataByName("avoidance_base", info_struct->avoidance_base); // confirmed DoV packet->setDataByName("avoidance", 71); // packet->setDataByName("unknown_1096_1_MJ", 90);//unknown_1096_1_MJ packet->setDataByName("base_avoidance_pct", info_struct->base_avoidance_pct);// confirmed DoV // packet->setDataByName("unknown_1096_2_MJ", 89);//unknown_1096_2_MJ packet->setDataByName("parry", info_struct->parry_base);// confirmed DoV // packet->setDataByName("unknown_1096_3_MJ", 88);//unknown_1096_3_MJ packet->setDataByName("block", info_struct->block_base);// confirmed DoV // packet->setDataByName("unknown_1096_4_MJ", 87);//unknown_1096_4_MJ packet->setDataByName("uncontested_block", info_struct->uncontested_block);// confirmed DoV // packet->setDataByName("unknown_1096_5_MJ", 86);//unknown_1096_5_MJ packet->setDataByName("str", info_struct->str);// confirmed DoV packet->setDataByName("sta", info_struct->sta);// confirmed DoV packet->setDataByName("agi", info_struct->agi);// confirmed DoV packet->setDataByName("wis", info_struct->wis);// confirmed DoV packet->setDataByName("int", info_struct->intel);// confirmed DoV packet->setDataByName("str_base", info_struct->str_base); // confirmed DoV packet->setDataByName("sta_base", info_struct->sta_base);// confirmed DoV packet->setDataByName("agi_base", info_struct->agi_base);// confirmed DoV packet->setDataByName("wis_base", info_struct->wis_base);// confirmed DoV packet->setDataByName("int_base", info_struct->intel_base);// confirmed DoV // packet->setDataByName("unknown_1096_6_MJ", 86);//unknown_1096_6_MJ if (version <= 996) { packet->setDataByName("heat", info_struct->heat); packet->setDataByName("cold", info_struct->cold); packet->setDataByName("magic", info_struct->magic); packet->setDataByName("mental", info_struct->mental); packet->setDataByName("divine", info_struct->divine); packet->setDataByName("disease", info_struct->disease); packet->setDataByName("poison", info_struct->poison); packet->setDataByName("heat_base", info_struct->heat_base); packet->setDataByName("cold_base", info_struct->cold_base); packet->setDataByName("magic_base", info_struct->magic_base); packet->setDataByName("mental_base", info_struct->mental_base); packet->setDataByName("divine_base", info_struct->divine_base); packet->setDataByName("disease_base", info_struct->disease_base); packet->setDataByName("poison_base", info_struct->poison_base); } else { packet->setDataByName("elemental", info_struct->heat);// confirmed DoV packet->setDataByName("noxious", info_struct->poison);// confirmed DoV packet->setDataByName("arcane", info_struct->magic);// confirmed DoV // packet->setDataByName("unknown_1096_7_MJ", 85);//unknown_1096_7_MJ packet->setDataByName("elemental_base", info_struct->elemental_base);// confirmed DoV packet->setDataByName("noxious_base", info_struct->noxious_base);// confirmed DoV packet->setDataByName("arcane_base", info_struct->arcane_base);// confirmed DoV } // packet->setDataByName("unknown_1096_8_MJ", 205);//unknown_1096_8_MJ 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("unknown_1096_9_MJ", 240);//unknown_1096_9_MJ 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("unknown_1096_10_MJ", 280);//unknown_1096_10_MJ 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("unknown_1096_11_MJ", 320);//unknown_1096_11_MJ 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->xp); // confirmed DoV packet->setDataByName("needed_adv_xp", info_struct->xp_needed);// confirmed DoV packet->setDataByName("debt_adv_xp", 0);//95= 9500% //confirmed DoV packet->setDataByName("current_trade_xp", info_struct->ts_xp);// confirmed DoV packet->setDataByName("needed_trade_xp", info_struct->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->xp_yellow_vitality_bar); //change info_struct to match struct packet->setDataByName("adventure_vitality_blue_arrow", info_struct->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", 200);// 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("unknown_1096_12_MJ", 90); 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->coin_copper);// dov confirmed packet->setDataByName("coins_silver", info_struct->coin_silver);// dov confirmed packet->setDataByName("coins_gold", info_struct->coin_gold);// dov confirmed packet->setDataByName("coins_plat", info_struct->coin_plat);// dov confirmed //packet->setDataByName("unknown_1096_15_MJ", 50);//unknown_1096_15_MJ //////Spell Effects go here, but are below //////Dettrimental effects go here, but are below packet->setDataByName("trauma_count", 45);// added with spells leave here for testing//dov confirmed packet->setDataByName("arcane_count", 255);// added with spells leave here for testing//dov confirmed packet->setDataByName("noxious_count", 47);// added with spells leave here for testing//dov confirmed packet->setDataByName("elemental_count", 255);// added with spells leave here for testing//dov confirmed packet->setDataByName("curse_count", 49);// added with spells leave here for testing//dov confirmed // packet->setDataByName("unknown_1096_17_MJ", 30);//unknown_1096_17_MJ //////Maintained effects go here, but are below packet->setDataByName("breath", 30); //packet->setDataByName("unknown_1096_18_MJ", 1000);//16880 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->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("unknown_1096_18_MJ", 99);//unknown_1096_19a_MJ //packet->setDataByName("unknown_1096_18_MJ", 98);//unknown_1096_19b_MJ //packet->setDataByName("unknown_1096_18_MJ", 97);//unknown_1096_19c_MJ //packet->setDataByName("unknown_1096_18_MJ", 96);//unknown_1096_19d_MJ packet->setDataByName("ability_mod_pve", info_struct->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->flags); packet->setDataByName("flags2", info_struct->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); } //unknown_1096_20_MJ //unknown_1096_21_MJ //unknown_1096_22_MJ //unknown_1096_23_MJ packet->setDataByName("haste", info_struct->haste);// dov confirmed //unknown_1096_24_MJ //unknown_1096_25_MJ //unknown_1096_26_MJ packet->setDataByName("drunk", info_struct->drunk);// dov confirmed //unknown_1096_27_MJ packet->setDataByName("hate_mod", info_struct->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 //unknown_1096_28_MJ packet->setDataByName("dps", info_struct->dps);// dov confirmed //unknown_1096_29_MJ packet->setDataByName("melee_ae", info_struct->melee_ae);// dov confirmed packet->setDataByName("multi_attack", info_struct->multi_attack);// dov confirmed packet->setDataByName("spell_multi_attack", info_struct->spell_multi_attack);// dov confirmed //unknown_1096_30_MJ packet->setDataByName("block_chance", info_struct->block_chance);// dov confirmed //unknown_1096_31_MJ packet->setDataByName("crit_chance", info_struct->crit_chance);// dov confirmed //unknown_1096_32_MJ packet->setDataByName("crit_bonus", info_struct->crit_bonus);// dov confirmed packet->setDataByName("potency", player->stats[ITEM_STAT_POTENCY]);//info_struct->potency);// dov confirmed //unknown_1096_33_MJ packet->setDataByName("reuse_speed", info_struct->reuse_speed);// dov confirmed packet->setDataByName("recovery_speed", info_struct->recovery_speed);// dov confirmed packet->setDataByName("casting_speed", info_struct->casting_speed);// dov confirmed packet->setDataByName("spell_reuse_speed", info_struct->spell_reuse_speed);// dov confirmed //unknown_1096_34_MJ packet->setDataByName("strikethrough", info_struct->strikethrough);//dov confirmed //unknown_1096_35_MJ packet->setDataByName("accuracy", info_struct->accuracy);//dov confirmed //unknown_1096_36_MJ packet->setDataByName("critical_mit", info_struct->critical_mitigation);//dov /confirmed //unknown_1096_37_MJ //toughness_resist_crit_pvp //unknown_1096_38_MJ 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 //unknown_1096_39_MJ /////GRoup Members //unknown_1096_40_MJ //unknown_1096_41_MJ if (version <= 283 && info_struct->pet_id == 0xFFFFFFFF) packet->setDataByName("pet_id", 0); else { packet->setDataByName("pet_id", info_struct->pet_id); packet->setDataByName("pet_name", info_struct->pet_name); } //unknown_1096_42_MJ packet->setDataByName("pet_health_pct", info_struct->pet_health_pct); packet->setDataByName("pet_power_pct", info_struct->pet_power_pct); //unknown_1096_43_MJ packet->setDataByName("pet_movement", info_struct->pet_movement); packet->setDataByName("pet_behavior", info_struct->pet_behavior); packet->setDataByName("rain", info_struct->rain); packet->setDataByName("rain2", info_struct->wind); //-102.24); packet->setDataByName("status_points", 999999);// info_struct->status_points); packet->setDataByName("guild_status", 888888); //unknown_1096_44_MJ string* house_name = 0; if (house_zone_id > 0) house_name = database.GetZoneName(house_zone_id); if (house_name) { packet->setDataByName("house_zone", house_name->c_str()); safe_delete(house_name); } else packet->setDataByName("house_zone", "abcdefghijklmnopqrst"); //unknown_1096_45_MJ string* bind_name = 0; if (bind_zone_id > 0) bind_name = database.GetZoneName(bind_zone_id); if (bind_name) { packet->setDataByName("bind_zone", bind_name->c_str()); safe_delete(bind_name); } else packet->setDataByName("bind_zone", "abcdefghijklmnopqrst"); // 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]); packet->setDataByName("flurry", info_struct->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->xp_blue = 12; info_struct->xp_yellow = 16; info_struct->weight = 50; info_struct->max_weight = 200; //packet->setDataByName("auto_attack", 1); //492 packet->setDataByName("exp_yellow", info_struct->xp_yellow); packet->setDataByName("exp_blue", info_struct->xp_blue); packet->setDataByName("tradeskill_exp_yellow", info_struct->tradeskill_exp_yellow); packet->setDataByName("tradeskill_exp_blue", info_struct->tradeskill_exp_blue); packet->setDataByName("attack", info_struct->cur_attack); packet->setDataByName("attack_base", info_struct->attack_base); packet->setDataByName("absorb", info_struct->absorb); packet->setDataByName("mitigation_skill1", info_struct->mitigation_skill1); packet->setDataByName("mitigation_skill2", info_struct->mitigation_skill2); packet->setDataByName("mitigation_skill3", info_struct->mitigation_skill3); packet->setDataByName("mitigation_max", info_struct->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->cur_mitigation); packet->setDataByName("mitigation_max2", info_struct->max_mitigation); packet->setDataByName("mitigation_base2", info_struct->mitigation_base); if (version < 1096) packet->setDataByName("weight", info_struct->weight); packet->setDataByName("max_weight", info_struct->max_weight); packet->setDataByName("unknownint32a", 777777); packet->setDataByName("unknownint32b", 666666); packet->setDataByName("mitigation2_cur", 2367); packet->setDataByName("uncontested_riposte", info_struct->uncontested_riposte); packet->setDataByName("uncontested_dodge", info_struct->uncontested_dodge); packet->setDataByName("uncontested_parry", info_struct->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", 25); // player->GetUnassignedPretigeAA()); packet->setDataByName("total_tradeskill_points", 40); // player->GetTradeskillAA()); packet->setDataByName("unassigned_tradeskill_points", 25);// player->GetUnassignedTradeskillAA()); packet->setDataByName("total_tradeskill_prestige_points", player->GetTradeskillPrestigeAA()); packet->setDataByName("unassigned_tradeskill_prestige_points", 25);// player->GetUnassignedTradeskillPrestigeAA()); /*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("unknown23", 1, 146); //packet->setDataByName("unknown24", 0xFF, 42); //packet->setDataByName("unknown24", 0xFF, 46); // unknown14c = percent aa exp to next level packet->setDataByName("unknown14d", 100, 0); packet->setDataByName("unknown20", 1084227584, 72); //packet->setDataByName("unknown16", 0xFFFFFFFF, 4); //packet->setDataByName("unknown15b", 9911); packet->setDataByName("unknown15c", 200); //packet->setDataByName("unknown15", 100, 10); /*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("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("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("unknown199a", 843);// 25); //packet->setDataByName("unknown199b", 844);// 30); //packet->setDataByName("unknown199c", 845);// 45); //packet->setDataByName("unknown199d", 846);// 55); packet->setDataByName("unknown37", 537); packet->setDataByName("unknown38", 538); packet->setDataByName("unknown39", 539); packet->setDataByName("unknown40", 540); packet->setDataByName("unknown41", 541); packet->setDataByName("unknown42", 542); packet->setDataByName("unknown43", 543); packet->setDataByName("unknown44", 544); packet->setDataByName("ability_mod_pvp", 542); packet->setDataByName("unknown43", 543); packet->setDataByName("unknown44", 544); packet->setDataByName("unknown45", 645); packet->setDataByName("unknown46", 646); packet->setDataByName("unknown47", 647); packet->setDataByName("unknown48", 648); packet->setDataByName("unknown49", 649); packet->setDataByName("unknown50", 650); packet->setDataByName("unknown51", 651); packet->setDataByName("unknown52", 652); packet->setDataByName("unknown53", 653); packet->setDataByName("unknown54", 654); packet->setDataByName("unknown55", 655); packet->setDataByName("unknown56", 656); packet->setDataByName("unknown57", 657); packet->setDataByName("unknown58", 658); packet->setDataByName("unknown59", 659); packet->setDataByName("unknown60", 660); */ packet->setDataByName("in_combat_movement_speed", 125); packet->setDataByName("increase_max_power", 127); packet->setDataByName("increase_max_power2", 128); //129 does not exist /* packet->setDataByName("unknown130", 130); packet->setDataByName("unknown132", 132); packet->setDataByName("unknown133", 133); packet->setDataByName("unknown137", 137); packet->setDataByName("unknown138", 138); packet->setDataByName("unknown139", 139); packet->setDataByName("unknown141", 141); packet->setDataByName("unknown142", 142); packet->setDataByName("unknown144", 144); packet->setDataByName("unknown147", 147); packet->setDataByName("unknown148", 148); packet->setDataByName("unknown170", 170); packet->setDataByName("unknown171", 171); packet->setDataByName("unknown172", 172); packet->setDataByName("unknown173", 173); packet->setDataByName("unknown174", 174); packet->setDataByName("unknown175", 175); packet->setDataByName("unknown176", 176); packet->setDataByName("unknown177", 177); packet->setDataByName("loot_coin", 178); packet->setDataByName("mitigation_increase", 179); packet->setDataByName("unknown180", 180); packet->setDataByName("unknown182", 182); packet->setDataByName("unknown184", 184); packet->setDataByName("unknown185", 185); packet->setDataByName("unknown186", 186); packet->setDataByName("unknown187", 187); packet->setDataByName("unknown188", 188); packet->setDataByName("unknown189", 189); packet->setDataByName("unknown190", 190); packet->setDataByName("unknown191", 191); packet->setDataByName("unknown192", 192); packet->setDataByName("unknown193", 193); packet->setDataByName("unknown194", 194); packet->setDataByName("unknown195", 195); packet->setDataByName("unknown196", 196); packet->setDataByName("unknown197", 197); packet->setDataByName("unknown198", 198); packet->setDataByName("unknown199", 199); packet->setDataByName("unknown200", 200); packet->setDataByName("unknown201", 201); packet->setDataByName("unknown202", 202); packet->setDataByName("unknown203", 203); packet->setDataByName("unknown204", 204); packet->setDataByName("unknown205", 205); packet->setDataByName("unknown206", 206); packet->setDataByName("unknown207", 207); packet->setDataByName("unknown208", 208); packet->setDataByName("unknown209", 209); packet->setDataByName("unknown210", 210); packet->setDataByName("unknown211", 211); packet->setDataByName("unknown212", 212); packet->setDataByName("unknown213", 213); packet->setDataByName("unknown214", 214); packet->setDataByName("unknown215", 215); packet->setDataByName("unknown216", 216); packet->setDataByName("unknown217", 217); packet->setDataByName("unknown218", 218); packet->setDataByName("unknown219", 219); packet->setDataByName("unknown220", 220); packet->setDataByName("unknown221", 221); packet->setDataByName("unknown222", 222); packet->setDataByName("unknown223", 223); packet->setDataByName("unknown224", 224); packet->setDataByName("unknown225", 225); packet->setDataByName("unknown226", 226); packet->setDataByName("unknown227", 227); packet->setDataByName("unknown228", 228); packet->setDataByName("unknown229", 229); packet->setDataByName("unknown230", 230); packet->setDataByName("unknown231", 231); packet->setDataByName("unknown232", 232); packet->setDataByName("unknown233", 233); packet->setDataByName("unknown234", 234); packet->setDataByName("unknown235", 235); packet->setDataByName("unknown236", 236); packet->setDataByName("unknown237", 237); packet->setDataByName("unknown238", 238); packet->setDataByName("unknown239", 239); packet->setDataByName("unknown240", 240); // Tradeskill stats packet->setDataByName("unknown383", 383); packet->setDataByName("unknown384", 384); packet->setDataByName("unknown385", 385); packet->setDataByName("unknown386", 386); packet->setDataByName("unknown387", 387); packet->setDataByName("unknown388", 388); packet->setDataByName("unknown389", 389); packet->setDataByName("unknown390", 390); packet->setDataByName("unknown391", 391); packet->setDataByName("unknown392", 392); packet->setDataByName("unknown393", 393); packet->setDataByName("unknown394", 394); packet->setDataByName("unknown395", 395); packet->setDataByName("unknown396", 396); packet->setDataByName("unknown397", 397); packet->setDataByName("unknown398", 398); */ packet->setDataByName("vision", info_struct->vision); packet->setDataByName("breathe_underwater", info_struct->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); /*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); 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); } 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* 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__); packet->setDataByName("spirit_rank", 2); packet->setDataByName("spirit", 1); packet->setDataByName("spirit_progress", .67); packet->setDataByName("combat_exp_enabled", 1); /*for (int i = 0; i < 12; i++) { packet->setSubstructDataByName("spell_effects", "spell_id", i + 1, i); if (i % 2 == 0) packet->setSubstructDataByName("spell_effects", "cancellable", 1, i); }*/ int testa = 0x41; int testb = 0x41; //160-330 //0-250 (160-250) //top down view //250-290 nothing //290-330 //blocked view //310-330 nothing //1168: 00 00 00 00 00 00 00 00 - 00 00 00 00 00 41 41 41 | .............AAA //1184: 42 41 43 41 44 41 45 00 - 00 00 00 00 00 00 00 00 | BACADAE......... //blocked view //1184: 00 41 41 41 42 41 43 00 - 00 00 00 00 00 00 00 00 | .AAABAC......... //blocked view //1184: 00 41 41 41 41 00 00 00 - 00 00 00 00 00 00 00 00 | .AAAA........... //blocked view //1184: 00 41 41 00 00 00 00 00 - 00 00 00 00 00 00 00 00 | .AA............. //blocked view //1184: 00 41 00 00 00 00 00 00 - 00 00 00 00 00 00 00 00 | .AA............. //blocked view //1184: 41 00 00 00 00 00 00 00 - 00 00 00 00 00 00 00 00 | .AA............. //blocked view 293 //1168: 00 00 00 00 00 00 00 00 - 00 00 00 00 00 00 00 41 | ...............A //blocked view 292 //packet->setDataByName("screen_blur", 0); //1168: 00 00 00 00 00 00 00 00 - 00 00 00 00 00 00 41 00 //blurred view //packet->setDataByName("unknown18", testa, 295); //packet->setDataByName("unknown18", testa, 296); //packet->setDataByName("unknown18", testa, 297); //300 pet junk //492 /*for (int i = 300; i < 360; i++) { packet->setDataByName("unknown19", testa, i); testa++; //packet->setDataByName("unknown19", 0xc3, i+1); }*/ /*packet->setDataByName("pet_id", 5); packet->setDataByName("pet_name", "Blah"); packet->setDataByName("pet_hp", .9); packet->setDataByName("pet_power", .8);*/ /*packet->setDataByName("test7", 0x3f); packet->setDataByName("test8", 0xc3); packet->setDataByName("unknown17", 12); packet->setDataByName("unknown17", 12, 1); packet->setDataByName("unknown17", 12, 2); packet->setDataByName("unknown17", 12, 3);*/ string* data = packet->serializeString(); int32 size = data->length(); /*uchar blah[] = { 0x31,0x02,0x00,0x00,0xff,0x4f,0x77,0x6b,0x65,0x65,0x63,0x65,0x87,0x61 ,0x67,0x68,0x1b,0x83,0x04,0x01,0x13,0x95,0x02,0x02,0x01,0x88,0x01,0x91,0x30,0x30 ,0xa2,0x01,0x30,0x84,0x30,0x8a,0x38,0x38,0xf0,0x17,0x01,0x17,0x9f,0x01,0x17,0x01 ,0x17,0x01,0x0a,0xd5,0x10,0x14,0x18,0x14,0xaa,0x14,0x10,0x14,0x95,0x18,0x14,0x14 ,0x09,0xd1,0x08,0x08,0x06,0x82,0x06,0x1a,0xd1,0x28,0x28,0x1e,0x8a,0x1e,0x01,0x1f ,0x81,0x13,0x09,0x91,0x01,0x50,0x15,0x8f,0xff,0xff,0xff,0xff,0x07,0x8f,0xff,0xff ,0xff,0xff,0x07,0x8f,0xff,0xff,0xff,0xff,0x07,0x8f,0xff,0xff,0xff,0xff,0x07,0x8f ,0xff,0xff,0xff,0xff,0x07,0x8f,0xff,0xff,0xff,0xff,0x07,0x8f,0xff,0xff,0xff,0xff ,0x07,0x8f,0xff,0xff,0xff,0xff,0x07,0x8f,0xff,0xff,0xff,0xff,0x07,0x8f,0xff,0xff ,0xff,0xff,0x07,0x8f,0xff,0xff,0xff,0xff,0x07,0x8f,0xff,0xff,0xff,0xff,0x07,0x8f ,0xff,0xff,0xff,0xff,0x07,0x8f,0xff,0xff,0xff,0xff,0x07,0x8f,0xff,0xff,0xff,0xff ,0x07,0x8f,0xff,0xff,0xff,0xff,0x07,0x8f,0xff,0xff,0xff,0xff,0x07,0x8f,0xff,0xff ,0xff,0xff,0x07,0x8f,0xff,0xff,0xff,0xff,0x07,0x8f,0xff,0xff,0xff,0xff,0x07,0x8f ,0xff,0xff,0xff,0xff,0x07,0x8f,0xff,0xff,0xff,0xff,0x07,0x8f,0xff,0xff,0xff,0xff ,0x07,0x8f,0xff,0xff,0xff,0xff,0x07,0x8f,0xff,0xff,0xff,0xff,0x07,0x8f,0xff,0xff ,0xff,0xff,0x07,0x8f,0xff,0xff,0xff,0xff,0x07,0x8f,0xff,0xff,0xff,0xff,0x07,0x8f ,0xff,0xff,0xff,0xff,0x07,0x8f,0xff,0xff,0xff,0xff,0x47,0x8f,0xff,0xff,0xff,0xff ,0x86,0xff,0xff,0x48,0x8f,0xff,0xff,0xff,0xff,0x86,0xff,0xff,0x48,0x8f,0xff,0xff ,0xff,0xff,0x86,0xff,0xff,0x48,0x8f,0xff,0xff,0xff,0xff,0x86,0xff,0xff,0x48,0x8f ,0xff,0xff,0xff,0xff,0x86,0xff,0xff,0x48,0x8f,0xff,0xff,0xff,0xff,0x86,0xff,0xff ,0x48,0x8f,0xff,0xff,0xff,0xff,0x86,0xff,0xff,0x48,0x8f,0xff,0xff,0xff,0xff,0x86 ,0xff,0xff,0x48,0x8f,0xff,0xff,0xff,0xff,0x86,0xff,0xff,0x48,0x8f,0xff,0xff,0xff ,0xff,0x86,0xff,0xff,0x48,0x8f,0xff,0xff,0xff,0xff,0x86,0xff,0xff,0x48,0x8f,0xff ,0xff,0xff,0xff,0x86,0xff,0xff,0x48,0x8f,0xff,0xff,0xff,0xff,0x86,0xff,0xff,0x48 ,0x8f,0xff,0xff,0xff,0xff,0x86,0xff,0xff,0x48,0x8f,0xff,0xff,0xff,0xff,0x86,0xff ,0xff,0x48,0x8f,0xff,0xff,0xff,0xff,0x86,0xff,0xff,0x48,0x8f,0xff,0xff,0xff,0xff ,0x86,0xff,0xff,0x48,0x8f,0xff,0xff,0xff,0xff,0x86,0xff,0xff,0x48,0x8f,0xff,0xff ,0xff,0xff,0x86,0xff,0xff,0x48,0x8f,0xff,0xff,0xff,0xff,0x86,0xff,0xff,0x48,0x8f ,0xff,0xff,0xff,0xff,0x86,0xff,0xff,0x48,0x8f,0xff,0xff,0xff,0xff,0x86,0xff,0xff ,0x48,0x8f,0xff,0xff,0xff,0xff,0x86,0xff,0xff,0x48,0x8f,0xff,0xff,0xff,0xff,0x86 ,0xff,0xff,0x48,0x8f,0xff,0xff,0xff,0xff,0x86,0xff,0xff,0x48,0x8f,0xff,0xff,0xff ,0xff,0x86,0xff,0xff,0x48,0x8f,0xff,0xff,0xff,0xff,0x86,0xff,0xff,0x48,0x8f,0xff ,0xff,0xff,0xff,0x86,0xff,0xff,0x48,0x8f,0xff,0xff,0xff,0xff,0x86,0xff,0xff,0x48 ,0x8f,0xff,0xff,0xff,0xff,0x86,0xff,0xff,0x0a,0x83,0xf0,0x41,0x7f,0x7f,0x7f,0x7f ,0x3a,0xff,0xff,0xff,0xff,0xff,0x4e,0x6f,0x20,0x87,0x50,0x65,0x74,0x2d,0x9f,0x3f ,0xc3,0x94,0xcb,0xc2,0x08,0x81,0x02 };*/ //size = sizeof(blah); //packet->PrintPacket(); 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); //DumpPacket(orig_packet, 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); } /*if (player->GetTempVariable("offset").length() > 0){ changes[atoul(player->GetTempVariable("offset").c_str())] = 0xF4; changes[atoul(player->GetTempVariable("offset").c_str()) + 1] = 0x01; }*/ 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; DumpPacket(ptr2, tmpsize - modifyPos); } size = Pack(tmp, changes, size, size, version, reverse); //DumpPacket(tmp, size); } 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->pet_id); packet->setDataByName("spawn_id2", info_struct->pet_id); packet->setDataByName("name", info_struct->pet_name); packet->setDataByName("no_pet", info_struct->pet_name); if (version >= 57000) { packet->setDataByName("current_power3", pet->GetPower()); packet->setDataByName("max_power3", pet->GetTotalPower()); packet->setDataByName("health_pct_tooltip", (double)info_struct->pet_health_pct); packet->setDataByName("health_pct_bar", (double)info_struct->pet_health_pct); } else { packet->setDataByName("health_pct_tooltip", info_struct->pet_health_pct); packet->setDataByName("health_pct_bar", info_struct->pet_health_pct); } packet->setDataByName("power_pct_tooltip", info_struct->pet_power_pct); packet->setDataByName("power_pct_bar", info_struct->pet_power_pct); packet->setDataByName("unknown5", 255); // Hate % maybe packet->setDataByName("movement", info_struct->pet_movement); packet->setDataByName("behavior", info_struct->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; for(int8 i=0;igeneric_info.item_type; if (item->details.item_id > 0 && item_type != ITEM_TYPE_FOOD && item_type != ITEM_TYPE_BAUBLE && item_type != ITEM_TYPE_THROWN){ 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)); } } } 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; } 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; } return slot; } vector Player::UnequipItem(int16 index, sint32 bag_id, int8 slot, int16 version) { vector packets; Item* item = equipment_list.items[index]; if (item && bag_id == -999) { int8 old_slot = item->details.slot_id; if (item_list.AssignItemToFreeSlot(item)) { database.DeleteItem(GetCharacterID(), item, "EQUIPPED"); if (item->GetItemScript() && lua_interface) lua_interface->RunItemScript(item->GetItemScript(), "unequipped", item, this); 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); } equipment_list.RemoveItem(index); packets.push_back(equipment_list.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 (item_list.items.count(bag_id) > 0 && item_list.items[bag_id].count(slot) > 0) to_item = item_list.items[bag_id][slot]; if (to_item && GetEquipmentList()->CanItemBeEquippedInSlot(to_item, ConvertSlotFromClient(item->details.slot_id, version))) { equipment_list.RemoveItem(index); 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(item->GetItemScript(), "equipped", to_item, this); item_list.RemoveItem(to_item); slot = item->details.slot_id; equipment_list.SetItem(slot, 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_list.AddItem(item); item->save_needed = true; packets.push_back(item->serialize(version, false)); packets.push_back(equipment_list.serialize(version)); packets.push_back(item_list.serialize(this, version)); } 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++) { if (item_list.items[to_item->details.bag_id].count(i) == 0) { SetEquipment(0, item->details.slot_id); database.DeleteItem(GetCharacterID(), item, "EQUIPPED"); if (item->GetItemScript() && lua_interface) lua_interface->RunItemScript(item->GetItemScript(), "unequipped", item, this); equipment_list.RemoveItem(index); item->details.inv_slot_id = to_item->details.bag_id; item->details.slot_id = i; item_list.AddItem(item); item->save_needed = true; packets.push_back(equipment_list.serialize(version)); packets.push_back(item->serialize(version, false)); packets.push_back(to_item->serialize(version, false, this)); packets.push_back(item_list.serialize(this, version)); 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 { SetEquipment(0, item->details.slot_id); database.DeleteItem(GetCharacterID(), item, "EQUIPPED"); if (item->GetItemScript() && lua_interface) lua_interface->RunItemScript(item->GetItemScript(), "unequipped", item, this); equipment_list.RemoveItem(index); item->details.inv_slot_id = bag_id; item->details.slot_id = slot; item_list.AddItem(item); item->save_needed = true; packets.push_back(equipment_list.serialize(version)); packets.push_back(item->serialize(version, false)); packets.push_back(item_list.serialize(this, 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); database.DeleteItem(GetCharacterID(), item, "EQUIPPED"); if (item->GetItemScript() && lua_interface) lua_interface->RunItemScript(item->GetItemScript(), "unequipped", item, this); equipment_list.RemoveItem(index); item->details.inv_slot_id = bag_id; item->details.slot_id = slot; item_list.AddItem(item); item->save_needed = true; packets.push_back(equipment_list.serialize(version)); packets.push_back(item->serialize(version, false)); packets.push_back(item_list.serialize(this, version)); } } } Item* bag = item_list.GetItemFromUniqueID(bag_id, true); if (bag && bag->IsBag()) packets.push_back(bag->serialize(version, false, this)); } return packets; } map* Player::GetItemList(){ return item_list.GetAllItems(); } vector* Player::GetEquippedItemList(){ return 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* items = GetEquipmentList()->GetAllEquippedItems(); if(items){ for(int32 i=0;isize();i++) SetEquipment(items->at(i)); } safe_delete(items); } EQ2Packet* Player::SwapEquippedItems(int8 slot1, int8 slot2, int16 version){ Item* item_from = equipment_list.items[slot1]; Item* item_to = equipment_list.items[slot2]; if(item_from && equipment_list.CanItemBeEquippedInSlot(item_from, slot2)){ if(item_to){ if(!equipment_list.CanItemBeEquippedInSlot(item_to, slot1)) return 0; item_to->details.slot_id = slot1; item_to->save_needed = true; } item_from->save_needed = true; item_from->details.slot_id = slot2; return equipment_list.serialize(version); } return 0; } bool Player::CanEquipItem(Item* item) { if (item) { Client* client = GetZone()->GetClientBySpawn(this); if (client) { 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 \\aITEM %u 0:%s\\/a.", item->generic_info.adventure_default_level, item->details.item_id, item->name.c_str()); else client->Message(CHANNEL_COLOR_RED, "Your class may not equip \\aITEM %u 0:%s\\/a.", item->details.item_id, item->name.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 Player::EquipItem(int16 index, int16 version, int8 slot_id) { vector packets; if (item_list.indexed_items.count(index) == 0) return packets; Item* item = item_list.indexed_items[index]; slot_id = ConvertSlotFromClient(slot_id, version); if (item) { if (slot_id != 255 && !item->HasSlot(slot_id)) return packets; int8 slot = equipment_list.GetFreeSlot(item, slot_id); bool canEquip = CanEquipItem(item); 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); return packets; } if (canEquip && slot == 255) { if (slot_id == 255) slot = item->slot_data.at(0); else slot = slot_id; packets = UnequipItem(slot, item->details.inv_slot_id, item->details.slot_id, version); // 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 && equipment_list.GetItem(EQ2_SECONDARY_SLOT) != 0) { vector tmp_packets = UnequipItem(EQ2_SECONDARY_SLOT, -999, 0, version); //packets.reserve(packets.size() + tmp_packets.size()); packets.insert(packets.end(), tmp_packets.begin(), tmp_packets.end()); } } 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 && equipment_list.GetItem(EQ2_SECONDARY_SLOT) != 0) { vector tmp_packets = UnequipItem(EQ2_SECONDARY_SLOT, -999, 0, version); //packets.reserve(packets.size() + tmp_packets.size()); packets.insert(packets.end(), tmp_packets.begin(), tmp_packets.end()); } database.DeleteItem(GetCharacterID(), item, "NOT-EQUIPPED"); if (item->GetItemScript() && lua_interface) lua_interface->RunItemScript(item->GetItemScript(), "equipped", item, this); item_list.RemoveItem(item); equipment_list.SetItem(ConvertSlotToClient(slot, version), item); item->save_needed = true; packets.push_back(item->serialize(version, false)); SetEquipment(item); 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 \\aITEM %u %u:%s\\/a is worn out and will not be effective until repaired.", item->details.item_id, item->details.unique_id, item->name.c_str()); } } packets.push_back(equipment_list.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); } } return packets; } bool Player::AddItem(Item* item) { if (item && item->details.item_id > 0) { 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; item_list.AddItem(item); return true; } else if (item_list.AddOverflowItem(item)) return true; } return false; } EQ2Packet* Player::SendInventoryUpdate(int16 version) { return item_list.serialize(this, version); } EQ2Packet* Player::MoveInventoryItem(sint32 to_bag_id, int16 from_index, int8 new_slot, int8 charges, int16 version) { Item* item = item_list.GetItemFromIndex(from_index); int8 result = item_list.MoveItem(to_bag_id, from_index, new_slot, charges); if (result == 1) { if (item) { if (!item->needs_deletion) item->save_needed = true; else if (item->needs_deletion) { database.DeleteItem(GetCharacterID(), item, 0); safe_delete(item); } } 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()->coin_copper; } int32 Player::GetCoinsSilver(){ return GetInfoStruct()->coin_silver; } int32 Player::GetCoinsGold(){ return GetInfoStruct()->coin_gold; } int32 Player::GetCoinsPlat(){ return GetInfoStruct()->coin_plat; } int32 Player::GetBankCoinsCopper(){ return GetInfoStruct()->bank_coin_copper; } int32 Player::GetBankCoinsSilver(){ return GetInfoStruct()->bank_coin_silver; } int32 Player::GetBankCoinsGold(){ return GetInfoStruct()->bank_coin_gold; } int32 Player::GetBankCoinsPlat(){ return GetInfoStruct()->bank_coin_plat; } vector* 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::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::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 = 161; 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; 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::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(); if (!maxlvl_only) { switch (sort_by) { case 0: if (!order) stable_sort(spells.begin(), spells.end(), SortSpellEntryByName); else stable_sort(spells.begin(), spells.end(), SortSpellEntryByNameReverse); break; case 1: if (!order) stable_sort(spells.begin(), spells.end(), SortSpellEntryByLevel); else stable_sort(spells.begin(), spells.end(), SortSpellEntryByLevelReverse); break; case 2: if (!order) stable_sort(spells.begin(), spells.end(), SortSpellEntryByCategory); else stable_sort(spells.begin(), spells.end(), SortSpellEntryByCategoryReverse); break; } } vector::iterator itr; SpellBookEntry* spell = 0; int i = 0; map tmpSpells; vector resultSpells; for (itr = spells.begin(); itr != spells.end(); itr++) { spell = *itr; if (spell->type != book_type || spell->slot == -1) 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::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::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; i++; } // 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; vector::iterator tmpItr; for (tmpItr = resultSpells.begin(); tmpItr != resultSpells.end(); tmpItr++) { ((SpellBookEntry*)*tmpItr)->slot = i; i++; } } 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::iterator itr; SpellBookEntry* spell = 0; for(itr = spells.begin(); itr != spells.end(); itr++){ spell = *itr; if(spell->spell_id == spell_id) return spell->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); 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::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;islot >= 0 && spell->spell_id > 0) ret++; } MSpellsBook.unlock(); return ret; } int8 Player::GetSpellTier(int32 id){ int8 ret = 0; MSpellsBook.lock(); for(int32 i=0;ispell_id == id){ ret = spell->tier; break; } } MSpellsBook.unlock(); return ret; } int16 Player::GetSpellPacketCount(){ int16 ret = 0; MSpellsBook.lock(); for(int32 i=0;ispell_id > 0) ret++; } MSpellsBook.unlock(); return ret; } void Player::LockAllSpells() { vector::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, false); } MSpellsBook.releasewritelock(__FUNCTION__, __LINE__); } void Player::UnlockAllSpells(bool modify_recast) { vector::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, modify_recast); } MSpellsBook.releasewritelock(__FUNCTION__, __LINE__); } void Player::LockSpell(Spell* spell, int16 recast) { vector::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)*/) RemoveSpellStatus(spell2, SPELL_STATUS_LOCK, true, recast); } MSpellsBook.releasewritelock(__FUNCTION__, __LINE__); } void Player::UnlockSpell(Spell* spell) { vector::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)*/) AddSpellStatus(spell2, SPELL_STATUS_LOCK); } MSpellsBook.releasewritelock(__FUNCTION__, __LINE__); } void Player::LockTSSpells() { vector::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::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::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::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 Player::GetSpellBookSpellsByTimer(int32 timerID) { vector ret; vector::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::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* Player::GetSpellsSaveNeeded(){ vector* ret = 0; vector::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; ret->push_back(spell); } } MSpellsBook.unlock(); return ret; } bool Player::HasSpell(int32 spell_id, int8 tier, bool include_higher_tiers){ bool ret = false; vector::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))){ ret = true; break; } } MSpellsBook.unlock(); return ret; } sint32 Player::GetFreeSpellBookSlot(int32 type){ sint32 ret = 0; MSpellsBook.lock(); vector::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::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 Player::GetSpellBookSpellIDBySkill(int32 skill_id) { vector ret; MSpellsBook.readlock(__FUNCTION__, __LINE__); vector::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;islot < 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", GetNameCrc(spell->GetName()), 0, ptr); 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(); strcpy(info_struct->name, player->GetName()); info_struct->class1 = classes.GetBaseClass(player->GetAdventureClass()); info_struct->class2 = classes.GetSecondaryBaseClass(player->GetAdventureClass()); info_struct->class3 = player->GetAdventureClass(); info_struct->race = player->GetRace(); info_struct->gender = player->GetGender(); info_struct->level = player->GetLevel(); info_struct->tradeskill_level = player->GetTSLevel(); // JA: added 2011.07.22 to address TODO below info_struct->tradeskill_class1 = classes.GetTSBaseClass(player->GetTradeskillClass()); info_struct->tradeskill_class2 = classes.GetSecondaryTSBaseClass(player->GetTradeskillClass()); info_struct->tradeskill_class3 = player->GetTradeskillClass(); LogWrite(MISC__TODO, 1, "TODO", "Fix info_struct.tradeskill_level = player->GetArtLevel();\n\t(%s, function: %s, line #: %i)", __FILE__, __FUNCTION__, __LINE__); 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->spell_effects[i].spell_id = 0xFFFFFFFF; } 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;imaintained_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;imaintained_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;imaintained_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; } void Player::ClearEverything(){ player_removed_spawns.clear(); player_spawn_map.clear(); player_spawn_index_map.clear(); player_spawn_id_map.clear(); player_spawn_reverse_id_map.clear(); map*>::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__); vis_mutex.writelock(__FUNCTION__, __LINE__); spawn_vis_packet_list.clear(); vis_mutex.releasewritelock(__FUNCTION__, __LINE__); info_mutex.writelock(__FUNCTION__, __LINE__); spawn_info_packet_list.clear(); info_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; luaspell->slot_pos = effect->slot_pos; effect->spell_id = spell->GetSpellData()->id; LogWrite(PLAYER__DEBUG, 5, "Player", "AddMaintainedSpell Spell ID: %u", spell->GetSpellData()->id); effect->icon = spell->GetSpellData()->icon; effect->icon_backdrop = spell->GetSpellData()->icon_backdrop; effect->conc_used = spell->GetSpellData()->req_concentration / 256; 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){ 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 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; } } 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; 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__); } bool Player::HasActiveMaintainedSpell(Spell* spell, Spawn* target){ GetMaintainedMutex()->readlock(__FUNCTION__, __LINE__); for(int i=0;i<30;i++){ if (GetInfoStruct()->maintained_effects[i].spell_id == spell->GetSpellData()->id){ GetMaintainedMutex()->releasereadlock(__FUNCTION__, __LINE__); return true; } } GetMaintainedMutex()->releasereadlock(__FUNCTION__, __LINE__); return false; } bool Player::HasActiveSpellEffect(Spell* spell, Spawn* target){ return false; } void Player::PrepareIncomingMovementPacket(int32 len, uchar* data, int16 version) { 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) { if (GetZone() && GetZone()->GetDrowningVictim(this) && (activity == UPDATE_ACTIVITY_RUNNING || activity == UPDATE_ACTIVITY_IN_WATER_ABOVE)) // not drowning anymore GetZone()->RemoveDrowningVictim(this); if ((activity == UPDATE_ACTIVITY_DROWNING || activity == UPDATE_ACTIVITY_DROWNING2) && GetZone() && !GetInvulnerable()) //drowning GetZone()->AddDrowningVictim(this); if (activity == UPDATE_ACTIVITY_JUMPING || activity == UPDATE_ACTIVITY_FALLING) SetInitialState(1024); else if (GetInitialState() == 1024) SetInitialState(16512); 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 || (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) SetBoatSpawn(0); 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) 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::NeedsSpawnResent(Spawn* spawn){ return WasSentSpawn(spawn->GetID()) && WasSpawnRemoved(spawn); } bool Player::WasSentSpawn(int32 spawn_id){ bool ret; info_mutex.readlock(__FUNCTION__, __LINE__); ret = spawn_info_packet_list.count(spawn_id) == 1; info_mutex.releasereadlock(__FUNCTION__, __LINE__); return ret; } PlayerSkillList* Player::GetSkills(){ return &skill_list; } void Player::InCombat(bool val, bool range) { if (val) GetInfoStruct()->flags |= (1 << (range?CF_RANGED_AUTO_ATTACK:CF_AUTO_ATTACK)); else GetInfoStruct()->flags &= ~(1 << (range?CF_RANGED_AUTO_ATTACK:CF_AUTO_ATTACK)); in_combat = val; if(in_combat) AddIconValue(64); else RemoveIconValue(64); charsheet_changed = true; } void Player::SetCharSheetChanged(bool val){ charsheet_changed = val; } bool Player::GetCharSheetChanged(){ return charsheet_changed; } bool Player::AdventureXPEnabled(){ return (GetInfoStruct()->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()->flags, GetInfoStruct()->flags2); if (flag > CF_MAXIMUM_FLAG) return; if (flag < 32) GetInfoStruct()->flags |= (1 << flag); else GetInfoStruct()->flags2 |= (1 << (flag - 32)); charsheet_changed = true; info_changed = true; LogWrite(PLAYER__DEBUG, 0, "Player", "Flags after: %u, Flags2: %u", GetInfoStruct()->flags, GetInfoStruct()->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()->flags, GetInfoStruct()->flags2); if (flag > CF_MAXIMUM_FLAG) return; if (flag < 32) GetInfoStruct()->flags &= ~(1 << flag); else GetInfoStruct()->flags2 &= ~(1 << (flag - 32)); charsheet_changed = true; info_changed = true; LogWrite(PLAYER__DEBUG, 0, "Player", "Flags after: %u, Flags2: %u", GetInfoStruct()->flags, GetInfoStruct()->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()->flags, GetInfoStruct()->flags2); if (flag > CF_MAXIMUM_FLAG) return; if (flag < 32) GetInfoStruct()->flags ^= (1 << flag); else GetInfoStruct()->flags2 ^= (1 << (flag - 32)); charsheet_changed = true; info_changed = true; LogWrite(PLAYER__DEBUG, 0, "Player", "Flags after: %u, Flags2: %u", GetInfoStruct()->flags, GetInfoStruct()->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()->flags) >> flag & 1); else ret = ((GetInfoStruct()->flags2) >> (flag - 32) & 1); return ret; } float Player::GetXPVitality(){ return GetInfoStruct()->xp_vitality; } float Player::GetTSXPVitality() { return GetInfoStruct()->tradeskill_xp_vitality; } bool Player::DoubleXPEnabled(){ return GetInfoStruct()->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_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); if(GetXPVitality() >= percent) { GetInfoStruct()->xp_vitality -= percent; total *= 2; LogWrite(PLAYER__DEBUG, 5, "XP", "Vitality >= Percent, total = %.2f", total); } else { total += ((GetXPVitality() / percent) *2)*total; GetInfoStruct()->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); if(GetTSXPVitality() >= percent) { GetInfoStruct()->tradeskill_xp_vitality -= percent; total *= 2; LogWrite(PLAYER__DEBUG, 5, "XP", "Vitality >= Percent, total = %.2f", total); } else { total += ((GetTSXPVitality() / percent) *2)*total; GetInfoStruct()->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::SetNeededXP(int32 val){ GetInfoStruct()->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()->xp = val; } void Player::SetNeededTSXP(int32 val) { GetInfoStruct()->ts_xp_needed = val; } void Player::SetNeededTSXP() { GetInfoStruct()->ts_xp_needed = GetTSLevel() * 100; } void Player::SetTSXP(int32 val) { GetInfoStruct()->ts_xp = val; } int32 Player::GetXPDebt(){ return GetInfoStruct()->xp_debt; } int32 Player::GetNeededXP(){ return GetInfoStruct()->xp_needed; } int32 Player::GetXP(){ return GetInfoStruct()->xp; } int32 Player::GetNeededTSXP() { return GetInfoStruct()->ts_xp_needed; } int32 Player::GetTSXP() { return GetInfoStruct()->ts_xp; } bool Player::AddXP(int32 xp_amount){ xp_amount += ((xp_amount) * stats[ITEM_STAT_COMBATEXPMOD]) / 100; 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!"); return false; } xp_amount -= GetNeededXP() - GetXP(); SetLevel(GetLevel() + 1); SetXP(0); SetNeededXP(); } 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()); } return true; } bool Player::AddTSXP(int32 xp_amount){ xp_amount += ((xp_amount)*stats[ITEM_STAT_TRADESKILLEXPMOD]) / 100; 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()->tradeskill_class1 = 1; GetInfoStruct()->tradeskill_class2 = 1; GetInfoStruct()->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){ if(player_spawn_map.count(index) > 0) return player_spawn_map[index]; else return 0; } int16 Player::GetIndexForSpawn(Spawn* spawn){ if(player_spawn_index_map.count(spawn) > 0) return player_spawn_index_map[spawn]; else return 0; } bool Player::WasSpawnRemoved(Spawn* spawn){ if(player_removed_spawns.count(spawn) > 0) return true; else return false; } void Player::RemoveSpawn(Spawn* spawn) { LogWrite(PLAYER__DEBUG, 3, "Player", "Remove Spawn '%s' (%u)", spawn->GetName(), spawn->GetID()); player_removed_spawns[spawn] = 1; int32 id = spawn->GetID(); info_mutex.writelock(__FUNCTION__, __LINE__); spawn_info_packet_list.erase(id); info_mutex.releasewritelock(__FUNCTION__, __LINE__); pos_mutex.writelock(__FUNCTION__, __LINE__); spawn_pos_packet_list.erase(id); pos_mutex.releasewritelock(__FUNCTION__, __LINE__); vis_mutex.writelock(__FUNCTION__, __LINE__); spawn_vis_packet_list.erase(id); vis_mutex.releasewritelock(__FUNCTION__, __LINE__); } vector Player::GetQuestIDs(){ vector ret; map::iterator itr; MPlayerQuests.lock(); for(itr = player_quests.begin(); itr != player_quests.end(); itr++){ if(itr->second) ret.push_back(itr->second->GetQuestID()); } MPlayerQuests.unlock(); return ret; } vector* Player::CheckQuestsItemUpdate(Item* item){ vector* quest_updates = 0; map::iterator itr; MPlayerQuests.lock(); 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_updates->push_back(itr->second); } } MPlayerQuests.unlock(); return quest_updates; } void Player::CheckQuestsCraftUpdate(Item* item, int32 qty){ map::iterator itr; vector* update_list = new vector; MPlayerQuests.lock(); for(itr = player_quests.begin(); itr != player_quests.end(); itr++){ if(itr->second){ if(item && qty > 0){ if(itr->second->CheckQuestCraftUpdate(item->details.item_id, qty)){ update_list->push_back(itr->second); } } } } MPlayerQuests.unlock(); if(update_list && update_list->size() > 0){ Client* client = GetZone()->GetClientBySpawn(this); if(client){ for(int8 i=0;isize(); 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::iterator itr; vector* update_list = new vector; MPlayerQuests.lock(); for(itr = player_quests.begin(); itr != player_quests.end(); itr++){ if(itr->second){ if(item && qty > 0){ if(itr->second->CheckQuestHarvestUpdate(item->details.item_id, qty)){ update_list->push_back(itr->second); } } } } MPlayerQuests.unlock(); if(update_list && update_list->size() > 0){ Client* client = GetZone()->GetClientBySpawn(this); if(client){ for(int8 i=0;isize(); i++){ client->SendQuestUpdate(update_list->at(i)); client->SendQuestFailure(update_list->at(i)); } } } update_list->clear(); safe_delete(update_list); } vector* Player::CheckQuestsSpellUpdate(Spell* spell) { vector* quest_updates = 0; map::iterator itr; MPlayerQuests.lock(); 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_updates->push_back(itr->second); } } MPlayerQuests.unlock(); return quest_updates; } PacketStruct* Player::GetQuestJournalPacket(bool all_quests, int16 version, int32 crc, int32 current_quest_id){ PacketStruct* packet = configReader.getStruct("WS_QuestJournalUpdate", version); Quest* quest = 0; if(packet){ int16 total_quests_num = 0; int16 total_completed_quests = 0; map total_quests = player_quests; if(all_quests && completed_quests.size() > 0) total_quests.insert(completed_quests.begin(), completed_quests.end()); MPlayerQuests.lock(); if(total_quests.size() > 0){ map quest_types; map::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::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); display_status += QUEST_DISPLAY_STATUS_COMPLETED; packet->setArrayDataByName("unknown3", 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("visible", 0, i); packet->setArrayDataByName("display_status", display_status, i); i++; } //packet->setDataByName("unknown4", 0); packet->setDataByName("visible_quest_id", current_quest_id); } MPlayerQuests.unlock(); 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) { 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()) 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("unknown3", 1); } 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("visible", 0); packet->setArrayDataByName("display_status", display_status); 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.lock(); if(player_quests.count(id) > 0){ if(player_quests[id]->SetStepComplete(step)) ret = player_quests[id]; } MPlayerQuests.unlock(); return ret; } Quest* Player::AddStepProgress(int32 quest_id, int32 step, int32 progress) { Quest* ret = 0; MPlayerQuests.lock(); if (player_quests.count(quest_id) > 0) { if (player_quests[quest_id]->AddStepProgress(step, progress)) ret = player_quests[quest_id]; } MPlayerQuests.unlock(); return ret; } int32 Player::GetStepProgress(int32 quest_id, int32 step_id) { int32 ret = 0; MPlayerQuests.lock(); if (player_quests.count(quest_id) > 0) ret = player_quests[quest_id]->GetStepProgress(step_id); MPlayerQuests.unlock(); return ret; } void Player::RemoveQuest(int32 id, bool delete_quest){ MPlayerQuests.lock(); if(delete_quest){ safe_delete(player_quests[id]); } player_quests.erase(id); MPlayerQuests.unlock(); SendQuestRequiredSpawns(id); } vector* Player::CheckQuestsLocationUpdate(){ vector* quest_updates = 0; map::iterator itr; MPlayerQuests.lock(); for(itr = player_quests.begin(); itr != player_quests.end(); itr++){ if(itr->second && itr->second->CheckQuestLocationUpdate(GetX(), GetY(), GetZ())){ if(!quest_updates) quest_updates = new vector(); quest_updates->push_back(itr->second); } } MPlayerQuests.unlock(); return quest_updates; } vector* Player::CheckQuestsFailures(){ vector* quest_failures = 0; map::iterator itr; MPlayerQuests.lock(); 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_failures->push_back(itr->second); } } MPlayerQuests.unlock(); return quest_failures; } vector* Player::CheckQuestsKillUpdate(Spawn* spawn, bool update){ vector* quest_updates = 0; map::iterator itr; MPlayerQuests.lock(); 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_updates->push_back(itr->second); } } MPlayerQuests.unlock(); return quest_updates; } vector* Player::CheckQuestsChatUpdate(Spawn* spawn){ vector* quest_updates = 0; map::iterator itr; MPlayerQuests.lock(); 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_updates->push_back(itr->second); } } MPlayerQuests.unlock(); return quest_updates; } int16 Player::GetTaskGroupStep(int32 quest_id){ Quest* quest = 0; int16 step = 0; MPlayerQuests.lock(); if(player_quests.count(quest_id) > 0){ quest = player_quests[quest_id]; step = quest->GetTaskGroupStep(); } MPlayerQuests.unlock(); return step; } bool Player::GetQuestStepComplete(int32 quest_id, int32 step_id){ bool ret = false; MPlayerQuests.lock(); if(player_quests.count(quest_id) > 0){ Quest* quest = player_quests[quest_id]; if ( quest != NULL ) ret = quest->GetQuestStepCompleted(step_id); } MPlayerQuests.unlock(); return ret; } int16 Player::GetQuestStep(int32 quest_id){ Quest* quest = 0; int16 step = 0; MPlayerQuests.lock(); if(player_quests.count(quest_id) > 0){ quest = player_quests[quest_id]; step = quest->GetQuestStep(); } MPlayerQuests.unlock(); return step; } void Player::LockQuests(){ MPlayerQuests.lock(); } void Player::UnlockQuests(){ MPlayerQuests.unlock(); } map* Player::GetPlayerQuests(){ return &player_quests; } map* Player::GetCompletedPlayerQuests(){ return &completed_quests; } 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* quests = spawn->GetProvidedQuests(); Quest* quest = 0; for(int32 i=0;isize();i++){ MPlayerQuests.lock(); 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.unlock(); break; } } MPlayerQuests.unlock(); if (CanReceiveQuest(quests->at(i))){ MPlayerQuests.lock(); quest = master_quest_list.GetQuest(quests->at(i)); MPlayerQuests.unlock(); 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; safe_delete(quest); break; } } } } map::iterator itr; MPlayerQuests.lock(); for(itr = player_quests.begin(); itr != player_quests.end(); itr++){ if(itr->second->CheckQuestChatUpdate(spawn->GetDatabaseID(), false)) ret = 2; } MPlayerQuests.unlock(); if(ret > 0) current_quest_flagged[spawn] = true; return ret; } bool Player::CanReceiveQuest(int32 quest_id){ bool passed = true; int32 x; MPlayerQuests.lock(); Quest* quest = master_quest_list.GetQuest(quest_id); MPlayerQuests.unlock(); 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* prereq_quests = quest->GetPrereqQuests(); if(passed && prereq_quests && prereq_quests->size() > 0){ for(int32 x=0;xsize();x++){ if(completed_quests.count(prereq_quests->at(x)) == 0){ passed = false; break; } } } //Check Prereq Classes vector* prereq_classes = quest->GetPrereqClasses(); if(passed && prereq_classes && prereq_classes->size() > 0){ for(int32 x=0;xsize();x++){ if(prereq_classes->at(x) == GetAdventureClass()){ passed = true; break; } else passed = false; } } //Check Prereq TS Classes vector* prereq_tsclasses = quest->GetPrereqTradeskillClasses(); if(passed && prereq_tsclasses && prereq_tsclasses->size() > 0){ for( x=0;xsize();x++){ if(prereq_tsclasses->at(x) == GetTradeskillClass()){ passed = true; break; } else passed = false; } } // Check model prereq vector* prereq_model_types = quest->GetPrereqModelTypes(); if(passed && prereq_model_types && prereq_model_types->size() > 0){ for(x=0;xsize();x++){ if(prereq_model_types->at(x) == GetModelType()){ passed = true; break; } else passed = false; } } // Check faction pre req vector* prereq_factions = quest->GetPrereqFactions(); if(passed && prereq_factions && prereq_factions->size() > 0){ sint32 val = 0; for(x=0;xsize();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* prereq_races = quest->GetPrereqRaces(); if(passed && prereq_races && prereq_races->size() > 0){ for(x=0;xsize();x++){ if(prereq_races->at(x) == GetRace()){ passed = true; break; } else passed = false; } } safe_delete(quest); return passed; } void Player::ClearRemovedSpawn(Spawn* spawn){ if(player_removed_spawns.count(spawn) > 0) player_removed_spawns.erase(spawn); } bool Player::ShouldSendSpawn(Spawn* spawn){ // Added a try catch to attempt to prevent a zone crash when an invalid spawn is passed to this function. // Think invalid spawns are coming from the mutex list, if spawn is invalid return false. try { if((WasSentSpawn(spawn->GetID()) == false || NeedsSpawnResent(spawn)) && (!spawn->IsPrivateSpawn() || spawn->AllowedAccess(this))) return true; } catch (...) { LogWrite(SPAWN__ERROR, 0, "Spawn", "Invalid spawn passes to player->ShouldSendSpawn()"); } 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()->coin_plat += tmp; } if(val >= 10000){ tmp = val / 10000; val -= tmp*10000; GetInfoStruct()->coin_gold += tmp; } if(val >= 100){ tmp = val / 100; val -= tmp*100; GetInfoStruct()->coin_silver += tmp; } GetInfoStruct()->coin_copper += val; if(GetInfoStruct()->coin_copper >= 100){ tmp = GetInfoStruct()->coin_copper/100; GetInfoStruct()->coin_copper -= 100 * tmp; GetInfoStruct()->coin_silver += tmp; } if(GetInfoStruct()->coin_silver >= 100){ tmp = GetInfoStruct()->coin_silver/100; GetInfoStruct()->coin_silver -= 100 * tmp; GetInfoStruct()->coin_gold += tmp; } if(GetInfoStruct()->coin_gold >= 100){ tmp = GetInfoStruct()->coin_gold/100; GetInfoStruct()->coin_gold -= 100 * tmp; GetInfoStruct()->coin_plat += tmp; } charsheet_changed = true; } bool Player::RemoveCoins(int64 val){ int64 total_coins = GetInfoStruct()->coin_plat*1000000; total_coins += GetInfoStruct()->coin_gold*10000; total_coins += GetInfoStruct()->coin_silver*100; total_coins += GetInfoStruct()->coin_copper; if(total_coins >= val){ total_coins -= val; GetInfoStruct()->coin_plat = 0; GetInfoStruct()->coin_gold = 0; GetInfoStruct()->coin_silver = 0; GetInfoStruct()->coin_copper = 0; AddCoins(total_coins); return true; } return false; } bool Player::HasCoins(int64 val) { int64 total_coins = GetInfoStruct()->coin_plat*1000000; total_coins += GetInfoStruct()->coin_gold*10000; total_coins += GetInfoStruct()->coin_silver*100; total_coins += GetInfoStruct()->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* Player::GetPendingLootItems(int32 id){ vector* ret = 0; if(pending_loot_items.count(id) > 0){ ret = new vector(); map::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* items){ if(items){ Item* item = 0; for(int32 i=0;isize();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::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::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::iterator itr; deque* 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()) { deque* members = world.GetGroupManager()->GetGroupMembers(GetGroupMemberInfo()->group_id); deque::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++; } } //packet->PrintPacket(); world.GetGroupManager()->ReleaseGroupLock(__FUNCTION__, __LINE__); } PlayerItemList* Player::GetPlayerItemList(){ return &item_list; } void Player::ResetSavedSpawns(){ player_removed_spawns.clear(); vis_mutex.writelock(__FUNCTION__, __LINE__); spawn_vis_packet_list.clear(); vis_mutex.releasewritelock(__FUNCTION__, __LINE__); info_mutex.writelock(__FUNCTION__, __LINE__); spawn_info_packet_list.clear(); info_mutex.releasewritelock(__FUNCTION__, __LINE__); pos_mutex.writelock(__FUNCTION__, __LINE__); spawn_pos_packet_list.clear(); pos_mutex.releasewritelock(__FUNCTION__, __LINE__); player_spawn_reverse_id_map.clear(); player_spawn_id_map.clear(); player_spawn_map.clear(); player_spawn_index_map.clear(); m_playerSpawnQuestsRequired.writelock(__FUNCTION__, __LINE__); player_spawn_quests_required.clear(); m_playerSpawnQuestsRequired.releasewritelock(__FUNCTION__, __LINE__); info->RemoveOldPackets(); safe_delete_array(movement_packet); safe_delete_array(old_movement_packet); } void Player::SetReturningFromLD(bool val){ 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* 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* 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) skill_list.CheckSkillIncrease(ret); 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* 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::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;imembers.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::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::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 CharacterInstances::GetLockoutInstances() { vector 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 CharacterInstances::GetPersistentInstances() { vector 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;isize();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()->class1 = classes.GetBaseClass(new_class); GetInfoStruct()->class2 = classes.GetSecondaryBaseClass(new_class); GetInfoStruct()->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(int32 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); 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){ // 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* languages = player_languages_list.GetAllLanguages(); list::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* languages = player_languages_list.GetAllLanguages(); list::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::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::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::iterator itr; for (itr = passive_spells.begin(); itr != passive_spells.end(); itr++) RemoveSpellBookEntry((*itr), false); passive_spells.clear(); } void Player::ResetPetInfo() { GetInfoStruct()->pet_id = 0xFFFFFFFF; strcpy(GetInfoStruct()->pet_name, "No Pet"); GetInfoStruct()->pet_movement = 0; GetInfoStruct()->pet_behavior = 0; GetInfoStruct()->pet_health_pct = 0.0f; GetInfoStruct()->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::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 > >::iterator itr; map >::iterator itr2; vector::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__); Quest* quest = GetQuest(quest_id); 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 spawns = *player_spawn_quests_required[quest_id]; m_playerSpawnQuestsRequired.releasereadlock(__FUNCTION__, __LINE__); Spawn* spawn = 0; vector::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 spawns = *player_spawn_history_required[event_id]; m_playerSpawnHistoryRequired.releasereadlock(__FUNCTION__, __LINE__); Spawn* spawn = 0; vector::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; vector* quest_spawns = player_spawn_quests_required[quest_id]; int32 current_spawn = 0; for(int32 i=0;isize();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; vector* history_spawns = player_spawn_history_required[event_id]; vector::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); } 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* ptr = 0; map >::iterator itr; map::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) { 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); return; } m_charLuaHistory[event_id] = history; } void Player::SaveLUAHistory() { LogWrite(PLAYER__DEBUG, 0, "Player", "Saving LUA History for Player: '%s'", GetName()); map::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; } } } void Player::UpdateLUAHistory(int32 event_id, int32 value, int32 value2) { LUAHistory* hd = 0; if (m_charLuaHistory.count(event_id) > 0) hd = m_charLuaHistory[event_id]; else { hd = new LUAHistory; m_charLuaHistory[event_id] = hd; } hd->Value = value; hd->Value2 = value2; hd->SaveNeeded = true; SendHistoryRequiredSpawns(event_id); } LUAHistory* Player::GetLUAHistory(int32 event_id) { LUAHistory* ret = 0; if (m_charLuaHistory.count(event_id) > 0) ret = m_charLuaHistory[event_id]; 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* 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::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); }