Updates to Chat, Prevent Punt Spamming

Author: Matthew Bate

BHD-ServerManager/Classes/GameManagement/ServerMemory.cs

@@ -1288,9 +1288,7 @@ public static void WriteMemorySendChatMessage(int MsgLocation, string Msg)
             int revert_colorbuffer = 0;
             byte[] revert_colorcode = Functions.ToByteArray("6A 01".Replace(" ", ""));
             WriteProcessMemory((int)processHandle, 0x00462ABA, revert_colorcode, revert_colorcode.Length, ref revert_colorbuffer);
-
-
-
+   
         }
         // Function: WriteMemoryChatCountDownKiller
         public static void WriteMemoryChatCountDownKiller(int ChatLogAddr)
@@ -1417,6 +1415,8 @@ public static void WriteMemoryTogglePlayerGodMode(int playerSlot, int health)
             byte[] setDamageBy = BitConverter.GetBytes(0);
             int setDamageByWrite = 0;
 
+            AppDebug.Log("WriteMemoryTogglePlayerGodMode", $"Player Health Data - Base: 0x{playerNewLocationAddress:X8}, Object: 0x{playerObjectLocation:X8}, Damage Addr: 0x{(playerObjectLocation + 0x138):X8}, Health Addr: 0x{(playerObjectLocation + 0xE2):X8}");
+
             WriteProcessMemory((int)processHandle, playerObjectLocation + 0x138, setDamageBy, setDamageBy.Length, ref setDamageByWrite);
             WriteProcessMemory((int)processHandle, playerObjectLocation + 0xE2, setPlayerHealth, setPlayerHealth.Length, ref setPlayerHealthWrite);
 
@@ -2214,6 +2214,64 @@ public static void ScoreMap()
 
         }
 
+        // Function: ReadMemoryPlayerLeaningStatus
+        // Returns: 0 = upright, 2 = left leaning, 4 = right leaning
+        public static int ReadMemoryPlayerLeaningStatus(int playerSlot)
+        {
+            int buffer = 0;
+            byte[] PointerAddr9 = new byte[4];
+            var Pointer = baseAddr + 0x005ED600;
+
+            // read the playerlist memory
+            ReadProcessMemory((int)processHandle, Pointer, PointerAddr9, PointerAddr9.Length, ref buffer);
+            var playerlistStartingLocationPointer = BitConverter.ToInt32(PointerAddr9, 0) + 0x28;
+            byte[] playerListStartingLocationByteArray = new byte[4];
+            int playerListStartingLocationBuffer = 0;
+            ReadProcessMemory((int)processHandle, playerlistStartingLocationPointer, playerListStartingLocationByteArray, playerListStartingLocationByteArray.Length, ref playerListStartingLocationBuffer);
+
+            int playerlistStartingLocation = BitConverter.ToInt32(playerListStartingLocationByteArray, 0);
+
+            // Calculate the player's address
+            int playerNewLocationAddress = playerlistStartingLocation + (playerSlot - 1) * 0xAF33C;
+
+            byte[] playerObjectLocationBytes = new byte[4];
+            int playerObjectLocationRead = 0;
+            ReadProcessMemory((int)processHandle, playerNewLocationAddress + 0x11C, playerObjectLocationBytes, playerObjectLocationBytes.Length, ref playerObjectLocationRead);
+            int playerObjectLocation = BitConverter.ToInt32(playerObjectLocationBytes, 0);
+
+            // Read prone/rolling status (2 bytes)
+            byte[] proneStatusBytes = new byte[2];
+            int proneStatusRead = 0;
+            ReadProcessMemory((int)processHandle, playerObjectLocation + 0x164, proneStatusBytes, proneStatusBytes.Length, ref proneStatusRead);
+            short proneStatus = BitConverter.ToInt16(proneStatusBytes, 0);
+
+            // Check if player is rolling (95 or 96) - ignore leaning status when rolling
+            if (proneStatus == 95 || proneStatus == 96)
+            {
+                AppDebug.Log("ReadMemoryPlayerLeaningStatus", $"Slot {playerSlot} - Rolling detected (prone: {proneStatus}), ignoring lean");
+                return 0; // Return 0 (upright) when rolling
+            }
+
+            // Read leaning status (2 bytes)
+            byte[] leaningStatusBytes = new byte[2];
+            int leaningStatusRead = 0;
+            ReadProcessMemory((int)processHandle, playerObjectLocation + 0x102, leaningStatusBytes, leaningStatusBytes.Length, ref leaningStatusRead);
+            short leaningStatus = BitConverter.ToInt16(leaningStatusBytes, 0);
+
+            // Normalize the status (remove the +8 for moving)
+            // 0 = upright, 2 = left lean, 4 = right lean
+            // 8 = moving upright, 10 = moving left lean, 12 = moving right lean
+            int normalizedStatus = leaningStatus % 8;
+
+            AppDebug.Log("ReadMemoryPlayerLeaningStatus", 
+                $"Slot {playerSlot} - Object: 0x{playerObjectLocation:X8}, " +
+                $"Lean Addr: 0x{(playerObjectLocation + 0x102):X8}, " +
+                $"Prone Addr: 0x{(playerObjectLocation + 0x164):X8}, " +
+                $"Raw: {leaningStatus}, Normalized: {normalizedStatus}");
+
+            return normalizedStatus;
+        }
+
     }
 
 }

BHD-ServerManager/Classes/InstanceManagers/theInstanceManager.cs

@@ -114,7 +114,7 @@ public static void InitializeTickers()
         {
             // TODO: Remove the need for the thisServer variable in the ticker methods.
             CommonCore.Ticker?.Start("ServerManager", 500, () => tickerServerManager.runTicker());
-            CommonCore.Ticker?.Start("ChatManager", 500, () => tickerChatManagement.runTicker());
+            CommonCore.Ticker?.Start("ChatManager", 100, () => tickerChatManagement.runTicker());
             CommonCore.Ticker?.Start("PlayerManager", 1000, () => tickerPlayerManagement.runTicker());
             CommonCore.Ticker?.Start("BanManager", 1000, () => tickerBanManagement.runTicker());
 

BHD-ServerManager/Classes/Services/ProxyDetection/ProxyCheckManager.cs

@@ -85,7 +85,54 @@ public static int ReloadCacheFromDatabase(bool replaceExisting = true)
 
             return addedCount + updatedCount;
         }
+        
+        /// <summary>
+        /// Check if an IP address is internal/private.
+        /// </summary>
+        private static bool IsInternalIP(IPAddress ipAddress)
+        {
+            if (ipAddress.AddressFamily == System.Net.Sockets.AddressFamily.InterNetworkV6)
+            {
+                // Check for IPv6 loopback (::1) and link-local (fe80::/10)
+                if (IPAddress.IsLoopback(ipAddress))
+                    return true;
+
+                byte[] bytes = ipAddress.GetAddressBytes();
+                // Link-local: fe80::/10
+                if (bytes[0] == 0xfe && (bytes[1] & 0xc0) == 0x80)
+                    return true;
+
+                // Unique local: fc00::/7
+                if ((bytes[0] & 0xfe) == 0xfc)
+                    return true;
+
+                return false;
+            }
+
+            // IPv4 checks
+            if (IPAddress.IsLoopback(ipAddress))
+                return true;
+
+            byte[] addressBytes = ipAddress.GetAddressBytes();
 
+            // 10.0.0.0/8
+            if (addressBytes[0] == 10)
+                return true;
+
+            // 172.16.0.0/12
+            if (addressBytes[0] == 172 && addressBytes[1] >= 16 && addressBytes[1] <= 31)
+                return true;
+
+            // 192.168.0.0/16
+            if (addressBytes[0] == 192 && addressBytes[1] == 168)
+                return true;
+
+            // 169.254.0.0/16 (link-local)
+            if (addressBytes[0] == 169 && addressBytes[1] == 254)
+                return true;
+
+            return false;
+        }
         /// <summary>
         /// Check an IP address for proxy/VPN/Tor. Uses in-memory cache first, then database, then API.
         /// </summary>
@@ -102,6 +149,21 @@ public static async Task<ProxyCheckResult> CheckIPAsync(IPAddress ipAddress)
             if (ipAddress == null)
                 throw new ArgumentNullException(nameof(ipAddress));
 
+            // Step 0: Check if IP is internal/private - skip proxy check
+            if (IsInternalIP(ipAddress))
+            {
+                AppDebug.Log("ProxyCheckManager", $"Internal IP detected: {ipAddress} - Skipping proxy check");
+                return new ProxyCheckResult
+                {
+                    Success = true,
+                    IsProxy = false,
+                    IsVpn = false,
+                    IsTor = false,
+                    RiskScore = 0,
+                    ErrorMessage = "Internal IP Proxy Check Skipped"
+                };
+            }
+
             // Step 1: Check in-memory cache first
             var cachedRecord = GetFromMemoryCache(ipAddress);
             if (cachedRecord != null && !IsCacheExpired(cachedRecord))

BHD-ServerManager/Classes/Tickers/tickerBanManagement.cs

@@ -426,6 +426,11 @@ public static void CheckAndPuntBannedPlayers()
                     // Punt the player if they're banned
                     if (shouldPunt)
                     {
+                        if (player.PlayerPing <= 0)
+                        {
+                            return;  // Player not in game yet. Needless to spam the "punt".
+                        }
+
                         ServerMemory.WriteMemorySendConsoleCommand("punt " + slotNum);
                         AppDebug.Log("tickerBanManagement", $"Punting player '{player.PlayerName}' (Slot {slotNum}). Reason: {puntReason}");
                     }

BHD-ServerManager/Classes/Tickers/tickerChatManagement.cs

@@ -1,9 +1,10 @@
-using BHD_ServerManager.Classes.GameManagement;
-using BHD_ServerManager.Forms;
+using BHD_ServerManager;
 using BHD_ServerManager.Classes.CoreObjects;
+using BHD_ServerManager.Classes.GameManagement;
 using BHD_ServerManager.Classes.InstanceManagers;
 using BHD_ServerManager.Classes.Instances;
 using BHD_ServerManager.Classes.SupportClasses;
+using BHD_ServerManager.Forms;
 
 namespace BHD_ServerManager.Classes.Tickers
 {
@@ -19,60 +20,42 @@ public static class tickerChatManagement
         // For deduplication of chat messages
         private static string? _lastProcessedPlayerName = null;
         private static string? _lastProcessedMessageText = null;
-
-        // Helper for UI thread safety
+        private static DateTime _lastProcessedMessageTime = DateTime.MinValue;
 
         public static void runTicker()
         {
-            // Always ensure UI thread safety for UI-bound operations
-            if (thisServer.InvokeRequired)
-            {
-                try
-                {
-                    thisServer.BeginInvoke(new Action(runTicker));
-                }
-                catch (Exception ex)
-                {
-                    AppDebug.Log("tickerChatManagement", $"Error invoking runTicker: {ex.Message}");
-                }
-                return;
-            }
-
             lock (tickerLock)
             {
-
                 // Only process chat when server is online or in start delay
                 if (thisInstance.instanceStatus != InstanceStatus.ONLINE &&
                     thisInstance.instanceStatus != InstanceStatus.STARTDELAY)
                 {
                     return;
                 }
 
-                // Ensure the chat tab is initialized before proceeding
-                thisServer.ChatTab.ChatTickerHook();
-
-
                 if (ServerMemory.ReadMemoryIsProcessAttached())
                 {
                     // Recover auto message counter before processing auto messages
                     RecoverAutoMessageCounter();
 
-                    // Process auto messages (non-blocking)
+                    // Process auto messages (non-blocking to avoid ticker delays)
                     Task.Run(ProcessAutoMessages);
 
-                    // Process latest chat message and update UI (non-blocking)
-                    Task.Run(ProcessChatMessages);
+                    // Process latest chat message immediately (no Task.Run to prevent missing messages)
+                    ProcessChatMessages();
                 }
                 else
                 {
-                    AppDebug.Log("tickerChatManagement", "Server process is not attached. Ticker Skipping.");
+                    AppDebug.Log("tickerChatManagement", "Server process is not attached. Ticker skipping.");
                 }
             }
         }
 
         public static void ProcessChatMessages()
         {
+            // Read memory immediately on ticker thread to avoid missing messages
             var latestMessage = ServerMemory.ReadMemoryLastChatMessage();
+            
             if (latestMessage == null || latestMessage.Length < 3)
                 return;
 
@@ -92,13 +75,30 @@ public static void ProcessChatMessages()
 
             string playerName = lastMessage.Substring(0, msgStart).Trim();
             string playerMessage = lastMessage.Substring(msgStart + 1).Trim();
-
-            // Prevent duplicate messages based on last processed message
-            if (_lastProcessedPlayerName == playerName && _lastProcessedMessageText == playerMessage)
-                return;
-
+            
+            AppDebug.Log("ProcessChatMessages", $"Last Message: {latestMessage[0]} - {latestMessage[1]} - {latestMessage[2]}");
+            
             lock (chatLog)
             {
+                // Primary check: Compare against the most recent chat log entry
+                if (chatLog.Count > 0)
+                {
+                    var lastEntry = chatLog[^1];
+                    if (lastEntry.PlayerName == playerName && 
+                        lastEntry.MessageText == playerMessage)
+                    {
+                        return;
+                    }
+                }
+
+                // Secondary check: Use static fields with 1-second window
+                // This allows multi-part messages (sent 1+ seconds apart) to both be logged
+                if (_lastProcessedPlayerName == playerName && 
+                    _lastProcessedMessageText == playerMessage)
+                {
+                    return;
+                }
+
                 // Message type mapping
                 int msgType = msgTypeBytes switch
                 {
@@ -112,8 +112,9 @@ public static void ProcessChatMessages()
                 if (msgType == 0 && int.TryParse(latestMessage[0], out int chatLogAddr))
                     ServerMemory.WriteMemoryChatCountDownKiller(chatLogAddr);
 
-                // Find PlayerTeam number
+                // Find player team number
                 int teamNum = 3;
+
                 foreach (var player in thisInstance.playerList.Values)
                 {
                     if (player.PlayerName == playerName)
@@ -123,6 +124,7 @@ public static void ProcessChatMessages()
                     }
                 }
 
+                // Create chat log entry
                 ChatLogObject newChatLog = new ChatLogObject
                 {
                     PlayerName = playerName,
@@ -133,14 +135,24 @@ public static void ProcessChatMessages()
                 };
 
                 chatLog.Add(newChatLog);
-
                 chatInstanceManager.SaveChatLogEntry(newChatLog);
 
-                // Update last processed message for deduplication
+                // Update deduplication tracking
                 _lastProcessedPlayerName = playerName;
                 _lastProcessedMessageText = playerMessage;
+                _lastProcessedMessageTime = DateTime.Now;
 
                 AppDebug.Log("tickerChatManagement", $"Chat Message: {playerName} ({teamNum}) - {playerMessage} (Type: {msgType})");
+
+                // Marshal UI updates to UI thread AFTER processing
+                if (thisServer.InvokeRequired)
+                {
+                    thisServer.BeginInvoke(() => thisServer.ChatTab.ChatTickerHook());
+                }
+                else
+                {
+                    thisServer.ChatTab.ChatTickerHook();
+                }
             }
         }
 
@@ -222,6 +234,12 @@ public static void RecoverAutoMessageCounter()
             _autoMessageRecoveryDone = true;
         }
 
-
+        public static void ResetDeduplication()
+        {
+            _lastProcessedPlayerName = null;
+            _lastProcessedMessageText = null;
+            _lastProcessedMessageTime = DateTime.MinValue;
+            _autoMessageRecoveryDone = false;
+        }
     }
 }