293 lines
13 KiB
C#
293 lines
13 KiB
C#
using System.Collections.Generic;
|
|
using Jotunn.Managers;
|
|
using UnityEngine;
|
|
|
|
namespace RacesOfValheim
|
|
{
|
|
/// <summary>
|
|
/// The army: four creatures, hatched at the market, bound to the nest that paid for them.
|
|
///
|
|
/// TWO RESOURCES IN PARALLEL, which is section 10.2 and the whole shape of the colony. The EGG
|
|
/// is the slot and it grows back on its own; the BIOMASS is the price and it does not. A troop
|
|
/// needs both, so a hive with a full tank and no eggs waits, and a hive full of eggs and no
|
|
/// biomass waits differently.
|
|
///
|
|
/// Nothing here is new machinery. A troop is a RaisedThrall - the same component the Draugh's
|
|
/// spawner, the Dvergar's bank and the Fenrir's trough hang their rosters on - so the follow and
|
|
/// stay orders, the leash, the walk home and the withering when the station falls all come for
|
|
/// free and behave exactly like every other summoned thing in the mod. The self-healing is
|
|
/// SkeletonSentryBehaviour, reused whole, which is section 11.2 word for word.
|
|
/// </summary>
|
|
public static class SvermBrood
|
|
{
|
|
/// <summary>
|
|
/// What every troop prefab's name starts with. One place, because two things ask the
|
|
/// question "is this creature one of ours" - the roster and the medicine.
|
|
/// </summary>
|
|
public const string PrefabPrefix = "SvermTroop_";
|
|
|
|
/// <summary>One rung of the ladder, from section 11's table.</summary>
|
|
public class Kind
|
|
{
|
|
public string Id;
|
|
public string Display;
|
|
public string Source; // the vanilla creature it is cloned from
|
|
public string Icon;
|
|
public float Price;
|
|
public int Stage; // the nest stage it becomes available at
|
|
public float Cooldown; // seconds between two of these
|
|
|
|
public string PrefabName => PrefabPrefix + Source;
|
|
public int Cap => CapOf(Id);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Section 11's table, prices and caps and stage gates unchanged.
|
|
///
|
|
/// The cooldowns are section 20.4's: ten minutes for a Gjall and "the others scaled
|
|
/// accordingly", which is read here as scaled BY PRICE - a Brood is a tenth of a Gjall in
|
|
/// biomass, so it is a tenth of a Gjall in patience too.
|
|
/// </summary>
|
|
public static readonly List<Kind> Roster = new List<Kind>
|
|
{
|
|
new Kind { Id = "brood", Display = "Brood", Source = "SeekerBrood", Icon = "TrophySeeker", Price = 100f, Stage = 1, Cooldown = 60f },
|
|
new Kind { Id = "seeker", Display = "Seeker", Source = "Seeker", Icon = "TrophySeeker", Price = 250f, Stage = 2, Cooldown = 150f },
|
|
new Kind { Id = "soldier", Display = "Soldier", Source = "SeekerBrute", Icon = "TrophySeekerBrute", Price = 500f, Stage = 3, Cooldown = 300f },
|
|
new Kind { Id = "gjall", Display = "Gjall", Source = "Gjall", Icon = "TrophyGjall", Price = 1000f, Stage = 4, Cooldown = 600f },
|
|
};
|
|
|
|
private static int CapOf(string id)
|
|
{
|
|
switch (id)
|
|
{
|
|
case "brood": return SvermConfigManagement.Brood;
|
|
case "seeker": return SvermConfigManagement.Seeker;
|
|
case "soldier": return SvermConfigManagement.Soldier;
|
|
case "gjall": return SvermConfigManagement.Gjall;
|
|
default: return 0;
|
|
}
|
|
}
|
|
|
|
// ─── Registration ────────────────────────────────────────────────────
|
|
|
|
public static void Register()
|
|
{
|
|
foreach (Kind kind in Roster) RegisterOne(kind);
|
|
}
|
|
|
|
/// <summary>
|
|
/// One troop prefab: the vanilla creature, tamed at spawn, leashed, healing, worth nothing dead.
|
|
///
|
|
/// The drop table goes for the reason it always goes here - a troop that dropped seeker parts
|
|
/// would turn the colony into a trophy farm, and the biomass would be paying for itself.
|
|
/// </summary>
|
|
private static void RegisterOne(Kind kind)
|
|
{
|
|
GameObject source = PrefabManager.Cache.GetPrefab<GameObject>(kind.Source);
|
|
if (source == null)
|
|
{
|
|
Jotunn.Logger.LogWarning($"[Sverm] No '{kind.Source}' to build the {kind.Display} from; " +
|
|
"that rung of the roster is missing.");
|
|
return;
|
|
}
|
|
|
|
GameObject prefab = PrefabManager.Instance.CreateClonedPrefab(kind.PrefabName, source);
|
|
if (prefab == null) return;
|
|
|
|
BaseAI ai = prefab.GetComponent<BaseAI>();
|
|
if (ai != null) ai.m_randomMoveRange = SvermConfig.TroopLeashRange;
|
|
|
|
foreach (CharacterDrop drops in prefab.GetComponentsInChildren<CharacterDrop>(true))
|
|
{
|
|
if (drops != null) Object.DestroyImmediate(drops);
|
|
}
|
|
|
|
RaisedThrall thrall = prefab.AddComponent<RaisedThrall>();
|
|
thrall.m_kind = kind.PrefabName;
|
|
thrall.m_commandingRace = SvermConfig.RaceId;
|
|
thrall.m_maxFollowers = -1; // the cap is the colony's, counted at the nest, not per player
|
|
thrall.m_witherSeconds = SvermConfig.TroopWitherSeconds;
|
|
thrall.m_homeCheckRange = SvermConfig.TroopHomeCheckRange;
|
|
thrall.m_refusalMessage = "It does not smell your colony on you.";
|
|
|
|
// Section 11.2, reused whole: ten seconds untouched, then two percent a second. Healing
|
|
// and not respawning - a dead troop is dead, and the egg it cost is already back.
|
|
prefab.AddComponent<SkeletonSentryBehaviour>();
|
|
|
|
PrefabManager.Instance.AddPrefab(prefab);
|
|
Jotunn.Logger.LogInfo($"[Sverm] Registered '{kind.PrefabName}' for the {kind.Display}.");
|
|
}
|
|
|
|
// ─── Counting and hatching ───────────────────────────────────────────
|
|
|
|
/// <summary>
|
|
/// How many of this kind this nest has alive.
|
|
///
|
|
/// Counted off the thralls bound to the nest, which is the same answer every other station in
|
|
/// the mod gives - and carries the same honest limit: it can only see creatures that are
|
|
/// loaded. A troop in an unloaded zone is not counted, so a cap can be briefly exceeded by
|
|
/// hatching a replacement for something that is still alive far away.
|
|
/// </summary>
|
|
public static int CountAlive(SvermHiveBehaviour hive, Kind kind)
|
|
{
|
|
if (hive == null || kind == null) return 0;
|
|
|
|
int count = 0;
|
|
foreach (RaisedThrall thrall in RaisedThrall.BoundTo(hive.transform.position))
|
|
{
|
|
if (thrall != null && thrall.Kind == kind.PrefabName) count++;
|
|
}
|
|
return count;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Puts one on the ground beside the nest, bound to it and born at whatever star the colony
|
|
/// has bought.
|
|
/// </summary>
|
|
public static bool Hatch(SvermHiveBehaviour hive, Kind kind)
|
|
{
|
|
if (hive == null || kind == null) return false;
|
|
|
|
GameObject prefab = ZNetScene.instance != null ? ZNetScene.instance.GetPrefab(kind.PrefabName) : null;
|
|
if (prefab == null)
|
|
{
|
|
Jotunn.Logger.LogWarning($"[Sverm] No '{kind.PrefabName}' in ZNetScene; the {kind.Display} " +
|
|
"could not be hatched.");
|
|
return false;
|
|
}
|
|
|
|
Vector3 offset = Random.insideUnitSphere * 2f;
|
|
offset.y = 0f;
|
|
Vector3 where = hive.transform.position + offset + Vector3.up * 0.5f;
|
|
|
|
GameObject spawned = Object.Instantiate(prefab, where, Quaternion.Euler(0f, Random.Range(0, 360), 0f));
|
|
if (spawned == null) return false;
|
|
|
|
// The stars, and this is the ONLY thing the two star upgrades do: they are read here, at
|
|
// birth, so everything bought before them stays as it was born. Section 14's "valgono su
|
|
// tutto quello che nasce DOPO l'acquisto", enforced by the fact that nothing goes back
|
|
// and re-levels anyone.
|
|
Character character = spawned.GetComponent<Character>();
|
|
if (character != null)
|
|
{
|
|
int stars = SvermBroodStars.Of(hive.transform);
|
|
if (stars > 0) character.SetLevel(1 + stars);
|
|
}
|
|
|
|
RaisedThrall thrall = spawned.GetComponent<RaisedThrall>();
|
|
if (thrall != null) thrall.Bind(hive.transform.position);
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// The brood eggs: the slot half of the price, section 10.2.
|
|
///
|
|
/// One every twenty seconds up to five plus the stage, and it is worked out from the WORLD CLOCK
|
|
/// rather than ticked - the same trick the digestion uses. A nest nobody is standing next to
|
|
/// still fills its clutch, and there is no timer to lose when a zone unloads.
|
|
/// </summary>
|
|
public static class SvermBroodEggs
|
|
{
|
|
private const string EggKey = "RacesOfValheim_SvermEggs";
|
|
private const string ClockKey = "RacesOfValheim_SvermEggAt";
|
|
|
|
public static int Cap(Transform nest)
|
|
{
|
|
return SvermConfig.EggCapBase + SvermHiveStage.Of(nest);
|
|
}
|
|
|
|
/// <summary>What the clutch holds right now, without writing anything.</summary>
|
|
public static int Count(Transform nest)
|
|
{
|
|
ZNetView nview = View(nest);
|
|
if (nview == null) return 0;
|
|
|
|
ZDO zdo = nview.GetZDO();
|
|
int stored = zdo.GetInt(EggKey, 0);
|
|
long clock = zdo.GetLong(ClockKey, 0L);
|
|
|
|
// A clutch that has never been settled has no elapsed time to claim. Reading a missing
|
|
// clock as zero would hand a brand new nest every egg since the world began.
|
|
if (clock <= 0L) return Mathf.Clamp(stored, 0, Cap(nest));
|
|
|
|
long elapsed = WorldSecond() - clock;
|
|
int laid = elapsed > 0L ? (int)(elapsed / SvermConfig.EggInterval) : 0;
|
|
|
|
return Mathf.Clamp(stored + laid, 0, Cap(nest));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Writes down what time has laid and restarts the clock. The owner calls this on a timer so
|
|
/// the number the other clients read is never far behind.
|
|
/// </summary>
|
|
public static void Settle(Transform nest)
|
|
{
|
|
ZNetView nview = View(nest);
|
|
if (nview == null || !nview.IsOwner()) return;
|
|
|
|
ZDO zdo = nview.GetZDO();
|
|
int now = Count(nest);
|
|
|
|
zdo.Set(EggKey, now);
|
|
zdo.Set(ClockKey, WorldSecond());
|
|
}
|
|
|
|
/// <summary>Takes eggs out of the clutch. All or nothing.</summary>
|
|
public static bool Take(Transform nest, int howMany)
|
|
{
|
|
ZNetView nview = View(nest);
|
|
if (nview == null) return false;
|
|
|
|
int have = Count(nest);
|
|
if (have < howMany) return false;
|
|
|
|
if (!nview.IsOwner()) nview.ClaimOwnership();
|
|
nview.GetZDO().Set(EggKey, have - howMany);
|
|
nview.GetZDO().Set(ClockKey, WorldSecond());
|
|
return true;
|
|
}
|
|
|
|
private static ZNetView View(Transform nest)
|
|
{
|
|
ZNetView nview = nest != null ? nest.GetComponent<ZNetView>() : null;
|
|
return nview != null && nview.IsValid() ? nview : null;
|
|
}
|
|
|
|
private static long WorldSecond()
|
|
{
|
|
return ZNet.instance != null ? (long)ZNet.instance.GetTimeSeconds() : 0L;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Surrenal Glands and Hyperplasia: what star the colony's troops are born at.
|
|
///
|
|
/// One number on the nest, 0 to 2, and it is read at the moment a troop is hatched and never
|
|
/// again. Everything already walking around keeps the stars it was born with, which is the
|
|
/// document's own rule and also the only version that does not need to find and re-level a
|
|
/// garrison spread over half the map.
|
|
/// </summary>
|
|
public static class SvermBroodStars
|
|
{
|
|
private const string StarKey = "RacesOfValheim_SvermStars";
|
|
|
|
public static int Of(Transform nest)
|
|
{
|
|
ZNetView nview = nest != null ? nest.GetComponent<ZNetView>() : null;
|
|
if (nview == null || !nview.IsValid()) return 0;
|
|
|
|
return Mathf.Clamp(nview.GetZDO().GetInt(StarKey, 0), 0, 2);
|
|
}
|
|
|
|
public static void Set(Transform nest, int stars)
|
|
{
|
|
ZNetView nview = nest != null ? nest.GetComponent<ZNetView>() : null;
|
|
if (nview == null || !nview.IsValid()) return;
|
|
|
|
if (!nview.IsOwner()) nview.ClaimOwnership();
|
|
nview.GetZDO().Set(StarKey, Mathf.Clamp(stars, 0, 2));
|
|
}
|
|
}
|
|
}
|