OnLootEntityEnd

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

namespace Oxide.Plugins
{
    [Info("Corpse Loot Alert", "RustPluginGenerator", "1.0.0")]
    [Description("Notifies corpse owners and admins when someone closes the loot panel of a corpse.")]
    public class CorpseLootAlert : RustPlugin
    {
        private const string PermAdmin = "corpselootalert.admin";

        private readonly Dictionary<ulong, float> lastNotify = new Dictionary<ulong, float>();

        private class PluginConfig
        {
            [JsonProperty("Notify online owners")]
            public bool NotifyOwner { get; set; } = true;

            [JsonProperty("Notify admins with permission")]
            public bool NotifyAdmins { get; set; } = true;

            [JsonProperty("Minimum seconds between notifications per looter")]
            public float CooldownSeconds { get; set; } = 3f;
        }

        private PluginConfig config;

        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>
            {
                ["OwnerNotice"] = "{0} was seen leaving your corpse at {1}",
                ["AdminNotice"] = "{0} looted corpse of {1} at {2}"
            }, 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(PermAdmin, this);
        }

        private void OnLootEntityEnd(BasePlayer player, LootableCorpse lootableCorpse)
        {
            if (player == null || lootableCorpse == null) return;

            ulong ownerId = lootableCorpse.OwnerID;
            if (ownerId == 0UL) return;

            float now = UnityEngine.Time.realtimeSinceStartup;
            float last;
            if (lastNotify.TryGetValue(player.userID.Get(), out last) && now - last < config.CooldownSeconds)
                return;
            lastNotify[player.userID.Get()] = now;

            string pos = FormatPosition(lootableCorpse.transform.position);
            string looterName = player.displayName ?? player.UserIDString;
            string ownerName = ownerId.ToString();

            if (config.NotifyOwner && ownerId != player.userID.Get())
            {
                BasePlayer owner = BasePlayer.FindByID(ownerId);
                if (owner != null && owner.IsConnected)
                {
                    owner.ChatMessage(Msg("OwnerNotice", owner.UserIDString, looterName, pos));
                    ownerName = owner.displayName;
                }
            }

            if (config.NotifyAdmins)
            {
                foreach (BasePlayer admin in BasePlayer.activePlayerList)
                {
                    if (admin == null || admin == player) continue;
                    if (!permission.UserHasPermission(admin.UserIDString, PermAdmin)) continue;
                    if (ownerId == admin.userID.Get()) continue;
                    admin.ChatMessage(Msg("AdminNotice", admin.UserIDString, looterName, ownerName, pos));
                }
            }
        }

        private static string FormatPosition(UnityEngine.Vector3 position)
            => string.Format("{0:0},{1:0}", position.x, position.z);

        private void Unload()
        {
            lastNotify.Clear();
        }
    }
}