mirror of
https://github.com/mangosfour/server.git
synced 2025-12-14 07:37:01 +00:00
[7336] Implemented new BattleGroundQueue invitation system. Now it supports premade group versus premade group matches.
Added 2 new config options - InvitationType and PremadeGroupWaitForMatch - you can find more info in default config file. This patch can cause crashes. Signed-off-by: Triply <triply@getmangos.com>
This commit is contained in:
Triply
parent
872d791ca6
commit
8f995ce904
14 changed files with 860 additions and 940 deletions
|
|
@ -573,11 +573,11 @@ void AchievementMgr::UpdateAchievementCriteria(AchievementCriteriaTypes type, ui
|
|||
uint32 spellCount = 0;
|
||||
for (PlayerSpellMap::const_iterator spellIter = GetPlayer()->GetSpellMap().begin();
|
||||
spellIter != GetPlayer()->GetSpellMap().end();
|
||||
spellIter++)
|
||||
++spellIter)
|
||||
{
|
||||
for(SkillLineAbilityMap::const_iterator skillIter = spellmgr.GetBeginSkillLineAbilityMap(spellIter->first);
|
||||
skillIter != spellmgr.GetEndSkillLineAbilityMap(spellIter->first);
|
||||
skillIter++)
|
||||
++skillIter)
|
||||
{
|
||||
if(skillIter->second->skillId == achievementCriteria->learn_skilline_spell.skillLine)
|
||||
spellCount++;
|
||||
|
|
@ -605,7 +605,7 @@ void AchievementMgr::UpdateAchievementCriteria(AchievementCriteriaTypes type, ui
|
|||
{
|
||||
uint32 counter = 0;
|
||||
const FactionStateList factionStateList = GetPlayer()->GetFactionStateList();
|
||||
for (FactionStateList::const_iterator iter = factionStateList.begin(); iter!= factionStateList.end(); iter++)
|
||||
for (FactionStateList::const_iterator iter = factionStateList.begin(); iter!= factionStateList.end(); ++iter)
|
||||
{
|
||||
if(GetPlayer()->ReputationToRank(iter->second.Standing) >= REP_EXALTED)
|
||||
++counter;
|
||||
|
|
|
|||
|
|
@ -39,7 +39,7 @@ BattleGround::BattleGround()
|
|||
m_Status = 0;
|
||||
m_EndTime = 0;
|
||||
m_LastResurrectTime = 0;
|
||||
m_QueueId = MAX_BATTLEGROUND_QUEUES;
|
||||
m_QueueId = QUEUE_ID_MAX_LEVEL_19;
|
||||
m_InvitedAlliance = 0;
|
||||
m_InvitedHorde = 0;
|
||||
m_ArenaType = 0;
|
||||
|
|
@ -130,8 +130,6 @@ void BattleGround::Update(uint32 diff)
|
|||
//BG is empty
|
||||
return;
|
||||
|
||||
WorldPacket data;
|
||||
|
||||
if(GetRemovedPlayersSize())
|
||||
{
|
||||
for(std::map<uint64, uint8>::iterator itr = m_RemovedPlayers.begin(); itr != m_RemovedPlayers.end(); ++itr)
|
||||
|
|
@ -139,16 +137,6 @@ void BattleGround::Update(uint32 diff)
|
|||
Player *plr = objmgr.GetPlayer(itr->first);
|
||||
switch(itr->second)
|
||||
{
|
||||
//following code is handled by event:
|
||||
/*case 0:
|
||||
sBattleGroundMgr.m_BattleGroundQueues[GetTypeID()].RemovePlayer(itr->first);
|
||||
//RemovePlayerFromQueue(itr->first);
|
||||
if(plr)
|
||||
{
|
||||
sBattleGroundMgr.BuildBattleGroundStatusPacket(&data, this, plr->GetTeam(), plr->GetBattleGroundQueueIndex(m_TypeID), STATUS_NONE, 0, 0);
|
||||
plr->GetSession()->SendPacket(&data);
|
||||
}
|
||||
break;*/
|
||||
case 1: // currently in bg and was removed from bg
|
||||
if(plr)
|
||||
RemovePlayerAtLeave(itr->first, true, true);
|
||||
|
|
@ -874,7 +862,7 @@ void BattleGround::RemovePlayerAtLeave(uint64 guid, bool Transport, bool SendPac
|
|||
// this method is called when no players remains in battleground
|
||||
void BattleGround::Reset()
|
||||
{
|
||||
SetQueueId(MAX_BATTLEGROUND_QUEUES);
|
||||
SetQueueId(QUEUE_ID_MAX_LEVEL_19);
|
||||
SetWinner(WINNER_NONE);
|
||||
SetStatus(STATUS_WAIT_QUEUE);
|
||||
SetStartTime(0);
|
||||
|
|
@ -1009,7 +997,7 @@ void BattleGround::AddOrSetPlayerToCorrectBgGroup(Player *plr, uint64 plr_guid,
|
|||
void BattleGround::AddToBGFreeSlotQueue()
|
||||
{
|
||||
// make sure to add only once
|
||||
if(!m_InBGFreeSlotQueue)
|
||||
if(!m_InBGFreeSlotQueue && isBattleGround())
|
||||
{
|
||||
sBattleGroundMgr.BGFreeSlotQueue[m_TypeID].push_front(this);
|
||||
m_InBGFreeSlotQueue = true;
|
||||
|
|
@ -1033,61 +1021,12 @@ void BattleGround::RemoveFromBGFreeSlotQueue()
|
|||
}
|
||||
|
||||
// get the number of free slots for team
|
||||
// works in similar way that HasFreeSlotsForTeam did, but this is needed for join as group
|
||||
// returns the number how many players can join battleground to MaxPlayersPerTeam
|
||||
uint32 BattleGround::GetFreeSlotsForTeam(uint32 Team) const
|
||||
{
|
||||
//if BG is starting ... invite anyone
|
||||
if (GetStatus() == STATUS_WAIT_JOIN)
|
||||
if (GetStatus() == STATUS_WAIT_JOIN || GetStatus() == STATUS_IN_PROGRESS)
|
||||
return (GetInvitedCount(Team) < GetMaxPlayersPerTeam()) ? GetMaxPlayersPerTeam() - GetInvitedCount(Team) : 0;
|
||||
//if BG is already started .. do not allow to join too much players of one faction
|
||||
uint32 otherTeam;
|
||||
uint32 otherIn;
|
||||
if (Team == ALLIANCE)
|
||||
{
|
||||
otherTeam = GetInvitedCount(HORDE);
|
||||
otherIn = GetPlayersCountByTeam(HORDE);
|
||||
}
|
||||
else
|
||||
{
|
||||
otherTeam = GetInvitedCount(ALLIANCE);
|
||||
otherIn = GetPlayersCountByTeam(ALLIANCE);
|
||||
}
|
||||
if (GetStatus() == STATUS_IN_PROGRESS)
|
||||
{
|
||||
// difference based on ppl invited (not necessarily entered battle)
|
||||
// default: allow 0
|
||||
uint32 diff = 0;
|
||||
// allow join one person if the sides are equal (to fill up bg to minplayersperteam)
|
||||
if (otherTeam == GetInvitedCount(Team))
|
||||
diff = 1;
|
||||
// allow join more ppl if the other side has more players
|
||||
else if(otherTeam > GetInvitedCount(Team))
|
||||
diff = otherTeam - GetInvitedCount(Team);
|
||||
|
||||
// difference based on max players per team (don't allow inviting more)
|
||||
uint32 diff2 = (GetInvitedCount(Team) < GetMaxPlayersPerTeam()) ? GetMaxPlayersPerTeam() - GetInvitedCount(Team) : 0;
|
||||
|
||||
// difference based on players who already entered
|
||||
// default: allow 0
|
||||
uint32 diff3 = 0;
|
||||
// allow join one person if the sides are equal (to fill up bg minplayersperteam)
|
||||
if (otherIn == GetPlayersCountByTeam(Team))
|
||||
diff3 = 1;
|
||||
// allow join more ppl if the other side has more players
|
||||
else if (otherIn > GetPlayersCountByTeam(Team))
|
||||
diff3 = otherIn - GetPlayersCountByTeam(Team);
|
||||
// or other side has less than minPlayersPerTeam
|
||||
else if (GetInvitedCount(Team) <= GetMinPlayersPerTeam())
|
||||
diff3 = GetMinPlayersPerTeam() - GetInvitedCount(Team) + 1;
|
||||
|
||||
// return the minimum of the 3 differences
|
||||
|
||||
// min of diff and diff 2
|
||||
diff = diff < diff2 ? diff : diff2;
|
||||
|
||||
// min of diff, diff2 and diff3
|
||||
return diff < diff3 ? diff : diff3 ;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -86,6 +86,7 @@ enum BattleGroundTimeIntervals
|
|||
{
|
||||
RESURRECTION_INTERVAL = 30000, // ms
|
||||
REMIND_INTERVAL = 30000, // ms
|
||||
INVITATION_REMIND_TIME = 60000, // ms
|
||||
INVITE_ACCEPT_WAIT_TIME = 80000, // ms
|
||||
TIME_TO_AUTOREMOVE = 120000, // ms
|
||||
MAX_OFFLINE_TIME = 300000, // ms
|
||||
|
|
@ -143,8 +144,22 @@ enum BattleGroundQueueTypeId
|
|||
BATTLEGROUND_QUEUE_SA = 5,
|
||||
BATTLEGROUND_QUEUE_2v2 = 6,
|
||||
BATTLEGROUND_QUEUE_3v3 = 7,
|
||||
BATTLEGROUND_QUEUE_5v5 = 8,
|
||||
BATTLEGROUND_QUEUE_5v5 = 8
|
||||
};
|
||||
#define MAX_BATTLEGROUND_QUEUE_TYPES 9
|
||||
|
||||
enum BGQueueIdBasedOnLevel // queue_id for level ranges
|
||||
{
|
||||
QUEUE_ID_MAX_LEVEL_19 = 0,
|
||||
QUEUE_ID_MAX_LEVEL_29 = 1,
|
||||
QUEUE_ID_MAX_LEVEL_39 = 2,
|
||||
QUEUE_ID_MAX_LEVEL_49 = 3,
|
||||
QUEUE_ID_MAX_LEVEL_59 = 4,
|
||||
QUEUE_ID_MAX_LEVEL_69 = 5,
|
||||
QUEUE_ID_MAX_LEVEL_79 = 6,
|
||||
QUEUE_ID_MAX_LEVEL_80 = 7
|
||||
};
|
||||
#define MAX_BATTLEGROUND_QUEUES 8
|
||||
|
||||
enum ScoreType
|
||||
{
|
||||
|
|
@ -195,7 +210,8 @@ enum BattleGroundWinner
|
|||
enum BattleGroundTeamId
|
||||
{
|
||||
BG_TEAM_ALLIANCE = 0,
|
||||
BG_TEAM_HORDE = 1
|
||||
BG_TEAM_HORDE = 1,
|
||||
BG_TEAMS_COUNT = 2
|
||||
};
|
||||
|
||||
enum BattleGroundJoinError
|
||||
|
|
@ -255,7 +271,7 @@ class BattleGround
|
|||
// Get methods:
|
||||
char const* GetName() const { return m_Name; }
|
||||
BattleGroundTypeId GetTypeID() const { return m_TypeID; }
|
||||
uint32 GetQueueId() const { return m_QueueId; }
|
||||
BGQueueIdBasedOnLevel GetQueueId() const { return m_QueueId; }
|
||||
uint32 GetInstanceID() const { return m_InstanceID; }
|
||||
uint32 GetStatus() const { return m_Status; }
|
||||
uint32 GetStartTime() const { return m_StartTime; }
|
||||
|
|
@ -278,7 +294,13 @@ class BattleGround
|
|||
// Set methods:
|
||||
void SetName(char const* Name) { m_Name = Name; }
|
||||
void SetTypeID(BattleGroundTypeId TypeID) { m_TypeID = TypeID; }
|
||||
void SetQueueId(uint32 ID) { m_QueueId = ID; }
|
||||
//here we can count minlevel and maxlevel for players
|
||||
void SetQueueId(BGQueueIdBasedOnLevel ID)
|
||||
{
|
||||
m_QueueId = ID;
|
||||
uint8 diff = (m_TypeID == BATTLEGROUND_AV) ? 1 : 0;
|
||||
this->SetLevelRange((ID + 1) * 10 + diff, (ID + 2) * 10 - ((diff + 1) % 2));
|
||||
}
|
||||
void SetInstanceID(uint32 InstanceID) { m_InstanceID = InstanceID; }
|
||||
void SetStatus(uint32 Status) { m_Status = Status; }
|
||||
void SetStartTime(uint32 Time) { m_StartTime = Time; }
|
||||
|
|
@ -310,7 +332,6 @@ class BattleGround
|
|||
else
|
||||
return m_InvitedHorde;
|
||||
}
|
||||
bool HasFreeSlotsForTeam(uint32 Team) const;
|
||||
bool HasFreeSlots() const;
|
||||
uint32 GetFreeSlotsForTeam(uint32 Team) const;
|
||||
|
||||
|
|
@ -472,7 +493,7 @@ class BattleGround
|
|||
uint32 m_StartTime;
|
||||
uint32 m_EndTime;
|
||||
uint32 m_LastResurrectTime;
|
||||
uint32 m_QueueId;
|
||||
BGQueueIdBasedOnLevel m_QueueId;
|
||||
uint8 m_ArenaType; // 2=2v2, 3=3v3, 5=5v5
|
||||
bool m_InBGFreeSlotQueue; // used to make sure that BG is only once inserted into the BattleGroundMgr.BGFreeSlotQueue[bgTypeId] deque
|
||||
bool m_SetDeleteThis; // used for safe deletion of the bg after end / all players leave
|
||||
|
|
@ -498,15 +519,15 @@ class BattleGround
|
|||
uint32 m_InvitedHorde;
|
||||
|
||||
/* Raid Group */
|
||||
Group *m_BgRaids[2]; // 0 - alliance, 1 - horde
|
||||
Group *m_BgRaids[BG_TEAMS_COUNT]; // 0 - alliance, 1 - horde
|
||||
|
||||
/* Players count by team */
|
||||
uint32 m_PlayersCount[2];
|
||||
uint32 m_PlayersCount[BG_TEAMS_COUNT];
|
||||
|
||||
/* Arena team ids by team */
|
||||
uint32 m_ArenaTeamIds[2];
|
||||
uint32 m_ArenaTeamIds[BG_TEAMS_COUNT];
|
||||
|
||||
int32 m_ArenaTeamRatingChanges[2];
|
||||
int32 m_ArenaTeamRatingChanges[BG_TEAMS_COUNT];
|
||||
|
||||
/* Limits */
|
||||
uint32 m_LevelMin;
|
||||
|
|
@ -518,9 +539,9 @@ class BattleGround
|
|||
|
||||
/* Location */
|
||||
uint32 m_MapId;
|
||||
float m_TeamStartLocX[2];
|
||||
float m_TeamStartLocY[2];
|
||||
float m_TeamStartLocZ[2];
|
||||
float m_TeamStartLocO[2];
|
||||
float m_TeamStartLocX[BG_TEAMS_COUNT];
|
||||
float m_TeamStartLocY[BG_TEAMS_COUNT];
|
||||
float m_TeamStartLocZ[BG_TEAMS_COUNT];
|
||||
float m_TeamStartLocO[BG_TEAMS_COUNT];
|
||||
};
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -78,6 +78,7 @@ void WorldSession::HandleBattleGroundJoinOpcode( WorldPacket & recv_data )
|
|||
uint32 bgTypeId_;
|
||||
uint32 instanceId;
|
||||
uint8 joinAsGroup;
|
||||
bool isPremade = false;
|
||||
Group * grp;
|
||||
|
||||
recv_data >> guid; // battlemaster guid
|
||||
|
|
@ -146,6 +147,7 @@ void WorldSession::HandleBattleGroundJoinOpcode( WorldPacket & recv_data )
|
|||
if(!grp)
|
||||
return;
|
||||
uint32 err = grp->CanJoinBattleGroundQueue(bgTypeId, bgQueueTypeId, 0, bg->GetMaxPlayersPerTeam(), false, 0);
|
||||
isPremade = (grp->GetMembersCount() >= bg->GetMinPlayersPerTeam());
|
||||
if (err != BG_JOIN_ERR_OK)
|
||||
{
|
||||
SendBattleGroundOrArenaJoinError(err);
|
||||
|
|
@ -158,7 +160,7 @@ void WorldSession::HandleBattleGroundJoinOpcode( WorldPacket & recv_data )
|
|||
if(joinAsGroup /* && _player->GetGroup()*/)
|
||||
{
|
||||
sLog.outDebug("Battleground: the following players are joining as group:");
|
||||
GroupQueueInfo * ginfo = sBattleGroundMgr.m_BattleGroundQueues[bgQueueTypeId].AddGroup(_player, bgTypeId, 0, false, 0);
|
||||
GroupQueueInfo * ginfo = sBattleGroundMgr.m_BattleGroundQueues[bgQueueTypeId].AddGroup(_player, bgTypeId, 0, false, isPremade, 0);
|
||||
for(GroupReference *itr = grp->GetFirstMember(); itr != NULL; itr = itr->next())
|
||||
{
|
||||
Player *member = itr->getSource();
|
||||
|
|
@ -195,7 +197,7 @@ void WorldSession::HandleBattleGroundJoinOpcode( WorldPacket & recv_data )
|
|||
sBattleGroundMgr.BuildBattleGroundStatusPacket(&data, bg, _player->GetTeam(), queueSlot, STATUS_WAIT_QUEUE, 0, 0);
|
||||
SendPacket(&data);
|
||||
|
||||
GroupQueueInfo * ginfo = sBattleGroundMgr.m_BattleGroundQueues[bgQueueTypeId].AddGroup(_player, bgTypeId, 0, false, 0);
|
||||
GroupQueueInfo * ginfo = sBattleGroundMgr.m_BattleGroundQueues[bgQueueTypeId].AddGroup(_player, bgTypeId, 0, false, false, 0);
|
||||
sBattleGroundMgr.m_BattleGroundQueues[bgQueueTypeId].AddPlayer(_player, ginfo);
|
||||
sBattleGroundMgr.m_BattleGroundQueues[bgQueueTypeId].Update(bgTypeId, _player->GetBattleGroundQueueIdFromLevel(bgTypeId));
|
||||
if(!ginfo->IsInvitedToBGInstanceGUID)
|
||||
|
|
@ -316,8 +318,7 @@ void WorldSession::HandleBattleGroundPlayerPortOpcode( WorldPacket &recv_data )
|
|||
if(!bgQueueTypeId)
|
||||
continue;
|
||||
BattleGroundTypeId bgTypeId = BattleGroundMgr::BGTemplateId(bgQueueTypeId);
|
||||
uint32 queue_id = _player->GetBattleGroundQueueIdFromLevel(bgTypeId);
|
||||
BattleGroundQueue::QueuedPlayersMap& qpMap = sBattleGroundMgr.m_BattleGroundQueues[bgQueueTypeId].m_QueuedPlayers[queue_id];
|
||||
BattleGroundQueue::QueuedPlayersMap& qpMap = sBattleGroundMgr.m_BattleGroundQueues[bgQueueTypeId].m_QueuedPlayers;
|
||||
BattleGroundQueue::QueuedPlayersMap::iterator itrPlayerStatus = qpMap.find(_player->GetGUID());
|
||||
// if the player is not in queue, continue
|
||||
if(itrPlayerStatus == qpMap.end())
|
||||
|
|
@ -370,7 +371,7 @@ void WorldSession::HandleBattleGroundPlayerPortOpcode( WorldPacket &recv_data )
|
|||
BattleGroundQueueTypeId bgQueueTypeId = BATTLEGROUND_QUEUE_NONE;
|
||||
// get the bg what we were invited to
|
||||
bgQueueTypeId = BattleGroundMgr::BGQueueTypeId(bgTypeId,type);
|
||||
BattleGroundQueue::QueuedPlayersMap& qpMap = sBattleGroundMgr.m_BattleGroundQueues[bgQueueTypeId].m_QueuedPlayers[_player->GetBattleGroundQueueIdFromLevel(bgTypeId)];
|
||||
BattleGroundQueue::QueuedPlayersMap& qpMap = sBattleGroundMgr.m_BattleGroundQueues[bgQueueTypeId].m_QueuedPlayers;
|
||||
BattleGroundQueue::QueuedPlayersMap::iterator itrPlayerStatus = qpMap.find(_player->GetGUID());
|
||||
if(itrPlayerStatus == qpMap.end())
|
||||
{
|
||||
|
|
@ -410,7 +411,7 @@ void WorldSession::HandleBattleGroundPlayerPortOpcode( WorldPacket &recv_data )
|
|||
uint32 opponentsRating = 0;
|
||||
// get the team info from the queue
|
||||
|
||||
BattleGroundQueue::QueuedPlayersMap& qpMap2 = sBattleGroundMgr.m_BattleGroundQueues[bgQueueTypeId].m_QueuedPlayers[_player->GetBattleGroundQueueIdFromLevel(bgTypeId)];
|
||||
BattleGroundQueue::QueuedPlayersMap& qpMap2 = sBattleGroundMgr.m_BattleGroundQueues[bgQueueTypeId].m_QueuedPlayers;
|
||||
BattleGroundQueue::QueuedPlayersMap::iterator pitr = qpMap2.find(_player->GetGUID());
|
||||
if (pitr !=qpMap2.end() && pitr->second.GroupInfo)
|
||||
{
|
||||
|
|
@ -546,8 +547,7 @@ void WorldSession::HandleBattlefieldStatusOpcode( WorldPacket & /*recv_data*/ )
|
|||
BattleGroundTypeId bgTypeId = BattleGroundMgr::BGTemplateId(bgQueueTypeId);
|
||||
uint8 arenatype = BattleGroundMgr::BGArenaType(bgQueueTypeId);
|
||||
uint8 isRated = 0;
|
||||
uint32 queue_id = _player->GetBattleGroundQueueIdFromLevel(bgTypeId);
|
||||
BattleGroundQueue::QueuedPlayersMap& qpMap = sBattleGroundMgr.m_BattleGroundQueues[bgQueueTypeId].m_QueuedPlayers[queue_id];
|
||||
BattleGroundQueue::QueuedPlayersMap& qpMap = sBattleGroundMgr.m_BattleGroundQueues[bgQueueTypeId].m_QueuedPlayers;
|
||||
BattleGroundQueue::QueuedPlayersMap::iterator itrPlayerStatus = qpMap.find(_player->GetGUID());
|
||||
if(itrPlayerStatus == qpMap.end())
|
||||
continue;
|
||||
|
|
@ -578,9 +578,8 @@ void WorldSession::HandleBattlefieldStatusOpcode( WorldPacket & /*recv_data*/ )
|
|||
BattleGroundTypeId bgTypeId = BattleGroundMgr::BGTemplateId(bgQueueTypeId);
|
||||
uint8 arenatype = BattleGroundMgr::BGArenaType(bgQueueTypeId);
|
||||
uint8 isRated = 0;
|
||||
uint32 queue_id = _player->GetBattleGroundQueueIdFromLevel(bgTypeId);
|
||||
BattleGround *bg = sBattleGroundMgr.GetBattleGroundTemplate(bgTypeId);
|
||||
BattleGroundQueue::QueuedPlayersMap& qpMap = sBattleGroundMgr.m_BattleGroundQueues[bgQueueTypeId].m_QueuedPlayers[queue_id];
|
||||
BattleGroundQueue::QueuedPlayersMap& qpMap = sBattleGroundMgr.m_BattleGroundQueues[bgQueueTypeId].m_QueuedPlayers;
|
||||
BattleGroundQueue::QueuedPlayersMap::iterator itrPlayerStatus = qpMap.find(_player->GetGUID());
|
||||
if(itrPlayerStatus == qpMap.end())
|
||||
continue;
|
||||
|
|
@ -768,7 +767,7 @@ void WorldSession::HandleBattleGroundArenaJoin( WorldPacket & recv_data )
|
|||
|
||||
if(asGroup)
|
||||
{
|
||||
GroupQueueInfo * ginfo = sBattleGroundMgr.m_BattleGroundQueues[bgQueueTypeId].AddGroup(_player, bgTypeId, arenatype, isRated, arenaRating, ateamId);
|
||||
GroupQueueInfo * ginfo = sBattleGroundMgr.m_BattleGroundQueues[bgQueueTypeId].AddGroup(_player, bgTypeId, arenatype, isRated, false, arenaRating, ateamId);
|
||||
sLog.outDebug("Battleground: arena join as group start");
|
||||
if(isRated)
|
||||
sLog.outDebug("Battleground: arena team id %u, leader %s queued with rating %u for type %u",_player->GetArenaTeamId(arenaslot),_player->GetName(),arenaRating,arenatype);
|
||||
|
|
@ -807,7 +806,7 @@ void WorldSession::HandleBattleGroundArenaJoin( WorldPacket & recv_data )
|
|||
// send status packet (in queue)
|
||||
sBattleGroundMgr.BuildBattleGroundStatusPacket(&data, bg, _player->GetTeam(), queueSlot, STATUS_WAIT_QUEUE, 0, 0, arenatype, isRated);
|
||||
SendPacket(&data);
|
||||
GroupQueueInfo * ginfo = sBattleGroundMgr.m_BattleGroundQueues[bgQueueTypeId].AddGroup(_player, bgTypeId, arenatype, isRated, arenaRating);
|
||||
GroupQueueInfo * ginfo = sBattleGroundMgr.m_BattleGroundQueues[bgQueueTypeId].AddGroup(_player, bgTypeId, arenatype, isRated, false, arenaRating);
|
||||
sBattleGroundMgr.m_BattleGroundQueues[bgQueueTypeId].AddPlayer(_player, ginfo);
|
||||
sBattleGroundMgr.m_BattleGroundQueues[bgQueueTypeId].Update(bgTypeId, _player->GetBattleGroundQueueIdFromLevel(bgTypeId), arenatype, isRated, arenaRating);
|
||||
sLog.outDebug("Battleground: player joined queue for arena, skirmish, bg queue type %u bg type %u: GUID %u, NAME %s",bgQueueTypeId,bgTypeId,_player->GetGUIDLow(), _player->GetName());
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
|
|
@ -25,15 +25,11 @@
|
|||
//TODO it is not possible to have this structure, because we should have BattlegroundSet for each queue
|
||||
//so i propose to change this type to array 1..MAX_BATTLEGROUND_TYPES of sets or maps..
|
||||
typedef std::map<uint32, BattleGround*> BattleGroundSet;
|
||||
//typedef std::map<uint32, BattleGroundQueue*> BattleGroundQueueSet;
|
||||
|
||||
typedef std::deque<BattleGround*> BGFreeSlotQueueType;
|
||||
|
||||
typedef UNORDERED_MAP<uint32, BattleGroundTypeId> BattleMastersMap;
|
||||
|
||||
#define MAX_BATTLEGROUND_QUEUES 8 // for level ranges 10-19, 20-29, 30-39, 40-49, 50-59, 60-69, 70-79, 80+
|
||||
|
||||
#define MAX_BATTLEGROUND_QUEUE_TYPES 9
|
||||
|
||||
#define BATTLEGROUND_ARENA_POINT_DISTRIBUTION_DAY 86400 // seconds in a day
|
||||
|
||||
struct GroupQueueInfo; // type predefinition
|
||||
|
|
@ -59,6 +55,15 @@ struct GroupQueueInfo // stores informatio
|
|||
uint32 OpponentsTeamRating; // for rated arena matches
|
||||
};
|
||||
|
||||
enum BattleGroundQueueGroupTypes
|
||||
{
|
||||
BG_QUEUE_PREMADE_ALLIANCE = 0,
|
||||
BG_QUEUE_PREMADE_HORDE = 1,
|
||||
BG_QUEUE_NORMAL_ALLIANCE = 2,
|
||||
BG_QUEUE_NORMAL_HORDE = 3,
|
||||
BG_QUEUE_GROUP_TYPES_COUNT = 4
|
||||
};
|
||||
|
||||
class BattleGround;
|
||||
class BattleGroundQueue
|
||||
{
|
||||
|
|
@ -66,9 +71,12 @@ class BattleGroundQueue
|
|||
BattleGroundQueue();
|
||||
~BattleGroundQueue();
|
||||
|
||||
void Update(BattleGroundTypeId bgTypeId, uint32 queue_id, uint8 arenatype = 0, bool isRated = false, uint32 minRating = 0);
|
||||
void Update(BattleGroundTypeId bgTypeId, BGQueueIdBasedOnLevel queue_id, uint8 arenaType = 0, bool isRated = false, uint32 minRating = 0);
|
||||
|
||||
GroupQueueInfo * AddGroup(Player * leader, BattleGroundTypeId bgTypeId, uint8 ArenaType, bool isRated, uint32 ArenaRating, uint32 ArenaTeamId = 0);
|
||||
void FillPlayersToBG(BattleGround* bg, BGQueueIdBasedOnLevel queue_id);
|
||||
bool CheckPremadeMatch(BGQueueIdBasedOnLevel queue_id, uint32 MaxPlayersPerTeam, uint32 MinPlayersPerTeam);
|
||||
bool CheckNormalMatch(BattleGround* bg_template, BGQueueIdBasedOnLevel queue_id, uint32 MinPlayersPerTeam);
|
||||
GroupQueueInfo * AddGroup(Player * leader, BattleGroundTypeId bgTypeId, uint8 ArenaType, bool isRated, bool isPremade, uint32 ArenaRating, uint32 ArenaTeamId = 0);
|
||||
void AddPlayer(Player *plr, GroupQueueInfo *ginfo);
|
||||
void RemovePlayer(const uint64& guid, bool decreaseInvitedCount);
|
||||
void DecreaseGroupLength(uint32 queueId, uint32 AsGroup);
|
||||
|
|
@ -76,52 +84,38 @@ class BattleGroundQueue
|
|||
void AnnounceWorld(GroupQueueInfo *ginfo, const uint64& playerGUID, bool isAddedToQueue);
|
||||
|
||||
typedef std::map<uint64, PlayerQueueInfo> QueuedPlayersMap;
|
||||
QueuedPlayersMap m_QueuedPlayers[MAX_BATTLEGROUND_QUEUES];
|
||||
QueuedPlayersMap m_QueuedPlayers;
|
||||
|
||||
typedef std::list<GroupQueueInfo*> QueuedGroupsList;
|
||||
QueuedGroupsList m_QueuedGroups[MAX_BATTLEGROUND_QUEUES];
|
||||
//we need constant add to begin and constant remove / add from the end, therefore deque suits our problem well
|
||||
typedef std::deque<GroupQueueInfo*> GroupsQueueType;
|
||||
|
||||
// class to hold pointers to the groups eligible for a specific selection pool building mode
|
||||
class EligibleGroups : public std::list<GroupQueueInfo *>
|
||||
{
|
||||
public:
|
||||
void Init(QueuedGroupsList * source, BattleGroundTypeId BgTypeId, uint32 side, uint32 MaxPlayers, uint8 ArenaType = 0, bool IsRated = false, uint32 MinRating = 0, uint32 MaxRating = 0, uint32 DisregardTime = 0, uint32 excludeTeam = 0);
|
||||
void RemoveGroup(GroupQueueInfo * ginfo);
|
||||
};
|
||||
|
||||
EligibleGroups m_EligibleGroups;
|
||||
/*
|
||||
This two dimensional array is used to store All queued groups
|
||||
First dimension specifies the bgTypeId
|
||||
Second dimension specifies the player's group types -
|
||||
BG_QUEUE_PREMADE_ALLIANCE is used for premade alliance groups and alliance rated arena teams
|
||||
BG_QUEUE_PREMADE_HORDE is used for premade horde groups and horde rated arena teams
|
||||
BG_QUEUE_NORMAL_ALLIANCE is used for normal (or small) alliance groups or non-rated arena matches
|
||||
BG_QUEUE_NORMAL_HORDE is used for normal (or small) horde groups or non-rated arena matches
|
||||
*/
|
||||
GroupsQueueType m_QueuedGroups[MAX_BATTLEGROUND_QUEUES][BG_QUEUE_GROUP_TYPES_COUNT];
|
||||
|
||||
// class to select and invite groups to bg
|
||||
class SelectionPool
|
||||
{
|
||||
public:
|
||||
void Init();
|
||||
void AddGroup(GroupQueueInfo * group);
|
||||
GroupQueueInfo * GetMaximalGroup();
|
||||
void RemoveGroup(GroupQueueInfo * group);
|
||||
bool AddGroup(GroupQueueInfo *ginfo, uint32 desiredCount);
|
||||
bool KickGroup(uint32 size);
|
||||
uint32 GetPlayerCount() const {return PlayerCount;}
|
||||
public:
|
||||
std::list<GroupQueueInfo *> SelectedGroups;
|
||||
GroupsQueueType SelectedGroups;
|
||||
private:
|
||||
uint32 PlayerCount;
|
||||
GroupQueueInfo * MaxGroup;
|
||||
};
|
||||
|
||||
enum SelectionPoolBuildMode
|
||||
{
|
||||
NORMAL_ALLIANCE,
|
||||
NORMAL_HORDE,
|
||||
ONESIDE_ALLIANCE_TEAM1,
|
||||
ONESIDE_ALLIANCE_TEAM2,
|
||||
ONESIDE_HORDE_TEAM1,
|
||||
ONESIDE_HORDE_TEAM2,
|
||||
|
||||
NUM_SELECTION_POOL_TYPES
|
||||
};
|
||||
|
||||
SelectionPool m_SelectionPools[NUM_SELECTION_POOL_TYPES];
|
||||
|
||||
bool BuildSelectionPool(BattleGroundTypeId bgTypeId, uint32 queue_id, uint32 MinPlayers, uint32 MaxPlayers, SelectionPoolBuildMode mode, uint8 ArenaType = 0, bool isRated = false, uint32 MinRating = 0, uint32 MaxRating = 0, uint32 DisregardTime = 0, uint32 excludeTeam = 0);
|
||||
//one selection pool for horde, other one for alliance
|
||||
SelectionPool m_SelectionPools[BG_TEAMS_COUNT];
|
||||
|
||||
private:
|
||||
|
||||
|
|
@ -182,8 +176,8 @@ class BattleGroundMgr
|
|||
void BuildPvpLogDataPacket(WorldPacket *data, BattleGround *bg);
|
||||
void BuildBattleGroundStatusPacket(WorldPacket *data, BattleGround *bg, uint32 team, uint8 QueueSlot, uint8 StatusID, uint32 Time1, uint32 Time2, uint32 arenatype = 0, uint8 israted = 0);
|
||||
void BuildPlaySoundPacket(WorldPacket *data, uint32 soundid);
|
||||
|
||||
void SendAreaSpiritHealerQueryOpcode(Player *pl, BattleGround *bg, const uint64& guid);
|
||||
|
||||
/* Player invitation */
|
||||
// called from Queue update, or from Addplayer to queue
|
||||
void InvitePlayer(Player* plr, uint32 bgInstanceGUID, uint32 team);
|
||||
|
|
@ -199,7 +193,7 @@ class BattleGroundMgr
|
|||
};
|
||||
|
||||
BattleGround * GetBattleGroundTemplate(BattleGroundTypeId bgTypeId);
|
||||
BattleGround * CreateNewBattleGround(BattleGroundTypeId bgTypeId);
|
||||
BattleGround * CreateNewBattleGround(BattleGroundTypeId bgTypeId, BGQueueIdBasedOnLevel queue_id, uint8 arenaType, bool isRated);
|
||||
|
||||
uint32 CreateBattleGround(BattleGroundTypeId bgTypeId, bool IsArena, uint32 MinPlayersPerTeam, uint32 MaxPlayersPerTeam, uint32 LevelMin, uint32 LevelMax, char* BattleGroundName, uint32 MapID, float Team1StartLocX, float Team1StartLocY, float Team1StartLocZ, float Team1StartLocO, float Team2StartLocX, float Team2StartLocY, float Team2StartLocZ, float Team2StartLocO);
|
||||
|
||||
|
|
|
|||
|
|
@ -1344,7 +1344,7 @@ uint32 Group::CanJoinBattleGroundQueue(BattleGroundTypeId bgTypeId, BattleGround
|
|||
if(!reference)
|
||||
return BG_JOIN_ERR_OFFLINE_MEMBER;
|
||||
|
||||
uint32 queue_id = reference->GetBattleGroundQueueIdFromLevel(bgTypeId);
|
||||
BGQueueIdBasedOnLevel queue_id = reference->GetBattleGroundQueueIdFromLevel(bgTypeId);
|
||||
uint32 arenaTeamId = reference->GetArenaTeamId(arenaSlot);
|
||||
uint32 team = reference->GetTeam();
|
||||
|
||||
|
|
|
|||
|
|
@ -18475,34 +18475,20 @@ bool Player::GetBGAccessByLevel(BattleGroundTypeId bgTypeId) const
|
|||
return true;
|
||||
}
|
||||
|
||||
uint32 Player::GetMinLevelForBattleGroundQueueId(uint32 queue_id, BattleGroundTypeId bgTypeId)
|
||||
BGQueueIdBasedOnLevel Player::GetBattleGroundQueueIdFromLevel(BattleGroundTypeId bgTypeId) const
|
||||
{
|
||||
BattleGround *bg = sBattleGroundMgr.GetBattleGroundTemplate(bgTypeId);
|
||||
assert(bg);
|
||||
return (queue_id*10)+bg->GetMinLevel();
|
||||
}
|
||||
//returned to hardcoded version of this function, because there is no way to code it dynamic
|
||||
uint32 level = getLevel();
|
||||
if( bgTypeId == BATTLEGROUND_QUEUE_AV )
|
||||
level--;
|
||||
|
||||
uint32 Player::GetMaxLevelForBattleGroundQueueId(uint32 queue_id, BattleGroundTypeId bgTypeId)
|
||||
uint32 queue_id = (level / 10) - 1; // for ranges 0 - 19, 20 - 29, 30 - 39, 40 - 49, 50 - 59, 60 - 69, 70 -79, 80
|
||||
if( queue_id >= MAX_BATTLEGROUND_QUEUES )
|
||||
{
|
||||
return GetMinLevelForBattleGroundQueueId(queue_id, bgTypeId)+10;
|
||||
sLog.outError("BattleGround: too high queue_id %u this shouldn't happen", queue_id);
|
||||
return QUEUE_ID_MAX_LEVEL_80;
|
||||
}
|
||||
|
||||
uint32 Player::GetBattleGroundQueueIdFromLevel(BattleGroundTypeId bgTypeId) const
|
||||
{
|
||||
BattleGround *bg = sBattleGroundMgr.GetBattleGroundTemplate(bgTypeId);
|
||||
assert(bg);
|
||||
if(getLevel()<bg->GetMinLevel())
|
||||
{
|
||||
sLog.outError("getting queue_id for player who doesn't meet the requirements - this shouldn't happen");
|
||||
return 0;
|
||||
}
|
||||
uint32 queue_id = (getLevel() - bg->GetMinLevel()) / 10;
|
||||
if(queue_id>MAX_BATTLEGROUND_QUEUES)
|
||||
{
|
||||
sLog.outError("to high queue_id %u this shouldn't happen",queue_id);
|
||||
return 0;
|
||||
}
|
||||
return queue_id;
|
||||
return BGQueueIdBasedOnLevel(queue_id);
|
||||
}
|
||||
|
||||
float Player::GetReputationPriceDiscount( Creature const* pCreature ) const
|
||||
|
|
|
|||
|
|
@ -1866,13 +1866,12 @@ class MANGOS_DLL_SPEC Player : public Unit
|
|||
/*********************************************************/
|
||||
|
||||
bool InBattleGround() const { return m_bgBattleGroundID != 0; }
|
||||
bool InArena() const;
|
||||
uint32 GetBattleGroundId() const { return m_bgBattleGroundID; }
|
||||
BattleGround* GetBattleGround() const;
|
||||
bool InArena() const;
|
||||
|
||||
static uint32 GetMinLevelForBattleGroundQueueId(uint32 queue_id, BattleGroundTypeId bgTypeId);
|
||||
static uint32 GetMaxLevelForBattleGroundQueueId(uint32 queue_id, BattleGroundTypeId bgTypeId);
|
||||
uint32 GetBattleGroundQueueIdFromLevel(BattleGroundTypeId bgTypeId) const;
|
||||
|
||||
BGQueueIdBasedOnLevel GetBattleGroundQueueIdFromLevel(BattleGroundTypeId bgTypeId) const;
|
||||
|
||||
bool InBattleGroundQueue() const
|
||||
{
|
||||
|
|
|
|||
|
|
@ -762,13 +762,6 @@ void World::LoadConfigSettings(bool reload)
|
|||
m_configs[CONFIG_INSTANCE_IGNORE_LEVEL] = sConfig.GetBoolDefault("Instance.IgnoreLevel", false);
|
||||
m_configs[CONFIG_INSTANCE_IGNORE_RAID] = sConfig.GetBoolDefault("Instance.IgnoreRaid", false);
|
||||
|
||||
m_configs[CONFIG_BATTLEGROUND_CAST_DESERTER] = sConfig.GetBoolDefault("Battleground.CastDeserter", true);
|
||||
m_configs[CONFIG_BATTLEGROUND_QUEUE_ANNOUNCER_ENABLE] = sConfig.GetBoolDefault("Battleground.QueueAnnouncer.Enable", false);
|
||||
m_configs[CONFIG_BATTLEGROUND_QUEUE_ANNOUNCER_PLAYERONLY] = sConfig.GetBoolDefault("Battleground.QueueAnnouncer.PlayerOnly", false);
|
||||
m_configs[CONFIG_ARENA_QUEUE_ANNOUNCER_ENABLE] = sConfig.GetBoolDefault("Arena.QueueAnnouncer.Enable", false);
|
||||
m_configs[CONFIG_ARENA_SEASON_ID] = sConfig.GetIntDefault ("Arena.ArenaSeason.ID", 1);
|
||||
m_configs[CONFIG_ARENA_SEASON_IN_PROGRESS] = sConfig.GetBoolDefault("Arena.ArenaSeason.InProgress", true);
|
||||
|
||||
m_configs[CONFIG_CAST_UNSTUCK] = sConfig.GetBoolDefault("CastUnstuck", true);
|
||||
m_configs[CONFIG_INSTANCE_RESET_TIME_HOUR] = sConfig.GetIntDefault("Instance.ResetTimeHour", 4);
|
||||
m_configs[CONFIG_INSTANCE_UNLOAD_DELAY] = sConfig.GetIntDefault("Instance.UnloadDelay", 1800000);
|
||||
|
|
@ -933,12 +926,20 @@ void World::LoadConfigSettings(bool reload)
|
|||
m_configs[CONFIG_LISTEN_RANGE_TEXTEMOTE] = sConfig.GetIntDefault("ListenRange.TextEmote", 25);
|
||||
m_configs[CONFIG_LISTEN_RANGE_YELL] = sConfig.GetIntDefault("ListenRange.Yell", 300);
|
||||
|
||||
m_configs[CONFIG_ARENA_MAX_RATING_DIFFERENCE] = sConfig.GetIntDefault("Arena.MaxRatingDifference", 0);
|
||||
m_configs[CONFIG_ARENA_RATING_DISCARD_TIMER] = sConfig.GetIntDefault("Arena.RatingDiscardTimer",300000);
|
||||
m_configs[CONFIG_BATTLEGROUND_CAST_DESERTER] = sConfig.GetBoolDefault("Battleground.CastDeserter", true);
|
||||
m_configs[CONFIG_BATTLEGROUND_QUEUE_ANNOUNCER_ENABLE] = sConfig.GetBoolDefault("Battleground.QueueAnnouncer.Enable", false);
|
||||
m_configs[CONFIG_BATTLEGROUND_QUEUE_ANNOUNCER_PLAYERONLY] = sConfig.GetBoolDefault("Battleground.QueueAnnouncer.PlayerOnly", false);
|
||||
m_configs[CONFIG_BATTLEGROUND_INVITATION_TYPE] = sConfig.GetIntDefault ("Battleground.InvitationType", 0);
|
||||
m_configs[CONFIG_BATTLEGROUND_PREMATURE_FINISH_TIMER] = sConfig.GetIntDefault ("BattleGround.PrematureFinishTimer", 5 * MINUTE * IN_MILISECONDS);
|
||||
m_configs[CONFIG_BATTLEGROUND_PREMADE_GROUP_WAIT_FOR_MATCH] = sConfig.GetIntDefault ("BattleGround.PremadeGroupWaitForMatch", 30 * MINUTE * IN_MILISECONDS);
|
||||
m_configs[CONFIG_ARENA_MAX_RATING_DIFFERENCE] = sConfig.GetIntDefault ("Arena.MaxRatingDifference", 100);
|
||||
m_configs[CONFIG_ARENA_RATING_DISCARD_TIMER] = sConfig.GetIntDefault ("Arena.RatingDiscardTimer", 10 * MINUTE * IN_MILISECONDS);
|
||||
m_configs[CONFIG_ARENA_AUTO_DISTRIBUTE_POINTS] = sConfig.GetBoolDefault("Arena.AutoDistributePoints", false);
|
||||
m_configs[CONFIG_ARENA_AUTO_DISTRIBUTE_INTERVAL_DAYS] = sConfig.GetIntDefault ("Arena.AutoDistributeInterval", 7);
|
||||
m_configs[CONFIG_ARENA_QUEUE_ANNOUNCER_ENABLE] = sConfig.GetBoolDefault("Arena.QueueAnnouncer.Enable", false);
|
||||
m_configs[CONFIG_ARENA_SEASON_ID] = sConfig.GetIntDefault ("Arena.ArenaSeason.ID", 1);
|
||||
m_configs[CONFIG_ARENA_SEASON_IN_PROGRESS] = sConfig.GetBoolDefault("Arena.ArenaSeason.InProgress", true);
|
||||
|
||||
m_configs[CONFIG_BATTLEGROUND_PREMATURE_FINISH_TIMER] = sConfig.GetIntDefault("BattleGround.PrematureFinishTimer", 0);
|
||||
m_configs[CONFIG_INSTANT_LOGOUT] = sConfig.GetIntDefault("InstantLogout", SEC_MODERATOR);
|
||||
|
||||
m_VisibleUnitGreyDistance = sConfig.GetFloatDefault("Visibility.Distance.Grey.Unit", 1);
|
||||
|
|
|
|||
|
|
@ -113,9 +113,6 @@ enum WorldConfigs
|
|||
CONFIG_START_ARENA_POINTS,
|
||||
CONFIG_INSTANCE_IGNORE_LEVEL,
|
||||
CONFIG_INSTANCE_IGNORE_RAID,
|
||||
CONFIG_BATTLEGROUND_CAST_DESERTER,
|
||||
CONFIG_BATTLEGROUND_QUEUE_ANNOUNCER_ENABLE,
|
||||
CONFIG_BATTLEGROUND_QUEUE_ANNOUNCER_PLAYERONLY,
|
||||
CONFIG_INSTANCE_RESET_TIME_HOUR,
|
||||
CONFIG_INSTANCE_UNLOAD_DELAY,
|
||||
CONFIG_CAST_UNSTUCK,
|
||||
|
|
@ -184,6 +181,13 @@ enum WorldConfigs
|
|||
CONFIG_LISTEN_RANGE_SAY,
|
||||
CONFIG_LISTEN_RANGE_TEXTEMOTE,
|
||||
CONFIG_LISTEN_RANGE_YELL,
|
||||
CONFIG_SKILL_MILLING,
|
||||
CONFIG_BATTLEGROUND_CAST_DESERTER,
|
||||
CONFIG_BATTLEGROUND_QUEUE_ANNOUNCER_ENABLE,
|
||||
CONFIG_BATTLEGROUND_QUEUE_ANNOUNCER_PLAYERONLY,
|
||||
CONFIG_BATTLEGROUND_INVITATION_TYPE,
|
||||
CONFIG_BATTLEGROUND_PREMATURE_FINISH_TIMER,
|
||||
CONFIG_BATTLEGROUND_PREMADE_GROUP_WAIT_FOR_MATCH,
|
||||
CONFIG_ARENA_MAX_RATING_DIFFERENCE,
|
||||
CONFIG_ARENA_RATING_DISCARD_TIMER,
|
||||
CONFIG_ARENA_AUTO_DISTRIBUTE_POINTS,
|
||||
|
|
@ -191,8 +195,6 @@ enum WorldConfigs
|
|||
CONFIG_ARENA_QUEUE_ANNOUNCER_ENABLE,
|
||||
CONFIG_ARENA_SEASON_ID,
|
||||
CONFIG_ARENA_SEASON_IN_PROGRESS,
|
||||
CONFIG_BATTLEGROUND_PREMATURE_FINISH_TIMER,
|
||||
CONFIG_SKILL_MILLING,
|
||||
CONFIG_VALUE_COUNT
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -483,25 +483,6 @@ LogColors = ""
|
|||
# Default: 1 (true)
|
||||
# 0 (false)
|
||||
#
|
||||
# Battleground.CastDeserter
|
||||
# Cast or not Deserter spell at player who leave battleground in progress
|
||||
# Default: 1 (true)
|
||||
# 0 (false)
|
||||
#
|
||||
# Battleground.QueueAnnouncer.Enable
|
||||
# Enable queue announcer posting to chat
|
||||
# Default: 0 (false)
|
||||
# 1 (true)
|
||||
#
|
||||
# Battleground.QueueAnnouncer.PlayerOnly
|
||||
# Enable queue announcer posting to chat
|
||||
# Default: 0 (false)
|
||||
# 1 (true)
|
||||
#
|
||||
# Arena.QueueAnnouncer.Enable: Enable queue announcer posting to chat
|
||||
# Default: 0 (false)
|
||||
# 1 (true)
|
||||
#
|
||||
# CastUnstuck
|
||||
# Allow cast or not Unstuck spell at .start or client Help option use
|
||||
# Default: 1 (true)
|
||||
|
|
@ -606,10 +587,6 @@ DisableWaterBreath = 4
|
|||
AllFlightPaths = 0
|
||||
AlwaysMaxSkillForLevel = 0
|
||||
ActivateWeather = 1
|
||||
Battleground.CastDeserter = 1
|
||||
Battleground.QueueAnnouncer.Enable = 0
|
||||
Battleground.QueueAnnouncer.PlayerOnly = 0
|
||||
Arena.QueueAnnouncer.Enable = 0
|
||||
CastUnstuck = 1
|
||||
Instance.IgnoreLevel = 0
|
||||
Instance.IgnoreRaid = 0
|
||||
|
|
@ -1128,59 +1105,101 @@ Death.CorpseReclaimDelay.PvE = 1
|
|||
Death.Bones.World = 1
|
||||
Death.Bones.BattlegroundOrArena = 1
|
||||
|
||||
|
||||
###################################################################################################################
|
||||
# BATTLEGROUND CONFIG
|
||||
#
|
||||
# Rated arena matches config
|
||||
# Battleground.CastDeserter
|
||||
# Cast or not Deserter spell at player who leave battleground in progress
|
||||
# Default: 1 (true)
|
||||
# 0 (false)
|
||||
#
|
||||
# MaxRatingDifference: the maximum rating difference between two groups in rated matches
|
||||
# Default: 0 (disable, rating difference is discarded)
|
||||
# Battleground.QueueAnnouncer.Enable
|
||||
# Enable queue announcer posting to chat
|
||||
# Default: 0 (false)
|
||||
# 1 (true)
|
||||
#
|
||||
# RatingDiscardTimer: after the specified milliseconds has passed,
|
||||
# Battleground.QueueAnnouncer.PlayerOnly
|
||||
# Enable queue announcer posting to chat
|
||||
# Default: 0 (false)
|
||||
# 1 (true)
|
||||
#
|
||||
# Battleground.InvitationType
|
||||
# Set Battleground invitation type
|
||||
# Default: 0 (normal - invite as much players to bg as possible, don't bother with ballance)
|
||||
# 1 (Experimental - don't allow to invite much more players of one faction)
|
||||
#
|
||||
# Battleground.PrematureFinishTimer
|
||||
# The time to end the bg if there are less than MinPlayersPerTeam on one side in milliseconds
|
||||
# Default: 300000 (5 minutes)
|
||||
# 0 - disable (not recommended)
|
||||
#
|
||||
# BattleGround.PremadeGroupWaitForMatch
|
||||
# The time in which premade group of 1 faction waits in BG Queue for premade group of other faction
|
||||
# Default: 1800000 (30 minutes)
|
||||
# 0 - disable (not recommended)
|
||||
#
|
||||
###################################################################################################################
|
||||
|
||||
Battleground.CastDeserter = 1
|
||||
Battleground.QueueAnnouncer.Enable = 0
|
||||
Battleground.QueueAnnouncer.PlayerOnly = 0
|
||||
Battleground.InvitationType = 0
|
||||
BattleGround.PrematureFinishTimer = 300000
|
||||
BattleGround.PremadeGroupWaitForMatch = 1800000
|
||||
|
||||
|
||||
###################################################################################################################
|
||||
# ARENA CONFIG
|
||||
#
|
||||
# Arena.MaxRatingDifference
|
||||
# The maximum rating difference between two groups in rated matches
|
||||
# Default: 100 (enable, recommended)
|
||||
# 0 (disable, rating difference is discarded)
|
||||
#
|
||||
# Arena.RatingDiscardTimer
|
||||
# After the specified milliseconds has passed,
|
||||
# rating information will be discarded when selecting teams for matches
|
||||
# also initiates an update by this timer
|
||||
# Default: 60000
|
||||
# Default: 600000 (10 minutes, recommended)
|
||||
# 0 (disable, DO NOT USE - it will cause lags)
|
||||
#
|
||||
# AutoDistributePoints: set if arena points should be distributed automatically, or by GM command
|
||||
# Arena.AutoDistributePoints
|
||||
# Set if arena points should be distributed automatically, or by GM command
|
||||
# Default: 0 (disable) (recommended): use gm command or sql query to distribute the points
|
||||
# 1 (enable): arena points are distributed automatically
|
||||
# 1 (enable) arena points are distributed automatically
|
||||
#
|
||||
# AutoDistributeInterval: how often should the distribution take place
|
||||
# if automatic distribution is enabled
|
||||
# in days
|
||||
# Arena.AutoDistributeInterval
|
||||
# How often should the distribution take place
|
||||
# If automatic distribution is enabled in days
|
||||
# Default: 7 (weekly)
|
||||
#
|
||||
# ArenaSeason.ID: current area season id show in client
|
||||
# Arena.QueueAnnouncer.Enable
|
||||
# Enable bg queue announcer posting to chat
|
||||
# Default: 0 (false)
|
||||
# 1 (true)
|
||||
#
|
||||
# Arena.ArenaSeason.ID
|
||||
# Current area season id show in client
|
||||
# Default: 1
|
||||
#
|
||||
# ArenaSeason.InProgress: current area season state
|
||||
# Arena.ArenaSeason.InProgress
|
||||
# Current area season state
|
||||
# Default: 1 (active)
|
||||
# 0 (finished)
|
||||
#
|
||||
###################################################################################################################
|
||||
|
||||
Arena.MaxRatingDifference = 0
|
||||
Arena.RatingDiscardTimer = 60000
|
||||
Arena.MaxRatingDifference = 100
|
||||
Arena.RatingDiscardTimer = 600000
|
||||
Arena.AutoDistributePoints = 0
|
||||
Arena.AutoDistributeInterval = 7
|
||||
Arena.QueueAnnouncer.Enable = 0
|
||||
Arena.ArenaSeason.ID = 1
|
||||
Arena.ArenaSeason.InProgress = 1
|
||||
|
||||
###################################################################################################################
|
||||
#
|
||||
# Battleground config
|
||||
#
|
||||
# PrematureFinishTimer: the time to end the bg if there are less than minplayersperteam on one side
|
||||
# in milliseconds
|
||||
# Default: 300000
|
||||
# 0 - disable
|
||||
#
|
||||
###################################################################################################################
|
||||
|
||||
BattleGround.PrematureFinishTimer = 300000
|
||||
|
||||
|
||||
###################################################################################################################
|
||||
#
|
||||
# NETWORK CONFIG
|
||||
#
|
||||
# Network.Threads
|
||||
|
|
|
|||
|
|
@ -157,7 +157,8 @@ enum TimeConstants
|
|||
MINUTE = 60,
|
||||
HOUR = MINUTE*60,
|
||||
DAY = HOUR*24,
|
||||
MONTH = DAY*30
|
||||
MONTH = DAY*30,
|
||||
IN_MILISECONDS = 1000
|
||||
};
|
||||
|
||||
enum AccountTypes
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
#ifndef __REVISION_NR_H__
|
||||
#define __REVISION_NR_H__
|
||||
#define REVISION_NR "7335"
|
||||
#define REVISION_NR "7336"
|
||||
#endif // __REVISION_NR_H__
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue