The log in the troll's fist was there but switched off: an item's attach child is stored inactive in its prefab and VisEquipment turns it on after the Instantiate. It is now switched on, hung with the item's equipoffset, and sized to the costume, since AttachItem keeps an attach at its world size and the costume is not at scale 1. The slam never ran its slam code. troll_groundslam is a Vertical attack in vanilla, not Area, so asking the attack type sent every slam down the punch's sweep: damage, but no AoE, no dust and no crater. The slam now goes by the key that was pressed. The tint multiplied _Color, which the creature shader does not read. It now shifts _Hue, _Saturation and _Value, as LevelEffects does for starred creatures, by the distance from the vanilla troll's colour to the player's skin colour.
494 lines
24 KiB
C#
494 lines
24 KiB
C#
using System.Collections.Generic;
|
|
using HarmonyLib;
|
|
using Jotunn.Managers;
|
|
using UnityEngine;
|
|
|
|
namespace RacesOfValheim
|
|
{
|
|
/// <summary>
|
|
/// True Form wears Valheim's own forest troll instead of a scaled-up player.
|
|
///
|
|
/// Built the way the Fenrir forms are, not the way the Sverm's Ravager is: the troll's Visual is
|
|
/// instantiated live under the player, CharacterAnimEvent and AnimationEffect included. That
|
|
/// costs a FormFootsteps.Detach, and in return the troll's own clips play their own sounds and,
|
|
/// more to the point here, fire OnAttackTrigger at the exact frame a fist lands. That event
|
|
/// resolves to the PLAYER (the first Character up the hierarchy), and
|
|
/// Trol_TrueFormAttackTrigger_Patch catches it there - so every hit lands on the troll's own
|
|
/// timing rather than on a delay somebody guessed.
|
|
///
|
|
/// SIZE. The costume does not have a size of its own. Every frame it is sized to stand as tall as
|
|
/// the player's hidden Visual would - the same Visual Trol_PlayerUpdate_Patch already grows from
|
|
/// 1.2-1.3 to the True Form scale, on the owner's client and every onlooker's. So the grow-in, the
|
|
/// shrink back and the size other players see all come from code that already worked, and
|
|
/// "Scale" / "Scale (Tier 7+)" keep meaning what they meant: how many player heights tall.
|
|
///
|
|
/// ATTACKS. Read once off the troll's own weapons (Humanoid.m_defaultItems and friends): the
|
|
/// trigger each one plays, its damage, its reach. Nothing is cloned or equipped. The damage is a
|
|
/// share of the troll's (Troll Attack Damage), scaled by the player's Clubs skill exactly the way
|
|
/// a weapon is, and hit as Clubs - so Trol_Character_ApplyDamage_Patch adds the True Form and tier
|
|
/// bonuses on top just as it did for a club in hand.
|
|
/// </summary>
|
|
public static class TrolTrueFormModel
|
|
{
|
|
public const string Creature = "Troll";
|
|
public const string LocalModelName = "TrolTrueFormModel";
|
|
public const string RemoteModelName = "TrolTrueFormRemoteModel";
|
|
|
|
// Published by the owner after every trigger it fires, with a running count so the same
|
|
// punch twice in a row still reads as two - see FenrirAttackSync.
|
|
public const string AttackTriggerKey = "RacesOfValheim_TrolTrueFormAttack";
|
|
private static int attackSeq;
|
|
|
|
private static readonly int TrueFormHash = "SE_TrolTrueForm".GetStableHashCode();
|
|
|
|
public enum AttackKind { Punch, Slam, Throw, LogSwingH, LogSwingV }
|
|
|
|
public class Profile
|
|
{
|
|
public string Source;
|
|
public string Trigger;
|
|
public HitData.DamageTypes Damage;
|
|
public Attack.AttackType Type;
|
|
public float Range;
|
|
public float Height;
|
|
public float Angle;
|
|
public float PushForce;
|
|
public int ToolTier;
|
|
public ItemDrop.ItemData.SharedData Shared;
|
|
|
|
// The weapon's own model, as VisEquipment would hang it in the troll's hand. Only the
|
|
// log swings have one worth showing.
|
|
public GameObject Attach;
|
|
}
|
|
|
|
private static readonly Dictionary<AttackKind, Profile> profiles = new Dictionary<AttackKind, Profile>();
|
|
private static bool profilesRead;
|
|
|
|
// Measured once off the prefab: how tall the troll stands at scale 1.
|
|
private static float trollHeight = -1f;
|
|
private static string rightHandPath;
|
|
|
|
private static readonly HashSet<string> logged = new HashSet<string>();
|
|
|
|
private static GameObject localModel;
|
|
private static int attackEvents;
|
|
|
|
public static bool LocalActive => localModel != null;
|
|
|
|
/// <summary>True while the local troll is in the middle of a swing, a slam or a throw.
|
|
/// Trol_TrueFormHoldStill_Patch holds the player still for exactly that long.</summary>
|
|
public static bool LocalAttacking { get; set; }
|
|
|
|
/// <summary>How many OnAttackTrigger events the local troll has fired. Attack routines
|
|
/// remember the count and wait for it to move.</summary>
|
|
public static int AttackEvents => attackEvents;
|
|
|
|
public static void NotifyAttackTrigger() => attackEvents++;
|
|
|
|
// ─── Lifecycle ───────────────────────────────────────────────────────
|
|
|
|
/// <summary>
|
|
/// Called every frame from TrolRace.Update, before its race check, so a race change, a death
|
|
/// or the form running out all take the costume off even though nothing else in TrolRace
|
|
/// looks at the player any more by then.
|
|
/// </summary>
|
|
public static void Tick(Player player)
|
|
{
|
|
if (player == null || player != Player.m_localPlayer) return;
|
|
|
|
bool wanted = TrolConfig.TrueFormUseTrollModel.Value &&
|
|
!player.IsDead() &&
|
|
TrolRace.IsTrol() &&
|
|
player.GetSEMan().HaveStatusEffect(TrueFormHash);
|
|
|
|
if (wanted && localModel == null) SpawnLocal(player);
|
|
else if (!wanted && localModel != null) RemoveLocal(player);
|
|
}
|
|
|
|
private static void SpawnLocal(Player player)
|
|
{
|
|
localModel = Spawn(player, LocalModelName);
|
|
if (localModel == null) return;
|
|
|
|
localModel.AddComponent<TrolTrueFormBehavior>();
|
|
PlayerVisualHider.Hide(player.transform.Find("Visual"), "trol-trueform-local", keepScale: true);
|
|
|
|
GameObject smoke = PrefabManager.Cache.GetPrefab<GameObject>("vfx_corpse_destruction_medium");
|
|
if (smoke != null) Object.Instantiate(smoke, player.transform.position + Vector3.up, Quaternion.identity);
|
|
}
|
|
|
|
/// <summary>Takes the costume off and gives the body back. Safe to call when there is none.</summary>
|
|
public static bool RemoveLocal(Player player)
|
|
{
|
|
if (localModel == null) return false;
|
|
|
|
// SetActive first: Destroy waits for the end of the frame, and the behaviour's
|
|
// LateUpdate would hide the body again after the Show below. Same trap
|
|
// SvermRavagerForm.Exit documents.
|
|
localModel.SetActive(false);
|
|
Object.Destroy(localModel);
|
|
localModel = null;
|
|
LocalAttacking = false;
|
|
|
|
if (player != null) PlayerVisualHider.Show(player.transform.Find("Visual"), "trol-trueform-revert", keepScale: true);
|
|
return true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// The troll's Visual, under the given player. Shared by the owner's copy and every
|
|
/// onlooker's, so both look alike; only the driving component differs.
|
|
/// </summary>
|
|
public static GameObject Spawn(Player player, string name)
|
|
{
|
|
GameObject prefab = PrefabManager.Cache.GetPrefab<GameObject>(Creature);
|
|
Transform source = prefab != null ? prefab.transform.Find("Visual") : null;
|
|
if (source == null)
|
|
{
|
|
Jotunn.Logger.LogWarning($"[Trol] No '{Creature}' Visual to build True Form from; staying in the old shape.");
|
|
return null;
|
|
}
|
|
|
|
MeasureTroll(prefab);
|
|
|
|
GameObject model = Object.Instantiate(source.gameObject, player.transform);
|
|
model.name = name;
|
|
model.transform.localPosition = Vector3.zero;
|
|
model.transform.localRotation = Quaternion.identity;
|
|
model.transform.localScale = Vector3.one * ScaleFor(player);
|
|
|
|
FormFootsteps.Detach(model, Creature);
|
|
|
|
Animator anim = model.GetComponentInChildren<Animator>(true);
|
|
if (anim != null)
|
|
{
|
|
anim.cullingMode = AnimatorCullingMode.AlwaysAnimate;
|
|
if (anim.GetComponent("AnimationEffect") == null) anim.gameObject.AddComponent<FormAnimEventSound>();
|
|
}
|
|
|
|
Tint(model, SkinColorOf(player));
|
|
return model;
|
|
}
|
|
|
|
/// <summary>
|
|
/// The costume's scale for this player right now: as tall as their Visual stands, in
|
|
/// player heights, times the Troll Model Size setting.
|
|
/// </summary>
|
|
public static float ScaleFor(Player player)
|
|
{
|
|
if (player == null || trollHeight <= 0f) return 1f;
|
|
|
|
GameObject visual = Traverse.Create(player).Field("m_visual").GetValue<GameObject>();
|
|
float visualScale = visual != null ? visual.transform.localScale.y : 1f;
|
|
|
|
CapsuleCollider capsule = player.GetComponent<CapsuleCollider>();
|
|
float playerHeight = capsule != null ? capsule.height : 1.85f;
|
|
|
|
return playerHeight * visualScale / trollHeight * TrolConfig.TrueFormModelSize.Value;
|
|
}
|
|
|
|
private static void MeasureTroll(GameObject prefab)
|
|
{
|
|
if (trollHeight > 0f) return;
|
|
|
|
CapsuleCollider capsule = prefab.GetComponent<CapsuleCollider>();
|
|
trollHeight = capsule != null ? capsule.height * prefab.transform.localScale.y : 0f;
|
|
if (trollHeight <= 0.5f) trollHeight = 4.5f;
|
|
|
|
// Where the troll holds its log: VisEquipment knows, so ask it rather than guess bones.
|
|
VisEquipment vis = prefab.GetComponent<VisEquipment>();
|
|
Transform hand = vis != null ? vis.m_rightHand : null;
|
|
Transform visualRoot = prefab.transform.Find("Visual");
|
|
if (hand != null && visualRoot != null && hand.IsChildOf(visualRoot))
|
|
{
|
|
rightHandPath = PathFrom(visualRoot, hand);
|
|
}
|
|
|
|
Jotunn.Logger.LogInfo($"[Trol] True Form model: '{Creature}' stands {trollHeight:0.00} m at scale 1, " +
|
|
$"right hand '{rightHandPath ?? "not found"}'.");
|
|
}
|
|
|
|
private static string PathFrom(Transform root, Transform child)
|
|
{
|
|
var parts = new List<string>();
|
|
for (Transform t = child; t != null && t != root; t = t.parent) parts.Insert(0, t.name);
|
|
return string.Join("/", parts);
|
|
}
|
|
|
|
// ─── Looks ───────────────────────────────────────────────────────────
|
|
|
|
/// <summary>The colour this Trol picked in Trol - Appearance, as published on their ZDO.</summary>
|
|
public static Color SkinColorOf(Player player)
|
|
{
|
|
ZNetView nview = player != null ? player.GetComponent<ZNetView>() : null;
|
|
if (nview != null && nview.IsValid())
|
|
{
|
|
Vector3 v = nview.GetZDO().GetVec3(TrolSkinColorPatch.SkinColorKey, new Vector3(-1f, -1f, -1f));
|
|
if (v.x >= 0f) return new Color(v.x, v.y, v.z, 1f);
|
|
}
|
|
return player == Player.m_localPlayer ? TrolConfig.SkinColor.Value : TrolConfig.DefaultSkinColor;
|
|
}
|
|
|
|
// The vanilla forest troll's own colour, as near as a single swatch gets: the same value the
|
|
// Skin Color description recommends for "the look of Valheim's own trolls".
|
|
private static readonly Color VanillaTrollColor = new Color(0x7F / 255f, 0xA8 / 255f, 0xC9 / 255f, 1f);
|
|
|
|
/// <summary>
|
|
/// Shifts the troll's colour toward the player's skin colour, the way Valheim recolours a
|
|
/// starred creature: LevelEffects writes _Hue, _Saturation and _Value on the creature
|
|
/// shader. The first version multiplied _Color, which this shader does not read, so the
|
|
/// troll stayed vanilla blue. The shift is the distance from the vanilla troll's colour to
|
|
/// the chosen one, so the default Trol skin gives a troll close to its own colour and the
|
|
/// texture's shading survives whatever hue is picked.
|
|
/// </summary>
|
|
private static void Tint(GameObject model, Color skin)
|
|
{
|
|
Color.RGBToHSV(VanillaTrollColor, out float baseH, out float baseS, out float baseV);
|
|
Color.RGBToHSV(skin, out float h, out float s, out float v);
|
|
|
|
float hue = Mathf.Repeat(h - baseH + 0.5f, 1f) - 0.5f;
|
|
float saturation = Mathf.Clamp(s - baseS, -1f, 1f);
|
|
// Value is halved: the swatch reads darker on the skin than it looks in the picker (the
|
|
// Skin Color description says as much), and a full shift took the troll to near black.
|
|
float value = Mathf.Clamp((v - baseV) * 0.5f, -1f, 1f);
|
|
|
|
int tinted = 0;
|
|
foreach (Renderer r in model.GetComponentsInChildren<Renderer>(true))
|
|
{
|
|
if (r is ParticleSystemRenderer) continue;
|
|
foreach (Material m in r.materials)
|
|
{
|
|
if (m == null || !m.HasProperty("_Hue")) continue;
|
|
m.SetFloat("_Hue", hue);
|
|
if (m.HasProperty("_Saturation")) m.SetFloat("_Saturation", saturation);
|
|
if (m.HasProperty("_Value")) m.SetFloat("_Value", value);
|
|
tinted++;
|
|
}
|
|
}
|
|
|
|
if (logged.Add("tint/" + model.name))
|
|
{
|
|
Jotunn.Logger.LogInfo($"[Trol] True Form tint: hue {hue:+0.00;-0.00}, saturation {saturation:+0.00;-0.00}, " +
|
|
$"value {value:+0.00;-0.00} on {tinted} material(s).");
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Puts a copy of the held Trol log in the troll's right hand, or takes it away. Called every
|
|
/// frame by both drivers with whatever the player has in their right hand.
|
|
/// </summary>
|
|
public static void UpdateHeldLog(GameObject model, GameObject itemPrefab, ref GameObject current, ref string currentName)
|
|
{
|
|
string wanted = itemPrefab != null && itemPrefab.name.StartsWith("TrolWeapon_") ? itemPrefab.name : null;
|
|
if (wanted == currentName) return;
|
|
|
|
if (current != null) Object.Destroy(current);
|
|
current = null;
|
|
currentName = wanted;
|
|
if (wanted == null || rightHandPath == null) return;
|
|
|
|
Transform hand = model.transform.Find(rightHandPath);
|
|
if (hand == null) return;
|
|
|
|
// The troll's OWN log, not the Trol's. The Trol's was built for a person's hand - turned
|
|
// 90 degrees, pushed 1.5 m along it, scaled to 0.4 - and in the troll's fist that came
|
|
// out huge and pointing the wrong way. The troll's log weapon carries a model made for
|
|
// exactly this bone, and hanging it the way VisEquipment.AttachItem does (zero offset,
|
|
// no rotation, its own scale) puts it where vanilla puts it.
|
|
Profile log = Get(AttackKind.LogSwingH) ?? Get(AttackKind.LogSwingV);
|
|
GameObject source = log?.Attach;
|
|
if (source == null) return;
|
|
|
|
// An item's "attach" child is stored INACTIVE in its prefab; VisEquipment.AttachItem
|
|
// switches it on after the Instantiate. Copied as it was, the log hung in the fist
|
|
// switched off - invisible, and it looked as if the Trol held nothing.
|
|
current = Object.Instantiate(source);
|
|
current.SetActive(true);
|
|
current.name = "TrolTrueFormLog";
|
|
foreach (Collider c in current.GetComponentsInChildren<Collider>(true)) Object.Destroy(c);
|
|
|
|
// Hung the way AttachItem hangs it: on the joint at zero, then the item's equipoffset.
|
|
current.transform.SetParent(hand, false);
|
|
current.transform.localPosition = Vector3.zero;
|
|
current.transform.localRotation = Quaternion.identity;
|
|
Transform offset = source.transform.parent != null ? source.transform.parent.Find("equipoffset") : null;
|
|
if (offset != null)
|
|
{
|
|
current.transform.localPosition += offset.position;
|
|
current.transform.localRotation *= offset.rotation;
|
|
}
|
|
|
|
// AttachItem keeps the attach at its own WORLD size, and a vanilla troll stands at scale 1.
|
|
// This one is worn smaller or bigger, so the log takes the costume's share on top. Once
|
|
// set, the hand carries it through the grow and shrink like any child.
|
|
float handScale = hand.lossyScale.x;
|
|
float costume = model.transform.localScale.x;
|
|
current.transform.localScale = handScale > 0.0001f
|
|
? source.transform.localScale * (costume / handScale)
|
|
: source.transform.localScale;
|
|
|
|
if (logged.Add("log/" + source.name))
|
|
{
|
|
Jotunn.Logger.LogInfo($"[Trol] True Form log '{log.Source}' in hand: hand scale {handScale:0.###}, " +
|
|
$"costume {costume:0.###}, offset {(offset != null ? "yes" : "no")}.");
|
|
}
|
|
}
|
|
|
|
// ─── Attacks ─────────────────────────────────────────────────────────
|
|
|
|
public static Profile Get(AttackKind kind)
|
|
{
|
|
EnsureProfiles();
|
|
profiles.TryGetValue(kind, out Profile p);
|
|
return p;
|
|
}
|
|
|
|
private static void EnsureProfiles()
|
|
{
|
|
if (profilesRead) return;
|
|
GameObject prefab = PrefabManager.Cache.GetPrefab<GameObject>(Creature);
|
|
Humanoid humanoid = prefab != null ? prefab.GetComponent<Humanoid>() : null;
|
|
if (humanoid == null) return;
|
|
profilesRead = true;
|
|
|
|
var weapons = new List<GameObject>();
|
|
if (humanoid.m_defaultItems != null) weapons.AddRange(humanoid.m_defaultItems);
|
|
if (humanoid.m_randomWeapon != null) weapons.AddRange(humanoid.m_randomWeapon);
|
|
if (humanoid.m_randomSets != null)
|
|
{
|
|
foreach (Humanoid.ItemSet set in humanoid.m_randomSets)
|
|
{
|
|
if (set?.m_items != null) weapons.AddRange(set.m_items);
|
|
}
|
|
}
|
|
|
|
foreach (GameObject weapon in weapons)
|
|
{
|
|
ItemDrop drop = weapon != null ? weapon.GetComponent<ItemDrop>() : null;
|
|
ItemDrop.ItemData.SharedData shared = drop?.m_itemData?.m_shared;
|
|
if (shared?.m_attack == null || string.IsNullOrEmpty(shared.m_attack.m_attackAnimation)) continue;
|
|
|
|
AttackKind? kind = Classify(weapon.name.ToLower(), shared);
|
|
if (kind == null || profiles.ContainsKey(kind.Value)) continue;
|
|
|
|
Attack a = shared.m_attack;
|
|
Profile p = new Profile
|
|
{
|
|
Source = weapon.name,
|
|
Trigger = a.m_attackAnimation,
|
|
Damage = shared.m_damages,
|
|
Type = a.m_attackType,
|
|
Range = a.m_attackRange,
|
|
Height = a.m_attackHeight,
|
|
Angle = a.m_attackAngle,
|
|
PushForce = shared.m_attackForce,
|
|
ToolTier = shared.m_toolTier,
|
|
Shared = shared,
|
|
Attach = weapon.transform.Find("attach")?.gameObject,
|
|
};
|
|
profiles[kind.Value] = p;
|
|
|
|
Jotunn.Logger.LogInfo($"[Trol] True Form {kind.Value} <- '{p.Source}': trigger '{p.Trigger}', {p.Type}, " +
|
|
$"range {p.Range:0.0}, blunt {p.Damage.m_blunt:0} slash {p.Damage.m_slash:0} " +
|
|
$"chop {p.Damage.m_chop:0} pickaxe {p.Damage.m_pickaxe:0}.");
|
|
}
|
|
|
|
if (!profiles.ContainsKey(AttackKind.Punch))
|
|
{
|
|
Jotunn.Logger.LogWarning($"[Trol] '{Creature}' carries no punch; True Form left click will do nothing.");
|
|
}
|
|
}
|
|
|
|
private static AttackKind? Classify(string name, ItemDrop.ItemData.SharedData shared)
|
|
{
|
|
if (name.Contains("throw") || shared.m_attack.m_attackProjectile != null) return AttackKind.Throw;
|
|
if (name.Contains("log"))
|
|
{
|
|
return name.EndsWith("_v") || name.Contains("vertical") ? AttackKind.LogSwingV : AttackKind.LogSwingH;
|
|
}
|
|
if (name.Contains("slam") || shared.m_attack.m_attackType == Attack.AttackType.Area) return AttackKind.Slam;
|
|
if (name.Contains("punch")) return AttackKind.Punch;
|
|
return null;
|
|
}
|
|
|
|
/// <summary>
|
|
/// The owner's side of a remote replay: records the trigger just fired, so
|
|
/// RemoteTrolTrueFormAnimator plays it on every other client's copy.
|
|
/// </summary>
|
|
public static void PublishAttackTrigger(Player player, string trigger)
|
|
{
|
|
ZNetView nview = player != null ? player.GetComponent<ZNetView>() : null;
|
|
if (nview == null || !nview.IsValid()) return;
|
|
|
|
attackSeq++;
|
|
nview.GetZDO().Set(AttackTriggerKey, trigger + "#" + attackSeq);
|
|
}
|
|
|
|
/// <summary>
|
|
/// The damage a troll attack deals for this player right now: the troll's own numbers, times
|
|
/// Troll Attack Damage, times the same random Clubs factor a club would get.
|
|
/// </summary>
|
|
public static HitData.DamageTypes DamageFor(Player player, Profile profile)
|
|
{
|
|
HitData.DamageTypes damage = profile.Damage.Clone();
|
|
float factor = TrolConfig.TrueFormTrollDamageShare.Value * player.GetRandomSkillFactor(Skills.SkillType.Clubs);
|
|
damage.Modify(factor);
|
|
return damage;
|
|
}
|
|
|
|
// ─── Native attack loop, shut while the costume is on ────────────────
|
|
|
|
/// <summary>
|
|
/// Holds the troll still through its own attack clips, the way vanilla roots a creature in
|
|
/// mid-swing. SkeletonRiseControlsPatch's arrangement: the move direction is the first
|
|
/// argument of SetControls, bound by position.
|
|
/// </summary>
|
|
[HarmonyPatch(typeof(Player), "SetControls")]
|
|
public static class Trol_TrueFormHoldStill_Patch
|
|
{
|
|
public static void Prefix(Player __instance, ref Vector3 __0, ref bool jump, ref bool crouch, ref bool dodge)
|
|
{
|
|
if (__instance != Player.m_localPlayer || !LocalActive || !LocalAttacking) return;
|
|
|
|
__0 = Vector3.zero;
|
|
jump = false;
|
|
crouch = false;
|
|
dodge = false;
|
|
}
|
|
}
|
|
|
|
[HarmonyPatch(typeof(Humanoid), "StartAttack")]
|
|
public static class Trol_TrueFormBlockNativeAttack_Patch
|
|
{
|
|
public static bool Prefix(Humanoid __instance)
|
|
{
|
|
return __instance != Player.m_localPlayer || !LocalActive;
|
|
}
|
|
}
|
|
|
|
/// <summary>Crossbow reload and draw live here; see Fenrir's BlockPlayerAttackInputPatch.</summary>
|
|
[HarmonyPatch(typeof(Player), "PlayerAttackInput")]
|
|
public static class Trol_TrueFormBlockAttackInput_Patch
|
|
{
|
|
public static bool Prefix(Player __instance)
|
|
{
|
|
return __instance != Player.m_localPlayer || !LocalActive;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// The troll's own clips call OnAttackTrigger at the moment a blow lands, and it arrives on
|
|
/// the player. It is the hit cue for TrolTrueFormBehavior, and it must go no further: let
|
|
/// through, it fires whatever attack the human still has in hand.
|
|
/// </summary>
|
|
[HarmonyPatch(typeof(Humanoid), nameof(Humanoid.OnAttackTrigger))]
|
|
public static class Trol_TrueFormAttackTrigger_Patch
|
|
{
|
|
public static bool Prefix(Humanoid __instance)
|
|
{
|
|
if (__instance != Player.m_localPlayer || !LocalActive) return true;
|
|
NotifyAttackTrigger();
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|