Big settings refactor

2026-01-24 15:22:20 -06:00
parent f5f8e6a9d0
commit e5fd52376e
16 changed files with 171 additions and 141 deletions
--- a/ALttPRandomizer/JsonOptions.cs
+++ b/ALttPRandomizer/JsonOptions.cs
@@ -3,7 +3,7 @@
    using System.Text.Json.Serialization;

    public static class JsonOptions {
-        public static JsonSerializerOptions Default = new JsonSerializerOptions(JsonSerializerDefaults.Web) {
+        public static readonly JsonSerializerOptions Default = new JsonSerializerOptions(JsonSerializerDefaults.Web) {
            PropertyNamingPolicy = JsonNamingPolicy.SnakeCaseLower,
            NumberHandling = JsonNumberHandling.Strict,
        }.WithStringEnum();
--- a/ALttPRandomizer/Model/SeedSettings.cs
+++ b/ALttPRandomizer/Model/SeedSettings.cs
@@ -26,20 +26,24 @@
        public Goal Goal { get; set; } = Goal.Ganon;

        [SettingName("crystals_ganon")]
+        [IgnoreSetting(Apr2025)]
        public EntryRequirement CrystalsGanon { get; set; } = EntryRequirement.Crystals7;

        [SettingName("bosses_ganon")]
-        [NoSettingName([Apr2025, Base])]
+        [IgnoreSetting(Apr2025, Base)]
        public BossRequirement BossesGanon { get; set; } = BossRequirement.Bosses8of10;

+        [NoSettingName]
+        [IgnoreSetting(Apr2025)]
+        public TriforceRequirement TriforcePieces { get; set; } = TriforceRequirement.Triforce20of30;
+
        [SettingName("crystals_gt")]
        [JsonPropertyName("crystals_gt")]
-        [NoSettingName([Apr2025])]
+        [IgnoreSetting(Apr2025)]
        public EntryRequirement CrystalsGT { get; set; } = EntryRequirement.Crystals7;

        [SettingName("ganon_item")]
-        [RequiredSetting([Apr2025], GanonItem.Silver)]
-        [NoSettingName([Apr2025])]
+        [IgnoreSetting(Apr2025)]
        public GanonItem GanonItem { get; set; } = GanonItem.Silver;

        [SettingName("shuffle")]
@@ -47,32 +51,27 @@
        public EntranceShuffle EntranceShuffle { get; set; } = EntranceShuffle.Vanilla;

        [NoSettingName]
-        [RequiredSetting([Apr2025], LinksHouse.Vanilla)]
+        [IgnoreSetting(Apr2025)]
        public LinksHouse LinksHouse { get; set; } = LinksHouse.Vanilla;

        [SettingName("skullwoods")]
-        [RequiredSetting([Apr2025], SkullWoodsShuffle.Original)]
-        [NoSettingName([Apr2025])]
-        public SkullWoodsShuffle SkullWoods { get; set; } = SkullWoodsShuffle.Original;
+        [IgnoreSetting(Apr2025)]
+        public SkullWoodsShuffle SkullWoods { get; set; } = SkullWoodsShuffle.Default;

        [SettingName("linked_drops")]
-        [RequiredSetting([Apr2025], LinkedDrops.Unset)]
-        [NoSettingName([Apr2025])]
-        public LinkedDrops LinkedDrops { get; set; } = LinkedDrops.Unset;
+        [IgnoreSetting(Apr2025)]
+        public LinkedDrops LinkedDrops { get; set; } = LinkedDrops.Default;

        [SettingName("shufflebosses")]
-        [RequiredSetting([Apr2025], BossShuffle.Vanilla)]
-        [NoSettingName([Apr2025])]
+        [IgnoreSetting(Apr2025)]
        public BossShuffle BossShuffle { get; set; } = BossShuffle.Vanilla;

        [SettingName("shuffleenemies")]
-        [RequiredSetting([Apr2025], EnemyShuffle.Vanilla)]
-        [NoSettingName([Apr2025])]
+        [IgnoreSetting(Apr2025)]
        public EnemyShuffle EnemyShuffle { get; set; } = EnemyShuffle.Vanilla;

        [SettingName("shuffle_damage_table")]
-        [RequiredSetting([Apr2025], DamageTableShuffle.Vanilla)]
-        [NoSettingName([Apr2025])]
+        [IgnoreSetting(Apr2025)]
        public DamageTableShuffle DamageTableShuffle { get; set; } = DamageTableShuffle.Vanilla;

        [SettingName("keyshuffle")]
@@ -81,44 +80,37 @@
        public KeyLocations SmallKeys { get; set; } = KeyLocations.Dungeon;

        [SettingName("bigkeyshuffle")]
-        [RequiredSetting([Apr2025], DungeonItemLocations.Dungeon)]
-        [NoSettingName([Apr2025])]
+        [IgnoreSetting(Apr2025)]
        public DungeonItemLocations BigKeys { get; set; } = DungeonItemLocations.Dungeon;

        [SettingName("mapshuffle")]
-        [RequiredSetting([Apr2025], DungeonItemLocations.Dungeon)]
-        [NoSettingName([Apr2025])]
+        [IgnoreSetting(Apr2025)]
        public DungeonItemLocations Maps { get; set; } = DungeonItemLocations.Dungeon;

        [SettingName("compassshuffle")]
-        [RequiredSetting([Apr2025], DungeonItemLocations.Dungeon)]
-        [NoSettingName([Apr2025])]
+        [IgnoreSetting(Apr2025)]
        public DungeonItemLocations Compasses { get; set; } = DungeonItemLocations.Dungeon;

        [SettingName("showloot")]
-        [RequiredSetting([Apr2025, Base], ShowLoot.Never)]
-        [NoSettingName([Apr2025, Base])]
+        [IgnoreSetting(Apr2025, Base)]
        public ShowLoot ShowLoot { get; set; } = ShowLoot.Never;

        [SettingName("showmap")]
-        [RequiredSetting([Apr2025, Base], ShowMap.Map)]
-        [NoSettingName([Apr2025, Base])]
+        [IgnoreSetting(Apr2025, Base)]
        public ShowMap ShowMap { get; set; } = ShowMap.Map;

        [NoSettingName]
-        [RequiredSetting([Apr2025], ShopShuffle.Vanilla)]
+        [IgnoreSetting(Apr2025)]
        public ShopShuffle ShopShuffle { get; set; } = ShopShuffle.Vanilla;

-        [RequiredSetting([Apr2025], DropShuffle.Vanilla)]
-        [NoSettingName([Apr2025])]
+        [IgnoreSetting(Apr2025)]
        public DropShuffle DropShuffle { get; set; } = DropShuffle.Vanilla;

-        [RequiredSetting([Apr2025], Pottery.Vanilla)]
-        [NoSettingName([Apr2025])]
-        public Pottery Pottery { get; set; } = Pottery.Vanilla;
+        [SettingName("pottery")]
+        [IgnoreSetting(Apr2025)]
+        public PotShuffle PotShuffle { get; set; } = PotShuffle.Vanilla;

-        [RequiredSetting([Apr2025], PrizeShuffle.Vanilla)]
-        [NoSettingName([Apr2025])]
+        [IgnoreSetting(Apr2025)]
        public PrizeShuffle PrizeShuffle { get; set; } = PrizeShuffle.Vanilla;

        [NoSettingName]
@@ -126,57 +118,55 @@
        public BootsSettings Boots { get; set; } = BootsSettings.Normal;

        [NoSettingName]
-        [RequiredSetting([Apr2025], FluteSettings.Normal)]
+        [IgnoreSetting(Apr2025)]
        public FluteSettings Flute { get; set; } = FluteSettings.Normal;

        [SettingName("dark_rooms")]
-        [RequiredSetting([Apr2025], DarkRoomSettings.RequireLamp)]
-        [NoSettingName([Apr2025])]
+        [IgnoreSetting(Apr2025)]
        public DarkRoomSettings DarkRooms { get; set; } = DarkRoomSettings.RequireLamp;

        [NoSettingName]
-        [RequiredSetting([Apr2025], BombSettings.Normal)]
+        [IgnoreSetting(Apr2025)]
        public BombSettings Bombs { get; set; } = BombSettings.Normal;

        [NoSettingName]
-        [RequiredSetting([Apr2025], BookSettings.Normal)]
+        [IgnoreSetting(Apr2025)]
        public BookSettings Book { get; set; } = BookSettings.Normal;

        [NoSettingName]
-        [RequiredSetting([Apr2025], MirrorSettings.Normal)]
+        [IgnoreSetting(Apr2025)]
        public MirrorSettings Mirror { get; set; } = MirrorSettings.Normal;

        [SettingName("door_shuffle")]
-        [RequiredSetting([Apr2025], DoorShuffle.Vanilla)]
-        [NoSettingName([Apr2025])]
+        [IgnoreSetting(Apr2025)]
        public DoorShuffle DoorShuffle { get; set; } = DoorShuffle.Vanilla;

        [SettingName("intensity")]
-        [NoSettingName([Apr2025])]
+        [IgnoreSetting(Apr2025)]
        public DoorLobbies Lobbies { get; set; } = DoorLobbies.Vanilla;

        [SettingName("door_type_mode")]
-        [NoSettingName([Apr2025])]
+        [IgnoreSetting(Apr2025)]
        public DoorTypeMode DoorTypeMode { get; set; } = DoorTypeMode.Big;

        [SettingName("trap_door_mode")]
-        [NoSettingName([Apr2025])]
-        public TrapDoorMode TrapDoorMode { get; set; } = TrapDoorMode.Optional;
+        [IgnoreSetting(Apr2025)]
+        public TrapDoorMode TrapDoorMode { get; set; } = TrapDoorMode.Some;

        [NoSettingName]
-        [RequiredSetting([Apr2025], FollowerShuffle.Vanilla)]
+        [IgnoreSetting(Apr2025)]
        public FollowerShuffle FollowerShuffle { get; set; } = FollowerShuffle.Vanilla;

        [SettingName("ow_fluteshuffle")]
-        [NoSettingName([Apr2025])]
+        [IgnoreSetting(Apr2025)]
        public FluteShuffle FluteShuffle { get; set; } = FluteShuffle.Vanilla;

        [NoSettingName]
-        [RequiredSetting([Apr2025], TileSwap.Vanilla)]
+        [IgnoreSetting(Apr2025)]
        public TileSwap TileSwap { get; set; } = TileSwap.Vanilla;

        [SettingName("damage_challenge")]
-        [NoSettingName([Apr2025])]
+        [IgnoreSetting(Apr2025)]
        public DamageChallengeMode DamageChallenge { get; set; } = DamageChallengeMode.Normal;

        [NoSettingName]
@@ -187,7 +177,7 @@
    {
        [RandomizerName(BaseRandomizer.Name)] Base,
        [RandomizerName(Apr2025Randomizer.Name)] Apr2025,
-        [RandomizerName(BaseRandomizer.DungeonMapName)] DungeonMap,
+        [RandomizerName(BaseRandomizer.BetaName)] Beta,
    }

    public enum RaceMode {
@@ -234,6 +224,14 @@
        Random,
    }

+    public enum TriforceRequirement {
+        [JsonStringEnumMemberName("8of10")] [AdditionalSetting("--triforce_goal=8", "--triforce_pool=10")] Triforce8of10,
+        [JsonStringEnumMemberName("20of30")] [AdditionalSetting("--triforce_goal=20", "--triforce_pool=30")] Triforce20of30,
+        [JsonStringEnumMemberName("67of100")] [AdditionalSetting("--triforce_goal=67", "--triforce_pool=100")] Triforce67of100,
+        [JsonStringEnumMemberName("125of175")] [AdditionalSetting("--triforce_goal=125", "--triforce_pool=175")] Triforce125of175,
+        [JsonStringEnumMemberName("400of500")] [AdditionalSetting("--triforce_goal=400", "--triforce_pool=500")] Triforce400of500,
+    }
+
    public enum BossRequirement {
        [JsonStringEnumMemberName("0of10")] [SettingName("0")] Bosses0of10,
        [JsonStringEnumMemberName("1of10")] [SettingName("1")] Bosses1of10,
@@ -294,14 +292,14 @@
    }

    public enum SkullWoodsShuffle {
-        Original,
-        Restricted,
+        [SettingName("original")] Default,
+        [SettingName("restricted")] VanillaDrops,
        Loose,
-        FollowLinked,
+        [SettingName("follow_linked")] Chaos,
    }

    public enum LinkedDrops {
-        Unset,
+        [SettingName("unset")] Default,
        Linked,
        Independent,
    }
@@ -349,7 +347,7 @@
        Underworld,
    }

-    public enum Pottery {
+    public enum PotShuffle {
        [SettingName("none")] Vanilla,
        [AdditionalSetting("--colorizepots")] Keys,
        [AdditionalSetting("--colorizepots")] Cave,
@@ -358,7 +356,7 @@
        [AdditionalSetting("--colorizepots")] Clustered,
        [AdditionalSetting("--colorizepots")] NonEmpty,
        [AdditionalSetting("--colorizepots")] Dungeon,
-        Lottery,
+        [SettingName("lottery")] All,
    }

    public enum PrizeShuffle {
@@ -405,7 +403,7 @@
        [SettingName("always_light_cone")] AlwaysLightCone,
        [SettingName("no_dark_rooms")] NoDarkRooms,
        [SettingName("require_lamp")] [AddStartingItems("Lamp")] StartingLamp,
-        [SettingName("always_in_logic")] AlwaysInLogic,
+        [SettingName("always_in_logic")] DarkInLogic,
    }

    public enum BombSettings {
@@ -440,7 +438,7 @@

    public enum TrapDoorMode {
        Vanilla,
-        Optional,
+        [SettingName("optional")] Some,
        Boss,
        [SettingName("oneway")] RemoveAll,
    }
--- a/ALttPRandomizer/Options/ServiceOptions.cs
+++ b/ALttPRandomizer/Options/ServiceOptions.cs
@@ -4,11 +4,15 @@

    public class ServiceOptions {
        public string Baserom { get; set; } = null!;
-        public string PythonPath { get; set; } = null!;
        public string FlipsPath { get; set; } = null!;
-        public IList<string> AllowedCors { get; set; } = new List<string>();
-        public AzureSettings AzureSettings { get; set; } = new AzureSettings();
-        public IDictionary<string, string> RandomizerPaths { get; set; } = new Dictionary<string, string>();
+        public List<string> AllowedCors { get; set; } = [];
+        public AzureSettings AzureSettings { get; set; } = new();
+        public Dictionary<string, GeneratorSettings> Generators { get; set; } = new();
+    }
+
+    public class GeneratorSettings {
+        public string WorkingDirectory { get; set; } = null!;
+        public List<string> RandomizerCommand { get; set; } = [];
    }

    public class AzureSettings {
--- a/ALttPRandomizer/Program.cs
+++ b/ALttPRandomizer/Program.cs
@@ -72,7 +72,7 @@
            builder.Services.AddSingleton<ShutdownHandler>();

            builder.Services.AddKeyedScoped<IRandomizer, BaseRandomizer>(BaseRandomizer.Name);
-            builder.Services.AddKeyedScoped<IRandomizer, BaseRandomizer>(BaseRandomizer.DungeonMapName);
+            builder.Services.AddKeyedScoped<IRandomizer, BaseRandomizer>(BaseRandomizer.BetaName);
            builder.Services.AddKeyedScoped<IRandomizer, Apr2025Randomizer>(Apr2025Randomizer.Name);
            builder.Services.AddScoped<BaseRandomizer>();

--- a/ALttPRandomizer/Randomizers/Apr2025Randomizer.cs
+++ b/ALttPRandomizer/Randomizers/Apr2025Randomizer.cs
@@ -9,6 +9,7 @@
    using System;
    using System.Diagnostics;
    using System.IO;
+    using System.Linq;
    using System.Text.Json;
    using System.Threading.Tasks;

@@ -40,15 +41,14 @@
        public async Task Randomize(string id, SeedSettings settings, bool uploadSettings = true) {
            Logger.LogDebug("Recieved request for id {id} to randomize settings {@settings}", id, settings);

-            var start = new ProcessStartInfo() {
-                FileName = Configuration.PythonPath,
-                WorkingDirectory = Configuration.RandomizerPaths[Name],
+            var generatorSettings = this.Configuration.Generators[Name];
+            var start = new ProcessStartInfo(generatorSettings.RandomizerCommand[0], generatorSettings.RandomizerCommand.Skip(1)) {
+                WorkingDirectory = generatorSettings.WorkingDirectory,
                RedirectStandardOutput = true,
                RedirectStandardError = true,
            };

            var args = start.ArgumentList;
-            args.Add("EntranceRandomizer.py");
            args.Add("--rom");
            args.Add(Configuration.Baserom);

@@ -58,15 +58,11 @@
            args.Add("--outputname");
            args.Add(id);

-            args.Add("--json_spoiler");
-
-            args.Add("--quickswap");
-
            foreach (var arg in SettingsProcessor.GetSettings(Instance, settings)) {
                args.Add(arg);
            }

-            Logger.LogInformation("Randomizing with args: {args}", string.Join(" ", args));
+            Logger.LogInformation("Randomizing {id} with command: {command} {args}", id, start.FileName, string.Join(" ", args.Select(arg => arg.Contains(" ") ? $"\"{arg}\"" : arg)));

            var generating = string.Format("{0}/generating", id);
            await AzureStorage.UploadFile(generating, BinaryData.Empty);
--- a/ALttPRandomizer/Randomizers/BaseRandomizer.cs
+++ b/ALttPRandomizer/Randomizers/BaseRandomizer.cs
@@ -16,7 +16,7 @@

    public class BaseRandomizer : IRandomizer {
        public const string Name = "base";
-        public const string DungeonMapName = "dungeon_map";
+        public const string BetaName = "beta";

        public const int MULTI_TRIES = 100;
        public const int SINGLE_TRIES = 5;
@@ -57,7 +57,7 @@
            }
        }

-        private IList<string> GetArgs(SeedSettings settings) {
+        private List<string> GetArgs(SeedSettings settings) {
            var args = new List<string>() {
                "--reduce_flashing",
                "--quickswap",
@@ -73,26 +73,25 @@
            }

            if (settings.DoorShuffle != DoorShuffle.Vanilla || settings.DropShuffle != DropShuffle.Vanilla
-                || (settings.Pottery != Pottery.Vanilla && settings.Pottery != Pottery.Cave)) {
+                || (settings.PotShuffle != PotShuffle.Vanilla && settings.PotShuffle != PotShuffle.Cave)) {
                args.Add("--dungeon_counters=on");
            }

            return args;
        }

-        private async Task StartProcess(string randomizerName, string id, IEnumerable<string> settings, Func<int, Task> completed) {
-            var start = new ProcessStartInfo() {
-                FileName = Configuration.PythonPath,
-                WorkingDirectory = Configuration.RandomizerPaths[randomizerName],
+        private async Task StartProcess(string generatorName, string id, IEnumerable<string> settings, Func<int, Task> completed) {
+            var generatorSettings = this.Configuration.Generators[generatorName];
+
+            var start = new ProcessStartInfo(generatorSettings.RandomizerCommand[0], generatorSettings.RandomizerCommand.Skip(1)) {
+                WorkingDirectory = generatorSettings.WorkingDirectory,
                RedirectStandardOutput = true,
                RedirectStandardError = true,
            };

            var args = start.ArgumentList;
-            args.Add("DungeonRandomizer.py");
            args.Add("--rom");
            args.Add(Configuration.Baserom);
-            args.Add("--bps");

            args.Add("--outputpath");
            args.Add(Path.GetTempPath());
@@ -100,13 +99,11 @@
            args.Add("--outputname");
            args.Add(id);

-            args.Add("--spoiler=json");
-
            foreach (var arg in settings) {
                args.Add(arg);
            }

-            Logger.LogInformation("Randomizing {id} with args: {args}", id, string.Join(" ", args.Select(arg => $"\"{arg}\"")));
+            Logger.LogInformation("Randomizing {id} with command: {command} {args}", id, start.FileName, string.Join(" ", args.Select(arg => arg.Contains(" ") ? $"\"{arg}\"" : arg)));

            var generating = string.Format("{0}/generating", id);
            await AzureStorage.UploadFile(generating, BinaryData.Empty);
@@ -114,8 +111,16 @@
            var process = Process.Start(start) ?? throw new GenerationFailedException("Process failed to start.");
            process.EnableRaisingEvents = true;

-            process.OutputDataReceived += (_, args) => Logger.LogInformation("Randomizer {id} STDOUT: {output}", id, args.Data);
-            process.ErrorDataReceived += (_, args) => Logger.LogInformation("Randomizer {id} STDERR: {output}", id, args.Data);
+            process.OutputDataReceived += (_, args) => {
+                if (args.Data != null) {
+                    Logger.LogInformation("Randomizer {id} STDOUT: {output}", id, args.Data);
+                }
+            };
+            process.ErrorDataReceived += (_, args) => {
+                if (args.Data != null) {
+                    Logger.LogInformation("Randomizer {id} STDERR: {output}", id, args.Data);
+                }
+            };

            process.BeginOutputReadLine();
            process.BeginErrorReadLine();
@@ -270,7 +275,7 @@
                Logger.LogInformation("Finished uploading multiworld id {id}", id);
            } finally {
                var generating = string.Format("{0}/generating", id);
-                var deleteGenerating = AzureStorage.DeleteFile(generating);
+                await AzureStorage.DeleteFile(generating);
            }
        }

@@ -293,11 +298,9 @@
            return JsonSerializer.SerializeToDocument(processed, JsonOptions.Default);
        }

-        private async Task GenerationFailed(string id, int exitcode) {
+        private async Task GenerationFailed(string id, int _) {
            var generating = string.Format("{0}/generating", id);
-            var deleteGenerating = AzureStorage.DeleteFile(generating);
-
-            await Task.WhenAll(deleteGenerating);
+            await AzureStorage.DeleteFile(generating);
        }
    }
 }
--- a/ALttPRandomizer/Settings/Attributes.cs
+++ b/ALttPRandomizer/Settings/Attributes.cs
@@ -42,21 +42,27 @@
    internal class NoSettingNameAttribute : RandomizerSpecificAttribute {
        public NoSettingNameAttribute() : base(null) { }

-        public NoSettingNameAttribute(RandomizerInstance[] randomizers) : base(randomizers) { }
+        public NoSettingNameAttribute(params RandomizerInstance[] randomizers) : base(randomizers) { }
    }

+    internal class IgnoreSettingAttribute : RandomizerSpecificAttribute {
+        public IgnoreSettingAttribute(params RandomizerInstance[] randomizers) : base(randomizers) { }
+    }
+
+    [AttributeUsage(AttributeTargets.Field, AllowMultiple=true)]
    internal class AdditionalSettingAttribute : RandomizerSpecificAttribute {
-        public AdditionalSettingAttribute(string setting) : base(null) {
-            this.Setting = setting;
+        public AdditionalSettingAttribute(params string[] settings) : base(null) {
+            this.Settings = settings;
        }

-        public AdditionalSettingAttribute(RandomizerInstance[] randomizers, string setting) : base(randomizers) {
-            this.Setting = setting;
+        public AdditionalSettingAttribute(RandomizerInstance[] randomizers, params string[] settings) : base(randomizers) {
+            this.Settings = settings;
        }

-        public string Setting { get; }
+        public string[] Settings { get; }
    }

+    [AttributeUsage(AttributeTargets.Field, AllowMultiple=true)]
    internal class AddStartingItemsAttribute : RandomizerSpecificAttribute {
        public AddStartingItemsAttribute(params string[] items) : base(null) {
            this.Items = items;
@@ -69,6 +75,7 @@
        public string[] Items { get; }
    }

+    [AttributeUsage(AttributeTargets.Property, AllowMultiple=true)]
    internal class RequiredSettingAttribute : RandomizerSpecificAttribute {
        public RequiredSettingAttribute(params object[] values) : base(null) {
            this.Values = values;
@@ -81,6 +88,7 @@
        public object[] Values { get; }
    }

+    [AttributeUsage(AttributeTargets.Property, AllowMultiple=true)]
    internal class ForbiddenSettingAttribute : RandomizerSpecificAttribute {
        public ForbiddenSettingAttribute(params object[] values) : base(null) {
            this.Values = values;
--- a/ALttPRandomizer/Settings/CommonSettingsProcessor.cs
+++ b/ALttPRandomizer/Settings/CommonSettingsProcessor.cs
@@ -13,11 +13,16 @@
                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)
                    ?? throw new SettingsLookupException("Could not get field info for value {0}.{1}", prop.PropertyType, valueFieldName);

+                if (prop.GetCustomAttributes<IgnoreSettingAttribute>().Any(att => att.HasRandomizer(randomizer))) {
+                    continue;
+                }
+
                if (!prop.GetCustomAttributes<NoSettingNameAttribute>().Any(att => att.HasRandomizer(randomizer))) {
                    var settingName =
                        prop.GetCustomAttributes<SettingNameAttribute>()
@@ -30,7 +35,9 @@
                }

                foreach (var att in fi.GetCustomAttributes<AdditionalSettingAttribute>().Where(att => att.HasRandomizer(randomizer))) {
-                    yield return att.Setting;
+                    foreach (var setting in att.Settings) {
+                        yield return setting;
+                    }
                }

                foreach (var att in fi.GetCustomAttributes<AddStartingItemsAttribute>().Where(att => att.HasRandomizer(randomizer))) {
@@ -79,11 +86,7 @@
        }
    }

-    public class SettingsLookupException : Exception {
-        public SettingsLookupException(string message, params object?[] args) : base(string.Format(message, args)) { }
-    }
+    public class SettingsLookupException(string message, params object?[] args) : Exception(string.Format(message, args)) { }

-    public class InvalidSettingsException : Exception {
-        public InvalidSettingsException(string message, params object?[] args) : base(string.Format(message, args)) { }
-    }
+    public class InvalidSettingsException(string message, params object?[] args) : Exception(string.Format(message, args)) { }
 }
--- a/ALttPRandomizer/appsettings.Docker.json
+++ b/ALttPRandomizer/appsettings.Docker.json
@@ -1,7 +1,6 @@
 {
  "ALttPRandomizer": {
-    "baserom": "/randomizer/alttp.sfc",
-    "pythonPath": "/usr/bin/python3",
+    "baserom": "/baserom/alttp.sfc",
    "flipsPath": "/flips/flips",
    "allowedCors": [
      "https://new.alttpr.gwaa.kiwi",
@@ -12,10 +11,19 @@
      "clientId": "a48d5ae1-fa0a-4e33-9586-18c0eca0a28c",
      "blobstoreEndpoint": "https://alttprstorage.blob.core.windows.net/seeds"
    },
-    "randomizerPaths": {
-      "base": "/randomizer",
-      "apr2025": "/apr2025_randomizer",
-      "dungeon_map": "/dungeon_map_randomizer"
+    "generators": {
+      "base": {
+         "workingDirectory": "/randomizer",
+         "randomizerCommand": [ "uv", "run", "DungeonRandomizer.py", "--bps", "--spoiler=json" ],
+      },
+      "apr2025": {
+         "workingDirectory": "/apr2025_randomizer",
+         "randomizerCommand": [ "uv", "run", "EntranceRandomizer.py", "--json_spoiler" ],
+      },
+      "beta": {
+         "workingDirectory": "/beta_randomizer",
+         "randomizerCommand": [ "uv", "run", "DungeonRandomizer.py", "--bps", "--spoiler=json" ],
+      },
    }
  },
  "Serilog": {