653 lines
20 KiB
Java
653 lines
20 KiB
Java
package net.minecraft.core;
|
|
|
|
import com.google.common.collect.AbstractIterator;
|
|
import com.mojang.logging.LogUtils;
|
|
import com.mojang.serialization.Codec;
|
|
import io.netty.buffer.ByteBuf;
|
|
import it.unimi.dsi.fastutil.longs.LongOpenHashSet;
|
|
import it.unimi.dsi.fastutil.longs.LongSet;
|
|
import java.util.ArrayDeque;
|
|
import java.util.Optional;
|
|
import java.util.Queue;
|
|
import java.util.function.BiConsumer;
|
|
import java.util.function.Consumer;
|
|
import java.util.function.Function;
|
|
import java.util.function.Predicate;
|
|
import java.util.stream.IntStream;
|
|
import java.util.stream.Stream;
|
|
import java.util.stream.StreamSupport;
|
|
import net.minecraft.Util;
|
|
import net.minecraft.network.FriendlyByteBuf;
|
|
import net.minecraft.network.codec.StreamCodec;
|
|
import net.minecraft.util.Mth;
|
|
import net.minecraft.util.RandomSource;
|
|
import net.minecraft.world.level.block.Rotation;
|
|
import net.minecraft.world.level.levelgen.structure.BoundingBox;
|
|
import net.minecraft.world.phys.AABB;
|
|
import net.minecraft.world.phys.Vec3;
|
|
import org.apache.commons.lang3.Validate;
|
|
import org.apache.commons.lang3.tuple.Pair;
|
|
import org.jetbrains.annotations.Unmodifiable;
|
|
import org.slf4j.Logger;
|
|
|
|
@Unmodifiable
|
|
public class BlockPos extends Vec3i {
|
|
public static final Codec<BlockPos> CODEC = Codec.INT_STREAM
|
|
.<BlockPos>comapFlatMap(
|
|
intStream -> Util.fixedSize(intStream, 3).map(is -> new BlockPos(is[0], is[1], is[2])),
|
|
blockPos -> IntStream.of(new int[]{blockPos.getX(), blockPos.getY(), blockPos.getZ()})
|
|
)
|
|
.stable();
|
|
public static final StreamCodec<ByteBuf, BlockPos> STREAM_CODEC = new StreamCodec<ByteBuf, BlockPos>() {
|
|
public BlockPos decode(ByteBuf byteBuf) {
|
|
return FriendlyByteBuf.readBlockPos(byteBuf);
|
|
}
|
|
|
|
public void encode(ByteBuf byteBuf, BlockPos blockPos) {
|
|
FriendlyByteBuf.writeBlockPos(byteBuf, blockPos);
|
|
}
|
|
};
|
|
private static final Logger LOGGER = LogUtils.getLogger();
|
|
/**
|
|
* An immutable BlockPos with zero as all coordinates.
|
|
*/
|
|
public static final BlockPos ZERO = new BlockPos(0, 0, 0);
|
|
public static final int PACKED_HORIZONTAL_LENGTH = 1 + Mth.log2(Mth.smallestEncompassingPowerOfTwo(30000000));
|
|
public static final int PACKED_Y_LENGTH = 64 - 2 * PACKED_HORIZONTAL_LENGTH;
|
|
private static final long PACKED_X_MASK = (1L << PACKED_HORIZONTAL_LENGTH) - 1L;
|
|
private static final long PACKED_Y_MASK = (1L << PACKED_Y_LENGTH) - 1L;
|
|
private static final long PACKED_Z_MASK = (1L << PACKED_HORIZONTAL_LENGTH) - 1L;
|
|
private static final int Y_OFFSET = 0;
|
|
private static final int Z_OFFSET = PACKED_Y_LENGTH;
|
|
private static final int X_OFFSET = PACKED_Y_LENGTH + PACKED_HORIZONTAL_LENGTH;
|
|
public static final int MAX_HORIZONTAL_COORDINATE = (1 << PACKED_HORIZONTAL_LENGTH) / 2 - 1;
|
|
|
|
public BlockPos(int x, int y, int z) {
|
|
super(x, y, z);
|
|
}
|
|
|
|
public BlockPos(Vec3i vector) {
|
|
this(vector.getX(), vector.getY(), vector.getZ());
|
|
}
|
|
|
|
public static long offset(long pos, Direction direction) {
|
|
return offset(pos, direction.getStepX(), direction.getStepY(), direction.getStepZ());
|
|
}
|
|
|
|
public static long offset(long pos, int dx, int dy, int dz) {
|
|
return asLong(getX(pos) + dx, getY(pos) + dy, getZ(pos) + dz);
|
|
}
|
|
|
|
public static int getX(long packedPos) {
|
|
return (int)(packedPos << 64 - X_OFFSET - PACKED_HORIZONTAL_LENGTH >> 64 - PACKED_HORIZONTAL_LENGTH);
|
|
}
|
|
|
|
public static int getY(long packedPos) {
|
|
return (int)(packedPos << 64 - PACKED_Y_LENGTH >> 64 - PACKED_Y_LENGTH);
|
|
}
|
|
|
|
public static int getZ(long packedPos) {
|
|
return (int)(packedPos << 64 - Z_OFFSET - PACKED_HORIZONTAL_LENGTH >> 64 - PACKED_HORIZONTAL_LENGTH);
|
|
}
|
|
|
|
public static BlockPos of(long packedPos) {
|
|
return new BlockPos(getX(packedPos), getY(packedPos), getZ(packedPos));
|
|
}
|
|
|
|
public static BlockPos containing(double x, double y, double z) {
|
|
return new BlockPos(Mth.floor(x), Mth.floor(y), Mth.floor(z));
|
|
}
|
|
|
|
public static BlockPos containing(Position position) {
|
|
return containing(position.x(), position.y(), position.z());
|
|
}
|
|
|
|
public static BlockPos min(BlockPos pos1, BlockPos pos2) {
|
|
return new BlockPos(Math.min(pos1.getX(), pos2.getX()), Math.min(pos1.getY(), pos2.getY()), Math.min(pos1.getZ(), pos2.getZ()));
|
|
}
|
|
|
|
public static BlockPos max(BlockPos pos1, BlockPos pos2) {
|
|
return new BlockPos(Math.max(pos1.getX(), pos2.getX()), Math.max(pos1.getY(), pos2.getY()), Math.max(pos1.getZ(), pos2.getZ()));
|
|
}
|
|
|
|
public long asLong() {
|
|
return asLong(this.getX(), this.getY(), this.getZ());
|
|
}
|
|
|
|
public static long asLong(int x, int y, int z) {
|
|
long l = 0L;
|
|
l |= (x & PACKED_X_MASK) << X_OFFSET;
|
|
l |= (y & PACKED_Y_MASK) << 0;
|
|
return l | (z & PACKED_Z_MASK) << Z_OFFSET;
|
|
}
|
|
|
|
public static long getFlatIndex(long packedPos) {
|
|
return packedPos & -16L;
|
|
}
|
|
|
|
public BlockPos offset(int i, int j, int k) {
|
|
return i == 0 && j == 0 && k == 0 ? this : new BlockPos(this.getX() + i, this.getY() + j, this.getZ() + k);
|
|
}
|
|
|
|
public Vec3 getCenter() {
|
|
return Vec3.atCenterOf(this);
|
|
}
|
|
|
|
public Vec3 getBottomCenter() {
|
|
return Vec3.atBottomCenterOf(this);
|
|
}
|
|
|
|
public BlockPos offset(Vec3i vec3i) {
|
|
return this.offset(vec3i.getX(), vec3i.getY(), vec3i.getZ());
|
|
}
|
|
|
|
public BlockPos subtract(Vec3i vector) {
|
|
return this.offset(-vector.getX(), -vector.getY(), -vector.getZ());
|
|
}
|
|
|
|
public BlockPos multiply(int i) {
|
|
if (i == 1) {
|
|
return this;
|
|
} else {
|
|
return i == 0 ? ZERO : new BlockPos(this.getX() * i, this.getY() * i, this.getZ() * i);
|
|
}
|
|
}
|
|
|
|
public BlockPos above() {
|
|
return this.relative(Direction.UP);
|
|
}
|
|
|
|
public BlockPos above(int i) {
|
|
return this.relative(Direction.UP, i);
|
|
}
|
|
|
|
public BlockPos below() {
|
|
return this.relative(Direction.DOWN);
|
|
}
|
|
|
|
public BlockPos below(int i) {
|
|
return this.relative(Direction.DOWN, i);
|
|
}
|
|
|
|
public BlockPos north() {
|
|
return this.relative(Direction.NORTH);
|
|
}
|
|
|
|
public BlockPos north(int i) {
|
|
return this.relative(Direction.NORTH, i);
|
|
}
|
|
|
|
public BlockPos south() {
|
|
return this.relative(Direction.SOUTH);
|
|
}
|
|
|
|
public BlockPos south(int distance) {
|
|
return this.relative(Direction.SOUTH, distance);
|
|
}
|
|
|
|
public BlockPos west() {
|
|
return this.relative(Direction.WEST);
|
|
}
|
|
|
|
public BlockPos west(int i) {
|
|
return this.relative(Direction.WEST, i);
|
|
}
|
|
|
|
public BlockPos east() {
|
|
return this.relative(Direction.EAST);
|
|
}
|
|
|
|
public BlockPos east(int i) {
|
|
return this.relative(Direction.EAST, i);
|
|
}
|
|
|
|
public BlockPos relative(Direction direction) {
|
|
return new BlockPos(this.getX() + direction.getStepX(), this.getY() + direction.getStepY(), this.getZ() + direction.getStepZ());
|
|
}
|
|
|
|
public BlockPos relative(Direction direction, int i) {
|
|
return i == 0 ? this : new BlockPos(this.getX() + direction.getStepX() * i, this.getY() + direction.getStepY() * i, this.getZ() + direction.getStepZ() * i);
|
|
}
|
|
|
|
public BlockPos relative(Direction.Axis axis, int i) {
|
|
if (i == 0) {
|
|
return this;
|
|
} else {
|
|
int j = axis == Direction.Axis.X ? i : 0;
|
|
int k = axis == Direction.Axis.Y ? i : 0;
|
|
int l = axis == Direction.Axis.Z ? i : 0;
|
|
return new BlockPos(this.getX() + j, this.getY() + k, this.getZ() + l);
|
|
}
|
|
}
|
|
|
|
public BlockPos rotate(Rotation rotation) {
|
|
switch (rotation) {
|
|
case NONE:
|
|
default:
|
|
return this;
|
|
case CLOCKWISE_90:
|
|
return new BlockPos(-this.getZ(), this.getY(), this.getX());
|
|
case CLOCKWISE_180:
|
|
return new BlockPos(-this.getX(), this.getY(), -this.getZ());
|
|
case COUNTERCLOCKWISE_90:
|
|
return new BlockPos(this.getZ(), this.getY(), -this.getX());
|
|
}
|
|
}
|
|
|
|
public BlockPos cross(Vec3i vector) {
|
|
return new BlockPos(
|
|
this.getY() * vector.getZ() - this.getZ() * vector.getY(),
|
|
this.getZ() * vector.getX() - this.getX() * vector.getZ(),
|
|
this.getX() * vector.getY() - this.getY() * vector.getX()
|
|
);
|
|
}
|
|
|
|
public BlockPos atY(int y) {
|
|
return new BlockPos(this.getX(), y, this.getZ());
|
|
}
|
|
|
|
/**
|
|
* Returns a version of this BlockPos that is guaranteed to be immutable.
|
|
*
|
|
* <p>When storing a BlockPos given to you for an extended period of time, make sure you
|
|
* use this in case the value is changed internally.</p>
|
|
*/
|
|
public BlockPos immutable() {
|
|
return this;
|
|
}
|
|
|
|
public BlockPos.MutableBlockPos mutable() {
|
|
return new BlockPos.MutableBlockPos(this.getX(), this.getY(), this.getZ());
|
|
}
|
|
|
|
public Vec3 clampLocationWithin(Vec3 pos) {
|
|
return new Vec3(
|
|
Mth.clamp(pos.x, (double)(this.getX() + 1.0E-5F), this.getX() + 1.0 - 1.0E-5F),
|
|
Mth.clamp(pos.y, (double)(this.getY() + 1.0E-5F), this.getY() + 1.0 - 1.0E-5F),
|
|
Mth.clamp(pos.z, (double)(this.getZ() + 1.0E-5F), this.getZ() + 1.0 - 1.0E-5F)
|
|
);
|
|
}
|
|
|
|
public static Iterable<BlockPos> randomInCube(RandomSource random, int amount, BlockPos center, int radius) {
|
|
return randomBetweenClosed(
|
|
random,
|
|
amount,
|
|
center.getX() - radius,
|
|
center.getY() - radius,
|
|
center.getZ() - radius,
|
|
center.getX() + radius,
|
|
center.getY() + radius,
|
|
center.getZ() + radius
|
|
);
|
|
}
|
|
|
|
@Deprecated
|
|
public static Stream<BlockPos> squareOutSouthEast(BlockPos pos) {
|
|
return Stream.of(pos, pos.south(), pos.east(), pos.south().east());
|
|
}
|
|
|
|
public static Iterable<BlockPos> randomBetweenClosed(RandomSource random, int amount, int minX, int minY, int minZ, int maxX, int maxY, int maxZ) {
|
|
int i = maxX - minX + 1;
|
|
int j = maxY - minY + 1;
|
|
int k = maxZ - minZ + 1;
|
|
return () -> new AbstractIterator<BlockPos>() {
|
|
final BlockPos.MutableBlockPos nextPos = new BlockPos.MutableBlockPos();
|
|
int counter = amount;
|
|
|
|
protected BlockPos computeNext() {
|
|
if (this.counter <= 0) {
|
|
return this.endOfData();
|
|
} else {
|
|
BlockPos blockPos = this.nextPos.set(minX + random.nextInt(i), minY + random.nextInt(j), minZ + random.nextInt(k));
|
|
this.counter--;
|
|
return blockPos;
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
public static Iterable<BlockPos> withinManhattan(BlockPos pos, int xSize, int ySize, int zSize) {
|
|
int i = xSize + ySize + zSize;
|
|
int j = pos.getX();
|
|
int k = pos.getY();
|
|
int l = pos.getZ();
|
|
return () -> new AbstractIterator<BlockPos>() {
|
|
private final BlockPos.MutableBlockPos cursor = new BlockPos.MutableBlockPos();
|
|
private int currentDepth;
|
|
private int maxX;
|
|
private int maxY;
|
|
private int x;
|
|
private int y;
|
|
private boolean zMirror;
|
|
|
|
protected BlockPos computeNext() {
|
|
if (this.zMirror) {
|
|
this.zMirror = false;
|
|
this.cursor.setZ(l - (this.cursor.getZ() - l));
|
|
return this.cursor;
|
|
} else {
|
|
BlockPos blockPos;
|
|
for (blockPos = null; blockPos == null; this.y++) {
|
|
if (this.y > this.maxY) {
|
|
this.x++;
|
|
if (this.x > this.maxX) {
|
|
this.currentDepth++;
|
|
if (this.currentDepth > i) {
|
|
return this.endOfData();
|
|
}
|
|
|
|
this.maxX = Math.min(xSize, this.currentDepth);
|
|
this.x = -this.maxX;
|
|
}
|
|
|
|
this.maxY = Math.min(ySize, this.currentDepth - Math.abs(this.x));
|
|
this.y = -this.maxY;
|
|
}
|
|
|
|
int ix = this.x;
|
|
int jx = this.y;
|
|
int kx = this.currentDepth - Math.abs(ix) - Math.abs(jx);
|
|
if (kx <= zSize) {
|
|
this.zMirror = kx != 0;
|
|
blockPos = this.cursor.set(j + ix, k + jx, l + kx);
|
|
}
|
|
}
|
|
|
|
return blockPos;
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
public static Optional<BlockPos> findClosestMatch(BlockPos pos, int width, int height, Predicate<BlockPos> posFilter) {
|
|
for (BlockPos blockPos : withinManhattan(pos, width, height, width)) {
|
|
if (posFilter.test(blockPos)) {
|
|
return Optional.of(blockPos);
|
|
}
|
|
}
|
|
|
|
return Optional.empty();
|
|
}
|
|
|
|
/**
|
|
* Returns a stream of positions in a box shape, ordered by closest to furthest. Returns by definition the given position as first element in the stream.
|
|
*/
|
|
public static Stream<BlockPos> withinManhattanStream(BlockPos pos, int xSize, int ySize, int zSize) {
|
|
return StreamSupport.stream(withinManhattan(pos, xSize, ySize, zSize).spliterator(), false);
|
|
}
|
|
|
|
public static Iterable<BlockPos> betweenClosed(AABB box) {
|
|
BlockPos blockPos = containing(box.minX, box.minY, box.minZ);
|
|
BlockPos blockPos2 = containing(box.maxX, box.maxY, box.maxZ);
|
|
return betweenClosed(blockPos, blockPos2);
|
|
}
|
|
|
|
public static Iterable<BlockPos> betweenClosed(BlockPos firstPos, BlockPos secondPos) {
|
|
return betweenClosed(
|
|
Math.min(firstPos.getX(), secondPos.getX()),
|
|
Math.min(firstPos.getY(), secondPos.getY()),
|
|
Math.min(firstPos.getZ(), secondPos.getZ()),
|
|
Math.max(firstPos.getX(), secondPos.getX()),
|
|
Math.max(firstPos.getY(), secondPos.getY()),
|
|
Math.max(firstPos.getZ(), secondPos.getZ())
|
|
);
|
|
}
|
|
|
|
public static Stream<BlockPos> betweenClosedStream(BlockPos firstPos, BlockPos secondPos) {
|
|
return StreamSupport.stream(betweenClosed(firstPos, secondPos).spliterator(), false);
|
|
}
|
|
|
|
public static Stream<BlockPos> betweenClosedStream(BoundingBox box) {
|
|
return betweenClosedStream(
|
|
Math.min(box.minX(), box.maxX()),
|
|
Math.min(box.minY(), box.maxY()),
|
|
Math.min(box.minZ(), box.maxZ()),
|
|
Math.max(box.minX(), box.maxX()),
|
|
Math.max(box.minY(), box.maxY()),
|
|
Math.max(box.minZ(), box.maxZ())
|
|
);
|
|
}
|
|
|
|
public static Stream<BlockPos> betweenClosedStream(AABB aabb) {
|
|
return betweenClosedStream(Mth.floor(aabb.minX), Mth.floor(aabb.minY), Mth.floor(aabb.minZ), Mth.floor(aabb.maxX), Mth.floor(aabb.maxY), Mth.floor(aabb.maxZ));
|
|
}
|
|
|
|
public static Stream<BlockPos> betweenClosedStream(int minX, int minY, int minZ, int maxX, int maxY, int maxZ) {
|
|
return StreamSupport.stream(betweenClosed(minX, minY, minZ, maxX, maxY, maxZ).spliterator(), false);
|
|
}
|
|
|
|
/**
|
|
* Creates an Iterable that returns all positions in the box specified by the given corners. <strong>Coordinates must be in order</strong>. e.g. x1 <= x2.
|
|
*
|
|
* This method uses {@link BlockPos.MutableBlockPos MutableBlockPos} instead of regular BlockPos, which grants better performance. However, the resulting BlockPos instances can only be used inside the iteration loop (as otherwise the value will change), unless {@link #toImmutable()} is called. This method is ideal for searching large areas and only storing a few locations.
|
|
*
|
|
* @see #betweenClosed(BlockPos, BlockPos)
|
|
* @see #betweenClosed(int, int, int, int, int, int)
|
|
*/
|
|
public static Iterable<BlockPos> betweenClosed(int x1, int y1, int z1, int x2, int y2, int z2) {
|
|
int i = x2 - x1 + 1;
|
|
int j = y2 - y1 + 1;
|
|
int k = z2 - z1 + 1;
|
|
int l = i * j * k;
|
|
return () -> new AbstractIterator<BlockPos>() {
|
|
private final BlockPos.MutableBlockPos cursor = new BlockPos.MutableBlockPos();
|
|
private int index;
|
|
|
|
protected BlockPos computeNext() {
|
|
if (this.index == l) {
|
|
return this.endOfData();
|
|
} else {
|
|
int ix = this.index % i;
|
|
int jx = this.index / i;
|
|
int kx = jx % j;
|
|
int lx = jx / j;
|
|
this.index++;
|
|
return this.cursor.set(x1 + ix, y1 + kx, z1 + lx);
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
public static Iterable<BlockPos.MutableBlockPos> spiralAround(BlockPos center, int size, Direction rotationDirection, Direction expansionDirection) {
|
|
Validate.validState(rotationDirection.getAxis() != expansionDirection.getAxis(), "The two directions cannot be on the same axis");
|
|
return () -> new AbstractIterator<BlockPos.MutableBlockPos>() {
|
|
private final Direction[] directions = new Direction[]{
|
|
rotationDirection, expansionDirection, rotationDirection.getOpposite(), expansionDirection.getOpposite()
|
|
};
|
|
private final BlockPos.MutableBlockPos cursor = center.mutable().move(expansionDirection);
|
|
private final int legs = 4 * size;
|
|
private int leg = -1;
|
|
private int legSize;
|
|
private int legIndex;
|
|
private int lastX = this.cursor.getX();
|
|
private int lastY = this.cursor.getY();
|
|
private int lastZ = this.cursor.getZ();
|
|
|
|
protected BlockPos.MutableBlockPos computeNext() {
|
|
this.cursor.set(this.lastX, this.lastY, this.lastZ).move(this.directions[(this.leg + 4) % 4]);
|
|
this.lastX = this.cursor.getX();
|
|
this.lastY = this.cursor.getY();
|
|
this.lastZ = this.cursor.getZ();
|
|
if (this.legIndex >= this.legSize) {
|
|
if (this.leg >= this.legs) {
|
|
return this.endOfData();
|
|
}
|
|
|
|
this.leg++;
|
|
this.legIndex = 0;
|
|
this.legSize = this.leg / 2 + 1;
|
|
}
|
|
|
|
this.legIndex++;
|
|
return this.cursor;
|
|
}
|
|
};
|
|
}
|
|
|
|
public static int breadthFirstTraversal(
|
|
BlockPos startPos,
|
|
int radius,
|
|
int maxBlocks,
|
|
BiConsumer<BlockPos, Consumer<BlockPos>> childrenGetter,
|
|
Function<BlockPos, BlockPos.TraversalNodeStatus> action
|
|
) {
|
|
Queue<Pair<BlockPos, Integer>> queue = new ArrayDeque();
|
|
LongSet longSet = new LongOpenHashSet();
|
|
queue.add(Pair.of(startPos, 0));
|
|
int i = 0;
|
|
|
|
while (!queue.isEmpty()) {
|
|
Pair<BlockPos, Integer> pair = (Pair<BlockPos, Integer>)queue.poll();
|
|
BlockPos blockPos = pair.getLeft();
|
|
int j = pair.getRight();
|
|
long l = blockPos.asLong();
|
|
if (longSet.add(l)) {
|
|
BlockPos.TraversalNodeStatus traversalNodeStatus = (BlockPos.TraversalNodeStatus)action.apply(blockPos);
|
|
if (traversalNodeStatus != BlockPos.TraversalNodeStatus.SKIP) {
|
|
if (traversalNodeStatus == BlockPos.TraversalNodeStatus.STOP) {
|
|
break;
|
|
}
|
|
|
|
if (++i >= maxBlocks) {
|
|
return i;
|
|
}
|
|
|
|
if (j < radius) {
|
|
childrenGetter.accept(blockPos, (Consumer)blockPosx -> queue.add(Pair.of(blockPosx, j + 1)));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return i;
|
|
}
|
|
|
|
public static class MutableBlockPos extends BlockPos {
|
|
public MutableBlockPos() {
|
|
this(0, 0, 0);
|
|
}
|
|
|
|
public MutableBlockPos(int i, int j, int k) {
|
|
super(i, j, k);
|
|
}
|
|
|
|
public MutableBlockPos(double x, double y, double z) {
|
|
this(Mth.floor(x), Mth.floor(y), Mth.floor(z));
|
|
}
|
|
|
|
@Override
|
|
public BlockPos offset(int i, int j, int k) {
|
|
return super.offset(i, j, k).immutable();
|
|
}
|
|
|
|
@Override
|
|
public BlockPos multiply(int i) {
|
|
return super.multiply(i).immutable();
|
|
}
|
|
|
|
@Override
|
|
public BlockPos relative(Direction direction, int i) {
|
|
return super.relative(direction, i).immutable();
|
|
}
|
|
|
|
@Override
|
|
public BlockPos relative(Direction.Axis axis, int i) {
|
|
return super.relative(axis, i).immutable();
|
|
}
|
|
|
|
@Override
|
|
public BlockPos rotate(Rotation rotation) {
|
|
return super.rotate(rotation).immutable();
|
|
}
|
|
|
|
public BlockPos.MutableBlockPos set(int x, int y, int z) {
|
|
this.setX(x);
|
|
this.setY(y);
|
|
this.setZ(z);
|
|
return this;
|
|
}
|
|
|
|
public BlockPos.MutableBlockPos set(double x, double y, double z) {
|
|
return this.set(Mth.floor(x), Mth.floor(y), Mth.floor(z));
|
|
}
|
|
|
|
public BlockPos.MutableBlockPos set(Vec3i vector) {
|
|
return this.set(vector.getX(), vector.getY(), vector.getZ());
|
|
}
|
|
|
|
public BlockPos.MutableBlockPos set(long packedPos) {
|
|
return this.set(getX(packedPos), getY(packedPos), getZ(packedPos));
|
|
}
|
|
|
|
public BlockPos.MutableBlockPos set(AxisCycle cycle, int x, int y, int z) {
|
|
return this.set(cycle.cycle(x, y, z, Direction.Axis.X), cycle.cycle(x, y, z, Direction.Axis.Y), cycle.cycle(x, y, z, Direction.Axis.Z));
|
|
}
|
|
|
|
public BlockPos.MutableBlockPos setWithOffset(Vec3i pos, Direction direction) {
|
|
return this.set(pos.getX() + direction.getStepX(), pos.getY() + direction.getStepY(), pos.getZ() + direction.getStepZ());
|
|
}
|
|
|
|
public BlockPos.MutableBlockPos setWithOffset(Vec3i vector, int offsetX, int offsetY, int offsetZ) {
|
|
return this.set(vector.getX() + offsetX, vector.getY() + offsetY, vector.getZ() + offsetZ);
|
|
}
|
|
|
|
public BlockPos.MutableBlockPos setWithOffset(Vec3i pos, Vec3i offset) {
|
|
return this.set(pos.getX() + offset.getX(), pos.getY() + offset.getY(), pos.getZ() + offset.getZ());
|
|
}
|
|
|
|
public BlockPos.MutableBlockPos move(Direction direction) {
|
|
return this.move(direction, 1);
|
|
}
|
|
|
|
public BlockPos.MutableBlockPos move(Direction direction, int n) {
|
|
return this.set(this.getX() + direction.getStepX() * n, this.getY() + direction.getStepY() * n, this.getZ() + direction.getStepZ() * n);
|
|
}
|
|
|
|
public BlockPos.MutableBlockPos move(int x, int y, int z) {
|
|
return this.set(this.getX() + x, this.getY() + y, this.getZ() + z);
|
|
}
|
|
|
|
public BlockPos.MutableBlockPos move(Vec3i offset) {
|
|
return this.set(this.getX() + offset.getX(), this.getY() + offset.getY(), this.getZ() + offset.getZ());
|
|
}
|
|
|
|
public BlockPos.MutableBlockPos clamp(Direction.Axis axis, int min, int max) {
|
|
switch (axis) {
|
|
case X:
|
|
return this.set(Mth.clamp(this.getX(), min, max), this.getY(), this.getZ());
|
|
case Y:
|
|
return this.set(this.getX(), Mth.clamp(this.getY(), min, max), this.getZ());
|
|
case Z:
|
|
return this.set(this.getX(), this.getY(), Mth.clamp(this.getZ(), min, max));
|
|
default:
|
|
throw new IllegalStateException("Unable to clamp axis " + axis);
|
|
}
|
|
}
|
|
|
|
public BlockPos.MutableBlockPos setX(int i) {
|
|
super.setX(i);
|
|
return this;
|
|
}
|
|
|
|
public BlockPos.MutableBlockPos setY(int i) {
|
|
super.setY(i);
|
|
return this;
|
|
}
|
|
|
|
public BlockPos.MutableBlockPos setZ(int i) {
|
|
super.setZ(i);
|
|
return this;
|
|
}
|
|
|
|
@Override
|
|
public BlockPos immutable() {
|
|
return new BlockPos(this);
|
|
}
|
|
}
|
|
|
|
public static enum TraversalNodeStatus {
|
|
ACCEPT,
|
|
SKIP,
|
|
STOP;
|
|
}
|
|
}
|