Update README + remove ToSignal extension methods

Fractural · Mar 28, 2024 · f698a1f · f698a1f
1 parent 6175b95
commit f698a1f
Show file tree

Hide file tree

Showing 3 changed files with 41 additions and 18 deletions.
diff --git a/README.md b/README.md
@@ -13,18 +13,41 @@ using Fractural.Tasks;
 
 public Test : Node 
 {
+	[Signal]
+	public delegate void MySignalHandler(int number, bool boolean);
+
 	public override _Ready() 
 	{
-		// Running a task from a non-async method
+		// Running a task from a non-async method.
 		Run().Forget();
 	}
 
 	public async GDTaskVoid Run() 
 	{
 		await GDTask.DelayFrame(100);
 
-		// waiting some amount of time
+		// Waiting some amount of time
+		// Note that these delays are paused when the game is paused
 		await GDTask.Delay(TimeSpan.FromSeconds(10));
+		await GDTask.Delay(TimeSpan.FromSeconds(10), PlayerLoopTiming.Process);
+		await GDTask.Delay(TimeSpan.FromSeconds(10), PlayerLoopTiming.PhysicsProcess);
+		// Waiting some amount of milliseconds
+		await GDTask.Delay(1000);
+		// Waiting some amount of milliseconds, regardless of whether the game is paused
+		await GDTask.Delay(TimeSpan.FromSeconds(10), PlayerLoopTiming.PauseProcess);
+		await GDTask.Delay(TimeSpan.FromSeconds(10), PlayerLoopTiming.PausePhysicsProcess);
+
+		// Awaiting for a signal
+		WaitAndEmitMySignal(TimeSpan.FromSeconds(2)).Forget();
+		var signalResults = await GDTask.ToSignal(this, nameof(MySignal));
+		// signalResults = [10, true]
+
+		// Cancellable awaiting a signal
+		var cts = new CancellationTokenSource();
+		WaitAndEmitMySignal(TimeSpan.FromSeconds(2)).Forget();
+		WaitAndCancelToken(TimeSpan.FromSeconds(1), cts).Forget();
+		var signalResults = await GDTask.ToSignal(this, nameof(MySignal), cts.Token);
+		// signalResults = null, since we cancelled awaiting the signal before the signal could fire.
 
 		// Waiting a single frame
 		await GDTask.Yield();
@@ -34,13 +57,13 @@ public Test : Node
 		// Waiting for specific lifetime call
 		await GDTask.WaitForPhysicsProcess();
 
-		// Cancellation
+		// Cancellation of a GDTask
 		var cts = new CancellationTokenSource();
 		CancellableReallyLongTask(cts.Token).Forget();
 		await GDTask.Delay(TimeSpan.FromSeconds(3));
 		cts.Cancel();
 
-		// Async await with return value
+		// Returning a value from a GDTask
 		string result = await RunWithResult();
 		return result + " with additional text";
 	}
@@ -57,6 +80,18 @@ public Test : Node
 		await GDTask.Delay(TimeSpan.FromSeconds(1000000), cancellationToken: cancellationToken);
 		GD.Print("Finished long task.");
 	}
+
+	public async GDTaskVoid WaitAndEmitMySignal(TimeSpan delay)
+	{
+		await GDTask.Delay(delay);
+		EmitSignal(nameof(MySignal), 10, true);
+	}
+
+	public async GDTaskVoid WaitAndCancelToken(TimeSpan delay, CancellationTokenSource cts)
+	{
+		await GDTask.Delay(delay);
+		cts.Cancel();
+	}
 }
 ```
 

diff --git a/addons/GDTask/GDTask.ToSignal.cs b/addons/GDTask/GDTask.ToSignal.cs
@@ -86,16 +86,4 @@ public static async GDTask<Variant[]> ToSignal(GodotObject self, string signal,
             return await cancellableSignalAwaiter;
         }
     }
-
-    public static partial class GDTaskExtensions
-    {
-        public static GDTask<Variant[]> ToGDTaskSignal(this GodotObject self, string signal)
-        {
-            return GDTask.ToSignal(self, signal);
-        }
-        public static GDTask<Variant[]> ToGDTaskSignal(this GodotObject self, string signal, CancellationToken ct)
-        {
-            return GDTask.ToSignal(self, signal, ct);
-        }
-    }
 }
diff --git a/tests/manual/Test.cs b/tests/manual/Test.cs
@@ -85,14 +85,14 @@ private async GDTaskVoid Run()
             GD.Print("Run: Await Cancellable MyEmptySignal");
             WaitAndEmitMyEmptySignal(TimeSpan.FromSeconds(3)).Forget();
             WaitAndCancelToken(TimeSpan.FromSeconds(0.5), cts).Forget();
-            signalResult = await this.ToGDTaskSignal(nameof(MyEmptySignal), cts.Token);
+            signalResult = await GDTask.ToSignal(this, nameof(MyEmptySignal), cts.Token);
             GD.Print("Run: Await Cancellable MyEmptySignal Cancelled, result: ", signalResult);
 
             cts = new CancellationTokenSource();
             GD.Print("Run: Await Cancellable MyArgSignal");
             WaitAndEmitMyArgSignal(TimeSpan.FromSeconds(3)).Forget();
             WaitAndCancelToken(TimeSpan.FromSeconds(0.5), cts).Forget();
-            signalResult = await this.ToGDTaskSignal(nameof(MyArgSignal), cts.Token);
+            signalResult = await GDTask.ToSignal(this, nameof(MyArgSignal), cts.Token);
             GD.Print("Run: Await Cancellable MyArgSignal Cancelled, result: ", signalResult);
 
             GD.Print("Run: Pre RunWithResult");