private async Task UpdateGameServerAsync()
{
if (steamServerQueryService == null)
{
return;
}
IsBusy = true;
try
{
Parsers.TryParseIPEndpoint(ServerAdress, out var endPoint);
steamServerQueryService.EndPoint = endPoint;
SteamServerInfo serverInfo = null;
List <PlayerInfo> playerInfo = null;
try
{
serverInfo = await steamServerQueryService.GetServerInfoAsync().ConfigureAwait(false);
playerInfo = (await steamServerQueryService.GetPlayersAsync().ConfigureAwait(false))?.Where(x => !string.IsNullOrEmpty(x.Name)).OrderBy(x => x.Name).ToList();
}
catch (Exception ex)
{
ConnectError = true;
//Connected = false;
return;
}
Application.Current.Dispatcher.Invoke(new Action(() =>
{
ConnectError = false;
Connected = true;
PlayerCount = serverInfo.Players;
if (playerInfo != null)
{
if (OnlinePlayers == null)
{
OnlinePlayers = new ObservableRangeCollection <PlayerInfo>(playerInfo);
}
else
{
OnlinePlayers.ReplaceRange(playerInfo);
}
PlayerCount = OnlinePlayers.Count();
}
MaxPlayerCount = serverInfo.MaxPlayers;
ServerHeading = $"{serverInfo.Name} ({PlayerCount}/{MaxPlayerCount})";
}));
}
finally
{
IsBusy = false;
}
}
private void onPingResponded(gameserveritem_t data)
{
this.isAttemptingServerQuery = false;
this.cleanupServerQuery();
if (data.m_nAppID == Provider.APP_ID.m_AppId)
{
SteamServerInfo steamServerInfo = new SteamServerInfo(data);
if (!steamServerInfo.isPro || Provider.isPro)
{
if (!steamServerInfo.isPassworded || this.connectionInfo.password != string.Empty)
{
if (this.autoJoinServerQuery)
{
Provider.connect(steamServerInfo, this.connectionInfo.password);
}
else
{
MenuUI.closeAll();
MenuUI.closeAlert();
MenuPlayServerInfoUI.open(steamServerInfo, this.connectionInfo.password, MenuPlayServerInfoUI.EServerInfoOpenContext.CONNECT);
}
}
else
{
Provider._connectionFailureInfo = ESteamConnectionFailureInfo.PASSWORD;
}
}
else
{
Provider._connectionFailureInfo = ESteamConnectionFailureInfo.PRO_SERVER;
}
}
else
{
Provider._connectionFailureInfo = ESteamConnectionFailureInfo.TIMED_OUT;
}
if (this.onTimedOut != null)
{
this.onTimedOut();
}
}
private void onServerListResponded(HServerListRequest request, int index)
{
if (request != this.serverListRequest)
{
return;
}
gameserveritem_t serverDetails = SteamMatchmakingServers.GetServerDetails(request, index);
if (this.matchmakingIgnored.Contains(serverDetails.m_steamID.m_SteamID))
{
return;
}
SteamServerInfo steamServerInfo = new SteamServerInfo(serverDetails);
if (index == this.serverListRefreshIndex)
{
if (this.onMasterServerQueryRefreshed != null)
{
this.onMasterServerQueryRefreshed(steamServerInfo);
}
return;
}
if (FilterSettings.filterPlugins == EPlugins.NO)
{
if (serverDetails.m_nBotPlayers != 0)
{
return;
}
}
else if (FilterSettings.filterPlugins == EPlugins.YES && serverDetails.m_nBotPlayers != 1)
{
return;
}
if (steamServerInfo.maxPlayers < (int)CommandMaxPlayers.MIN_NUMBER)
{
return;
}
if (this.currentList == ESteamServerList.INTERNET)
{
if (steamServerInfo.maxPlayers > (int)(CommandMaxPlayers.MAX_NUMBER / 2))
{
return;
}
}
else if (steamServerInfo.maxPlayers > (int)CommandMaxPlayers.MAX_NUMBER)
{
return;
}
if (PlaySettings.serversName != null && PlaySettings.serversName.Length > 1 && steamServerInfo.name.IndexOf(PlaySettings.serversName, StringComparison.OrdinalIgnoreCase) == -1)
{
return;
}
int num = this.serverList.BinarySearch(steamServerInfo, this.serverInfoComparer);
if (num < 0)
{
num = ~num;
}
this.serverList.Insert(num, steamServerInfo);
if (this.onMasterServerAdded != null)
{
this.onMasterServerAdded(num, steamServerInfo);
}
this.matchmakingBestServer = null;
int num2 = 25;
while (this.matchmakingBestServer == null && num2 <= OptionsSettings.maxMatchmakingPing)
{
int num3 = -1;
foreach (SteamServerInfo steamServerInfo2 in this.serverList)
{
if (steamServerInfo2.players < OptionsSettings.minMatchmakingPlayers)
{
break;
}
if (steamServerInfo2.players != num3)
{
num3 = steamServerInfo2.players;
if (steamServerInfo2.ping <= num2)
{
this.matchmakingBestServer = steamServerInfo2;
break;
}
}
}
num2 += 25;
}
if (this.matchmakingProgressed != null)
{
this.matchmakingProgressed();
}
}
public async Task <SteamServerInfo> GetServerInfoAsync()
{
var response = await GetServerResponseAsync(QueryMsg.InfoQuery);
return(SteamServerInfo.Parse(response)); // Skip header
}
