Rework demobox creation workflow

Author: MattiDragon

README.md

@@ -7,11 +7,29 @@ allowing users to experience mods in survival mode without risking them breaking
 To create a demo using demobox, first build a structure and store it with a structure block. 
 This structure will spawn in your demo worlds centered at 0, 0.
 
-Then you can run the `/demobox open <structure>` command to visit a demo world. 
+As of 26.1, demos are first created using the `/demo create` command. This command opens a dialog letting your configure the demo.
+You can then use `/demo open` to open it, or `/demo edit` to modify it. 
+
+Editing demos requires the `demobox.edit` command. This should not be given to untrusted players,
+as it permits them to run arbitrary commands with gamemaster permissions. Opening demos requires the `demobox.open` permission.
+This one can generally be given to untrusted players unless you want to keep some demos inaccessible.
+
+Demos can also be attached to signs using the `/demobox sign` command. It overwrites the content the targeted sign with a link to the demo.
+Using the command requires the `demobox.sign` permission, but interacting with the sign itself doesn't require anything.
+
+All commands except `/demobox leave` default to gamemaster/level 2 permissions unless their specific nodes are set.
+
+<details>
+<summary>Pre 26.1 instructions</summary>
+
+Then you can run the `/demobox open <structure>` command to visit a demo world.
 You can leave using the `/demobox leave` command or by using the `/game` command from plasmid.
 
 The open command requires a permission level of 2 or the `demobox.open` permission node
-because it can be used to create dimensions with arbitrary structures and that could cause problems. 
+because it can be used to create dimensions with arbitrary structures and that could cause problems.
 The recommended way to give players access to demos is by using signs with click events.
 
 The open command also accepts a position for where players spawn and a function to run during setup if you need to do something more advanced.
+
+</details>
+

src/main/java/io/github/mattidragon/demobox/DemoBoxClickActions.java

@@ -0,0 +1,7 @@
+package io.github.mattidragon.demobox;
+
+import net.minecraft.resources.Identifier;
+
+public class DemoBoxClickActions {
+	public static final Identifier CREATE_UPDATE_DEMO = DemoBox.id("create_update_demo");
+}

src/main/java/io/github/mattidragon/demobox/DemoBoxCommand.java

@@ -0,0 +1,43 @@
+package io.github.mattidragon.demobox;
+
+import com.mojang.serialization.Codec;
+import net.minecraft.resources.Identifier;
+import net.minecraft.util.Util;
+import net.minecraft.world.level.saveddata.SavedData;
+import net.minecraft.world.level.saveddata.SavedDataType;
+import org.jspecify.annotations.Nullable;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+
+public class DemoBoxConfigs extends SavedData {
+	private static final Codec<Map<Identifier, DemoConfig>> DATA_CODEC = Codec.unboundedMap(Identifier.CODEC, DemoConfig.CODEC.codec());
+	public static final Codec<DemoBoxConfigs> CODEC = DATA_CODEC.xmap(
+		data -> Util.make(new DemoBoxConfigs(), obj -> obj.configs.putAll(data)),
+		DemoBoxConfigs::getConfigs
+	);
+	@SuppressWarnings("DataFlowIssue") // Fabric patches this to accept null
+	public static final SavedDataType<DemoBoxConfigs> TYPE = new SavedDataType<>(DemoBox.id("configs"), DemoBoxConfigs::new, CODEC, null);
+
+	private final Map<Identifier, DemoConfig> configs = new HashMap<>();
+
+	public void createOrUpdateConfig(Identifier id, DemoConfig config) {
+		configs.put(id, config);
+		setDirty();
+	}
+
+	public boolean removeConfig(Identifier id) {
+		var old = configs.remove(id);
+		setDirty();
+		return old != null;
+	}
+
+	public @Nullable DemoConfig getConfig(Identifier id) {
+		return configs.get(id);
+	}
+
+	public Map<Identifier, DemoConfig> getConfigs() {
+		return Collections.unmodifiableMap(configs);
+	}
+}

src/main/java/io/github/mattidragon/demobox/DemoBoxConfigs.java

@@ -1,15 +1,13 @@
 package io.github.mattidragon.demobox;
 
-import com.mojang.serialization.MapCodec;
-import com.mojang.serialization.codecs.RecordCodecBuilder;
 import net.minecraft.ChatFormatting;
 import net.minecraft.commands.CommandSourceStack;
+import net.minecraft.commands.functions.CommandFunction;
 import net.minecraft.core.BlockPos;
 import net.minecraft.core.Holder;
 import net.minecraft.core.HolderSet;
 import net.minecraft.core.RegistryAccess;
 import net.minecraft.network.chat.Component;
-import net.minecraft.resources.Identifier;
 import net.minecraft.server.level.ServerLevel;
 import net.minecraft.server.level.ServerPlayer;
 import net.minecraft.server.permissions.LevelBasedPermissionSet;
@@ -43,27 +41,27 @@
 import java.util.concurrent.CompletableFuture;
 
 public class DemoBoxGame {
-	public static final GameType<Settings> TYPE = GameTypes.register(DemoBox.id("demo_box"), Settings.CODEC, DemoBoxGame::open);
+	public static final GameType<DemoConfig> TYPE = GameTypes.register(DemoBox.id("demo_box"), DemoConfig.CODEC, DemoBoxGame::open);
 
 	private final ServerLevel world;
 	private final GameSpace gameSpace;
-	private final Settings settings;
+	private final DemoConfig config;
 
-	public DemoBoxGame(ServerLevel world, GameSpace gameSpace, Settings settings) {
+	public DemoBoxGame(ServerLevel world, GameSpace gameSpace, DemoConfig config) {
 		this.world = world;
 		this.gameSpace = gameSpace;
-		this.settings = settings;
+		this.config = config;
 	}
 
 	public static void register() {
 	}
 
-	public static CompletableFuture<GameSpace> open(Settings settings) {
-		var config = new GameConfig<>(TYPE, null, null, null, null, CustomValuesConfig.empty(), settings);
+	public static CompletableFuture<GameSpace> open(DemoConfig demoConfig) {
+		var config = new GameConfig<>(TYPE, null, null, null, null, CustomValuesConfig.empty(), demoConfig);
 		return GameSpaceManager.get().open(Holder.direct(config));
 	}
 
-	private static GameOpenProcedure open(GameOpenContext<Settings> context) {
+	private static GameOpenProcedure open(GameOpenContext<DemoConfig> context) {
 		return context.openWithLevel(createLevelConfig(context.server().registryAccess()), (activity, world) -> {
 			var instance = new DemoBoxGame(world, activity.getGameSpace(), context.config());
 			instance.setup();
@@ -83,17 +81,17 @@ private static GameOpenProcedure open(GameOpenContext<Settings> context) {
 
 	private void setup() {
 		world.getStructureManager()
-			.get(settings.structureId)
+			.get(config.structure())
 			.ifPresent(template -> {
 				var size = template.getSize();
 				var pos = new BlockPos(size.getX() / -2, 1, size.getZ() / -2);
 				template.placeInWorld(world, pos, pos, new StructurePlaceSettings(), world.getRandom(), 0);
 			});
-		executeFunctions(settings.functions, null);
+		executeCommands(config.setupCommands(), null);
 	}
 
 	private void onPlayerLeave(ServerPlayer player) {
-		if (gameSpace.getPlayers().stream().allMatch(player2 -> player2 != player)) {
+		if (gameSpace.getPlayers().stream().allMatch(player2 -> player2 == player)) {
 			gameSpace.close(GameCloseReason.FINISHED);
 		}
 	}
@@ -103,7 +101,7 @@ private void onPlayerJoin(ServerPlayer player) {
 		player.sendSystemMessage(Component.translatable("demobox.info.2").withStyle(ChatFormatting.WHITE));
 		player.sendSystemMessage(Component.translatable("demobox.info.3").withStyle(ChatFormatting.WHITE));
 		player.sendSystemMessage(Component.translatable("demobox.info.4").withStyle(ChatFormatting.WHITE));
-		executeFunctions(settings.playerFunctions, player);
+		executeCommands(config.joinCommands(), player);
 	}
 
 	private Component onJoinMessage(ServerPlayer player, @Nullable Component currentText, Component defaultText) {
@@ -119,21 +117,16 @@ private JoinOfferResult onPlayerOffered(JoinOffer offer) {
 	}
 
 	private JoinAcceptorResult onPlayerAccepted(JoinAcceptor joinAcceptor) {
-		return joinAcceptor.teleport(world, settings.playerPos);
+		return joinAcceptor.teleport(world, config.spawnPos());
 	}
 
-	private void executeFunctions(List<Identifier> functions, Entity entity) {
+	private void executeCommands(String commands, Entity entity) {
 		var server = world.getServer();
-		var manager = server.getFunctions();
-		for (var id : functions) {
-			manager.get(id).ifPresentOrElse(
-				function -> manager.execute(
-					function,
-					new CommandSourceStack(server, Vec3.ZERO, Vec2.ZERO, world, LevelBasedPermissionSet.GAMEMASTER, "DemoBox Setup", Component.literal("DemoBox Setup"), server, entity).withSuppressedOutput()
-				),
-				() -> DemoBox.LOGGER.warn("Missing function: {}", id)
-			);
-		}
+		var source = new CommandSourceStack(server, Vec3.ZERO, Vec2.ZERO, world, LevelBasedPermissionSet.GAMEMASTER, "DemoBox Setup", Component.literal("DemoBox Setup"), server, entity).withSuppressedOutput();
+		var dispatcher = source.dispatcher();
+
+		var function = CommandFunction.fromLines(DemoBox.id("/virtual_setup_function"), dispatcher, source, commands.lines().toList());
+		server.getFunctions().execute(function, source);
 	}
 
 	@NotNull
@@ -152,14 +145,4 @@ private static RuntimeLevelConfig createLevelConfig(RegistryAccess registryManag
 		worldConfig.setSeed(1);
 		return worldConfig;
 	}
-
-	public record Settings(Identifier structureId, Vec3 playerPos, List<Identifier> functions,
-	                       List<Identifier> playerFunctions) {
-		public static final MapCodec<Settings> CODEC = RecordCodecBuilder.mapCodec(instance -> instance.group(
-			Identifier.CODEC.fieldOf("structureId").forGetter(Settings::structureId),
-			Vec3.CODEC.fieldOf("playerPos").forGetter(Settings::playerPos),
-			Identifier.CODEC.listOf().fieldOf("functions").forGetter(Settings::functions),
-			Identifier.CODEC.listOf().fieldOf("playerFunctions").forGetter(Settings::playerFunctions)
-		).apply(instance, Settings::new));
-	}
 }

src/main/java/io/github/mattidragon/demobox/DemoBoxGame.java

@@ -0,0 +1,48 @@
+package io.github.mattidragon.demobox;
+
+import com.mojang.brigadier.StringReader;
+import com.mojang.brigadier.exceptions.CommandSyntaxException;
+import com.mojang.serialization.Codec;
+import com.mojang.serialization.DataResult;
+import com.mojang.serialization.MapCodec;
+import com.mojang.serialization.codecs.RecordCodecBuilder;
+import net.minecraft.commands.arguments.coordinates.WorldCoordinates;
+import net.minecraft.resources.Identifier;
+import net.minecraft.world.phys.Vec3;
+
+public record DemoConfig(Identifier structure, Vec3 spawnPos, String setupCommands, String joinCommands) {
+	public static final MapCodec<DemoConfig> CODEC = RecordCodecBuilder.mapCodec(i -> i.group(
+		Identifier.CODEC.fieldOf("structure").forGetter(DemoConfig::structure),
+		Vec3.CODEC.fieldOf("spawn_pos").forGetter(DemoConfig::spawnPos),
+		Codec.STRING.fieldOf("setup_commands").forGetter(DemoConfig::setupCommands),
+		Codec.STRING.fieldOf("join_commands").forGetter(DemoConfig::joinCommands)
+	).apply(i, DemoConfig::new));
+
+	private static final Codec<Vec3> VEC3_STRING_CODEC = Codec.STRING.comapFlatMap(s -> {
+		var reader = new StringReader(s);
+		WorldCoordinates worldCoordinates;
+		try {
+			worldCoordinates = WorldCoordinates.parseDouble(reader, true);
+		} catch (CommandSyntaxException e) {
+			return DataResult.error(() -> "Failed to decode coordinates: " + e.getMessage());
+		}
+		while (reader.canRead()) {
+			if (reader.read() != ' ') {
+				return DataResult.error(() -> "Unexpected character while parsing coordinates: '" + (char) reader.getCursor() + "'");
+			}
+		}
+
+		return DataResult.success(new Vec3(
+			worldCoordinates.x().get(0.5),
+			worldCoordinates.y().get(2),
+			worldCoordinates.z().get(0.5)
+		));
+	}, vec -> "%s %s %s".formatted(vec.x, vec.y, vec.z));
+
+	public static final Codec<DemoConfig> DIALOG_CODEC = RecordCodecBuilder.create(i -> i.group(
+		Identifier.CODEC.fieldOf("structure").forGetter(DemoConfig::structure),
+		VEC3_STRING_CODEC.fieldOf("spawn_pos").forGetter(DemoConfig::spawnPos),
+		Codec.STRING.fieldOf("setup_commands").forGetter(DemoConfig::setupCommands),
+		Codec.STRING.fieldOf("join_commands").forGetter(DemoConfig::joinCommands)
+	).apply(i, DemoConfig::new));
+}

src/main/java/io/github/mattidragon/demobox/DemoConfig.java

@@ -0,0 +1,73 @@
+package io.github.mattidragon.demobox.mixin;
+
+import com.mojang.datafixers.util.Pair;
+import com.mojang.serialization.DataResult;
+import io.github.mattidragon.demobox.DemoBox;
+import io.github.mattidragon.demobox.DemoBoxClickActions;
+import io.github.mattidragon.demobox.DemoBoxConfigs;
+import io.github.mattidragon.demobox.DemoConfig;
+import net.minecraft.core.UUIDUtil;
+import net.minecraft.nbt.NbtOps;
+import net.minecraft.nbt.Tag;
+import net.minecraft.network.chat.Component;
+import net.minecraft.resources.Identifier;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.server.players.PlayerList;
+import net.minecraft.world.level.storage.SavedDataStorage;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.Unique;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+import java.util.Optional;
+import java.util.UUID;
+
+@Mixin(MinecraftServer.class)
+public abstract class MinecraftServerMixin {
+	@Shadow
+	public abstract SavedDataStorage getDataStorage();
+
+	@Shadow
+	public abstract PlayerList getPlayerList();
+
+	@Inject(method = "handleCustomClickAction", at = @At("HEAD"))
+	private void onHandleCustomClickAction(Identifier id, Optional<Tag> payload, CallbackInfo ci) {
+		if (id.equals(DemoBoxClickActions.CREATE_UPDATE_DEMO)) {
+			handleCreateUpdate(payload);
+		}
+	}
+
+	@Unique
+	private void handleCreateUpdate(Optional<Tag> payload) {
+		if (payload.isEmpty()) {
+			DemoBox.LOGGER.error("Received create/update demo click action with no payload");
+			return;
+		}
+		var tag = payload.get();
+		var ops = NbtOps.INSTANCE;
+
+		var playerResult = UUIDUtil.CODEC.fieldOf("player").codec().decode(ops, tag).map(Pair::getFirst);
+		var idResult = Identifier.CODEC.fieldOf("id").codec().decode(ops, tag).map(Pair::getFirst);
+		var configResult = DemoConfig.DIALOG_CODEC.decode(ops, tag).map(Pair::getFirst);
+
+		if (playerResult instanceof DataResult.Error<UUID> error) {
+			DemoBox.LOGGER.error("Failed to decode player UUID from click action payload: {}", error.message());
+			return;
+		}
+		if (idResult instanceof DataResult.Error<Identifier> error) {
+			DemoBox.LOGGER.error("Failed to decode demo config ID from click action payload: {}", error.message());
+			return;
+		}
+		if (configResult instanceof DataResult.Error<DemoConfig> error) {
+			DemoBox.LOGGER.error("Failed to decode demo config from click action payload: {}", error.message());
+			playerResult.result().map(getPlayerList()::getPlayer)
+				.ifPresent(player -> player.sendSystemMessage(Component.translatable("demobox.config.invalid", error.message())));
+			return;
+		}
+
+		getDataStorage().computeIfAbsent(DemoBoxConfigs.TYPE)
+			.createOrUpdateConfig(idResult.getOrThrow(), configResult.getOrThrow());
+	}
+}