add packet sink

src/MineCase.Core/Server/ServerProperties.cs

@@ -0,0 +1,10 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace MineCase.Core.Server
+{
+    public class ServerProperties
+    {
+    }
+}

src/MineCase.Core/World/GameType.cs

@@ -12,4 +12,9 @@ namespace MineCase.Core.World
         Adventure = 2,
         Spectator = 3,
     }
+
+    public class GameTypes
+    {
+
+    }
 }

src/MineCase.Gateway/Network/Handler/Login/ServerLoginNetHandler.cs

@@ -3,6 +3,7 @@ using System.Collections.Generic;
 using System.Text;
 using System.Threading.Tasks;
 using MineCase.Core.Game;
+using MineCase.Protocol.Protocol;
 using MineCase.Protocol.Protocol.Login.Client;
 using MineCase.Protocol.Protocol.Login.Server;
 using MineCase.Server.Server;
@@ -83,6 +84,12 @@ namespace MineCase.Gateway.Network.Handler.Login
             };
 
             await _clientSession.SendPacket(successPacket);
+
+            // Change session state
+            _clientSession.SetSessionState(SessionState.Play);
+
+            // Set net handler
+            _clientSession.SetNetHandler(SessionState.Play);
         }
     }
 }

src/MineCase.Server.Grains/MineCase.Server.Grains.csproj

@@ -33,4 +33,8 @@
     <ProjectReference Include="..\MineCase.Server.Interfaces\MineCase.Server.Interfaces.csproj" />
   </ItemGroup>
 
+  <ItemGroup>
+    <Folder Include="Server\MultiPlayer\" />
+  </ItemGroup>
+
 </Project>

src/MineCase.Server.Grains/Network/ClientboundPacketSink.cs

@@ -0,0 +1,61 @@
+using System;
+using System.Threading.Tasks;
+using MineCase.Protocol.Protocol;
+using Orleans;
+using Orleans.Concurrency;
+
+namespace MineCase.Server.Network
+{
+    internal class ClientboundPacketSinkGrain : Grain, IClientboundPacketSink
+    {
+        private GrainObserverManager<IClientboundPacketObserver> _subsManager;
+
+        public ClientboundPacketSinkGrain()
+        {
+        }
+
+        public override Task OnActivateAsync()
+        {
+            _subsManager = new GrainObserverManager<IClientboundPacketObserver>();
+            _subsManager.ExpirationDuration = new TimeSpan(0, 0, 60);
+            return base.OnActivateAsync();
+        }
+
+        // Clients call this to subscribe.
+        public Task Subscribe(IClientboundPacketObserver observer)
+        {
+            _subsManager.Subscribe(observer);
+            return Task.CompletedTask;
+        }
+
+        // Also clients use this to unsubscribe themselves to no longer receive the messages.
+        public Task UnSubscribe(IClientboundPacketObserver observer)
+        {
+            _subsManager.Unsubscribe(observer);
+            return Task.CompletedTask;
+        }
+
+        public Task SendPacket(ISerializablePacket packet)
+        {
+            if (_subsManager.Count == 0)
+                DeactivateOnIdle();
+            else
+                _subsManager.Notify(n => n.ReceivePacket(packet));
+            return Task.CompletedTask;
+        }
+
+        public Task Close()
+        {
+            _subsManager.Notify(n => n.OnClosed());
+            _subsManager.Clear();
+            DeactivateOnIdle();
+            return Task.CompletedTask;
+        }
+
+        public Task NotifyUseCompression(uint threshold)
+        {
+            // _subsManager.Notify(n => n.UseCompression(threshold));
+            return Task.CompletedTask;
+        }
+    }
+}

src/MineCase.Server.Grains/Server/Management/ManagementSettings.cs

@@ -1,30 +1,20 @@
 using System;
 using System.Collections.Generic;
 using System.Text;
+using MineCase.Core.World;
 using MineCase.Server.Server;
+using Orleans;
 
 namespace MineCase.Server.Server.Management
 {
-    public abstract class ManagementSettings
+    public class ManagementSettings : Grain, IManagementSettings
     {
         private IMinecraftServer _server;
-
-        private readonly List<ServerPlayerEntity> players = new List<>();
-        private readonly Map<UUID, ServerPlayerEntity> uuidToPlayerMap = Maps.newHashMap();
-        private readonly BanList bannedPlayers = new BanList(FILE_PLAYERBANS);
-        private readonly IPBanList bannedIPs = new IPBanList(FILE_IPBANS);
-        private readonly OpList ops = new OpList(FILE_OPS);
-        private readonly WhiteList whiteListedPlayers = new WhiteList(FILE_WHITELIST);
-        private readonly Map<UUID, ServerStatisticsManager> playerStatFiles = Maps.newHashMap();
-        private readonly Map<UUID, PlayerAdvancements> advancements = Maps.newHashMap();
-        private IPlayerFileData playerDataManager;
-        private bool whiteListEnforced;
-        protected readonly int maxPlayers;
-        private int viewDistance;
-        private GameType gameType;
-        private bool commandsAllowedForAll;
-        private int playerPingIndex;
-        private readonly List<ServerPlayerEntity> playersView = java.util.Collections.unmodifiableList(players);
-
+        private bool _whiteListEnforced;
+        protected readonly int _maxPlayers;
+        private int _viewDistance;
+        private GameType _gameType;
+        private bool _commandsAllowedForAll;
+        private int _playerPingIndex;
     }
 }

src/MineCase.Server.Interfaces/Network/IClientboundPacketObserver.cs

@@ -0,0 +1,16 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using MineCase.Protocol;
+using MineCase.Protocol.Protocol;
+using Orleans;
+
+namespace MineCase.Server.Network
+{
+    public interface IClientboundPacketObserver : IGrainObserver
+    {
+        void ReceivePacket(ISerializablePacket packet);
+
+        void OnClosed();
+    }
+}

src/MineCase.Server.Interfaces/Network/IClientboundPacketSink.cs

@@ -0,0 +1,20 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading.Tasks;
+using MineCase.Protocol;
+using Orleans;
+
+namespace MineCase.Server.Network
+{
+    public interface IClientboundPacketSink : IPacketSink, IGrainWithGuidKey
+    {
+        Task Subscribe(IClientboundPacketObserver observer);
+
+        Task UnSubscribe(IClientboundPacketObserver observer);
+
+        Task NotifyUseCompression(uint threshold);
+
+        Task Close();
+    }
+}

src/MineCase.Server.Interfaces/Network/IPacketSink.cs

@@ -0,0 +1,15 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading.Tasks;
+using MineCase.Protocol;
+using MineCase.Protocol.Protocol;
+using Orleans.Concurrency;
+
+namespace MineCase.Server.Network
+{
+    public interface IPacketSink
+    {
+        Task SendPacket(ISerializablePacket packet);
+    }
+}

src/MineCase.Server.Interfaces/Server/Management/IManagementSettings.cs

@@ -0,0 +1,11 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using Orleans;
+
+namespace MineCase.Server.Server.Management
+{
+    public interface IManagementSettings : IGrainWithStringKey
+    {
+    }
+}