FREE AutoBroadcast : 1.0.0 1.0.0

using System;
using System.Collections.Generic;
using Oxide.Core;
using Oxide.Core.Plugins;
using UnityEngine;

namespace Oxide.Plugins
{
    [Info("Auto Broadcast", "0killrest", "1.0.0")]
    [Description("Automatically sends broadcast messages to chat on a timer")]
    internal class AutoBroadcast : RustPlugin
    {
        #region Configuration
        private static ConfigData config;
        private Timer broadcastTimer;
        private int currentIndex = 0;
        
        private class ConfigData
        {
            public bool Enabled { get; set; } = true;
            public float IntervalSeconds { get; set; } = 300f; // 5 minutes
            public BroadcastMode Mode { get; set; } = BroadcastMode.Sequential;
            public List<BroadcastMessage> Messages { get; set; }

            public ConfigData()
            {
                Messages = new List<BroadcastMessage>
                {
                    new BroadcastMessage { Text = "Welcome to the server! Read rules at <color=#00ff00>/rules</color>", Color = "#00ff00" },
                    new BroadcastMessage { Text = "Join our Discord: discord.gg/example", Color = "#7289DA" },
                    new BroadcastMessage { Text = "Support the server with /donate", Color = "#ffaa00" },
                    new BroadcastMessage { Text = "Be respectful to other players!", Color = "#ff5555" }
                };
            }
        }
        
        public enum BroadcastMode
        {
            Sequential, // One after another in order
            Random      // Random message each time
        }
        
        public class BroadcastMessage
        {
            public string Text { get; set; }
            public string Color { get; set; } = "white";
        }
        
        protected override void LoadConfig()
        {
            base.LoadConfig();
            config = Config.ReadObject<ConfigData>();
            if (config == null)
            {
                LoadDefaultConfig();
            }
        }
        
        protected override void LoadDefaultConfig()
        {
            config = new ConfigData();
            PrintWarning("Default configuration created.Edit it in oxide/config/AutoBroadcast.json");
            SaveConfig();
        }
        
        protected override void SaveConfig() => Config.WriteObject(config);
        #endregion
        
        #region Hooks
        private void Init()
        {
            LoadConfig();
        }
        
        private void OnServerInitialized()
        {
            if (config.Enabled && config.Messages.Count > 0)
            {
                StartBroadcastTimer();
            }
        }
        
        private void Unload()
        {
            if (broadcastTimer != null)
            {
                broadcastTimer.Destroy();
                broadcastTimer = null;
            }
        }
        #endregion
        
        #region Core Logic
        private void StartBroadcastTimer()
        {
            if (broadcastTimer != null)
            {
                broadcastTimer.Destroy();
            }
            
            broadcastTimer = timer.Repeat(config.IntervalSeconds, 0, () =>
            {
                SendNextBroadcast();
            });
            
            Puts($"AutoBroadcast started: {config.Messages.Count} messages, interval {config.IntervalSeconds}s");
        }
        
        private void SendNextBroadcast()
        {
            if (!config.Enabled || config.Messages.Count == 0) return;
            
            BroadcastMessage msg = GetNextMessage();
            if (msg == null) return;
            
            string formattedMessage = FormatMessage(msg.Text, msg.Color);
            Server.Broadcast(formattedMessage);
            
            // Also log to console
            Puts($"[BROADCAST] {msg.Text}");
        }
        
        private BroadcastMessage GetNextMessage()
        {
            if (config.Mode == BroadcastMode.Random)
            {
                Random rnd = new Random();
                return config.Messages[rnd.Next(config.Messages.Count)];
            }
            else // Sequential
            {
                BroadcastMessage msg = config.Messages[currentIndex];
                currentIndex = (currentIndex + 1) % config.Messages.Count;
                return msg;
            }
        }
        
        private string FormatMessage(string text, string colorHex)
        {
            if (string.IsNullOrEmpty(colorHex))
                return text;
                
            // Remove # if present (it's optional for our config)
            string cleanColor = colorHex.StartsWith("#") ? colorHex : $"#{colorHex}";
            return $"<color={cleanColor}>{text}</color>";
        }
        
        [ConsoleCommand("autobroadcast.reload")]
        private void cmdReload(ConsoleSystem.Arg args)
        {
            if (args.Connection != null)
            {
                args.ReplyWith("This command can only be used from server console");
                return;
            }
            
            LoadConfig();
            
            if (broadcastTimer != null)
            {
                broadcastTimer.Destroy();
            }
            
            if (config.Enabled && config.Messages.Count > 0)
            {
                StartBroadcastTimer();
            }
            
            Puts("AutoBroadcast reloaded");
            args.ReplyWith("AutoBroadcast reloaded");
        }
        
        [ConsoleCommand("autobroadcast.next")]
        private void cmdNext(ConsoleSystem.Arg args)
        {
            if (args.Connection != null)
            {
                args.ReplyWith("This command can only be used from server console");
                return;
            }
            
            SendNextBroadcast();
            args.ReplyWith("Broadcast sent manually");
        }
        
        [ConsoleCommand("autobroadcast.status")]
        private void cmdStatus(ConsoleSystem.Arg args)
        {
            if (args.Connection != null)
            {
                args.ReplyWith("This command can only be used from server console");
                return;
            }
            
            string status = config.Enabled ? "ENABLED" : "DISABLED";
            args.ReplyWith($"AutoBroadcast: {status} | {config.Messages.Count} messages | Interval: {config.IntervalSeconds}s | Mode: {config.Mode}");
        }
        #endregion
    }
}