(1.6.4) Managed RandomEvent Message

MxValheim/EventSystem/Experience.cs

@@ -0,0 +1,69 @@
+using MxValheim.Patch.HUD;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using UnityEngine;
+
+namespace MxValheim.EventSystem
+{
+    internal class Experience
+    {        
+        public static int GetRequiredExpByLevel(int level)
+        {
+            return (level * 100);
+        }
+
+        public static float CalculateExpMultiplier(int level, Heightmap.Biome biome)
+        {
+            Dictionary<int, float> biomeBase = new Dictionary<int, float>()
+            {
+                { 1, 1.0f },
+                { 2, 1.5f },
+                { 8, 2.0f },
+                { 4, 2.5f },
+                { 16, 3.0f },
+                { 256, 3.5f },
+                { 32, 4.0f },
+            };
+
+            float rewardExpMulti = biomeBase[((int)biome)];
+
+            return rewardExpMulti;
+        }
+
+        public static void AddExperience(int amount)
+        {
+            ZRoutedRpc.instance.InvokeRoutedRPC(0, "RPC_RequestProfile", "Event");
+            int level = Profiles.serverLevel;
+            int exp = Profiles.serverExperience;
+            exp += amount;
+            ZRoutedRpc.instance.InvokeRoutedRPC(0, "RPC_ServerSetExperience", exp);
+            exp = Profiles.serverExperience;
+            int maxexp = GetRequiredExpByLevel(level);
+            UpdateProgressBar();
+            if (exp >= maxexp)
+            {
+                exp -= maxexp;
+                level++;
+                ZRoutedRpc.instance.InvokeRoutedRPC(0, "RPC_ServerSetLevel", level);
+                ZRoutedRpc.instance.InvokeRoutedRPC(0, "RPC_ServerSetExperience", exp);
+                UpdateProgressBar();
+            }
+        }
+
+        public static void UpdateProgressBar()
+        {
+            ZRoutedRpc.instance.InvokeRoutedRPC(0, "RPC_RequestProfile", "Event");
+            float expPercentage = ((float)Profiles.serverExperience / GetRequiredExpByLevel(Profiles.serverLevel));
+
+            if (Clock.m_barFill != null)
+            {
+                Clock.m_barFill.anchorMax = new Vector2(expPercentage, 1);
+                Clock.m_barFill.offsetMin = Vector2.zero;
+                Clock.m_barFill.offsetMax = Vector2.zero;
+            }
+        }
+    }
+}

MxValheim/EventSystem/Patch.cs

@@ -0,0 +1,183 @@
+using HarmonyLib;
+using Splatform;
+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
+    {
+        // --- 3. HARMONY PATCHES ---
+
+        [HarmonyPatch(typeof(Player), nameof(Player.Awake))]
+        public static class PlayerAwakePatch
+        {
+            static void Postfix(Player __instance)
+            {
+
+            }
+        }
+
+        [HarmonyPatch(typeof(RandEventSystem), nameof(RandEventSystem.StartRandomEvent))]
+        public static class DebugRaidFrequency
+        {
+            static void Prefix(RandEventSystem __instance)
+            {
+                if (ZRoutedRpc.instance != null)
+                {
+                    ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.Everybody, "RPC_MxKillMsg", "", "", "", "", -1);
+                }
+            }
+        }
+
+        [HarmonyPatch(typeof(RandEventSystem), nameof(RandEventSystem.FixedUpdate))]
+        public static class TimerFreezePatch
+        {
+            static void Prefix(RandEventSystem __instance)
+            {
+                //__instance.m_eventIntervalMin = 10f;
+                //__instance.m_eventChance = 100f;
+            }
+        }
+
+        [HarmonyPatch(typeof(RandEventSystem), nameof(RandEventSystem.RPC_SetEvent))]
+        public static class RandEventEndPatch
+        {
+            private static readonly AccessTools.FieldRef<RandEventSystem, RandomEvent> ActiveEventField = AccessTools.FieldRefAccess<RandEventSystem, RandomEvent>("m_activeEvent");
+            static void Prefix(RandEventSystem __instance, string eventName)
+            {
+                RandomEvent currentRaid = ActiveEventField(__instance);
+                if (string.IsNullOrEmpty(eventName) && currentRaid != null)
+                {
+                    Vector3 playerPos = Player.m_localPlayer.transform.position;
+                    float distance = Vector3.Distance(playerPos, currentRaid.m_pos);
+
+                    if (distance <= 96f)
+                    {
+                        Heightmap.Biome currentBiome = EnvMan.instance.GetCurrentBiome();
+                        Reward.GiveItemStatic("Coins", Reward.CalculateRewardCoin(Profiles.serverLevel, currentBiome));
+                        System.Random rand = new System.Random();
+                        Reward.GiveItemStatic("Feathers", rand.Next(5, 20));
+                        if (rand.Next(100) < 50)
+                        {
+                            Reward.GiveItemRandom(Reward.GetRewardPrefab(Profiles.serverLevel, "food"), 1);
+                        }
+                        if (rand.Next(100) < 25)
+                        {
+                            Reward.GiveItemRandom(Reward.GetRewardPrefab(Profiles.serverLevel, "heal"), 1);
+                        }
+                        if (rand.Next(100) < 10)
+                        {
+                            Reward.GiveItemRandom(Reward.GetRewardPrefab(Profiles.serverLevel, "metal"), rand.Next(5, 20));
+                        }
+                    }
+                }
+            }
+        }
+
+        [HarmonyPatch(typeof(Hud), nameof(Hud.Update))]
+        public static class Hud_Update_Patch
+        {
+            static void Postfix(Hud __instance)
+            {
+                if (Player.m_localPlayer == null || !Hud.instance) return;
+
+                if (RandEventSystem.instance != null)
+                {
+                    RandomEvent activeEvent = RandEventSystem.instance.GetActiveEvent();
+
+                    if (activeEvent != null)
+                    {
+                        eventName = Localization.instance.Localize(activeEvent.GetHudText());
+                    }
+                }
+
+                // Hiding the yellow persistent text at the top center
+                if (RandEventSystem.instance != null && RandEventSystem.instance.GetActiveEvent() != null)
+                {
+                    // We set the text to an empty string so it doesn't render
+                    __instance.m_eventName.text = "";
+                }
+            }
+        }
+
+        [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;
+
+                    Vector3 playerPos = Player.m_localPlayer.transform.position;
+                    float distance = Vector3.Distance(playerPos, activeEvent.m_pos);
+
+                    MonsterAI mai = __instance.GetComponent<MonsterAI>();
+                    bool isEventCreature = false;
+                    if (mai != null)
+                    {
+                        isEventCreature = Traverse.Create(mai).Field<bool>("m_eventCreature").Value;
+                    }
+                    Debug.Log($"EventSystem: Event Enemy {nview.GetZDO().GetBool(ZDOVars.s_eventCreature, isEventCreature)}");
+
+                    if (distance <= 96f)
+                    {
+                        int level = __instance.GetLevel();
+                        int exp =
+                            (level == 1) ? 2 :
+                            (level == 2) ? 4 :
+                            (level == 3) ? 6 :
+                                           6;
+                        ZRoutedRpc.instance.InvokeRoutedRPC(0, "RPC_RequestProfile", "Event");
+                        Heightmap.Biome currentBiome = EnvMan.instance.GetCurrentBiome();
+                        int expFinal = (int)(exp * Experience.CalculateExpMultiplier(Profiles.serverLevel, currentBiome));
+                        Experience.AddExperience(expFinal);
+                    }
+                }
+            }
+        }
+
+        [HarmonyPatch(typeof(Character), nameof(Character.ApplyDamage))]
+        public static class DeathNotifierEvent
+        {
+            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;
+
+                    MonsterAI mai = __instance.GetComponent<MonsterAI>();
+                    bool isEventCreature = false;
+                    if (mai != null)
+                    {
+                        isEventCreature = Traverse.Create(mai).Field<bool>("m_eventCreature").Value;
+                    }
+                    Debug.Log($"EventSystem: Event Enemy {nview.GetZDO().GetBool(ZDOVars.s_eventCreature, isEventCreature)}");
+                }
+            }
+        }
+    }
+}

MxValheim/EventSystem/Profiles.cs

@@ -0,0 +1,115 @@
+using Newtonsoft.Json;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace MxValheim.EventSystem
+{
+    internal class Profiles
+    {
+        public class ProfileRoot
+        {
+            public int level { get; set; }
+            public int experience { get; set; }
+        }
+
+        public static bool userExists = false;
+        public static int serverLevel = 1;
+        public static int serverExperience = 0;
+
+
+        public static void ServerUserExists(string playerid)
+        {
+            // Check to ensure this is actually the server running this
+            ZNet zn = new ZNet();
+            if (!zn.IsDedicated()) return;
+
+            if (File.Exists(MxValheimMod.internalDataEventSystem)) userExists = true;
+        }
+
+        public static void ServerReceiveCreateUser(long sender, string playerid, string playerName)
+        {
+            // Check to ensure this is actually the server running this
+            ZNet zn = new ZNet();
+            if (!zn.IsDedicated()) return;
+
+            ProfileRoot pr = new ProfileRoot
+            {
+                level = 1,
+                experience = 0
+            };
+
+            var raw = JsonConvert.SerializeObject(pr, Formatting.Indented);
+            File.WriteAllText(MxValheimMod.internalDataEventSystem, raw);
+        }
+
+        public static void ServerHandleProfileRequest(long sender, string required)
+        {
+            // Check to ensure this is actually the server running this
+            ZNet zn = new ZNet();
+            if (!zn.IsDedicated()) return;
+
+            if (File.Exists(MxValheimMod.internalDataEventSystem))
+            {
+                string rawJson = File.ReadAllText(MxValheimMod.internalDataEventSystem);
+                ZRoutedRpc.instance.InvokeRoutedRPC(sender, "RPC_ClientReceiveProfile", rawJson);
+            }
+            else
+            {
+                ProfileRoot pr = new ProfileRoot
+                {
+                    level = 1,
+                    experience = 0
+                };
+
+                var raw = JsonConvert.SerializeObject(pr, Formatting.Indented);
+                File.WriteAllText(MxValheimMod.internalDataEventSystem, raw);
+            }
+        }
+
+        public static void LoadProfile(long sender, string json)
+        {
+            ProfileRoot loadedProfile = JsonConvert.DeserializeObject<ProfileRoot>(json);
+
+            serverLevel = loadedProfile.level;
+            serverExperience = loadedProfile.experience;
+        }
+
+        public static void ServerSetExperience(long sender, int exp)
+        {
+            // Check to ensure this is actually the server running this
+            ZNet zn = new ZNet();
+            if (!zn.IsDedicated()) return;
+
+            ProfileRoot pro = JsonConvert.DeserializeObject<ProfileRoot>(File.ReadAllText(MxValheimMod.internalDataEventSystem));
+            ProfileRoot pr = new ProfileRoot
+            {
+                level = pro.level,
+                experience = exp
+            };
+            var raw = JsonConvert.SerializeObject(pr, Formatting.Indented);
+            File.WriteAllText(MxValheimMod.internalDataEventSystem, raw);
+            ZRoutedRpc.instance.InvokeRoutedRPC(0, "RPC_RequestProfile", "Event");
+        }
+
+        public static void ServerSetLevel(long sender, int level)
+        {
+            // Check to ensure this is actually the server running this
+            ZNet zn = new ZNet();
+            if (!zn.IsDedicated()) return;
+
+            ProfileRoot pro = JsonConvert.DeserializeObject<ProfileRoot>(File.ReadAllText(MxValheimMod.internalDataEventSystem));
+            ProfileRoot pr = new ProfileRoot
+            {
+                level = level,
+                experience = pro.experience
+            };
+            var raw = JsonConvert.SerializeObject(pr, Formatting.Indented);
+            File.WriteAllText(MxValheimMod.internalDataEventSystem, raw);
+            ZRoutedRpc.instance.InvokeRoutedRPC(0, "RPC_RequestProfile", "Event");
+        }
+    }
+}

MxValheim/EventSystem/Reward.cs

@@ -0,0 +1,87 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using UnityEngine;
+
+namespace MxValheim.EventSystem
+{
+    internal class Reward
+    {
+        public static int CalculateRewardCoin(int level, Heightmap.Biome biome)
+        {
+            Dictionary<int, int> biomeBase = new Dictionary<int, int>()
+            {
+                { 1, 10 },
+                { 2, 20 },
+                { 8, 30 },
+                { 4, 40 },
+                { 16, 50 },
+                { 256, 60 },
+                { 32, 70 },
+            };
+
+            int rewardCoin = biomeBase[((int)biome)] * level;
+
+            return rewardCoin;
+        }      
+
+        public static string GetRewardPrefab(int level, string type)
+        {           
+            string[] foodList = { "OnionSoup", "CarrotSoup", "DeerStew", "Salad", "SerpentStew", "WolfMeatSkewer" };
+            string[] healList = { "MeadHealthMinor", "MeadHealthMedium", "MeadHealthMajor", "MeadHealthLingering" };
+            string[] metalList = { "CopperOre", "TinOre", "IronScrap", "SilverOre", "BlackMetalScrap", "FlametalOreNew" };
+
+            System.Random rng = new System.Random();
+            int foodTier = rng.Next(1, foodList.Length);
+            int healTier = rng.Next(1, healList.Length);
+            int metalTier = rng.Next(1, metalList.Length);
+
+            if (type == "food") return foodList[foodTier];
+            if (type == "heal") return healList[healTier];
+            if (type == "metal") return metalList[metalTier];
+            return "Wood";
+        }
+
+        public static void GiveItemRandom(string itemName, int qty)
+        {
+            System.Random rng = new System.Random();
+
+            Player player = Player.m_localPlayer;
+            if (player == null) return;
+
+            GameObject prefab = ObjectDB.instance.GetItemPrefab(itemName);
+            if (prefab != null)
+            {
+                player.GetInventory().AddItem(itemName, qty, 1, 0, 0, "");
+
+                player.Message(MessageHud.MessageType.TopLeft, $"Received {qty}x {itemName}");
+            }
+            else
+            {
+                Debug.LogWarning($"Item {itemName} not found in ObjectDB!");
+            }
+        }
+
+        public static void GiveItemStatic(string itemName, int qty)
+        {
+            Player player = Player.m_localPlayer;
+            if (player == null) return;
+
+            GameObject prefab = ObjectDB.instance.GetItemPrefab(itemName);
+            if (prefab != null)
+            {
+                player.GetInventory().AddItem(itemName, qty, 1, 0, 0, "");
+
+                player.Message(MessageHud.MessageType.TopLeft, $"Received {qty}x {itemName}");
+            }
+            else
+            {
+                Debug.LogWarning($"Item {itemName} not found in ObjectDB!");
+            }
+        }
+
+
+    }
+}

MxValheim/KillFeed/Patch.cs

@@ -2,6 +2,7 @@
 using HarmonyLib;
 using System;
 using System.Collections.Generic;
+using System.IO;
 using System.Linq;
 using System.Reflection.Emit;
 using System.Threading;
@@ -15,6 +16,38 @@ namespace MxValheim.KillFeed
 {
     public class KillFeed_Patch
     {
+        public static Sprite LoadCustomSprite(string fileName)
+        {
+            string path = Path.Combine(BepInEx.Paths.PluginPath, "MxValheim", "Icons", fileName);
+            if (!File.Exists(path)) return null;
+
+            try
+            {
+                byte[] fileData = File.ReadAllBytes(path);
+                Texture2D tex = new Texture2D(2, 2);
+
+                // We use Reflection to find the LoadImage method inside the game's assemblies
+                var imageConversion = System.Reflection.Assembly.Load("UnityEngine.ImageConversionModule")
+                    .GetType("UnityEngine.ImageConversion");
+
+                var loadImageMethod = imageConversion.GetMethod("LoadImage", new[] { typeof(Texture2D), typeof(byte[]) });
+
+                // Invoke the method: LoadImage(tex, fileData)
+                bool success = (bool)loadImageMethod.Invoke(null, new object[] { tex, fileData });
+
+                if (success)
+                {
+                    return Sprite.Create(tex, new Rect(0, 0, tex.width, tex.height), new Vector2(0.5f, 0.5f));
+                }
+            }
+            catch (Exception e)
+            {
+                UnityEngine.Debug.LogError($"[MxKillFeed] Reflection Load failed: {e.Message}");
+            }
+
+            return null;
+        }
+
         public static void SendKillToAll(string attacker, string victim, string victimInternalName, string weaponPrefab, int encodedType)
         {
             if (ZRoutedRpc.instance != null)
@@ -29,11 +62,32 @@ namespace MxValheim.KillFeed
             if (zn.IsDedicated()) return;
             if (attacker == "The World") return;
 
-            float distance = (encodedType / 1000) / 10.0f;
+            // --- DECODING START ---
-            int remainder = encodedType % 1000;
+            int biomeIndex = encodedType / 100000;
-            bool isBoss = (remainder >= 100);
+            int mainRemainder = encodedType % 100000;
-            int level = (remainder % 100) / 10;
+
-            int type = remainder % 10;
+            float distance = (mainRemainder / 1000) / 10.0f;
+            int subRemainder = mainRemainder % 1000;
+
+            bool isBoss = (subRemainder >= 100);
+            int level = (subRemainder % 100) / 10;
+            int type = subRemainder % 10;
+            // --- DECODING END ---
+
+            // Inside OnReceiveKillMsg...
+            Sprite biomeSprite = null;
+            switch (biomeIndex)
+            {
+                case 1: biomeSprite = LoadCustomSprite("biome_meadows.png"); break;
+                case 2: biomeSprite = LoadCustomSprite("biome_blackforest.png"); break;
+                case 3: biomeSprite = LoadCustomSprite("biome_swamp.png"); break;
+                case 4: biomeSprite = LoadCustomSprite("biome_mountain.png"); break;
+                case 5: biomeSprite = LoadCustomSprite("biome_plains.png"); break;
+                case 6: biomeSprite = LoadCustomSprite("biome_mistland.png"); break;
+                case 7: biomeSprite = LoadCustomSprite("biome_deepnorth.png"); break;
+                case 8: biomeSprite = LoadCustomSprite("biome_ashlands.png"); break;
+                case 9: biomeSprite = LoadCustomSprite("biome_ocean.png"); break;
+            }
 
             Sprite victimIcon = GetCreatureIcon(victimInternalName);
 
@@ -48,6 +102,8 @@ namespace MxValheim.KillFeed
             // Message Format Variables
             string type1Separator = Localization.instance.Localize("$killfeed_format_type1");
             string type2Separator = Localization.instance.Localize("$killfeed_format_type2");
+            string type3Separator = Localization.instance.Localize("$killfeed_format_type3");
+            string eventFormat = $"<color=#00ff06>{victim}</color>";
             string finalMsg = "";
             string attackerFormat = "";
             string victimFormat = "";
@@ -91,6 +147,12 @@ namespace MxValheim.KillFeed
                 (type == 2) ? $"{attackerFormat}{type2Separator}{victimFormat}{distanceFormat}" : // Player Killed Something
                               $"{attackerFormat}{type2Separator}{victimFormat}{distanceFormat}"; // Failsafe
 
+            if (encodedType == -1)
+            {
+                attacker = Player.m_localPlayer?.GetHoverName();
+                finalMsg = $"<color=#00ff06>{attacker.ToUpper()}</color><color=#ffd000>{type3Separator}</color>";
+            }
+
             Sprite weaponIcon = null;
 
             if (ObjectDB.instance != null && !string.IsNullOrEmpty(weaponPrefab))
@@ -124,17 +186,22 @@ namespace MxValheim.KillFeed
             {
                 borderColor = new Color(0.141f, 0.141f, 0.153f);
             }
+            if (encodedType == -1)
+            {
+                borderColor = new Color(0.0196f, 0.250f, 0.00750f);
+            }
 
                 lock (_msgQueue)
             {
                 _msgQueue.Enqueue(finalMsg);
+                _biomeIconQueue.Enqueue(biomeSprite);
                 _borderColQueue.Enqueue(borderColor);
                 _iconQueue.Enqueue(weaponIcon);
                 _victimIconQueue.Enqueue(victimIcon);
             }
         }
 
-        public void ShowNextMessage(string msg, Sprite weaponIcon, Sprite victimIcon, Color borderColor)
+        public void ShowNextMessage(string msg, Sprite biome, Sprite weaponIcon, Sprite victimIcon, Color borderColor)
         {
             if (_hudRoot == null) CreateCustomHud();
 
@@ -154,6 +221,9 @@ namespace MxValheim.KillFeed
             _killText.text = msg;
             _border.effectColor = borderColor;
             _border.enabled = true;
+            /////////////////////
+            _biomeIconSlot.sprite = biome;
+            _biomeIconSlot.gameObject.SetActive(biome != null);
             // Weapon icon (Left)
             _weaponIconSlot.sprite = weaponIcon;
             _weaponIconSlot.enabled = (weaponIcon != null);
@@ -240,6 +310,9 @@ namespace MxValheim.KillFeed
                     // This check should now pass because ApplyDamage happens before the object is invalidated
                     if (nview == null || !nview.IsValid() || !nview.IsOwner()) return;
 
+                    Heightmap.Biome currentBiome;
+                    int biomeIndex = 0;
+
                     float distance = 0f;
                     Character attacker = hit.GetAttacker();
                     if (attacker != null)
@@ -272,14 +345,45 @@ namespace MxValheim.KillFeed
                     string victimName = __instance.GetHoverName();
 
                     int type = 0;
-                    if (__instance.IsPlayer()) type = 1;
+                    if (__instance.IsPlayer())
-                    else if (attackerName == Player.m_localPlayer?.GetHoverName()) type = 2;
+                    { 
+                        type = 1;
+                        currentBiome = Player.m_localPlayer.GetCurrentBiome();
+                        Debug.Log($"KillFeed: {currentBiome}");
+                        biomeIndex = 0;
+                        if (currentBiome == Heightmap.Biome.Meadows) biomeIndex = 1;
+                        else if (currentBiome == Heightmap.Biome.BlackForest) biomeIndex = 2;
+                        else if (currentBiome == Heightmap.Biome.Swamp) biomeIndex = 3;
+                        else if (currentBiome == Heightmap.Biome.Mountain) biomeIndex = 4;
+                        else if (currentBiome == Heightmap.Biome.Plains) biomeIndex = 5;
+                        else if (currentBiome == Heightmap.Biome.Mistlands) biomeIndex = 6;
+                        else if (currentBiome == Heightmap.Biome.DeepNorth) biomeIndex = 7;
+                        else if (currentBiome == Heightmap.Biome.AshLands) biomeIndex = 8;
+                        else if (currentBiome == Heightmap.Biome.Ocean) biomeIndex = 9;
+                    }
+                    
+                    if (attackerName == Player.m_localPlayer?.GetHoverName())
+                    {
+                        type = 2;
+                        currentBiome = Player.m_localPlayer.GetCurrentBiome();
+                        Debug.Log($"KillFeed: {currentBiome}");
+                        biomeIndex = 0;
+                        if (currentBiome == Heightmap.Biome.Meadows) biomeIndex = 1;
+                        else if (currentBiome == Heightmap.Biome.BlackForest) biomeIndex = 2;
+                        else if (currentBiome == Heightmap.Biome.Swamp) biomeIndex = 3;
+                        else if (currentBiome == Heightmap.Biome.Mountain) biomeIndex = 4;
+                        else if (currentBiome == Heightmap.Biome.Plains) biomeIndex = 5;
+                        else if (currentBiome == Heightmap.Biome.Mistlands) biomeIndex = 6;
+                        else if (currentBiome == Heightmap.Biome.DeepNorth) biomeIndex = 7;
+                        else if (currentBiome == Heightmap.Biome.AshLands) biomeIndex = 8;
+                        else if (currentBiome == Heightmap.Biome.Ocean) biomeIndex = 9;
+                    }
 
                     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);
+                    int encodedType = type + (level * 10) + (isBoss ? 100 : 0) + (distInt * 1000) + (biomeIndex * 100000);
 
                     if (ZRoutedRpc.instance != null)
                     {
@@ -349,6 +453,14 @@ namespace MxValheim.KillFeed
             pRect.sizeDelta = new Vector2(400, 35); // Shorter and narrower
             pRect.localScale = Vector3.one;
 
+            GameObject biomeObj = new GameObject("BiomeIcon", typeof(RectTransform), typeof(Image));
+            biomeObj.transform.SetParent(panel.transform, false); // Use 'false' for worldPositionStays
+            _biomeIconSlot = biomeObj.GetComponent<Image>();
+            _biomeIconSlot.preserveAspect = true;
+            LayoutElement biomeLayout = biomeObj.AddComponent<LayoutElement>();
+            biomeLayout.preferredWidth = 32;
+            biomeLayout.preferredHeight = 32;
+
             // 2. Compact Icon
             GameObject iconObj = new GameObject("Icon", typeof(RectTransform), typeof(Image));
             iconObj.transform.SetParent(panel.transform, false);

MxValheim/MxValheim.cs

@@ -1,10 +1,12 @@
 using BepInEx;
 using BepInEx.Configuration;
 using HarmonyLib;
+using MxValheim.EventSystem;
 using MxValheim.KillFeed;
 using MxValheim.Patch;
 using MxValheim.Patch.HUD;
 using Newtonsoft.Json;
+using Splatform;
 using System;
 using System.Collections.Generic;
 using System.IO;
@@ -15,6 +17,7 @@ using System.Xml;
 using TMPro;
 using UnityEngine;
 using UnityEngine.UI;
+using static MxValheim.Patch.Doors_Patch;
 
 [BepInPlugin(ModGUID, ModName, ModVersion)]
 public class MxValheimMod : BaseUnityPlugin
@@ -25,7 +28,7 @@ public class MxValheimMod : BaseUnityPlugin
 
     private const string ModGUID = "ovh.mxdev.mxvalheim";
     private const string ModName = "MxValheim";
-    public const string ModVersion = "1.5.7";
+    private const string ModVersion = "1.6.4";
 
     public static ConfigEntry<bool> Config_Locked;
     public static ConfigEntry<int> Config_OreMultiplier;
@@ -38,10 +41,15 @@ public class MxValheimMod : BaseUnityPlugin
 
     public static string modPath = Path.Combine(Paths.PluginPath, "MxValheim");
     public static string internalConfigsPath = Path.Combine(modPath, "Configs");
+    public static string internalDataPath = Path.Combine(modPath, "Data");
+    public static string internalDataEventSystem = Path.Combine(internalDataPath, "EventSystem.json");
     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>();
 
+    public static bool initExpBar = true;
+
     // Data structures
     public class KillData
     {
@@ -56,6 +64,7 @@ public class MxValheimMod : BaseUnityPlugin
     public static Image _weaponIconSlot;
     public static Image _victimIconSlot;
     public static Image _panelImage;
+    public static  Image _biomeIconSlot;
     public static Outline _border;
     public static Color borderColor = Color.white;
     public static CanvasGroup _canvasGroup;
@@ -66,6 +75,7 @@ public class MxValheimMod : BaseUnityPlugin
     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 Queue<Sprite> _biomeIconQueue = new Queue<Sprite>();
     public static readonly Dictionary<Character, KillData> _activeTrackers = new Dictionary<Character, KillData>();
 
     public static readonly Queue<ZNetView> _doorQueueNview = new Queue<ZNetView>();
@@ -73,6 +83,8 @@ public class MxValheimMod : BaseUnityPlugin
     public static readonly Queue<string> _doorQueueName = new Queue<string>();
     public static float _doorTimer;
 
+    public static string eventName;
+
     void Awake()
     {
         Instance = this;
@@ -87,6 +99,7 @@ public class MxValheimMod : BaseUnityPlugin
 
         LoadLocalization();
         LoadJsonConfig();
+        LoadDoorConfig();
 
         _doorTimer = MxValheimMod.Config_autoDoorClose.Value;
 
@@ -112,17 +125,7 @@ public class MxValheimMod : BaseUnityPlugin
             string text = __instance.m_input.text;
             if (text.ToLower() == "listicons")
             {
-                var spriteAsset = Resources.FindObjectsOfTypeAll<TMP_SpriteAsset>().FirstOrDefault(x => x.name == "icons"); ;
 
-                if (spriteAsset != null)
-                {
-                    Debug.Log($"--- Listing all sprites in {spriteAsset.name} ---");
-                    for (int i = 0; i < spriteAsset.spriteCharacterTable.Count; i++)
-                    {
-                        var sprite = spriteAsset.spriteCharacterTable[i];
-                        Debug.Log($"Index: {i} | Name: {sprite.name}");
-                    }
-                }
             }
         }
     }
@@ -138,13 +141,24 @@ public class MxValheimMod : BaseUnityPlugin
                 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.");
+                ZRoutedRpc.instance.Register<string, string>("RPC_ServerCreateUser", Profiles.ServerReceiveCreateUser);
+                ZRoutedRpc.instance.Register<string>("RPC_RequestProfile", Profiles.ServerHandleProfileRequest);
+                ZRoutedRpc.instance.Register<string>("RPC_ClientReceiveProfile", Profiles.LoadProfile);
+                ZRoutedRpc.instance.Register<int>("RPC_ServerSetExperience", Profiles.ServerSetExperience);
+                ZRoutedRpc.instance.Register<int>("RPC_ServerSetLevel", Profiles.ServerSetLevel);
             }      
         }
     }
 
     void Update()
     {
+        // Only run if we are actually in the game world
+        if (Player.m_localPlayer != null)
+        {
+            string pid = GetUserPlayerID(Player.m_localPlayer).ToString();
+            Experience.UpdateProgressBar();
+        }
+
         // Only run if we are actually in the game world
         if (Player.m_localPlayer != null)
         {
@@ -163,6 +177,12 @@ public class MxValheimMod : BaseUnityPlugin
             {
                 Clock clk = new Clock();
                 clk.CreateOverlay();
+                if (initExpBar)
+                {
+                    string pid = GetUserPlayerID(Player.m_localPlayer).ToString();
+                    Experience.UpdateProgressBar();
+                    initExpBar = false;
+                }
             }
 
             if (Clock.m_textComponent != null)
@@ -170,7 +190,15 @@ public class MxValheimMod : BaseUnityPlugin
                 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>";
+                string pid = GetUserPlayerID(Player.m_localPlayer).ToString();
+                RandomEvent activeEvent = RandEventSystem.instance.GetActiveEvent();
+                if ((activeEvent == null))
+                {
+                    Clock.m_textComponent.text = $"<color=#32a852>{Localization.instance.Localize("$clock_string_rank")} {Profiles.serverLevel}</color> <color=#677074>|</color> <color=#32a852>{Localization.instance.Localize("$clock_string_day")} {day}</color> <color=#677074>|</color> <color=#d1954a>{timeString}</color>";
+                } else
+                {
+                    Clock.m_textComponent.text = $"<color=#ffd000>{eventName}</color> <color=#677074>|</color> <color=#32a852>{Localization.instance.Localize("$clock_string_rank")} {Profiles.serverLevel}</color> <color=#677074>|</color> <color=#32a852>{Localization.instance.Localize("$clock_string_day")} {day}</color> <color=#677074>|</color> <color=#d1954a>{timeString}</color>";
+                }            
             }
         }
 
@@ -202,7 +230,7 @@ public class MxValheimMod : BaseUnityPlugin
         if (_msgQueue.Count > 0 && _displayTimer <= 0)
         {
             borderColor = new Color(0.141f, 0.141f, 0.153f);
-            kfp.ShowNextMessage(_msgQueue.Dequeue(), _iconQueue.Dequeue(), _victimIconQueue.Dequeue(), _borderColQueue.Dequeue());
+            kfp.ShowNextMessage(_msgQueue.Dequeue(), _biomeIconQueue.Dequeue(), _iconQueue.Dequeue(), _victimIconQueue.Dequeue(), _borderColQueue.Dequeue());
         }
 
         if (_displayTimer > 0)
@@ -233,7 +261,11 @@ public class MxValheimMod : BaseUnityPlugin
         }
         // KillFeed Logic
         /////////////////
+    }
 
+    public static long GetUserPlayerID(Player player)
+    {
+        return player.GetPlayerID();
     }
 
     public static void LoadLocalization()
@@ -305,6 +337,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

@@ -13,6 +13,7 @@
     <LangVersion>12.0</LangVersion>
     <FileAlignment>512</FileAlignment>
     <Deterministic>true</Deterministic>
+    <TargetFrameworkProfile />
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
     <DebugSymbols>true</DebugSymbols>
@@ -35,16 +36,25 @@
     <Reference Include="0Harmony">
       <HintPath>E:\SteamLibrary\steamapps\common\Valheim\BepInEx\core\0Harmony.dll</HintPath>
     </Reference>
+    <Reference Include="assembly_googleanalytics">
+      <HintPath>E:\SteamLibrary\steamapps\common\Valheim\Valheim_Data\Managed\assembly_googleanalytics.dll</HintPath>
+    </Reference>
     <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_utils, Version=0.0.0.0, Culture=neutral, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>E:\SteamLibrary\steamapps\common\Valheim\Valheim_Data\Managed\assembly_utils.dll</HintPath>
+    </Reference>
     <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>
@@ -59,7 +69,9 @@
     <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>
@@ -74,7 +86,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>
@@ -83,8 +97,20 @@
       <SpecificVersion>False</SpecificVersion>
       <HintPath>E:\SteamLibrary\steamapps\common\Valheim\Valheim_Data\Managed\UnityEngine.UIModule.dll</HintPath>
     </Reference>
+    <Reference Include="UnityEngine.UnityWebRequestModule, Version=0.0.0.0, Culture=neutral, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>E:\SteamLibrary\steamapps\common\Valheim\Valheim_Data\Managed\UnityEngine.UnityWebRequestModule.dll</HintPath>
+    </Reference>
+    <Reference Include="UnityEngine.UnityWebRequestTextureModule, Version=0.0.0.0, Culture=neutral, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>E:\SteamLibrary\steamapps\common\Valheim\Valheim_Data\Managed\UnityEngine.UnityWebRequestTextureModule.dll</HintPath>
+    </Reference>
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="EventSystem\Experience.cs" />
+    <Compile Include="EventSystem\Patch.cs" />
+    <Compile Include="EventSystem\Profiles.cs" />
+    <Compile Include="EventSystem\Reward.cs" />
     <Compile Include="KillFeed\NPCIcon.cs" />
     <Compile Include="KillFeed\Patch.cs" />
     <Compile Include="MxValheim.cs" />
@@ -99,7 +125,9 @@
     <Compile Include="Properties\AssemblyInfo.cs" />
   </ItemGroup>
   <ItemGroup>
+    <Analyzer Include="E:\SteamLibrary\steamapps\common\Valheim\Valheim_Data\Managed\assembly_googleanalytics.dll" />
     <Analyzer Include="E:\SteamLibrary\steamapps\common\Valheim\Valheim_Data\Managed\assembly_guiutils.dll" />
+    <Analyzer Include="E:\SteamLibrary\steamapps\common\Valheim\Valheim_Data\Managed\assembly_utils.dll" />
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <PropertyGroup>

MxValheim/Patch/Doors.cs

@@ -29,8 +29,8 @@ namespace MxValheim.Patch
                     int prefabHash = nview.GetZDO().GetPrefab();
                     string prefabName = ZNetScene.instance.GetPrefab(prefabHash).name;
 
-                    DoorRoot iL = JsonConvert.DeserializeObject<DoorRoot>(File.ReadAllText(MxValheimMod.AutoDoorConfigPath));
+                    if (MxValheimMod.CachedConfig?.ignoreList != null)
-                    if (iL.ignoreList.Contains(prefabName)) return;
+                        if (MxValheimMod.CachedConfig.ignoreList.Contains(prefabName)) return;
 
                     if (hold || alt || ___m_nview == null || !___m_nview.IsValid()) return;
 

MxValheim/Patch/HUD/Clock.cs

@@ -1,4 +1,5 @@
-using System;
+using HarmonyLib;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
@@ -12,6 +13,7 @@ namespace MxValheim.Patch.HUD
     {
         public static GameObject m_canvasObject;
         public static Text m_textComponent;
+        public static RectTransform m_barFill;
 
         // This replaces the missing GetTimeString() method
         public string GetFormattedTime()
@@ -27,70 +29,89 @@ namespace MxValheim.Patch.HUD
             return $"{hours:00}:{minutes:00}";
         }
 
+        [HarmonyPatch(typeof(MessageHud), nameof(MessageHud.ShowMessage))]
+        public static class HideEventMessage_Patch
+        {
+            // We use a Prefix to check the message before it is displayed
+            static bool Prefix(MessageHud.MessageType type, string text)
+            {
+                // Check if a raid is active
+                if (RandEventSystem.instance != null)
+                {
+                    RandomEvent activeEvent = RandEventSystem.instance.GetActiveEvent();
+                    if (activeEvent != null)
+                    {                      
+                        // If the message text matches the start or end message of the raid, block it
+                        if (text == activeEvent.GetHudText())
+                        {
+                            Debug.Log("Reached msg logic!!!");
+                            // Returning false tells Harmony to skip the original method (don't show text)
+                            return false;
+                        }
+                    }
+                }
+                return true; // Show all other messages (health, items, etc.) normally
+            }
+        }
+
         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
+            // --- CLOCK PANEL ---
             GameObject panelObj = new GameObject("TextBackground");
             panelObj.transform.SetParent(m_canvasObject.transform, false);
+            panelObj.AddComponent<Image>().color = new Color(0, 0, 0, 0.5f);
 
-            Image panelImage = panelObj.AddComponent<Image>();
+            ContentSizeFitter fitter = panelObj.AddComponent<ContentSizeFitter>();
-            panelImage.color = new Color(0, 0, 0, 0.5f); // 50% transparent black
+            fitter.horizontalFit = ContentSizeFitter.FitMode.PreferredSize;
+            fitter.verticalFit = ContentSizeFitter.FitMode.PreferredSize;
+
+            HorizontalLayoutGroup layout = panelObj.AddComponent<HorizontalLayoutGroup>();
+            layout.padding = new RectOffset(15, 15, 5, 5);
 
             RectTransform panelRect = panelObj.GetComponent<RectTransform>();
-            panelRect.anchorMin = new Vector2(0.5f, 1.0f); // Top Center
+            panelRect.anchorMin = new Vector2(0.5f, 1.0f);
             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.anchoredPosition = new Vector2(0, -5);
-            panelRect.sizeDelta = new Vector2(180, 35);      // Width and Height of the bar
 
-            // 3. Text (Attached to Panel)
+            // --- TEXT ---
             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
+            m_textComponent.font = Resources.GetBuiltinResource<Font>("Arial.ttf");
-            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
+            // --- PROGRESS BAR CONTAINER ---
-            var shadow = textObj.AddComponent<Shadow>();
+            // This sits under the main rectangle
-            shadow.effectColor = Color.black;
+            GameObject barBgObj = new GameObject("BarBackground");
-            shadow.effectDistance = new Vector2(2, 2);
+            barBgObj.transform.SetParent(m_canvasObject.transform, false);
+            barBgObj.AddComponent<Image>().color = new Color(0.1f, 0.1f, 0.1f, 0.8f); // Dark background
 
-            // FIX: Correct way to make text fill the parent panel
+            RectTransform barBgRect = barBgObj.GetComponent<RectTransform>();
-            RectTransform textRect = textObj.GetComponent<RectTransform>();
+            barBgRect.anchorMin = new Vector2(0.5f, 1.0f);
-            textRect.anchorMin = Vector2.zero; // (0, 0)
+            barBgRect.anchorMax = new Vector2(0.5f, 1.0f);
-            textRect.anchorMax = Vector2.one;  // (1, 1)
+            barBgRect.pivot = new Vector2(0.5f, 1.0f);
-            textRect.pivot = new Vector2(0.5f, 0.5f);
+            // Positioned below the clock panel (Clock is 35px high + 5px gap = -40)
+            barBgRect.anchoredPosition = new Vector2(0, -45);
+            barBgRect.sizeDelta = new Vector2(180, 8); // Match width of clock, small height
 
-            // Resetting these to zero ensures the text box matches the panel exactly
+            // --- PROGRESS BAR FILL ---
-            textRect.offsetMin = Vector2.zero;
+            GameObject fillObj = new GameObject("BarFill");
-            textRect.offsetMax = Vector2.zero;
+            fillObj.transform.SetParent(barBgObj.transform, false);
+            fillObj.AddComponent<Image>().color = Color.yellow; // Classic Valheim XP color
+
+            m_barFill = fillObj.GetComponent<RectTransform>();
+            m_barFill.anchorMin = new Vector2(0, 0);
+            m_barFill.anchorMax = new Vector2(0.5f, 1); // This X value (0.5) will be updated via code
+            m_barFill.pivot = new Vector2(0, 0.5f);
+            m_barFill.offsetMin = Vector2.zero;
+            m_barFill.offsetMax = Vector2.zero;
         }
     }
 }

README.md

@@ -1,10 +1,11 @@
-![logo](https://mxdev.ovh/wp-content/uploads/2025/09/mxdev-1.png)
+![logo](https://mxio.ovh/gaming/valheim/mxvalheim.png)
 
 ## MxValheim
 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
+- Enhanced Event System with level and reward based on current biome.
 - 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.