RAGECOOP-V/Server/Client.cs

using System;
using System.Diagnostics;
using System.Net;
using System.Security.Cryptography;
using GTA.Native;
using Lidgren.Network;
using RageCoop.Core;
using RageCoop.Core.Scripting;
using RageCoop.Server.Scripting;

namespace RageCoop.Server;

/// <summary>
///     Represent a player connected to this server.
/// </summary>
public class Client
{
    private readonly Stopwatch _latencyWatch = new();
    internal readonly Dictionary<int, Action<object>> Callbacks = new();
    private readonly Server Server;


    private bool _autoRespawn = true;

    private bool _displayNameTag = true;

    internal long NetHandle = 0;

    internal Client(Server server)
    {
        Server = server;
    }

    /// <summary>
    ///     Gets the total number of entities owned by this client
    /// </summary>
    public int EntitiesCount { get; internal set; }

    /// <summary>
    ///     Th client's IP address and port.
    /// </summary>
    public IPEndPoint EndPoint => Connection?.RemoteEndPoint;

    /// <summary>
    ///     Internal(LAN) address of this client, used for NAT hole-punching
    /// </summary>
    public IPEndPoint InternalEndPoint { get; internal set; }

    internal NetConnection Connection { get; set; }

    /// <summary>
    ///     The <see cref="ServerPed" /> instance representing the client's main character.
    /// </summary>
    public ServerPed Player { get; internal set; }

    /// <summary>
    ///     The client's latency in seconds.
    /// </summary>
    public float Latency => Connection.AverageRoundtripTime / 2;

    internal byte[] PublicKey { get; set; }

    /// <summary>
    ///     Indicates whether the client has succefully loaded all resources.
    /// </summary>
    public bool IsReady { get; internal set; } = false;

    /// <summary>
    ///     The client's username.
    /// </summary>
    public string Username { get; internal set; } = "N/A";

    /// <summary>
    ///     Gets or sets whether to enable automatic respawn for this client's main ped.
    /// </summary>
    public bool EnableAutoRespawn
    {
        get => _autoRespawn;
        set
        {
            BaseScript.SetAutoRespawn(this, value);
            _autoRespawn = value;
        }
    }

    /// <summary>
    ///     Gets or sets whether to enable automatic respawn for this client's main ped.
    /// </summary>
    public bool DisplayNameTag
    {
        get => _displayNameTag;
        set
        {
            Server.BaseScript.SetNameTag(this, value);
            _displayNameTag = value;
        }
    }

    #region FUNCTIONS

    /// <summary>
    ///     Kick this client
    /// </summary>
    /// <param name="reason"></param>
    public void Kick(string reason = "You have been kicked!")
    {
        Connection?.Disconnect(reason);
    }

    /// <summary>
    ///     Kick this client
    /// </summary>
    /// <param name="reasons">Reasons to kick</param>
    public void Kick(params string[] reasons)
    {
        Kick(string.Join(" ", reasons));
    }

    /// <summary>
    ///     Send a chat messsage to this client, not visible to others.
    /// </summary>
    /// <param name="message"></param>
    /// <param name="from"></param>
    public void SendChatMessage(string message, string from = "Server")
    {
        try
        {
            Server.SendChatMessage(from, message, this);
        }
        catch (Exception e)
        {
            Server.Logger?.Error(
                $">> {e.Message} <<>> {e.Source ?? string.Empty} <<>> {e.StackTrace ?? string.Empty} <<");
        }
    }

    /// <summary>
    ///     Send a native call to client and do a callback when the response received.
    /// </summary>
    /// <typeparam name="T">Type of the response</typeparam>
    /// <param name="callBack"></param>
    /// <param name="hash"></param>
    /// <param name="args"></param>
    public void SendNativeCall<T>(Action<object> callBack, Hash hash, params object[] args)
    {
        var argsList = new List<object>(args);
        argsList.InsertRange(0,
            new object[] { (byte)Type.GetTypeCode(typeof(T)), RequestNativeCallID<T>(callBack), (ulong)hash });

        SendCustomEventQueued(CustomEvents.NativeCall, argsList.ToArray());
    }

    /// <summary>
    ///     Send a native call to client and ignore it's response.
    /// </summary>
    /// <param name="hash"></param>
    /// <param name="args"></param>
    public void SendNativeCall(Hash hash, params object[] args)
    {
        var argsList = new List<object>(args);
        argsList.InsertRange(0, new object[] { (byte)TypeCode.Empty, (ulong)hash });
        // Server.Logger?.Debug(argsList.DumpWithType());
        SendCustomEventQueued(CustomEvents.NativeCall, argsList.ToArray());
    }

    private int RequestNativeCallID<T>(Action<object> callback)
    {
        var ID = 0;
        lock (Callbacks)
        {
            while (ID == 0
                   || Callbacks.ContainsKey(ID))
            {
                var rngBytes = new byte[4];

                RandomNumberGenerator.Create().GetBytes(rngBytes);

                // Convert the bytes into an integer
                ID = BitConverter.ToInt32(rngBytes, 0);
            }

            Callbacks.Add(ID, callback);
        }

        return ID;
    }

    /// <summary>
    ///     Trigger a CustomEvent for this client
    /// </summary>
    /// <param name="flags"></param>
    /// <param name="hash">An unique identifier of the event</param>
    /// <param name="args">Arguments</param>
    public void SendCustomEvent(CustomEventFlags flags, CustomEventHash hash, params object[] args)
    {
        if (!IsReady) Server.Logger?.Warning($"Player \"{Username}\" is not ready!");

        try
        {
            var outgoingMessage = Server.MainNetServer.CreateMessage();

            var writer = GetWriter();
            CustomEvents.WriteObjects(writer, args);;
            new Packets.CustomEvent(flags)
            {
                Hash = hash,
                Payload = writer.ToByteArray(writer.Position)
            }.Pack(outgoingMessage);
            Server.MainNetServer.SendMessage(outgoingMessage, Connection, NetDeliveryMethod.ReliableOrdered,
                (byte)ConnectionChannel.Event);
        }
        catch (Exception ex)
        {
            Server.Logger?.Error(ex);
        }
    }

    public void SendCustomEventQueued(CustomEventHash hash, params object[] args)
    {
        SendCustomEvent(CustomEventFlags.Queued, hash, args);
    }

    public void SendCustomEvent(CustomEventHash hash, params object[] args)
    {
        SendCustomEvent(CustomEventFlags.None, hash, args);
    }

    #endregion
}