/* 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 #include "World.h" #include "Items/Items.h" #include "Items/Items_ToV.h" #include "Items/Items_DoV.h" #include "Spells.h" #include "client.h" #include "WorldDatabase.h" #include "../common/debug.h" #include "races.h" #include "classes.h" #include "VisualStates.h" #include "Appearances.h" #include "Skills.h" #include "LoginServer.h" #include "Quests.h" #include "Factions.h" #include "Guilds/Guild.h" #include "Collections/Collections.h" #include "Achievements/Achievements.h" #include "Recipes/Recipe.h" #include "Rules/Rules.h" #include "../common/Log.h" #include "Traits/Traits.h" #include "Chat/Chat.h" #include "Tradeskills/Tradeskills.h" #include "AltAdvancement/AltAdvancement.h" #include "LuaInterface.h" #include "HeroicOp/HeroicOp.h" #include "RaceTypes/RaceTypes.h" #include MasterQuestList master_quest_list; MasterItemList master_item_list; MasterSpellList master_spell_list; MasterTraitList master_trait_list; MasterHeroicOPList master_ho_list; MasterSkillList master_skill_list; MasterFactionList master_faction_list; MasterCollectionList master_collection_list; MasterAchievementList master_achievement_list; MasterRecipeList master_recipe_list; MasterRecipeBookList master_recipebook_list; MasterTradeskillEventsList master_tradeskillevent_list; MasterAAList master_aa_list; MasterRaceTypeList race_types_list; MasterAANodeList master_tree_nodes; ClientList client_list; ZoneList zone_list; ZoneAuth zone_auth; int32 Spawn::next_id = 1; int32 WorldDatabase::next_id = 0; Commands commands; Variables variables; VisualStates visual_states; Appearances master_appearance_list; Classes classes; Races races; mapEQOpcodeManager; map EQOpcodeVersions; WorldDatabase database; GuildList guild_list; Chat chat; extern ConfigReader configReader; extern LoginServer loginserver; extern World world; extern RuleManager rule_manager; World::World() : save_time_timer(300000), time_tick_timer(3000), vitality_timer(3600000), player_stats_timer(60000), server_stats_timer(60000), /*remove_grouped_player(30000),*/ guilds_timer(60000), lotto_players_timer(500), watchdog_timer(10000) { save_time_timer.Start(); time_tick_timer.Start(); vitality_timer.Start(); player_stats_timer.Start(); server_stats_timer.Start(); //remove_grouped_player.Start(); guilds_timer.Start(); lotto_players_timer.Start(); watchdog_timer.Start(); xp_rate = -1; ts_xp_rate = -1; vitality_frequency = 0xFFFFFFFF; vitality_amount = -1; last_checked_time = 0; items_loaded = false; spells_loaded = false; achievments_loaded = false; merchant_inventory_items.clear(); MHouseZones.SetName("World::m_houseZones"); MPlayerHouses.SetName("World::m_playerHouses"); MWorldMaps.SetName("World::MWorldMaps"); MWorldRegionMaps.SetName("World::MWorldRegionMaps"); } World::~World(){ // At this point the log system is already shut down so no calls to LogWrite are allowed in any of the functions called by this deconstructor DeleteSpawns(); if(database.GetStatus() == database.Connected) WriteServerStatistics(); RemoveServerStatistics(); DeleteMerchantsInfo(); MutexMap::iterator itr = lotto_players.begin(); while (itr.Next()) safe_delete(itr->second); map::iterator itr2; for (itr2 = m_houseZones.begin(); itr2 != m_houseZones.end(); itr2++) safe_delete(itr2->second); m_houseZones.clear(); tov_itemstat_conversion.clear(); PurgeStartingLists(); PurgeVoiceOvers(); map::iterator itr3; for (itr3 = region_maps.begin(); itr3 != region_maps.end(); itr3++) safe_delete(itr3->second); map::iterator itr4; for (itr4 = maps.begin(); itr4 != maps.end(); itr4++) safe_delete(itr4->second); PurgeNPCSpells(); } void World::init(){ WorldDatabase::next_id = database.GetMaxHotBarID(); LogWrite(COMMAND__DEBUG, 1, "Command", "-Loading Commands..."); database.LoadCommandList(); LogWrite(COMMAND__DEBUG, 1, "Command", "-Load Commands complete!"); LogWrite(FACTION__DEBUG, 1, "Faction", "-Loading Factions..."); database.LoadFactionList(); LogWrite(FACTION__DEBUG, 1, "Faction", "-Load Factions complete!..."); LogWrite(SKILL__DEBUG, 1, "Skill", "-Loading Skills..."); database.LoadSkills(); LogWrite(SKILL__DEBUG, 1, "Skill", "-Load Skills complete..."); LogWrite(WORLD__DEBUG, 1, "World", "-Loading `variables`..."); database.LoadGlobalVariables(); LogWrite(WORLD__DEBUG, 1, "World", "-Load `variables` complete!"); LogWrite(WORLD__DEBUG, 1, "World", "-Loading `appearances`..."); database.LoadAppearanceMasterList(); LogWrite(WORLD__DEBUG, 1, "World", "-Load `appearances` complete!"); LogWrite(WORLD__DEBUG, 1, "World", "-Loading `visual_states`..."); database.LoadVisualStates(); LogWrite(WORLD__DEBUG, 1, "World", "-Load `visual states` complete!"); LoadStartingLists(); LoadVoiceOvers(); LogWrite(WORLD__DEBUG, 1, "World", "-Setting system parameters..."); Variable* var = variables.FindVariable("gametime"); const char* time_string = 0; char default_time[] = "0/0/3800 8:30"; if(var) time_string = var->GetValue(); if(!time_string) time_string = default_time; int year, month, day, hour, minute; sscanf (time_string, "%d/%d/%d %d:%d", &month, &day, &year, &hour, &minute); LogWrite(WORLD__DEBUG, 3, "World", "--Setting World Time to %s...", time_string); world_time.month = month; world_time.day = day; world_time.year = year; world_time.hour = hour; world_time.minute = minute; LogWrite(WORLD__DEBUG, 3, "World", "--Loading Vitality Information..."); LoadVitalityInformation(); LogWrite(WORLD__DEBUG, 3, "World", "--Loading Server Statistics..."); database.LoadServerStatistics(); LogWrite(WORLD__DEBUG, 3, "World", "--Setting Server Start Time..."); UpdateServerStatistic(STAT_SERVER_START_TIME, Timer::GetUnixTimeStamp(), true); LogWrite(WORLD__DEBUG, 3, "World", "--Resetting Accepted Connections to 0..."); UpdateServerStatistic(STAT_SERVER_ACCEPTED_CONNECTION, 0, true); LogWrite(WORLD__DEBUG, 3, "World", "--Resetting Active Zones to 0..."); UpdateServerStatistic(STAT_SERVER_NUM_ACTIVE_ZONES, 0, true); // Clear all online players at server startup LogWrite(WORLD__DEBUG, 3, "World", "--Resetting characters online flags..."); database.ToggleCharacterOnline(); LogWrite(WORLD__DEBUG, 1, "World", "-Set system parameters complete!"); LogWrite(RULESYS__DEBUG, 1, "Rules", "-Loading Rule Sets..."); database.LoadRuleSets(); LogWrite(RULESYS__DEBUG, 1, "Rules", "-Load Rule Sets complete!"); LoadItemBlueStats(); //PopulateTOVStatMap(); group_buff_updates.Start(rule_manager.GetGlobalRule(R_Client, GroupSpellsTimer)->GetInt32()); } PacketStruct* World::GetWorldTime(int16 version){ MWorldTime.readlock(__FUNCTION__, __LINE__); PacketStruct* packet = configReader.getStruct("WS_GameWorldTime", version); if(packet){ packet->setDataByName("year", world_time.year); packet->setDataByName("month", world_time.month); packet->setDataByName("day", world_time.day); packet->setDataByName("hour", world_time.hour); packet->setDataByName("minute", world_time.minute); packet->setDataByName("unknown", 250); packet->setDataByName("unix_time", Timer::GetUnixTimeStamp()); packet->setDataByName("unknown2", 1); } MWorldTime.releasereadlock(__FUNCTION__, __LINE__); return packet; } float World::GetXPRate(){ xp_rate = rule_manager.GetGlobalRule(R_Player, XPMultiplier)->GetFloat(); LogWrite(WORLD__DEBUG, 0, "World", "Setting Global XP Rate to: %.2f", xp_rate); return xp_rate; } float World::GetTSXPRate(){ ts_xp_rate = rule_manager.GetGlobalRule(R_Player, TSXPMultiplier)->GetFloat(); LogWrite(WORLD__DEBUG, 0, "World", "Setting Global Tradeskill XP Rate to: %.2f", ts_xp_rate); return ts_xp_rate; } void World::Process(){ if(last_checked_time > Timer::GetCurrentTime2()) return; last_checked_time = Timer::GetCurrentTime2() + 1000; if(save_time_timer.Check()) { MWorldTime.readlock(__FUNCTION__, __LINE__); database.SaveWorldTime(&world_time); MWorldTime.releasereadlock(__FUNCTION__, __LINE__); } if(time_tick_timer.Check()) { MWorldTime.writelock(__FUNCTION__, __LINE__); WorldTimeTick(); MWorldTime.releasewritelock(__FUNCTION__, __LINE__); } if(vitality_timer.Check()) UpdateVitality(); if (player_stats_timer.Check()) WritePlayerStatistics(); if (server_stats_timer.Check()) WriteServerStatistics(); /*if(remove_grouped_player.Check()) CheckRemoveGroupedPlayer();*/ if (group_buff_updates.Check()) GetGroupManager()->UpdateGroupBuffs(); if (guilds_timer.Check()) SaveGuilds(); if (lotto_players_timer.Check()) CheckLottoPlayers(); if(watchdog_timer.Check()) zone_list.WatchdogHeartbeat(); } vector* World::GetClientVariables(){ return variables.GetVariables("cl_"); } void World::LoadVitalityInformation() { int32 timestamp = Timer::GetUnixTimeStamp(); int32 diff = 0; // fetch vitalitytimer value from `variables` table Variable* timer_var = variables.FindVariable("vitalitytimer"); if(timer_var) { try { diff = timestamp - atoul(timer_var->GetValue()); diff *= 1000; //convert seconds to milliseconds } catch(...) { LogWrite(WORLD__ERROR, 0, "World", "Error parsing vitalitytimer, value: %s", timer_var->GetValue()); } } // Now using Rules System to set vitality parameters vitality_amount = rule_manager.GetGlobalRule(R_Player, VitalityAmount)->GetFloat(); vitality_frequency = rule_manager.GetGlobalRule(R_Player, VitalityFrequency)->GetInt32(); vitality_frequency *= 1000; //convert seconds to milliseconds if(diff >= vitality_frequency) UpdateVitality(); //update now else vitality_timer.SetTimer(vitality_frequency - diff); } void World::UpdateVitality() { // push new vitalitytimer to `variables` table database.UpdateVitality(Timer::GetUnixTimeStamp(), vitality_amount); if(vitality_timer.GetDuration() != vitality_frequency) vitality_timer.SetTimer(vitality_frequency); zone_list.UpdateVitality(vitality_amount); } void ZoneList::UpdateVitality(float amount) { list::iterator zone_iter; ZoneServer* tmp = 0; MZoneList.readlock(__FUNCTION__, __LINE__); for(zone_iter=zlist.begin(); zone_iter!=zlist.end(); zone_iter++) { tmp = *zone_iter; if(tmp) tmp->UpdateVitality(amount); } MZoneList.releasereadlock(__FUNCTION__, __LINE__); } void ZoneList::SendTimeUpdate() { list::iterator zone_iter; ZoneServer* tmp = 0; MZoneList.readlock(__FUNCTION__, __LINE__); for(zone_iter=zlist.begin(); zone_iter!=zlist.end(); zone_iter++) { tmp = *zone_iter; if(tmp && !tmp->isZoneShuttingDown()) tmp->WorldTimeUpdateTrigger(); } MZoneList.releasereadlock(__FUNCTION__, __LINE__); } // should already be ran inside MWorldTime void World::WorldTimeTick(){ world_time.minute++; //I know it looks complicated, but the nested ifs are to avoid checking all of them every 3 seconds if(world_time.minute >= 60){ // >= in case of bad time from db world_time.minute = 0; world_time.hour++; if(world_time.hour >= 24){ world_time.hour = 0; world_time.day++; if(world_time.day>=30){ world_time.day = 0; world_time.month++; if(world_time.month >= 12){ world_time.month = 0; world_time.year++; } } } } } ZoneList::ZoneList() { MZoneList.SetName("ZoneList::MZoneList"); } ZoneList::~ZoneList() { list::iterator zone_iter; ZoneServer* zs = 0; for(zone_iter=zlist.begin(); zone_iter!=zlist.end();){ zs = *zone_iter; zone_iter = zlist.erase(zone_iter); safe_delete(zs); } } void ZoneList::CheckFriendList(Client* client) { LogWrite(WORLD__DEBUG, 0, "World", "Sending FriendList..."); MClientList.lock(); map::iterator itr; for(itr = client_map.begin(); itr != client_map.end(); itr++){ if(itr->second != client && itr->second){ if(itr->second->GetPlayer()->IsFriend(client->GetPlayer()->GetName())){ itr->second->SendFriendList(); itr->second->Message(CHANNEL_COLOR_CHAT_RELATIONSHIP, "Friend: %s has logged in.", client->GetPlayer()->GetName()); } } } MClientList.unlock(); } void ZoneList::CheckFriendZoned(Client* client){ MClientList.lock(); map::iterator itr; for(itr = client_map.begin(); itr != client_map.end(); itr++){ if(itr->second != client && itr->second){ if(itr->second->GetPlayer()->IsFriend(client->GetPlayer()->GetName())){ itr->second->SendFriendList(); } } } MClientList.unlock(); } bool ZoneList::HandleGlobalChatMessage(Client* from, char* to, int16 channel, const char* message, const char* channel_name, int32 current_language_id){ if (!from) { LogWrite(WORLD__ERROR, 0, "World", "HandleGlobalChatMessage() called with an invalid client"); return false; } if(channel == CHANNEL_PRIVATE_TELL){ Client* find_client = zone_list.GetClientByCharName(to); if(!find_client || find_client->GetPlayer()->IsIgnored(from->GetPlayer()->GetName())) return false; else if(find_client == from) { from->Message(CHANNEL_COLOR_RED,"You must be very lonely...(ERROR: Cannot send tell to self)"); } else { const char* whoto = find_client->GetPlayer()->GetName(); find_client->HandleTellMessage(from, message, whoto, from->GetPlayer()->GetCurrentLanguage()); from->HandleTellMessage(from, message, whoto, from->GetPlayer()->GetCurrentLanguage()); if (find_client->GetPlayer()->get_character_flag(CF_AFK)) { find_client->HandleTellMessage(find_client, find_client->GetPlayer()->GetAwayMessage().c_str(),whoto, from->GetPlayer()->GetCurrentLanguage()); from->HandleTellMessage(find_client, find_client->GetPlayer()->GetAwayMessage().c_str(),whoto, from->GetPlayer()->GetCurrentLanguage()); } } } else if(channel == CHANNEL_GROUP_SAY) { GroupMemberInfo* gmi = from->GetPlayer()->GetGroupMemberInfo(); if(gmi) world.GetGroupManager()->GroupMessage(gmi->group_id, message); } else{ list::iterator zone_iter; ZoneServer* zs = 0; MZoneList.readlock(__FUNCTION__, __LINE__); for(zone_iter=zlist.begin(); zone_iter!=zlist.end();zone_iter++){ zs = *zone_iter; if(zs) zs->HandleChatMessage(from->GetPlayer(), to, channel, message, 0, channel_name, true, current_language_id); } MZoneList.releasereadlock(__FUNCTION__, __LINE__); } return true; } void ZoneList::LoadSpellProcess(){ list::iterator zone_iter; ZoneServer* zone = 0; MZoneList.readlock(__FUNCTION__, __LINE__); for (zone_iter=zlist.begin(); zone_iter!=zlist.end();zone_iter++){ zone = *zone_iter; if (zone) zone->LoadSpellProcess(); } MZoneList.releasereadlock(__FUNCTION__, __LINE__); } void ZoneList::DeleteSpellProcess(){ list::iterator zone_iter; ZoneServer* zone = 0; MZoneList.readlock(__FUNCTION__, __LINE__); for (zone_iter=zlist.begin(); zone_iter!=zlist.end();zone_iter++){ zone = *zone_iter; if (zone) zone->DeleteSpellProcess(); } MZoneList.releasereadlock(__FUNCTION__, __LINE__); } void ZoneList::HandleGlobalBroadcast(const char* message) { list::iterator zone_iter; ZoneServer* zone = 0; MZoneList.readlock(__FUNCTION__, __LINE__); for (zone_iter=zlist.begin(); zone_iter!=zlist.end();zone_iter++){ zone = *zone_iter; if (zone) zone->HandleBroadcast(message); } MZoneList.releasereadlock(__FUNCTION__, __LINE__); } void ZoneList::HandleGlobalAnnouncement(const char* message) { list::iterator zone_iter; ZoneServer* zone = 0; MZoneList.readlock(__FUNCTION__, __LINE__); for (zone_iter=zlist.begin(); zone_iter!=zlist.end();zone_iter++){ zone = *zone_iter; if (zone) zone->HandleAnnouncement(message); } MZoneList.releasereadlock(__FUNCTION__, __LINE__); } int32 ZoneList::Count(){ return zlist.size(); } void ZoneList::Add(ZoneServer* zone) { MZoneList.writelock(__FUNCTION__, __LINE__); zlist.push_back(zone); MZoneList.releasewritelock(__FUNCTION__, __LINE__); } void ZoneList::Remove(ZoneServer* zone) { const char* zoneName = zone->GetZoneName(); MZoneList.writelock(__FUNCTION__, __LINE__); zlist.remove(zone); MZoneList.releasewritelock(__FUNCTION__, __LINE__); ZoneServer* alternativeZone = Get(zoneName, false, false); if(!alternativeZone && !rule_manager.GetGlobalRule(R_World, MemoryCacheZoneMaps)->GetBool()) { world.RemoveMaps(std::string(zoneName)); } } ZoneServer* ZoneList::Get(const char* zone_name, bool loadZone, bool skip_existing_zones) { list::iterator zone_iter; ZoneServer* tmp = 0; ZoneServer* ret = 0; if(!skip_existing_zones) { MZoneList.readlock(__FUNCTION__, __LINE__); for(zone_iter=zlist.begin(); zone_iter!=zlist.end(); zone_iter++){ tmp = *zone_iter; if (!tmp->isZoneShuttingDown() && !tmp->IsInstanceZone() && strlen(zone_name) == strlen(tmp->GetZoneName()) && strncasecmp(tmp->GetZoneName(), zone_name, strlen(zone_name))==0){ if(tmp->NumPlayers() < 30 || tmp->IsCityZone()) ret = tmp; break; } } MZoneList.releasereadlock(__FUNCTION__, __LINE__); } if(!ret ) { if ( loadZone ) { ret = new ZoneServer(zone_name, true); database.LoadZoneInfo(ret); ret->Init(); } } else if(ret && loadZone) { ret->IncrementIncomingClients(); } return ret; } ZoneServer* ZoneList::Get(int32 id, bool loadZone, bool skip_existing_zones) { list::iterator zone_iter; ZoneServer* tmp = 0; ZoneServer* ret = 0; if(!skip_existing_zones) { MZoneList.readlock(__FUNCTION__, __LINE__); for(zone_iter=zlist.begin(); zone_iter!=zlist.end(); zone_iter++){ tmp = *zone_iter; if(!tmp->isZoneShuttingDown() && !tmp->IsInstanceZone() && tmp->GetZoneID() == id){ if(tmp->NumPlayers() < 30 || tmp->IsCityZone()) ret = tmp; break; } } MZoneList.releasereadlock(__FUNCTION__, __LINE__); } if(ret) tmp = ret; else if (loadZone) { string zonename = database.GetZoneName(id); if(zonename.length() >0){ tmp = new ZoneServer(zonename.c_str()); database.LoadZoneInfo(tmp); tmp->Init(); } } return tmp; } void ZoneList::SendZoneList(Client* client) { list::iterator zone_iter; ZoneServer* tmp = 0; MZoneList.readlock(__FUNCTION__, __LINE__); int zonesListed = 0; for(zone_iter=zlist.begin(); zone_iter!=zlist.end(); zone_iter++){ tmp = *zone_iter; if ( zonesListed > 20 ) { client->Message(CHANNEL_COLOR_YELLOW,"Reached max zone list of 20."); break; } zonesListed++; client->Message(CHANNEL_COLOR_YELLOW,"Zone(ID): %s(%i), Instance ID: %i, Description: %s.",tmp->GetZoneName(),tmp->GetZoneID(), tmp->GetInstanceID(),tmp->GetZoneDescription()); } MZoneList.releasereadlock(__FUNCTION__, __LINE__); } ZoneServer* ZoneList::GetByInstanceID(int32 id, int32 zone_id, bool skip_existing_zones) { list::iterator zone_iter; ZoneServer* tmp = 0; ZoneServer* ret = 0; if(!skip_existing_zones) { MZoneList.readlock(__FUNCTION__, __LINE__); if ( id > 0 ) { for(zone_iter=zlist.begin(); zone_iter!=zlist.end(); zone_iter++){ tmp = *zone_iter; if(tmp->GetInstanceID() == id){ ret = tmp; break; } } } MZoneList.releasereadlock(__FUNCTION__, __LINE__); } if(ret) tmp = ret; else if ( zone_id > 0 ){ string zonename = database.GetZoneName(zone_id); if(zonename.length() > 0){ tmp = new ZoneServer(zonename.c_str()); // the player is trying to preload an already existing instance but it isn't loaded if ( id > 0 ) tmp->SetupInstance(id); database.LoadZoneInfo(tmp); tmp->Init(); } } return tmp; } ZoneServer* ZoneList::GetByLowestPopulation(int32 zone_id) { ZoneServer* ret = 0; ZoneServer* zone = 0; int32 clients = 0; list::iterator itr; MZoneList.readlock(__FUNCTION__, __LINE__); if (zone_id) { for (itr = zlist.begin(); itr != zlist.end(); itr++) { zone = *itr; if (zone) { // check the zone id's if (zone->GetZoneID() == zone_id) { // check this zones client count if (clients == 0 || zone->GetClientCount() < clients) { ret = zone; clients = zone->GetClientCount(); } } } } } MZoneList.releasereadlock(__FUNCTION__, __LINE__); return ret; } bool ZoneList::ClientConnected(int32 account_id){ bool ret = false; map::iterator itr; MClientList.lock(); for(itr=client_map.begin(); itr != client_map.end(); itr++){ if(itr->second && itr->second->GetAccountID() == account_id && itr->second->getConnection() && itr->second->getConnection()->GetState() != CLOSING && itr->second->getConnection()->GetState() != CLOSED && (itr->second->GetPlayer()->GetActivityStatus() & ACTIVITY_STATUS_LINKDEAD) == 0){ ret = true; break; } else if(!itr->second){ client_map.erase(itr); if(client_map.size() > 0){ itr=client_map.begin(); if(itr == client_map.end()){ if(itr->second && itr->second->GetAccountID() == account_id && (itr->second->GetPlayer()->GetActivityStatus() & ACTIVITY_STATUS_LINKDEAD) == 0) ret = true; break; } } else break; } } MClientList.unlock(); return ret; } void ZoneList::RemoveClientZoneReference(ZoneServer* zone){ map::iterator itr; MClientList.lock(); for(itr=client_map.begin(); itr != client_map.end(); itr++){ if(itr->second) { if(itr->second->GetCurrentZone() == zone) { itr->second->SetCurrentZone(nullptr); } if(itr->second->GetZoningDestination() == zone) { itr->second->SetZoningDestination(nullptr); } } } MClientList.unlock(); list::iterator zone_iter; ZoneServer* tmp = 0; MZoneList.readlock(__FUNCTION__, __LINE__); for(zone_iter=zlist.begin(); zone_iter!=zlist.end(); zone_iter++){ tmp = *zone_iter; if(tmp) tmp->RemoveClientsFromZone(zone); } MZoneList.releasereadlock(__FUNCTION__, __LINE__); } void ZoneList::ReloadClientQuests(){ list::iterator zone_iter; ZoneServer* tmp = 0; MZoneList.readlock(__FUNCTION__, __LINE__); for(zone_iter=zlist.begin(); zone_iter!=zlist.end(); zone_iter++){ tmp = *zone_iter; if(tmp) tmp->ReloadClientQuests(); } MZoneList.releasereadlock(__FUNCTION__, __LINE__); } void ZoneList::ProcessWhoQuery(vector* queries, ZoneServer* zone, vector* players, bool isGM){ Entity* player = 0; bool add_player = true; bool found_match = false; int8 lower = 0; int8 upper = 0; vector tmpPlayers; vector::iterator spawn_iter; if(!zone->isZoneShuttingDown()){ tmpPlayers = zone->GetPlayers(); for(spawn_iter = tmpPlayers.begin(); spawn_iter!=tmpPlayers.end(); spawn_iter++){ player = *spawn_iter; add_player = true; Client* find_client = zone_list.GetClientByCharName(player->GetName()); if (find_client == NULL) continue; int flags = find_client->GetPlayer()->GetInfoStruct()->get_flags(); int flags2 = find_client->GetPlayer()->GetInfoStruct()->get_flags2(); for(int32 i=0;add_player && queries && isize();i++){ found_match = false; if(queries->at(i) == "ALL") continue; if(queries->at(i).length() > 3 && classes.GetClassID(queries->at(i).c_str()) > 0){ if(player->GetAdventureClass() != classes.GetClassID(queries->at(i).c_str())) add_player = false; found_match = true; } else if(queries->at(i).length() > 2 && races.GetRaceID(queries->at(i).c_str()) > 0){ if(player->GetRace() != races.GetRaceID(queries->at(i).c_str())) add_player = false; found_match = true; } if(!found_match && queries->at(i) == "GOOD"){ if(player->GetDeity() != 1) add_player = false; found_match = true; } else if(!found_match && queries->at(i) == "EVIL"){ if(player->GetDeity() == 1) add_player = false; found_match = true; } if((queries->at(i) == "GUIDE") && (find_client->GetAdminStatus() > 0) && ((find_client->GetAdminStatus() >> 4) < 5)) found_match = true; else if((queries->at(i) == "GM") && ((find_client->GetAdminStatus() >> 4) > 4)) found_match = true; else if((queries->at(i) == "LFG") && (flags & (1 << CF_LFG))) found_match = true; else if((queries->at(i) == "LFW") && (flags & (1 << CF_LFW))) found_match = true; else if((queries->at(i) == "ROLEPLAYING") && (flags & (1 << CF_ROLEPLAYING))) found_match = true; else if(strspn(queries->at(i).c_str(),"0123456789") == queries->at(i).length()){ try{ if(lower == 0) lower = atoi(queries->at(i).c_str()); else upper = atoi(queries->at(i).c_str()); } catch(...){} found_match = true; } if(!found_match){ string name = string(player->GetName()); name = ToUpper(name); if(name.find(queries->at(i)) == name.npos) add_player = false; } } if(lower > 0 && upper > 0){ if(player->GetLevel() < lower || player->GetLevel() > upper) add_player = false; } else if(lower > 0){ if(player->GetLevel() != lower) add_player = false; } if((flags2 & (1 << (CF_GM_HIDDEN - 32))) && !isGM) { add_player = false; found_match = true; } if(add_player) players->push_back(player); } } } void ZoneList::ProcessWhoQuery(const char* query, Client* client){ list::iterator zone_iter; vector players; vector::iterator spawn_iter; Entity* player = 0; //for now display all clients bool all = false; vector* queries = 0; bool isGM = ((client->GetAdminStatus() >> 4) > 4); if(query){ string query_string = string(query); query_string = ToUpper(query_string); queries = SplitString(query_string, ' '); } if(queries && queries->size() > 0 && queries->at(0) == "ALL") all = true; if(all){ MZoneList.readlock(__FUNCTION__, __LINE__); for(zone_iter=zlist.begin(); zone_iter!=zlist.end(); zone_iter++){ ZoneServer* tmp = *zone_iter; ProcessWhoQuery(queries, tmp, &players, isGM); } MZoneList.releasereadlock(__FUNCTION__, __LINE__); } else{ ProcessWhoQuery(queries, client->GetCurrentZone(), &players, isGM); } PacketStruct* packet = configReader.getStruct("WS_WhoQueryReply", client->GetVersion()); if(packet){ packet->setDataByName("account_id", client->GetAccountID()); packet->setDataByName("unknown", 0xFFFFFFFF); int8 num_characters = players.size(); int8 max_who_results = 10; int8 max_who_results_status_override = 100; Variable* var = variables.FindVariable("max_who_results_status_override"); if ( var ){ max_who_results_status_override = atoi(var->GetValue()); } // AdnaeDMorte if ( client->GetAdminStatus() >= max_who_results_status_override ){ client->Message(CHANNEL_COLOR_RED, "** ADMIN-MODE ** "); } Variable* var1 = variables.FindVariable("max_who_results"); if ( var1 ){ max_who_results = atoi(var1->GetValue()); } if(num_characters > max_who_results && client->GetAdminStatus() < max_who_results_status_override){ num_characters = max_who_results; packet->setDataByName("response", 3); //response 1 = error message, 3 == capped } else packet->setDataByName("response", 2); packet->setArrayLengthByName("num_characters", num_characters); packet->setDataByName("unknown10", 1); int i=0; for(spawn_iter = players.begin(); spawn_iter!=players.end(); spawn_iter++, i++){ if(i == num_characters) break; player = *spawn_iter; Client* find_client = zone_list.GetClientByCharName(player->GetName()); int flags = find_client->GetPlayer()->GetInfoStruct()->get_flags(); int flags2 = find_client->GetPlayer()->GetInfoStruct()->get_flags2(); packet->setArrayDataByName("char_name", player->GetName(), i); packet->setArrayDataByName("level", player->GetLevel(), i); packet->setArrayDataByName("admin_level", ((flags2 & (1 << (CF_HIDE_STATUS - 32))) && !isGM)?0:(find_client->GetAdminStatus() >> 4), i); packet->setArrayDataByName("class", player->GetAdventureClass(), i); packet->setArrayDataByName("unknown4", 0xFF, i); //probably tradeskill class packet->setArrayDataByName("flags", (((flags >> CF_ANONYMOUS) & 1) << 0 ) | (((flags >> CF_LFG) & 1) << 1 ) | (((flags >> CF_ANONYMOUS) & 1) << 2 ) | /*(((flags >> CF_HIDDEN) & 1) << 3 ) |*/ (((flags >> CF_ROLEPLAYING) & 1) << 4 ) | (((flags >> CF_AFK) & 1) << 5 ) | (((flags >> CF_LFW) & 1) << 6 ) /*| (((flags >> CF_NOTA) & 1) << 7 )*/, i); packet->setArrayDataByName("race", player->GetRace(), i); if(player->GetZone() && player->GetZone()->GetZoneDescription()) packet->setArrayDataByName("zone", player->GetZone()->GetZoneDescription(), i); if(player->appearance.sub_title) { int32 sub_title_length = strlen(player->appearance.sub_title); char tmp_title[255]; int32 index = 0; int32 index_tmp = 0; while (index < sub_title_length) { if (player->appearance.sub_title[index] != '<' && player->appearance.sub_title[index] != '>') { memcpy(tmp_title + index_tmp, player->appearance.sub_title + index, 1); index_tmp++; } index++; } tmp_title[index_tmp] = '\0'; packet->setArrayDataByName("guild", tmp_title, i); } } client->QueuePacket(packet->serialize()); safe_delete(packet); } } bool ZoneList::DepopFinished(){ list::iterator zone_iter; MZoneList.readlock(__FUNCTION__, __LINE__); bool finished_depop = true; for(zone_iter=zlist.begin(); zone_iter!=zlist.end(); zone_iter++){ if(!(*zone_iter)->FinishedDepop()) finished_depop = false; } MZoneList.releasereadlock(__FUNCTION__, __LINE__); return finished_depop; } void ZoneList::Depop(){ list::iterator zone_iter; MZoneList.readlock(__FUNCTION__, __LINE__); for(zone_iter=zlist.begin(); zone_iter!=zlist.end(); zone_iter++){ (*zone_iter)->Depop(); } MZoneList.releasereadlock(__FUNCTION__, __LINE__); } void ZoneList::Repop(){ list::iterator zone_iter; MZoneList.readlock(__FUNCTION__, __LINE__); for(zone_iter=zlist.begin(); zone_iter!=zlist.end(); zone_iter++){ (*zone_iter)->Depop(false, true); } MZoneList.releasereadlock(__FUNCTION__, __LINE__); } void ZoneList::ReloadSpawns() { MZoneList.readlock(__FUNCTION__, __LINE__); list::iterator itr; for (itr = zlist.begin(); itr != zlist.end(); itr++) (*itr)->ReloadSpawns(); MZoneList.releasereadlock(__FUNCTION__, __LINE__); } bool World::ReportBug(string data, char* player_name, int32 account_id, const char* spawn_name, int32 spawn_id, int32 zone_id){ //loginserver vector list; int32 offset = 0; int32 old_offset = 0; while((offset = data.find(7, old_offset+1)) < 0xFFFFFFFF){ if(old_offset > 0) list.push_back(data.substr(old_offset+1, offset-old_offset-1)); else list.push_back(data.substr(old_offset, offset)); old_offset = offset; } if(list.size() > 0 && list.size() < 7){ string output = "Invalid bug list:\n"; for(int32 i=0;ipBuffer; if (list.size() < 7) { strncpy(report->category, "AutoBug", 7); strncpy(report->subcategory, "AutoGenerate", 12); strncpy(report->causes_crash, "N", 1); strncpy(report->reproducible, "Y", 1); strncpy(report->summary, data.c_str(), data.length() > 127 ? 127 : data.length()); strncpy(report->description, data.c_str(), data.length() > 1999 ? 1999 : data.length()); strncpy(report->version, "CUR", 3); } else { strncpy(report->category, list[0].c_str(), list[0].length() > 63 ? 63 : list[0].length()); strncpy(report->subcategory, list[1].c_str(), list[1].length() > 63 ? 63 : list[1].length()); strncpy(report->causes_crash, list[2].c_str(), list[2].length() > 63 ? 63 : list[2].length()); strncpy(report->reproducible, list[3].c_str(), list[3].length() > 63 ? 63 : list[3].length()); strncpy(report->summary, list[4].c_str(), list[4].length() > 127 ? 127 : list[4].length()); strncpy(report->description, list[5].c_str(), list[5].length() > 1999 ? 1999 : list[5].length()); strncpy(report->version, list[6].c_str(), list[6].length() > 31 ? 31 : list[6].length()); } strncpy(report->player, player_name, strlen(player_name) > 63 ? 63 : strlen(player_name)); strncpy(report->spawn_name, spawn_name, strlen(spawn_name) > 63 ? 63 : strlen(spawn_name)); report->spawn_id = spawn_id; report->account_id = account_id; report->zone_id = zone_id; loginserver.SendPacket(outpack); database.SaveBugReport(report->category, report->subcategory, report->causes_crash, report->reproducible, report->summary, report->description, report->version, report->player, account_id, spawn_name, spawn_id, zone_id); safe_delete(outpack); return true; } void ZoneList::WritePlayerStatistics() { list::iterator zone_itr; MZoneList.readlock(__FUNCTION__, __LINE__); for (zone_itr = zlist.begin(); zone_itr != zlist.end(); zone_itr++) (*zone_itr)->WritePlayerStatistics(); MZoneList.releasereadlock(__FUNCTION__, __LINE__); } void ZoneList::ShutDownZones(){ LogWrite(WORLD__INFO, 0, "World", "Shutting down all zones, please wait..."); list::iterator zone_itr; int32 size = 0; MZoneList.readlock(__FUNCTION__, __LINE__); for (zone_itr = zlist.begin(); zone_itr != zlist.end(); zone_itr++){ (*zone_itr)->Shutdown(); } size = zlist.size(); MZoneList.releasereadlock(__FUNCTION__, __LINE__); while(size > 0){ Sleep(10); MZoneList.readlock(__FUNCTION__, __LINE__); size = zlist.size(); MZoneList.releasereadlock(__FUNCTION__, __LINE__); } LogWrite(WORLD__INFO, 0, "World", "Zone shutdown complete"); } void ZoneList::ReloadMail() { map::iterator itr; MClientList.writelock(__FUNCTION__, __LINE__); for (itr = client_map.begin(); itr != client_map.end(); itr++) { itr->second->GetPlayer()->DeleteMail(); database.LoadPlayerMail(itr->second); } MClientList.releasewritelock(__FUNCTION__, __LINE__); } void World::AddSpawnScript(int32 id, const char* name){ MSpawnScripts.lock(); if(name) spawn_scripts[id] = string(name); MSpawnScripts.unlock(); } void World::AddSpawnEntryScript(int32 id, const char* name){ MSpawnScripts.lock(); if(name) spawnentry_scripts[id] = string(name); MSpawnScripts.unlock(); } void World::AddSpawnLocationScript(int32 id, const char* name){ MSpawnScripts.lock(); if(name) spawnlocation_scripts[id] = string(name); MSpawnScripts.unlock(); } void World::AddZoneScript(int32 id, const char* name) { MZoneScripts.lock(); if (name) zone_scripts[id] = string(name); MZoneScripts.unlock(); } const char* World::GetSpawnScript(int32 id){ LogWrite(SPAWN__TRACE, 1, "Spawn", "Enter %s", __FUNCTION__); const char* ret = 0; MSpawnScripts.lock(); if(spawn_scripts.count(id) > 0) ret = spawn_scripts[id].c_str(); MSpawnScripts.unlock(); LogWrite(SPAWN__TRACE, 1, "Spawn", "Exit %s", __FUNCTION__); return ret; } const char* World::GetSpawnEntryScript(int32 id){ LogWrite(SPAWN__TRACE, 1, "Spawn", "Enter %s", __FUNCTION__); const char* ret = 0; MSpawnScripts.lock(); if(spawnentry_scripts.count(id) > 0) ret = spawnentry_scripts[id].c_str(); MSpawnScripts.unlock(); LogWrite(SPAWN__TRACE, 1, "Spawn", "Exit %s", __FUNCTION__); return ret; } const char* World::GetSpawnLocationScript(int32 id){ LogWrite(SPAWN__TRACE, 1, "Spawn", "Enter %s", __FUNCTION__); const char* ret = 0; MSpawnScripts.lock(); if(spawnlocation_scripts.count(id) > 0) ret = spawnlocation_scripts[id].c_str(); MSpawnScripts.unlock(); LogWrite(SPAWN__TRACE, 1, "Spawn", "Exit %s", __FUNCTION__); return ret; } const char* World::GetZoneScript(int32 id) { const char* ret = 0; MZoneScripts.lock(); if (zone_scripts.count(id) > 0) ret = zone_scripts[id].c_str(); MZoneScripts.unlock(); return ret; } void World::ResetSpawnScripts(){ MSpawnScripts.lock(); spawn_scripts.clear(); spawnentry_scripts.clear(); spawnlocation_scripts.clear(); MSpawnScripts.unlock(); } void World::ResetZoneScripts() { MZoneScripts.lock(); zone_scripts.clear(); MZoneScripts.unlock(); } vector* World::GetMerchantItemList(int32 merchant_id, int8 merchant_type, Player* player) { vector* ret = 0; MMerchantList.lock(); if(merchant_info.count(merchant_id) > 0) { MerchantInfo* info = merchant_info[merchant_id]; vector::iterator itr; int32 inventory_id = 0; Item* item = 0; for(int i=info->inventory_ids.size()-1;i>=0;i--) { inventory_id = info->inventory_ids[i]; if(merchant_inventory_items.count(inventory_id) > 0) { for(itr = merchant_inventory_items[inventory_id].begin(); itr != merchant_inventory_items[inventory_id].end(); itr++) { if(!ret) ret = new vector; item = master_item_list.GetItem((*itr).item_id); // if NOT spell merchant, OR // skill req is any skill, OR player has the skill, AND // skill req2 is any skill, OR player has the skill2 if(item && ( (merchant_type & MERCHANT_TYPE_SPELLS) == 0 || ( (item->generic_info.skill_req1 == 0xFFFFFFFF || player->GetSkills()->HasSkill(item->generic_info.skill_req1)) && (item->generic_info.skill_req2 == 0xFFFFFFFF || player->GetSkills()->HasSkill(item->generic_info.skill_req2)) ) ) ) (*ret).push_back(*itr); } } } } MMerchantList.unlock(); return ret; } vector* World::GetMerchantList(int32 merchant_id){ vector* ret = 0; MMerchantList.lock(); if(merchant_info.count(merchant_id) > 0){ MerchantInfo* info = merchant_info[merchant_id]; map::iterator itr; int32 inventory_id = 0; for(int i=info->inventory_ids.size()-1;i>=0;i--){ inventory_id = info->inventory_ids[i]; if(merchant_inventory_items.count(inventory_id) > 0){ ret = &merchant_inventory_items[inventory_id]; } } } MMerchantList.unlock(); return ret; } void World::AddMerchantItem(int32 inventory_id, MerchantItemInfo ItemInfo){ MMerchantList.lock(); merchant_inventory_items[inventory_id].push_back(ItemInfo); MMerchantList.unlock(); } void World::DeleteMerchantItems(){ MMerchantList.lock(); merchant_inventory_items.clear(); MMerchantList.unlock(); } void World::RemoveMerchantItem(int32 inventory_id, int32 item_id){ MMerchantList.lock(); if(merchant_inventory_items.count(inventory_id) > 0) { vector::iterator itr; for(itr = merchant_inventory_items[inventory_id].begin(); itr != merchant_inventory_items[inventory_id].end(); itr++){ if ((*itr).item_id == item_id) { merchant_inventory_items[inventory_id].erase(itr); break; } } } MMerchantList.unlock(); } int16 World::GetMerchantItemQuantity(int32 merchant_id, int32 item_id){ int16 amount = 0; int32 inventory_id = GetInventoryID(merchant_id, item_id); if(inventory_id > 0){ MMerchantList.lock(); vector::iterator itr; for(itr = merchant_inventory_items[inventory_id].begin(); itr != merchant_inventory_items[inventory_id].end(); itr++){ if ((*itr).item_id == item_id) amount = (*itr).quantity; } MMerchantList.unlock(); } return amount; } int32 World::GetInventoryID(int32 merchant_id, int32 item_id){ int32 ret = 0; MMerchantList.lock(); if(merchant_info.count(merchant_id) > 0){ MerchantInfo* info = merchant_info[merchant_id]; vector::iterator itr; int32 inventory_id = 0; for(int i=info->inventory_ids.size()-1;i>=0;i--){ inventory_id = info->inventory_ids[i]; if(merchant_inventory_items.count(inventory_id) > 0){ for(itr = merchant_inventory_items[inventory_id].begin(); itr != merchant_inventory_items[inventory_id].end(); itr++){ if((*itr).item_id == item_id){ ret = inventory_id; break; } } if(ret > 0) break; } } } MMerchantList.unlock(); return ret; } void World::DecreaseMerchantQuantity(int32 merchant_id, int32 item_id, int16 amount){ int16 total_left = GetMerchantItemQuantity(merchant_id, item_id); if(total_left > 0 && total_left < 0xFF){ int32 inventory_id = GetInventoryID(merchant_id, item_id); if(inventory_id > 0){ MMerchantList.lock(); vector::iterator itr; for(itr = merchant_inventory_items[inventory_id].begin(); itr != merchant_inventory_items[inventory_id].end(); itr++){ if ((*itr).item_id == item_id) { if(total_left <= amount) { merchant_inventory_items[inventory_id].erase(itr); amount = 0; break; } else (*itr).quantity -= amount; amount = (*itr).quantity; } } MMerchantList.unlock(); } } } MerchantInfo* World::GetMerchantInfo(int32 merchant_id){ MerchantInfo* ret = 0; MMerchantList.lock(); if(merchant_info.count(merchant_id) > 0) ret = merchant_info[merchant_id]; MMerchantList.unlock(); return ret; } void World::AddMerchantInfo(int32 merchant_id, MerchantInfo* info){ MMerchantList.lock(); if(merchant_info.count(merchant_id) > 0){ safe_delete(merchant_info[merchant_id]); } merchant_info[merchant_id] = info; MMerchantList.unlock(); } map* World::GetMerchantInfo() { return &merchant_info; } void World::DeleteMerchantsInfo(){ MMerchantList.lock(); map::iterator itr; for(itr = merchant_info.begin(); itr != merchant_info.end(); itr++){ safe_delete(itr->second); } merchant_info.clear(); MMerchantList.unlock(); } void World::DeleteSpawns(){ //reloading = true; //ClearLootTables(); /* map::iterator npc_list_iter; for(npc_list_iter=npc_list.begin();npc_list_iter!=npc_list.end();npc_list_iter++) { safe_delete(npc_list_iter->second); } npc_list.clear(); map::iterator object_list_iter; for(object_list_iter=object_list.begin();object_list_iter!=object_list.end();object_list_iter++) { safe_delete(object_list_iter->second); } object_list.clear(); map::iterator groundspawn_list_iter; for(groundspawn_list_iter=groundspawn_list.begin();groundspawn_list_iter!=groundspawn_list.end();groundspawn_list_iter++) { safe_delete(groundspawn_list_iter->second); } groundspawn_list.clear(); map::iterator widget_list_iter; for(widget_list_iter=widget_list.begin();widget_list_iter!=widget_list.end();widget_list_iter++) { safe_delete(widget_list_iter->second); } widget_list.clear(); map::iterator sign_list_iter; for(sign_list_iter=sign_list.begin();sign_list_iter!=sign_list.end();sign_list_iter++) { safe_delete(sign_list_iter->second); } sign_list.clear();*/ map::iterator appearance_list_iter; for(appearance_list_iter=npc_appearance_list.begin();appearance_list_iter!=npc_appearance_list.end();appearance_list_iter++) { safe_delete(appearance_list_iter->second); } npc_appearance_list.clear(); /* map* >::iterator command_list_iter; for(command_list_iter=entity_command_list.begin();command_list_iter!=entity_command_list.end();command_list_iter++) { vector* v = command_list_iter->second; if(v){ for(int32 i=0;isize();i++){ safe_delete(v->at(i)); } safe_delete(v); } } entity_command_list.clear(); */ //DeleteGroundSpawnItems(); //DeleteTransporters(); //DeleteTransporterMaps(); } void World::ReloadGuilds() { guild_list.GetGuilds()->clear(true); database.LoadGuilds(); } int8 World::GetClassID(const char* name){ return classes.GetClassID(name); } void World::WritePlayerStatistics() { zone_list.WritePlayerStatistics(); } void World::WriteServerStatistics() { map::iterator itr; Statistic* stat = 0; for (itr = server_statistics.begin(); itr != server_statistics.end(); itr++) { stat = itr->second; if (stat->save_needed) { stat->save_needed = false; database.WriteServerStatistic(stat); } } database.WriteServerStatisticsNeededQueries(); } void World::AddServerStatistic(int32 stat_id, sint32 stat_value, int32 stat_date) { if (server_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; server_statistics[stat_id] = stat; } } void World::UpdateServerStatistic(int32 stat_id, sint32 stat_value, bool overwrite) { if (server_statistics.count(stat_id) == 0) AddServerStatistic(stat_id, stat_value, 0); Statistic* stat = server_statistics[stat_id]; overwrite == true ? stat->stat_value = stat_value : stat->stat_value += stat_value; stat->stat_date = Timer::GetUnixTimeStamp(); stat->save_needed = true; } sint32 World::GetServerStatisticValue(int32 stat_id) { if (server_statistics.count(stat_id) > 0) return server_statistics[stat_id]->stat_value; return 0; } void World::RemoveServerStatistics() { map::iterator stat_itr; for (stat_itr = server_statistics.begin(); stat_itr != server_statistics.end(); stat_itr++) safe_delete(stat_itr->second); server_statistics.clear(); } void World::SendGroupQuests(PlayerGroup* group, Client* client){ return; /*if(!group) return; GroupMemberInfo* info = 0; MGroups.readlock(__FUNCTION__, __LINE__); deque::iterator itr; for(itr = group->members.begin(); itr != group->members.end(); itr++){ info = *itr; if(info->client){ LogWrite(PLAYER__DEBUG, 0, "Player", "Send Quest Journal..."); info->client->SendQuestJournal(false, client); client->SendQuestJournal(false, info->client); } } MGroups.releasereadlock(__FUNCTION__, __LINE__);*/ } /*void World::CheckRemoveGroupedPlayer(){ map::iterator itr; GroupMemberInfo* found = 0; MGroups.readlock(__FUNCTION__, __LINE__); for(itr = group_removal_pending.begin(); itr != group_removal_pending.end(); itr++){ if(itr->second < Timer::GetCurrentTime2()){ found = itr->first; break; } } MGroups.releasereadlock(__FUNCTION__, __LINE__); if(found){ if(!found->client || (found->client && found->client->IsConnected() == false)) DeleteGroupMember(found); else{ MGroups.writelock(__FUNCTION__, __LINE__); group_removal_pending.erase(found); MGroups.releasewritelock(__FUNCTION__, __LINE__); } } }*/ bool World::RejoinGroup(Client* client, int32 group_id){ if (!group_id) // no need if no group id! return false; world.GetGroupManager()->GroupLock(__FUNCTION__, __LINE__); PlayerGroup* group = world.GetGroupManager()->GetGroup(group_id); deque* members = 0; if (group) members = group->GetMembers(); string name = string(client->GetPlayer()->GetName()); if (!members) { // group does not exist! Query query; query.AddQueryAsync(client->GetCharacterID(), &database, Q_INSERT, "UPDATE characters set group_id = 0 where id = %u", client->GetCharacterID()); LogWrite(PLAYER__ERROR, 0, "Player", "Group did not exist for player %s to group id %i, async query to group_id = 0.", name.c_str(), group_id); world.GetGroupManager()->ReleaseGroupLock(__FUNCTION__, __LINE__); return false; } deque::iterator itr; GroupMemberInfo* info = 0; bool match = false; group->MGroupMembers.writelock(); for (itr = members->begin(); itr != members->end(); itr++) { info = *itr; if (info && info->name == name) { info->client = client; info->member = client->GetPlayer(); client->GetPlayer()->SetGroup(group); client->GetPlayer()->SetGroupMemberInfo(info); client->GetPlayer()->UpdateGroupMemberInfo(true, true); LogWrite(PLAYER__DEBUG, 0, "Player", "Identified group match for player %s to group id %u", name.c_str(), group_id); match = true; break; } } group->MGroupMembers.releasewritelock(); // must be done after cause it needs a readlock if (match) group->SendGroupUpdate(); if (!match) LogWrite(PLAYER__ERROR, 0, "Player", "Identified group match for player %s to group id %u, however the player name was not present in the group! May be an old group id that has been re-used.", name.c_str(), group_id); world.GetGroupManager()->ReleaseGroupLock(__FUNCTION__, __LINE__); return match; } void World::AddBonuses(Item* item, ItemStatsValues* values, int16 type, sint32 value, Entity* entity){ if(values){ if(item && entity && entity->IsPlayer()) { int32 effective_level = entity->GetInfoStructUInt("effective_level"); if(effective_level && effective_level < entity->GetLevel() && item->details.recommended_level > effective_level) { int32 diff = item->details.recommended_level - effective_level; float tmpValue = (float)value; value = (sint32)(float)(tmpValue / (1.0f + ((float)diff * .05f))); } } switch(type){ case ITEM_STAT_STR:{ values->str += value; break; } case ITEM_STAT_STA:{ values->sta += value; break; } case ITEM_STAT_AGI:{ values->agi += value; break; } case ITEM_STAT_WIS:{ values->wis += value; break; } case ITEM_STAT_INT:{ values->int_ += value; break; } case ITEM_STAT_VS_SLASH:{ values->vs_slash += value; break; } case ITEM_STAT_VS_CRUSH:{ values->vs_crush += value; break; } case ITEM_STAT_VS_PIERCE:{ values->vs_pierce += value; break; } case ITEM_STAT_VS_HEAT:{ values->vs_heat += value; break; } case ITEM_STAT_VS_COLD:{ values->vs_cold += value; break; } case ITEM_STAT_VS_MAGIC:{ values->vs_magic += value; break; } case ITEM_STAT_VS_MENTAL:{ values->vs_mental += value; break; } case ITEM_STAT_VS_DIVINE:{ values->vs_divine += value; break; } case ITEM_STAT_VS_DISEASE:{ values->vs_disease += value; break; } case ITEM_STAT_VS_POISON:{ values->vs_poison += value; break; } case ITEM_STAT_HEALTH:{ values->health += value; break; } case ITEM_STAT_POWER:{ values->power += value; break; } case ITEM_STAT_CONCENTRATION:{ values->concentration += value; break; } case ITEM_STAT_ABILITY_MODIFIER:{ values->ability_modifier += value; break; } case ITEM_STAT_CRITICALMITIGATION:{ values->criticalmitigation += value; break; } case ITEM_STAT_EXTRASHIELDBLOCKCHANCE:{ values->extrashieldblockchance += value; break; } case ITEM_STAT_BENEFICIALCRITCHANCE:{ values->beneficialcritchance += value; break; } case ITEM_STAT_CRITBONUS:{ values->critbonus += value; break; } case ITEM_STAT_POTENCY:{ values->potency += value; break; } case ITEM_STAT_HATEGAINMOD:{ values->hategainmod += value; break; } case ITEM_STAT_ABILITYREUSESPEED:{ values->abilityreusespeed += value; break; } case ITEM_STAT_ABILITYCASTINGSPEED:{ values->abilitycastingspeed += value; break; } case ITEM_STAT_ABILITYRECOVERYSPEED:{ values->abilityrecoveryspeed += value; break; } case ITEM_STAT_SPELLREUSESPEED:{ values->spellreusespeed += value; break; } case ITEM_STAT_SPELLMULTIATTACKCHANCE:{ values->spellmultiattackchance += value; break; } case ITEM_STAT_DPS:{ values->dps += value; break; } case ITEM_STAT_ATTACKSPEED:{ values->attackspeed += value; break; } case ITEM_STAT_MULTIATTACKCHANCE:{ values->multiattackchance += value; break; } case ITEM_STAT_AEAUTOATTACKCHANCE:{ values->aeautoattackchance += value; break; } case ITEM_STAT_STRIKETHROUGH:{ values->strikethrough += value; break; } case ITEM_STAT_ACCURACY:{ values->accuracy += value; break; } /*case ITEM_STAT_OFFENSIVESPEED:{ values->offensivespeed += value; break; }*/ default: { if (entity) { entity->MStats.lock(); entity->stats[type] += value; entity->MStats.unlock(); } break; } } } } void World::CreateGuild(const char* guild_name, Client* leader, int32 group_id) { deque::iterator itr; GroupMemberInfo* gmi; Guild *guild; assert(guild_name); guild = new Guild(); guild->SetName(guild_name); guild->SetFormedDate(Timer::GetUnixTimeStamp()); database.LoadGuildDefaultRanks(guild); database.LoadGuildDefaultEventFilters(guild); database.SaveGuild(guild, true); database.SaveGuildEvents(guild); database.SaveGuildRanks(guild); database.SaveGuildEventFilters(guild); database.SaveGuildRecruiting(guild); guild_list.AddGuild(guild); if (leader && !leader->GetPlayer()->GetGuild()) guild->AddNewGuildMember(leader, 0, GUILD_RANK_LEADER); database.SaveGuildMembers(guild); if (leader && group_id > 0) { GetGroupManager()->GroupLock(__FUNCTION__, __LINE__); PlayerGroup* group = world.GetGroupManager()->GetGroup(group_id); if (group) { group->MGroupMembers.readlock(__FUNCTION__, __LINE__); deque* members = group->GetMembers(); for (itr = members->begin(); itr != members->end(); itr++) { gmi = *itr; if (gmi->client && gmi->client != leader && !gmi->client->GetPlayer()->GetGuild()) guild->InvitePlayer(gmi->client, leader->GetPlayer()->GetName()); } group->MGroupMembers.releasereadlock(__FUNCTION__, __LINE__); } GetGroupManager()->ReleaseGroupLock(__FUNCTION__, __LINE__); } } void World::SaveGuilds() { MutexMap* guilds = guild_list.GetGuilds(); MutexMap::iterator itr = guilds->begin(); while (itr.Next()) { Guild* guild = itr.second; if (guild->GetSaveNeeded()) database.SaveGuild(guild); if (guild->GetMemberSaveNeeded()) database.SaveGuildMembers(guild); if (guild->GetEventsSaveNeeded()) database.SaveGuildEvents(guild); if (guild->GetRanksSaveNeeded()) database.SaveGuildRanks(guild); if (guild->GetEventFiltersSaveNeeded()) database.SaveGuildEventFilters(guild); if (guild->GetPointsHistorySaveNeeded()) database.SaveGuildPointsHistory(guild); if (guild->GetRecruitingSaveNeeded()) database.SaveGuildRecruiting(guild); } } void World::PickRandomLottoDigits(int32* digits) { if (digits) { for (int32 i = 0; i < 6; i++) { bool found = true; int32 num = 0; while (found) { num = ((int32)rand() % 36) + 1; for (int32 j = 0; j < 6; j++) { if (digits[j] == num) break; if (j == 5) found = false; } } digits[i] = num; } } } void World::AddLottoPlayer(int32 character_id, int32 end_time) { LottoPlayer* lp; if (lotto_players.count(character_id) == 0) { lp = new LottoPlayer; lotto_players.Put(character_id, lp); } else lp = lotto_players.Get(character_id); lp->end_time = end_time; lp->num_matches = 0; lp->set = false; } void World::RemoveLottoPlayer(int32 character_id) { if (lotto_players.count(character_id) > 0) lotto_players.erase(character_id, false, true); } void World::SetLottoPlayerNumMatches(int32 character_id, int8 num_matches) { if (lotto_players.count(character_id) > 0) { lotto_players.Get(character_id)->num_matches = num_matches; lotto_players.Get(character_id)->set = true; } } void World::CheckLottoPlayers() { MutexMap::iterator itr = lotto_players.begin(); while (itr.Next()) { LottoPlayer* lp = itr->second; if (Timer::GetCurrentTime2() >= lp->end_time && lp->set) { int8 num_matches = lp->num_matches; LogWrite(PLAYER__DEBUG, 0, "Player", "Num matches: %u", lp->num_matches); Client* client = zone_list.GetClientByCharID(itr->first); if (client && num_matches >= 2) { if (num_matches == 2) { client->SimpleMessage(CHANNEL_COLOR_YELLOW, "You receive 10 silver."); client->SendPopupMessage(0, "Congratulations! You have won 10 silver!", "", 2, 0xFF, 0xFF, 0x99); client->GetPlayer()->AddCoins(1000); client->GetPlayer()->GetZone()->SendCastSpellPacket(869, client->GetPlayer()); } else if (num_matches == 3) { client->SimpleMessage(CHANNEL_COLOR_YELLOW, "You receive 50 silver."); client->SendPopupMessage(0, "Congratulations! You have won 50 silver!", "", 2, 0xFF, 0xFF, 0x99); client->GetPlayer()->AddCoins(5000); client->GetPlayer()->GetZone()->SendCastSpellPacket(870, client->GetPlayer()); } else if (num_matches == 4) { client->SimpleMessage(CHANNEL_COLOR_YELLOW, "You receive 2 gold 50 silver."); client->SendPopupMessage(0, "Congratulations! You have won 2 gold 50 silver!", "", 2, 0xFF, 0xFF, 0x99); client->GetPlayer()->AddCoins(25000); client->GetPlayer()->GetZone()->SendCastSpellPacket(871, client->GetPlayer()); } else if (num_matches == 5) { client->SimpleMessage(CHANNEL_COLOR_YELLOW, "You receive 25 gold."); client->SendPopupMessage(0, "Congratulations! You have won 25 gold!", "", 2, 0xFF, 0xFF, 0x99); client->GetPlayer()->AddCoins(250000); client->GetPlayer()->GetZone()->SendCastSpellPacket(872, client->GetPlayer()); } else if (num_matches == 6) { Variable* var = variables.FindVariable("gambling_current_jackpot"); if (var) { int64 jackpot = 0; try { jackpot = atoul(var->GetValue()); } catch (...) { jackpot = 10000; } char coin_message[128]; char message[512]; char announcement[512]; memset(coin_message, 0, sizeof(coin_message)); memset(message, 0, sizeof(message)); memset(announcement, 0, sizeof(announcement)); sprintf(coin_message, "%s", client->GetCoinMessage(jackpot).c_str()); sprintf(message, "Congratulations! You have won %s!", coin_message); sprintf(announcement, "%s as won the jackpot containing a total of %s!", client->GetPlayer()->GetName(), coin_message); client->Message(CHANNEL_COLOR_YELLOW, "You receive %s.", coin_message); client->SendPopupMessage(0, message, "", 2, 0xFF, 0xFF, 0x99); zone_list.HandleGlobalAnnouncement(announcement); client->GetPlayer()->AddCoins(jackpot); client->GetPlayer()->GetZone()->SendCastSpellPacket(843, client->GetPlayer()); client->GetPlayer()->GetZone()->SendCastSpellPacket(1413, client->GetPlayer()); } } } RemoveLottoPlayer(itr->first); } } } void World::AddHouseZone(int32 id, string name, int64 cost_coins, int32 cost_status, int64 upkeep_coins, int32 upkeep_status, int8 vault_slots, int8 alignment, int8 guild_level, int32 zone_id, int32 exit_zone_id, float exit_x, float exit_y, float exit_z, float exit_heading) { MHouseZones.writelock(__FUNCTION__, __LINE__); if (m_houseZones.count(id) == 0) { HouseZone* hz = new HouseZone; //ZeroMemory(hz, sizeof(HouseZone)); hz->id = id; hz->name = name; hz->cost_coin = cost_coins; hz->cost_status = cost_status; hz->upkeep_coin = upkeep_coins; hz->upkeep_status = upkeep_status; hz->vault_slots = vault_slots; hz->alignment = alignment; hz->guild_level = guild_level; hz->zone_id = zone_id; hz->exit_zone_id = exit_zone_id; hz->exit_x = exit_x; hz->exit_y = exit_y; hz->exit_z = exit_z; hz->exit_heading = exit_heading; m_houseZones[id] = hz; } else { LogWrite(WORLD__ERROR, 0, "Housing", "Duplicate house id (%u) for %s", id, name.c_str()); } MHouseZones.releasewritelock(__FUNCTION__, __LINE__); } HouseZone* World::GetHouseZone(int32 id) { HouseZone* ret = 0; MHouseZones.readlock(__FUNCTION__, __LINE__); if (m_houseZones.count(id) > 0) ret = m_houseZones[id]; MHouseZones.releasereadlock(__FUNCTION__, __LINE__); return ret; } void World::AddPlayerHouse(int32 char_id, int32 house_id, int64 unique_id, int32 instance_id, int32 upkeep_due, int64 escrow_coins, int32 escrow_status, string player_name) { MPlayerHouses.writelock(__FUNCTION__, __LINE__); if (m_playerHouses.count(house_id) == 0 || m_playerHouses[house_id].count(char_id) == 0) { PlayerHouse* ph = new PlayerHouse; ph->house_id = house_id; ph->unique_id = unique_id; ph->instance_id = instance_id; ph->escrow_coins = escrow_coins; ph->escrow_status = escrow_status; ph->upkeep_due = upkeep_due; ph->player_name = player_name; ReloadHouseData(ph); m_playerHouses[house_id][char_id] = ph; } MPlayerHouses.releasewritelock(__FUNCTION__, __LINE__); } void World::ReloadHouseData(PlayerHouse* ph) { database.LoadDeposits(ph); database.LoadHistory(ph); } PlayerHouse* World::GetPlayerHouseByHouseID(int32 char_id, int32 house_id) { PlayerHouse* ret = 0; MPlayerHouses.readlock(__FUNCTION__, __LINE__); if (m_playerHouses.count(house_id) > 0 && m_playerHouses[house_id].count(char_id) > 0) ret = m_playerHouses[house_id][char_id]; MPlayerHouses.releasereadlock(__FUNCTION__, __LINE__); return ret; } PlayerHouse* World::GetPlayerHouseByUniqueID(int64 unique_id) { PlayerHouse* ret = 0; MPlayerHouses.readlock(__FUNCTION__, __LINE__); map >::iterator itr; for (itr = m_playerHouses.begin(); itr != m_playerHouses.end(); itr++) { map::iterator itr2; for (itr2 = itr->second.begin(); itr2 != itr->second.end(); itr2++) { if (itr2->second->unique_id == unique_id) { ret = itr2->second; break; } } if (ret) break; } MPlayerHouses.releasereadlock(__FUNCTION__, __LINE__); return ret; } PlayerHouse* World::GetPlayerHouseByInstanceID(int32 instance_id) { PlayerHouse* ret = 0; MPlayerHouses.readlock(__FUNCTION__, __LINE__); map >::iterator itr; for (itr = m_playerHouses.begin(); itr != m_playerHouses.end(); itr++) { map::iterator itr2; for (itr2 = itr->second.begin(); itr2 != itr->second.end(); itr2++) { if (itr2->second->instance_id == instance_id) { ret = itr2->second; break; } } if (ret) break; } MPlayerHouses.releasereadlock(__FUNCTION__, __LINE__); return ret; } vector World::GetAllPlayerHouses(int32 char_id) { vector ret; MPlayerHouses.readlock(__FUNCTION__, __LINE__); map >::iterator itr; for (itr = m_playerHouses.begin(); itr != m_playerHouses.end(); itr++) { if (itr->second.count(char_id) > 0) ret.push_back(itr->second[char_id]); } MPlayerHouses.releasereadlock(__FUNCTION__, __LINE__); return ret; } vector World::GetAllPlayerHousesByHouseID(int32 house_id) { vector ret; MPlayerHouses.readlock(__FUNCTION__, __LINE__); if (m_houseZones.count(house_id) > 0) { map::iterator itr; for (itr = m_playerHouses[house_id].begin(); itr != m_playerHouses[house_id].end(); itr++) ret.push_back(itr->second); } MPlayerHouses.releasereadlock(__FUNCTION__, __LINE__); return ret; } void World::PopulateTOVStatMap() { //This function populates a map that converts changed CoE to ToV stats tov_itemstat_conversion[0] = TOV_ITEM_STAT_HPREGEN; tov_itemstat_conversion[1] = TOV_ITEM_STAT_MANAREGEN; tov_itemstat_conversion[2] = TOV_ITEM_STAT_HPREGENPPT; tov_itemstat_conversion[3] = TOV_ITEM_STAT_MPREGENPPT; tov_itemstat_conversion[4] = TOV_ITEM_STAT_COMBATHPREGENPPT; tov_itemstat_conversion[5] = TOV_ITEM_STAT_COMBATMPREGENPPT; tov_itemstat_conversion[6] = TOV_ITEM_STAT_MAXHP; tov_itemstat_conversion[7] = TOV_ITEM_STAT_MAXHPPERC; tov_itemstat_conversion[8] = TOV_ITEM_STAT_MAXHPPERCFINAL; tov_itemstat_conversion[9] = TOV_ITEM_STAT_SPEED; tov_itemstat_conversion[10] = TOV_ITEM_STAT_SLOW; tov_itemstat_conversion[11] = TOV_ITEM_STAT_MOUNTSPEED; tov_itemstat_conversion[12] = TOV_ITEM_STAT_MOUNTAIRSPEED; tov_itemstat_conversion[13] = TOV_ITEM_STAT_LEAPSPEED; tov_itemstat_conversion[14] = TOV_ITEM_STAT_LEAPTIME; tov_itemstat_conversion[15] = TOV_ITEM_STAT_GLIDEEFFICIENCY; tov_itemstat_conversion[16] = TOV_ITEM_STAT_OFFENSIVESPEED; tov_itemstat_conversion[17] = TOV_ITEM_STAT_ATTACKSPEED; tov_itemstat_conversion[18] = 698; tov_itemstat_conversion[19] = TOV_ITEM_STAT_MAXMANA; tov_itemstat_conversion[20] = TOV_ITEM_STAT_MAXMANAPERC; tov_itemstat_conversion[21] = TOV_ITEM_STAT_MAXATTPERC; tov_itemstat_conversion[22] = TOV_ITEM_STAT_BLURVISION; tov_itemstat_conversion[23] = TOV_ITEM_STAT_MAGICLEVELIMMUNITY; tov_itemstat_conversion[24] = TOV_ITEM_STAT_HATEGAINMOD; tov_itemstat_conversion[25] = TOV_ITEM_STAT_COMBATEXPMOD; tov_itemstat_conversion[26] = TOV_ITEM_STAT_TRADESKILLEXPMOD; tov_itemstat_conversion[27] = TOV_ITEM_STAT_ACHIEVEMENTEXPMOD; tov_itemstat_conversion[28] = TOV_ITEM_STAT_SIZEMOD; tov_itemstat_conversion[29] = TOV_ITEM_STAT_DPS; tov_itemstat_conversion[30] = 698; tov_itemstat_conversion[31] = TOV_ITEM_STAT_STEALTH; tov_itemstat_conversion[32] = TOV_ITEM_STAT_INVIS; tov_itemstat_conversion[33] = TOV_ITEM_STAT_SEESTEALTH; tov_itemstat_conversion[34] = TOV_ITEM_STAT_SEEINVIS; tov_itemstat_conversion[35] = TOV_ITEM_STAT_EFFECTIVELEVELMOD; tov_itemstat_conversion[36] = TOV_ITEM_STAT_RIPOSTECHANCE; tov_itemstat_conversion[37] = TOV_ITEM_STAT_PARRYCHANCE; tov_itemstat_conversion[38] = TOV_ITEM_STAT_DODGECHANCE; tov_itemstat_conversion[39] = TOV_ITEM_STAT_AEAUTOATTACKCHANCE; tov_itemstat_conversion[40] = 698; tov_itemstat_conversion[41] = TOV_ITEM_STAT_MULTIATTACKCHANCE; tov_itemstat_conversion[42] = 698; tov_itemstat_conversion[43] = 698; tov_itemstat_conversion[44] = 698; tov_itemstat_conversion[45] = TOV_ITEM_STAT_SPELLMULTIATTACKCHANCE; tov_itemstat_conversion[46] = 698; tov_itemstat_conversion[47] = TOV_ITEM_STAT_FLURRY; tov_itemstat_conversion[48] = 698; tov_itemstat_conversion[49] = TOV_ITEM_STAT_MELEEDAMAGEMULTIPLIER; tov_itemstat_conversion[50] = TOV_ITEM_STAT_EXTRAHARVESTCHANCE; tov_itemstat_conversion[51] = TOV_ITEM_STAT_EXTRASHIELDBLOCKCHANCE; tov_itemstat_conversion[52] = TOV_ITEM_STAT_ITEMHPREGENPPT; tov_itemstat_conversion[53] = TOV_ITEM_STAT_ITEMPPREGENPPT; tov_itemstat_conversion[54] = TOV_ITEM_STAT_MELEECRITCHANCE; tov_itemstat_conversion[55] = TOV_ITEM_STAT_CRITAVOIDANCE; tov_itemstat_conversion[56] = TOV_ITEM_STAT_BENEFICIALCRITCHANCE; tov_itemstat_conversion[57] = TOV_ITEM_STAT_CRITBONUS; tov_itemstat_conversion[58] = 698; tov_itemstat_conversion[59] = TOV_ITEM_STAT_POTENCY; tov_itemstat_conversion[60] = 698; tov_itemstat_conversion[61] = TOV_ITEM_STAT_UNCONSCIOUSHPMOD; tov_itemstat_conversion[62] = TOV_ITEM_STAT_ABILITYREUSESPEED; tov_itemstat_conversion[63] = TOV_ITEM_STAT_ABILITYRECOVERYSPEED; tov_itemstat_conversion[64] = TOV_ITEM_STAT_ABILITYCASTINGSPEED; tov_itemstat_conversion[65] = TOV_ITEM_STAT_SPELLREUSESPEED; tov_itemstat_conversion[66] = TOV_ITEM_STAT_MELEEWEAPONRANGE; tov_itemstat_conversion[67] = TOV_ITEM_STAT_RANGEDWEAPONRANGE; tov_itemstat_conversion[68] = TOV_ITEM_STAT_FALLINGDAMAGEREDUCTION; tov_itemstat_conversion[69] = TOV_ITEM_STAT_RIPOSTEDAMAGE; tov_itemstat_conversion[70] = TOV_ITEM_STAT_MINIMUMDEFLECTIONCHANCE; tov_itemstat_conversion[71] = TOV_ITEM_STAT_MOVEMENTWEAVE; tov_itemstat_conversion[72] = TOV_ITEM_STAT_COMBATHPREGEN; tov_itemstat_conversion[73] = TOV_ITEM_STAT_COMBATMANAREGEN; tov_itemstat_conversion[74] = TOV_ITEM_STAT_CONTESTSPEEDBOOST; tov_itemstat_conversion[75] = TOV_ITEM_STAT_TRACKINGAVOIDANCE; tov_itemstat_conversion[76] = TOV_ITEM_STAT_STEALTHINVISSPEEDMOD; tov_itemstat_conversion[77] = TOV_ITEM_STAT_LOOT_COIN; tov_itemstat_conversion[78] = TOV_ITEM_STAT_ARMORMITIGATIONINCREASE; tov_itemstat_conversion[79] = TOV_ITEM_STAT_AMMOCONSERVATION; tov_itemstat_conversion[80] = TOV_ITEM_STAT_STRIKETHROUGH; tov_itemstat_conversion[81] = TOV_ITEM_STAT_STATUSBONUS; tov_itemstat_conversion[82] = TOV_ITEM_STAT_ACCURACY; tov_itemstat_conversion[83] = TOV_ITEM_STAT_COUNTERSTRIKE; tov_itemstat_conversion[84] = TOV_ITEM_STAT_SHIELDBASH; tov_itemstat_conversion[85] = TOV_ITEM_STAT_WEAPONDAMAGEBONUS; tov_itemstat_conversion[86] = 698; tov_itemstat_conversion[87] = TOV_ITEM_STAT_WEAPONDAMAGEBONUSMELEEONLY; tov_itemstat_conversion[88] = TOV_ITEM_STAT_ADDITIONALRIPOSTECHANCE; tov_itemstat_conversion[89] = TOV_ITEM_STAT_PVPTOUGHNESS; tov_itemstat_conversion[90] = TOV_ITEM_STAT_PVPLETHALITY; tov_itemstat_conversion[91] = TOV_ITEM_STAT_STAMINABONUS; tov_itemstat_conversion[92] = TOV_ITEM_STAT_WISDOMMITBONUS; tov_itemstat_conversion[93] = TOV_ITEM_STAT_HEALRECEIVE; tov_itemstat_conversion[94] = TOV_ITEM_STAT_HEALRECEIVEPERC; tov_itemstat_conversion[95] = TOV_ITEM_STAT_PVPCRITICALMITIGATION; tov_itemstat_conversion[96] = TOV_ITEM_STAT_BASEAVOIDANCEBONUS; tov_itemstat_conversion[97] = TOV_ITEM_STAT_INCOMBATSAVAGERYREGEN; tov_itemstat_conversion[98] = TOV_ITEM_STAT_OUTOFCOMBATSAVAGERYREGEN; tov_itemstat_conversion[99] = TOV_ITEM_STAT_SAVAGERYREGEN; tov_itemstat_conversion[100] = TOV_ITEM_STAT_SAVAGERYGAINMOD; tov_itemstat_conversion[101] = TOV_ITEM_STAT_MAXSAVAGERYLEVEL; } int32 World::LoadItemBlueStats() { Query query; MYSQL_ROW row; int32 count = 0; MYSQL_RES* result = query.RunQuery2(Q_SELECT, "SELECT version_range1,version_range2,emu_stat,name,stat from itemstats"); if (result && mysql_num_rows(result) > 0) { while (result && (row = mysql_fetch_row(result))) { count++; if (atoi(row[0]) >= 63119) //KA ka_itemstat_conversion[atoi(row[2])] = atoi(row[4]); else if (atoi(row[0]) >= 57101) // ToV tov_itemstat_conversion[atoi(row[2])] = atoi(row[4]); else if (atoi(row[0]) >= 1193) // CoE coe_itemstat_conversion[atoi(row[2])] = atoi(row[4]); else if (atoi(row[0]) >= 1096) // DoV dov_itemstat_conversion[atoi(row[2])] = atoi(row[4]); } } return count; } sint64 World::newValue = 0; sint16 World::GetItemStatAOMValue(sint16 subtype) { sint16 tmp_subtype = subtype; // this is ugly for now cause I didn't want to map it all out, see a better way later but a lot of these are just slightly shifted if(subtype > 39) { // 88 needs to be something else (crit mitigation) // 19 needs to be something else (ability reuse speed) which is 62 if(subtype == 21) // ITEM_STAT_MAXATTPERC tmp_subtype = 20; else if(subtype == 41) // flurry tmp_subtype = 39; else if(subtype == 47) // flurry tmp_subtype = 41; else if(subtype == 49) // flurry tmp_subtype = 42; else if(subtype == 51) // ITEM_STAT_EXTRASHIELDBLOCKCHANCE tmp_subtype = 44; //tmp_subtype = 43 is bountiful harvest else if(subtype == 54 && subtype <= 57) // ITEM_STAT_MELEECRITCHANCE tmp_subtype = subtype - 7; else if(subtype == 59) // ITEM_STAT_POTENCY tmp_subtype = 51; else if(subtype >= 61 && subtype <= 85) // ITEM_STAT_RANGEDWEAPONRANGE tmp_subtype = subtype - 9; // else if(subtype >= 86 && subtype <= 101) // ITEM_STAT_WEAPONDAMAGEBONUSMELEEONLY tmp_subtype = subtype - 8; // else if(subtype == 102) // ITEM_STAT_SPELLWEAPONDAMAGEBONUS tmp_subtype = 77; // else if(subtype >= 103 && subtype <= 110) tmp_subtype = subtype - 9; else if(subtype == 122) // ITEM_STAT_ABILITYDOUBLECASTCHANCE tmp_subtype = 40; // else if(subtype == 124) // ITEM_STAT_STATUSEARNED tmp_subtype = 27; // else tmp_subtype += 1; // 80 serves as ranged weapon range increase, but so does 58? } else if((subtype > 18 && subtype < 28) || subtype > 30) // max mana was 18 tmp_subtype = subtype - 1; else if(subtype == 5) tmp_subtype = 46; else if(subtype == 4) tmp_subtype = 45; LogWrite(PLAYER__DEBUG, 0, "Player", "Convert type: %i -> %i", subtype, tmp_subtype); return tmp_subtype; } sint16 World::GetItemStatTOVValue(sint16 subtype) { return (tov_itemstat_conversion[subtype] - 600); } sint16 World::GetItemStatDOVValue(sint16 subtype) { return (dov_itemstat_conversion[subtype] - 600); } sint16 World::GetItemStatCOEValue(sint16 subtype) { return (coe_itemstat_conversion[subtype] - 600); } sint16 World::GetItemStatKAValue(sint16 subtype) { return (ka_itemstat_conversion[subtype] - 600); } bool World::CheckTempBugCRC(char* msg) { MBugReport.writelock(); sint32 crc = GetItemNameCrc(std::string(msg)); if (bug_report_crc.count(crc) > 0) { MBugReport.releasewritelock(); return true; } else bug_report_crc.insert(make_pair(crc, true)); MBugReport.releasewritelock(); return false; } #ifdef WIN32 ulong World::GetCurrentThreadID(){ return GetCurrentThreadId(); } int64 World::GetThreadUsageCPUTime(){ HANDLE handle = GetCurrentThread(); int64 lpCreationTime; int64 lpExitTime; int64 lpKernelTime; int64 lpUserTime; if(GetThreadTimes(handle, (FILETIME*)&lpCreationTime, (FILETIME*)&lpExitTime, (FILETIME*)&lpKernelTime, (FILETIME*)&lpUserTime)) return lpKernelTime + lpUserTime; return 0; } #else #endif void World::SyncCharacterAbilities(Client* client) { MStartingLists.readlock(); int8 baseClass = classes.GetBaseClass(client->GetPlayer()->GetAdventureClass()); int8 secondaryClass = classes.GetSecondaryBaseClass(client->GetPlayer()->GetAdventureClass()); int8 actualClass = client->GetPlayer()->GetAdventureClass(); int8 baseRace = client->GetPlayer()->GetRace(); bool reloadSpells = false; multimap*>::iterator skill_itr = starting_skills.begin(); multimap*>::iterator spell_itr = starting_spells.begin(); bool isComplete = false; int8 wait_iterations = 0; // wait 5 iterations and give up if db takes too long do { bool isProcessing = false; if (skill_itr != starting_skills.end()) { isProcessing = true; // race = 255 is wildcard all, otherwise needs to match the race id if (skill_itr->first == 255 || skill_itr->first == baseRace) { multimap::iterator child_itr; for (child_itr = skill_itr->second->begin(); child_itr != skill_itr->second->end(); child_itr++) { // class = 255 is wildcard all, otherwise needs to match the class id if (child_itr->first == 255 || child_itr->first == baseClass || child_itr->first == secondaryClass || child_itr->first == actualClass) { if (!client->GetPlayer()->skill_list.HasSkill(child_itr->second.skill_id)) { Query query; LogWrite(PLAYER__DEBUG, 0, "Player", "Adding skill %i for race: %i, class: %i for char_id: %u", child_itr->second.skill_id, baseRace, baseClass, client->GetCharacterID()); query.AddQueryAsync(client->GetCharacterID(), &database, Q_INSERT, "INSERT IGNORE INTO character_skills (char_id, skill_id, current_val, max_val) VALUES (%u, %u, %u, %u)", client->GetCharacterID(), child_itr->second.skill_id, child_itr->second.current_val, child_itr->second.max_val); client->GetPlayer()->AddSkill(child_itr->second.skill_id, child_itr->second.current_val, child_itr->second.max_val); } } } } skill_itr++; } if (spell_itr != starting_spells.end()) { isProcessing = true; // race = 255 is wildcard all, otherwise needs to match the race id if (spell_itr->first == 255 || spell_itr->first == baseRace) { multimap::iterator child_itr; for (child_itr = spell_itr->second->begin(); child_itr != spell_itr->second->end(); child_itr++) { // class = 255 is wildcard all, otherwise needs to match the class id if (child_itr->first == 255 || child_itr->first == baseClass || child_itr->first == secondaryClass || child_itr->first == actualClass) { if (!client->GetPlayer()->HasSpell(child_itr->second.spell_id, child_itr->second.tier, true)) { Query query; LogWrite(PLAYER__DEBUG, 0, "Player", "Adding spell %i for race: %i, class: %i for char_id: %u", child_itr->second.spell_id, baseRace, baseClass, client->GetCharacterID()); // knowledge_slot is a signed int in the DB query.AddQueryAsync(client->GetCharacterID(), &database, Q_INSERT, "INSERT IGNORE INTO character_spells (char_id, spell_id, tier, knowledge_slot) VALUES (%u, %u, %u, %i)", client->GetCharacterID(), child_itr->second.spell_id, child_itr->second.tier, child_itr->second.knowledge_slot); // reload spells, we don't know the spellbook or timer info reloadSpells = true; } } } } spell_itr++; } // poor mans async kill just in case, we don't want a client stuck here, they can get the spells on next zone if (!isProcessing) { bool isDBActive = database.IsActiveQuery(client->GetCharacterID()); if (isDBActive && wait_iterations < 5) { wait_iterations++; } else isComplete = true; } } while (!isComplete); MStartingLists.releasereadlock(); if (reloadSpells) database.LoadCharacterSpells(client->GetCharacterID(), client->GetPlayer()); } void World::LoadStartingLists() { LogWrite(WORLD__DEBUG, 1, "World", "-Loading `starting_skills`..."); database.LoadStartingSkills(this); LogWrite(WORLD__DEBUG, 1, "World", "-Loading `starting_spells`..."); database.LoadStartingSpells(this); } void World::PurgeStartingLists() { MStartingLists.writelock(); multimap*>::iterator skill_itr; for (skill_itr = starting_skills.begin(); skill_itr != starting_skills.end(); skill_itr++) { multimap* tmpMap = skill_itr->second; safe_delete(tmpMap); } starting_skills.clear(); multimap*>::iterator spell_itr; for (spell_itr = starting_spells.begin(); spell_itr != starting_spells.end(); spell_itr++) { multimap* tmpMap = spell_itr->second; safe_delete(tmpMap); } starting_spells.clear(); for(int type=0;type<3;type++) { multimap*>::iterator vos_itr; for (vos_itr = voiceover_map[type].begin(); vos_itr != voiceover_map[type].end(); vos_itr++) { multimap* tmpMap = vos_itr->second; safe_delete(tmpMap); } voiceover_map[type].clear(); } MStartingLists.releasewritelock(); } void World::SetReloadingSubsystem(string subsystem) { MReloadingSubsystems.lock(); reloading_subsystems[subsystem] = Timer::GetCurrentTime2(); MReloadingSubsystems.unlock(); } void World::RemoveReloadingSubSystem(string subsystem) { MReloadingSubsystems.lock(); if (reloading_subsystems.count(subsystem) > 0) reloading_subsystems.erase(subsystem); MReloadingSubsystems.unlock(); } bool World::IsReloadingSubsystems() { bool result = false; MReloadingSubsystems.lock(); result = reloading_subsystems.size() > 0; MReloadingSubsystems.unlock(); return result; } map World::GetOldestReloadingSubsystem() { map result; MReloadingSubsystems.lock(); int32 current_time = Timer::GetCurrentTime2(); map::iterator itr; int32 oldest = current_time; string oldestname = ""; for (itr = reloading_subsystems.begin(); itr != reloading_subsystems.end(); itr++) { if (itr->second < oldest) { oldestname = itr->first; result.clear(); result[oldestname] = oldest; } } MReloadingSubsystems.unlock(); return result; } void ZoneList::WatchdogHeartbeat() { list::iterator zone_iter; ZoneServer* tmp = 0; MZoneList.writelock(__FUNCTION__, __LINE__); bool match = false; for (zone_iter = zlist.begin(); zone_iter != zlist.end(); zone_iter++) { tmp = *zone_iter; if (tmp) { int32 curTime = Timer::GetCurrentTime2(); sint64 diff = (sint64)curTime - (sint64)tmp->GetWatchdogTime(); if (diff > 120000) { LogWrite(WORLD__ERROR, 1, "World", "Zone %s is hung for %i milliseconds.. attempting to cancel threads...", tmp->GetZoneName(), diff); #ifndef WIN32 tmp->CancelThreads(); zlist.erase(zone_iter); safe_delete(tmp); #endif MZoneList.releasewritelock(__FUNCTION__, __LINE__); match = true; break; } else if (diff > 90000 && !tmp->isZoneShuttingDown()) { tmp->SetWatchdogTime(Timer::GetCurrentTime2()); // reset so we don't continuously flood this heartbeat map oldest_process = world.GetOldestReloadingSubsystem(); if (oldest_process.size() > 0) { map::iterator itr = oldest_process.begin(); if(itr != oldest_process.end()) LogWrite(WORLD__ERROR, 1, "World", "Zone %s is hung for %i milliseconds.. while waiting for %s to reload...attempting shutdown", tmp->GetZoneName(), diff, itr->first); else LogWrite(WORLD__ERROR, 1, "World", "Zone %s is hung for %i milliseconds... attempting shutdown", tmp->GetZoneName(), diff); } else LogWrite(WORLD__ERROR, 1, "World", "Zone %s is hung for %i milliseconds.. attempting shutdown", tmp->GetZoneName(), diff); tmp->Shutdown(); } else if (diff > 30000) { if (world.IsReloadingSubsystems()) { if (world.GetSuppressedWarningTime() == 0) { world.SetSuppressedWarning(); map oldest_process = world.GetOldestReloadingSubsystem(); if (oldest_process.size() > 0) { map::iterator itr = oldest_process.begin(); if(itr != oldest_process.end()) LogWrite(WORLD__ERROR, 1, "World", "Zone %s is hung for %i milliseconds.. while waiting for %s to reload...", tmp->GetZoneName(), diff, itr->first); else LogWrite(WORLD__ERROR, 1, "World", "Zone %s is hung for %i milliseconds...", tmp->GetZoneName(), diff); } } continue; } } else if (diff > 60000 && !tmp->isZoneShuttingDown()) { if (world.IsReloadingSubsystems()) continue; LogWrite(WORLD__ERROR, 1, "World", "Zone %s is hung for %i milliseconds.. attempting shutdown", tmp->GetZoneName(), diff); tmp->Shutdown(); } } } if(!match) MZoneList.releasewritelock(__FUNCTION__, __LINE__); } void World::LoadRegionMaps(std::string zoneFile) { string zoneToLower(zoneFile); boost::algorithm::to_lower(zoneToLower); MWorldRegionMaps.writelock(); std::map::iterator itr; itr = region_maps.find(zoneToLower); if (itr == region_maps.end()) { RegionMapRange* newRange = new RegionMapRange(); newRange->AddVersionRange(zoneFile); region_maps.insert(make_pair(zoneToLower, newRange)); } MWorldRegionMaps.releasewritelock(); } RegionMap* World::GetRegionMap(std::string zoneFile, int32 client_version) { string zoneToLower(zoneFile); boost::algorithm::to_lower(zoneToLower); MWorldRegionMaps.readlock(); std::map::iterator itr; itr = region_maps.find(zoneToLower); if ( itr != region_maps.end()) { std::map::iterator rmitr; rmitr = itr->second->FindRegionByVersion(client_version); if ( rmitr != itr->second->GetRangeEnd()) { MWorldRegionMaps.releasereadlock(); return rmitr->second; } } MWorldRegionMaps.releasereadlock(); return nullptr; } void World::LoadMaps(std::string zoneFile) { string zoneToLower(zoneFile); boost::algorithm::to_lower(zoneToLower); MWorldMaps.writelock(); std::map::iterator itr; itr = maps.find(zoneToLower); if (itr == maps.end()) { MapRange* newRange = new MapRange(); newRange->AddVersionRange(zoneFile); maps.insert(make_pair(zoneToLower, newRange)); } MWorldMaps.releasewritelock(); } void World::RemoveMaps(std::string zoneFile) { string zoneToLower(zoneFile); boost::algorithm::to_lower(zoneToLower); MWorldMaps.writelock(); std::map::iterator itr; itr = maps.find(zoneToLower); if (itr != maps.end()) { MapRange* range = itr->second; maps.erase(itr); MWorldMaps.releasewritelock(); safe_delete(range); } else { MWorldMaps.releasewritelock(); } } Map* World::GetMap(std::string zoneFile, int32 client_version) { string zoneToLower(zoneFile); boost::algorithm::to_lower(zoneToLower); MWorldMaps.readlock(); std::map::iterator itr; itr = maps.find(zoneToLower); if ( itr != maps.end()) { std::map::iterator rmitr; rmitr = itr->second->FindMapByVersion(client_version); if ( rmitr != itr->second->GetRangeEnd()) { MWorldMaps.releasereadlock(); return rmitr->second; } } MWorldMaps.releasereadlock(); return nullptr; } void World::SendTimeUpdate() { zone_list.SendTimeUpdate(); } void World::LoadVoiceOvers() { LogWrite(WORLD__DEBUG, 1, "World", "-Loading `voiceovers`..."); database.LoadVoiceOvers(this); } void World::PurgeVoiceOvers() { MVoiceOvers.writelock(); for(int type=0;type*>::iterator vos_itr; for (vos_itr = voiceover_map[type].begin(); vos_itr != voiceover_map[type].end(); vos_itr++) { multimap* tmpMap = vos_itr->second; safe_delete(tmpMap); } voiceover_map[type].clear(); } MVoiceOvers.releasewritelock(); } bool World::FindVoiceOver(int8 type, int32 id, int16 index, VoiceOverStruct* struct_, bool* find_garbled, VoiceOverStruct* garble_struct_) { // if we complete both requirements, based on struct_ and garble_struct_ being passed when required by ptr not being null bool succeed = false; if(type > MAX_VOICEOVER_TYPE) { LogWrite(WORLD__ERROR, 0, "World", "Voice over %u out of range, max voiceover type is %u...", type, MAX_VOICEOVER_TYPE); return succeed; } MVoiceOvers.readlock(); multimap*>::iterator itr = voiceover_map[type].find(id); if(itr != voiceover_map[type].end()) { std::pair result = itr->second->equal_range(index); int count = std::distance(result.first, result.second); bool tries_attempt = true; // abort out the while loop bool non_garble_found = false; int rand = 0; // use to randomize the voiceover selection int pos = 0; int tries = 0; bool has_ungarbled = false; bool has_garbled = false; int8 garble_link_id = 0; // used to match ungarbled to garbled when the link id is set in the DB while(tries_attempt) { pos = 0; rand = MakeRandomInt(0, count); if ( tries == 3 || non_garble_found || (find_garbled && (*find_garbled))) rand = 0; // override, too many tries, or we otherwise found one garbled/ungarbled lets try to link it for (VOMapIterator it = result.first; it != result.second; it++) { if(!it->second.is_garbled) { has_ungarbled = true; } else { has_garbled = true; } pos++; // if there is only 1 entry in the voiceover list we aren't going to bother skipping if(count > 1 && pos < rand) { continue; } if(!it->second.is_garbled && (garble_link_id == 0 || it->second.garble_link_id == garble_link_id)) { garble_link_id = it->second.garble_link_id; non_garble_found = true; if(struct_) { CopyVoiceOver(struct_, &it->second); } if(!find_garbled || ((*find_garbled))) { if(find_garbled) *find_garbled = true; tries_attempt = false; succeed = true; break; } } else if(find_garbled && !(*find_garbled) && it->second.is_garbled && (garble_link_id == 0 || it->second.garble_link_id == garble_link_id)) { *find_garbled = true; garble_link_id = it->second.garble_link_id; if(garble_struct_) { CopyVoiceOver(garble_struct_, &it->second); if(!struct_ || non_garble_found) { tries_attempt = false; succeed = true; break; } } } } tries++; if(!tries_attempt || (tries > 0 && !has_ungarbled && (!find_garbled || *find_garbled == true || !has_garbled)) || tries > 3) break; } } MVoiceOvers.releasereadlock(); return succeed; } void World::AddVoiceOver(int8 type, int32 id, int16 index, VoiceOverStruct* struct_) { if(type > MAX_VOICEOVER_TYPE) { LogWrite(WORLD__ERROR, 0, "World", "Voice over %u out of range, max voiceover type is %u...", type, MAX_VOICEOVER_TYPE); return; } VoiceOverStruct tmpStruct; tmpStruct.mp3_string = std::string(struct_->mp3_string); tmpStruct.text_string = std::string(struct_->text_string); tmpStruct.emote_string = std::string(struct_->emote_string); tmpStruct.key1 = struct_->key1; tmpStruct.key2 = struct_->key2; tmpStruct.is_garbled = struct_->is_garbled; MVoiceOvers.writelock(); if(!voiceover_map[type].count(id)) { multimap* vo_struct = new multimap(); vo_struct->insert(make_pair(index, tmpStruct)); voiceover_map[type].insert(make_pair(id, vo_struct)); } else { multimap*>::const_iterator itr = voiceover_map[type].find(id); itr->second->insert(make_pair(index, tmpStruct)); } MVoiceOvers.releasewritelock(); } void World::CopyVoiceOver(VoiceOverStruct* struct1, VoiceOverStruct* struct2) { if(!struct1 || !struct2) return; struct1->mp3_string = std::string(struct2->mp3_string); struct1->text_string = std::string(struct2->text_string); struct1->emote_string = std::string(struct2->emote_string); struct1->key1 = struct2->key1; struct1->key2 = struct2->key2; struct1->is_garbled = struct2->is_garbled; struct1->garble_link_id = struct2->garble_link_id; } void World::AddNPCSpell(int32 list_id, int32 spell_id, int8 tier, bool spawn_cast, bool aggro_cast){ std::unique_lock lock(MNPCSpells); NPCSpell* npc_spell_struct = new NPCSpell; npc_spell_struct->list_id = list_id; npc_spell_struct->spell_id = spell_id; npc_spell_struct->tier = tier; npc_spell_struct->cast_on_spawn = spawn_cast; npc_spell_struct->cast_on_initial_aggro = aggro_cast; if(npc_spell_list.count(list_id) && npc_spell_list[list_id].count(spell_id)) { map::iterator spell_itr = npc_spell_list[list_id].find(spell_id); if(spell_itr != npc_spell_list[list_id].end()) { safe_delete(spell_itr->second); npc_spell_list[list_id].erase(spell_itr); } } npc_spell_list[list_id].insert(make_pair(spell_id, npc_spell_struct)); } vector* World::GetNPCSpells(int32 primary_list, int32 secondary_list){ std::shared_lock lock(MNPCSpells); vector* ret = 0; if(npc_spell_list.count(primary_list) > 0){ ret = new vector(); map::iterator itr; Spell* tmpSpell = 0; for(itr = npc_spell_list[primary_list].begin(); itr != npc_spell_list[primary_list].end(); itr++){ tmpSpell = master_spell_list.GetSpell(itr->first, itr->second->tier); if(tmpSpell) { NPCSpell* addedSpell = new NPCSpell(itr->second); ret->push_back(addedSpell); } } } if(npc_spell_list.count(secondary_list) > 0){ if(!ret) ret = new vector(); map::iterator itr; Spell* tmpSpell = 0; for(itr = npc_spell_list[secondary_list].begin(); itr != npc_spell_list[secondary_list].end(); itr++){ tmpSpell = master_spell_list.GetSpell(itr->first, itr->second->tier); if(tmpSpell) { NPCSpell* addedSpell = new NPCSpell(itr->second); ret->push_back(addedSpell); } } } if(ret && ret->size() == 0){ safe_delete(ret); ret = 0; } return ret; } void World::PurgeNPCSpells() { std::unique_lock lock(MNPCSpells); map >::iterator list_itr; map::iterator spell_itr; Spell* tmpSpell = 0; for(list_itr = npc_spell_list.begin(); list_itr != npc_spell_list.end(); list_itr++) { for(spell_itr = npc_spell_list[list_itr->first].begin(); spell_itr != npc_spell_list[list_itr->first].end(); spell_itr++){ safe_delete(spell_itr->second); } } npc_spell_list.clear(); }