warvulture
This commit is contained in:
parent
5c5b8c34d2
commit
e9f41a86e3
11 changed files with 2318 additions and 7 deletions
|
|
@ -35,6 +35,20 @@ namespace RacesOfValheim
|
||||||
|
|
||||||
private static readonly Dictionary<string, Limit> Limits = new Dictionary<string, Limit>();
|
private static readonly Dictionary<string, Limit> Limits = new Dictionary<string, Limit>();
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Extra placement rules, one per piece, for the chains whose cap cannot be expressed as
|
||||||
|
/// "how many of THIS piece stand nearby".
|
||||||
|
///
|
||||||
|
/// The Skadi's golem is the case that forced this: the piece it builds removes itself a frame
|
||||||
|
/// later and leaves a creature behind, so counting the piece counts nothing, and one of its two
|
||||||
|
/// caps is per-stonecutter rather than per-area. A gate is handed the same player and the same
|
||||||
|
/// placement point the simple limit gets, says yes or no, and is responsible for its own
|
||||||
|
/// refusal message - which is the whole extension: the counting is the chain's business, being
|
||||||
|
/// the ONE Player.PlacePiece prefix in the mod is still this class's.
|
||||||
|
/// </summary>
|
||||||
|
private static readonly Dictionary<string, System.Func<Player, Vector3, bool>> Gates =
|
||||||
|
new Dictionary<string, System.Func<Player, Vector3, bool>>();
|
||||||
|
|
||||||
/// <summary>
|
/// <summary>
|
||||||
/// The radius of a circle with the given area, so a limit can be written the way it is
|
/// The radius of a circle with the given area, so a limit can be written the way it is
|
||||||
/// actually discussed - "five per 1.6 square kilometres" - instead of as a magic distance.
|
/// actually discussed - "five per 1.6 square kilometres" - instead of as a magic distance.
|
||||||
|
|
@ -61,6 +75,45 @@ namespace RacesOfValheim
|
||||||
Jotunn.Logger.LogInfo($"[Density] {piecePrefabName}: at most {max} within {radius:0} m.");
|
Jotunn.Logger.LogInfo($"[Density] {piecePrefabName}: at most {max} within {radius:0} m.");
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Adds a rule of the chain's own to a piece. Same call-once-from-Register() contract as
|
||||||
|
/// <see cref="Register"/>, and a second call replaces the first rather than stacking.
|
||||||
|
/// </summary>
|
||||||
|
public static void RegisterGate(string piecePrefabName, System.Func<Player, Vector3, bool> gate)
|
||||||
|
{
|
||||||
|
if (string.IsNullOrEmpty(piecePrefabName) || gate == null)
|
||||||
|
{
|
||||||
|
Jotunn.Logger.LogWarning($"[Density] Refusing a nonsense gate for '{piecePrefabName}'.");
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
Gates[piecePrefabName] = gate;
|
||||||
|
Jotunn.Logger.LogInfo($"[Density] {piecePrefabName}: a rule of its own runs at placement.");
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Every ZDO in the world carrying that prefab. False when the world cannot be asked right
|
||||||
|
/// now, which callers must read as "no information" rather than as "none".
|
||||||
|
///
|
||||||
|
/// ZDOs and not loaded GameObjects, for the reason at the top of this file, and public
|
||||||
|
/// because the Skadi's golem counts by an anchor written INTO each ZDO rather than by
|
||||||
|
/// distance - so it needs the ZDOs themselves and not a tally of them.
|
||||||
|
/// </summary>
|
||||||
|
public static bool Gather(string prefabName, List<ZDO> into)
|
||||||
|
{
|
||||||
|
if (ZDOMan.instance == null || into == null) return false;
|
||||||
|
|
||||||
|
int index = 0;
|
||||||
|
// The iterative sweep hands back a chunk per call and reports true when it is done. The
|
||||||
|
// guard is so a pathological world cannot spin here forever.
|
||||||
|
for (int guard = 0; guard < 1000; guard++)
|
||||||
|
{
|
||||||
|
if (ZDOMan.instance.GetAllZDOsWithPrefabIterative(prefabName, into, ref index)) break;
|
||||||
|
}
|
||||||
|
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
/// <summary>
|
/// <summary>
|
||||||
/// How many of that piece already stand within the radius of a point, or -1 if the world
|
/// How many of that piece already stand within the radius of a point, or -1 if the world
|
||||||
/// cannot be asked right now - in which case callers must let the placement through rather
|
/// cannot be asked right now - in which case callers must let the placement through rather
|
||||||
|
|
@ -68,16 +121,8 @@ namespace RacesOfValheim
|
||||||
/// </summary>
|
/// </summary>
|
||||||
public static int Count(string piecePrefabName, Vector3 position, float radius)
|
public static int Count(string piecePrefabName, Vector3 position, float radius)
|
||||||
{
|
{
|
||||||
if (ZDOMan.instance == null) return -1;
|
|
||||||
|
|
||||||
List<ZDO> zdos = new List<ZDO>();
|
List<ZDO> zdos = new List<ZDO>();
|
||||||
int index = 0;
|
if (!Gather(piecePrefabName, zdos)) return -1;
|
||||||
// The iterative sweep hands back a chunk per call and reports true when it is done. The
|
|
||||||
// guard is so a pathological world cannot spin here forever.
|
|
||||||
for (int guard = 0; guard < 1000; guard++)
|
|
||||||
{
|
|
||||||
if (ZDOMan.instance.GetAllZDOsWithPrefabIterative(piecePrefabName, zdos, ref index)) break;
|
|
||||||
}
|
|
||||||
|
|
||||||
float rangeSq = radius * radius;
|
float rangeSq = radius * radius;
|
||||||
int count = 0;
|
int count = 0;
|
||||||
|
|
@ -96,6 +141,14 @@ namespace RacesOfValheim
|
||||||
/// </summary>
|
/// </summary>
|
||||||
public static bool Allow(Player player, string piecePrefabName, Vector3 position)
|
public static bool Allow(Player player, string piecePrefabName, Vector3 position)
|
||||||
{
|
{
|
||||||
|
// The chain's own rule first: it is the more specific of the two, so it should be the one
|
||||||
|
// that gets to explain itself when both would refuse.
|
||||||
|
if (Gates.TryGetValue(piecePrefabName, out System.Func<Player, Vector3, bool> gate) &&
|
||||||
|
!gate(player, position))
|
||||||
|
{
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
if (!Limits.TryGetValue(piecePrefabName, out Limit limit)) return true;
|
if (!Limits.TryGetValue(piecePrefabName, out Limit limit)) return true;
|
||||||
|
|
||||||
int nearby = Count(piecePrefabName, position, limit.Radius);
|
int nearby = Count(piecePrefabName, position, limit.Radius);
|
||||||
|
|
|
||||||
|
|
@ -36,6 +36,9 @@ namespace RacesOfValheim
|
||||||
SkeletonConfig.Bind(Config);
|
SkeletonConfig.Bind(Config);
|
||||||
TrentaConfigManagement.Bind(Config);
|
TrentaConfigManagement.Bind(Config);
|
||||||
TrolConfig.Bind(Config);
|
TrolConfig.Bind(Config);
|
||||||
|
// Not a race: a summoned mount two races share, so it binds after the races rather
|
||||||
|
// than inside the alphabetical run above.
|
||||||
|
WarVultureConfig.Bind(Config);
|
||||||
harmony.PatchAll();
|
harmony.PatchAll();
|
||||||
gameObject.AddComponent<FenrirRace>();
|
gameObject.AddComponent<FenrirRace>();
|
||||||
gameObject.AddComponent<SkadiRace>();
|
gameObject.AddComponent<SkadiRace>();
|
||||||
|
|
@ -119,6 +122,7 @@ namespace RacesOfValheim
|
||||||
DraughRace.Instance.CreateModAssets();
|
DraughRace.Instance.CreateModAssets();
|
||||||
DvergarRace.Instance.CreateModAssets();
|
DvergarRace.Instance.CreateModAssets();
|
||||||
TrentaRace.Instance.CreateModAssets();
|
TrentaRace.Instance.CreateModAssets();
|
||||||
|
WarVultureItem.Register();
|
||||||
}
|
}
|
||||||
// --- RACE SELECTION UI ---
|
// --- RACE SELECTION UI ---
|
||||||
public void ShowRaceSelectionMenu()
|
public void ShowRaceSelectionMenu()
|
||||||
|
|
|
||||||
460
JotunnModStub/Skadi/SkadiGolem.cs
Normal file
460
JotunnModStub/Skadi/SkadiGolem.cs
Normal file
|
|
@ -0,0 +1,460 @@
|
||||||
|
using System.Collections.Generic;
|
||||||
|
using HarmonyLib;
|
||||||
|
using Jotunn.Configs;
|
||||||
|
using Jotunn.Entities;
|
||||||
|
using Jotunn.Managers;
|
||||||
|
using UnityEngine;
|
||||||
|
|
||||||
|
namespace RacesOfValheim
|
||||||
|
{
|
||||||
|
/// <summary>
|
||||||
|
/// The Skadi station: crystal golems, cut at a stonecutter and bound to it.
|
||||||
|
///
|
||||||
|
/// Eighth of the per-race item-progression chains, and the odd one out in two ways that decide
|
||||||
|
/// everything else in this file.
|
||||||
|
///
|
||||||
|
/// FIRST, the station is not ours. Every other chain builds its own bench - a trough, a bone pile,
|
||||||
|
/// a composter - and can therefore hang a MonoBehaviour on it, count its own garrison from it, and
|
||||||
|
/// mark its thralls when it falls. The stonecutter is vanilla's, and nothing here modifies it: the
|
||||||
|
/// golem carries the stonecutter's position in its own ZDO and asks the world whether one still
|
||||||
|
/// stands there. That is why this chain does not use RaisedThrall, which is otherwise exactly the
|
||||||
|
/// right component - RaisedThrall's wither depends on the station registering itself, and a vanilla
|
||||||
|
/// piece never will.
|
||||||
|
///
|
||||||
|
/// SECOND, a golem is not a follower. RaisedThrall's whole vocabulary - follow me, stand down, call
|
||||||
|
/// to arms - is wrong for something that may not leave a twenty metre circle. There is deliberately
|
||||||
|
/// no Tameable on it either: it is tame, so it will never turn on anyone, but it cannot be named,
|
||||||
|
/// ordered, or walked away with. It guards the stone that shaped it, and that is all it does.
|
||||||
|
///
|
||||||
|
/// The three limits are the design, not decoration:
|
||||||
|
/// never further than 20 m from its stonecutter (the vanilla station build range)
|
||||||
|
/// two per stonecutter
|
||||||
|
/// ten per square mile
|
||||||
|
/// The first is enforced on the golem (SkadiGolemGuard), the other two at the moment of building,
|
||||||
|
/// through PieceDensityLimit's single Player.PlacePiece prefix - refusing later would spend a
|
||||||
|
/// dragon tear before telling anyone no.
|
||||||
|
/// </summary>
|
||||||
|
public static class SkadiGolem
|
||||||
|
{
|
||||||
|
// ─── Names ───────────────────────────────────────────────────────────
|
||||||
|
public const string GolemName = "SkadiCrystalGolem";
|
||||||
|
public const string SeedPieceName = "SkadiCrystalGolemSeed";
|
||||||
|
public const string DisplayName = "Crystal Golem";
|
||||||
|
|
||||||
|
private const string SourceGolem = "StoneGolem";
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// The seed piece's model, and it is chosen for its BUILD GHOST: the golem itself only exists
|
||||||
|
/// a frame later, so a standing stone is what the player actually aims with. Everything the
|
||||||
|
/// ward DOES - the private area above all - is stripped off the clone below; a chain that
|
||||||
|
/// quietly planted a ward every time you cut a golem would be a much worse bug than a wrong
|
||||||
|
/// silhouette.
|
||||||
|
/// </summary>
|
||||||
|
private const string SourcePiece = "guard_stone";
|
||||||
|
|
||||||
|
public const string StationPrefab = "piece_stonecutter";
|
||||||
|
|
||||||
|
// ─── The price ───────────────────────────────────────────────────────
|
||||||
|
// Moder needs no state check of her own to BUILD one - her drop is in the recipe - but the
|
||||||
|
// gate asks anyway, because the recipe is not the only way an item reaches an inventory.
|
||||||
|
public const string GolemTrophy = "TrophySGolem";
|
||||||
|
public const string CrystalItem = "Crystal";
|
||||||
|
public const int CrystalCost = 10;
|
||||||
|
public const string ModerDrop = "DragonTear";
|
||||||
|
public const int ModerProgressionState = 5;
|
||||||
|
|
||||||
|
// ─── The limits ──────────────────────────────────────────────────────
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// How far a golem may get from its stonecutter. Twenty metres because that is the
|
||||||
|
/// stonecutter's own build range in vanilla, so the circle a golem defends is exactly the
|
||||||
|
/// circle it could have been built in - one number, visible in game, not two that nearly
|
||||||
|
/// agree.
|
||||||
|
/// </summary>
|
||||||
|
public const float LeashRange = 20f;
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Past this it has stopped walking home and started failing to. A golem that has been pushed
|
||||||
|
/// into water, or that stands on the wrong side of something it cannot path around, would
|
||||||
|
/// otherwise sit outside its leash forever - so at half again the leash it is simply put back.
|
||||||
|
/// It is a failsafe for a stuck pathfinder, not a movement mechanic.
|
||||||
|
/// </summary>
|
||||||
|
public const float HardLeashRange = 30f;
|
||||||
|
|
||||||
|
public const int MaxPerStation = 2;
|
||||||
|
|
||||||
|
// Ten per square mile. 2.59 km2, the same area the Fenrir's trough is measured in, so the two
|
||||||
|
// stations are spaced by the same yardstick even though the numbers differ.
|
||||||
|
public const int MaxInArea = 10;
|
||||||
|
public const float DensityAreaKm2 = 2.59f;
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// How long a golem outlives the stonecutter that cut it. Shorter than the Fenrir trough's
|
||||||
|
/// five minutes because there is nothing to rebuild: a stonecutter costs ten stone and two
|
||||||
|
/// wood, so "put it back" is a moment's work, and a longer grace would just mean a garrison
|
||||||
|
/// that survives being moved.
|
||||||
|
/// </summary>
|
||||||
|
public const float WitherSeconds = 60f;
|
||||||
|
|
||||||
|
/// <summary>Slack when asking "is my stonecutter still there" - a station never moves.</summary>
|
||||||
|
public const float StationCheckRange = 2f;
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Only asked this close to home, for the reason RaisedThrall's wither carries the same guard:
|
||||||
|
/// further out the station's zone is probably not loaded, so "nothing stands there" would be a
|
||||||
|
/// lie. A golem is leashed to 20 m anyway, so this is never the reason one survives.
|
||||||
|
/// </summary>
|
||||||
|
public const float HomeCheckRange = 40f;
|
||||||
|
|
||||||
|
// ─── Behaviour ───────────────────────────────────────────────────────
|
||||||
|
|
||||||
|
/// <summary>Idle wander around the stonecutter. Half the leash, so it never idles onto it.</summary>
|
||||||
|
private const float WanderRange = 10f;
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// The station's m_name, read off the stonecutter prefab once at registration.
|
||||||
|
///
|
||||||
|
/// It is NOT the prefab name: CraftingStation.HaveBuildStationInRange compares against
|
||||||
|
/// m_name, which is a localisation token, while Jotunn's PieceConfig.CraftingStation wants the
|
||||||
|
/// prefab name. Both spellings are needed and they are not the same string, which is exactly
|
||||||
|
/// the kind of thing worth reading off the game once instead of guessing at twice.
|
||||||
|
/// </summary>
|
||||||
|
private static string StationName = "$piece_stonecutter";
|
||||||
|
|
||||||
|
public static void Register()
|
||||||
|
{
|
||||||
|
CacheStationName();
|
||||||
|
|
||||||
|
if (!RegisterGolem()) return;
|
||||||
|
RegisterSeedPiece();
|
||||||
|
|
||||||
|
PieceDensityLimit.RegisterGate(SeedPieceName, MayRaise);
|
||||||
|
}
|
||||||
|
|
||||||
|
private static void CacheStationName()
|
||||||
|
{
|
||||||
|
GameObject station = PrefabManager.Cache.GetPrefab<GameObject>(StationPrefab);
|
||||||
|
CraftingStation component = station != null ? station.GetComponent<CraftingStation>() : null;
|
||||||
|
|
||||||
|
if (component == null || string.IsNullOrEmpty(component.m_name))
|
||||||
|
{
|
||||||
|
Jotunn.Logger.LogWarning($"[Skadi] Could not read the stonecutter's station name off " +
|
||||||
|
$"'{StationPrefab}'; falling back to '{StationName}'.");
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
StationName = component.m_name;
|
||||||
|
}
|
||||||
|
|
||||||
|
// ---------------------------------------------------------------- the golem
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// A vanilla stone golem, tamed, frozen over, and made incapable of the three things it must
|
||||||
|
/// never do.
|
||||||
|
///
|
||||||
|
/// Health, damage and resistances stay exactly as vanilla has them. A mountain golem is a slow
|
||||||
|
/// wall with a great deal of health, which is precisely what a defender that cannot leave its
|
||||||
|
/// circle should be - there is nothing to retune, and nothing here does.
|
||||||
|
///
|
||||||
|
/// What IS written over:
|
||||||
|
/// - it does not sleep. Vanilla golems start as rocks and wake when something comes near;
|
||||||
|
/// a guard that has to be woken up is not a guard.
|
||||||
|
/// - it does not target player-built anything (m_attackPlayerObjects). That is the first
|
||||||
|
/// half of "never attacks structures"; the second half is the WearNTear guard below,
|
||||||
|
/// because an area attack aimed at a greydwarf can still land on a wall.
|
||||||
|
/// - it does not flee. A golem holds its ground or it dies on it.
|
||||||
|
/// - it gives up a chase past its leash, measured from its own spawn point, which
|
||||||
|
/// SkadiGolemGuard pins to the stonecutter. That is vanilla's own leash, used as intended
|
||||||
|
/// rather than reimplemented.
|
||||||
|
/// - it drops nothing. Two golems per stonecutter that could be farmed for crystals and
|
||||||
|
/// trophies would be a mint, and the trophy is this chain's own gate item.
|
||||||
|
/// It never attacks tamed creatures or players for free: Attack.DoMeleeAttack only lets a
|
||||||
|
/// tamed attacker through to targets its own AI counts as enemies, which is checked in the
|
||||||
|
/// game's code rather than assumed here.
|
||||||
|
/// </summary>
|
||||||
|
private static bool RegisterGolem()
|
||||||
|
{
|
||||||
|
GameObject prefab = PrefabManager.Instance.CreateClonedPrefab(GolemName, SourceGolem);
|
||||||
|
if (prefab == null)
|
||||||
|
{
|
||||||
|
Jotunn.Logger.LogWarning($"[Skadi] Could not clone {SourceGolem}; {DisplayName} not registered.");
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
Character character = prefab.GetComponent<Character>();
|
||||||
|
if (character != null) character.m_name = DisplayName;
|
||||||
|
|
||||||
|
SkadiIce.Apply(prefab);
|
||||||
|
|
||||||
|
BaseAI ai = prefab.GetComponent<BaseAI>();
|
||||||
|
if (ai != null)
|
||||||
|
{
|
||||||
|
ai.m_randomMoveRange = WanderRange;
|
||||||
|
ai.m_avoidWater = true;
|
||||||
|
}
|
||||||
|
|
||||||
|
MonsterAI monster = prefab.GetComponent<MonsterAI>();
|
||||||
|
if (monster != null)
|
||||||
|
{
|
||||||
|
monster.m_sleeping = false;
|
||||||
|
monster.m_attackPlayerObjects = false;
|
||||||
|
|
||||||
|
// It notices what comes into the circle it defends, and nothing outside it. Being
|
||||||
|
// hit still turns it around - OnDamaged sets a target whatever the alert range says -
|
||||||
|
// which is the difference between a defender and a statue.
|
||||||
|
monster.m_alertRange = LeashRange;
|
||||||
|
monster.m_maxChaseDistance = LeashRange;
|
||||||
|
monster.m_fleeIfLowHealth = 0f;
|
||||||
|
monster.m_fleeIfNotAlerted = false;
|
||||||
|
monster.m_fleeIfHurtWhenTargetCantBeReached = false;
|
||||||
|
}
|
||||||
|
|
||||||
|
foreach (CharacterDrop drops in prefab.GetComponentsInChildren<CharacterDrop>(true))
|
||||||
|
{
|
||||||
|
if (drops != null) Object.DestroyImmediate(drops);
|
||||||
|
}
|
||||||
|
|
||||||
|
foreach (Procreation breeding in prefab.GetComponentsInChildren<Procreation>(true))
|
||||||
|
{
|
||||||
|
if (breeding != null) Object.DestroyImmediate(breeding);
|
||||||
|
}
|
||||||
|
|
||||||
|
// "Ten seconds unhurt, then 2% a second" - the Skeleton's sentry regeneration, which three
|
||||||
|
// chains now share. A guard that cannot heal between raids is a guard you rebuild.
|
||||||
|
prefab.AddComponent<SkeletonSentryBehaviour>();
|
||||||
|
|
||||||
|
prefab.AddComponent<SkadiGolemGuard>();
|
||||||
|
|
||||||
|
PrefabManager.Instance.AddPrefab(prefab);
|
||||||
|
Jotunn.Logger.LogInfo($"[Skadi] {GolemName} from '{SourceGolem}': awake, tame, leashed, " +
|
||||||
|
"blind to structures, drops nothing.");
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
// ---------------------------------------------------------------- the seed piece
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// The hammer entry, and the same trick SkeletonSentry uses for the same reason: the hammer
|
||||||
|
/// builds Piece, a golem is a Character, so a piece is placed and swaps itself for one.
|
||||||
|
/// </summary>
|
||||||
|
private static void RegisterSeedPiece()
|
||||||
|
{
|
||||||
|
GameObject prefab = PrefabManager.Instance.CreateClonedPrefab(SeedPieceName, SourcePiece);
|
||||||
|
if (prefab == null)
|
||||||
|
{
|
||||||
|
Jotunn.Logger.LogWarning($"[Skadi] Could not clone {SourcePiece}; {DisplayName} cannot be built.");
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Everything the ward does goes - PrivateArea and its effect areas above all. What is
|
||||||
|
// wanted is a placeable shell with the right outline, alive for one frame.
|
||||||
|
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);
|
||||||
|
}
|
||||||
|
|
||||||
|
AswidBloodRefinery.StripOffensive(prefab, SeedPieceName);
|
||||||
|
SkadiIce.Apply(prefab);
|
||||||
|
|
||||||
|
prefab.AddComponent<SkadiGolemSeed>();
|
||||||
|
|
||||||
|
Piece piece = prefab.GetComponent<Piece>() ?? prefab.AddComponent<Piece>();
|
||||||
|
piece.m_resources = new Piece.Requirement[0];
|
||||||
|
piece.m_name = DisplayName;
|
||||||
|
piece.m_canBeRemoved = true;
|
||||||
|
piece.m_groundPiece = true;
|
||||||
|
piece.m_groundOnly = true;
|
||||||
|
piece.m_icon = BorrowIcon(CrystalItem);
|
||||||
|
|
||||||
|
PieceManager.Instance.AddPiece(new CustomPiece(prefab, fixReference: false, new PieceConfig
|
||||||
|
{
|
||||||
|
Name = DisplayName,
|
||||||
|
Description = "Cut at the stone and woken with a tear. It will not follow you, and it " +
|
||||||
|
"will not leave the stonecutter that shaped it.",
|
||||||
|
PieceTable = PieceTables.Hammer,
|
||||||
|
Category = PieceCategories.Crafting,
|
||||||
|
// The stonecutter is the station, so vanilla itself refuses to place one anywhere its
|
||||||
|
// golem could not then be bound - the gate below never has to be the first to say no.
|
||||||
|
CraftingStation = CraftingStations.Stonecutter,
|
||||||
|
Icon = BorrowIcon(CrystalItem),
|
||||||
|
Requirements = new[]
|
||||||
|
{
|
||||||
|
new RequirementConfig(GolemTrophy, 1, 0, true),
|
||||||
|
new RequirementConfig(CrystalItem, CrystalCost, 0, true),
|
||||||
|
new RequirementConfig(ModerDrop, 1, 0, true),
|
||||||
|
}
|
||||||
|
}));
|
||||||
|
}
|
||||||
|
|
||||||
|
// ---------------------------------------------------------------- the gate
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// The two caps that cannot live on the golem, asked at the moment of building.
|
||||||
|
///
|
||||||
|
/// Order matters: race, then boss, then the stonecutter, then its own two, so the first thing
|
||||||
|
/// a player is told is the thing they can actually do something about.
|
||||||
|
///
|
||||||
|
/// HONEST LIMIT, inherited from PieceDensityLimit and worth repeating: the counts are over
|
||||||
|
/// ZDOs, which on a remote client are only the ZDOs the server has sent. On the host they are
|
||||||
|
/// exact. Where a count cannot be taken at all the placement is allowed - refusing on no
|
||||||
|
/// information is worse than a cap that occasionally misses.
|
||||||
|
/// </summary>
|
||||||
|
public static bool MayRaise(Player player, Vector3 position)
|
||||||
|
{
|
||||||
|
if (player == null) return true;
|
||||||
|
|
||||||
|
if (!SkadiRace.IsLocalSkadi())
|
||||||
|
{
|
||||||
|
player.Message(MessageHud.MessageType.Center, "The stone does not answer to you.");
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (BossProgressionManager.GetCurrentProgressionState() < ModerProgressionState)
|
||||||
|
{
|
||||||
|
player.Message(MessageHud.MessageType.Center,
|
||||||
|
"The tear is cold. Nothing wakes in the stone until the mountain's queen has fallen.");
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
CraftingStation station = FindStonecutter(position);
|
||||||
|
if (station == null)
|
||||||
|
{
|
||||||
|
player.Message(MessageHud.MessageType.Center, "It needs a stonecutter to be cut at.");
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
int bound = CountBoundTo(station.transform.position);
|
||||||
|
if (bound >= MaxPerStation)
|
||||||
|
{
|
||||||
|
player.Message(MessageHud.MessageType.Center,
|
||||||
|
$"That stonecutter already holds {bound}. It will not hold more.");
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
int nearby = PieceDensityLimit.Count(GolemName, position, PieceDensityLimit.RadiusForArea(DensityAreaKm2));
|
||||||
|
if (nearby >= MaxInArea)
|
||||||
|
{
|
||||||
|
player.Message(MessageHud.MessageType.Center,
|
||||||
|
$"There are already {nearby} of these within a day's walk. The stone is spent.");
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// The stonecutter that owns a point, by the station's OWN build range rather than by a number
|
||||||
|
/// of ours - so the circle a golem may be cut in and the circle it may stand in are the same
|
||||||
|
/// circle, and stay the same if a game update retunes the station.
|
||||||
|
/// </summary>
|
||||||
|
public static CraftingStation FindStonecutter(Vector3 position)
|
||||||
|
{
|
||||||
|
return CraftingStation.HaveBuildStationInRange(StationName, position);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>True if a stonecutter still stands at that exact point.</summary>
|
||||||
|
public static bool StonecutterStandsAt(Vector3 position)
|
||||||
|
{
|
||||||
|
return CraftingStation.FindClosestStationInRange(StationName, position, StationCheckRange) != null;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// How many golems already answer to the stonecutter at that point, counted over ZDOs and not
|
||||||
|
/// over loaded creatures.
|
||||||
|
///
|
||||||
|
/// That distinction is the whole cap: a golem in an unloaded zone is still a golem, and
|
||||||
|
/// counting only what is loaded would make walking away and coming back the way to hold six.
|
||||||
|
/// Dead ones are gone from the world entirely, so a slot frees itself with no bookkeeping.
|
||||||
|
/// </summary>
|
||||||
|
public static int CountBoundTo(Vector3 station)
|
||||||
|
{
|
||||||
|
List<ZDO> zdos = new List<ZDO>();
|
||||||
|
if (!PieceDensityLimit.Gather(GolemName, zdos)) return 0;
|
||||||
|
|
||||||
|
int count = 0;
|
||||||
|
foreach (ZDO zdo in zdos)
|
||||||
|
{
|
||||||
|
if (zdo == null) continue;
|
||||||
|
|
||||||
|
// A generous epsilon: a station never moves, so this only has to survive float
|
||||||
|
// round-tripping through the ZDO.
|
||||||
|
Vector3 anchor = zdo.GetVec3(SkadiGolemGuard.KeyAnchor, Vector3.zero);
|
||||||
|
if (anchor != Vector3.zero && Vector3.SqrMagnitude(anchor - station) < 0.25f) count++;
|
||||||
|
}
|
||||||
|
|
||||||
|
return count;
|
||||||
|
}
|
||||||
|
|
||||||
|
// ---------------------------------------------------------------- known pieces
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Learnt by being Skadi, and not by having killed Moder.
|
||||||
|
///
|
||||||
|
/// Deliberate: the entry shows up greyed out with its price on it, which is how every vanilla
|
||||||
|
/// recipe tells you what to go and get. Gating the entry itself on the boss would hide it
|
||||||
|
/// until a relog anyway - OnSpawned is the only moment this is asked - so the boss check lives
|
||||||
|
/// where it can be asked every time instead, in MayRaise.
|
||||||
|
/// </summary>
|
||||||
|
public static void EnsureKnown(Player player)
|
||||||
|
{
|
||||||
|
if (player == null || !SkadiRace.IsLocalSkadi()) return;
|
||||||
|
|
||||||
|
GameObject prefab = PrefabManager.Instance.GetPrefab(SeedPieceName);
|
||||||
|
Piece piece = prefab != null ? prefab.GetComponent<Piece>() : null;
|
||||||
|
if (piece == null) return;
|
||||||
|
|
||||||
|
Traverse traverse = Traverse.Create(player);
|
||||||
|
traverse.Method("AddKnownPiece", piece).GetValue();
|
||||||
|
traverse.Method("UpdateAvailablePiecesList").GetValue();
|
||||||
|
}
|
||||||
|
|
||||||
|
private static Sprite BorrowIcon(string prefabName)
|
||||||
|
{
|
||||||
|
ItemDrop drop = PrefabManager.Cache.GetPrefab<ItemDrop>(prefabName);
|
||||||
|
Sprite[] icons = drop != null && drop.m_itemData != null && drop.m_itemData.m_shared != null
|
||||||
|
? drop.m_itemData.m_shared.m_icons
|
||||||
|
: null;
|
||||||
|
if (icons != null && icons.Length > 0 && icons[0] != null) return icons[0];
|
||||||
|
|
||||||
|
Jotunn.Logger.LogWarning($"[Skadi] Could not borrow the icon from '{prefabName}'.");
|
||||||
|
return null;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
[HarmonyPatch(typeof(Player), "OnSpawned")]
|
||||||
|
public static class SkadiGolemKnownPatch
|
||||||
|
{
|
||||||
|
public static void Postfix(Player __instance)
|
||||||
|
{
|
||||||
|
if (__instance != Player.m_localPlayer) return;
|
||||||
|
SkadiGolem.EnsureKnown(__instance);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// The second half of "it never attacks structures".
|
||||||
|
///
|
||||||
|
/// m_attackPlayerObjects stops a golem CHOOSING a wall as a target; it does not stop one landing a
|
||||||
|
/// swing on the wall behind a greydwarf, because Attack.DoMeleeAttack has no tamed check on the
|
||||||
|
/// destructible path at all - only on the character one. Read off the game's own code rather than
|
||||||
|
/// assumed, and it is why this patch exists instead of one field being trusted to do both jobs.
|
||||||
|
///
|
||||||
|
/// The signature is spelled out and bound positionally for the reason PieceDensityLimitPatch
|
||||||
|
/// carries in its own comment: Damage returns VOID, so a prefix returning false is the whole
|
||||||
|
/// mechanism, and asking for a __result on a void method throws at patch time and takes the rest
|
||||||
|
/// of the mod's patches down with it.
|
||||||
|
/// </summary>
|
||||||
|
[HarmonyPatch(typeof(WearNTear), "Damage", new[] { typeof(HitData) })]
|
||||||
|
public static class SkadiGolemStructureGuardPatch
|
||||||
|
{
|
||||||
|
public static bool Prefix(HitData __0)
|
||||||
|
{
|
||||||
|
if (__0 == null) return true;
|
||||||
|
|
||||||
|
Character attacker = __0.GetAttacker();
|
||||||
|
return attacker == null || attacker.GetComponent<SkadiGolemGuard>() == null;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
302
JotunnModStub/Skadi/SkadiGolemBehaviour.cs
Normal file
302
JotunnModStub/Skadi/SkadiGolemBehaviour.cs
Normal file
|
|
@ -0,0 +1,302 @@
|
||||||
|
using System;
|
||||||
|
using HarmonyLib;
|
||||||
|
using UnityEngine;
|
||||||
|
|
||||||
|
namespace RacesOfValheim
|
||||||
|
{
|
||||||
|
/// <summary>
|
||||||
|
/// One crystal golem: tame, bound to a stonecutter, and unable to get more than its leash away
|
||||||
|
/// from it.
|
||||||
|
///
|
||||||
|
/// Same shape as RaisedThrall - an anchor in the creature's own ZDO, a leash pinned to it, a
|
||||||
|
/// wither clock that starts when the station is gone - and deliberately NOT that class. Two
|
||||||
|
/// differences make it a copy rather than a reuse, and both are in SkadiGolem's own comment: the
|
||||||
|
/// station is vanilla's and cannot register itself, and a golem takes no orders, so the follow,
|
||||||
|
/// stand-down and call-to-arms half of RaisedThrall is not merely unused here but wrong.
|
||||||
|
///
|
||||||
|
/// The leash is three layers, weakest first, because each one covers the case the one before it
|
||||||
|
/// cannot:
|
||||||
|
/// - vanilla's own chase limit (m_maxChaseDistance, measured from m_spawnPoint, which is pinned
|
||||||
|
/// to the stonecutter below) makes it GIVE UP on anything it would have to leave home for;
|
||||||
|
/// - the patrol point, re-pinned every tick, is what brings it back and what keeps it wandering
|
||||||
|
/// around the station rather than drifting after it has been pushed or knocked back;
|
||||||
|
/// - and past half again the leash it is simply put back, because at that distance it is not
|
||||||
|
/// walking home slowly, it is failing to walk home at all.
|
||||||
|
/// </summary>
|
||||||
|
public class SkadiGolemGuard : MonoBehaviour
|
||||||
|
{
|
||||||
|
public const string KeyAnchor = "RoV_golemAnchor";
|
||||||
|
public const string KeyOrphanAt = "RoV_golemOrphanAt";
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// One second, and not the two RaisedThrall uses. Vanilla will not drop a target it can still
|
||||||
|
/// SEE, whatever m_maxChaseDistance says - read off MonsterAI.UpdateTarget, where the give-up
|
||||||
|
/// test also wants a second of having lost sight of it - so this tick is what actually holds
|
||||||
|
/// the leash, and how far past twenty metres a golem gets is how far it walks between two of
|
||||||
|
/// them. A stone golem is slow; at one second that is a stride.
|
||||||
|
/// </summary>
|
||||||
|
private const float TickSeconds = 1f;
|
||||||
|
|
||||||
|
// SetPatrolPoint(Vector3) is private - only the parameterless overload, which uses the
|
||||||
|
// creature's current position, is public. Resolved once here rather than per call, exactly as
|
||||||
|
// RaisedThrall does it.
|
||||||
|
private static readonly System.Reflection.MethodInfo SetPatrolPointMethod =
|
||||||
|
AccessTools.Method(typeof(BaseAI), "SetPatrolPoint", new[] { typeof(Vector3) });
|
||||||
|
|
||||||
|
// m_spawnPoint is protected, and it is the point vanilla measures m_maxChaseDistance from -
|
||||||
|
// read off MonsterAI.UpdateTarget rather than assumed, because "chase distance" could just as
|
||||||
|
// easily have meant distance from the target.
|
||||||
|
private static readonly System.Reflection.FieldInfo SpawnPointField =
|
||||||
|
AccessTools.Field(typeof(BaseAI), "m_spawnPoint");
|
||||||
|
|
||||||
|
private Character m_character;
|
||||||
|
private BaseAI m_ai;
|
||||||
|
private MonsterAI m_monsterAI;
|
||||||
|
private ZNetView m_nview;
|
||||||
|
private Rigidbody m_body;
|
||||||
|
|
||||||
|
private void Awake()
|
||||||
|
{
|
||||||
|
m_character = GetComponent<Character>();
|
||||||
|
m_ai = GetComponent<BaseAI>();
|
||||||
|
m_monsterAI = GetComponent<MonsterAI>();
|
||||||
|
m_nview = GetComponent<ZNetView>();
|
||||||
|
m_body = GetComponent<Rigidbody>();
|
||||||
|
|
||||||
|
InvokeRepeating("Tick", TickSeconds, TickSeconds);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>Where the stonecutter that cut this one stands, or null if it was cut by none.</summary>
|
||||||
|
public Vector3? Anchor
|
||||||
|
{
|
||||||
|
get
|
||||||
|
{
|
||||||
|
if (m_nview == null || !m_nview.IsValid()) return null;
|
||||||
|
|
||||||
|
Vector3 anchor = m_nview.GetZDO().GetVec3(KeyAnchor, Vector3.zero);
|
||||||
|
return anchor == Vector3.zero ? (Vector3?)null : anchor;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Called once, by the seed piece that placed it. Tames it, marks whose stonecutter it is, and
|
||||||
|
/// sends it home - all three, so nothing else has to remember to do any of them.
|
||||||
|
/// </summary>
|
||||||
|
public void Bind(Vector3 anchor)
|
||||||
|
{
|
||||||
|
if (m_nview == null || !m_nview.IsValid()) return;
|
||||||
|
|
||||||
|
m_nview.GetZDO().Set(KeyAnchor, anchor);
|
||||||
|
|
||||||
|
if (m_monsterAI != null) m_monsterAI.MakeTame();
|
||||||
|
if (m_character != null) m_character.SetTamed(true);
|
||||||
|
|
||||||
|
GoHome();
|
||||||
|
}
|
||||||
|
|
||||||
|
// ---------------------------------------------------------------- the tick
|
||||||
|
|
||||||
|
private void Tick()
|
||||||
|
{
|
||||||
|
if (m_nview == null || !m_nview.IsValid() || !m_nview.IsOwner()) return;
|
||||||
|
if (m_character == null || m_character.IsDead()) return;
|
||||||
|
|
||||||
|
if (TickWither()) return;
|
||||||
|
|
||||||
|
Vector3? anchor = Anchor;
|
||||||
|
if (anchor == null) return;
|
||||||
|
|
||||||
|
float distance = Vector3.Distance(transform.position, anchor.Value);
|
||||||
|
|
||||||
|
if (distance > SkadiGolem.LeashRange)
|
||||||
|
{
|
||||||
|
// Whatever it was going after is outside the circle it defends, so it stops going
|
||||||
|
// after it. Vanilla would drop the target itself a second or so later through
|
||||||
|
// m_maxChaseDistance; doing it here as well means the leash does not depend on that
|
||||||
|
// one field surviving a game update.
|
||||||
|
ClearTarget();
|
||||||
|
}
|
||||||
|
|
||||||
|
if (distance > SkadiGolem.HardLeashRange) SnapHome(anchor.Value);
|
||||||
|
|
||||||
|
// Every tick, and not only when it has strayed: this is also what pins m_spawnPoint after
|
||||||
|
// a zone reload, where Bind is never called again.
|
||||||
|
GoHome();
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Starts the clock when the stonecutter is gone, and stops the golem when it runs out.
|
||||||
|
/// Returns true once it has done so, so the caller stops bothering with it.
|
||||||
|
///
|
||||||
|
/// Without some form of this a stonecutter is a duplication exploit: cut two golems, take the
|
||||||
|
/// stonecutter down, put it up somewhere else, and keep both from every round.
|
||||||
|
/// </summary>
|
||||||
|
private bool TickWither()
|
||||||
|
{
|
||||||
|
Vector3? anchor = Anchor;
|
||||||
|
if (anchor == null || ZNet.instance == null) return false;
|
||||||
|
|
||||||
|
long stamp = m_nview.GetZDO().GetLong(KeyOrphanAt, 0L);
|
||||||
|
|
||||||
|
if (stamp == 0L)
|
||||||
|
{
|
||||||
|
// Only asked from close to home - see SkadiGolem.HomeCheckRange. Being leashed to
|
||||||
|
// twenty metres, a golem is essentially always close enough, so this guard is about
|
||||||
|
// the moment after a zone loads rather than about distance.
|
||||||
|
if (Vector3.SqrMagnitude(transform.position - anchor.Value) >
|
||||||
|
SkadiGolem.HomeCheckRange * SkadiGolem.HomeCheckRange) return false;
|
||||||
|
|
||||||
|
if (SkadiGolem.StonecutterStandsAt(anchor.Value)) return false;
|
||||||
|
|
||||||
|
MarkOrphaned();
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Put back in time, on the same spot: the clock is cleared and the golem lives. It opens
|
||||||
|
// no exploit - a stonecutter on the same spot owns these golems by anchor anyway.
|
||||||
|
if (SkadiGolem.StonecutterStandsAt(anchor.Value))
|
||||||
|
{
|
||||||
|
m_nview.GetZDO().Set(KeyOrphanAt, 0L);
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
double elapsed = (ZNet.instance.GetTime() - new DateTime(stamp)).TotalSeconds;
|
||||||
|
if (elapsed < SkadiGolem.WitherSeconds) return false;
|
||||||
|
|
||||||
|
Crumble();
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>Starts the wither clock, once. Idempotent, so it cannot be restarted and keep an
|
||||||
|
/// orphan alive forever.</summary>
|
||||||
|
private void MarkOrphaned()
|
||||||
|
{
|
||||||
|
if (m_nview == null || !m_nview.IsValid() || ZNet.instance == null) return;
|
||||||
|
if (m_nview.GetZDO().GetLong(KeyOrphanAt, 0L) != 0L) return;
|
||||||
|
|
||||||
|
m_nview.ClaimOwnership();
|
||||||
|
m_nview.GetZDO().Set(KeyOrphanAt, ZNet.instance.GetTime().Ticks);
|
||||||
|
|
||||||
|
if (Player.m_localPlayer != null &&
|
||||||
|
Vector3.Distance(Player.m_localPlayer.transform.position, transform.position) < 30f)
|
||||||
|
{
|
||||||
|
Player.m_localPlayer.Message(MessageHud.MessageType.Center,
|
||||||
|
"The stonecutter is gone. What it cut will not outlast it by long.");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Pins the patrol point - and the spawn point vanilla measures its own chase limit from -
|
||||||
|
/// back onto the stonecutter. Cheap enough to call on a timer, and calling it repeatedly is
|
||||||
|
/// what stops a golem drifting after it has been pushed or knocked back.
|
||||||
|
/// </summary>
|
||||||
|
private void GoHome()
|
||||||
|
{
|
||||||
|
Vector3? anchor = Anchor;
|
||||||
|
if (anchor == null || m_ai == null) return;
|
||||||
|
|
||||||
|
if (SpawnPointField != null) SpawnPointField.SetValue(m_ai, anchor.Value);
|
||||||
|
|
||||||
|
if (SetPatrolPointMethod != null)
|
||||||
|
{
|
||||||
|
SetPatrolPointMethod.Invoke(m_ai, new object[] { anchor.Value });
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
// Fall back to writing the two fields the private method writes.
|
||||||
|
Traverse traverse = Traverse.Create(m_ai);
|
||||||
|
traverse.Field("m_patrolPoint").SetValue(anchor.Value);
|
||||||
|
traverse.Field("m_patrol").SetValue(true);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>Forgets whatever it was going after, creature or otherwise.</summary>
|
||||||
|
private void ClearTarget()
|
||||||
|
{
|
||||||
|
if (m_monsterAI == null) return;
|
||||||
|
|
||||||
|
Traverse traverse = Traverse.Create(m_monsterAI);
|
||||||
|
traverse.Field("m_targetCreature").SetValue(null);
|
||||||
|
traverse.Field("m_targetStatic").SetValue(null);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// The failsafe, and only that. A golem that is this far out has not wandered - it has been
|
||||||
|
/// pushed somewhere it cannot path back from, and the alternative to putting it back is one
|
||||||
|
/// that stands in a lake until its stonecutter falls.
|
||||||
|
/// </summary>
|
||||||
|
private void SnapHome(Vector3 anchor)
|
||||||
|
{
|
||||||
|
Vector2 offset = UnityEngine.Random.insideUnitCircle * 3f;
|
||||||
|
Vector3 destination = anchor + new Vector3(offset.x, 0.5f, offset.y);
|
||||||
|
|
||||||
|
transform.position = destination;
|
||||||
|
if (m_body != null) m_body.linearVelocity = Vector3.zero;
|
||||||
|
|
||||||
|
ClearTarget();
|
||||||
|
|
||||||
|
Jotunn.Logger.LogWarning($"[Skadi] A golem was {SkadiGolem.HardLeashRange:0} m or more from its " +
|
||||||
|
"stonecutter and could not walk back; it was put back.");
|
||||||
|
}
|
||||||
|
|
||||||
|
private void Crumble()
|
||||||
|
{
|
||||||
|
if (m_character == null || m_character.IsDead()) return;
|
||||||
|
|
||||||
|
HitData hit = new HitData();
|
||||||
|
hit.m_damage.m_damage = 1E+10f;
|
||||||
|
hit.m_hitType = HitData.HitType.Undefined;
|
||||||
|
m_character.ApplyDamage(hit, true, false);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Lives for one frame: swaps itself for the golem and goes. Owner only, so in multiplayer exactly
|
||||||
|
/// one golem stands up rather than one per client.
|
||||||
|
///
|
||||||
|
/// The stonecutter is looked up again here rather than handed over by the placement gate, and that
|
||||||
|
/// is deliberate: both call SkadiGolem.FindStonecutter with the same point, so both get the same
|
||||||
|
/// answer, and there is no piece of state between them that can go stale or arrive out of order.
|
||||||
|
///
|
||||||
|
/// If the lookup comes back empty the materials are lost, and that is the honest outcome rather
|
||||||
|
/// than an oversight: it can only happen if the stonecutter was taken down between the gate saying
|
||||||
|
/// yes and this frame, and the alternative - a golem anchored to nothing - would wither in a
|
||||||
|
/// minute anyway while looking like a bug.
|
||||||
|
/// </summary>
|
||||||
|
public class SkadiGolemSeed : MonoBehaviour
|
||||||
|
{
|
||||||
|
private void Start()
|
||||||
|
{
|
||||||
|
ZNetView nview = GetComponent<ZNetView>();
|
||||||
|
if (nview == null || !nview.IsValid() || !nview.IsOwner()) return;
|
||||||
|
|
||||||
|
GameObject prefab = ZNetScene.instance != null
|
||||||
|
? ZNetScene.instance.GetPrefab(SkadiGolem.GolemName)
|
||||||
|
: null;
|
||||||
|
|
||||||
|
if (prefab == null)
|
||||||
|
{
|
||||||
|
Jotunn.Logger.LogWarning($"[Skadi] No '{SkadiGolem.GolemName}' in ZNetScene; nothing was cut.");
|
||||||
|
ZNetScene.instance.Destroy(gameObject);
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
CraftingStation station = SkadiGolem.FindStonecutter(transform.position);
|
||||||
|
if (station == null)
|
||||||
|
{
|
||||||
|
Jotunn.Logger.LogWarning("[Skadi] No stonecutter in range at the moment of cutting; " +
|
||||||
|
"nothing was raised.");
|
||||||
|
ZNetScene.instance.Destroy(gameObject);
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
GameObject spawned = Instantiate(prefab, transform.position, transform.rotation);
|
||||||
|
|
||||||
|
// Bind tames it, marks whose stonecutter it is, and sends it home - all three.
|
||||||
|
SkadiGolemGuard guard = spawned.GetComponent<SkadiGolemGuard>();
|
||||||
|
if (guard != null) guard.Bind(station.transform.position);
|
||||||
|
|
||||||
|
ZNetScene.instance.Destroy(gameObject);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
@ -56,6 +56,7 @@ namespace RacesOfValheim
|
||||||
// bench - and the staff's recipe references it by name too.
|
// bench - and the staff's recipe references it by name too.
|
||||||
SkadiFrostHeart.Register();
|
SkadiFrostHeart.Register();
|
||||||
SkadiNokkel.Register();
|
SkadiNokkel.Register();
|
||||||
|
SkadiGolem.Register();
|
||||||
|
|
||||||
var se = ScriptableObject.CreateInstance<SE_SkadiStats>();
|
var se = ScriptableObject.CreateInstance<SE_SkadiStats>();
|
||||||
se.name = "SE_SkadiStats";
|
se.name = "SE_SkadiStats";
|
||||||
|
|
|
||||||
109
JotunnModStub/WarVulture/WarVultureConfig.cs
Normal file
109
JotunnModStub/WarVulture/WarVultureConfig.cs
Normal file
|
|
@ -0,0 +1,109 @@
|
||||||
|
using BepInEx.Configuration;
|
||||||
|
|
||||||
|
namespace RacesOfValheim
|
||||||
|
{
|
||||||
|
/// <summary>
|
||||||
|
/// Every tunable number behind the War Vulture, bound as BepInEx ConfigEntry so it shows up in
|
||||||
|
/// Configuration Manager - same shape as TrolConfig, which is the house model for this.
|
||||||
|
///
|
||||||
|
/// The three numbers most likely to need a pass in game are deliberately here rather than in
|
||||||
|
/// code: MountSize, MountOffsetY and MountOffsetZ. Where a bird sits under a rider is the one
|
||||||
|
/// thing the last attempt lost three rounds to (section 16.6 of the design doc: measure a
|
||||||
|
/// relation, never pick a number in metres from the armchair), and a value that can be dragged
|
||||||
|
/// in the menu while standing in the world beats another compile.
|
||||||
|
///
|
||||||
|
/// No keybind is bound here on purpose. The mount answers to LEFT CLICK on the item and to the
|
||||||
|
/// vanilla run key, so there is nothing new to learn and nothing new to rebind.
|
||||||
|
/// </summary>
|
||||||
|
public static class WarVultureConfig
|
||||||
|
{
|
||||||
|
// ─── Access ────────────────────────────────────────────────────────────
|
||||||
|
public static ConfigEntry<string> AllowedRaces;
|
||||||
|
|
||||||
|
// ─── Flight ────────────────────────────────────────────────────────────
|
||||||
|
public static ConfigEntry<float> CruiseSpeed;
|
||||||
|
public static ConfigEntry<float> SprintSpeed;
|
||||||
|
public static ConfigEntry<float> SprintSeconds;
|
||||||
|
public static ConfigEntry<float> RechargeSeconds;
|
||||||
|
public static ConfigEntry<float> LandingSpeed;
|
||||||
|
|
||||||
|
// ─── Model ─────────────────────────────────────────────────────────────
|
||||||
|
public static ConfigEntry<float> HandModelScale;
|
||||||
|
public static ConfigEntry<float> MountSize;
|
||||||
|
public static ConfigEntry<string> SeatBone;
|
||||||
|
public static ConfigEntry<float> SeatNudgeY;
|
||||||
|
public static ConfigEntry<float> SeatNudgeZ;
|
||||||
|
|
||||||
|
// ─── Interface ─────────────────────────────────────────────────────────
|
||||||
|
public static ConfigEntry<bool> ShowStaminaBar;
|
||||||
|
|
||||||
|
public static void Bind(ConfigFile config)
|
||||||
|
{
|
||||||
|
const string access = "War Vulture - Access";
|
||||||
|
AllowedRaces = config.Bind(access, "Allowed races", "Furling,Dvergar",
|
||||||
|
new ConfigDescription("Comma separated list of race ids that can call the vulture. " +
|
||||||
|
"In anyone else's hands the item is an inert trophy on a stick. " +
|
||||||
|
"Leave empty to let every race ride."));
|
||||||
|
|
||||||
|
const string flight = "War Vulture - Flight";
|
||||||
|
// 7 and 13 are not proposals: they are m_flySlowSpeed and m_flyFastSpeed read off the
|
||||||
|
// vanilla Volture at runtime (design doc 15.13). A number read from the game survives a
|
||||||
|
// Valheim patch; a number invented here does not.
|
||||||
|
CruiseSpeed = config.Bind(flight, "Cruise speed", 7f,
|
||||||
|
new ConfigDescription("Metres per second with the run key up. This one is unlimited - " +
|
||||||
|
"vultures stay up for hours."));
|
||||||
|
SprintSpeed = config.Bind(flight, "Sprint speed", 13f,
|
||||||
|
new ConfigDescription("Metres per second while the run key is held and the bird still " +
|
||||||
|
"has wind in it."));
|
||||||
|
SprintSeconds = config.Bind(flight, "Sprint seconds", 10f,
|
||||||
|
new ConfigDescription("How long full speed lasts before the bird drops back to cruise."));
|
||||||
|
RechargeSeconds = config.Bind(flight, "Recharge seconds", 10f,
|
||||||
|
new ConfigDescription("How long a spent bird takes to fill up again. It recharges in the " +
|
||||||
|
"air as soon as the run key is released - landing is not required."));
|
||||||
|
LandingSpeed = config.Bind(flight, "Landing speed", 12f,
|
||||||
|
new ConfigDescription("Metres per second of the automatic descent after the dismount " +
|
||||||
|
"click. The controls are ignored until the ground arrives."));
|
||||||
|
|
||||||
|
const string model = "War Vulture - Model";
|
||||||
|
HandModelScale = config.Bind(model, "Hand model scale", 0.6f,
|
||||||
|
new ConfigDescription("Size of the vulture trophy carried in hand, as a fraction of the " +
|
||||||
|
"real trophy. 0.6 is the 40% smaller that was asked for."));
|
||||||
|
MountSize = config.Bind(model, "Mount size", 7.75f,
|
||||||
|
new ConfigDescription("Largest dimension of the bird under the rider, in metres. 7.75 is " +
|
||||||
|
"the vanilla Volture's own mesh, wings included."));
|
||||||
|
// The rider is glued to a BONE, not to a height: the bird's back rises and falls with
|
||||||
|
// every wingbeat, and any offset in metres can only be right on one frame of that.
|
||||||
|
SeatBone = config.Bind(model, "Seat bone", "",
|
||||||
|
new ConfigDescription("Name (or part of a name) of the bone on the vulture's skeleton the " +
|
||||||
|
"rider sits on. Empty picks the last spine/chest bone automatically, " +
|
||||||
|
"which is what the bird actually flies with."));
|
||||||
|
SeatNudgeY = config.Bind(model, "Seat nudge Y", 0f,
|
||||||
|
new ConfigDescription("Fine adjustment up (+) or down (-) from the seat bone, in metres. " +
|
||||||
|
"Zero means exactly on the bone."));
|
||||||
|
SeatNudgeZ = config.Bind(model, "Seat nudge Z", 0f,
|
||||||
|
new ConfigDescription("Fine adjustment forward (+) or back (-) from the seat bone, in metres."));
|
||||||
|
|
||||||
|
const string ui = "War Vulture - Interface";
|
||||||
|
ShowStaminaBar = config.Bind(ui, "Show stamina bar", true,
|
||||||
|
new ConfigDescription("Draws the bird's own wind as a bar under the player's stamina, " +
|
||||||
|
"cloned from vanilla's mount stamina bar."));
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Whether a race id may call the bird. An empty list means everyone, which is the honest
|
||||||
|
/// reading of "no restriction" and is also what makes this testable on any character.
|
||||||
|
/// </summary>
|
||||||
|
public static bool RaceAllowed(string race)
|
||||||
|
{
|
||||||
|
string list = AllowedRaces != null ? AllowedRaces.Value : null;
|
||||||
|
if (string.IsNullOrEmpty(list)) return true;
|
||||||
|
if (string.IsNullOrEmpty(race)) return false;
|
||||||
|
|
||||||
|
foreach (string entry in list.Split(','))
|
||||||
|
{
|
||||||
|
if (entry.Trim().Equals(race.Trim(), System.StringComparison.OrdinalIgnoreCase)) return true;
|
||||||
|
}
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
116
JotunnModStub/WarVulture/WarVultureHud.cs
Normal file
116
JotunnModStub/WarVulture/WarVultureHud.cs
Normal file
|
|
@ -0,0 +1,116 @@
|
||||||
|
using System.Reflection;
|
||||||
|
using HarmonyLib;
|
||||||
|
using UnityEngine;
|
||||||
|
|
||||||
|
namespace RacesOfValheim
|
||||||
|
{
|
||||||
|
/// <summary>
|
||||||
|
/// The bird's wind, as a bar under the player's stamina.
|
||||||
|
///
|
||||||
|
/// It is a CLONE of vanilla's own mount stamina bar, not a bar drawn from scratch, for two
|
||||||
|
/// reasons: it is already skinned, sized and animated like every other bar in the game, and it
|
||||||
|
/// is semantically the same thing - Hud.UpdateMount drives that bar from Sadle.GetStamina for
|
||||||
|
/// the asksvin. Ours is the same idea with a different animal underneath.
|
||||||
|
///
|
||||||
|
/// Vanilla's copy cannot simply be borrowed where it stands: Hud.UpdateMount switches the whole
|
||||||
|
/// mount panel off on every frame in which the player is not on a Sadle, and it would take the
|
||||||
|
/// bar with it. The clone is reparented out of that panel, so vanilla never touches it again.
|
||||||
|
///
|
||||||
|
/// Everything here is reflection because GuiBar lives in assembly_guiutils, which this project
|
||||||
|
/// does not reference - and adding a reference to the csproj is a bigger change than a bar is
|
||||||
|
/// worth. Every step is null-checked: a bar that fails to build costs the bar and nothing else,
|
||||||
|
/// which is the right trade for an ornament on a flying mount.
|
||||||
|
/// </summary>
|
||||||
|
public class WarVultureHud
|
||||||
|
{
|
||||||
|
private const float BelowStaminaPixels = 24f;
|
||||||
|
|
||||||
|
private readonly WarVultureMount mount;
|
||||||
|
private readonly GameObject barObject;
|
||||||
|
private readonly Component guiBar;
|
||||||
|
private readonly MethodInfo setValue;
|
||||||
|
|
||||||
|
private WarVultureHud(WarVultureMount mount, GameObject barObject, Component guiBar, MethodInfo setValue)
|
||||||
|
{
|
||||||
|
this.mount = mount;
|
||||||
|
this.barObject = barObject;
|
||||||
|
this.guiBar = guiBar;
|
||||||
|
this.setValue = setValue;
|
||||||
|
}
|
||||||
|
|
||||||
|
public static WarVultureHud Create(WarVultureMount mount)
|
||||||
|
{
|
||||||
|
Hud hud = Hud.instance;
|
||||||
|
if (hud == null) return null;
|
||||||
|
|
||||||
|
Component template = Traverse.Create(hud).Field("m_mountStaminaBar").GetValue<Component>();
|
||||||
|
RectTransform staminaRoot = hud.m_staminaBar2Root;
|
||||||
|
if (template == null || staminaRoot == null || staminaRoot.parent == null)
|
||||||
|
{
|
||||||
|
Jotunn.Logger.LogWarning("[WarVulture] The vanilla mount stamina bar or the stamina bar root " +
|
||||||
|
"could not be found, so the bird flies without a gauge.");
|
||||||
|
return null;
|
||||||
|
}
|
||||||
|
|
||||||
|
GameObject clone = Object.Instantiate(template.gameObject, staminaRoot.parent);
|
||||||
|
clone.name = "WarVultureWindBar";
|
||||||
|
|
||||||
|
// Anchored off the stamina bar rather than off the screen: the stamina bar moves with
|
||||||
|
// the player's HUD layout, and anything positioned against the screen would drift away
|
||||||
|
// from it the moment that layout changes.
|
||||||
|
RectTransform rect = clone.GetComponent<RectTransform>();
|
||||||
|
if (rect != null)
|
||||||
|
{
|
||||||
|
rect.anchorMin = staminaRoot.anchorMin;
|
||||||
|
rect.anchorMax = staminaRoot.anchorMax;
|
||||||
|
rect.pivot = staminaRoot.pivot;
|
||||||
|
rect.anchoredPosition = staminaRoot.anchoredPosition + new Vector2(0f, -BelowStaminaPixels);
|
||||||
|
rect.localScale = staminaRoot.localScale;
|
||||||
|
}
|
||||||
|
|
||||||
|
clone.SetActive(true);
|
||||||
|
|
||||||
|
Component bar = clone.GetComponent("GuiBar");
|
||||||
|
MethodInfo setter = bar != null
|
||||||
|
? bar.GetType().GetMethod("SetValue", new[] { typeof(float) })
|
||||||
|
: null;
|
||||||
|
|
||||||
|
if (setter == null)
|
||||||
|
{
|
||||||
|
Jotunn.Logger.LogWarning("[WarVulture] The cloned bar has no GuiBar.SetValue(float) to drive, " +
|
||||||
|
"so it would have sat there full forever; it was removed.");
|
||||||
|
Object.Destroy(clone);
|
||||||
|
return null;
|
||||||
|
}
|
||||||
|
|
||||||
|
TintBrown(bar);
|
||||||
|
|
||||||
|
return new WarVultureHud(mount, clone, bar, setter);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Optional, and treated as such: if GuiBar ever loses SetColor the bar simply keeps
|
||||||
|
/// vanilla's colour instead of costing an exception every summon.
|
||||||
|
/// </summary>
|
||||||
|
private static void TintBrown(Component bar)
|
||||||
|
{
|
||||||
|
MethodInfo setColor = bar.GetType().GetMethod("SetColor", new[] { typeof(Color) });
|
||||||
|
if (setColor == null) return;
|
||||||
|
|
||||||
|
setColor.Invoke(bar, new object[] { new Color(0.72f, 0.55f, 0.32f, 1f) });
|
||||||
|
}
|
||||||
|
|
||||||
|
public void Refresh()
|
||||||
|
{
|
||||||
|
if (barObject == null || guiBar == null || setValue == null) return;
|
||||||
|
if (mount == null) return;
|
||||||
|
|
||||||
|
setValue.Invoke(guiBar, new object[] { mount.WindFraction });
|
||||||
|
}
|
||||||
|
|
||||||
|
public void Dispose()
|
||||||
|
{
|
||||||
|
if (barObject != null) Object.Destroy(barObject);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
308
JotunnModStub/WarVulture/WarVultureItem.cs
Normal file
308
JotunnModStub/WarVulture/WarVultureItem.cs
Normal file
|
|
@ -0,0 +1,308 @@
|
||||||
|
using HarmonyLib;
|
||||||
|
using Jotunn.Entities;
|
||||||
|
using Jotunn.Managers;
|
||||||
|
using UnityEngine;
|
||||||
|
|
||||||
|
namespace RacesOfValheim
|
||||||
|
{
|
||||||
|
/// <summary>
|
||||||
|
/// The War Vulture item: a Dead Raiser with the skeleton taken out of it and a vulture trophy
|
||||||
|
/// hung in its place. Clicked, it puts the player on a flying bird; clicked again, it brings
|
||||||
|
/// them down and takes the bird away.
|
||||||
|
///
|
||||||
|
/// Why a staff and not a trinket: the game lets a WEAPON be used without any trickery. Cloning
|
||||||
|
/// StaffSkeleton buys the click, the cast gesture and the effects for free - which is exactly
|
||||||
|
/// the reasoning that produced SkadiNokkel, and this file is deliberately that file's twin. If
|
||||||
|
/// one of them ever needs a fix, the other almost certainly needs the same one.
|
||||||
|
///
|
||||||
|
/// Three things are removed from the vanilla staff, and each is removed TWICE on purpose:
|
||||||
|
/// - the eitr, health and stamina costs are zeroed on the clone AND forced to zero in the
|
||||||
|
/// getters every cost check flows through (WarVultureFreeCastPatch). The eitr cost is not
|
||||||
|
/// cosmetic: it is checked BEFORE the attack starts, so a player without eitr would never
|
||||||
|
/// reach the code that summons;
|
||||||
|
/// - the summon is nulled on the clone AND the attack trigger itself is taken over, so
|
||||||
|
/// vanilla's spawn code is not merely defused but unreachable (WarVultureCastPatch);
|
||||||
|
/// - the staff's model is replaced by the trophy under the item's "attach" child, which is
|
||||||
|
/// the ONLY child VisEquipment draws - a model hung anywhere else is present, correct and
|
||||||
|
/// invisible (design doc 15.11, half an hour paid for once already).
|
||||||
|
/// </summary>
|
||||||
|
public static class WarVultureItem
|
||||||
|
{
|
||||||
|
public const string PrefabName = "WarVulture";
|
||||||
|
public const string DisplayName = "War Vulture";
|
||||||
|
|
||||||
|
private const string SourcePrefab = "StaffSkeleton";
|
||||||
|
private const string TrophyPrefab = "TrophyVolture";
|
||||||
|
private const string Label = "WarVulture";
|
||||||
|
|
||||||
|
public static void Register()
|
||||||
|
{
|
||||||
|
GameObject prefab = PrefabManager.Instance.CreateClonedPrefab(PrefabName, SourcePrefab);
|
||||||
|
if (prefab == null)
|
||||||
|
{
|
||||||
|
Jotunn.Logger.LogWarning($"[{Label}] Could not clone {SourcePrefab}; {DisplayName} not registered.");
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
ItemDrop drop = prefab.GetComponent<ItemDrop>();
|
||||||
|
if (drop == null || drop.m_itemData == null || drop.m_itemData.m_shared == null)
|
||||||
|
{
|
||||||
|
Jotunn.Logger.LogWarning($"[{Label}] {SourcePrefab} clone has no usable ItemDrop; {DisplayName} not registered.");
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
ItemDrop.ItemData.SharedData shared = drop.m_itemData.m_shared;
|
||||||
|
shared.m_name = DisplayName;
|
||||||
|
shared.m_description = "A vulture's head, kept. Raise it and the bird comes back under you, " +
|
||||||
|
"and it will carry you as long as you care to stay up - though it only " +
|
||||||
|
"has so much haste in it before it settles into a glide.";
|
||||||
|
shared.m_useDurability = false;
|
||||||
|
|
||||||
|
// ItemType is left exactly as the vanilla staff has it: it decides the equip slot and
|
||||||
|
// which animation set the arms use, and the cast gesture is the whole reason this is a
|
||||||
|
// staff rather than a trinket.
|
||||||
|
|
||||||
|
Strip(shared);
|
||||||
|
SwapHandModel(prefab);
|
||||||
|
|
||||||
|
ItemManager.Instance.AddItem(new CustomItem(prefab, fixReference: false));
|
||||||
|
|
||||||
|
// Built HERE and not at the summon, and the comment on WarVultureVisual explains why in
|
||||||
|
// full: this is a context where components may be destroyed immediately, and the summon
|
||||||
|
// is not. Getting that wrong once put a live Ashlands predator in the player's world.
|
||||||
|
WarVultureVisual.BuildTemplate();
|
||||||
|
|
||||||
|
// No recipe, on purpose and for now: the item is spawned from the console
|
||||||
|
// ("spawn WarVulture") while the flight is being proven. A recipe costs nothing to add
|
||||||
|
// later and would only be materials invented before anyone knows what this is worth.
|
||||||
|
Jotunn.Logger.LogInfo($"[{Label}] {DisplayName} registered: no eitr, no health, no stamina, no skeleton.");
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Takes the skeleton staff apart. Every field is zeroed on BOTH attacks, because the
|
||||||
|
/// secondary is a separate Attack carrying its own copy of every cost.
|
||||||
|
///
|
||||||
|
/// The summon hangs off a SpawnAbility on a prefab referenced by the attack, and WHICH
|
||||||
|
/// field carries it is not knowable from the game files - so all three candidates go.
|
||||||
|
/// Nulling three fields that might each be the culprit costs nothing; guessing wrong costs
|
||||||
|
/// a skeleton on every click.
|
||||||
|
///
|
||||||
|
/// The animation is the one thing deliberately left alone. It is the whole point: the
|
||||||
|
/// player raises the trophy, and the bird answers.
|
||||||
|
/// </summary>
|
||||||
|
private static void Strip(ItemDrop.ItemData.SharedData shared)
|
||||||
|
{
|
||||||
|
StripAttack(shared.m_attack);
|
||||||
|
StripAttack(shared.m_secondaryAttack);
|
||||||
|
}
|
||||||
|
|
||||||
|
private static void StripAttack(Attack attack)
|
||||||
|
{
|
||||||
|
if (attack == null) return;
|
||||||
|
|
||||||
|
attack.m_attackEitr = 0f;
|
||||||
|
attack.m_drawEitrDrain = 0f;
|
||||||
|
attack.m_reloadEitrDrain = 0f;
|
||||||
|
|
||||||
|
attack.m_attackHealth = 0f;
|
||||||
|
attack.m_attackHealthPercentage = 0f;
|
||||||
|
attack.m_attackHealthLowBlockUse = false;
|
||||||
|
attack.m_attackHealthReturnHit = 0f;
|
||||||
|
|
||||||
|
attack.m_attackStamina = 0f;
|
||||||
|
attack.m_drawStaminaDrain = 0f;
|
||||||
|
attack.m_reloadStaminaDrain = 0f;
|
||||||
|
|
||||||
|
attack.m_attackProjectile = null;
|
||||||
|
attack.m_spawnOnTrigger = null;
|
||||||
|
attack.m_spawnOnHit = null;
|
||||||
|
attack.m_spawnOnHitChance = 0f;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Puts the vulture trophy in the hand where the staff's model was.
|
||||||
|
///
|
||||||
|
/// "attach" is not a name picked for tidiness: VisEquipment instantiates that child and
|
||||||
|
/// nothing else, so this is the only place a held model can live.
|
||||||
|
///
|
||||||
|
/// The size is a MULTIPLIER rather than a measurement in metres, which is the opposite of
|
||||||
|
/// what ModelBorrow does and is right here for one reason: the brief was "the trophy, 40%
|
||||||
|
/// smaller". The trophy's own size is the measurement; 0.6 is the relation applied to it.
|
||||||
|
/// </summary>
|
||||||
|
private static void SwapHandModel(GameObject prefab)
|
||||||
|
{
|
||||||
|
Transform attach = FindChild(prefab.transform, "attach");
|
||||||
|
if (attach == null)
|
||||||
|
{
|
||||||
|
Jotunn.Logger.LogWarning($"[{Label}] The {SourcePrefab} clone has no 'attach' child, so the " +
|
||||||
|
"held model was left as the vanilla staff. VisEquipment draws " +
|
||||||
|
"nothing else, so there was nowhere else to put it.");
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
GameObject trophy = PrefabManager.Cache.GetPrefab<GameObject>(TrophyPrefab);
|
||||||
|
if (trophy == null)
|
||||||
|
{
|
||||||
|
Jotunn.Logger.LogWarning($"[{Label}] No '{TrophyPrefab}' to borrow; the item keeps the " +
|
||||||
|
"skeleton staff's look.");
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
// The old staff mesh goes first, or the hand holds both.
|
||||||
|
for (int i = attach.childCount - 1; i >= 0; i--)
|
||||||
|
{
|
||||||
|
Object.DestroyImmediate(attach.GetChild(i).gameObject);
|
||||||
|
}
|
||||||
|
foreach (Renderer renderer in attach.GetComponents<Renderer>())
|
||||||
|
{
|
||||||
|
if (renderer != null) Object.DestroyImmediate(renderer);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Instantiate into a holder that is ALREADY INACTIVE - the one line ModelBorrow exists
|
||||||
|
// for. A trophy is an ItemDrop, and Instantiate runs Awake first: waking one for a
|
||||||
|
// single frame drops a real trophy on the floor.
|
||||||
|
GameObject holder = new GameObject("WarVultureTrophy");
|
||||||
|
holder.transform.SetParent(attach, false);
|
||||||
|
holder.SetActive(false);
|
||||||
|
|
||||||
|
GameObject copy = Object.Instantiate(trophy, holder.transform);
|
||||||
|
copy.name = "model";
|
||||||
|
copy.transform.localPosition = Vector3.zero;
|
||||||
|
copy.transform.localRotation = Quaternion.identity;
|
||||||
|
copy.transform.localScale = Vector3.one * WarVultureConfig.HandModelScale.Value;
|
||||||
|
|
||||||
|
StripToMeshesOnly(copy);
|
||||||
|
|
||||||
|
holder.SetActive(true);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// The trophy reduced to nothing but its shape.
|
||||||
|
///
|
||||||
|
/// This used to be a BLACKLIST - scripts, colliders, rigidbodies, ZNetView - and it let
|
||||||
|
/// through exactly what a blacklist always lets through: the things nobody thought to name.
|
||||||
|
/// A vanilla item prefab carries the sparkle that makes dropped loot findable in long grass,
|
||||||
|
/// and that lives in ParticleSystems, ParticleSystemRenderers and Lights. None of those is a
|
||||||
|
/// MonoBehaviour, so all of them survived, and the item glittered in the player's hand like
|
||||||
|
/// something they had just thrown away.
|
||||||
|
///
|
||||||
|
/// So it is a whitelist now, the same shape as WarVultureVisual's: MeshFilter,
|
||||||
|
/// MeshRenderer, SkinnedMeshRenderer, Transform. Note it is deliberately NARROWER than the
|
||||||
|
/// mount's whitelist - "Renderer" would be wrong here, because ParticleSystemRenderer IS a
|
||||||
|
/// Renderer and it is half of what we are trying to be rid of.
|
||||||
|
///
|
||||||
|
/// Passes, because Unity refuses to destroy a component another one still requires, and the
|
||||||
|
/// refusal only unblocks once the dependent is gone.
|
||||||
|
/// </summary>
|
||||||
|
private static void StripToMeshesOnly(GameObject copy)
|
||||||
|
{
|
||||||
|
for (int pass = 0; pass < 6; pass++)
|
||||||
|
{
|
||||||
|
bool destroyedSomething = false;
|
||||||
|
|
||||||
|
foreach (Component component in copy.GetComponentsInChildren<Component>(true))
|
||||||
|
{
|
||||||
|
if (component == null) continue;
|
||||||
|
if (component is Transform) continue;
|
||||||
|
if (component is MeshFilter) continue;
|
||||||
|
if (component is MeshRenderer) continue;
|
||||||
|
if (component is SkinnedMeshRenderer) continue;
|
||||||
|
|
||||||
|
Object.DestroyImmediate(component);
|
||||||
|
|
||||||
|
if (component == null) destroyedSomething = true;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!destroyedSomething) break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private static Transform FindChild(Transform root, string name)
|
||||||
|
{
|
||||||
|
if (root.name == name) return root;
|
||||||
|
for (int i = 0; i < root.childCount; i++)
|
||||||
|
{
|
||||||
|
Transform found = FindChild(root.GetChild(i), name);
|
||||||
|
if (found != null) return found;
|
||||||
|
}
|
||||||
|
return null;
|
||||||
|
}
|
||||||
|
|
||||||
|
public static bool IsWarVulture(ItemDrop.ItemData item)
|
||||||
|
{
|
||||||
|
return item != null && item.m_dropPrefab != null && item.m_dropPrefab.name == PrefabName;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// True when a cost being asked about belongs to this item.
|
||||||
|
///
|
||||||
|
/// The fallback on the equipped weapon is necessary rather than belt-and-braces: the cost
|
||||||
|
/// getters are called from Attack.Start and m_weapon is not guaranteed to be assigned yet.
|
||||||
|
/// It is only consulted when m_weapon is null, so a creature's own attack cannot be zeroed
|
||||||
|
/// just because the player happens to be holding the trophy at the time.
|
||||||
|
/// </summary>
|
||||||
|
public static bool IsWarVultureContext(ItemDrop.ItemData weapon)
|
||||||
|
{
|
||||||
|
if (weapon != null) return IsWarVulture(weapon);
|
||||||
|
|
||||||
|
Player local = Player.m_localPlayer;
|
||||||
|
return local != null && IsWarVulture(local.GetCurrentWeapon());
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// The click. Attack.OnAttackTrigger is used rather than Attack.Start because it takes NO
|
||||||
|
/// parameters - its signature cannot drift - and it fires when the animation reaches its
|
||||||
|
/// release point, which is when a summon should land.
|
||||||
|
///
|
||||||
|
/// A Prefix returning FALSE, so for this item vanilla's attack-trigger code never runs at all.
|
||||||
|
/// m_weapon and m_character are private on Attack and arrive through Harmony's triple
|
||||||
|
/// underscore injection, which is checked at patch time: a rename becomes a startup error
|
||||||
|
/// instead of a silent null on every click.
|
||||||
|
/// </summary>
|
||||||
|
[HarmonyPatch(typeof(Attack), "OnAttackTrigger")]
|
||||||
|
public static class WarVultureCastPatch
|
||||||
|
{
|
||||||
|
public static bool Prefix(ItemDrop.ItemData ___m_weapon, Humanoid ___m_character)
|
||||||
|
{
|
||||||
|
if (!WarVultureItem.IsWarVulture(___m_weapon)) return true;
|
||||||
|
|
||||||
|
// Still returns false while riding, so vanilla's trigger never runs - but the dismount
|
||||||
|
// is NOT taken from here. In the saddle this event is unreliable: the cast clip loses
|
||||||
|
// to the sitting pose before its event fires. WarVultureMount reads the button itself.
|
||||||
|
WarVultureMount.Toggle(___m_character as Player);
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// The item costs nothing, guaranteed.
|
||||||
|
///
|
||||||
|
/// Zeroing the fields on the clone ought to be enough by every reading of the game's own code.
|
||||||
|
/// On the Skadi staff the cost came back in game anyway, which means the write to a clone's
|
||||||
|
/// SharedData does not survive something - so relying on it alone is relying on a mechanism
|
||||||
|
/// already observed to fail. These three getters are the single funnel every cost check flows
|
||||||
|
/// through: Attack.Start asks them before it will start, and the tooltip asks them for what to
|
||||||
|
/// print. All three are private and take no parameters, so they are addressed by name.
|
||||||
|
/// </summary>
|
||||||
|
[HarmonyPatch]
|
||||||
|
public static class WarVultureFreeCastPatch
|
||||||
|
{
|
||||||
|
[HarmonyTargetMethods]
|
||||||
|
private static System.Collections.Generic.IEnumerable<System.Reflection.MethodBase> TargetMethods()
|
||||||
|
{
|
||||||
|
yield return AccessTools.Method(typeof(Attack), "GetAttackEitr");
|
||||||
|
yield return AccessTools.Method(typeof(Attack), "GetAttackHealth");
|
||||||
|
yield return AccessTools.Method(typeof(Attack), "GetAttackStamina");
|
||||||
|
}
|
||||||
|
|
||||||
|
[HarmonyPostfix]
|
||||||
|
private static void Postfix(ItemDrop.ItemData ___m_weapon, ref float __result)
|
||||||
|
{
|
||||||
|
if (__result == 0f) return;
|
||||||
|
if (!WarVultureItem.IsWarVultureContext(___m_weapon)) return;
|
||||||
|
|
||||||
|
__result = 0f;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
389
JotunnModStub/WarVulture/WarVultureMount.cs
Normal file
389
JotunnModStub/WarVulture/WarVultureMount.cs
Normal file
|
|
@ -0,0 +1,389 @@
|
||||||
|
using HarmonyLib;
|
||||||
|
using Jotunn.Managers;
|
||||||
|
using UnityEngine;
|
||||||
|
|
||||||
|
namespace RacesOfValheim
|
||||||
|
{
|
||||||
|
/// <summary>
|
||||||
|
/// The ride itself. Lives on the local player while they are mounted, and nowhere else.
|
||||||
|
///
|
||||||
|
/// THE ONE IDEA THIS FILE IS BUILT ON: the PLAYER flies, the bird is how it looks from outside.
|
||||||
|
/// That inversion is what makes a flying mount a small feature instead of a large one - it
|
||||||
|
/// removes the ZDO owner problem, the AI, the taming, the passivity and the whole saddle, all
|
||||||
|
/// of which cost a session each the first time round. The flight itself is the Aswid's bat
|
||||||
|
/// form: Player.m_debugFly, and nothing else.
|
||||||
|
///
|
||||||
|
/// THE ONE TRAP: a real attach and a self-driven player are enemies in vanilla, and the game
|
||||||
|
/// says so twice.
|
||||||
|
/// - Player.SetControls: if the player is attached, has no doodad controller and presses ANY
|
||||||
|
/// movement key, vanilla calls AttachStop. That is how you stand up from a chair.
|
||||||
|
/// - Player.SetDoodadControlls: giving it a doodad controller instead is worse - it zeroes
|
||||||
|
/// moveDir, run and autoRun unconditionally after handing them to the controller, so the
|
||||||
|
/// rider could not move at all.
|
||||||
|
/// Both were read out of the assembly, not guessed. The way through is the third door: the
|
||||||
|
/// attach point is the PLAYER'S OWN TRANSFORM, so Player.UpdateAttach - which copies position
|
||||||
|
/// and rotation from the attach point every frame, and would otherwise nail the rider in place
|
||||||
|
/// - provably copies the player onto themselves and does nothing. The bird hangs off the
|
||||||
|
/// player, not the other way round. The one remaining conflict, the AttachStop above, is
|
||||||
|
/// switched off for the duration in WarVultureControlsPatch.
|
||||||
|
///
|
||||||
|
/// What the attach is still there FOR, after all that, is the pose: AttachStart ends with
|
||||||
|
/// m_zanim.SetBool(attachAnimation, true), and ZSyncAnimation replicates it - so every other
|
||||||
|
/// player sees the rider sitting, for free, with no code of ours involved.
|
||||||
|
/// </summary>
|
||||||
|
public class WarVultureMount : MonoBehaviour
|
||||||
|
{
|
||||||
|
/// <summary>The ZDO flag other clients watch to know they should draw a bird under this player.</summary>
|
||||||
|
public const string MountedKey = "WarVulture_Mounted";
|
||||||
|
|
||||||
|
private const string Label = "WarVulture";
|
||||||
|
private const string HolderName = "WarVultureMountModel";
|
||||||
|
|
||||||
|
/// <summary>How long after the summon a click is ignored, so one press cannot do both.</summary>
|
||||||
|
private const float ClickGuardSeconds = 0.6f;
|
||||||
|
|
||||||
|
/// <summary>The one live mount. There is at most one: this is the local player's own ride.</summary>
|
||||||
|
public static WarVultureMount Active { get; private set; }
|
||||||
|
|
||||||
|
private Player player;
|
||||||
|
private WarVultureRig rig;
|
||||||
|
private Transform seat;
|
||||||
|
private WarVultureHud hud;
|
||||||
|
|
||||||
|
private float wind; // seconds of full speed left in the bird
|
||||||
|
private bool landing; // dismount asked for; coming down before it takes effect
|
||||||
|
private float landingStartedAt;
|
||||||
|
private float summonedAt;
|
||||||
|
|
||||||
|
// ---------------------------------------------------------------- public surface
|
||||||
|
|
||||||
|
public static bool IsRiding(Player candidate)
|
||||||
|
{
|
||||||
|
return Active != null && candidate != null && Active.player == candidate;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>Fraction of the bird's wind left, for the bar. 1 = fresh, 0 = spent.</summary>
|
||||||
|
public float WindFraction
|
||||||
|
{
|
||||||
|
get
|
||||||
|
{
|
||||||
|
float max = Mathf.Max(0.01f, WarVultureConfig.SprintSeconds.Value);
|
||||||
|
return Mathf.Clamp01(wind / max);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// The SUMMON, and only the summon. Called from WarVultureCastPatch, which has already
|
||||||
|
/// established that the thing being swung is ours and that the player is not already up.
|
||||||
|
///
|
||||||
|
/// The dismount used to come through here too, and it did not work: the click fires
|
||||||
|
/// Attack.OnAttackTrigger, which the game raises from an animation event partway through
|
||||||
|
/// the cast clip - and in the saddle that clip loses to the sitting pose before it ever
|
||||||
|
/// gets there. The rider was trapped in the air with a click that did nothing. The dismount
|
||||||
|
/// is now read straight off the button in Update, where no animation can swallow it.
|
||||||
|
/// </summary>
|
||||||
|
public static void Toggle(Player caster)
|
||||||
|
{
|
||||||
|
if (caster == null || caster != Player.m_localPlayer) return;
|
||||||
|
if (Active != null && Active.player == caster) return;
|
||||||
|
|
||||||
|
Summon(caster);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// The dismount button, read from the device rather than from the animation.
|
||||||
|
///
|
||||||
|
/// RaceInput.Allowed is the same gate every ability in this mod uses, and it is here for a
|
||||||
|
/// reason worth remembering: it reads Player.TakeInput, which is FALSE while the console is
|
||||||
|
/// open. A dismount that "does not work" during a test session is usually the console.
|
||||||
|
/// </summary>
|
||||||
|
private static bool DismountPressed()
|
||||||
|
{
|
||||||
|
if (!RaceInput.Allowed) return false;
|
||||||
|
return ZInput.GetButtonDown("Attack") || ZInput.GetButtonDown("JoyAttack");
|
||||||
|
}
|
||||||
|
|
||||||
|
// ---------------------------------------------------------------- summon
|
||||||
|
|
||||||
|
private static void Summon(Player rider)
|
||||||
|
{
|
||||||
|
string race = null;
|
||||||
|
if (rider.m_customData != null) rider.m_customData.TryGetValue("Race", out race);
|
||||||
|
|
||||||
|
if (!WarVultureConfig.RaceAllowed(race))
|
||||||
|
{
|
||||||
|
rider.Message(MessageHud.MessageType.Center, "The bird does not know you.");
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!WarVultureVisual.Ready)
|
||||||
|
{
|
||||||
|
rider.Message(MessageHud.MessageType.Center, "The vulture does not answer.");
|
||||||
|
Jotunn.Logger.LogWarning($"[{Label}] Call refused: the stripped model template was never built, " +
|
||||||
|
"so there is no bird to show. The reason is logged at startup - and " +
|
||||||
|
"refusing is deliberate, because the alternative is putting an unstripped " +
|
||||||
|
"creature prefab in the world.");
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
ZNetView nview = rider.GetComponent<ZNetView>();
|
||||||
|
if (nview == null || !nview.IsValid())
|
||||||
|
{
|
||||||
|
Jotunn.Logger.LogWarning($"[{Label}] Call refused: the player has no valid ZNetView yet, so " +
|
||||||
|
"the flight state could not be published and no one else would see " +
|
||||||
|
"the bird.");
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
WarVultureMount mount = rider.gameObject.AddComponent<WarVultureMount>();
|
||||||
|
mount.player = rider;
|
||||||
|
mount.Begin(nview);
|
||||||
|
}
|
||||||
|
|
||||||
|
private void Begin(ZNetView nview)
|
||||||
|
{
|
||||||
|
Active = this;
|
||||||
|
summonedAt = Time.time;
|
||||||
|
wind = WarVultureConfig.SprintSeconds.Value;
|
||||||
|
|
||||||
|
// No lift, and that is the point: the rider is not raised above anything. The bird is
|
||||||
|
// moved so that its BACK BONE arrives under the rider, every frame, in WarVultureRig.
|
||||||
|
rig = WarVultureVisual.Spawn(player.transform, HolderName);
|
||||||
|
Seat();
|
||||||
|
SetFlying(nview, true);
|
||||||
|
nview.GetZDO().Set(MountedKey, true);
|
||||||
|
|
||||||
|
if (WarVultureConfig.ShowStaminaBar.Value) hud = WarVultureHud.Create(this);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// The attach, and the reason it is harmless: the seat is a child of the player sitting
|
||||||
|
/// exactly on the player's own origin, so UpdateAttach's every-frame "put the rider on the
|
||||||
|
/// attach point" is the identity.
|
||||||
|
///
|
||||||
|
/// The pose string is READ from the lox's own Sadle rather than typed from memory - the
|
||||||
|
/// same rule as prefab names, applied to an animation.
|
||||||
|
///
|
||||||
|
/// hideWeapons is false on purpose: hiding the hand items unequips them, and the item in
|
||||||
|
/// that hand is the only way back down.
|
||||||
|
/// </summary>
|
||||||
|
private void Seat()
|
||||||
|
{
|
||||||
|
seat = new GameObject("WarVultureSeat").transform;
|
||||||
|
seat.SetParent(player.transform, false);
|
||||||
|
seat.localPosition = Vector3.zero;
|
||||||
|
seat.localRotation = Quaternion.identity;
|
||||||
|
|
||||||
|
player.AttachStart(seat, null, false, false, false, ReadSaddlePose(), Vector3.zero, null);
|
||||||
|
}
|
||||||
|
|
||||||
|
private static string ReadSaddlePose()
|
||||||
|
{
|
||||||
|
GameObject lox = PrefabManager.Cache.GetPrefab<GameObject>("Lox");
|
||||||
|
Sadle sadle = lox != null ? lox.GetComponentInChildren<Sadle>(true) : null;
|
||||||
|
if (sadle != null && !string.IsNullOrEmpty(sadle.m_attachAnimation)) return sadle.m_attachAnimation;
|
||||||
|
|
||||||
|
Jotunn.Logger.LogWarning($"[{Label}] Could not read the lox saddle's attach animation; " +
|
||||||
|
"falling back to 'attach_chair'. The rider may sit oddly.");
|
||||||
|
return "attach_chair";
|
||||||
|
}
|
||||||
|
|
||||||
|
// ---------------------------------------------------------------- per frame
|
||||||
|
|
||||||
|
private void Update()
|
||||||
|
{
|
||||||
|
if (player == null || player != Player.m_localPlayer) { Dismount(); return; }
|
||||||
|
if (player.IsDead()) { Dismount(); return; }
|
||||||
|
|
||||||
|
ZNetView nview = player.GetComponent<ZNetView>();
|
||||||
|
if (nview == null || !nview.IsValid())
|
||||||
|
{
|
||||||
|
// Not an ordinary way down: the rider's own networking went away mid-flight, so it
|
||||||
|
// is worth a line even though the dismount itself is silent.
|
||||||
|
Jotunn.Logger.LogWarning($"[{Label}] The rider's ZNetView went away mid-flight; dismounting.");
|
||||||
|
Dismount();
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Held on every frame rather than set once: the same thing BatFormBehavior does, for
|
||||||
|
// the same reason - anything else in the game (or in this mod) that clears debug fly
|
||||||
|
// would otherwise drop the rider out of the sky without a word.
|
||||||
|
SetFlying(nview, true);
|
||||||
|
|
||||||
|
DriveAnimator();
|
||||||
|
|
||||||
|
// The guard is not superstition: the summoning click is still physically down on the
|
||||||
|
// frame the mount is created, and without it the bird would be called and dismissed by
|
||||||
|
// the same press.
|
||||||
|
if (Time.time - summonedAt > ClickGuardSeconds && DismountPressed())
|
||||||
|
{
|
||||||
|
// A second click during the descent lets go there and then.
|
||||||
|
if (landing) Dismount();
|
||||||
|
else BeginLanding();
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (landing) UpdateLanding();
|
||||||
|
|
||||||
|
if (hud != null) hud.Refresh();
|
||||||
|
}
|
||||||
|
|
||||||
|
private void DriveAnimator()
|
||||||
|
{
|
||||||
|
if (rig == null) return;
|
||||||
|
|
||||||
|
Vector3 velocity = player.GetVelocity();
|
||||||
|
rig.Drive(new Vector3(velocity.x, 0f, velocity.z).magnitude);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// The descent. The rider's own controls are not disabled - they are simply overruled in
|
||||||
|
/// ApplyFlight, which writes the velocity last and therefore wins.
|
||||||
|
/// </summary>
|
||||||
|
private void BeginLanding()
|
||||||
|
{
|
||||||
|
landing = true;
|
||||||
|
landingStartedAt = Time.time;
|
||||||
|
player.Message(MessageHud.MessageType.Center, "The vulture spirals down.");
|
||||||
|
}
|
||||||
|
|
||||||
|
private void UpdateLanding()
|
||||||
|
{
|
||||||
|
Vector3 position = player.transform.position;
|
||||||
|
|
||||||
|
float floor = -10000f;
|
||||||
|
if (ZoneSystem.instance != null)
|
||||||
|
{
|
||||||
|
// Over open water the solid height is the seabed, which would mean a long swim
|
||||||
|
// down. The surface is the floor there.
|
||||||
|
floor = Mathf.Max(ZoneSystem.instance.GetSolidHeight(position), ZoneSystem.instance.m_waterLevel);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (position.y - floor <= 0.6f) { Dismount(); return; }
|
||||||
|
|
||||||
|
// A descent that never ends is worse than a hard landing: if the ground cannot be
|
||||||
|
// found at all, let go anyway rather than trap the rider in a falling animation.
|
||||||
|
if (Time.time - landingStartedAt > 20f)
|
||||||
|
{
|
||||||
|
Jotunn.Logger.LogWarning($"[{Label}] The descent found no ground in 20s; letting go anyway.");
|
||||||
|
Dismount();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// ---------------------------------------------------------------- flight, called from the physics step
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Called from WarVultureFlightPatch, right after vanilla's UpdateDebugFly has written the
|
||||||
|
/// rider's velocity for this physics step.
|
||||||
|
///
|
||||||
|
/// Speed is applied as a FACTOR on what vanilla just computed rather than as a fresh
|
||||||
|
/// velocity, and that is deliberate: vanilla lerps towards its target, so scaling the
|
||||||
|
/// result keeps every bit of its smoothing - the ramp up, the ease off, the standstill at
|
||||||
|
/// zero input - and only changes how fast the whole thing runs. Writing a velocity of our
|
||||||
|
/// own would have thrown all of that away.
|
||||||
|
///
|
||||||
|
/// The wind is spent here, in the physics step, because this is the only place that knows
|
||||||
|
/// the rider is actually flying.
|
||||||
|
/// </summary>
|
||||||
|
public void ApplyFlight(bool runHeld, ref Vector3 currentVelocity, Rigidbody body)
|
||||||
|
{
|
||||||
|
float dt = Time.fixedDeltaTime;
|
||||||
|
|
||||||
|
if (landing)
|
||||||
|
{
|
||||||
|
currentVelocity = Vector3.down * WarVultureConfig.LandingSpeed.Value;
|
||||||
|
if (body != null) body.linearVelocity = currentVelocity;
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
bool sprinting = runHeld && wind > 0f && currentVelocity.sqrMagnitude > 0.01f;
|
||||||
|
|
||||||
|
if (sprinting)
|
||||||
|
{
|
||||||
|
wind = Mathf.Max(0f, wind - dt);
|
||||||
|
if (wind <= 0f)
|
||||||
|
{
|
||||||
|
player.Message(MessageHud.MessageType.Center, "The vulture settles into a glide.");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else if (wind < WarVultureConfig.SprintSeconds.Value)
|
||||||
|
{
|
||||||
|
// Refills in the air the moment the run key is released. A vulture can stay up for
|
||||||
|
// hours; what it cannot do is keep stooping.
|
||||||
|
float perSecond = WarVultureConfig.SprintSeconds.Value /
|
||||||
|
Mathf.Max(0.01f, WarVultureConfig.RechargeSeconds.Value);
|
||||||
|
wind = Mathf.Min(WarVultureConfig.SprintSeconds.Value, wind + perSecond * dt);
|
||||||
|
}
|
||||||
|
|
||||||
|
float wanted = sprinting ? WarVultureConfig.SprintSpeed.Value : WarVultureConfig.CruiseSpeed.Value;
|
||||||
|
|
||||||
|
// What vanilla aimed for this step: m_debugFlySpeed, times 2.5 when the run key is
|
||||||
|
// down. Read from the game rather than assumed, so a Valheim retune cannot silently
|
||||||
|
// double our speeds.
|
||||||
|
float vanilla = WarVultureFlightPatch.DebugFlySpeed * (runHeld ? 2.5f : 1f);
|
||||||
|
if (vanilla <= 0.01f) return;
|
||||||
|
|
||||||
|
currentVelocity *= wanted / vanilla;
|
||||||
|
if (body != null) body.linearVelocity = currentVelocity;
|
||||||
|
}
|
||||||
|
|
||||||
|
// ---------------------------------------------------------------- dismount
|
||||||
|
|
||||||
|
private void Dismount()
|
||||||
|
{
|
||||||
|
Player rider = player;
|
||||||
|
|
||||||
|
if (rider != null)
|
||||||
|
{
|
||||||
|
ZNetView nview = rider.GetComponent<ZNetView>();
|
||||||
|
if (nview != null && nview.IsValid())
|
||||||
|
{
|
||||||
|
SetFlying(nview, false);
|
||||||
|
nview.GetZDO().Set(MountedKey, false);
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
// No ZDO to write to, but the local field still has to come off or the player
|
||||||
|
// keeps flying on foot.
|
||||||
|
Traverse.Create(rider).Field("m_debugFly").SetValue(false);
|
||||||
|
}
|
||||||
|
|
||||||
|
rider.AttachStop();
|
||||||
|
}
|
||||||
|
|
||||||
|
if (hud != null) { hud.Dispose(); hud = null; }
|
||||||
|
// Destroy, never DestroyImmediate: a dismount can be a click, which arrives from an
|
||||||
|
// animation event callback where immediate destruction is refused. The whole reason
|
||||||
|
// this feature had a live vulture in it once.
|
||||||
|
if (rig != null) { Destroy(rig.gameObject); rig = null; }
|
||||||
|
if (seat != null) { Destroy(seat.gameObject); seat = null; }
|
||||||
|
|
||||||
|
if (Active == this) Active = null;
|
||||||
|
|
||||||
|
Destroy(this);
|
||||||
|
}
|
||||||
|
|
||||||
|
private void OnDestroy()
|
||||||
|
{
|
||||||
|
// Belt and braces for a component torn off by something other than Dismount (a scene
|
||||||
|
// change, a reload). Leaving debug fly on would be the worst possible parting gift.
|
||||||
|
if (Active != this) return;
|
||||||
|
Active = null;
|
||||||
|
|
||||||
|
if (player == null) return;
|
||||||
|
Traverse.Create(player).Field("m_debugFly").SetValue(false);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Both halves of debug fly. The field is what the local rider's own physics reads; the ZDO
|
||||||
|
/// var is what every OTHER client reads (Character.IsDebugFlying consults the ZDO when it
|
||||||
|
/// is not the owner). BatFormBehavior only ever wrote the field, which is why a bat looked
|
||||||
|
/// wrong to everyone else - this writes both.
|
||||||
|
/// </summary>
|
||||||
|
private void SetFlying(ZNetView nview, bool flying)
|
||||||
|
{
|
||||||
|
Traverse.Create(player).Field("m_debugFly").SetValue(flying);
|
||||||
|
nview.GetZDO().Set(ZDOVars.s_debugFly, flying);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
193
JotunnModStub/WarVulture/WarVulturePatches.cs
Normal file
193
JotunnModStub/WarVulture/WarVulturePatches.cs
Normal file
|
|
@ -0,0 +1,193 @@
|
||||||
|
using System.Reflection;
|
||||||
|
using HarmonyLib;
|
||||||
|
using UnityEngine;
|
||||||
|
|
||||||
|
namespace RacesOfValheim
|
||||||
|
{
|
||||||
|
/// <summary>
|
||||||
|
/// The one patch that makes a seated player able to fly.
|
||||||
|
///
|
||||||
|
/// Player.SetControls opens with: if the player is attached and presses any movement key, and
|
||||||
|
/// there is no doodad controller, call AttachStop. That is vanilla's "stand up from the chair",
|
||||||
|
/// read straight out of the assembly - and against a rider who drives themselves it fires on
|
||||||
|
/// the first tap of W.
|
||||||
|
///
|
||||||
|
/// Giving the game a doodad controller instead is not the way out: SetDoodadControlls zeroes
|
||||||
|
/// moveDir, run and autoRun unconditionally afterwards, so the rider would stay attached and
|
||||||
|
/// be unable to move. Both doors are shut, which is why this one is a patch.
|
||||||
|
///
|
||||||
|
/// So m_attached is lifted for the duration of SetControls and put straight back. Nothing else
|
||||||
|
/// in that method reads it (checked instruction by instruction), and everything else in the
|
||||||
|
/// game still sees an attached player - including ZSyncAnimation, which is what keeps the
|
||||||
|
/// sitting pose on everyone else's screen.
|
||||||
|
///
|
||||||
|
/// AND THE SECOND HALF, added after the first flight. Lifting m_attached hands the rider back
|
||||||
|
/// every action a standing player has, and three of them have no business happening in a
|
||||||
|
/// saddle: jump, dodge and crouch each played their own animation for half a second before the
|
||||||
|
/// sitting pose snapped back, which is what a rider trying to gain height actually saw.
|
||||||
|
///
|
||||||
|
/// They are suppressed here, at the source, and it costs nothing that was wanted: vanilla's
|
||||||
|
/// UpdateDebugFly does NOT read these arguments. It reads ZInput directly - GetButton("Jump")
|
||||||
|
/// to climb and KeyCode.LeftControl to descend - so taking them out of SetControls removes the
|
||||||
|
/// jump and keeps the climb. Same for the click: while riding, the dismount is read straight
|
||||||
|
/// off ZInput in WarVultureMount, so the attack is suppressed here rather than left to fight
|
||||||
|
/// the saddle pose for an animation it was never going to win.
|
||||||
|
///
|
||||||
|
/// It costs one boolean read per frame when nobody is riding.
|
||||||
|
/// </summary>
|
||||||
|
[HarmonyPatch(typeof(Player), "SetControls")]
|
||||||
|
public static class WarVultureControlsPatch
|
||||||
|
{
|
||||||
|
public static void Prefix(Player __instance, ref bool ___m_attached,
|
||||||
|
ref bool attack, ref bool attackHold,
|
||||||
|
ref bool secondaryAttack, ref bool secondaryAttackHold,
|
||||||
|
ref bool jump, ref bool crouch, ref bool dodge,
|
||||||
|
out bool __state)
|
||||||
|
{
|
||||||
|
__state = false;
|
||||||
|
if (!WarVultureMount.IsRiding(__instance)) return;
|
||||||
|
|
||||||
|
attack = false;
|
||||||
|
attackHold = false;
|
||||||
|
secondaryAttack = false;
|
||||||
|
secondaryAttackHold = false;
|
||||||
|
jump = false;
|
||||||
|
crouch = false;
|
||||||
|
dodge = false;
|
||||||
|
|
||||||
|
if (!___m_attached) return;
|
||||||
|
|
||||||
|
___m_attached = false;
|
||||||
|
__state = true;
|
||||||
|
}
|
||||||
|
|
||||||
|
public static void Postfix(ref bool ___m_attached, bool __state)
|
||||||
|
{
|
||||||
|
if (__state) ___m_attached = true;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// The speed of the ride, and the bird's wind.
|
||||||
|
///
|
||||||
|
/// Character.UpdateDebugFly has just written this physics step's velocity when this runs, so
|
||||||
|
/// this is the last word on it. The mount scales what vanilla computed rather than replacing
|
||||||
|
/// it - see WarVultureMount.ApplyFlight for why that keeps the flight feeling smooth.
|
||||||
|
///
|
||||||
|
/// m_currentVel, m_body and m_run are all private on Character and arrive through Harmony's
|
||||||
|
/// field injection, which is verified when the patch is applied: a Valheim rename becomes a
|
||||||
|
/// startup error instead of a mount that silently stops working.
|
||||||
|
/// </summary>
|
||||||
|
[HarmonyPatch(typeof(Character), "UpdateDebugFly")]
|
||||||
|
public static class WarVultureFlightPatch
|
||||||
|
{
|
||||||
|
private static readonly FieldInfo DebugFlySpeedField = AccessTools.Field(typeof(Character), "m_debugFlySpeed");
|
||||||
|
private static bool warnedAboutSpeedField;
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Vanilla's own debug fly speed, read live rather than cached: the game exposes it as a
|
||||||
|
/// static that can be retuned, and a stale copy here would quietly scale the whole ride.
|
||||||
|
/// </summary>
|
||||||
|
public static float DebugFlySpeed
|
||||||
|
{
|
||||||
|
get
|
||||||
|
{
|
||||||
|
if (DebugFlySpeedField != null) return System.Convert.ToSingle(DebugFlySpeedField.GetValue(null));
|
||||||
|
|
||||||
|
if (!warnedAboutSpeedField)
|
||||||
|
{
|
||||||
|
warnedAboutSpeedField = true;
|
||||||
|
Jotunn.Logger.LogWarning("[WarVulture] Character.m_debugFlySpeed could not be found, so the " +
|
||||||
|
"mount's speeds are being scaled against an assumed 10 m/s. If the " +
|
||||||
|
"bird flies wrong, this line is why.");
|
||||||
|
}
|
||||||
|
return 10f;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
public static void Postfix(Character __instance, ref Vector3 ___m_currentVel, Rigidbody ___m_body, bool ___m_run)
|
||||||
|
{
|
||||||
|
WarVultureMount mount = WarVultureMount.Active;
|
||||||
|
if (mount == null) return;
|
||||||
|
|
||||||
|
Player player = __instance as Player;
|
||||||
|
if (player == null || !WarVultureMount.IsRiding(player)) return;
|
||||||
|
|
||||||
|
mount.ApplyFlight(___m_run, ref ___m_currentVel, ___m_body);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Gives every player a watcher, so a rider on someone else's screen gets a bird under them.
|
||||||
|
///
|
||||||
|
/// A second Player.Awake postfix alongside the one in ZdoVisualSync rather than an edit to it:
|
||||||
|
/// that file belongs to the shared race visuals, this belongs to the vulture, and Harmony is
|
||||||
|
/// perfectly happy to hold both.
|
||||||
|
/// </summary>
|
||||||
|
[HarmonyPatch(typeof(Player), "Awake")]
|
||||||
|
public static class WarVulturePlayerAwakePatch
|
||||||
|
{
|
||||||
|
public static void Postfix(Player __instance)
|
||||||
|
{
|
||||||
|
if (__instance.GetComponent<WarVultureRemoteVisual>() == null)
|
||||||
|
{
|
||||||
|
__instance.gameObject.AddComponent<WarVultureRemoteVisual>();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// The bird as everyone ELSE sees it.
|
||||||
|
///
|
||||||
|
/// The rider's own client draws its bird from WarVultureMount; this draws one for every other
|
||||||
|
/// player who has the flag set on their ZDO. It never touches flight, attachment or input -
|
||||||
|
/// remote players are moved by their own owner and the pose replicates itself through
|
||||||
|
/// ZSyncAnimation, so there is nothing here but a model that appears and disappears.
|
||||||
|
/// </summary>
|
||||||
|
public class WarVultureRemoteVisual : MonoBehaviour
|
||||||
|
{
|
||||||
|
private const string HolderName = "WarVultureRemoteModel";
|
||||||
|
|
||||||
|
private Player player;
|
||||||
|
private WarVultureRig rig;
|
||||||
|
|
||||||
|
private void Awake()
|
||||||
|
{
|
||||||
|
player = GetComponent<Player>();
|
||||||
|
}
|
||||||
|
|
||||||
|
private void Update()
|
||||||
|
{
|
||||||
|
if (player == null) return;
|
||||||
|
|
||||||
|
// The local rider is drawn by their own mount; two birds is one too many.
|
||||||
|
if (player == Player.m_localPlayer) { Hide(); return; }
|
||||||
|
|
||||||
|
ZNetView nview = player.GetComponent<ZNetView>();
|
||||||
|
if (nview == null || !nview.IsValid()) { Hide(); return; }
|
||||||
|
|
||||||
|
bool mounted = nview.GetZDO().GetBool(WarVultureMount.MountedKey, false) && !player.IsDead();
|
||||||
|
|
||||||
|
if (mounted && rig == null) rig = WarVultureVisual.Spawn(player.transform, HolderName);
|
||||||
|
else if (!mounted && rig != null) Hide();
|
||||||
|
|
||||||
|
if (rig != null)
|
||||||
|
{
|
||||||
|
Vector3 velocity = player.GetVelocity();
|
||||||
|
rig.Drive(new Vector3(velocity.x, 0f, velocity.z).magnitude);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private void Hide()
|
||||||
|
{
|
||||||
|
if (rig == null) return;
|
||||||
|
Destroy(rig.gameObject);
|
||||||
|
rig = null;
|
||||||
|
}
|
||||||
|
|
||||||
|
private void OnDestroy()
|
||||||
|
{
|
||||||
|
Hide();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
376
JotunnModStub/WarVulture/WarVultureVisual.cs
Normal file
376
JotunnModStub/WarVulture/WarVultureVisual.cs
Normal file
|
|
@ -0,0 +1,376 @@
|
||||||
|
using UnityEngine;
|
||||||
|
using Jotunn.Managers;
|
||||||
|
|
||||||
|
namespace RacesOfValheim
|
||||||
|
{
|
||||||
|
/// <summary>
|
||||||
|
/// The bird's body: built dead once, then copied.
|
||||||
|
///
|
||||||
|
/// WHY IT IS BUILT AT REGISTRATION AND NOT AT THE SUMMON. The first version borrowed the model
|
||||||
|
/// the way ModelBorrow does it - instantiate into an inactive holder, then DestroyImmediate
|
||||||
|
/// everything that is not a renderer. That is correct at registration time and wrong at summon
|
||||||
|
/// time, and the game says so out loud:
|
||||||
|
///
|
||||||
|
/// Destroying components immediately is not permitted during physics trigger/contact,
|
||||||
|
/// animation event callbacks, rendering callbacks or OnValidate.
|
||||||
|
///
|
||||||
|
/// The summon runs from Attack.OnAttackTrigger, which the game calls from CharacterAnimEvent -
|
||||||
|
/// an animation event callback. Every DestroyImmediate was refused, the model kept its
|
||||||
|
/// Character, its MonsterAI and its ZNetView, and the moment the holder was switched on Awake
|
||||||
|
/// ran and a real Ashlands predator was born under the player. A live rigidbody ignores its
|
||||||
|
/// parent transform, so it flew off. Eleven refusal lines sat in the log directly above the
|
||||||
|
/// "Borrowed 'Volture'" line, which is exactly how it was found.
|
||||||
|
///
|
||||||
|
/// So: the stripping happens once, during CreateAllModAssets, where DestroyImmediate is legal.
|
||||||
|
/// What is kept is a TEMPLATE - an inactive, script-free carcass held in DontDestroyOnLoad -
|
||||||
|
/// and a summon is a plain Instantiate of it. Instantiate is allowed in any context.
|
||||||
|
///
|
||||||
|
/// And it is CHECKED, not assumed. If a single MonoBehaviour survives the strip, the template
|
||||||
|
/// is thrown away and the item refuses to summon. A bird that does not appear is a bug report;
|
||||||
|
/// a bird that appears with an AI is a predator in the player's world with a saved ZDO.
|
||||||
|
/// </summary>
|
||||||
|
public static class WarVultureVisual
|
||||||
|
{
|
||||||
|
private const string SourcePrefab = "Volture";
|
||||||
|
private const string Label = "WarVulture";
|
||||||
|
|
||||||
|
// The three parameters DrakeFormBehavior drives, which is the only animated borrowed
|
||||||
|
// creature in this mod known to look right.
|
||||||
|
private const string FlyingParam = "flying";
|
||||||
|
private const string GroundParam = "onGround";
|
||||||
|
private const string SpeedParam = "forward_speed";
|
||||||
|
|
||||||
|
private static GameObject template;
|
||||||
|
private static float templateSize = 1f;
|
||||||
|
|
||||||
|
public static bool Ready => template != null;
|
||||||
|
|
||||||
|
// ---------------------------------------------------------------- the template
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Called once from WarVultureItem.Register, i.e. from CreateAllModAssets, i.e. from a
|
||||||
|
/// context where components may be destroyed immediately.
|
||||||
|
/// </summary>
|
||||||
|
public static void BuildTemplate()
|
||||||
|
{
|
||||||
|
if (template != null) return;
|
||||||
|
|
||||||
|
GameObject source = PrefabManager.Cache.GetPrefab<GameObject>(SourcePrefab);
|
||||||
|
if (source == null)
|
||||||
|
{
|
||||||
|
Jotunn.Logger.LogWarning($"[{Label}] No '{SourcePrefab}' prefab to copy; the mount will refuse " +
|
||||||
|
"to summon rather than put an invisible rider in the sky.");
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Inactive BEFORE the Instantiate - the one line that keeps Awake from running on a
|
||||||
|
// live predator. Everything else here depends on it.
|
||||||
|
GameObject root = new GameObject("WarVultureTemplate");
|
||||||
|
root.SetActive(false);
|
||||||
|
Object.DontDestroyOnLoad(root);
|
||||||
|
|
||||||
|
GameObject copy = Object.Instantiate(source, root.transform);
|
||||||
|
copy.name = "VoltureModel";
|
||||||
|
copy.transform.localPosition = Vector3.zero;
|
||||||
|
copy.transform.localRotation = Quaternion.identity;
|
||||||
|
copy.transform.localScale = Vector3.one;
|
||||||
|
|
||||||
|
int refused = StripToRenderers(copy);
|
||||||
|
|
||||||
|
int alive = CountBehaviours(copy);
|
||||||
|
if (alive > 0)
|
||||||
|
{
|
||||||
|
Jotunn.Logger.LogError($"[{Label}] {alive} script(s) survived the strip on '{SourcePrefab}' " +
|
||||||
|
$"({refused} destroy calls were refused). The template is being thrown " +
|
||||||
|
"away and the War Vulture will not summon - a half-stripped creature " +
|
||||||
|
"prefab is a live animal, not a model.");
|
||||||
|
Object.DestroyImmediate(root);
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
PrepareAnimator(copy);
|
||||||
|
templateSize = Mathf.Max(0.01f, LargestDimension(copy));
|
||||||
|
template = copy;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Everything that is not geometry or animation, removed in passes.
|
||||||
|
///
|
||||||
|
/// Passes rather than one sweep because Unity refuses to destroy a component another
|
||||||
|
/// component still requires, and the refusal is silent as far as the caller is concerned -
|
||||||
|
/// it logs and moves on. Repeating until a pass changes nothing lets a dependency chain
|
||||||
|
/// unwind in whatever order it needs to.
|
||||||
|
///
|
||||||
|
/// Returns how many destroy calls were refused on the last pass, purely so the failure
|
||||||
|
/// above can say something useful.
|
||||||
|
/// </summary>
|
||||||
|
private static int StripToRenderers(GameObject copy)
|
||||||
|
{
|
||||||
|
int stubborn = 0;
|
||||||
|
|
||||||
|
for (int pass = 0; pass < 6; pass++)
|
||||||
|
{
|
||||||
|
bool destroyedSomething = false;
|
||||||
|
stubborn = 0;
|
||||||
|
|
||||||
|
foreach (Component component in copy.GetComponentsInChildren<Component>(true))
|
||||||
|
{
|
||||||
|
if (component == null) continue;
|
||||||
|
if (IsKept(component)) continue;
|
||||||
|
|
||||||
|
Object.DestroyImmediate(component);
|
||||||
|
|
||||||
|
if (component == null) destroyedSomething = true;
|
||||||
|
else stubborn++;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!destroyedSomething) break;
|
||||||
|
}
|
||||||
|
|
||||||
|
return stubborn;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// The whitelist. Anything not on it goes - colliders, rigidbodies, ZNetView, Character,
|
||||||
|
/// MonsterAI, the lot. Keeping a list of what to KEEP rather than a list of what to remove
|
||||||
|
/// is the difference between a model and an animal: a new component in a future Valheim
|
||||||
|
/// patch is removed by default instead of surviving by omission.
|
||||||
|
///
|
||||||
|
/// The two MESH renderers by name rather than Renderer as a family, which looks like
|
||||||
|
/// pedantry and is not: ParticleSystemRenderer is a Renderer, and "keep every Renderer" is
|
||||||
|
/// how the trophy in the player's hand ended up carrying the sparkle vanilla puts on
|
||||||
|
/// dropped loot. Meshes and the animator that poses them - nothing else.
|
||||||
|
/// </summary>
|
||||||
|
private static bool IsKept(Component component)
|
||||||
|
{
|
||||||
|
return component is Transform
|
||||||
|
|| component is MeshFilter
|
||||||
|
|| component is MeshRenderer
|
||||||
|
|| component is SkinnedMeshRenderer
|
||||||
|
|| component is Animator
|
||||||
|
|| component is LODGroup;
|
||||||
|
}
|
||||||
|
|
||||||
|
private static int CountBehaviours(GameObject copy)
|
||||||
|
{
|
||||||
|
int alive = 0;
|
||||||
|
foreach (MonoBehaviour behaviour in copy.GetComponentsInChildren<MonoBehaviour>(true))
|
||||||
|
{
|
||||||
|
if (behaviour != null) alive++;
|
||||||
|
}
|
||||||
|
return alive;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Three settings, each preventing one specific failure rather than tidying anything.
|
||||||
|
///
|
||||||
|
/// applyRootMotion: clips authored to walk a creature through the world would walk the
|
||||||
|
/// model out from under its rider.
|
||||||
|
///
|
||||||
|
/// cullingMode: the default stops animating when no renderer is on screen, and this bird
|
||||||
|
/// lives half off the bottom of the screen - a frozen mid-flap reads as a bug.
|
||||||
|
///
|
||||||
|
/// fireEvents: the flight clips carry animation events aimed at CharacterAnimEvent, which
|
||||||
|
/// has just been stripped off. Left on, every wingbeat would log "has no receiver".
|
||||||
|
/// </summary>
|
||||||
|
private static void PrepareAnimator(GameObject copy)
|
||||||
|
{
|
||||||
|
Animator animator = copy.GetComponentInChildren<Animator>(true);
|
||||||
|
if (animator == null)
|
||||||
|
{
|
||||||
|
Jotunn.Logger.LogWarning($"[{Label}] The stripped '{SourcePrefab}' has no Animator, so the bird " +
|
||||||
|
"will hang in its bind pose - wings out, legs straight.");
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
animator.applyRootMotion = false;
|
||||||
|
animator.cullingMode = AnimatorCullingMode.AlwaysAnimate;
|
||||||
|
animator.fireEvents = false;
|
||||||
|
animator.enabled = true;
|
||||||
|
}
|
||||||
|
|
||||||
|
// ---------------------------------------------------------------- summoning a copy
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Hangs a copy of the template under a rider and returns the rig that keeps it there.
|
||||||
|
/// Null when the template could not be built, which the caller must treat as "do not
|
||||||
|
/// summon" rather than "summon an invisible bird".
|
||||||
|
/// </summary>
|
||||||
|
public static WarVultureRig Spawn(Transform rider, string holderName)
|
||||||
|
{
|
||||||
|
if (template == null || rider == null) return null;
|
||||||
|
|
||||||
|
GameObject holder = new GameObject(holderName);
|
||||||
|
holder.transform.SetParent(rider, false);
|
||||||
|
holder.transform.localPosition = Vector3.zero;
|
||||||
|
holder.transform.localRotation = Quaternion.identity;
|
||||||
|
|
||||||
|
GameObject model = Object.Instantiate(template, holder.transform);
|
||||||
|
model.name = "model";
|
||||||
|
model.transform.localPosition = Vector3.zero;
|
||||||
|
model.transform.localRotation = Quaternion.identity;
|
||||||
|
model.transform.localScale = Vector3.one * (WarVultureConfig.MountSize.Value / templateSize);
|
||||||
|
model.SetActive(true);
|
||||||
|
|
||||||
|
WarVultureRig rig = holder.AddComponent<WarVultureRig>();
|
||||||
|
rig.Bind(rider, model);
|
||||||
|
return rig;
|
||||||
|
}
|
||||||
|
|
||||||
|
// ---------------------------------------------------------------- animation
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// One frame of flight, told to the animator. Any parameter this controller does not have
|
||||||
|
/// is skipped, so a Valheim animator rename costs a stiff-looking bird rather than a wall
|
||||||
|
/// of errors every frame.
|
||||||
|
/// </summary>
|
||||||
|
public static void Drive(Animator animator, float forwardSpeed)
|
||||||
|
{
|
||||||
|
if (animator == null || animator.runtimeAnimatorController == null) return;
|
||||||
|
|
||||||
|
if (Has(animator, FlyingParam, AnimatorControllerParameterType.Bool)) animator.SetBool(FlyingParam, true);
|
||||||
|
if (Has(animator, GroundParam, AnimatorControllerParameterType.Bool)) animator.SetBool(GroundParam, false);
|
||||||
|
if (Has(animator, SpeedParam, AnimatorControllerParameterType.Float)) animator.SetFloat(SpeedParam, forwardSpeed);
|
||||||
|
}
|
||||||
|
|
||||||
|
private static bool Has(Animator animator, string name, AnimatorControllerParameterType type)
|
||||||
|
{
|
||||||
|
foreach (AnimatorControllerParameter parameter in animator.parameters)
|
||||||
|
{
|
||||||
|
if (parameter.type == type && parameter.name == name) return true;
|
||||||
|
}
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
// ---------------------------------------------------------------- the seat bone
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// The bone the rider sits on.
|
||||||
|
///
|
||||||
|
/// A bone rather than an offset in metres, because that is the difference between sitting
|
||||||
|
/// on the bird and hovering above it: the back moves with every wingbeat, and a fixed
|
||||||
|
/// offset can only ever be right on one frame of the animation.
|
||||||
|
///
|
||||||
|
/// The name is guessed from a priority list and can be overridden in config, because the
|
||||||
|
/// rig's bone names are not knowable from outside the game. The automatic pick was the right
|
||||||
|
/// one in play, so the startup dump that found it has been retired.
|
||||||
|
/// </summary>
|
||||||
|
public static Transform FindSeatBone(GameObject model)
|
||||||
|
{
|
||||||
|
if (model == null) return null;
|
||||||
|
|
||||||
|
Transform[] bones = model.GetComponentsInChildren<Transform>(true);
|
||||||
|
|
||||||
|
string wanted = WarVultureConfig.SeatBone.Value;
|
||||||
|
if (!string.IsNullOrEmpty(wanted))
|
||||||
|
{
|
||||||
|
Transform named = Match(bones, wanted);
|
||||||
|
if (named != null) return named;
|
||||||
|
|
||||||
|
Jotunn.Logger.LogWarning($"[{Label}] No bone matching '{wanted}' on the vulture; falling back " +
|
||||||
|
"to the automatic pick. The bone list is in the log from startup.");
|
||||||
|
}
|
||||||
|
|
||||||
|
// Deliberately in this order: the back of a bird is its spine and chest, and the hips
|
||||||
|
// and root are last-ditch so that SOMETHING is anchored rather than nothing.
|
||||||
|
foreach (string candidate in new[] { "spine", "chest", "back", "torso", "body", "pelvis", "hip", "root" })
|
||||||
|
{
|
||||||
|
Transform found = Match(bones, candidate);
|
||||||
|
if (found != null) return found;
|
||||||
|
}
|
||||||
|
|
||||||
|
return null;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Last match rather than first, on purpose: rigs number their spines outward from the
|
||||||
|
/// hips, so the last "spine" is the one furthest along the back - which is where a saddle
|
||||||
|
/// goes, not where the tail joins.
|
||||||
|
/// </summary>
|
||||||
|
private static Transform Match(Transform[] bones, string needle)
|
||||||
|
{
|
||||||
|
Transform best = null;
|
||||||
|
foreach (Transform bone in bones)
|
||||||
|
{
|
||||||
|
if (bone.name.IndexOf(needle, System.StringComparison.OrdinalIgnoreCase) >= 0) best = bone;
|
||||||
|
}
|
||||||
|
return best;
|
||||||
|
}
|
||||||
|
|
||||||
|
// ---------------------------------------------------------------- measuring
|
||||||
|
|
||||||
|
private static float LargestDimension(GameObject model)
|
||||||
|
{
|
||||||
|
bool any = false;
|
||||||
|
Bounds bounds = new Bounds();
|
||||||
|
|
||||||
|
foreach (Renderer renderer in model.GetComponentsInChildren<Renderer>(true))
|
||||||
|
{
|
||||||
|
Mesh mesh = renderer is SkinnedMeshRenderer skinned
|
||||||
|
? skinned.sharedMesh
|
||||||
|
: renderer.GetComponent<MeshFilter>()?.sharedMesh;
|
||||||
|
if (mesh == null) continue;
|
||||||
|
|
||||||
|
Bounds local = mesh.bounds;
|
||||||
|
Matrix4x4 toModel = model.transform.worldToLocalMatrix * renderer.transform.localToWorldMatrix;
|
||||||
|
|
||||||
|
for (int corner = 0; corner < 8; corner++)
|
||||||
|
{
|
||||||
|
Vector3 point = toModel.MultiplyPoint3x4(local.center + new Vector3(
|
||||||
|
(corner & 1) == 0 ? -local.extents.x : local.extents.x,
|
||||||
|
(corner & 2) == 0 ? -local.extents.y : local.extents.y,
|
||||||
|
(corner & 4) == 0 ? -local.extents.z : local.extents.z));
|
||||||
|
|
||||||
|
if (!any) { bounds = new Bounds(point, Vector3.zero); any = true; }
|
||||||
|
else bounds.Encapsulate(point);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return any ? Mathf.Max(bounds.size.x, Mathf.Max(bounds.size.y, bounds.size.z)) : 1f;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Keeps the bird under its rider, one bone at a time.
|
||||||
|
///
|
||||||
|
/// In LateUpdate, after the animator has posed the skeleton for this frame, the whole model is
|
||||||
|
/// slid so that the seat bone lands exactly on the rider's own origin. That is what "sitting on
|
||||||
|
/// the bird's back" means as a piece of code, and it is why there is no height offset anywhere
|
||||||
|
/// in this feature any more: the back tells us where it is, every frame, including while it
|
||||||
|
/// rises and falls with the wingbeat.
|
||||||
|
///
|
||||||
|
/// Shared by the rider's own copy and by the copy other players see, so the bird cannot sit in
|
||||||
|
/// two different places depending on who is looking.
|
||||||
|
/// </summary>
|
||||||
|
public class WarVultureRig : MonoBehaviour
|
||||||
|
{
|
||||||
|
private Transform rider;
|
||||||
|
private Transform model;
|
||||||
|
private Transform seatBone;
|
||||||
|
private Animator animator;
|
||||||
|
|
||||||
|
public void Bind(Transform rider, GameObject model)
|
||||||
|
{
|
||||||
|
this.rider = rider;
|
||||||
|
this.model = model.transform;
|
||||||
|
seatBone = WarVultureVisual.FindSeatBone(model);
|
||||||
|
animator = model.GetComponentInChildren<Animator>(true);
|
||||||
|
}
|
||||||
|
|
||||||
|
public void Drive(float forwardSpeed)
|
||||||
|
{
|
||||||
|
WarVultureVisual.Drive(animator, forwardSpeed);
|
||||||
|
}
|
||||||
|
|
||||||
|
private void LateUpdate()
|
||||||
|
{
|
||||||
|
if (rider == null || model == null) return;
|
||||||
|
|
||||||
|
Vector3 seat = rider.position + rider.rotation * new Vector3(
|
||||||
|
0f, WarVultureConfig.SeatNudgeY.Value, WarVultureConfig.SeatNudgeZ.Value);
|
||||||
|
|
||||||
|
if (seatBone != null) model.position += seat - seatBone.position;
|
||||||
|
else model.position = seat;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
Loading…
Add table
Add a link
Reference in a new issue