API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Jun 27th, 2017
76
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 96.18 KB | None | 0 0
raw download clone embed print report
  1. using System;
  2. using System.Linq;
  3. using System.Text;
  4. using System.Collections.Generic;
  5. using System.Collections.Concurrent;
  6. using Nenoa.Network.GamePackets;
  7. using Nenoa.Database;
  8. using System.IO;
  9.  
  10. namespace Nenoa.Game.Features.Tournaments
  11. {
  12. public class ElitePkStatus
  13. {
  14. public static bool InSkillTeam(byte grupe, Game.ConquerStructures.Team team)
  15. {
  16. if (grupe > 3) return false;
  17. if (team.EliteMatch == null) return false;
  18. if (team.EliteFighterStats == null) return false;
  19. if (TeamElitePk.SkillTeamTournament.Tournaments[grupe].Teams == null) return false;
  20. if (!TeamElitePk.SkillTeamTournament.Tournaments[grupe].Alive) return false;
  21. if (TeamElitePk.SkillTeamTournament.Tournaments[grupe].Teams.ContainsKey(team.UID)) return true;
  22. if (TeamElitePk.TeamTournament.Tournaments[grupe].Teams == null) return false;
  23. if (!TeamElitePk.TeamTournament.Tournaments[grupe].Alive) return false;
  24. if (TeamElitePk.TeamTournament.Tournaments[grupe].Teams.ContainsKey(team.UID))
  25. return true;
  26. return false;
  27. }
  28. public void GetSkillElitePkReward(Client.GameState client, byte Rank)
  29. {
  30. uint ITEM_ID = 0;
  31. switch (Rank)
  32. {
  33. case 0:
  34. ITEM_ID = (uint)(721300 + GetEliteGroup(client.Player.Level));
  35. break;
  36. case 1:
  37. ITEM_ID = (uint)(721304 + GetEliteGroup(client.Player.Level));
  38. break;
  39. case 2:
  40. ITEM_ID = (uint)(721308 + GetEliteGroup(client.Player.Level));
  41. break;
  42. default:
  43. ITEM_ID = (uint)(721312 + GetEliteGroup(client.Player.Level));
  44. break;
  45.  
  46. }
  47. client.Inventory.Add(ITEM_ID, 0, 1);
  48. }
  49. public void GetTeamElitePkReward(Client.GameState client, byte Rank)
  50. {
  51. uint ITEM_ID = 0;
  52. switch (Rank)
  53. {
  54. case 0:
  55. ITEM_ID = (uint)(720794 + GetEliteGroup(client.Player.Level));
  56. break;
  57. case 1:
  58. ITEM_ID = (uint)(720798 + GetEliteGroup(client.Player.Level));
  59. break;
  60. case 2:
  61. ITEM_ID = (uint)(720802 + GetEliteGroup(client.Player.Level));
  62. break;
  63. default:
  64. ITEM_ID = (uint)(720806 + GetEliteGroup(client.Player.Level));
  65. break;
  66.  
  67. }
  68. client.Inventory.Add(ITEM_ID, 0, 1);
  69. }
  70.  
  71. public static byte[] BlockOpenArena = new byte[] { 20, 0, 86, 4, 255, 87, 14, 0, 160, 187, 13, 0, 103, 0, 21, 64, 204, 17, 0, 0, 84, 81, 83, 101, 114, 118, 101, 114 };
  72.  
  73. public byte GetEliteGroup(byte level)
  74. {
  75. if (level >= 130)
  76. return 3;
  77. if (level >= 120)
  78. return 3;
  79. if (level >= 100)
  80. return 1;
  81. else
  82. return 0;
  83. }
  84.  
  85. public enum top_typ
  86. {
  87. Elite_PK_Champion__Low_ = 12,
  88. Elite_PK_2nd_Place_Low_ = 13,
  89. Elite_PK_3rd_Place_Low_ = 14,
  90. Elite_PK_Top_8__Low_ = 15,
  91.  
  92. Elite_PK_Champion_High_ = 16,
  93. Elite_PK_2nd_Place_High_ = 17,
  94. Elite_PK_3rd_Place__High_ = 18,
  95. Elite_PK_Top_8_High_ = 19
  96. }
  97. public class States
  98. {
  99. public const byte
  100. GUI_Top8Ranking = 0,
  101. GUI_Knockout = 3,
  102. GUI_Top8Qualifier = 4,
  103. GUI_Top4Qualifier = 5,
  104. GUI_Top2Qualifier = 6,
  105. GUI_Top3 = 7,
  106. GUI_Top1 = 8,
  107. GUI_ReconstructTop = 9;
  108.  
  109. public const byte
  110. T_Organize = 0,
  111. T_CreateMatches = 1,
  112. T_Wait = 2,
  113. T_Fights = 3,
  114. T_Finished = 4,
  115. T_ReOrganize = 5;
  116. }
  117.  
  118. }
  119. public class TeamElitePk : ElitePkStatus
  120. {
  121. public enum GamePackets : ushort
  122. {
  123. MsgDominateTeamPopPkName = 2260,
  124. MsgTeamPopPKRankInfo = 2253,
  125. MsgTeamPopPKMatchInfo = 2252,
  126. MsgTeamPopPKArenicScore = 2251,
  127. MsgTeamPopPKArenic = 2250,
  128.  
  129. MsgDominateTeamName = 2240,
  130. MsgTeamPKRankInfo = 2233,
  131. MsgTeamPKMatchInfo = 2232,
  132. MsgTeamPKArenicScore = 2231,
  133. MsgTeamPKArenic = 2230,
  134. }
  135. public class TeamTournament
  136. {
  137. public static uint WaitingAreaID = 2068;
  138. public static TeamElitePk[] Tournaments;
  139. public static bool Opened = false;
  140. public static void Create()
  141. {
  142. try
  143. {
  144. Tournaments = new TeamElitePk[4];
  145. for (byte x = 0; x < Tournaments.Length; x++)
  146. Tournaments[x] = new TeamElitePk(x, GamePackets.MsgTeamPKMatchInfo);
  147. }
  148. catch (Exception e)
  149. {
  150. Console.WriteLine(e.ToString());
  151. }
  152.  
  153. }
  154. public static void Save()
  155. {
  156. // SaveTop(Tournaments, "TeamElitePkTop8");
  157. }
  158. public static bool GetReward(Client.GameState client, out byte rank, out byte elitestage)
  159. {
  160. if (Tournaments != null)
  161.  
  162. for (byte x = 0; x < Tournaments.Length; x++)
  163. {
  164. if (Tournaments[x] != null)
  165. {
  166. if (Tournaments[x].Top8 != null)
  167. {
  168. for (byte i = 0; i < Tournaments[x].Top8.Length; i++)
  169. {
  170. if (Tournaments[x].Top8[i] != null)
  171. {
  172. if (Tournaments[x].Top8[i].LeaderUID == client.Player.UID)
  173. {
  174.  
  175. if (Tournaments[x].Top8[i].RceiveReward == 0)
  176. {
  177. rank = (byte)(i + 1);
  178. elitestage = x;
  179. Tournaments[x].Top8[i].RceiveReward = 1;
  180. return true;
  181. }
  182. }
  183. }
  184. }
  185. }
  186. }
  187. }
  188. rank = 0;
  189. elitestage = 0;
  190. return false;
  191. }
  192. public static void Open()
  193. {
  194. if (!Opened)
  195. {
  196. Opened = true;
  197. for (byte x = 0; x < Tournaments.Length; x++)
  198. {
  199. Tournaments[x].SubscribeTimer(1);
  200. Tournaments[x].AllowJoin = true;
  201. }
  202. //The Team PK Tournament has start at 20:00. Prepare yourself and sign up for it as a team!");
  203. //Program.World.SendServerMessaj("The Team PK Tournament has start at 20:00. Prepare yourself and sign up for it as a team!");
  204.  
  205. }
  206. }
  207. public static bool Join(Client.GameState client, byte Grope)
  208. {
  209. if (client.Team == null)
  210. return false;
  211.  
  212. if (Grope <= 3)
  213. {
  214. client.Team.SetEliteFighterStats(true);
  215. return Tournaments[Grope].SignUp(client);
  216. }
  217. return false;
  218. }
  219. public static void Process(byte[] packet, Client.GameState client)
  220. {
  221. client.Send(packet);
  222. if (packet[4] == TeamElitePkBrackets.UpdateList ||
  223. packet[4] == TeamElitePkBrackets.RequestInformation ||
  224. packet[4] == TeamElitePkBrackets.InitialList)
  225. TeamElitePk.TeamTournament.Tournaments[packet[14]].Update(client, packet[6]);
  226. }
  227. }
  228. public class SkillTeamTournament
  229. {
  230. public static bool GetReward(Client.GameState client, out byte rank, out byte elitestage)
  231. {
  232. if (Tournaments != null)
  233.  
  234. for (byte x = 0; x < Tournaments.Length; x++)
  235. {
  236. if (Tournaments[x] != null)
  237. {
  238. if (Tournaments[x].Top8 != null)
  239. {
  240. for (byte i = 0; i < Tournaments[x].Top8.Length; i++)
  241. {
  242. if (Tournaments[x].Top8[i] != null)
  243. {
  244. if (Tournaments[x].Top8[i].LeaderUID == client.Player.UID)
  245. {
  246.  
  247. if (Tournaments[x].Top8[i].RceiveReward == 0)
  248. {
  249. rank = (byte)(i + 1);
  250. elitestage = x;
  251. Tournaments[x].Top8[i].RceiveReward = 1;
  252. return true;
  253. }
  254. }
  255. }
  256. }
  257. }
  258. }
  259. }
  260. rank = 0;
  261. elitestage = 0;
  262. return false;
  263. }
  264. public static uint WaitingAreaID = 2068;
  265. public static TeamElitePk[] Tournaments;
  266. public static bool Opened = false;
  267. public static void Create()
  268. {
  269. Tournaments = new TeamElitePk[4];
  270. for (byte x = 0; x < Tournaments.Length; x++)
  271. Tournaments[x] = new TeamElitePk(x, GamePackets.MsgTeamPopPKMatchInfo);
  272. //LoadTop(Tournaments, "SkillTeamElitePkTop8");
  273. }
  274. public static void Save()
  275. {
  276. // SaveTop(Tournaments, "SkillTeamElitePkTop8");
  277. }
  278. public static void Open()
  279. {
  280. if (!Opened)
  281. {
  282. Opened = true;
  283. for (byte x = 0; x < Tournaments.Length; x++)
  284. {
  285. Tournaments[x].SubscribeTimer(1);
  286. Tournaments[x].AllowJoin = true;
  287. }
  288. //Program.World.SendServerMessaj("The Skill Team PK Tournament will start at 20:00. Prepare yourself and sign up for it as a team!");
  289. }
  290. }
  291. public static bool Join(Client.GameState client, byte Grope)
  292. {
  293. if (client.Team == null)
  294. return false;
  295.  
  296. if (Grope <= 3)
  297. {
  298. client.Team.SetEliteFighterStats(true);
  299. return Tournaments[Grope].SignUp(client);
  300. }
  301. return false;
  302. }
  303. public static void Process(byte[] packet, Client.GameState client)
  304. {
  305. client.Send(packet);
  306. if (packet[4] == TeamElitePkBrackets.UpdateList ||
  307. packet[4] == TeamElitePkBrackets.RequestInformation ||
  308. packet[4] == TeamElitePkBrackets.InitialList)
  309. TeamElitePk.SkillTeamTournament.Tournaments[packet[14]].Update(client, packet[6]);
  310. }
  311.  
  312. }
  313. private void SaveTop8(string epk)
  314. {
  315. try
  316. {
  317. int len = Top8.Count(p => p.LeaderUID != 0);
  318. var stream = new MemoryStream();
  319. var writer = new BinaryWriter(stream);
  320. writer.Write(len);
  321. for (int i = 0; i < len; i++)
  322. {
  323. writer.Write(Top8[i].LeaderUID);
  324. writer.Write(Top8[i].Name);
  325. writer.Write(Top8[i].LeaderMesh);
  326. writer.Write(Top8[i].Rank);
  327. writer.Write(Top8[i].Title);
  328. writer.Write(Top8[i].RceiveReward);
  329. }
  330.  
  331. string SQL = "UPDATE `Tournaments` SET data=@data where ID = '" + epk + "' ;";
  332. byte[] rawData = stream.ToArray();
  333. using (var conn = DataHolder.MySqlConnection)
  334. {
  335. conn.Open();
  336. using (var cmd = new MySql.Data.MySqlClient.MySqlCommand())
  337. {
  338. cmd.Connection = conn;
  339. cmd.CommandText = SQL;
  340. cmd.Parameters.AddWithValue("@data", rawData);
  341. cmd.ExecuteNonQuery();
  342. }
  343. }
  344. }
  345. catch (Exception e)
  346. {
  347. Console.WriteLine(e);
  348. }
  349. }
  350. private void LoadTop8(string epk)
  351. {
  352. try
  353. {
  354. Top8 = new FighterStats[8];
  355. using (var cmd = new MySqlCommand(MySqlCommandType.SELECT))
  356. {
  357. cmd.Select("Tournaments").Where("ID", epk);
  358. using (MySqlReader rdr = new MySqlReader(cmd))
  359. {
  360. if (rdr.Read())
  361. {
  362. byte[] data = rdr.ReadBlob("data");
  363. if (data.Length > 0)
  364. {
  365. using (var stream = new MemoryStream(data))
  366. using (var reader = new BinaryReader(stream))
  367. {
  368. int len = reader.ReadInt32();
  369. for (int i = 0; i < len; i++)
  370. {
  371. Top8[i] = new FighterStats(reader.ReadUInt32(), reader.ReadString(), reader.ReadUInt32(), null);
  372. Top8[i].Rank = reader.ReadByte();
  373. Top8[i].Title = reader.ReadByte();
  374. Top8[i].RceiveReward = reader.ReadByte();
  375. }
  376. }
  377. }
  378. }
  379. else
  380. {
  381. using (var command = new MySqlCommand(MySqlCommandType.INSERT))
  382. {
  383. command.Insert("Tournaments").Insert("ID", epk);
  384. command.Execute();
  385. }
  386. }
  387. }
  388. }
  389. }
  390. catch (Exception e)
  391. {
  392.  
  393. Console.WriteLine(e);
  394. }
  395. }
  396. public class FighterStats
  397. {
  398. public enum StatusFlag : int
  399. {
  400. None = 0,
  401. Fighting = 2,
  402. Lost = 4,
  403. Qualified = 3,
  404. Waiting = 1,
  405. }
  406.  
  407. public Game.ConquerStructures.Team Team;
  408.  
  409. public string Name;
  410. public uint LeaderUID;
  411. public uint LeaderMesh;
  412.  
  413. public bool OnNextMatch = false;
  414. public uint Cheers;
  415. public uint Points;
  416. public StatusFlag Flag;
  417. public bool Teleported;
  418.  
  419. public byte RceiveReward;
  420. public byte Title;
  421. public byte Rank;
  422.  
  423. public bool Waiting { get { return Flag == StatusFlag.Waiting; } }
  424. public bool NoFlag { get { return Flag == StatusFlag.None; } }
  425. public bool Fighting { get { return Flag == StatusFlag.Fighting; } }
  426. public bool Winner { get { return Flag == StatusFlag.Qualified; } }
  427. public bool Lost { get { return Flag == StatusFlag.Lost; } }
  428.  
  429.  
  430. public FighterStats(uint id, string name, uint mesh, Game.ConquerStructures.Team temate)
  431. {
  432. LeaderUID = id;
  433. Name = name;
  434. LeaderMesh = mesh;
  435. Team = temate;
  436. }
  437. public void Reset(bool noflag = false)
  438. {
  439. Points = 0;
  440. Cheers = 0;
  441. if (!noflag)
  442. {
  443. if (!Lost)
  444. Flag = StatusFlag.Waiting;
  445. }
  446. }
  447. public FighterStats Clone()
  448. {
  449. FighterStats stats = new FighterStats(LeaderUID, Name, LeaderMesh, Team);
  450. stats.Points = this.Points;
  451. stats.Flag = this.Flag;
  452.  
  453. return stats;
  454. }
  455. public override string ToString()
  456. {
  457. if (Name.Contains('^'))
  458. Name.Replace("^", "");
  459. if (Name.Contains('#'))
  460. Name.Replace('#', ' ');
  461. StringBuilder build = new StringBuilder();
  462. build.Append(LeaderUID + "#" + Name + "#" + LeaderMesh + "#" + Rank + "#" + Title + "#" + RceiveReward + "");
  463. return build.ToString();
  464. }
  465. public void Load(string Line)
  466. {
  467. string[] data = Line.Split('#');
  468. LeaderUID = uint.Parse(data[0]);
  469. Name = data[1];
  470. LeaderMesh = uint.Parse(data[2]);
  471. Rank = byte.Parse(data[3]);
  472. Title = byte.Parse(data[4]);
  473. RceiveReward = byte.Parse(data[5]);
  474. }
  475. }
  476.  
  477. public class Match
  478. {
  479. public enum StatusFlag : int
  480. {
  481. SwitchOut = 0,
  482. Watchable = 1,
  483. Waiting = 3,
  484. OK = 2,
  485. }
  486. public IEnumerable<Client.GameState> Players
  487. {
  488. get
  489. {
  490.  
  491. foreach (var team in MatchStats)
  492. foreach (var player in team.Team.Players)
  493. yield return player;
  494. }
  495. }
  496. public FighterStats[] MatchStats;
  497. public GamePackets T_ID;
  498. public bool OnGoing { get { return Flag == StatusFlag.Watchable; } }
  499. public int GroupID { get { return (int)ID / 100000 - 1; } }
  500.  
  501. public uint TimeLeft
  502. {
  503. get
  504. {
  505. int val = 0;
  506. if (MatchStats.Length == 1)
  507. val = 0;
  508. else
  509. val = (int)((ImportTime.AddMinutes(4).TotalMilliseconds - Time32.Now.TotalMilliseconds) / 1000);
  510. if (val < 0)
  511. val = 0;
  512. return (uint)val;
  513. }
  514. }
  515. public void Commit()
  516. {
  517. var matchStats = new FighterStats[MatchStats.Length];
  518. for (int i = 0; i < matchStats.Length; i++)
  519. {
  520. matchStats[i] = MatchStats[i].Clone();
  521. }
  522. MatchStats = matchStats;
  523. }
  524. public ConcurrentDictionary<uint, Client.GameState> Watchers;
  525.  
  526. public FighterStats Return(Func<FighterStats, bool> fn)
  527. {
  528. foreach (var stat in MatchStats)
  529. if (stat != null)
  530. if (fn(stat))
  531. {
  532. if (T_ID == GamePackets.MsgTeamPopPKMatchInfo)
  533. return SkillTeamTournament.Tournaments[GroupID].Teams[stat.Team.UID].EliteFighterStats;
  534. else
  535. return TeamTournament.Tournaments[GroupID].Teams[stat.Team.UID].EliteFighterStats;
  536. // return ElitePKTournament.Tournaments[GroupID].Players[stat.UID];
  537. }
  538. MatchStats[0].Flag = FighterStats.StatusFlag.Qualified;
  539. return MatchStats[0];
  540. // return null;
  541. }
  542.  
  543. public uint ID;
  544.  
  545. public StatusFlag Flag;
  546. public bool Inside;
  547. public bool Done;
  548. public bool Exported;
  549.  
  550. public bool Completed;
  551. public ushort Index;
  552.  
  553. public Time32 ImportTime;
  554. public Map Map;
  555. public Time32 DoneStamp;
  556.  
  557. private int Imports;
  558.  
  559.  
  560. public void AliveMatch()
  561. {
  562.  
  563. if (Flag != StatusFlag.OK)
  564. {
  565. if (Inside && !Done)
  566. {
  567. foreach (var dismised in MatchStats)
  568. {
  569. if (Flag != StatusFlag.OK)
  570. {
  571. if (MatchStats.Length == 2)
  572. {
  573. if (MatchStats[0].Winner)
  574. return;
  575. if (MatchStats[1].Winner)
  576. return;
  577. }
  578. if (!dismised.Team.OnPopulates)
  579. {
  580. if (dismised.Waiting)
  581. {
  582. dismised.Flag = FighterStats.StatusFlag.Lost;
  583. dismised.Team.EliteFighterStats.Flag = FighterStats.StatusFlag.Lost;
  584. }
  585. if (!dismised.Lost)
  586. {
  587. Console.WriteLine("team " + dismised.Team.EliteFighterStats.Name + " has lost");
  588. this.End(dismised.Team);
  589. }
  590. }
  591. }
  592. }
  593. }
  594. }
  595. }
  596.  
  597. public Match(GamePackets ID, params FighterStats[] teamates)
  598. {
  599. try
  600. {
  601. Map = Kernel.Maps[700].MakeDynamicMap();
  602. T_ID = ID;
  603. if (teamates.Length == 1)
  604. {
  605. Flag = StatusFlag.OK;
  606. MatchStats = new FighterStats[1];
  607. MatchStats[0] = teamates[0].Team.EliteFighterStats;
  608. MatchStats[0].Team.EliteMatch = this;
  609. MatchStats[0].Points = 0;
  610. MatchStats[0].Cheers = 0;
  611. MatchStats[0].Flag = FighterStats.StatusFlag.Qualified;
  612. Flag = StatusFlag.OK;
  613. }
  614. else
  615. {
  616. Watchers = new ConcurrentDictionary<uint, Client.GameState>();
  617. MatchStats = new FighterStats[teamates.Length];
  618. for (int i = 0; i < teamates.Length; i++)
  619. {
  620. MatchStats[i] = teamates[i].Team.EliteFighterStats;
  621. MatchStats[i].Team.EliteMatch = this;
  622. MatchStats[i].Flag = FighterStats.StatusFlag.Waiting;
  623. MatchStats[i].Points = 0;
  624. MatchStats[i].Cheers = 0;
  625. MatchStats[i].Teleported = false;
  626. }
  627. if (MatchStats.Length == 3)
  628. MatchStats[0].Flag = FighterStats.StatusFlag.None;
  629.  
  630. Imports = 0;
  631. Flag = StatusFlag.Waiting;
  632. }
  633. }
  634. catch (Exception e) { Console.WriteLine(e.ToString()); }
  635. }
  636. public void Import(StatusFlag flag = StatusFlag.OK)
  637. {
  638. Imports++;
  639. Exported = Done = false;
  640. Inside = true;
  641. Flag = flag;
  642. ImportTime = Time32.Now;
  643.  
  644. if (MatchStats.Length > 1)
  645. {
  646. Game.ConquerStructures.Team team1 = null, team2 = null;
  647. for (int i = 0; i < MatchStats.Length; i++)
  648. if (!MatchStats[i].NoFlag && !MatchStats[i].Lost)
  649. if (team1 == null)
  650. team1 = MatchStats[i].Team;
  651. else
  652. team2 = MatchStats[i].Team;
  653.  
  654. team1.EliteFighterStats.Flag = FighterStats.StatusFlag.Fighting;
  655. team2.EliteFighterStats.Flag = FighterStats.StatusFlag.Fighting;
  656. importPlayer(team1, team2);
  657. importPlayer(team2, team1);
  658.  
  659. Network.GamePackets.TeamElitePkBrackets brackets = new Network.GamePackets.TeamElitePkBrackets(T_ID, 1);
  660. {
  661. brackets.Group = (ushort)GroupID;
  662. brackets.GUIType = (ushort)ElitePKTournament.Tournaments[GroupID].State;
  663. brackets.TotalMatchesOnRoom = brackets.MatchCount = 1;
  664. brackets.Type = Network.GamePackets.TeamElitePkBrackets.StaticUpdate;
  665. brackets.Append(this);
  666. Kernel.SendWorldMessage(brackets.ToArray());
  667. }
  668. }
  669. else
  670. {
  671. Done = true;
  672. Flag = StatusFlag.OK;
  673. Exported = true;
  674. Completed = true;
  675. MatchStats[0].Flag = FighterStats.StatusFlag.Qualified;
  676. }
  677. }
  678. private void importPlayer(Game.ConquerStructures.Team teamone, Game.ConquerStructures.Team opponent)
  679. {
  680. if (MatchStats.Length > 1)
  681. {
  682. teamone.EliteFighterStats.Teleported = true;
  683. opponent.EliteFighterStats.Teleported = true;
  684. // ushort x = 0; ushort y = 0;
  685. foreach (var player in teamone.Players)
  686. {
  687. if (player.Player.ContainsFlag((ulong)MsgUpdate.Flags.Ride))
  688. {
  689. player.Player.RemoveFlag((ulong)MsgUpdate.Flags.Ride);
  690. }
  691. if (T_ID == GamePackets.MsgTeamPopPKMatchInfo)
  692. {
  693. // player.LoadItemStats();
  694. player.Player.InSkillPk = true;
  695. }
  696. var coords = Map.RandomCoordinates();
  697. player.Player.Teleport(Map.BaseID, Map.ID, coords.Item1, coords.Item2);
  698. player.Player.BringToLife();
  699. player.Player.SkillTeamWatchingElitePKMatch = null;
  700.  
  701. if (T_ID == GamePackets.MsgTeamPopPKMatchInfo)
  702. player.LoadItemStats();//.MyEquip.SendAllItems(player.Player.MyEquip.aleternante);
  703. Network.GamePackets.TeamElitePKMatchUI ui = new Network.GamePackets.TeamElitePKMatchUI(T_ID);
  704. {
  705. ui.Append(opponent);
  706. ui.TimeLeft = TimeLeft;
  707. ui.Type = Network.GamePackets.TeamElitePKMatchUI.BeginMatch;
  708. player.Send(ui.ToArray());
  709. }
  710. player.Send(CreateUpdate().ToArray());
  711. player.CantAttack = Time32.Now.AddSeconds(11);
  712. player.Player.PrevPKMode = player.Player.PKMode;
  713. player.Player.PKMode = Enums.PKMode.Team;
  714.  
  715. Network.GamePackets.MsgAction dat = new Network.GamePackets.MsgAction(true);
  716. {
  717. dat.UID = player.Player.UID;
  718. dat.ID = Network.GamePackets.MsgAction.Mode.ChangePKMode;
  719. dat.dwParam = (uint)player.Player.PKMode;
  720. player.Send(dat.ToArray());
  721. }
  722. }
  723. }
  724. else
  725. {
  726. MatchStats[0].Flag = FighterStats.StatusFlag.Qualified;
  727. Done = true;
  728. Flag = StatusFlag.OK;
  729. Exported = true;
  730. Completed = true;
  731. }
  732. }
  733. public void End(Game.ConquerStructures.Team team)
  734. {
  735. try
  736. {
  737.  
  738. if (MatchStats.Length == 1)
  739. {
  740. MatchStats[0].Flag = FighterStats.StatusFlag.Qualified;
  741. Flag = StatusFlag.OK;
  742. return;
  743. }
  744. if (Done) return;
  745. Done = true;
  746. DoneStamp = Time32.Now;
  747. Flag = StatusFlag.OK;
  748. team.EliteFighterStats.Flag = FighterStats.StatusFlag.Lost;
  749. Network.GamePackets.TeamElitePKMatchUI ui = new Network.GamePackets.TeamElitePKMatchUI(T_ID);
  750. {
  751. ui.Type = Network.GamePackets.MsgElitePKArenic.Effect;
  752. ui.dwParam = Network.GamePackets.MsgElitePKArenic.Effect_Lose;
  753. team.SendMesageTeam(ui.ToArray(), 0);
  754.  
  755. var team_win = targetOfWin(team);
  756. if (team_win != null)
  757. {
  758. ui.Append(team_win.Team);
  759. ui.dwParam = Network.GamePackets.TeamElitePKMatchUI.Effect_Win;
  760.  
  761. foreach (var target in team_win.Team.Players)
  762. {
  763. target.Player.InSkillPk = false;
  764. target.Send(ui.ToArray());
  765. ui.Type = Network.GamePackets.TeamElitePKMatchUI.EndMatch;
  766. team.SendMesageTeam(ui.ToArray(), 0);
  767. target.Send(ui.ToArray());
  768.  
  769. if (T_ID == GamePackets.MsgTeamPopPKMatchInfo)
  770. target.Inventory.Add(720981, 0, 1);
  771.  
  772. ui.Type = Network.GamePackets.TeamElitePKMatchUI.Reward;
  773. target.Send(ui.ToArray());
  774.  
  775. if (Imports == 2 || MatchStats.Length != 3 || MatchStats[0] == null)
  776. {
  777. team_win.Flag = FighterStats.StatusFlag.Qualified;
  778. }
  779. else
  780. {
  781. var dictionar = MatchStats.Where(p => !p.Lost).ToArray();
  782. if (dictionar.Length == 2)
  783. {
  784. Flag = StatusFlag.SwitchOut;
  785. team_win.Flag = FighterStats.StatusFlag.Waiting;
  786. team_win.OnNextMatch = true;
  787. }
  788. else
  789. team_win.Flag = FighterStats.StatusFlag.Qualified;
  790. }
  791. }
  792.  
  793. }
  794. }
  795. Network.GamePackets.TeamElitePkBrackets brackets = new Network.GamePackets.TeamElitePkBrackets(T_ID, 1);
  796. {
  797. brackets.Group = (ushort)GroupID;
  798. brackets.GUIType = (ushort)ElitePKTournament.Tournaments[GroupID].State;
  799. brackets.TotalMatchesOnRoom = brackets.MatchCount = 1;
  800. brackets.Type = Network.GamePackets.TeamElitePkBrackets.StaticUpdate;
  801. brackets.Append(this);
  802. Kernel.SendWorldMessage(brackets.ToArray());
  803. }
  804. foreach (var clien in Watchers.Values)
  805. if (clien.Player.MapID == Map.ID)
  806. LeaveWatch(clien);
  807. }
  808. catch (Exception e) { Console.WriteLine(e.ToString()); }
  809. }
  810. public void Export()
  811. {
  812. try
  813. {
  814. if (Time32.Now > DoneStamp.AddSeconds(3) || TimeLeft == 0)
  815. {
  816. #region !Done
  817. if (!Done)
  818. {
  819. if (MatchStats.Length == 1)
  820. {
  821. MatchStats[0].Flag = FighterStats.StatusFlag.Qualified;
  822. Flag = StatusFlag.OK;
  823. Exported = true;
  824.  
  825. Exported = true;
  826. Completed = true;
  827. return;
  828. }
  829. else
  830. {
  831. var fighters = MatchStats.Where(p => p.Fighting).OrderBy(p => p.Points).ToArray();
  832. for (int i = 0; i < fighters.Length; i++)
  833. {
  834. var team = fighters[i];
  835. End(team.Team);
  836.  
  837. }
  838. }
  839. }
  840. #endregion
  841. foreach (var teams in MatchStats)
  842. {
  843. if (teams != null)
  844. {
  845. if (!teams.Waiting && teams.Teleported || teams.OnNextMatch)
  846. {
  847. foreach (var player in teams.Team.Players)
  848. {
  849. if (player.Player.MapID == Map.ID)
  850. {
  851. player.Player.InSkillPk = false;
  852. if (T_ID == GamePackets.MsgTeamPKMatchInfo)
  853. {
  854. var map = TeamTournament.Tournaments[GroupID].WaitingArea;
  855. var coords = map.RandomCoordinates();
  856. player.Player.Teleport(map.ID, coords.Item1, coords.Item2);
  857. }
  858. else
  859. {
  860. player.LoadItemStats();
  861. var map = SkillTeamTournament.Tournaments[GroupID].WaitingArea;
  862. var coords = map.RandomCoordinates();
  863. player.Player.Teleport(map.ID, coords.Item1, coords.Item2);
  864. }
  865. if (player.Player.Hitpoints == 0)
  866. player.Player.BringToLife();
  867. }
  868. }
  869. teams.Teleported = true;
  870. }
  871. }
  872. }
  873.  
  874. Exported = true;
  875. Completed = true;
  876. }
  877. }
  878. catch (Exception e) { Console.WriteLine(e.ToString()); }
  879. }
  880.  
  881. public void SwitchBetween()
  882. {
  883. if (Imports == 1 && MatchStats.Length == 3 && MatchStats[0] != null && !MatchStats[0].Lost)
  884. {
  885. MatchStats[0].Flag = FighterStats.StatusFlag.Waiting;
  886. if (MatchStats[1].Winner)
  887. {
  888. MatchStats[1].Teleported = false;
  889. MatchStats[1].Flag = FighterStats.StatusFlag.Waiting;
  890.  
  891. }
  892. if (MatchStats[2].Winner)
  893. {
  894. MatchStats[2].Teleported = false;
  895. MatchStats[2].Flag = FighterStats.StatusFlag.Waiting;
  896. }
  897. Completed = false;
  898. }
  899. }
  900. public TeamElitePk.FighterStats targetOfWin(Game.ConquerStructures.Team team)
  901. {
  902. var dictionar = MatchStats.Where(p => p.Fighting).ToArray();
  903. for (int i = 0; i < dictionar.Length; i++)
  904. if (dictionar[i] != null)
  905. if (dictionar[i].Team.UID != team.UID)
  906. return dictionar[i];
  907. return null;
  908. }
  909. public TeamElitePKMatchStats CreateUpdate()
  910. {
  911. Network.GamePackets.TeamElitePKMatchStats stats = new Network.GamePackets.TeamElitePKMatchStats(T_ID);
  912. stats.Append(this);
  913. return stats;
  914. }
  915. public void BeginWatch(Client.GameState client)
  916. {
  917.  
  918. if (Watchers.ContainsKey(client.Player.UID)) return;
  919. Watchers.TryAdd(client.Player.UID, client);
  920. client.Player.SkillTeamWatchingElitePKMatch = this;
  921. var coords = Map.RandomCoordinates();
  922. client.Player.Teleport(Map.BaseID, Map.ID, coords.Item1, coords.Item2);
  923.  
  924. Network.GamePackets.MsgArenicWitness watch = new Network.GamePackets.MsgArenicWitness(true, MatchStats.Length);
  925.  
  926. watch.ID = ID;
  927. watch.Type = Network.GamePackets.MsgArenicWitness.Fighters;
  928. watch.dwCheers1 = MatchStats[0].Cheers;
  929. watch.dwCheers2 = MatchStats[1].Cheers;
  930. watch.Append(MatchStats[0].Name);
  931. watch.Append(MatchStats[1].Name);
  932. client.Send(watch.ToArray());
  933. watch = new Network.GamePackets.MsgArenicWitness(true, Watchers.Count);
  934. watch.ID = ID;
  935. watch.dwCheers1 = MatchStats[0].Cheers;
  936. watch.dwCheers2 = MatchStats[1].Cheers;
  937. foreach (var pClient in Watchers.Values)
  938. watch.Append(pClient.Player.Mesh, pClient.Player.Name);
  939. client.Send(watch.ToArray());
  940. client.Send(CreateUpdate().ToArray());
  941.  
  942. UpdateWatchers();
  943. }
  944.  
  945. public void Update()
  946. {
  947. var update = CreateUpdate();
  948. foreach (var player in Players)
  949. if (player != null)
  950. if (player.Team.EliteFighterStats.Fighting)
  951. player.Send(update.ToArray());
  952. }
  953. public void UpdateWatchers()
  954. {
  955. Network.GamePackets.MsgArenicWitness watch = new Network.GamePackets.MsgArenicWitness(true, Watchers.Count);
  956. {
  957. watch.ID = ID;
  958. watch.Type = Network.GamePackets.MsgArenicWitness.Watchers;
  959. watch.dwCheers1 = MatchStats[0].Cheers;
  960. watch.dwCheers2 = MatchStats[1].Cheers;
  961. foreach (var pClient in Watchers.Values)
  962. watch.Append(pClient.Player.Mesh, pClient.Player.Name);
  963. foreach (var pClient in Watchers.Values)
  964. pClient.Send(watch.ToArray());
  965. foreach (var pClient in Players)
  966. if (pClient != null)
  967. pClient.Send(watch.ToArray());
  968. }
  969. }
  970. public void LeaveWatch(Client.GameState client)
  971. {
  972. if (Watchers.TryRemove(client.Player.UID, out client))
  973. {
  974. client.Player.SkillTeamWatchingElitePKMatch = null;
  975. Network.GamePackets.MsgArenicWitness watch = new Network.GamePackets.MsgArenicWitness(true);
  976. {
  977. watch.ID = ID;
  978. watch.Type = Network.GamePackets.MsgArenicWitness.Leave;
  979. client.Send(watch.ToArray());
  980. client.Player.PreviousTeleport();
  981. }
  982. }
  983. }
  984.  
  985. public void Cheer(Client.GameState client, uint fighter)
  986. {
  987. MatchStats.First(p => p != null && p.Team.Contain(fighter)).Team
  988. .EliteFighterStats.Cheers++;
  989. UpdateWatchers();
  990. }
  991. }
  992.  
  993. public FighterStats[] Top8 = new FighterStats[0];
  994.  
  995. public ConcurrentDictionary<uint, Game.ConquerStructures.Team> Teams;
  996. public ConcurrentDictionary<uint, Match> Matches;
  997. private Match[] MatchArray;
  998. private Match[] Top4MatchArray;
  999. private Match[] ExtendedMatchArray;
  1000. private Counter MatchCounter;
  1001. private ushort MatchIndex;
  1002.  
  1003. public bool Alive = false;
  1004. public DateTime ConstructTop8 = new DateTime();
  1005. public Map WaitingArea;
  1006. public int State;
  1007. private int pState = States.T_Organize;
  1008. public int GroupID;
  1009. private bool willAdvance;
  1010.  
  1011. private Time32 pStamp;
  1012. public GamePackets ID;
  1013. public ushort TimeLeft
  1014. {
  1015. get
  1016. {
  1017. int value = (int)((pStamp.TotalMilliseconds - Time32.Now.TotalMilliseconds) / 1000);
  1018. if (value < 0) return 0;
  1019. return (ushort)value;
  1020. }
  1021. }
  1022.  
  1023.  
  1024.  
  1025. public TeamElitePk(int group, GamePackets T_ID)
  1026. {
  1027. if (!Alive)
  1028. {
  1029.  
  1030. ID = T_ID;
  1031. Alive = true;
  1032. Teams = new ConcurrentDictionary<uint, ConquerStructures.Team>();
  1033. Matches = new ConcurrentDictionary<uint, Match>();
  1034.  
  1035. GroupID = group;
  1036.  
  1037. var name = "TeamPk";
  1038. if (ID == GamePackets.MsgTeamPopPKMatchInfo)
  1039. name = "SkillPk";
  1040. LoadTop8(string.Format("{0}{1}", name, GroupID));
  1041.  
  1042. MatchCounter = new Counter((uint)(GroupID * 100000 + 100000));
  1043.  
  1044. WaitingArea = Kernel.Maps[(ushort)ElitePKTournament.WaitingAreaID].MakeDynamicMap();
  1045. Constants.PKForbiddenMaps.Add(WaitingArea.ID);
  1046.  
  1047. State = States.GUI_Top8Ranking;
  1048. pState = States.T_Organize;
  1049. }
  1050. }
  1051.  
  1052. public bool SignUp(Client.GameState client)
  1053. {
  1054. if (AllowJoin || client.Fake)
  1055. {
  1056. var coords = WaitingArea.RandomCoordinates();
  1057. client.Player.Teleport(WaitingArea.ID, coords.Item1, coords.Item2);
  1058.  
  1059.  
  1060. if (!Teams.ContainsKey(client.Team.UID))
  1061. Teams.TryAdd(client.Team.UID, client.Team);
  1062.  
  1063. Network.GamePackets.TeamElitePKMatchUI ui = new Network.GamePackets.TeamElitePKMatchUI(ID);
  1064. {
  1065. ui.Type = Network.GamePackets.TeamElitePKMatchUI.Information;
  1066. ui.Append(client.Team);
  1067. client.Send(ui.ToArray());
  1068. ui.Type = 5;
  1069. client.Send(ui.ToArray());
  1070. }
  1071. if (client.Team.TeamLider(client))
  1072. {
  1073. Network.GamePackets.SkillEliteSetTeamName teamname = new Network.GamePackets.SkillEliteSetTeamName(ID);
  1074. {
  1075. teamname.TeamID = client.Team.UID;
  1076. teamname.TeamName = client.Team.EliteFighterStats.Name;
  1077. client.Send(teamname.ToArray());
  1078. }
  1079. }
  1080. return true;
  1081. }
  1082. return false;
  1083. }
  1084.  
  1085. DateTime StarTimer = new DateTime();
  1086. private bool AllowJoin = false;
  1087. private IDisposable Subscriber;
  1088. public void SubscribeTimer(int minutes)
  1089. {
  1090. StarTimer = DateTime.Now;
  1091. StarTimer = StarTimer.AddMinutes(5);
  1092. AllowJoin = true;
  1093. if (Subscriber == null)
  1094. Subscriber = Thread.Subscribe(timerCallback, 1000);
  1095. }
  1096.  
  1097. public void Purge()
  1098. {
  1099. foreach (var team in Teams.Values)
  1100. {
  1101. if (State == States.GUI_Top8Qualifier)
  1102. {
  1103. if (Teams.Count > 8)
  1104. {
  1105. if (team.EliteFighterStats.Lost || !team.OnPopulates)// && player.Player.MyLocation.DinamicID != WaitingArea)
  1106. {
  1107. Game.ConquerStructures.Team remover;
  1108. Teams.TryRemove(team.UID, out remover);
  1109. }
  1110. }
  1111. }
  1112. else if (team.EliteFighterStats.Lost)
  1113. {
  1114. if (Teams.Count > 8)
  1115. {
  1116. Game.ConquerStructures.Team remover;
  1117. Teams.TryRemove(team.UID, out remover);
  1118. }
  1119. }
  1120. }
  1121. }
  1122. public static List<AI> Ais = new List<AI>();
  1123. private void timerCallback(int tim)
  1124. {
  1125. try
  1126. {
  1127.  
  1128. if (!Alive)
  1129. {
  1130. if (ID == GamePackets.MsgTeamPopPKMatchInfo)
  1131. SkillTeamTournament.Opened = false;
  1132. else
  1133. TeamTournament.Opened = false;
  1134. Subscriber.Dispose();
  1135. return;
  1136. }
  1137. #region ReconstructTop
  1138. if (State == States.GUI_ReconstructTop)
  1139. {
  1140. if (DateTime.Now > ConstructTop8.AddMinutes(2))
  1141. {
  1142. State = States.GUI_Top8Ranking;
  1143. Kernel.SendWorldMessage(new Network.GamePackets.TeamElitePkBrackets(ID) { Type = 6, OnGoing = false }.ToArray());
  1144. Alive = false;
  1145. }
  1146. return;
  1147. }
  1148. #endregion
  1149. DateTime Now64 = DateTime.Now;
  1150. if (Now64 > StarTimer)
  1151. {
  1152. SkillTeamTournament.Opened = false;
  1153. TeamTournament.Opened = false;
  1154. #region GetState
  1155. if (State == States.GUI_Top8Ranking)
  1156. {
  1157. willAdvance = Teams.Count > 8;
  1158. Kernel.SendWorldMessage(new Network.GamePackets.TeamElitePkBrackets(ID) { Type = 6, OnGoing = true }.ToArray());
  1159. foreach (var team in Teams.Values)
  1160. {
  1161. foreach (var player in team.Players)
  1162. {
  1163. if (player != null)
  1164. {
  1165. if (player.Team != null)
  1166. {
  1167. Network.GamePackets.SkillEliteSetTeamName teamname = new Network.GamePackets.SkillEliteSetTeamName(ID);
  1168. {
  1169. teamname.Type = Network.GamePackets.SkillEliteSetTeamName.SuccessfulName;
  1170. teamname.TeamID = player.Team.UID;
  1171. teamname.TeamName = player.Team.EliteFighterStats.Name;
  1172. player.Send(teamname.ToArray());
  1173.  
  1174. if (player.Team.TeamLider(player))
  1175. {
  1176. teamname.Type = Network.GamePackets.SkillEliteSetTeamName.Remove;
  1177. player.Send(teamname.ToArray());
  1178. }
  1179. }
  1180. if (ID == GamePackets.MsgTeamPKMatchInfo)
  1181. player.Inventory.Add(720793, 0, 1);
  1182. }
  1183. }
  1184. }
  1185. }
  1186. if (Teams.Count < 8)
  1187. {
  1188. if (Teams.Count < 1)
  1189. {
  1190. foreach (var team in Teams.Values)
  1191. foreach (var player in team.Players)
  1192. player.Player.Teleport(1002, 311, 288);
  1193. Teams.Clear();
  1194. Alive = false;
  1195. Kernel.SendWorldMessage(new Network.GamePackets.TeamElitePkBrackets(ID) { Type = 6, OnGoing = false }.ToArray());
  1196. return;
  1197. }
  1198. if (GroupID == 3)
  1199. {
  1200. Ais = new List<AI>();
  1201. int count = 8 - Teams.Count;
  1202. for (int i = 0; i < count; i++)
  1203. {
  1204. var ai = new AI(WaitingArea.ID, 50,50, AI.BotLevel.Medium, (po) => { return Client.GameState.IsVaildForTeamPk(po); });
  1205. if (ai.Bot.Team == null)
  1206. ai.Bot.Team = new Game.ConquerStructures.Team(ai.Bot);
  1207. ai.Bot.Team.SetEliteFighterStats(true);
  1208. if (!Teams.ContainsKey(ai.Bot.Team.UID))
  1209. Teams.TryAdd(ai.Bot.Team.UID, ai.Bot.Team);
  1210.  
  1211. Ais.Add(ai);
  1212. }
  1213. }
  1214. }
  1215. Kernel.SendWorldMessage(new Network.GamePackets.TeamElitePkBrackets(ID) { Type = 6, OnGoing = true }.ToArray());
  1216. Top8 = new FighterStats[8];
  1217. if (Teams.Count == 8)
  1218. State = States.GUI_Top4Qualifier;
  1219. else if (willAdvance && Teams.Count <= 24)
  1220. State = States.GUI_Top8Qualifier;
  1221. else
  1222. State = States.GUI_Knockout;
  1223. }
  1224. #endregion
  1225. #region Knockout
  1226. if (State == States.GUI_Knockout)
  1227. {
  1228. AllowJoin = false;
  1229. if (pState == States.T_Organize)
  1230. {
  1231. if (willAdvance && Teams.Count <= 24)
  1232. {
  1233. State = States.GUI_Top8Qualifier;
  1234. }
  1235. else
  1236. {
  1237. MatchIndex = 0;
  1238. var array = Teams.Values.ToArray();
  1239. ushort counter = 0;
  1240. bool NoPar = array.Length % 2 == 0;
  1241. if (NoPar)
  1242. {
  1243. for (ushort x = 0; x < array.Length; x++)
  1244. {
  1245. int r = counter;
  1246. counter++;
  1247. int t = counter;
  1248. counter++;
  1249. if (counter <= array.Length)
  1250. {
  1251. Match match = new Match(ID, array[r].EliteFighterStats, array[t].EliteFighterStats);
  1252. match.Index = MatchIndex++;
  1253. match.ID = MatchCounter.Next;
  1254. Matches.TryAdd(match.ID, match);
  1255. }
  1256. }
  1257. }
  1258. else
  1259. {
  1260. for (ushort x = 0; x < array.Length - 1; x++)
  1261. {
  1262. int r = counter;
  1263. counter++;
  1264. int t = counter;
  1265. counter++;
  1266. if (counter <= array.Length)
  1267. {
  1268. Match match = new Match(ID, array[r].EliteFighterStats, array[t].EliteFighterStats);
  1269. match.Index = MatchIndex++;
  1270. match.ID = MatchCounter.Next;
  1271. Matches.TryAdd(match.ID, match);
  1272. }
  1273. }
  1274. Match math_bye = new Match(ID, array[array.Length - 1].EliteFighterStats);
  1275. math_bye.Index = MatchIndex++;
  1276. math_bye.ID = MatchCounter.Next;
  1277. Matches.TryAdd(math_bye.ID, math_bye);
  1278. }
  1279. pStamp = Time32.Now.AddSeconds(60);
  1280. pState = States.T_Wait;
  1281. MatchArray = (from match in Matches.Values orderby match.MatchStats.Length descending select match).ToArray();
  1282. var brackets = CreateBrackets(MatchArray, 0);
  1283. foreach (var packet in brackets)
  1284. {
  1285. Kernel.SendWorldMessage(packet.ToArray());
  1286. }
  1287. }
  1288. }
  1289. else if (pState == States.T_Wait)
  1290. {
  1291. if (TimeLeft == 0)
  1292. {
  1293. int doneMatches = 0;
  1294.  
  1295. foreach (var match in MatchArray)
  1296. {
  1297. match.AliveMatch();
  1298. if (!match.Inside)
  1299. {
  1300. match.Import(Match.StatusFlag.Watchable);
  1301. }
  1302. else
  1303. {
  1304. if (!match.Exported && (match.Done || match.TimeLeft == 0))
  1305. {
  1306. match.Export();
  1307. }
  1308. if (match.Exported || match.MatchStats.Length == 1)
  1309. doneMatches++;
  1310. }
  1311. }
  1312. if (doneMatches == Matches.Count)
  1313. {
  1314. Matches.Clear();
  1315. Purge();
  1316. pState = States.T_Organize;
  1317. }
  1318. }
  1319. }
  1320. }
  1321. #endregion
  1322. #region Top8Qualifier
  1323. if (State == States.GUI_Top8Qualifier)
  1324. {
  1325. if (pState == States.T_Organize)
  1326. {
  1327. if (Teams.Count == 8)
  1328. {
  1329. State = States.GUI_Top4Qualifier;
  1330. }
  1331. else
  1332. {
  1333. MatchIndex = 0;
  1334. var array = Teams.Values.ToArray();
  1335. int[] taken = new int[array.Length];
  1336.  
  1337. if (array.Length <= 16)
  1338. {
  1339. ushort counter = 0;
  1340. int t1Group = array.Length - 8;
  1341. int lim = taken.Length / 2;
  1342. for (int i = 0; i < t1Group; i++)
  1343. {
  1344. int r = counter;
  1345. counter++;
  1346. int t = counter;
  1347. counter++;
  1348. Match match = new Match(ID, array[r].EliteFighterStats, array[t].EliteFighterStats);
  1349. match.Index = MatchIndex++;
  1350. match.ID = MatchCounter.Next;
  1351. Matches.TryAdd(match.ID, match);
  1352. }
  1353. for (int i = 0; i < 8 - t1Group; i++)
  1354. {
  1355. ushort r = counter;
  1356. counter++;
  1357. Match match = new Match(ID, array[r].EliteFighterStats);
  1358. match.Index = MatchIndex++;
  1359. match.ID = MatchCounter.Next;
  1360. Matches.TryAdd(match.ID, match);
  1361. }
  1362. }
  1363. else
  1364. {
  1365. ushort counter = 0;
  1366. int t3GroupCount = array.Length - 16;
  1367. for (int i = 0; i < t3GroupCount; i++)
  1368. {
  1369. int r = counter;
  1370. counter++;
  1371. int t = counter;
  1372. counter++;
  1373. int y = counter;
  1374. counter++;
  1375. Match match = new Match(ID, array[r].EliteFighterStats, array[t].EliteFighterStats, array[y].EliteFighterStats);
  1376. match.Index = MatchIndex++;
  1377. match.ID = MatchCounter.Next;
  1378. Matches.TryAdd(match.ID, match);
  1379. }
  1380. int t2GroupCount = array.Length - counter;
  1381. for (int i = 0; i < t2GroupCount / 2; i++)
  1382. {
  1383. int r = counter;
  1384. counter++;
  1385. int t = counter;
  1386. counter++;
  1387. Match match = new Match(ID, array[r].EliteFighterStats, array[t].EliteFighterStats);
  1388. match.Index = MatchIndex++;
  1389. match.ID = MatchCounter.Next;
  1390. Matches.TryAdd(match.ID, match);
  1391. }
  1392. }
  1393. pStamp = Time32.Now.AddSeconds(60);
  1394. pState = States.T_Wait;
  1395. MatchArray = (from match in Matches.Values orderby match.MatchStats.Length descending select match).ToArray();
  1396.  
  1397. var brackets = CreateBrackets(MatchArray, 0, Network.GamePackets.TeamElitePkBrackets.UpdateList);
  1398. foreach (var packet in brackets)
  1399. {
  1400. Kernel.SendWorldMessage(packet.ToArray());
  1401. }
  1402. Network.GamePackets.TeamElitePkBrackets brea = new Network.GamePackets.TeamElitePkBrackets(0);
  1403. brea.Type = Network.GamePackets.TeamElitePkBrackets.EPK_State;
  1404. brea.OnGoing = true;
  1405. Kernel.SendWorldMessage(brea.ToArray());
  1406. }
  1407. }
  1408. else if (pState == States.T_Wait)
  1409. {
  1410. if (TimeLeft == 0)
  1411. {
  1412. int doneMatches = 0;
  1413. foreach (var match in MatchArray)
  1414. {
  1415. match.AliveMatch();
  1416. if (!match.Inside)
  1417. {
  1418. if (match.MatchStats.Length > 1)
  1419. {
  1420. match.Import(Match.StatusFlag.Watchable);
  1421. }
  1422. else
  1423. {
  1424. match.Inside = true;
  1425. match.Completed = true;
  1426. match.Done = true;
  1427. match.MatchStats
  1428. .First(p => p != null).Team
  1429. .EliteFighterStats.Flag = FighterStats.StatusFlag.Qualified;
  1430. }
  1431. }
  1432. else
  1433. {
  1434. if (!match.Exported && (match.Done || match.TimeLeft == 0))
  1435. {
  1436. match.Export();
  1437. if (match.MatchStats.Length == 3)
  1438. match.SwitchBetween();
  1439. else
  1440. match.Flag = Match.StatusFlag.OK;
  1441. }
  1442.  
  1443. if (match.Exported || match.MatchStats.Length == 1)
  1444. doneMatches++;
  1445. }
  1446. }
  1447. if (doneMatches == Matches.Count)
  1448. {
  1449. bool finishedRound = true;
  1450. foreach (var match in MatchArray)
  1451. {
  1452. if (!match.Completed)
  1453. {
  1454. finishedRound = false;
  1455. break;
  1456. }
  1457. }
  1458. if (!finishedRound)
  1459. {
  1460. foreach (var match in MatchArray)
  1461. {
  1462. if (!match.Completed)
  1463. {
  1464. foreach (var stats in match.MatchStats)
  1465. stats.Reset(true);
  1466. match.Inside = false;
  1467. match.Done = false;
  1468. match.Exported = false;
  1469. if (match.MatchStats.Length != 1)
  1470. match.Flag = Match.StatusFlag.Waiting;
  1471. }
  1472. }
  1473. pStamp = Time32.Now.AddSeconds(60);
  1474. pState = States.T_Wait;
  1475. var brakets = CreateBrackets(MatchArray, 0, Network.GamePackets.TeamElitePkBrackets.UpdateList);
  1476. foreach (var packet in brakets)
  1477. {
  1478. Kernel.SendWorldMessage(packet.ToArray());
  1479. }
  1480.  
  1481. }
  1482. else
  1483. {
  1484. Matches.Clear();
  1485. Purge();
  1486. pState = States.T_Organize;
  1487. }
  1488. }
  1489. }
  1490. }
  1491. }
  1492. #endregion
  1493. #region Top4Qualifier
  1494. if (State == States.GUI_Top4Qualifier)
  1495. {
  1496. if (pState == States.T_Organize)
  1497. {
  1498. try
  1499. {
  1500. MatchIndex = 0;
  1501. var array = Teams.Values.ToArray();
  1502. int[] taken = new int[array.Length];
  1503. int lim = taken.Length / 2;
  1504. for (int i = 0; i < taken.Length; i += 2)
  1505. {
  1506. taken[i] = taken[i + 1] = 1;
  1507. Match match = new Match(ID, array[i].EliteFighterStats, array[i + 1].EliteFighterStats);
  1508. match.Index = MatchIndex++;
  1509. //match.Flag = Match.StatusFlag.FinalMatch;
  1510. match.ID = MatchCounter.Next;
  1511. Matches.TryAdd(match.ID, match);
  1512. }
  1513. pStamp = Time32.Now.AddSeconds(60);
  1514. pState = States.T_Wait;
  1515. MatchArray = Matches.Values.ToArray();
  1516. var brackets = CreateBrackets(MatchArray, 0, Network.GamePackets.TeamElitePkBrackets.UpdateList);
  1517. foreach (var packet in brackets)
  1518. Kernel.SendWorldMessage(packet.ToArray());
  1519. }
  1520. catch (Exception e)
  1521. {
  1522. Console.WriteLine(e.ToString());
  1523. }
  1524.  
  1525. }
  1526. else if (pState == States.T_Wait)
  1527. {
  1528. if (TimeLeft == 0)
  1529. {
  1530. try
  1531. {
  1532. int doneMatches = 0;
  1533.  
  1534. foreach (var match in MatchArray)
  1535. {
  1536. match.AliveMatch();
  1537. if (!match.Inside)
  1538. {
  1539. match.Import(Match.StatusFlag.Watchable);
  1540. }
  1541. else
  1542. {
  1543. if (!match.Exported && (match.Done || match.TimeLeft == 0))
  1544. match.Export();
  1545. if (match.Exported)
  1546. doneMatches++;
  1547. }
  1548. }
  1549. if (doneMatches == MatchArray.Length)
  1550. {
  1551. int i = 7;
  1552. foreach (var match in MatchArray)
  1553. {
  1554. foreach (var stats in match.MatchStats)
  1555. if (stats.Flag == FighterStats.StatusFlag.Lost)
  1556. Top8[i--] = stats.Clone();//fara clone;
  1557. match.Commit();
  1558. }
  1559. State = States.GUI_Top2Qualifier;
  1560. pState = States.T_Organize;
  1561. }
  1562. }
  1563. catch (Exception e)
  1564. {
  1565. Console.WriteLine(e.ToString());
  1566. }
  1567. }
  1568. }
  1569. }
  1570. #endregion
  1571. #region Top2Qualifier
  1572. if (State == States.GUI_Top2Qualifier)
  1573. {
  1574. if (pState == States.T_Organize)
  1575. {
  1576. try
  1577. {
  1578. MatchIndex = 0;
  1579. Top4MatchArray = new Match[2];
  1580.  
  1581. for (int i = 0; i < Top4MatchArray.Length; i++)
  1582. {
  1583. Match match = new Match(ID,//p.winer este
  1584. MatchArray[i].Return(p => p.Team.EliteFighterStats.Winner),//.MatchStats.First(p => p.Team.EliteFighterStats.Winner),
  1585. MatchArray[i + 2].Return(p => p.Team.EliteFighterStats.Winner));//.MatchStats.First(p => p.Team.EliteFighterStats.Winner));
  1586. match.Index = MatchIndex++;
  1587. match.ID = MatchCounter.Next;
  1588. Top4MatchArray[i] = match;
  1589. Matches.TryAdd(match.ID, match);
  1590. }
  1591.  
  1592. pStamp = Time32.Now.AddSeconds(60);
  1593. pState = States.T_Wait;
  1594. var brackets = CreateBrackets(Top4MatchArray, 0, Network.GamePackets.TeamElitePkBrackets.UpdateList);
  1595. foreach (var packet in brackets)
  1596. Kernel.SendWorldMessage(packet.ToArray());
  1597. }
  1598. catch (Exception e)
  1599. {
  1600. Console.WriteLine(e.ToString());
  1601. }
  1602.  
  1603. }
  1604. else if (pState == States.T_Wait)
  1605. {
  1606. if (TimeLeft == 0)
  1607. {
  1608. try
  1609. {
  1610. int doneMatches = 0;
  1611. foreach (var match in Top4MatchArray)
  1612. {
  1613. match.AliveMatch();
  1614. if (!match.Inside)
  1615. {
  1616. match.Import(Match.StatusFlag.Watchable);
  1617. }
  1618. else
  1619. {
  1620. if (!match.Exported && (match.Done || match.TimeLeft == 0))
  1621. match.Export();
  1622. if (match.Exported)
  1623. doneMatches++;
  1624. }
  1625. }
  1626. if (doneMatches == Top4MatchArray.Length)
  1627. {
  1628. foreach (var match in Top4MatchArray)
  1629. match.Commit();
  1630.  
  1631. pState = States.T_Organize;
  1632. State = States.GUI_Top3;
  1633. }
  1634. }
  1635. catch (Exception e)
  1636. {
  1637. Console.WriteLine(e.ToString());
  1638. }
  1639. }
  1640. }
  1641. }
  1642. #endregion
  1643. #region Top3
  1644. if (State == States.GUI_Top3)
  1645. {
  1646. if (pState == States.T_Organize)
  1647. {
  1648. try
  1649. {
  1650. MatchIndex = 0;
  1651.  
  1652. ExtendedMatchArray = new Match[2];
  1653. Match match = new Match(ID,
  1654. Top4MatchArray[0].Return(p => !p.Team.EliteFighterStats.Winner),//.MatchStats.First(p => !p.Team.EliteFighterStats.Winner),
  1655. Top4MatchArray[1].Return(p => !p.Team.EliteFighterStats.Winner));//.MatchStats.First(p => !p.Team.EliteFighterStats.Winner));
  1656. match.Index = MatchIndex++;
  1657. match.ID = MatchCounter.Next;
  1658. ExtendedMatchArray[0] = match;
  1659.  
  1660. Match finalmatch = new Match(ID,
  1661. Top4MatchArray[0].Return(p => p.Winner).Clone(),//.MatchStats.First(p => p.Team.EliteFighterStats.Winner).Clone(),
  1662. Top4MatchArray[1].Return(p => p.Winner).Clone());//.MatchStats.First(p => p.Team.EliteFighterStats.Winner).Clone());
  1663. finalmatch.Flag = Match.StatusFlag.SwitchOut;
  1664. ExtendedMatchArray[1] = finalmatch;
  1665.  
  1666. Matches.TryAdd(match.ID, match);
  1667. pStamp = Time32.Now.AddSeconds(60);
  1668. pState = States.T_Wait;
  1669. var brackets = CreateBrackets(ExtendedMatchArray, 0, Network.GamePackets.TeamElitePkBrackets.UpdateList);
  1670. foreach (var packet in brackets)
  1671. Kernel.SendWorldMessage(packet.ToArray());
  1672.  
  1673. Kernel.SendWorldMessage(new Network.GamePackets.TeamElitePkBrackets(ID) { Type = 6, OnGoing = true }.ToArray());
  1674. }
  1675. catch (Exception e)
  1676. {
  1677. Console.WriteLine(e.ToString());
  1678. }
  1679. }
  1680. else if (pState == States.T_Wait)
  1681. {
  1682. if (TimeLeft == 0)
  1683. {
  1684. try
  1685. {
  1686. var match = ExtendedMatchArray[0];
  1687. match.AliveMatch();
  1688. if (!match.Inside)
  1689. {
  1690. match.Import(Match.StatusFlag.Watchable);
  1691. }
  1692. else
  1693. {
  1694. if (!match.Exported && (match.Done || match.TimeLeft == 0))
  1695. match.Export();
  1696. if (match.Exported)
  1697. {
  1698.  
  1699. //var a_math =ExtendedMatchArray[0].MatchStats;
  1700. var top3 = ExtendedMatchArray[0].Return(p => p.Team.EliteFighterStats.Winner);
  1701. //.First(p => p.Team.EliteFighterStats.Winner).Team.EliteFighterStats;
  1702. var top4 = ExtendedMatchArray[0].Return(p => !p.Team.EliteFighterStats.Winner);
  1703. //ExtendedMatchArray[0].MatchStats
  1704. //.First(p => !p.Team.EliteFighterStats.Winner).Team.EliteFighterStats;
  1705.  
  1706. Top8[2] = top3;
  1707. Top8[3] = top4;
  1708. top3.Flag = FighterStats.StatusFlag.Lost;
  1709.  
  1710. pState = States.T_Organize;
  1711. State = States.GUI_Top1;
  1712. foreach (var client in Kernel.GamePool.Values)
  1713. Rankings(client);
  1714. var brackets = CreateBrackets(ExtendedMatchArray, 0, Network.GamePackets.TeamElitePkBrackets.UpdateList);
  1715. foreach (var packet in brackets)
  1716. Kernel.SendWorldMessage(packet.ToArray());
  1717.  
  1718. }
  1719. }
  1720. }
  1721. catch (Exception e)
  1722. {
  1723. Console.WriteLine(e.ToString());
  1724. }
  1725.  
  1726. }
  1727. }
  1728. }
  1729. #endregion
  1730. #region Top1
  1731. if (State == States.GUI_Top1)
  1732. {
  1733. if (pState == States.T_Organize)
  1734. {
  1735. try
  1736. {
  1737. MatchIndex = 0;
  1738. Match match = new Match(ID, ExtendedMatchArray[1].MatchStats);
  1739. ExtendedMatchArray = new Match[1];
  1740. match.Index = MatchIndex++;
  1741. match.ID = MatchCounter.Next;
  1742. ExtendedMatchArray[0] = match;
  1743. Matches.TryAdd(match.ID, match);
  1744. pStamp = Time32.Now.AddSeconds(60);
  1745. pState = States.T_Wait;
  1746. var brackets = CreateBrackets(ExtendedMatchArray, 0, Network.GamePackets.TeamElitePkBrackets.UpdateList);
  1747. foreach (var packet in brackets)
  1748. Kernel.SendWorldMessage(packet.ToArray());
  1749.  
  1750. Kernel.SendWorldMessage(new Network.GamePackets.TeamElitePkBrackets(ID) { Type = 6, OnGoing = true }.ToArray());
  1751. }
  1752. catch (Exception e)
  1753. {
  1754. Console.WriteLine(e.ToString());
  1755. }
  1756. }
  1757. else if (pState == States.T_Wait)
  1758. {
  1759. if (TimeLeft == 0)
  1760. {
  1761. try
  1762. {
  1763. int doneMatches = 0;
  1764. foreach (var match in ExtendedMatchArray)
  1765. {
  1766. match.AliveMatch();
  1767. if (!match.Inside)
  1768. {
  1769. match.Import(Match.StatusFlag.Watchable);
  1770. }
  1771. else
  1772. {
  1773. if (!match.Exported && (match.Done || match.TimeLeft == 0))
  1774. match.Export();
  1775. if (match.Exported)
  1776. doneMatches++;
  1777. }
  1778. }
  1779. if (doneMatches == ExtendedMatchArray.Length)
  1780. {
  1781. try
  1782. {
  1783. var top1 = ExtendedMatchArray[0].MatchStats
  1784. .First(p => p.Team.EliteFighterStats.Winner).Team.EliteFighterStats;
  1785. var top2 = ExtendedMatchArray[0].MatchStats
  1786. .First(p => !p.Team.EliteFighterStats.Winner).Team.EliteFighterStats;
  1787. Top8[0] = top1;
  1788. Top8[1] = top2;
  1789. ConstructTop8 = DateTime.Now;
  1790. var name = "TeamPk";
  1791. if (ID == GamePackets.MsgTeamPopPKMatchInfo)
  1792. name = "SkillPk";
  1793. SaveTop8(string.Format("{0}{1}", name, GroupID));
  1794.  
  1795. foreach (var ai in Ais)
  1796. ai.Bot = null;
  1797. foreach (var team in Teams.Values)
  1798. foreach (var player in team.Players)
  1799. player.Player.Teleport(1002, 311, 288);
  1800. State = States.GUI_ReconstructTop;
  1801. foreach (var client in Kernel.GamePool.Values)
  1802. Rankings(client);
  1803. var brackets = CreateBrackets(ExtendedMatchArray, 0, Network.GamePackets.TeamElitePkBrackets.UpdateList);
  1804. foreach (var packet in brackets)
  1805. Kernel.SendWorldMessage(packet.ToArray());
  1806. Kernel.SendWorldMessage(new Network.GamePackets.TeamElitePkBrackets(ID) { Type = 6, OnGoing = false }.ToArray());
  1807. }
  1808. catch (Exception e)
  1809. {
  1810. Console.WriteLine(e.ToString());
  1811. }
  1812. }
  1813. }
  1814. catch (Exception e)
  1815. {
  1816. Console.WriteLine(e.ToString());
  1817. }
  1818. }
  1819. }
  1820. }
  1821. #endregion
  1822. }
  1823. }
  1824. catch (Exception e)
  1825. { Console.WriteLine(e.ToString()); }
  1826. }
  1827. public void Update(Client.GameState client, int page = 0)
  1828. {
  1829. try
  1830. {
  1831. if (State == States.GUI_Top8Ranking)
  1832. {
  1833. Rankings(client);
  1834. }
  1835. else
  1836. {
  1837. if (State >= States.GUI_Top4Qualifier)
  1838. {
  1839. var brackets = CreateBrackets(MatchArray, 0, Network.GamePackets.TeamElitePkBrackets.GUIEdit);
  1840. foreach (var packet in brackets)
  1841. client.Send(packet.ToArray());
  1842. }
  1843. else
  1844. {
  1845. var brackets = CreateBrackets(MatchArray, page);
  1846. foreach (var packet in brackets)
  1847. client.Send(packet.ToArray());
  1848. }
  1849. if (State >= States.GUI_Top1)
  1850. Rankings(client);
  1851. }
  1852. }
  1853. catch (Exception e) { Console.WriteLine(e.ToString()); }
  1854. }
  1855. public void Rankings(Client.GameState client)
  1856. {
  1857. Network.GamePackets.TeamElitePkTop ranks = new Network.GamePackets.TeamElitePkTop(ID);
  1858. {
  1859. ranks.Type = Network.GamePackets.TeamElitePkTop.Top8;
  1860. ranks.Group = (uint)GroupID;
  1861. ranks.GroupStatus = (uint)State;
  1862. if (State >= States.GUI_Top1)
  1863. {
  1864. ranks.Type = Network.GamePackets.TeamElitePkTop.Top3;
  1865. if (State == States.GUI_Top1)
  1866. {
  1867. ranks.Count = 1;
  1868. ranks.Append(Top8[2], 3);
  1869. }
  1870. else
  1871. {
  1872. ranks.Count = 3;
  1873. for (int i = 0; i < 3; i++)
  1874. ranks.Append(Top8[i], i + 1);
  1875. }
  1876. client.Send(ranks.ToArray());
  1877. }
  1878. else
  1879. {
  1880. ranks.Count = (uint)Top8.Length;
  1881. for (int i = 0; i < ranks.Count; i++)
  1882. if (Top8[i] != null)
  1883. ranks.Append(Top8[i], i);
  1884. client.Send(ranks.ToArray());
  1885. }
  1886. }
  1887. }
  1888. private Network.GamePackets.TeamElitePkBrackets[] CreateBrackets(Match[] matches, int page = 0, byte type = 0)
  1889. {
  1890. try
  1891. {
  1892. int lim = 0, count = 0;
  1893. if (matches == null) return new Network.GamePackets.TeamElitePkBrackets[0];
  1894. if (State == States.GUI_Knockout)
  1895. {
  1896. const int max = 5;
  1897. int offset = page * max;
  1898.  
  1899. int Do_count = matches.Length - page * max;
  1900.  
  1901. if (page * max > matches.Length)
  1902. Do_count = 0;
  1903. uint ccount = (uint)Math.Min(max, Do_count);
  1904.  
  1905. Network.GamePackets.TeamElitePkBrackets brackets = new Network.GamePackets.TeamElitePkBrackets(ID, (int)ccount);
  1906. brackets.Group = (ushort)GroupID;
  1907. brackets.GUIType = (ushort)State;
  1908. brackets.TotalMatchesOnRoom = (ushort)ccount;
  1909. brackets.Page = (byte)page;
  1910. brackets.TimeLeft = TimeLeft;
  1911. brackets.MatchCount = (ushort)matches.Length;
  1912. brackets.Type = type;
  1913. for (int i = 0; i < ccount; i++)
  1914. {
  1915. var element = matches[i + offset];
  1916. brackets.Append(element);
  1917. }
  1918. Network.GamePackets.TeamElitePkBrackets[] buffer = new Network.GamePackets.TeamElitePkBrackets[1];
  1919. buffer[0] = brackets;
  1920. return buffer;
  1921. }
  1922. else if (State == States.GUI_Top8Qualifier)
  1923. {
  1924. const int max = 5;
  1925. int offset = page * max;
  1926.  
  1927. int Do_count = matches.Length - page * max;
  1928.  
  1929. if (page * max > matches.Length)
  1930. Do_count = 0;
  1931. uint ccount = (uint)Math.Min(max, Do_count);
  1932.  
  1933. Network.GamePackets.TeamElitePkBrackets[] buffer;
  1934. if (matches.Length > ccount)
  1935. buffer = new Network.GamePackets.TeamElitePkBrackets[2];
  1936. else
  1937. buffer = new Network.GamePackets.TeamElitePkBrackets[1];
  1938.  
  1939. Network.GamePackets.TeamElitePkBrackets brackets = new Network.GamePackets.TeamElitePkBrackets(ID, (int)ccount);
  1940. brackets.Group = (ushort)GroupID;
  1941. brackets.GUIType = (ushort)State;
  1942. brackets.TotalMatchesOnRoom = (ushort)ccount;
  1943. brackets.Page = (byte)page;
  1944. brackets.TimeLeft = TimeLeft;
  1945. brackets.MatchCount = (ushort)matches.Length;
  1946. brackets.Type = type;
  1947. for (int i = 0; i < ccount; i++)
  1948. {
  1949. var element = matches[i + offset];
  1950. brackets.Append(element);
  1951. }
  1952. buffer[0] = brackets;
  1953. if (matches.Length > ccount)
  1954. {
  1955. ushort towcount = (ushort)(matches.Length - ccount);
  1956. Network.GamePackets.TeamElitePkBrackets twobrackets = new Network.GamePackets.TeamElitePkBrackets(ID, (int)towcount);
  1957. twobrackets.Group = (ushort)GroupID;
  1958. twobrackets.GUIType = (ushort)State;
  1959. twobrackets.TotalMatchesOnRoom = (ushort)towcount;
  1960. twobrackets.Page = (byte)page;
  1961. twobrackets.TimeLeft = TimeLeft;
  1962. twobrackets.ListCount = 1;
  1963. twobrackets.MatchCount = (ushort)matches.Length;
  1964. twobrackets.Type = type;
  1965. for (int i = 0; i < towcount; i++)
  1966. {
  1967. var element = matches[i + ccount];
  1968. twobrackets.Append(element);
  1969. }
  1970. buffer[1] = twobrackets;
  1971. return buffer;
  1972. }
  1973. return buffer;
  1974. }
  1975. lim = matches.Length;
  1976. count = Math.Min(lim, matches.Length - page * lim);
  1977.  
  1978. if (State >= States.GUI_Top2Qualifier)
  1979. {
  1980. lim = MatchArray.Length;
  1981. count = Math.Min(lim, MatchArray.Length - page * lim);
  1982. Network.GamePackets.TeamElitePkBrackets[] buffer = new Network.GamePackets.TeamElitePkBrackets[2];
  1983. if (Top4MatchArray == null)
  1984. return new Network.GamePackets.TeamElitePkBrackets[0];
  1985. Network.GamePackets.TeamElitePkBrackets qbrackets = new Network.GamePackets.TeamElitePkBrackets(ID, count);
  1986. {
  1987. qbrackets.Group = (ushort)GroupID;
  1988. qbrackets.GUIType = (ushort)State;
  1989. qbrackets.TotalMatchesOnRoom = (ushort)(count);
  1990. qbrackets.Page = (byte)page;
  1991. qbrackets.TimeLeft = TimeLeft;
  1992. qbrackets.MatchCount = (byte)(MatchArray.Length * 2);
  1993. qbrackets.Type = type;
  1994. for (int i = page * lim; i < page * lim + count; i++)
  1995. qbrackets.Append(MatchArray[i]);
  1996. buffer[0] = qbrackets;
  1997. }
  1998. if (State >= States.GUI_Top3)
  1999. {
  2000. lim = 4;
  2001. count = (byte)(Top4MatchArray.Length + ExtendedMatchArray.Length);
  2002. Network.GamePackets.TeamElitePkBrackets Twoqbrackets = new Network.GamePackets.TeamElitePkBrackets(ID, count);
  2003. {
  2004. Twoqbrackets.Group = (ushort)GroupID;
  2005. Twoqbrackets.GUIType = (ushort)State;
  2006. Twoqbrackets.TotalMatchesOnRoom = (ushort)count;
  2007. Twoqbrackets.Page = (byte)1;
  2008. Twoqbrackets.TimeLeft = TimeLeft;
  2009. Twoqbrackets.MatchCount = (byte)((Top4MatchArray.Length + ExtendedMatchArray.Length) * 2);
  2010. Twoqbrackets.Type = type;
  2011. for (int i = 0; i < 2; i++)
  2012. Twoqbrackets.Append(Top4MatchArray[i]);
  2013. for (int x = 0; x < ExtendedMatchArray.Length; x++)
  2014. Twoqbrackets.Append(ExtendedMatchArray[x]);
  2015. buffer[1] = Twoqbrackets;
  2016. }
  2017. buffer[1] = Twoqbrackets;
  2018. }
  2019. else
  2020. {
  2021. lim = 2;
  2022. count = Top4MatchArray.Length;
  2023. Network.GamePackets.TeamElitePkBrackets Twoqbrackets = new Network.GamePackets.TeamElitePkBrackets(ID, count);
  2024. {
  2025. Twoqbrackets.Group = (ushort)GroupID;
  2026. Twoqbrackets.GUIType = (ushort)State;
  2027. Twoqbrackets.TotalMatchesOnRoom = (ushort)count;
  2028. Twoqbrackets.Page = (byte)1;
  2029. Twoqbrackets.TimeLeft = TimeLeft;
  2030. Twoqbrackets.MatchCount = (byte)MatchArray.Length;
  2031. Twoqbrackets.Type = type;
  2032. for (int i = page * lim; i < page * lim + count; i++)
  2033. Twoqbrackets.Append(Top4MatchArray[i]);
  2034. buffer[1] = Twoqbrackets;
  2035. }
  2036. }
  2037. return buffer;
  2038. }
  2039.  
  2040. Network.GamePackets.TeamElitePkBrackets aqbrackets = new Network.GamePackets.TeamElitePkBrackets(ID, count);
  2041. {
  2042. aqbrackets.Group = (ushort)GroupID;
  2043. aqbrackets.GUIType = (ushort)State;
  2044. aqbrackets.TotalMatchesOnRoom = (ushort)count;
  2045. aqbrackets.Page = (byte)page;
  2046. aqbrackets.TimeLeft = TimeLeft;
  2047. aqbrackets.MatchCount = (ushort)matches.Length;
  2048. aqbrackets.Type = type;
  2049. for (int i = page * lim; i < page * lim + count; i++)
  2050. aqbrackets.Append(matches[i]);
  2051. Network.GamePackets.TeamElitePkBrackets[] buffer = new Network.GamePackets.TeamElitePkBrackets[1];
  2052. buffer[0] = aqbrackets;
  2053. return buffer;
  2054. }
  2055. }
  2056. catch (Exception e) { Console.WriteLine(e.ToString()); return new Network.GamePackets.TeamElitePkBrackets[0]; }
  2057. }
  2058.  
  2059. }
  2060. }
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!