diff --git a/JotunnModStub/BossProgressionManager.cs b/JotunnModStub/BossProgressionManager.cs
index 39ce04b..d688a88 100644
--- a/JotunnModStub/BossProgressionManager.cs
+++ b/JotunnModStub/BossProgressionManager.cs
@@ -16,6 +16,85 @@ namespace RacesOfValheim
public const string TheQueen = "defeated_queen";
public const string Fader = "defeated_fader";
+ public const int MinState = 1;
+ public const int MaxState = 8;
+
+ // Stored on the character rather than the world, so a personal tier travels with the
+ // player between servers instead of being tied to whichever world unlocked it.
+ private const string PersonalStateKey = "RacesOfValheim_PersonalState";
+ private const string PersonalModeKey = "RacesOfValheim_PersonalMode";
+
+ ///
+ /// Boss secondary drops, and the progression state each one unlocks when offered to the
+ /// Race Menu Ward. Keyed by prefab name, which is what the item stack carries.
+ ///
+ public static readonly Dictionary BossDropStates = new Dictionary
+ {
+ { "HardAntler", 2 }, // Eikthyr
+ { "CryptKey", 3 }, // The Elder
+ { "Wishbone", 4 }, // Bonemass
+ { "DragonTear", 5 }, // Moder
+ { "YagluthDrop", 6 }, // Yagluth
+ { "QueenDrop", 7 }, // The Queen - Majestic carapace
+ { "FaderDrop", 8 } // Fader - Fader relic
+ };
+
+ public static string GetBossNameForState(int state)
+ {
+ switch (state)
+ {
+ case 2: return "Eikthyr";
+ case 3: return "The Elder";
+ case 4: return "Bonemass";
+ case 5: return "Moder";
+ case 6: return "Yagluth";
+ case 7: return "The Queen";
+ case 8: return "Fader";
+ default: return "No bosses";
+ }
+ }
+
+ ///
+ /// True when the player has chosen to advance on their own unlocks rather than on whatever
+ /// the server has already killed.
+ ///
+ public static bool UsePersonalProgression
+ {
+ get
+ {
+ Player player = Player.m_localPlayer;
+ if (player == null || player.m_customData == null) return false;
+ return player.m_customData.TryGetValue(PersonalModeKey, out string value) && value == "true";
+ }
+ set
+ {
+ Player player = Player.m_localPlayer;
+ if (player == null || player.m_customData == null) return;
+ player.m_customData[PersonalModeKey] = value ? "true" : "false";
+ }
+ }
+
+ public static int PersonalState
+ {
+ get
+ {
+ Player player = Player.m_localPlayer;
+ if (player == null || player.m_customData == null) return MinState;
+ if (player.m_customData.TryGetValue(PersonalStateKey, out string value) &&
+ int.TryParse(value, out int state))
+ {
+ return UnityEngine.Mathf.Clamp(state, MinState, MaxState);
+ }
+ return MinState;
+ }
+ set
+ {
+ Player player = Player.m_localPlayer;
+ if (player == null || player.m_customData == null) return;
+ player.m_customData[PersonalStateKey] = UnityEngine.Mathf.Clamp(value, MinState, MaxState).ToString();
+ }
+ }
+
///
/// Returns the current progression state of the world based on defeated bosses.
/// 1 = No bosses defeated
@@ -27,13 +106,11 @@ namespace RacesOfValheim
/// 7 = The Queen defeated
/// 8 = Fader defeated
///
- public static int GetCurrentProgressionState()
+ public static int GetWorldProgressionState()
{
- if (DebugState != -1) return DebugState; // [DEBUG]
-
if (ZoneSystem.instance == null)
{
- return 1; // Default to 1 if ZoneSystem isn't ready
+ return MinState; // Default to 1 if ZoneSystem isn't ready
}
// We check in reverse order (highest tier first)
@@ -45,7 +122,16 @@ namespace RacesOfValheim
if (ZoneSystem.instance.GetGlobalKey(TheElder)) return 3;
if (ZoneSystem.instance.GetGlobalKey(Eikthyr)) return 2;
- return 1; // No bosses defeated
+ return MinState; // No bosses defeated
+ }
+
+ public static int GetCurrentProgressionState()
+ {
+ if (DebugState != -1) return DebugState; // [DEBUG]
+
+ if (UsePersonalProgression) return PersonalState;
+
+ return GetWorldProgressionState();
}
}
}
diff --git a/JotunnModStub/RaceMenuWard.cs b/JotunnModStub/RaceMenuWard.cs
new file mode 100644
index 0000000..59c6201
--- /dev/null
+++ b/JotunnModStub/RaceMenuWard.cs
@@ -0,0 +1,379 @@
+using Jotunn.Configs;
+using Jotunn.Entities;
+using Jotunn.Managers;
+using UnityEngine;
+using UnityEngine.UI;
+
+namespace RacesOfValheim
+{
+ ///
+ /// A buildable ward that lets a player manage their race outside of the debug console: reset
+ /// the race, switch between the server's boss progression and their own, and advance that
+ /// personal progression by offering a boss's secondary drop to it.
+ ///
+ public static class RaceMenuWard
+ {
+ public const string PrefabName = "RaceMenuWard";
+
+ public static void Register()
+ {
+ // The Ward ("guard_stone") is only borrowed for its model and build sounds; its own
+ // area-protection behaviour is stripped below so it never claims territory.
+ GameObject prefab = PrefabManager.Instance.CreateClonedPrefab(PrefabName, "guard_stone");
+ if (prefab == null)
+ {
+ Jotunn.Logger.LogWarning("Could not clone guard_stone; Race Menu Ward not registered.");
+ return;
+ }
+
+ PrivateArea privateArea = prefab.GetComponent();
+ if (privateArea != null) Object.DestroyImmediate(privateArea);
+
+ // The Ward is a workbench recipe, and Player.HaveRequirements hides any piece whose
+ // crafting station is not both known and in range - which is why a fresh character
+ // never saw this in the hammer. Clearing the station makes it buildable anywhere.
+ Piece piece = prefab.GetComponent();
+ if (piece != null)
+ {
+ piece.m_craftingStation = null;
+ // The clone arrives carrying the Ward's own recipe (fine wood, surtling cores and
+ // so on). Jotunn only overwrites m_resources when the config lists requirements,
+ // so wipe the inherited ones here and let the config below set the real cost.
+ piece.m_resources = new Piece.Requirement[0];
+ }
+
+ prefab.AddComponent();
+
+ PieceConfig config = new PieceConfig
+ {
+ Name = "Race Menu Ward",
+ Description = "Commune with your heritage. Offer a fallen boss's relic to claim its power.",
+ PieceTable = PieceTables.Hammer,
+ Category = PieceCategories.Misc,
+ // Deliberately trivial: this is a utility the player needs early, not a reward.
+ Requirements = new[]
+ {
+ new RequirementConfig("Wood", 2, 0, true)
+ }
+ };
+
+ PieceManager.Instance.AddPiece(new CustomPiece(prefab, fixReference: false, config));
+ }
+
+ // Marks a world as already having its starter ward, so it is placed exactly once rather
+ // than every time someone loads in.
+ private const string PlacedKey = "RacesOfValheim_StarterWardPlaced";
+ // Clear of the stone circle itself, which is why the first attempt ended up inside a stone.
+ private const float SpawnRadius = 14f;
+ private const float ClearanceRadius = 2.5f;
+
+ ///
+ /// Drops a ward beside the sacrificial stones so a fresh world has one without anyone
+ /// needing to build it. Only the host runs this, and only once per world.
+ ///
+ public static void TryPlaceAtSpawn()
+ {
+ if (ZoneSystem.instance == null || ZNetScene.instance == null) return;
+ if (ZNet.instance == null || !ZNet.instance.IsServer()) return;
+ if (ZoneSystem.instance.GetGlobalKey(PlacedKey)) return;
+
+ if (!ZoneSystem.instance.GetLocationIcon("StartTemple", out Vector3 templePos)) return;
+
+ GameObject prefab = ZNetScene.instance.GetPrefab(PrefabName);
+ if (prefab == null) return;
+
+ if (!TryFindClearSpot(templePos, out Vector3 pos)) return;
+
+ Object.Instantiate(prefab, pos, Quaternion.identity);
+ ZoneSystem.instance.SetGlobalKey(PlacedKey);
+ Jotunn.Logger.LogInfo($"Placed the starter Race Menu Ward near spawn at {pos}.");
+ }
+
+ ///
+ /// A build piece only appears in the hammer once its name is in the player's known recipes
+ /// (PieceTable.UpdateAvailable filters on exactly that), and the vanilla learning pass can
+ /// miss a piece injected after the fact. Teach it directly and rebuild the list. Both
+ /// methods are non-public, hence the reflection.
+ ///
+ public static void EnsureKnown(Player player)
+ {
+ if (player == null) return;
+
+ GameObject prefab = PrefabManager.Instance.GetPrefab(PrefabName);
+ if (prefab == null)
+ {
+ Jotunn.Logger.LogWarning($"{PrefabName} prefab missing; cannot teach the piece.");
+ return;
+ }
+
+ Piece piece = prefab.GetComponent();
+ if (piece == null)
+ {
+ Jotunn.Logger.LogWarning($"{PrefabName} has no Piece component.");
+ return;
+ }
+
+ var traverse = HarmonyLib.Traverse.Create(player);
+ traverse.Method("AddKnownPiece", piece).GetValue();
+ traverse.Method("UpdateAvailablePiecesList").GetValue();
+ }
+
+ ///
+ /// Walks a ring around the sacrificial stones looking for open, level terrain. Uses the
+ /// ground height rather than the solid height, since the latter happily reports the top of
+ /// a standing stone and leaves the ward embedded in it.
+ ///
+ private static bool TryFindClearSpot(Vector3 centre, out Vector3 result)
+ {
+ int obstacleMask = LayerMask.GetMask("Default", "static_solid", "Default_small", "piece", "vehicle");
+
+ for (int i = 0; i < 12; i++)
+ {
+ float angle = i * (360f / 12f) * Mathf.Deg2Rad;
+ Vector3 candidate = centre + new Vector3(Mathf.Cos(angle), 0f, Mathf.Sin(angle)) * SpawnRadius;
+ candidate.y = ZoneSystem.instance.GetGroundHeight(candidate);
+
+ // Skip anything underwater, and anything with a rock, tree or build piece on it.
+ if (candidate.y < ZoneSystem.instance.m_waterLevel) continue;
+ if (Physics.CheckSphere(candidate + Vector3.up * 1.5f, ClearanceRadius, obstacleMask)) continue;
+
+ result = candidate;
+ return true;
+ }
+
+ // Nothing ideal: fall back to due south on the terrain rather than skipping entirely.
+ result = centre + new Vector3(0f, 0f, -SpawnRadius);
+ result.y = ZoneSystem.instance.GetGroundHeight(result);
+ return true;
+ }
+ }
+
+ // The spawn point only resolves once the world is up and the local player exists, so the
+ // placement attempt rides along with the player spawning rather than world load.
+ [HarmonyLib.HarmonyPatch(typeof(Player), "OnSpawned")]
+ public static class RaceMenuWardSpawnPatch
+ {
+ public static void Postfix(Player __instance)
+ {
+ if (__instance != Player.m_localPlayer) return;
+ RaceMenuWard.TryPlaceAtSpawn();
+ RaceMenuWard.EnsureKnown(__instance);
+ }
+ }
+
+ public class RaceMenuWardBehavior : MonoBehaviour, Hoverable, Interactable
+ {
+ public string GetHoverName() => "Race Menu Ward";
+
+ public string GetHoverText()
+ {
+ string mode = BossProgressionManager.UsePersonalProgression ? "Personal" : "World";
+ int state = BossProgressionManager.GetCurrentProgressionState();
+ string boss = BossProgressionManager.GetBossNameForState(state);
+
+ return $"Race Menu Ward\n{mode} progression - {boss} ({state}/{BossProgressionManager.MaxState})\n" +
+ "[E] Open\n" +
+ "[Use item] Offer a boss relic";
+ }
+
+ public bool Interact(Humanoid user, bool hold, bool alt)
+ {
+ if (hold) return false;
+ if (user != Player.m_localPlayer) return false;
+
+ RaceMenuWardUI.Show();
+ return true;
+ }
+
+ ///
+ /// Offering a boss's secondary drop unlocks that boss's tier of personal progression.
+ /// Any tier may be claimed directly - holding a Dragon tear takes you straight to Moder's
+ /// tier whether or not the earlier ones were ever claimed.
+ ///
+ public bool UseItem(Humanoid user, ItemDrop.ItemData item)
+ {
+ if (user != Player.m_localPlayer || item == null) return false;
+
+ string prefabName = item.m_dropPrefab != null ? item.m_dropPrefab.name : null;
+ if (prefabName == null || !BossProgressionManager.BossDropStates.TryGetValue(prefabName, out int state))
+ {
+ user.Message(MessageHud.MessageType.Center, "The ward has no use for that.");
+ return true;
+ }
+
+ if (!BossProgressionManager.UsePersonalProgression)
+ {
+ user.Message(MessageHud.MessageType.Center, "Switch to personal progression first.");
+ return true;
+ }
+
+ if (BossProgressionManager.PersonalState >= state)
+ {
+ user.Message(MessageHud.MessageType.Center,
+ $"You already carry {BossProgressionManager.GetBossNameForState(state)}'s power.");
+ return true;
+ }
+
+ Player player = Player.m_localPlayer;
+ player.GetInventory().RemoveOneItem(item);
+ BossProgressionManager.PersonalState = state;
+
+ user.Message(MessageHud.MessageType.Center,
+ $"{BossProgressionManager.GetBossNameForState(state)}'s power is yours.");
+
+ RefreshRaceState();
+ return true;
+ }
+
+ // Progression drives stats and unlocks that are only recalculated when equipment is set
+ // up, so nudge that after any change or the new tier will not show until something else
+ // happens to trigger it.
+ public static void RefreshRaceState()
+ {
+ if (Player.m_localPlayer == null) return;
+ HarmonyLib.Traverse.Create(Player.m_localPlayer).Method("SetupEquipment").GetValue();
+ }
+ }
+
+ public static class RaceMenuWardUI
+ {
+ private static GameObject panel;
+
+ public static bool IsOpen => panel != null;
+
+ public static void Show()
+ {
+ if (panel != null) return;
+ if (GUIManager.Instance == null || GUIManager.CustomGUIFront == null)
+ {
+ Jotunn.Logger.LogWarning("GUIManager not ready; cannot open the Race Menu Ward.");
+ return;
+ }
+
+ panel = new GameObject("RaceMenuWardPanel");
+ panel.transform.SetParent(GUIManager.CustomGUIFront.transform, false);
+
+ RectTransform rect = panel.AddComponent();
+ rect.anchorMin = Vector2.zero;
+ rect.anchorMax = Vector2.one;
+ rect.offsetMin = Vector2.zero;
+ rect.offsetMax = Vector2.zero;
+
+ Image bg = panel.AddComponent();
+ bg.color = new Color(0f, 0f, 0f, 0.85f);
+
+ AddLabel("Title", "Race Menu Ward", 46, new Vector2(0, 230), new Vector2(700, 90));
+
+ AddLabel("Status", BuildStatusText(), 24, new Vector2(0, 110), new Vector2(900, 160));
+
+ AddButton("WorldBtn", "Use World Progression", new Vector2(-170, -20), new Color(0.2f, 0.35f, 0.5f, 1f), () =>
+ {
+ BossProgressionManager.UsePersonalProgression = false;
+ RaceMenuWardBehavior.RefreshRaceState();
+ Refresh();
+ });
+
+ AddButton("PersonalBtn", "Use Personal Progression", new Vector2(170, -20), new Color(0.35f, 0.3f, 0.5f, 1f), () =>
+ {
+ BossProgressionManager.UsePersonalProgression = true;
+ RaceMenuWardBehavior.RefreshRaceState();
+ Refresh();
+ });
+
+ AddButton("ResetBtn", "Reset Race", new Vector2(0, -110), new Color(0.5f, 0.25f, 0.2f, 1f), () =>
+ {
+ Close();
+ RacesOfValheim.ResetRace();
+ });
+
+ AddButton("CloseBtn", "Close", new Vector2(0, -200), new Color(0.3f, 0.3f, 0.3f, 1f), Close);
+
+ GUIManager.BlockInput(true);
+ }
+
+ public static void Close()
+ {
+ if (panel == null) return;
+ Object.Destroy(panel);
+ panel = null;
+ GUIManager.BlockInput(false);
+ }
+
+ private static void Refresh()
+ {
+ if (panel == null) return;
+ Transform status = panel.transform.Find("Status");
+ if (status != null)
+ {
+ Text text = status.GetComponent();
+ if (text != null) text.text = BuildStatusText();
+ }
+ }
+
+ private static string BuildStatusText()
+ {
+ int world = BossProgressionManager.GetWorldProgressionState();
+ int personal = BossProgressionManager.PersonalState;
+ bool usingPersonal = BossProgressionManager.UsePersonalProgression;
+
+ string worldLine = $"World: {BossProgressionManager.GetBossNameForState(world)} ({world}/{BossProgressionManager.MaxState})";
+ string personalLine = $"Personal: {BossProgressionManager.GetBossNameForState(personal)} ({personal}/{BossProgressionManager.MaxState})";
+
+ if (usingPersonal) personalLine = "> " + personalLine + " <";
+ else worldLine = "> " + worldLine + " <";
+
+ return worldLine + "\n" + personalLine +
+ "\n\nOffer a boss's relic to the ward to claim its tier for your personal progression.";
+ }
+
+ private static void AddLabel(string name, string content, int fontSize, Vector2 position, Vector2 size)
+ {
+ GameObject obj = new GameObject(name);
+ obj.transform.SetParent(panel.transform, false);
+
+ Text text = obj.AddComponent();
+ text.font = GUIManager.Instance.AveriaSerifBold;
+ text.text = content;
+ text.fontSize = fontSize;
+ text.alignment = TextAnchor.MiddleCenter;
+ text.color = Color.white;
+
+ RectTransform textRect = obj.GetComponent();
+ textRect.anchoredPosition = position;
+ textRect.sizeDelta = size;
+ }
+
+ private static void AddButton(string name, string label, Vector2 position, Color colour, UnityEngine.Events.UnityAction onClick)
+ {
+ GameObject obj = new GameObject(name);
+ obj.transform.SetParent(panel.transform, false);
+
+ RectTransform btnRect = obj.AddComponent();
+ btnRect.sizeDelta = new Vector2(300, 60);
+ btnRect.anchoredPosition = position;
+
+ Image image = obj.AddComponent();
+ image.color = colour;
+
+ Button button = obj.AddComponent