mirror of
https://github.com/funkemunky/KauriV3.git
synced 2026-06-07 16:42:17 +00:00
Dawson
319 lines
10 KiB
Java
319 lines
10 KiB
Java
package dev.brighten.ac.utils;
|
|
|
|
import dev.brighten.ac.packet.wrapper.objects.WrappedEnumDirection;
|
|
import dev.brighten.ac.utils.world.types.RayCollision;
|
|
import dev.brighten.ac.utils.world.types.SimpleCollisionBox;
|
|
import org.bukkit.Location;
|
|
import org.bukkit.util.Vector;
|
|
|
|
public class AxisAlignedBB {
|
|
|
|
public final double minX;
|
|
public final double minY;
|
|
public final double minZ;
|
|
public final double maxX;
|
|
public final double maxY;
|
|
public final double maxZ;
|
|
|
|
public AxisAlignedBB(double d0, double d1, double d2, double d3, double d4, double d5) {
|
|
this.minX = Math.min(d0, d3);
|
|
this.minY = Math.min(d1, d4);
|
|
this.minZ = Math.min(d2, d5);
|
|
this.maxX = Math.max(d0, d3);
|
|
this.maxY = Math.max(d1, d4);
|
|
this.maxZ = Math.max(d2, d5);
|
|
}
|
|
|
|
public AxisAlignedBB(BoundingBox box) {
|
|
this.minX = box.minX;
|
|
this.minY = box.minY;
|
|
this.minZ = box.minZ;
|
|
this.maxX = box.maxX;
|
|
this.maxY = box.maxY;
|
|
this.maxZ = box.maxZ;
|
|
}
|
|
|
|
public AxisAlignedBB(SimpleCollisionBox box) {
|
|
this.minX = box.xMin;
|
|
this.minY = box.yMin;
|
|
this.minZ = box.zMin;
|
|
this.maxX = box.xMax;
|
|
this.maxY = box.yMax;
|
|
this.maxZ = box.zMax;
|
|
}
|
|
|
|
public AxisAlignedBB(Location blockposition, Location blockposition1) {
|
|
this.minX = blockposition.getBlockX();
|
|
this.minY = blockposition.getBlockY();
|
|
this.minZ = blockposition.getBlockZ();
|
|
this.maxX = blockposition1.getBlockX();
|
|
this.maxY = blockposition1.getBlockY();
|
|
this.maxZ = blockposition1.getBlockZ();
|
|
}
|
|
|
|
public AxisAlignedBB a(double d0, double d1, double d2) {
|
|
double d3 = this.minX;
|
|
double d4 = this.minY;
|
|
double d5 = this.minZ;
|
|
double d6 = this.maxX;
|
|
double d7 = this.maxY;
|
|
double d8 = this.maxZ;
|
|
|
|
if (d0 < 0.0D) {
|
|
d3 += d0;
|
|
} else if (d0 > 0.0D) {
|
|
d6 += d0;
|
|
}
|
|
|
|
if (d1 < 0.0D) {
|
|
d4 += d1;
|
|
} else if (d1 > 0.0D) {
|
|
d7 += d1;
|
|
}
|
|
|
|
if (d2 < 0.0D) {
|
|
d5 += d2;
|
|
} else if (d2 > 0.0D) {
|
|
d8 += d2;
|
|
}
|
|
|
|
return new AxisAlignedBB(d3, d4, d5, d6, d7, d8);
|
|
}
|
|
|
|
public AxisAlignedBB grow(double d0, double d1, double d2) {
|
|
double d3 = this.minX - d0;
|
|
double d4 = this.minY - d1;
|
|
double d5 = this.minZ - d2;
|
|
double d6 = this.maxX + d0;
|
|
double d7 = this.maxY + d1;
|
|
double d8 = this.maxZ + d2;
|
|
|
|
return new AxisAlignedBB(d3, d4, d5, d6, d7, d8);
|
|
}
|
|
|
|
public AxisAlignedBB a(AxisAlignedBB axisalignedbb) {
|
|
double d0 = Math.min(this.minX, axisalignedbb.minX);
|
|
double d1 = Math.min(this.minY, axisalignedbb.minY);
|
|
double d2 = Math.min(this.minZ, axisalignedbb.minZ);
|
|
double d3 = Math.max(this.maxX, axisalignedbb.maxX);
|
|
double d4 = Math.max(this.maxY, axisalignedbb.maxY);
|
|
double d5 = Math.max(this.maxZ, axisalignedbb.maxZ);
|
|
|
|
return new AxisAlignedBB(d0, d1, d2, d3, d4, d5);
|
|
}
|
|
|
|
public AxisAlignedBB c(double d0, double d1, double d2) {
|
|
return new AxisAlignedBB(this.minX + d0, this.minY + d1,
|
|
this.minZ + d2, this.maxX + d0, this.maxY + d1, this.maxZ + d2);
|
|
}
|
|
|
|
public double a(AxisAlignedBB axisalignedbb, double d0) {
|
|
if (axisalignedbb.maxY > this.minY && axisalignedbb.minY < this.maxY && axisalignedbb.maxZ > this.minZ
|
|
&& axisalignedbb.minZ < this.maxZ) {
|
|
double d1;
|
|
|
|
if (d0 > 0.0D && axisalignedbb.maxX <= this.minX) {
|
|
d1 = this.minX - axisalignedbb.maxX;
|
|
if (d1 < d0) {
|
|
d0 = d1;
|
|
}
|
|
} else if (d0 < 0.0D && axisalignedbb.minX >= this.maxX) {
|
|
d1 = this.maxX - axisalignedbb.minX;
|
|
if (d1 > d0) {
|
|
d0 = d1;
|
|
}
|
|
}
|
|
|
|
return d0;
|
|
} else {
|
|
return d0;
|
|
}
|
|
}
|
|
|
|
public double b(AxisAlignedBB axisalignedbb, double d0) {
|
|
if (axisalignedbb.maxX > this.minX && axisalignedbb.minX < this.maxX
|
|
&& axisalignedbb.maxZ > this.minZ && axisalignedbb.minZ < this.maxZ) {
|
|
double d1;
|
|
|
|
if (d0 > 0.0D && axisalignedbb.maxY <= this.minY) {
|
|
d1 = this.minY - axisalignedbb.maxY;
|
|
if (d1 < d0) {
|
|
d0 = d1;
|
|
}
|
|
} else if (d0 < 0.0D && axisalignedbb.minY >= this.maxY) {
|
|
d1 = this.maxY - axisalignedbb.minY;
|
|
if (d1 > d0) {
|
|
d0 = d1;
|
|
}
|
|
}
|
|
|
|
return d0;
|
|
} else {
|
|
return d0;
|
|
}
|
|
}
|
|
|
|
public double c(AxisAlignedBB axisalignedbb, double d0) {
|
|
if (axisalignedbb.maxX > this.minX && axisalignedbb.minX < this.maxX
|
|
&& axisalignedbb.maxY > this.minY && axisalignedbb.minY < this.maxY) {
|
|
double d1;
|
|
|
|
if (d0 > 0.0D && axisalignedbb.maxZ <= this.minZ) {
|
|
d1 = this.minZ - axisalignedbb.maxZ;
|
|
if (d1 < d0) {
|
|
d0 = d1;
|
|
}
|
|
} else if (d0 < 0.0D && axisalignedbb.minZ >= this.maxZ) {
|
|
d1 = this.maxZ - axisalignedbb.minZ;
|
|
if (d1 > d0) {
|
|
d0 = d1;
|
|
}
|
|
}
|
|
|
|
return d0;
|
|
} else {
|
|
return d0;
|
|
}
|
|
}
|
|
|
|
public boolean b(AxisAlignedBB axisalignedbb) {
|
|
return (axisalignedbb.maxX > this.minX && axisalignedbb.minX < this.maxX)
|
|
&& ((axisalignedbb.maxY > this.minY && axisalignedbb.minY < this.maxY)
|
|
&& (axisalignedbb.maxZ > this.minZ && axisalignedbb.minZ < this.maxZ));
|
|
}
|
|
|
|
public boolean a(Vec3D vec3d) {
|
|
return (vec3d.x > this.minX && vec3d.x < this.maxX) && ((vec3d.y > this.minY && vec3d.y < this.maxY)
|
|
&& (vec3d.z > this.minZ && vec3d.z < this.maxZ));
|
|
}
|
|
|
|
public double a() {
|
|
double d0 = this.maxX - this.minX;
|
|
double d1 = this.maxY - this.minY;
|
|
double d2 = this.maxZ - this.minZ;
|
|
|
|
return (d0 + d1 + d2) / 3.0D;
|
|
}
|
|
|
|
public AxisAlignedBB shrink(double d0, double d1, double d2) {
|
|
double d3 = this.minX + d0;
|
|
double d4 = this.minY + d1;
|
|
double d5 = this.minZ + d2;
|
|
double d6 = this.maxX - d0;
|
|
double d7 = this.maxY - d1;
|
|
double d8 = this.maxZ - d2;
|
|
|
|
return new AxisAlignedBB(d3, d4, d5, d6, d7, d8);
|
|
}
|
|
|
|
public Vec3D rayTrace(RayCollision collision, double distance) {
|
|
Vec3D origin = new Vec3D(collision.originX, collision.originY, collision.originZ);
|
|
Vec3D dir = origin.clone().add(collision.directionX * distance, collision.directionY * distance, collision.directionZ * distance);
|
|
return rayTrace(origin, dir);
|
|
}
|
|
|
|
public Vec3D rayTrace(Vector vorigin, Vector vdirection, double distance) {
|
|
Vec3D origin = new Vec3D(vorigin.getX(), vorigin.getY(), vorigin.getZ());
|
|
Vector direction = vdirection.clone().multiply(distance);
|
|
Vec3D dir = origin.clone().add(direction.getX(), direction.getY(), direction.getZ());
|
|
|
|
return rayTrace(origin, dir);
|
|
}
|
|
|
|
public Vec3D rayTrace(Vec3D vec3d, Vec3D vec3d1) {
|
|
Vec3D vec3d2 = vec3d.a(vec3d1, this.minX);
|
|
Vec3D vec3d3 = vec3d.a(vec3d1, this.maxX);
|
|
Vec3D vec3d4 = vec3d.b(vec3d1, this.minY);
|
|
Vec3D vec3d5 = vec3d.b(vec3d1, this.maxY);
|
|
Vec3D vec3d6 = vec3d.c(vec3d1, this.minZ);
|
|
Vec3D vec3d7 = vec3d.c(vec3d1, this.maxZ);
|
|
|
|
if (!this.b(vec3d2)) {
|
|
vec3d2 = null;
|
|
}
|
|
|
|
if (!this.b(vec3d3)) {
|
|
vec3d3 = null;
|
|
}
|
|
|
|
if (!this.c(vec3d4)) {
|
|
vec3d4 = null;
|
|
}
|
|
|
|
if (!this.c(vec3d5)) {
|
|
vec3d5 = null;
|
|
}
|
|
|
|
if (!this.d(vec3d6)) {
|
|
vec3d6 = null;
|
|
}
|
|
|
|
if (!this.d(vec3d7)) {
|
|
vec3d7 = null;
|
|
}
|
|
|
|
Vec3D vec3d8 = null;
|
|
|
|
if (vec3d2 != null) {
|
|
vec3d8 = vec3d2;
|
|
}
|
|
|
|
if (vec3d3 != null && (vec3d8 == null || vec3d.distanceSquared(vec3d3) < vec3d.distanceSquared(vec3d8))) {
|
|
vec3d8 = vec3d3;
|
|
}
|
|
|
|
if (vec3d4 != null && (vec3d8 == null || vec3d.distanceSquared(vec3d4) < vec3d.distanceSquared(vec3d8))) {
|
|
vec3d8 = vec3d4;
|
|
}
|
|
|
|
if (vec3d5 != null && (vec3d8 == null || vec3d.distanceSquared(vec3d5) < vec3d.distanceSquared(vec3d8))) {
|
|
vec3d8 = vec3d5;
|
|
}
|
|
|
|
if (vec3d6 != null && (vec3d8 == null || vec3d.distanceSquared(vec3d6) < vec3d.distanceSquared(vec3d8))) {
|
|
vec3d8 = vec3d6;
|
|
}
|
|
|
|
if (vec3d7 != null && (vec3d8 == null || vec3d.distanceSquared(vec3d7) < vec3d.distanceSquared(vec3d8))) {
|
|
vec3d8 = vec3d7;
|
|
}
|
|
|
|
if (vec3d8 == null) {
|
|
return null;
|
|
} else {
|
|
WrappedEnumDirection enumdirection = null;
|
|
|
|
if (vec3d8 == vec3d2) {
|
|
enumdirection = WrappedEnumDirection.WEST;
|
|
} else if (vec3d8 == vec3d3) {
|
|
enumdirection = WrappedEnumDirection.EAST;
|
|
} else if (vec3d8 == vec3d4) {
|
|
enumdirection = WrappedEnumDirection.DOWN;
|
|
} else if (vec3d8 == vec3d5) {
|
|
enumdirection = WrappedEnumDirection.UP;
|
|
} else if (vec3d8 == vec3d6) {
|
|
enumdirection = WrappedEnumDirection.NORTH;
|
|
} else {
|
|
enumdirection = WrappedEnumDirection.SOUTH;
|
|
}
|
|
|
|
return vec3d8;
|
|
}
|
|
}
|
|
|
|
private boolean b(Vec3D vec3d) {
|
|
return vec3d != null && (vec3d.y >= this.minY && vec3d.y <= this.maxY && vec3d.z >= this.minZ && vec3d.z <= this.maxZ);
|
|
}
|
|
|
|
private boolean c(Vec3D vec3d) {
|
|
return vec3d != null && (vec3d.x >= this.minX && vec3d.x <= this.maxX && vec3d.z >= this.minZ && vec3d.z <= this.maxZ);
|
|
}
|
|
|
|
private boolean d(Vec3D vec3d) {
|
|
return vec3d != null && (vec3d.x >= this.minX && vec3d.x <= this.maxX && vec3d.y >= this.minY && vec3d.y <= this.maxY);
|
|
}
|
|
|
|
public String toString() {
|
|
return "box[" + this.minX + ", " + this.minY + ", " + this.minZ + " -> " + this.maxX + ", " + this.maxY + ", " + this.maxZ + "]";
|
|
}
|
|
} |