Version bumped in manifest.json, the packaging manifest and PluginVersion. Valheim 1.0's new creatures for the Aswid and the Draugh (seal, moose, Elaking, Jotun, Barka, Deep North Goblin and every Dvergr), the Elaking Hair Bundle in the blood refinery, and the Skeleton choosing its look at the barber. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
513 lines
23 KiB
C#
513 lines
23 KiB
C#
using UnityEngine;
|
|
using Jotunn.Managers;
|
|
using Jotunn.Entities;
|
|
using System.Collections.Generic;
|
|
|
|
namespace RacesOfValheim
|
|
{
|
|
public class SkeletonRace : MonoBehaviour
|
|
{
|
|
public static SkeletonRace Instance;
|
|
public static SE_SkeletonStats skeletonStatsSE;
|
|
|
|
private void Awake()
|
|
{
|
|
Instance = this;
|
|
}
|
|
|
|
public void CreateModAssets()
|
|
{
|
|
// The bone pile and its garrison. Registered here because the faction merchant catalogue
|
|
// resolves its entries by prefab name, so the two cursed skulls have to exist before a
|
|
// Skeleton is ever set up as a bench.
|
|
SkeletonBonePile.Register();
|
|
|
|
var se = ScriptableObject.CreateInstance<SE_SkeletonStats>();
|
|
se.name = "SE_SkeletonStats";
|
|
se.m_name = "$rov_se_skeleton_stats_name";
|
|
|
|
// Icon
|
|
GameObject skelTrophy = PrefabManager.Cache.GetPrefab<ItemDrop>("TrophySkeleton")?.gameObject;
|
|
if (skelTrophy != null)
|
|
{
|
|
ItemDrop trophyDrop = skelTrophy.GetComponent<ItemDrop>();
|
|
if (trophyDrop != null && trophyDrop.m_itemData.m_shared.m_icons.Length > 0)
|
|
{
|
|
se.m_icon = trophyDrop.m_itemData.m_shared.m_icons[0];
|
|
}
|
|
}
|
|
|
|
CustomStatusEffect skeletonStats = new CustomStatusEffect(se, fixReference: false);
|
|
ItemManager.Instance.AddStatusEffect(skeletonStats);
|
|
skeletonStatsSE = skeletonStats.StatusEffect as SE_SkeletonStats;
|
|
|
|
var resurrectSE = ScriptableObject.CreateInstance<SE_SkeletonResurrectCooldown>();
|
|
resurrectSE.name = "SE_SkeletonResurrectCooldown";
|
|
CustomStatusEffect customResurrectSE = new CustomStatusEffect(resurrectSE, fixReference: false);
|
|
ItemManager.Instance.AddStatusEffect(customResurrectSE);
|
|
}
|
|
|
|
public static bool IsSkeleton()
|
|
{
|
|
return Player.m_localPlayer != null &&
|
|
Player.m_localPlayer.m_customData.ContainsKey("Race") &&
|
|
Player.m_localPlayer.m_customData["Race"] == "Skeleton";
|
|
}
|
|
|
|
private static readonly int StatsEffectHash = "SE_SkeletonStats".GetStableHashCode();
|
|
|
|
private float lastAuraTime = 0f;
|
|
private GameObject fireAuraVFX = null;
|
|
|
|
// The local player's burning skull. The build lives in SkeletonVisuals so that
|
|
// RacesVisualController can grow the same one on every remote skeleton - this script only
|
|
// ever sees the player at the keyboard, which is why nobody else could see the fire.
|
|
private readonly SkeletonVisuals.HeadFlame headFlame = new SkeletonVisuals.HeadFlame();
|
|
|
|
private static List<ItemDrop.ItemData>[] cachedRealFoods = new List<ItemDrop.ItemData>[9];
|
|
|
|
private List<ItemDrop.ItemData> GetBestRealFoods(int state)
|
|
{
|
|
if (state < 1) state = 1;
|
|
if (state > 8) state = 8;
|
|
if (cachedRealFoods[state] != null) return cachedRealFoods[state];
|
|
|
|
if (ObjectDB.instance == null || ObjectDB.instance.m_items == null) return null;
|
|
|
|
float targetHealth = SkeletonProgression.GetMaxHealthBonus(state);
|
|
|
|
List<ItemDrop.ItemData> allFoods = new List<ItemDrop.ItemData>();
|
|
foreach (GameObject obj in ObjectDB.instance.m_items)
|
|
{
|
|
ItemDrop drop = obj.GetComponent<ItemDrop>();
|
|
if (drop != null && drop.m_itemData != null && drop.m_itemData.m_shared.m_itemType == ItemDrop.ItemData.ItemType.Consumable && drop.m_itemData.m_shared.m_food > 0)
|
|
{
|
|
allFoods.Add(drop.m_itemData);
|
|
}
|
|
}
|
|
|
|
if (allFoods.Count < 3) return null;
|
|
|
|
float bestDiff = float.MaxValue;
|
|
float bestRegen = -1f;
|
|
List<ItemDrop.ItemData> bestCombo = null;
|
|
|
|
if (state == 8)
|
|
{
|
|
ItemDrop.ItemData f1 = null, f2 = null, f3 = null;
|
|
foreach(var drop in allFoods)
|
|
{
|
|
string n = drop.m_shared.m_name.ToLower();
|
|
string p = drop.m_dropPrefab != null ? drop.m_dropPrefab.name.ToLower() : "";
|
|
|
|
if (f1 == null && ((n.Contains("asksvin") && n.Contains("tail")) || (p.Contains("asksvin") && p.Contains("tail")))) f1 = drop;
|
|
else if (f2 == null && ((n.Contains("mashed") && n.Contains("meat")) || (p.Contains("mashed") && p.Contains("meat")))) f2 = drop;
|
|
else if (f3 == null && ((n.Contains("piquant") && n.Contains("pie")) || (p.Contains("piquant") && p.Contains("pie")))) f3 = drop;
|
|
}
|
|
|
|
if (f1 != null && f2 != null && f3 != null)
|
|
{
|
|
bestCombo = new List<ItemDrop.ItemData> { f1.Clone(), f2.Clone(), f3.Clone() };
|
|
}
|
|
}
|
|
|
|
if (bestCombo == null)
|
|
{
|
|
for (int i = 0; i < allFoods.Count; i++)
|
|
{
|
|
for (int j = i; j < allFoods.Count; j++)
|
|
{
|
|
for (int k = j; k < allFoods.Count; k++)
|
|
{
|
|
var f1 = allFoods[i];
|
|
var f2 = allFoods[j];
|
|
var f3 = allFoods[k];
|
|
|
|
float hpSum = f1.m_shared.m_food + f2.m_shared.m_food + f3.m_shared.m_food;
|
|
float regenSum = f1.m_shared.m_foodRegen + f2.m_shared.m_foodRegen + f3.m_shared.m_foodRegen;
|
|
|
|
float diff = Mathf.Abs(hpSum - targetHealth);
|
|
|
|
if (diff < bestDiff || (Mathf.Abs(diff - bestDiff) < 0.1f && regenSum > bestRegen))
|
|
{
|
|
bestDiff = diff;
|
|
bestRegen = regenSum;
|
|
bestCombo = new List<ItemDrop.ItemData> { f1.Clone(), f2.Clone(), f3.Clone() };
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (bestCombo != null)
|
|
{
|
|
float actualSum = 0f;
|
|
foreach(var c in bestCombo) actualSum += c.m_shared.m_food;
|
|
|
|
float scale = actualSum > 0f ? (targetHealth / actualSum) : 1f;
|
|
|
|
foreach(var c in bestCombo)
|
|
{
|
|
c.m_shared = (ItemDrop.ItemData.SharedData)typeof(object).GetMethod("MemberwiseClone", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic).Invoke(c.m_shared, null);
|
|
|
|
// Modificatore per scalare perfettamente gli HP
|
|
c.m_shared.m_food = c.m_shared.m_food * scale;
|
|
|
|
// Azzerare completamente l'Eitr e la Stamina
|
|
c.m_shared.m_foodEitr = 0f;
|
|
c.m_shared.m_foodStamina = 0f;
|
|
|
|
c.m_shared.m_foodBurnTime = 999999f;
|
|
}
|
|
}
|
|
|
|
cachedRealFoods[state] = bestCombo;
|
|
return bestCombo;
|
|
}
|
|
|
|
private void DumpTransformHierarchy(Transform t, string indent)
|
|
{
|
|
if (t == null) return;
|
|
Jotunn.Logger.LogInfo(indent + t.name + " (Active: " + t.gameObject.activeSelf + ")");
|
|
for(int i = 0; i < t.childCount; i++)
|
|
{
|
|
DumpTransformHierarchy(t.GetChild(i), indent + " ");
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// F8 debug: fires a ray from the camera and logs whatever it hits. Cosmetic pieces
|
|
/// (hair, beard, helmet) carry no collider, so this mostly confirms terrain/creature hits
|
|
/// - LogHeadCosmeticsState below is what actually answers "what is that floating chunk."
|
|
/// Kept anyway because it is the general-purpose "what am I looking at" tool for any other
|
|
/// bone or prefab placement question that comes up later.
|
|
/// </summary>
|
|
private void LogRaycastHit()
|
|
{
|
|
Camera cam = Camera.main;
|
|
if (cam == null)
|
|
{
|
|
Jotunn.Logger.LogInfo("[F8] No camera found for raycast.");
|
|
return;
|
|
}
|
|
|
|
Ray ray = new Ray(cam.transform.position, cam.transform.forward);
|
|
if (Physics.Raycast(ray, out RaycastHit hit, 50f))
|
|
{
|
|
Jotunn.Logger.LogInfo("--- F8 RAYCAST HIT ---");
|
|
Jotunn.Logger.LogInfo($"Collider: '{hit.collider.gameObject.name}' at {hit.point:F2}, distance={hit.distance:F2}");
|
|
Jotunn.Logger.LogInfo($"Full path: {GetFullPath(hit.collider.transform)}");
|
|
Renderer renderer = hit.collider.GetComponentInParent<Renderer>();
|
|
if (renderer != null)
|
|
{
|
|
Jotunn.Logger.LogInfo($"Nearest renderer: '{renderer.gameObject.name}' ({renderer.GetType().Name}), enabled={renderer.enabled}, scale={renderer.transform.lossyScale:F3}");
|
|
}
|
|
Jotunn.Logger.LogInfo("----------------------");
|
|
}
|
|
else
|
|
{
|
|
Jotunn.Logger.LogInfo("[F8] Raycast hit nothing within 50m (cosmetic pieces usually have no collider anyway).");
|
|
}
|
|
}
|
|
|
|
private static string GetFullPath(Transform t)
|
|
{
|
|
string path = t.name;
|
|
for (Transform parent = t.parent; parent != null; parent = parent.parent)
|
|
{
|
|
path = parent.name + "/" + path;
|
|
}
|
|
return path;
|
|
}
|
|
|
|
/// <summary>
|
|
/// F8 debug: dumps the exact state of the three item slots this race hides (hair, beard,
|
|
/// helmet) - active flag, renderer enabled flag and scale for every renderer underneath.
|
|
/// This is the direct answer to "what is still visible and why": a chunk that survives
|
|
/// hiding will show up here as active=true, or as a renderer with enabled=true even while
|
|
/// its wrapper is scaled to zero (the skinned-mesh case scale alone cannot hide).
|
|
/// </summary>
|
|
private void LogHeadCosmeticsState()
|
|
{
|
|
if (Player.m_localPlayer == null) return;
|
|
VisEquipment vis = Player.m_localPlayer.GetComponent<VisEquipment>();
|
|
if (vis == null) return;
|
|
|
|
Jotunn.Logger.LogInfo("--- F8 SKELETON HEAD COSMETICS ---");
|
|
DumpItemInstanceField(vis, "m_hairItemInstance");
|
|
DumpItemInstanceField(vis, "m_beardItemInstance");
|
|
DumpItemInstanceField(vis, "m_helmetItemInstance");
|
|
Jotunn.Logger.LogInfo("----------------------------------");
|
|
}
|
|
|
|
private static void DumpItemInstanceField(VisEquipment vis, string fieldName)
|
|
{
|
|
GameObject go = HarmonyLib.Traverse.Create(vis).Field<GameObject>(fieldName).Value;
|
|
if (go == null)
|
|
{
|
|
Jotunn.Logger.LogInfo($"[F8] {fieldName}: null (nothing equipped/instantiated).");
|
|
return;
|
|
}
|
|
|
|
Jotunn.Logger.LogInfo($"[F8] {fieldName}: '{go.name}' active={go.activeSelf} scale={go.transform.localScale:F3}");
|
|
foreach (Renderer r in go.GetComponentsInChildren<Renderer>(true))
|
|
{
|
|
Jotunn.Logger.LogInfo($"[F8] renderer '{r.gameObject.name}' ({r.GetType().Name}) enabled={r.enabled}");
|
|
}
|
|
}
|
|
|
|
private void Update()
|
|
{
|
|
if (Input.GetKeyDown(KeyCode.F8))
|
|
{
|
|
if (Hud.instance != null)
|
|
{
|
|
Jotunn.Logger.LogInfo("--- HUD HIERARCHY DUMP ---");
|
|
DumpTransformHierarchy(Hud.instance.transform, "");
|
|
Jotunn.Logger.LogInfo("--------------------------");
|
|
}
|
|
|
|
LogRaycastHit();
|
|
LogHeadCosmeticsState();
|
|
}
|
|
|
|
if (Player.m_localPlayer == null) return;
|
|
|
|
if (!IsSkeleton() || Player.m_localPlayer.IsDead())
|
|
{
|
|
// Everything the race puts on the player has to come off here, because this is the
|
|
// only path taken once they stop being one. A Fader-tier Skeleton who reset to
|
|
// Human kept a burning skull and a collapsed jaw, since neither the flame nor the
|
|
// jaw was ever switched back from outside the Skeleton branch below.
|
|
SkeletonVisuals.EnsureFireAura(Player.m_localPlayer, false, ref fireAuraVFX);
|
|
headFlame.Apply(Player.m_localPlayer, false);
|
|
RestoreJawBone();
|
|
|
|
if (Player.m_localPlayer.transform.localScale != Vector3.one)
|
|
{
|
|
Player.m_localPlayer.transform.localScale = Vector3.one;
|
|
}
|
|
return;
|
|
}
|
|
|
|
// Force hide hair and beard
|
|
var profile = Game.instance?.GetPlayerProfile();
|
|
if (profile != null)
|
|
{
|
|
var hair = HarmonyLib.Traverse.Create(profile).Field<string>("m_hairItem");
|
|
var beard = HarmonyLib.Traverse.Create(profile).Field<string>("m_beardItem");
|
|
|
|
if (!string.IsNullOrEmpty(hair.Value) || !string.IsNullOrEmpty(beard.Value))
|
|
{
|
|
hair.Value = "";
|
|
beard.Value = "";
|
|
|
|
HarmonyLib.Traverse.Create(Player.m_localPlayer).Field("m_hairItem").SetValue("");
|
|
HarmonyLib.Traverse.Create(Player.m_localPlayer).Field("m_beardItem").SetValue("");
|
|
|
|
VisEquipment vis = Player.m_localPlayer.GetComponent<VisEquipment>();
|
|
if (vis != null)
|
|
{
|
|
// Since Valheim 1.0 these take an item hash, not a prefab name. 0 is the empty slot.
|
|
vis.SetHairItem(0);
|
|
vis.SetBeardItem(0);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Undead Fortitude carries every one of the race's damage modifiers - the pierce and
|
|
// slash resistance, the weakness to blunt, and the poison immunity. It was applied in
|
|
// exactly one place: the moment the player clicked "Skeleton" in the race menu. Status
|
|
// effects are not saved with a character and do not survive death, so from the next
|
|
// respawn or the next login onward a Skeleton had none of them, which is why poison
|
|
// still landed at tiers that grant immunity. Put it back whenever it is missing.
|
|
if (!Player.m_localPlayer.GetSEMan().HaveStatusEffect(StatsEffectHash))
|
|
{
|
|
Player.m_localPlayer.GetSEMan().AddStatusEffect(StatsEffectHash, true);
|
|
}
|
|
|
|
int state = BossProgressionManager.GetCurrentProgressionState();
|
|
var rules = SkeletonProgression.GetRules(state);
|
|
|
|
// Continuously adjust equipment
|
|
VisEquipment currentVis = Player.m_localPlayer.GetComponent<VisEquipment>();
|
|
if (currentVis != null)
|
|
{
|
|
// Hide Helmets (Valheim uses singular GameObject for helmet)
|
|
var helmetObj = HarmonyLib.Traverse.Create(currentVis).Field<GameObject>("m_helmetItemInstance").Value;
|
|
SkeletonVisuals.SetEquipmentPieceHidden(helmetObj, true);
|
|
|
|
// Scale Body Armor (Chest, Legs, Shoulder) by 5%
|
|
string[] armorFields = { "m_chestItemInstances", "m_legItemInstances", "m_shoulderItemInstances" };
|
|
foreach (string field in armorFields)
|
|
{
|
|
var armorList = HarmonyLib.Traverse.Create(currentVis).Field<System.Collections.Generic.List<GameObject>>(field).Value;
|
|
if (armorList != null)
|
|
{
|
|
foreach (GameObject armor in armorList)
|
|
{
|
|
if (armor != null && Mathf.Abs(armor.transform.localScale.x - 1.05f) > 0.01f)
|
|
{
|
|
armor.transform.localScale = new Vector3(1.05f, 1.05f, 1.05f);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Fader used to collapse this bone, because the charred twitcher it wore there carried
|
|
// a jaw of its own and the two doubled up. That model is gone from every tier now, and
|
|
// the skeleton worn in its place has a jaw that belongs on the face - so the tier lost
|
|
// its mandible for no reason at all. Kept as a restore so anyone left with a collapsed
|
|
// jaw by the old build gets it back.
|
|
RestoreJawBone();
|
|
|
|
// Apply Scale
|
|
Vector3 targetScale = rules.ScaleMultiplier;
|
|
if (Player.m_localPlayer.transform.localScale != targetScale)
|
|
{
|
|
Player.m_localPlayer.transform.localScale = targetScale;
|
|
}
|
|
|
|
// Ensure ZDO is synced for visuals
|
|
ZNetView nview = Player.m_localPlayer.GetComponent<ZNetView>();
|
|
if (nview != null && nview.IsValid())
|
|
{
|
|
nview.GetZDO().Set("RacesOfValheim_SkeletonState", state);
|
|
|
|
// The saved look goes on the ZDO so everyone else sees the same body.
|
|
Player.m_localPlayer.m_customData.TryGetValue(SkeletonVisuals.LookDataKey, out string savedLook);
|
|
savedLook = savedLook ?? "";
|
|
if (nview.GetZDO().GetString(SkeletonVisuals.LookZdoKey, "") != savedLook)
|
|
{
|
|
nview.GetZDO().Set(SkeletonVisuals.LookZdoKey, savedLook);
|
|
}
|
|
}
|
|
|
|
// Manage Fake Foods
|
|
var foods = Player.m_localPlayer.GetFoods();
|
|
bool needsFood = false;
|
|
|
|
if (foods.Count != 3)
|
|
{
|
|
needsFood = true;
|
|
}
|
|
else
|
|
{
|
|
foreach(var food in foods)
|
|
{
|
|
food.m_time = 0f; // Always reset time so they never degrade!
|
|
}
|
|
|
|
float expectedHp = 0f;
|
|
var expectedFoods = GetBestRealFoods(state);
|
|
if (expectedFoods != null)
|
|
{
|
|
foreach(var f in expectedFoods) expectedHp += f.m_shared.m_food;
|
|
}
|
|
|
|
float currentHp = 0f;
|
|
foreach(var food in foods)
|
|
{
|
|
if (food.m_item != null && food.m_item.m_shared != null)
|
|
currentHp += food.m_item.m_shared.m_food;
|
|
}
|
|
|
|
if (Mathf.Abs(currentHp - expectedHp) > 1f)
|
|
{
|
|
needsFood = true;
|
|
}
|
|
}
|
|
|
|
if (needsFood)
|
|
{
|
|
Player.m_localPlayer.ClearFood();
|
|
var newDiet = GetBestRealFoods(state);
|
|
if (newDiet != null)
|
|
{
|
|
foreach (var dietItem in newDiet)
|
|
{
|
|
Player.Food newFood = new Player.Food();
|
|
newFood.m_name = dietItem.m_dropPrefab != null ? dietItem.m_dropPrefab.name : "";
|
|
newFood.m_item = dietItem;
|
|
newFood.m_health = dietItem.m_shared.m_food;
|
|
newFood.m_stamina = dietItem.m_shared.m_foodStamina;
|
|
newFood.m_eitr = dietItem.m_shared.m_foodEitr;
|
|
newFood.m_time = 0f;
|
|
foods.Add(newFood);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Enhanced Health Regeneration. The multiplier itself now lives on the status effect,
|
|
// which sets it on the live instance - writing it here only ever reached the template
|
|
// SEMan clones from, so it changed nothing for the player. What stays here is the tick
|
|
// rate, which is the player's own field.
|
|
if (rules.EnhancedRegen)
|
|
{
|
|
float currentTimer = HarmonyLib.Traverse.Create(Player.m_localPlayer).Field<float>("m_foodRegenTimer").Value;
|
|
HarmonyLib.Traverse.Create(Player.m_localPlayer).Field("m_foodRegenTimer").SetValue(currentTimer + Time.deltaTime * SkeletonConfig.EnhancedRegenTickSpeedBonus.Value);
|
|
}
|
|
|
|
// Flames on the skull, worn with the fire-tier model and nothing else.
|
|
headFlame.Apply(Player.m_localPlayer, SkeletonConfig.HeadFireVFXEnabled.Value && SkeletonVisuals.GetModel(Player.m_localPlayer, state) == SkeletonProgression.FireModel);
|
|
|
|
if (rules.FireAura)
|
|
{
|
|
SkeletonVisuals.EnsureFireAura(Player.m_localPlayer, true, ref fireAuraVFX);
|
|
if (Time.time - lastAuraTime >= SkeletonConfig.FireAuraTickInterval.Value)
|
|
{
|
|
ApplyFireAura();
|
|
lastAuraTime = Time.time;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
SkeletonVisuals.EnsureFireAura(Player.m_localPlayer, false, ref fireAuraVFX);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Puts the player's jaw back if anything collapsed it. Safe to call every frame and for
|
|
/// any race - it does nothing unless the bone is actually at zero scale.
|
|
/// </summary>
|
|
private static void RestoreJawBone()
|
|
{
|
|
VisEquipment vis = Player.m_localPlayer != null
|
|
? Player.m_localPlayer.GetComponent<VisEquipment>()
|
|
: null;
|
|
if (vis == null || vis.m_bodyModel == null || vis.m_bodyModel.bones == null) return;
|
|
|
|
foreach (Transform bone in vis.m_bodyModel.bones)
|
|
{
|
|
if (bone == null || !bone.name.ToLower().Contains("jaw")) continue;
|
|
if (bone.localScale == Vector3.zero) bone.localScale = Vector3.one;
|
|
break;
|
|
}
|
|
}
|
|
|
|
private void ApplyFireAura()
|
|
{
|
|
if (Player.m_localPlayer == null) return;
|
|
|
|
Vector3 center = Player.m_localPlayer.transform.position;
|
|
float radius = SkeletonConfig.FireAuraRadius.Value;
|
|
|
|
HitData hitData = new HitData();
|
|
hitData.m_damage.m_fire = SkeletonConfig.FireAuraDamagePerTick.Value;
|
|
hitData.SetAttacker(Player.m_localPlayer);
|
|
hitData.m_dir = Vector3.zero;
|
|
|
|
int hits = 0;
|
|
foreach (Collider collider in Physics.OverlapSphere(center, radius))
|
|
{
|
|
Character character = collider.GetComponentInParent<Character>();
|
|
if (character != null && character != Player.m_localPlayer && BaseAI.IsEnemy(Player.m_localPlayer, character))
|
|
{
|
|
character.Damage(hitData);
|
|
hits++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|