Add advanced settings

ACT.FFXIVPing/ACT.FFXIVPing/FFXIVPingTabControl.cs

@@ -8,7 +8,6 @@
 using ACT.FoxCommon.localization;
 using ACT.FoxCommon.shortcut;
 using ACT.FoxCommon.update;
-using Advanced_Combat_Tracker;
 
 namespace ACT.FFXIVPing
 {
@@ -48,6 +47,8 @@ public void AttachToAct(FFXIVPingPlugin plugin)
             settings.AddControlSetting(checkBoxAutoHide);
             settings.AddControlSetting(checkBoxCheckUpdate);
             settings.AddControlSetting(checkBoxNotifyStableOnly);
+            settings.AddControlSetting(checkBoxAdvancedPing);
+            settings.AddControlSetting(numericUpDownRefreshInterval);
 
             _controller = plugin.Controller;
 
@@ -158,12 +159,47 @@ private void buttonShortcutHide_Click(object sender, EventArgs e)
             }
         }
 
+        private void CheckBoxAdvancedPingOnCheckedChanged(object sender, EventArgs eventArgs)
+        {
+            _controller.NotifyAdvancedPingEnabled(true, checkBoxAdvancedPing.Checked);
+        }
+
+        private void NumericUpDownRefreshIntervalOnValueChanged(object sender, EventArgs eventArgs)
+        {
+            _controller.NotifyRefreshIntervalChanged(true, (double)numericUpDownRefreshInterval.Value);
+        }
+
+        private void TextBoxOverlayContentOnTextChanged(object sender, EventArgs eventArgs)
+        {
+            _controller.NotifyOverlayTextTemplateChanged(true, textBoxOverlayContentNormal.Text, textBoxOverlayContentNoData.Text);
+        }
+
+        private void buttonResetTexts_Click(object sender, EventArgs e)
+        {
+            textBoxOverlayContentNormal.Text = strings.defaultOverlayContentNormal;
+            textBoxOverlayContentNoData.Text = strings.defaultOverlayContentNoData;
+        }
+
         private void ControllerOnSettingsLoaded()
         {
             if (checkBoxCheckUpdate.Checked)
             {
                 _plugin.UpdateChecker.CheckUpdate(false);
             }
+
+            checkBoxAdvancedPing.CheckedChanged += CheckBoxAdvancedPingOnCheckedChanged;
+            numericUpDownRefreshInterval.ValueChanged += NumericUpDownRefreshIntervalOnValueChanged;
+
+            var settings = _plugin.Settings;
+            textBoxOverlayContentNormal.Text = settings.OverlayContentNormal ?? strings.defaultOverlayContentNormal;
+            textBoxOverlayContentNoData.Text = settings.OverlayContentNoData ?? strings.defaultOverlayContentNoData;
+
+            textBoxOverlayContentNormal.TextChanged += TextBoxOverlayContentOnTextChanged;
+            textBoxOverlayContentNoData.TextChanged += TextBoxOverlayContentOnTextChanged;
+
+            CheckBoxAdvancedPingOnCheckedChanged(this, EventArgs.Empty);
+            NumericUpDownRefreshIntervalOnValueChanged(this, EventArgs.Empty);
+            TextBoxOverlayContentOnTextChanged(this, EventArgs.Empty);
         }
 
         private void ControllerOnOverlayMoved(bool fromView, int x, int y)

ACT.FFXIVPing/ACT.FFXIVPing/FFXIVPingTabControl.resx

@@ -117,4 +117,13 @@
   <resheader name="writer">
     <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
   </resheader>
+  <data name="labelAdvancedPing.Text" xml:space="preserve">
+    <value>* By enabling advanced ping detection, the plugin will capture and read the contents of your game connection and calculate the latency using the heartbeat packets.
+
+* This will give you the REAL latency between the game client sends a packet to server and receives the response packet.
+
+* However, due to the existence of Server Tick Rate, this latency may be significantly larger than the normal ping value and will have greater volatility.
+
+* This is particularly useful if you are using any sorts of VPN software.</value>
+  </data>
 </root>

ACT.FFXIVPing/ACT.FFXIVPing/MachinaProbeService.cs

@@ -10,12 +10,27 @@ namespace ACT.FFXIVPing
 {
     class MachinaProbeService : IPluginComponent
     {
+        private MainController _controller;
         private bool _isStarted = false;
         private readonly ConcurrentDictionary<uint, ProcessContext> _processContexts = new ConcurrentDictionary<uint, ProcessContext>();
 
         public void AttachToAct(FFXIVPingPlugin plugin)
         {
-            plugin.Controller.GameProcessUpdated += ControllerOnGameProcessUpdated;
+            _controller = plugin.Controller;
+            _controller.GameProcessUpdated += ControllerOnGameProcessUpdated;
+            _controller.AdvancedPingEnabled += ControllerOnAdvancedPingEnabled;
+        }
+
+        private void ControllerOnAdvancedPingEnabled(bool fromView, bool enabled)
+        {
+            if (enabled)
+            {
+                Start();
+            }
+            else
+            {
+                Stop();
+            }
         }
 
         private void ControllerOnGameProcessUpdated(bool fromView, HashSet<uint> pids)
@@ -51,23 +66,18 @@ private void ControllerOnGameProcessUpdated(bool fromView, HashSet<uint> pids)
 
         public void PostAttachToAct(FFXIVPingPlugin plugin)
         {
-            Start();
         }
 
         public int FindTTL(uint pid)
         {
-            if (_processContexts.TryGetValue(pid, out var ctx))
+            if (!_isStarted)
             {
-                return ctx.CurrentTTL;
+                return -1;
             }
-            return -1;
-        }
 
-        public long FindEpoch(uint pid)
-        {
             if (_processContexts.TryGetValue(pid, out var ctx))
             {
-                return ctx.LastEpoch;
+                return ctx.CurrentTTL;
             }
             return -1;
         }
@@ -78,6 +88,7 @@ private void Start()
             {
                 Stop();
                 _isStarted = true;
+                _controller.NotifyLogMessageAppend(false, "Advanced Ping Detection (MachinaProbeService) started.");
             }
         }
 
@@ -96,6 +107,7 @@ public void Stop()
                     context.Stop();
                 }
                 _processContexts.Clear();
+                _controller.NotifyLogMessageAppend(false, "Advanced Ping Detection (MachinaProbeService) stopped.");
             }
         }
 

ACT.FFXIVPing/ACT.FFXIVPing/MainController.cs

@@ -79,5 +79,31 @@ public void NotifyOverlayAutoHideChanged(bool fromView, bool autoHide)
             OverlayAutoHideChanged?.Invoke(fromView, autoHide);
         }
 
+        public delegate void OnAdvancedPingEnabledDelegate(bool fromView, bool enabled);
+
+        public event OnAdvancedPingEnabledDelegate AdvancedPingEnabled;
+
+        public void NotifyAdvancedPingEnabled(bool fromView, bool enabled)
+        {
+            AdvancedPingEnabled?.Invoke(fromView, enabled);
+        }
+
+        public delegate void OnRefreshIntervalChangedDelegate(bool fromView, double interval);
+
+        public event OnRefreshIntervalChangedDelegate RefreshIntervalChanged;
+
+        public void NotifyRefreshIntervalChanged(bool fromView, double interval)
+        {
+            RefreshIntervalChanged?.Invoke(fromView, interval);
+        }
+
+        public delegate void OnOverlayTextTemplateChangedDelegate(bool fromView, string normal, string noData);
+
+        public event OnOverlayTextTemplateChangedDelegate OverlayTextTemplateChanged;
+
+        public void NotifyOverlayTextTemplateChanged(bool fromView, string normal, string noData)
+        {
+            OverlayTextTemplateChanged?.Invoke(fromView, normal, noData);
+        }
     }
 }

ACT.FFXIVPing/ACT.FFXIVPing/NetworkProbeService.cs

@@ -4,7 +4,6 @@
 using System.Linq;
 using ACT.FoxCommon;
 using ACT.FoxCommon.core;
-using Machina;
 
 namespace ACT.FFXIVPing
 {
@@ -18,22 +17,39 @@ class NetworkProbeService : IPluginComponent
         private uint _currentPid;
         private uint _lastPid;
 
+        private string _textTemplateNormal = "Ping {ping}, {lost}% Pkt Lost";
+        private string _textTemplateNoData = "No Ping Data...";
+
         public void AttachToAct(FFXIVPingPlugin plugin)
         {
             _machinaProbeService = plugin.MachinaService;
             _controller = plugin.Controller;
             _controller.ActivatedProcessPathChanged += ControllerOnActivatedProcessPathChanged;
             _controller.GameProcessUpdated += _workingThread.GameProcessUpdated;
+            _controller.RefreshIntervalChanged += ControllerOnRefreshIntervalChanged;
+            _controller.OverlayTextTemplateChanged += ControllerOnOverlayTextTemplateChanged;
         }
 
         public void PostAttachToAct(FFXIVPingPlugin plugin)
+        {
+        }
+
+        private void ControllerOnRefreshIntervalChanged(bool fromView, double interval)
         {
             _workingThread.StartWorkingThread(new ProbeContext
             {
-                Service = this
+                Service = this,
+                Delay = (int)(interval * 1000)
             });
         }
 
+        private void ControllerOnOverlayTextTemplateChanged(bool fromView, string normal, string noData)
+        {
+            _textTemplateNormal = normal;
+            _textTemplateNoData = noData;
+            DisplayByPid(_currentPid);
+        }
+
         public void Stop()
         {
             _workingThread.StopWorkingThread();
@@ -106,7 +122,7 @@ private void DisplayRecord(ProcessContext ctx, uint pid)
             {
                 if (ttlMachina == -1)
                 {
-                    _controller.NotifyOverlayContentChanged(false, "No Ping Data...");
+                    _controller.NotifyOverlayContentChanged(false, _textTemplateNoData);
                     return;
                 }
                 ttl = ttlMachina;
@@ -128,7 +144,12 @@ private void DisplayRecord(ProcessContext ctx, uint pid)
                 ttlStr = $"{ttl}ms";
             }
 
-            _controller.NotifyOverlayContentChanged(false, $"Ping {ttlStr}, {lost}% Pkt Lost");
+            var finalStr = _textTemplateNormal
+                .Replace("{ping}", $"{ttl}")
+                .Replace("{ping_ms_na}", ttlStr)
+                .Replace("{lost}", $"{lost}");
+
+            _controller.NotifyOverlayContentChanged(false, finalStr);
         }
 
         private class ConnectionContext

ACT.FFXIVPing/ACT.FFXIVPing/SettingsHolder.cs

@@ -94,10 +94,14 @@ public void Save()
 
         public string ShortcutHide { get; set; }
 
+        public string OverlayContentNormal { get; set; }
+
+        public string OverlayContentNoData { get; set; }
+
         #endregion
 
         #region Controller notify
-        
+
         private MainController _controller;
 
         public void AttachToAct(FFXIVPingPlugin plugin)
@@ -106,13 +110,16 @@ public void AttachToAct(FFXIVPingPlugin plugin)
             Settings.AddStringSetting(nameof(OverlayFont));
             Settings.AddStringSetting(nameof(VersionIgnored));
             Settings.AddStringSetting(nameof(ShortcutHide));
+            Settings.AddStringSetting(nameof(OverlayContentNormal));
+            Settings.AddStringSetting(nameof(OverlayContentNoData));
 
             _controller = plugin.Controller;
 
             _controller.LanguageChanged += ControllerOnLanguageChanged;
             _controller.OverlayFontChanged += ControllerOnOverlayFontChanged;
             _controller.NewVersionIgnored += ControllerOnNewVersionIgnored;
             _controller.ShortcutChanged += ControllerOnShortcutChanged;
+            _controller.OverlayTextTemplateChanged += ControllerOnOverlayTextTemplateChanged;
         }
 
         public void PostAttachToAct(FFXIVPingPlugin plugin)
@@ -178,6 +185,12 @@ private void ControllerOnShortcutChanged(bool fromView, PluginShortcut shortcut,
             }
         }
 
+        private void ControllerOnOverlayTextTemplateChanged(bool fromView, string normal, string noData)
+        {
+            OverlayContentNormal = normal;
+            OverlayContentNoData = noData;
+        }
+
         #endregion
     }
 }