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 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();
}
}
private async Task LoadWorldSaveFiles()
{
var cursor = this.Cursor;
try
{
Application.Current.Dispatcher.Invoke(() => this.Cursor = System.Windows.Input.Cursors.Wait);
await Task.Delay(500);
WorldSaveFiles.Clear();
var saveFolder = ServerProfile.GetProfileSavePath(_profile);
if (!Directory.Exists(saveFolder))
{
return;
}
var saveFolderInfo = new DirectoryInfo(saveFolder);
var mapName = ServerProfile.GetProfileMapFileName(_profile);
var mapFileName = $"{mapName}{Config.Default.MapExtension}";
var searchPattern = $"{mapName}*{Config.Default.MapExtension}";
var saveFiles = saveFolderInfo.GetFiles(searchPattern);
foreach (var file in saveFiles)
{
WorldSaveFiles.Add(new WorldSaveFile {
File = file.FullName, FileName = file.Name, CreatedDate = file.CreationTime, UpdatedDate = file.LastWriteTime, IsArchiveFile = false, IsActiveFile = file.Name.Equals(mapFileName, StringComparison.OrdinalIgnoreCase)
});
}
var backupFolder = ServerApp.GetServerBackupFolder(_profile.ProfileName);
if (Directory.Exists(backupFolder))
{
var backupFolderInfo = new DirectoryInfo(backupFolder);
searchPattern = $"{mapName}*{Config.Default.BackupExtension}";
var backupFiles = backupFolderInfo.GetFiles(searchPattern);
foreach (var file in backupFiles)
{
WorldSaveFiles.Add(new WorldSaveFile {
File = file.FullName, FileName = file.Name, CreatedDate = file.CreationTime, UpdatedDate = file.LastWriteTime, IsArchiveFile = true, IsActiveFile = false
});
}
}
WorldSaveFiles.Sort(f => f, new WorldSaveFileComparer());
}
finally
{
Application.Current.Dispatcher.Invoke(() => this.Cursor = cursor);
}
}
private async Task LoadWorldSaveFiles()
{
var cursor = this.Cursor;
try
{
Application.Current.Dispatcher.Invoke(() => this.Cursor = System.Windows.Input.Cursors.Wait);
await Task.Delay(500);
WorldSaveFiles.Clear();
var profileSaveFolder = ServerProfile.GetProfileSavePath(_profile);
if (!Directory.Exists(profileSaveFolder))
{
return;
}
var profileSaveFolderInfo = new DirectoryInfo(profileSaveFolder);
var mapName = ServerProfile.GetProfileMapFileName(_profile);
var mapFileName = $"{mapName}.ark";
var searchPattern = $"{mapName}*.ark";
foreach (var file in profileSaveFolderInfo.GetFiles(searchPattern))
{
WorldSaveFiles.Add(new WorldSaveFile {
File = file.FullName, FileName = file.Name, CreatedDate = file.CreationTime, UpdatedDate = file.LastWriteTime, IsActiveFile = file.Name.Equals(mapFileName, StringComparison.OrdinalIgnoreCase)
});
}
WorldSaveFiles.Sort(f => f, new WorldSaveFileComparer());
}
finally
{
Application.Current.Dispatcher.Invoke(() => this.Cursor = cursor);
}
}
private async Task <List <string> > UpdatePlayerDetailsAsync(CancellationToken token)
{
if (this._disposed)
{
return(new List <string>());
}
if (string.IsNullOrWhiteSpace(_rconParameters.GameFile) || !File.Exists(_rconParameters.GameFile))
{
return(new List <string>());
}
var savedPath = ServerProfile.GetProfileSavePath(_rconParameters.InstallDirectory);
DataContainer dataContainer = null;
try
{
// load the player data from the files.
dataContainer = await DataContainer.CreateAsync(_rconParameters.GameFile);
}
catch (Exception ex)
{
_errorLogger?.Error($"{nameof(UpdatePlayerDetailsAsync)} - Error: CreateAsync. {ex.Message}\r\n{ex.StackTrace}");
return(new List <string>());
}
if (token.IsCancellationRequested)
{
return(new List <string>());
}
await Task.Run(() =>
{
// update the player data with the latest update value from the players collection
foreach (var playerData in dataContainer.Players)
{
var id = playerData.PlayerId;
if (string.IsNullOrWhiteSpace(id))
{
continue;
}
this._players.TryGetValue(id, out PlayerInfo player);
player?.UpdatePlatformData(playerData);
}
}, token);
if (token.IsCancellationRequested)
{
return(new List <string>());
}
var totalPlayers = dataContainer.Players.Count;
var output = new List <string>();
foreach (var playerData in dataContainer.Players)
{
token.ThrowIfCancellationRequested();
await Task.Run(async() =>
{
var id = playerData.PlayerId;
if (!string.IsNullOrWhiteSpace(id))
{
var validPlayer = new PlayerInfo()
{
PlayerId = id,
PlayerName = playerData.PlayerName,
IsValid = true,
};
this._players.AddOrUpdate(id, validPlayer, (k, v) => { v.PlayerName = playerData.PlayerName; v.IsValid = true; return(v); });
}
else
{
_debugLogger?.Debug($"{nameof(UpdatePlayerDetailsAsync)} - Error: corrupted profile.\r\n{playerData.CharacterId}.");
}
if (this._players.TryGetValue(id, out PlayerInfo player) && player != null)
{
if (player.IsOnline != playerData.Online)
{
if (playerData.Online)
{
var messageFormat = GlobalizedApplication.Instance.GetResourceString("Player_Join") ?? "Player '{0}' joined the game.";
var message = string.Format(messageFormat, playerData.CharacterName);
output.Add(message);
LogEvent(LogEventType.Event, message);
LogEvent(LogEventType.All, message);
}
else
{
var messageFormat = GlobalizedApplication.Instance.GetResourceString("Player_Leave") ?? "Player '{0}' left the game.";
var message = string.Format(messageFormat, playerData.CharacterName);
output.Add(message);
LogEvent(LogEventType.Event, message);
LogEvent(LogEventType.All, message);
}
}
player.UpdateData(playerData);
await TaskUtils.RunOnUIThreadAsync(() =>
{
player.IsWhitelisted = _rconParameters?.Server?.Profile?.ServerFilesWhitelisted?.Any(u => u.PlayerId.Equals(player.PlayerId, StringComparison.OrdinalIgnoreCase)) ?? false;
});
}
}, token);
}
if (token.IsCancellationRequested)
{
return(new List <string>());
}
// remove any players that do not have a player record.
var droppedPlayers = this._players.Values.Where(p => dataContainer.Players.FirstOrDefault(pd => pd.PlayerId.Equals(p.PlayerId, StringComparison.OrdinalIgnoreCase)) == null).ToArray();
foreach (var droppedPlayer in droppedPlayers)
{
_players.TryRemove(droppedPlayer.PlayerId, out PlayerInfo player);
}
return(output);
}
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
{
// load the player data from the files.
dataContainer = await DataContainer.CreateAsync(savedPath, savedPath);
}
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)
{
var id = playerData.PlayerId;
if (string.IsNullOrWhiteSpace(id))
{
continue;
}
_players.TryGetValue(id, out PlayerInfo player);
player?.UpdatePlatformData(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}");
}
token.ThrowIfCancellationRequested();
var totalPlayers = dataContainer.Players.Count;
foreach (var playerData in dataContainer.Players)
{
token.ThrowIfCancellationRequested();
await Task.Run(async() =>
{
var id = playerData.PlayerId;
if (!string.IsNullOrWhiteSpace(id))
{
var validPlayer = new PlayerInfo()
{
PlayerId = playerData.PlayerId,
PlayerName = playerData.PlayerName,
IsValid = true,
};
_players.AddOrUpdate(id, validPlayer, (k, v) => { v.PlayerName = playerData.PlayerName; v.IsValid = true; return(v); });
}
else
{
id = Path.GetFileNameWithoutExtension(playerData.Filename);
if (!string.IsNullOrWhiteSpace(id))
{
var invalidPlayer = new PlayerInfo()
{
PlayerId = id,
PlayerName = "< corrupted profile >",
IsValid = false,
};
_players.AddOrUpdate(id, invalidPlayer, (k, v) => { v.PlayerName = "< corrupted profile >"; v.IsValid = false; return(v); });
}
else
{
_debugLogger?.Debug($"{nameof(UpdatePlayerDetailsAsync)} - Error: corrupted profile.\r\n{playerData.Filename}.");
}
}
if (_players.TryGetValue(id, out PlayerInfo player) && player != null)
{
player.UpdateData(playerData);
await TaskUtils.RunOnUIThreadAsync(() =>
{
player.IsAdmin = _playerListParameters?.Server?.Profile?.ServerFilesAdmins?.Any(u => u.PlayerId.Equals(player.PlayerId, StringComparison.OrdinalIgnoreCase)) ?? false;
player.IsWhitelisted = _playerListParameters?.Server?.Profile?.ServerFilesWhitelisted?.Any(u => u.PlayerId.Equals(player.PlayerId, StringComparison.OrdinalIgnoreCase)) ?? false;
});
}
}, token);
}
token.ThrowIfCancellationRequested();
// remove any players that do not have a player file.
var droppedPlayers = _players.Values.Where(p => dataContainer.Players.FirstOrDefault(pd => pd.PlayerId.Equals(p.PlayerId, StringComparison.OrdinalIgnoreCase)) == null).ToArray();
foreach (var droppedPlayer in droppedPlayers)
{
_players.TryRemove(droppedPlayer.PlayerId, out PlayerInfo player);
}
}
}
private async Task UpdatePlayerDetails()
{
if (updatingPlayerDetails)
{
return;
}
updatingPlayerDetails = true;
try
{
if (!String.IsNullOrEmpty(rconParams.InstallDirectory))
{
var savedPath = ServerProfile.GetProfileSavePath(rconParams.InstallDirectory, rconParams.AltSaveDirectoryName, rconParams.PGM_Enabled, rconParams.PGM_Name);
ArkDataContainer dataContainer = null;
try
{
dataContainer = await ArkDataContainer.CreateAsync(savedPath);
}
catch (Exception ex)
{
errorLogger.Error($"{nameof(UpdatePlayerDetails)} - Error: CreateAsync. {ex.Message}\r\n{ex.StackTrace}");
return;
}
try
{
await dataContainer.LoadSteamAsync(SteamUtils.SteamWebApiKey);
}
catch (Exception ex)
{
errorLogger.Error($"{nameof(UpdatePlayerDetails)} - Error: LoadSteamAsync. {ex.Message}\r\n{ex.StackTrace}");
return;
}
TaskUtils.RunOnUIThreadAsync(() =>
{
// create a new temporary list
List <PlayerInfo> players = new List <PlayerInfo>(this.Players.Count + dataContainer.Players.Count);
players.AddRange(this.Players);
foreach (var playerData in dataContainer.Players)
{
PlayerInfo player = null;
if (Int64.TryParse(playerData.SteamId, out long steamId))
{
player = players.FirstOrDefault(p => p.SteamId == steamId);
if (player == null)
{
player = new PlayerInfo(this.debugLogger)
{
SteamId = steamId,
SteamName = playerData.SteamName
};
players.Add(player);
}
player.IsValid = true;
}
else
{
var filename = Path.GetFileNameWithoutExtension(playerData.Filename);
if (Int64.TryParse(filename, out steamId))
{
player = players.FirstOrDefault(p => p.SteamId == steamId);
if (player == null)
{
player = new PlayerInfo(this.debugLogger)
{
SteamId = steamId,
SteamName = "< corrupted profile >"
};
players.Add(player);
}
player.IsValid = false;
}
else
{
debugLogger.Debug($"{nameof(UpdatePlayerDetails)} - Error: corrupted profile.\r\n{playerData.Filename}.");
}
}
if (player != null)
{
player.UpdateDataAsync(playerData, savedPath).DoNotWait();
}
}
this.Players = new SortableObservableCollection <PlayerInfo>(players);
OnPlayerCollectionUpdated();
}).DoNotWait();
}
}
finally
{
updatingPlayerDetails = false;
}
}
private async Task UpdatePlayerDetailsAsync(CancellationToken token)
{
if (!string.IsNullOrWhiteSpace(rconParams.InstallDirectory))
{
var savedPath = ServerProfile.GetProfileSavePath(rconParams.InstallDirectory, rconParams.AltSaveDirectoryName, rconParams.PGM_Enabled, rconParams.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;
}
this.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(this.debugLogger)
{
SteamId = steamId,
SteamName = playerData.SteamName,
IsValid = true,
};
this.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(this.debugLogger)
{
SteamId = steamId,
SteamName = "< corrupted profile >",
IsValid = false,
};
this.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 (this.players.TryGetValue(steamId, out PlayerInfo player) && player != null)
{
player.UpdateData(playerData, lastSteamUpdateUtc);
await TaskUtils.RunOnUIThreadAsync(() =>
{
player.IsAdmin = rconParams?.Server?.Profile?.ServerFilesAdmins?.Any(u => u.SteamId.Equals(player.SteamId.ToString(), StringComparison.OrdinalIgnoreCase)) ?? false;
player.IsWhitelisted = rconParams?.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 = this.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);
}
}
}
