Allow level ranges in cenchant, add ordered option. Closes #374, closes #328

Author: Earthcomputer

src/main/java/net/earthcomputer/clientcommands/command/arguments/ItemAndEnchantmentsPredicateArgument.java

@@ -10,6 +10,7 @@
 import com.mojang.brigadier.suggestion.Suggestions;
 import com.mojang.brigadier.suggestion.SuggestionsBuilder;
 import net.earthcomputer.clientcommands.util.MultiVersionCompat;
+import net.minecraft.advancements.critereon.MinMaxBounds;
 import net.minecraft.commands.SharedSuggestionProvider;
 import net.minecraft.commands.arguments.ResourceArgument;
 import net.minecraft.core.component.DataComponents;
@@ -23,10 +24,12 @@
 import net.minecraft.world.item.enchantment.Enchantment;
 import net.minecraft.world.item.enchantment.EnchantmentInstance;
 import net.minecraft.world.item.enchantment.ItemEnchantments;
+import org.jetbrains.annotations.Nullable;
 
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
+import java.util.Collections;
 import java.util.List;
 import java.util.concurrent.CompletableFuture;
 import java.util.function.BiPredicate;
@@ -37,7 +40,6 @@ public class ItemAndEnchantmentsPredicateArgument implements ArgumentType<ItemAn
 
     private static final Collection<String> EXAMPLES = Arrays.asList("stick with sharpness 4 without sweeping *", "minecraft:diamond_sword with sharpness *");
 
-    private static final SimpleCommandExceptionType EXPECTED_WITH_WITHOUT_EXACTLY_EXCEPTION = new SimpleCommandExceptionType(Component.translatable("commands.cenchant.expectedWithWithoutExactly"));
     private static final SimpleCommandExceptionType INCOMPATIBLE_ENCHANTMENT_EXCEPTION = new SimpleCommandExceptionType(Component.translatable("commands.cenchant.incompatible"));
     private static final DynamicCommandExceptionType ID_INVALID_EXCEPTION = new DynamicCommandExceptionType(id -> Component.translatable("argument.item.id.invalid", id));
 
@@ -80,24 +82,38 @@ public ItemAndEnchantmentsPredicate parse(StringReader reader) throws CommandSyn
             if (parser.exact && (parser.with.size() != enchantments.size())) {
                 return false;
             }
-            for (EnchantmentInstance with : parser.with) {
-                boolean found = false;
-                for (EnchantmentInstance ench : enchantments) {
-                    if (with.enchantment == ench.enchantment && (with.level == -1 || with.level == ench.level)) {
-                        found = true;
-                        break;
+            if (parser.ordered) {
+                int enchIndex = 0;
+                for (EnchantmentInstancePredicate with : parser.with) {
+                    while (enchIndex < enchantments.size() && !with.test(enchantments.get(enchIndex))) {
+                        enchIndex++;
                     }
+                    if (enchIndex >= enchantments.size()) {
+                        return false;
+                    }
+                    // we're matching, increment index
+                    enchIndex++;
                 }
-                if (!found) {
-                    return false;
+            } else {
+                for (EnchantmentInstancePredicate with : parser.with) {
+                    boolean found = false;
+                    for (EnchantmentInstance ench : enchantments) {
+                        if (with.test(ench)) {
+                            found = true;
+                            break;
+                        }
+                    }
+                    if (!found) {
+                        return false;
+                    }
                 }
             }
             if (parser.exact) {
                 return true;
             }
-            for (EnchantmentInstance without : parser.without) {
+            for (EnchantmentInstancePredicate without : parser.without) {
                 for (EnchantmentInstance ench : enchantments) {
-                    if (without.enchantment == ench.enchantment && (without.level == -1 || without.level == ench.level)) {
+                    if (without.test(ench)) {
                         return false;
                     }
                 }
@@ -149,10 +165,11 @@ private class Parser {
         private Consumer<SuggestionsBuilder> suggestor;
 
         private Item item;
-        private final List<EnchantmentInstance> with = new ArrayList<>();
-        private final List<EnchantmentInstance> without = new ArrayList<>();
+        private final List<EnchantmentInstancePredicate> with = new ArrayList<>();
+        private final List<EnchantmentInstancePredicate> without = new ArrayList<>();
 
         private boolean exact = false;
+        private boolean ordered = false;
 
         public Parser(StringReader reader) {
             this.reader = reader;
@@ -163,9 +180,8 @@ public void parse() throws CommandSyntaxException {
 
             while (reader.canRead()) {
                 parseSpace();
-                parseInfoEnchantment();
-                if (exact) {
-                    return;
+                if (!parseEnchantmentInstancePredicate()) {
+                    break;
                 }
             }
         }
@@ -188,46 +204,64 @@ private Item parseItem() throws CommandSyntaxException {
             return item;
         }
 
-        private void parseInfoEnchantment() throws CommandSyntaxException {
+        private boolean parseEnchantmentInstancePredicate() throws CommandSyntaxException {
             ItemStack stack = new ItemStack(item);
 
-            Option option = parseWithWithoutExactly();
+            int start = reader.getCursor();
+            Option option = parseOption();
+            if (option == null) {
+                reader.setCursor(start);
+                return false;
+            }
+
             boolean suggest = reader.canRead();
-            parseSpace();
             if (option == Option.EXACT) {
                 exact = true;
-                return;
+                return true;
+            }
+            if (option == Option.ORDERED) {
+                ordered = true;
+                return true;
             }
+
+            if (exact || ordered) {
+                reader.setCursor(start);
+                return false;
+            }
+
+            parseSpace();
+
             Enchantment enchantment = parseEnchantment(suggest, option, stack);
             suggest = reader.canRead();
             parseSpace();
-            int level = parseEnchantmentLevel(suggest, option, stack, enchantment);
+            MinMaxBounds.Ints level = parseEnchantmentLevel(suggest, option, stack, enchantment);
 
             if (option == Option.WITH) {
-                with.add(new EnchantmentInstance(enchantment, level));
+                with.add(new EnchantmentInstancePredicate(enchantment, level));
             } else {
-                without.add(new EnchantmentInstance(enchantment, level));
+                without.add(new EnchantmentInstancePredicate(enchantment, level));
             }
+
+            return true;
         }
 
         private enum Option {
             WITH,
             WITHOUT,
-            EXACT
+            EXACT,
+            ORDERED,
         }
 
-        private Option parseWithWithoutExactly() throws CommandSyntaxException {
-            suggestWithWithoutExactly();
-            int start = reader.getCursor();
+        @Nullable
+        private Option parseOption() {
+            suggestOption();
             String option = reader.readUnquotedString();
             return switch (option) {
                 case "with" -> Option.WITH;
                 case "without" -> Option.WITHOUT;
-                case "exactly" -> Option.EXACT;
-                default -> {
-                    reader.setCursor(start);
-                    throw EXPECTED_WITH_WITHOUT_EXACTLY_EXCEPTION.createWithContext(reader);
-                }
+                case "exactly" -> exact ? null : Option.EXACT;
+                case "ordered" -> ordered ? null : Option.ORDERED;
+                default -> null;
             };
         }
 
@@ -239,24 +273,24 @@ private Enchantment parseEnchantment(boolean suggest, Option option, ItemStack s
                     continue;
                 }
                 if (option == Option.WITH) {
-                    for (EnchantmentInstance ench2 : with) {
+                    for (EnchantmentInstancePredicate ench2 : with) {
                         if (ench2.enchantment == ench || !ench2.enchantment.isCompatibleWith(ench)) {
                             continue nextEnchantment;
                         }
                     }
-                    for (EnchantmentInstance ench2 : without) {
-                        if (ench2.enchantment == ench && ench2.level == -1) {
+                    for (EnchantmentInstancePredicate ench2 : without) {
+                        if (ench2.enchantment == ench && ench2.level.isAny()) {
                             continue nextEnchantment;
                         }
                     }
                 } else {
-                    for (EnchantmentInstance ench2 : with) {
-                        if (ench2.enchantment == ench && ench2.level == -1) {
+                    for (EnchantmentInstancePredicate ench2 : with) {
+                        if (ench2.enchantment == ench && ench2.level.isAny()) {
                             continue nextEnchantment;
                         }
                     }
-                    for (EnchantmentInstance ench2 : without) {
-                        if (ench2.enchantment == ench && ench2.level == -1) {
+                    for (EnchantmentInstancePredicate ench2 : without) {
+                        if (ench2.enchantment == ench && ench2.level.isAny()) {
                             continue nextEnchantment;
                         }
                     }
@@ -287,7 +321,7 @@ private Enchantment parseEnchantment(boolean suggest, Option option, ItemStack s
             return enchantment;
         }
 
-        private int parseEnchantmentLevel(boolean suggest, Option option, ItemStack stack, Enchantment enchantment) throws CommandSyntaxException {
+        private MinMaxBounds.Ints parseEnchantmentLevel(boolean suggest, Option option, ItemStack stack, Enchantment enchantment) throws CommandSyntaxException {
             int maxLevel;
             if (constrainMaxLevel) {
                 int enchantability = stack.getItem().getEnchantmentValue();
@@ -309,19 +343,19 @@ private int parseEnchantmentLevel(boolean suggest, Option option, ItemStack stac
                 }
 
                 if (option == Option.WITH) {
-                    for (EnchantmentInstance ench : without) {
-                        if (ench.enchantment == enchantment && (level == -1 || level == ench.level)) {
+                    for (EnchantmentInstancePredicate ench : without) {
+                        if (ench.enchantment == enchantment && (level == -1 || ench.level.matches(level))) {
                             continue nextLevel;
                         }
                     }
                 } else {
-                    for (EnchantmentInstance ench : with) {
-                        if (ench.enchantment == enchantment && (level == -1 || level == ench.level)) {
+                    for (EnchantmentInstancePredicate ench : with) {
+                        if (ench.enchantment == enchantment && (level == -1 || ench.level.matches(level))) {
                             continue nextLevel;
                         }
                     }
-                    for (EnchantmentInstance ench : without) {
-                        if (ench.enchantment == enchantment && (level == -1 || level == ench.level)) {
+                    for (EnchantmentInstancePredicate ench : without) {
+                        if (ench.enchantment == enchantment && (level == -1 || ench.level.matches(level))) {
                             continue nextLevel;
                         }
                     }
@@ -352,15 +386,17 @@ private int parseEnchantmentLevel(boolean suggest, Option option, ItemStack stac
 
             if (reader.peek() == '*') {
                 reader.skip();
-                return -1;
+                return MinMaxBounds.Ints.ANY;
             }
 
-            int level = reader.readInt();
-            if (level == -1 || !allowedLevels.contains(level)) {
-                reader.setCursor(start);
-                throw CommandSyntaxException.BUILT_IN_EXCEPTIONS.readerInvalidInt().createWithContext(reader, level);
+            int levelStart = reader.getCursor();
+            MinMaxBounds.Ints result = MinMaxBounds.Ints.fromReader(reader);
+            if (allowedLevels.stream().noneMatch(result::matches)) {
+                int levelEnd = reader.getCursor();
+                reader.setCursor(levelStart);
+                throw CommandSyntaxException.BUILT_IN_EXCEPTIONS.readerInvalidInt().createWithContext(reader, reader.getString().substring(levelStart, levelEnd));
             }
-            return level;
+            return result;
         }
 
         private void parseSpace() throws CommandSyntaxException {
@@ -393,13 +429,30 @@ private void suggestEnchantableItem() {
             };
         }
 
-        private void suggestWithWithoutExactly() {
+        private void suggestOption() {
             int start = reader.getCursor();
             suggestor = suggestions -> {
                 SuggestionsBuilder builder = suggestions.createOffset(start);
-                SharedSuggestionProvider.suggest(new String[]{"with", "without", "exactly"}, builder);
+                List<String> validOptions = new ArrayList<>(4);
+                if (!exact && !ordered) {
+                    Collections.addAll(validOptions, "with", "without");
+                }
+                if (!exact) {
+                    validOptions.add("exactly");
+                }
+                if (!ordered) {
+                    validOptions.add("ordered");
+                }
+                SharedSuggestionProvider.suggest(validOptions, builder);
                 suggestions.add(builder);
             };
         }
     }
+
+    private record EnchantmentInstancePredicate(Enchantment enchantment, MinMaxBounds.Ints level) implements Predicate<EnchantmentInstance> {
+        @Override
+        public boolean test(EnchantmentInstance enchInstance) {
+            return enchantment == enchInstance.enchantment && level.matches(enchInstance.level);
+        }
+    }
 }

src/main/resources/assets/clientcommands/lang/de_de.json

@@ -57,7 +57,6 @@
   "commands.ccreativetab.saveFile.failed": "Konnte Kreativtab-Datei nicht speichern",
   "commands.ccreativetab.setStack.success": "Stapel in Kreativtab \"%s\" an Position %d erfolgreich auf %s geändert",
 
-  "commands.cenchant.expectedWithWithoutExactly": "Erwartet \"with\"/\"without\"/\"exactly\"",
   "commands.cenchant.failed": "Es ist unmöglich oder würde zu lange brauchen, diese Verzauberungen zu bekommen",
   "commands.cenchant.help.uncrackedPlayerSeed": "Hilfe: du hast den Spielerseed nicht vollständig geknackt",
   "commands.cenchant.incompatible": "Unvereinbare Verzauberungen",

src/main/resources/assets/clientcommands/lang/en_us.json

@@ -58,7 +58,6 @@
   "commands.ccreativetab.saveFile.failed": "Could not save creative tabs file",
   "commands.ccreativetab.setStack.success": "Successfully set the stack from \"%s\" at index %d to %s",
 
-  "commands.cenchant.expectedWithWithoutExactly": "Expected \"with\"/\"without\"/\"exactly\"",
   "commands.cenchant.failed": "It's impossible or would take too long to get those enchantments",
   "commands.cenchant.help.uncrackedPlayerSeed": "Help: you have not fully cracked the player seed",
   "commands.cenchant.incompatible": "Incompatible enchantments",

src/main/resources/assets/clientcommands/lang/id_id.json

@@ -57,7 +57,6 @@
   "commands.ccreativetab.saveFile.failed": "Tidak bisa menyimpan file kelompok benda",
   "commands.ccreativetab.setStack.success": "Berhasil setel tumpukan dari \"%s\" di indeks %d",
 
-  "commands.cenchant.expectedWithWithoutExactly": "Diharapkan \"with (dengan)\"/\"without (tanpa)\"/\"exactly (tepat)\"",
   "commands.cenchant.failed": "Tidak mungkin atau akan memakan waktu yang lama untuk mendapatkan pesona tersebut",
   "commands.cenchant.help.uncrackedPlayerSeed": "Bantuan: anda belum sepenuhnya memecahkan benih pemain",
   "commands.cenchant.incompatible": "Pesona tidak kompatibel",

src/main/resources/assets/clientcommands/lang/ja_jp.json

@@ -57,7 +57,6 @@
   "commands.ccreativetab.saveFile.failed": "アイテムグループファイルを保存できませんでした",
   "commands.ccreativetab.setStack.success": "\"%s\"からのスタックを索引%dに%sを保存するのに成功しました",
 
-  "commands.cenchant.expectedWithWithoutExactly": "\"with\"/\"without\"/\"exactly\"が予期されました",
   "commands.cenchant.failed": "それらのエンチャントを取得するのは不可能であるか、時間がかかりすぎます",
   "commands.cenchant.help.uncrackedPlayerSeed": "ヘルプ: プレイヤーのシードは完全にクラックされていません。",
   "commands.cenchant.incompatible": "競合するエンチャント",

src/main/resources/assets/clientcommands/lang/ru_ru.json

@@ -57,7 +57,6 @@
   "commands.ccreativetab.saveFile.failed": "Не удалось сохранить файл групп элементов",
   "commands.ccreativetab.setStack.success": "Успешно установил стак из \"%s\" с индексом %d в %s",
 
-  "commands.cenchant.expectedWithWithoutExactly": "Ожидал \"with\"/\"without\"/\"exactly\"",
   "commands.cenchant.failed": "Невозможно или это займет слишком много времени, чтобы получить эти чары",
   "commands.cenchant.incompatible": "Несовместимые чары",
   "commands.cenchant.needEnchantingPrediction": "Эта команда требует, чтобы предсказание зачарования было включено.",

src/main/resources/assets/clientcommands/lang/zh_cn.json

@@ -57,7 +57,6 @@
   "commands.ccreativetab.saveFile.failed": "无法保存创造模式物品栏文件",
   "commands.ccreativetab.setStack.success": "成功将“%s”中第%d个物品设为%s",
 
-  "commands.cenchant.expectedWithWithoutExactly": "有效参数：“with”“without”“exactly”",
   "commands.cenchant.failed": "你请求的附魔无法获得或者需要太长时间",
   "commands.cenchant.help.uncrackedPlayerSeed": "提示：你还没有完全破解玩家种子",
   "commands.cenchant.incompatible": "互斥的附魔",