"Beehives per Aura" was bound into the config and then read by nobody. SvermConfigManagement.Beehives had no callers and neither did the constant behind it, so the entry described a limit that did not exist and a player could raise thirty hives in one aura and get thirty workers. SweepAura is two passes now, with the cap between them. The first applies to hives already taken and counts them - that maintenance is not skippable, it is what survives a zone reload - and only then are new candidates considered. One pass would have let the order the physics query happens to return decide whether a hive counted against the cap or was measured by it. The minute keeps running on a hive that does not fit today, so when a taken hive is destroyed the one that has waited longest is claimed on the next sweep instead of starting over; lowering the cap never hands a hive back. Three limits are now the player's: Aura Radius, Nests per Radius and Nest Spacing Radius. PieceDensityLimit.Register takes a snapshot of its numbers, so the Hive Market and the Brood Mound both watch their entries and re-register when one moves - Register replaces an entry rather than stacking a second limit on the same piece. All three are clamped, and the reason is not tidiness: Register REFUSES a radius of zero or a maximum below one, and a refused limit is no limit at all. A player typing 0 into "Nests per Radius" to mean "no nests" would have been handed unlimited nests. Every player-facing string that stated the old numbers now reads the live ones - the two build refusals, the orphaned market's message and hover, and the two Compendium lines. The nest's hover shows the cap next to the count, so moving the knob has visible effect. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
545 lines
25 KiB
C#
545 lines
25 KiB
C#
using System.Collections.Generic;
|
|
using HarmonyLib;
|
|
using UnityEngine;
|
|
|
|
namespace RacesOfValheim
|
|
{
|
|
/// <summary>
|
|
/// The two mouths of the nest, and the window behind one of them.
|
|
///
|
|
/// FIRST PASS, AND WHY IT WAS THROWN AWAY. Feeding used to be a button in a second column of
|
|
/// the vanilla store, cloned the way FactionMerchantSellPanel clones one. In game the window
|
|
/// came up EMPTY and the button did nothing you could click - the column is drawn outside the
|
|
/// panel that clips it, and that panel's own sell button sells for coins, which a hive does not
|
|
/// have. Both problems disappear if the feeding never goes through a UI at all.
|
|
///
|
|
/// So the nest wears two hives instead. The one at its foot is the STOMACH: press E and it
|
|
/// takes a whole stack out of your inventory. The one up top is the MARKET: press E and the
|
|
/// vanilla store opens, which is where the upgrades of 20.4 will hang when they are written.
|
|
/// The store's own sell button is switched off while a hive's window is open.
|
|
///
|
|
/// Feeding reads the INVENTORY and never the hand, which was the point of section 20.1: food is
|
|
/// a consumable, it never reaches the weapon slot, and "press E holding meat" only ever fed the
|
|
/// player.
|
|
/// </summary>
|
|
public static class SvermHiveStore
|
|
{
|
|
/// <summary>
|
|
/// Opens the store standing at <paramref name="host"/>, spending the tank of
|
|
/// <paramref name="hive"/>.
|
|
///
|
|
/// THE TRADER LIVES ON THE BENCH AND NOT ON THE NEST, and that is not tidiness either.
|
|
/// StoreGui.Update measures the player against the TRADER's transform and closes the window
|
|
/// past m_hideDistance - so a trader left on the nest would slam the window shut the moment
|
|
/// you used a bench standing anywhere but on top of it. The bench carries the trader; the
|
|
/// nest it points at carries the biomass.
|
|
///
|
|
/// It goes on a CHILD of the bench for a second reason: Trader is an Interactable and so is
|
|
/// the bench, and vanilla Player.Interact resolves its target with
|
|
/// GetComponentInParent<Interactable>, which returns whichever implementation happens to
|
|
/// sit first in the component list. The Factions module lost a day to exactly that ambiguity
|
|
/// (see FactionMerchantInteractPatch). A child with no collider is never the hovered object,
|
|
/// so it never enters the race.
|
|
/// </summary>
|
|
public static bool Open(GameObject host, SvermHiveBehaviour hive, Player player)
|
|
{
|
|
if (host == null || hive == null || player == null || StoreGui.instance == null) return false;
|
|
|
|
Trader trader = Mount(host, hive);
|
|
if (trader == null) return false;
|
|
|
|
StoreGui.instance.Show(trader);
|
|
return true;
|
|
}
|
|
|
|
private static Trader Mount(GameObject host, SvermHiveBehaviour hive)
|
|
{
|
|
SvermHiveShop shop = host.GetComponentInChildren<SvermHiveShop>(true);
|
|
if (shop != null)
|
|
{
|
|
// Re-bound on every visit: the nest a bench answers to is whichever one is nearest
|
|
// TODAY, and nests can be torn down and raised again around a bench that never moved.
|
|
shop.Hive = hive;
|
|
return shop.GetComponent<Trader>();
|
|
}
|
|
|
|
GameObject holder = new GameObject("SvermHiveMerchant");
|
|
holder.transform.SetParent(host.transform, false);
|
|
|
|
shop = holder.AddComponent<SvermHiveShop>();
|
|
shop.Hive = hive;
|
|
|
|
Trader trader = holder.AddComponent<Trader>();
|
|
trader.m_name = SvermHive.DisplayName;
|
|
|
|
// DISABLED ON PURPOSE, and this is the load-bearing line of the file. Trader was written
|
|
// for Haldor, who is a creature with an animator: Trader.Update() calls
|
|
// m_animator.SetBool("Stand", false) with no null check whenever no player is nearby, and
|
|
// Trader.Start() calls InvokeRepeating("RandomTalk", m_randomTalkInterval, ...) with an
|
|
// interval of zero on a component nobody authored in the editor. On a building both of
|
|
// those throw. A disabled component runs neither - and StoreGui needs neither, because
|
|
// Show() only reads fields off the Trader and asks it for its item list.
|
|
trader.enabled = false;
|
|
|
|
// Filled rather than assumed: these are serialized fields, and what a runtime
|
|
// AddComponent leaves in them is the constructor's business, not the editor's.
|
|
trader.m_items = new List<Trader.TradeItem>();
|
|
trader.m_useItems = new List<Trader.TraderUseItem>();
|
|
trader.m_randomTalk = new List<string>();
|
|
trader.m_randomGreets = new List<string>();
|
|
trader.m_randomGoodbye = new List<string>();
|
|
trader.m_randomStartTrade = new List<string>();
|
|
trader.m_randomBuy = new List<string>();
|
|
trader.m_randomSell = new List<string>();
|
|
|
|
return trader;
|
|
}
|
|
|
|
/// <summary>The nest behind the store window, or null if the window is not a hive's.</summary>
|
|
public static SvermHiveBehaviour ActiveHive(StoreGui gui)
|
|
{
|
|
Trader trader = FactionMerchantRuntime.GetActiveTrader(gui);
|
|
if (trader == null) return null;
|
|
|
|
SvermHiveShop shop = ((Component)trader).GetComponent<SvermHiveShop>();
|
|
return shop != null ? shop.Hive : null;
|
|
}
|
|
|
|
// ─── Feeding ─────────────────────────────────────────────────────────
|
|
|
|
/// <summary>
|
|
/// One press, one stack.
|
|
///
|
|
/// A stack and not the whole pack: the player can see what left, one press at a time, and a
|
|
/// misplaced E costs a stack of wood rather than the larder. The first thing in the
|
|
/// inventory the hive will eat is the thing it takes, so the order on screen is the order it
|
|
/// goes in.
|
|
///
|
|
/// Returns true if it did anything at all - the messages are the honest part, since a nest
|
|
/// that quietly does nothing is what sent the last pass back.
|
|
/// </summary>
|
|
public static bool FeedOneStack(SvermHiveBehaviour hive, Player player)
|
|
{
|
|
if (hive == null || player == null) return false;
|
|
|
|
Inventory inventory = player.GetInventory();
|
|
if (inventory == null) return false;
|
|
|
|
float room = SvermBiomass.Space(hive.transform);
|
|
if (room <= 0f)
|
|
{
|
|
player.Message(MessageHud.MessageType.Center, "The hive is full. Give it time to digest.");
|
|
return true;
|
|
}
|
|
|
|
foreach (ItemDrop.ItemData item in new List<ItemDrop.ItemData>(inventory.GetAllItems()))
|
|
{
|
|
if (item == null || item.m_stack <= 0) continue;
|
|
|
|
float perUnit = SvermBiomass.ValueOf(item);
|
|
if (perUnit <= 0f) continue;
|
|
|
|
// Not "does the stack fit" but "how much of it does": one royal jelly's worth of room
|
|
// should still take one royal jelly.
|
|
int units = Mathf.Min(item.m_stack, Mathf.FloorToInt(room / perUnit));
|
|
if (units <= 0) continue;
|
|
|
|
string name = Localization.instance.Localize(item.m_shared.m_name);
|
|
float fed = SvermBiomass.Swallow(hive.transform, units * perUnit);
|
|
inventory.RemoveItem(item, units);
|
|
|
|
player.Message(MessageHud.MessageType.TopLeft,
|
|
$"{name} x{units} -> +{fed:0} biomass, digesting");
|
|
return true;
|
|
}
|
|
|
|
player.Message(MessageHud.MessageType.Center,
|
|
"Nothing here it will eat. Food, wood and resin - honey and royal jelly are medicine.");
|
|
return true;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Marker on the child that carries the nest's Trader. Everything else reads it to answer "is
|
|
/// the open store window a hive's, and if so, whose".
|
|
/// </summary>
|
|
public class SvermHiveShop : MonoBehaviour
|
|
{
|
|
public SvermHiveBehaviour Hive;
|
|
}
|
|
|
|
// ─── The two mouths ──────────────────────────────────────────────────────
|
|
|
|
/// <summary>
|
|
/// Shared half of the two hives bolted to the nest: find the nest, refuse anyone who is not a
|
|
/// Sverm, and show the tank.
|
|
///
|
|
/// EACH MOUTH NEEDS ITS OWN COLLIDER, and that is not decoration. Player.FindHoverObject asks
|
|
/// hit.collider.GetComponent<Hoverable> - GetComponent on the collider's own GameObject, not
|
|
/// GetComponentInParent - and stops at the first collider the ray meets. So what the player is
|
|
/// pointing at is decided entirely by which collider is in front, and a mouth with no collider
|
|
/// of its own can never be pointed at. SvermHive.MountMouth gives each one a sphere wide enough
|
|
/// to stand clear of the trunk.
|
|
/// </summary>
|
|
public abstract class SvermHiveMouth : MonoBehaviour, Hoverable, Interactable
|
|
{
|
|
protected SvermHiveBehaviour Hive => GetComponentInParent<SvermHiveBehaviour>();
|
|
|
|
protected abstract string Title { get; }
|
|
protected abstract string Prompt { get; }
|
|
|
|
protected abstract bool Use(SvermHiveBehaviour hive, Player player);
|
|
|
|
public bool Interact(Humanoid user, bool hold, bool alt)
|
|
{
|
|
if (hold) return false;
|
|
|
|
Player player = user as Player;
|
|
if (player == null || player != Player.m_localPlayer) return false;
|
|
|
|
SvermHiveBehaviour hive = Hive;
|
|
if (hive == null) return false;
|
|
|
|
if (!SvermVisuals.IsSvermPlayer(player))
|
|
{
|
|
player.Message(MessageHud.MessageType.Center, "The hive does not know you.");
|
|
return true;
|
|
}
|
|
|
|
return Use(hive, player);
|
|
}
|
|
|
|
public bool UseItem(Humanoid user, ItemDrop.ItemData item) => false;
|
|
|
|
public string GetHoverName() => Title;
|
|
|
|
public string GetHoverText()
|
|
{
|
|
SvermHiveBehaviour hive = Hive;
|
|
if (hive == null) return Title;
|
|
|
|
return $"{Title}\n" +
|
|
SvermHiveReadout.Tank(hive.transform) +
|
|
$"[<color=yellow><b>$KEY_Use</b></color>] {Prompt}";
|
|
}
|
|
}
|
|
|
|
/// <summary>The hive at the foot of the nest. Press E, a stack goes in.</summary>
|
|
public class SvermHiveStomach : SvermHiveMouth
|
|
{
|
|
protected override string Title => "Hive Stomach";
|
|
protected override string Prompt => "Feed it a stack";
|
|
|
|
protected override bool Use(SvermHiveBehaviour hive, Player player)
|
|
{
|
|
return SvermHiveStore.FeedOneStack(hive, player);
|
|
}
|
|
}
|
|
|
|
// ─── The market, a building of its own ───────────────────────────────────
|
|
|
|
/// <summary>
|
|
/// The Hive Market: a bench you raise inside a nest's ten metres, and the only door to the shop.
|
|
///
|
|
/// IT WAS A SECOND MOUTH ON THE NEST and it never worked. On the trunk's measured crown it stood
|
|
/// eight metres above the player; moved to a reachable height, the .cfg still held the old zero
|
|
/// from the launch before, so it sat inside the stomach's sphere and the ray found the stomach
|
|
/// every time. The lesson is not the numbers - it is that a mouth on a shared body is always a
|
|
/// race between colliders, and this mod already has two stores that avoided that race by being
|
|
/// their own building: DvergarBanco and TrolTotem.
|
|
///
|
|
/// It owns no biomass. It finds the nest it stands in and spends THAT tank, so the serbatoio
|
|
/// stays one number in one place no matter how many benches end up around it.
|
|
/// </summary>
|
|
public static class SvermHiveMarketPiece
|
|
{
|
|
public const string PieceName = "SvermHiveMarket";
|
|
public const string DisplayName = "Hive Market";
|
|
|
|
/// <summary>Scenery only, and checked rather than trusted - see SvermHive.MouthCandidates.</summary>
|
|
private static readonly string[] SourceCandidates =
|
|
{
|
|
"CreepProp_egg_hanging01",
|
|
"CreepProp_egg_hanging02",
|
|
"Creeppillar_half_shorttendrils",
|
|
"CreepProp_hanging01",
|
|
};
|
|
|
|
public static void Register()
|
|
{
|
|
// A REAL PIECE as the body and a BORROWED MODEL as the look, which is TrolTotem's recipe
|
|
// line for line - the one store-building in this mod that is known to work in game.
|
|
// Cloning scenery instead would have meant taking whatever pivot its author used: a
|
|
// hanging egg sac hangs, and a hanging thing used as a ground piece floats or sinks.
|
|
// ModelBorrow measures the mesh and stands it on the piece's own origin, so "on the
|
|
// ground" needs no guess.
|
|
GameObject prefab = Jotunn.Managers.PrefabManager.Instance.CreateClonedPrefab(PieceName, "piece_workbench");
|
|
if (prefab == null)
|
|
{
|
|
Jotunn.Logger.LogWarning("[Sverm] Could not clone piece_workbench; the market is not registered.");
|
|
return;
|
|
}
|
|
|
|
// Down to a placeable shell: no station, no crafting, no furniture.
|
|
foreach (MonoBehaviour behaviour in prefab.GetComponentsInChildren<MonoBehaviour>(true))
|
|
{
|
|
if (behaviour == null) continue;
|
|
if (behaviour is Piece || behaviour is ZNetView || behaviour is WearNTear) continue;
|
|
Object.DestroyImmediate(behaviour);
|
|
}
|
|
foreach (Renderer renderer in prefab.GetComponentsInChildren<Renderer>(true))
|
|
{
|
|
if (renderer != null) renderer.enabled = false; // the bench's own mesh, hidden
|
|
}
|
|
|
|
AswidBloodRefinery.StripOffensive(prefab, PieceName);
|
|
|
|
string sourceName = null;
|
|
foreach (string candidate in SourceCandidates)
|
|
{
|
|
GameObject source = Jotunn.Managers.PrefabManager.Cache.GetPrefab<GameObject>(candidate);
|
|
if (source == null) continue;
|
|
if (!SvermHive.IsSafeScenery(source, candidate)) continue;
|
|
|
|
sourceName = candidate;
|
|
break;
|
|
}
|
|
|
|
if (sourceName == null)
|
|
{
|
|
Jotunn.Logger.LogWarning("[Sverm] No safe scenery to dress the market with (" +
|
|
string.Join(", ", SourceCandidates) + "); it is registered " +
|
|
"anyway and will be an invisible counter rather than none.");
|
|
}
|
|
else
|
|
{
|
|
ModelBorrow.Attach(prefab.transform, "MarketModel", sourceName,
|
|
Vector3.zero, Quaternion.identity, SvermConfigManagement.MarketSize, "Sverm");
|
|
}
|
|
|
|
Piece piece = prefab.GetComponent<Piece>() ?? prefab.AddComponent<Piece>();
|
|
piece.m_craftingStation = null;
|
|
piece.m_resources = new Piece.Requirement[0];
|
|
piece.m_name = DisplayName;
|
|
piece.m_description = "Where the colony trades. It spends the tank of the nest it stands in.";
|
|
piece.m_groundPiece = true;
|
|
piece.m_groundOnly = true;
|
|
piece.m_canBeRemoved = true;
|
|
|
|
if (prefab.GetComponent<WearNTear>() == null)
|
|
{
|
|
WearNTear wear = prefab.AddComponent<WearNTear>();
|
|
wear.m_health = 500f;
|
|
wear.m_noRoofWear = true;
|
|
wear.m_noSupportWear = true;
|
|
wear.m_destroyedEffect = new EffectList();
|
|
wear.m_hitEffect = new EffectList();
|
|
}
|
|
|
|
// The workbench this is cloned from brings a persistent ZNetView with it, so this is
|
|
// belt as well as braces - but it is the line the NEST turned out to need after players
|
|
// reported hives gone at world load, and a counter that saves only because of what
|
|
// it was copied from is one refactor away from not saving at all.
|
|
ZNetView view = prefab.GetComponent<ZNetView>() ?? prefab.AddComponent<ZNetView>();
|
|
view.m_persistent = true;
|
|
|
|
prefab.AddComponent<SvermHiveMarket>();
|
|
|
|
Jotunn.Managers.PieceManager.Instance.AddPiece(new Jotunn.Entities.CustomPiece(prefab, fixReference: false,
|
|
new Jotunn.Configs.PieceConfig
|
|
{
|
|
Name = DisplayName,
|
|
Description = piece.m_description,
|
|
PieceTable = Jotunn.Configs.PieceTables.Hammer,
|
|
Category = "Crafting",
|
|
Icon = SvermHive.BorrowIcon("TrophySeeker") ?? SvermHive.BorrowIcon("TrophySeekerBrute") ??
|
|
SvermHive.BorrowIcon("Honey"),
|
|
|
|
// Cheap on purpose, and these two numbers are INVENTED - the design document
|
|
// never had this building in it. The market is not a gate on anything: the nest
|
|
// is the achievement, this is the counter you trade over.
|
|
Requirements = new[]
|
|
{
|
|
new Jotunn.Configs.RequirementConfig { Item = "Wood", Amount = 10, Recover = true },
|
|
new Jotunn.Configs.RequirementConfig { Item = "Resin", Amount = 5, Recover = true },
|
|
},
|
|
}));
|
|
|
|
// One counter to a nest. The radius is the nest's own aura, so "another market too close"
|
|
// and "inside this nest's aura" are the same circle measured from opposite ends.
|
|
//
|
|
// Register takes a SNAPSHOT of the radius, so the aura being configurable means this one
|
|
// has to be told when it changes - the gate below and the sweep read the live value on
|
|
// every call and need nothing. Re-registering is the documented way to do it: Register
|
|
// replaces the entry rather than stacking a second limit on the same piece.
|
|
RegisterMarketDensity();
|
|
|
|
if (SvermConfigManagement.AuraRadiusValue != null)
|
|
{
|
|
SvermConfigManagement.AuraRadiusValue.SettingChanged += (sender, args) => RegisterMarketDensity();
|
|
}
|
|
|
|
PieceDensityLimit.RegisterGate(PieceName, (player, position) =>
|
|
{
|
|
if (player == null) return false;
|
|
|
|
if (!SvermVisuals.IsSvermPlayer(player))
|
|
{
|
|
player.Message(MessageHud.MessageType.Center, "Only the Sverm can raise a market.");
|
|
return false;
|
|
}
|
|
|
|
if (SvermHive.NearestNest(position, SvermConfigManagement.AuraRadius) == null)
|
|
{
|
|
player.Message(MessageHud.MessageType.Center,
|
|
$"A market has to stand within {SvermConfigManagement.AuraRadius:0} metres of a hive.");
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
});
|
|
|
|
Jotunn.Logger.LogInfo($"[Sverm] Registered '{PieceName}' from '{sourceName}'.");
|
|
}
|
|
|
|
/// <summary>Re-read the aura and cap the market to it. Safe to call any number of times.</summary>
|
|
private static void RegisterMarketDensity()
|
|
{
|
|
PieceDensityLimit.Register(PieceName, SvermConfigManagement.AuraRadius, 1,
|
|
"This hive already has a market.");
|
|
}
|
|
}
|
|
|
|
/// <summary>The bench itself. Press E, the store opens on the nest it stands in.</summary>
|
|
public class SvermHiveMarket : MonoBehaviour, Hoverable, Interactable
|
|
{
|
|
private SvermHiveBehaviour Nest => SvermHive.NearestNest(transform.position, SvermConfigManagement.AuraRadius);
|
|
|
|
public bool Interact(Humanoid user, bool hold, bool alt)
|
|
{
|
|
if (hold) return false;
|
|
|
|
Player player = user as Player;
|
|
if (player == null || player != Player.m_localPlayer) return false;
|
|
|
|
if (!SvermVisuals.IsSvermPlayer(player))
|
|
{
|
|
player.Message(MessageHud.MessageType.Center, "The hive does not know you.");
|
|
return true;
|
|
}
|
|
|
|
// Asked again at every press rather than remembered: the nest this counter answered to
|
|
// last week may have been torn down since, and a market quietly spending a tank that no
|
|
// longer exists is worse than one that says so.
|
|
SvermHiveBehaviour nest = Nest;
|
|
if (nest == null)
|
|
{
|
|
player.Message(MessageHud.MessageType.Center,
|
|
$"No hive within {SvermConfigManagement.AuraRadius:0} metres. This counter is dead.");
|
|
return true;
|
|
}
|
|
|
|
return SvermHiveStore.Open(gameObject, nest, player);
|
|
}
|
|
|
|
public bool UseItem(Humanoid user, ItemDrop.ItemData item) => false;
|
|
|
|
public string GetHoverName() => SvermHiveMarketPiece.DisplayName;
|
|
|
|
public string GetHoverText()
|
|
{
|
|
SvermHiveBehaviour nest = Nest;
|
|
if (nest == null)
|
|
{
|
|
return $"{SvermHiveMarketPiece.DisplayName}\n" +
|
|
$"No hive within {SvermConfigManagement.AuraRadius:0} metres.";
|
|
}
|
|
|
|
return $"{SvermHiveMarketPiece.DisplayName}\n" +
|
|
SvermHiveReadout.Tank(nest.transform) +
|
|
"[<color=yellow><b>$KEY_Use</b></color>] Trade with the hive";
|
|
}
|
|
}
|
|
|
|
/// <summary>The tank, worded once, for every mouth and for the trunk between them.</summary>
|
|
public static class SvermHiveReadout
|
|
{
|
|
public static string Tank(Transform nest)
|
|
{
|
|
return $"Biomass {SvermBiomass.Bank(nest):0} / {SvermBiomass.Capacity(nest):0}\n" +
|
|
$"Digesting {SvermBiomass.Digesting(nest):0}\n" +
|
|
$"Brood eggs {SvermBroodEggs.Count(nest)} / {SvermBroodEggs.Cap(nest)}\n";
|
|
}
|
|
}
|
|
|
|
// ─── The store window, made fit for a hive ───────────────────────────────
|
|
|
|
/// <summary>
|
|
/// Two edits to the vanilla window while a hive owns it, and no new UI whatsoever.
|
|
///
|
|
/// THE SELL BUTTON IS SWITCHED OFF, at the player's call and for a good reason of its own: it
|
|
/// sells the first valuable thing in the pack for COINS, which is nonsense against a hive that
|
|
/// has no coins and never wanted the amber. Switched off rather than destroyed - StoreGui is one
|
|
/// object shared with Haldor, the faction merchants and the war totem, so it has to come back
|
|
/// the moment the window belongs to somebody else.
|
|
///
|
|
/// WHERE THE COINS GO, the hive's own three numbers go instead. StoreGui.Update writes the coin
|
|
/// count into that label every frame, so this writes over it afterwards.
|
|
/// </summary>
|
|
[HarmonyPatch(typeof(StoreGui), "Update")]
|
|
public static class SvermHiveStoreWindowPatch
|
|
{
|
|
public static void Postfix(StoreGui __instance)
|
|
{
|
|
SvermHiveBehaviour hive = SvermHiveStore.ActiveHive(__instance);
|
|
|
|
if (__instance.m_sellButton != null)
|
|
{
|
|
GameObject button = __instance.m_sellButton.gameObject;
|
|
bool wanted = hive == null;
|
|
if (button.activeSelf != wanted) button.SetActive(wanted);
|
|
}
|
|
|
|
if (hive == null || __instance.m_coinText == null) return;
|
|
|
|
float bank = SvermBiomass.Bank(hive.transform);
|
|
float digesting = SvermBiomass.Digesting(hive.transform);
|
|
float capacity = SvermBiomass.Capacity(hive.transform);
|
|
|
|
__instance.m_coinText.text = digesting > 0f
|
|
? $"{bank:0} / {capacity:0} (+{digesting:0})"
|
|
: $"{bank:0} / {capacity:0}";
|
|
}
|
|
}
|
|
|
|
/// <summary>The same refusal at the other end, for a gamepad that reaches the sell action anyway.</summary>
|
|
[HarmonyPatch(typeof(StoreGui), "SellItem")]
|
|
public static class SvermHiveStoreSellItemPatch
|
|
{
|
|
public static bool Prefix(StoreGui __instance)
|
|
{
|
|
return SvermHiveStore.ActiveHive(__instance) == null;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Belt as well as braces on the disabled Trader in SvermHiveStore.Mount: if anything ever
|
|
/// enables that component - a mod, a future edit here - Trader.Update() would start
|
|
/// dereferencing an animator the nest does not have, every frame. One component lookup removes
|
|
/// the whole class of failure.
|
|
/// </summary>
|
|
[HarmonyPatch(typeof(Trader), "Update")]
|
|
public static class SvermHiveStoreTraderUpdatePatch
|
|
{
|
|
public static bool Prefix(Trader __instance)
|
|
{
|
|
return ((Component)__instance).GetComponent<SvermHiveShop>() == null;
|
|
}
|
|
}
|
|
|
|
// The empty-catalogue crash that used to kill the whole window is NOT guarded here: the war
|
|
// totem hit it first and StoreGuiEmptyCatalogueGuardPatch in Trol/TrolTotemStore.cs already
|
|
// covers every trader in the game, this one included. It is the reason the hive's window opens
|
|
// at all with nothing in its buy list, and a second prefix doing the same job would only make
|
|
// the log lie about who is holding the door.
|
|
}
|