diff --git a/JotunnModStub/Dvergar/DvergarCheapBuilding.cs b/JotunnModStub/Dvergar/DvergarCheapBuilding.cs new file mode 100644 index 0000000..9fa25ec --- /dev/null +++ b/JotunnModStub/Dvergar/DvergarCheapBuilding.cs @@ -0,0 +1,275 @@ +using System.Collections.Generic; +using HarmonyLib; +using UnityEngine; +using UnityEngine.UI; + +namespace RacesOfValheim +{ + /// + /// A Dvergar builds the black marble and Yggdrasil wood building pieces with stone and fine + /// wood (Wargles' suggestion). Only structural pieces: stations, furniture, containers and + /// fires keep their cost, so nothing with a progression role gets cheaper. + /// + /// The swap is done on the piece prefabs of the Dvergar's own client. The build menu, the + /// "known piece" check and ConsumeResources all read the prefab's m_resources, so the menu + /// lists the pieces once stone or fine wood is known, and the player pays the swapped cost. + /// + /// The refund is the catch. Piece.DropResources gives back whatever m_resources says on the + /// machine that destroys the piece; vanilla never records what was paid. Without help a human + /// deconstructing a Dvergar's stone wall would get black marble, and a Dvergar deconstructing a + /// vanilla wall would get stone. So a cheap piece is tagged on its ZDO when placed, with the + /// ratios it was paid at, and DropResources is given the matching cost on every client. + /// + public static class DvergarCheapBuilding + { + // The ratios a cheap piece was paid at. Absent (0) on every piece placed at full cost. + public const string StoneRatioZdoKey = "RacesOfValheim_DvergarCheapStone"; + public const string WoodRatioZdoKey = "RacesOfValheim_DvergarCheapWood"; + + private const string BlackMarble = "BlackMarble"; + private const string YggdrasilWood = "YggdrasilWood"; + private const string Stone = "Stone"; + private const string FineWood = "FineWood"; + + private const string LabelName = "rov_dvergar_cheap"; + + private const Piece.UsageTagFlags StructuralTags = + Piece.UsageTagFlags.Building | Piece.UsageTagFlags.Floor | Piece.UsageTagFlags.Wall | + Piece.UsageTagFlags.Roof | Piece.UsageTagFlags.Architecture | Piece.UsageTagFlags.Stairs | + Piece.UsageTagFlags.Doors; + + // Piece prefab name -> its vanilla cost. Collected once and kept: the prefabs live for the + // whole session, and the originals must survive every swap. + private static Dictionary originals; + private static Dictionary prefabs; + private static ItemDrop stoneItem, fineWoodItem; + + // "" while the prefabs carry their vanilla cost, otherwise the ratios they were swapped at. + private static string appliedKey = ""; + + private static bool Collect() + { + if (originals != null) return true; + if (ObjectDB.instance == null) return false; + + GameObject hammer = ObjectDB.instance.GetItemPrefab("Hammer"); + PieceTable table = hammer != null ? hammer.GetComponent()?.m_itemData?.m_shared?.m_buildPieces : null; + stoneItem = ObjectDB.instance.GetItemPrefab(Stone)?.GetComponent(); + fineWoodItem = ObjectDB.instance.GetItemPrefab(FineWood)?.GetComponent(); + if (table == null || stoneItem == null || fineWoodItem == null) return false; + + originals = new Dictionary(); + prefabs = new Dictionary(); + foreach (GameObject go in table.m_pieces) + { + Piece piece = go != null ? go.GetComponent() : null; + if (piece == null || piece.m_resources == null || !UsesSwappedMaterial(piece) || !IsBuildingPiece(piece)) continue; + + originals[go.name] = piece.m_resources; + prefabs[go.name] = piece; + // The list to read once in game: every piece that changes cost, and where it is built. + Jotunn.Logger.LogInfo($"[Dvergar] Cheap building: {go.name} at {(piece.m_craftingStation != null ? piece.m_craftingStation.name : "no station")}, {Describe(piece.m_resources)} -> {Describe(BuildCheap(piece.m_resources, 3, 2))} (at 3/2)"); + } + Jotunn.Logger.LogInfo($"[Dvergar] Cheap building: {originals.Count} pieces."); + return true; + } + + private static bool UsesSwappedMaterial(Piece piece) + { + foreach (Piece.Requirement req in piece.m_resources) + { + if (req.m_resItem == null) continue; + string name = req.m_resItem.name; + if (name == BlackMarble || name == YggdrasilWood) return true; + } + return false; + } + + private static bool IsBuildingPiece(Piece piece) + { + bool structural = piece.m_category == Piece.PieceCategory.BuildingWorkbench + || piece.m_category == Piece.PieceCategory.BuildingStonecutter + || (piece.m_usage & StructuralTags) != 0; + if (!structural) return false; + if ((piece.m_usage & Piece.UsageTagFlags.Crafting) != 0) return false; + + // Anything that does a job keeps its cost, whatever its tags say. + return piece.GetComponentInChildren() == null + && piece.GetComponentInChildren() == null + && piece.GetComponentInChildren() == null + && piece.GetComponentInChildren() == null + && piece.GetComponentInChildren() == null + && piece.m_comfort <= 0; + } + + /// + /// The cost with black marble and Yggdrasil wood swapped out. New Requirement objects + /// throughout: the originals are shared with the prefab and must stay untouched. A + /// material the piece already had (some marble pieces also ask for stone) is merged. + /// + private static Piece.Requirement[] BuildCheap(Piece.Requirement[] original, int stoneRatio, int woodRatio) + { + var result = new List(); + foreach (Piece.Requirement req in original) + { + ItemDrop item = req.m_resItem; + int amount = req.m_amount; + if (item != null && item.name == BlackMarble) { item = stoneItem; amount *= stoneRatio; } + else if (item != null && item.name == YggdrasilWood) { item = fineWoodItem; amount *= woodRatio; } + + Piece.Requirement same = item != null ? result.Find(r => r.m_resItem == item) : null; + if (same != null) + { + same.m_amount += amount; + continue; + } + result.Add(new Piece.Requirement + { + m_resItem = item, + m_amount = amount, + m_extraAmountOnlyOneIngredient = req.m_extraAmountOnlyOneIngredient, + m_amountPerLevel = req.m_amountPerLevel, + m_upgraderResource = req.m_upgraderResource, + m_recover = req.m_recover, + }); + } + return result.ToArray(); + } + + private static string Describe(Piece.Requirement[] reqs) + { + var parts = new List(); + foreach (Piece.Requirement req in reqs) + { + if (req.m_resItem != null) parts.Add($"{req.m_amount} {req.m_resItem.name}"); + } + return string.Join(", ", parts); + } + + /// + /// Puts the cost the local player should see on the prefabs. Returns whether anything + /// changed, so the caller knows to refresh the build menu. + /// + private static bool Apply(bool cheap) + { + int stone = DvergarConfigManagement.CheapStonePerBlackMarble.Value; + int wood = DvergarConfigManagement.CheapFineWoodPerYggdrasil.Value; + string key = cheap ? stone + "/" + wood : ""; + if (key == appliedKey) return false; + + foreach (var pair in originals) + { + if (!prefabs.TryGetValue(pair.Key, out Piece prefab) || prefab == null) continue; + prefab.m_resources = cheap ? BuildCheap(pair.Value, stone, wood) : pair.Value; + } + appliedKey = key; + return true; + } + + private static bool IsSwapped(Piece piece) + { + return appliedKey != "" && piece != null && originals != null + && originals.ContainsKey(Utils.GetPrefabName(piece.gameObject.name)); + } + + /// + /// Keeps the prefabs in step with the local player: a Dvergar with the option on sees the + /// cheap cost, anyone else the vanilla one. Checked every frame because the race can change + /// mid-session (resetrace) and the ratios with the server's config; the check is a string + /// compare unless something changed. + /// + [HarmonyPatch(typeof(Player), "Update")] + public static class Dvergar_CheapBuildingSync_Patch + { + public static void Postfix(Player __instance) + { + if (__instance != Player.m_localPlayer || !Collect()) return; + + bool cheap = DvergarConfigManagement.CheapBuildingEnabled.Value && DvergarRace.IsDvergar(); + if (Apply(cheap)) Traverse.Create(__instance).Method("UpdateAvailablePiecesList").GetValue(); + } + } + + /// + /// Tags a piece placed at the cheap cost. SetCreator is called once, by PlacePiece, on the + /// placing client, right after the piece was paid for from the same prefab cost. + /// + [HarmonyPatch(typeof(Piece), nameof(Piece.SetCreator))] + public static class Dvergar_CheapBuildingTag_Patch + { + public static void Postfix(Piece __instance) + { + if (!IsSwapped(__instance)) return; + + ZNetView nview = __instance.GetComponent(); + if (nview == null || !nview.IsValid() || !nview.IsOwner()) return; + + nview.GetZDO().Set(StoneRatioZdoKey, DvergarConfigManagement.CheapStonePerBlackMarble.Value); + nview.GetZDO().Set(WoodRatioZdoKey, DvergarConfigManagement.CheapFineWoodPerYggdrasil.Value); + } + } + + /// + /// Gives back what the piece cost: the cheap materials at the ratios it was paid at for a + /// tagged piece, the vanilla cost for every other one, whoever destroys it and whatever + /// cost this client's prefab carries right now. + /// + [HarmonyPatch(typeof(Piece), nameof(Piece.DropResources))] + public static class Dvergar_CheapBuildingRefund_Patch + { + public static void Prefix(Piece __instance) + { + if (!Collect()) return; + if (!originals.TryGetValue(Utils.GetPrefabName(__instance.gameObject.name), out Piece.Requirement[] original)) return; + + ZNetView nview = __instance.GetComponent(); + ZDO zdo = nview != null && nview.IsValid() ? nview.GetZDO() : null; + int stone = zdo != null ? zdo.GetInt(StoneRatioZdoKey, 0) : 0; + int wood = zdo != null ? zdo.GetInt(WoodRatioZdoKey, 0) : 0; + + __instance.m_resources = stone > 0 && wood > 0 ? BuildCheap(original, stone, wood) : original; + } + } + + /// + /// The Dvergar icon on every swapped piece in the hammer menu. Valheim 1.0 + /// draws that menu with BuildUi, one pooled BuildUiPieceButton per piece, and Setup is + /// where a button takes its piece. The old Hud.UpdatePieceList grid still runs but is + /// hidden, so a label there is never seen. + /// + [HarmonyPatch(typeof(BuildUiPieceButton), nameof(BuildUiPieceButton.Setup))] + public static class Dvergar_CheapBuildingLabel_Patch + { + public static void Postfix(BuildUiPieceButton __instance, Piece pieceInfo) + { + bool cheap = IsSwapped(pieceInfo); + Transform label = __instance.transform.Find(LabelName); + if (label == null) + { + if (!cheap) return; + label = CreateLabel(__instance.transform); + } + if (label.gameObject.activeSelf != cheap) label.gameObject.SetActive(cheap); + } + + private static Transform CreateLabel(Transform button) + { + var obj = new GameObject(LabelName, typeof(RectTransform)); + obj.transform.SetParent(button, false); + + // The race's own icon in the bottom-right corner, as the race menu and the build + // panel's race requirement show it: no text, so it fits in every language. + var rect = (RectTransform)obj.transform; + rect.anchorMin = rect.anchorMax = rect.pivot = new Vector2(1f, 0f); + rect.anchoredPosition = new Vector2(-2f, 2f); + rect.sizeDelta = new Vector2(22f, 22f); + + var image = obj.AddComponent(); + image.sprite = RacesOfValheim.RaceIcon(DvergarConfig.RaceId); + image.preserveAspect = true; + image.raycastTarget = false; + return obj.transform; + } + } + } +} diff --git a/JotunnModStub/Dvergar/DvergarConfigManagement.cs b/JotunnModStub/Dvergar/DvergarConfigManagement.cs index b9be848..3a6d43f 100644 --- a/JotunnModStub/Dvergar/DvergarConfigManagement.cs +++ b/JotunnModStub/Dvergar/DvergarConfigManagement.cs @@ -57,6 +57,11 @@ namespace RacesOfValheim public static ConfigEntry RunicOverchargeWindow; public static ConfigEntry RunicOverchargeCooldown; + // ─── Cheap Building ─────────────────────────────────────────────────────── + public static ConfigEntry CheapBuildingEnabled; + public static ConfigEntry CheapStonePerBlackMarble; + public static ConfigEntry CheapFineWoodPerYggdrasil; + public static void Bind(ConfigFile config) { const string keybinds = "Dvergar - Keybinds"; @@ -106,6 +111,14 @@ namespace RacesOfValheim new ConfigDescription("Seconds a loaded charge is held before it lapses unused.", new AcceptableValueRange(1f, 60f))); RunicOverchargeCooldown = config.Bind(overcharge, "Cooldown", 60f, new ConfigDescription("Seconds between casts.", new AcceptableValueRange(0f, 300f))); + + const string building = "Dvergar - Cheap Building"; + CheapBuildingEnabled = config.Bind(building, "Enabled", true, + new ConfigDescription("A Dvergar builds the black marble and Yggdrasil wood building pieces (walls, floors, beams, roofs, arches, stairs) with stone and fine wood instead. Stations and furniture keep their cost. A deconstructed piece gives back what was paid for it.")); + CheapStonePerBlackMarble = config.Bind(building, "Stone per Black Marble", 3, + new ConfigDescription("Stone a Dvergar pays for each black marble in a piece's cost.", new AcceptableValueRange(1, 10))); + CheapFineWoodPerYggdrasil = config.Bind(building, "Fine Wood per Yggdrasil Wood", 2, + new ConfigDescription("Fine wood a Dvergar pays for each Yggdrasil wood in a piece's cost.", new AcceptableValueRange(1, 10))); } } }