Component Refactor

- Ping
- Player Regen
- Player Save
- Player Cooldown
- Player Status / Threat

Author: FallenDev

Zolian.Server.Base/Network/Components/PingComponent.cs

@@ -11,38 +11,45 @@ public class PingComponent(WorldServer server) : WorldServerComponent(server)
 
     protected internal override async Task Update()
     {
-        var componentStopWatch = new Stopwatch();
-        componentStopWatch.Start();
-        var variableGameSpeed = ComponentSpeed;
+        var sw = Stopwatch.StartNew();
+        var target = ComponentSpeed;
 
         while (ServerSetup.Instance.Running)
         {
-            if (componentStopWatch.Elapsed.TotalMilliseconds < variableGameSpeed)
+            var elapsed = sw.Elapsed.TotalMilliseconds;
+            if (elapsed < target)
             {
-                await Task.Delay(50);
+                var remaining = (int)(target - elapsed);
+
+                // Clamp to avoid super tiny delays
+                if (remaining > 0)
+                    await Task.Delay(Math.Min(remaining, 50));
                 continue;
             }
 
-            var players = Server.Aislings;
-            players.AsParallel()
-                .WithDegreeOfParallelism(Environment.ProcessorCount)
-                .ForAll(Ping);
+            foreach (var player in Server.Aislings)
+                Ping(player);
 
-            var awaiter = (int)(ComponentSpeed - componentStopWatch.Elapsed.TotalMilliseconds);
+            var postElapsed = sw.Elapsed.TotalMilliseconds;
+            var overshoot = postElapsed - ComponentSpeed;
 
-            if (awaiter < 0)
+            if (overshoot > 0)
             {
-                variableGameSpeed = ComponentSpeed + awaiter;
-                componentStopWatch.Restart();
-                continue;
+                // Compensate next tick by firing slightly earlier
+                target = ComponentSpeed - (int)overshoot;
+                if (target < 0)
+                    target = 0;
+            }
+            else
+            {
+                target = ComponentSpeed;
             }
 
-            await Task.Delay(TimeSpan.FromMilliseconds(awaiter));
-            variableGameSpeed = ComponentSpeed;
-            componentStopWatch.Restart();
+            sw.Restart();
         }
     }
 
+
     private static void Ping(Aisling player)
     {
         if (player?.Client == null) return;

Zolian.Server.Base/Network/Components/PlayerRegenerationComponent.cs

@@ -1,5 +1,4 @@
 using System.Diagnostics;
-
 using Darkages.Enums;
 using Darkages.Network.Client;
 using Darkages.Network.Server;
@@ -9,79 +8,64 @@ namespace Darkages.Network.Components;
 
 public class PlayerRegenerationComponent(WorldServer server) : WorldServerComponent(server)
 {
-    private static readonly Stopwatch PlayerRegenControl = new();
     private const int ComponentSpeed = 1000;
 
     protected internal override async Task Update()
     {
-        var componentStopWatch = new Stopwatch();
-        componentStopWatch.Start();
-        var variableGameSpeed = ComponentSpeed;
+        var sw = Stopwatch.StartNew();
+        var target = ComponentSpeed;
 
         while (ServerSetup.Instance.Running)
         {
-            if (componentStopWatch.Elapsed.TotalMilliseconds < variableGameSpeed)
+            var elapsed = sw.Elapsed.TotalMilliseconds;
+            if (elapsed < target)
             {
-                await Task.Delay(1);
+                var remaining = (int)(target - elapsed);
+
+                if (remaining > 0)
+                    await Task.Delay(Math.Min(remaining, 50));
+
                 continue;
             }
 
-            _ = UpdatePlayerRegeneration();
-            var awaiter = (int)(ComponentSpeed - componentStopWatch.Elapsed.TotalMilliseconds);
+            UpdatePlayerRegeneration();
+
+            var postElapsed = sw.Elapsed.TotalMilliseconds;
+            var overshoot = postElapsed - ComponentSpeed;
 
-            if (awaiter < 0)
+            if (overshoot > 0 && overshoot < ComponentSpeed)
             {
-                variableGameSpeed = ComponentSpeed + awaiter;
-                componentStopWatch.Restart();
-                continue;
+                // Slightly compensate next tick if we ran late
+                target = ComponentSpeed - (int)overshoot;
+            }
+            else
+            {
+                target = ComponentSpeed;
             }
 
-            await Task.Delay(TimeSpan.FromMilliseconds(awaiter));
-            variableGameSpeed = ComponentSpeed;
-            componentStopWatch.Restart();
+            sw.Restart();
         }
     }
 
-    private static async Task UpdatePlayerRegeneration()
+    private void UpdatePlayerRegeneration()
     {
-        if (!ServerSetup.Instance.Running || !Server.Aislings.Any()) return;
-        const int maxConcurrency = 10;
-        var semaphore = new SemaphoreSlim(maxConcurrency);
-        var playerUpdateTasks = new List<Task>();
+        var players = Server.Aislings
+            .Where(p => p?.Client != null && p.LoggedIn)
+            .ToList();
 
-        if (!PlayerRegenControl.IsRunning)
-            PlayerRegenControl.Start();
+        if (players.Count == 0)
+            return;
 
-        if (PlayerRegenControl.Elapsed.TotalMilliseconds < 1000) return;
-
-        try
-        {
-            var players = Server.Aislings.Where(player => player?.Client != null).ToList();
-
-            foreach (var player in players)
-            {
-                await semaphore.WaitAsync();
-                var task = ProcessUpdates(player).ContinueWith(t =>
-                {
-                    semaphore.Release();
-                }, TaskScheduler.Default);
-
-                playerUpdateTasks.Add(task);
-            }
-
-            await Task.WhenAll(playerUpdateTasks);
-            PlayerRegenControl.Restart();
-        }
-        catch (Exception ex)
-        {
-            SentrySdk.CaptureException(ex);
-        }
+        foreach (var player in players)
+            ProcessUpdates(player);
     }
 
-    private static Task ProcessUpdates(Aisling player)
+    private static void ProcessUpdates(Aisling player)
     {
-        if (player?.Client == null) return Task.CompletedTask;
-        if (!player.LoggedIn) return Task.CompletedTask;
+        if (player?.Client == null) return;
+        if (!player.LoggedIn) return;
+
+        // Statuses that disable regen
         if (player.IsPoisoned || player.Skulled || player.IsDead())
         {
             player.RegenTimerDisabled = true;
@@ -91,28 +75,36 @@ private static Task ProcessUpdates(Aisling player)
             player.RegenTimerDisabled = false;
         }
 
-        if (player.RegenTimerDisabled) return Task.CompletedTask;
+        if (player.RegenTimerDisabled) return;
+
+        // Already full
         if (player.CurrentHp == player.MaximumHp &&
-            player.CurrentMp == player.MaximumMp) return Task.CompletedTask;
+            player.CurrentMp == player.MaximumMp)
+            return;
 
+        // Clamp overflows
         if (player.CurrentHp > player.MaximumHp || player.CurrentMp > player.MaximumMp)
         {
             player.CurrentHp = player.MaximumHp;
             player.CurrentMp = player.MaximumMp;
             player.Client.SendAttributes(StatUpdateType.Vitality);
         }
 
-        if (player.Path == Class.Peasant | player.GameMaster)
+        // Special-case: peasants / GMs
+        if (player.Path == Class.Peasant || player.GameMaster)
         {
             player.Recover();
         }
 
-        if (player.CurrentMp < 1) player.CurrentMp = 1;
+        if (player.CurrentMp < 1)
+            player.CurrentMp = 1;
 
         var hpRegenSeed = HpRegenSoftCap(player.Client);
         var mpRegenSeed = MpRegenSoftCap(player.Client);
+
         var hpHardCap = Math.Abs(player.BaseHp / 3.00);
         var mpHardCap = Math.Abs(player.BaseMp / 3.00);
+
         var performedRegen = false;
 
         if (player.CurrentHp < player.MaximumHp)
@@ -129,11 +121,8 @@ private static Task ProcessUpdates(Aisling player)
 
         if (performedRegen)
             player.Client.SendAttributes(StatUpdateType.Vitality);
-
-        return Task.CompletedTask;
     }
 
-
     private static void RegenHpCalculator(WorldClient client, double seed, double cap)
     {
         var currentHp = client.Aisling.CurrentHp;
@@ -172,7 +161,6 @@ private static void RegenMpCalculator(WorldClient client, double seed, double ca
         }
     }
 
-
     private static double HpRegenSoftCap(WorldClient client)
     {
         var conMod = Math.Abs(client.Aisling.Con / 3.00);

Zolian.Server.Base/Network/Components/PlayerSaveComponent.cs

@@ -2,6 +2,7 @@
 
 using Darkages.Database;
 using Darkages.Network.Server;
+using Microsoft.Extensions.Logging;
 
 namespace Darkages.Network.Components;
 
@@ -11,39 +12,52 @@ public class PlayerSaveComponent(WorldServer server) : WorldServerComponent(serv
 
     protected internal override async Task Update()
     {
-        var componentStopWatch = new Stopwatch();
-        componentStopWatch.Start();
-        var variableGameSpeed = ComponentSpeed;
+        var sw = Stopwatch.StartNew();
+        var target = ComponentSpeed;
 
         while (ServerSetup.Instance.Running)
         {
-            if (componentStopWatch.Elapsed.TotalMilliseconds < variableGameSpeed)
+            var elapsed = sw.Elapsed.TotalMilliseconds;
+            if (elapsed < target)
             {
-                await Task.Delay(500);
+                var remaining = (int)(target - elapsed);
+
+                if (remaining > 0)
+                    await Task.Delay(Math.Min(remaining, 1000));
                 continue;
             }
 
-            UpdatePlayerSave();
-            var awaiter = (int)(ComponentSpeed - componentStopWatch.Elapsed.TotalMilliseconds);
+            await UpdatePlayerSaveAsync();
+
+            var postElapsed = sw.Elapsed.TotalMilliseconds;
+            var overshoot = postElapsed - ComponentSpeed;
 
-            if (awaiter < 0)
+            if (overshoot > 0 && overshoot < ComponentSpeed)
             {
-                variableGameSpeed = ComponentSpeed + awaiter;
-                componentStopWatch.Restart();
-                continue;
+                target = ComponentSpeed - (int)overshoot;
+            }
+            else
+            {
+                target = ComponentSpeed;
             }
 
-            await Task.Delay(TimeSpan.FromMilliseconds(awaiter));
-            variableGameSpeed = ComponentSpeed;
-            componentStopWatch.Restart();
+            sw.Restart();
         }
     }
 
-    private static void UpdatePlayerSave()
+    private async Task UpdatePlayerSaveAsync()
     {
-        if (!ServerSetup.Instance.Running || !Server.Aislings.Any()) return;
-
         var playersList = Server.Aislings.ToList();
-        _ = StorageManager.AislingBucket.ServerSave(playersList);
+        if (playersList.Count == 0) return;
+
+        try
+        {
+            await StorageManager.AislingBucket.ServerSave(playersList);
+        }
+        catch (Exception e)
+        {
+            ServerSetup.EventsLogger($"PlayerSaveComponent failed to save {playersList.Count} players: {e}", LogLevel.Error);
+            SentrySdk.CaptureException(e);
+        }
     }
 }