fix because retarded exmaples

(cherry picked from commit c81f139fe6b5de0c9f7a005dc2cbe576f4ca8f67)

.github/workflows/release.yaml

@@ -8,9 +8,9 @@ on:
 jobs:
   build:
     name: Build
-    runs-on: windows-latest
+    runs-on: ubuntu-latest
     env:
-      VERSION: ${{ github.ref_name }}
+      TORCH_VERSION: ${{ github.ref_name }}
       BUILD_CONFIGURATION: Release
       DOTNET_NOLOGO: true
       DOTNET_CLI_TELEMETRY_OPTOUT: true
@@ -31,10 +31,15 @@ jobs:
         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 --use-lock-file
+      - uses: bhowell2/github-substring-action@v1.0.0
+        id: normalize_version
+        with:
+          value: ${{ env.TORCH_VERSION }}
+          index_of_str: "v"
       - name: Build
-        run: dotnet build Torch.Server/Torch.Server.csproj --no-restore -c $env:BUILD_CONFIGURATION /p:AssemblyVersion=$env:VERSION /p:Version=$env:VERSION
+        run: dotnet build Torch.Server/Torch.Server.csproj --no-restore -c ${{ env.BUILD_CONFIGURATION }} /p:AssemblyVersion=${{ env.TORCH_VERSION }} /p:Version=${{ steps.normalize_version.outputs.substring }}
       - name: Publish
-        run: dotnet publish Torch.Server/Torch.Server.csproj --no-build -r win-x64 --sc -c $env:BUILD_CONFIGURATION
+        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:
@@ -45,14 +50,16 @@ jobs:
         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.VERSION }}
-          release_name: Release v${{ env.VERSION }}
+          tag_name: ${{ env.TORCH_VERSION }}
+          release_name: Release v${{ env.TORCH_VERSION }}
           body: ${{ steps.github_release.outputs.changelog }}
           draft: true
           prerelease: false

README.md

@@ -12,7 +12,10 @@ Torch is the successor to SE Server Extender and gives server admins the tools t
 
 ### Fork Difference
 * .NET 6.0 runtime
-* Additional options & features
+* Optimized in-game scripts (also newer compiler & language versions)
+* Better configuration via cli arguments, environment variables or xml config
+* Designed to run multiple instance from same install directory without having you to waste disk space 
+* Mostly compatible with original torch's plugins
 
 ### Discord
 
@@ -21,10 +24,13 @@ If you have any questions or issues please join our [discord](https://discord.gg
 ### Installation
 
 * Unzip the Torch release into its own directory and run the executable. It will automatically download the SE DS and generate the other necessary files.
-  - If you already have a DS installed you can unzip the Torch files into the folder that contains the DedicatedServer64 folder.
+  - If you already have a DS installed you can:
+    * Unzip the Torch files into the folder that contains the DedicatedServer64 folder.
+    * Pass path to game files using config parameter `gamePath`
 
 # Building
-To build Torch you must first have a complete SE Dedicated installation somewhere. Before you open the solution, run the Setup batch file and enter the path of that installation's DedicatedServer64 folder. The script will make a symlink to that folder so the Torch solution can find the DLL references it needs.
+
+As a regular dotnet project with cli by running `dotnet build Torch.Server/Torch.Server.csproj`, with VS 2022 or higher, with JB Rider or Fleet.
 
 If you have a more enjoyable server experience because of Torch, please consider supporting us on Patreon. (https://www.patreon.com/TorchSE)
 

Torch.API/ITorchConfig.cs

@@ -31,6 +31,23 @@ namespace Torch
         int FontSize { get; set; }
         UGCServiceType UgcServiceType { get; set; }
         bool EntityManagerEnabled { get; set; }
+        string LoginToken { get; set; }
+        UpdateSource UpdateSource { get; set; }
+        
         void Save(string path = null);
     }
+
+    public class UpdateSource
+    {
+        public UpdateSourceType SourceType { get; set; }
+        public string Url { get; set; }
+        public string Repository { get; set; }
+        public string Branch { get; set; }
+    }
+
+    public enum UpdateSourceType
+    {
+        Github,
+        Jenkins
+    }
 }

Torch.API/Torch.API.csproj

@@ -8,9 +8,7 @@
     <GenerateAssemblyConfigurationAttribute>false</GenerateAssemblyConfigurationAttribute>
     <OutputPath>..\bin\$(Platform)\$(Configuration)\</OutputPath>
     <UseWpf>True</UseWpf>
-    <PlatformTarget>x64</PlatformTarget>
-    <Configurations>Debug;Release</Configurations>
-    <Platforms>AnyCPU</Platforms>
+    <EnableWindowsTargeting>true</EnableWindowsTargeting>
   </PropertyGroup>
   
   <PropertyGroup Condition="$(Configuration) == 'Release'">
@@ -18,6 +16,7 @@
   </PropertyGroup>
   
   <ItemGroup>
+    <PackageReference Include="JorgeSerrano.Json.JsonSnakeCaseNamingPolicy" Version="0.9.0" />
     <PackageReference Include="NLog" Version="5.0.4" />
     <PackageReference Include="SemanticVersioning" Version="2.0.2" />
     <PackageReference Include="SpaceEngineersDedicated.ReferenceAssemblies" Version="1.201.13">

Torch.API/WebAPI/GithubQuery.cs

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

Torch.API/WebAPI/IUpdateQuery.cs

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

Torch.API/WebAPI/JenkinsQuery.cs

@@ -1,82 +1,52 @@
 using System;
 using System.Collections.Generic;
-using System.IO;
 using System.Linq;
-using System.Net;
 using System.Net.Http;
 using System.Net.Http.Json;
-using System.Text;
 using System.Text.Json.Serialization;
 using System.Threading.Tasks;
-using NLog;
 using Torch.API.Utils;
 using Version = SemanticVersioning.Version;
 
 namespace Torch.API.WebAPI
 {
-    public class JenkinsQuery
+    public class JenkinsQuery : IUpdateQuery
     {
-        private const string BRANCH_QUERY = "http://136.243.80.164:2690/job/Torch/job/{0}/" + API_PATH;
-        private const string ARTIFACT_PATH = "artifact/bin/torch-server.zip";
-        private const string API_PATH = "api/json";
+        private const string ApiPath = "api/json";
+        private readonly HttpClient _client;
         
-        private static readonly Logger Log = LogManager.GetCurrentClassLogger();
-
-        private static JenkinsQuery _instance;
-        public static JenkinsQuery Instance => _instance ??= new JenkinsQuery();
-        private HttpClient _client;
-
-        private JenkinsQuery()
+        public JenkinsQuery(string url)
         {
-            _client = new HttpClient();
+            if (url == null) throw new ArgumentNullException(nameof(url));
+            
+            _client = new()
+            {
+                BaseAddress = new(url)
+            };
         }
 
-        public async Task<Job> GetLatestVersion(string branch)
+        public async Task<UpdateRelease> GetLatestReleaseAsync(string repository, string branch = null)
         {
-            var h = await _client.GetAsync(string.Format(BRANCH_QUERY, branch));
-            if (!h.IsSuccessStatusCode)
-            {
-                Log.Error($"'{branch}' Branch query failed with code {h.StatusCode}");
-                if(h.StatusCode == HttpStatusCode.NotFound)
-                    Log.Error("This likely means you're trying to update a branch that is not public on Jenkins. Sorry :(");
-                return null;
-            }
+            branch ??= "master";
 
-            var branchResponse = await h.Content.ReadFromJsonAsync<BranchResponse>();
+            var response = await _client.GetFromJsonAsync<BranchResponse>($"/job/{repository}/job/{branch}/{ApiPath}");
 
-            if (branchResponse is null)
-            {
-                Log.Error("Error reading branch response");
-                return null;
-            }
+            if (response is null)
+                throw new($"Unable to get latest release for {repository}");
 
-            h = await _client.GetAsync($"{branchResponse.LastStableBuild.Url}{API_PATH}");
-            if (h.IsSuccessStatusCode) 
-                return await h.Content.ReadFromJsonAsync<Job>();
+            var job = await _client.GetFromJsonAsync<Job>(
+                $"/job/{repository}/job/{branch}/{response.LastBuild.Number}/{ApiPath}");
             
-            Log.Error($"Job query failed with code {h.StatusCode}");
-            return null;
+            if (job is null)
+                throw new($"Unable to get latest release for job {repository}/{response.LastBuild.Number}");
 
+            return new(job.Version, job.Url + job.Artifacts.First(b => b.FileName == "torch-server.zip").RelativePath);
         }
 
-        public async Task<bool> DownloadRelease(Job job, string path)
+        public void Dispose()
         {
-            var h = await _client.GetAsync(job.Url + ARTIFACT_PATH);
-            if (!h.IsSuccessStatusCode)
-            {
-                Log.Error($"Job download failed with code {h.StatusCode}");
-                return false;
-            }
-            var s = await h.Content.ReadAsStreamAsync();
-#if !NETFRAMEWORK
-            await using var fs = new FileStream(path, FileMode.Create);
-#else
-            using var fs = new FileStream(path, FileMode.Create);
-#endif
-            await s.CopyToAsync(fs);
-            return true;
+            _client?.Dispose();
         }
-
     }
 
     public record BranchResponse(string Name, string Url, Build LastBuild, Build LastStableBuild);
@@ -84,5 +54,12 @@ namespace Torch.API.WebAPI
     public record Build(int Number, string Url);
 
     public record Job(int Number, bool Building, string Description, string Result, string Url,
-        [property: JsonConverter(typeof(SemanticVersionConverter))] Version Version);
+        [property: JsonConverter(typeof(SemanticVersionConverter))] Version Version,
+                      IReadOnlyList<Artifact> Artifacts);
+    
+    public record Artifact(
+        string DisplayPath,
+        string FileName,
+        string RelativePath
+    );
 }

Torch.API/WebAPI/PluginQuery.cs

@@ -14,7 +14,7 @@ namespace Torch.API.WebAPI
     public class PluginQuery
     {
         private const string ALL_QUERY = "https://torchapi.com/api/plugins/";
-        private const string PLUGIN_QUERY = "https://torchapi.com/api/plugins/?guid={0}";
+        private const string PLUGIN_QUERY = "https://torchapi.com/api/plugins/search/{0}";
         private readonly HttpClient _client;
         private static readonly Logger Log = LogManager.GetCurrentClassLogger();
 

Torch.API/WebAPI/UpdateRelease.cs

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

Torch.Server/Initializer.cs

@@ -57,7 +57,7 @@ namespace Torch.Server
 #endif
             
             if (!configuration.GetValue("noupdate", false))
-                RunSteamCmd();
+                RunSteamCmd(configuration);
 
             var processPid = configuration.GetValue<int>("waitForPid");
             if (processPid != 0)
@@ -124,11 +124,12 @@ namespace Torch.Server
             }
         }
         
-        public static void RunSteamCmd()
+        public static void RunSteamCmd(IConfiguration configuration)
         {
             var log = LogManager.GetLogger("SteamCMD");
 
-            var path = Environment.GetEnvironmentVariable("TORCH_STEAMCMD") ?? Path.GetFullPath(STEAMCMD_DIR);
+            var path = configuration.GetValue<string>("steamCmdPath") ?? ApplicationContext.Current.TorchDirectory
+                .CreateSubdirectory(STEAMCMD_DIR).FullName;
             
             if (!Directory.Exists(path))
             {
@@ -143,7 +144,8 @@ namespace Torch.Server
                     log.Info("Downloading SteamCMD.");
                     using (var client = new HttpClient()) 
                     using (var file = File.Create(STEAMCMD_ZIP))
-                        client.GetStreamAsync("https://steamcdn-a.akamaihd.net/client/installer/steamcmd.zip").Result.CopyTo(file);
+                    using (var stream = client.GetStreamAsync("https://steamcdn-a.akamaihd.net/client/installer/steamcmd.zip").Result)
+                        stream.CopyTo(file);
 
                     ZipFile.ExtractToDirectory(STEAMCMD_ZIP, path);
                     File.Delete(STEAMCMD_ZIP);
@@ -159,7 +161,7 @@ namespace Torch.Server
             log.Info("Checking for DS updates.");
             var steamCmdProc = new ProcessStartInfo(steamCmdExePath)
             {
-                Arguments = string.Format(STEAMCMD_ARGS, Environment.GetEnvironmentVariable("TORCH_GAME_PATH") ?? "../"),
+                Arguments = string.Format(STEAMCMD_ARGS, configuration.GetValue("gamePath", "../")),
                 WorkingDirectory = path,
                 UseShellExecute = false,
                 RedirectStandardOutput = true,

Torch.Server/Patches/SteamLoginPatch.cs

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

Torch.Server/Program.cs

@@ -90,8 +90,6 @@ namespace Torch.Server
             var gamePath = configuration.GetValue("gamePath", workingDir);
             var binDir = Path.Combine(gamePath, "DedicatedServer64");
 
-            Directory.SetCurrentDirectory(gamePath);
-
             var instanceName = configuration.GetValue("instanceName", "Instance");
             string instancePath;
             
@@ -105,6 +103,8 @@ namespace Torch.Server
                 instancePath = Directory.CreateDirectory(instanceName!).FullName;
             }
             
+            Directory.SetCurrentDirectory(gamePath);
+            
             return new ApplicationContext(new(workingDir), new(gamePath), new(binDir), 
                 new(instancePath), instanceName, isService);
         }

Torch.Server/Torch.Server.csproj

@@ -15,7 +15,7 @@
     <UseWPF>true</UseWPF>
     <SatelliteResourceLanguages>en</SatelliteResourceLanguages>
     <NeutralLanguage>en</NeutralLanguage>
-    <PlatformTarget>x64</PlatformTarget>
+    <EnableWindowsTargeting>true</EnableWindowsTargeting>
   </PropertyGroup>
   
   <PropertyGroup>
@@ -45,6 +45,10 @@
     <PackageReference Include="Microsoft.Extensions.Configuration.Xml" Version="6.0.0" />
     <PackageReference Include="NLog" Version="5.0.4" />
     <PackageReference Include="PropertyChanged.Fody" Version="4.0.3" PrivateAssets="all" />
+    <PackageReference Include="Steamworks.NET" Version="20.1.0">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>compile</IncludeAssets>
+    </PackageReference>
     <PackageReference Include="System.ComponentModel.Annotations" Version="5.0.0" />
     <PackageReference Include="System.Management" Version="6.0.0" />
     <PackageReference Include="nulastudio.NetCoreBeauty" Version="1.2.9.3" />

Torch.Server/TorchConfig.cs

@@ -1,167 +1,124 @@
 using System;
 using System.Collections.Generic;
-using System.ComponentModel;
-using System.IO;
-using System.Runtime.CompilerServices;
 using System.Xml.Serialization;
-using NLog;
 using Torch.API;
 using Torch.Views;
 
-namespace Torch.Server
+namespace Torch.Server;
+
+public class TorchConfig : ViewModel, ITorchConfig
 {
-    // TODO: redesign this gerbage
-    public class TorchConfig : CommandLine, ITorchConfig, INotifyPropertyChanged
+    public bool ShouldUpdatePlugins => (GetPluginUpdates && !NoUpdate) || ForceUpdate;
+    public bool ShouldUpdateTorch => (GetTorchUpdates && !NoUpdate) || ForceUpdate;
+
+    /// <inheritdoc />
+    [XmlIgnore]
+    public bool NoUpdate { get; set; }
+
+    /// <inheritdoc />
+    [XmlIgnore]
+    public bool ForceUpdate { get; set; }
+
+    /// <summary>
+    /// Permanent flag to ALWAYS automatically start the server
+    /// </summary>
+    [Display(Name = "Auto Start", Description = "Permanent flag to ALWAYS automatically start the server.", GroupName = "Server")]
+    public bool Autostart { get; set; }
+
+    /// <summary>
+    /// Temporary flag to automatically start the server only on the next run
+    /// </summary>
+    [XmlIgnore]
+    public bool TempAutostart { get; set; }
+
+    /// <inheritdoc />
+    [Display(Name = "Restart On Crash", Description = "Automatically restart the server if it crashes.", GroupName = "Server")]
+    public bool RestartOnCrash { get; set; }
+
+    public string InstancePath { get; set; }
+
+    /// <inheritdoc />
+    [Display(Name = "No GUI", Description = "Do not show the Torch UI.", GroupName = "Window")]
+    public bool NoGui { get; set; }
+
+    /// <inheritdoc />
+    [Display(Name = "Update Torch", Description = "Check every start for new versions of torch.",
+             GroupName = "Server")]
+    public bool GetTorchUpdates { get; set; } = true;
+
+    public string InstanceName { get; set; }
+
+    /// <inheritdoc />
+    [Display(Name = "Update Plugins", Description = "Check every start for new versions of plugins.",
+             GroupName = "Server")]
+    public bool GetPluginUpdates { get; set; } = true;
+
+    /// <inheritdoc />
+    [Display(Name = "Watchdog Timeout", Description = "Watchdog timeout (in seconds).", GroupName = "Server")]
+    public int TickTimeout { get; set; } = 60;
+
+    /// <inheritdoc />
+    public List<Guid> Plugins { get; set; } = new();
+
+    [Display(Name = "Local Plugins", Description = "Loads all pluhins from disk, ignores the plugins defined in config.", GroupName = "In-Game")]
+    public bool LocalPlugins { get; set; }
+
+    [Display(Name = "Auto Disconnect", Description = "When server restarts, all clients are rejected to main menu to prevent auto rejoin.", GroupName = "In-Game")]
+    public bool DisconnectOnRestart { get; set; }
+
+    [Display(Name = "Chat Name", Description = "Default name for chat from gui, broadcasts etc..",
+             GroupName = "In-Game")]
+    public string ChatName { get; set; } = "Server";
+
+    [Display(Name = "Chat Color",
+             Description = "Default color for chat from gui, broadcasts etc.. (Red, Blue, White, Green)",
+             GroupName = "In-Game")]
+    public string ChatColor { get; set; } = "Red";
+
+    [Display(Name = "Enable Whitelist", Description = "Enable Whitelist to prevent random players join while maintance, tests or other.", GroupName = "In-Game")]
+    public bool EnableWhitelist { get; set; }
+
+    [Display(Name = "Whitelist", Description = "Collection of whitelisted steam ids.", GroupName = "In-Game")]
+    public List<ulong> Whitelist { get; set; } = new();
+
+    [Display(Name = "Width", Description = "Default window width.", GroupName = "Window")]
+    public int WindowWidth { get; set; } = 980;
+
+    [Display(Name = "Height", Description = "Default window height", GroupName = "Window")]
+    public int WindowHeight { get; set; } = 588;
+
+    [Display(Name = "Font Size", Description = "Font size for logging text box. (default is 16)",
+             GroupName = "Window")]
+    public int FontSize { get; set; } = 16;
+
+    [Display(Name = "UGC Service Type", Description = "Service for downloading mods", GroupName = "Server")]
+    public UGCServiceType UgcServiceType { get; set; } = UGCServiceType.Steam;
+
+    public string LastUsedTheme { get; set; } = "Torch Theme";
+
+    [Display(Name = "Independent Console", Description = "Keeps a separate console window open after the main UI loads.", GroupName = "Window")]
+    public bool IndependentConsole { get; set; }
+
+    [XmlIgnore]
+    public string TestPlugin { get; set; }
+
+    [Display(Name = "Enable Asserts", Description = "Enable Keen's assert logging.", GroupName = "Server")]
+    public bool EnableAsserts { get; set; }
+
+    [Display(Name = "Enable Entity Manager", Description = "Enable Entity Manager tab. (can affect performance)",
+             GroupName = "Server")]
+    public bool EntityManagerEnabled { get; set; } = true;
+
+    [Display(Name = "Login Token", Description = "Steam GSLT (can be used if you have dynamic ip)", GroupName = "Server")]
+    public string LoginToken { get; set; }
+
+    public UpdateSource UpdateSource { get; set; } = new()
     {
-        private static Logger _log = LogManager.GetLogger("Config");
+        Repository = "PveTeam/Torch",
+        Url = "https://api.github.com",
+        SourceType = UpdateSourceType.Github
+    };
 
-        public bool ShouldUpdatePlugins => (GetPluginUpdates && !NoUpdate) || ForceUpdate;
-        public bool ShouldUpdateTorch => (GetTorchUpdates && !NoUpdate) || ForceUpdate;
-        
-        private bool _autostart;
-        private bool _restartOnCrash;
-        private bool _noGui;
-        private bool _getPluginUpdates = true;
-        private bool _getTorchUpdates = true;
-        private int _tickTimeout = 60;
-        private bool _localPlugins;
-        private bool _disconnectOnRestart;
-        private string _chatName = "Server";
-        private string _chatColor = "Red";
-        private bool _enableWhitelist = false;
-        private List<ulong> _whitelist = new List<ulong>();
-        private int _windowWidth = 980;
-        private int _windowHeight = 588;
-        private bool _independentConsole = false;
-        private bool _enableAsserts = false;
-        private int _fontSize = 16;
-        private UGCServiceType _ugcServiceType = UGCServiceType.Steam;
-        private bool _entityManagerEnabled = true;
-
-        /// <inheritdoc />
-        [XmlIgnore, Arg("noupdate", "Disable automatically downloading game and plugin updates.")]
-        public bool NoUpdate { get; set; }
-
-        /// <inheritdoc />
-        [XmlIgnore, Arg("forceupdate", "Manually check for and install updates.")]
-        public bool ForceUpdate { get; set; }
-
-        /// <summary>
-        /// Permanent flag to ALWAYS automatically start the server
-        /// </summary>
-        [Display(Name = "Auto Start", Description = "Permanent flag to ALWAYS automatically start the server.", GroupName = "Server")]
-        public bool Autostart { get => _autostart; set => Set(value, ref _autostart); }
-
-        /// <summary>
-        /// Temporary flag to automatically start the server only on the next run
-        /// </summary>
-        [Arg("autostart", "Start the server immediately.")]
-        [XmlIgnore]
-        public bool TempAutostart { get; set; }
-
-        /// <inheritdoc />
-        [Arg("restartoncrash", "Automatically restart the server if it crashes.")]
-        [Display(Name = "Restart On Crash", Description = "Automatically restart the server if it crashes.", GroupName = "Server")]
-        public bool RestartOnCrash { get => _restartOnCrash; set => Set(value, ref _restartOnCrash); }
-
-        public string InstancePath { get; set; }
-
-        /// <inheritdoc />
-        [Arg("nogui", "Do not show the Torch UI.")]
-        [Display(Name = "No GUI", Description = "Do not show the Torch UI.", GroupName = "Window")]
-        public bool NoGui { get => _noGui; set => Set(value, ref _noGui); }
-
-        /// <inheritdoc />
-        [Display(Name = "Update Torch", Description = "Check every start for new versions of torch.", GroupName = "Server")]
-        public bool GetTorchUpdates { get => _getTorchUpdates; set => Set(value, ref _getTorchUpdates); }
-
-        public string InstanceName { get; set; }
-
-        /// <inheritdoc />
-        [Display(Name = "Update Plugins", Description = "Check every start for new versions of plugins.", GroupName = "Server")]
-        public bool GetPluginUpdates { get => _getPluginUpdates; set => Set(value, ref _getPluginUpdates); }
-
-        /// <inheritdoc />
-        [Display(Name = "Watchdog Timeout", Description = "Watchdog timeout (in seconds).", GroupName = "Server")]
-        public int TickTimeout { get => _tickTimeout; set => Set(value, ref _tickTimeout); }
-
-        /// <inheritdoc />
-        [Arg("plugins", "Starts Torch with the given plugin GUIDs (space delimited).")]
-        public List<Guid> Plugins { get; set; } = new List<Guid>();
-
-        [Arg("localplugins", "Loads all pluhins from disk, ignores the plugins defined in config.")]
-        [Display(Name = "Local Plugins", Description = "Loads all pluhins from disk, ignores the plugins defined in config.", GroupName = "In-Game")]
-        public bool LocalPlugins { get => _localPlugins; set => Set(value, ref _localPlugins); }
-
-        [Arg("disconnect", "When server restarts, all clients are rejected to main menu to prevent auto rejoin.")]
-        [Display(Name = "Auto Disconnect", Description = "When server restarts, all clients are rejected to main menu to prevent auto rejoin.", GroupName = "In-Game")]
-        public bool DisconnectOnRestart { get => _disconnectOnRestart; set => Set(value, ref _disconnectOnRestart); }
-
-        [Display(Name = "Chat Name", Description = "Default name for chat from gui, broadcasts etc..", GroupName = "In-Game")]
-        public string ChatName { get => _chatName; set => Set(value, ref _chatName); }
-
-        [Display(Name = "Chat Color", Description = "Default color for chat from gui, broadcasts etc.. (Red, Blue, White, Green)", GroupName = "In-Game")]
-        public string ChatColor { get => _chatColor; set => Set(value, ref _chatColor); }
-
-        [Display(Name = "Enable Whitelist", Description = "Enable Whitelist to prevent random players join while maintance, tests or other.", GroupName = "In-Game")]
-        public bool EnableWhitelist { get => _enableWhitelist; set => Set(value, ref _enableWhitelist); }
-
-        [Display(Name = "Whitelist", Description = "Collection of whitelisted steam ids.", GroupName = "In-Game")]
-        public List<ulong> Whitelist { get => _whitelist; set => Set(value, ref _whitelist); }
-
-        [Display(Name = "Width", Description = "Default window width.", GroupName = "Window")]
-        public int WindowWidth { get => _windowWidth; set => Set(value, ref _windowWidth); }
-
-        [Display(Name = "Height", Description = "Default window height", GroupName = "Window")]
-        public int WindowHeight { get => _windowHeight; set => Set(value, ref _windowHeight); }
-
-        [Display(Name = "Font Size", Description = "Font size for logging text box. (default is 16)", GroupName = "Window")]
-        public int FontSize { get => _fontSize; set => Set(value, ref _fontSize); }
-
-        [Display(Name = "UGC Service Type", Description = "Service for downloading mods", GroupName = "Server")]
-        public UGCServiceType UgcServiceType
-        {
-            get => _ugcServiceType;
-            set => Set(value, ref _ugcServiceType);
-        }
-
-        public string LastUsedTheme { get; set; } = "Torch Theme";
-
-        //Prevent reserved players being written to disk, but allow it to be read
-        //remove this when ReservedPlayers is removed
-        private bool ShouldSerializeReservedPlayers() => false;
-
-        [Arg("console", "Keeps a separate console window open after the main UI loads.")]
-        [Display(Name = "Independent Console", Description = "Keeps a separate console window open after the main UI loads.", GroupName = "Window")]
-        public bool IndependentConsole { get => _independentConsole; set => Set(value, ref _independentConsole); }
-
-        [XmlIgnore]
-        [Arg("testplugin", "Path to a plugin to debug. For development use only.")]
-        public string TestPlugin { get; set; }
-
-        [Arg("asserts", "Enable Keen's assert logging.")]
-        [Display(Name = "Enable Asserts", Description = "Enable Keen's assert logging.", GroupName = "Server")]
-        public bool EnableAsserts { get => _enableAsserts; set => Set(value, ref _enableAsserts); }
-
-        [Display(Name = "Enable Entity Manager", Description = "Enable Entity Manager tab. (can affect performance)",
-            GroupName = "Server")]
-        public bool EntityManagerEnabled
-        {
-            get => _entityManagerEnabled;
-            set => Set(value, ref _entityManagerEnabled);
-        }
-
-        public event PropertyChangedEventHandler PropertyChanged;
-
-        public TorchConfig() { }
-
-        protected void Set<T>(T value, ref T field, [CallerMemberName] string callerName = default)
-        {
-            field = value;
-            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(callerName));
-        }
-
-        // for backward compatibility
-        public void Save(string path = null) => Initializer.Instance?.ConfigPersistent?.Save(path);
-    }
+    // for backward compatibility
+    public void Save(string path = null) => Initializer.Instance?.ConfigPersistent?.Save(path);
 }

Torch.Server/TorchServer.cs

@@ -205,16 +205,30 @@ namespace Torch.Server
             new Thread(() =>
             {
                 StopInternal();
-                var config = (TorchConfig)Config;
                 LogManager.Flush();
                 
-                string exe = Assembly.GetExecutingAssembly().Location.Replace("dll", "exe");
-                
-                config.TempAutostart = true;
-                
-                Process.Start(exe, $"-waitForPid {Environment.ProcessId} {config}");
-
+#if DEBUG
                 Environment.Exit(0);
+#endif
+
+                var exe = Assembly.GetExecutingAssembly().Location.Replace("dll", "exe");
+
+                var args = Environment.GetCommandLineArgs();
+
+                for (var i = 0; i < args.Length; i++)
+                {
+                    if (args[i].Contains(' '))
+                        args[i] = $"\"{args[i]}\"";
+                    
+                    if (!args[i].Contains("--tempAutostart", StringComparison.InvariantCultureIgnoreCase) &&
+                        !args[i].Contains("--waitForPid", StringComparison.InvariantCultureIgnoreCase)) 
+                        continue;
+                    
+                    args[i] = string.Empty;
+                    args[++i] = string.Empty;
+                }
+
+                Process.Start(exe, $"--waitForPid {Environment.ProcessId} --tempAutostart true {string.Join(" ", args)}");
             })
             {
                 Name = "Restart thread"

Torch/CommandLine.cs

@@ -1,138 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Reflection;
-using System.Text;
-using NLog;
-
-namespace Torch
-{
-    /// <summary>
-    /// Base class that adds tools for setting type properties through the command line.
-    /// </summary>
-    public abstract class CommandLine
-    {
-        private readonly string _argPrefix;
-        private readonly Dictionary<ArgAttribute, PropertyInfo> _args = new Dictionary<ArgAttribute, PropertyInfo>();
-        private readonly Logger _log = LogManager.GetCurrentClassLogger();
-
-        protected CommandLine(string argPrefix = "-")
-        {
-            _argPrefix = argPrefix;
-            foreach (var prop in GetType().GetProperties())
-            {
-                var attr = prop.GetCustomAttribute<ArgAttribute>();
-                if (attr == null)
-                    continue;
-                _args.Add(attr, prop);
-            }
-        }
-
-        public string GetHelp()
-        {
-            var sb = new StringBuilder();
-
-            foreach (var property in _args)
-            {
-                var attr = property.Key;
-                sb.AppendLine($"{_argPrefix}{attr.Name.PadRight(24)}{attr.Description}");
-            }
-
-            return sb.ToString();
-        }
-
-        public override string ToString()
-        {
-            var args = new List<string>();
-            foreach (var prop in _args)
-            {
-                var attr = prop.Key;
-                if (prop.Value.PropertyType == typeof(bool) && (bool)prop.Value.GetValue(this))
-                {
-                    args.Add($"{_argPrefix}{attr.Name}");
-                }
-                else if (prop.Value.PropertyType == typeof(string))
-                {
-                    var str = (string)prop.Value.GetValue(this);
-                    if (string.IsNullOrEmpty(str))
-                        continue;
-                    args.Add($"{_argPrefix}{attr.Name} \"{str}\"");
-                }
-            }
-
-            return string.Join(" ", args);
-        }
-
-        public bool Parse(string[] args)
-        {
-            if (args.Length == 0)
-                return true;
-
-            if (args[0] == $"{_argPrefix}help")
-            {
-                Console.WriteLine(GetHelp());
-                return false;
-            }
-
-            for (var i = 0; i < args.Length; i++)
-            {
-                if (!args[i].StartsWith(_argPrefix))
-                    continue;
-
-                foreach (var property in _args)
-                {
-                    var argName = property.Key.Name;
-                    if (argName == null)
-                        continue;
-
-                    try
-                    {
-                        if (string.Compare(argName, 0, args[i], 1, argName.Length, StringComparison.InvariantCultureIgnoreCase) == 0)
-                        {
-                            if (property.Value.PropertyType == typeof(bool))
-                                property.Value.SetValue(this, true);
-
-                            if (property.Value.PropertyType == typeof(string))
-                                property.Value.SetValue(this, args[++i]);
-
-                            if (property.Value.PropertyType == typeof(List<Guid>))
-                            {
-                                i++;
-                                var l = new List<Guid>(16);
-                                while (i < args.Length && !args[i].StartsWith(_argPrefix))
-                                {
-                                    if (Guid.TryParse(args[i], out Guid g))
-                                    {
-                                        l.Add(g);
-                                        _log.Info($"added plugin {g}");
-                                    }
-                                    else
-                                        _log.Warn($"Failed to parse GUID {args[i]}");
-                                    i++;
-                                }
-                                property.Value.SetValue(this, l);
-                            }
-                        }
-                    }
-                    catch
-                    {
-                        Console.WriteLine($"Error parsing arg {argName}");
-                    }
-                }
-            }
-
-            return true;
-
-        }
-
-        public class ArgAttribute : Attribute
-        {
-            public string Name { get; }
-            public string Description { get; }
-            public ArgAttribute(string name, string description)
-            {
-                Name = name;
-                Description = description;
-            }
-        }
-    }
-}

Torch/Managers/ScriptCompilationManager.cs

@@ -0,0 +1,231 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.Loader;
+using System.Text;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.Emit;
+using Sandbox.Game.Entities.Blocks;
+using Sandbox.Game.EntityComponents;
+using Sandbox.ModAPI;
+using Sandbox.ModAPI.Ingame;
+using Torch.API;
+using Torch.Utils;
+using VRage;
+using VRage.ModAPI;
+using VRage.Scripting;
+
+namespace Torch.Managers;
+
+public class ScriptCompilationManager : Manager
+{
+    [ReflectedSetter(Name = "m_terminationReason")]
+    private static Action<MyProgrammableBlock, MyProgrammableBlock.ScriptTerminationReason> TerminationReasonSetter = null!;
+
+    [ReflectedGetter(Name = "ScriptComponent")]
+    private static Func<MyProgrammableBlock, MyIngameScriptComponent> ScriptComponentGetter = null!;
+
+    [ReflectedMethod]
+    private static Action<MyProgrammableBlock, string> SetDetailedInfo = null!;
+
+    [ReflectedSetter(Name = "m_instance")]
+    private static Action<MyProgrammableBlock, IMyGridProgram> InstanceSetter = null!;
+
+    [ReflectedSetter(Name = "m_assembly")]
+    private static Action<MyProgrammableBlock, Assembly> AssemblySetter = null!;
+
+    [ReflectedMethod]
+    private static Func<MyProgrammableBlock, Assembly, IEnumerable<string>, string, bool> CreateInstance = null!;
+
+    [ReflectedGetter(Name = "m_compilerErrors")]
+    private static Func<MyProgrammableBlock, List<string>> CompilerErrorsGetter = null!;
+
+    [ReflectedGetter(Name = "m_modApiWhitelistDiagnosticAnalyzer")]
+    private static Func<MyScriptCompiler, DiagnosticAnalyzer> ModWhitelistAnalyzer = null!;
+
+    [ReflectedGetter(Name = "m_ingameWhitelistDiagnosticAnalyzer")]
+    private static Func<MyScriptCompiler, DiagnosticAnalyzer> ScriptWhitelistAnalyzer = null!;
+
+    [ReflectedMethod]
+    private static Func<MyScriptCompiler, CSharpCompilation, SyntaxTree, int, SyntaxTree> InjectMod = null!;
+
+    [ReflectedMethod]
+    private static Func<MyScriptCompiler, CSharpCompilation, SyntaxTree, SyntaxTree> InjectInstructionCounter = null!;
+
+    [ReflectedMethod]
+    private static Func<MyScriptCompiler, CompilationWithAnalyzers, EmitResult, List<Message>, bool, Task<bool>> EmitDiagnostics = null!;
+
+    [ReflectedMethod]
+    private static Func<MyScriptCompiler, MyApiTarget, string, IList<SyntaxTree>, string, Task> WriteDiagnostics = null!;
+
+    [ReflectedMethod(Name = "WriteDiagnostics")]
+    private static Func<MyScriptCompiler, MyApiTarget, string, IEnumerable<Message>, bool, Task> WriteDiagnostics2 = null!;
+    
+    [ReflectedGetter(Name = "m_metadataReferences")]
+    private static Func<MyScriptCompiler, List<MetadataReference>> MetadataReferencesGetter = null!;
+
+    private readonly ConditionalWeakTable<MyProgrammableBlock, AssemblyLoadContext> _contexts = new();
+
+    public ScriptCompilationManager(ITorchBase torchInstance) : base(torchInstance)
+    {
+    }
+
+    public async void CompileAsync(MyProgrammableBlock block, string program, string storage, bool instantiate)
+    {
+        TerminationReasonSetter(block, MyProgrammableBlock.ScriptTerminationReason.None);
+
+        var component = ScriptComponentGetter(block);
+        component.NextUpdate = UpdateType.None;
+        component.NeedsUpdate = MyEntityUpdateEnum.NONE;
+
+        try
+        {
+            if (_contexts.TryGetValue(block, out var context))
+            {
+                InstanceSetter(block, null);
+                AssemblySetter(block, null);
+                context!.Unload();
+            }
+
+            _contexts.AddOrUpdate(block, context = new AssemblyLoadContext(null, true));
+
+            var messages = new List<Message>();
+            var assembly = await CompileAsync(context, MyApiTarget.Ingame,
+                                              $"pb_{block.EntityId}_{Random.Shared.NextInt64()}",
+                                              new[]
+                                              {
+                                                  MyVRage.Platform.Scripting.GetIngameScript(
+                                                      program, "Program", nameof(MyGridProgram))
+                                              }, messages, $"PB: {block.DisplayName} ({block.EntityId})");
+            AssemblySetter(block, assembly);
+            var errors = CompilerErrorsGetter(block);
+
+            errors.Clear();
+            errors.AddRange(messages.Select(b => b.Text));
+
+            if (instantiate)
+                await Torch.InvokeAsync(() => CreateInstance(block, assembly, errors, storage));
+        }
+        catch (Exception e)
+        {
+            await Torch.InvokeAsync(() => SetDetailedInfo(block, e.ToString()));
+            throw;
+        }
+    }
+
+    public async Task<Assembly> CompileAsync(AssemblyLoadContext context, MyApiTarget target, string assemblyName, IEnumerable<Script> scripts, List<Message> messages, string friendlyName, bool enableDebugInformation = false)
+    {
+        friendlyName ??= "<No Name>";
+        Func<CSharpCompilation, SyntaxTree, SyntaxTree> syntaxTreeInjector;
+        DiagnosticAnalyzer whitelistAnalyzer;
+        switch (target)
+        {
+            case MyApiTarget.None:
+                whitelistAnalyzer = null;
+                syntaxTreeInjector = null;
+                break;
+            case MyApiTarget.Mod:
+            {
+                var modId = MyModWatchdog.AllocateModId(friendlyName);
+                whitelistAnalyzer = ModWhitelistAnalyzer(MyScriptCompiler.Static);
+                syntaxTreeInjector = (c, st) => InjectMod(MyScriptCompiler.Static, c, st, modId);
+                break;
+            }
+            case MyApiTarget.Ingame:
+                syntaxTreeInjector = (c, t) => InjectInstructionCounter(MyScriptCompiler.Static, c, t);
+                whitelistAnalyzer = ScriptWhitelistAnalyzer(MyScriptCompiler.Static);
+                break;
+            default:
+                throw new ArgumentOutOfRangeException(nameof(target), target, "Invalid compilation target");
+        }
+        var compilation = CreateCompilation(assemblyName, scripts);
+        
+        await WriteDiagnostics(MyScriptCompiler.Static, target, assemblyName, compilation.SyntaxTrees, null).ConfigureAwait(false);
+        var injectionFailed = false;
+        var compilationWithoutInjection = compilation;
+        if (syntaxTreeInjector != null)
+        {
+            SyntaxTree[] newSyntaxTrees = null;
+            try
+            {
+                var syntaxTrees = compilation.SyntaxTrees;
+                if (syntaxTrees.Length == 1)
+                {
+                    newSyntaxTrees = new[] { syntaxTreeInjector(compilation, syntaxTrees[0]) };
+                }
+                else
+                {
+                    newSyntaxTrees = await Task
+                                           .WhenAll(syntaxTrees.Select(
+                                                        x => Task.Run(() => syntaxTreeInjector(compilation, x))))
+                                           .ConfigureAwait(false);
+                }
+            }
+            catch
+            {
+                injectionFailed = true;
+            }
+            if (!injectionFailed)
+            {
+                await WriteDiagnostics(MyScriptCompiler.Static, target, assemblyName, newSyntaxTrees, ".injected").ConfigureAwait(false);
+                compilation = compilation.RemoveAllSyntaxTrees().AddSyntaxTrees(newSyntaxTrees);
+            }
+        }
+        CompilationWithAnalyzers analyticCompilation = null;
+        if (whitelistAnalyzer != null)
+        {
+            analyticCompilation = compilation.WithAnalyzers(ImmutableArray.Create(whitelistAnalyzer));
+            compilation = (CSharpCompilation)analyticCompilation.Compilation;
+        }
+
+        using var assemblyStream = new MemoryStream();
+
+        var emitResult = compilation.Emit(assemblyStream);
+        var success = emitResult.Success;
+        var myBlacklistSyntaxVisitor = new MyBlacklistSyntaxVisitor();
+        foreach (var syntaxTree in compilation.SyntaxTrees)
+        {
+            myBlacklistSyntaxVisitor.SetSemanticModel(compilation.GetSemanticModel(syntaxTree, false));
+            myBlacklistSyntaxVisitor.Visit(await syntaxTree.GetRootAsync());
+        }
+        if (myBlacklistSyntaxVisitor.HasAnyResult())
+        {
+            myBlacklistSyntaxVisitor.GetResultMessages(messages);
+        }
+        else
+        {
+            success = await EmitDiagnostics(MyScriptCompiler.Static, analyticCompilation, emitResult, messages, success).ConfigureAwait(false);
+            await WriteDiagnostics2(MyScriptCompiler.Static, target, assemblyName, messages, success).ConfigureAwait(false);
+            assemblyStream.Seek(0, SeekOrigin.Begin);
+            if (injectionFailed) return null;
+            if (success)
+                return context.LoadFromStream(assemblyStream);
+
+            await EmitDiagnostics(MyScriptCompiler.Static, analyticCompilation, compilationWithoutInjection.Emit(assemblyStream), messages, false).ConfigureAwait(false);
+        }
+
+        return null;
+    }
+
+    private readonly CSharpCompilationOptions _compilationOptions = new(OutputKind.DynamicallyLinkedLibrary);
+    private readonly CSharpParseOptions _parseOptions = new(LanguageVersion.CSharp10, DocumentationMode.None);
+    
+    private CSharpCompilation CreateCompilation(string assemblyFileName, IEnumerable<Script> scripts)
+    {
+        if (scripts == null)
+            return CSharpCompilation.Create(assemblyFileName, null, MetadataReferencesGetter(MyScriptCompiler.Static),
+                                            _compilationOptions);
+        
+        var parseOptions = _parseOptions.WithPreprocessorSymbols(MyScriptCompiler.Static.ConditionalCompilationSymbols);
+        var enumerable = scripts.Select(s => CSharpSyntaxTree.ParseText(s.Code, parseOptions, s.Name, Encoding.UTF8));
+        
+        return CSharpCompilation.Create(assemblyFileName, enumerable, MetadataReferencesGetter(MyScriptCompiler.Static), _compilationOptions);
+    }
+}

Torch/Managers/UpdateManager.cs

@@ -5,6 +5,7 @@ using System.IO.Compression;
 using System.IO.Packaging;
 using System.Linq;
 using System.Net;
+using System.Net.Http;
 using System.Text;
 using System.Text.RegularExpressions;
 using System.Threading;
@@ -21,8 +22,9 @@ namespace Torch.Managers
     public class UpdateManager : Manager
     {
         private readonly Timer _updatePollTimer;
-        private string _torchDir = new FileInfo(typeof(UpdateManager).Assembly.Location).DirectoryName;
-        private Logger _log = LogManager.GetCurrentClassLogger();
+        private readonly string _torchDir = ApplicationContext.Current.TorchDirectory.FullName;
+        private readonly Logger _log = LogManager.GetCurrentClassLogger();
+
         [Dependency]
         private FilesystemManager _fsManager = null!;
         
@@ -50,26 +52,22 @@ namespace Torch.Managers
 
             try
             {
-                var job = await JenkinsQuery.Instance.GetLatestVersion(Torch.TorchVersion.Build);
-                if (job == null)
-                {
-                    _log.Info("Failed to fetch latest version.");
-                    return;
-                }
+                var updateSource = Torch.Config.UpdateSource;
                 
-                if (job.Version > Torch.TorchVersion)
+                IUpdateQuery source = updateSource.SourceType switch
                 {
-                    _log.Warn($"Updating Torch from version {Torch.TorchVersion} to version {job.Version}");
-                    var updateName = Path.Combine(_fsManager.TempDirectory, "torchupdate.zip");
-                    //new WebClient().DownloadFile(new Uri(releaseInfo.Item2), updateName);
-                    if (!await JenkinsQuery.Instance.DownloadRelease(job, updateName))
-                    {
-                        _log.Warn("Failed to download new release!");
-                        return;
-                    }
-                    UpdateFromZip(updateName, _torchDir);
-                    File.Delete(updateName);
-                    _log.Warn($"Torch version {job.Version} has been installed, please restart Torch to finish the process.");
+                    UpdateSourceType.Github => new GithubQuery(updateSource.Url),
+                    UpdateSourceType.Jenkins => new JenkinsQuery(updateSource.Url),
+                    _ => throw new ArgumentOutOfRangeException()
+                };
+                
+                var release = await source.GetLatestReleaseAsync(updateSource.Repository, updateSource.Branch);
+
+                if (release.Version > Torch.TorchVersion)
+                {
+                    _log.Warn($"Updating Torch from version {Torch.TorchVersion} to version {release.Version}");
+                    await UpdateAsync(release, _torchDir);
+                    _log.Warn($"Torch version {release.Version} has been installed, please restart Torch to finish the process.");
                 }
                 else
                 {
@@ -83,23 +81,29 @@ namespace Torch.Managers
             }
         }
 
-        private void UpdateFromZip(string zipFile, string extractPath)
+        private async Task UpdateAsync(UpdateRelease release, string extractPath)
         {
-            using (var zip = ZipFile.OpenRead(zipFile))
+            using var client = new HttpClient();
+            await using var stream = await client.GetStreamAsync(release.ArtifactUrl);
+            UpdateFromZip(stream, extractPath);
+        }
+
+        private void UpdateFromZip(Stream zipStream, string extractPath)
+        {
+            using var zip = new ZipArchive(zipStream, ZipArchiveMode.Read, true);
+            
+            foreach (var file in zip.Entries)
             {
-                foreach (var file in zip.Entries)
-                {
-                    if(file.Name == "NLog-user.config" && File.Exists(Path.Combine(extractPath, file.FullName)))
-                        continue;
+                if(file.Name == "NLog-user.config" && File.Exists(Path.Combine(extractPath, file.FullName)))
+                    continue;
 
-                    _log.Debug($"Unzipping {file.FullName}");
-                    var targetFile = Path.Combine(extractPath, file.FullName);
-                    _fsManager.SoftDelete(extractPath, file.FullName);
-                    file.ExtractToFile(targetFile, true);
-                }
-
-                //zip.ExtractToDirectory(extractPath); //throws exceptions sometimes?
+                _log.Debug($"Unzipping {file.FullName}");
+                var targetFile = Path.Combine(extractPath, file.FullName);
+                _fsManager.SoftDelete(extractPath, file.FullName);
+                file.ExtractToFile(targetFile, true);
             }
+
+            //zip.ExtractToDirectory(extractPath); //throws exceptions sometimes?
         }
 
         /// <inheritdoc />

Torch/Patches/GcCollectPatch.cs

@@ -1,4 +1,5 @@
-using System;
+#if false
+using System;
 using System.Collections.Generic;
 using System.Reflection;
 using System.Reflection.Emit;
@@ -51,3 +52,4 @@ internal static class GcCollectPatch
         }
     }
 }
+#endif

Torch/Patches/ProgramableBlockPatch.cs

@@ -0,0 +1,33 @@
+using System;
+using System.Reflection;
+using Sandbox.Game.Entities.Blocks;
+using Sandbox.Game.World;
+using Torch.API.Managers;
+using Torch.Managers;
+using Torch.Managers.PatchManager;
+using Torch.Utils;
+
+namespace Torch.Patches;
+
+[PatchShim]
+public static class ProgramableBlockPatch
+{
+    [ReflectedMethodInfo(typeof(MyProgrammableBlock), "Compile")]
+    private static MethodInfo CompileMethod = null!;
+    
+    public static void Patch(PatchContext context)
+    {
+        context.GetPattern(CompileMethod).AddPrefix();
+    }
+
+    private static bool Prefix(MyProgrammableBlock __instance, string program, string storage, bool instantiate)
+    {
+        if (!MySession.Static.EnableIngameScripts || __instance.CubeGrid is {IsPreview: true} or {CreatePhysics: false})
+            return false;
+
+#pragma warning disable CS0618
+        TorchBase.Instance.CurrentSession.Managers.GetManager<ScriptCompilationManager>().CompileAsync(__instance, program, storage, instantiate);
+#pragma warning restore CS0618
+        return false;
+    }
+}

Torch/Patches/ScriptCompilerPatch.cs

@@ -12,6 +12,7 @@ using System.Reflection.Emit;
 using System.Text.RegularExpressions;
 using System.Threading;
 using Microsoft.CodeAnalysis;
+using ParallelTasks;
 using ProtoBuf;
 using Torch.Managers.PatchManager;
 using Torch.Managers.PatchManager.MSIL;
@@ -82,6 +83,14 @@ 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/AssemblyRewriter.cs

@@ -1,14 +1,17 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 using System.IO;
 using System.IO.Compression;
 using System.Linq;
 using System.Reflection;
 using Mono.Cecil;
+using NLog;
 
 namespace Torch.Plugins;
 
 internal static class AssemblyRewriter
 {
+    private static readonly ILogger Log = LogManager.GetCurrentClassLogger();
     private static readonly ZipResolver _zipResolver;
     private static readonly DefaultAssemblyResolver _defaultResolver;
 
@@ -23,12 +26,25 @@ internal static class AssemblyRewriter
     public static Assembly ProcessWeavers(this Stream stream, ZipArchive archive)
     {
         _zipResolver.Archive = archive;
+        
         using var assStream = new MemoryStream();
         stream.CopyTo(assStream);
         assStream.Position = 0;
-        var ass = ProcessInternal(assStream, _zipResolver);
-        _zipResolver.Archive = null;
-        return ass;
+        
+        try
+        {
+            var ass = ProcessInternal(assStream, _zipResolver);
+            return ass;
+        }
+        catch (Exception e)
+        {
+            Log.Error(e, "Unable to process assembly, skipping");
+            return Assembly.Load(assStream.ToArray());
+        }
+        finally
+        {
+            _zipResolver.Archive = null;
+        }
     }
     
     public static Assembly ProcessWeavers(this Stream stream, string path)

Torch/Torch.csproj

@@ -12,6 +12,7 @@
     <PlatformTarget>x64</PlatformTarget>
     <Configurations>Debug;Release</Configurations>
     <Platforms>AnyCPU</Platforms>
+    <EnableWindowsTargeting>true</EnableWindowsTargeting>
   </PropertyGroup>
   
   <PropertyGroup Condition="$(Configuration) == 'Release'">

Torch/TorchBase.cs

@@ -92,6 +92,7 @@ namespace Torch
         /// <summary>
         /// 
         /// </summary>
+        /// <exception cref="ArgumentOutOfRangeException"></exception>
         /// <exception cref="InvalidOperationException">Thrown if a TorchBase instance already exists.</exception>
         protected TorchBase(ITorchConfig config)
         {
@@ -103,14 +104,8 @@ namespace Torch
 #pragma warning restore CS0618
             Config = config;
 
-            var versionString = GetType().Assembly
-                .GetCustomAttribute<AssemblyInformationalVersionAttribute>()!
-                .InformationalVersion;
-            
-            if (!SemanticVersioning.Version.TryParse(versionString, out var version))
-                throw new TypeLoadException("Unable to parse the Torch version from the assembly.");
-
-            TorchVersion = version;
+            var assemblyVersion = GetType().Assembly.GetName().Version ?? new Version();
+            TorchVersion = new(assemblyVersion.Major, assemblyVersion.Minor, assemblyVersion.Build);
 
             RunArgs = Array.Empty<string>();
 
@@ -128,11 +123,12 @@ namespace Torch
             Managers.AddManager(sessionManager);
             Managers.AddManager(new PatchManager(this));
             Managers.AddManager(new FilesystemManager(this));
-            // Managers.AddManager(new UpdateManager(this));
+            Managers.AddManager(new UpdateManager(this));
             Managers.AddManager(new EventManager(this));
 #pragma warning disable CS0618
             Managers.AddManager(Plugins);
 #pragma warning restore CS0618
+            Managers.AddManager(new ScriptCompilationManager(this));
             TorchAPI.Instance = this;
 
             GameStateChanged += (game, state) =>
@@ -146,6 +142,20 @@ namespace Torch
                     PatchManager.CommitInternal();
                 }
             };
+
+            var harmonyLog = LogManager.GetLogger("HarmonyX");
+            HarmonyLib.Tools.Logger.ChannelFilter = HarmonyLib.Tools.Logger.LogChannel.Debug;
+            HarmonyLib.Tools.Logger.MessageReceived += (_, args) => harmonyLog.Log(args.LogChannel switch
+            {
+                HarmonyLib.Tools.Logger.LogChannel.None => LogLevel.Off,
+                HarmonyLib.Tools.Logger.LogChannel.Info => LogLevel.Info,
+                HarmonyLib.Tools.Logger.LogChannel.IL => LogLevel.Trace,
+                HarmonyLib.Tools.Logger.LogChannel.Warn => LogLevel.Warn,
+                HarmonyLib.Tools.Logger.LogChannel.Error => LogLevel.Error,
+                HarmonyLib.Tools.Logger.LogChannel.Debug => LogLevel.Debug,
+                HarmonyLib.Tools.Logger.LogChannel.All => LogLevel.Debug,
+                _ => throw new ArgumentOutOfRangeException()
+            }, args.Message);
         }
 
         [Obsolete("Prefer using Managers.GetManager for global managers")]