void Chat::removeUserFromAllChannels(const Player& player)
{
for (auto& it : normalChannels) {
it.second.removeUser(player);
}
for (auto& it : partyChannels) {
it.second.removeUser(player);
}
for (auto& it : guildChannels) {
it.second.removeUser(player);
}
auto it = privateChannels.begin();
while (it != privateChannels.end()) {
PrivateChatChannel* channel = &it->second;
channel->removeInvite(player.getGUID());
channel->removeUser(player);
if (channel->getOwner() == player.getGUID()) {
channel->closeChannel();
it = privateChannels.erase(it);
} else {
++it;
}
}
}
ChatChannel* Chat::createChannel(Player* player, uint16_t channelId)
{
if(!player || player->isRemoved() || getChannel(player, channelId))
return NULL;
switch(channelId)
{
case CHANNEL_GUILD:
{
ChatChannel* newChannel = NULL;
if((newChannel = new ChatChannel(channelId, player->getGuildName(), ChatChannel::staticFlags)))
m_guildChannels[player->getGuildId()] = newChannel;
return newChannel;
}
case CHANNEL_PARTY:
{
ChatChannel* newChannel = NULL;
if(player->getParty() && (newChannel = new ChatChannel(channelId, partyName, ChatChannel::staticFlags)))
m_partyChannels[player->getParty()] = newChannel;
return newChannel;
}
case CHANNEL_PRIVATE:
{
//only 1 private channel for each premium player
if(!player->isPremium() || getPrivateChannel(player))
return NULL;
//find a free private channel slot
for(uint16_t i = 100; i < 10000; ++i)
{
if(m_privateChannels.find(i) != m_privateChannels.end())
continue;
uint16_t flags = 0;
if(dummyPrivate)
flags = dummyPrivate->getFlags();
PrivateChatChannel* newChannel = NULL;
if((newChannel = new PrivateChatChannel(i, player->getName() + "'s Channel", flags)))
{
newChannel->setOwner(player->getGUID());
m_privateChannels[i] = newChannel;
}
return newChannel;
}
}
default:
break;
}
return NULL;
}
PrivateChatChannel* Chat::getPrivateChannel(const Player& player)
{
for (PrivateChannelMap::iterator it = privateChannels.begin(); it != privateChannels.end(); ++it) {
PrivateChatChannel* channel = it->second;
if (channel->getOwner() == player.getGUID()) {
return channel;
}
}
return NULL;
}
ChannelList Chat::getChannelList(Player* player)
{
ChannelList list;
NormalChannelMap::iterator itn;
PrivateChannelMap::iterator it;
bool gotPrivate = false;
// If has guild
if(player->getGuildId() && player->getGuildName().length()){
ChatChannel *channel = getChannel(player, CHANNEL_GUILD);
if(channel)
list.push_back(channel);
else if((channel = createChannel(player, CHANNEL_GUILD)))
list.push_back(channel);
}
if(player->getParty()){
ChatChannel *channel = getChannel(player, CHANNEL_PARTY);
if(channel)
list.push_back(channel);
else if((channel = createChannel(player, CHANNEL_PARTY)))
list.push_back(channel);
}
for(itn = m_normalChannels.begin(); itn != m_normalChannels.end(); ++itn){
if(!player->hasFlag(PlayerFlag_CannotBeMuted)){
if(itn->first == CHANNEL_TRADE && player->getVocationId() == 0)
continue;
if(itn->first == CHANNEL_TRADE_ROOK && player->getVocationId() != 0)
continue;
}
ChatChannel *channel = itn->second;
list.push_back(channel);
}
for(it = m_privateChannels.begin(); it != m_privateChannels.end(); ++it){
PrivateChatChannel* channel = it->second;
if(channel){
if(channel->isInvited(player))
list.push_back(channel);
if(channel->getOwner() == player->getGUID())
gotPrivate = true;
}
}
if(!gotPrivate)
list.push_front(dummyPrivate);
return list;
}
ChatChannel* Chat::createChannel(Player* player, const uint16_t& channelId)
{
if (getChannel(player, channelId))
{
return NULL;
}
if (channelId == CHANNEL_GUILD)
{
ChatChannel* newChannel = new ChatChannel(channelId, player->getGuild()->getName());
m_guildChannels[player->getGuildId()] = newChannel;
return newChannel;
}
else if (channelId == CHANNEL_PARTY)
{
if (!player->getParty())
{
return NULL;
}
PrivateChatChannel* newChannel = new PrivateChatChannel(channelId, "Party");
m_partyChannels[player->getParty()] = newChannel;
return newChannel;
}
else if (channelId == CHANNEL_PRIVATE)
{
// Private chat channel
//only 1 private channel for each player
if (getPrivateChannel(player))
{
return NULL;
}
//find a free private channel slot
uint16_t i = getFreePrivateChannelId();
if (i != 0)
{
PrivateChatChannel* newChannel = new PrivateChatChannel(i, player->getName() + "'s Channel");
if (!newChannel)
{
return NULL;
}
newChannel->setOwner(player->getGUID());
m_privateChannels[i] = newChannel;
return newChannel;
}
}
return NULL;
}
bool Chat::deleteChannel(Party* party)
{
PartyChannelMap::iterator it = m_partyChannels.find(party);
if(it == m_partyChannels.end())
return false;
PrivateChatChannel* cc = it->second;
cc->closeChannel();
m_partyChannels.erase(it);
delete cc;
return true;
}
void Spectators::sendCreatureChannelSay(const Creature* creature, MessageClasses type, const std::string& text, uint16_t channelId, uint32_t statementId)
{
if(!owner)
return;
owner->sendCreatureChannelSay(creature, type, text, channelId, statementId);
PrivateChatChannel* tmp = g_chat.getPrivateChannel(owner->getPlayer());
if(!tmp || tmp->getId() != channelId)
return;
for(SpectatorList::iterator it = spectators.begin(); it != spectators.end(); ++it)
it->first->sendCreatureChannelSay(creature, type, text, channelId, statementId);
}
void Spectators::sendChannelMessage(std::string author, std::string text, MessageClasses type, uint16_t channel)
{
if(!owner)
return;
owner->sendChannelMessage(author, text, type, channel);
PrivateChatChannel* tmp = g_chat.getPrivateChannel(owner->getPlayer());
if(!tmp || tmp->getId() != channel)
return;
for(SpectatorList::iterator it = spectators.begin(); it != spectators.end(); ++it)
it->first->sendChannelMessage(author, text, type, channel);
}
ChatChannel* Chat::createChannel(const Player& player, uint16_t channelId)
{
if (getChannel(player, channelId)) {
return NULL;
}
switch (channelId) {
case CHANNEL_GUILD: {
Guild* guild = player.getGuild();
if (guild) {
ChatChannel* newChannel = new ChatChannel(channelId, guild->getName());
guildChannels[guild->getId()] = newChannel;
return newChannel;
}
break;
}
case CHANNEL_PARTY: {
Party* party = player.getParty();
if (party) {
ChatChannel* newChannel = new ChatChannel(channelId, "Party");
partyChannels[party] = newChannel;
return newChannel;
}
break;
}
case CHANNEL_PRIVATE: {
//only 1 private channel for each premium player
if (!player.isPremium() || getPrivateChannel(player)) {
return NULL;
}
//find a free private channel slot
for (uint16_t i = 100; i < 10000; ++i) {
if (privateChannels.find(i) == privateChannels.end()) {
PrivateChatChannel* newChannel = new PrivateChatChannel(i, player.getName() + "'s Channel");
newChannel->setOwner(player.getGUID());
privateChannels[i] = newChannel;
return newChannel;
}
}
break;
}
default:
break;
}
return NULL;
}
PrivateChatChannel* Chat::getPrivateChannel(Player* player)
{
if(!player || player->isRemoved())
return NULL;
PrivateChatChannel* channel = NULL;
for(PrivateChannelMap::iterator it = m_privateChannels.begin(); it != m_privateChannels.end(); ++it)
{
if((channel = it->second) && channel->getOwner() == player->getGUID())
return channel;
}
return NULL;
}
void Spectators::chat(uint16_t channelId)
{
if(!owner)
return;
PrivateChatChannel* tmp = g_chat.getPrivateChannel(owner->getPlayer());
if(!tmp || tmp->getId() != channelId)
return;
for(SpectatorList::iterator it = spectators.begin(); it != spectators.end(); ++it)
{
it->first->sendClosePrivate(channelId);
it->first->sendCreatureSay(owner->getPlayer(), MSG_PRIVATE, "Chat has been disabled.", NULL, 0);
}
}
void Spectators::sendCreatePrivateChannel(uint16_t channelId, const std::string& channelName)
{
if(!owner)
return;
owner->sendCreatePrivateChannel(channelId, channelName);
PrivateChatChannel* tmp = g_chat.getPrivateChannel(owner->getPlayer());
if(!tmp || tmp->getId() != channelId)
return;
for(SpectatorList::iterator it = spectators.begin(); it != spectators.end(); ++it)
{
it->first->sendCreatePrivateChannel(channelId, channelName);
it->first->sendCreatureSay(owner->getPlayer(), MSG_PRIVATE, "Chat has been enabled.", NULL, 0);
}
}
ChannelList Chat::getChannelList(Player* player)
{
ChannelList list;
NormalChannelMap::iterator itn;
PrivateChannelMap::iterator it;
bool gotPrivate = false;
// If has guild
if(player->getGuildId() && player->getGuildName().length()){
ChatChannel *channel = getChannel(player, 0x00);
if(channel)
list.push_back(channel);
else if((channel = createChannel(player, 0x00)))
list.push_back(channel);
}
for(itn = m_normalChannels.begin(); itn != m_normalChannels.end(); ++itn){
if(itn->first == 0x03 && !player->hasFlag(PlayerFlag_CanAnswerRuleViolations)){ //Rule violations channel
continue;
}
ChatChannel *channel = itn->second;
list.push_back(channel);
}
for(it = m_privateChannels.begin(); it != m_privateChannels.end(); ++it){
PrivateChatChannel* channel = it->second;
if(channel){
if(channel->isInvited(player))
list.push_back(channel);
if(channel->getOwner() == player->getGUID())
gotPrivate = true;
}
}
if(!gotPrivate)
list.push_front(dummyPrivate);
return list;
}
void Chat::removeUserFromAllChannels(const Player& player)
{
for (auto& it : normalChannels) {
it.second.removeUser(player);
}
for (const auto& it : partyChannels) {
it.second->removeUser(player);
}
for (const auto& it : guildChannels) {
it.second->removeUser(player);
}
for (const auto& it : privateChannels) {
PrivateChatChannel* channel = it.second;
channel->removeUser(player);
if (channel->getOwner() == player.getGUID()) {
deleteChannel(player, channel->getId());
}
}
}
ChannelList Chat::getChannelList(Player* player)
{
ChannelList list;
if(!player || player->isRemoved())
return list;
ChatChannel* channel = NULL;
if(player->getParty() && ((channel = getChannel(player, CHANNEL_PARTY)) || (channel = createChannel(player, CHANNEL_PARTY))))
list.push_back(channel);
if(player->getGuildId() && player->getGuildName().length() && ((channel = getChannel(
player, CHANNEL_GUILD)) || (channel = createChannel(player, CHANNEL_GUILD))))
list.push_back(channel);
for(NormalChannelMap::iterator it = m_normalChannels.begin(); it != m_normalChannels.end(); ++it)
{
if((channel = getChannel(player, it->first)))
list.push_back(it->second);
}
bool hasPrivate = false;
PrivateChatChannel* privChannel = NULL;
for(PrivateChannelMap::iterator pit = m_privateChannels.begin(); pit != m_privateChannels.end(); ++pit)
{
if(!(privChannel = pit->second))
continue;
if(privChannel->isInvited(player))
list.push_back(privChannel);
if(privChannel->getOwner() == player->getGUID())
hasPrivate = true;
}
if(!hasPrivate && player->isPremium())
list.push_front(dummyPrivate);
return list;
}
void Chat::removeUserFromAllChannels(Player* player)
{
for (NormalChannelMap::iterator it = m_normalChannels.begin(), end = m_normalChannels.end(); it != end; ++it) {
it->second->removeUser(player);
}
for (PartyChannelMap::iterator it = m_partyChannels.begin(), end = m_partyChannels.end(); it != end; ++it) {
it->second->removeUser(player);
}
for (GuildChannelMap::iterator it = m_guildChannels.begin(), end = m_guildChannels.end(); it != end; ++it) {
it->second->removeUser(player);
}
for (PrivateChannelMap::iterator it = m_privateChannels.begin(), end = m_privateChannels.end(); it != end; ++it) {
PrivateChatChannel* channel = it->second;
channel->removeUser(player);
if (channel->getOwner() == player->getGUID()) {
deleteChannel(player, channel->getId());
}
}
}
ChatChannel* Chat::createChannel(Player* player, uint16_t channelId)
{
if(getChannel(player, channelId))
return NULL;
if(channelId == 0x00){
ChatChannel *newChannel = new ChatChannel(channelId, player->getGuildName());
if(!newChannel)
return NULL;
m_guildChannels[player->getGuildId()] = newChannel;
return newChannel;
}
else if(channelId == 0xFFFF){
//only 1 private channel for each player
if(getPrivateChannel(player)){
return NULL;
}
//find a free private channel slot
for(uint16_t i = 100; i < 10000; ++i){
if(m_privateChannels.find(i) == m_privateChannels.end()){
PrivateChatChannel* newChannel = new PrivateChatChannel(i, player->getName() + "'s Channel");
if(!newChannel)
return NULL;
newChannel->setOwner(player->getGUID());
m_privateChannels[i] = newChannel;
return newChannel;
}
}
}
return NULL;
}
void Spectators::handle(ProtocolGame* client, const std::string& text, uint16_t channelId)
{
if(!owner)
return;
SpectatorList::iterator sit = spectators.find(client);
if(sit == spectators.end())
return;
PrivateChatChannel* channel = g_chat.getPrivateChannel(owner->getPlayer());
if(text[0] == '/')
{
StringVec t = explodeString(text.substr(1, text.length()), " ", true, 1);
toLowerCaseString(t[0]);
if(t[0] == "show")
{
std::stringstream s;
s << spectators.size() << " spectators. ";
for(SpectatorList::const_iterator it = spectators.begin(); it != spectators.end(); ++it)
{
if(it != spectators.begin())
s << " ,";
s << it->second.first;
}
s << ".";
client->sendCreatureSay(owner->getPlayer(), MSG_PRIVATE, s.str(), NULL, 0);
}
else if(t[0] == "name")
{
if(t.size() > 1)
{
if(t[1].length() > 2)
{
if(t[1].length() < 26)
{
t[1] += " [G]";
bool found = false;
for(SpectatorList::iterator iit = spectators.begin(); iit != spectators.end(); ++iit)
{
if(asLowerCaseString(iit->second.first) != asLowerCaseString(t[1]))
continue;
found = true;
break;
}
if(!found)
{
client->sendCreatureSay(owner->getPlayer(), MSG_PRIVATE, "Your name has been set to " + t[1] + ".", NULL, 0);
if(!auth && channel)
sendChannelMessage("", sit->second.first + " is now known as " + t[1] + ".", MSG_GAMEMASTER_CHANNEL, channel->getId());
StringVec::iterator mit = std::find(mutes.begin(), mutes.end(), asLowerCaseString(sit->second.first));
if(mit != mutes.end())
(*mit) = asLowerCaseString(t[1]);
sit->second.first = t[1];
sit->second.second = false;
}
else
client->sendCreatureSay(owner->getPlayer(), MSG_PRIVATE, "Specified name is already taken.", NULL, 0);
}
else
client->sendCreatureSay(owner->getPlayer(), MSG_PRIVATE, "Specified name is too long.", NULL, 0);
}
else
client->sendCreatureSay(owner->getPlayer(), MSG_PRIVATE, "Specified name is too short.", NULL, 0);
}
else
client->sendCreatureSay(owner->getPlayer(), MSG_PRIVATE, "Not enough param(s) given.", NULL, 0);
}
else if(t[0] == "auth")
{
if(t.size() > 1)
{
StringVec _t = explodeString(t[1], " ", true, 1);
if(_t.size() > 1)
{
Database* db = Database::getInstance();
DBQuery query;
query << "SELECT `id`, `salt`, `password` FROM `accounts` WHERE `name` " << db->getStringComparer() << db->escapeString(_t[0]) << " LIMIT 1";
if(DBResult* result = db->storeQuery(query.str()))
{
std::string password = result->getDataString("salt") + _t[1],
hash = result->getDataString("password");
uint32_t id = result->getDataInt("id");
result->free();
if(encryptTest(password, hash))
{
query.str("");
query << "SELECT `name` FROM `players` WHERE `account_id` = " << id << " ORDER BY `level` DESC LIMIT 1";
if((result = db->storeQuery(query.str())))
{
std::string nickname = result->getDataString("name");
result->free();
client->sendCreatureSay(owner->getPlayer(), MSG_PRIVATE, "You have authenticated as " + nickname + ".", NULL, 0);
if(channel)
sendChannelMessage("", sit->second.first + " authenticated as " + nickname + ".", MSG_GAMEMASTER_CHANNEL, channel->getId());
StringVec::iterator mit = std::find(mutes.begin(), mutes.end(), asLowerCaseString(sit->second.first));
if(mit != mutes.end())
(*mit) = asLowerCaseString(nickname);
sit->second.first = nickname;
sit->second.second = true;
}
else
client->sendCreatureSay(owner->getPlayer(), MSG_PRIVATE, "Your account has no characters yet.", NULL, 0);
}
else
client->sendCreatureSay(owner->getPlayer(), MSG_PRIVATE, "Invalid password.", NULL, 0);
}
else
client->sendCreatureSay(owner->getPlayer(), MSG_PRIVATE, "Invalid account name.", NULL, 0);
}
else
client->sendCreatureSay(owner->getPlayer(), MSG_PRIVATE, "Not enough param(s) given.", NULL, 0);
}
else
client->sendCreatureSay(owner->getPlayer(), MSG_PRIVATE, "Not enough param(s) given.", NULL, 0);
}
else
client->sendCreatureSay(owner->getPlayer(), MSG_PRIVATE, "Command not found.", NULL, 0);
return;
}
if(!auth || sit->second.second)
{
StringVec::const_iterator mit = std::find(mutes.begin(), mutes.end(), asLowerCaseString(sit->second.first));
if(mit == mutes.end())
{
if(channel && channel->getId() == channelId)
channel->talk(sit->second.first, MSG_CHANNEL_HIGHLIGHT, text);
}
else
client->sendCreatureSay(owner->getPlayer(), MSG_PRIVATE, "You are muted.", NULL, 0);
}
else
client->sendCreatureSay(owner->getPlayer(), MSG_PRIVATE, "This chat is protected, you have to authenticate first.", NULL, 0);
}
bool Party::leaveParty(Player* player)
{
if(!player){
return false;
}
if(!isPlayerMember(player) && getLeader() != player){
return false;
}
// Remove from chat
PrivateChatChannel* pcc = static_cast<PrivateChatChannel*>(g_chat.getChannel(this));
if(pcc){
pcc->removeUser(player, true);
}
bool hasNoLeader = false;
if(getLeader() == player){
if(!memberList.empty()){
if(memberList.size() == 1 && inviteList.empty()){
//just one member left, disband instead of passing leadership
hasNoLeader = true;
}
else{
passPartyLeadership(memberList.front());
}
}
else{
hasNoLeader = true;
}
}
//since we already passed the leadership, we remove the player from the list
PlayerVector::iterator it = std::find(memberList.begin(), memberList.end(), player);
if(it != memberList.end()){
memberList.erase(it);
}
it = std::find(inviteList.begin(), inviteList.end(), player);
if(it != inviteList.end()){
inviteList.erase(it);
}
player->setParty(NULL);
player->sendTextMessage(MSG_INFO_DESCR, "You have left the party.");
player->sendPlayerPartyIcons(player);
updateSharedExperience();
updatePartyIcons(player);
clearPlayerPoints(player);
std::stringstream ss;
ss << player->getName() << " has left the party.";
broadcastPartyMessage(MSG_INFO_DESCR, ss.str());
if(hasNoLeader || disbandParty()){
disband();
}
return true;
}
