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 = ObjectAccessor::FindPlayer(p);
if (plr)
{
if (HasFlag(CHANNEL_FLAG_LFG) &&
sWorld->getConfig(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->getConfig(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);
// if no owner first logged will become
if (!IsConstant() && !m_ownerGUID)
{
SetOwner(p, (players.size() > 1 ? true : false));
players[p].SetModerator(true);
}
/*
else if (!IsConstant() && m_ownerGUID && plr && m_ownerGUID == plr->GetGUID()))
{
SetOwner(p, (players.size() > 1 ? true : false));
players[p].SetModerator(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;
}
bool notify = !(AccountMgr::IsGMAccount(sec) && sWorld->getBoolConfig(CONFIG_SILENTLY_GM_JOIN_TO_CHANNEL));
if (ban && !IsBanned(victim))
{
bannedStore.insert(victim);
UpdateChannelInDB();
if (notify)
{
WorldPacket data;
MakePlayerBanned(&data, victim, good);
SendToAll(&data);
}
}
else if (notify)
{
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(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::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 CXTPPropertyGridInplaceList::Create(CXTPPropertyGridItem* pItem, CRect rect)
{
ASSERT(pItem && pItem->GetGrid());
if (!pItem)
return;
CRect rcValue(rect);
rcValue.left = pItem->GetGrid()->GetDividerPos() + 1;
CWnd* pParent = (CWnd*)pItem->GetGrid();
m_pItem = pItem;
DestroyWindow();
if (!m_hWnd)
{
CListBox::CreateEx(WS_EX_TOOLWINDOW | (pParent->GetExStyle() & WS_EX_LAYOUTRTL), _T("LISTBOX"), _T(""),
LBS_NOTIFY | WS_CHILD | WS_VSCROLL | WS_BORDER | LBS_OWNERDRAWFIXED | LBS_HASSTRINGS, CRect(0, 0, 0, 0), pParent, 0);
SetOwner(pParent);
if (m_bShowShadow && XTPSystemVersion()->IsWinXPOrGreater())
SetClassLongPtr(m_hWnd, GCL_STYLE, GetClassLongPtr(m_hWnd, GCL_STYLE) | 0x00020000);
}
SetFont(pParent->GetFont());
ResetContent();
CXTPPropertyGridItemConstraints* pList = pItem->GetConstraints();
int dx = rect.right - rcValue.left;
CWindowDC dc(pParent);
CXTPFontDC font(&dc, pParent->GetFont());
int nHeight = dc.GetTextExtent(_T(" "), 1).cy + 3;
for (int i = 0; i < pList->GetCount(); i++)
{
CXTPPropertyGridItemConstraint* pConstraint = pList->GetConstraintAt(i);
CString str = pConstraint->m_strConstraint;
int nIndex = AddString(str);
SetItemDataPtr(nIndex, pConstraint);
CSize sz = pItem->OnMergeItemConstraint(&dc, pConstraint);
dx = max(dx, sz.cx);
nHeight = max(nHeight, sz.cy);
if (pItem->GetValue() == str)
SetCurSel(nIndex);
}
SetItemHeight(0, nHeight);
rect.top = rect.bottom;
rect.bottom += nHeight * __min(pItem->GetDropDownItemCount(), GetCount()) + 2;
rect.left = rect.right - __min(dx, rect.Width() - XTP_PGI_EXPAND_BORDER);
pParent->ClientToScreen(&rect);
CRect rcWork = XTPMultiMonitor()->GetWorkArea(rect);
if (rect.bottom > rcWork.bottom && rect.top > rcWork.CenterPoint().y)
{
rect.OffsetRect(0, - rect.Height() - rcValue.Height() - 1);
}
if (rect.left < rcWork.left) rect.OffsetRect(rcWork.left - rect.left, 0);
if (rect.right > rcWork.right) rect.OffsetRect(rcWork.right - rect.right, 0);
SetFocus();
SetWindowLongPtr(m_hWnd, GWLP_HWNDPARENT, 0);
ModifyStyle(WS_CHILD, WS_POPUP);
SetWindowLongPtr(m_hWnd, GWLP_HWNDPARENT, (LONG_PTR)pParent->m_hWnd);
SetWindowPos(&CWnd::wndTopMost, rect.left, rect.top, rect.Width(), rect.Height(), SWP_SHOWWINDOW | SWP_NOACTIVATE | SWP_NOOWNERZORDER);
CXTPMouseMonitor::SetupHook(this);
}
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::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_BOOL_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_GM || !sWorld.getConfig(CONFIG_BOOL_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);
sIRC.Handle_WoW_Channel(m_name, sObjectMgr.GetPlayer(p), CHANNEL_JOIN);
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(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;
}
Player* plr = sObjectMgr.GetPlayer(p);
if (plr)
{
if (plr->GetGuildId() && (GetFlags() == 0x38))
return;
plr->JoinedChannel(this);
}
if (m_announce && (!plr || 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 (!IsConstant() && !m_ownerGuid)
{
SetOwner(p, (m_players.size() > 1 ? true : false));
m_players[p].SetModerator(true);
}
}
void Channel::KickOrBan(Player const* player, std::string const& badname, bool ban)
{
uint64 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);
uint64 victim = bad ? bad->GetGUID() : 0;
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())
{
uint64 newowner = good;
playersStore[newowner].SetModerator(true);
SetOwner(newowner);
}
}
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())
{
WorldPackets::Channel::ChannelNotify notify;
MakePlayerAlreadyMember(notify, guid);
player->SendDirectMessage(notify.Write());
}
return;
}
if (IsBanned(guid))
{
WorldPackets::Channel::ChannelNotify notify;
MakeBanned(notify);
player->SendDirectMessage(notify.Write());
return;
}
if (!_password.empty() && pass != _password)
{
WorldPackets::Channel::ChannelNotify notify;
MakeWrongPassword(notify);
player->SendDirectMessage(notify.Write());
return;
}
if (HasFlag(CHANNEL_FLAG_LFG) &&
sWorld->getBoolConfig(CONFIG_RESTRICTED_LFG_CHANNEL) &&
AccountMgr::IsPlayerAccount(player->GetSession()->GetSecurity()) && //FIXME: Move to RBAC
player->GetGroup())
{
WorldPackets::Channel::ChannelNotify notify;
MakeNotInLfg(notify);
player->SendDirectMessage(notify.Write());
return;
}
player->JoinedChannel(this);
if (_announce && !player->GetSession()->HasPermission(rbac::RBAC_PERM_SILENTLY_JOIN_CHANNEL))
{
WorldPackets::Channel::ChannelNotify notify;
MakeJoined(notify, guid);
SendToAll(notify.Write());
}
PlayerInfo playerInfo;
playerInfo.PlayerGuid = guid;
_playersStore[guid] = playerInfo;
/*
WorldPackets::Channel::ChannelNotify notify;
MakeYouJoined(notify);
player->SendDirectMessage(notify.Write());
*/
WorldPackets::Channel::ChannelNotifyJoined notify;
//notify.ChannelWelcomeMsg = "";
notify.ChatChannelID = _channelId;
//notify.InstanceID = 0;
notify._ChannelFlags = _flags;
notify._Channel = _name;
player->SendDirectMessage(notify.Write());
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.
if (_ownerGUID.IsEmpty() && _ownership)
{
SetOwner(guid, _playersStore.size() > 1);
_playersStore[guid].SetModerator(true);
}
}
}
void Channel::KickOrBan(Player const* player, std::string const& badname, bool ban)
{
ObjectGuid const& good = player->GetGUID();
if (!IsOn(good))
{
WorldPackets::Channel::ChannelNotify notify;
MakeNotMember(notify);
player->SendDirectMessage(notify.Write());
return;
}
if (!_playersStore[good].IsModerator() && !player->GetSession()->HasPermission(rbac::RBAC_PERM_CHANGE_CHANNEL_NOT_MODERATOR))
{
WorldPackets::Channel::ChannelNotify notify;
MakeNotModerator(notify);
player->SendDirectMessage(notify.Write());
return;
}
Player* bad = ObjectAccessor::FindConnectedPlayerByName(badname);
ObjectGuid victim = bad ? bad->GetGUID() : ObjectGuid::Empty;
if (!victim || !IsOn(victim))
{
WorldPackets::Channel::ChannelNotify notify;
MakePlayerNotFound(notify, badname);
player->SendDirectMessage(notify.Write());
return;
}
bool changeowner = _ownerGUID == victim;
if (!player->GetSession()->HasPermission(rbac::RBAC_PERM_CHANGE_CHANNEL_NOT_MODERATOR) && changeowner && good != _ownerGUID)
{
WorldPackets::Channel::ChannelNotify notify;
MakeNotOwner(notify);
player->SendDirectMessage(notify.Write());
return;
}
if (ban && !IsBanned(victim))
{
_bannedStore.insert(victim);
UpdateChannelInDB();
if (!player->GetSession()->HasPermission(rbac::RBAC_PERM_SILENTLY_JOIN_CHANNEL))
{
WorldPackets::Channel::ChannelNotify notify;
MakePlayerBanned(notify, victim, good);
SendToAll(notify.Write());
}
}
else if (!player->GetSession()->HasPermission(rbac::RBAC_PERM_SILENTLY_JOIN_CHANNEL))
{
WorldPackets::Channel::ChannelNotify notify;
MakePlayerKicked(notify, victim, good);
SendToAll(notify.Write());
}
_playersStore.erase(victim);
bad->LeftChannel(this);
if (changeowner && _ownership && !_playersStore.empty())
{
_playersStore[good].SetModerator(true);
SetOwner(good);
}
}
//////////////////////////////////////////////////////////////////////////
// CComboEdit
SComboEdit::SComboEdit( SWindow *pOwner )
{
SetOwner(pOwner);
}
void XmlNode::SetParent(XmlNode* value)
{
if (value == NULL)
throw Sys::CreateArgumentNullException();
SetOwner(value->m_Children);
}
bool Planet::Colonize(int empire_id, const std::string& species_name, double population) {
const Species* species = 0;
// if desired pop > 0, we want a colony, not an outpost, so we need to do some checks
if (population > 0.0) {
// check if specified species exists and get reference
species = GetSpecies(species_name);
if (!species) {
ErrorLogger() << "Planet::Colonize couldn't get species already on planet with name: " << species_name;
return false;
}
// check if specified species can colonize this planet
if (EnvironmentForSpecies(species_name) < PE_HOSTILE) {
ErrorLogger() << "Planet::Colonize: can't colonize planet already populated by species " << species_name;
return false;
}
}
// reset the planet to unowned/unpopulated
if (!OwnedBy(empire_id)) {
Reset();
} else {
PopCenter::Reset();
for (std::set<int>::const_iterator it = m_buildings.begin(); it != m_buildings.end(); ++it)
if (TemporaryPtr<Building> building = GetBuilding(*it))
building->Reset();
m_just_conquered = false;
m_is_about_to_be_colonized = false;
m_is_about_to_be_invaded = false;
m_is_about_to_be_bombarded = false;
SetOwner(ALL_EMPIRES);
}
// if desired pop > 0, we want a colony, not an outpost, so we have to set the colony species
if (population > 0.0)
SetSpecies(species_name);
// find a default focus. use first defined available focus.
// AvailableFoci function should return a vector of all names of
// available foci.
std::vector<std::string> available_foci = AvailableFoci();
if (species && !available_foci.empty()) {
bool found_preference = false;
for (std::vector<std::string>::const_iterator it = available_foci.begin();
it != available_foci.end(); ++it)
{
if (!it->empty() && *it == species->PreferredFocus()) {
SetFocus(*it);
found_preference = true;
break;
}
}
if (!found_preference)
SetFocus(*available_foci.begin());
} else {
DebugLogger() << "Planet::Colonize unable to find a focus to set for species " << species_name;
}
// set colony population
GetMeter(METER_POPULATION)->SetCurrent(population);
GetMeter(METER_TARGET_POPULATION)->SetCurrent(population);
BackPropegateMeters();
// set specified empire as owner
SetOwner(empire_id);
// if there are buildings on the planet, set the specified empire as their owner too
std::vector<TemporaryPtr<Building> > buildings = Objects().FindObjects<Building>(BuildingIDs());
for (std::vector<TemporaryPtr<Building> >::iterator building_it = buildings.begin();
building_it != buildings.end(); ++building_it)
{ (*building_it)->SetOwner(empire_id); }
return true;
}
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::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 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;
}
}
}
//***********************************************************************************************************
BOOL CBCGPBaseVisualCtrl::CreatePopup(const CRect& rect, BYTE nTransparency, CWnd* pWndOwner)
{
#if !defined _BCGPCHART_STANDALONE
CString strClassName = globalData.RegisterWindowClass (_T("BCGPVisualCtrl"));
m_bIsPopup = TRUE;
m_nPopupAlpha = nTransparency;
#if _MSC_VER < 1700 || !defined(_BCGSUITE_)
DWORD dwExStyle = (globalData.IsWindowsLayerSupportAvailable () && globalData.m_nBitsPerPixel > 8) ?
WS_EX_LAYERED : 0;
#else
DWORD dwExStyle = globalData.m_nBitsPerPixel > 8 ? WS_EX_LAYERED : 0;
#endif
if (!CWnd::CreateEx (dwExStyle | WS_EX_TOOLWINDOW,
strClassName,
_T (""),
WS_POPUP | MFS_SYNCACTIVE,
rect,
pWndOwner == NULL ? AfxGetMainWnd() : pWndOwner,
0))
{
return FALSE;
}
if (pWndOwner != NULL)
{
SetOwner(pWndOwner);
}
if (CBCGPPopupMenu::GetActiveMenu() != NULL && ::IsWindow (CBCGPPopupMenu::GetActiveMenu()->m_hWnd))
{
CBCGPPopupMenu::GetActiveMenu()->SendMessage (WM_CLOSE);
}
ShowWindow(SW_SHOWNOACTIVATE);
if (TRUE /* TODO - flag close on mouse click */)
{
if (m_hwndHookedPopup != NULL)
{
::SendMessage(m_hwndHookedPopup, WM_CLOSE, 0, 0);
}
ASSERT(m_hookMouse == NULL);
m_hookMouse = ::SetWindowsHookEx(WH_MOUSE, MouseProc, 0, GetCurrentThreadId());
m_hwndHookedPopup = GetSafeHwnd();
}
if (dwExStyle & WS_EX_LAYERED)
{
OnDrawLayeredPopup();
}
SetFocus();
return TRUE;
#else
return FALSE;
#endif
}
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);
}
}
/*
==============================
SUB_UseTargets
If self.delay is set, a DelayedUse entity will be created that will actually
do the SUB_UseTargets after that many seconds have passed.
Removes all entities with a targetname that match self.killtarget,
and removes them, so some events can remove other triggers.
Search for (string)targetname in all entities that
match (string)self.target and call their .use function (if they have one)
==============================
*/
void CBaseDelay::SUB_UseTargets( CBaseEntity *pActivator, USE_TYPE useType, float value )
{
//
// exit immediatly if we don't have a target or kill target
//
if( !HasTarget() && !m_iszKillTarget )
return;
//
// check for a delay
//
if( m_flDelay != 0 )
{
// create a temp object to fire at a later time
auto pTemp = static_cast<CBaseDelay*>( UTIL_CreateNamedEntity( "DelayedUse" ) );
pTemp->SetNextThink( gpGlobals->time + m_flDelay );
pTemp->SetThink( &CBaseDelay::DelayThink );
// Save the useType
pTemp->GetButtons().Set( ( int ) useType );
pTemp->m_iszKillTarget = m_iszKillTarget;
pTemp->m_flDelay = 0; // prevent "recursion"
pTemp->SetTarget( GetTarget() );
// HACKHACK
// This wasn't in the release build of Half-Life. We should have moved m_hActivator into this class
// but changing member variable hierarchy would break save/restore without some ugly code.
// This code is not as ugly as that code
if( pActivator && pActivator->IsPlayer() ) // If a player activates, then save it
{
pTemp->SetOwner( pActivator );
}
else
{
pTemp->SetOwner( NULL );
}
return;
}
//
// kill the killtargets
//
if( m_iszKillTarget )
{
CBaseEntity* pKillTarget = nullptr;
ALERT( at_aiconsole, "KillTarget: %s\n", STRING( m_iszKillTarget ) );
while( ( pKillTarget = UTIL_FindEntityByTargetname( pKillTarget, STRING( m_iszKillTarget ) ) ) != nullptr )
{
UTIL_Remove( pKillTarget );
ALERT( at_aiconsole, "killing %s\n", pKillTarget->GetClassname() );
}
}
//
// fire targets
//
if( HasTarget() )
{
FireTargets( GetTarget(), pActivator, this, useType, value );
}
}
void Channel::Part(Player* plr, bool silent)
{
if(plr == 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);
plr->LeftChannel(m_channelId);
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)
{
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;
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);
}
}
}
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);
}
}
}
}
Ship::Ship(int empire_id, int design_id, const std::string& species_name,
int produced_by_empire_id/* = ALL_EMPIRES*/) :
UniverseObject(),
m_design_id(design_id),
m_fleet_id(INVALID_OBJECT_ID),
m_ordered_scrapped(false),
m_ordered_colonize_planet_id(INVALID_OBJECT_ID),
m_ordered_invade_planet_id(INVALID_OBJECT_ID),
m_ordered_bombard_planet_id(INVALID_OBJECT_ID),
m_last_turn_active_in_combat(INVALID_GAME_TURN),
m_species_name(species_name),
m_produced_by_empire_id(produced_by_empire_id),
m_arrived_on_turn(CurrentTurn())
{
if (!GetShipDesign(design_id))
throw std::invalid_argument("Attempted to construct a Ship with an invalid design id");
if (!m_species_name.empty() && !GetSpecies(m_species_name))
DebugLogger() << "Ship created with invalid species name: " << m_species_name;
SetOwner(empire_id);
UniverseObject::Init();
AddMeter(METER_FUEL);
AddMeter(METER_MAX_FUEL);
AddMeter(METER_SHIELD);
AddMeter(METER_MAX_SHIELD);
AddMeter(METER_DETECTION);
AddMeter(METER_STRUCTURE);
AddMeter(METER_MAX_STRUCTURE);
AddMeter(METER_SPEED);
AddMeter(METER_TARGET_INDUSTRY);
AddMeter(METER_INDUSTRY);
AddMeter(METER_TARGET_RESEARCH);
AddMeter(METER_RESEARCH);
AddMeter(METER_TARGET_TRADE);
AddMeter(METER_TRADE);
const std::vector<std::string>& part_names = Design()->Parts();
for (std::size_t i = 0; i < part_names.size(); ++i) {
if (part_names[i] != "") {
const PartType* part = GetPartType(part_names[i]);
if (!part) {
ErrorLogger() << "Ship::Ship couldn't get part with name " << part_names[i];
continue;
}
switch (part->Class()) {
case PC_COLONY:
case PC_TROOPS: {
m_part_meters[std::make_pair(METER_CAPACITY, part->Name())];
break;
}
case PC_DIRECT_WEAPON: // capacity is damage, secondary stat is shots per attack
case PC_FIGHTER_HANGAR: { // capacity is how many fighters contained, secondary stat is damage per fighter attack
m_part_meters[std::make_pair(METER_SECONDARY_STAT, part->Name())];
m_part_meters[std::make_pair(METER_MAX_SECONDARY_STAT, part->Name())];
// intentionally no break here
}
case PC_FIGHTER_BAY: { // capacity is how many fighters launched per combat round
m_part_meters[std::make_pair(METER_CAPACITY, part->Name())];
m_part_meters[std::make_pair(METER_MAX_CAPACITY, part->Name())];
break;
}
default:
break;
}
}
}
}