313 lines
11 KiB
Java
313 lines
11 KiB
Java
/*
|
|
* Decompiled with CFR 0.152.
|
|
*
|
|
* Could not load the following classes:
|
|
* io.netty.buffer.ByteBuf
|
|
* it.unimi.dsi.fastutil.longs.LongConsumer
|
|
*/
|
|
package net.minecraft.core;
|
|
|
|
import io.netty.buffer.ByteBuf;
|
|
import it.unimi.dsi.fastutil.longs.LongConsumer;
|
|
import java.util.Spliterators;
|
|
import java.util.function.Consumer;
|
|
import java.util.stream.Stream;
|
|
import java.util.stream.StreamSupport;
|
|
import net.minecraft.core.BlockPos;
|
|
import net.minecraft.core.Cursor3D;
|
|
import net.minecraft.core.Direction;
|
|
import net.minecraft.core.Position;
|
|
import net.minecraft.core.Vec3i;
|
|
import net.minecraft.network.codec.ByteBufCodecs;
|
|
import net.minecraft.network.codec.StreamCodec;
|
|
import net.minecraft.util.Mth;
|
|
import net.minecraft.world.level.ChunkPos;
|
|
import net.minecraft.world.level.chunk.ChunkAccess;
|
|
import net.minecraft.world.level.entity.EntityAccess;
|
|
|
|
public class SectionPos
|
|
extends Vec3i {
|
|
public static final int SECTION_BITS = 4;
|
|
public static final int SECTION_SIZE = 16;
|
|
public static final int SECTION_MASK = 15;
|
|
public static final int SECTION_HALF_SIZE = 8;
|
|
public static final int SECTION_MAX_INDEX = 15;
|
|
private static final int PACKED_X_LENGTH = 22;
|
|
private static final int PACKED_Y_LENGTH = 20;
|
|
private static final int PACKED_Z_LENGTH = 22;
|
|
private static final long PACKED_X_MASK = 0x3FFFFFL;
|
|
private static final long PACKED_Y_MASK = 1048575L;
|
|
private static final long PACKED_Z_MASK = 0x3FFFFFL;
|
|
private static final int Y_OFFSET = 0;
|
|
private static final int Z_OFFSET = 20;
|
|
private static final int X_OFFSET = 42;
|
|
private static final int RELATIVE_X_SHIFT = 8;
|
|
private static final int RELATIVE_Y_SHIFT = 0;
|
|
private static final int RELATIVE_Z_SHIFT = 4;
|
|
public static final StreamCodec<ByteBuf, SectionPos> STREAM_CODEC = ByteBufCodecs.LONG.map(SectionPos::of, SectionPos::asLong);
|
|
|
|
private SectionPos(int x, int y, int z) {
|
|
super(x, y, z);
|
|
}
|
|
|
|
public static SectionPos of(int x, int y, int z) {
|
|
return new SectionPos(x, y, z);
|
|
}
|
|
|
|
public static SectionPos of(BlockPos pos) {
|
|
return new SectionPos(SectionPos.blockToSectionCoord(pos.getX()), SectionPos.blockToSectionCoord(pos.getY()), SectionPos.blockToSectionCoord(pos.getZ()));
|
|
}
|
|
|
|
public static SectionPos of(ChunkPos pos, int sectionY) {
|
|
return new SectionPos(pos.x, sectionY, pos.z);
|
|
}
|
|
|
|
public static SectionPos of(EntityAccess entity) {
|
|
return SectionPos.of(entity.blockPosition());
|
|
}
|
|
|
|
public static SectionPos of(Position pos) {
|
|
return new SectionPos(SectionPos.blockToSectionCoord(pos.x()), SectionPos.blockToSectionCoord(pos.y()), SectionPos.blockToSectionCoord(pos.z()));
|
|
}
|
|
|
|
public static SectionPos of(long sectionNode) {
|
|
return new SectionPos(SectionPos.x(sectionNode), SectionPos.y(sectionNode), SectionPos.z(sectionNode));
|
|
}
|
|
|
|
public static SectionPos bottomOf(ChunkAccess chunk) {
|
|
return SectionPos.of(chunk.getPos(), chunk.getMinSectionY());
|
|
}
|
|
|
|
public static long offset(long sectionNode, Direction offset) {
|
|
return SectionPos.offset(sectionNode, offset.getStepX(), offset.getStepY(), offset.getStepZ());
|
|
}
|
|
|
|
public static long offset(long sectionNode, int stepX, int stepY, int stepZ) {
|
|
return SectionPos.asLong(SectionPos.x(sectionNode) + stepX, SectionPos.y(sectionNode) + stepY, SectionPos.z(sectionNode) + stepZ);
|
|
}
|
|
|
|
public static int posToSectionCoord(double pos) {
|
|
return SectionPos.blockToSectionCoord(Mth.floor(pos));
|
|
}
|
|
|
|
public static int blockToSectionCoord(int blockCoord) {
|
|
return blockCoord >> 4;
|
|
}
|
|
|
|
public static int blockToSectionCoord(double coord) {
|
|
return Mth.floor(coord) >> 4;
|
|
}
|
|
|
|
public static int sectionRelative(int blockCoord) {
|
|
return blockCoord & 0xF;
|
|
}
|
|
|
|
public static short sectionRelativePos(BlockPos pos) {
|
|
int x = SectionPos.sectionRelative(pos.getX());
|
|
int y = SectionPos.sectionRelative(pos.getY());
|
|
int z = SectionPos.sectionRelative(pos.getZ());
|
|
return (short)(x << 8 | z << 4 | y << 0);
|
|
}
|
|
|
|
public static int sectionRelativeX(short relative) {
|
|
return relative >>> 8 & 0xF;
|
|
}
|
|
|
|
public static int sectionRelativeY(short relative) {
|
|
return relative >>> 0 & 0xF;
|
|
}
|
|
|
|
public static int sectionRelativeZ(short relative) {
|
|
return relative >>> 4 & 0xF;
|
|
}
|
|
|
|
public int relativeToBlockX(short relative) {
|
|
return this.minBlockX() + SectionPos.sectionRelativeX(relative);
|
|
}
|
|
|
|
public int relativeToBlockY(short relative) {
|
|
return this.minBlockY() + SectionPos.sectionRelativeY(relative);
|
|
}
|
|
|
|
public int relativeToBlockZ(short relative) {
|
|
return this.minBlockZ() + SectionPos.sectionRelativeZ(relative);
|
|
}
|
|
|
|
public BlockPos relativeToBlockPos(short relative) {
|
|
return new BlockPos(this.relativeToBlockX(relative), this.relativeToBlockY(relative), this.relativeToBlockZ(relative));
|
|
}
|
|
|
|
public static int sectionToBlockCoord(int sectionCoord) {
|
|
return sectionCoord << 4;
|
|
}
|
|
|
|
public static int sectionToBlockCoord(int sectionCoord, int offset) {
|
|
return SectionPos.sectionToBlockCoord(sectionCoord) + offset;
|
|
}
|
|
|
|
public static int x(long sectionNode) {
|
|
return (int)(sectionNode << 0 >> 42);
|
|
}
|
|
|
|
public static int y(long sectionNode) {
|
|
return (int)(sectionNode << 44 >> 44);
|
|
}
|
|
|
|
public static int z(long sectionNode) {
|
|
return (int)(sectionNode << 22 >> 42);
|
|
}
|
|
|
|
public int x() {
|
|
return this.getX();
|
|
}
|
|
|
|
public int y() {
|
|
return this.getY();
|
|
}
|
|
|
|
public int z() {
|
|
return this.getZ();
|
|
}
|
|
|
|
public int minBlockX() {
|
|
return SectionPos.sectionToBlockCoord(this.x());
|
|
}
|
|
|
|
public int minBlockY() {
|
|
return SectionPos.sectionToBlockCoord(this.y());
|
|
}
|
|
|
|
public int minBlockZ() {
|
|
return SectionPos.sectionToBlockCoord(this.z());
|
|
}
|
|
|
|
public int maxBlockX() {
|
|
return SectionPos.sectionToBlockCoord(this.x(), 15);
|
|
}
|
|
|
|
public int maxBlockY() {
|
|
return SectionPos.sectionToBlockCoord(this.y(), 15);
|
|
}
|
|
|
|
public int maxBlockZ() {
|
|
return SectionPos.sectionToBlockCoord(this.z(), 15);
|
|
}
|
|
|
|
public static long blockToSection(long blockNode) {
|
|
return SectionPos.asLong(SectionPos.blockToSectionCoord(BlockPos.getX(blockNode)), SectionPos.blockToSectionCoord(BlockPos.getY(blockNode)), SectionPos.blockToSectionCoord(BlockPos.getZ(blockNode)));
|
|
}
|
|
|
|
public static long getZeroNode(int x, int z) {
|
|
return SectionPos.getZeroNode(SectionPos.asLong(x, 0, z));
|
|
}
|
|
|
|
public static long getZeroNode(long sectionNode) {
|
|
return sectionNode & 0xFFFFFFFFFFF00000L;
|
|
}
|
|
|
|
public static long sectionToChunk(long sectionNode) {
|
|
return ChunkPos.asLong(SectionPos.x(sectionNode), SectionPos.z(sectionNode));
|
|
}
|
|
|
|
public BlockPos origin() {
|
|
return new BlockPos(SectionPos.sectionToBlockCoord(this.x()), SectionPos.sectionToBlockCoord(this.y()), SectionPos.sectionToBlockCoord(this.z()));
|
|
}
|
|
|
|
public BlockPos center() {
|
|
int delta = 8;
|
|
return this.origin().offset(8, 8, 8);
|
|
}
|
|
|
|
public ChunkPos chunk() {
|
|
return new ChunkPos(this.x(), this.z());
|
|
}
|
|
|
|
public static long asLong(BlockPos pos) {
|
|
return SectionPos.asLong(SectionPos.blockToSectionCoord(pos.getX()), SectionPos.blockToSectionCoord(pos.getY()), SectionPos.blockToSectionCoord(pos.getZ()));
|
|
}
|
|
|
|
public static long asLong(int x, int y, int z) {
|
|
long node = 0L;
|
|
node |= ((long)x & 0x3FFFFFL) << 42;
|
|
node |= ((long)y & 0xFFFFFL) << 0;
|
|
return node |= ((long)z & 0x3FFFFFL) << 20;
|
|
}
|
|
|
|
public long asLong() {
|
|
return SectionPos.asLong(this.x(), this.y(), this.z());
|
|
}
|
|
|
|
@Override
|
|
public SectionPos offset(int x, int y, int z) {
|
|
if (x == 0 && y == 0 && z == 0) {
|
|
return this;
|
|
}
|
|
return new SectionPos(this.x() + x, this.y() + y, this.z() + z);
|
|
}
|
|
|
|
public Stream<BlockPos> blocksInside() {
|
|
return BlockPos.betweenClosedStream(this.minBlockX(), this.minBlockY(), this.minBlockZ(), this.maxBlockX(), this.maxBlockY(), this.maxBlockZ());
|
|
}
|
|
|
|
public static Stream<SectionPos> cube(SectionPos center, int radius) {
|
|
int x = center.x();
|
|
int y = center.y();
|
|
int z = center.z();
|
|
return SectionPos.betweenClosedStream(x - radius, y - radius, z - radius, x + radius, y + radius, z + radius);
|
|
}
|
|
|
|
public static Stream<SectionPos> aroundChunk(ChunkPos center, int radius, int minSection, int maxSection) {
|
|
int x = center.x;
|
|
int z = center.z;
|
|
return SectionPos.betweenClosedStream(x - radius, minSection, z - radius, x + radius, maxSection, z + radius);
|
|
}
|
|
|
|
public static Stream<SectionPos> betweenClosedStream(final int minX, final int minY, final int minZ, final int maxX, final int maxY, final int maxZ) {
|
|
return StreamSupport.stream(new Spliterators.AbstractSpliterator<SectionPos>((long)((maxX - minX + 1) * (maxY - minY + 1) * (maxZ - minZ + 1)), 64){
|
|
final Cursor3D cursor;
|
|
{
|
|
super(est, additionalCharacteristics);
|
|
this.cursor = new Cursor3D(minX, minY, minZ, maxX, maxY, maxZ);
|
|
}
|
|
|
|
@Override
|
|
public boolean tryAdvance(Consumer<? super SectionPos> action) {
|
|
if (this.cursor.advance()) {
|
|
action.accept(new SectionPos(this.cursor.nextX(), this.cursor.nextY(), this.cursor.nextZ()));
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
}, false);
|
|
}
|
|
|
|
public static void aroundAndAtBlockPos(BlockPos blockPos, LongConsumer sectionConsumer) {
|
|
SectionPos.aroundAndAtBlockPos(blockPos.getX(), blockPos.getY(), blockPos.getZ(), sectionConsumer);
|
|
}
|
|
|
|
public static void aroundAndAtBlockPos(long blockPos, LongConsumer sectionConsumer) {
|
|
SectionPos.aroundAndAtBlockPos(BlockPos.getX(blockPos), BlockPos.getY(blockPos), BlockPos.getZ(blockPos), sectionConsumer);
|
|
}
|
|
|
|
public static void aroundAndAtBlockPos(int blockX, int blockY, int blockZ, LongConsumer sectionConsumer) {
|
|
int minSectionX = SectionPos.blockToSectionCoord(blockX - 1);
|
|
int maxSectionX = SectionPos.blockToSectionCoord(blockX + 1);
|
|
int minSectionY = SectionPos.blockToSectionCoord(blockY - 1);
|
|
int maxSectionY = SectionPos.blockToSectionCoord(blockY + 1);
|
|
int minSectionZ = SectionPos.blockToSectionCoord(blockZ - 1);
|
|
int maxSectionZ = SectionPos.blockToSectionCoord(blockZ + 1);
|
|
if (minSectionX == maxSectionX && minSectionY == maxSectionY && minSectionZ == maxSectionZ) {
|
|
sectionConsumer.accept(SectionPos.asLong(minSectionX, minSectionY, minSectionZ));
|
|
} else {
|
|
for (int sectionX = minSectionX; sectionX <= maxSectionX; ++sectionX) {
|
|
for (int sectionY = minSectionY; sectionY <= maxSectionY; ++sectionY) {
|
|
for (int sectionZ = minSectionZ; sectionZ <= maxSectionZ; ++sectionZ) {
|
|
sectionConsumer.accept(SectionPos.asLong(sectionX, sectionY, sectionZ));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|