void SendReloadMessage(int id, int status){
byte buffer[] = {16,id,status};
SendToAll(buffer, 3, 1);
}
void Channel::Join(ObjectGuid p, const char *pass)
{
WorldPacket data;
if (IsOn(p))
{
if (!IsConstant()) // non send error message for built-in channels
{
MakePlayerAlreadyMember(&data, p);
SendToOne(&data, p);
}
return;
}
if (IsBanned(p))
{
MakeBanned(&data);
SendToOne(&data, p);
return;
}
if (m_password.length() > 0 && strcmp(pass, m_password.c_str()))
{
MakeWrongPassword(&data);
SendToOne(&data, p);
return;
}
PlayerPointer plr = GetPlayer(p);
if (m_securityLevel && (!plr.get() || plr->GetSession()->GetSecurity() < m_securityLevel))
{
MakeWrongPassword(&data);
SendToOne(&data, p);
return;
}
if (plr && plr->ToPlayer())
{
if (plr->GetGuildId() && (GetFlags() == 0x38))
return;
plr->ToPlayer()->JoinedChannel(this);
}
if (m_announce && (!plr.get() || plr->GetSession()->GetSecurity() < SEC_GAMEMASTER || !sWorld.getConfig(CONFIG_BOOL_SILENTLY_GM_JOIN_TO_CHANNEL)))
{
MakeJoined(&data, p);
SendToAll(&data);
}
data.clear();
PlayerInfo& pinfo = m_players[p];
pinfo.player = p;
pinfo.flags = 0;
MakeYouJoined(&data);
SendToOne(&data, p);
JoinNotify(p);
// if no owner first logged will become
if (HasFlag(CHANNEL_FLAG_CUSTOM) && !IsConstant() && !m_ownerGuid)
{
SetOwner(p, (m_players.size() > 1 ? true : false));
m_players[p].SetModerator(true);
}
}
void Channel::Join(uint64 p, const char *pass)
{
WorldPacket data;
if (IsOn(p))
{
if (!IsConstant()) // non send error message for built-in channels
{
MakePlayerAlreadyMember(&data, p);
SendToOne(&data, p);
}
return;
}
if (IsBanned(p))
{
MakeBanned(&data);
SendToOne(&data, p);
return;
}
if (m_password.length() > 0 && strcmp(pass, m_password.c_str()))
{
MakeWrongPassword(&data);
SendToOne(&data, p);
return;
}
Player *plr = sObjectMgr->GetPlayer(p);
if (plr)
{
if (HasFlag(CHANNEL_FLAG_LFG) &&
sWorld->getBoolConfig(CONFIG_RESTRICTED_LFG_CHANNEL) && plr->GetSession()->GetSecurity() == SEC_PLAYER && plr->GetGroup())
{
MakeNotInLfg(&data);
SendToOne(&data, p);
return;
}
plr->JoinedChannel(this);
}
if (m_announce && (!plr || plr->GetSession()->GetSecurity() < SEC_GAMEMASTER || !sWorld->getBoolConfig(CONFIG_SILENTLY_GM_JOIN_TO_CHANNEL)))
{
MakeJoined(&data, p);
SendToAll(&data);
}
data.clear();
PlayerInfo pinfo;
pinfo.player = p;
pinfo.flags = MEMBER_FLAG_NONE;
players[p] = pinfo;
MakeYouJoined(&data);
SendToOne(&data, p);
JoinNotify(p);
// Custom channel handling
if (!IsConstant())
{
// Update last_used timestamp in db
if (!players.empty())
UpdateChannelUseageInDB();
// If the channel has no owner yet and ownership is allowed, set the new owner.
if ( !m_ownerGUID && m_ownership)
{
SetOwner(p, (players.size() > 1 ? true : false));
players[p].SetModerator(true);
}
}
}
void Channel::LeaveChannel(Player* player, bool send)
{
uint64 guid = player->GetGUID();
if (!IsOn(guid))
{
if (send)
{
WorldPacket data;
MakeNotMember(&data);
SendToOne(&data, guid);
}
return;
}
if (send)
{
WorldPacket data;
MakeYouLeft(&data);
SendToOne(&data, guid);
player->LeftChannel(this);
data.clear();
}
bool changeowner = playersStore[guid].IsOwner();
playersStore.erase(guid);
if (_announce && (!AccountMgr::IsGMAccount(player->GetSession()->GetSecurity()) ||
!sWorld->getBoolConfig(CONFIG_SILENTLY_GM_JOIN_TO_CHANNEL)))
{
WorldPacket data;
MakeLeft(&data, guid);
SendToAll(&data);
}
RemoveWatching(player);
LeaveNotify(player);
if (!IsConstant())
{
// Update last_used timestamp in db
UpdateChannelUseageInDB();
// If the channel owner left and there are still playersStore inside, pick a new owner
if (changeowner && _ownership)
{
if (!playersStore.empty())
{
uint64 newowner = 0;
for (Channel::PlayerContainer::const_iterator itr = playersStore.begin(); itr != playersStore.end(); ++itr)
{
newowner = itr->second.player;
if (!itr->second.plrPtr->GetSession()->GetSecurity())
break;
}
SetOwner(newowner);
}
else
SetOwner(0);
}
}
}
void Channel::JoinChannel(Player* player, std::string const& pass)
{
ObjectGuid guid = player->GetGUID();
if (IsOn(guid))
{
// Do not send error message for built-in channels
if (!IsConstant())
{
WorldPacket data;
MakePlayerAlreadyMember(&data, guid);
SendToOne(&data, guid);
}
return;
}
if (IsBanned(guid))
{
WorldPacket data;
MakeBanned(&data);
SendToOne(&data, guid);
return;
}
if (!_password.empty() && pass != _password)
{
WorldPacket data;
MakeWrongPassword(&data);
SendToOne(&data, guid);
return;
}
if (HasFlag(CHANNEL_FLAG_LFG) &&
sWorld->getBoolConfig(CONFIG_RESTRICTED_LFG_CHANNEL) &&
AccountMgr::IsPlayerAccount(player->GetSession()->GetSecurity()) && //FIXME: Move to RBAC
player->GetGroup())
{
WorldPacket data;
MakeNotInLfg(&data);
SendToOne(&data, guid);
return;
}
player->JoinedChannel(this);
if (_announce && !player->GetSession()->HasPermission(rbac::RBAC_PERM_SILENTLY_JOIN_CHANNEL))
{
WorldPacket data;
MakeJoined(&data, guid);
SendToAll(&data);
}
PlayerInfo pinfo;
pinfo.player = guid;
pinfo.flags = MEMBER_FLAG_NONE;
playersStore[guid] = pinfo;
WorldPacket data;
MakeYouJoined(&data);
SendToOne(&data, guid);
JoinNotify(guid);
// Custom channel handling
if (!IsConstant())
{
// Update last_used timestamp in db
if (!playersStore.empty())
UpdateChannelUseageInDB();
// If the channel has no owner yet and ownership is allowed, set the new owner.
if (!_ownerGUID && _ownership)
{
SetOwner(guid, playersStore.size() > 1);
playersStore[guid].SetModerator(true);
}
}
}
/**
* verarbeitet die Chat-Nachricht eines Clients.
*
* @author FloSoft
*/
void LobbyServer::OnNMSLobbyChat(unsigned int id, const std::string& to, const std::string& text)
{
if(text.empty())
return;
LobbyPlayer& player = players[id];
if(player.getName() == "LobbyBot")
{
if(text == "!kick" || !text.compare(0, 6, "!kick "))
{
LobbyPlayer* p = GetPlayer(to);
if(p)
{
if(text.length() > 6)
p->Send(new LobbyMessage_Chat(player.getName(), text.substr(6)));
Disconnect(*p);
}
}
else if(text == "!ban")
{
MYSQLCLIENT.SetBan(to, true);
player.Send(new LobbyMessage_Chat(player.getName(), std::string("!ban") + to));
}
else if(text == "!unban")
{
MYSQLCLIENT.SetBan(to, false);
player.Send(new LobbyMessage_Chat(player.getName(), std::string("!unban") + to));
}
else if(text == "!getinfo")
{
LobbyPlayer* p = GetPlayer(to);
if(p)
{
std::stringstream out;
out << "!getinfo " << p->getPeerIP() << " " << p->getEmail() << " " << p->getName();
player.Send(new LobbyMessage_Chat(player.getName(), out.str()));
}
}
// Hide all commands
if (text[0] == '!')
return;
}
// send to lobbybot only, throw away otherwise
if (text[0] == '!')
{
LobbyPlayer* p = GetPlayer("LobbyBot");
if(p)
p->Send(new LobbyMessage_Chat(player.getName(), text));
return;
}
if(!to.empty())
{
LobbyPlayer* p = GetPlayer(to);
if(p)
p->Send(new LobbyMessage_Chat(player.getName(), text));
} else
{
// no player selected
SendToAll(LobbyMessage_Chat(player.getName(), text));
}
}
void Channel::Say(uint64 p, const char *what, uint32 lang)
{
if (!what)
return;
if (sWorld.getConfig(CONFIG_ALLOW_TWO_SIDE_INTERACTION_CHANNEL))
lang = LANG_UNIVERSAL;
uint32 sec = 0;
Player *plr = sObjectMgr.GetPlayer(p);
if (plr)
sec = plr->GetSession()->GetPermissions();
if (!IsOn(p))
{
WorldPacket data;
MakeNotMember(&data);
SendToOne(&data, p);
}
else if (players[p].IsMuted())
{
WorldPacket data;
MakeMuted(&data);
SendToOne(&data, p);
}
else if (m_moderate && !players[p].IsModerator() && !(sec & PERM_GMT))
{
WorldPacket data;
MakeNotModerator(&data);
SendToOne(&data, p);
}
else
{
uint32 messageLength = strlen(what) + 1;
WorldPacket data(SMSG_MESSAGECHAT, 1+4+8+4+m_name.size()+1+8+4+messageLength+1);
data << (uint8)CHAT_MSG_CHANNEL;
data << (uint32)lang;
data << p; // 2.1.0
data << uint32(0); // 2.1.0
data << m_name;
data << p;
data << messageLength;
data << what;
data << uint8(plr ? plr->chatTag() : 0);
if (!plr || !plr->IsTrollmuted())
{
// exclude LFG from two-side channels
if (sWorld.getConfig(CONFIG_ALLOW_TWO_SIDE_INTERACTION_CHANNEL) && IsLFG() && plr)
{
uint32 fromteam = plr->GetTeam();
for (PlayerList::iterator i = players.begin(); i != players.end(); ++i)
{
Player *to = sObjectMgr.GetPlayer(i->first);
if (!to || to->GetTeam() != fromteam)
continue;
if (!p || !to->GetSocial()->HasIgnore(GUID_LOPART(p)))
to->SendPacketToSelf(&data);
}
}
else
SendToAll(&data, !players[p].IsModerator() ? p : false);
}
else
plr->SendPacketToSelf(&data);
}
}
void Channel::SetOwner(RPlayerInfo* oldpl, RPlayerInfo* plr)
{
Guard mGuard(m_lock);
RPlayerInfo* pOwner = NULL;
uint32 oldflags, oldflags2;
WorldPacket data(SMSG_CHANNEL_NOTIFY, 100);
if(oldpl != NULL)
{
MemberMap::iterator itr = m_members.find(oldpl);
if(m_members.end() == itr)
{
data << uint8(CHANNEL_NOTIFY_FLAG_NOTON) << m_name;
plr->GetSession()->SendPacket(&data);
return;
}
if(!(itr->second & CHANNEL_FLAG_OWNER))
{
data << uint8(CHANNEL_NOTIFY_FLAG_NOT_OWNER) << m_name;
plr->GetSession()->SendPacket(&data);
return;
}
}
if(plr == NULL)
{
for(MemberMap::iterator itr = m_members.begin(); itr != m_members.end(); itr++)
{
if(itr->second & CHANNEL_FLAG_OWNER)
{
// remove the old owner
oldflags2 = itr->second;
itr->second &= ~CHANNEL_FLAG_OWNER;
data << uint8(CHANNEL_NOTIFY_FLAG_MODE_CHG) << m_name << uint64(itr->first->Guid) << uint8(oldflags2) << uint8(itr->second);
SendToAll(&data);
}
else
{
if(pOwner == NULL)
{
pOwner = itr->first;
oldflags = itr->second;
itr->second |= CHANNEL_FLAG_OWNER;
}
}
}
}
else
{
for(MemberMap::iterator itr = m_members.begin(); itr != m_members.end(); itr++)
{
if(itr->second & CHANNEL_FLAG_OWNER)
{
// remove the old owner
oldflags2 = itr->second;
itr->second &= ~CHANNEL_FLAG_OWNER;
data << uint8(CHANNEL_NOTIFY_FLAG_MODE_CHG) << m_name << uint64(itr->first->Guid) << uint8(oldflags2) << uint8(itr->second);
SendToAll(&data);
}
else
{
if(plr == itr->first)
{
pOwner = itr->first;
oldflags = itr->second;
itr->second |= CHANNEL_FLAG_OWNER;
}
}
}
}
if(pOwner == NULL)
return; // obviously no members
data.clear();
data << uint8(CHANNEL_NOTIFY_FLAG_CHGOWNER) << m_name << uint64(pOwner->Guid);
SendToAll(&data);
// send the mode changes
data.clear();
data << uint8(CHANNEL_NOTIFY_FLAG_MODE_CHG) << m_name << uint64(pOwner->Guid) << uint8(oldflags) << uint8(oldflags | CHANNEL_FLAG_OWNER);
SendToAll(&data);
}
//void newProcessForClient(int conn_fd, struct sockaddr_in serv_addr, struct OnlineUser * userlist)
void newPthreadForClient(int * conn_fd)
{
char buf[500];
char recvfrom[10];
char message[500];
char sendto[10];
int i, j;
int stat;
int CONN_FD;
struct UserInfo user;
struct Package package;
int send_to_fd;
char oder[20];
CONN_FD = *conn_fd;
printf("##server : now is newProcessForClient \n##Waiting for Log in\n");
printf("##server : conn_fd : %d\n", CONN_FD);
if(recv(CONN_FD, &user,sizeof(user), 0) == 0)
{
pthread_exit(0);
}
printf("##server : received %d\n", user.flag);
printf("##server : received %s\n", user.name);
printf("##server : received %s\n", user.passwd);
if(user.flag == 1)
{
//登陆 signIn
stat = SignIn(CONN_FD,user);
printf("stat = %d\n", stat);
if(stat == 1)
{
AddUser(user.name,CONN_FD);
ShowUser();
send(CONN_FD, &stat, sizeof(stat), 0);
}
else
{
send(CONN_FD, &stat, sizeof(stat), 0);
pthread_exit(0);
}
}
if(user.flag == 2)
{
//注册signUp
SignUp(CONN_FD, user);
pthread_exit(0);
}
// strcpy(recvfrom , user.name);
OnLineHint(user.name);
while(1)
{ //解析信息
printf("##server : waitting for massage form %s\n", user.name);
memset(buf, 0, sizeof(buf));
if(recv(CONN_FD, &package, sizeof(package), 0) == 0)
{
printf("%s off line\n", user.name);
OffLine(user.name);
pthread_exit(0);
} //下线
if(package.order == 1 && strcmp(package.sendto, "all") == 0)
{
SendToAll(package);
printf("now is send all\n");
continue;
}
send_to_fd = find_fd(package.sendto);
if(package.order == 1)
{
if(send_to_fd == -1)
{
continue;
}
if(send(send_to_fd, &package, sizeof(package), 0) == 0)
{
printf("send error\n");
continue;
}
}
if(package.order == 2)
{
if(strcmp(package.message, "show") == 0)
{
ShowOnlineUser(CONN_FD);
}
}
}
}
void SendWeaponChangeMessage(int id, int wpnid){
byte buffer[] = {9, id, wpnid, 0};
SendToAll(buffer, 4, 1);
}
void Channel::Part(RPlayerInfo* plr, bool silent)
{
if(plr == NULL || plr->GetSession() == NULL)
return;
m_lock.Acquire();
WorldPacket data(SMSG_CHANNEL_NOTIFY, 100);
uint32 flags;
MemberMap::iterator itr = m_members.find(plr);
if(itr == m_members.end())
{
data << uint8(CHANNEL_NOTIFY_FLAG_NOTON) << m_name;
plr->GetSession()->SendPacket(&data);
m_lock.Release();
return;
}
flags = itr->second;
m_members.erase(itr);
WorldPacket data2(ISMSG_CHANNEL_ACTION, 9);
data2 << uint8(CHANNEL_PART); // left channel
data2 << uint32(plr->Guid);
data2 << uint32(m_channelId);
plr->GetSession()->GetServer()->SendPacket(&data2);
if(flags & CHANNEL_FLAG_OWNER)
{
// we need to find a new owner
SetOwner(NULL, NULL);
}
if(plr->GetSession())
{
if( !silent )
{
data << uint8(CHANNEL_NOTIFY_FLAG_YOULEFT) << m_name << m_typeId << uint32(0) << uint8(0);
plr->GetSession()->SendPacket(&data);
}
}
if(m_announce)
{
data.clear();
data << uint8(CHANNEL_NOTIFY_FLAG_LEFT) << m_name << uint64(plr->Guid);
SendToAll(&data);
}
#ifndef WIN32
if(m_members.size() == 0 )
{
m_lock.Release();
channelmgr.RemoveChannel(this);
}
else
m_lock.Release();
#else
m_lock.Release();
#endif
}
void SendHitMessage(int id, int victim, int health, int armor){
byte buffer[] = {17,id,victim,health,armor};
SendToAll(buffer, 5, 1);
}
void SendFireMessage(int id){
byte buffer[] = {7,id};
SendToAll(buffer, 2, 1);
}
void SendAdvancedFireMessage(int id, int status){
byte buffer[] = {8,id,status};
SendToAll(buffer, 3, 1);
}
void Channel::Part(Player * plr, bool silent)
{
m_lock.Acquire();
WorldPacket data(SMSG_CHANNEL_NOTIFY, 100);
uint32 flags;
MemberMap::iterator itr = m_members.find(plr);
if(itr == m_members.end())
{
data << uint8(CHANNEL_NOTIFY_FLAG_NOTON) << m_name;
plr->GetSession()->SendPacket(&data);
m_lock.Release();
return;
}
flags = itr->second;
m_members.erase(itr);
plr->LeftChannel(this);
if(flags & CHANNEL_FLAG_OWNER)
{
// we need to find a new owner
SetOwner(NULL, NULL);
}
if(plr->GetSession() && plr->GetSession()->IsLoggingOut())
{
}
else
{
if( !silent )
{
data << uint8(CHANNEL_NOTIFY_FLAG_YOULEFT) << m_name << m_typeId << uint32(0) << uint8(0);
plr->GetSession()->SendPacket(&data);
}
}
if(m_announce)
{
data.clear();
data << uint8(CHANNEL_NOTIFY_FLAG_LEFT) << m_name << plr->GetGUID();
SendToAll(&data);
/* data.Initialize(SMSG_PLAYER_LEFT_CHANNEL);
data << plr->GetGUID() << m_flags << m_id << m_name;
SendToAll(&data);*/
}
#ifndef WIN32
if(m_members.size() == 0 )
{
m_lock.Release();
channelmgr.RemoveChannel(this);
}
else
m_lock.Release();
#else
m_lock.Release();
#endif
}
void Channel::JoinChannel(Player* player, std::string const& pass)
{
ObjectGuid const& guid = player->GetGUID();
if (IsOn(guid))
{
// Do not send error message for built-in channels
if (!IsConstant())
{
PlayerAlreadyMemberAppend appender(guid);
ChannelNameBuilder<PlayerAlreadyMemberAppend> builder(this, appender);
SendToOne(builder, guid);
}
return;
}
if (IsBanned(guid))
{
BannedAppend appender;
ChannelNameBuilder<BannedAppend> builder(this, appender);
SendToOne(builder, guid);
return;
}
if (!_channelPassword.empty() && pass != _channelPassword)
{
WrongPasswordAppend appender;
ChannelNameBuilder<WrongPasswordAppend> builder(this, appender);
SendToOne(builder, guid);
return;
}
if (HasFlag(CHANNEL_FLAG_LFG) &&
sWorld->getBoolConfig(CONFIG_RESTRICTED_LFG_CHANNEL) &&
AccountMgr::IsPlayerAccount(player->GetSession()->GetSecurity()) && //FIXME: Move to RBAC
player->GetGroup())
{
NotInLFGAppend appender;
ChannelNameBuilder<NotInLFGAppend> builder(this, appender);
SendToOne(builder, guid);
return;
}
player->JoinedChannel(this);
if (_announceEnabled && !player->GetSession()->HasPermission(rbac::RBAC_PERM_SILENTLY_JOIN_CHANNEL))
{
JoinedAppend appender(guid);
ChannelNameBuilder<JoinedAppend> builder(this, appender);
SendToAll(builder);
}
bool newChannel = _playersStore.empty();
PlayerInfo& playerInfo = _playersStore[guid];
playerInfo.SetInvisible(!player->isGMVisible());
/*
YouJoinedAppend appender;
ChannelNameBuilder<YouJoinedAppend> builder(this, appender);
SendToOne(builder, guid);
*/
auto builder = [&](LocaleConstant /*locale*/)
{
WorldPackets::Channel::ChannelNotifyJoined* notify = new WorldPackets::Channel::ChannelNotifyJoined();
//notify->ChannelWelcomeMsg = "";
notify->ChatChannelID = _channelId;
//notify->InstanceID = 0;
notify->_ChannelFlags = _channelFlags;
notify->_Channel = _channelName;
return notify;
};
SendToOne(builder, guid);
JoinNotify(player);
// Custom channel handling
if (!IsConstant())
{
// Update last_used timestamp in db
if (!_playersStore.empty())
UpdateChannelUseageInDB();
// If the channel has no owner yet and ownership is allowed, set the new owner.
// or if the owner was a GM with .gm visible off
// don't do this if the new player is, too, an invis GM, unless the channel was empty
if (_ownershipEnabled && (newChannel || !playerInfo.IsInvisible()) && (_ownerGuid.IsEmpty() || _isOwnerInvisible))
{
_isOwnerInvisible = playerInfo.IsInvisible();
SetOwner(guid, !newChannel && !_isOwnerInvisible);
playerInfo.SetModerator(true);
}
}
}
void Channel::SetOwner(Player* oldpl, Player* plr)
{
Guard mGuard(m_lock);
Player* pOwner = NULLPLR;
uint32 oldflags = 0;
uint32 oldflags2 = 0;
WorldPacket data;
if(oldpl != NULL)
{
MemberMap::iterator itr = m_members.find(oldpl);
if(m_members.end() == itr)
{
MakeNotifyPacket(&data, CHANNEL_NOTIFY_FLAG_NOTON);
plr->GetSession()->SendPacket(&data);
return;
}
if(!(itr->second & CHANNEL_FLAG_OWNER))
{
MakeNotifyPacket(&data, CHANNEL_NOTIFY_FLAG_NOT_OWNER);
plr->GetSession()->SendPacket(&data);
return;
}
}
if(plr == NULL)
{
for(MemberMap::iterator itr = m_members.begin(); itr != m_members.end(); itr++)
{
if(itr->second & CHANNEL_FLAG_OWNER)
{
// remove the old owner
oldflags2 = itr->second;
itr->second &= ~CHANNEL_FLAG_OWNER;
MakeNotifyPacket(&data, CHANNEL_NOTIFY_FLAG_MODE_CHG);
data << itr->first->GetGUID() << uint8(oldflags2) << uint8(itr->second);
SendToAll(&data);
}
else
{
if(pOwner == NULL)
{
pOwner = itr->first;
oldflags = itr->second;
itr->second |= CHANNEL_FLAG_OWNER;
}
}
}
}
else
{
for(MemberMap::iterator itr = m_members.begin(); itr != m_members.end(); itr++)
{
if(itr->second & CHANNEL_FLAG_OWNER)
{
// remove the old owner
oldflags2 = itr->second;
itr->second &= ~CHANNEL_FLAG_OWNER;
MakeNotifyPacket(&data, CHANNEL_NOTIFY_FLAG_MODE_CHG);
data << itr->first->GetGUID() << uint8(oldflags2) << uint8(itr->second);
SendToAll(&data);
}
else
{
if(plr == itr->first)
{
pOwner = itr->first;
oldflags = itr->second;
itr->second |= CHANNEL_FLAG_OWNER;
}
}
}
}
if(pOwner == NULL)
return; // obviously no members
MakeNotifyPacket(&data, CHANNEL_NOTIFY_FLAG_CHGOWNER);
data << pOwner->GetGUID();
SendToAll(&data);
// send the mode changes
MakeNotifyPacket(&data, CHANNEL_NOTIFY_FLAG_MODE_CHG);
data << pOwner->GetGUID() << uint8(oldflags) << uint8(oldflags | CHANNEL_FLAG_OWNER);
SendToAll(&data);
}
void Channel::LeaveChannel(Player* player, bool send)
{
ObjectGuid const& guid = player->GetGUID();
if (!IsOn(guid))
{
if (send)
{
NotMemberAppend appender;
ChannelNameBuilder<NotMemberAppend> builder(this, appender);
SendToOne(builder, guid);
}
return;
}
player->LeftChannel(this);
if (send)
{
/*
YouLeftAppend appender;
ChannelNameBuilder<YouLeftAppend> builder(this, appender);
SendToOne(builder, guid);
*/
auto builder = [&](LocaleConstant locale)
{
LocaleConstant localeIdx = sWorld->GetAvailableDbcLocale(locale);
WorldPackets::Channel::ChannelNotifyLeft* notify = new WorldPackets::Channel::ChannelNotifyLeft();
notify->Channel = GetName(localeIdx);
notify->ChatChannelID = 0;
//notify->Suspended = false;
return notify;
};
SendToOne(builder, guid);
}
PlayerInfo& info = _playersStore.at(guid);
bool changeowner = info.IsOwner();
_playersStore.erase(guid);
if (_announceEnabled && !player->GetSession()->HasPermission(rbac::RBAC_PERM_SILENTLY_JOIN_CHANNEL))
{
LeftAppend appender(guid);
ChannelNameBuilder<LeftAppend> builder(this, appender);
SendToAll(builder);
}
LeaveNotify(player);
if (!IsConstant())
{
// Update last_used timestamp in db
UpdateChannelUseageInDB();
// If the channel owner left and there are still playersStore inside, pick a new owner
// do not pick invisible gm owner unless there are only invisible gms in that channel (rare)
if (changeowner && _ownershipEnabled && !_playersStore.empty())
{
PlayerContainer::iterator itr;
for (itr = _playersStore.begin(); itr != _playersStore.end(); ++itr)
{
if (!itr->second.IsInvisible())
break;
}
if (itr == _playersStore.end())
itr = _playersStore.begin();
ObjectGuid const& newowner = itr->first;
itr->second.SetModerator(true);
SetOwner(newowner);
// if the new owner is invisible gm, set flag to automatically choose a new owner
if (itr->second.IsInvisible())
_isOwnerInvisible = true;
}
}
}
void Channel::KickOrBan(uint64 good, const char *badname, bool ban)
{
AccountTypes sec = SEC_PLAYER;
Player *gplr = ObjectAccessor::FindPlayer(good);
if (gplr)
sec = gplr->GetSession()->GetSecurity();
if (!IsOn(good))
{
WorldPacket data;
MakeNotMember(&data);
SendToOne(&data, good);
}
else if (!players[good].IsModerator() && !AccountMgr::IsGMAccount(sec))
{
WorldPacket data;
MakeNotModerator(&data);
SendToOne(&data, good);
}
else
{
Player *bad = sObjectAccessor->FindPlayerByName(badname);
if (bad == NULL || !IsOn(bad->GetGUID()))
{
WorldPacket data;
MakePlayerNotFound(&data, badname);
SendToOne(&data, good);
}
else if (!AccountMgr::IsGMAccount(sec) && bad->GetGUID() == m_ownerGUID && good != m_ownerGUID)
{
WorldPacket data;
MakeNotOwner(&data);
SendToOne(&data, good);
}
else
{
bool changeowner = (m_ownerGUID == bad->GetGUID());
WorldPacket data;
bool notify = !(AccountMgr::IsGMAccount(sec) && sWorld->getBoolConfig(CONFIG_SILENTLY_GM_JOIN_TO_CHANNEL));
if (ban && !IsBanned(bad->GetGUID()))
{
banned.insert(bad->GetGUID());
UpdateChannelInDB();
if (notify)
MakePlayerBanned(&data, bad->GetGUID(), good);
}
else if (notify)
MakePlayerKicked(&data, bad->GetGUID(), good);
if (notify)
SendToAll(&data);
players.erase(bad->GetGUID());
bad->LeftChannel(this);
if (changeowner && m_ownership && !players.empty())
{
uint64 newowner = good;
players[newowner].SetModerator(true);
SetOwner(newowner);
}
}
}
}
void Channel::KickOrBan(Player const* player, std::string const& badname, bool ban)
{
ObjectGuid const& good = player->GetGUID();
if (!IsOn(good))
{
NotMemberAppend appender;
ChannelNameBuilder<NotMemberAppend> builder(this, appender);
SendToOne(builder, good);
return;
}
PlayerInfo& info = _playersStore.at(good);
if (!info.IsModerator() && !player->GetSession()->HasPermission(rbac::RBAC_PERM_CHANGE_CHANNEL_NOT_MODERATOR))
{
NotModeratorAppend appender;
ChannelNameBuilder<NotModeratorAppend> builder(this, appender);
SendToOne(builder, good);
return;
}
Player* bad = ObjectAccessor::FindConnectedPlayerByName(badname);
ObjectGuid const& victim = bad ? bad->GetGUID() : ObjectGuid::Empty;
if (!victim || !IsOn(victim))
{
PlayerNotFoundAppend appender(badname);
ChannelNameBuilder<PlayerNotFoundAppend> builder(this, appender);
SendToOne(builder, good);
return;
}
bool changeowner = _ownerGuid == victim;
if (!player->GetSession()->HasPermission(rbac::RBAC_PERM_CHANGE_CHANNEL_NOT_MODERATOR) && changeowner && good != _ownerGuid)
{
NotOwnerAppend appender;
ChannelNameBuilder<NotOwnerAppend> builder(this, appender);
SendToOne(builder, good);
return;
}
if (ban && !IsBanned(victim))
{
_bannedStore.insert(victim);
UpdateChannelInDB();
if (!player->GetSession()->HasPermission(rbac::RBAC_PERM_SILENTLY_JOIN_CHANNEL))
{
PlayerBannedAppend appender(good, victim);
ChannelNameBuilder<PlayerBannedAppend> builder(this, appender);
SendToAll(builder);
}
}
else if (!player->GetSession()->HasPermission(rbac::RBAC_PERM_SILENTLY_JOIN_CHANNEL))
{
PlayerKickedAppend appender(good, victim);
ChannelNameBuilder<PlayerKickedAppend> builder(this, appender);
SendToAll(builder);
}
_playersStore.erase(victim);
bad->LeftChannel(this);
if (changeowner && _ownershipEnabled && !_playersStore.empty())
{
info.SetModerator(true);
SetOwner(good);
}
}
void Channel::JoinChannel(Player* player, std::string const& pass)
{
uint64 guid = player->GetGUID();
if (IsOn(guid))
{
// Do not send error message for built-in channels
if (!IsConstant())
{
WorldPacket data;
MakePlayerAlreadyMember(&data, guid);
SendToOne(&data, guid);
}
return;
}
if (IsBanned(guid))
{
WorldPacket data;
MakeBanned(&data);
SendToOne(&data, guid);
return;
}
if (!_password.empty() && pass != _password)
{
WorldPacket data;
MakeWrongPassword(&data);
SendToOne(&data, guid);
return;
}
if (HasFlag(CHANNEL_FLAG_LFG) &&
sWorld->getBoolConfig(CONFIG_RESTRICTED_LFG_CHANNEL) &&
AccountMgr::IsPlayerAccount(player->GetSession()->GetSecurity()) &&
player->GetGroup())
{
WorldPacket data;
MakeNotInLfg(&data);
SendToOne(&data, guid);
return;
}
player->JoinedChannel(this);
if (_announce && (!AccountMgr::IsGMAccount(player->GetSession()->GetSecurity()) ||
!sWorld->getBoolConfig(CONFIG_SILENTLY_GM_JOIN_TO_CHANNEL)))
{
WorldPacket data;
MakeJoined(&data, guid);
SendToAll(&data);
}
PlayerInfo pinfo;
pinfo.player = guid;
pinfo.flags = MEMBER_FLAG_NONE;
pinfo.lastSpeakTime = 0;
pinfo.plrPtr = player;
playersStore[guid] = pinfo;
if (_channelRights.joinMessage.length())
ChatHandler(player->GetSession()).PSendSysMessage("%s", _channelRights.joinMessage.c_str());
WorldPacket data;
MakeYouJoined(&data);
SendToOne(&data, guid);
JoinNotify(player);
// Custom channel handling
if (!IsConstant())
{
// Update last_used timestamp in db
if (!playersStore.empty())
UpdateChannelUseageInDB();
if (_channelRights.moderators.find(player->GetSession()->GetAccountId()) != _channelRights.moderators.end())
{
playersStore[guid].SetModerator(true);
FlagsNotify(player);
}
// If the channel has no owner yet and ownership is allowed, set the new owner.
if (!_ownerGUID && _ownership)
SetOwner(guid, false);
if (_channelRights.flags & CHANNEL_RIGHT_CANT_SPEAK)
playersStore[guid].SetMuted(true);
}
}
void Channel::KickOrBan(Player const* player, std::string const& badname, bool ban)
{
AccountTypes sec = player->GetSession()->GetSecurity();
uint64 good = player->GetGUID();
if (!IsOn(good))
{
WorldPacket data;
MakeNotMember(&data);
SendToOne(&data, good);
return;
}
if (!playersStore[good].IsModerator() && !AccountMgr::IsGMAccount(sec))
{
WorldPacket data;
MakeNotModerator(&data);
SendToOne(&data, good);
return;
}
Player* bad = sObjectAccessor->FindPlayerByName(badname);
uint64 victim = bad ? bad->GetGUID() : 0;
if (!victim || !IsOn(victim))
{
WorldPacket data;
MakePlayerNotFound(&data, badname);
SendToOne(&data, good);
return;
}
bool changeowner = _ownerGUID == victim;
if (!AccountMgr::IsGMAccount(sec) && changeowner && good != _ownerGUID)
{
WorldPacket data;
MakeNotOwner(&data);
SendToOne(&data, good);
return;
}
if (ban && !IsBanned(victim))
{
bannedStore.insert(victim);
UpdateChannelInDB();
if (!AccountMgr::IsGMAccount(sec))
{
WorldPacket data;
MakePlayerBanned(&data, victim, good);
SendToAll(&data);
}
}
else if (!AccountMgr::IsGMAccount(sec))
{
WorldPacket data;
MakePlayerKicked(&data, victim, good);
SendToAll(&data);
}
playersStore.erase(victim);
bad->LeftChannel(this);
if (changeowner && _ownership && !playersStore.empty())
{
uint64 newowner = good;
playersStore[newowner].SetModerator(true);
SetOwner(newowner);
}
}
void Channel::KickOrBan(Player const* player, std::string const& badname, bool ban)
{
AccountTypes sec = player->GetSession()->GetSecurity();
uint64 good = player->GetGUID();
if (!IsOn(good))
{
WorldPacket data;
MakeNotMember(&data);
SendToOne(&data, good);
return;
}
if (!playersStore[good].IsModerator() && !AccountMgr::IsGMAccount(sec))
{
WorldPacket data;
MakeNotModerator(&data);
SendToOne(&data, good);
return;
}
bool banOffline = false; // pussywizard
bool isGoodConstantModerator = _channelRights.moderators.find(player->GetSession()->GetAccountId()) != _channelRights.moderators.end();
uint64 victim = 0;
uint32 badAccId = 0;
uint32 badSecurity = 0;
Player* bad = ObjectAccessor::FindPlayerByName(badname, false);
if (bad)
{
victim = bad->GetGUID();
badAccId = bad->GetSession()->GetAccountId();
badSecurity = bad->GetSession()->GetSecurity();
}
bool isOnChannel = victim && IsOn(victim);
if (!isOnChannel)
{
if (ban && (AccountMgr::IsGMAccount(sec) || isGoodConstantModerator))
{
if (uint32 lowGuid = sWorld->GetGlobalPlayerGUID(badname))
if (const GlobalPlayerData* gpd = sWorld->GetGlobalPlayerData(lowGuid))
{
if (Player::TeamIdForRace(gpd->race) == Player::TeamIdForRace(player->getRace()))
{
banOffline = true;
victim = MAKE_NEW_GUID(lowGuid, 0, HIGHGUID_PLAYER);
badAccId = gpd->accountId;
}
else
{
ChatHandler(player->GetSession()).PSendSysMessage("Character %s has other faction!", badname.c_str());
return;
}
}
if (!banOffline)
{
WorldPacket data;
MakePlayerNotFound(&data, badname);
SendToOne(&data, good);
return;
}
}
else
{
WorldPacket data;
MakePlayerNotFound(&data, badname);
SendToOne(&data, good);
return;
}
}
bool changeowner = _ownerGUID == victim;
bool isBadConstantModerator = _channelRights.moderators.find(badAccId) != _channelRights.moderators.end();
if (!AccountMgr::IsGMAccount(sec) && !isGoodConstantModerator)
{
if (changeowner && good != _ownerGUID)
{
WorldPacket data;
MakeNotOwner(&data);
SendToOne(&data, good);
return;
}
if (ban && (_channelRights.flags & CHANNEL_RIGHT_CANT_BAN) || !ban && (_channelRights.flags & CHANNEL_RIGHT_CANT_KICK))
{
WorldPacket data;
MakeNotModerator(&data);
SendToOne(&data, good);
return;
}
if (isBadConstantModerator || AccountMgr::IsGMAccount(badSecurity))
{
WorldPacket data;
MakeNotModerator(&data);
SendToOne(&data, good);
return;
}
}
bool notify = !(AccountMgr::IsGMAccount(sec) && sWorld->getBoolConfig(CONFIG_SILENTLY_GM_JOIN_TO_CHANNEL));
if (ban)
{
if (!IsBanned(victim))
{
bannedStore[GUID_LOPART(victim)] = time(NULL) + CHANNEL_BAN_DURATION;
AddChannelBanToDB(GUID_LOPART(victim), time(NULL) + CHANNEL_BAN_DURATION);
if (notify)
{
WorldPacket data;
MakePlayerBanned(&data, victim, good);
SendToAll(&data);
}
}
}
else if (notify)
{
WorldPacket data;
MakePlayerKicked(&data, victim, good);
SendToAll(&data);
}
if (isOnChannel)
{
playersStore.erase(victim);
bad->LeftChannel(this);
RemoveWatching(bad);
LeaveNotify(bad);
}
if (changeowner && _ownership)
{
if (good != victim)
SetOwner(good);
else if (!playersStore.empty())
{
uint64 newowner = 0;
for (Channel::PlayerContainer::const_iterator itr = playersStore.begin(); itr != playersStore.end(); ++itr)
{
newowner = itr->second.player;
if (!itr->second.plrPtr->GetSession()->GetSecurity())
break;
}
SetOwner(newowner);
}
else
SetOwner(0);
}
}
void Channel::Say(Player* player, const char* text, uint32 lang)
{
if (!text)
return;
uint32 sec = 0;
ObjectGuid guid = player->GetObjectGuid();
Player* plr = sObjectMgr.GetPlayer(guid);
bool speakInLocalDef = false;
bool speakInWorldDef = false;
if (plr)
{
sec = plr->GetSession()->GetSecurity();
if (plr->isGameMaster())
{
speakInLocalDef = true;
speakInWorldDef = true;
}
HonorRankInfo honorInfo = plr->GetHonorRankInfo();
//We can speak in local defense if we're above this rank (see .h file)
if (honorInfo.rank >= SPEAK_IN_LOCALDEFENSE_RANK)
speakInLocalDef = true;
// Are we not allowed to speak in WorldDefense at all?
// if (honorInfo.rank >= SPEAK_IN_WORLDDEFENSE_RANK)
// speakInWorldDef = true;
}
if (!IsOn(guid))
{
WorldPacket data;
MakeNotMember(&data);
SendToOne(&data, guid);
return;
}
else if (m_players[guid].IsMuted() ||
(GetChannelId() == CHANNEL_ID_LOCAL_DEFENSE && !speakInLocalDef) ||
(GetChannelId() == CHANNEL_ID_WORLD_DEFENSE && !speakInWorldDef))
{
WorldPacket data;
MakeMuted(&data);
SendToOne(&data, guid);
return;
}
if (m_moderate && !m_players[guid].IsModerator() && player->GetSession()->GetSecurity() < SEC_GAMEMASTER)
{
WorldPacket data;
MakeNotModerator(&data);
SendToOne(&data, guid);
return;
}
// send channel message
if (sWorld.getConfig(CONFIG_BOOL_ALLOW_TWO_SIDE_INTERACTION_CHANNEL))
lang = LANG_UNIVERSAL;
WorldPacket data;
ChatHandler::BuildChatPacket(data, CHAT_MSG_CHANNEL, text, Language(lang), player->GetChatTag(), guid, player->GetName(), ObjectGuid(), "", m_name.c_str(), player->GetHonorRankInfo().rank);
SendToAll(&data, !m_players[guid].IsModerator() ? guid : ObjectGuid());
}
void Channel::KickOrBan(Player const* player, std::string const& badname, bool ban)
{
ObjectGuid good = player->GetGUID();
if (!IsOn(good))
{
WorldPacket data;
MakeNotMember(&data);
SendToOne(&data, good);
return;
}
if (!playersStore[good].IsModerator() && !player->GetSession()->HasPermission(rbac::RBAC_PERM_CHANGE_CHANNEL_NOT_MODERATOR))
{
WorldPacket data;
MakeNotModerator(&data);
SendToOne(&data, good);
return;
}
Player* bad = sObjectAccessor->FindPlayerByName(badname);
ObjectGuid victim = bad ? bad->GetGUID() : ObjectGuid::Empty;
if (!victim || !IsOn(victim))
{
WorldPacket data;
MakePlayerNotFound(&data, badname);
SendToOne(&data, good);
return;
}
bool changeowner = _ownerGUID == victim;
if (!player->GetSession()->HasPermission(rbac::RBAC_PERM_CHANGE_CHANNEL_NOT_MODERATOR) && changeowner && good != _ownerGUID)
{
WorldPacket data;
MakeNotOwner(&data);
SendToOne(&data, good);
return;
}
if (ban && !IsBanned(victim))
{
bannedStore.insert(victim);
UpdateChannelInDB();
if (!player->GetSession()->HasPermission(rbac::RBAC_PERM_SILENTLY_JOIN_CHANNEL))
{
WorldPacket data;
MakePlayerBanned(&data, victim, good);
SendToAll(&data);
}
}
else if (!player->GetSession()->HasPermission(rbac::RBAC_PERM_SILENTLY_JOIN_CHANNEL))
{
WorldPacket data;
MakePlayerKicked(&data, victim, good);
SendToAll(&data);
}
playersStore.erase(victim);
bad->LeftChannel(this);
if (changeowner && _ownership && !playersStore.empty())
{
ObjectGuid newowner = good;
playersStore[newowner].SetModerator(true);
SetOwner(newowner);
}
}
void Channel::KickOrBan(Player* player, const char* targetName, bool ban)
{
ObjectGuid guid = player->GetObjectGuid();
if (!IsOn(guid))
{
WorldPacket data;
MakeNotMember(&data);
SendToOne(&data, guid);
return;
}
if (!m_players[guid].IsModerator() && player->GetSession()->GetSecurity() < SEC_GAMEMASTER)
{
WorldPacket data;
MakeNotModerator(&data);
SendToOne(&data, guid);
return;
}
Player* target = sObjectMgr.GetPlayer(targetName);
if (!target)
{
WorldPacket data;
MakePlayerNotFound(&data, targetName);
SendToOne(&data, guid);
return;
}
ObjectGuid targetGuid = target->GetObjectGuid();
if (!IsOn(targetGuid))
{
WorldPacket data;
MakePlayerNotFound(&data, targetName);
SendToOne(&data, guid);
return;
}
bool changeowner = m_ownerGuid == targetGuid;
if (player->GetSession()->GetSecurity() < SEC_GAMEMASTER && changeowner && guid != m_ownerGuid)
{
WorldPacket data;
MakeNotOwner(&data);
SendToOne(&data, guid);
return;
}
// kick or ban player
WorldPacket data;
if (ban && !IsBanned(targetGuid))
{
m_banned.insert(targetGuid);
MakePlayerBanned(&data, targetGuid, guid);
}
else
MakePlayerKicked(&data, targetGuid, guid);
SendToAll(&data);
m_players.erase(targetGuid);
target->LeftChannel(this);
if (changeowner)
{
ObjectGuid newowner = !m_players.empty() ? guid : ObjectGuid();
SetOwner(newowner);
}
}
void Channel::Join(uint64 p, const char *pass)
{
WorldPacket data;
if(IsOn(p))
{
if(!IsConstant()) // non send error message for built-in channels
{
MakePlayerAlreadyMember(&data, p);
SendToOne(&data, p);
}
return;
}
if(IsBanned(p))
{
MakeBanned(&data);
SendToOne(&data, p);
return;
}
if(m_password.length() > 0 && strcmp(pass, m_password.c_str()))
{
MakeWrongPassword(&data);
SendToOne(&data, p);
return;
}
Player *plr = sObjectMgr.GetPlayer(p);
if(plr)
{
if(HasFlag(CHANNEL_FLAG_LFG) &&
sWorld.getConfig(CONFIG_RESTRICTED_LFG_CHANNEL) && plr->GetSession()->GetSecurity() == SEC_PLAYER &&
(plr->GetGroup() || plr->m_lookingForGroup.Empty()) )
{
MakeNotInLfg(&data);
SendToOne(&data, p);
return;
}
if(plr->GetGuildId() && (GetFlags() == 0x38))
return;
plr->JoinedChannel(this);
}
if(m_announce && (!plr || plr->GetSession()->GetSecurity() < SEC_GAMEMASTER || !sWorld.getConfig(CONFIG_SILENTLY_GM_JOIN_TO_CHANNEL) ))
{
MakeJoined(&data, p);
SendToAll(&data);
}
data.clear();
PlayerInfo pinfo;
pinfo.player = p;
pinfo.flags = 0;
players[p] = pinfo;
MakeYouJoined(&data);
SendToOne(&data, p);
JoinNotify(p);
// if no owner first logged will become
if(!IsConstant() && !m_ownerGUID)
{
SetOwner(p, (players.size() > 1 ? true : false));
players[p].SetModerator(true);
}
}
void Channel::Join(Player* player, const char* password)
{
ObjectGuid guid = player->GetObjectGuid();
WorldPacket data;
if (IsOn(guid))
{
if (!IsConstant()) // non send error message for built-in channels
{
MakePlayerAlreadyMember(&data, guid);
SendToOne(&data, guid);
}
return;
}
if (IsBanned(guid))
{
MakeBanned(&data);
SendToOne(&data, guid);
return;
}
if (m_password.length() > 0 && strcmp(password, m_password.c_str()))
{
MakeWrongPassword(&data);
SendToOne(&data, guid);
return;
}
if (HasFlag(CHANNEL_FLAG_LFG) && sWorld.getConfig(CONFIG_BOOL_RESTRICTED_LFG_CHANNEL) && player->GetSession()->GetSecurity() == SEC_PLAYER &&
(player->GetGroup() || player->m_lookingForGroup.Empty()))
{
MakeNotInLfg(&data);
SendToOne(&data, guid);
return;
}
if (player->GetGuildId() && (GetFlags() == 0x38))
return;
// join channel
player->JoinedChannel(this);
if (m_announce && (player->GetSession()->GetSecurity() < SEC_GAMEMASTER || !sWorld.getConfig(CONFIG_BOOL_SILENTLY_GM_JOIN_TO_CHANNEL)))
{
MakeJoined(&data, guid);
SendToAll(&data);
}
data.clear();
PlayerInfo& pinfo = m_players[guid];
pinfo.player = guid;
pinfo.flags = MEMBER_FLAG_NONE;
MakeYouJoined(&data);
SendToOne(&data, guid);
JoinNotify(guid);
// if no owner first logged will become
if (!IsConstant() && !m_ownerGuid)
{
SetOwner(guid, (m_players.size() > 1 ? true : false));
m_players[guid].SetModerator(true);
}
}
void Channel::KickOrBan(uint64 good, const char *badname, bool ban)
{
AccountTypes sec = SEC_PLAYER;
Player *gplr = sObjectMgr->GetPlayer(good);
if (gplr)
sec = gplr->GetSession()->GetSecurity();
if (!IsOn(good))
{
WorldPacket data;
MakeNotMember(&data);
SendToOne(&data, good);
}
else if (!players[good].IsModerator() && sec < SEC_GAMEMASTER)
{
WorldPacket data;
MakeNotModerator(&data);
SendToOne(&data, good);
}
else
{
Player *bad = sObjectMgr->GetPlayer(badname);
if (bad == NULL || !IsOn(bad->GetGUID()))
{
WorldPacket data;
MakePlayerNotFound(&data, badname);
SendToOne(&data, good);
}
else if (sec < SEC_GAMEMASTER && bad->GetGUID() == m_ownerGUID && good != m_ownerGUID)
{
WorldPacket data;
MakeNotOwner(&data);
SendToOne(&data, good);
}
else
{
bool changeowner = (m_ownerGUID == bad->GetGUID());
WorldPacket data;
if (ban && !IsBanned(bad->GetGUID()))
{
banned.insert(bad->GetGUID());
MakePlayerBanned(&data, bad->GetGUID(), good);
UpdateChannelInDB();
}
else
MakePlayerKicked(&data, bad->GetGUID(), good);
SendToAll(&data);
players.erase(bad->GetGUID());
bad->LeftChannel(this);
if (changeowner && m_ownership && !players.empty())
{
uint64 newowner = good;
players[newowner].SetModerator(true);
SetOwner(newowner);
}
}
}
}
void SendTeamChangeMessage(int id, unsigned char team, unsigned char skin){
byte buffer[] = {20,id,team,skin};
SendToAll(buffer, 4, 1);
}