RacesOfValheim/JotunnModStub/Skeleton/SkeletonPatches.cs
kanym 5ef7a102da fix(skeleton): make the progression real, and say so in the compendium
Four separate faults were behind one player report.

The tier table had drifted a long way from the published progression. Poison
immunity arrived at Bonemass instead of Eikthyr, auto-stun at The Queen instead
of The Elder, and lifesteal jumped 20/30/40 where the description promises a
climb in fives from 5% to 35%. Rewritten to match the description tier for tier,
which is the copy players actually read.

Poison immunity never worked even at the tier that granted it. SE_SkeletonStats
built its damage modifiers in Setup, which runs once when the effect is applied -
at spawn, before any boss has fallen - and nothing ever asked again, so the
modifiers stayed frozen at tier 1 for the whole session. Everything else the race
does re-reads the rules per hit, which is why only the modifiers looked broken.
They are now rebuilt when the tier actually changes.

Max health was whatever three scaled sausages happened to add up to. A Skeleton
cannot eat, so the race fakes three permanent foods to carry the tier bonus -
sound enough for regeneration, which Valheim drives off the food list, but the
number the game reads is Food.m_health, recomputed every second from the burn
curve, and anything that leaves those foods partly burnt or one short quietly
costs health. A Bonemass Skeleton had 95 where the table promises 165. The foods
stay for regeneration; the total is now overwritten at Player.GetTotalFoodValue,
which has exactly one caller and decides the number outright.

Skeleton Secrets was a one-line placeholder returning the same sentence at every
tier - never written rather than broken. It now unfolds tier by tier, and opens
by naming the standing the race believes it is on, so the next player who kills a
boss and sees nothing change can tell a tier that failed to advance from an
unlock that failed to fire.

The charred model moves from Fader to Moder, where the description asks for a
fire skeleton, and summons stay skeletons at both tiers rather than turning
charred at Fader. Both are one-line reverts if the old look is preferred.
2026-08-05 16:33:27 +02:00

568 lines
26 KiB
C#

using HarmonyLib;
using UnityEngine;
using Jotunn.Managers;
using System.Linq;
namespace RacesOfValheim
{
public static class SkeletonPatches
{
// Cache the skeleton mesh and materials for performance
private static Mesh skeletonMesh = null;
private static Material[] skeletonMaterials = null;
/// <summary>
/// Makes the Skeleton's max health exactly what its progression promises.
///
/// A Skeleton cannot eat, so SkeletonRace fakes three permanent foods whose values are
/// scaled to add up to the tier's bonus. That is a good way to keep food-based health
/// regeneration working - Valheim regenerates from the food list, so a Skeleton with no
/// food would never heal - but a bad way to land an exact number: the value the game reads
/// is Food.m_health, which UpdateFood recomputes every second as
/// Pow(remaining/burnTime, 0.3) * m_food, and anything that leaves those three foods
/// partly burnt, partly rebuilt or one short quietly costs health. A Bonemass-tier
/// Skeleton reported 95 max health where the table promises 25 + 140.
///
/// So the foods stay, for regeneration, and the total they feed into is overwritten here.
/// GetTotalFoodValue has exactly one caller, Player.UpdateFood, which passes the result
/// straight to SetMaxHealth - so this is the single point where the number is decided, and
/// it now comes from the progression table rather than from three scaled sausages.
/// </summary>
[HarmonyPatch(typeof(Player), "GetTotalFoodValue")]
public static class Player_GetTotalFoodValue_SkeletonHealth_Patch
{
public static void Postfix(Player __instance, ref float hp)
{
if (__instance != Player.m_localPlayer || !SkeletonRace.IsSkeleton()) return;
int state = BossProgressionManager.GetCurrentProgressionState();
hp = __instance.m_baseHP + SkeletonProgression.GetMaxHealthBonus(state);
}
}
[HarmonyPatch(typeof(Player), "UseStamina")]
public static class Player_UseStamina_Patch
{
public static bool Prefix(Player __instance)
{
if ((SkeletonRace.IsSkeleton() || AswidRace.IsAswid() || DraughRace.IsDraugh()) && __instance == Player.m_localPlayer)
{
// Infinite stamina: skip the original UseStamina method
return false;
}
return true;
}
}
[HarmonyPatch(typeof(Player), "ConsumeItem")]
public static class Player_ConsumeItem_Patch
{
public static bool Prefix(Player __instance, ItemDrop.ItemData item, ref bool __result)
{
if (__instance == Player.m_localPlayer)
{
if (SkeletonRace.IsSkeleton() && item.m_shared.m_itemType == ItemDrop.ItemData.ItemType.Consumable && (item.m_shared.m_food > 0 || item.m_shared.m_foodStamina > 0 || item.m_shared.m_foodEitr > 0))
{
__instance.Message(MessageHud.MessageType.Center, "Skeletons do not need to eat.");
__result = false;
return false;
}
else if (AswidRace.IsAswid() && !AswidRace.BypassAswidFoodCheck && item.m_shared.m_itemType == ItemDrop.ItemData.ItemType.Consumable && (item.m_shared.m_food > 0 || item.m_shared.m_foodStamina > 0 || item.m_shared.m_foodEitr > 0))
{
__instance.Message(MessageHud.MessageType.Center, "Mortal food disgusts you.");
__result = false;
return false;
}
}
return true;
}
}
[HarmonyPatch(typeof(MessageHud), "ShowMessage")]
public static class MessageHud_ShowMessage_Patch
{
private static System.Collections.Generic.Dictionary<string, System.Collections.Generic.List<float>> messageTimestamps = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.List<float>>();
private static System.Collections.Generic.Dictionary<string, float> messageBans = new System.Collections.Generic.Dictionary<string, float>();
public static bool Prefix(MessageHud __instance, MessageHud.MessageType type, string text)
{
if (Player.m_localPlayer != null && SkeletonRace.IsSkeleton())
{
if (string.IsNullOrEmpty(text)) return true;
// Exception for resting messages to never be filtered
string lowerText = text.ToLower();
if (text == "$se_resting_name" || text == "$se_resting" || lowerText.Contains("resting") || lowerText.Contains("riposo"))
{
return true;
}
float currentTime = Time.time;
// Check if message is currently banned (4 hours = 14400 seconds)
if (messageBans.TryGetValue(text, out float banTime))
{
if (currentTime - banTime < 14400f)
{
return false; // Still banned
}
else
{
messageBans.Remove(text); // Ban expired
if (messageTimestamps.ContainsKey(text))
{
messageTimestamps[text].Clear(); // Reset spam count
}
}
}
if (!messageTimestamps.ContainsKey(text))
{
messageTimestamps[text] = new System.Collections.Generic.List<float>();
}
// Remove timestamps older than 5 seconds
messageTimestamps[text].RemoveAll(t => currentTime - t > 5f);
if (messageTimestamps[text].Count >= 2)
{
// Trigger a 4-hour ban
messageBans[text] = currentTime;
return false;
}
messageTimestamps[text].Add(currentTime);
}
return true;
}
}
[HarmonyPatch(typeof(Player), "Message")]
public static class Player_Message_Patch
{
public static bool Prefix(Player __instance, MessageHud.MessageType type, string msg)
{
if (__instance == Player.m_localPlayer)
{
if (msg == "$msg_eatanother" || msg.ToLower().Contains("eat") || msg.ToLower().Contains("mangiare") || msg.ToLower().Contains("boccone"))
{
if (AswidRace.IsAswid())
{
return false;
}
}
}
return true;
}
}
[HarmonyPatch(typeof(Hud), "UpdateFood")]
public static class Hud_UpdateFood_Patch
{
private static readonly string[] foodElements = new string[]
{
"hudroot/healthpanel/foodicon",
"hudroot/healthpanel/foodicon (1)",
"hudroot/healthpanel/food0",
"hudroot/healthpanel/food1",
"hudroot/healthpanel/food2",
"hudroot/healthpanel/FoodText",
"hudroot/healthpanel/Food"
};
public static bool Prefix(Hud __instance, Player player)
{
try
{
if (player == Player.m_localPlayer && SkeletonRace.IsSkeleton())
{
if (__instance.m_foodBarRoot != null && __instance.m_foodBarRoot.gameObject.activeSelf)
{
__instance.m_foodBarRoot.gameObject.SetActive(false);
}
foreach (string path in foodElements)
{
Transform t = __instance.transform.Find(path);
if (t != null && t.gameObject.activeSelf)
{
t.gameObject.SetActive(false);
}
}
return false; // Safely skip original Valheim Hud.UpdateFood
}
else
{
if (__instance.m_foodBarRoot != null && !__instance.m_foodBarRoot.gameObject.activeSelf)
{
__instance.m_foodBarRoot.gameObject.SetActive(true);
}
foreach (string path in foodElements)
{
Transform t = __instance.transform.Find(path);
if (t != null && !t.gameObject.activeSelf)
{
t.gameObject.SetActive(true);
}
}
return true;
}
}
catch (System.Exception e)
{
if (player == Player.m_localPlayer && SkeletonRace.IsSkeleton()) return false;
return true;
}
}
}
[HarmonyPatch(typeof(VisEquipment), "UpdateVisuals")]
public static class VisEquipment_UpdateVisuals_Patch
{
public static void Postfix(VisEquipment __instance)
{
if (!__instance.m_isPlayer) return;
Player p = __instance.GetComponent<Player>();
if (p == null) return;
ZNetView nview = p.GetComponent<ZNetView>();
if (nview == null || !nview.IsValid()) return;
string race = nview.GetZDO().GetString("RacesOfValheim_Race", "Human");
if (race == "Skeleton")
{
if (__instance.m_bodyModel != null)
{
// Ensure the base model is hidden
__instance.m_bodyModel.enabled = false;
int state = nview.GetZDO().GetInt("RacesOfValheim_SkeletonState", 0);
SkeletonProgression.SkeletonRules rules = SkeletonProgression.GetRules(state);
string targetBodyName = $"SkeletonBody_{rules.ModelPrefab}";
// Check if we already created the Skeleton body for this VisEquipment
Transform parentTransform = __instance.m_bodyModel.transform.parent;
// Destroy old bodies if state changed
for (int i = parentTransform.childCount - 1; i >= 0; i--)
{
Transform child = parentTransform.GetChild(i);
if (child.name.StartsWith("SkeletonBody") && child.name != targetBodyName)
{
UnityEngine.Object.Destroy(child.gameObject);
}
}
Transform skeletonBodyTransform = parentTransform.Find(targetBodyName);
if (skeletonBodyTransform == null)
{
GameObject skelPrefab = PrefabManager.Cache.GetPrefab<GameObject>(rules.ModelPrefab);
if (skelPrefab != null)
{
GameObject skelObj = new GameObject(targetBodyName);
skelObj.transform.SetParent(parentTransform, false);
SkinnedMeshRenderer[] smrs = skelPrefab.GetComponentsInChildren<SkinnedMeshRenderer>(true);
foreach (SkinnedMeshRenderer smr in smrs)
{
GameObject partObj = UnityEngine.Object.Instantiate(smr.gameObject, skelObj.transform);
partObj.name = smr.gameObject.name;
SkinnedMeshRenderer newSmr = partObj.GetComponent<SkinnedMeshRenderer>();
// Map bones by name
Transform[] playerBones = __instance.m_bodyModel.bones;
Transform[] newBones = new Transform[newSmr.bones.Length];
for (int i = 0; i < newSmr.bones.Length; i++)
{
Transform matchedBone = FindBoneByName(playerBones, newSmr.bones[i].name);
newBones[i] = matchedBone != null ? matchedBone : playerBones[0];
}
newSmr.bones = newBones;
if (newSmr.rootBone != null)
{
newSmr.rootBone = FindBoneByName(playerBones, newSmr.rootBone.name) ?? playerBones[0];
}
}
skeletonBodyTransform = skelObj.transform;
}
}
if (skeletonBodyTransform != null)
{
skeletonBodyTransform.gameObject.SetActive(true);
}
// Prevent Animator from freezing when body is disabled
Animator anim = __instance.GetComponentInChildren<Animator>();
if (anim != null)
{
anim.cullingMode = AnimatorCullingMode.AlwaysAnimate;
}
HideItemInstances(__instance, "m_hairItemInstances");
HideItemInstances(__instance, "m_beardItemInstances");
}
}
else
{
// Not a skeleton, ensure human body is visible and skeleton is hidden
if (__instance.m_bodyModel != null)
{
__instance.m_bodyModel.enabled = true;
Transform parentTransform = __instance.m_bodyModel.transform.parent;
if (parentTransform != null)
{
for (int i = 0; i < parentTransform.childCount; i++)
{
Transform child = parentTransform.GetChild(i);
if (child.name.StartsWith("SkeletonBody"))
{
child.gameObject.SetActive(false);
}
}
}
ShowItemInstances(__instance, "m_hairItemInstances");
ShowItemInstances(__instance, "m_beardItemInstances");
}
}
}
private static void HideItemInstances(VisEquipment visEq, string fieldName)
{
try
{
var field = typeof(VisEquipment).GetField(fieldName, System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
if (field != null)
{
var list = field.GetValue(visEq) as System.Collections.Generic.List<GameObject>;
if (list != null)
{
foreach (GameObject go in list)
{
if (go != null) go.SetActive(false);
}
}
}
}
catch (System.Exception e)
{
Jotunn.Logger.LogWarning($"Failed to hide {fieldName}: {e.Message}");
}
}
private static void ShowItemInstances(VisEquipment visEq, string fieldName)
{
try
{
var field = typeof(VisEquipment).GetField(fieldName, System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
if (field != null)
{
var list = field.GetValue(visEq) as System.Collections.Generic.List<GameObject>;
if (list != null)
{
foreach (GameObject go in list)
{
if (go != null) go.SetActive(true);
}
}
}
}
catch (System.Exception e) { }
}
private static Transform FindBoneByName(Transform[] bones, string skelBoneName)
{
// Exact match first
foreach (Transform b in bones)
{
if (b != null && b.name == skelBoneName) return b;
}
// Fuzzy match
string sName = skelBoneName.ToLower().Replace("skeleton_", "").Replace("skel_", "").Replace(" skeleton", "");
// Some specific Valheim mappings if needed
if (sName == "pelvis") sName = "hips";
if (sName == "clavicle.l") sName = "leftshoulder";
if (sName == "clavicle.r") sName = "rightshoulder";
if (sName == "upperarm.l") sName = "leftarm";
if (sName == "upperarm.r") sName = "rightarm";
if (sName == "lowerarm.l") sName = "leftforearm";
if (sName == "lowerarm.r") sName = "rightforearm";
if (sName == "thigh.l") sName = "leftupleg";
if (sName == "thigh.r") sName = "rightupleg";
if (sName == "calf.l") sName = "leftleg";
if (sName == "calf.r") sName = "rightleg";
foreach (Transform b in bones)
{
if (b != null)
{
string pName = b.name.ToLower();
if (pName == sName || pName.Contains(sName) || sName.Contains(pName))
{
return b;
}
}
}
return null;
}
}
[HarmonyPatch(typeof(Character), "Damage")]
public static class Character_Damage_Patch
{
private static float lastStunTime = 0f;
public static bool Prefix(Character __instance, HitData hit)
{
if (Player.m_localPlayer == null) return true;
int state = BossProgressionManager.GetCurrentProgressionState();
var rules = SkeletonProgression.GetRules(state);
// Auto-Resurrect check
if (__instance == Player.m_localPlayer && SkeletonRace.IsSkeleton() && rules.AutoResurrect)
{
if (hit.GetTotalDamage() >= __instance.GetHealth())
{
if (!Player.m_localPlayer.GetSEMan().HaveStatusEffect("SE_SkeletonResurrectCooldown".GetStableHashCode()))
{
// Cancel death!
Player.m_localPlayer.Heal(Player.m_localPlayer.GetMaxHealth(), true);
Player.m_localPlayer.GetSEMan().AddStatusEffect("SE_SkeletonResurrectCooldown".GetStableHashCode(), true);
// Spawn VFX
GameObject vfx = PrefabManager.Cache.GetPrefab<GameObject>("vfx_skeleton_spawn") ??
PrefabManager.Cache.GetPrefab<GameObject>("vfx_bloodmagic_aoe");
if (vfx != null)
{
UnityEngine.Object.Instantiate(vfx, Player.m_localPlayer.transform.position, Quaternion.identity);
}
Player.m_localPlayer.Message(MessageHud.MessageType.Center, "You have been resurrected by dark magic!");
return false; // Skip applying this lethal damage
}
}
}
// Outgoing damage (Lifesteal, Poison, Stun)
Character attacker = hit.GetAttacker();
if (attacker != null && attacker == Player.m_localPlayer && SkeletonRace.IsSkeleton())
{
// Auto Stun
if (rules.AutoStunFirstHit && Time.time - lastStunTime > 5f)
{
hit.m_staggerMultiplier = 100f; // Force stagger
lastStunTime = Time.time;
}
// Poison Attacks
if (rules.PoisonAttacks)
{
hit.m_damage.m_poison += 20f; // Add flat 20 poison damage
}
// Lifesteal
if (rules.LifestealPercent > 0f)
{
float physDamage = hit.m_damage.m_blunt + hit.m_damage.m_slash + hit.m_damage.m_pierce;
if (physDamage > 0)
{
float healAmount = physDamage * rules.LifestealPercent;
Player.m_localPlayer.Heal(healAmount, true);
}
}
}
return true;
}
}
[HarmonyPatch(typeof(Character), "OnDeath")]
public static class Character_OnDeath_Patch
{
public static System.Collections.Generic.List<Character> activeMinions = new System.Collections.Generic.List<Character>();
public static void Prefix(Character __instance)
{
if (Player.m_localPlayer == null || !SkeletonRace.IsSkeleton()) return;
HitData lastHit = HarmonyLib.Traverse.Create(__instance).Field("m_lastHit").GetValue<HitData>();
if (lastHit != null && lastHit.GetAttacker() == Player.m_localPlayer)
{
int state = BossProgressionManager.GetCurrentProgressionState();
var rules = SkeletonProgression.GetRules(state);
if (rules.SummonOnKill && !string.IsNullOrEmpty(rules.SummonPrefab))
{
// Clean up dead minions
activeMinions.RemoveAll(m => m == null || m.IsDead());
if (activeMinions.Count < rules.MaxSummons)
{
GameObject minionPrefab = PrefabManager.Cache.GetPrefab<GameObject>(rules.SummonPrefab);
if (minionPrefab != null)
{
GameObject minion = UnityEngine.Object.Instantiate(minionPrefab, __instance.transform.position, Quaternion.identity);
Character minionChar = minion.GetComponent<Character>();
if (minionChar != null)
{
// Make it friendly
minionChar.m_faction = Character.Faction.Players;
BaseAI ai = minion.GetComponent<BaseAI>();
if (ai != null)
{
MonsterAI monsterAI = minion.GetComponent<MonsterAI>();
if (monsterAI != null)
{
monsterAI.SetFollowTarget(Player.m_localPlayer.gameObject);
}
}
activeMinions.Add(minionChar);
}
}
}
}
}
}
}
[HarmonyPatch(typeof(BaseAI), "IsEnemy", typeof(Character), typeof(Character))]
public static class BaseAI_IsEnemy_Patch
{
public static void Postfix(Character a, Character b, ref bool __result)
{
if (!__result || !SkeletonRace.IsSkeleton() || Player.m_localPlayer == null) return;
Character playerChar = Player.m_localPlayer;
Character otherChar = null;
if (a == playerChar) otherChar = b;
else if (b == playerChar) otherChar = a;
if (otherChar != null)
{
string name = otherChar.gameObject.name.Replace("(Clone)", "").ToLower();
if (name == "skeleton" ||
name == "skeleton_noarcher" ||
name == "skeleton_poison" ||
name == "skeleton_friendly" ||
name.StartsWith("draugr") ||
name == "ghost" ||
name == "wraith")
{
__result = false;
}
}
}
}
}
}