Replace int flag Limit attribute logic with Maximum attribute

- Maximum is more consistent since we already have the Minimum attribute
- The bit extent is calculated from the Min to Max (inclusive) range of values
- Do not waste bits on nullable int flags since null is not a supported input for any int field

- Set Magic Container minimum to 1 to remove the bug for release

Author: initsu

CoreSourceGenerator/FlagsSerializeGenerator.cs

@@ -89,8 +89,8 @@ private static bool IsPartialClass(SyntaxNode node)
                 DefaultValue = GetDefaultValue(f),
                 IsEnum = f.Type.TypeKind == TypeKind.Enum,
                 EnumSymbol = f.Type.TypeKind == TypeKind.Enum ? f.Type as INamedTypeSymbol : null,
-                Limit = GetCustomLimit(f),
                 Minimum = GetCustomMinimum(f),
+                Maximum = GetCustomMaximum(f),
                 CustomSerializerName = GetCustomFlagSerializer(f),
             }).ToList();
 
@@ -153,29 +153,29 @@ private static bool HasReactiveAttribute(IFieldSymbol field)
             .Any(attr => attr.AttributeClass?.Name.StartsWith("Reactive") ?? false);
     }
 
-    private static int? GetCustomLimit(IFieldSymbol property)
+    private static int? GetCustomMinimum(IFieldSymbol property)
     {
         var customAttr = property.GetAttributes()
-            .FirstOrDefault(attr => attr.AttributeClass?.Name.StartsWith("Limit") ?? false);
+            .FirstOrDefault(attr => attr.AttributeClass?.Name.StartsWith("Minimum") ?? false);
 
         if (customAttr?.ConstructorArguments.Length > 0 &&
-            customAttr.ConstructorArguments[0].Value is int limit)
+            customAttr.ConstructorArguments[0].Value is int minimum)
         {
-            return limit;
+            return minimum;
         }
 
         return null;
     }
 
-    private static int? GetCustomMinimum(IFieldSymbol property)
+    private static int? GetCustomMaximum(IFieldSymbol property)
     {
         var customAttr = property.GetAttributes()
-            .FirstOrDefault(attr => attr.AttributeClass?.Name.StartsWith("Minimum") ?? false);
+            .FirstOrDefault(attr => attr.AttributeClass?.Name.StartsWith("Maximum") ?? false);
 
         if (customAttr?.ConstructorArguments.Length > 0 &&
-            customAttr.ConstructorArguments[0].Value is int minimum)
+            customAttr.ConstructorArguments[0].Value is int maximum)
         {
-            return minimum;
+            return maximum;
         }
 
         return null;
@@ -393,15 +393,21 @@ private static void GenerateSerializerList(StringBuilder sb, List<SerializedFiel
 
     private static string GetSerializeCall(SerializedFieldInfo field)
     {
-        var limitExpression = field.Limit != null ? $"{field.Limit}" : "null";
-        var minExpression = $"{field.Minimum ?? 0}";
         var output = new StringBuilder();
-        if (field.FieldType is "int" or "int?" && field.Limit == null)
-            output.AppendLine($"#error Numeric type {field.FieldName} must have a `Limit` attribute!");
+        if (field.FieldType is "int" or "int?")
+        {
+            if (field.Minimum == null)
+            {
+                output.AppendLine($"#error Numeric type {field.FieldName} must have a `Minimum` attribute!");
+            }
+            if (field.Maximum == null)
+            {
+                output.AppendLine($"#error Numeric type {field.FieldName} must have a `Maximum` attribute!");
+            }
+        }
         output.Append(field.FieldType switch
         {
-            "int" or "System.Int32" => $"SerializeInt(flags, \"{field.FieldName}\", {field.FieldName}, false, {limitExpression}, {minExpression})",
-            "int?" or "System.Int32?" => $"SerializeInt(flags, \"{field.FieldName}\", {field.FieldName}, true, {limitExpression}, {minExpression})",
+            "int" or "int?" => $"SerializeInt(flags, \"{field.FieldName}\", {field.FieldName}, {field.Minimum}, {field.Maximum})",
             "bool" or "System.Boolean" => $"SerializeBool(flags, \"{field.FieldName}\", {field.FieldName}, false)",
             "bool?" or "System.Boolean?" => $"SerializeBool(flags, \"{field.FieldName}\", {field.FieldName}, true)",
             var type when field.IsEnum => $"SerializeEnum<{type}>(flags, \"{field.FieldName}\", {field.FieldName})",
@@ -412,16 +418,11 @@ private static string GetSerializeCall(SerializedFieldInfo field)
 
     private static string GetDeserializeCall(SerializedFieldInfo field)
     {
-        var limitExpression = field.Limit != null ? $"{field.Limit}" : "null";
-        var minExpression = $"{field.Minimum ?? 0}";
         var output = new StringBuilder();
         var propName = GetPropertyName(field.FieldName);
-        if (field.FieldType is "int" or "int?" && field.Limit == null)
-            output.AppendLine($"#error Numeric type {field.FieldName} must have a `Limit` attribute!");
         output.Append(field.FieldType switch
         {
-            "int" or "System.Int32" => $"{propName} = DeserializeInt(flags, \"{field.FieldName}\", {limitExpression}, {minExpression})",
-            "int?" or "System.Int32?" => $"{propName} = DeserializeNullableInt(flags, \"{field.FieldName}\", {limitExpression}, {minExpression})",
+            "int" or "int?" => $"{propName} = DeserializeInt(flags, \"{field.FieldName}\", {field.Minimum}, {field.Maximum})",
             "bool" or "System.Boolean" => $"{propName} = DeserializeBool(flags, \"{field.FieldName}\")",
             "bool?" or "System.Boolean?" => $"{propName} = DeserializeNullableBool(flags, \"{field.FieldName}\")",
             var type when field.IsEnum => $"{propName} = DeserializeEnum<{type}>(flags, \"{field.FieldName}\")",
@@ -582,7 +583,7 @@ public class SerializedFieldInfo
     public string? DefaultValue { get; set; }
     public bool IsEnum { get; set; }
     public INamedTypeSymbol? EnumSymbol { get; set; }
-    public int? Limit { get; set; }
+    public int? Maximum { get; set; }
     public int? Minimum { get; set; }
     public string? CustomSerializerName { get; set; }
 }

CrossPlatformUI/Views/Tabs/StartView.axaml

@@ -112,7 +112,7 @@
                                    Height="72"
                                    Value="{Binding Config.StartingMagicContainersMin}"
                                    FormatString="N0" ParsingNumberStyle="Integer"
-                                   ClipValueToMinMax="True" Minimum="0" Maximum="{Binding Config.StartingMagicContainersMax}" assists:TextFieldAssist.Hints="Start Min"/>
+                                   ClipValueToMinMax="True" Minimum="1" Maximum="{Binding Config.StartingMagicContainersMax}" assists:TextFieldAssist.Hints="Start Min"/>
 					<NumericUpDown Grid.Column="1"
                                    Height="72"
                                    Value="{Binding Config.StartingMagicContainersMax}"

RandomizerCore/Flags/FlagBuilder.cs

@@ -113,7 +113,7 @@ public FlagBuilder Append(int val, int extent, int? minimum = null)
             throw new ArgumentException("Value is greater than extent in FlagBuilder.Append(int, int)");
         }
 
-        BitArray argBits = new BitArray([value]);
+        BitArray argBits = new([value]);
         for (int i = BitOperations.Log2((uint)extent - 1); i >= 0; i--)
         {
             bits.Add(argBits[i]);

RandomizerCore/Flags/FlagReader.cs

@@ -134,20 +134,17 @@ public bool ReadBool()
     /// Reads an integer value using a fixed number of bits.
     /// 
     /// The number of bits read will be the minimum number of bits needed
-    /// to represent values in the range <c>[minimum, minimum + extent - 1]</c>.
+    /// to represent values in the range <c>[0, extent - 1]</c>.
     /// </summary>
     /// <param name="extent">
     /// The number of distinct values that may be represented.
     /// </param>
-    /// <param name="minimum">
-    /// Optional minimum value added to the decoded result.
-    /// </param>
     /// <returns>
     /// The decoded integer value.
     /// </returns>
     /// <remarks>
     /// <example>
-    /// Examples (with <c>minimum = 0</c>):
+    /// Examples:
     /// <list type="bullet">
     /// <item><description>
     /// <c>extent = 4</c> → values 0–3, uses 2 bits
@@ -158,35 +155,31 @@ public bool ReadBool()
     /// </list>
     /// </example>
     ///
-    /// The same <paramref name="extent"/> and <paramref name="minimum"/> values
+    /// The same <paramref name="extent"/> value
     /// must be used during encoding to ensure correct decoding.
     /// </remarks>
-    public int ReadInt(int extent, int? minimum = null)
+    public int ReadInt(int extent)
     {
-        var min = minimum ?? 0;
-        return Take(BitOperations.Log2((uint)extent - 1) + 1) + min;
+        return Take(BitOperations.Log2((uint)(extent - 1)) + 1);
     }
 
     /// <summary>
     /// Reads a nullable integer value using a fixed number of bits.
     /// 
     /// The number of bits read will be the minimum number of bits needed
     /// to represent values in the range
-    /// <c>[minimum, minimum + extent - 1]</c>, where the value
-    /// <c>minimum + extent</c> is reserved as a sentinel representing <c>null</c>.
+    /// <c>[0, extent - 1]</c>, where the value
+    /// <c>extent</c> is reserved as a sentinel representing <c>null</c>.
     /// </summary>
     /// <param name="extent">
     /// The number of distinct non-null values that may be represented.
     /// </param>
-    /// <param name="minimum">
-    /// Optional minimum value added to non-null decoded results.
-    /// </param>
     /// <returns>
     /// The decoded integer value, or <c>null</c>.
     /// </returns>
     /// <remarks>
     /// <example>
-    /// Examples (with <c>minimum = 0</c>):
+    /// Examples:
     /// <list type="bullet">
     /// <item><description>
     /// <c>extent = 3</c> → values 0–2 or null, uses 2 bits
@@ -197,17 +190,16 @@ public int ReadInt(int extent, int? minimum = null)
     /// </list>
     /// </example>
     ///
-    /// The same <paramref name="extent"/> and <paramref name="minimum"/> values
+    /// The same <paramref name="extent"/> value
     /// must be used during encoding to ensure correct decoding.
     /// </remarks>
-    public int? ReadNullableInt(int extent, int? minimum = null)
+    public int? ReadNullableInt(int extent)
     {
-        var min = minimum ?? 0;
         int result = (byte)Take(BitOperations.Log2((uint)extent) + 1);
         if (result == extent)
         {
             return null;
         }
-        return result + min;
+        return result;
     }
 }

RandomizerCore/Flags/LimitAttribute.cs

@@ -0,0 +1,12 @@
+using System;
+
+namespace Z2Randomizer.RandomizerCore.Flags;
+
+internal class MaximumAttribute : Attribute
+{
+    public int Maximum { get; }
+    public MaximumAttribute(int maximum) 
+    {
+        Maximum = maximum;
+    }
+}

RandomizerCore/Flags/MaximumAttribute.cs

@@ -123,23 +123,23 @@ public sealed partial class RandomizerConfiguration : INotifyPropertyChanged
     private StartingResourceLimit startSpellsLimit;
 
     [Reactive]
-    [Limit(8)]
     [Minimum(1)]
+    [Maximum(8)]
     private int? startingHeartContainersMin;
 
     [Reactive]
-    [Limit(8)]
     [Minimum(1)]
+    [Maximum(8)]
     private int? startingHeartContainersMax;
 
     [Reactive]
-    [Limit(8)]
-    [Minimum(0)]
+    [Minimum(1)]
+    [Maximum(8)]
     private int? startingMagicContainersMin;
 
     [Reactive]
-    [Limit(8)]
-    [Minimum(0)]
+    [Minimum(1)]
+    [Maximum(8)]
     private int? startingMagicContainersMax;
 
     [Reactive]
@@ -152,18 +152,18 @@ public sealed partial class RandomizerConfiguration : INotifyPropertyChanged
     private StartingLives startingLives;
 
     [Reactive]
-    [Limit(8)]
     [Minimum(1)]
+    [Maximum(8)]
     private int startingAttackLevel;
 
     [Reactive]
-    [Limit(8)]
     [Minimum(1)]
+    [Maximum(8)]
     private int startingMagicLevel;
 
     [Reactive]
-    [Limit(8)]
     [Minimum(1)]
+    [Maximum(8)]
     private int startingLifeLevel;
 
     [Reactive]
@@ -402,11 +402,13 @@ private bool palaceStylesAnyMetastyleSelected()
     private PalaceItemRoomCount palaceItemRoomCount;
 
     [Reactive]
-    [Limit(7)]
+    [Minimum(0)]
+    [Maximum(6)]
     private int palacesToCompleteMin;
 
     [Reactive]
-    [Limit(7)]
+    [Minimum(0)]
+    [Maximum(6)]
     [ConditionallyIncludeInFlags]
     [DefaultValue(6)]
     private int palacesToCompleteMax;
@@ -436,18 +438,18 @@ private bool palaceStylesAnyMetastyleSelected()
     private bool shuffleLifeExperience;
 
     [Reactive]
-    [Limit(8)]
     [Minimum(1)]
+    [Maximum(8)]
     private int attackLevelCap;
 
     [Reactive]
-    [Limit(8)]
     [Minimum(1)]
+    [Maximum(8)]
     private int magicLevelCap;
 
     [Reactive]
-    [Limit(8)]
     [Minimum(1)]
+    [Maximum(8)]
     private int lifeLevelCap;
 
     [Reactive]
@@ -828,20 +830,21 @@ private bool DeserializeBool(FlagReader flags, string name)
     {
         return flags.ReadNullableBool();
     }
-    private int DeserializeInt(FlagReader flags, string name, int limit, int? minimum)
+    private int DeserializeInt(FlagReader flags, string name, int minimum, int maximum)
     {
-        int min = minimum ?? 0;
-        return flags.ReadInt(limit) + min;
+        var extent = maximum - minimum + 1;
+        return flags.ReadInt(extent) + minimum;
     }
-    private int? DeserializeNullableInt(FlagReader flags, string name, int limit, int? minimum)
+    private int? DeserializeNullableInt(FlagReader flags, string name, int minimum, int maximum)
     {
-        return flags.ReadNullableInt(limit, minimum);
+        var extent = maximum - minimum + 1;
+        return flags.ReadNullableInt(extent) + minimum;
     }
 
     private T DeserializeEnum<T>(FlagReader flags, string name) where T: Enum
     {
-        var limit = GetEnumCount<T>();
-        var index = flags.ReadInt(limit);
+        var extent = GetEnumCount<T>();
+        var index = flags.ReadInt(extent);
         return GetEnumFromIndex<T>(index)!;
     }
 
@@ -858,8 +861,11 @@ private void SerializeBool(FlagBuilder flags, string name, bool? val, bool isNul
         }
     }
 
-    private void SerializeInt(FlagBuilder flags, string name, int? val, bool isNullable, int limit, int? minimum)
+    private void SerializeInt(FlagBuilder flags, string name, int? val, int minimum, int maximum)
     {
+        // We don't actually have any real nullable ints in the flags.
+        // Enums would probably always be a better option anyway.
+        /*
         // limit is checked for null in the flags source generator
         if (isNullable)
         {
@@ -869,22 +875,21 @@ private void SerializeInt(FlagBuilder flags, string name, int? val, bool isNulla
             }
             flags.Append(val, limit, minimum);
         }
-        else
+        */
+        int extent = maximum - minimum + 1;
+        int value = val ?? minimum;
+        if (value < minimum || value > maximum)
         {
-            var value = val!.Value;
-            if (value < minimum || value > minimum + limit)
-            {
-                logger.Warn($"Property ({name}) was out of range.");
-            }
-            flags.Append(value, limit, minimum);
+            logger.Warn($"Property ({name}={value}) is out of range.");
         }
+        flags.Append(value, extent, minimum);
     }
 
     private void SerializeEnum<T>(FlagBuilder flags, string name, T? val) where T: Enum
     {
         var index = GetEnumIndex<T>(val);
-        var limit = GetEnumCount<T>();
-        flags.Append(index, limit);
+        var extent = GetEnumCount<T>();
+        flags.Append(index, extent);
     }
 
     private void SerializeCustom<Serializer, T>(FlagBuilder flags, string name, T? val) where Serializer : IFlagSerializer where T : class