Anvilcraft/DimDoors
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

it has been done

Browse source 
public pockets via VoidGenerator, ShellModifier and DimensionalDoorModifier
This commit is contained in:
CreepyCre 2021-02-02 21:24:54 +01:00
parent c4db51ef34
commit 51784c95a6
15 changed files with 303 additions and 180 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
src/main/java/org/dimdev/dimdoors/DimensionalDoorsInitializer.java
View file

@ -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();
}

2
src/main/java/org/dimdev/dimdoors/block/entity/RiftBlockEntity.java
View file

@ -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() {

4
src/main/java/org/dimdev/dimdoors/pockets/virtual/VirtualGeneratorPocket.java
View file

@ -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;
}
}

2
src/main/java/org/dimdev/dimdoors/pockets/virtual/VirtualSingularPocket.java
View file

@ -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);

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

@ -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());

98
src/main/java/org/dimdev/dimdoors/pockets/virtual/generator/VoidGenerator.java Normal file
View file

@ -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;
}
}

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

@ -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<String, Double> 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<String, Double> 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);
}
}

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

@ -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);
public static ModifierType<DimensionalDoorModifier> DIMENSIONAL_DOOR_MODIFIER_TYPE = register(new Identifier("dimdoors:dimensional_door"), DimensionalDoorModifier::new);
ModifierType<ShellModifier> SHELL_MODIFIER_TYPE = register(new Identifier("dimdoors", ShellModifier.KEY), ShellModifier::new);
ModifierType<DimensionalDoorModifier> DIMENSIONAL_DOOR_MODIFIER_TYPE = register(new Identifier("dimdoors", DimensionalDoorModifier.KEY), DimensionalDoorModifier::new);
Modifier fromTag(CompoundTag tag);

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

@ -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<Layer> 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<Layer> 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"));
}
}
}

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

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

2
src/main/java/org/dimdev/dimdoors/rift/targets/PocketEntranceMarker.java
View file

@ -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) {

5
src/main/java/org/dimdev/dimdoors/util/math/StringEquationParser.java
View file

@ -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;

22
src/main/java/org/dimdev/dimdoors/world/pocket/Pocket.java
View file

@ -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);
}
}

24
src/main/resources/data/dimdoors/pockets/json/v2/default_private.json
View file

@ -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"
}
]
}

94
src/main/resources/data/dimdoors/pockets/json/v2/default_public.json
View file

@ -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"
}
]
}