feat: nuget packer

CedaryCat · CedaryCat · commit 62a633137998 · 2025-07-25T01:18:14.000+08:00
diff --git a/docs/OTAPI.USP.md b/docs/OTAPI.USP.md
@@ -0,0 +1,28 @@
+# OTAPI Unified Server Process
+
+**OTAPI.USP** is a secondary IL patch built on top of [OTAPI](https://github.com/SignatureBeef/Open-Terraria-API), enabling **multiple isolated Terraria server instances to run within a single process**.
+
+Unlike standard OTAPI builds, this package introduces a **breaking change** by redirecting access to static fields within the Terraria server to their **instance-scoped equivalents**. This change allows each server instance to operate in a fully isolated execution context—enabling true multi-server concurrency within a single host process.
+
+## Key Features
+
+- 🧩 Built on top of OTAPI (IL-patched `TerrariaServer.exe`)
+- ⚠️ Breaking change: static server state is redirected to instance-level context
+- 🧵 Supports multiple Terraria server instances running in parallel threads
+- 💡 Enables advanced hosting models (e.g., high-density server clusters, custom orchestration, dynamic scaling)
+
+## Compatibility
+
+- Terraria: **1.4.4.9**
+- OTAPI: `[INJECT_OTAPI_VERSION]`
+
+## Important Notes
+
+- This package is not drop-in compatible with standard OTAPI mods.
+- Due to static field redirection, code that relies on traditional static access (e.g., `Main.time`, `Netplay`) must be adapted to use the appropriate instance context.
+- For mod development or integration, consult the API documentation or source examples on GitHub.
+
+## Licensing
+
+This package follows the licensing terms of OTAPI and the original Terraria server executable. See `COPYING.txt` for details.
+
diff --git a/docs/OTAPI.USP.nuspec b/docs/OTAPI.USP.nuspec
@@ -0,0 +1,24 @@
+<?xml version="1.0"?>
+<package >
+  <metadata>
+    <id>OTAPI.USP</id>
+    <title>OTAPI Unified Server Process</title>
+    <version>[INJECT_VERSION]</version>
+    <authors>CedaryCat</authors>
+    <owners>CedaryCat</owners>
+    <license type="file">COPYING.txt</license>
+    <projectUrl>https://github.com/CedaryCat/UnifiedServerProcess</projectUrl>
+    <requireLicenseAcceptance>false</requireLicenseAcceptance>
+    <description>
+		An additional IL patch layered on top of OTAPI, enabling multiple Terraria server instances to run concurrently within a single process.
+	</description>
+    <summary>Unified Server Process [INJECT_VERSION] on Open Terraria API [INJECT_OTAPI_VERSION] - Terraria 1.4.4.9[INJECT_GIT_HASH]</summary>
+    <releaseNotes>
+      Preliminary Terraria 1.4.4.9
+    </releaseNotes>
+    <copyright>Copyright 2025-[INJECT_YEAR]</copyright>
+    <tags>Terraria,OTAPI,MultiServer</tags>
+    [INJECT_DEPENDENCIES]
+  </metadata>
+</package>
+
diff --git a/src/Directory.Build.props b/src/Directory.Build.props
@@ -0,0 +1,5 @@
+<Project>
+  <ItemGroup Condition="'$(DisableGitVersion)' != 'true'">
+    <PackageReference Include="GitVersion.MSBuild" Version="5.12.0" PrivateAssets="All" />
+  </ItemGroup>
+</Project>
diff --git a/src/OTAPI.UnifiedServerProcess.sln b/src/OTAPI.UnifiedServerProcess.sln
@@ -1,3 +1,4 @@
+﻿
 Microsoft Visual Studio Solution File, Format Version 12.00
 # Visual Studio Version 17
 VisualStudioVersion = 17.14.35906.104
@@ -16,6 +17,17 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "TrProtocol.SerializerGenera
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "TrProtocol", "TrProtocol\TrProtocol.csproj", "{F252FFD8-5DE7-DAA8-BA3D-341C543C73EE}"
 EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "解决方案项", "解决方案项", "{9FA3D6BD-1EC1-3BA5-80CB-CE02773A58D5}"
+	ProjectSection(SolutionItems) = preProject
+		Directory.Build.props = Directory.Build.props
+	EndProjectSection
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "docs", "docs", "{02EA681E-C7D8-13C7-8484-4AC65E1B71E8}"
+	ProjectSection(SolutionItems) = preProject
+		..\docs\OTAPI.USP.md = ..\docs\OTAPI.USP.md
+		..\docs\OTAPI.USP.nuspec = ..\docs\OTAPI.USP.nuspec
+	EndProjectSection
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -50,6 +62,9 @@ Global
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
 	EndGlobalSection
+	GlobalSection(NestedProjects) = preSolution
+		{02EA681E-C7D8-13C7-8484-4AC65E1B71E8} = {9FA3D6BD-1EC1-3BA5-80CB-CE02773A58D5}
+	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {A7CFB05D-AB46-4256-92A6-C8723719BBD5}
 	EndGlobalSection
diff --git a/src/OTAPI.UnifiedServerProcess/Extensions/ModContextExt.cs b/src/OTAPI.UnifiedServerProcess/Extensions/ModContextExt.cs
@@ -3,17 +3,14 @@
 
 namespace OTAPI.UnifiedServerProcess.Extensions
 {
-    [MonoMod.MonoModIgnore]
     public static class ModContextExt
     {
-        [MonoMod.MonoModIgnore]
         public static string ExtractResources(this ModContext modcontext, string fileinput) {
             var dir = GetEmbeddedResourcesDirectory(modcontext, fileinput);
             var extractor = new ResourceExtractor();
             var embeddedResourcesDir = extractor.Extract(fileinput, dir);
             return embeddedResourcesDir;
         }
-        [MonoMod.MonoModIgnore]
         public static string GetEmbeddedResourcesDirectory(ModContext modcontext, string fileinput) {
             return Path.Combine(modcontext.BaseDirectory, Path.GetDirectoryName(fileinput)!);
         }
diff --git a/src/OTAPI.UnifiedServerProcess/Extensions/ModFwModderExt.cs b/src/OTAPI.UnifiedServerProcess/Extensions/ModFwModderExt.cs
@@ -1,14 +1,13 @@
 ﻿using ModFramework;
 using ModFramework.Relinker;
 using Mono.Cecil;
+using System;
 using System.IO;
 
 namespace OTAPI.UnifiedServerProcess.Extensions
 {
-    [MonoMod.MonoModIgnore]
     public static class ModFwModderExt
     {
-        [MonoMod.MonoModIgnore]
         public static void CreateRuntimeHooks(this ModFwModder modder, string output) {
             modder.Log("[OTAPI-ProC] Generating OTAPI.Runtime.dll");
             var gen = new MonoMod.RuntimeDetour.HookGen.HookGenerator(modder, "OTAPI.Runtime.dll");
@@ -41,5 +40,16 @@ public static void CreateRuntimeHooks(this ModFwModder modder, string output) {
 
             mm.Write();
         }
+
+        public static void AddEnvMetadata(this ModFwModder modder) {
+            var commitSha = Utilities.GetGitCommitSha();
+            var run = Environment.GetEnvironmentVariable("GITHUB_RUN_NUMBER")?.Trim();
+
+            if (!string.IsNullOrWhiteSpace(commitSha))
+                modder.AddMetadata("GitHub.Commit", commitSha);
+
+            if (!string.IsNullOrWhiteSpace(run))
+                modder.AddMetadata("GitHub.Action.RunNo", run);
+        }
     }
 }
diff --git a/src/OTAPI.UnifiedServerProcess/ModAssemblyMerger.cs b/src/OTAPI.UnifiedServerProcess/ModAssemblyMerger.cs
@@ -13,20 +13,20 @@ namespace OTAPI.UnifiedServerProcess
 {
     public class ModAssemblyMerger
     {
-        public ModAssemblyMerger(ModContext context, params System.Reflection.Assembly[] mods) {
-
-            Dictionary<string, ModuleDefinition> modModules = [];
-
+        readonly Dictionary<string, ModuleDefinition> modModules = [];
+        public ModAssemblyMerger(params System.Reflection.Assembly[] mods) {
+            foreach (var assembly in mods) {
+                var mod = AssemblyDefinition.ReadAssembly(assembly.Location);
+                modModules.TryAdd(mod.FullName, mod.MainModule);
+            }
+        }
+        public void Attach(ModContext context) {
             context.OnApply += (progress, modder) => {
                 if (modder is null) {
                     return ModContext.EApplyResult.Continue;
                 }
                 var module = modder.Module;
                 if (progress == ModType.PreRead) {
-                    foreach (var assembly in mods) {
-                        var mod = AssemblyDefinition.ReadAssembly(assembly.Location);
-                        modModules.TryAdd(mod.FullName, mod.MainModule);
-                    }
                 }
                 else if (progress == ModType.PrePatch) {
                     var modderTypes = module.GetAllTypes().ToDictionary(x => x.FullName, x => x);
diff --git a/src/OTAPI.UnifiedServerProcess/NugetPackageBuilder.cs b/src/OTAPI.UnifiedServerProcess/NugetPackageBuilder.cs
@@ -0,0 +1,89 @@
+﻿using ModFramework;
+using OTAPI.UnifiedServerProcess.Core.Patching.Framework;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace OTAPI.UnifiedServerProcess
+{
+    public class NugetPackageBuilder(string packageName, string nugetDocPath)
+    {
+        string GetNugetVersionFromAssembly(Assembly assembly)
+            => assembly.GetCustomAttribute<AssemblyInformationalVersionAttribute>()!.InformationalVersion;
+
+        string GetNugetVersionFromAssembly<TType>()
+            => GetNugetVersionFromAssembly(typeof(TType).Assembly);
+
+        public readonly string PackageFileName = packageName + ".nupkg";
+        public readonly string PackageMDFilePath = Path.Combine(nugetDocPath, packageName + ".md");
+        public readonly string NuspecFilePath = Path.Combine(nugetDocPath, packageName + ".nuspec");
+
+        public void Build(ModFwModder modder, string otapiVersion, DirectoryInfo outputDir) {
+            var nuspec_xml = File.ReadAllText(NuspecFilePath);
+            var md = File.ReadAllText(PackageMDFilePath);
+
+            md = md.Replace("[INJECT_OTAPI_VERSION]", otapiVersion);
+            nuspec_xml = nuspec_xml.Replace("[INJECT_OTAPI_VERSION]", otapiVersion);
+
+            var version = GetNugetVersionFromAssembly<Patcher>();
+            var gitIndex = version.IndexOf('+');
+            if (gitIndex > -1) {
+                var gitCommitSha = version[(gitIndex + 1)..];
+                version = version[..gitIndex];
+                nuspec_xml = nuspec_xml.Replace("[INJECT_GIT_HASH]", $" git#{gitCommitSha}");
+            }
+            else {
+                nuspec_xml = nuspec_xml.Replace("[INJECT_GIT_HASH]", "");
+            }
+            nuspec_xml = nuspec_xml.Replace("[INJECT_VERSION]", version);
+
+            var platforms = new[] { "net9.0" };
+            var steamworks = modder.Module.AssemblyReferences.First(x => x.Name == "Steamworks.NET");
+            var newtonsoft = modder.Module.AssemblyReferences.First(x => x.Name == "Newtonsoft.Json");
+            var dependencies = new[]
+            {
+                (typeof(ModFwModder).Assembly.GetName().Name, Version: GetNugetVersionFromAssembly<ModFwModder>()),
+                (typeof(MonoMod.MonoModder).Assembly.GetName().Name, Version: typeof(MonoMod.MonoModder).Assembly.GetName().Version!.ToString()),
+                (typeof(MonoMod.RuntimeDetour.Hook).Assembly.GetName().Name, Version: typeof(MonoMod.RuntimeDetour.Hook).Assembly.GetName().Version!.ToString()),
+                (steamworks.Name, Version: steamworks.Version.ToString()),
+                (newtonsoft.Name, Version: GetNugetVersionFromAssembly<Newtonsoft.Json.JsonConverter>().Split('+')[0]  ),
+            };
+
+            var xml_dependency = string.Join("", dependencies.Select(dep => $"\n\t    <dependency id=\"{dep.Name}\" version=\"{dep.Version}\" />"));
+            var xml_group = string.Join("", platforms.Select(platform => $"\n\t<group targetFramework=\"{platform}\">{xml_dependency}\n\t</group>"));
+            var xml_dependencies = $"<dependencies>{xml_group}\n    </dependencies>";
+
+            nuspec_xml = nuspec_xml.Replace("[INJECT_DEPENDENCIES]", xml_dependencies);
+
+            nuspec_xml = nuspec_xml.Replace("[INJECT_YEAR]", DateTime.UtcNow.Year.ToString());
+
+            File.WriteAllText(Path.Combine(outputDir.FullName, "COPYING.txt"), File.ReadAllText("../../../../../LICENSE"));
+            File.WriteAllText(packageName + ".md", md);
+
+            using (var nuspec = new MemoryStream(Encoding.UTF8.GetBytes(nuspec_xml))) {
+                var manifest = NuGet.Packaging.Manifest.ReadFrom(nuspec, validateSchema: true);
+                var packageBuilder = new NuGet.Packaging.PackageBuilder();
+                packageBuilder.Populate(manifest.Metadata);
+
+                packageBuilder.AddFiles(outputDir.FullName, "COPYING.txt", "");
+
+                foreach (var platform in platforms) {
+                    var dest = Path.Combine("lib", platform);
+                    packageBuilder.AddFiles(outputDir.FullName, "OTAPI.dll", dest);
+                    packageBuilder.AddFiles(outputDir.FullName, "OTAPI.Runtime.dll", dest);
+                }
+
+                if (File.Exists(PackageFileName))
+                    File.Delete(PackageFileName);
+
+                using (var srm = File.OpenWrite(PackageFileName)) {
+                    packageBuilder.Save(srm);
+                }
+            }
+        }
+    }
+}
diff --git a/src/OTAPI.UnifiedServerProcess/PatchExecutor.cs b/src/OTAPI.UnifiedServerProcess/PatchExecutor.cs
@@ -10,6 +10,7 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Reflection;
 using System.Runtime.InteropServices;
 
 namespace OTAPI.UnifiedServerProcess
@@ -58,17 +59,19 @@ public static void PatchMonoMod() {
             }
         }
 
-        public bool Patch() {
-            DirectoryInfo outputDir = new DirectoryInfo(Path.Combine(Directory.GetCurrentDirectory(), "output"));
+        public bool Patch(DirectoryInfo outputDir) {
             outputDir.Create();
             var output = Path.Combine(outputDir.FullName, "OTAPI.dll");
             var hookOutput = Path.Combine(outputDir.FullName, "OTAPI.Runtime.dll");
 
             var input = typeof(Terraria.Main).Assembly.Location;
+            var version = typeof(Terraria.Main).Assembly
+                .GetCustomAttribute<AssemblyInformationalVersionAttribute>()
+                ?.InformationalVersion ?? throw new NullReferenceException();
 
             var modcontext = new ModContext("Terraria");
-            modcontext.ReferenceFiles.AddRange(new[]
-            {
+            modcontext.ReferenceFiles.AddRange(
+            [
                 "ModFramework.dll",
                 "MonoMod.dll",
                 "MonoMod.Utils.dll",
@@ -79,18 +82,18 @@ public bool Patch() {
                 "Steamworks.NET.dll",
                 input,
                 typeof(Program).Assembly.Location,
-            });
+            ]);
 
             using ModFwModder mm = new(modcontext) {
                 InputPath = input,
                 OutputPath = output,
                 MissingDependencyThrow = false,
                 PublicEverything = false,
                 LogVerboseEnabled = true,
-                GACPaths = new string[] { }, // avoid MonoMod looking up the GAC, which causes an exception on .netcore
+                GACPaths = [], // avoid MonoMod looking up the GAC, which causes an exception on .netcore
             };
 
-            List<MethodDefinition> virtualMaked = new List<MethodDefinition>();
+            List<MethodDefinition> virtualMaked = [];
 
             var embeddedResources = modcontext.ExtractResources(input);
 
@@ -100,7 +103,8 @@ public bool Patch() {
 
             var logger = new DefaultLogger(Logger.DEBUG);
 
-            _ = new ModAssemblyMerger(modcontext, typeof(TrProtocol.MessageID).Assembly);
+            new ModAssemblyMerger(typeof(TrProtocol.MessageID).Assembly)
+                .Attach(modcontext);
 
             modcontext.OnApply += (modType, modder) => {
 
@@ -114,10 +118,14 @@ public bool Patch() {
                     else if (modType == ModType.PreWrite) {
                         PatchingLogic.Patch(logger, modder.Module);
                         modder.ModContext.TargetAssemblyName = "OTAPI";
+                        modder.AddEnvMetadata();
                     }
                     else if (modType == ModType.Write) {
                         modder.ModContext = new("OTAPI.Runtime");
                         modder.CreateRuntimeHooks(hookOutput);
+
+                        new NugetPackageBuilder("OTAPI.USP", "../../../../../docs")
+                            .Build(modder, version, outputDir);
                     }
                 }
 
diff --git a/src/OTAPI.UnifiedServerProcess/Program.cs b/src/OTAPI.UnifiedServerProcess/Program.cs
@@ -1,9 +1,14 @@
-﻿namespace OTAPI.UnifiedServerProcess
+﻿using System;
+using System.IO;
+using System.Reflection;
+
+namespace OTAPI.UnifiedServerProcess
 {
     internal class Program
     {
         static void Main(string[] args) {
-            new PatchExecutor().Patch();
+            var outputDir = new DirectoryInfo(Path.Combine(Directory.GetCurrentDirectory(), "output"));
+            new PatchExecutor().Patch(outputDir);
         }
     }
 }
diff --git a/src/OTAPI.UnifiedServerProcess/Utilities.cs b/src/OTAPI.UnifiedServerProcess/Utilities.cs
@@ -0,0 +1,26 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace OTAPI.UnifiedServerProcess
+{
+    public static class Utilities
+    {
+
+        public static string? GetCliValue(string key) {
+            string find = $"-{key}=";
+            var match = Array.Find(Environment.GetCommandLineArgs(), x => x.StartsWith(find, StringComparison.CurrentCultureIgnoreCase));
+            return match?.Substring(find.Length)?.ToLower();
+        }
+
+        public static string? GetGitCommitSha() {
+            var commitSha = Environment.GetEnvironmentVariable("GITHUB_SHA")?.Trim();
+            if (commitSha != null && commitSha.Length >= 7) {
+                return commitSha.Substring(0, 7);
+            }
+            return null;
+        }
+    }
+}
diff --git a/src/TrProtocol.SerializerGenerator/SerializeGenerator.cs b/src/TrProtocol.SerializerGenerator/SerializeGenerator.cs
diff --git a/src/TrProtocol.SerializerGenerator/TrProtocol.SerializerGenerator.csproj b/src/TrProtocol.SerializerGenerator/TrProtocol.SerializerGenerator.csproj

Original file line number	Diff line number	Diff line change
`@@ -3,17 +3,14 @@`
`3`	`3`
`4`	`4`	`namespace OTAPI.UnifiedServerProcess.Extensions`
`5`	`5`	`{`
`6`		`- [MonoMod.MonoModIgnore]`
`7`	`6`	`public static class ModContextExt`
`8`	`7`	`{`
`9`		`- [MonoMod.MonoModIgnore]`
`10`	`8`	`public static string ExtractResources(this ModContext modcontext, string fileinput) {`
`11`	`9`	`var dir = GetEmbeddedResourcesDirectory(modcontext, fileinput);`
`12`	`10`	`var extractor = new ResourceExtractor();`
`13`	`11`	`var embeddedResourcesDir = extractor.Extract(fileinput, dir);`
`14`	`12`	`return embeddedResourcesDir;`
`15`	`13`	`}`
`16`		`- [MonoMod.MonoModIgnore]`
`17`	`14`	`public static string GetEmbeddedResourcesDirectory(ModContext modcontext, string fileinput) {`
`18`	`15`	`return Path.Combine(modcontext.BaseDirectory, Path.GetDirectoryName(fileinput)!);`
`19`	`16`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,9 +1,14 @@`
`1`		`-namespace OTAPI.UnifiedServerProcess`
	`1`	`+using System;`
	`2`	`+using System.IO;`
	`3`	`+using System.Reflection;`
	`4`	`+`
	`5`	`+namespace OTAPI.UnifiedServerProcess`
`2`	`6`	`{`
`3`	`7`	`internal class Program`
`4`	`8`	`{`
`5`	`9`	`static void Main(string[] args) {`
`6`		`- new PatchExecutor().Patch();`
	`10`	`+ var outputDir = new DirectoryInfo(Path.Combine(Directory.GetCurrentDirectory(), "output"));`
	`11`	`+ new PatchExecutor().Patch(outputDir);`
`7`	`12`	`}`
`8`	`13`	`}`
`9`	`14`	`}`