feat(trenta): composter and heartwood grove

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
This commit is contained in:
Ferdinando 2026-08-07 17:02:47 +02:00
commit 1a741978bf
7 changed files with 1659 additions and 19 deletions

View file

@ -0,0 +1,279 @@
using System;
using UnityEngine;
namespace RacesOfValheim
{
/// <summary>
/// The Composter's logic. Modelled on <see cref="Fermenter"/> - same one-second tick, same
/// owner-only accounting with all state in the ZDO - but with a numeric tank filled by many
/// different meats in place of the barrel's single stored item.
///
/// Three states, and the barrel already has a visual for each of them: filling, composting,
/// ready. Raw flesh is destroyed on the spot and becomes mass; at capacity the lid closes and
/// the clock starts; when it runs out the tap gives a batch of Fertilizer and the cycle resets.
///
/// One simplification over <see cref="BloodRefineryBehaviour"/> worth pointing out: the refinery
/// has to carry a time accumulator because it produces continuously and must catch up on every
/// second it spent unloaded. This works in batches, so the whole timer is one stored timestamp
/// compared against ZNet's world clock - which gets "keeps composting while the zone is
/// unloaded and the game is shut" for free rather than by bookkeeping.
/// </summary>
public class ComposterBehaviour : MonoBehaviour
{
// Handed over from the vanilla Fermenter before it is destroyed, which is what keeps the
// three visual states, the sounds and the tap effects identical to the real barrel's. The
// Switch is ours - see the comment in TrentaComposter.RegisterPiece for why.
public Switch m_switch;
public GameObject m_topObject;
public GameObject m_fermentingObject;
public GameObject m_readyObject;
public Transform m_outputPoint;
public EffectList m_addedEffects;
public EffectList m_tapEffects;
public EffectList m_spawnEffects;
public float m_capacity = 100f;
public float m_compostSeconds = 2400f;
public int m_yield = 20;
private const string KeyFlesh = "RoV_compostFlesh";
private const string KeySealed = "RoV_compostSealed";
private ZNetView m_nview;
public enum State
{
Filling,
Composting,
Ready,
}
private void Awake()
{
m_nview = GetComponent<ZNetView>();
if (m_nview == null) m_nview = GetComponentInParent<ZNetView>();
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<string>("RoV_CompostAdd", RPC_Add);
m_nview.Register("RoV_CompostTap", RPC_Tap);
WearNTear wear = GetComponent<WearNTear>();
if (wear == null) wear = GetComponentInParent<WearNTear>();
if (wear != null) wear.m_onDestroyed = (Action)Delegate.Combine(wear.m_onDestroyed, new Action(OnDestroyed));
InvokeRepeating("UpdateComposter", 1f, 1f);
}
// ---------------------------------------------------------------- interaction
/// <summary>
/// One interaction point, exactly like the vanilla barrel: the item in hand decides what the
/// click means. Holding flesh feeds it; empty hands tap it when it is ready and otherwise
/// just report what it is doing.
/// </summary>
private bool OnUse(Switch caller, Humanoid user, ItemDrop.ItemData item)
{
if (user == null) return false;
State state = GetState();
if (state == State.Ready)
{
m_nview.InvokeRPC("RoV_CompostTap");
return true;
}
if (state == State.Composting)
{
user.Message(MessageHud.MessageType.Center, $"Still rotting. {MinutesLeft()} minutes.");
return false;
}
Inventory inventory = user.GetInventory();
if (inventory == null) return false;
if (item == null) item = FindFlesh(inventory);
if (item == null)
{
user.Message(MessageHud.MessageType.Center, "No raw flesh to rot.");
return false;
}
string prefabName = item.m_dropPrefab != null ? item.m_dropPrefab.name : null;
if (AswidBloodRefinery.FleshValue(prefabName) <= 0)
{
user.Message(MessageHud.MessageType.Center, "$msg_wontwork");
return false;
}
user.Message(MessageHud.MessageType.Center, "$msg_added " + item.m_shared.m_name);
inventory.RemoveItem(item, 1);
m_nview.InvokeRPC("RoV_CompostAdd", prefabName);
return true;
}
private ItemDrop.ItemData FindFlesh(Inventory inventory)
{
foreach (ItemDrop.ItemData candidate in inventory.GetAllItems())
{
if (candidate == null || candidate.m_dropPrefab == null) continue;
if (AswidBloodRefinery.FleshValue(candidate.m_dropPrefab.name) > 0) return candidate;
}
return null;
}
private void RPC_Add(long sender, string prefabName)
{
if (!m_nview.IsOwner()) return;
if (GetState() != State.Filling) return;
int value = AswidBloodRefinery.FleshValue(prefabName);
if (value <= 0) return;
float flesh = Mathf.Min(m_capacity, GetFlesh() + value);
SetFlesh(flesh);
// Reaching capacity is what starts the clock. Stamped once, here, so a barrel that fills
// up while nobody is watching still seals at the right moment.
if (flesh >= m_capacity) m_nview.GetZDO().Set(KeySealed, ZNet.instance.GetTime().Ticks);
if (m_addedEffects != null) m_addedEffects.Create(transform.position, transform.rotation);
}
private void RPC_Tap(long sender)
{
if (!m_nview.IsOwner()) return;
if (GetState() != State.Ready) return;
SetFlesh(0f);
m_nview.GetZDO().Set(KeySealed, 0L);
Produce();
}
private void Produce()
{
GameObject prefab = ObjectDB.instance != null
? ObjectDB.instance.GetItemPrefab(TrentaConfig.FertilizerName)
: null;
if (prefab == null || m_outputPoint == null) return;
if (m_tapEffects != null) m_tapEffects.Create(transform.position, transform.rotation);
if (m_spawnEffects != null) m_spawnEffects.Create(m_outputPoint.position, m_outputPoint.rotation);
// One stack rather than twenty objects on the ground: Fertilizer stacks to 50, so the
// whole batch fits, the same way Smelter.m_spawnStack gathers its output.
GameObject spawned = Instantiate(prefab, m_outputPoint.position, m_outputPoint.rotation);
ItemDrop drop = spawned.GetComponent<ItemDrop>();
if (drop != null)
{
drop.m_itemData.m_stack = m_yield;
ItemDrop.OnCreateNew(drop);
}
}
/// <summary>
/// A finished batch is given back; flesh that has already rotted is not. Same rule the Blood
/// Refinery follows for blood, and for the same reason - what the machine has absorbed is
/// gone by design, and the hover text says so before anyone swings a hammer at it.
/// </summary>
private void OnDestroyed()
{
if (m_nview == null || !m_nview.IsOwner()) return;
bool ready = GetState() == State.Ready;
SetFlesh(0f);
m_nview.GetZDO().Set(KeySealed, 0L);
if (!ready) return;
GameObject prefab = ObjectDB.instance != null
? ObjectDB.instance.GetItemPrefab(TrentaConfig.FertilizerName)
: null;
if (prefab == null) return;
Vector3 position = transform.position + Vector3.up * 0.5f;
GameObject spawned = Instantiate(prefab, position, Quaternion.Euler(0f, UnityEngine.Random.Range(0, 360), 0f));
ItemDrop drop = spawned.GetComponent<ItemDrop>();
if (drop != null)
{
drop.m_itemData.m_stack = m_yield;
ItemDrop.OnCreateNew(drop);
}
}
// ---------------------------------------------------------------- state and display
public State GetState()
{
if (GetFlesh() < m_capacity) return State.Filling;
return SecondsSealed() >= m_compostSeconds ? State.Ready : State.Composting;
}
private void UpdateComposter()
{
if (m_nview == null || !m_nview.IsValid()) return;
State state = GetState();
if (m_topObject != null) m_topObject.SetActive(state == State.Filling);
if (m_fermentingObject != null) m_fermentingObject.SetActive(state == State.Composting);
if (m_readyObject != null) m_readyObject.SetActive(state == State.Ready);
}
private int MinutesLeft()
{
double left = m_compostSeconds - SecondsSealed();
return Mathf.Max(1, Mathf.CeilToInt((float)left / 60f));
}
private string Hover()
{
string body;
switch (GetState())
{
case State.Ready:
body = $"ready: {m_yield} {TrentaConfig.FertilizerDisplayName}\n" +
"[<color=yellow><b>$KEY_Use</b></color>] Empty it";
break;
case State.Composting:
body = $"rotting, {MinutesLeft()} minutes left";
break;
default:
body = $"flesh {Mathf.Floor(GetFlesh())}/{m_capacity}\n" +
"[<color=yellow><b>$KEY_Use</b></color>] Feed it raw flesh";
break;
}
return Localization.instance.Localize($"{TrentaConfig.ComposterDisplayName} ({body})");
}
// ---------------------------------------------------------------- ZDO accessors
/// <summary>
/// Seconds since the barrel sealed itself, on ZNet's world clock rather than on frames - so
/// it keeps counting while the zone is unloaded and across a restart. 0 while still filling.
/// </summary>
private double SecondsSealed()
{
if (m_nview == null || !m_nview.IsValid() || ZNet.instance == null) return 0.0;
long ticks = m_nview.GetZDO().GetLong(KeySealed, 0L);
if (ticks == 0L) return 0.0;
return (ZNet.instance.GetTime() - new DateTime(ticks)).TotalSeconds;
}
private float GetFlesh() => m_nview != null && m_nview.IsValid() ? m_nview.GetZDO().GetFloat(KeyFlesh) : 0f;
private void SetFlesh(float value)
{
if (m_nview != null && m_nview.IsValid()) m_nview.GetZDO().Set(KeyFlesh, Mathf.Max(0f, value));
}
}
}

View file

@ -0,0 +1,373 @@
using System;
using Jotunn.Managers;
using UnityEngine;
namespace RacesOfValheim
{
/// <summary>
/// The Heartwood Grove's logic: three independent jobs on one timer.
///
/// GROWING UP one timestamp on ZNet's world clock, exactly like the Composter's seal time, so
/// a planted grove keeps ageing with the zone unloaded and the game shut. The only
/// visible effect is which of the two models is showing.
/// FERTILISING once grown, one plant per minute inside the radius, one Fertilizer each, drawn
/// from a tank the player fills through the Switch on the trunk. Deliberately one
/// plant per tick and not the whole radius: a full tank is then twenty minutes of
/// autonomy instead of one tick's worth.
/// HONEY accrues into the Container on the root at the vanilla Beehive's own rate, read
/// off that prefab rather than invented.
///
/// A tank that is empty stops the fertilising and nothing else. The bees do not care, and neither
/// does the honey - they are three jobs, not three stages.
///
/// Everything that changes state runs on the ZNetView owner only, which is also why the swarm is
/// spawned there: bees on every client would mean every client's copy landing its own sting.
/// </summary>
public class GroveBehaviour : MonoBehaviour
{
public Switch m_switch;
public Container m_container;
public GameObject m_youngModel;
public GameObject m_grownModel;
private const string KeyPlanted = "RoV_grovePlanted";
private const string KeyFertilizer = "RoV_groveFert";
private const string KeyHoneyTime = "RoV_groveHoneyTime";
// Container.Save is private, so it is reached the same way AswidBloodPotions reaches
// Fermenter.GetContent. Honey added by us has to be written to the ZDO explicitly: a player
// dropping items in goes through the inventory's own change callback, and nothing guarantees
// that callback covers a write made from outside the container's own UI.
private static readonly System.Reflection.MethodInfo ContainerSaveMethod =
HarmonyLib.AccessTools.Method(typeof(Container), "Save");
private ZNetView m_nview;
private GameObject m_bees;
// Read off the vanilla Beehive at Awake, so the grove uses the game's own honey rate. Only
// the capacity is scaled - a tree of bees has to last while the player is away.
private float m_secPerHoney = 1200f;
private int m_honeyCapacity = 20;
private GameObject m_honeyPrefab;
// The fertilise tick is local time, not world time, and that is correct rather than lazy: an
// unloaded grove cannot grow plants in a zone that is not there, so banking the time it spent
// unloaded would hand back growth that never could have happened. Honey banks; growth does not.
private float m_fertilizeTimer;
private void Awake()
{
m_nview = GetComponent<ZNetView>();
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_GroveFeed", RPC_Feed);
ReadHoneyRates();
if (m_nview.IsOwner())
{
// Stamped once, on the first client to own it, which is the moment it was planted.
if (m_nview.GetZDO().GetLong(KeyPlanted, 0L) == 0L)
{
m_nview.GetZDO().Set(KeyPlanted, ZNet.instance.GetTime().Ticks);
}
if (m_nview.GetZDO().GetLong(KeyHoneyTime, 0L) == 0L)
{
m_nview.GetZDO().Set(KeyHoneyTime, ZNet.instance.GetTime().Ticks);
}
}
InvokeRepeating("UpdateGrove", 1f, 1f);
}
private void OnDestroy()
{
if (m_bees != null) Destroy(m_bees);
}
/// <summary>
/// Borrows m_secPerUnit, m_maxHoney and the honey item off the vanilla Beehive. The rate is
/// not a design decision this mod gets to make - a hive's is already tuned - so only the
/// capacity is multiplied.
/// </summary>
private void ReadHoneyRates()
{
Beehive hive = TrentaConfig.FindVanillaBeehive();
if (hive != null)
{
if (hive.m_secPerUnit > 0f) m_secPerHoney = hive.m_secPerUnit;
if (hive.m_maxHoney > 0) m_honeyCapacity = hive.m_maxHoney * TrentaConfig.GroveHoneyCapacityFactor;
if (hive.m_honeyItem != null) m_honeyPrefab = hive.m_honeyItem.gameObject;
}
else
{
Jotunn.Logger.LogWarning("[Trenta] Heartwood Grove: no vanilla beehive; falling back to default honey rates.");
}
if (m_honeyPrefab == null && ObjectDB.instance != null)
{
m_honeyPrefab = ObjectDB.instance.GetItemPrefab("Honey");
}
// Without this the honey half fails silently, which is exactly how the night-gate bug
// managed to hide: nothing appeared and nothing said why. The log line also settles a
// question the design doc left open - whether the tuned Beehive component lives on
// "Beehive" or on "piece_beehive" - by printing what was actually read.
if (m_honeyPrefab == null)
{
Jotunn.Logger.LogWarning("[Trenta] Heartwood Grove: no honey prefab found; this grove will never produce honey.");
return;
}
Jotunn.Logger.LogInfo($"[Trenta] Heartwood Grove: honey every {m_secPerHoney:0}s, capacity {m_honeyCapacity} " +
$"(rates {(hive != null ? "read from the vanilla beehive" : "defaulted")}).");
}
// ---------------------------------------------------------------- the loop
private void UpdateGrove()
{
if (m_nview == null || !m_nview.IsValid()) return;
bool grown = IsGrown();
if (m_youngModel != null) m_youngModel.SetActive(!grown);
if (m_grownModel != null) m_grownModel.SetActive(grown);
if (!m_nview.IsOwner()) return;
if (!grown) return;
EnsureBees();
TickHoney();
m_fertilizeTimer += 1f;
if (m_fertilizeTimer >= TrentaConfig.GroveFertilizeInterval)
{
m_fertilizeTimer = 0f;
TickFertilize();
}
}
private void EnsureBees()
{
if (m_bees != null) return;
m_bees = TrentaHornetSwarm.SpawnAtAnchor(transform, TrentaConfig.GroveStingRadius);
}
/// <summary>
/// Grows exactly one thing per tick, through the very same method a player's Fertilizer click
/// goes through. That sharing is the point: two tiers growing plants by two slightly
/// different sets of rules is the failure this is written to prevent.
/// </summary>
private void TickFertilize()
{
if (GetFertilizer() <= 0) return;
foreach (Collider collider in Physics.OverlapSphere(transform.position, TrentaConfig.GroveRadius))
{
if (collider == null) continue;
if (TrentaComposter.TryGrow(collider.gameObject) != TrentaComposter.GrowOutcome.Grown) continue;
SetFertilizer(GetFertilizer() - 1);
return; // One per tick, by design
}
}
private void TickHoney()
{
if (m_honeyPrefab == null || m_container == null) return;
long stamp = m_nview.GetZDO().GetLong(KeyHoneyTime, 0L);
if (stamp == 0L) return;
DateTime now = ZNet.instance.GetTime();
// No night gate. There used to be one, and it was what stopped the honey ever appearing -
// see the long note in TrentaConfig where GroveHoneyAtNight used to live.
double elapsed = (now - new DateTime(stamp)).TotalSeconds;
if (elapsed < m_secPerHoney) return;
Inventory inventory = m_container.GetInventory();
if (inventory == null) return;
int produced = 0;
bool blocked = false;
while (elapsed >= m_secPerHoney)
{
if (CountHoney(inventory) >= m_honeyCapacity || !inventory.AddItem(m_honeyPrefab, 1))
{
blocked = true;
break;
}
elapsed -= m_secPerHoney;
produced++;
}
if (blocked)
{
// Full chest: the clock is reset to now and the surplus is thrown away, so an
// untouched grove cannot bank an unbounded debt that dumps all at once the moment
// the player finally empties it. This is also what a vanilla hive does when it caps.
m_nview.GetZDO().Set(KeyHoneyTime, now.Ticks);
}
else
{
// Only the time actually spent on the honey produced is consumed. Resetting to now
// here instead would silently throw away the remainder on every single unit and
// leave the grove producing slower than the hive whose rate it borrowed.
m_nview.GetZDO().Set(KeyHoneyTime, now.AddSeconds(-elapsed).Ticks);
}
if (produced > 0 && ContainerSaveMethod != null) ContainerSaveMethod.Invoke(m_container, null);
}
private int CountHoney(Inventory inventory)
{
if (m_honeyPrefab == null) return 0;
ItemDrop drop = m_honeyPrefab.GetComponent<ItemDrop>();
string name = drop != null && drop.m_itemData != null && drop.m_itemData.m_shared != null
? drop.m_itemData.m_shared.m_name
: null;
if (name == null) return 0;
// Counted by hand rather than through Inventory.CountItems so no overload's quality and
// world-level arguments have to be guessed at.
int total = 0;
foreach (ItemDrop.ItemData item in inventory.GetAllItems())
{
if (item != null && item.m_shared != null && item.m_shared.m_name == name) total += item.m_stack;
}
return total;
}
// ---------------------------------------------------------------- interaction
/// <summary>
/// E on the tree. Holding Fertilizer fills the tank; empty-handed it reports what the grove is
/// doing. Loading a tank before the tree has grown is allowed on purpose - there is no reason
/// to make the player come back twice.
/// </summary>
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 = FindFertilizer(inventory);
if (item == null)
{
user.Message(MessageHud.MessageType.Center, IsGrown()
? "Nothing to feed it. It wants Fertilizer."
: $"Still growing. {MinutesLeft()} minutes.");
return false;
}
if (!TrentaComposter.IsFertilizer(item))
{
user.Message(MessageHud.MessageType.Center, "$msg_wontwork");
return false;
}
if (GetFertilizer() >= TrentaConfig.GroveFertilizerCapacity)
{
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("RoV_GroveFeed");
return true;
}
private ItemDrop.ItemData FindFertilizer(Inventory inventory)
{
foreach (ItemDrop.ItemData candidate in inventory.GetAllItems())
{
if (TrentaComposter.IsFertilizer(candidate)) return candidate;
}
return null;
}
private void RPC_Feed(long sender)
{
if (!m_nview.IsOwner()) return;
int stored = GetFertilizer();
if (stored >= TrentaConfig.GroveFertilizerCapacity) return;
SetFertilizer(stored + 1);
}
private string Hover()
{
if (!IsGrown())
{
return Localization.instance.Localize(
$"{TrentaConfig.GroveDisplayName} (growing, {MinutesLeft()} minutes left)");
}
// The honey line is here because it was missing, and its absence is why a grove that
// was quietly producing nothing looked exactly like one that was working.
return Localization.instance.Localize(
$"{TrentaConfig.GroveDisplayName} ({TrentaConfig.FertilizerDisplayName} " +
$"{GetFertilizer()}/{TrentaConfig.GroveFertilizerCapacity}, honey {HoneyStatus()})\n" +
"[<color=yellow><b>$KEY_Use</b></color>] Feed it Fertilizer");
}
/// <summary>How much honey is in the crate and how long until the next drop of it.</summary>
private string HoneyStatus()
{
if (m_honeyPrefab == null) return "none (no honey item found)";
Inventory inventory = m_container != null ? m_container.GetInventory() : null;
int stored = inventory != null ? CountHoney(inventory) : 0;
string status = $"{stored}/{m_honeyCapacity}";
if (stored >= m_honeyCapacity) return status + ", full";
long stamp = m_nview.GetZDO().GetLong(KeyHoneyTime, 0L);
if (stamp == 0L || ZNet.instance == null) return status;
double left = m_secPerHoney - (ZNet.instance.GetTime() - new DateTime(stamp)).TotalSeconds;
return status + $", next in {Mathf.Max(1, Mathf.CeilToInt((float)left / 60f))} min";
}
// ---------------------------------------------------------------- state
public bool IsGrown() => SecondsSincePlanted() >= TrentaConfig.GroveGrowSeconds;
private double SecondsSincePlanted()
{
if (m_nview == null || !m_nview.IsValid() || ZNet.instance == null) return 0.0;
long ticks = m_nview.GetZDO().GetLong(KeyPlanted, 0L);
if (ticks == 0L) return 0.0;
return (ZNet.instance.GetTime() - new DateTime(ticks)).TotalSeconds;
}
private int MinutesLeft()
{
double left = TrentaConfig.GroveGrowSeconds - SecondsSincePlanted();
return Mathf.Max(1, Mathf.CeilToInt((float)left / 60f));
}
private int GetFertilizer() => m_nview != null && m_nview.IsValid() ? m_nview.GetZDO().GetInt(KeyFertilizer) : 0;
private void SetFertilizer(int value)
{
if (m_nview != null && m_nview.IsValid()) m_nview.GetZDO().Set(KeyFertilizer, Mathf.Max(0, value));
}
}
}

View file

@ -0,0 +1,488 @@
using System.Collections.Generic;
using HarmonyLib;
using Jotunn.Configs;
using Jotunn.Entities;
using Jotunn.Managers;
using UnityEngine;
namespace RacesOfValheim
{
/// <summary>
/// The Trenta station: a slightly smaller fermenter wearing the Draugr's flies and green gas,
/// which rots raw flesh into Fertilizer. A Fertilizer used on any plant grows it on the spot.
///
/// Second half of the per-race "item progression" system the Aswid's Blood Refinery started,
/// and deliberately the same shape: an item bought from a faction merchant gates a buildable
/// station, and the station produces the race's own material. Design doc: Trenta_Composter.txt.
///
/// Where it differs from the refinery is worth stating, because it drove the code: the refinery
/// produces FOOD for its race and runs continuously off two tanks, while this produces a TOOL
/// that acts on the world and runs in batches, because that is what a fermenter does. And the
/// vanilla <see cref="Fermenter"/> is one item in, N items out, which is no more usable here
/// than <see cref="Smelter"/>'s ore queue was there - so the component is stripped after its
/// scene references are handed to <see cref="ComposterBehaviour"/>, which is what keeps the
/// barrel's three visual states and its sounds identical to the vanilla one's.
/// </summary>
public static class TrentaComposter
{
/// <summary>What a single use of Fertilizer managed to do, so callers can pick the message.</summary>
public enum GrowOutcome
{
NoTarget,
NotGrowable,
AlreadyRipe,
Unhealthy,
Grown,
}
/// <summary>
/// Every Pickable the Fertilizer is allowed to bring back, as a CLOSED list - the same
/// standard the Aswid's bone table is held to, and for a sharper reason here.
///
/// The "wild plant" branch works by un-picking a Pickable, and Pickable is also what a tin
/// deposit, a flint pile, a tar pit, a meteorite and every crypt remains pile are. Deducing
/// "is this a plant?" from the component would hand the player a fertilizer that regenerates
/// ore, which is an exploit made entirely of code nobody wrote. Names verified against the
/// shipped asset manifest; entries the running game does not have are simply never matched.
/// </summary>
public static readonly HashSet<string> GrowablePickables = new HashSet<string>
{
// Cultivated crops, in their grown-and-harvestable form
"Pickable_Carrot", "Pickable_Turnip", "Pickable_Onion",
"Pickable_Barley", "Pickable_Flax",
"Pickable_SeedCarrot", "Pickable_SeedOnion", "Pickable_SeedTurnip",
// Wild versions of the same
"Pickable_Barley_Wild", "Pickable_Flax_Wild",
// Wild plants and mushrooms
"Pickable_Mushroom", "Pickable_Mushroom_yellow", "Pickable_Mushroom_blue",
"Pickable_Mushroom_Magecap", "Pickable_Mushroom_JotunPuffs", "Pickable_SmokePuff",
"Pickable_Thistle", "Pickable_Dandelion", "Pickable_Fiddlehead",
// Berry bushes - not Pickable_-prefixed, the Pickable sits on the bush itself
"RaspberryBush", "BlueberryBush", "CloudberryBush",
// Grown vines (the sapling stages are Plants and go through the other branch)
"VineGreen", "VineAsh",
};
public static void Register()
{
RegisterRotSeed();
RegisterFertilizer();
RegisterPiece();
}
/// <summary>True for the Fertilizer, by prefab first and display name only as a fallback.</summary>
public static bool IsFertilizer(ItemDrop.ItemData item)
{
if (item == null || item.m_shared == null) return false;
if (item.m_dropPrefab != null) return item.m_dropPrefab.name == TrentaConfig.FertilizerName;
return item.m_shared.m_name == TrentaConfig.FertilizerDisplayName;
}
// ---------------------------------------------------------------- items
private static void RegisterRotSeed()
{
GameObject prefab = PrefabManager.Instance.CreateClonedPrefab(TrentaConfig.RotSeedName, "AncientSeed");
if (prefab == null)
{
Jotunn.Logger.LogWarning("[Trenta] Could not clone AncientSeed; Rot Seed not registered.");
return;
}
Recolour(prefab, TrentaConfig.RotSeedTint);
ItemDrop drop = prefab.GetComponent<ItemDrop>();
if (drop == null) return;
ItemDrop.ItemData.SharedData shared = drop.m_itemData.m_shared;
shared.m_name = TrentaConfig.RotSeedDisplayName;
shared.m_description = "A seed that died before it could sprout, and did not stop. " +
"The forest folk sell them; only the forest knows what grows from one.";
shared.m_itemType = ItemDrop.ItemData.ItemType.Material;
shared.m_weight = 0.5f;
shared.m_maxStackSize = 20;
ItemManager.Instance.AddItem(new CustomItem(prefab, fixReference: false));
}
private static void RegisterFertilizer()
{
GameObject prefab = PrefabManager.Instance.CreateClonedPrefab(TrentaConfig.FertilizerName, "Entrails");
if (prefab == null)
{
Jotunn.Logger.LogWarning("[Trenta] Could not clone Entrails; Fertilizer not registered.");
return;
}
Recolour(prefab, TrentaConfig.FertilizerTint);
ItemDrop drop = prefab.GetComponent<ItemDrop>();
if (drop == null) return;
ItemDrop.ItemData.SharedData shared = drop.m_itemData.m_shared;
shared.m_name = TrentaConfig.FertilizerDisplayName;
shared.m_description = "Everything that was meat, a month later. Press it into the soil and " +
"whatever is rooted there stops waiting.";
// Consumable, not Material, and this is the only reason: a Material never reaches
// Humanoid.UseItem - vanilla refuses it before that - while a Consumable does, which is
// where TrentaFertilizerUsePatch takes it over. With every food value at zero it also
// stays invisible to the two prefixes that would otherwise fight over it: the vegan
// check in TrentaFoodPatches, and the "Mortal food disgusts you" block on
// Player.ConsumeItem in Skeleton/SkeletonPatches.cs.
shared.m_itemType = ItemDrop.ItemData.ItemType.Consumable;
shared.m_food = 0f;
shared.m_foodStamina = 0f;
shared.m_foodEitr = 0f;
shared.m_foodBurnTime = 0f;
shared.m_foodRegen = 0f;
shared.m_consumeStatusEffect = null;
shared.m_weight = 0.5f;
shared.m_maxStackSize = 50;
// The tint above only reaches the world and held models. Icons are atlas sprites and
// cannot be repainted - repainting one produced an empty inventory slot when the Aswid
// tried it - so a vanilla dark icon is borrowed instead.
Sprite icon = BorrowIcon(TrentaConfig.FertilizerIconSource);
if (icon != null) shared.m_icons = new[] { icon };
ItemManager.Instance.AddItem(new CustomItem(prefab, fixReference: false));
}
// ---------------------------------------------------------------- piece
private static void RegisterPiece()
{
// "fermenter", not "piece_fermenter" - the same name AswidBloodPotions already reads.
GameObject prefab = PrefabManager.Instance.CreateClonedPrefab(TrentaConfig.ComposterPieceName, "fermenter");
if (prefab == null)
{
Jotunn.Logger.LogWarning("[Trenta] Could not clone fermenter; Composter not registered.");
return;
}
Fermenter fermenter = prefab.GetComponentInChildren<Fermenter>(true);
if (fermenter == null)
{
Jotunn.Logger.LogWarning("[Trenta] fermenter clone has no Fermenter; Composter not registered.");
return;
}
ComposterBehaviour composter = fermenter.gameObject.AddComponent<ComposterBehaviour>();
composter.m_topObject = fermenter.m_topObject;
composter.m_fermentingObject = fermenter.m_fermentingObject;
composter.m_readyObject = fermenter.m_readyObject;
composter.m_outputPoint = fermenter.m_outputPoint;
composter.m_addedEffects = fermenter.m_addedEffects;
composter.m_tapEffects = fermenter.m_tapEffects;
composter.m_spawnEffects = fermenter.m_spawnEffects;
composter.m_capacity = TrentaConfig.ComposterCapacity;
composter.m_compostSeconds = TrentaConfig.ComposterCompostSeconds;
composter.m_yield = TrentaConfig.ComposterYield;
// The vanilla barrel is its own Hoverable and Interactable: one interaction point on the
// root, unlike the eitr refinery, whose two assigned Switches the Blood Refinery could
// simply inherit. So the interaction is rebuilt with a Switch of our own on the same
// object, which is a component this repo already drives (see BloodRefineryBehaviour) and
// costs no interface implementation. Any Switch the prefab happened to carry is dropped
// first so it cannot win the hover from a child collider - the components only, never
// their colliders, which the barrel still needs.
foreach (Switch existing in prefab.GetComponentsInChildren<Switch>(true))
{
if (existing != null) Object.DestroyImmediate(existing);
}
Object.DestroyImmediate(fermenter);
composter.m_switch = composter.gameObject.AddComponent<Switch>();
composter.m_switch.m_name = TrentaConfig.ComposterDisplayName;
// A barrel carries nothing that shoots, unlike the eitr refinery and its two Radiators.
// Called anyway as a belt: it logs whatever it finds, and a silent log is the proof.
AswidBloodRefinery.StripOffensive(prefab, TrentaConfig.ComposterPieceName);
prefab.transform.localScale = Vector3.one * TrentaConfig.ComposterScale;
BuildRotVfx(prefab.transform);
Piece piece = prefab.GetComponent<Piece>();
if (piece != null)
{
// Same call as RaceMenuWard and the Blood Refinery: a piece with a crafting station
// set vanishes from the hammer whenever that station is out of range, and this one
// has to stay findable.
piece.m_craftingStation = null;
piece.m_resources = new Piece.Requirement[0];
piece.m_name = TrentaConfig.ComposterDisplayName;
}
PieceConfig config = new PieceConfig
{
Name = TrentaConfig.ComposterDisplayName,
Description = "What rots is not lost. It feeds.",
PieceTable = PieceTables.Hammer,
Category = PieceCategories.Crafting,
Requirements = new[]
{
new RequirementConfig(TrentaConfig.RotSeedName, 1, 0, true),
new RequirementConfig("Wood", 20, 0, true),
new RequirementConfig("Resin", 10, 0, true),
new RequirementConfig("Bronze", 5, 0, true),
}
};
PieceManager.Instance.AddPiece(new CustomPiece(prefab, fixReference: false, config));
}
/// <summary>
/// Hangs the Draugr's flies and green gas over the lid.
///
/// The same particles, off the same prefab, with the same loop filter DraughVisuals.BuildAura
/// uses - looping is what separates a creature's ambient rot from its one-shot hit and death
/// effects. Copied rather than shared: DraughVisuals takes a Player, is driven by both
/// DraughRace and ZdoVisualSync, and generalising it to oblige a compost barrel would put a
/// working multiplayer aura at risk to save twenty lines.
///
/// The holder is parented to the ROOT, never to the three state objects, which
/// ComposterBehaviour switches on and off - the VFX would blink out with them.
/// </summary>
private static void BuildRotVfx(Transform root)
{
GameObject source = PrefabManager.Cache.GetPrefab<GameObject>(TrentaConfig.ComposterVfxSourcePrefab);
if (source == null)
{
Jotunn.Logger.LogWarning($"[Trenta] Composter: could not find VFX source prefab '{TrentaConfig.ComposterVfxSourcePrefab}'.");
return;
}
GameObject holder = new GameObject("ComposterVFX");
holder.transform.SetParent(root, false);
holder.transform.localPosition = TrentaConfig.ComposterVfxLocalPosition;
foreach (ParticleSystem particles in source.GetComponentsInChildren<ParticleSystem>(true))
{
if (particles == null || !particles.main.loop) continue;
string name = particles.gameObject.name.ToLowerInvariant();
// Dripping water reads as rain coming off the barrel. DraughVisuals rejects the
// same three for the same reason.
if (name.Contains("drip") || name.Contains("drop") || name.Contains("rain") || name.Contains("splash")) continue;
GameObject copy = Object.Instantiate(particles.gameObject, holder.transform);
copy.name = particles.gameObject.name;
copy.SetActive(true);
copy.transform.localPosition = Vector3.zero;
copy.transform.localRotation = particles.transform.localRotation;
}
}
/// <summary>
/// A piece only reaches the hammer once it is in the player's known recipes, and the vanilla
/// learning pass misses pieces injected after the fact - the trap RaceMenuWard and the Blood
/// Refinery both fell into. The Rot Seed requirement is the real gate; this only makes the
/// entry visible, greyed out until one is owned.
/// </summary>
public static void EnsureKnown(Player player)
{
if (player == null) return;
GameObject prefab = PrefabManager.Instance.GetPrefab(TrentaConfig.ComposterPieceName);
Piece piece = prefab != null ? prefab.GetComponent<Piece>() : null;
if (piece == null) return;
Traverse traverse = Traverse.Create(player);
traverse.Method("AddKnownPiece", piece).GetValue();
traverse.Method("UpdateAvailablePiecesList").GetValue();
}
// ---------------------------------------------------------------- growing things
/// <summary>
/// Grows one thing, now. The single place that knows how, called both by a player clicking a
/// Fertilizer and by a Heartwood Grove's own tick - the two tiers must not grow plants by
/// two slightly different rules, which is exactly what would happen if this were written
/// twice.
///
/// Three families, and the order matters: a planted carrot is a Plant (sapling_carrot) and
/// only becomes a Pickable (Pickable_Carrot) once grown, so asking Pickable first would try
/// to "un-pick" a seedling, do nothing visible, and eat the item.
/// </summary>
public static GrowOutcome TryGrow(GameObject candidate)
{
if (candidate == null) return GrowOutcome.NoTarget;
// a. Cultivated crops and tree saplings. Plant.Grow is the very method Plant.SUpdate
// calls once the natural timer runs out, so calling it by hand means literally "the
// time has passed" - no state is faked and nothing is short-circuited.
Plant plant = candidate.GetComponentInParent<Plant>();
if (plant != null)
{
// Growing regardless of conditions would beat sun, space, biome and cultivated
// ground all at once and make half of vanilla farming pointless. GetStatus is
// public, so this costs one comparison.
if (plant.GetStatus() != Plant.Status.Healthy) return GrowOutcome.Unhealthy;
ZNetView nview = plant.GetComponent<ZNetView>();
if (nview == null || !nview.IsValid()) return GrowOutcome.NotGrowable;
// Grow() instantiates the grown prefab and destroys this one through ZNetScene:
// both are the owner's work.
nview.ClaimOwnership();
plant.Grow();
return GrowOutcome.Grown;
}
// b. Wild plants that are already grown. A berry bush does not grow, it ripens: for
// those, "grow instantly" means "be ripe again now".
Pickable pickable = candidate.GetComponentInParent<Pickable>();
if (pickable != null)
{
if (!IsGrowablePickable(pickable)) return GrowOutcome.NotGrowable;
if (!pickable.GetPicked()) return GrowOutcome.AlreadyRipe;
ZNetView nview = pickable.GetComponent<ZNetView>();
if (nview == null || !nview.IsValid()) return GrowOutcome.NotGrowable;
nview.ClaimOwnership();
pickable.SetPicked(false);
return GrowOutcome.Grown;
}
// c. Everything else, a full-grown tree included: TreeBase.Grow is the growth animation
// a fresh trunk plays for itself, not a stage to advance.
return GrowOutcome.NotGrowable;
}
private static bool IsGrowablePickable(Pickable pickable)
{
if (GrowablePickables.Contains(Utils.GetPrefabName(pickable.gameObject))) return true;
// Safety net for modded plants the closed list above cannot know about: allow one if
// what it produces is something the Trenta itself calls food. Deliberately NOT a plain
// "does it drop something edible" test - that would let a meat pile through.
ItemDrop drop = pickable.m_itemPrefab != null ? pickable.m_itemPrefab.GetComponent<ItemDrop>() : null;
if (drop == null) return false;
return TrentaConfig.VeganFoodPrefabNames.Contains(Utils.GetPrefabName(pickable.m_itemPrefab));
}
/// <summary>
/// A Fertilizer used from the hotbar. The plant is whatever the player is looking at:
/// Player.GetHoverObject already enforces the vanilla interact distance on its own, so
/// there is no raycast and no radius here.
///
/// One unit per plant grown, and only when something actually grew - every refusal leaves
/// the inventory alone.
/// </summary>
public static void UseFertilizer(Player player, Inventory inventory, ItemDrop.ItemData item)
{
if (player == null || item == null) return;
if (inventory == null) inventory = player.GetInventory();
GrowOutcome outcome = TryGrow(player.GetHoverObject());
switch (outcome)
{
case GrowOutcome.Grown:
if (inventory != null) inventory.RemoveItem(item, 1);
player.Message(MessageHud.MessageType.Center, "It grows.");
break;
case GrowOutcome.AlreadyRipe:
player.Message(MessageHud.MessageType.Center, "It is ripe already.");
break;
case GrowOutcome.Unhealthy:
player.Message(MessageHud.MessageType.Center, "This one is not well. Nothing will hurry it.");
break;
case GrowOutcome.NoTarget:
player.Message(MessageHud.MessageType.Center, "Nothing there to feed.");
break;
default:
player.Message(MessageHud.MessageType.Center, "$msg_wontwork");
break;
}
}
// ---------------------------------------------------------------- prefab surgery
/// <summary>
/// Darkens every material on the clone. renderer.materials instantiates a copy, so the real
/// Entrails and the real Ancient seed keep their own look - which is the whole reason this
/// is the technique the Aswid settled on too.
/// </summary>
private static void Recolour(GameObject root, Color tint)
{
foreach (Renderer renderer in root.GetComponentsInChildren<Renderer>(true))
{
if (renderer == null) continue;
if (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);
if (material.HasProperty("_EmissionColor")) material.SetColor("_EmissionColor", Color.black);
}
}
}
private static Sprite BorrowIcon(string prefabName)
{
ItemDrop drop = PrefabManager.Cache.GetPrefab<ItemDrop>(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($"[Trenta] Could not borrow the icon from '{prefabName}'.");
return null;
}
}
/// <summary>
/// Teaches every piece this mod registers after the vanilla learning pass, exactly like
/// RaceMenuWard does - none of them reach their table on their own. It lives in the Trenta's file
/// for historical reasons and now also covers the Furling's cultivator entries; one OnSpawned
/// postfix teaching all of them beats three postfixes doing the same thing.
/// </summary>
[HarmonyPatch(typeof(Player), "OnSpawned")]
public static class TrentaComposterKnownPatch
{
public static void Postfix(Player __instance)
{
if (__instance != Player.m_localPlayer) return;
TrentaComposter.EnsureKnown(__instance);
TrentaHeartwoodGrove.EnsureKnown(__instance);
FurlingCrops.EnsureKnown(__instance);
}
}
/// <summary>
/// Turns using a Fertilizer into growing whatever the player is looking at.
///
/// A prefix on the same method - and with the same signature - as
/// TrentaFoodPatches.Trenta_Humanoid_UseItem_Patch. The two never collide: that one returns
/// early for anything without food values, and the Fertilizer has none.
/// </summary>
[HarmonyPatch(typeof(Humanoid), "UseItem")]
public static class TrentaFertilizerUsePatch
{
public static bool Prefix(Humanoid __instance, Inventory inventory, ItemDrop.ItemData item)
{
Player player = __instance as Player;
if (player == null || player != Player.m_localPlayer) return true;
if (!TrentaComposter.IsFertilizer(item)) return true;
TrentaComposter.UseFertilizer(player, inventory, item);
return false; // Never let vanilla try to eat it
}
}
}

View file

@ -200,7 +200,6 @@ namespace RacesOfValheim
// Source of the buzz: the ambient bee-swarm effect a placed Beehive plays, read for its // Source of the buzz: the ambient bee-swarm effect a placed Beehive plays, read for its
// AudioClip only - never instantiated, so nothing about how it looks ever enters this // AudioClip only - never instantiated, so nothing about how it looks ever enters this
// ability, matching "la sua unica componente visiva sarà le mosche" literally. // ability, matching "la sua unica componente visiva sarà le mosche" literally.
public const string HornetsNestBeehivePrefab = "Beehive";
// ─── Muspell (Fader) ───────────────────────────────────────────────── // ─── Muspell (Fader) ─────────────────────────────────────────────────
// A toggled transformation, the same shape as FenrirRace's own G/H/J forms: press J to // A toggled transformation, the same shape as FenrirRace's own G/H/J forms: press J to
@ -387,7 +386,163 @@ namespace RacesOfValheim
return lookup; return lookup;
} }
// ─── Composter (item progression, tier 1) ────────────────────────────
// The Trenta's half of the per-race station system the Aswid's Blood Refinery started.
// Full design in Trenta_Composter.txt; every number it settles on lives here.
//
// The chain: a Rot Seed bought from the Greydwarf faction bench gates the Composter, the
// Composter rots raw flesh into Fertilizer, and Fertilizer grows any plant on the spot.
public const string ComposterPieceName = "TrentaComposter";
public const string ComposterDisplayName = "Composter";
public const string FertilizerName = "Fertilizer";
public const string FertilizerDisplayName = "Fertilizer";
public const string RotSeedName = "RotSeed";
public const string RotSeedDisplayName = "Rot Seed";
// Same band as the Aswid's Blood Core, which does the same job for the same reason.
public const int RotSeedPrice = 500;
// "Slightly smaller than a fermenter" - the vanilla barrel is already human-sized, so this
// is a shave rather than the halving the (enormous) eitr refinery needed.
public const float ComposterScale = 0.85f;
// One batch: 100 units of flesh in, 20 Fertilizer out after the compost time, so 5 units
// of flesh per Fertilizer. Flesh is valued by AswidBloodRefinery.FleshValue.
public const float ComposterCapacity = 100f;
public const float ComposterCompostSeconds = 2400f; // as a normal fermenter
public const int ComposterYield = 20;
// Where the Draugr's flies and green gas hang over the lid. The scaled barrel is roughly a
// metre tall; this is an eyeball figure and is meant to be adjusted in game.
public static readonly Vector3 ComposterVfxLocalPosition = new Vector3(0f, 1f, 0f);
// Same prefab TrentaHornetsNest and DraughVisuals already read their particles off. The
// Composter keeps the same subset DraughVisuals keeps - flies plus the green smoke - which
// is why the swarm on a Heartwood Grove and the haze over a Composter match by default.
public const string ComposterVfxSourcePrefab = "Draugr";
// Entrails, darkened to loam. Only the world/held model takes the tint - the inventory
// icon is an atlas sprite and cannot be repainted (proven the hard way on the Aswid's
// Blood Essence), so the icon is borrowed from Guck instead: green-black reads as
// "compost" without reading as "intestine".
public static readonly Color FertilizerTint = new Color(0.18f, 0.13f, 0.09f, 1f);
public const string FertilizerIconSource = "Guck";
public static readonly Color RotSeedTint = new Color(0.16f, 0.12f, 0.08f, 1f);
// ─── Heartwood Grove (item progression, tier 2) ──────────────────────
// Plant a seed, wait, and the tree that comes up fertilises what surrounds it, stings what
// approaches it, and fills a chest with honey. Three independent functions on one piece.
public const string GroveSeedName = "HeartwoodSeed";
public const string GroveSeedDisplayName = "Heartwood Seed";
public const string GroveSaplingPieceName = "TrentaHeartwoodSapling";
public const string GroveSaplingDisplayName = "Heartwood Sapling";
public const string GrovePieceName = "TrentaHeartwoodGrove";
public const string GroveDisplayName = "Heartwood Grove";
// A grove costs exactly one full Composter batch. That is the whole balance argument.
public const int GroveSeedFertilizerCost = ComposterYield;
// World time, not session time: Plant.TimeSincePlanted reads ZNet's clock, so a sapling
// keeps growing with the zone unloaded and the game shut, same as the Composter's timer.
public const float GroveGrowSeconds = 7200f;
// One radius for both halves on purpose - the grove defends exactly the ground it farms,
// and the player only has to learn one number. Matches PurpleRainRadius.
public const float GroveRadius = 8f;
// One plant per tick, not the whole radius: 20 Fertilizer is then 20 minutes of autonomy.
// Growing everything at once would empty the trough in a single tick.
public const float GroveFertilizeInterval = 60f;
public const int GroveFertilizerCapacity = ComposterYield;
// The honey rate is not invented: m_secPerUnit and m_maxHoney are read off the vanilla
// Beehive at registration. Only the capacity is scaled - a whole tree of bees has to last
// while the player is away, where a hive only has to last until they walk past it.
public const int GroveHoneyCapacityFactor = 5;
// Honey accrues day and night, exactly as a vanilla hive's does.
//
// This used to be a GroveHoneyAtNight knob defaulting to false, on the reading that
// Beehive.m_effectOnlyInDaylight meant "bees only work in daylight". It does not: by its
// name and by the only method that touches it (Beehive.UpdateBees), it gates m_beeEffect -
// the buzz and the particles - not production. Vanilla hives make honey overnight.
//
// Getting that wrong did not merely slow the grove down, it starved it. The night was
// discarded by resetting the accrual stamp, which meant a whole m_secPerUnit had to fit
// inside one unbroken stretch of daylight - and m_secPerUnit is of the same order as a
// Valheim day is long (a full cycle is EnvMan.m_dayLengthSec, 1800s by default, of which
// roughly 1260s is not night). So honey was somewhere between rare and arithmetically
// impossible depending on the hive's real rate and what time it was when the tree matured.
//
// If the "bees sleep at night" flavour is ever wanted, it belongs where vanilla puts it:
// on the swarm's buzz, not on the honey.
// Only the model is taken off this prefab, never its TreeBase or its log drop - the same
// discipline the VFX borrowing follows. A Yggdrasil shoot reads as "grown from a root of
// the world" rather than as any old beech, and matches YggdrasilWood being in the recipe.
public const string GroveModelPrefab = "YggaShoot_small1";
public const float GroveModelScale = 1f;
// Cloned for the sapling stage; must be a prefab that carries a Plant component.
public const string GroveSaplingSourcePrefab = "Beech_Sapling";
// The grove's swarm is the Hornet's Nest swarm with a different anchor - deliberately not
// a second copy of that code, so a change to the sting is a change to both. It therefore
// reads HornetsNestDamagePerTick / HornetsNestTickInterval and has no damage of its own.
//
// A grove is a piece, not a Character, so BaseAI.IsEnemy cannot be asked directly the way
// the player-anchored swarm asks it. The fallback rule lives in TrentaHornetSwarm.
public const float GroveStingRadius = GroveRadius;
// Density cap, enforced by PieceDensityLimit. Without one, a field of groves is a carpet of
// bees that kills anything that comes near, and this was a known open point for two rounds.
//
// More permissive than the Draugh body pile's five, on the reading that a grove is a farm
// rather than an army and costs a Composter batch rather than a 500-coin bone. Unlike almost
// every other number in this file it has no vanilla equivalent to be read off, so it IS a
// guess - change it freely, it is one line and nothing else depends on it.
public const int GroveMaxInRange = 10;
public const float GroveDensityAreaKm2 = 1.6f; // the same frame the body pile uses
// ─── The vanilla beehive ─────────────────────────────────────────────
// Two features read this prefab: the grove borrows its honey rate and capacity, and the
// Hornet's Nest borrows the AudioClip off its bee effect.
//
// Both used to look up "Beehive" and both silently got nothing - confirmed from the BepInEx
// log, which is the whole reason those lookups now warn instead of returning quietly. There is
// a Beehive.prefab in the asset manifest, but it is not what PrefabManager resolves under that
// name; the buildable hive is "piece_beehive", and that is the one carrying the tuned Beehive
// component. Both names are tried in order so a game update that moves it cannot silence this
// again without saying so.
public static readonly string[] BeehiveSourcePrefabs = { "piece_beehive", "Beehive" };
// ─── Helpers ───────────────────────────────────────────────────────── // ─── Helpers ─────────────────────────────────────────────────────────
/// <summary>
/// The vanilla Beehive component, or null. Shared by the grove and the Hornet's Nest so the
/// two cannot disagree about where it lives.
/// </summary>
public static Beehive FindVanillaBeehive()
{
foreach (string name in BeehiveSourcePrefabs)
{
GameObject prefab = Jotunn.Managers.PrefabManager.Cache.GetPrefab<GameObject>(name);
Beehive hive = prefab != null ? prefab.GetComponent<Beehive>() : null;
if (hive != null)
{
Jotunn.Logger.LogInfo($"[Trenta] Vanilla beehive resolved from '{name}'.");
return hive;
}
}
Jotunn.Logger.LogWarning("[Trenta] No vanilla beehive found under any of: " +
string.Join(", ", BeehiveSourcePrefabs));
return null;
}
/// <summary>Clamped table lookup, so a state outside 1..8 can never index out of range.</summary> /// <summary>Clamped table lookup, so a state outside 1..8 can never index out of range.</summary>
public static float Lookup(float[] table, int state) public static float Lookup(float[] table, int state)
{ {

View file

@ -0,0 +1,237 @@
using HarmonyLib;
using Jotunn.Configs;
using Jotunn.Entities;
using Jotunn.Managers;
using UnityEngine;
namespace RacesOfValheim
{
/// <summary>
/// Tier 2 of the Trenta's item chain: plant it, wait, and the tree that comes up fertilises what
/// surrounds it, stings what approaches it, and fills a chest with honey. Three functions that do
/// not depend on each other, on one piece. Design doc: Trenta_Composter.txt section 11.
///
/// ONE piece, not two. The doc called for a sapling carrying a vanilla Plant whose m_grownPrefabs
/// pointed at a separate grown prefab; this grows in place instead - same crate, same ZNetView,
/// with the young model swapped for the grown one when the clock runs out. Three risks went away
/// with that decision and nothing was lost:
/// - no second prefab to register outside a piece table, and no question about whether Jotunn
/// has put it in ZNetScene by the time a Plant tries to instantiate it;
/// - no dependency on Beech_Sapling actually carrying a Plant, which was the one link in the
/// tier-1 design nobody had opened yet;
/// - the honey chest and the Fertilizer trough survive the transition, because there is no
/// transition - nothing is destroyed and re-spawned, so nothing has to be carried over.
/// The growth timer is the same shape as the Composter's: one timestamp on ZNet's world clock, so
/// it advances with the zone unloaded and across a restart.
///
/// The layout is forced by a single fact worth stating plainly: there is one ZNetView per
/// instantiated prefab, and Container keeps its inventory in the ZDO. So there can be exactly one
/// real chest, and it is the honey one. The Fertilizer goes in through a Switch on the plant
/// itself - E on the crate opens the honey, E on the tree feeds it - which is the same division
/// of labour the vanilla fermenter uses between its root component and its child switches.
/// </summary>
public static class TrentaHeartwoodGrove
{
public static void Register()
{
RegisterSeed();
RegisterPiece();
PieceDensityLimit.Register(TrentaConfig.GrovePieceName,
PieceDensityLimit.RadiusForArea(TrentaConfig.GroveDensityAreaKm2), TrentaConfig.GroveMaxInRange,
"This country already answers to {0} of these. Plant it somewhere else.");
}
// ---------------------------------------------------------------- the seed
private static void RegisterSeed()
{
GameObject prefab = PrefabManager.Instance.CreateClonedPrefab(TrentaConfig.GroveSeedName, "AncientSeed");
if (prefab == null)
{
Jotunn.Logger.LogWarning("[Trenta] Could not clone AncientSeed; Heartwood Seed not registered.");
return;
}
ItemDrop drop = prefab.GetComponent<ItemDrop>();
if (drop == null) return;
ItemDrop.ItemData.SharedData shared = drop.m_itemData.m_shared;
shared.m_name = TrentaConfig.GroveSeedDisplayName;
shared.m_description = "A seed fed on a whole barrel of rot. Plant it and go away for a while.";
shared.m_itemType = ItemDrop.ItemData.ItemType.Material;
shared.m_weight = 1f;
shared.m_maxStackSize = 10;
ItemManager.Instance.AddItem(new CustomItem(prefab, fixReference: false));
// One grove costs exactly one full Composter batch - 100 units of flesh and forty
// minutes. That is the whole balance argument, and it is why the cost is expressed in
// Fertilizer rather than in some second currency.
ItemManager.Instance.AddRecipe(new CustomRecipe(new RecipeConfig
{
Item = TrentaConfig.GroveSeedName,
Amount = 1,
CraftingStation = "piece_preptable",
Requirements = new[]
{
new RequirementConfig(TrentaConfig.FertilizerName, TrentaConfig.GroveSeedFertilizerCost),
new RequirementConfig(TrentaConfig.RotSeedName, 1),
new RequirementConfig("YggdrasilWood", 10),
}
}));
}
// ---------------------------------------------------------------- the piece
private static void RegisterPiece()
{
// A wooden chest is the base because it arrives with everything a honey store needs
// already wired: ZNetView, Piece, WearNTear, colliders, and a Container whose lid
// objects and effect lists are assigned. Building one from scratch would mean assigning
// all of that by hand and finding out in game which field Container.Awake dereferences
// without checking.
GameObject prefab = PrefabManager.Instance.CreateClonedPrefab(TrentaConfig.GrovePieceName, "piece_chest_wood");
if (prefab == null)
{
Jotunn.Logger.LogWarning("[Trenta] Could not clone piece_chest_wood; Heartwood Grove not registered.");
return;
}
Container container = prefab.GetComponent<Container>();
if (container == null)
{
Jotunn.Logger.LogWarning("[Trenta] piece_chest_wood clone has no Container; Heartwood Grove not registered.");
return;
}
container.m_name = TrentaConfig.GroveDisplayName;
GroveBehaviour grove = prefab.AddComponent<GroveBehaviour>();
grove.m_container = container;
grove.m_youngModel = BuildModel(prefab.transform, "GroveYoung", TrentaConfig.GroveSaplingSourcePrefab, TrentaConfig.GroveModelScale);
grove.m_grownModel = BuildModel(prefab.transform, "GroveGrown", TrentaConfig.GroveModelPrefab, TrentaConfig.GroveModelScale);
// The plant is the second interaction point. It carries its own collider so the hover
// raycast resolves to the Switch on it rather than walking up to the Container on the
// root - which is how the crate keeps meaning "open the honey" while the tree means
// "feed me". Sized generously: it has to be clickable at both growth stages.
grove.m_switch = BuildTroughSwitch(grove.m_grownModel, grove.m_youngModel);
Piece piece = prefab.GetComponent<Piece>();
if (piece != null)
{
piece.m_craftingStation = null;
piece.m_resources = new Piece.Requirement[0];
piece.m_name = TrentaConfig.GroveDisplayName;
}
PieceConfig config = new PieceConfig
{
Name = TrentaConfig.GroveDisplayName,
Description = "A crate of rot with something growing out of it. Give it time.",
PieceTable = PieceTables.Hammer,
Category = PieceCategories.Misc,
Requirements = new[]
{
new RequirementConfig(TrentaConfig.GroveSeedName, 1, 0, true),
}
};
PieceManager.Instance.AddPiece(new CustomPiece(prefab, fixReference: false, config));
}
/// <summary>
/// Borrows the visible half of a world prefab and nothing else.
///
/// The same discipline the VFX borrowing follows, and here it matters more: the Yggdrasil
/// shoot is a TreeBase, so taken whole it would bring a choppable trunk, a log drop and a
/// tree collider along with the mesh - a grove that can be felled for wood instead of being
/// destroyed as a piece. Only Renderers and their transforms survive; every component that
/// is not a Renderer, and every collider, is stripped.
/// </summary>
private static GameObject BuildModel(Transform root, string name, string sourcePrefabName, float scale)
{
GameObject holder = new GameObject(name);
holder.transform.SetParent(root, false);
holder.transform.localPosition = Vector3.zero;
GameObject source = PrefabManager.Cache.GetPrefab<GameObject>(sourcePrefabName);
if (source == null)
{
Jotunn.Logger.LogWarning($"[Trenta] Heartwood Grove: could not find model prefab '{sourcePrefabName}'.");
return holder;
}
GameObject copy = Object.Instantiate(source, holder.transform);
copy.name = "model";
copy.transform.localPosition = Vector3.zero;
copy.transform.localScale = Vector3.one * scale;
foreach (MonoBehaviour behaviour in copy.GetComponentsInChildren<MonoBehaviour>(true))
{
if (behaviour != null) Object.DestroyImmediate(behaviour);
}
foreach (Collider collider in copy.GetComponentsInChildren<Collider>(true))
{
if (collider != null) Object.DestroyImmediate(collider);
}
foreach (ZNetView nview in copy.GetComponentsInChildren<ZNetView>(true))
{
if (nview != null) Object.DestroyImmediate(nview);
}
return holder;
}
/// <summary>
/// The Fertilizer input: a Switch with a collider of its own, hung off the grown model but
/// parented so it stays live at both stages (the models get toggled, this does not).
/// </summary>
private static Switch BuildTroughSwitch(GameObject grownModel, GameObject youngModel)
{
// Parented to the models' shared parent - the piece root - precisely so GroveBehaviour
// can switch the two models on and off without taking the interaction point with them.
Transform parent = grownModel != null ? grownModel.transform.parent : youngModel.transform.parent;
GameObject holder = new GameObject("GroveTrough");
holder.transform.SetParent(parent, false);
holder.transform.localPosition = new Vector3(0f, 1.2f, 0f);
// Two decisions here that both come down to "will the hover raycast find this at all",
// which is the one thing about this piece that cannot be settled by reading code:
// - the layer is copied from the piece root rather than left on Default, because
// Player.FindHoverObject raycasts against a mask and a brand new GameObject starts
// on whatever layer 0 happens to be;
// - it is NOT a trigger. Physics.queriesHitTriggers is a global whose value here is
// not ours, so a trigger collider might simply be invisible to that raycast. Solid
// also happens to be right: it is a tree trunk, and walking through it would be odd.
holder.layer = parent.gameObject.layer;
BoxCollider collider = holder.AddComponent<BoxCollider>();
collider.size = new Vector3(1.2f, 2.4f, 1.2f);
collider.isTrigger = false;
Switch trough = holder.AddComponent<Switch>();
trough.m_name = TrentaConfig.GroveDisplayName;
return trough;
}
/// <summary>
/// Same reason as the Composter's: a piece registered after the vanilla learning pass never
/// reaches the hammer on its own. The Heartwood Seed requirement is the real gate.
/// </summary>
public static void EnsureKnown(Player player)
{
if (player == null) return;
GameObject prefab = PrefabManager.Instance.GetPrefab(TrentaConfig.GrovePieceName);
Piece piece = prefab != null ? prefab.GetComponent<Piece>() : null;
if (piece == null) return;
Traverse traverse = Traverse.Create(player);
traverse.Method("AddKnownPiece", piece).GetValue();
traverse.Method("UpdateAvailablePiecesList").GetValue();
}
}
}

View file

@ -7,13 +7,22 @@ namespace RacesOfValheim
/// <summary> /// <summary>
/// The swarm itself. Not a Character - it has no health, no hitbox anything else can target, /// The swarm itself. Not a Character - it has no health, no hitbox anything else can target,
/// so "indistruttibile" falls out of what it simply isn't rather than needing invulnerability /// so "indistruttibile" falls out of what it simply isn't rather than needing invulnerability
/// code of its own. Idles in a slow orbit around the Trenta; the instant an enemy comes within /// code of its own. Idles in a slow orbit around whatever it is tied to; the instant an enemy
/// range it breaks off, hovers over that enemy instead, and sting-ticks it on a timer until it /// comes within range it breaks off, hovers over that enemy instead, and sting-ticks it on a
/// dies or leaves range, then returns to orbiting. /// timer until it dies or leaves range, then returns to orbiting.
///
/// Two things it can be tied to, and the difference is only in what counts as an enemy:
/// - a Trenta player (the Hornet's Nest perk), which can be asked BaseAI.IsEnemy directly;
/// - a Heartwood Grove's trunk (the tier-2 station), which cannot, because a piece is not a
/// Character. See IsHostile.
/// Deliberately one class rather than two copies: the sting is combat logic, and a second copy
/// means the next tweak to the venom gets made in one place and forgotten in the other.
/// </summary> /// </summary>
public class TrentaHornetSwarm : MonoBehaviour public class TrentaHornetSwarm : MonoBehaviour
{ {
private Player owner; private Player owner; // null for a grove swarm
private Transform anchor; // what it orbits; the owner's own transform for a player swarm
private float engageRadius;
private Character target; private Character target;
private float tickTimer; private float tickTimer;
private float orbitAngle; private float orbitAngle;
@ -21,11 +30,38 @@ namespace RacesOfValheim
public static GameObject Spawn(Player player) public static GameObject Spawn(Player player)
{ {
GameObject go = new GameObject("TrentaHornetsNest"); GameObject go = Build("TrentaHornetsNest", player.transform.position + Vector3.up);
go.transform.position = player.transform.position + Vector3.up;
TrentaHornetSwarm swarm = go.GetComponent<TrentaHornetSwarm>();
swarm.owner = player;
swarm.anchor = player.transform;
swarm.engageRadius = TrentaConfig.HornetsNestEngageRadius;
return go;
}
/// <summary>
/// The grove's swarm: same bees, tied to a fixed point instead of to a player. The radius is
/// its own number because 6 metres is tuned for something that walks - a tree that cannot
/// chase has to reach further, and it matches the ground the grove fertilises.
/// </summary>
public static GameObject SpawnAtAnchor(Transform anchorPoint, float radius)
{
GameObject go = Build("TrentaGroveBees", anchorPoint.position + Vector3.up);
TrentaHornetSwarm swarm = go.GetComponent<TrentaHornetSwarm>();
swarm.anchor = anchorPoint;
swarm.engageRadius = radius;
return go;
}
private static GameObject Build(string name, Vector3 position)
{
GameObject go = new GameObject(name);
go.transform.position = position;
TrentaHornetSwarm swarm = go.AddComponent<TrentaHornetSwarm>(); TrentaHornetSwarm swarm = go.AddComponent<TrentaHornetSwarm>();
swarm.owner = player;
BuildFliesVfx(go.transform); BuildFliesVfx(go.transform);
swarm.buzz = BuildBuzzAudio(go.transform); swarm.buzz = BuildBuzzAudio(go.transform);
@ -33,15 +69,20 @@ namespace RacesOfValheim
return go; return go;
} }
private Vector3 AnchorPosition => anchor != null ? anchor.position : transform.position;
private void Update() private void Update()
{ {
if (owner == null || owner.IsDead()) // A player swarm dies with its player; a grove swarm dies with its tree. Either way the
// check is "is there still something to orbit", which is also what makes the swarm clean
// itself up when the grove is destroyed without the grove having to say so.
if (anchor == null || (owner != null && owner.IsDead()))
{ {
Destroy(gameObject); Destroy(gameObject);
return; return;
} }
if (target != null && (target.IsDead() || Vector3.Distance(target.transform.position, owner.transform.position) > TrentaConfig.HornetsNestEngageRadius * 1.5f)) if (target != null && (target.IsDead() || Vector3.Distance(target.transform.position, AnchorPosition) > engageRadius * 1.5f))
{ {
target = null; target = null;
} }
@ -74,7 +115,7 @@ namespace RacesOfValheim
// them - reads as "trying to stay on him" without looking glued in place. // them - reads as "trying to stay on him" without looking glued in place.
orbitAngle += Time.deltaTime * 60f; orbitAngle += Time.deltaTime * 60f;
Vector3 orbitOffset = new Vector3(Mathf.Cos(orbitAngle * Mathf.Deg2Rad), 0.3f, Mathf.Sin(orbitAngle * Mathf.Deg2Rad)) * TrentaConfig.HornetsNestOrbitRadius; Vector3 orbitOffset = new Vector3(Mathf.Cos(orbitAngle * Mathf.Deg2Rad), 0.3f, Mathf.Sin(orbitAngle * Mathf.Deg2Rad)) * TrentaConfig.HornetsNestOrbitRadius;
Vector3 restPoint = owner.transform.position + Vector3.up + orbitOffset; Vector3 restPoint = AnchorPosition + Vector3.up + orbitOffset;
transform.position = Vector3.MoveTowards(transform.position, restPoint, TrentaConfig.HornetsNestFollowSpeed * Time.deltaTime); transform.position = Vector3.MoveTowards(transform.position, restPoint, TrentaConfig.HornetsNestFollowSpeed * Time.deltaTime);
} }
} }
@ -83,16 +124,17 @@ namespace RacesOfValheim
{ {
Character nearest = null; Character nearest = null;
float nearestDist = float.MaxValue; float nearestDist = float.MaxValue;
Vector3 centre = AnchorPosition;
foreach (Collider collider in Physics.OverlapSphere(owner.transform.position, TrentaConfig.HornetsNestEngageRadius)) foreach (Collider collider in Physics.OverlapSphere(centre, engageRadius))
{ {
if (collider == null) continue; if (collider == null) continue;
Character character = collider.GetComponentInParent<Character>(); Character character = collider.GetComponentInParent<Character>();
if (character == null || character == owner || character.IsDead()) continue; if (character == null || character == owner) continue;
if (!BaseAI.IsEnemy(owner, character)) continue; if (!IsHostile(character)) continue;
float dist = Vector3.Distance(character.transform.position, owner.transform.position); float dist = Vector3.Distance(character.transform.position, centre);
if (dist < nearestDist) if (dist < nearestDist)
{ {
nearestDist = dist; nearestDist = dist;
@ -103,6 +145,59 @@ namespace RacesOfValheim
return nearest; return nearest;
} }
/// <summary>
/// Who gets stung.
///
/// For a player swarm this is one line - BaseAI.IsEnemy - and it is the most valuable line in
/// the file: RaceHostilityManager is a postfix on that very method, so the Trenta's own
/// alliances (greyling, greydwarf, fuling, troll, leech, deathsquito) are honoured for free.
///
/// A grove has no Character to ask on its own behalf, so the rule is rebuilt from parts:
/// never players, never tamed, and only things carrying a MonsterAI - which is the cut that
/// spares wild deer and boar, since vanilla gives passive animals AnimalAI instead. And if
/// there is a Trenta standing inside the radius, IsEnemy is consulted against them too, so
/// the alliances come back the moment someone is there to carry them.
/// </summary>
private bool IsHostile(Character character)
{
if (character == null || character.IsDead()) return false;
if (character.IsPlayer()) return false;
if (character.IsTamed()) return false;
if (owner != null) return BaseAI.IsEnemy(owner, character);
if (character.GetComponent<MonsterAI>() == null) return false;
Player trenta = NearestTrenta();
return trenta == null || BaseAI.IsEnemy(trenta, character);
}
/// <summary>
/// The nearest Trenta inside the swarm's own radius, or null. Used both to borrow their
/// alliances and to attribute the sting - a hit with no attacker at all is what the old eitr
/// refinery's mystery damage looked like, and worth avoiding whenever there is a real one.
/// </summary>
private Player NearestTrenta()
{
Player nearest = null;
float nearestDist = float.MaxValue;
Vector3 centre = AnchorPosition;
foreach (Player player in Player.GetAllPlayers())
{
if (player == null || player.IsDead() || !TrentaVisuals.IsTrentaPlayer(player)) continue;
float dist = Vector3.Distance(player.transform.position, centre);
if (dist <= engageRadius && dist < nearestDist)
{
nearestDist = dist;
nearest = player;
}
}
return nearest;
}
/// <summary> /// <summary>
/// Two hits, matching "come se il giocatore fosse costantemente avvelenato dalle api, più /// Two hits, matching "come se il giocatore fosse costantemente avvelenato dalle api, più
/// lo stesso danno ma perforante da sopra" literally: one Poison hit at the wild Bee /// lo stesso danno ma perforante da sopra" literally: one Poison hit at the wild Bee
@ -111,16 +206,20 @@ namespace RacesOfValheim
/// </summary> /// </summary>
private void Sting(Character victim) private void Sting(Character victim)
{ {
// A grove's bees are still somebody's bees when a Trenta is standing under the tree;
// when nobody is, the sting lands with no attacker rather than picking one at random.
Character attacker = owner != null ? owner : NearestTrenta();
HitData poison = new HitData(); HitData poison = new HitData();
poison.m_damage.m_poison = TrentaConfig.HornetsNestDamagePerTick; poison.m_damage.m_poison = TrentaConfig.HornetsNestDamagePerTick;
poison.SetAttacker(owner); if (attacker != null) poison.SetAttacker(attacker);
poison.m_point = victim.GetCenterPoint(); poison.m_point = victim.GetCenterPoint();
poison.m_dir = Vector3.zero; poison.m_dir = Vector3.zero;
victim.Damage(poison); victim.Damage(poison);
HitData pierce = new HitData(); HitData pierce = new HitData();
pierce.m_damage.m_pierce = TrentaConfig.HornetsNestDamagePerTick; pierce.m_damage.m_pierce = TrentaConfig.HornetsNestDamagePerTick;
pierce.SetAttacker(owner); if (attacker != null) pierce.SetAttacker(attacker);
pierce.m_point = victim.GetCenterPoint(); pierce.m_point = victim.GetCenterPoint();
pierce.m_dir = Vector3.down; pierce.m_dir = Vector3.down;
victim.Damage(pierce); victim.Damage(pierce);
@ -165,8 +264,10 @@ namespace RacesOfValheim
source.spatialBlend = 1f; // 3D - it should sound like it is coming from the swarm source.spatialBlend = 1f; // 3D - it should sound like it is coming from the swarm
source.volume = 0.6f; source.volume = 0.6f;
GameObject beehivePrefab = PrefabManager.Cache.GetPrefab<GameObject>(TrentaConfig.HornetsNestBeehivePrefab); // Resolved through TrentaConfig, which tries "piece_beehive" before "Beehive". This used
Beehive beehive = beehivePrefab != null ? beehivePrefab.GetComponent<Beehive>() : null; // to look up "Beehive" alone and got nothing, every time, which is why the swarm has been
// silent since it was written - found in the BepInEx log, not by listening.
Beehive beehive = TrentaConfig.FindVanillaBeehive();
GameObject beeEffect = beehive != null ? Traverse.Create(beehive).Field<GameObject>("m_beeEffect").Value : null; GameObject beeEffect = beehive != null ? Traverse.Create(beehive).Field<GameObject>("m_beeEffect").Value : null;
AudioSource sourceClipHolder = beeEffect != null ? beeEffect.GetComponentInChildren<AudioSource>(true) : null; AudioSource sourceClipHolder = beeEffect != null ? beeEffect.GetComponentInChildren<AudioSource>(true) : null;

View file

@ -27,6 +27,13 @@ namespace RacesOfValheim
{ {
TrentaStatusEffects.RegisterStatusEffects(); TrentaStatusEffects.RegisterStatusEffects();
CreateAwakenedSeedFoods(); CreateAwakenedSeedFoods();
// The item-progression chain: the Composter and its Fertilizer, then the Heartwood Grove
// that runs on that Fertilizer. Registered here rather than lazily because the faction
// merchant catalogue resolves the Rot Seed by prefab name, so the item has to exist
// before that catalogue is read.
TrentaComposter.Register();
TrentaHeartwoodGrove.Register();
} }
/// <summary> /// <summary>