quantum-space-buddies/QSB/Messaging/QSBMessageManager.cs

using Mirror;
using OWML.Common;
using QSB.ClientServerStateSync;
using QSB.ClientServerStateSync.Messages;
using QSB.Player;
using QSB.Player.Messages;
using QSB.Player.TransformSync;
using QSB.Utility;
using QSB.WorldSync;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Runtime.Serialization;

namespace QSB.Messaging
{
	public static class QSBMessageManager
	{
		#region inner workings

		internal static readonly Type[] _types;
		internal static readonly Dictionary<Type, ushort> _typeToId = new();

		static QSBMessageManager()
		{
			_types = typeof(QSBMessage).GetDerivedTypes().ToArray();
			for (ushort i = 0; i < _types.Length; i++)
			{
				_typeToId.Add(_types[i], i);
				// call static constructor of message if needed
				RuntimeHelpers.RunClassConstructor(_types[i].TypeHandle);
			}
		}

		public static void Init()
		{
			NetworkServer.RegisterHandler<Wrapper>((_, wrapper) => OnServerReceive(wrapper));
			NetworkClient.RegisterHandler<Wrapper>(wrapper => OnClientReceive(wrapper));
		}

		private static void OnServerReceive(QSBMessage msg)
		{
			if (msg.To == uint.MaxValue)
			{
				NetworkServer.SendToAll<Wrapper>(msg);
			}
			else if (msg.To == 0)
			{
				NetworkServer.localConnection.Send<Wrapper>(msg);
			}
			else
			{
				msg.To.GetNetworkConnection().Send<Wrapper>(msg);
			}
		}

		private static void OnClientReceive(QSBMessage msg)
		{
			if (PlayerTransformSync.LocalInstance == null)
			{
				DebugLog.ToConsole($"Warning - Tried to handle message {msg} before local player was established.", MessageType.Warning);
				return;
			}

			if (QSBPlayerManager.PlayerExists(msg.From))
			{
				var player = QSBPlayerManager.GetPlayer(msg.From);

				if (!player.IsReady
				    && player.PlayerId != QSBPlayerManager.LocalPlayerId
				    && player.State is ClientState.AliveInSolarSystem or ClientState.AliveInEye or ClientState.DeadInSolarSystem
				    && msg is not (PlayerInformationMessage or PlayerReadyMessage or RequestStateResyncMessage or ServerStateMessage))
				{
					DebugLog.ToConsole($"Warning - Got message {msg} from player {msg.From}, but they were not ready. Asking for state resync, just in case.", MessageType.Warning);
					new RequestStateResyncMessage().Send();
				}
			}

			try
			{
				if (!msg.ShouldReceive)
				{
					return;
				}

				if (msg.From != QSBPlayerManager.LocalPlayerId)
				{
					msg.OnReceiveRemote();
				}
				else
				{
					msg.OnReceiveLocal();
				}
			}
			catch (Exception ex)
			{
				DebugLog.ToConsole($"Error - Exception handling message {msg} : {ex}", MessageType.Error);
			}
		}

		#endregion

		public static void Send<M>(this M msg)
			where M : QSBMessage
		{
			if (PlayerTransformSync.LocalInstance == null)
			{
				DebugLog.ToConsole($"Warning - Tried to send message {msg} before local player was established.", MessageType.Warning);
				return;
			}

			msg.From = QSBPlayerManager.LocalPlayerId;
			NetworkClient.Send<Wrapper>(msg);
		}

		public static void SendMessage<T, M>(this T worldObject, M msg)
			where T : IWorldObject
			where M : QSBWorldObjectMessage<T>
		{
			msg.ObjectId = worldObject.ObjectId;
			Send(msg);
		}
	}

	internal struct Wrapper : NetworkMessage
	{
		public QSBMessage Msg;

		public static implicit operator QSBMessage(Wrapper wrapper) => wrapper.Msg;
		public static implicit operator Wrapper(QSBMessage msg) => new() { Msg = msg };
	}

	internal static class ReaderWriterExtensions
	{
		private static QSBMessage ReadQSBMessage(this NetworkReader reader)
		{
			var id = reader.ReadUShort();
			var type = QSBMessageManager._types[id];
			var msg = (QSBMessage)FormatterServices.GetUninitializedObject(type);
			msg.Deserialize(reader);
			return msg;
		}

		private static void WriteQSBMessage(this NetworkWriter writer, QSBMessage msg)
		{
			var type = msg.GetType();
			var id = QSBMessageManager._typeToId[type];
			writer.Write(id);
			msg.Serialize(writer);
		}
	}
}