bool ChatHandler::HandleServerRevCommand(const char* /*args*/)
{
PSendSysMessage(_REVISION);
return true;
}
/// Display the 'Message of the day' for the realm
bool ChatHandler::HandleServerMotdCommand(char* /*args*/)
{
PSendSysMessage(LANG_MOTD_CURRENT, sWorld.GetMotd());
return true;
}
bool ChatHandler::HandleCreatePetCommand(const char* /*args*/)
{
Player *player = m_session->GetPlayer();
Creature *creatureTarget = getSelectedCreature();
if (!creatureTarget || creatureTarget->isPet() || creatureTarget->GetTypeId() == TYPEID_PLAYER)
{
PSendSysMessage(LANG_SELECT_CREATURE);
SetSentErrorMessage(true);
return false;
}
CreatureTemplate const* cInfo = sObjectMgr->GetCreatureTemplate(creatureTarget->GetEntry());
// Creatures with family 0 crashes the server
if (cInfo->family == 0)
{
PSendSysMessage("This creature cannot be tamed. (family id: 0).");
SetSentErrorMessage(true);
return false;
}
if (player->GetPetGUID())
{
PSendSysMessage("You already have a pet");
SetSentErrorMessage(true);
return false;
}
// Everything looks OK, create new pet
Pet* pet = new Pet(player, HUNTER_PET);
if (!pet)
return false;
if (!pet->CreateBaseAtCreature(creatureTarget))
{
delete pet;
PSendSysMessage("Error 1");
return false;
}
creatureTarget->setDeathState(JUST_DIED);
creatureTarget->RemoveCorpse();
creatureTarget->SetHealth(0); // just for nice GM-mode view
pet->SetUInt64Value(UNIT_FIELD_CREATEDBY, player->GetGUID());
pet->SetUInt32Value(UNIT_FIELD_FACTIONTEMPLATE, player->getFaction());
if (!pet->InitStatsForLevel(creatureTarget->getLevel()))
{
sLog->outError("InitStatsForLevel() in EffectTameCreature failed! Pet deleted.");
PSendSysMessage("Error 2");
delete pet;
return false;
}
// prepare visual effect for levelup
pet->SetUInt32Value(UNIT_FIELD_LEVEL, creatureTarget->getLevel()-1);
pet->GetCharmInfo()->SetPetNumber(sObjectMgr->GeneratePetNumber(), true);
// this enables pet details window (Shift+P)
pet->InitPetCreateSpells();
pet->SetFullHealth();
pet->GetMap()->Add(pet->ToCreature());
// visual effect for levelup
pet->SetUInt32Value(UNIT_FIELD_LEVEL, creatureTarget->getLevel());
player->SetMinion(pet, true);
pet->SavePetToDB(PET_SAVE_AS_CURRENT);
player->PetSpellInitialize();
return true;
}
//mute player for some times
bool ChatHandler::HandleMuteCommand(const char* args)
{
std::string announce;
char* nameStr;
char* delayStr;
extractOptFirstArg((char*)args, &nameStr, &delayStr);
if (!delayStr)
return false;
char *mutereason = strtok(NULL, "\r");
std::string mutereasonstr = "No reason";
if (mutereason != NULL)
mutereasonstr = mutereason;
if(!mutereason)
{
PSendSysMessage("You must enter a reason of mute");
SetSentErrorMessage(true);
return false;
}
Player* target;
uint64 target_guid;
std::string target_name;
if (!extractPlayerTarget(nameStr, &target, &target_guid, &target_name))
return false;
uint32 accountId = target ? target->GetSession()->GetAccountId() : sObjectMgr->GetPlayerAccountIdByGUID(target_guid);
// find only player from same account if any
if (!target)
if (WorldSession* session = sWorld->FindSession(accountId))
target = session->GetPlayer();
uint32 notspeaktime = (uint32) atoi(delayStr);
// must have strong lesser security level
if (HasLowerSecurity (target, target_guid, true))
return false;
PreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_UPD_MUTE_TIME);
if (target)
{
// Target is online, mute will be in effect right away.
int64 muteTime = time(NULL) + notspeaktime * MINUTE;
target->GetSession()->m_muteTime = muteTime;
stmt->setInt64(0, muteTime);
ChatHandler(target).PSendSysMessage(LANG_YOUR_CHAT_DISABLED, notspeaktime, mutereasonstr.c_str());
}
else
{
// Target is offline, mute will be in effect starting from the next login.
int32 muteTime = -int32(notspeaktime * MINUTE);
stmt->setInt64(0, muteTime);
}
stmt->setUInt32(1, accountId);
LoginDatabase.Execute(stmt);
std::string nameLink = playerLink(target_name);
PSendSysMessage(target ? LANG_YOU_DISABLE_CHAT : LANG_COMMAND_DISABLE_CHAT_DELAYED, nameLink.c_str(), notspeaktime, mutereasonstr.c_str());
announce = "The character '";
announce += nameStr;
announce += "' was muted for ";
announce += delayStr;
announce += " minutes by the character '";
announce += m_session->GetPlayerName();
announce += "'. The reason is: ";
announce += mutereason;
HandleAnnounceCommand(announce.c_str());
return true;
}
//show info of player
bool ChatHandler::HandlePInfoCommand(const char* args)
{
Player* target;
uint64 target_guid;
std::string target_name;
uint32 parseGUID = MAKE_NEW_GUID(atol((char*)args), 0, HIGHGUID_PLAYER);
if (sObjectMgr->GetPlayerNameByGUID(parseGUID, target_name))
{
target = sObjectMgr->GetPlayerByLowGUID(parseGUID);
target_guid = parseGUID;
}
else if (!extractPlayerTarget((char*)args, &target, &target_guid, &target_name))
return false;
uint32 accId = 0;
uint32 money = 0;
uint32 total_player_time = 0;
uint8 level = 0;
uint32 latency = 0;
uint8 race;
uint8 Class;
int64 muteTime = 0;
int64 banTime = -1;
uint32 mapId;
uint32 areaId;
uint32 phase = 0;
// get additional information from Player object
if (target)
{
// check online security
if (HasLowerSecurity(target, 0))
return false;
accId = target->GetSession()->GetAccountId();
money = target->GetMoney();
total_player_time = target->GetTotalPlayedTime();
level = target->getLevel();
latency = target->GetSession()->GetLatency();
race = target->getRace();
Class = target->getClass();
muteTime = target->GetSession()->m_muteTime;
mapId = target->GetMapId();
areaId = target->GetAreaId();
phase = target->GetPhaseMask();
}
// get additional information from DB
else
{
// check offline security
if (HasLowerSecurity(NULL, target_guid))
return false;
// 0 1 2 3 4 5 6 7
QueryResult result = CharacterDatabase.PQuery("SELECT totaltime, level, money, account, race, class, map, zone FROM characters "
"WHERE guid = '%u'", GUID_LOPART(target_guid));
if (!result)
return false;
Field* fields = result->Fetch();
total_player_time = fields[0].GetUInt32();
level = fields[1].GetUInt32();
money = fields[2].GetUInt32();
accId = fields[3].GetUInt32();
race = fields[4].GetUInt8();
Class = fields[5].GetUInt8();
mapId = fields[6].GetUInt16();
areaId = fields[7].GetUInt16();
}
std::string username = GetTrinityString(LANG_ERROR);
std::string email = GetTrinityString(LANG_ERROR);
std::string last_ip = GetTrinityString(LANG_ERROR);
uint32 security = 0;
std::string last_login = GetTrinityString(LANG_ERROR);
QueryResult result = LoginDatabase.PQuery("SELECT a.username, aa.gmlevel, a.email, a.last_ip, a.last_login, a.mutetime "
"FROM account a "
"LEFT JOIN account_access aa "
"ON (a.id = aa.id) "
"WHERE a.id = '%u'", accId);
if (result)
{
Field* fields = result->Fetch();
username = fields[0].GetString();
security = fields[1].GetUInt32();
email = fields[2].GetString();
muteTime = fields[5].GetUInt64();
if (email.empty())
email = "-";
if (!m_session || m_session->GetSecurity() >= AccountTypes(security))
{
last_ip = fields[3].GetString();
last_login = fields[4].GetString();
}
else
{
last_ip = "-";
last_login = "******";
}
}
std::string nameLink = playerLink(target_name);
PSendSysMessage(LANG_PINFO_ACCOUNT, (target?"":GetTrinityString(LANG_OFFLINE)), nameLink.c_str(), GUID_LOPART(target_guid), username.c_str(), accId, email.c_str(), security, last_ip.c_str(), last_login.c_str(), latency);
std::string bannedby = "unknown";
std::string banreason = "";
if (QueryResult result = LoginDatabase.PQuery("SELECT unbandate, bandate = unbandate, bannedby, banreason FROM account_banned "
"WHERE id = '%u' AND active ORDER BY bandate ASC LIMIT 1", accId))
{
Field* fields = result->Fetch();
banTime = fields[1].GetBool() ? 0 : fields[0].GetUInt64();
bannedby = fields[2].GetString();
banreason = fields[3].GetString();
}
else if (QueryResult result = CharacterDatabase.PQuery("SELECT unbandate, bandate = unbandate, bannedby, banreason FROM character_banned "
"WHERE guid = '%u' AND active ORDER BY bandate ASC LIMIT 1", GUID_LOPART(target_guid)))
{
Field* fields = result->Fetch();
banTime = fields[1].GetBool() ? 0 : fields[0].GetUInt64();
bannedby = fields[2].GetString();
banreason = fields[3].GetString();
}
if (muteTime > 0)
PSendSysMessage(LANG_PINFO_MUTE, secsToTimeString(muteTime - time(NULL), true).c_str());
if (banTime >= 0)
PSendSysMessage(LANG_PINFO_BAN, banTime > 0 ? secsToTimeString(banTime - time(NULL), true).c_str() : "permanently", bannedby.c_str(), banreason.c_str());
std::string race_s, Class_s;
switch (race)
{
case RACE_HUMAN: race_s = "Human"; break;
case RACE_ORC: race_s = "Orc"; break;
case RACE_DWARF: race_s = "Dwarf"; break;
case RACE_NIGHTELF: race_s = "Night Elf"; break;
case RACE_UNDEAD_PLAYER: race_s = "Undead"; break;
case RACE_TAUREN: race_s = "Tauren"; break;
case RACE_GNOME: race_s = "Gnome"; break;
case RACE_TROLL: race_s = "Troll"; break;
case RACE_BLOODELF: race_s = "Blood Elf"; break;
case RACE_DRAENEI: race_s = "Draenei"; break;
}
switch (Class)
{
case CLASS_WARRIOR: Class_s = "Warrior"; break;
case CLASS_PALADIN: Class_s = "Paladin"; break;
case CLASS_HUNTER: Class_s = "Hunter"; break;
case CLASS_ROGUE: Class_s = "Rogue"; break;
case CLASS_PRIEST: Class_s = "Priest"; break;
case CLASS_DEATH_KNIGHT: Class_s = "Death Knight"; break;
case CLASS_SHAMAN: Class_s = "Shaman"; break;
case CLASS_MAGE: Class_s = "Mage"; break;
case CLASS_WARLOCK: Class_s = "Warlock"; break;
case CLASS_DRUID: Class_s = "Druid"; break;
}
std::string timeStr = secsToTimeString(total_player_time, true, true);
uint32 gold = money /GOLD;
uint32 silv = (money % GOLD) / SILVER;
uint32 copp = (money % GOLD) % SILVER;
PSendSysMessage(LANG_PINFO_LEVEL, race_s.c_str(), Class_s.c_str(), timeStr.c_str(), level, gold, silv, copp);
// Add map, zone, subzone and phase to output
int locale = GetSessionDbcLocale();
std::string areaName = "<unknown>";
std::string zoneName = "";
MapEntry const* map = sMapStore.LookupEntry(mapId);
AreaTableEntry const* area = GetAreaEntryByAreaID(areaId);
if (area)
{
areaName = area->area_name[locale];
AreaTableEntry const* zone = GetAreaEntryByAreaID(area->zone);
if (zone)
zoneName = zone->area_name[locale];
}
if (target)
{
if (!zoneName.empty())
PSendSysMessage(LANG_PINFO_MAP_ONLINE, map->name[locale], zoneName.c_str(), areaName.c_str(), phase);
else
PSendSysMessage(LANG_PINFO_MAP_ONLINE, map->name[locale], areaName.c_str(), "<unknown>", phase);
}
else
PSendSysMessage(LANG_PINFO_MAP_OFFLINE, map->name[locale], areaName.c_str());
return true;
}
bool ChatHandler::HandleBanAutoCommand(char *args)
{
if (!*args)
return false;
char* cname = strtok ((char*)args, " ");
if (!cname)
return false;
std::string name = cname;
char* creason = strtok (NULL,"");
std::string banreason = creason ? creason : "";
QueryResult *result;
Field *fields;
result = CharacterDatabase.PQuery("SELECT account FROM characters WHERE name = '%s'",name.c_str());
if(!result)
{
PSendSysMessage(LANG_BAN_NOTFOUND,"character",name.c_str());
return true;
}
fields = result->Fetch();
uint32 accId = fields->GetUInt32();
delete result;
std::string oldreason;
uint32 bandate, unbandate;
int32 bandiff;
uint32 max_banid = 0;
uint32 counted_extra_bans = 0;
result = LoginDatabase.PQuery("SELECT bandate,unbandate,banreason FROM account_banned WHERE id=%u", accId);
if(result)
{
do
{
fields = result->Fetch();
bandate = fields[0].GetUInt32();
unbandate = fields[1].GetUInt32();
oldreason = fields[2].GetCppString();
bandiff = unbandate - bandate;
if(oldreason.size() > 10 && oldreason.substr(0,10) == "[AutoBan #")
{
uint32 banid = atoi(oldreason.c_str() + 10);
max_banid = std::max(max_banid, banid);
}
else if(bandiff >= (int32)sWorld.getConfig(CONFIG_UINT32_AUTOBAN_MIN_COUNTED_BANTIME) || bandiff == 0)
{
++counted_extra_bans;
}
}
while (result->NextRow());
delete result;
}
max_banid = std::max(max_banid, counted_extra_bans);
std::string duration = sWorld.GetAutoBanTime(max_banid);
std::stringstream reason;
reason << "[AutoBan #" << (max_banid + 1) << "; " << duration << "] " << banreason;
uint32 duration_secs = TimeStringToSecs(duration);
switch(sWorld.BanAccount(BAN_CHARACTER, name, duration_secs, reason.str().c_str(), m_session ? m_session->GetPlayerName() : ""))
{
case BAN_SUCCESS:
if(atoi(duration.c_str())>0)
PSendSysMessage(LANG_BAN_YOUBANNED,name.c_str(),secsToTimeString(TimeStringToSecs(duration),true).c_str(),reason.str().c_str());
else
PSendSysMessage(LANG_BAN_YOUPERMBANNED,name.c_str(),reason.str().c_str());
break;
case BAN_SYNTAX_ERROR:
return false;
case BAN_NOTFOUND:
PSendSysMessage(LANG_BAN_NOTFOUND,"character",name.c_str());
SetSentErrorMessage(true);
return false;
}
return true;
}
bool ChatHandler::HandlePlayerbotCommand(char* args)
{
if (sWorld.getConfig(CONFIG_BOOL_PLAYERBOT_DISABLE))
{
PSendSysMessage("|cffff0000Playerbot system is currently disabled!");
SetSentErrorMessage(true);
return false;
}
if (!m_session)
{
PSendSysMessage("|cffff0000You may only add bots from an active session");
SetSentErrorMessage(true);
return false;
}
if (!*args)
{
PSendSysMessage("|cffff0000usage: add PLAYERNAME or remove PLAYERNAME");
SetSentErrorMessage(true);
return false;
}
char *cmd = strtok ((char *) args, " ");
char *charname = strtok (NULL, " ");
if (!cmd || !charname)
{
PSendSysMessage("|cffff0000usage: add PLAYERNAME or remove PLAYERNAME");
SetSentErrorMessage(true);
return false;
}
std::string cmdStr = cmd;
std::string charnameStr = charname;
if (!normalizePlayerName(charnameStr))
return false;
uint64 guid = sObjectMgr.GetPlayerGUIDByName(charnameStr.c_str());
if (guid == 0 || (guid == m_session->GetPlayer()->GetGUID()))
{
SendSysMessage(LANG_PLAYER_NOT_FOUND);
SetSentErrorMessage(true);
return false;
}
uint32 accountId = sObjectMgr.GetPlayerAccountIdByGUID(guid);
if (accountId != m_session->GetAccountId())
{
PSendSysMessage("|cffff0000You may only add bots from the same account.");
SetSentErrorMessage(true);
return false;
}
// create the playerbot manager if it doesn't already exist
PlayerbotMgr* mgr = m_session->GetPlayer()->GetPlayerbotMgr();
if (!mgr)
{
mgr = new PlayerbotMgr(m_session->GetPlayer());
m_session->GetPlayer()->SetPlayerbotMgr(mgr);
}
QueryResult *resultchar = CharacterDatabase.PQuery("SELECT COUNT(*) FROM characters WHERE online = '1' AND account = '%u'", m_session->GetAccountId());
if (resultchar)
{
Field *fields = resultchar->Fetch();
int acctcharcount = fields[0].GetUInt32();
int maxnum = sWorld.getConfig(CONFIG_UINT32_PLAYERBOT_MAXBOTS);
if (!(m_session->GetSecurity() > SEC_PLAYER))
if (acctcharcount > maxnum && (cmdStr == "add" || cmdStr == "login"))
{
PSendSysMessage("|cffff0000You cannot summon anymore bots.(Current Max: |cffffffff%u)", maxnum);
SetSentErrorMessage(true);
delete resultchar;
return false;
}
}
delete resultchar;
QueryResult *resultlvl = CharacterDatabase.PQuery("SELECT level,name FROM characters WHERE guid = '%lu'", guid);
if (resultlvl)
{
Field *fields = resultlvl->Fetch();
int charlvl = fields[0].GetUInt32();
int maxlvl = sWorld.getConfig(CONFIG_UINT32_PLAYERBOT_RESTRICTLEVEL);
if (!(m_session->GetSecurity() > SEC_PLAYER))
if (charlvl > maxlvl)
{
PSendSysMessage("|cffff0000You cannot summon |cffffffff[%s]|cffff0000, it's level is too high.(Current Max:lvl |cffffffff%u)", fields[1].GetString(), maxlvl);
SetSentErrorMessage(true);
delete resultlvl;
return false;
}
}
delete resultlvl;
// end of gmconfig patch
if (cmdStr == "add" || cmdStr == "login")
{
if (mgr->GetPlayerBot(guid))
{
PSendSysMessage("Bot already exists in world.");
SetSentErrorMessage(true);
return false;
}
CharacterDatabase.DirectPExecute("UPDATE characters SET online = 1 WHERE guid = '%lu'", guid);
mgr->AddPlayerBot(guid);
PSendSysMessage("Bot added successfully.");
}
else if (cmdStr == "remove" || cmdStr == "logout")
{
if (!mgr->GetPlayerBot(guid))
{
PSendSysMessage("|cffff0000Bot can not be removed because bot does not exist in world.");
SetSentErrorMessage(true);
return false;
}
CharacterDatabase.DirectPExecute("UPDATE characters SET online = 0 WHERE guid = '%lu'", guid);
mgr->LogoutPlayerBot(guid);
PSendSysMessage("Bot removed successfully.");
}
else if (cmdStr == "co" || cmdStr == "combatorder")
{
Unit *target = NULL;
char *orderChar = strtok(NULL, " ");
if (!orderChar)
{
PSendSysMessage("|cffff0000Syntax error:|cffffffff .bot co <botName> <order=reset|tank|assist|heal|protect> [targetPlayer]");
SetSentErrorMessage(true);
return false;
}
std::string orderStr = orderChar;
if (orderStr == "protect" || orderStr == "assist")
{
char *targetChar = strtok(NULL, " ");
ObjectGuid targetGUID = m_session->GetPlayer()->GetSelectionGuid();
if (!targetChar && targetGUID.IsEmpty())
{
PSendSysMessage("|cffff0000Combat orders protect and assist expect a target either by selection or by giving target player in command string!");
SetSentErrorMessage(true);
return false;
}
if (targetChar)
{
std::string targetStr = targetChar;
targetGUID.Set(sObjectMgr.GetPlayerGUIDByName(targetStr.c_str()));
}
target = ObjectAccessor::GetUnit(*m_session->GetPlayer(), targetGUID);
if (!target)
{
PSendSysMessage("|cffff0000Invalid target for combat order protect or assist!");
SetSentErrorMessage(true);
return false;
}
}
if (mgr->GetPlayerBot(guid) == NULL)
{
PSendSysMessage("|cffff0000Bot can not receive combat order because bot does not exist in world.");
SetSentErrorMessage(true);
return false;
}
mgr->GetPlayerBot(guid)->GetPlayerbotAI()->SetCombatOrderByStr(orderStr, target);
}
return true;
}
bool ChatHandler::HandleGPSCommand(const char* args)
{
WorldObject *obj = NULL;
if (*args)
{
uint64 guid = extractGuidFromLink((char*)args);
if (guid)
obj = (WorldObject*)ObjectAccessor::GetObjectByTypeMask(*m_session->GetPlayer(), guid, TYPEMASK_UNIT|TYPEMASK_GAMEOBJECT);
if (!obj)
{
SendSysMessage(LANG_PLAYER_NOT_FOUND);
SetSentErrorMessage(true);
return false;
}
}
else
{
obj = getSelectedUnit();
if (!obj)
{
SendSysMessage(LANG_SELECT_CHAR_OR_CREATURE);
SetSentErrorMessage(true);
return false;
}
}
CellPair cell_val = Trinity::ComputeCellPair(obj->GetPositionX(), obj->GetPositionY());
Cell cell(cell_val);
uint32 zone_id, area_id;
obj->GetZoneAndAreaId(zone_id, area_id);
MapEntry const* mapEntry = sMapStore.LookupEntry(obj->GetMapId());
AreaTableEntry const* zoneEntry = GetAreaEntryByAreaID(zone_id);
AreaTableEntry const* areaEntry = GetAreaEntryByAreaID(area_id);
float zone_x = obj->GetPositionX();
float zone_y = obj->GetPositionY();
Map2ZoneCoordinates(zone_x, zone_y, zone_id);
Map const *map = obj->GetMap();
float ground_z = map->GetHeight(obj->GetPositionX(), obj->GetPositionY(), MAX_HEIGHT);
float floor_z = map->GetHeight(obj->GetPositionX(), obj->GetPositionY(), obj->GetPositionZ());
GridPair p = Trinity::ComputeGridPair(obj->GetPositionX(), obj->GetPositionY());
// 63? WHY?
int gx = 63 - p.x_coord;
int gy = 63 - p.y_coord;
uint32 have_map = Map::ExistMap(obj->GetMapId(), gx, gy) ? 1 : 0;
uint32 have_vmap = Map::ExistVMap(obj->GetMapId(), gx, gy) ? 1 : 0;
if(have_vmap)
{
if(map->IsOutdoors(obj->GetPositionX(), obj->GetPositionY(), obj->GetPositionZ()))
PSendSysMessage("You are outdoors");
else
PSendSysMessage("You are indoors");
}
else PSendSysMessage("no VMAP available for area info");
PSendSysMessage(LANG_MAP_POSITION,
obj->GetMapId(), (mapEntry ? mapEntry->name[GetSessionDbcLocale()] : "<unknown>"),
zone_id, (zoneEntry ? zoneEntry->area_name[GetSessionDbcLocale()] : "<unknown>"),
area_id, (areaEntry ? areaEntry->area_name[GetSessionDbcLocale()] : "<unknown>"),
obj->GetPhaseMask(),
obj->GetPositionX(), obj->GetPositionY(), obj->GetPositionZ(), obj->GetOrientation(),
cell.GridX(), cell.GridY(), cell.CellX(), cell.CellY(), obj->GetInstanceId(),
zone_x, zone_y, ground_z, floor_z, have_map, have_vmap);
LiquidData liquid_status;
ZLiquidStatus res = map->getLiquidStatus(obj->GetPositionX(), obj->GetPositionY(), obj->GetPositionZ(), MAP_ALL_LIQUIDS, &liquid_status);
if (res)
{
PSendSysMessage(LANG_LIQUID_STATUS, liquid_status.level, liquid_status.depth_level, liquid_status.type, res);
}
return true;
}
//Summon Player
bool ChatHandler::HandleSummonCommand(const char* args)
{
Player* target;
uint64 target_guid;
std::string target_name;
if (!extractPlayerTarget((char*)args, &target, &target_guid, &target_name))
return false;
Player* _player = m_session->GetPlayer();
if (target == _player || target_guid == _player->GetGUID())
{
PSendSysMessage(LANG_CANT_TELEPORT_SELF);
SetSentErrorMessage(true);
return false;
}
if (target)
{
std::string nameLink = playerLink(target_name);
// check online security
if (HasLowerSecurity(target, 0))
return false;
if (target->IsBeingTeleported())
{
PSendSysMessage(LANG_IS_TELEPORTED, nameLink.c_str());
SetSentErrorMessage(true);
return false;
}
Map* pMap = m_session->GetPlayer()->GetMap();
if (pMap->IsBattlegroundOrArena())
{
// only allow if gm mode is on
if (!_player->isGameMaster())
{
PSendSysMessage(LANG_CANNOT_GO_TO_BG_GM, nameLink.c_str());
SetSentErrorMessage(true);
return false;
}
// if both players are in different bgs
else if (target->GetBattlegroundId() && m_session->GetPlayer()->GetBattlegroundId() != target->GetBattlegroundId())
target->LeaveBattleground(false); // Note: should be changed so target gets no Deserter debuff
// all's well, set bg id
// when porting out from the bg, it will be reset to 0
target->SetBattlegroundId(m_session->GetPlayer()->GetBattlegroundId(), m_session->GetPlayer()->GetBattlegroundTypeId());
// remember current position as entry point for return at bg end teleportation
if (!target->GetMap()->IsBattlegroundOrArena())
target->SetBattlegroundEntryPoint();
}
else if (pMap->IsDungeon())
{
Map* cMap = target->GetMap();
if (cMap->Instanceable() && cMap->GetInstanceId() != pMap->GetInstanceId())
target->UnbindInstance(pMap->GetInstanceId(), target->GetDungeonDifficulty(), true);
// we are in instance, and can summon only player in our group with us as lead
if (!m_session->GetPlayer()->GetGroup() || !target->GetGroup() ||
(target->GetGroup()->GetLeaderGUID() != m_session->GetPlayer()->GetGUID()) ||
(m_session->GetPlayer()->GetGroup()->GetLeaderGUID() != m_session->GetPlayer()->GetGUID()))
// the last check is a bit excessive, but let it be, just in case
{
PSendSysMessage(LANG_CANNOT_SUMMON_TO_INST, nameLink.c_str());
SetSentErrorMessage(true);
return false;
}
}
PSendSysMessage(LANG_SUMMONING, nameLink.c_str(), "");
if (needReportToTarget(target))
ChatHandler(target).PSendSysMessage(LANG_SUMMONED_BY, playerLink(_player->GetName()).c_str());
// stop flight if need
if (target->isInFlight())
{
target->GetMotionMaster()->MovementExpired();
target->CleanupAfterTaxiFlight();
}
// save only in non-flight case
else
target->SaveRecallPosition();
// before GM
float x, y, z;
m_session->GetPlayer()->GetClosePoint(x, y, z, target->GetObjectSize());
target->TeleportTo(m_session->GetPlayer()->GetMapId(), x, y, z, target->GetOrientation());
target->SetPhaseMask(m_session->GetPlayer()->GetPhaseMask(), true);
}
else
{
// check offline security
if (HasLowerSecurity(NULL, target_guid))
return false;
std::string nameLink = playerLink(target_name);
PSendSysMessage(LANG_SUMMONING, nameLink.c_str(), GetTrinityString(LANG_OFFLINE));
// in point where GM stay
Player::SavePositionInDB(m_session->GetPlayer()->GetMapId(),
m_session->GetPlayer()->GetPositionX(),
m_session->GetPlayer()->GetPositionY(),
m_session->GetPlayer()->GetPositionZ(),
m_session->GetPlayer()->GetOrientation(),
m_session->GetPlayer()->GetZoneId(),
target_guid);
}
return true;
}
bool ChatHandler::HandlePlayerbotCommand(char* args)
{
if (!(m_session->GetSecurity() > SEC_PLAYER))
if (botConfig.GetBoolDefault("PlayerbotAI.DisableBots", false))
{
PSendSysMessage("|cffff0000Playerbot system is currently disabled!");
SetSentErrorMessage(true);
return false;
}
if (!m_session)
{
PSendSysMessage("|cffff0000You may only add bots from an active session");
SetSentErrorMessage(true);
return false;
}
if (!*args)
{
PSendSysMessage("|cffff0000usage: add PLAYERNAME or remove PLAYERNAME");
SetSentErrorMessage(true);
return false;
}
char* cmd = strtok((char*) args, " ");
char* charname = strtok(nullptr, " ");
if (!cmd || !charname)
{
PSendSysMessage("|cffff0000usage: add PLAYERNAME or remove PLAYERNAME");
SetSentErrorMessage(true);
return false;
}
std::string cmdStr = cmd;
std::string charnameStr = charname;
if (!normalizePlayerName(charnameStr))
return false;
ObjectGuid guid = sObjectMgr.GetPlayerGuidByName(charnameStr.c_str());
if (guid == ObjectGuid() || (guid == m_session->GetPlayer()->GetObjectGuid()))
{
SendSysMessage(LANG_PLAYER_NOT_FOUND);
SetSentErrorMessage(true);
return false;
}
uint32 accountId = sObjectMgr.GetPlayerAccountIdByGUID(guid);
if (accountId != m_session->GetAccountId())
{
PSendSysMessage("|cffff0000You may only add bots from the same account.");
SetSentErrorMessage(true);
return false;
}
// create the playerbot manager if it doesn't already exist
PlayerbotMgr* mgr = m_session->GetPlayer()->GetPlayerbotMgr();
if (!mgr)
{
mgr = new PlayerbotMgr(m_session->GetPlayer());
m_session->GetPlayer()->SetPlayerbotMgr(mgr);
}
QueryResult* resultchar = CharacterDatabase.PQuery("SELECT COUNT(*) FROM characters WHERE online = '1' AND account = '%u'", m_session->GetAccountId());
if (resultchar)
{
Field* fields = resultchar->Fetch();
int acctcharcount = fields[0].GetUInt32();
int maxnum = botConfig.GetIntDefault("PlayerbotAI.MaxNumBots", 9);
if (!(m_session->GetSecurity() > SEC_PLAYER))
if (acctcharcount > maxnum && (cmdStr == "add" || cmdStr == "login"))
{
PSendSysMessage("|cffff0000You cannot summon anymore bots.(Current Max: |cffffffff%u)", maxnum);
SetSentErrorMessage(true);
delete resultchar;
return false;
}
delete resultchar;
}
QueryResult* resultlvl = CharacterDatabase.PQuery("SELECT level,name FROM characters WHERE guid = '%u'", guid.GetCounter());
if (resultlvl)
{
Field* fields = resultlvl->Fetch();
int charlvl = fields[0].GetUInt32();
int maxlvl = botConfig.GetIntDefault("PlayerbotAI.RestrictBotLevel", 60);
if (!(m_session->GetSecurity() > SEC_PLAYER))
if (charlvl > maxlvl)
{
PSendSysMessage("|cffff0000You cannot summon |cffffffff[%s]|cffff0000, it's level is too high.(Current Max:lvl |cffffffff%u)", fields[1].GetString(), maxlvl);
SetSentErrorMessage(true);
delete resultlvl;
return false;
}
delete resultlvl;
}
// end of gmconfig patch
if (cmdStr == "add" || cmdStr == "login")
{
if (mgr->GetPlayerBot(guid))
{
PSendSysMessage("Bot already exists in world.");
SetSentErrorMessage(true);
return false;
}
CharacterDatabase.DirectPExecute("UPDATE characters SET online = 1 WHERE guid = '%u'", guid.GetCounter());
mgr->LoginPlayerBot(guid);
PSendSysMessage("Bot added successfully.");
}
else if (cmdStr == "remove" || cmdStr == "logout")
{
if (!mgr->GetPlayerBot(guid))
{
PSendSysMessage("|cffff0000Bot can not be removed because bot does not exist in world.");
SetSentErrorMessage(true);
return false;
}
CharacterDatabase.DirectPExecute("UPDATE characters SET online = 0 WHERE guid = '%u'", guid.GetCounter());
mgr->LogoutPlayerBot(guid);
PSendSysMessage("Bot removed successfully.");
}
else if (cmdStr == "co" || cmdStr == "combatorder")
{
Unit* target = nullptr;
char* orderChar = strtok(nullptr, " ");
if (!orderChar)
{
PSendSysMessage("|cffff0000Syntax error:|cffffffff .bot co <botName> <order=reset|tank|assist|heal|protect> [targetPlayer]");
SetSentErrorMessage(true);
return false;
}
}
return true;
}
bool ChatHandler::HandleAccountCommand(const char* /*args*/)
{
AccountTypes gmlevel = GetAccessLevel();
PSendSysMessage(LANG_ACCOUNT_LEVEL, uint32(gmlevel));
return true;
}
bool ChatHandler::HandleServerVersionCommand(const char* /*args*/)
{
PSendSysMessage(_FULLVERSION);
return true;
}
bool ChatHandler::HandleServerUptimeCommand(const char* /*args*/)
{
std::string str = secsToTimeString(sWorld.GetUptime());
PSendSysMessage("%s", str.c_str());
return true;
}
bool ChatHandler::HandleServerDBVersionCommand(const char* /*args*/)
{
PSendSysMessage(LANG_USING_WORLD_DB,sWorld.GetDBVersion());
return true;
}
bool ChatHandler::HandlePunishCommand(char *args)
{
Player *plr = NULL;
std::string pname;
uint64 plr_guid = 0;
uint32 accid = 0;
if(!ExtractPlayerTarget(&args, &plr, NULL, &pname))
return false;
if(plr)
accid = plr->GetSession()->GetAccountId();
else
{
std::string pname_esc(pname);
CharacterDatabase.escape_string(pname_esc);
QueryResult *result = CharacterDatabase.PQuery("SELECT account FROM characters WHERE name = '%s'", pname_esc.c_str());
if(!result)
{
SendSysMessage(LANG_PLAYER_NOT_FOUND);
SetSentErrorMessage(true);
return false;
}
Field *fields = result->Fetch();
accid = fields[0].GetUInt32();
delete result;
}
// extra check, not sure if really necessary, but we better be on the safe side!
if(!accid)
{
SendSysMessage(LANG_PLAYER_NOT_FOUND);
SetSentErrorMessage(true);
return false;
}
// find only player from same account if any
if (!plr)
{
if (WorldSession* session = sWorld.FindSession(accid))
{
plr = session->GetPlayer();
pname = plr->GetName();
}
}
char *what = ExtractArg(&args);
char *reason = ExtractArg(&args);
std::string strWhat(what ? what : "");
bool handled = sPunishMgr.Handle(accid, plr, m_session->GetPlayer(), pname, strWhat, reason ? reason : GetMangosString(LANG_NO_REASON_GIVEN));
if(!handled)
{
PSendSysMessage(LANG_NO_RECORD_IN_DB, strWhat.c_str());
SetSentErrorMessage(true);
return false;
}
return true;
}
//Teleport to Player
bool ChatHandler::HandleAppearCommand(const char* args)
{
Player* target;
uint64 target_guid;
std::string target_name;
if (!extractPlayerTarget((char*)args, &target, &target_guid, &target_name))
return false;
Player* _player = m_session->GetPlayer();
if (target == _player || target_guid == _player->GetGUID())
{
SendSysMessage(LANG_CANT_TELEPORT_SELF);
SetSentErrorMessage(true);
return false;
}
if (target)
{
// check online security
if (HasLowerSecurity(target, 0))
return false;
std::string chrNameLink = playerLink(target_name);
Map* cMap = target->GetMap();
if (cMap->IsBattlegroundOrArena())
{
// only allow if gm mode is on
if (!_player->isGameMaster())
{
PSendSysMessage(LANG_CANNOT_GO_TO_BG_GM, chrNameLink.c_str());
SetSentErrorMessage(true);
return false;
}
// if both players are in different bgs
else if (_player->GetBattlegroundId() && _player->GetBattlegroundId() != target->GetBattlegroundId())
_player->LeaveBattleground(false); // Note: should be changed so _player gets no Deserter debuff
// all's well, set bg id
// when porting out from the bg, it will be reset to 0
_player->SetBattlegroundId(target->GetBattlegroundId(), target->GetBattlegroundTypeId());
// remember current position as entry point for return at bg end teleportation
if (!_player->GetMap()->IsBattlegroundOrArena())
_player->SetBattlegroundEntryPoint();
}
else if (cMap->IsDungeon())
{
// we have to go to instance, and can go to player only if:
// 1) we are in his group (either as leader or as member)
// 2) we are not bound to any group and have GM mode on
if (_player->GetGroup())
{
// we are in group, we can go only if we are in the player group
if (_player->GetGroup() != target->GetGroup())
{
PSendSysMessage(LANG_CANNOT_GO_TO_INST_PARTY, chrNameLink.c_str());
SetSentErrorMessage(true);
return false;
}
}
else
{
// we are not in group, let's verify our GM mode
if (!_player->isGameMaster())
{
PSendSysMessage(LANG_CANNOT_GO_TO_INST_GM, chrNameLink.c_str());
SetSentErrorMessage(true);
return false;
}
}
// if the player or the player's group is bound to another instance
// the player will not be bound to another one
InstancePlayerBind *pBind = _player->GetBoundInstance(target->GetMapId(), target->GetDifficulty(cMap->IsRaid()));
if (!pBind)
{
Group *group = _player->GetGroup();
// if no bind exists, create a solo bind
InstanceGroupBind *gBind = group ? group->GetBoundInstance(target) : NULL; // if no bind exists, create a solo bind
if (!gBind)
if (InstanceSave *save = sInstanceSaveMgr->GetInstanceSave(target->GetInstanceId()))
_player->BindToInstance(save, !save->CanReset());
}
if (cMap->IsRaid())
_player->SetRaidDifficulty(target->GetRaidDifficulty());
else
_player->SetDungeonDifficulty(target->GetDungeonDifficulty());
}
PSendSysMessage(LANG_APPEARING_AT, chrNameLink.c_str());
// stop flight if need
if (_player->isInFlight())
{
_player->GetMotionMaster()->MovementExpired();
_player->CleanupAfterTaxiFlight();
}
// save only in non-flight case
else
_player->SaveRecallPosition();
// to point to see at target with same orientation
float x, y, z;
target->GetContactPoint(_player, x, y, z);
_player->TeleportTo(target->GetMapId(), x, y, z, _player->GetAngle(target), TELE_TO_GM_MODE);
_player->SetPhaseMask(target->GetPhaseMask(), true);
}
else
{
// check offline security
if (HasLowerSecurity(NULL, target_guid))
return false;
std::string nameLink = playerLink(target_name);
PSendSysMessage(LANG_APPEARING_AT, nameLink.c_str());
// to point where player stay (if loaded)
float x, y, z, o;
uint32 map;
bool in_flight;
if (!Player::LoadPositionFromDB(map, x, y, z, o, in_flight, target_guid))
return false;
// stop flight if need
if (_player->isInFlight())
{
_player->GetMotionMaster()->MovementExpired();
_player->CleanupAfterTaxiFlight();
}
// save only in non-flight case
else
_player->SaveRecallPosition();
_player->TeleportTo(map, x, y, z, _player->GetOrientation());
}
return true;
}
bool ChatHandler::HandleTargetAndDeleteObjectCommand(char *args)
{
QueryResult *result;
if(*args)
{
int32 id = atoi((char*)args);
if(id)
result = WorldDatabase.PQuery("SELECT `guid`, `id`, `position_x`, `position_y`, `position_z`, `orientation`, `map`, (POW(`position_x` - %f, 2) + POW(`position_y` - %f, 2) + POW(`position_z` - %f, 2)) as `order` FROM `gameobject` WHERE `map` = %i AND `id` = '%u' ORDER BY `order` ASC LIMIT 1", m_session->GetPlayer()->GetPositionX(), m_session->GetPlayer()->GetPositionY(), m_session->GetPlayer()->GetPositionZ(), m_session->GetPlayer()->GetMapId(),id);
else
result = WorldDatabase.PQuery(
"SELECT `guid`, `id`, `position_x`, `position_y`, `position_z`, `orientation`, `map`, (POW(`position_x` - %f, 2) + POW(`position_y` - %f, 2) + POW(`position_z` - %f, 2)) as `order` "
"FROM `gameobject`,`gameobject_template` WHERE `gameobject_template`.`entry` = `gameobject`.`id` AND `map` = %i AND `name` LIKE '%%%s%%' ORDER BY `order` ASC LIMIT 1",
m_session->GetPlayer()->GetPositionX(), m_session->GetPlayer()->GetPositionY(), m_session->GetPlayer()->GetPositionZ(), m_session->GetPlayer()->GetMapId(),args);
}
else
result = WorldDatabase.PQuery("SELECT `guid`, `id`, `position_x`, `position_y`, `position_z`, `orientation`, `map`, (POW(`position_x` - %f, 2) + POW(`position_y` - %f, 2) + POW(`position_z` - %f, 2)) as `order` FROM `gameobject` WHERE `map` = %i ORDER BY `order` ASC LIMIT 1", m_session->GetPlayer()->GetPositionX(), m_session->GetPlayer()->GetPositionY(), m_session->GetPlayer()->GetPositionZ(), m_session->GetPlayer()->GetMapId());
if (!result)
{
SendSysMessage("Nothing found!");
return true;
}
Field *fields = result->Fetch();
uint32 guid = fields[0].GetUInt32();
uint32 id = fields[1].GetUInt32();
float x = fields[2].GetFloat();
float y = fields[3].GetFloat();
float z = fields[4].GetFloat();
float o = fields[5].GetFloat();
int mapid = fields[6].GetUInt16();
delete result;
const GameObjectInfo *goI = sObjectMgr.GetGameObjectInfo(id);
if (!goI)
{
PSendSysMessage(LANG_GAMEOBJECT_NOT_EXIST,id);
return false;
}
GameObject* obj = m_session->GetPlayer()->GetMap()->GetGameObject(ObjectGuid(HIGHGUID_GAMEOBJECT, guid, id));
if(!obj)
{
PSendSysMessage("Game Object (GUID: %u) not found", GUID_LOPART(guid));
return true;
}
uint64 owner_guid = obj->GetOwnerGUID();
if(owner_guid)
{
Unit* owner = ObjectAccessor::Instance().GetUnit(*m_session->GetPlayer(),owner_guid);
if(!owner && GUID_HIPART(owner_guid)!=HIGHGUID_PLAYER)
{
PSendSysMessage("Game Object (GUID: %u) have references in not found creature %u GO list, can't be deleted.", GUID_LOPART(owner_guid), obj->GetGUIDLow());
return true;
}
owner->RemoveGameObject(obj,false);
}
obj->Delete();
obj->DeleteFromDB();
PSendSysMessage("Game Object (GUID: %u) [%s] removed", obj->GetGUIDLow(),goI->name);
return true;
}
bool ChatHandler::HandleLookupAreaCommand(const char* args)
{
if (!*args)
return false;
std::string namepart = args;
std::wstring wnamepart;
if (!Utf8toWStr (namepart, wnamepart))
return false;
bool found = false;
uint32 count = 0;
uint32 maxResults = sWorld->getIntConfig(CONFIG_MAX_RESULTS_LOOKUP_COMMANDS);
// converting string that we try to find to lower case
wstrToLower (wnamepart);
// Search in AreaTable.dbc
for (uint32 areaflag = 0; areaflag < sAreaStore.GetNumRows (); ++areaflag)
{
AreaTableEntry const *areaEntry = sAreaStore.LookupEntry (areaflag);
if (areaEntry)
{
int loc = GetSessionDbcLocale ();
std::string name = areaEntry->area_name[loc];
if (name.empty())
continue;
if (!Utf8FitTo (name, wnamepart))
{
loc = 0;
for (; loc < TOTAL_LOCALES; ++loc)
{
if (loc == GetSessionDbcLocale ())
continue;
name = areaEntry->area_name[loc];
if (name.empty ())
continue;
if (Utf8FitTo (name, wnamepart))
break;
}
}
if (loc < TOTAL_LOCALES)
{
if (maxResults && count++ == maxResults)
{
PSendSysMessage(LANG_COMMAND_LOOKUP_MAX_RESULTS, maxResults);
return true;
}
// send area in "id - [name]" format
std::ostringstream ss;
if (m_session)
ss << areaEntry->ID << " - |cffffffff|Harea:" << areaEntry->ID << "|h[" << name << " " << localeNames[loc]<< "]|h|r";
else
ss << areaEntry->ID << " - " << name << " " << localeNames[loc];
SendSysMessage (ss.str ().c_str());
if (!found)
found = true;
}
}
}
if (!found)
SendSysMessage (LANG_COMMAND_NOAREAFOUND);
return true;
}
bool ChatHandler::HandlePlayerbotCommand(const char* args)
{
if (! m_session)
{
PSendSysMessage("You may only add bots from an active session");
SetSentErrorMessage(true);
return false;
}
if (!*args)
{
PSendSysMessage("usage: add PLAYERNAME or remove PLAYERNAME");
SetSentErrorMessage(true);
return false;
}
char *cmd = strtok ((char*)args, " ");
char *charname = strtok (NULL, " ");
if (!cmd || !charname)
{
PSendSysMessage("usage: add PLAYERNAME or remove PLAYERNAME");
SetSentErrorMessage(true);
return false;
}
std::string cmdStr = cmd;
std::string charnameStr = charname;
if(!normalizePlayerName(charnameStr))
return false;
uint64 guid = objmgr.GetPlayerGUIDByName(charnameStr.c_str());
if (guid == 0 || (guid == m_session->GetPlayer()->GetGUID()))
{
SendSysMessage(LANG_PLAYER_NOT_FOUND);
SetSentErrorMessage(true);
return false;
}
uint32 accountId = objmgr.GetPlayerAccountIdByGUID(guid);
if (accountId != m_session->GetAccountId()) {
PSendSysMessage("You may only add bots from the same account.");
SetSentErrorMessage(true);
return false;
}
// create the playerbot manager if it doesn't already exist
PlayerbotMgr* mgr = m_session->GetPlayer()->GetPlayerbotMgr();
if (!mgr)
{
mgr = new PlayerbotMgr(m_session->GetPlayer());
m_session->GetPlayer()->SetPlayerbotMgr(mgr);
}
if (cmdStr == "add" || cmdStr == "login")
{
if (mgr->GetPlayerBot(guid)) {
PSendSysMessage("Bot already exists in world.");
SetSentErrorMessage(true);
return false;
}
mgr->AddPlayerBot(guid);
PSendSysMessage("Bot added successfully.");
}
else if (cmdStr == "remove" || cmdStr == "logout")
{
if (! mgr->GetPlayerBot(guid)) {
PSendSysMessage("Bot can not be removed because bot does not exist in world.");
SetSentErrorMessage(true);
return false;
}
mgr->LogoutPlayerBot(guid);
PSendSysMessage("Bot removed successfully.");
}
else if (cmdStr == "co" || cmdStr == "combatorder")
{
Unit *target = 0;
char *orderChar = strtok( NULL, " " );
if( !orderChar ) {
PSendSysMessage("Syntax error: .bot co <botName> <order=reset|tank|assist|heal|protect> [targetPlayer]");
SetSentErrorMessage(true);
return false;
}
std::string orderStr = orderChar;
if( orderStr == "protect" || orderStr == "assist" ) {
char *targetChar = strtok( NULL, " " );
uint64 targetGUID = m_session->GetPlayer()->GetSelection();
if( !targetChar && !targetGUID ) {
PSendSysMessage("Combat orders protect and assist expect a target either by selection or by giving target player in command string!");
SetSentErrorMessage(true);
return false;
}
std::string targetStr = targetChar;
if( targetChar ) {
targetGUID = objmgr.GetPlayerGUIDByName( targetStr.c_str() );
}
target = ObjectAccessor::GetUnit( *m_session->GetPlayer(), targetGUID );
if( !target ) {
PSendSysMessage("Invalid target for combat order protect or assist!");
SetSentErrorMessage(true);
return false;
}
}
if (mgr->GetPlayerBot(guid) == NULL) {
PSendSysMessage("Bot can not receive combat order because bot does not exist in world.");
SetSentErrorMessage(true);
return false;
}
mgr->GetPlayerBot( guid )->GetPlayerbotAI()->SetCombatOrderByStr( orderStr, target );
}
return true;
}
//Summon group of player
bool ChatHandler::HandleGroupSummonCommand(const char* args)
{
Player* target;
if (!extractPlayerTarget((char*)args, &target))
return false;
// check online security
if (HasLowerSecurity(target, 0))
return false;
Group *grp = target->GetGroup();
std::string nameLink = GetNameLink(target);
if (!grp)
{
PSendSysMessage(LANG_NOT_IN_GROUP, nameLink.c_str());
SetSentErrorMessage(true);
return false;
}
Map* gmMap = m_session->GetPlayer()->GetMap();
bool to_instance = gmMap->Instanceable();
// we are in instance, and can summon only player in our group with us as lead
if (to_instance && (
!m_session->GetPlayer()->GetGroup() || (grp->GetLeaderGUID() != m_session->GetPlayer()->GetGUID()) ||
(m_session->GetPlayer()->GetGroup()->GetLeaderGUID() != m_session->GetPlayer()->GetGUID())))
// the last check is a bit excessive, but let it be, just in case
{
SendSysMessage(LANG_CANNOT_SUMMON_TO_INST);
SetSentErrorMessage(true);
return false;
}
for (GroupReference *itr = grp->GetFirstMember(); itr != NULL; itr = itr->next())
{
Player *pl = itr->getSource();
if (!pl || pl == m_session->GetPlayer() || !pl->GetSession())
continue;
// check online security
if (HasLowerSecurity(pl, 0))
return false;
std::string plNameLink = GetNameLink(pl);
if (pl->IsBeingTeleported() == true)
{
PSendSysMessage(LANG_IS_TELEPORTED, plNameLink.c_str());
SetSentErrorMessage(true);
return false;
}
if (to_instance)
{
Map* plMap = pl->GetMap();
if (plMap->Instanceable() && plMap->GetInstanceId() != gmMap->GetInstanceId())
{
// cannot summon from instance to instance
PSendSysMessage(LANG_CANNOT_SUMMON_TO_INST, plNameLink.c_str());
SetSentErrorMessage(true);
return false;
}
}
PSendSysMessage(LANG_SUMMONING, plNameLink.c_str(), "");
if (needReportToTarget(pl))
ChatHandler(pl).PSendSysMessage(LANG_SUMMONED_BY, GetNameLink().c_str());
// stop flight if need
if (pl->isInFlight())
{
pl->GetMotionMaster()->MovementExpired();
pl->CleanupAfterTaxiFlight();
}
// save only in non-flight case
else
pl->SaveRecallPosition();
// before GM
float x, y, z;
m_session->GetPlayer()->GetClosePoint(x, y, z, pl->GetObjectSize());
pl->TeleportTo(m_session->GetPlayer()->GetMapId(), x, y, z, pl->GetOrientation());
}
return true;
}
bool ChatHandler::HandleGMTicketAssignToCommand(const char* args)
{
if (!*args)
return false;
char* tguid = strtok((char*)args, " ");
uint64 ticketGuid = atoi(tguid);
char* targetgm = strtok(NULL, " ");
if (!targetgm)
return false;
std::string targm = targetgm;
if (!normalizePlayerName(targm))
return false;
Player *cplr = m_session->GetPlayer();
GM_Ticket *ticket = sTicketMgr->GetGMTicket(ticketGuid);
if (!ticket || ticket->closed != 0)
{
SendSysMessage(LANG_COMMAND_TICKETNOTEXIST);
return true;
}
uint64 tarGUID = sObjectMgr->GetPlayerGUIDByName(targm.c_str());
uint64 accid = sObjectMgr->GetPlayerAccountIdByGUID(tarGUID);
uint32 gmlevel = sAccountMgr->GetSecurity(accid, realmID);
if (!tarGUID || gmlevel == SEC_PLAYER)
{
SendSysMessage(LANG_COMMAND_TICKETASSIGNERROR_A);
return true;
}
if (ticket->assignedToGM == tarGUID)
{
PSendSysMessage(LANG_COMMAND_TICKETASSIGNERROR_B, ticket->guid);
return true;
}
std::string gmname;
sObjectMgr->GetPlayerNameByGUID(tarGUID, gmname);
if (ticket->assignedToGM != 0 && ticket->assignedToGM != cplr->GetGUID())
{
PSendSysMessage(LANG_COMMAND_TICKETALREADYASSIGNED, ticket->guid, gmname.c_str());
return true;
}
ticket->assignedToGM = tarGUID;
if (gmlevel == SEC_ADMINISTRATOR && ticket->escalated == TICKET_IN_ESCALATION_QUEUE)
ticket->escalated = TICKET_ESCALATED_ASSIGNED;
else if (ticket->escalated == TICKET_UNASSIGNED)
ticket->escalated = TICKET_ASSIGNED;
sTicketMgr->AddOrUpdateGMTicket(*ticket);
std::stringstream ss;
ss << PGetParseString(LANG_COMMAND_TICKETLISTGUID, ticket->guid);
ss << PGetParseString(LANG_COMMAND_TICKETLISTNAME, ticket->name.c_str());
ss << PGetParseString(LANG_COMMAND_TICKETLISTASSIGNEDTO, gmname.c_str());
SendGlobalGMSysMessage(ss.str().c_str());
sTicketMgr->UpdateLastChange();
return true;
}
bool ChatHandler::HandlePartyInfoCommand(const char* args)
{
Player* target;
uint64 target_guid;
std::string target_name;
if (!extractPlayerTarget((char*)args,&target,&target_guid,&target_name))
return false;
uint32 accId = 0;
std::string username = "";
std::string status = "";
uint32 security = 0;
// get additional information from Player object
if (target)
{
std::string nameLink = playerLink(target_name);
if (Group *grp = target->GetGroup())
{
if (grp->isRaidGroup())
SendSysMessage("----------------Raid Group----------------");
else if (grp->isBGGroup())
SendSysMessage("----------------BG Group-----------------");
else if (grp->isLFGGroup())
SendSysMessage("----------------LFG Group----------------");
else
SendSysMessage("------------------Group------------------");
for (GroupReference *itr = grp->GetFirstMember(); itr != NULL; itr = itr->next())
{
Player *pl = itr->getSource();
if (!pl || pl == m_session->GetPlayer() || !pl->GetSession())
continue;
accId = pl->GetSession()->GetAccountId();
nameLink = playerLink(pl->GetName());
QueryResult result = LoginDatabase.PQuery("SELECT aa.gmlevel, a.username "
"FROM account a "
"LEFT JOIN account_access aa "
"ON (a.id = aa.id) "
"WHERE a.id = '%u'",accId);
if (result)
{
Field* fields = result->Fetch();
security = fields[0].GetUInt32();
username = fields[1].GetString();
}
if (grp->IsLeader(pl->GetGUID()))
{
status = "[Leader]";
}
else if (grp->IsAssistant(pl->GetGUID()))
{
status = "[Assistant]";
}
PSendSysMessage(LANG_PARTYINFO_PLAYER, (pl?"":GetTrinityString(LANG_OFFLINE)), nameLink.c_str(), username.c_str(), accId, security, status.c_str());
}
SendSysMessage("----------------------------------------");
}
else
{
PSendSysMessage(LANG_NOT_IN_GROUP,nameLink.c_str());
SetSentErrorMessage(true);
return false;
}
}
return true;
}
// Delete a user account and all associated characters in this realm
// todo - This function has to be enhanced to respect the login/realm split (delete char, delete account chars in realm, delete account chars in realm then delete account
bool ChatHandler::HandleAccountDeleteCommand(const char* args)
{
if (!*args)
return false;
///- Get the account name from the command line
char *account_name_str=strtok ((char*)args," ");
if (!account_name_str)
return false;
std::string account_name = account_name_str;
if (!AccountMgr::normalizeString(account_name))
{
PSendSysMessage(LANG_ACCOUNT_NOT_EXIST,account_name.c_str());
SetSentErrorMessage(true);
return false;
}
uint32 account_id = accmgr.GetId(account_name);
if (!account_id)
{
PSendSysMessage(LANG_ACCOUNT_NOT_EXIST,account_name.c_str());
SetSentErrorMessage(true);
return false;
}
// Commands not recommended call from chat, but support anyway
if (m_session)
{
uint32 targetSecurity = accmgr.GetSecurity(account_id);
// can delete only for account with less security
// This is also reject self apply in fact
if (targetSecurity >= m_session->GetSecurity())
{
SendSysMessage (LANG_YOURS_SECURITY_IS_LOW);
SetSentErrorMessage (true);
return false;
}
}
AccountOpResult result = accmgr.DeleteAccount(account_id);
switch(result)
{
case AOR_OK:
PSendSysMessage(LANG_ACCOUNT_DELETED,account_name.c_str());
break;
case AOR_NAME_NOT_EXIST:
PSendSysMessage(LANG_ACCOUNT_NOT_EXIST,account_name.c_str());
SetSentErrorMessage(true);
return false;
case AOR_DB_INTERNAL_ERROR:
PSendSysMessage(LANG_ACCOUNT_NOT_DELETED_SQL_ERROR,account_name.c_str());
SetSentErrorMessage(true);
return false;
default:
PSendSysMessage(LANG_ACCOUNT_NOT_DELETED,account_name.c_str());
SetSentErrorMessage(true);
return false;
}
return true;
}
bool ChatHandler::HandleAcctCommand(const char* args)
{
uint32 gmlevel = m_session->GetSecurity();
PSendSysMessage(LANG_ACCOUNT_LEVEL, gmlevel);
return true;
}
bool ChatHandler::HandleAccountCommand(const char* /*args*/)
{
AccountTypes gmlevel = m_session->GetSecurity();
PSendSysMessage(LANG_ACCOUNT_LEVEL, uint32(gmlevel));
return true;
}
bool ChatHandler::HandleShowHonor(const char* args)
{
uint32 dishonorable_kills = m_session->GetPlayer()->GetUInt32Value(PLAYER_FIELD_LIFETIME_DISHONORABLE_KILLS);
uint32 honorable_kills = m_session->GetPlayer()->GetUInt32Value(PLAYER_FIELD_LIFETIME_HONORABLE_KILLS);
uint32 highest_rank = (m_session->GetPlayer()->GetHonorHighestRank() < 16)? m_session->GetPlayer()->GetHonorHighestRank() : 0;
uint32 today_honorable_kills = (uint16)m_session->GetPlayer()->GetUInt32Value(PLAYER_FIELD_SESSION_KILLS);
uint32 today_dishonorable_kills = (uint16)(m_session->GetPlayer()->GetUInt32Value(PLAYER_FIELD_SESSION_KILLS)>>16);
uint32 yesterday_kills = m_session->GetPlayer()->GetUInt32Value(PLAYER_FIELD_YESTERDAY_KILLS);
uint32 yesterday_honor = m_session->GetPlayer()->GetUInt32Value(PLAYER_FIELD_YESTERDAY_CONTRIBUTION);
uint32 this_week_kills = m_session->GetPlayer()->GetUInt32Value(PLAYER_FIELD_THIS_WEEK_KILLS);
uint32 this_week_honor = m_session->GetPlayer()->GetUInt32Value(PLAYER_FIELD_THIS_WEEK_CONTRIBUTION);
uint32 last_week_kills = m_session->GetPlayer()->GetUInt32Value(PLAYER_FIELD_LAST_WEEK_KILLS);
uint32 last_week_honor = m_session->GetPlayer()->GetUInt32Value(PLAYER_FIELD_LAST_WEEK_CONTRIBUTION);
uint32 last_week_standing = m_session->GetPlayer()->GetUInt32Value(PLAYER_FIELD_LAST_WEEK_RANK);
std::string alliance_ranks[] =
{
"",
LANG_ALI_PRIVATE,
LANG_ALI_CORPORAL,
LANG_ALI_SERGEANT,
LANG_ALI_MASTER_SERGEANT,
LANG_ALI_SERGEANT_MAJOR,
LANG_ALI_KNIGHT,
LANG_ALI_KNIGHT_LIEUTENANT,
LANG_ALI_KNIGHT_CAPTAIN,
LANG_ALI_KNIGHT_CHAMPION,
LANG_ALI_LIEUTENANT_COMMANDER,
LANG_ALI_COMMANDER,
LANG_ALI_MARSHAL,
LANG_ALI_FIELD_MARSHAL,
LANG_ALI_GRAND_MARSHAL,
LANG_ALI_GAME_MASTER
};
std::string horde_ranks[] =
{
"",
LANG_HRD_SCOUT,
LANG_HRD_GRUNT,
LANG_HRD_SERGEANT,
LANG_HRD_SENIOR_SERGEANT,
LANG_HRD_FIRST_SERGEANT,
LANG_HRD_STONE_GUARD,
LANG_HRD_BLOOD_GUARD,
LANG_HRD_LEGIONNARE,
LANG_HRD_CENTURION,
LANG_HRD_CHAMPION,
LANG_HRD_LIEUTENANT_GENERAL,
LANG_HRD_GENERAL,
LANG_HRD_WARLORD,
LANG_HRD_HIGH_WARLORD,
LANG_HRD_GAME_MASTER
};
std::string rank_name;
std::string hrank_name;
if ( m_session->GetPlayer()->GetTeam() == ALLIANCE )
{
rank_name = alliance_ranks[ m_session->GetPlayer()->CalculateHonorRank( m_session->GetPlayer()->GetTotalHonor() ) ];
hrank_name = alliance_ranks[ highest_rank ];
}
else
if ( m_session->GetPlayer()->GetTeam() == HORDE )
{
rank_name = horde_ranks[ m_session->GetPlayer()->CalculateHonorRank( m_session->GetPlayer()->GetTotalHonor() ) ];
hrank_name = horde_ranks[ highest_rank ];
}
else
{
rank_name = LANG_NO_RANK;
}
PSendSysMessage(LANG_RANK, rank_name.c_str(), m_session->GetPlayer()->GetName(), m_session->GetPlayer()->CalculateHonorRank( m_session->GetPlayer()->GetTotalHonor() ));
PSendSysMessage(LANG_HONOR_TODAY, today_honorable_kills, today_dishonorable_kills);
PSendSysMessage(LANG_HONOR_YESTERDAY, yesterday_kills, yesterday_honor);
PSendSysMessage(LANG_HONOR_THIS_WEEK, this_week_kills, this_week_honor);
PSendSysMessage(LANG_HONOR_LAST_WEEK, last_week_kills, last_week_honor, last_week_standing);
PSendSysMessage(LANG_HONOR_LIFE, honorable_kills, dishonorable_kills, highest_rank, hrank_name.c_str());
return true;
}
//show info of player
bool ChatHandler::HandlePInfoCommand(const char* args)
{
Player* target;
uint64 target_guid;
std::string target_name;
if (!extractPlayerTarget((char*)args, &target, &target_guid, &target_name))
return false;
uint32 accId = 0;
uint32 money = 0;
uint32 total_player_time = 0;
uint8 level = 0;
uint32 latency = 0;
uint8 race;
uint8 Class;
int64 muteTime = 0;
int64 banTime = -1;
// get additional information from Player object
if (target)
{
// check online security
if (HasLowerSecurity(target, 0))
return false;
accId = target->GetSession()->GetAccountId();
money = target->GetMoney();
total_player_time = target->GetTotalPlayedTime();
level = target->getLevel();
latency = target->GetSession()->GetLatency();
race = target->getRace();
Class = target->getClass();
muteTime = target->GetSession()->m_muteTime;
}
// get additional information from DB
else
{
// check offline security
if (HasLowerSecurity(NULL, target_guid))
return false;
// 0 1 2 3 4 5
QueryResult result = CharacterDatabase.PQuery("SELECT totaltime, level, money, account, race, class FROM characters WHERE guid = '%u'", GUID_LOPART(target_guid));
if (!result)
return false;
Field *fields = result->Fetch();
total_player_time = fields[0].GetUInt32();
level = fields[1].GetUInt32();
money = fields[2].GetUInt32();
accId = fields[3].GetUInt32();
race = fields[4].GetUInt8();
Class = fields[5].GetUInt8();
}
std::string username = GetSingularityString(LANG_ERROR);
std::string email = GetSingularityString(LANG_ERROR);
std::string last_ip = GetSingularityString(LANG_ERROR);
uint32 security = 0;
std::string last_login = GetSingularityString(LANG_ERROR);
QueryResult result = LoginDatabase.PQuery("SELECT a.username, aa.gmlevel, a.email, a.last_ip, a.last_login, a.mutetime "
"FROM account a "
"LEFT JOIN account_access aa "
"ON (a.id = aa.id) "
"WHERE a.id = '%u'", accId);
if (result)
{
Field* fields = result->Fetch();
username = fields[0].GetString();
security = fields[1].GetUInt32();
email = fields[2].GetString();
muteTime = fields[5].GetUInt64();
if (email.empty())
email = "-";
if (!m_session || m_session->GetSecurity() >= AccountTypes(security))
{
last_ip = fields[3].GetString();
last_login = fields[4].GetString();
}
else
{
last_ip = "-";
last_login = "******";
}
}
std::string nameLink = playerLink(target_name);
PSendSysMessage(LANG_PINFO_ACCOUNT, (target?"":GetSingularityString(LANG_OFFLINE)), nameLink.c_str(), GUID_LOPART(target_guid), username.c_str(), accId, email.c_str(), security, last_ip.c_str(), last_login.c_str(), latency);
if (QueryResult result = LoginDatabase.PQuery("SELECT unbandate, bandate = unbandate FROM account_banned WHERE id = '%u' AND active ORDER BY bandate ASC LIMIT 1", accId))
{
Field * fields = result->Fetch();
banTime = fields[1].GetBool() ? 0 : fields[0].GetUInt64();
}
else if (QueryResult result = CharacterDatabase.PQuery("SELECT unbandate, bandate = unbandate FROM character_banned WHERE guid = '%u' AND active ORDER BY bandate ASC LIMIT 1", GUID_LOPART(target_guid)))
{
Field * fields = result->Fetch();
banTime = fields[1].GetBool() ? 0 : fields[0].GetUInt64();
}
muteTime = muteTime - time(NULL);
if (muteTime > 0 || banTime >= 0)
PSendSysMessage(LANG_PINFO_MUTE_BAN, muteTime > 0 ? secsToTimeString(muteTime, true).c_str() : "---", !banTime ? "perm." : (banTime > 0 ? secsToTimeString(banTime - time(NULL), true).c_str() : "---"));
std::string race_s, Class_s;
switch(race)
{
case RACE_HUMAN: race_s = "Human"; break;
case RACE_ORC: race_s = "Orc"; break;
case RACE_DWARF: race_s = "Dwarf"; break;
case RACE_NIGHTELF: race_s = "Night Elf"; break;
case RACE_UNDEAD_PLAYER: race_s = "Undead"; break;
case RACE_TAUREN: race_s = "Tauren"; break;
case RACE_GNOME: race_s = "Gnome"; break;
case RACE_TROLL: race_s = "Troll"; break;
case RACE_BLOODELF: race_s = "Blood Elf"; break;
case RACE_DRAENEI: race_s = "Draenei"; break;
}
switch(Class)
{
case CLASS_WARRIOR: Class_s = "Warrior"; break;
case CLASS_PALADIN: Class_s = "Paladin"; break;
case CLASS_HUNTER: Class_s = "Hunter"; break;
case CLASS_ROGUE: Class_s = "Rogue"; break;
case CLASS_PRIEST: Class_s = "Priest"; break;
case CLASS_DEATH_KNIGHT: Class_s = "Death Knight"; break;
case CLASS_SHAMAN: Class_s = "Shaman"; break;
case CLASS_MAGE: Class_s = "Mage"; break;
case CLASS_WARLOCK: Class_s = "Warlock"; break;
case CLASS_DRUID: Class_s = "Druid"; break;
}
std::string timeStr = secsToTimeString(total_player_time, true, true);
uint32 gold = money /GOLD;
uint32 silv = (money % GOLD) / SILVER;
uint32 copp = (money % GOLD) % SILVER;
PSendSysMessage(LANG_PINFO_LEVEL, race_s.c_str(), Class_s.c_str(), timeStr.c_str(), level, gold, silv, copp);
return true;
}
bool ChatHandler::HandleGMTicketAssignToCommand(const char* args)
{
if (!*args)
return false;
char* sTicketId = strtok((char*)args, " ");
uint32 ticketId = atoi(sTicketId);
char* sTarget = strtok(NULL, " ");
if (!sTarget)
return false;
std::string target(sTarget);
if (!normalizePlayerName(target))
return false;
GmTicket* ticket = sTicketMgr->GetTicket(ticketId);
if (!ticket || ticket->IsClosed())
{
SendSysMessage(LANG_COMMAND_TICKETNOTEXIST);
return true;
}
// Get target information
uint64 targetGuid = sObjectMgr->GetPlayerGUIDByName(target.c_str());
uint64 targetAccId = sObjectMgr->GetPlayerAccountIdByGUID(targetGuid);
uint32 targetGmLevel = AccountMgr::GetSecurity(targetAccId, realmID);
// Target must exist and have administrative rights
if (!targetGuid || AccountMgr::IsPlayerAccount(targetGmLevel))
{
SendSysMessage(LANG_COMMAND_TICKETASSIGNERROR_A);
return true;
}
// If already assigned, leave
if (ticket->IsAssignedTo(targetGuid))
{
PSendSysMessage(LANG_COMMAND_TICKETASSIGNERROR_B, ticket->GetId());
return true;
}
// If assigned to different player other than current, leave
//! Console can override though
Player* player = m_session ? m_session->GetPlayer() : NULL;
if (player && ticket->IsAssignedNotTo(player->GetGUID()))
{
PSendSysMessage(LANG_COMMAND_TICKETALREADYASSIGNED, ticket->GetId(), target.c_str());
return true;
}
// Assign ticket
SQLTransaction trans = SQLTransaction(NULL);
ticket->SetAssignedTo(targetGuid, AccountMgr::IsAdminAccount(targetGmLevel));
ticket->SaveToDB(trans);
sTicketMgr->UpdateLastChange();
std::string msg = ticket->FormatMessageString(*this, NULL, target.c_str(), NULL, NULL);
SendGlobalGMSysMessage(msg.c_str());
return true;
}
bool ChatHandler::HandleLookupTitleCommand(const char* args)
{
if (!*args)
return false;
// can be NULL in console call
Player* target = getSelectedPlayer();
// title name have single string arg for player name
char const* targetName = target ? target->GetName() : "NAME";
std::string namepart = args;
std::wstring wnamepart;
if (!Utf8toWStr(namepart, wnamepart))
return false;
// converting string that we try to find to lower case
wstrToLower(wnamepart);
uint32 counter = 0; // Counter for figure out that we found smth.
uint32 maxResults = sWorld->getIntConfig(CONFIG_MAX_RESULTS_LOOKUP_COMMANDS);
// Search in CharTitles.dbc
for (uint32 id = 0; id < sCharTitlesStore.GetNumRows(); id++)
{
CharTitlesEntry const *titleInfo = sCharTitlesStore.LookupEntry(id);
if (titleInfo)
{
int loc = GetSessionDbcLocale();
std::string name = titleInfo->name[loc];
if (name.empty())
continue;
if (!Utf8FitTo(name, wnamepart))
{
loc = 0;
for (; loc < TOTAL_LOCALES; ++loc)
{
if (loc == GetSessionDbcLocale())
continue;
name = titleInfo->name[loc];
if (name.empty())
continue;
if (Utf8FitTo(name, wnamepart))
break;
}
}
if (loc < TOTAL_LOCALES)
{
if (maxResults && counter == maxResults)
{
PSendSysMessage(LANG_COMMAND_LOOKUP_MAX_RESULTS, maxResults);
return true;
}
char const* knownStr = target && target->HasTitle(titleInfo) ? GetSingularityString(LANG_KNOWN) : "";
char const* activeStr = target && target->GetUInt32Value(PLAYER_CHOSEN_TITLE) == titleInfo->bit_index
? GetSingularityString(LANG_ACTIVE)
: "";
char titleNameStr[80];
snprintf(titleNameStr, 80, name.c_str(), targetName);
// send title in "id (idx:idx) - [namedlink locale]" format
if (m_session)
PSendSysMessage(LANG_TITLE_LIST_CHAT, id, titleInfo->bit_index, id, titleNameStr, localeNames[loc], knownStr, activeStr);
else
PSendSysMessage(LANG_TITLE_LIST_CONSOLE, id, titleInfo->bit_index, titleNameStr, localeNames[loc], knownStr, activeStr);
++counter;
}
}
}
if (counter == 0) // if counter == 0 then we found nth
SendSysMessage(LANG_COMMAND_NOTITLEFOUND);
return true;
}
bool ChatHandler::HandlePDumpLoadCommand(const char *args)
{
if (!*args)
return false;
char * file = strtok((char*)args, " ");
if (!file)
return false;
char * account = strtok(NULL, " ");
if (!account)
return false;
std::string account_name = account;
if (!AccountMgr::normalizeString(account_name))
{
PSendSysMessage(LANG_ACCOUNT_NOT_EXIST, account_name.c_str());
SetSentErrorMessage(true);
return false;
}
uint32 account_id = AccountMgr::GetId(account_name);
if (!account_id)
{
account_id = atoi(account); // use original string
if (!account_id)
{
PSendSysMessage(LANG_ACCOUNT_NOT_EXIST, account_name.c_str());
SetSentErrorMessage(true);
return false;
}
}
if (!AccountMgr::GetName(account_id, account_name))
{
PSendSysMessage(LANG_ACCOUNT_NOT_EXIST, account_name.c_str());
SetSentErrorMessage(true);
return false;
}
char* guid_str = NULL;
char* name_str = strtok(NULL, " ");
std::string name;
if (name_str)
{
name = name_str;
// normalize the name if specified and check if it exists
if (!normalizePlayerName(name))
{
PSendSysMessage(LANG_INVALID_CHARACTER_NAME);
SetSentErrorMessage(true);
return false;
}
if (ObjectMgr::CheckPlayerName(name, true) != CHAR_NAME_SUCCESS)
{
PSendSysMessage(LANG_INVALID_CHARACTER_NAME);
SetSentErrorMessage(true);
return false;
}
guid_str = strtok(NULL, " ");
}
uint32 guid = 0;
if (guid_str)
{
guid = atoi(guid_str);
if (!guid)
{
PSendSysMessage(LANG_INVALID_CHARACTER_GUID);
SetSentErrorMessage(true);
return false;
}
if (sObjectMgr->GetPlayerAccountIdByGUID(guid))
{
PSendSysMessage(LANG_CHARACTER_GUID_IN_USE, guid);
SetSentErrorMessage(true);
return false;
}
}
switch (PlayerDumpReader().LoadDump(file, account_id, name, guid))
{
case DUMP_SUCCESS:
PSendSysMessage(LANG_COMMAND_IMPORT_SUCCESS);
break;
case DUMP_FILE_OPEN_ERROR:
PSendSysMessage(LANG_FILE_OPEN_FAIL, file);
SetSentErrorMessage(true);
return false;
case DUMP_FILE_BROKEN:
PSendSysMessage(LANG_DUMP_BROKEN, file);
SetSentErrorMessage(true);
return false;
case DUMP_TOO_MANY_CHARS:
PSendSysMessage(LANG_ACCOUNT_CHARACTER_LIST_FULL, account_name.c_str(), account_id);
SetSentErrorMessage(true);
return false;
default:
PSendSysMessage(LANG_COMMAND_IMPORT_FAILED);
SetSentErrorMessage(true);
return false;
}
return true;
}