RacesOfValheim/JotunnModStub/Factions/FactionHostilityPatch.cs
kanym fac6e3986c fix(factions): stop same-faction mobs from smashing player structures
The truce only ever patched BaseAI.IsEnemy, but MonsterAI.UpdateTarget
picks a structure to attack (m_targetStatic) through a completely
separate gate - m_attackPlayerObjects, a flag baked into the prefab
(true for Troll among others) - and never calls IsEnemy at all. A Trol
player, exempt from a cave's resident Troll in combat, could still
watch it flatten a workbench built moments earlier in its own cave.

FactionStaticTargetPatch postfixes UpdateTarget and vetoes the pick if
a same-faction player is within 20 m (matching FindRandomStaticTarget's
own 10 m search radius with room to spare), rather than trying to
intercept the two private target-selection methods themselves.

Confirmed fixed by build+playtest.
2026-08-09 16:46:23 +02:00

135 lines
6.6 KiB
C#

using System.Collections.Generic;
using HarmonyLib;
using UnityEngine;
namespace RacesOfValheim
{
// "Mobs of a faction don't attack players of the same faction" - the core Factions
// rule from the brainstorm. RaceHostilityManager.cs already grants some of this
// (Fenrir/Aswid/Draugh/Trenta), but several races have no coverage at all (Trol,
// Furling, Skadi, Dvergar, Skeleton), and none of it lines up race-for-race with the
// three Factions groupings. Both patches postfix the same vanilla method, so this one
// simply layers the full, faction-consistent ruleset on top without touching the
// older file - a player already exempted there stays exempted, this only adds pairs.
//
// Without this, a matching-faction mob keeps fighting the player, which is why the
// Trader's "E to use" prompt never has a chance to come up: BaseAI.UpdateAI() is
// still busy chasing/attacking every frame.
[HarmonyPatch(typeof(BaseAI), nameof(BaseAI.IsEnemy), new System.Type[] { typeof(Character), typeof(Character) })]
public static class FactionHostilityPatch
{
// "Fuling" was in this set and is not a prefab: the Fuling family is named Goblin* in code,
// so the basic Fuling and the Archer were never exempted for any of the three races that
// read this set (Trenta, Trol, Furling) while the Berserker and Shaman were. In a camp that
// is the same as no truce at all - the unexempted Fulings open fire, the player defends
// themselves, and every Berserker in earshot joins in through damage retaliation, which
// IsEnemy has no say over. Verified against the asset manifest, not the wiki's display names.
private static readonly HashSet<string> NeraForestaMobs = new HashSet<string>
{
"Greydwarf", "Greydwarf_Elite", "Greydwarf_Shaman",
"Goblin", "GoblinArcher", "GoblinBrute", "GoblinShaman",
"Troll",
};
private static readonly HashSet<string> MontagnaMobs = new HashSet<string>
{
"Hatchling", // Drake
"Wolf", "Ulv", "Fenring", "Fenring_Cultist",
"Dverger", "DvergerMageFire", "DvergerMageIce", "DvergerMageSupport", "DvergerAshlands",
};
private static readonly HashSet<string> PaludeMobs = new HashSet<string>
{
"Ghost", "Skeleton", "Skeleton_Poison", // Skeleton, Rancid remains
"Draugr", "Draugr_Elite",
"Wraith", "Leech", "Abomination",
"Blob", "BlobElite", "BlobTar", // Blob, Oozer, Growth
};
// Every race id ever assigned to m_customData["Race"] for the nine playable races,
// grouped by which faction's mobs they get along with (see RacesOfValheim.cs for
// where each string is set, and DvergarRace.cs's LegacyRaceId for the old save value).
private static readonly Dictionary<string, HashSet<string>> RaceFactionMobs = new Dictionary<string, HashSet<string>>
{
{ TrentaConfig.RaceId, NeraForestaMobs },
{ "Trol", NeraForestaMobs },
{ "Furling", NeraForestaMobs },
{ "Skadi", MontagnaMobs },
{ "Fenrir", MontagnaMobs },
{ DvergarConfig.RaceId, MontagnaMobs },
{ DvergarRace.LegacyRaceId, MontagnaMobs },
{ "Aswid", PaludeMobs },
{ "Draugh", PaludeMobs },
{ SkeletonVisuals.RaceId, PaludeMobs },
};
// Shared with FactionMerchantHoverPatch: a player should only get the "E - Talk"
// hover prompt for a mob whose faction actually matches their own race.
public static bool IsSameFaction(Player player, Character monster)
{
if (player == null || monster == null) return false;
if (!player.m_customData.TryGetValue("Race", out string race)) return false;
if (!RaceFactionMobs.TryGetValue(race, out HashSet<string> mobs)) return false;
string prefabName = monster.gameObject.name.Replace("(Clone)", "").Trim();
return mobs.Contains(prefabName);
}
public static void Postfix(Character a, Character b, ref bool __result)
{
if (!__result) return; // already not enemies, nothing to add
if (a == null || b == null) return;
Character playerCharacter = a.IsPlayer() ? a : (b.IsPlayer() ? b : null);
Character monster = a.IsPlayer() ? b : (b.IsPlayer() ? a : null);
if (!(playerCharacter is Player p) || monster == null) return;
if (IsSameFaction(p, monster))
{
__result = false;
}
}
}
/// <summary>
/// The truce above only ever touches BaseAI.IsEnemy - a mob's decision to smash a nearby
/// piece runs on a completely separate track. MonsterAI.UpdateTarget gates that on
/// m_attackPlayerObjects (a flag baked into the prefab, true for Troll among others) and
/// never once calls IsEnemy: a Troll with nothing to fight picks a m_targetStatic and
/// swings at it regardless of who is standing next to it. That is how a Trol player,
/// exempt from that very Troll's hostility, could still watch it flatten a workbench built
/// two seconds earlier in its own cave.
///
/// A postfix on UpdateTarget rather than trying to intercept FindClosestStaticPriorityTarget
/// or FindRandomStaticTarget (both private, both called from more than one branch inside it):
/// simpler to let vanilla pick whatever it wants and veto the pick once, right after, than to
/// duplicate its target-selection logic to stop it picking in the first place.
/// </summary>
[HarmonyPatch(typeof(MonsterAI), "UpdateTarget")]
public static class FactionStaticTargetPatch
{
// Comfortably past FindRandomStaticTarget's own 10 m search radius, so a truce holds for
// any piece the mob could have picked in the first place.
private const float FactionCheckRange = 20f;
public static void Postfix(MonsterAI __instance)
{
Traverse targetStatic = Traverse.Create(__instance).Field("m_targetStatic");
if (targetStatic.GetValue() == null) return;
Character monster = Traverse.Create(__instance).Field<Character>("m_character").Value;
if (monster == null) return;
foreach (Player player in Player.GetAllPlayers())
{
if (Vector3.Distance(player.transform.position, monster.transform.position) > FactionCheckRange) continue;
if (!FactionHostilityPatch.IsSameFaction(player, monster)) continue;
targetStatic.SetValue(null);
return;
}
}
}
}