Working reader

src/datagen/java/org/dimdev/dimdoors/datagen/LootTableProvider.java

@@ -25,10 +25,10 @@ public class LootTableProvider implements DataProvider {
 		}
 		LOOT_TABLE_CONSUMER.registerBlockDropSelf(ModBlocks.GOLD_DOOR);
 		LOOT_TABLE_CONSUMER.registerBlockDropSelf(ModBlocks.QUARTZ_DOOR);
-		LOOT_TABLE_CONSUMER.registerBlockDropSelf(ModBlocks.OAK_DIMENSIONAL_DOOR);
+//		LOOT_TABLE_CONSUMER.registerBlockDropSelf(ModBlocks.OAK_DIMENSIONAL_DOOR);
-		LOOT_TABLE_CONSUMER.registerBlockDropSelf(ModBlocks.IRON_DIMENSIONAL_DOOR);
+//		LOOT_TABLE_CONSUMER.registerBlockDropSelf(ModBlocks.IRON_DIMENSIONAL_DOOR);
-		LOOT_TABLE_CONSUMER.registerBlockDropSelf(ModBlocks.GOLD_DIMENSIONAL_DOOR);
+//		LOOT_TABLE_CONSUMER.registerBlockDropSelf(ModBlocks.GOLD_DIMENSIONAL_DOOR);
-		LOOT_TABLE_CONSUMER.registerBlockDropSelf(ModBlocks.QUARTZ_DIMENSIONAL_DOOR);
+//		LOOT_TABLE_CONSUMER.registerBlockDropSelf(ModBlocks.QUARTZ_DIMENSIONAL_DOOR);
 		LOOT_TABLE_CONSUMER.registerBlockDropSelf(ModBlocks.OAK_DIMENSIONAL_TRAPDOOR);
 		LOOT_TABLE_CONSUMER.registerBlockDropSelf(ModBlocks.MARKING_PLATE);
 	}

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

@@ -5,6 +5,7 @@ import java.nio.file.Path;
 import me.sargunvohra.mcmods.autoconfig1u.AutoConfig;
 import me.sargunvohra.mcmods.autoconfig1u.ConfigHolder;
 import org.dimdev.dimdoors.block.ModBlocks;
+import org.dimdev.dimdoors.block.door.condition.Condition;
 import org.dimdev.dimdoors.block.entity.ModBlockEntityTypes;
 import org.dimdev.dimdoors.command.ModCommands;
 import org.dimdev.dimdoors.entity.ModEntityTypes;
@@ -114,6 +115,7 @@ public class DimensionalDoorsInitializer implements ModInitializer {
 		PocketGenerator.PocketGeneratorType.register();
 		AbstractPocket.AbstractPocketType.register();
 		PocketAddon.PocketAddonType.register();
+		Condition.ConditionType.register();
 
 		ResourceManagerHelper.get(ResourceType.SERVER_DATA).registerReloadListener(PocketLoader.getInstance());
 		ResourceManagerHelper.registerBuiltinResourcePack(new Identifier("dimdoors", "default_pockets"), dimDoorsMod, ResourcePackActivationType.DEFAULT_ENABLED);

src/main/java/org/dimdev/dimdoors/block/ModBlocks.java

@@ -4,6 +4,10 @@ import java.util.HashMap;
 import java.util.Map;
 
 import com.google.common.collect.Maps;
+import org.dimdev.dimdoors.block.door.DimensionalDoorBlock;
+import org.dimdev.dimdoors.block.door.DimensionalTrapdoorBlock;
+import org.dimdev.dimdoors.block.door.DoorData;
+import org.dimdev.dimdoors.block.door.DoorDataReader;
 
 import net.minecraft.block.Block;
 import net.minecraft.block.Blocks;
@@ -95,18 +99,14 @@ public final class ModBlocks {
 		BLOCKS.forEach((str, block) -> {
 			Registry.register(Registry.BLOCK, str, block);
 		});
+		DoorDataReader.read();
 		BLOCKS.clear();
 	}
 
 	@Environment(EnvType.CLIENT)
 	public static void initClient() {
-		BlockRenderLayerMap.INSTANCE.putBlocks(RenderLayer.getCutout(),
+		BlockRenderLayerMap.INSTANCE.putBlocks(RenderLayer.getCutout(), ModBlocks.QUARTZ_DOOR, ModBlocks.GOLD_DOOR);
-				ModBlocks.OAK_DIMENSIONAL_DOOR,
+		DoorData.DOORS.forEach(door -> BlockRenderLayerMap.INSTANCE.putBlock(door, RenderLayer.getCutout()));
-				ModBlocks.GOLD_DIMENSIONAL_DOOR,
-				ModBlocks.IRON_DIMENSIONAL_DOOR,
-				ModBlocks.OAK_DIMENSIONAL_TRAPDOOR,
-				ModBlocks.QUARTZ_DIMENSIONAL_DOOR,
-				ModBlocks.QUARTZ_DOOR);
 	}
 
 	public static Block ancientFabricFromDye(DyeColor color) {

src/main/java/org/dimdev/dimdoors/block/door/DimensionalDoorBlock.java

@@ -1,8 +1,11 @@
-package org.dimdev.dimdoors.block;
+package org.dimdev.dimdoors.block.door;
 
 import net.minecraft.util.math.Vec3d;
 
 import org.dimdev.dimdoors.DimensionalDoorsInitializer;
+import org.dimdev.dimdoors.block.CoordinateTransformerBlock;
+import org.dimdev.dimdoors.block.ModBlocks;
+import org.dimdev.dimdoors.block.RiftProvider;
 import org.dimdev.dimdoors.block.entity.DetachedRiftBlockEntity;
 import org.dimdev.dimdoors.block.entity.EntranceRiftBlockEntity;
 import org.dimdev.dimdoors.util.math.MathUtil;

src/main/java/org/dimdev/dimdoors/block/door/DimensionalTrapdoorBlock.java

@@ -1,5 +1,6 @@
-package org.dimdev.dimdoors.block;
+package org.dimdev.dimdoors.block.door;
 
+import org.dimdev.dimdoors.block.RiftProvider;
 import org.dimdev.dimdoors.block.entity.EntranceRiftBlockEntity;
 import org.jetbrains.annotations.Nullable;
 

src/main/java/org/dimdev/dimdoors/block/door/DoorData.java

@@ -1,5 +1,7 @@
 package org.dimdev.dimdoors.block.door;
 
+import java.util.ArrayList;
+import java.util.List;
 import java.util.Map;
 import java.util.Objects;
 import java.util.Optional;
@@ -9,7 +11,6 @@ import java.util.function.Consumer;
 import com.google.common.collect.ImmutableMap;
 import com.google.gson.JsonElement;
 import com.google.gson.JsonObject;
-import org.dimdev.dimdoors.block.DimensionalDoorBlock;
 import org.dimdev.dimdoors.block.entity.EntranceRiftBlockEntity;
 import org.dimdev.dimdoors.item.DimensionalDoorItem;
 import org.dimdev.dimdoors.item.ItemExtensions;
@@ -19,36 +20,50 @@ import org.dimdev.dimdoors.util.OptionalBool;
 import net.minecraft.block.Block;
 import net.minecraft.item.Item;
 import net.minecraft.util.Identifier;
-import net.minecraft.util.Pair;
 import net.minecraft.util.Rarity;
 import net.minecraft.util.Util;
 import net.minecraft.util.registry.Registry;
 
 import net.fabricmc.fabric.api.object.builder.v1.block.FabricBlockSettings;
 
-public final class UnbakedDoorData implements AutoCloseable {
+public final class DoorData implements AutoCloseable {
+	public static final List<Block> DOORS = new ArrayList<>();
 	private String id;
 	private UnbakedItemSettings itemSettings;
 	private UnbakedBlockSettings blockSettings;
 	private RiftDataList riftDataList;
 	private boolean closed = false;
 
-	public static UnbakedDoorData fromJson(JsonObject json) {
+	public static DoorData fromJson(JsonObject json) {
 		String id = json.get("id").getAsString();
 		UnbakedItemSettings itemSettings = UnbakedItemSettings.fromJson(json.getAsJsonObject("itemSettings"));
 		UnbakedBlockSettings blockSettings = UnbakedBlockSettings.fromJson(json.getAsJsonObject("blockSettings"));
 		RiftDataList riftDataList = RiftDataList.fromJson(json.getAsJsonArray("riftData"));
-		return new UnbakedDoorData(id, itemSettings, blockSettings, riftDataList);
+		return new DoorData(id, itemSettings, blockSettings, riftDataList);
 	}
 
-	public UnbakedDoorData(String id, UnbakedItemSettings itemSettings, UnbakedBlockSettings blockSettings, RiftDataList riftDataList) {
+	public DoorData(String id, UnbakedItemSettings itemSettings, UnbakedBlockSettings blockSettings, RiftDataList riftDataList) {
 		this.id = id;
 		this.itemSettings = itemSettings;
 		this.blockSettings = blockSettings;
 		this.riftDataList = riftDataList;
 	}
 
-	public Pair<Item, Block> construct() {
+	public JsonObject toJson(JsonObject json) {
+		json.addProperty("id", this.id);
+		return json;
+	}
+
+	private Consumer<? super EntranceRiftBlockEntity> createSetupFunction() {
+		return rift -> {
+			RiftDataList.OptRiftData riftData = this.riftDataList.getRiftData(rift);
+			riftData.getDestination().ifPresent(rift::setDestination);
+			riftData.getProperties().ifPresent(rift::setProperties);
+		};
+	}
+
+	@Override
+	public void close() {
 		if (closed) {
 			throw new UnsupportedOperationException("Already Closed");
 		}
@@ -66,21 +81,13 @@ public final class UnbakedDoorData implements AutoCloseable {
 
 		FabricBlockSettings blockSettings = FabricBlockSettings.copyOf(Registry.BLOCK.get(new Identifier(this.blockSettings.parent)));
 		this.blockSettings.luminance.ifPresent(blockSettings::luminance);
+		Identifier id = new Identifier(this.id);
 		Block doorBlock = new DimensionalDoorBlock(blockSettings);
 		Item doorItem = new DimensionalDoorItem(doorBlock, itemSettings, createSetupFunction());
-		return new Pair<>(doorItem, doorBlock);
+		Registry.register(Registry.BLOCK, id, doorBlock);
-	}
+		Registry.register(Registry.ITEM, id, doorItem);
+		DOORS.add(doorBlock);
 
-	private Consumer<? super EntranceRiftBlockEntity> createSetupFunction() {
-		return rift -> {
-			RiftDataList.OptRiftData riftData = this.riftDataList.getRiftData(rift);
-			riftData.getDestination().ifPresent(rift::setDestination);
-			riftData.getProperties().ifPresent(rift::setProperties);
-		};
-	}
-
-	@Override
-	public void close() throws Exception {
 		this.id = null;
 		this.blockSettings = null;
 		this.itemSettings = null;
@@ -89,7 +96,7 @@ public final class UnbakedDoorData implements AutoCloseable {
 	}
 
 	@SuppressWarnings("OptionalUsedAsFieldOrParameterType")
-	private static final class UnbakedItemSettings {
+	public static final class UnbakedItemSettings {
 		private static final Map<String, Rarity> RARITIES = Util.make(ImmutableMap.<String, Rarity>builder(), b -> {
 			for (Rarity rarity : Rarity.values()) {
 				b.put(rarity.name().toLowerCase(), rarity);
@@ -110,29 +117,44 @@ public final class UnbakedDoorData implements AutoCloseable {
 			return new UnbakedItemSettings(parent, maxCount, maxDamage, rarity, fireproof);
 		}
 
-		private UnbakedItemSettings(Optional<String> parent, OptionalInt maxCount, OptionalInt maxDamage, Optional<Rarity> rarity, OptionalBool fireproof) {
+		public UnbakedItemSettings(Optional<String> parent, OptionalInt maxCount, OptionalInt maxDamage, Optional<Rarity> rarity, OptionalBool fireproof) {
 			this.parent = parent;
 			this.maxCount = maxCount;
 			this.maxDamage = maxDamage;
 			this.rarity = rarity;
 			this.fireproof = fireproof;
 		}
+
+		public JsonObject toJson(JsonObject json) {
+			parent.ifPresent(s -> json.addProperty("parent", s));
+			maxCount.ifPresent(s -> json.addProperty("maxCount", s));
+			maxDamage.ifPresent(s -> json.addProperty("maxDamage", s));
+			rarity.ifPresent(s -> json.addProperty("rarity", s.name().toLowerCase()));
+			fireproof.ifPresent(s -> json.addProperty("fireproof", s));
+			return json;
+		}
 	}
 
 	@SuppressWarnings("OptionalUsedAsFieldOrParameterType")
-	private static final class UnbakedBlockSettings {
+	public static final class UnbakedBlockSettings {
 		private final String parent;
 		private final OptionalInt luminance;
 
 		public static UnbakedBlockSettings fromJson(JsonObject json) {
 			String parent = Optional.ofNullable(json.get("parent")).map(JsonElement::getAsString).orElseThrow(() -> new RuntimeException("Missing parent block"));
-			OptionalInt luminance = Optional.ofNullable(json.get("maxCount")).map(JsonElement::getAsInt).map(OptionalInt::of).orElse(OptionalInt.empty());
+			OptionalInt luminance = Optional.ofNullable(json.get("luminance")).map(JsonElement::getAsInt).map(OptionalInt::of).orElse(OptionalInt.empty());
 			return new UnbakedBlockSettings(parent, luminance);
 		}
 
-		private UnbakedBlockSettings(String parent, OptionalInt luminance) {
+		public UnbakedBlockSettings(String parent, OptionalInt luminance) {
 			this.parent = parent;
 			this.luminance = luminance;
 		}
+
+		public JsonObject toJson(JsonObject json) {
+			json.addProperty("parent", parent);
+			luminance.ifPresent(s -> json.addProperty("luminance", s));
+			return json;
+		}
 	}
 }

src/main/java/org/dimdev/dimdoors/block/door/DoorDataReader.java

@@ -0,0 +1,141 @@
+package org.dimdev.dimdoors.block.door;
+
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.Optional;
+import java.util.OptionalInt;
+import java.util.stream.Collectors;
+
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import com.google.gson.JsonObject;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.dimdev.dimdoors.DimensionalDoorsInitializer;
+import org.dimdev.dimdoors.block.door.condition.AlwaysTrueCondition;
+import org.dimdev.dimdoors.block.door.condition.InverseCondition;
+import org.dimdev.dimdoors.block.door.condition.WorldMatchCondition;
+import org.dimdev.dimdoors.rift.registry.LinkProperties;
+import org.dimdev.dimdoors.rift.targets.PrivatePocketExitTarget;
+import org.dimdev.dimdoors.rift.targets.PrivatePocketTarget;
+import org.dimdev.dimdoors.rift.targets.PublicPocketTarget;
+import org.dimdev.dimdoors.rift.targets.RandomTarget;
+import org.dimdev.dimdoors.util.OptionalBool;
+import org.dimdev.dimdoors.world.ModDimensions;
+
+import net.minecraft.util.Pair;
+import net.minecraft.util.Rarity;
+import net.minecraft.util.Util;
+
+public class DoorDataReader {
+	private static final Gson GSON = new GsonBuilder().setPrettyPrinting().setLenient().create();
+	private static final Logger LOGGER = LogManager.getLogger();
+	private static final DoorData DEFAULT_IRON_DIMENSIONAL_DOOR = new DoorData(
+			"dimdoors:iron_dimensional_door",
+			new DoorData.UnbakedItemSettings(
+					Optional.empty(),
+					OptionalInt.of(1),
+					OptionalInt.empty(),
+					Optional.of(Rarity.UNCOMMON),
+					OptionalBool.FALSE
+					),
+			new DoorData.UnbakedBlockSettings(
+					"minecraft:iron_door",
+					OptionalInt.of(10)
+			), new RiftDataList(Util.make(new LinkedList<>(), list -> list.add(new Pair<>(new RiftDataList.OptRiftData(Optional.of(new PublicPocketTarget()), Optional.empty()), AlwaysTrueCondition.INSTANCE)))
+	));
+	private static final DoorData DEFAULT_GOLD_DIMENSIONAL_DOOR = new DoorData(
+			"dimdoors:gold_dimensional_door",
+			new DoorData.UnbakedItemSettings(
+					Optional.empty(),
+					OptionalInt.of(1),
+					OptionalInt.empty(),
+					Optional.of(Rarity.UNCOMMON),
+					OptionalBool.FALSE
+			),
+			new DoorData.UnbakedBlockSettings(
+					"dimdoors:gold_door",
+					OptionalInt.of(10)
+			), new RiftDataList(Util.make(new LinkedList<>(), list -> list.add(new Pair<>(new RiftDataList.OptRiftData(Optional.of(RandomTarget.builder().acceptedGroups(Collections.singleton(0)).coordFactor(1).negativeDepthFactor(10000).positiveDepthFactor(80).weightMaximum(100).noLink(false).noLinkBack(false).newRiftWeight(1).build()), Optional.of(LinkProperties.builder().groups(new HashSet<>(Arrays.asList(0, 1))).linksRemaining(1).build())), AlwaysTrueCondition.INSTANCE)))
+	));
+	private static final DoorData DEFAULT_OAK_DIMENSIONAL_DOOR = new DoorData(
+			"dimdoors:oak_dimensional_door",
+			new DoorData.UnbakedItemSettings(
+					Optional.empty(),
+					OptionalInt.of(1),
+					OptionalInt.empty(),
+					Optional.of(Rarity.UNCOMMON),
+					OptionalBool.FALSE
+			),
+			new DoorData.UnbakedBlockSettings(
+					"minecraft:oak_door",
+					OptionalInt.of(10)
+			), new RiftDataList(Util.make(new LinkedList<>(), list -> list.add(new Pair<>(new RiftDataList.OptRiftData(Optional.of(RandomTarget.builder().acceptedGroups(Collections.singleton(0)).coordFactor(1).negativeDepthFactor(80).positiveDepthFactor(Double.MAX_VALUE).weightMaximum(100).noLink(false).newRiftWeight(0).build()), Optional.empty()), AlwaysTrueCondition.INSTANCE)))
+	));
+	private static final DoorData DEFAULT_QUARTZ_DIMENSIONAL_DOOR = new DoorData(
+			"dimdoors:gold_dimensional_door",
+			new DoorData.UnbakedItemSettings(
+					Optional.empty(),
+					OptionalInt.of(1),
+					OptionalInt.empty(),
+					Optional.of(Rarity.UNCOMMON),
+					OptionalBool.FALSE
+			),
+			new DoorData.UnbakedBlockSettings(
+					"dimdoors:quartz_door",
+					OptionalInt.of(10)
+			), new RiftDataList(Util.make(new LinkedList<>(), list -> {
+				WorldMatchCondition condition = new WorldMatchCondition(ModDimensions.PERSONAL);
+				list.add(new Pair<>(new RiftDataList.OptRiftData(Optional.of(new PrivatePocketExitTarget()), Optional.empty()), condition));
+				list.add(new Pair<>(new RiftDataList.OptRiftData(Optional.of(new PrivatePocketTarget()), Optional.empty()), new InverseCondition(condition)));
+	})
+	));
+
+	public static void read() {
+		try {
+			Path doorDir = DimensionalDoorsInitializer.getConfigRoot().resolve("doors");
+
+			if (Files.notExists(doorDir)) {
+				writeDefault(doorDir);
+				return;
+			}
+
+			if (Files.isDirectory(doorDir)) {
+				for (Path p : Files.list(doorDir).collect(Collectors.toList())) {
+					if (!Files.isDirectory(p) && Files.isRegularFile(p)) {
+						String jsonStr = new String(Files.readAllBytes(p), StandardCharsets.UTF_8);
+						JsonObject json = GSON.fromJson(jsonStr, JsonObject.class);
+						try (DoorData ignored = DoorData.fromJson(json)) {
+							LOGGER.info("Loading door json from {}", p.toAbsolutePath().toString());
+						}
+					}
+				}
+			} else {
+				Files.delete(doorDir);
+				writeDefault(doorDir);
+			}
+		} catch (IOException | RuntimeException e) {
+			LOGGER.error("Error leading door json", e);
+			e.printStackTrace();
+		}
+	}
+
+	private static void writeDefault(Path root) throws IOException {
+		writeDefault(root.resolve("iron_dimensional_door.json"), DEFAULT_IRON_DIMENSIONAL_DOOR);
+		writeDefault(root.resolve("gold_dimensional_door.json"), DEFAULT_GOLD_DIMENSIONAL_DOOR);
+		writeDefault(root.resolve("oak_dimensional_door.json"), DEFAULT_OAK_DIMENSIONAL_DOOR);
+		writeDefault(root.resolve("quartz_dimensional_door.json"), DEFAULT_QUARTZ_DIMENSIONAL_DOOR);
+	}
+
+	private static void writeDefault(Path path, DoorData doorData) throws IOException {
+		Files.createFile(path);
+		String json = GSON.toJson(doorData.toJson(new JsonObject()));
+		Files.write(path, json.getBytes(StandardCharsets.UTF_8));
+	}
+}

src/main/java/org/dimdev/dimdoors/block/door/RiftDataList.java

@@ -1,7 +1,9 @@
 package org.dimdev.dimdoors.block.door;
 
 import java.util.LinkedList;
+import java.util.Map;
 import java.util.Optional;
+import java.util.stream.Collectors;
 
 import com.google.gson.JsonArray;
 import com.google.gson.JsonElement;
@@ -24,7 +26,8 @@ public class RiftDataList {
 		for (JsonElement json : jsonArray) {
 			JsonObject jsonObject = json.getAsJsonObject();
 			OptRiftData riftData = OptRiftData.fromJson(jsonObject.getAsJsonObject("data"));
-			Condition condition = Condition.fromJson(jsonObject.getAsJsonObject("data"));
+			Condition condition = Condition.fromJson(jsonObject.getAsJsonObject("condition"));
+			riftDataConditions.add(new Pair<>(riftData, condition));
 		}
 		return new RiftDataList(riftDataConditions);
 	}
@@ -37,6 +40,19 @@ public class RiftDataList {
 		return riftDataConditions.stream().filter(pair -> pair.getRight().matches(rift)).findFirst().orElseThrow(() -> new RuntimeException("Could not find any matching rift data")).getLeft();
 	}
 
+	public JsonArray toJson() {
+		JsonArray jsonArray = new JsonArray();
+		for (Map.Entry<OptRiftData, Condition> entry : this.riftDataConditions.stream().collect(Collectors.toMap(Pair::getLeft, Pair::getRight)).entrySet()) {
+			OptRiftData riftData = entry.getKey();
+			Condition condition = entry.getValue();
+			JsonObject jsonInner = new JsonObject();
+			jsonInner.add("data", riftData.toJson(new JsonObject()));
+			jsonInner.add("condition", condition.toJson(new JsonObject()));
+			jsonArray.add(jsonInner);
+		}
+		return jsonArray;
+	}
+
 	@SuppressWarnings("OptionalUsedAsFieldOrParameterType")
 	public static class OptRiftData {
 		private final Optional<VirtualTarget> destination;
@@ -44,7 +60,7 @@ public class RiftDataList {
 
 		public static OptRiftData fromJson(JsonObject json) {
 			Optional<VirtualTarget> destination = Optional.ofNullable(json.get("destination")).map(JsonElement::getAsJsonObject).map(j -> JsonOps.INSTANCE.convertTo(NbtOps.INSTANCE, j)).map(CompoundTag.class::cast).map(VirtualTarget::fromTag);
-			Optional<LinkProperties> linkProperties = Optional.ofNullable(json.get("destination")).map(JsonElement::getAsJsonObject).map(j -> JsonOps.INSTANCE.convertTo(NbtOps.INSTANCE, j)).map(CompoundTag.class::cast).map(LinkProperties::fromTag);
+			Optional<LinkProperties> linkProperties = Optional.ofNullable(json.get("properties")).map(JsonElement::getAsJsonObject).map(j -> JsonOps.INSTANCE.convertTo(NbtOps.INSTANCE, j)).map(CompoundTag.class::cast).map(LinkProperties::fromTag);
 			return new OptRiftData(destination, linkProperties);
 		}
 
@@ -53,6 +69,12 @@ public class RiftDataList {
 			this.linkProperties = linkProperties;
 		}
 
+		public JsonObject toJson(JsonObject json) {
+			this.destination.ifPresent(s -> json.add("destination", NbtOps.INSTANCE.convertTo(JsonOps.INSTANCE, VirtualTarget.toTag(s))));
+			this.linkProperties.ifPresent(s -> json.add("properties", NbtOps.INSTANCE.convertTo(JsonOps.INSTANCE, LinkProperties.toTag(s))));
+			return json;
+		}
+
 		public Optional<LinkProperties> getProperties() {
 			return linkProperties;
 		}

src/main/java/org/dimdev/dimdoors/block/door/condition/AlwaysTrueCondition.java

@@ -0,0 +1,22 @@
+package org.dimdev.dimdoors.block.door.condition;
+
+import com.google.gson.JsonObject;
+import org.dimdev.dimdoors.block.entity.EntranceRiftBlockEntity;
+
+public enum AlwaysTrueCondition implements Condition {
+	INSTANCE;
+
+	@Override
+	public boolean matches(EntranceRiftBlockEntity rift) {
+		return true;
+	}
+
+	@Override
+	public void toJsonInner(JsonObject json) {
+	}
+
+	@Override
+	public Condition.ConditionType<?> getType() {
+		return null;
+	}
+}

src/main/java/org/dimdev/dimdoors/block/door/condition/Condition.java

@@ -35,6 +35,7 @@ public interface Condition {
 	}
 
 	interface ConditionType<T extends Condition> {
+		ConditionType<AlwaysTrueCondition> ALWAYS_TRUE = register("always_true", j -> AlwaysTrueCondition.INSTANCE);
 		ConditionType<AllCondition> ALL = register("all", AllCondition::fromJson);
 		ConditionType<AnyCondition> ANY = register("any", AnyCondition::fromJson);
 		ConditionType<InverseCondition> INVERSE = register("inverse", InverseCondition::fromJson);
@@ -45,7 +46,10 @@ public interface Condition {
 		JsonObject toJson(T t, JsonObject json);
 
 		default String getId() {
-			return REGISTRY.getId(this).toString();
+			return String.valueOf(REGISTRY.getId(this));
+		}
+
+		static void register() {
 		}
 
 		static <T extends Condition> ConditionType<T> register(String name, Function<JsonObject, T> fromJson) {

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

@@ -1,6 +1,8 @@
 package org.dimdev.dimdoors.block.entity;
 
+import org.apache.commons.lang3.ArrayUtils;
 import org.dimdev.dimdoors.block.ModBlocks;
+import org.dimdev.dimdoors.block.door.DoorData;
 import org.dimdev.dimdoors.client.DetachedRiftBlockEntityRenderer;
 import org.dimdev.dimdoors.client.EntranceRiftBlockEntityRenderer;
 
@@ -23,7 +25,7 @@ public class ModBlockEntityTypes {
 	public static final BlockEntityType<EntranceRiftBlockEntity> ENTRANCE_RIFT = register(
 			"dimdoors:entrance_rift",
 			EntranceRiftBlockEntity::new,
-			ModBlocks.OAK_DIMENSIONAL_DOOR, ModBlocks.IRON_DIMENSIONAL_DOOR, ModBlocks.GOLD_DIMENSIONAL_DOOR, ModBlocks.QUARTZ_DIMENSIONAL_DOOR, ModBlocks.DIMENSIONAL_PORTAL);
+			ArrayUtils.add(DoorData.DOORS.toArray(new Block[0]), ModBlocks.DIMENSIONAL_PORTAL));
 
 	private static <E extends BlockEntity> BlockEntityType<E> register(String id, FabricBlockEntityTypeBuilder.Factory<E> factory, Block... blocks) {
 		return Registry.register(Registry.BLOCK_ENTITY_TYPE, id, FabricBlockEntityTypeBuilder.create(factory, blocks).build());

src/main/java/org/dimdev/dimdoors/client/wthit/WthitPlugin.java

@@ -3,7 +3,7 @@ package org.dimdev.dimdoors.client.wthit;
 import mcp.mobius.waila.api.IRegistrar;
 import mcp.mobius.waila.api.IWailaPlugin;
 import mcp.mobius.waila.api.TooltipPosition;
-import org.dimdev.dimdoors.block.DimensionalDoorBlock;
+import org.dimdev.dimdoors.block.door.DimensionalDoorBlock;
 
 public class WthitPlugin implements IWailaPlugin {
 	@Override

src/main/java/org/dimdev/dimdoors/item/ModItems.java

@@ -47,53 +47,53 @@ public final class ModItems {
 	@RegistryObject("quartz_door")
 	public static final Item QUARTZ_DOOR = create(ModBlocks.QUARTZ_DOOR);
 
-	@RegistryObject("quartz_dimensional_door")
+//	@RegistryObject("quartz_dimensional_door")
-	public static final Item QUARTZ_DIMENSIONAL_DOOR = create(new DimensionalDoorItem(
+//	public static final Item QUARTZ_DIMENSIONAL_DOOR = create(new DimensionalDoorItem(
-			ModBlocks.QUARTZ_DIMENSIONAL_DOOR,
+//			ModBlocks.QUARTZ_DIMENSIONAL_DOOR,
-			new Item.Settings().group(DIMENSIONAL_DOORS).maxCount(1),
+//			new Item.Settings().group(DIMENSIONAL_DOORS).maxCount(1),
-			rift -> {
+//			rift -> {
-				if (ModDimensions.isPrivatePocketDimension(rift.getWorld())) {
+//				if (ModDimensions.isPrivatePocketDimension(rift.getWorld())) {
-					rift.setDestination(new PrivatePocketExitTarget()); // exit
+//					rift.setDestination(new PrivatePocketExitTarget()); // exit
-				} else {
+//				} else {
-					rift.setDestination(new PrivatePocketTarget()); // entrances
+//					rift.setDestination(new PrivatePocketTarget()); // entrances
-				}
+//				}
-			}
+//			}
-	));
+//	));
 
 	@RegistryObject("gold_door")
 	public static final Item GOLD_DOOR = create(ModBlocks.GOLD_DOOR);
 
-	@RegistryObject("gold_dimensional_door")
+//	@RegistryObject("gold_dimensional_door")
-	public static final Item GOLD_DIMENSIONAL_DOOR = create(new DimensionalDoorItem(
+//	public static final Item GOLD_DIMENSIONAL_DOOR = create(new DimensionalDoorItem(
-			ModBlocks.GOLD_DIMENSIONAL_DOOR,
+//			ModBlocks.GOLD_DIMENSIONAL_DOOR,
-			new Item.Settings().group(DIMENSIONAL_DOORS).maxCount(1),
+//			new Item.Settings().group(DIMENSIONAL_DOORS).maxCount(1),
-			rift -> {
+//			rift -> {
-				rift.setProperties(LinkProperties.builder()
+//				rift.setProperties(LinkProperties.builder()
-						.groups(new HashSet<>(Arrays.asList(0, 1)))
+//						.groups(new HashSet<>(Arrays.asList(0, 1)))
-						.linksRemaining(1).build());
+//						.linksRemaining(1).build());
-
+//
-				rift.setDestination(RandomTarget.builder()
+//				rift.setDestination(RandomTarget.builder()
-						.acceptedGroups(Collections.singleton(0))
+//						.acceptedGroups(Collections.singleton(0))
-						.coordFactor(1)
+//						.coordFactor(1)
-						.negativeDepthFactor(10000)
+//						.negativeDepthFactor(10000)
-						.positiveDepthFactor(80)
+//						.positiveDepthFactor(80)
-						.weightMaximum(100)
+//						.weightMaximum(100)
-						.noLink(false)
+//						.noLink(false)
-						.noLinkBack(false)
+//						.noLinkBack(false)
-						.newRiftWeight(1).build());
+//						.newRiftWeight(1).build());
-			}
+//			}
-	));
+//	));
-
+//
-	@RegistryObject("iron_dimensional_door")
+//	@RegistryObject("iron_dimensional_door")
-	public static final Item IRON_DIMENSIONAL_DOOR = create(new DimensionalDoorItem(
+//	public static final Item IRON_DIMENSIONAL_DOOR = create(new DimensionalDoorItem(
-			ModBlocks.IRON_DIMENSIONAL_DOOR,
+//			ModBlocks.IRON_DIMENSIONAL_DOOR,
-			new Item.Settings().group(DIMENSIONAL_DOORS).maxCount(1),
+//			new Item.Settings().group(DIMENSIONAL_DOORS).maxCount(1),
-			rift -> {
+//			rift -> {
-				PublicPocketTarget destination = new PublicPocketTarget();
+//				PublicPocketTarget destination = new PublicPocketTarget();
-				rift.setDestination(destination);
+//				rift.setDestination(destination);
-			}
+//			}
-	));
+//	));
-	/*
+	/* TODO
 	@RegistryObject("unstable_dimensional_door")
     public static final Item UNSTABLE_DIMENSIONAL_DOOR = create(new DimensionalDoorItem(
             ModBlocks.IRON_DIMENSIONAL_DOOR,
@@ -109,22 +109,22 @@ public final class ModItems {
 					.newRiftWeight(0.5F).build())
     ));
 	*/
-	@RegistryObject("oak_dimensional_door")
+//	@RegistryObject("oak_dimensional_door")
-	public static final Item OAK_DIMENSIONAL_DOOR = create(new DimensionalDoorItem(
+//	public static final Item OAK_DIMENSIONAL_DOOR = create(new DimensionalDoorItem(
-			ModBlocks.OAK_DIMENSIONAL_DOOR,
+//			ModBlocks.OAK_DIMENSIONAL_DOOR,
-			new Item.Settings().group(DIMENSIONAL_DOORS).maxCount(1),
+//			new Item.Settings().group(DIMENSIONAL_DOORS).maxCount(1),
-			rift -> rift.setDestination(
+//			rift -> rift.setDestination(
-					RandomTarget.builder()
+//					RandomTarget.builder()
-							.acceptedGroups(Collections.singleton(0))
+//							.acceptedGroups(Collections.singleton(0))
-							.coordFactor(1)
+//							.coordFactor(1)
-							.negativeDepthFactor(80)
+//							.negativeDepthFactor(80)
-							.positiveDepthFactor(Double.MAX_VALUE)
+//							.positiveDepthFactor(Double.MAX_VALUE)
-							.weightMaximum(100)
+//							.weightMaximum(100)
-							.noLink(false)
+//							.noLink(false)
-							.newRiftWeight(0)
+//							.newRiftWeight(0)
-							.build()
+//							.build()
-			)
+//			)
-	));
+//	));
 
 	@RegistryObject("wood_dimensional_trapdoor")
 	public static final Item OAK_DIMENSIONAL_TRAPDOOR = create(new DimensionalTrapdoorItem(

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

@@ -19,7 +19,7 @@ import net.minecraft.util.registry.Registry;
 import com.google.common.base.MoreObjects;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
-import org.dimdev.dimdoors.block.DimensionalDoorBlock;
+import org.dimdev.dimdoors.block.door.DimensionalDoorBlock;
 import org.dimdev.dimdoors.block.ModBlocks;
 import org.dimdev.dimdoors.block.entity.EntranceRiftBlockEntity;
 import org.dimdev.dimdoors.block.entity.ModBlockEntityTypes;
@@ -56,15 +56,13 @@ public class DimensionalDoorModifier implements LazyCompatibleModifier {
 		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 + "\"");
+			throw new RuntimeException("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 + "\"");
+			throw new RuntimeException("Could not interpret door type \"" + doorTypeString + "\"");
-			doorBlock = ModBlocks.IRON_DIMENSIONAL_DOOR;
 		}
 		doorType = (DimensionalDoorBlock) doorBlock;
 

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

@@ -56,11 +56,11 @@ public interface Modifier {
 		static void register() {
 		}
 
-		static <U extends Modifier> ModifierType<U> register(Identifier id, Supplier<U> constructor) {
+		static <U extends Modifier> ModifierType<U> register(Identifier id, Supplier<U> factory) {
 			return Registry.register(REGISTRY, id, new ModifierType<U>() {
 				@Override
 				public Modifier fromTag(CompoundTag tag) {
-					return constructor.get().fromTag(tag);
+					return factory.get().fromTag(tag);
 				}
 
 				@Override

src/main/java/org/dimdev/dimdoors/util/OptionalBool.java

@@ -10,6 +10,8 @@ import it.unimi.dsi.fastutil.booleans.BooleanConsumer;
 
 public final class OptionalBool {
     private static final OptionalBool EMPTY = new OptionalBool();
+    public static final OptionalBool TRUE = new OptionalBool(true);
+	public static final OptionalBool FALSE = new OptionalBool(false);
     private final boolean present;
     private final boolean value;
 
@@ -28,7 +30,7 @@ public final class OptionalBool {
     }
 
     public static OptionalBool of(boolean value) {
-        return new OptionalBool(value);
+        return value ? TRUE : FALSE;
     }
 
     public boolean getAsBool() {

src/main/java/org/dimdev/dimdoors/world/limbo/LimboDecay.java

@@ -17,9 +17,11 @@ import com.google.gson.JsonObject;
 import com.mojang.serialization.Codec;
 import com.mojang.serialization.JsonOps;
 import com.mojang.serialization.codecs.UnboundedMapCodec;
+import org.apache.commons.lang3.ArrayUtils;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.dimdev.dimdoors.DimensionalDoorsInitializer;
+import org.dimdev.dimdoors.block.door.DoorData;
 
 import net.minecraft.block.Block;
 import net.minecraft.block.BlockState;
@@ -84,12 +86,8 @@ import static net.minecraft.block.Blocks.SPRUCE_WOOD;
 import static net.minecraft.block.Blocks.STONE;
 import static net.minecraft.block.Blocks.STONE_BRICKS;
 import static org.dimdev.dimdoors.block.ModBlocks.DETACHED_RIFT;
-import static org.dimdev.dimdoors.block.ModBlocks.DIMENSIONAL_PORTAL;
 import static org.dimdev.dimdoors.block.ModBlocks.ETERNAL_FLUID;
-import static org.dimdev.dimdoors.block.ModBlocks.GOLD_DIMENSIONAL_DOOR;
 import static org.dimdev.dimdoors.block.ModBlocks.GOLD_DOOR;
-import static org.dimdev.dimdoors.block.ModBlocks.IRON_DIMENSIONAL_DOOR;
-import static org.dimdev.dimdoors.block.ModBlocks.OAK_DIMENSIONAL_DOOR;
 import static org.dimdev.dimdoors.block.ModBlocks.QUARTZ_DOOR;
 import static org.dimdev.dimdoors.block.ModBlocks.UNRAVELLED_FABRIC;
 
@@ -134,7 +132,7 @@ public final class LimboDecay {
 		}
 	}
 
-	private static final Random random = new Random();
+	private static final Random RANDOM = new Random();
 	private static Block[] blocksImmuneToDecay = null;
 
 	public static Map<Block, Block> getDecaySequence() {
@@ -143,17 +141,7 @@ public final class LimboDecay {
 
 	public static Block[] getBlocksImmuneToDecay() {
 		if (blocksImmuneToDecay == null) {
-			blocksImmuneToDecay = new Block[]{
+			blocksImmuneToDecay = ArrayUtils.addAll(DoorData.DOORS.toArray(new Block[0]), UNRAVELLED_FABRIC, ETERNAL_FLUID, DETACHED_RIFT, GOLD_DOOR, QUARTZ_DOOR);
-					UNRAVELLED_FABRIC,
-					ETERNAL_FLUID,
-					DIMENSIONAL_PORTAL,
-					IRON_DIMENSIONAL_DOOR,
-					OAK_DIMENSIONAL_DOOR,
-					DETACHED_RIFT,
-					GOLD_DOOR,
-					QUARTZ_DOOR,
-					GOLD_DIMENSIONAL_DOOR
-			};
 		}
 
 		return blocksImmuneToDecay;
@@ -166,7 +154,7 @@ public final class LimboDecay {
 	public static void applySpreadDecay(World world, BlockPos pos) {
 		//Check if we randomly apply decay spread or not. This can be used to moderate the frequency of
 		//full spread decay checks, which can also shift its performance impact on the game.
-		if (random.nextDouble() < DimensionalDoorsInitializer.getConfig().getLimboConfig().decaySpreadChance) {
+		if (RANDOM.nextDouble() < DimensionalDoorsInitializer.getConfig().getLimboConfig().decaySpreadChance) {
 			//Apply decay to the blocks above, below, and on all four sides.
 			//World.getBlockId() implements bounds checking, so we don't have to worry about reaching out of the world
 			boolean flag = decayBlock(world, pos.up());