private async Task UpdatePlayerDetails()
{
if (!String.IsNullOrEmpty(rconParams.InstallDirectory))
{
var savedArksPath = ServerProfile.GetProfileSavePath(rconParams.InstallDirectory, rconParams.AltSaveDirectoryName, rconParams.PGM_Enabled, rconParams.PGM_Name);
var arkData = await ArkData.ArkDataContainer.CreateAsync(savedArksPath);
await arkData.LoadSteamAsync(Config.Default.SteamAPIKey);
TaskUtils.RunOnUIThreadAsync(() =>
{
foreach (var playerData in arkData.Players)
{
var playerToUpdate = this.Players.FirstOrDefault(p => p.SteamId == Int64.Parse(playerData.SteamId));
if (playerToUpdate != null)
{
playerToUpdate.UpdateArkDataAsync(playerData).DoNotWait();
}
else
{
var newPlayer = new PlayerInfo()
{
SteamId = Int64.Parse(playerData.SteamId), SteamName = playerData.SteamName
};
newPlayer.UpdateArkDataAsync(playerData).DoNotWait();
this.Players.Add(newPlayer);
}
}
}).DoNotWait();
}
}
private async Task UpdatePlayersAsync()
{
if (_disposed)
{
return;
}
_cancellationTokenSource = new CancellationTokenSource();
var token = _cancellationTokenSource.Token;
await UpdatePlayerDetailsAsync(_cancellationTokenSource.Token)
.ContinueWith(async t1 =>
{
await TaskUtils.RunOnUIThreadAsync(() =>
{
UpdatePlayerCollection();
});
}, TaskContinuationOptions.NotOnCanceled)
.ContinueWith(t2 =>
{
var cancelled = _cancellationTokenSource.IsCancellationRequested;
_cancellationTokenSource.Dispose();
_cancellationTokenSource = null;
if (!cancelled)
{
Task.Delay(PLAYER_LIST_INTERVAL).ContinueWith(t3 => UpdatePlayersAsync());
}
});
}
private async Task UpdatePlayerDetails()
{
var savedArksPath = Path.Combine(snapshot.InstallDirectory, Config.Default.SavedArksRelativePath);
var arkData = await ArkData.ArkDataContainer.CreateAsync(savedArksPath);
await arkData.LoadSteamAsync(Config.Default.SteamAPIKey);
TaskUtils.RunOnUIThreadAsync(() =>
{
foreach (var playerData in arkData.Players)
{
var playerToUpdate = this.Players.FirstOrDefault(p => p.SteamId == Int64.Parse(playerData.SteamId));
if (playerToUpdate != null)
{
playerToUpdate.UpdateArkData(playerData).DoNotWait();
}
else
{
var newPlayer = new PlayerInfo()
{
SteamId = Int64.Parse(playerData.SteamId), SteamName = playerData.SteamName
};
newPlayer.UpdateArkData(playerData).DoNotWait();
this.Players.Add(newPlayer);
}
}
}).DoNotWait();
}
private void ProcessStatusUpdate(IAsyncDisposable registration, ServerStatusWatcher.ServerStatusUpdate update)
{
if (!Object.ReferenceEquals(registration, this.updateRegistration))
{
return;
}
TaskUtils.RunOnUIThreadAsync(() =>
{
switch (update.Status)
{
case ServerStatusWatcher.ServerStatus.NotInstalled:
this.Status = ServerStatus.Uninstalled;
this.Steam = SteamStatus.Unavailable;
break;
case ServerStatusWatcher.ServerStatus.Initializing:
this.Status = ServerStatus.Initializing;
this.Steam = SteamStatus.Unavailable;
break;
case ServerStatusWatcher.ServerStatus.Stopped:
this.Status = ServerStatus.Stopped;
this.Steam = SteamStatus.Unavailable;
break;
case ServerStatusWatcher.ServerStatus.Running:
this.Status = ServerStatus.Running;
this.Steam = SteamStatus.WaitingForPublication;
break;
case ServerStatusWatcher.ServerStatus.Published:
this.Status = ServerStatus.Running;
this.Steam = SteamStatus.Available;
break;
}
if (update.ServerInfo != null)
{
var match = Regex.Match(update.ServerInfo.Name, @"\(v([0-9]+\.[0-9]*)\)");
if (match.Success && match.Groups.Count >= 2)
{
var serverVersion = match.Groups[1].Value;
Version temp;
if (!String.IsNullOrWhiteSpace(serverVersion) && Version.TryParse(serverVersion, out temp))
{
this.Version = temp;
}
}
// set the player count using the players list, as this should only contain the current valid players.
this.Players = update.Players.Count;
this.MaxPlayers = update.ServerInfo.MaxPlayers;
}
this.serverProcess = update.Process;
}).DoNotWait();
}
private async Task UpdatePlayerDetails()
{
if (updatingPlayerDetails)
{
return;
}
updatingPlayerDetails = true;
if (!String.IsNullOrEmpty(rconParams.InstallDirectory))
{
var savedArksPath = ServerProfile.GetProfileSavePath(rconParams.InstallDirectory, rconParams.AltSaveDirectoryName, rconParams.PGM_Enabled, rconParams.PGM_Name);
var arkData = await ArkData.ArkDataContainer.CreateAsync(savedArksPath);
try
{
await arkData.LoadSteamAsync(SteamUtils.SteamWebApiKey);
}
catch (Exception ex)
{
Debug.WriteLine($"Error: UpdatePlayerDetails - arkData.LoadSteamAsync - {ex.Message}");
}
TaskUtils.RunOnUIThreadAsync(() =>
{
// create a new temporary list
List <PlayerInfo> players = new List <PlayerInfo>(this.Players.Count + arkData.Players.Count);
players.AddRange(this.Players);
try
{
foreach (var playerData in arkData.Players)
{
var player = players.FirstOrDefault(p => p.SteamId == Int64.Parse(playerData.SteamId));
if (player == null)
{
player = new PlayerInfo()
{
SteamId = Int64.Parse(playerData.SteamId), SteamName = playerData.SteamName
};
players.Add(player);
}
if (player != null)
{
player.UpdateArkDataAsync(playerData).DoNotWait();
}
}
this.Players = new SortableObservableCollection <PlayerInfo>(players);
OnPlayerCollectionUpdated();
}
finally
{
updatingPlayerDetails = false;
}
}).DoNotWait();
}
}
public async Task CheckForUpdatesAsync()
{
var result = await NetworkUtils.GetLatestAvailableVersion();
await TaskUtils.RunOnUIThreadAsync(() => this.AvailableVersion = result.Current);
}
private async Task UpdatePlayerDetailsAsync(CancellationToken token)
{
if (!string.IsNullOrWhiteSpace(_playerListParameters.InstallDirectory))
{
var savedPath = ServerProfile.GetProfileSavePath(_playerListParameters.InstallDirectory, _playerListParameters.AltSaveDirectoryName, _playerListParameters.PGM_Enabled, _playerListParameters.PGM_Name);
DataContainer dataContainer = null;
DateTime lastSteamUpdateUtc = DateTime.MinValue;
try
{
DataFileDetails.PlayerFileFolder = savedPath;
DataFileDetails.TribeFileFolder = savedPath;
// load the player data from the files.
dataContainer = await DataContainer.CreateAsync();
}
catch (Exception ex)
{
_errorLogger.Error($"{nameof(UpdatePlayerDetailsAsync)} - Error: CreateAsync. {ex.Message}\r\n{ex.StackTrace}");
return;
}
token.ThrowIfCancellationRequested();
await Task.Run(() =>
{
// update the player data with the latest steam update value from the players collection
foreach (var playerData in dataContainer.Players)
{
if (!long.TryParse(playerData.SteamId, out long steamId))
{
continue;
}
_players.TryGetValue(steamId, out PlayerInfo player);
player?.UpdateSteamData(playerData);
}
}, token);
try
{
// load the player data from steam
lastSteamUpdateUtc = await dataContainer.LoadSteamAsync(SteamUtils.SteamWebApiKey, STEAM_UPDATE_INTERVAL);
}
catch (Exception ex)
{
_errorLogger.Error($"{nameof(UpdatePlayerDetailsAsync)} - Error: LoadSteamAsync. {ex.Message}\r\n{ex.StackTrace}");
return;
}
token.ThrowIfCancellationRequested();
var totalPlayers = dataContainer.Players.Count;
foreach (var playerData in dataContainer.Players)
{
token.ThrowIfCancellationRequested();
await Task.Run(async() =>
{
if (long.TryParse(playerData.SteamId, out long steamId))
{
var validPlayer = new PlayerInfo(_debugLogger)
{
SteamId = steamId,
SteamName = playerData.SteamName,
IsValid = true,
};
_players.AddOrUpdate(steamId, validPlayer, (k, v) => { v.SteamName = playerData.SteamName; v.IsValid = true; return(v); });
}
else
{
var filename = Path.GetFileNameWithoutExtension(playerData.Filename);
if (long.TryParse(filename, out steamId))
{
var invalidPlayer = new PlayerInfo(_debugLogger)
{
SteamId = steamId,
SteamName = "< corrupted profile >",
IsValid = false,
};
_players.AddOrUpdate(steamId, invalidPlayer, (k, v) => { v.SteamName = "< corrupted profile >"; v.IsValid = false; return(v); });
}
else
{
_debugLogger.Debug($"{nameof(UpdatePlayerDetailsAsync)} - Error: corrupted profile.\r\n{playerData.Filename}.");
}
}
if (_players.TryGetValue(steamId, out PlayerInfo player) && player != null)
{
player.UpdateData(playerData, lastSteamUpdateUtc);
await TaskUtils.RunOnUIThreadAsync(() =>
{
player.IsAdmin = _playerListParameters?.Server?.Profile?.ServerFilesAdmins?.Any(u => u.SteamId.Equals(player.SteamId.ToString(), StringComparison.OrdinalIgnoreCase)) ?? false;
player.IsWhitelisted = _playerListParameters?.Server?.Profile?.ServerFilesWhitelisted?.Any(u => u.SteamId.Equals(player.SteamId.ToString(), StringComparison.OrdinalIgnoreCase)) ?? false;
if (totalPlayers <= Config.Default.RCON_MaximumPlayerAvatars && Config.Default.RCON_ShowPlayerAvatars)
{
player.UpdateAvatarImageAsync(savedPath).DoNotWait();
}
});
}
}, token);
}
token.ThrowIfCancellationRequested();
// remove any players that do not have a player file.
var droppedPlayers = _players.Values.Where(p => dataContainer.Players.FirstOrDefault(pd => pd.SteamId == p.SteamId.ToString()) == null).ToArray();
foreach (var droppedPlayer in droppedPlayers)
{
_players.TryRemove(droppedPlayer.SteamId, out PlayerInfo player);
}
}
}
public static async Task WriteFormatThreadSafeAsync(string format, params object[] args)
{
await TaskUtils.RunOnUIThreadAsync(() => Debug.WriteLine(format, args));
}
