ModernUO/Projects/UOContent/Engines/Player Murder System/PlayerMurderSystem.cs

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Runtime.InteropServices;
using ModernUO.CodeGeneratedEvents;
using Server.Collections;
using Server.Logging;
using Server.Mobiles;

namespace Server.Engines.PlayerMurderSystem;

public class PlayerMurderSystem : GenericPersistence
{
    private static PlayerMurderSystem _playerMurderPersistence;

    private static readonly ILogger logger = LogFactory.GetLogger(typeof(PlayerMurderSystem));

    // All of the players with murders
    private static readonly Dictionary<PlayerMobile, MurderContext> _murderContexts = new();

    // Only the players that are online
    private static readonly HashSet<MurderContext> _contextTerms = new(MurderContext.EqualityComparer.Default);

    private static TimeSpan _shortTermMurderDuration;

    private static TimeSpan _longTermMurderDuration;

    public static TimeSpan ShortTermMurderDuration => _shortTermMurderDuration;

    public static TimeSpan LongTermMurderDuration => _longTermMurderDuration;

    public static bool PingPongEnabled => Core.T2A && !Core.LBR;

    public static void Configure()
    {
        _shortTermMurderDuration = ServerConfiguration.GetOrUpdateSetting("murderSystem.shortTermMurderDuration", TimeSpan.FromHours(8));
        _longTermMurderDuration = ServerConfiguration.GetOrUpdateSetting("murderSystem.longTermMurderDuration", TimeSpan.FromHours(40));

        _playerMurderPersistence = new PlayerMurderSystem();
    }

    public static void Initialize()
    {
        EventSink.Disconnected += OnDisconnected;
    }

    [OnEvent(nameof(PlayerMobile.PlayerDeletedEvent))]
    public static void OnPlayerDeleted(Mobile m)
    {
        if (m is PlayerMobile pm && _murderContexts.Remove(pm, out var context))
        {
            _contextTerms.Remove(context);
        }
    }

    public PlayerMurderSystem() : base("PlayerMurders", 10)
    {
    }

    // Only used for migrations!
    public static void MigrateContext(PlayerMobile player, TimeSpan shortTerm, TimeSpan longTerm)
    {
        if (!World.Loading)
        {
            logger.Error(
                $"Attempted to call MigrateContext outside of world loading.{Environment.NewLine}{{StackTrace}}",
                new StackTrace()
            );
            return;
        }

        var context = GetOrCreateMurderContext(player);

        // We make a big assumption that by the time this is called, the Mobile/PlayerMobile info is deserialized
        if (Mobile.MurderMigrations?.TryGetValue(player, out var shortTermMurders) == true)
        {
            context.ShortTermMurders = shortTermMurders;
        }

        context.ShortTermElapse = shortTerm;
        context.LongTermElapse = longTerm;
        UpdateMurderContext(context);
    }

    [OnEvent(nameof(PlayerMobile.PlayerLoginEvent))]
    public static void OnLogin(PlayerMobile pm)
    {
        if (!GetMurderContext(pm, out var context))
        {
            return;
        }

        if (context.CheckStart())
        {
            _contextTerms.Add(context);
        }
        else
        {
            _contextTerms.Remove(context);
            if (context.CanRemove())
            {
                _murderContexts.Remove(pm);
            }
        }
    }

    private static void OnDisconnected(Mobile m)
    {
        if (m is not PlayerMobile pm || !_murderContexts.TryGetValue(pm, out var context))
        {
            return;
        }

        context.DecayKills();
        _contextTerms.Remove(context);

        if (context.CanRemove())
        {
            _murderContexts.Remove(pm);
        }
    }

    public override void Deserialize(IGenericReader reader)
    {
        var version = reader.ReadEncodedInt();

        var count = reader.ReadEncodedInt();
        for (var i = 0; i < count; ++i)
        {
            var context = new MurderContext(reader.ReadEntity<PlayerMobile>());
            context.Deserialize(reader);

            _murderContexts.Add(context.Player, context);
        }
    }

    public override void Serialize(IGenericWriter writer)
    {
        writer.WriteEncodedInt(0); // version

        writer.WriteEncodedInt(_murderContexts.Count);
        foreach (var (m, context) in _murderContexts)
        {
            writer.Write(m);
            context.Serialize(writer);
        }
    }

    public static bool GetMurderContext(PlayerMobile player, out MurderContext context)
    {
        if (player != null && _murderContexts.TryGetValue(player, out context))
        {
            return true;
        }

        context = null;
        return false;
    }

    public static MurderContext GetOrCreateMurderContext(PlayerMobile player)
    {
        if (player == null)
        {
            return null;
        }

        ref var context = ref CollectionsMarshal.GetValueRefOrAddDefault(_murderContexts, player, out var exists);
        if (!exists)
        {
            context = new MurderContext(player);
        }

        return context;
    }

    public static void ManuallySetPingPong(PlayerMobile player, int pingPong)
    {
        var context = GetOrCreateMurderContext(player);
        context.PingPong = Math.Max(pingPong, 0);
        UpdateMurderContext(context);
    }

    public static void ManuallySetShortTermMurders(PlayerMobile player, int shortTermMurders)
    {
        var context = GetOrCreateMurderContext(player);
        context.ShortTermMurders = shortTermMurders;

        context.ResetKillTime();
        UpdateMurderContext(context);
    }

    public static void OnPlayerMurder(PlayerMobile player)
    {
        var context = GetOrCreateMurderContext(player);
        context.ShortTermMurders++;
        player.Kills++;

        if (PingPongEnabled && player.Kills == 5)
        {
            context.PingPong++;
        }

        context.ResetKillTime();
        UpdateMurderContext(context);
    }

    private static void UpdateMurderContext(MurderContext context)
    {
        var player = context.Player;

        if (!context.CheckStart())
        {
            if (context.CanRemove())
            {
                _murderContexts.Remove(player);
            }
            _contextTerms.Remove(context);
        }
        else if (player.NetState != null)
        {
            _contextTerms.Add(context);
        }
    }

    internal static void ReportKillsToSelf(PlayerMobile player)
    {
        if (Core.Expansion == Expansion.None)
        {
            return;  // no consider sins in pre-t2a
        }
        else if (Core.Expansion is Expansion.T2A)
        {
            if (player.ShortTermMurders >= 5)
            {
                player.SendLocalizedMessage(502126, "", 0x022); // If thou should return to the land of the living, the innocent shall wreak havoc upon thy soul
            }
            else if (PingPongEnabled && player.Murderer)
            {
                player.SendLocalizedMessage(502123, "", 0x022);  // Thou art known throughout the land as a murderous brigand.
            }
            else if (player.ShortTermMurders > 0)
            {
                player.SendLocalizedMessage(502125, "", 0x59); // Although thou hast slain the innocent, thy deeds shall not bring retribution upon thy return to the living
            }
            else if (player.Kills > 0)
            {
                player.SendLocalizedMessage(502124, "", 0x59);  // Fear not, thou hast not slain the innocent in some time...
            }
            else  // no kills
            {
                player.SendLocalizedMessage(502122, "", 0x59);  // Fear not, thou hast not slain the innocent.
            }
        }
        else if (!Core.SE)
        {
            player.SendMessage($"Short Term Murders : {player.ShortTermMurders}");
            player.SendMessage($"Long Term Murders : {player.Kills}");
            if (PingPongEnabled)
            {
                player.SendMessage($"Ping Pongs: {player.PingPong}");
            }
        }
        else
        {
            player.SendLocalizedMessage(1114370, $"{player.ShortTermMurders}\t{player.Kills}");
        }
    }

    private class MurdererTimer : Timer
    {
        public MurdererTimer() : base(TimeSpan.FromMinutes(5.0), TimeSpan.FromMinutes(5.0))
        {
        }

        public static void Initialize()
        {
            new MurdererTimer().Start();
        }

        protected override void OnTick()
        {
            if (_contextTerms.Count == 0)
            {
                return;
            }

            using var queue = PooledRefQueue<Mobile>.Create();

            foreach (var context in _contextTerms)
            {
                context.DecayKills();
                if (!context.CheckStart())
                {
                    queue.Enqueue(context.Player);
                }
            }

            while (queue.Count > 0)
            {
                var pm = (PlayerMobile)queue.Dequeue();
                if (_murderContexts.TryGetValue(pm, out var ctx))
                {
                    if (ctx.CanRemove())
                    {
                        _murderContexts.Remove(pm);
                    }
                    _contextTerms.Remove(ctx);
                }
            }
        }

        ~MurdererTimer()
        {
            PlayerMurderSystem.logger.Error($"{nameof(MurdererTimer)} is no longer running!");
        }
    }
}