Created basic notifications

They don't look great yet but hey we can see items being sent out or received in game now!

4 files changed, 242 insertions, 0 deletions

@@ -1,5 +1,6 @@
 using Archipelago.MultiClient.Net;
 using Archipelago.MultiClient.Net.Enums;
+using Archipelago.MultiClient.Net.MessageLog.Messages;
 using Archipelago.MultiClient.Net.Models;
 using Archipelago.MultiClient.Net.Packets;
 using System;
@@ -22,6 +23,7 @@ namespace ManifoldGardenArchipelago
             try
             {
                 _session = ArchipelagoSessionFactory.CreateSession(url);
+                _session.MessageLog.OnMessageReceived += OnMessageReceived;
 
                 RoomInfoPacket roomInfoPacket = await _session.ConnectAsync();
 
@@ -83,6 +85,7 @@ namespace ManifoldGardenArchipelago
                     ItemInfo item = _session.Items.AllItemsReceived[i];
                     string itemName = item.ItemName;
                     Plugin.Logger.LogInfo($"Received {itemName}");
+                    Plugin.notificationManager.AddMessage($"Received {itemName}");
 
                     _items.Add(itemName);
 
@@ -111,5 +114,20 @@ namespace ManifoldGardenArchipelago
                 */
             }
         }
+
+        private void OnMessageReceived(LogMessage message)
+        {
+            if (message is ItemSendLogMessage itemSendLogMessage &&
+                itemSendLogMessage.IsSenderTheActivePlayer &&
+                !itemSendLogMessage.IsReceiverTheActivePlayer)
+            {
+                string itemName = itemSendLogMessage.Item.ItemName;
+                string otherPlayer = itemSendLogMessage.Receiver.Name;
+
+                string messageText = $"Sent {itemName} to {otherPlayer}";
+
+                Plugin.notificationManager.AddMessage(messageText);
+            }
+        }
     }
 }
@@ -36,6 +36,12 @@
     <Reference Include="Assembly-CSharp">
       <HintPath>D:\SteamLibrary\steamapps\common\Manifold Garden\ManifoldGarden_Data\Managed\Assembly-CSharp.dll</HintPath>
     </Reference>
+    <Reference Include="Unity.TextMeshPro">
+      <HintPath>D:\SteamLibrary\steamapps\common\Manifold Garden\ManifoldGarden_Data\Managed\Unity.TextMeshPro.dll</HintPath>
+    </Reference>
+    <Reference Include="UnityEngine.UI">
+      <HintPath>D:\SteamLibrary\steamapps\common\Manifold Garden\ManifoldGarden_Data\Managed\UnityEngine.UI.dll</HintPath>
+    </Reference>
   </ItemGroup>
   
   <ItemGroup>
@@ -0,0 +1,205 @@
+using System;
+using System.Collections.Generic;
+using TMPro;
+using UnityEngine;
+
+namespace ManifoldGardenArchipelago
+{
+    public class NotificationManager : MonoBehaviour
+    {
+        public static NotificationManager InitializeNotifications(UIManager uiManager)
+        {
+            GameObject gameObject = new("Notifications");
+            gameObject.transform.parent = uiManager.transform;
+
+            Vector3 groupPosition = new(1260f, 680f, 0f);
+            gameObject.transform.set_position_Injected(ref groupPosition);
+
+            NotificationManager notificationManager = gameObject.AddComponent<NotificationManager>();
+
+            Plugin.Logger.LogInfo("Notification manager initialized");
+
+            return notificationManager;
+        }
+
+        public const int MAX_VISIBLE = 5;
+
+        private readonly List<NotificationLine> _notifications = [];
+        private readonly List<string> _queuedMessages = [];
+        private int _counter = 0;
+
+        void Update()
+        {
+            while (_notifications.Count > 0 && _notifications[_notifications.Count - 1].ReadyToBeDestroyed())
+            {
+                NotificationLine toDestroy = _notifications[_notifications.Count - 1];
+                GameObject.Destroy(toDestroy.gameObject);
+                _notifications.RemoveAt(_notifications.Count - 1);
+            }
+
+            if (_queuedMessages.Count > 0)
+            {
+                if (_notifications.Count > 0 && !_notifications[0].ReadyToBeSurplanted())
+                {
+                    if (!_notifications[0].IsMoving() &&
+                        !(_notifications.Count >= MAX_VISIBLE && !_notifications[_notifications.Count - 1].IsFadingOut()))
+                    {
+                        foreach (var notification in _notifications)
+                        {
+                            notification.SlideDown();
+                        }
+                    }
+                }
+                else
+                {
+                    foreach (var notification in _notifications)
+                    {
+                        notification.ConfirmMovement();
+                    }
+
+                    GameObject newNotify = new($"Message_{_counter}");
+                    _counter += 1;
+
+                    newNotify.transform.parent = transform;
+
+                    Vector3 freshPos = new();
+                    newNotify.transform.set_localPosition_Injected(ref freshPos);
+
+                    TextMeshProUGUI textMeshPro = newNotify.AddComponent<TextMeshProUGUI>();
+                    textMeshPro.alignment = TextAlignmentOptions.TopRight;
+                    textMeshPro.enableWordWrapping = false;
+                    textMeshPro.text = _queuedMessages[0];
+                    textMeshPro.alpha = 0f;
+                    textMeshPro.autoSizeTextContainer = true;
+
+                    Vector2 pivot = new(1f, 0.5f);
+                    textMeshPro.rectTransform.set_pivot_Injected(ref pivot);
+
+                    _queuedMessages.RemoveAt(0);
+
+                    NotificationLine newLine = newNotify.AddComponent<NotificationLine>();
+                    _notifications.Insert(0, newLine);
+                }
+            }
+        }
+
+        public void AddMessage(string message)
+        {
+            _queuedMessages.Add(message);
+        }
+    }
+
+    public class NotificationLine : MonoBehaviour
+    {
+        public const float ALPHA_SPEED = 1f;
+        public const float SLIDE_SPEED = 75f;
+        public const float SLIDE_DISPLACEMENT = 50f;
+
+        private enum FadeState
+        {
+            FadingIn,
+            Waiting,
+            FadingOut,
+            ReadyToDestroy,
+        }
+
+        private enum MoveState
+        {
+            Waiting,
+            Moving,
+            Ready,
+        }
+
+        private TextMeshProUGUI _textMeshPro;
+
+        private float _alphaTarget = 1f;
+        private FadeState _fadeState = FadeState.FadingIn;
+        private float _waitTimer = 10f;
+
+        private MoveState _moveState = MoveState.Waiting;
+        private float _targetY = 0f;
+
+        void Start()
+        {
+            _textMeshPro = GetComponent<TextMeshProUGUI>();
+        }
+
+        void Update()
+        {
+            if (_textMeshPro.alpha != _alphaTarget)
+            {
+                float alpha = _textMeshPro.alpha;
+
+                if (alpha < _alphaTarget)
+                {
+                    alpha = Math.Min(_alphaTarget, alpha + ALPHA_SPEED * Time.deltaTime);
+                }
+                else
+                {
+                    alpha = Math.Max(_alphaTarget, alpha - ALPHA_SPEED * Time.deltaTime);
+                }
+
+                _textMeshPro.alpha = alpha;
+            }
+
+            if (_fadeState == FadeState.FadingIn)
+            {
+                if (_textMeshPro.alpha >= _alphaTarget)
+                {
+                    _fadeState = FadeState.Waiting;
+                }
+            }
+            else if (_fadeState == FadeState.Waiting)
+            {
+                _waitTimer -= ALPHA_SPEED * Time.deltaTime;
+
+                if (_waitTimer < 0)
+                {
+                    _fadeState = FadeState.FadingOut;
+                    _alphaTarget = 0f;
+                }
+            }
+            else if (_fadeState == FadeState.FadingOut)
+            {
+                if (_textMeshPro.alpha <= _alphaTarget)
+                {
+                    _fadeState = FadeState.ReadyToDestroy;
+                }
+            }
+
+            if (_moveState == MoveState.Moving)
+            {
+                if (transform.localPosition.y > _targetY)
+                {
+                    Vector3 localPos = transform.localPosition;
+                    localPos.y = Math.Max(_targetY, localPos.y - SLIDE_SPEED * Time.deltaTime);
+                    transform.set_localPosition_Injected(ref localPos);
+
+                    if (transform.localPosition.y <= _targetY)
+                    {
+                        _moveState = MoveState.Ready;
+                    }
+                }
+            }
+        }
+
+        public bool ReadyToBeSurplanted() => _moveState == MoveState.Ready;
+
+        public bool IsMoving() => _moveState == MoveState.Moving;
+
+        public void SlideDown()
+        {
+            _moveState = MoveState.Moving;
+            _targetY = transform.localPosition.y - SLIDE_DISPLACEMENT;
+        }
+
+        public void ConfirmMovement()
+        {
+            _moveState = MoveState.Waiting;
+        }
+
+        public bool IsFadingOut() => _fadeState == FadeState.FadingOut;
+
+        public bool ReadyToBeDestroyed() => _fadeState == FadeState.ReadyToDestroy;
+    }
+}
@@ -12,6 +12,7 @@ namespace ManifoldGardenArchipelago
 
         public static ArchipelagoManager archipelagoManager = new();
         public static SlotSave slotSave = new();
+        public static NotificationManager notificationManager = null;
 
         private void Awake()
         {
@@ -26,6 +27,18 @@ namespace ManifoldGardenArchipelago
         }
     }
 
+    [HarmonyPatch(typeof(GameManager), nameof(GameManager.AttachUI))]
+    static class UIManagerAwakePatch
+    {
+        static void Postfix()
+        {
+            if (Plugin.notificationManager == null)
+            {
+                Plugin.notificationManager = NotificationManager.InitializeNotifications(GameManager.UI);
+            }
+        }
+    }
+
     [HarmonyPatch(typeof(GameManager), "Update")]
     static class GameManagerUpdatePatch
     {