FREE UnsafeRecycler : 1.0.2 1.0.2

using System.Collections.Generic;
using UnityEngine;

namespace Oxide.Plugins
{
    [Info("UnsafeRecycler", "Bad Cop", "1.0.2")]
    [Description("Converts safe zone recyclers into normal recyclers.")]
    public class UnsafeRecycler : RustPlugin
    {
        private const string PermUse = "unsaferecycler.use";

        private readonly HashSet<Recycler> _recyclers = new HashSet<Recycler>();

        private readonly Dictionary<Recycler, bool> _changedRecyclers = new Dictionary<Recycler, bool>();

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

        private void OnServerInitialized()
        {
            int total = 0;
            int changed = 0;

            foreach (BaseNetworkable entity in BaseNetworkable.serverEntities)
            {
                Recycler recycler = entity as Recycler;
                if (recycler == null)
                    continue;

                total++;
                TrackRecycler(recycler);

                if (TryApplyUnsafeSettings(recycler))
                    changed++;
            }

            Puts($"Initialized {total} recycler(s). Changed {changed} safe-zone recycler(s) to radtown settings.");
        }

        private void OnEntitySpawned(Recycler recycler)
        {
            if (recycler == null)
                return;

            TrackRecycler(recycler);
            TryApplyUnsafeSettings(recycler);
        }

        private void OnEntityKill(Recycler recycler)
        {
            if (recycler == null)
                return;

            _recyclers.Remove(recycler);
            _changedRecyclers.Remove(recycler);
        }

        private void TrackRecycler(Recycler recycler)
        {
            if (recycler == null)
                return;

            _recyclers.Add(recycler);
        }

        private bool TryApplyUnsafeSettings(Recycler recycler)
        {
            if (recycler == null)
                return false;

            if (!recycler.HasFlag(BaseEntity.Flags.Reserved9))
                return false;

            if (!_changedRecyclers.ContainsKey(recycler))
                _changedRecyclers.Add(recycler, true);

            recycler.SetFlagLocal(BaseEntity.Flags.Reserved9, false, false);
            return true;
        }

        private int RestoreChangedRecyclers()
        {
            int restored = 0;

            if (_changedRecyclers.Count == 0)
                return restored;

            Recycler[] keys = new Recycler[_changedRecyclers.Count];
            _changedRecyclers.Keys.CopyTo(keys, 0);

            for (int i = 0; i < keys.Length; i++)
            {
                Recycler recycler = keys[i];
                if (recycler == null)
                    continue;

                bool originalValue;
                if (!_changedRecyclers.TryGetValue(recycler, out originalValue))
                    continue;

                recycler.SetFlagLocal(BaseEntity.Flags.Reserved9, originalValue, false);
                restored++;
            }

            _changedRecyclers.Clear();
            return restored;
        }

        [ConsoleCommand("unsaferecycler")]
        private void ForceRadtownRecyclers(ConsoleSystem.Arg arg)
        {
            if (!HasAccess(arg))
            {
                arg.ReplyWith("You do not have permission to use this command.");
                return;
            }

            int changed = 0;

            foreach (Recycler recycler in _recyclers)
            {
                if (recycler == null)
                    continue;

                if (TryApplyUnsafeSettings(recycler))
                    changed++;
            }

            arg.ReplyWith($"Changed {changed} recycler(s) to radtown settings.");
        }

        [ConsoleCommand("saferecycler")]
        private void RestoreSafeZoneRecyclers(ConsoleSystem.Arg arg)
        {
            if (!HasAccess(arg))
            {
                arg.ReplyWith("You do not have permission to use this command.");
                return;
            }

            int restored = RestoreChangedRecyclers();
            arg.ReplyWith($"Restored {restored} plugin-modified recycler(s) to their original settings.");
        }

        private bool HasAccess(ConsoleSystem.Arg arg)
        {
            if (arg == null)
                return false;

            if (arg.Connection == null)
                return true;

            BasePlayer player = arg.Player();
            if (player == null)
                return false;

            return permission.UserHasPermission(player.UserIDString, PermUse);
        }

        private void Unload()
        {
            int restored = RestoreChangedRecyclers();

            _recyclers.Clear();

            Puts($"Plugin unloaded. Restored {restored} plugin-modified recycler(s) to their original state.");
        }
    }
}