Project-M/Assets/_Project/Scripts/Client/Debug/DebugCommandSendSystem.cs

#if UNITY_EDITOR
using System.Collections.Generic;
using ProjectM.Simulation;
using Unity.Entities;
using Unity.NetCode;
using UnityEngine;

namespace ProjectM.Client
{
    /// <summary>
    /// EDITOR-ONLY client sender for dev-tool <see cref="DebugCommandRequest"/> RPCs. Mirrors
    /// <c>StorageOpSendSystem</c>: static convenience methods enqueue into a queue that this client
    /// <see cref="SystemBase"/> drains into request entities each tick (so it works from the DebugOverlay's IMGUI
    /// AND headless from execute_code). The statics are reset on play-enter so a fast-enter-playmode reload can't
    /// replay a stale queue. The wire type is unconditional; this system is #if UNITY_EDITOR (stripped from builds).
    /// </summary>
    [WorldSystemFilter(WorldSystemFilterFlags.ClientSimulation)]
    public partial class DebugCommandSendSystem : SystemBase
    {
        struct Pending { public byte Op; public int ArgA; public int ArgB; }

        static readonly List<Pending> s_Pending = new List<Pending>();

        /// <summary>Queue a raw dev command for the next client tick.</summary>
        public static void Send(byte op, int argA = 0, int argB = 0)
            => s_Pending.Add(new Pending { Op = op, ArgA = argA, ArgB = argB });

        // Convenience wrappers (overlay buttons + execute_code).
        public static void SpawnWave() => Send(DebugOp.SpawnWave);          // re-meant: force the next wave now
        public static void StopWaves() => Send(DebugOp.EndSiege);           // re-meant: quiet the arena (cull + delay waves)
        public static void ClearEnemies() => Send(DebugOp.ClearEnemies);
        public static void GrantResource(byte itemId, int count) => Send(DebugOp.GrantResource, itemId, count);
        public static void GrantUpgrade() => Send(DebugOp.GrantUpgrade);
        public static void Teleport(byte region) => Send(DebugOp.Teleport, region);
        public static void ToggleGod() => Send(DebugOp.ToggleGod);
        public static void Heal() => Send(DebugOp.Heal);
        public static void Kill() => Send(DebugOp.KillPlayer);
        /// <summary>Set the <see cref="ProjectM.Simulation.TuningKnob"/> knob to value (server-applied, x1000 fixed-point; MC-0).</summary>
        public static void SetTuning(byte knob, float value) => Send(DebugOp.SetTuning, knob, Mathf.RoundToInt(value * 1000f));
        /// <summary>Swap the sender's class to <paramref name="classId"/> (a <see cref="ProjectM.Simulation.FrameKind"/> byte); server-authoritative (class-switch dev tool).</summary>
        public static void SetClass(byte classId) => Send(DebugOp.SetClass, classId);
        public static void SetBathynaut() => SetClass(ClassTraits.BathynautFrame);
        public static void SetHarpooner() => SetClass(ClassTraits.HarpoonerFrame);
        /// <summary>GYM: spawn enemy KIND (a <see cref="ProjectM.Simulation.GymEnemyKind"/> byte) near the sender, count times.</summary>
        public static void SpawnEnemy(byte kind, int count = 1) => Send(DebugOp.SpawnEnemy, kind, count);


        [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.SubsystemRegistration)]
        static void ResetOnEnterPlayMode() => s_Pending.Clear();

        protected override void OnUpdate()
        {
            if (s_Pending.Count == 0)
                return;
            if (!SystemAPI.TryGetSingletonEntity<NetworkId>(out var connection))
                return; // not connected yet — hold the queue

            var em = EntityManager;
            for (int i = 0; i < s_Pending.Count; i++)
            {
                var p = s_Pending[i];
                var req = em.CreateEntity();
                em.AddComponentData(req, new DebugCommandRequest { Op = p.Op, ArgA = p.ArgA, ArgB = p.ArgB });
                em.AddComponentData(req, new SendRpcCommandRequest { TargetConnection = connection });
            }
            s_Pending.Clear();
        }
    }
}
#endif