From fae82162beed7cd81e0a126729c4f17f156f42ab Mon Sep 17 00:00:00 2001 From: Ferdinando Date: Fri, 7 Aug 2026 17:02:34 +0200 Subject: [PATCH] feat(aswid): blood refinery and blood potions Co-Authored-By: Claude Opus 5 --- JotunnModStub/Aswid/AswidBloodPotions.cs | 298 +++++++++ JotunnModStub/Aswid/AswidBloodRefinery.cs | 573 ++++++++++++++++++ JotunnModStub/Aswid/AswidPatches.cs | 4 +- JotunnModStub/Aswid/AswidRace.cs | 18 +- JotunnModStub/Aswid/BloodRefineryBehaviour.cs | 299 +++++++++ 5 files changed, 1185 insertions(+), 7 deletions(-) create mode 100644 JotunnModStub/Aswid/AswidBloodPotions.cs create mode 100644 JotunnModStub/Aswid/AswidBloodRefinery.cs create mode 100644 JotunnModStub/Aswid/BloodRefineryBehaviour.cs diff --git a/JotunnModStub/Aswid/AswidBloodPotions.cs b/JotunnModStub/Aswid/AswidBloodPotions.cs new file mode 100644 index 0000000..5e7e10f --- /dev/null +++ b/JotunnModStub/Aswid/AswidBloodPotions.cs @@ -0,0 +1,298 @@ +using System.Collections; +using HarmonyLib; +using Jotunn.Configs; +using Jotunn.Entities; +using Jotunn.Managers; +using UnityEngine; + +namespace RacesOfValheim +{ + /// + /// The second step of the refinement chain, brewed at the Mead Ketill: + /// + /// 5 Blood Essence -> 1 Superior Blood Essence + /// 3 Blood Essence + 5 Blueberries + /// + 5 Yellow Mushrooms -> Blood Potion mead base + /// 3 Superior Blood Essence + 5 Sap + /// + 5 Cloudberry -> Superior Blood Potion mead base + /// + /// Either base then goes into a Fermenter and comes out as five bottles. Drinking one force + /// feeds every food slot with the matching essence - full stomachs and all - and heals a + /// percentage of maximum health over eight seconds. + /// + public static class AswidBloodPotions + { + public const string BaseName = "MeadBaseBloodPotion"; + public const string PotionName = "MeadBloodPotion"; + public const string SuperiorBaseName = "MeadBaseSuperiorBloodPotion"; + public const string SuperiorPotionName = "MeadSuperiorBloodPotion"; + + private const string PotionDisplayName = "Blood Potion"; + private const string SuperiorPotionDisplayName = "Superior Blood Potion"; + + private const float HealDuration = 8f; + private const float HealFraction = 0.05f; + private const float SuperiorHealFraction = 0.10f; + + // Five bottles per barrel, as designed. + private const int BottlesPerBrew = 5; + + /// + /// Blood brews are done in a quarter of the normal time. The fermenter keeps a single + /// duration for every recipe, so instead of shortening it - which would speed up every + /// vanilla mead in the barrel - the elapsed time is multiplied while our base is inside. + /// + public const double FermentSpeedMultiplier = 4.0; + + private static readonly System.Reflection.MethodInfo GetContentMethod = + AccessTools.Method(typeof(Fermenter), "GetContent"); + + public static void Register() + { + SE_BloodPotion drink = CreateEffect("SE_BloodPotion", PotionDisplayName, HealFraction, + AswidBloodRefinery.EssenceName, "GemstoneRed"); + SE_BloodPotion superiorDrink = CreateEffect("SE_SuperiorBloodPotion", SuperiorPotionDisplayName, + SuperiorHealFraction, AswidBloodRefinery.SuperiorEssenceName, "MoltenCore"); + + GameObject meadBase = CloneItem(BaseName, "MeadBaseHealthMinor", "Blood Potion Mead Base", + "Blood, berries and crypt light, waiting on a barrel."); + GameObject potion = CloneItem(PotionName, "MeadHealthMinor", PotionDisplayName, + "Drink and the hunger stops mattering for a while. Fills every stomach with blood essence, " + + "full or not, and knits the flesh back together."); + GameObject superiorBase = CloneItem(SuperiorBaseName, "MeadBaseHealthMedium", "Superior Blood Potion Mead Base", + "The twice-rendered draught, still raw."); + GameObject superiorPotion = CloneItem(SuperiorPotionName, "MeadHealthMedium", SuperiorPotionDisplayName, + "The same mercy, twice as deep."); + + AttachEffect(potion, drink); + AttachEffect(superiorPotion, superiorDrink); + + AddRecipe(AswidBloodRefinery.SuperiorEssenceName, new[] + { + new RequirementConfig(AswidBloodRefinery.EssenceName, 5), + }); + + AddRecipe(BaseName, new[] + { + new RequirementConfig(AswidBloodRefinery.EssenceName, 3), + new RequirementConfig("Blueberries", 5), + // "Funghi luminosi": the Yellow Mushroom, the one that glows in the burial + // chambers. Same tier as the blueberries, unlike the Mistlands blue one. + new RequirementConfig("MushroomYellow", 5), + }); + + AddRecipe(SuperiorBaseName, new[] + { + new RequirementConfig(AswidBloodRefinery.SuperiorEssenceName, 3), + new RequirementConfig("Sap", 5), + new RequirementConfig("Cloudberry", 5), + }); + + AddFermenterConversion(meadBase, potion); + AddFermenterConversion(superiorBase, superiorPotion); + } + + // ---------------------------------------------------------------- items + + private static GameObject CloneItem(string prefabName, string source, string displayName, string description) + { + GameObject prefab = PrefabManager.Instance.CreateClonedPrefab(prefabName, source); + if (prefab == null) + { + Jotunn.Logger.LogWarning($"[Aswid] Could not clone '{source}'; {displayName} not registered."); + return null; + } + + ItemDrop drop = prefab.GetComponent(); + if (drop == null) return null; + + ItemDrop.ItemData.SharedData shared = drop.m_itemData.m_shared; + shared.m_name = displayName; + shared.m_description = description; + // The clone arrives carrying the vanilla health mead's own effect; ours is attached + // afterwards, and the mead bases must carry none at all. + shared.m_consumeStatusEffect = null; + + ItemManager.Instance.AddItem(new CustomItem(prefab, fixReference: false)); + return prefab; + } + + private static void AttachEffect(GameObject potion, SE_BloodPotion effect) + { + ItemDrop drop = potion != null ? potion.GetComponent() : null; + if (drop == null || effect == null) return; + drop.m_itemData.m_shared.m_consumeStatusEffect = effect; + } + + private static void AddRecipe(string item, RequirementConfig[] requirements) + { + ItemManager.Instance.AddRecipe(new CustomRecipe(new RecipeConfig + { + Item = item, + Amount = 1, + CraftingStation = CraftingStations.MeadKetill, + Requirements = requirements, + })); + } + + /// + /// Teaches the vanilla fermenter one more brew. The vanilla prefab's conversion list is + /// appended to rather than replaced, so every stock mead still works. + /// + private static void AddFermenterConversion(GameObject from, GameObject to) + { + if (from == null || to == null) return; + + GameObject barrel = PrefabManager.Cache.GetPrefab("fermenter"); + Fermenter fermenter = barrel != null ? barrel.GetComponent() : null; + if (fermenter == null) + { + Jotunn.Logger.LogWarning("[Aswid] No fermenter prefab; blood potions cannot be brewed."); + return; + } + + ItemDrop fromDrop = from.GetComponent(); + ItemDrop toDrop = to.GetComponent(); + if (fromDrop == null || toDrop == null) return; + + foreach (Fermenter.ItemConversion existing in fermenter.m_conversion) + { + if (existing != null && existing.m_from == fromDrop) return; // already taught + } + + fermenter.m_conversion.Add(new Fermenter.ItemConversion + { + m_from = fromDrop, + m_to = toDrop, + m_producedItems = BottlesPerBrew, + }); + } + + // ---------------------------------------------------------------- status effect + + private static SE_BloodPotion CreateEffect(string name, string displayName, float fraction, + string essencePrefab, string iconSource) + { + SE_BloodPotion effect = ScriptableObject.CreateInstance(); + effect.name = name; + effect.m_name = displayName; + effect.m_tooltip = $"Stomachs filled with blood. Healing {Mathf.RoundToInt(fraction * 100f)}% over {HealDuration:0} seconds."; + effect.m_ttl = HealDuration; + effect.m_healFraction = fraction; + effect.m_essencePrefab = essencePrefab; + + // A flat m_healthOverTime cannot express "5% of maximum health", so the real number is + // computed per drinker in SE_BloodPotion.Setup. One tick a second over the eight. + effect.m_healthOverTimeDuration = HealDuration; + effect.m_healthOverTimeInterval = 1f; + + ItemDrop source = PrefabManager.Cache.GetPrefab(iconSource); + Sprite[] icons = source != null && source.m_itemData != null && source.m_itemData.m_shared != null + ? source.m_itemData.m_shared.m_icons + : null; + if (icons != null && icons.Length > 0) effect.m_icon = icons[0]; + + ItemManager.Instance.AddStatusEffect(new CustomStatusEffect(effect, fixReference: false)); + return effect; + } + + /// + /// Force feeds every food slot with the given essence, ignoring whether the stomachs are + /// full - that refusal is the whole point of drinking the potion. The Aswid's fourth slot + /// is filled too once the progression has unlocked it. + /// + public static void FillStomachs(Player player, string essencePrefabName) + { + if (player == null || ObjectDB.instance == null) return; + + GameObject prefab = ObjectDB.instance.GetItemPrefab(essencePrefabName); + ItemDrop drop = prefab != null ? prefab.GetComponent() : null; + if (drop == null) return; + + Traverse traverse = Traverse.Create(player); + IList foods = traverse.Field("m_foods").GetValue(); + if (foods == null) return; + + foods.Clear(); + for (int slot = 0; slot < 3; slot++) + { + foods.Add(MakeFood(drop, prefab, essencePrefabName)); + } + + if (AswidRace.IsAswid() && BossProgressionManager.GetCurrentProgressionState() >= 8) + { + ItemDrop.ItemData item = drop.m_itemData.Clone(); + item.m_dropPrefab = prefab; + AswidFoodManager.SetExtraFood(player, item); + } + + traverse.Method("UpdateFood", 0f, true).GetValue(); + } + + /// True while one of our two mead bases is the thing fermenting in that barrel. + public static bool IsBloodBrew(Fermenter fermenter) + { + if (fermenter == null || GetContentMethod == null) return false; + + string content = GetContentMethod.Invoke(fermenter, null) as string; + return content == BaseName || content == SuperiorBaseName; + } + + private static Player.Food MakeFood(ItemDrop drop, GameObject prefab, string prefabName) + { + ItemDrop.ItemData item = drop.m_itemData.Clone(); + // Vanilla reads m_dropPrefab.name when it rebuilds a food entry, and a cloned + // ItemData off a raw prefab does not carry it. + item.m_dropPrefab = prefab; + + return new Player.Food + { + m_name = prefabName, + m_item = item, + m_time = item.m_shared.m_foodBurnTime, + m_health = item.m_shared.m_food, + m_stamina = item.m_shared.m_foodStamina, + m_eitr = item.m_shared.m_foodEitr, + }; + } + } + + /// + /// Blood ferments fast. GetFermentationTime is the single place the barrel measures progress + /// from - GetStatus is its only caller - so scaling the elapsed time here makes the brew ready + /// at a quarter of the duration and keeps the hover text agreeing with it, without touching + /// m_fermentationDuration and dragging every vanilla mead along. + /// + [HarmonyPatch(typeof(Fermenter), "GetFermentationTime")] + public static class AswidBloodPotionFermentPatch + { + public static void Postfix(Fermenter __instance, ref double __result) + { + if (__result <= 0.0) return; + if (!AswidBloodPotions.IsBloodBrew(__instance)) return; + + __result *= AswidBloodPotions.FermentSpeedMultiplier; + } + } + + /// + /// The effect both potions apply. Heals a fraction of maximum health rather than a flat + /// amount, which SE_Stats cannot express on its own, and refills the drinker's food slots. + /// + public class SE_BloodPotion : SE_Stats + { + public float m_healFraction = 0.05f; + public string m_essencePrefab = ""; + + public override void Setup(Character character) + { + // SEMan clones the effect before setting it up, so writing the resolved amount here + // touches this drinker's copy only. + if (character != null) m_healthOverTime = character.GetMaxHealth() * m_healFraction; + + base.Setup(character); + + AswidBloodPotions.FillStomachs(character as Player, m_essencePrefab); + } + } +} diff --git a/JotunnModStub/Aswid/AswidBloodRefinery.cs b/JotunnModStub/Aswid/AswidBloodRefinery.cs new file mode 100644 index 0000000..1990b1e --- /dev/null +++ b/JotunnModStub/Aswid/AswidBloodRefinery.cs @@ -0,0 +1,573 @@ +using System.Collections.Generic; +using HarmonyLib; +using Jotunn.Configs; +using Jotunn.Entities; +using Jotunn.Managers; +using UnityEngine; + +namespace RacesOfValheim +{ + /// + /// The Aswid station: a half-size, blood-dark copy of the Eitr Refinery that eats raw flesh + /// and bone and produces Blood Essence, the base currency of the (future) Aswid potion tree. + /// + /// The whole chain is gated behind the Blood Core, an item sold by the Draugr faction + /// merchant, so the station cannot be reached without going through the Factions system. + /// + /// The vanilla refinery is a : a queue of "ore" names plus a single + /// fuel type, one product per queued item. That shape does not fit two numeric tanks fed by + /// many different items with different yields, so the Smelter component is stripped after its + /// scene references (switches, animators, output point, effect lists, state objects) are + /// handed over to . That is why the animation and the VFX + /// stay exactly the ones the vanilla refinery plays. + /// + public static class AswidBloodRefinery + { + public const string PieceName = "AswidBloodRefinery"; + public const string EssenceName = "BloodEssence"; + public const string SuperiorEssenceName = "SuperiorBloodEssence"; + public const string CoreName = "BloodCore"; + + // The Aswid food patches recognise a meal by its display name, so these strings are part + // of the contract with AswidPatches - see IsAswidMeal. + public const string EssenceDisplayName = "Blood Essence"; + public const string SuperiorEssenceDisplayName = "Superior Blood Essence"; + public const string CoreDisplayName = "Blood Core"; + public const string PieceDisplayName = "Blood Refinery"; + + // Regeneration is tied to the health value rather than set per tier, so 60 hp gives 5 and + // 80 hp gives 6.67 without a second number to keep in sync. + private const float RegenPerHealth = 12f; + + public static GameObject EssencePrefab { get; private set; } + public static GameObject SuperiorEssencePrefab { get; private set; } + + // Half size, as designed. Everything under the root scales with it. + private const float ModelScale = 0.5f; + + private static readonly Color BodyTint = new Color(0.13f, 0.07f, 0.07f, 1f); + private static readonly Color BodyEmission = new Color(0.20f, 0.01f, 0.01f, 1f); + private static readonly Color EssenceTint = new Color(0.62f, 0.03f, 0.04f, 1f); + private static readonly Color SuperiorEssenceTint = new Color(0.85f, 0.0f, 0.02f, 1f); + private static readonly Color EssenceEmission = new Color(0.16f, 0.0f, 0.0f, 1f); + + /// + /// Every bone in the game and what it is worth to the machine. Bones carry no food values + /// to derive a number from, unlike meat, so this table is explicit. Names verified against + /// the shipped asset manifest, not guessed; entries the running game does not have are + /// simply never matched. + /// + public static readonly Dictionary BoneValues = new Dictionary + { + { "BoneFragments", 1 }, // Swamp / skeletons, the common one + { "CharredBone", 2 }, // Ashlands + { "Charredskull", 3 }, // Ashlands + { "WitheredBone", 3 }, // Bonemass offering, still just a bone + { "AsksvinCarrionNeck", 2 }, // Ashlands asksvin carrion + { "AsksvinCarrionPelvic", 2 }, + { "AsksvinCarrionRibcage", 3 }, + { "AsksvinCarrionSkull", 3 }, + { "UndeadBjornRibcage", 3 }, // Deep North + }; + + // Vanilla grills. Anything they cook counts as raw flesh, which keeps modded meat working. + private static readonly string[] CookingStationPrefabs = + { + "piece_cookingstation", + "piece_cookingstation_iron", + }; + + private static Dictionary meatToCooked; + + public static void Register() + { + RegisterCore(); + RegisterEssence(); + RegisterPiece(); + AswidBloodPotions.Register(); + } + + /// + /// True for anything the Aswid is allowed to put in a food slot: the blood drained from a + /// mob, or refined Blood Essence. AswidPatches routes both through the same slot logic. + /// + public static bool IsAswidMeal(ItemDrop.ItemData item) + { + if (item == null || item.m_shared == null || item.m_shared.m_name == null) return false; + return item.m_shared.m_name.StartsWith("Aswid Food:") + || item.m_shared.m_name == EssenceDisplayName + || IsEssence(item); + } + + /// Either tier of refined blood - the things only an Aswid may swallow. + public static bool IsEssence(ItemDrop.ItemData item) + { + if (item == null || item.m_shared == null || item.m_shared.m_name == null) return false; + return item.m_shared.m_name == EssenceDisplayName || item.m_shared.m_name == SuperiorEssenceDisplayName; + } + + // ---------------------------------------------------------------- items + + private static void RegisterCore() + { + GameObject prefab = PrefabManager.Instance.CreateClonedPrefab(CoreName, "Bloodbag"); + if (prefab == null) + { + Jotunn.Logger.LogWarning("[Aswid] Could not clone Bloodbag; Blood Core not registered."); + return; + } + + ItemDrop drop = prefab.GetComponent(); + if (drop == null) return; + + ItemDrop.ItemData.SharedData shared = drop.m_itemData.m_shared; + shared.m_name = CoreDisplayName; + shared.m_description = "A knot of clotted blood kept beating by something that is not a heart. " + + "The dead trade them; only the dead know how they are made."; + shared.m_itemType = ItemDrop.ItemData.ItemType.Material; + shared.m_food = 0f; + shared.m_foodStamina = 0f; + shared.m_foodEitr = 0f; + shared.m_weight = 0.5f; + shared.m_maxStackSize = 20; + + Sprite icon = BorrowIcon("MorgenHeart"); + if (icon != null) shared.m_icons = new[] { icon }; + + ItemManager.Instance.AddItem(new CustomItem(prefab, fixReference: false)); + } + + private static void RegisterEssence() + { + EssencePrefab = BuildEssence( + EssenceName, + EssenceDisplayName, + "Blood rendered down to what it actually is. The only real food an Aswid can " + + "still chew, and the base of every draught worth brewing.", + food: 60f, + tint: EssenceTint, + iconSource: "GemstoneRed"); + + SuperiorEssencePrefab = BuildEssence( + SuperiorEssenceName, + SuperiorEssenceDisplayName, + "The same blood, rendered twice. Darker, thicker, and worth five of the first pass.", + food: 80f, + tint: SuperiorEssenceTint, + iconSource: "MoltenCore"); + } + + /// + /// Both essences are the same object with a different weight of red behind them. Stamina + /// and burn time are deliberately shared: only the health and the regeneration that scales + /// off it change between the two tiers. + /// + private static GameObject BuildEssence(string prefabName, string displayName, string description, + float food, Color tint, string iconSource) + { + GameObject prefab = PrefabManager.Instance.CreateClonedPrefab(prefabName, "Eitr"); + if (prefab == null) + { + Jotunn.Logger.LogWarning($"[Aswid] Could not clone Eitr; {displayName} not registered."); + return null; + } + + // Refined eitr carries a Radiator of its own plus a point light. The design calls for + // red spheres that emit no light and hurt nothing, so both go. + StripOffensive(prefab, prefabName); + StripGlow(prefab, prefabName); + Recolour(prefab, tint, EssenceEmission); + RedShiftEffects(prefab, tint); + + ItemDrop drop = prefab.GetComponent(); + if (drop == null) return null; + + ItemDrop.ItemData.SharedData shared = drop.m_itemData.m_shared; + shared.m_name = displayName; + shared.m_description = description; + shared.m_itemType = ItemDrop.ItemData.ItemType.Consumable; + shared.m_weight = 0.2f; + + // Top of the food ladder on purpose: it costs a station, a purchased Core, and a pile + // of corpses, and no other race can swallow it. + shared.m_food = food; + shared.m_foodStamina = 60f; + shared.m_foodEitr = 0f; + shared.m_foodBurnTime = 2400f; // 40 minutes + shared.m_foodRegen = food / RegenPerHealth; + shared.m_consumeStatusEffect = null; + + // Repainting the eitr sprite pixel by pixel produced an empty slot in the inventory + // (the icon atlas is not readable), so a vanilla red icon is borrowed instead. + Sprite icon = BorrowIcon(iconSource); + if (icon != null) shared.m_icons = new[] { icon }; + + ItemManager.Instance.AddItem(new CustomItem(prefab, fixReference: false)); + return prefab; + } + + // ---------------------------------------------------------------- piece + + private static void RegisterPiece() + { + GameObject prefab = PrefabManager.Instance.CreateClonedPrefab(PieceName, "eitrrefinery"); + if (prefab == null) + { + Jotunn.Logger.LogWarning("[Aswid] Could not clone eitrrefinery; Blood Refinery not registered."); + return; + } + + Smelter smelter = prefab.GetComponentInChildren(true); + if (smelter == null) + { + Jotunn.Logger.LogWarning("[Aswid] eitrrefinery clone has no Smelter; Blood Refinery not registered."); + return; + } + + BloodRefineryBehaviour refinery = smelter.gameObject.AddComponent(); + refinery.m_addMeatSwitch = smelter.m_addOreSwitch; // the soft tissue slot + refinery.m_addBoneSwitch = smelter.m_addWoodSwitch; // the sap slot + refinery.m_outputPoint = smelter.m_outputPoint; + refinery.m_enabledObject = smelter.m_enabledObject; + refinery.m_disabledObject = smelter.m_disabledObject; + refinery.m_haveBoneObject = smelter.m_haveFuelObject; + refinery.m_haveMeatObject = smelter.m_haveOreObject; + refinery.m_noMeatObject = smelter.m_noOreObject; + refinery.m_animators = smelter.m_animators; + refinery.m_meatAddedEffects = smelter.m_oreAddedEffects; + refinery.m_boneAddedEffects = smelter.m_fuelAddedEffects; + refinery.m_produceEffects = smelter.m_produceEffects; + refinery.m_smokeSpawner = smelter.m_smokeSpawner; + + Object.DestroyImmediate(smelter); + + // Two Radiators under _enabled are what shot the tester: see IsOffensive. + StripOffensive(prefab, PieceName); + SanitiseEffects(refinery.m_meatAddedEffects, PieceName + ".oreAdded"); + SanitiseEffects(refinery.m_boneAddedEffects, PieceName + ".fuelAdded"); + SanitiseEffects(refinery.m_produceEffects, PieceName + ".produce"); + + prefab.transform.localScale = Vector3.one * ModelScale; + Recolour(prefab, BodyTint, BodyEmission); + RedShiftEffects(prefab); + + Piece piece = prefab.GetComponent(); + if (piece != null) + { + // Same call as RaceMenuWard: a piece whose crafting station is out of range is + // hidden from the hammer entirely, and this one has to be findable. + piece.m_craftingStation = null; + piece.m_resources = new Piece.Requirement[0]; + piece.m_name = PieceDisplayName; + } + + PieceConfig config = new PieceConfig + { + Name = PieceDisplayName, + Description = "Flesh goes in, bone goes in, and what is left of both comes out red.", + PieceTable = PieceTables.Hammer, + Category = PieceCategories.Crafting, + Requirements = new[] + { + new RequirementConfig(CoreName, 1, 0, true), + new RequirementConfig("Stone", 20, 0, true), + new RequirementConfig("Bronze", 10, 0, true), + } + }; + + PieceManager.Instance.AddPiece(new CustomPiece(prefab, fixReference: false, config)); + } + + /// + /// A piece only shows up in the hammer once it is in the player's known recipes, and the + /// vanilla learning pass misses pieces injected after the fact - the same trap + /// RaceMenuWard fell into. The Blood Core requirement is the real gate; this only makes + /// the entry visible (greyed out until you own one). + /// + 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(); + } + + // ---------------------------------------------------------------- input values + + /// Units of blood a single piece of this item is worth, 0 if it is not flesh. + public static int BloodValue(string prefabName) + { + EnsureMeatMap(); + if (string.IsNullOrEmpty(prefabName) || !meatToCooked.TryGetValue(prefabName, out string cookedName)) return 0; + + // The yield is what the COOKED version would have given the eater: health plus + // stamina, so a lox steak is worth more than a neck tail without a second table. + ItemDrop.ItemData.SharedData source = SharedOf(cookedName) ?? SharedOf(prefabName); + if (source == null) return 1; + + int units = Mathf.CeilToInt((source.m_food + source.m_foodStamina) / 20f); + return Mathf.Max(1, units); + } + + /// + /// The same question BloodValue answers - "how much soft tissue is this piece of flesh + /// worth" - under a name that does not say "blood", for callers outside the Aswid. The + /// Trenta's Composter rots the same meat this refinery renders, so it asks here rather + /// than keeping a second table that would drift out of step with this one. + /// + public static int FleshValue(string prefabName) => BloodValue(prefabName); + + /// Units of bone a single piece of this item is worth, 0 if it is not a bone. + public static int BoneValue(string prefabName) + { + if (string.IsNullOrEmpty(prefabName)) return 0; + return BoneValues.TryGetValue(prefabName, out int units) ? units : 0; + } + + private static void EnsureMeatMap() + { + if (meatToCooked != null) return; + + // The raw -> cooked table the Draugh already maintains is the source of truth. + meatToCooked = new Dictionary(DraughFoodPatches.rawToCookedMapping); + meatToCooked.Remove("GreydwarfEye"); // stew ingredient, not flesh + meatToCooked["AsksvinMeat"] = "CookedAsksvinMeat"; + meatToCooked["BoneMawSerpentMeat"] = "CookedBoneMawSerpentMeat"; + + foreach (string stationName in CookingStationPrefabs) + { + GameObject station = PrefabManager.Cache.GetPrefab(stationName); + CookingStation cooking = station != null ? station.GetComponent() : null; + if (cooking == null || cooking.m_conversion == null) continue; + + foreach (CookingStation.ItemConversion conversion in cooking.m_conversion) + { + if (conversion == null || conversion.m_from == null || conversion.m_to == null) continue; + string from = conversion.m_from.gameObject.name; + if (!meatToCooked.ContainsKey(from)) meatToCooked[from] = conversion.m_to.gameObject.name; + } + } + } + + private static ItemDrop.ItemData.SharedData SharedOf(string prefabName) + { + GameObject prefab = ObjectDB.instance != null ? ObjectDB.instance.GetItemPrefab(prefabName) : null; + ItemDrop drop = prefab != null ? prefab.GetComponent() : null; + return drop != null ? drop.m_itemData.m_shared : null; + } + + // ---------------------------------------------------------------- prefab surgery + + /// + /// Removes anything on the prefab that can hurt somebody. Kept type-based rather than + /// name-based so a game update that renames a child object cannot quietly bring the + /// damage back. + /// + internal static void StripOffensive(GameObject root, string label) + { + foreach (MonoBehaviour behaviour in root.GetComponentsInChildren(true)) + { + if (behaviour == null || !IsOffensive(behaviour)) continue; + + Jotunn.Logger.LogInfo($"[Aswid] {label}: stripped {behaviour.GetType().Name} from '{behaviour.gameObject.name}'."); + Object.DestroyImmediate(behaviour); + } + } + + private static bool IsOffensive(MonoBehaviour behaviour) + { + // Radiator is the one that shoots. It is a plain MonoBehaviour holding a projectile + // prefab in a field and firing it every 2-5 seconds while its object is enabled, which + // is why neither an interface check nor a hierarchy scan for projectiles found it. The + // refinery carries two under _enabled (so only while it is running) and refined eitr + // carries one of its own - hence the 60 damage plus poison out of nowhere. + if (behaviour is Radiator) return true; + if (behaviour is IProjectile || behaviour is Aoe || behaviour is Turret) return true; + + // An EffectArea is usually harmless bookkeeping - PlayerBase marks the thing as part of + // a home, and stripping that was a mistake in the first pass. Only the burning kinds go. + EffectArea area = behaviour as EffectArea; + if (area == null) return false; + return (area.m_type & (EffectArea.Type.Heat | EffectArea.Type.Fire | EffectArea.Type.Burning)) != 0; + } + + private static bool IsOffensivePrefab(GameObject prefab) + { + if (prefab == null) return false; + if (prefab.name.ToLowerInvariant().Contains("radiation")) return true; + + foreach (MonoBehaviour behaviour in prefab.GetComponentsInChildren(true)) + { + if (behaviour != null && IsOffensive(behaviour)) return true; + } + return false; + } + + /// + /// Drops any effect the refinery plays that carries something damaging with it. Only the + /// list on our own clone is rebuilt - the referenced prefabs are the vanilla ones and are + /// never touched, so the real eitr refinery keeps working. + /// + private static void SanitiseEffects(EffectList list, string label) + { + if (list == null || list.m_effectPrefabs == null) return; + + List kept = new List(); + foreach (EffectList.EffectData data in list.m_effectPrefabs) + { + if (data == null || data.m_prefab == null) continue; + + if (IsOffensivePrefab(data.m_prefab)) + { + Jotunn.Logger.LogInfo($"[Aswid] {label}: dropped effect '{data.m_prefab.name}' (carries damage)."); + continue; + } + + Jotunn.Logger.LogInfo($"[Aswid] {label}: kept effect '{data.m_prefab.name}'."); + kept.Add(data); + } + list.m_effectPrefabs = kept.ToArray(); + } + + private static void StripGlow(GameObject root, string label) + { + // LightFlicker and LightLod both grab the Light in Awake without a null check, so + // deleting the Light on its own threw on every sphere the machine produced. They go + // first, and the light after. + foreach (LightFlicker flicker in root.GetComponentsInChildren(true)) + { + if (flicker != null) Object.DestroyImmediate(flicker); + } + foreach (LightLod lod in root.GetComponentsInChildren(true)) + { + if (lod != null) Object.DestroyImmediate(lod); + } + foreach (Light light in root.GetComponentsInChildren(true)) + { + if (light != null) Object.DestroyImmediate(light); + } + + foreach (Transform child in root.GetComponentsInChildren(true)) + { + if (child == null || child == root.transform) continue; + string name = child.gameObject.name.ToLowerInvariant(); + if (name.Contains("radiation") || name.Contains("gamma") || name.Contains("halo") || name.Contains("glow")) + { + Jotunn.Logger.LogInfo($"[Aswid] {label}: removed glow child '{child.gameObject.name}'."); + Object.DestroyImmediate(child.gameObject); + } + } + } + + /// + /// Turns the borrowed eitr VFX from purple to blood: particle tint and every remaining + /// light. The refinery keeps its lights - a running one should glow red - while the + /// essence spheres had theirs removed outright by StripGlow. + /// + private static void RedShiftEffects(GameObject root) + { + RedShiftEffects(root, EssenceTint); + } + + private static void RedShiftEffects(GameObject root, Color tint) + { + foreach (ParticleSystem particles in root.GetComponentsInChildren(true)) + { + if (particles == null) continue; + + ParticleSystem.MainModule main = particles.main; + main.startColor = new ParticleSystem.MinMaxGradient(tint); + } + + foreach (Light light in root.GetComponentsInChildren(true)) + { + if (light != null) light.color = tint; + } + } + + 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($"[Aswid] Could not borrow the icon from '{prefabName}'."); + return null; + } + + private static void Recolour(GameObject root, Color tint, Color emission) + { + foreach (Renderer renderer in root.GetComponentsInChildren(true)) + { + if (renderer == null) continue; + + // Particle renderers are handled by RedShiftEffects - painting flames and smoke + // with the dark body tint just turns the VFX into soot. + if (renderer is ParticleSystemRenderer) continue; + + // renderer.material instantiates a copy, so the vanilla refinery and the vanilla + // eitr keep their own look. + foreach (Material material in renderer.materials) + { + if (material == null) continue; + material.color = tint; + if (material.HasProperty("_Color")) material.SetColor("_Color", tint); + if (material.HasProperty("_EmissionColor")) material.SetColor("_EmissionColor", emission); + } + } + } + } + + /// + /// Teaches the piece on spawn, exactly like RaceMenuWard does, because a piece registered + /// after the vanilla learning pass never reaches the hammer on its own. + /// + [HarmonyPatch(typeof(Player), "OnSpawned")] + public static class AswidBloodRefineryKnownPatch + { + public static void Postfix(Player __instance) + { + if (__instance != Player.m_localPlayer) return; + AswidBloodRefinery.EnsureKnown(__instance); + } + } + + /// + /// Blood Essence is Aswid food. Anyone else who tries to swallow it gets nothing, the same + /// way the Draugh's human meat is refused to the living. + /// + [HarmonyPatch(typeof(Player), "CanConsumeItem")] + public static class AswidBloodEssenceGatePatch + { + public static void Postfix(Player __instance, ItemDrop.ItemData item, ref bool __result) + { + if (__instance != Player.m_localPlayer || item == null || item.m_shared == null) return; + if (!AswidBloodRefinery.IsEssence(item)) return; + if (AswidRace.IsAswid()) return; + + __result = false; + } + } + + [HarmonyPatch(typeof(Humanoid), "UseItem")] + public static class AswidBloodEssenceMessagePatch + { + public static bool Prefix(Humanoid __instance, ItemDrop.ItemData item) + { + Player player = __instance as Player; + if (player == null || player != Player.m_localPlayer || item == null || item.m_shared == null) return true; + if (!AswidBloodRefinery.IsEssence(item)) return true; + if (AswidRace.IsAswid()) return true; + + player.Message(MessageHud.MessageType.Center, "Living blood curdles in a living throat."); + return false; + } + } +} diff --git a/JotunnModStub/Aswid/AswidPatches.cs b/JotunnModStub/Aswid/AswidPatches.cs index e3f2724..c115515 100644 --- a/JotunnModStub/Aswid/AswidPatches.cs +++ b/JotunnModStub/Aswid/AswidPatches.cs @@ -285,7 +285,7 @@ namespace RacesOfValheim { public static void Postfix(Player __instance, ItemDrop.ItemData item, ref bool __result) { - if (__instance == Player.m_localPlayer && AswidRace.IsAswid() && item != null && item.m_shared != null && item.m_shared.m_name.StartsWith("Aswid Food:")) + if (__instance == Player.m_localPlayer && AswidRace.IsAswid() && AswidBloodRefinery.IsAswidMeal(item)) { var foods = HarmonyLib.Traverse.Create(__instance).Field("m_foods").GetValue(); if (foods != null) @@ -339,7 +339,7 @@ namespace RacesOfValheim public static bool Prefix(Player __instance, ItemDrop.ItemData item, ref bool __result) { hiddenFoods.Clear(); - if (__instance == Player.m_localPlayer && AswidRace.IsAswid() && item != null && item.m_shared != null && item.m_shared.m_name.StartsWith("Aswid Food:")) + if (__instance == Player.m_localPlayer && AswidRace.IsAswid() && AswidBloodRefinery.IsAswidMeal(item)) { var m_foods = HarmonyLib.Traverse.Create(__instance).Field("m_foods").GetValue(); if (m_foods != null) diff --git a/JotunnModStub/Aswid/AswidRace.cs b/JotunnModStub/Aswid/AswidRace.cs index a117fa9..93606cf 100644 --- a/JotunnModStub/Aswid/AswidRace.cs +++ b/JotunnModStub/Aswid/AswidRace.cs @@ -24,9 +24,13 @@ namespace RacesOfValheim { "Leech", "TrophyLeech" }, { "Hatchling", "TrophyHatchling" }, { "Lox", "TrophyLox" }, - { "Fuling", "TrophyGoblin" }, - { "FulingShaman", "TrophyGoblinShaman" }, - { "FulingBerserker", "TrophyGoblinBrute" }, + // The Fuling family is named Goblin* in code - "Fuling" is only ever the display name, + // and no prefab by that name exists. These three keys never matched anything, so the + // Aswid could not drain a Fuling of any kind. Verified against the asset manifest. + { "Goblin", "TrophyGoblin" }, + { "GoblinArcher", "TrophyGoblin" }, + { "GoblinShaman", "TrophyGoblinShaman" }, + { "GoblinBrute", "TrophyGoblinBrute" }, { "Deathsquito", "TrophyDeathsquito" }, { "Hare", "TrophyHare" }, { "Seeker", "TrophySeeker" }, @@ -35,7 +39,7 @@ namespace RacesOfValheim { "Gjall", "TrophyGjall" }, { "Tick", "TrophyTick" }, { "Ulv", "TrophyUlv" }, - { "Cultist", "TrophyCultist" }, + { "Fenring_Cultist", "TrophyCultist" }, // the prefab is Fenring_Cultist, not "Cultist" { "Asksvin", "TrophyAsksvin" }, { "Volture", "TrophyVolture" } }; @@ -84,6 +88,7 @@ namespace RacesOfValheim { AswidStatusEffects.RegisterStatusEffects(); CreateFoodItems(); + AswidBloodRefinery.Register(); GameObject geirrhafa = Jotunn.Managers.PrefabManager.Cache.GetPrefab("Fenring_Cultist_Hildir"); if (geirrhafa != null) @@ -137,7 +142,10 @@ namespace RacesOfValheim { float foodHp = Mathf.Min(c.m_health / 2f, 150f); float burnTime = c.m_health * 2f; - if (mobName == "Cultist" || mobName.StartsWith("Fenring") || mobName.StartsWith("Fuling")) + // StartsWith("Fenring") already covers Fenring_Cultist. "Fuling" was + // never a prefab prefix - the family is Goblin* - so that arm of the + // test matched nothing until now. + if (mobName.StartsWith("Fenring") || mobName.StartsWith("Goblin")) { burnTime = 1200f; // 20 minutes } diff --git a/JotunnModStub/Aswid/BloodRefineryBehaviour.cs b/JotunnModStub/Aswid/BloodRefineryBehaviour.cs new file mode 100644 index 0000000..f64e983 --- /dev/null +++ b/JotunnModStub/Aswid/BloodRefineryBehaviour.cs @@ -0,0 +1,299 @@ +using System; +using UnityEngine; + +namespace RacesOfValheim +{ + /// + /// The Blood Refinery's logic. Modelled on - same one-second tick, same + /// owner-only accounting with everything in the ZDO so it keeps working in multiplayer and + /// keeps ticking while the zone is unloaded - but with two numeric tanks instead of an ore + /// queue and a single fuel item. + /// + /// Raw flesh is destroyed on the spot and becomes blood; bone is destroyed on the spot and + /// becomes bone dust. When both tanks can pay, the machine refines a Blood Essence and spits + /// it out of the vanilla output point. It never deals damage - see AswidBloodRefinery for the + /// strip pass that guarantees that. + /// + public class BloodRefineryBehaviour : MonoBehaviour + { + // Wired up from the vanilla Smelter before it is destroyed, which is what keeps the + // animation and the VFX identical to the eitr refinery's. + public Switch m_addMeatSwitch; + public Switch m_addBoneSwitch; + public Transform m_outputPoint; + public GameObject m_enabledObject; + public GameObject m_disabledObject; + public GameObject m_haveMeatObject; + public GameObject m_haveBoneObject; + public GameObject m_noMeatObject; + public Animator[] m_animators; + public EffectList m_meatAddedEffects; + public EffectList m_boneAddedEffects; + public EffectList m_produceEffects; + public SmokeSpawner m_smokeSpawner; + + // Balance. Ten units of blood is roughly one cooked lox steak's worth. + public float m_maxBlood = 50f; + public float m_maxBone = 20f; + public float m_bloodPerEssence = 5f; + public float m_bonePerEssence = 2f; + public float m_secPerEssence = 20f; + + private const string KeyBlood = "RoV_blood"; + private const string KeyBone = "RoV_bone"; + private const string KeyTimer = "RoV_refineTimer"; + private const string KeyAccumulator = "RoV_accTime"; + private const string KeyStartTime = "RoV_startTime"; + + private ZNetView m_nview; + private bool m_blockedSmoke; + + private void Awake() + { + m_nview = GetComponent(); + if (m_nview == null) m_nview = GetComponentInParent(); + if (m_nview == null || m_nview.GetZDO() == null) return; + + if (m_addMeatSwitch != null) + { + m_addMeatSwitch.m_onUse = OnAddMeat; + m_addMeatSwitch.m_onHover = HoverMeat; + } + if (m_addBoneSwitch != null) + { + m_addBoneSwitch.m_onUse = OnAddBone; + m_addBoneSwitch.m_onHover = HoverBone; + } + + m_nview.Register("RoV_AddMeat", RPC_AddMeat); + m_nview.Register("RoV_AddBone", RPC_AddBone); + + WearNTear wear = GetComponent(); + if (wear == null) wear = GetComponentInParent(); + if (wear != null) wear.m_onDestroyed = (Action)Delegate.Combine(wear.m_onDestroyed, new Action(OnDestroyed)); + + InvokeRepeating("UpdateRefinery", 1f, 1f); + } + + // ---------------------------------------------------------------- input + + private bool OnAddMeat(Switch caller, Humanoid user, ItemDrop.ItemData item) + { + return TryAdd(user, item, isMeat: true); + } + + private bool OnAddBone(Switch caller, Humanoid user, ItemDrop.ItemData item) + { + return TryAdd(user, item, isMeat: false); + } + + private bool TryAdd(Humanoid user, ItemDrop.ItemData item, bool isMeat) + { + if (user == null) return false; + Inventory inventory = user.GetInventory(); + if (inventory == null) return false; + + if (item == null) item = FindUsable(inventory, isMeat); + if (item == null) + { + user.Message(MessageHud.MessageType.Center, isMeat ? "No raw flesh to render." : "No bone to grind."); + return false; + } + + string prefabName = item.m_dropPrefab != null ? item.m_dropPrefab.name : null; + int value = isMeat ? AswidBloodRefinery.BloodValue(prefabName) : AswidBloodRefinery.BoneValue(prefabName); + if (value <= 0) + { + user.Message(MessageHud.MessageType.Center, "$msg_wontwork"); + return false; + } + + float stored = isMeat ? GetBlood() : GetBone(); + float capacity = isMeat ? m_maxBlood : m_maxBone; + if (stored >= capacity) + { + user.Message(MessageHud.MessageType.Center, "$msg_itsfull"); + return false; + } + + user.Message(MessageHud.MessageType.Center, "$msg_added " + item.m_shared.m_name); + inventory.RemoveItem(item, 1); + m_nview.InvokeRPC(isMeat ? "RoV_AddMeat" : "RoV_AddBone", prefabName); + return true; + } + + private ItemDrop.ItemData FindUsable(Inventory inventory, bool isMeat) + { + foreach (ItemDrop.ItemData candidate in inventory.GetAllItems()) + { + if (candidate == null || candidate.m_dropPrefab == null) continue; + string prefabName = candidate.m_dropPrefab.name; + int value = isMeat ? AswidBloodRefinery.BloodValue(prefabName) : AswidBloodRefinery.BoneValue(prefabName); + if (value > 0) return candidate; + } + return null; + } + + private void RPC_AddMeat(long sender, string prefabName) + { + if (!m_nview.IsOwner()) return; + + int value = AswidBloodRefinery.BloodValue(prefabName); + if (value <= 0) return; + + SetBlood(Mathf.Min(m_maxBlood, GetBlood() + value)); + if (m_meatAddedEffects != null) m_meatAddedEffects.Create(transform.position, transform.rotation); + } + + private void RPC_AddBone(long sender, string prefabName) + { + if (!m_nview.IsOwner()) return; + + int value = AswidBloodRefinery.BoneValue(prefabName); + if (value <= 0) return; + + SetBone(Mathf.Min(m_maxBone, GetBone() + value)); + if (m_boneAddedEffects != null) m_boneAddedEffects.Create(transform.position, transform.rotation, transform); + } + + // ---------------------------------------------------------------- the loop + + private void UpdateRefinery() + { + if (m_nview == null || !m_nview.IsValid()) return; + + m_blockedSmoke = m_smokeSpawner != null && m_smokeSpawner.IsBlocked(); + UpdateState(); + + if (!m_nview.IsOwner()) return; + + float accumulator = m_nview.GetZDO().GetFloat(KeyAccumulator) + (float)GetDeltaTime(); + if (accumulator > 3600f) accumulator = 3600f; // one hour of catch-up, as vanilla + + while (accumulator >= 1f) + { + accumulator -= 1f; + if (!IsActive()) continue; + + float timer = m_nview.GetZDO().GetFloat(KeyTimer) + 1f; + if (timer >= m_secPerEssence) + { + timer = 0f; + SetBlood(GetBlood() - m_bloodPerEssence); + SetBone(GetBone() - m_bonePerEssence); + Produce(); + } + m_nview.GetZDO().Set(KeyTimer, timer); + } + + m_nview.GetZDO().Set(KeyAccumulator, accumulator); + } + + private void Produce() + { + GameObject prefab = ObjectDB.instance != null + ? ObjectDB.instance.GetItemPrefab(AswidBloodRefinery.EssenceName) + : null; + if (prefab == null || m_outputPoint == null) return; + + if (m_produceEffects != null) m_produceEffects.Create(transform.position, transform.rotation); + + GameObject spawned = Instantiate(prefab, m_outputPoint.position, m_outputPoint.rotation); + ItemDrop drop = spawned.GetComponent(); + if (drop != null) + { + drop.m_itemData.m_stack = 1; + ItemDrop.OnCreateNew(drop); + } + } + + /// + /// Bones survive the machine, blood does not, so a demolished refinery gives the bone back + /// and keeps the blood. The hover text says so before anyone swings a hammer at it. + /// + private void OnDestroyed() + { + if (m_nview == null || !m_nview.IsOwner()) return; + + int bones = Mathf.FloorToInt(GetBone()); + SetBone(0f); + SetBlood(0f); + if (bones <= 0) return; + + GameObject prefab = ObjectDB.instance != null ? ObjectDB.instance.GetItemPrefab("BoneFragments") : null; + if (prefab == null) return; + + for (int i = 0; i < bones; i++) + { + Vector3 position = transform.position + Vector3.up * 0.5f + UnityEngine.Random.insideUnitSphere * 0.3f; + Quaternion rotation = Quaternion.Euler(0f, UnityEngine.Random.Range(0, 360), 0f); + ItemDrop.OnCreateNew(Instantiate(prefab, position, rotation)); + } + } + + // ---------------------------------------------------------------- state and display + + public bool IsActive() + { + if (m_blockedSmoke) return false; + return GetBlood() >= m_bloodPerEssence && GetBone() >= m_bonePerEssence; + } + + private void UpdateState() + { + bool active = IsActive(); + + if (m_enabledObject != null) m_enabledObject.SetActive(active); + if (m_disabledObject != null) m_disabledObject.SetActive(!active); + if (m_haveBoneObject != null) m_haveBoneObject.SetActive(GetBone() > 0f); + if (m_haveMeatObject != null) m_haveMeatObject.SetActive(GetBlood() > 0f); + if (m_noMeatObject != null) m_noMeatObject.SetActive(GetBlood() <= 0f); + + if (m_animators == null) return; + foreach (Animator animator in m_animators) + { + if (animator == null || !animator.gameObject.activeInHierarchy) continue; + animator.SetBool("active", active); + animator.SetFloat("activef", active ? 1f : 0f); + } + } + + private string HoverMeat() + { + return Localization.instance.Localize( + $"{AswidBloodRefinery.PieceDisplayName} (blood {Mathf.Floor(GetBlood())}/{m_maxBlood})\n" + + "[$KEY_Use] Render raw flesh"); + } + + private string HoverBone() + { + return Localization.instance.Localize( + $"{AswidBloodRefinery.PieceDisplayName} (bone {Mathf.Floor(GetBone())}/{m_maxBone})\n" + + "[$KEY_Use] Grind bone"); + } + + // ---------------------------------------------------------------- ZDO accessors + + private double GetDeltaTime() + { + DateTime now = ZNet.instance.GetTime(); + DateTime last = new DateTime(m_nview.GetZDO().GetLong(KeyStartTime, now.Ticks)); + m_nview.GetZDO().Set(KeyStartTime, now.Ticks); + return (now - last).TotalSeconds; + } + + private float GetBlood() => m_nview != null && m_nview.IsValid() ? m_nview.GetZDO().GetFloat(KeyBlood) : 0f; + + private float GetBone() => m_nview != null && m_nview.IsValid() ? m_nview.GetZDO().GetFloat(KeyBone) : 0f; + + private void SetBlood(float value) + { + if (m_nview != null && m_nview.IsValid()) m_nview.GetZDO().Set(KeyBlood, Mathf.Max(0f, value)); + } + + private void SetBone(float value) + { + if (m_nview != null && m_nview.IsValid()) m_nview.GetZDO().Set(KeyBone, Mathf.Max(0f, value)); + } + } +}