Fixes

# Conflicts:
#	gradle.properties

build.gradle

@@ -1,5 +1,5 @@
 plugins {
-    id 'fabric-loom' version '1.8-SNAPSHOT'
+    id 'fabric-loom' version '1.10-SNAPSHOT'
     id 'maven-publish'
 }
 
@@ -14,6 +14,10 @@ base {
     archivesName = project.archives_base_name
 }
 
+loom {
+    accessWidenerPath = file("src/main/resources/minions.accesswidener")
+}
+
 repositories {
     // Add repositories to retrieve artifacts from in here.
     // You should only use this when depending on other mods because

gradle.properties

@@ -3,21 +3,21 @@ org.gradle.jvmargs=-Xmx1G
 
 # Fabric Properties
 	# check these on https://modmuss50.me/fabric.html
-	minecraft_version=1.21.3
-	loader_version=0.16.13
-	yarn_mappings=1.21.3+build.2
+	minecraft_version=1.21.7
+	loader_version=0.16.14
+	yarn_mappings=1.21.7+build.2
 
 # Mod Properties
-	mod_version = 0.1.2-SNAPSHOT
+	mod_version = 0.2.1-SNAPSHOT
 	maven_group = io.github.skippyall
 	archives_base_name = Minions
 
 # Dependencies
 	# check this on https://modmuss50.me/fabric.html
-	fabric_version=0.107.0+1.21.3
+	fabric_version=0.128.1+1.21.7
 
-	polymer_version=0.10.0+1.21.2
-	sgui_version=1.7.1+1.21.2
-	server_translations_version=2.4.0+1.21.2-rc1
+	polymer_version=0.13.3+1.21.6
+	sgui_version=1.10.0+1.21.6
+	server_translations_version=2.5.1+1.21.5
 
-	universal_graves_version=3.5.0+1.21.2
+	universal_graves_version=3.8.0+1.21.6

gradle/wrapper/gradle-wrapper.properties

@@ -1 +1 @@
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.10-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.12-bin.zip

src/main/java/io/github/skippyall/minions/MinionCreativeTab.java

@@ -0,0 +1,35 @@
+package io.github.skippyall.minions;
+
+import eu.pb4.polymer.core.api.item.PolymerItemGroupUtils;
+import net.fabricmc.fabric.api.itemgroup.v1.FabricItemGroup;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemGroup;
+import net.minecraft.item.ItemStack;
+import net.minecraft.text.Text;
+import net.minecraft.util.Identifier;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class MinionCreativeTab {
+    public static ItemGroup group;
+
+    private static final List<ItemStack> items = new ArrayList<>();
+
+    public static void add(Item entry) {
+        items.add(entry.getDefaultStack());
+    }
+
+    public static void collectEntries(ItemGroup.DisplayContext displayContext, ItemGroup.Entries entries) {
+        entries.addAll(items);
+    }
+
+    public static void registerGroup() {
+        group = FabricItemGroup.builder()
+                .displayName(Text.translatable("minions.generic.mod_name"))
+                .icon(MinionItems.MINION_ITEM::getDefaultStack)
+                .entries(MinionCreativeTab::collectEntries)
+                .build();
+        PolymerItemGroupUtils.registerPolymerItemGroup(Identifier.of(Minions.MOD_ID, "main"), group);
+    }
+}

src/main/java/io/github/skippyall/minions/MinionItems.java

@@ -0,0 +1,44 @@
+package io.github.skippyall.minions;
+
+import eu.pb4.polymer.core.api.item.SimplePolymerItem;
+import io.github.skippyall.minions.minion.MinionItem;
+import io.github.skippyall.minions.module.Modules;
+import net.minecraft.component.DataComponentTypes;
+import net.minecraft.component.type.DamageResistantComponent;
+import net.minecraft.entity.damage.DamageType;
+import net.minecraft.item.Item;
+import net.minecraft.item.Items;
+import net.minecraft.registry.Registries;
+import net.minecraft.registry.Registry;
+import net.minecraft.registry.RegistryKey;
+import net.minecraft.registry.RegistryKeys;
+import net.minecraft.registry.tag.TagKey;
+import net.minecraft.util.Identifier;
+
+import java.util.function.Function;
+
+import static io.github.skippyall.minions.Minions.MOD_ID;
+
+public class MinionItems {
+    public static final TagKey<DamageType> MINION_ITEM_RESISTS = TagKey.of(RegistryKeys.DAMAGE_TYPE, Identifier.of(MOD_ID, "minion_item_resists"));
+    public static final MinionItem MINION_ITEM = registerItem(Identifier.of(MOD_ID, "minion"), settings -> new MinionItem(settings.component(DataComponentTypes.DAMAGE_RESISTANT, new DamageResistantComponent(MINION_ITEM_RESISTS))));
+    public static final SimplePolymerItem BASIC_UPGRADE_BASE = registerItem(Identifier.of(MOD_ID, "basic_upgrade_base"), settings -> new SimplePolymerItem(settings, Items.NETHERITE_UPGRADE_SMITHING_TEMPLATE));
+    public static final SimplePolymerItem ADVANCED_UPGRADE_BASE = registerItem(Identifier.of(MOD_ID, "advanced_upgrade_base"), settings -> new SimplePolymerItem(settings, Items.NETHERITE_UPGRADE_SMITHING_TEMPLATE));
+
+
+    public static <T extends Item> T registerItem(Identifier identifier, Function<Item.Settings, T> constructor, Item.Settings settings) {
+        T item = constructor.apply(settings.registryKey(RegistryKey.of(RegistryKeys.ITEM, identifier)));
+
+        MinionCreativeTab.add(item);
+
+        return Registry.register(Registries.ITEM, identifier, item);
+    }
+
+    public static <T extends Item> T registerItem(Identifier identifier, Function<Item.Settings, T> constructor) {
+        return registerItem(identifier, constructor, new Item.Settings());
+    }
+
+    public static void register() {
+        Modules.register();
+    }
+}

src/main/java/io/github/skippyall/minions/Minions.java

@@ -1,88 +1,40 @@
 package io.github.skippyall.minions;
 
 import eu.pb4.polymer.core.api.entity.PolymerEntityUtils;
-import eu.pb4.polymer.core.api.item.SimplePolymerItem;
+import io.github.skippyall.minions.command.MinionsCommand;
 import io.github.skippyall.minions.minion.fakeplayer.MinionFakePlayer;
 import io.github.skippyall.minions.minion.MinionData;
-import io.github.skippyall.minions.minion.MinionItem;
 import io.github.skippyall.minions.minion.MinionPersistentState;
-import io.github.skippyall.minions.module.Modules;
 import net.fabricmc.api.ModInitializer;
 import net.fabricmc.fabric.api.command.v2.CommandRegistrationCallback;
 import net.fabricmc.fabric.api.event.lifecycle.v1.ServerLifecycleEvents;
-import net.fabricmc.fabric.api.event.lifecycle.v1.ServerTickEvents;
-import net.minecraft.component.DataComponentTypes;
-import net.minecraft.component.type.DamageResistantComponent;
-import net.minecraft.entity.boss.WitherEntity;
-import net.minecraft.entity.damage.DamageType;
-import net.minecraft.item.Item;
-import net.minecraft.item.Items;
-import net.minecraft.registry.Registries;
-import net.minecraft.registry.Registry;
-import net.minecraft.registry.RegistryKey;
-import net.minecraft.registry.RegistryKeys;
-import net.minecraft.registry.tag.TagKey;
-import net.minecraft.server.world.ChunkTicketManager;
-import net.minecraft.util.Identifier;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import java.util.ArrayList;
-import java.util.List;
-import java.util.function.Function;
-
 public class Minions implements ModInitializer {
     public static final String MOD_ID = "minions";
-    public static final TagKey<DamageType> MINION_ITEM_RESISTS = TagKey.of(RegistryKeys.DAMAGE_TYPE, Identifier.of(MOD_ID, "minion_item_resists"));
-    public static final MinionItem MINION_ITEM = registerItem(Identifier.of(MOD_ID, "minion"), settings -> new MinionItem(settings.component(DataComponentTypes.DAMAGE_RESISTANT, new DamageResistantComponent(MINION_ITEM_RESISTS)),false));
-    public static final SimplePolymerItem BASIC_UPGRADE_BASE = registerItem(Identifier.of(MOD_ID, "basic_upgrade_base"), settings -> new SimplePolymerItem(settings, Items.NETHERITE_UPGRADE_SMITHING_TEMPLATE));
-    public static final SimplePolymerItem ADVANCED_UPGRADE_BASE = registerItem(Identifier.of(MOD_ID, "advanced_upgrade_base"), settings -> new SimplePolymerItem(settings, Items.NETHERITE_UPGRADE_SMITHING_TEMPLATE));
 
     public static final Logger LOGGER = LoggerFactory.getLogger(MOD_ID);
 
-    private static final List<Runnable> executeOnNextTick = new ArrayList<>();
-
     @Override
     public void onInitialize() {
         MinionData.register();
         PolymerEntityUtils.registerType();
         ServerLifecycleEvents.SERVER_STARTED.register(server -> {
+            LOGGER.error("Initializing Minion data");
             MinionPersistentState.create(server);
-            MinionPersistentState.INSTANCE.getMinionData().forEach(data -> {
-                MinionFakePlayer.spawnMinionAt(data, server.getOverworld(), null, null);
-            });
-        });
-        ServerTickEvents.START_SERVER_TICK.register(server -> {
-            exec(() -> {
-                for (Runnable run:executeOnNextTick) {
-                    run.run();
+            MinionPersistentState.INSTANCE.getMinionData().forEach((uuid, data) -> {
+                if(data.isSpawned()) {
+                    MinionFakePlayer.spawnMinion(data, server.getOverworld(), null, null, true);
                 }
-                executeOnNextTick.clear();
             });
         });
 
         CommandRegistrationCallback.EVENT.register((commandDispatcher, commandRegistryAccess, registrationEnvironment) -> {
-            MobCapCommand.registerCommand(commandDispatcher);
+            MinionsCommand.register(commandDispatcher);
         });
 
-        Modules.register();
-    }
-
-    private static <T extends Item> T registerItem(Identifier identifier, Function<Item.Settings, T> constructor, Item.Settings settings) {
-        return Registry.register(Registries.ITEM, identifier, constructor.apply(settings.registryKey(RegistryKey.of(RegistryKeys.ITEM, identifier))));
-    }
-
-    private static <T extends Item> T registerItem(Identifier identifier, Function<Item.Settings, T> constructor) {
-        return registerItem(identifier, constructor, new Item.Settings());
-    }
-
-    private static synchronized void exec(Runnable run) {
-        run.run();
-    }
-
-    public static void addExecuteOnNextTick(Runnable run) {
-        exec(() -> {
-            executeOnNextTick.add(run);
-        });
+        MinionItems.register();
+        MinionCreativeTab.registerGroup();
     }
 }

src/main/java/io/github/skippyall/minions/MobCapCommand.java

@@ -1,24 +0,0 @@
-package io.github.skippyall.minions;
-
-import com.mojang.brigadier.CommandDispatcher;
-import io.github.skippyall.minions.mixinhelper.ChunkTicketManager$DistanceFromNearestPlayerTrackerAccessor;
-import io.github.skippyall.minions.mixinhelper.ChunkTicketManagerAccessor;
-import io.github.skippyall.minions.mixins.antimobcap.ServerChunkManagerAccessor;
-import net.minecraft.server.command.ServerCommandSource;
-import net.minecraft.server.world.ChunkTicketManager;
-import net.minecraft.text.Text;
-
-import static net.minecraft.server.command.CommandManager.literal;
-
-public class MobCapCommand {
-    public static void registerCommand(CommandDispatcher<ServerCommandSource> dispatcher) {
-        dispatcher.register(literal("mobcapdebug")
-                .executes(context -> {
-                    ChunkTicketManager ticketManager = ((ServerChunkManagerAccessor)context.getSource().getWorld().getChunkManager()).getTicketManager();
-                    int tickedChunkCount = ((ChunkTicketManager$DistanceFromNearestPlayerTrackerAccessor)((ChunkTicketManagerAccessor)ticketManager).getMinionless()).minions$getTickedChunkCount();
-                    context.getSource().sendFeedback(() -> Text.of(String.valueOf(tickedChunkCount)), false);
-                    return 0;
-                })
-        );
-    }
-}

src/main/java/io/github/skippyall/minions/command/ListSubcommand.java

@@ -0,0 +1,25 @@
+package io.github.skippyall.minions.command;
+
+import com.mojang.brigadier.builder.LiteralArgumentBuilder;
+import com.mojang.brigadier.context.CommandContext;
+import io.github.skippyall.minions.minion.MinionData;
+import io.github.skippyall.minions.minion.MinionPersistentState;
+import net.minecraft.server.command.ServerCommandSource;
+import net.minecraft.text.Text;
+
+import java.util.Collection;
+
+import static net.minecraft.server.command.CommandManager.literal;
+
+public class ListSubcommand {
+    public static final LiteralArgumentBuilder<ServerCommandSource> LIST = literal("list")
+            .executes(ListSubcommand::list);
+
+    public static int list(CommandContext<ServerCommandSource> context) {
+        Collection<MinionData> minions = MinionPersistentState.INSTANCE.getMinionData().values();
+        for (MinionData minion : minions) {
+            context.getSource().sendFeedback(() -> Text.literal(minion.name() + "(" + minion.uuid() + "):" + minion.isSpawned()), false);
+        }
+        return 0;
+    }
+}

src/main/java/io/github/skippyall/minions/command/MinionArgument.java

@@ -0,0 +1,50 @@
+package io.github.skippyall.minions.command;
+
+import com.mojang.brigadier.context.CommandContext;
+import com.mojang.brigadier.exceptions.CommandSyntaxException;
+import com.mojang.brigadier.exceptions.SimpleCommandExceptionType;
+import com.mojang.brigadier.suggestion.SuggestionProvider;
+import com.mojang.brigadier.suggestion.Suggestions;
+import com.mojang.brigadier.suggestion.SuggestionsBuilder;
+import io.github.skippyall.minions.minion.MinionData;
+import io.github.skippyall.minions.minion.MinionPersistentState;
+import io.github.skippyall.minions.minion.MinionProfileUtils;
+import net.minecraft.server.command.ServerCommandSource;
+import net.minecraft.text.Text;
+
+import java.util.Optional;
+import java.util.UUID;
+import java.util.concurrent.CompletableFuture;
+
+public class MinionArgument {
+    public static final SimpleCommandExceptionType MINION_NOT_PRESENT = new SimpleCommandExceptionType(Text.translatable("minions.command.minion.not_present"));
+
+    public static final MinionSuggestionProvider SUGGESTION_PROVIDER = new MinionSuggestionProvider();
+
+    public static MinionData parse(String argument) throws CommandSyntaxException {
+        Optional<MinionData> data = Optional.empty();
+        if(argument.startsWith(MinionProfileUtils.PREFIX)) {
+            data = MinionPersistentState.INSTANCE.getMinionWithName(argument);
+        } else {
+            try {
+                data = Optional.ofNullable(MinionPersistentState.INSTANCE.getMinionData(UUID.fromString(argument)));
+            } catch (IllegalArgumentException ignored) {}
+        }
+
+        if(data.isEmpty()) {
+            throw MINION_NOT_PRESENT.create();
+        }
+        return data.get();
+    }
+
+    public static class MinionSuggestionProvider implements SuggestionProvider<ServerCommandSource> {
+        @Override
+        public CompletableFuture<Suggestions> getSuggestions(CommandContext<ServerCommandSource> context, SuggestionsBuilder builder) throws CommandSyntaxException {
+            for (MinionData data : MinionPersistentState.INSTANCE.getMinionDataList()) {
+                builder.suggest(data.name());
+            }
+
+            return builder.buildFuture();
+        }
+    }
+}

src/main/java/io/github/skippyall/minions/command/MinionsCommand.java

@@ -0,0 +1,19 @@
+package io.github.skippyall.minions.command;
+
+import com.mojang.brigadier.CommandDispatcher;
+import net.minecraft.server.command.ServerCommandSource;
+
+import static net.minecraft.server.command.CommandManager.literal;
+
+public class MinionsCommand {
+    public static void register(CommandDispatcher<ServerCommandSource> dispatcher) {
+        dispatcher.register(
+                literal("minions")
+                        .then(SpawnSubcommand.SPAWN)
+                        .then(MobCapDebugSubcommand.MOB_CAP_DEBUG)
+                        .then(ListSubcommand.LIST)
+        );
+    }
+
+
+}

src/main/java/io/github/skippyall/minions/command/MobCapDebugSubcommand.java

@@ -0,0 +1,24 @@
+package io.github.skippyall.minions.command;
+
+import com.mojang.brigadier.builder.LiteralArgumentBuilder;
+import com.mojang.brigadier.context.CommandContext;
+import io.github.skippyall.minions.mixinhelper.ChunkLevelManager$DistanceFromNearestPlayerTrackerAccessor;
+import io.github.skippyall.minions.mixinhelper.ChunkLevelManagerAccessor;
+import io.github.skippyall.minions.mixins.antimobcap.ServerChunkManagerAccessor;
+import net.minecraft.server.command.ServerCommandSource;
+import net.minecraft.server.world.ChunkTicketManager;
+import net.minecraft.text.Text;
+
+import static net.minecraft.server.command.CommandManager.literal;
+
+public class MobCapDebugSubcommand {
+    public static final LiteralArgumentBuilder<ServerCommandSource> MOB_CAP_DEBUG = literal("mobcapdebug")
+            .executes(MobCapDebugSubcommand::mobcapdebugCommand);
+
+    public static int mobcapdebugCommand(CommandContext<ServerCommandSource> context) {
+        ChunkTicketManager ticketManager = ((ServerChunkManagerAccessor)context.getSource().getWorld().getChunkManager()).getTicketManager();
+        int tickedChunkCount = ((ChunkLevelManager$DistanceFromNearestPlayerTrackerAccessor)((ChunkLevelManagerAccessor)ticketManager).minions$getMinionless()).minions$getTickedChunkCount();
+        context.getSource().sendFeedback(() -> Text.of(String.valueOf(tickedChunkCount)), false);
+        return 0;
+    }
+}

src/main/java/io/github/skippyall/minions/command/SpawnSubcommand.java

@@ -0,0 +1,47 @@
+package io.github.skippyall.minions.command;
+
+import com.mojang.brigadier.arguments.BoolArgumentType;
+import com.mojang.brigadier.arguments.StringArgumentType;
+import com.mojang.brigadier.builder.LiteralArgumentBuilder;
+import com.mojang.brigadier.exceptions.CommandSyntaxException;
+import io.github.skippyall.minions.minion.MinionData;
+import io.github.skippyall.minions.minion.fakeplayer.MinionFakePlayer;
+import net.minecraft.command.argument.PosArgument;
+import net.minecraft.command.argument.Vec3ArgumentType;
+import net.minecraft.server.command.ServerCommandSource;
+
+import static net.minecraft.server.command.CommandManager.argument;
+import static net.minecraft.server.command.CommandManager.literal;
+
+public class SpawnSubcommand {
+    public static final LiteralArgumentBuilder<ServerCommandSource> SPAWN = literal("spawn")
+            .then(argument("minion", StringArgumentType.word())
+                    .suggests(MinionArgument.SUGGESTION_PROVIDER)
+                    .then(argument("pos", Vec3ArgumentType.vec3()))
+                    .executes(context ->
+                            spawnCommand(
+                                    context.getSource(),
+                                    StringArgumentType.getString(context, "minion"),
+                                    Vec3ArgumentType.getPosArgument(context, "pos"),
+                                    false
+                            )
+                    )
+
+                    .then(argument("force", BoolArgumentType.bool())
+                            .executes(context ->
+                                    spawnCommand(
+                                            context.getSource(),
+                                            StringArgumentType.getString(context, "minion"),
+                                            Vec3ArgumentType.getPosArgument(context, "pos"),
+                                            BoolArgumentType.getBool(context, "force")
+                                    )
+                            )
+                    )
+            );
+
+    public static int spawnCommand(ServerCommandSource source, String minion, PosArgument pos, boolean force) throws CommandSyntaxException {
+        MinionData data = MinionArgument.parse(minion);
+        MinionFakePlayer.spawnMinion(data, source.getWorld(), pos.getPos(source), pos.getRotation(source), force);
+        return 0;
+    }
+}

src/main/java/io/github/skippyall/minions/gui/CommandsGui.java

@@ -2,26 +2,26 @@ package io.github.skippyall.minions.gui;
 
 import eu.pb4.sgui.api.elements.GuiElementBuilder;
 import eu.pb4.sgui.api.gui.SimpleGui;
-import io.github.skippyall.minions.command.Command;
+import io.github.skippyall.minions.module.command.Command;
 import io.github.skippyall.minions.minion.fakeplayer.MinionFakePlayer;
 import io.github.skippyall.minions.module.ModuleItem;
 import net.minecraft.screen.ScreenHandlerType;
 import net.minecraft.server.network.ServerPlayerEntity;
 import net.minecraft.text.Text;
 
+import java.util.Collection;
 import java.util.List;
 
 public class CommandsGui {
     public static void openServerModuleCommandGui(ServerPlayerEntity player, MinionFakePlayer minion) {
-        List<ModuleItem> modules = minion.getModuleInventory().getModuleItems();
+        Collection<ModuleItem> modules = minion.getModuleInventory().getModuleItems();
 
         SimpleGui gui = new SimpleGui(ScreenHandlerType.GENERIC_9X3, player, false);
 
         gui.setTitle(Text.translatable("minions.gui.module_commands.title"));
 
-        for (int i = 0; i < modules.size(); i++) {
-            ModuleItem module = modules.get(i);
-            gui.setSlot(i, new GuiElementBuilder()
+        for (ModuleItem module : modules) {
+            gui.addSlot(new GuiElementBuilder()
                     .setItem(module.asItem())
                     .setCallback(() -> openServerCommandGui(player, minion, module))
             );

src/main/java/io/github/skippyall/minions/gui/MinionGui.java

@@ -25,15 +25,6 @@ public class MinionGui {
                     openCommandsGui(player, minion);
                 })
         );
-        if(minion.isProgrammable()) {
-            gui.setSlot(4, new GuiElementBuilder()
-                    .setItem(Items.REDSTONE)
-                    .setName(Text.translatable("minions.gui.main.programming"))
-                    .setCallback(() -> {
-                        openProgrammingInventory(player, minion);
-                    })
-            );
-        }
         gui.setSlot(3, new GuiElementBuilder()
                 .setItem(Items.NETHERITE_UPGRADE_SMITHING_TEMPLATE)
                 .setName(Text.translatable("minions.gui.main.modules"))
@@ -52,7 +43,7 @@ public class MinionGui {
                 .setItem(Items.BARRIER)
                 .setName(Text.translatable("minions.gui.main.pickup"))
                 .setCallback(() -> {
-                    minion.kill(minion.getServerWorld());
+                    minion.kill(minion.getWorld());
                 })
         );
         gui.open();

src/main/java/io/github/skippyall/minions/gui/MinionLookGui.java

@@ -0,0 +1,95 @@
+package io.github.skippyall.minions.gui;
+
+import eu.pb4.sgui.api.elements.GuiElementBuilder;
+import eu.pb4.sgui.api.gui.SimpleGui;
+import io.github.skippyall.minions.input.TextInput;
+import io.github.skippyall.minions.minion.MinionData;
+import io.github.skippyall.minions.minion.MinionItem;
+import io.github.skippyall.minions.minion.MinionProfileUtils;
+import io.github.skippyall.minions.minion.skin.SkinProvider;
+import io.github.skippyall.minions.minion.skin.SkinProviders;
+import net.minecraft.component.DataComponentTypes;
+import net.minecraft.component.type.ProfileComponent;
+import net.minecraft.item.ItemStack;
+import net.minecraft.item.Items;
+import net.minecraft.screen.ScreenHandlerType;
+import net.minecraft.server.network.ServerPlayerEntity;
+import net.minecraft.text.Text;
+
+import java.util.Optional;
+
+public class MinionLookGui extends SimpleGui {
+    private ItemStack minionItem;
+    private SkinProvider currentSkinProvider;
+
+    public MinionLookGui(ServerPlayerEntity player, ItemStack minionItem) {
+        super(ScreenHandlerType.GENERIC_9X3, player, false);
+        this.minionItem = minionItem;
+        this.currentSkinProvider = SkinProviders.NAME;
+    }
+
+    public void update() {
+        updateName();
+        updateSkin();
+        updateSkinProvider();
+    }
+
+    private void updateName() {
+        setSlot(10, new GuiElementBuilder()
+                .setItem(Items.OAK_SIGN)
+                .setName(Text.literal(getData().name()))
+                .setCallback(() -> {
+                    openRenameGui(player, minionItem);
+                })
+        );
+    }
+
+    private void updateSkin() {
+        GuiElementBuilder builder = new GuiElementBuilder()
+                .setItem(Items.PLAYER_HEAD)
+                .setCallback(() -> currentSkinProvider.openSkinMenu(player).thenAccept(skin -> {
+                    MinionItem.setData(getData().withSkin(skin), minionItem);
+                }));
+        if(MinionItem.getData(minionItem) != null && MinionItem.getData(minionItem).skin().isPresent()) {
+            builder.setComponent(DataComponentTypes.PROFILE, new ProfileComponent(Optional.empty(), Optional.empty(), getData().skin().get()));
+        }
+        setSlot(16, builder);
+    }
+
+    private void cycleSkinProvider() {
+        int currentId = SkinProviders.SKIN_PROVIDERS.getRawId(currentSkinProvider);
+        currentId++;
+        if(SkinProviders.SKIN_PROVIDERS.size() == currentId) {
+            currentId = 0;
+        }
+
+        currentSkinProvider = SkinProviders.SKIN_PROVIDERS.get(currentId);
+        updateSkinProvider();
+    }
+
+    private void updateSkinProvider() {
+        setSlot(25, new GuiElementBuilder()
+                .setItem(Items.GREEN_STAINED_GLASS_PANE)
+                .setComponent(DataComponentTypes.CUSTOM_NAME, currentSkinProvider.getDisplayName())
+                .setCallback(this::cycleSkinProvider)
+        );
+    }
+
+    private MinionData getData() {
+        return MinionItem.getDataOrDefault(minionItem);
+    }
+
+    public static void open(ServerPlayerEntity player, ItemStack minionItem) {
+        MinionLookGui gui = new MinionLookGui(player, minionItem);
+        gui.update();
+        gui.open();
+    }
+
+    public void openRenameGui(ServerPlayerEntity player, ItemStack minionItem) {
+        TextInput.inputSync(player, Text.translatable("minions.gui.look.rename.title"), "Minion", MinionProfileUtils::checkMinionNameWithoutPrefix)
+                .thenAccept(name -> {
+                    MinionItem.setData(getData().withName(MinionProfileUtils.PREFIX + name), minionItem);
+                    open();
+                });
+    }
+}

src/main/java/io/github/skippyall/minions/gui/ModuleInventory.java

@@ -1,22 +1,26 @@
 package io.github.skippyall.minions.gui;
 
-import io.github.skippyall.minions.command.Command;
+import io.github.skippyall.minions.module.command.Command;
 import io.github.skippyall.minions.minion.fakeplayer.MinionFakePlayer;
 import io.github.skippyall.minions.module.ModuleItem;
 import io.github.skippyall.minions.program.block.CodeBlock;
 import net.minecraft.inventory.Inventories;
 import net.minecraft.inventory.SimpleInventory;
 import net.minecraft.item.ItemStack;
-import net.minecraft.nbt.NbtCompound;
-import net.minecraft.registry.RegistryWrapper;
 import net.minecraft.screen.SimpleNamedScreenHandlerFactory;
 import net.minecraft.server.network.ServerPlayerEntity;
+import net.minecraft.storage.ReadView;
+import net.minecraft.storage.WriteView;
 import net.minecraft.text.Text;
 
 import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashSet;
 import java.util.List;
+import java.util.Set;
 
 public class ModuleInventory extends SimpleInventory {
+    private final Set<ModuleItem> modules = new HashSet<>();
     public ModuleInventory() {
         super(27);
     }
@@ -35,30 +39,35 @@ public class ModuleInventory extends SimpleInventory {
         return (stack.getCount() <= getMaxCountPerStack()) && stack.getItem() instanceof ModuleItem;
     }
 
-    public void readNbt(NbtCompound nbt, RegistryWrapper.WrapperLookup lookup) {
-        Inventories.readNbt(nbt, heldStacks, lookup);
+    @Override
+    public void markDirty() {
+        super.markDirty();
+        updateModules();
     }
 
-    public NbtCompound writeNbt(NbtCompound nbt, RegistryWrapper.WrapperLookup lookup) {
-        return Inventories.writeNbt(nbt, heldStacks, lookup);
+    public void updateModules() {
+        modules.clear();
+        for (ItemStack heldStack : heldStacks) {
+            if(heldStack.getItem() instanceof ModuleItem moduleItem) {
+                modules.add(moduleItem);
+            }
+        }
+    }
+
+    public void readData(ReadView view) {
+        Inventories.readData(view, heldStacks);
+        updateModules();
+    }
+
+    public void writeData(WriteView view) {
+        Inventories.writeData(view, heldStacks);
     }
 
     public boolean hasModule(ModuleItem module) {
-        for(ItemStack stack : heldStacks) {
-            if(stack.getItem() instanceof ModuleItem module2 && module2 == module) {
-                return true;
-            }
-        }
-        return false;
+        return modules.contains(module);
     }
 
-    public List<ModuleItem> getModuleItems() {
-        ArrayList<ModuleItem> modules = new ArrayList<>();
-        for(ItemStack stack : heldStacks) {
-            if(stack.getItem() instanceof ModuleItem module) {
-                modules.add(module);
-            }
-        }
+    public Collection<ModuleItem> getModuleItems() {
         return modules;
     }
 

src/main/java/io/github/skippyall/minions/input/Result.java

@@ -0,0 +1,117 @@
+package io.github.skippyall.minions.input;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Optional;
+import java.util.function.Consumer;
+import java.util.function.Function;
+
+public interface Result<T, E> {
+    static <T> Result<T, String> wrap(UnsafeOperation<T> toWrap) {
+        return wrapCustomError(toWrap, Exception::getMessage);
+    }
+
+    static <T, E> Result<T, E> wrapCustomError(UnsafeOperation<T> toWrap, E error) {
+        return wrapCustomError(toWrap,  e -> error);
+    }
+
+    static <T, E> Result<T, E> wrapCustomError(UnsafeOperation<T> toWrap, Function<Exception, E> errorTransformer) {
+        try {
+            return new Result.Success<>(toWrap.run());
+        } catch (Exception e) {
+            return new Result.Error<>(errorTransformer.apply(e));
+        }
+    }
+
+    boolean isSuccess();
+
+    @NotNull T getOrDefault(@NotNull T defaultValue);
+
+    @NotNull T getOrThrow();
+
+    @NotNull E getErrorOrThrow();
+
+    @NotNull Optional<T> getOptional();
+
+    void ifSuccess(@NotNull Consumer<T> handler);
+
+    void ifError(@NotNull Consumer<Error<T, E>> handler);
+
+    record Success<T, E>(@NotNull T result) implements Result<T, E> {
+        @Override
+        public boolean isSuccess() {
+            return true;
+        }
+
+        @Override
+        public @NotNull T getOrDefault(@NotNull T defaultValue) {
+            return result;
+        }
+
+        @Override
+        public @NotNull T getOrThrow() {
+            return result;
+        }
+
+        @Override
+        public @NotNull E getErrorOrThrow() {
+            throw new RuntimeException("Result was not an Error");
+        }
+
+        @Override
+        public @NotNull Optional<T> getOptional() {
+            return Optional.of(result);
+        }
+
+        @Override
+        public void ifSuccess(@NotNull Consumer<T> handler) {
+            handler.accept(result);
+        }
+
+        @Override
+        public void ifError(@NotNull Consumer<Error<T, E>> handler) {
+
+        }
+    }
+
+    record Error<T, E>(@NotNull E message) implements Result<T, E> {
+        @Override
+        public boolean isSuccess() {
+            return false;
+        }
+
+        @Override
+        public @NotNull T getOrDefault(@NotNull T defaultValue) {
+            return defaultValue;
+        }
+
+        @Override
+        public @NotNull T getOrThrow() {
+            throw new RuntimeException("Result was an error: " + message.toString());
+        }
+
+        @Override
+        public @NotNull E getErrorOrThrow() {
+            return message;
+        }
+
+        @Override
+        public @NotNull Optional<T> getOptional() {
+            return Optional.empty();
+        }
+
+        @Override
+        public void ifSuccess(@NotNull Consumer<T> handler) {
+
+        }
+
+        @Override
+        public void ifError(Consumer<Error<T, E>> handler) {
+            handler.accept(this);
+        }
+    }
+
+    interface UnsafeOperation<T> {
+        T run() throws Exception;
+    }
+}

src/main/java/io/github/skippyall/minions/input/TextInput.java

@@ -9,42 +9,82 @@ import net.minecraft.text.Text;
 
 import java.util.concurrent.CompletableFuture;
 import java.util.function.Function;
+import java.util.function.Predicate;
 
-public class TextInput {
-    public static CompletableFuture<String> inputText(ServerPlayerEntity player, Text title, String defaultText) {
-        CompletableFuture<String> future = new CompletableFuture<>();
+public class TextInput<T> extends AnvilInputGui {
+    private final GuiElementBuilder valid = new GuiElementBuilder()
+            .setItem(Items.EMERALD_BLOCK)
+            .setName(Text.literal("OK"))
+            .setCallback(this::onConfirm);
 
-        AnvilInputGui gui = new AnvilInputGui(player, false);
-        gui.setSlot(AnvilScreenHandler.OUTPUT_ID, new GuiElementBuilder()
-                .setItem(Items.EMERALD_BLOCK)
-                .setName(Text.literal("OK"))
-                .setCallback(() -> {
-                    gui.close();
-                    future.complete(gui.getInput());
-                })
-        );
-        gui.setTitle(title);
-        gui.setDefaultInputValue(defaultText);
-        gui.open();
+    private final GuiElementBuilder invalid = new GuiElementBuilder()
+            .setItem(Items.REDSTONE_BLOCK);
+    private final Function<String, CompletableFuture<Result<T, Text>>> parser;
+    private final CompletableFuture<T> future;
+    private Result<T, Text> result;
+
+    public TextInput(ServerPlayerEntity player, Text title, String defaultValue, Function<String, CompletableFuture<Result<T, Text>>> parser, CompletableFuture<T> future) {
+        super(player, false);
+        setTitle(title);
+        setDefaultInputValue(defaultValue);
+        this.parser = parser;
+        this.future = future;
+
+        updateConfirmButton(defaultValue);
+    }
+
+    public static <T> CompletableFuture<T> inputSync(ServerPlayerEntity player, Text title, String defaultValue, Function<String, Result<T, Text>> parser) {
+        return input(player, title, defaultValue, (String string) -> CompletableFuture.completedFuture(parser.apply(string)));
+    }
+
+    public static <T> CompletableFuture<T> input(ServerPlayerEntity player, Text title, String defaultValue, Function<String, CompletableFuture<Result<T, Text>>> parser) {
+        CompletableFuture<T> future = new CompletableFuture<>();
+        new TextInput<>(player, title, defaultValue, parser, future).open();
         return future;
     }
 
-    public static <T> CompletableFuture<T> inputParse(ServerPlayerEntity player, Text title, String defaultValue, Function<String, T> parser, Text failureMessage) {
-        return inputText(player, title, String.valueOf(defaultValue)).thenCompose(string -> {
-            try {
-                return CompletableFuture.completedFuture(parser.apply(string));
-            } catch (Exception e) {
-                player.sendMessage(failureMessage);
-                return CompletableFuture.failedFuture(e);
+    public static CompletableFuture<String> inputString(ServerPlayerEntity player, Text title, String defaultValue) {
+        return inputSync(player, title, defaultValue, Result.Success::new);
+    }
+
+    public static CompletableFuture<Integer> inputInt(ServerPlayerEntity player, Text title, String defaultValue) {
+        return inputSync(player, title, defaultValue, string -> Result.wrapCustomError(() -> Integer.valueOf(string), Text.translatable("minions.command.input.int.fail")));
+    }
+
+    public static CompletableFuture<Float> inputFloat(ServerPlayerEntity player, Text title, String defaultValue) {
+        return inputSync(player, title, defaultValue, string -> Result.wrapCustomError(() -> Float.valueOf(string), Text.translatable("minions.command.input.float.fail")));
+    }
+
+    @Override
+    public void onInput(String input) {
+        updateConfirmButton(input);
+    }
+
+    public void updateConfirmButton(String input) {
+        parser.apply(input).thenAccept(result -> {
+            this.result = result;
+            if(result.isSuccess()) {
+                setSlot(AnvilScreenHandler.OUTPUT_ID, valid);
+            } else {
+                Text text = result.getErrorOrThrow();
+                setSlot(AnvilScreenHandler.OUTPUT_ID, invalid.setName(text));
             }
         });
     }
 
-    public static CompletableFuture<Integer> inputInt(ServerPlayerEntity player, Text title, String defaultValue) {
-        return inputParse(player, title, defaultValue, Integer::parseInt, Text.translatable("minions.command.input.int.fail"));
+    @Override
+    public void onClose() {
+        if(!future.isDone()) {
+            future.cancel(false);
+        }
     }
 
-    public static CompletableFuture<Float> inputFloat(ServerPlayerEntity player, Text title, String defaultValue) {
-        return inputParse(player, title, defaultValue, Float::parseFloat, Text.translatable("minions.command.input.float.fail"));
+    public void onConfirm() {
+        if(result != null) {
+            result.ifSuccess(success -> {
+                future.complete(success);
+                close();
+            });
+        }
     }
 }

src/main/java/io/github/skippyall/minions/minion/MinionData.java

@@ -1,10 +1,11 @@
 package io.github.skippyall.minions.minion;
 
+import com.mojang.authlib.properties.PropertyMap;
+import com.mojang.datafixers.util.Pair;
 import com.mojang.serialization.Codec;
 import com.mojang.serialization.codecs.RecordCodecBuilder;
 import eu.pb4.polymer.core.api.other.PolymerComponent;
 import io.github.skippyall.minions.Minions;
-import io.github.skippyall.minions.minion.fakeplayer.MinionFakePlayer;
 import net.minecraft.component.ComponentType;
 import net.minecraft.nbt.NbtCompound;
 import net.minecraft.nbt.NbtOps;
@@ -12,43 +13,50 @@ import net.minecraft.registry.Registries;
 import net.minecraft.registry.Registry;
 import net.minecraft.util.Identifier;
 import net.minecraft.util.Uuids;
-import org.jetbrains.annotations.NotNull;
+import net.minecraft.util.dynamic.Codecs;
+import org.jetbrains.annotations.Nullable;
 
 import java.util.Optional;
 import java.util.UUID;
 
-public record MinionData(UUID uuid, String name, @NotNull Optional<UUID> skinUuid) {
+public record MinionData(UUID uuid, String name, Optional<PropertyMap> skin, boolean isSpawned) {
     public static final Codec<MinionData> CODEC = RecordCodecBuilder.create(instance ->
             instance.group(
                     Uuids.CODEC.fieldOf("uuid").forGetter(MinionData::uuid),
                     Codec.STRING.fieldOf("name").forGetter(MinionData::name),
-                    Uuids.CODEC.optionalFieldOf("skinUuid").orElse(Optional.empty()).forGetter(MinionData::skinUuid)
+                    Codecs.GAME_PROFILE_PROPERTY_MAP.optionalFieldOf("skin").forGetter(MinionData::skin),
+                    Codec.BOOL.optionalFieldOf("isSpawned", false).forGetter(MinionData::isSpawned)
             ).apply(instance, MinionData::new)
     );
-    public static final ComponentType<MinionData> COMPONENT = Registry.register(Registries.DATA_COMPONENT_TYPE, Identifier.of(Minions.MOD_ID, "minion_data"), ComponentType.<MinionData>builder().codec(CODEC).build());
+
+    public static final ComponentType<UUID> COMPONENT = Registry.register(Registries.DATA_COMPONENT_TYPE, Identifier.of(Minions.MOD_ID, "minion_data"), ComponentType.<UUID>builder().codec(Uuids.CODEC).build());
+
+    public static MinionData createDefault() {
+        return new MinionData(UUID.randomUUID(), MinionProfileUtils.newDefaultMinionName(), Optional.empty(), false);
+    }
 
     public MinionData withUuid(UUID uuid) {
-        return new MinionData(uuid, name, skinUuid);
+        return new MinionData(uuid, name, skin, isSpawned);
     }
 
     public MinionData withName(String name) {
-        return new MinionData(uuid, name, skinUuid);
+        return new MinionData(uuid, name, skin, isSpawned);
     }
 
-    public MinionData withSkin(Optional<UUID> skinUuid) {
-        return new MinionData(uuid, name, skinUuid);
+    public MinionData withSkin(Optional<PropertyMap> skin) {
+        return new MinionData(uuid, name, skin, isSpawned);
+    }
+
+    public MinionData withSpawned(boolean isSpawned) {
+        return new MinionData(uuid, name, skin, isSpawned);
     }
 
     public NbtCompound writeNbt() {
-        return (NbtCompound) MinionData.CODEC.encode(this, NbtOps.INSTANCE, null).getOrThrow();
+        return (NbtCompound) MinionData.CODEC.encode(this, NbtOps.INSTANCE, null).result().orElse(new NbtCompound());
     }
 
     public static MinionData readNbt(NbtCompound nbt) {
-        return MinionData.CODEC.decode(NbtOps.INSTANCE, nbt).getOrThrow().getFirst();
-    }
-
-    public static MinionData fromMinion(MinionFakePlayer minion) {
-        return new MinionData(minion.getUuid(), minion.getMinionName(), minion.getSkinUuid());
+        return MinionData.CODEC.decode(NbtOps.INSTANCE, nbt).resultOrPartial().map(Pair::getFirst).orElseGet(MinionData::createDefault);
     }
 
     public static void register() {

src/main/java/io/github/skippyall/minions/minion/MinionItem.java

@@ -2,9 +2,11 @@ package io.github.skippyall.minions.minion;
 
 import eu.pb4.polymer.core.api.item.PolymerItem;
 import eu.pb4.polymer.core.api.item.PolymerItemUtils;
+import io.github.skippyall.minions.gui.MinionLookGui;
 import io.github.skippyall.minions.minion.fakeplayer.MinionFakePlayer;
 import net.minecraft.component.DataComponentTypes;
-import net.minecraft.component.type.NbtComponent;
+import net.minecraft.component.type.TooltipDisplayComponent;
+import net.minecraft.entity.player.PlayerEntity;
 import net.minecraft.item.Item;
 import net.minecraft.item.ItemStack;
 import net.minecraft.item.ItemUsageContext;
@@ -14,20 +16,19 @@ import net.minecraft.server.network.ServerPlayerEntity;
 import net.minecraft.server.world.ServerWorld;
 import net.minecraft.text.Text;
 import net.minecraft.util.ActionResult;
+import net.minecraft.util.Hand;
 import net.minecraft.util.Identifier;
 import net.minecraft.util.math.Vec2f;
+import net.minecraft.world.World;
 import org.jetbrains.annotations.Nullable;
 import xyz.nucleoid.packettweaker.PacketContext;
 
 import java.util.List;
-import java.util.Optional;
+import java.util.function.Consumer;
 
 public class MinionItem extends Item implements PolymerItem {
-    private final boolean canProgram;
-
-    public MinionItem(Settings settings, boolean canProgram) {
+    public MinionItem(Settings settings) {
         super(settings);
-        this.canProgram = canProgram;
     }
 
     @Override
@@ -48,55 +49,57 @@ public class MinionItem extends Item implements PolymerItem {
     }
 
     @Override
-    public void appendTooltip(ItemStack stack, TooltipContext context, List<Text> tooltip, TooltipType type) {
-        MinionData data = stack.get(MinionData.COMPONENT);
+    public void appendTooltip(ItemStack stack, TooltipContext context, TooltipDisplayComponent component,  Consumer<Text> tooltip, TooltipType type) {
+        MinionData data = getData(stack);
         if(data != null) {
-            tooltip.add(Text.translatable("minions.minion_item.tooltip", data.name()));
+            tooltip.accept(Text.translatable("minions.minion_item.tooltip", data.name()));
         }
     }
 
     @Override
-    public ActionResult useOnBlock(ItemUsageContext context) {
-        String contents = context.getStack().getName().getLiteralString();
-        String name;
-        if(contents != null && contents.length() <= 16) {
-            name = contents;
-        } else {
-            name = "Minion";
+    public ActionResult use(World world, PlayerEntity user, Hand hand) {
+        if(user instanceof ServerPlayerEntity serverPlayer) {
+            ItemStack stack = user.getStackInHand(hand);
+            MinionLookGui.open(serverPlayer, stack);
+            return ActionResult.SUCCESS;
         }
+
+        return ActionResult.SUCCESS_SERVER;
+    }
+
+    @Override
+    public ActionResult useOnBlock(ItemUsageContext context) {
         if(!context.getWorld().isClient) {
-            MinionData data = getData(context.getStack());
-
-            if(data == null) {
-                data = new MinionData(null, name, Optional.empty());
-            }
-
-            if (data.uuid() == null) {
-                MinionFakePlayer.createMinion(data, (ServerWorld) context.getWorld(), (ServerPlayerEntity) context.getPlayer(), canProgram, context.getBlockPos().toCenterPos().add(0,0.5,0), new Vec2f(0, 0));
-            }else {
-                data = data.withName(name);
-                MinionFakePlayer.spawnMinionAt(data, (ServerWorld) context.getWorld(), context.getBlockPos().toCenterPos().add(0,0.5,0), new Vec2f(0, 0));
-                MinionPersistentState.INSTANCE.addMinion(data);
-            }
+            MinionData data = getDataOrDefault(context.getStack());
+            MinionFakePlayer.spawnMinion(data, (ServerWorld) context.getWorld(), context.getBlockPos().toCenterPos().add(0,0.5,0), new Vec2f(0, 0));
         }
         context.getStack().decrement(1);
         return ActionResult.SUCCESS;
     }
 
     public static void setData(MinionData data, ItemStack item) {
-        item.set(MinionData.COMPONENT, data);
+        item.set(MinionData.COMPONENT, data.uuid());
+        MinionPersistentState.INSTANCE.updateMinionData(data);
     }
 
     @Nullable
     public static MinionData getData(ItemStack item) {
-        return item.get(MinionData.COMPONENT);
+        if(item.contains(MinionData.COMPONENT)) {
+            return MinionPersistentState.INSTANCE.getMinionData(item.get(MinionData.COMPONENT));
+        }
+        return null;
+    }
+
+    public static MinionData getDataOrDefault(ItemStack item) {
+        MinionData data = getData(item);
+        if(data == null) {
+            data = MinionData.createDefault();
+            setData(data, item);
+        }
+        return data;
     }
 
     public static boolean containsData(ItemStack item) {
-        NbtComponent nbt = item.get(DataComponentTypes.CUSTOM_DATA);
-        if (nbt == null) {
-            return false;
-        }
-        return nbt.copyNbt().contains("data");
+        return item.contains(MinionData.COMPONENT);
     }
 }

src/main/java/io/github/skippyall/minions/minion/MinionPersistentState.java

@@ -1,100 +1,70 @@
 package io.github.skippyall.minions.minion;
 
-import io.github.skippyall.minions.minion.fakeplayer.MinionFakePlayer;
-import net.minecraft.nbt.NbtCompound;
-import net.minecraft.nbt.NbtElement;
-import net.minecraft.nbt.NbtList;
-import net.minecraft.registry.RegistryWrapper;
+import com.mojang.serialization.Codec;
+import io.github.skippyall.minions.Minions;
 import net.minecraft.server.MinecraftServer;
 import net.minecraft.world.PersistentState;
+import net.minecraft.world.PersistentStateType;
 import net.minecraft.world.World;
 
-import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
+import java.util.Optional;
 import java.util.UUID;
 
 public class MinionPersistentState extends PersistentState {
-    public static Type<MinionPersistentState> TYPE = new Type<>(MinionPersistentState::new, MinionPersistentState::read, null);
+    public static final Codec<MinionPersistentState> CODEC = MinionData.CODEC.listOf().xmap(MinionPersistentState::new, MinionPersistentState::getMinionDataList);
+
+    public static PersistentStateType<MinionPersistentState> TYPE = new PersistentStateType<>("minion", MinionPersistentState::new, MinionPersistentState.CODEC, null);
 
     public static MinionPersistentState INSTANCE;
 
-    private final List<MinionData> minionData = new ArrayList<>();
-    private final List<UUID> minionUuids = new ArrayList<>();
+    private final Map<UUID, MinionData> minionData = new HashMap<>();
 
-    @Override
-    public NbtCompound writeNbt(NbtCompound nbt, RegistryWrapper.WrapperLookup registryLookup) {
-        NbtList list = new NbtList();
-        for(MinionData data : minionData) {
-            list.add(data.writeNbt());
-        }
-        nbt.put("minions", list);
+    public MinionPersistentState() {
 
-        NbtList uuids = new NbtList();
-        for(UUID uuid : minionUuids) {
-            NbtCompound compound = new NbtCompound();
-            compound.putUuid("uuid", uuid);
-            uuids.add(compound);
-        }
-        nbt.put("uuids", uuids);
-        return nbt;
     }
 
-    public static MinionPersistentState read(NbtCompound compound, RegistryWrapper.WrapperLookup lookup) {
-        NbtList list = compound.getList("minions", NbtElement.COMPOUND_TYPE);
-        MinionPersistentState instance = new MinionPersistentState();
-        for(NbtElement element : list) {
-            instance.addMinion(MinionData.readNbt((NbtCompound) element));
-        }
-
-        NbtList uuids = compound.getList("uuids", NbtElement.COMPOUND_TYPE);
-        for(NbtElement element : uuids) {
-            instance.minionUuids.add(((NbtCompound) element).getUuid("uuid"));
-        }
-        return instance;
-    }
-
-    public void addMinionUUID(UUID uuid) {
-        if(!minionUuids.contains(uuid)) {
-            minionUuids.add(uuid);
+    public MinionPersistentState(List<MinionData> dataList) {
+        for (MinionData data : dataList) {
+            minionData.put(data.uuid(), data);
         }
     }
 
-    public void addMinion(MinionFakePlayer minion) {
-        addMinion(MinionData.fromMinion(minion));
+    public MinionData getMinionData(UUID uuid) {
+        return minionData.get(uuid);
     }
 
-    public void addMinion(MinionData data) {
-        System.out.println("add Minion " + data.name());
-        minionData.add(data);
-        markDirty();
-    }
-
-    public void removeMinion(MinionFakePlayer minionData) {
-        removeMinion(minionData.getUuid());
-    }
-
-    public void removeMinion(UUID minionUUID) {
-        MinionData removal = null;
-        for (MinionData data : minionData) {
-            if (data.uuid().equals(minionUUID)) {
-                removal = data;
-            }
-        }
-        if (removal != null) {
-            minionData.remove(removal);
-        }
-        markDirty();
-    }
-
-    public List<MinionData> getMinionData() {
+    public Map<UUID, MinionData> getMinionData() {
         return minionData;
     }
 
+    public List<MinionData> getMinionDataList() {
+        return List.copyOf(minionData.values());
+    }
+
+    public void updateMinionData(MinionData data) {
+        minionData.put(data.uuid(), data);
+        markDirty();
+    }
+
     public boolean isMinion(UUID uuid) {
-        return minionUuids.contains(uuid);
+        return minionData.containsKey(uuid);
+    }
+
+    public boolean isMinionNameTaken(String name) {
+        return getMinionWithName(name).isPresent();
+    }
+
+    public Optional<MinionData> getMinionWithName(String name) {
+        return minionData.values().stream()
+                .filter(data -> data.name().equals(name))
+                .findFirst();
     }
 
     public static void create(MinecraftServer server) {
-        INSTANCE = server.getWorld(World.OVERWORLD).getPersistentStateManager().getOrCreate(TYPE, "minion");
+        Minions.LOGGER.error("Creating Minion Persistent state");
+        INSTANCE = server.getWorld(World.OVERWORLD).getPersistentStateManager().getOrCreate(TYPE);
     }
 }

src/main/java/io/github/skippyall/minions/minion/MinionProfileUtils.java

@@ -2,8 +2,14 @@ package io.github.skippyall.minions.minion;
 
 import com.mojang.authlib.GameProfile;
 import com.mojang.authlib.ProfileLookupCallback;
+import com.mojang.authlib.properties.PropertyMap;
 import com.mojang.authlib.yggdrasil.ProfileResult;
+import com.mojang.brigadier.StringReader;
+import io.github.skippyall.minions.input.Result;
+import net.minecraft.block.entity.SkullBlockEntity;
 import net.minecraft.server.MinecraftServer;
+import net.minecraft.text.Text;
+import net.minecraft.util.StringHelper;
 import org.jetbrains.annotations.Nullable;
 
 import java.util.UUID;
@@ -13,67 +19,51 @@ import java.util.concurrent.ForkJoinPool;
 import static io.github.skippyall.minions.Minions.LOGGER;
 
 public class MinionProfileUtils {
-    public static CompletableFuture<@Nullable GameProfile> lookupSkinOwnerProfile(MinecraftServer server, String username) {
-        CompletableFuture<GameProfile> future = new CompletableFuture<>();
+    public static final String PREFIX = "+";
 
-        ForkJoinPool.commonPool().execute(() -> {
-            try {
-                server.getGameProfileRepo().findProfilesByNames(new String[]{username}, new ProfileLookupCallback() {
-                    @Override
-                    public void onProfileLookupSucceeded(GameProfile found) {
-                        LOGGER.info("SkinProfile: {}", found);
-                        try {
-                            getSkinOwnerProfile(server, found.getId()).thenAccept(future::complete);
-                        } catch (Throwable ex) {
-                            LOGGER.warn("Exception during Game Profile creation", ex);
-                        }
-                    }
-
-                    @Override
-                    public void onProfileLookupFailed(String profileName, Exception exception) {
-                        LOGGER.warn("Lookup Error: ", exception);
-                        future.complete(null);
-                    }
-                });
-            } catch (Throwable e) {
-                LOGGER.warn("Failed to get UUID for username " + username, e);
-                future.complete(null);
-            }
-        });
-
-        return future;
-    }
-
-    public static CompletableFuture<@Nullable GameProfile> getSkinOwnerProfile(MinecraftServer server, @Nullable UUID uuid) {
-        CompletableFuture<GameProfile> future = new CompletableFuture<>();
-        future.completeAsync(() -> {
-            GameProfile profile = null;
-            if(uuid != null) {
-                ProfileResult result = server.getSessionService().fetchProfile(uuid, true);
-                if (result != null) {
-                    profile = result.profile();
-                    LOGGER.info("Full SkinProfile: {}", profile);
-                }
-            }
-            return profile;
-        });
-        return future;
-    }
-
-    public static GameProfile makeNewMinionProfile(@Nullable UUID uuidMinion, String username, @Nullable GameProfile skinProfile) {
+    public static GameProfile makeNewMinionProfile(UUID uuidMinion, String username, PropertyMap skin) {
         if(uuidMinion == null) {
             uuidMinion = UUID.randomUUID();
         }
-        MinionPersistentState.INSTANCE.addMinionUUID(uuidMinion);
 
         GameProfile newProfile = new GameProfile(uuidMinion, username);
-        if (skinProfile != null) {
-            newProfile.getProperties().putAll(skinProfile.getProperties());
+        if (skin != null) {
+            newProfile.getProperties().putAll(skin);
         }
         LOGGER.info("Minion Profile: {}", newProfile);
         return newProfile;
     }
 
+    public static Result<String, Text> checkMinionNameWithoutPrefix(String name) {
+        for(char c : name.toCharArray()) {
+            if(!StringReader.isAllowedInUnquotedString(c)) {
+                return new Result.Error<>(Text.translatable("minions.generic.name.invalid_char"));
+            }
+        }
+
+        if((PREFIX + name).length() > 16)  {
+            return new Result.Error<>(Text.translatable("minions.generic.name.too_long"));
+        }
+
+        if(!StringHelper.isValidPlayerName(PREFIX + name)) {
+            return new Result.Error<>(Text.translatable("minions.generic.name.invalid"));
+        }
+
+        if(MinionPersistentState.INSTANCE.isMinionNameTaken(PREFIX + name)) {
+            return new Result.Error<>(Text.translatable("minions.generic.name.taken"));
+        }
+
+        return new Result.Success<>(name);
+    }
+
+    public static String newDefaultMinionName() {
+        int i = 0;
+        while (MinionPersistentState.INSTANCE.isMinionNameTaken("+Minion" + i)) {
+            i++;
+        }
+        return "+Minion" + i;
+    }
+
     public static boolean isMinion(UUID uuid) {
         return MinionPersistentState.INSTANCE.isMinion(uuid);
     }

src/main/java/io/github/skippyall/minions/minion/fakeplayer/EntityPlayerActionPack.java

@@ -281,14 +281,14 @@ public class EntityPlayerActionPack
         else // one slot
         {
             if (selectedSlot == -1)
-                selectedSlot = inv.selectedSlot;
+                selectedSlot = inv.getSelectedSlot();
             dropItemFromSlot(selectedSlot, dropAll);
         }
     }
 
     public void setSlot(int slot)
     {
-        player.getInventory().selectedSlot = slot-1;
+        player.getInventory().setSelectedSlot(slot-1);
         player.networkHandler.sendPacket(new UpdateSelectedSlotS2CPacket(slot-1));
     }
 
@@ -299,7 +299,7 @@ public class EntityPlayerActionPack
                     @Override
                     boolean execute(ServerPlayerEntity player, Action action)
                     {
-                        EntityPlayerActionPack ap = ((ServerPlayerInterface) player).getActionPack();
+                        EntityPlayerActionPack ap = ((ServerPlayerInterface) player).minions$getActionPack();
                         if (ap.itemUseCooldown > 0)
                         {
                             ap.itemUseCooldown--;
@@ -317,11 +317,11 @@ public class EntityPlayerActionPack
                                 case BLOCK:
                                 {
                                     player.updateLastActionTime();
-                                    ServerWorld world = player.getServerWorld();
+                                    ServerWorld world = player.getWorld();
                                     BlockHitResult blockHit = (BlockHitResult) hit;
                                     BlockPos pos = blockHit.getBlockPos();
                                     Direction side = blockHit.getSide();
-                                    if (pos.getY() < player.getServerWorld().getTopYInclusive() - (side == Direction.UP ? 1 : 0) && world.canPlayerModifyAt(player, pos))
+                                    if (pos.getY() < player.getWorld().getTopYInclusive() - (side == Direction.UP ? 1 : 0) && world.canEntityModifyAt(player, pos))
                                     {
                                         ActionResult result = player.interactionManager.interactBlock(player, world, player.getStackInHand(hand), hand, blockHit);
                                         if (result instanceof ActionResult.Success success)
@@ -368,7 +368,7 @@ public class EntityPlayerActionPack
                     @Override
                     void inactiveTick(ServerPlayerEntity player, Action action)
                     {
-                        EntityPlayerActionPack ap = ((ServerPlayerInterface) player).getActionPack();
+                        EntityPlayerActionPack ap = ((ServerPlayerInterface) player).minions$getActionPack();
                         ap.itemUseCooldown = 0;
                         player.stopUsingItem();
                     }
@@ -390,7 +390,7 @@ public class EntityPlayerActionPack
                         return true;
                     }
                     case BLOCK: {
-                        EntityPlayerActionPack ap = ((ServerPlayerInterface) player).getActionPack();
+                        EntityPlayerActionPack ap = ((ServerPlayerInterface) player).minions$getActionPack();
                         if (ap.blockHitDelay > 0)
                         {
                             ap.blockHitDelay--;
@@ -461,7 +461,7 @@ public class EntityPlayerActionPack
             @Override
             void inactiveTick(ServerPlayerEntity player, Action action)
             {
-                EntityPlayerActionPack ap = ((ServerPlayerInterface) player).getActionPack();
+                EntityPlayerActionPack ap = ((ServerPlayerInterface) player).minions$getActionPack();
                 if (ap.currentBlock == null) return;
                 player.getWorld().setBlockBreakingInfo(-1, ap.currentBlock, -1);
                 player.interactionManager.processBlockBreakingAction(ap.currentBlock, PlayerActionC2SPacket.Action.ABORT_DESTROY_BLOCK, Direction.DOWN, player.getWorld().getTopYInclusive(), -1);

src/main/java/io/github/skippyall/minions/minion/fakeplayer/FakeClientConnection.java

@@ -4,7 +4,7 @@ package io.github.skippyall.minions.minion.fakeplayer;
 import io.netty.channel.embedded.EmbeddedChannel;
 import net.minecraft.network.ClientConnection;
 import net.minecraft.network.NetworkSide;
-import net.minecraft.network.NetworkState;
+import net.minecraft.network.state.NetworkState;
 import net.minecraft.network.listener.PacketListener;
 
 public class FakeClientConnection extends ClientConnection {

src/main/java/io/github/skippyall/minions/minion/fakeplayer/MinionFakePlayer.java

@@ -2,7 +2,8 @@
 package io.github.skippyall.minions.minion.fakeplayer;
 
 import com.mojang.authlib.GameProfile;
-import io.github.skippyall.minions.Minions;
+import com.mojang.authlib.properties.PropertyMap;
+import io.github.skippyall.minions.MinionItems;
 import io.github.skippyall.minions.minion.MinionData;
 import io.github.skippyall.minions.gui.MinionGui;
 import io.github.skippyall.minions.minion.MinionItem;
@@ -11,16 +12,15 @@ import io.github.skippyall.minions.minion.MinionProfileUtils;
 import io.github.skippyall.minions.gui.ModuleInventory;
 import io.github.skippyall.minions.program.runtime.MinionRuntime;
 import net.minecraft.block.BlockState;
-import net.minecraft.component.DataComponentTypes;
 import net.minecraft.entity.Entity;
 import net.minecraft.entity.EquipmentSlot;
+import net.minecraft.entity.ItemEntity;
 import net.minecraft.entity.MovementType;
 import net.minecraft.entity.attribute.EntityAttributes;
 import net.minecraft.entity.damage.DamageSource;
 import net.minecraft.entity.player.HungerManager;
 import net.minecraft.entity.player.PlayerEntity;
 import net.minecraft.item.ItemStack;
-import net.minecraft.nbt.NbtCompound;
 import net.minecraft.network.DisconnectionInfo;
 import net.minecraft.network.NetworkSide;
 import net.minecraft.network.packet.c2s.common.SyncedClientOptions;
@@ -32,6 +32,8 @@ import net.minecraft.server.ServerTask;
 import net.minecraft.server.network.ConnectedClientData;
 import net.minecraft.server.network.ServerPlayerEntity;
 import net.minecraft.server.world.ServerWorld;
+import net.minecraft.storage.ReadView;
+import net.minecraft.storage.WriteView;
 import net.minecraft.text.Text;
 import net.minecraft.text.TranslatableTextContent;
 import net.minecraft.util.ActionResult;
@@ -43,12 +45,7 @@ import net.minecraft.world.GameMode;
 import net.minecraft.world.TeleportTarget;
 import org.jetbrains.annotations.Nullable;
 
-import java.util.Optional;
 import java.util.Set;
-import java.util.UUID;
-import java.util.concurrent.CompletableFuture;
-import java.util.function.BiConsumer;
-import java.util.function.Consumer;
 
 public class MinionFakePlayer extends ServerPlayerEntity {
     public Runnable fixStartingPosition = () -> {};
@@ -56,87 +53,59 @@ public class MinionFakePlayer extends ServerPlayerEntity {
     private float moveForward;
     private float moveSideways;
 
-    private boolean programmable;
     private final ModuleInventory moduleInventory = new ModuleInventory();
     private final MinionRuntime runtime = new MinionRuntime(this);
 
-    private UUID skinUuid = null;
+    private final MinionData data;
 
-    public static void createMinion(MinionData data, ServerWorld level, ServerPlayerEntity owner, boolean canProgram, Vec3d pos, Vec2f rot) {
-        spawnMinion(data, level, pos, rot,
-                (minion, skinProfile) -> {
-                    if (skinProfile != null) {
-                        minion.skinUuid = skinProfile.getId();
-                    }
-
-                    minion.programmable = canProgram;
-                },
-                minion -> {
-                    MinionPersistentState.INSTANCE.addMinion(minion);
-                }
-        );
+    public static void spawnMinion(MinionData data, ServerWorld level, @Nullable Vec3d pos, @Nullable Vec2f rot) {
+        spawnMinion(data, level, pos, rot, false);
     }
 
-    public static void spawnMinionAt(MinionData data, ServerWorld level, @Nullable Vec3d pos, @Nullable Vec2f rot) {
-        spawnMinion(data, level, pos, rot, (minion, skinProfile) -> {}, minion -> {});
-    }
+    public static void spawnMinion(MinionData data, ServerWorld level, @Nullable Vec3d pos, @Nullable Vec2f rot, boolean force) {
+        if(!data.isSpawned() || force) {
+            MinecraftServer server = level.getServer();
 
-    public static void spawnMinion(MinionData data, ServerWorld level, @Nullable Vec3d pos, @Nullable Vec2f rot, BiConsumer<MinionFakePlayer, GameProfile> beforeSpawn, Consumer<MinionFakePlayer> afterSpawn) {
-        MinecraftServer server = level.getServer();
+            PropertyMap skin = data.skin().orElse(null);
 
-        CompletableFuture<GameProfile> future;
-        if(data.skinUuid().isPresent()) {
-            future = MinionProfileUtils.getSkinOwnerProfile(server, data.skinUuid().get());
-        } else {
-            future = MinionProfileUtils.lookupSkinOwnerProfile(server, data.name());
+            GameProfile profile = MinionProfileUtils.makeNewMinionProfile(data.uuid(), data.name(), skin);
+            server.send(server.createTask(() -> doSpawn(data, profile, server, level, pos, rot)));
         }
-
-        future.thenAccept((skinProfile) -> {
-            GameProfile profile = MinionProfileUtils.makeNewMinionProfile(data.uuid(), data.name(), skinProfile);
-            Minions.addExecuteOnNextTick(() -> {
-                MinionFakePlayer instance = new MinionFakePlayer(server, level, profile, SyncedClientOptions.createDefault());
-                beforeSpawn.accept(instance, skinProfile);
-
-                if(pos != null && rot != null) {
-                    instance.fixStartingPosition = () -> instance.refreshPositionAndAngles(pos.x, pos.y, pos.z, rot.x, rot.y);
-                }
-                server.getPlayerManager().onPlayerConnect(new FakeClientConnection(NetworkSide.SERVERBOUND), instance, new ConnectedClientData(profile, 0, instance.getClientOptions(), false));
-                System.out.println(instance.getPos());
-                if(pos != null && rot != null) {
-                    instance.teleport(level, pos.x, pos.y, pos.z, Set.of(), rot.x, rot.y, true);
-                }
-                instance.setVelocity(0,0,0);
-                instance.setHealth(20.0F);
-                instance.unsetRemoved();
-                instance.getAttributeInstance(EntityAttributes.STEP_HEIGHT).setBaseValue(0.6F);
-                instance.interactionManager.changeGameMode(GameMode.SURVIVAL);
-                server.getPlayerManager().sendToDimension(new EntitySetHeadYawS2CPacket(instance, (byte) (instance.headYaw * 256 / 360)), level.getRegistryKey());//instance.dimension);
-                server.getPlayerManager().sendToDimension(EntityPositionSyncS2CPacket.create(instance), level.getRegistryKey());//instance.dimension);
-                //instance.world.getChunkManager(). updatePosition(instance);
-                instance.dataTracker.set(PLAYER_MODEL_PARTS, (byte) 0x7f); // show all model layers (incl. capes)
-                instance.getAbilities().flying = false;
-
-                afterSpawn.accept(instance);
-            });
-        });
     }
 
-    public static MinionFakePlayer respawnFake(MinecraftServer server, ServerWorld level, GameProfile profile, SyncedClientOptions cli)
+    private static void doSpawn(MinionData data, GameProfile profile, MinecraftServer server, ServerWorld level, @Nullable Vec3d pos, @Nullable Vec2f rot) {
+        MinionFakePlayer instance = new MinionFakePlayer(server, level, profile, SyncedClientOptions.createDefault(), data);
+        MinionPersistentState.INSTANCE.updateMinionData(data.withSpawned(true));
+
+        if(pos != null && rot != null) {
+            instance.fixStartingPosition = () -> instance.refreshPositionAndAngles(pos.x, pos.y, pos.z, rot.x, rot.y);
+        }
+        server.getPlayerManager().onPlayerConnect(new FakeClientConnection(NetworkSide.SERVERBOUND), instance, new ConnectedClientData(profile, 0, instance.getClientOptions(), false));
+        System.out.println(instance.getPos());
+        if(pos != null && rot != null) {
+            instance.teleport(level, pos.x, pos.y, pos.z, Set.of(), rot.x, rot.y, true);
+        }
+        instance.setVelocity(0,0,0);
+        instance.setHealth(20.0F);
+        instance.unsetRemoved();
+        instance.getAttributeInstance(EntityAttributes.STEP_HEIGHT).setBaseValue(0.6F);
+        instance.interactionManager.changeGameMode(GameMode.SURVIVAL);
+        server.getPlayerManager().sendToDimension(new EntitySetHeadYawS2CPacket(instance, (byte) (instance.headYaw * 256 / 360)), level.getRegistryKey());//instance.dimension);
+        server.getPlayerManager().sendToDimension(EntityPositionSyncS2CPacket.create(instance), level.getRegistryKey());//instance.dimension);
+        //instance.world.getChunkManager(). updatePosition(instance);
+        instance.dataTracker.set(PLAYER_MODEL_PARTS, (byte) 0x7f); // show all model layers (incl. capes)
+        instance.getAbilities().flying = false;
+    }
+
+    public static MinionFakePlayer respawnFake(MinecraftServer server, ServerWorld level, GameProfile profile, SyncedClientOptions cli, MinionData data)
     {
-        return new MinionFakePlayer(server, level, profile, cli);
+        return new MinionFakePlayer(server, level, profile, cli, data);
     }
 
-    private MinionFakePlayer(MinecraftServer server, ServerWorld worldIn, GameProfile profile, SyncedClientOptions cli)
+    private MinionFakePlayer(MinecraftServer server, ServerWorld worldIn, GameProfile profile, SyncedClientOptions cli, MinionData data)
     {
         super(server, worldIn, profile, cli);
-    }
-
-    public boolean isProgrammable() {
-        return programmable;
-    }
-
-    public void setProgrammable(boolean programmable) {
-        this.programmable = programmable;
+        this.data = data;
     }
 
     public ModuleInventory getModuleInventory() {
@@ -148,7 +117,7 @@ public class MinionFakePlayer extends ServerPlayerEntity {
     }
 
     public EntityPlayerActionPack getMinionActionPack() {
-        return ((ServerPlayerInterface)this).getActionPack();
+        return ((ServerPlayerInterface)this).minions$getActionPack();
     }
 
     @Override
@@ -183,12 +152,12 @@ public class MinionFakePlayer extends ServerPlayerEntity {
         if (reason.getContent() instanceof TranslatableTextContent text && text.getKey().equals("multiplayer.disconnect.duplicate_login")) {
             this.networkHandler.onDisconnected(new DisconnectionInfo(reason));
         } else {
-            this.server.send(new ServerTask(this.server.getTicks(), () -> {
+            this.getServer().send(new ServerTask(this.getServer().getTicks(), () -> {
                 this.networkHandler.onDisconnected(new DisconnectionInfo(reason));
             }));
         }
 
-        MinionPersistentState.INSTANCE.removeMinion(this);
+        MinionPersistentState.INSTANCE.updateMinionData(data.withSpawned(false));
     }
 
     @Override
@@ -197,7 +166,7 @@ public class MinionFakePlayer extends ServerPlayerEntity {
         if (this.getServer().getTicks() % 10 == 0)
         {
             this.networkHandler.syncWithPlayerPosition();
-            this.getServerWorld().getChunkManager().updatePosition(this);
+            this.getWorld().getChunkManager().updatePosition(this);
         }
         try
         {
@@ -306,37 +275,31 @@ public class MinionFakePlayer extends ServerPlayerEntity {
     @Override
     public void drop(ServerWorld world, DamageSource damageSource) {
         super.drop(world, damageSource);
-        dropStack(world, toItemStack()).setNeverDespawn();
+        ItemEntity entity = dropStack(world, toItemStack());
+        if (entity != null) {
+            entity.setNeverDespawn();
+        }
     }
 
     private ItemStack toItemStack() {
-        ItemStack stack = new ItemStack(Minions.MINION_ITEM);
-        MinionItem.setData(MinionData.fromMinion(this), stack);
-        if (!getMinionName().equals("Minion")) {
-            stack.set(DataComponentTypes.CUSTOM_NAME, Text.of(getMinionName()));
-        }
+        ItemStack stack = new ItemStack(MinionItems.MINION_ITEM);
+        MinionItem.setData(data, stack);
         return stack;
     }
 
-    @Override
-    public void writeCustomDataToNbt(NbtCompound nbt) {
-        super.writeCustomDataToNbt(nbt);
-        nbt.put("modules", moduleInventory.writeNbt(new NbtCompound(), getRegistryManager()));
-        nbt.putBoolean("programmable", programmable);
+    public MinionData getData() {
+        return data;
     }
 
     @Override
-    public void readCustomDataFromNbt(NbtCompound nbt) {
-        super.readCustomDataFromNbt(nbt);
-        moduleInventory.readNbt(nbt.getCompound("modules"), getRegistryManager());
-        programmable = nbt.getBoolean("programmable");
+    public void writeCustomData(WriteView view) {
+        super.writeCustomData(view);
+        moduleInventory.writeData(view.get("modules"));
     }
 
-    public String getMinionName() {
-        return getGameProfile().getName();
-    }
-
-    public Optional<UUID> getSkinUuid() {
-        return Optional.ofNullable(skinUuid);
+    @Override
+    public void readCustomData(ReadView view) {
+        super.readCustomData(view);
+        moduleInventory.readData(view.getReadView("modules"));
     }
 }

src/main/java/io/github/skippyall/minions/minion/fakeplayer/NetHandlerPlayServerFake.java

@@ -38,9 +38,9 @@ public class NetHandlerPlayServerFake extends ServerPlayNetworkHandler
     public void requestTeleport(PlayerPosition pos, Set<PositionFlag> set)
     {
         super.requestTeleport(pos, set);
-        if (player.getServerWorld().getPlayerByUuid(player.getUuid()) != null) {
+        if (player.getWorld().getPlayerByUuid(player.getUuid()) != null) {
             syncWithPlayerPosition();
-            player.getServerWorld().getChunkManager().updatePosition(player);
+            player.getWorld().getChunkManager().updatePosition(player);
         }
     }
 

src/main/java/io/github/skippyall/minions/minion/fakeplayer/ServerPlayerInterface.java

@@ -3,5 +3,5 @@ package io.github.skippyall.minions.minion.fakeplayer;
 
 public interface ServerPlayerInterface
 {
-    EntityPlayerActionPack getActionPack();
+    EntityPlayerActionPack minions$getActionPack();
 }

src/main/java/io/github/skippyall/minions/minion/skin/Base64SkinProvider.java

@@ -0,0 +1,27 @@
+package io.github.skippyall.minions.minion.skin;
+
+import com.mojang.authlib.properties.Property;
+import com.mojang.authlib.properties.PropertyMap;
+import io.github.skippyall.minions.input.TextInput;
+import net.minecraft.server.network.ServerPlayerEntity;
+import net.minecraft.text.Text;
+
+import java.util.Optional;
+import java.util.concurrent.CompletableFuture;
+
+public class Base64SkinProvider implements SkinProvider {
+    @Override
+    public CompletableFuture<Optional<PropertyMap>> openSkinMenu(ServerPlayerEntity player) {
+        return TextInput.inputString(player, Text.translatable("minions.gui.look.skin.base64.title"), "")
+                .thenApply(base64String -> {
+                    PropertyMap map = new PropertyMap();
+                    map.put("textures", new Property("textures", base64String));
+                    return Optional.of(map);
+                });
+    }
+
+    @Override
+    public Text getDisplayName() {
+        return Text.translatable("minions.gui.look.skin.base64");
+    }
+}

src/main/java/io/github/skippyall/minions/minion/skin/NameSkinProvider.java

@@ -0,0 +1,25 @@
+package io.github.skippyall.minions.minion.skin;
+
+import com.mojang.authlib.GameProfile;
+import com.mojang.authlib.properties.PropertyMap;
+import io.github.skippyall.minions.input.TextInput;
+import net.minecraft.block.entity.SkullBlockEntity;
+import net.minecraft.server.network.ServerPlayerEntity;
+import net.minecraft.text.Text;
+
+import java.util.Optional;
+import java.util.concurrent.CompletableFuture;
+
+public class NameSkinProvider implements SkinProvider {
+    @Override
+    public CompletableFuture<Optional<PropertyMap>> openSkinMenu(ServerPlayerEntity player) {
+        return TextInput.inputString(player, Text.translatable("minions.gui.look.skin.name.title"), "")
+                .thenCompose(SkullBlockEntity::fetchProfileByName)
+                .thenApply(gameProfile -> gameProfile.map(GameProfile::getProperties));
+    }
+
+    @Override
+    public Text getDisplayName() {
+        return Text.translatable("minions.gui.look.skin.name");
+    }
+}

src/main/java/io/github/skippyall/minions/minion/skin/SkinProvider.java

@@ -0,0 +1,14 @@
+package io.github.skippyall.minions.minion.skin;
+
+import com.mojang.authlib.properties.PropertyMap;
+import net.minecraft.server.network.ServerPlayerEntity;
+import net.minecraft.text.Text;
+
+import java.util.Optional;
+import java.util.concurrent.CompletableFuture;
+
+public interface SkinProvider {
+    CompletableFuture<Optional<PropertyMap>> openSkinMenu(ServerPlayerEntity player);
+
+    Text getDisplayName();
+}

src/main/java/io/github/skippyall/minions/minion/skin/SkinProviders.java

@@ -0,0 +1,25 @@
+package io.github.skippyall.minions.minion.skin;
+
+import com.mojang.serialization.Lifecycle;
+import io.github.skippyall.minions.Minions;
+import net.minecraft.registry.Registry;
+import net.minecraft.registry.RegistryKey;
+import net.minecraft.registry.SimpleRegistry;
+import net.minecraft.util.Identifier;
+
+public class SkinProviders {
+    public static final Registry<SkinProvider> SKIN_PROVIDERS = new SimpleRegistry<>(RegistryKey.ofRegistry(Identifier.of(Minions.MOD_ID, "skin_providers")), Lifecycle.stable());
+
+    public static NameSkinProvider NAME = register(new NameSkinProvider(), "name");
+    public static UUIDSkinProvider UUID = register(new UUIDSkinProvider(), "uuid");
+    public static Base64SkinProvider BASE64 = register(new Base64SkinProvider(), "base64");
+
+
+    public static <T extends SkinProvider> T register(T skinProvider, String path) {
+        return Registry.register(SKIN_PROVIDERS, Identifier.of(Minions.MOD_ID, path), skinProvider);
+    }
+
+    public static void register() {
+
+    }
+}

src/main/java/io/github/skippyall/minions/minion/skin/UUIDSkinProvider.java

@@ -0,0 +1,32 @@
+package io.github.skippyall.minions.minion.skin;
+
+import com.mojang.authlib.GameProfile;
+import com.mojang.authlib.properties.PropertyMap;
+import com.mojang.serialization.Codec;
+import com.mojang.serialization.codecs.RecordCodecBuilder;
+import io.github.skippyall.minions.input.TextInput;
+import io.github.skippyall.minions.minion.MinionProfileUtils;
+import net.minecraft.block.entity.SkullBlockEntity;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.server.network.ServerPlayerEntity;
+import net.minecraft.text.Text;
+import net.minecraft.util.Uuids;
+import net.minecraft.util.dynamic.Codecs;
+
+import java.util.Optional;
+import java.util.UUID;
+import java.util.concurrent.CompletableFuture;
+
+public class UUIDSkinProvider implements SkinProvider {
+    @Override
+    public CompletableFuture<Optional<PropertyMap>> openSkinMenu(ServerPlayerEntity player) {
+        return TextInput.inputString(player, Text.translatable("minions.gui.look.skin.uuid.title"), "")
+                .thenCompose(uuidString -> SkullBlockEntity.fetchProfileByUuid(UUID.fromString(uuidString)))
+                .thenApply(gameProfile -> gameProfile.map(GameProfile::getProperties));
+    }
+
+    @Override
+    public Text getDisplayName() {
+        return Text.translatable("minions.gui.look.skin.uuid");
+    }
+}

src/main/java/io/github/skippyall/minions/mixinhelper/ChunkLevelManager$DistanceFromNearestPlayerTrackerAccessor.java

@@ -1,6 +1,6 @@
 package io.github.skippyall.minions.mixinhelper;
 
-public interface ChunkTicketManager$DistanceFromNearestPlayerTrackerAccessor {
+public interface ChunkLevelManager$DistanceFromNearestPlayerTrackerAccessor {
     void minions$markAsMinionless();
     void minions$markAsTarget();
     int minions$getTickedChunkCount();

src/main/java/io/github/skippyall/minions/mixinhelper/ChunkLevelManagerAccessor.java

@@ -0,0 +1,11 @@
+package io.github.skippyall.minions.mixinhelper;
+
+import it.unimi.dsi.fastutil.objects.ObjectSet;
+import net.minecraft.server.network.ServerPlayerEntity;
+import net.minecraft.server.world.ChunkLevelManager;
+
+public interface ChunkLevelManagerAccessor {
+    ObjectSet<ServerPlayerEntity> minions$getPlayers(long chunkpos);
+
+    ChunkLevelManager.DistanceFromNearestPlayerTracker minions$getMinionless();
+}

src/main/java/io/github/skippyall/minions/mixinhelper/ChunkTicketManagerAccessor.java

@@ -1,11 +0,0 @@
-package io.github.skippyall.minions.mixinhelper;
-
-import it.unimi.dsi.fastutil.objects.ObjectSet;
-import net.minecraft.server.network.ServerPlayerEntity;
-import net.minecraft.server.world.ChunkTicketManager;
-
-public interface ChunkTicketManagerAccessor {
-    ObjectSet<ServerPlayerEntity> getPlayers(long chunkpos);
-
-    ChunkTicketManager.DistanceFromNearestPlayerTracker getMinionless();
-}

src/main/java/io/github/skippyall/minions/mixinhelper/EntityViewMixinHelper.java

@@ -0,0 +1,9 @@
+package io.github.skippyall.minions.mixinhelper;
+
+import net.minecraft.entity.Entity;
+
+import java.util.function.Predicate;
+
+public class EntityViewMixinHelper {
+    public static final ThreadLocal<Predicate<Entity>> ADDITIONAL_PREDICATE = ThreadLocal.withInitial(() -> entity -> true);
+}

src/main/java/io/github/skippyall/minions/mixins/ChunkTicketManagerFixMixin.java

@@ -3,11 +3,12 @@ package io.github.skippyall.minions.mixins;
 import com.llamalad7.mixinextras.injector.wrapoperation.Operation;
 import com.llamalad7.mixinextras.injector.wrapoperation.WrapOperation;
 import it.unimi.dsi.fastutil.objects.ObjectSet;
+import net.minecraft.server.world.ChunkLevelManager;
 import net.minecraft.server.world.ChunkTicketManager;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.injection.At;
 
-@Mixin(value = ChunkTicketManager.class)
+@Mixin(value = ChunkLevelManager.class)
 public class ChunkTicketManagerFixMixin {
     @WrapOperation(method = "handleChunkLeave", at = @At(value = "INVOKE", target = "Lit/unimi/dsi/fastutil/objects/ObjectSet;remove(Ljava/lang/Object;)Z", remap = false))
     public boolean filterIfNull(ObjectSet instance, Object o, Operation<Boolean> original) {

src/main/java/io/github/skippyall/minions/mixins/EntityViewMixin.java

@@ -0,0 +1,24 @@
+package io.github.skippyall.minions.mixins;
+
+import io.github.skippyall.minions.mixinhelper.EntityViewMixinHelper;
+import net.minecraft.entity.Entity;
+import net.minecraft.world.EntityView;
+import org.jetbrains.annotations.Nullable;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.ModifyArg;
+
+import java.util.function.Predicate;
+
+@Mixin(EntityView.class)
+public interface EntityViewMixin {
+    @ModifyArg(method = "getClosestPlayer(DDDDZ)Lnet/minecraft/entity/player/PlayerEntity;", at = @At(value = "INVOKE", target = "Lnet/minecraft/world/EntityView;getClosestPlayer(DDDDLjava/util/function/Predicate;)Lnet/minecraft/entity/player/PlayerEntity;"))
+    private @Nullable Predicate<Entity> addMinionPredicate(@Nullable Predicate<Entity> targetPredicate) {
+        Predicate<Entity> predicate = EntityViewMixinHelper.ADDITIONAL_PREDICATE.get();
+        if(targetPredicate != null) {
+            return predicate.and(targetPredicate);
+        } else {
+            return predicate;
+        }
+    }
+}

src/main/java/io/github/skippyall/minions/mixins/MobEntityMixin.java

@@ -1,29 +1,30 @@
 package io.github.skippyall.minions.mixins;
 
+import com.llamalad7.mixinextras.injector.wrapoperation.Operation;
+import com.llamalad7.mixinextras.injector.wrapoperation.WrapOperation;
 import io.github.skippyall.minions.minion.fakeplayer.MinionFakePlayer;
+import io.github.skippyall.minions.mixinhelper.EntityViewMixinHelper;
 import io.github.skippyall.minions.module.MobSpawningModule;
 import net.minecraft.entity.Entity;
 import net.minecraft.entity.mob.MobEntity;
 import net.minecraft.entity.player.PlayerEntity;
-import net.minecraft.predicate.entity.EntityPredicates;
-import net.minecraft.server.network.ServerPlayerEntity;
 import net.minecraft.world.World;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Redirect;
 
 @Mixin(MobEntity.class)
 public abstract class MobEntityMixin {
-    @Redirect(method = "checkDespawn", at = @At(value = "INVOKE", target = "Lnet/minecraft/world/World;getClosestPlayer(Lnet/minecraft/entity/Entity;D)Lnet/minecraft/entity/player/PlayerEntity;"))
-    public PlayerEntity checkMobDespawningMinion(World instance, Entity entity, double maxDistance) {
-        return instance.getClosestPlayer(entity.getX(), entity.getY(), entity.getZ(), maxDistance, EntityPredicates.EXCEPT_SPECTATOR.and(entity1 -> {
-            if(entity1 instanceof ServerPlayerEntity player) {
-                if(player instanceof MinionFakePlayer minion) {
-                    return MobSpawningModule.canMinionDespawnMobs(minion);
-                }
+    @WrapOperation(method = "checkDespawn", at = @At(value = "INVOKE", target = "Lnet/minecraft/world/World;getClosestPlayer(Lnet/minecraft/entity/Entity;D)Lnet/minecraft/entity/player/PlayerEntity;"))
+    public PlayerEntity checkMobDespawningMinion(World instance, Entity entity, double maxDistance, Operation<PlayerEntity> original) {
+        EntityViewMixinHelper.ADDITIONAL_PREDICATE.set(entity2 -> {
+            if(entity2 instanceof MinionFakePlayer minion) {
+                return MobSpawningModule.canMinionDespawnMobs(minion);
+            } else {
                 return true;
             }
-            return false;
-        }));
+        });
+        PlayerEntity player = original.call(instance, entity, maxDistance);
+        EntityViewMixinHelper.ADDITIONAL_PREDICATE.remove();
+        return player;
     }
 }

src/main/java/io/github/skippyall/minions/mixins/PlayerListEntryS2CPacket$EntryMixin.java

@@ -10,7 +10,7 @@ import org.spongepowered.asm.mixin.injection.ModifyArg;
 
 @Mixin(PlayerListS2CPacket.Entry.class)
 public class PlayerListEntryS2CPacket$EntryMixin {
-    @ModifyArg(method = "<init>(Lnet/minecraft/server/network/ServerPlayerEntity;)V", at = @At(value = "INVOKE", target = "Lnet/minecraft/network/packet/s2c/play/PlayerListS2CPacket$Entry;<init>(Ljava/util/UUID;Lcom/mojang/authlib/GameProfile;ZILnet/minecraft/world/GameMode;Lnet/minecraft/text/Text;ILnet/minecraft/network/encryption/PublicPlayerSession$Serialized;)V"))
+    @ModifyArg(method = "<init>(Lnet/minecraft/server/network/ServerPlayerEntity;)V", at = @At(value = "INVOKE", target = "Lnet/minecraft/network/packet/s2c/play/PlayerListS2CPacket$Entry;<init>(Ljava/util/UUID;Lcom/mojang/authlib/GameProfile;ZILnet/minecraft/world/GameMode;Lnet/minecraft/text/Text;ZILnet/minecraft/network/encryption/PublicPlayerSession$Serialized;)V"), index = 2)
     private static boolean removeMinionFromTabList(boolean original, @Local(argsOnly = true) ServerPlayerEntity player) {
         if(player instanceof MinionFakePlayer) {
             return false;

src/main/java/io/github/skippyall/minions/mixins/PlayerListMixin.java

@@ -17,7 +17,9 @@ import net.minecraft.server.network.ConnectedClientData;
 import net.minecraft.server.network.ServerPlayNetworkHandler;
 import net.minecraft.server.network.ServerPlayerEntity;
 import net.minecraft.server.world.ServerWorld;
+import net.minecraft.storage.ReadView;
 import net.minecraft.text.Text;
+import net.minecraft.util.ErrorReporter;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
@@ -25,17 +27,18 @@ import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Optional;
 import java.util.stream.Collectors;
 
 @Mixin(PlayerManager.class)
 public class PlayerListMixin {
 
     @Inject(method = "loadPlayerData", at = @At(value = "RETURN", shift = At.Shift.BEFORE))
-    private void fixStartingPos(ServerPlayerEntity serverPlayerEntity_1, CallbackInfoReturnable<NbtCompound> cir)
+    private void fixStartingPos(ServerPlayerEntity player, ErrorReporter errorReporter, CallbackInfoReturnable<Optional<ReadView>> cir)
     {
-        if (serverPlayerEntity_1 instanceof MinionFakePlayer)
+        if (player instanceof MinionFakePlayer)
         {
-            ((MinionFakePlayer) serverPlayerEntity_1).fixStartingPosition.run();
+            ((MinionFakePlayer) player).fixStartingPosition.run();
         }
     }
 
@@ -52,7 +55,7 @@ public class PlayerListMixin {
     @WrapOperation(method = "respawnPlayer", at = @At(value = "NEW", target = "(Lnet/minecraft/server/MinecraftServer;Lnet/minecraft/server/world/ServerWorld;Lcom/mojang/authlib/GameProfile;Lnet/minecraft/network/packet/c2s/common/SyncedClientOptions;)Lnet/minecraft/server/network/ServerPlayerEntity;"))
     public ServerPlayerEntity makePlayerForRespawn(MinecraftServer minecraftServer, ServerWorld serverLevel, GameProfile gameProfile, SyncedClientOptions clientInformation, Operation<ServerPlayerEntity> original, ServerPlayerEntity serverPlayer, boolean bl) {
         if (serverPlayer instanceof MinionFakePlayer minion) {
-            return MinionFakePlayer.respawnFake(minecraftServer, serverLevel, gameProfile, clientInformation);
+            return MinionFakePlayer.respawnFake(minecraftServer, serverLevel, gameProfile, clientInformation, minion.getData());
         }
         return original.call(minecraftServer, serverLevel, gameProfile, clientInformation);
     }

src/main/java/io/github/skippyall/minions/mixins/ServerPlayerMixin.java

@@ -18,7 +18,7 @@ public abstract class ServerPlayerMixin implements ServerPlayerInterface {
     @Unique
     public EntityPlayerActionPack actionPack;
     @Override
-    public EntityPlayerActionPack getActionPack()
+    public EntityPlayerActionPack minions$getActionPack()
     {
         return actionPack;
     }

src/main/java/io/github/skippyall/minions/mixins/antimobcap/ChunkLevelManager$DistanceFromNearestPlayerTrackerMixin.java

@@ -1,12 +1,13 @@
 package io.github.skippyall.minions.mixins.antimobcap;
 
 import io.github.skippyall.minions.minion.fakeplayer.MinionFakePlayer;
-import io.github.skippyall.minions.mixinhelper.ChunkTicketManager$DistanceFromNearestPlayerTrackerAccessor;
-import io.github.skippyall.minions.mixinhelper.ChunkTicketManagerAccessor;
+import io.github.skippyall.minions.mixinhelper.ChunkLevelManager$DistanceFromNearestPlayerTrackerAccessor;
+import io.github.skippyall.minions.mixinhelper.ChunkLevelManagerAccessor;
 import io.github.skippyall.minions.module.MobSpawningModule;
 import it.unimi.dsi.fastutil.longs.Long2ByteMap;
 import it.unimi.dsi.fastutil.objects.ObjectSet;
 import net.minecraft.server.network.ServerPlayerEntity;
+import net.minecraft.server.world.ChunkLevelManager;
 import net.minecraft.server.world.ChunkTicketManager;
 import org.spongepowered.asm.mixin.Final;
 import org.spongepowered.asm.mixin.Mixin;
@@ -17,11 +18,11 @@ import org.spongepowered.asm.mixin.injection.Inject;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
 
-@Mixin(value = ChunkTicketManager.DistanceFromNearestPlayerTracker.class)
-public abstract class ChunkTicketManager$DistanceFromNearestPlayerTrackerMixin extends ChunkPosDistanceLevelPropagatorMixin implements ChunkTicketManager$DistanceFromNearestPlayerTrackerAccessor {
+@Mixin(value = ChunkLevelManager.DistanceFromNearestPlayerTracker.class)
+public abstract class ChunkLevelManager$DistanceFromNearestPlayerTrackerMixin extends ChunkPosDistanceLevelPropagatorMixin implements ChunkLevelManager$DistanceFromNearestPlayerTrackerAccessor {
     @Final
     @Shadow
-    ChunkTicketManager field_17462;
+    ChunkLevelManager field_17462;
 
     @Shadow
     @Final
@@ -41,7 +42,7 @@ public abstract class ChunkTicketManager$DistanceFromNearestPlayerTrackerMixin e
 
     @Override
     public boolean minions$isRealPlayerInChunk(long chunkPos) {
-        ObjectSet<ServerPlayerEntity> players = ((ChunkTicketManagerAccessor)field_17462).getPlayers(chunkPos);
+        ObjectSet<ServerPlayerEntity> players = ((ChunkLevelManagerAccessor)field_17462).minions$getPlayers(chunkPos);
         boolean contains = false;
         if(players != null) {
             contains = players.stream().anyMatch(player -> {
@@ -57,14 +58,14 @@ public abstract class ChunkTicketManager$DistanceFromNearestPlayerTrackerMixin e
     @Inject(method = "updateLevels", at = @At("HEAD"))
     public void minions$sync(CallbackInfo info) {
         if (minions$target) {
-            ((ChunkTicketManagerAccessor)field_17462).getMinionless().updateLevels();
+            ((ChunkLevelManagerAccessor)field_17462).minions$getMinionless().updateLevels();
         }
     }
 
     @Override
     public void minions$updateLevel(long chunkPos, int distance, boolean decrease, CallbackInfo info) {
         if (minions$target && (distance == Integer.MAX_VALUE || minions$isRealPlayerInChunk(chunkPos))) {
-            ((ChunkTicketManagerAccessor)field_17462).getMinionless().updateLevel(chunkPos, distance, decrease);
+            ((ChunkLevelManagerAccessor)field_17462).minions$getMinionless().updateLevel(chunkPos, distance, decrease);
         }
     }
 

src/main/java/io/github/skippyall/minions/mixins/antimobcap/ChunkLevelManagerMixin.java

@@ -1,48 +1,51 @@
 package io.github.skippyall.minions.mixins.antimobcap;
 
 import com.llamalad7.mixinextras.sugar.Local;
-import io.github.skippyall.minions.mixinhelper.ChunkTicketManager$DistanceFromNearestPlayerTrackerAccessor;
-import io.github.skippyall.minions.mixinhelper.ChunkTicketManagerAccessor;
+import io.github.skippyall.minions.mixinhelper.ChunkLevelManager$DistanceFromNearestPlayerTrackerAccessor;
+import io.github.skippyall.minions.mixinhelper.ChunkLevelManagerAccessor;
 import it.unimi.dsi.fastutil.longs.Long2ObjectMap;
 import it.unimi.dsi.fastutil.objects.ObjectSet;
 import net.minecraft.server.network.ServerPlayerEntity;
+import net.minecraft.server.world.ChunkLevelManager;
 import net.minecraft.server.world.ChunkTicketManager;
 import net.minecraft.util.math.ChunkSectionPos;
 import org.spongepowered.asm.mixin.Final;
 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.concurrent.Executor;
 
-@Mixin(ChunkTicketManager.class)
-public class ChunkTicketManagerMixin implements ChunkTicketManagerAccessor {
+@Mixin(ChunkLevelManager.class)
+public class ChunkLevelManagerMixin implements ChunkLevelManagerAccessor {
     @Shadow @Final private Long2ObjectMap<ObjectSet<ServerPlayerEntity>> playersByChunkPos;
-    @Shadow @Final private ChunkTicketManager.DistanceFromNearestPlayerTracker distanceFromNearestPlayerTracker;
-    ChunkTicketManager.DistanceFromNearestPlayerTracker minionless;
+    @Shadow @Final private ChunkLevelManager.DistanceFromNearestPlayerTracker distanceFromNearestPlayerTracker;
+    @Unique
+    ChunkLevelManager.DistanceFromNearestPlayerTracker minionless;
 
     @Inject(method = "<init>", at = @At("RETURN"))
-    public void createMinionlessClone(Executor workerExecutor, Executor mainThreadExecutor, CallbackInfo ci) {
-        ChunkTicketManager manager = ((ChunkTicketManager)(Object)this);
+    public void createMinionlessClone(ChunkTicketManager ticketManager, Executor executor, Executor mainThreadExecutor, CallbackInfo ci) {
+        ChunkLevelManager manager = ((ChunkLevelManager)(Object)this);
         minionless = manager.new DistanceFromNearestPlayerTracker(8);
-        ((ChunkTicketManager$DistanceFromNearestPlayerTrackerAccessor)minionless).minions$markAsMinionless();
-        ((ChunkTicketManager$DistanceFromNearestPlayerTrackerAccessor)distanceFromNearestPlayerTracker).minions$markAsTarget();
+        ((ChunkLevelManager$DistanceFromNearestPlayerTrackerAccessor)minionless).minions$markAsMinionless();
+        ((ChunkLevelManager$DistanceFromNearestPlayerTrackerAccessor)distanceFromNearestPlayerTracker).minions$markAsTarget();
     }
 
-    public ObjectSet<ServerPlayerEntity> getPlayers(long chunkpos) {
+    public ObjectSet<ServerPlayerEntity> minions$getPlayers(long chunkpos) {
         return playersByChunkPos.get(chunkpos);
     }
 
     @Override
-    public ChunkTicketManager.DistanceFromNearestPlayerTracker getMinionless() {
+    public ChunkLevelManager.DistanceFromNearestPlayerTracker minions$getMinionless() {
         return minionless;
     }
 
     @Inject(method = "handleChunkLeave", at = @At(value = "INVOKE", target = "Lit/unimi/dsi/fastutil/objects/ObjectSet;remove(Ljava/lang/Object;)Z", shift = At.Shift.AFTER, remap = false))
     public void minion$updateMinionlessIfNoMinionInChunk(ChunkSectionPos pos, ServerPlayerEntity player, CallbackInfo ci, @Local long chunk) {
-        if (!((ChunkTicketManager$DistanceFromNearestPlayerTrackerAccessor)minionless).minions$isRealPlayerInChunk(chunk)) {
+        if (!((ChunkLevelManager$DistanceFromNearestPlayerTrackerAccessor)minionless).minions$isRealPlayerInChunk(chunk)) {
             minionless.updateLevel(chunk, Integer.MAX_VALUE, false);
         }
     }

src/main/java/io/github/skippyall/minions/mixins/antimobcap/ChunkPosDistanceLevelPropagatorMixin.java

@@ -1,11 +1,12 @@
 package io.github.skippyall.minions.mixins.antimobcap;
 
+import net.minecraft.server.world.ChunkPosDistanceLevelPropagator;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 
-@Mixin(net.minecraft.world.ChunkPosDistanceLevelPropagator.class)
+@Mixin(ChunkPosDistanceLevelPropagator.class)
 public class ChunkPosDistanceLevelPropagatorMixin {
     @Inject(method = "updateLevel", at = @At("HEAD"))
     public void minions$updateLevel(long chunkPos, int distance, boolean decrease, CallbackInfo info) {

src/main/java/io/github/skippyall/minions/mixins/antimobcap/ServerChunkManagerMixin.java

@@ -1,7 +1,8 @@
 package io.github.skippyall.minions.mixins.antimobcap;
 
-import io.github.skippyall.minions.mixinhelper.ChunkTicketManager$DistanceFromNearestPlayerTrackerAccessor;
-import io.github.skippyall.minions.mixinhelper.ChunkTicketManagerAccessor;
+import io.github.skippyall.minions.mixinhelper.ChunkLevelManager$DistanceFromNearestPlayerTrackerAccessor;
+import io.github.skippyall.minions.mixinhelper.ChunkLevelManagerAccessor;
+import net.minecraft.server.world.ChunkLevelManager;
 import net.minecraft.server.world.ChunkTicketManager;
 import net.minecraft.server.world.ServerChunkManager;
 import org.spongepowered.asm.mixin.Final;
@@ -14,10 +15,10 @@ import org.spongepowered.asm.mixin.injection.ModifyArg;
 public class ServerChunkManagerMixin {
     @Shadow
     @Final
-    private ChunkTicketManager ticketManager;
+    private ChunkLevelManager levelManager;
 
-    @ModifyArg(method = "tickChunks(Lnet/minecraft/util/profiler/Profiler;JLjava/util/List;)V", at = @At(value = "INVOKE", target = "Lnet/minecraft/world/SpawnHelper;setupSpawn(ILjava/lang/Iterable;Lnet/minecraft/world/SpawnHelper$ChunkSource;Lnet/minecraft/world/SpawnDensityCapper;)Lnet/minecraft/world/SpawnHelper$Info;"))
+    @ModifyArg(method = "tickChunks(Lnet/minecraft/util/profiler/Profiler;J)V", at = @At(value = "INVOKE", target = "Lnet/minecraft/world/SpawnHelper;setupSpawn(ILjava/lang/Iterable;Lnet/minecraft/world/SpawnHelper$ChunkSource;Lnet/minecraft/world/SpawnDensityCapper;)Lnet/minecraft/world/SpawnHelper$Info;"))
     public int useMinionless(int spawningChunkCount) {
-        return ((ChunkTicketManager$DistanceFromNearestPlayerTrackerAccessor)((ChunkTicketManagerAccessor)ticketManager).getMinionless()).minions$getTickedChunkCount();
+        return ((ChunkLevelManager$DistanceFromNearestPlayerTrackerAccessor)((ChunkLevelManagerAccessor)levelManager).minions$getMinionless()).minions$getTickedChunkCount();
     }
 }

src/main/java/io/github/skippyall/minions/module/ActionModules.java

@@ -2,10 +2,10 @@ package io.github.skippyall.minions.module;
 
 import eu.pb4.sgui.api.elements.GuiElementBuilder;
 import eu.pb4.sgui.api.gui.SimpleGui;
-import io.github.skippyall.minions.command.CommandExecutor;
+import io.github.skippyall.minions.module.command.CommandExecutor;
+import io.github.skippyall.minions.input.TextInput;
 import io.github.skippyall.minions.minion.fakeplayer.EntityPlayerActionPack;
 import io.github.skippyall.minions.minion.fakeplayer.MinionFakePlayer;
-import io.github.skippyall.minions.input.TextInput;
 import net.minecraft.item.Items;
 import net.minecraft.screen.ScreenHandlerType;
 import net.minecraft.server.network.ServerPlayerEntity;

src/main/java/io/github/skippyall/minions/module/AttackModule.java

@@ -1,7 +1,7 @@
 package io.github.skippyall.minions.module;
 
 import io.github.skippyall.minions.Minions;
-import io.github.skippyall.minions.command.SimpleCommand;
+import io.github.skippyall.minions.module.command.SimpleCommand;
 import io.github.skippyall.minions.minion.fakeplayer.EntityPlayerActionPack;
 import net.minecraft.item.Items;
 import net.minecraft.text.Text;

src/main/java/io/github/skippyall/minions/module/ChatModule.java

@@ -1,7 +1,7 @@
 package io.github.skippyall.minions.module;
 
 import io.github.skippyall.minions.Minions;
-import io.github.skippyall.minions.command.SimpleCommand;
+import io.github.skippyall.minions.module.command.SimpleCommand;
 import net.minecraft.item.Items;
 import net.minecraft.text.Text;
 import net.minecraft.util.Identifier;

src/main/java/io/github/skippyall/minions/module/InteractModule.java

@@ -1,7 +1,7 @@
 package io.github.skippyall.minions.module;
 
 import io.github.skippyall.minions.Minions;
-import io.github.skippyall.minions.command.SimpleCommand;
+import io.github.skippyall.minions.module.command.SimpleCommand;
 import io.github.skippyall.minions.minion.fakeplayer.EntityPlayerActionPack;
 import net.minecraft.item.Items;
 import net.minecraft.text.Text;

src/main/java/io/github/skippyall/minions/module/ModuleItem.java

@@ -1,6 +1,6 @@
 package io.github.skippyall.minions.module;
 
-import io.github.skippyall.minions.command.Command;
+import io.github.skippyall.minions.module.command.Command;
 import io.github.skippyall.minions.program.block.CodeBlock;
 import net.minecraft.item.ItemConvertible;
 

src/main/java/io/github/skippyall/minions/module/Modules.java

@@ -1,6 +1,7 @@
 package io.github.skippyall.minions.module;
 
-import io.github.skippyall.minions.command.Command;
+import io.github.skippyall.minions.MinionItems;
+import io.github.skippyall.minions.module.command.Command;
 import io.github.skippyall.minions.program.block.CodeBlock;
 import net.minecraft.item.Item;
 import net.minecraft.registry.Registries;
@@ -21,11 +22,7 @@ public class Modules {
         AttackModule.registerMe();
     }
 
-    public static <T extends Item & ModuleItem> T register(Identifier id, T item) {
-        return Registry.register(Registries.ITEM, id, item);
-    }
-
     public static SimpleModuleItem register(Identifier id, List<CodeBlock<?,?>> codeBlocks, List<Command> commands, Item vanillaItem) {
-        return Registry.register(Registries.ITEM, id, new SimpleModuleItem(codeBlocks, commands, new Item.Settings().registryKey(RegistryKey.of(RegistryKeys.ITEM, id)), vanillaItem));
+        return MinionItems.registerItem(id, settings -> new SimpleModuleItem(codeBlocks, commands, settings, vanillaItem));
     }
 }

src/main/java/io/github/skippyall/minions/module/MountModule.java

@@ -1,7 +1,7 @@
 package io.github.skippyall.minions.module;
 
 import io.github.skippyall.minions.Minions;
-import io.github.skippyall.minions.command.SimpleCommand;
+import io.github.skippyall.minions.module.command.SimpleCommand;
 import net.minecraft.item.Items;
 import net.minecraft.text.Text;
 import net.minecraft.util.Identifier;

src/main/java/io/github/skippyall/minions/module/MoveModule.java

@@ -1,7 +1,7 @@
 package io.github.skippyall.minions.module;
 
 import io.github.skippyall.minions.Minions;
-import io.github.skippyall.minions.command.SimpleCommand;
+import io.github.skippyall.minions.module.command.SimpleCommand;
 import io.github.skippyall.minions.input.TextInput;
 import net.minecraft.item.Items;
 import net.minecraft.text.Text;
@@ -57,6 +57,8 @@ public class MoveModule {
                             .thenAccept(degrees -> minion.getMinionActionPack().turn(0, degrees))
             );
 
+
+
     public static final SimpleModuleItem MOVE_MODULE =
             register(Identifier.of(Minions.MOD_ID, "move_module"),
                     List.of(),

src/main/java/io/github/skippyall/minions/module/SimpleModuleItem.java

@@ -1,7 +1,7 @@
 package io.github.skippyall.minions.module;
 
 import eu.pb4.polymer.core.api.item.SimplePolymerItem;
-import io.github.skippyall.minions.command.Command;
+import io.github.skippyall.minions.module.command.Command;
 import io.github.skippyall.minions.program.block.CodeBlock;
 import net.minecraft.item.Item;
 

src/main/java/io/github/skippyall/minions/module/command/Command.java

@@ -1,4 +1,4 @@
-package io.github.skippyall.minions.command;
+package io.github.skippyall.minions.module.command;
 
 import net.minecraft.item.Item;
 import net.minecraft.text.Text;

src/main/java/io/github/skippyall/minions/module/command/CommandExecutor.java

@@ -1,4 +1,4 @@
-package io.github.skippyall.minions.command;
+package io.github.skippyall.minions.module.command;
 
 import io.github.skippyall.minions.minion.fakeplayer.MinionFakePlayer;
 import net.minecraft.server.network.ServerPlayerEntity;

src/main/java/io/github/skippyall/minions/module/command/SimpleCommand.java

@@ -1,4 +1,4 @@
-package io.github.skippyall.minions.command;
+package io.github.skippyall.minions.module.command;
 
 import io.github.skippyall.minions.minion.fakeplayer.MinionFakePlayer;
 import net.minecraft.item.Item;

src/main/java/io/github/skippyall/minions/program/block/GoBlock.java

@@ -19,7 +19,7 @@ public class GoBlock extends CodeBlock<Void, Tuple2<Float, Float>> {
     public Void execute(ProgramRuntime runtime, Tuple2<Float, Float> args, Statement<Void, Tuple2<Float, Float>>.Run run) {
         if(runtime instanceof MinionRuntime minionRuntime) {
             MinionFakePlayer minion = minionRuntime.getMinion();
-            EntityPlayerActionPack action = ((ServerPlayerInterface) minion).getActionPack();
+            EntityPlayerActionPack action = ((ServerPlayerInterface) minion).minions$getActionPack();
             minion.moveForward(args.v0());
             minion.moveSideways(args.v1());
         }

src/main/resources/data/minions/lang/en_us.json

@@ -7,6 +7,14 @@
   "minions.gui.module_commands.title": "Commands",
   "minions.gui.commands.title": "%s's Commands",
   "minions.gui.modules.title": "%s's Modules",
+  "minions.gui.ok": "OK",
+  "minions.gui.look.skin.name": "Name",
+  "minions.gui.look.skin.name.title": "Enter a player name",
+  "minions.gui.look.skin.uuid": "UUID",
+  "minions.gui.look.skin.uuid.title": "Enter a player UUID",
+  "minions.gui.look.skin.base64": "Base64",
+  "minions.gui.look.skin.base64.title": "Enter a skin in base64 encoding",
+  "minions.gui.look.rename.title": "Enter a name",
 
   "minions.command.input.int.fail": "Not an integer",
   "minions.command.input.float.fail": "Not a number",
@@ -30,5 +38,11 @@
   "item.minions.basic_upgrade_base": "Basic Upgrade Base",
   "item.minions.advanced_upgrade_base": "Advanced Upgrade Base",
 
-  "minions.minion_item.tooltip": "Name: %s"
+  "minions.minion_item.tooltip": "Name: %s",
+  "minions.generic.name.invalid_char": "Name contains invalid character",
+  "minions.generic.name.too_long": "Name is too long",
+  "minions.generic.name.invalid": "Name is invalid",
+  "minions.generic.name.taken": "This name is already used",
+  "minions.generic.mod_name": "Minions",
+  "minions.command.minion.not_present": "This minion does not exist"
 }

src/main/resources/fabric.mod.json

@@ -23,7 +23,7 @@
   "depends": {
     "fabricloader": "*",
     "fabric": "*",
-    "minecraft": "~1.21.3",
+    "minecraft": "~1.21.5",
     "polymer-core": "*"
   }
 }

src/main/resources/minions.accesswidener

@@ -1,4 +1,4 @@
 accessWidener v2 named
 
-accessible class net/minecraft/server/world/ChunkTicketManager$DistanceFromNearestPlayerTracker
-accessible method net/minecraft/server/world/ChunkTicketManager$DistanceFromNearestPlayerTracker <init> (Lnet/minecraft/server/world/ChunkTicketManager;I)V
+accessible class net/minecraft/server/world/ChunkLevelManager$DistanceFromNearestPlayerTracker
+accessible method net/minecraft/server/world/ChunkLevelManager$DistanceFromNearestPlayerTracker <init> (Lnet/minecraft/server/world/ChunkLevelManager;I)V

src/main/resources/minions.mixins.json

@@ -8,6 +8,7 @@
     "ConnectionMixin",
     "EntityAccessor",
     "GraveCompatMixin",
+    "EntityViewMixin",
     "MinecraftServerMixin",
     "MobEntityMixin",
     "PlayerListEntryS2CPacket$EntryMixin",
@@ -17,8 +18,8 @@
     "SleepManagerMixin",
     "SpawnHelperMixin",
     "antimobcap.ChunkPosDistanceLevelPropagatorMixin",
-    "antimobcap.ChunkTicketManager$DistanceFromNearestPlayerTrackerMixin",
-    "antimobcap.ChunkTicketManagerMixin",
+    "antimobcap.ChunkLevelManager$DistanceFromNearestPlayerTrackerMixin",
+    "antimobcap.ChunkLevelManagerMixin",
     "antimobcap.ServerChunkManagerAccessor",
     "antimobcap.ServerChunkManagerMixin"
   ],