public void WaitForPlayers()
{
try
{
QueryMaster.GameServer.Server server = ServerQuery.GetServerInstance(EngineType.Source, "217.78.24.8", 28892);
server.ReceiveTimeout = 200;
bool stop = false;
while (!stop)
{
ServerInfo info = server.GetInfo();
if (info.Players == 2)
{
stop = true;
}
Thread.Sleep(10000);
}
}
catch (Exception ex)
{
using (StreamWriter writer = new StreamWriter(errorsPath, true))
{
writer.WriteLine("Message :" + ex.Message + "<br/>" + Environment.NewLine + "StackTrace :" + ex.StackTrace + Environment.NewLine + "Innerexception :" + ex.InnerException +
"" + Environment.NewLine + "Date :" + DateTime.Now.ToString());
writer.WriteLine(Environment.NewLine + "-----------------------------------------------------------------------------" + Environment.NewLine);
}
}
}
private bool Reconnect()
{
if (this.console != null)
{
this.console.Dispose();
this.console = null;
}
try
{
var endpoint = new IPEndPoint(IPAddress.Parse(this.snapshot.ServerIP), this.snapshot.RCONPort);
var server = ServerQuery.GetServerInstance(EngineType.Source, endpoint);
this.console = server.GetControl(this.snapshot.AdminPassword);
return(true);
}
catch (Exception ex)
{
_logger.Debug("Failed to connect to RCON at {0}:{1} with {2}: {3}\n{4}",
this.snapshot.ServerIP,
this.snapshot.RCONPort,
this.snapshot.AdminPassword,
ex.Message,
ex.StackTrace);
return(false);
}
}
public void WhitelistPlayers(ArenaStars.Models.Game _game)
{
try
{
ArenaStarsContext db = new ArenaStarsContext();
var findGame = from x in db.Games
where x.Id == _game.Id
select x;
Models.Game g = findGame.FirstOrDefault();
User playerA = g.Participants.FirstOrDefault();
User playerB = g.Participants.LastOrDefault();
//Add players to the whitelist
string playerAID = "\"" + playerA.SteamId + "\"";
string playerBID = "\"" + playerB.SteamId + "\"";
QueryMaster.GameServer.Server server = ServerQuery.GetServerInstance(EngineType.Source, "217.78.24.8", 28892);
if (server.GetControl("lol"))
{
server.Rcon.SendCommand("sm_whitelist_add " + playerAID);
server.Rcon.SendCommand("sm_whitelist_add " + playerBID);
}
}
catch (Exception ex)
{
using (StreamWriter writer = new StreamWriter(errorsPath, true))
{
writer.WriteLine("Message :" + ex.Message + "<br/>" + Environment.NewLine + "StackTrace :" + ex.StackTrace + Environment.NewLine + "Innerexception :" + ex.InnerException +
"" + Environment.NewLine + "Date :" + DateTime.Now.ToString());
writer.WriteLine(Environment.NewLine + "-----------------------------------------------------------------------------" + Environment.NewLine);
}
}
}
public ServerInfo GetServerData()
{
using (QueryMaster.GameServer.Server s = ServerQuery.GetServerInstance(EngineType.Source, new IPEndPoint(this.serverConnectionInfo.ServerIP, this.serverConnectionInfo.ServerQueryPort)))
{
return(s.GetInfo());
}
}
private static readonly ushort[] ServerPorts = { 2303, 2323, 2333 }; //Query port = server port + 1
/// <summary>
/// Check if the servers are online and call the form to update stattus
/// </summary>
public static void CheckServers()
{
for (int i = 0; i < ServerPorts.Length; i++)
{
bool status;
string players = "-/-";
MainWindow.UpdateForm("UpdateStatusBar", new object[] { "Comprobando servidor " + (i + 1) });
try
{
Server server = ServerQuery.GetServerInstance(EngineType.Source, GetServerIp().ToString(), ServerPorts[i]);
ServerInfo info = server.GetInfo();
players = info.Players + "/" + info.MaxPlayers;
status = true;
server.Dispose();
}
catch (SocketException)
{
status = false;
}
MainWindow.UpdateForm("UpdateServerStatus", new object[] { i, status, players });
}
}
private static ServerInfo GetLocalNetworkStatus(IPEndPoint specificEndpoint, out ReadOnlyCollection <Player> players)
{
players = null;
ServerInfo serverInfo = null;
try
{
using (var server = ServerQuery.GetServerInstance(EngineType.Source, specificEndpoint))
{
serverInfo = server.GetInfo();
players = server.GetPlayers();
}
// return the list of valid players only.
if (players != null)
{
players = new ReadOnlyCollection <Player>(players.Where(record => !string.IsNullOrWhiteSpace(record.Name)).ToList());
}
}
catch (SocketException ex)
{
Logger.Debug("GetInfo failed: {0}: {1}", specificEndpoint, ex.Message);
// Common when the server is unreachable. Ignore it.
}
return(serverInfo);
}
private async Task ReconnectRcon()
{
await Task.Run(() =>
{
try
{
_rconServer?.Dispose();
_rconServer = null;
_rconServer = ServerQuery.GetServerInstance(QueryMaster.EngineType.Source, _config.Ip, (ushort)_config.RconPort, false, 2000, 5000, 1, true);
_rconServer?.GetControl(_config.RconPassword);
}
catch (SocketException)
{
_rconServer?.Dispose();
_rconServer = null;
}
catch (Exception ex)
{
_rconServer?.Dispose();
_rconServer = null;
Logging.LogException($"Error when connecting to server rcon ({_config.Ip}, {_config.RconPort})", ex, typeof(SteamManager), LogLevel.WARN, ExceptionLevel.Ignored);
}
});
}
public void ShouldInitializeWithProperHostAndPort(string ipAndHost)
{
using (var sq = new ServerQuery(new Mock <IUdpClient>().Object, It.IsAny <IPEndPoint>()))
{
sq.Connect(ipAndHost);
}
}
private Task StartConnectionAsync()
{
var server = ServerQuery.GetServerInstance(EngineType.Source, this.endpoint);
this.console = server.GetControl(this.password);
return(Task.FromResult(true));
}
private EmbedBuilder GetEmbedBuilder(string ip, ushort port)
{
var server = ServerQuery.GetServerInstance(EngineType.Source, ip, port, sendTimeout: 1000,
receiveTimeout: 1000, throwExceptions: true);
return(GetSourceServerReplyEmbed(server));
}
private void UpdateDataGrid()
{
ThreadPool.SetMinThreads(1, 1);
ThreadPool.SetMaxThreads(8, 8);
foreach (var item in server_config)
{
ThreadPool.QueueUserWorkItem(_ =>
{
Tuple <string, ushort> tp = item;
Server server = ServerQuery.GetServerInstance(EngineType.Source, tp.Item1, tp.Item2, false, 1000, 1000);
var server_info = server.GetInfo();
this.Dispatcher.BeginInvoke(DispatcherPriority.Normal, (ThreadStart) delegate()
{
if (server_info != null)
{
serverData.Add(new ServerInfoPreview()
{
Map = server_info.Map,
Name = server_info.Name,
Players = string.Format("{0}/{1}", server_info.Players, server_info.MaxPlayers),
Host = tp.Item1,
Port = tp.Item2,
Ping = server_info.Ping
});;
dataGrid.Items.Refresh();
}
});
});
}
}
public PageGridData <ServerDto> GetServerByPage(ServerQuery query)
{
using (var dbScope = _dbScopeFactory.CreateReadOnly())
{
var db = dbScope.DbContexts.Get <FireProjDbContext>();
var data = db.Servers.Select(t => new ServerDto
{
Id = t.Id,
Name = t.Name,
IP = t.IP,
ServerDesc = t.ServerDesc,
PackageDir = t.PackageDir,
StageType = t.StageType,
});
if (query.StageType.HasValue)
{
data = data.Where(t => t.StageType == query.StageType.Value);
}
if (!string.IsNullOrEmpty(query.Search))
{
data = data.Where(t => t.Name.Contains(query.Search) || t.IP.Contains(query.Search));
}
var result = data.OrderBy(t => t.IP).Skip(query.Offset).Take(query.Limit).ToList();
var total = data.Count();
return(new PageGridData <ServerDto> {
rows = result, total = total
});
}
}
private static ServerInfo GetLocalNetworkStatus(IPEndPoint specificEndpoint, out ReadOnlyCollection <Player> players)
{
var server = ServerQuery.GetServerInstance(EngineType.Source, specificEndpoint);
ServerInfo serverInfo = null;
players = null;
try
{
serverInfo = server.GetInfo();
}
catch (SocketException ex)
{
logger.Debug("GetInfo failed: {0}: {1}", specificEndpoint, ex.Message);
// Common when the server is unreachable. Ignore it.
}
if (serverInfo != null)
{
try
{
players = server.GetPlayers();
}
catch (SocketException)
{
// Common when the server is unreachable. Ignore it.
}
}
return(serverInfo);
}
/// <summary>
/// Compare the local game version with the server version and callback the form to show if it doesn't match
/// </summary>
public static void CompareServerVersion()
{
foreach (ushort serverPort in ServerPorts)
{
try
{
Server server = ServerQuery.GetServerInstance(EngineType.Source, GetServerIp().ToString(), serverPort);
ServerInfo info = server.GetInfo();
server.Dispose();
string localVersion = Settings.GameVersion;
string remoteVersion = info.GameVersion;
//Version mismatch, show in form
if (!string.IsNullOrEmpty(localVersion) && !localVersion.Equals(remoteVersion))
{
MainWindow.UpdateForm("ShowVersionMismatch", new object[] { remoteVersion });
}
break;
}
catch (SocketException) {}
}
}
/// <summary>
/// Retrieve a list of servers.
/// </summary>
/// <param name="query">
/// A <see cref="ServerQuery"/> that determines which servers will be retrieved.
/// </param>
/// <param name="paging">
/// An optional <see cref="Paging"/> configuration for the results.
/// </param>
/// <param name="cancellationToken">
/// An optional cancellation token that can be used to cancel the request.
/// </param>
/// <returns>
/// A <see cref="Servers"/> representing the page of results.
/// </returns>
public async Task <Servers> ListServers(ServerQuery query, Paging paging = null, CancellationToken cancellationToken = default(CancellationToken))
{
if (query == null)
{
throw new ArgumentNullException(nameof(query));
}
Guid organizationId = await GetOrganizationId();
HttpRequest listServers = Requests.Server.ListServers
.WithTemplateParameters(new
{
organizationId,
networkDomainId = query.NetworkDomainId
})
.WithPaging(paging);
using (HttpResponseMessage response = await _httpClient.GetAsync(listServers, cancellationToken))
{
if (!response.IsSuccessStatusCode)
{
throw await CloudControlException.FromApiV2Response(response);
}
return(await response.ReadContentAsAsync <Servers>());
}
}
public static string sendRcon(string address, string cmd)
{
Tuple <string, UInt16> addr = splitAddr(address);
string addrIP = addr.Item1;
UInt16 port = addr.Item2;
string pw = decryptRcon();
var server = ServerQuery.GetServerInstance(
(Game)appId,
addrIP,
port,
throwExceptions: false,
retries: retries,
sendTimeout: 2000,
receiveTimeout: 2000);
try
{
// GetControl() validates the RCON password and returns true if the
// server accepted it. For some reason this only works half of the time..
if (server.GetControl(pw))
{
string response = server.Rcon.SendCommand(cmd);
server.Dispose();
return(response);
}
server.Dispose();
return(null);
}
catch (Exception exception)
{
Console.WriteLine(exception);
return(null);
}
}
private Types.Server GetServerStats(Types.Server server)
{
try
{
server.Players = new List <string>();
using (var Connect = ServerQuery.GetServerInstance((QueryMaster.Game) 107410, server.IP, server.Port, throwExceptions: false, retries: 0, sendTimeout: 4000, receiveTimeout: 4000))
{
var Connection = Connect.GetInfo();
if (Connection == null)
{
server.Ping = -1;
return(server);
}
else
{
var INFO = JObject.FromObject(Connection);
server.ServerName = (string)INFO["Name"];
server.Ping = (int)INFO["Ping"];
var Players = Connect.GetPlayers();
foreach (var Player in Players)
{
var ply = JObject.FromObject(Player);
server.Players.Add((string)ply["Name"]);
}
return(server);
}
}
}
catch
{
server.Ping = -1;
return(server);
}
}
public void GetInfoTest()
{
var server = ServerQuery.GetServerInstance(EngineType.Source, @"121.46.225.75", 27015);
var info = server.GetInfo();
Console.WriteLine(info.IsObsolete);
Console.WriteLine(info.Address);
Console.WriteLine(info.Protocol);
Console.WriteLine(info.Name);
Console.WriteLine(info.Map);
Console.WriteLine(info.Directory);
Console.WriteLine(info.Description);
Console.WriteLine(info.Id);
Console.WriteLine(info.Players);
Console.WriteLine(info.MaxPlayers);
Console.WriteLine(info.Bots);
Console.WriteLine(info.ServerType);
Console.WriteLine(info.Environment);
Console.WriteLine(info.IsPrivate);
Console.WriteLine(info.IsSecure);
Console.WriteLine(info.GameVersion);
Console.WriteLine(info.Ping);
Console.WriteLine(info.ExtraInfo);
Console.WriteLine(info.ShipInfo);
Console.WriteLine(info.IsModded);
Console.WriteLine(info.ModInfo);
}
private void FormChooseServer_FormClosing(object sender, FormClosingEventArgs e)
{
Helper.Instance.loadedServer = formChooseServer.Server;
if (Helper.Instance.loadedServer != null)
{
server = ServerQuery.GetServerInstance(EngineType.Source, Helper.Instance.loadedServer.getQueryIPEndPoint());
Helper.Instance.rcon = ServerQuery.GetServerInstance(EngineType.Source, Helper.Instance.loadedServer.getRCONIPEndPoint()).GetControl(Helper.Instance.loadedServer.RCONpw);
panelMain.Visible = true;
toolStripBtnConnect.Visible = false;
toolStripBtnDisconnect.Visible = true;
toolStripBtnServerSettings.Visible = true;
toolStripSeparator1.Visible = true;
//Elemente im Toolstrip, Reiter Aufgaben einblenden
toolStripSchedules.Visible = true;
toolStripBtnDeleteTask.Visible = true;
loadTasks();
toolStripStatusLabelStatus.Text = "Connected";
}
Enabled = true;
}
public static async void UpdateServerAsync()
{
await Task.Run(() =>
{
Server gta1 = ServerQuery.GetServerInstance(Game.Arma_3, "164.132.200.53", 2303, false, 1000, 1000, 0);
Server gta2 = ServerQuery.GetServerInstance(Game.Arma_3, "164.132.202.63", 2603, false, 1000, 1000, 0);
Server gta3 = ServerQuery.GetServerInstance(Game.Arma_3, "164.132.202.63", 2303, false, 1000, 1000, 0);
while (true)
{
ServerInfo info1 = gta1.GetInfo();
ServerInfo info2 = gta2.GetInfo();
ServerInfo info3 = gta3.GetInfo();
if (Application.Current != null)
{
Application.Current.Dispatcher.Invoke(async() =>
{
ShowServerInfo(info1, Win.TextBlockServer1, Win.JoinServer1Button);
ShowServerInfo(info2, Win.TextBlockServer2, Win.JoinServer2Button);
ShowServerInfo(info3, Win.TextBlockServer3, Win.JoinServer3Button);
await ScrapGTA(Win.TextBlockTs);
});
}
Task.Delay(15_000);
}
});
}
private void ServerInfoTimer(object source, ElapsedEventArgs e)
{
if (ServerProcess.IsRunning())
{
try
{
ServerQuery query = new ServerQuery("127.0.0.1", 2303);
Dispatcher.Invoke(() =>
{
PlayerCount.Text = Convert.ToString(query.getPlayer());
});
}
catch (Exception ex)
{
Debug.Write(ex.Message);
}
}
else
{
Dispatcher.Invoke(() =>
{
PlayerCount.Text = "0";
});
}
}
private bool TryRunRconCommand(string command, out string response)
{
using (var server = ServerQuery.GetServerInstance(EngineType.Source, _config.CounterStrike.IP,
_config.CounterStrike.Port, false, 1000, 1000, 1, false))
{
var serverInfo = server.GetInfo();
if (serverInfo == null)
{
response = "Server is down.";
return(false);
}
server.GetControl(_config.CounterStrike.RconPassword);
var result = server.Rcon.SendCommand(command);
if (result == null)
{
response = $"Ran command '{command}'";
return(true);
}
else
{
response = $"Ran command '{command}' with result '{result}'";
return(true);
}
}
}
// shared update code
#region UpdateServerAndDetails()
private void UpdateServerAndDetails(UpdateRequest request, ServerRow row, bool fireRefreshSingleServerComplete)
{
string status = "";
try
{
if (request.IsCancelled)
{
return;
}
using (Server server = ServerQuery.GetServerInstance(EngineType.Source, row.EndPoint, false, request.Timeout, request.Timeout))
{
row.Retries = 0;
server.SendFirstPacketTwice = this.sendFirstUdpPacketTwice;
server.Retries = 3;
status = "timeout";
if (this.UpdateServerInfo(request, row, server))
{
row.GameExtension = gameExtensions.Get((Game)(row.ServerInfo.Extra?.GameId ?? row.ServerInfo.Id));
this.UpdatePlayers(request, row, server);
this.UpdateRules(request, row, server);
status = "ok";
}
row.RequestTimestamp = request.Timestamp;
}
if (request.IsCancelled) // status might have changed
{
return;
}
if (row.Retries > 0)
{
status += " (" + row.Retries + ")";
}
}
catch
{
// this happens when you hibernate windows and the program resumes before the network connection has be reestablished
status = "network error";
}
finally
{
row.Status = status;
row.Update();
request.SetDataModified();
if (fireRefreshSingleServerComplete && !request.IsCancelled)
{
this.RefreshSingleServerComplete?.Invoke(this, new ServerEventArgs(row));
}
if (!request.PendingTasks.IsSet)
{
request.PendingTasks.Signal();
}
}
}
public override async Task <ServerQueryPlayer[]> GetServerPlayers(Server server, System.Threading.CancellationToken?token)
{
var endpoint = GetServerEndpoint(server);
var players = await ServerQuery.Players(endpoint);
return(players);
}
public void StartGame()
{
QueryMaster.GameServer.Server server = ServerQuery.GetServerInstance(EngineType.Source, "217.78.24.8", 28892);
if (server.GetControl("lol"))
{
server.Rcon.SendCommand("1on1");
}
}
public ServerInfo GetServerData()
{
// connect over UDP port
using (Server s = ServerQuery.GetServerInstance(EngineType.Source, new IPEndPoint(this.serverConnectionInfo.ServerIP, 27165)))
{
return(s.GetInfo());
}
}
/// <summary>
/// Grab server information to servers.json
/// </summary>
/// <param name="ip"></param>
/// <param name="location"></param>
/// <param name="last"></param>
static void getServerInformation(string ip, string location, bool last)
{
TextWriter text = new StreamWriter(@"servers.json", true);
Server arkserver = null;
List <int> ports = new List <int>();
ports.Add(27015);
ports.Add(27017);
ports.Add(27019);
ports.Add(27021);
ports.Add(27023);
foreach (int port in ports)
{
using (arkserver = ServerQuery.GetServerInstance(QueryMaster.EngineType.Source, ip, (ushort)port, false, 500, 500, 1, false))
{
var serverInfo = arkserver.GetInfo();
if (serverInfo != null)
{
string prettyname = serverInfo.Name.Split(' ')[0];
if (prettyname != "TrailerTeam")
{
MatchCollection match = Regex.Matches(serverInfo.Name, @"\w\d+");
string id = match[0].Value;
match = Regex.Matches(prettyname, @"(FRESH|Hardcore|CrossArk|OfflineRaidProtection|PVP|PVE|[0-9])");
string type = (match.Count != 0) ? match[0].Value : "Unknown";
if (prettyname != "")
{
text.WriteLine("\t\t{");
text.WriteLine("\t\t\t\"type\":\"" + type + "\", ");
text.WriteLine("\t\t\t\"prettyname\":\"" + prettyname + "\", ");
text.WriteLine("\t\t\t\"id\":\"" + id + "\", ");
text.WriteLine("\t\t\t\"ip\":\"" + ip + "\", ");
text.WriteLine("\t\t\t\"location\":\"" + location + "\", ");
text.WriteLine("\t\t\t\"name\":\"" + serverInfo.Name + "\", ");
text.WriteLine("\t\t\t\"map\":\"" + serverInfo.Map + "\", ");
text.WriteLine("\t\t\t\"port\":\"" + port + "\", ");
text.WriteLine("\t\t\t\"steamid\":\"" + serverInfo.Id + "\"");
string lastline = "\t\t}";
if (last && port == 27023)
{
}
else
{
lastline = lastline + ",";
}
text.WriteLine(lastline);
}
//text.WriteLine("{\"type\":\"" + type + "\",\"prettyname\":\"" + prettyname + "\",\"id\":\"" + id + "\",\"ip\":\"" + ip + "\", \"location\": \"" + location + "\", \"name\":\"" + serverInfo.Name + "\", \"map\":\"" + serverInfo.Map + "\", \"port\":" + port + ", \"steamid\":" + serverInfo.Id + "},");
//Console.WriteLine("Added server: " + serverInfo.Name);
}
}
}
}
text.Close();
}
private async Task ReconnectSource()
{
if (DateTime.Now - _sourceServerLastReconnect <= TimeSpan.FromSeconds(60))
{
return;
}
await Task.Run(() =>
{
try
{
_sourceServer?.Dispose();
_sourceServer = null;
_sourceServer = ServerQuery.GetServerInstance(QueryMaster.EngineType.Source, _config.Ip, (ushort)_config.QueryPort, false, 2000, 5000, 1, true);
}
catch (Exception ex)
{
Logging.LogException($"Failed to connect to server steamworks api ({_config.Ip}, {_config.QueryPort}). Exception Message : {ex.Message}", ex, typeof(SteamManager), LogLevel.WARN, ExceptionLevel.Ignored);
_sourceServer?.Dispose();
_sourceServer = null;
}
});
//Task reconnect = null;
//lock (_sourceServerLock)
//{
// if (_sourceServerReconnectTask != null) reconnect = Task.WhenAll(_sourceServerReconnectTask);
// else
// {
// _sourceServerLastReconnect = DateTime.Now;
// _sourceServerReconnectTask = reconnect = Task.Run(() =>
// {
// try
// {
// _sourceServer?.Dispose();
// _sourceServer = null;
// _sourceServer = ServerQuery.GetServerInstance(QueryMaster.EngineType.Source, _config.Ip, (ushort)_config.QueryPort, false, 2000, 5000, 1, true);
// }
// catch (Exception ex)
// {
// _sourceServer?.Dispose();
// _sourceServer = null;
// Logging.LogException($"Failed to connect to server steamworks api ({_config.Ip}, {_config.QueryPort})", ex, typeof(SteamManager), LogLevel.WARN, ExceptionLevel.Ignored);
// }
// });
// }
//}
//await reconnect;
//lock (_sourceServerLock)
//{
// _sourceServerReconnectTask = null;
//}
}
// getPlayerInfo() retrieves a player list grouped by team and includes
// each players Kill/Death ratio.
public static JArray getPlayerInfo(string address)
{
Tuple <string, UInt16> addr = splitAddr(address);
string addrIP = addr.Item1;
UInt16 port = addr.Item2;
var server = ServerQuery.GetServerInstance(
(Game)appId,
addrIP,
port,
throwExceptions: false,
retries: retries);
sendRcon(address, "host_players_show 2");
//QueryMasterCollection<PlayerInfo> playerInfo = server.GetPlayers();
string playerInfo = sendRcon(address, "getplayers");
sendRcon(address, "host_players_show 1");
if (playerInfo == null || playerInfo.Contains("Unknown"))
{
server.Dispose();
Console.WriteLine("Error fetching player information.");
return(null);
}
List <PlayerModel> playerList_T = new List <PlayerModel>();
List <PlayerModel> playerList_CT = new List <PlayerModel>();
using (StringReader reader = new StringReader(playerInfo))
{
string line;
while ((line = reader.ReadLine()) != null)
{
string[] splitter = line.Split(':');
switch (splitter[1])
{
case "T":
playerList_T.Add(new PlayerModel(splitter[0], splitter[1], splitter[2], splitter[3]));
break;
case "CT":
playerList_CT.Add(new PlayerModel(splitter[0], splitter[1], splitter[2], splitter[3]));
break;
}
}
}
var playerJsonStr_T = JsonConvert.SerializeObject(playerList_T, Formatting.Indented);
var playerJsonStr_CT = JsonConvert.SerializeObject(playerList_CT, Formatting.Indented);
var jaT = (JArray)JsonConvert.DeserializeObject(playerJsonStr_T);
var jaCT = (JArray)JsonConvert.DeserializeObject(playerJsonStr_CT);
var jaBothTeams = new JArray(jaT, jaCT);
server.Dispose();
return(jaBothTeams);
}
static async void OutputServerRules(ServerQuery serverQuery)
{
ServerRule[] serverRules = await serverQuery.QueryServerRulesAsync();
foreach (var item in serverRules)
{
Console.WriteLine(item.RuleName + " : " + item.RuleValue);
}
}