Luis Gonzalez
86 lines
4.1 KiB
C#
86 lines
4.1 KiB
C#
#if UNITY_EDITOR
|
|
using ProjectM.Simulation;
|
|
using Unity.Entities;
|
|
using Unity.Mathematics;
|
|
using Unity.NetCode;
|
|
|
|
namespace ProjectM.Client
|
|
{
|
|
/// <summary>
|
|
/// EDITOR-ONLY validation hook for driving the local player's <see cref="PlayerInput"/> without a
|
|
/// real input device or a focused Game view. The Unity Input System ignores injected/real device
|
|
/// input while the Game view is unfocused, which makes headless (MCP <c>execute_code</c>) or
|
|
/// automated fire/move validation impossible through <see cref="PlayerInputGatherSystem"/> alone.
|
|
/// <para>
|
|
/// This system runs in <see cref="GhostInputSystemGroup"/> immediately AFTER the real gather and,
|
|
/// when <see cref="Active"/> is set, overwrites the locally-owned player's input from static fields
|
|
/// you can poke from a debugger / <c>execute_code</c> / an editor button. Because it writes the same
|
|
/// <see cref="PlayerInput"/> the gather does, it drives the authentic command → prediction →
|
|
/// AbilityFireSystem pipeline (not a shortcut), so it validates the real fire/move/auto-target path.
|
|
/// </para>
|
|
/// <para>
|
|
/// Entirely wrapped in <c>#if UNITY_EDITOR</c>: it does not exist in player builds. Pair with
|
|
/// <c>Application.runInBackground = true</c> so the unfocused editor keeps ticking. Usage from
|
|
/// <c>execute_code</c>: <c>ProjectM.Client.DebugInputInjectionSystem.Fire();</c> (one shot),
|
|
/// <c>...SetMove(0f, 1f);</c> (hold a move heading), <c>...SetAim(1f, 0f);</c>, <c>...Stop();</c>.
|
|
/// </para>
|
|
/// </summary>
|
|
[UpdateInGroup(typeof(GhostInputSystemGroup))]
|
|
[UpdateAfter(typeof(PlayerInputGatherSystem))]
|
|
[WorldSystemFilter(WorldSystemFilterFlags.ClientSimulation)]
|
|
public partial class DebugInputInjectionSystem : SystemBase
|
|
{
|
|
/// <summary>While true, this system overrides the local player's gathered input each frame.</summary>
|
|
public static bool Active;
|
|
|
|
/// <summary>Movement heading applied to PlayerInput.Move while <see cref="Active"/>.</summary>
|
|
public static float2 Move;
|
|
|
|
/// <summary>Aim vector applied to PlayerInput.Aim while <see cref="Active"/> (zero = face movement).</summary>
|
|
public static float2 Aim;
|
|
|
|
/// <summary>Frames remaining to hold the Fire event. Each held frame raises Fire.Set(); holding
|
|
/// across several frames spans multiple network ticks so the one-shot event reliably reaches the
|
|
/// command buffer (a single-frame pulse can be lost across the frame→tick boundary). 0 = idle.</summary>
|
|
public static int FireFrames;
|
|
|
|
/// <summary>Convenience: hold Fire for the next <paramref name="frames"/> frames (also enables
|
|
/// override). The ability cooldown still gates how many shots actually result.</summary>
|
|
public static void Fire(int frames = 10) { Active = true; FireFrames = math.max(FireFrames, frames); }
|
|
|
|
/// <summary>Convenience: hold a planar move heading (also enables override).</summary>
|
|
public static void SetMove(float x, float z) { Active = true; Move = new float2(x, z); }
|
|
|
|
/// <summary>Convenience: hold an aim direction (also enables override).</summary>
|
|
public static void SetAim(float x, float z) { Active = true; Aim = new float2(x, z); }
|
|
|
|
/// <summary>Convenience: stop overriding and clear all injected input.</summary>
|
|
public static void Stop() { Active = false; Move = default; Aim = default; FireFrames = 0; }
|
|
|
|
protected override void OnCreate()
|
|
{
|
|
RequireForUpdate<PlayerInput>();
|
|
}
|
|
|
|
protected override void OnUpdate()
|
|
{
|
|
if (!Active)
|
|
return;
|
|
|
|
bool fire = FireFrames > 0;
|
|
if (FireFrames > 0) FireFrames--;
|
|
float2 move = Move;
|
|
float2 aim = Aim;
|
|
|
|
foreach (var input in SystemAPI.Query<RefRW<PlayerInput>>().WithAll<GhostOwnerIsLocal>())
|
|
{
|
|
input.ValueRW.Move = move;
|
|
input.ValueRW.Aim = aim;
|
|
if (fire)
|
|
input.ValueRW.Fire.Set();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif
|