feat(dvergur): add the Dvergur race scaffold

An eighth race built on the existing per-race pattern: a MonoBehaviour driver
registered from Awake, a progression table keyed on the boss state, an SE_Stats
carrier, and Harmony patches for the individual perks.

The helmet slot stays free. Whatever the player equips keeps every one of its
stats and only its mesh is swapped for the dvergr hood, which is the Skeleton's
helmet handling turned into a replacement rather than a plain hide.

Every percentage the spec left open lives in DvergurConfig as a named value and
is marked TODO there, so tuning the race never means touching the logic. The
knobs are static readonly rather than const so that switching a perk off with a
zero does not fold its guard into dead code.
This commit is contained in:
kanym 2026-08-02 21:45:44 +02:00
commit 3ec51aeb45
10 changed files with 1365 additions and 1 deletions

View file

@ -0,0 +1,207 @@
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
namespace RacesOfValheim
{
/// <summary>
/// The Dvergur's two eitr abilities.
///
/// Runic Ping (Yagluth) - spend eitr to light up ore veins and hidden enemies nearby.
/// Runic Overcharge (Fader) - spend eitr to load the next blow of a favoured weapon.
///
/// Both are driven from DvergurRace.Update and both read their cost, radius, duration and
/// cooldown out of DvergurConfig.
/// </summary>
public static class DvergurAbilities
{
private static float lastPingTime = -1000f;
private static float lastOverchargeTime = -1000f;
public static void Tick(Player player, int state)
{
// Ability input is gated exactly like every other race's: RaceInput mirrors
// Player.TakeInput, so nothing fires while a map, chest or chat window has focus.
if (!RaceInput.Allowed) return;
DvergurProgression.DvergurRules rules = DvergurProgression.GetRules(state);
if (rules.RunicPing && Input.GetKeyDown(DvergurConfig.RunicPingKey))
{
TryRunicPing(player);
}
if (rules.RunicOvercharge && Input.GetKeyDown(DvergurConfig.RunicOverchargeKey))
{
TryRunicOvercharge(player);
}
}
// ─── Runic Ping ──────────────────────────────────────────────────────
private static void TryRunicPing(Player player)
{
if (Time.time - lastPingTime < DvergurConfig.RunicPingCooldown) return;
if (player.GetEitr() < DvergurConfig.RunicPingEitrCost)
{
player.Message(MessageHud.MessageType.Center, "Not enough eitr");
return;
}
player.UseEitr(DvergurConfig.RunicPingEitrCost);
lastPingTime = Time.time;
DvergurStatusEffects.ApplyCooldownIcon(DvergurConfig.RunicPingCdSE, DvergurConfig.RunicPingCooldown);
int marked = MarkSurroundings(player);
player.Message(MessageHud.MessageType.Center,
marked > 0 ? $"Runic Ping: {marked} echoes answer" : "Runic Ping: the stone is silent");
}
/// <summary>
/// Lights every ore vein and every hostile within the radius for the duration. The marker
/// is a local point light parented to the target, the same trick the Aswid's Auspex uses -
/// nothing is replicated, so it costs other players nothing.
/// </summary>
private static int MarkSurroundings(Player player)
{
Vector3 center = player.transform.position;
HashSet<GameObject> alreadyMarked = new HashSet<GameObject>();
int marked = 0;
foreach (Collider collider in Physics.OverlapSphere(center, DvergurConfig.RunicPingRadius))
{
if (collider == null) continue;
GameObject vein = FindVeinRoot(collider);
if (vein == null || !alreadyMarked.Add(vein)) continue;
SpawnMarker(vein.transform, DvergurConfig.RunicPingOreColor);
marked++;
}
foreach (Character character in Character.GetAllCharacters())
{
if (character == null || character == player || character.IsDead() || character.IsTamed()) continue;
if (Vector3.Distance(character.transform.position, center) > DvergurConfig.RunicPingRadius) continue;
if (!BaseAI.IsEnemy(player, character)) continue;
if (!alreadyMarked.Add(character.gameObject)) continue;
SpawnMarker(character.transform, DvergurConfig.RunicPingEnemyColor);
marked++;
}
return marked;
}
/// <summary>
/// The mineable object a collider belongs to, or null. Both halves matter: the component
/// check keeps ordinary terrain out, and the name check keeps plain rock and trees out of
/// what is meant to read as an ore reading.
/// </summary>
private static GameObject FindVeinRoot(Collider collider)
{
GameObject root = null;
MineRock5 mineRock5 = collider.GetComponentInParent<MineRock5>();
if (mineRock5 != null) root = mineRock5.gameObject;
if (root == null)
{
MineRock mineRock = collider.GetComponentInParent<MineRock>();
if (mineRock != null) root = mineRock.gameObject;
}
if (root == null)
{
Destructible destructible = collider.GetComponentInParent<Destructible>();
if (destructible != null && destructible.m_destructibleType != DestructibleType.Tree)
{
root = destructible.gameObject;
}
}
if (root == null) return null;
string name = root.name.ToLower();
foreach (string veinName in DvergurConfig.RunicPingVeinNames)
{
if (name.Contains(veinName)) return root;
}
return null;
}
private static void SpawnMarker(Transform target, Color color)
{
GameObject markerObj = new GameObject("DvergurRunicMark");
markerObj.transform.SetParent(target, false);
markerObj.transform.localPosition = Vector3.up;
Light light = markerObj.AddComponent<Light>();
light.type = LightType.Point;
light.color = color;
light.range = DvergurConfig.RunicPingLightRange;
light.intensity = DvergurConfig.RunicPingLightIntensity;
light.shadows = LightShadows.None;
if (DvergurRace.Instance != null)
{
DvergurRace.Instance.StartCoroutine(DestroyAfter(markerObj, DvergurConfig.RunicPingDuration));
}
else
{
// No driver to run the coroutine on: better a marker that never appears than one
// that never goes away.
Object.Destroy(markerObj);
}
}
private static IEnumerator DestroyAfter(GameObject obj, float seconds)
{
yield return new WaitForSeconds(seconds);
if (obj != null) Object.Destroy(obj);
}
// ─── Runic Overcharge ────────────────────────────────────────────────
private static void TryRunicOvercharge(Player player)
{
if (Time.time - lastOverchargeTime < DvergurConfig.RunicOverchargeCooldown) return;
int overchargeHash = DvergurConfig.OverchargeSE.GetStableHashCode();
if (player.GetSEMan().HaveStatusEffect(overchargeHash)) return; // already loaded
if (player.GetEitr() < DvergurConfig.RunicOverchargeEitrCost)
{
player.Message(MessageHud.MessageType.Center, "Not enough eitr");
return;
}
player.UseEitr(DvergurConfig.RunicOverchargeEitrCost);
lastOverchargeTime = Time.time;
DvergurStatusEffects.ApplyCooldownIcon(DvergurConfig.OverchargeCdSE, DvergurConfig.RunicOverchargeCooldown);
player.GetSEMan().AddStatusEffect(overchargeHash, true);
StatusEffect se = player.GetSEMan().GetStatusEffect(overchargeHash);
// The charge is held, not permanent: it lapses if no favoured blow lands in time.
if (se != null) se.m_ttl = DvergurConfig.RunicOverchargeWindow;
player.Message(MessageHud.MessageType.Center, "Runic Overcharge: your next blow is loaded");
}
/// <summary>
/// Spends a held charge. Called from the damage patch once it has confirmed the blow was
/// struck with a weapon the Dvergur is at home with.
/// </summary>
public static bool ConsumeOvercharge(Player player)
{
if (player == null) return false;
int hash = DvergurConfig.OverchargeSE.GetStableHashCode();
if (!player.GetSEMan().HaveStatusEffect(hash)) return false;
player.GetSEMan().RemoveStatusEffect(hash, true);
return true;
}
}
}

View file

@ -0,0 +1,237 @@
using UnityEngine;
namespace RacesOfValheim
{
/// <summary>
/// Every tunable number the Dvergur uses, in one place.
///
/// The race was specced with most percentages still open, so nothing here is baked into the
/// logic: DvergurProgression reads these to build its per-tier rules and the patches read the
/// rules, never a literal. Retuning the race means editing this file only.
///
/// Values still marked TODO are placeholders chosen to be playable, not final.
/// </summary>
public static class DvergurConfig
{
// ─── Identity ────────────────────────────────────────────────────────
// "Dvergur" is provisional. It is the value stored in m_customData["Race"] and in the
// ZDO, so renaming it after players have chosen the race would orphan their characters.
public const string RaceId = "Dvergur";
public const string StatsSE = "SE_DvergurStats";
public const string OverchargeSE = "SE_DvergurOvercharge";
public const string RunicPingCdSE = "SE_DvergurRunicPingCooldown";
public const string OverchargeCdSE = "SE_DvergurOverchargeCooldown";
// Mirrors the ZDO key layout the other races use, so remote clients can read the tier
// without having the local player's progression state.
public const string StateZdoKey = "RacesOfValheim_DvergurState";
// ─── Model ───────────────────────────────────────────────────────────
// Applied to the player's "Visual" child rather than the root transform, the way Furling
// does it: scaling the root would drag the collider and camera pivot along with it.
// Tuning knobs are static readonly rather than const throughout: a const folds at compile
// time, which turns "is this perk switched off?" guards into dead code the moment a knob
// is set to zero, and would bake the old value into any assembly built against this one.
public static readonly float VisualScale = 0.70f; // -30% versus a human
// ─── Cosmetic hood ───────────────────────────────────────────────────
// The helmet slot itself stays free — whatever the player equips keeps all of its stats,
// only the mesh is swapped. Tried in order; the first prefab that resolves wins.
public static readonly string[] HoodPrefabCandidates =
{
"HelmetDverger", // Dverger circlet item
"helmet_dverger", // its attach visual, if the item prefab is unavailable
"Dverger" // last resort: lift the headgear renderer off the creature
};
// Valheim rigs are authored at scale 100, hence the very small numbers. Tuned against
// the head bone, same approach as the Furling trophy head.
public static readonly Vector3 HoodLocalPosition = new Vector3(0f, 0.0012f, 0f);
public static readonly Vector3 HoodLocalRotation = new Vector3(-90f, 0f, 90f);
public static readonly float HoodLocalScale = 0.0075f;
// ─── Health malus ────────────────────────────────────────────────────
// Indexed by progression state; index 0 is unused so the state number indexes directly.
// Base -10, growing to -20 once The Queen falls.
public static readonly float[] HealthMalusByState =
{
0f, // (unused)
10f, // 1 Base
10f, // 2 Eikthyr
10f, // 3 The Elder
13f, // 4 Bonemass
15f, // 5 Moder
17.5f, // 6 Yagluth TODO: spec says -17/-18, pick one
20f, // 7 The Queen
20f // 8 Fader
};
// A Dvergur must never be reduced below this, however the malus and food line up.
public static readonly float MinMaxHealth = 5f;
// ─── Weapon affinity ─────────────────────────────────────────────────
// Bonus damage plus a stamina discount on the attack. Neither scales with the tier - a
// tier only ever adds a new weapon to the list - and skill XP is deliberately untouched.
public struct WeaponAffinity
{
public Skills.SkillType Skill;
public int UnlockState;
public HitData.DamageType FlatDamageType; // channel the flat bonus lands on
public float FlatDamage; // TODO
public float DamagePercent; // TODO, share of physical damage added
public float StaminaPercent; // TODO, share of attack stamina refunded
public float StaminaFlat; // TODO, flat stamina refunded
public string DisplayName;
}
public static readonly WeaponAffinity[] WeaponAffinities =
{
new WeaponAffinity
{
Skill = Skills.SkillType.Clubs, UnlockState = 1,
FlatDamageType = HitData.DamageType.Blunt,
FlatDamage = 0f, DamagePercent = 0.15f,
StaminaPercent = 0.20f, StaminaFlat = 0f,
DisplayName = "Hammer"
},
new WeaponAffinity
{
Skill = Skills.SkillType.Bows, UnlockState = 2,
FlatDamageType = HitData.DamageType.Pierce,
FlatDamage = 0f, DamagePercent = 0.15f,
StaminaPercent = 0.20f, StaminaFlat = 0f,
DisplayName = "Bow"
},
new WeaponAffinity
{
Skill = Skills.SkillType.Axes, UnlockState = 3,
FlatDamageType = HitData.DamageType.Slash,
FlatDamage = 0f, DamagePercent = 0.15f,
StaminaPercent = 0.20f, StaminaFlat = 0f,
DisplayName = "Axe"
},
new WeaponAffinity
{
Skill = Skills.SkillType.Crossbows, UnlockState = 6,
FlatDamageType = HitData.DamageType.Pierce,
FlatDamage = 0f, DamagePercent = 0.15f,
StaminaPercent = 0.20f, StaminaFlat = 0f,
DisplayName = "Crossbow"
}
};
// ─── Mining affinity ─────────────────────────────────────────────────
// Unlocks alongside the antler pickaxe.
public const int MiningAffinityState = 2;
// Faster mining is modelled as extra pickaxe damage per swing rather than a swing-rate
// change: rock HP is what actually gates how long a vein takes.
public static readonly float MiningDamageMultiplier = 1.20f; // TODO: 20% faster?
public static readonly float MiningStaminaPercent = 0.40f; // TODO: or 40% less stamina?
// Chance for a mined vein to yield an extra unit of ore. 0 disables the yield half of
// the affinity and leaves it purely a speed/stamina perk.
public static readonly float MiningExtraDropChance = 0.25f; // TODO
// Matched against the drop prefab name, lowercased, by Contains.
public static readonly string[] OreDropNames =
{
"copperore", "tinore", "ironscrap", "silverore", "blackmetalscrap", "flametalore"
};
// ─── Smithing / jewelry ──────────────────────────────────────────────
// Percentage saved on the metal cost of crafting and upgrading. Starts at Bonemass and
// caps at Moder. Indexed by progression state.
public static readonly float[] SmithingDiscountByState =
{
0f, // (unused)
0f, // 1 Base
0f, // 2 Eikthyr
0f, // 3 The Elder
0.20f, // 4 Bonemass
0.40f, // 5 Moder - cap
0.40f, // 6 Yagluth
0.40f, // 7 The Queen
0.40f // 8 Fader
};
// Only these resources are discounted, which is what keeps the perk to smithing and
// jewelry rather than quietly cheapening every wooden wall the player puts up.
public static readonly string[] DiscountedResourceNames =
{
"copper", "tin", "bronze", "iron", "silver", "blackmetal", "flametal",
"ironnails", "bronzenails", "copperore", "tinore", "silverore", "flametalore",
"ruby", "amber", "amberpearl", "coins", "silvernecklace"
};
// ─── Haldor / Hildir favour ──────────────────────────────────────────
// Both halves of the trade: a discount on what the traders charge, and a bonus on what
// they pay for trophies and hunting rewards. Indexed by progression state.
public static readonly float[] TraderBuyDiscountByState =
{
0f, // (unused)
0f, // 1 Base
0f, // 2 Eikthyr
0f, // 3 The Elder
0.10f, // 4 Bonemass - step 1 TODO
0.15f, // 5 Moder - step 2 TODO
0.20f, // 6 Yagluth - step 3 TODO
0.25f, // 7 The Queen - full TODO
0.25f // 8 Fader
};
public static readonly float[] TraderSellBonusByState =
{
0f, // (unused)
0f, // 1 Base
0f, // 2 Eikthyr
0f, // 3 The Elder
0.10f, // 4 Bonemass - step 1 TODO
0.20f, // 5 Moder - step 2 TODO
0.30f, // 6 Yagluth - step 3 TODO
0.40f, // 7 The Queen - full TODO
0.40f // 8 Fader
};
// ─── Runic Ping (Yagluth) ────────────────────────────────────────────
public const int RunicPingState = 6;
public const KeyCode RunicPingKey = KeyCode.G;
public static readonly float RunicPingEitrCost = 25f; // TODO
public static readonly float RunicPingRadius = 40f; // TODO
public static readonly float RunicPingDuration = 10f; // TODO
public static readonly float RunicPingCooldown = 20f; // TODO
public static readonly Color RunicPingOreColor = new Color(0.4f, 0.8f, 1f);
public static readonly Color RunicPingEnemyColor = new Color(1f, 0.35f, 0.35f);
public static readonly float RunicPingLightRange = 8f;
public static readonly float RunicPingLightIntensity = 2f;
// Vein prefabs are matched on name, lowercased, by Contains - MineRock5_Copper,
// silvervein, rock4_copper and friends all fall out of this list.
public static readonly string[] RunicPingVeinNames =
{
"copper", "tin", "silvervein", "obsidian", "meteorite", "flametal", "mudpile", "leviathan"
};
// ─── Runic Overcharge (Fader) ────────────────────────────────────────
public const int RunicOverchargeState = 8;
public const KeyCode RunicOverchargeKey = KeyCode.H;
public static readonly float RunicOverchargeEitrCost = 60f; // TODO
public static readonly float RunicOverchargeMultiplier = 4f; // TODO, applied to physical damage
public static readonly float RunicOverchargeWindow = 15f; // seconds the charge is held
public static readonly float RunicOverchargeCooldown = 60f; // TODO
// ─── Helpers ─────────────────────────────────────────────────────────
/// <summary>Clamped table lookup, so a state outside 1..8 can never index out of range.</summary>
public static float Lookup(float[] table, int state)
{
if (table == null || table.Length == 0) return 0f;
int index = Mathf.Clamp(state, BossProgressionManager.MinState, table.Length - 1);
return table[index];
}
}
}

View file

@ -0,0 +1,297 @@
using System.Collections.Generic;
using System.Reflection;
using HarmonyLib;
using UnityEngine;
namespace RacesOfValheim
{
/// <summary>
/// Every hook the Dvergur needs. The patches only ever decide *whether* a perk applies; *how
/// much* it applies always comes from DvergurProgression, which in turn reads DvergurConfig.
/// </summary>
public static class DvergurPatches
{
// ─── Health malus ────────────────────────────────────────────────────
/// <summary>
/// The Dvergur is a small frame, and carries less health for it. The target is resolved
/// with AccessTools rather than named against a type, because GetMaxHealth may be declared
/// on Character or overridden on Player depending on the game version - AccessTools walks
/// up to whichever one actually runs, and the local-player guard makes either correct.
/// </summary>
[HarmonyPatch]
public static class Dvergur_GetMaxHealth_Patch
{
public static MethodBase TargetMethod() => AccessTools.Method(typeof(Player), "GetMaxHealth");
public static void Postfix(Character __instance, ref float __result)
{
if (__instance == null || __instance != Player.m_localPlayer) return;
if (!DvergurRace.IsDvergur()) return;
float malus = DvergurProgression.Current.HealthMalus;
if (malus <= 0f) return;
__result = Mathf.Max(DvergurConfig.MinMaxHealth, __result - malus);
}
}
// ─── Weapon affinity: damage ─────────────────────────────────────────
/// <summary>
/// Bonus damage with hammer, bow, axe and crossbow as each is unlocked, and the payoff for
/// a held Runic Overcharge. Neither touches skill XP: the Dvergur is at home with these
/// weapons, not faster at learning them.
/// </summary>
[HarmonyPatch(typeof(Character), "Damage")]
public static class Dvergur_WeaponAffinity_Damage_Patch
{
public static void Prefix(Character __instance, HitData hit)
{
if (hit == null || Player.m_localPlayer == null) return;
if (hit.GetAttacker() != Player.m_localPlayer) return;
if (!DvergurRace.IsDvergur()) return;
int state = BossProgressionManager.GetCurrentProgressionState();
DvergurConfig.WeaponAffinity? found = DvergurProgression.GetAffinity(hit.m_skill, state);
if (!found.HasValue) return;
DvergurConfig.WeaponAffinity affinity = found.Value;
if (affinity.DamagePercent > 0f)
{
ScalePhysical(hit, 1f + affinity.DamagePercent);
}
if (affinity.FlatDamage > 0f)
{
AddFlat(hit, affinity.FlatDamageType, affinity.FlatDamage);
}
// Overcharge only ever discharges into a favoured weapon, which is why it is
// spent here rather than on the first hit of any kind.
if (DvergurProgression.GetRules(state).RunicOvercharge &&
DvergurAbilities.ConsumeOvercharge(Player.m_localPlayer))
{
ScalePhysical(hit, DvergurConfig.RunicOverchargeMultiplier);
Player.m_localPlayer.Message(MessageHud.MessageType.TopLeft, "Runic Overcharge discharges");
}
}
private static void ScalePhysical(HitData hit, float multiplier)
{
hit.m_damage.m_blunt *= multiplier;
hit.m_damage.m_slash *= multiplier;
hit.m_damage.m_pierce *= multiplier;
}
private static void AddFlat(HitData hit, HitData.DamageType type, float amount)
{
switch (type)
{
case HitData.DamageType.Blunt: hit.m_damage.m_blunt += amount; break;
case HitData.DamageType.Slash: hit.m_damage.m_slash += amount; break;
case HitData.DamageType.Pierce: hit.m_damage.m_pierce += amount; break;
default: hit.m_damage.m_damage += amount; break;
}
}
}
// ─── Mining affinity ─────────────────────────────────────────────────
/// <summary>
/// Set for the duration of a mining hit so the drop patch below can tell an ore roll made
/// by this player apart from every other DropTable call in the world. Same flag-around-the
/// -call approach the Furling uses for its doubled ore.
/// </summary>
private static bool isDvergurMining = false;
private static bool BeginMiningHit(HitData hit)
{
if (hit == null || Player.m_localPlayer == null) return false;
if (hit.GetAttacker() != Player.m_localPlayer) return false;
if (!DvergurRace.IsDvergur()) return false;
if (!DvergurProgression.Current.MiningAffinity) return false;
// A pickaxe swing is what the affinity is about - chopping and combat hits on the same
// objects go through here too and must be left alone.
if (hit.m_damage.m_pickaxe <= 0f) return false;
hit.m_damage.m_pickaxe *= DvergurConfig.MiningDamageMultiplier;
isDvergurMining = true;
return true;
}
private static void EndMiningHit(bool began)
{
if (began) isDvergurMining = false;
}
[HarmonyPatch(typeof(MineRock5), "DamageArea")]
public static class Dvergur_MineRock5_DamageArea_Patch
{
public static void Prefix(HitData hit, out bool __state) => __state = BeginMiningHit(hit);
public static void Postfix(bool __state) => EndMiningHit(__state);
}
[HarmonyPatch(typeof(MineRock), "RPC_Hit")]
public static class Dvergur_MineRock_RPC_Hit_Patch
{
public static void Prefix(HitData hit, out bool __state) => __state = BeginMiningHit(hit);
public static void Postfix(bool __state) => EndMiningHit(__state);
}
[HarmonyPatch(typeof(Destructible), "RPC_Damage")]
public static class Dvergur_Destructible_RPC_Damage_Patch
{
public static void Prefix(HitData hit, out bool __state) => __state = BeginMiningHit(hit);
public static void Postfix(bool __state) => EndMiningHit(__state);
}
[HarmonyPatch(typeof(DropTable), "GetDropList", new System.Type[] { typeof(int) })]
public static class Dvergur_DropTable_GetDropList_Patch
{
public static void Postfix(ref List<GameObject> __result)
{
if (!isDvergurMining || __result == null) return;
if (DvergurConfig.MiningExtraDropChance <= 0f) return;
List<GameObject> extra = new List<GameObject>();
foreach (GameObject drop in __result)
{
if (drop == null || !IsOre(drop.name)) continue;
if (Random.value <= DvergurConfig.MiningExtraDropChance) extra.Add(drop);
}
__result.AddRange(extra);
}
private static bool IsOre(string prefabName)
{
string lower = prefabName.ToLower();
foreach (string ore in DvergurConfig.OreDropNames)
{
if (lower.Contains(ore)) return true;
}
return false;
}
}
// ─── Smithing and jewelry ────────────────────────────────────────────
/// <summary>
/// Metal saved when crafting and upgrading. Requirement.GetAmount is the single point both
/// the crafting panel and Player.ConsumeResources go through, so the figure the player is
/// quoted and the figure they are charged can never drift apart.
///
/// Scoped to the metals and gems in DvergurConfig.DiscountedResourceNames, which is what
/// keeps this a smithing perk rather than a blanket discount on every wooden wall.
/// </summary>
[HarmonyPatch(typeof(Piece.Requirement), "GetAmount")]
public static class Dvergur_Requirement_GetAmount_Patch
{
public static void Postfix(Piece.Requirement __instance, ref int __result)
{
if (__result <= 1 || Player.m_localPlayer == null) return;
if (!DvergurRace.IsDvergur()) return;
float discount = DvergurProgression.Current.SmithingDiscount;
if (discount <= 0f) return;
if (__instance == null || __instance.m_resItem == null) return;
if (!IsDiscounted(__instance.m_resItem.gameObject.name)) return;
__result = Mathf.Max(1, Mathf.RoundToInt(__result * (1f - discount)));
}
private static bool IsDiscounted(string prefabName)
{
string lower = prefabName.ToLower();
foreach (string resource in DvergurConfig.DiscountedResourceNames)
{
if (lower == resource || lower.Contains(resource)) return true;
}
return false;
}
}
// ─── Haldor and Hildir's favour ──────────────────────────────────────
/// <summary>
/// The buying half. Both traders are Trader components, so patching the shared source of
/// the stock list covers Haldor and Hildir at once.
///
/// The discounted entries are fresh TradeItem instances rather than edited originals: the
/// list Valheim hands back holds the trader's own objects, and rewriting their prices in
/// place would permanently mark down the shop for everyone, Dvergur or not.
/// </summary>
[HarmonyPatch(typeof(Trader), "GetAvailableItems")]
public static class Dvergur_Trader_GetAvailableItems_Patch
{
public static void Postfix(ref List<Trader.TradeItem> __result)
{
if (__result == null || Player.m_localPlayer == null) return;
if (!DvergurRace.IsDvergur()) return;
float discount = DvergurProgression.Current.TraderBuyDiscount;
if (discount <= 0f) return;
List<Trader.TradeItem> discounted = new List<Trader.TradeItem>(__result.Count);
foreach (Trader.TradeItem item in __result)
{
if (item == null) continue;
discounted.Add(new Trader.TradeItem
{
m_prefab = item.m_prefab,
m_stack = item.m_stack,
m_price = Mathf.Max(1, Mathf.RoundToInt(item.m_price * (1f - discount))),
m_requiredGlobalKey = item.m_requiredGlobalKey
});
}
__result = discounted;
}
}
/// <summary>
/// The selling half - trophies and hunting rewards fetch more. GetValue is what the sell
/// button both displays and pays out, and it is not consulted for purchases, so the bonus
/// lands on exactly the side of the counter it is meant to.
/// </summary>
[HarmonyPatch(typeof(ItemDrop.ItemData), "GetValue")]
public static class Dvergur_ItemData_GetValue_Patch
{
public static void Postfix(ref int __result)
{
if (__result <= 0 || Player.m_localPlayer == null) return;
if (!DvergurRace.IsDvergur()) return;
float bonus = DvergurProgression.Current.TraderSellBonus;
if (bonus <= 0f) return;
__result = Mathf.RoundToInt(__result * (1f + bonus));
}
}
// ─── Cosmetic hood ───────────────────────────────────────────────────
/// <summary>
/// Runs for every player, local and remote, whenever Valheim rebuilds their visuals - the
/// point at which a newly equipped helmet has just been instantiated and needs hiding
/// again behind the hood.
/// </summary>
[HarmonyPatch(typeof(VisEquipment), "UpdateVisuals")]
public static class Dvergur_VisEquipment_UpdateVisuals_Patch
{
public static void Postfix(VisEquipment __instance)
{
if (__instance == null || !__instance.m_isPlayer) return;
Player player = __instance.GetComponent<Player>();
if (player == null) return;
DvergurVisuals.Apply(player);
}
}
}
}

View file

@ -0,0 +1,82 @@
using System.Collections.Generic;
using UnityEngine;
namespace RacesOfValheim
{
/// <summary>
/// Turns a boss progression state into the set of Dvergur perks active at that tier, the same
/// way SkeletonProgression and SkadiProgression do for their races.
///
/// Nothing is decided here - every figure comes out of DvergurConfig - so the tuning pass can
/// happen without touching a single patch.
/// </summary>
public static class DvergurProgression
{
public struct DvergurRules
{
/// <summary>Points subtracted from max health at this tier.</summary>
public float HealthMalus;
/// <summary>Weapon skills the Dvergur is at home with, already filtered by tier.</summary>
public List<DvergurConfig.WeaponAffinity> Affinities;
public bool MiningAffinity;
public float SmithingDiscount;
public float TraderBuyDiscount;
public float TraderSellBonus;
public bool RunicPing;
public bool RunicOvercharge;
}
// GetRules runs from Update loops and from damage patches, so the per-state result is
// built once and handed back on every later call.
private static readonly DvergurRules[] cache = new DvergurRules[BossProgressionManager.MaxState + 1];
private static readonly bool[] cached = new bool[BossProgressionManager.MaxState + 1];
public static DvergurRules GetRules(int state)
{
state = Mathf.Clamp(state, BossProgressionManager.MinState, BossProgressionManager.MaxState);
if (cached[state]) return cache[state];
List<DvergurConfig.WeaponAffinity> affinities = new List<DvergurConfig.WeaponAffinity>();
foreach (DvergurConfig.WeaponAffinity affinity in DvergurConfig.WeaponAffinities)
{
if (state >= affinity.UnlockState) affinities.Add(affinity);
}
DvergurRules rules = new DvergurRules
{
HealthMalus = DvergurConfig.Lookup(DvergurConfig.HealthMalusByState, state),
Affinities = affinities,
MiningAffinity = state >= DvergurConfig.MiningAffinityState,
SmithingDiscount = DvergurConfig.Lookup(DvergurConfig.SmithingDiscountByState, state),
TraderBuyDiscount = DvergurConfig.Lookup(DvergurConfig.TraderBuyDiscountByState, state),
TraderSellBonus = DvergurConfig.Lookup(DvergurConfig.TraderSellBonusByState, state),
RunicPing = state >= DvergurConfig.RunicPingState,
RunicOvercharge = state >= DvergurConfig.RunicOverchargeState
};
cache[state] = rules;
cached[state] = true;
return rules;
}
/// <summary>Rules for whatever tier the local player is currently on.</summary>
public static DvergurRules Current => GetRules(BossProgressionManager.GetCurrentProgressionState());
/// <summary>
/// The affinity covering a weapon skill at the current tier, or null when the Dvergur has
/// no particular feel for it. Mining counts as an affinity for stamina purposes only, so
/// it is deliberately not part of this list.
/// </summary>
public static DvergurConfig.WeaponAffinity? GetAffinity(Skills.SkillType skill, int state)
{
DvergurRules rules = GetRules(state);
foreach (DvergurConfig.WeaponAffinity affinity in rules.Affinities)
{
if (affinity.Skill == skill) return affinity;
}
return null;
}
}
}

View file

@ -0,0 +1,72 @@
using UnityEngine;
namespace RacesOfValheim
{
/// <summary>
/// Driver for the Dvergur: a short, stocky smith who trades a slice of health for an affinity
/// with hammer, bow, axe and crossbow, a knack for mining and the ear of Haldor and Hildir.
///
/// Only the per-frame upkeep lives here. The perks themselves are Harmony patches in
/// DvergurPatches, the two eitr abilities are in DvergurAbilities, and every number they use
/// comes from DvergurConfig by way of DvergurProgression.
/// </summary>
public class DvergurRace : MonoBehaviour
{
public static DvergurRace Instance;
private void Awake()
{
Instance = this;
}
public void CreateModAssets()
{
DvergurStatusEffects.RegisterStatusEffects();
}
public static bool IsDvergur()
{
return Player.m_localPlayer != null &&
Player.m_localPlayer.m_customData.ContainsKey("Race") &&
Player.m_localPlayer.m_customData["Race"] == DvergurConfig.RaceId;
}
private void Update()
{
Player player = Player.m_localPlayer;
if (player == null) return;
if (!IsDvergur())
{
DvergurVisuals.Apply(player);
return;
}
DvergurVisuals.Apply(player);
if (player.IsDead()) return;
int state = BossProgressionManager.GetCurrentProgressionState();
// Keep the passive carrier attached. It is re-added rather than assumed because a
// respawn, a death or a world load all clear the player's status effects.
if (DvergurStatusEffects.StatsSE != null)
{
int hash = DvergurConfig.StatsSE.GetStableHashCode();
if (!player.GetSEMan().HaveStatusEffect(hash))
{
player.GetSEMan().AddStatusEffect(hash, true);
}
}
// Published for remote clients, matching how the Skeleton replicates its tier.
ZNetView nview = player.GetComponent<ZNetView>();
if (nview != null && nview.IsValid())
{
nview.GetZDO().Set(DvergurConfig.StateZdoKey, state);
}
DvergurAbilities.Tick(player, state);
}
}
}

View file

@ -0,0 +1,139 @@
using HarmonyLib;
using Jotunn.Entities;
using Jotunn.Managers;
using UnityEngine;
namespace RacesOfValheim
{
/// <summary>
/// Passive carrier for the Dvergur. The stamina half of weapon affinity lives here rather than
/// in a Harmony patch because Valheim already routes attack cost through the status effects
/// (SEMan.ModifyAttackStaminaUsage), so there is nothing to intercept.
/// </summary>
public class SE_DvergurStats : SE_Stats
{
public override void Setup(Character character)
{
base.Setup(character);
name = DvergurConfig.StatsSE;
m_name = "Stone and Forge";
m_tooltip = "Small, sturdy, and born to the anvil.";
}
public override void ModifyAttackStaminaUsage(float baseStaminaUse, ref float staminaUse)
{
base.ModifyAttackStaminaUsage(baseStaminaUse, ref staminaUse);
if (!(m_character is Player player) || player != Player.m_localPlayer) return;
if (!DvergurRace.IsDvergur()) return;
int state = BossProgressionManager.GetCurrentProgressionState();
// m_rightItem rather than GetCurrentWeapon(): it is what the rest of the mod reaches
// for, and it is the item the swing is actually paying for.
ItemDrop.ItemData weapon = Traverse.Create(player).Field<ItemDrop.ItemData>("m_rightItem").Value;
if (weapon == null || weapon.m_shared == null) return;
Skills.SkillType skill = weapon.m_shared.m_skillType;
// Mining is a discount on the pickaxe, not a weapon affinity, so it is checked apart.
if (skill == Skills.SkillType.Pickaxes)
{
if (DvergurProgression.GetRules(state).MiningAffinity)
{
staminaUse = Mathf.Max(0f, staminaUse * (1f - DvergurConfig.MiningStaminaPercent));
}
return;
}
DvergurConfig.WeaponAffinity? affinity = DvergurProgression.GetAffinity(skill, state);
if (!affinity.HasValue) return;
// Static by design: the discount is the same the day it unlocks as it is after Fader.
staminaUse = Mathf.Max(0f, staminaUse * (1f - affinity.Value.StaminaPercent) - affinity.Value.StaminaFlat);
}
}
/// <summary>
/// Runic Overcharge, held between the cast and the blow that spends it. Purely a marker with a
/// countdown - DvergurPatches reads it when the next affine hit lands.
/// </summary>
public class SE_DvergurOvercharge : StatusEffect
{
}
/// <summary>
/// Ability cooldowns. They exist only so the HUD has something to count down, the way
/// SE_SkadiAbilityCooldown does: Valheim prints the remaining time of any effect with a m_ttl.
/// </summary>
public class SE_DvergurAbilityCooldown : StatusEffect
{
}
public static class DvergurStatusEffects
{
public static SE_DvergurStats StatsSE { get; private set; }
public static void RegisterStatusEffects()
{
Sprite icon = GetItemIcon("HelmetDverger") ?? GetItemIcon("DvergrKeyFragment") ?? GetItemIcon("Copper");
var stats = ScriptableObject.CreateInstance<SE_DvergurStats>();
stats.name = DvergurConfig.StatsSE;
stats.m_name = "Stone and Forge";
stats.m_icon = icon;
CustomStatusEffect customStats = new CustomStatusEffect(stats, fixReference: false);
ItemManager.Instance.AddStatusEffect(customStats);
StatsSE = customStats.StatusEffect as SE_DvergurStats;
var overcharge = ScriptableObject.CreateInstance<SE_DvergurOvercharge>();
overcharge.name = DvergurConfig.OverchargeSE;
overcharge.m_name = "Runic Overcharge";
overcharge.m_tooltip = "Your next blow with a favoured weapon carries the whole of the charge.";
overcharge.m_icon = GetItemIcon("Eitr") ?? icon;
ItemManager.Instance.AddStatusEffect(new CustomStatusEffect(overcharge, fixReference: false));
var pingCd = ScriptableObject.CreateInstance<SE_DvergurAbilityCooldown>();
pingCd.name = DvergurConfig.RunicPingCdSE;
pingCd.m_name = "Runic Ping";
pingCd.m_tooltip = "The runes must settle before you may call on them again.";
pingCd.m_icon = GetItemIcon("DvergrKeyFragment") ?? icon;
ItemManager.Instance.AddStatusEffect(new CustomStatusEffect(pingCd, fixReference: false));
var overchargeCd = ScriptableObject.CreateInstance<SE_DvergurAbilityCooldown>();
overchargeCd.name = DvergurConfig.OverchargeCdSE;
overchargeCd.m_name = "Overcharge Cooldown";
overchargeCd.m_tooltip = "The runes are spent.";
overchargeCd.m_icon = GetItemIcon("Eitr") ?? icon;
ItemManager.Instance.AddStatusEffect(new CustomStatusEffect(overchargeCd, fixReference: false));
}
/// <summary>
/// Drives the HUD countdown for an ability, mirroring SkadiRace.ApplyCooldownIcon: the
/// effect only has to exist with a m_ttl for the icon to tick down by itself.
/// </summary>
public static void ApplyCooldownIcon(string effectName, float seconds)
{
if (Player.m_localPlayer == null || seconds <= 0f) return;
int hash = effectName.GetStableHashCode();
SEMan seman = Player.m_localPlayer.GetSEMan();
seman.RemoveStatusEffect(hash, true);
seman.AddStatusEffect(hash, true);
StatusEffect se = seman.GetStatusEffect(hash);
if (se != null) se.m_ttl = seconds;
}
private static Sprite GetItemIcon(string prefabName)
{
GameObject prefab = PrefabManager.Cache.GetPrefab<ItemDrop>(prefabName)?.gameObject;
ItemDrop drop = prefab != null ? prefab.GetComponent<ItemDrop>() : null;
if (drop != null && drop.m_itemData.m_shared.m_icons.Length > 0)
{
return drop.m_itemData.m_shared.m_icons[0];
}
return null;
}
}
}

View file

@ -0,0 +1,232 @@
using HarmonyLib;
using Jotunn.Managers;
using UnityEngine;
namespace RacesOfValheim
{
/// <summary>
/// The Dvergur's looks: a short body and a hood that is always worn.
///
/// The hood is a pure cosmetic override, not an equipment lock. The helmet slot stays free and
/// whatever the player equips keeps every one of its stats - only its mesh is swapped out, the
/// way the Skeleton hides helmets outright, so armour, resistances and set bonuses all still
/// count. Everything here runs for local and remote players alike, which is why it takes a
/// Player rather than reading Player.m_localPlayer.
/// </summary>
public static class DvergurVisuals
{
private const string HoodName = "DvergurHood";
/// <summary>
/// Reads the race off the ZDO so remote players render correctly, falling back to
/// m_customData for the main-menu preview which has no ZNetView. Same shape as
/// FurlingPatches.GetPlayerRace.
/// </summary>
public static string GetPlayerRace(Player player)
{
if (player == null) return "Human";
ZNetView nview = player.GetComponent<ZNetView>();
if (nview != null && nview.IsValid())
{
return nview.GetZDO().GetString("RacesOfValheim_Race", "Human");
}
if (player.m_customData != null && player.m_customData.TryGetValue("Race", out string race))
{
return race;
}
return "Human";
}
public static bool IsDvergurPlayer(Player player) => GetPlayerRace(player) == DvergurConfig.RaceId;
/// <summary>
/// Brings a player's body in line with their race. Safe to call every frame: each step
/// checks the current value first and does nothing when it already matches.
/// </summary>
public static void Apply(Player player)
{
if (player == null) return;
bool isDvergur = IsDvergurPlayer(player) && !player.IsDead();
ApplyScale(player, isDvergur);
VisEquipment visEq = player.GetComponent<VisEquipment>();
if (visEq == null) return;
if (isDvergur)
{
EnsureHood(visEq);
HideEquippedHelmet(visEq);
}
else
{
RemoveHood(visEq);
}
}
private static void ApplyScale(Player player, bool isDvergur)
{
// Scaling the "Visual" child rather than the root, as Furling does: the root carries
// the collider and the camera pivot, and shrinking those makes the player fall through
// the world geometry they were standing on.
GameObject visual = Traverse.Create(player).Field("m_visual").GetValue<GameObject>();
if (visual == null) return;
Vector3 target = isDvergur ? Vector3.one * DvergurConfig.VisualScale : Vector3.one;
if (isDvergur)
{
if (visual.transform.localScale != target) visual.transform.localScale = target;
}
else if (visual.transform.localScale == Vector3.one * DvergurConfig.VisualScale)
{
// Only undo our own scale - another race may legitimately be scaling this player.
visual.transform.localScale = Vector3.one;
}
}
/// <summary>
/// Blanks the mesh of whatever helmet is equipped. Scaled to zero rather than deactivated
/// because Valheim re-enables the instance whenever it refreshes visuals, and this is the
/// approach the Skeleton already proved out.
/// </summary>
private static void HideEquippedHelmet(VisEquipment visEq)
{
GameObject helmet = Traverse.Create(visEq).Field<GameObject>("m_helmetItemInstance").Value;
if (helmet != null && helmet.transform.localScale != Vector3.zero)
{
helmet.transform.localScale = Vector3.zero;
}
}
private static void EnsureHood(VisEquipment visEq)
{
if (visEq.m_bodyModel == null || visEq.m_bodyModel.bones == null) return;
Transform headBone = FindBoneByName(visEq.m_bodyModel.bones, "Head");
if (headBone == null) return;
Transform existing = headBone.Find(HoodName);
if (existing != null)
{
if (!existing.gameObject.activeSelf) existing.gameObject.SetActive(true);
return;
}
GameObject source = ResolveHoodSource();
if (source == null)
{
// Logged once per player rather than per frame: the early return above means we
// only reach here while the hood is genuinely missing.
Jotunn.Logger.LogWarning(
$"[Dvergur] No hood prefab found among [{string.Join(", ", DvergurConfig.HoodPrefabCandidates)}]; " +
"the helmet slot stays cosmetically empty.");
return;
}
bool wasActive = source.activeSelf;
source.SetActive(false);
GameObject hood = Object.Instantiate(source, headBone, false);
source.SetActive(wasActive);
hood.name = HoodName;
// Strip anything that would make a decorative mesh behave like a world object -
// hover prompts, pickup triggers, physics. Same cleanup the Furling head does.
foreach (MonoBehaviour comp in hood.GetComponentsInChildren<MonoBehaviour>(true))
{
Object.DestroyImmediate(comp);
}
foreach (Rigidbody body in hood.GetComponentsInChildren<Rigidbody>(true))
{
Object.DestroyImmediate(body);
}
foreach (Collider col in hood.GetComponentsInChildren<Collider>(true))
{
Object.DestroyImmediate(col);
}
hood.SetActive(true);
hood.transform.localPosition = DvergurConfig.HoodLocalPosition;
hood.transform.localRotation = Quaternion.Euler(DvergurConfig.HoodLocalRotation);
hood.transform.localScale = Vector3.one * DvergurConfig.HoodLocalScale;
// Without the creature shader the hood ignores the camera's dither fade and blocks
// the view in first person; its own textures are kept.
Shader dither = Shader.Find("Custom/Creature");
if (dither != null)
{
foreach (Renderer renderer in hood.GetComponentsInChildren<Renderer>(true))
{
if (renderer.material != null) renderer.material.shader = dither;
}
}
}
/// <summary>
/// First candidate prefab that resolves wins. A creature prefab is handled specially: the
/// Dvergr's headgear is a child renderer of the creature, not a standalone prefab, so the
/// piece is lifted out rather than the whole NPC being instantiated on the player's head.
/// </summary>
private static GameObject ResolveHoodSource()
{
foreach (string candidate in DvergurConfig.HoodPrefabCandidates)
{
GameObject prefab = PrefabManager.Cache.GetPrefab<GameObject>(candidate);
if (prefab == null) continue;
if (prefab.GetComponent<Character>() == null) return prefab;
foreach (Renderer renderer in prefab.GetComponentsInChildren<Renderer>(true))
{
string name = renderer.gameObject.name.ToLower();
if (name.Contains("helmet") || name.Contains("hat") || name.Contains("hood") || name.Contains("cap"))
{
return renderer.gameObject;
}
}
}
return null;
}
private static void RemoveHood(VisEquipment visEq)
{
if (visEq.m_bodyModel == null || visEq.m_bodyModel.bones == null) return;
Transform headBone = FindBoneByName(visEq.m_bodyModel.bones, "Head");
if (headBone == null) return;
Transform hood = headBone.Find(HoodName);
if (hood == null) return; // never was a Dvergur - leave the helmet alone
// Destroy is deferred to the end of the frame, so the object is renamed first: without
// that, every call until it actually goes away finds it again and re-runs the restore.
hood.name = HoodName + "_Removed";
Object.Destroy(hood.gameObject);
GameObject helmet = Traverse.Create(visEq).Field<GameObject>("m_helmetItemInstance").Value;
if (helmet != null && helmet.transform.localScale == Vector3.zero)
{
helmet.transform.localScale = Vector3.one;
}
}
private static Transform FindBoneByName(Transform[] bones, string targetBoneName)
{
foreach (Transform bone in bones)
{
if (bone != null && bone.name == targetBoneName) return bone;
}
string target = targetBoneName.ToLower();
foreach (Transform bone in bones)
{
if (bone != null && bone.name.ToLower().Contains(target)) return bone;
}
return null;
}
}
}

View file

@ -15,7 +15,8 @@ namespace RacesOfValheim
"Skeleton Secrets",
"Furling Secrets",
"Trol Secrets",
"Draugh Secrets"
"Draugh Secrets",
"Dvergur Secrets"
};
public static void UpdateCompendiumText(Player player)
@ -67,6 +68,51 @@ namespace RacesOfValheim
{
GenerateDraughText(knownTexts, state, player);
}
else if (currentRace == DvergurConfig.RaceId)
{
GenerateDvergurText(knownTexts, state);
}
}
/// <summary>
/// Reads its figures straight out of the live rules rather than restating them, so the
/// entry cannot drift from the code the way a hand-written percentage would.
/// </summary>
private static void GenerateDvergurText(Dictionary<string, string> knownTexts, int state)
{
DvergurProgression.DvergurRules rules = DvergurProgression.GetRules(state);
StringBuilder sb = new StringBuilder();
sb.AppendLine("The Dvergur's Craft\n");
sb.AppendLine($"[Base Passive] Small and Stubborn: You stand a third shorter than a human and carry {rules.HealthMalus:0.#} less health for it. The dvergr hood never leaves your head - wear whatever helm you please and keep every point of its protection, but the runes will always show you as one of the deep folk.\n");
List<string> weapons = new List<string>();
foreach (DvergurConfig.WeaponAffinity affinity in rules.Affinities)
{
weapons.Add(affinity.DisplayName);
}
if (weapons.Count > 0)
{
sb.AppendLine($"Weapon Affinity (Passive): {string.Join(", ", weapons.ToArray())}. Blows struck with these land harder and cost less stamina. The saving never grows - a tier only ever hands you another weapon to feel at home with - and your skill rises no faster than anyone else's.\n");
}
if (rules.MiningAffinity)
sb.AppendLine("[Eikthyr Unlock] Mining Affinity (Passive): The pickaxe answers to you. Veins break faster, cost you less stamina to work, and sometimes give up more than they should.\n");
if (rules.SmithingDiscount > 0f)
sb.AppendLine($"[Bonemass Unlock] Smithing and Jewelry (Passive): You waste nothing at the anvil. Metal and gems cost you {rules.SmithingDiscount * 100f:0}% less when crafting and upgrading.\n");
if (rules.TraderBuyDiscount > 0f || rules.TraderSellBonus > 0f)
sb.AppendLine($"[Bonemass Unlock] Kin of the Traders (Passive): Haldor and Hildir know their own. Their prices drop by {rules.TraderBuyDiscount * 100f:0}% for you, and what they pay for your trophies and hunting rewards rises by {rules.TraderSellBonus * 100f:0}%.\n");
if (rules.RunicPing)
sb.AppendLine($"[Yagluth Unlock] Runic Ping ('{DvergurConfig.RunicPingKey}' Key): Spend {DvergurConfig.RunicPingEitrCost:0} eitr to send a pulse through the stone. For {DvergurConfig.RunicPingDuration:0} seconds every ore vein and every hidden enemy within {DvergurConfig.RunicPingRadius:0} meters is lit for you alone.\n");
if (rules.RunicOvercharge)
sb.AppendLine($"[Fader Unlock] Runic Overcharge ('{DvergurConfig.RunicOverchargeKey}' Key): Spend {DvergurConfig.RunicOverchargeEitrCost:0} eitr to load the runes. Your next blow with a favoured weapon lands with {DvergurConfig.RunicOverchargeMultiplier:0}x its weight. Hold the charge no longer than {DvergurConfig.RunicOverchargeWindow:0} seconds or it bleeds away.\n");
knownTexts["Dvergur Secrets"] = sb.ToString();
}
private static void GenerateDraughText(Dictionary<string, string> knownTexts, int state, Player player)

View file

@ -32,6 +32,7 @@ namespace RacesOfValheim
gameObject.AddComponent<FurlingRace>();
gameObject.AddComponent<TrolRace>();
gameObject.AddComponent<DraughRace>();
gameObject.AddComponent<DvergurRace>();
PrefabManager.OnVanillaPrefabsAvailable += CreateAllModAssets;
CommandManager.Instance.AddConsoleCommand(new ResetRaceCommand());
CommandManager.Instance.AddConsoleCommand(new CheckProgressionCommand());
@ -72,6 +73,8 @@ namespace RacesOfValheim
player.GetSEMan().RemoveStatusEffect("SE_SkeletonStats".GetStableHashCode());
player.GetSEMan().RemoveStatusEffect("SE_SkadiStats".GetStableHashCode());
player.GetSEMan().RemoveStatusEffect("SE_SkadiCooldown".GetStableHashCode());
player.GetSEMan().RemoveStatusEffect(DvergurConfig.StatsSE.GetStableHashCode());
player.GetSEMan().RemoveStatusEffect(DvergurConfig.OverchargeSE.GetStableHashCode());
ZNetView nview = player.GetComponent<ZNetView>();
if (nview != null && nview.IsValid()) nview.GetZDO().Set("RacesOfValheim_Race", "Human");
@ -93,6 +96,7 @@ namespace RacesOfValheim
FurlingRace.Instance.CreateModAssets();
TrolRace.Instance.CreateModAssets();
DraughRace.Instance.CreateModAssets();
DvergurRace.Instance.CreateModAssets();
}
// --- RACE SELECTION UI ---
public void ShowRaceSelectionMenu()
@ -233,6 +237,9 @@ namespace RacesOfValheim
CreateRaceButtonWithConfirm("Trol", new Vector2(150, -20), GetTrolIcon(), "Massive brute strength. Towering over others but slow to react.", SelectTrol);
CreateRaceButtonWithConfirm("Draugh", new Vector2(450, -20), GetDraughIcon(), "A decaying undead warrior fueled by dark magic and extreme metal.", SelectDraugh);
// Row 3 (y = -140)
CreateRaceButtonWithConfirm("Dvergur", new Vector2(-450, -140), GetDvergurIcon(), "Small, stubborn smiths of the deep. Frail of frame, but masters of metal, mine and market.", SelectDvergur);
GUIManager.BlockInput(true);
}
@ -575,6 +582,45 @@ namespace RacesOfValheim
return null;
}
private void SelectDvergur()
{
if (Player.m_localPlayer != null)
{
Player.m_localPlayer.m_customData["Race"] = DvergurConfig.RaceId;
ZNetView nview = Player.m_localPlayer.GetComponent<ZNetView>();
if (nview != null && nview.IsValid()) nview.GetZDO().Set("RacesOfValheim_Race", DvergurConfig.RaceId);
Player.m_localPlayer.GetSEMan().AddStatusEffect(DvergurConfig.StatsSE.GetStableHashCode(), true);
// The Dvergur keeps its own skin - only the silhouette and the hood change, so
// UpdateVisuals is enough and UpdateColors has nothing to do here.
VisEquipment visEq = Player.m_localPlayer.GetComponent<VisEquipment>();
if (visEq != null)
{
visEq.GetType().GetMethod("UpdateVisuals", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Public)?.Invoke(visEq, null);
}
Player.m_localPlayer.Message(MessageHud.MessageType.Center, "You chose the path of the Dvergur.");
CloseRaceSelectionMenu();
}
}
private Sprite GetDvergurIcon()
{
GameObject prefab = PrefabManager.Cache.GetPrefab<ItemDrop>("HelmetDverger")?.gameObject;
if (prefab == null) prefab = PrefabManager.Cache.GetPrefab<ItemDrop>("DvergrKeyFragment")?.gameObject;
if (prefab == null) prefab = PrefabManager.Cache.GetPrefab<ItemDrop>("Copper")?.gameObject;
if (prefab != null)
{
ItemDrop drop = prefab.GetComponent<ItemDrop>();
if (drop != null && drop.m_itemData.m_shared.m_icons.Length > 0)
{
return drop.m_itemData.m_shared.m_icons[0];
}
}
return null;
}
public void CloseRaceSelectionMenu()
{
if (raceSelectionMenu != null)

View file

@ -81,6 +81,12 @@ namespace RacesOfValheim
{
// Managed externally in TrolPatches.cs
}
else if (race == DvergurConfig.RaceId)
{
// The hood itself is rebuilt by the VisEquipment patch; this keeps the shrunken
// silhouette and the hidden helmet asserted between those rebuilds.
DvergurVisuals.Apply(m_player);
}
else
{
RevertAllVisuals();