Exemple #1
0
        public async Task ParsePlayersAsync()
        {
            container = await ArkDataContainer.CreateAsync(Directory);

            Assert.IsTrue(container.Players.Count > 0);
            Assert.IsTrue(container.Tribes.Count > 0);
        }
Exemple #2
0
        public async Task ParsePlayersAsync()
        {
            container = await ArkDataContainer.CreateAsync(Directory);

            Assert.IsTrue(container.Players.Count > 0);
            Assert.IsTrue(container.Tribes.Count > 0);
        }
Exemple #3
0
        public void ParsePlayers()
        {
            container = ArkDataContainer.Create(Directory);

            Assert.IsTrue(container.Players.Count > 0);
            Assert.IsTrue(container.Tribes.Count > 0);
        }
Exemple #4
0
        public void ParsePlayers()
        {
            container = ArkDataContainer.Create(Directory);

            Assert.IsTrue(container.Players.Count > 0);
            Assert.IsTrue(container.Tribes.Count > 0);
        }
Exemple #5
0
        public static async void Start(string folder, string api_key,
                                string ip_address, int port, string url)
        {
            try
            {
                Program.cfgForm.Log("Loading ARK profiles...");
                container = await ArkDataContainer.CreateAsync(folder);

                Program.cfgForm.Log("Linking Steam profiles...");
                await container.LoadSteamAsync(api_key);

                Program.cfgForm.Log("Loading online players...");
                await container.LoadOnlinePlayersAsync(ip_address, port);
                Program.cfgForm.Log(container.Players.Where(p => p.Online).Count() + " players online.");

                Program.cfgForm.Log("Starting HTTP server...");

                webSvc = WebApp.Start<ServerStartup>(url);

                server_running = true;

                online_refresh = new Timer();
                online_refresh.Interval = 180000;
                online_refresh.Tick += async (sender, e) =>
                {
                    try
                    {
                        ArkDataContainer cont;
                        cont = await ArkDataContainer.CreateAsync(folder);
                        await cont.LoadSteamAsync(api_key);
                        await cont.LoadOnlinePlayersAsync(ip_address, port);
                        lock (containerLock)
                            container = cont;
                        Program.cfgForm.Log(container.Players.Where(p => p.Online).Count() + " players online.");
                    }
                    catch (Exception ex)
                    {
                        handleException(ex);
                    }
                };
                online_refresh.Start();

                Program.cfgForm.Log("Server is running.");
            }
            catch (System.Exception ex)
            {
                handleException(ex);
            }
        }
        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;
            }
        }