diff --git a/src/main/java/org/dimdev/dimdoors/DimensionalDoorsInitializer.java b/src/main/java/org/dimdev/dimdoors/DimensionalDoorsInitializer.java index de96f5a2..173343a7 100644 --- a/src/main/java/org/dimdev/dimdoors/DimensionalDoorsInitializer.java +++ b/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(); } diff --git a/src/main/java/org/dimdev/dimdoors/block/entity/RiftBlockEntity.java b/src/main/java/org/dimdev/dimdoors/block/entity/RiftBlockEntity.java index d7678c53..677f5eea 100644 --- a/src/main/java/org/dimdev/dimdoors/block/entity/RiftBlockEntity.java +++ b/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() { diff --git a/src/main/java/org/dimdev/dimdoors/pockets/virtual/VirtualGeneratorPocket.java b/src/main/java/org/dimdev/dimdoors/pockets/virtual/VirtualGeneratorPocket.java index ad51d9a0..24c914c8 100644 --- a/src/main/java/org/dimdev/dimdoors/pockets/virtual/VirtualGeneratorPocket.java +++ b/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; } } diff --git a/src/main/java/org/dimdev/dimdoors/pockets/virtual/VirtualSingularPocket.java b/src/main/java/org/dimdev/dimdoors/pockets/virtual/VirtualSingularPocket.java index 608ab8df..7afd7950 100644 --- a/src/main/java/org/dimdev/dimdoors/pockets/virtual/VirtualSingularPocket.java +++ b/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 { VirtualSingularPocketType SCHEMATIC = register(new Identifier("dimdoors", SchematicGenerator.KEY), SchematicGenerator::new); VirtualSingularPocketType CHUNK = register(new Identifier("dimdoors", ChunkGenerator.KEY), ChunkGenerator::new); + VirtualSingularPocketType VOID = register(new Identifier("dimdoors", VoidGenerator.KEY), VoidGenerator::new); VirtualSingularPocketType DEPTH_DEPENDENT = register(new Identifier("dimdoors", DepthDependentSelector.KEY), DepthDependentSelector::new); diff --git a/src/main/java/org/dimdev/dimdoors/pockets/virtual/generator/ChunkGenerator.java b/src/main/java/org/dimdev/dimdoors/pockets/virtual/generator/ChunkGenerator.java index df6380c3..1f87cc7e 100644 --- a/src/main/java/org/dimdev/dimdoors/pockets/virtual/generator/ChunkGenerator.java +++ b/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()}); - tag.putIntArray("offset", new int[]{this.offset.getX(), this.offset.getY(), this.offset.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()); diff --git a/src/main/java/org/dimdev/dimdoors/pockets/virtual/generator/VoidGenerator.java b/src/main/java/org/dimdev/dimdoors/pockets/virtual/generator/VoidGenerator.java new file mode 100644 index 00000000..552d1788 --- /dev/null +++ b/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 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 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; + } +} diff --git a/src/main/java/org/dimdev/dimdoors/pockets/virtual/modifier/DimensionalDoorModifier.java b/src/main/java/org/dimdev/dimdoors/pockets/virtual/modifier/DimensionalDoorModifier.java index eccaa877..93ee3d67 100644 --- a/src/main/java/org/dimdev/dimdoors/pockets/virtual/modifier/DimensionalDoorModifier.java +++ b/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; - StringEquationParser.Equation y; - StringEquationParser.Equation z; + private static final Logger LOGGER = LogManager.getLogger(); + public static final String KEY = "door"; + + 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")); - y = StringEquationParser.parse(tag.getString("y")); - z = StringEquationParser.parse(tag.getString("z")); + x = tag.getString("x"); + y = tag.getString("y"); + 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 variables = ImmutableMap.of("width", (double) size.getX(), "height", (double) size.getY(), "length", (double) size.getZ()); - - BlockPos pos = new BlockPos(x.apply(variables), y.apply(variables), z.apply(variables)); + Map variableMap = pocket.toVariableMap(new HashMap<>()); + BlockPos pocketOrigin = pocket.getOrigin(); + BlockPos pos = new BlockPos(xEquation.apply(variableMap) + pocketOrigin.getX(), yEquation.apply(variableMap) + pocketOrigin.getY(), zEquation.apply(variableMap) + pocketOrigin.getZ()); + 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); } } diff --git a/src/main/java/org/dimdev/dimdoors/pockets/virtual/modifier/Modifier.java b/src/main/java/org/dimdev/dimdoors/pockets/virtual/modifier/Modifier.java index 775c3dff..945f083a 100644 --- a/src/main/java/org/dimdev/dimdoors/pockets/virtual/modifier/Modifier.java +++ b/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 { - public static ModifierType SHELL_MODIFIER_TYPE = register(new Identifier("dimdoors:shell"), ShellModifier::new); - public static ModifierType DIMENSIONAL_DOOR_MODIFIER_TYPE = register(new Identifier("dimdoors:dimensional_door"), DimensionalDoorModifier::new); + ModifierType SHELL_MODIFIER_TYPE = register(new Identifier("dimdoors", ShellModifier.KEY), ShellModifier::new); + ModifierType DIMENSIONAL_DOOR_MODIFIER_TYPE = register(new Identifier("dimdoors", DimensionalDoorModifier.KEY), DimensionalDoorModifier::new); Modifier fromTag(CompoundTag tag); diff --git a/src/main/java/org/dimdev/dimdoors/pockets/virtual/modifier/ShellModifier.java b/src/main/java/org/dimdev/dimdoors/pockets/virtual/modifier/ShellModifier.java index 84b675a9..08c990d4 100644 --- a/src/main/java/org/dimdev/dimdoors/pockets/virtual/modifier/ShellModifier.java +++ b/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.IntTag; -import net.minecraft.nbt.ListTag; -import net.minecraft.nbt.Tag; +import net.minecraft.nbt.*; +import net.minecraft.server.world.ServerWorld; 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 layers = new ArrayList<>(); + private static final Logger LOGGER = LogManager.getLogger(); + public static final String KEY = "shell"; - private int total = 0; - - 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)); - } + private final List layers = new ArrayList<>(); @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,16 +45,16 @@ 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; - Layer layer = Layer.fromTag(compoundTag); - layers.add(layer); + 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++) { - 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); + layers.forEach(layer -> drawLayer(layer, pocket, parameters.getWorld())); } - private BlockState getBlockState(int x, int y, int z) { - return layers.stream().filter(layer -> layer.contains(x, y, z)).findFirst().map(Layer::getBlock).orElse(Blocks.AIR).getDefaultState(); + private void drawLayer(Layer layer, Pocket pocket, ServerWorld world) { + int thickness = layer.getThickness(); + final BlockState blockState = layer.getBlockState(); + BlockBox pocketBox = pocket.getBox(); + + // x-planes + 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 int thickness; + private final String blockStateString; + private final int thickness; // TODO: maybe this could even be an equation? + private final BlockState blockState; - private Box box; - - public Layer(Identifier material, int thickness) { - this.material = material; + public Layer(String blockStateString, int thickness) { + this.blockStateString = blockStateString; this.thickness = thickness; + + this.blockState = SchematicBlockPalette.Entry.to(blockStateString).getOrThrow(false, LOGGER::error); } - public Identifier getMaterial() { - return material; + public BlockState getBlockState() { + 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) { - return new Layer(Identifier.tryParse(tag.getString("material")), tag.getInt("thickness")); + public static Layer fromTag(CompoundTag tag) throws CommandSyntaxException { + return new Layer(tag.getString("block_state"), tag.getInt("thickness")); } - } } diff --git a/src/main/java/org/dimdev/dimdoors/pockets/virtual/selection/DepthDependentSelector.java b/src/main/java/org/dimdev/dimdoors/pockets/virtual/selection/DepthDependentSelector.java index 9bd8ea32..99f28869 100644 --- a/src/main/java/org/dimdev/dimdoors/pockets/virtual/selection/DepthDependentSelector.java +++ b/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 diff --git a/src/main/java/org/dimdev/dimdoors/rift/targets/PocketEntranceMarker.java b/src/main/java/org/dimdev/dimdoors/rift/targets/PocketEntranceMarker.java index 8f130922..9427cf77 100644 --- a/src/main/java/org/dimdev/dimdoors/rift/targets/PocketEntranceMarker.java +++ b/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) { diff --git a/src/main/java/org/dimdev/dimdoors/util/math/StringEquationParser.java b/src/main/java/org/dimdev/dimdoors/util/math/StringEquationParser.java index a6896f38..302d05cb 100644 --- a/src/main/java/org/dimdev/dimdoors/util/math/StringEquationParser.java +++ b/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, Double> { } + public interface Equation { + double apply(Map variableMap); + } private interface EquationParser { Optional tryParse(String toParse) throws EquationParseException; diff --git a/src/main/java/org/dimdev/dimdoors/world/pocket/Pocket.java b/src/main/java/org/dimdev/dimdoors/world/pocket/Pocket.java index 02e04dce..a3fbd325 100644 --- a/src/main/java/org/dimdev/dimdoors/world/pocket/Pocket.java +++ b/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); + } } 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 312d60bb..d6eb47f5 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 @@ -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" } ] } 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 e808dce6..9ef381b3 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,80 +2,32 @@ "group": "public", "pockets": [ { - "type": "dimdoors:depth_dependent", - "id": "public_pocket", - "pockets": [ + "type": "dimdoors:void", + "width": "min(16 * (depth-5)^0.5, 128)", + "height": "min(16 * (depth-5)^0.35, 64)", + "length": "min(16 * (depth-5)^0.5, 128)", + "offset_y": "5", + "modifiers": [ { - "regex": "6", - "pocket": { - "type": "dimdoors:schematic", - "id": "public_pocket_0", - "size": 0, - "weight": 20 - } + "type": "dimdoors:shell", + "layers": [ + { + "block_state": "dimdoors:black_fabric", + "thickness": 4 + }, + { + "block_state": "dimdoors:black_ancient_fabric", + "thickness": 1 + } + ] }, { - "regex": "7", - "pocket": { - "type": "dimdoors:schematic", - "id": "public_pocket_1", - "size": 1, - "weight": 17 - } - }, - { - "regex": "8", - "pocket": { - "type": "dimdoors:schematic", - "id": "public_pocket_2", - "size": 2, - "weight": 14 - } - }, - { - "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 - } + "type": "dimdoors:door", + "door_type": "dimdoors:iron_dimensional_door", + "facing": "north", + "x": "width/2", + "y": "5", + "z": "4" } ] }