The faction merchants' 90 jokes, their generic lines and their names now read from merchants.json. Merchant names use the game's own creature tokens where one matches, so they arrive translated in every language Valheim ships; the Dverg keeps a key of its own, since vanilla's token reads "Dvergr Rogue". The Dvergar and Trol troop names and terms, and the Sverm hive's goods, refusals, stage names and brood kinds, follow. Their panels fill TMP texts themselves, so they localize the names where they draw them. The jokes have English text only for now. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
489 lines
20 KiB
C#
489 lines
20 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using HarmonyLib;
|
|
using TMPro;
|
|
using UnityEngine;
|
|
using UnityEngine.UI;
|
|
|
|
namespace RacesOfValheim
|
|
{
|
|
/// <summary>
|
|
/// What the Hive Market sells, and the column it is sold from.
|
|
///
|
|
/// THE VANILLA BUY LIST CANNOT CARRY THIS. StoreGui's own column is a list of
|
|
/// Trader.TradeItem, every one of which is an ItemDrop that lands in your inventory when you pay
|
|
/// coin for it. The hive sells no items: it sells a stage of growth, which is a number on its
|
|
/// own ZDO. So the goods hang in a column of our own, cloned from the store's list element -
|
|
/// exactly what TrolTotemStore does for its warbands, down to sitting at m_listRoot's own
|
|
/// position and switching itself off when the window belongs to somebody else.
|
|
///
|
|
/// That position matters and it is the correction of a failed attempt: the first version of the
|
|
/// hive's panel put its column at m_listRoot's position PLUS 260 px, which is outside the panel
|
|
/// that clips it. It drew perfectly and nobody could see or click a single row of it.
|
|
///
|
|
/// PRICES ARE THE DOCUMENT'S, unchanged: 1000, 1500, 2000, each one the full tank of the stage
|
|
/// it buys you out of, so growing always empties the hive.
|
|
/// </summary>
|
|
public static class SvermHiveGoods
|
|
{
|
|
/// <summary>One thing the market sells.</summary>
|
|
public class Good
|
|
{
|
|
public string Id;
|
|
public string Name;
|
|
public float Price;
|
|
public string Icon;
|
|
public string Description;
|
|
|
|
/// <summary>Why this cannot be bought right now, or null when it can.</summary>
|
|
public Func<SvermHiveBehaviour, string> Refusal;
|
|
|
|
/// <summary>Hands over the goods. Only ever called after the price has been taken.</summary>
|
|
public Action<SvermHiveBehaviour> Deliver;
|
|
|
|
/// <summary>
|
|
/// How long before another of these, in seconds. A function and not a number because the
|
|
/// upgrades wait a GAME DAY, and how long a game day is belongs to the world rather than
|
|
/// to this table.
|
|
/// </summary>
|
|
public Func<float> Cooldown;
|
|
}
|
|
|
|
/// <summary>
|
|
/// The shelf: three stages, two stars, four troops.
|
|
///
|
|
/// NO VENOM COIL. Section 13's serpent turret was built and then taken out again at the
|
|
/// player's call - it is not on this shelf, there is no prefab for it, and it is not a thing
|
|
/// waiting to be finished. If it ever comes back it comes back as a new decision.
|
|
///
|
|
/// Stages first, because they are what unlocks the rest of the list.
|
|
/// </summary>
|
|
public static readonly List<Good> Shelf = BuildShelf();
|
|
|
|
private static List<Good> BuildShelf()
|
|
{
|
|
List<Good> shelf = new List<Good>
|
|
{
|
|
StageUpgrade(2, "TrophySeeker"),
|
|
StageUpgrade(3, "TrophySeekerBrute"),
|
|
StageUpgrade(4, "TrophySeekerQueen"),
|
|
|
|
Star(1, ModText.Get("rov_sverm_good_glands_name"), 800f, "TrophySeeker",
|
|
ModText.Get("rov_sverm_good_glands_desc")),
|
|
|
|
Star(2, ModText.Get("rov_sverm_good_hyperplasia_name"), 1600f, "TrophySeekerQueen",
|
|
ModText.Get("rov_sverm_good_hyperplasia_desc")),
|
|
};
|
|
|
|
foreach (SvermBrood.Kind kind in SvermBrood.Roster) shelf.Add(Troop(kind));
|
|
|
|
shelf.Add(BlisterTick());
|
|
|
|
return shelf;
|
|
}
|
|
|
|
/// <summary>
|
|
/// The bomb tick, which is the only thing on this shelf you buy ONCE and keep having.
|
|
/// Section 12: fifty biomass and an egg buy a slot, the slot is permanent, and whatever
|
|
/// stands in it comes back for free half a minute after it bursts.
|
|
/// </summary>
|
|
private static Good BlisterTick()
|
|
{
|
|
return new Good
|
|
{
|
|
Id = "blistertick",
|
|
Name = Localization.instance.Localize(SvermBlisterTick.DisplayName),
|
|
Price = SvermConfig.TickPrice,
|
|
Icon = "TrophyTick",
|
|
Description = ModText.Get("rov_sverm_good_tick_desc"),
|
|
|
|
Refusal = hive =>
|
|
{
|
|
int slots = SvermBlisterTick.SlotsOf(hive.transform);
|
|
if (slots >= SvermConfigManagement.BlisterTick)
|
|
{
|
|
return ModText.Get("rov_sverm_refusal_keeps", slots);
|
|
}
|
|
|
|
if (SvermBroodEggs.Count(hive.transform) < 1) return ModText.Get("rov_sverm_refusal_no_egg");
|
|
|
|
return null;
|
|
},
|
|
|
|
Deliver = hive =>
|
|
{
|
|
if (!SvermBroodEggs.Take(hive.transform, 1))
|
|
{
|
|
SvermBiomass.Refund(hive.transform, SvermConfig.TickPrice);
|
|
return;
|
|
}
|
|
|
|
SvermBlisterTick.BuySlot(hive.transform);
|
|
SvermBlisterTick.Hatch(hive);
|
|
},
|
|
|
|
// The tick has no queue of its own: the wait is the thirty seconds it takes to come
|
|
// back, and that is enforced at the nest rather than at the counter.
|
|
Cooldown = () => 0f,
|
|
};
|
|
}
|
|
|
|
/// <summary>
|
|
/// One step up the four stages. The price is the tank it empties, from section 10.1.
|
|
/// </summary>
|
|
private static Good StageUpgrade(int target, string icon)
|
|
{
|
|
int from = target - 1;
|
|
|
|
return new Good
|
|
{
|
|
Id = "stage" + target,
|
|
Name = Localization.instance.Localize(SvermHiveStage.NameOf(target)),
|
|
Price = SvermHiveStage.PriceToLeave(from),
|
|
Icon = icon,
|
|
Description = ModText.Get("rov_sverm_good_stage_desc", SvermHiveStage.NameOf(target),
|
|
SvermHiveStage.Capacity(target).ToString("0"), SvermHiveStage.Capacity(from).ToString("0")),
|
|
|
|
Refusal = hive =>
|
|
{
|
|
int stage = SvermHiveStage.Of(hive.transform);
|
|
if (stage > from) return ModText.Get("rov_sverm_refusal_grown_past");
|
|
if (stage < from) return ModText.Get("rov_sverm_refusal_stage_first", SvermHiveStage.NameOf(from));
|
|
return null;
|
|
},
|
|
|
|
Deliver = hive => SvermHiveStage.Advance(hive.transform),
|
|
|
|
Cooldown = () => DayLength() * SvermConfig.UpgradeCooldownDays,
|
|
};
|
|
}
|
|
|
|
/// <summary>
|
|
/// One of the two permanent star upgrades. They are a ladder: the glands before the
|
|
/// hyperplasia.
|
|
///
|
|
/// THE LADDER IS AN INVENTION. The document prices them separately and says nothing about
|
|
/// needing one for the other - but without it the cheap path to two stars is to skip the
|
|
/// eight hundred entirely, which makes the first upgrade a thing only a mistake buys.
|
|
/// </summary>
|
|
private static Good Star(int stars, string name, float price, string icon, string description)
|
|
{
|
|
return new Good
|
|
{
|
|
Id = "stars" + stars,
|
|
Name = name,
|
|
Price = price,
|
|
Icon = icon,
|
|
Description = description,
|
|
|
|
Refusal = hive =>
|
|
{
|
|
int have = SvermBroodStars.Of(hive.transform);
|
|
if (have >= stars) return ModText.Get("rov_sverm_refusal_already_breeds");
|
|
if (have < stars - 1) return ModText.Get("rov_sverm_refusal_one_star");
|
|
return null;
|
|
},
|
|
|
|
Deliver = hive => SvermBroodStars.Set(hive.transform, stars),
|
|
|
|
Cooldown = () => DayLength() * SvermConfig.UpgradeCooldownDays,
|
|
};
|
|
}
|
|
|
|
/// <summary>
|
|
/// One rung of the roster on sale. Costs biomass AND a brood egg, which is section 10.2's
|
|
/// two resources in parallel: the egg is the slot and grows back, the biomass is the price
|
|
/// and does not.
|
|
/// </summary>
|
|
private static Good Troop(SvermBrood.Kind kind)
|
|
{
|
|
return new Good
|
|
{
|
|
Id = "troop_" + kind.Id,
|
|
Name = Localization.instance.Localize(kind.Display),
|
|
Price = kind.Price,
|
|
Icon = kind.Icon,
|
|
Description = ModText.Get("rov_sverm_good_troop_desc", kind.Display, kind.Cap),
|
|
|
|
Refusal = hive =>
|
|
{
|
|
int stage = SvermHiveStage.Of(hive.transform);
|
|
if (stage < kind.Stage)
|
|
{
|
|
return ModText.Get("rov_sverm_refusal_stage_first", SvermHiveStage.NameOf(kind.Stage));
|
|
}
|
|
|
|
int alive = SvermBrood.CountAlive(hive, kind);
|
|
if (alive >= kind.Cap) return ModText.Get("rov_sverm_refusal_keeping", alive);
|
|
|
|
if (SvermBroodEggs.Count(hive.transform) < 1) return ModText.Get("rov_sverm_refusal_no_egg");
|
|
|
|
return null;
|
|
},
|
|
|
|
Deliver = hive =>
|
|
{
|
|
// The egg is taken here rather than in Buy, because it is this good's price and
|
|
// not every good's: an upgrade costs biomass and nothing else.
|
|
//
|
|
// And if the egg is gone between the refusal check and this line - which only two
|
|
// players at one nest can manage - the biomass goes back. A purchase that took
|
|
// the price and handed over nothing is the one outcome worth writing code for.
|
|
if (!SvermBroodEggs.Take(hive.transform, 1))
|
|
{
|
|
SvermBiomass.Refund(hive.transform, kind.Price);
|
|
return;
|
|
}
|
|
|
|
if (!SvermBrood.Hatch(hive, kind))
|
|
{
|
|
SvermBiomass.Refund(hive.transform, kind.Price);
|
|
}
|
|
},
|
|
|
|
Cooldown = () => kind.Cooldown,
|
|
};
|
|
}
|
|
|
|
// ─── Buying ──────────────────────────────────────────────────────────
|
|
|
|
/// <summary>
|
|
/// Why this good is greyed out, or null when it can be bought.
|
|
///
|
|
/// The order of the questions is the order the player would ask them: can I have it at all,
|
|
/// is it too soon, can I afford it.
|
|
/// </summary>
|
|
public static string RefusalFor(Good good, SvermHiveBehaviour hive)
|
|
{
|
|
if (good == null || hive == null) return ModText.Get("rov_sverm_refusal_no_hive");
|
|
|
|
string ownRefusal = good.Refusal != null ? good.Refusal(hive) : null;
|
|
if (ownRefusal != null) return ownRefusal;
|
|
|
|
long waitingSeconds = CooldownLeft(hive.transform, good);
|
|
if (waitingSeconds > 0L)
|
|
{
|
|
return waitingSeconds >= 60L
|
|
? ModText.Get("rov_sverm_refusal_working_m", waitingSeconds / 60)
|
|
: ModText.Get("rov_sverm_refusal_working_s", waitingSeconds);
|
|
}
|
|
|
|
if (SvermBiomass.Bank(hive.transform) < good.Price) return ModText.Get("rov_msg_sverm_not_enough_biomass_bank");
|
|
|
|
return null;
|
|
}
|
|
|
|
public static bool Buy(Good good, SvermHiveBehaviour hive, Player player)
|
|
{
|
|
string refusal = RefusalFor(good, hive);
|
|
if (refusal != null)
|
|
{
|
|
player?.Message(MessageHud.MessageType.Center, refusal);
|
|
return false;
|
|
}
|
|
|
|
// Paid first and delivered second, and never the other way round: Spend is the only
|
|
// thing here that can fail on a race with another client, and a hive that hands over a
|
|
// stage it was not paid for cannot be undone.
|
|
if (!SvermBiomass.Spend(hive.transform, good.Price))
|
|
{
|
|
player?.Message(MessageHud.MessageType.Center, ModText.Get("rov_msg_sverm_not_enough_biomass_bank"));
|
|
return false;
|
|
}
|
|
|
|
good.Deliver?.Invoke(hive);
|
|
StampCooldown(hive.transform, good.Id);
|
|
|
|
player?.Message(MessageHud.MessageType.Center, good.Name);
|
|
return true;
|
|
}
|
|
|
|
// ─── The day between purchases ───────────────────────────────────────
|
|
|
|
/// <summary>
|
|
/// How long this good still has to wait, on the world clock.
|
|
///
|
|
/// Section 20.4 asks for two different clocks and this is both of them: a GAME DAY between
|
|
/// upgrades, and a wait of its own for every troop - ten minutes for a Gjall, the rest
|
|
/// scaled by price. On the three stage upgrades nobody will ever see it, since each of them
|
|
/// can only be bought once; on the troops it is the pacing.
|
|
/// </summary>
|
|
private static long CooldownLeft(Transform nest, Good good)
|
|
{
|
|
ZNetView nview = nest != null ? nest.GetComponent<ZNetView>() : null;
|
|
if (nview == null || !nview.IsValid()) return 0L;
|
|
|
|
long stamped = nview.GetZDO().GetLong(CooldownKey(good.Id), 0L);
|
|
if (stamped <= 0L) return 0L;
|
|
|
|
float wait = good.Cooldown != null ? good.Cooldown() : 0f;
|
|
if (wait <= 0f) return 0L;
|
|
|
|
long ready = stamped + (long)wait;
|
|
long now = WorldSecond();
|
|
return now >= ready ? 0L : ready - now;
|
|
}
|
|
|
|
private static void StampCooldown(Transform nest, string id)
|
|
{
|
|
ZNetView nview = nest != null ? nest.GetComponent<ZNetView>() : null;
|
|
if (nview == null || !nview.IsValid()) return;
|
|
|
|
if (!nview.IsOwner()) nview.ClaimOwnership();
|
|
nview.GetZDO().Set(CooldownKey(id), WorldSecond());
|
|
}
|
|
|
|
private static string CooldownKey(string id) => "RacesOfValheim_SvermBought_" + id;
|
|
|
|
/// <summary>A day of game time in seconds. The world's own setting, not a hardcoded 1800.</summary>
|
|
private static float DayLength()
|
|
{
|
|
return EnvMan.instance != null ? EnvMan.instance.m_dayLengthSec : 1800f;
|
|
}
|
|
|
|
private static long WorldSecond()
|
|
{
|
|
return ZNet.instance != null ? (long)ZNet.instance.GetTimeSeconds() : 0L;
|
|
}
|
|
}
|
|
|
|
// ─── The column ──────────────────────────────────────────────────────────
|
|
|
|
[HarmonyPatch(typeof(StoreGui), "Awake")]
|
|
public static class SvermHiveGoodsSetupPatch
|
|
{
|
|
public static void Postfix(StoreGui __instance) => SvermHiveGoodsPanel.Create(__instance);
|
|
}
|
|
|
|
[HarmonyPatch(typeof(StoreGui), "FillList")]
|
|
public static class SvermHiveGoodsFillPatch
|
|
{
|
|
public static void Postfix(StoreGui __instance) => SvermHiveGoodsPanel.Refresh(__instance);
|
|
}
|
|
|
|
[HarmonyPatch(typeof(StoreGui), "Hide")]
|
|
public static class SvermHiveGoodsHidePatch
|
|
{
|
|
public static void Postfix() => SvermHiveGoodsPanel.Clear();
|
|
}
|
|
|
|
/// <summary>
|
|
/// The market's shelf on screen. Built the way TrolTotemStore builds the war totem's, which is
|
|
/// the one column in this mod that is known to draw where a player can see it.
|
|
/// </summary>
|
|
public static class SvermHiveGoodsPanel
|
|
{
|
|
private static RectTransform _root;
|
|
private static readonly List<GameObject> _rows = new List<GameObject>();
|
|
|
|
public static void Create(StoreGui gui)
|
|
{
|
|
if (gui == null || gui.m_listRoot == null)
|
|
{
|
|
Jotunn.Logger.LogWarning("[Sverm] StoreGui has no m_listRoot; the market's shelf cannot be built.");
|
|
return;
|
|
}
|
|
if (_root != null) return;
|
|
|
|
GameObject clone = UnityEngine.Object.Instantiate(gui.m_listRoot.gameObject, gui.m_listRoot.parent);
|
|
clone.name = "SvermHiveGoodsList";
|
|
_root = clone.GetComponent<RectTransform>();
|
|
|
|
// The vanilla list's OWN position. An offset from it - 260 px was the first guess - puts
|
|
// the column outside the panel that clips it, where it draws perfectly and invisibly.
|
|
_root.anchoredPosition = gui.m_listRoot.anchoredPosition;
|
|
|
|
foreach (Transform child in _root) UnityEngine.Object.Destroy(child.gameObject);
|
|
_root.gameObject.SetActive(false);
|
|
}
|
|
|
|
public static void Clear()
|
|
{
|
|
foreach (GameObject row in _rows) if (row != null) UnityEngine.Object.Destroy(row);
|
|
_rows.Clear();
|
|
|
|
if (_root != null) _root.gameObject.SetActive(false);
|
|
}
|
|
|
|
public static void Refresh(StoreGui gui)
|
|
{
|
|
Clear();
|
|
|
|
SvermHiveBehaviour hive = SvermHiveStore.ActiveHive(gui);
|
|
if (hive == null) return; // an ordinary merchant, or the war totem. Not ours.
|
|
|
|
if (_root == null)
|
|
{
|
|
Jotunn.Logger.LogWarning("[Sverm] The market's shelf was never built (did the patch on " +
|
|
"StoreGui.Awake fail?), so nothing can be drawn into it.");
|
|
return;
|
|
}
|
|
|
|
_root.gameObject.SetActive(true);
|
|
|
|
int row = 0;
|
|
foreach (SvermHiveGoods.Good good in SvermHiveGoods.Shelf)
|
|
{
|
|
BuildRow(gui, hive, good, row++);
|
|
}
|
|
|
|
float baseSize = Traverse.Create(gui).Field("m_itemlistBaseSize").GetValue<float>();
|
|
_root.SetSizeWithCurrentAnchors(RectTransform.Axis.Vertical, Mathf.Max(baseSize, row * gui.m_itemSpacing));
|
|
}
|
|
|
|
private static void BuildRow(StoreGui gui, SvermHiveBehaviour hive, SvermHiveGoods.Good good, int rowIndex)
|
|
{
|
|
GameObject element = UnityEngine.Object.Instantiate(gui.m_listElement, _root);
|
|
element.SetActive(true);
|
|
|
|
RectTransform rt = (RectTransform)element.transform;
|
|
float offset = (_root.rect.width - rt.rect.width) / 2f;
|
|
rt.anchoredPosition = new Vector2(offset, rowIndex * -gui.m_itemSpacing - offset);
|
|
|
|
string refusal = SvermHiveGoods.RefusalFor(good, hive);
|
|
bool available = refusal == null;
|
|
|
|
Sprite icon = SvermHive.BorrowIcon(good.Icon) ?? SvermHive.BorrowIcon("Honey");
|
|
Image iconImage = element.transform.Find("icon").GetComponent<Image>();
|
|
if (icon != null) iconImage.sprite = icon;
|
|
iconImage.color = available ? Color.white : Color.grey;
|
|
|
|
TMP_Text nameLabel = element.transform.Find("name").GetComponent<TMP_Text>();
|
|
nameLabel.text = good.Name;
|
|
nameLabel.color = available ? Color.white : Color.grey;
|
|
|
|
TMP_Text price = FindDescendant<TMP_Text>(element.transform, "price");
|
|
if (price != null)
|
|
{
|
|
price.text = good.Price.ToString("0");
|
|
price.color = available ? Color.white : Color.grey;
|
|
}
|
|
|
|
UITooltip tooltip = element.GetComponent<UITooltip>();
|
|
if (tooltip != null)
|
|
{
|
|
string body = available ? good.Description : refusal + "\n\n" + good.Description;
|
|
tooltip.Set(good.Name, body, gui.m_tooltipAnchor, default(Vector2));
|
|
}
|
|
|
|
Button button = element.GetComponent<Button>();
|
|
button.interactable = available;
|
|
button.onClick.AddListener(() =>
|
|
{
|
|
SvermHiveGoods.Buy(good, hive, Player.m_localPlayer);
|
|
Traverse.Create(gui).Method("FillList").GetValue(); // repaints the shelf
|
|
});
|
|
|
|
_rows.Add(element);
|
|
}
|
|
|
|
private static T FindDescendant<T>(Transform root, string childName) where T : Component
|
|
{
|
|
foreach (T candidate in root.GetComponentsInChildren<T>(true))
|
|
{
|
|
if (candidate.gameObject.name == childName) return candidate;
|
|
}
|
|
return null;
|
|
}
|
|
}
|
|
}
|