FREE PowerlessTurrets : 2.4.8 2.4.8

using System.Collections.Generic;
using Newtonsoft.Json;
using Oxide.Core;
using UnityEngine;
using System.Linq;

namespace Oxide.Plugins
{
    [Info("Powerless Turrets", "August", "2.4.8")]
    [Description("Allows turrets to operate without electricity.")]
    
    class PowerlessTurrets : RustPlugin
    {
        #region Initialization
        #region Config
        private Configuration _config;
        private Data _data;
        private List<AutoTurret> turrets = new List<AutoTurret>();

        protected override void LoadDefaultConfig()
        {
            Config.WriteObject(new Configuration(), true);
        }
        private class Data
        {
            public Data()
            {
                OnlineTurrets = new List<uint>();
            }
            public List<uint> OnlineTurrets;
        }
        private class Configuration
        {
            [JsonProperty("Can SAM Sites operate without power?")]
            public bool IsEnabled { get; set; } = true;

            [JsonProperty("Maximum distance players can turn on/off turrets")]
            public float MaxDistance { get; set; } = 5f;

            [JsonProperty("Command to power autoturrets on/off")]
            public string Command { get; set; } = "turret";
        }
        private void SaveConfig()
        {
            Config.WriteObject(_config, true);
        }
        
        #endregion

        private const string Perm = "powerlessturrets.use";
        private const string PermManage = "powerlessturrets.manage";
        
        void Init()
        {
            try
            {
                _data = Interface.Oxide.DataFileSystem.ReadObject<Data>(Name);
            }
            catch { }

            if (_data == null) _data = new Data();

            _config = Config.ReadObject<Configuration>();

            permission.RegisterPermission(PermManage, this);
            permission.RegisterPermission(Perm, this);

            cmd.AddChatCommand(_config.Command, this, "TurretCommand");
        }

        void OnServerInitialized()
        {
            if (_config.IsEnabled)
            {
                Subscribe(nameof(OnEntitySpawned));
                ChangePower(25);
            }
            if (_data.OnlineTurrets.Count > 0)
            {
                foreach (AutoTurret turret in BaseNetworkable.serverEntities.OfType<AutoTurret>())
                {
                    if (_data.OnlineTurrets.Contains(turret.net.ID))
                        turret.InitiateStartup();
                }
            }
        }
        
        protected override void LoadDefaultMessages()
        {
            // English
            lang.RegisterMessages(new Dictionary<string, string> {
                ["Enabled"] = "Sam sites now operate without power",
                ["Disabled"] = "Sam sites now require power to operate.",
                
                ["NoPermission"] = "Error: No Permission",
                ["Syntax"] = "Error: Syntax",
                
                ["InvalidEntity"] = "This is not a valid entity! (Are you too far?)"
            }, this);
        }
        #endregion
        
        #region Commands
        
        private void TurretCommand(BasePlayer player, string cmd, string[] args)
        {
            if (!permission.UserHasPermission(player.UserIDString, Perm))
            {
                player.ChatMessage(Lang("NoPermission", player.UserIDString));
                return;
            }

            RaycastHit ray;

            if (!Physics.Raycast(player.eyes.HeadRay(), out ray, _config.MaxDistance))
            {
                player.ChatMessage(Lang("InvalidEntity", player.UserIDString));
                return;
            }

            AutoTurret ent = ray.GetEntity() as AutoTurret;

            if (ent == null)
            {
                player.ChatMessage(Lang("InvalidEntity", player.UserIDString));
                return;
            }
            
            if (!ent.IsAuthed(player))
            {
                player.ChatMessage(Lang("NoPermission", player.UserIDString));
                return;
            }
            UpdateTurret(ent);
        }
        void OnEntitySpawned(SamSite sam)
        {
            sam.UpdateHasPower(25, 1);
        }
        
        [ChatCommand("sams")]
        void PowerlessTurretsCommand(BasePlayer player, string cmd, string[] args)
        {
            if (!permission.UserHasPermission(player.UserIDString, PermManage))
            {
                player.ChatMessage(Lang("NoPermission", player.UserIDString));
                return;
            }

            if (args.Length != 1)
            {
                player.ChatMessage(Lang("Syntax", player.UserIDString));
                return;
            }

            if (args[0].ToLower() == "toggle")
            {
                ToggleSams(player);
            }
            else
            {
                player.ChatMessage(Lang("Syntax", player.UserIDString));
            }
            
        }
        #endregion
        
        #region Methods and Unload
        
        void ChangePower(int amt)
        {
            foreach (var sam in BaseNetworkable.serverEntities.OfType<SamSite>())
            {
                sam.UpdateHasPower(amt, 1);
            }
        }
        void ToggleSams(BasePlayer player)
        {
            if (_config.IsEnabled == false)
            {
                Subscribe(nameof(OnEntitySpawned));
                
                ChangePower(25);
                
                player.ChatMessage(Lang("Enabled", player.UserIDString));
            }
            else
            {
                Unsubscribe(nameof(OnEntitySpawned));

                ChangePower(0);
                
                player.ChatMessage(Lang("Disabled", player.UserIDString));
            }
            _config.IsEnabled = !_config.IsEnabled;
            SaveConfig();
        }
        private void UpdateTurret(AutoTurret turret)
        {
            if (!turret.IsOnline())
            {
                turret.InitiateStartup();
                if (!_data.OnlineTurrets.Contains(turret.net.ID))
                {
                    _data.OnlineTurrets.Add(turret.net.ID);
                }
            }
            else
            {
                turret.InitiateShutdown();
                if (_data.OnlineTurrets.Contains(turret.net.ID))
                {
                    _data.OnlineTurrets.Remove(turret.net.ID);
                }
            }
        }
        
        object OnTurretShutdown(AutoTurret turret)
        {
            if (_data.OnlineTurrets.Contains(turret.net.ID))
                _data.OnlineTurrets.Remove(turret.net.ID);
                
            return null;
        }

        private string Lang(string key, string id = null, params object[] args) => string.Format(lang.GetMessage(key, this, id), args);
        private void SaveData() => Interface.Oxide.DataFileSystem.WriteObject(Name, _data);
        private void OnServerSave() => timer.Once(5f, () => SaveData());

        void Unload()
        {
            SaveData();
        }

        void OnServerShutdown() => SaveConfig();
        
        #endregion
    }
}