reworked PocketDirectory to allow for usage of negative quadrants

Pocket object generation now via Pocket.PocketBuilder

src/main/java/org/dimdev/dimdoors/DimensionalDoorsInitializer.java

@@ -10,6 +10,7 @@ import net.fabricmc.fabric.api.event.player.AttackBlockCallback;
 import net.fabricmc.fabric.api.networking.v1.ServerPlayConnectionEvents;
 
 import me.sargunvohra.mcmods.autoconfig1u.serializer.JanksonConfigSerializer;
+import net.minecraft.util.math.Vec3i;
 import org.dimdev.dimdoors.block.ModBlocks;
 import org.dimdev.dimdoors.block.entity.ModBlockEntityTypes;
 import org.dimdev.dimdoors.command.ModCommands;
@@ -31,6 +32,9 @@ import org.dimdev.dimdoors.sound.ModSoundEvents;
 import org.dimdev.dimdoors.world.ModBiomes;
 import org.dimdev.dimdoors.world.ModDimensions;
 import org.dimdev.dimdoors.world.feature.ModFeatures;
+import org.dimdev.dimdoors.world.pocket.PocketDirectory;
+import org.dimdev.dimdoors.world.pocket.type.AbstractPocket;
+import org.dimdev.dimdoors.world.pocket.type.Pocket;
 import org.jetbrains.annotations.NotNull;
 
 import net.minecraft.server.MinecraftServer;
@@ -88,11 +92,14 @@ public class DimensionalDoorsInitializer implements ModInitializer {
 		VirtualSingularPocket.VirtualSingularPocketType.register();
 		Modifier.ModifierType.register();
 		PocketGenerator.PocketGeneratorType.register();
+		AbstractPocket.AbstractPocketType.register();
 
         SchematicV2Handler.getInstance().load();
         SchematicHandler.INSTANCE.loadSchematics();
 
 		registerListeners();
+
+		//newPocketTest();
     }
 
     private void registerListeners() {
@@ -106,4 +113,40 @@ public class DimensionalDoorsInitializer implements ModInitializer {
 
 		AttackBlockCallback.EVENT.register(new AttackBlockCallbackListener());
 	}
+
+	/*
+	void newPocketTest() {
+		PocketDirectory directory = new PocketDirectory(ModDimensions.DUNGEON, 512);
+
+		Pocket.PocketBuilder<?, ?> builder = Pocket.builder().expand(new Vec3i(1, 1, 1));
+
+
+		System.out.println(0 + ", " + directory.newPocket(builder).getId());
+		System.out.println(1 + ", " + directory.newPocket(builder).getId());
+		System.out.println(2 + ", " + directory.newPocket(builder).getId());
+		System.out.println(3 + ", " + directory.newPocket(builder).getId());
+		System.out.println(4 + ", " + directory.newPocket(builder).getId());
+		System.out.println(5 + ", " + directory.newPocket(builder).getId());
+		System.out.println(6 + ", " + directory.newPocket(builder).getId());
+
+
+
+		builder = Pocket.builder().expand(new Vec3i(directory.getGridSize() + 1, directory.getGridSize() + 1, directory.getGridSize() + 1));
+		System.out.println(9 + ", " + directory.newPocket(builder).getId());
+		System.out.println(18 + ", " + directory.newPocket(builder).getId());
+
+		builder = Pocket.builder().expand(new Vec3i(3 * directory.getGridSize() + 1, 3 * directory.getGridSize() + 1, 3 * directory.getGridSize() + 1));
+		System.out.println(81 + ", " + directory.newPocket(builder).getId());
+
+
+
+		builder = Pocket.builder().expand(new Vec3i(directory.getGridSize() + 1, directory.getGridSize() + 1, directory.getGridSize() + 1));
+		System.out.println(27 + ", " + directory.newPocket(builder).getId());
+
+		builder = Pocket.builder().expand(new Vec3i(1, 1, 1));
+		System.out.println(7 + ", " + directory.newPocket(builder).getId());
+		System.out.println(8 + ", " + directory.newPocket(builder).getId());
+		System.out.println(36 + ", " + directory.newPocket(builder).getId());
+	}
+	*/
 }

src/main/java/org/dimdev/dimdoors/command/PocketCommand.java

@@ -7,6 +7,7 @@ import com.mojang.brigadier.context.CommandContext;
 import com.mojang.brigadier.exceptions.CommandSyntaxException;
 import net.minecraft.util.math.EulerAngle;
 import net.minecraft.util.math.Vec3d;
+import net.minecraft.util.math.Vec3i;
 import org.dimdev.dimdoors.command.arguments.GroupArugmentType;
 import org.dimdev.dimdoors.command.arguments.NameArugmentType;
 import org.dimdev.dimdoors.pockets.PocketGenerator;
@@ -17,7 +18,7 @@ import org.dimdev.dimdoors.world.level.DimensionalRegistry;
 import org.dimdev.dimdoors.util.Location;
 import org.dimdev.dimdoors.util.TeleportUtil;
 import org.dimdev.dimdoors.world.ModDimensions;
-import org.dimdev.dimdoors.world.pocket.Pocket;
+import org.dimdev.dimdoors.world.pocket.type.Pocket;
 
 import net.minecraft.command.CommandException;
 import net.minecraft.server.command.CommandManager;
@@ -69,7 +70,8 @@ public class PocketCommand {
                     entrance.receiveEntity(player, Vec3d.ZERO, new EulerAngle(0, 0, 0), player.getVelocity());
                 }
             } else {
-                Vector3i size = pocket.getSize().add(1, 1, 1).mul(15).div(2);
+            	Vec3i sizeVec3i = pocket.getSize();
+				Vector3i size = Vector3i.from(sizeVec3i.getX(), sizeVec3i.getY(), sizeVec3i.getZ()).add(1, 1, 1).mul(15).div(2);
                 TeleportUtil.teleport(player, new Location(player.getServerWorld(), pocket.getOrigin().add(size.getX(), size.getY(), size.getZ())));
             }
         } catch (Exception e) {

src/main/java/org/dimdev/dimdoors/pockets/PocketGenerator.java

@@ -2,6 +2,7 @@ package org.dimdev.dimdoors.pockets;
 
 import java.util.Random;
 
+import net.minecraft.util.math.Vec3i;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.dimdev.dimdoors.DimensionalDoorsInitializer;
@@ -11,7 +12,7 @@ import org.dimdev.dimdoors.rift.targets.VirtualTarget;
 import org.dimdev.dimdoors.util.PocketGenerationParameters;
 import org.dimdev.dimdoors.world.level.DimensionalRegistry;
 import org.dimdev.dimdoors.world.ModDimensions;
-import org.dimdev.dimdoors.world.pocket.Pocket;
+import org.dimdev.dimdoors.world.pocket.type.Pocket;
 import org.dimdev.dimdoors.world.pocket.VirtualLocation;
 
 import net.minecraft.server.world.ServerWorld;
@@ -22,7 +23,7 @@ public final class PocketGenerator {
     private static Pocket prepareAndPlacePocket(ServerWorld world, PocketTemplate pocketTemplate, VirtualLocation virtualLocation, boolean setup) {
         LOGGER.info("Generating pocket from template " + pocketTemplate.getId() + " at virtual location " + virtualLocation);
 
-        Pocket pocket = DimensionalRegistry.getPocketDirectory(world.getRegistryKey()).newPocket();
+        Pocket pocket = DimensionalRegistry.getPocketDirectory(world.getRegistryKey()).newPocket(Pocket.builder().expand(new Vec3i(1, 1, 1)));
         pocketTemplate.place(pocket, setup);
         pocket.virtualLocation = virtualLocation;
         return pocket;

src/main/java/org/dimdev/dimdoors/pockets/PocketTemplate.java

@@ -17,7 +17,7 @@ import org.dimdev.dimdoors.rift.targets.VirtualTarget;
 import org.dimdev.dimdoors.world.level.DimensionalRegistry;
 import org.dimdev.dimdoors.util.Location;
 import org.dimdev.dimdoors.util.schematic.Schematic;
-import org.dimdev.dimdoors.world.pocket.Pocket;
+import org.dimdev.dimdoors.world.pocket.type.Pocket;
 
 import net.minecraft.block.BlockState;
 import net.minecraft.block.entity.BlockEntity;
@@ -117,8 +117,8 @@ public class PocketTemplate {
 
     public void place(Pocket pocket, boolean setup) {
         pocket.setSize(this.size * 16, this.size * 16, this.size * 16);
-        int gridSize = DimensionalRegistry.getPocketDirectory(pocket.world).getGridSize();
+        int gridSize = DimensionalRegistry.getPocketDirectory(pocket.getWorld()).getGridSize();
-        ServerWorld world = DimensionalDoorsInitializer.getWorld(pocket.world);
+        ServerWorld world = DimensionalDoorsInitializer.getWorld(pocket.getWorld());
         int xBase = pocket.box.minX;
         int yBase = pocket.box.minY;
         int zBase = pocket.box.minZ;
@@ -142,8 +142,8 @@ public class PocketTemplate {
     }
 
     public void setup(Pocket pocket, VirtualTarget linkTo, LinkProperties linkProperties) {
-        int gridSize = DimensionalRegistry.getPocketDirectory(pocket.world).getGridSize();
+        int gridSize = DimensionalRegistry.getPocketDirectory(pocket.getWorld()).getGridSize();
-        ServerWorld world = DimensionalDoorsInitializer.getWorld(pocket.world);
+        ServerWorld world = DimensionalDoorsInitializer.getWorld(pocket.getWorld());
         int xBase = pocket.box.minX;
         int yBase = pocket.box.minY;
         int zBase = pocket.box.minZ;

src/main/java/org/dimdev/dimdoors/pockets/PocketTemplateV2.java

@@ -5,7 +5,7 @@ import org.apache.logging.log4j.Logger;
 import org.dimdev.dimdoors.DimensionalDoorsInitializer;
 import org.dimdev.dimdoors.util.schematic.v2.Schematic;
 import org.dimdev.dimdoors.util.schematic.v2.SchematicPlacer;
-import org.dimdev.dimdoors.world.pocket.Pocket;
+import org.dimdev.dimdoors.world.pocket.type.Pocket;
 
 import net.minecraft.server.world.ServerWorld;
 import net.minecraft.util.math.BlockPos;
@@ -58,7 +58,7 @@ public class PocketTemplateV2 {
 
     public void place(Pocket pocket) {
         pocket.setSize(schematic.getWidth(), schematic.getHeight(), schematic.getLength());
-        ServerWorld world = DimensionalDoorsInitializer.getWorld(pocket.world);
+        ServerWorld world = DimensionalDoorsInitializer.getWorld(pocket.getWorld());
         BlockPos origin = pocket.getOrigin();
         LOGGER.info("Placing new pocket using schematic " + this.id + " at x = " + origin.getX() + ", z = " + origin.getZ());
         SchematicPlacer.place(this.schematic, world, origin);

src/main/java/org/dimdev/dimdoors/pockets/TemplateUtils.java

@@ -10,7 +10,6 @@ import net.minecraft.util.math.Vec3d;
 import org.apache.logging.log4j.Logger;
 import org.dimdev.dimdoors.DimensionalDoorsInitializer;
 import org.dimdev.dimdoors.block.entity.EntranceRiftBlockEntity;
-import org.dimdev.dimdoors.block.entity.ModBlockEntityTypes;
 import org.dimdev.dimdoors.block.entity.RiftBlockEntity;
 import org.dimdev.dimdoors.entity.ModEntityTypes;
 import org.dimdev.dimdoors.entity.MonolithEntity;
@@ -22,7 +21,7 @@ import org.dimdev.dimdoors.world.level.DimensionalRegistry;
 import org.dimdev.dimdoors.util.Location;
 import org.dimdev.dimdoors.util.math.MathUtil;
 import org.dimdev.dimdoors.util.schematic.v2.Schematic;
-import org.dimdev.dimdoors.world.pocket.Pocket;
+import org.dimdev.dimdoors.world.pocket.type.Pocket;
 
 import net.minecraft.block.entity.BlockEntity;
 import net.minecraft.block.entity.ChestBlockEntity;
@@ -75,7 +74,7 @@ public class TemplateUtils {
     }
 
     static public void registerRifts(List<? extends RiftBlockEntity> rifts, VirtualTarget linkTo, LinkProperties linkProperties, Pocket pocket) {
-        ServerWorld world = DimensionalDoorsInitializer.getWorld(pocket.world);
+        ServerWorld world = DimensionalDoorsInitializer.getWorld(pocket.getWorld());
         HashMap<RiftBlockEntity, Float> entranceWeights = new HashMap<>();
 
         for (RiftBlockEntity rift : rifts) { // Find an entrance

src/main/java/org/dimdev/dimdoors/pockets/generator/ChunkGenerator.java

@@ -2,7 +2,6 @@ package org.dimdev.dimdoors.pockets.generator;
 
 import net.minecraft.block.BlockState;
 import net.minecraft.block.Blocks;
-import net.minecraft.entity.Entity;
 import net.minecraft.fluid.FluidState;
 import net.minecraft.fluid.Fluids;
 import net.minecraft.nbt.CompoundTag;
@@ -27,9 +26,8 @@ import org.dimdev.dimdoors.block.entity.DetachedRiftBlockEntity;
 import org.dimdev.dimdoors.block.entity.ModBlockEntityTypes;
 import org.dimdev.dimdoors.rift.targets.PocketEntranceMarker;
 import org.dimdev.dimdoors.util.PocketGenerationParameters;
-import org.dimdev.dimdoors.util.TeleportUtil;
 import org.dimdev.dimdoors.world.level.DimensionalRegistry;
-import org.dimdev.dimdoors.world.pocket.Pocket;
+import org.dimdev.dimdoors.world.pocket.type.Pocket;
 import org.dimdev.dimdoors.world.pocket.VirtualLocation;
 
 import java.util.ArrayList;
@@ -79,14 +77,14 @@ public class ChunkGenerator extends PocketGenerator {
 	}
 
 	@Override
-	public Pocket prepareAndPlacePocket(PocketGenerationParameters parameters) {
+	public Pocket prepareAndPlacePocket(PocketGenerationParameters parameters, Pocket.PocketBuilder<?, ?> builder) {
 		ServerWorld world = parameters.getWorld();
 		VirtualLocation sourceVirtualLocation = parameters.getSourceVirtualLocation();
 
 		int chunkSizeX = ((this.size.getX() >> 4) + (this.size.getX() % 16 == 0 ? 0 : 1));
 		int chunkSizeZ = ((this.size.getZ() >> 4) + (this.size.getZ() % 16 == 0 ? 0 : 1));
 
-		Pocket pocket = DimensionalRegistry.getPocketDirectory(world.getRegistryKey()).newPocket();
+		Pocket pocket = DimensionalRegistry.getPocketDirectory(world.getRegistryKey()).newPocket(builder);
 		pocket.setSize(size);
 		pocket.offsetOrigin(offset);
 
@@ -199,6 +197,11 @@ public class ChunkGenerator extends PocketGenerator {
 		return KEY;
 	}
 
+	@Override
+	public Vec3i getSize(PocketGenerationParameters parameters) {
+		return size;
+	}
+
 	private static class ChunkRegionHack extends ChunkRegion { // Please someone tell me if there is a better way
 		ChunkRegionHack(ServerWorld world, List<Chunk> chunks) {
 			super(world, chunks);

src/main/java/org/dimdev/dimdoors/pockets/generator/PocketGenerator.java

@@ -11,6 +11,7 @@ import net.minecraft.nbt.ListTag;
 import net.minecraft.nbt.StringTag;
 import net.minecraft.server.world.ServerWorld;
 import net.minecraft.util.Identifier;
+import net.minecraft.util.math.Vec3i;
 import net.minecraft.util.registry.Registry;
 import net.minecraft.util.registry.RegistryKey;
 import net.minecraft.util.registry.SimpleRegistry;
@@ -26,7 +27,7 @@ import org.dimdev.dimdoors.util.PocketGenerationParameters;
 import org.dimdev.dimdoors.util.Weighted;
 import org.dimdev.dimdoors.util.math.Equation;
 import org.dimdev.dimdoors.util.math.Equation.EquationParseException;
-import org.dimdev.dimdoors.world.pocket.Pocket;
+import org.dimdev.dimdoors.world.pocket.type.Pocket;
 
 import java.util.*;
 import java.util.function.Supplier;
@@ -127,7 +128,7 @@ public abstract class PocketGenerator implements Weighted<PocketGenerationParame
 		return tag;
 	}
 
-	public abstract Pocket prepareAndPlacePocket(PocketGenerationParameters parameters);
+	public abstract Pocket prepareAndPlacePocket(PocketGenerationParameters parameters, Pocket.PocketBuilder<?, ?> builder);
 
 	public abstract PocketGeneratorType<? extends PocketGenerator> getType();
 
@@ -148,8 +149,14 @@ public abstract class PocketGenerator implements Weighted<PocketGenerationParame
 		}
 	}
 
+	public void applyModifiers(PocketGenerationParameters parameters, Pocket.PocketBuilder<?, ?> builder) {
+		for (Modifier modifier : modifierList) {
+			modifier.apply(parameters, builder);
+		}
+	}
+
 	public void setup(Pocket pocket, PocketGenerationParameters parameters, boolean setupLootTables) {
-		ServerWorld world = DimensionalDoorsInitializer.getWorld(pocket.world);
+		ServerWorld world = DimensionalDoorsInitializer.getWorld(pocket.getWorld());
 		List<RiftBlockEntity> rifts = new ArrayList<>();
 
 		pocket.getBlockEntities().forEach((blockPos, blockEntity) -> {
@@ -191,6 +198,13 @@ public abstract class PocketGenerator implements Weighted<PocketGenerationParame
 		return true;
 	}
 
+	public Pocket.PocketBuilder<?, ?> pocketBuilder(PocketGenerationParameters parameters) { // TODO: PocketBuilder from json
+		return Pocket.builder()
+				.expand(getSize(parameters));
+	}
+
+	public abstract Vec3i getSize(PocketGenerationParameters parameters);
+
 	public interface PocketGeneratorType<T extends PocketGenerator> {
 		PocketGeneratorType<SchematicGenerator> SCHEMATIC = register(new Identifier("dimdoors", SchematicGenerator.KEY), SchematicGenerator::new);
 		PocketGeneratorType<ChunkGenerator> CHUNK = register(new Identifier("dimdoors", ChunkGenerator.KEY), ChunkGenerator::new);

src/main/java/org/dimdev/dimdoors/pockets/generator/SchematicGenerator.java

@@ -3,14 +3,16 @@ package org.dimdev.dimdoors.pockets.generator;
 import net.minecraft.nbt.CompoundTag;
 import net.minecraft.server.world.ServerWorld;
 import net.minecraft.util.Identifier;
+import net.minecraft.util.math.Vec3i;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.dimdev.dimdoors.pockets.PocketTemplateV2;
 import org.dimdev.dimdoors.pockets.SchematicV2Handler;
 import org.dimdev.dimdoors.util.PocketGenerationParameters;
 import org.dimdev.dimdoors.util.math.Equation;
+import org.dimdev.dimdoors.util.schematic.v2.Schematic;
 import org.dimdev.dimdoors.world.level.DimensionalRegistry;
-import org.dimdev.dimdoors.world.pocket.Pocket;
+import org.dimdev.dimdoors.world.pocket.type.Pocket;
 
 import java.util.HashMap;
 import java.util.Map;
@@ -30,7 +32,6 @@ public class SchematicGenerator extends PocketGenerator {
 	private String id;
 	private Identifier templateID;
 
-	private Equation lengthEquation;
 	private String offsetX;
 	private Equation offsetXEquation;
 	private String offsetY;
@@ -92,20 +93,22 @@ public class SchematicGenerator extends PocketGenerator {
 	}
 
 	@Override
-	public Pocket prepareAndPlacePocket(PocketGenerationParameters parameters) {
+	public Pocket prepareAndPlacePocket(PocketGenerationParameters parameters, Pocket.PocketBuilder<?, ?> builder) {
 		ServerWorld world = parameters.getWorld();
 		Map<String, Double> variableMap = parameters.toVariableMap(new HashMap<>());
 
 		PocketTemplateV2 template = SchematicV2Handler.getInstance().getTemplates().get(templateID);
 		if (template == null) throw new RuntimeException("Pocket template of id " + templateID + " not found!");
 
-		Pocket pocket = DimensionalRegistry.getPocketDirectory(world.getRegistryKey()).newPocket();
+		Pocket pocket = DimensionalRegistry.getPocketDirectory(world.getRegistryKey()).newPocket(builder);
 		LOGGER.info("Generating pocket from template " + template.getId() + " at location " + pocket.getOrigin());
 
 		pocket.offsetOrigin((int) offsetXEquation.apply(variableMap), (int) offsetYEquation.apply(variableMap), (int) offsetZEquation.apply(variableMap));
 
 		template.place(pocket);
 
+		pocket.virtualLocation = parameters.getSourceVirtualLocation(); // TODO: this makes very little sense
+
 		return pocket;
 	}
 
@@ -118,4 +121,12 @@ public class SchematicGenerator extends PocketGenerator {
 	public String getKey() {
 		return KEY;
 	}
+
+	@Override
+	public Vec3i getSize(PocketGenerationParameters parameters) {
+		PocketTemplateV2 template = SchematicV2Handler.getInstance().getTemplates().get(templateID);
+		if (template == null) throw new RuntimeException("Pocket template of id " + templateID + " not found!");
+		Schematic schem = template.getSchematic();
+		return new Vec3i(schem.getWidth(), schem.getHeight(), schem.getLength());
+	}
 }

src/main/java/org/dimdev/dimdoors/pockets/generator/VoidGenerator.java

@@ -1,13 +1,14 @@
 package org.dimdev.dimdoors.pockets.generator;
 
 import net.minecraft.nbt.CompoundTag;
+import net.minecraft.util.math.Vec3i;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.dimdev.dimdoors.util.PocketGenerationParameters;
 import org.dimdev.dimdoors.util.math.Equation;
 import org.dimdev.dimdoors.util.math.Equation.EquationParseException;
 import org.dimdev.dimdoors.world.level.DimensionalRegistry;
-import org.dimdev.dimdoors.world.pocket.Pocket;
+import org.dimdev.dimdoors.world.pocket.type.Pocket;
 
 import java.util.HashMap;
 import java.util.Map;
@@ -29,8 +30,8 @@ public class VoidGenerator extends PocketGenerator {
 	private Equation offsetZEquation;
 
 	@Override
-	public Pocket prepareAndPlacePocket(PocketGenerationParameters parameters) {
+	public Pocket prepareAndPlacePocket(PocketGenerationParameters parameters, Pocket.PocketBuilder<?, ?> builder) {
-		Pocket pocket = DimensionalRegistry.getPocketDirectory(parameters.getWorld().getRegistryKey()).newPocket();
+		Pocket pocket = DimensionalRegistry.getPocketDirectory(parameters.getWorld().getRegistryKey()).newPocket(builder);
 		Map<String, Double> variableMap = parameters.toVariableMap(new HashMap<>());
 		pocket.setSize((int) widthEquation.apply(variableMap), (int) heightEquation.apply(variableMap), (int) lengthEquation.apply(variableMap));
 		pocket.offsetOrigin((int) offsetXEquation.apply(variableMap), (int) offsetYEquation.apply(variableMap), (int) offsetZEquation.apply(variableMap));
@@ -48,6 +49,12 @@ public class VoidGenerator extends PocketGenerator {
 		return KEY;
 	}
 
+	@Override
+	public Vec3i getSize(PocketGenerationParameters parameters) {
+		Map<String, Double> variableMap = parameters.toVariableMap(new HashMap<>());
+		return new Vec3i((int) widthEquation.apply(variableMap), (int) heightEquation.apply(variableMap), (int) lengthEquation.apply(variableMap));
+	}
+
 	@Override
 	public PocketGenerator fromTag(CompoundTag tag) {
 		super.fromTag(tag);

src/main/java/org/dimdev/dimdoors/pockets/modifier/DimensionalDoorModifier.java

@@ -29,6 +29,7 @@ import org.dimdev.dimdoors.util.PocketGenerationParameters;
 import org.dimdev.dimdoors.util.TagEquations;
 import org.dimdev.dimdoors.util.math.Equation;
 import org.dimdev.dimdoors.util.math.Equation.EquationParseException;
+import org.dimdev.dimdoors.world.pocket.type.Pocket;
 
 public class DimensionalDoorModifier implements Modifier {
 	private static final Logger LOGGER = LogManager.getLogger();
@@ -151,4 +152,9 @@ public class DimensionalDoorModifier implements Modifier {
 
 		world.addBlockEntity(rift);
 	}
+
+	@Override
+	public void apply(PocketGenerationParameters parameters, Pocket.PocketBuilder<?, ?> builder) {
+
+	}
 }

src/main/java/org/dimdev/dimdoors/pockets/modifier/Modifier.java

@@ -8,12 +8,9 @@ import net.minecraft.util.registry.Registry;
 import net.minecraft.util.registry.RegistryKey;
 import net.minecraft.util.registry.SimpleRegistry;
 
-import org.dimdev.dimdoors.block.entity.RiftBlockEntity;
-import org.dimdev.dimdoors.block.entity.RiftData;
 import org.dimdev.dimdoors.util.PocketGenerationParameters;
-import org.dimdev.dimdoors.world.pocket.Pocket;
+import org.dimdev.dimdoors.world.pocket.type.Pocket;
 
-import java.util.Map;
 import java.util.function.Supplier;
 
 public interface Modifier {
@@ -41,6 +38,8 @@ public interface Modifier {
 
 	void apply(PocketGenerationParameters parameters, RiftManager manager);
 
+	void apply(PocketGenerationParameters parameters, Pocket.PocketBuilder<?, ?> builder);
+
 	interface ModifierType<T extends Modifier> {
 		ModifierType<ShellModifier> SHELL_MODIFIER_TYPE = register(new Identifier("dimdoors", ShellModifier.KEY), ShellModifier::new);
 		ModifierType<DimensionalDoorModifier> DIMENSIONAL_DOOR_MODIFIER_TYPE = register(new Identifier("dimdoors", DimensionalDoorModifier.KEY), DimensionalDoorModifier::new);

src/main/java/org/dimdev/dimdoors/pockets/modifier/PocketEntranceModifier.java

@@ -1,18 +1,12 @@
 package org.dimdev.dimdoors.pockets.modifier;
 
-import java.util.List;
-import java.util.Map;
-
 import net.minecraft.nbt.CompoundTag;
-import net.minecraft.nbt.ListTag;
 
 import com.google.common.base.MoreObjects;
-import org.dimdev.dimdoors.block.entity.RiftBlockEntity;
-import org.dimdev.dimdoors.rift.registry.PocketEntrancePointer;
 import org.dimdev.dimdoors.rift.targets.PocketEntranceMarker;
 import org.dimdev.dimdoors.rift.targets.PocketExitMarker;
 import org.dimdev.dimdoors.util.PocketGenerationParameters;
-import org.dimdev.dimdoors.world.pocket.Pocket;
+import org.dimdev.dimdoors.world.pocket.type.Pocket;
 
 public class PocketEntranceModifier implements Modifier {
 	public static final String KEY = "pocket_entrance";
@@ -65,4 +59,9 @@ public class PocketEntranceModifier implements Modifier {
 			return true;
 		});
 	}
+
+	@Override
+	public void apply(PocketGenerationParameters parameters, Pocket.PocketBuilder<?, ?> builder) {
+
+	}
 }

src/main/java/org/dimdev/dimdoors/pockets/modifier/RelativeReferenceModifier.java

@@ -11,6 +11,7 @@ import org.dimdev.dimdoors.rift.targets.LocalReference;
 import org.dimdev.dimdoors.rift.targets.RiftReference;
 import org.dimdev.dimdoors.util.Location;
 import org.dimdev.dimdoors.util.PocketGenerationParameters;
+import org.dimdev.dimdoors.world.pocket.type.Pocket;
 
 public class RelativeReferenceModifier implements Modifier {
 	public static final String KEY = "relative";
@@ -56,6 +57,11 @@ public class RelativeReferenceModifier implements Modifier {
 		}
 	}
 
+	@Override
+	public void apply(PocketGenerationParameters parameters, Pocket.PocketBuilder<?, ?> builder) {
+
+	}
+
 	@Override
 	public String toString() {
 		return MoreObjects.toStringHelper(this)

src/main/java/org/dimdev/dimdoors/pockets/modifier/RiftDataModifier.java

@@ -19,6 +19,7 @@ import org.dimdev.dimdoors.pockets.SchematicV2Handler;
 import org.dimdev.dimdoors.rift.targets.VirtualTarget;
 import org.dimdev.dimdoors.util.PocketGenerationParameters;
 import org.dimdev.dimdoors.util.TagEquations;
+import org.dimdev.dimdoors.world.pocket.type.Pocket;
 
 public class RiftDataModifier implements Modifier {
 	public static final String KEY = "rift_data";
@@ -104,4 +105,8 @@ public class RiftDataModifier implements Modifier {
 			}
 		});
 	}
+
+	@Override
+	public void apply(PocketGenerationParameters parameters, Pocket.PocketBuilder<?, ?> builder) {
+	}
 }

src/main/java/org/dimdev/dimdoors/pockets/modifier/RiftManager.java

@@ -3,16 +3,13 @@ package org.dimdev.dimdoors.pockets.modifier;
 import java.util.HashSet;
 import java.util.Map;
 import java.util.Optional;
-import java.util.Set;
-import java.util.function.BiConsumer;
 import java.util.function.BiPredicate;
-import java.util.function.Function;
 import java.util.function.Predicate;
 import java.util.stream.Collectors;
 
 import org.dimdev.dimdoors.block.entity.RiftBlockEntity;
 import org.dimdev.dimdoors.rift.targets.IdMarker;
-import org.dimdev.dimdoors.world.pocket.Pocket;
+import org.dimdev.dimdoors.world.pocket.type.Pocket;
 
 public class RiftManager {
 	private final Map<Integer, RiftBlockEntity> map;

src/main/java/org/dimdev/dimdoors/pockets/modifier/ShellModifier.java

@@ -14,14 +14,14 @@ import net.minecraft.util.math.BlockBox;
 import net.minecraft.util.math.BlockPos;
 
 import net.fabricmc.fabric.api.util.NbtType;
+import net.minecraft.util.math.Vec3i;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 
-import org.dimdev.dimdoors.block.entity.RiftBlockEntity;
 import org.dimdev.dimdoors.util.PocketGenerationParameters;
 import org.dimdev.dimdoors.util.math.Equation;
 import org.dimdev.dimdoors.util.schematic.v2.SchematicBlockPalette;
-import org.dimdev.dimdoors.world.pocket.Pocket;
+import org.dimdev.dimdoors.world.pocket.type.Pocket;
 
 public class ShellModifier implements Modifier {
 	private static final Logger LOGGER = LogManager.getLogger();
@@ -72,6 +72,16 @@ public class ShellModifier implements Modifier {
 		layers.forEach(layer -> drawLayer(layer, manager.getPocket(), parameters.getWorld()));
 	}
 
+	@Override
+	public void apply(PocketGenerationParameters parameters, Pocket.PocketBuilder<?, ?> builder) {
+		Map<String, Double> variableMap = parameters.toVariableMap(new HashMap<>());
+		for (Layer layer : layers) {
+			int thickness = layer.getThickness(variableMap);
+			builder.expandExpected(new Vec3i(2 * thickness, 2 * thickness, 2 * thickness));
+			builder.offsetOrigin(new Vec3i(thickness, thickness, thickness));
+		}
+	}
+
 	private void drawLayer(Layer layer, Pocket pocket, ServerWorld world) {
 		int thickness = layer.getThickness(pocket.toVariableMap(new HashMap<>()));
 		final BlockState blockState = layer.getBlockState();

src/main/java/org/dimdev/dimdoors/pockets/virtual/VirtualPocket.java

@@ -6,7 +6,7 @@ import net.minecraft.nbt.Tag;
 import org.dimdev.dimdoors.pockets.virtual.reference.PocketGeneratorReference;
 import org.dimdev.dimdoors.util.PocketGenerationParameters;
 import org.dimdev.dimdoors.util.Weighted;
-import org.dimdev.dimdoors.world.pocket.Pocket;
+import org.dimdev.dimdoors.world.pocket.type.Pocket;
 
 public interface VirtualPocket extends Weighted<PocketGenerationParameters> {
 

src/main/java/org/dimdev/dimdoors/pockets/virtual/VirtualPocketList.java

@@ -4,7 +4,7 @@ import net.minecraft.nbt.ListTag;
 import org.dimdev.dimdoors.pockets.virtual.reference.PocketGeneratorReference;
 import org.dimdev.dimdoors.util.PocketGenerationParameters;
 import org.dimdev.dimdoors.util.WeightedList;
-import org.dimdev.dimdoors.world.pocket.Pocket;
+import org.dimdev.dimdoors.world.pocket.type.Pocket;
 
 // TODO: add weight tha
 public class VirtualPocketList extends WeightedList<VirtualPocket, PocketGenerationParameters> implements VirtualPocket {

src/main/java/org/dimdev/dimdoors/pockets/virtual/reference/PocketGeneratorReference.java

@@ -13,7 +13,7 @@ import org.dimdev.dimdoors.pockets.virtual.VirtualSingularPocket;
 import org.dimdev.dimdoors.util.PocketGenerationParameters;
 import org.dimdev.dimdoors.util.math.Equation;
 import org.dimdev.dimdoors.util.math.Equation.EquationParseException;
-import org.dimdev.dimdoors.world.pocket.Pocket;
+import org.dimdev.dimdoors.world.pocket.type.Pocket;
 
 import net.minecraft.nbt.CompoundTag;
 import net.minecraft.nbt.ListTag;
@@ -94,10 +94,21 @@ public abstract class PocketGeneratorReference extends VirtualSingularPocket {
 		}
 	}
 
+	public void applyModifiers(PocketGenerationParameters parameters, Pocket.PocketBuilder<?, ?> builder) {
+		for (Modifier modifier : modifierList) {
+			modifier.apply(parameters, builder);
+		}
+	}
+
 	@Override
 	public Pocket prepareAndPlacePocket(PocketGenerationParameters parameters) {
 		PocketGenerator generator = getReferencedPocketGenerator(parameters);
-		Pocket pocket = generator.prepareAndPlacePocket(parameters);
+
+		Pocket.PocketBuilder<?, ?> builder = generator.pocketBuilder(parameters);
+		generator.applyModifiers(parameters, builder);
+		this.applyModifiers(parameters, builder);
+
+		Pocket pocket = generator.prepareAndPlacePocket(parameters, builder);
 
 		RiftManager manager = new RiftManager(pocket);
 

src/main/java/org/dimdev/dimdoors/pockets/virtual/selection/ConditionalSelector.java

@@ -10,7 +10,7 @@ import org.dimdev.dimdoors.pockets.virtual.VirtualSingularPocket;
 import org.dimdev.dimdoors.pockets.virtual.reference.PocketGeneratorReference;
 import org.dimdev.dimdoors.util.PocketGenerationParameters;
 import org.dimdev.dimdoors.util.math.Equation;
-import org.dimdev.dimdoors.world.pocket.Pocket;
+import org.dimdev.dimdoors.world.pocket.type.Pocket;
 
 import java.util.HashMap;
 import java.util.LinkedHashMap;

src/main/java/org/dimdev/dimdoors/rift/registry/RiftRegistry.java

@@ -13,7 +13,7 @@ import org.apache.logging.log4j.Logger;
 import org.dimdev.dimdoors.util.GraphUtils;
 import org.dimdev.dimdoors.util.Location;
 import org.dimdev.dimdoors.world.level.DimensionalRegistry;
-import org.dimdev.dimdoors.world.pocket.Pocket;
+import org.dimdev.dimdoors.world.pocket.type.Pocket;
 import org.dimdev.dimdoors.world.pocket.PocketDirectory;
 import org.jgrapht.graph.DefaultDirectedGraph;
 import org.jgrapht.graph.DefaultEdge;
@@ -278,7 +278,7 @@ public class RiftRegistry {
 	}
 
 	public void addPocketEntrance(Pocket pocket, Location location) {
-		LOGGER.debug("Adding pocket entrance for pocket " + pocket.id + " in dimension " + pocket.world + " at " + location);
+		LOGGER.debug("Adding pocket entrance for pocket " + pocket.getId() + " in dimension " + pocket.getWorld() + " at " + location);
 
 //		PocketEntrancePointer pointer = this.pocketEntranceMap.get(pocket);
 //		if (pointer == null) {
@@ -290,8 +290,8 @@ public class RiftRegistry {
 //		}
 		this.addEdge(
 				this.pocketEntranceMap.computeIfAbsent(pocket, p -> {
-					PocketEntrancePointer pointer = new PocketEntrancePointer(pocket.world, pocket.id);
+					PocketEntrancePointer pointer = new PocketEntrancePointer(pocket.getWorld(), pocket.getId());
-					pointer.world = pocket.world;
+					pointer.world = pocket.getWorld();
 					this.graph.addVertex(pointer);
 					this.uuidMap.put(pointer.id, pointer);
 					return pointer;

src/main/java/org/dimdev/dimdoors/rift/targets/PrivatePocketExitTarget.java

@@ -10,7 +10,7 @@ import org.dimdev.dimdoors.util.Location;
 import org.dimdev.dimdoors.util.RGBA;
 import org.dimdev.dimdoors.world.ModDimensions;
 import org.dimdev.dimdoors.world.level.DimensionalRegistry;
-import org.dimdev.dimdoors.world.pocket.Pocket;
+import org.dimdev.dimdoors.world.pocket.type.Pocket;
 import org.dimdev.dimdoors.world.pocket.PocketDirectory;
 
 import net.minecraft.entity.Entity;
@@ -32,7 +32,7 @@ public class PrivatePocketExitTarget extends VirtualTarget implements EntityTarg
 		if (uuid != null) {
 			destLoc = DimensionalRegistry.getRiftRegistry().getPrivatePocketExit(uuid);
 			Pocket pocket = DimensionalRegistry.getPrivateRegistry().getPrivatePocket(uuid);
-			if (ModDimensions.isPersonalPocketDimension(this.location.getWorld()) && pocket != null && DimensionalRegistry.getPocketDirectory(pocket.world).getPocketAt(this.location.pos).equals(pocket)) {
+			if (ModDimensions.isPersonalPocketDimension(this.location.getWorld()) && pocket != null && DimensionalRegistry.getPocketDirectory(pocket.getWorld()).getPocketAt(this.location.pos).equals(pocket)) {
 				DimensionalRegistry.getRiftRegistry().setLastPrivatePocketEntrance(uuid, this.location); // Remember which exit was used for next time the pocket is entered
 			}
 			if (destLoc == null || !(destLoc.getBlockEntity() instanceof RiftBlockEntity)) {

src/main/java/org/dimdev/dimdoors/rift/targets/PrivatePocketTarget.java

@@ -11,7 +11,7 @@ import org.dimdev.dimdoors.util.EntityUtils;
 import org.dimdev.dimdoors.util.Location;
 import org.dimdev.dimdoors.util.RGBA;
 import org.dimdev.dimdoors.world.level.DimensionalRegistry;
-import org.dimdev.dimdoors.world.pocket.Pocket;
+import org.dimdev.dimdoors.world.pocket.type.Pocket;
 import org.dimdev.dimdoors.world.pocket.VirtualLocation;
 
 import net.minecraft.block.entity.BlockEntity;

src/main/java/org/dimdev/dimdoors/rift/targets/PublicPocketTarget.java

@@ -3,7 +3,7 @@ package org.dimdev.dimdoors.rift.targets;
 import org.dimdev.dimdoors.pockets.PocketGenerator;
 import org.dimdev.dimdoors.util.Location;
 import org.dimdev.dimdoors.world.level.DimensionalRegistry;
-import org.dimdev.dimdoors.world.pocket.Pocket;
+import org.dimdev.dimdoors.world.pocket.type.Pocket;
 import org.dimdev.dimdoors.world.pocket.VirtualLocation;
 
 import net.minecraft.nbt.CompoundTag;

src/main/java/org/dimdev/dimdoors/rift/targets/RandomTarget.java

@@ -21,7 +21,7 @@ import org.dimdev.dimdoors.rift.registry.Rift;
 import org.dimdev.dimdoors.util.Location;
 import org.dimdev.dimdoors.util.math.MathUtil;
 import org.dimdev.dimdoors.world.level.DimensionalRegistry;
-import org.dimdev.dimdoors.world.pocket.Pocket;
+import org.dimdev.dimdoors.world.pocket.type.Pocket;
 import org.dimdev.dimdoors.world.pocket.VirtualLocation;
 
 import net.minecraft.nbt.CompoundTag;

src/main/java/org/dimdev/dimdoors/util/math/GridUtil.java

@@ -1,15 +1,19 @@
 package org.dimdev.dimdoors.util.math;
 
+import java.util.Arrays;
+import java.util.Vector;
+
 public final class GridUtil {
 	public static final class GridPos {
-		public final int x;
+		public int x;
-		public final int z;
+		public int z;
 
 		public GridPos(int x, int z) {
 			this.x = x;
 			this.z = z;
 		}
 
+		@Override
 		public boolean equals(Object o) {
 			if (o == this) return true;
 			if (!(o instanceof GridPos)) return false;
@@ -18,6 +22,7 @@ public final class GridUtil {
 			return this.z == other.z;
 		}
 
+		@Override
 		public int hashCode() {
 			int PRIME = 59;
 			int result = 1;
@@ -26,41 +31,57 @@ public final class GridUtil {
 			return result;
 		}
 
+		@Override
 		public String toString() {
 			return "GridUtils.GridPos(x=" + this.x + ", z=" + this.z + ")";
 		}
 	}
 
+
 	/**
-	 * Calculates the grid position for a certain element number in the grid.
+	 * Calculates the grid position for a certain element id in the grid.
 	 *
-	 * @param num The element's number in the grid
+	 * @param id The element's id in the grid
 	 * @return The location on the grid
 	 */
-	public static GridPos numToPos(int num) { // TODO: alternate the sign on every number to have negative coords too
+	public static GridPos idToGridPos(int id) {
-		// Grows by adding two sides to a square, keeping both x and z positive
+		GridPos out = id > 8 ? idToGridPos(id / 9) : new GridPos(0, 0);
-		int layer = (int) Math.sqrt(num); // The layer of the square, the innermost being layer 0
+		int x = out.x * 3;
-		int layerNumber = num - layer * layer; // The number of the spot on that layer
+		int z = out.z * 3;
-		//                           | First Side   |  Second Side                     |
-		int x = layerNumber <= layer ? layer : layer - (layerNumber - layer);
-		int z = Math.min(layerNumber, layer);
 
-		return new GridPos(x, z);
+		long minor = id % 9;
+		x += (minor + 1) % 3 - 1;
+		z += (minor / 3 + 1) % 3 - 1;
+
+		out.x = x;
+		out.z = z;
+		return out;
 	}
 
+
 	/**
-	 * Calculates the element number
+	 * Calculates the element id
 	 *
 	 * @param pos The location on the grid
-	 * @return The location on the grid
+	 * @return The id of the location on the grid
 	 */
-	public static int posToNum(GridPos pos) {
+	public static int gridPosToID(GridPos pos) {
-		int x = pos.x;
+		return convToID(new Vector<>(Arrays.asList(pos.x, pos.z)));
-		int z = pos.z;
+	}
-		if (x >= z) { // First side
+
-			return x * x + z; // (number of points in the square x * x) + (z points on the top layer)
+	private static int convToID(Vector<Integer> vector) {
-		} else { // Second side
+		int x = vector.get(0);
-			return (z + 1) * z + z - x; // (number of points in the rectangle (z + 1) * z) + (z - x points on the top layer)
+		int z = vector.get(1);
+
+		int id = Math.floorMod(x, 3) + (Math.floorMod(z, 3) * 3);
+
+		x = Math.floorDiv(x + 1, 3);
+		z = Math.floorDiv(z + 1, 3);
+		if (x != 0 || z != 0) {
+			vector.set(0, x);
+			vector.set(1, z);
+			id += 9 * convToID(vector);
 		}
+		return id;
 	}
 }

src/main/java/org/dimdev/dimdoors/world/pocket/PocketDirectory.java

@@ -2,8 +2,11 @@ package org.dimdev.dimdoors.world.pocket;
 
 import java.util.HashMap;
 import java.util.Map;
+import java.util.SortedMap;
+import java.util.TreeMap;
 import java.util.stream.Collectors;
 
+import net.minecraft.util.math.Vec3i;
 import org.dimdev.dimdoors.DimensionalDoorsInitializer;
 import org.dimdev.dimdoors.util.math.GridUtil;
 
@@ -13,19 +16,29 @@ import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.registry.Registry;
 import net.minecraft.util.registry.RegistryKey;
 import net.minecraft.world.World;
+import org.dimdev.dimdoors.world.pocket.type.AbstractPocket;
+import org.dimdev.dimdoors.world.pocket.type.IdReferencePocket;
+import org.dimdev.dimdoors.world.pocket.type.Pocket;
 
 public class PocketDirectory {
 	int gridSize; // Determines how much pockets in their dimension are spaced
 	int privatePocketSize;
 	int publicPocketSize;
-	Map<Integer, Pocket> pockets;
+	Map<Integer, AbstractPocket<?>> pockets;
-	int nextID;
+	private SortedMap<Integer, Integer> nextIDMap;
 	RegistryKey<World> worldKey;
 
 	public PocketDirectory(RegistryKey<World> worldKey) {
 		this.gridSize = DimensionalDoorsInitializer.getConfig().getPocketsConfig().pocketGridSize;
 		this.worldKey = worldKey;
-		this.nextID = 0;
+		this.nextIDMap = new TreeMap<>();
+		this.pockets = new HashMap<>();
+	}
+
+	public PocketDirectory(RegistryKey<World> worldKey, int gridSize) { // for testing
+		this.gridSize = gridSize;
+		this.worldKey = worldKey;
+		this.nextIDMap = new TreeMap<>();
 		this.pockets = new HashMap<>();
 	}
 
@@ -37,8 +50,9 @@ public class PocketDirectory {
 		directory.publicPocketSize = tag.getInt("publicPocketSize");
 
 		CompoundTag pocketsTag = tag.getCompound("pockets");
-		directory.pockets = pocketsTag.getKeys().stream().collect(Collectors.toMap(Integer::parseInt, a -> Pocket.fromTag(pocketsTag.getCompound(a))));
+		directory.pockets = pocketsTag.getKeys().stream().collect(Collectors.toMap(Integer::parseInt, a -> AbstractPocket.deserialize(pocketsTag.getCompound(a))));
-		directory.nextID = tag.getInt("nextID");
+		CompoundTag nextIdMapTag = tag.getCompound("next_id_map");
+		directory.nextIDMap.putAll(nextIdMapTag.getKeys().stream().collect(Collectors.toMap(Integer::parseInt, nextIdMapTag::getInt)));
 
 		return directory;
 	}
@@ -50,9 +64,12 @@ public class PocketDirectory {
 		tag.putInt("publicPocketSize", this.publicPocketSize);
 
 		CompoundTag pocketsTag = new CompoundTag();
-		this.pockets.forEach((key, value) -> pocketsTag.put(key.toString(), value.toTag()));
+		this.pockets.forEach((key, value) -> pocketsTag.put(key.toString(), value.toTag(new CompoundTag())));
 		tag.put("pockets", pocketsTag);
-		tag.putInt("nextID", this.nextID);
+
+		CompoundTag nextIdMapTag = new CompoundTag();
+		this.nextIDMap.forEach((key, value) -> nextIdMapTag.putInt(key.toString(), value));
+		tag.put("next_id_map", nextIdMapTag);
 
 		return tag;
 	}
@@ -62,45 +79,83 @@ public class PocketDirectory {
 	 *
 	 * @return The newly created pockets
 	 */
-	public Pocket newPocket() {
+	public <T extends Pocket> T newPocket(Pocket.PocketBuilder<?, T> builder) {
-		Pocket pocket = null;
+		Vec3i size = builder.getExpectedSize();
-		while (pocket == null) pocket = this.newPocket(this.nextID++);
+		int longest = Math.max(size.getX(), size.getZ());
+		longest = ((longest - 1) / gridSize) >> 4 + 1;
+
+		int base3Size = 1;
+		while (longest > base3Size) {
+			base3Size *= 3;
+		}
+
+		int squaredSize = base3Size * base3Size;
+
+		int cursor = nextIDMap.headMap(base3Size+1).values().stream().mapToInt(num -> num).max().orElse(0);
+		cursor = cursor - Math.floorMod(cursor, squaredSize);
+
+		Pocket pocketAt = getPocket(cursor);
+		while (pocketAt != null) {
+			size = pocketAt.getSize();
+			longest = Math.max(size.getX(), size.getZ());
+			longest = ((longest - 1) / gridSize) >> 4 + 1;
+
+			int pocketBase3Size = 1;
+			while (longest > pocketBase3Size) {
+				pocketBase3Size *= 3;
+			}
+
+			System.out.println(Math.max(squaredSize, pocketBase3Size * pocketBase3Size));
+			cursor += Math.max(squaredSize, pocketBase3Size * pocketBase3Size);
+			pocketAt = getPocket(cursor);
+		}
+
+		T pocket = builder
+				.id(cursor)
+				.world(worldKey)
+				.offsetOrigin(idToPos(cursor))
+				.build();
+
+		nextIDMap.put(base3Size, cursor + squaredSize);
+		addPocket(pocket);
+
+		IdReferencePocket.IdReferencePocketBuilder idReferenceBuilder = IdReferencePocket.builder();
+		for (int i = 1; i < squaredSize; i++) {
+			addPocket(idReferenceBuilder
+					.id(cursor + i)
+					.world(worldKey)
+					.referencedId(cursor)
+					.build());
+		}
+
 		return pocket;
 	}
 
-	/**
+	private void addPocket(AbstractPocket<?> pocket) {
-	 * Create a new pockets with a specific ID.
+		pockets.put(pocket.getId(), pocket);
-	 *
-	 * @return The newly created Pocket, or null if that ID is already taken.
-	 */
-	public Pocket newPocket(int id) {
-		if (this.pockets.get(id) != null) return null;
-		GridUtil.GridPos pos = this.idToGridPos(id);
-		Pocket pocket = new Pocket(id, worldKey, pos.x, pos.z);
-		this.pockets.put(id, pocket);
-		if (id >= this.nextID) this.nextID = id + 1;
-		return pocket;
 	}
 
+	// TODO: rework this method to remove references as well
 	public void removePocket(int id) {
 		this.pockets.remove(id);
 	}
 
 	/**
-	 * Gets the pocket with a certain ID, or null if there is no pocket with that ID.
+	 * Gets the pocket that occupies the GridPos which a certain ID represents, or null if there is no pocket at that GridPos.
 	 *
-	 * @return The pocket with that ID, or null if there was no pocket with that ID.
+	 * @return The pocket which occupies the GridPos represented by that ID, or null if there was no pocket occupying that GridPos.
 	 */
 	public Pocket getPocket(int id) {
-		return this.pockets.get(id);
+		AbstractPocket<?> pocket = this.pockets.get(id);
+		return pocket == null ? null : pocket.getReferencedPocket();
 	}
 
 	public GridUtil.GridPos idToGridPos(int id) {
-		return GridUtil.numToPos(id);
+		return GridUtil.idToGridPos(id);
 	}
 
 	public int gridPosToID(GridUtil.GridPos pos) {
-		return GridUtil.posToNum(pos);
+		return GridUtil.gridPosToID(pos);
 	}
 
 	/**
@@ -146,13 +201,9 @@ public class PocketDirectory {
 		return this.publicPocketSize;
 	}
 
-	public Map<Integer, Pocket> getPockets() {
+	public Map<Integer, AbstractPocket<?>> getPockets() {
 		return this.pockets;
 	}
-
-	public int getNextID() {
-		return this.nextID;
-	}
 }
 
 

src/main/java/org/dimdev/dimdoors/world/pocket/PrivateRegistry.java

@@ -6,18 +6,14 @@ import java.util.UUID;
 import com.google.common.collect.BiMap;
 import com.google.common.collect.HashBiMap;
 
-import dev.onyxstudios.cca.api.v3.component.ComponentV3;
-import org.dimdev.dimdoors.DimensionalDoorsInitializer;
 import org.dimdev.dimdoors.world.level.DimensionalRegistry;
 
 import net.minecraft.nbt.CompoundTag;
 import net.minecraft.util.Identifier;
 import net.minecraft.util.registry.Registry;
 import net.minecraft.util.registry.RegistryKey;
-import net.minecraft.world.PersistentState;
 import net.minecraft.world.World;
-
+import org.dimdev.dimdoors.world.pocket.type.Pocket;
-import static net.minecraft.world.World.OVERWORLD;
 
 public class PrivateRegistry {
 	protected static class PocketInfo {
@@ -78,10 +74,10 @@ public class PrivateRegistry {
 	}
 
 	public void setPrivatePocketID(UUID playerUUID, Pocket pocket) {
-		this.privatePocketMap.put(playerUUID, new PocketInfo(pocket.world, pocket.id));
+		this.privatePocketMap.put(playerUUID, new PocketInfo(pocket.getWorld(), pocket.getId()));
 	}
 
 	public UUID getPrivatePocketOwner(Pocket pocket) {
-		return this.privatePocketMap.inverse().get(new PocketInfo(pocket.world, pocket.id));
+		return this.privatePocketMap.inverse().get(new PocketInfo(pocket.getWorld(), pocket.getId()));
 	}
 }

src/main/java/org/dimdev/dimdoors/world/pocket/VirtualLocation.java

@@ -16,6 +16,7 @@ import net.minecraft.util.registry.Registry;
 import net.minecraft.util.registry.RegistryKey;
 import net.minecraft.world.Heightmap;
 import net.minecraft.world.World;
+import org.dimdev.dimdoors.world.pocket.type.Pocket;
 
 import static net.minecraft.world.World.OVERWORLD;
 

src/main/java/org/dimdev/dimdoors/world/pocket/type/AbstractPocket.java

@@ -0,0 +1,149 @@
+package org.dimdev.dimdoors.world.pocket.type;
+
+import com.mojang.serialization.Lifecycle;
+import net.fabricmc.fabric.api.event.registry.FabricRegistryBuilder;
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.util.Identifier;
+import net.minecraft.util.math.Vec3i;
+import net.minecraft.util.registry.Registry;
+import net.minecraft.util.registry.RegistryKey;
+import net.minecraft.util.registry.SimpleRegistry;
+import net.minecraft.world.World;
+
+import java.util.Map;
+import java.util.function.Supplier;
+
+public abstract class AbstractPocket<V extends AbstractPocket<V>> {
+	public static final Registry<AbstractPocketType<? extends AbstractPocket<?>>> REGISTRY = FabricRegistryBuilder.from(new SimpleRegistry<AbstractPocketType<? extends AbstractPocket<?>>>(RegistryKey.ofRegistry(new Identifier("dimdoors", "abstract_pocket_type")), Lifecycle.stable())).buildAndRegister();
+
+	protected int id;
+	protected RegistryKey<World> world;
+
+	public AbstractPocket(int id, RegistryKey<World> world) {
+		this.id = id;
+		this.world = world;
+	}
+
+	protected AbstractPocket() {
+	}
+
+	public int getId() {
+		return id;
+	}
+
+	public static AbstractPocket<? extends AbstractPocket<?>> deserialize(CompoundTag tag) {
+		Identifier id = Identifier.tryParse(tag.getString("type"));
+		return REGISTRY.get(id).fromTag(tag);
+	}
+
+	public static CompoundTag serialize(AbstractPocket<?> pocket) {
+		return pocket.toTag(new CompoundTag());
+	}
+
+	public V fromTag(CompoundTag tag) {
+		this.id = tag.getInt("id");
+		this.world = RegistryKey.of(Registry.DIMENSION, new Identifier(tag.getString("world")));
+
+		return (V) this;
+	}
+
+	public CompoundTag toTag(CompoundTag tag) {
+		tag.putInt("id", id);
+		tag.putString("world", world.getValue().toString());
+
+		getType().toTag(tag);
+
+		return tag;
+	}
+
+	public abstract AbstractPocketType<V> getType();
+
+	public Map<String, Double> toVariableMap(Map<String, Double> variableMap) {
+		variableMap.put("id", (double) this.id);
+		return variableMap;
+	}
+
+	public abstract Pocket getReferencedPocket();
+
+	public RegistryKey<World> getWorld() {
+		return world;
+	}
+
+	public interface AbstractPocketType<T extends AbstractPocket<?>> {
+		AbstractPocketType<IdReferencePocket> ID_REFERENCE = register(new Identifier("dimdoors", IdReferencePocket.KEY), IdReferencePocket::new, IdReferencePocket::builder);
+
+		AbstractPocketType<Pocket> POCKET = register(new Identifier("dimdoors", Pocket.KEY), Pocket::new, Pocket::builder);
+
+
+		T fromTag(CompoundTag tag);
+
+		CompoundTag toTag(CompoundTag tag);
+
+		T instance();
+
+		AbstractPocketBuilder<?, T> builder();
+
+		static void register() {
+		}
+
+		static <U extends AbstractPocket<U>> AbstractPocketType<U> register(Identifier id, Supplier<U> supplier, Supplier<AbstractPocketBuilder<?, U>> factorySupplier) {
+			return Registry.register(REGISTRY, id, new AbstractPocketType<U>() {
+				@Override
+				public U fromTag(CompoundTag tag) {
+					return supplier.get().fromTag(tag);
+				}
+
+				@Override
+				public CompoundTag toTag(CompoundTag tag) {
+					tag.putString("type", id.toString());
+					return tag;
+				}
+
+				@Override
+				public U instance() {
+					return supplier.get();
+				}
+
+				@Override
+				public AbstractPocketBuilder<?, U> builder() {
+					return factorySupplier.get();
+				}
+			});
+		}
+	}
+
+	public static abstract class AbstractPocketBuilder<P extends AbstractPocketBuilder<P, T>, T extends AbstractPocket<?>> {
+		private final AbstractPocketType<T> type;
+
+		private int id;
+		private RegistryKey<World> world;
+
+		//TODO: fromTag/ toTag for reading builders from json, in subclasses as well
+		protected AbstractPocketBuilder(AbstractPocketType<T> type) {
+			this.type = type;
+		}
+
+		public Vec3i getExpectedSize() {
+			return new Vec3i(1, 1, 1);
+		}
+
+		public T build() {
+			T instance = type.instance();
+
+			instance.id = id;
+			instance.world = world;
+
+			return instance;
+		}
+
+		public P id(int id) {
+			this.id = id;
+			return (P) this;
+		}
+
+		public P world(RegistryKey<World> world) {
+			this.world = world;
+			return (P) this;
+		}
+	}
+}

src/main/java/org/dimdev/dimdoors/world/pocket/type/IdReferencePocket.java

@@ -0,0 +1,62 @@
+package org.dimdev.dimdoors.world.pocket.type;
+
+import net.minecraft.nbt.CompoundTag;
+import org.dimdev.dimdoors.world.level.DimensionalRegistry;
+
+public class IdReferencePocket extends AbstractPocket<IdReferencePocket> {
+	public static String KEY = "id_reference";
+
+	protected int referencedId;
+
+	@Override
+	public IdReferencePocket fromTag(CompoundTag tag) {
+		super.fromTag(tag);
+
+		this.referencedId = tag.getInt("referenced_id");
+
+		return this;
+	}
+
+	@Override
+	public CompoundTag toTag(CompoundTag tag) {
+		tag = super.toTag(tag);
+
+		tag.putInt("referenced_id", referencedId);
+
+		return tag;
+	}
+
+	@Override
+	public AbstractPocketType<IdReferencePocket> getType() {
+		return AbstractPocketType.ID_REFERENCE;
+	}
+
+	@Override
+	public Pocket getReferencedPocket() {
+		return DimensionalRegistry.getPocketDirectory(getWorld()).getPocket(referencedId);
+	}
+
+	public static IdReferencePocketBuilder builder() {
+		return new IdReferencePocketBuilder(AbstractPocketType.ID_REFERENCE);
+	}
+
+	public static class IdReferencePocketBuilder extends AbstractPocketBuilder<IdReferencePocketBuilder, IdReferencePocket> {
+		private int referencedId;
+
+		protected IdReferencePocketBuilder(AbstractPocketType<IdReferencePocket> type) {
+			super(type);
+		}
+
+		@Override
+		public IdReferencePocket build() {
+			IdReferencePocket pocket = super.build();
+			pocket.referencedId = referencedId;
+			return pocket;
+		}
+
+		public IdReferencePocketBuilder referencedId(int referencedId) {
+			this.referencedId = referencedId;
+			return this;
+		}
+	}
+}

src/main/java/org/dimdev/dimdoors/world/pocket/type/Pocket.java

@@ -1,4 +1,4 @@
-package org.dimdev.dimdoors.world.pocket;
+package org.dimdev.dimdoors.world.pocket.type;
 
 import java.util.HashMap;
 import java.util.Map;
@@ -21,47 +21,38 @@ import net.minecraft.nbt.CompoundTag;
 import net.minecraft.server.world.ServerWorld;
 import net.minecraft.text.TranslatableText;
 import net.minecraft.util.DyeColor;
-import net.minecraft.util.Identifier;
 import net.minecraft.util.math.BlockBox;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.math.ChunkPos;
 import net.minecraft.util.math.Vec3i;
-import net.minecraft.util.registry.Registry;
 import net.minecraft.util.registry.RegistryKey;
 import net.minecraft.world.World;
+import org.dimdev.dimdoors.world.pocket.VirtualLocation;
+
+public final class Pocket extends AbstractPocket<Pocket> {
+	public static String KEY = "pocket";
 
-public final class Pocket {
 	private static final int BLOCKS_PAINTED_PER_DYE = 1000000;
 
-	// TODO: please someone make all these private and add a getter & setter where needed
+
-	public final int id;
+	public BlockBox box; // TODO: make protected
-	public BlockBox box;
 	public VirtualLocation virtualLocation;
-	public PocketColor dyeColor = PocketColor.WHITE;
+	protected PocketColor dyeColor = PocketColor.WHITE;
-	public PocketColor nextDyeColor = PocketColor.NONE;
+	private PocketColor nextDyeColor = PocketColor.NONE;
-	public int count = 0;
+	private int count = 0;
-
-	public RegistryKey<World> world;
-
-	private Pocket(int id, BlockBox box, VirtualLocation virtualLocation, PocketColor dyeColor, PocketColor nextDyeColor, int count, RegistryKey<World> world) {
-		this.id = id;
-		this.box = box;
-		this.virtualLocation = virtualLocation;
-		this.dyeColor = dyeColor;
-		this.nextDyeColor = nextDyeColor;
-		this.count = count;
-		this.world = world;
-	}
 
 	public Pocket(int id, RegistryKey<World> world, int x, int z) {
+		super(id, world);
 		int gridSize = DimensionalRegistry.getPocketDirectory(world).getGridSize() * 16;
-		this.id = id;
-		this.world = world;
 		this.box = BlockBox.create(x * gridSize, 0, z * gridSize, (x + 1) * gridSize, 0, (z + 1) * gridSize);
 		this.virtualLocation = new VirtualLocation(world, x, z, 0);
 	}
 
-	boolean isInBounds(BlockPos pos) {
+	protected Pocket() {
+
+	}
+
+	public boolean isInBounds(BlockPos pos) {
 		return this.box.contains(pos);
 	}
 
@@ -107,7 +98,7 @@ public final class Pocket {
 	}
 
     private void repaint(DyeColor dyeColor) {
-        ServerWorld serverWorld = DimensionalDoorsInitializer.getWorld(world);
+        ServerWorld serverWorld = DimensionalDoorsInitializer.getWorld(getWorld());
         BlockState innerWall = ModBlocks.fabricFromDye(dyeColor).getDefaultState();
         BlockState outerWall = ModBlocks.ancientFabricFromDye(dyeColor).getDefaultState();
 
@@ -135,34 +126,35 @@ public final class Pocket {
 		this.box = BlockBox.create(this.box.minX, this.box.minY, this.box.minZ, this.box.minX + x - 1, this.box.minY + y - 1, this.box.minZ + z - 1);
 	}
 
-	public Vector3i getSize() {
+	public Vec3i getSize() {
-		Vec3i dimensions = this.box.getDimensions();
+		return this.box.getDimensions();
-		return new Vector3i(dimensions.getX(), dimensions.getY(), dimensions.getZ());
 	}
 
-	public CompoundTag toTag() {
+	public CompoundTag toTag(CompoundTag tag) {
-		CompoundTag tag = new CompoundTag();
+		super.toTag(tag);
-		tag.putInt("id", this.id);
 		tag.putIntArray("box", IntStream.of(this.box.minX, this.box.minY, this.box.minZ, this.box.maxX, this.box.maxY, this.box.maxZ).toArray());
 		tag.put("virtualLocation", VirtualLocation.toTag(this.virtualLocation));
 		tag.putInt("dyeColor", this.dyeColor.getId());
 		tag.putInt("nextDyeColor", this.nextDyeColor.getId());
 		tag.putInt("count", this.count);
-		tag.putString("world", world.getValue().toString());
 		return tag;
 	}
 
-	public static Pocket fromTag(CompoundTag tag) {
+	@Override
+	public AbstractPocketType<Pocket> getType() {
+		return AbstractPocketType.POCKET;
+	}
+
+	public Pocket fromTag(CompoundTag tag) {
+		super.fromTag(tag);
 		int[] box = tag.getIntArray("box");
-		return new Pocket(
+		this.box = new BlockBox(box[0], box[1], box[2], box[3], box[4], box[5]);
-				tag.getInt("id"),
+		this.virtualLocation = VirtualLocation.fromTag(tag.getCompound("virtualLocation"));
-				new BlockBox(box[0], box[1], box[2], box[3], box[4], box[5]),
+		this.dyeColor = PocketColor.from(tag.getInt("dyeColor"));
-				VirtualLocation.fromTag(tag.getCompound("virtualLocation")),
+		this.nextDyeColor = PocketColor.from(tag.getInt("nextDyeColor"));
-				PocketColor.from(tag.getInt("dyeColor")),
+		this.count = tag.getInt("count");
-				PocketColor.from(tag.getInt("nextDyeColor")),
+
-				tag.getInt("count"),
+		return this;
-				RegistryKey.of(Registry.DIMENSION, new Identifier(tag.getString("world")))
-		);
 	}
 
 	public enum PocketColor {
@@ -224,7 +216,7 @@ public final class Pocket {
 	}
 
 	public Map<BlockPos, BlockEntity> getBlockEntities() {
-		ServerWorld serverWorld = DimensionalDoorsInitializer.getWorld(this.world);
+		ServerWorld serverWorld = DimensionalDoorsInitializer.getWorld(this.getWorld());
 		Map<BlockPos, BlockEntity> blockEntities = new HashMap<>();
 		ChunkPos.stream(new ChunkPos(new BlockPos(box.minX, box.minY, box.minZ)), new ChunkPos(new BlockPos(box.maxX, box.maxY, box.maxZ))).forEach(chunkPos -> serverWorld.getChunk(chunkPos.x, chunkPos.z).getBlockEntities().forEach((blockPos, blockEntity) -> {
 			if (this.box.contains(blockPos)) blockEntities.put(blockPos, blockEntity);
@@ -236,20 +228,83 @@ public final class Pocket {
 		return box;
 	}
 
-	public Map<String, Double> toVariableMap(Map<String, Double> stringDoubleMap) {
+	public Map<String, Double> toVariableMap(Map<String, Double> variableMap) {
-		stringDoubleMap.put("originX", (double) this.box.minX);
+		variableMap = super.toVariableMap(variableMap);
-		stringDoubleMap.put("originY", (double) this.box.minY);
+		variableMap.put("originX", (double) this.box.minX);
-		stringDoubleMap.put("originZ", (double) this.box.minZ);
+		variableMap.put("originY", (double) this.box.minY);
-		stringDoubleMap.put("width", (double) this.box.getDimensions().getX());
+		variableMap.put("originZ", (double) this.box.minZ);
-		stringDoubleMap.put("height", (double) this.box.getDimensions().getY());
+		variableMap.put("width", (double) this.box.getDimensions().getX());
-		stringDoubleMap.put("length", (double) this.box.getDimensions().getZ());
+		variableMap.put("height", (double) this.box.getDimensions().getY());
-		stringDoubleMap.put("depth", (double) this.virtualLocation.getDepth());
+		variableMap.put("length", (double) this.box.getDimensions().getZ());
-		stringDoubleMap.put("id", (double) this.id); // don't really know why you would need this but it's there if needed
+		variableMap.put("depth", (double) this.virtualLocation.getDepth());
-		return stringDoubleMap;
+		return variableMap;
+	}
+
+	@Override
+	public Pocket getReferencedPocket() {
+		return this;
 	}
 
 	public void expand(int amount) {
 		if (amount == 0) return;
 		this.box = BlockBox.create(box.minX - amount, box.minY - amount, box.minZ - amount, box.maxX + amount, box.maxY + amount, box.maxZ + amount);
 	}
+
+	public static PocketBuilder<?, Pocket> builder() {
+		return new PocketBuilder<>(AbstractPocketType.POCKET);
+	}
+
+	// TODO: flesh this out a bit more, stuff like box() makes little sense in how it is implemented atm
+	public static class PocketBuilder<P extends PocketBuilder<P, T>, T extends Pocket> extends AbstractPocketBuilder<P, T> {
+		private Vec3i origin = new Vec3i(0, 0, 0);
+		private Vec3i size = new Vec3i(0, 0, 0);
+		private Vec3i expected = new Vec3i(0, 0, 0);
+		private VirtualLocation virtualLocation;
+		private PocketColor dyeColor = PocketColor.NONE;
+
+		protected PocketBuilder(AbstractPocketType<T> type) {
+			super(type);
+		}
+
+		@Override
+		public Vec3i getExpectedSize() {
+			return expected;
+		}
+
+		public T build() {
+			T instance = super.build();
+
+			instance.box = BlockBox.create(origin.getX(), origin.getY(), origin.getZ(), origin.getX() + size.getX(), origin.getY() + size.getY(), origin.getZ() + size.getZ());
+			instance.virtualLocation = virtualLocation;
+			instance.dyeColor = dyeColor;
+
+			return instance;
+		}
+
+		public P offsetOrigin(Vec3i offset) {
+			this.origin = new Vec3i(origin.getX() + offset.getX(), origin.getY() + offset.getY(), origin.getZ() + offset.getZ());
+			return (P) this;
+		}
+
+		public P expand(Vec3i expander) {
+			this.size = new Vec3i(size.getX() + expander.getX(), size.getY() + expander.getY(), size.getZ() + expander.getZ());
+			this.expected = new Vec3i(expected.getX() + expander.getX(), expected.getY() + expander.getY(), expected.getZ() + expander.getZ());
+			return (P) this;
+		}
+
+		public P expandExpected(Vec3i expander) {
+			this.expected = new Vec3i(expected.getX() + expander.getX(), expected.getY() + expander.getY(), expected.getZ() + expander.getZ());
+			return (P) this;
+		}
+
+		public P virtualLocation(VirtualLocation virtualLocation) {
+			this.virtualLocation = virtualLocation;
+			return (P) this;
+		}
+
+		public P dyeColor(PocketColor dyeColor) {
+			this.dyeColor = dyeColor;
+			return (P) this;
+		}
+	}
 }

src/test/java/org/dimdev/dimdoors/util/math/GridUtilTest.java

@@ -0,0 +1,29 @@
+package org.dimdev.dimdoors.util.math;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.Vector;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class GridUtilTest {
+
+	@Test
+	void idToGridPos() {
+		GridUtil.GridPos pos;
+		// I scribbled the grid down so I could figure out these tests, lmao
+		pos = GridUtil.idToGridPos(86);
+		assertEquals(new GridUtil.GridPos(8, 1), pos);
+		pos = GridUtil.idToGridPos(90);
+		assertEquals(new GridUtil.GridPos(12, 0), pos);
+		pos = GridUtil.idToGridPos(100);
+		assertEquals(new GridUtil.GridPos(7, 0), pos);
+	}
+
+	@Test
+	void conversionConsistencyTest() {
+		for (int i = 0; i < 1000; i++) {
+			assertEquals(i, GridUtil.gridPosToID(GridUtil.idToGridPos(i)));
+		}
+	}
+}

src/test/java/org/dimdev/dimdoors/world/pocket/PocketDirectoryTest.java

@@ -0,0 +1,46 @@
+package org.dimdev.dimdoors.world.pocket;
+
+import net.minecraft.util.math.Vec3i;
+import org.dimdev.dimdoors.world.ModDimensions;
+import org.dimdev.dimdoors.world.pocket.type.Pocket;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class PocketDirectoryTest {
+
+
+	//@Test
+	void newPocket() {
+		PocketDirectory directory = new PocketDirectory(ModDimensions.DUNGEON, 512);
+
+		Pocket.PocketBuilder<?, ?> builder = Pocket.builder().expand(new Vec3i(1, 1, 1));
+
+		assertEquals(0, directory.newPocket(builder).getId());
+		assertEquals(1, directory.newPocket(builder).getId());
+		assertEquals(2, directory.newPocket(builder).getId());
+		assertEquals(3, directory.newPocket(builder).getId());
+		assertEquals(4, directory.newPocket(builder).getId());
+		assertEquals(5, directory.newPocket(builder).getId());
+		assertEquals(6, directory.newPocket(builder).getId());
+
+
+
+		builder = Pocket.builder().expand(new Vec3i(directory.getGridSize() + 1, directory.getGridSize() + 1, directory.getGridSize() + 1));
+		assertEquals(9, directory.newPocket(builder).getId());
+		assertEquals(18, directory.newPocket(builder).getId());
+
+		builder = Pocket.builder().expand(new Vec3i(3 * directory.getGridSize() + 1, 3 * directory.getGridSize() + 1, 3 * directory.getGridSize() + 1));
+		assertEquals(81, directory.newPocket(builder).getId());
+
+
+
+		Pocket.builder().expand(new Vec3i(directory.getGridSize() + 1, directory.getGridSize() + 1, directory.getGridSize() + 1));
+		assertEquals(27, directory.newPocket(builder).getId());
+
+		builder = Pocket.builder().expand(new Vec3i(1, 1, 1));
+		assertEquals(7, directory.newPocket(builder).getId());
+		assertEquals(8, directory.newPocket(builder).getId());
+		assertEquals(36, directory.newPocket(builder).getId());
+	}
+}