API tools faq
paste
Advertisement
AhmedKorwash

TeamArena.cs

AhmedKorwash
Dec 24th, 2015
205
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C# 72.32 KB | None | 0 0
raw download clone embed print report
  1. /*
  2.  * The following code belongs to Ultimation and impulse.
  3.  * Ultimation is credited for most of this piece of code.
  4.  * Thanks to him, we have arena implented.
  5.  * */
  6. using System;
  7. using System.Collections.Generic;
  8. using System.Linq;
  9. using System.Text;
  10. using System.IO;
  11. using AhmedKorwash.Client;
  12. using AhmedKorwash.Network.GamePackets;
  13. using System.Threading;
  14. using System.Globalization;
  15. using System.Collections.Concurrent;
  16. using AhmedKorwash.Game;
  17. using System.Drawing;
  18.  
  19. namespace AhmedKorwash.Game
  20. {
  21.     public class TeamArena
  22.     {
  23.         public static ConcurrentDictionary<uint, GameState> PlayerList = new ConcurrentDictionary<uint, GameState>();
  24.         public static ConcurrentDictionary<uint, GameState> WaitingPlayerList = new ConcurrentDictionary<uint, GameState>();
  25.  
  26.         public static ConcurrentDictionary<uint, TeamArenaStatistic> ArenaStatistics = new ConcurrentDictionary<uint, TeamArenaStatistic>();
  27.  
  28.         public static SafeDictionary<uint, TeamArenaStatistic> YesterdayArenaStatistics = new SafeDictionary<uint, TeamArenaStatistic>();
  29.  
  30.         public static List<TeamArenaStatistic> ArenaStatisticsList, YesterdayArenaStatisticsList;
  31.  
  32.         public static int InArenaCount = 0, HistoryArenaCount = 0;
  33.  
  34.         public static void Sort()
  35.         {
  36.             var where = ArenaStatistics.Values;//.Where((a) => a.TodayWin != 0 || a.TodayBattles != 0);
  37.             List<TeamArenaStatistic> stats = where.OrderByDescending((p) => p.ArenaPoints).ToList();
  38.             InArenaCount = stats.Count;
  39.             for (uint i = 0; i < stats.Count; i++)
  40.                 stats[(int)i].Rank = i + 1;
  41.             ArenaStatisticsList = stats;
  42.         }
  43.         public static void YesterdaySort()
  44.         {
  45.             var where = ArenaStatistics.Values.Where((a) => a.LastSeasonWin != 0 || a.LastSeasonLose != 0);
  46.             List<TeamArenaStatistic> stats = where.OrderByDescending((p) => p.LastSeasonArenaPoints).ToList();
  47.             HistoryArenaCount = stats.Count;
  48.             for (uint i = 0; i < stats.Count; i++)
  49.                 stats[(int)i].LastSeasonRank = i + 1;
  50.             YesterdayArenaStatisticsList = stats;
  51.         }
  52.  
  53.         private static void SaveArenaStats()
  54.         {
  55.             var array = ArenaStatistics.Values.ToArray();
  56.             foreach (TeamArenaStatistic stats in array)
  57.                 if (stats != null)
  58.                     Database.TeamArenaTable.SaveArenaStatistics(stats);
  59.         }
  60.  
  61.         public static class QualifierList
  62.         {
  63.             public static ConcurrentDictionary<uint, QualifierGroup> Groups = new ConcurrentDictionary<uint, QualifierGroup>();
  64.             public static Counter GroupCounter = new Counter();
  65.  
  66.             public static byte[] BuildPacket(ushort page)
  67.             {
  68.                 MemoryStream strm = new MemoryStream();
  69.                 BinaryWriter wtr = new BinaryWriter(strm);
  70.                 wtr.Write((ushort)0);
  71.                 wtr.Write((ushort)2242);
  72.                 wtr.Write((uint)page);
  73.                 wtr.Write((uint)Game.Enums.ArenaIDs.QualifierList);
  74.                 wtr.Write((uint)Groups.Count);
  75.                 wtr.Write((uint)PlayerList.Count);
  76.                 page--;
  77.                 wtr.Write((uint)(Groups.Count - page));
  78.                 QualifierGroup[] GroupsList = Groups.Values.ToArray();
  79.                 for (int count = page; count < page + 6; count++)
  80.                 {
  81.                     if (count >= Groups.Count)
  82.                         break;
  83.  
  84.                     QualifierGroup entry = GroupsList[count];
  85.  
  86.                     wtr.Write((uint)(entry.Player1.TeamArenaStatistic.EntityID));
  87.                     byte[] array = Encoding.Default.GetBytes(entry.Player1.TeamArenaStatistic.Name);
  88.                     for (int i = 0; i < 16; i++)
  89.                     {
  90.                         if (i < entry.Player1.TeamArenaStatistic.Name.Length)
  91.                         {
  92.                             wtr.Write(array[i]);
  93.                         }
  94.                         else
  95.                             wtr.Write((byte)0);
  96.                     }
  97.                     uint player1Teammates = 0;
  98.                     if (entry.Player1.Team != null)
  99.                         if (entry.Player1.Team.Teammates != null)
  100.                             player1Teammates = (uint)entry.Player1.Team.Teammates.Length;
  101.                     wtr.Write(player1Teammates);
  102.                     wtr.Write((uint)entry.Player2.TeamArenaStatistic.EntityID);
  103.                     byte[] array2 = Encoding.Default.GetBytes(entry.Player2.TeamArenaStatistic.Name);
  104.                     for (int i = 0; i < 16; i++)
  105.                     {
  106.                         if (i < entry.Player2.TeamArenaStatistic.Name.Length)
  107.                         {
  108.                             wtr.Write(array2[i]);
  109.                         }
  110.                         else
  111.                             wtr.Write((byte)0);
  112.                     }
  113.  
  114.                     uint player2Teammates = 0;
  115.                     if (entry.Player2.Team != null)
  116.                         if (entry.Player2.Team.Teammates != null)
  117.                             player2Teammates = (uint)entry.Player2.Team.Teammates.Length;
  118.                     wtr.Write(player2Teammates);
  119.                 }
  120.                 GroupsList = null;
  121.                 int packetlength = (int)strm.Length;
  122.                 strm.Position = 0;
  123.                 wtr.Write((ushort)packetlength);
  124.                 strm.Position = strm.Length;
  125.                 wtr.Write(Encoding.Default.GetBytes("TQServer"));
  126.                 strm.Position = 0;
  127.                 byte[] buf = new byte[strm.Length];
  128.                 strm.Read(buf, 0, buf.Length);
  129.                 wtr.Close();
  130.                 strm.Close();
  131.                 return buf;
  132.             }
  133.  
  134.             public class QualifierParticipants
  135.             {
  136.                 public enum KindOfParticipants : ushort
  137.                 {
  138.                     Neutral = 0,
  139.                     Opponents = 1
  140.                 }
  141.                 private ICollection<Client.GameState> Players;
  142.                 private ushort id;
  143.                 private byte[] built;
  144.  
  145.                 public QualifierParticipants(Client.GameState player, KindOfParticipants kind)
  146.                 {
  147.                     id = (ushort)kind;
  148.                     Players = player.Team.Teammates;
  149.                 }
  150.                 public byte[] Build(uint uid)
  151.                 {
  152.                     if (built != null)
  153.                     {
  154.                         Network.Writer.WriteUInt32(uid, 8, built);
  155.                         return built;
  156.                     }
  157.                     else
  158.                     {
  159.                         uint correctPlayers = (uint)Players.Count;
  160.                         MemoryStream strm = new MemoryStream();
  161.                         BinaryWriter wtr = new BinaryWriter(strm);
  162.                         wtr.Write((ushort)0);
  163.                         wtr.Write((ushort)2247);
  164.                         wtr.Write((uint)id);
  165.                         wtr.Write(uid);
  166.                         wtr.Write((uint)0);
  167.                         foreach (Client.GameState client in Players)
  168.                         {
  169.                             if (id == (ushort)KindOfParticipants.Opponents)
  170.                             {
  171.                                 if (client.TeamQualifierGroup == null)
  172.                                 {
  173.                                     correctPlayers--;
  174.                                     continue;
  175.                                 }
  176.                             }
  177.  
  178.                             wtr.Write((uint)client.Entity.UID);
  179.                             wtr.Write((uint)client.Entity.Level);
  180.                             wtr.Write((uint)client.Entity.Class);
  181.                             wtr.Write((uint)client.Entity.Body / 1000);
  182.                             wtr.Write((uint)client.TeamArenaStatistic.Rank);
  183.                             wtr.Write((uint)client.ArenaPoints);
  184.                             for (int i = 0; i < 16; i++)
  185.                             {
  186.                                 if (i < client.TeamArenaStatistic.Name.Length)
  187.                                 {
  188.                                     wtr.Write((byte)client.TeamArenaStatistic.Name[i]);
  189.                                 }
  190.                                 else
  191.                                     wtr.Write((byte)0);
  192.                             }
  193.                         }
  194.                         int packetlength = (int)strm.Length;
  195.                         strm.Position = 0;
  196.                         wtr.Write((ushort)packetlength);
  197.                         strm.Position = strm.Length;
  198.                         wtr.Write(Encoding.Default.GetBytes("TQServer"));
  199.                         strm.Position = 0;
  200.                         byte[] buf = new byte[strm.Length];
  201.                         strm.Read(buf, 0, buf.Length);
  202.                         wtr.Close();
  203.                         strm.Close();
  204.                         built = buf;
  205.                         Network.Writer.WriteUInt32(correctPlayers, 12, buf);
  206.                         return buf;
  207.                     }
  208.                 }
  209.             }
  210.  
  211.             public class QualifierGroup
  212.             {
  213.                 #region Watchers
  214.                 public byte[] BuildWatcherPacket(ushort id = 0, uint uid = 0)
  215.                 {
  216.                     MemoryStream strm = new MemoryStream();
  217.                     BinaryWriter wtr = new BinaryWriter(strm);
  218.                     wtr.Write((ushort)38);
  219.                     wtr.Write((ushort)2211);
  220.                     wtr.Write((ushort)id);
  221.                     wtr.Write((uint)5);
  222.                     wtr.Write((uint)uid);
  223.                     wtr.Write((uint)0);
  224.                     wtr.Write((uint)Player1Cheers);
  225.                     wtr.Write((uint)Player2Cheers);
  226.                     int packetlength = (int)strm.Length;
  227.                     strm.Position = 0;
  228.                     wtr.Write((ushort)packetlength);
  229.                     strm.Position = strm.Length;
  230.                     wtr.Write(Encoding.Default.GetBytes("TQServer"));
  231.                     strm.Position = 0;
  232.                     byte[] buf = new byte[strm.Length];
  233.                     strm.Read(buf, 0, buf.Length);
  234.                     wtr.Close();
  235.                     strm.Close();
  236.                     return buf;
  237.                 }
  238.                 public byte[] BuildWatcherPacket(ICollection<Client.GameState> list, ushort id = 2, uint uid = 0)
  239.                 {
  240.                     MemoryStream strm = new MemoryStream();
  241.                     BinaryWriter wtr = new BinaryWriter(strm);
  242.                     wtr.Write((ushort)38);
  243.                     wtr.Write((ushort)2211);
  244.                     wtr.Write((ushort)id);
  245.                     wtr.Write((uint)5);
  246.                     wtr.Write((uint)list.Count);
  247.                     wtr.Write((uint)uid);
  248.                     wtr.Write((uint)Player1Cheers);
  249.                     wtr.Write((uint)Player2Cheers);
  250.                     foreach (Client.GameState client in list)
  251.                     {
  252.                         wtr.Write((uint)client.Entity.Mesh);
  253.                         for (int i = 0; i < 16; i++)
  254.                         {
  255.                             if (i < client.ArenaStatistic.Name.Length)
  256.                             {
  257.                                 wtr.Write((byte)client.ArenaStatistic.Name[i]);
  258.                             }
  259.                             else
  260.                                 wtr.Write((byte)0);
  261.                         }
  262.                         wtr.Write((uint)0);
  263.                         wtr.Write((uint)0);
  264.                         wtr.Write((uint)0);
  265.                         wtr.Write((uint)0);
  266.                     }
  267.                     int packetlength = (int)strm.Length;
  268.                     strm.Position = 0;
  269.                     wtr.Write((ushort)packetlength);
  270.                     strm.Position = strm.Length;
  271.                     wtr.Write(Encoding.Default.GetBytes("TQServer"));
  272.                     strm.Position = 0;
  273.                     byte[] buf = new byte[strm.Length];
  274.                     strm.Read(buf, 0, buf.Length);
  275.                     wtr.Close();
  276.                     strm.Close();
  277.                     return buf;
  278.                 }
  279.                 public void BeginWatching(Client.GameState client)
  280.                 {
  281.                     if (!client.Entity.Dead && client.WatchingGroup == null && client.TeamQualifierGroup == null)
  282.                     {
  283.                         client.Send(BuildWatcherPacket());
  284.                         client.Send(this.MatchPacket.BuildPacket());
  285.  
  286.                         Watchers.Add(client);
  287.                         byte[] data = BuildWatcherPacket(Watchers);
  288.                         foreach (Client.GameState client2 in Watchers)
  289.                             client.Send(data);
  290.                         Player1.Team.SendMessage(data);
  291.                         Player2.Team.SendMessage(data);
  292.                         client.TeamWatchingGroup = this;
  293.                         client.Entity.Teleport(1005, dynamicMap.ID, (ushort)Kernel.Random.Next(35, 70), (ushort)Kernel.Random.Next(35, 70));
  294.                     }
  295.                 }
  296.                 public List<Client.GameState> Watchers = new List<GameState>();
  297.                 #endregion
  298.  
  299.                 public Time32 CreateTime;
  300.                 public Time32 DoneStamp;
  301.  
  302.                 public uint Player1Damage, Player2Damage;
  303.                 public uint Player1Cheers, Player2Cheers;
  304.  
  305.                 public List<uint> Cheerers = new List<uint>();
  306.  
  307.                 public bool Inside;
  308.                 public bool Done, Finished;
  309.  
  310.                 public uint ID;
  311.  
  312.                 public GroupMatch MatchPacket = new GroupMatch();
  313.  
  314.                 public Client.GameState Winner, Loser;
  315.                 public Client.GameState Player1, Player2;
  316.  
  317.                 private Map dynamicMap;
  318.                 public Time32 ImportTime;
  319.                 public QualifierGroup(Client.GameState player1, Client.GameState player2)
  320.                 {
  321.                     Player1 = player1;
  322.                     Player2 = player2;
  323.                     CreateTime = Time32.Now;
  324.                     Inside = false;
  325.                     Player1Damage = 0;
  326.                     Player2Damage = 0;
  327.                     Done = false;
  328.                     ID = GroupCounter.Next;
  329.                     MatchPacket.Group = this;
  330.                     Done = false;
  331.                     Inside = false;
  332.                     Finished = false;
  333.                     Groups.Add(ID, this);
  334.                 }
  335.  
  336.                 public void Import()
  337.                 {
  338.                     Inside = true;
  339.  
  340.                     if (!Kernel.Maps.ContainsKey(700))
  341.                         new Map(700, Database.DMaps.MapPaths[700]);
  342.                     Map origMap = Kernel.Maps[700];
  343.                     dynamicMap = origMap.MakeDynamicMap();
  344.  
  345.  
  346.                     foreach (var team1Player in Player1.Team.Teammates)
  347.                     {
  348.                         if (CanFight(team1Player))
  349.                         {
  350.                             if (team1Player.Entity.MyJiang != null)
  351.                             {
  352.                                 if (team1Player.Entity.MyJiang.OnJiangMode)
  353.                                 {
  354.                                     team1Player.Entity.PKMode = Enums.PKMode.Capture;
  355.                                     team1Player.Entity.MyJiang.OnJiangMode = false;
  356.                                     team1Player.Entity.MyJiang.SendStatusMode(team1Player);
  357.  
  358.                                 }
  359.                             }
  360.                             var x = (ushort)Kernel.Random.Next(35, 70);
  361.                             var y = (ushort)Kernel.Random.Next(35, 70);
  362.                             team1Player.Entity.Teleport(origMap.ID, dynamicMap.ID, x, y);
  363.                             if (team1Player.Entity.ContainsFlag(Update.Flags.Ride))
  364.                             {
  365.                                 team1Player.Entity.RemoveFlag(Update.Flags.Ride);
  366.                             }
  367.                             team1Player.TeamQualifierGroup = this;
  368.                         }
  369.                     }
  370.  
  371.                     foreach (var team2Player in Player2.Team.Teammates)
  372.                     {
  373.                         if (CanFight(team2Player))
  374.                         {
  375.                             if (team2Player.Entity.MyJiang != null)
  376.                             {
  377.                                 if (team2Player.Entity.MyJiang.OnJiangMode)
  378.                                 {
  379.                                     team2Player.Entity.PKMode = Enums.PKMode.Capture;
  380.                                     team2Player.Entity.MyJiang.OnJiangMode = false;
  381.                                     team2Player.Entity.MyJiang.SendStatusMode(team2Player);
  382.  
  383.                                 }
  384.                             }
  385.                             var x = (ushort)Kernel.Random.Next(35, 70);
  386.                             var y = (ushort)Kernel.Random.Next(35, 70);
  387.                             team2Player.Entity.Teleport(origMap.ID, dynamicMap.ID, x, y);
  388.                             if (team2Player.Entity.ContainsFlag(Update.Flags.Ride))
  389.                             {
  390.                                 team2Player.Entity.RemoveFlag(Update.Flags.Ride);
  391.                             }
  392.                             team2Player.TeamQualifierGroup = this;
  393.                         }
  394.                     }
  395.                     var team1Op = new QualifierParticipants(Player2, QualifierParticipants.KindOfParticipants.Opponents);
  396.                     foreach (var team1Player in Player1.Team.Teammates)
  397.                     {
  398.                         if (team1Player.TeamQualifierGroup != null)
  399.                         {
  400.                             team1Player.Entity.AddFlag(Update.Flags2.GoldSparkle);
  401.                             team1Player.Send(team1Op.Build(team1Player.Entity.UID));
  402.                             ArenaSignup sign = new ArenaSignup();
  403.                             sign.DialogID = ArenaSignup.MainIDs.StartTheFight;
  404.                             sign.Stats = Player2.TeamArenaStatistic;
  405.                             team1Player.Send(sign.BuildPacket());
  406.                             sign.DialogID = ArenaSignup.MainIDs.Match;
  407.                             sign.OptionID = ArenaSignup.DialogButton.MatchOn;
  408.                             team1Player.Send(sign.BuildPacket());
  409.                             team1Player.Send(MatchPacket.BuildPacket());
  410.                             team1Player.Entity.BringToLife();
  411.                             team1Player.Entity.RemoveFlag(Network.GamePackets.Update.Flags.Ride);
  412.                             team1Player.PrevPK = team1Player.Entity.PKMode;
  413.                             team1Player.Entity.PKMode = Game.Enums.PKMode.Team;
  414.                             team1Player.Send(new Data(true) { UID = team1Player.Entity.UID, ID = Data.ChangePKMode, dwParam = (uint)team1Player.Entity.PKMode });
  415.                         }
  416.                     }
  417.                     var team2Op = new QualifierParticipants(Player1, QualifierParticipants.KindOfParticipants.Opponents);
  418.                     foreach (var team2Player in Player2.Team.Teammates)
  419.                     {
  420.                         if (team2Player.TeamQualifierGroup != null)
  421.                         {
  422.                             team2Player.Entity.AddFlag(Update.Flags2.VioletSparkle);
  423.                             team2Player.Send(team2Op.Build(team2Player.Entity.UID));
  424.                             ArenaSignup sign = new ArenaSignup();
  425.                             sign.DialogID = ArenaSignup.MainIDs.StartTheFight;
  426.                             sign.Stats = Player1.TeamArenaStatistic;
  427.                             team2Player.Send(sign.BuildPacket());
  428.                             sign.DialogID = ArenaSignup.MainIDs.Match;
  429.                             sign.OptionID = ArenaSignup.DialogButton.MatchOn;
  430.                             team2Player.Send(sign.BuildPacket());
  431.                             team2Player.Send(MatchPacket.BuildPacket());
  432.                             team2Player.Entity.BringToLife();
  433.                             team2Player.Entity.RemoveFlag(Network.GamePackets.Update.Flags.Ride);
  434.                             team2Player.PrevPK = team2Player.Entity.PKMode;
  435.                             team2Player.Entity.PKMode = Game.Enums.PKMode.Team;
  436.                             team2Player.Send(new Data(true) { UID = team2Player.Entity.UID, ID = Data.ChangePKMode, dwParam = (uint)team2Player.Entity.PKMode });
  437.                         }
  438.                     }
  439.                     ImportTime = Time32.Now;
  440.                 }
  441.  
  442.                 public void Export()
  443.                 {
  444.                     Groups.Remove(ID);
  445.  
  446.                     if (dynamicMap != null)
  447.                         dynamicMap.Dispose();
  448.  
  449.                     var arr = Watchers.ToArray();
  450.                     foreach (Client.GameState client in arr)
  451.                         QualifyEngine.DoLeave(client);
  452.                     arr = null;
  453.                     Win(Winner, Loser);
  454.  
  455.                     Inside = false;
  456.                     if (Player1.Team == null || Player2.Team == null)
  457.                         return;
  458.                     if (Player1.Team != null)
  459.                     {
  460.                         foreach (var team1Player in Player1.Team.Teammates)
  461.                         {
  462.                             if (team1Player.Map.ID == dynamicMap.ID)
  463.                             {
  464.                                 team1Player.Entity.RemoveFlag(Update.Flags2.GoldSparkle);
  465.                                 team1Player.Entity.PreviousTeleport();
  466.                                 if (team1Player.Map.BaseID == 700)
  467.                                     team1Player.Entity.Teleport(1002, 400, 400);
  468.                                 team1Player.Entity.Ressurect();
  469.                                 team1Player.Entity.PKMode = team1Player.PrevPK;
  470.                                 team1Player.Send(new Data(true) { UID = team1Player.Entity.UID, ID = Data.ChangePKMode, dwParam = (uint)team1Player.Entity.PKMode });
  471.                                 team1Player.TeamQualifierGroup = null;
  472.  
  473.                                 team1Player.Entity.ToxicFogLeft = 0;
  474.                                 team1Player.Entity.NoDrugsTime = 1 - 0;
  475.                                 team1Player.Entity.RemoveFlag(Update.Flags.Poisoned);
  476.  
  477.                                 team1Player.endteam = false;
  478.                             }
  479.                         }
  480.                     }
  481.                     if (Player2.Team != null)
  482.                     {
  483.                         foreach (var team2Player in Player2.Team.Teammates)
  484.                         {
  485.                             if (team2Player.Map.ID == dynamicMap.ID)
  486.                             {
  487.                                 team2Player.Entity.RemoveFlag(Update.Flags2.VioletSparkle);
  488.                                 team2Player.Entity.PreviousTeleport();
  489.                                 if (team2Player.Map.BaseID == 700)
  490.                                     team2Player.Entity.Teleport(1002, 400, 400);
  491.                                 team2Player.Entity.Ressurect();
  492.                                 team2Player.Entity.PKMode = team2Player.PrevPK;
  493.                                 team2Player.Send(new Data(true) { UID = team2Player.Entity.UID, ID = Data.ChangePKMode, dwParam = (uint)team2Player.Entity.PKMode });
  494.                                 team2Player.TeamQualifierGroup = null;
  495.  
  496.                                 team2Player.Entity.ToxicFogLeft = 0;
  497.                                 team2Player.Entity.NoDrugsTime = 1 - 0;
  498.                                 team2Player.Entity.RemoveFlag(Update.Flags.Poisoned);
  499.  
  500.                                 team2Player.endteam = false;
  501.                             }
  502.                         }
  503.                     }
  504.                     Player1.TeamArenaStatistic.AcceptBox = Player2.TeamArenaStatistic.AcceptBox = false;
  505.                     Player1.TeamArenaStatistic.AcceptBoxShow = Player2.TeamArenaStatistic.AcceptBoxShow = Player2.TeamArenaStatistic.AcceptBoxShow.AddHours(-2);
  506.                     Player1.TeamArenaStatistic.PlayWith = Player2.TeamArenaStatistic.PlayWith = null;
  507.                 }
  508.  
  509.                 public void End()
  510.                 {
  511.                     if (Finished) return;
  512.                     Finished = true;
  513.                     Player1.endteam = true;
  514.                     Player2.endteam = true;
  515.                     if (Player1Damage > Player2Damage)
  516.                     {
  517.                         Winner = Player1;
  518.                         Loser = Player2;
  519.                     }
  520.                     else
  521.                     {
  522.                         Winner = Player2;
  523.                         Loser = Player1;
  524.                     }
  525.                     if (Inside)
  526.                     {
  527.                         var sign = new ArenaSignup();
  528.                         sign.Stats = Loser.TeamArenaStatistic;
  529.                         sign.DialogID = ArenaSignup.MainIDs.Dialog;
  530.                         sign.OptionID = ArenaSignup.DialogButton.Lose;
  531.                         Loser.Send(sign.BuildPacket());
  532.                         sign.OptionID = ArenaSignup.DialogButton.Win;
  533.                         sign.Stats = Winner.TeamArenaStatistic;
  534.                         Winner.Send(sign.BuildPacket());
  535.                     }
  536.                     Done = true;
  537.                     DoneStamp = Time32.Now;
  538.                 }
  539.  
  540.                 public void End(GameState loser)
  541.                 {
  542.                     if (!loser.Team.TeamLeader) return;
  543.                     if (Finished) return;
  544.                     Finished = true;
  545.                     Player1.endteam = true;
  546.                     Player2.endteam = true;
  547.                     if (Player1.Entity.UID == loser.Entity.UID)
  548.                     {
  549.                         Winner = Player2;
  550.                         Loser = Player1;
  551.                     }
  552.                     else
  553.                     {
  554.                         Winner = Player1;
  555.                         Loser = Player2;
  556.                     }
  557.                     if (Inside)
  558.                     {
  559.                         var sign = new ArenaSignup();
  560.                         sign.Stats = Loser.TeamArenaStatistic;
  561.                         sign.DialogID = ArenaSignup.MainIDs.Dialog;
  562.                         sign.OptionID = ArenaSignup.DialogButton.Lose;
  563.                         Loser.Send(sign.BuildPacket());
  564.                         sign.OptionID = ArenaSignup.DialogButton.Win;
  565.                         sign.Stats = Winner.TeamArenaStatistic;
  566.                         Winner.Send(sign.BuildPacket());
  567.                     }
  568.                     Done = true;
  569.                     DoneStamp = Time32.Now;
  570.                 }
  571.  
  572.  
  573.                 public void CheckEnd(GameState client, bool disconnect = false)
  574.                 {
  575.                     bool allDead = true;
  576.                     if (client == null) return;
  577.                     if (client.Team == null) return;
  578.                     if (client.Team.Teammates == null) return;
  579.                     foreach (var teammate in client.Team.Teammates)
  580.                         if (teammate.InTeamQualifier())
  581.                             allDead &= teammate.Entity.Dead;
  582.                     if (client.Team.TeamLeader && disconnect)
  583.                         End(client);
  584.                     else if (allDead)
  585.                         if (client.Team.TeamLeader)
  586.                             End(client);
  587.                         else
  588.                             foreach (var teammate in client.Team.Teammates)
  589.                                 if (teammate.Team.TeamLeader)
  590.                                     End(teammate);
  591.                 }
  592.  
  593.                 public GameState OppositeClient(GameState client)
  594.                 {
  595.                     if (client == Player1)
  596.                         return Player2;
  597.                     else
  598.                         return Player1;
  599.                 }
  600.                 public void UpdateDamage(GameState client, uint damage, bool otherParty = false)
  601.                 {
  602.                     if (client != null && Player1 != null)
  603.                     {
  604.                         if (client.Entity.UID == Player1.Entity.UID)
  605.                         {
  606.                             if (!otherParty)
  607.                                 Player1Damage += damage;
  608.                             else
  609.                                 Player2Damage += damage;
  610.                         }
  611.                         else
  612.                         {
  613.                             if (!otherParty)
  614.                                 Player2Damage += damage;
  615.                             else
  616.                                 Player1Damage += damage;
  617.                         }
  618.                         Player1.Team.SendMessage(MatchPacket.BuildPacket());
  619.                         Player2.Team.SendMessage(MatchPacket.BuildPacket());
  620.                     }
  621.                 }
  622.             }
  623.         }
  624.  
  625.         public class QualifyEngine
  626.         {
  627.             public static void RequestGroupList(Client.GameState client, ushort page)
  628.             {
  629.                 client.Send(QualifierList.BuildPacket(page));
  630.             }
  631.  
  632.             public static void DoQuit(Client.GameState client)
  633.             {
  634.                 PlayerList.Remove(client.Entity.UID);
  635.                 RequestGroupList(client, 1);
  636.  
  637.                 if (client.TeamQualifierGroup != null)
  638.                 {
  639.                     if (client.Team.TeamLeader)
  640.                     {
  641.                         if (client.TeamQualifierGroup.Inside)
  642.                         {
  643.                             client.TeamQualifierGroup.End(client);
  644.                             client.TeamQualifierGroup.CreateTime = Time32.Now;
  645.                         }
  646.                         else
  647.                         {
  648.                             Win(client.TeamArenaStatistic.PlayWith, client);
  649.                         }
  650.                     }
  651.                 }
  652.                 else
  653.                 {
  654.                     ArenaSignup sign = new ArenaSignup();
  655.                     sign.DialogID = ArenaSignup.MainIDs.OpponentGaveUp;
  656.                     if (client.TeamArenaStatistic.PlayWith != null)
  657.                     {
  658.                         Client.GameState other = client.TeamArenaStatistic.PlayWith;
  659.                         client.TeamArenaStatistic.PlayWith.Send(sign.BuildPacket());
  660.                         if (WaitingPlayerList.ContainsKey(client.Entity.UID))
  661.                         {
  662.                             WaitingPlayerList.Remove(client.Entity.UID);
  663.                             WaitingPlayerList.Remove(client.TeamArenaStatistic.PlayWith.Entity.UID);
  664.                         }
  665.                         Win(client.TeamArenaStatistic.PlayWith, client);
  666.                         Clear(other);
  667.                     }
  668.                     Clear(client);
  669.                 }
  670.             }
  671.  
  672.             public static void DoSignup(Client.GameState client)
  673.             {
  674.                 if (client.ArenaStatistic.Status != ArenaStatistic.NotSignedUp || client.TeamArenaStatistic.Status != TeamArenaStatistic.NotSignedUp)
  675.                 {
  676.                     client.Send(new Message("You already joined a qualifier arena! Quit the other one and sign up again.", Color.Beige, Message.Agate));
  677.                     return;
  678.                 }
  679.                 if (client.InQualifier())
  680.                 {
  681.                     return;
  682.                 }
  683.                 if (client.Team == null)
  684.                     Network.PacketHandler.CreateTeam(new Network.GamePackets.Team() { UID = client.Entity.UID, Type = Network.GamePackets.Team.Create }, client);
  685.                 if (client.Team == null)
  686.                     return;
  687.                 client.TeamArenaStatistic.HasBox = false;
  688.                 if (client.TeamArenaStatistic.ArenaPoints == 0)
  689.                     return;
  690.                 if (client.Entity.MapID == 601) return;
  691.                 if (client.Map.BaseID >= 6000 && client.Map.BaseID <= 6003) return;
  692.  
  693.                 if (WaitingPlayerList.ContainsKey(client.Entity.UID))
  694.                 {
  695.                     if (client.TeamQualifierGroup == null)
  696.                         WaitingPlayerList.Remove(client.Entity.UID);
  697.                     else
  698.                         return;
  699.                 }
  700.                 PlayerList.Add(client.Entity.UID, client);
  701.                 client.TeamArenaStatistic.Status = Network.GamePackets.TeamArenaStatistic.WaitingForOpponent;
  702.                 client.Send(client.TeamArenaStatistic);
  703.                 RequestGroupList(client, 1);
  704.             }
  705.             public static void DoGiveUp(Client.GameState client)
  706.             {
  707.                 client.TeamArenaStatistic.Status = Network.GamePackets.TeamArenaStatistic.WaitingInactive;
  708.                 client.Send(client.TeamArenaStatistic);
  709.                 RequestGroupList(client, 1);
  710.                 ArenaSignup sign = new ArenaSignup();
  711.                 sign.DialogID = ArenaSignup.MainIDs.OpponentGaveUp;
  712.  
  713.                 if (client.TeamArenaStatistic.PlayWith != null)
  714.                 {
  715.                     client.TeamArenaStatistic.PlayWith.Send(sign.BuildPacket());
  716.  
  717.                     client.TeamArenaStatistic.PlayWith.TeamArenaStatistic.Status = Network.GamePackets.TeamArenaStatistic.NotSignedUp;
  718.                     client.TeamArenaStatistic.Status = Network.GamePackets.TeamArenaStatistic.NotSignedUp;
  719.                     client.TeamArenaStatistic.PlayWith.Send(client.TeamArenaStatistic.PlayWith.TeamArenaStatistic);
  720.                     client.Send(client.TeamArenaStatistic);
  721.  
  722.                     if (WaitingPlayerList.ContainsKey(client.Entity.UID))
  723.                     {
  724.                         WaitingPlayerList.Remove(client.Entity.UID);
  725.                         WaitingPlayerList.Remove(client.TeamArenaStatistic.PlayWith.Entity.UID);
  726.                     }
  727.                     if (client.Team.TeamLeader)
  728.                     {
  729.                         if (client.TeamQualifierGroup != null)
  730.                         {
  731.                             if (client.TeamQualifierGroup.Inside)
  732.                             {
  733.                                 client.TeamQualifierGroup.End(client);
  734.                             }
  735.                             else
  736.                             {
  737.                                 Win(client.TeamArenaStatistic.PlayWith, client);
  738.                             }
  739.                         }
  740.                         else
  741.                         {
  742.                             Win(client.TeamArenaStatistic.PlayWith, client);
  743.                         }
  744.                     }
  745.                     else
  746.                     {
  747.                         client.Team.Remove(client);
  748.                     }
  749.                 }
  750.             }
  751.  
  752.             public static void DoAccept(Client.GameState client)
  753.             {
  754.                 if (!client.TeamArenaStatistic.HasBox)
  755.                     return;
  756.                 if (!client.TeamArenaStatistic.AcceptBox)
  757.                 {
  758.                     if (client.TeamArenaStatistic.ArenaPoints == 0)
  759.                         return;
  760.  
  761.                     if (client.TeamArenaStatistic.PlayWith != null)
  762.                     {
  763.                         client.TeamArenaStatistic.AcceptBox = true;
  764.                     }
  765.                 }
  766.             }
  767.  
  768.             public static void DoLeave(Client.GameState client)
  769.             {
  770.                 if (client.TeamWatchingGroup != null)
  771.                 {
  772.                     client.TeamWatchingGroup.Watchers.Remove(client);
  773.                     client.Send(client.TeamWatchingGroup.BuildWatcherPacket(3));
  774.                     byte[] data = client.TeamWatchingGroup.BuildWatcherPacket(client.TeamWatchingGroup.Watchers);
  775.                     foreach (Client.GameState client2 in client.TeamWatchingGroup.Watchers)
  776.                         client.Send(data);
  777.                     client.TeamWatchingGroup.Player1.Team.SendMessage(data);
  778.                     client.TeamWatchingGroup.Player2.Team.SendMessage(data);
  779.                     client.TeamWatchingGroup = null;
  780.                     client.Entity.PreviousTeleport();
  781.                 }
  782.             }
  783.  
  784.             public static void DoCheer(Client.GameState client, uint uid)
  785.             {
  786.                 if (client.TeamWatchingGroup != null && !client.TeamWatchingGroup.Cheerers.Contains(client.Entity.UID))
  787.                 {
  788.                     client.TeamWatchingGroup.Cheerers.Add(client.Entity.UID);
  789.                     if (client.TeamWatchingGroup.Player1.Entity.UID == uid)
  790.                     {
  791.                         client.TeamCheerFor = 1;
  792.                         client.TeamWatchingGroup.Player1Cheers++;
  793.                     }
  794.                     else
  795.                     {
  796.                         client.TeamCheerFor = 2;
  797.                         client.TeamWatchingGroup.Player2Cheers++;
  798.                     }
  799.                     byte[] data = client.TeamWatchingGroup.BuildWatcherPacket(client.TeamWatchingGroup.Watchers);
  800.                     foreach (Client.GameState client2 in client.TeamWatchingGroup.Watchers)
  801.                         client.Send(data);
  802.                     client.TeamWatchingGroup.Player1.Team.SendMessage(data);
  803.                     client.TeamWatchingGroup.Player2.Team.SendMessage(data);
  804.                 }
  805.             }
  806.         }
  807.  
  808.         public class Statistics
  809.         {
  810.             public static void ShowWiners(Client.GameState client)
  811.             {
  812.                 MemoryStream strm = new MemoryStream();
  813.                 BinaryWriter wtr = new BinaryWriter(strm);
  814.                 int MyCount = 0;
  815.                 wtr.Write((ushort)0);
  816.                 wtr.Write((ushort)2244);
  817.                 wtr.Write((uint)Game.Enums.ArenaIDs.QualifierList);
  818.                 foreach (TeamArenaStatistic entry in YesterdayArenaStatisticsList)
  819.                 {
  820.                     MyCount++;
  821.                     byte[] array = Encoding.Default.GetBytes(entry.Name);
  822.                     for (int i = 0; i < 16; i++)
  823.                     {
  824.                         if (i < entry.Name.Length)
  825.                         {
  826.                             wtr.Write(array[i]);
  827.                         }
  828.                         else
  829.                             wtr.Write((byte)0);
  830.                     }
  831.                     wtr.Write((uint)entry.LastSeasonRank);
  832.                     wtr.Write((uint)entry.Model);
  833.                     wtr.Write((uint)entry.Class);
  834.                     wtr.Write((uint)entry.Level);
  835.                     wtr.Write((uint)entry.LastSeasonArenaPoints);
  836.                     wtr.Write((uint)entry.LastSeasonWin);
  837.                     wtr.Write((uint)entry.LastSeasonLose);
  838.                     if (MyCount == 11)
  839.                         break;
  840.                 }
  841.                 int packetlength = (int)strm.Length;
  842.                 strm.Position = 0;
  843.                 wtr.Write((ushort)packetlength);
  844.                 strm.Position = strm.Length;
  845.                 wtr.Write(Encoding.Default.GetBytes("TQServer"));
  846.                 strm.Position = 0;
  847.                 byte[] buf = new byte[strm.Length];
  848.                 strm.Read(buf, 0, buf.Length);
  849.                 wtr.Close();
  850.                 strm.Close();
  851.                 client.Send(buf);
  852.             }
  853.  
  854.             public static void ShowRankingPage(ushort thisSeason, int pageIndex, Client.GameState client)
  855.             {
  856.                 ArenaList list = new ArenaList(((pageIndex - 1) * 10) + 1);
  857.                 list.ID = Game.Enums.ArenaIDs.ShowPlayerRankList;
  858.                 list.PageNumber = (ushort)(((pageIndex - 1) * 10) + 1);
  859.                 list.Subtype = thisSeason;
  860.                 // if (list.Subtype == 1)
  861.                 {
  862.                     var Array = ArenaStatisticsList;
  863.                     if (Array.Count > pageIndex * 10)
  864.                     {
  865.                         list.Players.Clear();
  866.                         for (int i = (pageIndex) * 10 - 10; i < (pageIndex) * 10; i++)
  867.                         {
  868.                             if (i < Array.Count)
  869.                             {
  870.                                 if (Array[i].Rank > 0)
  871.                                 {
  872.                                     list.Players.Add(Array[i]);
  873.                                 }
  874.                             }
  875.                         }
  876.                     }
  877.                 }
  878.                 //else
  879.                 //{
  880.                 //    var Array = YesterdayArenaStatisticsList;
  881.                 //    if (Array.Count > (((pageIndex) * 10) + 10))
  882.                 //    {
  883.                 //        list.Players.Clear();
  884.                 //        for (int i = ((pageIndex) * 10); i < ((pageIndex) * 10) + 10; i++)
  885.                 //        {
  886.                 //            if (i < Array.Count)
  887.                 //            {
  888.                 //                if (Array[i].LastSeasonRank > 0)
  889.                 //                {
  890.                 //                    list.Players.Add(Array[i]);
  891.                 //                }
  892.                 //            }
  893.                 //        }
  894.                 //    }
  895.                 //}
  896.                 client.Send(list.BuildPacket());
  897.             }
  898.         }
  899.  
  900.         public class ArenaList
  901.         {
  902.             public ushort Size;
  903.             public ushort Type;
  904.             public ushort Subtype;
  905.             public ushort PageNumber;
  906.             public Game.Enums.ArenaIDs ID;
  907.             public List<TeamArenaStatistic> Players = new List<TeamArenaStatistic>();
  908.             public ArenaList(int PageIndex, ushort type = 2243)
  909.             {
  910.                 Type = type;
  911.                 PageNumber = (ushort)PageIndex;
  912.             }
  913.             public ArenaList(byte[] Packet)
  914.             {
  915.                 BinaryReader rdr = new BinaryReader(new MemoryStream(Packet));
  916.                 Size = rdr.ReadUInt16();
  917.                 Type = rdr.ReadUInt16();
  918.                 Subtype = rdr.ReadUInt16();
  919.                 PageNumber = rdr.ReadUInt16();
  920.             }
  921.             public ArenaList()
  922.             {
  923.                 Type = 2243;
  924.             }
  925.             public byte[] BuildPacket()
  926.             {
  927.                 byte[] buff = new byte[(int)(12 + Players.Count * 40 + 8)];
  928.                 Network.Writer.WriteUInt16((ushort)(buff.Length - 8), 0, buff);
  929.                 Network.Writer.WriteUInt16(Type, 2, buff);
  930.                 Network.Writer.WriteUInt16(Subtype, 4, buff);
  931.  
  932.                 Network.Writer.WriteUInt32((uint)InArenaCount, 6, buff);
  933.                 Network.Writer.WriteUInt32((uint)ID, 8, buff);
  934.                 int offset = 12;
  935.                 foreach (TeamArenaStatistic entry in Players)
  936.                 {
  937.                     Network.Writer.WriteUInt32((uint)entry.Rank, offset, buff);
  938.                     offset += 4;
  939.                     Network.Writer.WriteUInt32((uint)entry.HistoryHonor, offset, buff);
  940.                     offset += 4;
  941.                     Network.Writer.WriteUInt32((uint)entry.ArenaPoints, offset, buff);
  942.                     offset += 4;
  943.                     Network.Writer.WriteUInt32((uint)entry.Class, offset, buff);
  944.                     offset += 4;
  945.                     Network.Writer.WriteUInt32((uint)entry.Level, offset, buff);
  946.                     offset += 4;
  947.                     Network.Writer.WriteByte((byte)1, offset, buff);
  948.                     offset += 1;
  949.                     Network.Writer.WriteString(entry.Name, offset, buff);
  950.                     offset += 16;
  951.                     Network.Writer.WriteByte((byte)0, offset, buff);
  952.                     offset += 1;
  953.                     Network.Writer.WriteUInt16((ushort)0, offset, buff);
  954.                     offset += 2;
  955.                 }
  956.                 //MemoryStream strm = new MemoryStream();
  957.                 //BinaryWriter wtr = new BinaryWriter(strm);
  958.  
  959.                 //wtr.Write((ushort)0);
  960.                 //wtr.Write((ushort)Type);
  961.                 //wtr.Write((ushort)Subtype);            
  962.                 //wtr.Write((ushort)InArenaCount);            
  963.                 //wtr.Write((uint)ID);  
  964.                 //foreach (TeamArenaStatistic entry in Players)
  965.                 //{
  966.  
  967.  
  968.                 //    wtr.Write((uint)entry.Rank);                
  969.                 //    wtr.Write((uint)entry.HistoryHonor);
  970.                 //    wtr.Write((uint)entry.ArenaPoints);
  971.                 //    wtr.Write((uint)entry.Class);
  972.                 //    wtr.Write((uint)entry.Level);
  973.                 //    wtr.Write((byte)1);
  974.                 //    for (int i = 0; i < 16; i++)
  975.                 //    {
  976.                 //        if (i < entry.Name.Length)
  977.                 //        {
  978.                 //            wtr.Write((byte)entry.Name[i]);
  979.                 //        }
  980.                 //        else
  981.                 //            wtr.Write((byte)0);
  982.                 //    }
  983.                 //    wtr.Write((byte)0);
  984.                 //    wtr.Write((ushort)0);
  985.  
  986.                 //}
  987.                 //int packetlength = (int)strm.Length;
  988.                 //strm.Position = 0;
  989.                 //wtr.Write((ushort)packetlength);
  990.                 //strm.Position = strm.Length;
  991.                 //wtr.Write(Encoding.Default.GetBytes("TQServer"));
  992.                 //strm.Position = 0;
  993.                 //byte[] buf = new byte[strm.Length];
  994.                 //strm.Read(buf, 0, buf.Length);
  995.                 //wtr.Close();
  996.                 //strm.Close();
  997.                 return buff;
  998.             }
  999.         }
  1000.  
  1001.         public class ArenaSignup
  1002.         {
  1003.             public abstract class MainIDs
  1004.             {
  1005.                 public const uint ArenaIconOn = 0,
  1006.                                     ArenaIconOff = 1,
  1007.                                     StartCountDown = 2,
  1008.                                     OpponentGaveUp = 4,
  1009.                                     Match = 6,
  1010.                                     YouAreKicked = 7,
  1011.                                     StartTheFight = 8,
  1012.                                     Dialog = 9,
  1013.                                     Dialog2 = 10;
  1014.             }
  1015.             public abstract class DialogButton
  1016.             {
  1017.                 public const uint Lose = 3,
  1018.                                     Win = 1,
  1019.                                     MatchOff = 3,
  1020.                                     MatchOn = 5;
  1021.             }
  1022.  
  1023.             public ushort Type = 2241;
  1024.             public uint DialogID;
  1025.             public uint OptionID;
  1026.             public TeamArenaStatistic Stats;
  1027.             public byte[] BuildPacket()
  1028.             {
  1029.                 MemoryStream strm = new MemoryStream();
  1030.                 BinaryWriter wtr = new BinaryWriter(strm);
  1031.                 if (Stats == null)
  1032.                 {
  1033.                     Stats = new TeamArenaStatistic(true);
  1034.                     Stats.Name = "";
  1035.                 }
  1036.                 wtr.Write((ushort)0);
  1037.                 wtr.Write((ushort)Type);
  1038.                 wtr.Write((uint)DialogID);
  1039.                 wtr.Write((uint)OptionID);
  1040.                 wtr.Write((uint)Stats.EntityID);
  1041.                 byte[] array = Encoding.Default.GetBytes(Stats.Name);
  1042.                 for (int i = 0; i < 20; i++)
  1043.                 {
  1044.                     if (i < Stats.Name.Length)
  1045.                     {
  1046.                         wtr.Write(array[i]);
  1047.                     }
  1048.                     else
  1049.                         wtr.Write((byte)0);
  1050.                 }
  1051.                 wtr.Write((uint)Stats.Class);
  1052.                 wtr.Write((uint)Stats.Rank);
  1053.                 wtr.Write((uint)Stats.ArenaPoints);
  1054.                 wtr.Write((uint)Stats.Level);
  1055.                 int packetlength = (int)strm.Length;
  1056.                 strm.Position = 0;
  1057.                 wtr.Write((ushort)packetlength);
  1058.                 strm.Position = strm.Length;
  1059.                 wtr.Write(Encoding.Default.GetBytes("TQServer"));
  1060.                 strm.Position = 0;
  1061.                 byte[] buf = new byte[strm.Length];
  1062.                 strm.Read(buf, 0, buf.Length);
  1063.                 wtr.Close();
  1064.                 strm.Close();
  1065.                 return buf;
  1066.             }
  1067.         }
  1068.  
  1069.         public class GroupMatch
  1070.         {
  1071.             public ushort Type = 2246;
  1072.             public QualifierList.QualifierGroup Group;
  1073.             public byte[] BuildPacket()
  1074.             {
  1075.                 MemoryStream strm = new MemoryStream();
  1076.                 BinaryWriter wtr = new BinaryWriter(strm);
  1077.  
  1078.                 wtr.Write((ushort)64);
  1079.                 wtr.Write((ushort)Type);
  1080.                 wtr.Write((uint)Group.Player1.TeamArenaStatistic.EntityID);
  1081.                 wtr.Write((uint)Group.Player1.TeamArenaStatistic.Rank);
  1082.                 byte[] array = Encoding.Default.GetBytes(Group.Player1.TeamArenaStatistic.Name);
  1083.                 for (int i = 0; i < 16; i++)
  1084.                 {
  1085.                     if (i < Group.Player1.TeamArenaStatistic.Name.Length)
  1086.                     {
  1087.                         wtr.Write(array[i]);
  1088.                     }
  1089.                     else
  1090.                         wtr.Write((byte)0);
  1091.                 }
  1092.                 wtr.Write((uint)Group.Player1Damage);
  1093.                 wtr.Write((uint)Group.Player2.TeamArenaStatistic.EntityID);
  1094.                 wtr.Write((uint)Group.Player2.TeamArenaStatistic.Rank);
  1095.                 byte[] array2 = Encoding.Default.GetBytes(Group.Player2.TeamArenaStatistic.Name);
  1096.                 for (int i = 0; i < 16; i++)
  1097.                 {
  1098.                     if (i < Group.Player2.TeamArenaStatistic.Name.Length)
  1099.                     {
  1100.                         wtr.Write(array2[i]);
  1101.                     }
  1102.                     else
  1103.                         wtr.Write((byte)0);
  1104.                 }
  1105.                 wtr.Write((uint)Group.Player2Damage);
  1106.                 wtr.Write((uint)1);
  1107.                 wtr.Write(Encoding.Default.GetBytes("TQServer"));
  1108.                 strm.Position = 0;
  1109.                 byte[] buf = new byte[strm.Length];
  1110.                 strm.Read(buf, 0, buf.Length);
  1111.                 wtr.Close();
  1112.                 strm.Close();
  1113.                 return buf;
  1114.             }
  1115.         }
  1116.  
  1117.         public static void Win(Client.GameState winner, Client.GameState loser)
  1118.         {
  1119.             if (winner.TeamArenaStatistic.PlayWith != null && loser.TeamArenaStatistic.PlayWith != null)
  1120.             {
  1121.                 winner.TeamArenaStatistic.HasBox =
  1122.                     loser.TeamArenaStatistic.HasBox = false;
  1123.  
  1124.                 int diff = Kernel.Random.Next(30, 50);
  1125.                 if (winner.Team != null)
  1126.                 {
  1127.                     if (winner.Team.Teammates != null)
  1128.                     {
  1129.                         foreach (var teammate in winner.Team.Teammates)
  1130.                         {
  1131.                             if (teammate.Team.TeamLeader)
  1132.                                 teammate.ArenaPoints += (uint)diff;
  1133.                             else
  1134.                                 teammate.ArenaPoints += (uint)(diff - 10);
  1135.                             teammate.TeamArenaStatistic.TodayWin++;
  1136.                             teammate.TeamArenaStatistic.TotalWin++;
  1137.                             if (teammate.TeamArenaStatistic.TodayWin == 9)
  1138.                                 teammate.Inventory.Add(723912, 0, 1);
  1139.                             if (teammate.TeamArenaStatistic.TodayBattles == 20)
  1140.                                 teammate.Inventory.Add(723912, 0, 1);
  1141.                             teammate.Send(teammate.TeamArenaStatistic);
  1142.                             teammate.TeamQualifierGroup = null;
  1143.                         }
  1144.                     }
  1145.                 }
  1146.                 if (loser.Team != null)
  1147.                 {
  1148.                     if (loser.Team.Teammates != null)
  1149.                     {
  1150.                         foreach (var teammate in loser.Team.Teammates)
  1151.                         {
  1152.                             if (teammate.Team.TeamLeader)
  1153.                                 teammate.ArenaPoints -= (uint)diff;
  1154.                             else
  1155.                                 teammate.ArenaPoints -= (uint)(diff - 10);
  1156.                             teammate.TeamArenaStatistic.TodayBattles++;
  1157.                             teammate.TeamArenaStatistic.TotalLose++;
  1158.                             if (teammate.ArenaPoints > 80000)
  1159.                                 teammate.ArenaPoints = 0;
  1160.                             if (teammate.TeamArenaStatistic.TodayBattles == 20)
  1161.                                 teammate.Inventory.Add(723912, 0, 1);
  1162.                             teammate.Send(teammate.TeamArenaStatistic);
  1163.                             teammate.TeamQualifierGroup = null;
  1164.                         }
  1165.                     }
  1166.                 }
  1167.  
  1168.                 winner.TeamArenaStatistic.PlayWith = null;
  1169.                 loser.TeamArenaStatistic.PlayWith = null;
  1170.  
  1171.                 if (WaitingPlayerList.ContainsKey(loser.Entity.UID))
  1172.                     WaitingPlayerList.Remove(loser.Entity.UID);
  1173.                 if (WaitingPlayerList.ContainsKey(winner.Entity.UID))
  1174.                     WaitingPlayerList.Remove(winner.Entity.UID);
  1175.  
  1176.                 QualifyEngine.DoQuit(winner);
  1177.                 QualifyEngine.DoQuit(loser);
  1178.  
  1179.                 winner.TeamArenaStatistic.AcceptBox = false;
  1180.                 loser.TeamArenaStatistic.AcceptBox = false;
  1181.  
  1182.                 Sort();
  1183.  
  1184.                 StringBuilder builder = new StringBuilder();
  1185.                 if (winner.Entity.GuildID != 0)
  1186.                 {
  1187.                     builder.Append("(");
  1188.                     builder.Append(winner.Guild.Name);
  1189.                     builder.Append(") ");
  1190.                 }
  1191.                 builder.Append(winner.Entity.Name);
  1192.                 builder.Append(" has defeated ");
  1193.  
  1194.                 if (loser.Entity.GuildID != 0)
  1195.                 {
  1196.                     builder.Append("(");
  1197.                     builder.Append(loser.Guild.Name);
  1198.                     builder.Append(") ");
  1199.                 }
  1200.                 builder.Append(loser.Entity.Name);
  1201.                 if (winner.TeamArenaStatistic.Rank > 0)
  1202.                 {
  1203.                     builder.Append(" in the Qualifier, and is currently ranked No. "); builder.Append(winner.TeamArenaStatistic.Rank);
  1204.                 }
  1205.                 else { builder.Append(" in the Qualifier"); }
  1206.  
  1207.                 builder.Append(".");
  1208.  
  1209.                 Kernel.SendWorldMessage(new Message(builder.ToString(), System.Drawing.Color.Red, Message.ArenaQualifier), Program.Values);
  1210.  
  1211.                 winner.TeamQualifierGroup = null;
  1212.                 loser.TeamQualifierGroup = null;
  1213.                 foreach (var teammate in loser.Team.Teammates)
  1214.                 {
  1215.                     ArenaSignup sign = new ArenaSignup();
  1216.                     sign.Stats = teammate.TeamArenaStatistic;
  1217.                     sign.DialogID = ArenaSignup.MainIDs.Dialog2;
  1218.                     teammate.Send(sign.BuildPacket());
  1219.                 }
  1220.                 foreach (var teammate in winner.Team.Teammates)
  1221.                 {
  1222.                     ArenaSignup sign = new ArenaSignup();
  1223.                     sign.Stats = teammate.TeamArenaStatistic;
  1224.                     sign.DialogID = ArenaSignup.MainIDs.Dialog2;
  1225.                     sign.OptionID = ArenaSignup.DialogButton.Win;
  1226.                     teammate.Send(sign.BuildPacket());
  1227.                 }
  1228.                 loser.TeamArenaStatistic.Status = TeamArenaStatistic.NotSignedUp;
  1229.                 loser.Send(loser.TeamArenaStatistic);
  1230.  
  1231.                 winner.TeamArenaStatistic.Status = TeamArenaStatistic.NotSignedUp;
  1232.                 winner.Send(winner.TeamArenaStatistic);
  1233.             }
  1234.         }
  1235.  
  1236.         private static DateTime YesterdaySorted = DateTime.Now;
  1237.  
  1238.         public static void Clear(Client.GameState client)
  1239.         {
  1240.             var teamarena_stat = client.TeamArenaStatistic;
  1241.             teamarena_stat.HasBox = false;
  1242.             teamarena_stat.AcceptBox = false;
  1243.             teamarena_stat.AcceptBoxShow = Time32.Now;
  1244.             teamarena_stat.PlayWith = null;
  1245.             teamarena_stat.Status = TeamArenaStatistic.NotSignedUp;
  1246.             client.Send(teamarena_stat);
  1247.             client.QualifierGroup = null;
  1248.             client.TeamQualifierGroup = null;
  1249.             Game.TeamArena.WaitingPlayerList.Remove(teamarena_stat.EntityID);
  1250.             Game.TeamArena.PlayerList.Remove(teamarena_stat.EntityID);
  1251.         }
  1252.  
  1253.         public static void EngagePlayers()
  1254.         {
  1255.             if (PlayerList.Count < 2 || !AcceptingNewBattles)
  1256.                 return;
  1257.             var Players = new GameState[PlayerList.Count];
  1258.             PlayerList.Values.CopyTo(Players, 0);
  1259.             int i, j;
  1260.             int iPlus, jPlus;
  1261.             int iEnd, jEnd;
  1262.             iPlus = Kernel.Random.Next(2);
  1263.             jPlus = Kernel.Random.Next(2);
  1264.             if (iPlus == 0) { i = 0; iPlus = 1; iEnd = Players.Length; } else { i = Players.Length - 1; iPlus = -1; iEnd = -1; }
  1265.             if (jPlus == 0) { j = 0; jPlus = 1; jEnd = Players.Length; } else { j = Players.Length - 1; jPlus = -1; jEnd = -1; }
  1266.             Time32 Now = Time32.Now;
  1267.             for (; i != iEnd; i += iPlus)
  1268.             {
  1269.                 var Challanger = Players[i];
  1270.  
  1271.                 if (CanJoin(Challanger, Now))
  1272.                 {
  1273.                     if (Challanger.Team == null) continue;
  1274.                     if (Challanger.Team.Teammates == null) continue;
  1275.                     for (; j != jEnd; j += jPlus)
  1276.                     {
  1277.                         var Challanged = Players[j];
  1278.                         if (CanJoin(Challanged, Now))
  1279.                         {
  1280.                             if (Challanged.Team == null) continue;
  1281.                             if (Challanged.Team.Teammates == null) continue;
  1282.                             if (Challanger.Entity.UID != Challanged.Entity.UID)
  1283.                             {
  1284.                                 Challanged.TeamArenaStatistic.AcceptBoxShow = Challanger.TeamArenaStatistic.AcceptBoxShow = Time32.Now;
  1285.                                 Challanged.TeamArenaStatistic.Status = Network.GamePackets.TeamArenaStatistic.WaitingInactive;
  1286.                                 Challanger.TeamArenaStatistic.Status = Network.GamePackets.TeamArenaStatistic.WaitingInactive;
  1287.                                 Challanged.Send(Challanged.TeamArenaStatistic);
  1288.                                 Challanger.Send(Challanger.TeamArenaStatistic);
  1289.                                 Challanged.TeamArenaStatistic.PlayWith = Challanger;
  1290.                                 Challanger.TeamArenaStatistic.PlayWith = Challanged;
  1291.                                 ArenaSignup sign = new ArenaSignup();
  1292.                                 sign.DialogID = ArenaSignup.MainIDs.StartCountDown;
  1293.                                 sign.Stats = Challanged.TeamArenaStatistic;
  1294.                                 Challanged.Send(sign.BuildPacket());
  1295.                                 sign.Stats = Challanger.TeamArenaStatistic;
  1296.                                 Challanger.Send(sign.BuildPacket());
  1297.                                 Challanger.TeamArenaStatistic.HasBox =
  1298.                                 Challanged.TeamArenaStatistic.HasBox = true;
  1299.                                 PlayerList.Remove(Challanged.Entity.UID);
  1300.                                 PlayerList.Remove(Challanger.Entity.UID);
  1301.                                 WaitingPlayerList.Add(Challanged.Entity.UID, Challanged);
  1302.                                 WaitingPlayerList.Add(Challanger.Entity.UID, Challanger);
  1303.                                 break;
  1304.                             }
  1305.                         }
  1306.                     }
  1307.                 }
  1308.             }
  1309.         }
  1310.         public static void VerifyAwaitingPeople()
  1311.         {
  1312.             foreach (var Challanger in WaitingPlayerList.Values)
  1313.             {
  1314.                 if (Challanger.Team == null) continue;
  1315.                 if (Challanger.Team.Teammates == null) continue;
  1316.                 if (Challanger != null)
  1317.                 {
  1318.                     if (Challanger.TeamArenaStatistic == null)
  1319.                     {
  1320.                         WaitingPlayerList.Remove(Challanger.Entity.UID);
  1321.                         continue;
  1322.                     }
  1323.                     if (Challanger.TeamArenaStatistic.HasBox)
  1324.                     {
  1325.                         if (Challanger.TeamArenaStatistic.PlayWith != null && Challanger.TeamQualifierGroup == null)
  1326.                         {
  1327.                             Client.GameState Challanged = Challanger.TeamArenaStatistic.PlayWith;
  1328.                             if (Challanged != null)
  1329.                             {
  1330.                                 if (Challanged.Team == null) continue;
  1331.                                 if (Challanged.Team.Teammates == null) continue;
  1332.                                 if (Challanged.TeamArenaStatistic.PlayWith != null && Challanged.TeamQualifierGroup == null)
  1333.                                 {
  1334.                                     if (Challanger.TeamArenaStatistic.AcceptBox && Challanged.TeamArenaStatistic.AcceptBox)
  1335.                                     {
  1336.                                         if (Challanged.Entity.MapID == 1081 || Challanged.Entity.ContainsFlag2(Update.Flags2.SoulShackle))
  1337.                                         {
  1338.                                             Arena.QualifyEngine.DoQuit(Challanged);
  1339.                                             continue;
  1340.                                         }
  1341.                                         if (Challanger.Entity.MapID == 1081 || Challanger.Entity.ContainsFlag2(Update.Flags2.SoulShackle))
  1342.                                         {
  1343.                                             Arena.QualifyEngine.DoQuit(Challanger);
  1344.                                             continue;
  1345.                                         }
  1346.                                         QualifierList.QualifierGroup group = new QualifierList.QualifierGroup(Challanger, Challanged);
  1347.                                         group.Import();
  1348.                                         Challanger.TeamArenaStatistic.HasBox =
  1349.                                             Challanged.TeamArenaStatistic.HasBox = false;
  1350.                                     }
  1351.                                     else if (Time32.Now > Challanger.TeamArenaStatistic.AcceptBoxShow.AddSeconds(59))
  1352.                                     {
  1353.                                         if (Challanger.TeamArenaStatistic.AcceptBox == true)
  1354.                                         {
  1355.                                             Win(Challanger, Challanged);
  1356.                                         }
  1357.                                         else
  1358.                                         {
  1359.                                             if (Challanged.TeamArenaStatistic.AcceptBox)
  1360.                                             {
  1361.                                                 Win(Challanged, Challanger);
  1362.                                             }
  1363.                                             else
  1364.                                             {
  1365.                                                 if (Challanger.ArenaPoints > Challanged.ArenaPoints)
  1366.                                                 {
  1367.                                                     Win(Challanger, Challanged);
  1368.                                                 }
  1369.                                                 else
  1370.                                                 {
  1371.                                                     Win(Challanged, Challanger);
  1372.                                                 }
  1373.                                             }
  1374.                                         }
  1375.                                     }
  1376.                                 }
  1377.                             }
  1378.                             else
  1379.                             {
  1380.                                 Challanger.TeamArenaStatistic.HasBox = false;
  1381.                             }
  1382.                         }
  1383.                     }
  1384.                 }
  1385.             }
  1386.         }
  1387.         public static void CheckGroups()
  1388.         {
  1389.             if (QualifierList.Groups.Count > 0)
  1390.             {
  1391.                 foreach (var group in QualifierList.Groups.Values)
  1392.                 {
  1393.                     if (Time32.Now > group.CreateTime.AddSeconds(5))
  1394.                     {
  1395.                         if (group.Inside)
  1396.                         {
  1397.                             if (!group.Done)
  1398.                             {
  1399.                                 if (Time32.Now > group.CreateTime.AddMinutes(3))
  1400.                                 {
  1401.                                     group.End();
  1402.                                 }
  1403.                             }
  1404.                             else
  1405.                             {
  1406.                                 if (Time32.Now > group.DoneStamp.AddSeconds(4))
  1407.                                 {
  1408.                                     group.Done = false;
  1409.                                     group.Export();
  1410.                                 }
  1411.                             }
  1412.                         }
  1413.                     }
  1414.                 }
  1415.             }
  1416.         }
  1417.         public static void PickUpTeams()
  1418.         {
  1419.             if (PlayerList.Count >= 2)
  1420.             {
  1421.                 int num;
  1422.                 int num2;
  1423.                 int length;
  1424.                 int num4;
  1425.                 GameState[] array = new GameState[PlayerList.Count];
  1426.                 PlayerList.Values.CopyTo(array, 0);
  1427.                 int num5 = Kernel.Random.Next(2);
  1428.                 int num6 = Kernel.Random.Next(2);
  1429.                 if (num5 == 0)
  1430.                 {
  1431.                     num = 0;
  1432.                     num5 = 1;
  1433.                     length = array.Length;
  1434.                 }
  1435.                 else
  1436.                 {
  1437.                     num = array.Length - 1;
  1438.                     num5 = -1;
  1439.                     length = -1;
  1440.                 }
  1441.                 if (num6 == 0)
  1442.                 {
  1443.                     num2 = 0;
  1444.                     num6 = 1;
  1445.                     num4 = array.Length;
  1446.                 }
  1447.                 else
  1448.                 {
  1449.                     num2 = array.Length - 1;
  1450.                     num6 = -1;
  1451.                     num4 = -1;
  1452.                 }
  1453.                 Time32 now = Time32.Now;
  1454.                 while (num != length)
  1455.                 {
  1456.                     GameState client = array[num];
  1457.                     if (CanJoin(client, now))
  1458.                     {
  1459.                         while (num2 != num4)
  1460.                         {
  1461.                             GameState OpponentTeam = array[num2];
  1462.                             if (CanJoin(OpponentTeam, now))
  1463.                             {
  1464.                                 OpponentTeam.TeamArenaStatistic.AcceptBoxShow = client.TeamArenaStatistic.AcceptBoxShow = Time32.Now;
  1465.                                 OpponentTeam.TeamArenaStatistic.Status = 2;
  1466.                                 client.TeamArenaStatistic.Status = 2;
  1467.                                 OpponentTeam.Send(OpponentTeam.TeamArenaStatistic);
  1468.                                 client.Send(client.TeamArenaStatistic);
  1469.                                 OpponentTeam.TeamArenaStatistic.PlayWith = client;
  1470.                                 client.TeamArenaStatistic.PlayWith = OpponentTeam;
  1471.                                 ArenaSignup signup = new ArenaSignup
  1472.                                 {
  1473.                                     DialogID = 2,
  1474.                                     Stats = OpponentTeam.TeamArenaStatistic
  1475.                                 };
  1476.                                 OpponentTeam.Send(signup.BuildPacket());
  1477.                                 signup.Stats = client.TeamArenaStatistic;
  1478.                                 client.Send(signup.BuildPacket());
  1479.                                 #region Sending Accept Box To Opponent's Team Teammates
  1480.                                 foreach (var OpponentTeamMember in OpponentTeam.Team.Teammates)
  1481.                                 {
  1482.                                     if (OpponentTeamMember.Entity.UID != OpponentTeam.Entity.UID)
  1483.                                     {
  1484.                                         OpponentTeamMember.Send(signup.BuildPacket());
  1485.                                     }
  1486.                                 }
  1487.                                 #endregion
  1488.                                 #region Sending Accept Box to Client's Team Teammates
  1489.                                 foreach (var TeamMember in client.Team.Teammates)
  1490.                                 {
  1491.                                     if (TeamMember.Entity.UID != OpponentTeam.Entity.UID)
  1492.                                     {
  1493.                                         TeamMember.Send(signup.BuildPacket());
  1494.                                     }
  1495.                                 }
  1496.                                 #endregion
  1497.                                 client.TeamArenaStatistic.HasBox = OpponentTeam.TeamArenaStatistic.HasBox = true;
  1498.                                 PlayerList.Remove(OpponentTeam.Entity.UID);
  1499.                                 PlayerList.Remove(client.Entity.UID);
  1500.                                 WaitingPlayerList.Add(OpponentTeam.Entity.UID, OpponentTeam);
  1501.                                 WaitingPlayerList.Add(client.Entity.UID, client);
  1502.                             }
  1503.                             num2 += num6;
  1504.                         }
  1505.                     }
  1506.                     num += num5;
  1507.                 }
  1508.             }
  1509.         }
  1510.  
  1511.         private static bool DayPassed = false;
  1512.         private static DateTime StartDateTime = DateTime.Now;
  1513.         public static bool AcceptingNewBattles;
  1514.         public static void Reset()
  1515.         {
  1516.             DateTime Now64 = DateTime.Now;
  1517.             AcceptingNewBattles = ((Now64.Hour >= 11 && Now64.Hour < 13) || (Now64.Hour >= 19 && Now64.Hour < 21));
  1518.             if (!AcceptingNewBattles && WaitingPlayerList.Count == 0 && PlayerList.Count != 0)
  1519.             {
  1520.                 foreach (var player in PlayerList.Values)
  1521.                 {
  1522.                     player.Send("Team Qualifier has ended!");
  1523.                     Clear(player);
  1524.                 }
  1525.             }
  1526.  
  1527.             if (!DayPassed)
  1528.             {
  1529.                 if (Now64.DayOfYear != StartDateTime.DayOfYear)
  1530.                 {
  1531.                     DayPassed = true;
  1532.                     var array = ArenaStatistics.Values.ToArray();
  1533.                     foreach (TeamArenaStatistic stat in array)
  1534.                     {
  1535.                         try
  1536.                         {
  1537.                             Database.TeamArenaTable.Reset(stat);
  1538.                             if (Kernel.GamePool.ContainsKey(stat.EntityID))
  1539.                             {
  1540.                                 Client.GameState client = Kernel.GamePool[stat.EntityID];
  1541.                                 client.Send(stat);
  1542.                             }
  1543.                         }
  1544.                         catch { }
  1545.                     }
  1546.                     try { SaveArenaStats(); }
  1547.                     catch { }
  1548.                     YesterdaySort();
  1549.                 }
  1550.             }
  1551.             else
  1552.             {
  1553.                 if (Now64.DayOfYear == StartDateTime.DayOfYear)
  1554.                 {
  1555.                     DayPassed = false;
  1556.                     StartDateTime = Now64;
  1557.                 }
  1558.             }
  1559.         }
  1560.         private static bool CanFight(Client.GameState client)
  1561.         {
  1562.             if (client.ArenaPoints <= 0) return false;
  1563.             if (client.Entity.Level <= 70) return false;
  1564.             if (client.Entity.ContainsFlag2(Update.Flags2.SoulShackle)) return false;
  1565.             if (client.Map.BaseID == 1038) return false;
  1566.             if (client.Map.BaseID == 700) return false;
  1567.             if (client.Entity.MapID >= 1090 && client.Entity.MapID <= 1094) return false;
  1568.             if (client.Entity.MapID >= 1505 && client.Entity.MapID <= 1509) return false;
  1569.             if (client.Entity.MapID == 1081) return false;
  1570.             return (!Constants.PKFreeMaps.Contains(client.Map.ID) || client.Map.ID == 1005);
  1571.         }
  1572.         private static bool CanJoin(Client.GameState client, Time32 now)
  1573.         {
  1574.             if (client != null)
  1575.             {
  1576.                 if (client.TeamArenaStatistic.PlayWith == null)
  1577.                 {
  1578.                     if (client.TeamQualifierGroup == null)
  1579.                     {
  1580.                         if (!client.Entity.ContainsFlag(Update.Flags.TeamLeader)) return false;
  1581.                         if (!CanFight(client)) return false;
  1582.                         if (client.TeamArenaStatistic.Status == Network.GamePackets.TeamArenaStatistic.WaitingForOpponent)
  1583.                             return true;
  1584.                     }
  1585.                 }
  1586.             }
  1587.             return false;
  1588.         }
  1589.     }
  1590. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!