275 lines
7.9 KiB
Java
275 lines
7.9 KiB
Java
/*
|
|
* Decompiled with CFR 0.152.
|
|
*
|
|
* Could not load the following classes:
|
|
* com.google.common.base.MoreObjects
|
|
* com.mojang.serialization.Codec
|
|
* com.mojang.serialization.DataResult
|
|
* io.netty.buffer.ByteBuf
|
|
* javax.annotation.concurrent.Immutable
|
|
* org.joml.Vector3i
|
|
*/
|
|
package net.minecraft.core;
|
|
|
|
import com.google.common.base.MoreObjects;
|
|
import com.mojang.serialization.Codec;
|
|
import com.mojang.serialization.DataResult;
|
|
import io.netty.buffer.ByteBuf;
|
|
import java.util.stream.IntStream;
|
|
import javax.annotation.concurrent.Immutable;
|
|
import net.minecraft.core.Direction;
|
|
import net.minecraft.core.Position;
|
|
import net.minecraft.network.codec.ByteBufCodecs;
|
|
import net.minecraft.network.codec.StreamCodec;
|
|
import net.minecraft.util.Mth;
|
|
import net.minecraft.util.Util;
|
|
import org.joml.Vector3i;
|
|
|
|
@Immutable
|
|
public class Vec3i
|
|
implements Comparable<Vec3i> {
|
|
public static final Codec<Vec3i> CODEC = Codec.INT_STREAM.comapFlatMap(input -> Util.fixedSize(input, 3).map(ints -> new Vec3i(ints[0], ints[1], ints[2])), pos -> IntStream.of(pos.getX(), pos.getY(), pos.getZ()));
|
|
public static final StreamCodec<ByteBuf, Vec3i> STREAM_CODEC = StreamCodec.composite(ByteBufCodecs.VAR_INT, Vec3i::getX, ByteBufCodecs.VAR_INT, Vec3i::getY, ByteBufCodecs.VAR_INT, Vec3i::getZ, Vec3i::new);
|
|
public static final Vec3i ZERO = new Vec3i(0, 0, 0);
|
|
private int x;
|
|
private int y;
|
|
private int z;
|
|
|
|
public static Codec<Vec3i> offsetCodec(int maxOffsetPerAxis) {
|
|
return CODEC.validate(value -> {
|
|
if (Math.abs(value.getX()) < maxOffsetPerAxis && Math.abs(value.getY()) < maxOffsetPerAxis && Math.abs(value.getZ()) < maxOffsetPerAxis) {
|
|
return DataResult.success((Object)value);
|
|
}
|
|
return DataResult.error(() -> "Position out of range, expected at most " + maxOffsetPerAxis + ": " + String.valueOf(value));
|
|
});
|
|
}
|
|
|
|
public Vec3i(int x, int y, int z) {
|
|
this.x = x;
|
|
this.y = y;
|
|
this.z = z;
|
|
}
|
|
|
|
public boolean equals(Object o) {
|
|
if (this == o) {
|
|
return true;
|
|
}
|
|
if (!(o instanceof Vec3i)) {
|
|
return false;
|
|
}
|
|
Vec3i vec3i = (Vec3i)o;
|
|
if (this.getX() != vec3i.getX()) {
|
|
return false;
|
|
}
|
|
if (this.getY() != vec3i.getY()) {
|
|
return false;
|
|
}
|
|
return this.getZ() == vec3i.getZ();
|
|
}
|
|
|
|
public int hashCode() {
|
|
return (this.getY() + this.getZ() * 31) * 31 + this.getX();
|
|
}
|
|
|
|
@Override
|
|
public int compareTo(Vec3i pos) {
|
|
if (this.getY() == pos.getY()) {
|
|
if (this.getZ() == pos.getZ()) {
|
|
return this.getX() - pos.getX();
|
|
}
|
|
return this.getZ() - pos.getZ();
|
|
}
|
|
return this.getY() - pos.getY();
|
|
}
|
|
|
|
public int getX() {
|
|
return this.x;
|
|
}
|
|
|
|
public int getY() {
|
|
return this.y;
|
|
}
|
|
|
|
public int getZ() {
|
|
return this.z;
|
|
}
|
|
|
|
protected Vec3i setX(int x) {
|
|
this.x = x;
|
|
return this;
|
|
}
|
|
|
|
protected Vec3i setY(int y) {
|
|
this.y = y;
|
|
return this;
|
|
}
|
|
|
|
protected Vec3i setZ(int z) {
|
|
this.z = z;
|
|
return this;
|
|
}
|
|
|
|
public Vec3i offset(int x, int y, int z) {
|
|
if (x == 0 && y == 0 && z == 0) {
|
|
return this;
|
|
}
|
|
return new Vec3i(this.getX() + x, this.getY() + y, this.getZ() + z);
|
|
}
|
|
|
|
public Vec3i offset(Vec3i vec) {
|
|
return this.offset(vec.getX(), vec.getY(), vec.getZ());
|
|
}
|
|
|
|
public Vec3i subtract(Vec3i vec) {
|
|
return this.offset(-vec.getX(), -vec.getY(), -vec.getZ());
|
|
}
|
|
|
|
public Vec3i multiply(int scale) {
|
|
if (scale == 1) {
|
|
return this;
|
|
}
|
|
if (scale == 0) {
|
|
return ZERO;
|
|
}
|
|
return new Vec3i(this.getX() * scale, this.getY() * scale, this.getZ() * scale);
|
|
}
|
|
|
|
public Vec3i multiply(int xScale, int yScale, int zScale) {
|
|
return new Vec3i(this.getX() * xScale, this.getY() * yScale, this.getZ() * zScale);
|
|
}
|
|
|
|
public Vec3i above() {
|
|
return this.above(1);
|
|
}
|
|
|
|
public Vec3i above(int steps) {
|
|
return this.relative(Direction.UP, steps);
|
|
}
|
|
|
|
public Vec3i below() {
|
|
return this.below(1);
|
|
}
|
|
|
|
public Vec3i below(int steps) {
|
|
return this.relative(Direction.DOWN, steps);
|
|
}
|
|
|
|
public Vec3i north() {
|
|
return this.north(1);
|
|
}
|
|
|
|
public Vec3i north(int steps) {
|
|
return this.relative(Direction.NORTH, steps);
|
|
}
|
|
|
|
public Vec3i south() {
|
|
return this.south(1);
|
|
}
|
|
|
|
public Vec3i south(int steps) {
|
|
return this.relative(Direction.SOUTH, steps);
|
|
}
|
|
|
|
public Vec3i west() {
|
|
return this.west(1);
|
|
}
|
|
|
|
public Vec3i west(int steps) {
|
|
return this.relative(Direction.WEST, steps);
|
|
}
|
|
|
|
public Vec3i east() {
|
|
return this.east(1);
|
|
}
|
|
|
|
public Vec3i east(int steps) {
|
|
return this.relative(Direction.EAST, steps);
|
|
}
|
|
|
|
public Vec3i relative(Direction direction) {
|
|
return this.relative(direction, 1);
|
|
}
|
|
|
|
public Vec3i relative(Direction direction, int steps) {
|
|
if (steps == 0) {
|
|
return this;
|
|
}
|
|
return new Vec3i(this.getX() + direction.getStepX() * steps, this.getY() + direction.getStepY() * steps, this.getZ() + direction.getStepZ() * steps);
|
|
}
|
|
|
|
public Vec3i relative(Direction.Axis axis, int steps) {
|
|
if (steps == 0) {
|
|
return this;
|
|
}
|
|
int xStep = axis == Direction.Axis.X ? steps : 0;
|
|
int yStep = axis == Direction.Axis.Y ? steps : 0;
|
|
int zStep = axis == Direction.Axis.Z ? steps : 0;
|
|
return new Vec3i(this.getX() + xStep, this.getY() + yStep, this.getZ() + zStep);
|
|
}
|
|
|
|
public Vec3i cross(Vec3i upVector) {
|
|
return new Vec3i(this.getY() * upVector.getZ() - this.getZ() * upVector.getY(), this.getZ() * upVector.getX() - this.getX() * upVector.getZ(), this.getX() * upVector.getY() - this.getY() * upVector.getX());
|
|
}
|
|
|
|
public boolean closerThan(Vec3i pos, double distance) {
|
|
return this.distSqr(pos) < Mth.square(distance);
|
|
}
|
|
|
|
public boolean closerToCenterThan(Position pos, double distance) {
|
|
return this.distToCenterSqr(pos) < Mth.square(distance);
|
|
}
|
|
|
|
public double distSqr(Vec3i pos) {
|
|
return this.distToLowCornerSqr(pos.getX(), pos.getY(), pos.getZ());
|
|
}
|
|
|
|
public double distToCenterSqr(Position pos) {
|
|
return this.distToCenterSqr(pos.x(), pos.y(), pos.z());
|
|
}
|
|
|
|
public double distToCenterSqr(double x, double y, double z) {
|
|
double dx = (double)this.getX() + 0.5 - x;
|
|
double dy = (double)this.getY() + 0.5 - y;
|
|
double dz = (double)this.getZ() + 0.5 - z;
|
|
return dx * dx + dy * dy + dz * dz;
|
|
}
|
|
|
|
public double distToLowCornerSqr(double x, double y, double z) {
|
|
double dx = (double)this.getX() - x;
|
|
double dy = (double)this.getY() - y;
|
|
double dz = (double)this.getZ() - z;
|
|
return dx * dx + dy * dy + dz * dz;
|
|
}
|
|
|
|
public int distManhattan(Vec3i pos) {
|
|
float xd = Math.abs(pos.getX() - this.getX());
|
|
float yd = Math.abs(pos.getY() - this.getY());
|
|
float zd = Math.abs(pos.getZ() - this.getZ());
|
|
return (int)(xd + yd + zd);
|
|
}
|
|
|
|
public int distChessboard(Vec3i pos) {
|
|
int xd = Math.abs(this.getX() - pos.getX());
|
|
int yd = Math.abs(this.getY() - pos.getY());
|
|
int zd = Math.abs(this.getZ() - pos.getZ());
|
|
return Math.max(Math.max(xd, yd), zd);
|
|
}
|
|
|
|
public int get(Direction.Axis axis) {
|
|
return axis.choose(this.x, this.y, this.z);
|
|
}
|
|
|
|
public Vector3i toMutable() {
|
|
return new Vector3i(this.x, this.y, this.z);
|
|
}
|
|
|
|
public String toString() {
|
|
return MoreObjects.toStringHelper((Object)this).add("x", this.getX()).add("y", this.getY()).add("z", this.getZ()).toString();
|
|
}
|
|
|
|
public String toShortString() {
|
|
return this.getX() + ", " + this.getY() + ", " + this.getZ();
|
|
}
|
|
}
|
|
|