it has been done

public pockets via VoidGenerator, ShellModifier and DimensionalDoorModifier

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

@@ -13,6 +13,7 @@ import org.dimdev.dimdoors.particle.ModParticleTypes;
 import org.dimdev.dimdoors.pockets.SchematicHandler;
 import org.dimdev.dimdoors.pockets.SchematicV2Handler;
 import org.dimdev.dimdoors.pockets.virtual.VirtualSingularPocket;
+import org.dimdev.dimdoors.pockets.virtual.modifier.Modifier;
 import org.dimdev.dimdoors.rift.targets.Targets;
 import org.dimdev.dimdoors.rift.targets.VirtualTarget;
 import org.dimdev.dimdoors.sound.ModSoundEvents;
@@ -82,6 +83,8 @@ public class DimensionalDoorsInitializer implements ModInitializer {
 
 		VirtualSingularPocket.VirtualSingularPocketType.register();
 
+		Modifier.ModifierType.register();
+
         SchematicV2Handler.getInstance().load();
         SchematicHandler.INSTANCE.loadSchematics();
     }

src/main/java/org/dimdev/dimdoors/block/entity/RiftBlockEntity.java

@@ -110,7 +110,7 @@ public abstract class RiftBlockEntity extends BlockEntity implements BlockEntity
 	}
 
 	public boolean isRegistered() {
-		return !PocketTemplate.isReplacingPlaceholders() && DimensionalRegistry.getRiftRegistry().isRiftAt(new Location((ServerWorld) this.world, this.pos));
+		return !PocketTemplate.isReplacingPlaceholders() && this.world != null && DimensionalRegistry.getRiftRegistry().isRiftAt(new Location((ServerWorld) this.world, this.pos));
 	}
 
 	public void register() {

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

@@ -44,7 +44,7 @@ public abstract class VirtualGeneratorPocket extends VirtualSingularPocket {
 	}
 
 	public VirtualGeneratorPocket fromTag(CompoundTag tag) {
-		this.weight = tag.contains("weight") ? tag.getString("weight") : "5";
+		this.weight = tag.contains("weight") ? tag.getString("weight") : defaultWeightEquation;
 		try {
 			this.weightEquation = StringEquationParser.parse(weight);
 		} catch (StringEquationParser.EquationParseException e) {
@@ -53,7 +53,7 @@ public abstract class VirtualGeneratorPocket extends VirtualSingularPocket {
 				this.weightEquation = StringEquationParser.parse(defaultWeightEquation);
 			} catch (StringEquationParser.EquationParseException equationParseException) {
 				LOGGER.error("Could not parse default weight equation \"" + defaultWeightEquation + "\", defaulting to fallback weight \"" + fallbackWeight + "\"", equationParseException);
-				this.weightEquation = stringDoubleMap -> 5d;
+				this.weightEquation = stringDoubleMap -> fallbackWeight;
 			}
 		}
 

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

@@ -9,6 +9,7 @@ import net.minecraft.util.registry.RegistryKey;
 import net.minecraft.util.registry.SimpleRegistry;
 import org.dimdev.dimdoors.pockets.virtual.generator.ChunkGenerator;
 import org.dimdev.dimdoors.pockets.virtual.generator.SchematicGenerator;
+import org.dimdev.dimdoors.pockets.virtual.generator.VoidGenerator;
 import org.dimdev.dimdoors.pockets.virtual.selection.DepthDependentSelector;
 import org.dimdev.dimdoors.util.PocketGenerationParameters;
 import org.dimdev.dimdoors.util.Weighted;
@@ -60,6 +61,7 @@ public abstract class VirtualSingularPocket implements VirtualPocket {
 	public interface VirtualSingularPocketType<T extends VirtualSingularPocket> {
 		VirtualSingularPocketType<SchematicGenerator> SCHEMATIC = register(new Identifier("dimdoors", SchematicGenerator.KEY), SchematicGenerator::new);
 		VirtualSingularPocketType<ChunkGenerator> CHUNK = register(new Identifier("dimdoors", ChunkGenerator.KEY), ChunkGenerator::new);
+		VirtualSingularPocketType<VoidGenerator> VOID = register(new Identifier("dimdoors", VoidGenerator.KEY), VoidGenerator::new);
 
 		VirtualSingularPocketType<DepthDependentSelector> DEPTH_DEPENDENT = register(new Identifier("dimdoors", DepthDependentSelector.KEY), DepthDependentSelector::new);
 

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

@@ -51,6 +51,8 @@ public class ChunkGenerator extends VirtualGeneratorPocket {
 
 	@Override
 	public VirtualGeneratorPocket fromTag(CompoundTag tag) {
+		super.fromTag(tag);
+
 		this.dimensionID = new Identifier(tag.getString("dimension_id"));
 
 		int[] temp = tag.getIntArray("size");
@@ -69,7 +71,9 @@ public class ChunkGenerator extends VirtualGeneratorPocket {
 
 		tag.putString("dimension_id", dimensionID.toString());
 		tag.putIntArray("size", new int[]{this.size.getX(), this.size.getY(), this.size.getZ()});
+		if (!(offset.getX() == 0 && offset.getY() == 0 && offset.getZ() == 0)) {
 			tag.putIntArray("offset", new int[]{this.offset.getX(), this.offset.getY(), this.offset.getZ()});
+		}
 		tag.putInt("virtual_y_offset", this.virtualYOffset);
 		return tag;
 	}
@@ -87,7 +91,7 @@ public class ChunkGenerator extends VirtualGeneratorPocket {
 		int ChunkSizeZ = ((this.size.getZ() >> 4) + (this.size.getZ() % 16 == 0 ? 0 : 1));
 
 		Pocket pocket = DimensionalRegistry.getPocketDirectory(world.getRegistryKey()).newPocket();
-		pocket.setSize(size.getX(), size.getY(), size.getZ());
+		pocket.setSize(size);
 		pocket.offsetOrigin(offset);
 
 		LOGGER.info("Generating chunk pocket at location " + pocket.getOrigin());

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

@@ -0,0 +1,98 @@
+package org.dimdev.dimdoors.pockets.virtual.generator;
+
+import net.minecraft.nbt.CompoundTag;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.dimdev.dimdoors.pockets.PocketGroup;
+import org.dimdev.dimdoors.pockets.virtual.VirtualGeneratorPocket;
+import org.dimdev.dimdoors.pockets.virtual.VirtualSingularPocket;
+import org.dimdev.dimdoors.util.PocketGenerationParameters;
+import org.dimdev.dimdoors.util.math.StringEquationParser;
+import org.dimdev.dimdoors.world.level.DimensionalRegistry;
+import org.dimdev.dimdoors.world.pocket.Pocket;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class VoidGenerator extends VirtualGeneratorPocket {
+	private static final Logger LOGGER = LogManager.getLogger();
+	public static final String KEY = "void";
+	private String width;
+	private StringEquationParser.Equation heightEquation;
+	private String height;
+	private StringEquationParser.Equation widthEquation;
+	private String length;
+	private StringEquationParser.Equation lengthEquation;
+	private String offsetX;
+	private StringEquationParser.Equation offsetXEquation;
+	private String offsetY;
+	private StringEquationParser.Equation offsetYEquation;
+	private String offsetZ;
+	private StringEquationParser.Equation offsetZEquation;
+
+	@Override
+	public void init(PocketGroup group) { }
+
+	@Override
+	public Pocket prepareAndPlacePocket(PocketGenerationParameters parameters) {
+		Pocket pocket = DimensionalRegistry.getPocketDirectory(parameters.getWorld().getRegistryKey()).newPocket();
+		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));
+
+		applyModifiers(pocket, parameters);
+		setup(pocket, parameters, false);
+
+		return pocket;
+	}
+
+	@Override
+	public VirtualSingularPocketType<? extends VirtualSingularPocket> getType() {
+		return VirtualSingularPocketType.VOID;
+	}
+
+	@Override
+	public String getKey() {
+		return KEY;
+	}
+
+	@Override
+	public VirtualGeneratorPocket fromTag(CompoundTag tag) {
+		super.fromTag(tag);
+
+		try {
+			width = tag.getString("width");
+			widthEquation = StringEquationParser.parse(width);
+			height = tag.getString("height");
+			heightEquation = StringEquationParser.parse(height);
+			length = tag.getString("length");
+			lengthEquation = StringEquationParser.parse(length);
+
+			offsetX = tag.contains("offset_x") ? tag.getString("offset_x") : "0";
+			offsetXEquation = StringEquationParser.parse(offsetX);
+			offsetY = tag.contains("offset_y") ? tag.getString("offset_y") : "0";
+			offsetYEquation = StringEquationParser.parse(offsetY);
+			offsetZ = tag.contains("offset_z") ? tag.getString("offset_z") : "0";
+			offsetZEquation = StringEquationParser.parse(offsetZ);
+		} catch (StringEquationParser.EquationParseException e) {
+			LOGGER.error(e);
+		}
+
+		return this;
+	}
+
+	@Override
+	public CompoundTag toTag(CompoundTag tag) {
+		super.toTag(tag);
+
+		tag.putString("width", width);
+		tag.putString("height", height);
+		tag.putString("length", length);
+
+		if (!offsetX.equals("0")) tag.putString("offset_x", offsetX);
+		if (!offsetY.equals("0")) tag.putString("offset_y", offsetY);
+		if (!offsetZ.equals("0")) tag.putString("offset_z", offsetZ);
+
+		return tag;
+	}
+}

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

@@ -1,34 +1,90 @@
 package org.dimdev.dimdoors.pockets.virtual.modifier;
 
-import com.google.common.collect.ImmutableMap;
+import java.util.Collections;
-
+import java.util.HashMap;
 import java.util.Map;
-import java.util.function.Function;
 
+import net.minecraft.block.Block;
+import net.minecraft.block.BlockState;
+import net.minecraft.block.enums.DoubleBlockHalf;
 import net.minecraft.nbt.CompoundTag;
+import net.minecraft.server.world.ServerWorld;
+import net.minecraft.util.Identifier;
 import net.minecraft.util.math.BlockPos;
 
-import com.flowpowered.math.vector.Vector3i;
+import net.minecraft.util.math.Direction;
+import net.minecraft.util.registry.Registry;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.dimdev.dimdoors.block.DimensionalDoorBlock;
+import org.dimdev.dimdoors.block.ModBlocks;
+import org.dimdev.dimdoors.block.entity.EntranceRiftBlockEntity;
+import org.dimdev.dimdoors.block.entity.ModBlockEntityTypes;
+import org.dimdev.dimdoors.rift.registry.LinkProperties;
+import org.dimdev.dimdoors.rift.targets.PocketEntranceMarker;
+import org.dimdev.dimdoors.rift.targets.PocketExitMarker;
 import org.dimdev.dimdoors.util.PocketGenerationParameters;
 import org.dimdev.dimdoors.util.math.StringEquationParser;
 import org.dimdev.dimdoors.world.pocket.Pocket;
 
 public class DimensionalDoorModifier implements Modifier {
-	StringEquationParser.Equation x;
+	private static final Logger LOGGER = LogManager.getLogger();
-	StringEquationParser.Equation y;
+	public static final String KEY = "door";
-	StringEquationParser.Equation z;
+
+	private Direction facing;
+	private String doorTypeString;
+	private DimensionalDoorBlock doorType;
+
+	private String x;
+	private String y;
+	private String z;
+	private StringEquationParser.Equation xEquation;
+	private StringEquationParser.Equation yEquation;
+	private StringEquationParser.Equation zEquation;
+
 
 	@Override
 	public Modifier fromTag(CompoundTag tag) {
+		String facingString = tag.getString("facing");
+		facing = Direction.byName(tag.getString("facing"));
+		if (facing == null || facing.getAxis().isVertical()) {
+			LOGGER.error("Could not interpret facing direction \"" + facingString + "\"");
+			facing = Direction.NORTH;
+		}
+
+		doorTypeString = tag.getString("door_type");
+		Block doorBlock = Registry.BLOCK.get(Identifier.tryParse(doorTypeString));
+		if (!(doorBlock instanceof DimensionalDoorBlock)) {
+			LOGGER.error("Could not interpret door type \"" + doorTypeString + "\"");
+			doorBlock = ModBlocks.IRON_DIMENSIONAL_DOOR;
+		}
+		doorType = (DimensionalDoorBlock) doorBlock;
+
 		try {
-			x = StringEquationParser.parse(tag.getString("x"));
+			x = tag.getString("x");
-			y = StringEquationParser.parse(tag.getString("y"));
+			y = tag.getString("y");
-			z = StringEquationParser.parse(tag.getString("z"));
+			z = tag.getString("z");
+
+			xEquation = StringEquationParser.parse(x);
+			yEquation = StringEquationParser.parse(y);
+			zEquation = StringEquationParser.parse(z);
 		} catch (StringEquationParser.EquationParseException e) {
-			e.printStackTrace();
+			LOGGER.error(e);
 		}
 		return this;
+	}
 
+	@Override
+	public CompoundTag toTag(CompoundTag tag) {
+		Modifier.super.toTag(tag);
+
+		tag.putString("facing", facing.asString());
+		tag.putString("door_type", doorTypeString);
+		tag.putString("x", x);
+		tag.putString("y", y);
+		tag.putString("z", z);
+
+		return tag;
 	}
 
 	@Override
@@ -38,16 +94,24 @@ public class DimensionalDoorModifier implements Modifier {
 
 	@Override
 	public String getKey() {
-		return "dimensional_doors";
+		return KEY;
 	}
 
 	@Override
 	public void apply(Pocket pocket, PocketGenerationParameters parameters) {
-		Vector3i size = pocket.getSize();
+		Map<String, Double> variableMap = pocket.toVariableMap(new HashMap<>());
-		Map<String, Double> variables = ImmutableMap.of("width", (double) size.getX(), "height", (double) size.getY(), "length", (double) size.getZ());
+		BlockPos pocketOrigin = pocket.getOrigin();
-
+		BlockPos pos = new BlockPos(xEquation.apply(variableMap) + pocketOrigin.getX(), yEquation.apply(variableMap) + pocketOrigin.getY(), zEquation.apply(variableMap) + pocketOrigin.getZ());
-		BlockPos pos = new BlockPos(x.apply(variables), y.apply(variables), z.apply(variables));
 
+		ServerWorld world = parameters.getWorld();
+		BlockState lower = doorType.getDefaultState().with(DimensionalDoorBlock.HALF, DoubleBlockHalf.LOWER).with(DimensionalDoorBlock.FACING, facing);
+		world.setBlockState(pos, lower);
+		world.setBlockState(pos.up(), doorType.getDefaultState().with(DimensionalDoorBlock.HALF, DoubleBlockHalf.UPPER).with(DimensionalDoorBlock.FACING, facing));
 
+		// TODO: make the rifts be built more dynamically
+		EntranceRiftBlockEntity rift = ModBlockEntityTypes.ENTRANCE_RIFT.instantiate();
+		rift.setDestination(PocketEntranceMarker.builder().ifDestination(new PocketExitMarker()).weight(1f).build());
+		rift.setProperties(LinkProperties.builder().entranceWeight(1f).groups(Collections.singleton(1)).floatingWeight(1f).linksRemaining(1).oneWay(false).build());
+		world.setBlockEntity(pos, rift);
 	}
 }

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

@@ -39,8 +39,8 @@ public interface Modifier {
 	void apply(Pocket pocket, PocketGenerationParameters parameters);
 
 	interface ModifierType<T extends Modifier> {
-		public static ModifierType<ShellModifier> SHELL_MODIFIER_TYPE = register(new Identifier("dimdoors:shell"), ShellModifier::new);
+		ModifierType<ShellModifier> SHELL_MODIFIER_TYPE = register(new Identifier("dimdoors", ShellModifier.KEY), ShellModifier::new);
-		public static ModifierType<DimensionalDoorModifier> DIMENSIONAL_DOOR_MODIFIER_TYPE = register(new Identifier("dimdoors:dimensional_door"), DimensionalDoorModifier::new);
+		ModifierType<DimensionalDoorModifier> DIMENSIONAL_DOOR_MODIFIER_TYPE = register(new Identifier("dimdoors", DimensionalDoorModifier.KEY), DimensionalDoorModifier::new);
 
 		Modifier fromTag(CompoundTag tag);
 

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

@@ -4,44 +4,40 @@ import java.util.ArrayList;
 import java.util.List;
 import java.util.stream.IntStream;
 
+import com.mojang.brigadier.exceptions.CommandSyntaxException;
 import net.minecraft.block.Block;
 import net.minecraft.block.BlockState;
 import net.minecraft.block.Blocks;
-import net.minecraft.nbt.CompoundTag;
+import net.minecraft.nbt.*;
-import net.minecraft.nbt.IntTag;
+import net.minecraft.server.world.ServerWorld;
-import net.minecraft.nbt.ListTag;
-import net.minecraft.nbt.Tag;
 import net.minecraft.util.Identifier;
+import net.minecraft.util.math.BlockBox;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.math.Box;
 import net.minecraft.util.registry.Registry;
 
 import net.fabricmc.fabric.api.util.NbtType;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
 import org.dimdev.dimdoors.util.PocketGenerationParameters;
+import org.dimdev.dimdoors.util.schematic.v2.Schematic;
+import org.dimdev.dimdoors.util.schematic.v2.SchematicBlockPalette;
 import org.dimdev.dimdoors.world.pocket.Pocket;
 
 public class ShellModifier implements Modifier{
-	private List<Layer> layers = new ArrayList<>();
+	private static final Logger LOGGER = LogManager.getLogger();
+	public static final String KEY = "shell";
 
-	private int total = 0;
+	private final List<Layer> layers = new ArrayList<>();
-
-	private void calculate() {
-		total = layers.stream().mapToInt(Layer::getThickness).sum();
-		double half = total * 0.5;
-
-		Box box = new Box(0,0,0,0,0,0).offset(half, half, half);
-
-		layers.forEach(layer -> layer.adjust(box));
-	}
 
 	@Override
 	public CompoundTag toTag(CompoundTag tag) {
-		ListTag layersTag = new ListTag();
+		Modifier.super.toTag(tag);
 
+		ListTag layersTag = new ListTag();
 		for (Layer layer : layers) {
 			layersTag.add(layer.toTag());
 		}
-
 		tag.put("layers", layersTag);
 
 		return tag;
@@ -49,15 +45,15 @@ public class ShellModifier implements Modifier{
 
 	@Override
 	public Modifier fromTag(CompoundTag tag) {
-		layers.clear();
-
 		for (Tag layerTag : tag.getList("layers", NbtType.COMPOUND)) {
 			CompoundTag compoundTag = (CompoundTag) layerTag;
+			try {
 				Layer layer = Layer.fromTag(compoundTag);
 				layers.add(layer);
+			} catch (CommandSyntaxException e) {
+				LOGGER.error("could not parse Layer: " + compoundTag.toString(), e);
+			}
 		}
-
-		calculate();
 
 		return this;
 	}
@@ -69,69 +65,70 @@ public class ShellModifier implements Modifier{
 
 	@Override
 	public String getKey() {
-		return "shell";
+		return KEY;
 	}
 
 	@Override
 	public void apply(Pocket pocket, PocketGenerationParameters parameters) {
-		for (int x = 0; x < total; x++) {
+		layers.forEach(layer -> drawLayer(layer, pocket, parameters.getWorld()));
-			for (int y = 0; y < total; y++) {
-				for (int z = 0; z < total; z++) {
-					parameters.getWorld().setBlockState(pocket.getOrigin().add(x,y,z), getBlockState(x,y,z));
-				}
-			}
 	}
 
-		pocket.setSize(total, total, total);
+	private void drawLayer(Layer layer, Pocket pocket, ServerWorld world) {
-	}
+		int thickness = layer.getThickness();
+		final BlockState blockState = layer.getBlockState();
+		BlockBox pocketBox = pocket.getBox();
 
-	private BlockState getBlockState(int x, int y, int z) {
+		// x-planes
-		return layers.stream().filter(layer -> layer.contains(x, y, z)).findFirst().map(Layer::getBlock).orElse(Blocks.AIR).getDefaultState();
+		BlockPos.stream(BlockBox.create(pocketBox.maxX + 1, pocketBox.minY - thickness, pocketBox.minZ - thickness, pocketBox.maxX + thickness, pocketBox.maxY + thickness, pocketBox.maxZ + thickness))
+				.forEach(blockPos -> world.setBlockState(blockPos, blockState));
+		BlockPos.stream(BlockBox.create(pocketBox.minX - 1, pocketBox.minY - thickness, pocketBox.minZ - thickness, pocketBox.minX - thickness, pocketBox.maxY + thickness, pocketBox.maxZ + thickness))
+				.forEach(blockPos -> world.setBlockState(blockPos, blockState));
+
+		// y-planes
+		BlockPos.stream(BlockBox.create(pocketBox.minX, pocketBox.maxY + 1, pocketBox.minZ - thickness, pocketBox.maxX, pocketBox.maxY + thickness, pocketBox.maxZ + thickness))
+				.forEach(blockPos -> world.setBlockState(blockPos, blockState));
+		BlockPos.stream(BlockBox.create(pocketBox.minX, pocketBox.minY - 1, pocketBox.minZ - thickness, pocketBox.maxX, pocketBox.minY - thickness, pocketBox.maxZ + thickness))
+				.forEach(blockPos -> world.setBlockState(blockPos, blockState));
+
+		// z-planes
+		BlockPos.stream(BlockBox.create(pocketBox.minX, pocketBox.minY, pocketBox.minZ - 1, pocketBox.maxX, pocketBox.maxY, pocketBox.minZ - thickness))
+				.forEach(blockPos -> world.setBlockState(blockPos, blockState));
+		BlockPos.stream(BlockBox.create(pocketBox.minX, pocketBox.minY, pocketBox.maxZ + 1, pocketBox.maxX, pocketBox.maxY, pocketBox.maxZ + thickness))
+				.forEach(blockPos -> world.setBlockState(blockPos, blockState));
+
+		pocket.expand(thickness);
 	}
 
 	public static class Layer {
-		private final Identifier material;
+		private final String blockStateString;
-		private final int thickness;
+		private final int thickness; // TODO: maybe this could even be an equation?
+		private final BlockState blockState;
 
-		private Box box;
+		public Layer(String blockStateString, int thickness) {
-
+			this.blockStateString = blockStateString;
-		public Layer(Identifier material, int thickness) {
-			this.material = material;
 			this.thickness = thickness;
+
+			this.blockState = SchematicBlockPalette.Entry.to(blockStateString).getOrThrow(false, LOGGER::error);
 		}
 
-		public Identifier getMaterial() {
+		public BlockState getBlockState() {
-			return material;
+			return blockState;
 		}
 
 		public int getThickness() {
 			return thickness;
 		}
 
-		public boolean contains(int x, int y, int z) {
-			return box.contains(x, y, z);
-		}
-
-		public Block getBlock() {
-			return Registry.BLOCK.get(material);
-		}
-
-		public void adjust(Box box) {
-			double half = thickness * 0.5d;
-			this.box = box.expand(thickness);
-		}
-
 		public CompoundTag toTag() {
 			CompoundTag tag = new CompoundTag();
-			tag.putString("material", material.toString());
+			tag.putString("block_state", blockStateString);
 			tag.putInt("thickness", thickness);
 			return tag;
 		}
 
-		public static Layer fromTag(CompoundTag tag) {
+		public static Layer fromTag(CompoundTag tag) throws CommandSyntaxException {
-			return new Layer(Identifier.tryParse(tag.getString("material")), tag.getInt("thickness"));
+			return new Layer(tag.getString("block_state"), tag.getInt("thickness"));
 		}
-
 	}
 }
 

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

@@ -103,7 +103,7 @@ public class DepthDependentSelector extends VirtualSingularPocket {
 
 	@Override
 	public String getKey() {
-		return null;
+		return KEY;
 	}
 
 	@Override

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

@@ -79,7 +79,7 @@ public class PocketEntranceMarker extends VirtualTarget implements EntityTarget
 		private VirtualTarget ifDestination = NoneTarget.INSTANCE;
 		private VirtualTarget otherwiseDestination = NoneTarget.INSTANCE;
 
-		PocketEntranceMarkerBuilder() {
+		private PocketEntranceMarkerBuilder() {
 		}
 
 		public PocketEntranceMarker.PocketEntranceMarkerBuilder weight(float weight) {

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

@@ -5,7 +5,6 @@ import org.apache.logging.log4j.Logger;
 
 import java.util.*;
 import java.util.function.BiFunction;
-import java.util.function.Function;
 
 public class StringEquationParser {
 	private static final Logger LOGGER = LogManager.getLogger();
@@ -88,7 +87,9 @@ public class StringEquationParser {
 	}
 
 
-	public interface Equation extends Function<Map<String, Double>, Double> { }
+	public interface Equation {
+		double apply(Map<String, Double> variableMap);
+	}
 
 	private interface EquationParser {
 		Optional<Equation> tryParse(String toParse) throws EquationParseException;

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

@@ -1,7 +1,5 @@
 package org.dimdev.dimdoors.world.pocket;
 
-import java.util.Arrays;
-import java.util.Collections;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.stream.IntStream;
@@ -26,7 +24,6 @@ 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.Box;
 import net.minecraft.util.math.ChunkPos;
 import net.minecraft.util.math.Vec3i;
 import net.minecraft.util.registry.Registry;
@@ -60,7 +57,7 @@ public final class Pocket {
 		int gridSize = DimensionalRegistry.getPocketDirectory(world).getGridSize() * 16;
 		this.id = id;
 		this.world = world;
-		this.box = new BlockBox(x * gridSize, 0, z * gridSize, (x + 1) * gridSize, 0, (z + 1) * gridSize);
+		this.box = BlockBox.create(x * gridSize, 0, z * gridSize, (x + 1) * gridSize, 0, (z + 1) * gridSize);
 		this.virtualLocation = new VirtualLocation(world, x, z, 0);
 	}
 
@@ -73,7 +70,11 @@ public final class Pocket {
 	}
 
 	public void offsetOrigin(Vec3i vec) {
-		this.box = box.offset(vec.getX(), vec.getY(), vec.getZ());
+		offsetOrigin(vec.getX(), vec.getY(), vec.getZ());
+	}
+
+	public void offsetOrigin(int x, int y, int z) {
+		this.box = box.offset(x, y, z);
 	}
 
 	public boolean addDye(Entity entity, DyeColor dyeColor) {
@@ -126,8 +127,12 @@ public final class Pocket {
 		return Math.max((outerVolume - innerVolume) / BLOCKS_PAINTED_PER_DYE, 1);
 	}
 
+	public void setSize(Vec3i size) {
+		setSize(size.getX(), size.getY(), size.getZ());
+	}
+
 	public void setSize(int x, int y, int z) {
-		this.box = new BlockBox(this.box.minX, this.box.minY, this.box.minZ, this.box.minX + x, this.box.minY + y, this.box.minZ + z);
+		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() {
@@ -242,4 +247,9 @@ public final class Pocket {
 		stringDoubleMap.put("id", (double) this.id); // don't really know why you would need this but it's there if needed
 		return stringDoubleMap;
 	}
+
+	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);
+	}
 }

src/main/resources/data/dimdoors/pockets/json/v2/default_private.json

@@ -4,50 +4,42 @@
     {
       "type": "dimdoors:schematic",
       "id": "private_pocket_0",
-      "size": 0,
+      "weight": "20"
-      "weight": 20
     },
     {
       "type": "dimdoors:schematic",
       "id": "private_pocket_1",
-      "size": 1,
+      "weight": "17"
-      "weight": 17
     },
     {
       "type": "dimdoors:schematic",
       "id": "private_pocket_2",
-      "size": 2,
+      "weight": "14"
-      "weight": 14
     },
     {
       "type": "dimdoors:schematic",
       "id": "private_pocket_3",
-      "size": 3,
+      "weight": "11"
-      "weight": 11
     },
     {
       "type": "dimdoors:schematic",
       "id": "private_pocket_4",
-      "size": 4,
+      "weight": "8"
-      "weight": 8
     },
     {
       "type": "dimdoors:schematic",
       "id": "private_pocket_5",
-      "size": 5,
+      "weight": "5"
-      "weight": 5
     },
     {
       "type": "dimdoors:schematic",
       "id": "private_pocket_6",
-      "size": 6,
+      "weight": "3"
-      "weight": 3
     },
     {
       "type": "dimdoors:schematic",
       "id": "private_pocket_7",
-      "size": 7,
+      "weight": "1"
-      "weight": 1
     }
   ]
 }

src/main/resources/data/dimdoors/pockets/json/v2/default_public.json

@@ -2,80 +2,32 @@
   "group": "public",
   "pockets": [
     {
-      "type": "dimdoors:depth_dependent",
+      "type": "dimdoors:void",
-      "id": "public_pocket",
+      "width": "min(16 * (depth-5)^0.5, 128)",
-      "pockets": [
+      "height": "min(16 * (depth-5)^0.35, 64)",
+      "length": "min(16 * (depth-5)^0.5, 128)",
+      "offset_y": "5",
+      "modifiers": [
         {
-          "regex": "6",
+          "type": "dimdoors:shell",
-          "pocket": {
+          "layers": [
-            "type": "dimdoors:schematic",
+            {
-            "id": "public_pocket_0",
+              "block_state": "dimdoors:black_fabric",
-            "size": 0,
+              "thickness": 4
-            "weight": 20
-          }
             },
             {
-          "regex": "7",
+              "block_state": "dimdoors:black_ancient_fabric",
-          "pocket": {
+              "thickness": 1
-            "type": "dimdoors:schematic",
-            "id": "public_pocket_1",
-            "size": 1,
-            "weight": 17
             }
+          ]
         },
         {
-          "regex": "8",
+          "type": "dimdoors:door",
-          "pocket": {
+          "door_type": "dimdoors:iron_dimensional_door",
-            "type": "dimdoors:schematic",
+          "facing": "north",
-            "id": "public_pocket_2",
+          "x": "width/2",
-            "size": 2,
+          "y": "5",
-            "weight": 14
+          "z": "4"
-          }
-        },
-        {
-          "regex": "9",
-          "pocket": {
-            "type": "dimdoors:schematic",
-            "id": "public_pocket_3",
-            "size": 3,
-            "weight": 11
-          }
-        },
-        {
-          "regex": "10",
-          "pocket": {
-            "type": "dimdoors:schematic",
-            "id": "public_pocket_4",
-            "size": 4,
-            "weight": 8
-          }
-        },
-        {
-          "regex": "11",
-          "pocket": {
-            "type": "dimdoors:schematic",
-            "id": "public_pocket_5",
-            "size": 5,
-            "weight": 5
-          }
-        },
-        {
-          "regex": "12",
-          "pocket": {
-            "type": "dimdoors:schematic",
-            "id": "public_pocket_6",
-            "size": 6,
-            "weight": 3
-          }
-        },
-        {
-          "regex": "[0-9]+",
-          "pocket": {
-            "type": "dimdoors:schematic",
-            "id": "public_pocket_7",
-            "size": 7,
-            "weight": 1
-          }
         }
       ]
     }