OnPlayerChat

using System;
using System.Collections.Generic;
using System.Text.RegularExpressions;
using Newtonsoft.Json;
using Oxide.Core;

namespace Oxide.Plugins
{
    [Info("Chat Word Filter", "RustPluginGenerator", "1.0.0")]
    [Description("Blocks chat messages containing configured words and alerts staff")]
    public class ChatWordFilter : RustPlugin
    {
        private const string PermNotify = "chatwordfilter.notify";

        private PluginConfig config;
        private Regex blockedPattern;

        private class PluginConfig
        {
            [JsonProperty("Blocked words")]
            public List<string> BlockedWords = new List<string> { "freeitems", "cheats" };

            [JsonProperty("Filter team chat")]
            public bool FilterTeamChat = true;
        }

        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>
            {
                ["Blocked"] = "Your message was hidden: it contains a blocked word.",
                ["StaffAlert"] = "{0} tried to send a filtered message: {1}"
            }, 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(PermNotify, this);
            BuildPattern();
        }

        private void BuildPattern()
        {
            var words = new List<string>();
            foreach (var word in config.BlockedWords)
            {
                if (!string.IsNullOrEmpty(word)) words.Add(Regex.Escape(word.ToLowerInvariant()));
            }
            blockedPattern = words.Count > 0 ? new Regex(@"\b(" + string.Join("|", words) + @")\b", RegexOptions.IgnoreCase) : null;
        }

        private object OnPlayerChat(BasePlayer player, string message, ConVar.Chat.ChatChannel channel)
        {
            if (player == null || string.IsNullOrEmpty(message) || blockedPattern == null) return null;
            if (!config.FilterTeamChat && channel == ConVar.Chat.ChatChannel.Team) return null;
            if (!blockedPattern.IsMatch(message)) return null;

            player.ChatMessage(Msg("Blocked", player.UserIDString));

            foreach (var target in BasePlayer.activePlayerList)
            {
                if (target == null || !target.IsConnected) continue;
                if (target.UserIDString == player.UserIDString) continue;
                if (permission.UserHasPermission(target.UserIDString, PermNotify))
                {
                    target.ChatMessage(Msg("StaffAlert", target.UserIDString, player.displayName, message));
                }
            }

            return true;
        }
    }
}