CanLootEntity

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

namespace Oxide.Plugins
{
    [Info("Corpse Team Loot Gate", "RustPluginGenerator", "1.0.0")]
    [Description("Restricts corpse looting to the dead player's team and the corpse owner.")]
    public class CorpseTeamLootGate : RustPlugin
    {
        private const string PermBypass = "corpseteamlootgate.bypass";

        private PluginConfig config;
        private StoredData data;

        private class PluginConfig
        {
            [JsonProperty("Enable team-only corpse looting")]
            public bool Enabled = true;

            [JsonProperty("Notify blocked players in chat")]
            public bool NotifyBlocked = true;
        }

        private class StoredData
        {
            [JsonProperty("Corpse teams by net id")]
            public Dictionary<ulong, ulong> CorpseTeams = new Dictionary<ulong, ulong>();
        }

        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"] = "This corpse belongs to another team. Only the owner's team can loot it."
            }, 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(PermBypass, this);
            data = Interface.Oxide.DataFileSystem.ReadObject<StoredData>(Name) ?? new StoredData();
        }

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

        private void OnEntityDeath(BaseCombatEntity entity, HitInfo info)
        {
            var player = entity as BasePlayer;
            if (player == null || player.currentTeam == 0 || entity.net == null) return;

            data.CorpseTeams[entity.net.ID.Value] = player.currentTeam;
        }

        private object CanLootEntity(BasePlayer player, LootableCorpse corpse)
        {
            if (!config.Enabled || player == null || corpse == null || corpse.net == null) return null;

            ulong corpseId = corpse.net.ID.Value;
            ulong teamId = 0;
            if (data.CorpseTeams.TryGetValue(corpseId, out teamId))
            {
                // teamId was recorded at death
            }

            ulong owner = corpse.playerSteamID;
            if (teamId == 0)
            {
                // Fall back to the corpse owner's current team when nothing was recorded.
                var ownerPlayer = BasePlayer.FindByID(owner);
                if (ownerPlayer != null) teamId = ownerPlayer.currentTeam;
            }

            if (player.userID.Get() == owner) return null;
            if (player.IsAdmin || permission.UserHasPermission(player.UserIDString, PermBypass)) return null;
            if (teamId != 0 && player.currentTeam == teamId) return null;

            if (config.NotifyBlocked && player.IsConnected)
                player.ChatMessage(Msg("Blocked", player.UserIDString));

            return true;
        }
    }
}