Broadcast gameplay events for third-party use

.github/workflows/dotnetcore.yml

@@ -9,7 +9,10 @@ on:
 jobs:
   build:
     name: Build and Test
-    runs-on: ubuntu-latest
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ ubuntu-latest, macos-latest, windows-latest ]
 
     steps:
     - name: Checkout repository

osu.Game.Rulesets.Sentakki.Tests/IO/TestSceneGameplayEventBroadcaster.cs

@@ -0,0 +1,187 @@
+using System;
+using System.IO.Pipes;
+using System.Security.Principal;
+using System.Threading;
+using System.Threading.Tasks;
+using NUnit.Framework;
+using osu.Framework.Graphics.Sprites;
+using osu.Game.Rulesets.Sentakki.IO;
+using osu.Game.Tests.Visual;
+
+namespace osu.Game.Rulesets.Sentakki.Tests.IO
+{
+    public class TestSceneGameplayEventBroadcaster : OsuTestScene
+    {
+        private GameplayEventBroadcaster broadcaster;
+        private TestBroadcastClient client;
+        private readonly SpriteText text;
+
+        public TestSceneGameplayEventBroadcaster()
+        {
+            Add(text = new SpriteText()
+            {
+                Text = "Nothing here yet"
+            });
+        }
+
+        [Test]
+        public void TestNormalOperation()
+        {
+            AddStep("Start broadcaster", () => createBroadcaster());
+            AddStep("Create Client", () => createTestClient());
+            AddUntilStep("Client connected", () => client.IsClientConnected);
+            AddStep("Send message 1", () => broadcaster.Broadcast(new TransmissionData(TransmissionData.InfoType.HitPerfect, 3)));
+            AddUntilStep("Client received message 1", () => text.Text == new TransmissionData(TransmissionData.InfoType.HitPerfect, 3).ToString());
+            AddStep("Send message 2", () => broadcaster.Broadcast(new TransmissionData(TransmissionData.InfoType.MetaEndPlay, 3)));
+            AddUntilStep("Client received message 2", () => text.Text == new TransmissionData(TransmissionData.InfoType.MetaEndPlay, 3).ToString());
+            AddStep("Send message 3", () => broadcaster.Broadcast(new TransmissionData(TransmissionData.InfoType.Miss, 3)));
+            AddUntilStep("Client received message 3", () => text.Text == new TransmissionData(TransmissionData.InfoType.Miss, 3).ToString());
+            AddStep("Dispose client", () => client?.Dispose());
+            AddStep("Dispose broadcaster", () => broadcaster.Dispose());
+        }
+
+        [Test]
+        public void TestOperationWithoutClient()
+        {
+            AddStep("Start broadcaster", () => createBroadcaster());
+            AddStep("Send message 1", () => broadcaster.Broadcast(new TransmissionData(TransmissionData.InfoType.HitPerfect, 3)));
+            AddStep("Dispose broadcaster", () => broadcaster.Dispose());
+        }
+
+        [Test]
+        public void TestOperationWithClientDisconnect()
+        {
+            AddStep("Start broadcaster", () => createBroadcaster());
+            AddStep("Create Client", () => createTestClient());
+            AddUntilStep("Client connected", () => client.IsClientConnected);
+            AddStep("Client disconnect", () => client?.Dispose());
+            AddStep("Send message 1", () => broadcaster.Broadcast(new TransmissionData(TransmissionData.InfoType.HitPerfect, 3)));
+            AddStep("Dispose broadcaster", () => broadcaster.Dispose());
+        }
+
+        [Test]
+        public void TestRetryBroadcastOnClientReconnect()
+        {
+            AddStep("Start broadcaster", () => createBroadcaster());
+            AddStep("Send message 1", () => broadcaster.Broadcast(new TransmissionData(TransmissionData.InfoType.HitPerfect, 3)));
+            AddStep("Create Client", () => createTestClient());
+            AddUntilStep("Client connected", () => client.IsClientConnected);
+            AddUntilStep("Client received message 1", () => text.Text == new TransmissionData(TransmissionData.InfoType.HitPerfect, 3).ToString());
+            AddStep("Dispose broadcaster", () => broadcaster.Dispose());
+            AddStep("Dispose client", () => client?.Dispose());
+        }
+
+        // This is just to ensure my sample client implementation holds up
+        // So others can be confident they aren't getting a sample that doesn't work
+        [Test]
+        public void TestClientOperationWithServerReconnect()
+        {
+            AddStep("Start broadcaster", () => createBroadcaster());
+            AddStep("Create Client", () => createTestClient());
+            AddUntilStep("Client connected", () => client.IsClientConnected);
+            AddStep("Dispose broadcaster", () => broadcaster.Dispose());
+            AddStep("Start new broadcaster", () => broadcaster = new GameplayEventBroadcaster());
+            AddUntilStep("Client connected", () => client.IsClientConnected);
+            AddStep("Send message 1", () => broadcaster.Broadcast(new TransmissionData(TransmissionData.InfoType.HitPerfect, 3)));
+            AddUntilStep("Client received message 1", () => text.Text == new TransmissionData(TransmissionData.InfoType.HitPerfect, 3).ToString());
+            AddStep("Dispose broadcaster", () => broadcaster.Dispose());
+            AddStep("Dispose client", () => client?.Dispose());
+        }
+
+        private void createBroadcaster()
+        {
+            broadcaster?.Dispose();
+            broadcaster = new GameplayEventBroadcaster();
+        }
+
+        private void createTestClient()
+        {
+            client?.Dispose();
+            client = new TestBroadcastClient(text);
+        }
+
+        protected override void Dispose(bool isDisposing)
+        {
+            base.Dispose(isDisposing);
+            client?.Dispose();
+            broadcaster?.Dispose();
+        }
+
+        public class TestBroadcastClient : IDisposable
+        {
+            private NamedPipeClientStream pipeClient;
+
+            private readonly SpriteText text;
+
+            private bool running = true;
+
+            public bool IsClientConnected => pipeClient.IsConnected;
+
+            private readonly Thread readThread;
+
+            public TestBroadcastClient(SpriteText outputText)
+            {
+                text = outputText;
+                pipeClient = new NamedPipeClientStream(".", "senPipe",
+                        PipeDirection.In, PipeOptions.Asynchronous,
+                        TokenImpersonationLevel.Impersonation);
+
+                readThread = new Thread(clientLoop);
+                readThread.Start();
+            }
+
+            private readonly CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
+            private CancellationToken cancellationToken => cancellationTokenSource.Token;
+
+            private async void clientLoop()
+            {
+                byte[] buffer = new byte[1];
+                while (running)
+                {
+                    try
+                    {
+                        if (!pipeClient.IsConnected)
+                            await pipeClient.ConnectAsync(cancellationToken).ConfigureAwait(false);
+
+                        int result = await pipeClient.ReadAsync(new Memory<byte>(buffer), cancellationToken).ConfigureAwait(false);
+
+                        if (result > 0)
+                        {
+                            TransmissionData packet = new TransmissionData(buffer[0]);
+
+                            if (packet != TransmissionData.Empty)
+                                text.Text = packet.ToString();
+                        }
+                        else if (result == 0) // End of stream reached, meaning that the server disconnected
+                        {
+                            text.Text = TransmissionData.Kill.ToString();
+
+                            // On non-Windows platforms, the client doesn't automatically reconnect
+                            // So we must recreate the client to ensure safety;
+                            pipeClient.Dispose();
+                            pipeClient = new NamedPipeClientStream(".", "senPipe",
+                                    PipeDirection.In, PipeOptions.Asynchronous,
+                                    TokenImpersonationLevel.Impersonation);
+                        }
+                    }
+                    catch (Exception e)
+                    {
+                        // The operation was canceled. Gracefully shutdown;
+                        if (e is TaskCanceledException || e is OperationCanceledException)
+                            return;
+
+                        throw;
+                    }
+                }
+            }
+
+            public void Dispose()
+            {
+                running = false;
+                cancellationTokenSource.Cancel();
+                readThread.Join();
+                pipeClient.Dispose();
+            }
+        }
+    }
+}

osu.Game.Rulesets.Sentakki.Tests/IO/TestSceneTransmissionProtocol.cs

@@ -0,0 +1,38 @@
+using NUnit.Framework;
+using osu.Framework.Testing;
+using osu.Game.Rulesets.Sentakki.IO;
+
+namespace osu.Game.Rulesets.Sentakki.Tests.IO
+{
+    [HeadlessTest]
+    public class TestSceneTransmissionProtocol
+    {
+        private const TransmissionData.InfoType testtype = TransmissionData.InfoType.Miss;
+        private const int testvalue = 7;
+        private const byte testbyte = ((byte)testtype << 3) + 7;
+
+        [Test]
+        public void TestEncode()
+        {
+            var encoded = new TransmissionData(testtype, testvalue);
+            Assert.AreEqual(testbyte, encoded.RawData);
+        }
+
+        [Test]
+        public void TestDecode()
+        {
+            var encoded = new TransmissionData(testbyte);
+            Assert.AreEqual(testtype, encoded.Type);
+            Assert.AreEqual(testvalue, encoded.Value);
+        }
+
+        [Test]
+        public void TestKillEquality()
+        {
+            var packet1 = new TransmissionData(TransmissionData.InfoType.Kill, 7); // Baseline
+            var packet2 = new TransmissionData(TransmissionData.InfoType.Kill, 0); // Lightly altered, but should still be considered the same, because of the kill flag
+
+            Assert.AreEqual(packet1, packet2);
+        }
+    }
+}

osu.Game.Rulesets.Sentakki.Tests/TestSceneOsuGame.cs

@@ -2,8 +2,10 @@
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Shapes;
+using osu.Framework.Graphics.Sprites;
 using osu.Game.Online.API;
 using osu.Game.Online.API.Requests.Responses;
+using osu.Game.Rulesets.Sentakki.Tests.IO;
 using osu.Game.Tests.Visual;
 using osu.Game.Users;
 using osuTK.Graphics;

osu.Game.Rulesets.Sentakki/Configurations/SentakkiRulesetConfigManager.cs

@@ -24,6 +24,7 @@ protected override void InitialiseDefaults()
             SetDefault(SentakkiRulesetSettings.LaneInputMode, LaneInputMode.Button);
             SetDefault(SentakkiRulesetSettings.SnakingSlideBody, true);
             SetDefault(SentakkiRulesetSettings.DetailedJudgements, false);
+            SetDefault(SentakkiRulesetSettings.GameplayIPC, false);
         }
     }
 
@@ -51,6 +52,7 @@ public enum SentakkiRulesetSettings
         TouchAnimationDuration,
         LaneInputMode,
         SnakingSlideBody,
-        DetailedJudgements
+        DetailedJudgements,
+        GameplayIPC,
     }
 }

osu.Game.Rulesets.Sentakki/IO/GameplayEventBroadcaster.cs

@@ -0,0 +1,83 @@
+using System;
+using System.IO;
+using System.IO.Pipes;
+using System.Net.Sockets;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace osu.Game.Rulesets.Sentakki.IO
+{
+    public class GameplayEventBroadcaster : IDisposable
+    {
+        private readonly NamedPipeServerStream pipeServer;
+
+        // This is used to store the message that needs to be sent
+        // In the event that a broadcast fails, we can resend this message once a new connection is established.
+        private TransmissionData queuedData;
+
+        public GameplayEventBroadcaster()
+        {
+            pipeServer = new NamedPipeServerStream("senPipe", PipeDirection.Out, 1, PipeTransmissionMode.Byte, PipeOptions.Asynchronous);
+            attemptConnection();
+        }
+
+        private bool isWaitingForClient;
+
+        private readonly CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
+        private CancellationToken cancellationToken => cancellationTokenSource.Token;
+
+        private async void attemptConnection()
+        {
+            if (isWaitingForClient) return;
+
+            isWaitingForClient = true;
+
+            try { await pipeServer.WaitForConnectionAsync(cancellationToken).ConfigureAwait(false); }
+            catch (Exception e)
+            {
+                // The operation was canceled. Gracefully shutdown;
+                if (e is TaskCanceledException || (e is SocketException se && se.SocketErrorCode == SocketError.OperationAborted))
+                    return;
+
+                throw;
+            }
+
+            isWaitingForClient = false;
+
+            if (queuedData != TransmissionData.Empty)
+                Broadcast(queuedData);
+        }
+
+        private readonly byte[] buffer = new byte[1];
+
+        public async void Broadcast(TransmissionData packet)
+        {
+            buffer[0] = packet.RawData;
+
+            queuedData = packet;
+
+            if (isWaitingForClient) return;
+
+            try
+            {
+                await pipeServer.WriteAsync(new Memory<byte>(buffer), cancellationToken).ConfigureAwait(false);
+            }
+            catch (IOException)
+            {
+                // The client has suddenly disconnected, we must disconnect on our end, and wait for a new connection.
+                pipeServer.Disconnect();
+                attemptConnection();
+
+                return;
+            }
+
+            queuedData = TransmissionData.Empty;
+        }
+
+        public void Dispose()
+        {
+            cancellationTokenSource.Cancel();
+            pipeServer.Dispose();
+        }
+    }
+}