FREE xNoBleeding : 1.1.1 1.1.1

using System.Collections.Generic;

namespace Oxide.Plugins
{
    [Info("xNoBleeding", "xNullPointer95", "1.1.1")]
    [Description("Discord: https://discord.gg/rGm7VS5ERc")]
    public class xNoBleeding : RustPlugin
    {
        const string permNoBleeding = "xnobleeding.use";

        readonly Dictionary<ulong, float> _originalBleedMax = new Dictionary<ulong, float>();

        void Init()
        {
            permission.RegisterPermission(permNoBleeding, this);
        }

        void OnServerInitialized()
        {
            RefreshAllPermissionCache();
        }

        void OnUserPermissionGranted(string id, string permName)
        {
            if (permName != permNoBleeding) return;
            if (ulong.TryParse(id, out var userId))
            {
                var player = FindConnectedPlayer(userId);
                if (player != null)
                {
                    ApplyNoBleeding(player);
                }
            }
        }

        void OnUserPermissionRevoked(string id, string permName)
        {
            if (permName != permNoBleeding) return;
            if (ulong.TryParse(id, out var userId))
            {
                var player = FindConnectedPlayer(userId);
                if (player != null)
                {
                    RestoreBleeding(player);
                }
            }
        }

        void OnGroupPermissionGranted(string groupName, string permName)
        {
            if (permName != permNoBleeding) return;
            RefreshAllPermissionCache();
        }

        void OnGroupPermissionRevoked(string groupName, string permName)
        {
            if (permName != permNoBleeding) return;
            RefreshAllPermissionCache();
        }

        void OnPlayerConnected(BasePlayer player)
        {
            if (player == null) return;

            if (permission.UserHasPermission(player.UserIDString, permNoBleeding))
            {
                ApplyNoBleeding(player);
            }
            else
            {
                RestoreBleeding(player);
            }
        }

        void OnPlayerDisconnected(BasePlayer player)
        {
            if (player == null) return;
            RestoreBleeding(player);
        }

        void Unload()
        {
            foreach (var player in BasePlayer.activePlayerList)
            {
                if (player == null) continue;
                RestoreBleeding(player);
            }
        }

        BasePlayer FindConnectedPlayer(ulong userId)
        {
            foreach (var player in BasePlayer.activePlayerList)
            {
                if (player != null && player.userID == userId)
                {
                    return player;
                }
            }

            return null;
        }

        void ApplyNoBleeding(BasePlayer player)
        {
            if (player == null || !player.IsConnected) return;

            if (!_originalBleedMax.ContainsKey(player.userID))
            {
                _originalBleedMax[player.userID] = player.metabolism.bleeding.max;
            }

            bool changed = false;
            if (player.metabolism.bleeding.max != 0f)
            {
                player.metabolism.bleeding.max = 0f;
                changed = true;
            }

            if (player.metabolism.bleeding.value != 0f)
            {
                player.metabolism.bleeding.value = 0f;
                changed = true;
            }

            if (changed)
            {
                player.metabolism.SendChanges();
            }
        }

        void RestoreBleeding(BasePlayer player)
        {
            if (player == null) return;

            bool changed = false;
            if (_originalBleedMax.TryGetValue(player.userID, out var originalMax))
            {
                if (player.metabolism.bleeding.max != originalMax)
                {
                    player.metabolism.bleeding.max = originalMax;
                    changed = true;
                }

                _originalBleedMax.Remove(player.userID);
            }

            if (changed && player.IsConnected)
            {
                player.metabolism.SendChanges();
            }
        }

        void RefreshAllPermissionCache()
        {
            foreach (var player in BasePlayer.activePlayerList)
            {
                if (player == null) continue;

                if (permission.UserHasPermission(player.UserIDString, permNoBleeding))
                {
                    ApplyNoBleeding(player);
                }
                else
                {
                    RestoreBleeding(player);
                }
            }
        }
    }
}