diff --git a/JotunnModStub/Dvergar/DvergarBanco.cs b/JotunnModStub/Dvergar/DvergarBanco.cs
new file mode 100644
index 0000000..2b519aa
--- /dev/null
+++ b/JotunnModStub/Dvergar/DvergarBanco.cs
@@ -0,0 +1,455 @@
+using System.Collections.Generic;
+using HarmonyLib;
+using Jotunn.Configs;
+using Jotunn.Entities;
+using Jotunn.Managers;
+using UnityEngine;
+
+namespace RacesOfValheim
+{
+ ///
+ /// The Dvergar's station: a contract bank. Coin goes on the table, a crew signs on.
+ ///
+ /// The Trol's war totem is the twin of this file and the two should be read together - same five
+ /// group slots, same empty Trader driving vanilla's store window, same "a dead band is money spent".
+ /// What is NOT shared is deliberate: the dvergr are hired professionals rather than a shouted-for
+ /// warband, and everything different here follows from that one sentence.
+ ///
+ /// - they are TAMED and answer the follow command, like every servant in this mod (RaisedThrall);
+ /// - they knit their own wounds shut, the sentry's regeneration reused whole;
+ /// - they are NOT merchants, which costs no code at all: FactionMerchantSetupPatch matches the
+ /// exact prefab name and these clones are DvergarMerc_*. This is the same mechanism that made
+ /// every tameable wolf in the world a shop window until the catalogue stopped listing "Wolf",
+ /// read from the other side;
+ /// - they keep their race's truce. A hired crew walking into a dvergr outpost does not start a
+ /// war with the shopkeeper - see DvergarMercenaryTrucePatch at the bottom, which is the one
+ /// rule in this file that has no counterpart on the totem;
+ /// - they can be given drink, later. Nothing here is needed for that: a rune barrel will buff
+ /// whatever RaisedThrall is bound to this bank's anchor, so the mercenaries need no hook of
+ /// their own and this file does not have to be reopened to add one.
+ ///
+ /// The seekers in the low bands are not allies, they are LEASHED. A dvergr contract sends you two
+ /// workers and their beasts, which is also why the truce has to cover them: wild dvergr shoot
+ /// seekers on sight, and a firefight started by a brood at your heel would be retaliation damage,
+ /// which IsEnemy has no say over once it has begun.
+ ///
+ public static class DvergarBanco
+ {
+ public const string PieceName = "DvergarContractBank";
+ public const string PieceDisplayName = "Contract Bank";
+ public const string RaceId = DvergarConfig.RaceId;
+
+ /// The Queen's drop, mapped to state 7 in BossProgressionManager. Mistlands money for
+ /// a mistlands station: the dvergr do not take Yagluth's leavings seriously.
+ public const string UpgradeItem = "QueenDrop";
+ public const int UpgradeProgressionState = 7; // The Queen
+
+ public const int MaxTroops = 5;
+
+ /// Written into each hired creature's ZDO so the bank can tell its crews apart -
+ /// five slots means counting contracts, not bodies.
+ public const string KeyGroup = "RoV_dvergarGroup";
+
+ public const float LeashRange = 12f;
+ public const float WitherSeconds = 60f;
+ public const float HomeCheckRange = 25f;
+
+ /// No cap: a signed contract walks out as a contract.
+ public const int MaxFollowers = -1;
+
+ // One per square kilometre. Looser than the Fenrir's pen (2.59 km2) because a bank does not
+ // grow anything on its own, stricter than the Trol's totem, which has no limit at all and
+ // should probably get one once it is out of test.
+ public const int MaxBanksInRange = 1;
+ public const float DensityAreaKm2 = 1f;
+
+ // ---------------------------------------------------------------- the look, in metres
+ /// A cartography table, slightly cut down. The dvergr write smaller than we do.
+ private const float TableScale = 0.8f;
+
+ ///
+ /// How high the coin pile sits, in the piece's own space and BEFORE TableScale is applied.
+ /// Unlike the totem's head this is not measured: the table keeps its own vanilla mesh, so
+ /// there is no borrowed holder to call ModelBorrow.HeightOf on. If the pile floats or sinks,
+ /// this is the ONE number to touch.
+ ///
+ private const float PileHeight = 1.05f;
+ private const float PileSize = 0.45f;
+
+ public class Troop
+ {
+ public string Id;
+ public string Display;
+ public int Price;
+ public bool NeedsUpgrade;
+ /// Trophy of whoever leads the crew - the face it wears in the rack.
+ public string Icon;
+ /// Vanilla creature prefab -> how many of it.
+ public KeyValuePair[] Members;
+ }
+
+ // Anchored at the same 400-2000 as the Trol's totem, and laddered against ITS bands rather
+ // than against head count: one Dverger is worth rather more than six greydwarves, so the
+ // bodies come down as the coin goes up and the seekers make up the difference at the bottom.
+ //
+ // The top band is knowingly stronger than the totem's two thousand coin fuling war band. It
+ // sits behind the Queen and it dies for good; if it proves too much in play, the lever is to
+ // drop the support mage out of it before touching the price.
+ public static readonly Troop[] Troops =
+ {
+ new Troop
+ {
+ Id = "escort", Display = "Escort", Price = 400, NeedsUpgrade = false, Icon = "TrophyDvergr",
+ Members = new[]
+ {
+ new KeyValuePair("Dverger", 1),
+ new KeyValuePair("SeekerBrood", 2),
+ }
+ },
+ new Troop
+ {
+ Id = "yard_patrol", Display = "Yard Patrol", Price = 700, NeedsUpgrade = false, Icon = "TrophyDvergr",
+ Members = new[]
+ {
+ new KeyValuePair("Dverger", 2),
+ new KeyValuePair("SeekerBrood", 2),
+ }
+ },
+ new Troop
+ {
+ Id = "fire_crew", Display = "Fire Crew", Price = 1000, NeedsUpgrade = false, Icon = "TrophyDvergr",
+ Members = new[]
+ {
+ new KeyValuePair("Dverger", 1),
+ new KeyValuePair("DvergerMageFire", 1),
+ new KeyValuePair("SeekerBrood", 3),
+ }
+ },
+ new Troop
+ {
+ Id = "runic_crew", Display = "Runic Crew", Price = 1500, NeedsUpgrade = true, Icon = "TrophyDvergr",
+ Members = new[]
+ {
+ new KeyValuePair("Dverger", 2),
+ new KeyValuePair("DvergerMageIce", 1),
+ new KeyValuePair("DvergerMageSupport", 1),
+ }
+ },
+ new Troop
+ {
+ Id = "ash_guard", Display = "Ash Guard", Price = 2000, NeedsUpgrade = true, Icon = "TrophySeekerBrute",
+ Members = new[]
+ {
+ new KeyValuePair("DvergerAshlands", 2),
+ new KeyValuePair("DvergerMageSupport", 1),
+ new KeyValuePair("SeekerBrute", 1),
+ }
+ },
+ };
+
+ public static Troop Find(string id)
+ {
+ foreach (Troop troop in Troops) if (troop.Id == id) return troop;
+ return null;
+ }
+
+ ///
+ /// What this player actually pays, after the Dvergar's own trader discount.
+ ///
+ /// It reads the LOCAL player's tier, which is correct rather than convenient: the coin comes
+ /// out of that player's own inventory, on that player's own client, and a contract bank is not
+ /// a shared till. The discount table stops at 25% at state 7 (DvergarConfig.cs), which is the
+ /// same state that unlocks the two upgraded bands - so the top of the list can never be
+ /// discounted before it can be bought, and no separate ceiling is needed.
+ ///
+ public static int PriceFor(Troop troop)
+ {
+ if (troop == null) return 0;
+
+ float discount = Mathf.Clamp01(DvergarProgression.Current.TraderBuyDiscount);
+ return Mathf.Max(1, Mathf.RoundToInt(troop.Price * (1f - discount)));
+ }
+
+ /// Every distinct creature the bank can hire, so their clones exist before anyone signs.
+ private static readonly Dictionary HiredPrefabs = new Dictionary();
+
+ public static string HiredNameFor(string vanillaPrefab) =>
+ HiredPrefabs.TryGetValue(vanillaPrefab, out string name) ? name : null;
+
+ /// The mercenary prefabs, by name, so the truce can recognise its own cheaply.
+ private static readonly HashSet HiredNames = new HashSet();
+
+ public static bool IsHiredName(string prefabName) =>
+ !string.IsNullOrEmpty(prefabName) && HiredNames.Contains(prefabName);
+
+ public static void Register()
+ {
+ HashSet sources = new HashSet();
+ foreach (Troop troop in Troops)
+ {
+ foreach (KeyValuePair member in troop.Members) sources.Add(member.Key);
+ }
+ foreach (string source in sources) RegisterHired(source);
+
+ RegisterPiece();
+
+ PieceDensityLimit.Register(PieceName,
+ PieceDensityLimit.RadiusForArea(DensityAreaKm2), MaxBanksInRange,
+ "There is already {0} contract bank within a day's walk. One ledger per valley.");
+ }
+
+ // ---------------------------------------------------------------- the hired
+
+ ///
+ /// One signed mercenary: the vanilla creature, tamed, leashed, healing, and worth nothing dead.
+ ///
+ /// CharacterDrop is destroyed for the reason it always is here, and it matters more on this
+ /// chain than on any other: dvergr and seekers both carry loot that SELLS. A mercenary that
+ /// dropped its own parts would make the bank a way of turning coin into more coin.
+ ///
+ private static void RegisterHired(string source)
+ {
+ string prefabName = "DvergarMerc_" + source;
+
+ GameObject prefab = PrefabManager.Instance.CreateClonedPrefab(prefabName, source);
+ if (prefab == null)
+ {
+ Jotunn.Logger.LogWarning($"[Dvergar] Could not clone {source}; that crew member cannot be hired. " +
+ "The rest of its band still signs on without it.");
+ return;
+ }
+
+ BaseAI ai = prefab.GetComponent();
+ if (ai != null) ai.m_randomMoveRange = LeashRange;
+
+ foreach (CharacterDrop drops in prefab.GetComponentsInChildren(true))
+ {
+ if (drops != null) Object.DestroyImmediate(drops);
+ }
+
+ RaisedThrall thrall = prefab.AddComponent();
+ thrall.m_kind = prefabName;
+ thrall.m_commandingRace = RaceId;
+ thrall.m_maxFollowers = MaxFollowers;
+ thrall.m_witherSeconds = WitherSeconds;
+ thrall.m_homeCheckRange = HomeCheckRange;
+ thrall.m_refusalMessage = "Your name is not on the contract.";
+
+ // Ten seconds unhurt, then two percent a second - the sentry's regeneration, shared with
+ // the Trol's troops and the Fenrir's pack. A dead mercenary still stays dead.
+ prefab.AddComponent();
+
+ PrefabManager.Instance.AddPrefab(prefab);
+ HiredPrefabs[source] = prefabName;
+ HiredNames.Add(prefabName);
+ }
+
+ // ---------------------------------------------------------------- the bank
+
+ private static void RegisterPiece()
+ {
+ GameObject prefab = PrefabManager.Instance.CreateClonedPrefab(PieceName, "piece_cartographytable");
+ if (prefab == null)
+ {
+ Jotunn.Logger.LogWarning("[Dvergar] Could not clone piece_cartographytable; the contract bank " +
+ "is not registered.");
+ return;
+ }
+
+ // EVERY behaviour goes except the three that make it a building, and the blanket sweep is
+ // the point rather than laziness: the cartography table's MapTable is Interactable AND
+ // Hoverable, so it takes the E key before our own Switch ever sees it and opens the shared
+ // map instead of the ledger. That is the same bug as the barrel's Container on the Fenrir
+ // trough and the Trader on the vanilla wolf, and stripping by capability instead of by
+ // type name means it cannot come back if a future patch renames or adds a component.
+ //
+ // Unlike the Trol's totem the renderers are KEPT: the table is the look, there is nothing
+ // borrowed underneath it.
+ foreach (MonoBehaviour behaviour in prefab.GetComponentsInChildren(true))
+ {
+ if (behaviour == null) continue;
+ if (behaviour is Piece || behaviour is ZNetView || behaviour is WearNTear) continue;
+ Object.DestroyImmediate(behaviour);
+ }
+
+ AswidBloodRefinery.StripOffensive(prefab, PieceName);
+
+ prefab.transform.localScale = Vector3.one * TableScale;
+
+ DvergarBancoBehaviour bank = prefab.AddComponent();
+
+ foreach (Switch existing in prefab.GetComponentsInChildren(true))
+ {
+ if (existing != null) Object.DestroyImmediate(existing);
+ }
+ bank.m_switch = prefab.AddComponent();
+ bank.m_switch.m_name = PieceDisplayName;
+
+ // An empty catalogue IS the design: the bank sells crews and buys nothing. Every list is
+ // filled in even though this trader never talks, because a Trader added with AddComponent
+ // comes up with all of them null and Trader.Interact walks into Say(m_randomStartTrade)
+ // if the player's E happens to reach it instead of our Switch.
+ //
+ // The empty list would also throw out of StoreGui.FillList on its last instruction - that
+ // is fixed once and for everyone by StoreGuiEmptyCatalogueGuardPatch over in
+ // Trol/TrolTotemStore.cs, which is generic and is deliberately NOT copied here.
+ Trader trader = prefab.GetComponent() ?? prefab.AddComponent();
+ trader.m_name = PieceDisplayName;
+ trader.m_items = new List();
+ trader.m_useItems = new List();
+ trader.m_randomTalk = new List();
+ trader.m_randomGreets = new List();
+ trader.m_randomGoodbye = new List();
+ trader.m_randomStartTrade = new List();
+ trader.m_randomBuy = new List();
+ trader.m_randomSell = new List();
+ trader.m_randomGiveItemNo = new List();
+ trader.m_randomUseItemAlreadyRecieved = new List();
+ trader.m_randomTalkConditionals = new List();
+
+ // The mark of a bank that has been paid: a heap of coin on the table, hidden until the
+ // Queen has fallen and the ledger has been rewritten.
+ //
+ // 'treasure_pile' is the player's own choice of prop and is NOT verified against this
+ // build - nothing else in the project references it. ModelBorrow is null-safe by
+ // construction, so a wrong name costs exactly one warning in the log and an empty holder;
+ // if that warning appears, 'Coins' is the fallback and this is a one-string change.
+ bank.m_coinPile = ModelBorrow.Attach(prefab.transform, "BankCoinPile", "treasure_pile",
+ new Vector3(0f, PileHeight, 0f), Quaternion.identity,
+ PileSize, "Dvergar");
+ bank.m_coinPile.SetActive(false);
+
+ Piece piece = prefab.GetComponent() ?? prefab.AddComponent();
+ piece.m_craftingStation = null; // a bank is built where the work is, not at a bench
+ piece.m_resources = new Piece.Requirement[0];
+ piece.m_name = PieceDisplayName;
+ piece.m_canBeRemoved = true;
+ piece.m_groundPiece = true;
+ piece.m_groundOnly = true;
+ piece.m_icon = BorrowIcon("TrophyDvergr");
+
+ Piece template = PrefabManager.Cache.GetPrefab("piece_workbench");
+ if (template != null && template.m_placeEffect != null) piece.m_placeEffect = template.m_placeEffect;
+
+ // Coin in the RECIPE, and that is the whole reason this chain needs no gate item bought
+ // from a merchant the way the other three do: the Dvergar pay for everything, so the
+ // station opens by being paid for rather than by being unlocked.
+ PieceManager.Instance.AddPiece(new CustomPiece(prefab, fixReference: false, new PieceConfig
+ {
+ Name = PieceDisplayName,
+ Description = "A ledger, a seal and a heap of coin. Sign here and someone else does the dying.",
+ PieceTable = PieceTables.Hammer,
+ Category = PieceCategories.Crafting,
+ Icon = BorrowIcon("TrophyDvergr"),
+ Requirements = new[]
+ {
+ new RequirementConfig("BlackMarble", 10, 0, true),
+ new RequirementConfig("YggdrasilWood", 5, 0, true),
+ new RequirementConfig("Sap", 2, 0, true),
+ new RequirementConfig("Coins", 100, 0, true),
+ }
+ }));
+ }
+
+ public static void EnsureKnown(Player player)
+ {
+ if (player == null) return;
+
+ GameObject prefab = PrefabManager.Instance.GetPrefab(PieceName);
+ Piece piece = prefab != null ? prefab.GetComponent() : null;
+ if (piece == null) return;
+
+ Traverse traverse = Traverse.Create(player);
+ traverse.Method("AddKnownPiece", piece).GetValue();
+ traverse.Method("UpdateAvailablePiecesList").GetValue();
+ }
+
+ private static Sprite BorrowIcon(string prefabName)
+ {
+ ItemDrop drop = PrefabManager.Cache.GetPrefab(prefabName);
+ Sprite[] icons = drop != null && drop.m_itemData != null && drop.m_itemData.m_shared != null
+ ? drop.m_itemData.m_shared.m_icons
+ : null;
+ return icons != null && icons.Length > 0 ? icons[0] : null;
+ }
+ }
+
+ [HarmonyPatch(typeof(Player), "OnSpawned")]
+ public static class DvergarBancoKnownPatch
+ {
+ public static void Postfix(Player __instance)
+ {
+ if (__instance != Player.m_localPlayer) return;
+ DvergarBanco.EnsureKnown(__instance);
+ }
+ }
+
+ ///
+ /// The race lock, caught at placement so the marble and the coin are not spent before the refusal.
+ /// The same shape as TrolTotemRaceLockPatch - the second station in the mod that refuses the hammer
+ /// outright, because hiring dvergr with dvergr money is the race's identity and not a tool it owns.
+ ///
+ [HarmonyPatch(typeof(Player), "PlacePiece",
+ new[] { typeof(Piece), typeof(Vector3), typeof(Quaternion), typeof(bool) })]
+ public static class DvergarBancoRaceLockPatch
+ {
+ public static bool Prefix(Player __instance, Piece __0)
+ {
+ if (__instance != Player.m_localPlayer || __0 == null) return true;
+ if (Utils.GetPrefabName(__0.gameObject) != DvergarBanco.PieceName) return true;
+ if (DvergarRace.IsDvergar()) return true;
+
+ __instance.Message(MessageHud.MessageType.Center, "The contract is in runic. You do not sign it.");
+ return false;
+ }
+ }
+
+ ///
+ /// A hired crew keeps its employer's truce.
+ ///
+ /// Without this the station fights itself: a Dvergar player is at peace with the mountain's dvergr
+ /// (FactionHostilityPatch), and those dvergr are where the player BUYS - so walking into an outpost
+ /// with an escort would mean the escort killing the shopkeeper. Taming a creature puts it in the
+ /// player faction, which makes it an enemy of everything the player is merely not fighting.
+ ///
+ /// One condition covers the whole band, seekers included, because every hired body is a RaisedThrall
+ /// carrying the same commanding race - so the leashed brood at your heel is as welcome in an outpost
+ /// as the dvergr holding its chain, even though wild dvergr shoot seekers on sight. That was the
+ /// player's call and it is the only reason a bank is usable in the mistlands at all: retaliation
+ /// damage does not go through IsEnemy, so one shot fired by an outpost would have escalated into a
+ /// war this patch could no longer stop.
+ ///
+ /// A postfix that only ever says "not enemies", layered on top of the older hostility patch on the
+ /// same method exactly as that one layers on RaceHostilityManager. It cannot make anything hostile
+ /// that was not already.
+ ///
+ [HarmonyPatch(typeof(BaseAI), nameof(BaseAI.IsEnemy), new System.Type[] { typeof(Character), typeof(Character) })]
+ public static class DvergarMercenaryTrucePatch
+ {
+ /// The mountain's dvergr, by prefab name. The same roster FactionHostilityPatch uses
+ /// for the player's own truce - kept as its own copy so a change to one is a deliberate change
+ /// to that one, since these two lists answer different questions.
+ private static readonly HashSet WildDvergr = new HashSet
+ {
+ "Dverger", "DvergerMageFire", "DvergerMageIce", "DvergerMageSupport", "DvergerAshlands",
+ };
+
+ public static void Postfix(Character a, Character b, ref bool __result)
+ {
+ if (!__result) return; // already not enemies, nothing to add
+ if (a == null || b == null) return;
+
+ if (IsTruce(a, b) || IsTruce(b, a)) __result = false;
+ }
+
+ /// True if is one of ours and is
+ /// a wild dvergr.
+ private static bool IsTruce(Character mercenary, Character other)
+ {
+ RaisedThrall thrall = mercenary.GetComponent();
+ if (thrall == null || thrall.m_commandingRace != DvergarBanco.RaceId) return false;
+
+ return WildDvergr.Contains(Utils.GetPrefabName(other.gameObject));
+ }
+ }
+}
diff --git a/JotunnModStub/Dvergar/DvergarBancoBehaviour.cs b/JotunnModStub/Dvergar/DvergarBancoBehaviour.cs
new file mode 100644
index 0000000..dbbfa6e
--- /dev/null
+++ b/JotunnModStub/Dvergar/DvergarBancoBehaviour.cs
@@ -0,0 +1,290 @@
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace RacesOfValheim
+{
+ ///
+ /// The bank's logic: five contracts, bought with coin, and no way to cancel one.
+ ///
+ /// Slots count CREWS, not bodies - a fire crew of five is one slot, and it stays one slot as its
+ /// members die. Each hired body carries its crew's id in its own ZDO, so the count survives a reload
+ /// and corrects itself when a whole crew is wiped, with nothing tallied anywhere.
+ ///
+ /// This is TrolTotemBehaviour's twin and was written from it. The differences are all consequences
+ /// of one thing - these are paid professionals rather than a shouted-for warband:
+ /// - the price a player pays is discounted by their own Dvergar tier (DvergarBanco.PriceFor);
+ /// - the upgrade is the Queen's drop rather than Yagluth's, and it puts coin on the table
+ /// instead of a head on a post.
+ /// If a bug is found in one of the two files, look for it in the other before assuming it is local.
+ ///
+ public class DvergarBancoBehaviour : MonoBehaviour
+ {
+ public Switch m_switch;
+ public GameObject m_coinPile;
+
+ private const string KeyUpgraded = "RoV_dvergarBankUpgraded";
+ private const string KeyNextGroup = "RoV_dvergarBankNextGroup";
+
+ private ZNetView m_nview;
+
+ private void Awake()
+ {
+ RaisedThrall.RegisterStation(transform);
+
+ m_nview = GetComponent();
+ if (m_nview == null || m_nview.GetZDO() == null) return;
+
+ if (m_switch != null)
+ {
+ m_switch.m_onUse = OnUse;
+ m_switch.m_onHover = Hover;
+ }
+
+ m_nview.Register("RoV_DvergarHire", RPC_Hire);
+ m_nview.Register("RoV_DvergarUpgrade", RPC_Upgrade);
+
+ InvokeRepeating("UpdatePile", 0.5f, 2f);
+ }
+
+ private void OnDestroy()
+ {
+ RaisedThrall.UnregisterStation(transform);
+ }
+
+ /// The coin is mounted from the start; the tier decides whether it is there to see.
+ private void UpdatePile()
+ {
+ if (m_coinPile != null) m_coinPile.SetActive(IsUpgraded());
+ }
+
+ // ---------------------------------------------------------------- interaction
+
+ private bool OnUse(Switch caller, Humanoid user, ItemDrop.ItemData item)
+ {
+ Player player = user as Player;
+ if (player == null) return false;
+
+ if (!DvergarRace.IsDvergar())
+ {
+ player.Message(MessageHud.MessageType.Center, "The ledger is not written for you.");
+ return false;
+ }
+
+ // The Queen's drop in hand rewrites the ledger: coin on the table, and two more crews.
+ if (item != null && item.m_dropPrefab != null && item.m_dropPrefab.name == DvergarBanco.UpgradeItem)
+ {
+ return TryUpgrade(player, item);
+ }
+
+ if (item != null)
+ {
+ player.Message(MessageHud.MessageType.Center, "$msg_wontwork");
+ return false;
+ }
+
+ return OpenStore(player);
+ }
+
+ private bool TryUpgrade(Player player, ItemDrop.ItemData item)
+ {
+ if (IsUpgraded())
+ {
+ player.Message(MessageHud.MessageType.Center, "It has already had one.");
+ return false;
+ }
+
+ if (BossProgressionManager.GetCurrentProgressionState() < DvergarBanco.UpgradeProgressionState)
+ {
+ player.Message(MessageHud.MessageType.Center, "Not while she still sits under the mist.");
+ return false;
+ }
+
+ player.GetInventory().RemoveItem(item, 1);
+ m_nview.InvokeRPC("RoV_DvergarUpgrade");
+ player.Message(MessageHud.MessageType.Center, "The ledger is rewritten. Better names sign it now.");
+ return true;
+ }
+
+ ///
+ /// Opens the vanilla store window, with the crew column hung off it by DvergarBancoStore. A
+ /// Trader has to be present for StoreGui.Show to have anything to show; this one's catalogue is
+ /// empty, which is how "hires crews, buys nothing" is expressed.
+ ///
+ private bool OpenStore(Player player)
+ {
+ Trader trader = GetComponent();
+ if (trader == null || StoreGui.instance == null)
+ {
+ player.Message(MessageHud.MessageType.Center, "The ledger is shut.");
+ return false;
+ }
+
+ // Nothing is handed to the panel: DvergarBancoStore reads the bank back out of StoreGui's
+ // own m_trader when it repaints, so the window cannot draw one bank's crews while showing
+ // another's, and there is no static left over to go stale.
+ StoreGui.instance.Show(trader);
+ return true;
+ }
+
+ // ---------------------------------------------------------------- what the store calls
+
+ /// Sign a crew by id, from a row the player clicked. Every check TryHire made applies.
+ public void HireFromStore(string troopId)
+ {
+ Player player = Player.m_localPlayer;
+ if (player == null) return;
+
+ DvergarBanco.Troop troop = DvergarBanco.Find(troopId);
+ if (troop == null) return;
+ if (troop.NeedsUpgrade && !IsUpgraded()) return;
+
+ if (CountGroups() >= DvergarBanco.MaxTroops)
+ {
+ player.Message(MessageHud.MessageType.Center, "Five contracts is all the ledger holds.");
+ return;
+ }
+
+ Inventory inventory = player.GetInventory();
+ if (inventory == null) return;
+
+ // Priced here and NOT on the way in from the row: the button only draws a number, and the
+ // player's tier could have changed since the window was opened.
+ int price = DvergarBanco.PriceFor(troop);
+
+ if (CountCoins(inventory) < price)
+ {
+ player.Message(MessageHud.MessageType.Center, "$msg_notenoughmoney");
+ return;
+ }
+
+ TakeCoins(inventory, price);
+ m_nview.InvokeRPC("RoV_DvergarHire", troop.Id);
+ player.Message(MessageHud.MessageType.Center, $"{troop.Display} signs on.");
+ }
+
+ private const string CoinsPrefab = "Coins";
+
+ private static int CountCoins(Inventory inventory)
+ {
+ int total = 0;
+ foreach (ItemDrop.ItemData item in inventory.GetAllItems())
+ {
+ if (item != null && item.m_dropPrefab != null && item.m_dropPrefab.name == CoinsPrefab)
+ {
+ total += item.m_stack;
+ }
+ }
+ return total;
+ }
+
+ private static void TakeCoins(Inventory inventory, int amount)
+ {
+ foreach (ItemDrop.ItemData item in new List(inventory.GetAllItems()))
+ {
+ if (amount <= 0) return;
+ if (item == null || item.m_dropPrefab == null || item.m_dropPrefab.name != CoinsPrefab) continue;
+
+ int take = Mathf.Min(amount, item.m_stack);
+ inventory.RemoveItem(item, take);
+ amount -= take;
+ }
+ }
+
+ // ---------------------------------------------------------------- hiring
+
+ private void RPC_Hire(long sender, string troopId)
+ {
+ if (!m_nview.IsOwner()) return;
+
+ DvergarBanco.Troop troop = DvergarBanco.Find(troopId);
+ if (troop == null || CountGroups() >= DvergarBanco.MaxTroops) return;
+ if (troop.NeedsUpgrade && !IsUpgraded()) return;
+
+ int next = m_nview.GetZDO().GetInt(KeyNextGroup) + 1;
+ m_nview.GetZDO().Set(KeyNextGroup, next);
+ string group = troopId + "#" + next;
+
+ foreach (KeyValuePair member in troop.Members)
+ {
+ string hired = DvergarBanco.HiredNameFor(member.Key);
+ if (hired == null) continue;
+
+ GameObject prefab = ZNetScene.instance != null ? ZNetScene.instance.GetPrefab(hired) : null;
+ if (prefab == null)
+ {
+ Jotunn.Logger.LogWarning($"[Dvergar] No '{hired}' in ZNetScene; part of {troop.Display} " +
+ "did not turn up for work.");
+ continue;
+ }
+
+ for (int i = 0; i < member.Value; i++) SpawnOne(prefab, group);
+ }
+ }
+
+ private void SpawnOne(GameObject prefab, string group)
+ {
+ Vector3 offset = Random.insideUnitSphere * 3f;
+ offset.y = 0f;
+ Vector3 position = transform.position + offset + Vector3.up * 0.5f;
+
+ GameObject spawned = Instantiate(prefab, position, Quaternion.Euler(0f, Random.Range(0, 360), 0f));
+
+ ZNetView nview = spawned.GetComponent();
+ if (nview != null && nview.IsValid()) nview.GetZDO().Set(DvergarBanco.KeyGroup, group);
+
+ RaisedThrall thrall = spawned.GetComponent();
+ if (thrall != null) thrall.Bind(transform.position);
+ }
+
+ private void RPC_Upgrade(long sender)
+ {
+ if (!m_nview.IsOwner()) return;
+ m_nview.GetZDO().Set(KeyUpgraded, true);
+ }
+
+ // ---------------------------------------------------------------- state
+
+ public bool IsUpgraded() =>
+ m_nview != null && m_nview.IsValid() && m_nview.GetZDO().GetBool(KeyUpgraded, false);
+
+ private static string GroupOf(RaisedThrall thrall)
+ {
+ ZNetView nview = thrall != null ? thrall.GetComponent() : null;
+ if (nview == null || !nview.IsValid()) return null;
+
+ string group = nview.GetZDO().GetString(DvergarBanco.KeyGroup, "");
+ return string.IsNullOrEmpty(group) ? null : group;
+ }
+
+ ///
+ /// Live crews, counted as distinct groups rather than as bodies. Nothing is stored: the count
+ /// is the truth, and it corrects itself the moment a crew is wiped out.
+ ///
+ public int CountGroups()
+ {
+ HashSet groups = new HashSet();
+ foreach (RaisedThrall thrall in RaisedThrall.BoundTo(transform.position))
+ {
+ string group = GroupOf(thrall);
+ if (group != null) groups.Add(group);
+ }
+ return groups.Count;
+ }
+
+ private string Hover()
+ {
+ string body = $"contracts {CountGroups()}/{DvergarBanco.MaxTroops}";
+
+ // Said in as many words: a player who cannot see their own discount will read the lower
+ // number in the window as a mistake.
+ float discount = Mathf.Clamp01(DvergarProgression.Current.TraderBuyDiscount);
+ if (discount > 0f) body += $"\nyour seal is worth {Mathf.RoundToInt(discount * 100f)}% off";
+
+ if (!IsUpgraded()) body += "\n(what the Queen left behind buys two more crews)";
+
+ body += "\n[$KEY_Use ] Read the ledger";
+
+ return Localization.instance.Localize($"{DvergarBanco.PieceDisplayName} ({body})");
+ }
+ }
+}
diff --git a/JotunnModStub/Dvergar/DvergarBancoStore.cs b/JotunnModStub/Dvergar/DvergarBancoStore.cs
new file mode 100644
index 0000000..e225ae0
--- /dev/null
+++ b/JotunnModStub/Dvergar/DvergarBancoStore.cs
@@ -0,0 +1,211 @@
+using System.Collections.Generic;
+using System.Text;
+using HarmonyLib;
+using TMPro;
+using UnityEngine;
+using UnityEngine.UI;
+
+namespace RacesOfValheim
+{
+ ///
+ /// The contract bank's window: the merchant's own store, with a column of hireable crews in it.
+ ///
+ /// TWINNED WITH Trol/TrolTotemStore.cs. This is a copy of that file, taken deliberately rather than
+ /// refactored into something shared, so the Trol's totem is not touched while it is in test - the
+ /// two are the same panel drawn from a different roster. A FIX TO ONE BELONGS IN THE OTHER; when
+ /// the totem is settled they should collapse into one panel driven by a common station interface.
+ ///
+ /// Two things are deliberately NOT copied across:
+ /// - StoreGuiEmptyCatalogueGuardPatch, which is what stops vanilla FillList throwing on an empty
+ /// catalogue and taking every postfix down with it. It is generic - it fires for any trader with
+ /// nothing to sell - so it already covers this bank, and a second copy would just be a second
+ /// prefix on the same method doing the same work.
+ /// - the slot rack. There was one on the totem and it was removed at the player's call: a crew
+ /// that dies is dead, and a butcher knife already dismisses one that has outlived its use.
+ ///
+ /// The two columns cannot collide. Each one clears itself at the top of its own Refresh and only
+ /// switches on when the trader the window belongs to carries ITS behaviour, so at most one is ever
+ /// drawn - a bank is not a totem.
+ ///
+ public static class DvergarBancoStore
+ {
+ private static RectTransform _crewList;
+ private static readonly List _rows = new List();
+
+ ///
+ /// The bank the open window belongs to, read back out of StoreGui's own m_trader rather than
+ /// pushed in before Show(). Same field the factions sell panel and the totem's column read.
+ ///
+ public static DvergarBancoBehaviour ActiveBank(StoreGui gui)
+ {
+ Trader trader = FactionMerchantRuntime.GetActiveTrader(gui);
+ return trader != null ? trader.GetComponent() : null;
+ }
+
+ // ---------------------------------------------------------------- build
+
+ public static void Create(StoreGui gui)
+ {
+ if (gui == null || gui.m_listRoot == null)
+ {
+ Jotunn.Logger.LogWarning("[Dvergar] StoreGui has no m_listRoot; the contract bank's window " +
+ "cannot be built.");
+ return;
+ }
+ if (_crewList != null) return;
+
+ GameObject clone = Object.Instantiate(gui.m_listRoot.gameObject, gui.m_listRoot.parent);
+ clone.name = "DvergarCrewList";
+ _crewList = clone.GetComponent();
+ _crewList.anchoredPosition = gui.m_listRoot.anchoredPosition;
+
+ // The clone carries whatever rows the vanilla list held at Awake. Usually none, but a
+ // leftover would sit under ours forever, so it starts empty by construction.
+ foreach (Transform child in _crewList) Object.Destroy(child.gameObject);
+
+ _crewList.gameObject.SetActive(false);
+ }
+
+ public static void Clear()
+ {
+ foreach (GameObject row in _rows) if (row != null) Object.Destroy(row);
+ _rows.Clear();
+
+ if (_crewList != null) _crewList.gameObject.SetActive(false);
+ }
+
+ // ---------------------------------------------------------------- fill
+
+ public static void Refresh(StoreGui gui)
+ {
+ Clear();
+
+ DvergarBancoBehaviour bank = ActiveBank(gui);
+ if (bank == null) return; // an ordinary merchant, or the Trol's totem. Not ours.
+
+ if (_crewList == null)
+ {
+ Jotunn.Logger.LogWarning("[Dvergar] The contract bank's column was never built (did the patch " +
+ "on StoreGui.Awake fail?), so nothing can be drawn into it.");
+ return;
+ }
+
+ _crewList.gameObject.SetActive(true);
+
+ int row = 0;
+ int hidden = 0;
+ foreach (DvergarBanco.Troop troop in DvergarBanco.Troops)
+ {
+ if (troop.NeedsUpgrade && !bank.IsUpgraded()) { hidden++; continue; }
+ BuildRow(gui, bank, troop, row++);
+ }
+
+ float baseSize = Traverse.Create(gui).Field("m_itemlistBaseSize").GetValue();
+ _crewList.SetSizeWithCurrentAnchors(RectTransform.Axis.Vertical,
+ Mathf.Max(baseSize, row * gui.m_itemSpacing));
+
+ Jotunn.Logger.LogInfo($"[Dvergar] Contract bank window: {row} crews on offer, {hidden} still behind " +
+ $"the Queen, {bank.CountGroups()}/{DvergarBanco.MaxTroops} contracts live.");
+ }
+
+ private static void BuildRow(StoreGui gui, DvergarBancoBehaviour bank, DvergarBanco.Troop troop, int rowIndex)
+ {
+ GameObject element = Object.Instantiate(gui.m_listElement, _crewList);
+ element.SetActive(true);
+
+ RectTransform rt = (RectTransform)element.transform;
+ float offset = (_crewList.rect.width - rt.rect.width) / 2f;
+ rt.anchoredPosition = new Vector2(offset, rowIndex * -gui.m_itemSpacing - offset);
+
+ Sprite icon = TrophyIcon(troop.Icon);
+ Image iconImage = element.transform.Find("icon").GetComponent();
+ if (icon != null) iconImage.sprite = icon;
+ else Jotunn.Logger.LogWarning($"[Dvergar] No icon on '{troop.Icon}' for {troop.Display}; the row " +
+ "keeps whatever the cloned element was showing.");
+
+ element.transform.Find("name").GetComponent().text = troop.Display;
+
+ // The DISCOUNTED price, because that is what will actually leave the player's pocket.
+ TMP_Text price = FindDescendant(element.transform, "price");
+ if (price != null) price.text = DvergarBanco.PriceFor(troop).ToString();
+
+ UITooltip tooltip = element.GetComponent();
+ if (tooltip != null) tooltip.Set(troop.Display, Composition(troop), gui.m_tooltipAnchor, default(Vector2));
+
+ string id = troop.Id;
+ element.GetComponent().onClick.AddListener(() =>
+ {
+ bank.HireFromStore(id);
+ Traverse.Create(gui).Method("FillList").GetValue(); // repaints the column
+ });
+
+ _rows.Add(element);
+ }
+
+ /// Who actually turns up, so two thousand coin is not spent blind.
+ private static string Composition(DvergarBanco.Troop troop)
+ {
+ StringBuilder text = new StringBuilder();
+ foreach (KeyValuePair member in troop.Members)
+ {
+ if (text.Length > 0) text.Append('\n');
+ text.Append(member.Value).Append(" x ").Append(CreatureName(member.Key));
+ }
+
+ int full = troop.Price;
+ int paid = DvergarBanco.PriceFor(troop);
+ if (paid < full) text.Append("\n\nList price ").Append(full).Append(" - your seal takes it to ").Append(paid).Append('.');
+
+ text.Append("\n\nThey answer the follow command, knit their own wounds shut, keep your truce with " +
+ "the mountain's dvergr, drop nothing, and do not come back. A dead crew is money spent.");
+ return text.ToString();
+ }
+
+ private static string CreatureName(string prefabName)
+ {
+ Character character = Jotunn.Managers.PrefabManager.Cache.GetPrefab(prefabName);
+ if (character == null || string.IsNullOrEmpty(character.m_name)) return prefabName;
+ return Localization.instance.Localize(character.m_name);
+ }
+
+ // ---------------------------------------------------------------- helpers
+
+ private static Sprite TrophyIcon(string prefabName)
+ {
+ if (string.IsNullOrEmpty(prefabName)) return null;
+
+ ItemDrop drop = Jotunn.Managers.PrefabManager.Cache.GetPrefab(prefabName);
+ Sprite[] icons = drop != null && drop.m_itemData != null && drop.m_itemData.m_shared != null
+ ? drop.m_itemData.m_shared.m_icons
+ : null;
+ return icons != null && icons.Length > 0 ? icons[0] : null;
+ }
+
+ private static T FindDescendant(Transform root, string childName) where T : Component
+ {
+ foreach (T candidate in root.GetComponentsInChildren(true))
+ {
+ if (candidate.gameObject.name == childName) return candidate;
+ }
+ return null;
+ }
+ }
+
+ [HarmonyPatch(typeof(StoreGui), "Awake")]
+ public static class DvergarBancoStoreSetupPatch
+ {
+ public static void Postfix(StoreGui __instance) => DvergarBancoStore.Create(__instance);
+ }
+
+ [HarmonyPatch(typeof(StoreGui), "FillList")]
+ public static class DvergarBancoStoreFillPatch
+ {
+ public static void Postfix(StoreGui __instance) => DvergarBancoStore.Refresh(__instance);
+ }
+
+ [HarmonyPatch(typeof(StoreGui), "Hide")]
+ public static class DvergarBancoStoreHidePatch
+ {
+ public static void Postfix() => DvergarBancoStore.Clear();
+ }
+}
diff --git a/JotunnModStub/Dvergar/DvergarBotte.cs b/JotunnModStub/Dvergar/DvergarBotte.cs
new file mode 100644
index 0000000..2a2bbeb
--- /dev/null
+++ b/JotunnModStub/Dvergar/DvergarBotte.cs
@@ -0,0 +1,309 @@
+using System.Collections.Generic;
+using System.Reflection;
+using System.Text;
+using HarmonyLib;
+using Jotunn.Configs;
+using Jotunn.Entities;
+using Jotunn.Managers;
+using UnityEngine;
+
+namespace RacesOfValheim
+{
+ ///
+ /// The rune barrel: drink for a hired crew.
+ ///
+ /// Second half of the Dvergar chain and the answer to "can they be given potions". They can, and it
+ /// costs the mercenaries nothing of their own - a creature carries an SEMan exactly like a player
+ /// does, so the barrel pours a vanilla consumable's own status effect straight into whoever is
+ /// standing around it. Nothing new had to be added to DvergarBanco.cs for this to work, which was
+ /// the whole point of choosing a barrel over a hand-held flask: the buff is something you PREPARE
+ /// before walking out, not a button you press mid-fight.
+ ///
+ /// WHAT ACTUALLY WORKS IS NOT A DESIGN DECISION, IT IS A FACT ABOUT EACH POTION. A mead that heals
+ /// over time heals a dvergr; a mead that regenerates stamina does nothing at all, because a creature
+ /// has no stamina bar to fill. The barrel therefore refuses nothing and promises nothing - it pours
+ /// what you put in it. `dumppotions` at the bottom of this file is how the two lists were told
+ /// apart: it reads every consumable in ObjectDB and reports, by reflection, what its effect actually
+ /// carries, so no guess about a field name is involved.
+ ///
+ /// The serving code is race-agnostic on purpose - it drinks to any RaisedThrall in range, whoever
+ /// raised it - but the piece itself is locked to the Dvergar like the bank. If another chain ever
+ /// wants a barrel of its own, the lock is the only line that has to change.
+ ///
+ public static class DvergarBotte
+ {
+ public const string PieceName = "DvergarRuneBarrel";
+ public const string PieceDisplayName = "Rune Barrel";
+ public const string RaceId = DvergarConfig.RaceId;
+
+ /// How many drinks it holds. One dose is one mercenary served, so twenty is four
+ /// rounds for a full five-crew bank and a reason to keep brewing.
+ public const int MaxDoses = 20;
+
+ ///
+ /// Who is close enough to be handed a cup. Deliberately a range around the BARREL rather than
+ /// "everyone bound to the bank": a crew that is out across the map following its master is not
+ /// at the table, and buffing it from three biomes away would make the barrel a remote control.
+ ///
+ public const float ServeRange = 30f;
+
+ private const float BarrelScale = 0.7f;
+
+ /// Dvergr brass and verdigris, so it does not read as the Fenrir's trough - which is
+ /// the same barrel, tinted brown and rather bigger.
+ private static readonly Color BarrelTint = new Color(0.30f, 0.42f, 0.40f, 1f);
+
+ public static void Register()
+ {
+ GameObject prefab = PrefabManager.Instance.CreateClonedPrefab(PieceName, "piece_chest_barrel");
+ if (prefab == null)
+ {
+ Jotunn.Logger.LogWarning("[Dvergar] Could not clone piece_chest_barrel; the rune barrel is " +
+ "not registered.");
+ return;
+ }
+
+ // The barrel's Container is both the Hoverable and the Interactable, so a chest would
+ // swallow the click that fills it and the hover text that reports it. Same strip as the
+ // Fenrir trough, and the same reason.
+ foreach (Container container in prefab.GetComponentsInChildren(true))
+ {
+ if (container != null) Object.DestroyImmediate(container);
+ }
+
+ AswidBloodRefinery.StripOffensive(prefab, PieceName);
+
+ DvergarBotteBehaviour barrel = prefab.AddComponent();
+
+ foreach (Switch existing in prefab.GetComponentsInChildren(true))
+ {
+ if (existing != null) Object.DestroyImmediate(existing);
+ }
+ barrel.m_switch = prefab.AddComponent();
+ barrel.m_switch.m_name = PieceDisplayName;
+
+ prefab.transform.localScale = Vector3.one * BarrelScale;
+ Recolour(prefab, BarrelTint);
+
+ Piece piece = prefab.GetComponent() ?? prefab.AddComponent();
+ piece.m_craftingStation = null;
+ piece.m_resources = new Piece.Requirement[0];
+ piece.m_name = PieceDisplayName;
+ piece.m_canBeRemoved = true;
+ piece.m_groundPiece = true;
+ piece.m_groundOnly = true;
+ piece.m_icon = BorrowIcon("MeadHealthMinor") ?? BorrowIcon("TrophyDvergr");
+
+ Piece template = PrefabManager.Cache.GetPrefab("piece_workbench");
+ if (template != null && template.m_placeEffect != null) piece.m_placeEffect = template.m_placeEffect;
+
+ // Cheap on purpose. The barrel is not the cost - the potions poured into it are, forever.
+ PieceManager.Instance.AddPiece(new CustomPiece(prefab, fixReference: false, new PieceConfig
+ {
+ Name = PieceDisplayName,
+ Description = "Pour a brew in and the crew drinks. What it does to them is whatever it " +
+ "would have done to you - if they have the parts for it.",
+ PieceTable = PieceTables.Hammer,
+ Category = PieceCategories.Crafting,
+ Icon = BorrowIcon("MeadHealthMinor") ?? BorrowIcon("TrophyDvergr"),
+ Requirements = new[]
+ {
+ new RequirementConfig("FineWood", 10, 0, true),
+ new RequirementConfig("BlackMarble", 5, 0, true),
+ new RequirementConfig("Sap", 1, 0, true),
+ }
+ }));
+ }
+
+ // ---------------------------------------------------------------- what a brew is
+
+ ///
+ /// The status effect a consumable would hand to whoever drank it, or null if the item is not a
+ /// drink at all. This is the ONLY test the barrel makes: anything with an effect on it can go
+ /// in, and whether that effect means anything to a dvergr is the potion's business, not ours.
+ ///
+ public static StatusEffect BrewEffect(string prefabName)
+ {
+ if (string.IsNullOrEmpty(prefabName)) return null;
+
+ ItemDrop drop = PrefabManager.Cache.GetPrefab(prefabName);
+ if (drop == null || drop.m_itemData == null || drop.m_itemData.m_shared == null) return null;
+
+ return drop.m_itemData.m_shared.m_consumeStatusEffect;
+ }
+
+ public static bool IsBrew(string prefabName) => BrewEffect(prefabName) != null;
+
+ public static string BrewDisplayName(string prefabName)
+ {
+ ItemDrop drop = PrefabManager.Cache.GetPrefab(prefabName);
+ if (drop == null || drop.m_itemData == null || drop.m_itemData.m_shared == null) return prefabName;
+
+ return Localization.instance.Localize(drop.m_itemData.m_shared.m_name);
+ }
+
+ public static void EnsureKnown(Player player)
+ {
+ if (player == null) return;
+
+ GameObject prefab = PrefabManager.Instance.GetPrefab(PieceName);
+ Piece piece = prefab != null ? prefab.GetComponent() : null;
+ if (piece == null) return;
+
+ Traverse traverse = Traverse.Create(player);
+ traverse.Method("AddKnownPiece", piece).GetValue();
+ traverse.Method("UpdateAvailablePiecesList").GetValue();
+ }
+
+ // ---------------------------------------------------------------- helpers
+
+ private static Sprite BorrowIcon(string prefabName)
+ {
+ ItemDrop drop = PrefabManager.Cache.GetPrefab(prefabName);
+ Sprite[] icons = drop != null && drop.m_itemData != null && drop.m_itemData.m_shared != null
+ ? drop.m_itemData.m_shared.m_icons
+ : null;
+ return icons != null && icons.Length > 0 ? icons[0] : null;
+ }
+
+ private static void Recolour(GameObject root, Color tint)
+ {
+ foreach (Renderer renderer in root.GetComponentsInChildren(true))
+ {
+ if (renderer == null || renderer is ParticleSystemRenderer) continue;
+
+ foreach (Material material in renderer.materials)
+ {
+ if (material == null) continue;
+ material.color = tint;
+ if (material.HasProperty("_Color")) material.SetColor("_Color", tint);
+ }
+ }
+ }
+ }
+
+ [HarmonyPatch(typeof(Player), "OnSpawned")]
+ public static class DvergarBotteKnownPatch
+ {
+ public static void Postfix(Player __instance)
+ {
+ if (__instance != Player.m_localPlayer) return;
+ DvergarBotte.EnsureKnown(__instance);
+ }
+ }
+
+ [HarmonyPatch(typeof(Player), "PlacePiece",
+ new[] { typeof(Piece), typeof(Vector3), typeof(Quaternion), typeof(bool) })]
+ public static class DvergarBotteRaceLockPatch
+ {
+ public static bool Prefix(Player __instance, Piece __0)
+ {
+ if (__instance != Player.m_localPlayer || __0 == null) return true;
+ if (Utils.GetPrefabName(__0.gameObject) != DvergarBotte.PieceName) return true;
+ if (DvergarRace.IsDvergar()) return true;
+
+ __instance.Message(MessageHud.MessageType.Center, "You do not know what goes in it.");
+ return false;
+ }
+ }
+
+ ///
+ /// [DEBUG] Every drinkable in the game, and what its effect ACTUALLY carries.
+ ///
+ /// Written because "which potions work on a mercenary" cannot be answered from the names: two meads
+ /// with almost the same label can be a heal-over-time and a stamina regen, and only one of those
+ /// means anything to a creature. Reading the effect is the answer, and reading it BY REFLECTION is
+ /// what makes this command safe to write without knowing a single field name of this build's
+ /// StatusEffect classes - a renamed or missing field is one line that does not print, not a
+ /// compile error and not a wrong answer.
+ ///
+ /// dumppotions every consumable with an effect
+ /// dumppotions mead only the ones whose prefab name contains "mead"
+ ///
+ public class DumpPotionsCommand : ConsoleCommand
+ {
+ public override string Name => "dumppotions";
+
+ public override string Help =>
+ "[DEBUG] Lists every consumable with a status effect and what that effect carries, so it " +
+ "can be told whether a mercenary would feel it. Optional filter: dumppotions .";
+
+ public override void Run(string[] args)
+ {
+ if (ObjectDB.instance == null)
+ {
+ Console.instance.Print("ObjectDB is not up yet - be in a world.");
+ return;
+ }
+
+ string filter = args.Length > 0 ? args[0].ToLowerInvariant() : null;
+ int found = 0;
+
+ foreach (GameObject item in ObjectDB.instance.m_items)
+ {
+ if (item == null) continue;
+ if (filter != null && !item.name.ToLowerInvariant().Contains(filter)) continue;
+
+ ItemDrop drop = item.GetComponent();
+ if (drop == null || drop.m_itemData == null || drop.m_itemData.m_shared == null) continue;
+
+ StatusEffect effect = drop.m_itemData.m_shared.m_consumeStatusEffect;
+ if (effect == null) continue;
+
+ found++;
+ Jotunn.Logger.LogInfo($"[Potion] {item.name} ({effect.GetType().Name} '{effect.name}')" +
+ $"\n {Describe(effect)}");
+ }
+
+ string message = found == 0
+ ? "No consumable carried a status effect - check the filter."
+ : $"{found} drinkable(s) written to the log with everything their effect carries.";
+
+ Console.instance.Print(message);
+ Jotunn.Logger.LogInfo($"[Potion] {message}");
+ }
+
+ ///
+ /// Every public field of the effect that is not at its default, as "name=value". Reflection
+ /// rather than a hand-written list of fields: this build's StatusEffect subclasses are whatever
+ /// they are, and the whole point of the command is to find that out instead of assuming it.
+ ///
+ private static string Describe(StatusEffect effect)
+ {
+ StringBuilder text = new StringBuilder();
+
+ foreach (FieldInfo field in effect.GetType().GetFields(BindingFlags.Public | BindingFlags.Instance))
+ {
+ object value = field.GetValue(effect);
+ if (IsDefault(value)) continue;
+
+ // Collections and objects are reported as "present" rather than dumped - what matters
+ // is whether the effect has any, not what is in them.
+ string printed;
+ if (value is float f) printed = f.ToString("0.###");
+ else if (value is int || value is bool || value is string) printed = value.ToString();
+ else if (value is System.Collections.ICollection collection) printed = $"[{collection.Count}]";
+ else printed = value.GetType().Name;
+
+ if (text.Length > 0) text.Append(", ");
+ text.Append(field.Name).Append('=').Append(printed);
+ }
+
+ return text.Length > 0 ? text.ToString() : "(carries nothing - a flavour effect only)";
+ }
+
+ private static bool IsDefault(object value)
+ {
+ if (value == null) return true;
+ if (value is float f) return Mathf.Approximately(f, 0f);
+ if (value is int i) return i == 0;
+ if (value is bool b) return !b;
+ if (value is string s) return string.IsNullOrEmpty(s);
+ if (value is System.Collections.ICollection collection) return collection.Count == 0;
+
+ // A Unity object reference that has been destroyed compares equal to null.
+ if (value is Object unityObject) return unityObject == null;
+ return false;
+ }
+ }
+}
diff --git a/JotunnModStub/Dvergar/DvergarBotteBehaviour.cs b/JotunnModStub/Dvergar/DvergarBotteBehaviour.cs
new file mode 100644
index 0000000..829f94f
--- /dev/null
+++ b/JotunnModStub/Dvergar/DvergarBotteBehaviour.cs
@@ -0,0 +1,267 @@
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace RacesOfValheim
+{
+ ///
+ /// The barrel's logic: one brew at a time, one dose per mercenary, poured by hand.
+ ///
+ /// Two gestures on one key, and the split is the same one the bank uses:
+ /// - a potion USED on the barrel fills it (and tops it up, if it is the same brew);
+ /// - a bare E pours a round - and fills it from your pack first if it is empty, so the common
+ /// case is one click rather than the inventory dance. The Fenrir trough does the same thing
+ /// with meat, for the same reason.
+ ///
+ /// Serving is MANUAL and never automatic. An automatic barrel would drink itself dry keeping a
+ /// buff up on a crew that is standing still doing nothing, and the whole point of a barrel over a
+ /// flask was that the buff is something you spend on purpose before walking out.
+ ///
+ /// HONEST LIMIT, in the shape this project writes them: the round is poured by the client that
+ /// clicked. It claims ownership of each mercenary before adding the effect, so the effect is
+ /// simulated by someone who has it - but a mercenary that is not loaded on that client cannot be
+ /// served at all, and in multiplayer the dose count can be spent twice if two players click in the
+ /// same instant. Neither is worth a handshake for a barrel of mead.
+ ///
+ public class DvergarBotteBehaviour : MonoBehaviour
+ {
+ public Switch m_switch;
+
+ private const string KeyBrew = "RoV_dvergarBotteBrew";
+ private const string KeyDoses = "RoV_dvergarBotteDoses";
+
+ private ZNetView m_nview;
+
+ private void Awake()
+ {
+ m_nview = GetComponent();
+ if (m_nview == null || m_nview.GetZDO() == null) return;
+
+ if (m_switch != null)
+ {
+ m_switch.m_onUse = OnUse;
+ m_switch.m_onHover = Hover;
+ }
+
+ m_nview.Register("RoV_DvergarBotteFill", RPC_Fill);
+ m_nview.Register("RoV_DvergarBotteSpend", RPC_Spend);
+ }
+
+ // ---------------------------------------------------------------- interaction
+
+ private bool OnUse(Switch caller, Humanoid user, ItemDrop.ItemData item)
+ {
+ Player player = user as Player;
+ if (player == null) return false;
+
+ Inventory inventory = player.GetInventory();
+ if (inventory == null) return false;
+
+ // A drink handed to the barrel always fills it, whatever is already in there.
+ if (item != null)
+ {
+ string prefabName = item.m_dropPrefab != null ? item.m_dropPrefab.name : null;
+ if (!DvergarBotte.IsBrew(prefabName))
+ {
+ player.Message(MessageHud.MessageType.Center, "$msg_wontwork");
+ return false;
+ }
+ return Fill(player, inventory, item, prefabName);
+ }
+
+ // Bare hands: pour a round if there is one, otherwise go looking for something to pour.
+ if (GetDoses() > 0) return Serve(player);
+
+ ItemDrop.ItemData found = FindAnyBrew(inventory);
+ if (found == null)
+ {
+ player.Message(MessageHud.MessageType.Center, "It is empty, and so are you.");
+ return false;
+ }
+
+ return Fill(player, inventory, found, found.m_dropPrefab.name);
+ }
+
+ private ItemDrop.ItemData FindAnyBrew(Inventory inventory)
+ {
+ foreach (ItemDrop.ItemData candidate in inventory.GetAllItems())
+ {
+ if (candidate == null || candidate.m_dropPrefab == null) continue;
+ if (DvergarBotte.IsBrew(candidate.m_dropPrefab.name)) return candidate;
+ }
+ return null;
+ }
+
+ // ---------------------------------------------------------------- filling
+
+ ///
+ /// Pours a stack in. One brew at a time: a barrel holding two different meads would have to
+ /// decide which one a mercenary gets, and there is no answer to that which is not arbitrary.
+ ///
+ private bool Fill(Player player, Inventory inventory, ItemDrop.ItemData item, string prefabName)
+ {
+ string current = GetBrew();
+ if (!string.IsNullOrEmpty(current) && current != prefabName && GetDoses() > 0)
+ {
+ player.Message(MessageHud.MessageType.Center,
+ $"There is still {DvergarBotte.BrewDisplayName(current)} in it.");
+ return false;
+ }
+
+ int room = DvergarBotte.MaxDoses - GetDoses();
+ if (room <= 0)
+ {
+ player.Message(MessageHud.MessageType.Center, "$msg_itsfull");
+ return false;
+ }
+
+ int poured = Mathf.Min(room, Mathf.Max(1, item.m_stack));
+ inventory.RemoveItem(item, poured);
+
+ m_nview.InvokeRPC("RoV_DvergarBotteFill", prefabName, poured);
+ player.Message(MessageHud.MessageType.Center,
+ $"$msg_added {DvergarBotte.BrewDisplayName(prefabName)} x{poured}");
+ return true;
+ }
+
+ private void RPC_Fill(long sender, string prefabName, int count)
+ {
+ if (!m_nview.IsOwner()) return;
+ if (count < 1) return;
+
+ // A barrel that has been drunk dry forgets what it held, so the next brew can be anything.
+ string current = GetBrew();
+ if (string.IsNullOrEmpty(current) || GetDoses() <= 0) m_nview.GetZDO().Set(KeyBrew, prefabName);
+ else if (current != prefabName) return;
+
+ SetDoses(GetDoses() + count);
+ }
+
+ // ---------------------------------------------------------------- serving
+
+ ///
+ /// One round: every mercenary in reach gets a cup, and every cup is a dose. Whoever is out of
+ /// range or already dead simply is not served - there is no queue and no leftovers.
+ ///
+ private bool Serve(Player player)
+ {
+ string brew = GetBrew();
+ StatusEffect effect = DvergarBotte.BrewEffect(brew);
+ if (effect == null)
+ {
+ player.Message(MessageHud.MessageType.Center, "Whatever is in it does nothing to anyone.");
+ return false;
+ }
+
+ List drinkers = InRange();
+ if (drinkers.Count == 0)
+ {
+ player.Message(MessageHud.MessageType.Center, "Nobody is at the barrel.");
+ return false;
+ }
+
+ int doses = GetDoses();
+ int served = 0;
+
+ foreach (RaisedThrall thrall in drinkers)
+ {
+ if (served >= doses) break;
+ if (Pour(thrall, effect)) served++;
+ }
+
+ if (served == 0)
+ {
+ player.Message(MessageHud.MessageType.Center, "Not a drop went down.");
+ return false;
+ }
+
+ m_nview.InvokeRPC("RoV_DvergarBotteSpend", served);
+
+ string what = DvergarBotte.BrewDisplayName(brew);
+ player.Message(MessageHud.MessageType.Center, served < drinkers.Count
+ ? $"{served} drink {what}. The barrel runs dry."
+ : $"{served} drink {what}.");
+ return true;
+ }
+
+ ///
+ /// Hands one creature the drink. The effect object is passed the same way vanilla passes it
+ /// when a player swallows a potion - Humanoid.UseItem does exactly this - so whatever SEMan
+ /// does with the shared asset internally, it is what the game already does to itself.
+ ///
+ private static bool Pour(RaisedThrall thrall, StatusEffect effect)
+ {
+ Character character = thrall != null ? thrall.GetComponent() : null;
+ if (character == null || character.IsDead()) return false;
+
+ // Claimed so that the client pouring is the one simulating the effect. Without this the
+ // drink would tick on a machine that does not own the creature, which for a heal-over-time
+ // means it quietly does nothing.
+ ZNetView nview = character.GetComponent();
+ if (nview != null && nview.IsValid()) nview.ClaimOwnership();
+
+ character.GetSEMan().AddStatusEffect(effect, true);
+ return true;
+ }
+
+ private List InRange()
+ {
+ List near = new List();
+
+ foreach (Character character in Character.GetAllCharacters())
+ {
+ if (character == null || character.IsDead()) continue;
+
+ RaisedThrall thrall = character.GetComponent();
+ if (thrall == null) continue;
+
+ if (Vector3.SqrMagnitude(character.transform.position - transform.position) >
+ DvergarBotte.ServeRange * DvergarBotte.ServeRange) continue;
+
+ near.Add(thrall);
+ }
+
+ return near;
+ }
+
+ private void RPC_Spend(long sender, int count)
+ {
+ if (!m_nview.IsOwner()) return;
+ SetDoses(GetDoses() - Mathf.Max(0, count));
+ }
+
+ // ---------------------------------------------------------------- state and display
+
+ private string GetBrew() =>
+ m_nview != null && m_nview.IsValid() ? m_nview.GetZDO().GetString(KeyBrew, "") : "";
+
+ private int GetDoses() =>
+ m_nview != null && m_nview.IsValid() ? m_nview.GetZDO().GetInt(KeyDoses, 0) : 0;
+
+ private void SetDoses(int value)
+ {
+ if (m_nview == null || !m_nview.IsValid()) return;
+ m_nview.GetZDO().Set(KeyDoses, Mathf.Clamp(value, 0, DvergarBotte.MaxDoses));
+ }
+
+ private string Hover()
+ {
+ int doses = GetDoses();
+ string brew = GetBrew();
+
+ string body;
+ if (doses <= 0 || string.IsNullOrEmpty(brew))
+ {
+ body = "empty\n[$KEY_Use ] Pour a brew in";
+ }
+ else
+ {
+ int waiting = InRange().Count;
+ body = $"{DvergarBotte.BrewDisplayName(brew)} {doses}/{DvergarBotte.MaxDoses}" +
+ $"\n{waiting} at the barrel" +
+ $"\n[$KEY_Use ] Pour a round";
+ }
+
+ return Localization.instance.Localize($"{DvergarBotte.PieceDisplayName} ({body})");
+ }
+ }
+}
diff --git a/JotunnModStub/Dvergar/DvergarRace.cs b/JotunnModStub/Dvergar/DvergarRace.cs
index 731dbab..01165cf 100644
--- a/JotunnModStub/Dvergar/DvergarRace.cs
+++ b/JotunnModStub/Dvergar/DvergarRace.cs
@@ -28,6 +28,14 @@ namespace RacesOfValheim
public void CreateModAssets()
{
DvergarStatusEffects.RegisterStatusEffects();
+
+ // The contract bank and every mercenary it can hire. Race-locked at placement, like the
+ // Trol's war totem and unlike every other station in the mod.
+ DvergarBanco.Register();
+
+ // The barrel the crews drink from. Separate piece, no dependency in either direction:
+ // it serves whatever RaisedThrall is standing near it.
+ DvergarBotte.Register();
}
///
diff --git a/JotunnModStub/Factions/FactionMerchantCatalog.cs b/JotunnModStub/Factions/FactionMerchantCatalog.cs
index bfc02c4..2847b82 100644
--- a/JotunnModStub/Factions/FactionMerchantCatalog.cs
+++ b/JotunnModStub/Factions/FactionMerchantCatalog.cs
@@ -141,9 +141,24 @@ namespace RacesOfValheim
}
};
- private static readonly ShopDefinition WolfShop = new ShopDefinition
+ ///
+ /// The mountain's animal bench. It used to be the WOLF, and moving it was not a preference:
+ /// a bench is a Trader, a Trader is Interactable, and it wins the E key. The wolf is the ONLY
+ /// creature vanilla lets you tame that this catalogue ever made a merchant, so every wolf in
+ /// the world - including the two in your own pen - answered a click with a shop window
+ /// instead of being pettable, nameable or commandable. Taming an animal you cannot handle is
+ /// not taming.
+ ///
+ /// The Ulv carries the whole line now, wolf goods included. It is a mountain creature of the
+ /// same faction, it is not tameable, and nothing about it is spent by being a shopkeeper.
+ ///
+ /// Checked while fixing this: Boar, Lox, Hen and Asksvin - the rest of what vanilla lets you
+ /// tame - are not benches and never were. This was the only one, so the whole class of bug
+ /// closes here rather than needing a rule.
+ ///
+ private static readonly ShopDefinition UlvShop = new ShopDefinition
{
- DisplayName = "Wolf",
+ DisplayName = "Ulv",
JokeCategory = JokeLupoLicantropo,
Items = new List
{
@@ -154,18 +169,8 @@ namespace RacesOfValheim
new CatalogEntry("FreezeGland", 5), // Drake, folded in here: no talk-capable rig
new CatalogEntry("OnionSeeds", 20),
new CatalogEntry("TrophyWolf", 350),
- new CatalogEntry("TrophyHatchling", 350), // Drake (internal id "Hatchling")
- }
- };
-
- private static readonly ShopDefinition UlvShop = new ShopDefinition
- {
- DisplayName = "Ulv",
- JokeCategory = JokeLupoLicantropo,
- Items = new List
- {
- new CatalogEntry("WolfFang", 5),
new CatalogEntry("TrophyUlv", 350),
+ new CatalogEntry("TrophyHatchling", 350), // Drake (internal id "Hatchling")
}
};
@@ -176,6 +181,8 @@ namespace RacesOfValheim
Items = new List
{
new CatalogEntry("WolfFang", 5),
+ new CatalogEntry("Ulvsblod", 500), // gates the Fenrir pack trough
+ new CatalogEntry("GreaterUlvsblod", 1500), // upgrades it: the fenrir themselves
new CatalogEntry("TrophyFenring", 350),
}
};
@@ -187,6 +194,7 @@ namespace RacesOfValheim
Items = new List
{
new CatalogEntry("JuteRed", 2),
+ new CatalogEntry("GreaterFrostHeart", 1500), // gates the Skadi's hidden hollow
new CatalogEntry("TrophyCultist", 1500),
}
};
@@ -284,7 +292,10 @@ namespace RacesOfValheim
{ "GoblinBrute", FulingShop },
{ "GoblinShaman", GoblinShamanShop }, // the only bench carrying the crop line
- { "Wolf", WolfShop },
+ // NO "Wolf" ENTRY, and it must stay that way: a bench is a Trader and a Trader takes the
+ // E key, which would make every tameable wolf in the world a shop instead of an animal.
+ // Its goods live on the Ulv now. (The wolf stays in FactionHostilityPatch's mountain
+ // roster - that list is about who attacks whom and is a different question entirely.)
{ "Ulv", UlvShop },
{ "Fenring", FenringShop },
{ "Fenring_Cultist", CultistShop },
diff --git a/JotunnModStub/Fenrir/FenrirMangiatoia.cs b/JotunnModStub/Fenrir/FenrirMangiatoia.cs
new file mode 100644
index 0000000..79a9c38
--- /dev/null
+++ b/JotunnModStub/Fenrir/FenrirMangiatoia.cs
@@ -0,0 +1,516 @@
+using HarmonyLib;
+using Jotunn.Configs;
+using Jotunn.Entities;
+using Jotunn.Managers;
+using UnityEngine;
+
+namespace RacesOfValheim
+{
+ ///
+ /// The Fenrir station: a trough that keeps a standing pack, in three ranks.
+ ///
+ /// Seventh of the per-race chains, and the same family as the Draugh's body pile and the
+ /// Skeleton's bone pile - meat goes in, a roster fills up, and a death is a slot that refills
+ /// itself. The ranks fill in order and each one waits for the one below it to be full:
+ ///
+ /// 10 wolves, one every two minutes
+ /// then 6 ulv, one every three
+ /// upgraded: 15 wolves, 10 ulv, and 5 fenrir on top
+ ///
+ /// CORRECTION, and the reason this file was rewritten: the first two versions bred the pack
+ /// instead of raising it - the trough rewrote what the animals in its circle gave birth to, and
+ /// the ranks were meant to fill through vanilla's own Procreation. It cannot work. Cubs are a
+ /// different prefab from adults, so they either count towards the cap - and then the pen jams at
+ /// its first litter, because vanilla stops breeding at four head - or they do not, and then
+ /// nothing stops the pen breeding until it is shoulder to shoulder. There is no third option,
+ /// and the whole ladder of chances and forced rungs went with it. What is left is smaller, has
+ /// no cache to prime, no private fields to reach into, and cannot overshoot.
+ ///
+ /// It is still not a spawner of the kind the guide warns against (4.9b), and the difference is
+ /// the same one the Skeleton's pile has: nothing here is free or immediate. The pack is paid for
+ /// in meat, arrives one animal at a time over the better part of an hour, and dies for good if
+ /// the trough does - so it is a herd you keep, not a button you press before a fight.
+ ///
+ public static class FenrirMangiatoia
+ {
+ // ─── Names ───────────────────────────────────────────────────────────
+ public const string PieceName = "FenrirPackTrough";
+ public const string PieceDisplayName = "Pack Trough";
+
+ public const string UlvsblodName = "Ulvsblod";
+ public const string UlvsblodDisplayName = "Ulvsblod";
+ public const string GreaterUlvsblodName = "GreaterUlvsblod";
+ public const string GreaterUlvsblodDisplayName = "Greater Ulvsblod";
+
+ public const int UlvsblodPrice = 500;
+ public const int GreaterUlvsblodPrice = 1500;
+
+ public const string WolfName = "FenrirPack_Wolf";
+ public const string UlvName = "FenrirPack_Ulv";
+ public const string FenrirName = "FenrirPack_Fenrir";
+
+ public const string WolfDisplayName = "Pack Wolf";
+ public const string UlvDisplayName = "Ulv";
+ public const string FenrirDisplayName = "Fenrir";
+
+ public const string KindWolf = "FenrirPackWolf";
+ public const string KindUlv = "FenrirPackUlv";
+ public const string KindFenrir = "FenrirPackFenrir";
+
+ public const string RaceId = "Fenrir";
+
+ // Moder needs no state check of her own: her drop is IN the recipe, so a trough cannot be
+ // built without her having fallen. Yagluth's is checked as well as spent, because the
+ // upgrade is bought with coin and a drop rather than built.
+ public const string ModerDrop = "DragonTear";
+ public const string YagluthDrop = "YagluthDrop";
+ public const int UpgradeProgressionState = 6; // Yagluth
+
+ // ─── The roster ──────────────────────────────────────────────────────
+ public const int WolfSlots = 10;
+ public const int UlvSlots = 6;
+ public const int FenrirSlots = 0; // none at all until upgraded
+
+ public const int WolfSlotsUpgraded = 15;
+ public const int UlvSlotsUpgraded = 10;
+ public const int FenrirSlotsUpgraded = 5;
+
+ ///
+ /// How long each rank takes to put one more up. Local seconds, and only while the zone is
+ /// loaded: a pack that rebuilt itself in an unloaded zone would mean walking away was the
+ /// fastest way to raise one.
+ ///
+ /// The fenrir's five minutes is the one number here nobody specified. It is set longest
+ /// because it is the rank worth waiting for; it is one constant.
+ ///
+ public const float WolfSeconds = 120f;
+ public const float UlvSeconds = 180f;
+ public const float FenrirSeconds = 300f;
+
+ ///
+ /// What one of each costs out of the tank, on AswidBloodRefinery.FleshValue's scale - the
+ /// same one three other chains use, so a lox steak already counts for more than a neck tail
+ /// without a second table.
+ ///
+ /// Anchored to the Draugh's hundred-per-thrall rather than picked: a fenrir is worth one of
+ /// those, and the ranks below it step down from there.
+ ///
+ public const float WolfCost = 25f;
+ public const float UlvCost = 50f;
+ public const float FenrirCost = 100f;
+
+ /// The tank. Four fenrir deep, so a full pack is several trips and not one.
+ public const float TankCap = 400f;
+
+ public const float TickSeconds = 5f;
+
+ // ─── Behaviour ───────────────────────────────────────────────────────
+ // Five minutes. Long enough to notice the mistake and rebuild, short enough that the wither
+ // is really doing its job. The trough cannot be broken by accident anyway - it is immune to
+ // pickaxes - so losing a pack is always a deliberate act.
+ public const float OrphanWitherSeconds = 300f;
+
+ public const float HomeCheckRange = 45f;
+ public const float LeashRange = 15f;
+
+ // No cap, and that is a balance decision rather than an oversight: this chain sits AFTER the
+ // mountain - Moder to build it, Yagluth for the fenrir at all - and five fenrir is a small
+ // number next to what the other races field by then.
+ public const int MaxFollowers = -1;
+
+ // One per square mile. 2.59 km2, and stricter than every other station in the mod because of
+ // what stands around this one.
+ public const int MaxTroughsInRange = 1;
+ public const float DensityAreaKm2 = 2.59f;
+
+ // ─── Looks ───────────────────────────────────────────────────────────
+ private const float TroughScale = 1.1f;
+
+ ///
+ /// A fenrir is a Fenring, and the player's own race turns INTO a Fenring at tier 4. If the
+ /// two are the same size they are the same silhouette in a melee. This is the only number
+ /// written over a vanilla creature's own, and it is a legibility fix, not a stat.
+ ///
+ private const float FenrirScale = 1.6f;
+
+ private static readonly Color TroughTint = new Color(0.42f, 0.36f, 0.30f, 1f);
+ private static readonly Color UlvsblodTint = new Color(0.55f, 0.10f, 0.12f, 1f);
+ private static readonly Color GreaterUlvsblodTint = new Color(0.30f, 0.16f, 0.42f, 1f);
+
+ public static void Register()
+ {
+ RegisterUlvsblod(UlvsblodName, UlvsblodDisplayName, UlvsblodTint,
+ "Wolf blood, kept warm by something that should not be able to keep anything warm. " +
+ "The Fenring sell it and do not explain it.");
+ RegisterUlvsblod(GreaterUlvsblodName, GreaterUlvsblodDisplayName, GreaterUlvsblodTint,
+ "Older blood, and further down the line. A trough given one of these starts raising " +
+ "something worse than ulv.");
+
+ RegisterPackAnimal(WolfName, "Wolf", WolfDisplayName, KindWolf,
+ "It answers to the blood of the wolf, not to you.", 1f);
+ RegisterPackAnimal(UlvName, "Ulv", UlvDisplayName, KindUlv,
+ "It answers to the blood of the wolf, not to you.", 1f);
+ RegisterPackAnimal(FenrirName, "Fenring", FenrirDisplayName, KindFenrir,
+ "Only the blood of the wolf commands this one.", FenrirScale);
+
+ RegisterPiece();
+
+ PieceDensityLimit.Register(PieceName,
+ PieceDensityLimit.RadiusForArea(DensityAreaKm2), MaxTroughsInRange,
+ "There is already {0} of these within a day's walk. A pack needs room.");
+ }
+
+ // ---------------------------------------------------------------- items
+
+ private static void RegisterUlvsblod(string prefabName, string displayName, Color tint, string description)
+ {
+ GameObject prefab = PrefabManager.Instance.CreateClonedPrefab(prefabName, "Bloodbag");
+ if (prefab == null)
+ {
+ Jotunn.Logger.LogWarning($"[Fenrir] Could not clone Bloodbag; {displayName} not registered.");
+ return;
+ }
+
+ Recolour(prefab, tint);
+
+ ItemDrop drop = prefab.GetComponent();
+ if (drop == null) return;
+
+ ItemDrop.ItemData.SharedData shared = drop.m_itemData.m_shared;
+ shared.m_name = displayName;
+ shared.m_description = description;
+ shared.m_itemType = ItemDrop.ItemData.ItemType.Material;
+ shared.m_weight = 1f;
+ shared.m_maxStackSize = 10;
+
+ // A Bloodbag is food in vanilla. Left alone, someone eats the gate item.
+ shared.m_food = 0f;
+ shared.m_foodStamina = 0f;
+ shared.m_foodRegen = 0f;
+ shared.m_foodBurnTime = 0f;
+
+ ItemManager.Instance.AddItem(new CustomItem(prefab, fixReference: false));
+ }
+
+ // ---------------------------------------------------------------- the pack
+
+ ///
+ /// One rank of the pack: a vanilla creature, born tame, leashed to the trough that raised it,
+ /// and carrying nothing on death.
+ ///
+ /// Everything it is - health, damage, resistances, speed - stays exactly as vanilla has it.
+ /// The only number written over is the fenrir's scale, and only so it cannot be mistaken for
+ /// a transformed player at a glance.
+ ///
+ /// No Procreation on any of them, deliberately: the trough raises the pack, the pack does not
+ /// raise itself. That is the whole correction this file was rewritten for.
+ ///
+ /// The CharacterDrop goes for the usual reason and one of this chain's own: a slot refills
+ /// itself forever, so an animal that dropped its pelt would not be a farm but a mint.
+ ///
+ private static void RegisterPackAnimal(string prefabName, string source, string displayName,
+ string kind, string refusal, float scale)
+ {
+ GameObject prefab = PrefabManager.Instance.CreateClonedPrefab(prefabName, source);
+ if (prefab == null)
+ {
+ Jotunn.Logger.LogWarning($"[Fenrir] Could not clone {source}; {displayName} not registered.");
+ return;
+ }
+
+ Character character = prefab.GetComponent();
+ if (character != null) character.m_name = displayName;
+
+ if (scale != 1f) prefab.transform.localScale = Vector3.one * scale;
+
+ BaseAI ai = prefab.GetComponent();
+ if (ai != null) ai.m_randomMoveRange = LeashRange;
+
+ // A raised pack does not breed. Vanilla gives the Ulv and the Fenring none anyway; the
+ // wolf comes with one, and it goes.
+ foreach (Procreation breeding in prefab.GetComponentsInChildren(true))
+ {
+ if (breeding != null) Object.DestroyImmediate(breeding);
+ }
+
+ foreach (CharacterDrop drops in prefab.GetComponentsInChildren(true))
+ {
+ if (drops != null) Object.DestroyImmediate(drops);
+ }
+
+ // Vanilla gives the Ulv and the Fenring no Tameable at all. Without one they are tamed
+ // animals that cannot be named or handled like one, so the wolf's is copied across.
+ if (prefab.GetComponent() == null)
+ {
+ GameObject wolf = PrefabManager.Cache.GetPrefab("Wolf");
+ Tameable source_tame = wolf != null ? wolf.GetComponent() : null;
+ if (source_tame != null) CopyPublicFields(source_tame, prefab.AddComponent(), prefabName);
+ }
+
+ // "Ten seconds unhurt, then 2% a second" - the same one the Trol's troops already use.
+ // The postfix that resets its clock on a hit looks for the component, not for a skeleton.
+ prefab.AddComponent();
+
+ RaisedThrall thrall = prefab.AddComponent();
+ thrall.m_kind = kind;
+ thrall.m_commandingRace = RaceId;
+ thrall.m_maxFollowers = MaxFollowers;
+ thrall.m_witherSeconds = OrphanWitherSeconds;
+ thrall.m_homeCheckRange = HomeCheckRange;
+ thrall.m_refusalMessage = refusal;
+
+ PrefabManager.Instance.AddPrefab(prefab);
+ Jotunn.Logger.LogInfo($"[Fenrir] {prefabName} from '{source}': tamed, leashed, no drops, no breeding.");
+ }
+
+ /// True if the trough takes this as meat. Any flesh, by the scale three chains share.
+ public static bool IsMeat(string prefabName)
+ {
+ return !string.IsNullOrEmpty(prefabName) && AswidBloodRefinery.FleshValue(prefabName) > 0;
+ }
+
+ public static float FeedValue(string prefabName)
+ {
+ int flesh = AswidBloodRefinery.FleshValue(prefabName);
+ return flesh > 0 ? flesh : 0f;
+ }
+
+ // ---------------------------------------------------------------- piece
+
+ private static void RegisterPiece()
+ {
+ // A barrel, because a trough is a barrel that someone left open. piece_chest_barrel is
+ // free - the taken list names piece_chest_wood, which is the Trenta's.
+ GameObject prefab = PrefabManager.Instance.CreateClonedPrefab(PieceName, "piece_chest_barrel");
+ if (prefab == null)
+ {
+ Jotunn.Logger.LogWarning("[Fenrir] Could not clone piece_chest_barrel; the trough is not registered.");
+ return;
+ }
+
+ // The barrel's Container is itself the Hoverable AND the Interactable, so a chest would
+ // swallow both the click that feeds the trough and the hover text that carries the
+ // roster. The model stays; the chest goes.
+ foreach (Container container in prefab.GetComponentsInChildren(true))
+ {
+ if (container != null) Object.DestroyImmediate(container);
+ }
+
+ AswidBloodRefinery.StripOffensive(prefab, PieceName);
+
+ FenrirMangiatoiaBehaviour behaviour = prefab.AddComponent();
+
+ foreach (Switch existing in prefab.GetComponentsInChildren(true))
+ {
+ if (existing != null) Object.DestroyImmediate(existing);
+ }
+ behaviour.m_switch = prefab.AddComponent();
+ behaviour.m_switch.m_name = PieceDisplayName;
+
+ prefab.transform.localScale = Vector3.one * TroughScale;
+ Recolour(prefab, TroughTint);
+
+ // Ten silver ingots in the recipe, and a pickaxe that does literally nothing to it.
+ // "Silver hit points" is not a thing - WearNTear.MaterialType has no silver - but an
+ // immunity is more precise than a big number anyway: a stray swing while mining out a pen
+ // cannot cost a pack, and the hammer still takes it down deliberately, because removing a
+ // piece in Valheim does not go through damage at all.
+ WearNTear wear = prefab.GetComponent();
+ if (wear != null)
+ {
+ wear.m_damages.m_pickaxe = HitData.DamageModifier.Immune;
+ wear.m_materialType = WearNTear.MaterialType.Iron;
+ Jotunn.Logger.LogInfo($"[Fenrir] Trough health {wear.m_health} (inherited), pickaxe immune.");
+ }
+
+ Piece piece = prefab.GetComponent() ?? prefab.AddComponent();
+ piece.m_craftingStation = null;
+ piece.m_resources = new Piece.Requirement[0];
+ piece.m_name = PieceDisplayName;
+ piece.m_canBeRemoved = true;
+ piece.m_groundPiece = true;
+ piece.m_groundOnly = true;
+ piece.m_icon = BorrowIcon("TrophyFenring");
+
+ Piece template = PrefabManager.Cache.GetPrefab("piece_workbench");
+ if (template != null && template.m_placeEffect != null) piece.m_placeEffect = template.m_placeEffect;
+
+ PieceManager.Instance.AddPiece(new CustomPiece(prefab, fixReference: false, new PieceConfig
+ {
+ Name = PieceDisplayName,
+ Description = "Fill it with meat and the pack comes. One at a time, and it remembers its dead.",
+ PieceTable = PieceTables.Hammer,
+ Category = PieceCategories.Crafting,
+ Icon = BorrowIcon("TrophyFenring"),
+ Requirements = new[]
+ {
+ new RequirementConfig(UlvsblodName, 1, 0, true),
+ new RequirementConfig("Silver", 10, 0, true),
+ new RequirementConfig(ModerDrop, 1, 0, true),
+ new RequirementConfig("FineWood", 20, 0, true),
+ }
+ }));
+ }
+
+ public static void EnsureKnown(Player player)
+ {
+ if (player == null) return;
+
+ GameObject prefab = PrefabManager.Instance.GetPrefab(PieceName);
+ Piece piece = prefab != null ? prefab.GetComponent() : null;
+ if (piece == null) return;
+
+ Traverse traverse = Traverse.Create(player);
+ traverse.Method("AddKnownPiece", piece).GetValue();
+ traverse.Method("UpdateAvailablePiecesList").GetValue();
+ }
+
+ // ---------------------------------------------------------------- helpers
+
+ ///
+ /// Copies every public instance field from one component to another of the same type. Private
+ /// ones are left alone - they are the caches Awake fills in.
+ ///
+ private static void CopyPublicFields(T source, T target, string label) where T : Component
+ {
+ if (source == null || target == null) return;
+
+ int copied = 0;
+ foreach (System.Reflection.FieldInfo field in typeof(T).GetFields(
+ System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance))
+ {
+ field.SetValue(target, field.GetValue(source));
+ copied++;
+ }
+
+ Jotunn.Logger.LogInfo($"[Fenrir] {label}: {copied} {typeof(T).Name} values taken from the vanilla Wolf.");
+ }
+
+ private static Sprite BorrowIcon(string prefabName)
+ {
+ ItemDrop drop = PrefabManager.Cache.GetPrefab(prefabName);
+ Sprite[] icons = drop != null && drop.m_itemData != null && drop.m_itemData.m_shared != null
+ ? drop.m_itemData.m_shared.m_icons
+ : null;
+ if (icons != null && icons.Length > 0 && icons[0] != null) return icons[0];
+
+ Jotunn.Logger.LogWarning($"[Fenrir] Could not borrow the icon from '{prefabName}'.");
+ return null;
+ }
+
+ private static void Recolour(GameObject root, Color tint)
+ {
+ foreach (Renderer renderer in root.GetComponentsInChildren(true))
+ {
+ if (renderer == null || renderer is ParticleSystemRenderer) continue;
+
+ foreach (Material material in renderer.materials)
+ {
+ if (material == null) continue;
+ material.color = tint;
+ if (material.HasProperty("_Color")) material.SetColor("_Color", tint);
+ }
+ }
+ }
+ }
+
+ [HarmonyPatch(typeof(Player), "OnSpawned")]
+ public static class FenrirMangiatoiaKnownPatch
+ {
+ public static void Postfix(Player __instance)
+ {
+ if (__instance != Player.m_localPlayer) return;
+ FenrirMangiatoia.EnsureKnown(__instance);
+ }
+ }
+
+ ///
+ /// [DEBUG] The pack, without the hour it takes to raise one.
+ ///
+ /// A full roster is 30 animals at two to five minutes each, which is most of an afternoon, and
+ /// the things worth looking at - what a rank looks like, whether a slot refills after a death,
+ /// whether the upgrade opens the third rank - are all at the far end of it.
+ ///
+ public class FenrirPackSpawnCommand : ConsoleCommand
+ {
+ public override string Name => "fenrirpack";
+
+ public override string Help =>
+ "[DEBUG] fenrirpack now [count] - the nearest trough raises its next animals immediately. " +
+ "'fenrirpack fill' tops up its meat; 'fenrirpack [wolf|ulv|fenrir] [count]' puts animals " +
+ "in front of you directly, roster or no roster.";
+
+ public override void Run(string[] args)
+ {
+ Player player = Player.m_localPlayer;
+ if (player == null)
+ {
+ Console.instance.Print("You must be in-game.");
+ return;
+ }
+
+ string what = args.Length > 0 ? args[0].ToLowerInvariant() : "wolf";
+
+ if (what == "fill") { FenrirMangiatoiaBehaviour.FillNearby(player); return; }
+
+ if (what == "now")
+ {
+ // No number given means "as many as the roster still wants" - 30 is past the biggest
+ // possible roster, so the loop stops when NextShort says the pack is whole.
+ int wanted = 30;
+ if (args.Length > 1 && !int.TryParse(args[1], out wanted)) wanted = 30;
+
+ FenrirMangiatoiaBehaviour.ForceNearby(player, Mathf.Clamp(wanted, 1, 30));
+ return;
+ }
+
+ string prefabName;
+ switch (what)
+ {
+ case "wolf": prefabName = FenrirMangiatoia.WolfName; break;
+ case "ulv": prefabName = FenrirMangiatoia.UlvName; break;
+ case "fenrir": prefabName = FenrirMangiatoia.FenrirName; break;
+ default:
+ Console.instance.Print($"'{what}'? wolf, ulv, fenrir - or now / fill.");
+ return;
+ }
+
+ int count = 2;
+ if (args.Length > 1 && !int.TryParse(args[1], out count)) count = 2;
+ count = Mathf.Clamp(count, 1, 30);
+
+ GameObject prefab = ZNetScene.instance != null ? ZNetScene.instance.GetPrefab(prefabName) : null;
+ if (prefab == null)
+ {
+ Console.instance.Print($"No '{prefabName}' in ZNetScene - the chain did not register.");
+ return;
+ }
+
+ // Bound to a trough if there is one in reach, so they count against its roster exactly as
+ // if it had raised them. Loose otherwise, which is its own useful test.
+ FenrirMangiatoiaBehaviour trough = FenrirMangiatoiaBehaviour.NearestTo(player.transform.position);
+
+ for (int i = 0; i < count; i++)
+ {
+ float angle = i * Mathf.PI * 2f / count;
+ Vector3 ring = new Vector3(Mathf.Cos(angle), 0f, Mathf.Sin(angle)) * 3f;
+ Vector3 position = player.transform.position + player.transform.forward * 3f + ring + Vector3.up * 0.5f;
+
+ GameObject spawned = Object.Instantiate(prefab, position, Quaternion.identity);
+
+ Character character = spawned.GetComponent();
+ if (character != null) character.SetTamed(true);
+
+ MonsterAI ai = spawned.GetComponent();
+ if (ai != null) ai.MakeTame();
+
+ RaisedThrall thrall = spawned.GetComponent();
+ if (thrall != null && trough != null) thrall.Bind(trough.transform.position);
+ }
+
+ Console.instance.Print(trough != null
+ ? $"{count} {prefabName}, bound to the trough {Mathf.RoundToInt(Vector3.Distance(player.transform.position, trough.transform.position))}m away."
+ : $"{count} {prefabName}, bound to nothing - no trough within range.");
+ }
+ }
+}
diff --git a/JotunnModStub/Fenrir/FenrirMangiatoiaBehaviour.cs b/JotunnModStub/Fenrir/FenrirMangiatoiaBehaviour.cs
new file mode 100644
index 0000000..0929e64
--- /dev/null
+++ b/JotunnModStub/Fenrir/FenrirMangiatoiaBehaviour.cs
@@ -0,0 +1,468 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace RacesOfValheim
+{
+ ///
+ /// The trough's logic: one rank at a time, one animal at a time, paid for in meat.
+ ///
+ /// Same shape as DraughSpawnerBehaviour and SkeletonBonePileBehaviour, and deliberately so - all
+ /// the state in the ZDO, owner-only accounting, and a roster that is COUNTED rather than tallied.
+ /// Counting fresh on every tick is what makes "when one dies its slot comes back" need no code at
+ /// all: a death, a despawn, or a player killing his own wolf all correct themselves.
+ ///
+ /// The ranks fill in order - wolves, then ulv, then fenrir - and whichever rank is short is the
+ /// one the clock is running for. That is also what "the timer for that one restarts" means: a
+ /// wolf dying while the trough is working on ulv moves the clock back to the wolf rank, because
+ /// the lowest short rank always wins.
+ ///
+ /// HONEST LIMIT, the same one the Skeleton's pile carries: RaisedThrall.BoundTo can only see
+ /// LOADED creatures. A pack that is off across the map following its owner does not count, and a
+ /// trough left alone will fill the slots it thinks are empty. The wither is what stops that
+ /// becoming permanent - a trough only sustains one pack - but a player who ferries animals away
+ /// and comes back can hold more than the roster says. Closing it properly needs the animals to
+ /// carry their own bookkeeping, which is the version this replaced and which cost more than it
+ /// was worth.
+ ///
+ public class FenrirMangiatoiaBehaviour : MonoBehaviour
+ {
+ public Switch m_switch;
+
+ private const string KeyFeed = "RoV_fenrirFeed";
+ private const string KeyUpgraded = "RoV_fenrirUpgraded";
+
+ private static readonly List Live = new List();
+
+ private ZNetView m_nview;
+
+ /// Seconds towards the next animal of whichever rank is currently short.
+ private float m_timer;
+
+ /// Which rank the clock is running for, so that a change resets it.
+ private string m_waitingFor;
+
+ // ---------------------------------------------------------------- life
+
+ private void Awake()
+ {
+ Live.Add(this);
+ RaisedThrall.RegisterStation(transform);
+
+ m_nview = GetComponent();
+ if (m_nview == null || m_nview.GetZDO() == null) return;
+
+ if (m_switch != null)
+ {
+ m_switch.m_onUse = OnUse;
+ m_switch.m_onHover = Hover;
+ }
+
+ m_nview.Register("RoV_FenrirFeed", RPC_Feed);
+ m_nview.Register("RoV_FenrirUpgrade", RPC_Upgrade);
+
+ WearNTear wear = GetComponent();
+ if (wear != null) wear.m_onDestroyed = (Action)Delegate.Combine(wear.m_onDestroyed, new Action(OnDestroyed));
+
+ InvokeRepeating("Tick", FenrirMangiatoia.TickSeconds, FenrirMangiatoia.TickSeconds);
+ }
+
+ private void OnDestroy()
+ {
+ Live.Remove(this);
+ RaisedThrall.UnregisterStation(transform);
+ }
+
+ /// The nearest loaded trough, or null if none is in reach.
+ public static FenrirMangiatoiaBehaviour NearestTo(Vector3 position)
+ {
+ FenrirMangiatoiaBehaviour best = null;
+ float bestSq = 60f * 60f;
+
+ for (int i = Live.Count - 1; i >= 0; i--)
+ {
+ FenrirMangiatoiaBehaviour trough = Live[i];
+ if (trough == null) { Live.RemoveAt(i); continue; }
+
+ float sq = Vector3.SqrMagnitude(trough.transform.position - position);
+ if (sq > bestSq) continue;
+
+ bestSq = sq;
+ best = trough;
+ }
+ return best;
+ }
+
+ /// [DEBUG] Tops up every nearby trough, so a test does not start with a meat run.
+ public static void FillNearby(Player player)
+ {
+ int filled = 0;
+ foreach (FenrirMangiatoiaBehaviour trough in Live)
+ {
+ if (trough == null || trough.m_nview == null || !trough.m_nview.IsValid()) continue;
+ if (Vector3.Distance(trough.transform.position, player.transform.position) > 60f) continue;
+
+ trough.m_nview.ClaimOwnership();
+ trough.SetFeed(FenrirMangiatoia.TankCap);
+ filled++;
+ }
+
+ Console.instance.Print(filled == 0 ? "No troughs within 60m." : $"{filled} filled to the brim.");
+ }
+
+ // ---------------------------------------------------------------- the tick
+
+ private void Tick()
+ {
+ if (m_nview == null || !m_nview.IsValid() || !m_nview.IsOwner()) return;
+
+ if (!NextShort(out string kind, out string prefabName, out float wait, out float cost))
+ {
+ // Nothing short: the pack is whole. The clock does not run, so a death does not get a
+ // head start it never earned.
+ m_timer = 0f;
+ m_waitingFor = null;
+ return;
+ }
+
+ // A rank that has just fallen short takes the clock over from the one above it, and it
+ // starts from zero. This is "the timer for that one restarts", and it is why a death
+ // costs the full wait rather than whatever happened to be left on another rank's clock.
+ if (m_waitingFor != kind)
+ {
+ m_waitingFor = kind;
+ m_timer = 0f;
+ }
+
+ if (GetFeed() < cost) return; // no meat, no clock
+
+ m_timer += FenrirMangiatoia.TickSeconds;
+ if (m_timer < wait) return;
+ m_timer = 0f;
+
+ if (Spawn(prefabName)) SetFeed(GetFeed() - cost);
+ }
+
+ ///
+ /// The lowest rank that is short, and what raising one of it costs and takes. Ranks fill in
+ /// order, so this one method is the whole scheduler.
+ ///
+ /// Extracted so the debug command that forces a spawn goes through EXACTLY this, and cannot
+ /// quietly fill a rank out of order, past its cap, or before the upgrade opens it. A test
+ /// tool that skips the rule it is testing proves nothing.
+ ///
+ /// Returns false when the pack is whole.
+ ///
+ private bool NextShort(out string kind, out string prefabName, out float wait, out float cost)
+ {
+ Count(out int wolves, out int ulv, out int fenrir);
+
+ if (wolves < WolfCap())
+ {
+ kind = FenrirMangiatoia.KindWolf;
+ prefabName = FenrirMangiatoia.WolfName;
+ wait = FenrirMangiatoia.WolfSeconds;
+ cost = FenrirMangiatoia.WolfCost;
+ return true;
+ }
+
+ if (ulv < UlvCap())
+ {
+ kind = FenrirMangiatoia.KindUlv;
+ prefabName = FenrirMangiatoia.UlvName;
+ wait = FenrirMangiatoia.UlvSeconds;
+ cost = FenrirMangiatoia.UlvCost;
+ return true;
+ }
+
+ if (fenrir < FenrirCap())
+ {
+ kind = FenrirMangiatoia.KindFenrir;
+ prefabName = FenrirMangiatoia.FenrirName;
+ wait = FenrirMangiatoia.FenrirSeconds;
+ cost = FenrirMangiatoia.FenrirCost;
+ return true;
+ }
+
+ kind = null;
+ prefabName = null;
+ wait = 0f;
+ cost = 0f;
+ return false;
+ }
+
+ ///
+ /// [DEBUG] Raises the next animals at once, skipping only the wait.
+ ///
+ /// The meat is still charged and the tank is topped up to cover it, because a full roster is
+ /// far more meat than a tank holds and the point of the command is to skip the CLOCK, not the
+ /// economy. Everything else - which rank is next, its cap, whether the upgrade has opened the
+ /// third one - comes from NextShort, the same call the timer uses.
+ ///
+ public static void ForceNearby(Player player, int count)
+ {
+ FenrirMangiatoiaBehaviour trough = NearestTo(player.transform.position);
+ if (trough == null || trough.m_nview == null || !trough.m_nview.IsValid())
+ {
+ Console.instance.Print("No trough within 60m.");
+ return;
+ }
+
+ trough.m_nview.ClaimOwnership();
+
+ int raised = 0;
+ for (int i = 0; i < count; i++)
+ {
+ if (!trough.NextShort(out _, out string prefabName, out _, out float cost)) break;
+
+ if (trough.GetFeed() < cost) trough.SetFeed(FenrirMangiatoia.TankCap);
+ if (!trough.Spawn(prefabName)) break;
+
+ trough.SetFeed(trough.GetFeed() - cost);
+ raised++;
+ }
+
+ trough.m_timer = 0f;
+
+ Console.instance.Print(raised == 0
+ ? "The pack is already whole."
+ : $"{raised} raised on the spot. The roster picked them, in its own order.");
+ }
+
+ ///
+ /// The roster, counted fresh. Never banked: a tally would have to be corrected on death, on
+ /// despawn and on a player killing his own, and any one of those going missing leaves a
+ /// trough that thinks it is full forever.
+ ///
+ private void Count(out int wolves, out int ulv, out int fenrir)
+ {
+ wolves = 0;
+ ulv = 0;
+ fenrir = 0;
+
+ foreach (RaisedThrall thrall in RaisedThrall.BoundTo(transform.position))
+ {
+ if (thrall.Kind == FenrirMangiatoia.KindWolf) wolves++;
+ else if (thrall.Kind == FenrirMangiatoia.KindUlv) ulv++;
+ else if (thrall.Kind == FenrirMangiatoia.KindFenrir) fenrir++;
+ }
+ }
+
+ private bool Spawn(string prefabName)
+ {
+ GameObject prefab = ZNetScene.instance != null ? ZNetScene.instance.GetPrefab(prefabName) : null;
+ if (prefab == null)
+ {
+ Jotunn.Logger.LogWarning($"[Fenrir] No '{prefabName}' in ZNetScene; the trough cannot raise anything.");
+ return false;
+ }
+
+ Vector3 offset = UnityEngine.Random.insideUnitSphere * 3f;
+ offset.y = 0f;
+ Vector3 position = transform.position + offset + Vector3.up * 0.5f;
+
+ GameObject spawned = Instantiate(prefab, position, Quaternion.Euler(0f, UnityEngine.Random.Range(0, 360), 0f));
+
+ // Bind tames it, marks whose it is, and sends it home - all three.
+ RaisedThrall thrall = spawned.GetComponent();
+ if (thrall != null) thrall.Bind(transform.position);
+
+ return true;
+ }
+
+ // ---------------------------------------------------------------- interaction
+
+ private bool OnUse(Switch caller, Humanoid user, ItemDrop.ItemData item)
+ {
+ if (user == null) return false;
+
+ Inventory inventory = user.GetInventory();
+ if (inventory == null) return false;
+
+ if (item == null) item = FindAnyInput(inventory);
+ if (item == null)
+ {
+ user.Message(MessageHud.MessageType.Center, "It wants meat. Any meat.");
+ return false;
+ }
+
+ string prefabName = item.m_dropPrefab != null ? item.m_dropPrefab.name : null;
+ if (prefabName == null) return false;
+
+ if (prefabName == FenrirMangiatoia.GreaterUlvsblodName) return TryUpgrade(user, inventory, item);
+
+ if (!FenrirMangiatoia.IsMeat(prefabName))
+ {
+ user.Message(MessageHud.MessageType.Center, "$msg_wontwork");
+ return false;
+ }
+
+ if (GetFeed() >= FenrirMangiatoia.TankCap)
+ {
+ user.Message(MessageHud.MessageType.Center, "$msg_itsfull");
+ return false;
+ }
+
+ // A whole stack per click. A full tank is a lot of neck tails and clicking them out one
+ // at a time is not a mechanic.
+ int stack = Mathf.Max(1, item.m_stack);
+ user.Message(MessageHud.MessageType.Center, $"$msg_added {item.m_shared.m_name} x{stack}");
+ inventory.RemoveItem(item, stack);
+
+ m_nview.InvokeRPC("RoV_FenrirFeed", prefabName, stack);
+ return true;
+ }
+
+ private ItemDrop.ItemData FindAnyInput(Inventory inventory)
+ {
+ foreach (ItemDrop.ItemData candidate in inventory.GetAllItems())
+ {
+ if (candidate == null || candidate.m_dropPrefab == null) continue;
+
+ string name = candidate.m_dropPrefab.name;
+ if (name == FenrirMangiatoia.GreaterUlvsblodName) return candidate;
+ if (FenrirMangiatoia.IsMeat(name)) return candidate;
+ }
+ return null;
+ }
+
+ ///
+ /// The 1500-coin upgrade, and the second boss gate. Nothing about the trough changes to look
+ /// at - which is exactly why the hover text has to say it, or the next thing that happens is
+ /// somebody buys a second one.
+ ///
+ private bool TryUpgrade(Humanoid user, Inventory inventory, ItemDrop.ItemData item)
+ {
+ if (IsUpgraded())
+ {
+ user.Message(MessageHud.MessageType.Center, "It has already had one.");
+ return false;
+ }
+
+ if (BossProgressionManager.GetCurrentProgressionState() < FenrirMangiatoia.UpgradeProgressionState)
+ {
+ user.Message(MessageHud.MessageType.Center, "The blood will not take. Something in the plains has to fall first.");
+ return false;
+ }
+
+ if (inventory.CountItems(YagluthDropName()) < 1)
+ {
+ user.Message(MessageHud.MessageType.Center, "It wants what Yagluth left behind.");
+ return false;
+ }
+
+ inventory.RemoveItem(YagluthDropName(), 1);
+ inventory.RemoveItem(item, 1);
+ m_nview.InvokeRPC("RoV_FenrirUpgrade");
+
+ user.Message(MessageHud.MessageType.Center, "The trough takes it. The line runs deeper now.");
+ return true;
+ }
+
+ /// Inventory.RemoveItem and CountItems work on the DISPLAYED name, not the prefab.
+ private static string YagluthDropName()
+ {
+ ItemDrop drop = Jotunn.Managers.PrefabManager.Cache.GetPrefab(FenrirMangiatoia.YagluthDrop);
+ return drop != null ? drop.m_itemData.m_shared.m_name : FenrirMangiatoia.YagluthDrop;
+ }
+
+ // ---------------------------------------------------------------- accounting
+
+ private void RPC_Feed(long sender, string prefabName, int count)
+ {
+ if (!m_nview.IsOwner()) return;
+ if (count < 1) count = 1;
+
+ SetFeed(GetFeed() + FenrirMangiatoia.FeedValue(prefabName) * count);
+ }
+
+ private void RPC_Upgrade(long sender)
+ {
+ if (!m_nview.IsOwner()) return;
+ m_nview.GetZDO().Set(KeyUpgraded, true);
+ }
+
+ ///
+ /// The trough sustains the pack, so it takes the pack with it - on the wither's delay rather
+ /// than on the spot. Without some form of this, a trough is a duplication exploit: fill it,
+ /// dismantle it, rebuild it elsewhere, and keep every animal from every round.
+ ///
+ private void OnDestroyed()
+ {
+ if (m_nview == null || !m_nview.IsOwner()) return;
+
+ List bound = RaisedThrall.BoundTo(transform.position);
+ foreach (RaisedThrall thrall in bound) thrall.MarkOrphaned();
+
+ if (bound.Count > 0 && Player.m_localPlayer != null)
+ {
+ Player.m_localPlayer.Message(MessageHud.MessageType.Center,
+ $"The trough is broken. {bound.Count} will not outlast it by long.");
+ }
+
+ SetFeed(0f);
+ }
+
+ // ---------------------------------------------------------------- state and display
+
+ public bool IsUpgraded() =>
+ m_nview != null && m_nview.IsValid() && m_nview.GetZDO().GetBool(KeyUpgraded, false);
+
+ private int WolfCap() => IsUpgraded() ? FenrirMangiatoia.WolfSlotsUpgraded : FenrirMangiatoia.WolfSlots;
+
+ private int UlvCap() => IsUpgraded() ? FenrirMangiatoia.UlvSlotsUpgraded : FenrirMangiatoia.UlvSlots;
+
+ private int FenrirCap() => IsUpgraded() ? FenrirMangiatoia.FenrirSlotsUpgraded : FenrirMangiatoia.FenrirSlots;
+
+ private float GetFeed() => m_nview != null && m_nview.IsValid() ? m_nview.GetZDO().GetFloat(KeyFeed) : 0f;
+
+ private void SetFeed(float value)
+ {
+ if (m_nview != null && m_nview.IsValid())
+ {
+ m_nview.GetZDO().Set(KeyFeed, Mathf.Clamp(value, 0f, FenrirMangiatoia.TankCap));
+ }
+ }
+
+ ///
+ /// Everything a player needs without opening a log, which is the standard this project
+ /// arrived at the hard way: a mechanic that cannot say whether it is working looks exactly
+ /// like one that is broken.
+ ///
+ private string Hover()
+ {
+ Count(out int wolves, out int ulv, out int fenrir);
+
+ string body = $"meat {Mathf.Floor(GetFeed())}/{FenrirMangiatoia.TankCap}" +
+ $"\nwolves {wolves}/{WolfCap()}, ulv {ulv}/{UlvCap()}";
+
+ // Said in as many words, because the upgrade is deliberately invisible on the model.
+ body += IsUpgraded()
+ ? $", fenrir {fenrir}/{FenrirCap()}"
+ : "\nthe blood is thin here - it raises no fenrir yet";
+
+ if (m_waitingFor != null)
+ {
+ float wait = m_waitingFor == FenrirMangiatoia.KindWolf ? FenrirMangiatoia.WolfSeconds
+ : m_waitingFor == FenrirMangiatoia.KindUlv ? FenrirMangiatoia.UlvSeconds
+ : FenrirMangiatoia.FenrirSeconds;
+
+ float cost = m_waitingFor == FenrirMangiatoia.KindWolf ? FenrirMangiatoia.WolfCost
+ : m_waitingFor == FenrirMangiatoia.KindUlv ? FenrirMangiatoia.UlvCost
+ : FenrirMangiatoia.FenrirCost;
+
+ body += GetFeed() < cost
+ ? $"\nnot enough meat for the next one ({cost} needed)"
+ : $"\nnext in {Mathf.Max(1, Mathf.CeilToInt(wait - m_timer))}s";
+ }
+ else
+ {
+ body += "\nthe pack is whole";
+ }
+
+ body += "\n[$KEY_Use ] Fill it with meat";
+
+ return Localization.instance.Localize($"{FenrirMangiatoia.PieceDisplayName} ({body})");
+ }
+ }
+}
diff --git a/JotunnModStub/Fenrir/FenrirRace.cs b/JotunnModStub/Fenrir/FenrirRace.cs
index 1bf827d..b37968d 100644
--- a/JotunnModStub/Fenrir/FenrirRace.cs
+++ b/JotunnModStub/Fenrir/FenrirRace.cs
@@ -30,6 +30,11 @@ namespace RacesOfValheim {
public void CreateModAssets()
{
+ // The pack trough and its bloodline. Registered here because the faction merchant
+ // catalogue resolves its entries by prefab name, so both Ulvsblod have to exist before a
+ // Fenring is ever set up as a bench.
+ FenrirMangiatoia.Register();
+
curseSE = ScriptableObject.CreateInstance();
curseSE.name = "SE_FenrirCurse";
curseSE.m_name = "Fenrir's Blood";
diff --git a/JotunnModStub/PieceDensityLimit.cs b/JotunnModStub/PieceDensityLimit.cs
index 024014f..b872263 100644
--- a/JotunnModStub/PieceDensityLimit.cs
+++ b/JotunnModStub/PieceDensityLimit.cs
@@ -141,7 +141,28 @@ namespace RacesOfValheim
{
if (__instance != Player.m_localPlayer || __0 == null) return true;
+ if (!HollowAllowsPiece(__instance, __0)) return false;
+
return PieceDensityLimit.Allow(__instance, Utils.GetPrefabName(__0.gameObject), __1);
}
+
+ ///
+ /// "You may build in your hollow, but nothing takes root there." Rides along on this prefix
+ /// rather than adding a second one, which is the whole reason this class exists.
+ ///
+ /// Worth knowing that the refusal is about the MESSAGE, not about making the impossible
+ /// impossible: a Plant needs cultivated ground and a matching biome (Plant.m_needCultivated-
+ /// Ground, Plant.m_biome), and five kilometres above the sea there is no terrain to cultivate
+ /// and no biome to match, so a seed would have failed anyway - with a vanilla error that says
+ /// nothing useful about why.
+ ///
+ private static bool HollowAllowsPiece(Player player, Piece piece)
+ {
+ if (!SkadiHollow.IsInside(player)) return true;
+ if (piece.GetComponentInChildren(true) == null) return true;
+
+ player.Message(MessageHud.MessageType.Center, "Nothing takes root here.");
+ return false;
+ }
}
}
diff --git a/JotunnModStub/RaceCaveBuilding.cs b/JotunnModStub/RaceCaveBuilding.cs
new file mode 100644
index 0000000..c34cb9d
--- /dev/null
+++ b/JotunnModStub/RaceCaveBuilding.cs
@@ -0,0 +1,212 @@
+using System.Collections.Generic;
+using HarmonyLib;
+using UnityEngine;
+
+namespace RacesOfValheim
+{
+ ///
+ /// "A troll cave is a house, if you are the right sort of thing."
+ ///
+ /// Skadi and Trol may build inside ANY troll cave in the world.
+ ///
+ /// THE ACTUAL RESTRICTION, found only after the game was asked instead of guessed at: a troll
+ /// cave counts as a DUNGEON, and Valheim refuses any piece whose Piece.m_allowedInDungeons is
+ /// false while the player is in one - "Can't build in a dungeon". That is a per-PIECE flag, not a
+ /// per-location one.
+ ///
+ /// Two earlier versions of this file cleared Location.m_noBuild instead. That is a real
+ /// restriction and it is still cleared below, but it was never the one refusing these
+ /// placements, which is why lifting it changed nothing twice in a row. The lesson is in the log
+ /// line this class now prints: Player.m_placementStatus names the exact reason, and reading it
+ /// would have answered the question on the first report rather than the third.
+ ///
+ /// The flag is flipped only while an eligible player is actually standing in a troll cave, and
+ /// put back when they leave, so this does not quietly become "build anywhere in any crypt". It
+ /// touches only the pieces on the build tables the player is carrying, and placement checks are
+ /// client-side, so nobody else's game is affected.
+ ///
+ public class RaceCaveBuilding : MonoBehaviour
+ {
+ /// Matches both troll cave locations this build has: TrollCave and TrollCave02.
+ private const string CaveNameFragment = "TrollCave";
+
+ /// Slack on the location's own radius, since the inside of a cave is not a neat sphere.
+ private const float RadiusSlack = 12f;
+
+ private const float CheckInterval = 0.25f;
+
+ private float nextCheck;
+ private bool allowing;
+ private readonly List flipped = new List();
+ private string lastReport;
+ private string lastHow = "not checked yet";
+
+ private void Update()
+ {
+ if (Time.time < nextCheck) return;
+ nextCheck = Time.time + CheckInterval;
+
+ Player player = Player.m_localPlayer;
+ if (player == null) return;
+
+ if (!SkadiRace.IsLocalSkadi() && !TrolRace.IsTrol())
+ {
+ Restore();
+ return;
+ }
+
+ bool inCave = IsInTrollCave(player, out string how);
+ lastHow = how;
+
+ if (inCave && !allowing) Allow(player);
+ else if (!inCave && allowing) Restore();
+
+ ReportWhyIfRefused(player);
+ }
+
+ ///
+ /// Two ways of asking, because the two cases are genuinely different.
+ ///
+ /// FIRST, Location.GetLocation(point, checkDungeons: true). That flag exists for exactly this
+ /// question - "which location owns this point, counting dungeon interiors" - and it is the
+ /// only one of the two that can answer it when the interior is not where the mouth is. The
+ /// previous version of this file dropped it in favour of a distance sweep, and that is why
+ /// the log said "in troll cave=False" while the player was standing in one: a distance test
+ /// against the mouth cannot find a player who is inside.
+ ///
+ /// SECOND, the sweep, kept as the case the first one is weakest at: standing at the mouth,
+ /// outside, where there is no interior to own the point.
+ ///
+ private static bool IsInTrollCave(Player player, out string how)
+ {
+ Vector3 position = player.transform.position;
+
+ Location owning = Location.GetLocation(position, true);
+ if (owning != null && IsTrollCave(owning))
+ {
+ LiftOutrightBan(owning);
+ how = $"GetLocation -> {owning.gameObject.name}";
+ return true;
+ }
+
+ foreach (Location location in Object.FindObjectsByType(FindObjectsSortMode.None))
+ {
+ if (location == null || !IsTrollCave(location)) continue;
+ if (Vector3.Distance(position, location.transform.position) > location.GetMaxRadius() + RadiusSlack) continue;
+
+ LiftOutrightBan(location);
+ how = $"nearby -> {location.gameObject.name}";
+ return true;
+ }
+
+ how = owning != null ? $"owned by '{owning.gameObject.name}', not a cave" : "no location owns this point";
+ return false;
+ }
+
+ private static bool IsTrollCave(Location location)
+ {
+ return location.gameObject.name.IndexOf(CaveNameFragment, System.StringComparison.OrdinalIgnoreCase) >= 0;
+ }
+
+ ///
+ /// Cheap and harmless while we are here: a location may also forbid building outright, and
+ /// that ban would beat everything else. It is NOT what refuses a piece in a troll cave - that
+ /// was two wrong guesses ago - but a cave that did set it would be unbuildable for a second,
+ /// separate reason.
+ ///
+ private static void LiftOutrightBan(Location location)
+ {
+ if (!location.m_noBuild) return;
+
+ location.m_noBuild = false;
+ Jotunn.Logger.LogInfo($"[Races] '{location.gameObject.name}' also forbade building outright; cleared that too.");
+ }
+
+ ///
+ /// Marks every piece on the build tables the player is carrying as dungeon-legal, remembering
+ /// which ones were not so they can be put back exactly as they were.
+ ///
+ private void Allow(Player player)
+ {
+ Inventory inventory = player.GetInventory();
+ if (inventory == null) return;
+
+ foreach (ItemDrop.ItemData item in inventory.GetAllItems())
+ {
+ PieceTable table = item?.m_shared?.m_buildPieces;
+ if (table == null || table.m_pieces == null) continue;
+
+ foreach (GameObject entry in table.m_pieces)
+ {
+ Piece piece = entry != null ? entry.GetComponent() : null;
+ if (piece == null || piece.m_allowedInDungeons) continue;
+
+ piece.m_allowedInDungeons = true;
+ flipped.Add(piece);
+ }
+ }
+
+ allowing = true;
+ Jotunn.Logger.LogInfo($"[Races] In a troll cave: {flipped.Count} pieces temporarily allowed in dungeons.");
+ player.Message(MessageHud.MessageType.Center, "This cave will hold what you build in it.");
+ }
+
+ ///
+ /// Puts the flags back. Without this the permission would follow the player into every crypt
+ /// and sunken chamber in the world, which is not what was asked for.
+ ///
+ private void Restore()
+ {
+ if (!allowing) return;
+
+ foreach (Piece piece in flipped)
+ {
+ if (piece != null) piece.m_allowedInDungeons = false;
+ }
+
+ Jotunn.Logger.LogInfo($"[Races] Left the troll cave: {flipped.Count} pieces set back to dungeon-forbidden.");
+ flipped.Clear();
+ allowing = false;
+ }
+
+ private void OnDestroy()
+ {
+ Restore();
+ }
+
+ ///
+ /// Says, in the log, exactly why the game is refusing a placement right now. m_placementStatus
+ /// is private and Player cannot be inspected offline at all, so it is read with Traverse and
+ /// printed by name - the enum's own ToString does the translating, so this cannot fall out of
+ /// step with the game's own list of reasons. Only speaks when the answer changes.
+ ///
+ private void ReportWhyIfRefused(Player player)
+ {
+ object status = Traverse.Create(player).Field("m_placementStatus").GetValue();
+ if (status == null) return;
+
+ string statusName = status.ToString();
+ if (statusName == "Valid") { lastReport = null; return; }
+
+ string report = statusName + "|" + lastHow;
+ if (report == lastReport) return;
+ lastReport = report;
+
+ // The player's own position and the distance to the nearest troll cave MOUTH are here for
+ // one reason: if a refusal ever survives with "in troll cave=False", these two numbers say
+ // whether the interior sits near its mouth or has been relocated somewhere else entirely -
+ // which is the difference between a tolerance to widen and a wrong idea about the world.
+ Vector3 position = player.transform.position;
+ string nearest = "";
+ if (ZoneSystem.instance != null
+ && ZoneSystem.instance.FindClosestLocation("TrollCave02", position, out ZoneSystem.LocationInstance closest))
+ {
+ nearest = $"{Vector3.Distance(position, closest.m_position):0} m away at {closest.m_position}";
+ }
+
+ Jotunn.Logger.LogInfo($"[Races] Placement refused: {statusName} " +
+ $"(in troll cave={allowing}, pieces flipped={flipped.Count}). " +
+ $"Detection said: {lastHow}. Player at {position}; nearest TrollCave02 mouth {nearest}.");
+ }
+ }
+}
diff --git a/JotunnModStub/RacesOfValheim.cs b/JotunnModStub/RacesOfValheim.cs
index f39e47e..4b69a34 100644
--- a/JotunnModStub/RacesOfValheim.cs
+++ b/JotunnModStub/RacesOfValheim.cs
@@ -46,6 +46,9 @@ namespace RacesOfValheim
gameObject.AddComponent();
gameObject.AddComponent();
gameObject.AddComponent();
+ // Not a race: a perk two races share (Skadi and Trol build inside troll caves), so it
+ // gets its own component rather than living inside either one's Update.
+ gameObject.AddComponent();
PrefabManager.OnVanillaPrefabsAvailable += CreateAllModAssets;
CommandManager.Instance.AddConsoleCommand(new ResetRaceCommand());
CommandManager.Instance.AddConsoleCommand(new CheckProgressionCommand());
@@ -53,6 +56,8 @@ namespace RacesOfValheim
CommandManager.Instance.AddConsoleCommand(new ResetProgressionCommand());
CommandManager.Instance.AddConsoleCommand(new DumpDvergerCommand());
CommandManager.Instance.AddConsoleCommand(new DumpElderCommand());
+ CommandManager.Instance.AddConsoleCommand(new FenrirPackSpawnCommand());
+ CommandManager.Instance.AddConsoleCommand(new DumpPotionsCommand());
}
///
diff --git a/JotunnModStub/RacesOfValheim.csproj b/JotunnModStub/RacesOfValheim.csproj
index 2487ffe..497541d 100644
--- a/JotunnModStub/RacesOfValheim.csproj
+++ b/JotunnModStub/RacesOfValheim.csproj
@@ -34,6 +34,12 @@
..\..\..\..\..\..\Program Files (x86)\Steam\steamapps\common\Valheim\valheim_Data\Managed\assembly_valheim.dll
+
+
+ ..\..\..\..\..\..\Program Files (x86)\Steam\steamapps\common\Valheim\valheim_Data\Managed\SoftReferenceableAssets.dll
+
diff --git a/JotunnModStub/Skadi/SkadiConfig.cs b/JotunnModStub/Skadi/SkadiConfig.cs
index 81134c3..7910560 100644
--- a/JotunnModStub/Skadi/SkadiConfig.cs
+++ b/JotunnModStub/Skadi/SkadiConfig.cs
@@ -48,6 +48,12 @@ namespace RacesOfValheim
// ─── Passive combat ──────────────────────────────────────────────────
public static ConfigEntry BonusFrostDamagePerState;
+ // ─── Skadis Nokkel / the hidden hollow ───────────────────────────────
+ public static ConfigEntry HollowCooldown;
+ public static ConfigEntry HollowPortalCloseDelay;
+ public static ConfigEntry HollowPortalSpawnDistance;
+ public static ConfigEntry HollowEntryHeight;
+
// ─── Dragon forms: scale ─────────────────────────────────────────────
public static ConfigEntry DrakeScale;
public static ConfigEntry ModerScale;
@@ -102,6 +108,16 @@ namespace RacesOfValheim
BonusFrostDamagePerState = config.Bind(combat, "Bonus Frost Damage Per State", 2f,
new ConfigDescription("Flat frost damage added to every hit the player lands, multiplied by the current progression state.", new AcceptableValueRange(0f, 10f)));
+ const string hollow = "Skadi - Hidden Hollow";
+ HollowCooldown = config.Bind(hollow, "Cooldown", 120f,
+ new ConfigDescription("Seconds between openings of the hollow. This is the only brake on Skadis Nokkel - it costs no stamina, eitr or health - and it never applies to LEAVING: stepping in and changing your mind must not lock you in.", new AcceptableValueRange(0f, 600f)));
+ HollowPortalCloseDelay = config.Bind(hollow, "Portal Close Delay", 5f,
+ new ConfigDescription("Seconds the portal pair lingers after the player comes back out. Until then both ends simply stand there - unlike the Trenta portal, this one has no lifetime of its own.", new AcceptableValueRange(0f, 60f)));
+ HollowPortalSpawnDistance = config.Bind(hollow, "Portal Spawn Distance", 2f,
+ new ConfigDescription("Metres in front of the player the outside end of the portal appears.", new AcceptableValueRange(0.5f, 10f)));
+ HollowEntryHeight = config.Bind(hollow, "Entry Height", 1f,
+ new ConfigDescription("Height above the claimed troll cave's own origin that the inner portal stands at. Raise it if arriving ever puts the player inside the ground.", new AcceptableValueRange(0f, 20f)));
+
const string spell = "Skadi - Cold Spell";
SpellStaminaCost = config.Bind(spell, "Stamina Cost", 20f,
new ConfigDescription("Stamina spent per cast.", new AcceptableValueRange(0f, 100f)));
diff --git a/JotunnModStub/Skadi/SkadiFrostHeart.cs b/JotunnModStub/Skadi/SkadiFrostHeart.cs
new file mode 100644
index 0000000..0b53594
--- /dev/null
+++ b/JotunnModStub/Skadi/SkadiFrostHeart.cs
@@ -0,0 +1,57 @@
+using Jotunn.Entities;
+using Jotunn.Managers;
+using UnityEngine;
+
+namespace RacesOfValheim
+{
+ ///
+ /// Greater Frost Heart - the bought leg of the Skadi recipe, and the piece that keeps this chain
+ /// hooked to the faction merchant system the way every other race's does. 1500 coins from the
+ /// Cultist bench, which is the same price band as GreaterUlvsblod, GreaterCursedBone and
+ /// GreaterCursedSkull: the reagent that unlocks the last step of a race's chain.
+ ///
+ /// A NOTE ON THE SHOP KEY, because it has already cost this project once: the Cultist shop in
+ /// FactionMerchantCatalog is mapped on the mob "Fenring_Cultist", NOT on "Fenring" - that one is
+ /// a different bench belonging to the Fenrir trough. Selling from the wrong one puts the item in
+ /// a shop nobody expects.
+ ///
+ public static class SkadiFrostHeart
+ {
+ public const string PrefabName = "GreaterFrostHeart";
+ public const string DisplayName = "Greater Frost Heart";
+ public const int Price = 1500;
+
+ private const string SourcePrefab = "FreezeGland";
+
+ public static void Register()
+ {
+ GameObject prefab = PrefabManager.Instance.CreateClonedPrefab(PrefabName, SourcePrefab);
+ if (prefab == null)
+ {
+ Jotunn.Logger.LogWarning($"[Skadi] Could not clone {SourcePrefab}; {DisplayName} not registered.");
+ return;
+ }
+
+ ItemDrop drop = prefab.GetComponent();
+ if (drop == null || drop.m_itemData == null || drop.m_itemData.m_shared == null)
+ {
+ Jotunn.Logger.LogWarning($"[Skadi] {SourcePrefab} clone has no usable ItemDrop; {DisplayName} not registered.");
+ return;
+ }
+
+ SkadiIce.Apply(prefab);
+
+ ItemDrop.ItemData.SharedData shared = drop.m_itemData.m_shared;
+ shared.m_name = DisplayName;
+ shared.m_description = "Older cold than the mountain's. The cultists sell it and will not say where they dig.";
+ shared.m_itemType = ItemDrop.ItemData.ItemType.Material;
+ shared.m_weight = 0.5f;
+ shared.m_maxStackSize = 10;
+ shared.m_value = Price;
+
+ ItemManager.Instance.AddItem(new CustomItem(prefab, fixReference: false));
+
+ Jotunn.Logger.LogInfo($"[Skadi] {DisplayName} registered at {Price} coins.");
+ }
+ }
+}
diff --git a/JotunnModStub/Skadi/SkadiHollow.cs b/JotunnModStub/Skadi/SkadiHollow.cs
new file mode 100644
index 0000000..6f9f498
--- /dev/null
+++ b/JotunnModStub/Skadi/SkadiHollow.cs
@@ -0,0 +1,256 @@
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace RacesOfValheim
+{
+ ///
+ /// Where Skadis Nokkel takes you: a troll cave that already exists in the world, the same one
+ /// every time, claimed the first time the staff is used.
+ ///
+ /// THIRD AND FINAL SHAPE, and it is by far the smallest. What used to be here - instantiating a
+ /// cave shell, learning where its interior was, emptying it of trolls, standing three benches up
+ /// in it - is all gone. Four things that could each fail, and between them always did.
+ ///
+ /// What makes the cave usable now is not here at all: RaceCaveBuilding lets a Skadi (and a Trol)
+ /// build inside ANY troll cave, by lifting the one restriction that mattered. So this file has
+ /// nothing left to arrange. It picks a cave, it remembers which, and it opens a door to it.
+ ///
+ /// The three failed designs are on the record in Skadi_PortaleGhiaccio.txt sections 0c to 0g, in
+ /// particular the two facts that killed them: DestroyImmediate is forbidden inside an animation
+ /// event callback (and the cast runs in one), and a location's m_position is its MOUTH rather
+ /// than its inside - which is why the portal kept putting the player out on the hillside.
+ ///
+ public static class SkadiHollow
+ {
+ ///
+ /// Confirmed present in a live world, along with TrollCave (interior radius 0, so no use to
+ /// us), MountainCave01, MountainCave02 and Hildir_cave.
+ ///
+ public const string SourceLocation = "TrollCave02";
+
+ // ─── Which cave ───────────────────────────────────────────────────────
+ //
+ // "Half way out, and away from the north." Half of the world's ~10 km radius is 5000, and the
+ // band is generous because a Black Forest troll cave has to actually exist in it.
+ private const float ClaimRadiusMin = 3500f;
+ private const float ClaimRadiusMax = 6500f;
+
+ ///
+ /// Everything with a positive Z is thrown out, which is the whole northern half of the map.
+ /// Cruder than a bearing test and that is deliberate: it cannot accidentally admit the Deep
+ /// North, which is where the first design landed.
+ ///
+ private const float MaxNorthing = 0f;
+
+ ///
+ /// How far from the cave counts as "at my hollow" - used only by the no-planting rule now.
+ /// Wide, because the cave's origin is its mouth and the inside is some way past it.
+ ///
+ public const float Radius = 72f;
+
+ // The claim is written down rather than recomputed. It depends on where this world's troll
+ // caves are and on the order the candidates come back in, so recomputing it after any change
+ // to either would hand the player a different cave and orphan everything built in the old one.
+ private const string CaveKey = "Skadi_HollowCave";
+ private const string ReturnPointKey = "Skadi_HollowReturn";
+
+ private static float lastCastTime = -100000f;
+
+ // ─── Claiming ─────────────────────────────────────────────────────────
+
+ ///
+ /// This player's cave, if they have claimed one. Does not allocate: it is called from the
+ /// build prefix, which runs on every attempted placement.
+ ///
+ public static bool TryGetCave(Player player, out Vector3 cave)
+ {
+ cave = Vector3.zero;
+ if (player == null || player.m_customData == null) return false;
+ return TryReadVector(player, CaveKey, out cave);
+ }
+
+ public static bool IsInside(Player player)
+ {
+ if (player == null) return false;
+ if (!TryGetCave(player, out Vector3 cave)) return false;
+ return (player.transform.position - cave).sqrMagnitude <= Radius * Radius;
+ }
+
+ private static bool TryClaimCave(Player player, out Vector3 cave)
+ {
+ if (TryGetCave(player, out cave)) return true;
+
+ List candidates = FindCandidateCaves();
+ if (candidates.Count == 0)
+ {
+ Jotunn.Logger.LogWarning($"[Skadi] No '{SourceLocation}' found in the Black Forest between " +
+ $"{ClaimRadiusMin:0} m and {ClaimRadiusMax:0} m of the centre, south of the equator. " +
+ "The hollow cannot be claimed in this world.");
+ return false;
+ }
+
+ // Sorted before indexing, because GetLocationList() makes no promise about order and an
+ // unstable order would mean an unstable claim on the very first cast.
+ candidates.Sort((a, b) => a.x != b.x ? a.x.CompareTo(b.x) : a.z.CompareTo(b.z));
+
+ cave = candidates[(int)(HashOf(player) % (uint)candidates.Count)];
+ player.m_customData[CaveKey] = FormatVector(cave);
+
+ Jotunn.Logger.LogInfo($"[Skadi] Hollow claimed for '{player.GetPlayerName()}': {SourceLocation} at {cave} " +
+ $"({BiomeAt(cave)}, {new Vector2(cave.x, cave.z).magnitude:0} m from the centre) " +
+ $"- chosen from {candidates.Count} candidates.");
+ return true;
+ }
+
+ private static List FindCandidateCaves()
+ {
+ List found = new List();
+ if (ZoneSystem.instance == null) return found;
+
+ foreach (ZoneSystem.LocationInstance instance in ZoneSystem.instance.GetLocationList())
+ {
+ if (instance.m_location == null) continue;
+ if (instance.m_location.m_prefabName != SourceLocation) continue;
+
+ Vector3 position = instance.m_position;
+ if (position.z > MaxNorthing) continue;
+
+ float distance = new Vector2(position.x, position.z).magnitude;
+ if (distance < ClaimRadiusMin || distance > ClaimRadiusMax) continue;
+
+ if (BiomeAt(position) != Heightmap.Biome.BlackForest) continue;
+
+ found.Add(position);
+ }
+ return found;
+ }
+
+ private static Heightmap.Biome BiomeAt(Vector3 point)
+ {
+ if (WorldGenerator.instance == null) return Heightmap.Biome.None;
+ return WorldGenerator.instance.GetBiome(new Vector3(point.x, 0f, point.z));
+ }
+
+ private static uint HashOf(Player player)
+ {
+ long id = player != null ? player.GetPlayerID() : 0L;
+ if (id == 0L)
+ {
+ string name = player != null ? player.GetPlayerName() : null;
+ id = string.IsNullOrEmpty(name) ? 1L : name.GetStableHashCode();
+ }
+ // Knuth's multiplicative hash, so two ids one apart do not pick neighbouring caves.
+ return (uint)(id ^ (id >> 32)) * 2654435761u;
+ }
+
+ // ─── The cast ─────────────────────────────────────────────────────────
+
+ ///
+ /// What Skadis Nokkel does. Outside, it opens the pair; inside, it takes the player straight
+ /// back out. The cooldown applies to going IN only - stepping in and changing your mind must
+ /// not lock you in a cave for two minutes.
+ ///
+ /// The far end stands at the cave's mouth, and the player walks in from there. That is not a
+ /// compromise any more: since building works in the cave itself, there is nothing waiting
+ /// inside that has to be lined up with, so the one point we can name honestly is the right
+ /// one to use.
+ ///
+ public static void Cast(Player player)
+ {
+ if (player == null || player != Player.m_localPlayer) return;
+
+ if (IsInside(player))
+ {
+ Leave(player);
+ return;
+ }
+
+ float cooldown = SkadiConfig.HollowCooldown.Value;
+ float waited = Time.time - lastCastTime;
+ if (waited < cooldown)
+ {
+ int remaining = Mathf.CeilToInt(cooldown - waited);
+ player.Message(MessageHud.MessageType.Center, $"The frost has not gathered again ({remaining}s).");
+ return;
+ }
+
+ if (!TryClaimCave(player, out Vector3 cave))
+ {
+ player.Message(MessageHud.MessageType.Center, "No hollow answers you.");
+ return;
+ }
+
+ lastCastTime = Time.time;
+ SkadiRace.ApplyCooldownIcon(SkadiRace.HOLLOW_COOLDOWN_SE, SkadiConfig.HollowCooldown.Value);
+
+ // Remembered across a logout, so casting from inside always has somewhere to put them.
+ player.m_customData[ReturnPointKey] = FormatVector(player.transform.position);
+
+ Vector3 castPoint = player.transform.position
+ + player.transform.forward * SkadiConfig.HollowPortalSpawnDistance.Value;
+
+ SkadiHollowPortal.Open(castPoint, player.transform.rotation,
+ cave + Vector3.up * SkadiConfig.HollowEntryHeight.Value);
+ }
+
+ private static void Leave(Player player)
+ {
+ player.TeleportTo(ReturnPointFor(player), player.transform.rotation, true);
+ SkadiHollowPortal.CloseSoon();
+ }
+
+ ///
+ /// Called by the portal when the player walks through. Going in changes nothing - the pair
+ /// stands as long as they are inside. Coming out starts the collapse.
+ ///
+ public static void OnTraversed(bool intoHollow)
+ {
+ if (!intoHollow) SkadiHollowPortal.CloseSoon();
+ }
+
+ private static Vector3 ReturnPointFor(Player player)
+ {
+ if (TryReadVector(player, ReturnPointKey, out Vector3 stored)
+ && TryGetCave(player, out Vector3 cave)
+ && (stored - cave).sqrMagnitude > Radius * Radius) // a point inside would strand them
+ {
+ return stored;
+ }
+
+ // Same fallback the Trenta portal uses for its home end, and for the same reason: the
+ // respawn point is the one place the game itself considers always valid.
+ PlayerProfile profile = Game.instance != null ? Game.instance.GetPlayerProfile() : null;
+ if (profile != null)
+ {
+ return profile.HaveCustomSpawnPoint() ? profile.GetCustomSpawnPoint() : PlayerProfile.m_originalSpawnPoint;
+ }
+ return PlayerProfile.m_originalSpawnPoint;
+ }
+
+ // ─── customData helpers ───────────────────────────────────────────────
+
+ private static string FormatVector(Vector3 v)
+ {
+ return $"{v.x:R};{v.y:R};{v.z:R}";
+ }
+
+ private static bool TryReadVector(Player player, string key, out Vector3 value)
+ {
+ value = Vector3.zero;
+ if (player == null || player.m_customData == null) return false;
+ if (!player.m_customData.TryGetValue(key, out string stored) || string.IsNullOrEmpty(stored)) return false;
+
+ string[] parts = stored.Split(';');
+ if (parts.Length != 3) return false;
+
+ System.Globalization.CultureInfo invariant = System.Globalization.CultureInfo.InvariantCulture;
+ const System.Globalization.NumberStyles style = System.Globalization.NumberStyles.Float;
+ if (!float.TryParse(parts[0], style, invariant, out float x)) return false;
+ if (!float.TryParse(parts[1], style, invariant, out float y)) return false;
+ if (!float.TryParse(parts[2], style, invariant, out float z)) return false;
+
+ value = new Vector3(x, y, z);
+ return true;
+ }
+ }
+}
diff --git a/JotunnModStub/Skadi/SkadiHollowPortal.cs b/JotunnModStub/Skadi/SkadiHollowPortal.cs
new file mode 100644
index 0000000..cdf91f3
--- /dev/null
+++ b/JotunnModStub/Skadi/SkadiHollowPortal.cs
@@ -0,0 +1,234 @@
+using System.Collections;
+using Jotunn.Managers;
+using UnityEngine;
+
+namespace RacesOfValheim
+{
+ ///
+ /// One end of the pair of portals Skadis Nokkel opens. Deliberately a copy of
+ /// TrentaPortalLink rather than a shared abstraction: the two diverge on colour, on who is
+ /// allowed through, and above all on when they close (the Trenta pair dies on a timer, this
+ /// one waits for the player to come back out), and three differences in a forty-line class is
+ /// cheaper duplicated than parameterised.
+ ///
+ /// Everything the Trenta version earned is kept: a plain GameObject with no ZNetView, so it is
+ /// unregistered and purely local - which is most of "only the player can go in", since remote
+ /// clients never learn the thing exists - plus its own trigger, its own teleport call, and the
+ /// same guard against the same-frame ping-pong.
+ ///
+ public class SkadiHollowPortalLink : MonoBehaviour
+ {
+ public SkadiHollowPortalLink Other;
+
+ /// True on the end that stands inside the hollow.
+ public bool IsHollowSide;
+
+ // Without this, a player who arrives is still standing in the destination's own trigger and
+ // gets bounced straight back the way they came, forever.
+ private float reentryBlockedUntil = -1f;
+
+ private void OnTriggerEnter(Collider other)
+ {
+ if (Other == null || Time.time < reentryBlockedUntil) return;
+
+ Player player = other.GetComponentInParent();
+ if (player == null) return;
+
+ // The requirement spelled out, even though the portal being local already means no
+ // other player can reach this line: only the owner walks through.
+ if (player != Player.m_localPlayer) return;
+
+ Vector3 destination = Other.transform.position + Other.transform.forward * 1.5f;
+ player.TeleportTo(destination, Other.transform.rotation, true);
+
+ Other.reentryBlockedUntil = Time.time + 1.5f;
+
+ // Going in leaves the pair standing; coming out starts the collapse.
+ SkadiHollow.OnTraversed(intoHollow: !IsHollowSide);
+ }
+ }
+
+ public static class SkadiHollowPortal
+ {
+ private static Material cachedVfxMaterial;
+ private static bool vfxMaterialResolved;
+
+ private static GameObject outsideEnd;
+ private static GameObject hollowEnd;
+ private static Coroutine closing;
+
+ public static bool IsOpen => outsideEnd != null || hollowEnd != null;
+
+ ///
+ /// Spawns the pair: one where the Skadi is standing, one inside their hollow. Neither end
+ /// has a lifetime - they stand until CloseSoon is called.
+ ///
+ public static void Open(Vector3 outsidePoint, Quaternion outsideRotation, Vector3 hollowPoint)
+ {
+ CloseNow();
+
+ outsideEnd = SpawnEnd(outsidePoint, outsideRotation, isHollowSide: false);
+ hollowEnd = SpawnEnd(hollowPoint, Quaternion.identity, isHollowSide: true);
+
+ SkadiHollowPortalLink outsideLink = outsideEnd.GetComponent();
+ SkadiHollowPortalLink hollowLink = hollowEnd.GetComponent();
+ outsideLink.Other = hollowLink;
+ hollowLink.Other = outsideLink;
+ }
+
+ ///
+ /// Takes both ends down after the configured grace period. Called when the player leaves the
+ /// hollow - by walking out or by casting from inside - which is the only thing that closes
+ /// this pair.
+ ///
+ public static void CloseSoon()
+ {
+ if (!IsOpen || closing != null) return;
+ if (SkadiRace.Instance == null) { CloseNow(); return; }
+
+ closing = SkadiRace.Instance.StartCoroutine(
+ CloseAfter(SkadiConfig.HollowPortalCloseDelay.Value));
+ }
+
+ /// No grace period, no animation. For reopening, and for shutting down.
+ public static void CloseNow()
+ {
+ if (closing != null && SkadiRace.Instance != null)
+ {
+ SkadiRace.Instance.StopCoroutine(closing);
+ }
+ closing = null;
+
+ if (outsideEnd != null) Object.Destroy(outsideEnd);
+ if (hollowEnd != null) Object.Destroy(hollowEnd);
+ outsideEnd = null;
+ hollowEnd = null;
+ }
+
+ private static GameObject SpawnEnd(Vector3 position, Quaternion rotation, bool isHollowSide)
+ {
+ GameObject portal = new GameObject(isHollowSide ? "SkadiHollowPortal_In" : "SkadiHollowPortal_Out");
+ portal.transform.position = position;
+ portal.transform.rotation = rotation;
+
+ CapsuleCollider trigger = portal.AddComponent();
+ trigger.isTrigger = true;
+ trigger.height = 3f;
+ trigger.radius = 1.2f;
+ trigger.center = new Vector3(0, 1.5f, 0);
+
+ SkadiHollowPortalLink link = portal.AddComponent();
+ link.IsHollowSide = isHollowSide;
+
+ BuildSwirlVfx(portal.transform);
+
+ return portal;
+ }
+
+ ///
+ /// The swirl only, no wooden frame - same shape and same reasoning as the Trenta portal's:
+ /// borrow a particle material off the real portal prefab by READING it (never instantiating
+ /// it, so none of the real portal's gameplay components ever get a chance to run), then
+ /// drive shape, emission and colour from here. The one change is the colour, which is
+ /// Skadi's ice instead of the Trenta's toxic purple.
+ ///
+ private static void BuildSwirlVfx(Transform parent)
+ {
+ if (!vfxMaterialResolved)
+ {
+ vfxMaterialResolved = true;
+ GameObject source = PrefabManager.Cache.GetPrefab("portal_wood");
+ if (source != null)
+ {
+ ParticleSystemRenderer sourceRenderer = source.GetComponentInChildren(true);
+ if (sourceRenderer != null) cachedVfxMaterial = sourceRenderer.material;
+ }
+ if (cachedVfxMaterial == null)
+ {
+ Jotunn.Logger.LogWarning("[Skadi] Hollow portal: no particle material on 'portal_wood'; using the default particle material.");
+ }
+ }
+
+ GameObject vfx = new GameObject("Swirl");
+ vfx.transform.SetParent(parent, false);
+ vfx.transform.localPosition = new Vector3(0, 1.2f, 0);
+
+ ParticleSystem ps = vfx.AddComponent();
+ var main = ps.main;
+ main.loop = true;
+ main.startLifetime = 1.5f;
+ main.startSpeed = 0f;
+ main.startSize = new ParticleSystem.MinMaxCurve(0.15f, 0.3f);
+ main.maxParticles = 200;
+ main.simulationSpace = ParticleSystemSimulationSpace.Local;
+
+ var emission = ps.emission;
+ emission.rateOverTime = 80f;
+
+ var shape = ps.shape;
+ shape.shapeType = ParticleSystemShapeType.Circle;
+ shape.radius = 1f;
+ shape.radiusThickness = 0.1f; // hollow ring, not a filled disc
+
+ var rotationOverLifetime = ps.rotationOverLifetime;
+ rotationOverLifetime.enabled = true;
+ rotationOverLifetime.z = new ParticleSystem.MinMaxCurve(90f);
+
+ ParticleSystemRenderer renderer = ps.GetComponent();
+ if (cachedVfxMaterial != null) renderer.material = cachedVfxMaterial;
+
+ var colorOverLifetime = ps.colorOverLifetime;
+ colorOverLifetime.enabled = true;
+ Gradient grad = new Gradient();
+ grad.SetKeys(
+ new GradientColorKey[] { new GradientColorKey(SkadiIce.PortalSwirl, 0f), new GradientColorKey(SkadiIce.PortalSwirl, 1f) },
+ new GradientAlphaKey[] { new GradientAlphaKey(0f, 0f), new GradientAlphaKey(0.9f, 0.3f), new GradientAlphaKey(0.9f, 0.7f), new GradientAlphaKey(0f, 1f) }
+ );
+ colorOverLifetime.color = grad;
+
+ ps.Play();
+ }
+
+ private static IEnumerator CloseAfter(float seconds)
+ {
+ yield return new WaitForSeconds(seconds);
+
+ GameObject a = outsideEnd;
+ GameObject b = hollowEnd;
+ outsideEnd = null;
+ hollowEnd = null;
+ closing = null;
+
+ yield return Collapse(a);
+ yield return Collapse(b);
+ }
+
+ ///
+ /// Link and trigger die first, so nothing can walk through mid-collapse, then a one-second
+ /// shrink stands in for a closing animation - vanilla portals are simply present or absent,
+ /// so there is no real one to borrow.
+ ///
+ private static IEnumerator Collapse(GameObject portal)
+ {
+ if (portal == null) yield break;
+
+ SkadiHollowPortalLink link = portal.GetComponent();
+ if (link != null) Object.Destroy(link);
+
+ CapsuleCollider trigger = portal.GetComponent();
+ if (trigger != null) Object.Destroy(trigger);
+
+ float t = 0f;
+ Vector3 startScale = portal.transform.localScale;
+ while (t < 1f)
+ {
+ if (portal == null) yield break;
+ t += Time.deltaTime;
+ portal.transform.localScale = Vector3.Lerp(startScale, Vector3.zero, t);
+ yield return null;
+ }
+
+ if (portal != null) Object.Destroy(portal);
+ }
+ }
+}
diff --git a/JotunnModStub/Skadi/SkadiNokkel.cs b/JotunnModStub/Skadi/SkadiNokkel.cs
new file mode 100644
index 0000000..f4a32b4
--- /dev/null
+++ b/JotunnModStub/Skadi/SkadiNokkel.cs
@@ -0,0 +1,396 @@
+using HarmonyLib;
+using Jotunn.Configs;
+using Jotunn.Entities;
+using Jotunn.Managers;
+using UnityEngine;
+
+namespace RacesOfValheim
+{
+ ///
+ /// The one ice palette the whole Skadi chain shares. Taken from the Fader recolour in
+ /// SkadiRace.ExecuteTransformation rather than picked fresh, so the staff, the reagent and the
+ /// portal are all the same ice as the Skeleton Dragon the race turns into at tier 8.
+ ///
+ public static class SkadiIce
+ {
+ public static readonly Color Albedo = new Color(0.6f, 0.8f, 1f, 1f);
+ public static readonly Color Emission = new Color(0f, 0.5f, 1f, 1f);
+ public static readonly Color PortalSwirl = new Color(0.55f, 0.85f, 1f, 1f);
+
+ ///
+ /// Multiplies the ice tint over whatever the base texture already carries instead of
+ /// overwriting it, so the model keeps its detail and reads as frozen bone rather than as a
+ /// flat blue silhouette. Same approach as AswidSpectralClaw.ApplySpectralVisual, and like
+ /// that one it copies each material first so the vanilla asset is never touched.
+ ///
+ public static void Apply(GameObject root)
+ {
+ if (root == null) return;
+
+ foreach (Renderer renderer in root.GetComponentsInChildren(true))
+ {
+ if (renderer == null || renderer is ParticleSystemRenderer) continue;
+
+ Material[] source = renderer.sharedMaterials;
+ Material[] tinted = new Material[source.Length];
+ for (int i = 0; i < source.Length; i++)
+ {
+ if (source[i] == null) continue;
+
+ Material material = new Material(source[i]);
+ if (material.HasProperty("_Color"))
+ {
+ Color baseColor = material.GetColor("_Color");
+ material.SetColor("_Color", new Color(baseColor.r * Albedo.r,
+ baseColor.g * Albedo.g,
+ baseColor.b * Albedo.b,
+ baseColor.a));
+ }
+ if (material.HasProperty("_EmissionColor")) material.SetColor("_EmissionColor", Emission);
+
+ tinted[i] = material;
+ }
+ renderer.sharedMaterials = tinted;
+ }
+ }
+ }
+
+ ///
+ /// Skadis Nokkel - "Skadi's key". A StaffSkeleton with the skeleton taken out of it: it costs no
+ /// eitr, no health and no stamina, it summons nothing, and what it does instead is open a portal
+ /// into the player's own hidden hollow (SkadiHollow).
+ ///
+ /// The name is the point. It is not a weapon that happens to open a door, it is a key - and a
+ /// reproducible one: losing it costs a trip to the forge, not the hollow.
+ ///
+ /// Two layers keep the vanilla staff's behaviour from leaking through, deliberately overlapping:
+ /// - every field that could carry a cost or a summon is zeroed on the clone (Strip below);
+ /// - the attack trigger itself is intercepted and vanilla's never runs for this staff
+ /// (SkadiNokkelCastPatch). Nulling a projectile field would leave vanilla walking into it;
+ /// taking over the method means that code path is not merely defused, it is unreachable.
+ ///
+ public static class SkadiNokkel
+ {
+ public const string PrefabName = "SkadiNokkel";
+ public const string DisplayName = "Skadis Nokkel";
+ private const string SourcePrefab = "StaffSkeleton";
+
+ private const string ModerDrop = "DragonTear";
+ private const string SkullTrophy = "TrophySkeleton";
+
+ public static void Register()
+ {
+ GameObject prefab = PrefabManager.Instance.CreateClonedPrefab(PrefabName, SourcePrefab);
+ if (prefab == null)
+ {
+ Jotunn.Logger.LogWarning($"[Skadi] Could not clone {SourcePrefab}; {DisplayName} not registered.");
+ return;
+ }
+
+ ItemDrop drop = prefab.GetComponent();
+ if (drop == null || drop.m_itemData == null || drop.m_itemData.m_shared == null)
+ {
+ Jotunn.Logger.LogWarning($"[Skadi] {SourcePrefab} clone has no usable ItemDrop; {DisplayName} not registered.");
+ return;
+ }
+
+ ItemDrop.ItemData.SharedData shared = drop.m_itemData.m_shared;
+ shared.m_name = DisplayName;
+ shared.m_description = "A staff of frozen bone. It raises nothing. Used, it opens the way to a hollow " +
+ "that is yours and no one else's - and used again, it lets you out.";
+ shared.m_useDurability = false;
+
+ // ItemType is left exactly as the vanilla staff has it, on purpose: it decides the
+ // equip slot and which animation set the character uses, and the cast gesture is the
+ // whole reason this is a staff and not a trinket.
+
+ Strip(shared);
+ SkadiIce.Apply(prefab);
+
+ ItemManager.Instance.AddItem(new CustomItem(prefab, fixReference: false));
+
+ LogCosts("straight after registering", shared);
+
+ ItemManager.Instance.AddRecipe(new CustomRecipe(new RecipeConfig
+ {
+ Item = PrefabName,
+ Amount = 1,
+ CraftingStation = CraftingStations.Forge,
+ Requirements = new[]
+ {
+ new RequirementConfig(SkadiFrostHeart.PrefabName, 1, 0, true),
+ new RequirementConfig(ModerDrop, 1, 0, true),
+ new RequirementConfig(SkullTrophy, 1, 0, true),
+ },
+ }));
+
+ Jotunn.Logger.LogInfo($"[Skadi] {DisplayName} registered: no eitr, no health, no summon.");
+ }
+
+ ///
+ /// Takes the skeleton staff apart. Every field is zeroed on BOTH attacks, because the
+ /// secondary is a separate Attack with its own copy of every cost.
+ ///
+ /// The summon is the interesting one: it comes from a SpawnAbility component (verified class,
+ /// field GameObject[] m_spawnPrefab) which does not live on the item but on a prefab hung off
+ /// the attack. WHICH field hangs it - m_attackProjectile or m_spawnOnTrigger - is not
+ /// knowable from the game files, so all of them go. Nulling three fields that might each be
+ /// the culprit costs nothing; guessing wrong costs a skeleton every cast.
+ ///
+ /// m_attackStamina goes to zero too, and that is a decision, not thoroughness: the moment
+ /// someone wants to flee into their hollow is exactly the moment they have no stamina left.
+ /// The only brake on this staff is its cooldown.
+ ///
+ private static void Strip(ItemDrop.ItemData.SharedData shared)
+ {
+ StripAttack(shared.m_attack);
+ StripAttack(shared.m_secondaryAttack);
+ }
+
+ private static void StripAttack(Attack attack)
+ {
+ if (attack == null) return;
+
+ attack.m_attackEitr = 0f;
+ attack.m_drawEitrDrain = 0f;
+ attack.m_reloadEitrDrain = 0f;
+
+ attack.m_attackHealth = 0f;
+ attack.m_attackHealthPercentage = 0f;
+ attack.m_attackHealthLowBlockUse = false;
+ attack.m_attackHealthReturnHit = 0f;
+
+ attack.m_attackStamina = 0f;
+ attack.m_drawStaminaDrain = 0f;
+ attack.m_reloadStaminaDrain = 0f;
+
+ attack.m_attackProjectile = null;
+ attack.m_spawnOnTrigger = null;
+ attack.m_spawnOnHit = null;
+ attack.m_spawnOnHitChance = 0f;
+
+ // The animation stays. It is the summoning gesture, which is the right gesture for
+ // opening a way, and it is the same one TrentaAbilities plays by hand for its portal.
+ }
+
+ ///
+ /// Runs on the cast. Race-gated: the hollow belongs to the Skadi, so in anyone else's hands
+ /// this is an inert stick - the same shape as Aswid_SpectralClawDamage_Patch, which asks
+ /// AswidRace.IsAswid() before doing anything at all.
+ ///
+ public static void OnCast(Player player)
+ {
+ if (player == null || player != Player.m_localPlayer) return;
+
+ if (!SkadiRace.IsLocalSkadi())
+ {
+ player.Message(MessageHud.MessageType.Center, "The staff is cold and answers to someone else.");
+ return;
+ }
+
+ SkadiHollow.Cast(player);
+ }
+
+ public static bool IsNokkel(ItemDrop.ItemData item)
+ {
+ return item != null && item.m_dropPrefab != null && item.m_dropPrefab.name == PrefabName;
+ }
+
+ ///
+ /// True when a cost being asked about belongs to this staff.
+ ///
+ /// The fallback on the equipped weapon is not belt-and-braces, it is necessary: the cost
+ /// getters are called from Attack.Start, and m_weapon is not guaranteed to have been assigned
+ /// by the time the cost is checked. It is deliberately only consulted when m_weapon is null,
+ /// so a creature's own attack cannot be zeroed just because the player happens to be holding
+ /// the staff at the time.
+ ///
+ public static bool IsNokkelContext(ItemDrop.ItemData weapon)
+ {
+ if (weapon != null) return IsNokkel(weapon);
+
+ Player local = Player.m_localPlayer;
+ return local != null && IsNokkel(local.GetCurrentWeapon());
+ }
+
+ ///
+ /// Prints what the clone's attack actually costs, so "the eitr cost came back" stops being a
+ /// mystery and becomes a number with a timestamp. Called once at registration and again from
+ /// the F8 dump, which between them say whether the zeroes were never written or were written
+ /// and then overwritten by something else.
+ ///
+ public static void LogCosts(string when, ItemDrop.ItemData.SharedData shared)
+ {
+ if (shared == null) { Jotunn.Logger.LogWarning($"[Skadi] Nokkel costs {when}: no shared data."); return; }
+
+ Attack primary = shared.m_attack;
+ Attack secondary = shared.m_secondaryAttack;
+
+ Jotunn.Logger.LogInfo($"[Skadi] Nokkel costs {when}: " +
+ $"primary eitr={Describe(primary, a => a.m_attackEitr)} " +
+ $"health={Describe(primary, a => a.m_attackHealth)} " +
+ $"health%={Describe(primary, a => a.m_attackHealthPercentage)} " +
+ $"stamina={Describe(primary, a => a.m_attackStamina)} | " +
+ $"secondary eitr={Describe(secondary, a => a.m_attackEitr)} " +
+ $"stamina={Describe(secondary, a => a.m_attackStamina)}");
+ }
+
+ private static string Describe(Attack attack, System.Func read)
+ {
+ return attack == null ? "" : read(attack).ToString("0.##");
+ }
+
+ ///
+ /// What the F8 dump prints for this chain. Two unknowns, both settled by reading them once
+ /// off a running game: which field of the vanilla staff carries the summon, and what the
+ /// troll cave location is really called in this build.
+ ///
+ public static void DumpSource()
+ {
+ Jotunn.Logger.LogInfo("=== SKADI NOKKEL SOURCE DUMP ===");
+
+ GameObject staff = PrefabManager.Cache.GetPrefab(SourcePrefab);
+ ItemDrop staffDrop = staff != null ? staff.GetComponent() : null;
+ if (staffDrop == null)
+ {
+ Jotunn.Logger.LogWarning($"{SourcePrefab} not found.");
+ }
+ else
+ {
+ Attack attack = staffDrop.m_itemData.m_shared.m_attack;
+ Jotunn.Logger.LogInfo($" m_attackType : {attack.m_attackType}");
+ Jotunn.Logger.LogInfo($" m_attackAnimation : {attack.m_attackAnimation}");
+ Jotunn.Logger.LogInfo($" m_attackProjectile : {(attack.m_attackProjectile != null ? attack.m_attackProjectile.name : "")}");
+ Jotunn.Logger.LogInfo($" m_spawnOnTrigger : {(attack.m_spawnOnTrigger != null ? attack.m_spawnOnTrigger.name : "")}");
+ Jotunn.Logger.LogInfo($" m_attackEitr : {attack.m_attackEitr}");
+ Jotunn.Logger.LogInfo($" m_attackHealth : {attack.m_attackHealth} / {attack.m_attackHealthPercentage}%");
+
+ foreach (GameObject candidate in new[] { attack.m_attackProjectile, attack.m_spawnOnTrigger })
+ {
+ if (candidate == null) continue;
+ foreach (SpawnAbility ability in candidate.GetComponentsInChildren(true))
+ {
+ string spawns = "";
+ if (ability.m_spawnPrefab != null && ability.m_spawnPrefab.Length > 0)
+ {
+ string[] names = new string[ability.m_spawnPrefab.Length];
+ for (int i = 0; i < names.Length; i++)
+ {
+ names[i] = ability.m_spawnPrefab[i] != null ? ability.m_spawnPrefab[i].name : "";
+ }
+ spawns = string.Join(", ", names);
+ }
+ Jotunn.Logger.LogInfo($" SpawnAbility on '{candidate.name}' spawns: {spawns}");
+ }
+ }
+ }
+
+ // The clone as the game currently holds it, not as Register() left it. If these are not
+ // zero, the write in Strip() did not survive - which is the whole reason
+ // SkadiNokkelFreeCastPatch exists, and this line is how we find out whether it is still
+ // needed or whether the fields hold after all.
+ GameObject clone = PrefabManager.Cache.GetPrefab(PrefabName);
+ ItemDrop cloneDrop = clone != null ? clone.GetComponent() : null;
+ if (cloneDrop == null)
+ {
+ Jotunn.Logger.LogWarning($" {PrefabName} is not in the prefab cache.");
+ }
+ else
+ {
+ LogCosts("as the game holds it now", cloneDrop.m_itemData.m_shared);
+ Jotunn.Logger.LogInfo($" shared data instance is {(ReferenceEquals(cloneDrop.m_itemData.m_shared, staffDrop != null ? staffDrop.m_itemData.m_shared : null) ? "THE SAME OBJECT as the vanilla staff's - that is the bug" : "its own copy, as expected")}");
+ }
+
+ // The other half: is 'TrollCave02' actually what it is called here?
+ Jotunn.Logger.LogInfo($"--- locations matching 'cave' (looking for {SkadiHollow.SourceLocation}) ---");
+ if (ZoneSystem.instance == null || ZoneSystem.instance.m_locations == null)
+ {
+ Jotunn.Logger.LogWarning(" ZoneSystem not up yet; load a world first.");
+ }
+ else
+ {
+ // m_locations, not GetLocationList(): the latter is public but returns the locations
+ // PLACED in this world, and the hollow needs the definition, not an instance.
+ foreach (ZoneSystem.ZoneLocation location in ZoneSystem.instance.m_locations)
+ {
+ if (location == null || string.IsNullOrEmpty(location.m_prefabName)) continue;
+ if (location.m_prefabName.IndexOf("cave", System.StringComparison.OrdinalIgnoreCase) < 0) continue;
+
+ Jotunn.Logger.LogInfo($" {location.m_prefabName} (biome {location.m_biome}, " +
+ $"interior r{location.m_interiorRadius}, clearArea {location.m_clearArea})");
+ }
+ }
+
+ Jotunn.Logger.LogInfo("=== END SKADI NOKKEL SOURCE DUMP ===");
+ }
+ }
+
+ ///
+ /// The cast hook, and the second half of "remove the unwanted components".
+ ///
+ /// Attack.OnAttackTrigger() is used rather than Attack.Start because it takes NO parameters -
+ /// its signature cannot drift and cannot be got wrong, which matters here because Attack.Start's
+ /// parameter types could not even be loaded for inspection outside the game. It also fires at
+ /// the moment the animation reaches its release point, which is exactly when a cast should land.
+ ///
+ /// It is a Prefix returning FALSE, not a postfix, and that is the whole trick: for this staff
+ /// vanilla's attack-trigger code never executes at all. The summon and the projectile are not
+ /// just defused by the zeroed fields, they are unreachable - and vanilla cannot trip over the
+ /// nulls we left behind either, which a postfix would have been at the mercy of.
+ ///
+ /// m_weapon and m_character are both PRIVATE on Attack, so they arrive through Harmony's triple
+ /// underscore field injection rather than off __instance - which is also why they are spelled
+ /// out here instead of being read with Traverse: the injection is checked at patch time, so a
+ /// rename shows up as a startup error instead of a silent null every cast.
+ ///
+ [HarmonyPatch(typeof(Attack), "OnAttackTrigger")]
+ public static class SkadiNokkelCastPatch
+ {
+ public static bool Prefix(ItemDrop.ItemData ___m_weapon, Humanoid ___m_character)
+ {
+ if (!SkadiNokkel.IsNokkel(___m_weapon)) return true;
+
+ SkadiNokkel.OnCast(___m_character as Player);
+ return false;
+ }
+ }
+
+ ///
+ /// The staff costs nothing, guaranteed - and this is what guarantees it.
+ ///
+ /// Zeroing m_attackEitr, m_attackHealth and m_attackStamina on the clone is still done in
+ /// Strip(), and by every reading of the game's own code it ought to be enough: those three, plus
+ /// the two drain fields, are the ONLY eitr costs that exist anywhere on Attack, and SharedData
+ /// carries none at all (checked field by field). In game the cost came back anyway, which means
+ /// the write to the clone's own SharedData does not survive something - so relying on that write
+ /// is relying on a mechanism that has already been observed to fail.
+ ///
+ /// These three getters are the single funnel every cost check flows through: Attack.Start asks
+ /// them before it will start, and the tooltip asks them for what to print. Forcing them to zero
+ /// makes the staff free no matter what any field says, which is the same reasoning as the prefix
+ /// above - do not defuse the code path, remove it.
+ ///
+ /// All three are PRIVATE and take no parameters, so they are addressed by name through
+ /// AccessTools and share one postfix.
+ ///
+ [HarmonyPatch]
+ public static class SkadiNokkelFreeCastPatch
+ {
+ [HarmonyTargetMethods]
+ private static System.Collections.Generic.IEnumerable TargetMethods()
+ {
+ yield return AccessTools.Method(typeof(Attack), "GetAttackEitr");
+ yield return AccessTools.Method(typeof(Attack), "GetAttackHealth");
+ yield return AccessTools.Method(typeof(Attack), "GetAttackStamina");
+ }
+
+ [HarmonyPostfix]
+ private static void Postfix(ItemDrop.ItemData ___m_weapon, ref float __result)
+ {
+ if (__result == 0f) return;
+ if (!SkadiNokkel.IsNokkelContext(___m_weapon)) return;
+
+ __result = 0f;
+ }
+ }
+}
diff --git a/JotunnModStub/Skadi/SkadiRace.cs b/JotunnModStub/Skadi/SkadiRace.cs
index f5cf719..75e2602 100644
--- a/JotunnModStub/Skadi/SkadiRace.cs
+++ b/JotunnModStub/Skadi/SkadiRace.cs
@@ -33,6 +33,7 @@ namespace RacesOfValheim
// rebuild - see CONFIGURATION-MANAGER-HOWTO.md.
public const string SPELL_COOLDOWN_SE = "SE_SkadiSpellCooldown";
public const string ATTACK_COOLDOWN_SE = "SE_SkadiAttackCooldown";
+ public const string HOLLOW_COOLDOWN_SE = "SE_SkadiHollowCooldown";
private static float SPELL_STAMINA_COST => SkadiConfig.SpellStaminaCost.Value;
private static float SPELL_COOLDOWN => SkadiConfig.SpellCooldown.Value;
@@ -50,6 +51,12 @@ namespace RacesOfValheim
public void CreateModAssets()
{
+ // The reagent goes first: the faction merchant catalogue resolves its entries by prefab
+ // name, so Greater Frost Heart has to exist before a Fenring_Cultist is ever set up as a
+ // bench - and the staff's recipe references it by name too.
+ SkadiFrostHeart.Register();
+ SkadiNokkel.Register();
+
var se = ScriptableObject.CreateInstance();
se.name = "SE_SkadiStats";
se.m_name = "Skadi's Blessing";
@@ -101,6 +108,13 @@ namespace RacesOfValheim
attackCd.m_tooltip = "Your dragon shape must ready itself to strike again.";
attackCd.m_icon = GetItemIcon("TrophyHatchling") ?? dragonIcon;
ItemManager.Instance.AddStatusEffect(new CustomStatusEffect(attackCd, fixReference: false));
+
+ var hollowCd = ScriptableObject.CreateInstance();
+ hollowCd.name = HOLLOW_COOLDOWN_SE;
+ hollowCd.m_name = "Skadis Nokkel";
+ hollowCd.m_tooltip = "The way to your hollow must freeze over again before it will open.";
+ hollowCd.m_icon = GetItemIcon("StaffIceShards") ?? dragonIcon;
+ ItemManager.Instance.AddStatusEffect(new CustomStatusEffect(hollowCd, fixReference: false));
}
// Drives the HUD countdown: Valheim prints the remaining time on any status effect whose
@@ -133,8 +147,17 @@ namespace RacesOfValheim
public bool IsSkadi()
{
- return Player.m_localPlayer != null &&
- Player.m_localPlayer.m_customData.ContainsKey("Race") &&
+ return IsLocalSkadi();
+ }
+
+ ///
+ /// The same check, reachable without an Instance - which the Nokkel's Harmony patch and the
+ /// hollow both need, since they run from static context.
+ ///
+ public static bool IsLocalSkadi()
+ {
+ return Player.m_localPlayer != null &&
+ Player.m_localPlayer.m_customData.ContainsKey("Race") &&
Player.m_localPlayer.m_customData["Race"] == "Skadi";
}
@@ -231,7 +254,8 @@ namespace RacesOfValheim
DumpPrefabDebugInfo("Dragon");
DumpPrefabDebugInfo("Hatchling");
DumpPrefabDebugInfo("Fader");
- if (Player.m_localPlayer != null) Player.m_localPlayer.Message(MessageHud.MessageType.Center, "Dumped Dragon/Drake/Fader debug info to console!");
+ SkadiNokkel.DumpSource();
+ if (Player.m_localPlayer != null) Player.m_localPlayer.Message(MessageHud.MessageType.Center, "Dumped Dragon/Drake/Fader + Nokkel debug info to console!");
}
}