feat: entity editing

.run/DevServer.run.xml

@@ -1,15 +1,15 @@
 <component name="ProjectRunConfigurationManager">
-    <configuration default="false" name="DevServer" type="Application" factoryName="Application">
-        <option name="ALTERNATIVE_JRE_PATH" value="jbr-25"/>
-        <option name="ALTERNATIVE_JRE_PATH_ENABLED" value="true"/>
-        <envs>
-            <env name="MAPMAKER_RESOURCE_PACK_HASH" value="dev"/>
-        </envs>
-        <option name="MAIN_CLASS_NAME" value="net.hollowcube.mapmaker.dev.DevMain"/>
-        <module name="mapmaker.bin.development.main"/>
-        <option name="VM_PARAMETERS" value="--enable-native-access=ALL-UNNAMED -XX:+AllowEnhancedClassRedefinition"/>
-        <method v="2">
-            <option name="Make" enabled="true"/>
-        </method>
-    </configuration>
+  <configuration default="false" name="DevServer" type="Application" factoryName="Application">
+    <option name="ALTERNATIVE_JRE_PATH" value="25" />
+    <option name="ALTERNATIVE_JRE_PATH_ENABLED" value="true" />
+    <envs>
+      <env name="MAPMAKER_RESOURCE_PACK_HASH" value="dev" />
+    </envs>
+    <option name="MAIN_CLASS_NAME" value="net.hollowcube.mapmaker.dev.DevMain" />
+    <module name="mapmaker.bin.development.main" />
+    <option name="VM_PARAMETERS" value="--enable-native-access=ALL-UNNAMED" />
+    <method v="2">
+      <option name="Make" enabled="true" />
+    </method>
+  </configuration>
 </component>

bin/map/src/main/java/net/hollowcube/mapmaker/map/MapMapServer.java

@@ -165,6 +165,7 @@ public static void registerCommands(@NotNull AbstractMapServer server, @NotNull
         commandManager.register(new AddMarkerCommand());
         commandManager.register(new AddInteractionCommand());
         commandManager.register(new EntitiesCommand());
+        commandManager.register(new SummonCommand());
 
         // Need to update the condition of some commands to allow during build mode.
         var fly = commandManager.xpath("fly");

gradle/libs.versions.toml

@@ -4,7 +4,7 @@ annotations = "26.1.0"
 fastutil = "8.5.15"
 gson = "2.12.1"
 adventure = "4.25.0"
-minestom = "2026.01.01-1.21.11"
+minestom = "2026.03.25-1.21.11"
 posthog = "0.1.12"
 slf4j = "2.0.9"
 junit = "6.1.0-M1"

modules/command/src/main/java/net/hollowcube/command/arg/Argument.java

@@ -67,6 +67,10 @@ public static <E extends Enum<?>> ArgumentEnum<E> Enum(@NotNull String id, Class
         return new ArgumentBlock(id);
     }
 
+    public static @NotNull ArgumentCompoundTag CompoundTag(@NotNull String id) {
+        return new ArgumentCompoundTag(id);
+    }
+
     // Impl
 
     private final String id;

modules/command/src/main/java/net/hollowcube/command/arg/ArgumentCompoundTag.java

@@ -0,0 +1,54 @@
+package net.hollowcube.command.arg;
+
+import net.hollowcube.command.util.StringReader;
+import net.hollowcube.common.parsing.ParsingException;
+import net.hollowcube.common.parsing.snbt.Snbt;
+import net.hollowcube.common.parsing.snbt.SnbtReader;
+import net.kyori.adventure.nbt.CompoundBinaryTag;
+import net.minestom.server.command.ArgumentParserType;
+import net.minestom.server.command.CommandSender;
+import net.minestom.server.network.NetworkBuffer;
+import org.jetbrains.annotations.NotNull;
+
+public class ArgumentCompoundTag extends Argument<CompoundBinaryTag> {
+
+    private static final int COMMAND_SNBT_MAX_DEPTH = 16;
+
+    ArgumentCompoundTag(@NotNull String id) {
+        super(id);
+    }
+
+    @Override
+    public @NotNull ParseResult<CompoundBinaryTag> parse(@NotNull CommandSender sender, @NotNull StringReader reader) {
+        var remainingText = reader.raw().substring(reader.pos());
+        var snbtReader = new SnbtReader(remainingText, COMMAND_SNBT_MAX_DEPTH);
+        try {
+            var tag = Snbt.parse(snbtReader);
+            if (!(tag instanceof CompoundBinaryTag compoundTag)) {
+                return new ParseResult.Failure<>(reader.pos(), "Expected a compound tag");
+            }
+            return new ParseResult.Success<>(compoundTag);
+        } catch (ParsingException exception) {
+            return new ParseResult.Failure<>(
+                reader.pos() + exception.cursor(),
+                "Failed to parse tag, " + exception.getMessage()
+            );
+        } finally {
+            reader.restore(reader.pos() + snbtReader.cursor());
+        }
+    }
+
+    @Override
+    public @NotNull ArgumentParserType argumentType() {
+        return ArgumentParserType.NBT_COMPOUND_TAG;
+    }
+
+    @Override
+    public void properties(@NotNull NetworkBuffer buffer) {
+    }
+
+    @Override
+    public boolean shouldSuggest() {
+        return false;
+    }
+}

modules/common/src/main/java/net/hollowcube/common/dialogs/DialogBuilder.java

@@ -5,11 +5,13 @@
 import net.kyori.adventure.nbt.CompoundBinaryTag;
 import net.kyori.adventure.text.Component;
 import net.minestom.server.dialog.Dialog;
+import net.minestom.server.dialog.DialogActionButton;
 import net.minestom.server.dialog.DialogAfterAction;
 import net.minestom.server.dialog.DialogMetadata;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
+import java.util.List;
 import java.util.function.Consumer;
 
 public class DialogBuilder {
@@ -55,16 +57,16 @@ private DialogMetadata metadata(@NotNull DialogAfterAction action) {
     public Dialog buildSaveConfirmation(@NotNull Key key, @Nullable CompoundBinaryTag extra) {
         return new Dialog.Confirmation(
             this.metadata(DialogAfterAction.NONE),
-            DialogButtons.close(Component.translatable("dialog.generic.close"), 150),
-            DialogButtons.button(Component.translatable("dialog.generic.save"), 150, key, extra)
+            DialogButtons.button(Component.translatable("dialog.generic.save"), 150, key, extra),
+            DialogButtons.close(Component.translatable("dialog.generic.close"), 150)
         );
     }
 
     public Dialog buildSubmitConfirmation(@NotNull Key key, @Nullable CompoundBinaryTag extra) {
         return new Dialog.Confirmation(
             this.metadata(DialogAfterAction.CLOSE),
-            DialogButtons.close(Component.translatable("dialog.generic.close"), 150),
-            DialogButtons.button(Component.translatable("dialog.generic.submit"), 150, key, extra)
+            DialogButtons.button(Component.translatable("dialog.generic.submit"), 150, key, extra),
+            DialogButtons.close(Component.translatable("dialog.generic.close"), 150)
         );
     }
 
@@ -74,4 +76,13 @@ public Dialog buildNotice(@NotNull Key key, @Nullable CompoundBinaryTag extra) {
             DialogButtons.button(Component.translatable("dialog.generic.close"), 150, key, extra)
         );
     }
+
+    public Dialog buildActions(List<DialogActionButton> buttons, int columns) {
+        return new Dialog.MultiAction(
+            this.metadata(DialogAfterAction.CLOSE),
+            buttons,
+            DialogButtons.close(Component.translatable("dialog.generic.close"), 150),
+            columns
+        );
+    }
 }

modules/common/src/main/java/net/hollowcube/common/parsing/ParsingException.java

@@ -0,0 +1,15 @@
+package net.hollowcube.common.parsing;
+
+public final class ParsingException extends RuntimeException {
+
+    private final int cursor;
+
+    public ParsingException(int cursor, String message) {
+        super(message);
+        this.cursor = cursor;
+    }
+
+    public int cursor() {
+        return cursor;
+    }
+}

modules/common/src/main/java/net/hollowcube/common/parsing/snbt/Snbt.java

@@ -0,0 +1,34 @@
+package net.hollowcube.common.parsing.snbt;
+
+import net.hollowcube.common.parsing.ParsingException;
+import net.kyori.adventure.nbt.BinaryTag;
+
+public class Snbt {
+
+    private static final int DEFAULT_MAX_DEPTH = 64;
+
+    public static BinaryTag parse(String input) throws ParsingException {
+        return parse(new SnbtReader(input, DEFAULT_MAX_DEPTH));
+    }
+
+    public static BinaryTag parse(SnbtReader reader) throws ParsingException {
+        return switch (reader.peek()) {
+            case '{' -> SnbtObject.parseObject(reader);
+            case '[' -> SnbtArray.parseArray(reader);
+            case 't', 'T', 'f', 'F' -> SnbtMisc.parseBoolean(reader);
+            case '\"', '\'' -> SnbtString.parse(reader);
+            case '-', '+', '.', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' -> SnbtNumber.parse(reader);
+            default -> {
+                if (SnbtString.ALPHA_PREDICATE.test(reader.peek())) {
+                    var string = SnbtString.parseUnquoted(reader);
+                    var operation = SnbtMisc.parseOperation(reader, string.value());
+                    if (operation != null) {
+                        yield operation;
+                    }
+                    yield string;
+                }
+                throw new ParsingException(reader.cursor(), "Unexpected character: '" + reader.peek() + "'");
+            }
+        };
+    }
+}

modules/common/src/main/java/net/hollowcube/common/parsing/snbt/SnbtArray.java

@@ -0,0 +1,79 @@
+package net.hollowcube.common.parsing.snbt;
+
+import it.unimi.dsi.fastutil.bytes.ByteArrayList;
+import it.unimi.dsi.fastutil.ints.IntArrayList;
+import it.unimi.dsi.fastutil.longs.LongArrayList;
+import net.hollowcube.common.parsing.ParsingException;
+import net.kyori.adventure.nbt.*;
+
+import java.util.function.Function;
+
+public class SnbtArray {
+
+    static BinaryTag parseArray(SnbtReader reader) throws ParsingException {
+        try (var _ = reader.scope()) {
+            reader.require('[');
+            reader.read(SnbtMisc.WHITESPACE_PREDICATE);
+            var type = getArrayType(reader);
+            if (type == '\0') {
+                var output = ListBinaryTag.builder();
+                parseArray(reader, () -> output.add(Snbt.parse(reader)));
+                return output.build();
+            } else if (type == 'B' || type == 'b') {
+                var output = new ByteArrayList();
+                parseArray(reader, () -> output.add(SnbtMisc.parseBooleanOrByte(reader).value()));
+                return ByteArrayBinaryTag.byteArrayBinaryTag(output.toByteArray());
+            } else if (type == 'I' || type == 'i') {
+                var output = new IntArrayList();
+                parseArray(reader, () -> output.add(expect(reader, SnbtNumber::parse, IntBinaryTag.class).value()));
+                return IntArrayBinaryTag.intArrayBinaryTag(output.toIntArray());
+            } else if (type == 'L' || type == 'l') {
+                var output = new LongArrayList();
+                parseArray(reader, () -> output.add(expect(reader, SnbtNumber::parse, LongBinaryTag.class).value()));
+                return LongArrayBinaryTag.longArrayBinaryTag(output.toLongArray());
+            }
+            throw new ParsingException(reader.cursor(), "Expected array type but got '" + type + "'");
+        }
+    }
+
+    private static char getArrayType(SnbtReader reader) throws ParsingException {
+        var type = reader.peek();
+        var offset = 0;
+        while (SnbtMisc.WHITESPACE_PREDICATE.test(reader.peek(offset))) {
+            offset++;
+        }
+        if (reader.peek(offset) == ';') {
+            reader.read(offset);
+            reader.require(';');
+            return type;
+        }
+        return '\0';
+    }
+
+    private static <T extends BinaryTag> T expect(SnbtReader reader, Function<SnbtReader, BinaryTag> parser, Class<T> expected) {
+        var tag = parser.apply(reader);
+        if (expected.isInstance(tag)) {
+            return expected.cast(tag);
+        } else {
+            throw new ParsingException(reader.cursor(), "Expected " + expected.getSimpleName() + " but got " + tag.getClass().getSimpleName());
+        }
+    }
+
+    private static void parseArray(SnbtReader reader, Runnable elementReader) throws ParsingException {
+        reader.read(SnbtMisc.WHITESPACE_PREDICATE);
+
+        while (reader.peek() != ']') {
+            elementReader.run();
+            reader.read(SnbtMisc.WHITESPACE_PREDICATE);
+            if (reader.peek() == ',') {
+                reader.read();
+                reader.read(SnbtMisc.WHITESPACE_PREDICATE);
+            } else if (reader.peek() == ']') {
+                break;
+            } else {
+                throw new ParsingException(reader.cursor(), "Expected ',' or ']' but got '" + reader.peek() + "'");
+            }
+        }
+        reader.require(']');
+    }
+}

modules/common/src/main/java/net/hollowcube/common/parsing/snbt/SnbtMisc.java

@@ -0,0 +1,70 @@
+package net.hollowcube.common.parsing.snbt;
+
+import it.unimi.dsi.fastutil.chars.CharPredicate;
+import net.hollowcube.common.parsing.ParsingException;
+import net.kyori.adventure.nbt.BinaryTag;
+import net.kyori.adventure.nbt.ByteBinaryTag;
+import net.kyori.adventure.nbt.IntArrayBinaryTag;
+
+import java.util.UUID;
+
+public class SnbtMisc {
+
+    static final CharPredicate WHITESPACE_PREDICATE = Character::isWhitespace;
+
+    static ByteBinaryTag parseBoolean(SnbtReader reader) throws ParsingException {
+        return switch (reader.peek()) {
+            case 't', 'T' -> {
+                reader.require("true");
+                yield ByteBinaryTag.byteBinaryTag((byte) 1);
+            }
+            case 'f', 'F' -> {
+                reader.require("false");
+                yield ByteBinaryTag.byteBinaryTag((byte) 0);
+            }
+            default -> throw new ParsingException(reader.cursor(), "Expected 'true' or 'false'");
+        };
+    }
+
+    static ByteBinaryTag parseBooleanOrByte(SnbtReader reader) throws ParsingException {
+        if (reader.peek() == 't' || reader.peek() == 'T' || reader.peek() == 'f' || reader.peek() == 'F') {
+            return SnbtMisc.parseBoolean(reader);
+        } else if (SnbtNumber.parse(reader) instanceof ByteBinaryTag tag) {
+            return tag;
+        } else {
+            throw new ParsingException(reader.cursor(), "Expected boolean or byte value");
+        }
+    }
+
+    static BinaryTag parseOperation(SnbtReader reader, String name) throws ParsingException {
+        return switch (name) {
+            case "uuid" -> {
+                try {
+                    reader.read(WHITESPACE_PREDICATE);
+                    reader.require('(');
+                    var uuid = UUID.fromString(SnbtString.parseUnquoted(reader).value());
+                    reader.read(WHITESPACE_PREDICATE);
+                    reader.require(')');
+
+                    yield IntArrayBinaryTag.intArrayBinaryTag(
+                        (int) (uuid.getMostSignificantBits() >> 32),
+                        (int) uuid.getMostSignificantBits(),
+                        (int) (uuid.getLeastSignificantBits() >> 32),
+                        (int) uuid.getLeastSignificantBits()
+                    );
+                } catch (IllegalArgumentException e) {
+                    throw new ParsingException(reader.cursor(), "Invalid UUID format");
+                }
+            }
+            case "bool" -> {
+                reader.read(WHITESPACE_PREDICATE);
+                reader.require('(');
+                var value = parseBooleanOrByte(reader);
+                reader.read(WHITESPACE_PREDICATE);
+                reader.require(')');
+                yield ByteBinaryTag.byteBinaryTag(value.value() != 0 ? (byte) 1 : (byte) 0);
+            }
+            default -> null;
+        };
+    }
+}