/**
Function that refresh all battlefield players
*/
void Battlefield::UpdateBattlefieldPlayers()
{
bool bRemoved = false;
for (BattlefieldPlayerDataMap::iterator itr = m_activePlayers.begin(); itr != m_activePlayers.end();)
{
if (itr->second->removeTime && itr->second->removeTime + itr->second->removeDelay < time(nullptr))
{
// kick player from zone
delete itr->second;
if (Player* player = sObjectMgr.GetPlayer(itr->first))
KickBattlefieldPlayer(player);
// remove player from group
if (HasPlayer(itr->first))
{
RemovePlayerFromRaid(itr->first);
bRemoved = true;
}
m_activePlayers.erase(itr++);
}
else
++itr;
}
// call the update function for specific script action
if (bRemoved)
OnBattlefieldPlayersUpdate();
}
bool pyVaultPlayerInfoListNode::AddPlayer( uint32_t playerID )
{
if (HasPlayer(playerID))
return true;
if (!fNode)
return false;
NetVaultNode * templateNode = NEWZERO(NetVaultNode);
templateNode->IncRef();
templateNode->SetNodeType(plVault::kNodeType_PlayerInfo);
VaultPlayerInfoNode access(templateNode);
access.SetPlayerId(playerID);
ARRAY(unsigned) nodeIds;
VaultLocalFindNodes(templateNode, &nodeIds);
if (!nodeIds.Count())
VaultFindNodesAndWait(templateNode, &nodeIds);
if (nodeIds.Count())
VaultAddChildNodeAndWait(fNode->nodeId, nodeIds[0], VaultGetPlayerId());
templateNode->DecRef();
return nodeIds.Count() != 0;
}
/**
Function that handles player invite response
@param player that responded
@param whether the player has accepted or not
*/
void Battlefield::HandleQueueInviteResponse(Player* player, bool accepted)
{
if (!accepted || HasPlayer(player->GetObjectGuid()))
return;
PvpTeamIndex teamIdx = GetTeamIndexByTeamId(player->GetTeam());
// reject if queue battlefield is full
if (IsTeamFull(teamIdx))
{
player->GetSession()->SendBattlefieldQueueResponse(m_battleFieldId, m_zoneId, true, true);
return;
}
if (m_queuedPlayers[teamIdx].find(player->GetObjectGuid()) == m_queuedPlayers[teamIdx].end())
{
if (GetBattlefieldStatus() == BF_STATUS_IN_PROGRESS)
{
m_invitedPlayers[teamIdx][player->GetObjectGuid()] = time(nullptr) + BF_TIME_TO_ACCEPT;
player->GetSession()->SendBattlefieldWarInvite(m_battleFieldId, m_zoneId, BF_TIME_TO_ACCEPT);
}
else
{
m_queuedPlayers[teamIdx].insert(player->GetObjectGuid());
player->GetSession()->SendBattlefieldQueueResponse(m_battleFieldId, m_zoneId, true, false);
}
}
}
/**
Function that adds a player to the players of the affected battlefield zones
@param player to add
@param whether zone is main outdoor pvp zone or a affected zone
*/
void Battlefield::HandlePlayerEnterZone(Player* player, bool isMainZone)
{
OutdoorPvP::HandlePlayerEnterZone(player, isMainZone);
// invite to group or queue
if (!HasPlayer(player->GetObjectGuid()))
{
if (GetBattlefieldStatus() == BF_STATUS_IN_PROGRESS)
{
m_invitedPlayers[GetTeamIndexByTeamId(player->GetTeam())][player->GetObjectGuid()] = time(nullptr) + BF_TIME_TO_ACCEPT;
player->GetSession()->SendBattlefieldWarInvite(m_battleFieldId, m_zoneId, BF_TIME_TO_ACCEPT);
}
else if (GetBattlefieldStatus() == BF_STATUS_COOLDOWN && m_timer < m_startInviteDelay)
InvitePlayerToQueue(player);
}
// check if player is already marked as active
BattlefieldPlayerDataMap::iterator itr = m_activePlayers.find(player->GetObjectGuid());
if (itr == m_activePlayers.end())
InitPlayerBattlefieldData(player);
else
{
if (GetBattlefieldStatus() == BF_STATUS_IN_PROGRESS && itr->second->removeTime && m_startTime > itr->second->removeTime)
SetupPlayerPosition(player);
itr->second->removeTime = 0;
}
}
/**
Function that handles the AFK status
@param player to be punished
*/
void Battlefield::HandlePlayerAFK(Player* player)
{
if (GetBattlefieldStatus() != BF_STATUS_IN_PROGRESS || !HasPlayer(player->GetObjectGuid()))
return;
RemovePlayerFromRaid(player->GetObjectGuid());
player->GetSession()->SendBattlefieldLeaveMessage(m_battleFieldId, BATTLEFIELD_LEAVE_REASON_EXITED);
KickBattlefieldPlayer(player);
}
/**
Function that handles player teleport response
@param player that responded
@param whether the player has accepted or not
*/
void Battlefield::HandleWarInviteResponse(Player* player, bool accepted)
{
if (HasPlayer(player->GetObjectGuid()))
return;
if (accepted)
{
PvpTeamIndex teamIdx = GetTeamIndexByTeamId(player->GetTeam());
std::map<ObjectGuid, time_t>::iterator itr = m_invitedPlayers[teamIdx].find(player->GetObjectGuid());
// he was not invited by core
if (itr == m_invitedPlayers[teamIdx].end())
return;
m_invitedPlayers[teamIdx].erase(itr);
if (CanAddPlayerToRaid(player))
{
DEBUG_LOG("Battlefield: CanAddPlayerToRaid for %s returned: TRUE", player->GetGuidStr().c_str());
player->GetSession()->SendBattlefieldEnteredResponse(m_battleFieldId);
}
else
DEBUG_LOG("Battlefield: CanAddPlayerToRaid for %s returned: FALSE", player->GetGuidStr().c_str());
// ToDo: recheck this!
if (player->GetZoneId() == m_zoneId)
{
if (m_activePlayers.find(player->GetObjectGuid()) == m_activePlayers.end()) // must never happen
InitPlayerBattlefieldData(player);
}
}
else
{
// kick players which refuse the war invite if battlefield is in progress
if (GetBattlefieldStatus() == BF_STATUS_IN_PROGRESS && player->GetZoneId() == m_zoneId)
{
player->GetSession()->SendBattlefieldLeaveMessage(m_battleFieldId, BATTLEFIELD_LEAVE_REASON_EXITED);
if (m_activePlayers.find(player->GetObjectGuid()) != m_activePlayers.end())
{
m_activePlayers[player->GetObjectGuid()]->removeTime = time(nullptr);
m_activePlayers[player->GetObjectGuid()]->removeDelay = BF_UNACCEPTED_REMOVE_DELAY;
}
}
}
// notify battlefield
UpdatePlayerBattleResponse(player);
}
/**
Function that removes a player from the players of the affected battlefield zones
@param player to remove
@param whether zone is main outdoor pvp zone or a affected zone
*/
void Battlefield::HandlePlayerLeaveZone(Player* player, bool isMainZone)
{
OutdoorPvP::HandlePlayerLeaveZone(player, isMainZone);
BattlefieldPlayerDataMap::iterator itr = m_activePlayers.find(player->GetObjectGuid());
if (itr != m_activePlayers.end())
{
// remove from battlefield if active
if (HasPlayer(itr->first))
{
player->GetSession()->SendBattlefieldLeaveMessage(m_battleFieldId, BATTLEFIELD_LEAVE_REASON_EXITED);
itr->second->removeTime = time(nullptr);
itr->second->removeDelay = BF_UNACCEPTED_REMOVE_DELAY;
}
else
m_activePlayers.erase(itr);
}
}
/**
Function that handles player invite to queue
@param player to be invited
*/
void Battlefield::InvitePlayerToQueue(Player* player)
{
if (HasPlayer(player->GetObjectGuid()))
return;
PvpTeamIndex teamIdx = GetTeamIndexByTeamId(player->GetTeam());
// he is in queue or waiting to accept teleport button
if (m_queuedPlayers[teamIdx].find(player->GetObjectGuid()) != m_queuedPlayers[teamIdx].end())
return;
if (m_invitedPlayers[teamIdx].find(player->GetObjectGuid()) != m_invitedPlayers[teamIdx].end())
return;
if (!IsTeamFull(teamIdx))
player->GetSession()->SendBattlefieldQueueInvite(m_battleFieldId);
else
player->GetSession()->SendBattlefieldQueueResponse(m_battleFieldId, m_zoneId, true, true);
}
/**
Function that rewards the given team players
@param kill credit
@param team
@param source object
*/
void Battlefield::QuestCreditTeam(uint32 credit, Team team, WorldObject* source)
{
for (auto& m_zonePlayer : m_zonePlayers)
{
if (!m_zonePlayer.first || !HasPlayer(m_zonePlayer.first))
continue;
Player* player = sObjectMgr.GetPlayer(m_zonePlayer.first);
if (!player)
continue;
// check if player is eligible for kill credit
if (!source || !credit || player->GetTeam() != team || !player->IsAtGroupRewardDistance(source))
continue;
player->KilledMonsterCredit(credit);
}
}
void pyVaultPlayerInfoListNode::AddPlayer( uint32_t playerID )
{
if (HasPlayer(playerID) || !fNode)
return;
NetVaultNode* templateNode = new NetVaultNode();
templateNode->IncRef();
templateNode->SetNodeType(plVault::kNodeType_PlayerInfo);
VaultPlayerInfoNode access(templateNode);
access.SetPlayerId(playerID);
ARRAY(uint32_t) nodeIds;
VaultLocalFindNodes(templateNode, &nodeIds);
// So, if we know about this node, we can take it easy. If not, we lazy load it.
if (nodeIds.Count())
VaultAddChildNode(fNode->GetNodeId(), nodeIds[0], VaultGetPlayerId(), nullptr, nullptr);
else {
fNode->IncRef();
VaultFindNodes(templateNode, IAddPlayer_NodesFound, fNode);
}
}
/**
Function that handles player queue exit request
@param player to exit queue
*/
void Battlefield::HandleExitRequest(Player* player)
{
// if already active in battlefield
if (HasPlayer(player->GetObjectGuid()))
{
player->GetSession()->SendBattlefieldLeaveMessage(m_battleFieldId, BATTLEFIELD_LEAVE_REASON_EXITED);
RemovePlayerFromRaid(player->GetObjectGuid());
if (m_activePlayers.find(player->GetObjectGuid()) != m_activePlayers.end())
{
m_activePlayers[player->GetObjectGuid()]->removeTime = time(nullptr);
m_activePlayers[player->GetObjectGuid()]->removeDelay = BF_UNACCEPTED_REMOVE_DELAY;
}
}
// else remove only from queue
else
{
std::set<ObjectGuid>::iterator itr = m_queuedPlayers[GetTeamIndexByTeamId(player->GetTeam())].find(player->GetObjectGuid());
if (itr != m_queuedPlayers[GetTeamIndexByTeamId(player->GetTeam())].end())
{
m_queuedPlayers[GetTeamIndexByTeamId(player->GetTeam())].erase(itr);
player->GetSession()->SendBattlefieldLeaveMessage(m_battleFieldId, BATTLEFIELD_LEAVE_REASON_EXITED);
if (m_activePlayers.find(player->GetObjectGuid()) != m_activePlayers.end())
{
m_activePlayers[player->GetObjectGuid()]->removeTime = time(nullptr);
m_activePlayers[player->GetObjectGuid()]->removeDelay = BF_UNACCEPTED_REMOVE_DELAY;
}
}
}
// notify battlefield
UpdatePlayerExitRequest(player);
}
bool PlayerContext::CreatePlayer(TV *tv, QWidget *widget,
TVState desiredState,
bool embed, const QRect &embedbounds,
bool muted)
{
if (HasPlayer())
{
LOG(VB_GENERAL, LOG_ERR, LOC +
"Attempting to setup a player, but it already exists.");
return false;
}
uint playerflags = kDecodeAllowEXT; // allow VDA etc for normal playback
playerflags |= muted ? kAudioMuted : kNoFlags;
playerflags |= useNullVideo ? kVideoIsNull : kNoFlags;
playerflags |= nohardwaredecoders ? kNoFlags : kDecodeAllowGPU;
MythPlayer *player = NULL;
if (kState_WatchingBD == desiredState)
player = new MythBDPlayer((PlayerFlags)playerflags);
else if (kState_WatchingDVD == desiredState)
player = new MythDVDPlayer((PlayerFlags)playerflags);
else
player = new MythPlayer((PlayerFlags)playerflags);
QString passthru_device =
gCoreContext->GetNumSetting("PassThruDeviceOverride", false) ?
gCoreContext->GetSetting("PassThruOutputDevice") : QString::null;
player->SetPlayerInfo(tv, widget, this);
AudioPlayer *audio = player->GetAudio();
audio->SetAudioInfo(gCoreContext->GetSetting("AudioOutputDevice"),
passthru_device,
gCoreContext->GetNumSetting("AudioSampleRate", 44100));
audio->SetStretchFactor(ts_normal);
player->SetLength(playingLen);
player->SetVideoFilters((useNullVideo) ? "onefield" : "");
if (!IsAudioNeeded())
audio->SetNoAudio();
else
{
QString subfn = buffer->GetSubtitleFilename();
if (!subfn.isEmpty() && player->GetSubReader())
player->GetSubReader()->LoadExternalSubtitles(subfn);
}
if (embed && !embedbounds.isNull())
player->EmbedInWidget(embedbounds);
bool isWatchingRecording = (desiredState == kState_WatchingRecording);
player->SetWatchingRecording(isWatchingRecording);
SetPlayer(player);
if (pipState == kPIPOff || pipState == kPBPLeft)
{
if (audio->HasAudioOut())
{
QString errMsg = audio->ReinitAudio();
}
}
else if (pipState == kPBPRight)
player->SetMuted(true);
return StartPlaying(-1);
}
bool PlayerContext::CreatePlayer(TV *tv, QWidget *widget,
TVState desiredState,
WId embedwinid, const QRect *embedbounds,
bool muted)
{
int exact_seeking = gCoreContext->GetNumSetting("ExactSeeking", 0);
if (HasPlayer())
{
VERBOSE(VB_IMPORTANT, LOC_ERR +
"Attempting to setup a player, but it already exists.");
return false;
}
MythPlayer *player = NULL;
if (kState_WatchingBD == desiredState)
player = new MythBDPlayer(muted);
else if (kState_WatchingDVD == desiredState)
player = new MythDVDPlayer(muted);
else
player = new MythPlayer(muted);
if (nohardwaredecoders)
player->DisableHardwareDecoders();
QString passthru_device = gCoreContext->GetNumSetting(
"PassThruDeviceOverride", false) ?
gCoreContext->GetSetting("PassThruOutputDevice") : QString::null;
player->SetPlayerInfo(tv, widget, exact_seeking, this);
AudioPlayer *audio = player->GetAudio();
audio->SetAudioInfo(gCoreContext->GetSetting("AudioOutputDevice"),
passthru_device,
gCoreContext->GetNumSetting("AudioSampleRate", 44100));
audio->SetStretchFactor(ts_normal);
player->SetLength(playingLen);
if (useNullVideo)
player->SetNullVideo();
player->SetVideoFilters((useNullVideo) ? "onefield" : "");
if (!IsAudioNeeded())
audio->SetNoAudio();
else
{
QString subfn = buffer->GetSubtitleFilename();
if (!subfn.isEmpty() && player->GetSubReader())
player->GetSubReader()->LoadExternalSubtitles(subfn);
}
if ((embedwinid > 0) && embedbounds)
{
player->EmbedInWidget(
embedbounds->x(), embedbounds->y(),
embedbounds->width(), embedbounds->height(), embedwinid);
}
bool isWatchingRecording = (desiredState == kState_WatchingRecording);
player->SetWatchingRecording(isWatchingRecording);
SetPlayer(player);
if (pipState == kPIPOff || pipState == kPBPLeft)
{
if (audio->HasAudioOut())
{
QString errMsg = audio->ReinitAudio();
}
}
else if (pipState == kPBPRight)
player->SetMuted(true);
return StartPlaying(-1);
}
