David Sula's Lavish Atelier

{
    public class AmmoCounter
    {

        private static readonly Dictionary<Player, Hint> PlayerHint = new();
        private static readonly Dictionary<Player, string> PlayerAmmo = new();

        public static void OnJoined(PlayerJoinedEventArgs ev) 
        {
            Hint hint = new()
            {
                YCoordinate = 1056,
                XCoordinate = 725,
                Alignment = HintAlignment.Center,
                FontSize = 20,
                Id = "ammo",
            };

            // Store the hint in the dictionary
            PlayerHint[ev.Player] = hint;
            Logger.Debug("Created hint for" + ev.Player);

            PlayerDisplay playerDisplay = PlayerDisplay.Get(ev.Player);
            playerDisplay.AddHint(hint);
            
        }

        public static void OnRoundEnded(RoundEndedEventArgs ev)
        {
            Logger.Debug("Clearing all player hints.");
            PlayerHint.Clear();
            PlayerAmmo.Clear();
        }

        public static void OnShooting(PlayerShootingWeaponEventArgs ev)
        {

            if (Config.Guns.ContainsKey(ev.FirearmItem.Type)) 
            {
                PlayerHint[ev.Player].Text = (Config.Guns[ev.FirearmItem.Type] + ": " + (ev.FirearmItem.Base.GetTotalStoredAmmo() - 1) + "/" + ev.FirearmItem.Base.GetTotalMaxAmmo());
            }
        
        }

        public static void OnReloaded(PlayerReloadedWeaponEventArgs ev)
        {
            if (Config.Guns.ContainsKey(ev.FirearmItem.Type))
            {
                PlayerHint[ev.Player].Text = (Config.Guns[ev.FirearmItem.Type] + ": " + (ev.FirearmItem.Base.GetTotalStoredAmmo() - 1) + "/" + ev.FirearmItem.Base.GetTotalMaxAmmo());
            }
        }
        public static void OnChangedItem(PlayerChangedItemEventArgs ev)
        {
            if (ev.NewItem == null || !Config.Guns.ContainsKey(ev.NewItem.Type))
            {
                {
                    PlayerHint[ev.Player].Text = "";
                    PlayerAmmo[ev.Player] = null;
                }
                Logger.Debug("return");
                return;
            }

            if (Config.Guns.ContainsKey(ev.NewItem.Type))
            {
                Logger.Debug("contains");

                PlayerHint[ev.Player].Text = Config.Guns[ev.NewItem.Type];
            }
        }

    }
}

// Little note for this, when I started working on the Sula's Custom Classes plugin, I switched over to Jetbrains Rider and ditched Visual Studio as Rider is much better (at least for SCP:SL plugins). 
// I did use AI to program the coroutine. As I previously stated, whilst you can't rely on AI, it is also a good shortcut for speeding up simple specific tasks. With JetBrains Rider's built-in AI, you can write your base code and then ask the AI for minor implementations - it can view the code you already have and understand where to go from there. I know how to program a coroutine myself, I just used AI to speed up the process. When using tools like this, you have to proof-read the code and make your own amendments after.

{
    public class Ekko
    {
        public static readonly Dictionary<Player, DateTime> EkkoCooldown = new Dictionary<Player, DateTime>();

        public static readonly HashSet<Player> HasUsedAbility = new HashSet<Player>();

        public static float InitialCooldownSeconds = 10f;
        public static float StandardCooldownSeconds = 90f;

        public class PlayerState
        {
            public Vector3 Position { get; set; }
            public float Health { get; set; }

        }

        public static readonly Dictionary<Player, Queue<PlayerState>> StateHistory =
            new Dictionary<Player, Queue<PlayerState>>();

        private const int MaxHistoryLength = 32; // 5 seconds of history

        private static readonly Dictionary<Player, CoroutineHandle> PlayerCoroutines =
            new Dictionary<Player, CoroutineHandle>();

        // Handles activation of the Archangel's special ability
        public static void ActivateEkkoAbility(Player player)
        {
            if (EkkoCooldown.TryGetValue(player, out var lastUseTime))
            {
                var currentCooldown =
                    HasUsedAbility.Contains(player) ? StandardCooldownSeconds : InitialCooldownSeconds;

                var elapsed = (DateTime.Now - lastUseTime).TotalSeconds;
                if (elapsed < currentCooldown)
                {
                    player.SendHint(
                        $"<color=#FF4500><b>Ability is on cooldown. Time remaining: </b></color><color=#FFD700>{currentCooldown - elapsed:F1}</color> <color=#87CEEB>seconds</color>");
                    return;
                }
            }
            
            if (player.GetEffect<PocketCorroding>().IsEnabled)
            {
                player.SendHint("<color=#FF4500><b>Cannot use ability while in the pocket dimension!</b></color>");
                return;
            }

            
            if (!HasUsedAbility.Contains(player))
            {
                HasUsedAbility.Add(player);
            }

            EkkoAbilityAudio(player);

            if (StateHistory.TryGetValue(player, out var history) && history.Count > 0)
            {
                // Start the gradual rewind coroutine
                Timing.RunCoroutine(RewindPlayerHistory(player, history));
            }

            EkkoCooldown[player] = DateTime.Now;
        }

        private static IEnumerator<float> RewindPlayerHistory(Player player, Queue<PlayerState> history)
        {
            if (history.Count == 0)
                yield break;

            player.IsGodModeEnabled = true;
            player.EnableEffect<Fade>(150, 0f);
            player.EnableEffect<Blindness>(50, 0f);

            // Convert queue to list to access states in reverse order
            List<PlayerState> states = new List<PlayerState>(history);

            // Calculate time between each state transition
            float totalDuration = 0.3f; // 1 second total
            float timePerState = totalDuration / states.Count;

            // Go through states from newest to oldest (reverse order)
            for (int i = states.Count - 1; i >= 0; i--)
            {
                PlayerState state = states[i];
                player.Position = state.Position;
                player.Health = state.Health;

                // Wait before moving to next state (except on the last one)
                if (i > 0)
                {
                    yield return Timing.WaitForSeconds(timePerState);
                }
            }

            player.IsGodModeEnabled = false;
            player.DisableEffect<Fade>();
            player.DisableEffect<Blindness>();

        }

        // Handles initialization when a Juggernaut role is assigned to a player
        public static void EkkoRoleAdded(Player player, CustomRoleBaseInfo roleInfo)
        {
            if (player == null || roleInfo == null)
                return;

            if (roleInfo.Rolename != "Ekko")
                return;

            EkkoCooldown[player] = DateTime.Now;

            HasUsedAbility.Remove(player);

            // Initialize state history for this player
            if (!StateHistory.ContainsKey(player))
            {
                StateHistory[player] = new Queue<PlayerState>();
            }
            else
            {
                StateHistory[player].Clear();
            }

            // Start tracking the player's position and health

            // Kill existing coroutine if running
            if (PlayerCoroutines.TryGetValue(player, out var existingHandle))
            {
                Timing.KillCoroutines(existingHandle);
            }

            // Start tracking the player's position and health
            PlayerCoroutines[player] = Timing.RunCoroutine(PastCheck(player));
        }
    
        public static void EkkoAbilityAudio(Player player)
        {
            AudioPlayer audioPlayer = AudioPlayer.CreateOrGet($"Player {player.Nickname}", onIntialCreation: (p) =>
            {
                // Attach created audio player to player.
                p.transform.parent = player.GameObject.transform;

                // This created speaker will be in 3D space.
                Speaker speaker = p.AddSpeaker("Main", isSpatial: true, volume: 1.5F, minDistance: 5f, maxDistance: 15f);

                // Attach created speaker to player.
                speaker.transform.parent = player.GameObject.transform;

                // Set local positino to zero to make sure that speaker is in player.
                speaker.transform.localPosition = Vector3.zero;
            });

            audioPlayer.AddClip("Ekko");
        }
        
        public static IEnumerator<float> PastCheck(Player player)
        {
            while (player.IsOnline)
            {
                // Log position and health here
                if (!StateHistory.ContainsKey(player))
                {
                    StateHistory[player] = new Queue<PlayerState>();
                }
                
                var history = StateHistory[player];
                
                // Add current state (position and health) to history
                history.Enqueue(new PlayerState
                {
                    Position = player.Position,
                    Health = player.Health
                });
                
                // Keep only the last 5 states (5 seconds of history)
                if (history.Count > MaxHistoryLength)
                {
                    history.Dequeue();
                }
                
                yield return Timing.WaitForSeconds(0.25f);
            }
            
            // Cleanup when player goes offline
            if (StateHistory.ContainsKey(player))
            {
                StateHistory.Remove(player);
            }
        }

        public static void OnDying(PlayerDyingEventArgs ev)
        {
            var player = ev.Player;

            if (SCREvents.TryGetCustomRole(player, out var customRoleInfo))
            {
                if (customRoleInfo.Rolename == "Ekko")
                {
                    if (EkkoCooldown.TryGetValue(player, out var lastUseTime))
                    {
                        var currentCooldown = HasUsedAbility.Contains(player) ? StandardCooldownSeconds : InitialCooldownSeconds;

                        var elapsed = (DateTime.Now - lastUseTime).TotalSeconds;
                        if (elapsed > currentCooldown)
                        {
                            if (!player.GetEffect<PocketCorroding>().IsEnabled)
                            {
                                ev.IsAllowed = false;
                                ActivateEkkoAbility(player); 
                            }
                        }
                        else
                        {
                            ev.IsAllowed = true;
                            if (PlayerCoroutines.TryGetValue(player, out var handle))
                            {
                                Timing.KillCoroutines(handle);
                                PlayerCoroutines.Remove(player);
                            }
            
                            // Clear state history
                            if (StateHistory.ContainsKey(player))
                            {
                                StateHistory.Remove(player);
                            }
                        }
                    }
                }
            }
        }
    }
}