From 34137d12b7f1fb2367823f68718c5d71922decd8 Mon Sep 17 00:00:00 2001 From: CreepyCre Date: Tue, 26 Jan 2021 13:42:45 +0100 Subject: [PATCH] initial rewrite of pocket placement instead of each pocket having an assigned template, the pockets now generate/ place themselves allows for pockets with custom generators instead of schematics --- .../dimdoors/DimensionalDoorsInitializer.java | 3 + .../dimdoors/pockets/PocketGenerator.java | 38 +++------ .../{PocketType.java => PocketGroup.java} | 20 +++-- .../dimdoors/pockets/SchematicV2Handler.java | 68 ++++++++------- .../dimdoors/pockets/VirtualPocket.java | 52 ++++++++++++ .../pockets/VirtualSchematicPocket.java | 85 +++++++++++++++++++ .../org/dimdev/dimdoors/util/WeightedSet.java | 69 +++++++++++++++ .../pockets/json/v2/default_private.json | 72 ++++++++++------ .../pockets/json/v2/default_public.json | 72 ++++++++++------ 9 files changed, 363 insertions(+), 116 deletions(-) rename src/main/java/org/dimdev/dimdoors/pockets/{PocketType.java => PocketGroup.java} (82%) create mode 100644 src/main/java/org/dimdev/dimdoors/pockets/VirtualPocket.java create mode 100644 src/main/java/org/dimdev/dimdoors/pockets/VirtualSchematicPocket.java create mode 100644 src/main/java/org/dimdev/dimdoors/util/WeightedSet.java diff --git a/src/main/java/org/dimdev/dimdoors/DimensionalDoorsInitializer.java b/src/main/java/org/dimdev/dimdoors/DimensionalDoorsInitializer.java index aa9d2903..7dd5cdae 100644 --- a/src/main/java/org/dimdev/dimdoors/DimensionalDoorsInitializer.java +++ b/src/main/java/org/dimdev/dimdoors/DimensionalDoorsInitializer.java @@ -12,6 +12,7 @@ import org.dimdev.dimdoors.item.ModItems; import org.dimdev.dimdoors.particle.ModParticleTypes; import org.dimdev.dimdoors.pockets.SchematicHandler; import org.dimdev.dimdoors.pockets.SchematicV2Handler; +import org.dimdev.dimdoors.pockets.VirtualPocket; import org.dimdev.dimdoors.rift.targets.Targets; import org.dimdev.dimdoors.rift.targets.VirtualTarget; import org.dimdev.dimdoors.sound.ModSoundEvents; @@ -79,6 +80,8 @@ public class DimensionalDoorsInitializer implements ModInitializer { Targets.registerDefaultTargets(); VirtualTarget.VirtualTargetType.register(); + VirtualPocket.VirtualPocketType.register(); + SchematicV2Handler.getInstance().load(); SchematicHandler.INSTANCE.loadSchematics(); } diff --git a/src/main/java/org/dimdev/dimdoors/pockets/PocketGenerator.java b/src/main/java/org/dimdev/dimdoors/pockets/PocketGenerator.java index 96588adb..7dec6547 100644 --- a/src/main/java/org/dimdev/dimdoors/pockets/PocketGenerator.java +++ b/src/main/java/org/dimdev/dimdoors/pockets/PocketGenerator.java @@ -27,50 +27,25 @@ public final class PocketGenerator { return pocket; } - private static Pocket prepareAndPlaceV2Pocket(ServerWorld world, PocketTemplateV2 pocketTemplate, VirtualLocation virtualLocation, boolean setup) { - LOGGER.info("Generating pocket from template " + pocketTemplate.getId() + " at virtual location " + virtualLocation); - - Pocket pocket = DimensionalRegistry.getPocketDirectory(world.getRegistryKey()).newPocket(); - pocketTemplate.place(pocket); - pocket.virtualLocation = virtualLocation; - return pocket; - } - public static Pocket generatePocketFromTemplate(ServerWorld world, PocketTemplate pocketTemplate, VirtualLocation virtualLocation, boolean setup) { Pocket pocket = prepareAndPlacePocket(world, pocketTemplate, virtualLocation, setup); if (setup) pocketTemplate.setup(pocket, null, null); return pocket; } - public static Pocket generateV2PocketFromTemplate(ServerWorld world, PocketTemplateV2 pocketTemplate, VirtualLocation virtualLocation, boolean setup) { - Pocket pocket = prepareAndPlaceV2Pocket(world, pocketTemplate, virtualLocation, setup); - if (setup) { - pocketTemplate.setup(pocket, null, null); - } - return pocket; - } - - public static Pocket generatePocketFromTemplate(ServerWorld world, PocketTemplate pocketTemplate, VirtualLocation virtualLocation, VirtualTarget linkTo, LinkProperties linkProperties) { Pocket pocket = prepareAndPlacePocket(world, pocketTemplate, virtualLocation, true); pocketTemplate.setup(pocket, linkTo, linkProperties); return pocket; } - public static Pocket generateV2PocketFromTemplate(ServerWorld world, PocketTemplateV2 pocketTemplate, VirtualLocation virtualLocation, VirtualTarget linkTo, LinkProperties linkProperties) { - Pocket pocket = prepareAndPlaceV2Pocket(world, pocketTemplate, virtualLocation, true); - pocketTemplate.setup(pocket, linkTo, linkProperties); - return pocket; - } - public static Pocket generatePrivatePocket(VirtualLocation virtualLocation) { PocketTemplate pocketTemplate = SchematicHandler.INSTANCE.getPersonalPocketTemplate(); return generatePocketFromTemplate(DimensionalDoorsInitializer.getWorld(ModDimensions.PERSONAL), pocketTemplate, virtualLocation, true); } public static Pocket generatePrivatePocketV2(VirtualLocation virtualLocation) { - PocketTemplateV2 pocketTemplate = SchematicV2Handler.getInstance().getRandomPrivatePocket(); - return generateV2PocketFromTemplate(DimensionalDoorsInitializer.getWorld(ModDimensions.PERSONAL), pocketTemplate, virtualLocation, true); + return generateRandomPocketFromGroupV2(DimensionalDoorsInitializer.getWorld(ModDimensions.PUBLIC), "private", virtualLocation, null, null); } // TODO: size of public pockets should increase with depth @@ -80,10 +55,17 @@ public final class PocketGenerator { } public static Pocket generatePublicPocketV2(VirtualLocation virtualLocation, VirtualTarget linkTo, LinkProperties linkProperties) { - PocketTemplateV2 pocketTemplate = SchematicV2Handler.getInstance().getRandomPublicPocket(); - return generateV2PocketFromTemplate(DimensionalDoorsInitializer.getWorld(ModDimensions.PUBLIC), pocketTemplate, virtualLocation, linkTo, linkProperties); + return generateRandomPocketFromGroupV2(DimensionalDoorsInitializer.getWorld(ModDimensions.PUBLIC), "public", virtualLocation, linkTo, linkProperties); } + public static Pocket generateRandomPocketFromGroupV2(ServerWorld world, String group, VirtualLocation virtualLocation, VirtualTarget linkTo, LinkProperties linkProperties) { + return generatePocketV2(world, SchematicV2Handler.getInstance().getRandomPocketFromGroup(group), virtualLocation, linkTo, linkProperties); + } + + public static Pocket generatePocketV2(ServerWorld world, VirtualPocket virtualPocket, VirtualLocation virtualLocation, VirtualTarget linkTo, LinkProperties linkProperties) { + return virtualPocket.prepareAndPlacePocket(world, virtualLocation, linkTo, linkProperties); + } + /** * Create a dungeon pockets at a certain depth. * diff --git a/src/main/java/org/dimdev/dimdoors/pockets/PocketType.java b/src/main/java/org/dimdev/dimdoors/pockets/PocketGroup.java similarity index 82% rename from src/main/java/org/dimdev/dimdoors/pockets/PocketType.java rename to src/main/java/org/dimdev/dimdoors/pockets/PocketGroup.java index cff1f26a..904248a3 100644 --- a/src/main/java/org/dimdev/dimdoors/pockets/PocketType.java +++ b/src/main/java/org/dimdev/dimdoors/pockets/PocketGroup.java @@ -6,15 +6,15 @@ import java.util.Objects; import com.mojang.serialization.Codec; import com.mojang.serialization.codecs.RecordCodecBuilder; -public final class PocketType { - public static final Codec CODEC = RecordCodecBuilder.create(instance -> instance.group( - Codec.STRING.fieldOf("group").forGetter(PocketType::getGroup), - PocketEntry.CODEC.listOf().fieldOf("pockets").forGetter(PocketType::getEntries) - ).apply(instance, PocketType::new)); +public final class PocketGroup { + public static final Codec CODEC = RecordCodecBuilder.create(instance -> instance.group( + Codec.STRING.fieldOf("group").forGetter(PocketGroup::getGroup), + VirtualPocket.CODEC.listOf().fieldOf("pockets").forGetter(PocketGroup::getEntries) + ).apply(instance, PocketGroup::new)); private final String group; - private final List entries; + private final List entries; - public PocketType(String group, List entries) { + public PocketGroup(String group, List entries) { this.group = group; this.entries = entries; } @@ -22,7 +22,7 @@ public final class PocketType { return this.group; } - public List getEntries() { + public List getEntries() { return this.entries; } @@ -39,7 +39,7 @@ public final class PocketType { public boolean equals(Object o) { if (super.equals(o)) return true; if (o == null || this.getClass() != o.getClass()) return false; - PocketType that = (PocketType) o; + PocketGroup that = (PocketGroup) o; return Objects.equals(this.group, that.group) && Objects.equals(this.entries, that.entries); } @@ -49,6 +49,7 @@ public final class PocketType { return Objects.hash(this.group, this.entries); } + /* public static final class PocketEntry { public static final Codec CODEC = RecordCodecBuilder.create(instance -> instance.group( Codec.INT.fieldOf("size").forGetter(PocketEntry::getSize), @@ -101,4 +102,5 @@ public final class PocketType { '}'; } } + */ } diff --git a/src/main/java/org/dimdev/dimdoors/pockets/SchematicV2Handler.java b/src/main/java/org/dimdev/dimdoors/pockets/SchematicV2Handler.java index 21f70b1e..7ebfe73a 100644 --- a/src/main/java/org/dimdev/dimdoors/pockets/SchematicV2Handler.java +++ b/src/main/java/org/dimdev/dimdoors/pockets/SchematicV2Handler.java @@ -6,22 +6,17 @@ import java.net.URISyntaxException; import java.nio.file.Files; import java.nio.file.Path; import java.nio.file.Paths; -import java.util.ArrayList; -import java.util.Collection; -import java.util.List; -import java.util.Random; -import java.util.Set; +import java.util.*; -import com.google.common.collect.HashMultimap; -import com.google.common.collect.ImmutableSet; -import com.google.common.collect.Lists; -import com.google.common.collect.Multimap; +import com.google.common.collect.*; import com.google.gson.Gson; import com.google.gson.GsonBuilder; import com.google.gson.JsonObject; import com.mojang.serialization.JsonOps; +import net.minecraft.util.Identifier; import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.Logger; +import org.dimdev.dimdoors.util.WeightedSet; import org.dimdev.dimdoors.util.schematic.v2.Schematic; import net.minecraft.nbt.CompoundTag; @@ -31,9 +26,9 @@ public class SchematicV2Handler { private static final Logger LOGGER = LogManager.getLogger(); private static final Gson GSON = new GsonBuilder().setLenient().setPrettyPrinting().create(); private static final SchematicV2Handler INSTANCE = new SchematicV2Handler(); - private final List templates = Lists.newArrayList(); - private final Multimap templateMap = HashMultimap.create(); - private final List pocketTypes = Lists.newArrayList(); + private final Map templates = Maps.newHashMap(); + private final Map> templateMap = Maps.newHashMap(); //TODO: un-ugly-fy + private final List pocketTypes = Lists.newArrayList(); private static final Random RANDOM = new Random(new Random().nextLong()); private boolean loaded = false; @@ -58,7 +53,7 @@ public class SchematicV2Handler { result.add(line); } JsonObject json = GSON.fromJson(String.join("", result), JsonObject.class); - PocketType type = PocketType.CODEC.decode(JsonOps.INSTANCE, json).getOrThrow(false, System.err::println).getFirst(); + PocketGroup type = PocketGroup.CODEC.decode(JsonOps.INSTANCE, json).getOrThrow(false, System.err::println).getFirst(); this.pocketTypes.add(type); this.loadResourceSchematics(type); } catch (IOException | URISyntaxException e) { @@ -69,40 +64,51 @@ public class SchematicV2Handler { LOGGER.info("Loaded schematics in {} seconds", System.currentTimeMillis() - startTime); } - private void loadResourceSchematics(PocketType type) throws URISyntaxException, IOException { + /* + TODO: Change, is currently ugly. + Maybe request schematic from within VirtualSchematicPocket#init() and add default void init() to VirtualPocket? + */ + private void loadResourceSchematics(PocketGroup type) throws URISyntaxException, IOException { String group = type.getGroup(); + WeightedSet weightedPockets = new WeightedSet<>(); + templateMap.put(group, weightedPockets); Path basePath = Paths.get(SchematicV2Handler.class.getResource(String.format("/data/dimdoors/pockets/schematic/v2/%s/", group)).toURI()); - for (PocketType.PocketEntry entry : type.getEntries()) { - Path schemPath = basePath.resolve(entry.getName() + ".schem"); - CompoundTag schemTag = NbtIo.readCompressed(Files.newInputStream(schemPath)); - Schematic schematic = Schematic.fromTag(schemTag); - for (int i = 0; i < entry.getWeight(); i++) { - this.templateMap.put(group, new PocketTemplateV2(schematic, group, entry.getSize(), entry.getName(), entry.getWeight())); - } + for (VirtualPocket virtualPocket : type.getEntries()) { + weightedPockets.add(virtualPocket, virtualPocket.getWeight()); + if (virtualPocket instanceof VirtualSchematicPocket) { + VirtualSchematicPocket schemPocket = (VirtualSchematicPocket) virtualPocket; + Path schemPath = basePath.resolve(schemPocket.getName() + ".schem"); + CompoundTag schemTag = NbtIo.readCompressed(Files.newInputStream(schemPath)); + Schematic schematic = Schematic.fromTag(schemTag); + PocketTemplateV2 template = new PocketTemplateV2(schematic, group, schemPocket.getSize(), schemPocket.getName(), schemPocket.getWeight()); + Identifier templateID = new Identifier("dimdoors", schemPocket.getName()); + templates.put(templateID, template); + schemPocket.setTemplateID(templateID); + } } } - public PocketTemplateV2 getRandomPublicPocket() { - Collection publicPockets = this.templateMap.get("public"); - int index = RANDOM.nextInt(publicPockets.size()); - return Lists.newArrayList(publicPockets).get(0); + public VirtualPocket getRandomPublicPocket() { + return getRandomPocketFromGroup("public"); } - public PocketTemplateV2 getRandomPrivatePocket() { - Collection publicPockets = this.templateMap.get("private"); - int index = RANDOM.nextInt(publicPockets.size()); - return Lists.newArrayList(publicPockets).get(0); + public VirtualPocket getRandomPrivatePocket() { + return getRandomPocketFromGroup("private"); } + public VirtualPocket getRandomPocketFromGroup(String group) { + return templateMap.get(group).getRandomWeighted(); + } + public static SchematicV2Handler getInstance() { return INSTANCE; } - public List getTemplates() { + public Map getTemplates() { return this.templates; } - public List getPocketTypes() { + public List getPocketTypes() { return this.pocketTypes; } } diff --git a/src/main/java/org/dimdev/dimdoors/pockets/VirtualPocket.java b/src/main/java/org/dimdev/dimdoors/pockets/VirtualPocket.java new file mode 100644 index 00000000..33a13e9c --- /dev/null +++ b/src/main/java/org/dimdev/dimdoors/pockets/VirtualPocket.java @@ -0,0 +1,52 @@ +package org.dimdev.dimdoors.pockets; + +import com.mojang.datafixers.util.Pair; +import com.mojang.serialization.*; +import net.fabricmc.fabric.api.event.registry.FabricRegistryBuilder; +import net.minecraft.server.world.ServerWorld; +import net.minecraft.util.Identifier; +import net.minecraft.util.registry.Registry; +import net.minecraft.util.registry.RegistryKey; +import net.minecraft.util.registry.SimpleRegistry; +import org.dimdev.dimdoors.rift.registry.LinkProperties; +import org.dimdev.dimdoors.rift.targets.VirtualTarget; +import org.dimdev.dimdoors.world.pocket.Pocket; +import org.dimdev.dimdoors.world.pocket.VirtualLocation; + +// maybe PocketEntry is a better name? Only realised after I named this that the previous PocketEntry would be redundant. +public abstract class VirtualPocket { + public static final Registry> REGISTRY = FabricRegistryBuilder.from(new SimpleRegistry>(RegistryKey.ofRegistry(new Identifier("dimdoors", "virtual_pocket_type")), Lifecycle.stable())).buildAndRegister(); + public static final Codec CODEC = new Codec() { + @Override + public DataResult> decode(DynamicOps dynamicOps, T input) { + Identifier id = Identifier.CODEC.decode(dynamicOps, dynamicOps.get(input, "virtual_type").getOrThrow(false, System.err::println)).getOrThrow(false, System.err::println).getFirst(); + return REGISTRY.get(id).getCodec().decode(dynamicOps, dynamicOps.get(input, "properties").getOrThrow(false, System.err::println)).map(pair -> pair.mapFirst(virtualPocket -> (VirtualPocket) virtualPocket)); // TODO: can you use forField() here? + } + + @Override + public DataResult encode(VirtualPocket input, DynamicOps ops, T prefix) { + return null; // TODO: write encode function + } + }; + + + public abstract Pocket prepareAndPlacePocket(ServerWorld world, VirtualLocation virtualLocation, VirtualTarget linkTo, LinkProperties linkProperties); + public abstract String toString(); + // TODO: are equals() and hashCode() necessary? + public abstract VirtualPocketType getType(); + public abstract int getWeight(); + + + public interface VirtualPocketType { + VirtualPocketType SCHEMATIC = register("dimdoors:schematic", VirtualSchematicPocket.CODEC); + + Codec getCodec(); + + static void register() { + } + + static VirtualPocketType register(String id, Codec codec) { + return Registry.register(REGISTRY, id, () -> codec); + } + } +} diff --git a/src/main/java/org/dimdev/dimdoors/pockets/VirtualSchematicPocket.java b/src/main/java/org/dimdev/dimdoors/pockets/VirtualSchematicPocket.java new file mode 100644 index 00000000..bcfd616c --- /dev/null +++ b/src/main/java/org/dimdev/dimdoors/pockets/VirtualSchematicPocket.java @@ -0,0 +1,85 @@ +package org.dimdev.dimdoors.pockets; + +import com.mojang.serialization.Codec; +import com.mojang.serialization.codecs.RecordCodecBuilder; +import net.minecraft.server.world.ServerWorld; +import net.minecraft.util.Identifier; +import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; +import org.dimdev.dimdoors.rift.registry.LinkProperties; +import org.dimdev.dimdoors.rift.targets.VirtualTarget; +import org.dimdev.dimdoors.util.DimensionalRegistry; +import org.dimdev.dimdoors.world.pocket.Pocket; +import org.dimdev.dimdoors.world.pocket.VirtualLocation; + +public class VirtualSchematicPocket extends VirtualPocket{ + private static final Logger LOGGER = LogManager.getLogger(); + + public static final Codec CODEC = RecordCodecBuilder.create(instance -> instance.group( + Codec.INT.fieldOf("size").forGetter(VirtualSchematicPocket::getSize), + Codec.STRING.fieldOf("id").forGetter(VirtualSchematicPocket::getName), + Codec.INT.optionalFieldOf("weight", 5).forGetter(VirtualSchematicPocket::getWeight) + ).apply(instance, VirtualSchematicPocket::new)); + + private final int size; + private final String name; + private Identifier templateID; + private final int weight; + + VirtualSchematicPocket(int size, String name, int weight) { + this.size = size; + this.name = name; + this.weight = weight; + } + + public int getSize() { + return this.size; + } + + public String getName() { + return this.name; + } + + public Identifier getTemplateID() { + return templateID; + } + + public void setTemplateID(Identifier templateID) { + this.templateID = templateID; + } + + @Override + public int getWeight() { + return this.weight; + } + + + + + @Override + public Pocket prepareAndPlacePocket(ServerWorld world, VirtualLocation virtualLocation, VirtualTarget linkTo, LinkProperties linkProperties) { + PocketTemplateV2 template = SchematicV2Handler.getInstance().getTemplates().get(templateID); + if (template == null) throw new RuntimeException("Pocket template of id " + templateID + " not found!"); + LOGGER.info("Generating pocket from template " + template.getId() + " at virtual location " + virtualLocation); + + Pocket pocket = DimensionalRegistry.getPocketDirectory(world.getRegistryKey()).newPocket(); + template.place(pocket); + template.setup(pocket, linkTo, linkProperties); + pocket.virtualLocation = virtualLocation; + return pocket; + } + + @Override + public String toString() { + return "PocketEntry{" + + "size=" + this.size + + ", name='" + this.name + '\'' + + ", weight=" + this.weight + + '}'; + } + + @Override + public VirtualPocketType getType() { + return VirtualPocketType.SCHEMATIC; + } +} diff --git a/src/main/java/org/dimdev/dimdoors/util/WeightedSet.java b/src/main/java/org/dimdev/dimdoors/util/WeightedSet.java new file mode 100644 index 00000000..5ad459cf --- /dev/null +++ b/src/main/java/org/dimdev/dimdoors/util/WeightedSet.java @@ -0,0 +1,69 @@ +package org.dimdev.dimdoors.util; + +import net.minecraft.util.Pair; + +import java.util.*; +import java.util.stream.Collectors; + +public class WeightedSet { + private final TreeSet> set; + private final int defaultWeight; + private int totalWeight = 0; + private boolean dirty = false; + private final Random random = new Random(); + + public WeightedSet() { + this(1); + } + + //TODO: ensure default Weight is >= 0? + public WeightedSet(int defaultWeight) { + this.set = new TreeSet<>((pair1, pair2) -> pair2.getRight().compareTo(pair1.getRight())); + this.defaultWeight = defaultWeight; + } + + private void markDirty() { + dirty = true; + } + + private void updateTotalWeight() { + if (dirty) totalWeight = set.stream().mapToInt(Pair::getRight).sum(); + } + + public T getRandomWeighted() { + updateTotalWeight(); + int cursor = random.nextInt(totalWeight); + for (Pair pair : set) { + cursor -= pair.getRight(); + if (cursor <= 0) { + return pair.getLeft(); // should never return an entry with weight 0, unless there are only weight 0 entries + } + } + throw new RuntimeException(); // either the list is empty, or it somehow + } + + // TODO: ensure weight is >= 0? How about a negativeWeightException? + public boolean add(T t, Integer weight) { + if (set.add(new Pair<>(t, weight))) { + markDirty(); + return true; + } + return false; + } + + public boolean add(T t) { + return add(t, defaultWeight); + } + + public boolean remove(T t){ + if (set.remove(set.stream().filter(pair -> pair.getLeft().equals(t)).findFirst().orElse(null))) { + markDirty(); + return true; + } + return false; + } + + public List getObjectList() { + return set.stream().map(Pair::getLeft).collect(Collectors.toList()); + } +} diff --git a/src/main/resources/data/dimdoors/pockets/json/v2/default_private.json b/src/main/resources/data/dimdoors/pockets/json/v2/default_private.json index 128aa8e1..b906f3a6 100644 --- a/src/main/resources/data/dimdoors/pockets/json/v2/default_private.json +++ b/src/main/resources/data/dimdoors/pockets/json/v2/default_private.json @@ -2,44 +2,68 @@ "group": "private", "pockets": [ { - "id": "private_pocket_0", - "size": 0, - "weight": 20 + "virtual_type": "dimdoors:schematic", + "properties": { + "id": "private_pocket_0", + "size": 0, + "weight": 20 + } }, { - "id": "private_pocket_1", - "size": 1, - "weight": 17 + "virtual_type": "dimdoors:schematic", + "properties": { + "id": "private_pocket_1", + "size": 1, + "weight": 17 + } }, { - "id": "private_pocket_2", - "size": 2, - "weight": 14 + "virtual_type": "dimdoors:schematic", + "properties": { + "id": "private_pocket_2", + "size": 2, + "weight": 14 + } }, { - "id": "private_pocket_3", - "size": 3, - "weight": 11 + "virtual_type": "dimdoors:schematic", + "properties": { + "id": "private_pocket_3", + "size": 3, + "weight": 11 + } }, { - "id": "private_pocket_4", - "size": 4, - "weight": 8 + "virtual_type": "dimdoors:schematic", + "properties": { + "id": "private_pocket_4", + "size": 4, + "weight": 8 + } }, { - "id": "private_pocket_5", - "size": 5, - "weight": 5 + "virtual_type": "dimdoors:schematic", + "properties": { + "id": "private_pocket_5", + "size": 5, + "weight": 5 + } }, { - "id": "private_pocket_6", - "size": 6, - "weight": 3 + "virtual_type": "dimdoors:schematic", + "properties": { + "id": "private_pocket_6", + "size": 6, + "weight": 3 + } }, { - "id": "private_pocket_7", - "size": 7, - "weight": 1 + "virtual_type": "dimdoors:schematic", + "properties": { + "id": "private_pocket_7", + "size": 7, + "weight": 1 + } } ] } diff --git a/src/main/resources/data/dimdoors/pockets/json/v2/default_public.json b/src/main/resources/data/dimdoors/pockets/json/v2/default_public.json index 91e51605..0f7c5ab7 100644 --- a/src/main/resources/data/dimdoors/pockets/json/v2/default_public.json +++ b/src/main/resources/data/dimdoors/pockets/json/v2/default_public.json @@ -2,44 +2,68 @@ "group": "public", "pockets": [ { - "id": "public_pocket_0", - "size": 0, - "weight": 20 + "virtual_type": "dimdoors:schematic", + "properties": { + "id": "public_pocket_0", + "size": 0, + "weight": 20 + } }, { - "id": "public_pocket_1", - "size": 1, - "weight": 17 + "virtual_type": "dimdoors:schematic", + "properties": { + "id": "public_pocket_1", + "size": 1, + "weight": 17 + } }, { - "id": "public_pocket_2", - "size": 2, - "weight": 14 + "virtual_type": "dimdoors:schematic", + "properties": { + "id": "public_pocket_2", + "size": 2, + "weight": 14 + } }, { - "id": "public_pocket_3", - "size": 3, - "weight": 11 + "virtual_type": "dimdoors:schematic", + "properties": { + "id": "public_pocket_3", + "size": 3, + "weight": 11 + } }, { - "id": "public_pocket_4", - "size": 4, - "weight": 8 + "virtual_type": "dimdoors:schematic", + "properties": { + "id": "public_pocket_4", + "size": 4, + "weight": 8 + } }, { - "id": "public_pocket_5", - "size": 5, - "weight": 5 + "virtual_type": "dimdoors:schematic", + "properties": { + "id": "public_pocket_5", + "size": 5, + "weight": 5 + } }, { - "id": "public_pocket_6", - "size": 6, - "weight": 3 + "virtual_type": "dimdoors:schematic", + "properties": { + "id": "public_pocket_6", + "size": 6, + "weight": 3 + } }, { - "id": "public_pocket_7", - "size": 7, - "weight": 1 + "virtual_type": "dimdoors:schematic", + "properties": { + "id": "public_pocket_7", + "size": 7, + "weight": 1 + } } ] }