OnPowergridStageChange

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

namespace Oxide.Plugins
{
    [Info("Powergrid Stage Announcer", "RustPluginGenerator", "1.0.0")]
    [Description("Announces power grid stage changes in chat and throttles repeated messages")]
    public class PowergridStageAnnouncer : RustPlugin
    {
        private const string PermAnnounce = "powergridstageannouncer.announce";

        private PluginConfig config;
        private readonly Dictionary<ulong, int> lastStage = new Dictionary<ulong, int>();
        private readonly Dictionary<ulong, float> lastAnnounce = new Dictionary<ulong, float>();

        private class PluginConfig
        {
            [JsonProperty("Announce upgrades")]
            public bool AnnounceUpgrades { get; set; } = true;

            [JsonProperty("Announce downgrades")]
            public bool AnnounceDowngrades { get; set; } = true;

            [JsonProperty("Minimum seconds between messages per grid")]
            public float CooldownSeconds { get; set; } = 30f;
        }

        protected override void LoadDefaultConfig() => config = new PluginConfig();

        protected override void LoadConfig()
        {
            base.LoadConfig();
            try
            {
                config = Config.ReadObject<PluginConfig>();
                if (config == null) throw new Exception();
            }
            catch
            {
                PrintWarning("Configuration file is invalid, using defaults");
                LoadDefaultConfig();
            }
            SaveConfig();
        }

        protected override void SaveConfig() => Config.WriteObject(config);

        protected override void LoadDefaultMessages()
        {
            lang.RegisterMessages(new Dictionary<string, string>
            {
                ["Upgrade"] = "Power grid stage increased to {0}.",
                ["Downgrade"] = "Power grid stage dropped to {0}."
            }, this);
        }

        private string Msg(string key, string userId = null, params object[] args) => string.Format(lang.GetMessage(key, this, userId), args);

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

        private object OnPowergridStageChange(PowergridManager powergridManager, int stage)
        {
            if (powergridManager == null || !config.AnnounceUpgrades && !config.AnnounceDowngrades) return null;

            ulong gridId = powergridManager.net != null ? powergridManager.net.ID.Value : 0UL;
            int oldStage;
            if (!lastStage.TryGetValue(gridId, out oldStage))
            {
                lastStage[gridId] = stage;
                return null;
            }

            if (oldStage == stage) return null;
            lastStage[gridId] = stage;

            bool upgrade = stage > oldStage;
            if (upgrade && !config.AnnounceUpgrades) return null;
            if (!upgrade && !config.AnnounceDowngrades) return null;

            float now = Time.realtimeSinceStartup;
            float previous;
            if (lastAnnounce.TryGetValue(gridId, out previous) && now - previous < config.CooldownSeconds) return null;
            lastAnnounce[gridId] = now;

            string message = Msg(upgrade ? "Upgrade" : "Downgrade", null, stage);
            foreach (BasePlayer player in BasePlayer.activePlayerList)
            {
                if (player == null || !player.IsConnected) continue;
                if (!permission.UserHasPermission(player.UserIDString, PermAnnounce)) continue;
                player.ChatMessage(message);
            }

            return null;
        }
    }
}