Multiworld

ALttPRandomizer/Azure/AzureStorage.cs

@@ -27,11 +27,15 @@
             await BlobClient.UploadBlobAsync(name, data);
         }
 
-        public async Task UploadFileAndDelete(string name, string filepath) {
+        public async Task UploadFileFromSource(string name, string filepath) {
             using (var stream = new FileStream(filepath, FileMode.Open, FileAccess.Read)) {
                 this.Logger.LogDebug("Uploading file {filepath} -> {name}", filepath, name);
                 await this.UploadFile(name, stream);
             }
+        }
+
+        public async Task UploadFileAndDelete(string name, string filepath) {
+            await this.UploadFileFromSource(name, filepath);
 
             this.Logger.LogDebug("Deleting file {filepath}", filepath);
             File.Delete(filepath);

ALttPRandomizer/Model/SeedSettings.cs

@@ -9,6 +9,9 @@
         [NoSettingName]
         public RandomizerInstance Randomizer { get; set; } = RandomizerInstance.Base;
 
+        [NoSettingName]
+        public string PlayerName { get; set; } = string.Empty;
+
         [NoSettingName]
         public RaceMode Race { get; set; } = RaceMode.Normal;
 

ALttPRandomizer/Program.cs

@@ -73,6 +73,7 @@
 
             builder.Services.AddKeyedScoped<IRandomizer, BaseRandomizer>(BaseRandomizer.Name);
             builder.Services.AddKeyedScoped<IRandomizer, Apr2025Randomizer>(Apr2025Randomizer.Name);
+            builder.Services.AddScoped<BaseRandomizer>();
 
             builder.Services.AddScoped<RandomizeService>();
             builder.Services.AddScoped<SeedService>();

ALttPRandomizer/Randomizers/BaseRandomizer.cs

@@ -10,6 +10,7 @@
     using System.Collections.Generic;
     using System.Diagnostics;
     using System.IO;
+    using System.Linq;
     using System.Text.Json;
     using System.Threading.Tasks;
 
@@ -20,16 +21,19 @@
         public BaseRandomizer(
                 AzureStorage azureStorage,
                 CommonSettingsProcessor settingsProcessor,
+                IdGenerator idGenerator,
                 IOptionsMonitor<ServiceOptions> optionsMonitor,
                 ILogger<BaseRandomizer> logger) {
-            AzureStorage = azureStorage;
+            this.AzureStorage = azureStorage;
-            SettingsProcessor = settingsProcessor;
+            this.SettingsProcessor = settingsProcessor;
-            OptionsMonitor = optionsMonitor;
+            this.IdGenerator = idGenerator;
-            Logger = logger;
+            this.OptionsMonitor = optionsMonitor;
+            this.Logger = logger;
         }
 
         private CommonSettingsProcessor SettingsProcessor { get; }
         private AzureStorage AzureStorage { get; }
+        private IdGenerator IdGenerator { get; }
         private IOptionsMonitor<ServiceOptions> OptionsMonitor { get; }
         private ILogger<BaseRandomizer> Logger { get; }
         private ServiceOptions Configuration => OptionsMonitor.CurrentValue;
@@ -38,9 +42,30 @@
             this.SettingsProcessor.ValidateSettings(Instance, settings);
         }
 
-        public async Task Randomize(string id, SeedSettings settings) {
+        public void ValidateAll(IList<SeedSettings> settings) {
-            Logger.LogDebug("Recieved request for id {id} to randomize settings {@settings}", id, settings);
+            foreach (var settingsItem in settings) {
+                this.Validate(settingsItem);
+                if (string.IsNullOrWhiteSpace(settingsItem.PlayerName)) {
+                    throw new InvalidSettingsException("PlayerNames must be non-empty");
+                }
+            }
+        }
 
+        private IList<string> GetArgs(SeedSettings settings) {
+            var args = new List<string>() {
+                "--reduce_flashing",
+                "--quickswap",
+                "--shufflelinks",
+                "--shuffletavern",
+            };
+
+            foreach (var arg in SettingsProcessor.GetSettings(Instance, settings)) {
+                args.Add(arg);
+            }
+            return args;
+        }
+
+        private async Task StartProcess(string id, IEnumerable<string> settings, Func<int, Task> completed) {
             var start = new ProcessStartInfo() {
                 FileName = Configuration.PythonPath,
                 WorkingDirectory = Configuration.RandomizerPaths[Name],
@@ -62,13 +87,7 @@
 
             args.Add("--spoiler=json");
 
-            args.Add("--reduce_flashing");
+            foreach (var arg in settings) {
-            args.Add("--quickswap");
-
-            args.Add("--shufflelinks");
-            args.Add("--shuffletavern");
-
-            foreach (var arg in SettingsProcessor.GetSettings(Instance, settings)) {
                 args.Add(arg);
             }
 
@@ -87,51 +106,140 @@
             process.BeginErrorReadLine();
 
             process.Exited += async (sender, args) => {
-                var exitcode = process.ExitCode;
+                await completed.Invoke(process.ExitCode);
+            };
+        }
 
+        public async Task Randomize(string id, SeedSettings settings) {
+            Logger.LogDebug("Recieved request for id {id} to randomize settings {@settings}", id, settings);
+
+            await StartProcess(id, this.GetArgs(settings), async exitcode => {
                 if (exitcode != 0) {
                     await GenerationFailed(id, exitcode);
                 } else {
-                    await GenerationSucceeded(id, settings);
+                    await SingleSucceeded(id);
                 }
-            };
+            });
 
             var settingsJson = JsonSerializer.SerializeToDocument(settings, JsonOptions.Default);
             var settingsOut = string.Format("{0}/settings.json", id);
             await AzureStorage.UploadFile(settingsOut, new BinaryData(settingsJson));
         }
 
-        private async Task GenerationSucceeded(string id, SeedSettings settings) {
+        public async Task RandomizeMultiworld(string id, IList<SeedSettings> settings) {
-            var rom = Path.Join(Path.GetTempPath(), string.Format("OR_{0}.sfc", id));
+            Logger.LogDebug("Recieved request for id {id} to randomize multiworld settings {@settings}", id, settings);
 
-            var bpsIn = Path.Join(Path.GetTempPath(), string.Format("OR_{0}.bps", id));
+            var names = settings.Select(s => s.PlayerName).ToList();
+
+            var args = settings.Select((s, idx) => string.Format("--p{0}={1}", idx + 1, string.Join(" ", this.GetArgs(s))))
+                .Append(string.Format("--names={0}", string.Join(",", names)))
+                .Append(string.Format("--multi={0}", settings.Count));
+
+            await StartProcess(id, args, async exitcode => {
+                if (exitcode != 0) {
+                    await GenerationFailed(id, exitcode);
+                } else {
+                    await MultiSucceeded(id, settings);
+                }
+            });
+
+            var settingsJson = JsonSerializer.SerializeToDocument(settings, JsonOptions.Default);
+            var settingsOut = string.Format("{0}/settings.json", id);
+            await AzureStorage.UploadFile(settingsOut, new BinaryData(settingsJson));
+        }
+
+        private async Task SingleSucceeded(string id) {
+            var basename = string.Format("OR_{0}", id);
+            await this.UploadFiles(id, basename, 1, null);
+
+            var metaIn = Path.Join(Path.GetTempPath(), string.Format("OR_{0}_Meta.json", id));
+            Logger.LogDebug("Deleting file {filepath}", metaIn);
+            File.Delete(metaIn);
+
+            var spoilerIn = Path.Join(Path.GetTempPath(), string.Format("OR_{0}_Spoiler.json", id));
+            Logger.LogDebug("Deleting file {filepath}", spoilerIn);
+            File.Delete(spoilerIn);
+
+            var generating = string.Format("{0}/generating", id);
+            await AzureStorage.DeleteFile(generating);
+
+            Logger.LogInformation("Finished uploading seed id {id}", id);
+        }
+
+        private async Task UploadFiles(string id, string basename, int playerNum, string? parentId) {
+            var tasks = new List<Task>();
+
+            var rom = Path.Join(Path.GetTempPath(), string.Format("{0}.sfc", basename));
+            Logger.LogDebug("Deleting file {filepath}", rom);
+            File.Delete(rom);
+
+            var bpsIn = Path.Join(Path.GetTempPath(), string.Format("{0}.bps", basename));
             var bpsOut = string.Format("{0}/patch.bps", id);
-            var uploadPatch = AzureStorage.UploadFileAndDelete(bpsOut, bpsIn);
+            tasks.Add(this.AzureStorage.UploadFileAndDelete(bpsOut, bpsIn));
+
+            var spoilerIn = Path.Join(Path.GetTempPath(), string.Format("OR_{0}_Spoiler.json", parentId ?? id));
+            var spoilerOut = string.Format("{0}/spoiler.json", id);
+            tasks.Add(this.AzureStorage.UploadFileFromSource(spoilerOut, spoilerIn));
+
+            var metaIn = Path.Join(Path.GetTempPath(), string.Format("OR_{0}_Meta.json", parentId ?? id));
+            var metaOut = string.Format("{0}/meta.json", id);
+            var meta = ProcessMetadata(metaIn, playerNum);
+            tasks.Add(this.AzureStorage.UploadFile(metaOut, new BinaryData(meta)));
+
+            if (parentId != null) {
+                var parentOut = string.Format("{0}/parent", id);
+                tasks.Add(this.AzureStorage.UploadFile(parentOut, new BinaryData(parentId)));
+            }
+
+            await Task.WhenAll(tasks);
+        }
+
+        private async Task MultiSucceeded(string id, IList<SeedSettings> settings) {
+            var tasks = new List<Task>();
+            var subIds = new List<string>();
+            var worlds = new List<object>();
+
+            for (var i = 0; i < settings.Count; i++) {
+                var basename = string.Format("OR_{0}_P{1}_{2}", id, i + 1, settings[i].PlayerName);
+                var randomId = this.IdGenerator.GenerateId();
+                subIds.Add(randomId);
+                tasks.Add(this.UploadFiles(randomId, basename, i + 1, id));
+
+                worlds.Add(new { Name = settings[i].PlayerName, Id = randomId });
+
+                var settingsJson = JsonSerializer.SerializeToDocument(settings[i], JsonOptions.Default);
+                var settingsOut = string.Format("{0}/settings.json", randomId);
+                tasks.Add(this.AzureStorage.UploadFile(settingsOut, new BinaryData(settingsJson)));
+            }
+
+            var worldsJson = JsonSerializer.SerializeToDocument(worlds, JsonOptions.Default);
+            var worldsOut = string.Format("{0}/worlds.json", id);
+
+            tasks.Add(this.AzureStorage.UploadFile(worldsOut, new BinaryData(worldsJson)));
+
+            await Task.WhenAll(tasks);
+
+            var metaIn = Path.Join(Path.GetTempPath(), string.Format("OR_{0}_Meta.json", id));
+            var metaOut = string.Format("{0}/meta.json", id);
+            var uploadMeta = AzureStorage.UploadFileAndDelete(metaOut, metaIn);
 
             var spoilerIn = Path.Join(Path.GetTempPath(), string.Format("OR_{0}_Spoiler.json", id));
             var spoilerOut = string.Format("{0}/spoiler.json", id);
             var uploadSpoiler = AzureStorage.UploadFileAndDelete(spoilerOut, spoilerIn);
 
-            var metaIn = Path.Join(Path.GetTempPath(), string.Format("OR_{0}_Meta.json", id));
+            var multidataIn = Path.Join(Path.GetTempPath(), string.Format("OR_{0}_multidata", id));
-            var metaOut = string.Format("{0}/meta.json", id);
+            var multidataOut = string.Format("{0}/multidata", id);
-            var meta = ProcessMetadata(metaIn);
+            var uploadMultidata = AzureStorage.UploadFileAndDelete(multidataOut, multidataIn);
-            var uploadMeta = AzureStorage.UploadFile(metaOut, new BinaryData(meta));
+
+            await Task.WhenAll(uploadMeta, uploadSpoiler, uploadMultidata);
 
             var generating = string.Format("{0}/generating", id);
             var deleteGenerating = AzureStorage.DeleteFile(generating);
 
-            await Task.WhenAll(uploadPatch, uploadSpoiler, uploadMeta, deleteGenerating);
+            Logger.LogInformation("Finished uploading multiworld id {id}", id);
-
-            Logger.LogDebug("Deleting file {filepath}", metaIn);
-            File.Delete(metaIn);
-
-            Logger.LogDebug("Deleting file {filepath}", rom);
-            File.Delete(rom);
-
-            Logger.LogInformation("Finished uploading seed id {id}", id);
         }
 
-        private JsonDocument ProcessMetadata(string path) {
+        private JsonDocument ProcessMetadata(string path, int playerNum) {
             JsonDocument orig;
             using (var file = File.OpenRead(path)) {
                 orig = JsonDocument.Parse(file);
@@ -140,8 +248,8 @@
             var processed = new Dictionary<string, JsonElement>();
             foreach (var toplevel in orig.RootElement.EnumerateObject()) {
                 var value = toplevel.Value;
-                if (value.ValueKind == JsonValueKind.Object && value.TryGetProperty("1", out var p1)) {
+                if (value.ValueKind == JsonValueKind.Object && value.TryGetProperty(playerNum.ToString(), out var p)) {
-                    processed[toplevel.Name] = p1;
+                    processed[toplevel.Name] = p;
                 } else {
                     processed[toplevel.Name] = toplevel.Value;
                 }

ALttPRandomizer/SeedController.cs

@@ -4,6 +4,7 @@
     using ALttPRandomizer.Settings;
     using Microsoft.AspNetCore.Mvc;
     using Microsoft.Extensions.Logging;
+    using System.Collections.Generic;
     using System.Threading.Tasks;
 
     public class SeedController : Controller {
@@ -32,6 +33,21 @@
             }
         }
 
+        [Route("/multiworld")]
+        [HttpPost]
+        public async Task<ActionResult> GenerateMultiworld([FromBody] IList<SeedSettings> settings) {
+            if (!ModelState.IsValid) {
+                return BadRequest(ModelState);
+            }
+            try {
+                var id = await this.RandomizeService.RandomizeMultiworld(settings);
+                var url = string.Format("/multi/{0}", id);
+                return Accepted(url, id);
+            } catch (InvalidSettingsException ex) {
+                return BadRequest(ex.Message);
+            }
+        }
+
         [Route("/seed/{id}")]
         [HttpGet]
         public async Task<ActionResult> GetSeed(string id) {
@@ -50,5 +66,24 @@
             this.Logger.LogWarning("Unexpected result from SeedService: {@result}", result);
             return StatusCode(500);
         }
+
+        [Route("/multi/{id}")]
+        [HttpGet]
+        public async Task<ActionResult> GetMulti(string id) {
+            var result = await this.SeedService.GetMulti(id);
+            if (result.TryGetValue("status", out var responseCode)) {
+                switch (responseCode) {
+                    case 200:
+                        return Ok(result);
+                    case 404:
+                        return NotFound(result);
+                    case 409:
+                        return Conflict(result);
+                }
+            }
+
+            this.Logger.LogWarning("Unexpected result from SeedService: {@result}", result);
+            return StatusCode(500);
+        }
     }
 }

ALttPRandomizer/Service/RandomizeService.cs

@@ -5,19 +5,22 @@
     using Microsoft.Extensions.DependencyInjection;
     using Microsoft.Extensions.Logging;
     using System;
+    using System.Collections.Generic;
     using System.Reflection;
     using System.Threading.Tasks;
 
     public class RandomizeService {
-        public RandomizeService(IdGenerator idGenerator, IServiceProvider serviceProvider, ILogger<RandomizeService> logger) {
+        public RandomizeService(IdGenerator idGenerator, IServiceProvider serviceProvider, BaseRandomizer baseRandomizer, ILogger<RandomizeService> logger) {
             this.IdGenerator = idGenerator;
             this.ServiceProvider = serviceProvider;
+            this.BaseRandomizer = baseRandomizer;
             this.Logger = logger;
         }
 
         private ILogger<RandomizeService> Logger { get; }
 
         private IdGenerator IdGenerator { get; }
+        private BaseRandomizer BaseRandomizer { get; }
         private IServiceProvider ServiceProvider { get; }
 
         public async Task<string> RandomizeSeed(SeedSettings settings) {
@@ -38,5 +41,15 @@
             await randomizer.Randomize(id, settings);
             return id;
         }
+
+        public async Task<string> RandomizeMultiworld(IList<SeedSettings> settings) {
+            var id = this.IdGenerator.GenerateId();
+            this.Logger.LogInformation("Generating multiworld {seedId} with settings {@settings}", id, settings);
+
+            this.BaseRandomizer.ValidateAll(settings);
+
+            await this.BaseRandomizer.RandomizeMultiworld(id, settings);
+            return id;
+        }
     }
 }

ALttPRandomizer/Service/SeedService.cs

@@ -4,6 +4,7 @@
     using Microsoft.Extensions.Logging;
     using System;
     using System.Collections.Generic;
+    using System.Linq;
     using System.Text.Json;
     using System.Threading.Tasks;
 
@@ -52,6 +53,10 @@
                 result["meta"] = json;
             }
 
+            if (files.TryGetValue("parent", out var parent)) {
+                result["parent"] = parent.ToString();
+            }
+
             if (settings.Race != RaceMode.Race && files.TryGetValue("spoiler.json", out var spoilerData)) {
                 var json = JsonDocument.Parse(spoilerData.ToString());
                 result["spoiler"] = json;
@@ -61,5 +66,56 @@
 
             return result;
         }
+
+        public async Task<IDictionary<string, object>> GetMulti(string multiId) {
+            var files = await this.AzureStorage.GetFiles(multiId);
+
+            this.Logger.LogDebug("Found files: {@files}", files.Keys);
+
+            var result = new Dictionary<string, object>();
+
+            if (!files.TryGetValue("settings.json", out var settingsData)) {
+                result["status"] = 404;
+                result["error"] = "multi not found";
+                return result;
+            }
+
+            var settingsJson = JsonDocument.Parse(settingsData.ToString());
+            result["settings"] = settingsJson;
+
+            var settings = settingsJson.Deserialize<IList<SeedSettings>>(JsonOptions.Default) ?? new List<SeedSettings>();
+
+            if (!files.TryGetValue("multidata", out var multidata)) {
+                if (files.ContainsKey("generating")) {
+                    result["status"] = 409;
+                    result["error"] = "generation still in progress";
+                    return result;
+                } else {
+                    result["status"] = 404;
+                    result["error"] = "generation failed";
+                    return result;
+                }
+            }
+            result["multidata"] = Convert.ToBase64String(multidata.ToArray());
+
+            if (files.TryGetValue("meta.json", out var metaData)) {
+                var json = JsonDocument.Parse(metaData.ToString());
+                result["meta"] = json;
+            }
+
+            if (files.TryGetValue("worlds.json", out var worlds)) {
+                var json = JsonDocument.Parse(worlds.ToString());
+                result["worlds"] = json;
+            }
+
+            if (!settings.Any(s => s.Race == RaceMode.Race) && files.TryGetValue("spoiler.json", out var spoilerData)) {
+                var json = JsonDocument.Parse(spoilerData.ToString());
+                result["spoiler"] = json;
+            }
+
+            result["status"] = 200;
+
+            return result;
+        }
     }
 }

ALttPRandomizer/Settings/CommonSettingsProcessor.cs

@@ -10,6 +10,9 @@
             var props = typeof(SeedSettings).GetProperties(BindingFlags.Instance | BindingFlags.Public);
             var starting = new List<string>();
             foreach (var prop in props) {
+                if (prop.Name == nameof(SeedSettings.PlayerName)) {
+                    continue;
+                }
                 var value = prop.GetValue(settings) ?? throw new SettingsLookupException("settings.{0} not found", prop.Name);
                 var valueFieldName = value.ToString() ?? throw new SettingsLookupException("settings.{0}.ToString() returned null", prop.Name);
                 var fi = prop.PropertyType.GetField(valueFieldName, BindingFlags.Static | BindingFlags.Public)