How to make a Rust announcement banner plugin (CUI top-screen messages)

using System;
using System.Collections.Generic;
using Newtonsoft.Json;
using Oxide.Core;
using Oxide.Game.Rust.Cui;
using UnityEngine;

namespace Oxide.Plugins
{
    [Info("Announcement Banner", "RustPluginGenerator", "1.0.0")]
    [Description("Shows a top-screen CUI banner to all players via /announce or scheduled config entries.")]
    public class AnnouncementBanner : RustPlugin
    {
        private const string PanelId = "announcementbanner.panel";
        private const string PermUse = "announcementbanner.use";

        private PluginConfig config;
        private Timer activeTimer;
        private float activeRemaining;
        private readonly List<Timer> scheduledTimers = new List<Timer>();

        private class BannerEntry
        {
            [JsonProperty("Interval Seconds")]
            public float IntervalSeconds = 600f;

            [JsonProperty("Text")]
            public string Text = "Server restart in 10 minutes";
        }

        private class PluginConfig
        {
            [JsonProperty("Default Duration")]
            public float DefaultDuration = 10f;

            [JsonProperty("Text Color")]
            public string TextColor = "1 1 1 1";

            [JsonProperty("Font Size")]
            public int FontSize = 20;

            [JsonProperty("Scheduled Banners")]
            public List<BannerEntry> ScheduledBanners = new List<BannerEntry>
            {
                new BannerEntry { IntervalSeconds = 1800f, Text = "Server restart in 10 minutes" }
            };
        }

        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>
            {
                ["Usage"] = "Usage: /announce <text> [seconds]",
                ["Announced"] = "Banner sent to all players.",
                ["NoPlayers"] = "No players are connected."
            }, 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(PermUse, this);
        }

        private void OnServerInitialized()
        {
            StartScheduled();
        }

        [ChatCommand("announce")]
        private void CmdAnnounce(BasePlayer player, string command, string[] args)
        {
            if (!permission.UserHasPermission(player.UserIDString, PermUse))
            {
                player.ChatMessage("You do not have permission to use that command.");
                return;
            }

            if (args == null || args.Length == 0)
            {
                player.ChatMessage(Msg("Usage", player.UserIDString));
                return;
            }

            float duration = config.DefaultDuration;
            int textCount = args.Length;

            if (args.Length > 1 && float.TryParse(args[args.Length - 1], out float parsed) && parsed > 0f)
            {
                duration = parsed;
                textCount = args.Length - 1;
            }

            string text = string.Join(" ", args, 0, textCount).Trim();
            if (string.IsNullOrEmpty(text))
            {
                player.ChatMessage(Msg("Usage", player.UserIDString));
                return;
            }

            ShowBanner(text, duration);
            player.ChatMessage(Msg("Announced", player.UserIDString));
        }

        private void ShowBanner(string text, float duration)
        {
            if (string.IsNullOrEmpty(text) || duration <= 0f) return;
            if (BasePlayer.activePlayerList.Count == 0) return;

            activeRemaining = duration;

            foreach (var target in BasePlayer.activePlayerList)
            {
                if (target == null || !target.IsConnected) continue;
                DrawFor(target, text);
            }

            activeTimer?.Destroy();
            activeTimer = timer.Once(duration, () =>
            {
                foreach (var target in BasePlayer.activePlayerList)
                {
                    if (target == null || !target.IsConnected) continue;
                    CuiHelper.DestroyUi(target, PanelId);
                }
                activeRemaining = 0f;
                activeTimer = null;
            });
        }

        private void DrawFor(BasePlayer player, string text)
        {
            CuiHelper.DestroyUi(player, PanelId);

            var elements = new CuiElementContainer();
            string panel = elements.Add(new CuiPanel
            {
                Image = { Color = "0.08 0.08 0.08 0.85" },
                RectTransform = { AnchorMin = "0.22 0.88", AnchorMax = "0.78 0.97" }
            }, "Overlay", PanelId);

            elements.Add(new CuiLabel
            {
                Text = { Text = text, FontSize = config.FontSize, Color = config.TextColor, Align = TextAnchor.MiddleCenter },
                RectTransform = { AnchorMin = "0.02 0", AnchorMax = "0.98 1" }
            }, panel);

            CuiHelper.AddUi(player, elements);
        }

        private void OnPlayerConnected(BasePlayer player)
        {
            if (player == null) return;
            if (activeRemaining <= 0f) return;
            if (string.IsNullOrEmpty(lastText)) return;

            DrawFor(player, lastText);
            activeTimer?.Destroy();
            activeTimer = timer.Once(activeRemaining, () =>
            {
                foreach (var target in BasePlayer.activePlayerList)
                {
                    if (target == null || !target.IsConnected) continue;
                    CuiHelper.DestroyUi(target, PanelId);
                }
                activeRemaining = 0f;
                activeTimer = null;
            });
        }

        private string lastText;

        private void ShowPersistentBanner(string text, float duration)
        {
            lastText = text;
            ShowBanner(text, duration);
        }

        private void StartScheduled()
        {
            foreach (var timerItem in scheduledTimers) timerItem?.Destroy();
            scheduledTimers.Clear();

            if (config.ScheduledBanners == null) return;

            foreach (var entry in config.ScheduledBanners)
            {
                if (entry == null) continue;
                if (string.IsNullOrEmpty(entry.Text) || entry.IntervalSeconds <= 0f)
                {
                    PrintWarning("Skipping scheduled banner with empty text or non-positive interval");
                    continue;
                }

                var captured = entry;
                var t = timer.Every(captured.IntervalSeconds, () => ShowBanner(captured.Text, config.DefaultDuration));
                scheduledTimers.Add(t);
            }
        }

        private void Unload()
        {
            foreach (var player in BasePlayer.activePlayerList)
            {
                if (player == null) continue;
                CuiHelper.DestroyUi(player, PanelId);
            }

            activeTimer?.Destroy();
            activeTimer = null;

            foreach (var t in scheduledTimers) t?.Destroy();
            scheduledTimers.Clear();
        }
    }
}