OnInventoryNetworkUpdate

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

namespace Oxide.Plugins
{
    [Info("InventoryUpdateMask", "RustPluginGenerator", "1.0.0")]
    [Description("Blocks wear-container network updates for players added to a staff-managed mask list")]
    public class InventoryUpdateMask : RustPlugin
    {
        private const string PermUse = "inventoryupdatemask.use";

        private PluginConfig config;
        private HashSet<string> masked;

        private class PluginConfig
        {
            [JsonProperty("Maximum masked players")]
            public int MaxMasked = 5;
        }

        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>
            {
                ["Masked"] = "Container updates for {0} are now blocked.",
                ["Unmasked"] = "Container updates for {0} are restored.",
                ["Full"] = "Mask list is full. Unmask a player first.",
                ["Unknown"] = "No player found for '{0}'.",
                ["List"] = "Masked players: {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(PermUse, this);
            masked = Interface.Oxide.DataFileSystem.ReadObject<HashSet<string>>(Name) ?? new HashSet<string>();
        }

        private void Unload()
        {
            Interface.Oxide.DataFileSystem.WriteObject(Name, masked);
        }

        [ChatCommand("inventorymask")]
        private void CmdMask(BasePlayer player, string command, string[] args)
        {
            if (player == null || !player.IsAdmin) return;
            if (!permission.UserHasPermission(player.UserIDString, PermUse)) return;

            if (args == null || args.Length == 0)
            {
                string list = masked.Count == 0 ? "none" : string.Join(", ", masked);
                SendReply(player, Msg("List", player.UserIDString, list));
                return;
            }

            BasePlayer target = BasePlayer.FindAwakeOrSleeping(args[0]);
            if (target == null)
            {
                SendReply(player, Msg("Unknown", player.UserIDString, args[0]));
                return;
            }

            string id = target.UserIDString;
            if (masked.Remove(id))
            {
                SendReply(player, Msg("Unmasked", player.UserIDString, target.displayName));
            }
            else
            {
                if (masked.Count >= config.MaxMasked)
                {
                    SendReply(player, Msg("Full", player.UserIDString));
                    return;
                }
                masked.Add(id);
                SendReply(player, Msg("Masked", player.UserIDString, target.displayName));
            }
            Interface.Oxide.DataFileSystem.WriteObject(Name, masked);
        }

        private object OnInventoryNetworkUpdate(PlayerInventory playerInventory, ItemContainer container, ProtoBuf.UpdateItemContainer updateItemContainer, PlayerInventory.Type type, PlayerInventory.NetworkInventoryMode mode)
        {
            if (playerInventory == null || container == null || masked == null) return null;
            if (type != PlayerInventory.Type.Wear) return null;

            BasePlayer owner = playerInventory.baseEntity as BasePlayer;
            if (owner == null || !owner.IsConnected) return null;
            if (!masked.Contains(owner.UserIDString)) return null;

            return true;
        }
    }
}