feat: client map cache (AscensionGameDev#2101)

* feat: generic object data request packet

* fix: correct checksum, separate entities/items packets from map packet since they are not 'static'

* fix MessagePack.Annotations reference

* skip Enqueue if packet is null

* fix: clear cache when map data is changed

Author: pandinocoder

Directory.Build.props

@@ -4,7 +4,7 @@
     <IntersectRepoPath Condition="'$(IntersectRepoPath)' == ''">$(MSBuildProjectDirectory)\..</IntersectRepoPath>
   </PropertyGroup>
 
-  <Import Project=".\Intersect.props"/>
+  <Import Project=".\Intersect.props" />
 
   <PropertyGroup>
     <IntersectProjectName>$(MSBuildProjectName.Substring(10))</IntersectProjectName>

Framework/Directory.Build.props

@@ -0,0 +1,5 @@
+<Project>
+  <PropertyGroup>
+    <IntersectRepoPath>$(MSBuildProjectDirectory)\..\..</IntersectRepoPath>
+  </PropertyGroup>
+</Project>

Framework/Intersect.Framework/Converters/Json/GenericFactoryNewtonsoftJsonConverter.cs

@@ -0,0 +1,79 @@
+using Intersect.Framework.Reflection;
+using Newtonsoft.Json;
+
+namespace Intersect.Framework.Converters.Json;
+
+public abstract class GenericFactoryNewtonsoftJsonConverter : JsonConverter
+{
+    private static readonly Dictionary<Type, JsonConverter> _converters = new Dictionary<Type, JsonConverter>();
+
+    private readonly Type _converterTypeDefinition;
+    private readonly Type _serializedGenericTypeDefinition;
+
+    protected GenericFactoryNewtonsoftJsonConverter(Type converterTypeDefinition, Type serializedGenericTypeDefinition)
+    {
+        _converterTypeDefinition = converterTypeDefinition ??
+                                   throw new ArgumentNullException(nameof(converterTypeDefinition));
+        _serializedGenericTypeDefinition = serializedGenericTypeDefinition ??
+                                           throw new ArgumentNullException(nameof(serializedGenericTypeDefinition));
+    }
+
+    public override bool CanConvert(Type objectType) =>
+        objectType.IsGenericType && objectType.GetGenericTypeDefinition() == _serializedGenericTypeDefinition;
+
+    public override object? ReadJson(JsonReader reader, Type objectType, object? existingValue,
+        JsonSerializer serializer)
+    {
+        if (reader.Value == default)
+        {
+            return reader.Value;
+        }
+
+        var actualConverter = CreateActualConverter(
+            _converterTypeDefinition,
+            _serializedGenericTypeDefinition,
+            objectType
+        );
+        return actualConverter.ReadJson(reader, objectType, existingValue, serializer);
+    }
+
+    public override void WriteJson(JsonWriter writer, object? value, JsonSerializer serializer)
+    {
+        if (value == default)
+        {
+            writer.WriteNull();
+        }
+        else
+        {
+            var actualConverter = CreateActualConverter(
+                _converterTypeDefinition,
+                _serializedGenericTypeDefinition,
+                value.GetType()
+            );
+            actualConverter.WriteJson(writer, value, serializer);
+        }
+    }
+
+    private static JsonConverter CreateActualConverter(
+        Type converterTypeDefinition,
+        Type serializedGenericTypeDefinition,
+        Type objectType
+    )
+    {
+        if (_converters.TryGetValue(objectType, out JsonConverter? jsonConverter))
+        {
+            return jsonConverter;
+        }
+
+        var targetType = objectType
+                             .FindGenericTypeParameters(typeof(Nullable<>), false)
+                             .FirstOrDefault()
+                         ?? objectType;
+
+        var identifiedType = targetType.FindGenericTypeParameters(serializedGenericTypeDefinition);
+        var converterType = converterTypeDefinition.MakeGenericType(identifiedType);
+        jsonConverter = Activator.CreateInstance(converterType) as JsonConverter;
+        _converters[objectType] = jsonConverter ?? throw new InvalidOperationException();
+        return jsonConverter;
+    }
+}

Framework/Intersect.Framework/Converters/Json/GenericSystemJsonConverterFactory.cs

@@ -0,0 +1,31 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace Intersect.Framework.Converters.Json;
+
+public abstract class GenericSystemJsonConverterFactory : JsonConverterFactory
+{
+    private readonly Type _converterTypeDefinition;
+    private readonly Type _serializedGenericTypeDefinition;
+
+    protected GenericSystemJsonConverterFactory(Type converterTypeDefinition, Type serializedGenericTypeDefinition)
+    {
+        _converterTypeDefinition = converterTypeDefinition ??
+                                   throw new ArgumentNullException(nameof(converterTypeDefinition));
+        _serializedGenericTypeDefinition = serializedGenericTypeDefinition ??
+                                           throw new ArgumentNullException(nameof(serializedGenericTypeDefinition));
+    }
+
+    /// <inheritdoc/>
+    public override bool CanConvert(Type typeToConvert) =>
+        typeToConvert.IsGenericType && typeToConvert.GetGenericTypeDefinition() == _serializedGenericTypeDefinition;
+
+    /// <inheritdoc/>
+    public override JsonConverter? CreateConverter(Type typeToConvert, JsonSerializerOptions options)
+    {
+        var identifiedType = typeToConvert.GetGenericArguments()[0];
+        var converterType = _converterTypeDefinition.MakeGenericType(identifiedType);
+        var jsonConverter = Activator.CreateInstance(converterType) as JsonConverter;
+        return jsonConverter;
+    }
+}

Framework/Intersect.Framework/Converters/Json/HandleNewtonsoftJsonConverter.cs

@@ -0,0 +1,20 @@
+using Newtonsoft.Json;
+
+namespace Intersect.Framework.Converters.Json;
+
+public sealed class HandleNewtonsoftJsonConverter : GenericFactoryNewtonsoftJsonConverter
+{
+    public HandleNewtonsoftJsonConverter() : base(typeof(HandleNewtonsoftJsonConverter<>), typeof(Handle<>))
+    {
+    }
+}
+
+public class HandleNewtonsoftJsonConverter<THandle> : JsonConverter<Handle<THandle>>
+{
+    public override Handle<THandle> ReadJson(JsonReader reader, Type objectType, Handle<THandle> existingValue,
+        bool hasExistingValue, JsonSerializer serializer) =>
+        new Handle<THandle>(new IntPtr(serializer.Deserialize<long>(reader)));
+
+    public override void WriteJson(JsonWriter writer, Handle<THandle> value, JsonSerializer serializer) =>
+        serializer.Serialize(writer, value.Pointer.ToInt64());
+}

Framework/Intersect.Framework/Converters/Json/HandleSystemJsonConverterFactory.cs

@@ -0,0 +1,30 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace Intersect.Framework.Converters.Json;
+
+/// <summary>
+/// Creates <see cref="JsonConverter{T}"/> instances for <see cref="Id{T}"/>.
+/// </summary>
+public sealed class HandleSystemJsonConverterFactory : GenericSystemJsonConverterFactory
+{
+    public HandleSystemJsonConverterFactory() : base(
+        typeof(HandleJsonConverter<>),
+        typeof(Handle<>)
+    )
+    {
+    }
+
+    private class HandleJsonConverter<T> : JsonConverter<Handle<T>>
+    {
+        public override Handle<T> Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+        {
+            return new Handle<T>(new IntPtr(reader.GetInt64()));
+        }
+
+        public override void Write(Utf8JsonWriter writer, Handle<T> value, JsonSerializerOptions options)
+        {
+            writer.WriteNumberValue(value.Pointer.ToInt64());
+        }
+    }
+}

Framework/Intersect.Framework/Converters/Json/IdNewtonsoftJsonConverter.cs

@@ -0,0 +1,23 @@
+using Newtonsoft.Json;
+
+namespace Intersect.Framework.Converters.Json;
+
+public sealed class IdNewtonsoftJsonConverter : GenericFactoryNewtonsoftJsonConverter
+{
+    public IdNewtonsoftJsonConverter() : base(
+        typeof(IdNewtonsoftJsonConverter<>),
+        typeof(Id<>)
+    )
+    {
+    }
+}
+
+public class IdNewtonsoftJsonConverter<TId> : JsonConverter<Id<TId>>
+{
+    public override Id<TId> ReadJson(JsonReader reader, Type objectType, Id<TId> existingValue, bool hasExistingValue,
+        JsonSerializer serializer) =>
+        new Id<TId>(serializer.Deserialize<Guid>(reader));
+
+    public override void WriteJson(JsonWriter writer, Id<TId> value, JsonSerializer serializer) =>
+        serializer.Serialize(writer, value.Guid);
+}

Framework/Intersect.Framework/Converters/Json/IdSystemJsonConverterFactory.cs

@@ -0,0 +1,26 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace Intersect.Framework.Converters.Json;
+
+/// <summary>
+/// Creates <see cref="JsonConverter{T}"/> instances for <see cref="Id{T}"/>.
+/// </summary>
+public sealed class IdSystemJsonConverterFactory : GenericSystemJsonConverterFactory
+{
+    public IdSystemJsonConverterFactory() : base(
+        typeof(IdJsonConverter<>),
+        typeof(Id<>)
+    )
+    {
+    }
+
+    private class IdJsonConverter<T> : JsonConverter<Id<T>>
+    {
+        public override Id<T> Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) =>
+            new Id<T>(reader.GetGuid());
+
+        public override void Write(Utf8JsonWriter writer, Id<T> value, JsonSerializerOptions options) =>
+            writer.WriteStringValue(value.Guid);
+    }
+}

Framework/Intersect.Framework/Eventing/AggregateSender.cs

@@ -0,0 +1,17 @@
+namespace Intersect.Framework.Eventing;
+
+public sealed record AggregateSender : IAggregateSender
+{
+    // ReSharper disable once ConvertToPrimaryConstructor
+    public AggregateSender(object currentSender, object? originalSender)
+    {
+        CurrentSender = currentSender;
+        OriginalSender = originalSender;
+    }
+
+    /// <inheritdoc />
+    public object CurrentSender { get; }
+
+    /// <inheritdoc />
+    public object? OriginalSender { get; }
+}

Framework/Intersect.Framework/Eventing/AggregateSender`1.cs

@@ -0,0 +1,16 @@
+namespace Intersect.Framework.Eventing;
+
+public sealed class AggregateSender<T> : IAggregateSender<T> where T : notnull
+{
+    public AggregateSender(T currentSender, object? originalSender)
+    {
+        CurrentSender = currentSender;
+        OriginalSender = originalSender;
+    }
+
+    /// <inheritdoc />
+    public T CurrentSender { get; }
+
+    /// <inheritdoc />
+    public object? OriginalSender { get; }
+}