What the stations, thralls, the ward and the hive show under the crosshair now reads its text through ModText.Get, and hover.json holds 50 texts in English and Italian. The Aswid thralls and the Race Menu Ward wrote the use key as a literal E; they now use $KEY_Use, which shows the key the player actually bound. For that to work, ModText.Get runs a second localization pass when a $ is left in the result: Valheim resolves tokens once and never looks inside what it inserted, and hover texts go to the HUD without another pass. The Sverm hive stage names stay English for now: the compendium and the hive's goods show them too, and those come with the merchants step. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
404 lines
18 KiB
C#
404 lines
18 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using UnityEngine;
|
|
|
|
namespace RacesOfValheim
|
|
{
|
|
/// <summary>
|
|
/// The bone pile's logic. Simpler than the body pile's, because there is no reserve to keep books
|
|
/// on: the ZDO holds how many SLOTS have been paid for per kind, and a slot with nobody standing
|
|
/// in it refills itself on a timer, forever.
|
|
///
|
|
/// That is the whole "skeletons are immortal" mechanic, and it is why nothing here drops or
|
|
/// consumes bones on death. Twenty fragments buy a place in the line once; whoever is standing in
|
|
/// that place gets back up as often as they are knocked down. No death hook, no drop table, no
|
|
/// resource created or destroyed.
|
|
///
|
|
/// The roster is counted from the world rather than tallied, exactly like the body pile's, so a
|
|
/// death, a despawn or a player killing his own skeleton all correct themselves.
|
|
/// </summary>
|
|
public class SkeletonBonePileBehaviour : MonoBehaviour
|
|
{
|
|
public Switch m_switch;
|
|
|
|
private const string KeyBones = "RoV_skelBones";
|
|
private const string KeySlotsMelee = "RoV_skelSlotsMelee";
|
|
private const string KeySlotsRanged = "RoV_skelSlotsRanged";
|
|
private const string KeySlotsRancid = "RoV_skelSlotsRancid";
|
|
private const string KeyUpgraded = "RoV_skelUpgraded";
|
|
|
|
private ZNetView m_nview;
|
|
private float m_respawnTimer;
|
|
|
|
private void Awake()
|
|
{
|
|
// The registry RaisedThrall consults to answer "is my pile still standing?".
|
|
RaisedThrall.RegisterStation(transform);
|
|
|
|
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<string, int>("RoV_SkelFeed", RPC_Feed);
|
|
m_nview.Register("RoV_SkelUpgrade", RPC_Upgrade);
|
|
|
|
WearNTear wear = GetComponent<WearNTear>();
|
|
if (wear != null) wear.m_onDestroyed = (Action)Delegate.Combine(wear.m_onDestroyed, new Action(OnDestroyed));
|
|
|
|
InvokeRepeating("UpdatePile", 2f, 2f);
|
|
}
|
|
|
|
private void OnDestroy()
|
|
{
|
|
RaisedThrall.UnregisterStation(transform);
|
|
}
|
|
|
|
// ---------------------------------------------------------------- interaction
|
|
|
|
/// <summary>
|
|
/// Bones in hand feed it, a Greater Cursed Skull upgrades it, a Rancid trophy buys an officer -
|
|
/// and EMPTY HANDS move the whole garrison. That last one is the mechanic the Draugh does not
|
|
/// have: a body pile is commanded draugr by draugr, a bone pile is commanded as a line.
|
|
///
|
|
/// Empty hands were free to use for this because the pile's own hover already carries the
|
|
/// status the Draugh needs an empty-handed click to report.
|
|
/// </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)
|
|
{
|
|
Player player = user as Player;
|
|
if (player == null) return false;
|
|
|
|
Inventory inventory = player.GetInventory();
|
|
if (inventory == null) return false;
|
|
|
|
// EMPTY HANDS MEAN THE COMMAND, always, and nothing else is consulted.
|
|
//
|
|
// This used to scan the pack for something to feed first, copied from the body pile where
|
|
// empty hands mean nothing else. Two bugs came out of it: a Rancid trophy in the pack was
|
|
// skipped in SILENCE when the pile was not upgraded yet - the refusal that explains why was
|
|
// only reachable by holding the item - and, worse, anyone carrying bone fragments (which is
|
|
// everyone) would feed the pile when they meant to move the line. The hover has always said
|
|
// "bone in hand to buy a place, empty hands to move the line"; now the code agrees with it.
|
|
if (item == null) return ToggleGarrison(player);
|
|
|
|
string prefabName = item.m_dropPrefab != null ? item.m_dropPrefab.name : null;
|
|
if (prefabName == null) return false;
|
|
|
|
if (prefabName == SkeletonBonePile.GreaterSkullName) return TryUpgrade(player, inventory, item);
|
|
|
|
// How many of this the pile can still take. Not "is there room for one" - that was the bug:
|
|
// the old check only asked whether a single trophy would fit and then handed over the WHOLE
|
|
// stack, so ten Rancid trophies went in, RPC_Feed clamped the slots to two, and eight were
|
|
// destroyed for nothing. Anything taken from the player has to be something the pile will
|
|
// actually keep.
|
|
int room;
|
|
if (prefabName == SkeletonBonePile.RancidTrophy)
|
|
{
|
|
if (!IsUpgraded())
|
|
{
|
|
player.Message(MessageHud.MessageType.Center, ModText.Get("rov_msg_skeleton_this_pile_cannot_hold_rotten"));
|
|
return false;
|
|
}
|
|
room = RancidCap() - GetSlots(SkeletonBonePile.KindRancid);
|
|
}
|
|
else if (prefabName == SkeletonBonePile.BonePrefab)
|
|
{
|
|
// Bone is measured in fragments, not places: what is left to buy, minus what is already
|
|
// part-paid towards the next place.
|
|
room = (TotalCap() - PaidSlots()) * SkeletonBonePile.BonesPerSlot
|
|
- m_nview.GetZDO().GetInt(KeyBones);
|
|
}
|
|
else
|
|
{
|
|
player.Message(MessageHud.MessageType.Center, "$msg_wontwork");
|
|
return false;
|
|
}
|
|
|
|
if (room <= 0)
|
|
{
|
|
player.Message(MessageHud.MessageType.Center, "$msg_itsfull");
|
|
return false;
|
|
}
|
|
|
|
int taken = Mathf.Min(Mathf.Max(1, item.m_stack), room);
|
|
player.Message(MessageHud.MessageType.Center, $"$msg_added {item.m_shared.m_name} x{taken}");
|
|
inventory.RemoveItem(item, taken);
|
|
|
|
m_nview.InvokeRPC("RoV_SkelFeed", prefabName, taken);
|
|
return true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// The new command: every skeleton of this pile follows, or every one of them comes home. One
|
|
/// click for the line, decided by whether any of them is already out.
|
|
/// </summary>
|
|
private bool ToggleGarrison(Player player)
|
|
{
|
|
List<RaisedThrall> bound = RaisedThrall.BoundTo(transform.position);
|
|
if (bound.Count == 0)
|
|
{
|
|
player.Message(MessageHud.MessageType.Center, ModText.Get("rov_msg_skeleton_nothing_standing_yet_wants_bone"));
|
|
return false;
|
|
}
|
|
|
|
bool anyFollowing = false;
|
|
foreach (RaisedThrall thrall in bound)
|
|
{
|
|
if (thrall.IsFollowing(player)) { anyFollowing = true; break; }
|
|
}
|
|
|
|
int moved = 0;
|
|
foreach (RaisedThrall thrall in bound)
|
|
{
|
|
// announce: false - one message for the line, not one per skeleton.
|
|
if (thrall.SetFollowing(player, !anyFollowing, announce: false)) moved++;
|
|
}
|
|
|
|
if (moved == 0)
|
|
{
|
|
// Every one of them refused, which for these means the player is not a Skeleton.
|
|
player.Message(MessageHud.MessageType.Center, ModText.Get("rov_msg_skeleton_these_bones_answer_only_their"));
|
|
return false;
|
|
}
|
|
|
|
player.Message(MessageHud.MessageType.Center, (anyFollowing ? ModText.Get("rov_msg_skeleton_return_pile", moved) : ModText.Get("rov_msg_skeleton_rise_follow", moved)));
|
|
return true;
|
|
}
|
|
|
|
private bool TryUpgrade(Player player, Inventory inventory, ItemDrop.ItemData item)
|
|
{
|
|
if (IsUpgraded())
|
|
{
|
|
player.Message(MessageHud.MessageType.Center, ModText.Get("rov_msg_skeleton_has_already_had_one"));
|
|
return false;
|
|
}
|
|
|
|
if (BossProgressionManager.GetCurrentProgressionState() < SkeletonBonePile.UpgradeProgressionState)
|
|
{
|
|
player.Message(MessageHud.MessageType.Center, ModText.Get("rov_msg_skeleton_skull_will_not_wake_something"));
|
|
return false;
|
|
}
|
|
|
|
inventory.RemoveItem(item, 1);
|
|
m_nview.InvokeRPC("RoV_SkelUpgrade");
|
|
player.Message(MessageHud.MessageType.Center, ModText.Get("rov_msg_skeleton_pile_deepens_rotten_will_stand"));
|
|
return true;
|
|
}
|
|
|
|
// ---------------------------------------------------------------- accounting
|
|
|
|
private void RPC_Feed(long sender, string prefabName, int count)
|
|
{
|
|
if (!m_nview.IsOwner()) return;
|
|
if (count < 1) count = 1;
|
|
|
|
if (prefabName == SkeletonBonePile.RancidTrophy)
|
|
{
|
|
if (!IsUpgraded()) return;
|
|
SetSlots(SkeletonBonePile.KindRancid,
|
|
Mathf.Min(RancidCap(), GetSlots(SkeletonBonePile.KindRancid) + count));
|
|
return;
|
|
}
|
|
|
|
if (prefabName != SkeletonBonePile.BonePrefab) return;
|
|
|
|
int bones = m_nview.GetZDO().GetInt(KeyBones) + count;
|
|
|
|
// Melee places fill first, then the archers'. A loop rather than a single test so a whole
|
|
// stack cannot overflow into bones that are never counted.
|
|
while (bones >= SkeletonBonePile.BonesPerSlot && PaidSlots() < TotalCap())
|
|
{
|
|
bones -= SkeletonBonePile.BonesPerSlot;
|
|
|
|
if (GetSlots(SkeletonBonePile.KindMelee) < MeleeCap())
|
|
{
|
|
SetSlots(SkeletonBonePile.KindMelee, GetSlots(SkeletonBonePile.KindMelee) + 1);
|
|
}
|
|
else
|
|
{
|
|
SetSlots(SkeletonBonePile.KindRanged, GetSlots(SkeletonBonePile.KindRanged) + 1);
|
|
}
|
|
}
|
|
|
|
m_nview.GetZDO().Set(KeyBones, bones);
|
|
}
|
|
|
|
private void RPC_Upgrade(long sender)
|
|
{
|
|
if (!m_nview.IsOwner()) return;
|
|
m_nview.GetZDO().Set(KeyUpgraded, true);
|
|
}
|
|
|
|
private void UpdatePile()
|
|
{
|
|
if (m_nview == null || !m_nview.IsValid() || !m_nview.IsOwner()) return;
|
|
|
|
string empty = FirstEmptyKind();
|
|
if (empty == null)
|
|
{
|
|
m_respawnTimer = 0f;
|
|
return;
|
|
}
|
|
|
|
m_respawnTimer += 2f; // the tick interval
|
|
if (m_respawnTimer < RespawnSeconds()) return;
|
|
m_respawnTimer = 0f;
|
|
|
|
Spawn(empty);
|
|
}
|
|
|
|
/// <summary>A kind that has a paid slot with nobody standing in it, or null. Rotten first -
|
|
/// they are the scarcest and the reason to upgrade.</summary>
|
|
private string FirstEmptyKind()
|
|
{
|
|
Dictionary<string, int> alive = CountAlive();
|
|
|
|
if (alive[SkeletonBonePile.KindRancid] < GetSlots(SkeletonBonePile.KindRancid)) return SkeletonBonePile.KindRancid;
|
|
if (alive[SkeletonBonePile.KindMelee] < GetSlots(SkeletonBonePile.KindMelee)) return SkeletonBonePile.KindMelee;
|
|
if (alive[SkeletonBonePile.KindRanged] < GetSlots(SkeletonBonePile.KindRanged)) return SkeletonBonePile.KindRanged;
|
|
return null;
|
|
}
|
|
|
|
private Dictionary<string, int> CountAlive()
|
|
{
|
|
Dictionary<string, int> alive = new Dictionary<string, int>
|
|
{
|
|
{ SkeletonBonePile.KindMelee, 0 },
|
|
{ SkeletonBonePile.KindRanged, 0 },
|
|
{ SkeletonBonePile.KindRancid, 0 },
|
|
};
|
|
|
|
foreach (RaisedThrall thrall in RaisedThrall.BoundTo(transform.position))
|
|
{
|
|
if (thrall.Kind != null && alive.ContainsKey(thrall.Kind)) alive[thrall.Kind]++;
|
|
}
|
|
return alive;
|
|
}
|
|
|
|
private void Spawn(string kind)
|
|
{
|
|
string prefabName =
|
|
kind == SkeletonBonePile.KindRancid ? SkeletonBonePile.ThrallRancidName :
|
|
kind == SkeletonBonePile.KindRanged ? SkeletonBonePile.ThrallRangedName :
|
|
SkeletonBonePile.ThrallMeleeName;
|
|
|
|
GameObject prefab = ZNetScene.instance != null ? ZNetScene.instance.GetPrefab(prefabName) : null;
|
|
if (prefab == null)
|
|
{
|
|
Jotunn.Logger.LogWarning($"[Skeleton] No '{prefabName}' in ZNetScene; the pile cannot raise anything.");
|
|
return;
|
|
}
|
|
|
|
Vector3 offset = UnityEngine.Random.insideUnitSphere * 2f;
|
|
offset.y = 0f;
|
|
Vector3 position = transform.position + offset + Vector3.up * 0.5f;
|
|
|
|
GameObject spawned = Instantiate(prefab, position, Quaternion.Euler(0f, UnityEngine.Random.Range(0, 360), 0f));
|
|
RaisedThrall thrall = spawned.GetComponent<RaisedThrall>();
|
|
if (thrall != null) thrall.Bind(transform.position);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Instantly, unlike the body pile's minute. The garrison rebuilds itself for free forever, so
|
|
/// the pile being broken has to be an immediate off switch or there is no counterweight at all.
|
|
/// MarkOrphaned still covers any that were unloaded when it fell - with a wither of zero they
|
|
/// die on their first tick home rather than lingering.
|
|
/// </summary>
|
|
private void OnDestroyed()
|
|
{
|
|
if (m_nview == null || !m_nview.IsOwner()) return;
|
|
|
|
List<RaisedThrall> bound = RaisedThrall.BoundTo(transform.position);
|
|
foreach (RaisedThrall thrall in bound)
|
|
{
|
|
thrall.MarkOrphaned();
|
|
thrall.Kill();
|
|
}
|
|
|
|
if (bound.Count > 0 && Player.m_localPlayer != null)
|
|
{
|
|
Player.m_localPlayer.Message(MessageHud.MessageType.Center,
|
|
ModText.Get("rov_msg_skeleton_pile_broken_fall_where_they", bound.Count));
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------- state and display
|
|
|
|
public bool IsUpgraded() => m_nview != null && m_nview.IsValid() && m_nview.GetZDO().GetBool(KeyUpgraded, false);
|
|
|
|
private int MeleeCap() => IsUpgraded() ? SkeletonBonePile.MeleeSlotsUpgraded : SkeletonBonePile.MeleeSlots;
|
|
|
|
private int RangedCap() => IsUpgraded() ? SkeletonBonePile.RangedSlotsUpgraded : SkeletonBonePile.RangedSlots;
|
|
|
|
private int RancidCap() => IsUpgraded() ? SkeletonBonePile.RancidSlotsUpgraded : SkeletonBonePile.RancidSlots;
|
|
|
|
private float RespawnSeconds() =>
|
|
IsUpgraded() ? SkeletonBonePile.RespawnSecondsUpgraded : SkeletonBonePile.RespawnSeconds;
|
|
|
|
/// <summary>Paid melee and archer places. Rotten ones are bought with trophies, not bone, so
|
|
/// they are counted separately and do not compete for the same twenty fragments.</summary>
|
|
private int PaidSlots() => GetSlots(SkeletonBonePile.KindMelee) + GetSlots(SkeletonBonePile.KindRanged);
|
|
|
|
private int TotalCap() => MeleeCap() + RangedCap();
|
|
|
|
private string Hover()
|
|
{
|
|
Dictionary<string, int> alive = CountAlive();
|
|
|
|
// A line per kind, each reading "standing / places bought / places possible", because the
|
|
// first version told the player none of that: the rotten line was hidden until the pile was
|
|
// upgraded, so there was no way to know the cap was two until ten trophies had gone in.
|
|
// Every shelf is now visible whether or not it can be used yet, and says why when it cannot.
|
|
string body =
|
|
ModText.Get("rov_hover_skeleton_melee_archers_rotten", alive[SkeletonBonePile.KindMelee], GetSlots(SkeletonBonePile.KindMelee), MeleeCap(), alive[SkeletonBonePile.KindRanged], GetSlots(SkeletonBonePile.KindRanged), RangedCap(), alive[SkeletonBonePile.KindRancid], GetSlots(SkeletonBonePile.KindRancid), RancidCap());
|
|
|
|
if (!IsUpgraded()) body += ModText.Get("rov_hover_skeleton_needs_greater_cursed_skull");
|
|
|
|
int bonesToward = m_nview.GetZDO().GetInt(KeyBones);
|
|
int placesLeft = TotalCap() - PaidSlots();
|
|
body += (placesLeft > 0 ? ModText.Get("rov_hover_skeleton_bone_toward_next_places", bonesToward, SkeletonBonePile.BonesPerSlot, placesLeft) : ModText.Get("rov_hover_skeleton_every_place_bought"));
|
|
|
|
if (m_respawnTimer > 0f)
|
|
{
|
|
int left = Mathf.Max(1, Mathf.CeilToInt(RespawnSeconds() - m_respawnTimer));
|
|
body += ModText.Get("rov_hover_skeleton_next_rises_s", left);
|
|
}
|
|
|
|
body += ModText.Get("rov_hover_skeleton_bone_hand_buy_place_empty");
|
|
|
|
return Localization.instance.Localize($"{SkeletonBonePile.PieceDisplayName} ({body})");
|
|
}
|
|
|
|
// ---------------------------------------------------------------- ZDO accessors
|
|
|
|
private int GetSlots(string kind)
|
|
{
|
|
if (m_nview == null || !m_nview.IsValid()) return 0;
|
|
return m_nview.GetZDO().GetInt(KeyFor(kind));
|
|
}
|
|
|
|
private void SetSlots(string kind, int value)
|
|
{
|
|
if (m_nview != null && m_nview.IsValid()) m_nview.GetZDO().Set(KeyFor(kind), Mathf.Max(0, value));
|
|
}
|
|
|
|
private static string KeyFor(string kind)
|
|
{
|
|
if (kind == SkeletonBonePile.KindRanged) return KeySlotsRanged;
|
|
if (kind == SkeletonBonePile.KindRancid) return KeySlotsRancid;
|
|
return KeySlotsMelee;
|
|
}
|
|
}
|
|
}
|