bool ChatHandler::HandleInfoCommand(const char* args, WorldSession *m_session)
{
WorldPacket data;
uint32 clientsNum = (uint32)sWorld.GetSessionCount();
int gm = 0;
int count = 0;
int avg = 0;
PlayerStorageMap::const_iterator itr;
objmgr._playerslock.AcquireReadLock();
for (itr = objmgr._players.begin(); itr != objmgr._players.end(); itr++)
{
if(itr->second->GetSession())
{
count++;
avg += itr->second->GetSession()->GetLatency();
if(itr->second->GetSession()->GetPermissionCount())
gm++;
}
}
objmgr._playerslock.ReleaseReadLock();
GreenSystemMessage(m_session, "Server Uptime: |r%s", sWorld.GetUptimeString().c_str());
GreenSystemMessage(m_session, "Current Players: |r%d (%d GMs, %d queued)", clientsNum, gm, 0);
GreenSystemMessage(m_session, "Average Latency: |r%.3fms", (float)((float)avg / (float)count));
return true;
}
bool ChatHandler::HandleReviveStringcommand(const char* args, WorldSession* m_session)
{
Player* plr = objmgr.GetPlayer(args, false);
if(!plr)
{
RedSystemMessage(m_session, "Could not find player %s.", args);
return true;
}
if(plr->IsDead())
{
if(plr->GetInstanceID() == m_session->GetPlayer()->GetInstanceID())
plr->RemoteRevive();
else
sEventMgr.AddEvent(plr, &Player::RemoteRevive, EVENT_PLAYER_REST, 1, 1, EVENT_FLAG_DO_NOT_EXECUTE_IN_WORLD_CONTEXT);
GreenSystemMessage(m_session, "Revived player %s.", args);
sGMLog.writefromsession(m_session, "revived player %s", args);
}
else
{
GreenSystemMessage(m_session, "Player %s is not dead.", args);
}
return true;
}
bool ChatHandler::HandleGMTicketToggleTicketSystemStatusCommand(const char* args, WorldSession *m_session)
{
if(sWorld.toggleGMTicketStatus())
GreenSystemMessage(m_session, "TicketSystem enabled.");
else
GreenSystemMessage(m_session, "TicketSystem disabled.");
return true;
}
//.gm list
bool ChatHandler::HandleGMListCommand(const char* /*args*/, WorldSession* m_session)
{
bool print_headline = true;
bool is_gamemaster = m_session->GetPermissionCount() != 0;
objmgr._playerslock.AcquireReadLock();
for (PlayerStorageMap::const_iterator itr = objmgr._players.begin(); itr != objmgr._players.end(); ++itr)
{
if (itr->second->GetSession()->GetPermissionCount())
{
if (!worldConfig.gm.listOnlyActiveGms)
{
if (print_headline)
GreenSystemMessage(m_session, "The following GMs are on this server:");
if (worldConfig.gm.hidePermissions && !is_gamemaster)
SystemMessage(m_session, " - %s", itr->second->GetName());
else
SystemMessage(m_session, " - %s [%s]", itr->second->GetName(), itr->second->GetSession()->GetPermissions());
print_headline = false;
}
else if (worldConfig.gm.listOnlyActiveGms && itr->second->isGMFlagSet())
{
if (itr->second->isGMFlagSet())
{
if (print_headline)
GreenSystemMessage(m_session, "The following GMs are active on this server:");
if (worldConfig.gm.hidePermissions && !is_gamemaster)
SystemMessage(m_session, " - %s", itr->second->GetName());
else
SystemMessage(m_session, " - %s [%s]", itr->second->GetName(), itr->second->GetSession()->GetPermissions());
print_headline = false;
}
else
{
SystemMessage(m_session, "No GMs are currently logged in on this server.");
print_headline = false;
}
}
}
}
objmgr._playerslock.ReleaseReadLock();
if (print_headline)
{
if (!worldConfig.gm.listOnlyActiveGms)
SystemMessage(m_session, "No GMs are currently logged in on this server.");
else
SystemMessage(m_session, "No GMs are currently active on this server.");
}
return true;
}
bool ChatHandler::HandleInfoCommand(const char* args, WorldSession *m_session)
{
WorldPacket data;
//uint32 clientsNum = (uint32)sWorld.GetSessionCount();
int gm = 0;
int count = 0;
int avg = 0;
PlayerStorageMap::const_iterator itr;
objmgr._playerslock.AcquireReadLock();
for (itr = objmgr._players.begin(); itr != objmgr._players.end(); itr++)
{
if(itr->second->GetSession())
{
count++;
avg += itr->second->GetSession()->GetLatency();
if(itr->second->GetSession()->GetPermissionCount())
gm++;
}
}
objmgr._playerslock.ReleaseReadLock();
GreenSystemMessage(m_session, "Server Revision: |r%sArcEmu r%u/%s-%s-%s %s(www.arcemu.org)", MSG_COLOR_WHITE,
BUILD_REVISION, CONFIG, PLATFORM_TEXT, ARCH, MSG_COLOR_LIGHTBLUE);
GreenSystemMessage(m_session, "Server Uptime: |r%s", sWorld.GetUptimeString().c_str());
GreenSystemMessage(m_session, "Current Players: |r%d (%d GMs) (%d Peak)", count, gm,(int)sWorld.PeakSessionCount);
GreenSystemMessage(m_session, "Active Thread Count: |r%u", ThreadPool.GetActiveThreadCount());
GreenSystemMessage(m_session, "Free Thread Count: |r%u", ThreadPool.GetFreeThreadCount());
GreenSystemMessage(m_session, "Average Latency: |r%.3fms", (float)((float)avg / (float)count));
GreenSystemMessage(m_session, "SQL Query Cache Size (World): |r%u queries delayed", WorldDatabase.GetQueueSize());
GreenSystemMessage(m_session, "SQL Query Cache Size (Character): |r%u queries delayed", CharacterDatabase.GetQueueSize());
return true;
}
//.guild removeplayer
bool ChatHandler::HandleGuildRemovePlayerCommand(const char* /*args*/, WorldSession* m_session)
{
Player* selected_player = GetSelectedPlayer(m_session, true, true);
if (selected_player == nullptr)
return true;
#if VERSION_STRING != Cata
if (selected_player->IsInGuild())
{
RedSystemMessage(m_session, "%s not in a guild.", selected_player->GetName());
return true;
}
#else
if (selected_player->GetGuild())
{
RedSystemMessage(m_session, "%s not in a guild.", selected_player->GetName());
return true;
}
#endif
#if VERSION_STRING != Cata
if (selected_player->GetGuild()->GetGuildLeader() != selected_player->getGuidLow() || !m_session->GetPlayer()->isGMFlagSet())
{
RedSystemMessage(m_session, "Only guild leaders and gms can remove players from a guild!");
return true;
}
GreenSystemMessage(m_session, "Kicked %s from Guild: %s", selected_player->GetName(), selected_player->GetGuild()->getGuildName());
if (selected_player != m_session->GetPlayer())
sGMLog.writefromsession(m_session, "Kicked %s from Guild %s", selected_player->GetName(), selected_player->GetGuild()->getGuildName());
selected_player->GetGuild()->RemoveGuildMember(selected_player->getPlayerInfo(), selected_player->GetSession());
#else
if (selected_player->GetGuild()->getLeaderGUID() != selected_player->getGuid() || !m_session->GetPlayer()->isGMFlagSet())
{
RedSystemMessage(m_session, "Only guild leaders and gms can remove players from a guild!");
return true;
}
GreenSystemMessage(m_session, "Kicked %s from Guild: %s", selected_player->GetName(), selected_player->GetGuild()->getName().c_str());
if (selected_player != m_session->GetPlayer())
sGMLog.writefromsession(m_session, "Kicked %s from Guild %s", selected_player->GetName(), selected_player->GetGuild()->getName().c_str());
selected_player->GetGuild()->handleRemoveMember(selected_player->GetSession(), selected_player->getGuid());
#endif
return true;
}
//.guild rename
bool ChatHandler::HandleRenameGuildCommand(const char* args, WorldSession* m_session)
{
Player* selected_player = GetSelectedPlayer(m_session, true, true);
if (selected_player == nullptr)
return true;
#if VERSION_STRING != Cata
if (selected_player->IsInGuild())
{
RedSystemMessage(m_session, "%s not in a guild.", selected_player->GetName());
return true;
}
#else
if (selected_player->GetGuild())
{
RedSystemMessage(m_session, "%s not in a guild.", selected_player->GetName());
return true;
}
#endif
if (!*args)
return false;
#if VERSION_STRING != Cata
Guild* guild = objmgr.GetGuildByGuildName(std::string(args));
#else
Guild* guild = sGuildMgr.getGuildByName(std::string(args));
#endif
if (guild != nullptr)
{
RedSystemMessage(m_session, "Guild name %s is already taken.", args);
return true;
}
else
{
#if VERSION_STRING != Cata
GreenSystemMessage(m_session, "Changed guild name of %s to %s. This will take effect next restart.", selected_player->GetGuild()->getGuildName(), args);
CharacterDatabase.Execute("UPDATE guilds SET `guildName` = \'%s\' WHERE `guildId` = '%u'", CharacterDatabase.EscapeString(std::string(args)).c_str(), selected_player->GetGuild()->getGuildId());
sGMLog.writefromsession(m_session, "Changed guild name of '%s' to '%s'", selected_player->GetGuild()->getGuildName(), args);
#else
GreenSystemMessage(m_session, "Changed guild name of %s to %s. This will take effect next restart.", selected_player->GetGuild()->getName().c_str(), args);
CharacterDatabase.Execute("UPDATE guilds SET `guildName` = \'%s\' WHERE `guildId` = '%u'", CharacterDatabase.EscapeString(std::string(args)).c_str(), selected_player->GetGuild()->getId());
sGMLog.writefromsession(m_session, "Changed guild name of '%s' to '%s'", selected_player->GetGuild()->getName().c_str(), args);
#endif
}
return true;
}
//.pet removespell
bool ChatHandler::HandlePetRemoveSpellCommand(const char* args, WorldSession* m_session)
{
Player* selected_player = GetSelectedPlayer(m_session, true, true);
if (selected_player == nullptr)
return true;
if (selected_player->GetSummon() == nullptr)
{
RedSystemMessage(m_session, "%s has no pet.", selected_player->GetName());
return true;
}
if (!*args)
return false;
uint32 SpellId = atol(args);
SpellInfo* spell_entry = sSpellCustomizations.GetSpellInfo(SpellId);
if (spell_entry == nullptr)
{
RedSystemMessage(m_session, "Invalid spell id requested.");
return true;
}
std::list<Pet*> summons = selected_player->GetSummons();
for (std::list<Pet*>::iterator itr = summons.begin(); itr != summons.end(); ++itr)
{
(*itr)->RemoveSpell(SpellId);
}
GreenSystemMessage(m_session, "Removed spell %u from %s's pet.", SpellId, selected_player->GetName());
return true;
}
bool ChatHandler::HandleGMListCommand(const char* args, WorldSession *m_session)
{
WorldPacket data;
bool first = true;
WorldSession *gm_session;
SessionSet::iterator itr;
sWorld.gmList_lock.AcquireReadLock();
for (itr = sWorld.gmList.begin(); itr != sWorld.gmList.end();)
{
gm_session = (*itr);
++itr;
if(first)
GreenSystemMessage(m_session, "There are following active GMs on this server:");
first = false;
if(gm_session->GetPlayer() && m_session != gm_session)
SystemMessage(m_session, "%s [%s]", gm_session->GetPlayer()->GetName(), gm_session->GetPermissions());
}
sWorld.gmList_lock.ReleaseReadLock();
if(first)
SystemMessage(m_session, "There are no GMs currently logged in on this server.");
return true;
}
bool ChatHandler::HandleTicketDeleteCommand(const char* args, WorldSession* m_session)
{
if (!args)
{
RedSystemMessage(m_session, "You need to specify a ticket ID");
return false;
}
Player* player = m_session->GetPlayer();
uint32 ticketID = atol(args);
QueryResult* result = CharacterDatabase.Query("SELECT * FROM gm_tickets WHERE ticketid = %u AND deleted = 1", ticketID);
if (!result)
{
RedSystemMessage(m_session, "Ticket %u is not available in gm_tickets table or not closed!", ticketID);
return false;
}
delete result;
CharacterDatabase.Execute("DELETE FROM gm_tickets WHERE ticketid = %u", ticketID);
GreenSystemMessage(m_session, "Ticket %u is deleted", ticketID);
sGMLog.writefromsession(m_session, "deleted ticket %u ", ticketID);
return true;
}
bool ChatHandler::HandleInvisibleCommand(const char *args, WorldSession *m_session)
{
char msg[256];
Player* pChar =m_session->GetPlayer();
snprintf(msg, 256, "Invisibility and Invincibility are now ");
if(pChar->m_isGmInvisible)
{
pChar->m_isGmInvisible = false;
pChar->m_invisible = false;
pChar->bInvincible = false;
pChar->Social_TellFriendsOnline();
if( pChar->m_bg )
{
pChar->m_bg->RemoveInvisGM();
}
snprintf(msg, 256, "%s OFF.", msg);
} else {
pChar->m_isGmInvisible = true;
pChar->m_invisible = true;
pChar->bInvincible = true;
pChar->Social_TellFriendsOffline();
if( pChar->m_bg )
{
pChar->m_bg->AddInvisGM();
}
snprintf(msg, 256, "%s ON.", msg);
}
snprintf(msg, 256, "%s You may have to leave and re-enter this zone for changes to take effect.", msg);
GreenSystemMessage(m_session, (const char*)msg);
return true;
}
bool ChatHandler::HandleAccountMuteCommand(const char* args, WorldSession* m_session)
{
if (!*args)
return false;
char* pAccount = (char*)args;
char* pDuration = strchr(pAccount, ' ');
if (pDuration == NULL)
return false;
*pDuration = 0;
++pDuration;
uint32_t timeperiod = Util::GetTimePeriodFromString(pDuration);
if (timeperiod == 0)
return false;
uint32 banned = (uint32)UNIXTIME + timeperiod;
sLogonCommHandler.setAccountMute(pAccount, banned);
std::string tsstr = Util::GetDateTimeStringFromTimeStamp(timeperiod + (uint32)UNIXTIME);
GreenSystemMessage(m_session, "Account '%s' has been muted until %s. The change will be effective immediately.", pAccount,
tsstr.c_str());
sGMLog.writefromsession(m_session, "mutex account %s until %s", pAccount, Util::GetDateTimeStringFromTimeStamp(timeperiod + (uint32)UNIXTIME).c_str());
WorldSession* pSession = sWorld.getSessionByAccountName(pAccount);
if (pSession != NULL)
{
pSession->m_muted = banned;
pSession->SystemMessage("Your voice has been muted until %s by a GM. Until this time, you will not be able to speak in any form.", tsstr.c_str());
}
return true;
}
bool ChatHandler::HandleGMListCommand(const char* args, WorldSession *m_session)
{
WorldPacket data;
bool first = true;
PlayerStorageMap::const_iterator itr;
objmgr._playerslock.AcquireReadLock();
for (itr = objmgr._players.begin(); itr != objmgr._players.end(); itr++)
{
if(itr->second->GetSession()->GetPermissionCount())
{
if(first)
GreenSystemMessage(m_session, "There are following active GMs on this server:");
SystemMessage(m_session, "%s [%s]", itr->second->GetName(), itr->second->GetSession()->GetPermissions());
first = false;
}
}
objmgr._playerslock.ReleaseReadLock();
if(first)
SystemMessage(m_session, "There are no GMs currently logged in on this server.");
return true;
}
bool ChatHandler::HandleUnlearnCommand(const char* args, WorldSession * m_session)
{
Player * plr = getSelectedChar(m_session, true);
if (plr == 0)
return true;
uint32 SpellId = atol(args);
if (SpellId == 0)
{
RedSystemMessage(m_session, "You must specify a spell id.");
return true;
}
sGMLog.writefromsession(m_session, "removed spell %u from %s", SpellId, plr->GetName());
if (plr->HasSpell(SpellId))
{
GreenSystemMessageToPlr(plr, "Removed spell %u.", SpellId);
GreenSystemMessage(m_session, "Removed spell %u from %s.", SpellId, plr->GetName());
plr->removeSpell(SpellId, false, false, 0);
}
else
{
RedSystemMessage(m_session, "That player does not have spell %u learnt.", SpellId);
}
return true;
}
bool ChatHandler::HandleAccountBannedCommand(const char* args, WorldSession* m_session)
{
if (!*args)
return false;
char* pAccount = (char*)args;
char* pReason;
char* pDuration;
ParseAccBanArgs(pAccount, &pDuration, &pReason);
uint32_t timeperiod = 0;
if (pDuration != NULL)
{
timeperiod = Util::GetTimePeriodFromString(pDuration);
if (timeperiod == 0)
return false;
}
uint32 banned = (timeperiod ? (uint32)UNIXTIME + timeperiod : 1);
char emptystring = 0;
if (pReason == NULL)
pReason = &emptystring;
sLogonCommHandler.setAccountBanned(pAccount, banned, pReason);
GreenSystemMessage(m_session, "Account '%s' has been banned %s%s for reason : %s. The change will be effective immediately.", pAccount,
timeperiod ? "until " : "forever", timeperiod ? Util::GetDateTimeStringFromTimeStamp(timeperiod + (uint32)UNIXTIME).c_str() : "", pReason);
sWorld.disconnectSessionByAccountName(pAccount, m_session);
sGMLog.writefromsession(m_session, "banned account %s until %s", pAccount, timeperiod ? Util::GetDateTimeStringFromTimeStamp(timeperiod + (uint32)UNIXTIME).c_str() : "permanent");
return true;
}
Player * ChatHandler::getSelectedChar(WorldSession *m_session, bool showerror)
{
uint64 guid;
Player *chr;
guid = m_session->GetPlayer()->GetSelection();
if (guid == 0)
{
if(showerror)
GreenSystemMessage(m_session, "Auto-targeting self.");
chr = m_session->GetPlayer(); // autoselect
}
else
chr = m_session->GetPlayer()->GetMapMgr()->GetPlayer(guid);
if(chr == NULL)
{
if(showerror)
RedSystemMessage(m_session, "This command requires that you select a player.");
return NULL;
}
return chr;
}
bool ChatHandler::HandleRecallDelCommand(const char* args, WorldSession *m_session)
{
if(!*args)
return false;
QueryResult *result = WorldDatabase.Query( "SELECT id,name FROM recall" );
if(!result)
return false;
do
{
Field *fields = result->Fetch();
float id = fields[0].GetFloat();
const char * locname = fields[1].GetString();
if (strnicmp((char*)args,locname,strlen(locname))==0)
{
std::stringstream ss;
ss << "DELETE FROM recall WHERE id = "<< (int)id <<";";
WorldDatabase.Execute( ss.str( ).c_str( ) );
GreenSystemMessage(m_session, "Recall location removed.");
sGMLog.writefromsession(m_session, "used recall delete, removed \"%s\" location from database.", args);
delete result;
return true;
}
}while (result->NextRow());
delete result;
return false;
}
//.pet dismiss
bool ChatHandler::HandlePetDismissCommand(const char* args, WorldSession* m_session)
{
Player* selected_player = GetSelectedPlayer(m_session, false, true);
Pet* selected_pet = nullptr;
if (selected_player != nullptr)
{
if (selected_player->GetSummon() == nullptr)
{
RedSystemMessage(m_session, "Player has no pet.");
return true;
}
else
{
selected_player->DismissActivePets();
}
}
else
{
// no player selected, see if it is a pet
Creature* selected_creature = GetSelectedCreature(m_session, false);
if (selected_creature == nullptr)
return false;
if (!selected_creature->IsPet())
return false;
selected_pet = static_cast< Pet* >(selected_creature);
selected_player = selected_pet->GetPetOwner();
selected_pet->Dismiss();
}
if (selected_player != m_session->GetPlayer())
{
GreenSystemMessage(m_session, "Dismissed %s's pet.", selected_player->GetName());
SystemMessage(selected_player->GetSession(), "%s dismissed your pet.", m_session->GetPlayer()->GetName());
sGMLog.writefromsession(m_session, "used dismiss pet command on player %s", selected_player->GetName());
}
else
{
GreenSystemMessage(m_session, "Your pet is dismissed.");
}
return true;
}
bool ChatHandler::HandleInfoCommand(const char* /*args*/, WorldSession* m_session)
{
//uint32 clientsNum = (uint32)sWorld.GetSessionCount();
uint16 gm = 0;
uint16 count = 0;
uint32 avg = 0;
objmgr._playerslock.AcquireReadLock();
for (PlayerStorageMap::const_iterator itr = objmgr._players.begin(); itr != objmgr._players.end(); ++itr)
{
if (itr->second->GetSession())
{
count++;
avg += itr->second->GetSession()->GetLatency();
if (itr->second->GetSession()->GetPermissionCount())
gm++;
}
}
objmgr._playerslock.ReleaseReadLock();
// GreenSystemMessage(m_session, "Server Revision: |r%EasyWOW %s/%s-%s-%s %s(github.com/EasyWoW/)", MSG_COLOR_WHITE,
// BUILD_HASH_STR, CONFIG, PLATFORM_TEXT, ARCH, MSG_COLOR_LIGHTBLUE);
GreenSystemMessage(m_session, "Server Uptime: |r%s", sWorld.GetUptimeString().c_str());
GreenSystemMessage(m_session, "Current Players: |r%d (%d GMs) (%u Peak)", count, gm, sWorld.PeakSessionCount);
GreenSystemMessage(m_session, "Active Thread Count: |r%u", ThreadPool.GetActiveThreadCount());
GreenSystemMessage(m_session, "Free Thread Count: |r%u", ThreadPool.GetFreeThreadCount());
GreenSystemMessage(m_session, "Average Latency: |r%.3fms", ((float)avg / (float)count));
GreenSystemMessage(m_session, "SQL Query Cache Size (World): |r%u queries delayed", WorldDatabase.GetQueueSize());
GreenSystemMessage(m_session, "SQL Query Cache Size (Character): |r%u queries delayed", CharacterDatabase.GetQueueSize());
return true;
}
void ChatHandler::GreenSystemMessageToPlr(Player* plr, const char *message, ...)
{
if( !message || !plr->GetSession() ) return;
va_list ap;
va_start(ap, message);
char msg1[1024];
vsnprintf(msg1,1024,message,ap);
GreenSystemMessage(plr->GetSession(), (const char*)msg1);
}
bool ChatHandler::HandleAddItemSetCommand(const char* args, WorldSession* m_session)
{
uint32 setid = (args ? atoi(args) : 0);
if(!setid)
{
RedSystemMessage(m_session, "You must specify a setid.");
return false;
}
Player* chr = getSelectedChar(m_session);
if(!chr)
{
RedSystemMessage(m_session, "Unable to select character.");
return false;
}
ItemSetEntry* entry = dbcItemSet.LookupEntryForced(setid);
std::list<ItemPrototype*>* l = objmgr.GetListForItemSet(setid);
if(!entry || !l)
{
RedSystemMessage(m_session, "Invalid item set.");
return false;
}
//const char* setname = sItemSetStore.LookupString(entry->name);
BlueSystemMessage(m_session, "Searching item set %u...", setid);
uint32 start = getMSTime();
sGMLog.writefromsession(m_session, "used add item set command, set %u, target %s", setid, chr->GetName());
for(std::list<ItemPrototype*>::iterator itr = l->begin(); itr != l->end(); ++itr)
{
Item* itm = objmgr.CreateItem((*itr)->ItemId, m_session->GetPlayer());
if(!itm)
continue;
if(itm->GetProto()->Bonding == ITEM_BIND_ON_PICKUP)
{
if(itm->GetProto()->Flags & ITEM_FLAG_ACCOUNTBOUND) // don't "Soulbind" account-bound items
itm->AccountBind();
else
itm->SoulBind();
}
if(!chr->GetItemInterface()->AddItemToFreeSlot(itm))
{
m_session->SendNotification("No free slots left!");
itm->DeleteMe();
return false;
}
else
{
//SystemMessage(m_session, "Added item: %s [%u]", (*itr)->Name1, (*itr)->ItemId);
SlotResult* le = chr->GetItemInterface()->LastSearchResult();
chr->SendItemPushResult(false, true, false, true, le->ContainerSlot, le->Slot, 1 , itm->GetEntry(), itm->GetItemRandomSuffixFactor(), itm->GetItemRandomPropertyId(), itm->GetStackCount());
}
}
GreenSystemMessage(m_session, "Added set to inventory complete. Time: %u ms", getMSTime() - start);
return true;
}
bool ChatHandler::HandleSaveCommand(const char* /*args*/, WorldSession* m_session)
{
Player* p_target = getSelectedChar(m_session, false);
if (!p_target)
return false;
p_target->SaveToDB(false);
GreenSystemMessage(m_session, "Player %s saved to DB", p_target->GetName());
return true;
}
bool ChatHandler::HandleGuildInfoCommand(const char* /*args*/, WorldSession* session)
{
Player* selected_player = GetSelectedPlayer(session, true, true);
if (selected_player == nullptr)
return true;
if (!selected_player->GetGuild())
{
RedSystemMessage(session, "%s is not in a guild.", selected_player->GetName());
return true;
}
GreenSystemMessage(session, "Player Guild Information:");
GreenSystemMessage(session, " GuildName: %s", selected_player->GetGuild()->getName().c_str());
GreenSystemMessage(session, " GuildId: %u", selected_player->GetGuild()->getId());
GreenSystemMessage(session, " Player rank: %u", selected_player->GetRankFromDB(selected_player->getGuid()));
return true;
}
bool ChatHandler::HandleRenameCommand(const char * args, WorldSession * m_session)
{
// prevent buffer overflow
if(strlen(args) > 100)
return false;
char name1[100];
char name2[100];
if(sscanf(args, "%s %s", name1, name2) != 2)
return false;
if(VerifyName(name2, strlen(name2)) == false)
{
RedSystemMessage(m_session, "That name is invalid or contains invalid characters.");
return true;
}
string new_name = name2;
PlayerInfo * pi = objmgr.GetPlayerInfoByName(name1);
if(pi == 0)
{
RedSystemMessage(m_session, "Player not found with this name.");
return true;
}
if( objmgr.GetPlayerInfoByName(new_name.c_str()) != NULL )
{
RedSystemMessage(m_session, "Player found with this name in use already.");
return true;
}
objmgr.RenamePlayerInfo(pi, pi->name, new_name.c_str());
free(pi->name);
pi->name = strdup(new_name.c_str());
// look in world for him
Player* plr = objmgr.GetPlayer(pi->guid);
if(plr != 0)
{
plr->SetName(new_name);
BlueSystemMessageToPlr(plr, "%s changed your name to '%s'.", m_session->GetPlayer()->GetName(), new_name.c_str());
plr->SaveToDB(false);
}
else
{
CharacterDatabase.WaitExecute("UPDATE characters SET name = '%s' WHERE guid = %u", CharacterDatabase.EscapeString(new_name).c_str(), (uint32)pi->guid);
}
GreenSystemMessage(m_session, "Changed name of '%s' to '%s'.", (char*)name1, (char*)name2);
sGMLog.writefromsession(m_session, "renamed character %s (GUID: %u) to %s", (char*)name1, pi->guid, (char*)name2);
sPlrLog.writefromsession(m_session, "GM renamed character %s (GUID: %u) to %s", (char*)name1, pi->guid, ((char*)name2));
return true;
}
//.guild listmembers
bool ChatHandler::HandleGuildListMembersCommand(const char* /*args*/, WorldSession* m_session)
{
Player* selected_player = GetSelectedPlayer(m_session, true, true);
if (selected_player == nullptr)
return true;
#if VERSION_STRING != Cata
if (selected_player->IsInGuild())
{
RedSystemMessage(m_session, "%s not in a guild.", selected_player->GetName());
return true;
}
#else
if (selected_player->GetGuild())
{
RedSystemMessage(m_session, "%s not in a guild.", selected_player->GetName());
return true;
}
#endif
#if VERSION_STRING != Cata
GreenSystemMessage(m_session, "Now showing guild members for %s", selected_player->GetGuild()->getGuildName());
#else
GreenSystemMessage(m_session, "Now showing guild members for %s", selected_player->GetGuild()->getName().c_str());
#endif
#if VERSION_STRING != Cata
selected_player->GetGuild()->Lock();
for (GuildMemberMap::iterator itr = selected_player->GetGuild()->GetGuildMembersBegin(); itr != selected_player->GetGuild()->GetGuildMembersEnd(); ++itr)
{
GuildMember* member = itr->second;
if (!member || !member->pPlayer)
continue;
BlueSystemMessage(m_session, "%s (Rank: %s)", member->pPlayer->name, member->pRank->szRankName);
}
selected_player->GetGuild()->Unlock();
#endif
return true;
}
bool ChatHandler::HandleNextDayCommand(const char* args, WorldSession* m_session)
{
Player * plr = getSelectedChar(m_session);
if(plr == 0)
return true;
BlueSystemMessage(m_session, "Moving honor fields to tomorrow for player %s.", plr->GetName());
GreenSystemMessage(m_session, "%s moved your honor fields to tomorrow.", m_session->GetPlayer()->GetName());
HonorHandler::DailyFieldMove(plr);
return true;
}
bool ChatHandler::HandleRecallDelCommand(const char* args, WorldSession *m_session)
{
if(!*args)
return false;
if(!objmgr.DeleteRecallLocation(std::string(args)))
return false;
GreenSystemMessage(m_session, "Removed location %s", args);
sWorld.LogGM(m_session, "used recall add, added \"%s\" location to database.", args);
return true;
}
bool ChatHandler::HandleAccountUnbanCommand(const char* args, WorldSession* m_session)
{
if (!*args)
return false;
char* pAccount = (char*)args;
sLogonCommHandler.setAccountBanned(pAccount, 0, "");
GreenSystemMessage(m_session, "Account '%s' has been unbanned. This change will be effective immediately.", pAccount);
sGMLog.writefromsession(m_session, "unbanned account %s", pAccount);
return true;
}
bool ChatHandler::HandleInfoCommand(const char* args, WorldSession *m_session)
{
WorldPacket data;
uint32 clientsNum = sWorld.GetSessionCount();
int gm = 0;
int count = 0;
int avg = 0;
HM_NAMESPACE::hash_map<uint32, Player*>::const_iterator itr;
objmgr._playerslock.AcquireReadLock();
for (itr = objmgr._players.begin(); itr != objmgr._players.end(); itr++)
{
if(itr->second->GetSession())
{
count++;
avg += itr->second->GetSession()->GetLatency();
if(itr->second->GetSession()->GetPermissionCount())
gm++;
}
}
objmgr._playerslock.ReleaseReadLock();
GreenSystemMessage(m_session, "Server Uptime: |r%s", sWorld.GetUptimeString().c_str());
GreenSystemMessage(m_session, "Current Players: |r%d (%d GMs, %d queued)", clientsNum, gm, 0);
GreenSystemMessage(m_session, "Thread Count: |r%u", sThreadMgr.GetThreadCount());
GreenSystemMessage(m_session, "Average Latency: |r%.3fms", (float)((float)avg / (float)count));
GreenSystemMessage(m_session, "SQL Query Cache Size (World): |r%u queries delayed", ((MySQLDatabase*)Database_World)->GetQueueSize());
GreenSystemMessage(m_session, "SQL Query Cache Size (Character): |r%u queries delayed", ((MySQLDatabase*)Database_Character)->GetQueueSize());
return true;
}
bool ChatHandler::HandleAddHonorCommand(const char* args, WorldSession* m_session)
{
uint32 HonorAmount = args ? atol(args) : 1;
Player *plr = getSelectedChar(m_session, true);
if(plr == 0)
return true;
BlueSystemMessage(m_session, "Adding %u honor to player %s.", HonorAmount, plr->GetName());
GreenSystemMessage(plr->GetSession(), "You have had %u honor points added to your character.", HonorAmount);
HonorHandler::AddHonorPointsToPlayer(plr, HonorAmount);
return true;
}
