Improve CountPossibleMinorItems for multiple item palaces

Author: initsu

RandomizerCore/EnumTypes.cs

@@ -837,7 +837,7 @@ public enum PalaceLengthOption
     SHORT = 0,
     [Description("Medium; [60% to 80%]"), RandomRangeDouble(Low = 0.60, High = 0.80)]
     MEDIUM = 1,
-    [Description("Full; [85% to 115%]"), RandomRangeDouble(Low = 0.85, High = 1.15)]
+    [Description("Full"), RandomRangeDouble(Low = 0.85, High = 1.15)]
     FULL = 2, // remains 100% for Vanilla palaces
     [Description("Random; [50% to 115%]"), RandomRangeDouble(Low = 0.50, High = 1.15)]
     RANDOM = 3

RandomizerCore/Hyrule.cs

@@ -2327,9 +2327,9 @@ private void RandomizeStartingValues(RandomizerProperties props, Assembler a, Ra
         if (props.EncounterRates == EncounterRate.HALF)
         {
             //terrain timers
-            rom.Put(0x250, 0x40);
-            rom.Put(0x251, 0x30);
-            rom.Put(0x252, 0x30);
+            rom.Put(0x250, 0x40); // grass
+            rom.Put(0x251, 0x30); // desert
+            rom.Put(0x252, 0x30); // forest
             rom.Put(0x253, 0x40);
             rom.Put(0x254, 0x12);
             rom.Put(0x255, 0x06);

RandomizerCore/RandomizerConfiguration.cs

@@ -958,7 +958,7 @@ public RandomizerProperties Export(Random r)
             }
 
 
-            properties.PalaceLengths = Palaces.RollPalaceLengths(r, properties, this);
+            properties.PalaceLengths = Palaces.RollPalaceLengths(this, properties, r);
 
             properties.DarkLinkMinDistance = GetDarkLinkMinDistance();
 
@@ -1631,34 +1631,8 @@ public void AssignPalaceItemCounts(RandomizerProperties properties, Random r)
         //I'm not sure whether I like the bias introduced in generating random values and then capping them
         //vs just determining min/max ranges and fair rolling between them. Keeping it for now.
         int[] palaceItemRoomsMin = palaceItemRoomCount == PalaceItemRoomCount.RANDOM_INCLUDE_ZERO ? [0, 0, 0, 0, 0, 0] : [1, 1, 1, 1, 1, 1];
-        // To keep weighting consistent between 0-item and 1-item rooms across
-        // Standard, Max Rando, etc., we roll the room count the same way
-        // regardless of palace type. This also reduces how much (imperfect)
-        // information the item count reveals about the palace style.
-        int[] palaceItemRoomsMax = palaceItemRoomCount switch
-        {
-            PalaceItemRoomCount.ZERO => [0, 0, 0, 0, 0, 0],
-            PalaceItemRoomCount.ONE => [1, 1, 1, 1, 1, 1],
-            PalaceItemRoomCount.TWO => [2, 2, 2, 2, 2, 2],
-            PalaceItemRoomCount.RANDOM_NOT_ZERO or
-            PalaceItemRoomCount.RANDOM_INCLUDE_ZERO =>
-                properties.PalaceLengths.Select(len => len switch
-                {
-                    < 14 => 1,
-                    < 24 => 2,
-                    _    => 3,
-                }).ToArray(),
-            _ => throw new NotImplementedException(),
-        };
-        // We have to cap the number of item rooms for some styles.
-        // Vanilla, because it doesn't make sense to change any rooms,
-        // and Vanilla Shuffled, because it crashes with more than two.
-        int[] palaceItemRoomsLimit = properties.PalaceStyles.Select(style => style switch
-        {
-            PalaceStyle.VANILLA => 1,
-            PalaceStyle.SHUFFLED => 2,
-            _ => int.MaxValue,
-        }).ToArray();
+        int[] palaceItemRoomsMax = GetPalaceItemRoomMaxCounts(palaceItemRoomCount, properties.PalaceLengths);
+        int[] palaceItemRoomsLimit = GetPalaceItemRoomLimits(properties.PalaceStyles);
 
         switch (palaceItemRoomCount)
         {
@@ -1702,6 +1676,43 @@ PalaceItemRoomCount.RANDOM_NOT_ZERO or
         }
     }
 
+    /// Note: this value can be limited by other things, like the style being Vanilla
+    public static int[] GetPalaceItemRoomMaxCounts(PalaceItemRoomCount palaceItemRoomCount, int[] palaceLengths)
+    {
+        // To keep weighting consistent between 0-item and 1-item rooms across
+        // Standard, Max Rando, etc., we roll the room count the same way
+        // regardless of palace type. This also reduces how much (imperfect)
+        // information the item count reveals about the palace style.
+        return palaceItemRoomCount switch
+        {
+            PalaceItemRoomCount.ZERO => [0, 0, 0, 0, 0, 0],
+            PalaceItemRoomCount.ONE => [1, 1, 1, 1, 1, 1],
+            PalaceItemRoomCount.TWO => [2, 2, 2, 2, 2, 2],
+            PalaceItemRoomCount.RANDOM_NOT_ZERO or
+            PalaceItemRoomCount.RANDOM_INCLUDE_ZERO =>
+                palaceLengths.Select(len => len switch
+                {
+                    < 16 => 1,
+                    < 26 => 2,
+                    _ => 3,
+                }).ToArray(),
+            _ => throw new NotImplementedException(),
+        };
+    }
+
+    public static int[] GetPalaceItemRoomLimits(PalaceStyle[] palaceStyles)
+    {
+        // We have to cap the number of item rooms for some styles.
+        // Vanilla, because it doesn't make sense to change any rooms,
+        // and Vanilla Shuffled, because it crashes with more than two.
+        return palaceStyles.Select(style => style switch
+        {
+            PalaceStyle.VANILLA => 1,
+            PalaceStyle.SHUFFLED => 2,
+            _ => int.MaxValue,
+        }).ToArray();
+    }
+
     /// Let the user know when their combination of flags will not be
     /// possible to achieve.
     /// 
@@ -1714,10 +1725,6 @@ public void CheckForFlagConflicts()
         {
             requiredMinorItemReplacements = 4 - (startingHeartContainersMax ?? 4);
         }
-        if (palaceItemRoomCount == PalaceItemRoomCount.ZERO)
-        {
-            requiredMinorItemReplacements += 6;
-        }
         if (CountPossibleMinorItems() < requiredMinorItemReplacements)
         {
             throw new UserFacingException("Impossible Item Flags", "Not enough possible item locations for removed palace items.\n\nAdd more starting items or more palace items.");
@@ -1906,6 +1913,13 @@ private int CountPossibleMinorItems()
 
         count += 4 - (8 - (startingMagicContainersMax ?? 8));
 
+        var palaceLengthsMax = Palaces.VANILLA_LENGTHS[..6].Select(n => Palaces.MaxLengthRoll(n, normalPalaceLength)).ToArray();
+        var itemCountMaxRoll = GetPalaceItemRoomMaxCounts(palaceItemRoomCount, palaceLengthsMax);
+        var itemCountLimit = GetPalaceItemRoomLimits(Enumerable.Repeat(normalPalaceStyle, 6).ToArray());
+        var palaceItemsMaxDiff = itemCountMaxRoll.Zip(itemCountLimit, Math.Min).Sum(n => n - 1);
+
+        count += palaceItemsMaxDiff;
+
         return count;
     }
 

RandomizerCore/Sidescroll/Palaces.cs

@@ -1,6 +1,6 @@
 using System;
 using System.Collections.Generic;
-using System.Collections.ObjectModel;
+using System.Collections.Immutable;
 using System.IO;
 using System.Linq;
 using System.Threading;
@@ -45,8 +45,8 @@ public class Palaces
         VANILLA_P7_ALLOWED_BLOCKERS
     ];
 
-    public static readonly ReadOnlyCollection<int> VANILLA_LENGTHS = [14, 21, 15, 21, 28, 27, 55];
-    public static readonly ReadOnlyCollection<int> VANILLA_MIN_PALACE_LENGTHS = [11, 16, 10, 19, 23, 20, 31];
+    public static readonly ImmutableArray<int> VANILLA_LENGTHS = [14, 21, 15, 21, 28, 27, 55];
+    public static readonly ImmutableArray<int> VANILLA_MIN_PALACE_LENGTHS = [11, 16, 10, 19, 23, 20, 31];
 
     public static Dictionary<RoomExitType, int> itemRoomCounts = [];
 
@@ -158,7 +158,7 @@ public async Task<List<Palace>> CreatePalaces(Random r, RandomizerProperties pro
         return palaces;
     }
 
-    public static int[] RollPalaceLengths(Random r, RandomizerProperties props, RandomizerConfiguration conf)
+    public static int[] RollPalaceLengths(RandomizerConfiguration conf, RandomizerProperties props, Random r)
     {
         int[] sizes = [.. VANILLA_LENGTHS];
 
@@ -264,6 +264,13 @@ public static int RollPalaceLength(Random random, int vanillaLength, PalaceLengt
         return Math.Min(Math.Max(random.Next(intMin, intMax), hardMin), hardMax);
     }
 
+    public static int MaxLengthRoll(int vanillaLength, PalaceLengthOption length)
+    {
+        var rr = length.GetRandomRangeDouble()!;
+        int intMax = (int)(Math.Round(rr.High * vanillaLength) + 1);
+        return intMax;
+    }
+
     private static bool ValidatePalaces(RandomizerProperties props, bool raftIsRequired, List<Palace> palaces)
     {
         //Enforce aggregate max length of enemy data