187 lines
9 KiB
C#
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;
|
|
}
|
|
}
|
|
}
|