Merge branch 'fix-grudge-multiplayer'

This commit is contained in:
kanym 2026-11-06 21:28:13 +01:00
commit 6ddca72144
2 changed files with 77 additions and 49 deletions

View file

@ -59,8 +59,9 @@ namespace RacesOfValheim
"Without this the truce is absolute in both directions: MonsterAI.UpdateTarget " +
"throws away any target BaseAI.IsEnemy calls a non-enemy, so a truced mob could " +
"not fight back even after being struck - it stood still, or fled because it " +
"was hurt and had no enemy it was allowed to have. The grudge is per attacker " +
"and per creature, on whichever machine runs that creature's AI. 0 restores the " +
"was hurt and had no enemy it was allowed to have. Each creature holds one " +
"grudge, against the last player who hit it, and keeps it when another player's " +
"game takes over running that creature. 0 restores the " +
"old absolute truce.",
new AcceptableValueRange<float>(0f, 600f)));

View file

@ -25,11 +25,13 @@ namespace RacesOfValheim
/// which means everything downstream - acquiring, chasing, retaliating, giving up - is vanilla
/// behaviour rather than anything reimplemented here.
///
/// WHERE IT RUNS. On the client that owns the mob's AI, which is the only one whose UpdateTarget
/// matters and the only one that runs Character.ApplyDamage for it. BaseAI.OnDamaged is reached
/// through the character's damage callback on exactly that machine, so the record is made where
/// it will be read. Nothing is replicated and nothing needs to be: another client's copy of the
/// same mob is not the one deciding who it chases.
/// WHERE IT LIVES. On the creature's own ZDO: who it is angry at and until when, in network time.
/// The AI that reads it runs on whichever machine owns the creature, and that can change in the
/// middle of a fight (the owner walks off or logs out). A grudge kept in one machine's memory
/// went with it, and the new owner's copy of the creature made peace on its next UpdateTarget.
/// On the ZDO the new owner reads the same grudge. Only the owner writes it: a hit reaches the
/// owner through Character.Damage's RPC anyway, and kin owned elsewhere are told by an RPC of
/// our own (RpcName), so no client writes a ZDO it does not own.
///
/// Vanilla has its own version of this idea in BaseAI.SetAggravated, and it is not usable here:
/// it does nothing unless the prefab sets m_aggravatable, which only the dvergr and the seekers
@ -37,67 +39,96 @@ namespace RacesOfValheim
/// </summary>
public static class RaceGrudge
{
private struct Grudge
{
public ZDOID Attacker;
public float Until;
}
private const string RpcName = "RacesOfValheim_Grudge";
// One grudge per mob, against the last thing that hit it. A creature can only chase one
// target anyway, and if two players of the same race are both poking it, the one it wants
// is whoever hit it last.
private static readonly Dictionary<ZDOID, Grudge> grudges = new Dictionary<ZDOID, Grudge>();
private static float lastSweep = 0f;
// One grudge per creature, against the last player that hit it. A creature can only chase
// one target anyway, and if two players of the same race are both poking it, the one it
// wants is whoever hit it last.
private static readonly KeyValuePair<int, int> AttackerKey = ZDO.GetHashZDOID("RacesOfValheim_GrudgeAttacker");
private static readonly int UntilKey = "RacesOfValheim_GrudgeUntil".GetStableHashCode();
private static float Duration => FactionsConfig.GrudgeSeconds;
// Network time, the same on every machine, so an end time written by one owner means the
// same thing to the next. Milliseconds in a long: ZDO has no double.
private static long NowMs => ZNet.instance != null ? (long)(ZNet.instance.GetTimeSeconds() * 1000.0) : 0L;
private static ZDO ZdoOf(Character character)
{
if (character == null || ZDOMan.instance == null) return null;
ZDOID id = character.GetZDOID();
return id.IsNone() ? null : ZDOMan.instance.GetZDO(id);
}
/// <summary>
/// True while <paramref name="monster"/> is owed a hit by <paramref name="player"/>. Both
/// truce postfixes ask this first and leave IsEnemy alone when it answers yes.
/// truce postfixes ask this first and leave IsEnemy alone when it answers yes. Read on any
/// machine; it only matters on the owner's.
/// </summary>
public static bool Holds(Character monster, Character player)
{
if (monster == null || player == null) return false;
if (Duration <= 0f) return false;
if (!grudges.TryGetValue(monster.GetZDOID(), out Grudge grudge)) return false;
if (Time.time >= grudge.Until) return false;
ZDO zdo = ZdoOf(monster);
if (zdo == null) return false;
return grudge.Attacker == player.GetZDOID();
}
long until = zdo.GetLong(UntilKey, 0L);
if (until == 0L || NowMs >= until) return false;
public static void Remember(Character monster, Character attacker)
{
if (monster == null || attacker == null) return;
if (Duration <= 0f) return;
grudges[monster.GetZDOID()] = new Grudge
{
Attacker = attacker.GetZDOID(),
Until = Time.time + Duration
};
Sweep();
return zdo.GetZDOID(AttackerKey) == player.GetZDOID();
}
/// <summary>
/// Drops grudges nobody is owed any more. At most once per duration: a fight is a burst of
/// damage events and the list should not be walked on each one.
/// Writes the grudge on the creature's ZDO if this machine owns it, and otherwise asks the
/// owner to. Returns true when it was written here.
/// </summary>
private static void Sweep()
public static bool Remember(Character monster, Character attacker)
{
if (Time.time - lastSweep < Duration) return;
lastSweep = Time.time;
if (monster == null || attacker == null) return false;
if (Duration <= 0f) return false;
List<ZDOID> expired = null;
foreach (var entry in grudges)
ZNetView nview = monster.GetComponent<ZNetView>();
if (nview == null || !nview.IsValid()) return false;
if (!nview.IsOwner())
{
if (Time.time < entry.Value.Until) continue;
if (expired == null) expired = new List<ZDOID>();
expired.Add(entry.Key);
nview.InvokeRPC(RpcName, attacker.GetZDOID());
return false;
}
Write(nview.GetZDO(), attacker.GetZDOID());
return true;
}
private static void Write(ZDO zdo, ZDOID attacker)
{
zdo.Set(AttackerKey, attacker);
zdo.Set(UntilKey, NowMs + (long)(Duration * 1000f));
}
/// <summary>
/// Every creature can be told about a grudge by a machine that does not own it. ZNetView's
/// InvokeRPC routes to the owner, so the handler always runs where the ZDO may be written,
/// and the owner checks it is still the owner: ownership can move while the RPC travels.
/// </summary>
[HarmonyPatch(typeof(Character), "Awake")]
public static class Character_Awake_GrudgeRpc_Patch
{
public static void Postfix(Character __instance)
{
if (__instance.IsPlayer()) return;
ZNetView nview = __instance.GetComponent<ZNetView>();
if (nview == null || !nview.IsValid()) return;
nview.Register<ZDOID>(RpcName, (sender, attacker) =>
{
if (__instance == null || !nview.IsValid() || !nview.IsOwner()) return;
if (attacker.IsNone() || Duration <= 0f) return;
Write(nview.GetZDO(), attacker);
__instance.GetBaseAI()?.Alert();
});
}
if (expired == null) return;
foreach (ZDOID id in expired) grudges.Remove(id);
}
/// <summary>
@ -179,10 +210,8 @@ namespace RacesOfValheim
/// Vanilla's Dvergr camp, for every faction ("Grudge spreads to kin", off by default): hit
/// a creature that is at peace with you and its kin around it take up the same grudge.
///
/// Only the creatures this machine runs the AI for are told, because a grudge is read where
/// the AI runs (see WHERE IT RUNS above). The creatures around the one that was hit are
/// nearly always simulated by the same client; one owned by another player's machine stays
/// at peace until it is hit itself.
/// Kin this machine owns are written here; kin owned by another player's machine are told
/// through RpcName, and their owner writes the grudge and alerts them.
/// </summary>
private static void SpreadToKin(Character monster, Player player)
{
@ -194,12 +223,10 @@ namespace RacesOfValheim
foreach (Character other in Character.GetAllCharacters())
{
if (other == null || other == monster || other.IsPlayer() || other.IsDead() || other.IsTamed()) continue;
if (!other.IsOwner()) continue;
if (Vector3.Distance(other.transform.position, center) > radius) continue;
if (!FactionHostilityPatch.IsAlliedMob(race, other.gameObject.name)) continue;
Remember(other, player);
other.GetBaseAI()?.Alert();
if (Remember(other, player)) other.GetBaseAI()?.Alert();
}
}
}