diff --git a/JotunnModStub/Factions/FactionsConfig.cs b/JotunnModStub/Factions/FactionsConfig.cs index 6086402..6535e12 100644 --- a/JotunnModStub/Factions/FactionsConfig.cs +++ b/JotunnModStub/Factions/FactionsConfig.cs @@ -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(0f, 600f))); diff --git a/JotunnModStub/RaceGrudge.cs b/JotunnModStub/RaceGrudge.cs index 944a260..09bb834 100644 --- a/JotunnModStub/RaceGrudge.cs +++ b/JotunnModStub/RaceGrudge.cs @@ -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 /// 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 grudges = new Dictionary(); - 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 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); + } + /// /// True while is owed a hit by . 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. /// 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(); } /// - /// 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. /// - 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 expired = null; - foreach (var entry in grudges) + ZNetView nview = monster.GetComponent(); + if (nview == null || !nview.IsValid()) return false; + + if (!nview.IsOwner()) { - if (Time.time < entry.Value.Until) continue; - if (expired == null) expired = new List(); - 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)); + } + + /// + /// 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. + /// + [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(); + if (nview == null || !nview.IsValid()) return; + + nview.Register(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); } /// @@ -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. /// 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(); } } }