/*
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 "LuaInterface.h"
#include "Player.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;
Player player;
extern ConfigReader configReader;
extern LoginServer loginserver;
extern World world;
extern RuleManager rule_manager;
extern LuaInterface* lua_interface;
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", "-Loading EXP Curve From DB...");
player.InitXPTable();
LogWrite(WORLD__DEBUG, 1, "World", "-Loading EXP Curve From DB Complete!");
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(lua_interface)
lua_interface->Process();
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, bool increment_zone) {
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;
if(increment_zone) {
ret->IncrementIncomingClients();
}
break;
}
}
}
MZoneList.releasereadlock(__FUNCTION__, __LINE__);
}
if(!ret )
{
if ( loadZone )
{
ret = new ZoneServer(zone_name);
database.LoadZoneInfo(ret);
ret->Init();
}
}
return ret;
}
ZoneServer* ZoneList::Get(int32 id, bool loadZone, bool skip_existing_zones, bool increment_zone) {
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;
if(increment_zone) {
ret->IncrementIncomingClients();
}
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, bool increment_zone) {
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->isZoneShuttingDown() && tmp->GetInstanceID() == id){
ret = tmp;
if(increment_zone) {
ret->IncrementIncomingClients();
}
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;
}
PlayerHouse* World::GetPlayerHouse(Client* client, int32 spawn_id, int64 unique_house_id, HouseZone** set_house_zone) {
PlayerHouse* ph = nullptr;
HouseZone* hz = nullptr;
if(spawn_id) {
Spawn* houseWidget = client->GetPlayer()->GetSpawnByIndex(spawn_id);
if(houseWidget && houseWidget->IsWidget() && ((Widget*)houseWidget)->GetHouseID()) {
hz = world.GetHouseZone(((Widget*)houseWidget)->GetHouseID());
if (hz) {
ph = world.GetPlayerHouseByHouseID(client->GetPlayer()->GetCharacterID(), hz->id);
}
}
}
if(!ph && client->GetCurrentZone()->GetInstanceID()) {
ph = world.GetPlayerHouseByInstanceID(client->GetCurrentZone()->GetInstanceID());
}
if(!ph && unique_house_id) {
ph = world.GetPlayerHouseByUniqueID(unique_house_id);
}
if (ph && !hz) {
hz = world.GetHouseZone(ph->house_id);
}
if(set_house_zone)
*set_house_zone = hz;
return ph;
}
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);
}
int8 World::TranslateSlotSubTypeToClient(Client* client, int8 stat_type, sint16 sub_type) {
int8 new_subtype = (int8)sub_type;
switch(stat_type) {
case 2: {
if(client->GetVersion() <= 561) {
if(sub_type == (ITEM_STAT_VS_POISON-200)) // poison
new_subtype = 9;
else if(sub_type == (ITEM_STAT_VS_DISEASE-200)) // disease
new_subtype = 8;
else if(sub_type == (ITEM_STAT_VS_COLD-200)) // cold
new_subtype = 4;
else if(sub_type == (ITEM_STAT_VS_HEAT-200) || sub_type == (ITEM_STAT_VS_MAGIC-200))
new_subtype += 2;
else if(sub_type == (ITEM_STAT_VS_MENTAL-200) || sub_type == (ITEM_STAT_VS_DIVINE-200))
new_subtype -= 2;
}
else if(client->GetVersion() >= 60085) { // AoM era since its the client we support
if(sub_type == (ITEM_STAT_VS_MENTAL-200) || sub_type == (ITEM_STAT_VS_DIVINE-200) || sub_type == (ITEM_STAT_VS_COLD-200)) {
new_subtype = 255; // omit client cannot properly display
}
}
break;
}
case 6:
case 7: {
if(stat_type == 7){
new_subtype = sub_type;
}
else if ((client->GetVersion() >= 63119) || client->GetVersion() == 61331){ //KA
new_subtype = world.GetItemStatKAValue(sub_type);
}
else if(client->GetVersion() >= 60085 ) {
new_subtype = world.GetItemStatAOMValue(sub_type);
}
else if (client->GetVersion() >= 57107){ //TOV
new_subtype = world.GetItemStatTOVValue(sub_type);
}
else if (client->GetVersion() >= 1193){ //COE
new_subtype = world.GetItemStatCOEValue(sub_type);
//tmp_subtype = stat->stat_subtype;
}
else if (client->GetVersion() >= 1096){ //DOV
new_subtype = world.GetItemStatDOVValue(sub_type); //comment out for testing
//tmp_subtype = stat->stat_subtype; //comment for normal use
}
break;
}
}
return new_subtype;
}
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();
multimap*>::iterator skill_itr = starting_skills.begin();
multimap*>::iterator spell_itr = starting_spells.begin();
bool isProcessing = false;
int8 wait_iterations = 0; // wait 5 iterations and give up if db takes too long
do
{
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
client->GetPlayer()->GetInfoStruct()->set_reload_player_spells(1);
}
}
}
}
spell_itr++;
}
} while (isProcessing);
MStartingLists.releasereadlock();
}
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, sint8 req_hp_ratio){
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;
npc_spell_struct->required_hp_ratio = req_hp_ratio;
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();
}