(1.6.13) EventSystem Exp Revamp + Reward Fix

MxValheim/EventSystem/Experience.cs

@@ -0,0 +1,160 @@
+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 int CalculateExperience(string enemyInternalName, int level, Heightmap.Biome biome)
+        {
+            Dictionary<int, float> levelMulti = new Dictionary<int, float>
+            {
+                { 1, 1.0f },
+                { 2, 1.5f },
+                { 3, 2.0f },
+                { 4, 2.5f },
+            };
+            int expfinal = (int)(EnemiesExpValue[enemyInternalName] * levelMulti[level]);
+            return expfinal;
+        }
+
+        public static float CalculateExpMultiplier(Heightmap.Biome biome)
+        {
+            Dictionary<int, float> biomeBase = new Dictionary<int, float>()
+            {
+                { 1, 1.0f },
+                { 8, 1.5f },
+                { 2, 2.0f },
+                { 4, 2.5f },
+                { 16, 3.0f },
+                { 512, 4.0f },
+                { 64, 2.5f },
+                { 32, 5.0f },
+                { 256, 1.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;
+            }
+        }
+
+        public static Dictionary<string, int> EnemiesExpValue = new Dictionary<string, int>
+    {
+        // --- Meadows ---
+        { "Boar", 10 },
+        { "Neck", 10 },
+        { "Greyling", 15 },
+
+        // --- Black Forest ---
+        { "Greydwarf", 20 },
+        { "Greydwarf_Elite", 30 },
+        { "Greydwarf_Shaman", 30 },
+        { "Troll", 100 },
+        { "Ghost", 100 },
+        { "Skeleton", 30 },
+        { "Skeleton_NoArcher", 30 }, // Melee only variant
+
+        // --- Swamp ---
+        { "Blob", 20 },
+        { "BlobElite", 30 }, // Oozer
+        { "Draugr", 40 },
+        { "Draugr_Elite", 50 },
+        { "Draugr_Ranged", 40 },
+        { "Leech", 20 },
+        { "Surtling", 40 },
+        { "Wraith", 100 },
+        { "Abomination", 200 },
+
+        // --- Mountains ---
+        { "Bat", 10 },
+        { "Hatchling", 50 },
+        { "Fenring", 50 },
+        { "Fenring_Cultist", 50 },
+        { "StoneGolem", 100 },
+        { "Ulv", 100 },
+        { "Wolf", 30 },
+
+        // --- Plains ---
+        { "Deathsquito", 10 },
+        { "Fuling", 50 },
+        { "FulingBerserker", 60 },
+        { "FulingShaman", 60 },
+        { "Lox", 200 },
+        { "Growth", 10 },
+
+        // --- Mistlands ---
+        { "Gjall", 100 },
+        { "Seeker", 40 },
+        { "SeekerBrute", 100 }, // Seeker Soldier
+        { "SeekerBrood", 100 },
+        { "Tick", 20 },
+        { "Dverger", 50 },
+
+        // --- Ashlands ---
+        { "Asksvin", 50 },
+        { "Charred_Melee", 50 },  // Charred Warrior
+        { "Charred_Archer", 50 }, // Charred Marksman
+        { "Charred_Mage", 50 },   // Charred Warlock
+        { "Charred_Twitcher", 50 },
+        { "FallenValkyrie", 200 },
+        { "Morgen", 300 },
+        { "BonemawSerpent", 200 },
+        { "Voltures", 50 },
+
+        // --- Ocean ---
+        { "Serpent", 500 },
+
+        // --- Bosses ---
+        { "Eikthyr", 100 },
+        { "gd_king", 200 },      // The Elder
+        { "Bonemass", 300 },
+        { "Dragon", 400 },        // Moder
+        { "GoblinKing", 500 },    // Yagluth
+        { "SeekerQueen", 600 },
+        { "Fader", 800 }
+    };
+    }
+}

MxValheim/EventSystem/Patch.cs

@@ -0,0 +1,224 @@
+using BepInEx.Bootstrap;
+using EpicLoot;
+using HarmonyLib;
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+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);
+                }
+            }
+
+            static void Postfix(RandEventSystem __instance)
+            {
+                RandomEvent activeEvent = RandEventSystem.instance.GetActiveEvent();
+                if (activeEvent != null)
+                {
+                    activeEvent.m_eventRange = 200f;
+                }
+            }
+        }
+
+        [HarmonyPatch(typeof(RandEventSystem), nameof(RandEventSystem.FixedUpdate))]
+        public static class EventRadiusPatch
+        {
+            static void Postfix(RandEventSystem __instance)
+            {
+                RandomEvent currentEvent = __instance.GetCurrentRandomEvent();
+
+                if (currentEvent != null)
+                {
+                    currentEvent.m_eventRange = 200f;
+                }
+            }
+        }
+
+        [HarmonyPatch(typeof(RandEventSystem), nameof(RandEventSystem.FixedUpdate))]
+        public static class TimerFreezePatch
+        {
+            static void Prefix(RandEventSystem __instance)
+            {
+                if (MxValheimMod.Config_DebugRandomEventInterval.Value)
+                {
+                    __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)
+                {
+                    int points = 0;
+                    ZPackage pkg = new ZPackage();
+                    pkg.Write(currentRaid.m_name);
+                    pkg.Write($"{currentRaid.m_pos}");
+                    points = Watcher.eventPoints;
+                    ZRoutedRpc.instance.InvokeRoutedRPC(0, "RPC_ServerRemoveEvent", pkg);
+
+                    Vector3 playerPos = Player.m_localPlayer.transform.position;
+                    float distance = Vector3.Distance(playerPos, currentRaid.m_pos);
+
+                    if (distance <= 200f)
+                    {
+                        Heightmap.Biome currentBiome = EnvMan.instance.GetCurrentBiome();
+                        Reward.GiveItemStatic("Coins", Reward.CalculateRewardCoin(Profiles.serverLevel, currentBiome, points));
+                        System.Random rand = new System.Random();
+                        Reward.GiveItemStatic("Feathers", rand.Next(5, 20));
+                        float dayPercent = ((float)EnvMan.instance.GetDay() / 10);
+                        if (rand.Next(100) < (50+dayPercent))
+                        {
+                            Reward.GiveItemRandom(Reward.GetRewardPrefab(Profiles.serverLevel, "food"), 1);
+                        }
+                        if (rand.Next(100) < (25+dayPercent))
+                        {
+                            Reward.GiveItemRandom(Reward.GetRewardPrefab(Profiles.serverLevel, "heal"), 1);
+                        }
+                        if (rand.Next(100) < (10+dayPercent))
+                        {
+                            Reward.GiveItemRandom(Reward.GetRewardPrefab(Profiles.serverLevel, "metal"), rand.Next(5, (20+Profiles.serverLevel)));
+                        }
+                        if (Chainloader.PluginInfos.ContainsKey("randyknapp.mods.epicloot"))
+                        {
+                            Reward.GenRarity();
+                            Reward.GiveEpicLootDust();
+                            Reward.GiveEpicLootShard();
+                            Reward.GiveEpicLootEssence();
+                            Reward.GiveEpicLootRune();
+                        }                    
+                    }
+                }
+            }
+        }
+
+        [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());
+                    }
+                }
+
+                if (RandEventSystem.instance != null && RandEventSystem.instance.GetActiveEvent() != null)
+                {
+                    __instance.m_eventName.text = "";
+                }                
+            }
+        }
+
+        [HarmonyPatch(typeof(Character), nameof(Character.ApplyDamage))]
+        public static class DeathNotifier
+        {
+            static void Postfix(Character __instance)
+            {
+                if (__instance.GetHealth() <= 0f)
+                {
+                    ZNetView nview = __instance.GetComponent<ZNetView>();
+
+                    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;
+                    }
+
+                    string internalName = __instance.gameObject.name;
+                    int cloneIndex = internalName.IndexOf("(Clone)");
+                    if (cloneIndex != -1)
+                    {
+                        internalName = internalName.Substring(0, cloneIndex);
+                    }
+
+                    if (isEventCreature)
+                    {
+                        RandomEvent activeEvent = RandEventSystem.instance.GetActiveEvent();
+                        if (activeEvent != null)
+                        {
+                            ZPackage pkg = new ZPackage();
+                            pkg.Write(activeEvent.m_name);
+                            pkg.Write($"{activeEvent.m_pos}");                       
+                            pkg.Write(Reward.EnemiesPointValue[internalName]);
+                            ActiveEventData entry = MxValheimMod.ActiveEvents.Find(e => e.Position == activeEvent.m_pos.ToString());
+                            if (entry == null)
+                            {
+                                ZRoutedRpc.instance.InvokeRoutedRPC(0, "RPC_ServerRegisterEvent", pkg);
+                            }
+                            else
+                            {
+                                ZRoutedRpc.instance.InvokeRoutedRPC(0, "RPC_ServerSetEventKill", pkg);
+                            }
+                            ZRoutedRpc.instance.InvokeRoutedRPC(0, "RPC_ServerGetEventKill", pkg);
+                        }
+
+                        int level = __instance.GetLevel();
+                        Heightmap.Biome currentBiome = EnvMan.instance.GetCurrentBiome();
+                        int exp = Experience.CalculateExperience(internalName, level, currentBiome);
+                        ZRoutedRpc.instance.InvokeRoutedRPC(0, "RPC_RequestProfile", "Event");
+                        Experience.AddExperience(exp);
+                        Color magicPurple = new Color(0.921f, 0.475f, 0.990f);
+                        Vector3 spawnPos = __instance.transform.position + Vector3.up * 1.0f;
+                        DamageText.instance.ShowText(HitData.DamageModifier.Normal, spawnPos, exp, true);
+                    } else
+                    {
+                        int level = __instance.GetLevel();
+                        Heightmap.Biome currentBiome = EnvMan.instance.GetCurrentBiome();
+                        int exp = Experience.CalculateExperience(internalName, level, currentBiome);                 
+                        Experience.AddExperience(exp);
+                        Color magicPurple = new Color(0.921f, 0.475f, 0.990f);
+                        Vector3 spawnPos = __instance.transform.position + Vector3.up * 1.0f;
+                        DamageText.instance.ShowText(HitData.DamageModifier.Normal, spawnPos, exp, true);
+                    }              
+                }
+            }
+        }
+    }
+}

MxValheim/EventSystem/Profiles.cs

@@ -0,0 +1,114 @@
+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/RandomUnique/SpawnManager.cs

@@ -0,0 +1,158 @@
+using HarmonyLib;
+using Jotunn.Configs;
+using Jotunn.Entities;
+using Jotunn.Managers;
+using Newtonsoft.Json;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using UnityEngine;
+using static DropTable;
+
+namespace MxValheim.EventSystem.RandomUnique
+{
+    internal class SpawnManager
+    {
+        public class SpawnConditionsData
+        {
+            public bool WorldSpawnEnabled;
+            public string Biome;
+            public float SpawnChance;
+            public int MaxSpawned;
+            public float SpawnInterval;
+            public float SpawnDistance;
+            public bool SpawnInForest;
+            public bool SpawnOutsideForest;
+            public float MinAltitude;
+            public float MaxAltitude;
+            public int MinGroupSize;
+            public int MaxGroupSize;
+            public bool SpawnAtDay;
+            public bool SpawnAtNight;
+            public int MinLevel;
+        }
+
+        public class DropData
+        {
+            public string ItemName;
+            public int Min;
+            public int Max;
+            public float Chance;
+            public bool OnePerPlayer;
+        }
+
+        public class EquipmentData
+        {
+            public string RightHand;
+            public string LeftHand;
+            public string Chest;
+            public string Legs;
+            public string Back;
+        }
+
+        public class EnemyTemplate
+        {
+            public string PrefabToClone;
+            public string InternalName;
+            public string HoverName;
+            public string Faction;
+            public float Health;
+            public float Speed;
+            public float Scale;
+            public ColorData ColorTint;
+
+            public SpawnConditionsData SpawnConditions;
+
+            public List<DropData> DropTable;
+            public EquipmentData Equipment;
+        }
+
+        public class ColorData
+        {
+            public float r;
+            public float g;
+            public float b;
+            public float intensity;
+        }
+
+        public static void RegisterWithWorldSpawn(GameObject customEnemy, EnemyTemplate data)
+        {
+            var spawnConfig = new SpawnConfig
+            {
+                Name = data.InternalName + "_Spawn",
+                WorldSpawnEnabled = data.SpawnConditions.WorldSpawnEnabled,
+                Biome = (Heightmap.Biome)Enum.Parse(typeof(Heightmap.Biome), data.SpawnConditions.Biome),
+                SpawnChance = data.SpawnConditions.SpawnChance,
+                MaxSpawned = data.SpawnConditions.MaxSpawned,
+                SpawnInterval = data.SpawnConditions.SpawnInterval,
+                SpawnDistance = data.SpawnConditions.SpawnDistance,
+                SpawnInForest = data.SpawnConditions.SpawnInForest,
+                SpawnOutsideForest = data.SpawnConditions.SpawnOutsideForest,
+                MinAltitude = data.SpawnConditions.MinAltitude,
+                MaxAltitude = data.SpawnConditions.MaxAltitude,
+                MinGroupSize = data.SpawnConditions.MinGroupSize,
+                MaxGroupSize = data.SpawnConditions.MaxGroupSize,
+                SpawnAtDay = !data.SpawnConditions.SpawnAtDay,
+                SpawnAtNight = data.SpawnConditions.SpawnAtNight,
+                MinLevel = data.SpawnConditions.MinLevel,
+            };
+
+            var creatureConfig = new CreatureConfig();
+            creatureConfig.Name = data.HoverName;
+
+            creatureConfig.AddSpawnConfig(spawnConfig);
+
+            CreatureManager.Instance.AddCreature(new CustomCreature(customEnemy, true, creatureConfig));
+
+            Debug.Log($"[MxValheim] {data.InternalName} registered correctly with CreatureConfig!");
+        }
+
+        [HarmonyPatch(typeof(Hud), nameof(Hud.Update))]
+        public static class Hud_Update_SpawnManager
+        {
+            static void Postfix(Hud __instance)
+            {
+                if (Player.m_localPlayer == null || !Player.m_localPlayer.IsDead()) return;
+
+                if (MxValheimMod._uniqueTimer > 0)
+                {
+                    MxValheimMod._uniqueTimer -= Time.deltaTime;
+                }
+
+                if (MxValheimMod._uniqueTimer <= 0)
+                {
+                    int pb = GetPlayerBiomeIndex(Player.m_localPlayer);
+                    System.Random rand = new System.Random();
+                    if (rand.Next(100) < 25)
+                    {
+                        switch (pb)
+                        {
+                            case 1:  break;
+                        }
+                    }
+                    MxValheimMod._uniqueTimer = 60.0f;
+                }
+            }
+        }
+
+        public static int GetPlayerBiomeIndex(Player player)
+        {
+            int biomeIndex = 0;
+            Heightmap.Biome currentBiome = player.GetCurrentBiome();
+            Debug.Log($"KillFeed: {currentBiome}");
+            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;
+
+            return biomeIndex;
+        }
+    }
+}

MxValheim/EventSystem/RandomUnique/UniqueManager.cs

@@ -0,0 +1,265 @@
+using Jotunn.Managers;
+using Newtonsoft.Json;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using UnityEngine;
+using static MxValheim.EventSystem.RandomUnique.SpawnManager;
+
+namespace MxValheim.EventSystem.RandomUnique
+{
+    internal class UniqueManager
+    {
+        public static void LoadAllTemplates()
+        {
+            string uniqueFolder = Path.Combine(MxValheimMod.internalDataPath, "UniqueEnemy");
+
+            if (!Directory.Exists(uniqueFolder))
+            {
+                Directory.CreateDirectory(uniqueFolder);
+            }
+
+            string[] jsonFiles = Directory.GetFiles(uniqueFolder, "*.json");
+
+            foreach (string filePath in jsonFiles)
+            {
+                try
+                {
+                    string jsonContent = File.ReadAllText(filePath);
+                    LoadEnemyFromJson(jsonContent);
+                    Debug.Log($"Loaded custom enemy from: {Path.GetFileName(filePath)}");
+                }
+                catch (System.Exception ex)
+                {
+                    Debug.LogError($"Failed to load {filePath}: {ex.Message}");
+                }
+            }
+        }
+
+        public static void LoadEnemyFromJson(string jsonContent)
+        {
+            var data = JsonConvert.DeserializeObject<EnemyTemplate>(jsonContent);
+
+            GameObject customEnemy = PrefabManager.Instance.CreateClonedPrefab(data.InternalName, data.PrefabToClone);
+
+            Character character = customEnemy.GetComponent<Character>();
+            if (character != null)
+            {
+                character.m_name = data.HoverName;
+                character.m_health = data.Health;
+                character.m_speed = data.Speed;
+                character.m_faction = Character.Faction.Boss;
+            }
+
+            customEnemy.transform.localScale = new Vector3(data.Scale, data.Scale, data.Scale);
+
+            PrefabManager.Instance.AddPrefab(customEnemy);
+
+            Debug.Log($"Successfully injected {data.InternalName} into Valheim!");
+        }
+
+        public static List<EnemyTemplate> LoadTemplatesFromFolder()
+        {
+            List<EnemyTemplate> loadedTemplates = new List<EnemyTemplate>();
+
+            string configFolder = Path.Combine(MxValheimMod.internalDataPath, "UniqueEnemy");
+
+            if (!Directory.Exists(configFolder))
+            {
+                Directory.CreateDirectory(configFolder);
+                return loadedTemplates;
+            }
+
+            string[] files = Directory.GetFiles(configFolder, "*.json");
+
+            foreach (string file in files)
+            {
+                try
+                {
+                    string json = File.ReadAllText(file);
+                    EnemyTemplate template = JsonConvert.DeserializeObject<EnemyTemplate>(json);
+
+                    if (template != null)
+                    {
+                        loadedTemplates.Add(template);
+                        Debug.Log($"Loaded template: {template.InternalName} from {Path.GetFileName(file)}");
+                    }
+                }
+                catch (Exception ex)
+                {
+                    Debug.Log($"Error loading JSON file {file}: {ex.Message}");
+                }
+            }
+
+            return loadedTemplates;
+        }
+
+        public static void ApplyEquipment(GameObject customEnemy, EnemyTemplate data)
+        {
+            Humanoid humanoid = customEnemy.GetComponent<Humanoid>();
+            if (humanoid == null) return;
+
+            humanoid.m_defaultItems = new GameObject[0];
+
+            List<GameObject> equipmentList = new List<GameObject>();
+
+            void AddToGear(string prefabName)
+            {
+                if (string.IsNullOrEmpty(prefabName)) return;
+                GameObject item = ObjectDB.instance.GetItemPrefab(prefabName);
+                if (item != null) equipmentList.Add(item);
+            }
+
+            AddToGear(data.Equipment.RightHand);
+            AddToGear(data.Equipment.LeftHand);
+            AddToGear(data.Equipment.Chest);
+            AddToGear(data.Equipment.Legs);
+            AddToGear(data.Equipment.Back);
+
+            humanoid.m_defaultItems = equipmentList.ToArray();
+        }
+
+        public static void ApplyDropTable(GameObject customEnemy, EnemyTemplate data)
+        {
+            CharacterDrop dropComp = customEnemy.GetComponent<CharacterDrop>();
+            if (dropComp == null)
+            {
+                dropComp = customEnemy.AddComponent<CharacterDrop>();
+            }
+
+            dropComp.m_drops.Clear();
+
+            foreach (var dropInfo in data.DropTable)
+            {
+                GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(dropInfo.ItemName);
+
+                if (itemPrefab != null)
+                {
+                    CharacterDrop.Drop newDrop = new CharacterDrop.Drop
+                    {
+                        m_prefab = itemPrefab,
+                        m_amountMin = dropInfo.Min,
+                        m_amountMax = dropInfo.Max,
+                        m_chance = dropInfo.Chance,
+                        m_onePerPlayer = dropInfo.OnePerPlayer
+                    };
+
+                    dropComp.m_drops.Add(newDrop);
+                }
+            }
+        }
+
+        public static void ApplyStats(GameObject customEnemy, EnemyTemplate data)
+        {
+            Character character = customEnemy.GetComponent<Character>();
+            if (character != null)
+            {
+                character.m_name = data.HoverName;
+
+                if (!string.IsNullOrEmpty(data.Faction) &&
+                    Enum.TryParse(data.Faction, out Character.Faction factionEnum))
+                {
+                    character.m_faction = factionEnum;
+                }
+                else
+                {
+                    character.m_faction = Character.Faction.Undead;
+                }
+
+                typeof(Character).GetField("m_maxHealth", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance)
+                                 ?.SetValue(character, data.Health);
+                character.m_health = data.Health;
+
+                typeof(Character).GetField("m_tamed", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance)
+                                 ?.SetValue(character, false);
+
+                var tameable = customEnemy.GetComponent<Tameable>();
+                if (tameable != null)
+                {
+                    UnityEngine.Object.DestroyImmediate(tameable);
+                }
+
+                var procreation = customEnemy.GetComponent<Procreation>();
+                if (procreation != null) UnityEngine.Object.DestroyImmediate(procreation);
+
+                character.m_speed = data.Speed;
+                character.m_runSpeed = data.Speed * 1.5f;
+            }
+
+            BaseAI ai = customEnemy.GetComponent<BaseAI>();
+            if (ai != null && character != null)
+            {
+                typeof(BaseAI).GetField("m_character", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance)?.SetValue(ai, character);
+
+                typeof(BaseAI).GetField("m_aggravated", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance)?.SetValue(ai, true);
+
+                ai.m_viewRange = 50f;
+            }
+
+            Rigidbody rb = customEnemy.GetComponent<Rigidbody>();
+            if (rb != null)
+            {
+                rb.isKinematic = false;
+                rb.useGravity = true;
+            }
+
+            ZNetView nview = customEnemy.GetComponent<ZNetView>();
+            if (nview != null)
+            {
+                nview.m_type = ZDO.ObjectType.Default;
+                nview.m_syncInitialScale = true;
+            }
+
+            UnityEngine.AI.NavMeshAgent agent = customEnemy.GetComponent<UnityEngine.AI.NavMeshAgent>();
+            if (agent != null)
+            {
+                agent.enabled = true;
+                agent.updatePosition = true;
+                agent.updateRotation = true;
+                agent.stoppingDistance = 1.0f;
+            }
+
+            nview.GetZDO()?.Set("m_eventCreature", true);
+
+            customEnemy.transform.localScale = Vector3.one * data.Scale;
+            if (nview != null)
+            {
+                nview.SetLocalScale(customEnemy.transform.localScale);
+            }
+        }
+
+        public static void ApplyColorTint(GameObject customEnemy, EnemyTemplate data)
+        {
+            if (data.ColorTint == null) return;
+
+            // Convert JSON floats to a Unity Color object
+            Color customColor = new Color(data.ColorTint.r, data.ColorTint.g, data.ColorTint.b);
+
+            // Find all renderers (body, head, etc.)
+            var renderers = customEnemy.GetComponentsInChildren<Renderer>();
+
+            foreach (var renderer in renderers)
+            {
+                // We use 'material' (singular) to create a unique instance for THIS enemy
+                foreach (var mat in renderer.materials)
+                {
+                    // '_Color' is the standard main tint property in most Valheim shaders
+                    if (mat.HasProperty("_Color"))
+                    {
+                        mat.SetColor("_Color", customColor);
+                    }
+
+                    // Optional: If you want them to GLOW slightly, set the Emission
+                    if (mat.HasProperty("_EmissionColor"))
+                    {
+                        mat.SetColor("_EmissionColor", customColor * 0.5f);
+                        mat.EnableKeyword("_EMISSION");
+                    }
+                }
+            }
+        }
+    }
+}

MxValheim/EventSystem/Reward.cs

@@ -0,0 +1,353 @@
+using EpicLoot;
+using HarmonyLib;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+using System.Threading.Tasks;
+using System.Windows.Navigation;
+using UnityEngine;
+
+namespace MxValheim.EventSystem
+{
+    internal class Reward
+    {
+        private static string globalRarity = "Magic";
+
+        public static int CalculateRewardCoin(int level, Heightmap.Biome biome, int points)
+        {
+            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) + points;
+
+            return rewardCoin;
+        }
+
+        public static void GenRarity()
+        {
+            string[] rarity = GetRarityList(Watcher.eventPoints);
+
+            System.Random rand = new System.Random();
+            globalRarity = rarity[rand.Next(0, rarity.Length - 1)];
+        }
+
+        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(0, foodList.Length - 1);
+            int healTier = rng.Next(0, healList.Length - 1);
+            int metalTier = rng.Next(0, metalList.Length - 1);
+
+            if (type == "food") return foodList[foodTier];
+            if (type == "heal") return healList[healTier];
+            if (type == "metal") return metalList[metalTier];
+            return "Wood";
+        }
+
+        public static void GiveEpicLootDust()
+        {
+            System.Random rand = new System.Random();
+
+            int qty = rand.Next(1, Profiles.serverLevel);
+
+            string[] rarity = GetRarityList(Watcher.eventPoints);
+
+            string itemName = $"Dust{globalRarity}";
+
+            Player player = Player.m_localPlayer;
+            if (player == null) return;
+
+            GameObject prefab = ObjectDB.instance.GetItemPrefab(itemName);
+            if (prefab != null)
+            {
+                GiveItemSafe(itemName, player, qty);
+            }
+            else
+            {
+                Debug.LogWarning($"Item {itemName} not found in ObjectDB!");
+            }
+        }
+
+        public static void GiveEpicLootShard()
+        {
+            System.Random rand = new System.Random();
+
+            int qty = rand.Next(1, Profiles.serverLevel);
+
+            string[] rarity = GetRarityList(Watcher.eventPoints);
+
+            string itemName = $"Shard{globalRarity}";
+
+            Player player = Player.m_localPlayer;
+            if (player == null) return;
+
+            GameObject prefab = ObjectDB.instance.GetItemPrefab(itemName);
+            if (prefab != null)
+            {
+                GiveItemSafe(itemName, player, qty);
+            }
+            else
+            {
+                Debug.LogWarning($"Item {itemName} not found in ObjectDB!");
+            }
+        }
+
+        public static void GiveEpicLootEssence()
+        {
+            System.Random rand = new System.Random();
+
+            int qty = rand.Next(1, Profiles.serverLevel);
+
+            string[] rarity = GetRarityList(Watcher.eventPoints);
+
+            string itemName = $"Essence{globalRarity}";
+
+            Player player = Player.m_localPlayer;
+            if (player == null) return;
+
+            GameObject prefab = ObjectDB.instance.GetItemPrefab(itemName);
+            if (prefab != null)
+            {
+                GiveItemSafe(itemName, player, qty);
+            }
+            else
+            {
+                Debug.LogWarning($"Item {itemName} not found in ObjectDB!");
+            }
+        }
+
+        public static void GiveEpicLootRune()
+        {
+            System.Random rand = new System.Random();
+
+            int qty = rand.Next(1, 2);
+
+            string[] rarity = GetRarityList(Watcher.eventPoints);
+
+            string itemName = $"Runestone{globalRarity}";
+
+            Player player = Player.m_localPlayer;
+            if (player == null) return;
+
+            GameObject prefab = ObjectDB.instance.GetItemPrefab(itemName);
+            if (prefab != null)
+            {
+                GiveItemSafe(itemName, player, qty);
+                SendRewardMessage(player, prefab, itemName, qty);
+            }
+            else
+            {
+                Debug.LogWarning($"Item {itemName} not found in ObjectDB!");
+            }
+        }
+
+        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)
+            {
+                GiveItemSafe(itemName, player, qty);
+            }
+            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)
+            {
+                GiveItemSafe(itemName, player, qty);
+                if (itemName == "Coins")
+                {
+                    SendRewardMessage(player, prefab, itemName, qty);
+                }
+            }
+            else
+            {
+                Debug.LogWarning($"Item {itemName} not found in ObjectDB!");
+            }
+        }
+
+        public static void GiveItemSafe(string itemName, Player player, int qty)
+        {
+            GameObject prefab = ObjectDB.instance.GetItemPrefab(itemName);
+            if (prefab == null) return;
+
+            ItemDrop itemDrop = prefab.GetComponent<ItemDrop>();
+            if (itemDrop == null) return;
+
+            ItemDrop.ItemData result = player.GetInventory().AddItem(itemName, qty, 1, 0, 0, "");
+
+            if (result == null)
+            {
+                GiveItemInWorld(itemName, player, qty);
+            }
+        }
+
+        public static void GiveItemInWorld(string itemName, Player player, int qty)
+        {
+            GameObject prefab = ObjectDB.instance.GetItemPrefab(itemName);
+            Vector3 spawnPos = player.transform.position + player.transform.forward + Vector3.up;
+
+            GameObject go = UnityEngine.Object.Instantiate(prefab, spawnPos, Quaternion.identity);
+
+            ItemDrop itemDrop = go.GetComponent<ItemDrop>();
+            if (itemDrop != null)
+            {
+                itemDrop.m_itemData.m_stack = qty;
+                ZNetView nview = go.GetComponent<ZNetView>();
+                if (nview != null && nview.IsValid())
+                {
+                    nview.GetZDO().Set("stack", qty);
+                }
+
+                GameObject vfxPrefab = ZNetScene.instance.GetPrefab("vfx_item_spawn");
+                if (vfxPrefab != null)
+                {
+                    UnityEngine.Object.Instantiate(vfxPrefab, spawnPos, Quaternion.identity);
+                }
+
+                GameObject sfxPrefab = ZNetScene.instance.GetPrefab("sfx_item_spawn");
+                if (sfxPrefab != null)
+                {
+                    UnityEngine.Object.Instantiate(sfxPrefab, spawnPos, Quaternion.identity);
+                }
+            }
+        }
+
+        public static void SendRewardMessage(Player player, GameObject prefab, string itemName, int qty)
+        {
+            if (ZRoutedRpc.instance != null)
+            {
+                ItemDrop item = prefab.GetComponent<ItemDrop>();
+                string nameToken = item.m_itemData.m_shared.m_name;
+                ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.Everybody, "RPC_MxKillMsg", Player.m_localPlayer.GetHoverName(), qty.ToString(), Localization.instance.Localize(nameToken), itemName, -2);
+            }
+        }
+
+        public static string[] GetRarityList(int point)
+        {
+            string[] rarity = { };
+            switch (point)
+            {
+                case < 100:
+                    rarity = ["Magic"];
+                    break;
+                case >= 100 and < 500:
+                    rarity = ["Rare"];
+                    break;
+                case >= 500 and <= 1000:
+                    rarity = ["Epic"];
+                    break;
+                case >= 1001 and <= 2000:
+                    rarity = ["Epic", "Legendary"];
+                    break;
+                case >= 2001:
+                    rarity = ["Epic", "Legendary", "Mythic"];
+                    break;
+            }
+            return rarity;
+        }
+
+        public static Dictionary<string, int> EnemiesPointValue = new Dictionary<string, int>
+    {
+        // --- Meadows ---
+        { "Boar", 10 },
+        { "Neck", 10 },
+        { "Greyling", 20 },
+
+        // --- Black Forest ---
+        { "Greydwarf", 20 },
+        { "Greydwarf_Elite", 50 },
+        { "Greydwarf_Shaman", 50 },
+        { "Troll", 250 },
+        { "Ghost", 100 },
+        { "Skeleton", 60 },
+        { "Skeleton_NoArcher", 60 }, // Melee only variant
+
+        // --- Swamp ---
+        { "Blob", 50 },
+        { "BlobElite", 80 }, // Oozer
+        { "Draugr", 100 },
+        { "Draugr_Elite", 150 },
+        { "Draugr_Ranged", 100 },
+        { "Leech", 50 },
+        { "Surtling", 80 },
+        { "Wraith", 100 },
+        { "Abomination", 300 },
+
+        // --- Mountains ---
+        { "Bat", 50 },
+        { "Hatchling", 150 },
+        { "Fenring", 150 },
+        { "Fenring_Cultist", 150 },
+        { "StoneGolem", 200 },
+        { "Ulv", 200 },
+        { "Wolf", 100 },
+
+        // --- Plains ---
+        { "Deathsquito", 50 },
+        { "Fuling", 100 },
+        { "FulingBerserker", 250 },
+        { "FulingShaman", 150 },
+        { "Lox", 300 },
+        { "Growth", 50 },
+
+        // --- Mistlands ---
+        { "Gjall", 50 },
+        { "Seeker", 100 },
+        { "SeekerBrute", 300 }, // Seeker Soldier
+        { "SeekerBrood", 150 },
+        { "Tick", 50 },
+        { "Dverger", 200 },
+
+        // --- Ashlands ---
+        { "Asksvin", 50 },
+        { "Charred_Melee", 100 },  // Charred Warrior
+        { "Charred_Archer", 100 }, // Charred Marksman
+        { "Charred_Mage", 100 },   // Charred Warlock
+        { "Charred_Twitcher", 100 },
+        { "FallenValkyrie", 400 },
+        { "Morgen", 300 },
+        { "BonemawSerpent", 300 },
+        { "Voltures", 100 },
+
+        // --- Ocean ---
+        { "Serpent", 500 },
+
+        // --- Bosses ---
+        { "Eikthyr", 100 },
+        { "gd_king", 101 },      // The Elder
+        { "Bonemass", 102 },
+        { "Dragon", 103 },        // Moder
+        { "GoblinKing", 104 },    // Yagluth
+        { "SeekerQueen", 105 },
+        { "Fader", 106 }
+    };
+    }
+}

MxValheim/EventSystem/Watcher.cs

@@ -0,0 +1,71 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using UnityEngine;
+
+namespace MxValheim.EventSystem
+{
+    internal class Watcher
+    {
+        public static int eventPoints = 0;
+
+        public static void GetEventKill(long sender, ZPackage pkg)
+        {
+            string eventName = pkg.ReadString();
+            string eventPos = pkg.ReadString();
+
+            int evindex = MxValheimMod.ActiveEvents.FindIndex(e => e.Position.ToString() == eventPos);
+
+            eventPoints = MxValheimMod.ActiveEvents[evindex].Points;       
+        }
+
+        public static void SetEventKill(long sender, ZPackage pkg)
+        {
+            string eventName = pkg.ReadString();
+            string eventPos = pkg.ReadString();
+            int killPoints = pkg.ReadInt();
+
+            int evindex = MxValheimMod.ActiveEvents.FindIndex(e => e.Position.ToString() == eventPos);
+            int evPoints = MxValheimMod.ActiveEvents[evindex].Points;
+
+            MxValheimMod.ActiveEvents.RemoveAt(evindex);
+            int newPoints = eventPoints + killPoints;
+            eventPoints = newPoints;
+
+            MxValheimMod.ActiveEventData newData = new MxValheimMod.ActiveEventData(eventName, eventPos, newPoints);
+            MxValheimMod.ActiveEvents.Add(newData);
+        }
+
+        public static void RegisterEvent(long sender, ZPackage pkg)
+        {
+            eventPoints = 0;
+            string eventName = pkg.ReadString();
+            string eventPos = pkg.ReadString();
+            int killPoints = pkg.ReadInt();
+
+            MxValheimMod.ActiveEventData newData = new MxValheimMod.ActiveEventData(eventName, eventPos, killPoints);
+            MxValheimMod.ActiveEvents.Add(newData);
+        }
+
+        public static void RemoveEvent(long sender, ZPackage pkg)
+        {
+            string eventName = pkg.ReadString();
+            string eventPos = pkg.ReadString();
+            
+            int evindex = 0;
+            UnityEngine.Debug.Log($"RemoveEvent: ActiveEvents Count = {MxValheimMod.ActiveEvents.Count} ( {eventName} / {eventPos} )");
+            if (MxValheimMod.ActiveEvents.Count > 0)
+            {
+                evindex = MxValheimMod.ActiveEvents.FindIndex(e => e.Position.ToString() == eventPos);
+                MxValheimMod.ActiveEvents.RemoveAt(evindex);
+            } else if (MxValheimMod.ActiveEvents.Count <= 0 && eventPos != null)
+            {
+                // That's not the best way to do it, but until i find a better one, it will prevent an event bugging eternaly.
+                MxValheimMod.ActiveEvents.Clear();
+            }   
+        }
+    }
+}

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;
@@ -14,7 +15,41 @@ using static MxValheimMod;
 namespace MxValheim.KillFeed
 {
     public class KillFeed_Patch
-    {      
+    {
+        public static string lastVictimName = "";
+        public static string lastAttackerName = "";
+        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 +64,35 @@ 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 ---
+
+            // Prevent the spam of multiple "same victim" kill to the feed
+            if (type == 2 && victim == lastVictimName && attacker == lastAttackerName) return;
+
+            // 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);
 
@@ -46,19 +105,25 @@ namespace MxValheim.KillFeed
             }
 
             // Message Format Variables
-            string type1Separator = " a été tué par ";
+            string type1Separator = Localization.instance.Localize("$killfeed_format_type1");
-            string type2Separator = " a tué ";
+            string type2Separator = Localization.instance.Localize("$killfeed_format_type2");
+            string type3Separator = Localization.instance.Localize("$killfeed_format_type3");
+            string type4Separator = Localization.instance.Localize("$killfeed_format_type4");
+            string eventFormat = $"<color=#00ff06>{victim}</color>";
             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)
+
+            if (type == 1)
             {
-                victimFormat = $"<color=#00ff06>{victim.ToUpper()}</color>";
+                victimFormat = $"{crossFormat} <color=#00ff06>{victim.ToUpper()}</color>";
             } else if(type == 2)
             {
                 switch (level)
@@ -75,18 +140,18 @@ namespace MxValheim.KillFeed
                     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 = $" à <color=#9402f5>{distance:F1}m</color> de distance.";          
+
+            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}":
+                (type == 1) ? $"{victimFormat}{type1Separator}{attackerFormat}{distanceFormat}" : // Player Death
-                (type == 2) ? $"{attackerFormat}{type2Separator}{victimFormat}{distanceFormat}" :
+                (type == 2) ? $"{attackerFormat}{type2Separator}{victimFormat}{distanceFormat}" : // Player Killed Something
-                              $"{attackerFormat}{type2Separator}{victimFormat}{distanceFormat}";            
+                              $"{attackerFormat}{type2Separator}{victimFormat}{distanceFormat}"; // Failsafe           
-
-            /*string finalMsg = (type == 1) ? $"<color=#FF3333>☠</color> <color=#00ff06>{victim.ToUpper()}</color> a été tué par <color=#ff0000>{attacker.ToUpper()}</color> à <color=#9402f5>{distance:F1}m</color> de distance." :
-                              (type == 2) ? $"<color=#00ff06>{attacker.ToUpper()}</color> a tué <color=#00c0ff>{victim.ToUpper()}</color> à <color=#9402f5>{distance:F1}m</color> de distance." :
-                              $"<color=#00ff06>{attacker.ToUpper()}</color> a tué <color=#00c0ff>{victim.ToUpper()}</color> à <color=#9402f5>{distance:F1}m</color> de distance.";*/
 
             Sprite weaponIcon = null;
 
@@ -121,17 +186,46 @@ namespace MxValheim.KillFeed
             {
                 borderColor = new Color(0.141f, 0.141f, 0.153f);
             }
+            if (encodedType == -1)
+            {
+                borderColor = new Color(0.0196f, 0.250f, 0.00750f);
+            }
+
+            if (encodedType == -1)
+            {
+                finalMsg = $"<color=#32a852>{type3Separator}</color><color=#ffd000>{eventName}</color><color=#32a852>{type4Separator}</color>";
+            }
+
+            if (encodedType == -2)
+            {
+                int qty = Convert.ToInt32(victim);
+                borderColor = new Color(0.0196f, 0.250f, 0.00750f);
+                finalMsg = $"<color=#ffd000>{attacker.ToUpper()}</color><color=#32a852>{Localization.instance.Localize("$EventSystem_format_reward_Msg_GiveItem")}</color><color=#ffd000>{qty}</color> <color=#32a852>x</color> <color=#ffd000>{victimInternalName}</color><color=#32a852>{Localization.instance.Localize("$EventSystem_format_reward_Msg_GiveItemEnd")}</color>";
+                GameObject itemObj = ObjectDB.instance.GetItemPrefab(weaponPrefab);
+                Sprite itemIcon = null;
+                if (itemObj != null)
+                {
+                    ItemDrop item = itemObj.GetComponent<ItemDrop>();
+                    itemIcon = item?.m_itemData?.m_shared?.m_icons[0];
+                }
+                biomeSprite = LoadCustomSprite("eventsystem_reward.png");
+                weaponIcon = itemIcon;
+            }
+
+            lastVictimName = victim;
+            lastAttackerName = attacker;
 
             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();
 
@@ -151,6 +245,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);
@@ -237,6 +334,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)
@@ -268,15 +368,48 @@ namespace MxValheim.KillFeed
                     }
                     string victimName = __instance.GetHoverName();
 
+                    if (victimName == null || victimName == "") return;
+
                     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)
                     {
@@ -287,7 +420,7 @@ namespace MxValheim.KillFeed
                     _activeTrackers.Remove(__instance);
                 }
             }
-        }      
+        }    
 
         private void CreateCustomHud()
         {
@@ -346,14 +479,22 @@ 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);
             _weaponIconSlot = iconObj.GetComponent<Image>();
             _weaponIconSlot.preserveAspect = true;
             LayoutElement weaponLayout = iconObj.AddComponent<LayoutElement>();
-            weaponLayout.preferredWidth = 24;
+            weaponLayout.preferredWidth = 32;
-            weaponLayout.preferredHeight = 24;
+            weaponLayout.preferredHeight = 32;
 
             RectTransform iRect = iconObj.GetComponent<RectTransform>();
             iRect.anchorMin = iRect.anchorMax = iRect.pivot = new Vector2(0, 0.5f);
@@ -364,10 +505,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;
             foreach (Font f in Resources.FindObjectsOfTypeAll<Font>())
             {
@@ -378,7 +517,6 @@ namespace MxValheim.KillFeed
                 }
             }
 
-            // Corrected fallback for older Unity versions used in Valheim
             if (valheimFont == null)
             {
                 valheimFont = Resources.GetBuiltinResource<Font>("Arial.ttf");
@@ -397,8 +535,8 @@ namespace MxValheim.KillFeed
             _victimIconSlot = victimObj.GetComponent<Image>();
             _victimIconSlot.preserveAspect = true;
             LayoutElement victimLayout = victimObj.AddComponent<LayoutElement>();
-            victimLayout.preferredWidth = 24;
+            victimLayout.preferredWidth = 32;
-            victimLayout.preferredHeight = 24;
+            victimLayout.preferredHeight = 32;
 
             RectTransform vRect = victimObj.GetComponent<RectTransform>();
             vRect.anchorMin = vRect.anchorMax = vRect.pivot = new Vector2(1, 0.5f);
@@ -417,72 +555,5 @@ namespace MxValheim.KillFeed
 
             _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,41 +1,56 @@
 using BepInEx;
 using BepInEx.Configuration;
 using HarmonyLib;
+using Jotunn.Managers;
+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.EventSystems;
 using UnityEngine.UI;
+using static MxValheim.EventSystem.RandomUnique.SpawnManager;
+using static MxValheim.EventSystem.RandomUnique.UniqueManager;
+using static MxValheim.EventSystem.Watcher;
+using static MxValheim.Patch.Doors_Patch;
 
 [BepInPlugin(ModGUID, ModName, ModVersion)]
+[BepInDependency(Jotunn.Main.ModGuid)]
 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.3";
+    private const string ModVersion = "1.6.13";
 
-    public static ConfigEntry<bool> Config_Locked;
+    public static ConfigEntry<bool> Config_DebugRandomEventInterval;
-    public static ConfigEntry<int> Config_OreMultiplier;
-    public static ConfigEntry<float> Config_rangeMultiplier;
     public static ConfigEntry<float> Config_bowDrawSpeedBonusPerLevel;
-    public static ConfigEntry<bool> Config_rainDamage;
-    public static ConfigEntry<float> Config_boatSpeed;
-    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 internalDataPath = Path.Combine(modPath, "Data");
+    public static string internalDataEventSystem = Path.Combine(internalDataPath, "EventSystem.json");
+    public static string DropConfigPath => Path.Combine(internalConfigsPath, "items_drop.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 Dictionary<string, int> DropSettings = new Dictionary<string, int>();
+
+    public static bool initExpBar = true;
 
-    // Data structures
     public class KillData
     {
         public string attackerName;
@@ -49,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;
@@ -59,61 +75,91 @@ 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>();
+    public static readonly Queue<Door> _doorQueueDoor = new Queue<Door>();
+    public static readonly Queue<string> _doorQueueName = new Queue<string>();
+    public static float _doorTimer;
+
+    public static float _uniqueTimer = 60.0f;
+    public static string eventName;
+
+    public static float eventTimer = 0f;
+
+    public class ActiveEventData
+    {
+        public string Name;
+        public string Position;
+        public int Points;
+
+        public ActiveEventData(string name, string pos, int points)
+        {
+            Name = name;
+            Position = pos;
+            Points = points;
+        }
+    }
+
+    public static List<ActiveEventData> ActiveEvents = new List<ActiveEventData>();
+
     void Awake()
     {
         Instance = this;
 
-        Config_OreMultiplier = Config.Bind("General","OreMultiplier",3,"How many items should drop for every 1 ore/scrap found.");
+        Config_DebugRandomEventInterval = Config.Bind("Debug", "DebugRandomEventInterval", false, "Event are triggered really often, to debug my EventSystem logic.");
-        Config_rangeMultiplier = Config.Bind("General", "CraftingRangeMultiplier",2.0f,"Multiplier for the workbench build/crafting range. Default is 2x.");
         Config_bowDrawSpeedBonusPerLevel = Config.Bind("General", "BowDrawSpeedBonusPercentPerLevel", 1.0f, "Shorten the bow draw speed by this percent for every bow upgrade level.");
-        Config_rainDamage = Config.Bind("General", "RainDamage", true, "Set to true to stop rain damage, false to return to vanilla behavior.");
-        Config_boatSpeed = Config.Bind("General", "BoatSpeedMultiplier", 2.0f, "Your boat/raft will move without wind at a speed multiplied by this value.");
-        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 = 2;
+
+        //PrefabManager.OnVanillaPrefabsAvailable += InitCustomEnemies;
 
         Harmony harmony = new Harmony(ModGUID);
         harmony.PatchAll();
     }
 
-    // --- TEST COMMAND: Type 'testkill' in F5 console ---
+    private void InitCustomEnemies()
+    {
+        List<EnemyTemplate> templates = LoadTemplatesFromFolder();
+
+        foreach (var data in templates)
+        {
+            GameObject customEnemy = PrefabManager.Instance.CreateClonedPrefab(data.InternalName, data.PrefabToClone);
+
+            ApplyStats(customEnemy, data);
+            ApplyColorTint(customEnemy, data);
+            ApplyDropTable(customEnemy, data);
+            ApplyEquipment(customEnemy, data);
+
+            RegisterWithWorldSpawn(customEnemy, data);
+        }
+
+        PrefabManager.OnVanillaPrefabsAvailable -= InitCustomEnemies;
+    }
+
+    [HarmonyPatch(typeof(Localization), nameof(Localization.SetupLanguage))]
+    public static class Localization_SetupLanguage_Patch
+    {
+        public static void Postfix()
+        {
+            LoadLocalization();
+        }
+    }
+
     [HarmonyPatch(typeof(Terminal), nameof(Terminal.InputText))]
     public static class ConsoleInputPatch
     {
         static void Postfix(Terminal __instance)
         {
             string text = __instance.m_input.text;
-            if (text.ToLower() == "listiconsstore")
-            {
-                var spriteAsset = Resources.FindObjectsOfTypeAll<TMP_SpriteAsset>().FirstOrDefault(x => x.name == "store_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}");
-                    }
-                }
-            }
-
             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}");
-                    }
-                }
             }
         }
     }
@@ -124,19 +170,99 @@ public class MxValheimMod : BaseUnityPlugin
         static void Postfix()
         {
             if (ZRoutedRpc.instance != null && kfp != null)
-            {              
+            {
-                // We use the explicit 'Method' delegate to avoid the ArgumentException
                 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<ZPackage>("RPC_ServerAddDoorToQueue", Watcher.RegisterEvent);
-            }
+
+                ZRoutedRpc.instance.Register<ZPackage>("RPC_ServerRegisterEvent", Watcher.RegisterEvent);
+                ZRoutedRpc.instance.Register<ZPackage>("RPC_ServerGetEventKill", Watcher.GetEventKill);
+                ZRoutedRpc.instance.Register<ZPackage>("RPC_ServerSetEventKill", Watcher.SetEventKill);
+                ZRoutedRpc.instance.Register<ZPackage>("RPC_ServerRemoveEvent", Watcher.RemoveEvent);
+
+                ZRoutedRpc.instance.Register<int>("RPC_ServerRegisterEventKill", Profiles.ServerSetLevel);
+                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()
     {
-        // Use the game's native check for dedicated servers
+        // 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)
+        {
+            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 (initExpBar)
+                {
+                    string pid = GetUserPlayerID(Player.m_localPlayer).ToString();
+                    Experience.UpdateProgressBar();
+                    initExpBar = false;
+                }
+            }
+
+            if (Clock.m_textComponent != null)
+            {
+                Clock clk = new Clock();
+                string timeString = clk.GetFormattedTime();
+                int day = EnvMan.instance.GetDay();
+                string pid = GetUserPlayerID(Player.m_localPlayer).ToString();
+                RandomEvent activeEvent = RandEventSystem.instance.GetActiveEvent();
+                string separator = $"<color=#677074>][</color>";
+                if (activeEvent == null)
+                {
+                    Clock.m_textComponent.text = $"<color=#32a852>{Localization.instance.Localize("$clock_string_rank")}</color> <color=#ffd000>{Profiles.serverLevel}</color> {separator} <color=#32a852>{Localization.instance.Localize("$clock_string_day")}</color> <color=#ffd000>{day}</color> {separator} <color=#d1954a>{timeString}</color>";
+                } else
+                {
+                    Clock.m_textComponent.text = $"<color=#ffd000>{eventName}</color> {separator} <color=#32a852>{Localization.instance.Localize("$clock_string_kill")}</color> <color=#ffd000>{eventPoints}</color> {separator} <color=#32a852>{Localization.instance.Localize("$clock_string_rank")}</color> <color=#ffd000>{Profiles.serverLevel}</color> {separator} <color=#32a852>{Localization.instance.Localize("$clock_string_day")}</color> <color=#ffd000>{day}</color> {separator} <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 = 2;
+            }
+        }
+        // Door Logic
+        /////////////
+
+
+        // KillFeed Logic
         ZNet zn = new ZNet();
         if (zn.IsDedicated() || Player.m_localPlayer == null) return;
 
@@ -146,7 +272,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)
@@ -175,29 +301,92 @@ public class MxValheimMod : BaseUnityPlugin
 
             if (_displayTimer <= 0 && _hudRoot != null) _hudRoot.SetActive(false);
         }
-
+        // KillFeed Logic
+        /////////////////
     }
 
-    private bool LoadJsonConfig()
+    public static long GetUserPlayerID(Player player)
     {
-        try
+        return player.GetPlayerID();
-        {
+    }
-            if (!File.Exists(WeightConfigPath))
-            {
-                WeightSettings = new Dictionary<string, float> { { "Wood", 1.0f }, { "Stone", 1.0f } };
-                File.WriteAllText(WeightConfigPath, JsonConvert.SerializeObject(WeightSettings, Newtonsoft.Json.Formatting.Indented));
-                return true;
-            }
 
-            string json = File.ReadAllText(WeightConfigPath);
+    public static void LoadLocalization()
-            WeightSettings = JsonConvert.DeserializeObject<Dictionary<string, float>>(json);
+    {
-            Logger.LogInfo($"Successfully parsed {WeightSettings.Count} items.");
+        if (Localization.instance == null) return;
-            return true;
+
-        }
+        string modPath = Path.Combine(Paths.PluginPath, "MxValheim");
-        catch (Exception ex)
+        string translationsPath = Path.Combine(modPath, "Translations");
+        string lang = Localization.instance.GetSelectedLanguage();
+        string filePath = Path.Combine(translationsPath, $"{lang}.json");
+
+        if (!File.Exists(filePath))
         {
-            Logger.LogWarning($"Could not read JSON (might be busy): {ex.Message}");
+            filePath = Path.Combine(translationsPath, "English.json");
-            return false;
+        }
+
+        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}");
+            }
+        }
+    }
+
+    private void LoadJsonConfig()
+    {
+        string json = "";
+
+        if (!File.Exists(WeightConfigPath))
+        {
+            WeightSettings = new Dictionary<string, float> { { "Wood", 1.0f }, { "Stone", 1.0f } };
+            File.WriteAllText(WeightConfigPath, JsonConvert.SerializeObject(WeightSettings, Newtonsoft.Json.Formatting.Indented));
+        }
+
+        json = File.ReadAllText(WeightConfigPath);
+        WeightSettings = JsonConvert.DeserializeObject<Dictionary<string, float>>(json);
+        Logger.LogInfo($"Successfully parsed {WeightSettings.Count} items.");
+
+        if (!File.Exists(DropConfigPath))
+        {
+            DropSettings = new Dictionary<string, int> { { "Wood", 3 }, { "CopperOre", 3 }, { "TinOre", 3 }, { "IronScrap", 3 }, { "SilverOre", 3 }, { "Obsidian", 3 }, { "BlackMetalScrap", 3 }, { "BlackMarble", 3 }, { "FlametalOreNew", 3 } };
+            File.WriteAllText(DropConfigPath, JsonConvert.SerializeObject(DropSettings, Newtonsoft.Json.Formatting.Indented));
+        }
+
+        json = File.ReadAllText(DropConfigPath);
+        DropSettings = JsonConvert.DeserializeObject<Dictionary<string, int>>(json);
+        Logger.LogInfo($"Successfully parsed {DropSettings.Count} items.");
+    }
+
+    public void LoadDoorConfig()
+    {
+        if (File.Exists(AutoDoorConfigPath))
+        {
+            string json = System.IO.File.ReadAllText(AutoDoorConfigPath);
+            CachedConfig = JsonConvert.DeserializeObject<DoorRoot>(json);
         }
     }
 

MxValheim/MxValheim.csproj

@@ -9,10 +9,11 @@
     <AppDesignerFolder>Properties</AppDesignerFolder>
     <RootNamespace>MxValheim</RootNamespace>
     <AssemblyName>MxValheim</AssemblyName>
-    <TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
+    <TargetFrameworkVersion>v4.8.1</TargetFrameworkVersion>
     <LangVersion>12.0</LangVersion>
     <FileAlignment>512</FileAlignment>
     <Deterministic>true</Deterministic>
+    <TargetFrameworkProfile />
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
     <DebugSymbols>true</DebugSymbols>
@@ -35,19 +36,35 @@
     <Reference Include="0Harmony">
       <HintPath>E:\SteamLibrary\steamapps\common\Valheim\BepInEx\core\0Harmony.dll</HintPath>
     </Reference>
-    <Reference Include="Assembly-CSharp-publicized">
+    <Reference Include="assembly_googleanalytics">
-      <HintPath>E:\SteamLibrary\steamapps\common\Valheim\Valheim_Data\Managed\Assembly-CSharp-publicized.dll</HintPath>
+      <HintPath>E:\SteamLibrary\steamapps\common\Valheim\Valheim_Data\Managed\assembly_googleanalytics.dll</HintPath>
     </Reference>
-    <Reference Include="assembly_valheim-publicized">
+    <Reference Include="assembly_guiutils_publicized">
-      <HintPath>E:\SteamLibrary\steamapps\common\Valheim\Valheim_Data\Managed\assembly_valheim-publicized.dll</HintPath>
+      <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="EpicLoot">
+      <HintPath>E:\SteamLibrary\steamapps\common\Valheim\BepInEx\plugins\EpicLoot\EpicLoot.dll</HintPath>
+    </Reference>
+    <Reference Include="gui_framework">
+      <HintPath>E:\SteamLibrary\steamapps\common\Valheim\Valheim_Data\Managed\gui_framework.dll</HintPath>
+    </Reference>
+    <Reference Include="Jotunn">
+      <HintPath>E:\SteamLibrary\steamapps\common\Valheim\BepInEx\plugins\Jotunn.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" />
@@ -58,10 +75,20 @@
     <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.AIModule, Version=0.0.0.0, Culture=neutral, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>E:\SteamLibrary\steamapps\common\Valheim\Valheim_Data\Managed\UnityEngine.AIModule.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>
@@ -69,7 +96,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>
@@ -78,29 +107,50 @@
       <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\RandomUnique\SpawnManager.cs" />
+    <Compile Include="EventSystem\RandomUnique\UniqueManager.cs" />
+    <Compile Include="EventSystem\Reward.cs" />
+    <Compile Include="EventSystem\Watcher.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" />
     <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>
     <PostBuildEvent>
-copy /Y "$(TargetDir)$(TargetName).dll" "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\"
+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).dll" "R:\Server\valdev\BepInEx\plugins\MxValheim\"
-copy /Y "$(TargetDir)$(TargetName).pdb" "R:\Server\valdev\BepInEx\plugins\"</PostBuildEvent>
+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/CraftingStation.cs

@@ -17,7 +17,7 @@ namespace MxValheim.Patch
                 if (rangeField.FieldExists())
                 {
                     float currentRange = rangeField.GetValue<float>();
-                    rangeField.SetValue(currentRange * MxValheimMod.Config_rangeMultiplier.Value);
+                    rangeField.SetValue(currentRange * 1);
                 }
             }
         }

MxValheim/Patch/Doors.cs

@@ -1,55 +1,73 @@
 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
     {
-        [HarmonyPatch(typeof(Door), nameof(Door.Interact))]
+        public class DoorRoot
-        static class Door_Interact_Patch
         {
-            static void Postfix(Door __instance, Humanoid character, bool hold, bool alt, ZNetView ___m_nview)
+            public List<string> ignoreList { get; set; }
+        }
+
+        [HarmonyPatch(typeof(Door), nameof(Door.Interact))]
+        public static class DoorTracker
+        {
+            static void Postfix(Door __instance)
             {
                 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 (prefabName == "piece_crypt_door") return;
+                    if (MxValheimMod.CachedConfig?.ignoreList != null)
+                        if (MxValheimMod.CachedConfig.ignoreList.Contains(prefabName)) return;
 
-                    if (hold || alt || ___m_nview == null || !___m_nview.IsValid()) return;
+                    nview.ClaimOwnership();
 
                     // Get state: 0 is closed
-                    int state = ___m_nview.GetZDO().GetInt("state");
+                    int state = nview.GetZDO().GetInt("state");
 
-                    if (state != 0)
+                    if (state == 0) return;
+
+                    ZPackage pkg = new ZPackage();
+                    pkg.Write(nview);
+                    pkg.Write(__instance);
+                    pkg.Write(prefabName);
+
+                    lock (_doorQueueNview)
                     {
-                        // Start coroutine on the door object itself
+                        Debug.Log($"AutoDoor: Adding \"{prefabName}\" to queue.");
-                        __instance.StartCoroutine(CloseDoorAfterDelay(__instance, ___m_nview));
+                        _doorQueueNview.Enqueue(nview);
+                        _doorQueueDoor.Enqueue(__instance);
+                        _doorQueueName.Enqueue(prefabName);
                     }
-                }           
+                }
             }
 
-            static IEnumerator CloseDoorAfterDelay(Door door, ZNetView nview)
+        }
-            {
-                yield return new WaitForSeconds(MxValheimMod.Config_autoDoorClose.Value);
 
-                // Verify the door still exists and is still open before closing
+        public void CloseNextDoor(Door door, ZNetView nview, string doorName)
-                if (door != null && nview != null && nview.IsValid())
+        {
+            if (door != null && nview != null && nview.IsValid())
+            {
+                if (nview.GetZDO().GetInt("state") != 0)
                 {
-                    if (nview.GetZDO().GetInt("state") != 0)
+                    Debug.Log($"AutoDoor: Closing door \"{doorName}\".");
-                    {
+                    ZDO zd0 = nview.GetZDO();
-                        // Directly invoke the RPC with '0' (closed). 
+                    zd0.Set("state", 0);
-                        // This avoids the 'Null' player error in Door.Interact
+                } else
-                        ZDO zd0 = nview.GetZDO();
+                {
-                        zd0.Set("state", 0);
+                    Debug.Log($"AutoDoor: Door \"{doorName}\" was already closed.");
-                    }
                 }
             }
         }

MxValheim/Patch/HUD/Clock.cs

@@ -0,0 +1,120 @@
+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 Clock
+    {
+        public static GameObject m_canvasObject;
+        public static Text m_textComponent;
+        public static RectTransform m_barFill;
+
+        public string GetFormattedTime()
+        {
+            float fraction = EnvMan.instance.GetDayFraction();
+
+            float totalHours = fraction * 24f;
+            int hours = Mathf.FloorToInt(totalHours);
+            int minutes = Mathf.FloorToInt((totalHours - hours) * 60f);
+
+            return $"{hours:00}:{minutes:00}";
+        }
+
+        [HarmonyPatch(typeof(MessageHud), nameof(MessageHud.ShowMessage))]
+        public static class HideEventMessage_Patch
+        {
+            static bool Prefix(MessageHud.MessageType type, string text)
+            {
+                if (RandEventSystem.instance != null)
+                {
+                    RandomEvent activeEvent = RandEventSystem.instance.GetActiveEvent();
+                    if (activeEvent != null)
+                    {                      
+                        if (text == activeEvent.GetHudText())
+                        {
+                            return false;
+                        }
+                    }
+                }
+                return true;
+            }
+        }
+
+        public void CreateOverlay()
+        {
+            m_canvasObject = new GameObject("ModdedCanvas");
+            Canvas canvas = m_canvasObject.AddComponent<Canvas>();
+            canvas.renderMode = RenderMode.ScreenSpaceOverlay;
+            canvas.sortingOrder = 999;
+
+            GameObject panelObj = new GameObject("TextBackground");
+            panelObj.transform.SetParent(m_canvasObject.transform, false);
+            panelObj.AddComponent<Image>().color = new Color(0, 0, 0, 0.8f);
+
+            ContentSizeFitter fitter = panelObj.AddComponent<ContentSizeFitter>();
+            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);
+            panelRect.anchorMax = new Vector2(0.5f, 1.0f);
+            panelRect.pivot = new Vector2(0.5f, 1.0f);
+            panelRect.anchoredPosition = new Vector2(0, -5);
+
+            GameObject textObj = new GameObject("ModdedText");
+            textObj.transform.SetParent(panelObj.transform, false);
+            m_textComponent = textObj.AddComponent<Text>();
+
+            Font valheimFont = null;
+            foreach (Font f in Resources.FindObjectsOfTypeAll<Font>())
+            {
+                if (f.name == "AveriaSerifLibre-Bold")
+                {
+                    valheimFont = f;
+                    break;
+                }
+            }
+
+            if (valheimFont == null)
+            {
+                valheimFont = Resources.GetBuiltinResource<Font>("Arial.ttf");
+            }
+
+            m_textComponent.font = valheimFont;
+            m_textComponent.fontSize = 18;
+            m_textComponent.color = Color.white;
+
+            GameObject barBgObj = new GameObject("BarBackground");
+            barBgObj.transform.SetParent(m_canvasObject.transform, false);
+            barBgObj.AddComponent<Image>().color = new Color(0.1f, 0.1f, 0.1f, 0.8f);
+
+            RectTransform barBgRect = barBgObj.GetComponent<RectTransform>();
+            barBgRect.anchorMin = new Vector2(0.5f, 1.0f);
+            barBgRect.anchorMax = new Vector2(0.5f, 1.0f);
+            barBgRect.pivot = new Vector2(0.5f, 1.0f);
+            barBgRect.anchoredPosition = new Vector2(0, -45);
+            barBgRect.sizeDelta = new Vector2(180, 8);
+
+            // --- PROGRESS BAR FILL ---
+            GameObject fillObj = new GameObject("BarFill");
+            fillObj.transform.SetParent(barBgObj.transform, false);
+            fillObj.AddComponent<Image>().color = Color.yellow;
+
+            m_barFill = fillObj.GetComponent<RectTransform>();
+            m_barFill.anchorMin = new Vector2(0, 0);
+            m_barFill.anchorMax = new Vector2(0.5f, 1);
+            m_barFill.pivot = new Vector2(0, 0.5f);
+            m_barFill.offsetMin = Vector2.zero;
+            m_barFill.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);
+        }
+    }
+}

MxValheim/Patch/Ores.cs

@@ -14,17 +14,13 @@ namespace MxValheim.Patch
             {
                 if (__result == null || __result.Count == 0) return;
 
-                int countToAdd = MxValheimMod.Config_OreMultiplier.Value - 1;
-                if (countToAdd <= 0) return;
-
                 List<GameObject> extraDrops = new List<GameObject>();
 
                 foreach (var item in __result)
                 {
-                    string name = item.name.ToLower();
+                    if (item != null && MxValheimMod.DropSettings.TryGetValue(item.name, out int newDropMulti))
-                    if (name.Contains("ore") || name.Contains("scrap"))
                     {
-                        for (int i = 0; i < countToAdd; i++)
+                        for (int i = 0; i < newDropMulti; i++)
                         {
                             extraDrops.Add(item);
                         }

MxValheim/Patch/WearNTear.cs

@@ -10,8 +10,6 @@ namespace MxValheim.Patch
         {
             static void Postfix(WearNTear __instance, ref bool __result)
             {
-                if (!MxValheimMod.Config_rainDamage.Value) return;
-
                 __result = true;
             }
         }

README.md

@@ -1,11 +1,26 @@
-![logo](https://mxdev.ovh/wp-content/uploads/2025/09/mxdev-1.png)
+![logo](https://mxio.ovh/gaming/valheim/mxvalheim_valtint.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.**
+
+## Roadmap
+- **1.6.12** Revamped EventSystem Reward System based on enemy difficulty.
+- **1.6.13** Revamped Experience System based on enemy difficulty.
+- **1.7.x** Drop Multiplier Revamp & Stamina System Revamp
+- **1.8.x** Random Mini Boss System
+- **1.9.x** Biome Random Quest System
+
+## Dependencies
+- ![BepInEx for Valheim](https://thunderstore.io/c/valheim/p/denikson/BepInExPack_Valheim/)
+- ![Jotunn](https://thunderstore.io/c/valheim/p/ValheimModding/Jotunn/)
 
 ## 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.
-- Tweak individual item(s) weight in "BepInEx\config\mxvalheim.custom_weights.json".
+- Tweak individual item(s) weight in "BepInEx\plugins\MxValheim\Configs\items_weight.json".
 - Ore drop multiplier. (Value available in the generated config.)
 - Workbench crafting range multiplier. (Value available in the generated config.)
 - Reduce Bow draw time for each upgrade level. (Value available in the generated config.)
@@ -13,8 +28,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.
+1. Download the latest zip.
-2. Copy it to your (Client/Server) "BepInEx­\plugins".
+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!