From e8a0bff0a6eb30e88953494e7ae91c8b9bb27e34 Mon Sep 17 00:00:00 2001 From: Ferdinando Date: Fri, 7 Aug 2026 17:02:48 +0200 Subject: [PATCH] feat(furling): the five crops Co-Authored-By: Claude Opus 5 --- JotunnModStub/Furling/FurlingCrops.cs | 541 ++++++++++++++++++++++++ JotunnModStub/Furling/FurlingPatches.cs | 47 +- JotunnModStub/Furling/FurlingRace.cs | 19 +- 3 files changed, 589 insertions(+), 18 deletions(-) create mode 100644 JotunnModStub/Furling/FurlingCrops.cs diff --git a/JotunnModStub/Furling/FurlingCrops.cs b/JotunnModStub/Furling/FurlingCrops.cs new file mode 100644 index 0000000..75a7455 --- /dev/null +++ b/JotunnModStub/Furling/FurlingCrops.cs @@ -0,0 +1,541 @@ +using System.Collections.Generic; +using Jotunn.Configs; +using Jotunn.Entities; +using Jotunn.Managers; +using UnityEngine; + +namespace RacesOfValheim +{ + /// + /// The Furling's itemization: five things only a Fuling Shaman will sell, and the two chains + /// they open. + /// + /// Copper / Tin / Iron Flax -> plant, harvest, mill -> Copper / Tin / Iron Dust + /// -> smelt -> the metal itself + /// Stoneberry / Flintberry -> plant -> a bush that yields Stone / Flint + /// forever + /// + /// No new station: both `windmill` and `smelter` are components (the class + /// even carries an m_windmill field to drive the blades), so all six steps are appends to a + /// conversion list - the same trick AswidBloodPotions uses on the fermenter. Every vanilla + /// recipe in both machines keeps working. + /// + /// Two rules that came from the design conversation and are load-bearing: + /// - the FLAX travels through portals, the DUST does not. The dust copies the weight, stack + /// size and teleportability of the ore it becomes, so "behaves exactly like raw ore" is not + /// an approximation - it is read off that ore at registration. + /// - the flax yields what real flax yields and scales with the world modifiers the same way, + /// which is achieved by cloning Pickable_Flax and then NOT touching a single one of its + /// yield fields. See RegisterCrop. + /// + public static class FurlingCrops + { + // Prices are NOT here: they live with the rest of the shop data, in + // FactionMerchantCatalog.GoblinShamanShop. The benches are symmetric, so each figure there is + // both what the Shaman charges and what it pays. + + private class MetalCrop + { + public string Metal; // "Copper" - display only + public string FlaxName; + public string FlaxDisplay; + public string DustName; + public string DustDisplay; + public string PickableName; + public string SaplingName; + public string SaplingDisplay; + + /// + /// The vanilla raw ore this dust stands in for. Used for three things and never as an + /// output name: the dust's weight/stack/teleport flags, its borrowed icon, and looking up + /// what the vanilla smelter already turns that ore into. + /// + public string OrePrefab; + + public Color Tint; + + // Filled in during registration so the conversions can be wired from the objects we + // just built, rather than from ObjectDB - which has not been populated yet at + // CreateModAssets time. Same reason AswidBloodPotions passes GameObjects around. + public GameObject FlaxPrefab; + public GameObject DustPrefab; + } + + private static readonly MetalCrop[] Crops = + { + new MetalCrop + { + Metal = "Copper", FlaxName = "CopperFlax", FlaxDisplay = "Copper Flax", + DustName = "CopperDust", DustDisplay = "Copper Dust", + PickableName = "Pickable_CopperFlax", SaplingName = "sapling_copperflax", + SaplingDisplay = "Copper Flax", OrePrefab = "CopperOre", + Tint = new Color(0.72f, 0.45f, 0.20f, 1f), + }, + new MetalCrop + { + Metal = "Tin", FlaxName = "TinFlax", FlaxDisplay = "Tin Flax", + DustName = "TinDust", DustDisplay = "Tin Dust", + PickableName = "Pickable_TinFlax", SaplingName = "sapling_tinflax", + SaplingDisplay = "Tin Flax", OrePrefab = "TinOre", + Tint = new Color(0.80f, 0.82f, 0.85f, 1f), + }, + new MetalCrop + { + Metal = "Iron", FlaxName = "IronFlax", FlaxDisplay = "Iron Flax", + DustName = "IronDust", DustDisplay = "Iron Dust", + PickableName = "Pickable_IronFlax", SaplingName = "sapling_ironflax", + // Iron's raw form is IronScrap, not "IronOre" - there is no IronOre prefab. + SaplingDisplay = "Iron Flax", OrePrefab = "IronScrap", + Tint = new Color(0.35f, 0.36f, 0.38f, 1f), + }, + }; + + private class RockBerry + { + public string BerryName; + public string BerryDisplay; + public string BushName; // the cultivator entry AND the bush - one prefab + public string BushDisplay; + public string YieldPrefab; // what the bush gives instead of fruit + public Color Tint; + } + + private static readonly RockBerry[] Berries = + { + new RockBerry + { + BerryName = "Stoneberry", BerryDisplay = "Stoneberry", + BushName = "StoneberryBush", BushDisplay = "Stoneberry Bush", + YieldPrefab = "Stone", Tint = new Color(0.55f, 0.55f, 0.55f, 1f), + }, + new RockBerry + { + BerryName = "Flintberry", BerryDisplay = "Flintberry", + BushName = "FlintberryBush", BushDisplay = "Flintberry Bush", + YieldPrefab = "Flint", Tint = new Color(0.30f, 0.32f, 0.35f, 1f), + }, + }; + + public static void Register() + { + foreach (MetalCrop crop in Crops) RegisterCrop(crop); + foreach (RockBerry berry in Berries) RegisterBerry(berry); + AddConversions(); + } + + // ---------------------------------------------------------------- metal flax + + private static void RegisterCrop(MetalCrop crop) + { + crop.FlaxPrefab = BuildFlax(crop); + crop.DustPrefab = BuildDust(crop); + + // Order matters: the sapling's Plant has to point at a pickable that already exists. + GameObject pickable = BuildGrownFlax(crop); + BuildSapling(crop, pickable); + } + + private static GameObject BuildFlax(MetalCrop crop) + { + GameObject prefab = PrefabManager.Instance.CreateClonedPrefab(crop.FlaxName, "Flax"); + if (prefab == null) + { + Jotunn.Logger.LogWarning($"[Furling] Could not clone Flax; {crop.FlaxDisplay} not registered."); + return null; + } + + Recolour(prefab, crop.Tint); + + ItemDrop drop = prefab.GetComponent(); + if (drop == null) return null; + + ItemDrop.ItemData.SharedData shared = drop.m_itemData.m_shared; + shared.m_name = crop.FlaxDisplay; + shared.m_description = $"Flax grown in {crop.Metal.ToLowerInvariant()}-poisoned soil, and it took. " + + "Useless as cloth. Grind it and see."; + + // Teleportable is inherited from Flax and left alone on purpose: the flax travels, the + // dust does not. That asymmetry is the whole point of the chain. + + ItemManager.Instance.AddItem(new CustomItem(prefab, fixReference: false)); + return prefab; + } + + private static GameObject BuildDust(MetalCrop crop) + { + GameObject prefab = PrefabManager.Instance.CreateClonedPrefab(crop.DustName, "BarleyFlour"); + if (prefab == null) + { + Jotunn.Logger.LogWarning($"[Furling] Could not clone BarleyFlour; {crop.DustDisplay} not registered."); + return null; + } + + Recolour(prefab, crop.Tint); + + ItemDrop drop = prefab.GetComponent(); + if (drop == null) return null; + + ItemDrop.ItemData.SharedData shared = drop.m_itemData.m_shared; + shared.m_name = crop.DustDisplay; + shared.m_description = $"A sack of {crop.Metal.ToLowerInvariant()} ground fine. " + + "A furnace cannot tell it from ore, and it will not go through a portal either."; + shared.m_itemType = ItemDrop.ItemData.ItemType.Material; + shared.m_food = 0f; + shared.m_foodStamina = 0f; + shared.m_foodEitr = 0f; + shared.m_consumeStatusEffect = null; + + // "Behaves exactly like raw ore of that type", read off the ore instead of invented: + // its weight, its stack size, and - the one that matters - its refusal to teleport. + ItemDrop.ItemData.SharedData ore = SharedOf(crop.OrePrefab); + if (ore != null) + { + shared.m_weight = ore.m_weight; + shared.m_maxStackSize = ore.m_maxStackSize; + shared.m_teleportable = ore.m_teleportable; + } + else + { + Jotunn.Logger.LogWarning($"[Furling] No '{crop.OrePrefab}' to copy ore behaviour from; " + + $"{crop.DustDisplay} falls back to blocking teleport only."); + shared.m_teleportable = false; + } + + // The tint reaches the sack model but never the inventory icon - icons are atlas sprites + // and repainting one produces an empty slot, learned the hard way on the Aswid's Blood + // Essence. Three identical flour sacks in the inventory would be unusable, so the dusts + // borrow their ore's icon: it reads as "this is copper" at a glance, at the cost of not + // looking like flour. + Sprite icon = BorrowIcon(crop.OrePrefab); + if (icon != null) shared.m_icons = new[] { icon }; + + ItemManager.Instance.AddItem(new CustomItem(prefab, fixReference: false)); + return prefab; + } + + /// + /// The harvestable stage. Cloned from Pickable_Flax and then deliberately left alone except + /// for what it drops: m_amount, m_minAmountScaled, m_dontScale and m_respawnTimeMinutes all + /// come across untouched, which is exactly how "yields what a real flax plant yields and + /// reacts to the world modifiers like a real plant" is satisfied. Writing our own numbers + /// here is the one thing that would break that. + /// + /// Not a piece and not in any table - it only ever exists as the Plant's grown prefab - so it + /// is registered straight into ZNetScene with AddPrefab. That call is the thing to check in + /// the log on the first run: without it the sapling would grow into nothing. + /// + private static GameObject BuildGrownFlax(MetalCrop crop) + { + GameObject prefab = PrefabManager.Instance.CreateClonedPrefab(crop.PickableName, "Pickable_Flax"); + if (prefab == null) + { + Jotunn.Logger.LogWarning($"[Furling] Could not clone Pickable_Flax; grown {crop.FlaxDisplay} not registered."); + return null; + } + + Recolour(prefab, crop.Tint); + + Pickable pickable = prefab.GetComponent(); + if (pickable == null) + { + Jotunn.Logger.LogWarning($"[Furling] {crop.PickableName} has no Pickable; it will drop nothing."); + } + else if (crop.FlaxPrefab != null) + { + pickable.m_itemPrefab = crop.FlaxPrefab; + pickable.m_overrideName = crop.FlaxDisplay; + } + + PrefabManager.Instance.AddPrefab(prefab); + return prefab; + } + + private static void BuildSapling(MetalCrop crop, GameObject grown) + { + GameObject prefab = PrefabManager.Instance.CreateClonedPrefab(crop.SaplingName, "sapling_flax"); + if (prefab == null) + { + Jotunn.Logger.LogWarning($"[Furling] Could not clone sapling_flax; {crop.SaplingDisplay} not plantable."); + return; + } + + Recolour(prefab, crop.Tint); + + Plant plant = prefab.GetComponent(); + if (plant != null && grown != null) + { + plant.m_grownPrefabs = new[] { grown }; + plant.m_name = crop.SaplingDisplay; + // m_growTime, m_biome, m_needCultivatedGround and the rest stay as real flax's: the + // special strains are still flax, still Plains, still want tilled ground. + } + + Piece piece = prefab.GetComponent(); + if (piece != null) + { + piece.m_name = crop.SaplingDisplay; + piece.m_resources = new Piece.Requirement[0]; + } + + PieceManager.Instance.AddPiece(new CustomPiece(prefab, fixReference: false, new PieceConfig + { + Name = crop.SaplingDisplay, + Description = $"Plant it and it grows more {crop.FlaxDisplay}.", + PieceTable = PieceTables.Cultivator, + Requirements = new[] { new RequirementConfig(crop.FlaxName, 1, 0, true) }, + })); + } + + // ---------------------------------------------------------------- rock berries + + private static void RegisterBerry(RockBerry berry) + { + BuildBerry(berry); + BuildBush(berry); + } + + private static GameObject BuildBerry(RockBerry berry) + { + GameObject prefab = PrefabManager.Instance.CreateClonedPrefab(berry.BerryName, "Cloudberry"); + if (prefab == null) + { + Jotunn.Logger.LogWarning($"[Furling] Could not clone Cloudberry; {berry.BerryDisplay} not registered."); + return null; + } + + Recolour(prefab, berry.Tint); + + ItemDrop drop = prefab.GetComponent(); + if (drop == null) return null; + + ItemDrop.ItemData.SharedData shared = drop.m_itemData.m_shared; + shared.m_name = berry.BerryDisplay; + shared.m_description = $"Not a berry, whatever it looks like. Bury one and a {berry.YieldPrefab.ToLowerInvariant()}-bearing bush comes up."; + + // Inedible, as designed. Material with every food value at zero also keeps it clear of + // the Trenta's vegan check and of the Aswid/Skeleton food gates, all three of which only + // look at consumables that carry food values. + shared.m_itemType = ItemDrop.ItemData.ItemType.Material; + shared.m_food = 0f; + shared.m_foodStamina = 0f; + shared.m_foodEitr = 0f; + shared.m_foodBurnTime = 0f; + shared.m_foodRegen = 0f; + shared.m_consumeStatusEffect = null; + + ItemManager.Instance.AddItem(new CustomItem(prefab, fixReference: false)); + return prefab; + } + + /// + /// The bush: one prefab, cloned from CloudberryBush and nothing else. It is already a Pickable + /// that regrows its fruit on a timer forever, so "once planted they regrow forever, exactly + /// like normal plants" needs nothing added - only the fruit swapped for Stone or Flint. The + /// respawn timer, the amount and the world-modifier scaling all come across untouched, the + /// same way the flax's do. + /// + /// There is no growth stage and no second prefab. The first version of this did the same and + /// showed up in the cultivator as a blank square; the fix for that is the two lines marked + /// below, not a different base prefab. An attempt in between cloned sapling_flax for the + /// plantable stage, which did produce a working button - and put a grey flax sprout in the + /// middle of a chain that is supposed to be cloudberry all the way down. Reverted. + /// + private static void BuildBush(RockBerry berry) + { + GameObject prefab = PrefabManager.Instance.CreateClonedPrefab(berry.BushName, "CloudberryBush"); + if (prefab == null) + { + Jotunn.Logger.LogWarning($"[Furling] Could not clone CloudberryBush; {berry.BushDisplay} not registered."); + return; + } + + Recolour(prefab, berry.Tint); + + Pickable pickable = prefab.GetComponent(); + GameObject yield = PrefabManager.Cache.GetPrefab(berry.YieldPrefab); + if (pickable == null || yield == null) + { + Jotunn.Logger.LogWarning($"[Furling] {berry.BushName}: no Pickable or no '{berry.YieldPrefab}'; it will drop nothing."); + } + else + { + pickable.m_itemPrefab = yield; + pickable.m_overrideName = berry.BushDisplay; + } + + // CloudberryBush is world scenery, so it carries no Piece and cannot be built. Adding one + // is what puts it in the cultivator, and the two things a Piece added this way is missing + // are an icon - the sprite the build menu draws, whose absence is why the entry was there + // but invisible - and a placement effect. Both are supplied below. + Piece piece = prefab.GetComponent() ?? prefab.AddComponent(); + piece.m_name = berry.BushDisplay; + piece.m_craftingStation = null; + piece.m_resources = new Piece.Requirement[0]; + piece.m_canBeRemoved = true; + piece.m_groundPiece = true; + piece.m_groundOnly = true; + piece.m_cultivatedGroundOnly = false; // a bush of rocks does not want tilled soil + piece.m_icon = BorrowIcon(berry.YieldPrefab); + + // Borrowed from a real cultivator entry so planting one looks and sounds like planting + // anything else. Only the effect list is taken - never the model, never the Plant. + Piece template = PrefabManager.Cache.GetPrefab("sapling_flax"); + if (template != null && template.m_placeEffect != null) piece.m_placeEffect = template.m_placeEffect; + + PieceManager.Instance.AddPiece(new CustomPiece(prefab, fixReference: false, new PieceConfig + { + Name = berry.BushDisplay, + Description = $"Yields {berry.YieldPrefab.ToLowerInvariant()}, and keeps yielding it.", + PieceTable = PieceTables.Cultivator, + // The one thing that was actually missing the first time round. + Icon = BorrowIcon(berry.YieldPrefab), + Requirements = new[] { new RequirementConfig(berry.BerryName, 1, 0, true) }, + })); + } + + // ---------------------------------------------------------------- conversions + + /// + /// Six appends, three to the windmill and three to the smelter. Both are Smelter components, + /// so this is the same shape as AswidBloodPotions.AddFermenterConversion, and for the same + /// reason: the vanilla list is appended to, never replaced, so barley still becomes flour and + /// ore still becomes metal. + /// + private static void AddConversions() + { + Smelter mill = SmelterOn("windmill"); + Smelter furnace = SmelterOn("smelter"); + + foreach (MetalCrop crop in Crops) + { + ItemDrop flax = DropOf(crop.FlaxPrefab); + ItemDrop dust = DropOf(crop.DustPrefab); + if (flax == null || dust == null) continue; + + AddConversion(mill, "windmill", flax, dust); + + // The output is never named: whatever the vanilla furnace already makes from this + // ore is what the dust makes too. That is also the answer to "is the bar called + // Copper or CopperIngot" - it does not matter, because it is copied, not typed. + ItemDrop metal = OutputFor(furnace, crop.OrePrefab); + if (metal == null) + { + Jotunn.Logger.LogWarning($"[Furling] The smelter has no conversion from '{crop.OrePrefab}'; " + + $"{crop.DustDisplay} cannot be smelted."); + continue; + } + + AddConversion(furnace, "smelter", dust, metal); + } + } + + private static Smelter SmelterOn(string piecePrefabName) + { + GameObject prefab = PrefabManager.Cache.GetPrefab(piecePrefabName); + Smelter smelter = prefab != null ? prefab.GetComponent() : null; + if (smelter == null) + { + Jotunn.Logger.LogWarning($"[Furling] No Smelter on '{piecePrefabName}'; its half of the chain is dead."); + } + return smelter; + } + + /// What the machine already turns the named input into, or null. + private static ItemDrop OutputFor(Smelter smelter, string fromPrefabName) + { + if (smelter == null || smelter.m_conversion == null) return null; + + foreach (Smelter.ItemConversion conversion in smelter.m_conversion) + { + if (conversion == null || conversion.m_from == null || conversion.m_to == null) continue; + if (conversion.m_from.gameObject.name == fromPrefabName) return conversion.m_to; + } + return null; + } + + private static void AddConversion(Smelter smelter, string label, ItemDrop from, ItemDrop to) + { + if (smelter == null || from == null || to == null) return; + if (smelter.m_conversion == null) smelter.m_conversion = new List(); + + foreach (Smelter.ItemConversion existing in smelter.m_conversion) + { + if (existing != null && existing.m_from == from) return; // already taught + } + + smelter.m_conversion.Add(new Smelter.ItemConversion { m_from = from, m_to = to }); + Jotunn.Logger.LogInfo($"[Furling] {label}: {from.m_itemData.m_shared.m_name} -> {to.m_itemData.m_shared.m_name}."); + } + + // ---------------------------------------------------------------- known recipes + + /// + /// Teaches the five new cultivator entries, the same way RaceMenuWard, the Blood Refinery and + /// the Composter all had to be taught: a piece registered after the vanilla learning pass + /// never reaches its table on its own. The purchased item is still the real gate - the entry + /// just sits greyed out until one is owned. + /// + public static void EnsureKnown(Player player) + { + if (player == null) return; + + HarmonyLib.Traverse traverse = HarmonyLib.Traverse.Create(player); + bool taught = false; + + foreach (MetalCrop crop in Crops) taught |= Teach(traverse, crop.SaplingName); + foreach (RockBerry berry in Berries) taught |= Teach(traverse, berry.BushName); + + if (taught) traverse.Method("UpdateAvailablePiecesList").GetValue(); + } + + private static bool Teach(HarmonyLib.Traverse traverse, string piecePrefabName) + { + GameObject prefab = PrefabManager.Instance.GetPrefab(piecePrefabName); + Piece piece = prefab != null ? prefab.GetComponent() : null; + if (piece == null) return false; + + traverse.Method("AddKnownPiece", piece).GetValue(); + return true; + } + + // ---------------------------------------------------------------- helpers + + private static ItemDrop DropOf(GameObject prefab) => prefab != null ? prefab.GetComponent() : null; + + private static ItemDrop.ItemData.SharedData SharedOf(string prefabName) + { + ItemDrop drop = PrefabManager.Cache.GetPrefab(prefabName); + return drop != null && drop.m_itemData != null ? drop.m_itemData.m_shared : null; + } + + private static Sprite BorrowIcon(string prefabName) + { + ItemDrop.ItemData.SharedData shared = SharedOf(prefabName); + Sprite[] icons = shared != null ? shared.m_icons : null; + if (icons != null && icons.Length > 0 && icons[0] != null) return icons[0]; + + Jotunn.Logger.LogWarning($"[Furling] Could not borrow the icon from '{prefabName}'."); + return null; + } + + /// + /// renderer.materials instantiates a copy, so real flax, real flour, real cloudberries and + /// the real cloudberry bushes of the world all keep their own look. Particle renderers are + /// skipped - painting them just turns the effect into soot. + /// + 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); + } + } + } + } +} diff --git a/JotunnModStub/Furling/FurlingPatches.cs b/JotunnModStub/Furling/FurlingPatches.cs index c4c0ed8..3588c9d 100644 --- a/JotunnModStub/Furling/FurlingPatches.cs +++ b/JotunnModStub/Furling/FurlingPatches.cs @@ -46,6 +46,30 @@ namespace RacesOfValheim } } + /// + /// The Furling's truce with the Plains. Every name here is the game's actual internal prefab + /// id, checked against the shipped asset manifest one at a time, because the display names do + /// not predict them at all - this is the family where "Fuling" is the word the game shows the + /// player and "Goblin" is the word the game uses in code. + /// + /// The full roster under Assets/Characters, so nothing is missed by accident: + /// Goblin ............... Fuling (NOT "Fuling" - that prefab does not exist) + /// GoblinArcher ......... Fuling Archer (was missing entirely) + /// GoblinBrute .......... Fuling Berserker + /// GoblinShaman ......... Fuling Shaman + /// GoblinKing ........... Yagluth - a boss, stays hostile + /// GoblinBruteBros, GoblinBrute_Hildir, GoblinShaman_Hildir (+ _nochest variants) + /// Hildir's quest bosses - arena fights, they stay hostile too + /// The old code checked for "goblinking" inside a branch it could never reach, which is a + /// good sign the list was written from the display names rather than from the assets. + /// + private static readonly System.Collections.Generic.HashSet FurlingFriends = + new System.Collections.Generic.HashSet + { + "Goblin", "GoblinArcher", "GoblinBrute", "GoblinShaman", + "Lox", "Deathsquito", "Troll", + }; + [HarmonyPatch(typeof(BaseAI), "IsEnemy", typeof(Character), typeof(Character))] public static class Furling_BaseAI_IsEnemy_Patch { @@ -59,23 +83,12 @@ namespace RacesOfValheim if (a == playerChar) otherChar = b; else if (b == playerChar) otherChar = a; - if (otherChar != null) - { - string name = otherChar.gameObject.name.Replace("(Clone)", "").ToLower(); - if (name == "goblin" || - name == "goblinbrute" || - name == "goblinshaman" || - name == "lox" || - name == "deathsquito" || - name == "troll") - { - // Exclude minibosses/bosses explicitly if needed, but normally bosses are handled separately (Yagluth is GoblinKing). - if (name != "goblinking") - { - __result = false; - } - } - } + if (otherChar == null) return; + + // Trimmed as well as stripped: a stray "(Clone)" leaves a trailing space behind, and + // an exact-match set is unforgiving about it in a way the old ToLower chain also was. + string name = otherChar.gameObject.name.Replace("(Clone)", "").Trim(); + if (FurlingFriends.Contains(name)) __result = false; } } diff --git a/JotunnModStub/Furling/FurlingRace.cs b/JotunnModStub/Furling/FurlingRace.cs index 80939ad..bf33e7e 100644 --- a/JotunnModStub/Furling/FurlingRace.cs +++ b/JotunnModStub/Furling/FurlingRace.cs @@ -22,15 +22,32 @@ namespace RacesOfValheim } } + /// + /// Reads the race the same way every other race in the mod reads it. + /// + /// This used to be `GetPlayerModel() == 5`, with a comment admitting the 5 was assumed. + /// GetPlayerModel returns the character's BODY MODEL index - 0 or 1, male or female, the + /// thing PlayerCustomizaton.SetPlayerModel writes - and has nothing to do with the race, + /// which SelectFurling stores in m_customData["Race"]. So it never returned true, and + /// everything gated behind it was dead code: the -19% visual scale, the +10% run speed, the + /// truce with the Fuling camps, and Through Fire and Flames. + /// public static bool IsFurling() { - return Player.m_localPlayer != null && Player.m_localPlayer.GetPlayerModel() == 5; // Assumed ID for Furling + return Player.m_localPlayer != null && + Player.m_localPlayer.m_customData.ContainsKey("Race") && + Player.m_localPlayer.m_customData["Race"] == "Furling"; } public void CreateModAssets() { Jotunn.Logger.LogInfo("Initializing Furling Race..."); FurlingStatusEffects.RegisterStatusEffects(); + + // The metal flax and the rock berries. Registered here because the faction merchant + // catalogue resolves its entries by prefab name, so the five items have to exist before + // a Shaman is ever set up as a bench. + FurlingCrops.Register(); } private void Update()