Update private message behavior to be closer to vanilla client

EOLib.Localization/EOResourceID.cs

@@ -13,7 +13,7 @@ public enum EOResourceID
 
 
         YOUR_MIND_PREVENTS_YOU_TO_SAY = 14,
-
+        STATUS_LABEL_INVALID_INPUT_TRY = 15,
         STATUS_LABEL_CHAT_PANEL_NOW_VIEWED = 16,
         STATUS_LABEL_STATS_PANEL_NOW_VIEWED = 17,
         STATUS_LABEL_ONLINE_PLAYERS_NOW_VIEWED = 18,

EOLib/Domain/Chat/ChatActions.cs

@@ -9,6 +9,13 @@
 
 namespace EOLib.Domain.Chat
 {
+    public enum ChatResult
+    {
+        Ok,
+        YourMindPrevents,
+        HideSpeechBubble,
+    }
+
     [AutoMappedType]
     public class ChatActions : IChatActions
     {
@@ -40,14 +47,14 @@ public ChatActions(IChatRepository chatRepository,
             _configurationProvider = configurationProvider;
         }
 
-        public (bool, string) SendChatToServer(string chat, string targetCharacter)
+        public (ChatResult, string) SendChatToServer(string chat, string targetCharacter)
         {
             var chatType = _chatTypeCalculator.CalculateChatType(chat);
 
             if (chatType == ChatType.Command)
             {
                 if (HandleCommand(chat))
-                    return (true, chat);
+                    return (ChatResult.HideSpeechBubble, chat);
 
                 //treat unhandled command as local chat
                 chatType = ChatType.Local;
@@ -65,7 +72,7 @@ public ChatActions(IChatRepository chatRepository,
             var (ok, filtered) = _chatProcessor.FilterCurses(chat);
             if (!ok)
             {
-                return (ok, filtered);
+                return (ChatResult.YourMindPrevents, filtered);
             }
 
             chat = filtered;
@@ -78,7 +85,7 @@ public ChatActions(IChatRepository chatRepository,
 
             AddChatForLocalDisplay(chatType, chat, targetCharacter);
 
-            return (ok, chat);
+            return (chatType == ChatType.PM ? ChatResult.HideSpeechBubble : ChatResult.Ok, chat);
         }
 
         public void SetHearWhispers(bool whispersEnabled)
@@ -98,6 +105,19 @@ public void SetGlobalActive(bool active)
             _packetSendService.SendPacket(packet);
         }
 
+        public void ClosePMTab(ChatTab whichTab)
+        {
+            if (whichTab != ChatTab.Private1 && whichTab != ChatTab.Private2)
+                throw new ArgumentException("Tab must be a PM tab", nameof(whichTab));
+
+            _chatRepository.AllChat[whichTab].Clear();
+
+            if (whichTab == ChatTab.Private1)
+                _chatRepository.PMTarget1 = null;
+            else if (whichTab == ChatTab.Private2)
+                _chatRepository.PMTarget2 = null;
+        }
+
         /// <summary>
         /// Returns true if the text is a command (#) and can be handled as such, false if it should be sent to the server as a public chat string
         /// </summary>
@@ -126,8 +146,6 @@ private void AddChatForLocalDisplay(ChatType chatType, string chat, string targe
                         _chatRepository.AllChat[ChatTab.Private1].Add(new ChatData(ChatTab.Private1, who, chat, ChatIcon.Note, ChatColor.PM));
                     else if (targetCharacter == _chatRepository.PMTarget2)
                         _chatRepository.AllChat[ChatTab.Private2].Add(new ChatData(ChatTab.Private2, who, chat, ChatIcon.Note, ChatColor.PM));
-                    else
-                        throw new ArgumentException("Unexpected target character!", nameof(targetCharacter));
 
                     break;
                 case ChatType.Local:
@@ -157,10 +175,12 @@ private void AddChatForLocalDisplay(ChatType chatType, string chat, string targe
 
     public interface IChatActions
     {
-        (bool Ok, string Processed) SendChatToServer(string chat, string targetCharacter);
+        (ChatResult Ok, string Processed) SendChatToServer(string chat, string targetCharacter);
 
         void SetHearWhispers(bool whispersEnabled);
 
         void SetGlobalActive(bool active);
+
+        void ClosePMTab(ChatTab tab);
     }
 }

EndlessClient/Controllers/ChatController.cs

@@ -1,20 +1,15 @@
-using System.Threading.Tasks;
-using AutomaticTypeMapper;
+using AutomaticTypeMapper;
 using EndlessClient.ControlSets;
-using EndlessClient.Dialogs.Actions;
-using EndlessClient.GameExecution;
 using EndlessClient.HUD;
 using EndlessClient.HUD.Chat;
 using EndlessClient.HUD.Controls;
 using EndlessClient.UIControls;
 using EOLib.Domain.Chat;
 using EOLib.Localization;
-using EOLib.Net;
-using EOLib.Net.Communication;
 
 namespace EndlessClient.Controllers
 {
-    [MappedType(BaseType = typeof(IChatController))]
+    [AutoMappedType]
     public class ChatController : IChatController
     {
         private readonly IChatTextBoxActions _chatTextBoxActions;
@@ -42,20 +37,20 @@ public ChatController(IChatTextBoxActions chatTextBoxActions,
         public void SendChatAndClearTextBox()
         {
             var localTypedText = ChatTextBox.Text;
-            var targetCharacter = _privateMessageActions.GetTargetCharacter(localTypedText);
+            var (pmCheckOk, targetCharacter) = _privateMessageActions.GetTargetCharacter(localTypedText);
 
-            var (ok, updatedChat) = _chatActions.SendChatToServer(localTypedText, targetCharacter);
-
-            _chatTextBoxActions.ClearChatText();
-
-            if (ok)
+            if (pmCheckOk)
             {
-                _chatBubbleActions.ShowChatBubbleForMainCharacter(updatedChat);
-            }
-            else
-            {
-                _statusLabelSetter.SetStatusLabel(EOResourceID.STATUS_LABEL_TYPE_WARNING, EOResourceID.YOUR_MIND_PREVENTS_YOU_TO_SAY);
+                var (result, updatedChat) = _chatActions.SendChatToServer(localTypedText, targetCharacter);
+                switch (result)
+                {
+                    case ChatResult.Ok: _chatBubbleActions.ShowChatBubbleForMainCharacter(updatedChat); break;
+                    case ChatResult.YourMindPrevents: _statusLabelSetter.SetStatusLabel(EOResourceID.STATUS_LABEL_TYPE_WARNING, EOResourceID.YOUR_MIND_PREVENTS_YOU_TO_SAY); break;
+                    case ChatResult.HideSpeechBubble: break; // no-op
+                }
             }
+
+            _chatTextBoxActions.ClearChatText();
         }
 
         public void SelectChatTextBox()

EndlessClient/HUD/Chat/ChatNotificationActions.cs

@@ -43,9 +43,9 @@ public void NotifyPrivateMessageRecipientNotFound(string recipientName)
             whichTab.MatchSome(tab =>
             {
                 if (tab == ChatTab.Private1)
-                    _chatRepository.PMTarget1 = string.Empty;
+                    _chatRepository.PMTarget1 = null;
                 else if (tab == ChatTab.Private2)
-                    _chatRepository.PMTarget2 = string.Empty;
+                    _chatRepository.PMTarget2 = null;
 
                 _chatRepository.AllChat[tab].Clear();
 

EndlessClient/HUD/Chat/PrivateMessageActions.cs

@@ -1,48 +1,70 @@
-using System.Linq;
-using AutomaticTypeMapper;
+using AutomaticTypeMapper;
 using EndlessClient.ControlSets;
 using EndlessClient.HUD.Controls;
 using EndlessClient.HUD.Panels;
+using EOLib.Domain.Character;
 using EOLib.Domain.Chat;
+using EOLib.Localization;
+using System;
 
 namespace EndlessClient.HUD.Chat
 {
     [MappedType(BaseType = typeof(IPrivateMessageActions))]
     public class PrivateMessageActions : IPrivateMessageActions
     {
         private readonly IHudControlProvider _hudControlProvider;
+        private readonly ICharacterProvider _characterProvider;
         private readonly IChatProvider _chatProvider;
         private readonly IChatTypeCalculator _chatTypeCalculator;
+        private readonly IStatusLabelSetter _statusLabelSetter;
 
         public PrivateMessageActions(IHudControlProvider hudControlProvider,
+                                     ICharacterProvider characterProvider,
                                      IChatProvider chatProvider,
-                                     IChatTypeCalculator chatTypeCalculator)
+                                     IChatTypeCalculator chatTypeCalculator,
+                                     IStatusLabelSetter statusLabelSetter)
         {
             _hudControlProvider = hudControlProvider;
+            _characterProvider = characterProvider;
             _chatProvider = chatProvider;
             _chatTypeCalculator = chatTypeCalculator;
+            _statusLabelSetter = statusLabelSetter;
         }
 
-        public string GetTargetCharacter(string localTypedText)
+        public (bool, string) GetTargetCharacter(string localTypedText)
         {
-            //todo: error status bar message if there is no text following a character name
-
             if (_chatTypeCalculator.CalculateChatType(localTypedText) != ChatType.PM)
-                return "";
+            {
+                return (true, string.Empty);
+            }
+
+            if (localTypedText.Length < 2 || localTypedText[1] == ' ')
+            {
+                _statusLabelSetter.SetStatusLabel(EOResourceID.STATUS_LABEL_TYPE_WARNING, EOResourceID.STATUS_LABEL_INVALID_INPUT_TRY);
+                return (false, string.Empty);
+            }
 
             if (CurrentTab == ChatTab.Private1)
-                return _chatProvider.PMTarget1;
+            {
+                return (true, _chatProvider.PMTarget1);
+            }
+            else if (CurrentTab == ChatTab.Private2)
+            {
+                return (true, _chatProvider.PMTarget2);
+            }
 
-            if (CurrentTab == ChatTab.Private2)
-                return _chatProvider.PMTarget2;
+            var messageParts = localTypedText[1..].Split(' ', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
+            if (messageParts.Length <= 1)
+            {
+                _statusLabelSetter.SetStatusLabel(EOResourceID.STATUS_LABEL_TYPE_WARNING, EOResourceID.STATUS_LABEL_INVALID_INPUT_TRY);
+                return (false, string.Empty);
+            }
 
-            var characterArray = localTypedText.Skip(1)
-                                               .TakeWhile(x => x != ' ')
-                                               .ToArray();
-            var characterName = new string(characterArray);
+            if (string.Equals(messageParts[0], _characterProvider.MainCharacter.Name, StringComparison.OrdinalIgnoreCase))
+                return (false, string.Empty);
 
-            ChatPanel.TryStartNewPrivateChat(characterName);
-            return characterName;
+            ChatPanel.TryStartNewPrivateChat(messageParts[0]);
+            return (true, messageParts[0]);
         }
 
         private ChatPanel ChatPanel => _hudControlProvider.GetComponent<ChatPanel>(HudControlIdentifier.ChatPanel);
@@ -52,6 +74,6 @@ public string GetTargetCharacter(string localTypedText)
 
     public interface IPrivateMessageActions
     {
-        string GetTargetCharacter(string localTypedText);
+        (bool Ok, string TargetCharacter) GetTargetCharacter(string localTypedText);
     }
 }