Functions for magic cost-dependent logic for spells

RandomizerCore/RequirementType.cs

@@ -35,6 +35,33 @@ public enum RequirementType
 
 public static class RequirementTypeExtensions
 {
+    /// Mirror of Collectable.AsRequirement()
+    public static Collectable? AsCollectable(this RequirementType requirementType)
+    {
+        return requirementType switch
+        {
+            RequirementType.JUMP => Collectable.JUMP_SPELL,
+            RequirementType.FAIRY => Collectable.FAIRY_SPELL,
+            RequirementType.UPSTAB => Collectable.UPSTAB,
+            RequirementType.DOWNSTAB => Collectable.DOWNSTAB,
+            RequirementType.KEY => Collectable.MAGIC_KEY,
+            RequirementType.DASH => Collectable.DASH_SPELL,
+            RequirementType.GLOVE => Collectable.GLOVE,
+            RequirementType.REFLECT => Collectable.REFLECT_SPELL,
+            RequirementType.SPELL => Collectable.SPELL_SPELL,
+            RequirementType.TROPHY => Collectable.TROPHY,
+            RequirementType.MEDICINE => Collectable.MEDICINE,
+            RequirementType.CHILD => Collectable.CHILD,
+            RequirementType.MIRROR => Collectable.MIRROR,
+            RequirementType.WATER => Collectable.WATER,
+            RequirementType.FLUTE => Collectable.FLUTE,
+            RequirementType.HAMMER => Collectable.HAMMER,
+            RequirementType.BOOTS => Collectable.BOOTS,
+            RequirementType.BAGU_LETTER => Collectable.BAGUS_NOTE,
+            _ => null
+        };
+    }
+
     public static RequirementType[] UpToXContainers(int x)
     {
         List<RequirementType> requirements = [];
@@ -72,4 +99,27 @@ public static RequirementType[] UpToXContainers(int x)
         }
         return requirements.ToArray();
     }
+
+    public static RequirementType MagicContainerRequirementFromCost(int magicCost)
+    {
+        switch (magicCost)
+        {
+            case <= 16:
+                return RequirementType.ONE_CONTAINER;
+            case <= 32:
+                return RequirementType.TWO_CONTAINERS;
+            case <= 48:
+                return RequirementType.THREE_CONTAINERS;
+            case <= 64:
+                return RequirementType.FOUR_CONTAINERS;
+            case <= 80:
+                return RequirementType.FIVE_CONTAINERS;
+            case <= 96:
+                return RequirementType.SIX_CONTAINERS;
+            case <= 112:
+                return RequirementType.SEVEN_CONTAINERS;
+            default:
+                return RequirementType.EIGHT_CONTAINERS;
+        }
+    }
 }

RandomizerCore/Requirements.cs

@@ -19,7 +19,16 @@ public class Requirements
         {RequirementType.FAIRY, [RequirementType.FOUR_CONTAINERS] },
         {RequirementType.REFLECT, [RequirementType.FOUR_CONTAINERS] },
         {RequirementType.SPELL, [RequirementType.FOUR_CONTAINERS] },
-    };
+    };
+
+    // the magic level you have to each for each spell to be considered in-logic
+    private static readonly Dictionary<RequirementType, int> ImplicitMagicLevelRequirements = new()
+    {
+        { RequirementType.JUMP, 3 },
+        { RequirementType.FAIRY, 3 },
+        { RequirementType.REFLECT, 4 },
+        { RequirementType.SPELL, 4 },
+    };
 
     public RequirementType[] IndividualRequirements { get; private set; }
     public RequirementType[][] CompositeRequirements { get; private set; }
@@ -147,6 +156,73 @@ public bool AreSatisfiedBy(IEnumerable<RequirementType> requireables, bool enfor
             }
         }
         return individualRequirementsSatisfied || compositeRequirementSatisfied;
+    }
+
+    public bool AreSatisfiedBy(IEnumerable<RequirementType> requireables, StatRandomizer statRoll)
+    {
+        if (IndividualRequirements.Length + CompositeRequirements.Length == 0)
+        {
+            return true;
+        }
+        var individualRequirementsSatisfied = false;
+        var requirementTypes = requireables as RequirementType[] ?? requireables.ToArray();
+
+        statRoll.AssertHasRandomized();
+
+        bool StatAdjustedContainerRequirementSatisfied(RequirementType requirement)
+        {
+            if (ImplicitMagicLevelRequirements.ContainsKey(requirement))
+            {
+                Collectable collectable = requirement.AsCollectable()!.Value;
+                var requiredLevel = ImplicitMagicLevelRequirements[requirement];
+                var magicCost = statRoll.GetSpellCost(collectable, requiredLevel);
+                var containerRequirement = MagicContainerRequirementFromCost(magicCost);
+                return requirementTypes.Contains(containerRequirement);
+            }
+            else
+            {
+                return true;
+            }
+        }
+
+        foreach (var requirement in IndividualRequirements)
+        {
+            if (requirementTypes.Contains(requirement))
+            {
+                individualRequirementsSatisfied = true;
+                if (!StatAdjustedContainerRequirementSatisfied(requirement))
+                {
+                    individualRequirementsSatisfied = false;
+                }
+
+                if (individualRequirementsSatisfied)
+                {
+                    break;
+                }
+            }
+        }
+
+        bool compositeRequirementSatisfied = false;
+        foreach (RequirementType[] compositeRequirement in CompositeRequirements)
+        {
+            if (compositeRequirement.All(i => requireables.Contains(i)))
+            {
+                compositeRequirementSatisfied = true;
+            }
+            foreach (RequirementType component in compositeRequirement)
+            {
+                if (!StatAdjustedContainerRequirementSatisfied(component))
+                {
+                    compositeRequirementSatisfied = false;
+                    break;
+                }
+            }
+            if (compositeRequirementSatisfied == true)
+            {
+                break;
+            }
+        }
+        return individualRequirementsSatisfied || compositeRequirementSatisfied;
     }
 
     public Requirements WithHardRequirement(RequirementType requirement)
@@ -240,6 +316,29 @@ public bool HasHardRequirement(RequirementType requireable)
         }
         return true;
     }
+
+    public static RequirementType MagicContainerRequirementFromCost(int magicCost)
+    {
+        switch (magicCost)
+        {
+            case <= 16:
+                return RequirementType.ONE_CONTAINER;
+            case <= 32:
+                return RequirementType.TWO_CONTAINERS;
+            case <= 48:
+                return RequirementType.THREE_CONTAINERS;
+            case <= 64:
+                return RequirementType.FOUR_CONTAINERS;
+            case <= 80:
+                return RequirementType.FIVE_CONTAINERS;
+            case <= 96:
+                return RequirementType.SIX_CONTAINERS;
+            case <= 112:
+                return RequirementType.SEVEN_CONTAINERS;
+            default:
+                return RequirementType.EIGHT_CONTAINERS;
+        }
+    }
 }
 
 public class RequirementsJsonConverter : JsonConverter<Requirements>

RandomizerCore/StatRandomizer.cs

@@ -712,4 +712,11 @@ public void FixRebonackHorseKillBug()
             BossHpTable[2] = reboHp;
         }
     }
+
+    public int GetSpellCost(Collectable spell, int level)
+    {
+        var spellIndex = spell.VanillaSpellOrder();
+        int index = spellIndex * 8 + level - 1;
+        return MagicEffectivenessTable[index];
+    }
 }