move ui lifetime to a manager for better lifetime control

(cherry picked from commit e41a26dbd2fb966b21757fa0248f6b4a4e716aad)

.dockerignore

@@ -0,0 +1,25 @@
+**/.dockerignore
+**/.env
+**/.git
+**/.gitignore
+**/.project
+**/.settings
+**/.toolstarget
+**/.vs
+**/.vscode
+**/.idea
+**/*.*proj.user
+**/*.dbmdl
+**/*.jfm
+**/azds.yaml
+**/bin
+**/charts
+**/docker-compose*
+**/Dockerfile*
+**/node_modules
+**/npm-debug.log
+**/obj
+**/secrets.dev.yaml
+**/values.dev.yaml
+LICENSE
+README.md

.github/workflows/release.yaml

@@ -2,68 +2,100 @@ name: Release
 
 on:
   push:
-    tags:
+    branches: [master]
-      - '*'
+
+env:
+  BUILD_CONFIGURATION: Release
+  DOTNET_NOLOGO: true
+  DOTNET_CLI_TELEMETRY_OPTOUT: true
 
 jobs:
-  build:
+  get-version:
-    name: Build
+    name: Get Version
     runs-on: ubuntu-latest
-    env:
+    outputs: 
-      TORCH_VERSION: ${{ github.ref_name }}
+      version: ${{ steps.version.outputs.version }}
-      BUILD_CONFIGURATION: Release
-      DOTNET_NOLOGO: true
-      DOTNET_CLI_TELEMETRY_OPTOUT: true
     steps:
       - uses: actions/checkout@master
         name: Checkout
+        with:
+          fetch-depth: 0
+          
+      - name: Git Version
+        id: version
+        uses: paulhatch/semantic-version@v5.3.0
+        with:
+          tag_prefix: ''
+          major_pattern: 'breaking:'
+          minor_pattern: 'feature:'
+  
+  build-nuget:
+    name: Build and Publish Nuget
+    runs-on: ubuntu-latest
+    needs: [get-version]
+    steps:
+      - uses: actions/checkout@master
+        name: Checkout
+          
       - uses: actions/setup-dotnet@v3
         name: Setup dotnet
         with:
-          dotnet-version: '7.0.x'
+          dotnet-version: '8.0.x'
-      - name: Add Gh Packages Nuget Source
+          
-        run: dotnet nuget add source "https://nuget.pkg.github.com/${{ github.repository_owner }}/index.json" --username ${{ github.actor }} --password ${{ secrets.GITHUB_TOKEN }} --store-password-in-clear-text --name github
       - name: Restore dependencies
         run: dotnet restore Torch.Server/Torch.Server.csproj --locked-mode
+
       - name: Build
-        run: dotnet build Torch.Server/Torch.Server.csproj --no-restore -c ${{ env.BUILD_CONFIGURATION }} /p:AssemblyVersion=${{ env.TORCH_VERSION }} /p:Version=${{ env.TORCH_VERSION }}
+        run: dotnet build Torch.Server/Torch.Server.csproj --no-restore -c ${{ env.BUILD_CONFIGURATION }} -p:Version="${{ needs.get-version.outputs.version }}" -p:AssemblyVersion="${{ needs.get-version.outputs.version }}"
+          
+      - run: dotnet pack -c Release ./Torch.API/Torch.API.csproj -o pack -p:Version="${{ needs.get-version.outputs.version }}" -p:AssemblyVersion="${{ needs.get-version.outputs.version }}" --no-build
+      - run: dotnet pack -c Release ./Torch/Torch.csproj -o pack -p:Version="${{ needs.get-version.outputs.version }}" -p:AssemblyVersion="${{ needs.get-version.outputs.version }}" --no-build
+      - run: dotnet pack -c Release ./Torch.Server/Torch.Server.csproj -o pack -p:Version="${{ needs.get-version.outputs.version }}" -p:AssemblyVersion="${{ needs.get-version.outputs.version }}" --no-build
+
+      - name: Install Sleet
+        run: dotnet tool install -g sleet --version 5.1.3
+      - name: Push Nuget Package
+        env:
+          SLEET_FEED_TYPE: s3
+          SLEET_FEED_PATH: https://nuget.storage.yandexcloud.net
+          SLEET_FEED_BUCKETNAME: nuget
+          SLEET_FEED_SERVICEURL: https://storage.yandexcloud.net
+          SLEET_FEED_ACCESSKEYID: ${{ secrets.S3_KEY_ID }}
+          SLEET_FEED_SECRETACCESSKEY: ${{ secrets.S3_KEY }}
+        run: /root/.dotnet/tools/sleet push ./pack
+  
+  build:
+    name: Build and Publish Package
+    runs-on: ubuntu-latest
+    needs: [get-version]
+    steps:
+      - uses: actions/checkout@master
+        name: Checkout
+          
+      - uses: actions/setup-dotnet@v3
+        name: Setup dotnet
+        with:
+          dotnet-version: '8.0.x'
+
+      - name: Restore dependencies
+        run: dotnet restore Torch.Server/Torch.Server.csproj --locked-mode -r win-x64
+        
       - name: Publish
-        run: dotnet publish Torch.Server/Torch.Server.csproj --no-build -r win-x64 --sc -c ${{ env.BUILD_CONFIGURATION }} -o ./publish
+        run: dotnet publish Torch.Server/Torch.Server.csproj --no-restore --sc -r win-x64 -c ${{ env.BUILD_CONFIGURATION }} -o ./publish -p:Version="${{ needs.get-version.outputs.version }}" -p:AssemblyVersion="${{ needs.get-version.outputs.version }}"
+      
       - uses: vimtor/action-zip@v1
         name: Zip Release
         with:
           files: publish/
-          dest: release.zip
+          dest: torch-server.zip
-      - name: Build Changelog
+      
-        id: build_changelog
+      - name: Create Release
-        uses: mikepenz/release-changelog-builder-action@v3
+        uses: akkuman/gitea-release-action@v1
         env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          NODE_OPTIONS: '--experimental-fetch' # if nodejs < 18
         with:
-          commitMode: true
+          tag_name: ${{ needs.get-version.outputs.version }}
-      - name: Create release
+          name: Release v${{ needs.get-version.outputs.version }}
-        id: create_release
-        uses: actions/create-release@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          tag_name: ${{ env.TORCH_VERSION }}
-          release_name: Release v${{ env.TORCH_VERSION }}
           body: ${{ steps.github_release.outputs.changelog }}
-          draft: true
+          files: |-
-          prerelease: false
+            ./torch-server.zip
-      - name: Upload release asset
-        uses: actions/upload-release-asset@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          upload_url: ${{ steps.create_release.outputs.upload_url }}
-          asset_path: release.zip
-          asset_name: torch-server.zip
-          asset_content_type: application/zip
-      - name: Publish release
-        uses: StuYarrow/publish-release@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          id: ${{ steps.create_release.outputs.id }}

.gitignore

@@ -159,10 +159,6 @@ publish/
 
 # NuGet Packages
 *.nupkg
-# The packages folder can be ignored because of Package Restore
-**/packages/*
-# except build/, which is used as an MSBuild target.
-!**/packages/build/
 # Uncomment if necessary however generally it will be regenerated when needed
 #!**/packages/repositories.config
 # NuGet v3's project.json files produces more ignoreable files

Directory.Build.props

@@ -0,0 +1,8 @@
+<Project>
+    <PropertyGroup>
+        <TargetFramework>net8.0-windows</TargetFramework>
+        <RuntimeIdentifier>win-x64</RuntimeIdentifier>
+        <RestorePackagesWithLockFile>true</RestorePackagesWithLockFile>
+        <EnableWindowsTargeting>true</EnableWindowsTargeting>
+    </PropertyGroup>
+</Project>

Dockerfile

@@ -0,0 +1,38 @@
+FROM mcr.microsoft.com/dotnet/runtime:8.0-windowsservercore-ltsc2022 AS base
+USER $APP_UID
+WORKDIR /app
+
+FROM mcr.microsoft.com/dotnet/sdk:8.0-windowsservercore-ltsc2022 AS build
+ARG BUILD_CONFIGURATION=Release
+WORKDIR /src
+COPY ["NuGet.config", "."]
+COPY ["Directory.Build.props", "."]
+COPY ["Torch.API/Torch.API.csproj", "Torch.API/"]
+COPY ["Torch/Torch.csproj", "Torch/"]
+COPY ["Torch.Server/Torch.Server.csproj", "Torch.Server/"]
+RUN dotnet restore "Torch.Server/Torch.Server.csproj" --locked-mode
+COPY . .
+WORKDIR "/src/Torch.Server"
+RUN dotnet build "Torch.Server.csproj" -c %BUILD_CONFIGURATION% -o /app/build
+
+FROM build AS publish
+ARG BUILD_CONFIGURATION=Release
+RUN dotnet publish "Torch.Server.csproj" -c %BUILD_CONFIGURATION% -o /app/publish --no-self-contained  /p:UseAppHost=false
+
+FROM mcr.microsoft.com/windows/servercore:ltsc2022
+
+ADD ["https://aka.ms/dotnet/8.0/windowsdesktop-runtime-win-x64.exe", "installer.exe"]
+
+RUN installer.exe /install /quiet /norestart && del installer.exe
+
+ADD ["https://github.com/abbodi1406/vcredist/releases/latest/download/VisualCppRedist_AIO_x86_x64.exe", "vc.exe"]
+
+USER ContainerAdministrator
+
+RUN vc.exe /ai39 && del vc.exe
+
+USER ContainerUser
+
+WORKDIR /app
+COPY --from=publish /app/publish .
+ENTRYPOINT ["dotnet", "Torch.Server.dll"]

Torch.API/IPlayer.cs

@@ -1,11 +1,4 @@
-using System;
+namespace Torch.API
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using VRage.Game.ModAPI;
-
-namespace Torch.API
 {
     /// <summary>
     /// Represents a player on the server.

Torch.API/ITorchBase.cs

@@ -1,12 +1,10 @@
 using System;
-using System.Collections.Generic;
+using System.ComponentModel;
-using System.Linq;
 using System.Runtime.CompilerServices;
-using System.Text;
 using System.Threading.Tasks;
+using Microsoft.Extensions.Configuration;
 using Torch.API.Managers;
 using Torch.API.Session;
-using VRage.Game.ModAPI;
 using Version = SemanticVersioning.Version;
 
 namespace Torch.API
@@ -26,6 +24,11 @@ namespace Torch.API
         /// </summary>
         ITorchConfig Config { get; }
         
+        /// <summary>
+        /// Extended Configuration for the current instance.
+        /// </summary>
+        IConfiguration Configuration { get; }
+
         /// <inheritdoc cref="IPluginManager"/>
         [Obsolete]
         IPluginManager Plugins { get; }
@@ -138,6 +141,22 @@ namespace Torch.API
         event Action<ITorchServer> Initialized;
         
         TimeSpan ElapsedPlayTime { get; set; }
+
+        #region Backwards compat
+
+        /// <summary>
+        /// Path of the dedicated instance folder.
+        /// </summary>
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        new string InstancePath => ((ITorchBase)this).InstancePath;
+        
+        /// <summary>
+        /// Name of the dedicated instance.
+        /// </summary>
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        new string InstanceName => ((ITorchBase)this).InstanceName;
+
+        #endregion
     }
 
     /// <summary>

Torch.API/ITorchConfig.cs

@@ -33,6 +33,7 @@ namespace Torch
         bool EntityManagerEnabled { get; set; }
         string LoginToken { get; set; }
         UpdateSource UpdateSource { get; set; }
+        List<string> Packages { get; set; }
 
         void Save(string path = null);
     }

Torch.API/Managers/IChatManagerClient.cs

@@ -1,17 +1,9 @@
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 using Sandbox.Engine.Multiplayer;
 using Sandbox.Game.Gui;
-using Sandbox.Game.Multiplayer;
 using Torch.Utils;
 using VRage.Game;
-using VRage.Network;
-using VRage.Replication;
 using VRageMath;
-using VRageRender;
 
 namespace Torch.API.Managers
 {

Torch.API/Managers/IChatManagerServer.cs

@@ -1,11 +1,6 @@
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 using VRage.Collections;
 using VRage.Game;
-using VRage.Network;
 using VRageMath;
 
 namespace Torch.API.Managers

Torch.API/Managers/IDependencyManager.cs

@@ -1,8 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 
 namespace Torch.API.Managers
 {

Torch.API/Managers/IDependencyProvider.cs

@@ -1,8 +1,4 @@
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 
 namespace Torch.API.Managers
 {

Torch.API/Managers/IManager.cs

@@ -1,10 +1,4 @@
-using System;
+namespace Torch.API.Managers
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace Torch.API.Managers
 {
     /// <summary>
     /// Base interface for Torch managers.

Torch.API/Managers/IMultiplayerManagerBase.cs

@@ -1,7 +1,4 @@
 using System;
-using System.Collections.Generic;
-using System.Collections.ObjectModel;
-using VRage.Game;
 using VRage.Game.ModAPI;
 
 namespace Torch.API.Managers

Torch.API/Managers/IMultiplayerManagerClient.cs

@@ -1,10 +1,4 @@
-using System;
+namespace Torch.API.Managers
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace Torch.API.Managers
 {
     public interface IMultiplayerManagerClient : IMultiplayerManagerBase
     {

Torch.API/Managers/IMultiplayerManagerServer.cs

@@ -1,8 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 using VRage.Game.ModAPI;
 
 namespace Torch.API.Managers

Torch.API/Managers/INetworkManager.cs

@@ -1,9 +1,4 @@
-using System;
+using VRage;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using VRage;
 using VRage.Library.Collections;
 using VRage.Network;
 

Torch.API/Managers/IPackageManager.cs

@@ -0,0 +1,13 @@
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Reflection;
+using Torch.API.WebAPI.Plugins;
+
+namespace Torch.API.Managers;
+
+public interface IPackageManager : IManager
+{
+    IReadOnlySet<Package> Packages { get; }
+
+    bool TryGetPackageAssemblies(Package package, [MaybeNullWhen(false)] out Assembly[] assemblies);
+}

Torch.API/Managers/IPluginManager.cs

@@ -1,8 +1,6 @@
 using System;
 using System.Collections.Generic;
 using Torch.API.Plugins;
-using VRage.Collections;
-using VRage.Plugins;
 
 namespace Torch.API.Managers
 {
@@ -14,6 +12,9 @@ namespace Torch.API.Managers
         /// <summary>
         /// Fired when plugins are loaded.
         /// </summary>
+        /// <remarks>
+        /// Fired when plugins are loaded and immediately if subscribed after the plugins are loaded.
+        /// </remarks>
         event Action<IReadOnlyCollection<ITorchPlugin>> PluginsLoaded;
 
         /// <summary>

Torch.API/ModAPI/Ingame/GridExtensions.cs

@@ -1,14 +1,4 @@
-using System;
+namespace Torch.API.ModAPI.Ingame
-using System.Collections.Generic;
-using System.Collections.ObjectModel;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using Sandbox.Game.Entities.Blocks;
-using Sandbox.ModAPI.Ingame;
-using VRage.Game.ModAPI.Ingame;
-
-namespace Torch.API.ModAPI.Ingame
 {
     public static class GridExtensions
     {

Torch.API/ModAPI/TorchAPI.cs

@@ -1,9 +1,4 @@
-using System;
+using System.Runtime.CompilerServices;
-using System.Collections.Generic;
-using System.Linq;
-using System.Runtime.CompilerServices;
-using System.Text;
-using System.Threading.Tasks;
 
 //Needed so Torch can set the instance here without exposing anything bad to mods or creating a circular dependency.
 [assembly: InternalsVisibleTo("Torch")]

Torch.API/Plugins/ITorchPlugin.cs

@@ -1,9 +1,4 @@
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Security.Cryptography.X509Certificates;
-using System.Text;
-using System.Threading.Tasks;
 
 namespace Torch.API.Plugins
 {

Torch.API/Plugins/IWpfPlugin.cs

@@ -1,9 +1,4 @@
-using System;
+using System.Windows.Controls;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using System.Windows.Controls;
 
 namespace Torch.API.Plugins
 {

Torch.API/Plugins/PluginAttribute.cs

@@ -1,9 +1,4 @@
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Reflection;
-using System.Text;
-using System.Threading.Tasks;
 
 namespace Torch.API.Plugins
 {

Torch.API/ServerState.cs

@@ -1,10 +1,4 @@
-using System;
+namespace Torch.API
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace Torch.API
 {
     /// <summary>
     /// Used to indicate the state of the dedicated server.

Torch.API/Session/GameSaveResult.cs

@@ -1,10 +1,4 @@
-using System;
+namespace Torch.API.Session
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace Torch.API.Session
 {
     /// <summary>
     /// The result of a save operation

Torch.API/Session/ITorchSession.cs

@@ -1,9 +1,4 @@
-using System;
+using Sandbox.Game.World;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using Sandbox.Game.World;
 using Torch.API.Managers;
 
 namespace Torch.API.Session

Torch.API/Session/ITorchSessionManager.cs

@@ -1,9 +1,6 @@
 using System;
 using System.Collections.Generic;
 using System.ComponentModel;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 using Torch.API.Managers;
 using VRage.Game;
 

Torch.API/Session/TorchSessionState.cs

@@ -1,10 +1,4 @@
-using System;
+namespace Torch.API.Session
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace Torch.API.Session
 {
     /// <summary>
     /// Represents the state of a <see cref="ITorchSession"/>

Torch.API/Torch.API.csproj

@@ -1,14 +1,10 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <TargetFramework>net7-windows</TargetFramework>
     <AssemblyTitle>Torch API</AssemblyTitle>
     <Product>Torch</Product>
     <Copyright>Copyright © Torch API 2017</Copyright>
     <GenerateAssemblyConfigurationAttribute>false</GenerateAssemblyConfigurationAttribute>
-    <OutputPath>..\bin\$(Platform)\$(Configuration)\</OutputPath>
     <UseWpf>True</UseWpf>
-    <EnableWindowsTargeting>true</EnableWindowsTargeting>
-    <RestorePackagesWithLockFile>true</RestorePackagesWithLockFile>
   </PropertyGroup>
   
   <PropertyGroup Condition="$(Configuration) == 'Release'">
@@ -16,12 +12,15 @@
   </PropertyGroup>
   
   <ItemGroup>
-    <PackageReference Include="JorgeSerrano.Json.JsonSnakeCaseNamingPolicy" Version="0.9.0" />
+    <PackageReference Include="JetBrains.Annotations" Version="2024.2.0" />
-    <PackageReference Include="NLog" Version="5.1.0" />
+    <PackageReference Include="Microsoft.Extensions.Configuration.Binder" Version="8.0.2" />
+    <PackageReference Include="NLog" Version="5.3.3" />
+    <PackageReference Include="NuGet.Commands" Version="6.11.0" />
+    <PackageReference Include="NuGet.DependencyResolver.Core" Version="6.11.0" />
     <PackageReference Include="SemanticVersioning" Version="2.0.2" />
-    <PackageReference Include="SpaceEngineersDedicated.ReferenceAssemblies" Version="1.201.13">
+    <PackageReference Include="SpaceEngineersDedicated.ReferenceAssemblies" Version="1.*">
-      <PrivateAssets>all</PrivateAssets>
+      <ExcludeAssets>runtime</ExcludeAssets>
-      <IncludeAssets>compile</IncludeAssets>
     </PackageReference>
+    <PackageReference Include="System.Linq.Async" Version="6.0.1" />
   </ItemGroup>
 </Project>

Torch.API/TorchGameState.cs

@@ -1,9 +1,4 @@
-using System;
+using Sandbox;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using Sandbox;
 
 namespace Torch.API
 {

Torch.API/Utils/StringUtils.cs

@@ -3,7 +3,6 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
 using System.Text;
-using System.Threading.Tasks;
 
 namespace Torch.Utils
 {

Torch.API/WebAPI/Plugins/IPackageItem.cs

@@ -0,0 +1,11 @@
+#nullable enable
+using System.IO;
+using System.Threading.Tasks;
+
+namespace Torch.API.WebAPI.Plugins;
+
+public interface IPackageItem
+{
+    Task<Stream> OpenFileAsync();
+    public string FileName { get; }
+}

Torch.API/WebAPI/Plugins/IPackageReader.cs

@@ -0,0 +1,10 @@
+#nullable enable
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+namespace Torch.API.WebAPI.Plugins;
+
+public interface IPackageReader
+{
+    Task<(IEnumerable<IPackageItem> Root, IReadOnlyDictionary<PackageDependency, IEnumerable<IPackageItem>> Dependencies)> GetItemsAsync();
+}

Torch.API/WebAPI/Plugins/IPackageResolver.cs

@@ -0,0 +1,11 @@
+#nullable enable
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+namespace Torch.API.WebAPI.Plugins;
+
+public interface IPackageResolver
+{
+    Task<IEnumerable<Package>> ResolvePackagesAsync(IReadOnlyDictionary<string, string> packages);
+    Task<IPackageReader> GetPackageAsync(Package package);
+}

Torch.API/WebAPI/Plugins/NLogLogger.cs

@@ -0,0 +1,87 @@
+#nullable enable
+using System;
+using System.Threading.Tasks;
+using NuGet.Common;
+
+namespace Torch.API.WebAPI.Plugins;
+
+internal class NLogLogger : ILogger
+{
+    private readonly NLog.ILogger _logger;
+
+    public NLogLogger(NLog.ILogger logger)
+    {
+        _logger = logger;
+    }
+
+    public void LogDebug(string data)
+    {
+        _logger.Debug(data);
+    }
+
+    public void LogVerbose(string data)
+    {
+        _logger.Trace(data);
+    }
+
+    public void LogInformation(string data)
+    {
+        _logger.Info(data);
+    }
+
+    public void LogMinimal(string data)
+    {
+        _logger.Debug(data);
+    }
+
+    public void LogWarning(string data)
+    {
+        _logger.Warn(data);
+    }
+
+    public void LogError(string data)
+    {
+        _logger.Error(data);
+    }
+
+    public void LogInformationSummary(string data)
+    {
+        _logger.Info(data);
+    }
+
+    public void Log(LogLevel level, string data)
+    {
+        _logger.Log(ToNLogLevel(level), data);
+    }
+
+    private static NLog.LogLevel ToNLogLevel(LogLevel level)
+    {
+        return level switch
+        {
+            LogLevel.Debug => NLog.LogLevel.Debug,
+            LogLevel.Verbose => NLog.LogLevel.Trace,
+            LogLevel.Information => NLog.LogLevel.Info,
+            LogLevel.Minimal => NLog.LogLevel.Debug,
+            LogLevel.Warning => NLog.LogLevel.Warn,
+            LogLevel.Error => NLog.LogLevel.Error,
+            _ => throw new ArgumentOutOfRangeException(nameof(level), level, null)
+        };
+    }
+
+    public Task LogAsync(LogLevel level, string data)
+    {
+        Log(level, data);
+        return Task.CompletedTask;
+    }
+
+    public void Log(ILogMessage message)
+    {
+        _logger.Log(ToNLogLevel(message.Level), message.FormatWithCode);
+    }
+
+    public Task LogAsync(ILogMessage message)
+    {
+        Log(message);
+        return Task.CompletedTask;
+    }
+}

Torch.API/WebAPI/Plugins/Package.cs

@@ -0,0 +1,10 @@
+using System.Collections.Generic;
+using NuGet.DependencyResolver;
+using SemanticVersioning;
+
+namespace Torch.API.WebAPI.Plugins;
+
+public record Package(string Name, Version Version, IReadOnlySet<PackageDependency> Dependencies)
+{
+    internal GraphItem<RemoteResolveResult> Graph { get; init; }
+}

Torch.API/WebAPI/Plugins/PackageDependency.cs

@@ -0,0 +1,9 @@
+using NuGet.DependencyResolver;
+using SemanticVersioning;
+
+namespace Torch.API.WebAPI.Plugins;
+
+public record PackageDependency(string Name, Version Version, PackageDependencyKind Kind)
+{
+    internal RemoteMatch Match { get; init; }
+}

Torch.API/WebAPI/Plugins/PackageDependencyKind.cs

@@ -0,0 +1,8 @@
+namespace Torch.API.WebAPI.Plugins;
+
+public enum PackageDependencyKind
+{
+    None,
+    Transitive,
+    Direct
+}

Torch.API/WebAPI/Plugins/PackageReader.cs

@@ -0,0 +1,91 @@
+#nullable enable
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using NuGet.Common;
+using NuGet.DependencyResolver;
+using NuGet.Frameworks;
+using NuGet.Packaging;
+using NuGet.Protocol.Core.Types;
+using NuGet.Versioning;
+
+namespace Torch.API.WebAPI.Plugins;
+
+public class PackageReader : IPackageReader
+{
+    private readonly Package _package;
+    private readonly SourceCacheContext _cacheContext;
+    private readonly ILogger _logger;
+    private readonly NuGetFramework _framework;
+    private readonly IFrameworkCompatibilityProvider _compatibilityProvider;
+    private readonly DirectoryInfo _packagesDirectory;
+
+    public PackageReader(Package package, SourceCacheContext cacheContext, ILogger logger, NuGetFramework framework,
+                         IFrameworkCompatibilityProvider compatibilityProvider, DirectoryInfo packagesDirectory)
+    {
+        _package = package;
+        _cacheContext = cacheContext;
+        _logger = logger;
+        _framework = framework;
+        _compatibilityProvider = compatibilityProvider;
+        _packagesDirectory = packagesDirectory;
+    }
+
+    public async Task<(IEnumerable<IPackageItem> Root, IReadOnlyDictionary<PackageDependency, IEnumerable<IPackageItem>>
+            Dependencies)>
+        GetItemsAsync()
+    {
+        async Task<IEnumerable<IPackageItem>> GetPackageItemsAsync(string id, NuGetVersion version,
+                                                                   IRemoteDependencyProvider provider)
+        {
+            var downloader =
+                await provider.GetPackageDownloaderAsync(new(id, version), _cacheContext, _logger,
+                                                         CancellationToken.None);
+
+            await downloader.CopyNupkgFileToAsync(Path.Combine(_packagesDirectory.FullName, $"{id}.{version}.nupkg"),
+                                                  CancellationToken.None);
+
+            var frameworks = await downloader.ContentReader.GetReferenceItemsAsync(CancellationToken.None);
+            var items = frameworks.Where(b => _compatibilityProvider.IsCompatible(_framework, b.TargetFramework))
+                                  .MaxBy(b => b.TargetFramework.Version)?.Items;
+
+            return items?.Select(b => new PackageItem(b, downloader)) ?? ImmutableArray<PackageItem>.Empty;
+        }
+
+        var rootIdentity = _package.Graph.Key;
+        return (await GetPackageItemsAsync(rootIdentity.Name, rootIdentity.Version, _package.Graph.Data.Match.Provider),
+            await _package.Dependencies.ToAsyncEnumerable().SelectManyAwait(async b =>
+                                                                                (await GetPackageItemsAsync(
+                                                                                    b.Match.Library.Name,
+                                                                                    b.Match.Library.Version,
+                                                                                    b.Match.Provider))
+                                                                                .ToAsyncEnumerable()
+                                                                                .Select(c => (b, c)))
+                          .GroupBy(b => b.b, b => b.c)
+                          .ToDictionaryAwaitAsync<IAsyncGrouping<PackageDependency, IPackageItem>, PackageDependency,
+                              IEnumerable<IPackageItem>>(b => ValueTask.FromResult(b.Key),
+                                                         async b => await b.ToArrayAsync()));
+    }
+}
+
+file class PackageItem : IPackageItem
+{
+    private readonly string _path;
+    private readonly IPackageDownloader _downloader;
+
+    public string FileName => Path.GetFileName(_path);
+
+    public PackageItem(string path, IPackageDownloader downloader)
+    {
+        _path = path;
+        _downloader = downloader;
+    }
+
+    public Task<Stream> OpenFileAsync()
+    {
+        return _downloader.CoreReader.GetStreamAsync(_path, CancellationToken.None);
+    }
+}

Torch.API/WebAPI/Plugins/PackageResolver.cs

@@ -0,0 +1,104 @@
+#nullable enable
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using NLog;
+using NuGet.Commands;
+using NuGet.Configuration;
+using NuGet.DependencyResolver;
+using NuGet.Frameworks;
+using NuGet.LibraryModel;
+using NuGet.Protocol;
+using NuGet.Protocol.Core.Types;
+using NuGet.Versioning;
+using Version = SemanticVersioning.Version;
+
+namespace Torch.API.WebAPI.Plugins;
+
+public class PackageResolver : IPackageResolver
+{
+    private static readonly ILogger Log = LogManager.GetCurrentClassLogger();
+
+    private readonly NuGetFramework _framework = NuGetFramework.Parse("net7.0-windows7.0");
+    private readonly NLogLogger _logger = new(Log);
+    private readonly SourceCacheContext _sourceCacheContext = new();
+    private readonly RemoteWalkContext _remoteWalkContext;
+    private readonly DirectoryInfo _packagesDirectory;
+    private readonly IFrameworkCompatibilityProvider _compatibilityProvider = DefaultCompatibilityProvider.Instance;
+
+    public PackageResolver(IEnumerable<PackageSource> sources, DirectoryInfo packagesDirectory)
+    {
+        _packagesDirectory = packagesDirectory;
+        IReadOnlySet<PackageSource> packageSources = sources.Where(b => b.Type is PackageSourceType.NuGet).ToImmutableHashSet();
+
+        var mapping = new PackageSourceMapping(packageSources.ToDictionary(b => b.Name, b => b.Patterns));
+        _remoteWalkContext = new RemoteWalkContext(_sourceCacheContext, mapping, _logger);
+
+        foreach (var (name, url, _, _) in packageSources)
+        {
+            var packageSource = new NuGet.Configuration.PackageSource(url, name);
+            var sourceRepository = new SourceRepository(packageSource, new INuGetResourceProvider[]
+            {
+                new DownloadResourceV3Provider(),
+                new DependencyInfoResourceV3Provider(),
+                new ServiceIndexResourceV3Provider(),
+                new RemoteV3FindPackageByIdResourceProvider(),
+                new V3FeedListResourceProvider(),
+                new HttpSourceResourceProvider(),
+                new RegistrationResourceV3Provider(),
+                new HttpHandlerResourceV3Provider()
+            }.Select(b => new Lazy<INuGetResourceProvider>(b)), FeedType.HttpV3);
+
+            _remoteWalkContext.RemoteLibraryProviders.Add(
+                new SourceRepositoryDependencyProvider(sourceRepository, _logger, _sourceCacheContext, true, false));
+        }
+    }
+
+    public async Task<IEnumerable<Package>> ResolvePackagesAsync(
+        IReadOnlyDictionary<string, string> packages)
+    {
+        Log.Info("Restoring {0} packages", packages.Count);
+
+        var graphs = await Task.WhenAll(packages.Select(b =>
+        {
+            var (key, versionRange) = b;
+            var libraryRange = new LibraryRange(key, VersionRange.Parse(versionRange), LibraryDependencyTarget.All);
+            return ResolverUtility.FindLibraryEntryAsync(libraryRange, _framework, "win-x64",
+                                                         _remoteWalkContext, CancellationToken.None);
+        }));
+
+        return await graphs.ToAsyncEnumerable().SelectAwait(async graph =>
+        {
+            return new Package(graph.Key.Name, Version.Parse(graph.Key.Version.ToFullString()),
+                               await graph.Data.Dependencies
+                                          .ToAsyncEnumerable()
+                                          .SelectAwait(async b =>
+                                          {
+                                              var match = await ResolverUtility.FindLibraryByVersionAsync(
+                                                  b.LibraryRange, _framework, _remoteWalkContext.RemoteLibraryProviders,
+                                                  _sourceCacheContext, _logger, CancellationToken.None);
+
+                                              return new PackageDependency(
+                                                  b.Name, Version.Parse(match.Library.Version.ToFullString()),
+                                                  (PackageDependencyKind)b.ReferenceType)
+                                              {
+                                                  Match = match
+                                              };
+                                          })
+                                          .ToHashSetAsync())
+            {
+                Graph = graph
+            };
+        }).ToArrayAsync();
+    }
+
+    public Task<IPackageReader> GetPackageAsync(Package package)
+    {
+        var reader = new PackageReader(package, _sourceCacheContext, _logger, _framework, _compatibilityProvider, _packagesDirectory);
+        return Task.FromResult<IPackageReader>(reader);
+    }
+}

Torch.API/WebAPI/Plugins/PackageSource.cs

@@ -0,0 +1,8 @@
+using System.Collections.Generic;
+
+namespace Torch.API.WebAPI.Plugins;
+
+#nullable enable
+public record PackageSource
+#nullable restore
+    (string Name, string Url, IReadOnlyList<string> Patterns, PackageSourceType Type);

Torch.API/WebAPI/Plugins/PackageSourceType.cs

@@ -0,0 +1,8 @@
+#nullable enable
+namespace Torch.API.WebAPI.Plugins;
+
+public enum PackageSourceType
+{
+    NuGet,
+    LegacyTorch
+}

Torch.API/WebAPI/Update/GithubQuery.cs

@@ -5,7 +5,6 @@ using System.Net.Http;
 using System.Net.Http.Json;
 using System.Text.Json;
 using System.Threading.Tasks;
-using JorgeSerrano.Json;
 using Version = SemanticVersioning.Version;
 
 namespace Torch.API.WebAPI.Update;
@@ -38,7 +37,7 @@ public class GithubQuery : IUpdateQuery
     {
         var response = await _client.GetFromJsonAsync<Release>($"/repos/{repository}/releases/latest", new JsonSerializerOptions(JsonSerializerDefaults.Web)
         {
-            PropertyNamingPolicy = new JsonSnakeCaseNamingPolicy()
+            PropertyNamingPolicy = JsonNamingPolicy.SnakeCaseLower
         });
 
         if (response is null)

Torch.API/packages.lock.json

@@ -1,18 +1,50 @@
 {
   "version": 1,
   "dependencies": {
-    "net7.0-windows7.0": {
+    "net8.0-windows7.0": {
-      "JorgeSerrano.Json.JsonSnakeCaseNamingPolicy": {
+      "JetBrains.Annotations": {
         "type": "Direct",
-        "requested": "[0.9.0, )",
+        "requested": "[2024.2.0, )",
-        "resolved": "0.9.0",
+        "resolved": "2024.2.0",
-        "contentHash": "xCqODS+wzpUXNtg4bMMvXG5PLbP0iTwRzRn2R+zWHKm83E6tbV2bCagawXp1EnZeNpd5OXpMxehulZWns8efzQ=="
+        "contentHash": "GNnqCFW/163p1fOehKx0CnAqjmpPrUSqrgfHM6qca+P+RN39C9rhlfZHQpJhxmQG/dkOYe/b3Z0P8b6Kv5m1qw=="
+      },
+      "Microsoft.Extensions.Configuration.Binder": {
+        "type": "Direct",
+        "requested": "[8.0.2, )",
+        "resolved": "8.0.2",
+        "contentHash": "7IQhGK+wjyGrNsPBjJcZwWAr+Wf6D4+TwOptUt77bWtgNkiV8tDEbhFS+dDamtQFZ2X7kWG9m71iZQRj2x3zgQ==",
+        "dependencies": {
+          "Microsoft.Extensions.Configuration.Abstractions": "8.0.0"
+        }
       },
       "NLog": {
         "type": "Direct",
-        "requested": "[5.1.0, )",
+        "requested": "[5.3.3, )",
-        "resolved": "5.1.0",
+        "resolved": "5.3.3",
-        "contentHash": "oW7ekrkRG9okpDMUcEglunWj8Qf2RY8qkgl+/chJoavzg3dbT13y32t19R54FKkmq80fKzw4ZekZkCrRGanKgQ=="
+        "contentHash": "cy0+hlrUbYu+6mgUsILqCcqlJ2Csqyt2lm8y9T9kE8nhgwl8SvR+LM21QX4nmzFCPiowbrTFYxNF8+gWpy7/HQ=="
+      },
+      "NuGet.Commands": {
+        "type": "Direct",
+        "requested": "[6.11.0, )",
+        "resolved": "6.11.0",
+        "contentHash": "8GjJQZVbNJuttVynsRWsgqhTZiBbjxRr2PgZ3E7zPxDBmKUazkQ1s/FqScm83w8Xq5OdEtegkU0dZhibfRkKeg==",
+        "dependencies": {
+          "Microsoft.Extensions.FileProviders.Abstractions": "6.0.0",
+          "Microsoft.Extensions.FileSystemGlobbing": "6.0.0",
+          "NuGet.Credentials": "6.11.0",
+          "NuGet.ProjectModel": "6.11.0"
+        }
+      },
+      "NuGet.DependencyResolver.Core": {
+        "type": "Direct",
+        "requested": "[6.11.0, )",
+        "resolved": "6.11.0",
+        "contentHash": "SoiPKPooA+IF+iCsX1ykwi3M0e+yBL34QnwIP3ujhQEn1dhlP/N1XsYAnKkJPxV15EZCahuuS4HtnBsZx+CHKA==",
+        "dependencies": {
+          "NuGet.Configuration": "6.11.0",
+          "NuGet.LibraryModel": "6.11.0",
+          "NuGet.Protocol": "6.11.0"
+        }
       },
       "SemanticVersioning": {
         "type": "Direct",
@@ -22,17 +54,172 @@
       },
       "SpaceEngineersDedicated.ReferenceAssemblies": {
         "type": "Direct",
-        "requested": "[1.201.13, )",
+        "requested": "[1.*, )",
-        "resolved": "1.201.13",
+        "resolved": "1.205.23",
-        "contentHash": "FRXuNLENsz5jGQvL0QkogAGsxEJyUQlXhvWHBWfZiHCnCrAWMD60nEis6yt0xCQpazszfMtHonbxz72XMxnFoQ==",
+        "contentHash": "J7mF5hY39PzzCZps6vhIRzKiq8vD6Af9TgumTJR068vjEi+BzyeEFhqX+cl2Dd1ngOmsBtGWc5m+vxgTfs5YuA==",
         "dependencies": {
+          "SharpDX": "4.2.0-keen-cringe",
           "protobuf-net": "1.0.0"
         }
       },
+      "System.Linq.Async": {
+        "type": "Direct",
+        "requested": "[6.0.1, )",
+        "resolved": "6.0.1",
+        "contentHash": "0YhHcaroWpQ9UCot3Pizah7ryAzQhNvobLMSxeDIGmnXfkQn8u5owvpOH0K6EVB+z9L7u6Cc4W17Br/+jyttEQ==",
+        "dependencies": {
+          "Microsoft.Bcl.AsyncInterfaces": "6.0.0"
+        }
+      },
+      "Microsoft.Bcl.AsyncInterfaces": {
+        "type": "Transitive",
+        "resolved": "6.0.0",
+        "contentHash": "UcSjPsst+DfAdJGVDsu346FX0ci0ah+lw3WRtn18NUwEqRt70HaOQ7lI72vy3+1LxtqI3T5GWwV39rQSrCzAeg=="
+      },
+      "Microsoft.Extensions.Configuration.Abstractions": {
+        "type": "Transitive",
+        "resolved": "8.0.0",
+        "contentHash": "3lE/iLSutpgX1CC0NOW70FJoGARRHbyKmG7dc0klnUZ9Dd9hS6N/POPWhKhMLCEuNN5nXEY5agmlFtH562vqhQ==",
+        "dependencies": {
+          "Microsoft.Extensions.Primitives": "8.0.0"
+        }
+      },
+      "Microsoft.Extensions.FileProviders.Abstractions": {
+        "type": "Transitive",
+        "resolved": "6.0.0",
+        "contentHash": "0pd4/fho0gC12rQswaGQxbU34jOS1TPS8lZPpkFCH68ppQjHNHYle9iRuHeev1LhrJ94YPvzcRd8UmIuFk23Qw==",
+        "dependencies": {
+          "Microsoft.Extensions.Primitives": "6.0.0"
+        }
+      },
+      "Microsoft.Extensions.FileSystemGlobbing": {
+        "type": "Transitive",
+        "resolved": "6.0.0",
+        "contentHash": "ip8jnL1aPiaPeKINCqaTEbvBFDmVx9dXQEBZ2HOBRXPD1eabGNqP/bKlsIcp7U2lGxiXd5xIhoFcmY8nM4Hdiw=="
+      },
+      "Microsoft.Extensions.Primitives": {
+        "type": "Transitive",
+        "resolved": "8.0.0",
+        "contentHash": "bXJEZrW9ny8vjMF1JV253WeLhpEVzFo1lyaZu1vQ4ZxWUlVvknZ/+ftFgVheLubb4eZPSwwxBeqS1JkCOjxd8g=="
+      },
+      "Newtonsoft.Json": {
+        "type": "Transitive",
+        "resolved": "13.0.3",
+        "contentHash": "HrC5BXdl00IP9zeV+0Z848QWPAoCr9P3bDEZguI+gkLcBKAOxix/tLEAAHC+UvDNPv4a2d18lOReHMOagPa+zQ=="
+      },
+      "NuGet.Common": {
+        "type": "Transitive",
+        "resolved": "6.11.0",
+        "contentHash": "T3bCiKUSx8wdYpcqr6Dbx93zAqFp689ee/oa1tH22XI/xl7EUzQ7No/WlE1FUqvEX1+Mqar3wRNAn2O/yxo94g==",
+        "dependencies": {
+          "NuGet.Frameworks": "6.11.0"
+        }
+      },
+      "NuGet.Configuration": {
+        "type": "Transitive",
+        "resolved": "6.11.0",
+        "contentHash": "73QprQqmumFrv3Ooi4YWpRYeBj8jZy9gNdOaOCp4pPInpt41SJJAz/aP4je+StwIJvi5HsgPPecLKekDIQEwKg==",
+        "dependencies": {
+          "NuGet.Common": "6.11.0",
+          "System.Security.Cryptography.ProtectedData": "4.4.0"
+        }
+      },
+      "NuGet.Credentials": {
+        "type": "Transitive",
+        "resolved": "6.11.0",
+        "contentHash": "TeMvEyoqkIxDnYJjPCpD48vV5XoDATmyX2kGYYB2MIzWBT24ZjWauTda72hYBzg0OLLiuafxfnNJKGG6IHHzOQ==",
+        "dependencies": {
+          "NuGet.Protocol": "6.11.0"
+        }
+      },
+      "NuGet.Frameworks": {
+        "type": "Transitive",
+        "resolved": "6.11.0",
+        "contentHash": "Ew/mrfmLF5phsprysHbph2+tdZ10HMHAURavsr/Kx1WhybDG4vmGuoNLbbZMZOqnPRdpyCTc42OKWLoedxpYtA=="
+      },
+      "NuGet.LibraryModel": {
+        "type": "Transitive",
+        "resolved": "6.11.0",
+        "contentHash": "KUV2eeMICMb24OPcICn/wgncNzt6+W+lmFVO5eorTdo1qV4WXxYGyG1NTPiCY+Nrv5H/Ilnv9UaUM2ozqSmnjw==",
+        "dependencies": {
+          "NuGet.Common": "6.11.0",
+          "NuGet.Versioning": "6.11.0"
+        }
+      },
+      "NuGet.Packaging": {
+        "type": "Transitive",
+        "resolved": "6.11.0",
+        "contentHash": "VmUv2LedVuPY1tfNybORO2I9IuqOzeV7I5JBD+PwNvJq2bAqovi4FCw2cYI0g+kjOJXBN2lAJfrfnqtUOlVJdQ==",
+        "dependencies": {
+          "Newtonsoft.Json": "13.0.3",
+          "NuGet.Configuration": "6.11.0",
+          "NuGet.Versioning": "6.11.0",
+          "System.Security.Cryptography.Pkcs": "6.0.4"
+        }
+      },
+      "NuGet.ProjectModel": {
+        "type": "Transitive",
+        "resolved": "6.11.0",
+        "contentHash": "g0KtmDH6fas97WsN73yV2h1F5JT9o6+Y0wlPK+ij9YLKaAXaF6+1HkSaQMMJ+xh9/jCJG9G6nau6InOlb1g48g==",
+        "dependencies": {
+          "NuGet.DependencyResolver.Core": "6.11.0"
+        }
+      },
+      "NuGet.Protocol": {
+        "type": "Transitive",
+        "resolved": "6.11.0",
+        "contentHash": "p5B8oNLLnGhUfMbcS16aRiegj11pD6k+LELyRBqvNFR/pE3yR1XT+g1XS33ME9wvoU+xbCGnl4Grztt1jHPinw==",
+        "dependencies": {
+          "NuGet.Packaging": "6.11.0"
+        }
+      },
+      "NuGet.Versioning": {
+        "type": "Transitive",
+        "resolved": "6.11.0",
+        "contentHash": "v/GGlIj2dd7svplFmASWEueu62veKW0MrMtBaZ7QG8aJTSGv2yE+pgUGhXRcQ4nxNOEq/wLBrz1vkth/1SND7A=="
+      },
       "protobuf-net": {
         "type": "Transitive",
         "resolved": "1.0.0",
         "contentHash": "kTGOK0E87473sOImOjgZOnz3kTC2aMLffoRWQLYNuBLJnwNNmjanF9IkevZ9Q7yYLeABQfcF3BpeepuMntMVNw=="
+      },
+      "SharpDX": {
+        "type": "Transitive",
+        "resolved": "4.2.0-keen-cringe",
+        "contentHash": "LaJN3h1Gi1FWVdef2I5WtOH9gwzKCBniH0CragarbkN2QheYY6Lqm+91PcOfp1w/4wdVb+k8Kjv3sO393Tphtw=="
+      },
+      "System.Formats.Asn1": {
+        "type": "Transitive",
+        "resolved": "6.0.0",
+        "contentHash": "T6fD00dQ3NTbPDy31m4eQUwKW84s03z0N2C8HpOklyeaDgaJPa/TexP4/SkORMSOwc7WhKifnA6Ya33AkzmafA=="
+      },
+      "System.Security.Cryptography.Pkcs": {
+        "type": "Transitive",
+        "resolved": "6.0.4",
+        "contentHash": "LGbXi1oUJ9QgCNGXRO9ndzBL/GZgANcsURpMhNR8uO+rca47SZmciS3RSQUvlQRwK3QHZSHNOXzoMUASKA+Anw==",
+        "dependencies": {
+          "System.Formats.Asn1": "6.0.0"
+        }
+      },
+      "System.Security.Cryptography.ProtectedData": {
+        "type": "Transitive",
+        "resolved": "4.4.0",
+        "contentHash": "cJV7ScGW7EhatRsjehfvvYVBvtiSMKgN8bOVI0bQhnF5bU7vnHVIsH49Kva7i7GWaWYvmEzkYVk1TC+gZYBEog=="
+      }
+    },
+    "net8.0-windows7.0/win-x64": {
+      "System.Security.Cryptography.Pkcs": {
+        "type": "Transitive",
+        "resolved": "6.0.4",
+        "contentHash": "LGbXi1oUJ9QgCNGXRO9ndzBL/GZgANcsURpMhNR8uO+rca47SZmciS3RSQUvlQRwK3QHZSHNOXzoMUASKA+Anw==",
+        "dependencies": {
+          "System.Formats.Asn1": "6.0.0"
+        }
+      },
+      "System.Security.Cryptography.ProtectedData": {
+        "type": "Transitive",
+        "resolved": "4.4.0",
+        "contentHash": "cJV7ScGW7EhatRsjehfvvYVBvtiSMKgN8bOVI0bQhnF5bU7vnHVIsH49Kva7i7GWaWYvmEzkYVk1TC+gZYBEog=="
       }
     }
   }

Torch.Mod/Messages/DialogMessage.cs

@@ -1,8 +1,4 @@
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 using ProtoBuf;
 using Sandbox.ModAPI;
 

Torch.Mod/Messages/IncomingMessage.cs

@@ -1,26 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-
-namespace Torch.Mod.Messages
-{
-    /// <summary>
-    /// shim to store incoming message data
-    /// </summary>
-    internal class IncomingMessage : MessageBase
-    {
-        public IncomingMessage()
-        {
-        }
-
-        public override void ProcessClient()
-        {
-            throw new Exception();
-        }
-
-        public override void ProcessServer()
-        {
-            throw new Exception();
-        }
-    }
-}

Torch.Mod/Messages/JoinServerMessage.cs

@@ -1,7 +1,4 @@
-using System;
+using ProtoBuf;
-using System.Collections.Generic;
-using System.Text;
-using ProtoBuf;
 using Sandbox.ModAPI;
 
 namespace Torch.Mod.Messages
@@ -32,11 +29,6 @@ namespace Torch.Mod.Messages
 
         public override void ProcessClient()
         {
-            if (TorchModCore.Debug)
-            {
-                MyAPIGateway.Utilities.ShowMessage("Torch", $"Joining server {Address} with delay {Delay}");
-            }
-
             if (Delay <= 0)
             {
                 MyAPIGateway.Multiplayer.JoinServer(Address);

Torch.Mod/Messages/MessageBase.cs

@@ -1,9 +1,4 @@
-using System;
+using ProtoBuf;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using ProtoBuf;
 
 namespace Torch.Mod.Messages
 {
@@ -17,36 +12,9 @@ namespace Torch.Mod.Messages
     [ProtoContract]
     public abstract class MessageBase
     {
-        [ProtoMember(101)]
         public ulong SenderId;
 
         public abstract void ProcessClient();
         public abstract void ProcessServer();
-
-        //members below not serialized, they're just metadata about the intended target(s) of this message
-        internal MessageTarget TargetType;
-        internal ulong Target;
-        internal ulong[] Ignore;
-        internal byte[] CompressedData;
-    }
-    
-    public enum MessageTarget
-    {
-        /// <summary>
-        /// Send to Target
-        /// </summary>
-        Single,
-        /// <summary>
-        /// Send to Server
-        /// </summary>
-        Server,
-        /// <summary>
-        /// Send to all Clients (only valid from server)
-        /// </summary>
-        AllClients,
-        /// <summary>
-        /// Send to all except those steam ID listed in Ignore
-        /// </summary>
-        AllExcept,
     }
 }

Torch.Mod/Messages/NotificationMessage.cs

@@ -1,6 +1,4 @@
 using System;
-using System.Collections.Generic;
-using System.Text;
 using ProtoBuf;
 using Sandbox.ModAPI;
 

Torch.Mod/Messages/VoxelResetMessage.cs

@@ -1,6 +1,4 @@
 using System;
-using System.Collections.Generic;
-using System.Text;
 using ProtoBuf;
 using Sandbox.ModAPI;
 using VRage.ModAPI;

Torch.Mod/ModCommunication.cs

@@ -1,161 +1,50 @@
 using System;
-using System.Collections.Concurrent;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading;
-using System.Threading.Tasks;
 using Sandbox.ModAPI;
 using Torch.Mod.Messages;
-using VRage;
+using VRage.Game.Components;
-using VRage.Collections;
 using VRage.Game.ModAPI;
-using VRage.Network;
+#if TORCH
-using VRage.Utils;
+using Torch.Utils;
-using Task = ParallelTasks.Task;
+using VRage.Library.Collections;
+using System.Reflection;
+#endif
 
 namespace Torch.Mod
 {
-    public static class ModCommunication
+    [MySessionComponentDescriptor(MyUpdateOrder.AfterSimulation)]
+    public class ModCommunication : MySessionComponentBase
     {
-        public const ushort NET_ID = 4352;
+        public const ulong MOD_ID = 2915950488;
-        private static bool _closing = false;
+        private const ushort CHANNEL = 7654;
-        private static BlockingCollection<MessageBase> _processing;
-        private static MyConcurrentPool<IncomingMessage> _messagePool;
-        private static List<IMyPlayer> _playerCache;
 
-        public static void Register()
+        public override void BeforeStart()
         {
-            MyLog.Default.WriteLineAndConsole("TORCH MOD: Registering mod communication.");
+            base.BeforeStart();
-            _processing = new BlockingCollection<MessageBase>(new ConcurrentQueue<MessageBase>());
+            MyAPIGateway.Multiplayer.RegisterSecureMessageHandler(CHANNEL, MessageHandler);
-            _playerCache = new List<IMyPlayer>();
-            _messagePool = new MyConcurrentPool<IncomingMessage>(8);
-
-            MyAPIGateway.Multiplayer.RegisterMessageHandler(NET_ID, MessageHandler);
-            //background thread to handle de/compression and processing
-            _closing = false;
-            MyAPIGateway.Parallel.StartBackground(DoProcessing);
-            MyLog.Default.WriteLineAndConsole("TORCH MOD: Mod communication registered successfully.");
         }
 
-        public static void Unregister()
+        private void MessageHandler(ushort channel, byte[] data, ulong sender, bool fromServer)
         {
-            MyLog.Default.WriteLineAndConsole("TORCH MOD: Unregistering mod communication.");
+            if (!fromServer)
-            MyAPIGateway.Multiplayer?.UnregisterMessageHandler(NET_ID, MessageHandler);
+                return;
-            _processing?.CompleteAdding();
+
-            _closing = true;
+            var message = MyAPIGateway.Utilities.SerializeFromBinary<MessageBase>(data);
-            //_task.Wait();
+            message.SenderId = sender;
+            
+            if (MyAPIGateway.Multiplayer.IsServer) message.ProcessServer();
+            else message.ProcessClient();
         }
 
-        private static void MessageHandler(byte[] bytes)
-        {
-            var m = _messagePool.Get();
-            m.CompressedData = bytes;
 #if TORCH
-            m.SenderId = MyEventContext.Current.Sender.Value;
+        [ReflectedMethodInfo(typeof(MyAPIUtilities), "VRage.Game.ModAPI.IMyUtilities.SerializeToBinary")]
-#endif
+        private static MethodInfo _serializeMethod = null!;
 
-            _processing.Add(m);
+        private static readonly CacheList<IMyPlayer> Players = new();
-        }
 
-        public static void DoProcessing()
+        private static byte[] Serialize(MessageBase message)
         {
-            while (!_closing)
+            return (byte[])_serializeMethod.MakeGenericMethod(message.GetType())
-            {
+                                          .Invoke(MyAPIGateway.Utilities, new object[] { message });
-                try
-                {
-                    MessageBase m;
-                    try
-                    {
-                        m = _processing.Take();
-                    }
-                    catch
-                    {
-                        continue;
-                    }
-
-                    MyLog.Default.WriteLineAndConsole($"Processing message: {m.GetType().Name}");
-
-                    if (m is IncomingMessage) //process incoming messages
-                    {
-                        MessageBase i;
-                        try
-                        {
-                            var o = MyCompression.Decompress(m.CompressedData);
-                            m.CompressedData = null;
-                            _messagePool.Return((IncomingMessage)m);
-                            i = MyAPIGateway.Utilities.SerializeFromBinary<MessageBase>(o);
-                        }
-                        catch (Exception ex)
-                        {
-                            MyLog.Default.WriteLineAndConsole($"TORCH MOD: Failed to deserialize message! {ex}");
-                            continue;
-                        }
-
-                        if (TorchModCore.Debug)
-                            MyAPIGateway.Utilities.ShowMessage("Torch", $"Received message of type {i.GetType().Name}");
-
-                        if (MyAPIGateway.Multiplayer.IsServer)
-                            i.ProcessServer();
-                        else
-                            i.ProcessClient();
-                    }
-                    else //process outgoing messages
-                    {
-                        if (TorchModCore.Debug)
-                            MyAPIGateway.Utilities.ShowMessage("Torch", $"Sending message of type {m.GetType().Name}");
-
-                        var b = MyAPIGateway.Utilities.SerializeToBinary(m);
-                        m.CompressedData = MyCompression.Compress(b);
-
-                        switch (m.TargetType)
-                        {
-                            case MessageTarget.Single:
-                                MyAPIGateway.Multiplayer.SendMessageTo(NET_ID, m.CompressedData, m.Target);
-                                break;
-                            case MessageTarget.Server:
-                                MyAPIGateway.Multiplayer.SendMessageToServer(NET_ID, m.CompressedData);
-                                break;
-                            case MessageTarget.AllClients:
-                                MyAPIGateway.Players.GetPlayers(_playerCache);
-                                foreach (var p in _playerCache)
-                                {
-                                    if (p.SteamUserId == MyAPIGateway.Multiplayer.MyId)
-                                        continue;
-                                    MyAPIGateway.Multiplayer.SendMessageTo(NET_ID, m.CompressedData, p.SteamUserId);
-                                }
-
-                                break;
-                            case MessageTarget.AllExcept:
-                                MyAPIGateway.Players.GetPlayers(_playerCache);
-                                foreach (var p in _playerCache)
-                                {
-                                    if (p.SteamUserId == MyAPIGateway.Multiplayer.MyId || m.Ignore.Contains(p.SteamUserId))
-                                        continue;
-                                    MyAPIGateway.Multiplayer.SendMessageTo(NET_ID, m.CompressedData, p.SteamUserId);
-                                }
-
-                                break;
-                            default:
-                                throw new Exception();
-                        }
-
-                        _playerCache.Clear();
-                    }
-                }
-                catch (Exception ex)
-                {
-                    MyLog.Default.WriteLineAndConsole($"TORCH MOD: Exception occurred in communication thread! {ex}");
-                }
-            }
-
-            MyLog.Default.WriteLineAndConsole("TORCH MOD: INFO: Communication thread shut down successfully! THIS IS NOT AN ERROR");
-            //exit signal received. Clean everything and GTFO
-            _processing?.Dispose();
-            _processing = null;
-            _messagePool?.Clean();
-            _messagePool = null;
-            _playerCache = null;
         }
         
         public static void SendMessageTo(MessageBase message, ulong target)
@@ -163,12 +52,7 @@ namespace Torch.Mod
             if (!MyAPIGateway.Multiplayer.IsServer)
                 throw new Exception("Only server can send targeted messages");
 
-            if (_closing)
+            MyAPIGateway.Multiplayer.SendMessageTo(CHANNEL, Serialize(message), target);
-                return;
-
-            message.Target = target;
-            message.TargetType = MessageTarget.Single;
-            _processing.Add(message);
         }
 
         public static void SendMessageToClients(MessageBase message)
@@ -176,11 +60,7 @@ namespace Torch.Mod
             if (!MyAPIGateway.Multiplayer.IsServer)
                 throw new Exception("Only server can send targeted messages");
 
-            if (_closing)
+            MyAPIGateway.Multiplayer.SendMessageToOthers(CHANNEL, Serialize(message));
-                return;
-
-            message.TargetType = MessageTarget.AllClients;
-            _processing.Add(message);
         }
 
         public static void SendMessageExcept(MessageBase message, params ulong[] ignoredUsers)
@@ -188,21 +68,20 @@ namespace Torch.Mod
             if (!MyAPIGateway.Multiplayer.IsServer)
                 throw new Exception("Only server can send targeted messages");
 
-            if (_closing)
+            using var players = Players;
-                return;
+            MyAPIGateway.Multiplayer.Players.GetPlayers(players, player => !ignoredUsers.Contains(player.SteamUserId));
 
-            message.TargetType = MessageTarget.AllExcept;
+            var data = Serialize(message);
-            message.Ignore = ignoredUsers;
+            foreach (var player in players)
-            _processing.Add(message);
+            {
+                MyAPIGateway.Multiplayer.SendMessageTo(CHANNEL, data, player.SteamUserId);
+            }
         }
 
         public static void SendMessageToServer(MessageBase message)
         {
-            if (_closing)
+            throw new NotSupportedException();
-                return;
-
-            message.TargetType = MessageTarget.Server;
-            _processing.Add(message);
         }
+#endif
     }
 }

Torch.Mod/Torch.Mod.projitems

@@ -9,13 +9,11 @@
     <Import_RootNamespace>Torch.Mod</Import_RootNamespace>
   </PropertyGroup>
   <ItemGroup>
-    <Compile Include="$(MSBuildThisFileDirectory)Messages\IncomingMessage.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Messages\JoinServerMessage.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Messages\NotificationMessage.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Messages\DialogMessage.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Messages\MessageBase.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Messages\VoxelResetMessage.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)ModCommunication.cs" />
-    <Compile Include="$(MSBuildThisFileDirectory)TorchModCore.cs" />
   </ItemGroup>
 </Project>

Torch.Mod/TorchModCore.cs

@@ -1,51 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using Sandbox.ModAPI;
-using VRage.Game.Components;
-
-namespace Torch.Mod
-{
-    [MySessionComponentDescriptor(MyUpdateOrder.AfterSimulation)]
-    public class TorchModCore : MySessionComponentBase
-    {
-        public const ulong MOD_ID = 2722000298;
-        private static bool _init;
-        public static bool Debug;
-
-        public override void UpdateAfterSimulation()
-        {
-            if (_init)
-                return;
-
-            _init = true;
-            ModCommunication.Register();
-            MyAPIGateway.Utilities.MessageEntered += Utilities_MessageEntered;
-        }
-
-        private void Utilities_MessageEntered(string messageText, ref bool sendToOthers)
-        {
-            if (messageText == "@!debug")
-            {
-                Debug = !Debug;
-                MyAPIGateway.Utilities.ShowMessage("Torch", $"Debug: {Debug}");
-                sendToOthers = false;
-            }
-        }
-
-        protected override void UnloadData()
-        {
-            try
-            {
-                MyAPIGateway.Utilities.MessageEntered -= Utilities_MessageEntered;
-                ModCommunication.Unregister();
-            }
-            catch
-            {
-                //session unloading, don't care
-            }
-        }
-    }
-}

Torch.Server.Tests/Torch.Server.Tests.csproj

@@ -1,6 +1,5 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <TargetFramework>net7-windows</TargetFramework>
     <NoWarn>1591,0649</NoWarn>
     <AssemblyTitle>Torch Server Tests</AssemblyTitle>
     <Product>Torch</Product>
@@ -8,24 +7,15 @@
     <GenerateAssemblyConfigurationAttribute>false</GenerateAssemblyConfigurationAttribute>
     <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
     <OutputPath>$(SolutionDir)\bin-test\$(Platform)\$(Configuration)\</OutputPath>
-    <PlatformTarget>x64</PlatformTarget>
-    <Configurations>Debug;Release</Configurations>
-    <Platforms>AnyCPU</Platforms>
   </PropertyGroup>
   <PropertyGroup Condition="$(Configuration) == 'Release'">
     <DocumentationFile>$(SolutionDir)\bin-test\$(Platform)\$(Configuration)\Torch.Server.Tests.xml</DocumentationFile>
   </PropertyGroup>
 <!--   <Import Project="$(SolutionDir)\TransformOnBuild.targets" /> -->
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.4.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.11.0" />
-    <PackageReference Include="NLog" Version="5.1.0" />
+    <PackageReference Include="NLog" Version="5.3.3" />
-    <PackageReference Include="xunit" Version="2.4.2" />
+    <PackageReference Include="xunit" Version="2.9.0" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="VRage.Game, Version=1.0.0.0, Culture=neutral, processorArchitecture=MSIL">
-      <HintPath>..\GameBinaries\VRage.Game.dll</HintPath>
-      <SpecificVersion>False</SpecificVersion>
-    </Reference>
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\Torch.API\Torch.API.csproj" />

Torch.Server.Tests/TorchServerSessionSettingsTest.cs

@@ -2,8 +2,6 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
-using System.Text;
-using System.Threading.Tasks;
 using Torch.Server.ViewModels;
 using VRage.Game;
 using Xunit;

Torch.Server.Tests/packages.lock.json

@@ -0,0 +1,699 @@
+{
+  "version": 1,
+  "dependencies": {
+    "net8.0-windows7.0": {
+      "Microsoft.NET.Test.Sdk": {
+        "type": "Direct",
+        "requested": "[17.11.0, )",
+        "resolved": "17.11.0",
+        "contentHash": "fH7P0LihMXgnlNLtrXGetHd30aQcD+YrSbWXbCPBnrypdRApPgNqd/TgncTlSVY1bbLYdnvpBgts2dcnK37GzA==",
+        "dependencies": {
+          "Microsoft.CodeCoverage": "17.11.0",
+          "Microsoft.TestPlatform.TestHost": "17.11.0"
+        }
+      },
+      "NLog": {
+        "type": "Direct",
+        "requested": "[5.3.3, )",
+        "resolved": "5.3.3",
+        "contentHash": "cy0+hlrUbYu+6mgUsILqCcqlJ2Csqyt2lm8y9T9kE8nhgwl8SvR+LM21QX4nmzFCPiowbrTFYxNF8+gWpy7/HQ=="
+      },
+      "xunit": {
+        "type": "Direct",
+        "requested": "[2.9.0, )",
+        "resolved": "2.9.0",
+        "contentHash": "PtU3rZ0ThdmdJqTbK7GkgFf6iBaCR6Q0uvJHznID+XEYk2v6O/b7sRxqnbi3B2gRDXxjTqMkVNayzwsqsFUxRw==",
+        "dependencies": {
+          "xunit.analyzers": "1.15.0",
+          "xunit.assert": "2.9.0",
+          "xunit.core": "[2.9.0]"
+        }
+      },
+      "AutoCompleteTextBox": {
+        "type": "Transitive",
+        "resolved": "1.7.2",
+        "contentHash": "rslnIhQRK++Ty7epprYj861F8bo2N11TCUOgRs1r9mJ6w9HrhnQnE4zvUVm7xUsq8u5DCxR7cQtbAZ1txS2/Aw=="
+      },
+      "AvalonEdit": {
+        "type": "Transitive",
+        "resolved": "6.3.0.90",
+        "contentHash": "WVTb5MxwGqKdeasd3nG5udlV4t6OpvkFanziwI133K0/QJ5FvZmfzRQgpAjGTJhQfIA8GP7AzKQ3sTY9JOFk8Q=="
+      },
+      "Ben.Demystifier": {
+        "type": "Transitive",
+        "resolved": "0.4.1",
+        "contentHash": "axFeEMfmEORy3ipAzOXG/lE+KcNptRbei3F0C4kQCdeiQtW+qJW90K5iIovITGrdLt8AjhNCwk5qLSX9/rFpoA==",
+        "dependencies": {
+          "System.Reflection.Metadata": "5.0.0"
+        }
+      },
+      "ControlzEx": {
+        "type": "Transitive",
+        "resolved": "5.0.2",
+        "contentHash": "f724LoDJ36LxaLR62G4ek9ZAJI8BiiYRJJ04furC/qjXSeIwU0qmHFIe19xB1/FwxyZjevdFguEr9ZUjf3dZgw==",
+        "dependencies": {
+          "Microsoft.Xaml.Behaviors.Wpf": "1.1.31",
+          "System.Text.Json": "5.0.1"
+        }
+      },
+      "JetBrains.Annotations": {
+        "type": "Transitive",
+        "resolved": "2024.2.0",
+        "contentHash": "GNnqCFW/163p1fOehKx0CnAqjmpPrUSqrgfHM6qca+P+RN39C9rhlfZHQpJhxmQG/dkOYe/b3Z0P8b6Kv5m1qw=="
+      },
+      "Lib.Harmony.Thin": {
+        "type": "Transitive",
+        "resolved": "2.3.3-torch",
+        "contentHash": "djQtMUpURRgP+Ytf1EgQwu4XnJL3J3bz5kyTVcRDNb632N62/A4CbduG96CUsKhL944yGNAJnLX3zfWldPYOTw==",
+        "dependencies": {
+          "MonoMod.Core": "1.1.0",
+          "System.Text.Json": "8.0.1"
+        }
+      },
+      "MahApps.Metro": {
+        "type": "Transitive",
+        "resolved": "2.4.10",
+        "contentHash": "45exHKJCVYaD1/rNr3ekZPECEBM4uHOt6aYp6yNaJbliFMUo+d3z8Gi1xG+qEkbiHKITX+dlz+BW1FOsjAbl/w==",
+        "dependencies": {
+          "ControlzEx": "[4.4.0, 6.0.0)"
+        }
+      },
+      "MdXaml": {
+        "type": "Transitive",
+        "resolved": "1.27.0",
+        "contentHash": "VWhqhCeKVkJe8vkPmXuGZlRX01WDrTugOLeUvJn18jH/8DrGGVBvtgIlJoELHD2f1DiEWqF3lxxjV55vnzE7Tg==",
+        "dependencies": {
+          "AvalonEdit": "6.3.0.90",
+          "MdXaml.Plugins": "1.27.0"
+        }
+      },
+      "MdXaml.Plugins": {
+        "type": "Transitive",
+        "resolved": "1.27.0",
+        "contentHash": "We7LtBdoukRg9mqTfa1f5n8z/GQPMKBRj3URk9DiMuqzIHkW1lTgK5njVPSScxsRt4YzW22423tSnLWNm2MJKg=="
+      },
+      "Microsoft.Bcl.AsyncInterfaces": {
+        "type": "Transitive",
+        "resolved": "8.0.0",
+        "contentHash": "3WA9q9yVqJp222P3x1wYIGDAkpjAku0TMUaaQV22g6L67AI0LdOIrVS7Ht2vJfLHGSPVuqN94vIr15qn+HEkHw=="
+      },
+      "Microsoft.CodeAnalysis.Analyzers": {
+        "type": "Transitive",
+        "resolved": "3.3.4",
+        "contentHash": "AxkxcPR+rheX0SmvpLVIGLhOUXAKG56a64kV9VQZ4y9gR9ZmPXnqZvHJnmwLSwzrEP6junUF11vuc+aqo5r68g=="
+      },
+      "Microsoft.CodeAnalysis.Common": {
+        "type": "Transitive",
+        "resolved": "4.11.0",
+        "contentHash": "djf8ujmqYImFgB04UGtcsEhHrzVqzHowS+EEl/Yunc5LdrYrZhGBWUTXoCF0NzYXJxtfuD+UVQarWpvrNc94Qg==",
+        "dependencies": {
+          "Microsoft.CodeAnalysis.Analyzers": "3.3.4",
+          "System.Collections.Immutable": "8.0.0",
+          "System.Reflection.Metadata": "8.0.0"
+        }
+      },
+      "Microsoft.CodeAnalysis.CSharp": {
+        "type": "Transitive",
+        "resolved": "4.11.0",
+        "contentHash": "6XYi2EusI8JT4y2l/F3VVVS+ISoIX9nqHsZRaG6W5aFeJ5BEuBosHfT/ABb73FN0RZ1Z3cj2j7cL28SToJPXOw==",
+        "dependencies": {
+          "Microsoft.CodeAnalysis.Analyzers": "3.3.4",
+          "Microsoft.CodeAnalysis.Common": "[4.11.0]",
+          "System.Collections.Immutable": "8.0.0",
+          "System.Reflection.Metadata": "8.0.0"
+        }
+      },
+      "Microsoft.CodeCoverage": {
+        "type": "Transitive",
+        "resolved": "17.11.0",
+        "contentHash": "QKcOSuw7MZG4XiQ+pCj+Ib6amOwoRDEO7e3DbxqXeOPXSnfyGXYoZQI8I140s1mKQVn1Vh+c5WlKvCvlgMovpg=="
+      },
+      "Microsoft.Diagnostics.NETCore.Client": {
+        "type": "Transitive",
+        "resolved": "0.2.410101",
+        "contentHash": "I4hMjlbPcM5R+M4ThD2Zt1z58M8uZnWkDbFLXHntOOAajajEucrw4XYNSaoi5rgoqksgxQ3g388Vof4QzUNwdQ==",
+        "dependencies": {
+          "Microsoft.Bcl.AsyncInterfaces": "1.1.0",
+          "Microsoft.Extensions.Logging": "2.1.1"
+        }
+      },
+      "Microsoft.Diagnostics.Runtime": {
+        "type": "Transitive",
+        "resolved": "3.1.512801",
+        "contentHash": "0lMUDr2oxNZa28D6NH5BuSQEe5T9tZziIkvkD44YkkCGQXPJqvFjLq5ZQq1hYLl3RjQJrY+hR0jFgap+EWPDTw==",
+        "dependencies": {
+          "Microsoft.Diagnostics.NETCore.Client": "0.2.410101"
+        }
+      },
+      "Microsoft.Extensions.Configuration": {
+        "type": "Transitive",
+        "resolved": "8.0.0",
+        "contentHash": "0J/9YNXTMWSZP2p2+nvl8p71zpSwokZXZuJW+VjdErkegAnFdO1XlqtA62SJtgVYHdKu3uPxJHcMR/r35HwFBA==",
+        "dependencies": {
+          "Microsoft.Extensions.Configuration.Abstractions": "8.0.0",
+          "Microsoft.Extensions.Primitives": "8.0.0"
+        }
+      },
+      "Microsoft.Extensions.Configuration.Abstractions": {
+        "type": "Transitive",
+        "resolved": "8.0.0",
+        "contentHash": "3lE/iLSutpgX1CC0NOW70FJoGARRHbyKmG7dc0klnUZ9Dd9hS6N/POPWhKhMLCEuNN5nXEY5agmlFtH562vqhQ==",
+        "dependencies": {
+          "Microsoft.Extensions.Primitives": "8.0.0"
+        }
+      },
+      "Microsoft.Extensions.Configuration.Binder": {
+        "type": "Transitive",
+        "resolved": "8.0.2",
+        "contentHash": "7IQhGK+wjyGrNsPBjJcZwWAr+Wf6D4+TwOptUt77bWtgNkiV8tDEbhFS+dDamtQFZ2X7kWG9m71iZQRj2x3zgQ==",
+        "dependencies": {
+          "Microsoft.Extensions.Configuration.Abstractions": "8.0.0"
+        }
+      },
+      "Microsoft.Extensions.Configuration.CommandLine": {
+        "type": "Transitive",
+        "resolved": "8.0.0",
+        "contentHash": "NZuZMz3Q8Z780nKX3ifV1fE7lS+6pynDHK71OfU4OZ1ItgvDOhyOC7E6z+JMZrAj63zRpwbdldYFk499t3+1dQ==",
+        "dependencies": {
+          "Microsoft.Extensions.Configuration": "8.0.0",
+          "Microsoft.Extensions.Configuration.Abstractions": "8.0.0"
+        }
+      },
+      "Microsoft.Extensions.Configuration.EnvironmentVariables": {
+        "type": "Transitive",
+        "resolved": "8.0.0",
+        "contentHash": "plvZ0ZIpq+97gdPNNvhwvrEZ92kNml9hd1pe3idMA7svR0PztdzVLkoWLcRFgySYXUJc3kSM3Xw3mNFMo/bxRA==",
+        "dependencies": {
+          "Microsoft.Extensions.Configuration": "8.0.0",
+          "Microsoft.Extensions.Configuration.Abstractions": "8.0.0"
+        }
+      },
+      "Microsoft.Extensions.Configuration.FileExtensions": {
+        "type": "Transitive",
+        "resolved": "8.0.0",
+        "contentHash": "McP+Lz/EKwvtCv48z0YImw+L1gi1gy5rHhNaNIY2CrjloV+XY8gydT8DjMR6zWeL13AFK+DioVpppwAuO1Gi1w==",
+        "dependencies": {
+          "Microsoft.Extensions.Configuration": "8.0.0",
+          "Microsoft.Extensions.Configuration.Abstractions": "8.0.0",
+          "Microsoft.Extensions.FileProviders.Abstractions": "8.0.0",
+          "Microsoft.Extensions.FileProviders.Physical": "8.0.0",
+          "Microsoft.Extensions.Primitives": "8.0.0"
+        }
+      },
+      "Microsoft.Extensions.Configuration.Xml": {
+        "type": "Transitive",
+        "resolved": "8.0.0",
+        "contentHash": "0iRltfE/Xbh6gs9DHiBMShrxhcpJLtF/+2OqW1OpUh1QLQuAvMy4cGElSeJx1/hF6IbsxYhakVgfCNU0Hsmcwg==",
+        "dependencies": {
+          "Microsoft.Extensions.Configuration": "8.0.0",
+          "Microsoft.Extensions.Configuration.Abstractions": "8.0.0",
+          "Microsoft.Extensions.Configuration.FileExtensions": "8.0.0",
+          "Microsoft.Extensions.FileProviders.Abstractions": "8.0.0",
+          "System.Security.Cryptography.Xml": "8.0.0"
+        }
+      },
+      "Microsoft.Extensions.DependencyInjection": {
+        "type": "Transitive",
+        "resolved": "8.0.0",
+        "contentHash": "V8S3bsm50ig6JSyrbcJJ8bW2b9QLGouz+G1miK3UTaOWmMtFwNNNzUf4AleyDWUmTrWMLNnFSLEQtxmxgNQnNQ==",
+        "dependencies": {
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "8.0.0"
+        }
+      },
+      "Microsoft.Extensions.DependencyInjection.Abstractions": {
+        "type": "Transitive",
+        "resolved": "8.0.0",
+        "contentHash": "cjWrLkJXK0rs4zofsK4bSdg+jhDLTaxrkXu4gS6Y7MAlCvRyNNgwY/lJi5RDlQOnSZweHqoyvgvbdvQsRIW+hg=="
+      },
+      "Microsoft.Extensions.FileProviders.Abstractions": {
+        "type": "Transitive",
+        "resolved": "8.0.0",
+        "contentHash": "ZbaMlhJlpisjuWbvXr4LdAst/1XxH3vZ6A0BsgTphZ2L4PGuxRLz7Jr/S7mkAAnOn78Vu0fKhEgNF5JO3zfjqQ==",
+        "dependencies": {
+          "Microsoft.Extensions.Primitives": "8.0.0"
+        }
+      },
+      "Microsoft.Extensions.FileProviders.Physical": {
+        "type": "Transitive",
+        "resolved": "8.0.0",
+        "contentHash": "UboiXxpPUpwulHvIAVE36Knq0VSHaAmfrFkegLyBZeaADuKezJ/AIXYAW8F5GBlGk/VaibN2k/Zn1ca8YAfVdA==",
+        "dependencies": {
+          "Microsoft.Extensions.FileProviders.Abstractions": "8.0.0",
+          "Microsoft.Extensions.FileSystemGlobbing": "8.0.0",
+          "Microsoft.Extensions.Primitives": "8.0.0"
+        }
+      },
+      "Microsoft.Extensions.FileSystemGlobbing": {
+        "type": "Transitive",
+        "resolved": "8.0.0",
+        "contentHash": "OK+670i7esqlQrPjdIKRbsyMCe9g5kSLpRRQGSr4Q58AOYEe/hCnfLZprh7viNisSUUQZmMrbbuDaIrP+V1ebQ=="
+      },
+      "Microsoft.Extensions.Logging": {
+        "type": "Transitive",
+        "resolved": "8.0.0",
+        "contentHash": "tvRkov9tAJ3xP51LCv3FJ2zINmv1P8Hi8lhhtcKGqM+ImiTCC84uOPEI4z8Cdq2C3o9e+Aa0Gw0rmrsJD77W+w==",
+        "dependencies": {
+          "Microsoft.Extensions.DependencyInjection": "8.0.0",
+          "Microsoft.Extensions.Logging.Abstractions": "8.0.0",
+          "Microsoft.Extensions.Options": "8.0.0"
+        }
+      },
+      "Microsoft.Extensions.Logging.Abstractions": {
+        "type": "Transitive",
+        "resolved": "8.0.0",
+        "contentHash": "arDBqTgFCyS0EvRV7O3MZturChstm50OJ0y9bDJvAcmEPJm0FFpFyjU/JLYyStNGGey081DvnQYlncNX5SJJGA==",
+        "dependencies": {
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "8.0.0"
+        }
+      },
+      "Microsoft.Extensions.Options": {
+        "type": "Transitive",
+        "resolved": "8.0.0",
+        "contentHash": "JOVOfqpnqlVLUzINQ2fox8evY2SKLYJ3BV8QDe/Jyp21u1T7r45x/R/5QdteURMR5r01GxeJSBBUOCOyaNXA3g==",
+        "dependencies": {
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "8.0.0",
+          "Microsoft.Extensions.Primitives": "8.0.0"
+        }
+      },
+      "Microsoft.Extensions.Primitives": {
+        "type": "Transitive",
+        "resolved": "8.0.0",
+        "contentHash": "bXJEZrW9ny8vjMF1JV253WeLhpEVzFo1lyaZu1vQ4ZxWUlVvknZ/+ftFgVheLubb4eZPSwwxBeqS1JkCOjxd8g=="
+      },
+      "Microsoft.TestPlatform.ObjectModel": {
+        "type": "Transitive",
+        "resolved": "17.11.0",
+        "contentHash": "PU+CC1yRzbR0IllrtdILaeep7WP5OIrvmWrvCMqG3jB1h4F6Ur7CYHl6ENbDVXPzEvygXh0GWbTyrbjfvgTpAg==",
+        "dependencies": {
+          "System.Reflection.Metadata": "1.6.0"
+        }
+      },
+      "Microsoft.TestPlatform.TestHost": {
+        "type": "Transitive",
+        "resolved": "17.11.0",
+        "contentHash": "KMzJO3dm3+9W8JRQ3IDviu0v7uXP5Lgii6TuxMc5m8ynaqcGnn7Y18cMb5AsP2xp59uUHO474WZrssxBdb8ZxQ==",
+        "dependencies": {
+          "Microsoft.TestPlatform.ObjectModel": "17.11.0",
+          "Newtonsoft.Json": "13.0.1"
+        }
+      },
+      "Microsoft.Xaml.Behaviors.Wpf": {
+        "type": "Transitive",
+        "resolved": "1.1.31",
+        "contentHash": "LZpuf82ACZWldmfMuv3CTUMDh3o0xo0uHUaybR5HgqVLDBJJ9RZLykplQ/bTJd0/VDt3EhD4iDgUgbdIUAM+Kg=="
+      },
+      "Mono.Cecil": {
+        "type": "Transitive",
+        "resolved": "0.11.5",
+        "contentHash": "fxfX+0JGTZ8YQeu1MYjbBiK2CYTSzDyEeIixt+yqKKTn7FW8rv7JMY70qevup4ZJfD7Kk/VG/jDzQQTpfch87g=="
+      },
+      "MonoMod.Backports": {
+        "type": "Transitive",
+        "resolved": "1.1.0",
+        "contentHash": "GUAjCrCZEddqHKHFA7Lh61PgTzoKY7gfBShFe0hQe0p8iynHhBK3TWGyRi+QIw/PGfaRPwx6c33CPGFURBVM6g==",
+        "dependencies": {
+          "MonoMod.ILHelpers": "1.0.1"
+        }
+      },
+      "MonoMod.Core": {
+        "type": "Transitive",
+        "resolved": "1.1.0",
+        "contentHash": "Ks8RntZGVcktr2QF/AovTEbuOkrgXz6omjrvT5LRveOIQJuy+IFuEQPBVWu+cSKVIoZD5XkpRFvlVrItgPIrXw==",
+        "dependencies": {
+          "Mono.Cecil": "0.11.5",
+          "MonoMod.Backports": "1.1.0",
+          "MonoMod.ILHelpers": "1.0.1",
+          "MonoMod.Utils": "25.0.4"
+        }
+      },
+      "MonoMod.ILHelpers": {
+        "type": "Transitive",
+        "resolved": "1.0.1",
+        "contentHash": "6djj/Hz+/eTomo1H/sJEJNxBz2ZdhXjvH0MOmyU2xRtbjaIfBQuyVV0zNUbJhMY/8qoWrz7WXfskfFhdaY0afA=="
+      },
+      "MonoMod.Utils": {
+        "type": "Transitive",
+        "resolved": "25.0.4",
+        "contentHash": "cB94MaZtFD9u4clYEFTwM4jGXnJnzXsxYF3yBpMZKHhXOas66tMF2frbdYte023i0MH4C5iRJbDjxHmA4x5VgA==",
+        "dependencies": {
+          "Mono.Cecil": "0.11.5",
+          "MonoMod.Backports": "1.1.0",
+          "MonoMod.ILHelpers": "1.0.1"
+        }
+      },
+      "Newtonsoft.Json": {
+        "type": "Transitive",
+        "resolved": "13.0.3",
+        "contentHash": "HrC5BXdl00IP9zeV+0Z848QWPAoCr9P3bDEZguI+gkLcBKAOxix/tLEAAHC+UvDNPv4a2d18lOReHMOagPa+zQ=="
+      },
+      "NuGet.Commands": {
+        "type": "Transitive",
+        "resolved": "6.11.0",
+        "contentHash": "8GjJQZVbNJuttVynsRWsgqhTZiBbjxRr2PgZ3E7zPxDBmKUazkQ1s/FqScm83w8Xq5OdEtegkU0dZhibfRkKeg==",
+        "dependencies": {
+          "Microsoft.Extensions.FileProviders.Abstractions": "6.0.0",
+          "Microsoft.Extensions.FileSystemGlobbing": "6.0.0",
+          "NuGet.Credentials": "6.11.0",
+          "NuGet.ProjectModel": "6.11.0"
+        }
+      },
+      "NuGet.Common": {
+        "type": "Transitive",
+        "resolved": "6.11.0",
+        "contentHash": "T3bCiKUSx8wdYpcqr6Dbx93zAqFp689ee/oa1tH22XI/xl7EUzQ7No/WlE1FUqvEX1+Mqar3wRNAn2O/yxo94g==",
+        "dependencies": {
+          "NuGet.Frameworks": "6.11.0"
+        }
+      },
+      "NuGet.Configuration": {
+        "type": "Transitive",
+        "resolved": "6.11.0",
+        "contentHash": "73QprQqmumFrv3Ooi4YWpRYeBj8jZy9gNdOaOCp4pPInpt41SJJAz/aP4je+StwIJvi5HsgPPecLKekDIQEwKg==",
+        "dependencies": {
+          "NuGet.Common": "6.11.0",
+          "System.Security.Cryptography.ProtectedData": "4.4.0"
+        }
+      },
+      "NuGet.Credentials": {
+        "type": "Transitive",
+        "resolved": "6.11.0",
+        "contentHash": "TeMvEyoqkIxDnYJjPCpD48vV5XoDATmyX2kGYYB2MIzWBT24ZjWauTda72hYBzg0OLLiuafxfnNJKGG6IHHzOQ==",
+        "dependencies": {
+          "NuGet.Protocol": "6.11.0"
+        }
+      },
+      "NuGet.DependencyResolver.Core": {
+        "type": "Transitive",
+        "resolved": "6.11.0",
+        "contentHash": "SoiPKPooA+IF+iCsX1ykwi3M0e+yBL34QnwIP3ujhQEn1dhlP/N1XsYAnKkJPxV15EZCahuuS4HtnBsZx+CHKA==",
+        "dependencies": {
+          "NuGet.Configuration": "6.11.0",
+          "NuGet.LibraryModel": "6.11.0",
+          "NuGet.Protocol": "6.11.0"
+        }
+      },
+      "NuGet.Frameworks": {
+        "type": "Transitive",
+        "resolved": "6.11.0",
+        "contentHash": "Ew/mrfmLF5phsprysHbph2+tdZ10HMHAURavsr/Kx1WhybDG4vmGuoNLbbZMZOqnPRdpyCTc42OKWLoedxpYtA=="
+      },
+      "NuGet.LibraryModel": {
+        "type": "Transitive",
+        "resolved": "6.11.0",
+        "contentHash": "KUV2eeMICMb24OPcICn/wgncNzt6+W+lmFVO5eorTdo1qV4WXxYGyG1NTPiCY+Nrv5H/Ilnv9UaUM2ozqSmnjw==",
+        "dependencies": {
+          "NuGet.Common": "6.11.0",
+          "NuGet.Versioning": "6.11.0"
+        }
+      },
+      "NuGet.Packaging": {
+        "type": "Transitive",
+        "resolved": "6.11.0",
+        "contentHash": "VmUv2LedVuPY1tfNybORO2I9IuqOzeV7I5JBD+PwNvJq2bAqovi4FCw2cYI0g+kjOJXBN2lAJfrfnqtUOlVJdQ==",
+        "dependencies": {
+          "Newtonsoft.Json": "13.0.3",
+          "NuGet.Configuration": "6.11.0",
+          "NuGet.Versioning": "6.11.0",
+          "System.Security.Cryptography.Pkcs": "6.0.4"
+        }
+      },
+      "NuGet.ProjectModel": {
+        "type": "Transitive",
+        "resolved": "6.11.0",
+        "contentHash": "g0KtmDH6fas97WsN73yV2h1F5JT9o6+Y0wlPK+ij9YLKaAXaF6+1HkSaQMMJ+xh9/jCJG9G6nau6InOlb1g48g==",
+        "dependencies": {
+          "NuGet.DependencyResolver.Core": "6.11.0"
+        }
+      },
+      "NuGet.Protocol": {
+        "type": "Transitive",
+        "resolved": "6.11.0",
+        "contentHash": "p5B8oNLLnGhUfMbcS16aRiegj11pD6k+LELyRBqvNFR/pE3yR1XT+g1XS33ME9wvoU+xbCGnl4Grztt1jHPinw==",
+        "dependencies": {
+          "NuGet.Packaging": "6.11.0"
+        }
+      },
+      "NuGet.Versioning": {
+        "type": "Transitive",
+        "resolved": "6.11.0",
+        "contentHash": "v/GGlIj2dd7svplFmASWEueu62veKW0MrMtBaZ7QG8aJTSGv2yE+pgUGhXRcQ4nxNOEq/wLBrz1vkth/1SND7A=="
+      },
+      "nulastudio.NetBeauty": {
+        "type": "Transitive",
+        "resolved": "2.1.4.5",
+        "contentHash": "hOluHDEPDlS/lmDrRAlv5Xaza+n7kBPOtkuS6nYm0k6npJLi/vlYhZwR/IhpV+lCRTiu4so4D61pSrtHdTiagw=="
+      },
+      "protobuf-net": {
+        "type": "Transitive",
+        "resolved": "1.0.0",
+        "contentHash": "kTGOK0E87473sOImOjgZOnz3kTC2aMLffoRWQLYNuBLJnwNNmjanF9IkevZ9Q7yYLeABQfcF3BpeepuMntMVNw=="
+      },
+      "SemanticVersioning": {
+        "type": "Transitive",
+        "resolved": "2.0.2",
+        "contentHash": "4EQgYdNZ92SyaO7YFk6olVnebF5V+jrHyMUjvPq89tLeMo8NSfgDF+6Zwq/lgh9j/0yfQp9Lkm0ZA0rUATCZFA=="
+      },
+      "SharpDX": {
+        "type": "Transitive",
+        "resolved": "4.2.0-keen-cringe",
+        "contentHash": "LaJN3h1Gi1FWVdef2I5WtOH9gwzKCBniH0CragarbkN2QheYY6Lqm+91PcOfp1w/4wdVb+k8Kjv3sO393Tphtw=="
+      },
+      "SixLabors.Core": {
+        "type": "Transitive",
+        "resolved": "1.0.0-beta0007",
+        "contentHash": "s9aPl6yxwcvoKRD0u0zjkCISZCCifbUi9/XVFjdvlx5Pt7vRYmGV0anq1EEftUjIEHbEu5aNBipbUSBIV2CE7w==",
+        "dependencies": {
+          "System.Runtime.CompilerServices.Unsafe": "4.5.1"
+        }
+      },
+      "SpaceEngineersDedicated.ReferenceAssemblies": {
+        "type": "Transitive",
+        "resolved": "1.205.23",
+        "contentHash": "J7mF5hY39PzzCZps6vhIRzKiq8vD6Af9TgumTJR068vjEi+BzyeEFhqX+cl2Dd1ngOmsBtGWc5m+vxgTfs5YuA==",
+        "dependencies": {
+          "SharpDX": "4.2.0-keen-cringe",
+          "protobuf-net": "1.0.0"
+        }
+      },
+      "System.CodeDom": {
+        "type": "Transitive",
+        "resolved": "8.0.0",
+        "contentHash": "WTlRjL6KWIMr/pAaq3rYqh0TJlzpouaQ/W1eelssHgtlwHAH25jXTkUphTYx9HaIIf7XA6qs/0+YhtLEQRkJ+Q=="
+      },
+      "System.Collections.Immutable": {
+        "type": "Transitive",
+        "resolved": "8.0.0",
+        "contentHash": "AurL6Y5BA1WotzlEvVaIDpqzpIPvYnnldxru8oXJU2yFxFUy3+pNXjXd1ymO+RA0rq0+590Q8gaz2l3Sr7fmqg=="
+      },
+      "System.ComponentModel.Annotations": {
+        "type": "Transitive",
+        "resolved": "5.0.0",
+        "contentHash": "dMkqfy2el8A8/I76n2Hi1oBFEbG1SfxD2l5nhwXV3XjlnOmwxJlQbYpJH4W51odnU9sARCSAgv7S3CyAFMkpYg=="
+      },
+      "System.Formats.Asn1": {
+        "type": "Transitive",
+        "resolved": "8.0.0",
+        "contentHash": "AJukBuLoe3QeAF+mfaRKQb2dgyrvt340iMBHYv+VdBzCUM06IxGlvl0o/uPOS7lHnXPN6u8fFRHSHudx5aTi8w=="
+      },
+      "System.Linq.Async": {
+        "type": "Transitive",
+        "resolved": "6.0.1",
+        "contentHash": "0YhHcaroWpQ9UCot3Pizah7ryAzQhNvobLMSxeDIGmnXfkQn8u5owvpOH0K6EVB+z9L7u6Cc4W17Br/+jyttEQ==",
+        "dependencies": {
+          "Microsoft.Bcl.AsyncInterfaces": "6.0.0"
+        }
+      },
+      "System.Management": {
+        "type": "Transitive",
+        "resolved": "8.0.0",
+        "contentHash": "jrK22i5LRzxZCfGb+tGmke2VH7oE0DvcDlJ1HAKYU8cPmD8XnpUT0bYn2Gy98GEhGjtfbR/sxKTVb+dE770pfA==",
+        "dependencies": {
+          "System.CodeDom": "8.0.0"
+        }
+      },
+      "System.Reflection.Metadata": {
+        "type": "Transitive",
+        "resolved": "8.0.0",
+        "contentHash": "ptvgrFh7PvWI8bcVqG5rsA/weWM09EnthFHR5SCnS6IN+P4mj6rE1lBDC4U8HL9/57htKAqy4KQ3bBj84cfYyQ==",
+        "dependencies": {
+          "System.Collections.Immutable": "8.0.0"
+        }
+      },
+      "System.Runtime.CompilerServices.Unsafe": {
+        "type": "Transitive",
+        "resolved": "4.5.1",
+        "contentHash": "Zh8t8oqolRaFa9vmOZfdQm/qKejdqz0J9kr7o2Fu0vPeoH3BL1EOXipKWwkWtLT1JPzjByrF19fGuFlNbmPpiw=="
+      },
+      "System.Security.Cryptography.Pkcs": {
+        "type": "Transitive",
+        "resolved": "8.0.0",
+        "contentHash": "ULmp3xoOwNYjOYp4JZ2NK/6NdTgiN1GQXzVVN1njQ7LOZ0d0B9vyMnhyqbIi9Qw4JXj1JgCsitkTShboHRx7Eg==",
+        "dependencies": {
+          "System.Formats.Asn1": "8.0.0"
+        }
+      },
+      "System.Security.Cryptography.ProtectedData": {
+        "type": "Transitive",
+        "resolved": "4.4.0",
+        "contentHash": "cJV7ScGW7EhatRsjehfvvYVBvtiSMKgN8bOVI0bQhnF5bU7vnHVIsH49Kva7i7GWaWYvmEzkYVk1TC+gZYBEog=="
+      },
+      "System.Security.Cryptography.Xml": {
+        "type": "Transitive",
+        "resolved": "8.0.0",
+        "contentHash": "HQSFbakswZ1OXFz2Bt3AJlC6ENDqWeVpgqhf213xqQUMDifzydOHIKVb1RV4prayobvR3ETIScMaQdDF2hwGZA==",
+        "dependencies": {
+          "System.Security.Cryptography.Pkcs": "8.0.0"
+        }
+      },
+      "System.Text.Encodings.Web": {
+        "type": "Transitive",
+        "resolved": "8.0.0",
+        "contentHash": "yev/k9GHAEGx2Rg3/tU6MQh4HGBXJs70y7j1LaM1i/ER9po+6nnQ6RRqTJn1E7Xu0fbIFK80Nh5EoODxrbxwBQ=="
+      },
+      "System.Text.Json": {
+        "type": "Transitive",
+        "resolved": "8.0.1",
+        "contentHash": "7AWk2za1hSEJBppe/Lg+uDcam2TrDqwIKa9XcPssSwyjC2xa39EKEGul3CO5RWNF+hMuZG4zlBDrvhBdDTg4lg==",
+        "dependencies": {
+          "System.Text.Encodings.Web": "8.0.0"
+        }
+      },
+      "Torch.SixLabors.ImageSharp": {
+        "type": "Transitive",
+        "resolved": "1.0.0-beta6",
+        "contentHash": "WJ7ocT79HgmuKi0+ltpvXTiMI80UcI3DeS8XSfYwJtTB1tcQws6zLPGuUwra6qe6qRrFfpABeDP3xvHV1rJgfg==",
+        "dependencies": {
+          "SixLabors.Core": "1.0.0-beta0007",
+          "System.Runtime.CompilerServices.Unsafe": "4.5.1"
+        }
+      },
+      "xunit.abstractions": {
+        "type": "Transitive",
+        "resolved": "2.0.3",
+        "contentHash": "pot1I4YOxlWjIb5jmwvvQNbTrZ3lJQ+jUGkGjWE3hEFM0l5gOnBWS+H3qsex68s5cO52g+44vpGzhAt+42vwKg=="
+      },
+      "xunit.analyzers": {
+        "type": "Transitive",
+        "resolved": "1.15.0",
+        "contentHash": "s+M8K/Rtlgr6CmD7AYQKrNTvT5sh0l0ZKDoZ3Z/ExhlIwfV9mGAMR4f7KqIB7SSK7ZOhqDTgTUMYPmKfmvWUWQ=="
+      },
+      "xunit.assert": {
+        "type": "Transitive",
+        "resolved": "2.9.0",
+        "contentHash": "Z/1pyia//860wEYTKn6Q5dmgikJdRjgE4t5AoxJkK8oTmidzPLEPG574kmm7LFkMLbH6Frwmgb750kcyR+hwoA=="
+      },
+      "xunit.core": {
+        "type": "Transitive",
+        "resolved": "2.9.0",
+        "contentHash": "uRaop9tZsZMCaUS4AfbSPGYHtvywWnm8XXFNUqII7ShWyDBgdchY6gyDNgO4AK1Lv/1NNW61Zq63CsDV6oH6Jg==",
+        "dependencies": {
+          "xunit.extensibility.core": "[2.9.0]",
+          "xunit.extensibility.execution": "[2.9.0]"
+        }
+      },
+      "xunit.extensibility.core": {
+        "type": "Transitive",
+        "resolved": "2.9.0",
+        "contentHash": "zjDEUSxsr6UNij4gIwCgMqQox+oLDPRZ+mubwWLci+SssPBFQD1xeRR4SvgBuXqbE0QXCJ/STVTp+lxiB5NLVA==",
+        "dependencies": {
+          "xunit.abstractions": "2.0.3"
+        }
+      },
+      "xunit.extensibility.execution": {
+        "type": "Transitive",
+        "resolved": "2.9.0",
+        "contentHash": "5ZTQZvmPLlBw6QzCOwM0KnMsZw6eGjbmC176QHZlcbQoMhGIeGcYzYwn5w9yXxf+4phtplMuVqTpTbFDQh2bqQ==",
+        "dependencies": {
+          "xunit.extensibility.core": "[2.9.0]"
+        }
+      },
+      "torch": {
+        "type": "Project",
+        "dependencies": {
+          "ControlzEx": "[5.0.2, )",
+          "Lib.Harmony.Thin": "[2.3.3-torch, )",
+          "MahApps.Metro": "[2.4.10, )",
+          "Microsoft.CodeAnalysis.CSharp": "[4.11.0, )",
+          "Microsoft.CodeAnalysis.Common": "[4.11.0, )",
+          "NLog": "[5.3.3, )",
+          "System.ComponentModel.Annotations": "[5.0.0, )",
+          "Torch.API": "[1.0.0, )",
+          "Torch.SixLabors.ImageSharp": "[1.0.0-beta6, )"
+        }
+      },
+      "torch.api": {
+        "type": "Project",
+        "dependencies": {
+          "JetBrains.Annotations": "[2024.2.0, )",
+          "Microsoft.Extensions.Configuration.Binder": "[8.0.2, )",
+          "NLog": "[5.3.3, )",
+          "NuGet.Commands": "[6.11.0, )",
+          "NuGet.DependencyResolver.Core": "[6.11.0, )",
+          "SemanticVersioning": "[2.0.2, )",
+          "SpaceEngineersDedicated.ReferenceAssemblies": "[1.*, )",
+          "System.Linq.Async": "[6.0.1, )"
+        }
+      },
+      "torch.server": {
+        "type": "Project",
+        "dependencies": {
+          "AutoCompleteTextBox": "[1.7.2, )",
+          "Ben.Demystifier": "[0.4.1, )",
+          "ControlzEx": "[5.0.2, )",
+          "MahApps.Metro": "[2.4.10, )",
+          "MdXaml": "[1.27.0, )",
+          "Microsoft.Bcl.AsyncInterfaces": "[8.0.0, )",
+          "Microsoft.Diagnostics.Runtime": "[3.1.512801, )",
+          "Microsoft.Extensions.Configuration.CommandLine": "[8.0.0, )",
+          "Microsoft.Extensions.Configuration.EnvironmentVariables": "[8.0.0, )",
+          "Microsoft.Extensions.Configuration.Xml": "[8.0.0, )",
+          "Microsoft.Extensions.Logging": "[8.0.0, )",
+          "NLog": "[5.3.3, )",
+          "System.ComponentModel.Annotations": "[5.0.0, )",
+          "System.Management": "[8.0.0, )",
+          "Torch": "[1.0.0, )",
+          "Torch.API": "[1.0.0, )",
+          "nulastudio.NetBeauty": "[2.1.4.5, )"
+        }
+      },
+      "torch.tests": {
+        "type": "Project",
+        "dependencies": {
+          "Microsoft.NET.Test.Sdk": "[17.11.0, )",
+          "NLog": "[5.3.3, )",
+          "Torch": "[1.0.0, )",
+          "Torch.API": "[1.0.0, )",
+          "xunit": "[2.9.0, )"
+        }
+      }
+    },
+    "net8.0-windows7.0/win-x64": {
+      "System.Management": {
+        "type": "Transitive",
+        "resolved": "8.0.0",
+        "contentHash": "jrK22i5LRzxZCfGb+tGmke2VH7oE0DvcDlJ1HAKYU8cPmD8XnpUT0bYn2Gy98GEhGjtfbR/sxKTVb+dE770pfA==",
+        "dependencies": {
+          "System.CodeDom": "8.0.0"
+        }
+      },
+      "System.Security.Cryptography.Pkcs": {
+        "type": "Transitive",
+        "resolved": "8.0.0",
+        "contentHash": "ULmp3xoOwNYjOYp4JZ2NK/6NdTgiN1GQXzVVN1njQ7LOZ0d0B9vyMnhyqbIi9Qw4JXj1JgCsitkTShboHRx7Eg==",
+        "dependencies": {
+          "System.Formats.Asn1": "8.0.0"
+        }
+      },
+      "System.Security.Cryptography.ProtectedData": {
+        "type": "Transitive",
+        "resolved": "4.4.0",
+        "contentHash": "cJV7ScGW7EhatRsjehfvvYVBvtiSMKgN8bOVI0bQhnF5bU7vnHVIsH49Kva7i7GWaWYvmEzkYVk1TC+gZYBEog=="
+      },
+      "System.Text.Encodings.Web": {
+        "type": "Transitive",
+        "resolved": "8.0.0",
+        "contentHash": "yev/k9GHAEGx2Rg3/tU6MQh4HGBXJs70y7j1LaM1i/ER9po+6nnQ6RRqTJn1E7Xu0fbIFK80Nh5EoODxrbxwBQ=="
+      }
+    }
+  }
+}

Torch.Server/Commands/WhitelistCommands.cs

@@ -1,9 +1,4 @@
-using System;
+using Torch.Commands;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using Torch.Commands;
 
 namespace Torch.Server.Commands
 {

Torch.Server/Initializer.cs

@@ -1,23 +1,13 @@
 using System;
-using System.Collections.Generic;
 using System.Diagnostics;
 using System.IO;
 using System.IO.Compression;
-using System.Linq;
-using System.Net;
 using System.Net.Http;
-using System.Reflection;
-using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
-using System.Windows;
 using System.Windows.Threading;
 using Microsoft.Extensions.Configuration;
 using NLog;
-using NLog.Targets;
-using Sandbox.Engine.Utils;
-using Torch.Utils;
-using VRage.FileSystem;
 
 namespace Torch.Server
 {
@@ -27,10 +17,10 @@ namespace Torch.Server
 
         private static readonly Logger Log = LogManager.GetLogger(nameof(Initializer));
         private bool _init;
-        private const string STEAMCMD_DIR = "steamcmd";
+        private const string TOOL_DIR = "tool";
-        private const string STEAMCMD_ZIP = "temp.zip";
+        private const string TOOL_ZIP = "temp.zip";
-        private static readonly string STEAMCMD_EXE = "steamcmd.exe";
+        private static readonly string TOOL_EXE = "steamcmd.exe";
-        private const string STEAMCMD_ARGS = "+force_install_dir \"{0}\" +login anonymous +app_update 298740 +quit";
+        private const string TOOL_ARGS = "+force_install_dir \"{0}\" +login anonymous +app_update 298740 +quit";
         private TorchServer _server;
 
         internal Persistent<TorchConfig> ConfigPersistent { get; }
@@ -56,8 +46,8 @@ namespace Torch.Server
             Log.Debug("Debug logging enabled.");
 #endif
             
-            if (!configuration.GetValue("noupdate", false))
+            if (configuration.GetValue("getGameUpdates", true) && !configuration.GetValue("noupdate", false))
-                RunSteamCmd(configuration);
+                RunSteamCmdAsync(configuration).Wait();
 
             var processPid = configuration.GetValue<int>("waitForPid");
             if (processPid != 0)
@@ -83,9 +73,9 @@ namespace Torch.Server
             return true;
         }
 
-        public void Run()
+        public void Run(IConfiguration configuration)
         {
-            _server = new TorchServer(Config, ApplicationContext.Current.InstanceDirectory.FullName, ApplicationContext.Current.InstanceName);
+            _server = new TorchServer(Config, ApplicationContext.Current.InstanceDirectory.FullName, ApplicationContext.Current.InstanceName, configuration);
 
             if (ApplicationContext.Current.IsService || Config.NoGui)
             {
@@ -102,53 +92,40 @@ namespace Torch.Server
                 }
 #endif
                 
-                var gameThread = new Thread(() =>
+                _server.Init();
-                {
-                    _server.Init();
 
-                    if (Config.Autostart || Config.TempAutostart)
+                if (!Config.Autostart && !Config.TempAutostart) return;
-                    {
-                        Config.TempAutostart = false;
-                        _server.Start();
-                    }
-                });
                 
-                gameThread.Start();
+                Config.TempAutostart = false;
-                
+                _server.Start();
-                var ui = new TorchUI(_server);
-                
-                SynchronizationContext.SetSynchronizationContext(
-                    new DispatcherSynchronizationContext(Dispatcher.CurrentDispatcher));
-                
-                ui.ShowDialog();
             }
         }
         
-        public static void RunSteamCmd(IConfiguration configuration)
+        public static async Task RunSteamCmdAsync(IConfiguration configuration)
         {
             var log = LogManager.GetLogger("SteamCMD");
             
-            var path = configuration.GetValue<string>("steamCmdPath") ?? ApplicationContext.Current.TorchDirectory
+            var path = configuration.GetValue<string>("steamToolPath") ?? ApplicationContext.Current.TorchDirectory
-                .CreateSubdirectory(STEAMCMD_DIR).FullName;
+                .CreateSubdirectory(TOOL_DIR).FullName;
 
             if (!Directory.Exists(path))
             {
                 Directory.CreateDirectory(path);
             }
             
-            var steamCmdExePath = Path.Combine(path, STEAMCMD_EXE);
+            var toolExe = Path.Combine(path, TOOL_EXE);
-            if (!File.Exists(steamCmdExePath))
+            if (!File.Exists(toolExe))
             {
                 try
                 {
                     log.Info("Downloading SteamCMD.");
                     using (var client = new HttpClient())
-                    using (var file = File.Create(STEAMCMD_ZIP))
+                    await using (var file = File.Create(TOOL_ZIP))
-                    using (var stream = client.GetStreamAsync("https://steamcdn-a.akamaihd.net/client/installer/steamcmd.zip").Result)
+                    await using (var stream = await client.GetStreamAsync("https://steamcdn-a.akamaihd.net/client/installer/steamcmd.zip"))
-                        stream.CopyTo(file);
+                        await stream.CopyToAsync(file);
 
-                    ZipFile.ExtractToDirectory(STEAMCMD_ZIP, path);
+                    ZipFile.ExtractToDirectory(TOOL_ZIP, path);
-                    File.Delete(STEAMCMD_ZIP);
+                    File.Delete(TOOL_ZIP);
                     log.Info("SteamCMD downloaded successfully!");
                 }
                 catch (Exception e)
@@ -159,21 +136,18 @@ namespace Torch.Server
             }
 
             log.Info("Checking for DS updates.");
-            var steamCmdProc = new ProcessStartInfo(steamCmdExePath)
+            var steamCmdProc = new ProcessStartInfo(toolExe)
             {
-                Arguments = string.Format(STEAMCMD_ARGS, configuration.GetValue("gamePath", "../")),
+                Arguments = string.Format(TOOL_ARGS, configuration.GetValue("gamePath", "../")),
                 WorkingDirectory = path,
-                UseShellExecute = false,
+                RedirectStandardOutput = true
-                RedirectStandardOutput = true,
-                StandardOutputEncoding = Encoding.ASCII
             };
-            var cmd = Process.Start(steamCmdProc);
+            var cmd = Process.Start(steamCmdProc)!;
             
-            // ReSharper disable once PossibleNullReferenceException
             while (!cmd.HasExited)
             {
-                log.Info(cmd.StandardOutput.ReadLine());
+                if (await cmd.StandardOutput.ReadLineAsync() is { } line)
-                Thread.Sleep(100);
+                    log.Info(line);
             }
         }
     }

Torch.Server/LogViewerTarget.cs

@@ -1,7 +1,6 @@
 using System.Collections.Generic;
 using System.Threading;
 using System.Windows.Media;
-using System.Windows.Threading;
 using NLog;
 using NLog.Targets;
 using Torch.Server.ViewModels;

Torch.Server/Managers/ConsoleCommandManager.cs

@@ -0,0 +1,54 @@
+using NLog;
+using System;
+using System.Threading;
+using Torch.API;
+using Torch.API.Managers;
+using Torch.Commands;
+using Torch.Managers;
+
+namespace Torch.Server.Managers
+{
+    internal class ConsoleCommandManager(ITorchBase torchInstance) : Manager(torchInstance)
+    {
+        private static readonly Logger Log = LogManager.GetCurrentClassLogger();
+
+        [Dependency]
+        private CommandManager _commandManager;
+
+        public override void Attach()
+        {
+            if (!Torch.Config.NoGui)
+                return;
+
+            Log.Info("Starting console command listener");
+
+            new Thread(CommandListener)
+            {
+                Name = "Console Command Listener",
+                IsBackground = true,
+            }.Start();
+        }
+
+        private void CommandListener()
+        {
+            while (Torch.GameState < TorchGameState.Unloading)
+            {
+                var line = Console.ReadLine();
+
+                if (line == null)
+                    break;
+
+                Torch.Invoke(() =>
+                {
+                    if (!_commandManager.HandleCommandFromServer(line, LogResponse))
+                        Log.Error("Invalid input '{0}'", line);
+                });
+            }
+        }
+
+        private void LogResponse(TorchChatMessage message)
+        {
+            Log.Info(message.Message);
+        }
+    }
+}

Torch.Server/Managers/EntityControlManager.cs

@@ -1,19 +1,13 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Reflection;
 using System.Runtime.CompilerServices;
-using System.Text;
-using System.Threading;
-using System.Threading.Tasks;
 using System.Windows.Controls;
 using NLog;
-using NLog.Fluent;
 using Torch.API;
 using Torch.Collections;
 using Torch.Managers;
 using Torch.Server.ViewModels.Entities;
-using Torch.Utils;
 
 namespace Torch.Server.Managers
 {

Torch.Server/Managers/InstanceManager.cs

@@ -1,20 +1,12 @@
 using System;
-using System.Collections.Generic;
-using System.Collections.ObjectModel;
-using System.ComponentModel;
 using System.IO;
 using System.Linq;
-using System.Reflection;
 using System.Runtime.Serialization;
-using System.Text;
+using System.Threading;
 using System.Threading.Tasks;
-using Havok;
 using NLog;
 using Sandbox;
-using Sandbox.Engine.Networking;
 using Sandbox.Engine.Utils;
-using Sandbox.Game;
-using Sandbox.Game.Gui;
 using Torch.API;
 using Torch.API.Managers;
 using Torch.Collections;
@@ -22,12 +14,10 @@ using Torch.Managers;
 using Torch.Mod;
 using Torch.Server.ViewModels;
 using Torch.Utils;
-using VRage;
 using VRage.FileSystem;
 using VRage.Game;
-using VRage.Game.ObjectBuilder;
 using VRage.ObjectBuilders;
-using VRage.Plugins;
+using VRage.ObjectBuilders.Private;
 
 namespace Torch.Server.Managers
 {
@@ -35,7 +25,45 @@ namespace Torch.Server.Managers
     {
         private const string CONFIG_NAME = "SpaceEngineers-Dedicated.cfg";
         
-        public event Action<ConfigDedicatedViewModel> InstanceLoaded;
+        private Action<ConfigDedicatedViewModel> _instanceLoaded;
+
+        /// <summary>
+        /// Gets or sets the instance loaded event.
+        /// </summary>
+        /// <remarks>
+        /// Called when the instance is loaded and immediately if subscribed after the instance is loaded.
+        /// </remarks>
+        public event Action<ConfigDedicatedViewModel> InstanceLoaded
+        {
+            add
+            {
+                var action = _instanceLoaded;
+                Action<ConfigDedicatedViewModel> action2;
+                do
+                {
+                    action2 = action;
+                    var action3 = (Action<ConfigDedicatedViewModel>)Delegate.Combine(action2, value);
+                    action = Interlocked.CompareExchange(ref _instanceLoaded, action3, action2);
+                }
+                while (action != action2);
+
+                if (DedicatedConfig is not null)
+                    value(DedicatedConfig);
+            }
+            remove
+            {
+                var action = _instanceLoaded;
+                Action<ConfigDedicatedViewModel> action2;
+                do
+                {
+                    action2 = action;
+                    var action3 = (Action<ConfigDedicatedViewModel>)Delegate.Remove(action2, value);
+                    action = Interlocked.CompareExchange(ref _instanceLoaded, action3, action2);
+                }
+                while (action != action2);
+            }
+        }
+
         public ConfigDedicatedViewModel DedicatedConfig { get; set; }
         private static readonly Logger Log = LogManager.GetLogger(nameof(InstanceManager));
         [Dependency]
@@ -100,9 +128,17 @@ namespace Torch.Server.Managers
                 return;
             }
 
-            SelectWorld(DedicatedConfig.LoadWorld ?? DedicatedConfig.Worlds.First().WorldPath, false);
+            var worldPath = DedicatedConfig.LoadWorld;
 
-            InstanceLoaded?.Invoke(DedicatedConfig);
+            if (worldPath == null)
+                worldPath = DedicatedConfig.Worlds.First().WorldPath;
+            else
+                // make sure we won't end up with a file path when we expect it to be a directory
+                worldPath = worldPath.EndsWith(".sbc") ? Path.GetDirectoryName(worldPath) : worldPath;
+
+            SelectWorld(worldPath, false);
+
+            _instanceLoaded?.Invoke(DedicatedConfig);
         }
 
         public void SelectCreatedWorld(string worldPath)
@@ -146,7 +182,7 @@ namespace Torch.Server.Managers
             {
                 DedicatedConfig.Mods.Clear();
                 //remove the Torch mod to avoid running multiple copies of it
-                DedicatedConfig.SelectedWorld.WorldConfiguration.Mods.RemoveAll(m => m.PublishedFileId == TorchModCore.MOD_ID);
+                DedicatedConfig.SelectedWorld.WorldConfiguration.Mods.RemoveAll(m => m.PublishedFileId == ModCommunication.MOD_ID);
                 foreach (var m in DedicatedConfig.SelectedWorld.WorldConfiguration.Mods)
                     DedicatedConfig.Mods.Add(new ModItemInfo(m));
                 Task.Run(() => DedicatedConfig.UpdateAllModInfosAsync());
@@ -161,7 +197,7 @@ namespace Torch.Server.Managers
             {
                 DedicatedConfig.Mods.Clear();
                 //remove the Torch mod to avoid running multiple copies of it
-                DedicatedConfig.SelectedWorld.WorldConfiguration.Mods.RemoveAll(m => m.PublishedFileId == TorchModCore.MOD_ID);
+                DedicatedConfig.SelectedWorld.WorldConfiguration.Mods.RemoveAll(m => m.PublishedFileId == ModCommunication.MOD_ID);
                 foreach (var m in DedicatedConfig.SelectedWorld.WorldConfiguration.Mods)
                     DedicatedConfig.Mods.Add(new ModItemInfo(m));
                 Task.Run(() => DedicatedConfig.UpdateAllModInfosAsync());
@@ -199,7 +235,7 @@ namespace Torch.Server.Managers
 
             try
             {
-                MyObjectBuilderSerializer.DeserializeXML(sandboxPath, out MyObjectBuilder_Checkpoint checkpoint, out ulong sizeInBytes);
+                MyObjectBuilderSerializerKeen.DeserializeXML(sandboxPath, out MyObjectBuilder_Checkpoint checkpoint, out ulong sizeInBytes);
                 if (checkpoint == null)
                 {
                     Log.Error($"Failed to load {DedicatedConfig.LoadWorld}, checkpoint null ({sizeInBytes} bytes, instance {Torch.Config.InstancePath})");
@@ -214,7 +250,7 @@ namespace Torch.Server.Managers
                 Log.Debug("Loaded mod list from world");
 
                 if (!modsOnly)
-                    DedicatedConfig.SessionSettings = new SessionSettingsViewModel(checkpoint.Settings);
+                    DedicatedConfig.SessionSettings = new DynamicViewModel<MyObjectBuilder_SessionSettings>(checkpoint.Settings);
             }
             catch (Exception e)
             {
@@ -324,22 +360,22 @@ namespace Torch.Server.Managers
         public void SaveSandbox()
         {
             using (var f = File.Open(_checkpointPath, FileMode.Create))
-                MyObjectBuilderSerializer.SerializeXML(f, Checkpoint);
+                MyObjectBuilderSerializerKeen.SerializeXML(f, Checkpoint);
 
             using (var f = File.Open(_worldConfigPath, FileMode.Create))
-                MyObjectBuilderSerializer.SerializeXML(f, WorldConfiguration);
+                MyObjectBuilderSerializerKeen.SerializeXML(f, WorldConfiguration);
         }
 
         public void LoadSandbox()
         {
-            if (!MyObjectBuilderSerializer.DeserializeXML(_checkpointPath, out MyObjectBuilder_Checkpoint checkpoint))
+            if (!MyObjectBuilderSerializerKeen.DeserializeXML(_checkpointPath, out MyObjectBuilder_Checkpoint checkpoint))
                 throw new SerializationException("Error reading checkpoint, see keen log for details");
             Checkpoint = new CheckpointViewModel(checkpoint);
             
             // migrate old saves
             if (File.Exists(_worldConfigPath))
             {
-                if (!MyObjectBuilderSerializer.DeserializeXML(_worldConfigPath, out MyObjectBuilder_WorldConfiguration worldConfig))
+                if (!MyObjectBuilderSerializerKeen.DeserializeXML(_worldConfigPath, out MyObjectBuilder_WorldConfiguration worldConfig))
                     throw new SerializationException("Error reading settings, see keen log for details");
                 WorldConfiguration = new WorldConfigurationViewModel(worldConfig);
             }

Torch.Server/Managers/MultiplayerManagerDedicated.cs

@@ -2,11 +2,8 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Net;
-using System.Reflection;
-using System.Text;
 using System.Threading.Tasks;
 using NLog;
-using NLog.Fluent;
 using Sandbox;
 using Sandbox.Engine.Multiplayer;
 using Sandbox.Engine.Networking;
@@ -16,12 +13,10 @@ using Torch.API;
 using Torch.API.Managers;
 using Torch.Managers;
 using Torch.Utils;
-using Torch.ViewModels;
 using VRage.Game;
 using VRage.Game.ModAPI;
 using VRage.GameServices;
 using VRage.Network;
-using VRage.Steam;
 
 namespace Torch.Server.Managers
 {

Torch.Server/Managers/MultiplayerManagerDedicatedEventShim.cs

@@ -1,10 +1,4 @@
-using System;
+using System.Threading.Tasks;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using NLog;
-using Sandbox;
 using Torch.API.Event;
 using Torch.Event;
 using VRage.Network;

Torch.Server/Managers/MultiplayerManagerDedicatedPatchShim.cs

@@ -1,10 +1,4 @@
-using System;
+using Sandbox.Engine.Multiplayer;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using NLog;
-using Sandbox.Engine.Multiplayer;
 using Torch.Managers.PatchManager;
 using Torch.API.Managers;
 
@@ -16,7 +10,7 @@ namespace Torch.Server.Managers
         public static void Patch(PatchContext ctx)
         {
             ctx.GetPattern(typeof(MyDedicatedServerBase).GetMethod(nameof(MyDedicatedServerBase.BanClient))).Prefixes.Add(typeof(MultiplayerManagerDedicatedPatchShim).GetMethod(nameof(BanPrefix)));
-            ctx.GetPattern(typeof(MyDedicatedServerBase).GetMethod(nameof(MyDedicatedServerBase.KickClient))).Prefixes.Add(typeof(MultiplayerManagerDedicatedPatchShim).GetMethod(nameof(KickPrefix)));
+            ctx.GetPattern(typeof(MyMultiplayerServerBase).GetMethod(nameof(MyMultiplayerServerBase.KickClient))).Prefixes.Add(typeof(MultiplayerManagerDedicatedPatchShim).GetMethod(nameof(KickPrefix)));
         }
 
         public static void BanPrefix(ulong userId, bool banned)

Torch.Server/Managers/RemoteAPIManager.cs

@@ -32,7 +32,7 @@ namespace Torch.Server.Managers
         {
             if (newstate == TorchGameState.Loading && MySandboxGame.ConfigDedicated.RemoteApiEnabled && !string.IsNullOrEmpty(MySandboxGame.ConfigDedicated.RemoteSecurityKey))
             {
-                var myRemoteServer = new MyRemoteServer(MySandboxGame.ConfigDedicated.RemoteApiPort, MySandboxGame.ConfigDedicated.RemoteSecurityKey);
+                var myRemoteServer = new MyRemoteServer(MySandboxGame.ConfigDedicated.RemoteApiIP, MySandboxGame.ConfigDedicated.RemoteApiPort, MySandboxGame.ConfigDedicated.RemoteSecurityKey);
                 LogManager.GetCurrentClassLogger().Info($"Remote API started on port {myRemoteServer.Port}");
             }
         }

Torch.Server/Managers/UiManager.cs

@@ -0,0 +1,37 @@
+using System.Threading;
+using System.Windows.Threading;
+using JetBrains.Annotations;
+using Torch.Managers;
+
+namespace Torch.Server.Managers;
+
+public class UiManager(TorchServer torchInstance) : Manager(torchInstance)
+{
+    [CanBeNull] private Thread _uiThread;
+    [CanBeNull] private Dispatcher _dispatcher;
+
+    public override void Attach()
+    {
+        _uiThread = new Thread(() =>
+        {
+            var ui = new TorchUI(torchInstance);
+
+            _dispatcher = Dispatcher.CurrentDispatcher;
+                
+            SynchronizationContext.SetSynchronizationContext(
+                new DispatcherSynchronizationContext(_dispatcher));
+
+            ui.ShowDialog();
+        });
+
+        _uiThread.SetApartmentState(ApartmentState.STA);
+        _uiThread.Start();
+    }
+
+    public override void Detach()
+    {
+        _dispatcher?.InvokeShutdown();
+        if (Thread.CurrentThread != _uiThread)
+            _uiThread?.Join();
+    }
+}

Torch.Server/NativeMethods.cs

@@ -1,9 +1,4 @@
-using System;
+using System.Runtime.InteropServices;
-using System.Collections.Generic;
-using System.Linq;
-using System.Runtime.InteropServices;
-using System.Text;
-using System.Threading.Tasks;
 
 namespace Torch.Server
 {

Torch.Server/Patches/PromotePatch.cs

@@ -1,9 +1,5 @@
 using System;
-using System.Collections.Generic;
-using System.Linq;
 using System.Reflection;
-using System.Text;
-using System.Threading.Tasks;
 using NLog;
 using Sandbox.Game.World;
 using Torch.Managers.PatchManager;

Torch.Server/Patches/ServerResponsePatch.cs

@@ -1,15 +1,10 @@
-using System;
 using System.Collections.Generic;
 using System.Reflection;
 using System.Reflection.Emit;
 using NLog;
 using Sandbox.Engine.Multiplayer;
-using Sandbox.Game.World;
-using Torch.API.Managers;
 using Torch.Managers.PatchManager;
 using Torch.Managers.PatchManager.MSIL;
-using Torch.Server.Managers;
-using VRage.Game.ModAPI;
 
 namespace Torch.Patches
 {
@@ -31,10 +26,18 @@ namespace Torch.Patches
             // Reduce response timeout from 100 seconds to 5 seconds.
             foreach (var instruction in instructions)
             {
-                if (instruction.OpCode == OpCodes.Ldc_I4 && instruction.Operand is MsilOperandInline.MsilOperandInt32 inlineI32 && inlineI32.Value == 1000)
+                if (instruction.OpCode == OpCodes.Ldc_I4 && instruction.Operand is 
+                        MsilOperandInline.MsilOperandInt32 { Value: 1000 } operandResponseTimeout)
                 {
                     _log.Info("Patching Steam response timeout to 5 seconds");
-                    inlineI32.Value = 50;
+                    operandResponseTimeout.Value = 50;
+                }
+                
+                if (instruction.OpCode == OpCodes.Ldc_I4 && instruction.Operand is 
+                        MsilOperandInline.MsilOperandInt32 { Value: 10000 } inlineI32)
+                {
+                    _log.Info("Patching Steam connect timeout to 60 seconds");
+                    inlineI32.Value = 60000;
                 }
 
                 yield return instruction;

Torch.Server/Patches/WorldLoadExceptionPatch.cs

@@ -1,5 +1,4 @@
 using System;
-using System.Collections;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;

Torch.Server/Program.cs

@@ -1,8 +1,6 @@
 using System;
 using System.IO;
 using Microsoft.Extensions.Configuration;
-using Microsoft.Extensions.Configuration.Xml;
-using NLog;
 using NLog.Config;
 using NLog.Targets;
 using Torch.API;
@@ -12,7 +10,7 @@ namespace Torch.Server
 {
     internal static class Program
     {
-        [STAThread]
+        [MTAThread]
         public static void Main(string[] args)
         {
             var configurationBuilder = new ConfigurationBuilder()
@@ -39,7 +37,7 @@ namespace Torch.Server
                 context.GameBinariesDirectory.FullName);
 #endif
 
-            initializer.Run();
+            initializer.Run(configuration);
         }
 
         private static void SetupLogging(IApplicationContext context, IConfiguration configuration)

Torch.Server/Torch.Server.csproj

@@ -1,26 +1,20 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>net7-windows</TargetFramework>
-    <RuntimeIdentifier>win-x64</RuntimeIdentifier>
-    <PublishUrl>publish\</PublishUrl>
     <UseApplicationTrust>false</UseApplicationTrust>
     <AssemblyTitle>Torch Server</AssemblyTitle>
     <Product>Torch</Product>
     <Copyright>Copyright © Torch API 2017</Copyright>
     <OutputPath>..\bin\$(Platform)\$(Configuration)\</OutputPath>
     <UseWPF>true</UseWPF>
+    <UseWindowsForms>true</UseWindowsForms>
     <SatelliteResourceLanguages>en</SatelliteResourceLanguages>
     <NeutralLanguage>en</NeutralLanguage>
-    <EnableWindowsTargeting>true</EnableWindowsTargeting>
     <TieredPGO>true</TieredPGO>
-    <RestorePackagesWithLockFile>true</RestorePackagesWithLockFile>
   </PropertyGroup>
   
   <PropertyGroup>
     <BeautyLibsDir>torch64</BeautyLibsDir>
-    <NoBeautyFlag>True</NoBeautyFlag>
-    <ForceBeauty>True</ForceBeauty>
   </PropertyGroup>
   
   <PropertyGroup>
@@ -32,29 +26,26 @@
   </PropertyGroup>
   
   <ItemGroup>
-    <PackageReference Include="AutoCompleteTextBox" Version="1.6.0" />
+    <PackageReference Include="AutoCompleteTextBox" Version="1.7.2" />
     <PackageReference Include="Ben.Demystifier" Version="0.4.1" />
     <PackageReference Include="ControlzEx" Version="5.0.2" />
-    <PackageReference Include="MahApps.Metro" Version="2.4.9" />
+    <PackageReference Include="MahApps.Metro" Version="2.4.10" />
-    <PackageReference Include="MdXaml" Version="1.16.2" />
+    <PackageReference Include="MdXaml" Version="1.27.0" />
-    <PackageReference Include="Microsoft.Diagnostics.Runtime" Version="2.2.343001" />
+    <PackageReference Include="Microsoft.Bcl.AsyncInterfaces" Version="8.0.0" />
-    <PackageReference Include="Microsoft.Extensions.Configuration.Binder" Version="7.0.0" />
+    <PackageReference Include="Microsoft.Diagnostics.Runtime" Version="3.1.512801" />
-    <PackageReference Include="Microsoft.Extensions.Configuration.CommandLine" Version="7.0.0" />
+    <PackageReference Include="Microsoft.Extensions.Configuration.CommandLine" Version="8.0.0" />
-    <PackageReference Include="Microsoft.Extensions.Configuration.EnvironmentVariables" Version="7.0.0" />
+    <PackageReference Include="Microsoft.Extensions.Configuration.EnvironmentVariables" Version="8.0.0" />
-    <PackageReference Include="Microsoft.Extensions.Configuration.Xml" Version="7.0.0" />
+    <PackageReference Include="Microsoft.Extensions.Configuration.Xml" Version="8.0.0" />
-    <PackageReference Include="NLog" Version="5.1.0" />
+    <PackageReference Include="Microsoft.Extensions.Logging" Version="8.0.0" />
-    <PackageReference Include="PropertyChanged.Fody" Version="4.0.3" PrivateAssets="all" />
+    <PackageReference Include="NLog" Version="5.3.3" />
-    <PackageReference Include="Steamworks.NET" Version="20.1.0">
+    <PackageReference Include="PropertyChanged.Fody" Version="4.1.0" PrivateAssets="all" />
+    <PackageReference Include="Steamworks.NET" Version="20.2.0">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>compile</IncludeAssets>
     </PackageReference>
     <PackageReference Include="System.ComponentModel.Annotations" Version="5.0.0" />
-    <PackageReference Include="System.Management" Version="7.0.0" />
+    <PackageReference Include="System.Management" Version="8.0.0" />
-    <PackageReference Include="nulastudio.NetCoreBeauty" Version="1.2.9.3" />
+    <PackageReference Include="nulastudio.NetBeauty" Version="2.1.4.5" />
-    <PackageReference Include="SpaceEngineersDedicated.ReferenceAssemblies" Version="1.201.13">
-      <PrivateAssets>all</PrivateAssets>
-      <IncludeAssets>compile</IncludeAssets>
-    </PackageReference>
   </ItemGroup>
   
   <ItemGroup>

Torch.Server/TorchConfig.cs

@@ -119,6 +119,9 @@ public class TorchConfig : ViewModel, ITorchConfig
         SourceType = UpdateSourceType.Github
     };
 
+    [Display(Name = "Packages", Description = "Packages to install and use.", GroupName = "Server")]
+    public List<string> Packages { get; set; } = new();
+
     // for backward compatibility
     public void Save(string path = null) => Initializer.Instance?.ConfigPersistent?.Save(path);
 }

Torch.Server/TorchServer.cs

@@ -8,6 +8,7 @@ using System.Linq;
 using System.Text;
 using System.Threading;
 using Microsoft.Diagnostics.Runtime;
+using Microsoft.Extensions.Configuration;
 using NLog;
 using PropertyChanged;
 using Sandbox;
@@ -19,7 +20,6 @@ using Torch.API.Managers;
 using Torch.API.Session;
 using Torch.Commands;
 using Torch.Managers.PatchManager;
-using Torch.Mod;
 using Torch.Server.Commands;
 using Torch.Server.Managers;
 using Torch.Utils;
@@ -46,8 +46,9 @@ namespace Torch.Server
 
         //Here to trigger rebuild
         /// <inheritdoc />
-        public TorchServer(ITorchConfig config, string instancePath, string instanceName) : base(config)
+        public TorchServer(ITorchConfig config, string instancePath, string instanceName, IConfiguration configuration) : base(config)
         {
+            Configuration = configuration;
             InstancePath = instancePath;
             InstanceName = instanceName;
             DedicatedInstance = new InstanceManager(this);
@@ -55,9 +56,12 @@ namespace Torch.Server
             if (config.EntityManagerEnabled)
                 AddManager(new EntityControlManager(this));
             AddManager(new RemoteAPIManager(this));
+            if (!ApplicationContext.Current.IsService && !config.NoGui)
+                AddManager(new UiManager(this));
 
             var sessionManager = Managers.GetManager<ITorchSessionManager>();
-            sessionManager.AddFactory(x => new MultiplayerManagerDedicated(this));
+            sessionManager.AddFactory(_ => new MultiplayerManagerDedicated(this));
+            sessionManager.AddFactory(_ => new ConsoleCommandManager(this));
             sessionManager.SessionStateChanged += OnSessionStateChanged;
             
             // Needs to be done at some point after MyVRageWindows.Init
@@ -67,6 +71,14 @@ namespace Torch.Server
             
             _simUpdateTimer.Elapsed += SimUpdateElapsed;
             _simUpdateTimer.Start();
+
+            Console.CancelKeyPress += (_, _) =>
+            {
+                if (State == ServerState.Running)
+                    Stop();
+                
+                Destroy();
+            };
         }
 
         private void SimUpdateElapsed(object sender, System.Timers.ElapsedEventArgs e)
@@ -119,7 +131,38 @@ namespace Torch.Server
         /// <inheritdoc />
         public ServerState State { get; private set; }
 
-        public event Action<ITorchServer> Initialized;
+        private Action<ITorchServer> _initializedEvent;
+
+        public event Action<ITorchServer> Initialized
+        {
+            add
+            {
+                var action = _initializedEvent;
+                Action<ITorchServer> action2;
+                do
+                {
+                    action2 = action;
+                    var action3 = (Action<ITorchServer>)Delegate.Combine(action2, value);
+                    action = Interlocked.CompareExchange(ref _initializedEvent, action3, action2);
+                }
+                while (action != action2);
+
+                if (GetManager<InstanceManager>().DedicatedConfig != null)
+                    value(this); //if already initialized
+            }
+            remove
+            {
+                var action = _initializedEvent;
+                Action<ITorchServer> action2;
+                do
+                {
+                    action2 = action;
+                    var action3 = (Action<ITorchServer>)Delegate.Remove(action2, value);
+                    action = Interlocked.CompareExchange(ref _initializedEvent, action3, action2);
+                }
+                while (action != action2);
+            }
+        }
 
         public int OnlinePlayers { get; private set; }
 
@@ -130,10 +173,12 @@ namespace Torch.Server
             base.Init();
             GetManager<InstanceManager>().LoadInstance(InstancePath);
             CanRun = true;
-            Initialized?.Invoke(this);
+            _initializedEvent?.Invoke(this);
             Log.Info($"Initialized server '{InstanceName}' at '{InstancePath}'");
         }
 
+        public override IConfiguration Configuration { get; }
+
         /// <inheritdoc />
         public override void Start()
         {
@@ -142,7 +187,7 @@ namespace Torch.Server
 
             if (IsRunning || HasRun)
             {
-                Restart();
+                Restart(false);
                 return;
             }
 
@@ -201,12 +246,28 @@ namespace Torch.Server
 
             new Thread(() =>
             {
+                if (save)
+                {
+                    var saveResult = Save().Result;
+                    if (saveResult is not (GameSaveResult.Success or GameSaveResult.TimedOut))
+                    {
+                        Log.Error("Save failed due to {Reason}. Restart aborted!", saveResult);
+                        return;
+                    }
+                }
+                
                 StopInternal();
+                Destroy();
                 LogManager.Flush();
                 
+                if (
 #if DEBUG
-                Environment.Exit(0);
+                    // ReSharper disable once ConditionIsAlwaysTrueOrFalse
+                    true ||
 #endif
+                    ApplicationContext.Current.IsService
+                    )
+                    return;
 
                 var exe = Path.Combine(AppContext.BaseDirectory, "Torch.Server.exe");
 
@@ -226,8 +287,6 @@ namespace Torch.Server
                 }
 
                 Process.Start(exe, $"--waitForPid {Environment.ProcessId} --tempAutostart true {string.Join(" ", args)}");
-                
-                Environment.Exit(0);
             })
             {
                 Name = "Restart thread"
@@ -242,14 +301,12 @@ namespace Torch.Server
                 case TorchSessionState.Unloading:
                     _watchdog?.Dispose();
                     _watchdog = null;
-                    ModCommunication.Unregister();
                     break;
                 case TorchSessionState.Loaded:
                     _multiplayerManagerDedicated = CurrentSession.Managers.GetManager<MultiplayerManagerDedicated>();
                     _multiplayerManagerDedicated.PlayerJoined += MultiplayerManagerDedicatedOnPlayerJoined;
                     _multiplayerManagerDedicated.PlayerLeft += MultiplayerManagerDedicatedOnPlayerLeft;
                     CurrentSession.Managers.GetManager<CommandManager>().RegisterCommandModule(typeof(WhitelistCommands));
-                    ModCommunication.Register();
                     break;
                 case TorchSessionState.Loading:
                 case TorchSessionState.Unloaded:

Torch.Server/UnhandledExceptionHandler.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Diagnostics;
+using System.IO;
 using System.Threading;
 using NLog;
 using VRage;
@@ -31,9 +32,25 @@ internal class UnhandledExceptionHandler
         {
             Console.WriteLine("Restarting in 5 seconds.");
             Thread.Sleep(5000);
-            var exe = typeof(Program).Assembly.Location;
             
-            Process.Start(exe, $"-waitForPid {Environment.ProcessId} {_config}");
+            var exe = Path.Combine(AppContext.BaseDirectory, "Torch.Server.exe");
+
+            var args = Environment.GetCommandLineArgs();
+
+            for (var i = 0; i < args.Length; i++)
+            {
+                if (args[i].Contains(' '))
+                    args[i] = $"\"{args[i]}\"";
+                    
+                if (!args[i].Contains("--tempAutostart", StringComparison.InvariantCultureIgnoreCase) &&
+                    !args[i].Contains("--waitForPid", StringComparison.InvariantCultureIgnoreCase)) 
+                    continue;
+                    
+                args[i] = string.Empty;
+                args[++i] = string.Empty;
+            }
+
+            Process.Start(exe, $"--waitForPid {Environment.ProcessId} --tempAutostart true {string.Join(" ", args)}");
         }
         else
         {

Torch.Server/ViewModels/BlockLimitViewModel.cs

@@ -1,23 +1,17 @@
-using System;
+using VRage.Game;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using System.Windows.Input;
-using VRage.Game;
 
 namespace Torch.Server.ViewModels
 {
     public class BlockLimitViewModel : ViewModel
     {
-        private SessionSettingsViewModel _sessionSettings;
+        private DynamicViewModel<MyObjectBuilder_SessionSettings> _sessionSettings;
 
         public string BlockType { get; set; }
         public short Limit { get; set; }
 
         //public CommandBinding Delete { get; } = new CommandBinding(new DeleteCommand());
 
-        public BlockLimitViewModel(SessionSettingsViewModel sessionSettings, string blockType, short limit)
+        public BlockLimitViewModel(DynamicViewModel<MyObjectBuilder_SessionSettings> sessionSettings, string blockType, short limit)
         {
             _sessionSettings = sessionSettings;
             BlockType = blockType;

Torch.Server/ViewModels/CheckpointViewModel.cs

@@ -1,9 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using Torch.Collections;
 using VRage;
 using VRage.Game;
 using VRage.Game.ModAPI;

Torch.Server/ViewModels/ConfigDedicatedViewModel.cs

@@ -1,14 +1,10 @@
-using System;
+using System.Collections.Generic;
-using System.Collections.Generic;
-using System.Linq;
 using System.Threading.Tasks;
 using NLog;
 using Sandbox.Engine.Utils;
 using Torch.Collections;
 using Torch.Server.Managers;
-using Torch.Utils;
 using VRage.Game;
-using VRage.GameServices;
 
 namespace Torch.Server.ViewModels
 {
@@ -22,7 +18,7 @@ namespace Torch.Server.ViewModels
         {
             _config = configDedicated;
             _config.IgnoreLastSession = true;
-            SessionSettings = new SessionSettingsViewModel(_config.SessionSettings);
+            SessionSettings = new DynamicViewModel<MyObjectBuilder_SessionSettings>(_config.SessionSettings);
             Task.Run(() => UpdateAllModInfosAsync());
         }
 
@@ -52,7 +48,7 @@ namespace Torch.Server.ViewModels
             return true;
         }
 
-        public SessionSettingsViewModel SessionSettings { get; set; }
+        public DynamicViewModel<MyObjectBuilder_SessionSettings> SessionSettings { get; set; }
 
         public MtObservableList<WorldViewModel> Worlds { get; } = new MtObservableList<WorldViewModel>();
         private WorldViewModel _selectedWorld;

Torch.Server/ViewModels/DynamicViewModel.cs

@@ -0,0 +1,115 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Reflection.Emit;
+using HarmonyLib;
+using JetBrains.Annotations;
+
+namespace Torch.Server.ViewModels;
+
+public class DynamicViewModel<T>(T obj) : ViewModel
+{
+    private readonly T _obj = obj;
+    
+    public ViewModel Wrapper { get; } = CreateProxy(obj);
+    
+    public static implicit operator T(DynamicViewModel<T> obj) => obj._obj;
+
+    private static ViewModel CreateProxy(T obj)
+    {
+        if (DynamicViewModel.Proxies.TryGetValue(typeof(T), out var proxy))
+            return (ViewModel)Activator.CreateInstance(proxy, obj);
+
+        var viewModelSetMethod = AccessTools.GetDeclaredMethods(typeof(ViewModel))
+            .First(b => b.Name == "SetValue" && b.GetParameters()[0].ParameterType.IsByRef);
+
+        DynamicViewModel.ModuleBuilder ??=
+            AssemblyBuilder.DefineDynamicAssembly(new("Torch.Server.ViewModels.Generated"), AssemblyBuilderAccess.Run)
+                .DefineDynamicModule("Torch.Server.ViewModels.Generated");
+
+        var type = DynamicViewModel.ModuleBuilder.DefineType($"{typeof(T).FullName}ViewModel",
+            TypeAttributes.Public | TypeAttributes.Sealed | TypeAttributes.Class, typeof(ViewModel));
+        
+        var instanceField = type.DefineField("_instance", typeof(T), FieldAttributes.Private | FieldAttributes.InitOnly);
+
+        var ctor = type.DefineConstructor(MethodAttributes.Public, CallingConventions.HasThis, [typeof(T)]);
+        {
+            var il = ctor.GetILGenerator();
+            
+            il.Emit(OpCodes.Ldarg_0);
+            il.Emit(OpCodes.Ldarg_1);
+            il.Emit(OpCodes.Stfld, instanceField);
+            il.Emit(OpCodes.Ret);
+        }
+        
+        foreach (var field in typeof(T).GetFields(BindingFlags.Instance | BindingFlags.Public))
+        {
+            var prop = type.DefineProperty(field.Name, PropertyAttributes.None, field.FieldType, null);
+            
+            foreach (var customAttribute in field.GetCustomAttributesData())
+            {
+                var hasCustomArgs = customAttribute.NamedArguments?.Any() ?? false;
+                var customArgsField = hasCustomArgs && customAttribute.NamedArguments[0].IsField;
+
+                var constructorArgs = customAttribute.ConstructorArguments.Select(b => b.Value).ToArray();
+                
+                CustomAttributeBuilder attributeBuilder;
+                if (!hasCustomArgs) 
+                    attributeBuilder = new CustomAttributeBuilder(customAttribute.Constructor, constructorArgs);
+                else if (customArgsField)
+                    attributeBuilder = new CustomAttributeBuilder(customAttribute.Constructor, constructorArgs, 
+                        customAttribute.NamedArguments.Select(b => (FieldInfo)b.MemberInfo).ToArray(),
+                        customAttribute.NamedArguments.Select(b => b.TypedValue.Value).ToArray());
+                else
+                    attributeBuilder = new CustomAttributeBuilder(customAttribute.Constructor, constructorArgs, 
+                        customAttribute.NamedArguments.Select(b => (PropertyInfo)b.MemberInfo).ToArray(),
+                        customAttribute.NamedArguments.Select(b => b.TypedValue.Value).ToArray());
+                
+                prop.SetCustomAttribute(attributeBuilder);
+            }
+            
+            var getMethod = type.DefineMethod($"get_{field.Name}", MethodAttributes.Public | MethodAttributes.HideBySig, field.FieldType, Type.EmptyTypes);
+            {
+                var il = getMethod.GetILGenerator();
+                
+                il.Emit(OpCodes.Ldarg_0);
+                il.Emit(OpCodes.Ldfld, instanceField);
+                il.Emit(OpCodes.Ldfld, field);
+                il.Emit(OpCodes.Ret);
+            }
+            prop.SetGetMethod(getMethod);
+
+            if (field.IsInitOnly) continue;
+            
+            var setMethod = type.DefineMethod($"set_{field.Name}", MethodAttributes.Public | MethodAttributes.HideBySig, typeof(void),
+                    [field.FieldType]);
+            {
+                var il = setMethod.GetILGenerator();
+
+                il.Emit(OpCodes.Ldarg_0);
+                il.Emit(OpCodes.Dup);
+                il.Emit(OpCodes.Ldfld, instanceField);
+                il.Emit(OpCodes.Ldflda, field);
+                il.Emit(OpCodes.Ldarg_1);
+                il.Emit(OpCodes.Ldstr, field.Name);
+                il.Emit(OpCodes.Callvirt, viewModelSetMethod.MakeGenericMethod(field.FieldType));
+                il.Emit(OpCodes.Ret);
+            }
+                
+            prop.SetSetMethod(setMethod);
+        }
+        
+        proxy = type.CreateType();
+        
+        DynamicViewModel.Proxies[typeof(T)] = proxy;
+        
+        return (ViewModel)Activator.CreateInstance(proxy, obj);
+    }
+}
+
+file static class DynamicViewModel
+{
+    public static readonly Dictionary<Type, Type> Proxies = [];
+    [CanBeNull] public static ModuleBuilder ModuleBuilder;
+}

Torch.Server/ViewModels/Entities/Blocks/BlockViewModel.cs

@@ -1,10 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.Drawing.Text;
-using System.Linq;
-using System.Reflection;
-using System.Text;
-using System.Threading.Tasks;
 using Sandbox.Game.Entities.Cube;
 using Sandbox.ModAPI;
 using Sandbox.ModAPI.Interfaces;

Torch.Server/ViewModels/Entities/Blocks/PropertyViewModel.cs

@@ -1,9 +1,4 @@
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using Sandbox.ModAPI;
 using Sandbox.ModAPI.Interfaces;
 
 namespace Torch.Server.ViewModels.Blocks

Torch.Server/ViewModels/Entities/EntityControlViewModel.cs

@@ -1,9 +1,4 @@
-using System;
+using System.Windows;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using System.Windows;
 
 namespace Torch.Server.ViewModels.Entities
 {

Torch.Server/ViewModels/Entities/EntityViewModel.cs

@@ -1,16 +1,11 @@
 using System;
-using System.Collections;
 using System.Collections.Generic;
-using System.Windows.Controls;
 using NLog;
 using Sandbox.Game.Entities;
-using Sandbox.Game.World;
 using Torch.API.Managers;
 using Torch.Collections;
 using Torch.Server.Managers;
 using Torch.Utils;
-using VRage.Game.Entity;
-using VRage.Game.ModAPI;
 using VRage.ModAPI;
 using VRageMath;
 

Torch.Server/ViewModels/Entities/GridViewModel.cs

@@ -1,12 +1,9 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Runtime.CompilerServices;
 using Sandbox.Definitions;
 using Sandbox.Game.Entities;
 using Sandbox.Game.Entities.Cube;
-using Sandbox.ModAPI;
-using Torch.API.Managers;
 using Torch.Collections;
 using Torch.Server.ViewModels.Blocks;
 using VRage.Game;

Torch.Server/ViewModels/Entities/VoxelMapViewModel.cs

@@ -1,8 +1,4 @@
-using System.Collections.Generic;
+using Sandbox.Game.Entities;
-using System.Linq;
-using Sandbox.Game.Entities;
-using VRage.Game.Entity;
-using VRage.Game.ModAPI;
 using System.Threading.Tasks;
 using Torch.Collections;
 

Torch.Server/ViewModels/EntityTreeViewModel.cs

@@ -1,18 +1,11 @@
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 using System.Windows.Controls;
 using Sandbox.Game.Entities;
 using Sandbox.Game.Entities.Character;
 using Torch.Server.ViewModels.Entities;
-using VRage.Game.ModAPI;
-using VRage.ModAPI;
 using System.Windows.Threading;
 using NLog;
 using Torch.Collections;
-using Torch.Server.Views.Entities;
 
 namespace Torch.Server.ViewModels
 {

Torch.Server/ViewModels/ILazyLoad.cs

@@ -1,10 +1,4 @@
-using System;
+namespace Torch.Server.ViewModels
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace Torch.Server.ViewModels
 {
     public interface ILazyLoad
     {

Torch.Server/ViewModels/ModItemInfo.cs

@@ -1,9 +1,6 @@
-using System;
+using System.Threading.Tasks;
-using System.Threading.Tasks;
 using NLog;
 using VRage.Game;
-using Torch.Utils;
-using VRage.GameServices;
 
 namespace Torch.Server.ViewModels
 {

Torch.Server/ViewModels/PluginManagerViewModel.cs

@@ -1,9 +1,5 @@
-using System;
+using System.Collections.Generic;
-using System.Collections.Generic;
 using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using Torch.API;
 using Torch.API.Managers;
 using Torch.API.Plugins;
 using Torch.Collections;

Torch.Server/ViewModels/PluginViewModel.cs

@@ -1,13 +1,8 @@
 using System;
-using System.Collections.Generic;
 using System.Drawing;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 using System.Windows;
 using System.Windows.Controls;
 using NLog;
-using Torch.API;
 using Torch.API.Plugins;
 using Torch.Server.Views;
 

Torch.Server/ViewModels/SessionSettingsViewModel.cs

@@ -1,328 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.ComponentModel;
-using System.ComponentModel.DataAnnotations;
-using System.Linq;
-using Torch;
-using Torch.Collections;
-using Torch.Views;
-using VRage.Game;
-using VRage.Library.Utils;
-using VRage.Serialization;
-
-namespace Torch.Server.ViewModels
-{
-    public class SessionSettingsViewModel : ViewModel
-    {
-        private MyObjectBuilder_SessionSettings _settings;
-
-        [Torch.Views.Display(Description = "The type of the game mode.", Name = "Game Mode", GroupName = "Others")]
-        public MyGameModeEnum GameMode { get => _settings.GameMode; set => SetValue(ref _settings.GameMode, value); }
-        [Torch.Views.Display(Description = "The type of the game online mode.", Name = "Online Mode", GroupName = "Others")]
-        public MyOnlineModeEnum OnlineMode { get => _settings.OnlineMode; set => SetValue(ref _settings.OnlineMode, value); }
-
-        [Torch.Views.Display(Description = "The multiplier for character inventory size.", Name = "Character Inventory Size", GroupName = "Multipliers")]
-        public float CharacterInventorySizeMultiplier { get => _settings.InventorySizeMultiplier; set => SetValue(ref _settings.InventorySizeMultiplier, value); }
-
-        [Torch.Views.Display(Description = "The multiplier for block inventory size.", Name = "Block Inventory Size", GroupName = "Multipliers")]
-        public float BlockInventorySizeMultiplier { get => _settings.BlocksInventorySizeMultiplier; set => SetValue(ref _settings.BlocksInventorySizeMultiplier, value); }
-
-        [Torch.Views.Display(Description = "The multiplier for assembler speed.", Name = "Assembler Speed", GroupName = "Multipliers")]
-        public float AssemblerSpeedMultiplier { get => _settings.AssemblerSpeedMultiplier; set => SetValue(ref _settings.AssemblerSpeedMultiplier, value); }
-
-        [Torch.Views.Display(Description = "The multiplier for assembler efficiency.", Name = "Assembler Efficiency", GroupName = "Multipliers")]
-        public float AssemblerEfficiencyMultiplier { get => _settings.AssemblerEfficiencyMultiplier; set => SetValue(ref _settings.AssemblerEfficiencyMultiplier, value); }
-
-        [Torch.Views.Display(Description = "The multiplier for refinery speed.", Name = "Refinery Speed", GroupName = "Multipliers")]
-        public float RefinerySpeedMultiplier { get => _settings.RefinerySpeedMultiplier; set => SetValue(ref _settings.RefinerySpeedMultiplier, value); }
-
-        [Torch.Views.Display(Description = "The maximum number of connected players.", Name = "Max Players", GroupName = "Players")]
-        public short MaxPlayers { get => _settings.MaxPlayers; set => SetValue(ref _settings.MaxPlayers, value); }
-
-        [Torch.Views.Display(Description = "The maximum number of existing floating objects.", Name = "Max Floating Objects", GroupName = "Environment")]
-        public short MaxFloatingObjects { get => _settings.MaxFloatingObjects; set => SetValue(ref _settings.MaxFloatingObjects, value); }
-
-        [Torch.Views.Display(Description = "The maximum number of backup saves.", Name = "Max Backup Saves", GroupName = "Others")]
-        public short MaxBackupSaves { get => _settings.MaxBackupSaves; set => SetValue(ref _settings.MaxBackupSaves, value); }
-
-        [Torch.Views.Display(Description = "The maximum number of blocks in one grid.", Name = "Max Grid Blocks", GroupName = "Block Limits")]
-        public int MaxGridSize { get => _settings.MaxGridSize; set => SetValue(ref _settings.MaxGridSize, value); }
-
-        [Torch.Views.Display(Description = "The maximum number of blocks per player.", Name = "Max Blocks per Player", GroupName = "Block Limits")]
-        public int MaxBlocksPerPlayer { get => _settings.MaxBlocksPerPlayer; set => SetValue(ref _settings.MaxBlocksPerPlayer, value); }
-
-        [Torch.Views.Display(Description = "The total number of Performance Cost Units in the world.", Name = "World PCU", GroupName = "Block Limits")]
-        public int TotalPCU { get => _settings.TotalPCU; set => SetValue(ref _settings.TotalPCU, value); }
-
-        [Torch.Views.Display(Description = "The maximum number of existing factions in the world.", Name = "Max Factions Count", GroupName = "Block Limits")]
-        public int MaxFactionsCount { get => _settings.MaxFactionsCount; set => SetValue(ref _settings.MaxFactionsCount, value); }
-
-        [Torch.Views.Display(Description = "Defines block limits mode.", Name = "Block Limits Mode", GroupName = "Block Limits")]
-        public MyBlockLimitsEnabledEnum BlockLimitsEnabled { get => _settings.BlockLimitsEnabled; set => SetValue(ref _settings.BlockLimitsEnabled, value); }
-
-        [Torch.Views.Display(Description = "Enables possibility to remove grid remotely from the world by an author.", Name = "Enable Remote Grid Removal", GroupName = "Others")]
-        public bool EnableRemoteBlockRemoval { get => _settings.EnableRemoteBlockRemoval; set => SetValue(ref _settings.EnableRemoteBlockRemoval, value); }
-
-        [Torch.Views.Display(Description = "Defines hostility of the environment.", Name = "Environment Hostility", GroupName = "Environment")]
-        public MyEnvironmentHostilityEnum EnvironmentHostility { get => _settings.EnvironmentHostility; set => SetValue(ref _settings.EnvironmentHostility, value); }
-
-        [Torch.Views.Display(Description = "Enables auto healing of the character.", Name = "Auto Healing", GroupName = "Players")]
-        public bool AutoHealing { get => _settings.AutoHealing; set => SetValue(ref _settings.AutoHealing, value); }
-
-        [Torch.Views.Display(Description = "Enables copy and paste feature.", Name = "Enable Copy & Paste", GroupName = "Players")]
-        public bool EnableCopyPaste { get => _settings.EnableCopyPaste; set => SetValue(ref _settings.EnableCopyPaste, value); }
-
-        [Torch.Views.Display(Description = "Enables weapons.", Name = "Enable Weapons", GroupName = "Others")]
-        public bool WeaponsEnabled { get => _settings.WeaponsEnabled; set => SetValue(ref _settings.WeaponsEnabled, value); }
-
-        [Torch.Views.Display(Description = "", Name = "Show Player Names on HUD", GroupName = "Players")]
-        public bool ShowPlayerNamesOnHud { get => _settings.ShowPlayerNamesOnHud; set => SetValue(ref _settings.ShowPlayerNamesOnHud, value); }
-
-        [Torch.Views.Display(Description = "Enables thruster damage.", Name = "Enable Thruster Damage", GroupName = "Others")]
-        public bool ThrusterDamage { get => _settings.ThrusterDamage; set => SetValue(ref _settings.ThrusterDamage, value); }
-
-        [Torch.Views.Display(Description = "Enables spawning of cargo ships.", Name = "Enable Cargo Ships", GroupName = "NPCs")]
-        public bool CargoShipsEnabled { get => _settings.CargoShipsEnabled; set => SetValue(ref _settings.CargoShipsEnabled, value); }
-
-        [Torch.Views.Display(Description = "Enables spectator camera.", Name = "Enable Spectator Camera", GroupName = "Others")]
-        public bool EnableSpectator { get => _settings.EnableSpectator; set => SetValue(ref _settings.EnableSpectator, value); }
-
-        /// <summary>
-        /// Size of the edge of the world area cube.
-        /// Don't use directly, as it is error-prone (it's km instead of m and edge size instead of half-extent)
-        /// Rather use MyEntities.WorldHalfExtent()
-        /// </summary>
-        [Torch.Views.Display(Description = "Defines the size of the world.", Name = "World Size [km]", GroupName = "Environment")]
-        public int WorldSizeKm { get => _settings.WorldSizeKm; set => SetValue(ref _settings.WorldSizeKm, value); }
-
-        [Torch.Views.Display(Description = "When enabled respawn ship is removed after player logout.", Name = "Remove Respawn Ships on Logoff", GroupName = "Others")]
-        public bool RespawnShipDelete { get => _settings.RespawnShipDelete; set => SetValue(ref _settings.RespawnShipDelete, value); }
-
-        [Torch.Views.Display(Description = "", Name = "Reset Ownership", GroupName = "Players")]
-        public bool ResetOwnership { get => _settings.ResetOwnership; set => SetValue(ref _settings.ResetOwnership, value); }
-
-        [Torch.Views.Display(Description = "The multiplier for welder speed.", Name = "Welder Speed", GroupName = "Multipliers")]
-        public float WelderSpeedMultiplier { get => _settings.WelderSpeedMultiplier; set => SetValue(ref _settings.WelderSpeedMultiplier, value); }
-
-        [Torch.Views.Display(Description = "The multiplier for grinder speed.", Name = "Grinder Speed", GroupName = "Multipliers")]
-        public float GrinderSpeedMultiplier { get => _settings.GrinderSpeedMultiplier; set => SetValue(ref _settings.GrinderSpeedMultiplier, value); }
-
-        [Torch.Views.Display(Description = "Enables realistic sounds.", Name = "Enable Realistic Sound", GroupName = "Environment")]
-        public bool RealisticSound { get => _settings.RealisticSound; set => SetValue(ref _settings.RealisticSound, value); }
-
-        [Torch.Views.Display(Description = "The multiplier for hacking speed.", Name = "Hacking Speed", GroupName = "Multipliers")]
-        public float HackSpeedMultiplier { get => _settings.HackSpeedMultiplier; set => SetValue(ref _settings.HackSpeedMultiplier, value); }
-
-        [Torch.Views.Display(Description = "Enables permanent death.", Name = "Permanent Death", GroupName = "Players")]
-        public bool? PermanentDeath { get => _settings.PermanentDeath; set => SetValue(ref _settings.PermanentDeath, value); }
-
-        [Torch.Views.Display(Description = "Defines autosave interval.", Name = "Autosave Interval [mins]", GroupName = "Others")]
-        public uint AutoSaveInMinutes { get => _settings.AutoSaveInMinutes; set => SetValue(ref _settings.AutoSaveInMinutes, value); }
-
-        [Torch.Views.Display(Description = "Enables saving from the menu.", Name = "Enable Saving from Menu", GroupName = "Others")]
-        public bool EnableSaving { get => _settings.EnableSaving; set => SetValue(ref _settings.EnableSaving, value); }
-
-        [Torch.Views.Display(Description = "Enables respawn screen.", Name = "Enable Respawn Screen in the Game", GroupName = "Players")]
-        public bool StartInRespawnScreen { get => _settings.StartInRespawnScreen; set => SetValue(ref _settings.StartInRespawnScreen, value); }
-        
-        [Torch.Views.Display(Description = "Enables research.", Name = "Enable Research", GroupName = "Players")]
-        public bool EnableResearch { get => _settings.EnableResearch; set => SetValue(ref _settings.EnableResearch, value); }
-        
-        [Torch.Views.Display(Description = "Enables Good.bot hints.", Name = "Enable Good.bot hints", GroupName = "Players")]
-        public bool EnableGoodBotHints { get => _settings.EnableGoodBotHints; set => SetValue(ref _settings.EnableGoodBotHints, value); }
-        
-        [Torch.Views.Display(Description = "Enables infinite ammunition in survival game mode.", Name = "Enable Infinite Ammunition in Survival", GroupName = "Others")]
-        public bool InfiniteAmmo { get => _settings.InfiniteAmmo; set => SetValue(ref _settings.InfiniteAmmo, value); }
-
-        [Torch.Views.Display(Description = "Enables drop containers (unknown signals).", Name = "Enable Drop Containers", GroupName = "Others")]
-        public bool EnableContainerDrops { get => _settings.EnableContainerDrops; set => SetValue(ref _settings.EnableContainerDrops, value); }
-
-        [Torch.Views.Display(Description = "The multiplier for respawn ship timer.", Name = "Respawn Ship Time Multiplier", GroupName = "Players")]
-        public float SpawnShipTimeMultiplier { get => _settings.SpawnShipTimeMultiplier; set => SetValue(ref _settings.SpawnShipTimeMultiplier, value); }
-
-        [Torch.Views.Display(Description = "Defines density of the procedurally generated content.", Name = "Procedural Density", GroupName = "Environment")]
-        public float ProceduralDensity { get => _settings.ProceduralDensity; set => SetValue(ref _settings.ProceduralDensity, value); }
-
-        [Torch.Views.Display(Description = "Defines unique starting seed for the procedurally generated content.", Name = "Procedural Seed", GroupName = "Environment")]
-        public int ProceduralSeed { get => _settings.ProceduralSeed; set => SetValue(ref _settings.ProceduralSeed, value); }
-
-        [Torch.Views.Display(Description = "Enables destruction feature for the blocks.", Name = "Enable Destructible Blocks", GroupName = "Environment")]
-        public bool DestructibleBlocks { get => _settings.DestructibleBlocks; set => SetValue(ref _settings.DestructibleBlocks, value); }
-
-        [Torch.Views.Display(Description = "Enables in game scripts.", Name = "Enable Ingame Scripts", GroupName = "Others")]
-        public bool EnableIngameScripts { get => _settings.EnableIngameScripts; set => SetValue(ref _settings.EnableIngameScripts, value); }
-
-        [Torch.Views.Display(Description = "", Name = "Flora Density Multiplier", GroupName = "Environment")]
-        public float FloraDensityMultiplier { get => _settings.FloraDensityMultiplier; set => SetValue(ref _settings.FloraDensityMultiplier, value); }
-
-        [Torch.Views.Display(Description = "Enables tool shake feature.", Name = "Enable Tool Shake", GroupName = "Players")]
-        [DefaultValue(false)]
-        public bool EnableToolShake { get => _settings.EnableToolShake; set => SetValue(ref _settings.EnableToolShake, value); }
-
-        [Torch.Views.Display(Description = "", Name = "Voxel Generator Version", GroupName = "Environment")]
-        public int VoxelGeneratorVersion { get => _settings.VoxelGeneratorVersion; set => SetValue(ref _settings.VoxelGeneratorVersion, value); }
-
-        [Torch.Views.Display(Description = "Enables oxygen in the world.", Name = "Enable Oxygen", GroupName = "Environment")]
-        public bool EnableOxygen { get => _settings.EnableOxygen; set => SetValue(ref _settings.EnableOxygen, value); }
-
-        [Torch.Views.Display(Description = "Enables airtightness in the world.", Name = "Enable Airtightness", GroupName = "Environment")]
-        public bool EnableOxygenPressurization { get => _settings.EnableOxygenPressurization; set => SetValue(ref _settings.EnableOxygenPressurization, value); }
-
-        [Torch.Views.Display(Description = "Enables 3rd person camera.", Name = "Enable 3rd Person Camera", GroupName = "Players")]
-        public bool Enable3rdPersonView { get => _settings.Enable3rdPersonView; set => SetValue(ref _settings.Enable3rdPersonView, value); }
-
-        [Torch.Views.Display(Description = "Enables random encounters in the world.", Name = "Enable Encounters", GroupName = "NPCs")]
-        public bool EnableEncounters { get => _settings.EnableEncounters; set => SetValue(ref _settings.EnableEncounters, value); }
-        
-        [Torch.Views.Display(Description = "Enables possibility of converting grid to station.", Name = "Enable Convert to Station", GroupName = "Others")]
-        public bool EnableConvertToStation { get => _settings.EnableConvertToStation; set => SetValue(ref _settings.EnableConvertToStation, value); }
-
-        [Torch.Views.Display(Description = "Enables possibility of station grid inside voxel.", Name = "Enable Station Grid with Voxel", GroupName = "Environment")]
-        public bool StationVoxelSupport { get => _settings.StationVoxelSupport; set => SetValue(ref _settings.StationVoxelSupport, value); }
-
-        [Torch.Views.Display(Description = "Enables sun rotation.", Name = "Enable Sun Rotation", GroupName = "Environment")]
-        public bool EnableSunRotation { get => _settings.EnableSunRotation; set => SetValue(ref _settings.EnableSunRotation, value); }
-
-        [Torch.Views.Display(Description = "Enables respawn ships.", Name = "Enable Respawn Ships", GroupName = "Others")]
-        public bool EnableRespawnShips { get => _settings.EnableRespawnShips; set => SetValue(ref _settings.EnableRespawnShips, value); }
-
-        [Torch.Views.Display(Description = "", Name = "Physics Iterations", GroupName = "Environment")]
-        public int PhysicsIterations { get => _settings.PhysicsIterations; set => SetValue(ref _settings.PhysicsIterations, value); }
-
-        [Torch.Views.Display(Description = "Defines interval of one rotation of the sun.", Name = "Sun Rotation Interval", GroupName = "Environment")]
-        public float SunRotationIntervalMinutes { get => _settings.SunRotationIntervalMinutes; set => SetValue(ref _settings.SunRotationIntervalMinutes, value); }
-
-        [Torch.Views.Display(Description = "Enables jetpack.", Name = "Enable Jetpack", GroupName = "Players")]
-        public bool EnableJetpack { get => _settings.EnableJetpack; set => SetValue(ref _settings.EnableJetpack, value); }
-
-        [Torch.Views.Display(Description = "Enables spawning with tools in the inventory.", Name = "Spawn with Tools", GroupName = "Players")]
-        public bool SpawnWithTools { get => _settings.SpawnWithTools; set => SetValue(ref _settings.SpawnWithTools, value); }
-
-        [Torch.Views.Display(Description = "Enables voxel destructions.", Name = "Enable Voxel Destruction", GroupName = "Environment")]
-        public bool EnableVoxelDestruction { get => _settings.EnableVoxelDestruction; set => SetValue(ref _settings.EnableVoxelDestruction, value); }
-
-        [Torch.Views.Display(Description = "Enables spawning of drones in the world.", Name = "Enable Drones", GroupName = "NPCs")]
-        public bool EnableDrones { get => _settings.EnableDrones; set => SetValue(ref _settings.EnableDrones, value); }
-
-        [Torch.Views.Display(Description = "Enables spawning of wolves in the world.", Name = "Enable Wolves", GroupName = "NPCs")]
-        public bool EnableWolfs { get => _settings.EnableWolfs; set => SetValue(ref _settings.EnableWolfs, value); }
-
-        [Torch.Views.Display(Description = "Enables spawning of spiders in the world.", Name = "Enable Spiders", GroupName = "NPCs")]
-        public bool EnableSpiders { get => _settings.EnableSpiders; set => SetValue(ref _settings.EnableSpiders, value); }
-
-        [Torch.Views.Display(Name = "Block Type World Limits", GroupName = "Block Limits")]
-        public Dictionary<string, short> BlockTypeLimits { get => _settings.BlockTypeLimits.Dictionary; set => SetValue(x => _settings.BlockTypeLimits.Dictionary = x, value); }
-
-        [Torch.Views.Display(Description = "Enables scripter role for administration.", Name = "Enable Scripter Role", GroupName = "Others")]
-        public bool EnableScripterRole { get => _settings.EnableScripterRole; set => SetValue(ref _settings.EnableScripterRole, value); }
-
-        [Torch.Views.Display(Description = "Defines minimum respawn time for drop containers.", Name = "Min Drop Container Respawn Time", GroupName = "Others")]
-        public int MinDropContainerRespawnTime { get => _settings.MinDropContainerRespawnTime; set => SetValue(ref _settings.MinDropContainerRespawnTime, value); }
-
-        [Torch.Views.Display(Description = "Defines maximum respawn time for drop containers.", Name = "Max Drop Container Respawn Time", GroupName = "Others")]
-        public int MaxDropContainerRespawnTime { get => _settings.MaxDropContainerRespawnTime; set => SetValue(ref _settings.MaxDropContainerRespawnTime, value); }
-
-        [Torch.Views.Display(Description = "Enables friendly fire for turrets.", Name = "Enable Turrets Friendly Fire", GroupName = "Environment")]
-        public bool EnableTurretsFriendlyFire { get => _settings.EnableTurretsFriendlyFire; set => SetValue(ref _settings.EnableTurretsFriendlyFire, value); }
-
-        [Torch.Views.Display(Description = "Enables sub-grid damage.", Name = "Enable Sub-Grid Damage", GroupName = "Environment")]
-        public bool EnableSubgridDamage { get => _settings.EnableSubgridDamage; set => SetValue(ref _settings.EnableSubgridDamage, value); }
-
-        [Torch.Views.Display(Description = "Defines synchronization distance in multiplayer. High distance can slow down server drastically. Use with caution.", Name = "Sync Distance", GroupName = "Environment")]
-        public int SyncDistance { get => _settings.SyncDistance; set => SetValue(ref _settings.SyncDistance, value); }
-
-        [Torch.Views.Display(Description = "Defines render distance for clients in multiplayer. High distance can slow down client FPS. Values larger than SyncDistance may not work as expected.", Name = "View Distance", GroupName = "Environment")]
-        public int ViewDistance { get => _settings.ViewDistance; set => SetValue(ref _settings.ViewDistance, value);}
-
-        [Torch.Views.Display(Description = "Enables experimental mode.", Name = "Experimental Mode", GroupName = "Others")]
-        public bool ExperimentalMode { get => _settings.ExperimentalMode; set => SetValue(ref _settings.ExperimentalMode, value); }
-
-        [Torch.Views.Display(Description = "Enables adaptive simulation quality system. This system is useful if you have a lot of voxel deformations in the world and low simulation speed.", Name = "Adaptive Simulation Quality", GroupName = "Others")]
-        public bool AdaptiveSimulationQuality { get => _settings.AdaptiveSimulationQuality; set => SetValue(ref _settings.AdaptiveSimulationQuality, value); }
-
-        [Torch.Views.Display(Description = "Enables voxel hand.", Name = "Enable voxel hand", GroupName = "Others")]
-        public bool EnableVoxelHand { get => _settings.EnableVoxelHand; set => SetValue(ref _settings.EnableVoxelHand, value); }
-
-        [Torch.Views.Display(Description = "Enables trash removal system.", Name = "Trash Removal Enabled", GroupName = "Trash Removal")]
-        public bool TrashRemovalEnabled { get => _settings.TrashRemovalEnabled; set => SetValue(ref _settings.TrashRemovalEnabled, value); }
-
-        [Torch.Views.Display(Description = "Defines flags for trash removal system.", Name = "Trash Removal Flags", GroupName = "Trash Removal")]
-        public MyTrashRemovalFlags TrashFlagsValue { get => (MyTrashRemovalFlags)_settings.TrashFlagsValue; set => SetValue(ref _settings.TrashFlagsValue, (int)value); }
-
-        [Torch.Views.Display(Description = "Defines block count threshold for trash removal system.", Name = "Block Count Threshold", GroupName = "Trash Removal")]
-        public int BlockCountThreshold { get => _settings.BlockCountThreshold; set => SetValue(ref _settings.BlockCountThreshold, value); }
-
-        [Torch.Views.Display(Description = "Defines player distance threshold for trash removal system.", Name = "Player Distance Threshold [m]", GroupName = "Trash Removal")]
-        public float PlayerDistanceThreshold { get => _settings.PlayerDistanceThreshold; set => SetValue(ref _settings.PlayerDistanceThreshold, value); }
-
-        [Torch.Views.Display(Description = "By setting this, server will keep number of grids around this value. \n !WARNING! It ignores Powered and Fixed flags, Block Count and lowers Distance from player.\n Set to 0 to disable.", Name = "Optimal Grid Count", GroupName = "Trash Removal")]
-        public int OptimalGridCount { get => _settings.OptimalGridCount; set => SetValue(ref _settings.OptimalGridCount, value); }
-
-        [Torch.Views.Display(Description = "Defines player inactivity threshold for trash removal system. \n !WARNING! This will remove all grids of the player.\n Set to 0 to disable.", Name = "Player Inactivity Threshold [hours]", GroupName = "Trash Removal")]
-        public float PlayerInactivityThreshold { get => _settings.PlayerInactivityThreshold; set => SetValue(ref _settings.PlayerInactivityThreshold, value); }
-
-        [Torch.Views.Display(Description = "Defines character removal threshold for trash removal system. If player disconnects it will remove his character after this time.\n Set to 0 to disable.", Name = "Character Removal Threshold [mins]", GroupName = "Trash Removal")]
-        public int PlayerCharacterRemovalThreshold { get => _settings.PlayerCharacterRemovalThreshold; set => SetValue(ref _settings.PlayerCharacterRemovalThreshold, value); }
-
-        [Torch.Views.Display(Description = "Sets optimal distance in meters when spawning new players near others.", Name = "Optimal Spawn Distance", GroupName = "Players")]
-        public float OptimalSpawnDistance { get => _settings.OptimalSpawnDistance; set => SetValue(ref _settings.OptimalSpawnDistance, value); }
-
-        [Torch.Views.Display(Description = "Enables automatic respawn at nearest available respawn point.", Name = "Enable Auto Respawn", GroupName = "Players")]
-        public bool EnableAutoRespawn { get => _settings.EnableAutorespawn; set => SetValue(ref _settings.EnableAutorespawn, value); }
-        
-        [Torch.Views.Display(Description = "The number of NPC factions generated on the start of the world.", Name = "NPC Factions Count", GroupName = "NPCs")]
-        public int TradeFactionsCount { get => _settings.TradeFactionsCount; set => SetValue(ref _settings.TradeFactionsCount, value); }
-        
-        [Torch.Views.Display(Description = "The inner radius [m] (center is in 0,0,0), where stations can spawn. Does not affect planet-bound stations (surface Outposts and Orbital stations).", Name = "Stations Inner Radius", GroupName = "NPCs")]
-        public double StationsDistanceInnerRadius { get => _settings.StationsDistanceInnerRadius; set => SetValue(ref _settings.StationsDistanceInnerRadius, value); }
-
-        [Torch.Views.Display(Description = "The outer radius [m] (center is in 0,0,0), where stations can spawn. Does not affect planet-bound stations (surface Outposts and Orbital stations).", Name = "Stations Outer Radius Start", GroupName = "NPCs")]
-        public double StationsDistanceOuterRadiusStart { get => _settings.StationsDistanceOuterRadiusStart; set => SetValue(ref _settings.StationsDistanceOuterRadiusStart, value); }
-        
-        [Torch.Views.Display(Description = "The outer radius [m] (center is in 0,0,0), where stations can spawn. Does not affect planet-bound stations (surface Outposts and Orbital stations).", Name = "Stations Outer Radius End", GroupName = "NPCs")]
-        public double StationsDistanceOuterRadiusEnd { get => _settings.StationsDistanceOuterRadiusEnd; set => SetValue(ref _settings.StationsDistanceOuterRadiusEnd, value); }
-        
-        [Torch.Views.Display(Description = "Time period between two economy updates in seconds.", Name = "Economy tick time", GroupName = "NPCs")]
-        public int EconomyTickInSeconds { get => _settings.EconomyTickInSeconds; set => SetValue(ref _settings.EconomyTickInSeconds, value); }
-        
-        [Torch.Views.Display(Description = "If enabled bounty contracts will be available on stations.", Name = "Enable Bounty Contracts", GroupName = "Players")]
-        public bool EnableBountyContracts { get => _settings.EnableBountyContracts; set => SetValue(ref _settings.EnableBountyContracts, value); }
-        
-        [Torch.Views.Display(Description = "Resource deposits count coefficient for generated world content (voxel generator version > 2).", Name = "Deposits Count Coefficient", GroupName = "Environment")]
-        public float DepositsCountCoefficient { get => _settings.DepositsCountCoefficient; set => SetValue(ref _settings.DepositsCountCoefficient, value); }
-        
-        [Torch.Views.Display(Description = "Resource deposit size denominator for generated world content (voxel generator version > 2).", Name = "Deposit Size Denominator", GroupName = "Environment")]
-        public float DepositSideDenominator { get => _settings.DepositSizeDenominator; set => SetValue(ref _settings.DepositSizeDenominator, value); }
-        
-        [Torch.Views.Display(Description = "Enables economy features.", Name = "Enable Economy", GroupName = "NPCs")]
-        public bool EnableEconomy { get => _settings.EnableEconomy; set => SetValue(ref _settings.EnableEconomy, value); }
-        
-        [Torch.Views.Display(Description = "Enables system for voxel reverting.", Name = "Enable Voxel Reverting", GroupName = "Trash Removal")]
-        public bool VoxelTrashRemovalEnabled { get => _settings.VoxelTrashRemovalEnabled; set => SetValue(ref _settings.VoxelTrashRemovalEnabled, value); }
-        
-        [Torch.Views.Display(Description = "Allows super gridding exploit to be used.", Name = "Enable Supergridding", GroupName = "Others")]
-        public bool EnableSupergridding { get => _settings.EnableSupergridding; set => SetValue(ref _settings.EnableSupergridding, value); }
-        
-        [Torch.Views.Display(Description = "Enables Selective Physics", Name = "Enable Selective Physics", GroupName = "Others")]
-        public bool EnableSelectivePhysics { get => _settings.EnableSelectivePhysicsUpdates; set => SetValue(ref _settings.EnableSelectivePhysicsUpdates, value); }
-
-        [Torch.Views.Display(Description = "Allows steam's family sharing", Name = "Enable Family Sharing", GroupName = "Players")]
-        public bool EnableFamilySharing { get => _settings.FamilySharing; set => SetValue(ref _settings.FamilySharing, value); }
-
-        [Torch.Views.Display(Description = "Enables PCU trading", Name = "Enable PCU Trading", GroupName = "Block Limits")]
-        public bool EnablePCUTrading { get => _settings.EnablePcuTrading; set => SetValue(ref _settings.EnablePcuTrading, value); }
-
-        [Torch.Views.Display(Description = "Enables system for weather", Name = "Enable Weather System", GroupName = "Others")]
-        public bool EnableWeatherSystem { get => _settings.WeatherSystem; set => SetValue(ref _settings.WeatherSystem, value); }
-
-        public SessionSettingsViewModel(MyObjectBuilder_SessionSettings settings)
-        {
-            _settings = settings;
-        }
-
-        public static implicit operator MyObjectBuilder_SessionSettings(SessionSettingsViewModel viewModel)
-        {
-            return viewModel._settings;
-        }
-    }
-}

Torch.Server/ViewModels/WorldConfigurationViewModel.cs

@@ -6,12 +6,12 @@ namespace Torch.Server.ViewModels
     public class WorldConfigurationViewModel : ViewModel
     {
         private readonly MyObjectBuilder_WorldConfiguration _worldConfiguration;
-        private SessionSettingsViewModel _sessionSettings;
+        private DynamicViewModel<MyObjectBuilder_SessionSettings> _sessionSettings;
 
         public WorldConfigurationViewModel(MyObjectBuilder_WorldConfiguration worldConfiguration)
         {
             _worldConfiguration = worldConfiguration;
-            _sessionSettings = new SessionSettingsViewModel(worldConfiguration.Settings);
+            _sessionSettings = new DynamicViewModel<MyObjectBuilder_SessionSettings>(worldConfiguration.Settings);
         }
 
         public static implicit operator MyObjectBuilder_WorldConfiguration(WorldConfigurationViewModel model)
@@ -21,7 +21,7 @@ namespace Torch.Server.ViewModels
         
         public List<MyObjectBuilder_Checkpoint.ModItem> Mods { get => _worldConfiguration.Mods; set => SetValue(ref _worldConfiguration.Mods, value); }
         
-        public SessionSettingsViewModel Settings
+        public DynamicViewModel<MyObjectBuilder_SessionSettings> Settings
         {
             get => _sessionSettings;
             set

Torch.Server/Views/AddWorkshopItemsDialog.xaml.cs

@@ -1,17 +1,5 @@
-using System;
+using System.Text.RegularExpressions;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Text.RegularExpressions;
-using System.Threading.Tasks;
 using System.Windows;
-using System.Windows.Controls;
-using System.Windows.Data;
-using System.Windows.Documents;
-using System.Windows.Input;
-using System.Windows.Media;
-using System.Windows.Media.Imaging;
-using System.Windows.Shapes;
 
 namespace Torch.Server
 {

Torch.Server/Views/ChatControl.xaml.cs

@@ -1,35 +1,20 @@
 using System;
 using System.Collections.Generic;
-using System.Collections.Specialized;
-using System.Linq;
 using System.Reflection;
-using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 using System.Windows;
 using System.Windows.Controls;
-using System.Windows.Data;
 using System.Windows.Documents;
 using System.Windows.Input;
 using System.Windows.Media;
-using System.Windows.Media.Imaging;
-using System.Windows.Navigation;
-using System.Windows.Shapes;
-using System.Windows.Threading;
 using NLog;
-using Torch;
-using Sandbox;
-using Sandbox.Engine.Multiplayer;
 using Sandbox.Game.Gui;
-using Sandbox.Game.Multiplayer;
 using Sandbox.Game.World;
 using Torch.API;
 using Torch.API.Managers;
 using Torch.API.Session;
-using Torch.Managers;
-using Torch.Server.Managers;
 using Torch.Server.Views;
-using VRage.Game;
 using Color = VRageMath.Color;
 
 namespace Torch.Server

Torch.Server/Views/ConfigControl.xaml

@@ -130,7 +130,7 @@
             </Grid>
             <TabControl Grid.Column="1" Margin="3">
                 <TabItem Header="World">
-                    <views:PropertyGrid DataContext="{Binding SessionSettings}" />
+                    <views:PropertyGrid DataContext="{Binding SessionSettings.Wrapper}" />
                 </TabItem>
                 <TabItem Header="Torch">
                     <views:PropertyGrid x:Name="TorchSettings" />

Torch.Server/Views/ConfigControl.xaml.cs

@@ -6,17 +6,14 @@ using System.Runtime.CompilerServices;
 using System.Windows;
 using System.Windows.Controls;
 using System.Windows.Data;
-using System.Windows.Media;
 using System.Windows.Threading;
+using JetBrains.Annotations;
 using Sandbox;
 using Torch.API;
 using Torch.API.Managers;
-using Torch.Server.Annotations;
 using Torch.Server.Managers;
 using Torch.Server.ViewModels;
-using Torch.Views;
 using VRage.Game.ModAPI;
-using VRage.Serialization;
 
 namespace Torch.Server.Views
 {

Torch.Server/Views/Converters/BooleanAndConverter.cs

@@ -1,9 +1,5 @@
 using System;
-using System.Collections.Generic;
 using System.Globalization;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 using System.Windows.Data;
 
 namespace Torch.Server.Views.Converters