Merge Conflict Fix

MxValheim/EventSystem/EventHud.cs

@@ -0,0 +1,129 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Windows.Annotations;
+using System.Windows.Controls;
+using UnityEngine;
+using UnityEngine.UI;
+using Image = UnityEngine.UI.Image;
+
+namespace MxValheim.EventSystem
+{
+    internal class EventHud
+    {
+        private static GameObject _eventRoot;
+        private static Text _eventTitleText;
+        private static Text _eventProgressText;
+        private static Image _progressBar;
+        private static CanvasGroup _canvasGroup;
+
+        public static void CreateEventHud()
+        {
+            // 1. Setup Root (Stacked under your KillFeed which is at -30)
+            _eventRoot = new GameObject("MxEventHUD_Root");
+            UnityEngine.Object.DontDestroyOnLoad(_eventRoot);
+
+            UnityEngine.Canvas c = _eventRoot.AddComponent<UnityEngine.Canvas>();
+            c.renderMode = RenderMode.ScreenSpaceOverlay;
+            c.sortingOrder = 9999; // Just behind killfeed
+
+            CanvasScaler scaler = _eventRoot.AddComponent<CanvasScaler>();
+            scaler.uiScaleMode = CanvasScaler.ScaleMode.ScaleWithScreenSize;
+            scaler.referenceResolution = new Vector2(1920, 1080);
+
+            _canvasGroup = _eventRoot.AddComponent<CanvasGroup>();
+            _canvasGroup.alpha = 0f;
+
+            // 2. Main Panel (Positioned at -80 to sit below the KillFeed)
+            GameObject panel = new GameObject("Background", typeof(RectTransform), typeof(Image));
+            panel.transform.SetParent(_eventRoot.transform, false);
+            Image panelImage = panel.GetComponent<Image>();
+            panelImage.color = new UnityEngine.Color(0, 0, 0, 0.7f);
+
+            // Find Valheim Sprite
+            foreach (Sprite s in Resources.FindObjectsOfTypeAll<Sprite>())
+            {
+                if (s.name == "item_background")
+                {
+                    panelImage.sprite = s;
+                    panelImage.type = Image.Type.Sliced;
+                    break;
+                }
+            }
+
+            RectTransform pRect = panel.GetComponent<RectTransform>();
+            pRect.anchorMin = pRect.anchorMax = pRect.pivot = new Vector2(0.5f, 1f);
+            pRect.anchoredPosition = new Vector2(0, -80); // Lowered to avoid overlap
+            pRect.sizeDelta = new Vector2(450, 60); // Slightly taller for progress bar
+
+            // 3. Vertical Layout for Title + Progress Bar
+            VerticalLayoutGroup layout = panel.AddComponent<VerticalLayoutGroup>();
+            layout.childAlignment = UnityEngine.TextAnchor.MiddleCenter;
+            layout.spacing = 5f;
+            layout.padding = new RectOffset(10, 10, 5, 5);
+
+            // 4. Title Text
+            _eventTitleText = CreateText(panel.transform, "EVENT ACTIVE", 14, UnityEngine.Color.yellow);
+
+            // 5. Progress Bar Background
+            GameObject barBg = new GameObject("BarBG", typeof(RectTransform), typeof(Image));
+            barBg.transform.SetParent(panel.transform, false);
+            barBg.GetComponent<Image>().color = new UnityEngine.Color(0.2f, 0.2f, 0.2f, 0.8f);
+            barBg.GetComponent<RectTransform>().sizeDelta = new Vector2(400, 10);
+
+            // 6. Actual Progress Fill
+            GameObject fillObj = new GameObject("Fill", typeof(RectTransform), typeof(Image));
+            fillObj.transform.SetParent(barBg.transform, false);
+            _progressBar = fillObj.GetComponent<Image>();
+            _progressBar.color = UnityEngine.Color.red;
+            _progressBar.type = Image.Type.Filled;
+            _progressBar.fillMethod = Image.FillMethod.Horizontal;
+
+            RectTransform fRect = _progressBar.GetComponent<RectTransform>();
+            fRect.anchorMin = Vector2.zero;
+            fRect.anchorMax = Vector2.one;
+            fRect.sizeDelta = Vector2.zero;
+
+            // 7. Counter Text (e.g., 12/20)
+            _eventProgressText = CreateText(panel.transform, "0 / 0", 10, UnityEngine.Color.white);
+
+            _eventRoot.SetActive(false);
+        }
+
+        public static Text CreateText(Transform parent, string content, int size, UnityEngine.Color col)
+        {
+            GameObject txtObj = new GameObject("Text", typeof(RectTransform), typeof(Text));
+            txtObj.transform.SetParent(parent, false);
+            Text t = txtObj.GetComponent<Text>();
+            t.text = content;
+            t.fontSize = size;
+            t.color = col;
+            t.alignment = UnityEngine.TextAnchor.MiddleCenter;
+            t.font = GetValheimFont();
+            return t;
+        }
+
+        public static UnityEngine.Font GetValheimFont()
+        {
+            foreach (UnityEngine.Font f in Resources.FindObjectsOfTypeAll<UnityEngine.Font>())
+                if (f.name == "AveriaSerifLibre-Bold") return f;
+            return Resources.GetBuiltinResource<UnityEngine.Font>("Arial.ttf");
+        }
+
+        public static void UpdateDisplay(string title, int current, int total, Color barColor)
+        {
+            if (_eventRoot == null) return;
+            _eventRoot.SetActive(true);
+            _canvasGroup.alpha = 1f;
+
+            _eventTitleText.text = title.ToUpper();
+            _eventProgressText.text = $"{current} / {total}";
+            _progressBar.fillAmount = (float)current / total;
+            _progressBar.color = barColor;
+        }
+
+        public static void Hide() => _canvasGroup.alpha = 0f;
+    }
+}

MxValheim/EventSystem/EventList.cs

@@ -0,0 +1,48 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace MxValheim.EventSystem
+{
+    internal class EventList
+    {
+        public static void SetupCustomRaid(RandEventSystem system)
+        {
+            // 1. Create the Event Data
+            RandomEvent myCustomRaid = new RandomEvent
+            {
+                m_name = "MxEvent_God1",
+                m_enabled = true,
+                m_duration = 600f,      // 10 minutes
+                m_nearBaseOnly = true,  // Must be near player structures
+                m_pauseIfNoPlayerInArea = true,
+                m_forceMusic = "Music_Boss_Moder", // Use specific music
+                m_startMessage = "The gods themselves challenge you...",
+                m_endMessage = "The gods are satisfied.",
+                m_forceEnvironment = "SnowStorm" // Force weather
+            };
+
+            // 2. Define what spawns during this event
+            SpawnSystem.SpawnData frostWraith = new SpawnSystem.SpawnData
+            {
+                m_name = "Frost Wraith",
+                m_prefab = ZNetScene.instance.GetPrefab("Wraith"), // Get the Wraith prefab
+                m_maxSpawned = 5,           // Max alive at once
+                m_spawnInterval = 10f,      // Try to spawn every 10s
+                m_spawnDistance = 30f,      // Distance from player
+                m_spawnRadiusMax = 10f,
+                m_spawnRadiusMin = 5f,
+                m_groupSizeMin = 1,
+                m_groupSizeMax = 2,
+                m_enabled = true
+            };
+
+            myCustomRaid.m_spawn = new List<SpawnSystem.SpawnData> { frostWraith };
+
+            // 3. Add to the game's master list
+            system.m_events.Add(myCustomRaid);
+        }
+    }
+}

MxValheim/EventSystem/Patch.cs

@@ -0,0 +1,396 @@
+using HarmonyLib;
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Windows.Controls;
+using UnityEngine;
+using UnityEngine.UI;
+using static MxValheimMod;
+using Canvas = UnityEngine.Canvas;
+using Image = UnityEngine.UI.Image;
+
+namespace MxValheim.EventSystem
+{
+    internal class EventSystem_Patch
+    {
+        public static GameObject _eventRoot;
+        public static Text _eventTitleText;
+        public static Text _eventProgressText;
+        public static Image _progressBar;
+        public static CanvasGroup _canvasGroup;
+
+        // --- STATE DATA ---
+        public enum RaidPhase
+        {
+            None,
+            Scouts,
+            EliteGuard,
+            BossInbound,
+            Completed
+        }
+        public static RaidPhase CurrentPhase = RaidPhase.None;
+        public static int KillsInCurrentPhase = 0;
+        // --- 1. HUD CREATION (Your Style) ---
+        public static void CreateEventHud()
+        {
+            if (_eventRoot != null) return;
+
+            _eventRoot = new GameObject("MxEventHUD_Root");
+            UnityEngine.Object.DontDestroyOnLoad(_eventRoot);
+
+            Canvas c = _eventRoot.AddComponent<Canvas>();
+            c.renderMode = RenderMode.ScreenSpaceOverlay;
+            c.sortingOrder = 9999;
+
+            CanvasScaler scaler = _eventRoot.AddComponent<CanvasScaler>();
+            scaler.uiScaleMode = CanvasScaler.ScaleMode.ScaleWithScreenSize;
+            scaler.referenceResolution = new Vector2(1920, 1080);
+
+            _canvasGroup = _eventRoot.AddComponent<CanvasGroup>();
+            _canvasGroup.alpha = 0f;
+
+            // Background Panel (Positioned -90 to sit below KillFeed at -30)
+            GameObject panel = new GameObject("Background", typeof(RectTransform), typeof(Image));
+            panel.transform.SetParent(_eventRoot.transform, false);
+            Image panelImage = panel.GetComponent<Image>();
+            panelImage.color = new Color(0, 0, 0, 0.7f);
+
+            // Styling with Valheim Assets
+            foreach (Sprite s in Resources.FindObjectsOfTypeAll<Sprite>())
+            {
+                if (s.name == "item_background")
+                {
+                    panelImage.sprite = s;
+                    panelImage.type = Image.Type.Sliced;
+                    break;
+                }
+            }
+
+            RectTransform pRect = panel.GetComponent<RectTransform>();
+            pRect.anchorMin = pRect.anchorMax = pRect.pivot = new Vector2(0.5f, 1f);
+            pRect.anchoredPosition = new Vector2(0, -90); // Stacks below your KillFeed
+            pRect.sizeDelta = new Vector2(400, 55);
+
+            VerticalLayoutGroup layout = panel.AddComponent<VerticalLayoutGroup>();
+            layout.childAlignment = TextAnchor.MiddleCenter;
+            layout.spacing = 2f;
+            layout.padding = new RectOffset(10, 10, 5, 5);
+
+            // Title
+            _eventTitleText = CreateText(panel.transform, "RAID STATUS", 14, Color.yellow);
+
+            // Progress Bar
+            GameObject barBg = new GameObject("BarBG", typeof(RectTransform), typeof(Image));
+            barBg.transform.SetParent(panel.transform, false);
+            barBg.GetComponent<Image>().color = new Color(0.1f, 0.1f, 0.1f, 0.9f);
+            barBg.GetComponent<RectTransform>().sizeDelta = new Vector2(350, 8);
+
+            GameObject fillObj = new GameObject("Fill", typeof(RectTransform), typeof(Image));
+            fillObj.transform.SetParent(barBg.transform, false);
+            _progressBar = fillObj.GetComponent<Image>();
+            _progressBar.color = Color.red;
+            _progressBar.type = Image.Type.Filled;
+            _progressBar.fillMethod = Image.FillMethod.Horizontal;
+            _progressBar.GetComponent<RectTransform>().anchorMin = Vector2.zero;
+            _progressBar.GetComponent<RectTransform>().anchorMax = Vector2.one;
+            _progressBar.GetComponent<RectTransform>().sizeDelta = Vector2.zero;
+
+            // Progress Text
+            _eventProgressText = CreateText(panel.transform, "0 / 0", 11, Color.white);
+        }
+
+        private static Text CreateText(Transform parent, string content, int size, Color col)
+        {
+            GameObject txtObj = new GameObject("Text", typeof(Text));
+            txtObj.transform.SetParent(parent, false);
+            Text t = txtObj.GetComponent<Text>();
+            t.text = content;
+            t.fontSize = size;
+            t.color = col;
+            t.alignment = TextAnchor.MiddleCenter;
+
+            Font valFont = null;
+            foreach (Font f in Resources.FindObjectsOfTypeAll<Font>())
+                if (f.name == "AveriaSerifLibre-Bold") valFont = f;
+            t.font = valFont ?? Resources.GetBuiltinResource<Font>("Arial.ttf");
+
+            return t;
+        }
+
+        // --- 2. WAVE LOGIC ---
+        public static void UpdateWave(bool reset = false)
+        {
+            Debug.Log($"MxEvent:UpdateWave Seen a wave start.");
+            if (reset)
+            {
+                CurrentPhase = RaidPhase.Scouts;
+                KillsInCurrentPhase = 0;
+            }
+
+            int target = GetTargetForPhase(CurrentPhase);
+            
+            Color barColor = (CurrentPhase == RaidPhase.Scouts) ? Color.magenta : Color.red;
+
+            UpdateDisplay($"PHASE: {CurrentPhase}", KillsInCurrentPhase, target, barColor);
+        }
+
+        public static int GetTargetForPhase(RaidPhase phase)
+        {
+            switch (phase)
+            {
+                case RaidPhase.Scouts: return 5;      // 5 kills to clear scouts
+                case RaidPhase.EliteGuard: return 10;  // 10 kills for elite guard
+                case RaidPhase.BossInbound: return 1;  // Just the boss
+                default: return 0;
+            }
+        }
+
+        public static void AdvancePhase()
+        {
+            KillsInCurrentPhase = 0; // Reset counter for the new phase
+
+            if (CurrentPhase == RaidPhase.Scouts) CurrentPhase = RaidPhase.EliteGuard;
+            else if (CurrentPhase == RaidPhase.EliteGuard) CurrentPhase = RaidPhase.BossInbound;
+            else CurrentPhase = RaidPhase.Completed;
+
+            if (CurrentPhase == RaidPhase.Scouts)
+            {
+                // Spawn Eikthyr at the player's location
+                GameObject boarPrefab = ZNetScene.instance.GetPrefab("Boar");
+                if (boarPrefab != null)
+                {
+                    UnityEngine.Object.Instantiate(boarPrefab, Player.m_localPlayer.transform.position + Vector3.forward * 20f, Quaternion.identity);
+                }
+            }
+
+            if (CurrentPhase == RaidPhase.BossInbound)
+            {
+                // Spawn Eikthyr at the player's location
+                GameObject bossPrefab = ZNetScene.instance.GetPrefab("Eikthyr");
+                if (bossPrefab != null)
+                {
+                    UnityEngine.Object.Instantiate(bossPrefab, Player.m_localPlayer.transform.position + Vector3.forward * 10f, Quaternion.identity);
+                }
+            }
+
+            Debug.Log($"MxEvent: Advancing to {CurrentPhase}");
+
+            // Play a sound to notify the player (The 'Quest Update' sound)
+            Player.m_localPlayer?.Message(MessageHud.MessageType.Center, $"$inventory_newphase: {CurrentPhase}");
+
+            if (CurrentPhase == RaidPhase.Completed)
+            {
+                Debug.Log("MxEvent: All phases complete. Ending vanilla raid.");
+                EndRaidManually();
+            }
+        }
+
+        public static void UpdateDisplay(string title, int curr, int total, Color col)
+        {
+            Debug.Log($"MxEvent:UpdateDisplay Something reached my display update logic.");
+            if (_eventRoot == null) CreateEventHud();
+            _eventRoot.SetActive(true);
+            _canvasGroup.alpha = 1f;
+
+            _eventTitleText.text = title;
+            _eventProgressText.text = $"{curr} / {total}";
+            _progressBar.fillAmount = (float)curr / total;
+            _progressBar.color = col;
+        }
+
+        public static void EndRaidManually()
+        {
+            if (RandEventSystem.instance != null)
+            {
+                // This tells Valheim the time is up
+                RandomEvent activeEvent = RandEventSystem.instance.GetActiveEvent();
+                if (activeEvent != null)
+                {
+                    activeEvent.m_time = 0;
+                }
+            }
+            FadeOutHud(); // Start your fade out
+        }
+
+        // --- 3. HARMONY PATCHES ---
+
+        [HarmonyPatch(typeof(RandEventSystem), nameof(RandEventSystem.FixedUpdate))]
+        public static class DebugRaidFrequency
+        {
+            static void Prefix(RandEventSystem __instance)
+            {
+                // Use a small timer check so we don't spam the logic every single frame
+                // though for debugging, forcing these values is fine.
+                __instance.m_eventIntervalMin = 10f;
+                __instance.m_eventChance = 100f;
+            }
+        }
+
+        [HarmonyPatch(typeof(RandEventSystem), nameof(RandEventSystem.FixedUpdate))]
+        public static class TimerFreezePatch
+        {
+            static void Prefix(RandEventSystem __instance)
+            {
+                RandomEvent activeEvent = __instance.GetActiveEvent();
+
+                // If we are in our custom phases and haven't reached "Completed" yet
+                if (activeEvent != null && CurrentPhase != RaidPhase.Completed)
+                {
+                    // Valheim subtracts time in FixedUpdate. 
+                    // We add it back using the engine's global fixedDeltaTime.
+                    activeEvent.m_time += Time.fixedDeltaTime;
+                }
+            }
+        }
+
+        // Ensure HUD is ready when the game UI loads
+        [HarmonyPatch(typeof(Hud), nameof(Hud.Awake))]
+        [HarmonyPostfix]
+        static void InitHud() => CreateEventHud();
+
+        [HarmonyPatch(typeof(Hud), nameof(Hud.Update))]
+        [HarmonyPostfix]
+        static void CheckForExistingRaid()
+        {
+            // If the HUD isn't visible but a raid IS active, force it to show
+            if (CurrentPhase == RaidPhase.None && RandEventSystem.instance.GetActiveEvent() != null)
+            {
+                Debug.Log("MxEvent: Detected existing raid on HUD update. Synchronizing...");
+                UpdateWave(true);
+            }
+        }
+
+        [HarmonyPatch(typeof(Hud), nameof(Hud.Update))]
+        public static class Hud_MonitorPatch
+        {
+            private static RandomEvent _lastKnownEvent = null;
+
+            static void Postfix()
+            {
+                // 1. Safety check: Ensure the system exists
+                if (RandEventSystem.instance == null) return;
+
+                RandomEvent activeEvent = RandEventSystem.instance.GetActiveEvent();
+
+                // 2. Logic: Detection
+                if (activeEvent != null && _lastKnownEvent == null)
+                {
+                    Debug.Log($"MxEvent: HUD Heartbeat detected Raid Start: {activeEvent.m_name}");
+                    _lastKnownEvent = activeEvent;
+
+                    // Force HUD Creation and Display
+                    UpdateWave(true);
+                }
+                else if (activeEvent == null && _lastKnownEvent != null)
+                {
+                    Debug.Log("MxEvent: HUD Heartbeat detected Raid End.");
+                    _lastKnownEvent = null;
+                    FadeOutHud();
+                }
+            }
+        }
+
+        [HarmonyPatch(typeof(Character), nameof(Character.ApplyDamage))]
+        public static class DeathNotifier
+        {
+            static void Postfix(Character __instance)
+            {
+                // Check if the character is dead or just died
+                if (__instance.GetHealth() <= 0f)
+                {
+                    ZNetView nview = __instance.GetComponent<ZNetView>();
+
+                    // This check should now pass because ApplyDamage happens before the object is invalidated
+                    if (nview == null || !nview.IsValid() || !nview.IsOwner()) return;
+
+                    // 2. Check if a raid is active
+                    RandomEvent activeEvent = RandEventSystem.instance.GetActiveEvent();
+                    if (activeEvent == null) return;
+                    Debug.Log("MxEvent: Confirmed Active Event!");
+
+                    Vector3 playerPos = Player.m_localPlayer.transform.position;
+                    float distance = Vector3.Distance(playerPos, activeEvent.m_pos);
+                    Debug.Log($"MxEvent: Distance: {distance}");
+
+                    if (distance <= 96f)
+                    {
+                        KillsInCurrentPhase++;
+                        int target = GetTargetForPhase(CurrentPhase);
+
+                        if (KillsInCurrentPhase >= target && CurrentPhase != RaidPhase.Completed)
+                        {
+                            AdvancePhase();
+                        }
+
+                        // Send the update
+                        ZRoutedRpc.instance.InvokeRoutedRPC(
+                            ZRoutedRpc.Everybody,
+                            "RPC_UpdateRaidHUD",
+                            $"PHASE: {CurrentPhase}",
+                            KillsInCurrentPhase,
+                            GetTargetForPhase(CurrentPhase)
+                        );
+                    }                   
+                }
+            }
+        }
+
+        public static bool IsEventCreature(Character character)
+        {
+            ZNetView nview = character.GetComponent<ZNetView>();
+            if (nview == null || nview.GetZDO() == null) return false;
+
+            // Layer 1: Check the networked boolean (The standard way)
+            if (nview.GetZDO().GetBool("eventcreature")) return true;
+
+            // Layer 2: Check the BaseAI component (The local way)
+            BaseAI ai = character.GetComponent<BaseAI>();
+            if (ai != null)
+            {
+                bool isRaidMob = (bool)AccessTools.Field(typeof(BaseAI), "m_eventCreature").GetValue(ai);
+                if (isRaidMob) return true;
+            }
+
+            return false;
+        }
+
+        // Hide HUD when raid ends
+        [HarmonyPatch(typeof(RandEventSystem), nameof(RandEventSystem.ResetRandomEvent))]
+        [HarmonyPostfix]
+        static void OnRaidEnd()
+        {
+            FadeOutHud();
+            CurrentPhase = RaidPhase.None;
+        }
+
+        private static IEnumerator FadeOutHud()
+        {
+            Debug.Log("MxEvent: Starting Fade Out...");
+
+            // Safety check for the component
+            if (_canvasGroup == null)
+            {
+                _eventRoot.SetActive(false);
+                yield break;
+            }
+
+            float startAlpha = _canvasGroup.alpha;
+            float rate = 1.0f / 1.5f; // Fade over 1.5 seconds
+            float progress = 0.0f;
+
+            while (progress < 1.0f)
+            {
+                progress += Time.deltaTime * rate;
+                _canvasGroup.alpha = Mathf.Lerp(startAlpha, 0, progress);
+                yield return null;
+            }
+
+            _canvasGroup.alpha = 0;
+            _eventRoot.SetActive(false); // Fully disable to ensure it's gone
+            Debug.Log("MxEvent: HUD Hidden and Deactivated.");
+        }
+    }
+}

MxValheim/EventSystem/WaveManager.cs

@@ -0,0 +1,66 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using UnityEngine;
+
+namespace MxValheim.EventSystem
+{
+    public enum RaidPhase { None, Scouts, Siege, Boss, Victory }
+
+    public static class WaveManager
+    {
+        public static RaidPhase CurrentPhase = RaidPhase.None;
+        public static int KillsInCurrentPhase = 0;
+        public static int TotalInPhase = 20;
+
+        public static void AdvanceWave()
+        {
+            KillsInCurrentPhase = 0;
+            CurrentPhase++;
+
+            switch (CurrentPhase)
+            {
+                case RaidPhase.Scouts:
+                    //
+                    break;
+                case RaidPhase.Siege:
+                    //
+                    break;
+                case RaidPhase.Boss:
+                    //
+                    //SpawnBoss();
+                    break;
+                case RaidPhase.Victory:
+                    //
+                    break;
+            }
+        }
+
+        public static void UpdateWave(bool reset = false)
+        {
+            if (reset)
+            {
+                CurrentPhase = RaidPhase.Scouts;
+                KillsInCurrentPhase = 0;
+            }
+
+            int target = GetTargetForWave(CurrentPhase);
+            Color barColor = (CurrentPhase == RaidPhase.Boss) ? Color.magenta : Color.red;
+
+            EventHud.UpdateDisplay($"PHASE: {CurrentPhase}", KillsInCurrentPhase, target, barColor);
+        }
+
+        private static int GetTargetForWave(RaidPhase phase)
+        {
+            switch (phase)
+            {
+                case RaidPhase.Scouts: return 5;
+                case RaidPhase.Siege: return 15;
+                case RaidPhase.Boss: return 1;
+                default: return 0;
+            }
+        }
+    }
+}

MxValheim/KillFeed/Chat.cs

@@ -1,47 +0,0 @@
-using HarmonyLib;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using UnityEngine;
-
-namespace MxValheim.KillFeed
-{
-    internal class Chat_Patch
-    {
-        [HarmonyPatch(typeof(Chat), nameof(Chat.Awake))]
-        class ChatLimitPatch
-        {
-            static void Postfix(Chat __instance)
-            {
-                // 1. Update the UI component (The most important part for typing)
-                if (__instance.m_input != null)
-                {
-                    __instance.m_input.characterLimit = 1000;
-                }
-
-                // 2. Try to find the internal length field (it might be m_maxLength or m_maxMessageLength)
-                try
-                {
-                    var field = AccessTools.Field(typeof(Chat), "m_maxMessageLength")
-                             ?? AccessTools.Field(typeof(Chat), "m_maxLength");
-
-                    if (field != null)
-                    {
-                        field.SetValue(__instance, 1000);
-                        UnityEngine.Debug.Log($"KillFeed: Set {field.Name} to 1000.");
-                    }
-                    else
-                    {
-                        UnityEngine.Debug.LogWarning("KillFeed: Could not find a length field in Chat. Logic might use InputField limit only.");
-                    }
-                }
-                catch (Exception e)
-                {
-                    UnityEngine.Debug.LogWarning($"KillFeed: Non-critical error setting chat limit: {e.Message}");
-                }
-            }
-        }
-    }
-}

MxValheim/KillFeed/NPCIcon.cs

@@ -0,0 +1,65 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace MxValheim.KillFeed
+{
+    internal class NPCIcon
+    {
+        Dictionary<string, string> valheimTrophies = new Dictionary<string, string>
+        {
+    // Meadows
+    { "Boar", "TrophyBoar" },
+    { "Deer", "TrophyDeer" },
+    { "Neck", "TrophyNeck" },
+    { "Eikthyr", "TrophyEikthyr" },
+
+    // Black Forest
+    { "Greydwarf", "TrophyGreydwarf" },
+    { "Greydwarf_Shaman", "TrophyGreydwarfShaman" },
+    { "Greydwarf_Elite", "TrophyGreydwarfBrute" },
+    { "Skeleton", "TrophySkeleton" },
+    { "Skeleton_Poison", "TrophySkeletonPoison" },
+    { "Ghost", "TrophyGhost" },
+    { "Troll", "TrophyTroll" },
+    { "gd_king", "TrophyTheElder" },
+
+    // Swamp
+    { "Blob", "TrophyBlob" },
+    { "Draugr", "TrophyDraugr" },
+    { "Draugr_Elite", "TrophyDraugrElite" },
+    { "Leech", "TrophyLeech" },
+    { "Surtling", "TrophySurtling" },
+    { "Wraith", "TrophyWraith" },
+    { "Abomination", "TrophyAbomination" },
+    { "Bonemass", "TrophyBonemass" },
+
+    // Mountains
+    { "Wolf", "TrophyWolf" },
+    { "Fenring", "TrophyFenring" },
+    { "StoneGolem", "TrophyStoneGolem" },
+    { "Drake", "TrophyDrake" },
+    { "Ulv", "TrophyUlv" },
+    { "Cultist", "TrophyCultist" },
+    { "Dragon", "TrophyModer" },
+
+    // Plains
+    { "Lox", "TrophyLox" },
+    { "Deathsquito", "TrophyDeathsquito" },
+    { "Goblin", "TrophyGoblin" },
+    { "GoblinBrute", "TrophyGoblinBrute" },
+    { "GoblinShaman", "TrophyGoblinShaman" },
+    { "Growth", "TrophyGrowth" },
+    { "GoblinKing", "TrophyGoblinKing" },
+
+    // Mistlands
+    { "Seeker", "TrophySeeker" },
+    { "SeekerBrute", "TrophySeekerBrute" },
+    { "Gjall", "TrophyGjall" },
+    { "Tick", "TrophyTick" },
+    { "SeekerQueen", "TrophySeekerQueen" }
+        };
+    }
+}

MxValheim/KillFeed/Patch.cs

@@ -2,8 +2,12 @@
 using HarmonyLib;
 using System;
 using System.Collections.Generic;
+using System.Linq;
+using System.Reflection.Emit;
 using System.Threading;
+using TMPro;
 using UnityEngine;
+using UnityEngine.Diagnostics;
 using UnityEngine.UI;
 using static MxValheimMod;
 
@@ -11,26 +15,84 @@ namespace MxValheim.KillFeed
 {
     public class KillFeed_Patch
     {      
-        public static void SendKillToAll(string attacker, string victim, string weaponPrefab, int type)
+        public static void SendKillToAll(string attacker, string victim, string victimInternalName, string weaponPrefab, int encodedType)
         {
             if (ZRoutedRpc.instance != null)
             {
-                ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.Everybody, "RPC_MxKillMsg", attacker, victim, weaponPrefab, type);
+                ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.Everybody, "RPC_MxKillMsg", attacker, victim, victimInternalName, weaponPrefab, encodedType);
             }
         }
 
-        public void OnReceiveKillMsg(long sender, string attacker, string victim, string weaponPrefab, int type)
+        public void OnReceiveKillMsg(long sender, string attacker, string victim, string victimInternalName, string weaponPrefab, int encodedType)
         {
             ZNet zn = new ZNet();
             if (zn.IsDedicated()) return;
+            if (attacker == "The World") return;
 
-            string finalMsg = (type == 1) ? $"<color=#FF3333>☠</color> {victim} a été tué par {attacker}" :
-                              (type == 2) ? $"{attacker} a tué {victim}" :
-                              $"{attacker} a tué {victim}";
+            float distance = (encodedType / 1000) / 10.0f;
+            int remainder = encodedType % 1000;
+            bool isBoss = (remainder >= 100);
+            int level = (remainder % 100) / 10;
+            int type = remainder % 10;
+
+            Sprite victimIcon = GetCreatureIcon(victimInternalName);
+
+            GameObject prefab = ZNetScene.instance.GetPrefab(victimInternalName);
+            string localizedVictim = victimInternalName;
+            if (prefab != null)
+            {
+                Character c = prefab.GetComponent<Character>();
+                if (c != null) localizedVictim = c.m_name;
+            }
+
+            // Message Format Variables
+            string type1Separator = Localization.instance.Localize("$killfeed_format_type1");
+            string type2Separator = Localization.instance.Localize("$killfeed_format_type2");
+            string finalMsg = "";
+            string attackerFormat = "";
+            string victimFormat = "";
+            string distanceFormat = "";
+            string starFormat = "";
+            string crossFormat = "";
+            // Format Message in Divided Section
+            starFormat = "<color=#fffb00>★</color>";
+            crossFormat = "<color=#a0a3a1>✝</color>";
+            attackerFormat = $"<color=#00ff06>{attacker.ToUpper()}</color>";
+
+            if (type == 1)
+            {
+                victimFormat = $"{crossFormat} <color=#00ff06>{victim.ToUpper()}</color>";
+            } else if(type == 2)
+            {
+                switch (level)
+                {
+                    case 1:
+                        victimFormat = $"<color=#00ff06>{victim.ToUpper()}</color>";
+                        break;
+                    case 2:
+                        victimFormat = $"{starFormat} <color=#00ff06>{victim.ToUpper()}</color>";
+                        break;
+                    case 3:
+                        victimFormat = $"{starFormat}{starFormat} <color=#00ff06>{victim.ToUpper()}</color>";
+                        break;
+                    case 4:
+                        victimFormat = $"{starFormat}{starFormat}{starFormat} <color=#00ff06>{victim.ToUpper()}</color>";
+                        break;
+                    case 5:
+                        victimFormat = $"{starFormat}{starFormat}{starFormat}{starFormat} <color=#00ff06>{victim.ToUpper()}</color>";
+                        break;
+                }
+            }
+
+            distanceFormat = $"{Localization.instance.Localize("$killfeed_format_distance_before")}<color=#9402f5>{distance:F1}m</color>{Localization.instance.Localize("$killfeed_format_distance_after")}";
+
+            finalMsg =
+                (type == 1) ? $"{victimFormat}{type1Separator}{attackerFormat}{distanceFormat}": // Player Death
+                (type == 2) ? $"{attackerFormat}{type2Separator}{victimFormat}{distanceFormat}": // Player Killed Something
+                              $"{attackerFormat}{type2Separator}{victimFormat}{distanceFormat}"; // Failsafe
 
             Sprite weaponIcon = null;
 
-            // Only check ObjectDB if we are actually in a world
             if (ObjectDB.instance != null && !string.IsNullOrEmpty(weaponPrefab))
             {
                 GameObject itemObj = ObjectDB.instance.GetItemPrefab(weaponPrefab);
@@ -41,88 +103,38 @@ namespace MxValheim.KillFeed
                     {
                         weaponIcon = itemDrop.m_itemData.m_shared.m_icons[0];
                     }
+                } else
+                {
                 }
             }
+           
+            if (type == 1)
+            { // Player
+                borderColor = new Color(0.545f, 0f, 0f);
+            }
+            else if (isBoss)
+            { // Boss
+                borderColor = new Color(0.545f, 0.361f, 0f);
+            }
+            else if (level >= 2)
+            { // 1-Star +
+                borderColor = new Color(0.525f, 0.545f, 0f);
+            }
+            else if (level < 2)
+            {
+                borderColor = new Color(0.141f, 0.141f, 0.153f);
+            }
+
             lock (_msgQueue)
             {
                 _msgQueue.Enqueue(finalMsg);
+                _borderColQueue.Enqueue(borderColor);
                 _iconQueue.Enqueue(weaponIcon);
+                _victimIconQueue.Enqueue(victimIcon);
             }
         }
 
-        [HarmonyPatch(typeof(Character), nameof(Character.Damage))]
-        public static class DamageTracker
-        {
-            static void Prefix(Character __instance, HitData hit)
-            {
-                if (__instance == null || hit == null) return;
-
-                Character attacker = hit.GetAttacker();
-                if (attacker != null)
-                {
-                    string weaponName = "Unknown";
-
-                    // If the attacker is a player, get their current weapon
-                    if (attacker.IsPlayer())
-                    {
-                        Player player = attacker as Player;
-                        if (player != null && player.GetCurrentWeapon() != null)
-                        {
-                            weaponName = player.GetCurrentWeapon().m_dropPrefab?.name ?? "Hands";
-                        }
-                    }
-                    else
-                    {
-                        // If it's a monster, we just use their hover name (e.g., "Troll")
-                        weaponName = attacker.GetHoverName();
-                    }
-
-                    // Store the data for the Postfix to use
-                    _activeTrackers[__instance] = new KillData
-                    {
-                        attackerName = attacker.GetHoverName(),
-                        weaponPrefabName = weaponName
-                    };
-                }
-            }
-        }
-
-        [HarmonyPatch(typeof(Character), nameof(Character.ApplyDamage))]
-        public static class DeathNotifier
-        {
-            // The parameter names MUST match the game's: hit, showDamageText, triggerEffects, mod
-            static void Postfix(Character __instance, HitData hit, bool showDamageText, bool triggerEffects, HitData.DamageModifier mod)
-            {
-                // Check if the character is dead or just died
-                if (__instance.GetHealth() <= 0f)
-                {
-                    ZNetView nview = __instance.GetComponent<ZNetView>();
-
-                    // This check should now pass because ApplyDamage happens before the object is invalidated
-                    if (nview == null || !nview.IsValid() || !nview.IsOwner()) return;
-
-                    _activeTrackers.TryGetValue(__instance, out KillData data);
-
-                    string attackerName = data?.attackerName ?? hit.GetAttacker()?.GetHoverName() ?? "The World";
-                    string weaponName = data?.weaponPrefabName ?? "";
-                    string victimName = __instance.GetHoverName();
-
-                    int type = 0;
-                    if (__instance.IsPlayer()) type = 1;
-                    else if (attackerName == Player.m_localPlayer?.GetHoverName()) type = 2;
-
-                    if (ZRoutedRpc.instance != null)
-                    {
-                        ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.Everybody, "RPC_MxKillMsg",
-                            attackerName, victimName, weaponName, type);
-                    }
-
-                    _activeTrackers.Remove(__instance);
-                }
-            }
-        }
-
-        public void ShowNextMessage(string msg, Sprite icon)
+        public void ShowNextMessage(string msg, Sprite weaponIcon, Sprite victimIcon, Color borderColor)
         {
             if (_hudRoot == null) CreateCustomHud();
 
@@ -140,13 +152,146 @@ namespace MxValheim.KillFeed
             }
 
             _killText.text = msg;
-            _weaponIconSlot.sprite = icon;
-            _weaponIconSlot.gameObject.SetActive(icon != null);
+            _border.effectColor = borderColor;
+            _border.enabled = true;
+            // Weapon icon (Left)
+            _weaponIconSlot.sprite = weaponIcon;
+            _weaponIconSlot.enabled = (weaponIcon != null);
+            // Victim icon (Right)
+            if (_victimIconSlot != null)
+            {
+                _victimIconSlot.sprite = victimIcon;
+                _victimIconSlot.enabled = (victimIcon != null);
+            }
+            _weaponIconSlot.gameObject.SetActive(weaponIcon != null);
+            _victimIconSlot.gameObject.SetActive(victimIcon != null);
+            _panelImage.rectTransform.localScale = (borderColor != Color.white) ? new Vector3(1.1f, 1.1f, 1.1f) : Vector3.one;
             _hudRoot.SetActive(true);
             _canvasGroup.alpha = 1f;
             _displayTimer = 5.0f;
         }
 
+        private Sprite GetCreatureIcon(string creatureName)
+        {
+            if (ObjectDB.instance == null) return null;
+
+            // Clean the name (remove "(Clone)" if it somehow slipped through)
+            string cleanName = creatureName.Replace("(Clone)", "").Trim();
+
+            // List of common trophies that don't follow the exact pattern if needed
+            // But for most (Boar, Greyling, Neck, Deer), this works:
+            string replace = cleanName.Replace("_","");
+            string trophyName = "Trophy" + replace;
+
+            GameObject trophyObj = ObjectDB.instance.GetItemPrefab(trophyName);
+            if (trophyObj != null)
+            {
+                ItemDrop item = trophyObj.GetComponent<ItemDrop>();
+                return item?.m_itemData?.m_shared?.m_icons[0];
+            }
+
+            return null;
+        }
+
+        [HarmonyPatch(typeof(Character), nameof(Character.Damage))]
+        public static class DamageTracker
+        {
+            static void Prefix(Character __instance, HitData hit)
+            {
+                if (__instance == null || hit == null) return;
+
+                Character attacker = hit.GetAttacker();
+                if (attacker != null)
+                {
+                    string weaponId = "";
+                    if (attacker is Player p)
+                    {
+                        // IMPORTANT: Use .m_dropPrefab.name to get "AxeStone"
+                        // Do NOT use .m_shared.m_name which returns "$item_axe_stone"
+                        ItemDrop.ItemData currentWeapon = p.GetCurrentWeapon();
+                        if (currentWeapon != null && currentWeapon.m_dropPrefab != null)
+                        {
+                            weaponId = currentWeapon.m_dropPrefab.name;
+                        }
+                    }
+                    _activeTrackers[__instance] = new KillData
+                    {
+                        attackerName = attacker.GetHoverName(),
+                        weaponPrefabName = weaponId
+                    };
+                }
+            }
+        }
+
+        [HarmonyPatch(typeof(Character), nameof(Character.ApplyDamage))]
+        public static class DeathNotifier
+        {
+            // The parameter names MUST match the game's: hit, showDamageText, triggerEffects, mod
+            static void Postfix(Character __instance, HitData hit, bool showDamageText, bool triggerEffects, HitData.DamageModifier mod)
+            {
+                // Check if the character is dead or just died
+                if (__instance.GetHealth() <= 0f)
+                {
+                    ZNetView nview = __instance.GetComponent<ZNetView>();
+
+                    // Prevent inter-npc kill
+                    if (!__instance.IsPlayer() && !hit.GetAttacker().IsPlayer()) return;
+
+                    // This check should now pass because ApplyDamage happens before the object is invalidated
+                    if (nview == null || !nview.IsValid() || !nview.IsOwner()) return;
+
+                    float distance = 0f;
+                    Character attacker = hit.GetAttacker();
+                    if (attacker != null)
+                    {
+                        Debug.Log($"KillFeed:ApplyDamage Attacker is {attacker} {attacker.transform.position}/{__instance.transform.position}");
+                        distance = Vector3.Distance(attacker.transform.position, __instance.transform.position);
+                    }
+
+                    // Use Utils.GetPrefabName to get "Boar" instead of "Sanglier" or "Boar(Clone)"
+                    string internalName = __instance.gameObject.name;
+                    int cloneIndex = internalName.IndexOf("(Clone)");
+                    if (cloneIndex != -1)
+                    {
+                        internalName = internalName.Substring(0, cloneIndex);
+                    }
+
+                    _activeTrackers.TryGetValue(__instance, out KillData data);
+
+                    string attackerName = data?.attackerName ?? hit.GetAttacker()?.GetHoverName() ?? "The World";
+                    string weaponName = "";
+                    if (data != null && !string.IsNullOrEmpty(data.weaponPrefabName))
+                    {
+                        weaponName = data.weaponPrefabName;
+                    }
+                    else if (hit.GetAttacker() is Player p)
+                    {
+                        // Fallback: If tracker missed it, get current player's weapon
+                        weaponName = p.GetCurrentWeapon()?.m_dropPrefab?.name ?? "";
+                    }
+                    string victimName = __instance.GetHoverName();
+
+                    int type = 0;
+                    if (__instance.IsPlayer()) type = 1;
+                    else if (attackerName == Player.m_localPlayer?.GetHoverName()) type = 2;
+
+                    int level = __instance.GetLevel();
+                    bool isBoss = __instance.IsBoss();
+
+                    int distInt = (int)(Math.Min(distance, 999f) * 10);
+                    int encodedType = type + (level * 10) + (isBoss ? 100 : 0) + (distInt * 1000);
+
+                    if (ZRoutedRpc.instance != null)
+                    {
+                        ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.Everybody, "RPC_MxKillMsg",
+                            attackerName, victimName, internalName, weaponName, encodedType);
+                    }
+
+                    _activeTrackers.Remove(__instance);
+                }
+            }
+        }    
+
         private void CreateCustomHud()
         {
             GameObject oldRoot = GameObject.Find("MxKillFeed_Root");
@@ -172,6 +317,21 @@ namespace MxValheim.KillFeed
             _panelImage = panel.GetComponent<Image>();
             _panelImage.color = new Color(0, 0, 0, 0.6f); // More transparent/sleek
 
+            // 1. Add Layout Group to handle the horizontal row
+            HorizontalLayoutGroup layout = panel.AddComponent<HorizontalLayoutGroup>();
+            layout.childAlignment = TextAnchor.MiddleCenter;
+            layout.spacing = 10f;
+            layout.padding = new RectOffset(15, 15, 5, 5); // Internal margins
+            layout.childControlWidth = true;  // Let the layout control widths
+            layout.childControlHeight = true;
+            layout.childForceExpandWidth = false;
+
+            // 2. Add the Content Size Fitter (The "Stretcher")
+            ContentSizeFitter fitter = panel.AddComponent<ContentSizeFitter>();
+            fitter.horizontalFit = ContentSizeFitter.FitMode.PreferredSize;
+            fitter.verticalFit = ContentSizeFitter.FitMode.PreferredSize;
+
+
             // Try to find the "sunken" wood panel style if shout_field isn't your vibe
             foreach (Sprite s in Resources.FindObjectsOfTypeAll<Sprite>())
             {
@@ -194,6 +354,9 @@ namespace MxValheim.KillFeed
             iconObj.transform.SetParent(panel.transform, false);
             _weaponIconSlot = iconObj.GetComponent<Image>();
             _weaponIconSlot.preserveAspect = true;
+            LayoutElement weaponLayout = iconObj.AddComponent<LayoutElement>();
+            weaponLayout.preferredWidth = 24;
+            weaponLayout.preferredHeight = 24;
 
             RectTransform iRect = iconObj.GetComponent<RectTransform>();
             iRect.anchorMin = iRect.anchorMax = iRect.pivot = new Vector2(0, 0.5f);
@@ -204,6 +367,8 @@ namespace MxValheim.KillFeed
             GameObject textObj = new GameObject("Text", typeof(RectTransform), typeof(Text));
             textObj.transform.SetParent(panel.transform, false);
             _killText = textObj.GetComponent<Text>();
+            // Important: Text needs to have its "Horizontal Overflow" set to Wrap or Overflow
+            _killText.horizontalOverflow = HorizontalWrapMode.Overflow;
 
             // Attempt to find Valheim's specific font, fallback to Arial if not found
             Font valheimFont = null;
@@ -223,85 +388,37 @@ namespace MxValheim.KillFeed
             }
 
             _killText.font = valheimFont;
-            _killText.fontSize = 18;
+            _killText.fontSize = 12;
             _killText.alignment = TextAnchor.MiddleLeft;
             _killText.supportRichText = true;
             _killText.color = Color.white;
 
+
+            // 4. Victim Portrait Slot
+            GameObject victimObj = new GameObject("VictimIcon", typeof(RectTransform), typeof(Image));
+            victimObj.transform.SetParent(panel.transform, false);
+            _victimIconSlot = victimObj.GetComponent<Image>();
+            _victimIconSlot.preserveAspect = true;
+            LayoutElement victimLayout = victimObj.AddComponent<LayoutElement>();
+            victimLayout.preferredWidth = 24;
+            victimLayout.preferredHeight = 24;
+
+            RectTransform vRect = victimObj.GetComponent<RectTransform>();
+            vRect.anchorMin = vRect.anchorMax = vRect.pivot = new Vector2(1, 0.5f);
+            vRect.anchoredPosition = new Vector2(-8, 0);
+            vRect.sizeDelta = new Vector2(30, 30);
+
             RectTransform tRect = textObj.GetComponent<RectTransform>();
             tRect.anchorMin = Vector2.zero;
             tRect.anchorMax = Vector2.one;
             tRect.offsetMin = new Vector2(40, 0);
-            tRect.offsetMax = new Vector2(-10, 0);
+            tRect.offsetMax = new Vector2(-40, 0);
+
+            _border = panel.AddComponent<Outline>();
+            _border.effectDistance = new Vector2(2, 2);
+            _border.enabled = false; // Off by default
 
             _hudRoot.SetActive(false);
         }
-
-        /*
-        public void CreateCustomHud()
-        {
-            _hudRoot = new GameObject("MxKillFeed_Root");
-            UnityEngine.Object.DontDestroyOnLoad(_hudRoot);
-
-            Canvas c = _hudRoot.AddComponent<Canvas>();
-            c.renderMode = RenderMode.ScreenSpaceOverlay;
-            c.sortingOrder = 10000;
-
-            // Add a Scaler to ensure it looks right on all resolutions
-            CanvasScaler scaler = _hudRoot.AddComponent<CanvasScaler>();
-            scaler.uiScaleMode = CanvasScaler.ScaleMode.ScaleWithScreenSize;
-            scaler.referenceResolution = new Vector2(1920, 1080);
-
-            _canvasGroup = _hudRoot.AddComponent<CanvasGroup>();
-
-            GameObject panel = new GameObject("Background", typeof(RectTransform), typeof(Image));
-            panel.transform.SetParent(_hudRoot.transform, false);
-            _panelImage = panel.GetComponent<Image>();
-
-            // Fallback: Set a solid color first in case the sprite search fails
-            _panelImage.color = new Color(0, 0, 0, 0.8f);
-
-            foreach (Sprite s in Resources.FindObjectsOfTypeAll<Sprite>())
-            {
-                if (s.name == "shout_field")
-                {
-                    _panelImage.sprite = s;
-                    _panelImage.type = Image.Type.Sliced;
-                    break;
-                }
-            }
-
-            RectTransform pRect = panel.GetComponent<RectTransform>();
-            pRect.anchorMin = pRect.anchorMax = pRect.pivot = new Vector2(0.5f, 0.95f);
-            pRect.anchoredPosition = Vector2.zero; // Center top
-            pRect.sizeDelta = new Vector2(550, 40);
-            pRect.localScale = Vector3.one; // FORCE SCALE TO 1
-
-            // Icon
-            GameObject iconObj = new GameObject("Icon", typeof(RectTransform), typeof(Image));
-            iconObj.transform.SetParent(panel.transform, false);
-            _weaponIconSlot = iconObj.GetComponent<Image>();
-            _weaponIconSlot.preserveAspect = true;
-            RectTransform iRect = iconObj.GetComponent<RectTransform>();
-            iRect.anchorMin = iRect.anchorMax = iRect.pivot = new Vector2(0, 0.5f);
-            iRect.anchoredPosition = new Vector2(10, 0);
-            iRect.sizeDelta = new Vector2(30, 30);
-
-            // Text
-            GameObject textObj = new GameObject("Text", typeof(RectTransform), typeof(Text));
-            textObj.transform.SetParent(panel.transform, false);
-            _killText = textObj.GetComponent<Text>();
-            _killText.font = Resources.GetBuiltinResource<Font>("Arial.ttf");
-            _killText.fontSize = 18;
-            _killText.alignment = TextAnchor.MiddleLeft;
-            _killText.supportRichText = true;
-            textObj.AddComponent<Outline>().effectColor = Color.black;
-
-            RectTransform tRect = textObj.GetComponent<RectTransform>();
-            tRect.anchorMin = Vector2.zero; tRect.anchorMax = Vector2.one;
-            tRect.offsetMin = new Vector2(50, 0); tRect.offsetMax = new Vector2(-10, 0);
-
-            _hudRoot.SetActive(false);
-        }*/
     }
 }

MxValheim/MxValheim.cs

@@ -1,25 +1,33 @@
 using BepInEx;
 using BepInEx.Configuration;
 using HarmonyLib;
+using MxValheim.EventSystem;
 using MxValheim.KillFeed;
+using MxValheim.Patch;
+using MxValheim.Patch.HUD;
 using Newtonsoft.Json;
 using System;
 using System.Collections.Generic;
 using System.IO;
+using System.Linq;
+using System.Reflection;
 using System.Threading;
 using System.Xml;
+using TMPro;
 using UnityEngine;
 using UnityEngine.UI;
+using static MxValheim.Patch.Doors_Patch;
 
 [BepInPlugin(ModGUID, ModName, ModVersion)]
 public class MxValheimMod : BaseUnityPlugin
 {
     public static MxValheimMod Instance; // Singleton reference
     public static KillFeed_Patch kfp = new KillFeed_Patch();
+    public static Doors_Patch dpatch = new Doors_Patch();
 
     private const string ModGUID = "ovh.mxdev.mxvalheim";
     private const string ModName = "MxValheim";
-    private const string ModVersion = "1.5.0";
+    private const string ModVersion = "1.6.0";
 
     public static ConfigEntry<bool> Config_Locked;
     public static ConfigEntry<int> Config_OreMultiplier;
@@ -30,7 +38,11 @@ public class MxValheimMod : BaseUnityPlugin
     public static ConfigEntry<bool> Config_autoDoorCloseEnabled;
     public static ConfigEntry<float> Config_autoDoorClose;
 
-    private static string WeightConfigPath => Path.Combine(Paths.ConfigPath, "mxvalheim.custom_weights.json");
+    public static string modPath = Path.Combine(Paths.PluginPath, "MxValheim");
+    public static string internalConfigsPath = Path.Combine(modPath, "Configs");
+    public static string WeightConfigPath => Path.Combine(internalConfigsPath, "items_weight.json");
+    public static string AutoDoorConfigPath => Path.Combine(internalConfigsPath, "auto_doors.json");
+    public static DoorRoot CachedConfig;
     public static Dictionary<string, float> WeightSettings = new Dictionary<string, float>();
 
     // Data structures
@@ -38,19 +50,32 @@ public class MxValheimMod : BaseUnityPlugin
     {
         public string attackerName;
         public string weaponPrefabName;
+        public int victimLevel;
+        public bool isBoss;
     }
 
     public static GameObject _hudRoot;
     public static Text _killText;
     public static Image _weaponIconSlot;
+    public static Image _victimIconSlot;
     public static Image _panelImage;
+    public static Outline _border;
+    public static Color borderColor = Color.white;
     public static CanvasGroup _canvasGroup;
+    public static float _fadeDuration = 0.5f;
     public static float _displayTimer;
 
     public static readonly Queue<string> _msgQueue = new Queue<string>();
+    public static readonly Queue<Color> _borderColQueue = new Queue<Color>();
     public static readonly Queue<Sprite> _iconQueue = new Queue<Sprite>();
+    public static readonly Queue<Sprite> _victimIconQueue = new Queue<Sprite>();
     public static readonly Dictionary<Character, KillData> _activeTrackers = new Dictionary<Character, KillData>();
 
+    public static readonly Queue<ZNetView> _doorQueueNview = new Queue<ZNetView>();
+    public static readonly Queue<Door> _doorQueueDoor = new Queue<Door>();
+    public static readonly Queue<string> _doorQueueName = new Queue<string>();
+    public static float _doorTimer;
+
     void Awake()
     {
         Instance = this;
@@ -63,12 +88,53 @@ public class MxValheimMod : BaseUnityPlugin
         Config_autoDoorCloseEnabled = Config.Bind("General", "AutoDoorCloseEnabled", true, "Your doors will auto close if enabled. See AutoDoorCloseTimer for the desired time.");
         Config_autoDoorClose = Config.Bind("General", "AutoDoorCloseTimer", 5.0f, "Your doors will auto close after the specified timer duration.");
 
+        LoadLocalization();
         LoadJsonConfig();
+        LoadDoorConfig();
+
+        _doorTimer = MxValheimMod.Config_autoDoorClose.Value;
 
         Harmony harmony = new Harmony(ModGUID);
         harmony.PatchAll();
     }
 
+    public static void RPC_UpdateRaidHUD(long sender, string phaseName, int current, int total)
+    {
+        Color phaseColor;
+        switch (phaseName)
+        {
+            case "SCOUTS": phaseColor = Color.green; break;
+            case "ELITEGUARD": phaseColor = Color.yellow; break;
+            case "BOSSINBOUND": phaseColor = Color.red; break;
+            default: phaseColor = Color.white; break;
+        }
+
+        EventSystem_Patch.UpdateDisplay(phaseName, current, total, phaseColor);
+    }
+
+    [HarmonyPatch(typeof(Localization), nameof(Localization.SetupLanguage))]
+    public static class Localization_SetupLanguage_Patch
+    {
+        public static void Postfix()
+        {
+            LoadLocalization();
+        }
+    }
+
+    // --- TEST COMMAND: Type 'testkill' in F5 console ---
+    [HarmonyPatch(typeof(Terminal), nameof(Terminal.InputText))]
+    public static class ConsoleInputPatch
+    {
+        static void Postfix(Terminal __instance)
+        {
+            string text = __instance.m_input.text;
+            if (text.ToLower() == "listicons")
+            {
+                
+            }
+        }
+    }
+
     [HarmonyPatch(typeof(Game), nameof(Game.Start))]
     public static class GameStartPatch
     {
@@ -77,25 +143,82 @@ public class MxValheimMod : BaseUnityPlugin
             if (ZRoutedRpc.instance != null && kfp != null)
             {              
                 // We use the explicit 'Method' delegate to avoid the ArgumentException
-                ZRoutedRpc.instance.Register<string, string, string, int>("RPC_MxKillMsg",
-                    new RoutedMethod<string, string, string, int>.Method(kfp.OnReceiveKillMsg));
+                ZRoutedRpc.instance.Register<string, string, string, string, int>("RPC_MxKillMsg",
+                    new RoutedMethod<string, string, string, string, int>.Method(kfp.OnReceiveKillMsg));
 
                 Debug.Log("MxValheimMod: RPC Registered successfully with explicit delegate.");
             }
+
+            if (ZRoutedRpc.instance != null)
+            {
+                ZRoutedRpc.instance.Register<string, int, int>("RPC_UpdateRaidHUD", RPC_UpdateRaidHUD);
+                Debug.Log("MxRaid: RPC Registered successfully.");
+            }
+
+            EventSystem_Patch.CreateEventHud();
         }
     }
 
     void Update()
     {
-        // Use the game's native check for dedicated servers
+        // Only run if we are actually in the game world
+        if (Player.m_localPlayer != null)
+        {
+            if (Splash.m_canvasObject == null)
+            {
+                Splash spl = new Splash();
+                spl.CreateOverlay();
+            }
+
+            if (Splash.m_textComponent != null)
+            {
+                Splash.m_textComponent.text = $"<color=#677074>Mx</color><color=#d1954a>Valheim {MxValheimMod.ModVersion}</color>";
+            }
+
+            if (Clock.m_canvasObject == null)
+            {
+                Clock clk = new Clock();
+                clk.CreateOverlay();
+            }
+
+            if (Clock.m_textComponent != null)
+            {
+                Clock clk = new Clock();
+                string timeString = clk.GetFormattedTime();
+                int day = EnvMan.instance.GetDay();
+                Clock.m_textComponent.text = $"<color=#32a852>{Localization.instance.Localize("$clock_string_day")} {day}</color> <color=#677074>|</color> <color=#d1954a>{timeString}</color>";
+            }
+        } 
+
+        // Door Logic
+        if (_doorQueueNview.Count > 0)
+        {         
+            if (_doorTimer > 0)
+            {
+                _doorTimer -= Time.deltaTime;
+            }
+
+            if (_doorTimer <= 0)
+            {
+                dpatch.CloseNextDoor(_doorQueueDoor.Dequeue(), _doorQueueNview.Dequeue(), _doorQueueName.Dequeue());
+                _doorTimer = MxValheimMod.Config_autoDoorClose.Value;
+            }
+        }    
+        // Door Logic
+        /////////////
+
+
+        // KillFeed Logic
         ZNet zn = new ZNet();
         if (zn.IsDedicated() || Player.m_localPlayer == null) return;
+
         if (_msgQueue == null || _msgQueue.Count == 0 && _displayTimer <= 0) return;
 
         // Logic to trigger next message
         if (_msgQueue.Count > 0 && _displayTimer <= 0)
         {
-            kfp.ShowNextMessage(_msgQueue.Dequeue(), _iconQueue.Dequeue());
+            borderColor = new Color(0.141f, 0.141f, 0.153f);
+            kfp.ShowNextMessage(_msgQueue.Dequeue(), _iconQueue.Dequeue(), _victimIconQueue.Dequeue(), _borderColQueue.Dequeue());
         }
 
         if (_displayTimer > 0)
@@ -110,7 +233,6 @@ public class MxValheimMod : BaseUnityPlugin
                 if (_displayTimer > 4.5f)
                 { // Fading in (first 0.5s)
                     _canvasGroup.alpha = (5f - _displayTimer) * 2;
-                    pRect.anchoredPosition = new Vector2(0, -20 - ((5f - _displayTimer) * 20)); // Slide down
                 }
                 else if (_displayTimer < 1f)
                 { // Fading out (last 1s)
@@ -125,23 +247,59 @@ public class MxValheimMod : BaseUnityPlugin
 
             if (_displayTimer <= 0 && _hudRoot != null) _hudRoot.SetActive(false);
         }
+        // KillFeed Logic
+        /////////////////
+
+        if (RandEventSystem.instance.GetActiveEvent() == null)
+        {
+            EventSystem_Patch._canvasGroup.alpha = 0;
+            EventSystem_Patch._eventRoot.SetActive(false);
         }
 
-    [HarmonyPatch(typeof(Terminal), nameof(Terminal.InputText))]
-    public static class ConsoleInputPatch
-    {
-        static void Postfix(Terminal __instance)
-        {
-            // 2. Get the text safely. Valheim often uses m_input.text
-            string text = __instance.m_input?.text;
-            Debug.Log($"MxKillFeed: {text}");
-            if (string.IsNullOrEmpty(text)) return;
+    }   
 
-            if (text.ToLower().Trim() == "testkill")
+    public static void LoadLocalization()
     {
-                // Trigger the message directly on the local client
-                KillFeed_Patch kfp = new KillFeed_Patch();
-                kfp.OnReceiveKillMsg(0, "Developer", "Testing Dummy", "AxeFlint", 2);
+        if (Localization.instance == null) return;
+
+        string modPath = Path.Combine(Paths.PluginPath, "MxValheim");
+        string translationsPath = Path.Combine(modPath, "Translations");
+        string lang = Localization.instance.GetSelectedLanguage();
+        string filePath = Path.Combine(translationsPath, $"{lang}.json");
+
+        if (!File.Exists(filePath))
+        {
+            filePath = Path.Combine(translationsPath, "English.json");
+        }
+
+        if (File.Exists(filePath))
+        {
+            try
+            {
+                string json = File.ReadAllText(filePath);
+                var dict = JsonConvert.DeserializeObject<Dictionary<string, string>>(json);
+
+                // Get the method via Reflection to bypass "Inaccessible" errors
+                MethodInfo addWordMethod = typeof(Localization).GetMethod("AddWord",
+                    BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
+
+                if (addWordMethod != null)
+                {
+                    foreach (var entry in dict)
+                    {
+                        // Parameters: (instance to run on, array of arguments)
+                        addWordMethod.Invoke(Localization.instance, new object[] { entry.Key, entry.Value });
+                    }
+                    Debug.Log($"[MxValheim] Successfully injected {dict.Count} strings for {lang}.");
+                }
+                else
+                {
+                    Debug.LogError("[MxValheim] Critical Error: Could not find AddWord method in game code.");
+                }
+            }
+            catch (Exception e)
+            {
+                Debug.LogError($"[MxValheim] Error loading JSON: {e.Message}");
             }
         }
     }
@@ -169,6 +327,15 @@ public class MxValheimMod : BaseUnityPlugin
         }
     }
 
+    public void LoadDoorConfig()
+    {
+        if (System.IO.File.Exists(AutoDoorConfigPath))
+        {
+            string json = System.IO.File.ReadAllText(AutoDoorConfigPath);
+            CachedConfig = JsonConvert.DeserializeObject<DoorRoot>(json);
+        }
+    }
+
     internal static void ShowKillMessage(string v)
     {
         throw new NotImplementedException();

MxValheim/MxValheim.csproj

@@ -35,32 +35,42 @@
     <Reference Include="0Harmony">
       <HintPath>E:\SteamLibrary\steamapps\common\Valheim\BepInEx\core\0Harmony.dll</HintPath>
     </Reference>
-    <Reference Include="Assembly-CSharp-publicized">
-      <HintPath>E:\SteamLibrary\steamapps\common\Valheim\Valheim_Data\Managed\Assembly-CSharp-publicized.dll</HintPath>
+    <Reference Include="assembly_guiutils_publicized">
+      <HintPath>E:\SteamLibrary\steamapps\common\Valheim\Valheim_Data\Managed\publicized_assemblies\assembly_guiutils_publicized.dll</HintPath>
     </Reference>
-    <Reference Include="assembly_valheim-publicized">
-      <HintPath>E:\SteamLibrary\steamapps\common\Valheim\Valheim_Data\Managed\assembly_valheim-publicized.dll</HintPath>
+    <Reference Include="assembly_valheim_publicized">
+      <HintPath>E:\SteamLibrary\steamapps\common\Valheim\Valheim_Data\Managed\publicized_assemblies\assembly_valheim_publicized.dll</HintPath>
     </Reference>
     <Reference Include="BepInEx">
       <HintPath>E:\SteamLibrary\steamapps\common\Valheim\BepInEx\core\BepInEx.dll</HintPath>
     </Reference>
-    <Reference Include="gui_framework, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null" />
+    <Reference Include="gui_framework">
+      <HintPath>E:\SteamLibrary\steamapps\common\Valheim\Valheim_Data\Managed\gui_framework.dll</HintPath>
+    </Reference>
     <Reference Include="Newtonsoft.Json">
       <HintPath>E:\SteamLibrary\steamapps\common\Valheim\BepInEx\plugins\Newtonsoft.Json.dll</HintPath>
     </Reference>
+    <Reference Include="PresentationFramework" />
     <Reference Include="Splatform, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null" />
     <Reference Include="System" />
     <Reference Include="System.Core" />
+    <Reference Include="System.Drawing" />
     <Reference Include="System.Xml.Linq" />
     <Reference Include="System.Data.DataSetExtensions" />
     <Reference Include="Microsoft.CSharp" />
     <Reference Include="System.Data" />
     <Reference Include="System.Net.Http" />
     <Reference Include="System.Xml" />
-    <Reference Include="Unity.TextMeshPro, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null" />
+    <Reference Include="Unity.TextMeshPro">
+      <HintPath>E:\SteamLibrary\steamapps\common\Valheim\Valheim_Data\Managed\Unity.TextMeshPro.dll</HintPath>
+    </Reference>
     <Reference Include="UnityEngine">
       <HintPath>E:\SteamLibrary\steamapps\common\Valheim\Valheim_Data\Managed\UnityEngine.dll</HintPath>
     </Reference>
+    <Reference Include="UnityEngine.AssetBundleModule, Version=0.0.0.0, Culture=neutral, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>E:\SteamLibrary\steamapps\common\Valheim\Valheim_Data\Managed\UnityEngine.AssetBundleModule.dll</HintPath>
+    </Reference>
     <Reference Include="UnityEngine.CoreModule">
       <HintPath>E:\SteamLibrary\steamapps\common\Valheim\Valheim_Data\Managed\UnityEngine.CoreModule.dll</HintPath>
     </Reference>
@@ -68,7 +78,9 @@
       <SpecificVersion>False</SpecificVersion>
       <HintPath>E:\SteamLibrary\steamapps\common\Valheim\Valheim_Data\Managed\UnityEngine.PhysicsModule.dll</HintPath>
     </Reference>
-    <Reference Include="UnityEngine.TextRenderingModule, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null" />
+    <Reference Include="UnityEngine.TextRenderingModule">
+      <HintPath>E:\SteamLibrary\steamapps\common\Valheim\Valheim_Data\Managed\UnityEngine.TextRenderingModule.dll</HintPath>
+    </Reference>
     <Reference Include="UnityEngine.UI, Version=1.0.0.0, Culture=neutral, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
       <HintPath>E:\SteamLibrary\steamapps\common\Valheim\Valheim_Data\Managed\UnityEngine.UI.dll</HintPath>
@@ -79,12 +91,18 @@
     </Reference>
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="KillFeed\Chat.cs" />
+    <Compile Include="EventSystem\EventHud.cs" />
+    <Compile Include="EventSystem\EventList.cs" />
+    <Compile Include="EventSystem\Patch.cs" />
+    <Compile Include="EventSystem\WaveManager.cs" />
+    <Compile Include="KillFeed\NPCIcon.cs" />
     <Compile Include="KillFeed\Patch.cs" />
     <Compile Include="MxValheim.cs" />
     <Compile Include="Patch\Bow.cs" />
     <Compile Include="Patch\CraftingStation.cs" />
     <Compile Include="Patch\Doors.cs" />
+    <Compile Include="Patch\HUD\Clock.cs" />
+    <Compile Include="Patch\HUD\Splash.cs" />
     <Compile Include="Patch\Items.cs" />
     <Compile Include="Patch\Ores.cs" />
     <Compile Include="Patch\WearNTear.cs" />
@@ -96,10 +114,12 @@
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <PropertyGroup>
     <PostBuildEvent>
-copy /Y "$(TargetDir)$(TargetName).dll" "E:\SteamLibrary\steamapps\common\Valheim\BepInEx\plugins\"
-copy /Y "$(TargetDir)$(TargetName).pdb" "E:\SteamLibrary\steamapps\common\Valheim\BepInEx\plugins\"
+copy /Y "$(TargetDir)$(TargetName).dll" "E:\SteamLibrary\steamapps\common\Valheim\BepInEx\plugins\MxValheim\"
+copy /Y "$(TargetDir)$(TargetName).pdb" "E:\SteamLibrary\steamapps\common\Valheim\BepInEx\plugins\MxValheim\"
 
-copy /Y "$(TargetDir)$(TargetName).dll" "R:\Server\valdev\BepInEx\plugins\"
-copy /Y "$(TargetDir)$(TargetName).pdb" "R:\Server\valdev\BepInEx\plugins\"</PostBuildEvent>
+copy /Y "$(TargetDir)$(TargetName).dll" "R:\Server\valdev\BepInEx\plugins\MxValheim\"
+copy /Y "$(TargetDir)$(TargetName).pdb" "R:\Server\valdev\BepInEx\plugins\MxValheim\"
+if exist "E:\SteamLibrary\steamapps\common\Valheim\BepInEx\plugins\MxValheim.zip" del "E:\SteamLibrary\steamapps\common\Valheim\BepInEx\plugins\MxValheim.zip"
+"C:\Program Files\7-Zip\7z.exe" a -tzip "E:\SteamLibrary\steamapps\common\Valheim\BepInEx\plugins\MxValheim.zip" "E:\SteamLibrary\steamapps\common\Valheim\BepInEx\plugins\MxValheim\*"</PostBuildEvent>
   </PropertyGroup>
 </Project>

MxValheim/Patch/Doors.cs

@@ -1,48 +1,67 @@
 using BepInEx;
 using HarmonyLib;
+using Newtonsoft.Json;
 using System.Collections;
+using System.Collections.Generic;
+using System.IO;
 using UnityEngine;
 using UnityEngine.Diagnostics;
+using static MxValheimMod;
 
 namespace MxValheim.Patch
 {
-    internal class Doors
+    public class Doors_Patch
     {
+        public class DoorRoot
+        {
+            public List<string> ignoreList { get; set; }
+        }
+
         [HarmonyPatch(typeof(Door), nameof(Door.Interact))]
-        static class Door_Interact_Patch
+        public static class DoorTracker
         {
             static void Postfix(Door __instance, Humanoid character, bool hold, bool alt, ZNetView ___m_nview)
             {
-                string prefabName = ___m_nview.GetPrefabName();
+                ZNetView nview = __instance.GetComponent<ZNetView>();
+                if (nview != null && nview.IsValid())
+                {
+                    // Get the prefab hash and look up the name in the master list
+                    int prefabHash = nview.GetZDO().GetPrefab();
+                    string prefabName = ZNetScene.instance.GetPrefab(prefabHash).name;
+
+                    if (MxValheimMod.CachedConfig?.ignoreList != null)
+                        if (MxValheimMod.CachedConfig.ignoreList.Contains(prefabName)) return;
 
                     if (hold || alt || ___m_nview == null || !___m_nview.IsValid()) return;
-                // Prevent closing of swamp iron gate
-                if (prefabName == "piece_crypt_door") return;
 
                     // Get state: 0 is closed
                     int state = ___m_nview.GetZDO().GetInt("state");
 
-                if (state != 0)
+                    if (state == 0) return;              
+
+                    lock (_doorQueueNview)
                     {
-                    // Start coroutine on the door object itself
-                    __instance.StartCoroutine(CloseDoorAfterDelay(__instance, ___m_nview));
+                        Debug.Log($"AutoDoor:Door.Interact Adding \"{prefabName}\" to queue.");
+                        _doorQueueNview.Enqueue(nview);
+                        _doorQueueDoor.Enqueue(__instance);
+                        _doorQueueName.Enqueue(prefabName);
+                    }
+                }
             }
         }    
 
-            static IEnumerator CloseDoorAfterDelay(Door door, ZNetView nview)
+        public void CloseNextDoor(Door door, ZNetView nview, string doorName)
         {
-                yield return new WaitForSeconds(MxValheimMod.Config_autoDoorClose.Value);
-
-                // Verify the door still exists and is still open before closing
             if (door != null && nview != null && nview.IsValid())
             {
                 if (nview.GetZDO().GetInt("state") != 0)
                 {
-                        // Directly invoke the RPC with '0' (closed). 
-                        // This avoids the 'Null' player error in Door.Interact
+                    Debug.Log($"AutoDoor:CloseNextDoor Closing door \"{doorName}\".");
                     ZDO zd0 = nview.GetZDO();
                     zd0.Set("state", 0);
-                    }
+                } else
+                {
+                    Debug.Log($"AutoDoor:CloseNextDoor Door \"{doorName}\" was already closed.");
                 }
             }
         }

MxValheim/Patch/HUD/Clock.cs

@@ -0,0 +1,96 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using UnityEngine;
+using UnityEngine.UI;
+
+namespace MxValheim.Patch.HUD
+{
+    internal class Clock
+    {
+        public static GameObject m_canvasObject;
+        public static Text m_textComponent;
+
+        // This replaces the missing GetTimeString() method
+        public string GetFormattedTime()
+        {
+            // Get fractional day (0.0 to 1.0)
+            float fraction = EnvMan.instance.GetDayFraction();
+
+            // Convert to hours and minutes
+            float totalHours = fraction * 24f;
+            int hours = Mathf.FloorToInt(totalHours);
+            int minutes = Mathf.FloorToInt((totalHours - hours) * 60f);
+
+            return $"{hours:00}:{minutes:00}";
+        }
+
+        public void CreateOverlay()
+        {
+            // 1. Root Canvas
+            m_canvasObject = new GameObject("ModdedCanvas");
+            Canvas canvas = m_canvasObject.AddComponent<Canvas>();
+            canvas.renderMode = RenderMode.ScreenSpaceOverlay;
+            canvas.sortingOrder = 999;
+
+            // 2. Background Panel
+            GameObject panelObj = new GameObject("TextBackground");
+            panelObj.transform.SetParent(m_canvasObject.transform, false);
+
+            Image panelImage = panelObj.AddComponent<Image>();
+            panelImage.color = new Color(0, 0, 0, 0.5f); // 50% transparent black
+
+            RectTransform panelRect = panelObj.GetComponent<RectTransform>();
+            panelRect.anchorMin = new Vector2(0.5f, 1.0f); // Top Center
+            panelRect.anchorMax = new Vector2(0.5f, 1.0f);
+            panelRect.pivot = new Vector2(0.5f, 1.0f);
+            panelRect.anchoredPosition = new Vector2(0, -5); // 5px gap from top
+            panelRect.sizeDelta = new Vector2(180, 35);      // Width and Height of the bar
+
+            // 3. Text (Attached to Panel)
+            GameObject textObj = new GameObject("ModdedText");
+            textObj.transform.SetParent(panelObj.transform, false);
+
+            m_textComponent = textObj.AddComponent<Text>();
+            // Attempt to find Valheim's specific font, fallback to Arial if not found
+            Font valheimFont = null;
+            foreach (Font f in Resources.FindObjectsOfTypeAll<Font>())
+            {
+                if (f.name == "AveriaSerifLibre-Bold")
+                {
+                    valheimFont = f;
+                    break;
+                }
+            }
+
+            // Corrected fallback for older Unity versions used in Valheim
+            if (valheimFont == null)
+            {
+                valheimFont = Resources.GetBuiltinResource<Font>("Arial.ttf");
+            }
+
+            m_textComponent.font = valheimFont;
+            m_textComponent.fontSize = 18;
+            m_textComponent.color = Color.white;
+            m_textComponent.alignment = TextAnchor.MiddleCenter;
+            m_textComponent.supportRichText = true;
+
+            // Add Shadow so it's visible in snow
+            var shadow = textObj.AddComponent<Shadow>();
+            shadow.effectColor = Color.black;
+            shadow.effectDistance = new Vector2(2, 2);
+
+            // FIX: Correct way to make text fill the parent panel
+            RectTransform textRect = textObj.GetComponent<RectTransform>();
+            textRect.anchorMin = Vector2.zero; // (0, 0)
+            textRect.anchorMax = Vector2.one;  // (1, 1)
+            textRect.pivot = new Vector2(0.5f, 0.5f);
+
+            // Resetting these to zero ensures the text box matches the panel exactly
+            textRect.offsetMin = Vector2.zero;
+            textRect.offsetMax = Vector2.zero;
+        }
+    }
+}

MxValheim/Patch/HUD/Splash.cs

@@ -0,0 +1,75 @@
+using HarmonyLib;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using UnityEngine;
+using UnityEngine.UI;
+
+namespace MxValheim.Patch.HUD
+{
+    internal class Splash
+    {
+        public static GameObject m_canvasObject;
+        public static Text m_textComponent;
+
+        public void CreateOverlay()
+        {
+            // 1. Create a dedicated Canvas for our mod
+            m_canvasObject = new GameObject("ModdedCanvas");
+            Canvas canvas = m_canvasObject.AddComponent<Canvas>();
+            canvas.renderMode = RenderMode.ScreenSpaceOverlay; // Always stays on top
+            canvas.sortingOrder = 100; // Higher than standard HUD
+
+            m_canvasObject.AddComponent<CanvasScaler>();
+            m_canvasObject.AddComponent<GraphicRaycaster>();
+
+            // 2. Create the Text Object
+            GameObject textObj = new GameObject("ModdedText");
+            textObj.transform.SetParent(m_canvasObject.transform, false);
+
+            m_textComponent = textObj.AddComponent<Text>();
+
+            // Attempt to find Valheim's specific font, fallback to Arial if not found
+            Font valheimFont = null;
+            foreach (Font f in Resources.FindObjectsOfTypeAll<Font>())
+            {
+                if (f.name == "AveriaSerifLibre-Bold")
+                {
+                    valheimFont = f;
+                    break;
+                }
+            }
+
+            // Corrected fallback for older Unity versions used in Valheim
+            if (valheimFont == null)
+            {
+                valheimFont = Resources.GetBuiltinResource<Font>("Arial.ttf");
+            }
+
+            m_textComponent.font = valheimFont;
+            m_textComponent.fontSize = 24;
+            m_textComponent.color = Color.yellow; // Bright yellow to stand out
+            m_textComponent.alignment = TextAnchor.UpperRight;
+            m_textComponent.supportRichText = true;
+
+            // This prevents the text from vanishing if the box is too small
+            m_textComponent.horizontalOverflow = HorizontalWrapMode.Overflow;
+            m_textComponent.verticalOverflow = VerticalWrapMode.Overflow;
+
+            // Add Shadow so it's visible in snow
+            var shadow = textObj.AddComponent<Shadow>();
+            shadow.effectColor = Color.black;
+            shadow.effectDistance = new Vector2(2, 2);
+
+            // 3. Position it
+            RectTransform rect = textObj.GetComponent<RectTransform>();
+            rect.anchorMin = new Vector2(1, 1);
+            rect.anchorMax = new Vector2(1, 1);
+            rect.pivot = new Vector2(1, 1);
+            rect.anchoredPosition = new Vector2(-10, -5); // Top Right
+            rect.sizeDelta = new Vector2(300, 100);
+        }
+    }
+}

README.md

@@ -1,9 +1,12 @@
 ![logo](https://mxdev.ovh/wp-content/uploads/2025/09/mxdev-1.png)
 
 ## MxValheim
-Official Mx Valheim Mod.
+Official **MxValheim Server** Mod.  
+**This mod is created to be used Client/Server side. A lot of features are not working in solo mode.**
 
 ## Features
+- Display the day and the formated time in-game.
+- Use your client language with built-in localization.
 - Kill Feed with custom UI showing player kill and death.
 - Tweak individual item(s) weight in "BepInEx\config\mxvalheim.custom_weights.json".
 - Ore drop multiplier. (Value available in the generated config.)
@@ -13,8 +16,8 @@ Official Mx Valheim Mod.
 - Auto close doors after a specified amount of time. (Enable/Disable and configure desired time in the generated config.)
 
 ## How-To Install
-1. Download the latest dll.
-2. Copy it to your (Client/Server) "BepInEx­\plugins".
+1. Download the latest zip.
+2. Copy the zip content to your (Client/Server) "BepInEx­\plugins\MxValheim\".
 3. Run your (Client/Server) at least one time.
 4. Tweaks the config in "BepInEx­\config\ovh.mxdev.mxvalheim.cfg" to your liking.
 5. Enjoy!