How to make a Rust playtime rewards plugin (AFK-safe, Oxide)

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

namespace Oxide.Plugins
{
    [Info("Playtime Rewards", "RustPluginGenerator", "1.0.0")]
    [Description("Pays configured items every N minutes of active play, skipping AFK players.")]
    public class PlaytimeRewards : RustPlugin
    {
        private const string PermUse = "playtimerewards.use";
        private const string PermVip = "playtimerewards.vip";
        private const string PermAdmin = "playtimerewards.admin";

        private class PluginConfig
        {
            [JsonProperty("Seconds between activity checks")]
            public float TickSeconds = 5f;

            [JsonProperty("Minutes of active play per reward")]
            public float MinutesPerReward = 30f;

            [JsonProperty("Minimum distance in metres to count as active")]
            public float AfkDistance = 1f;

            [JsonProperty("VIP reward multiplier")]
            public float VipMultiplier = 2f;

            [JsonProperty("Rewards")]
            public List<RewardEntry> Rewards = new List<RewardEntry>
            {
                new RewardEntry { Shortname = "scrap", Amount = 100, Skin = 0 },
                new RewardEntry { Shortname = "metal.fragments", Amount = 50, Skin = 0 }
            };
        }

        private class RewardEntry
        {
            [JsonProperty("Shortname")]
            public string Shortname = "scrap";

            [JsonProperty("Amount")]
            public int Amount = 100;

            [JsonProperty("Skin")]
            public ulong Skin = 0;
        }

        private class Session
        {
            public string UserId;
            public Vector3 LastPosition;
            public float Accumulated;
            public float Bonus;
        }

        private PluginConfig config;
        private readonly Dictionary<string, Session> sessions = new Dictionary<string, Session>();
        private Timer tickTimer;

        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>
            {
                ["RewardReceived"] = "Playtime reward: {0}",
                ["Progress"] = "Active playtime this session: {0}s of {1}s needed for the next reward.",
                ["ItemLine"] = "{0} x{1}",
                ["NoPermission"] = "You do not have permission to use this command.",
                ["Credited"] = "Credited {0} seconds to {1}.",
                ["PlayerNotFound"] = "No player found with that name or ID."
            }, 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);
            permission.RegisterPermission(PermVip, this);
            permission.RegisterPermission(PermAdmin, this);
        }

        private void OnServerInitialized()
        {
            foreach (var entry in config.Rewards)
            {
                if (ItemManager.FindItemDefinition(entry.Shortname) == null)
                    PrintWarning($"Unknown shortname in reward list: {entry.Shortname}");
            }

            tickTimer = timer.Every(Mathf.Max(1f, config.TickSeconds), Tick);
        }

        private void Unload()
        {
            tickTimer?.Destroy();
            sessions.Clear();
        }

        private void OnPlayerConnected(BasePlayer player)
        {
            if (player == null) return;
            sessions[player.UserIDString] = new Session
            {
                UserId = player.UserIDString,
                LastPosition = player.transform.position
            };
        }

        private void OnPlayerDisconnected(BasePlayer player, string reason)
        {
            if (player == null) return;
            sessions.Remove(player.UserIDString);
        }

        private void Tick()
        {
            if (sessions.Count == 0) return;
            float tick = Mathf.Max(1f, config.TickSeconds);

            foreach (var player in BasePlayer.activePlayerList)
            {
                if (player == null || player.IsNpc || !player.IsConnected) continue;
                if (player.IsDead() || player.IsSleeping()) continue;

                Session session;
                if (!sessions.TryGetValue(player.UserIDString, out session)) continue;

                Vector3 position = player.transform.position;
                if (Vector3.Distance(position, session.LastPosition) >= config.AfkDistance)
                {
                    session.LastPosition = position;
                    session.Accumulated += tick;
                }

                float needed = Mathf.Max(1f, config.MinutesPerReward) * 60f;
                session.Accumulated += session.Bonus;
                session.Bonus = 0f;

                if (session.Accumulated >= needed)
                {
                    session.Accumulated -= needed;
                    PayReward(player);
                }
            }
        }

        private void PayReward(BasePlayer player)
        {
            float multiplier = permission.UserHasPermission(player.UserIDString, PermVip)
                ? Mathf.Max(0.1f, config.VipMultiplier)
                : 1f;

            var lines = new List<string>();
            foreach (var entry in config.Rewards)
            {
                int amount = Mathf.Max(1, Mathf.RoundToInt(entry.Amount * multiplier));
                var item = ItemManager.CreateByName(entry.Shortname, amount, entry.Skin);
                if (item == null) continue;

                player.GiveItem(item);
                lines.Add(Msg("ItemLine", player.UserIDString, item.info.displayName.english, amount));
            }

            if (lines.Count == 0) return;

            float minutes = Mathf.Max(1f, config.MinutesPerReward);
            PrintToChat(player, Msg("RewardReceived", player.UserIDString, string.Join(", ", lines.ToArray())) + $" (+{minutes:0} min)");
        }

        [ChatCommand("playtime")]
        private void CmdPlaytime(BasePlayer player, string command, string[] args)
        {
            if (player == null) return;
            if (!permission.UserHasPermission(player.UserIDString, PermUse))
            {
                SendReply(player, Msg("NoPermission", player.UserIDString));
                return;
            }

            Session session;
            float accumulated = sessions.TryGetValue(player.UserIDString, out session) ? session.Accumulated : 0f;
            float needed = Mathf.Max(1f, config.MinutesPerReward) * 60f;
            SendReply(player, Msg("Progress", player.UserIDString, Mathf.FloorToInt(accumulated), Mathf.FloorToInt(needed)));
        }

        [ConsoleCommand("playtime.give")]
        private void CcmdGive(ConsoleSystem.Arg arg)
        {
            if (!arg.IsAdmin && (arg.Player() == null || !permission.UserHasPermission(arg.Player().UserIDString, PermAdmin)))
            {
                arg.ReplyWith(Msg("NoPermission"));
                return;
            }

            string target = arg.GetString(0, "");
            float seconds = arg.GetFloat(1, 0f);
            if (string.IsNullOrEmpty(target) || seconds <= 0f)
            {
                arg.ReplyWith("playtime.give <nameOrId> <seconds>");
                return;
            }

            var player = BasePlayer.FindAwakeOrSleeping(target);
            if (player == null)
            {
                arg.ReplyWith(Msg("PlayerNotFound"));
                return;
            }

            Session session;
            if (!sessions.TryGetValue(player.UserIDString, out session))
            {
                session = new Session { UserId = player.UserIDString, LastPosition = player.transform.position };
                sessions[player.UserIDString] = session;
            }

            session.Bonus += seconds;
            arg.ReplyWith(Msg("Credited", null, seconds, player.displayName));
        }
    }
}