RacesOfValheim/JotunnModStub/PieceDensityLimit.cs
kanym b0d18b0654 feat(text): on-screen messages come from translation files
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>
2026-09-26 20:30:03 +02:00

245 lines
12 KiB
C#

using System.Collections.Generic;
using HarmonyLib;
using UnityEngine;
namespace RacesOfValheim
{
/// <summary>
/// "How many of these may stand in one region." One place, one patch, one line per station.
///
/// Every station in the per-race item-progression system that produces something continuously has
/// to be capped, or five copies are five times the effect - a field of groves is a carpet of bees,
/// five body piles are fifty draugr. Each chain used to be expected to write its own placement
/// check; this exists so the five races still to come add a limit with one call instead of
/// re-deriving ZDO counting, and so there is exactly one Player.PlacePiece prefix rather than one
/// per race.
///
/// Counting is done over ZDOs and not over loaded GameObjects, and that distinction is the whole
/// point: Valheim keeps only a handful of zones alive around the player, a few hundred metres at
/// most, so counting objects would let anyone dodge the cap by walking away and building again.
///
/// HONEST LIMIT: a client only holds the ZDOs the server has sent it. In singleplayer and on the
/// host the count is exact; on a remote client it can undercount, so a cap can be exceeded by
/// someone building far from every other copy. It still closes the case that matters - fifty of
/// them around one base - and no client-side hook can do better without a server-authoritative
/// check.
/// </summary>
public static class PieceDensityLimit
{
private class Limit
{
public float Radius;
public int Max;
public string Message;
}
private static readonly Dictionary<string, Limit> Limits = new Dictionary<string, Limit>();
/// <summary>
/// Extra placement rules, one per piece, for the chains whose cap cannot be expressed as
/// "how many of THIS piece stand nearby".
///
/// The Skadi's golem is the case that forced this: the piece it builds removes itself a frame
/// later and leaves a creature behind, so counting the piece counts nothing, and one of its two
/// caps is per-stonecutter rather than per-area. A gate is handed the same player and the same
/// placement point the simple limit gets, says yes or no, and is responsible for its own
/// refusal message - which is the whole extension: the counting is the chain's business, being
/// the ONE Player.PlacePiece prefix in the mod is still this class's.
/// </summary>
private static readonly Dictionary<string, System.Func<Player, Vector3, bool>> Gates =
new Dictionary<string, System.Func<Player, Vector3, bool>>();
/// <summary>
/// The radius of a circle with the given area, so a limit can be written the way it is
/// actually discussed - "five per 1.6 square kilometres" - instead of as a magic distance.
/// </summary>
public static float RadiusForArea(float squareKilometres)
{
return Mathf.Sqrt(squareKilometres * 1000000f / Mathf.PI);
}
/// <summary>
/// Caps a piece. Call once from the chain's Register(); calling twice just replaces the entry,
/// so a Register() that runs more than once cannot stack limits.
/// </summary>
/// <param name="refusalMessage">A translation key, not text: its $1 is how many stand nearby, $2 the limit.</param>
public static void Register(string piecePrefabName, float radius, int max, string refusalMessage)
{
if (string.IsNullOrEmpty(piecePrefabName) || max < 1 || radius <= 0f)
{
Jotunn.Logger.LogWarning($"[Density] Refusing a nonsense limit for '{piecePrefabName}' " +
$"(radius {radius}, max {max}); it will not be capped.");
return;
}
Limits[piecePrefabName] = new Limit { Radius = radius, Max = max, Message = refusalMessage };
Jotunn.Logger.LogInfo($"[Density] {piecePrefabName}: at most {max} within {radius:0} m.");
}
/// <summary>
/// Adds a rule of the chain's own to a piece. Same call-once-from-Register() contract as
/// <see cref="Register"/>, and a second call replaces the first rather than stacking.
/// </summary>
public static void RegisterGate(string piecePrefabName, System.Func<Player, Vector3, bool> gate)
{
if (string.IsNullOrEmpty(piecePrefabName) || gate == null)
{
Jotunn.Logger.LogWarning($"[Density] Refusing a nonsense gate for '{piecePrefabName}'.");
return;
}
Gates[piecePrefabName] = gate;
Jotunn.Logger.LogInfo($"[Density] {piecePrefabName}: a rule of its own runs at placement.");
}
/// <summary>
/// Every ZDO in the world carrying that prefab. False when the world cannot be asked right
/// now, which callers must read as "no information" rather than as "none".
///
/// ZDOs and not loaded GameObjects, for the reason at the top of this file, and public
/// because the Skadi's golem counts by an anchor written INTO each ZDO rather than by
/// distance - so it needs the ZDOs themselves and not a tally of them.
/// </summary>
public static bool Gather(string prefabName, List<ZDO> into)
{
if (ZDOMan.instance == null || into == null) return false;
int index = 0;
// The iterative sweep hands back a chunk per call and reports true when it is done. The
// guard is so a pathological world cannot spin here forever.
for (int guard = 0; guard < 1000; guard++)
{
if (ZDOMan.instance.GetAllZDOsWithPrefabIterative(prefabName, into, ref index)) break;
}
return true;
}
/// <summary>
/// How many of that piece already stand within the radius of a point, or -1 if the world
/// cannot be asked right now - in which case callers must let the placement through rather
/// than refuse on no information.
/// </summary>
public static int Count(string piecePrefabName, Vector3 position, float radius)
{
List<ZDO> zdos = new List<ZDO>();
if (!Gather(piecePrefabName, zdos)) return -1;
float rangeSq = radius * radius;
int count = 0;
foreach (ZDO zdo in zdos)
{
if (zdo == null) continue;
if (Vector3.SqrMagnitude(zdo.GetPosition() - position) <= rangeSq) count++;
}
return count;
}
/// <summary>
/// True if one more may be placed there. Unknown pieces are always allowed - a station with no
/// registered limit is not this class's business.
/// </summary>
public static bool Allow(Player player, string piecePrefabName, Vector3 position)
{
// The chain's own rule first: it is the more specific of the two, so it should be the one
// that gets to explain itself when both would refuse.
if (Gates.TryGetValue(piecePrefabName, out System.Func<Player, Vector3, bool> gate) &&
!gate(player, position))
{
return false;
}
if (!Limits.TryGetValue(piecePrefabName, out Limit limit)) return true;
int nearby = Count(piecePrefabName, position, limit.Radius);
if (nearby < 0 || nearby < limit.Max) return true;
if (player != null)
{
player.Message(MessageHud.MessageType.Center, ModText.Get(limit.Message, nearby, limit.Max));
}
return false;
}
}
/// <summary>
/// The single enforcement point, at the moment of building - which is the only moment a refusal is
/// both cheap and understandable. Refusing later, or building and then quietly deleting what it
/// produced, would spend the player's gate item before telling them no.
/// </summary>
/// <summary>
/// The single enforcement point.
///
/// The signature is spelled out because it is NOT the one every Valheim modding example uses. The
/// familiar `bool PlacePiece(Piece)` does not exist in this build; the real one is
///
/// void PlacePiece(Piece piece, Vector3 pos, Quaternion rot, bool doAttack)
///
/// read off the HarmonyX error this patch produced on the first launch. Two things follow, and the
/// first one cost a whole startup:
/// - it returns VOID, so there is no __result to write. Asking for one throws "Cannot get result
/// from void method" at patch time, and that exception propagates out of Harmony.PatchAll() -
/// which means one bad signature here stops the rest of the mod's patches from being applied
/// at all. A prefix returning false is the whole mechanism: the original simply does not run,
/// nothing is placed, and no resources are spent.
/// - the placement position is an ARGUMENT, not the piece's transform. At prefix time the Piece
/// is the build ghost, so `pos` is the authority on where this thing is actually going.
/// Parameters are bound positionally (__0, __1) so a rename cannot break startup either.
/// </summary>
// Valheim 1.0 appended a 'bool cheated' parameter to this overload. The type array has to
// match it exactly or the patch silently fails to bind and PatchAll throws.
[HarmonyPatch(typeof(Player), "PlacePiece",
new[] { typeof(Piece), typeof(Vector3), typeof(Quaternion), typeof(bool), typeof(bool) })]
public static class PieceDensityLimitPatch
{
public static bool Prefix(Player __instance, Piece __0, Vector3 __1)
{
if (__instance != Player.m_localPlayer || __0 == null) return true;
return PieceDensityLimit.Allow(__instance, Utils.GetPrefabName(__0.gameObject), __1);
}
}
/// <summary>
/// What makes "a prefix returning false spends nothing" TRUE, which on its own it is not.
///
/// Read off the 1.0 IL: nothing is paid inside PlacePiece. TryPlacePiece calls it and then does an
/// unconditional `ldc.i4.1; ret`, and it is UpdatePlacement that, on that true, runs
/// ConsumeResources and UseStamina. So every race lock in the mod - this class's gates, the Trol
/// totem, the Dvergar bank and barrel, the Trenta Root - stopped the building and still took the
/// wood: "Only the Sverm can raise a hive", and 40 wood and 20 resin gone.
///
/// Fixed here once rather than in each lock: a last-priority prefix on the same PlacePiece
/// overload sees __runOriginal after every other prefix has had its say, and if any of them said
/// no, TryPlacePiece reports false - the path vanilla already takes for a blocked placement, which
/// charges nothing. Any lock added later is covered without knowing this exists.
/// </summary>
[HarmonyPatch(typeof(Player), "PlacePiece",
new[] { typeof(Piece), typeof(Vector3), typeof(Quaternion), typeof(bool), typeof(bool) })]
public static class PlacementRefusalWatch
{
internal static bool Refused;
[HarmonyPriority(Priority.Last)]
public static void Prefix(bool __runOriginal)
{
if (!__runOriginal) Refused = true;
}
}
[HarmonyPatch(typeof(Player), "TryPlacePiece")]
public static class PlacementRefusalCharge
{
public static void Prefix()
{
PlacementRefusalWatch.Refused = false;
}
public static void Postfix(ref bool __result)
{
if (PlacementRefusalWatch.Refused) __result = false;
PlacementRefusalWatch.Refused = false;
}
}
}