RacesOfValheim/JotunnModStub/RaceInput.cs
2026-09-12 10:42:01 +02:00

187 lines
9 KiB
C#

using System.Reflection;
using BepInEx.Configuration;
using HarmonyLib;
using UnityEngine;
namespace RacesOfValheim
{
/// <summary>
/// Gate for race ability input.
///
/// UnityEngine.Input reads the device directly, so abilities bound to keys or mouse buttons
/// kept firing while the map, the inventory, a chest, the chat or a menu had focus - dragging
/// an item inside a container also swung the transformed attack, for instance. Valheim runs
/// its own controls through Player.TakeInput, which reports false for exactly those states
/// (InventoryGui covers the backpack and chests alike), so mirror that instead of maintaining
/// a parallel list of GUI checks that would drift as the game changes.
///
/// ONE GUI THAT TakeInput DOES NOT COVER: the hammer's piece selection panel. Read off the IL,
/// TakeInput tests Chat, Console, TextInput, StoreGui, InventoryGui, Menu, TextViewer, the map,
/// free-fly and the barber - and nothing else. Vanilla does not need it there because build
/// input is handled separately in UpdatePlacement, but a mod ability reading the device
/// directly does: Skadi's cold spell is bound to middle mouse and kept casting while the build
/// menu was open. Hud.IsPieceSelectionVisible is static, public and null-safe on its own
/// instance, so it costs one call and no reflection.
/// </summary>
public static class RaceInput
{
// Not public on Player, hence the reflection; resolved once rather than per frame.
private static readonly MethodInfo TakeInputMethod = AccessTools.Method(typeof(Player), "TakeInput");
public static bool Allowed
{
get
{
Player player = Player.m_localPlayer;
if (player == null) return false;
// Checked before TakeInput, so it holds even on the fail-open path below.
if (Hud.IsPieceSelectionVisible()) return false;
// Fail open: if a game update ever renames the method, abilities stay usable
// rather than silently going dead.
if (TakeInputMethod == null) return true;
return (bool)TakeInputMethod.Invoke(player, null);
}
}
// Aswid/Skadi/Fenrir all borrow the native "gpower" Animator trigger to get its
// arms-raised cast gesture for their own transformations. The "gpower" clip carries a
// baked-in Animation Event that calls Player.ActivateGuardianPower() partway through -
// that fires no matter who requested the animation, so borrowing the trigger silently
// cast the player's real Guardian Power (and put it on cooldown) whenever it happened
// to be available. Races set this right before SetTrigger("gpower") to swallow that one
// call. Time-based rather than a plain latch, so a skipped/interrupted animation can't
// leave the real power blocked forever.
public static float SuppressGuardianPowerUntil = -1f;
public static void SuppressGuardianPowerBriefly(float seconds = 2f)
{
SuppressGuardianPowerUntil = Time.time + seconds;
}
/// <summary>
/// What KeyboardShortcut.IsDown() should have been for a game key.
///
/// BepInEx's own IsDown() ends in a check that no key outside the shortcut is being held
/// (ModifierKeyTest -> _modifierBlockKeyCodes.All(c => !GetKey(c) || allKeys.Contains(c))),
/// which is right for a config-menu hotkey and completely wrong for a game ability: it
/// only exempts the mouse buttons, so holding W - or any other movement key - silently
/// killed every bound ability in the mod, in every race, including the ones bound to mouse
/// buttons. Vanilla attacks kept working because they go through ZInput instead, which is
/// what made it look like the abilities specifically had broken.
///
/// This keeps the part that matters (main key down, every modifier held) and drops the
/// blocking rule, so an ability fires while the player is moving.
/// </summary>
public static bool IsDownIgnoringHeldKeys(this KeyboardShortcut shortcut)
{
if (ConsumePress(shortcut)) return true;
if (shortcut.MainKey == KeyCode.None) return false;
if (!Input.GetKeyDown(shortcut.MainKey)) return false;
foreach (KeyCode modifier in shortcut.Modifiers)
{
if (!Input.GetKey(modifier)) return false;
}
return true;
}
/// <summary>Held-down counterpart of <see cref="IsDownIgnoringHeldKeys"/>.</summary>
public static bool IsPressedIgnoringHeldKeys(this KeyboardShortcut shortcut)
{
if (shortcut.MainKey == KeyCode.None) return false;
if (!Input.GetKey(shortcut.MainKey)) return false;
foreach (KeyCode modifier in shortcut.Modifiers)
{
if (!Input.GetKey(modifier)) return false;
}
return true;
}
// A key press that came from somewhere other than the keyboard - the race group in the radial
// menu (RaceRadial). Held for a short window rather than one frame, because the radial closes
// with an animation and the race reading the key may not run on the very next frame; the
// first matching read takes it, so it fires once.
private const float PressWindow = 0.5f;
private static KeyboardShortcut pressed = KeyboardShortcut.Empty;
private static float pressedUntil = -1f;
public static void Press(KeyboardShortcut shortcut)
{
pressed = shortcut;
pressedUntil = Time.time + PressWindow;
}
/// <summary>True once if <paramref name="shortcut"/> was pressed through <see cref="Press"/>.
/// IsDownIgnoringHeldKeys already asks; the two readers still on BepInEx's own IsDown() ask
/// directly.</summary>
public static bool ConsumePress(KeyboardShortcut shortcut)
{
if (Time.time > pressedUntil) return false;
if (shortcut.MainKey == KeyCode.None || shortcut.MainKey != pressed.MainKey) return false;
if (!System.Linq.Enumerable.SequenceEqual(shortcut.Modifiers, pressed.Modifiers)) return false;
pressedUntil = -1f;
return true;
}
// Gamepad counterparts of the three mouse buttons, indexed like Input.GetMouseButton.
// Not a free choice: ZInput.ResetKBMButtons binds Attack to Mouse0, Block to Mouse1 and
// SecondaryAttack to Mouse2, so each form attack lands on the pad button vanilla already
// pairs with the same mouse button - and does whatever that button does in vanilla at the
// same time, exactly as the mouse already did. Going through ZInput rather than raw
// joystick buttons also follows the pad layout picked in the game settings.
private static readonly string[] PadAttackButtons = { "JoyAttack", "JoyBlock", "JoySecondaryAttack" };
/// <summary>
/// Transformed-form attack input: the mouse button, or its gamepad counterpart. Forms read
/// the device directly instead of going through Humanoid.StartAttack, so before this a
/// gamepad player had no way to attack in any of them.
/// </summary>
public static bool AttackDown(int mouseButton)
{
return Input.GetMouseButtonDown(mouseButton) || PadAttackDown(mouseButton);
}
/// <summary>Held-down counterpart of <see cref="AttackDown"/>.</summary>
public static bool AttackHeld(int mouseButton)
{
return Input.GetMouseButton(mouseButton) || PadAttackHeld(mouseButton);
}
/// <summary>The gamepad half of <see cref="AttackDown"/> alone, for attacks whose mouse
/// side is a rebindable KeyboardShortcut rather than a fixed button.</summary>
public static bool PadAttackDown(int mouseButton)
{
string button = PadButton(mouseButton);
return button != null && ZInput.GetButtonDown(button);
}
public static bool PadAttackHeld(int mouseButton)
{
string button = PadButton(mouseButton);
return button != null && ZInput.GetButton(button);
}
private static string PadButton(int mouseButton)
{
return mouseButton >= 0 && mouseButton < PadAttackButtons.Length ? PadAttackButtons[mouseButton] : null;
}
}
[HarmonyPatch(typeof(Player), "ActivateGuardianPower")]
public static class Player_ActivateGuardianPower_SuppressBorrowed_Patch
{
public static bool Prefix(Player __instance)
{
if (__instance != Player.m_localPlayer) return true;
if (Time.time > RaceInput.SuppressGuardianPowerUntil) return true;
RaceInput.SuppressGuardianPowerUntil = -1f; // one-shot: don't block real future casts
return false;
}
}
}