Update readme

Add a scrollpanel to fix clipped controls

.gitignore

@@ -1,6 +1,9 @@
 ## Ignore Visual Studio temporary files, build results, and
 ## files generated by popular Visual Studio add-ons.
 
+#Rider directory
+.idea/
+
 # User-specific files
 *.suo
 *.user
@@ -252,3 +255,6 @@ ModelManifest.xml
 # FAKE - F# Make
 .fake/
 GameBinaries
+
+# Generated Files
+**Gen.cs

CHANGELOG.md

@@ -1,4 +1,13 @@
-# Torch 1.1.205.478
+# 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

CONTRIBUTING.md

@@ -1,9 +1,9 @@
 # Making a Pull Request
-* Fork this repository and make sure your local **master** branch is up to date with the main repository.
+* Fork this repository and make sure your local **staging** branch is up to date with the main repository.
-* Create a new branch for your addition with an appropriate name, e.g. **add-restart-command**
+* Create a new branch from the **staging** branch for your addition with an appropriate name, e.g. **add-restart-command**
   * PRs work by submitting the *entire* branch, so this allows you to continue work without locking up your whole repository.
 * Commit your changes to that branch, making sure that you **follow the code guidelines below**.
-* Submit your branch as a PR to be reviewed.
+* Submit your branch as a PR to be reviewed, with Torch's **staging** branch as the base.
 
 ## Naming Conventions
 * Types: **PascalCase**

Jenkins/jenkins-grab-se.ps1

@@ -0,0 +1,22 @@
+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

@@ -0,0 +1,52 @@
+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

@@ -0,0 +1,73 @@
+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

@@ -1,15 +1,27 @@
 <?xml version="1.0" encoding="utf-8" ?>
 <nlog xmlns="http://www.nlog-project.org/schemas/NLog.xsd"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+  <variable name="logStamp" value="${time} ${pad:padding=-8:inner=[${level:uppercase=true}]}" />
+  <variable name="logContent" value="${message:withException=true}"/>
 
-  <targets>
+  <targets async="true">
-    <target xsi:type="File" name="main" layout="${time} [${level:uppercase=true}] ${logger}: ${message}" fileName="Logs\Torch-${shortdate}.log" />
+    <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" name="chat" layout="${longdate} ${message}" fileName="Logs\Chat.log" />
-    <target xsi:type="ColoredConsole" name="console" layout="${time} [${level:uppercase=true}] ${logger}: ${message}" />
+    <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}" />
   </targets>
 
   <rules>
-    <logger name="*" minlevel="Info" writeTo="main, console" />
+    <logger name="Keen" minlevel="Warn" writeTo="main"/>
+    <logger name="Keen" minlevel="Info" writeTo="console, wpf"/>
+    <logger name="Keen" minlevel="Debug" writeTo="keen" final="true" />
+    <logger name="Keen" writeTo="null" final="true" />
+
+    <logger name="*" minlevel="Info" writeTo="main, console, wpf" />
     <logger name="Chat" minlevel="Info" writeTo="chat" />
+    <!--<logger name="Torch.Managers.PatchManager.*" minlevel="Trace" writeTo="patch"/>-->
   </rules>
 </nlog>

README.md

@@ -1,31 +1,27 @@
-Discord: [![Discord](https://discordapp.com/api/guilds/230191591640268800/widget.png)](https://discord.gg/8uHZykr)
+[![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.
 
-# Features
+## Torch.Server
+
+### Features
 * WPF-based user interface
 * Chat: interact with the game chat and run commands without having to join the game.
 * Entity manager: realtime modification of ingame entities such as stopping grids and changing block settings without having to join the game
 * Organized, easy to use configuration editor
 * Extensible using the Torch plugin system
 
+### 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.
+
 # 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.
 
-# Installation Guide
-
-### Automatic (recommended)
-* Unzip Torch to its own folder, run Torch.Server.exe and enter 'y' in the prompt for automatic updates. Torch will automatically download the Space Engineers files and generate all of the configs/folders necessary.
-
-### Manual (for hosting companies or the paranoid)
-* Install the Space Engineers DS and then unzip the Torch files into the server's DedicatedServer64 directory. It will automatically detect the manual install and disable automatic updates.
-
 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.
 
-# Official Plugins
+If you have a more enjoyable server experience because of Torch, please consider supporting us on Patreon.
-Install plugins by unzipping them into the 'Plugins' folder which should be in the same location as the Torch files. If it doesn't exist you can simply create it.
+[![Patreon](http://i.imgur.com/VzzIMgn.png)](https://www.patreon.com/bePatron?u=847269)!
-* [Essentials](https://github.com/TorchAPI/Essentials): Adds a slew of chat commands and other tools to help manage your server.
-* [Concealment](https://github.com/TorchAPI/Concealment): Adds game logic and physics optimizations that significantly improve sim speed.
-
-If you have a more enjoyable server experience because of Torch, please consider supporting us on [Patreon](https://www.patreon.com/bePatron?u=847269)!

Setup (run before opening solution).bat

@@ -3,7 +3,7 @@
 @echo off
 set /p path="Please enter the folder location of your SpaceEngineersDedicated.exe: "
 cd %~dp0
-mklink /D GameBinaries %path%
+mklink /J GameBinaries "%path%"
 if errorlevel 1 goto Error
 echo Done! You can now open the Torch solution without issue.
 goto End

Torch.API/Event/EventHandlerAttribute.cs

@@ -0,0 +1,28 @@
+using System;
+
+namespace Torch.API.Event
+{
+    /// <summary>
+    /// Attribute indicating that a method should be invoked when the event occurs.
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Method)]
+    public class EventHandlerAttribute : Attribute
+    {
+        /// <summary>
+        /// Events are executed from low priority to high priority.
+        /// </summary>
+        /// <remarks>
+        /// While this may seem unintuitive this gives the high priority events the final say on changing/canceling events.
+        /// </remarks>
+        public int Priority { get; set; } = 0;
+
+        /// <summary>
+        /// Specifies if this handler should ignore a consumed event.
+        /// </summary>
+        /// <remarks>
+        /// If <see cref="SkipCancelled"/> is <em>true</em> and the event is cancelled by a lower priority handler this handler won't be invoked.
+        /// </remarks>
+        /// <seealso cref="IEvent.Cancelled"/>
+        public bool SkipCancelled { get; set; } = false;
+    }
+}

Torch.API/Event/IEvent.cs

@@ -0,0 +1,11 @@
+namespace Torch.API.Event
+{
+    public interface IEvent
+    {
+        /// <summary>
+        /// An event that has been cancelled will no be processed in the default manner.
+        /// </summary>
+        /// <seealso cref="EventHandlerAttribute.SkipCancelled"/>
+        bool Cancelled { get; }
+    }
+}

Torch.API/Event/IEventHandler.cs

@@ -0,0 +1,9 @@
+namespace Torch.API.Event
+{
+    /// <summary>
+    /// Interface used to tag an event handler.  This does <b>not</b> register it with the event manager.
+    /// </summary>
+    public interface IEventHandler
+    {
+    }
+}

Torch.API/Event/IEventManager.cs

@@ -0,0 +1,28 @@
+using System.Runtime.CompilerServices;
+using Torch.API.Managers;
+
+namespace Torch.API.Event
+{
+    /// <summary>
+    /// Manager class responsible for registration of event handlers.
+    /// </summary>
+    public interface IEventManager : IManager
+    {
+        /// <summary>
+        /// Registers all event handler methods contained in the given instance 
+        /// </summary>
+        /// <param name="handler">Instance to register</param>
+        /// <returns><b>true</b> if added, <b>false</b> otherwise</returns>
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        bool RegisterHandler(IEventHandler handler);
+
+
+        /// <summary>
+        /// Unregisters all event handler methods contained in the given instance 
+        /// </summary>
+        /// <param name="handler">Instance to unregister</param>
+        /// <returns><b>true</b> if removed, <b>false</b> otherwise</returns>
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        bool UnregisterHandler(IEventHandler handler);
+    }
+}

Torch.API/IChatMessage.cs

@@ -1,31 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace Torch.API
-{
-    public interface IChatMessage
-    {
-        /// <summary>
-        /// The time the message was created.
-        /// </summary>
-        DateTime Timestamp { get; }
-
-        /// <summary>
-        /// The SteamID of the message author.
-        /// </summary>
-        ulong SteamId { get; }
-
-        /// <summary>
-        /// The name of the message author.
-        /// </summary>
-        string Name { get; }
-
-        /// <summary>
-        /// The content of the message.
-        /// </summary>
-        string Message { get; }
-    }
-}

Torch.API/ITorchBase.cs

@@ -1,9 +1,11 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Runtime.CompilerServices;
 using System.Text;
 using System.Threading.Tasks;
 using Torch.API.Managers;
+using Torch.API.Session;
 using VRage.Game.ModAPI;
 
 namespace Torch.API
@@ -16,86 +18,121 @@ namespace Torch.API
         /// <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>
+        ITorchSession CurrentSession { get; }
+
         /// <summary>
         /// Configuration for the current instance.
         /// </summary>
         ITorchConfig Config { get; }
 
-        /// <inheritdoc cref="IMultiplayerManager"/>
-        IMultiplayerManager Multiplayer { get; }
-
         /// <inheritdoc cref="IPluginManager"/>
+        [Obsolete]
         IPluginManager Plugins { get; }
 
+        /// <inheritdoc cref="IDependencyManager"/>
+        IDependencyManager Managers { get; }
+
+        [Obsolete("Prefer using Managers.GetManager for global managers")]
+        T GetManager<T>() where T : class, IManager;
+
+        [Obsolete("Prefer using Managers.AddManager for global managers")]
+        bool AddManager<T>(T manager) where T : class, IManager;
+
         /// <summary>
         /// The binary version of the current instance.
         /// </summary>
-        Version TorchVersion { get; }
+        InformationalVersion TorchVersion { get; }
 
         /// <summary>
         /// Invoke an action on the game thread.
         /// </summary>
-        void Invoke(Action action);
+        void Invoke(Action action, [CallerMemberName] string caller = "");
 
         /// <summary>
         /// Invoke an action on the game thread and block until it has completed.
-        /// If this is called on the game thread the action will execute immediately.
         /// </summary>
-        void InvokeBlocking(Action action);
+        /// <param name="action">Action to execute</param>
+        /// <param name="caller">Caller of the invoke function</param>
+        /// <param name="timeoutMs">Timeout before <see cref="TimeoutException"/> is thrown, or -1 to never timeout</param>
+        /// <exception cref="TimeoutException">If the action times out</exception>
+        void InvokeBlocking(Action action, int timeoutMs = -1, [CallerMemberName] string caller = "");
 
         /// <summary>
         /// Invoke an action on the game thread asynchronously.
         /// </summary>
-        Task InvokeAsync(Action action);
+        Task InvokeAsync(Action action, [CallerMemberName] string caller = "");
 
         /// <summary>
-        /// Start the Torch instance.
+        /// Invoke a function on the game thread asynchronously.
+        /// </summary>
+        Task<T> InvokeAsync<T>(Func<T> func, [CallerMemberName] string caller = "");
+
+        /// <summary>
+        /// Signals the torch instance to start, then blocks until it's started.
         /// </summary>
         void Start();
 
         /// <summary>
-        /// Stop the Torch instance.
+        /// Signals the torch instance to stop, then blocks until it's stopped.
         /// </summary>
         void Stop();
 
         /// <summary>
-        /// Restart the Torch instance.
+        /// Restart the Torch instance, blocking until the restart has been performed.
         /// </summary>
         void Restart();
 
         /// <summary>
         /// Initializes a save of the game.
         /// </summary>
-        /// <param name="callerId">Id of the player who initiated the save.</param>
+        /// <param name="timeoutMs">timeout before the save is treated as failed, or -1 for no timeout</param>
-        Task Save(long callerId);
+        /// <param name="exclusive">Only start saving if we aren't already saving</param>
+        /// <returns>Future result of the save, or null if one is in progress and in exclusive mode</returns>
+        Task<GameSaveResult> Save(int timeoutMs = -1, bool exclusive = false);
 
         /// <summary>
-        /// Initialize the Torch instance.
+        /// Initialize the Torch instance.  Before this <see cref="Start"/> is invalid.
         /// </summary>
         void Init();
 
         /// <summary>
-        /// Get an <see cref="IManager"/> that is part of the Torch instance.
+        /// Disposes the Torch instance.  After this <see cref="Start"/> is invalid.
         /// </summary>
-        /// <typeparam name="T">Manager type</typeparam>
+        void Destroy();
-        T GetManager<T>() where T : class, IManager;
+
+        /// <summary>
+        /// The current state of the game this instance of torch is controlling.
+        /// </summary>
+        TorchGameState GameState { get; }
+
+        /// <summary>
+        /// Event raised when <see cref="GameState"/> changes.
+        /// </summary>
+        event TorchGameStateChangedDel GameStateChanged;
     }
 
     /// <summary>
@@ -103,10 +140,20 @@ namespace Torch.API
     /// </summary>
     public interface ITorchServer : ITorchBase
     {
+        /// <summary>
+        /// The current <see cref="ServerState"/>
+        /// </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;
     }
 
     /// <summary>

Torch.API/InformationalVersion.cs

@@ -0,0 +1,52 @@
+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/DependencyManagerExtensions.cs

@@ -0,0 +1,30 @@
+using System;
+
+namespace Torch.API.Managers
+{
+    public static class DependencyManagerExtensions
+    {
+        /// <summary>
+        /// Removes a single manager from this dependency manager.
+        /// </summary>
+        /// <param name="managerType">The dependency type to remove</param>
+        /// <returns>The manager that was removed, or null if one wasn't removed</returns>
+        /// <exception cref="InvalidOperationException">When removing managers from an initialized dependency manager</exception>
+        public static IManager RemoveManager(this IDependencyManager depManager, Type managerType)
+        {
+            IManager mgr = depManager.GetManager(managerType);
+            return depManager.RemoveManager(mgr) ? mgr : null;
+        }
+        /// <summary>
+        /// Removes a single manager from this dependency manager.
+        /// </summary>
+        /// <typeparam name="T">The dependency type to remove</typeparam>
+        /// <returns>The manager that was removed, or null if one wasn't removed</returns>
+        /// <exception cref="InvalidOperationException">When removing managers from an initialized dependency manager</exception>
+        public static IManager RemoveManager<T>(this IDependencyManager depManager)
+        {
+            return depManager.RemoveManager(typeof(T));
+        }
+
+    }
+}

Torch.API/Managers/DependencyProviderExtensions.cs

@@ -0,0 +1,15 @@
+namespace Torch.API.Managers
+{
+    public static class DependencyProviderExtensions
+    {
+        /// <summary>
+        /// Gets the manager that provides the given type.  If there is no such manager, returns null.
+        /// </summary>
+        /// <typeparam name="T">Type of manager</typeparam>
+        /// <returns>manager, or null if none exists</returns>
+        public static T GetManager<T>(this IDependencyProvider depProvider) where T : class, IManager
+        {
+            return (T)depProvider.GetManager(typeof(T));
+        }
+    }
+}

Torch.API/Managers/IChatManagerClient.cs

@@ -0,0 +1,128 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Sandbox.Engine.Multiplayer;
+using Sandbox.Game.Multiplayer;
+using VRage.Game;
+using VRage.Network;
+using VRage.Replication;
+
+namespace Torch.API.Managers
+{
+    /// <summary>
+    /// Represents a scripted or user chat message.
+    /// </summary>
+    public struct TorchChatMessage
+    {
+        /// <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)
+        {
+            Timestamp = DateTime.Now;
+            AuthorSteamId = null;
+            Author = author;
+            Message = message;
+            Font = font;
+        }
+
+        /// <summary>
+        /// Creates a new torch chat message with the given author and message.
+        /// </summary>
+        /// <param name="author">Author's name</param>
+        /// <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)
+        {
+            Timestamp = DateTime.Now;
+            AuthorSteamId = authorSteamId;
+            Author = author;
+            Message = message;
+            Font = font;
+        }
+
+        /// <summary>
+        /// Creates a new torch chat message with the given author and message.
+        /// </summary>
+        /// <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)
+        {
+            Timestamp = DateTime.Now;
+            AuthorSteamId = authorSteamId;
+            Author = MyMultiplayer.Static?.GetMemberName(authorSteamId) ?? "Player";
+            Message = message;
+            Font = font;
+        }
+
+        /// <summary>
+        /// This message's timestamp.
+        /// </summary>
+        public readonly DateTime Timestamp;
+        /// <summary>
+        /// The author's steam ID, if available.  Else, null.
+        /// </summary>
+        public readonly ulong? AuthorSteamId;
+        /// <summary>
+        /// The author's name, if available.  Else, null.
+        /// </summary>
+        public readonly string Author;
+        /// <summary>
+        /// The message contents.
+        /// </summary>
+        public readonly string Message;
+        /// <summary>
+        /// The font, or null if default.
+        /// </summary>
+        public readonly string Font;
+    }
+
+    /// <summary>
+    /// Callback used to indicate that a messaage has been recieved.
+    /// </summary>
+    /// <param name="msg"></param>
+    /// <param name="consumed">If true, this event has been consumed and should be ignored</param>
+    public delegate void MessageRecievedDel(TorchChatMessage msg, ref bool consumed);
+
+    /// <summary>
+    /// Callback used to indicate the user is attempting to send a message locally.
+    /// </summary>
+    /// <param name="msg">Message the user is attempting to send</param>
+    /// <param name="consumed">If true, this event has been consumed and should be ignored</param>
+    public delegate void MessageSendingDel(string msg, ref bool consumed);
+
+    public interface IChatManagerClient : IManager
+    {
+        /// <summary>
+        /// Event that is raised when a message addressed to us is recieved.  <see cref="MessageRecievedDel"/>
+        /// </summary>
+        event MessageRecievedDel MessageRecieved;
+
+        /// <summary>
+        /// Event that is raised when we are attempting to send a message.  <see cref="MessageSendingDel"/>
+        /// </summary>
+        event MessageSendingDel MessageSending;
+
+        /// <summary>
+        /// Triggers the <see cref="MessageSending"/> event,
+        /// typically raised by the user entering text into the chat window.
+        /// </summary>
+        /// <param name="message">The message to send</param>
+        void SendMessageAsSelf(string message);
+
+        /// <summary>
+        /// Displays a message on the UI given an author name and a message.
+        /// </summary>
+        /// <param name="author">Author name</param>
+        /// <param name="message">Message content</param>
+        /// <param name="font">font to use</param>
+        void DisplayMessageOnSelf(string author, string message, string font = "Blue" );
+    }
+}

Torch.API/Managers/IChatManagerServer.cs

@@ -0,0 +1,45 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using VRage.Network;
+
+namespace Torch.API.Managers
+{
+
+    /// <summary>
+    /// Callback used to indicate the server has recieved a message to process and forward on to others.
+    /// </summary>
+    /// <param name="authorId">Steam ID of the user sending a message</param>
+    /// <param name="msg">Message the user is attempting to send</param>
+    /// <param name="consumed">If true, this event has been consumed and should be ignored</param>
+    public delegate void MessageProcessingDel(TorchChatMessage msg, ref bool consumed);
+
+    public interface IChatManagerServer : IChatManagerClient
+    {
+        /// <summary>
+        /// Event triggered when the server has recieved a message and should process it.  <see cref="MessageProcessingDel"/>
+        /// </summary>
+        event MessageProcessingDel MessageProcessing;
+
+
+        /// <summary>
+        /// Sends a message with the given author and message to the given player, or all players by default.
+        /// </summary>
+        /// <param name="authorId">Author's steam ID</param>
+        /// <param name="message">The message to send</param>
+        /// <param name="targetSteamId">Player to send the message to, or everyone by default</param>
+        void SendMessageAsOther(ulong authorId, string message, 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="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);
+    }
+}

Torch.API/Managers/IDependencyManager.cs

@@ -0,0 +1,62 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Torch.API.Managers
+{
+    /// <summary>
+    /// Manages a set of <see cref="IManager"/> and the dependencies between them.
+    /// </summary>
+    public interface IDependencyManager : IDependencyProvider
+    {
+        /// <summary>
+        /// Registers the given manager into the dependency system.
+        /// </summary>
+        /// <remarks>
+        /// This method only returns false when there is already a manager registered with a type derived from this given manager,
+        /// or when the given manager is derived from an already existing manager.
+        /// </remarks>
+        /// <param name="manager">Manager to register</param>
+        /// <exception cref="InvalidOperationException">When adding a new manager to an initialized dependency manager</exception>
+        /// <returns>true if added, false if not</returns>
+        bool AddManager(IManager manager);
+
+        /// <summary>
+        /// Clears all managers registered with this dependency manager
+        /// </summary>
+        /// <exception cref="InvalidOperationException">When removing managers from an initialized dependency manager</exception>
+        void ClearManagers();
+
+        /// <summary>
+        /// Removes a single manager from this dependency manager.
+        /// </summary>
+        /// <param name="manager">The manager to remove</param>
+        /// <returns>true if successful, false if the manager wasn't found</returns>
+        /// <exception cref="InvalidOperationException">When removing managers from an initialized dependency manager</exception>
+        bool RemoveManager(IManager manager);
+
+        /// <summary>
+        /// Sorts the dependency manager, then attaches all its registered managers in <see cref="AttachOrder" />
+        /// </summary>
+        void Attach();
+
+        /// <summary>
+        /// Detaches all registered managers in <see cref="DetachOrder"/>
+        /// </summary>
+        void Detach();
+
+        /// <summary>
+        /// The order that managers should be attached in.  (Dependencies, then dependents)
+        /// </summary>
+        /// <exception cref="InvalidOperationException">When trying to determine load order before this dependency manager is initialized</exception>
+        IEnumerable<IManager> AttachOrder { get; }
+
+        /// <summary>
+        /// The order that managers should be detached in.  (Dependents, then dependencies)
+        /// </summary>
+        /// <exception cref="InvalidOperationException">When trying to determine unload order before this dependency manager is initialized</exception>
+        IEnumerable<IManager> DetachOrder { get; }
+    }
+}

Torch.API/Managers/IDependencyProvider.cs

@@ -0,0 +1,18 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Torch.API.Managers
+{
+    public interface IDependencyProvider
+    {
+        /// <summary>
+        /// Gets the manager that provides the given type.  If there is no such manager, returns null.
+        /// </summary>
+        /// <param name="type">Type of manager</param>
+        /// <returns>manager, or null if none exists</returns>
+        IManager GetManager(Type type);
+    }
+}

Torch.API/Managers/IManager.cs

@@ -12,8 +12,13 @@ namespace Torch.API.Managers
     public interface IManager
     {
         /// <summary>
-        /// Initializes the manager. Called after Torch is initialized.
+        /// Attaches the manager to the session. Called once this manager's dependencies have been attached.
         /// </summary>
-        void Init();
+        void Attach();
+
+        /// <summary>
+        /// Detaches the manager from the session.  Called before this manager's dependencies are detached.
+        /// </summary>
+        void Detach();
     }
 }

Torch.API/Managers/IMultiplayerManager.cs

@@ -1,61 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Collections.ObjectModel;
-using VRage.Game;
-using VRage.Game.ModAPI;
-
-namespace Torch.API.Managers
-{
-    /// <summary>
-    /// Delegate for received messages.
-    /// </summary>
-    /// <param name="message">Message data.</param>
-    /// <param name="sendToOthers">Flag to broadcast message to other players.</param>
-    public delegate void MessageReceivedDel(IChatMessage message, ref bool sendToOthers);
-
-    /// <summary>
-    /// API for multiplayer related functions.
-    /// </summary>
-    public interface IMultiplayerManager : IManager
-    {
-        /// <summary>
-        /// Fired when a player joins.
-        /// </summary>
-        event Action<IPlayer> PlayerJoined;
-
-        /// <summary>
-        /// Fired when a player disconnects.
-        /// </summary>
-        event Action<IPlayer> PlayerLeft;
-
-        /// <summary>
-        /// Fired when a chat message is received.
-        /// </summary>
-        event MessageReceivedDel MessageReceived;
-
-        /// <summary>
-        /// Send a chat message to all or one specific player.
-        /// </summary>
-        void SendMessage(string message, string author = "Server", long playerId = 0, string font = MyFontEnum.Blue);
-
-        /// <summary>
-        /// Kicks the player from the game.
-        /// </summary>
-        void KickPlayer(ulong steamId);
-
-        /// <summary>
-        /// Bans or unbans a player from the game.
-        /// </summary>
-        void BanPlayer(ulong steamId, bool banned = true);
-
-        /// <summary>
-        /// Gets a player by their Steam64 ID or returns null if the player isn't found.
-        /// </summary>
-        IMyPlayer GetPlayerBySteamId(ulong id);
-
-        /// <summary>
-        /// Gets a player by their display name or returns null if the player isn't found.
-        /// </summary>
-        IMyPlayer GetPlayerByName(string name);
-    }
-}

Torch.API/Managers/IMultiplayerManagerBase.cs

@@ -0,0 +1,41 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using VRage.Game;
+using VRage.Game.ModAPI;
+
+namespace Torch.API.Managers
+{
+    /// <summary>
+    /// API for multiplayer related functions common to servers and clients.
+    /// </summary>
+    public interface IMultiplayerManagerBase : IManager
+    {
+        /// <summary>
+        /// Fired when a player joins.
+        /// </summary>
+        event Action<IPlayer> PlayerJoined;
+
+        /// <summary>
+        /// Fired when a player disconnects.
+        /// </summary>
+        event Action<IPlayer> PlayerLeft;
+        
+        /// <summary>
+        /// Gets a player by their Steam64 ID or returns null if the player isn't found.
+        /// </summary>
+        IMyPlayer GetPlayerBySteamId(ulong id);
+
+        /// <summary>
+        /// Gets a player by their display name or returns null if the player isn't found.
+        /// </summary>
+        IMyPlayer GetPlayerByName(string name);
+
+        /// <summary>
+        /// Gets the steam username of a member's steam ID
+        /// </summary>
+        /// <param name="steamId">steam ID</param>
+        /// <returns>steam username</returns>
+        string GetSteamUsername(ulong steamId);
+    }
+}

Torch.API/Managers/IMultiplayerManagerClient.cs

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

Torch.API/Managers/IMultiplayerManagerServer.cs

@@ -0,0 +1,46 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Torch.API.Managers
+{
+    /// <summary>
+    /// API for multiplayer functions that exist on servers and lobbies
+    /// </summary>
+    public interface IMultiplayerManagerServer : IMultiplayerManagerBase
+    {
+        /// <summary>
+        /// Kicks the player from the game.
+        /// </summary>
+        void KickPlayer(ulong steamId);
+
+        /// <summary>
+        /// Bans or unbans a player from the game.
+        /// </summary>
+        void BanPlayer(ulong steamId, bool banned = true);
+
+        /// <summary>
+        /// List of the banned SteamID's
+        /// </summary>        
+        IReadOnlyList<ulong> BannedPlayers { get; }
+
+        /// <summary>
+        /// Checks if the player with the given SteamID is banned.
+        /// </summary>
+        /// <param name="steamId">The SteamID of the player.</param>
+        /// <returns>True if the player is banned; otherwise false.</returns>
+        bool IsBanned(ulong steamId);
+
+        /// <summary>
+        /// Raised when a player is kicked. Passes with SteamID of kicked player.
+        /// </summary>
+        event Action<ulong> PlayerKicked;
+
+        /// <summary>
+        /// 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;
+    }
+}

Torch.API/Managers/INetworkManager.cs

@@ -18,6 +18,12 @@ namespace Torch.API.Managers
         /// Register a network handler.
         /// </summary>
         void RegisterNetworkHandler(INetworkHandler handler);
+
+        /// <summary>
+        /// Unregister a network handler.
+        /// </summary>
+        /// <returns>true if the handler was unregistered, false if it wasn't registered to begin with</returns>
+        bool UnregisterNetworkHandler(INetworkHandler handler);
     }
 
     /// <summary>
@@ -33,6 +39,7 @@ namespace Torch.API.Managers
         /// <summary>
         /// Processes a network message.
         /// </summary>
+        /// <returns>true if the message should be discarded</returns>
         bool Handle(ulong remoteUserId, CallSite site, BitStream stream, object obj, MyPacket packet);
     }
 }

Torch.API/Managers/IPluginManager.cs

@@ -14,23 +14,18 @@ namespace Torch.API.Managers
         /// <summary>
         /// Fired when plugins are loaded.
         /// </summary>
-        event Action<IList<ITorchPlugin>> PluginsLoaded;
+        event Action<IReadOnlyCollection<ITorchPlugin>> PluginsLoaded;
 
         /// <summary>
         /// Collection of loaded plugins.
         /// </summary>
-        IList<ITorchPlugin> Plugins { get; }
+        IReadOnlyDictionary<Guid, ITorchPlugin> Plugins { get; }
 
         /// <summary>
         /// Updates all loaded plugins.
         /// </summary>
         void UpdatePlugins();
 
-        /// <summary>
-        /// Disposes all loaded plugins.
-        /// </summary>
-        void DisposePlugins();
-
         /// <summary>
         /// Load plugins.
         /// </summary>

Torch.API/Plugins/ITorchPlugin.cs

@@ -17,7 +17,7 @@ namespace Torch.API.Plugins
         /// <summary>
         /// The version of the plugin.
         /// </summary>
-        Version Version { get; }
+        string Version { get; }
 
         /// <summary>
         /// The name of the plugin.

Torch.API/Plugins/PluginAttribute.cs

@@ -1,22 +1,56 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Reflection;
 using System.Text;
 using System.Threading.Tasks;
 
 namespace Torch.API.Plugins
 {
+    /// <summary>
+    /// Indicates that the given type should be loaded by the plugin manager as a plugin.
+    /// </summary>
+    [Obsolete("All plugin meta-information is now defined in the manifest.xml.")]
+    [AttributeUsage(AttributeTargets.Class)]
     public class PluginAttribute : Attribute
     {
+        /// <summary>
+        /// The display name of the plugin
+        /// </summary>
         public string Name { get; }
+        /// <summary>
+        /// The version of the plugin
+        /// </summary>
         public Version Version { get; }
+        /// <summary>
+        /// The GUID of the plugin
+        /// </summary>
         public Guid Guid { get; }
 
+        /// <summary>
+        /// Creates a new plugin attribute with the given attributes
+        /// </summary>
+        /// <param name="name"></param>
+        /// <param name="version"></param>
+        /// <param name="guid"></param>
         public PluginAttribute(string name, string version, string guid)
         {
             Name = name;
             Version = Version.Parse(version);
             Guid = Guid.Parse(guid);
         }
+
+        /// <summary>
+        /// Creates a new plugin attribute with the given attributes.  Version is computed as the version of the assembly containing the given type.
+        /// </summary>
+        /// <param name="name"></param>
+        /// <param name="versionSupplier">Version is this type's assembly's version</param>
+        /// <param name="guid"></param>
+        public PluginAttribute(string name, Type versionSupplier, string guid)
+        {
+            Name = name;
+            Version = versionSupplier.Assembly.GetName().Version;
+            Guid = Guid.Parse(guid);
+        }
     }
 }

Torch.API/Properties/AssemblyInfo.cs

@@ -1,36 +1,17 @@
 using System.Reflection;
-using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 
-// General Information about an assembly is controlled through the following 
+[assembly: AssemblyTitle("Torch API")]
-// set of attributes. Change these attribute values to modify the information
-// associated with an assembly.
-[assembly: AssemblyTitle("TorchAPI")]
 [assembly: AssemblyDescription("")]
-[assembly: AssemblyConfiguration("")]
 [assembly: AssemblyCompany("")]
-[assembly: AssemblyProduct("TorchAPI")]
+[assembly: AssemblyProduct("Torch")]
-[assembly: AssemblyCopyright("Copyright ©  2016")]
+[assembly: AssemblyCopyright("Copyright © Torch API 2017")]
 [assembly: AssemblyTrademark("")]
 [assembly: AssemblyCulture("")]
-
-// Setting ComVisible to false makes the types in this assembly not visible 
-// to COM components.  If you need to access a type in this assembly from 
-// COM, set the ComVisible attribute to true on that type.
 [assembly: ComVisible(false)]
 
-// The following GUID is for the ID of the typelib if this project is exposed to COM
+#if DEBUG
-[assembly: Guid("fba5d932-6254-4a1e-baf4-e229fa94e3c2")]
+[assembly: AssemblyConfiguration("Debug")]
-
+#else
-// Version information for an assembly consists of the following four values:
+[assembly: AssemblyConfiguration("Release")]
-//
+#endif
-//      Major Version
-//      Minor Version 
-//      Build Number
-//      Revision
-//
-// You can specify all the values or you can default the Build and Revision Numbers 
-// by using the '*' as shown below:
-// [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("1.0.0.0")]
-[assembly: AssemblyFileVersion("1.0.0.0")]

Torch.API/Session/GameSaveResult.cs

@@ -0,0 +1,44 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Torch.API.Session
+{
+    /// <summary>
+    /// The result of a save operation
+    /// </summary>
+    public enum GameSaveResult
+    {
+        /// <summary>
+        /// Successfully saved
+        /// </summary>
+        Success = 0,
+
+        /// <summary>
+        /// The game wasn't ready to be saved
+        /// </summary>
+        GameNotReady = -1,
+
+        /// <summary>
+        /// Failed to take the snapshot of the current world state
+        /// </summary>
+        FailedToTakeSnapshot = -2,
+
+        /// <summary>
+        /// Failed to save the snapshot to disk
+        /// </summary>
+        FailedToSaveToDisk = -3,
+
+        /// <summary>
+        /// An unknown error occurred
+        /// </summary>
+        UnknownError = -4,
+
+        /// <summary>
+        /// The save operation timed out
+        /// </summary>
+        TimedOut = -5
+    }
+}

Torch.API/Session/ITorchSession.cs

@@ -0,0 +1,39 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Sandbox.Game.World;
+using Torch.API.Managers;
+
+namespace Torch.API.Session
+{
+    /// <summary>
+    /// Represents the Torch code working with a single game session
+    /// </summary>
+    public interface ITorchSession
+    {
+        /// <summary>
+        /// The Torch instance this session is bound to
+        /// </summary>
+        ITorchBase Torch { get; }
+
+        /// <summary>
+        /// The Space Engineers game session this session is bound to.
+        /// </summary>
+        MySession KeenSession { get; }
+
+        /// <inheritdoc cref="IDependencyManager"/>
+        IDependencyManager Managers { get; }
+
+        /// <summary>
+        /// The current state of the session
+        /// </summary>
+        TorchSessionState State { get; }
+
+        /// <summary>
+        /// Event raised when the <see cref="State"/> changes.
+        /// </summary>
+        event TorchSessionStateChangedDel StateChanged;
+    }
+}

Torch.API/Session/ITorchSessionManager.cs

@@ -0,0 +1,51 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Torch.API.Managers;
+
+namespace Torch.API.Session
+{
+    /// <summary>
+    /// Creates a manager for the given session if applicable.
+    /// </summary>
+    /// <remarks>
+    /// This is for creating managers that will live inside the session, not the manager that controls sesssions.
+    /// </remarks>
+    /// <param name="session">The session to construct a bound manager for</param>
+    /// <returns>The manager that will live in the session, or null if none.</returns>
+    public delegate IManager SessionManagerFactoryDel(ITorchSession session);
+
+    /// <summary>
+    /// Manages the creation and destruction of <see cref="ITorchSession"/> instances for each <see cref="Sandbox.Game.World.MySession"/> created by Space Engineers.
+    /// </summary>
+    public interface ITorchSessionManager : IManager
+    {
+        /// <summary>
+        /// The currently running session
+        /// </summary>
+        ITorchSession CurrentSession { get; }
+
+        /// <summary>
+        /// Raised when any <see cref="ITorchSession"/> <see cref="ITorchSession.State"/> changes.
+        /// </summary>
+        event TorchSessionStateChangedDel SessionStateChanged;
+
+        /// <summary>
+        /// Adds the given factory as a supplier for session based managers
+        /// </summary>
+        /// <param name="factory">Session based manager supplier</param>
+        /// <returns>true if added, false if already present</returns>
+        /// <exception cref="ArgumentNullException">If the factory is null</exception>
+        bool AddFactory(SessionManagerFactoryDel factory);
+
+        /// <summary>
+        /// Remove the given factory from the suppliers for session based managers
+        /// </summary>
+        /// <param name="factory">Session based manager supplier</param>
+        /// <returns>true if removed, false if not present</returns>
+        /// <exception cref="ArgumentNullException">If the factory is null</exception>
+        bool RemoveFactory(SessionManagerFactoryDel factory);
+    }
+}

Torch.API/Session/TorchSessionState.cs

@@ -0,0 +1,38 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Torch.API.Session
+{
+    /// <summary>
+    /// Represents the state of a <see cref="ITorchSession"/>
+    /// </summary>
+    public enum TorchSessionState
+    {
+        /// <summary>
+        /// The session has been created, and is now loading.
+        /// </summary>
+        Loading,
+        /// <summary>
+        /// The session has loaded, and is now running.
+        /// </summary>
+        Loaded,
+        /// <summary>
+        /// The session was running, and is now unloading.
+        /// </summary>
+        Unloading,
+        /// <summary>
+        /// The session was unloading, and is now unloaded and stopped.
+        /// </summary>
+        Unloaded
+    }
+
+    /// <summary>
+    /// Callback raised when a session's state changes
+    /// </summary>
+    /// <param name="session">The session who had a state change</param>
+    /// <param name="newState">The session's new state</param>
+    public delegate void TorchSessionStateChangedDel(ITorchSession session, TorchSessionState newState);
+}

Torch.API/Torch.API.csproj

@@ -2,8 +2,6 @@
 <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>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
     <ProjectGuid>{FBA5D932-6254-4A1E-BAF4-E229FA94E3C2}</ProjectGuid>
     <OutputType>Library</OutputType>
     <AppDesignerFolder>Properties</AppDesignerFolder>
@@ -12,10 +10,12 @@
     <TargetFrameworkVersion>v4.6.1</TargetFrameworkVersion>
     <FileAlignment>512</FileAlignment>
     <TargetFrameworkProfile />
+    <NuGetPackageImportStamp>
+    </NuGetPackageImportStamp>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x64'">
     <DebugSymbols>true</DebugSymbols>
-    <OutputPath>bin\x64\Debug\</OutputPath>
+    <OutputPath>$(SolutionDir)\bin\x64\Debug\</OutputPath>
     <DefineConstants>DEBUG;TRACE</DefineConstants>
     <DebugType>full</DebugType>
     <PlatformTarget>x64</PlatformTarget>
@@ -23,14 +23,14 @@
     <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x64'">
-    <OutputPath>bin\x64\Release\</OutputPath>
+    <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>bin\x64\Release\Torch.API.xml</DocumentationFile>
+    <DocumentationFile>$(SolutionDir)\bin\x64\Release\Torch.API.xml</DocumentationFile>
   </PropertyGroup>
   <ItemGroup>
     <Reference Include="HavokWrapper, Version=1.0.6278.22649, Culture=neutral, processorArchitecture=AMD64">
@@ -38,8 +38,8 @@
       <HintPath>..\GameBinaries\HavokWrapper.dll</HintPath>
       <Private>False</Private>
     </Reference>
-    <Reference Include="NLog">
+    <Reference Include="NLog, Version=4.0.0.0, Culture=neutral, PublicKeyToken=5120e14c03d0593c, processorArchitecture=MSIL">
-      <HintPath>..\packages\NLog.4.4.1\lib\net45\NLog.dll</HintPath>
+      <HintPath>..\packages\NLog.4.4.12\lib\net45\NLog.dll</HintPath>
       <Private>True</Private>
     </Reference>
     <Reference Include="PresentationCore" />
@@ -74,11 +74,6 @@
       <HintPath>..\GameBinaries\SpaceEngineers.ObjectBuilders.XmlSerializers.dll</HintPath>
       <Private>False</Private>
     </Reference>
-    <Reference Include="SteamSDK, Version=0.0.0.0, Culture=neutral, processorArchitecture=AMD64">
-      <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\GameBinaries\SteamSDK.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
     <Reference Include="System" />
     <Reference Include="System.Configuration" />
     <Reference Include="System.Core" />
@@ -156,12 +151,27 @@
     </Reference>
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="..\Versioning\AssemblyVersion.cs">
+      <Link>Properties\AssemblyVersion.cs</Link>
+    </Compile>
     <Compile Include="ConnectionState.cs" />
-    <Compile Include="IChatMessage.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\IMultiplayerManager.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" />
@@ -173,16 +183,19 @@
     <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" />
-  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+  <Import Project="$(SolutionDir)\TransformOnBuild.targets" />
-       Other similar extension points exist, see Microsoft.Common.targets.
-  <Target Name="BeforeBuild">
-  </Target>
-  <Target Name="AfterBuild">
-  </Target>
-  -->
 </Project>

Torch.API/TorchGameState.cs

@@ -0,0 +1,47 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Sandbox;
+
+namespace Torch.API
+{
+    /// <summary>
+    /// Represents the state of a <see cref="MySandboxGame"/>
+    /// </summary>
+    public enum TorchGameState
+    {
+        /// <summary>
+        /// The game is currently being created.
+        /// </summary>
+        Creating,
+        /// <summary>
+        /// The game has been created and is ready to begin loading.
+        /// </summary>
+        Created,
+        /// <summary>
+        /// The game is currently loading.
+        /// </summary>
+        Loading,
+        /// <summary>
+        /// The game is fully loaded and ready to start sessions
+        /// </summary>
+        Loaded,
+        /// <summary>
+        /// The game is beginning the unload sequence
+        /// </summary>
+        Unloading,
+        /// <summary>
+        /// The game has been shutdown and is no longer active
+        /// </summary>
+        Unloaded
+    }
+    
+    /// <summary>
+    /// Callback raised when a game's state changes
+    /// </summary>
+    /// <param name="game">The game who had a state change</param>
+    /// <param name="newState">The game's new state</param>
+    public delegate void TorchGameStateChangedDel(MySandboxGame game, TorchGameState newState);
+}

Torch.API/packages.config

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

Torch.Client.Tests/Properties/AssemblyInfo.cs

@@ -1,12 +1,17 @@
 using System.Reflection;
 using System.Runtime.InteropServices;
 
-[assembly: AssemblyTitle("Torch Client")]
+[assembly: AssemblyTitle("Torch Client Tests")]
 [assembly: AssemblyDescription("")]
-[assembly: AssemblyConfiguration("")]
 [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

@@ -0,0 +1,97 @@
+<?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

@@ -0,0 +1,94 @@
+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

@@ -0,0 +1,12 @@
+<?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

@@ -0,0 +1,32 @@
+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

@@ -0,0 +1,58 @@
+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,17 +1,180 @@
 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
@@ -27,11 +190,5 @@ namespace Torch.Client
 
             client.Start();
         }
-
-        private static void CurrentDomain_UnhandledException(object sender, UnhandledExceptionEventArgs e)
-        {
-            var ex = (Exception)e.ExceptionObject;
-            MessageBox.Show(ex.StackTrace, ex.Message);
-        }
     }
 }

Torch.Client/Properties/AssemblyInfo.cs

@@ -1,4 +1,17 @@
 using System.Reflection;
+using System.Runtime.InteropServices;
 
-[assembly: AssemblyVersion("1.0.207.7")]
+[assembly: AssemblyTitle("Torch Client")]
-[assembly: AssemblyFileVersion("1.0.207.7")]
+[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/AssemblyInfo.tt

@@ -1,16 +0,0 @@
-<#@ template debug="false" hostspecific="false" language="C#" #>
-<#@ assembly name="System.Core" #>
-<#@ import namespace="System.Linq" #>
-<#@ import namespace="System.Text" #>
-<#@ import namespace="System.Collections.Generic" #>
-<#@ output extension=".cs" #>
-using System.Reflection;
-
-<#  var dt = DateTime.Now;
-    int major = 1;
-	int minor = 0;
-	int build = dt.DayOfYear;
-	int rev = (int)dt.TimeOfDay.TotalMinutes / 2;
-#>
-[assembly: AssemblyVersion("<#= major #>.<#= minor #>.<#= build #>.<#= rev #>")]
-[assembly: AssemblyFileVersion("<#= major #>.<#= minor #>.<#= build #>.<#= rev #>")]

Torch.Client/Torch.Client.csproj

@@ -2,8 +2,6 @@
 <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>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
     <ProjectGuid>{E36DF745-260B-4956-A2E8-09F08B2E7161}</ProjectGuid>
     <OutputType>WinExe</OutputType>
     <AppDesignerFolder>Properties</AppDesignerFolder>
@@ -15,10 +13,12 @@
     <WarningLevel>4</WarningLevel>
     <AutoGenerateBindingRedirects>true</AutoGenerateBindingRedirects>
     <TargetFrameworkProfile />
+    <NuGetPackageImportStamp>
+    </NuGetPackageImportStamp>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x64'">
     <DebugSymbols>true</DebugSymbols>
-    <OutputPath>bin\x64\Debug\</OutputPath>
+    <OutputPath>$(SolutionDir)\bin\x64\Debug\</OutputPath>
     <DefineConstants>DEBUG;TRACE</DefineConstants>
     <DebugType>full</DebugType>
     <PlatformTarget>x64</PlatformTarget>
@@ -27,7 +27,7 @@
     <Prefer32Bit>true</Prefer32Bit>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x64'">
-    <OutputPath>bin\x64\Release\</OutputPath>
+    <OutputPath>$(SolutionDir)\bin\x64\Release\</OutputPath>
     <DefineConstants>TRACE</DefineConstants>
     <Optimize>true</Optimize>
     <DebugType>pdbonly</DebugType>
@@ -35,19 +35,20 @@
     <ErrorReport>prompt</ErrorReport>
     <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
     <Prefer32Bit>true</Prefer32Bit>
-    <DocumentationFile>bin\x64\Release\Torch.Client.xml</DocumentationFile>
+    <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.1\lib\net45\NLog.dll</HintPath>
+      <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>
@@ -64,6 +65,7 @@
     </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" />
@@ -81,6 +83,10 @@
       <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>
@@ -103,20 +109,24 @@
       <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="Properties\AssemblyInfo.cs">
+    <Compile Include="..\Versioning\AssemblyVersion.cs">
-      <DependentUpon>AssemblyInfo.tt</DependentUpon>
+      <Link>Properties\AssemblyVersion.cs</Link>
-      <AutoGen>True</AutoGen>
-      <DesignTime>True</DesignTime>
     </Compile>
-    <Compile Include="Properties\AssemblyInfo1.cs" />
+    <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="TorchMainMenuScreen.cs" />
     <Compile Include="TorchSettingsScreen.cs" />
     <Compile Include="Program.cs" />
     <Compile Include="Properties\Resources.Designer.cs">
@@ -129,6 +139,9 @@
       <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>
@@ -144,35 +157,25 @@
     <ProjectReference Include="..\Torch.API\Torch.API.csproj">
       <Project>{fba5d932-6254-4a1e-baf4-e229fa94e3c2}</Project>
       <Name>Torch.API</Name>
-      <Private>True</Private>
+      <Private>False</Private>
     </ProjectReference>
     <ProjectReference Include="..\Torch\Torch.csproj">
       <Project>{7E01635C-3B67-472E-BCD6-C5539564F214}</Project>
       <Name>Torch</Name>
-      <Private>True</Private>
+      <Private>False</Private>
     </ProjectReference>
   </ItemGroup>
   <ItemGroup>
     <Resource Include="torchicon.ico" />
   </ItemGroup>
-  <ItemGroup>
-    <Content Include="Properties\AssemblyInfo.tt">
-      <Generator>TextTemplatingFileGenerator</Generator>
-      <LastGenOutput>AssemblyInfo.cs</LastGenOutput>
-    </Content>
-  </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>
+    <PostBuildEvent>copy "$(SolutionDir)NLog.config" "$(TargetDir)"
+    </PostBuildEvent>
   </PropertyGroup>
-  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
-       Other similar extension points exist, see Microsoft.Common.targets.
-  <Target Name="BeforeBuild">
-  </Target>
-  <Target Name="AfterBuild">
-  </Target>
-  -->
 </Project>

Torch.Client/TorchClient.cs

@@ -1,71 +1,56 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
-using System.Linq;
+using System.Reflection;
-using System.Text;
-using System.Threading.Tasks;
 using System.Windows;
 using Sandbox;
+using Sandbox.Engine.Multiplayer;
+using Sandbox.Engine.Networking;
 using Sandbox.Engine.Platform;
-using Sandbox.Engine.Utils;
 using Sandbox.Game;
-using Sandbox.ModAPI;
 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
     {
-        private MyCommonProgramStartup _startup;
+        protected override uint SteamAppId => 244850;
-        private IMyRender _renderer;
+        protected override string SteamAppName => "SpaceEngineers";
-        private const uint APP_ID = 244850;
+
-        private VRageGameServices _services;
+        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();
-
-            if (!File.Exists("steam_appid.txt"))
-            {
-                Directory.SetCurrentDirectory(Path.GetDirectoryName(typeof(VRage.FastResourceLock).Assembly.Location) + "\\..");
-            }
-
-            SpaceEngineersGame.SetupBasicGameInfo();
-            _startup = new MyCommonProgramStartup(RunArgs);
-            if (_startup.PerformReporting())
-                return;
-
-            _startup.PerformAutoconnect();
-            if (!_startup.CheckSingleInstance())
-                return;
-
-            var appDataPath = _startup.GetAppDataPath();
-            MyInitializer.InvokeBeforeRun(APP_ID, MyPerGameSettings.BasicGameInfo.ApplicationName, appDataPath);
-            MyInitializer.InitCheckSum();
-            if (!_startup.Check64Bit())
-                return;
-
-            _startup.DetectSharpDxLeaksBeforeRun();
-            using (var mySteamService = new SteamService(Game.IsDedicated, APP_ID))
-            {
-                _renderer = null;
-                SpaceEngineersGame.SetupPerGameSettings();
-
             OverrideMenus();
-
+            SetRenderWindowTitle($"Space Engineers v{GameVersion} with Torch v{TorchVersion}");
-                InitializeRender();
-
-                _services = new VRageGameServices(mySteamService);
-                if (!Game.IsDedicated)
-                    MyFileSystem.InitUserSpecific(mySteamService.UserId.ToString());
-            }
-
-            _startup.DetectSharpDxLeaksAfterRun();
-            MyInitializer.InvokeAfterRun();
         }
 
         private void OverrideMenus()
@@ -83,60 +68,25 @@ namespace Torch.Client
             MyPerGameSettings.GUI.MainMenu = typeof(TorchMainMenuScreen);
         }
 
-        public override void Start()
+        private void SetRenderWindowTitle(string title)
         {
-            using (var spaceEngineersGame = new SpaceEngineersGame(_services, RunArgs))
+            MyRenderThread renderThread = MySandboxGame.Static?.GameRenderComponent?.RenderThread;
-            {
+            if (renderThread == null)
-                Log.Info("Starting client");
+                return;
-                spaceEngineersGame.OnGameLoaded += SpaceEngineersGame_OnGameLoaded;
+            FieldInfo renderWindowField = typeof(MyRenderThread).GetField("m_renderWindow",
-                spaceEngineersGame.Run();
+                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; });
         }
 
-        private void SpaceEngineersGame_OnGameLoaded(object sender, EventArgs e)
+        public override void Restart()
         {
-        }
+            throw new NotImplementedException();
-
-        public override void Stop()
-        {
-            MySandboxGame.ExitThreadSafe();
-        }
-
-        private void InitializeRender()
-        {
-            try
-            {
-                if (Game.IsDedicated)
-                {
-                    _renderer = new MyNullRender();
-                }
-                else
-                {
-                    var graphicsRenderer = MySandboxGame.Config.GraphicsRenderer;
-                    if (graphicsRenderer == MySandboxGame.DirectX11RendererKey)
-                    {
-                        _renderer = new MyDX11Render();
-                        if (!_renderer.IsSupported)
-                        {
-                            MySandboxGame.Log.WriteLine("DirectX 11 renderer not supported. No renderer to revert back to.");
-                            _renderer = null;
-                        }
-                    }
-                    if (_renderer == null)
-                        throw new MyRenderException("The current version of the game requires a Dx11 card. \\n For more information please see : http://blog.marekrosa.org/2016/02/space-engineers-news-full-source-code_26.html", MyRenderExceptionEnum.GpuNotSupported);
-
-                    MySandboxGame.Config.GraphicsRenderer = graphicsRenderer;
-                }
-
-                MyRenderProxy.Initialize(_renderer);
-                MyRenderProxy.GetRenderProfiler().SetAutocommit(false);
-                MyRenderProxy.GetRenderProfiler().InitMemoryHack("MainEntryPoint");
-            }
-            catch (Exception ex)
-            {
-                MessageBox.Show(ex.Message, "Render Initialization Failed");
-                Environment.Exit(-1);
-            }
         }
     }
 }

Torch.Client/TorchClientConfig.cs

@@ -0,0 +1,32 @@
+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/TorchMainMenuScreen.cs

@@ -1,35 +0,0 @@
-#pragma warning disable 618
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using Sandbox.Graphics;
-using Sandbox.Graphics.GUI;
-using Sandbox.Gui;
-using SpaceEngineers.Game.GUI;
-using VRage.Game;
-using VRage.Utils;
-using VRageMath;
-
-namespace Torch.Client
-{
-    public class TorchMainMenuScreen : MyGuiScreenMainMenu
-    {
-        /// <inheritdoc />
-        public override void RecreateControls(bool constructor)
-        {
-            base.RecreateControls(constructor);
-
-            var buttonSize = MyGuiControlButton.GetVisualStyle(MyGuiControlButtonStyleEnum.Default).NormalTexture.MinSizeGui;
-            Vector2 leftButtonPositionOrigin = MyGuiManager.ComputeFullscreenGuiCoordinate(MyGuiDrawAlignEnum.HORISONTAL_LEFT_AND_VERTICAL_BOTTOM) + new Vector2(buttonSize.X / 2f, 0f);
-            var btn = MakeButton(leftButtonPositionOrigin - 9 * MyGuiConstants.MENU_BUTTONS_POSITION_DELTA, MyStringId.GetOrCompute("Torch"), TorchButtonClicked);
-            Controls.Add(btn);
-        }
-
-        private void TorchButtonClicked(MyGuiControlButton obj)
-        {
-            MyGuiSandbox.AddScreen(new TorchSettingsScreen());
-        }
-    }
-}

Torch.Client/UI/TorchMainMenuScreen.cs

@@ -0,0 +1,56 @@
+#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

@@ -0,0 +1,49 @@
+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

@@ -0,0 +1,25 @@
+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,4 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
 <packages>
-  <package id="NLog" version="4.4.1" targetFramework="net461" />
+  <package id="Mono.TextTransform" version="1.0.0" targetFramework="net461" />
+  <package id="NLog" version="4.4.12" targetFramework="net461" />
 </packages>

Torch.Mod/Messages/DialogMessage.cs

@@ -0,0 +1,72 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using ProtoBuf;
+using Sandbox.ModAPI;
+
+namespace Torch.Mod.Messages
+{
+    /// Dialogs are structured as follows
+    /// 
+    /// _____________________________________
+    /// |            Title                   |
+    /// --------------------------------------
+    /// |          Prefix Subtitle           |
+    /// --------------------------------------
+    /// |  ________________________________  |
+    /// |  |         Content               | |
+    /// |  --------------------------------- |
+    /// |            ____________            |
+    /// |           | ButtonText |           |
+    /// |           --------------           |
+    /// --------------------------------------
+    /// 
+    /// Button has a callback on click option, 
+    /// but can't serialize that, so ¯\_(ツ)_/¯
+    [ProtoContract]
+    public class DialogMessage : MessageBase
+    {
+        [ProtoMember(201)]
+        public string Title;
+        [ProtoMember(202)]
+        public string Subtitle;
+        [ProtoMember(203)]
+        public string Prefix;
+        [ProtoMember(204)]
+        public string Content;
+        [ProtoMember(205)]
+        public string ButtonText;
+
+        public DialogMessage()
+        { }
+
+        public DialogMessage(string title, string subtitle, string content)
+        {
+            Title = title;
+            Subtitle = subtitle;
+            Content = content;
+            Prefix = String.Empty;
+        }
+
+        public DialogMessage(string title = null, string prefix = null, string subtitle = null, string content = null, string buttonText = null)
+        {
+            Title = title;
+            Subtitle = subtitle;
+            Prefix = prefix ?? String.Empty;
+            Content = content;
+            ButtonText = buttonText;
+        }
+
+        public override void ProcessClient()
+        {
+            MyAPIGateway.Utilities.ShowMissionScreen(Title, Prefix, Subtitle, Content, null, ButtonText);
+        }
+
+        public override void ProcessServer()
+        {
+            throw new Exception();
+        }
+    }
+}

Torch.Mod/Messages/IncomingMessage.cs

@@ -0,0 +1,26 @@
+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/MessageBase.cs

@@ -0,0 +1,51 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using ProtoBuf;
+
+namespace Torch.Mod.Messages
+{
+    #region Includes
+    [ProtoInclude(1, typeof(DialogMessage))]
+    [ProtoInclude(2, typeof(NotificationMessage))]
+    [ProtoInclude(3, typeof(VoxelResetMessage))]
+    #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/Messages/NotificationMessage.cs

@@ -0,0 +1,39 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using ProtoBuf;
+using Sandbox.ModAPI;
+
+namespace Torch.Mod.Messages
+{
+    [ProtoContract]
+    public class NotificationMessage : MessageBase
+    {
+        [ProtoMember(201)]
+        public string Message;
+        [ProtoMember(202)]
+        public string Font;
+        [ProtoMember(203)]
+        public int DisappearTimeMs;
+
+        public NotificationMessage()
+        { }
+
+        public NotificationMessage(string message, int disappearTimeMs, string font)
+        {
+            Message = message;
+            DisappearTimeMs = disappearTimeMs;
+            Font = font;
+        }
+
+        public override void ProcessClient()
+        {
+            MyAPIGateway.Utilities.ShowNotification(Message, DisappearTimeMs, Font);
+        }
+
+        public override void ProcessServer()
+        {
+            throw new Exception();
+        }
+    }
+}

Torch.Mod/Messages/VoxelResetMessage.cs

@@ -0,0 +1,44 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using ProtoBuf;
+using Sandbox.ModAPI;
+using VRage.ModAPI;
+using VRage.Voxels;
+
+namespace Torch.Mod.Messages
+{
+    [ProtoContract]
+    public class VoxelResetMessage : MessageBase
+    {
+        [ProtoMember(201)]
+        public long[] EntityId;
+
+        public VoxelResetMessage()
+        { }
+
+        public VoxelResetMessage(long[] entityId)
+        {
+            EntityId = entityId;
+        }
+
+        public override void ProcessClient()
+        {
+            //MyAPIGateway.Parallel.ForEach(EntityId, id =>
+            foreach (var id in EntityId)
+            {
+                IMyEntity e;
+                if (!MyAPIGateway.Entities.TryGetEntityById(id, out e))
+                    continue;
+
+                var v = e as IMyVoxelBase;
+                v?.Storage.Reset(MyStorageDataTypeFlags.All);
+            }
+        }
+
+        public override void ProcessServer()
+        {
+            throw new Exception();
+        }
+    }
+}

Torch.Mod/ModCommunication.cs

@@ -0,0 +1,189 @@
+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.ModAPI;
+using VRage.Utils;
+using Task = ParallelTasks.Task;
+
+namespace Torch.Mod
+{
+    public static class ModCommunication
+    {
+        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 static void Register()
+        {
+            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.");
+        }
+
+        public static void Unregister()
+        {
+            MyLog.Default.WriteLineAndConsole("TORCH MOD: Unregistering mod communication.");
+            MyAPIGateway.Multiplayer?.UnregisterMessageHandler(NET_ID, MessageHandler);
+            _processing?.CompleteAdding();
+            _closing = true;
+            //_task.Wait();
+        }
+
+        private static void MessageHandler(byte[] bytes)
+        {
+            var m = _messagePool.Get();
+            m.CompressedData = bytes;
+            _processing.Add(m);
+        }
+
+        public static void DoProcessing()
+        {
+            while (!_closing)
+            {
+                try
+                {
+                    var m = _processing.Take();
+                    MyLog.Default.WriteLineAndConsole($"Processing message: {m.GetType().Name}");
+
+                    if (m is IncomingMessage)
+                    {
+                        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;
+        }
+        
+        public static void SendMessageTo(MessageBase message, ulong target)
+        {
+            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);
+        }
+
+        public static void SendMessageToClients(MessageBase message)
+        {
+            if (!MyAPIGateway.Multiplayer.IsServer)
+                throw new Exception("Only server can send targeted messages");
+
+            if (_closing)
+                return;
+
+            message.TargetType = MessageTarget.AllClients;
+            _processing.Add(message);
+        }
+
+        public static void SendMessageExcept(MessageBase message, params ulong[] ignoredUsers)
+        {
+            if (!MyAPIGateway.Multiplayer.IsServer)
+                throw new Exception("Only server can send targeted messages");
+
+            if (_closing)
+                return;
+
+            message.TargetType = MessageTarget.AllExcept;
+            message.Ignore = ignoredUsers;
+            _processing.Add(message);
+        }
+
+        public static void SendMessageToServer(MessageBase message)
+        {
+            if (_closing)
+                return;
+
+            message.TargetType = MessageTarget.Server;
+            _processing.Add(message);
+        }
+    }
+}

Torch.Mod/Torch.Mod.projitems

@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <MSBuildAllProjects>$(MSBuildAllProjects);$(MSBuildThisFileFullPath)</MSBuildAllProjects>
+    <HasSharedItems>true</HasSharedItems>
+    <SharedGUID>3ce4d2e9-b461-4f19-8233-f87e0dfddd74</SharedGUID>
+  </PropertyGroup>
+  <PropertyGroup Label="Configuration">
+    <Import_RootNamespace>Torch.Mod</Import_RootNamespace>
+  </PropertyGroup>
+  <ItemGroup>
+    <Compile Include="$(MSBuildThisFileDirectory)Messages\IncomingMessage.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

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>3ce4d2e9-b461-4f19-8233-f87e0dfddd74</ProjectGuid>
+    <MinimumVisualStudioVersion>14.0</MinimumVisualStudioVersion>
+  </PropertyGroup>
+  <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

@@ -0,0 +1,37 @@
+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.Tests/Properties/AssemblyInfo.cs

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,102 @@
+<?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>{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>
+    <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.Server.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.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>
+    </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" />
+  </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/TorchServerReflectionTest.cs

@@ -0,0 +1,83 @@
+using System;
+using System.Collections.Generic;
+using Torch.Tests;
+using Torch.Utils;
+using Xunit;
+
+namespace Torch.Server.Tests
+{
+#warning Disabled reflection tests because of seemingly random failures
+    public class TorchServerReflectionTest
+    {
+        static TorchServerReflectionTest()
+        {
+            TestUtils.Init();
+        }
+
+        private static ReflectionTestManager _manager;
+
+        private static ReflectionTestManager Manager()
+        {
+            if (_manager != null)
+                return _manager;
+
+            return _manager = new ReflectionTestManager().Init(typeof(TorchServer).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(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.Server.Tests/TorchServerSessionSettingsTest.cs

@@ -0,0 +1,34 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+using System.Threading.Tasks;
+using Torch.Server.ViewModels;
+using VRage.Game;
+using Xunit;
+using System.ComponentModel.DataAnnotations;
+
+namespace Torch.Server.Tests
+{
+    public class TorchServerSessionSettingsTest
+    {
+        public static PropertyInfo[] ViewModelProperties = typeof(SessionSettingsViewModel).GetProperties(BindingFlags.Public | BindingFlags.Instance);
+        public static IEnumerable<object[]> ModelFields = typeof(MyObjectBuilder_SessionSettings).GetFields(BindingFlags.Public | BindingFlags.Instance).Select(x => new object[] { x });
+
+        [Theory]
+        [MemberData(nameof(ModelFields))]
+        public void MissingPropertyTest(FieldInfo modelField)
+        {
+            // Ignore fields that aren't applicable to SE
+            if (modelField.GetCustomAttribute<GameRelationAttribute>()?.RelatedTo == Game.MedievalEngineers)
+                return;
+
+            if (string.IsNullOrEmpty(modelField.GetCustomAttribute<DisplayAttribute>()?.Name))
+                return;
+
+            var match = ViewModelProperties.FirstOrDefault(p => p.Name.Equals(modelField.Name, StringComparison.InvariantCultureIgnoreCase));
+            Assert.NotNull(match);
+        }
+    }
+}

Torch.Server.Tests/packages.config

@@ -0,0 +1,12 @@
+<?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

@@ -0,0 +1,65 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Torch.Commands;
+
+namespace Torch.Server.Commands
+{
+    [Category("whitelist")]
+    public class WhitelistCommands : CommandModule
+    {
+        private TorchConfig Config => (TorchConfig)Context.Torch.Config;
+
+        [Command("on", "Enables the whitelist.")]
+        public void On()
+        {
+            if (!Config.EnableWhitelist)
+            {
+                Config.EnableWhitelist = true;
+                Context.Respond("Whitelist enabled.");
+                Config.Save();
+            }
+            else
+                Context.Respond("Whitelist is already enabled.");
+        }
+
+        [Command("off", "Disables the whitelist")]
+        public void Off()
+        {
+            if (Config.EnableWhitelist)
+            {
+                Config.EnableWhitelist = false;
+                Context.Respond("Whitelist disabled.");
+                Config.Save();
+            }
+            else
+                Context.Respond("Whitelist is already disabled.");
+        }
+
+        [Command("add", "Add a Steam ID to the whitelist.")]
+        public void Add(ulong steamId)
+        {
+            if (Config.Whitelist.Add(steamId))
+            {
+                Context.Respond($"Added {steamId} to the whitelist.");
+                Config.Save();
+            }
+            else
+                Context.Respond($"{steamId} is already whitelisted.");
+        }
+
+        [Command("remove", "Remove a Steam ID from the whitelist.")]
+        public void Remove(ulong steamId)
+        {
+            if (Config.Whitelist.Remove(steamId))
+            {
+                Context.Respond($"Removed {steamId} from the whitelist.");
+                Config.Save();
+            }
+            else
+                Context.Respond($"{steamId} is not whitelisted.");
+        }
+    }
+}

Torch.Server/FlowDocumentTarget.cs

@@ -0,0 +1,54 @@
+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/Initializer.cs

@@ -0,0 +1,238 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+using System.IO.Compression;
+using System.Linq;
+using System.Net;
+using System.Reflection;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using System.Windows;
+using System.Windows.Threading;
+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
+    {
+        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 TorchServer _server;
+        private string _basePath;
+
+        public TorchConfig Config => _config;
+        public TorchServer Server => _server;
+
+        public Initializer(string basePath)
+        {
+            _basePath = basePath;
+        }
+
+        public bool Initialize(string[] args)
+        {
+            if (_init)
+                return false;
+
+#if !DEBUG
+            AppDomain.CurrentDomain.UnhandledException += HandleException;
+#endif
+
+            // This is what happens when Keen is bad and puts extensions into the System namespace.
+            if (!Enumerable.Contains(args, "-noupdate"))
+                RunSteamCmd();
+
+            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))
+            {
+                try
+                {
+                    var pid = int.Parse(_config.WaitForPID);
+                    var waitProc = Process.GetProcessById(pid);
+                    Log.Info("Continuing in 5 seconds.");
+                    Log.Warn($"Waiting for process {pid} to close");
+                    while (!waitProc.HasExited)
+                    {
+                        Console.Write(".");
+                        Thread.Sleep(1000);
+                    }
+                }
+                catch
+                {
+                    // ignored
+                }
+            }
+
+            _init = true;
+            return true;
+        }
+
+        public void Run()
+        {
+            _server = new TorchServer(_config);
+            var init = Task.Run(() => _server.Init()).ContinueWith(x =>
+            {
+                if (!x.IsFaulted)
+                    return;
+
+                Log.Error("Error initializing server.");
+                LogException(x.Exception);
+            });
+            if (!_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.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()
+        {
+            var log = LogManager.GetLogger("SteamCMD");
+
+            if (!Directory.Exists(STEAMCMD_DIR))
+            {
+                Directory.CreateDirectory(STEAMCMD_DIR);
+            }
+
+            if (!File.Exists(RUNSCRIPT_PATH))
+                File.WriteAllText(RUNSCRIPT_PATH, RUNSCRIPT);
+
+            if (!File.Exists(STEAMCMD_PATH))
+            {
+                try
+                {
+                    log.Info("Downloading SteamCMD.");
+                    using (var client = new WebClient())
+                        client.DownloadFile("https://steamcdn-a.akamaihd.net/client/installer/steamcmd.zip", STEAMCMD_ZIP);
+
+                    ZipFile.ExtractToDirectory(STEAMCMD_ZIP, STEAMCMD_DIR);
+                    File.Delete(STEAMCMD_ZIP);
+                    log.Info("SteamCMD downloaded successfully!");
+                }
+                catch
+                {
+                    log.Error("Failed to download SteamCMD, unable to update the DS.");
+                    return;
+                }
+            }
+
+            log.Info("Checking for DS updates.");
+            var steamCmdProc = new ProcessStartInfo(STEAMCMD_PATH, "+runscript runscript.txt")
+            {
+                WorkingDirectory = Path.Combine(Directory.GetCurrentDirectory(), STEAMCMD_DIR),
+                UseShellExecute = false,
+                RedirectStandardOutput = true,
+                StandardOutputEncoding = Encoding.ASCII
+            };
+            var cmd = Process.Start(steamCmdProc);
+
+            // ReSharper disable once PossibleNullReferenceException
+            while (!cmd.HasExited)
+            {
+                log.Info(cmd.StandardOutput.ReadLine());
+                Thread.Sleep(100);
+            }
+        }
+
+        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/ListBoxExtensions.cs

@@ -0,0 +1,59 @@
+using System;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Controls.Primitives;
+using System.Windows.Media;
+
+namespace Torch.Server
+{
+    public static class ListBoxExtensions
+    {
+        //https://stackoverflow.com/questions/28689125/how-to-autoscroll-listbox-to-bottom-wpf-c
+        public static void ScrollToItem(this ListBox listBox, int index)
+        {
+            // Find a container
+            UIElement container = null;
+            for (int i = index; i > 0; i--)
+            {
+                container = listBox.ItemContainerGenerator.ContainerFromIndex(i) as UIElement;
+                if (container != null)
+                {
+                    break;
+                }
+            }
+            if (container == null)
+                return;
+
+            // Find the ScrollContentPresenter
+            ScrollContentPresenter presenter = null;
+            for (Visual vis = container; vis != null && vis != listBox; vis = VisualTreeHelper.GetParent(vis) as Visual)
+                if ((presenter = vis as ScrollContentPresenter) != null)
+                    break;
+            if (presenter == null)
+                return;
+
+            // Find the IScrollInfo
+            var scrollInfo =
+                !presenter.CanContentScroll ? presenter :
+                presenter.Content as IScrollInfo ??
+                FirstVisualChild(presenter.Content as ItemsPresenter) as IScrollInfo ??
+                presenter;
+
+            // Find the amount of items that is "Visible" in the ListBox
+            var height = (container as ListBoxItem).ActualHeight;
+            var lbHeight = listBox.ActualHeight;
+            var showCount = (int)Math.Floor(lbHeight / height) - 1;
+
+            //Set the scrollbar
+            if (scrollInfo.CanVerticallyScroll)
+                scrollInfo.SetVerticalOffset(index - showCount);
+        }
+
+        private static DependencyObject FirstVisualChild(Visual visual)
+        {
+            if (visual == null) return null;
+            if (VisualTreeHelper.GetChildrenCount(visual) == 0) return null;
+            return VisualTreeHelper.GetChild(visual, 0);
+        }
+    }
+}

Torch.Server/Managers/EntityControlManager.cs

@@ -0,0 +1,265 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using System.Windows.Controls;
+using NLog;
+using NLog.Fluent;
+using Torch.API;
+using Torch.Collections;
+using Torch.Managers;
+using Torch.Server.ViewModels.Entities;
+using Torch.Utils;
+
+namespace Torch.Server.Managers
+{
+    /// <summary>
+    /// Manager that lets users bind random view models to entities in Torch's Entity Manager
+    /// </summary>
+    public class EntityControlManager : Manager
+    {
+        private static readonly Logger _log = LogManager.GetCurrentClassLogger();
+
+        /// <summary>
+        /// Creates an entity control manager for the given instance of torch
+        /// </summary>
+        /// <param name="torchInstance">Torch instance</param>
+        internal EntityControlManager(ITorchBase torchInstance) : base(torchInstance)
+        {
+        }
+
+        private abstract class ModelFactory
+        {
+            private readonly ConditionalWeakTable<EntityViewModel, EntityControlViewModel> _models = new ConditionalWeakTable<EntityViewModel, EntityControlViewModel>();
+
+            public abstract Delegate Delegate { get; }
+
+            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 EntityControlViewModel GetOrCreate(EntityViewModel evm)
+            {
+                return _models.GetValue(evm, Create);
+            }
+
+            internal bool TryGet(EntityViewModel evm, out EntityControlViewModel res)
+            {
+                return _models.TryGetValue(evm, out res);
+            }
+        }
+
+        private class ModelFactory<T> : ModelFactory where T : EntityViewModel
+        {
+            private readonly Func<T, EntityControlViewModel> _factory;
+            public override Delegate Delegate => _factory;
+
+            internal ModelFactory(Func<T, EntityControlViewModel> factory)
+            {
+                _factory = factory;
+            }
+
+
+            protected override EntityControlViewModel Create(EntityViewModel evm)
+            {
+                if (evm is T m)
+                {
+                    var result = _factory(m);
+                    _log.Trace($"Model factory {_factory.Method} created {result} for {evm}");
+                    return result;
+                }
+                return null;
+            }
+        }
+
+        private readonly List<ModelFactory> _modelFactories = new List<ModelFactory>();
+        private readonly List<Delegate> _controlFactories = new List<Delegate>();
+
+        private readonly List<WeakReference<EntityViewModel>> _boundEntityViewModels = new List<WeakReference<EntityViewModel>>();
+        private readonly ConditionalWeakTable<EntityViewModel, MtObservableList<EntityControlViewModel>> _boundViewModels = new ConditionalWeakTable<EntityViewModel, MtObservableList<EntityControlViewModel>>();
+
+        /// <summary>
+        /// This factory will be used to create component models for matching entity models.
+        /// </summary>
+        /// <typeparam name="TEntityBaseModel">entity model type to match</typeparam>
+        /// <param name="modelFactory">Method to create component model from entity model.</param>
+        public void RegisterModelFactory<TEntityBaseModel>(Func<TEntityBaseModel, EntityControlViewModel> modelFactory)
+            where TEntityBaseModel : EntityViewModel
+        {
+            if (!typeof(TEntityBaseModel).IsAssignableFrom(modelFactory.Method.GetParameters()[0].ParameterType))
+                throw new ArgumentException("Generic type must match lamda type", nameof(modelFactory));
+            lock (this)
+            {
+                var factory = new ModelFactory<TEntityBaseModel>(modelFactory);
+                _modelFactories.Add(factory);
+
+                var i = 0;
+                while (i < _boundEntityViewModels.Count)
+                {
+                    if (_boundEntityViewModels[i].TryGetTarget(out EntityViewModel target) &&
+                        _boundViewModels.TryGetValue(target, out MtObservableList<EntityControlViewModel> components))
+                    {
+                        if (target is TEntityBaseModel tent)
+                            UpdateBinding(target, components);
+                        i++;
+                    }
+                    else
+                        _boundEntityViewModels.RemoveAtFast(i);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Unregisters a factory registered with <see cref="RegisterModelFactory{TEntityBaseModel}"/>
+        /// </summary>
+        /// <typeparam name="TEntityBaseModel">entity model type to match</typeparam>
+        /// <param name="modelFactory">Method to create component model from entity model.</param>
+        public void UnregisterModelFactory<TEntityBaseModel>(Func<TEntityBaseModel, EntityControlViewModel> modelFactory)
+            where TEntityBaseModel : EntityViewModel
+        {
+            if (!typeof(TEntityBaseModel).IsAssignableFrom(modelFactory.Method.GetParameters()[0].ParameterType))
+                throw new ArgumentException("Generic type must match lamda type", nameof(modelFactory));
+            lock (this)
+            {
+                for (var i = 0; i < _modelFactories.Count; i++)
+                {
+                    if (_modelFactories[i].Delegate == (Delegate)modelFactory)
+                    {
+                        foreach (var entry in _modelFactories[i].Keys)
+                            if (_modelFactories[i].TryGet(entry, out EntityControlViewModel ecvm) && ecvm != null
+                                && _boundViewModels.TryGetValue(entry, out var binding))
+                                binding.Remove(ecvm);
+                        _modelFactories.RemoveAt(i);
+                        break;
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// This factory will be used to create controls for matching view models.
+        /// </summary>
+        /// <typeparam name="TEntityComponentModel">component model to match</typeparam>
+        /// <param name="controlFactory">Method to create control from component model</param>
+        public void RegisterControlFactory<TEntityComponentModel>(
+            Func<TEntityComponentModel, Control> controlFactory)
+            where TEntityComponentModel : EntityControlViewModel
+        {
+            if (!typeof(TEntityComponentModel).IsAssignableFrom(controlFactory.Method.GetParameters()[0].ParameterType))
+                throw new ArgumentException("Generic type must match lamda type", nameof(controlFactory));
+            lock (this)
+            {
+                _controlFactories.Add(controlFactory);
+                RefreshControls<TEntityComponentModel>();
+            }
+        }
+
+        ///<summary>
+        /// Unregisters a factory registered with <see cref="RegisterControlFactory{TEntityComponentModel}"/>
+        /// </summary>
+        /// <typeparam name="TEntityComponentModel">component model to match</typeparam>
+        /// <param name="controlFactory">Method to create control from component model</param>
+        public void UnregisterControlFactory<TEntityComponentModel>(
+            Func<TEntityComponentModel, Control> controlFactory)
+            where TEntityComponentModel : EntityControlViewModel
+        {
+            if (!typeof(TEntityComponentModel).IsAssignableFrom(controlFactory.Method.GetParameters()[0].ParameterType))
+                throw new ArgumentException("Generic type must match lamda type", nameof(controlFactory));
+            lock (this)
+            {
+                _controlFactories.Remove(controlFactory);
+                RefreshControls<TEntityComponentModel>();
+            }
+        }
+
+        private void RefreshControls<TEntityComponentModel>() where TEntityComponentModel : EntityControlViewModel
+        {
+            var i = 0;
+            while (i < _boundEntityViewModels.Count)
+            {
+                if (_boundEntityViewModels[i].TryGetTarget(out EntityViewModel target) &&
+                    _boundViewModels.TryGetValue(target, out MtObservableList<EntityControlViewModel> components))
+                {
+                    foreach (EntityControlViewModel component in components)
+                        if (component is TEntityComponentModel)
+                            component.InvalidateControl();
+                    i++;
+                }
+                else
+                    _boundEntityViewModels.RemoveAtFast(i);
+            }
+        }
+
+        /// <summary>
+        /// Gets the models bound to the given entity view model.
+        /// </summary>
+        /// <param name="entity">view model to query</param>
+        /// <returns></returns>
+        public MtObservableList<EntityControlViewModel> BoundModels(EntityViewModel entity)
+        {
+            return _boundViewModels.GetValue(entity, CreateFreshBinding);
+        }
+
+        /// <summary>
+        /// Gets a control for the given view model type.
+        /// </summary>
+        /// <param name="model">model to create a control for</param>
+        /// <returns>control, or null if none</returns>
+        public Control CreateControl(EntityControlViewModel model)
+        {
+            lock (this)
+                foreach (Delegate factory in _controlFactories)
+                    if (factory.Method.GetParameters()[0].ParameterType.IsInstanceOfType(model) &&
+                        factory.DynamicInvoke(model) is Control result)
+                    {
+                        _log.Trace($"Control factory {factory.Method} created {result}");
+                        return result;
+                    }
+            _log.Warn($"No control created for {model}");
+            return null;
+        }
+
+        private MtObservableList<EntityControlViewModel> CreateFreshBinding(EntityViewModel key)
+        {
+            var binding = new MtObservableList<EntityControlViewModel>();
+            lock (this)
+            {
+                _boundEntityViewModels.Add(new WeakReference<EntityViewModel>(key));
+            }
+            binding.PropertyChanged += (x, args) =>
+            {
+                if (nameof(binding.IsObserved).Equals(args.PropertyName))
+                    UpdateBinding(key, binding);
+            };
+            return binding;
+        }
+
+        private void UpdateBinding(EntityViewModel key, MtObservableList<EntityControlViewModel> binding)
+        {
+            if (!binding.IsObserved)
+                return;
+
+            lock (this)
+            {
+                foreach (ModelFactory factory in _modelFactories)
+                {
+                    var result = factory.GetOrCreate(key);
+                    if (result != null && !binding.Contains(result))
+                        binding.Add(result);
+                }
+            }
+        }
+    }
+}

Torch.Server/Managers/InstanceManager.cs

@@ -10,41 +10,48 @@ using Havok;
 using NLog;
 using Sandbox.Engine.Networking;
 using Sandbox.Engine.Utils;
+using Sandbox.Game;
+using Sandbox.Game.Gui;
 using Torch.API;
 using Torch.API.Managers;
 using Torch.Managers;
+using Torch.Mod;
 using Torch.Server.ViewModels;
+using VRage;
 using VRage.FileSystem;
 using VRage.Game;
+using VRage.Game.ObjectBuilder;
 using VRage.ObjectBuilders;
+using VRage.Plugins;
 
 namespace Torch.Server.Managers
 {
     public class InstanceManager : Manager
     {
         private const string CONFIG_NAME = "SpaceEngineers-Dedicated.cfg";
+
+        public event Action<ConfigDedicatedViewModel> InstanceLoaded;
         public ConfigDedicatedViewModel DedicatedConfig { get; set; }
         private static readonly Logger Log = LogManager.GetLogger(nameof(InstanceManager));
+        [Dependency]
+        private FilesystemManager _filesystemManager;
 
         public InstanceManager(ITorchBase torchInstance) : base(torchInstance)
         {
             
         }
         
-        /// <inheritdoc />
-        public override void Init()
-        {
-            LoadInstance(Torch.Config.InstancePath);
-        }
-
         public void LoadInstance(string path, bool validate = true)
         {
+            Log.Info($"Loading instance {path}");
+
             if (validate)
                 ValidateInstance(path);
 
             MyFileSystem.Reset();
-            MyFileSystem.ExePath = Path.Combine(Torch.GetManager<FilesystemManager>().TorchDirectory, "DedicatedServer64");
             MyFileSystem.Init("Content", path);
+            //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))
@@ -57,35 +64,77 @@ namespace Torch.Server.Managers
             config.Load(configPath);
 
             DedicatedConfig = new ConfigDedicatedViewModel(config);
+
             var worldFolders = Directory.EnumerateDirectories(Path.Combine(Torch.Config.InstancePath, "Saves"));
 
             foreach (var f in worldFolders)
-                DedicatedConfig.WorldPaths.Add(f);
+            {
+                if (!string.IsNullOrEmpty(f) && File.Exists(Path.Combine(f, "Sandbox.sbc")))
+                    DedicatedConfig.Worlds.Add(new WorldViewModel(f));
+            }
 
-            if (DedicatedConfig.WorldPaths.Count == 0)
+            if (DedicatedConfig.Worlds.Count == 0)
             {
                 Log.Warn($"No worlds found in the current instance {path}.");
                 return;
             }
 
-            /*
+            SelectWorld(DedicatedConfig.LoadWorld ?? DedicatedConfig.Worlds.First().WorldPath, false);
-            if (string.IsNullOrEmpty(DedicatedConfig.LoadWorld))
+
-            {
+            InstanceLoaded?.Invoke(DedicatedConfig);
-                Log.Warn("No world specified, importing first available world.");
-                SelectWorld(DedicatedConfig.WorldPaths[0], false);
-            }*/
         }
 
         public void SelectWorld(string worldPath, bool modsOnly = true)
         {
             DedicatedConfig.LoadWorld = worldPath;
-            LoadWorldMods(modsOnly);
+            DedicatedConfig.SelectedWorld = DedicatedConfig.Worlds.FirstOrDefault(x => x.WorldPath == worldPath);
+            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);
+            }
         }
 
-
+        public void SelectWorld(WorldViewModel world, bool modsOnly = true)
-        private void LoadWorldMods(bool modsOnly = true)
         {
-            if (DedicatedConfig.LoadWorld == null)
+            DedicatedConfig.LoadWorld = world.WorldPath;
+            DedicatedConfig.SelectedWorld = world;
+            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);
+            }
+        }
+
+        public void ImportSelectedWorldConfig()
+        {
+            ImportWorldConfig(DedicatedConfig.SelectedWorld, false);
+        }
+
+        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();
+
+
+            Log.Debug("Loaded mod list from world");
+
+            if (!modsOnly)
+                DedicatedConfig.SessionSettings = world.Checkpoint.Settings;
+        }
+
+        private void ImportWorldConfig(bool modsOnly = true)
+        {
+            if (string.IsNullOrEmpty(DedicatedConfig.LoadWorld))
                 return;
 
             var sandboxPath = Path.Combine(DedicatedConfig.LoadWorld, "Sandbox.sbc");
@@ -93,44 +142,64 @@ namespace Torch.Server.Managers
             if (!File.Exists(sandboxPath))
                 return;
 
+            try
+            {
                 MyObjectBuilderSerializer.DeserializeXML(sandboxPath, out MyObjectBuilder_Checkpoint checkpoint, out ulong sizeInBytes);
                 if (checkpoint == null)
                 {
-                Log.Error($"Failed to load {DedicatedConfig.LoadWorld}, checkpoint null ({sizeInBytes} bytes, instance {TorchBase.Instance.Config.InstancePath})");
+                    Log.Error($"Failed to load {DedicatedConfig.LoadWorld}, checkpoint null ({sizeInBytes} bytes, instance {Torch.Config.InstancePath})");
                     return;
                 }
 
-            var sb = new StringBuilder();
+                DedicatedConfig.Mods = checkpoint.Mods.Select(x => x.PublishedFileId).ToList();
-            foreach (var mod in checkpoint.Mods)
-                sb.AppendLine(mod.PublishedFileId.ToString());
 
-            DedicatedConfig.Mods = sb.ToString();
+                Log.Debug("Loaded mod list from world");
-
-            Log.Info("Loaded mod list from world");
 
                 if (!modsOnly)
                     DedicatedConfig.SessionSettings = new SessionSettingsViewModel(checkpoint.Settings);
             }
+            catch (Exception e)
+            {
+                Log.Error($"Error loading mod list from world, verify that your mod list is accurate. '{DedicatedConfig.LoadWorld}'.");
+                Log.Error(e);
+            }
+        }
 
         public void SaveConfig()
         {
-            DedicatedConfig.Model.Save();
+            var cf = Torch.Config as TorchConfig;
+            if (cf?.ReservedPlayers?.Count > 0)
+            {
+                foreach (var res in cf.ReservedPlayers)
+                {
+                    if (!DedicatedConfig.Reserved.Contains(res))
+                        DedicatedConfig.Reserved.Add(res);
+                }
+            }
+
+            DedicatedConfig.Save(Path.Combine(Torch.Config.InstancePath, CONFIG_NAME));
             Log.Info("Saved dedicated config.");
 
             try
             {
-                MyObjectBuilderSerializer.DeserializeXML(Path.Combine(DedicatedConfig.LoadWorld, "Sandbox.sbc"), out MyObjectBuilder_Checkpoint checkpoint, out ulong sizeInBytes);
+                var sandboxPath = Path.Combine(DedicatedConfig.LoadWorld, "Sandbox.sbc");
+                MyObjectBuilderSerializer.DeserializeXML(sandboxPath, out MyObjectBuilder_Checkpoint checkpoint, out ulong sizeInBytes);
                 if (checkpoint == null)
                 {
-                    Log.Error($"Failed to load {DedicatedConfig.LoadWorld}, checkpoint null ({sizeInBytes} bytes, instance {TorchBase.Instance.Config.InstancePath})");
+                    Log.Error($"Failed to load {DedicatedConfig.LoadWorld}, checkpoint null ({sizeInBytes} bytes, instance {Torch.Config.InstancePath})");
                     return;
                 }
+
+                checkpoint.SessionName = DedicatedConfig.WorldName;
                 checkpoint.Settings = DedicatedConfig.SessionSettings;
                 checkpoint.Mods.Clear();
-                foreach (var modId in DedicatedConfig.Model.Mods)
+                
+                foreach (var modId in DedicatedConfig.Mods)
                     checkpoint.Mods.Add(new MyObjectBuilder_Checkpoint.ModItem(modId));
 
-                MyLocalCache.SaveCheckpoint(checkpoint, DedicatedConfig.LoadWorld);
+                MyObjectBuilderSerializer.SerializeXML(sandboxPath, false, checkpoint);
+
+                //MyLocalCache.SaveCheckpoint(checkpoint, DedicatedConfig.LoadWorld);
                 Log.Info("Saved world config.");
             }
             catch (Exception e)
@@ -155,4 +224,44 @@ namespace Torch.Server.Managers
             config.Save(configPath);
         }
     }
+
+    public class WorldViewModel : ViewModel
+    {
+        private static readonly Logger Log = LogManager.GetCurrentClassLogger();
+
+        public string FolderName { get; set; }
+        public string WorldPath { get; }
+        public long WorldSizeKB { get; }
+        private string _checkpointPath;
+        public CheckpointViewModel Checkpoint { get; private set; }
+
+        public WorldViewModel(string worldPath)
+        {
+            WorldPath = worldPath;
+            WorldSizeKB = new DirectoryInfo(worldPath).GetFiles().Sum(x => x.Length) / 1024;
+            _checkpointPath = Path.Combine(WorldPath, "Sandbox.sbc");
+            FolderName = Path.GetFileName(worldPath);
+            BeginLoadCheckpoint();
+        }
+
+        public async Task SaveCheckpointAsync()
+        {
+            await Task.Run(() =>
+            {
+                using (var f = File.Open(_checkpointPath, FileMode.Create))
+                    MyObjectBuilderSerializer.SerializeXML(f, Checkpoint);
+            });
+        }
+
+        private void BeginLoadCheckpoint()
+        {
+            //Task.Run(() =>
+            {
+                Log.Info($"Preloading checkpoint {_checkpointPath}");
+                MyObjectBuilderSerializer.DeserializeXML(_checkpointPath, out MyObjectBuilder_Checkpoint checkpoint);
+                Checkpoint = new CheckpointViewModel(checkpoint);
+                OnPropertyChanged(nameof(Checkpoint));
+            }//);
+        }
+    }
 }

Torch.Server/Managers/MultiplayerManagerDedicated.cs

@@ -0,0 +1,301 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net;
+using System.Reflection;
+using System.Text;
+using System.Threading.Tasks;
+using NLog;
+using NLog.Fluent;
+using Sandbox;
+using Sandbox.Engine.Multiplayer;
+using Sandbox.Engine.Networking;
+using Sandbox.Game.World;
+using Steamworks;
+using Torch.API;
+using Torch.API.Managers;
+using Torch.Managers;
+using Torch.Utils;
+using Torch.ViewModels;
+using VRage.Game;
+using VRage.Game.ModAPI;
+using VRage.GameServices;
+using VRage.Network;
+using VRage.Steam;
+
+namespace Torch.Server.Managers
+{
+    public class MultiplayerManagerDedicated : MultiplayerManagerBase, IMultiplayerManagerServer
+    {
+        private static readonly Logger _log = LogManager.GetCurrentClassLogger();
+
+#pragma warning disable 649
+        [ReflectedGetter(Name = "m_members")]
+        private static Func<MyDedicatedServerBase, List<ulong>> _members;
+
+        [ReflectedGetter(Name = "m_waitingForGroup")]
+        private static Func<MyDedicatedServerBase, HashSet<ulong>> _waitingForGroup;
+#pragma warning restore 649
+
+        /// <inheritdoc />
+        public IReadOnlyList<ulong> BannedPlayers => MySandboxGame.ConfigDedicated.Banned;
+
+        private Dictionary<ulong, ulong> _gameOwnerIds = new Dictionary<ulong, ulong>();
+
+        [Dependency]
+        private InstanceManager _instanceManager;
+
+        /// <inheritdoc />
+        public MultiplayerManagerDedicated(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);
+            });
+        }
+
+        internal void RaiseClientBanned(ulong user, bool banned)
+        {
+            PlayerBanned?.Invoke(user, banned);
+            Torch.Invoke(() =>
+                         {
+                             if(_gameOwnerIds.TryGetValue(user, out ulong owner))
+                                 MyMultiplayer.Static.BanClient(owner, banned);
+                         });
+        }
+
+        internal void RaiseClientKicked(ulong user)
+        {
+            PlayerKicked?.Invoke(user);
+        }
+
+        /// <inheritdoc />
+        public bool IsBanned(ulong steamId) => _isClientBanned.Invoke(MyMultiplayer.Static, steamId) ||
+                                               MySandboxGame.ConfigDedicated.Banned.Contains(steamId);
+
+        /// <inheritdoc />
+        public event Action<ulong> PlayerKicked;
+
+        /// <inheritdoc />
+        public event Action<ulong, bool> PlayerBanned;
+
+        /// <inheritdoc/>
+        public override void Attach()
+        {
+            base.Attach();
+            _gameServerValidateAuthTicketReplacer = _gameServerValidateAuthTicketFactory.Invoke();
+            _gameServerUserGroupStatusReplacer = _gameServerUserGroupStatusFactory.Invoke();
+            _gameServerValidateAuthTicketReplacer.Replace(
+                new Action<ulong, JoinResult, ulong>(ValidateAuthTicketResponse), MyGameService.GameServer);
+            _gameServerUserGroupStatusReplacer.Replace(new Action<ulong, ulong, bool, bool>(UserGroupStatusResponse),
+                MyGameService.GameServer);
+            _log.Info("Inserted steam authentication intercept");
+        }
+
+        /// <inheritdoc/>
+        public override void Detach()
+        {
+            if (_gameServerValidateAuthTicketReplacer != null && _gameServerValidateAuthTicketReplacer.Replaced)
+                _gameServerValidateAuthTicketReplacer.Restore(MyGameService.GameServer);
+            if (_gameServerUserGroupStatusReplacer != null && _gameServerUserGroupStatusReplacer.Replaced)
+                _gameServerUserGroupStatusReplacer.Restore(MyGameService.GameServer);
+            _log.Info("Removed steam authentication intercept");
+            base.Detach();
+        }
+
+
+#pragma warning disable 649
+        [ReflectedEventReplace(typeof(MySteamGameServer), nameof(MySteamGameServer.ValidateAuthTicketResponse),
+            typeof(MyDedicatedServerBase), "GameServer_ValidateAuthTicketResponse")]
+        private static Func<ReflectedEventReplacer> _gameServerValidateAuthTicketFactory;
+
+        [ReflectedEventReplace(typeof(MySteamGameServer), nameof(MySteamGameServer.UserGroupStatusResponse),
+            typeof(MyDedicatedServerBase), "GameServer_UserGroupStatus")]
+        private static Func<ReflectedEventReplacer> _gameServerUserGroupStatusFactory;
+
+        private ReflectedEventReplacer _gameServerValidateAuthTicketReplacer;
+        private ReflectedEventReplacer _gameServerUserGroupStatusReplacer;
+#pragma warning restore 649
+
+        #region CustomAuth
+
+#pragma warning disable 649
+        [ReflectedStaticMethod(Type = typeof(MyDedicatedServerBase), Name = "ConvertSteamIDFrom64")]
+        private static Func<ulong, string> _convertSteamIDFrom64;
+
+        [ReflectedStaticMethod(Type = typeof(MyGameService), Name = "GetServerAccountType")]
+        private static Func<ulong, MyGameServiceAccountType> _getServerAccountType;
+
+        [ReflectedMethod(Name = "UserAccepted")]
+        private static Action<MyDedicatedServerBase, ulong> _userAcceptedImpl;
+
+        [ReflectedMethod(Name = "UserRejected")]
+        private static Action<MyDedicatedServerBase, ulong, JoinResult> _userRejected;
+
+        [ReflectedMethod(Name = "IsClientBanned")]
+        private static Func<MyMultiplayerBase, ulong, bool> _isClientBanned;
+
+        [ReflectedMethod(Name = "IsClientKicked")]
+        private static Func<MyMultiplayerBase, ulong, bool> _isClientKicked;
+
+        [ReflectedMethod(Name = "RaiseClientKicked")]
+        private static Action<MyMultiplayerBase, ulong> _raiseClientKicked;
+#pragma warning restore 649
+
+        private const int _waitListSize = 32;
+        private readonly List<WaitingForGroup> _waitingForGroupLocal = new List<WaitingForGroup>(_waitListSize);
+
+        private struct WaitingForGroup
+        {
+            public readonly ulong SteamId;
+            public readonly JoinResult Response;
+            public readonly ulong SteamOwner;
+
+            public WaitingForGroup(ulong id, JoinResult response, ulong owner)
+            {
+                SteamId = id;
+                Response = response;
+                SteamOwner = owner;
+            }
+        }
+
+        //Largely copied from SE
+        private void ValidateAuthTicketResponse(ulong steamId, JoinResult response, ulong steamOwner)
+        {
+            var state = new MyP2PSessionState();
+            MySteamService.Static.Peer2Peer.GetSessionState(steamId, ref state);
+            var ip = new IPAddress(BitConverter.GetBytes(state.RemoteIP).Reverse().ToArray());
+
+            Torch.CurrentSession.KeenSession.PromotedUsers.TryGetValue(steamId, out MyPromoteLevel promoteLevel);
+
+            _log.Debug($"ValidateAuthTicketResponse(user={steamId}, response={response}, owner={steamOwner}, permissions={promoteLevel})");
+
+            _log.Info($"Connection attempt by {steamId} from {ip}");
+            
+            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.");
+                UserRejected(steamId, JoinResult.TicketCanceled);
+            }
+            else if (MySandboxGame.ConfigDedicated.GroupID == 0uL)
+                RunEvent(new ValidateAuthTicketEvent(steamId, steamOwner, response, 0, true, false));
+            else if (_getServerAccountType(MySandboxGame.ConfigDedicated.GroupID) != MyGameServiceAccountType.Clan)
+                UserRejected(steamId, JoinResult.GroupIdInvalid);
+            else if (MyGameService.GameServer.RequestGroupStatus(steamId, MySandboxGame.ConfigDedicated.GroupID))
+                lock (_waitingForGroupLocal)
+                {
+                    if (_waitingForGroupLocal.Count >= _waitListSize)
+                        _waitingForGroupLocal.RemoveAt(0);
+                    _waitingForGroupLocal.Add(new WaitingForGroup(steamId, response, steamOwner));
+                }
+            else
+                UserRejected(steamId, JoinResult.SteamServersOffline);
+        }
+
+        private void RunEvent(ValidateAuthTicketEvent info)
+        {
+            JoinResult internalAuth;
+
+
+            if (IsBanned(info.SteamOwner) || IsBanned(info.SteamID))
+                internalAuth = JoinResult.BannedByAdmins;
+            else if (_isClientKicked(MyMultiplayer.Static, info.SteamID) ||
+                     _isClientKicked(MyMultiplayer.Static, info.SteamOwner))
+                internalAuth = JoinResult.KickedRecently;
+            else if (info.SteamResponse == JoinResult.OK)
+            {
+                var config = (TorchConfig) Torch.Config;
+                if (config.EnableWhitelist && !config.Whitelist.Contains(info.SteamID))
+                {
+                    _log.Warn($"Rejecting user {info.SteamID} because they are not whitelisted in Torch.cfg.");
+                    internalAuth = JoinResult.NotInGroup;
+                }
+                else if (MySandboxGame.ConfigDedicated.Reserved.Contains(info.SteamID))
+                    internalAuth = JoinResult.OK;
+                //Admins can bypass member limit
+                else if (MySandboxGame.ConfigDedicated.Administrators.Contains(info.SteamID.ToString()) ||
+                         MySandboxGame.ConfigDedicated.Administrators.Contains(_convertSteamIDFrom64(info.SteamID)))
+                    internalAuth = JoinResult.OK;
+                //Server counts as a client, so subtract 1 from MemberCount
+                else if (MyMultiplayer.Static.MemberLimit > 0 &&
+                         MyMultiplayer.Static.MemberCount - 1 >= MyMultiplayer.Static.MemberLimit)
+                    internalAuth = JoinResult.ServerFull;
+                else if (MySandboxGame.ConfigDedicated.GroupID == 0uL)
+                    internalAuth = JoinResult.OK;
+                else
+                {
+                    if (MySandboxGame.ConfigDedicated.GroupID == info.Group && (info.Member || info.Officer))
+                        internalAuth = JoinResult.OK;
+                    else
+                        internalAuth = JoinResult.NotInGroup;
+                }
+            }
+            else
+                internalAuth = info.SteamResponse;
+
+            info.FutureVerdict = Task.FromResult(internalAuth);
+
+            MultiplayerManagerDedicatedEventShim.RaiseValidateAuthTicket(ref info);
+
+            info.FutureVerdict.ContinueWith((task) =>
+            {
+                JoinResult verdict;
+                if (task.IsFaulted)
+                {
+                    _log.Error(task.Exception, $"Future validation verdict faulted");
+                    verdict = JoinResult.TicketCanceled;
+                }
+                else
+                    verdict = task.Result;
+
+                Torch.Invoke(() => { CommitVerdict(info.SteamID, verdict); });
+            });
+        }
+
+        private void CommitVerdict(ulong steamId, JoinResult verdict)
+        {
+            if (verdict == JoinResult.OK)
+                UserAccepted(steamId);
+            else
+                UserRejected(steamId, verdict);
+        }
+
+        private void UserGroupStatusResponse(ulong userId, ulong groupId, bool member, bool officer)
+        {
+            lock (_waitingForGroupLocal)
+                for (var j = 0; j < _waitingForGroupLocal.Count; j++)
+                {
+                    var wait = _waitingForGroupLocal[j];
+                    if (wait.SteamId == userId)
+                    {
+                        RunEvent(new ValidateAuthTicketEvent(wait.SteamId, wait.SteamOwner, wait.Response, groupId,
+                            member, officer));
+                        _waitingForGroupLocal.RemoveAt(j);
+                        break;
+                    }
+                }
+        }
+
+        private void UserRejected(ulong steamId, JoinResult reason)
+        {
+            _userRejected.Invoke((MyDedicatedServerBase) MyMultiplayer.Static, steamId, reason);
+        }
+
+        private void UserAccepted(ulong steamId)
+        {
+            _userAcceptedImpl.Invoke((MyDedicatedServerBase) MyMultiplayer.Static, steamId);
+            base.RaiseClientJoined(steamId);
+        }
+
+        #endregion
+    }
+}

Torch.Server/Managers/MultiplayerManagerDedicatedEventShim.cs

@@ -0,0 +1,84 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using NLog;
+using Sandbox;
+using Torch.API.Event;
+using Torch.Event;
+using VRage.Network;
+
+namespace Torch.Server.Managers
+{
+    [EventShim]
+    internal static class MultiplayerManagerDedicatedEventShim
+    {
+        private static readonly EventList<ValidateAuthTicketEvent> _eventValidateAuthTicket =
+            new EventList<ValidateAuthTicketEvent>();
+
+
+        internal static void RaiseValidateAuthTicket(ref ValidateAuthTicketEvent info)
+        {
+            _eventValidateAuthTicket?.RaiseEvent(ref info);
+        }
+    }
+
+    /// <summary>
+    /// Event that occurs when a player tries to connect to a dedicated server.
+    /// Use these values to choose a <see cref="ValidateAuthTicketEvent.FutureVerdict"/>, 
+    /// or leave it unset to allow the default logic to handle the request.
+    /// </summary>
+    public struct ValidateAuthTicketEvent : IEvent
+    {
+        /// <summary>
+        /// SteamID of the player
+        /// </summary>
+        public readonly ulong SteamID;
+
+        /// <summary>
+        /// SteamID of the game owner
+        /// </summary>
+        public readonly ulong SteamOwner;
+
+        /// <summary>
+        /// The response from steam
+        /// </summary>
+        public readonly JoinResult SteamResponse;
+
+        /// <summary>
+        /// ID of the queried group, or <c>0</c> if no group.
+        /// </summary>
+        public readonly ulong Group;
+
+        /// <summary>
+        /// Is this person a member of <see cref="Group"/>.  If no group this is true.
+        /// </summary>
+        public readonly bool Member;
+
+        /// <summary>
+        /// Is this person an officer of <see cref="Group"/>.  If no group this is false.
+        /// </summary>
+        public readonly bool Officer;
+
+        /// <summary>
+        /// A future verdict on this authorization request.  If null, let the default logic choose.  If not async use <see cref="Task.FromResult{TResult}(TResult)"/>
+        /// </summary>
+        public Task<JoinResult> FutureVerdict;
+
+        internal ValidateAuthTicketEvent(ulong steamId, ulong steamOwner, JoinResult steamResponse,
+            ulong serverGroup, bool member, bool officer)
+        {
+            SteamID = steamId;
+            SteamOwner = steamOwner;
+            SteamResponse = steamResponse;
+            Group = serverGroup;
+            Member = member;
+            Officer = officer;
+            FutureVerdict = null;
+        }
+
+        /// <inheritdoc/>
+        public bool Cancelled => FutureVerdict != null;
+    }
+}

Torch.Server/Managers/MultiplayerManagerDedicatedPatchShim.cs

@@ -0,0 +1,32 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using NLog;
+using Sandbox.Engine.Multiplayer;
+using Torch.Managers.PatchManager;
+using Torch.API.Managers;
+
+namespace Torch.Server.Managers
+{
+    [PatchShim]
+    internal static class MultiplayerManagerDedicatedPatchShim
+    {
+        public static void Patch(PatchContext ctx)
+        {
+            ctx.GetPattern(typeof(MyDedicatedServerBase).GetMethod(nameof(MyDedicatedServerBase.BanClient))).Prefixes.Add(typeof(MultiplayerManagerDedicatedPatchShim).GetMethod(nameof(BanPrefix)));
+            ctx.GetPattern(typeof(MyDedicatedServerBase).GetMethod(nameof(MyDedicatedServerBase.KickClient))).Prefixes.Add(typeof(MultiplayerManagerDedicatedPatchShim).GetMethod(nameof(KickPrefix)));
+        }
+
+        public static void BanPrefix(ulong userId, bool banned)
+        {
+            TorchBase.Instance.CurrentSession.Managers.GetManager<MultiplayerManagerDedicated>().RaiseClientBanned(userId, banned);
+        }
+
+        public static void KickPrefix(ulong userId)
+        {
+            TorchBase.Instance.CurrentSession.Managers.GetManager<MultiplayerManagerDedicated>().RaiseClientKicked(userId);
+        }
+    }
+}

Torch.Server/MultiTextWriter.cs

@@ -0,0 +1,49 @@
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+
+namespace Torch.Server
+{
+    public class MultiTextWriter : TextWriter
+    {
+        private IEnumerable<TextWriter> writers;
+        public MultiTextWriter(IEnumerable<TextWriter> writers)
+        {
+            this.writers = writers.ToList();
+        }
+        public MultiTextWriter(params TextWriter[] writers)
+        {
+            this.writers = writers;
+        }
+
+        public override void Write(char value)
+        {
+            foreach (var writer in writers)
+                writer.Write(value);
+        }
+
+        public override void Write(string value)
+        {
+            foreach (var writer in writers)
+                writer.Write(value);
+        }
+
+        public override void Flush()
+        {
+            foreach (var writer in writers)
+                writer.Flush();
+        }
+
+        public override void Close()
+        {
+            foreach (var writer in writers)
+                writer.Close();
+        }
+
+        public override Encoding Encoding
+        {
+            get { return Encoding.ASCII; }
+        }
+    }
+}

Torch.Server/Program.cs

@@ -1,295 +1,50 @@
 using System;
-using System.Collections;
-using System.Collections.Generic;
-using System.Configuration.Install;
 using System.Diagnostics;
 using System.IO;
-using System.Linq;
+using System.IO.Compression;
+using System.Net;
 using System.Reflection;
 using System.ServiceProcess;
 using System.Text;
 using System.Threading;
-using System.Threading.Tasks;
-using System.Windows;
-using System.Windows.Threading;
-using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.CSharp;
 using NLog;
-using Sandbox.Game.World;
+using NLog.Targets;
-using Sandbox.ModAPI;
+using Torch.Utils;
-using Torch;
-using Torch.API;
-using Torch.Server.Views;
-using VRage.Game.ModAPI;
-using System.IO.Compression;
-using System.Net;
-using System.Security.Policy;
-using Torch.Server.Managers;
-using VRage.FileSystem;
-using VRageRender;
 
 namespace Torch.Server
 {
     internal static class Program
     {
-        private static ITorchServer _server;
+        /// <remarks>
-        private static Logger _log = LogManager.GetLogger("Torch");
-        private static bool _restartOnCrash;
-        private static TorchConfig _config;
-        private static bool _steamCmdDone;
-
-        /// <summary>
         /// This method must *NOT* load any types/assemblies from the vanilla game, otherwise automatic updates will fail.
-        /// </summary>
+        /// </remarks>
         [STAThread]
         public static void Main(string[] args)
         {
+            Target.Register<FlowDocumentTarget>("FlowDocument");
             //Ensures that all the files are downloaded in the Torch directory.
-            Directory.SetCurrentDirectory(new FileInfo(typeof(Program).Assembly.Location).Directory.ToString());
+            var workingDir = new FileInfo(typeof(Program).Assembly.Location).Directory.ToString();
+            var binDir = Path.Combine(workingDir, "DedicatedServer64");
+            Directory.SetCurrentDirectory(workingDir);
 
-            foreach (var file in Directory.GetFiles(Directory.GetCurrentDirectory(), "*.old"))
+            if (!TorchLauncher.IsTorchWrapped())
-                File.Delete(file);
+            {
-
+                TorchLauncher.Launch(Assembly.GetEntryAssembly().FullName, args, binDir);
-            AppDomain.CurrentDomain.AssemblyResolve += CurrentDomain_AssemblyResolve;
+                return;
-            AppDomain.CurrentDomain.UnhandledException += CurrentDomain_UnhandledException;
+            }
 
             if (!Environment.UserInteractive)
             {
                 using (var service = new TorchService())
-                {
                     ServiceBase.Run(service);
-                }
                 return;
             }
 
-            //CommandLine reflection triggers assembly loading, so DS update must be completely separated.
+            var initializer = new Initializer(workingDir);
-            if (!args.Contains("-noupdate"))
+            if (!initializer.Initialize(args))
-            {
-                if (!Directory.Exists("DedicatedServer64"))
-                {
-                    _log.Error("Game libraries not found. Press the Enter key to install the dedicated server.");
-                    Console.ReadLine();
-                }
-                RunSteamCmd();
-            }
-
-            InitConfig();
-
-            if (!_config.Parse(args))
                 return;
 
-            if (!string.IsNullOrEmpty(_config.WaitForPID))
+            initializer.Run();
-            {
-                try
-                {
-                    var pid = int.Parse(_config.WaitForPID);
-                    var waitProc = Process.GetProcessById(pid);
-                    _log.Warn($"Waiting for process {pid} to exit.");
-                    waitProc.WaitForExit();
-                    _log.Info("Continuing in 5 seconds.");
-                    Thread.Sleep(5000);
-                }
-                catch
-                {
-                    // ignored
-                }
-            }
-
-            _restartOnCrash = _config.RestartOnCrash;
-            RunServer(_config);
-        }
-
-        public static void InitConfig()
-        {
-            var configName = "Torch.cfg";
-            var configPath = Path.Combine(Directory.GetCurrentDirectory(), configName);
-            if (File.Exists(configName))
-            {
-                _log.Info($"Loading config {configPath}");
-                _config = TorchConfig.LoadFrom(configPath);
-            }
-            else
-            {
-                _log.Info($"Generating default config at {configPath}");
-                _config = new TorchConfig { InstancePath = Path.GetFullPath("Instance") };
-                _config.Save(configPath);
-            }
-        }
-
-        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";
-
-        public static void RunSteamCmd()
-        {
-            if (_steamCmdDone)
-                return;
-
-            var log = LogManager.GetLogger("SteamCMD");
-
-            if (!Directory.Exists(STEAMCMD_DIR))
-            {
-                Directory.CreateDirectory(STEAMCMD_DIR);
-            }
-
-            if (!File.Exists(RUNSCRIPT_PATH))
-                File.WriteAllText(RUNSCRIPT_PATH, RUNSCRIPT);
-
-            if (!File.Exists(STEAMCMD_PATH))
-            {
-                try
-                {
-                    log.Info("Downloading SteamCMD.");
-                    using (var client = new WebClient())
-                        client.DownloadFile("https://steamcdn-a.akamaihd.net/client/installer/steamcmd.zip", STEAMCMD_ZIP);
-
-                    ZipFile.ExtractToDirectory(STEAMCMD_ZIP, STEAMCMD_DIR);
-                    File.Delete(STEAMCMD_ZIP);
-                    log.Info("SteamCMD downloaded successfully!");
-                }
-                catch
-                {
-                    log.Error("Failed to download SteamCMD, unable to update the DS.");
-                    return;
-                }
-            }
-
-            log.Info("Checking for DS updates.");
-            var steamCmdProc = new ProcessStartInfo(STEAMCMD_PATH, "+runscript runscript.txt")
-            {
-                WorkingDirectory = Path.Combine(Directory.GetCurrentDirectory(), STEAMCMD_DIR),
-                UseShellExecute = false,
-                RedirectStandardOutput = true,
-                StandardOutputEncoding = Encoding.ASCII
-            };
-            var cmd = Process.Start(steamCmdProc);
-
-            // ReSharper disable once PossibleNullReferenceException
-            while (!cmd.HasExited)
-            {
-                log.Info(cmd.StandardOutput.ReadLine());
-                Thread.Sleep(100);
-            }
-
-            _steamCmdDone = true;
-        }
-
-        public static void RunServer(TorchConfig config)
-        {
-
-
-            /*
-            if (!parser.ParseArguments(args, config))
-            {
-                _log.Error($"Parsing arguments failed: {string.Join(" ", args)}");
-                return;
-            }
-
-            if (!string.IsNullOrEmpty(config.Config) && File.Exists(config.Config))
-            {
-                config = ServerConfig.LoadFrom(config.Config);
-                parser.ParseArguments(args, config);
-            }*/
-
-            //RestartOnCrash autostart autosave=15 
-            //gamepath ="C:\Program Files\Space Engineers DS" instance="Hydro Survival" instancepath="C:\ProgramData\SpaceEngineersDedicated\Hydro Survival"
-
-            /*
-            if (config.InstallService)
-            {
-                var serviceName = $"\"Torch - {config.InstanceName}\"";
-                // Working on installing the service properly instead of with sc.exe
-                _log.Info($"Installing service '{serviceName}");
-                var exePath = $"\"{Assembly.GetExecutingAssembly().Location}\"";
-                var createInfo = new ServiceCreateInfo
-                {
-                    Name = config.InstanceName,
-                    BinaryPath = exePath,
-                };
-                _log.Info("Service Installed");
-
-                var runArgs = string.Join(" ", args.Skip(1));
-                _log.Info($"Installing Torch as a service with arguments '{runArgs}'");
-                var startInfo = new ProcessStartInfo
-                {
-                    FileName = "sc.exe",
-                    Arguments = $"create Torch binPath=\"{Assembly.GetExecutingAssembly().Location} {runArgs}\"",
-                    CreateNoWindow = true,
-                    UseShellExecute = true,
-                    Verb = "runas"
-                };
-                Process.Start(startInfo).WaitForExit();
-                _log.Info("Torch service installed");
-                return;
-            }
-
-            if (config.UninstallService)
-            {
-                _log.Info("Uninstalling Torch service");
-                var startInfo = new ProcessStartInfo
-                {
-                    FileName = "sc.exe",
-                    Arguments = "delete Torch",
-                    CreateNoWindow = true,
-                    UseShellExecute = true,
-                    Verb = "runas"
-                };
-                Process.Start(startInfo).WaitForExit();
-                _log.Info("Torch service uninstalled");
-                return;
-            }*/
-
-            _server = new TorchServer(config);
-
-            _server.Init();
-            if (config.NoGui || config.Autostart)
-            {
-                new Thread(() => _server.Start()).Start();
-            }
-
-            if (!config.NoGui)
-            {
-                var ui = new TorchUI((TorchServer)_server);
-                ui.ShowDialog();
-            }
-        }
-
-        private static Assembly CurrentDomain_AssemblyResolve(object sender, ResolveEventArgs args)
-        {
-            try
-            {
-                var basePath = Path.Combine(Path.GetDirectoryName(typeof(Program).Assembly.Location), "DedicatedServer64");
-                string asmPath = Path.Combine(basePath, new AssemblyName(args.Name).Name + ".dll");
-                if (File.Exists(asmPath))
-                    return Assembly.LoadFrom(asmPath);
-            }
-            catch
-            {
-                // ignored
-            }
-
-            return null;
-        }
-
-        private static void CurrentDomain_UnhandledException(object sender, UnhandledExceptionEventArgs e)
-        {
-            var ex = (Exception)e.ExceptionObject;
-            _log.Fatal(ex);
-            Console.WriteLine("Exiting in 5 seconds.");
-            Thread.Sleep(5000);
-            if (_restartOnCrash)
-            {
-                var exe = typeof(Program).Assembly.Location;
-                _config.WaitForPID = Process.GetCurrentProcess().Id.ToString();
-                Process.Start(exe, _config.ToString());
-            }
-            //1627 = Function failed during execution.
-            Environment.Exit(1627);
         }
     }
 }

Torch.Server/Properties/AssemblyInfo.cs

@@ -1,4 +1,17 @@
 using System.Reflection;
+using System.Runtime.InteropServices;
 
-[assembly: AssemblyVersion("1.1.207.7")]
+[assembly: AssemblyTitle("Torch Server")]
-[assembly: AssemblyFileVersion("1.1.207.7")]
+[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/Properties/AssemblyInfo.tt

@@ -1,16 +0,0 @@
-<#@ template debug="false" hostspecific="false" language="C#" #>
-<#@ assembly name="System.Core" #>
-<#@ import namespace="System.Linq" #>
-<#@ import namespace="System.Text" #>
-<#@ import namespace="System.Collections.Generic" #>
-<#@ output extension=".cs" #>
-using System.Reflection;
-
-<#  var dt = DateTime.Now;
-    int major = 1;
-	int minor = 1;
-	int build = dt.DayOfYear;
-	int rev = (int)dt.TimeOfDay.TotalMinutes / 2;
-#>
-[assembly: AssemblyVersion("<#= major #>.<#= minor #>.<#= build #>.<#= rev #>")]
-[assembly: AssemblyFileVersion("<#= major #>.<#= minor #>.<#= build #>.<#= rev #>")]

Torch.Server/RichTextBoxWriter.cs

@@ -0,0 +1,89 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+using System.Windows.Controls;
+using System.Windows.Documents;
+using System.Windows.Media;
+
+namespace Torch.Server
+{
+    public class RichTextBoxWriter : TextWriter
+    {
+        private RichTextBox textbox;
+        private StringBuilder _cache = new StringBuilder();
+        public RichTextBoxWriter(RichTextBox textbox)
+        {
+            this.textbox = textbox;
+            textbox.Document.Background = new SolidColorBrush(UnpackColor(Console.BackgroundColor));
+            textbox.Document.Blocks.Clear();
+            textbox.Document.Blocks.Add(new Paragraph {LineHeight = 12});
+        }
+
+        public override void Write(char value)
+        {
+            if (value == '\r')
+                return;
+
+            _cache.Append(value);
+            if (value == '\n')
+            {
+                var str = _cache.ToString();
+                _cache.Clear();
+
+                var brush = _brushes[Console.ForegroundColor];
+                textbox.Dispatcher.BeginInvoke(() =>
+                {
+                    var p = (Paragraph)textbox.Document.Blocks.FirstBlock;
+                    p.Inlines.Add(new Run(str) { Foreground = brush });
+                    textbox.ScrollToEnd();
+                });
+            }
+
+        }
+
+        public override void Write(string value)
+        {
+            var brush = _brushes[Console.ForegroundColor];
+            textbox.Dispatcher.BeginInvoke(() =>
+            {
+                var p = (Paragraph)textbox.Document.Blocks.FirstBlock;
+                p.Inlines.Add(new Run(value) { Foreground = brush });
+                textbox.ScrollToEnd();
+            });
+        }
+
+        public override Encoding Encoding
+        {
+            get { return Encoding.ASCII; }
+        }
+
+        static RichTextBoxWriter()
+        {
+            foreach (var value in (ConsoleColor[])Enum.GetValues(typeof(ConsoleColor)))
+            {
+                _brushes.Add(value, new SolidColorBrush(UnpackColor(value)));
+            }
+        }
+
+        private static Dictionary<ConsoleColor, SolidColorBrush> _brushes = new Dictionary<ConsoleColor, SolidColorBrush>();
+
+        private static Color UnpackColor(ConsoleColor color)
+        {
+            var colorByte = (byte)color;
+            var isBright = (colorByte & 0b1000) >> 3 > 0;
+            var brightness = isBright ? (byte)255 : (byte)128;
+            var red = (colorByte & 0b0100) >> 2;
+            var green = (colorByte & 0b0010) >> 1;
+            var blue = (colorByte & 0b0001);
+
+            return new Color
+            {
+                R = (byte)(brightness * red),
+                G = (byte)(brightness * green),
+                B = (byte)(brightness * blue),
+                A = 255
+            };
+        }
+    }
+}

Torch.Server/ServerStatistics.cs

@@ -1,14 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using Torch.Collections;
-
-namespace Torch.Server
-{
-    public class ServerStatistics
-    {
-        public RollingAverage SimSpeed { get; } = new RollingAverage(30);
-    }
-}

Torch.Server/Themes/Dark Theme Animated.xaml

@@ -0,0 +1,17 @@
+<ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+                    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
+    <ResourceDictionary.MergedDictionaries>
+        <!-- MahApps.Metro resource dictionaries. Make sure that all file names are Case Sensitive! -->
+        <ResourceDictionary Source="pack://application:,,,/MahApps.Metro;component/Styles/Controls.xaml" />
+        <ResourceDictionary Source="pack://application:,,,/MahApps.Metro;component/Styles/Fonts.xaml" />
+        <ResourceDictionary Source="pack://application:,,,/MahApps.Metro;component/Styles/Colors.xaml" />
+        <!-- Accent and AppTheme setting -->
+        <ResourceDictionary Source="pack://application:,,,/MahApps.Metro;component/Styles/Accents/Blue.xaml" />
+        <ResourceDictionary Source="pack://application:,,,/MahApps.Metro;component/Styles/Accents/BaseDark.xaml" />
+        <ResourceDictionary Source="pack://application:,,,/MahApps.Metro;component/Styles/Controls.AnimatedSingleRowTabControl.xaml" />
+    </ResourceDictionary.MergedDictionaries>
+
+    <Style TargetType="Hyperlink" x:Name="LegalshtuffLink">
+        <Setter Property="NavigateUri" Value="https://github.com/MahApps/MahApps.Metro/blob/develop/LICENSE" />
+    </Style>
+</ResourceDictionary>

Torch.Server/Themes/Dark Theme.xaml

@@ -0,0 +1,85 @@
+<ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+                    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
+
+    <ResourceDictionary.MergedDictionaries>
+        <!-- MahApps.Metro resource dictionaries. Make sure that all file names are Case Sensitive! -->
+        <ResourceDictionary Source="pack://application:,,,/MahApps.Metro;component/Styles/Controls.xaml" />
+        <ResourceDictionary Source="pack://application:,,,/MahApps.Metro;component/Styles/Fonts.xaml" />
+        <ResourceDictionary Source="pack://application:,,,/MahApps.Metro;component/Styles/Colors.xaml" />
+        <!-- Accent and AppTheme setting -->
+        <ResourceDictionary Source="pack://application:,,,/MahApps.Metro;component/Styles/Accents/Blue.xaml" />
+        <ResourceDictionary Source="pack://application:,,,/MahApps.Metro;component/Styles/Accents/BaseDark.xaml" />
+    </ResourceDictionary.MergedDictionaries>
+
+    <Style TargetType="TabControl">
+        <Setter Property="Background" Value="Transparent"/>
+        <Setter Property="Template">
+            <Setter.Value>
+                <ControlTemplate TargetType="TabControl">
+                    <Grid ClipToBounds="true" SnapsToDevicePixels="true" KeyboardNavigation.TabNavigation="Local">
+                        <Grid.ColumnDefinitions>
+                            <ColumnDefinition x:Name="ColumnDefinition0"/>
+                            <ColumnDefinition x:Name="ColumnDefinition1" Width="0"/>
+                        </Grid.ColumnDefinitions>
+                        <Grid.RowDefinitions>
+                            <RowDefinition x:Name="RowDefinition0" Height="Auto"/>
+                            <RowDefinition x:Name="RowDefinition1" Height="*"/>
+                        </Grid.RowDefinitions>
+                        <StackPanel x:Name="HeaderPanel" Grid.Column="0" IsItemsHost="true" Margin="2,2,2,0" Grid.Row="0" KeyboardNavigation.TabIndex="1" Panel.ZIndex="1" Orientation="Horizontal"/>
+                        <Border x:Name="ContentPanel" BorderBrush="Transparent" BorderThickness="{TemplateBinding BorderThickness}" Background="Transparent" Grid.Column="0" KeyboardNavigation.DirectionalNavigation="Contained" Grid.Row="1" KeyboardNavigation.TabIndex="2" KeyboardNavigation.TabNavigation="Local">
+                            <ContentPresenter x:Name="PART_SelectedContentHost" ContentSource="SelectedContent" Margin="{TemplateBinding Padding}" SnapsToDevicePixels="{TemplateBinding SnapsToDevicePixels}"/>
+                        </Border>
+
+                        <ScrollViewer HorizontalScrollBarVisibility="Auto"  VerticalScrollBarVisibility="Hidden">
+                            <TabPanel x:Name="HeaderPanel2"
+                          Panel.ZIndex ="1" 
+                          KeyboardNavigation.TabIndex="1"
+                          Grid.Column="0"
+                          Grid.Row="0"
+                          Margin="2,2,2,0"
+                          IsItemsHost="true"/>
+                        </ScrollViewer>
+                    </Grid>
+                    <ControlTemplate.Triggers>
+                        <Trigger Property="TabStripPlacement" Value="Bottom">
+                            <Setter Property="Grid.Row" TargetName="HeaderPanel" Value="1"/>
+                            <Setter Property="Grid.Row" TargetName="ContentPanel" Value="0"/>
+                            <Setter Property="Height" TargetName="RowDefinition0" Value="*"/>
+                            <Setter Property="Height" TargetName="RowDefinition1" Value="Auto"/>
+                            <Setter Property="Margin" TargetName="HeaderPanel" Value="2,0,2,2"/>
+                        </Trigger>
+                        <Trigger Property="TabStripPlacement" Value="Left">
+                            <Setter Property="Grid.Row" TargetName="HeaderPanel" Value="0"/>
+                            <Setter Property="Grid.Row" TargetName="ContentPanel" Value="0"/>
+                            <Setter Property="Grid.Column" TargetName="HeaderPanel" Value="0"/>
+                            <Setter Property="Grid.Column" TargetName="ContentPanel" Value="1"/>
+                            <Setter Property="Width" TargetName="ColumnDefinition0" Value="Auto"/>
+                            <Setter Property="Width" TargetName="ColumnDefinition1" Value="*"/>
+                            <Setter Property="Height" TargetName="RowDefinition0" Value="*"/>
+                            <Setter Property="Height" TargetName="RowDefinition1" Value="0"/>
+                            <Setter Property="Margin" TargetName="HeaderPanel" Value="2,2,0,2"/>
+                        </Trigger>
+                        <Trigger Property="TabStripPlacement" Value="Right">
+                            <Setter Property="Grid.Row" TargetName="HeaderPanel" Value="0"/>
+                            <Setter Property="Grid.Row" TargetName="ContentPanel" Value="0"/>
+                            <Setter Property="Grid.Column" TargetName="HeaderPanel" Value="1"/>
+                            <Setter Property="Grid.Column" TargetName="ContentPanel" Value="0"/>
+                            <Setter Property="Width" TargetName="ColumnDefinition0" Value="*"/>
+                            <Setter Property="Width" TargetName="ColumnDefinition1" Value="Auto"/>
+                            <Setter Property="Height" TargetName="RowDefinition0" Value="*"/>
+                            <Setter Property="Height" TargetName="RowDefinition1" Value="0"/>
+                            <Setter Property="Margin" TargetName="HeaderPanel" Value="0,2,2,2"/>
+                        </Trigger>
+                        <Trigger Property="IsEnabled" Value="false">
+                            <Setter Property="Foreground" Value="{DynamicResource {x:Static SystemColors.GrayTextBrushKey}}"/>
+                        </Trigger>
+                    </ControlTemplate.Triggers>
+                </ControlTemplate>
+            </Setter.Value>
+        </Setter>
+    </Style>
+
+    <Style TargetType="Hyperlink" x:Name="LegalshtuffLink">
+        <Setter Property="NavigateUri" Value="https://github.com/MahApps/MahApps.Metro/blob/develop/LICENSE" />
+    </Style>
+</ResourceDictionary>

Torch.Server/Themes/Light Theme Animated.xaml

@@ -0,0 +1,19 @@
+<ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+                    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
+
+
+    <ResourceDictionary.MergedDictionaries>
+        <!-- MahApps.Metro resource dictionaries. Make sure that all file names are Case Sensitive! -->
+        <ResourceDictionary Source="pack://application:,,,/MahApps.Metro;component/Styles/Controls.xaml" />
+        <ResourceDictionary Source="pack://application:,,,/MahApps.Metro;component/Styles/Fonts.xaml" />
+        <ResourceDictionary Source="pack://application:,,,/MahApps.Metro;component/Styles/Colors.xaml" />
+        <!-- Accent and AppTheme setting -->
+        <ResourceDictionary Source="pack://application:,,,/MahApps.Metro;component/Styles/Accents/Blue.xaml" />
+        <ResourceDictionary Source="pack://application:,,,/MahApps.Metro;component/Styles/Accents/BaseLight.xaml" />
+        <ResourceDictionary Source="pack://application:,,,/MahApps.Metro;component/Styles/Controls.AnimatedSingleRowTabControl.xaml" />
+    </ResourceDictionary.MergedDictionaries>
+
+    <Style TargetType="Hyperlink" x:Name="LegalshtuffLink">
+        <Setter Property="NavigateUri" Value="https://github.com/MahApps/MahApps.Metro/blob/develop/LICENSE" />
+    </Style>
+</ResourceDictionary>

Torch.Server/Themes/Light Theme.xaml

@@ -0,0 +1,85 @@
+<ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+                    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
+
+    <ResourceDictionary.MergedDictionaries>
+        <!-- MahApps.Metro resource dictionaries. Make sure that all file names are Case Sensitive! -->
+        <ResourceDictionary Source="pack://application:,,,/MahApps.Metro;component/Styles/Controls.xaml" />
+        <ResourceDictionary Source="pack://application:,,,/MahApps.Metro;component/Styles/Fonts.xaml" />
+        <ResourceDictionary Source="pack://application:,,,/MahApps.Metro;component/Styles/Colors.xaml" />
+        <!-- Accent and AppTheme setting -->
+        <ResourceDictionary Source="pack://application:,,,/MahApps.Metro;component/Styles/Accents/Blue.xaml" />
+        <ResourceDictionary Source="pack://application:,,,/MahApps.Metro;component/Styles/Accents/BaseLight.xaml" />
+    </ResourceDictionary.MergedDictionaries>
+
+    <Style TargetType="TabControl">
+        <Setter Property="Background" Value="Transparent"/>
+        <Setter Property="Template">
+            <Setter.Value>
+                <ControlTemplate TargetType="TabControl">
+                    <Grid ClipToBounds="true" SnapsToDevicePixels="true" KeyboardNavigation.TabNavigation="Local">
+                        <Grid.ColumnDefinitions>
+                            <ColumnDefinition x:Name="ColumnDefinition0"/>
+                            <ColumnDefinition x:Name="ColumnDefinition1" Width="0"/>
+                        </Grid.ColumnDefinitions>
+                        <Grid.RowDefinitions>
+                            <RowDefinition x:Name="RowDefinition0" Height="Auto"/>
+                            <RowDefinition x:Name="RowDefinition1" Height="*"/>
+                        </Grid.RowDefinitions>
+                        <StackPanel x:Name="HeaderPanel" Grid.Column="0" IsItemsHost="true" Margin="2,2,2,0" Grid.Row="0" KeyboardNavigation.TabIndex="1" Panel.ZIndex="1" Orientation="Horizontal"/>
+                        <Border x:Name="ContentPanel" BorderBrush="Transparent" BorderThickness="{TemplateBinding BorderThickness}" Background="Transparent" Grid.Column="0" KeyboardNavigation.DirectionalNavigation="Contained" Grid.Row="1" KeyboardNavigation.TabIndex="2" KeyboardNavigation.TabNavigation="Local">
+                            <ContentPresenter x:Name="PART_SelectedContentHost" ContentSource="SelectedContent" Margin="{TemplateBinding Padding}" SnapsToDevicePixels="{TemplateBinding SnapsToDevicePixels}"/>
+                        </Border>
+
+                        <ScrollViewer HorizontalScrollBarVisibility="Auto"  VerticalScrollBarVisibility="Hidden">
+                            <TabPanel x:Name="HeaderPanel2"
+                          Panel.ZIndex ="1" 
+                          KeyboardNavigation.TabIndex="1"
+                          Grid.Column="0"
+                          Grid.Row="0"
+                          Margin="2,2,2,0"
+                          IsItemsHost="true"/>
+                        </ScrollViewer>
+                    </Grid>
+                    <ControlTemplate.Triggers>
+                        <Trigger Property="TabStripPlacement" Value="Bottom">
+                            <Setter Property="Grid.Row" TargetName="HeaderPanel" Value="1"/>
+                            <Setter Property="Grid.Row" TargetName="ContentPanel" Value="0"/>
+                            <Setter Property="Height" TargetName="RowDefinition0" Value="*"/>
+                            <Setter Property="Height" TargetName="RowDefinition1" Value="Auto"/>
+                            <Setter Property="Margin" TargetName="HeaderPanel" Value="2,0,2,2"/>
+                        </Trigger>
+                        <Trigger Property="TabStripPlacement" Value="Left">
+                            <Setter Property="Grid.Row" TargetName="HeaderPanel" Value="0"/>
+                            <Setter Property="Grid.Row" TargetName="ContentPanel" Value="0"/>
+                            <Setter Property="Grid.Column" TargetName="HeaderPanel" Value="0"/>
+                            <Setter Property="Grid.Column" TargetName="ContentPanel" Value="1"/>
+                            <Setter Property="Width" TargetName="ColumnDefinition0" Value="Auto"/>
+                            <Setter Property="Width" TargetName="ColumnDefinition1" Value="*"/>
+                            <Setter Property="Height" TargetName="RowDefinition0" Value="*"/>
+                            <Setter Property="Height" TargetName="RowDefinition1" Value="0"/>
+                            <Setter Property="Margin" TargetName="HeaderPanel" Value="2,2,0,2"/>
+                        </Trigger>
+                        <Trigger Property="TabStripPlacement" Value="Right">
+                            <Setter Property="Grid.Row" TargetName="HeaderPanel" Value="0"/>
+                            <Setter Property="Grid.Row" TargetName="ContentPanel" Value="0"/>
+                            <Setter Property="Grid.Column" TargetName="HeaderPanel" Value="1"/>
+                            <Setter Property="Grid.Column" TargetName="ContentPanel" Value="0"/>
+                            <Setter Property="Width" TargetName="ColumnDefinition0" Value="*"/>
+                            <Setter Property="Width" TargetName="ColumnDefinition1" Value="Auto"/>
+                            <Setter Property="Height" TargetName="RowDefinition0" Value="*"/>
+                            <Setter Property="Height" TargetName="RowDefinition1" Value="0"/>
+                            <Setter Property="Margin" TargetName="HeaderPanel" Value="0,2,2,2"/>
+                        </Trigger>
+                        <Trigger Property="IsEnabled" Value="false">
+                            <Setter Property="Foreground" Value="{DynamicResource {x:Static SystemColors.GrayTextBrushKey}}"/>
+                        </Trigger>
+                    </ControlTemplate.Triggers>
+                </ControlTemplate>
+            </Setter.Value>
+        </Setter>
+    </Style>
+
+    <Style TargetType="Hyperlink" x:Name="LegalshtuffLink">
+        <Setter Property="NavigateUri" Value="https://github.com/MahApps/MahApps.Metro/blob/develop/LICENSE" />
+    </Style>
+</ResourceDictionary>

Torch.Server/Torch.Server.csproj

@@ -2,8 +2,6 @@
 <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>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
     <ProjectGuid>{CA50886B-7B22-4CD8-93A0-C06F38D4F77D}</ProjectGuid>
     <OutputType>Exe</OutputType>
     <AppDesignerFolder>Properties</AppDesignerFolder>
@@ -15,10 +13,27 @@
     <WarningLevel>4</WarningLevel>
     <AutoGenerateBindingRedirects>true</AutoGenerateBindingRedirects>
     <TargetFrameworkProfile />
+    <NuGetPackageImportStamp>
+    </NuGetPackageImportStamp>
+    <PublishUrl>publish\</PublishUrl>
+    <Install>true</Install>
+    <InstallFrom>Disk</InstallFrom>
+    <UpdateEnabled>false</UpdateEnabled>
+    <UpdateMode>Foreground</UpdateMode>
+    <UpdateInterval>7</UpdateInterval>
+    <UpdateIntervalUnits>Days</UpdateIntervalUnits>
+    <UpdatePeriodically>false</UpdatePeriodically>
+    <UpdateRequired>false</UpdateRequired>
+    <MapFileExtensions>true</MapFileExtensions>
+    <ApplicationRevision>0</ApplicationRevision>
+    <ApplicationVersion>1.0.0.%2a</ApplicationVersion>
+    <IsWebBootstrapper>false</IsWebBootstrapper>
+    <UseApplicationTrust>false</UseApplicationTrust>
+    <BootstrapperEnabled>true</BootstrapperEnabled>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x64'">
     <DebugSymbols>true</DebugSymbols>
-    <OutputPath>bin\x64\Debug\</OutputPath>
+    <OutputPath>$(SolutionDir)\bin\x64\Debug\</OutputPath>
     <DefineConstants>DEBUG;TRACE</DefineConstants>
     <DebugType>full</DebugType>
     <PlatformTarget>x64</PlatformTarget>
@@ -27,7 +42,7 @@
     <Prefer32Bit>true</Prefer32Bit>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x64'">
-    <OutputPath>bin\x64\Release\</OutputPath>
+    <OutputPath>$(SolutionDir)\bin\x64\Release\</OutputPath>
     <DefineConstants>TRACE</DefineConstants>
     <Optimize>true</Optimize>
     <DebugType>pdbonly</DebugType>
@@ -35,7 +50,7 @@
     <ErrorReport>prompt</ErrorReport>
     <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
     <Prefer32Bit>true</Prefer32Bit>
-    <DocumentationFile>bin\x64\Release\Torch.Server.xml</DocumentationFile>
+    <DocumentationFile>$(SolutionDir)\bin\x64\Release\Torch.Server.xml</DocumentationFile>
   </PropertyGroup>
   <PropertyGroup>
     <StartupObject>Torch.Server.Program</StartupObject>
@@ -44,11 +59,17 @@
     <ApplicationIcon>torchicon.ico</ApplicationIcon>
   </PropertyGroup>
   <ItemGroup>
+    <Reference Include="ControlzEx, Version=3.0.2.4, Culture=neutral, processorArchitecture=MSIL">
+      <HintPath>..\packages\ControlzEx.3.0.2.4\lib\net45\ControlzEx.dll</HintPath>
+    </Reference>
     <Reference Include="HavokWrapper, Version=1.0.6051.28726, Culture=neutral, processorArchitecture=AMD64">
       <SpecificVersion>False</SpecificVersion>
       <HintPath>..\GameBinaries\HavokWrapper.dll</HintPath>
       <Private>False</Private>
     </Reference>
+    <Reference Include="MahApps.Metro, Version=1.6.1.4, Culture=neutral, processorArchitecture=MSIL">
+      <HintPath>..\packages\MahApps.Metro.1.6.1\lib\net45\MahApps.Metro.dll</HintPath>
+    </Reference>
     <Reference Include="Microsoft.CodeAnalysis, Version=1.2.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
       <HintPath>..\GameBinaries\Microsoft.CodeAnalysis.dll</HintPath>
@@ -63,7 +84,8 @@
       <HintPath>..\packages\Newtonsoft.Json.10.0.3\lib\net45\Newtonsoft.Json.dll</HintPath>
     </Reference>
     <Reference Include="NLog, Version=4.0.0.0, Culture=neutral, PublicKeyToken=5120e14c03d0593c, processorArchitecture=MSIL">
-      <HintPath>..\packages\NLog.4.4.11\lib\net45\NLog.dll</HintPath>
+      <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>
@@ -95,18 +117,20 @@
       <HintPath>..\GameBinaries\SpaceEngineers.ObjectBuilders.XmlSerializers.dll</HintPath>
       <Private>False</Private>
     </Reference>
-    <Reference Include="SteamSDK, Version=0.0.0.0, Culture=neutral, processorArchitecture=AMD64">
+    <Reference Include="Steamworks.NET">
-      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\GameBinaries\Steamworks.NET.dll</HintPath>
-      <HintPath>..\GameBinaries\SteamSDK.dll</HintPath>
-      <Private>False</Private>
     </Reference>
     <Reference Include="System" />
+    <Reference Include="System.ComponentModel.DataAnnotations" />
     <Reference Include="System.Configuration.Install" />
     <Reference Include="System.Data" />
     <Reference Include="System.Drawing" />
     <Reference Include="System.IO.Compression.FileSystem" />
     <Reference Include="System.ServiceProcess" />
     <Reference Include="System.Windows.Forms" />
+    <Reference Include="System.Windows.Interactivity, Version=4.5.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
+      <HintPath>..\packages\ControlzEx.3.0.2.4\lib\net45\System.Windows.Interactivity.dll</HintPath>
+    </Reference>
     <Reference Include="System.Xml" />
     <Reference Include="Microsoft.CSharp" />
     <Reference Include="System.Core" />
@@ -124,6 +148,7 @@
     <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, Version=1.0.0.0, Culture=neutral, processorArchitecture=AMD64">
       <SpecificVersion>False</SpecificVersion>
@@ -180,20 +205,30 @@
       <HintPath>..\GameBinaries\VRage.Scripting.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="Managers\InstanceManager.cs" />
+    <Compile Include="..\Versioning\AssemblyVersion.cs">
-    <Compile Include="NativeMethods.cs" />
+      <Link>Properties\AssemblyVersion.cs</Link>
-    <Compile Include="Properties\AssemblyInfo.cs">
-      <AutoGen>True</AutoGen>
-      <DesignTime>True</DesignTime>
-      <DependentUpon>AssemblyInfo.tt</DependentUpon>
     </Compile>
-    <Compile Include="Properties\AssemblyInfo1.cs" />
+    <Compile Include="Commands\WhitelistCommands.cs" />
-    <Compile Include="ServerStatistics.cs" />
+    <Compile Include="FlowDocumentTarget.cs" />
+    <Compile Include="ListBoxExtensions.cs" />
+    <Compile Include="Managers\EntityControlManager.cs" />
+    <Compile Include="Managers\MultiplayerManagerDedicated.cs" />
+    <Compile Include="Managers\InstanceManager.cs" />
+    <Compile Include="Managers\MultiplayerManagerDedicatedEventShim.cs" />
+    <Compile Include="Managers\MultiplayerManagerDedicatedPatchShim.cs" />
+    <Compile Include="NativeMethods.cs" />
+    <Compile Include="Initializer.cs" />
+    <Compile Include="Properties\Annotations.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="TorchConfig.cs" />
     <Compile Include="TorchService.cs">
       <SubType>Component</SubType>
@@ -202,11 +237,32 @@
       <SubType>Component</SubType>
     </Compile>
     <Compile Include="ViewModels\BlockLimitViewModel.cs" />
+    <Compile Include="ViewModels\CheckpointViewModel.cs" />
     <Compile Include="ViewModels\Entities\Blocks\BlockViewModel.cs" />
     <Compile Include="ViewModels\Entities\Blocks\BlockViewModelGenerator.cs" />
     <Compile Include="ViewModels\Entities\Blocks\PropertyViewModel.cs" />
     <Compile Include="ViewModels\Entities\CharacterViewModel.cs" />
     <Compile Include="ViewModels\ConfigDedicatedViewModel.cs" />
+    <Compile Include="ViewModels\Entities\EntityControlViewModel.cs" />
+    <Compile Include="ViewModels\SessionSettingsViewModel.cs" />
+    <Compile Include="Views\Converters\DefinitionToIdConverter.cs" />
+    <Compile Include="Views\Converters\BooleanAndConverter.cs" />
+    <Compile Include="Views\Converters\ListConverter.cs" />
+    <Compile Include="MultiTextWriter.cs" />
+    <Compile Include="RichTextBoxWriter.cs" />
+    <Compile Include="Views\Entities\CharacterView.xaml.cs">
+      <DependentUpon>CharacterView.xaml</DependentUpon>
+    </Compile>
+    <Compile Include="Views\ThemeControl.xaml.cs">
+      <DependentUpon>ThemeControl.xaml</DependentUpon>
+    </Compile>
+    <Compile Include="Views\ValidationRules\ListConverterValidationRule.cs" />
+    <Compile Include="Views\Entities\EntityControlHost.xaml.cs">
+      <DependentUpon>EntityControlHost.xaml</DependentUpon>
+    </Compile>
+    <Compile Include="Views\Entities\EntityControlsView.xaml.cs">
+      <DependentUpon>EntityControlsView.xaml</DependentUpon>
+    </Compile>
     <Compile Include="ViewModels\EntityTreeViewModel.cs" />
     <Compile Include="ViewModels\Entities\EntityViewModel.cs" />
     <Compile Include="ViewModels\Entities\FloatingObjectViewModel.cs" />
@@ -214,7 +270,6 @@
     <Compile Include="ViewModels\ILazyLoad.cs" />
     <Compile Include="ViewModels\PluginManagerViewModel.cs" />
     <Compile Include="ViewModels\PluginViewModel.cs" />
-    <Compile Include="ViewModels\SessionSettingsViewModel.cs" />
     <Compile Include="ViewModels\Entities\VoxelMapViewModel.cs" />
     <Compile Include="ViewModels\SteamUserViewModel.cs" />
     <Compile Include="Views\AddWorkshopItemsDialog.xaml.cs">
@@ -245,15 +300,15 @@
     <Compile Include="Views\Entities\VoxelMapView.xaml.cs">
       <DependentUpon>VoxelMapView.xaml</DependentUpon>
     </Compile>
-    <Compile Include="Views\FirstTimeSetup.xaml.cs">
-      <DependentUpon>FirstTimeSetup.xaml</DependentUpon>
-    </Compile>
     <Compile Include="Views\ModsControl.xaml.cs">
       <DependentUpon>ModsControl.xaml</DependentUpon>
     </Compile>
     <Compile Include="Views\PluginsControl.xaml.cs">
       <DependentUpon>PluginsControl.xaml</DependentUpon>
     </Compile>
+    <Compile Include="Views\SessionSettingsView.xaml.cs">
+      <DependentUpon>SessionSettingsView.xaml</DependentUpon>
+    </Compile>
     <Compile Include="Views\TorchUI.xaml.cs">
       <DependentUpon>TorchUI.xaml</DependentUpon>
     </Compile>
@@ -262,6 +317,10 @@
     </Compile>
     <Compile Include="Program.cs" />
     <Compile Include="TorchServer.cs" />
+    <Compile Include="Views\ValidationRules\NumberValidationRule.cs" />
+    <Compile Include="Views\WorldGeneratorDialog.xaml.cs">
+      <DependentUpon>WorldGeneratorDialog.xaml</DependentUpon>
+    </Compile>
   </ItemGroup>
   <ItemGroup>
     <Compile Include="Properties\Resources.Designer.cs">
@@ -289,15 +348,39 @@
     <ProjectReference Include="..\Torch.API\Torch.API.csproj">
       <Project>{fba5d932-6254-4a1e-baf4-e229fa94e3c2}</Project>
       <Name>Torch.API</Name>
-      <Private>True</Private>
+      <Private>False</Private>
     </ProjectReference>
     <ProjectReference Include="..\Torch\Torch.csproj">
       <Project>{7e01635c-3b67-472e-bcd6-c5539564f214}</Project>
       <Name>Torch</Name>
-      <Private>True</Private>
+      <Private>False</Private>
     </ProjectReference>
   </ItemGroup>
   <ItemGroup>
+    <Page Include="Themes\Dark Theme Animated.xaml">
+      <Generator>MSBuild:Compile</Generator>
+      <SubType>Designer</SubType>
+    </Page>
+    <Page Include="Themes\Dark Theme.xaml">
+      <Generator>MSBuild:Compile</Generator>
+      <SubType>Designer</SubType>
+    </Page>
+    <Page Include="Themes\Light Theme Animated.xaml">
+      <Generator>MSBuild:Compile</Generator>
+      <SubType>Designer</SubType>
+    </Page>
+    <Page Include="Themes\Light Theme.xaml">
+      <Generator>MSBuild:Compile</Generator>
+      <SubType>Designer</SubType>
+    </Page>
+    <Page Include="Views\Entities\EntityControlHost.xaml">
+      <SubType>Designer</SubType>
+      <Generator>MSBuild:Compile</Generator>
+    </Page>
+    <Page Include="Views\Entities\EntityControlsView.xaml">
+      <SubType>Designer</SubType>
+      <Generator>MSBuild:Compile</Generator>
+    </Page>
     <Page Include="Views\AddWorkshopItemsDialog.xaml">
       <SubType>Designer</SubType>
       <Generator>MSBuild:Compile</Generator>
@@ -322,26 +405,38 @@
       <SubType>Designer</SubType>
       <Generator>MSBuild:Compile</Generator>
     </Page>
+    <Page Include="Views\Entities\CharacterView.xaml">
+      <Generator>MSBuild:Compile</Generator>
+      <SubType>Designer</SubType>
+    </Page>
     <Page Include="Views\Entities\GridView.xaml">
       <SubType>Designer</SubType>
       <Generator>MSBuild:Compile</Generator>
     </Page>
+    <Page Include="Views\PluginsControl.xaml">
+      <SubType>Designer</SubType>
+      <Generator>MSBuild:Compile</Generator>
+    </Page>
     <Page Include="Views\Entities\VoxelMapView.xaml">
       <SubType>Designer</SubType>
       <Generator>MSBuild:Compile</Generator>
     </Page>
-    <Page Include="Views\FirstTimeSetup.xaml">
-      <SubType>Designer</SubType>
-      <Generator>MSBuild:Compile</Generator>
-    </Page>
     <Page Include="Views\ModsControl.xaml">
       <SubType>Designer</SubType>
       <Generator>MSBuild:Compile</Generator>
     </Page>
-    <Page Include="Views\PluginsControl.xaml">
+    <Page Include="Views\Resources.xaml">
       <SubType>Designer</SubType>
       <Generator>MSBuild:Compile</Generator>
     </Page>
+    <Page Include="Views\SessionSettingsView.xaml">
+      <SubType>Designer</SubType>
+      <Generator>MSBuild:Compile</Generator>
+    </Page>
+    <Page Include="Views\ThemeControl.xaml">
+      <Generator>MSBuild:Compile</Generator>
+      <SubType>Designer</SubType>
+    </Page>
     <Page Include="Views\TorchUI.xaml">
       <Generator>MSBuild:Compile</Generator>
       <SubType>Designer</SubType>
@@ -350,6 +445,10 @@
       <Generator>MSBuild:Compile</Generator>
       <SubType>Designer</SubType>
     </Page>
+    <Page Include="Views\WorldGeneratorDialog.xaml">
+      <SubType>Designer</SubType>
+      <Generator>MSBuild:Compile</Generator>
+    </Page>
   </ItemGroup>
   <ItemGroup>
     <Resource Include="torchicon.ico" />
@@ -358,23 +457,20 @@
     <Service Include="{508349B6-6B84-4DF5-91F0-309BEEBAD82D}" />
   </ItemGroup>
   <ItemGroup>
-    <Content Include="Properties\AssemblyInfo.tt">
+    <BootstrapperPackage Include=".NETFramework,Version=v4.6.1">
-      <Generator>TextTemplatingFileGenerator</Generator>
+      <Visible>False</Visible>
-      <LastGenOutput>AssemblyInfo.cs</LastGenOutput>
+      <ProductName>Microsoft .NET Framework 4.6.1 %28x86 and x64%29</ProductName>
-    </Content>
+      <Install>true</Install>
+    </BootstrapperPackage>
+    <BootstrapperPackage Include="Microsoft.Net.Framework.3.5.SP1">
+      <Visible>False</Visible>
+      <ProductName>.NET Framework 3.5 SP1</ProductName>
+      <Install>false</Install>
+    </BootstrapperPackage>
   </ItemGroup>
-  <ItemGroup />
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <Import Project="$(SolutionDir)\TransformOnBuild.targets" />
   <PropertyGroup>
-    <PostBuildEvent>cd "$(TargetDir)"
+    <PostBuildEvent>copy "$(SolutionDir)NLog.config" "$(TargetDir)"</PostBuildEvent>
-copy "$(SolutionDir)NLog.config" "$(TargetDir)"
-"Torch Server Release.bat"</PostBuildEvent>
   </PropertyGroup>
-  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
-       Other similar extension points exist, see Microsoft.Common.targets.
-  <Target Name="BeforeBuild">
-  </Target>
-  <Target Name="AfterBuild">
-  </Target>
-  -->
 </Project>

Torch.Server/TorchConfig.cs

@@ -8,6 +8,7 @@ using NLog;
 
 namespace Torch.Server
 {
+    // TODO: redesign this gerbage
     public class TorchConfig : CommandLine, ITorchConfig
     {
         private static Logger _log = LogManager.GetLogger("Config");
@@ -59,8 +60,22 @@ namespace Torch.Server
         /// <inheritdoc />
         public List<string> Plugins { get; set; } = new List<string>();
 
+        public bool EnableWhitelist { get; set; } = false;
+        public HashSet<ulong> Whitelist { get; set; } = new HashSet<ulong>();
+
         internal Point WindowSize { get; set; } = new Point(800, 600);
         internal Point WindowPosition { get; set; } = new Point();
+
+        public string LastUsedTheme { get; set; } = "Torch Theme";
+
+        //TODO: REMOVE ME BY JULY 2019
+        [Obsolete("Use vanilla reserved slot config")]
+        public HashSet<ulong> ReservedPlayers { get; set; } = new HashSet<ulong>();
+
+        //Prevent reserved players being written to disk, but allow it to bre read
+        //remove this when ReservedPlayers is removed
+        private bool ShouldSerializeReservedPlayers() => false;
+
         [XmlIgnore]
         private string _path;
 

Torch.Server/TorchServer.cs

@@ -1,124 +1,108 @@
-using Sandbox;
+#region
-using Sandbox.Engine.Utils;
+
-using Sandbox.Game;
-using Sandbox.Game.World;
 using System;
+using System.Collections.Generic;
 using System.Diagnostics;
-using System.Globalization;
+using System.Net;
-using System.IO;
 using System.Reflection;
-using System.Runtime.CompilerServices;
+using System.Text;
-using System.Security.Principal;
 using System.Threading;
 using System.Threading.Tasks;
-using Microsoft.Xml.Serialization.GeneratedAssembly;
+using System.Windows.Forms;
-using Sandbox.Engine.Analytics;
+using NLog;
+using Sandbox;
+using Sandbox.Engine.Networking;
 using Sandbox.Game.Multiplayer;
-using Sandbox.ModAPI;
+using Sandbox.Game.World;
-using SteamSDK;
 using Torch.API;
-using Torch.Managers;
+using Torch.API.Managers;
+using Torch.API.Session;
+using Torch.Commands;
+using Torch.Mod;
+using Torch.Server.Commands;
 using Torch.Server.Managers;
+using Torch.Utils;
+using VRage;
 using VRage.Dedicated;
-using VRage.FileSystem;
+using VRage.Dedicated.RemoteAPI;
-using VRage.Game;
+using VRage.GameServices;
-using VRage.Game.ModAPI;
+using VRage.Steam;
-using VRage.Game.ObjectBuilder;
+using Timer = System.Threading.Timer;
-using VRage.Game.SessionComponents;
+
-using VRage.Library;
+#endregion
-using VRage.ObjectBuilders;
+
-using VRage.Plugins;
-using VRage.Utils;
 #pragma warning disable 618
 
 namespace Torch.Server
 {
     public class TorchServer : TorchBase, ITorchServer
     {
-        //public MyConfigDedicated<MyObjectBuilder_SessionSettings> DedicatedConfig { get; set; }
+        private bool _canRun;
-        public float SimulationRatio { get => _simRatio; set { _simRatio = value; OnPropertyChanged(); } }
-        public TimeSpan ElapsedPlayTime { get => _elapsedPlayTime; set { _elapsedPlayTime = value; OnPropertyChanged(); } }
-        public Thread GameThread { get; private set; }
-        public ServerState State { get => _state; private set { _state = value; OnPropertyChanged(); } }
-        public bool IsRunning { get => _isRunning; set { _isRunning = value; OnPropertyChanged(); } }
-        public InstanceManager DedicatedInstance { get; }
-        /// <inheritdoc />
-        public string InstanceName => Config?.InstanceName;
-        /// <inheritdoc />
-        public string InstancePath => Config?.InstancePath;
-
-        private bool _isRunning;
-        private ServerState _state;
         private TimeSpan _elapsedPlayTime;
+        private bool _hasRun;
+        private bool _isRunning;
         private float _simRatio;
-        private readonly AutoResetEvent _stopHandle = new AutoResetEvent(false);
+        private ServerState _state;
-        private Timer _watchdog;
         private Stopwatch _uptime;
+        private Timer _watchdog;
 
+        /// <inheritdoc />
        public TorchServer(TorchConfig config = null)
         {
             DedicatedInstance = new InstanceManager(this);
             AddManager(DedicatedInstance);
+            AddManager(new EntityControlManager(this));
             Config = config ?? new TorchConfig();
-            MyFakes.ENABLE_INFINARIO = false;
+
+            var sessionManager = Managers.GetManager<ITorchSessionManager>();
+            sessionManager.AddFactory(x => new MultiplayerManagerDedicated(this));
         }
 
+        /// <inheritdoc />
+        public float SimulationRatio { get => _simRatio; set => SetValue(ref _simRatio, value); }
+
+        /// <inheritdoc />
+        public TimeSpan ElapsedPlayTime { get => _elapsedPlayTime; set => SetValue(ref _elapsedPlayTime, value); }
+
+        /// <inheritdoc />
+        public Thread GameThread { get; private set; }
+
+        /// <inheritdoc />
+        public bool IsRunning { get => _isRunning; set => SetValue(ref _isRunning, value); }
+
+        public bool CanRun { get => _canRun; set => SetValue(ref _canRun, value); }
+
+        /// <inheritdoc />
+        public InstanceManager DedicatedInstance { get; }
+
+        /// <inheritdoc />
+        public string InstanceName => Config?.InstanceName;
+
+        /// <inheritdoc />
+        protected override uint SteamAppId => 244850;
+
+        /// <inheritdoc />
+        protected override string SteamAppName => "SpaceEngineersDedicated";
+
+        /// <inheritdoc />
+        public ServerState State { get => _state; private set => SetValue(ref _state, value); }
+
+        public event Action<ITorchServer> Initialized;
+
+        /// <inheritdoc />
+        public string InstancePath => Config?.InstancePath;
+
         /// <inheritdoc />
         public override void Init()
         {
-            Log.Info($"Init server '{Config.InstanceName}' at '{Config.InstancePath}'");
+            Log.Info("Initializing server");
+            MySandboxGame.IsDedicated = true;
             base.Init();
-
+            Managers.GetManager<ITorchSessionManager>().SessionStateChanged += OnSessionStateChanged;
-            MyPerGameSettings.SendLogToKeen = false;
+            GetManager<InstanceManager>().LoadInstance(Config.InstancePath);
-            MyPerServerSettings.GameName = MyPerGameSettings.GameName;
+            CanRun = true;
-            MyPerServerSettings.GameNameSafe = MyPerGameSettings.GameNameSafe;
+            Initialized?.Invoke(this);
-            MyPerServerSettings.GameDSName = MyPerServerSettings.GameNameSafe + "Dedicated";
+            Log.Info($"Initialized server '{Config.InstanceName}' at '{Config.InstancePath}'");
-            MyPerServerSettings.GameDSDescription = "Your place for space engineering, destruction and exploring.";
-            MySessionComponentExtDebug.ForceDisable = true;
-            MyPerServerSettings.AppId = 244850;
-            MyFinalBuildConstants.APP_VERSION = MyPerGameSettings.BasicGameInfo.GameVersion;
-
-            MyObjectBuilderSerializer.RegisterFromAssembly(typeof(MyObjectBuilder_CheckpointSerializer).Assembly);
-            InvokeBeforeRun();
-
-            MyPlugins.RegisterGameAssemblyFile(MyPerGameSettings.GameModAssembly);
-            MyPlugins.RegisterGameObjectBuildersAssemblyFile(MyPerGameSettings.GameModObjBuildersAssembly);
-            MyPlugins.RegisterSandboxAssemblyFile(MyPerGameSettings.SandboxAssembly);
-            MyPlugins.RegisterSandboxGameAssemblyFile(MyPerGameSettings.SandboxGameAssembly);
-            MyPlugins.Load();
-            MyGlobalTypeMetadata.Static.Init();
-
-            Plugins.LoadPlugins();
-        }
-
-        private void InvokeBeforeRun()
-        {
-            MySandboxGame.Log.Init("SpaceEngineers-Dedicated.log", MyFinalBuildConstants.APP_VERSION_STRING);
-            MySandboxGame.Log.WriteLine("Steam build: Always true");
-            MySandboxGame.Log.WriteLine("Environment.ProcessorCount: " + MyEnvironment.ProcessorCount);
-            //MySandboxGame.Log.WriteLine("Environment.OSVersion: " + GetOsName());
-            MySandboxGame.Log.WriteLine("Environment.CommandLine: " + Environment.CommandLine);
-            MySandboxGame.Log.WriteLine("Environment.Is64BitProcess: " + MyEnvironment.Is64BitProcess);
-            MySandboxGame.Log.WriteLine("Environment.Is64BitOperatingSystem: " + Environment.Is64BitOperatingSystem);
-            //MySandboxGame.Log.WriteLine("Environment.Version: " + GetNETFromRegistry());
-            MySandboxGame.Log.WriteLine("Environment.CurrentDirectory: " + Environment.CurrentDirectory);
-            MySandboxGame.Log.WriteLine("MainAssembly.ProcessorArchitecture: " + Assembly.GetExecutingAssembly().GetArchitecture());
-            MySandboxGame.Log.WriteLine("ExecutingAssembly.ProcessorArchitecture: " + MyFileSystem.MainAssembly.GetArchitecture());
-            MySandboxGame.Log.WriteLine("IntPtr.Size: " + IntPtr.Size);
-            MySandboxGame.Log.WriteLine("Default Culture: " + CultureInfo.CurrentCulture.Name);
-            MySandboxGame.Log.WriteLine("Default UI Culture: " + CultureInfo.CurrentUICulture.Name);
-            MySandboxGame.Log.WriteLine("IsAdmin: " + new WindowsPrincipal(WindowsIdentity.GetCurrent()).IsInRole(WindowsBuiltInRole.Administrator));
-
-            MyLog.Default = MySandboxGame.Log;
-
-            Thread.CurrentThread.Name = "Main thread";
-
-            //Because we want exceptions from users to be in english
-            Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;
-            Thread.CurrentThread.CurrentUICulture = CultureInfo.InvariantCulture;
-
-            MySandboxGame.Config = new MyConfig("SpaceEngineers-Dedicated.cfg");
-            MySandboxGame.Config.Load();
         }
 
         /// <inheritdoc />
@@ -127,64 +111,26 @@ namespace Torch.Server
             if (State != ServerState.Stopped)
                 return;
 
-            DedicatedInstance.SaveConfig();
+            if (_hasRun)
-            _uptime = Stopwatch.StartNew();
+            {
-            IsRunning = true;
+                Restart();
-            GameThread = Thread.CurrentThread;
+                return;
-            Config.Save();
+            }
+
             State = ServerState.Starting;
+            IsRunning = true;
+            CanRun = false;
+            _hasRun = true;
             Log.Info("Starting server.");
+            MySandboxGame.ConfigDedicated = DedicatedInstance.DedicatedConfig.Model;
+            if (MySandboxGame.ConfigDedicated.RemoteApiEnabled && !string.IsNullOrEmpty(MySandboxGame.ConfigDedicated.RemoteSecurityKey))
+            {
+                var myRemoteServer = new MyRemoteServer(MySandboxGame.ConfigDedicated.RemoteApiPort, MySandboxGame.ConfigDedicated.RemoteSecurityKey);
+                Log.Info($"Remote API started on port {myRemoteServer.Port}");
+            }
             
-            var runInternal = typeof(DedicatedServer).GetMethod("RunInternal", BindingFlags.Static | BindingFlags.NonPublic);
+            _uptime = Stopwatch.StartNew();
-
-            MySandboxGame.IsDedicated = true;
-            Environment.SetEnvironmentVariable("SteamAppId", MyPerServerSettings.AppId.ToString());
-
-            VRage.Service.ExitListenerSTA.OnExit += delegate { MySandboxGame.Static?.Exit(); };
-
             base.Start();
-            runInternal.Invoke(null, null);
-
-            MySandboxGame.Log.Close();
-            State = ServerState.Stopped;
-        }
-
-        /// <inheritdoc />
-        public override void Init(object gameInstance)
-        {
-            base.Init(gameInstance);
-            State = ServerState.Running;
-            SteamServerAPI.Instance.GameServer.SetKeyValue("SM", "Torch");
-        }
-
-        /// <inheritdoc />
-        public override void Update()
-        {
-            base.Update();
-            SimulationRatio = Sync.ServerSimulationRatio;
-            var elapsed = TimeSpan.FromSeconds(Math.Floor(_uptime.Elapsed.TotalSeconds));
-            ElapsedPlayTime = elapsed;
-
-            if (_watchdog == null && Config.TickTimeout > 0)
-            {
-                Log.Info("Starting server watchdog.");
-                _watchdog = new Timer(CheckServerResponding, this, TimeSpan.Zero, TimeSpan.FromSeconds(Config.TickTimeout));
-            }
-        }
-
-        private static void CheckServerResponding(object state)
-        {
-            var mre = new ManualResetEvent(false);
-            ((TorchServer)state).Invoke(() => mre.Set());
-            if (!mre.WaitOne(TimeSpan.FromSeconds(Instance.Config.TickTimeout)))
-            {
-                var mainThread = MySandboxGame.Static.UpdateThread;
-                mainThread.Suspend();
-                var stackTrace = new StackTrace(mainThread, true);
-                throw new TimeoutException($"Server watchdog detected that the server was frozen for at least {((TorchServer)state).Config.TickTimeout} seconds.\n{stackTrace}");
-            }
-
-            Log.Debug("Server watchdog responded");
         }
 
         /// <inheritdoc />
@@ -192,71 +138,161 @@ namespace Torch.Server
         {
             if (State == ServerState.Stopped)
                 Log.Error("Server is already stopped");
-
-            if (Thread.CurrentThread != MySandboxGame.Static.UpdateThread)
-            {
-                Log.Debug("Invoking server stop on game thread.");
-                Invoke(Stop);
-                return;
-            }
-
             Log.Info("Stopping server.");
-
+            base.Stop();
-            //Unload all the static junk.
-            //TODO: Finish unloading all server data so it's in a completely clean state.
-            MySandboxGame.Static.Exit();
-
             Log.Info("Server stopped.");
-            _stopHandle.Set();
+
             State = ServerState.Stopped;
             IsRunning = false;
+            CanRun = true;
         }
 
         /// <summary>
-        /// Restart the program. DOES NOT SAVE!
+        ///     Restart the program.
         /// </summary>
         public override void Restart()
         {
-            var exe = Assembly.GetExecutingAssembly().Location;
+            if (IsRunning)
-            ((TorchConfig)Config).WaitForPID = Process.GetCurrentProcess().Id.ToString();
+                Save().ContinueWith(DoRestart, this, TaskContinuationOptions.RunContinuationsAsynchronously);
-            Process.Start(exe, Config.ToString());
+            else
-            Environment.Exit(0);
+                DoRestart(null, this);
+
+            void DoRestart(Task<GameSaveResult> task, object torch0)
+            {
+                var torch = (TorchServer)torch0;
+                torch.Stop();
+                // TODO clone this
+                var config = (TorchConfig)torch.Config;
+                LogManager.Flush();
+
+                string exe = Assembly.GetExecutingAssembly().Location;
+                Debug.Assert(exe != null);
+                config.WaitForPID = Process.GetCurrentProcess().Id.ToString();
+                config.Autostart = true;
+                Process.Start(exe, config.ToString());
+
+                Process.GetCurrentProcess().Kill();
+            }
         }
 
-        /// <inheritdoc/>
+        private void OnSessionStateChanged(ITorchSession session, TorchSessionState newState)
-        public override Task Save(long callerId)
         {
-            return SaveGameAsync(statusCode => SaveCompleted(statusCode, callerId));
+            if (newState == TorchSessionState.Unloading || newState == TorchSessionState.Unloaded)
+            {
+                _watchdog?.Dispose();
+                _watchdog = null;
+                ModCommunication.Unregister();
             }
 
-        /// <summary>
+            if (newState == TorchSessionState.Loaded)
-        /// Callback for when save has finished.
-        /// </summary>
-        /// <param name="statusCode">Return code of the save operation</param>
-        /// <param name="callerId">Caller of the save operation</param>
-        private void SaveCompleted(SaveGameStatus statusCode, long callerId = 0)
             {
-            switch (statusCode)
+                CurrentSession.Managers.GetManager<CommandManager>().RegisterCommandModule(typeof(WhitelistCommands));
-            {
+                ModCommunication.Register();
-                case SaveGameStatus.Success:
-                    Log.Info("Save completed.");
-                    Multiplayer.SendMessage("Saved game.", playerId: callerId);
-                    break;
-                case SaveGameStatus.SaveInProgress:
-                    Log.Error("Save failed, a save is already in progress.");
-                    Multiplayer.SendMessage("Save failed, a save is already in progress.", playerId: callerId, font: MyFontEnum.Red);
-                    break;
-                case SaveGameStatus.GameNotReady:
-                    Log.Error("Save failed, game was not ready.");
-                    Multiplayer.SendMessage("Save failed, game was not ready.", playerId: callerId, font: MyFontEnum.Red);
-                    break;
-                case SaveGameStatus.TimedOut:
-                    Log.Error("Save failed, save timed out.");
-                    Multiplayer.SendMessage("Save failed, save timed out.", playerId: callerId, font: MyFontEnum.Red);
-                    break;
-                default:
-                    break;
             }
         }
+
+        /// <inheritdoc />
+        public override void Init(object gameInstance)
+        {
+            base.Init(gameInstance);
+            var game = gameInstance as MySandboxGame;
+            if (game != null && MySession.Static != null)
+                State = ServerState.Running;
+            else
+                State = ServerState.Stopped;
+        }
+
+        /// <inheritdoc />
+        public override void Update()
+        {
+            base.Update();
+            // Stops 1.00-1.02 flicker.
+            SimulationRatio = Math.Min(Sync.ServerSimulationRatio, 1);
+            var elapsed = TimeSpan.FromSeconds(Math.Floor(_uptime.Elapsed.TotalSeconds));
+            ElapsedPlayTime = elapsed;
+
+            if (_watchdog == null && Config.TickTimeout > 0)
+            {
+                Log.Info("Starting server watchdog.");
+                _watchdog = new Timer(CheckServerResponding, this, TimeSpan.Zero,
+                    TimeSpan.FromSeconds(Config.TickTimeout));
+            }
+        }
+
+        #region Freeze Detection
+
+        private static void CheckServerResponding(object state)
+        {
+            var mre = new ManualResetEvent(false);
+            ((TorchServer)state).Invoke(() => mre.Set());
+            if (!mre.WaitOne(TimeSpan.FromSeconds(Instance.Config.TickTimeout)))
+            {
+#if DEBUG
+                Log.Error(
+                    $"Server watchdog detected that the server was frozen for at least {((TorchServer) state).Config.TickTimeout} seconds.");
+                Log.Error(DumpFrozenThread(MySandboxGame.Static.UpdateThread));
+#else
+                Log.Error(DumpFrozenThread(MySandboxGame.Static.UpdateThread));
+                throw new TimeoutException($"Server watchdog detected that the server was frozen for at least {((TorchServer)state).Config.TickTimeout} seconds.");
+#endif
+            }
+
+            Log.Debug("Server watchdog responded");
+        }
+
+        private static string DumpFrozenThread(Thread thread, int traces = 3, int pause = 5000)
+        {
+            var stacks = new List<string>(traces);
+            var totalSize = 0;
+            for (var i = 0; i < traces; i++)
+            {
+                string dump = DumpStack(thread).ToString();
+                totalSize += dump.Length;
+                stacks.Add(dump);
+                Thread.Sleep(pause);
+            }
+
+            string commonPrefix = StringUtils.CommonSuffix(stacks);
+            // Advance prefix to include the line terminator.
+            commonPrefix = commonPrefix.Substring(commonPrefix.IndexOf('\n') + 1);
+
+            var result = new StringBuilder(totalSize - (stacks.Count - 1) * commonPrefix.Length);
+            result.AppendLine($"Frozen thread dump {thread.Name}");
+            result.AppendLine("Common prefix:").AppendLine(commonPrefix);
+            for (var i = 0; i < stacks.Count; i++)
+                if (stacks[i].Length > commonPrefix.Length)
+                {
+                    result.AppendLine($"Suffix {i}");
+                    result.AppendLine(stacks[i].Substring(0, stacks[i].Length - commonPrefix.Length));
+                }
+
+            return result.ToString();
+        }
+
+        private static StackTrace DumpStack(Thread thread)
+        {
+            try
+            {
+                thread.Suspend();
+            }
+            catch
+            {
+                // ignored
+            }
+
+            var stack = new StackTrace(thread, true);
+            try
+            {
+                thread.Resume();
+            }
+            catch
+            {
+                // ignored
+            }
+
+            return stack;
+        }
+
+        #endregion
     }
 }

Torch.Server/TorchService.cs

@@ -14,13 +14,15 @@ namespace Torch.Server
     {
         public const string Name = "Torch (SEDS)";
         private TorchServer _server;
-        private static Logger _log = LogManager.GetLogger("Torch");
+        private Initializer _initializer;
 
         public TorchService()
         {
-            ServiceName = Name;
+            var workingDir = new FileInfo(typeof(TorchService).Assembly.Location).Directory.ToString();
+            Directory.SetCurrentDirectory(workingDir);
+            _initializer = new Initializer(workingDir);
 
-            CanHandlePowerEvent = true;
+            ServiceName = Name;
             CanHandleSessionChangeEvent = false;
             CanPauseAndContinue = false;
             CanStop = true;
@@ -31,17 +33,8 @@ namespace Torch.Server
         {
             base.OnStart(args);
 
-            string configName = args.Length > 0 ? args[0] : "TorchConfig.xml";
+            _initializer.Initialize(args);
-            var options = new TorchConfig("Torch");
+            _initializer.Run();
-            if (File.Exists(configName))
-                options = TorchConfig.LoadFrom(configName);
-            else
-                options.Save(configName);
-
-            _server = new TorchServer(options);
-            _server.Init();
-            _server.RunArgs = args;
-            Task.Run(() => _server.Start());
         }
 
         /// <inheritdoc />
@@ -50,17 +43,5 @@ namespace Torch.Server
             _server.Stop();
             base.OnStop();
         }
-
-        /// <inheritdoc />
-        protected override void OnShutdown()
-        {
-            base.OnShutdown();
-        }
-
-        /// <inheritdoc />
-        protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus)
-        {
-            return base.OnPowerEvent(powerStatus);
-        }
     }
 }

Torch.Server/ViewModels/CheckpointViewModel.cs

@@ -0,0 +1,132 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Torch.Collections;
+using VRage;
+using VRage.Game;
+using VRage.Game.ModAPI;
+using VRage.ObjectBuilders;
+using VRage.Serialization;
+using VRageMath;
+
+namespace Torch.Server.ViewModels
+{
+    public class CheckpointViewModel : ViewModel
+    {
+        private MyObjectBuilder_Checkpoint _checkpoint;
+        private SessionSettingsViewModel _sessionSettings;
+
+        public CheckpointViewModel(MyObjectBuilder_Checkpoint checkpoint)
+        {
+            _checkpoint = checkpoint;
+            _sessionSettings = new SessionSettingsViewModel(_checkpoint.Settings);
+        }
+
+        public static implicit operator MyObjectBuilder_Checkpoint(CheckpointViewModel model)
+        {
+            return model._checkpoint;
+        }
+
+        public Vector3I CurrentSector { get => _checkpoint.CurrentSector; set => SetValue(ref _checkpoint.CurrentSector, value); }
+
+        public long ElapsedGameTime { get => _checkpoint.ElapsedGameTime; set => SetValue(ref _checkpoint.ElapsedGameTime, value); }
+
+        public string SessionName { get => _checkpoint.SessionName; set => SetValue(ref _checkpoint.SessionName, value); }
+
+        public MyPositionAndOrientation SpectatorPosition { get => _checkpoint.SpectatorPosition; set => SetValue(ref _checkpoint.SpectatorPosition, value); }
+
+        public bool SpectatorIsLightOn { get => _checkpoint.SpectatorIsLightOn; set => SetValue(ref _checkpoint.SpectatorIsLightOn, value); }
+
+        public MyCameraControllerEnum CameraController { get => _checkpoint.CameraController; set => SetValue(ref _checkpoint.CameraController, value); }
+
+        public long CameraEntity { get => _checkpoint.CameraEntity; set => SetValue(ref _checkpoint.CameraEntity, value); }
+
+        public long ControlledObject { get => _checkpoint.ControlledObject; set => SetValue(ref _checkpoint.ControlledObject, value); }
+
+        public string Password { get => _checkpoint.Password; set => SetValue(ref _checkpoint.Password, value); }
+
+        public string Description { get => _checkpoint.Description; set => SetValue(ref _checkpoint.Description, value); }
+
+        public DateTime LastSaveTime { get => _checkpoint.LastSaveTime; set => SetValue(ref _checkpoint.LastSaveTime, value); }
+
+        public float SpectatorDistance { get => _checkpoint.SpectatorDistance; set => SetValue(ref _checkpoint.SpectatorDistance, value); }
+
+        public ulong? WorkshopId { get => _checkpoint.WorkshopId; set => SetValue(ref _checkpoint.WorkshopId, value); }
+
+        public MyObjectBuilder_Toolbar CharacterToolbar { get => _checkpoint.CharacterToolbar; set => SetValue(ref _checkpoint.CharacterToolbar, value); }
+
+        public SerializableDictionary<long, MyObjectBuilder_Checkpoint.PlayerId> ControlledEntities { get => _checkpoint.ControlledEntities; set => SetValue(ref _checkpoint.ControlledEntities, value); }
+
+        public SessionSettingsViewModel Settings
+        {
+            get => _sessionSettings;
+            set
+            {
+                SetValue(ref _sessionSettings, value);
+                _checkpoint.Settings = _sessionSettings;
+            }
+        }
+
+        public MyObjectBuilder_ScriptManager ScriptManagerData => throw new NotImplementedException();
+
+        public int AppVersion { get => _checkpoint.AppVersion; set => SetValue(ref _checkpoint.AppVersion, value); }
+
+        public MyObjectBuilder_FactionCollection Factions => throw new NotImplementedException();
+
+        public List<MyObjectBuilder_Checkpoint.ModItem> Mods { get => _checkpoint.Mods; set => SetValue(ref _checkpoint.Mods, value); }
+
+        public SerializableDictionary<ulong, MyPromoteLevel> PromotedUsers { get => _checkpoint.PromotedUsers; set => SetValue(ref _checkpoint.PromotedUsers, value); }
+
+        public HashSet<ulong> CreativeTools { get => _checkpoint.CreativeTools; set => SetValue(ref _checkpoint.CreativeTools, value); }
+
+        public SerializableDefinitionId Scenario { get => _checkpoint.Scenario; set => SetValue(ref _checkpoint.Scenario, value); }
+
+        public List<MyObjectBuilder_Checkpoint.RespawnCooldownItem> RespawnCooldowns { get => _checkpoint.RespawnCooldowns; set => SetValue(ref _checkpoint.RespawnCooldowns, value); }
+
+        public List<MyObjectBuilder_Identity> Identities { get => _checkpoint.Identities; set => SetValue(ref _checkpoint.Identities, value); }
+
+        public List<MyObjectBuilder_Client> Clients { get => _checkpoint.Clients; set => SetValue(ref _checkpoint.Clients, value); }
+
+        public MyEnvironmentHostilityEnum? PreviousEnvironmentHostility { get => _checkpoint.PreviousEnvironmentHostility; set => SetValue(ref _checkpoint.PreviousEnvironmentHostility, value); }
+
+        public SerializableDictionary<MyObjectBuilder_Checkpoint.PlayerId, MyObjectBuilder_Player> AllPlayersData { get => _checkpoint.AllPlayersData; set => SetValue(ref _checkpoint.AllPlayersData, value); }
+
+        public SerializableDictionary<MyObjectBuilder_Checkpoint.PlayerId, List<Vector3>> AllPlayersColors { get => _checkpoint.AllPlayersColors; set => SetValue(ref _checkpoint.AllPlayersColors, value); }
+
+        public List<MyObjectBuilder_ChatHistory> ChatHistory { get => _checkpoint.ChatHistory; set => SetValue(ref _checkpoint.ChatHistory, value); }
+
+        public List<MyObjectBuilder_FactionChatHistory> FactionChatHistory { get => _checkpoint.FactionChatHistory; set => SetValue(ref _checkpoint.FactionChatHistory, value); }
+
+        public List<long> NonPlayerIdentities { get => _checkpoint.NonPlayerIdentities; set => SetValue(ref _checkpoint.NonPlayerIdentities, value); }
+
+        public SerializableDictionary<long, MyObjectBuilder_Gps> Gps { get => _checkpoint.Gps; set => SetValue(ref _checkpoint.Gps, value); }
+
+        public SerializableBoundingBoxD? WorldBoundaries { get => _checkpoint.WorldBoundaries; set => SetValue(ref _checkpoint.WorldBoundaries, value); }
+
+        public List<MyObjectBuilder_SessionComponent> SessionComponents { get => _checkpoint.SessionComponents; set => SetValue(ref _checkpoint.SessionComponents, value); }
+
+        public SerializableDefinitionId GameDefinition { get => _checkpoint.GameDefinition; set => SetValue(ref _checkpoint.GameDefinition, value); }
+
+        public HashSet<string> SessionComponentEnabled { get => _checkpoint.SessionComponentEnabled; set => SetValue(ref _checkpoint.SessionComponentEnabled, value); }
+
+        public HashSet<string> SessionComponentDisabled { get => _checkpoint.SessionComponentDisabled; set => SetValue(ref _checkpoint.SessionComponentDisabled, value); }
+
+        public DateTime InGameTime { get => _checkpoint.InGameTime; set => SetValue(ref _checkpoint.InGameTime, value); }
+
+        public MyObjectBuilder_SessionComponentMission MissionTriggers { get => _checkpoint.MissionTriggers; set => SetValue(ref _checkpoint.MissionTriggers, value); }
+
+        public string Briefing { get => _checkpoint.Briefing; set => SetValue(ref _checkpoint.Briefing, value); }
+
+        public string BriefingVideo { get => _checkpoint.BriefingVideo; set => SetValue(ref _checkpoint.BriefingVideo, value); }
+
+        public string CustomLoadingScreenImage { get => _checkpoint.CustomLoadingScreenImage; set => SetValue(ref _checkpoint.BriefingVideo, value); }
+
+        public string CustomLoadingScreenText { get => _checkpoint.CustomLoadingScreenText; set => SetValue(ref _checkpoint.CustomLoadingScreenText, value); }
+
+        public string CustomSkybox { get => _checkpoint.CustomSkybox; set => SetValue(ref _checkpoint.CustomSkybox, value); }
+
+        public int RequiresDX { get => _checkpoint.RequiresDX; set => SetValue(ref _checkpoint.RequiresDX, value); }
+    }
+}

Torch.Server/ViewModels/ConfigDedicatedViewModel.cs

@@ -6,6 +6,8 @@ using System.Text;
 using System.Threading.Tasks;
 using NLog;
 using Sandbox.Engine.Utils;
+using Torch.Collections;
+using Torch.Server.Managers;
 using VRage.Game;
 using VRage.Game.ModAPI;
 
@@ -13,7 +15,7 @@ namespace Torch.Server.ViewModels
 {
     public class ConfigDedicatedViewModel : ViewModel
     {
-        private static readonly Logger Log = LogManager.GetLogger("Config");
+        private static readonly Logger Log = LogManager.GetCurrentClassLogger();
         private MyConfigDedicated<MyObjectBuilder_SessionSettings> _config;
         public MyConfigDedicated<MyObjectBuilder_SessionSettings> Model => _config;
 
@@ -25,111 +27,110 @@ namespace Torch.Server.ViewModels
         public ConfigDedicatedViewModel(MyConfigDedicated<MyObjectBuilder_SessionSettings> configDedicated)
         {
             _config = configDedicated;
+            _config.IgnoreLastSession = true;
             SessionSettings = new SessionSettingsViewModel(_config.SessionSettings);
-            Administrators = string.Join(Environment.NewLine, _config.Administrators);
-            Banned = string.Join(Environment.NewLine, _config.Banned);
-            Mods = string.Join(Environment.NewLine, _config.Mods);
         }
 
         public void Save(string path = null)
         {
-            var newline = new [] {Environment.NewLine};
+            Validate();
 
-            _config.Administrators.Clear();
+            _config.SessionSettings = _sessionSettings;
-            foreach (var admin in Administrators.Split(newline, StringSplitOptions.RemoveEmptyEntries))
+            // Never ever
-                _config.Administrators.Add(admin);
+            _config.IgnoreLastSession = true;
-
+            _config.Save(path);
-            _config.Banned.Clear();
-            foreach (var banned in Banned.Split(newline, StringSplitOptions.RemoveEmptyEntries))
-                _config.Banned.Add(ulong.Parse(banned));
-
-            _config.Mods.Clear();
-            foreach (var mod in Mods.Split(newline, StringSplitOptions.RemoveEmptyEntries))
-            {
-                if (ulong.TryParse(mod, out ulong modId))
-                    _config.Mods.Add(modId);
-                else
-                    Log.Warn($"'{mod}' is not a valid mod ID.");
         }
 
-            _config.Save(path);
+        public bool Validate()
+        {
+            if (SelectedWorld == null)
+            {
+                Log.Warn($"{nameof(SelectedWorld)} == null");
+                return false;
+            }
+
+            if (LoadWorld == null)
+            {
+                Log.Warn($"{nameof(LoadWorld)} == null");
+                return false;
+            }
+
+            return true;
         }
 
         private SessionSettingsViewModel _sessionSettings;
         public SessionSettingsViewModel SessionSettings { get => _sessionSettings; set { _sessionSettings = value; OnPropertyChanged(); } }
 
-        public ObservableList<string> WorldPaths { get; } = new ObservableList<string>();
+        public MtObservableList<WorldViewModel> Worlds { get; } = new MtObservableList<WorldViewModel>();
-        private string _administrators;
+        private WorldViewModel _selectedWorld;
-        public string Administrators { get => _administrators; set { _administrators = value; OnPropertyChanged(); } }
+        public WorldViewModel SelectedWorld
-        private string _banned;
-        public string Banned { get => _banned; set { _banned = value; OnPropertyChanged(); } }
-        private string _mods;
-        public string Mods { get => _mods; set { _mods = value; OnPropertyChanged(); } }
-
-        public int AsteroidAmount
         {
-            get { return _config.AsteroidAmount; }
+            get => _selectedWorld;
-            set { _config.AsteroidAmount = value; OnPropertyChanged(); }
+            set
+            {
+                SetValue(ref _selectedWorld, value);
+                LoadWorld = _selectedWorld?.WorldPath;
+            }
         }
 
-        public ulong GroupId
+        public List<string> Administrators { get => _config.Administrators; set => SetValue(x => _config.Administrators = x, value); }
-        {
-            get { return _config.GroupID; }
-            set { _config.GroupID = value; OnPropertyChanged(); }
-        }
 
-        public bool IgnoreLastSession
+        public List<ulong> Banned { get => _config.Banned; set => SetValue(x => _config.Banned = x, value); }
-        {
-            get { return _config.IgnoreLastSession; }
-            set { _config.IgnoreLastSession = value; OnPropertyChanged(); }
-        }
 
-        public string IP
+        public List<ulong> Reserved { get => _config.Reserved; set => SetValue(x => _config.Reserved = x, value); }
-        {
-            get { return _config.IP; }
-            set { _config.IP = value; OnPropertyChanged(); }
-        }
 
-        public int Port
+        private List<ulong> _mods = new List<ulong>();
-        {
+        public List<ulong> Mods { get => _mods; set => SetValue(x => _mods = x, value); }
-            get { return _config.ServerPort; }
-            set { _config.ServerPort = value; OnPropertyChanged(); }
-        }
 
-        public string ServerName
+        public int AsteroidAmount { get => _config.AsteroidAmount; set => SetValue(x => _config.AsteroidAmount = x, value); }
-        {
-            get { return _config.ServerName; }
-            set { _config.ServerName = value; OnPropertyChanged(); }
-        }
 
-        public bool PauseGameWhenEmpty
+        public ulong GroupId { get => _config.GroupID; set => SetValue(x => _config.GroupID = x, value); }
-        {
-            get { return _config.PauseGameWhenEmpty; }
-            set { _config.PauseGameWhenEmpty = value; OnPropertyChanged(); }
-        }
 
-        public string PremadeCheckpointPath
+        public string IP { get => _config.IP; set => SetValue(x => _config.IP = x, value); }
-        {
-            get { return _config.PremadeCheckpointPath; }
-            set { _config.PremadeCheckpointPath = value; OnPropertyChanged(); }
-        }
 
-        public string LoadWorld
+        public int Port { get => _config.ServerPort; set => SetValue(x => _config.ServerPort = x, value); }
-        {
-            get { return _config.LoadWorld; }
-            set { _config.LoadWorld = value; OnPropertyChanged(); }
-        }
 
-        public int SteamPort
+        public string ServerName { get => _config.ServerName; set => SetValue(x => _config.ServerName = x, value); }
-        {
-            get { return _config.SteamPort; }
-            set { _config.SteamPort = value; OnPropertyChanged(); }
-        }
 
-        public string WorldName
+        public string ServerDescription { get => _config.ServerDescription; set => SetValue(x => _config.ServerDescription = x, value); }
+
+        public bool PauseGameWhenEmpty { get => _config.PauseGameWhenEmpty; set => SetValue(x => _config.PauseGameWhenEmpty = x, value); }
+
+        public bool AutodetectDependencies { get => _config.AutodetectDependencies; set => SetValue(x => _config.AutodetectDependencies = x, value); }
+
+        public string PremadeCheckpointPath { get => _config.PremadeCheckpointPath; set => SetValue(x => _config.PremadeCheckpointPath = x, value); }
+
+        public string LoadWorld { get => _config.LoadWorld; set => SetValue(x => _config.LoadWorld = x, value); }
+
+        public int SteamPort { get => _config.SteamPort; set => SetValue(x => _config.SteamPort = x, value); }
+
+        public string WorldName { get => _config.WorldName; set => SetValue(x => _config.WorldName = x, value); }
+
+        //this is a damn server password. I don't care if this is insecure. Bite me.
+        private string _password;
+        public string Password
         {
-            get { return _config.WorldName; }
+            get
-            set { _config.WorldName = value; OnPropertyChanged(); }
+            {
+                if (string.IsNullOrEmpty(_password))
+                {
+                    if (string.IsNullOrEmpty(_config.ServerPasswordHash))
+                        return string.Empty;
+                    return "**********";
+                }
+                return _password;
+            }
+            set
+            {
+                _password = value;
+                if(!string.IsNullOrEmpty(value))
+                    _config.SetPassword(value);
+                else
+                {
+                    _config.ServerPasswordHash = null;
+                    _config.ServerPasswordSalt = null;
+                }
+            }
         }
     }
 }

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

@@ -8,16 +8,17 @@ using System.Threading.Tasks;
 using Sandbox.Game.Entities.Cube;
 using Sandbox.ModAPI;
 using Sandbox.ModAPI.Interfaces;
+using Torch.Collections;
 using Torch.Server.ViewModels.Entities;
 
 namespace Torch.Server.ViewModels.Blocks
 {
     public class BlockViewModel : EntityViewModel
     {
-        public IMyTerminalBlock Block { get; }
+        public IMyTerminalBlock Block => (IMyTerminalBlock) Entity;
-        public ObservableList<PropertyViewModel> Properties { get; } = new ObservableList<PropertyViewModel>();
+        public MtObservableList<PropertyViewModel> Properties { get; } = new MtObservableList<PropertyViewModel>();
 
-        public string FullName => $"{Block.CubeGrid.CustomName} - {Block.CustomName}";
+        public string FullName => $"{Block?.CubeGrid.CustomName} - {Block?.CustomName}";
 
         public override string Name
         {
@@ -37,7 +38,7 @@ namespace Torch.Server.ViewModels.Blocks
 
         public long BuiltBy
         {
-            get => ((MySlimBlock)Block.SlimBlock).BuiltBy;
+            get => ((MySlimBlock)Block?.SlimBlock)?.BuiltBy ?? 0;
             set
             {
                 TorchBase.Instance.Invoke(() =>
@@ -58,7 +59,6 @@ namespace Torch.Server.ViewModels.Blocks
 
         public BlockViewModel(IMyTerminalBlock block, EntityTreeViewModel tree) : base(block, tree)
         {
-            Block = block;
             if (Block == null)
                 return;
 

Torch.Server/ViewModels/Entities/CharacterViewModel.cs

@@ -6,7 +6,12 @@ namespace Torch.Server.ViewModels.Entities
     {
         public CharacterViewModel(MyCharacter character, EntityTreeViewModel tree) : base(character, tree)
         {
+            character.ControllerInfo.ControlAcquired += (x) => { OnPropertyChanged(nameof(Name)); };
+            character.ControllerInfo.ControlReleased += (x) => { OnPropertyChanged(nameof(Name)); };
+        }
 
+        public CharacterViewModel()
+        {
         }
     }
 }

Torch.Server/ViewModels/Entities/EntityControlViewModel.cs

@@ -0,0 +1,38 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Windows;
+
+namespace Torch.Server.ViewModels.Entities
+{
+    public class EntityControlViewModel : ViewModel
+    {
+        internal const string SignalPropertyInvalidateControl =
+            "InvalidateControl-4124a476-704f-4762-8b5e-336a18e2f7e5";
+
+        internal void InvalidateControl()
+        {
+            // ReSharper disable once ExplicitCallerInfoArgument
+            OnPropertyChanged(SignalPropertyInvalidateControl);
+        }
+
+        private bool _hide;
+
+        /// <summary>
+        /// Should this element be forced into the <see cref="Visibility.Collapsed"/>
+        /// </summary>
+        public bool Hide
+        {
+            get => _hide;
+            protected set
+            {
+                if (_hide == value)
+                    return;
+                _hide = value;
+                OnPropertyChanged();
+            }
+        }
+    }
+}

Torch.Server/ViewModels/Entities/EntityViewModel.cs

@@ -1,4 +1,10 @@
-using VRage.Game.ModAPI;
+using System.Windows.Controls;
+using Sandbox.Game.World;
+using Torch.API.Managers;
+using Torch.Collections;
+using Torch.Server.Managers;
+using VRage.Game.Entity;
+using VRage.Game.ModAPI;
 using VRage.ModAPI;
 using VRageMath;
 
@@ -7,14 +13,31 @@ namespace Torch.Server.ViewModels.Entities
     public class EntityViewModel : ViewModel
     {
         protected EntityTreeViewModel Tree { get; }
-        public IMyEntity Entity { get; }
+
+        private IMyEntity _backing;
+        public IMyEntity Entity
+        {
+            get => _backing;
+            protected set
+            {
+                _backing = value;
+                OnPropertyChanged();
+                EntityControls = TorchBase.Instance?.Managers.GetManager<EntityControlManager>()?.BoundModels(this);
+                // ReSharper disable once ExplicitCallerInfoArgument
+                OnPropertyChanged(nameof(EntityControls));
+            }
+        }
+
         public long Id => Entity.EntityId;
 
+        public MtObservableList<EntityControlViewModel> EntityControls { get; private set; }
+
         public virtual string Name
         {
-            get => Entity.DisplayName;
+            get => Entity?.DisplayName ?? (Entity != null ? $"eid:{Entity.EntityId}" : "nil");
             set
             {
+                if (Entity!=null)
                     TorchBase.Instance.InvokeBlocking(() => Entity.DisplayName = value);
                 OnPropertyChanged();
             }
@@ -22,12 +45,13 @@ namespace Torch.Server.ViewModels.Entities
 
         public virtual string Position
         {
-            get => Entity.GetPosition().ToString();
+            get => Entity?.GetPosition().ToString();
             set
             {
                 if (!Vector3D.TryParse(value, out Vector3D v))
                     return;
 
+                if (Entity != null)
                     TorchBase.Instance.InvokeBlocking(() => Entity.SetPosition(v));
                 OnPropertyChanged();
             }