s&box Spawner System: ISpawner Interface with Preview and Undo

public interface ISpawner
{
    string DisplayName { get; }      // UI label
    string Icon { get; }             // Cloud thumbnail path
    string Data { get; }             // Serialized spawn data
    BBox Bounds { get; }             // Preview bounds
    bool IsReady { get; }            // Ready to spawn?
    
    void DrawPreview(Transform t, Material m);
    Task<List<GameObject>> Spawn(Transform t, Player player);
}

// PropSpawner - Spawn models
public class PropSpawner : ISpawner
{
    public PropSpawner(string modelPath) { Data = modelPath; }
    public async Task<List<GameObject>> Spawn(Transform t, Player p)
    {
        var go = GameObject.Clone(Data, new CloneConfig { Transform = t });
        Ownable.Set(go, p?.Network.Owner);
        go.NetworkSpawn();
        return new List<GameObject> { go };
    }
}

// EntitySpawner - Spawn entity prefabs
public class EntitySpawner : ISpawner
{
    public EntitySpawner(string prefabPath) { Data = prefabPath; }
}

// DuplicatorSpawner - Paste saved contraptions
public class DuplicatorSpawner : ISpawner
{
    public static DuplicatorSpawner FromJson(string json, string title, string icon);
}

public partial class SpawnerWeapon : ScreenWeapon, IToolInfo
{
    // Synced payload - reconstructs ISpawner on all clients
    [Sync(SyncFlags.FromHost), Change(nameof(OnPayloadDataChanged))]
    public string SpawnerData { get; set; }
    
    public ISpawner Spawner { get; private set; }
    
    // Called when SpawnerData changes on any client
    private void OnPayloadDataChanged()
    {
        Spawner = DeserializeSpawner(SpawnerData);
    }
    
    // Serialization pattern: "type:data"
    private static string SerializeSpawner(ISpawner s) => s switch
    {
        PropSpawner => $"prop:{s.Data}",
        EntitySpawner => $"entity:{s.Data}",
        DuplicatorSpawner => $"dupe:{s.Data}",
        _ => null
    };
}

private bool _isRotating;           // Holding Use key
private Rotation _rotationOffset; // Accumulated rotation
private bool _isSnapping;         // Holding Run key for 45° snap

void OnControl(Player player)
{
    _isRotating = Input.Down("use");
    _isSnapping = Input.Down("run");
    
    if (_isRotating)
    {
        var look = Input.AnalogLook;
        if (_isSnapping)
        {
            // Axis-lock: prefer larger movement direction
            if (MathF.Abs(look.yaw) > MathF.Abs(look.pitch)) look.pitch = 0;
            else look.yaw = 0;
        }
        _rotationOffset = Rotation.From(look) * _rotationOffset;
    }
    
    // Trace for placement
    var placement = Scene.Trace.Ray(player.EyeTransform.ForwardRay, 4096)
        .IgnoreGameObjectHierarchy(player.GameObject)
        .Run();
    
    if (placement.Hit && Spawner.IsReady && Input.Pressed("attack1"))
    {
        DoSpawn(GetSpawnTransform(placement, player));
    }
}

[Rpc.Host]
private async void DoSpawn(Transform transform)
{
    var spawnData = new Global.ISpawnEvents.SpawnData { Spawner, Transform, Player };
    Scene.RunEvent<Global.ISpawnEvents>(x => x.OnSpawn(spawnData));
    if (spawnData.Cancelled) return;
    
    var objects = await Spawner.Spawn(transform, player);
    
    if (objects?.Count > 0)
    {
        var undo = player.Undo.Create();
        undo.Name = $"Spawn {Spawner.DisplayName}";
        foreach (var go in objects) undo.Add(go);
    }
}