Every message the mod puts in the middle or corner of the screen now reads its text through ModText.Get, and messages.json holds 191 texts in English and Italian. Values computed in code become $1, $2 in the text, so a translator can put them wherever the sentence needs them. Branching messages get one key per branch. A few messages travel through a field before they are shown: thralls' refusals and the building limits now hold a token or key there. Boss and form names inside messages use tokens too, the bosses the game's own, so "The Elder" arrives translated. ModText.Get now localizes each argument before inserting it. A token argument left for a later pass ran into the text after it: "$1's power" became the unknown token "enemy_eikthyr's". Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
378 lines
16 KiB
C#
378 lines
16 KiB
C#
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>
|
|
// With an item in hand every outcome counts as handled, refusals included: false makes
|
|
// Humanoid.UseItem cover our own message with the generic "$msg_cantuseon".
|
|
private bool OnUse(Switch caller, Humanoid user, ItemDrop.ItemData item)
|
|
{
|
|
return Use(user, item) || item != null;
|
|
}
|
|
|
|
private bool Use(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() ? ModText.Get("rov_msg_trenta_nothing_feed_wants_fertilizer") : ModText.Get("rov_msg_trenta_still_growing_minutes", MinutesLeft())));
|
|
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));
|
|
}
|
|
}
|
|
}
|