Add ClientTask functionality

SlipeServer.Console/Logic/ServerTestLogic.cs

@@ -9,6 +9,7 @@
 using SlipeServer.Packets.Lua.Camera;
 using SlipeServer.Packets.Structs;
 using SlipeServer.Server;
+using SlipeServer.Server.Concepts;
 using SlipeServer.Server.Constants;
 using SlipeServer.Server.ElementCollections;
 using SlipeServer.Server.Elements;
@@ -185,6 +186,7 @@
     private void SetupTestElements()
     {
         this.testResource = this.resourceProvider.GetResource("TestResource");
+        this.testResource.AddClientTaskHelper();
         this.secondTestResource = this.resourceProvider.GetResource("SecondTestResource");
         this.secondTestResource.NoClientScripts[$"{this.secondTestResource!.Name}/testfile.lua"] =
             Encoding.UTF8.GetBytes("outputChatBox(\"I AM A NOT CACHED MESSAGE\")");
@@ -266,7 +268,7 @@
         this.Vehicle = new Vehicle(530, new Vector3(20, 5, 3)).AssociateWith(this.server);
         this.Taxi = new Vehicle((ushort)VehicleModel.Taxi, new Vector3(20, -5, 3)).AssociateWith(this.server);
         this.Rhino = new Vehicle((ushort)VehicleModel.Rhino, new Vector3(20, -25, 3)).AssociateWith(this.server);
         this.Rhino.Jacked += (e, args) => this.logger.LogInformation($"Rhino has been jacked by {args.NewDriver.Name}, kicking out {args.PreviousDriver.Name}");
 
         this.Elegy = new Vehicle(562, new Vector3(30, -20, 3)).AssociateWith(this.server);
         this.Elegy.HealthChanged += (e, value) =>
@@ -561,7 +563,7 @@
                 if (ushort.TryParse(args.Arguments[0], out ushort slots))
                 {
                     this.server.SetMaxPlayers(slots);
                     this.logger.LogInformation("Slots has been changed to: {slots}", slots);
                 }
             }
         };
@@ -688,7 +690,7 @@
                 if (byte.TryParse(args.Arguments[0], out byte interior))
                 {
                     args.Player.Camera.Interior = interior;
                     this.logger.LogInformation("Camera interior changed to: {interior}", interior);
                 }
             }
         };
@@ -947,7 +949,7 @@
             await Task.Delay(1000);
             stopwatch.Stop();
             var distance = Vector3.Distance(element.Position, new Vector3(0, 0, 3));
             this.logger.LogInformation("Element travelled {distance} units in {ms} ms", distance, stopwatch.ElapsedMilliseconds);
             element.Destroy();
         };
 
@@ -1033,10 +1035,10 @@
             }
             catch (Exception ex)
             {
                 this.logger.LogError(ex, "Failed to start Slipe Lua test resource for {playerName}, {ex}", args.Player.Name, ex.ToString());
             }
             stopwatch.Stop();
             this.logger.LogInformation("Starting Slipe Lua test resource for {playerName} took {milliseconds}ms", args.Player.Name, stopwatch.ElapsedMilliseconds);
         };
 
         this.commandService.AddCommand("blowup").Triggered += (source, args) =>
@@ -1536,7 +1538,7 @@
 
         player.Kicked += (player, args) =>
         {
             this.logger.LogWarning("{playerName} has been kicked, reason: {reason}", player.Name, args.Reason);
         };
 
         player.ScreenshotTaken += HandlePlayerScreenshot;
@@ -1561,20 +1563,20 @@
 
         player.AcInfoReceived += (o, args) =>
         {
             this.logger.LogInformation("ACInfo for {playerName} detectedACList:{acList} d3d9Size: {D3D9Size} d3d9SHA256: {D3D9SHA256}", player.Name, string.Join(",", args.DetectedACList), args.D3D9Size, args.D3D9SHA256);
         };
 
         player.DiagnosticInfoReceived += (o, args) =>
         {
             this.logger.LogInformation("DIAGNOSTIC: {playerName} #{level} {message}", player.Name, args.Level, args.Message);
         };
 
         player.ModInfoReceived += (o, args) =>
         {
             this.logger.LogInformation("Player: {playerName} ModInfo:", player.Name);
             foreach (var item in args.ModInfoItems)
             {
                 this.logger.LogInformation("\t{name} - md5: {md5}", item.Name, item.LongMd5);
             }
         };
 
@@ -1583,17 +1585,17 @@
             switch (args.PlayerNetworkStatus)
             {
                 case Packets.Enums.PlayerNetworkStatusType.InterruptionBegan:
                     this.logger.LogInformation("(packets from {name}) interruption began {ticks} ticks ago", o.Name, args.Ticks);
                     break;
                 case Packets.Enums.PlayerNetworkStatusType.InterruptionEnd:
                     this.logger.LogInformation("(packets from {name}) interruption began {ticks} ticks ago and has just ended", o.Name, args.Ticks);
                     break;
             }
         };
 
         player.TeamChanged += (thePlayer, args) =>
         {
             this.logger.LogDebug("{playerName} Joined {teamName} team!", thePlayer.Name, thePlayer.Team?.TeamName);
         };
 
         player.TargetChanged += (thePlayer, args) =>
@@ -1601,7 +1603,7 @@
             if (args.NewValue != null && args.NewValue is Vehicle vehicle)
             {
                 if (vehicle.Model == (ushort)VehicleModel.Rhino)
                     this.logger.LogDebug("{playerName} Changed target rhino", thePlayer.Name);
             }
         };
 
@@ -1616,9 +1618,9 @@
             {
                 player.HasJetpack = !player.HasJetpack;
                 if (player.HasJetpack)
                     this.logger.LogInformation("{name} put on a jetpack!", sender.Name);
                 else
                     this.logger.LogInformation("{name} pulled off his jetpack!", sender.Name);
             } else if (e.Key == "h")
             {
                 jetpackBindEnabled = !jetpackBindEnabled;
@@ -1691,7 +1693,7 @@
         } else
         {
             Player? player = (Player?)o;
             this.logger.LogWarning("Failed to take a screenshot ({tag}) of player: {playerName}, reason: {errorMessage}", e.Tag, player?.Name, e.ErrorMessage);
         }
     }
 
@@ -1700,7 +1702,7 @@
         var sampleValue = new SampleLuaValue();
         sampleValue.Parse(luaEvent.Parameters.First());
 
         this.logger.LogInformation("{event}", JsonConvert.SerializeObject(sampleValue));
     }
 
     private void TriggerTestEvent(Player player)

SlipeServer.Console/Resources/TestResource/test.lua

@@ -114,4 +114,27 @@ addEventHandler("onClientRender", root, function()
 		k = k + 1
 		printDebugVehicle(k, v);
 	end
-end)
+end)
+
+local clientTasks = {}
+addEvent("testClientTask", true)
+addEventHandler("testClientTask", root, function(clientTask)
+	outputChatBox("ClientTask created.");
+	clientTasks[#clientTasks + 1] = clientTask;
+end)
+
+addCommandHandler("resolveTasks", function()
+	for i,task in ipairs(clientTasks)do
+		ClientTask.Resolve(task, "Ok");
+	end
+	outputChatBox("Resolved: "..#clientTasks.." tasks.")
+	clientTasks = {}
+end)
+
+addCommandHandler("rejectTasks", function()
+	for i,task in ipairs(clientTasks)do
+		ClientTask.Reject(task, "Ok");
+	end
+	outputChatBox("Failed: "..#clientTasks.." tasks.")
+	clientTasks = {}
+end)

SlipeServer.Example/ServerExampleLogic.cs

@@ -1,5 +1,7 @@
 using SlipeServer.Server;
+using SlipeServer.Server.Concepts;
 using SlipeServer.Server.Elements;
+using SlipeServer.Server.Exceptions;
 using SlipeServer.Server.Services;
 
 namespace SlipeServer.Example;
@@ -8,12 +10,13 @@
 {
     private readonly CommandService commandService;
     private readonly ChatBox chatBox;
+    private readonly MtaServer mtaServer;
 
     public ServerExampleLogic(CommandService commandService, ChatBox chatBox, MtaServer mtaServer)
     {
         this.commandService = commandService;
         this.chatBox = chatBox;
-
+        this.mtaServer = mtaServer;
         AddCommand("hello", player =>
         {
             this.chatBox.OutputTo(player, "Hello world");
@@ -34,7 +37,7 @@
         AddVehiclesCommands();
     }
 
     private void AddVehiclesCommands()
     {
         AddCommand("myvehprintdamage", player =>
         {
@@ -83,6 +86,40 @@
             vehicle.Fix();
             this.chatBox.OutputTo(player, "Vehicle fixed");
         });
+
+        AddCommand("clienttask", async player =>
+        {
+            var cts = new CancellationTokenSource(TimeSpan.FromSeconds(10));
+            var task = this.mtaServer.CreateClientTask(player, cts.Token);
+
+            player.TriggerLuaEvent("testClientTask", player, task);
+
+            try
+            {
+                await task;
+            }
+            catch (PlayerDisconnectedException e) // When player left the server
+            {
+                Console.WriteLine("Result: PlayerDisconnectedException");
+            }
+            catch (InvalidOperationException e) // When client sent invalid response
+            {
+                Console.WriteLine("Result: InvalidOperationException");
+            }
+            catch (ClientErrorException e) // When client on purpose rejected task
+            {
+                Console.WriteLine("Result: ClientErrorException");
+            }
+            catch (OperationCanceledException e) // Exceptin from cts from above
+            {
+                Console.WriteLine("Result: OperationCanceledException");
+            }
+            finally
+            {
+                this.chatBox.OutputTo(player, "Task completed");
+            }
+
+        });
     }
 
     private void AddCommand(string command, Action<Player> callback)
@@ -92,4 +129,19 @@
             callback(e.Player);
         };
     }
+
+    private void AddCommand(string command, Func<Player, Task> callback)
+    {
+        this.commandService.AddCommand(command).Triggered += async (object? sender, Server.Events.CommandTriggeredEventArgs e) =>
+        {
+            try
+            {
+                await callback(e.Player);
+            }
+            catch(Exception ex)
+            {
+                Console.WriteLine(ex.ToString());
+            }
+        };
+    }
 }

SlipeServer.Server/Concepts/ClientTask.cs

@@ -0,0 +1,131 @@
+using SlipeServer.Packets.Definitions.Lua;
+using SlipeServer.Server.Elements;
+using SlipeServer.Server.Exceptions;
+using SlipeServer.Server.Resources;
+using System;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace SlipeServer.Server.Concepts;
+
+public static class ResourceExtensions
+{
+    public static Resource AddClientTaskHelper(this Resource resource)
+    {
+        resource.NoClientScripts["clientTaskHelper.lua"] = System.Text.UTF8Encoding.UTF8.GetBytes(ClientTask.luaHelperCode);
+
+        return resource;
+    }
+}
+
+public sealed class ClientErrorException : Exception
+{
+    public ClientErrorException(string? message) : base(message)
+    {
+
+    }
+}
+
+public sealed class ClientTask : LuaValue, IDisposable
+{
+    public const string luaHelperCode = """
+        ClientTask = {
+          Resolve = function(clientTask, ...)
+            if(clientTask._completed)then
+                error("ClientTask already completed");
+            end
+            clientTask._completed = true;
+            triggerServerEvent("clientTask_"..clientTask._id, localPlayer, "success", ...)
+          end,
+          Reject = function(clientTask, ...)
+            if(clientTask._completed)then
+                error("ClientTask already completed");
+            end
+            clientTask._completed = true;
+            triggerServerEvent("clientTask_"..clientTask._id, localPlayer, "error", ...)
+          end,
+        }
+        """;
+
+    private readonly TaskCompletionSource taskCompletionSource;
+    private readonly string eventName;
+    public MtaServer MtaServer { get; }
+    public Player Player { get; }
+    public string Id { get; }
+
+    internal ClientTask(MtaServer mtaServer, Player player, string id, CancellationToken cancellationToken) : base(new LuaTable
+    {
+        ["_id"] = id
+    })
+    {
+        this.taskCompletionSource = new TaskCompletionSource();
+        this.MtaServer = mtaServer;
+        this.Player = player;
+        this.Id = id;
+        this.eventName = $"clientTask_{this.Id}";
+        this.MtaServer.LuaEventTriggered += HandleLuaEventTriggered;
+        this.Player.Disconnected += HandleDisconnected;
+        cancellationToken.Register(() =>
+        {
+            this.taskCompletionSource.TrySetCanceled();
+        });
+    }
+
+    private void HandleDisconnected(Player sender, Elements.Events.PlayerQuitEventArgs e)
+    {
+        this.taskCompletionSource.TrySetException(new PlayerDisconnectedException(sender));
+        Dispose();
+    }
+
+    private void HandleLuaEventTriggered(Events.LuaEvent luaEvent)
+    {
+        if (luaEvent.Name != this.eventName || luaEvent.Player != this.Player)
+            return;
+
+        try
+        {
+            var result = luaEvent.Parameters[0].StringValue;
+
+            if (result == "success")
+            {
+                this.taskCompletionSource.TrySetResult();
+            }
+            else if (result == "error")
+            {
+                if(luaEvent.Parameters.Length >= 2)
+                {
+                    this.taskCompletionSource.TrySetException(new ClientErrorException(luaEvent.Parameters[1].StringValue));
+                } else
+                {
+                    this.taskCompletionSource.TrySetException(new ClientErrorException(null));
+                }
+            }
+            else
+            {
+                this.taskCompletionSource.TrySetException(new InvalidOperationException());
+            }
+        }
+        catch (Exception ex)
+        {
+            this.taskCompletionSource.TrySetException(ex);
+        }
+        finally
+        {
+            Dispose();
+        }
+    }
+
+    public void Dispose()
+    {
+        this.MtaServer.LuaEventTriggered -= HandleLuaEventTriggered;
+        this.Player.Disconnected -= HandleDisconnected;
+        this.taskCompletionSource.TrySetException(new ObjectDisposedException(nameof(ClientTask)));
+    }
+
+    public TaskAwaiter GetAwaiter()
+    {
+        return this.taskCompletionSource.Task.GetAwaiter();
+    }
+}

SlipeServer.Server/Exceptions/PlayerDisconnectedException.cs

@@ -0,0 +1,14 @@
+using SlipeServer.Server.Elements;
+using System;
+
+namespace SlipeServer.Server.Exceptions;
+
+public sealed class PlayerDisconnectedException : Exception
+{
+    public Player Player { get; }
+
+    public PlayerDisconnectedException(Player player)
+    {
+        this.Player = player;
+    }
+}

SlipeServer.Server/MtaServer.cs

@@ -10,6 +10,7 @@
 using SlipeServer.Server.AllSeeingEye;
 using SlipeServer.Server.Bans;
 using SlipeServer.Server.Clients;
+using SlipeServer.Server.Concepts;
 using SlipeServer.Server.ElementCollections;
 using SlipeServer.Server.Elements;
 using SlipeServer.Server.Elements.IdGeneration;
@@ -32,6 +33,7 @@
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
+using System.Threading;
 
 namespace SlipeServer.Server;
 
@@ -678,6 +680,17 @@ public static MtaServer Create(IServiceProvider serviceProvider, Action<ServerBu
     public static MtaServer<TPlayer> CreateWithDiSupport<TPlayer>(Action<ServerBuilder> builderAction) where TPlayer : Player
         => new MtaDiPlayerServer<TPlayer>(builderAction);
 
+    /// <summary>
+    /// Creates 
+    /// </summary>
+    /// <param name="player"></param>
+    /// <returns></returns>
+    public ClientTask CreateClientTask(Player player, CancellationToken cancellationToken = default)
+    {
+        var id = Guid.NewGuid().ToString();
+        return new ClientTask(this, player, id, cancellationToken);
+    }
+
     /// <summary>
     /// Triggered when any element is created on the server through the .AssociateElement method
     /// </summary>