public static void SendPvpData(IPacketReceiver reciever, BattlegroundSide side, Battleground bg)
{
bg.EnsureContext();
using (var packet = new RealmPacketOut(RealmServerOpCode.MSG_PVP_LOG_DATA, 10 + bg.PlayerCount * 40))
{
var winner = bg.Winner;
packet.Write(bg.IsArena);
if (bg.IsArena)
{
// TODO: Arena
for (var i = 0; i < 2; i++)
{
packet.Write(0); // old rating
packet.Write(3999); // new rating (3000 + diff)
packet.Write(0); // matchmaking value (lvl group/rank?)
}
packet.WriteCString(string.Empty); // arena team names
packet.WriteCString(string.Empty);
}
var isFinished = bg.Winner != null;
packet.Write(isFinished);
if (isFinished)
{
packet.Write((byte)bg.Winner.Side);
}
var chrs = bg.Characters;
List <BattlegroundStats> listStats = new List <BattlegroundStats>(chrs.Count);
chrs.ForEach(chr => listStats.Add(chr.Battlegrounds.Stats));
packet.Write(listStats.Count);
for (var i = 0; i < listStats.Count; i++)
{
var chr = chrs[i];
if (!chr.IsInBattleground)
{
continue;
}
var stats = chr.Battlegrounds.Stats;
packet.Write(chr.EntityId); // player guid
packet.Write(stats.KillingBlows);
if (bg.IsArena)
{
packet.Write(winner != null && chr.Battlegrounds.Team == winner); // is on the winning team
}
else
{
packet.Write(stats.HonorableKills);
packet.Write(stats.Deaths);
packet.Write(stats.BonusHonor);
}
packet.Write(stats.TotalDamage);
packet.Write(stats.TotalHealing);
packet.Write(stats.SpecialStatCount);
stats.WriteSpecialStats(packet);
}
reciever.Send(packet);
}
}
public Hero(Battleground battleground)
: base(battleground)
{
}
public void HandlePacket(GameClient client, GSPacketIn packet)
{
ushort jumpSpotId;
jumpSpotId = client.Version >= GameClient.eClientVersion.Version1127 ? packet.ReadShortLowEndian() : packet.ReadShort();
eRealm targetRealm = client.Player.Realm;
if (client.Player.CurrentRegion.Expansion == (int)eClientExpansion.TrialsOfAtlantis && client.Player.CurrentZone.Realm != eRealm.None)
{
// if we are in TrialsOfAtlantis then base the target jump on the current region realm instead of the players realm
// this is only used if zone table has the proper realms defined, otherwise it reverts to old behavior - Tolakram
targetRealm = client.Player.CurrentZone.Realm;
}
var zonePoint = GameServer.Database.SelectObjects <ZonePoint>(
"`Id` = @Id AND (`Realm` = @Realm OR `Realm` = @DefaultRealm OR `Realm` IS NULL)",
new[]
{
new QueryParameter("@Id", jumpSpotId), new QueryParameter("@Realm", (byte)targetRealm),
new QueryParameter("@DefaultRealm", 0)
})
.FirstOrDefault();
if (zonePoint == null || zonePoint.TargetRegion == 0)
{
ChatUtil.SendDebugMessage(client, $"Invalid Jump (ZonePoint table): [{jumpSpotId}]{((zonePoint == null) ? ". Entry missing!" : ". TargetRegion is 0!")}");
zonePoint = new ZonePoint
{
Id = jumpSpotId
};
}
if (client.Account.PrivLevel > 1)
{
client.Out.SendMessage($"JumpSpotID = {jumpSpotId}", eChatType.CT_System, eChatLoc.CL_SystemWindow);
client.Out.SendMessage($"ZonePoint Target: Region = {zonePoint.TargetRegion}, ClassType = \'{zonePoint.ClassType}\'", eChatType.CT_System, eChatLoc.CL_SystemWindow);
}
// Dinberg: Fix - some jump points are handled code side, such as instances.
// As such, region MAY be zero in the database, so this causes an issue.
if (zonePoint.TargetRegion != 0)
{
Region reg = WorldMgr.GetRegion(zonePoint.TargetRegion);
if (reg != null)
{
// check for target region disabled if player is in a standard region
// otherwise the custom region should handle OnZonePoint for this check
if (client.Player.CurrentRegion.IsCustom == false && reg.IsDisabled)
{
if ((client.Player.Mission is TaskDungeonMission mission &&
mission.TaskRegion.Skin == reg.Skin) == false)
{
client.Out.SendMessage("This region has been disabled!", eChatType.CT_System, eChatLoc.CL_SystemWindow);
if (client.Account.PrivLevel == 1)
{
return;
}
}
}
}
}
// Allow the region to either deny exit or handle the zonepoint in a custom way
if (client.Player.CurrentRegion.OnZonePoint(client.Player, zonePoint) == false)
{
return;
}
// check caps for battleground
Battleground bg = GameServer.KeepManager.GetBattleground(zonePoint.TargetRegion);
if (client.Player.Level < bg?.MinLevel && client.Player.Level > bg.MaxLevel &&
client.Player.RealmLevel >= bg.MaxRealmLevel)
{
return;
}
IJumpPointHandler customHandler = null;
if (string.IsNullOrEmpty(zonePoint.ClassType) == false)
{
customHandler = (IJumpPointHandler)_customJumpPointHandlers[zonePoint.ClassType];
// check for db change to update cached handler
if (customHandler != null && customHandler.GetType().FullName != zonePoint.ClassType)
{
customHandler = null;
}
if (customHandler == null)
{
// Dinberg - Instances need to use a special handler. This is because some instances will result
// in duplicated zonepoints, such as if Tir Na Nog were to be instanced for a quest.
string type = client.Player.CurrentRegion.IsInstance
? "DOL.GS.ServerRules.InstanceDoorJumpPoint"
: zonePoint.ClassType;
Type t = ScriptMgr.GetType(type);
if (t == null)
{
Log.Error($"jump point {zonePoint.Id}: class {zonePoint.ClassType} not found!");
}
else if (!typeof(IJumpPointHandler).IsAssignableFrom(t))
{
Log.Error($"jump point {zonePoint.Id}: class {zonePoint.ClassType} must implement IJumpPointHandler interface!");
}
else
{
try
{
customHandler = (IJumpPointHandler)Activator.CreateInstance(t);
}
catch (Exception e)
{
customHandler = null;
Log.Error($"jump point {zonePoint.Id}: error creating a new instance of jump point handler {zonePoint.ClassType}", e);
}
}
}
if (customHandler != null)
{
_customJumpPointHandlers[zonePoint.ClassType] = customHandler;
}
}
new RegionChangeRequestHandler(client.Player, zonePoint, customHandler).Start(1);
}
public void AddToBGFreeSlotQueue(BattlegroundQueueTypeId bgTypeId, Battleground bg)
{
m_BGFreeSlotQueue.Add(bgTypeId, bg);
}
public void OnCommand(GameClient client, string[] args)
{
uint hour = WorldMgr.GetCurrentGameTime() / 1000 / 60 / 60;
uint minute = WorldMgr.GetCurrentGameTime() / 1000 / 60 % 60;
uint seconde = WorldMgr.GetCurrentGameTime() / 1000 % 60;
string name = "(NoName)";
var info = new List <string>();
info.Add(" Current Region : " + client.Player.CurrentRegionID);
info.Add(" ");
Type regionType = client.Player.CurrentRegion.GetType();
info.Add(" Region ClassType: " + regionType.FullName);
info.Add(" ");
if (client.Player.TargetObject != null)
{
#region Mob
/********************* MOB ************************/
if (client.Player.TargetObject is GameNPC)
{
var target = client.Player.TargetObject as GameNPC;
name = target.Name;
info.Add(" + Class: " + target.GetType().ToString());
info.Add(" + Brain: " + (target.Brain == null ? "(null)" : target.Brain.GetType().ToString()));
if (target.LoadedFromScript)
{
info.Add(" + Loaded: from Script");
}
else
{
info.Add(" + Loaded: from Database");
}
info.Add(" ");
if (client.Player.TargetObject is GameMerchant)
{
var targetM = client.Player.TargetObject as GameMerchant;
info.Add(" + Is Merchant ");
if (targetM.TradeItems != null)
{
info.Add(" + Sell List: \n " + targetM.TradeItems.ItemsListID);
}
else
{
info.Add(" + Sell List: Not Present !\n");
}
info.Add(" ");
}
if (client.Player.TargetObject is GamePet)
{
var targetP = client.Player.TargetObject as GamePet;
info.Add(" + Is Pet ");
info.Add(" + Pet Owner: " + targetP.Owner);
info.Add(" ");
}
if (client.Player.TargetObject is GameMovingObject)
{
var targetM = client.Player.TargetObject as GameMovingObject;
info.Add(" + Is GameMovingObject ");
info.Add(" + ( Boats - Siege weapons - Custom Object");
info.Add(" + Emblem: " + targetM.Emblem);
info.Add(" ");
}
info.Add(" + Name: " + name);
if (target.GuildName != null && target.GuildName.Length > 0)
{
info.Add(" + Guild: " + target.GuildName);
}
info.Add(" + Level: " + target.Level);
info.Add(" + Realm: " + GlobalConstants.RealmToName(target.Realm));
info.Add(" + Model: " + target.Model);
info.Add(" + Size " + target.Size);
info.Add(string.Format(" + Flags: {0} (0x{1})", ((GameNPC.eFlags)target.Flags).ToString("G"), target.Flags.ToString("X")));
info.Add(" ");
info.Add(" + Speed(current/max): " + target.CurrentSpeed + "/" + target.MaxSpeedBase);
info.Add(" + Health: " + target.Health + "/" + target.MaxHealth);
IOldAggressiveBrain aggroBrain = target.Brain as IOldAggressiveBrain;
if (aggroBrain != null)
{
info.Add(" + Aggro level: " + aggroBrain.AggroLevel);
info.Add(" + Aggro range: " + aggroBrain.AggroRange);
if (target.MaxDistance < 0)
{
info.Add(" + MaxDistance: " + -target.MaxDistance * aggroBrain.AggroRange / 100);
}
else
{
info.Add(" + MaxDistance: " + target.MaxDistance);
}
}
else
{
info.Add(" + Not aggressive brain");
}
if (target.NPCTemplate != null)
{
info.Add(" + NPCTemplate: " + "[" + target.NPCTemplate.TemplateId + "] " + target.NPCTemplate.Name);
}
info.Add(" + Roaming Range: " + target.RoamingRange);
TimeSpan respawn = TimeSpan.FromMilliseconds(target.RespawnInterval);
if (target.RespawnInterval <= 0)
{
info.Add(" + Respawn: NPC will not respawn");
}
else
{
string days = "";
string hours = "";
if (respawn.Days > 0)
{
days = respawn.Days + " days ";
}
if (respawn.Hours > 0)
{
hours = respawn.Hours + " hours ";
}
info.Add(" + Respawn: " + days + hours + respawn.Minutes + " minutes " + respawn.Seconds + " seconds");
info.Add(" + SpawnPoint: " + target.SpawnPoint.X + ", " + target.SpawnPoint.Y + ", " + target.SpawnPoint.Z);
}
if (target.QuestListToGive.Count > 0)
{
info.Add(" + Quests to give: " + target.QuestListToGive.Count);
}
if (target.PathID != null && target.PathID.Length > 0)
{
info.Add(" + Path: " + target.PathID);
}
if (target.OwnerID != null && target.OwnerID.Length > 0)
{
info.Add(" + OwnerID: " + target.OwnerID);
}
info.Add(" ");
if (target.Strength > 0)
{
info.Add(" + STR: " + target.Strength);
}
if (target.Constitution > 0)
{
info.Add(" + CON: " + target.Constitution);
}
if (target.Dexterity > 0)
{
info.Add(" + DEX: " + target.Dexterity);
}
if (target.Quickness > 0)
{
info.Add(" + QUI: " + target.Quickness);
}
if (target.Intelligence > 0)
{
info.Add(" + INT: " + target.Intelligence);
}
if (target.Empathy > 0)
{
info.Add(" + EMP: " + target.Empathy);
}
if (target.Piety > 0)
{
info.Add(" + PIE: " + target.Piety);
}
if (target.Charisma > 0)
{
info.Add(" + CHR: " + target.Charisma);
}
if (target.BlockChance > 0)
{
info.Add(" + Block: " + target.BlockChance);
}
if (target.ParryChance > 0)
{
info.Add(" + Parry: " + target.ParryChance);
}
if (target.EvadeChance > 0)
{
info.Add(" + Evade %: " + target.EvadeChance);
}
info.Add(" + Damage type: " + target.MeleeDamageType);
if (target.LeftHandSwingChance > 0)
{
info.Add(" + Left Swing %: " + target.LeftHandSwingChance);
}
if (target.Abilities != null && target.Abilities.Count > 0)
{
info.Add(" + Abilities: " + target.Abilities.Count);
}
if (target.Spells != null && target.Spells.Count > 0)
{
info.Add(" + Spells: " + target.Spells.Count);
}
if (target.Styles != null && target.Styles.Count > 0)
{
info.Add(" + Styles: " + target.Styles.Count);
}
info.Add(" ");
if (target.Race > 0)
{
info.Add(" + Race: " + target.Race);
}
if (target.BodyType > 0)
{
info.Add(" + Body Type: " + target.BodyType);
}
if (target.GetDamageResist(eProperty.Resist_Crush) > 0)
{
info.Add(" + Resist Crush: " + target.GetDamageResist(eProperty.Resist_Crush));
}
if (target.GetDamageResist(eProperty.Resist_Slash) > 0)
{
info.Add(" + Resist Slash: " + target.GetDamageResist(eProperty.Resist_Slash));
}
if (target.GetDamageResist(eProperty.Resist_Thrust) > 0)
{
info.Add(" + Resist Thrust: " + target.GetDamageResist(eProperty.Resist_Thrust));
}
if (target.GetDamageResist(eProperty.Resist_Heat) > 0)
{
info.Add(" + Resist Heat: " + target.GetDamageResist(eProperty.Resist_Heat));
}
if (target.GetDamageResist(eProperty.Resist_Cold) > 0)
{
info.Add(" + Resist Cold: " + target.GetDamageResist(eProperty.Resist_Cold));
}
if (target.GetDamageResist(eProperty.Resist_Matter) > 0)
{
info.Add(" + Resist Matter: " + target.GetDamageResist(eProperty.Resist_Matter));
}
if (target.GetDamageResist(eProperty.Resist_Natural) > 0)
{
info.Add(" + Resist Natural: " + target.GetDamageResist(eProperty.Resist_Natural));
}
if (target.GetDamageResist(eProperty.Resist_Body) > 0)
{
info.Add(" + Resist Body: " + target.GetDamageResist(eProperty.Resist_Body));
}
if (target.GetDamageResist(eProperty.Resist_Spirit) > 0)
{
info.Add(" + Resist Spirit: " + target.GetDamageResist(eProperty.Resist_Spirit));
}
if (target.GetDamageResist(eProperty.Resist_Energy) > 0)
{
info.Add(" + Resist Energy: " + target.GetDamageResist(eProperty.Resist_Energy));
}
info.Add(" + Active weapon slot: " + target.ActiveWeaponSlot);
info.Add(" + Visible weapon slot: " + target.VisibleActiveWeaponSlots);
if (target.EquipmentTemplateID != null && target.EquipmentTemplateID.Length > 0)
{
info.Add(" + Equipment Template ID: " + target.EquipmentTemplateID);
}
if (target.Inventory != null)
{
info.Add(" + Inventory: " + target.Inventory.AllItems.Count + " items");
}
info.Add(" ");
info.Add(" + Mob_ID: " + target.InternalID);
info.Add(" + Position: " + target.X + ", " + target.Y + ", " + target.Z + ", " + target.Heading);
info.Add(" + OID: " + target.ObjectID);
info.Add(" + Package ID: " + target.PackageID);
/* if (target.Brain != null && target.Brain.IsActive)
* {
* info.Add(target.Brain.GetType().FullName);
* info.Add(target.Brain.ToString());
* info.Add("");
* }
*/
info.Add("");
info.Add(" ------ State ------");
if (target.IsReturningHome || target.IsReturningToSpawnPoint)
{
info.Add("IsReturningHome: " + target.IsReturningHome);
info.Add("IsReturningToSpawnPoint: " + target.IsReturningToSpawnPoint);
info.Add("");
}
info.Add("InCombat: " + target.InCombat);
info.Add("AttackState: " + target.AttackState);
info.Add("LastCombatPVE: " + target.LastAttackedByEnemyTickPvE);
info.Add("LastCombatPVP: " + target.LastAttackedByEnemyTickPvP);
if (target.InCombat || target.AttackState)
{
info.Add("RegionTick: " + target.CurrentRegion.Time);
}
info.Add("");
if (target.TargetObject != null)
{
info.Add("TargetObject: " + target.TargetObject.Name);
info.Add("InView: " + target.TargetInView);
}
if (target.Brain != null && target.Brain is StandardMobBrain)
{
Dictionary <GameLiving, long> aggroList = (target.Brain as StandardMobBrain).AggroTable;
if (aggroList.Count > 0)
{
info.Add("");
info.Add("Aggro List:");
foreach (GameLiving living in aggroList.Keys)
{
info.Add(living.Name + ": " + aggroList[living]);
}
}
}
if (target.Attackers != null && target.Attackers.Count > 0)
{
info.Add("");
info.Add("Attacker List:");
foreach (GameLiving attacker in target.Attackers)
{
info.Add(attacker.Name);
}
}
if (target.EffectList.Count > 0)
{
info.Add("");
info.Add("Effect List:");
foreach (IGameEffect effect in target.EffectList)
{
info.Add(effect.Name + " remaining " + effect.RemainingTime);
}
}
info.Add("");
info.Add(" + Loot:");
var template = DOLDB <LootTemplate> .SelectObjects(DB.Column(nameof(LootTemplate.TemplateName)).IsEqualTo(target.Name));
foreach (LootTemplate loot in template)
{
ItemTemplate drop = GameServer.Database.FindObjectByKey <ItemTemplate>(loot.ItemTemplateID);
string message = "";
if (drop == null)
{
message += loot.ItemTemplateID + " (Template Not Found)";
}
else
{
message += drop.Name + " (" + drop.Id_nb + ")";
}
message += " Chance: " + loot.Chance.ToString();
info.Add("- " + message);
}
}
#endregion Mob
#region Player
/********************* PLAYER ************************/
if (client.Player.TargetObject is GamePlayer)
{
var target = client.Player.TargetObject as GamePlayer;
info.Add("PLAYER INFORMATION (Client # " + target.Client.SessionID + ")");
info.Add(" - Name : " + target.Name);
info.Add(" - Lastname : " + target.LastName);
info.Add(" - Realm : " + GlobalConstants.RealmToName(target.Realm));
info.Add(" - Level : " + target.Level);
info.Add(" - Class : " + target.CharacterClass.Name);
info.Add(" - Guild : " + target.GuildName);
info.Add(" ");
info.Add(" - Account Name : " + target.AccountName);
info.Add(" - IP : " + target.Client.Account.LastLoginIP);
info.Add(" - Priv. Level : " + target.Client.Account.PrivLevel);
info.Add(" - Client Version: " + target.Client.Account.LastClientVersion);
info.Add(" ");
info.Add(" - Craftingskill : " + target.CraftingPrimarySkill + "");
info.Add(" - Model ID : " + target.Model);
info.Add(" - AFK Message: " + target.TempProperties.getProperty <string>(GamePlayer.AFK_MESSAGE) + "");
info.Add(" ");
info.Add(" - Money : " + Money.GetString(target.GetCurrentMoney()) + "\n");
info.Add(" - Speed : " + target.MaxSpeedBase);
info.Add(" - XPs : " + target.Experience);
info.Add(" - RPs : " + target.RealmPoints);
info.Add(" - BPs : " + target.BountyPoints);
String sCurrent = "";
String sTitle = "";
int cnt = 0;
info.Add(" ");
info.Add("SPECCING INFORMATIONS ");
info.Add(" - Remaining spec. points : " + target.SkillSpecialtyPoints);
sTitle = " - Player specialisations / level: \n";
sCurrent = "";
foreach (Specialization spec in target.GetSpecList())
{
sCurrent += " - " + spec.Name + " = " + spec.Level + " \n";
}
info.Add(sTitle + sCurrent);
sCurrent = "";
sTitle = "";
info.Add(" ");
info.Add("CHARACTER STATS ");
info.Add(" - Maximum Health : " + target.MaxHealth);
info.Add(" - Current AF : " + target.GetModified(eProperty.ArmorFactor));
info.Add(" - Current ABS : " + target.GetModified(eProperty.ArmorAbsorption));
for (eProperty stat = eProperty.Stat_First; stat <= eProperty.Stat_Last; stat++, cnt++)
{
sTitle += GlobalConstants.PropertyToName(stat);
sCurrent += target.GetModified(stat);
info.Add(" - " + sTitle + " : " + sCurrent);
sCurrent = "";
sTitle = "";
}
sCurrent = "";
sTitle = "";
cnt = 0;
for (eProperty res = eProperty.Resist_First; res <= eProperty.Resist_Last; res++, cnt++)
{
sTitle += GlobalConstants.PropertyToName(res);
sCurrent += target.GetModified(res);
info.Add(" - " + sTitle + " : " + sCurrent);
sCurrent = "";
sTitle = "";
}
info.Add(" ");
info.Add(" ");
info.Add(" - Respecs dol : " + target.RespecAmountDOL);
info.Add(" - Respecs single : " + target.RespecAmountSingleSkill);
info.Add(" - Respecs full : " + target.RespecAmountAllSkill);
info.Add(" ");
info.Add(" ");
info.Add(" --------------------------------------");
info.Add(" ----- Inventory Equiped -----");
info.Add(" --------------------------------------");
////////////// Inventaire /////////////
info.Add(" ----- Money:");
info.Add(Money.GetShortString(target.GetCurrentMoney()));
info.Add(" ");
info.Add(" ----- Wearing:");
foreach (InventoryItem item in target.Inventory.EquippedItems)
{
info.Add(" [" + GlobalConstants.SlotToName(item.Item_Type) + "] " + item.Name);
}
info.Add(" ");
}
#endregion Player
#region StaticItem
/********************* OBJECT ************************/
if (client.Player.TargetObject is GameStaticItem)
{
var target = client.Player.TargetObject as GameStaticItem;
if (!string.IsNullOrEmpty(target.Name))
{
name = target.Name;
}
info.Add(" ------- OBJECT ------\n");
info.Add(" Name: " + name);
info.Add(" Model: " + target.Model);
info.Add(" Emblem: " + target.Emblem);
info.Add(" Realm: " + target.Realm);
if (target.Owners.LongLength > 0)
{
info.Add(" ");
info.Add(" Owner Name: " + target.Owners[0].Name);
}
info.Add(" ");
info.Add(" OID: " + target.ObjectID);
info.Add(" Type: " + target.GetType());
WorldInventoryItem invItem = target as WorldInventoryItem;
if (invItem != null)
{
info.Add(" Count: " + invItem.Item.Count);
}
info.Add(" ");
info.Add(" Location: X= " + target.X + " ,Y= " + target.Y + " ,Z= " + target.Z);
}
#endregion StaticItem
#region Door
/********************* DOOR ************************/
if (client.Player.TargetObject is GameDoor)
{
var target = client.Player.TargetObject as GameDoor;
string Realmname = "";
string statut = "";
name = target.Name;
if (target.Realm == eRealm.None)
{
Realmname = "None";
}
if (target.Realm == eRealm.Albion)
{
Realmname = "Albion";
}
if (target.Realm == eRealm.Midgard)
{
Realmname = "Midgard";
}
if (target.Realm == eRealm.Hibernia)
{
Realmname = "Hibernia";
}
if (target.Realm == eRealm.Door)
{
Realmname = "All";
}
if (target.Locked == 1)
{
statut = " Locked";
}
if (target.Locked == 0)
{
statut = " Unlocked";
}
info.Add(" ------- DOOR ------\n");
info.Add(" ");
info.Add(" + Name : " + target.Name);
info.Add(" + ID : " + target.DoorID);
info.Add(" + Realm : " + (int)target.Realm + " : " + Realmname);
info.Add(" + Level : " + target.Level);
info.Add(" + Guild : " + target.GuildName);
info.Add(" + Health : " + target.Health + " / " + target.MaxHealth);
info.Add(" + Statut : " + statut);
info.Add(" + Type : " + DoorRequestHandler.m_handlerDoorID / 100000000);
info.Add(" ");
info.Add(" + X : " + target.X);
info.Add(" + Y : " + target.Y);
info.Add(" + Z : " + target.Z);
info.Add(" + Heading : " + target.Heading);
}
#endregion Door
#region Keep
/********************* KEEP ************************/
if (client.Player.TargetObject is GameKeepComponent)
{
var target = client.Player.TargetObject as GameKeepComponent;
name = target.Name;
string realm = " other realm";
if ((byte)target.Realm == 0)
{
realm = " Monster";
}
if ((byte)target.Realm == 1)
{
realm = " Albion";
}
if ((byte)target.Realm == 2)
{
realm = " Midgard";
}
if ((byte)target.Realm == 3)
{
realm = " Hibernia";
}
info.Add(" ------- KEEP ------\n");
info.Add(" + Name : " + target.Name);
info.Add(" + KeepID : " + target.Keep.KeepID);
info.Add(" + Level : " + target.Level);
info.Add(" + BaseLevel : " + target.Keep.BaseLevel);
info.Add(" + Realm : " + realm);
info.Add(" ");
info.Add(" + Model : " + target.Model);
info.Add(" + Skin : " + target.Skin);
info.Add(" + Height : " + target.Height);
info.Add(" + ID : " + target.ID);
info.Add(" ");
info.Add(" + Health : " + target.Health);
info.Add(" + IsRaized : " + target.IsRaized);
info.Add(" + Status : " + target.Status);
info.Add(" ");
info.Add(" + Climbing : " + target.Climbing);
info.Add(" ");
info.Add(" + ComponentX : " + target.ComponentX);
info.Add(" + ComponentY : " + target.ComponentY);
info.Add(" + ComponentHeading : " + target.ComponentHeading);
info.Add(" ");
info.Add(" + HookPoints : " + target.HookPoints.Count);
info.Add(" + Positions : " + target.Positions.Count);
info.Add(" ");
info.Add(" + RealmPointsValue : " + target.RealmPointsValue);
info.Add(" + ExperienceValue : " + target.ExperienceValue);
info.Add(" + AttackRange : " + target.AttackRange);
info.Add(" ");
if (GameServer.KeepManager.GetFrontierKeeps().Contains(target.Keep))
{
info.Add(" + Keep Manager : " + GameServer.KeepManager.GetType().FullName);
info.Add(" + Frontiers");
}
else if (GameServer.KeepManager.GetBattleground(target.CurrentRegionID) != null)
{
info.Add(" + Keep Manager : " + GameServer.KeepManager.GetType().FullName);
Battleground bg = GameServer.KeepManager.GetBattleground(client.Player.CurrentRegionID);
info.Add(" + Battleground (" + bg.MinLevel + " to " + bg.MaxLevel + ", max RL: " + bg.MaxRealmLevel + ")");
}
else
{
info.Add(" + Keep Manager : Not Managed");
}
}
#endregion Keep
client.Out.SendCustomTextWindow("[ " + name + " ]", info);
return;
}
if (client.Player.TargetObject == null)
{
/*********************** HOUSE *************************/
if (client.Player.InHouse)
{
#region House
House house = client.Player.CurrentHouse as House;
name = house.Name;
int level = house.Model - ((house.Model - 1) / 4) * 4;
TimeSpan due = (house.LastPaid.AddDays(ServerProperties.Properties.RENT_DUE_DAYS).AddHours(1) - DateTime.Now);
info.Add(" ------- HOUSE ------\n");
info.Add(LanguageMgr.GetTranslation(client.Account.Language, "House.SendHouseInfo.Owner", name));
info.Add(LanguageMgr.GetTranslation(client.Account.Language, "House.SendHouseInfo.Lotnum", house.HouseNumber));
info.Add("Unique ID: " + house.UniqueID);
info.Add(LanguageMgr.GetTranslation(client.Account.Language, "House.SendHouseInfo.Level", level));
info.Add(" ");
info.Add(LanguageMgr.GetTranslation(client.Account.Language, "House.SendHouseInfo.Porch"));
info.Add(LanguageMgr.GetTranslation(client.Account.Language, "House.SendHouseInfo.PorchEnabled", (house.Porch ? " Present" : " Not Present")));
info.Add(LanguageMgr.GetTranslation(client.Account.Language, "House.SendHouseInfo.PorchRoofColor", Color(house.PorchRoofColor)));
info.Add(" ");
info.Add(LanguageMgr.GetTranslation(client.Account.Language, "House.SendHouseInfo.ExteriorMaterials"));
info.Add(LanguageMgr.GetTranslation(client.Account.Language, "House.SendHouseInfo.RoofMaterial", MaterialWall(house.RoofMaterial)));
info.Add(LanguageMgr.GetTranslation(client.Account.Language, "House.SendHouseInfo.WallMaterial", MaterialWall(house.WallMaterial)));
info.Add(LanguageMgr.GetTranslation(client.Account.Language, "House.SendHouseInfo.DoorMaterial", MaterialDoor(house.DoorMaterial)));
info.Add(LanguageMgr.GetTranslation(client.Account.Language, "House.SendHouseInfo.TrussMaterial", MaterialTruss(house.TrussMaterial)));
info.Add(LanguageMgr.GetTranslation(client.Account.Language, "House.SendHouseInfo.PorchMaterial", MaterialTruss(house.PorchMaterial)));
info.Add(LanguageMgr.GetTranslation(client.Account.Language, "House.SendHouseInfo.WindowMaterial", MaterialTruss(house.WindowMaterial)));
info.Add(" ");
info.Add(LanguageMgr.GetTranslation(client.Account.Language, "House.SendHouseInfo.ExteriorUpgrades"));
info.Add(LanguageMgr.GetTranslation(client.Account.Language, "House.SendHouseInfo.OutdoorGuildBanner", ((house.OutdoorGuildBanner) ? " Present" : " Not Present")));
info.Add(LanguageMgr.GetTranslation(client.Account.Language, "House.SendHouseInfo.OutdoorGuildShield", ((house.OutdoorGuildShield) ? " Present" : " Not Present")));
info.Add(" ");
info.Add(LanguageMgr.GetTranslation(client.Account.Language, "House.SendHouseInfo.InteriorUpgrades"));
info.Add(LanguageMgr.GetTranslation(client.Account.Language, "House.SendHouseInfo.IndoorGuildBanner", ((house.IndoorGuildBanner) ? " Present" : " Not Present")));
info.Add(LanguageMgr.GetTranslation(client.Account.Language, "House.SendHouseInfo.IndoorGuildShield", ((house.IndoorGuildShield) ? " Present" : " Not Present")));
info.Add(" ");
info.Add(LanguageMgr.GetTranslation(client.Account.Language, "House.SendHouseInfo.InteriorCarpets"));
if (house.Rug1Color != 0)
{
info.Add(LanguageMgr.GetTranslation(client.Account.Language, "House.SendHouseInfo.Rug1Color", Color(house.Rug1Color)));
}
if (house.Rug2Color != 0)
{
info.Add(LanguageMgr.GetTranslation(client.Account.Language, "House.SendHouseInfo.Rug2Color", Color(house.Rug2Color)));
}
if (house.Rug3Color != 0)
{
info.Add(LanguageMgr.GetTranslation(client.Account.Language, "House.SendHouseInfo.Rug3Color", Color(house.Rug3Color)));
}
if (house.Rug4Color != 0)
{
info.Add(LanguageMgr.GetTranslation(client.Account.Language, "House.SendHouseInfo.Rug4Color", Color(house.Rug4Color)));
}
info.Add(" ");
info.Add(LanguageMgr.GetTranslation(client.Account.Language, "House.SendHouseInfo.Lockbox", Money.GetString(house.KeptMoney)));
info.Add(LanguageMgr.GetTranslation(client.Account.Language, "House.SendHouseInfo.RentalPrice", Money.GetString(HouseMgr.GetRentByModel(house.Model))));
info.Add(LanguageMgr.GetTranslation(client.Account.Language, "House.SendHouseInfo.MaxLockbox", Money.GetString(HouseMgr.GetRentByModel(house.Model) * ServerProperties.Properties.RENT_LOCKBOX_PAYMENTS)));
info.Add(LanguageMgr.GetTranslation(client.Account.Language, "House.SendHouseInfo.RentDueIn", due.Days, due.Hours));
#endregion House
client.Out.SendCustomTextWindow(LanguageMgr.GetTranslation(client.Account.Language, "House.SendHouseInfo.HouseOwner", name), info);
}
else // No target and not in a house
{
string realm = " other realm";
if (client.Player.CurrentZone.Realm == eRealm.Albion)
{
realm = " Albion";
}
if (client.Player.CurrentZone.Realm == eRealm.Midgard)
{
realm = " Midgard";
}
if (client.Player.CurrentZone.Realm == eRealm.Hibernia)
{
realm = " Hibernia";
}
info.Add(" Game Time: \t" + hour.ToString() + ":" + minute.ToString());
info.Add(" ");
info.Add(" Server Rules: " + GameServer.ServerRules.GetType().FullName);
if (GameServer.KeepManager.FrontierRegionsList.Contains(client.Player.CurrentRegionID))
{
info.Add(" Keep Manager: " + GameServer.KeepManager.GetType().FullName);
info.Add(" Frontiers");
}
else if (GameServer.KeepManager.GetBattleground(client.Player.CurrentRegionID) != null)
{
info.Add(" Keep Manager: " + GameServer.KeepManager.GetType().FullName);
Battleground bg = GameServer.KeepManager.GetBattleground(client.Player.CurrentRegionID);
info.Add(" Battleground (" + bg.MinLevel + " to " + bg.MaxLevel + ", max RL: " + bg.MaxRealmLevel + ")");
}
else
{
info.Add(" Keep Manager : None for this region");
}
info.Add(" ");
info.Add(" Server players: " + WorldMgr.GetAllPlayingClientsCount());
info.Add(" ");
info.Add(" Region Players:");
info.Add(" All players: " + WorldMgr.GetClientsOfRegionCount(client.Player.CurrentRegion.ID));
info.Add(" ");
info.Add(" Alb players: " + WorldMgr.GetClientsOfRegionCount(client.Player.CurrentRegion.ID, eRealm.Albion));
info.Add(" Hib players: " + WorldMgr.GetClientsOfRegionCount(client.Player.CurrentRegion.ID, eRealm.Hibernia));
info.Add(" Mid players: " + WorldMgr.GetClientsOfRegionCount(client.Player.CurrentRegion.ID, eRealm.Midgard));
info.Add(" ");
info.Add(" Total objects in region: " + client.Player.CurrentRegion.TotalNumberOfObjects);
info.Add(" ");
info.Add(" NPC in zone:");
info.Add(" Alb : " + client.Player.CurrentZone.GetNPCsOfZone(eRealm.Albion).Count);
info.Add(" Hib : " + client.Player.CurrentZone.GetNPCsOfZone(eRealm.Hibernia).Count);
info.Add(" Mid: " + client.Player.CurrentZone.GetNPCsOfZone(eRealm.Midgard).Count);
info.Add(" None : " + client.Player.CurrentZone.GetNPCsOfZone(eRealm.None).Count);
info.Add(" ");
info.Add(" Total objects in zone: " + client.Player.CurrentZone.TotalNumberOfObjects);
info.Add(" ");
info.Add(" Zone Description: " + client.Player.CurrentZone.Description);
info.Add(" Zone Realm: " + realm);
info.Add(" Zone ID: " + client.Player.CurrentZone.ID);
info.Add(" Zone IsDungeon: " + client.Player.CurrentZone.IsDungeon);
info.Add(" Zone SkinID: " + client.Player.CurrentZone.ZoneSkinID);
info.Add(" Zone X: " + client.Player.CurrentZone.XOffset);
info.Add(" Zone Y: " + client.Player.CurrentZone.YOffset);
info.Add(" Zone Width: " + client.Player.CurrentZone.Width);
info.Add(" Zone Height: " + client.Player.CurrentZone.Height);
info.Add(" Zone DivingEnabled: " + client.Player.CurrentZone.IsDivingEnabled);
info.Add(" Zone Waterlevel: " + client.Player.CurrentZone.Waterlevel);
info.Add(" ");
info.Add(" Region Name: " + client.Player.CurrentRegion.Name);
info.Add(" Region Description: " + client.Player.CurrentRegion.Description);
info.Add(" Region Skin: " + client.Player.CurrentRegion.Skin);
info.Add(" Region ID: " + client.Player.CurrentRegion.ID);
info.Add(" Region Expansion: " + client.Player.CurrentRegion.Expansion);
info.Add(" Region IsRvR: " + client.Player.CurrentRegion.IsRvR);
info.Add(" Region IsFrontier: " + client.Player.CurrentRegion.IsFrontier);
info.Add(" Region IsDungeon: " + client.Player.CurrentRegion.IsDungeon);
info.Add(" Zone in Region: " + client.Player.CurrentRegion.Zones.Count);
info.Add(" Region WaterLevel: " + client.Player.CurrentRegion.WaterLevel);
info.Add(" Region HousingEnabled: " + client.Player.CurrentRegion.HousingEnabled);
info.Add(" Region IsDisabled: " + client.Player.CurrentRegion.IsDisabled);
info.Add(" ");
info.Add(" Region ServerIP: " + client.Player.CurrentRegion.ServerIP);
info.Add(" Region ServerPort: " + client.Player.CurrentRegion.ServerPort);
client.Out.SendCustomTextWindow("[ " + client.Player.CurrentRegion.Description + " ]", info);
}
}
}
public void BuildBattlegroundStatusQueued(out BattlefieldStatusQueued battlefieldStatus, Battleground bg, Player player, uint ticketId, uint joinTime, BattlegroundQueueTypeId queueId, uint avgWaitTime, ArenaTypes arenaType, bool asGroup)
{
battlefieldStatus = new BattlefieldStatusQueued();
BuildBattlegroundStatusHeader(battlefieldStatus.Hdr, bg, player, ticketId, joinTime, queueId, arenaType);
battlefieldStatus.AverageWaitTime = avgWaitTime;
battlefieldStatus.AsGroup = asGroup;
battlefieldStatus.SuspendedQueue = false;
battlefieldStatus.EligibleForMatchmaking = true;
battlefieldStatus.WaitTime = Time.GetMSTimeDiffToNow(joinTime);
}
// used to create the BG templates
bool CreateBattleground(BattlegroundTemplate bgTemplate)
{
Battleground bg = GetBattlegroundTemplate(bgTemplate.Id);
if (!bg)
{
// Create the BG
switch (bgTemplate.Id)
{
//case BattlegroundTypeId.AV:
// bg = new BattlegroundAV(bgTemplate);
//break;
case BattlegroundTypeId.WS:
bg = new BgWarsongGluch(bgTemplate);
break;
case BattlegroundTypeId.AB:
bg = new BgArathiBasin(bgTemplate);
break;
case BattlegroundTypeId.NA:
bg = new NagrandArena(bgTemplate);
break;
case BattlegroundTypeId.BE:
bg = new BladesEdgeArena(bgTemplate);
break;
case BattlegroundTypeId.EY:
bg = new BgEyeofStorm(bgTemplate);
break;
case BattlegroundTypeId.RL:
bg = new RuinsofLordaeronArena(bgTemplate);
break;
case BattlegroundTypeId.SA:
bg = new BgStrandOfAncients(bgTemplate);
break;
case BattlegroundTypeId.DS:
bg = new DalaranSewersArena(bgTemplate);
break;
case BattlegroundTypeId.RV:
bg = new RingofValorArena(bgTemplate);
break;
//case BattlegroundTypeId.IC:
//bg = new BattlegroundIC(bgTemplate);
//break;
case BattlegroundTypeId.AA:
bg = new Battleground(bgTemplate);
break;
case BattlegroundTypeId.RB:
bg = new Battleground(bgTemplate);
bg.SetRandom(true);
break;
/*
* case BattlegroundTypeId.TP:
* bg = new BattlegroundTP(bgTemplate);
* break;
* case BattlegroundTypeId.BFG:
* bg = new BattlegroundBFG(bgTemplate);
* break;
*/
case BattlegroundTypeId.RandomEpic:
bg = new Battleground(bgTemplate);
bg.SetRandom(true);
break;
default:
return(false);
}
}
if (!bgDataStore.ContainsKey(bg.GetTypeID()))
{
bgDataStore[bg.GetTypeID()] = new BattlegroundData();
}
bgDataStore[bg.GetTypeID()].Template = bg;
return(true);
}
void HandleBattlemasterJoinArena(BattlemasterJoinArena packet)
{
// ignore if we already in BG or BG queue
if (GetPlayer().InBattleground())
{
return;
}
ArenaTypes arenatype = (ArenaTypes)ArenaTeam.GetTypeBySlot(packet.TeamSizeIndex);
//check existence
Battleground bg = Global.BattlegroundMgr.GetBattlegroundTemplate(BattlegroundTypeId.AA);
if (!bg)
{
Log.outError(LogFilter.Network, "Battleground: template bg (all arenas) not found");
return;
}
if (Global.DisableMgr.IsDisabledFor(DisableType.Battleground, (uint)BattlegroundTypeId.AA, null))
{
GetPlayer().SendSysMessage(CypherStrings.ArenaDisabled);
return;
}
BattlegroundTypeId bgTypeId = bg.GetTypeID();
BattlegroundQueueTypeId bgQueueTypeId = Global.BattlegroundMgr.BGQueueTypeId(bgTypeId, arenatype);
PvpDifficultyRecord bracketEntry = Global.DB2Mgr.GetBattlegroundBracketByLevel(bg.GetMapId(), GetPlayer().getLevel());
if (bracketEntry == null)
{
return;
}
Group grp = GetPlayer().GetGroup();
// no group found, error
if (!grp)
{
return;
}
if (grp.GetLeaderGUID() != GetPlayer().GetGUID())
{
return;
}
uint ateamId = GetPlayer().GetArenaTeamId(packet.TeamSizeIndex);
// check real arenateam existence only here (if it was moved to group.CanJoin .. () then we would ahve to get it twice)
ArenaTeam at = Global.ArenaTeamMgr.GetArenaTeamById(ateamId);
if (at == null)
{
GetPlayer().GetSession().SendNotInArenaTeamPacket(arenatype);
return;
}
// get the team rating for queuing
uint arenaRating = at.GetRating();
uint matchmakerRating = at.GetAverageMMR(grp);
// the arenateam id must match for everyone in the group
if (arenaRating <= 0)
{
arenaRating = 1;
}
BattlegroundQueue bgQueue = Global.BattlegroundMgr.GetBattlegroundQueue(bgQueueTypeId);
uint avgTime = 0;
GroupQueueInfo ginfo = null;
ObjectGuid errorGuid;
var err = grp.CanJoinBattlegroundQueue(bg, bgQueueTypeId, (uint)arenatype, (uint)arenatype, true, packet.TeamSizeIndex, out errorGuid);
if (err == 0)
{
Log.outDebug(LogFilter.Battleground, "Battleground: arena team id {0}, leader {1} queued with matchmaker rating {2} for type {3}", GetPlayer().GetArenaTeamId(packet.TeamSizeIndex), GetPlayer().GetName(), matchmakerRating, arenatype);
ginfo = bgQueue.AddGroup(GetPlayer(), grp, bgTypeId, bracketEntry, arenatype, true, false, arenaRating, matchmakerRating, ateamId);
avgTime = bgQueue.GetAverageQueueWaitTime(ginfo, bracketEntry.GetBracketId());
}
for (GroupReference refe = grp.GetFirstMember(); refe != null; refe = refe.next())
{
Player member = refe.GetSource();
if (!member)
{
continue;
}
if (err != 0)
{
BattlefieldStatusFailed battlefieldStatus;
Global.BattlegroundMgr.BuildBattlegroundStatusFailed(out battlefieldStatus, bg, GetPlayer(), 0, arenatype, err, errorGuid);
member.SendPacket(battlefieldStatus);
continue;
}
// add to queue
uint queueSlot = member.AddBattlegroundQueueId(bgQueueTypeId);
BattlefieldStatusQueued battlefieldStatusQueued;
Global.BattlegroundMgr.BuildBattlegroundStatusQueued(out battlefieldStatusQueued, bg, member, queueSlot, ginfo.JoinTime, avgTime, arenatype, true);
member.SendPacket(battlefieldStatusQueued);
Log.outDebug(LogFilter.Battleground, "Battleground: player joined queue for arena as group bg queue type {0} bg type {1}: GUID {2}, NAME {3}", bgQueueTypeId, bgTypeId, member.GetGUID().ToString(), member.GetName());
}
Global.BattlegroundMgr.ScheduleQueueUpdate(matchmakerRating, arenatype, bgQueueTypeId, bgTypeId, bracketEntry.GetBracketId());
}
void HandleBattlemasterJoin(BattlemasterJoin battlemasterJoin)
{
bool isPremade = false;
Group grp = null;
BattlefieldStatusFailed battlefieldStatusFailed;
uint bgTypeId_ = (uint)(battlemasterJoin.QueueID & 0xFFFF);
if (!CliDB.BattlemasterListStorage.ContainsKey(bgTypeId_))
{
Log.outError(LogFilter.Network, "Battleground: invalid bgtype ({0}) received. possible cheater? player guid {1}", bgTypeId_, GetPlayer().GetGUID().ToString());
return;
}
if (Global.DisableMgr.IsDisabledFor(DisableType.Battleground, bgTypeId_, null))
{
GetPlayer().SendSysMessage(CypherStrings.BgDisabled);
return;
}
BattlegroundTypeId bgTypeId = (BattlegroundTypeId)bgTypeId_;
// can do this, since it's Battleground, not arena
BattlegroundQueueTypeId bgQueueTypeId = Global.BattlegroundMgr.BGQueueTypeId(bgTypeId, 0);
BattlegroundQueueTypeId bgQueueTypeIdRandom = Global.BattlegroundMgr.BGQueueTypeId(BattlegroundTypeId.RB, 0);
// ignore if player is already in BG
if (GetPlayer().InBattleground())
{
return;
}
// get bg instance or bg template if instance not found
Battleground bg = Global.BattlegroundMgr.GetBattlegroundTemplate(bgTypeId);
if (!bg)
{
return;
}
// expected bracket entry
PvpDifficultyRecord bracketEntry = Global.DB2Mgr.GetBattlegroundBracketByLevel(bg.GetMapId(), GetPlayer().getLevel());
if (bracketEntry == null)
{
return;
}
GroupJoinBattlegroundResult err = GroupJoinBattlegroundResult.None;
// check queue conditions
if (!battlemasterJoin.JoinAsGroup)
{
if (GetPlayer().isUsingLfg())
{
Global.BattlegroundMgr.BuildBattlegroundStatusFailed(out battlefieldStatusFailed, bg, GetPlayer(), 0, 0, GroupJoinBattlegroundResult.LfgCantUseBattleground);
SendPacket(battlefieldStatusFailed);
return;
}
// check Deserter debuff
if (!GetPlayer().CanJoinToBattleground(bg))
{
Global.BattlegroundMgr.BuildBattlegroundStatusFailed(out battlefieldStatusFailed, bg, GetPlayer(), 0, 0, GroupJoinBattlegroundResult.Deserters);
SendPacket(battlefieldStatusFailed);
return;
}
if (GetPlayer().GetBattlegroundQueueIndex(bgQueueTypeIdRandom) < SharedConst.MaxPlayerBGQueues)
{
// player is already in random queue
Global.BattlegroundMgr.BuildBattlegroundStatusFailed(out battlefieldStatusFailed, bg, GetPlayer(), 0, 0, GroupJoinBattlegroundResult.InRandomBg);
SendPacket(battlefieldStatusFailed);
return;
}
if (GetPlayer().InBattlegroundQueue() && bgTypeId == BattlegroundTypeId.RB)
{
// player is already in queue, can't start random queue
Global.BattlegroundMgr.BuildBattlegroundStatusFailed(out battlefieldStatusFailed, bg, GetPlayer(), 0, 0, GroupJoinBattlegroundResult.InNonRandomBg);
SendPacket(battlefieldStatusFailed);
return;
}
// check if already in queue
if (GetPlayer().GetBattlegroundQueueIndex(bgQueueTypeId) < SharedConst.MaxPlayerBGQueues)
{
return; // player is already in this queue
}
// check if has free queue slots
if (!GetPlayer().HasFreeBattlegroundQueueId())
{
Global.BattlegroundMgr.BuildBattlegroundStatusFailed(out battlefieldStatusFailed, bg, GetPlayer(), 0, 0, GroupJoinBattlegroundResult.TooManyQueues);
SendPacket(battlefieldStatusFailed);
return;
}
// check Freeze debuff
if (_player.HasAura(9454))
{
return;
}
BattlegroundQueue bgQueue = Global.BattlegroundMgr.GetBattlegroundQueue(bgQueueTypeId);
GroupQueueInfo ginfo = bgQueue.AddGroup(GetPlayer(), null, bgTypeId, bracketEntry, 0, false, isPremade, 0, 0);
uint avgTime = bgQueue.GetAverageQueueWaitTime(ginfo, bracketEntry.GetBracketId());
uint queueSlot = GetPlayer().AddBattlegroundQueueId(bgQueueTypeId);
BattlefieldStatusQueued battlefieldStatusQueued;
Global.BattlegroundMgr.BuildBattlegroundStatusQueued(out battlefieldStatusQueued, bg, GetPlayer(), queueSlot, ginfo.JoinTime, avgTime, ginfo.ArenaType, false);
SendPacket(battlefieldStatusQueued);
Log.outDebug(LogFilter.Battleground, "Battleground: player joined queue for bg queue type {0} bg type {1}: GUID {2}, NAME {3}",
bgQueueTypeId, bgTypeId, GetPlayer().GetGUID().ToString(), GetPlayer().GetName());
}
else
{
grp = GetPlayer().GetGroup();
if (!grp)
{
return;
}
if (grp.GetLeaderGUID() != GetPlayer().GetGUID())
{
return;
}
ObjectGuid errorGuid;
err = grp.CanJoinBattlegroundQueue(bg, bgQueueTypeId, 0, bg.GetMaxPlayersPerTeam(), false, 0, out errorGuid);
isPremade = (grp.GetMembersCount() >= bg.GetMinPlayersPerTeam());
BattlegroundQueue bgQueue = Global.BattlegroundMgr.GetBattlegroundQueue(bgQueueTypeId);
GroupQueueInfo ginfo = null;
uint avgTime = 0;
if (err == 0)
{
Log.outDebug(LogFilter.Battleground, "Battleground: the following players are joining as group:");
ginfo = bgQueue.AddGroup(GetPlayer(), grp, bgTypeId, bracketEntry, 0, false, isPremade, 0, 0);
avgTime = bgQueue.GetAverageQueueWaitTime(ginfo, bracketEntry.GetBracketId());
}
for (GroupReference refe = grp.GetFirstMember(); refe != null; refe = refe.next())
{
Player member = refe.GetSource();
if (!member)
{
continue; // this should never happen
}
if (err != 0)
{
BattlefieldStatusFailed battlefieldStatus;
Global.BattlegroundMgr.BuildBattlegroundStatusFailed(out battlefieldStatus, bg, GetPlayer(), 0, 0, err, errorGuid);
member.SendPacket(battlefieldStatus);
continue;
}
// add to queue
uint queueSlot = member.AddBattlegroundQueueId(bgQueueTypeId);
BattlefieldStatusQueued battlefieldStatusQueued;
Global.BattlegroundMgr.BuildBattlegroundStatusQueued(out battlefieldStatusQueued, bg, member, queueSlot, ginfo.JoinTime, avgTime, ginfo.ArenaType, true);
member.SendPacket(battlefieldStatusQueued);
Log.outDebug(LogFilter.Battleground, "Battleground: player joined queue for bg queue type {0} bg type {1}: GUID {2}, NAME {3}",
bgQueueTypeId, bgTypeId, member.GetGUID().ToString(), member.GetName());
}
Log.outDebug(LogFilter.Battleground, "Battleground: group end");
}
Global.BattlegroundMgr.ScheduleQueueUpdate(0, 0, bgQueueTypeId, bgTypeId, bracketEntry.GetBracketId());
}
void HandleBattleFieldPort(BattlefieldPort battlefieldPort)
{
if (!GetPlayer().InBattlegroundQueue())
{
Log.outDebug(LogFilter.Battleground, "CMSG_BATTLEFIELD_PORT {0} Slot: {1}, Unk: {2}, Time: {3}, AcceptedInvite: {4}. Player not in queue!",
GetPlayerInfo(), battlefieldPort.Ticket.Id, battlefieldPort.Ticket.Type, battlefieldPort.Ticket.Time, battlefieldPort.AcceptedInvite);
return;
}
BattlegroundQueueTypeId bgQueueTypeId = GetPlayer().GetBattlegroundQueueTypeId(battlefieldPort.Ticket.Id);
if (bgQueueTypeId == BattlegroundQueueTypeId.None)
{
Log.outDebug(LogFilter.Battleground, "CMSG_BATTLEFIELD_PORT {0} Slot: {1}, Unk: {2}, Time: {3}, AcceptedInvite: {4}. Invalid queueSlot!",
GetPlayerInfo(), battlefieldPort.Ticket.Id, battlefieldPort.Ticket.Type, battlefieldPort.Ticket.Time, battlefieldPort.AcceptedInvite);
return;
}
BattlegroundQueue bgQueue = Global.BattlegroundMgr.GetBattlegroundQueue(bgQueueTypeId);
//we must use temporary variable, because GroupQueueInfo pointer can be deleted in BattlegroundQueue.RemovePlayer() function
GroupQueueInfo ginfo;
if (!bgQueue.GetPlayerGroupInfoData(GetPlayer().GetGUID(), out ginfo))
{
Log.outDebug(LogFilter.Battleground, "CMSG_BATTLEFIELD_PORT {0} Slot: {1}, Unk: {2}, Time: {3}, AcceptedInvite: {4}. Player not in queue (No player Group Info)!",
GetPlayerInfo(), battlefieldPort.Ticket.Id, battlefieldPort.Ticket.Type, battlefieldPort.Ticket.Time, battlefieldPort.AcceptedInvite);
return;
}
// if action == 1, then instanceId is required
if (ginfo.IsInvitedToBGInstanceGUID == 0 && battlefieldPort.AcceptedInvite)
{
Log.outDebug(LogFilter.Battleground, "CMSG_BATTLEFIELD_PORT {0} Slot: {1}, Unk: {2}, Time: {3}, AcceptedInvite: {4}. Player is not invited to any bg!",
GetPlayerInfo(), battlefieldPort.Ticket.Id, battlefieldPort.Ticket.Type, battlefieldPort.Ticket.Time, battlefieldPort.AcceptedInvite);
return;
}
BattlegroundTypeId bgTypeId = Global.BattlegroundMgr.BGTemplateId(bgQueueTypeId);
// BGTemplateId returns Battleground_AA when it is arena queue.
// Do instance id search as there is no AA bg instances.
Battleground bg = Global.BattlegroundMgr.GetBattleground(ginfo.IsInvitedToBGInstanceGUID, bgTypeId == BattlegroundTypeId.AA ? BattlegroundTypeId.None : bgTypeId);
if (!bg)
{
if (battlefieldPort.AcceptedInvite)
{
Log.outDebug(LogFilter.Battleground, "CMSG_BATTLEFIELD_PORT {0} Slot: {1}, Unk: {2}, Time: {3}, AcceptedInvite: {4}. Cant find BG with id {5}!",
GetPlayerInfo(), battlefieldPort.Ticket.Id, battlefieldPort.Ticket.Type, battlefieldPort.Ticket.Time, battlefieldPort.AcceptedInvite, ginfo.IsInvitedToBGInstanceGUID);
return;
}
bg = Global.BattlegroundMgr.GetBattlegroundTemplate(bgTypeId);
if (!bg)
{
Log.outError(LogFilter.Network, "BattlegroundHandler: bg_template not found for type id {0}.", bgTypeId);
return;
}
}
// get real bg type
bgTypeId = bg.GetTypeID();
// expected bracket entry
PvpDifficultyRecord bracketEntry = Global.DB2Mgr.GetBattlegroundBracketByLevel(bg.GetMapId(), GetPlayer().getLevel());
if (bracketEntry == null)
{
return;
}
//some checks if player isn't cheating - it is not exactly cheating, but we cannot allow it
if (battlefieldPort.AcceptedInvite && ginfo.ArenaType == 0)
{
//if player is trying to enter Battleground(not arena!) and he has deserter debuff, we must just remove him from queue
if (!GetPlayer().CanJoinToBattleground(bg))
{
// send bg command result to show nice message
BattlefieldStatusFailed battlefieldStatus;
Global.BattlegroundMgr.BuildBattlegroundStatusFailed(out battlefieldStatus, bg, GetPlayer(), battlefieldPort.Ticket.Id, 0, GroupJoinBattlegroundResult.Deserters);
SendPacket(battlefieldStatus);
battlefieldPort.AcceptedInvite = false;
Log.outDebug(LogFilter.Battleground, "Player {0} ({1}) has a deserter debuff, do not port him to Battleground!", GetPlayer().GetName(), GetPlayer().GetGUID().ToString());
}
//if player don't match Battlegroundmax level, then do not allow him to enter! (this might happen when player leveled up during his waiting in queue
if (GetPlayer().getLevel() > bg.GetMaxLevel())
{
Log.outDebug(LogFilter.Network, "Player {0} ({1}) has level ({2}) higher than maxlevel ({3}) of Battleground({4})! Do not port him to Battleground!",
GetPlayer().GetName(), GetPlayer().GetGUID().ToString(), GetPlayer().getLevel(), bg.GetMaxLevel(), bg.GetTypeID());
battlefieldPort.AcceptedInvite = false;
}
}
if (battlefieldPort.AcceptedInvite)
{
// check Freeze debuff
if (GetPlayer().HasAura(9454))
{
return;
}
if (!GetPlayer().IsInvitedForBattlegroundQueueType(bgQueueTypeId))
{
return; // cheating?
}
if (!GetPlayer().InBattleground())
{
GetPlayer().SetBattlegroundEntryPoint();
}
// resurrect the player
if (!GetPlayer().IsAlive())
{
GetPlayer().ResurrectPlayer(1.0f);
GetPlayer().SpawnCorpseBones();
}
// stop taxi flight at port
if (GetPlayer().IsInFlight())
{
GetPlayer().GetMotionMaster().MovementExpired();
GetPlayer().CleanupAfterTaxiFlight();
}
BattlefieldStatusActive battlefieldStatus;
Global.BattlegroundMgr.BuildBattlegroundStatusActive(out battlefieldStatus, bg, GetPlayer(), battlefieldPort.Ticket.Id, GetPlayer().GetBattlegroundQueueJoinTime(bgQueueTypeId), bg.GetArenaType());
SendPacket(battlefieldStatus);
// remove BattlegroundQueue status from BGmgr
bgQueue.RemovePlayer(GetPlayer().GetGUID(), false);
// this is still needed here if Battleground"jumping" shouldn't add deserter debuff
// also this is required to prevent stuck at old Battlegroundafter SetBattlegroundId set to new
Battleground currentBg = GetPlayer().GetBattleground();
if (currentBg)
{
currentBg.RemovePlayerAtLeave(GetPlayer().GetGUID(), false, true);
}
// set the destination instance id
GetPlayer().SetBattlegroundId(bg.GetInstanceID(), bgTypeId);
// set the destination team
GetPlayer().SetBGTeam(ginfo.Team);
Global.BattlegroundMgr.SendToBattleground(GetPlayer(), ginfo.IsInvitedToBGInstanceGUID, bgTypeId);
Log.outDebug(LogFilter.Battleground, "Battleground: player {0} ({1}) joined battle for bg {2}, bgtype {3}, queue type {4}.", GetPlayer().GetName(), GetPlayer().GetGUID().ToString(), bg.GetInstanceID(), bg.GetTypeID(), bgQueueTypeId);
}
else // leave queue
{
// if player leaves rated arena match before match start, it is counted as he played but he lost
if (ginfo.IsRated && ginfo.IsInvitedToBGInstanceGUID != 0)
{
ArenaTeam at = Global.ArenaTeamMgr.GetArenaTeamById((uint)ginfo.Team);
if (at != null)
{
Log.outDebug(LogFilter.Battleground, "UPDATING memberLost's personal arena rating for {0} by opponents rating: {1}, because he has left queue!", GetPlayer().GetGUID().ToString(), ginfo.OpponentsTeamRating);
at.MemberLost(GetPlayer(), ginfo.OpponentsMatchmakerRating);
at.SaveToDB();
}
}
BattlefieldStatusNone battlefieldStatus = new BattlefieldStatusNone();
battlefieldStatus.Ticket = battlefieldPort.Ticket;
SendPacket(battlefieldStatus);
GetPlayer().RemoveBattlegroundQueueId(bgQueueTypeId); // must be called this way, because if you move this call to queue.removeplayer, it causes bugs
bgQueue.RemovePlayer(GetPlayer().GetGUID(), true);
// player left queue, we should update it - do not update Arena Queue
if (ginfo.ArenaType == 0)
{
Global.BattlegroundMgr.ScheduleQueueUpdate(ginfo.ArenaMatchmakerRating, ginfo.ArenaType, bgQueueTypeId, bgTypeId, bracketEntry.GetBracketId());
}
Log.outDebug(LogFilter.Battleground, "Battleground: player {0} ({1}) left queue for bgtype {2}, queue type {3}.", GetPlayer().GetName(), GetPlayer().GetGUID().ToString(), bg.GetTypeID(), bgQueueTypeId);
}
}
void HandleRequestBattlefieldStatus(RequestBattlefieldStatus packet)
{
// we must update all queues here
Battleground bg = null;
for (byte i = 0; i < SharedConst.MaxPlayerBGQueues; ++i)
{
BattlegroundQueueTypeId bgQueueTypeId = GetPlayer().GetBattlegroundQueueTypeId(i);
if (bgQueueTypeId == 0)
{
continue;
}
BattlegroundTypeId bgTypeId = Global.BattlegroundMgr.BGTemplateId(bgQueueTypeId);
ArenaTypes arenaType = Global.BattlegroundMgr.BGArenaType(bgQueueTypeId);
if (bgTypeId == GetPlayer().GetBattlegroundTypeId())
{
bg = GetPlayer().GetBattleground();
//i cannot check any variable from player class because player class doesn't know if player is in 2v2 / 3v3 or 5v5 arena
//so i must use bg pointer to get that information
if (bg && bg.GetArenaType() == arenaType)
{
BattlefieldStatusActive battlefieldStatus;
Global.BattlegroundMgr.BuildBattlegroundStatusActive(out battlefieldStatus, bg, GetPlayer(), i, GetPlayer().GetBattlegroundQueueJoinTime(bgQueueTypeId), arenaType);
SendPacket(battlefieldStatus);
continue;
}
}
//we are sending update to player about queue - he can be invited there!
//get GroupQueueInfo for queue status
BattlegroundQueue bgQueue = Global.BattlegroundMgr.GetBattlegroundQueue(bgQueueTypeId);
GroupQueueInfo ginfo;
if (!bgQueue.GetPlayerGroupInfoData(GetPlayer().GetGUID(), out ginfo))
{
continue;
}
if (ginfo.IsInvitedToBGInstanceGUID != 0)
{
bg = Global.BattlegroundMgr.GetBattleground(ginfo.IsInvitedToBGInstanceGUID, bgTypeId);
if (!bg)
{
continue;
}
BattlefieldStatusNeedConfirmation battlefieldStatus;
Global.BattlegroundMgr.BuildBattlegroundStatusNeedConfirmation(out battlefieldStatus, bg, GetPlayer(), i, GetPlayer().GetBattlegroundQueueJoinTime(bgQueueTypeId), Time.GetMSTimeDiff(Time.GetMSTime(), ginfo.RemoveInviteTime), arenaType);
SendPacket(battlefieldStatus);
}
else
{
bg = Global.BattlegroundMgr.GetBattlegroundTemplate(bgTypeId);
if (!bg)
{
continue;
}
// expected bracket entry
PvpDifficultyRecord bracketEntry = Global.DB2Mgr.GetBattlegroundBracketByLevel(bg.GetMapId(), GetPlayer().getLevel());
if (bracketEntry == null)
{
continue;
}
uint avgTime = bgQueue.GetAverageQueueWaitTime(ginfo, bracketEntry.GetBracketId());
BattlefieldStatusQueued battlefieldStatus;
Global.BattlegroundMgr.BuildBattlegroundStatusQueued(out battlefieldStatus, bg, GetPlayer(), i, GetPlayer().GetBattlegroundQueueJoinTime(bgQueueTypeId), avgTime, arenaType, ginfo.Players.Count > 1);
SendPacket(battlefieldStatus);
}
}
}
public void LogoutPlayer(bool save)
{
// finish pending transfers before starting the logout
while (_player && _player.IsBeingTeleportedFar())
{
HandleMoveWorldportAck();
}
m_playerLogout = true;
m_playerSave = save;
if (_player)
{
if (!_player.GetLootGUID().IsEmpty())
{
DoLootReleaseAll();
}
// If the player just died before logging out, make him appear as a ghost
//FIXME: logout must be delayed in case lost connection with client in time of combat
if (GetPlayer().GetDeathTimer() != 0)
{
_player.getHostileRefManager().deleteReferences();
_player.BuildPlayerRepop();
_player.RepopAtGraveyard();
}
else if (GetPlayer().HasAuraType(AuraType.SpiritOfRedemption))
{
// this will kill character by SPELL_AURA_SPIRIT_OF_REDEMPTION
_player.RemoveAurasByType(AuraType.ModShapeshift);
_player.KillPlayer();
_player.BuildPlayerRepop();
_player.RepopAtGraveyard();
}
else if (GetPlayer().HasPendingBind())
{
_player.RepopAtGraveyard();
_player.SetPendingBind(0, 0);
}
//drop a flag if player is carrying it
Battleground bg = GetPlayer().GetBattleground();
if (bg)
{
bg.EventPlayerLoggedOut(GetPlayer());
}
// Teleport to home if the player is in an invalid instance
if (!_player.m_InstanceValid && !_player.IsGameMaster())
{
_player.TeleportTo(_player.GetHomebind());
}
Global.OutdoorPvPMgr.HandlePlayerLeaveZone(_player, _player.GetZoneId());
for (uint i = 0; i < SharedConst.MaxPlayerBGQueues; ++i)
{
BattlegroundQueueTypeId bgQueueTypeId = GetPlayer().GetBattlegroundQueueTypeId(i);
if (bgQueueTypeId != 0)
{
_player.RemoveBattlegroundQueueId(bgQueueTypeId);
BattlegroundQueue queue = Global.BattlegroundMgr.GetBattlegroundQueue(bgQueueTypeId);
queue.RemovePlayer(_player.GetGUID(), true);
}
}
// Repop at GraveYard or other player far teleport will prevent saving player because of not present map
// Teleport player immediately for correct player save
while (_player.IsBeingTeleportedFar())
{
HandleMoveWorldportAck();
}
// If the player is in a guild, update the guild roster and broadcast a logout message to other guild members
Guild guild = Global.GuildMgr.GetGuildById(_player.GetGuildId());
if (guild)
{
guild.HandleMemberLogout(this);
}
// Remove pet
_player.RemovePet(null, PetSaveMode.AsCurrent, true);
// Clear whisper whitelist
_player.ClearWhisperWhiteList();
// empty buyback items and save the player in the database
// some save parts only correctly work in case player present in map/player_lists (pets, etc)
if (save)
{
for (int j = InventorySlots.BuyBackStart; j < InventorySlots.BuyBackEnd; ++j)
{
int eslot = j - InventorySlots.BuyBackStart;
_player.SetGuidValue(PlayerFields.InvSlotHead + (j * 4), ObjectGuid.Empty);
_player.SetUInt32Value(PlayerFields.BuyBackPrice1 + eslot, 0);
_player.SetUInt32Value(PlayerFields.BuyBackTimestamp1 + eslot, 0);
}
_player.SaveToDB();
}
// Leave all channels before player delete...
_player.CleanupChannels();
// If the player is in a group (or invited), remove him. If the group if then only 1 person, disband the group.
_player.UninviteFromGroup();
// remove player from the group if he is:
// a) in group; b) not in raid group; c) logging out normally (not being kicked or disconnected)
if (_player.GetGroup() && !_player.GetGroup().isRaidGroup() && m_Socket[(int)ConnectionType.Realm] != null)
{
_player.RemoveFromGroup();
}
//! Send update to group and reset stored max enchanting level
if (_player.GetGroup())
{
_player.GetGroup().SendUpdate();
_player.GetGroup().ResetMaxEnchantingLevel();
}
//! Broadcast a logout message to the player's friends
Global.SocialMgr.SendFriendStatus(_player, FriendsResult.Offline, _player.GetGUID(), true);
_player.RemoveSocial();
//! Call script hook before deletion
Global.ScriptMgr.OnPlayerLogout(GetPlayer());
//! Remove the player from the world
// the player may not be in the world when logging out
// e.g if he got disconnected during a transfer to another map
// calls to GetMap in this case may cause crashes
GetPlayer().CleanupsBeforeDelete();
Log.outInfo(LogFilter.Player, "Account: {0} (IP: {1}) Logout Character:[{2}] (GUID: {3}) Level: {4}",
GetAccountId(), GetRemoteAddress(), _player.GetName(), _player.GetGUID().ToString(), _player.getLevel());
Map map = GetPlayer().GetMap();
if (map != null)
{
map.RemovePlayerFromMap(GetPlayer(), true);
}
SetPlayer(null);
//! Send the 'logout complete' packet to the client
//! Client will respond by sending 3x CMSG_CANCEL_TRADE, which we currently dont handle
LogoutComplete logoutComplete = new LogoutComplete();
SendPacket(logoutComplete);
//! Since each account can only have one online character at any given time, ensure all characters for active account are marked as offline
PreparedStatement stmt = DB.Characters.GetPreparedStatement(CharStatements.UPD_ACCOUNT_ONLINE);
stmt.AddValue(0, GetAccountId());
DB.Characters.Execute(stmt);
}
if (m_Socket[(int)ConnectionType.Instance] != null)
{
m_Socket[(int)ConnectionType.Instance].CloseSocket();
m_Socket[(int)ConnectionType.Instance] = null;
}
m_playerLogout = false;
m_playerSave = false;
m_playerRecentlyLogout = true;
SetLogoutStartTime(0);
}
void Awake()
{
_battleGround = FindObjectOfType <Battleground>();
}
void HandleQuestgiverCompleteQuest(QuestGiverCompleteQuest packet)
{
bool autoCompleteMode = packet.FromScript; // 0 - standart complete quest mode with npc, 1 - auto-complete mode
Quest quest = Global.ObjectMgr.GetQuestTemplate(packet.QuestID);
if (quest == null)
{
return;
}
if (autoCompleteMode && !quest.HasFlag(QuestFlags.AutoComplete))
{
return;
}
WorldObject obj;
if (autoCompleteMode)
{
obj = GetPlayer();
}
else
{
obj = Global.ObjAccessor.GetObjectByTypeMask(GetPlayer(), packet.QuestGiverGUID, TypeMask.Unit | TypeMask.GameObject);
}
if (!obj)
{
return;
}
if (!autoCompleteMode)
{
if (!obj.HasInvolvedQuest(packet.QuestID))
{
return;
}
// some kind of WPE protection
if (!GetPlayer().CanInteractWithQuestGiver(obj))
{
return;
}
}
else
{
// Do not allow completing quests on other players.
if (packet.QuestGiverGUID != GetPlayer().GetGUID())
{
return;
}
}
if (!GetPlayer().CanSeeStartQuest(quest) && GetPlayer().GetQuestStatus(packet.QuestID) == QuestStatus.None)
{
Log.outError(LogFilter.Network, "Possible hacking attempt: Player {0} ({1}) tried to complete quest [entry: {2}] without being in possession of the quest!",
GetPlayer().GetName(), GetPlayer().GetGUID().ToString(), packet.QuestID);
return;
}
Battleground bg = GetPlayer().GetBattleground();
if (bg)
{
bg.HandleQuestComplete(packet.QuestID, GetPlayer());
}
if (GetPlayer().GetQuestStatus(packet.QuestID) != QuestStatus.Complete)
{
if (quest.IsRepeatable())
{
GetPlayer().PlayerTalkClass.SendQuestGiverRequestItems(quest, packet.QuestGiverGUID, GetPlayer().CanCompleteRepeatableQuest(quest), false);
}
else
{
GetPlayer().PlayerTalkClass.SendQuestGiverRequestItems(quest, packet.QuestGiverGUID, GetPlayer().CanRewardQuest(quest, false), false);
}
}
else
{
if (quest.HasQuestObjectiveType(QuestObjectiveType.Item)) // some items required
{
GetPlayer().PlayerTalkClass.SendQuestGiverRequestItems(quest, packet.QuestGiverGUID, GetPlayer().CanRewardQuest(quest, false), false);
}
else // no items required
{
GetPlayer().PlayerTalkClass.SendQuestGiverOfferReward(quest, packet.QuestGiverGUID, true);
}
}
}
public void BuildBattlegroundStatusNeedConfirmation(out BattlefieldStatusNeedConfirmation battlefieldStatus, Battleground bg, Player player, uint ticketId, uint joinTime, uint timeout, ArenaTypes arenaType)
{
battlefieldStatus = new BattlefieldStatusNeedConfirmation();
BuildBattlegroundStatusHeader(battlefieldStatus.Hdr, bg, player, ticketId, joinTime, bg.GetQueueId(), arenaType);
battlefieldStatus.Mapid = bg.GetMapId();
battlefieldStatus.Timeout = timeout;
battlefieldStatus.Role = 0;
}
public override void Run()
{
int statPvp = Battleground.QueueingStatus();
if (!Usefuls.IsInBattleground)
{
if (_deserter == null)
{
_deserter = new Spell(26013);
}
if (_deserter.HaveBuff)
{
return;
}
switch (statPvp)
{
case 0:
Thread.Sleep(100);
Fight.StopFight();
MovementManager.StopMove();
if (BattlegrounderSetting.CurrentSetting.RandomBattleground)
{
Battleground.JoinBattlegroundQueue(
BattlegroundId.RandomBattleground);
Logging.Write(Translate.Get(Translate.Id.JoinQueue) + " " +
Translate.Get(Translate.Id.RandomBattleground));
Thread.Sleep(500);
}
else
{
if (BattlegrounderSetting.CurrentSetting.AlteracValley)
{
Battleground.JoinBattlegroundQueue(
BattlegroundId.AlteracValley);
Logging.Write(Translate.Get(Translate.Id.JoinQueue) + " " +
Translate.Get(Translate.Id.AlteracValley) + ".");
Thread.Sleep(500);
}
if (BattlegrounderSetting.CurrentSetting.WarsongGulch)
{
Battleground.JoinBattlegroundQueue(
BattlegroundId.WarsongGulch);
Logging.Write(Translate.Get(Translate.Id.JoinQueue) + " " +
Translate.Get(Translate.Id.WarsongGulch) + ".");
Thread.Sleep(500);
}
if (BattlegrounderSetting.CurrentSetting.ArathiBasin)
{
Battleground.JoinBattlegroundQueue(
BattlegroundId.ArathiBasin);
Logging.Write(Translate.Get(Translate.Id.JoinQueue) + " " +
Translate.Get(Translate.Id.ArathiBasin) + ".");
Thread.Sleep(500);
}
if (BattlegrounderSetting.CurrentSetting.EyeoftheStorm)
{
Battleground.JoinBattlegroundQueue(
BattlegroundId.EyeoftheStorm);
Logging.Write(Translate.Get(Translate.Id.JoinQueue) + " " +
Translate.Get(Translate.Id.EyeoftheStorm) + ".");
Thread.Sleep(500);
}
if (BattlegrounderSetting.CurrentSetting.StrandoftheAncients)
{
Battleground.JoinBattlegroundQueue(
BattlegroundId.StrandoftheAncients);
Logging.Write(Translate.Get(Translate.Id.JoinQueue) + " " +
Translate.Get(Translate.Id.StrandoftheAncients) + ".");
Thread.Sleep(500);
}
if (BattlegrounderSetting.CurrentSetting.IsleofConquest)
{
Battleground.JoinBattlegroundQueue(
BattlegroundId.IsleofConquest);
Logging.Write(Translate.Get(Translate.Id.JoinQueue) + " " +
Translate.Get(Translate.Id.IsleofConquest) + ".");
Thread.Sleep(500);
}
if (BattlegrounderSetting.CurrentSetting.TwinPeaks)
{
Battleground.JoinBattlegroundQueue(
BattlegroundId.TwinPeaks);
Logging.Write(Translate.Get(Translate.Id.JoinQueue) + " " +
Translate.Get(Translate.Id.TwinPeaks) + ".");
Thread.Sleep(500);
}
if (BattlegrounderSetting.CurrentSetting.BattleforGilneas)
{
Battleground.JoinBattlegroundQueue(
BattlegroundId.BattleforGilneas);
Logging.Write(Translate.Get(Translate.Id.JoinQueue) + " " +
Translate.Get(Translate.Id.BattleforGilneas) + ".");
Thread.Sleep(500);
}
if (BattlegrounderSetting.CurrentSetting.TempleofKotmogu)
{
Battleground.JoinBattlegroundQueue(
BattlegroundId.TempleofKotmogu);
Logging.Write(Translate.Get(Translate.Id.JoinQueue) + " " +
Translate.Get(Translate.Id.TempleofKotmogu) + ".");
Thread.Sleep(500);
}
if (BattlegrounderSetting.CurrentSetting.SilvershardMines)
{
Battleground.JoinBattlegroundQueue(
BattlegroundId.SilvershardMines);
Logging.Write(Translate.Get(Translate.Id.JoinQueue) + " " +
Translate.Get(Translate.Id.SilvershardMines) + ".");
Thread.Sleep(500);
}
_requeuTimer = new Timer(_requeueingTime);
}
Thread.Sleep(1000);
Battleground.AcceptBattlefieldPortAll();
Thread.Sleep(1000);
break;
default:
if (BattlegrounderSetting.CurrentSetting.RequeueAfterXMinutes)
{
if (_requeuTimer == null)
{
_requeuTimer = new Timer(_requeueingTime);
}
if (_requeuTimer.IsReady)
{
int i = 2;
while (i > 0 && Battleground.QueueingStatus() != 0)
{
Lua.RunMacroText("/click MiniMapBattlefieldFrame /click DropDownList1Button2");
Lua.RunMacroText("/click MiniMapBattlefieldFrame");
Lua.RunMacroText("/click DropDownList1Button2");
i--;
}
_requeuTimer = new Timer(_requeueingTime);
Logging.Write(Translate.Get(Translate.Id.RequeueingInProcess));
}
}
Thread.Sleep(100);
Battleground.AcceptBattlefieldPortAll();
Thread.Sleep(3000);
break;
}
Thread.Sleep(300);
}
else
{
if (Battleground.IsFinishBattleground())
{
Battleground.ExitBattleground();
Logging.Write(Translate.Get(Translate.Id.Battleground_Ended));
Thread.Sleep(1000);
}
}
}
public void BuildBattlegroundStatusActive(out BattlefieldStatusActive battlefieldStatus, Battleground bg, Player player, uint ticketId, uint joinTime, ArenaTypes arenaType)
{
battlefieldStatus = new BattlefieldStatusActive();
BuildBattlegroundStatusHeader(battlefieldStatus.Hdr, bg, player, ticketId, joinTime, bg.GetQueueId(), arenaType);
battlefieldStatus.ShutdownTimer = bg.GetRemainingTime();
battlefieldStatus.ArenaFaction = (byte)(player.GetBGTeam() == Team.Horde ? TeamId.Horde : TeamId.Alliance);
battlefieldStatus.LeftEarly = false;
battlefieldStatus.StartTimer = bg.GetElapsedTime();
battlefieldStatus.Mapid = bg.GetMapId();
}
public Map CreateInstanceForPlayer(uint mapId, Player player, uint loginInstanceId = 0)
{
if (GetId() != mapId || player == null)
{
return(null);
}
Map map = null;
uint newInstanceId = 0; // instanceId of the resulting map
if (IsBattlegroundOrArena())
{
// instantiate or find existing bg map for player
// the instance id is set in Battlegroundid
newInstanceId = player.GetBattlegroundId();
if (newInstanceId == 0)
{
return(null);
}
map = Global.MapMgr.FindMap(mapId, newInstanceId);
if (map == null)
{
Battleground bg = player.GetBattleground();
if (bg)
{
map = CreateBattleground(newInstanceId, bg);
}
else
{
player.TeleportToBGEntryPoint();
return(null);
}
}
}
else if (!IsGarrison())
{
InstanceBind pBind = player.GetBoundInstance(GetId(), player.GetDifficultyID(GetEntry()));
InstanceSave pSave = pBind != null ? pBind.save : null;
// priority:
// 1. player's permanent bind
// 2. player's current instance id if this is at login
// 3. group's current bind
// 4. player's current bind
if (pBind == null || !pBind.perm)
{
if (loginInstanceId != 0) // if the player has a saved instance id on login, we either use this instance or relocate him out (return null)
{
map = FindInstanceMap(loginInstanceId);
return((map && map.GetId() == GetId()) ? map : null); // is this check necessary? or does MapInstanced only find instances of itself?
}
InstanceBind groupBind = null;
Group group = player.GetGroup();
// use the player's difficulty setting (it may not be the same as the group's)
if (group)
{
groupBind = group.GetBoundInstance(this);
if (groupBind != null)
{
// solo saves should be reset when entering a group's instance
player.UnbindInstance(GetId(), player.GetDifficultyID(GetEntry()));
pSave = groupBind.save;
}
}
}
if (pSave != null)
{
// solo/perm/group
newInstanceId = pSave.GetInstanceId();
map = FindInstanceMap(newInstanceId);
// it is possible that the save exists but the map doesn't
if (map == null)
{
map = CreateInstance(newInstanceId, pSave, pSave.GetDifficultyID(), player.GetTeamId());
}
}
else
{
// if no instanceId via group members or instance saves is found
// the instance will be created for the first time
newInstanceId = Global.MapMgr.GenerateInstanceId();
Difficulty diff = player.GetGroup() != null?player.GetGroup().GetDifficultyID(GetEntry()) : player.GetDifficultyID(GetEntry());
//Seems it is now possible, but I do not know if it should be allowed
map = FindInstanceMap(newInstanceId);
if (map == null)
{
map = CreateInstance(newInstanceId, null, diff, player.GetTeamId());
}
}
}
else
{
newInstanceId = (uint)player.GetGUID().GetCounter();
map = FindInstanceMap(newInstanceId);
if (!map)
{
map = CreateGarrison(newInstanceId, player);
}
}
return(map);
}
public void BuildBattlegroundStatusFailed(out BattlefieldStatusFailed battlefieldStatus, Battleground bg, Player pPlayer, uint ticketId, GroupJoinBattlegroundResult result, ObjectGuid errorGuid = default)
{
battlefieldStatus = new BattlefieldStatusFailed();
battlefieldStatus.Ticket.RequesterGuid = pPlayer.GetGUID();
battlefieldStatus.Ticket.Id = ticketId;
battlefieldStatus.Ticket.Type = RideType.Battlegrounds;
battlefieldStatus.Ticket.Time = (int)pPlayer.GetBattlegroundQueueJoinTime(bg.GetQueueId());
battlefieldStatus.QueueID = bg.GetQueueId().GetPacked();
battlefieldStatus.Reason = (int)result;
if (!errorGuid.IsEmpty() && (result == GroupJoinBattlegroundResult.NotInBattleground || result == GroupJoinBattlegroundResult.JoinTimedOut))
{
battlefieldStatus.ClientID = errorGuid;
}
}
public override bool Execute(ulong e_time, uint p_time)
{
Contract.Assert(Passenger.IsInWorld);
Contract.Assert(Target != null && Target.GetBase().IsInWorld);
Contract.Assert(Target.GetBase().HasAuraTypeWithCaster(AuraType.ControlVehicle, Passenger.GetGUID()));
Target.RemovePendingEventsForSeat(Seat.Key);
Target.RemovePendingEventsForPassenger(Passenger);
Passenger.SetVehicle(Target);
Seat.Value.Passenger.Guid = Passenger.GetGUID();
Seat.Value.Passenger.IsUnselectable = Passenger.HasFlag(UnitFields.Flags, UnitFlags.NotSelectable);
if (Seat.Value.SeatInfo.CanEnterOrExit())
{
Contract.Assert(Target.UsableSeatNum != 0);
--Target.UsableSeatNum;
if (Target.UsableSeatNum == 0)
{
if (Target.GetBase().IsTypeId(TypeId.Player))
{
Target.GetBase().RemoveFlag64(UnitFields.NpcFlags, NPCFlags.PlayerVehicle);
}
else
{
Target.GetBase().RemoveFlag64(UnitFields.NpcFlags, NPCFlags.SpellClick);
}
}
}
Passenger.InterruptNonMeleeSpells(false);
Passenger.RemoveAurasByType(AuraType.Mounted);
VehicleSeatRecord veSeat = Seat.Value.SeatInfo;
Player player = Passenger.ToPlayer();
if (player != null)
{
// drop flag
Battleground bg = player.GetBattleground();
if (bg)
{
bg.EventPlayerDroppedFlag(player);
}
player.StopCastingCharm();
player.StopCastingBindSight();
player.SendOnCancelExpectedVehicleRideAura();
if (!veSeat.FlagsB.HasAnyFlag(VehicleSeatFlagsB.KeepPet))
{
player.UnsummonPetTemporaryIfAny();
}
}
if (Seat.Value.SeatInfo.Flags.HasAnyFlag(VehicleSeatFlags.PassengerNotSelectable))
{
Passenger.SetFlag(UnitFields.Flags, UnitFlags.NotSelectable);
}
Passenger.m_movementInfo.transport.pos.Relocate(veSeat.AttachmentOffset.X, veSeat.AttachmentOffset.Y, veSeat.AttachmentOffset.Z);
Passenger.m_movementInfo.transport.time = 0;
Passenger.m_movementInfo.transport.seat = Seat.Key;
Passenger.m_movementInfo.transport.guid = Target.GetBase().GetGUID();
if (Target.GetBase().IsTypeId(TypeId.Unit) && Passenger.IsTypeId(TypeId.Player) &&
Seat.Value.SeatInfo.Flags.HasAnyFlag(VehicleSeatFlags.CanControl))
{
Contract.Assert(Target.GetBase().SetCharmedBy(Passenger, CharmType.Vehicle)); // SMSG_CLIENT_CONTROL
}
Passenger.SendClearTarget(); // SMSG_BREAK_TARGET
Passenger.SetControlled(true, UnitState.Root); // SMSG_FORCE_ROOT - In some cases we send SMSG_SPLINE_MOVE_ROOT here (for creatures)
// also adds MOVEMENTFLAG_ROOT
MoveSplineInit init = new MoveSplineInit(Passenger);
init.DisableTransportPathTransformations();
init.MoveTo(veSeat.AttachmentOffset.X, veSeat.AttachmentOffset.Y, veSeat.AttachmentOffset.Z, false, true);
init.SetFacing(0.0f);
init.SetTransportEnter();
init.Launch();
Creature creature = Target.GetBase().ToCreature();
if (creature != null)
{
if (creature.IsAIEnabled)
{
creature.GetAI().PassengerBoarded(Passenger, Seat.Key, true);
}
Global.ScriptMgr.OnAddPassenger(Target, Passenger, Seat.Key);
// Actually quite a redundant hook. Could just use OnAddPassenger and check for unit typemask inside script.
if (Passenger.HasUnitTypeMask(UnitTypeMask.Accessory))
{
Global.ScriptMgr.OnInstallAccessory(Target, Passenger.ToCreature());
}
}
return(true);
}
public void Update(uint diff)
{
m_UpdateTimer += diff;
if (m_UpdateTimer > 1000)
{
foreach (var data in bgDataStore.Values)
{
var bgs = data.m_Battlegrounds;
// first one is template and should not be deleted
foreach (var pair in bgs.ToList())
{
Battleground bg = pair.Value;
bg.Update(m_UpdateTimer);
if (bg.ToBeDeleted())
{
bgs.Remove(pair.Key);
var clients = data.m_ClientBattlegroundIds[(int)bg.GetBracketId()];
if (!clients.Empty())
{
clients.Remove(bg.GetClientInstanceID());
}
bg.Dispose();
}
}
}
m_UpdateTimer = 0;
}
// update events timer
foreach (var pair in m_BattlegroundQueues)
{
pair.Value.UpdateEvents(diff);
}
// update scheduled queues
if (!m_QueueUpdateScheduler.Empty())
{
List <ScheduledQueueUpdate> scheduled = new List <ScheduledQueueUpdate>();
Extensions.Swap(ref scheduled, ref m_QueueUpdateScheduler);
for (byte i = 0; i < scheduled.Count; i++)
{
uint arenaMMRating = scheduled[i].ArenaMatchmakerRating;
BattlegroundQueueTypeId bgQueueTypeId = scheduled[i].QueueId;
BattlegroundBracketId bracket_id = scheduled[i].BracketId;
GetBattlegroundQueue(bgQueueTypeId).BattlegroundQueueUpdate(diff, bracket_id, arenaMMRating);
}
}
// if rating difference counts, maybe force-update queues
if (WorldConfig.GetIntValue(WorldCfg.ArenaMaxRatingDifference) != 0 && WorldConfig.GetIntValue(WorldCfg.ArenaRatedUpdateTimer) != 0)
{
// it's time to force update
if (m_NextRatedArenaUpdate < diff)
{
// forced update for rated arenas (scan all, but skipped non rated)
Log.outDebug(LogFilter.Arena, "BattlegroundMgr: UPDATING ARENA QUEUES");
foreach (ArenaTypes teamSize in new[] { ArenaTypes.Team2v2, ArenaTypes.Team3v3, ArenaTypes.Team5v5 })
{
BattlegroundQueueTypeId ratedArenaQueueId = BGQueueTypeId((ushort)BattlegroundTypeId.AA, BattlegroundQueueIdType.Arena, true, teamSize);
for (var bracket = BattlegroundBracketId.First; bracket < BattlegroundBracketId.Max; ++bracket)
{
GetBattlegroundQueue(ratedArenaQueueId).BattlegroundQueueUpdate(diff, bracket, 0);
}
}
m_NextRatedArenaUpdate = WorldConfig.GetUIntValue(WorldCfg.ArenaRatedUpdateTimer);
}
else
{
m_NextRatedArenaUpdate -= diff;
}
}
}
// used to create the BG templates
bool CreateBattleground(BattlegroundTemplate bgTemplate)
{
Battleground bg = GetBattlegroundTemplate(bgTemplate.Id);
if (!bg)
{
// Create the BG
switch (bgTemplate.Id)
{
//case BattlegroundTypeId.AV:
// bg = new BattlegroundAV();
//break;
case BattlegroundTypeId.WS:
bg = new BgWarsongGluch();
break;
case BattlegroundTypeId.AB:
bg = new BgArathiBasin();
break;
case BattlegroundTypeId.NA:
bg = new NagrandArena();
break;
case BattlegroundTypeId.BE:
bg = new BladesEdgeArena();
break;
case BattlegroundTypeId.EY:
bg = new BgEyeofStorm();
break;
case BattlegroundTypeId.RL:
bg = new RuinsofLordaeronArena();
break;
case BattlegroundTypeId.SA:
bg = new BgStrandOfAncients();
break;
case BattlegroundTypeId.DS:
bg = new DalaranSewersArena();
break;
case BattlegroundTypeId.RV:
bg = new RingofValorArena();
break;
//case BattlegroundTypeId.IC:
//bg = new BattlegroundIC();
//break;
case BattlegroundTypeId.AA:
bg = new Battleground();
break;
case BattlegroundTypeId.RB:
bg = new Battleground();
bg.SetRandom(true);
break;
/*
* case BattlegroundTypeId.TP:
* bg = new BattlegroundTP();
* break;
* case BattlegroundTypeId.BFG:
* bg = new BattlegroundBFG();
* break;
*/
default:
return(false);
}
bg.SetTypeID(bgTemplate.Id);
}
bg.SetMapId((uint)bgTemplate.BattlemasterEntry.MapId[0]);
bg.SetName(bgTemplate.BattlemasterEntry.Name[Global.WorldMgr.GetDefaultDbcLocale()]);
bg.SetInstanceID(0);
bg.SetArenaorBGType(bgTemplate.IsArena());
bg.SetMinPlayersPerTeam(bgTemplate.MinPlayersPerTeam);
bg.SetMaxPlayersPerTeam(bgTemplate.MaxPlayersPerTeam);
bg.SetMinPlayers(bgTemplate.MinPlayersPerTeam * 2);
bg.SetMaxPlayers(bgTemplate.MaxPlayersPerTeam * 2);
bg.SetTeamStartPosition(TeamId.Alliance, bgTemplate.StartLocation[TeamId.Alliance]);
bg.SetTeamStartPosition(TeamId.Horde, bgTemplate.StartLocation[TeamId.Horde]);
bg.SetStartMaxDist(bgTemplate.StartMaxDist);
bg.SetLevelRange(bgTemplate.MinLevel, bgTemplate.MaxLevel);
bg.SetScriptId(bgTemplate.scriptId);
bg.SetQueueId((ulong)bgTemplate.Id | 0x1F10000000000000);
if (!bgDataStore.ContainsKey(bg.GetTypeID()))
{
bgDataStore[bg.GetTypeID()] = new BattlegroundData();
}
bgDataStore[bg.GetTypeID()].Template = bg;
return(true);
}
public static void DisplayInfo(CmdTrigger <RealmServerCmdArgs> trigger, Battleground bg)
{
trigger.Reply(bg.ToString());
trigger.Reply(" " + bg.GetTeam(BattlegroundSide.Alliance));
trigger.Reply(" " + bg.GetTeam(BattlegroundSide.Horde));
}
public void Update(uint diff)
{
m_UpdateTimer += diff;
if (m_UpdateTimer > 1000)
{
foreach (var data in bgDataStore.Values)
{
var bgs = data.m_Battlegrounds;
// first one is template and should not be deleted
foreach (var pair in bgs)
{
Battleground bg = pair.Value;
bg.Update(m_UpdateTimer);
if (bg.ToBeDeleted())
{
bgs.Remove(pair.Key);
var clients = data.m_ClientBattlegroundIds[(int)bg.GetBracketId()];
if (!clients.Empty())
{
clients.Remove(bg.GetClientInstanceID());
}
bg.Dispose();
}
}
}
m_UpdateTimer = 0;
}
// update events timer
for (var qtype = BattlegroundQueueTypeId.None; qtype < BattlegroundQueueTypeId.Max; ++qtype)
{
m_BattlegroundQueues[(int)qtype].UpdateEvents(diff);
}
// update scheduled queues
if (!m_QueueUpdateScheduler.Empty())
{
List <ulong> scheduled = new List <ulong>();
Extensions.Swap(ref scheduled, ref m_QueueUpdateScheduler);
for (byte i = 0; i < scheduled.Count; i++)
{
uint arenaMMRating = (uint)(scheduled[i] >> 32);
byte arenaType = (byte)(scheduled[i] >> 24 & 255);
BattlegroundQueueTypeId bgQueueTypeId = (BattlegroundQueueTypeId)(scheduled[i] >> 16 & 255);
BattlegroundTypeId bgTypeId = (BattlegroundTypeId)((scheduled[i] >> 8) & 255);
BattlegroundBracketId bracket_id = (BattlegroundBracketId)(scheduled[i] & 255);
m_BattlegroundQueues[(int)bgQueueTypeId].BattlegroundQueueUpdate(diff, bgTypeId, bracket_id, arenaType, arenaMMRating > 0, arenaMMRating);
}
}
// if rating difference counts, maybe force-update queues
if (WorldConfig.GetIntValue(WorldCfg.ArenaMaxRatingDifference) != 0 && WorldConfig.GetIntValue(WorldCfg.ArenaRatedUpdateTimer) != 0)
{
// it's time to force update
if (m_NextRatedArenaUpdate < diff)
{
// forced update for rated arenas (scan all, but skipped non rated)
Log.outDebug(LogFilter.Arena, "BattlegroundMgr: UPDATING ARENA QUEUES");
for (var qtype = BattlegroundQueueTypeId.Arena2v2; qtype <= BattlegroundQueueTypeId.Arena5v5; ++qtype)
{
for (int bracket = (int)BattlegroundBracketId.First; bracket < (int)BattlegroundBracketId.Max; ++bracket)
{
m_BattlegroundQueues[(int)qtype].BattlegroundQueueUpdate(diff,
BattlegroundTypeId.AA, (BattlegroundBracketId)bracket,
(byte)BGArenaType(qtype), true, 0);
}
}
m_NextRatedArenaUpdate = WorldConfig.GetUIntValue(WorldCfg.ArenaRatedUpdateTimer);
}
else
{
m_NextRatedArenaUpdate -= diff;
}
}
}
void HandleMoveWorldportAck()
{
Player player = GetPlayer();
// ignore unexpected far teleports
if (!player.IsBeingTeleportedFar())
{
return;
}
bool seamlessTeleport = player.IsBeingTeleportedSeamlessly();
player.SetSemaphoreTeleportFar(false);
// get the teleport destination
WorldLocation loc = player.GetTeleportDest();
// possible errors in the coordinate validity check
if (!GridDefines.IsValidMapCoord(loc))
{
LogoutPlayer(false);
return;
}
// get the destination map entry, not the current one, this will fix homebind and reset greeting
MapRecord mapEntry = CliDB.MapStorage.LookupByKey(loc.GetMapId());
InstanceTemplate mInstance = Global.ObjectMgr.GetInstanceTemplate(loc.GetMapId());
// reset instance validity, except if going to an instance inside an instance
if (!player.m_InstanceValid && mInstance == null)
{
player.m_InstanceValid = true;
}
Map oldMap = player.GetMap();
Map newMap = Global.MapMgr.CreateMap(loc.GetMapId(), player);
if (player.IsInWorld)
{
Log.outError(LogFilter.Network, $"Player (Name {player.GetName()}) is still in world when teleported from map {oldMap.GetId()} to new map {loc.GetMapId()}");
oldMap.RemovePlayerFromMap(player, false);
}
// relocate the player to the teleport destination
// the CannotEnter checks are done in TeleporTo but conditions may change
// while the player is in transit, for example the map may get full
if (newMap == null || newMap.CannotEnter(player) != 0)
{
Log.outError(LogFilter.Network, $"Map {loc.GetMapId()} could not be created for {(newMap ? newMap.GetMapName() : "Unknown")} ({player.GetGUID()}), porting player to homebind");
player.TeleportTo(player.GetHomebind());
return;
}
float z = loc.GetPositionZ() + player.GetHoverOffset();
player.Relocate(loc.GetPositionX(), loc.GetPositionY(), z, loc.GetOrientation());
player.SetFallInformation(0, player.GetPositionZ());
player.ResetMap();
player.SetMap(newMap);
ResumeToken resumeToken = new();
resumeToken.SequenceIndex = player.m_movementCounter;
resumeToken.Reason = seamlessTeleport ? 2 : 1u;
SendPacket(resumeToken);
if (!seamlessTeleport)
{
player.SendInitialPacketsBeforeAddToMap();
}
if (!player.GetMap().AddPlayerToMap(player, !seamlessTeleport))
{
Log.outError(LogFilter.Network, $"WORLD: failed to teleport player {player.GetName()} ({player.GetGUID()}) to map {loc.GetMapId()} ({(newMap ? newMap.GetMapName() : "Unknown")}) because of unknown reason!");
player.ResetMap();
player.SetMap(oldMap);
player.TeleportTo(player.GetHomebind());
return;
}
// Battleground state prepare (in case join to BG), at relogin/tele player not invited
// only add to bg group and object, if the player was invited (else he entered through command)
if (player.InBattleground())
{
// cleanup setting if outdated
if (!mapEntry.IsBattlegroundOrArena())
{
// We're not in BG
player.SetBattlegroundId(0, BattlegroundTypeId.None);
// reset destination bg team
player.SetBGTeam(0);
}
// join to bg case
else
{
Battleground bg = player.GetBattleground();
if (bg)
{
if (player.IsInvitedForBattlegroundInstance(player.GetBattlegroundId()))
{
bg.AddPlayer(player);
}
}
}
}
if (!seamlessTeleport)
{
player.SendInitialPacketsAfterAddToMap();
}
else
{
player.UpdateVisibilityForPlayer();
Garrison garrison = player.GetGarrison();
if (garrison != null)
{
garrison.SendRemoteInfo();
}
}
// flight fast teleport case
if (player.IsInFlight())
{
if (!player.InBattleground())
{
if (!seamlessTeleport)
{
// short preparations to continue flight
MovementGenerator movementGenerator = player.GetMotionMaster().GetCurrentMovementGenerator();
movementGenerator.Initialize(player);
}
return;
}
// Battlegroundstate prepare, stop flight
player.FinishTaxiFlight();
}
if (!player.IsAlive() && player.GetTeleportOptions().HasAnyFlag(TeleportToOptions.ReviveAtTeleport))
{
player.ResurrectPlayer(0.5f);
}
// resurrect character at enter into instance where his corpse exist after add to map
if (mapEntry.IsDungeon() && !player.IsAlive())
{
if (player.GetCorpseLocation().GetMapId() == mapEntry.Id)
{
player.ResurrectPlayer(0.5f, false);
player.SpawnCorpseBones();
}
}
if (mInstance != null)
{
// check if this instance has a reset time and send it to player if so
Difficulty diff = newMap.GetDifficultyID();
MapDifficultyRecord mapDiff = Global.DB2Mgr.GetMapDifficultyData(mapEntry.Id, diff);
if (mapDiff != null)
{
if (mapDiff.GetRaidDuration() != 0)
{
long timeReset = Global.InstanceSaveMgr.GetResetTimeFor(mapEntry.Id, diff);
if (timeReset != 0)
{
uint timeleft = (uint)(timeReset - GameTime.GetGameTime());
player.SendInstanceResetWarning(mapEntry.Id, diff, timeleft, true);
}
}
}
// check if instance is valid
if (!player.CheckInstanceValidity(false))
{
player.m_InstanceValid = false;
}
}
// update zone immediately, otherwise leave channel will cause crash in mtmap
player.GetZoneAndAreaId(out uint newzone, out uint newarea);
player.UpdateZone(newzone, newarea);
// honorless target
if (player.pvpInfo.IsHostile)
{
player.CastSpell(player, 2479, true);
}
// in friendly area
else if (player.IsPvP() && !player.HasPlayerFlag(PlayerFlags.InPVP))
{
player.UpdatePvP(false, false);
}
// resummon pet
player.ResummonPetTemporaryUnSummonedIfAny();
//lets process all delayed operations on successful teleport
player.ProcessDelayedOperations();
}
public void AddToBGFreeSlotQueue(BattlegroundTypeId bgTypeId, Battleground bg)
{
bgDataStore[bgTypeId].BGFreeSlotQueue.Insert(0, bg);
}
public void Start()
{
// Setup ----------------------------------------------------------------------
// For demo purpose I'm setting up two different game board layouts
var gameBoard1 = new GameBoardBasic();
var gameBoard2 = new GameBoardFancy();
IGameBoard gameBoard = gameBoard1;
// And two different parsers with slightly different syntax
Func <string, AppResult> parseCommandOriginal = InputParserOriginal.ParseCommand;
Func <string, AppResult> parseCommandSimplified = InputParserSimplified.ParseCommand;
var parseCommand = parseCommandOriginal;
var syntax = Syntax.Original;
Func <string> getKeyboardInput = KeyboardInput.ReadLine;
// Battleground (together with the BattleShip objects) holds all game logic
var battleground = new Battleground();
// Run game -------------------------------------------------------------------
battleground.Update(gameBoard.DisplayGameBoard, syntax);
AppResult result;
do
{
do
{
result = parseCommand(gameBoard.DisplayUserInput(getKeyboardInput));
switch (result.Command)
{
case Command.SwitchGameDisplay:
gameBoard = gameBoard.GameBoardName == "Basic" ? (IGameBoard)gameBoard2 : gameBoard1;
gameBoard.ClearScreen();
break;
case Command.SwitchInputSyntax:
parseCommand = parseCommand == parseCommandOriginal ? parseCommandSimplified : parseCommandOriginal;
syntax = syntax == Syntax.Original ? Syntax.Simplified : Syntax.Original;
gameBoard.ClearScreen();
break;
case Command.Shoot:
result = battleground.Shoot(result.InputParameter);
break;
}
battleground.Update(gameBoard.DisplayGameBoard, syntax);
gameBoard.ShowMessage(result);
} while (result.Command != Command.Exit &&
result.Command != Command.CancelGame &&
!battleground.GameWon());
if (battleground.GameWon())
{
result = gameBoard.GameWon();
}
if (result.Command == Command.CancelGame)
{
battleground.Cancel(gameBoard.DisplayGameBoard, syntax);
result = gameBoard.GameCancelled();
}
if (result.Command == Command.NewGame)
{
battleground = new Battleground();
battleground.Update(gameBoard.DisplayGameBoard, syntax);
}
} while (result.Command != Command.Exit);
gameBoard.WaitForKeyStrokeThenEnd();
}
void HandleAreaTrigger(AreaTriggerPkt packet)
{
Player player = GetPlayer();
if (player.IsInFlight())
{
Log.outDebug(LogFilter.Network, "HandleAreaTriggerOpcode: Player '{0}' (GUID: {1}) in flight, ignore Area Trigger ID:{2}",
player.GetName(), player.GetGUID().ToString(), packet.AreaTriggerID);
return;
}
AreaTriggerRecord atEntry = CliDB.AreaTriggerStorage.LookupByKey(packet.AreaTriggerID);
if (atEntry == null)
{
Log.outDebug(LogFilter.Network, "HandleAreaTriggerOpcode: Player '{0}' (GUID: {1}) send unknown (by DBC) Area Trigger ID:{2}",
player.GetName(), player.GetGUID().ToString(), packet.AreaTriggerID);
return;
}
if (packet.Entered && !player.IsInAreaTriggerRadius(atEntry))
{
Log.outDebug(LogFilter.Network, "HandleAreaTriggerOpcode: Player '{0}' ({1}) too far, ignore Area Trigger ID: {2}",
player.GetName(), player.GetGUID().ToString(), packet.AreaTriggerID);
return;
}
if (player.isDebugAreaTriggers)
{
player.SendSysMessage(packet.Entered ? CypherStrings.DebugAreatriggerEntered : CypherStrings.DebugAreatriggerLeft, packet.AreaTriggerID);
}
if (Global.ScriptMgr.OnAreaTrigger(player, atEntry, packet.Entered))
{
return;
}
if (player.IsAlive())
{
List <uint> quests = Global.ObjectMgr.GetQuestsForAreaTrigger(packet.AreaTriggerID);
if (quests != null)
{
foreach (uint questId in quests)
{
Quest qInfo = Global.ObjectMgr.GetQuestTemplate(questId);
if (qInfo != null && player.GetQuestStatus(questId) == QuestStatus.Incomplete)
{
foreach (QuestObjective obj in qInfo.Objectives)
{
if (obj.Type == QuestObjectiveType.AreaTrigger && !player.IsQuestObjectiveComplete(obj))
{
player.SetQuestObjectiveData(obj, 1);
player.SendQuestUpdateAddCreditSimple(obj);
break;
}
}
if (player.CanCompleteQuest(questId))
{
player.CompleteQuest(questId);
}
}
}
}
}
if (Global.ObjectMgr.IsTavernAreaTrigger(packet.AreaTriggerID))
{
// set resting flag we are in the inn
player.GetRestMgr().SetRestFlag(RestFlag.Tavern, atEntry.Id);
if (Global.WorldMgr.IsFFAPvPRealm())
{
player.RemoveByteFlag(UnitFields.Bytes2, UnitBytes2Offsets.PvpFlag, UnitBytes2Flags.FFAPvp);
}
return;
}
Battleground bg = player.GetBattleground();
if (bg)
{
bg.HandleAreaTrigger(player, packet.AreaTriggerID, packet.Entered);
}
OutdoorPvP pvp = player.GetOutdoorPvP();
if (pvp != null)
{
if (pvp.HandleAreaTrigger(player, packet.AreaTriggerID, packet.Entered))
{
return;
}
}
AreaTriggerStruct at = Global.ObjectMgr.GetAreaTrigger(packet.AreaTriggerID);
if (at == null)
{
return;
}
bool teleported = false;
if (player.GetMapId() != at.target_mapId)
{
EnterState denyReason = Global.MapMgr.PlayerCannotEnter(at.target_mapId, player, false);
if (denyReason != 0)
{
bool reviveAtTrigger = false; // should we revive the player if he is trying to enter the correct instance?
switch (denyReason)
{
case EnterState.CannotEnterNoEntry:
Log.outDebug(LogFilter.Maps, "MAP: Player '{0}' attempted to enter map with id {1} which has no entry", player.GetName(), at.target_mapId);
break;
case EnterState.CannotEnterUninstancedDungeon:
Log.outDebug(LogFilter.Maps, "MAP: Player '{0}' attempted to enter dungeon map {1} but no instance template was found", player.GetName(), at.target_mapId);
break;
case EnterState.CannotEnterDifficultyUnavailable:
{
Log.outDebug(LogFilter.Maps, "MAP: Player '{0}' attempted to enter instance map {1} but the requested difficulty was not found", player.GetName(), at.target_mapId);
MapRecord entry = CliDB.MapStorage.LookupByKey(at.target_mapId);
if (entry != null)
{
player.SendTransferAborted(entry.Id, TransferAbortReason.Difficulty, (byte)player.GetDifficultyID(entry));
}
}
break;
case EnterState.CannotEnterNotInRaid:
Log.outDebug(LogFilter.Maps, "MAP: Player '{0}' must be in a raid group to enter map {1}", player.GetName(), at.target_mapId);
player.SendRaidGroupOnlyMessage(RaidGroupReason.Only, 0);
reviveAtTrigger = true;
break;
case EnterState.CannotEnterCorpseInDifferentInstance:
player.SendPacket(new AreaTriggerNoCorpse());
Log.outDebug(LogFilter.Maps, "MAP: Player '{0}' does not have a corpse in instance map {1} and cannot enter", player.GetName(), at.target_mapId);
break;
case EnterState.CannotEnterInstanceBindMismatch:
{
MapRecord entry = CliDB.MapStorage.LookupByKey(at.target_mapId);
if (entry != null)
{
string mapName = entry.MapName[player.GetSession().GetSessionDbcLocale()];
Log.outDebug(LogFilter.Maps, "MAP: Player '{0}' cannot enter instance map '{1}' because their permanent bind is incompatible with their group's", player.GetName(), mapName);
// is there a special opcode for this?
// @todo figure out how to get player localized difficulty string (e.g. "10 player", "Heroic" etc)
player.SendSysMessage(CypherStrings.InstanceBindMismatch, mapName);
}
reviveAtTrigger = true;
}
break;
case EnterState.CannotEnterTooManyInstances:
player.SendTransferAborted(at.target_mapId, TransferAbortReason.TooManyInstances);
Log.outDebug(LogFilter.Maps, "MAP: Player '{0}' cannot enter instance map {1} because he has exceeded the maximum number of instances per hour.", player.GetName(), at.target_mapId);
reviveAtTrigger = true;
break;
case EnterState.CannotEnterMaxPlayers:
player.SendTransferAborted(at.target_mapId, TransferAbortReason.MaxPlayers);
reviveAtTrigger = true;
break;
case EnterState.CannotEnterZoneInCombat:
player.SendTransferAborted(at.target_mapId, TransferAbortReason.ZoneInCombat);
reviveAtTrigger = true;
break;
default:
break;
}
if (reviveAtTrigger) // check if the player is touching the areatrigger leading to the map his corpse is on
{
if (!player.IsAlive() && player.HasCorpse())
{
if (player.GetCorpseLocation().GetMapId() == at.target_mapId)
{
player.ResurrectPlayer(0.5f);
player.SpawnCorpseBones();
}
}
}
return;
}
Group group = player.GetGroup();
if (group)
{
if (group.isLFGGroup() && player.GetMap().IsDungeon())
{
teleported = player.TeleportToBGEntryPoint();
}
}
}
if (!teleported)
{
WorldSafeLocsRecord entranceLocation = null;
InstanceSave instanceSave = player.GetInstanceSave(at.target_mapId);
if (instanceSave != null)
{
// Check if we can contact the instancescript of the instance for an updated entrance location
Map map = Global.MapMgr.FindMap(at.target_mapId, player.GetInstanceSave(at.target_mapId).GetInstanceId());
if (map)
{
InstanceMap instanceMap = map.ToInstanceMap();
if (instanceMap != null)
{
InstanceScript instanceScript = instanceMap.GetInstanceScript();
if (instanceScript != null)
{
entranceLocation = CliDB.WorldSafeLocsStorage.LookupByKey(instanceScript.GetEntranceLocation());
}
}
}
// Finally check with the instancesave for an entrance location if we did not get a valid one from the instancescript
if (entranceLocation == null)
{
entranceLocation = CliDB.WorldSafeLocsStorage.LookupByKey(instanceSave.GetEntranceLocation());
}
}
if (entranceLocation != null)
{
player.TeleportTo(entranceLocation.MapID, entranceLocation.Loc.X, entranceLocation.Loc.Y, entranceLocation.Loc.Z, (float)(entranceLocation.Facing * Math.PI / 180), TeleportToOptions.NotLeaveTransport);
}
else
{
player.TeleportTo(at.target_mapId, at.target_X, at.target_Y, at.target_Z, at.target_Orientation, TeleportToOptions.NotLeaveTransport);
}
}
}
public bool RewardHonor(Unit victim, uint groupsize, int honor = -1, bool pvptoken = false)
{
// do not reward honor in arenas, but enable onkill spellproc
if (InArena())
{
if (!victim || victim == this || !victim.IsTypeId(TypeId.Player))
{
return(false);
}
if (GetBGTeam() == victim.ToPlayer().GetBGTeam())
{
return(false);
}
return(true);
}
// 'Inactive' this aura prevents the player from gaining honor points and BattlegroundTokenizer
if (HasAura(BattlegroundConst.SpellAuraPlayerInactive))
{
return(false);
}
ObjectGuid victim_guid = ObjectGuid.Empty;
uint victim_rank = 0;
// need call before fields update to have chance move yesterday data to appropriate fields before today data change.
UpdateHonorFields();
// do not reward honor in arenas, but return true to enable onkill spellproc
if (InBattleground() && GetBattleground() && GetBattleground().IsArena())
{
return(true);
}
// Promote to float for calculations
float honor_f = honor;
if (honor_f <= 0)
{
if (!victim || victim == this || victim.HasAuraType(AuraType.NoPvpCredit))
{
return(false);
}
victim_guid = victim.GetGUID();
Player plrVictim = victim.ToPlayer();
if (plrVictim)
{
if (GetTeam() == plrVictim.GetTeam() && !Global.WorldMgr.IsFFAPvPRealm())
{
return(false);
}
byte k_level = (byte)GetLevel();
byte k_grey = (byte)Formulas.GetGrayLevel(k_level);
byte v_level = (byte)victim.GetLevelForTarget(this);
if (v_level <= k_grey)
{
return(false);
}
// PLAYER_CHOSEN_TITLE VALUES DESCRIPTION
// [0] Just name
// [1..14] Alliance honor titles and player name
// [15..28] Horde honor titles and player name
// [29..38] Other title and player name
// [39+] Nothing
// this is all wrong, should be going off PvpTitle, not PlayerTitle
uint victim_title = plrVictim.m_playerData.PlayerTitle;
// Get Killer titles, CharTitlesEntry.bit_index
// Ranks:
// title[1..14] . rank[5..18]
// title[15..28] . rank[5..18]
// title[other] . 0
if (victim_title == 0)
{
victim_guid.Clear(); // Don't show HK: <rank> message, only log.
}
else if (victim_title < 15)
{
victim_rank = victim_title + 4;
}
else if (victim_title < 29)
{
victim_rank = victim_title - 14 + 4;
}
else
{
victim_guid.Clear(); // Don't show HK: <rank> message, only log.
}
honor_f = (float)Math.Ceiling(Formulas.HKHonorAtLevelF(k_level) * (v_level - k_grey) / (k_level - k_grey));
// count the number of playerkills in one day
ApplyModUpdateFieldValue(m_values.ModifyValue(m_activePlayerData).ModifyValue(m_activePlayerData.TodayHonorableKills), (ushort)1, true);
// and those in a lifetime
ApplyModUpdateFieldValue(m_values.ModifyValue(m_activePlayerData).ModifyValue(m_activePlayerData.LifetimeHonorableKills), 1u, true);
UpdateCriteria(CriteriaTypes.EarnHonorableKill);
UpdateCriteria(CriteriaTypes.HkClass, (uint)victim.GetClass());
UpdateCriteria(CriteriaTypes.HkRace, (uint)victim.GetRace());
UpdateCriteria(CriteriaTypes.HonorableKillAtArea, GetAreaId());
UpdateCriteria(CriteriaTypes.HonorableKill, 1, 0, 0, victim);
}
else
{
if (!victim.ToCreature().IsRacialLeader())
{
return(false);
}
honor_f = 100.0f; // ??? need more info
victim_rank = 19; // HK: Leader
}
}
if (victim != null)
{
if (groupsize > 1)
{
honor_f /= groupsize;
}
// apply honor multiplier from aura (not stacking-get highest)
MathFunctions.AddPct(ref honor_f, GetMaxPositiveAuraModifier(AuraType.ModHonorGainPct));
honor_f += _restMgr.GetRestBonusFor(RestTypes.Honor, (uint)honor_f);
}
honor_f *= WorldConfig.GetFloatValue(WorldCfg.RateHonor);
// Back to int now
honor = (int)honor_f;
// honor - for show honor points in log
// victim_guid - for show victim name in log
// victim_rank [1..4] HK: <dishonored rank>
// victim_rank [5..19] HK: <alliance\horde rank>
// victim_rank [0, 20+] HK: <>
PvPCredit data = new PvPCredit();
data.Honor = honor;
data.OriginalHonor = honor;
data.Target = victim_guid;
data.Rank = victim_rank;
SendPacket(data);
AddHonorXP((uint)honor);
if (InBattleground() && honor > 0)
{
Battleground bg = GetBattleground();
if (bg != null)
{
bg.UpdatePlayerScore(this, ScoreType.BonusHonor, (uint)honor, false); //false: prevent looping
}
}
if (WorldConfig.GetBoolValue(WorldCfg.PvpTokenEnable) && pvptoken)
{
if (!victim || victim == this || victim.HasAuraType(AuraType.NoPvpCredit))
{
return(true);
}
if (victim.IsTypeId(TypeId.Player))
{
// Check if allowed to receive it in current map
int MapType = WorldConfig.GetIntValue(WorldCfg.PvpTokenMapType);
if ((MapType == 1 && !InBattleground() && !IsFFAPvP()) ||
(MapType == 2 && !IsFFAPvP()) ||
(MapType == 3 && !InBattleground()))
{
return(true);
}
uint itemId = WorldConfig.GetUIntValue(WorldCfg.PvpTokenId);
uint count = WorldConfig.GetUIntValue(WorldCfg.PvpTokenCount);
if (AddItem(itemId, count))
{
SendSysMessage("You have been awarded a token for slaying another player.");
}
}
}
return(true);
}
public static void SendPvpData(IPacketReceiver reciever, BattlegroundSide side, Battleground bg)
{
bg.EnsureContext();
using (RealmPacketOut packet =
new RealmPacketOut(RealmServerOpCode.MSG_PVP_LOG_DATA, 10 + bg.PlayerCount * 40))
{
BattlegroundTeam winner = bg.Winner;
packet.Write(bg.IsArena);
if (bg.IsArena)
{
for (int index = 0; index < 2; ++index)
{
packet.Write(0);
packet.Write(3999);
packet.Write(0);
}
packet.WriteCString(string.Empty);
packet.WriteCString(string.Empty);
}
bool flag = bg.Winner != null;
packet.Write(flag);
if (flag)
{
packet.Write((byte)bg.Winner.Side);
}
List <Character> characters = bg.Characters;
List <BattlegroundStats> listStats = new List <BattlegroundStats>(characters.Count);
characters.ForEach(chr => listStats.Add(chr.Battlegrounds.Stats));
packet.Write(listStats.Count);
for (int index = 0; index < listStats.Count; ++index)
{
Character character = characters[index];
if (character.IsInBattleground)
{
BattlegroundStats stats = character.Battlegrounds.Stats;
packet.Write(character.EntityId);
packet.Write(stats.KillingBlows);
if (bg.IsArena)
{
packet.Write(winner != null && character.Battlegrounds.Team == winner);
}
else
{
packet.Write(stats.HonorableKills);
packet.Write(stats.Deaths);
packet.Write(stats.BonusHonor);
}
packet.Write(stats.TotalDamage);
packet.Write(stats.TotalHealing);
packet.Write(stats.SpecialStatCount);
stats.WriteSpecialStats(packet);
}
}
reciever.Send(packet, false);
}
}
