пиши на русском. У меня проблема, я не знаю как мне хранить реплеи рекордов.

у меня есть руты
Main
Bonus1-5

и еще стили стиль можно использовать любой на любом руте. Как мне сохронять реплеи так, желательно рекордов топ 1, я сохроняю щас через protobuf-net

Playback

using System.Text.Json;
using CounterStrikeSharp.API;
using CounterStrikeSharp.API.Core;
using CounterStrikeSharp.API.Modules.Utils;
using FabiusTimerApi;
using FabiusTimerApi.Enums;
using FabiusTimerApi.Models;
using ProtoBuf;

namespace FabiusTimer.Player.Replay;

public class Playback
{
    private readonly Plugin _plugin;
    private readonly FabiusTimerApi _api;
    public bool IsStarted { get; set; }

    private Replay _replay = new();

    public CCSPlayerController? Controller { get; set; }

    public int CurrentFrameTick { get; set; } = 0;
    public int FrameTickIncrement { get; set; } = 1;

    public Playback(Plugin plugin, FabiusTimerApi api)
    {
        _plugin = plugin;
        _api = api;

        foreach (var path in Directory.GetFiles(Path.Combine(_api.CoreConfigDirectory, "replay"), "*.replay"))
        {
            using var file = File.OpenRead(path);
            _replay = Serializer.Deserialize<Replay>(file);
        }

        plugin.RegisterListener<Listeners.OnTick>(OnTick);
    }

    public void SpawnBot()
    {
        Server.ExecuteCommand("sv_cheats 1");
        Server.ExecuteCommand("bot_kick");
        Server.ExecuteCommand("bot_quota_mode fill");
        Server.ExecuteCommand("bot_quota 1");
        Server.ExecuteCommand("bot_join_team CT");
        Server.ExecuteCommand("bot_add_ct");
        Server.ExecuteCommand("bot_stop 1");
        Server.ExecuteCommand("bot_controllable 0");
        Server.ExecuteCommand("sv_cheats 0");

        Server.NextFrame(() =>
        {
            foreach (var bot in Utilities.GetPlayers().Where(u => u.IsBot))
            {
                var botPawn = bot.PlayerPawn.Value;
                if (botPawn is null) continue;

                botPawn.Bot!.IsSleeping = true;
                botPawn.Bot!.AllowActive = false;

                bot.RemoveWeapons();

                Controller = bot;
            }
        });
    }

    public void Start()
    {
        IsStarted = true;
    }

    public void Stop()
    {
        IsStarted = false;
    }

    private void OnTick()
    {
        if (!IsStarted || Controller is null || !Controller.IsValid || !Controller.PawnIsAlive) return;

        var playerPawn = Controller.PlayerPawn.Value;
        if (playerPawn is null) return;

        var frames = _replay.Frames;
        if (frames.Count <= 0) return;

        foreach (var frame in frames)
        {
            var flags = (PlayerFlags)frame.Flags;
            playerPawn.MoveType = flags.HasFlag(PlayerFlags.FL_ONGROUND)
                ? MoveType_t.MOVETYPE_WALK
                : MoveType_t.MOVETYPE_OBSERVER;

            var movementService = playerPawn.MovementServices;
            if (movementService is not null)
            {
                var ccsMovementServices = new CCSPlayer_MovementServices(movementService.Handle);
                
                ccsMovementServices.DuckAmount = flags.HasFlag(PlayerFlags.FL_DUCKING) ? 1 : 0;


                movementService.Buttons.ButtonStates[0] = frame.Button;
            }
            //playerPawn.MoveType = frame.MoveType;

            playerPawn.Teleport(frame.Position, frame.Angle, frame.Velocity);
        }

        if (frames.Count <= CurrentFrameTick)
        {
            Stop();
        }
    }
}

Recorder

using System.Runtime.Serialization;
using System.Text.Json;
using CounterStrikeSharp.API;
using CounterStrikeSharp.API.Modules.Utils;
using FabiusTimer.Helpers;
using ProtoBuf;

namespace FabiusTimer.Player.Replay;

public class Recorder(TimerPlayer timerPlayer, FabiusTimerApi api)
{
    public List<Frame> Frames { get; } = [];

    private bool _isRecording;

    public void Start()
    {
        Frames.Clear();
        _isRecording = true;
    }

    public void Stop()
    {
        _isRecording = false;
    }

    public void Reset()
    {
        Stop();
        Frames.Clear();
    }

    public void Record()
    {
        var controller = timerPlayer.Controller;
        if (!_isRecording || timerPlayer.Data?.TimerStarted == false || controller is null) return;

        var playerPawn = controller.PlayerPawn.Value;
        if (playerPawn is null)
        {
            Reset();
            return;
        }

        var pos = playerPawn.AbsOrigin!;
        var ang = playerPawn.EyeAngles!;
        var vel = playerPawn.Velocity;

        Frames.Add(new Frame
        {
            Position = new FVector(pos.X, pos.Y, pos.Z),
            Angle = new FVector(ang.X, ang.Y, ang.Z),
            Velocity = new FVector(vel.X, vel.Y, vel.Z),
            Button = (ulong)controller.Buttons,
            Flags = playerPawn.Flags,
            MoveType = playerPawn.MoveType
        });
    }

    public void Serialize()
    {
        var map = Server.MapName;
        var name = timerPlayer.Controller!.PlayerName;
        var style = timerPlayer.CurrentStyleName;
        var route = timerPlayer.Route;
        
        var replay = new Replay
        {
            PlayerName = name,
            Style = style,
            Route = route,
            Frames = Frames,
        };
        
        var path = Path.Combine(api.CoreConfigDirectory, $"replay/{map}/");
        
        if (!Directory.Exists(path))
            Directory.CreateDirectory(path);

        using var file = File.Create(Path.Combine(path, $"{name}-{style}-{route}.replay"));
        Serializer.Serialize(file, replay);

        // var replayFrames = JsonSerializer.Serialize(replay,
        //     new JsonSerializerOptions
        //     {
        //         WriteIndented = false,
        //         Converters =
        //         {
        //             new VectorConverter(),
        //             new QAngleConverter()
        //         }
        //     });
        //
        // var path = Path.Combine(api.CoreConfigDirectory, $"replay/{map}/");
        //
        // if (!Directory.Exists(path))
        //     Directory.CreateDirectory(path);
        //
        // File.WriteAllText(path, replayFrames);
    }
}

мне нужно их сохронять и загружать когда стартует карта, как это мне сделать?