Fix MyEntities init

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

.github/workflows/release.yaml

@@ -2,56 +2,60 @@ name: Release
 
 on:
   push:
-    tags:
+    branches: [master]
-      - '*'
 
 jobs:
   build:
     name: Build
     runs-on: ubuntu-latest
     env:
-      TORCH_VERSION: ${{ github.ref_name }}
       BUILD_CONFIGURATION: Release
       DOTNET_NOLOGO: true
       DOTNET_CLI_TELEMETRY_OPTOUT: true
     steps:
       - uses: actions/checkout@master
         name: Checkout
+        with:
+          ref: ${{ github.head_ref }}
+          fetch-depth: 0
+          
       - uses: actions/setup-dotnet@v3
         name: Setup dotnet
         with:
           dotnet-version: '7.0.x'
+          
       - name: Add Gh Packages Nuget Source
         run: dotnet nuget add source "https://nuget.pkg.github.com/${{ github.repository_owner }}/index.json" --username ${{ github.actor }} --password ${{ secrets.GITHUB_TOKEN }} --store-password-in-clear-text --name github
       - name: Restore dependencies
         run: dotnet restore Torch.Server/Torch.Server.csproj --locked-mode
+        
+      - name: Git Version
+        id: version
+        uses: codacy/git-version@2.7.1
+        
       - name: Build
-        run: dotnet build Torch.Server/Torch.Server.csproj --no-restore -c ${{ env.BUILD_CONFIGURATION }} /p:AssemblyVersion=${{ env.TORCH_VERSION }} /p:Version=${{ env.TORCH_VERSION }}
+        run: dotnet build Torch.Server/Torch.Server.csproj --no-restore -c ${{ env.BUILD_CONFIGURATION }} -p:Version="${{ steps.version.outputs.version }}" -p:AssemblyVersion="${{ steps.version.outputs.version }}"
       - name: Publish
         run: dotnet publish Torch.Server/Torch.Server.csproj --no-build -r win-x64 --sc -c ${{ env.BUILD_CONFIGURATION }} -o ./publish
+      
       - uses: vimtor/action-zip@v1
         name: Zip Release
         with:
           files: publish/
           dest: release.zip
-      - name: Build Changelog
+      
-        id: build_changelog
-        uses: mikepenz/release-changelog-builder-action@v3
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          commitMode: true
       - name: Create release
         id: create_release
         uses: actions/create-release@v1
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         with:
-          tag_name: ${{ env.TORCH_VERSION }}
+          tag_name: ${{ steps.version.outputs.version }}
-          release_name: Release v${{ env.TORCH_VERSION }}
+          release_name: Release v${{ steps.version.outputs.version }}
           body: ${{ steps.github_release.outputs.changelog }}
           draft: true
           prerelease: false
+      
       - name: Upload release asset
         uses: actions/upload-release-asset@v1
         env:
@@ -61,16 +65,16 @@ jobs:
           asset_path: release.zip
           asset_name: torch-server.zip
           asset_content_type: application/zip
-      - name: Publish release
+      
-        uses: StuYarrow/publish-release@v1
+      - uses: eregon/publish-release@v1
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         with:
-          id: ${{ steps.create_release.outputs.id }}
+          release_id: ${{ steps.create_release.outputs.id }}
           
-      - run: dotnet pack -c Release ./Torch.API/Torch.API.csproj -o pack --include-symbols -p:SymbolPackageFormat=snupkg -p:Version=${{ env.TORCH_VERSION }} --no-build
+      - run: dotnet pack -c Release ./Torch.API/Torch.API.csproj -o pack --include-symbols -p:SymbolPackageFormat=snupkg -p:Version="${{ steps.version.outputs.version }}" -p:AssemblyVersion="${{ steps.version.outputs.version }}" --no-build
-      - run: dotnet pack -c Release ./Torch/Torch.csproj -o pack --include-symbols -p:SymbolPackageFormat=snupkg -p:Version=${{ env.TORCH_VERSION }} --no-build
+      - run: dotnet pack -c Release ./Torch/Torch.csproj -o pack --include-symbols -p:SymbolPackageFormat=snupkg -p:Version="${{ steps.version.outputs.version }}" -p:AssemblyVersion="${{ steps.version.outputs.version }}" --no-build
-      - run: dotnet pack -c Release ./Torch.Server/Torch.Server.csproj -o pack --include-symbols -p:SymbolPackageFormat=snupkg -p:Version=${{ env.TORCH_VERSION }} --no-build
+      - run: dotnet pack -c Release ./Torch.Server/Torch.Server.csproj -o pack --include-symbols -p:SymbolPackageFormat=snupkg -p:Version="${{ steps.version.outputs.version }}" -p:AssemblyVersion="${{ steps.version.outputs.version }}" --no-build
-      - run: mkdir blank && sed -i 's/torchVersion/${{ env.TORCH_VERSION }}/g' Torch.Server.ReferenceAssemblies.net7.nuspec && nuget pack Torch.Server.ReferenceAssemblies.net7.nuspec -BasePath ./blank -Version ${{ env.TORCH_VERSION }} -OutputDirectory pack -NonInteractive -NoPackageAnalysis
+      - run: mkdir blank && sed -i 's/torchVersion/${{ steps.version.outputs.version }}/g' Torch.Server.ReferenceAssemblies.net7.nuspec && nuget pack Torch.Server.ReferenceAssemblies.net7.nuspec -BasePath ./blank -OutputDirectory pack -NonInteractive -NoPackageAnalysis
   
       - run: dotnet nuget push ./pack/*.nupkg -s github 

.gitignore

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

Torch.API/Torch.API.csproj

@@ -21,7 +21,7 @@
     <PackageReference Include="NuGet.Commands" Version="6.4.0" />
     <PackageReference Include="NuGet.DependencyResolver.Core" Version="6.4.0" />
     <PackageReference Include="SemanticVersioning" Version="2.0.2" />
-    <PackageReference Include="SpaceEngineersDedicated.ReferenceAssemblies" Version="1.201.13">
+    <PackageReference Include="SpaceEngineersDedicated.ReferenceAssemblies" Version="1.202.120">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>compile</IncludeAssets>
     </PackageReference>

Torch.API/packages.lock.json

@@ -43,9 +43,9 @@
       },
       "SpaceEngineersDedicated.ReferenceAssemblies": {
         "type": "Direct",
-        "requested": "[1.201.13, )",
+        "requested": "[1.202.120, )",
-        "resolved": "1.201.13",
+        "resolved": "1.202.120",
-        "contentHash": "FRXuNLENsz5jGQvL0QkogAGsxEJyUQlXhvWHBWfZiHCnCrAWMD60nEis6yt0xCQpazszfMtHonbxz72XMxnFoQ==",
+        "contentHash": "HTP48NOSZY3eQPX3GJN+gjxdW83SM7DX6NcKCFqNIIvjz/J+l8uimHAQp9dnLySb0wb1K1Z1xBPIXyxMQRREIw==",
         "dependencies": {
           "protobuf-net": "1.0.0"
         }

Torch.Server.ReferenceAssemblies.net7.nuspec

@@ -2,7 +2,7 @@
 <package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
     <metadata>
         <id>Torch.Server.ReferenceAssemblies.net7</id>
-        <version>1.0.1</version>
+        <version>torchVersion</version>
         <title>Torch Server Reference Assemblies</title>
         <authors>zznty</authors>
         <owners>zznty</owners>
@@ -11,7 +11,7 @@
         <repository type="git" url="https://github.com/PveTeam/Torch" />
         <dependencies>
             <group targetFramework="net7.0-windows7.0">
-                <dependency id="SpaceEngineersDedicated.ReferenceAssemblies" version="1.201.13" />
+                <dependency id="SpaceEngineersDedicated.ReferenceAssemblies" version="1.202.120" />
                 <dependency id="Torch.Server" version="torchVersion" />
             </group>
         </dependencies>

Torch.Server/Initializer.cs

@@ -27,10 +27,11 @@ namespace Torch.Server
 
         private static readonly Logger Log = LogManager.GetLogger(nameof(Initializer));
         private bool _init;
-        private const string STEAMCMD_DIR = "steamcmd";
+        private const string TOOL_DIR = "tool";
-        private const string STEAMCMD_ZIP = "temp.zip";
+        private const string TOOL_ZIP = "temp.zip";
-        private static readonly string STEAMCMD_EXE = "steamcmd.exe";
+        private static readonly string TOOL_EXE = "DepotDownloader.exe";
-        private const string STEAMCMD_ARGS = "+force_install_dir \"{0}\" +login anonymous +app_update 298740 +quit";
+        private const string TOOL_ARGS = "-app 298740 -depot {1} -dir \"{0}\" -manifest {2}";
+        private static readonly int[] Depots = { 298741, 1004 }; 
         private TorchServer _server;
 
         internal Persistent<TorchConfig> ConfigPersistent { get; }
@@ -56,8 +57,8 @@ namespace Torch.Server
             Log.Debug("Debug logging enabled.");
 #endif
             
-            if (!configuration.GetValue("noupdate", false))
+            if (configuration.GetValue("getGameUpdates", true) && !configuration.GetValue("noupdate", false))
-                RunSteamCmd(configuration);
+                RunSteamCmdAsync(configuration).Wait();
 
             var processPid = configuration.GetValue<int>("waitForPid");
             if (processPid != 0)
@@ -102,78 +103,87 @@ namespace Torch.Server
                 }
 #endif
                 
-                var gameThread = new Thread(() =>
+                _server.Init();
+                var uiThread = new Thread(() =>
                 {
-                    _server.Init();
+                    var ui = new TorchUI(_server);
                 
-                    if (Config.Autostart || Config.TempAutostart)
+                    SynchronizationContext.SetSynchronizationContext(
-                    {
+                        new DispatcherSynchronizationContext(Dispatcher.CurrentDispatcher));
-                        Config.TempAutostart = false;
+                
-                        _server.Start();
+                    ui.ShowDialog();
-                    }
                 });
                 
-                gameThread.Start();
+                uiThread.SetApartmentState(ApartmentState.STA);
+                uiThread.Start();
 
-                var ui = new TorchUI(_server);
                 
-                SynchronizationContext.SetSynchronizationContext(
-                    new DispatcherSynchronizationContext(Dispatcher.CurrentDispatcher));
 
-                ui.ShowDialog();
+                if (Config.Autostart || Config.TempAutostart)
+                {
+                    Config.TempAutostart = false;
+                    _server.Start();
+                }
+
+                uiThread.Join();
             }
         }
         
-        public static void RunSteamCmd(IConfiguration configuration)
+        public static async Task RunSteamCmdAsync(IConfiguration configuration)
         {
-            var log = LogManager.GetLogger("SteamCMD");
+            var log = LogManager.GetLogger("SteamTool");
 
-            var path = configuration.GetValue<string>("steamCmdPath") ?? ApplicationContext.Current.TorchDirectory
+            var path = configuration.GetValue<string>("steamToolPath") ?? ApplicationContext.Current.TorchDirectory
-                .CreateSubdirectory(STEAMCMD_DIR).FullName;
+                .CreateSubdirectory(TOOL_DIR).FullName;
             
             if (!Directory.Exists(path))
             {
                 Directory.CreateDirectory(path);
             }
 
-            var steamCmdExePath = Path.Combine(path, STEAMCMD_EXE);
+            var steamCmdExePath = Path.Combine(path, TOOL_EXE);
             if (!File.Exists(steamCmdExePath))
             {
                 try
                 {
-                    log.Info("Downloading SteamCMD.");
+                    log.Info("Downloading Steam Tool.");
                     using (var client = new HttpClient())
-                    using (var file = File.Create(STEAMCMD_ZIP))
+                    await using (var file = File.Create(TOOL_ZIP))
-                    using (var stream = client.GetStreamAsync("https://steamcdn-a.akamaihd.net/client/installer/steamcmd.zip").Result)
+                    await using (var stream = await client.GetStreamAsync("https://github.com/SteamRE/DepotDownloader/releases/download/DepotDownloader_2.4.7/depotdownloader-2.4.7.zip"))
-                        stream.CopyTo(file);
+                        await stream.CopyToAsync(file);
 
-                    ZipFile.ExtractToDirectory(STEAMCMD_ZIP, path);
+                    ZipFile.ExtractToDirectory(TOOL_ZIP, path);
-                    File.Delete(STEAMCMD_ZIP);
+                    File.Delete(TOOL_ZIP);
-                    log.Info("SteamCMD downloaded successfully!");
+                    log.Info("Steam Tool downloaded successfully!");
                 }
                 catch (Exception e)
                 {
-                    log.Error(e, "Failed to download SteamCMD, unable to update the DS.");
+                    log.Error(e, "Failed to download Steam Tool, unable to update the DS.");
                     return;
                 }
             }
 
             log.Info("Checking for DS updates.");
-            var steamCmdProc = new ProcessStartInfo(steamCmdExePath)
+            foreach (var depot in Depots)
             {
-                Arguments = string.Format(STEAMCMD_ARGS, configuration.GetValue("gamePath", "../")),
+                await DownloadDepot(depot);
-                WorkingDirectory = path,
+            }
-                UseShellExecute = false,
-                RedirectStandardOutput = true,
-                StandardOutputEncoding = Encoding.ASCII
-            };
-            var cmd = Process.Start(steamCmdProc);
 
-            // ReSharper disable once PossibleNullReferenceException
+            async Task DownloadDepot(int depotId)
-            while (!cmd.HasExited)
             {
-                log.Info(cmd.StandardOutput.ReadLine());
+                var steamCmdProc = new ProcessStartInfo(steamCmdExePath)
-                Thread.Sleep(100);
+                {
+                    Arguments = string.Format(TOOL_ARGS, configuration.GetValue("gamePath", "../"), depotId, "3111493184861426002"),
+                    WorkingDirectory = path,
+                    RedirectStandardOutput = true
+                };
+                var cmd = Process.Start(steamCmdProc)!;
+            
+                while (!cmd.HasExited)
+                {
+                    if (await cmd.StandardOutput.ReadLineAsync() is { } line)
+                        log.Info(line);
+                }
             }
         }
     }

Torch.Server/Managers/RemoteAPIManager.cs

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

Torch.Server/Program.cs

@@ -12,7 +12,7 @@ namespace Torch.Server
 {
     internal static class Program
     {
-        [STAThread]
+        [MTAThread]
         public static void Main(string[] args)
         {
             var configurationBuilder = new ConfigurationBuilder()

Torch.Server/Torch.Server.csproj

@@ -51,7 +51,7 @@
     <PackageReference Include="System.ComponentModel.Annotations" Version="5.0.0" />
     <PackageReference Include="System.Management" Version="7.0.0" />
     <PackageReference Include="nulastudio.NetCoreBeauty" Version="1.2.9.3" />
-    <PackageReference Include="SpaceEngineersDedicated.ReferenceAssemblies" Version="1.201.13">
+    <PackageReference Include="SpaceEngineersDedicated.ReferenceAssemblies" Version="1.202.120">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>compile</IncludeAssets>
     </PackageReference>

Torch.Server/TorchServer.cs

@@ -56,9 +56,7 @@ namespace Torch.Server
                 AddManager(new EntityControlManager(this));
             AddManager(new RemoteAPIManager(this));
 
-            var sessionManager = Managers.GetManager<ITorchSessionManager>();
+            
-            sessionManager.AddFactory(x => new MultiplayerManagerDedicated(this));
-            sessionManager.SessionStateChanged += OnSessionStateChanged;
             
             // Needs to be done at some point after MyVRageWindows.Init
             // where the debug listeners are registered
@@ -128,6 +126,10 @@ namespace Torch.Server
         {
             Log.Info("Initializing server");
             base.Init();
+            var sessionManager = Managers.GetManager<ITorchSessionManager>();
+            sessionManager.AddFactory(x => new MultiplayerManagerDedicated(this));
+            sessionManager.SessionStateChanged += OnSessionStateChanged;
+            
             GetManager<InstanceManager>().LoadInstance(InstancePath);
             CanRun = true;
             Initialized?.Invoke(this);

Torch.Server/UnhandledExceptionHandler.cs

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

Torch.Server/packages.lock.json

@@ -122,9 +122,9 @@
       },
       "SpaceEngineersDedicated.ReferenceAssemblies": {
         "type": "Direct",
-        "requested": "[1.201.13, )",
+        "requested": "[1.202.120, )",
-        "resolved": "1.201.13",
+        "resolved": "1.202.120",
-        "contentHash": "FRXuNLENsz5jGQvL0QkogAGsxEJyUQlXhvWHBWfZiHCnCrAWMD60nEis6yt0xCQpazszfMtHonbxz72XMxnFoQ==",
+        "contentHash": "HTP48NOSZY3eQPX3GJN+gjxdW83SM7DX6NcKCFqNIIvjz/J+l8uimHAQp9dnLySb0wb1K1Z1xBPIXyxMQRREIw==",
         "dependencies": {
           "protobuf-net": "1.0.0"
         }
@@ -162,10 +162,10 @@
       },
       "HarmonyX": {
         "type": "Transitive",
-        "resolved": "2.10.2-prerelease.3",
+        "resolved": "2.10.2-prerelease.4",
-        "contentHash": "XnR2oKlFTCb7F+90OkJR0cqOYOsSPgsQrnX2v9qR0nmM6SPSET/v2SR9vjY/DQhBYUQia16NWv0Mwd8Ml4ZqKA==",
+        "contentHash": "M/44/DhSu1WR8gL62aLPGKqAJ0rrgkw38nT3DgEvLAvyIoQLJmL2Jsn4/d4CC0eDT1Vv82cB9Mxgg0sFD3/qrQ==",
         "dependencies": {
-          "MonoModReorg.RuntimeDetour": "23.1.2-prerelease.1"
+          "MonoModReorg.RuntimeDetour": "23.3.22.1"
         }
       },
       "JorgeSerrano.Json.JsonSnakeCaseNamingPolicy": {
@@ -318,48 +318,48 @@
       },
       "MonoModReorg.Backports": {
         "type": "Transitive",
-        "resolved": "23.1.2-prerelease.1",
+        "resolved": "23.3.22.1",
-        "contentHash": "m1wlCgVjZTFJs3mUxmC1aE/O0RIvsNbSFBI/g93Bqzz1tHa+LhXFyrHzL60PeZMQBIPVy3CeDX4um/UrqLOn/g==",
+        "contentHash": "nLx18prtZbS0nVO8YHElP+TUj1kkDswRgQpa9agt3tyNWke9Kqk5lVkGu87Y3cCMhG+m5Ai0ZDH0+V5B6bXF+Q==",
         "dependencies": {
-          "MonoModReorg.ILHelpers": "23.1.2-prerelease.1"
+          "MonoModReorg.ILHelpers": "23.3.22.1"
         }
       },
       "MonoModReorg.Core": {
         "type": "Transitive",
-        "resolved": "23.1.2-prerelease.1",
+        "resolved": "23.3.22.1",
-        "contentHash": "t1Y89M0rbwUx2VjDMCJOWgtSdsi1F5KNu0O6JAMOtwo2EWJ0HfYj9nS8UWWPwrgRpsquGjqbmYA8jhb59F2a/A==",
+        "contentHash": "Q3ZOgm6AOTL0icgcHsT/6mV5kYt6meqX3DEN1p/et5PxJsXUhVkiZfAptp8y/i+cO6HNgkcESpXEQ4jUWVwsDA==",
         "dependencies": {
           "Mono.Cecil": "0.11.4",
-          "MonoModReorg.Backports": "23.1.2-prerelease.1",
+          "MonoModReorg.Backports": "23.3.22.1",
-          "MonoModReorg.ILHelpers": "23.1.2-prerelease.1",
+          "MonoModReorg.ILHelpers": "23.3.22.1",
-          "MonoModReorg.Utils": "23.1.2-prerelease.1"
+          "MonoModReorg.Utils": "23.3.22.1"
         }
       },
       "MonoModReorg.ILHelpers": {
         "type": "Transitive",
-        "resolved": "23.1.2-prerelease.1",
+        "resolved": "23.3.22.1",
-        "contentHash": "GVh1cmrTCAK0zHr3t8aHnKsyKIlDFiDERn++lCZomHcYc8dgcOAhpkZ7KmaKgZCTJuBIrc44RjpKFr/4ScQnGA=="
+        "contentHash": "dHE/3VZtnTUTkQ34j8Gu6CxKes1QDL8tBuF3QElxHHpPl/QabGCK938k47WWRcRBMoP7IAthkn+Bob4H97rBgw=="
       },
       "MonoModReorg.RuntimeDetour": {
         "type": "Transitive",
-        "resolved": "23.1.2-prerelease.1",
+        "resolved": "23.3.22.1",
-        "contentHash": "UZyJ7OIbLCIBg+dzLejWq2paL1s11koUrq1noSLGCP9uNmFjwDPK+lRmGs0X4qg+Alfq6VsOpI45pGqmaAvP+Q==",
+        "contentHash": "cUES3Hi7QJtBNe0qwVdjZOCDkZDaCpdqS6Au0RaCyQ1PDIR4av13E9qBNAEYew46sgPe0fOrU334md6DLDGHlQ==",
         "dependencies": {
           "Mono.Cecil": "0.11.4",
-          "MonoModReorg.Backports": "23.1.2-prerelease.1",
+          "MonoModReorg.Backports": "23.3.22.1",
-          "MonoModReorg.Core": "23.1.2-prerelease.1",
+          "MonoModReorg.Core": "23.3.22.1",
-          "MonoModReorg.ILHelpers": "23.1.2-prerelease.1",
+          "MonoModReorg.ILHelpers": "23.3.22.1",
-          "MonoModReorg.Utils": "23.1.2-prerelease.1"
+          "MonoModReorg.Utils": "23.3.22.1"
         }
       },
       "MonoModReorg.Utils": {
         "type": "Transitive",
-        "resolved": "23.1.2-prerelease.1",
+        "resolved": "23.3.22.1",
-        "contentHash": "6N4LNG+x4RVPLOc8QWL7dc5sqWdl0gxR+4ASRd1CvvappsK84ISgD9qgeYHgQQtTgE+h6Cuqr3Om4Ly0roLfoA==",
+        "contentHash": "q1cX0mbYxdw2WcE/qGBB84lVY/ffobEr46VQFuwGcWhtw6f1Ql1k4TZfs8gebpesSxHnca13grLeVHrUSpy1+g==",
         "dependencies": {
           "Mono.Cecil": "0.11.4",
-          "MonoModReorg.Backports": "23.1.2-prerelease.1",
+          "MonoModReorg.Backports": "23.3.22.1",
-          "MonoModReorg.ILHelpers": "23.1.2-prerelease.1"
+          "MonoModReorg.ILHelpers": "23.3.22.1"
         }
       },
       "Newtonsoft.Json": {
@@ -585,11 +585,11 @@
         "type": "Project",
         "dependencies": {
           "ControlzEx": "[5.0.2, )",
-          "HarmonyX": "[2.10.2-prerelease.3, )",
+          "HarmonyX": "[2.10.2-prerelease.4, )",
           "MahApps.Metro": "[2.4.9, )",
           "Microsoft.CodeAnalysis.CSharp": "[4.4.0, )",
           "Microsoft.CodeAnalysis.Common": "[4.4.0, )",
-          "MonoModReorg.RuntimeDetour": "[23.1.2-prerelease.1, )",
+          "MonoModReorg.RuntimeDetour": "[23.3.22.1, )",
           "NLog": "[5.1.0, )",
           "System.ComponentModel.Annotations": "[5.0.0, )",
           "Torch.API": "[1.0.0, )",

Torch/Managers/FilesystemManager.cs

@@ -58,21 +58,25 @@ namespace Torch.Managers
             if (!File.Exists(source))
                 return;
 
-            var tempFilePath = Path.Combine(path, file + ".old");
+            try
-            if (File.Exists(tempFilePath))
+            {
-                File.Delete(tempFilePath);
+                File.Delete(source);
+            }
+            catch (Exception e) when (e is IOException or UnauthorizedAccessException)
+            {
+                var tempFilePath = Path.Combine(path, file + ".old");
+                if (File.Exists(tempFilePath))
+                    File.Delete(tempFilePath);
 
-            var errorCode = Rename(source, tempFilePath);
+                try
-            if (Marshal.GetExceptionForHR(errorCode) is { } exception)
+                {
-                throw exception;
+                    File.Move(source, tempFilePath);
+                }
+                catch (UnauthorizedAccessException)
+                {
+                    // ignore
+                }
+            }
         }
-        
-        [LibraryImport("msvcrt", SetLastError = true, EntryPoint = "rename")]
-        [UnmanagedCallConv(CallConvs = new[] { typeof(System.Runtime.CompilerServices.CallConvCdecl) })]
-        private static partial int Rename(
-            [MarshalAs(UnmanagedType.LPWStr)]
-            string oldpath,
-            [MarshalAs(UnmanagedType.LPWStr)]
-            string newpath);
     }
 }

Torch/Managers/PatchManager/MSIL/MsilInstruction.cs

@@ -133,6 +133,12 @@ namespace Torch.Managers.PatchManager.MSIL
                 case double @double when Operand is MsilOperandInline.MsilOperandDouble operandDouble:
                     operandDouble.Value = @double;
                     break;
+                case byte @byte when Operand is MsilOperandInline.MsilOperandArgument operandArgument:
+                    operandArgument.Value = new(@byte);
+                    break;
+                case byte @byte when Operand is MsilOperandInline.MsilOperandLocal operandArgument:
+                    operandArgument.Value = new(@byte);
+                    break;
             }
 
             Labels = instruction.labels.Select(b => new MsilLabel(b)).ToHashSet();
@@ -153,7 +159,10 @@ namespace Torch.Managers.PatchManager.MSIL
                 MsilOperandInline.MsilOperandDouble msilOperandDouble => msilOperandDouble.Value,
                 MsilOperandInline.MsilOperandInt32 msilOperandInt32 => msilOperandInt32.Value,
                 MsilOperandInline.MsilOperandInt64 msilOperandInt64 => msilOperandInt64.Value,
-                MsilOperandInline.MsilOperandLocal msilOperandLocal => msilOperandLocal.Value.Local,
+                MsilOperandInline.MsilOperandLocal msilOperandLocal when OpCode.OperandType == OperandType.InlineVar => msilOperandLocal.Value.Local,
+                MsilOperandInline.MsilOperandLocal msilOperandLocal when OpCode.OperandType == OperandType.ShortInlineVar => (byte)msilOperandLocal.Value.Index,
+                MsilOperandInline.MsilOperandArgument msilOperandArgument when OpCode.OperandType == OperandType.InlineVar => msilOperandArgument.Value,
+                MsilOperandInline.MsilOperandArgument msilOperandArgument when OpCode.OperandType == OperandType.ShortInlineVar => (byte)msilOperandArgument.Value.Position,
                 MsilOperandInline.MsilOperandSignature msilOperandSignature => msilOperandSignature.Value,
                 MsilOperandInline.MsilOperandSingle msilOperandSingle => msilOperandSingle.Value,
                 MsilOperandInline.MsilOperandString msilOperandString => msilOperandString.Value,

Torch/Managers/UpdateManager.cs

@@ -109,7 +109,14 @@ namespace Torch.Managers
                 else
                 {
                     _fsManager.SoftDelete(extractPath, file.FullName);
-                    file.ExtractToFile(targetFile, true);
+                    try
+                    {
+                        file.ExtractToFile(targetFile, true);
+                    }
+                    catch (Exception e)
+                    {
+                        _log.Warn(e, "unable to extract {0}", targetFile);
+                    }
                 }
             }
 

Torch/Packages/PackageManager.cs

@@ -0,0 +1,162 @@
+#nullable enable
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using System.Runtime.Loader;
+using System.Security.Cryptography;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using NLog;
+using Torch.API;
+using Torch.API.Managers;
+using Torch.API.WebAPI.Plugins;
+using Torch.Managers;
+using Torch.Utils;
+
+namespace Torch.Packages;
+
+public class PackageManager : Manager, IPackageManager
+{
+    private readonly PluginManager _pluginManager;
+    private static readonly ILogger Log = LogManager.GetCurrentClassLogger();
+
+    private IPackageResolver? _packageResolver;
+
+    public PackageManager(ITorchBase torchInstance, PluginManager pluginManager) : base(torchInstance)
+    {
+        _pluginManager = pluginManager;
+    }
+
+    private AssemblyLoadContext? _loadContext;
+
+    private ImmutableHashSet<Package> _packages = ImmutableHashSet<Package>.Empty;
+    private ImmutableDictionary<Package,Assembly[]> _packageAssemblies = ImmutableDictionary<Package, Assembly[]>.Empty;
+    private DirectoryInfo? _packagesDirectory;
+    public IReadOnlySet<Package> Packages => _packages;
+    
+    public bool TryGetPackageAssemblies(Package package, out Assembly[]? assemblies)
+    {
+        if (!Packages.Contains(package))
+            throw new InvalidOperationException($"Package {package.Name} does not exist");
+        
+        return _packageAssemblies.TryGetValue(package, out assemblies);
+    }
+
+    internal async void LoadAsync(SemaphoreSlim semaphore)
+    {
+        _packagesDirectory = Directory.CreateDirectory(Path.Combine(Torch.InstancePath, "Packages"));
+        _packageResolver = new PackageResolver(new[]
+        { // TODO make this configurable
+            new PackageSource("nuget", "https://api.nuget.org/v3/index.json", new[] { "*" }, PackageSourceType.NuGet)
+        }, _packagesDirectory);
+        
+        try
+        {
+            var packages =
+                Torch.Config.Packages.ToImmutableDictionary(b => b[..b.IndexOf(':')], b => b[(b.IndexOf(':') + 1)..]);
+            await ResolvePackagesAsync(packages);
+
+            var resolvedPackages = await _packages.ToAsyncEnumerable()
+                                                  .SelectAwait(async b =>
+                                                  {
+                                                      var reader = await _packageResolver!.GetPackageAsync(b);
+                                                      var items = await reader.GetItemsAsync();
+
+                                                      return (b, items);
+                                                  }).ToDictionaryAsync(b => b.b.Name, b => b,
+                                                                       StringComparer.OrdinalIgnoreCase);
+
+            var dependencies = new Dictionary<PackageDependency, IEnumerable<IPackageItem>>(
+                resolvedPackages.Values.SelectMany(b => b.items.Dependencies)
+                                .Where(b => !resolvedPackages.ContainsKey(b.Key.Name))
+                                .GroupBy(b => b.Key.Name)
+                                .Select(b => b.MaxBy(c => c.Key.Version)));
+
+            _loadContext = new("PackageManager Context");
+
+            var dependencyAssemblies = await dependencies.ToAsyncEnumerable().SelectAwait(async pair =>
+            {
+                var (dep, items) = pair;
+                var assemblies = await LoadAssembliesFromItems(items);
+
+                return (dep, assemblies);
+            }).ToDictionaryAsync(b => b.dep, b => b.assemblies);
+
+            var packageAssemblies = await resolvedPackages.Values.ToAsyncEnumerable().SelectAwait(async b =>
+            {
+                var assemblies = await LoadAssembliesFromItems(b.items.Root);
+
+                return (b.b, assemblies);
+            }).ToDictionaryAsync(b => b.b, b => b.assemblies);
+
+            foreach (var assembly in dependencyAssemblies.Values.Concat(packageAssemblies.Values).SelectMany(b => b))
+            {
+                TorchLauncher.RegisterAssembly(assembly);
+            }
+
+            foreach (var (package, assemblies) in packageAssemblies)
+            {
+                using var hash = MD5.Create();
+                hash.Initialize();
+                var guid = new Guid(hash.ComputeHash(Encoding.UTF8.GetBytes(package.Name)));
+                
+                _pluginManager.InstantiatePlugin(new()
+                {
+                    Name = package.Name,
+                    Version = package.Version.ToString(),
+                    Guid = guid
+                }, assemblies);
+            }
+
+            _packageAssemblies = packageAssemblies.ToImmutableDictionary();
+        }
+        finally
+        {
+            semaphore.Release();
+        }
+    }
+
+    private async Task<Assembly[]> LoadAssembliesFromItems(IEnumerable<IPackageItem> items)
+    {
+        var dictionary = items.ToImmutableDictionary(b => b.FileName, StringComparer.OrdinalIgnoreCase);
+
+        var assemblies = await dictionary
+                               .Where(b => Path.GetExtension(b.Key)
+                                               .Equals("dll", StringComparison.OrdinalIgnoreCase))
+                               .ToAsyncEnumerable()
+                               .SelectAwait(async b =>
+                               {
+                                   dictionary.TryGetValue(
+                                       Path.ChangeExtension(b.Key, "pdb"), out var pdbItem);
+                                   return await LoadFromStream(b.Key, b.Value, pdbItem);
+                               }).ToArrayAsync();
+        return assemblies;
+    }
+
+    private async ValueTask<Assembly> LoadFromStream(string key, IPackageItem dllItem, IPackageItem? pdbItem)
+    {
+        if (_loadContext is null)
+            throw new InvalidOperationException("Load Context should be initialized before calling the method");
+
+        Log.Trace("Loading {0}", key);
+        await using var dll = await dllItem.OpenFileAsync();
+        if (pdbItem is null)
+            return _loadContext.LoadFromStream(dll);
+
+        await using var pdb = await pdbItem.OpenFileAsync();
+        return _loadContext.LoadFromStream(dll, pdb);
+    }
+
+    private async Task ResolvePackagesAsync(IReadOnlyDictionary<string, string> requestedPackages)
+    {
+        Log.Info("Resolving packages");
+        var packages = await _packageResolver!.ResolvePackagesAsync(requestedPackages);
+
+        _packages = packages.ToImmutableHashSet();
+        Log.Info("Got {0} packages", _packages.Count);
+    }
+}

Torch/Patches/ModsDownloadingPatch.cs

@@ -10,6 +10,7 @@ using Torch.Managers.PatchManager;
 using Torch.Managers.PatchManager.MSIL;
 using Torch.Utils;
 using VRage.Game;
+using VRage.GameServices;
 
 namespace Torch.Patches
 {
@@ -31,7 +32,7 @@ namespace Torch.Patches
         }
         public static void Postfix(MyWorkshop.ResultData __result, List<MyObjectBuilder_Checkpoint.ModItem> mods)
         {
-            if (__result.Success) return;
+            if (__result.Result is MyGameServiceCallResult.OK) return;
             _log.Warn("Missing Mods:");
             var mismatchMods = mods.Where(b => __result.Mods.All(c => b.PublishedFileId != c.Id));
             foreach (var mod in mismatchMods)

Torch/Patches/ObjectFactoryInitPatch.cs

@@ -1,139 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Reflection;
-using System.Runtime.CompilerServices;
-using Sandbox;
-using Sandbox.Game.Entities;
-using Torch.Utils;
-using VRage.Game.Common;
-using VRage.Game.Components;
-using VRage.Game.Entity;
-using VRage.ObjectBuilders;
-using VRage.Plugins;
-using VRage.Utils;
-
-namespace Torch.Patches
-{
-
-    /// <summary>
-    /// There are places in static ctors where the registered assembly depends on the <see cref="Assembly.GetCallingAssembly"/>
-    /// or <see cref="MyPlugins"/>.  Here we force those registrations with the proper assemblies to ensure they work correctly.
-    /// </summary>
-    internal static class ObjectFactoryInitPatch
-    {
-#pragma warning disable 649
-        [ReflectedGetter(Name = "m_objectFactory", TypeName = "Sandbox.Game.Entities.MyEntityFactory, Sandbox.Game")]
-        private static Func<MyObjectFactory<MyEntityTypeAttribute, MyEntity>> EntityFactoryObjectFactory;
-#pragma warning restore 649
-
-        internal static void ForceRegisterAssemblies()
-        {
-            var userAssemblies = MyPlugins.UserAssemblies;
-            // static MyEntities() called by MySandboxGame.ForceStaticCtor
-            RuntimeHelpers.RunClassConstructor(typeof(MyEntities).TypeHandle);
-            {
-                MyObjectFactory<MyEntityTypeAttribute, MyEntity> factory = EntityFactoryObjectFactory();
-                ObjectFactory_RegisterFromAssemblySafe(factory, typeof(MySandboxGame).Assembly); // calling assembly
-                ObjectFactory_RegisterFromAssemblySafe(factory, MyPlugins.GameAssembly);
-                ObjectFactory_RegisterFromAssemblySafe(factory, MyPlugins.SandboxAssembly);
-                //ObjectFactory_RegisterFromAssemblySafe(factory, MyPlugins.UserAssembly);
-                if (userAssemblies != null)
-                {
-                    foreach (var assembly in userAssemblies)
-                    {
-                        ObjectFactory_RegisterFromAssemblySafe(factory, assembly);
-                    }
-                }
-            }
-
-            // static MyGuiManager():
-            // MyGuiControlsFactory.RegisterDescriptorsFromAssembly();
-
-            // static MyComponentTypeFactory() called by MyComponentContainer.Add
-            RuntimeHelpers.RunClassConstructor(typeof(MyComponentTypeFactory).TypeHandle);
-            {
-                ComponentTypeFactory_RegisterFromAssemblySafe(typeof(MyComponentContainer).Assembly); // calling assembly
-                ComponentTypeFactory_RegisterFromAssemblySafe(MyPlugins.SandboxAssembly);
-                ComponentTypeFactory_RegisterFromAssemblySafe(MyPlugins.GameAssembly);
-                ComponentTypeFactory_RegisterFromAssemblySafe(MyPlugins.SandboxGameAssembly);
-                //ComponentTypeFactory_RegisterFromAssemblySafe(MyPlugins.UserAssembly);
-                if (userAssemblies != null)
-                {
-                    foreach (var assembly in userAssemblies)
-                    {
-                        ComponentTypeFactory_RegisterFromAssemblySafe(assembly);
-                    }
-                }
-            }
-
-            MyEntities.Orchestrator = new MyParallelEntityUpdateOrchestrator();
-
-            // static MyObjectPoolManager()
-            // Render, so should be fine.
-        }
-
-        #region MyObjectFactory Adders
-        private static void ObjectFactory_RegisterDescriptorSafe<TAttribute, TCreatedObjectBase>(
-            MyObjectFactory<TAttribute, TCreatedObjectBase> factory, TAttribute descriptor, Type type) where TAttribute : MyFactoryTagAttribute where TCreatedObjectBase : class
-        {
-            if (factory.Attributes.TryGetValue(type, out _))
-                return;
-            if (descriptor.ObjectBuilderType != null && factory.TryGetProducedType(descriptor.ObjectBuilderType) != null)
-                return;
-            if (typeof(MyObjectBuilder_Base).IsAssignableFrom(descriptor.ProducedType) &&
-                factory.TryGetProducedType(descriptor.ProducedType) != null)
-                return;
-            factory.RegisterDescriptor(descriptor, type);
-        }
-
-        private static void ObjectFactory_RegisterFromAssemblySafe<TAttribute, TCreatedObjectBase>(MyObjectFactory<TAttribute, TCreatedObjectBase> factory, Assembly assembly) where TAttribute : MyFactoryTagAttribute where TCreatedObjectBase : class
-        {
-            if (assembly == null)
-            {
-                return;
-            }
-            foreach (Type type in assembly.GetTypes())
-            {
-                foreach (TAttribute descriptor in type.GetCustomAttributes<TAttribute>())
-                {
-                    ObjectFactory_RegisterDescriptorSafe(factory, descriptor, type);
-                }
-            }
-        }
-        #endregion
-        #region MyComponentTypeFactory Adders
-
-        [ReflectedGetter(Name = "m_idToType", Type = typeof(MyComponentTypeFactory))]
-        private static Func<Dictionary<MyStringId, Type>> ComponentTypeFactoryIdToType = null!;
-        [ReflectedGetter(Name = "m_typeToId", Type = typeof(MyComponentTypeFactory))]
-        private static Func<Dictionary<Type, MyStringId>> ComponentTypeFactoryTypeToId = null!;
-        [ReflectedGetter(Name = "m_typeToContainerComponentType", Type = typeof(MyComponentTypeFactory))]
-        private static Func<Dictionary<Type, Type>> ComponentTypeFactoryContainerComponentType = null!;
-
-        private static void ComponentTypeFactory_RegisterFromAssemblySafe(Assembly assembly)
-        {
-            if (assembly == null)
-                return;
-            foreach (Type type in assembly.GetTypes())
-                if (typeof(MyComponentBase).IsAssignableFrom(type))
-                {
-                    ComponentTypeFactory_AddIdSafe(type, MyStringId.GetOrCompute(type.Name));
-                    ComponentTypeFactory_RegisterComponentTypeAttributeSafe(type);
-                }
-        }
-
-        private static void ComponentTypeFactory_RegisterComponentTypeAttributeSafe(Type type)
-        {
-            Type componentType = type.GetCustomAttribute<MyComponentTypeAttribute>(true)?.ComponentType;
-            if (componentType != null)
-                ComponentTypeFactoryContainerComponentType()[type] = componentType;
-        }
-
-        private static void ComponentTypeFactory_AddIdSafe(Type type, MyStringId id)
-        {
-            ComponentTypeFactoryIdToType()[id] = type;
-            ComponentTypeFactoryTypeToId()[type] = id;
-        }
-        #endregion
-    }
-}

Torch/Patches/ScriptCompilerPatch.cs

@@ -58,10 +58,10 @@ namespace Torch.Patches
                 typeof(TypeConverter).Assembly.Location,
                 typeof(System.Diagnostics.TraceSource).Assembly.Location,
                 typeof(System.Security.Policy.Evidence).Assembly.Location,
-                typeof(ProtoBuf.Meta.RuntimeTypeModel).Assembly.Location,
+                Path.Combine(baseDir, "System.Xml.ReaderWriter.dll"),
-                typeof(ProtoContractAttribute).Assembly.Location,
                 Path.Combine(baseDir, "netstandard.dll"),
                 Path.Combine(baseDir, "System.Runtime.dll"),
+                Path.Combine(MyFileSystem.ExePath, "ProtoBuf.Net.Core.dll"),
                 Path.Combine(MyFileSystem.ExePath, "Sandbox.Game.dll"),
                 Path.Combine(MyFileSystem.ExePath, "Sandbox.Common.dll"),
                 Path.Combine(MyFileSystem.ExePath, "Sandbox.Graphics.dll"),
@@ -83,14 +83,6 @@ namespace Torch.Patches
 
             using var batch = MyScriptCompiler.Static.Whitelist.OpenBatch();
             batch.AllowTypes(MyWhitelistTarget.ModApi, typeof(ConcurrentQueue<>));
-            batch.AllowNamespaceOfTypes(MyWhitelistTarget.Both, typeof(ImmutableArray), typeof(ArrayExtensions));
-            batch.AllowTypes(MyWhitelistTarget.ModApi, typeof(ProtoContractAttribute).Assembly.GetExportedTypes()
-                                 .Where(b => b.Namespace == "ProtoBuf" && b.Name.Contains("Attribute"))
-                                 .Concat(new[]
-                                 {
-                                     typeof(DataFormat), typeof(MemberSerializationOptions), typeof(ImplicitFields)
-                                 }).ToArray());
-            batch.AllowTypes(MyWhitelistTarget.ModApi, typeof(WorkData));
             
             return false;
         }

Torch/Plugins/PluginManager.cs

@@ -386,11 +386,7 @@ namespace Torch.Managers
             }
 
             var harmonyAssembly = assemblies.FirstOrDefault(b => b.FullName?.StartsWith("0Harmony") == true);
-            if (harmonyAssembly is { })
+            if (harmonyAssembly is { }) assemblies.Remove(harmonyAssembly);
-            {
-                _log.Warn($"Plugin {item.Manifest.Name} is using harmony library, logic collision between plugins could be encountered!");
-                assemblies.Remove(harmonyAssembly);
-            }
 
             RegisterAllAssemblies(assemblies);
             InstantiatePlugin(item.Manifest, assemblies);

Torch/Torch.csproj

@@ -24,18 +24,18 @@
   
   <ItemGroup>
     <PackageReference Include="ControlzEx" Version="5.0.2" />
-    <PackageReference Include="HarmonyX" Version="2.10.2-prerelease.3" />
+    <PackageReference Include="HarmonyX" Version="2.10.2-prerelease.4" />
     <PackageReference Include="InfoOf.Fody" Version="2.1.1" PrivateAssets="all" />
     <PackageReference Include="MahApps.Metro" Version="2.4.9" />
     <PackageReference Include="Microsoft.CodeAnalysis.Common" Version="4.4.0" />
     <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.4.0" />
-    <PackageReference Include="MonoModReorg.RuntimeDetour" Version="23.1.2-prerelease.1" />
+    <PackageReference Include="MonoModReorg.RuntimeDetour" Version="23.3.22.1" />
     <PackageReference Include="NLog" Version="5.1.0" />
     <PackageReference Include="PropertyChanged.Fody" Version="4.1.0" PrivateAssets="all" />
     <PackageReference Include="protobuf-net" Version="3.1.26" />
     <PackageReference Include="System.ComponentModel.Annotations" Version="5.0.0" />
     <PackageReference Include="Torch.SixLabors.ImageSharp" Version="1.0.0-beta6" />
-    <PackageReference Include="SpaceEngineersDedicated.ReferenceAssemblies" Version="1.201.13">
+    <PackageReference Include="SpaceEngineersDedicated.ReferenceAssemblies" Version="1.202.120">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>compile</IncludeAssets>
     </PackageReference>

Torch/TorchBase.cs

@@ -10,6 +10,7 @@ using Sandbox;
 using Sandbox.Game;
 using Sandbox.Game.Multiplayer;
 using Sandbox.Game.Screens.Helpers;
+using SpaceEngineers.Game;
 using Torch.API;
 using Torch.API.Managers;
 using Torch.API.ModAPI;
@@ -113,12 +114,6 @@ namespace Torch
             Plugins = new PluginManager(this);
 #pragma warning restore CS0618
 
-            var sessionManager = new TorchSessionManager(this);
-            sessionManager.AddFactory((x) => Sync.IsServer ? new ChatManagerServer(this) : new ChatManagerClient(this));
-            sessionManager.AddFactory((x) => Sync.IsServer ? new CommandManager(this) : null);
-            sessionManager.AddFactory((x) => new EntityManager(this));
-
-            Managers.AddManager(sessionManager);
             Managers.AddManager(new PatchManager(this));
             Managers.AddManager(new FilesystemManager(this));
             Managers.AddManager(new UpdateManager(this));
@@ -133,13 +128,7 @@ namespace Torch
             GameStateChanged += (game, state) =>
             {
                 if (state == TorchGameState.Created) 
-                {
-                    // If the attached assemblies change (MySandboxGame.ctor => MySandboxGame.ParseArgs => MyPlugins.RegisterFromArgs)
-                    // attach assemblies to object factories again.
-                    ObjectFactoryInitPatch.ForceRegisterAssemblies();
-                    // safe to commit here; all important static ctors have run
                     PatchManager.CommitInternal();
-                }
             };
 
             var harmonyLog = LogManager.GetLogger("HarmonyX");
@@ -259,7 +248,8 @@ namespace Torch
         public virtual void Init()
         {
             Debug.Assert(!_init, "Torch instance is already initialized.");
-            ObjectFactoryInitPatch.ForceRegisterAssemblies();
+            SpaceEngineersGame.SetupBasicGameInfo();
+            SpaceEngineersGame.SetupPerGameSettings();
             VRageGame.SetupVersionInfo();
 
             Debug.Assert(MyPerGameSettings.BasicGameInfo.GameVersion != null, "MyPerGameSettings.BasicGameInfo.GameVersion != null");
@@ -293,6 +283,15 @@ namespace Torch
             Game = new VRageGame(this, TweakGameSettings, SteamAppName, SteamAppId, InstancePath, RunArgs);
             if (!Game.WaitFor(VRageGame.GameState.Stopped))
                 Log.Warn("Failed to wait for game to be initialized");
+            
+            var sessionManager = new TorchSessionManager(this);
+            sessionManager.AddFactory((x) => Sync.IsServer ? new ChatManagerServer(this) : new ChatManagerClient(this));
+            sessionManager.AddFactory((x) => Sync.IsServer ? new CommandManager(this) : null);
+            sessionManager.AddFactory((x) => new EntityManager(this));
+
+            Managers.AddManager(sessionManager);
+
+            
             Managers.Attach();
             _init = true;
 

Torch/Utils/TorchLauncher.cs

@@ -47,7 +47,7 @@ namespace Torch.Utils
         
         private static void CopyNative()
         {
-            if (ApplicationContext.Current.GameFilesDirectory.Attributes.HasFlag(FileAttributes.ReadOnly))
+            if (ApplicationContext.Current.IsService || ApplicationContext.Current.GameFilesDirectory.Attributes.HasFlag(FileAttributes.ReadOnly))
             {
                 Log.Warn("Torch directory is readonly. You should copy steam_api64.dll, Havok.dll from bin manually");
                 return;

Torch/VRageGame.cs

@@ -152,6 +152,7 @@ namespace Torch
             Environment.SetEnvironmentVariable("SteamAppId", _appSteamId.ToString());
             MyVRageWindows.Init("SpaceEngineersDedicated", MySandboxGame.Log, null, false);
             SpaceEngineersGame.SetupPerGameSettings();
+            SpaceEngineersGame.SetupBasicGameInfo();
             MySessionComponentExtDebug.ForceDisable = true;
             MyPerGameSettings.SendLogToKeen = false;
             // SpaceEngineersGame.SetupAnalytics();
@@ -165,7 +166,7 @@ namespace Torch
             _tweakGameSettings();
 
             MyFileSystem.Reset();
-            MyInitializer.InvokeBeforeRun(_appSteamId, _appName, _userDataPath);
+            MyInitializer.InvokeBeforeRun(_appSteamId, _appName, MyVRage.Platform.System.GetRootPath(), _userDataPath);
 
             _log.Info("Loading Dedicated Config");
             // object created in SpaceEngineersGame.SetupPerGameSettings()
@@ -193,7 +194,7 @@ namespace Torch
             {
                 service = MyEOSService.Create();
 
-                MyEOSService.InitNetworking(dedicated,
+                MyEOSService.InitNetworking(dedicated, true, //true because using Eos
                     "Space Engineers",
                     service,
                     "xyza7891A4WeGrpP85BTlBa3BSfUEABN",
@@ -225,7 +226,8 @@ namespace Torch
             
             MyGameService.WorkshopService.AddAggregate(MyModIoService.Create(service, "spaceengineers", "264",
                 "1fb4489996a5e8ffc6ec1135f9985b5b", "331", "f2b64abe55452252b030c48adc0c1f0e",
-                MyPlatformGameSettings.UGC_TEST_ENVIRONMENT, true));
+                MyPlatformGameSettings.UGC_TEST_ENVIRONMENT, true, MyPlatformGameSettings.MODIO_PLATFORM,
+                MyPlatformGameSettings.MODIO_PORTAL));
             
             if (!isEos && !MyGameService.HasGameServer)
             {

Torch/packages.lock.json

@@ -14,11 +14,11 @@
       },
       "HarmonyX": {
         "type": "Direct",
-        "requested": "[2.10.2-prerelease.3, )",
+        "requested": "[2.10.2-prerelease.4, )",
-        "resolved": "2.10.2-prerelease.3",
+        "resolved": "2.10.2-prerelease.4",
-        "contentHash": "XnR2oKlFTCb7F+90OkJR0cqOYOsSPgsQrnX2v9qR0nmM6SPSET/v2SR9vjY/DQhBYUQia16NWv0Mwd8Ml4ZqKA==",
+        "contentHash": "M/44/DhSu1WR8gL62aLPGKqAJ0rrgkw38nT3DgEvLAvyIoQLJmL2Jsn4/d4CC0eDT1Vv82cB9Mxgg0sFD3/qrQ==",
         "dependencies": {
-          "MonoModReorg.RuntimeDetour": "23.1.2-prerelease.1"
+          "MonoModReorg.RuntimeDetour": "23.3.22.1"
         }
       },
       "InfoOf.Fody": {
@@ -65,15 +65,15 @@
       },
       "MonoModReorg.RuntimeDetour": {
         "type": "Direct",
-        "requested": "[23.1.2-prerelease.1, )",
+        "requested": "[23.3.22.1, )",
-        "resolved": "23.1.2-prerelease.1",
+        "resolved": "23.3.22.1",
-        "contentHash": "UZyJ7OIbLCIBg+dzLejWq2paL1s11koUrq1noSLGCP9uNmFjwDPK+lRmGs0X4qg+Alfq6VsOpI45pGqmaAvP+Q==",
+        "contentHash": "cUES3Hi7QJtBNe0qwVdjZOCDkZDaCpdqS6Au0RaCyQ1PDIR4av13E9qBNAEYew46sgPe0fOrU334md6DLDGHlQ==",
         "dependencies": {
           "Mono.Cecil": "0.11.4",
-          "MonoModReorg.Backports": "23.1.2-prerelease.1",
+          "MonoModReorg.Backports": "23.3.22.1",
-          "MonoModReorg.Core": "23.1.2-prerelease.1",
+          "MonoModReorg.Core": "23.3.22.1",
-          "MonoModReorg.ILHelpers": "23.1.2-prerelease.1",
+          "MonoModReorg.ILHelpers": "23.3.22.1",
-          "MonoModReorg.Utils": "23.1.2-prerelease.1"
+          "MonoModReorg.Utils": "23.3.22.1"
         }
       },
       "NLog": {
@@ -102,9 +102,9 @@
       },
       "SpaceEngineersDedicated.ReferenceAssemblies": {
         "type": "Direct",
-        "requested": "[1.201.13, )",
+        "requested": "[1.202.120, )",
-        "resolved": "1.201.13",
+        "resolved": "1.202.120",
-        "contentHash": "FRXuNLENsz5jGQvL0QkogAGsxEJyUQlXhvWHBWfZiHCnCrAWMD60nEis6yt0xCQpazszfMtHonbxz72XMxnFoQ==",
+        "contentHash": "HTP48NOSZY3eQPX3GJN+gjxdW83SM7DX6NcKCFqNIIvjz/J+l8uimHAQp9dnLySb0wb1K1Z1xBPIXyxMQRREIw==",
         "dependencies": {
           "protobuf-net": "1.0.0"
         }
@@ -157,36 +157,36 @@
       },
       "MonoModReorg.Backports": {
         "type": "Transitive",
-        "resolved": "23.1.2-prerelease.1",
+        "resolved": "23.3.22.1",
-        "contentHash": "m1wlCgVjZTFJs3mUxmC1aE/O0RIvsNbSFBI/g93Bqzz1tHa+LhXFyrHzL60PeZMQBIPVy3CeDX4um/UrqLOn/g==",
+        "contentHash": "nLx18prtZbS0nVO8YHElP+TUj1kkDswRgQpa9agt3tyNWke9Kqk5lVkGu87Y3cCMhG+m5Ai0ZDH0+V5B6bXF+Q==",
         "dependencies": {
-          "MonoModReorg.ILHelpers": "23.1.2-prerelease.1"
+          "MonoModReorg.ILHelpers": "23.3.22.1"
         }
       },
       "MonoModReorg.Core": {
         "type": "Transitive",
-        "resolved": "23.1.2-prerelease.1",
+        "resolved": "23.3.22.1",
-        "contentHash": "t1Y89M0rbwUx2VjDMCJOWgtSdsi1F5KNu0O6JAMOtwo2EWJ0HfYj9nS8UWWPwrgRpsquGjqbmYA8jhb59F2a/A==",
+        "contentHash": "Q3ZOgm6AOTL0icgcHsT/6mV5kYt6meqX3DEN1p/et5PxJsXUhVkiZfAptp8y/i+cO6HNgkcESpXEQ4jUWVwsDA==",
         "dependencies": {
           "Mono.Cecil": "0.11.4",
-          "MonoModReorg.Backports": "23.1.2-prerelease.1",
+          "MonoModReorg.Backports": "23.3.22.1",
-          "MonoModReorg.ILHelpers": "23.1.2-prerelease.1",
+          "MonoModReorg.ILHelpers": "23.3.22.1",
-          "MonoModReorg.Utils": "23.1.2-prerelease.1"
+          "MonoModReorg.Utils": "23.3.22.1"
         }
       },
       "MonoModReorg.ILHelpers": {
         "type": "Transitive",
-        "resolved": "23.1.2-prerelease.1",
+        "resolved": "23.3.22.1",
-        "contentHash": "GVh1cmrTCAK0zHr3t8aHnKsyKIlDFiDERn++lCZomHcYc8dgcOAhpkZ7KmaKgZCTJuBIrc44RjpKFr/4ScQnGA=="
+        "contentHash": "dHE/3VZtnTUTkQ34j8Gu6CxKes1QDL8tBuF3QElxHHpPl/QabGCK938k47WWRcRBMoP7IAthkn+Bob4H97rBgw=="
       },
       "MonoModReorg.Utils": {
         "type": "Transitive",
-        "resolved": "23.1.2-prerelease.1",
+        "resolved": "23.3.22.1",
-        "contentHash": "6N4LNG+x4RVPLOc8QWL7dc5sqWdl0gxR+4ASRd1CvvappsK84ISgD9qgeYHgQQtTgE+h6Cuqr3Om4Ly0roLfoA==",
+        "contentHash": "q1cX0mbYxdw2WcE/qGBB84lVY/ffobEr46VQFuwGcWhtw6f1Ql1k4TZfs8gebpesSxHnca13grLeVHrUSpy1+g==",
         "dependencies": {
           "Mono.Cecil": "0.11.4",
-          "MonoModReorg.Backports": "23.1.2-prerelease.1",
+          "MonoModReorg.Backports": "23.3.22.1",
-          "MonoModReorg.ILHelpers": "23.1.2-prerelease.1"
+          "MonoModReorg.ILHelpers": "23.3.22.1"
         }
       },
       "Newtonsoft.Json": {