Fix NRE in MyGameService static constructor

keen has thrown a bunch of new static ctors so factory patch cannot be revied :(

.github/workflows/release.yaml

@@ -0,0 +1,80 @@
+name: Release
+
+on:
+  push:
+    branches: [master]
+
+jobs:
+  build:
+    name: Build
+    runs-on: ubuntu-latest
+    env:
+      BUILD_CONFIGURATION: Release
+      DOTNET_NOLOGO: true
+      DOTNET_CLI_TELEMETRY_OPTOUT: true
+    steps:
+      - uses: actions/checkout@master
+        name: Checkout
+        with:
+          ref: ${{ github.head_ref }}
+          fetch-depth: 0
+          
+      - uses: actions/setup-dotnet@v3
+        name: Setup dotnet
+        with:
+          dotnet-version: '7.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: Git Version
+        id: version
+        uses: codacy/git-version@2.7.1
+        
+      - name: Build
+        run: dotnet build Torch.Server/Torch.Server.csproj --no-restore -c ${{ env.BUILD_CONFIGURATION }} -p:Version="${{ steps.version.outputs.version }}" -p:AssemblyVersion="${{ steps.version.outputs.version }}"
+      - name: Publish
+        run: dotnet publish Torch.Server/Torch.Server.csproj --no-build -r win-x64 --sc -c ${{ env.BUILD_CONFIGURATION }} -o ./publish
+      
+      - uses: vimtor/action-zip@v1
+        name: Zip Release
+        with:
+          files: publish/
+          dest: release.zip
+      
+      - name: Create release
+        id: create_release
+        uses: actions/create-release@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          tag_name: ${{ steps.version.outputs.version }}
+          release_name: Release v${{ steps.version.outputs.version }}
+          body: ${{ steps.github_release.outputs.changelog }}
+          draft: true
+          prerelease: false
+      
+      - 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
+      
+      - uses: eregon/publish-release@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          release_id: ${{ steps.create_release.outputs.id }}
+          
+      - run: dotnet pack -c Release ./Torch.API/Torch.API.csproj -o pack --include-symbols -p:SymbolPackageFormat=snupkg -p:Version="${{ steps.version.outputs.version }}" -p:AssemblyVersion="${{ steps.version.outputs.version }}" --no-build
+      - run: dotnet pack -c Release ./Torch/Torch.csproj -o pack --include-symbols -p:SymbolPackageFormat=snupkg -p:Version="${{ steps.version.outputs.version }}" -p:AssemblyVersion="${{ steps.version.outputs.version }}" --no-build
+      - run: dotnet pack -c Release ./Torch.Server/Torch.Server.csproj -o pack --include-symbols -p:SymbolPackageFormat=snupkg -p:Version="${{ steps.version.outputs.version }}" -p:AssemblyVersion="${{ steps.version.outputs.version }}" --no-build
+      - run: mkdir blank && sed -i 's/torchVersion/${{ steps.version.outputs.version }}/g' Torch.Server.ReferenceAssemblies.net7.nuspec && nuget pack Torch.Server.ReferenceAssemblies.net7.nuspec -BasePath ./blank -OutputDirectory pack -NonInteractive -NoPackageAnalysis
+  
+      - run: dotnet nuget push ./pack/*.nupkg -s github 

.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

CHANGELOG.md

@@ -1,33 +0,0 @@
-# Torch 1.1.229.265
-* Features
-    - Added more lenient version parsing for plugins (v#.# should work)
-    - Added countdown option to restart command (!restart [seconds])
-* Fixes
-    - General fixes to work with the latest SE version
-    - Fixed config changes not saving
-    - (hopefully) Fixed issue causing crashes on servers using the Windows Classic theme
-
-# Torch 1.1.207.7
-* Notes
-    - This release makes significant changes to TorchConfig.xml. It has been renamed to Torch.cfg and has different options.
-* Features
-    - Plugins, Torch, and the DS can now all update automatically
-    - Changed command prefix to !
-    - Added manual save command (thanks to Maldark)
-    - Added restart command
-    - Improved instance creation: now creates an entire skeleton instance with blank config
-    - Added instance name to console title
-* Fixes
-    - Optimized UI so it's snappier and freezes less often
-    - Fixed NetworkManager.RaiseEvent overload that had an off-by-one bug
-    - Fixed chat window so it automatically scrolls down
-
-# Torch 1.0.182.329
-    * Improved logging, logs now to go the Logs folder and aren't deleted on start
-    * Fixed chat tab not enabling with -autostart
-    * Fixed player list
-    * Watchdog time-out is now configurable in TorchConfig.xml
-    * Fixed infinario log spam
-    * Fixed crash when sending empty message from chat tab
-    * Fixed permissions on Torch commands
-    * Changed plugin StoragePath to the current instance path (per-instance configs)

Jenkins/jenkins-grab-se.ps1

@@ -1,22 +0,0 @@
-pushd
-
-$steamData = "C:/Steam/Data/"
-$steamCMDPath = "C:/Steam/steamcmd/"
-$steamCMDZip = "C:/Steam/steamcmd.zip"
-
-Add-Type -AssemblyName System.IO.Compression.FileSystem
-
-if (!(Test-Path $steamData)) {
-	mkdir "$steamData"
-}
-if (!(Test-Path $steamCMDPath)) {
-	if (!(Test-Path $steamCMDZip)) {
-		(New-Object System.Net.WebClient).DownloadFile("https://steamcdn-a.akamaihd.net/client/installer/steamcmd.zip", "$steamCMDZip");
-	}
-	[System.IO.Compression.ZipFile]::ExtractToDirectory($steamCMDZip, $steamCMDPath)
-}
-
-cd "$steamData"
-& "$steamCMDPath/steamcmd.exe" "+login anonymous" "+force_install_dir $steamData" "+app_update 298740" "+quit"
-
-popd

Jenkins/release.ps1

@@ -1,52 +0,0 @@
-param([string] $ApiBase, [string]$tagName, [string]$authinfo, [string[]] $assetPaths)
-Add-Type -AssemblyName "System.Web"
-
-$headers = @{
-    Authorization = "Basic " + [System.Convert]::ToBase64String([System.Text.Encoding]::ASCII.GetBytes($authinfo))
-    Accept = "application/vnd.github.v3+json"
-}
-try
-{
-	Write-Output("Checking if release with tag " + $tagName + " already exists...")
-	$release = Invoke-RestMethod -Uri ($ApiBase+"releases/tags/$tagName") -Method "GET" -Headers $headers
-	Write-Output("    Using existing release " + $release.id + " at " + $release.html_url)
-} catch {
-	Write-Output("    Doesn't exist")
-	$rel_arg = @{
-	    tag_name=$tagName
-	    name="Generated $tagName"
-	    body=""
-	    draft=$TRUE
-		prerelease=$tagName.Contains("alpha") -or $tagName.Contains("beta")
-	}
-	Write-Output("Creating new release " + $tagName + "...")
-	$release = Invoke-RestMethod -Uri ($ApiBase+"releases") -Method "POST" -Headers $headers -Body (ConvertTo-Json($rel_arg))
-	Write-Output("    Created new release " + $tagName + " at " + $release.html_url)
-}
-
-$assetsApiBase = $release.assets_url
-Write-Output("Checking for existing assets...")
-$existingAssets = Invoke-RestMethod -Uri ($assetsApiBase) -Method "GET" -Headers $headers
-$assetLabels = ($assetPaths | ForEach-Object {[System.IO.Path]::GetFileName($_)})
-foreach ($asset in $existingAssets) {
-	if ($assetLabels -contains $asset.name) {
-		$uri = $asset.url
-		Write-Output("    Deleting old asset " + $asset.name + " (id " + $asset.id + "); URI=" + $uri)
-		$result = Invoke-RestMethod -Uri $uri -Method "DELETE" -Headers $headers
-	}
-}
-Write-Output("Uploading assets...")
-$uploadUrl = $release.upload_url.Substring(0, $release.upload_url.LastIndexOf('{'))
-foreach ($asset in $assetPaths) {
-	$assetName = [System.IO.Path]::GetFileName($asset)
-	$assetType = [System.Web.MimeMapping]::GetMimeMapping($asset)
-	$assetData = [System.IO.File]::ReadAllBytes($asset)
-	$headerExtra = $headers + @{
-		"Content-Type" = $assetType
-		Name = $assetName
-	}
-	$uri = $uploadUrl + "?name=" + $assetName
-	Write-Output("    Uploading " + $asset + " as " + $assetType + "; URI=" + $uri)
-	$result = Invoke-RestMethod -Uri $uri -Method "POST" -Headers $headerExtra -Body $assetData
-	Write-Output("        ID=" + $result.id + ", found at=" + $result.browser_download_url)
-}

Jenkinsfile

@@ -1,73 +0,0 @@
-def packageAndArchive(buildMode, packageName, exclude) {
-	zipFile = "bin\\${packageName}.zip"
-	packageDir = "bin\\${packageName}\\"
-
-	bat "IF EXIST ${zipFile} DEL ${zipFile}"
-	bat "IF EXIST ${packageDir} RMDIR /S /Q ${packageDir}"
-
-	bat "xcopy bin\\x64\\${buildMode} ${packageDir}"
-	if (exclude.length() > 0) {
-		bat "del ${packageDir}${exclude}"
-	}
-	powershell "Add-Type -Assembly System.IO.Compression.FileSystem; [System.IO.Compression.ZipFile]::CreateFromDirectory(\"\$PWD\\${packageDir}\", \"\$PWD\\${zipFile}\")"
-	archiveArtifacts artifacts: zipFile, caseSensitive: false, onlyIfSuccessful: true
-}
-
-node {
-	stage('Checkout') {
-		checkout scm
-		bat 'git pull --tags'
-	}
-
-	stage('Acquire SE') {
-		bat 'powershell -File Jenkins/jenkins-grab-se.ps1'
-		bat 'IF EXIST GameBinaries RMDIR GameBinaries'
-		bat 'mklink /J GameBinaries "C:/Steam/Data/DedicatedServer64/"'		
-	}
-
-	stage('Acquire NuGet Packages') {
-		bat 'nuget restore Torch.sln'
-	}
-
-	stage('Build') {
-		currentBuild.description = bat(returnStdout: true, script: '@powershell -File Versioning/version.ps1').trim()
-		if (env.BRANCH_NAME == "master") {
-			buildMode = "Release"
-		} else {
-			buildMode = "Debug"
-		}
-		bat "IF EXIST \"bin\" rmdir /Q /S \"bin\""
-		bat "IF EXIST \"bin-test\" rmdir /Q /S \"bin-test\""
-		bat "\"${tool 'MSBuild'}msbuild\" Torch.sln /p:Configuration=${buildMode} /p:Platform=x64 /t:Clean"
-		bat "\"${tool 'MSBuild'}msbuild\" Torch.sln /p:Configuration=${buildMode} /p:Platform=x64"
-	}
-
-	stage('Archive') {
-		archiveArtifacts artifacts: "bin/x64/${buildMode}/Torch*", caseSensitive: false, fingerprint: true, onlyIfSuccessful: true
-
-		packageAndArchive(buildMode, "torch-server", "Torch.Client*")
-
-		/*packageAndArchive(buildMode, "torch-client", "Torch.Server*")*/
-	}
-
-	/* Disabled because they fail builds more often than they detect actual problems
-	stage('Test') {
-		bat 'IF NOT EXIST reports MKDIR reports'
-		bat "\"packages/xunit.runner.console.2.2.0/tools/xunit.console.exe\" \"bin-test/x64/${buildMode}/Torch.Tests.dll\" \"bin-test/x64/${buildMode}/Torch.Server.Tests.dll\" \"bin-test/x64/${buildMode}/Torch.Client.Tests.dll\" -parallel none -xml \"reports/Torch.Tests.xml\""
-
-	    step([
-	        $class: 'XUnitBuilder',
-	        thresholdMode: 1,
-	        thresholds: [[$class: 'FailedThreshold', failureThreshold: '1']],
-	        tools: [[
-	            $class: 'XUnitDotNetTestType',
-	            deleteOutputFiles: true,
-	            failIfNotNew: true,
-	            pattern: 'reports/*.xml',
-	            skipNoTestFiles: false,
-	            stopProcessingIfError: true
-	        ]]
-	    ])
-	}
-	*/
-}

NLog.config

@@ -4,17 +4,21 @@
   <variable name="logStamp" value="${time} ${pad:padding=-8:inner=[${level:uppercase=true}]}" />
   <variable name="logContent" value="${message:withException=true}"/>
   
-  <targets async="true">
+  <targets>
+    <default-wrapper xsi:type="AsyncWrapper" overflowAction="Block" optimizeBufferReuse="true" />
     <target xsi:type="Null" name="null" formatMessage="false"  />
-    <target xsi:type="File" name="keen" layout="${var:logStamp} ${logger}: ${var:logContent}" fileName="Logs\Keen-${shortdate}.log" />
-    <target xsi:type="File" name="main" layout="${var:logStamp} ${logger}: ${var:logContent}" fileName="Logs\Torch-${shortdate}.log" />
+    <target xsi:type="File" keepFileOpen="true" concurrentWrites="false" name="keen" layout="${var:logStamp} ${logger}: ${var:logContent}" 
+            fileName="Logs\Keen-${shortdate}.log" />
+    <target xsi:type="File" keepFileOpen="true" concurrentWrites="false" name="main" layout="${var:logStamp} ${logger}: ${var:logContent}" 
+            fileName="Logs\Torch-${shortdate}.log" />
     <target xsi:type="File" name="chat" layout="${longdate} ${message}" fileName="Logs\Chat.log" />
     <target xsi:type="ColoredConsole" name="console" layout="${var:logStamp} ${logger:shortName=true}: ${var:logContent}" />
     <target xsi:type="File" name="patch" layout="${var:logContent}" fileName="Logs\patch.log"/>
-    <target xsi:type="FlowDocument" name="wpf" layout="${var:logStamp} ${logger:shortName=true}: ${var:logContent}" />
+    <target xsi:type="LogViewerTarget" name="wpf" layout="[${level:uppercase=true}] ${logger:shortName=true}: ${var:logContent}" />
   </targets>
 
   <rules>
+    <!-- Do not define custom rules here. Use NLog-user.config -->
     <logger name="Keen" minlevel="Warn" writeTo="main"/>
     <logger name="Keen" minlevel="Info" writeTo="console, wpf"/>
     <logger name="Keen" minlevel="Debug" writeTo="keen" final="true" />

README.md

@@ -1,5 +1,3 @@
-[![Discord](https://discordapp.com/api/guilds/230191591640268800/widget.png)](https://discord.gg/8uHZykr) [![Build Status](http://build.torchapi.net/job/Torch/job/Torch/job/master/badge/icon)](http://build.torchapi.net/job/Torch/job/Torch/job/master/)
-
 # What is Torch?
 Torch is the successor to SE Server Extender and gives server admins the tools they need to keep their Space Engineers servers running smoothly. It features a user interface with live management tools and a plugin system so you can run your server exactly how you'd like. Torch is still in early development so there may be bugs and incomplete features.
 
@@ -12,16 +10,27 @@ Torch is the successor to SE Server Extender and gives server admins the tools t
 * Organized, easy to use configuration editor
 * Extensible using the Torch plugin system
 
+### Fork Difference
+* .NET 6.0 runtime
+* Optimized in-game scripts (also newer compiler & language versions)
+* Better configuration via cli arguments, environment variables or xml config
+* Designed to run multiple instance from same install directory without having you to waste disk space 
+* Mostly compatible with original torch's plugins
+
+### Discord
+
+If you have any questions or issues please join our [discord](https://discord.gg/UyYFSe3TyQ)
+
 ### Installation
 
-* Get the latest Torch release here: https://torchapi.net/download
 * Unzip the Torch release into its own directory and run the executable. It will automatically download the SE DS and generate the other necessary files.
-  - If you already have a DS installed you can unzip the Torch files into the folder that contains the DedicatedServer64 folder.
+  - If you already have a DS installed you can:
+    * Unzip the Torch files into the folder that contains the DedicatedServer64 folder.
+    * Pass path to game files using config parameter `gamePath`
 
 # Building
-To build Torch you must first have a complete SE Dedicated installation somewhere. Before you open the solution, run the Setup batch file and enter the path of that installation's DedicatedServer64 folder. The script will make a symlink to that folder so the Torch solution can find the DLL references it needs.
 
-In both cases you will need to set the InstancePath in TorchConfig.xml to an existing dedicated server instance as Torch can't fully generate it on its own yet.
+As a regular dotnet project with cli by running `dotnet build Torch.Server/Torch.Server.csproj`, with VS 2022 or higher, with JB Rider or Fleet.
+
+If you have a more enjoyable server experience because of Torch, please consider supporting us on Patreon. (https://www.patreon.com/TorchSE)
 
-If you have a more enjoyable server experience because of Torch, please consider supporting us on Patreon.
-[![Patreon](http://i.imgur.com/VzzIMgn.png)](https://www.patreon.com/bePatron?u=847269)!

Setup (run before opening solution).bat

@@ -1,13 +0,0 @@
-:: This script creates a symlink to the game binaries to account for different installation directories on different systems.
-
-@echo off
-set /p path="Please enter the folder location of your SpaceEngineersDedicated.exe: "
-cd %~dp0
-mklink /J GameBinaries "%path%"
-if errorlevel 1 goto Error
-echo Done! You can now open the Torch solution without issue.
-goto End
-:Error
-echo An error occured creating the symlink.
-:End
-pause

Torch.API/IApplicationContext.cs

@@ -0,0 +1,30 @@
+using System.IO;
+namespace Torch.API;
+
+public interface IApplicationContext
+{
+    /// <summary>
+    /// Directory contains torch binaries.
+    /// </summary>
+    public DirectoryInfo TorchDirectory { get; }
+    /// <summary>
+    /// Root directory for all game files.
+    /// </summary>
+    public DirectoryInfo GameFilesDirectory { get; }
+    /// <summary>
+    /// Directory contains game binaries.
+    /// </summary>
+    public DirectoryInfo GameBinariesDirectory { get; }
+    /// <summary>
+    /// Current instance directory.
+    /// </summary>
+    public DirectoryInfo InstanceDirectory { get; }
+    /// <summary>
+    /// Current instance name.
+    /// </summary>
+    public string InstanceName { get; }
+    /// <summary>
+    /// Application running in service mode.
+    /// </summary>
+    public bool IsService { get; }
+}

Torch.API/ITorchBase.cs

@@ -7,6 +7,7 @@ using System.Threading.Tasks;
 using Torch.API.Managers;
 using Torch.API.Session;
 using VRage.Game.ModAPI;
+using Version = SemanticVersioning.Version;
 
 namespace Torch.API
 {
@@ -15,30 +16,6 @@ namespace Torch.API
     /// </summary>
     public interface ITorchBase
     {
-        /// <summary>
-        /// Fired when the session begins loading.
-        /// </summary>
-        [Obsolete("Prefer using the TorchSessionManager.SessionStateChanged event")]
-        event Action SessionLoading;
-
-        /// <summary>
-        /// Fired when the session finishes loading.
-        /// </summary>
-        [Obsolete("Prefer using the TorchSessionManager.SessionStateChanged event")]
-        event Action SessionLoaded;
-
-        /// <summary>
-        /// Fires when the session begins unloading.
-        /// </summary>
-        [Obsolete("Prefer using the TorchSessionManager.SessionStateChanged event")]
-        event Action SessionUnloading;
-
-        /// <summary>
-        /// Fired when the session finishes unloading.
-        /// </summary>
-        [Obsolete("Prefer using the TorchSessionManager.SessionStateChanged event")]
-        event Action SessionUnloaded;
-
         /// <summary>
         /// Gets the currently running session instance, or null if none exists.
         /// </summary>
@@ -65,7 +42,17 @@ namespace Torch.API
         /// <summary>
         /// The binary version of the current instance.
         /// </summary>
-        InformationalVersion TorchVersion { get; }
+        Version TorchVersion { get; }
+        
+        /// <summary>
+        /// Path of the dedicated instance folder.
+        /// </summary>
+        string InstancePath { get; }
+        
+        /// <summary>
+        /// Name of the dedicated instance.
+        /// </summary>
+        string InstanceName { get; }
 
         /// <summary>
         /// Invoke an action on the game thread.
@@ -104,7 +91,7 @@ namespace Torch.API
         /// <summary>
         /// Restart the Torch instance, blocking until the restart has been performed.
         /// </summary>
-        void Restart();
+        void Restart(bool save = true);
 
         /// <summary>
         /// Initializes a save of the game.
@@ -145,15 +132,12 @@ namespace Torch.API
         /// </summary>
         ServerState State { get; }
 
-        /// <summary>
-        /// Path of the dedicated instance folder.
-        /// </summary>
-        string InstancePath { get; }
-
         /// <summary>
         /// Raised when the server's Init() method has completed.
         /// </summary>
         event Action<ITorchServer> Initialized;
+        
+        TimeSpan ElapsedPlayTime { get; set; }
     }
 
     /// <summary>

Torch.API/ITorchConfig.cs

@@ -1,4 +1,6 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
+using Torch.API;
 
 namespace Torch
 {
@@ -8,17 +10,45 @@ namespace Torch
         bool ForceUpdate { get; set; }
         bool GetPluginUpdates { get; set; }
         bool GetTorchUpdates { get; set; }
+        [Obsolete("Use Torch.InstanceName instead")]
         string InstanceName { get; set; }
+        [Obsolete("Use Torch.InstancePath instead")]
         string InstancePath { get; set; }
         bool NoGui { get; set; }
         bool NoUpdate { get; set; }
-        List<string> Plugins { get; set; }
+        List<Guid> Plugins { get; set; }
+        bool LocalPlugins { get; set; }
         bool RestartOnCrash { get; set; }
         bool ShouldUpdatePlugins { get; }
         bool ShouldUpdateTorch { get; }
         int TickTimeout { get; set; }
-        string WaitForPID { get; set; }
+        string ChatName { get; set; }
+        string ChatColor { get; set; }
+        string TestPlugin { get; set; }
+        bool DisconnectOnRestart { get; set; }
+        int WindowWidth { get; set; }
+        int WindowHeight { get; set; }
+        int FontSize { get; set; }
+        UGCServiceType UgcServiceType { get; set; }
+        bool EntityManagerEnabled { get; set; }
+        string LoginToken { get; set; }
+        UpdateSource UpdateSource { get; set; }
+        List<string> Packages { get; set; }
 
-        bool Save(string path = null);
+        void Save(string path = null);
+    }
+
+    public class UpdateSource
+    {
+        public UpdateSourceType SourceType { get; set; }
+        public string Url { get; set; }
+        public string Repository { get; set; }
+        public string Branch { get; set; }
+    }
+
+    public enum UpdateSourceType
+    {
+        Github,
+        Jenkins
     }
 }

Torch.API/InformationalVersion.cs

@@ -1,52 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace Torch.API
-{
-    /// <summary>
-    /// Version in the form v#.#.#.#-info
-    /// </summary>
-    public class InformationalVersion
-    {
-        public Version Version { get; set; }
-        public string[] Information { get; set; }
-
-        public static bool TryParse(string input, out InformationalVersion version)
-        {
-            version = default(InformationalVersion);
-            var trim = input.TrimStart('v');
-            var info = trim.Split('-');
-            if (!Version.TryParse(info[0], out Version result))
-                return false;
-
-            version = new InformationalVersion { Version = result };
-
-            if (info.Length > 1)
-                version.Information = info.Skip(1).ToArray();
-
-            return true;
-        }
-
-        /// <inheritdoc />
-        public override string ToString()
-        {
-            if (Information == null || Information.Length == 0)
-                return $"v{Version}";
-
-            return $"v{Version}-{string.Join("-", Information)}";
-        }
-
-        public static explicit operator InformationalVersion(Version v)
-        {
-            return new InformationalVersion { Version = v };
-        }
-
-        public static implicit operator Version(InformationalVersion v)
-        {
-            return v.Version;
-        }
-    }
-}

Torch.API/Managers/IChatManagerClient.cs

@@ -4,31 +4,56 @@ 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
 {
     /// <summary>
     /// Represents a scripted or user chat message.
     /// </summary>
-    public struct TorchChatMessage
+    public readonly struct TorchChatMessage
     {
+        private const string DEFAULT_FONT = MyFontEnum.Blue;
+
+        #region Backwards compatibility
+
+        [Obsolete]
+        public TorchChatMessage(string author, string message, string font = DEFAULT_FONT) 
+            : this(author, message, default, font) { }
+
+        [Obsolete]
+        public TorchChatMessage(string author, ulong authorSteamId, string message, ChatChannel channel, long target, string font = DEFAULT_FONT)
+            : this(author, authorSteamId, message, channel, target, default, font) { }
+
+        [Obsolete]
+        public TorchChatMessage(ulong authorSteamId, string message, ChatChannel channel, long target, string font = DEFAULT_FONT)
+            : this(authorSteamId, message, channel, target, default, font) { }
+
+        #endregion
+        
         /// <summary>
         /// Creates a new torch chat message with the given author and message.
         /// </summary>
         /// <param name="author">Author's name</param>
         /// <param name="message">Message</param>
         /// <param name="font">Font</param>
-        public TorchChatMessage(string author, string message, string font = MyFontEnum.Blue)
+        public TorchChatMessage(string author, string message, Color color, string font = DEFAULT_FONT)
         {
             Timestamp = DateTime.Now;
             AuthorSteamId = null;
             Author = author;
             Message = message;
+            Channel = ChatChannel.Global;
+            Target = 0;
             Font = font;
+            Color = color == default ? ColorUtils.TranslateColor(font) : color;
         }
 
         /// <summary>
@@ -38,13 +63,16 @@ namespace Torch.API.Managers
         /// <param name="authorSteamId">Author's steam ID</param>
         /// <param name="message">Message</param>
         /// <param name="font">Font</param>
-        public TorchChatMessage(string author, ulong authorSteamId, string message, string font = MyFontEnum.Blue)
+        public TorchChatMessage(string author, ulong authorSteamId, string message, ChatChannel channel, long target, Color color, string font = DEFAULT_FONT)
         {
             Timestamp = DateTime.Now;
             AuthorSteamId = authorSteamId;
             Author = author;
             Message = message;
+            Channel = channel;
+            Target = target;
             Font = font;
+            Color = color == default ? ColorUtils.TranslateColor(font) : color;
         }
 
         /// <summary>
@@ -53,13 +81,16 @@ namespace Torch.API.Managers
         /// <param name="authorSteamId">Author's steam ID</param>
         /// <param name="message">Message</param>
         /// <param name="font">Font</param>
-        public TorchChatMessage(ulong authorSteamId, string message, string font = MyFontEnum.Blue)
+        public TorchChatMessage(ulong authorSteamId, string message, ChatChannel channel, long target, Color color, string font = DEFAULT_FONT)
         {
             Timestamp = DateTime.Now;
             AuthorSteamId = authorSteamId;
             Author = MyMultiplayer.Static?.GetMemberName(authorSteamId) ?? "Player";
             Message = message;
+            Channel = channel;
+            Target = target;
             Font = font;
+            Color = color == default ? ColorUtils.TranslateColor(font) : color;
         }
 
         /// <summary>
@@ -79,9 +110,21 @@ namespace Torch.API.Managers
         /// </summary>
         public readonly string Message;
         /// <summary>
+        /// The chat channel the message is part of.
+        /// </summary>
+        public readonly ChatChannel Channel;
+        /// <summary>
+        /// The intended recipient of the message.
+        /// </summary>
+        public readonly long Target;
+        /// <summary>
         /// The font, or null if default.
         /// </summary>
         public readonly string Font;
+        /// <summary>
+        /// The chat message color.
+        /// </summary>
+        public readonly Color Color;
     }
 
     /// <summary>

Torch.API/Managers/IChatManagerServer.cs

@@ -3,7 +3,10 @@ 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
 {
@@ -33,13 +36,36 @@ namespace Torch.API.Managers
         void SendMessageAsOther(ulong authorId, string message, ulong targetSteamId = 0);
 
 
+        [Obsolete("Use the other overload with a Color parameter.")]
+        void SendMessageAsOther(string author, string message, string font, ulong targetSteamId = 0);
+        
         /// <summary>
         /// Sends a scripted message with the given author and message to the given player, or all players by default.
         /// </summary>
         /// <param name="author">Author name</param>
         /// <param name="message">The message to send</param>
+        /// <param name="color">Name color</param>
         /// <param name="font">Font to use</param>
         /// <param name="targetSteamId">Player to send the message to, or everyone by default</param>
-        void SendMessageAsOther(string author, string message, string font, ulong targetSteamId = 0);
+        void SendMessageAsOther(string author, string message, Color color = default, ulong targetSteamId = 0, string font = MyFontEnum.White);
+
+        /// <summary>
+        /// Mute user from global chat.
+        /// </summary>
+        /// <param name="steamId"></param>
+        /// <returns></returns>
+        bool MuteUser(ulong steamId);
+
+        /// <summary>
+        /// Unmute user from global chat.
+        /// </summary>
+        /// <param name="steamId"></param>
+        /// <returns></returns>
+        bool UnmuteUser(ulong steamId);
+
+        /// <summary>
+        /// Users which are not allowed to chat.
+        /// </summary>
+        HashSetReader<ulong> MutedUsers { get; }
     }
 }

Torch.API/Managers/IInstanceManager.cs

@@ -0,0 +1,20 @@
+using VRage.Game;
+
+namespace Torch.API.Managers;
+
+public interface IInstanceManager : IManager
+{
+    IWorld SelectedWorld { get; } 
+    void LoadInstance(string path, bool validate = true);
+    void SelectCreatedWorld(string worldPath);
+    void SelectWorld(string worldPath, bool modsOnly = true);
+    void ImportSelectedWorldConfig();
+    void SaveConfig();
+}
+
+public interface IWorld
+{
+    string WorldPath { get; }
+    MyObjectBuilder_SessionSettings KeenSessionSettings { get; }
+    MyObjectBuilder_Checkpoint KeenCheckpoint { get; }
+}

Torch.API/Managers/IMultiplayerManagerServer.cs

@@ -3,6 +3,7 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
+using VRage.Game.ModAPI;
 
 namespace Torch.API.Managers
 {
@@ -21,6 +22,25 @@ namespace Torch.API.Managers
         /// </summary>
         void BanPlayer(ulong steamId, bool banned = true);
 
+        /// <summary>
+        /// Promotes user if possible.
+        /// </summary>
+        /// <param name="steamId"></param>
+        void PromoteUser(ulong steamId);
+
+        /// <summary>
+        /// Demotes user if possible.
+        /// </summary>
+        /// <param name="steamId"></param>
+        void DemoteUser(ulong steamId);
+
+        /// <summary>
+        /// Gets a user's promote level.
+        /// </summary>
+        /// <param name="steamId"></param>
+        /// <returns></returns>
+        MyPromoteLevel GetUserPromoteLevel(ulong steamId);
+
         /// <summary>
         /// List of the banned SteamID's
         /// </summary>        
@@ -42,5 +62,10 @@ namespace Torch.API.Managers
         /// Raised when a player is banned or unbanned. Passes SteamID of player, and true if banned, false if unbanned.
         /// </summary>
         event Action<ulong, bool> PlayerBanned;
+
+        /// <summary>
+        /// Raised when a player is promoted or demoted. Passes SteamID of player, and new promote level.
+        /// </summary>
+        event Action<ulong, MyPromoteLevel> PlayerPromoted;
     }
 }

Torch.API/Managers/IPackageManager.cs

@@ -0,0 +1,14 @@
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Reflection;
+using System.Runtime.Loader;
+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/ModAPI/TorchAPI.cs

@@ -2,7 +2,6 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices.WindowsRuntime;
 using System.Text;
 using System.Threading.Tasks;
 

Torch.API/Plugins/ITorchPlugin.cs

@@ -34,5 +34,22 @@ namespace Torch.API.Plugins
         /// This is called on the game thread after each tick.
         /// </summary>
         void Update();
+
+        /// <summary>
+        /// Plugin's enabled state. Mainly for UI niceness
+        /// </summary>
+        PluginState State { get; }
+    }
+
+    public enum PluginState
+    {
+         NotInitialized,
+         DisabledError,
+         DisabledUser,
+         UpdateRequired,
+         UninstallRequested,
+         NotInstalled,
+         MissingDependency,
+         Enabled
     }
 }

Torch.API/Properties/AssemblyInfo.cs

@@ -1,17 +0,0 @@
-using System.Reflection;
-using System.Runtime.InteropServices;
-
-[assembly: AssemblyTitle("Torch API")]
-[assembly: AssemblyDescription("")]
-[assembly: AssemblyCompany("")]
-[assembly: AssemblyProduct("Torch")]
-[assembly: AssemblyCopyright("Copyright © Torch API 2017")]
-[assembly: AssemblyTrademark("")]
-[assembly: AssemblyCulture("")]
-[assembly: ComVisible(false)]
-
-#if DEBUG
-[assembly: AssemblyConfiguration("Debug")]
-#else
-[assembly: AssemblyConfiguration("Release")]
-#endif

Torch.API/Session/ITorchSession.cs

@@ -23,6 +23,11 @@ namespace Torch.API.Session
         /// </summary>
         MySession KeenSession { get; }
         
+        /// <summary>
+        /// Currently running world
+        /// </summary>
+        IWorld World { get; }
+
         /// <inheritdoc cref="IDependencyManager"/>
         IDependencyManager Managers { get; }
 

Torch.API/Session/ITorchSessionManager.cs

@@ -1,9 +1,11 @@
 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;
 
 namespace Torch.API.Session
 {
@@ -47,5 +49,29 @@ namespace Torch.API.Session
         /// <returns>true if removed, false if not present</returns>
         /// <exception cref="ArgumentNullException">If the factory is null</exception>
         bool RemoveFactory(SessionManagerFactoryDel factory);
+
+        /// <summary>
+        /// Add a mod to be injected into client's world download.
+        /// </summary>
+        /// <param name="modId"></param>
+        /// <returns></returns>
+        bool AddOverrideMod(ulong modId);
+        
+        /// <summary>
+        /// Removes a mod from the injected mod list.
+        /// </summary>
+        /// <param name="modId"></param>
+        /// <returns></returns>
+        bool RemoveOverrideMod(ulong modId);
+        
+        /// <summary>
+        /// List over mods that will be injected into client world downloads.
+        /// </summary>
+        IReadOnlyCollection<MyObjectBuilder_Checkpoint.ModItem> OverrideMods { get; }
+
+        /// <summary>
+        /// Event raised when injected mod list changes.
+        /// </summary>
+        event Action<CollectionChangeEventArgs> OverrideModsChanged;
     }
 }

Torch.API/Torch.API.csproj

@@ -1,201 +1,30 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+<Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <ProjectGuid>{FBA5D932-6254-4A1E-BAF4-E229FA94E3C2}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <RootNamespace>Torch.API</RootNamespace>
-    <AssemblyName>Torch.API</AssemblyName>
-    <TargetFrameworkVersion>v4.6.1</TargetFrameworkVersion>
-    <FileAlignment>512</FileAlignment>
-    <TargetFrameworkProfile />
-    <NuGetPackageImportStamp>
-    </NuGetPackageImportStamp>
+    <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)|$(Platform)' == 'Debug|x64'">
-    <DebugSymbols>true</DebugSymbols>
-    <OutputPath>$(SolutionDir)\bin\x64\Debug\</OutputPath>
-    <DefineConstants>DEBUG;TRACE</DefineConstants>
-    <DebugType>full</DebugType>
-    <PlatformTarget>x64</PlatformTarget>
-    <ErrorReport>prompt</ErrorReport>
-    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x64'">
-    <OutputPath>$(SolutionDir)\bin\x64\Release\</OutputPath>
-    <DefineConstants>TRACE</DefineConstants>
-    <Optimize>true</Optimize>
-    <DebugType>pdbonly</DebugType>
-    <PlatformTarget>x64</PlatformTarget>
-    <ErrorReport>prompt</ErrorReport>
-    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
-    <DocumentationFile>$(SolutionDir)\bin\x64\Release\Torch.API.xml</DocumentationFile>
+  
+  <PropertyGroup Condition="$(Configuration) == 'Release'">
+    <NoWarn>1591</NoWarn>
   </PropertyGroup>
+  
   <ItemGroup>
-    <Reference Include="HavokWrapper, Version=1.0.6278.22649, Culture=neutral, processorArchitecture=AMD64">
-      <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\GameBinaries\HavokWrapper.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="NLog, Version=4.0.0.0, Culture=neutral, PublicKeyToken=5120e14c03d0593c, processorArchitecture=MSIL">
-      <HintPath>..\packages\NLog.4.4.12\lib\net45\NLog.dll</HintPath>
-      <Private>True</Private>
-    </Reference>
-    <Reference Include="PresentationCore" />
-    <Reference Include="PresentationFramework" />
-    <Reference Include="Sandbox.Common, Version=1.0.0.0, Culture=neutral, processorArchitecture=MSIL">
-      <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\GameBinaries\Sandbox.Common.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="Sandbox.Game, Version=0.1.6305.30774, Culture=neutral, processorArchitecture=AMD64">
-      <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\GameBinaries\Sandbox.Game.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="Sandbox.Graphics, Version=0.1.6305.30761, Culture=neutral, processorArchitecture=AMD64">
-      <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\GameBinaries\Sandbox.Graphics.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="SpaceEngineers.Game, Version=1.0.0.0, Culture=neutral, processorArchitecture=AMD64">
-      <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\GameBinaries\SpaceEngineers.Game.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="SpaceEngineers.ObjectBuilders, Version=1.0.0.0, Culture=neutral, processorArchitecture=AMD64">
-      <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\GameBinaries\SpaceEngineers.ObjectBuilders.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="SpaceEngineers.ObjectBuilders.XmlSerializers, Version=1.0.0.0, Culture=neutral, processorArchitecture=AMD64">
-      <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\GameBinaries\SpaceEngineers.ObjectBuilders.XmlSerializers.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="System" />
-    <Reference Include="System.Configuration" />
-    <Reference Include="System.Core" />
-    <Reference Include="System.IO.Compression" />
-    <Reference Include="System.Runtime.Serialization" />
-    <Reference Include="System.ServiceModel" />
-    <Reference Include="System.Transactions" />
-    <Reference Include="System.Xml.Linq" />
-    <Reference Include="System.Data.DataSetExtensions" />
-    <Reference Include="Microsoft.CSharp" />
-    <Reference Include="System.Data" />
-    <Reference Include="System.Net.Http" />
-    <Reference Include="System.Xml" />
-    <Reference Include="VRage">
-      <HintPath>..\GameBinaries\VRage.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="VRage.Audio, Version=1.0.0.0, Culture=neutral, processorArchitecture=AMD64">
-      <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\GameBinaries\VRage.Audio.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="VRage.Dedicated">
-      <HintPath>..\GameBinaries\VRage.Dedicated.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="VRage.Game, Version=1.0.0.0, Culture=neutral, processorArchitecture=MSIL">
-      <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\GameBinaries\VRage.Game.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="VRage.Game.XmlSerializers, Version=1.0.0.0, Culture=neutral, processorArchitecture=MSIL">
-      <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\GameBinaries\VRage.Game.XmlSerializers.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="VRage.Input, Version=1.0.0.0, Culture=neutral, processorArchitecture=AMD64">
-      <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\GameBinaries\VRage.Input.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="VRage.Library">
-      <HintPath>..\GameBinaries\VRage.Library.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="VRage.Math, Version=1.0.0.0, Culture=neutral, processorArchitecture=MSIL">
-      <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\GameBinaries\VRage.Math.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="VRage.Native, Version=0.0.0.0, Culture=neutral, processorArchitecture=AMD64">
-      <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\GameBinaries\VRage.Native.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="VRage.OpenVRWrapper, Version=1.0.0.0, Culture=neutral, processorArchitecture=AMD64">
-      <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\GameBinaries\VRage.OpenVRWrapper.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="VRage.Render, Version=1.0.0.0, Culture=neutral, processorArchitecture=MSIL">
-      <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\GameBinaries\VRage.Render.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="VRage.Render11, Version=1.0.0.0, Culture=neutral, processorArchitecture=AMD64">
-      <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\GameBinaries\VRage.Render11.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="VRage.Scripting, Version=1.0.0.0, Culture=neutral, processorArchitecture=AMD64">
-      <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\GameBinaries\VRage.Scripting.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
+    <PackageReference Include="JorgeSerrano.Json.JsonSnakeCaseNamingPolicy" Version="0.9.0" />
+    <PackageReference Include="NLog" Version="5.1.0" />
+    <PackageReference Include="NuGet.Commands" Version="6.4.0" />
+    <PackageReference Include="NuGet.DependencyResolver.Core" Version="6.4.0" />
+    <PackageReference Include="SemanticVersioning" Version="2.0.2" />
+    <PackageReference Include="SpaceEngineersDedicated.ReferenceAssemblies" Version="1.202.120">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>compile</IncludeAssets>
+    </PackageReference>
+    <PackageReference Include="System.Linq.Async" Version="6.0.1" />
   </ItemGroup>
-  <ItemGroup>
-    <Compile Include="..\Versioning\AssemblyVersion.cs">
-      <Link>Properties\AssemblyVersion.cs</Link>
-    </Compile>
-    <Compile Include="ConnectionState.cs" />
-    <Compile Include="InformationalVersion.cs" />
-    <Compile Include="ITorchConfig.cs" />
-    <Compile Include="Managers\DependencyManagerExtensions.cs" />
-    <Compile Include="Managers\DependencyProviderExtensions.cs" />
-    <Compile Include="Event\EventHandlerAttribute.cs" />
-    <Compile Include="Event\IEvent.cs" />
-    <Compile Include="Event\IEventHandler.cs" />
-    <Compile Include="Managers\IChatManagerClient.cs" />
-    <Compile Include="Managers\IChatManagerServer.cs" />
-    <Compile Include="Managers\IDependencyManager.cs" />
-    <Compile Include="Managers\IDependencyProvider.cs" />
-    <Compile Include="Event\IEventManager.cs" />
-    <Compile Include="Managers\IManager.cs" />
-    <Compile Include="Managers\IMultiplayerManagerClient.cs" />
-    <Compile Include="Managers\IMultiplayerManagerBase.cs" />
-    <Compile Include="IPlayer.cs" />
-    <Compile Include="Managers\IMultiplayerManagerServer.cs" />
-    <Compile Include="Managers\INetworkManager.cs" />
-    <Compile Include="Managers\IPluginManager.cs" />
-    <Compile Include="Plugins\ITorchPlugin.cs" />
-    <Compile Include="IServerControls.cs" />
-    <Compile Include="ITorchBase.cs" />
-    <Compile Include="Plugins\IWpfPlugin.cs" />
-    <Compile Include="ModAPI\Ingame\GridExtensions.cs" />
-    <Compile Include="Plugins\PluginAttribute.cs" />
-    <Compile Include="Properties\AssemblyInfo.cs" />
-    <Compile Include="ServerState.cs" />
-    <Compile Include="ModAPI\TorchAPI.cs" />
-    <Compile Include="Session\GameSaveResult.cs" />
-    <Compile Include="Session\ITorchSession.cs" />
-    <Compile Include="Session\ITorchSessionManager.cs" />
-    <Compile Include="Session\TorchSessionState.cs" />
-    <Compile Include="TorchGameState.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{508349B6-6B84-4DF5-91F0-309BEEBAD82D}" />
-  </ItemGroup>
-  <ItemGroup />
-  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
-  <Import Project="$(SolutionDir)\TransformOnBuild.targets" />
 </Project>

Torch.API/UGCServiceType.cs

@@ -0,0 +1,8 @@
+namespace Torch.API
+{
+    public enum UGCServiceType
+    {
+        Steam,
+        EOS
+    }
+}

Torch.API/Utils/ColorUtils.cs

@@ -0,0 +1,40 @@
+using System.Windows.Media;
+using VRage.Game;
+using Color = VRageMath.Color;
+
+namespace Torch.Utils
+{
+    public static class ColorUtils
+    {
+        /// <summary>
+        /// Convert the old "font" or a RGB hex code to a Color.
+        /// </summary>
+        public static Color TranslateColor(string font)
+        {
+            if (StringUtils.IsFontEnum(font))
+            {
+                // RGB values copied from Fonts.sbc
+                switch (font)
+                {
+                    case MyFontEnum.Blue:
+                        return new Color(220, 244, 252);
+                    case MyFontEnum.Red:
+                        return new Color(227, 65, 65);
+                    case MyFontEnum.Green:
+                        return new Color(101, 182, 193);
+                    case MyFontEnum.DarkBlue:
+                        return new Color(94, 115, 127);
+                    default:
+                        return Color.White;
+                }
+            }
+            else
+            {
+                // VRage color doesn't have its own hex code parser and I don't want to write one
+                var conv = (System.Windows.Media.Color)(ColorConverter.ConvertFromString(font) ?? 
+                                                        System.Windows.Media.Color.FromRgb(255, 255, 255));
+                return new Color(conv.R, conv.G, conv.B);
+            }
+        }
+    }
+}

Torch.API/Utils/SemanticVersionConverter.cs

@@ -0,0 +1,21 @@
+#nullable enable
+using System;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using Version = SemanticVersioning.Version;
+
+namespace Torch.API.Utils;
+
+public class SemanticVersionConverter : JsonConverter<Version>
+{
+    public override Version? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        Version.TryParse(reader.GetString(), out var ver);
+        return ver;
+    }
+
+    public override void Write(Utf8JsonWriter writer, Version value, JsonSerializerOptions options)
+    {
+        writer.WriteStringValue(value.ToString());
+    }
+}

Torch.API/Utils/StringUtils.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Reflection;
 using System.Text;
 using System.Threading.Tasks;
 
@@ -60,5 +61,13 @@ namespace Torch.Utils
             }
             return builder?.ToString() ?? "";
         }
+
+        private static string[] FontEnumValues => _fontEnumValues ?? (_fontEnumValues = typeof(VRage.Game.MyFontEnum).GetFields(BindingFlags.Public | BindingFlags.Static).Where(x => x.IsLiteral && !x.IsInitOnly).Select(x => (string)x.GetValue(null)).ToArray());
+
+        private static string[] _fontEnumValues;
+        public static bool IsFontEnum(string str)
+        {
+            return FontEnumValues.Contains(str);
+        }
     }
 }

Torch.API/WebAPI/Plugin/IPluginQuery.cs

@@ -0,0 +1,12 @@
+using System;
+using System.Threading.Tasks;
+
+namespace Torch.API.WebAPI.Plugin;
+
+public interface IPluginQuery
+{
+    Task<PluginsResponse> QueryAll();
+    Task<PluginItem> QueryOne(Guid guid);
+    Task<bool> DownloadPlugin(Guid guid, string path = null);
+    Task<bool> DownloadPlugin(PluginItem item, string path = null);
+}

Torch.API/WebAPI/Plugin/LegacyPluginQuery.cs

@@ -0,0 +1,81 @@
+using System;
+using System.IO;
+using System.Linq;
+using System.Net.Http;
+using System.Net.Http.Json;
+using System.Threading;
+using System.Threading.Tasks;
+using NLog;
+
+namespace Torch.API.WebAPI.Plugin;
+
+public class LegacyPluginQuery : IPluginQuery
+{
+    private const string BASE_URL = "https://torchapi.com/";
+    private readonly HttpClient _client;
+    private static readonly Logger Log = LogManager.GetCurrentClassLogger();
+
+    private LegacyPluginQuery()
+    {
+        _client = new()
+        {
+            BaseAddress = new(BASE_URL)
+        };
+    }
+    
+    public static LegacyPluginQuery Instance { get; } = new();
+
+    public async Task<PluginsResponse> QueryAll()
+    {
+        return await _client.GetFromJsonAsync<PluginsResponse>("/api/plugins/", CancellationToken.None);
+    }
+
+    public async Task<PluginItem> QueryOne(Guid guid)
+    {
+        using var res = await _client.GetAsync($"/api/plugins/search/{guid}");
+        if (!res.IsSuccessStatusCode)
+            return null;
+        return await res.Content.ReadFromJsonAsync<PluginItem>();
+    }
+
+    public async Task<bool> DownloadPlugin(Guid guid, string path = null)
+    {
+        var item = await QueryOne(guid);
+        if (item is null) return false;
+        return await DownloadPlugin(item, path);
+    }
+
+    public async Task<bool> DownloadPlugin(PluginItem item, string path = null)
+    {
+        try
+        {
+            path ??= Path.Combine(AppContext.BaseDirectory, "Plugins", $"{item.Name}.zip");
+                
+            if (item.Versions.Length == 0)
+            {
+                Log.Error($"Selected plugin {item.Name} does not have any versions to download!");
+                return false;
+            }
+            var version = item.Versions.FirstOrDefault(v => v.Version == item.LatestVersion);
+            if (version is null)
+            {
+                Log.Error($"Could not find latest version for selected plugin {item.Name}");
+                return false;
+            }
+            var s = await _client.GetStreamAsync(version.Url);
+
+            if(File.Exists(path))
+                File.Delete(path);
+
+            await using var f = File.Create(path);
+            await s.CopyToAsync(f);
+        }
+        catch (Exception ex)
+        {
+            Log.Error(ex, "Failed to download plugin!");
+            return false;
+        }
+
+        return true;
+    }
+}

Torch.API/WebAPI/Plugin/PluginItem.cs

@@ -0,0 +1,11 @@
+using System;
+using System.Text.Json.Serialization;
+
+namespace Torch.API.WebAPI.Plugin;
+
+public record PluginItem(Guid Id, string Name, string Author, string Description, string LatestVersion,
+                         VersionItem[] Versions)
+{
+    [JsonIgnore]
+    public bool Installed { get; set; }
+}

Torch.API/WebAPI/Plugin/PluginsResponse.cs

@@ -0,0 +1,3 @@
+namespace Torch.API.WebAPI.Plugin;
+
+public record PluginsResponse(PluginItem[] Plugins);

Torch.API/WebAPI/Plugin/VersionItem.cs

@@ -0,0 +1,6 @@
+using System.Text.Json.Serialization;
+
+namespace Torch.API.WebAPI.Plugin;
+
+public record VersionItem(string Version, string Note, [property: JsonPropertyName("is_beta")] bool IsBeta,
+                          string Url);

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,12 @@
+#nullable enable
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+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

@@ -0,0 +1,128 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+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;
+
+public class GithubQuery : IUpdateQuery
+{
+    private readonly HttpClient _client;
+
+    public GithubQuery(string url)
+    {
+        if (url == null) throw new ArgumentNullException(nameof(url));
+        
+        _client = new()
+        {
+            BaseAddress = new(url),
+            DefaultVersionPolicy = HttpVersionPolicy.RequestVersionOrHigher,
+            DefaultRequestHeaders =
+            {
+                {"User-Agent", "TorchAPI"}
+            }
+        };
+    }
+
+    public void Dispose()
+    {
+        _client?.Dispose();
+    }
+
+    public async Task<UpdateRelease> GetLatestReleaseAsync(string repository, string branch = null)
+    {
+        var response = await _client.GetFromJsonAsync<Release>($"/repos/{repository}/releases/latest", new JsonSerializerOptions(JsonSerializerDefaults.Web)
+        {
+            PropertyNamingPolicy = new JsonSnakeCaseNamingPolicy()
+        });
+
+        if (response is null)
+            throw new($"Unable to get latest release for {repository}");
+
+        return new(Version.Parse(response.TagName), response.Assets.First(b => b.Name == "torch-server.zip").BrowserDownloadUrl);
+    }
+    
+    private record Asset(
+        string Url,
+        int Id,
+        string NodeId,
+        string Name,
+        string Label,
+        Uploader Uploader,
+        string ContentType,
+        string State,
+        int Size,
+        int DownloadCount,
+        DateTime CreatedAt,
+        DateTime UpdatedAt,
+        string BrowserDownloadUrl
+    );
+    
+    private record Author(
+        string Login,
+        int Id,
+        string NodeId,
+        string AvatarUrl,
+        string GravatarId,
+        string Url,
+        string HtmlUrl,
+        string FollowersUrl,
+        string FollowingUrl,
+        string GistsUrl,
+        string StarredUrl,
+        string SubscriptionsUrl,
+        string OrganizationsUrl,
+        string ReposUrl,
+        string EventsUrl,
+        string ReceivedEventsUrl,
+        string Type,
+        bool SiteAdmin
+    );
+    
+    private record Release(
+        string Url,
+        string AssetsUrl,
+        string UploadUrl,
+        string HtmlUrl,
+        int Id,
+        Author Author,
+        string NodeId,
+        string TagName,
+        string TargetCommitish,
+        string Name,
+        bool Draft,
+        bool Prerelease,
+        DateTime CreatedAt,
+        DateTime PublishedAt,
+        IReadOnlyList<Asset> Assets,
+        string TarballUrl,
+        string ZipballUrl,
+        string Body
+    );
+    
+    private record Uploader(
+        string Login,
+        int Id,
+        string NodeId,
+        string AvatarUrl,
+        string GravatarId,
+        string Url,
+        string HtmlUrl,
+        string FollowersUrl,
+        string FollowingUrl,
+        string GistsUrl,
+        string StarredUrl,
+        string SubscriptionsUrl,
+        string OrganizationsUrl,
+        string ReposUrl,
+        string EventsUrl,
+        string ReceivedEventsUrl,
+        string Type,
+        bool SiteAdmin
+    );
+}

Torch.API/WebAPI/Update/IUpdateQuery.cs

@@ -0,0 +1,9 @@
+using System;
+using System.Threading.Tasks;
+
+namespace Torch.API.WebAPI.Update;
+
+public interface IUpdateQuery : IDisposable
+{
+    Task<UpdateRelease> GetLatestReleaseAsync(string repository, string branch = null);
+}

Torch.API/WebAPI/Update/JenkinsQuery.cs

@@ -0,0 +1,65 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net.Http;
+using System.Net.Http.Json;
+using System.Text.Json.Serialization;
+using System.Threading.Tasks;
+using Torch.API.Utils;
+using Version = SemanticVersioning.Version;
+
+namespace Torch.API.WebAPI.Update
+{
+    public class JenkinsQuery : IUpdateQuery
+    {
+        private const string ApiPath = "api/json";
+        private readonly HttpClient _client;
+        
+        public JenkinsQuery(string url)
+        {
+            if (url == null) throw new ArgumentNullException(nameof(url));
+            
+            _client = new()
+            {
+                BaseAddress = new(url)
+            };
+        }
+
+        public async Task<UpdateRelease> GetLatestReleaseAsync(string repository, string branch = null)
+        {
+            branch ??= "master";
+
+            var response = await _client.GetFromJsonAsync<BranchResponse>($"/job/{repository}/job/{branch}/{ApiPath}");
+
+            if (response is null)
+                throw new($"Unable to get latest release for {repository}");
+
+            var job = await _client.GetFromJsonAsync<Job>(
+                $"/job/{repository}/job/{branch}/{response.LastBuild.Number}/{ApiPath}");
+            
+            if (job is null)
+                throw new($"Unable to get latest release for job {repository}/{response.LastBuild.Number}");
+
+            return new(job.Version, job.Url + job.Artifacts.First(b => b.FileName == "torch-server.zip").RelativePath);
+        }
+
+        public void Dispose()
+        {
+            _client?.Dispose();
+        }
+    }
+
+    public record BranchResponse(string Name, string Url, Build LastBuild, Build LastStableBuild);
+
+    public record Build(int Number, string Url);
+
+    public record Job(int Number, bool Building, string Description, string Result, string Url,
+        [property: JsonConverter(typeof(SemanticVersionConverter))] Version Version,
+                      IReadOnlyList<Artifact> Artifacts);
+    
+    public record Artifact(
+        string DisplayPath,
+        string FileName,
+        string RelativePath
+    );
+}

Torch.API/WebAPI/Update/UpdateRelease.cs

@@ -0,0 +1,5 @@
+using SemanticVersioning;
+
+namespace Torch.API.WebAPI.Update;
+
+public record UpdateRelease(Version Version, string ArtifactUrl);

Torch.API/packages.config

@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="Mono.TextTransform" version="1.0.0" targetFramework="net461" />
-  <package id="NLog" version="4.4.12" targetFramework="net461" />
-</packages>

Torch.API/packages.lock.json

@@ -0,0 +1,178 @@
+{
+  "version": 1,
+  "dependencies": {
+    "net7.0-windows7.0": {
+      "JorgeSerrano.Json.JsonSnakeCaseNamingPolicy": {
+        "type": "Direct",
+        "requested": "[0.9.0, )",
+        "resolved": "0.9.0",
+        "contentHash": "xCqODS+wzpUXNtg4bMMvXG5PLbP0iTwRzRn2R+zWHKm83E6tbV2bCagawXp1EnZeNpd5OXpMxehulZWns8efzQ=="
+      },
+      "NLog": {
+        "type": "Direct",
+        "requested": "[5.1.0, )",
+        "resolved": "5.1.0",
+        "contentHash": "oW7ekrkRG9okpDMUcEglunWj8Qf2RY8qkgl+/chJoavzg3dbT13y32t19R54FKkmq80fKzw4ZekZkCrRGanKgQ=="
+      },
+      "NuGet.Commands": {
+        "type": "Direct",
+        "requested": "[6.4.0, )",
+        "resolved": "6.4.0",
+        "contentHash": "j3ma45boGZADsHpJcu3Y2yq+n2luicC6ezd61TXTTzbOzA452oAPaSsFGUB1stIsuP/DVoqkTzjHXjaCHuJKPQ==",
+        "dependencies": {
+          "NuGet.Credentials": "6.4.0",
+          "NuGet.ProjectModel": "6.4.0"
+        }
+      },
+      "NuGet.DependencyResolver.Core": {
+        "type": "Direct",
+        "requested": "[6.4.0, )",
+        "resolved": "6.4.0",
+        "contentHash": "AKomZEKuhQlshujuiHbKvwl2cZNGq3SHsXFbpjCfCjMFMLwwA8saJGQQZp1lzsqQWcQWa6hLOcPtm7T3rd0SVg==",
+        "dependencies": {
+          "NuGet.Configuration": "6.4.0",
+          "NuGet.LibraryModel": "6.4.0",
+          "NuGet.Protocol": "6.4.0"
+        }
+      },
+      "SemanticVersioning": {
+        "type": "Direct",
+        "requested": "[2.0.2, )",
+        "resolved": "2.0.2",
+        "contentHash": "4EQgYdNZ92SyaO7YFk6olVnebF5V+jrHyMUjvPq89tLeMo8NSfgDF+6Zwq/lgh9j/0yfQp9Lkm0ZA0rUATCZFA=="
+      },
+      "SpaceEngineersDedicated.ReferenceAssemblies": {
+        "type": "Direct",
+        "requested": "[1.202.120, )",
+        "resolved": "1.202.120",
+        "contentHash": "HTP48NOSZY3eQPX3GJN+gjxdW83SM7DX6NcKCFqNIIvjz/J+l8uimHAQp9dnLySb0wb1K1Z1xBPIXyxMQRREIw==",
+        "dependencies": {
+          "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=="
+      },
+      "Newtonsoft.Json": {
+        "type": "Transitive",
+        "resolved": "13.0.1",
+        "contentHash": "ppPFpBcvxdsfUonNcvITKqLl3bqxWbDCZIzDWHzjpdAHRFfZe0Dw9HmA0+za13IdyrgJwpkDTDA9fHaxOrt20A=="
+      },
+      "NuGet.Common": {
+        "type": "Transitive",
+        "resolved": "6.4.0",
+        "contentHash": "srECugLk+LB1bXelDCDhHoi6do/EYTXzuntKhjHraS4roVB3NfWohEdCSiAPdpSV9M40Q6jo6MV2Srml9e+jHQ==",
+        "dependencies": {
+          "NuGet.Frameworks": "6.4.0"
+        }
+      },
+      "NuGet.Configuration": {
+        "type": "Transitive",
+        "resolved": "6.4.0",
+        "contentHash": "vPjauG9AoacEjiZWGIs+d11FCRVmseqAw78FIApfLvZrYMEbbwc9vc0LdC3PpoW5FxYkktyZSiiXVKXGLu+gXw==",
+        "dependencies": {
+          "NuGet.Common": "6.4.0",
+          "System.Security.Cryptography.ProtectedData": "4.4.0"
+        }
+      },
+      "NuGet.Credentials": {
+        "type": "Transitive",
+        "resolved": "6.4.0",
+        "contentHash": "tebsxclknVz3D4FrvE2MzVcsOyf6PffjGNQ77X9Yvbj9x5YpVWfumVPetqETcdsNEgiN0bBzfMre33lhrY7Itw==",
+        "dependencies": {
+          "NuGet.Protocol": "6.4.0"
+        }
+      },
+      "NuGet.Frameworks": {
+        "type": "Transitive",
+        "resolved": "6.4.0",
+        "contentHash": "qcufbjJIDtyY/Hah7JJfcRVpRYM3scgPqYBnukjO9kfADCFGr2azvVBozuwzljA6w/cR3w8bXLq6vW5xGrsmHw=="
+      },
+      "NuGet.LibraryModel": {
+        "type": "Transitive",
+        "resolved": "6.4.0",
+        "contentHash": "K6ROQpWr34Aje81G0HfipiznLTB8vD4BO8sF6FEwx1KjJVdFkSmGZPmAhc6L1vZPs8TKY5BqoH72zG13zVzW2w==",
+        "dependencies": {
+          "NuGet.Common": "6.4.0",
+          "NuGet.Versioning": "6.4.0"
+        }
+      },
+      "NuGet.Packaging": {
+        "type": "Transitive",
+        "resolved": "6.4.0",
+        "contentHash": "aR10aYqcUMGC2mwMGH5rls/MGaz3EVH8DKTTHQ/EC91hXNtrCTTAQonaRR+v1EItcoxtQeZ/WQOorv4z270Tgg==",
+        "dependencies": {
+          "Newtonsoft.Json": "13.0.1",
+          "NuGet.Configuration": "6.4.0",
+          "NuGet.Versioning": "6.4.0",
+          "System.Security.Cryptography.Cng": "5.0.0",
+          "System.Security.Cryptography.Pkcs": "5.0.0"
+        }
+      },
+      "NuGet.ProjectModel": {
+        "type": "Transitive",
+        "resolved": "6.4.0",
+        "contentHash": "eW9Q7vPk8cpXDd5b+vtIPkl8dSDCPkPJPrjXPTfZGxhstldnhJrj1XPaonsDZLQ24YY7LrYCzC0BiHh3iO5zUA==",
+        "dependencies": {
+          "NuGet.DependencyResolver.Core": "6.4.0"
+        }
+      },
+      "NuGet.Protocol": {
+        "type": "Transitive",
+        "resolved": "6.4.0",
+        "contentHash": "KIPjsWP0P3EMsDsXaa6YBCTvYKur/zI0luS1kO5G37ci8mHs2kJFsuG5qaMhGvgyHASu54sxlic1n1oza2Pcbw==",
+        "dependencies": {
+          "NuGet.Packaging": "6.4.0"
+        }
+      },
+      "NuGet.Versioning": {
+        "type": "Transitive",
+        "resolved": "6.4.0",
+        "contentHash": "YE8p3TpX4jIw+Gb24maE8YRDoqWA4imLmCbdOj5IvslLrZJXQ8akeFOGOplxICNVevON1g1SFYT2+cq4yy0nQQ=="
+      },
+      "protobuf-net": {
+        "type": "Transitive",
+        "resolved": "1.0.0",
+        "contentHash": "kTGOK0E87473sOImOjgZOnz3kTC2aMLffoRWQLYNuBLJnwNNmjanF9IkevZ9Q7yYLeABQfcF3BpeepuMntMVNw=="
+      },
+      "System.Formats.Asn1": {
+        "type": "Transitive",
+        "resolved": "5.0.0",
+        "contentHash": "MTvUIktmemNB+El0Fgw9egyqT9AYSIk6DTJeoDSpc3GIHxHCMo8COqkWT1mptX5tZ1SlQ6HJZ0OsSvMth1c12w=="
+      },
+      "System.Security.Cryptography.Cng": {
+        "type": "Transitive",
+        "resolved": "5.0.0",
+        "contentHash": "jIMXsKn94T9JY7PvPq/tMfqa6GAaHpElRDpmG+SuL+D3+sTw2M8VhnibKnN8Tq+4JqbPJ/f+BwtLeDMEnzAvRg==",
+        "dependencies": {
+          "System.Formats.Asn1": "5.0.0"
+        }
+      },
+      "System.Security.Cryptography.Pkcs": {
+        "type": "Transitive",
+        "resolved": "5.0.0",
+        "contentHash": "9TPLGjBCGKmNvG8pjwPeuYy0SMVmGZRwlTZvyPHDbYv/DRkoeumJdfumaaDNQzVGMEmbWtg07zUpSW9q70IlDQ==",
+        "dependencies": {
+          "System.Formats.Asn1": "5.0.0",
+          "System.Security.Cryptography.Cng": "5.0.0"
+        }
+      },
+      "System.Security.Cryptography.ProtectedData": {
+        "type": "Transitive",
+        "resolved": "4.4.0",
+        "contentHash": "cJV7ScGW7EhatRsjehfvvYVBvtiSMKgN8bOVI0bQhnF5bU7vnHVIsH49Kva7i7GWaWYvmEzkYVk1TC+gZYBEog=="
+      }
+    }
+  }
+}

Torch.Client.Tests/Properties/AssemblyInfo.cs

@@ -1,17 +0,0 @@
-using System.Reflection;
-using System.Runtime.InteropServices;
-
-[assembly: AssemblyTitle("Torch Client Tests")]
-[assembly: AssemblyDescription("")]
-[assembly: AssemblyCompany("")]
-[assembly: AssemblyProduct("Torch")]
-[assembly: AssemblyCopyright("Copyright © Torch API 2017")]
-[assembly: AssemblyTrademark("")]
-[assembly: AssemblyCulture("")]
-[assembly: ComVisible(false)]
-
-#if DEBUG
-[assembly: AssemblyConfiguration("Debug")]
-#else
-[assembly: AssemblyConfiguration("Release")]
-#endif

Torch.Client.Tests/Torch.Client.Tests.csproj

@@ -1,97 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
-  <PropertyGroup>
-    <ProjectGuid>{632E78C0-0DAC-4B71-B411-2F1B333CC310}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <RootNamespace>Torch.Client.Tests</RootNamespace>
-    <AssemblyName>Torch.Client.Tests</AssemblyName>
-    <TargetFrameworkVersion>v4.6.1</TargetFrameworkVersion>
-    <FileAlignment>512</FileAlignment>
-    <TargetFrameworkProfile />
-    <NuGetPackageImportStamp>
-    </NuGetPackageImportStamp>
-    <NoWarn>1591,0649</NoWarn>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x64'">
-    <DebugSymbols>true</DebugSymbols>
-    <OutputPath>$(SolutionDir)\bin-test\x64\Debug\</OutputPath>
-    <DefineConstants>DEBUG;TRACE</DefineConstants>
-    <DebugType>full</DebugType>
-    <PlatformTarget>x64</PlatformTarget>
-    <ErrorReport>prompt</ErrorReport>
-    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x64'">
-    <OutputPath>$(SolutionDir)\bin-test\x64\Release\</OutputPath>
-    <DefineConstants>TRACE</DefineConstants>
-    <Optimize>true</Optimize>
-    <DebugType>pdbonly</DebugType>
-    <PlatformTarget>x64</PlatformTarget>
-    <ErrorReport>prompt</ErrorReport>
-    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
-    <DocumentationFile>$(SolutionDir)\bin-test\x64\Release\Torch.Client.Tests.xml</DocumentationFile>
-  </PropertyGroup>
-  <ItemGroup>
-    <Reference Include="NLog, Version=4.0.0.0, Culture=neutral, PublicKeyToken=5120e14c03d0593c, processorArchitecture=MSIL">
-      <HintPath>..\packages\NLog.4.4.12\lib\net45\NLog.dll</HintPath>
-      <Private>True</Private>
-    </Reference>
-    <Reference Include="System" />
-    <Reference Include="System.Core" />
-    <Reference Include="System.Xml.Linq" />
-    <Reference Include="System.Data.DataSetExtensions" />
-    <Reference Include="Microsoft.CSharp" />
-    <Reference Include="System.Data" />
-    <Reference Include="System.Net.Http" />
-    <Reference Include="System.Xml" />
-    <Reference Include="xunit.abstractions, Version=2.0.0.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
-      <HintPath>..\packages\xunit.abstractions.2.0.1\lib\net35\xunit.abstractions.dll</HintPath>
-    </Reference>
-    <Reference Include="xunit.assert, Version=2.2.0.3545, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
-      <HintPath>..\packages\xunit.assert.2.2.0\lib\netstandard1.1\xunit.assert.dll</HintPath>
-    </Reference>
-    <Reference Include="xunit.core, Version=2.2.0.3545, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
-      <HintPath>..\packages\xunit.extensibility.core.2.2.0\lib\netstandard1.1\xunit.core.dll</HintPath>
-    </Reference>
-    <Reference Include="xunit.execution.desktop, Version=2.2.0.3545, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
-      <HintPath>..\packages\xunit.extensibility.execution.2.2.0\lib\net452\xunit.execution.desktop.dll</HintPath>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <Compile Include="..\Versioning\AssemblyVersion.cs">
-      <Link>Properties\AssemblyVersion.cs</Link>
-    </Compile>
-    <Compile Include="Properties\AssemblyInfo.cs" />
-    <Compile Include="TorchClientReflectionTest.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="..\Torch.API\Torch.API.csproj">
-      <Project>{fba5d932-6254-4a1e-baf4-e229fa94e3c2}</Project>
-      <Name>Torch.API</Name>
-    </ProjectReference>
-    <ProjectReference Include="..\Torch.Client\Torch.Client.csproj">
-      <Project>{e36df745-260b-4956-a2e8-09f08b2e7161}</Project>
-      <Name>Torch.Client</Name>
-    </ProjectReference>
-    <ProjectReference Include="..\Torch.Tests\Torch.Tests.csproj">
-      <Project>{c3c8b671-6ad1-44aa-a8da-e0c0dc0fedf5}</Project>
-      <Name>Torch.Tests</Name>
-    </ProjectReference>
-    <ProjectReference Include="..\Torch\Torch.csproj">
-      <Project>{7e01635c-3b67-472e-bcd6-c5539564f214}</Project>
-      <Name>Torch</Name>
-      <Private>True</Private>
-    </ProjectReference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{508349B6-6B84-4DF5-91F0-309BEEBAD82D}" />
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
-  <Import Project="$(SolutionDir)\TransformOnBuild.targets" />
-</Project>

Torch.Client.Tests/TorchClientReflectionTest.cs

@@ -1,94 +0,0 @@
-using System;
-using System.Collections.Generic;
-using Torch.Client;
-using Torch.Tests;
-using Torch.Utils;
-using Xunit;
-
-namespace Torch.Client.Tests
-{
-    public class TorchClientReflectionTest
-    {
-        static TorchClientReflectionTest()
-        {
-            TestUtils.Init();
-        }
-
-        private static ReflectionTestManager _manager;
-
-        private static ReflectionTestManager Manager()
-        {
-            if (_manager != null)
-                return _manager;
-
-            return _manager = new ReflectionTestManager().Init(typeof(TorchClient).Assembly);
-        }
-
-        public static IEnumerable<object[]> Getters => Manager().Getters;
-
-        public static IEnumerable<object[]> Setters => Manager().Setters;
-
-        public static IEnumerable<object[]> Invokers => Manager().Invokers;
-
-        public static IEnumerable<object[]> MemberInfo => Manager().MemberInfo;
-
-        public static IEnumerable<object[]> Events => Manager().Events;
-
-        #region Binding
-        [Theory]
-        [MemberData(nameof(Getters))]
-        public void TestBindingGetter(ReflectionTestManager.FieldRef field)
-        {
-            if (field.Field == null)
-                return;
-            Assert.True(ReflectedManager.Process(field.Field));
-            if (field.Field.IsStatic)
-                Assert.NotNull(field.Field.GetValue(null));
-        }
-
-        [Theory]
-        [MemberData(nameof(Setters))]
-        public void TestBindingSetter(ReflectionTestManager.FieldRef field)
-        {
-            if (field.Field == null)
-                return;
-            Assert.True(ReflectedManager.Process(field.Field));
-            if (field.Field.IsStatic)
-                Assert.NotNull(field.Field.GetValue(null));
-        }
-
-        [Theory]
-        [MemberData(nameof(Invokers))]
-        public void TestBindingInvoker(ReflectionTestManager.FieldRef field)
-        {
-            if (field.Field == null)
-                return;
-            Assert.True(ReflectedManager.Process(field.Field));
-            if (field.Field.IsStatic)
-                Assert.NotNull(field.Field.GetValue(null));
-        }
-
-        [Theory]
-        [MemberData(nameof(MemberInfo))]
-        public void TestBindingMemberInfo(ReflectionTestManager.FieldRef field)
-        {
-            if (field.Field == null)
-                return;
-            Assert.True(ReflectedManager.Process(field.Field));
-            if (field.Field.IsStatic)
-                Assert.NotNull(field.Field.GetValue(null));
-        }
-
-        [Theory]
-        [MemberData(nameof(Events))]
-        public void TestBindingEvents(ReflectionTestManager.FieldRef field)
-        {
-            if (field.Field == null)
-                return;
-            Assert.True(ReflectedManager.Process(field.Field));
-            if (field.Field.IsStatic)
-                ((Func<ReflectedEventReplacer>)field.Field.GetValue(null)).Invoke();
-        }
-        #endregion
-    }
-}

Torch.Client.Tests/packages.config

@@ -1,12 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="Mono.TextTransform" version="1.0.0" targetFramework="net461" />
-  <package id="NLog" version="4.4.12" targetFramework="net461" />
-  <package id="xunit" version="2.2.0" targetFramework="net461" />
-  <package id="xunit.abstractions" version="2.0.1" targetFramework="net461" />
-  <package id="xunit.assert" version="2.2.0" targetFramework="net461" />
-  <package id="xunit.core" version="2.2.0" targetFramework="net461" />
-  <package id="xunit.extensibility.core" version="2.2.0" targetFramework="net461" />
-  <package id="xunit.extensibility.execution" version="2.2.0" targetFramework="net461" />
-  <package id="xunit.runner.console" version="2.2.0" targetFramework="net461" developmentDependency="true" />
-</packages>

Torch.Client/Manager/MultiplayerManagerClient.cs

@@ -1,32 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using Sandbox.Engine.Multiplayer;
-using Torch.API;
-using Torch.API.Managers;
-using Torch.Managers;
-
-namespace Torch.Client.Manager
-{
-    public class MultiplayerManagerClient : MultiplayerManagerBase, IMultiplayerManagerClient
-    {
-        /// <inheritdoc />
-        public MultiplayerManagerClient(ITorchBase torch) : base(torch) { }
-
-        /// <inheritdoc />
-        public override void Attach()
-        {
-            base.Attach();
-            MyMultiplayer.Static.ClientJoined += RaiseClientJoined;
-        }
-
-        /// <inheritdoc />
-        public override void Detach()
-        {
-            MyMultiplayer.Static.ClientJoined -= RaiseClientJoined;
-            base.Detach();
-        }
-    }
-}

Torch.Client/Manager/MultiplayerManagerLobby.cs

@@ -1,58 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using Sandbox.Engine.Multiplayer;
-using Torch.API;
-using Torch.API.Managers;
-using Torch.Managers;
-
-namespace Torch.Client.Manager
-{
-    public class MultiplayerManagerLobby : MultiplayerManagerBase, IMultiplayerManagerServer
-    {
-        /// <inheritdoc />
-        public IReadOnlyList<ulong> BannedPlayers => new List<ulong>();
-
-        /// <inheritdoc />
-        public MultiplayerManagerLobby(ITorchBase torch) : base(torch) { }
-
-        /// <inheritdoc />
-        public void KickPlayer(ulong steamId) => Torch.Invoke(() => MyMultiplayer.Static.KickClient(steamId));
-
-        /// <inheritdoc />
-        public void BanPlayer(ulong steamId, bool banned = true) => Torch.Invoke(() => MyMultiplayer.Static.BanClient(steamId, banned));
-
-        /// <inheritdoc />
-        public bool IsBanned(ulong steamId) => false;
-
-        /// <inheritdoc />
-        public event Action<ulong> PlayerKicked
-        {
-            add => throw new NotImplementedException();
-            remove => throw new NotImplementedException();
-        }
-
-        /// <inheritdoc />
-        public event Action<ulong, bool> PlayerBanned
-        {
-            add => throw new NotImplementedException();
-            remove => throw new NotImplementedException();
-        }
-
-        /// <inheritdoc/>
-        public override void Attach()
-        {
-            base.Attach();
-            MyMultiplayer.Static.ClientJoined += RaiseClientJoined;
-        }
-
-        /// <inheritdoc/>
-        public override void Detach()
-        {
-            MyMultiplayer.Static.ClientJoined -= RaiseClientJoined;
-            base.Detach();
-        }
-    }
-}

Torch.Client/Program.cs

@@ -1,194 +0,0 @@
-using System;
-using System.Diagnostics;
-using System.IO;
-using System.Reflection;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-using System.Text;
-using System.Threading;
-using System.Windows;
-using System.Windows.Forms;
-using NLog;
-using Torch.Utils;
-using MessageBox = System.Windows.MessageBox;
-
-namespace Torch.Client
-{
-    public static class Program
-    {
-        public const string SpaceEngineersBinaries = "Bin64";
-        private static string _spaceEngInstallAlias = null;
-
-        public static string SpaceEngineersInstallAlias
-        {
-            get
-            {
-                // ReSharper disable once ConvertIfStatementToNullCoalescingExpression
-                if (_spaceEngInstallAlias == null)
-                {
-                    // ReSharper disable once AssignNullToNotNullAttribute
-                    _spaceEngInstallAlias = Path.Combine(Path.GetDirectoryName(typeof(Program).Assembly.Location),
-                        "SpaceEngineersAlias");
-                }
-                return _spaceEngInstallAlias;
-            }
-        }
-
-        private const string _steamSpaceEngineersDirectory = @"steamapps\common\SpaceEngineers\";
-        private const string _spaceEngineersVerifyFile = SpaceEngineersBinaries + @"\SpaceEngineers.exe";
-
-        public const string ConfigName = "Torch.cfg";
-
-        private static Logger _log = LogManager.GetLogger("Torch");
-
-#if DEBUG
-        [DllImport("kernel32.dll")]
-        private static extern void AllocConsole();
-        [DllImport("kernel32.dll")]
-        private static extern void FreeConsole();
-#endif
-        public static void Main(string[] args)
-        {
-#if DEBUG
-            try
-            {
-                AllocConsole();
-#endif
-                if (!TorchLauncher.IsTorchWrapped())
-                {
-                    AppDomain.CurrentDomain.UnhandledException += CurrentDomain_UnhandledException;
-
-                    // Early config: Resolve SE install directory.
-                    if (!File.Exists(Path.Combine(SpaceEngineersInstallAlias, _spaceEngineersVerifyFile)))
-                        SetupSpaceEngInstallAlias();
-
-                    TorchLauncher.Launch(Assembly.GetEntryAssembly().FullName, args,
-                        Path.Combine(SpaceEngineersInstallAlias, SpaceEngineersBinaries));
-                    return;
-                }
-
-                RunClient();
-#if DEBUG
-            }
-            finally
-            {
-                FreeConsole();
-            }
-#endif
-        }
-
-        private static void SetupSpaceEngInstallAlias()
-        {
-            string spaceEngineersDirectory = null;
-
-            // TODO look at Steam/config/Config.VDF?  Has alternate directories.
-            var steamDir =
-                Microsoft.Win32.Registry.GetValue("HKEY_CURRENT_USER\\SOFTWARE\\Valve\\Steam", "SteamPath",
-                    null) as string;
-            if (steamDir != null)
-            {
-                spaceEngineersDirectory = Path.Combine(steamDir, _steamSpaceEngineersDirectory);
-                // ReSharper disable once ConvertIfStatementToConditionalTernaryExpression
-                if (File.Exists(Path.Combine(spaceEngineersDirectory, _spaceEngineersVerifyFile)))
-                    _log.Debug("Found Space Engineers in {0}", spaceEngineersDirectory);
-                else
-                {
-                    _log.Debug("Couldn't find Space Engineers in {0}", spaceEngineersDirectory);
-                    spaceEngineersDirectory = null;
-                }
-            }
-            if (spaceEngineersDirectory == null)
-            {
-                var dialog = new System.Windows.Forms.FolderBrowserDialog
-                {
-                    Description = "Please select the SpaceEngineers installation folder"
-                };
-                do
-                {
-                    if (dialog.ShowDialog() != DialogResult.OK)
-                    {
-                        var ex = new FileNotFoundException(
-                            "Unable to find the Space Engineers install directory, aborting");
-                        _log.Fatal(ex);
-                        LogManager.Flush();
-                        throw ex;
-                    }
-                    spaceEngineersDirectory = dialog.SelectedPath;
-                    if (File.Exists(Path.Combine(spaceEngineersDirectory, _spaceEngineersVerifyFile)))
-                        break;
-                    if (MessageBox.Show(
-                            $"Unable to find {0} in {1}.  Are you sure it's the Space Engineers install directory?",
-                            "Invalid Space Engineers Directory", MessageBoxButton.YesNo) == MessageBoxResult.Yes)
-                        break;
-                } while (true); // Repeat until they confirm.
-            }
-            if (!JunctionLink(SpaceEngineersInstallAlias, spaceEngineersDirectory))
-            {
-                var ex = new IOException(
-                    $"Failed to create junction link {SpaceEngineersInstallAlias} => {spaceEngineersDirectory}. Aborting.");
-                _log.Fatal(ex);
-                LogManager.Flush();
-                throw ex;
-            }
-            string junctionVerify = Path.Combine(SpaceEngineersInstallAlias, _spaceEngineersVerifyFile);
-            if (!File.Exists(junctionVerify))
-            {
-                var ex = new FileNotFoundException(
-                    $"Junction link is not working.  File {junctionVerify} does not exist");
-                _log.Fatal(ex);
-                LogManager.Flush();
-                throw ex;
-            }
-        }
-
-        private static bool JunctionLink(string linkName, string targetDir)
-        {
-            var junctionLinkProc = new ProcessStartInfo("cmd.exe", $"/c mklink /J \"{linkName}\" \"{targetDir}\"")
-            {
-                WorkingDirectory = Directory.GetCurrentDirectory(),
-                UseShellExecute = false,
-                RedirectStandardOutput = true,
-                StandardOutputEncoding = Encoding.ASCII
-            };
-            Process cmd = Process.Start(junctionLinkProc);
-            // ReSharper disable once PossibleNullReferenceException
-            while (!cmd.HasExited)
-            {
-                string line = cmd.StandardOutput.ReadLine();
-                if (!string.IsNullOrWhiteSpace(line))
-                    _log.Info(line);
-                Thread.Sleep(100);
-            }
-            if (cmd.ExitCode != 0)
-                _log.Error("Unable to create junction link {0} => {1}", linkName, targetDir);
-            return cmd.ExitCode == 0;
-        }
-
-        private static void CurrentDomain_UnhandledException(object sender, UnhandledExceptionEventArgs e)
-        {
-            var ex = (Exception) e.ExceptionObject;
-            _log.Error(ex);
-            LogManager.Flush();
-            MessageBox.Show(ex.StackTrace, ex.Message);
-        }
-
-        [MethodImpl(MethodImplOptions.NoInlining)]
-        private static void RunClient()
-        {
-            var client = new TorchClient();
-
-            try
-            {
-                client.Init();
-            }
-            catch (Exception e)
-            {
-                _log.Fatal("Torch encountered an error trying to initialize the game.");
-                _log.Fatal(e);
-                return;
-            }
-
-            client.Start();
-        }
-    }
-}

Torch.Client/Properties/AssemblyInfo.cs

@@ -1,17 +0,0 @@
-using System.Reflection;
-using System.Runtime.InteropServices;
-
-[assembly: AssemblyTitle("Torch Client")]
-[assembly: AssemblyDescription("")]
-[assembly: AssemblyCompany("")]
-[assembly: AssemblyProduct("Torch")]
-[assembly: AssemblyCopyright("Copyright © Torch API 2017")]
-[assembly: AssemblyTrademark("")]
-[assembly: AssemblyCulture("")]
-[assembly: ComVisible(false)]
-
-#if DEBUG
-[assembly: AssemblyConfiguration("Debug")]
-#else
-[assembly: AssemblyConfiguration("Release")]
-#endif

Torch.Client/Properties/Resources.Designer.cs

@@ -1,63 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by a tool.
-//     Runtime Version:4.0.30319.42000
-//
-//     Changes to this file may cause incorrect behavior and will be lost if
-//     the code is regenerated.
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-namespace Torch.Client.Properties {
-    using System;
-    
-    
-    /// <summary>
-    ///   A strongly-typed resource class, for looking up localized strings, etc.
-    /// </summary>
-    // This class was auto-generated by the StronglyTypedResourceBuilder
-    // class via a tool like ResGen or Visual Studio.
-    // To add or remove a member, edit your .ResX file then rerun ResGen
-    // with the /str option, or rebuild your VS project.
-    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
-    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
-    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
-    internal class Resources {
-        
-        private static global::System.Resources.ResourceManager resourceMan;
-        
-        private static global::System.Globalization.CultureInfo resourceCulture;
-        
-        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
-        internal Resources() {
-        }
-        
-        /// <summary>
-        ///   Returns the cached ResourceManager instance used by this class.
-        /// </summary>
-        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
-        internal static global::System.Resources.ResourceManager ResourceManager {
-            get {
-                if (object.ReferenceEquals(resourceMan, null)) {
-                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("Torch.Client.Properties.Resources", typeof(Resources).Assembly);
-                    resourceMan = temp;
-                }
-                return resourceMan;
-            }
-        }
-        
-        /// <summary>
-        ///   Overrides the current thread's CurrentUICulture property for all
-        ///   resource lookups using this strongly typed resource class.
-        /// </summary>
-        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
-        internal static global::System.Globalization.CultureInfo Culture {
-            get {
-                return resourceCulture;
-            }
-            set {
-                resourceCulture = value;
-            }
-        }
-    }
-}

Torch.Client/Properties/Resources.resx

@@ -1,117 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<root>
-  <!-- 
-    Microsoft ResX Schema 
-    
-    Version 2.0
-    
-    The primary goals of this format is to allow a simple XML format 
-    that is mostly human readable. The generation and parsing of the 
-    various data types are done through the TypeConverter classes 
-    associated with the data types.
-    
-    Example:
-    
-    ... ado.net/XML headers & schema ...
-    <resheader name="resmimetype">text/microsoft-resx</resheader>
-    <resheader name="version">2.0</resheader>
-    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
-    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
-    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
-    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
-    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
-        <value>[base64 mime encoded serialized .NET Framework object]</value>
-    </data>
-    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
-        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
-        <comment>This is a comment</comment>
-    </data>
-                
-    There are any number of "resheader" rows that contain simple 
-    name/value pairs.
-    
-    Each data row contains a name, and value. The row also contains a 
-    type or mimetype. Type corresponds to a .NET class that support 
-    text/value conversion through the TypeConverter architecture. 
-    Classes that don't support this are serialized and stored with the 
-    mimetype set.
-    
-    The mimetype is used for serialized objects, and tells the 
-    ResXResourceReader how to depersist the object. This is currently not 
-    extensible. For a given mimetype the value must be set accordingly:
-    
-    Note - application/x-microsoft.net.object.binary.base64 is the format 
-    that the ResXResourceWriter will generate, however the reader can 
-    read any of the formats listed below.
-    
-    mimetype: application/x-microsoft.net.object.binary.base64
-    value   : The object must be serialized with 
-            : System.Serialization.Formatters.Binary.BinaryFormatter
-            : and then encoded with base64 encoding.
-    
-    mimetype: application/x-microsoft.net.object.soap.base64
-    value   : The object must be serialized with 
-            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
-            : and then encoded with base64 encoding.
-
-    mimetype: application/x-microsoft.net.object.bytearray.base64
-    value   : The object must be serialized into a byte array 
-            : using a System.ComponentModel.TypeConverter
-            : and then encoded with base64 encoding.
-    -->
-  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
-    <xsd:element name="root" msdata:IsDataSet="true">
-      <xsd:complexType>
-        <xsd:choice maxOccurs="unbounded">
-          <xsd:element name="metadata">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" />
-              <xsd:attribute name="type" type="xsd:string" />
-              <xsd:attribute name="mimetype" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="assembly">
-            <xsd:complexType>
-              <xsd:attribute name="alias" type="xsd:string" />
-              <xsd:attribute name="name" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="data">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" msdata:Ordinal="1" />
-              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
-              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="resheader">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" />
-            </xsd:complexType>
-          </xsd:element>
-        </xsd:choice>
-      </xsd:complexType>
-    </xsd:element>
-  </xsd:schema>
-  <resheader name="resmimetype">
-    <value>text/microsoft-resx</value>
-  </resheader>
-  <resheader name="version">
-    <value>2.0</value>
-  </resheader>
-  <resheader name="reader">
-    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <resheader name="writer">
-    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-</root>

Torch.Client/Properties/Settings.Designer.cs

@@ -1,26 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by a tool.
-//     Runtime Version:4.0.30319.42000
-//
-//     Changes to this file may cause incorrect behavior and will be lost if
-//     the code is regenerated.
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-namespace Torch.Client.Properties {
-    
-    
-    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
-    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "15.0.0.0")]
-    internal sealed partial class Settings : global::System.Configuration.ApplicationSettingsBase {
-        
-        private static Settings defaultInstance = ((Settings)(global::System.Configuration.ApplicationSettingsBase.Synchronized(new Settings())));
-        
-        public static Settings Default {
-            get {
-                return defaultInstance;
-            }
-        }
-    }
-}

Torch.Client/Properties/Settings.settings

@@ -1,7 +0,0 @@
-<?xml version='1.0' encoding='utf-8'?>
-<SettingsFile xmlns="uri:settings" CurrentProfile="(Default)">
-  <Profiles>
-    <Profile Name="(Default)" />
-  </Profiles>
-  <Settings />
-</SettingsFile>

Torch.Client/Torch.Client.csproj

@@ -1,181 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
-  <PropertyGroup>
-    <ProjectGuid>{E36DF745-260B-4956-A2E8-09F08B2E7161}</ProjectGuid>
-    <OutputType>WinExe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <RootNamespace>Torch.Client</RootNamespace>
-    <AssemblyName>Torch.Client</AssemblyName>
-    <TargetFrameworkVersion>v4.6.1</TargetFrameworkVersion>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{60dc8134-eba5-43b8-bcc9-bb4bc16c2548};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <WarningLevel>4</WarningLevel>
-    <AutoGenerateBindingRedirects>true</AutoGenerateBindingRedirects>
-    <TargetFrameworkProfile />
-    <NuGetPackageImportStamp>
-    </NuGetPackageImportStamp>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x64'">
-    <DebugSymbols>true</DebugSymbols>
-    <OutputPath>$(SolutionDir)\bin\x64\Debug\</OutputPath>
-    <DefineConstants>DEBUG;TRACE</DefineConstants>
-    <DebugType>full</DebugType>
-    <PlatformTarget>x64</PlatformTarget>
-    <ErrorReport>prompt</ErrorReport>
-    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
-    <Prefer32Bit>true</Prefer32Bit>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x64'">
-    <OutputPath>$(SolutionDir)\bin\x64\Release\</OutputPath>
-    <DefineConstants>TRACE</DefineConstants>
-    <Optimize>true</Optimize>
-    <DebugType>pdbonly</DebugType>
-    <PlatformTarget>x64</PlatformTarget>
-    <ErrorReport>prompt</ErrorReport>
-    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
-    <Prefer32Bit>true</Prefer32Bit>
-    <DocumentationFile>$(SolutionDir)\bin\x64\Release\Torch.Client.xml</DocumentationFile>
-  </PropertyGroup>
-  <PropertyGroup>
-    <ApplicationIcon>torchicon.ico</ApplicationIcon>
-  </PropertyGroup>
-  <ItemGroup>
-    <Reference Include="NLog, Version=4.0.0.0, Culture=neutral, PublicKeyToken=5120e14c03d0593c, processorArchitecture=MSIL">
-      <HintPath>..\packages\NLog.4.4.12\lib\net45\NLog.dll</HintPath>
-      <Private>True</Private>
-    </Reference>
-    <Reference Include="Sandbox.Common, Version=1.0.0.0, Culture=neutral, processorArchitecture=MSIL">
-      <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\GameBinaries\Sandbox.Common.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="Sandbox.Game">
-      <HintPath>..\GameBinaries\Sandbox.Game.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="Sandbox.Graphics, Version=0.1.6108.20417, Culture=neutral, processorArchitecture=AMD64">
-      <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\GameBinaries\Sandbox.Graphics.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="SpaceEngineers.Game">
-      <HintPath>..\GameBinaries\SpaceEngineers.Game.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="System" />
-    <Reference Include="System.Data" />
-    <Reference Include="System.Windows.Forms" />
-    <Reference Include="System.Xml" />
-    <Reference Include="Microsoft.CSharp" />
-    <Reference Include="System.Core" />
-    <Reference Include="System.Xml.Linq" />
-    <Reference Include="System.Data.DataSetExtensions" />
-    <Reference Include="System.Net.Http" />
-    <Reference Include="System.Xaml">
-      <RequiredTargetFramework>4.0</RequiredTargetFramework>
-    </Reference>
-    <Reference Include="VRage">
-      <HintPath>..\GameBinaries\VRage.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="VRage.Game">
-      <HintPath>..\GameBinaries\VRage.Game.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="VRage.Game.XmlSerializers">
-      <HintPath>..\GameBinaries\VRage.Game.XmlSerializers.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="VRage.Input, Version=1.0.0.0, Culture=neutral, processorArchitecture=AMD64">
-      <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\GameBinaries\VRage.Input.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="VRage.Library">
-      <HintPath>..\GameBinaries\VRage.Library.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="VRage.Math, Version=1.0.0.0, Culture=neutral, processorArchitecture=MSIL">
-      <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\GameBinaries\VRage.Math.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="VRage.Render">
-      <HintPath>..\GameBinaries\VRage.Render.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="VRage.Render11">
-      <HintPath>..\GameBinaries\VRage.Render11.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="VRage.Steam">
-      <HintPath>..\GameBinaries\VRage.Steam.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="WindowsBase" />
-    <Reference Include="PresentationCore" />
-    <Reference Include="PresentationFramework" />
-  </ItemGroup>
-  <ItemGroup>
-    <Compile Include="..\Versioning\AssemblyVersion.cs">
-      <Link>Properties\AssemblyVersion.cs</Link>
-    </Compile>
-    <Compile Include="Manager\MultiplayerManagerClient.cs" />
-    <Compile Include="Manager\MultiplayerManagerLobby.cs" />
-    <Compile Include="Properties\AssemblyInfo.cs" />
-    <Compile Include="TorchClient.cs" />
-    <Compile Include="TorchClientConfig.cs" />
-    <Compile Include="TorchConsoleScreen.cs" />
-    <Compile Include="TorchSettingsScreen.cs" />
-    <Compile Include="Program.cs" />
-    <Compile Include="Properties\Resources.Designer.cs">
-      <AutoGen>True</AutoGen>
-      <DesignTime>True</DesignTime>
-      <DependentUpon>Resources.resx</DependentUpon>
-    </Compile>
-    <Compile Include="Properties\Settings.Designer.cs">
-      <AutoGen>True</AutoGen>
-      <DependentUpon>Settings.settings</DependentUpon>
-      <DesignTimeSharedInput>True</DesignTimeSharedInput>
-    </Compile>
-    <Compile Include="UI\TorchMainMenuScreen.cs" />
-    <Compile Include="UI\TorchNavScreen.cs" />
-    <Compile Include="UI\TorchSettingsScreen.cs" />
-    <EmbeddedResource Include="Properties\Resources.resx">
-      <Generator>ResXFileCodeGenerator</Generator>
-      <LastGenOutput>Resources.Designer.cs</LastGenOutput>
-    </EmbeddedResource>
-    <None Include="packages.config" />
-    <None Include="Properties\Settings.settings">
-      <Generator>SettingsSingleFileGenerator</Generator>
-      <LastGenOutput>Settings.Designer.cs</LastGenOutput>
-    </None>
-    <AppDesigner Include="Properties\" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="..\Torch.API\Torch.API.csproj">
-      <Project>{fba5d932-6254-4a1e-baf4-e229fa94e3c2}</Project>
-      <Name>Torch.API</Name>
-      <Private>False</Private>
-    </ProjectReference>
-    <ProjectReference Include="..\Torch\Torch.csproj">
-      <Project>{7E01635C-3B67-472E-BCD6-C5539564F214}</Project>
-      <Name>Torch</Name>
-      <Private>False</Private>
-    </ProjectReference>
-  </ItemGroup>
-  <ItemGroup>
-    <Resource Include="torchicon.ico" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{508349B6-6B84-4DF5-91F0-309BEEBAD82D}" />
-  </ItemGroup>
-  <ItemGroup />
-  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
-  <Import Project="$(SolutionDir)\TransformOnBuild.targets" />
-  <PropertyGroup>
-    <PostBuildEvent>copy "$(SolutionDir)NLog.config" "$(TargetDir)"
-    </PostBuildEvent>
-  </PropertyGroup>
-</Project>

Torch.Client/TorchClient.cs

@@ -1,92 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Reflection;
-using System.Windows;
-using Sandbox;
-using Sandbox.Engine.Multiplayer;
-using Sandbox.Engine.Networking;
-using Sandbox.Engine.Platform;
-using Sandbox.Game;
-using SpaceEngineers.Game;
-using VRage.Steam;
-using Torch.API;
-using Torch.API.Managers;
-using Torch.API.Session;
-using Torch.Client.Manager;
-using Torch.Client.UI;
-using Torch.Session;
-using VRage;
-using VRage.FileSystem;
-using VRage.GameServices;
-using VRageRender;
-using VRageRender.ExternalApp;
-
-namespace Torch.Client
-{
-    public class TorchClient : TorchBase, ITorchClient
-    {
-        protected override uint SteamAppId => 244850;
-        protected override string SteamAppName => "SpaceEngineers";
-
-        public TorchClient()
-        {
-            Config = new TorchClientConfig();
-            var sessionManager = Managers.GetManager<ITorchSessionManager>();
-            sessionManager.AddFactory((x) => MyMultiplayer.Static is MyMultiplayerLobby
-                ? new MultiplayerManagerLobby(this)
-                : null);
-            sessionManager.AddFactory((x) => MyMultiplayer.Static is MyMultiplayerClientBase
-                ? new MultiplayerManagerClient(this)
-                : null);
-        }
-
-        public override void Init()
-        {
-            Directory.SetCurrentDirectory(Program.SpaceEngineersInstallAlias);
-            MyFileSystem.ExePath = Path.Combine(Program.SpaceEngineersInstallAlias, Program.SpaceEngineersBinaries);
-            Log.Info("Initializing Torch Client");
-            Config.InstancePath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData),
-                SteamAppName);
-            base.Init();
-            OverrideMenus();
-            SetRenderWindowTitle($"Space Engineers v{GameVersion} with Torch v{TorchVersion}");
-        }
-
-        private void OverrideMenus()
-        {
-            var credits = new MyCreditsDepartment("Torch Developed By")
-            {
-                Persons = new List<MyCreditsPerson>
-                {
-                    new MyCreditsPerson("THE TORCH TEAM"),
-                    new MyCreditsPerson("http://github.com/TorchSE"),
-                }
-            };
-            MyPerGameSettings.Credits.Departments.Insert(0, credits);
-
-            MyPerGameSettings.GUI.MainMenu = typeof(TorchMainMenuScreen);
-        }
-
-        private void SetRenderWindowTitle(string title)
-        {
-            MyRenderThread renderThread = MySandboxGame.Static?.GameRenderComponent?.RenderThread;
-            if (renderThread == null)
-                return;
-            FieldInfo renderWindowField = typeof(MyRenderThread).GetField("m_renderWindow",
-                BindingFlags.Instance | BindingFlags.NonPublic);
-            if (renderWindowField == null)
-                return;
-            var window =
-                renderWindowField.GetValue(MySandboxGame.Static.GameRenderComponent.RenderThread) as
-                    System.Windows.Forms.Form;
-            if (window != null)
-                renderThread.Invoke(() => { window.Text = title; });
-        }
-
-        public override void Restart()
-        {
-            throw new NotImplementedException();
-        }
-    }
-}

Torch.Client/TorchClientConfig.cs

@@ -1,32 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace Torch.Client
-{
-    public class TorchClientConfig : ITorchConfig
-    {
-        // How do we want to handle client side config?  It's radically different than the server.
-        public bool GetPluginUpdates { get; set; } = false;
-        public bool GetTorchUpdates { get; set; } = false;
-        public string InstanceName { get; set; } = "TorchClient";
-        public string InstancePath { get; set; }
-        public bool NoUpdate { get; set; } = true;
-        public List<string> Plugins { get; set; }
-        public bool ShouldUpdatePlugins { get; } = false;
-        public bool ShouldUpdateTorch { get; } = false;
-        public int TickTimeout { get; set; }
-        public bool Autostart { get; set; } = false;
-        public bool ForceUpdate { get; set; } = false;
-        public bool NoGui { get; set; } = false;
-        public bool RestartOnCrash { get; set; } = false;
-        public string WaitForPID { get; set; } = null;
-
-        public bool Save(string path = null)
-        {
-            return true;
-        }
-    }
-}

Torch.Client/TorchConsoleScreen.cs

@@ -1,63 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using System.Windows;
-using Sandbox.Graphics;
-using Sandbox.Graphics.GUI;
-using Sandbox.Gui;
-using VRage.Utils;
-using VRageMath;
-
-namespace Torch.Client
-{
-    public class TorchConsoleScreen : MyGuiScreenBase
-    {
-        private MyGuiControlTextbox _textBox;
-
-        public override string GetFriendlyName()
-        {
-            return "Torch Console";
-        }
-
-        public TorchConsoleScreen() : base(isTopMostScreen: true)
-        {
-            BackgroundColor = new Vector4(0, 0, 0, 0.5f);
-            Size = new Vector2(0.5f);
-            RecreateControls(true);
-        }
-
-        public sealed override void RecreateControls(bool constructor)
-        {
-            Elements.Clear();
-            Elements.Add(new MyGuiControlLabel
-            {
-                Text = "Torch Console",
-                OriginAlign = MyGuiDrawAlignEnum.HORISONTAL_RIGHT_AND_VERTICAL_TOP,
-                Position = MyGuiManager.ComputeFullscreenGuiCoordinate(MyGuiDrawAlignEnum.HORISONTAL_RIGHT_AND_VERTICAL_TOP)
-            });
-
-            Controls.Clear();
-            _textBox = new MyGuiControlTextbox
-            {
-                BorderEnabled = false,
-                Enabled = true,
-                OriginAlign = MyGuiDrawAlignEnum.HORISONTAL_LEFT_AND_VERTICAL_TOP,
-                Position = new Vector2(-0.5f)
-            };
-            Controls.Add(_textBox);
-
-            var pistonBtn = new MyGuiControlImageButton
-            {
-                Name = "TorchButton",
-                Text = "Torch",
-                HighlightType = MyGuiControlHighlightType.WHEN_CURSOR_OVER,
-                Visible = true,
-                OriginAlign = MyGuiDrawAlignEnum.HORISONTAL_LEFT_AND_VERTICAL_TOP
-            };
-
-            Controls.Add(pistonBtn);
-        }
-    }
-}

Torch.Client/TorchSettingsScreen.cs

@@ -1,38 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using Sandbox.Graphics;
-using Sandbox.Graphics.GUI;
-using VRage.Utils;
-using VRageMath;
-
-namespace Torch.Client
-{
-    public class TorchSettingsScreen : MyGuiScreenBase
-    {
-        public override string GetFriendlyName() => "Torch Settings";
-
-        public TorchSettingsScreen() : base(new Vector2(0.5f), null, Vector2.One, true)
-        {
-            RecreateControls(true);
-        }
-
-        public sealed override void RecreateControls(bool constructor)
-        {
-            base.RecreateControls(constructor);
-            AddCaption(MyStringId.GetOrCompute("Torch Settings"), null, new Vector2(0, 0), 1.2f);
-            var pluginList = new MyGuiControlListbox
-            {
-                VisibleRowsCount = 10,
-            };
-
-            foreach (var plugin in TorchBase.Instance.Plugins)
-            {
-                pluginList.Items.Add(new MyGuiControlListbox.Item(new StringBuilder(plugin.Name)));
-            }
-            Controls.Add(pluginList);
-        }
-    }
-}

Torch.Client/UI/TorchMainMenuScreen.cs

@@ -1,56 +0,0 @@
-#pragma warning disable 618
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using Sandbox.Engine.Networking;
-using Sandbox.Engine.Utils;
-using Sandbox.Game;
-using Sandbox.Game.Gui;
-using Sandbox.Graphics;
-using Sandbox.Graphics.GUI;
-using Sandbox.Gui;
-using SpaceEngineers.Game.GUI;
-using Torch.Utils;
-using VRage.Game;
-using VRage.Utils;
-using VRageMath;
-
-namespace Torch.Client.UI
-{
-    public class TorchMainMenuScreen : MyGuiScreenMainMenu
-    {
-#pragma warning disable 169
-        [ReflectedGetter(Name = "m_elementGroup")]
-        private static Func<MyGuiScreenMainMenu, MyGuiControlElementGroup> _elementsGroup;
-#pragma warning restore 169
-
-        public TorchMainMenuScreen() : this(false)
-        {
-        }
-
-        public TorchMainMenuScreen(bool pauseGame)
-      : base(pauseGame)
-        {
-        }
-        /// <inheritdoc />
-        public override void RecreateControls(bool constructor)
-        {
-            base.RecreateControls(constructor);
-
-            Vector2 minSizeGui = MyGuiControlButton.GetVisualStyle(MyGuiControlButtonStyleEnum.Default).NormalTexture.MinSizeGui;
-            Vector2 value = MyGuiManager.ComputeFullscreenGuiCoordinate(MyGuiDrawAlignEnum.HORISONTAL_LEFT_AND_VERTICAL_BOTTOM, 54, 54) + new Vector2(minSizeGui.X / 2f, 0f) + new Vector2(15f, 0f) / MyGuiConstants.GUI_OPTIMAL_SIZE;
-            
-            MyGuiControlButton myGuiControlButton = MakeButton(value - 9 * MyGuiConstants.MENU_BUTTONS_POSITION_DELTA,
-                MyStringId.GetOrCompute("Torch"), TorchButtonClicked, MyCommonTexts.ToolTipExitToWindows);
-            Controls.Add(myGuiControlButton);
-            _elementsGroup.Invoke(this).Add(myGuiControlButton);
-        }
-
-        private void TorchButtonClicked(MyGuiControlButton obj)
-        {
-            MyGuiSandbox.AddScreen(MyGuiSandbox.CreateScreen<TorchNavScreen>());
-        }
-    }
-}

Torch.Client/UI/TorchNavScreen.cs

@@ -1,49 +0,0 @@
-using Sandbox;
-using Sandbox.Game.Gui;
-using Sandbox.Graphics.GUI;
-using VRage;
-using VRage.Game;
-using VRage.Utils;
-using VRageMath;
-
-namespace Torch.Client.UI
-{
-    public class TorchNavScreen : MyGuiScreenBase
-    {
-		private MyGuiControlElementGroup _elementGroup;
-
-        public TorchNavScreen() : base(new Vector2(0.5f, 0.5f), MyGuiConstants.SCREEN_BACKGROUND_COLOR, new Vector2(0.35875f, 0.558333337f))
-		{
-			EnabledBackgroundFade = true;
-			RecreateControls(true);
-		}
-
-		public override void RecreateControls(bool constructor)
-		{
-			base.RecreateControls(constructor);
-			_elementGroup = new MyGuiControlElementGroup();
-			_elementGroup.HighlightChanged += ElementGroupHighlightChanged;
-			AddCaption(MyCommonTexts.ScreenCaptionOptions, null, null);
-			var value = new Vector2(0f, -m_size.Value.Y / 2f + 0.146f);
-			var num = 0;
-			var myGuiControlButton = new MyGuiControlButton(value + num++ * MyGuiConstants.MENU_BUTTONS_POSITION_DELTA, MyGuiControlButtonStyleEnum.Default, null, null, MyGuiDrawAlignEnum.HORISONTAL_CENTER_AND_VERTICAL_CENTER, null, MyTexts.Get(MyCommonTexts.ScreenOptionsButtonGame), 0.8f, MyGuiDrawAlignEnum.HORISONTAL_CENTER_AND_VERTICAL_CENTER, MyGuiControlHighlightType.WHEN_ACTIVE, delegate(MyGuiControlButton sender)
-			{
-				MyGuiSandbox.AddScreen(MyGuiSandbox.CreateScreen<TorchSettingsScreen>());
-			}, GuiSounds.MouseClick, 1f, null);
-			Controls.Add(myGuiControlButton);
-			_elementGroup.Add(myGuiControlButton);
-			CloseButtonEnabled = true;
-		}
-
-		private void ElementGroupHighlightChanged(MyGuiControlElementGroup obj)
-		{
-			foreach (MyGuiControlBase current in _elementGroup)
-				if (current.HasFocus && obj.SelectedElement != current)
-					FocusedControl = obj.SelectedElement;
-		}
-
-        public override string GetFriendlyName() => "Torch";
-
-        public void OnBackClick(MyGuiControlButton sender) => CloseScreen();
-    }
-}

Torch.Client/UI/TorchSettingsScreen.cs

@@ -1,25 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using Sandbox.Graphics.GUI;
-using VRageMath;
-
-namespace Torch.Client.UI
-{
-    public class TorchSettingsScreen : MyGuiScreenBase
-    {
-        public TorchSettingsScreen() : base(new Vector2(0.5f, 0.5f), MyGuiConstants.SCREEN_BACKGROUND_COLOR,
-            new Vector2(0.35875f, 0.558333337f))
-		{
-            EnabledBackgroundFade = true;
-            RecreateControls(true);
-        }
-
-        /// <inheritdoc />
-        public override string GetFriendlyName() => "Torch Settings";
-
-        public void OnBackClick(MyGuiControlButton sender) => CloseScreen();
-    }
-}

Torch.Client/packages.config

@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="Mono.TextTransform" version="1.0.0" targetFramework="net461" />
-  <package id="NLog" version="4.4.12" targetFramework="net461" />
-</packages>

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

@@ -0,0 +1,52 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using ProtoBuf;
+using Sandbox.ModAPI;
+
+namespace Torch.Mod.Messages
+{
+    [ProtoContract]
+    public class JoinServerMessage : MessageBase
+    {
+        [ProtoMember(201)]
+        public int Delay;
+        [ProtoMember(202)]
+        public string Address;
+
+        private JoinServerMessage()
+        {
+
+        }
+
+        public JoinServerMessage(string address)
+        {
+            Address = address;
+        }
+
+        public JoinServerMessage(string address, int delay)
+        {
+            Address = address;
+            Delay = delay;
+        }
+
+        public override void ProcessClient()
+        {
+            if (Delay <= 0)
+            {
+                MyAPIGateway.Multiplayer.JoinServer(Address);
+                return;
+            }
+
+            MyAPIGateway.Parallel.StartBackground(() =>
+                                                  {
+                                                      MyAPIGateway.Parallel.Sleep(Delay);
+                                                      MyAPIGateway.Multiplayer.JoinServer(Address);
+                                                  });
+        }
+
+        public override void ProcessServer()
+        {
+        }
+    }
+}

Torch.Mod/Messages/MessageBase.cs

@@ -1,9 +1,4 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using ProtoBuf;
+using ProtoBuf;
 
 namespace Torch.Mod.Messages
 {
@@ -11,41 +6,15 @@ namespace Torch.Mod.Messages
     [ProtoInclude(1, typeof(DialogMessage))]
     [ProtoInclude(2, typeof(NotificationMessage))]
     [ProtoInclude(3, typeof(VoxelResetMessage))]
+    [ProtoInclude(4, typeof(JoinServerMessage))]
     #endregion
 
     [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/ModCommunication.cs

@@ -1,142 +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.Collections;
+using VRage.Game.Components;
 using VRage.Game.ModAPI;
-using VRage.Utils;
-using Task = ParallelTasks.Task;
+#if TORCH
+using Torch.Utils;
+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;
-        private static bool _closing = false;
-        private static BlockingCollection<MessageBase> _processing;
-        private static MyConcurrentPool<IncomingMessage> _messagePool;
-        private static List<IMyPlayer> _playerCache;
+        public const ulong MOD_ID = 2915950488;
+        private const ushort CHANNEL = 7654;
 
-        public static void Register()
+        public override void BeforeStart()
         {
-            MyLog.Default.WriteLineAndConsole("TORCH MOD: Registering mod communication.");
-            _processing = new BlockingCollection<MessageBase>(new ConcurrentQueue<MessageBase>());
-            _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.");
+            base.BeforeStart();
+            MyAPIGateway.Multiplayer.RegisterSecureMessageHandler(CHANNEL, MessageHandler);
         }
 
-        public static void Unregister()
+        private void MessageHandler(ushort channel, byte[] data, ulong sender, bool fromServer)
         {
-            MyLog.Default.WriteLineAndConsole("TORCH MOD: Unregistering mod communication.");
-            MyAPIGateway.Multiplayer?.UnregisterMessageHandler(NET_ID, MessageHandler);
-            _processing?.CompleteAdding();
-            _closing = true;
-            //_task.Wait();
+            if (!fromServer)
+                return;
+
+            var message = MyAPIGateway.Utilities.SerializeFromBinary<MessageBase>(data);
+            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;
-            _processing.Add(m);
-        }
+#if TORCH
+        [ReflectedMethodInfo(typeof(MyAPIUtilities), "VRage.Game.ModAPI.IMyUtilities.SerializeToBinary")]
+        private static MethodInfo _serializeMethod = null!;
 
-        public static void DoProcessing()
-        {
-            while (!_closing)
-            {
-                try
-                {
-                    var m = _processing.Take();
-                    MyLog.Default.WriteLineAndConsole($"Processing message: {m.GetType().Name}");
+        private static readonly CacheList<IMyPlayer> Players = new();
 
-                    if (m is IncomingMessage)
+        private static byte[] Serialize(MessageBase message)
         {
-                        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 (MyAPIGateway.Multiplayer.IsServer)
-                            i.ProcessServer();
-                        else
-                            i.ProcessClient();
-                    }
-                    else
-                    {
-                        var b = MyAPIGateway.Utilities.SerializeToBinary(m);
-                        m.CompressedData = MyCompression.Compress(b);
-
-                        MyAPIGateway.Utilities.InvokeOnGameThread(() =>
-                        {
-
-                            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: COMMUNICATION THREAD: EXIT SIGNAL RECEIVED!");
-            //exit signal received. Clean everything and GTFO
-            _processing?.Dispose();
-            _processing = null;
-            _messagePool?.Clean();
-            _messagePool = null;
-            _playerCache = null;
+            return (byte[])_serializeMethod.MakeGenericMethod(message.GetType())
+                                          .Invoke(MyAPIGateway.Utilities, new object[] { message });
         }
         
         public static void SendMessageTo(MessageBase message, ulong target)
@@ -144,12 +52,7 @@ namespace Torch.Mod
             if (!MyAPIGateway.Multiplayer.IsServer)
                 throw new Exception("Only server can send targeted messages");
 
-            if (_closing)
-                return;
-
-            message.Target = target;
-            message.TargetType = MessageTarget.Single;
-            _processing.Add(message);
+            MyAPIGateway.Multiplayer.SendMessageTo(CHANNEL, Serialize(message), target);
         }
 
         public static void SendMessageToClients(MessageBase message)
@@ -157,11 +60,7 @@ namespace Torch.Mod
             if (!MyAPIGateway.Multiplayer.IsServer)
                 throw new Exception("Only server can send targeted messages");
 
-            if (_closing)
-                return;
-
-            message.TargetType = MessageTarget.AllClients;
-            _processing.Add(message);
+            MyAPIGateway.Multiplayer.SendMessageToOthers(CHANNEL, Serialize(message));
         }
 
         public static void SendMessageExcept(MessageBase message, params ulong[] ignoredUsers)
@@ -169,21 +68,20 @@ namespace Torch.Mod
             if (!MyAPIGateway.Multiplayer.IsServer)
                 throw new Exception("Only server can send targeted messages");
 
-            if (_closing)
-                return;
+            using var players = Players;
+            MyAPIGateway.Multiplayer.Players.GetPlayers(players, player => !ignoredUsers.Contains(player.SteamUserId));
 
-            message.TargetType = MessageTarget.AllExcept;
-            message.Ignore = ignoredUsers;
-            _processing.Add(message);
+            var data = Serialize(message);
+            foreach (var player in players)
+            {
+                MyAPIGateway.Multiplayer.SendMessageTo(CHANNEL, data, player.SteamUserId);
+            }
         }
 
         public static void SendMessageToServer(MessageBase message)
         {
-            if (_closing)
-                return;
-
-            message.TargetType = MessageTarget.Server;
-            _processing.Add(message);
+            throw new NotSupportedException();
         }
+#endif
     }
 }

Torch.Mod/Torch.Mod.projitems

@@ -9,12 +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/Torch.Mod.shproj

@@ -7,7 +7,6 @@
   <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
   <Import Project="$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)\CodeSharing\Microsoft.CodeSharing.Common.Default.props" />
   <Import Project="$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)\CodeSharing\Microsoft.CodeSharing.Common.props" />
-  <PropertyGroup />
   <Import Project="Torch.Mod.projitems" Label="Shared" />
   <Import Project="$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)\CodeSharing\Microsoft.CodeSharing.CSharp.targets" />
 </Project>

Torch.Mod/TorchModCore.cs

@@ -1,37 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using VRage.Game.Components;
-
-namespace Torch.Mod
-{
-    [MySessionComponentDescriptor(MyUpdateOrder.AfterSimulation)]
-    public class TorchModCore : MySessionComponentBase
-    {
-        public const ulong MOD_ID = 1406994352;
-        private static bool _init;
-
-        public override void UpdateAfterSimulation()
-        {
-            if (_init)
-                return;
-
-            _init = true;
-            ModCommunication.Register();
-        }
-
-        protected override void UnloadData()
-        {
-            try
-            {
-                ModCommunication.Unregister();
-            }
-            catch
-            {
-                //session unloading, don't care
-            }
-        }
-    }
-}

Torch.Server.ReferenceAssemblies.net7.nuspec

@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="utf-8"?>
+<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
+    <metadata>
+        <id>Torch.Server.ReferenceAssemblies.net7</id>
+        <version>torchVersion</version>
+        <title>Torch Server Reference Assemblies</title>
+        <authors>zznty</authors>
+        <owners>zznty</owners>
+        <requireLicenseAcceptance>false</requireLicenseAcceptance>
+        <description>Torch Server Reference Assemblies (.NET 7 edition)</description>
+        <repository type="git" url="https://github.com/PveTeam/Torch" />
+        <dependencies>
+            <group targetFramework="net7.0-windows7.0">
+                <dependency id="SpaceEngineersDedicated.ReferenceAssemblies" version="1.202.117" />
+                <dependency id="Torch.Server" version="torchVersion" />
+            </group>
+        </dependencies>
+        <frameworkReferences>
+            <group targetFramework="net7.0-windows7.0">
+                <frameworkReference name="Microsoft.WindowsDesktop.App.WPF" />
+            </group>
+        </frameworkReferences>
+    </metadata>
+</package>

Torch.Server.Tests/Properties/AssemblyInfo.cs

@@ -1,17 +0,0 @@
-using System.Reflection;
-using System.Runtime.InteropServices;
-
-[assembly: AssemblyTitle("Torch Server Tests")]
-[assembly: AssemblyDescription("")]
-[assembly: AssemblyCompany("")]
-[assembly: AssemblyProduct("Torch")]
-[assembly: AssemblyCopyright("Copyright © Torch API 2017")]
-[assembly: AssemblyTrademark("")]
-[assembly: AssemblyCulture("")]
-[assembly: ComVisible(false)]
-
-#if DEBUG
-[assembly: AssemblyConfiguration("Debug")]
-#else
-[assembly: AssemblyConfiguration("Release")]
-#endif

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

@@ -1,102 +1,36 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+<Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <ProjectGuid>{9EFD1D91-2FA2-47ED-B537-D8BC3B0E543E}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <RootNamespace>Torch.Server.Tests</RootNamespace>
-    <AssemblyName>Torch.Server.Tests</AssemblyName>
-    <TargetFrameworkVersion>v4.6.1</TargetFrameworkVersion>
-    <FileAlignment>512</FileAlignment>
-    <TargetFrameworkProfile />
-    <NuGetPackageImportStamp>
-    </NuGetPackageImportStamp>
+    <TargetFramework>net7-windows</TargetFramework>
     <NoWarn>1591,0649</NoWarn>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x64'">
-    <DebugSymbols>true</DebugSymbols>
-    <OutputPath>$(SolutionDir)\bin-test\x64\Debug\</OutputPath>
-    <DefineConstants>DEBUG;TRACE</DefineConstants>
-    <DebugType>full</DebugType>
-    <PlatformTarget>x64</PlatformTarget>
-    <ErrorReport>prompt</ErrorReport>
+    <AssemblyTitle>Torch Server Tests</AssemblyTitle>
+    <Product>Torch</Product>
+    <Copyright>Copyright © Torch API 2017</Copyright>
+    <GenerateAssemblyConfigurationAttribute>false</GenerateAssemblyConfigurationAttribute>
     <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x64'">
-    <OutputPath>$(SolutionDir)\bin-test\x64\Release\</OutputPath>
-    <DefineConstants>TRACE</DefineConstants>
-    <Optimize>true</Optimize>
-    <DebugType>pdbonly</DebugType>
+    <OutputPath>$(SolutionDir)\bin-test\$(Platform)\$(Configuration)\</OutputPath>
     <PlatformTarget>x64</PlatformTarget>
-    <ErrorReport>prompt</ErrorReport>
-    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
-    <DocumentationFile>$(SolutionDir)\bin-test\x64\Release\Torch.Server.Tests.xml</DocumentationFile>
+    <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="NLog" Version="5.1.0" />
+    <PackageReference Include="xunit" Version="2.4.2" />
+  </ItemGroup>
   <ItemGroup>
-    <Reference Include="NLog, Version=4.0.0.0, Culture=neutral, PublicKeyToken=5120e14c03d0593c, processorArchitecture=MSIL">
-      <HintPath>..\packages\NLog.4.4.12\lib\net45\NLog.dll</HintPath>
-      <Private>True</Private>
-    </Reference>
-    <Reference Include="System" />
-    <Reference Include="System.ComponentModel.DataAnnotations" />
-    <Reference Include="System.Core" />
-    <Reference Include="System.Xml.Linq" />
-    <Reference Include="System.Data.DataSetExtensions" />
-    <Reference Include="Microsoft.CSharp" />
-    <Reference Include="System.Data" />
-    <Reference Include="System.Net.Http" />
-    <Reference Include="System.Xml" />
     <Reference Include="VRage.Game, Version=1.0.0.0, Culture=neutral, processorArchitecture=MSIL">
-      <SpecificVersion>False</SpecificVersion>
       <HintPath>..\GameBinaries\VRage.Game.dll</HintPath>
-    </Reference>
-    <Reference Include="xunit.abstractions, Version=2.0.0.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
-      <HintPath>..\packages\xunit.abstractions.2.0.1\lib\net35\xunit.abstractions.dll</HintPath>
-    </Reference>
-    <Reference Include="xunit.assert, Version=2.2.0.3545, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
-      <HintPath>..\packages\xunit.assert.2.2.0\lib\netstandard1.1\xunit.assert.dll</HintPath>
-    </Reference>
-    <Reference Include="xunit.core, Version=2.2.0.3545, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
-      <HintPath>..\packages\xunit.extensibility.core.2.2.0\lib\netstandard1.1\xunit.core.dll</HintPath>
-    </Reference>
-    <Reference Include="xunit.execution.desktop, Version=2.2.0.3545, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
-      <HintPath>..\packages\xunit.extensibility.execution.2.2.0\lib\net452\xunit.execution.desktop.dll</HintPath>
+      <SpecificVersion>False</SpecificVersion>
     </Reference>
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="..\Versioning\AssemblyVersion.cs">
-      <Link>Properties\AssemblyVersion.cs</Link>
-    </Compile>
-    <Compile Include="Properties\AssemblyInfo.cs" />
-    <Compile Include="TorchServerReflectionTest.cs" />
-    <Compile Include="TorchServerSessionSettingsTest.cs" />
+    <ProjectReference Include="..\Torch.API\Torch.API.csproj" />
+    <ProjectReference Include="..\Torch.Server\Torch.Server.csproj" />
+    <ProjectReference Include="..\Torch.Tests\Torch.Tests.csproj" />
+    <ProjectReference Include="..\Torch\Torch.csproj" />
   </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="..\Torch.API\Torch.API.csproj">
-      <Project>{fba5d932-6254-4a1e-baf4-e229fa94e3c2}</Project>
-      <Name>Torch.API</Name>
-    </ProjectReference>
-    <ProjectReference Include="..\Torch.Server\Torch.Server.csproj">
-      <Project>{ca50886b-7b22-4cd8-93a0-c06f38d4f77d}</Project>
-      <Name>Torch.Server</Name>
-    </ProjectReference>
-    <ProjectReference Include="..\Torch.Tests\Torch.Tests.csproj">
-      <Project>{c3c8b671-6ad1-44aa-a8da-e0c0dc0fedf5}</Project>
-      <Name>Torch.Tests</Name>
-    </ProjectReference>
-    <ProjectReference Include="..\Torch\Torch.csproj">
-      <Project>{7e01635c-3b67-472e-bcd6-c5539564f214}</Project>
-      <Name>Torch</Name>
-      <Private>True</Private>
-    </ProjectReference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
-  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
-  <Import Project="$(SolutionDir)\TransformOnBuild.targets" />
 </Project>

Torch.Server.Tests/packages.config

@@ -1,12 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="Mono.TextTransform" version="1.0.0" targetFramework="net461" />
-  <package id="NLog" version="4.4.12" targetFramework="net461" />
-  <package id="xunit" version="2.2.0" targetFramework="net461" />
-  <package id="xunit.abstractions" version="2.0.1" targetFramework="net461" />
-  <package id="xunit.assert" version="2.2.0" targetFramework="net461" />
-  <package id="xunit.core" version="2.2.0" targetFramework="net461" />
-  <package id="xunit.extensibility.core" version="2.2.0" targetFramework="net461" />
-  <package id="xunit.extensibility.execution" version="2.2.0" targetFramework="net461" />
-  <package id="xunit.runner.console" version="2.2.0" targetFramework="net461" developmentDependency="true" />
-</packages>

Torch.Server/Commands/WhitelistCommands.cs

@@ -41,8 +41,9 @@ namespace Torch.Server.Commands
         [Command("add", "Add a Steam ID to the whitelist.")]
         public void Add(ulong steamId)
         {
-            if (Config.Whitelist.Add(steamId))
+            if (!Config.Whitelist.Contains(steamId))
             {
+                Config.Whitelist.Add(steamId);
                 Context.Respond($"Added {steamId} to the whitelist.");
                 Config.Save();
             }

Torch.Server/FlowDocumentTarget.cs

@@ -1,54 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using System.Windows.Documents;
-using System.Windows.Media;
-using NLog;
-using NLog.Targets;
-
-namespace Torch.Server
-{
-    /// <summary>
-    /// NLog target that writes to a <see cref="FlowDocument"/>.
-    /// </summary>
-    [Target("flowDocument")]
-    public sealed class FlowDocumentTarget : TargetWithLayout
-    {
-        private FlowDocument _document = new FlowDocument { Background = new SolidColorBrush(Colors.Black) };
-        private readonly Paragraph _paragraph = new Paragraph();
-        private readonly int _maxLines = 500;
-
-        public FlowDocument Document => _document;
-
-        public FlowDocumentTarget()
-        {
-            _document.Blocks.Add(_paragraph);
-        }
-
-        /// <inheritdoc />
-        protected override void Write(LogEventInfo logEvent)
-        {
-            _document.Dispatcher.BeginInvoke(() =>
-            {
-                var message = $"{Layout.Render(logEvent)}\n";
-                _paragraph.Inlines.Add(new Run(message) {Foreground = LogLevelColors[logEvent.Level]});
-
-                // A massive paragraph slows the UI down
-                if (_paragraph.Inlines.Count > _maxLines)
-                    _paragraph.Inlines.Remove(_paragraph.Inlines.FirstInline);
-            });
-        }
-
-        private static readonly Dictionary<LogLevel, SolidColorBrush> LogLevelColors = new Dictionary<LogLevel, SolidColorBrush>
-        {
-            [LogLevel.Trace] = new SolidColorBrush(Colors.DimGray),
-            [LogLevel.Debug] = new SolidColorBrush(Colors.DarkGray),
-            [LogLevel.Info] = new SolidColorBrush(Colors.White),
-            [LogLevel.Warn] = new SolidColorBrush(Colors.Magenta),
-            [LogLevel.Error] = new SolidColorBrush(Colors.Yellow),
-            [LogLevel.Fatal] = new SolidColorBrush(Colors.Red),
-        };
-    }
-}

Torch.Server/FodyWeavers.xml

@@ -0,0 +1,3 @@
+<Weavers xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="FodyWeavers.xsd">
+  <PropertyChanged />
+</Weavers>

Torch.Server/FodyWeavers.xsd

@@ -0,0 +1,74 @@
+<?xml version="1.0" encoding="utf-8"?>
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+  <!-- This file was generated by Fody. Manual changes to this file will be lost when your project is rebuilt. -->
+  <xs:element name="Weavers">
+    <xs:complexType>
+      <xs:all>
+        <xs:element name="PropertyChanged" minOccurs="0" maxOccurs="1">
+          <xs:complexType>
+            <xs:attribute name="InjectOnPropertyNameChanged" type="xs:boolean">
+              <xs:annotation>
+                <xs:documentation>Used to control if the On_PropertyName_Changed feature is enabled.</xs:documentation>
+              </xs:annotation>
+            </xs:attribute>
+            <xs:attribute name="TriggerDependentProperties" type="xs:boolean">
+              <xs:annotation>
+                <xs:documentation>Used to control if the Dependent properties feature is enabled.</xs:documentation>
+              </xs:annotation>
+            </xs:attribute>
+            <xs:attribute name="EnableIsChangedProperty" type="xs:boolean">
+              <xs:annotation>
+                <xs:documentation>Used to control if the IsChanged property feature is enabled.</xs:documentation>
+              </xs:annotation>
+            </xs:attribute>
+            <xs:attribute name="EventInvokerNames" type="xs:string">
+              <xs:annotation>
+                <xs:documentation>Used to change the name of the method that fires the notify event. This is a string that accepts multiple values in a comma separated form.</xs:documentation>
+              </xs:annotation>
+            </xs:attribute>
+            <xs:attribute name="CheckForEquality" type="xs:boolean">
+              <xs:annotation>
+                <xs:documentation>Used to control if equality checks should be inserted. If false, equality checking will be disabled for the project.</xs:documentation>
+              </xs:annotation>
+            </xs:attribute>
+            <xs:attribute name="CheckForEqualityUsingBaseEquals" type="xs:boolean">
+              <xs:annotation>
+                <xs:documentation>Used to control if equality checks should use the Equals method resolved from the base class.</xs:documentation>
+              </xs:annotation>
+            </xs:attribute>
+            <xs:attribute name="UseStaticEqualsFromBase" type="xs:boolean">
+              <xs:annotation>
+                <xs:documentation>Used to control if equality checks should use the static Equals method resolved from the base class.</xs:documentation>
+              </xs:annotation>
+            </xs:attribute>
+            <xs:attribute name="SuppressWarnings" type="xs:boolean">
+              <xs:annotation>
+                <xs:documentation>Used to turn off build warnings from this weaver.</xs:documentation>
+              </xs:annotation>
+            </xs:attribute>
+            <xs:attribute name="SuppressOnPropertyNameChangedWarning" type="xs:boolean">
+              <xs:annotation>
+                <xs:documentation>Used to turn off build warnings about mismatched On_PropertyName_Changed methods.</xs:documentation>
+              </xs:annotation>
+            </xs:attribute>
+          </xs:complexType>
+        </xs:element>
+      </xs:all>
+      <xs:attribute name="VerifyAssembly" type="xs:boolean">
+        <xs:annotation>
+          <xs:documentation>'true' to run assembly verification (PEVerify) on the target assembly after all weavers have been executed.</xs:documentation>
+        </xs:annotation>
+      </xs:attribute>
+      <xs:attribute name="VerifyIgnoreCodes" type="xs:string">
+        <xs:annotation>
+          <xs:documentation>A comma-separated list of error codes that can be safely ignored in assembly verification.</xs:documentation>
+        </xs:annotation>
+      </xs:attribute>
+      <xs:attribute name="GenerateXsd" type="xs:boolean">
+        <xs:annotation>
+          <xs:documentation>'false' to turn off automatic generation of the XML Schema file.</xs:documentation>
+        </xs:annotation>
+      </xs:attribute>
+    </xs:complexType>
+  </xs:element>
+</xs:schema>

Torch.Server/Initializer.cs

@@ -5,88 +5,78 @@ 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;
-using VRage.Library.Exceptions;
 
 namespace Torch.Server
 {
     public class Initializer
     {
+        internal static Initializer Instance { get; private set; }
+
         private static readonly Logger Log = LogManager.GetLogger(nameof(Initializer));
         private bool _init;
-        private const string STEAMCMD_DIR = "steamcmd";
-        private const string STEAMCMD_ZIP = "temp.zip";
-        private static readonly string STEAMCMD_PATH = $"{STEAMCMD_DIR}\\steamcmd.exe";
-        private static readonly string RUNSCRIPT_PATH = $"{STEAMCMD_DIR}\\runscript.txt";
-
-        private const string RUNSCRIPT = @"force_install_dir ../
-login anonymous
-app_update 298740
-quit";
-
-        private TorchConfig _config;
+        private const string TOOL_DIR = "tool";
+        private const string TOOL_ZIP = "temp.zip";
+        private static readonly string TOOL_EXE = "DepotDownloader.exe";
+        private const string TOOL_ARGS = "-app 298740 -depot {1} -dir \"{0}\" -manifest {2}";
+        private static readonly int[] Depots = { 298741, 1004 }; 
         private TorchServer _server;
-        private string _basePath;
 
-        public TorchConfig Config => _config;
+        internal Persistent<TorchConfig> ConfigPersistent { get; }
+        public TorchConfig Config => ConfigPersistent?.Data;
         public TorchServer Server => _server;
 
-        public Initializer(string basePath)
+        public Initializer(Persistent<TorchConfig> torchConfig)
         {
-            _basePath = basePath;
+            Instance = this;
+            ConfigPersistent = torchConfig;
         }
 
-        public bool Initialize(string[] args)
+        public bool Initialize(IConfiguration configuration)
         {
             if (_init)
                 return false;
-
-#if !DEBUG
-            AppDomain.CurrentDomain.UnhandledException += HandleException;
+#if DEBUG
+            //enables logging debug messages when built in debug mode. Amazing.
+            LogManager.Configuration.AddRule(LogLevel.Debug, LogLevel.Debug, "main");
+            LogManager.Configuration.AddRule(LogLevel.Debug, LogLevel.Debug, "console");
+            LogManager.Configuration.AddRule(LogLevel.Debug, LogLevel.Debug, "wpf");
+            LogManager.ReconfigExistingLoggers();
+            Log.Debug("Debug logging enabled.");
 #endif
             
-            // This is what happens when Keen is bad and puts extensions into the System namespace.
-            if (!Enumerable.Contains(args, "-noupdate"))
-                RunSteamCmd();
+            if (configuration.GetValue("getGameUpdates", true) && !configuration.GetValue("noupdate", false))
+                RunSteamCmdAsync(configuration).Wait();
 
-            var basePath = new FileInfo(typeof(Program).Assembly.Location).Directory.ToString();
-            var apiSource = Path.Combine(basePath, "DedicatedServer64", "steam_api64.dll");
-            var apiTarget = Path.Combine(basePath, "steam_api64.dll");
-            
-            if (!File.Exists(apiTarget))
-                File.Copy(apiSource, apiTarget);
-            
-            _config = InitConfig();
-            if (!_config.Parse(args))
-                return false;
-
-            if (!string.IsNullOrEmpty(_config.WaitForPID))
+            var processPid = configuration.GetValue<int>("waitForPid");
+            if (processPid != 0)
             {
                 try
                 {
-                    var pid = int.Parse(_config.WaitForPID);
-                    var waitProc = Process.GetProcessById(pid);
+                    var waitProc = Process.GetProcessById(processPid);
                     Log.Info("Continuing in 5 seconds.");
-                    Log.Warn($"Waiting for process {pid} to close");
+                    Log.Warn($"Waiting for process {processPid} to close");
                     while (!waitProc.HasExited)
                     {
                         Console.Write(".");
                         Thread.Sleep(1000);
                     }
                 }
-                catch
+                catch (Exception e)
                 {
-                    // ignored
+                    Log.Warn(e);
                 }
             }
 
@@ -96,143 +86,104 @@ quit";
 
         public void Run()
         {
-            _server = new TorchServer(_config);
-            var init = Task.Run(() => _server.Init()).ContinueWith(x =>
-            {
-                if (!x.IsFaulted)
-                    return;
+            _server = new TorchServer(Config, ApplicationContext.Current.InstanceDirectory.FullName, ApplicationContext.Current.InstanceName);
 
-                Log.Error("Error initializing server.");
-                LogException(x.Exception);
-            });
-            if (!_config.NoGui)
+            if (ApplicationContext.Current.IsService || Config.NoGui)
             {
-                if (_config.Autostart)
-                    init.ContinueWith(x => _server.Start());
-
-                Log.Info("Showing UI");
-                Console.SetOut(TextWriter.Null);
-                NativeMethods.FreeConsole();
-                new TorchUI(_server).ShowDialog();
-            }
-            else
-            {
-                init.Wait();
+                _server.Init();
                 _server.Start();
             }
-        }
-
-        private TorchConfig InitConfig()
-        {
-            var configName = "Torch.cfg";
-            var configPath = Path.Combine(Directory.GetCurrentDirectory(), configName);
-            if (File.Exists(configName))
-            {
-                Log.Info($"Loading config {configPath}");
-                return TorchConfig.LoadFrom(configPath);
-            }
             else
             {
-                Log.Info($"Generating default config at {configPath}");
-                var config = new TorchConfig {InstancePath = Path.GetFullPath("Instance")};
-                config.Save(configPath);
-                return config;
-            }
-        }
-
-        public static void RunSteamCmd()
+#if !DEBUG
+                if (!Config.IndependentConsole)
                 {
-            var log = LogManager.GetLogger("SteamCMD");
+                    Console.SetOut(TextWriter.Null);
+                    NativeMethods.FreeConsole();
+                }
+#endif
                 
-            if (!Directory.Exists(STEAMCMD_DIR))
+                var uiThread = new Thread(() =>
                 {
-                Directory.CreateDirectory(STEAMCMD_DIR);
+                    var ui = new TorchUI(_server);
+                
+                    SynchronizationContext.SetSynchronizationContext(
+                        new DispatcherSynchronizationContext(Dispatcher.CurrentDispatcher));
+                
+                    ui.ShowDialog();
+                });
+                
+                uiThread.SetApartmentState(ApartmentState.STA);
+                uiThread.Start();
+
+                _server.Init();
+
+                if (Config.Autostart || Config.TempAutostart)
+                {
+                    Config.TempAutostart = false;
+                    _server.Start();
                 }
 
-            if (!File.Exists(RUNSCRIPT_PATH))
-                File.WriteAllText(RUNSCRIPT_PATH, RUNSCRIPT);
+                uiThread.Join();
+            }
+        }
         
-            if (!File.Exists(STEAMCMD_PATH))
+        public static async Task RunSteamCmdAsync(IConfiguration configuration)
+        {
+            var log = LogManager.GetLogger("SteamTool");
+
+            var path = configuration.GetValue<string>("steamToolPath") ?? ApplicationContext.Current.TorchDirectory
+                .CreateSubdirectory(TOOL_DIR).FullName;
+            
+            if (!Directory.Exists(path))
+            {
+                Directory.CreateDirectory(path);
+            }
+
+            var steamCmdExePath = Path.Combine(path, TOOL_EXE);
+            if (!File.Exists(steamCmdExePath))
             {
                 try
                 {
-                    log.Info("Downloading SteamCMD.");
-                    using (var client = new WebClient())
-                        client.DownloadFile("https://steamcdn-a.akamaihd.net/client/installer/steamcmd.zip", STEAMCMD_ZIP);
+                    log.Info("Downloading Steam Tool.");
+                    using (var client = new HttpClient())
+                    await using (var file = File.Create(TOOL_ZIP))
+                    await using (var stream = await client.GetStreamAsync("https://github.com/SteamRE/DepotDownloader/releases/download/DepotDownloader_2.4.7/depotdownloader-2.4.7.zip"))
+                        await stream.CopyToAsync(file);
 
-                    ZipFile.ExtractToDirectory(STEAMCMD_ZIP, STEAMCMD_DIR);
-                    File.Delete(STEAMCMD_ZIP);
-                    log.Info("SteamCMD downloaded successfully!");
+                    ZipFile.ExtractToDirectory(TOOL_ZIP, path);
+                    File.Delete(TOOL_ZIP);
+                    log.Info("Steam Tool downloaded successfully!");
                 }
-                catch
+                catch (Exception e)
                 {
-                    log.Error("Failed to download SteamCMD, unable to update the DS.");
+                    log.Error(e, "Failed to download Steam Tool, unable to update the DS.");
                     return;
                 }
             }
 
             log.Info("Checking for DS updates.");
-            var steamCmdProc = new ProcessStartInfo(STEAMCMD_PATH, "+runscript runscript.txt")
+            foreach (var depot in Depots)
             {
-                WorkingDirectory = Path.Combine(Directory.GetCurrentDirectory(), STEAMCMD_DIR),
-                UseShellExecute = false,
-                RedirectStandardOutput = true,
-                StandardOutputEncoding = Encoding.ASCII
-            };
-            var cmd = Process.Start(steamCmdProc);
+                await DownloadDepot(depot);
+            }
+
+            async Task DownloadDepot(int depotId)
+            {
+                var steamCmdProc = new ProcessStartInfo(steamCmdExePath)
+                {
+                    Arguments = string.Format(TOOL_ARGS, configuration.GetValue("gamePath", "../"), depotId, "3111493184861426002"),
+                    WorkingDirectory = path,
+                    RedirectStandardOutput = true
+                };
+                var cmd = Process.Start(steamCmdProc)!;
             
-            // ReSharper disable once PossibleNullReferenceException
                 while (!cmd.HasExited)
                 {
-                log.Info(cmd.StandardOutput.ReadLine());
-                Thread.Sleep(100);
+                    if (await cmd.StandardOutput.ReadLineAsync() is { } line)
+                        log.Info(line);
                 }
             }
-
-        private void LogException(Exception ex)
-        {         
-            if (ex.InnerException != null)
-            {
-                LogException(ex.InnerException);
-            }
-
-            Log.Fatal(ex);
-            
-            if (ex is ReflectionTypeLoadException exti)
-                foreach (Exception exl in exti.LoaderExceptions)
-                    LogException(exl);
-            
-            if (ex is AggregateException ag)
-                foreach (Exception e in ag.InnerExceptions)
-                    LogException(e);
-        }
-
-        private void HandleException(object sender, UnhandledExceptionEventArgs e)
-        {
-            var ex = (Exception)e.ExceptionObject;
-            LogException(ex);
-            if (MyFakes.ENABLE_MINIDUMP_SENDING)
-            {
-                string path = Path.Combine(MyFileSystem.UserDataPath, "Minidump.dmp");
-                Log.Info($"Generating minidump at {path}");
-                MyMiniDump.Options options = MyMiniDump.Options.WithProcessThreadData | MyMiniDump.Options.WithThreadInfo;
-                MyMiniDump.Write(path, options, MyMiniDump.ExceptionInfo.Present);
-            }
-            LogManager.Flush();
-            if (_config.RestartOnCrash)
-            {
-                Console.WriteLine("Restarting in 5 seconds.");
-                Thread.Sleep(5000);
-                var exe = typeof(Program).Assembly.Location;
-                _config.WaitForPID = Process.GetCurrentProcess().Id.ToString();
-                Process.Start(exe, _config.ToString());
-            }
-            else
-            {
-                MessageBox.Show("Torch encountered a fatal error and needs to close. Please check the logs for details.");
-            }
-
-            Process.GetCurrentProcess().Kill();
         }
     }
 }

Torch.Server/LogViewerTarget.cs

@@ -0,0 +1,56 @@
+using System.Collections.Generic;
+using System.Threading;
+using System.Windows.Media;
+using System.Windows.Threading;
+using NLog;
+using NLog.Targets;
+using Torch.Server.ViewModels;
+using Torch.Server.Views;
+
+namespace Torch.Server
+{
+    /// <summary>
+    /// NLog target that writes to a <see cref="LogViewerControl"/>.
+    /// </summary>
+    [Target("logViewer")]
+    public sealed class LogViewerTarget : TargetWithLayout
+    {
+        public IList<LogEntry> LogEntries { get; set; }
+        public SynchronizationContext TargetContext { get; set; }
+        private const int MAX_LINES = 1000;
+
+        /// <inheritdoc />
+        protected override void Write(LogEventInfo logEvent)
+        {
+            TargetContext?.Post(_sendOrPostCallback, logEvent);
+        }
+
+        private void WriteCallback(object state)
+        {
+            var logEvent = (LogEventInfo) state;
+            LogEntries?.Add(new(logEvent.TimeStamp, Layout.Render(logEvent), LogLevelColors[logEvent.Level]));
+            if (LogEntries is not {Count: > MAX_LINES}) return;
+            for (var i = 0; LogEntries.Count > MAX_LINES; i++)
+            {
+                LogEntries.RemoveAt(i);
+            }
+        }
+
+        private static readonly Dictionary<LogLevel, SolidColorBrush> LogLevelColors = new()
+        {
+            [LogLevel.Trace] = new SolidColorBrush(Colors.DimGray),
+            [LogLevel.Debug] = new SolidColorBrush(Colors.DarkGray),
+            [LogLevel.Info] = new SolidColorBrush(Colors.White),
+            [LogLevel.Warn] = new SolidColorBrush(Colors.Magenta),
+            [LogLevel.Error] = new SolidColorBrush(Colors.Yellow),
+            [LogLevel.Fatal] = new SolidColorBrush(Colors.Red),
+        };
+
+        private readonly SendOrPostCallback _sendOrPostCallback;
+
+        public LogViewerTarget()
+        {
+            _sendOrPostCallback = WriteCallback;
+        }
+    }
+}

Torch.Server/Managers/EntityControlManager.cs

@@ -40,15 +40,7 @@ namespace Torch.Server.Managers
 
             protected abstract EntityControlViewModel Create(EntityViewModel evm);
 
-#pragma warning disable 649
-            [ReflectedGetter(Name = "Keys")]
-            private static readonly Func<ConditionalWeakTable<EntityViewModel, EntityControlViewModel>, ICollection<EntityViewModel>> _weakTableKeys;
-#pragma warning restore 649
-
-            /// <summary>
-            /// Warning: Creates a giant list, avoid if possible.
-            /// </summary>
-            internal ICollection<EntityViewModel> Keys => _weakTableKeys(_models);
+            internal IEnumerable<EntityViewModel> Keys => _models.Select(b => b.Key);
 
             internal EntityControlViewModel GetOrCreate(EntityViewModel evm)
             {

Torch.Server/Managers/InstanceManager.cs

@@ -1,22 +1,27 @@
-using System;
+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.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;
 using Torch.Managers;
 using Torch.Mod;
 using Torch.Server.ViewModels;
+using Torch.Utils;
 using VRage;
 using VRage.FileSystem;
 using VRage.Game;
@@ -26,7 +31,7 @@ using VRage.Plugins;
 
 namespace Torch.Server.Managers
 {
-    public class InstanceManager : Manager
+    public class InstanceManager : Manager, IInstanceManager
     {
         private const string CONFIG_NAME = "SpaceEngineers-Dedicated.cfg";
 
@@ -36,11 +41,15 @@ namespace Torch.Server.Managers
         [Dependency]
         private FilesystemManager _filesystemManager;
 
-        public InstanceManager(ITorchBase torchInstance) : base(torchInstance)
-        {
+        private new ITorchServer Torch { get; }
 
+        public InstanceManager(ITorchServer torchInstance) : base(torchInstance)
+        {
+            Torch = torchInstance;
         }
 
+        public IWorld SelectedWorld => DedicatedConfig.SelectedWorld;
+
         public void LoadInstance(string path, bool validate = true)
         {
             Log.Info($"Loading instance {path}");
@@ -53,24 +62,36 @@ namespace Torch.Server.Managers
             //Initializes saves path. Why this isn't in Init() we may never know.
             MyFileSystem.InitUserSpecific(null);
 
-            var configPath = Path.Combine(path, CONFIG_NAME);
-            if (!File.Exists(configPath))
-            {
-                Log.Error($"Failed to load dedicated config at {path}");
-                return;
-            }
+            // why?....
+            // var configPath = Path.Combine(path, CONFIG_NAME);
+            // if (!File.Exists(configPath))
+            // {
+            //     Log.Error($"Failed to load dedicated config at {path}");
+            //     return;
+            // }
 
-            var config = new MyConfigDedicated<MyObjectBuilder_SessionSettings>(configPath);
-            config.Load(configPath);
             
-            DedicatedConfig = new ConfigDedicatedViewModel(config);
+            // var config = new MyConfigDedicated<MyObjectBuilder_SessionSettings>(configPath);
+            // config.Load(configPath);
 
-            var worldFolders = Directory.EnumerateDirectories(Path.Combine(Torch.Config.InstancePath, "Saves"));
+            DedicatedConfig = new ConfigDedicatedViewModel((MyConfigDedicated<MyObjectBuilder_SessionSettings>) MySandboxGame.ConfigDedicated);
+
+            var worldFolders = Directory.EnumerateDirectories(Path.Combine(Torch.InstancePath, "Saves"));
 
             foreach (var f in worldFolders)
+            {
+                try
                 {
                     if (!string.IsNullOrEmpty(f) && File.Exists(Path.Combine(f, "Sandbox.sbc")))
-                    DedicatedConfig.Worlds.Add(new WorldViewModel(f));
+                    {
+                        var worldViewModel = new WorldViewModel(f, DedicatedConfig.LoadWorld == f);
+                        DedicatedConfig.Worlds.Add(worldViewModel);
+                    }
+                }
+                catch (Exception ex)
+                {
+                    Log.Error(ex, "Failed to load world at path: " + f);
+                }
             }
 
             if (DedicatedConfig.Worlds.Count == 0)
@@ -84,17 +105,51 @@ namespace Torch.Server.Managers
             InstanceLoaded?.Invoke(DedicatedConfig);
         }
 
+        public void SelectCreatedWorld(string worldPath)
+        {
+            WorldViewModel worldViewModel;
+            try
+            {
+                worldViewModel = new(worldPath);
+                DedicatedConfig.Worlds.Add(worldViewModel);
+            }
+            catch (Exception ex)
+            {
+                Log.Error(ex, "Failed to load world at path: " + worldPath);
+                return;
+            }
+            SelectWorld(worldViewModel, false);
+        }
+
         public void SelectWorld(string worldPath, bool modsOnly = true)
         {
             DedicatedConfig.LoadWorld = worldPath;
-            DedicatedConfig.SelectedWorld = DedicatedConfig.Worlds.FirstOrDefault(x => x.WorldPath == worldPath);
+            
+            var worldInfo = DedicatedConfig.Worlds.FirstOrDefault(x => x.WorldPath == worldPath);
+            try
+            {
+                if (worldInfo?.Checkpoint == null)
+                {
+                    worldInfo = new WorldViewModel(worldPath);
+                    DedicatedConfig.Worlds.Add(worldInfo);
+                }
+            }
+            catch (Exception ex)
+            {
+                Log.Error(ex, "Failed to load world at path: " + worldPath);
+                DedicatedConfig.LoadWorld = null;
+                return;
+            }
+
+            DedicatedConfig.SelectedWorld = worldInfo;
             if (DedicatedConfig.SelectedWorld?.Checkpoint != null)
             {
                 DedicatedConfig.Mods.Clear();
                 //remove the Torch mod to avoid running multiple copies of it
-                DedicatedConfig.SelectedWorld.Checkpoint.Mods.RemoveAll(m => m.PublishedFileId == TorchModCore.MOD_ID);
-                foreach (var m in DedicatedConfig.SelectedWorld.Checkpoint.Mods)
-                    DedicatedConfig.Mods.Add(m.PublishedFileId);
+                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());
             }
         }
 
@@ -106,9 +161,10 @@ namespace Torch.Server.Managers
             {
                 DedicatedConfig.Mods.Clear();
                 //remove the Torch mod to avoid running multiple copies of it
-                DedicatedConfig.SelectedWorld.Checkpoint.Mods.RemoveAll(m => m.PublishedFileId == TorchModCore.MOD_ID);
-                foreach (var m in DedicatedConfig.SelectedWorld.Checkpoint.Mods)
-                    DedicatedConfig.Mods.Add(m.PublishedFileId);
+                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());
             }
         }
 
@@ -119,17 +175,16 @@ namespace Torch.Server.Managers
 
         private void ImportWorldConfig(WorldViewModel world, bool modsOnly = true)
         {
-            var sb = new StringBuilder();
-            foreach (var mod in world.Checkpoint.Mods)
-                sb.AppendLine(mod.PublishedFileId.ToString());
-            
-            DedicatedConfig.Mods = world.Checkpoint.Mods.Select(x => x.PublishedFileId).ToList();
+            var mods = new MtObservableList<ModItemInfo>();
+            foreach (var mod in world.WorldConfiguration.Mods)
+                mods.Add(new ModItemInfo(mod));
+            DedicatedConfig.Mods = mods;
 
 
             Log.Debug("Loaded mod list from world");
 
             if (!modsOnly)
-                DedicatedConfig.SessionSettings = world.Checkpoint.Settings;
+                DedicatedConfig.SessionSettings = world.WorldConfiguration.Settings;
         }
 
         private void ImportWorldConfig(bool modsOnly = true)
@@ -151,7 +206,10 @@ namespace Torch.Server.Managers
                     return;
                 }
 
-                DedicatedConfig.Mods = checkpoint.Mods.Select(x => x.PublishedFileId).ToList();
+                var mods = new MtObservableList<ModItemInfo>();
+                foreach (var mod in checkpoint.Mods)
+                    mods.Add(new ModItemInfo(mod));
+                DedicatedConfig.Mods = mods;
 
                 Log.Debug("Loaded mod list from world");
 
@@ -167,44 +225,40 @@ namespace Torch.Server.Managers
 
         public void SaveConfig()
         {
-            var cf = Torch.Config as TorchConfig;
-            if (cf?.ReservedPlayers?.Count > 0)
+            if (!((TorchServer)Torch).HasRun)
             {
-                foreach (var res in cf.ReservedPlayers)
-                {
-                    if (!DedicatedConfig.Reserved.Contains(res))
-                        DedicatedConfig.Reserved.Add(res);
-                }
-            }
-
-            DedicatedConfig.Save(Path.Combine(Torch.Config.InstancePath, CONFIG_NAME));
+                DedicatedConfig.Save(Path.Combine(Torch.InstancePath, CONFIG_NAME));
                 Log.Info("Saved dedicated config.");
+            }
 
             try
             {
-                var sandboxPath = Path.Combine(DedicatedConfig.LoadWorld, "Sandbox.sbc");
-                MyObjectBuilderSerializer.DeserializeXML(sandboxPath, out MyObjectBuilder_Checkpoint checkpoint, out ulong sizeInBytes);
-                if (checkpoint == null)
+                var world = DedicatedConfig.SelectedWorld;
+
+                world.Checkpoint.SessionName = string.IsNullOrEmpty(world.Checkpoint.SessionName)
+                    ? Path.GetDirectoryName(DedicatedConfig.LoadWorld)
+                    : world.Checkpoint.SessionName;
+                world.WorldConfiguration.Settings = DedicatedConfig.SessionSettings;
+                world.WorldConfiguration.Mods.Clear();
+
+                foreach (var mod in DedicatedConfig.Mods)
                 {
-                    Log.Error($"Failed to load {DedicatedConfig.LoadWorld}, checkpoint null ({sizeInBytes} bytes, instance {Torch.Config.InstancePath})");
-                    return;
+                    var savedMod = ModItemUtils.Create(mod.PublishedFileId);
+                    savedMod.IsDependency = mod.IsDependency;
+                    savedMod.Name = mod.Name;
+                    savedMod.FriendlyName = mod.FriendlyName;
+                    
+                    world.WorldConfiguration.Mods.Add(savedMod);
                 }
+                Task.Run(() => DedicatedConfig.UpdateAllModInfosAsync());
 
-                checkpoint.SessionName = DedicatedConfig.WorldName;
-                checkpoint.Settings = DedicatedConfig.SessionSettings;
-                checkpoint.Mods.Clear();
+                world.SaveSandbox();
 
-                foreach (var modId in DedicatedConfig.Mods)
-                    checkpoint.Mods.Add(new MyObjectBuilder_Checkpoint.ModItem(modId));
-
-                MyObjectBuilderSerializer.SerializeXML(sandboxPath, false, checkpoint);
-
-                //MyLocalCache.SaveCheckpoint(checkpoint, DedicatedConfig.LoadWorld);
                 Log.Info("Saved world config.");
             }
             catch (Exception e)
             {
-                Log.Error("Failed to write sandbox config, changes will not appear on server");
+                Log.Error("Failed to write sandbox config");
                 Log.Error(e);
             }
         }
@@ -215,7 +269,7 @@ namespace Torch.Server.Managers
         private void ValidateInstance(string path)
         {
             Directory.CreateDirectory(Path.Combine(path, "Saves"));
-            Directory.CreateDirectory(Path.Combine(path, "Mods"));
+            // Directory.CreateDirectory(Path.Combine(path, "Mods"));
             var configPath = Path.Combine(path, CONFIG_NAME);
             if (File.Exists(configPath))
                 return;
@@ -225,43 +279,81 @@ namespace Torch.Server.Managers
         }
     }
 
-    public class WorldViewModel : ViewModel
+    public class WorldViewModel : ViewModel, IWorld
     {
         private static readonly Logger Log = LogManager.GetCurrentClassLogger();
 
-        public string FolderName { get; set; }
         public string WorldPath { get; }
+        public MyObjectBuilder_SessionSettings KeenSessionSettings => WorldConfiguration.Settings;
+        public MyObjectBuilder_Checkpoint KeenCheckpoint => Checkpoint;
         public long WorldSizeKB { get; }
         private string _checkpointPath;
-        public CheckpointViewModel Checkpoint { get; private set; }
+        private string _worldConfigPath;
+        private CheckpointViewModel _checkpoint;
 
-        public WorldViewModel(string worldPath)
+        public CheckpointViewModel Checkpoint
+        {
+            get
+            {
+                if (_checkpoint is null) LoadSandbox();
+                return _checkpoint;
+            }
+            private set => _checkpoint = value;
+        }
+
+        public WorldConfigurationViewModel WorldConfiguration { get; private set; }
+
+        public WorldViewModel(string worldPath, bool loadFiles = true)
+        {
+            try
             {
                 WorldPath = worldPath;
                 WorldSizeKB = new DirectoryInfo(worldPath).GetFiles().Sum(x => x.Length) / 1024;
                 _checkpointPath = Path.Combine(WorldPath, "Sandbox.sbc");
-            FolderName = Path.GetFileName(worldPath);
-            BeginLoadCheckpoint();
+                _worldConfigPath = Path.Combine(WorldPath, "Sandbox_config.sbc");
+                if (loadFiles)
+                    LoadSandbox();
+            }
+            catch (ArgumentException ex)
+            {
+                Log.Error($"World view model failed to load the path: {worldPath} Please ensure this is a valid path.");
+                throw; //rethrow to be handled further up the stack
+            }
         }
 
-        public async Task SaveCheckpointAsync()
-        {
-            await Task.Run(() =>
+        public void SaveSandbox()
         {
             using (var f = File.Open(_checkpointPath, FileMode.Create))
                 MyObjectBuilderSerializer.SerializeXML(f, Checkpoint);
-            });
+
+            using (var f = File.Open(_worldConfigPath, FileMode.Create))
+                MyObjectBuilderSerializer.SerializeXML(f, WorldConfiguration);
         }
 
-        private void BeginLoadCheckpoint()
+        public void LoadSandbox()
         {
-            //Task.Run(() =>
-            {
-                Log.Info($"Preloading checkpoint {_checkpointPath}");
-                MyObjectBuilderSerializer.DeserializeXML(_checkpointPath, out MyObjectBuilder_Checkpoint checkpoint);
+            if (!MyObjectBuilderSerializer.DeserializeXML(_checkpointPath, out MyObjectBuilder_Checkpoint checkpoint))
+                throw new SerializationException("Error reading checkpoint, see keen log for details");
             Checkpoint = new CheckpointViewModel(checkpoint);
-                OnPropertyChanged(nameof(Checkpoint));
-            }//);
+            
+            // migrate old saves
+            if (File.Exists(_worldConfigPath))
+            {
+                if (!MyObjectBuilderSerializer.DeserializeXML(_worldConfigPath, out MyObjectBuilder_WorldConfiguration worldConfig))
+                    throw new SerializationException("Error reading settings, see keen log for details");
+                WorldConfiguration = new WorldConfigurationViewModel(worldConfig);
+            }
+            else
+            {
+                WorldConfiguration = new WorldConfigurationViewModel(new MyObjectBuilder_WorldConfiguration
+                {
+                    Mods = checkpoint.Mods,
+                    Settings = checkpoint.Settings
+                });
+
+                checkpoint.Mods = null;
+                checkpoint.Settings = null;
+            }
         }
     }
 }

Torch.Server/Managers/MultiplayerManagerDedicated.cs

@@ -10,8 +10,8 @@ using NLog.Fluent;
 using Sandbox;
 using Sandbox.Engine.Multiplayer;
 using Sandbox.Engine.Networking;
+using Sandbox.Game.Gui;
 using Sandbox.Game.World;
-using Steamworks;
 using Torch.API;
 using Torch.API.Managers;
 using Torch.Managers;
@@ -62,6 +62,36 @@ namespace Torch.Server.Managers
             });
         }
 
+        /// <inheritdoc />
+        public void PromoteUser(ulong steamId)
+        {
+            Torch.Invoke(() =>
+            {
+                var p = MySession.Static.GetUserPromoteLevel(steamId);
+                if (p < MyPromoteLevel.Admin) //cannot promote to owner by design
+                    //MySession.Static.SetUserPromoteLevel(steamId, p + 1);
+                    MyGuiScreenPlayers.PromoteImplementation(steamId, true);
+            });
+        }
+
+        /// <inheritdoc />
+        public void DemoteUser(ulong steamId)
+        {
+            Torch.Invoke(() =>
+            {
+                var p = MySession.Static.GetUserPromoteLevel(steamId);
+                if (p > MyPromoteLevel.None && p < MyPromoteLevel.Owner) //owner cannot be demoted by design
+                    //MySession.Static.SetUserPromoteLevel(steamId, p - 1);
+                    MyGuiScreenPlayers.PromoteImplementation(steamId, false);
+            });
+        }
+
+        /// <inheritdoc />
+        public MyPromoteLevel GetUserPromoteLevel(ulong steamId)
+        {
+            return MySession.Static.GetUserPromoteLevel(steamId);
+        }
+
         internal void RaiseClientBanned(ulong user, bool banned)
         {
             PlayerBanned?.Invoke(user, banned);
@@ -81,23 +111,43 @@ namespace Torch.Server.Managers
         public bool IsBanned(ulong steamId) => _isClientBanned.Invoke(MyMultiplayer.Static, steamId) ||
                                                MySandboxGame.ConfigDedicated.Banned.Contains(steamId);
 
+
+
+        public bool IsProfiling(ulong steamId) => _Profiling.Invoke((MyDedicatedServerBase)MyMultiplayer.Static, steamId);
+
         /// <inheritdoc />
         public event Action<ulong> PlayerKicked;
 
         /// <inheritdoc />
         public event Action<ulong, bool> PlayerBanned;
 
+        /// <inheritdoc />
+        public event Action<ulong, MyPromoteLevel> PlayerPromoted;
+
+        internal void RaisePromoteChanged(ulong steamId, MyPromoteLevel level)
+        {
+            PlayerPromoted?.Invoke(steamId, level);
+        }
+
         /// <inheritdoc/>
         public override void Attach()
         {
             base.Attach();
+            if (Torch.Config.UgcServiceType == UGCServiceType.Steam)
+            {
                 _gameServerValidateAuthTicketReplacer = _gameServerValidateAuthTicketFactory.Invoke();
                 _gameServerUserGroupStatusReplacer = _gameServerUserGroupStatusFactory.Invoke();
+            }
+            else
+            {
+                _gameServerValidateAuthTicketReplacer = _eosServerValidateAuthTicketFactory.Invoke();
+                _gameServerUserGroupStatusReplacer = _eosServerUserGroupStatusFactory.Invoke();
+            }
             _gameServerValidateAuthTicketReplacer.Replace(
-                new Action<ulong, JoinResult, ulong>(ValidateAuthTicketResponse), MyGameService.GameServer);
+                new Action<ulong, JoinResult, ulong, string>(ValidateAuthTicketResponse), MyGameService.GameServer);
             _gameServerUserGroupStatusReplacer.Replace(new Action<ulong, ulong, bool, bool>(UserGroupStatusResponse),
                 MyGameService.GameServer);
-            _log.Info("Inserted steam authentication intercept");
+            _log.Info("Inserted authentication intercept");
         }
 
         /// <inheritdoc/>
@@ -107,20 +157,28 @@ namespace Torch.Server.Managers
                 _gameServerValidateAuthTicketReplacer.Restore(MyGameService.GameServer);
             if (_gameServerUserGroupStatusReplacer != null && _gameServerUserGroupStatusReplacer.Replaced)
                 _gameServerUserGroupStatusReplacer.Restore(MyGameService.GameServer);
-            _log.Info("Removed steam authentication intercept");
+            _log.Info("Removed authentication intercept");
             base.Detach();
         }
 
 
 #pragma warning disable 649
-        [ReflectedEventReplace(typeof(MySteamGameServer), nameof(MySteamGameServer.ValidateAuthTicketResponse),
+        [ReflectedEventReplace("VRage.Steam.MySteamGameServer, VRage.Steam", "ValidateAuthTicketResponse",
             typeof(MyDedicatedServerBase), "GameServer_ValidateAuthTicketResponse")]
         private static Func<ReflectedEventReplacer> _gameServerValidateAuthTicketFactory;
 
-        [ReflectedEventReplace(typeof(MySteamGameServer), nameof(MySteamGameServer.UserGroupStatusResponse),
+        [ReflectedEventReplace("VRage.Steam.MySteamGameServer, VRage.Steam", "UserGroupStatusResponse",
             typeof(MyDedicatedServerBase), "GameServer_UserGroupStatus")]
         private static Func<ReflectedEventReplacer> _gameServerUserGroupStatusFactory;
         
+        [ReflectedEventReplace("VRage.EOS.MyEOSGameServer, VRage.EOS", "ValidateAuthTicketResponse",
+            typeof(MyDedicatedServerBase), "GameServer_ValidateAuthTicketResponse")]
+        private static Func<ReflectedEventReplacer> _eosServerValidateAuthTicketFactory;
+
+        [ReflectedEventReplace("VRage.EOS.MyEOSGameServer, VRage.EOS", "UserGroupStatusResponse",
+            typeof(MyDedicatedServerBase), "GameServer_UserGroupStatus")]
+        private static Func<ReflectedEventReplacer> _eosServerUserGroupStatusFactory;
+
         private ReflectedEventReplacer _gameServerValidateAuthTicketReplacer;
         private ReflectedEventReplacer _gameServerUserGroupStatusReplacer;
 #pragma warning restore 649
@@ -134,6 +192,9 @@ namespace Torch.Server.Managers
         [ReflectedStaticMethod(Type = typeof(MyGameService), Name = "GetServerAccountType")]
         private static Func<ulong, MyGameServiceAccountType> _getServerAccountType;
 
+        [ReflectedMethod(Name = "ClientIsProfiling")]
+        private static Func<MyDedicatedServerBase, ulong, bool> _Profiling;
+
         [ReflectedMethod(Name = "UserAccepted")]
         private static Action<MyDedicatedServerBase, ulong> _userAcceptedImpl;
 
@@ -168,10 +229,10 @@ namespace Torch.Server.Managers
         }
 
         //Largely copied from SE
-        private void ValidateAuthTicketResponse(ulong steamId, JoinResult response, ulong steamOwner)
+        private void ValidateAuthTicketResponse(ulong steamId, JoinResult response, ulong steamOwner, string serviceName)
         {           
             var state = new MyP2PSessionState();
-            MySteamService.Static.Peer2Peer.GetSessionState(steamId, ref state);
+            Sandbox.Engine.Networking.MyGameService.Peer2Peer.GetSessionState(steamId, ref state);
             var ip = new IPAddress(BitConverter.GetBytes(state.RemoteIP).Reverse().ToArray());
 
             Torch.CurrentSession.KeenSession.PromotedUsers.TryGetValue(steamId, out MyPromoteLevel promoteLevel);
@@ -180,7 +241,12 @@ namespace Torch.Server.Managers
 
             _log.Info($"Connection attempt by {steamId} from {ip}");
 
-            if (Torch.CurrentSession.KeenSession.OnlineMode == MyOnlineModeEnum.OFFLINE &&
+            if (IsProfiling(steamId))
+            {
+                _log.Warn($"Rejecting user {steamId} for using Profiler/ModSDK!");
+                UserRejected(steamId, JoinResult.ProfilingNotAllowed);
+            }
+            else if (Torch.CurrentSession.KeenSession.OnlineMode == MyOnlineModeEnum.OFFLINE &&
                      promoteLevel < MyPromoteLevel.Admin)
             {
                 _log.Warn($"Rejecting user {steamId}, world is set to offline and user is not admin.");
@@ -254,6 +320,11 @@ namespace Torch.Server.Managers
                     _log.Error(task.Exception, $"Future validation verdict faulted");
                     verdict = JoinResult.TicketCanceled;
                 }
+                else if (Players.ContainsKey(info.SteamID))
+                {
+                    _log.Warn($"Player {info.SteamID} has already joined!");
+                    verdict = JoinResult.AlreadyJoined;
+                }
                 else
                     verdict = task.Result;
 

Torch.Server/Managers/RemoteAPIManager.cs

@@ -0,0 +1,40 @@
+using NLog;
+using Sandbox;
+using Torch.API;
+using Torch.Managers;
+using VRage.Dedicated.RemoteAPI;
+
+namespace Torch.Server.Managers
+{
+    public class RemoteAPIManager : Manager
+    {
+        /// <inheritdoc />
+        public RemoteAPIManager(ITorchBase torchInstance) : base(torchInstance)
+        {
+            
+        }
+        
+        /// <inheritdoc />
+        public override void Attach()
+        {
+            Torch.GameStateChanged += TorchOnGameStateChanged;
+            base.Attach();
+        }
+
+        /// <inheritdoc />
+        public override void Detach()
+        {
+            Torch.GameStateChanged -= TorchOnGameStateChanged;
+            base.Detach();
+        }
+
+        private void TorchOnGameStateChanged(MySandboxGame game, TorchGameState newstate)
+        {
+            if (newstate == TorchGameState.Loading && MySandboxGame.ConfigDedicated.RemoteApiEnabled && !string.IsNullOrEmpty(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/Patches/CheckpointLoadPatch.cs

@@ -0,0 +1,46 @@
+using System.Reflection;
+using NLog;
+using Sandbox.Engine.Networking;
+using Torch.API.Managers;
+using Torch.Managers.PatchManager;
+using Torch.Server;
+using Torch.Server.Managers;
+using Torch.Utils;
+using VRage.Game;
+
+namespace Torch.Patches;
+
+[PatchShim]
+public static class CheckpointLoadPatch
+{
+    private static readonly ILogger Log = LogManager.GetCurrentClassLogger();
+    
+    [ReflectedMethodInfo(typeof(MyLocalCache), "LoadCheckpoint")]
+    private static MethodInfo LoadCheckpointMethod = null!;
+    
+    public static void Patch(PatchContext context)
+    {
+        context.GetPattern(LoadCheckpointMethod).AddPrefix();
+    }
+
+    private static bool Prefix(ref MyObjectBuilder_Checkpoint __result)
+    {
+#pragma warning disable CS0618
+        if (!((TorchServer)TorchBase.Instance).HasRun)
+            return true;
+        
+        var world = TorchBase.Instance.Managers.GetManager<InstanceManager>().DedicatedConfig.SelectedWorld;
+#pragma warning restore CS0618
+        if (world is null)
+        {
+            Log.Error("Selected world is null");
+            return false;
+        }
+
+        world.KeenCheckpoint.Settings = world.WorldConfiguration.Settings;
+        world.KeenCheckpoint.Mods = world.WorldConfiguration.Mods;
+
+        __result = world.Checkpoint;
+        return false;
+    }
+}

Torch.Server/Patches/PromotePatch.cs

@@ -0,0 +1,38 @@
+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;
+using VRage.Game.ModAPI;
+using Torch.API.Managers;
+using Torch.Server.Managers;
+
+namespace Torch.Patches
+{
+    [PatchShim]
+    internal static class PromotePatch
+    {
+        private static Logger _log = LogManager.GetCurrentClassLogger();
+        private static IMultiplayerManagerServer _backing;
+
+        private static IMultiplayerManagerServer ServerManager => _backing ?? (_backing = TorchBase.Instance?.CurrentSession?.Managers.GetManager<IMultiplayerManagerServer>());
+
+        public static void Patch(PatchContext ctx)
+        {
+            _log.Info("patching promote");
+            ctx.GetPattern(typeof(MySession).GetMethod("OnPromoteLevelSet", BindingFlags.NonPublic | BindingFlags.Static)).Prefixes.Add(typeof(PromotePatch).GetMethod(nameof(PromotePrefix)));
+        }
+
+        public static void PromotePrefix(ulong steamId, MyPromoteLevel level)
+        {
+            if (ServerManager is MultiplayerManagerDedicated d)
+                d.RaisePromoteChanged(steamId, level);
+            else
+                throw new NotSupportedException();
+        }
+    }
+}

Torch.Server/Patches/ServerResponsePatch.cs

@@ -0,0 +1,44 @@
+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
+{
+    [PatchShim]
+    public static class ServerResponsePatch
+    {
+        private static Logger _log = LogManager.GetCurrentClassLogger();
+
+        public static void Patch(PatchContext ctx)
+        {
+            var transpiler = typeof(ServerResponsePatch).GetMethod(nameof(Transpile), BindingFlags.Public | BindingFlags.Static);
+            ctx.GetPattern(typeof(MyDedicatedServerBase).GetMethod("Initialize", BindingFlags.NonPublic | BindingFlags.Instance))
+               .Transpilers.Add(transpiler);
+            _log.Info("Patching Steam response polling");
+        }
+
+        public static IEnumerable<MsilInstruction> Transpile(IEnumerable<MsilInstruction> instructions)
+        {
+            // 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)
+                {
+                    _log.Info("Patching Steam response timeout to 5 seconds");
+                    inlineI32.Value = 50;
+                }
+
+                yield return instruction;
+            }
+        }
+    }
+}

Torch.Server/Patches/SteamLoginPatch.cs

@@ -0,0 +1,35 @@
+using System.Reflection;
+using NLog;
+using Steamworks;
+using Torch.Managers.PatchManager;
+using Torch.Utils;
+
+namespace Torch.Patches;
+
+[PatchShim]
+public static class SteamLoginPatch
+{
+    private static readonly ILogger Log = LogManager.GetCurrentClassLogger();
+    
+    [ReflectedMethodInfo(null, "LogOnAnonymous", TypeName = "VRage.Steam.MySteamGameServer, VRage.Steam")]
+    private static MethodInfo LoginMethod = null!;
+
+    public static void Patch(PatchContext context)
+    {
+        context.GetPattern(LoginMethod).AddPrefix();
+    }
+        
+    private static bool Prefix()
+    {
+#pragma warning disable CS0618
+        var token = TorchBase.Instance.Config.LoginToken;
+#pragma warning restore CS0618
+
+        if (string.IsNullOrEmpty(token))
+            return true;
+
+        Log.Info("Logging in to Steam with GSLT");
+        SteamGameServer.LogOn(token);
+        return false;
+    }
+}

Torch.Server/Patches/WorldLoadExceptionPatch.cs

@@ -0,0 +1,52 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Reflection;
+using System.Reflection.Emit;
+using NLog;
+using Sandbox;
+using Torch.Managers.PatchManager;
+using Torch.Managers.PatchManager.MSIL;
+using Torch.Utils;
+
+namespace Torch.Patches
+{
+    /// <summary>
+    /// Patches MySandboxGame.InitQuickLaunch to rethrow exceptions caught during session load.
+    /// </summary>
+    [PatchShim]
+    public static class WorldLoadExceptionPatch
+    {
+        private static readonly ILogger Log = LogManager.GetCurrentClassLogger();
+
+        [ReflectedMethodInfo(typeof(MySandboxGame), "InitQuickLaunch")]
+        private static MethodInfo _quickLaunchMethod = null!;
+
+        public static void Patch(PatchContext ctx)
+        {
+            ctx.GetPattern(_quickLaunchMethod).AddTranspiler(nameof(Transpile));
+        }
+
+        private static IEnumerable<MsilInstruction> Transpile(IEnumerable<MsilInstruction> method)
+        {
+            var msil = method.ToList();
+            for (var i = 0; i < msil.Count; i++)
+            {
+                var instruction = msil[i];
+                if (instruction.IsLocalStore() && instruction.Operand is MsilOperandInline.MsilOperandLocal {Value.Index: 19} operand)
+                {
+                    msil.InsertRange(i + 1, new []
+                    {
+                        operand.Instruction.CopyWith(OpCodes.Ldloc_S),
+                        new MsilInstruction(OpCodes.Call).InlineValue(new Action<Exception>(LogFatal).Method)
+                    });
+                }
+            }
+            return msil;
+        }
+
+        private static void LogFatal(Exception e) => Log.Fatal(e.ToStringDemystified());
+    }
+}

Torch.Server/Program.cs

@@ -1,50 +1,112 @@
 using System;
-using System.Diagnostics;
 using System.IO;
-using System.IO.Compression;
-using System.Net;
-using System.Reflection;
-using System.ServiceProcess;
-using System.Text;
-using System.Threading;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Configuration.Xml;
 using NLog;
+using NLog.Config;
 using NLog.Targets;
+using Torch.API;
 using Torch.Utils;
 
 namespace Torch.Server
 {
     internal static class Program
     {
-        /// <remarks>
-        /// This method must *NOT* load any types/assemblies from the vanilla game, otherwise automatic updates will fail.
-        /// </remarks>
-        [STAThread]
+        [MTAThread]
         public static void Main(string[] args)
         {
-            Target.Register<FlowDocumentTarget>("FlowDocument");
-            //Ensures that all the files are downloaded in the Torch directory.
-            var workingDir = new FileInfo(typeof(Program).Assembly.Location).Directory.ToString();
-            var binDir = Path.Combine(workingDir, "DedicatedServer64");
-            Directory.SetCurrentDirectory(workingDir);
+            var configurationBuilder = new ConfigurationBuilder()
+                .AddEnvironmentVariables("TORCH")
+                .AddCommandLine(args);
+            var configuration = configurationBuilder.Build();
             
-            if (!TorchLauncher.IsTorchWrapped())
-            {
-                TorchLauncher.Launch(Assembly.GetEntryAssembly().FullName, args, binDir);
-                return;
-            }
+            var context = CreateApplicationContext(configuration);
 
-            if (!Environment.UserInteractive)
-            {
-                using (var service = new TorchService())
-                    ServiceBase.Run(service);
-                return;
-            }
+            SetupLogging(context, configuration);
+            var config = SetupConfiguration(context, configurationBuilder, out configuration);
             
-            var initializer = new Initializer(workingDir);
-            if (!initializer.Initialize(args))
-                return;
+            var handler = new UnhandledExceptionHandler(config.Data);
+            AppDomain.CurrentDomain.UnhandledException += handler.OnUnhandledException;
+
+            var initializer = new Initializer(config);
+            if (!initializer.Initialize(configuration))
+                Environment.Exit(1);
+
+#if DEBUG
+            TorchLauncher.Launch(context.TorchDirectory.FullName, context.GameBinariesDirectory.FullName);
+#else
+            TorchLauncher.Launch(context.TorchDirectory.FullName, Path.Combine(context.TorchDirectory.FullName, "torch64"),
+                context.GameBinariesDirectory.FullName);
+#endif
 
             initializer.Run();
         }
+
+        private static void SetupLogging(IApplicationContext context, IConfiguration configuration)
+        {
+            var oldNlog = Path.Combine(context.TorchDirectory.FullName, "NLog.config");
+            var newNlog = configuration.GetValue("loggingConfigPath", Path.Combine(context.InstanceDirectory.FullName, "NLog.config"));
+            if (File.Exists(oldNlog) && !File.ReadAllText(oldNlog).Contains("FlowDocument"))
+                File.Move(oldNlog, newNlog);
+            else if (!File.Exists(newNlog))
+                using (var f = File.Create(newNlog!))
+                    typeof(Program).Assembly.GetManifestResourceStream("Torch.Server.NLog.config")!.CopyTo(f);
+            
+            Target.Register<LogViewerTarget>(nameof(LogViewerTarget));
+            TorchLogManager.RegisterTargets(configuration.GetValue("loggingExtensionsPath",
+                                                                   Path.Combine(
+                                                                       context.InstanceDirectory.FullName,
+                                                                       "LoggingExtensions")));
+            
+            TorchLogManager.SetConfiguration(new XmlLoggingConfiguration(newNlog));
+        }
+
+        private static Persistent<TorchConfig> SetupConfiguration(IApplicationContext context,
+                                                                  IConfigurationBuilder builder,
+                                                                  out IConfigurationRoot configuration)
+        {
+            var oldTorchCfg = Path.Combine(context.TorchDirectory.FullName, "Torch.cfg");
+            var torchCfg = Path.Combine(context.InstanceDirectory.FullName, "Torch.cfg");
+            
+            if (File.Exists(oldTorchCfg))
+                File.Move(oldTorchCfg, torchCfg);
+
+            builder.AddXmlFile(torchCfg, true, true);
+
+            configuration = builder.Build();
+
+            var config = new Persistent<TorchConfig>(torchCfg, configuration.Get<TorchConfig>() ?? new());
+            config.Data.InstanceName = context.InstanceName;
+            config.Data.InstancePath = context.InstanceDirectory.FullName;
+
+            return config;
+        }
+
+        private static IApplicationContext CreateApplicationContext(IConfiguration configuration)
+        {
+            var isService = configuration.GetValue("service", false);
+            
+            var workingDir = AppContext.BaseDirectory;
+            var gamePath = configuration.GetValue("gamePath", workingDir);
+            var binDir = Path.Combine(gamePath, "DedicatedServer64");
+
+            var instanceName = configuration.GetValue("instanceName", "Instance");
+            string instancePath;
+            
+            if (Path.IsPathRooted(instanceName))
+            {
+                instancePath = instanceName;
+                instanceName = Path.GetDirectoryName(instanceName);
+            }
+            else
+            {
+                instancePath = Directory.CreateDirectory(instanceName!).FullName;
+            }
+            
+            Directory.SetCurrentDirectory(gamePath);
+            
+            return new ApplicationContext(new(workingDir), new(gamePath), new(binDir), 
+                new(instancePath), instanceName, isService);
+        }
     }
 }

Torch.Server/Properties/AssemblyInfo.cs

@@ -1,17 +0,0 @@
-using System.Reflection;
-using System.Runtime.InteropServices;
-
-[assembly: AssemblyTitle("Torch Server")]
-[assembly: AssemblyDescription("")]
-[assembly: AssemblyCompany("")]
-[assembly: AssemblyProduct("Torch")]
-[assembly: AssemblyCopyright("Copyright © Torch API 2017")]
-[assembly: AssemblyTrademark("")]
-[assembly: AssemblyCulture("")]
-[assembly: ComVisible(false)]
-
-#if DEBUG
-[assembly: AssemblyConfiguration("Debug")]
-#else
-[assembly: AssemblyConfiguration("Release")]
-#endif