Auto code cleanup
This commit is contained in:
@@ -190,10 +190,10 @@ public final class WorldUtils2 {
|
||||
public static RectI2 intersectRectangles(final RectI2 r0, final RectI2 r1) {
|
||||
final CoordI2 size0 = ImmutableCoordI2.create(r0.getC1().getX() - r0.getC0().getX(), r0.getC1().getY() - r0.getC0().getY());
|
||||
final CoordI2 size1 = ImmutableCoordI2.create(r1.getC1().getX() - r1.getC0().getX(), r1.getC1().getY() - r1.getC0().getY());
|
||||
final Rectangle rect0 = new Rectangle(r0.getC0().getX(), r0.getC0().getY(), size0.getX(), size0.getY());
|
||||
final Rectangle rect1 = new Rectangle(r1.getC0().getX(), r1.getC0().getY(), size1.getX(), size1.getY());
|
||||
final var rect0 = new Rectangle(r0.getC0().getX(), r0.getC0().getY(), size0.getX(), size0.getY());
|
||||
final var rect1 = new Rectangle(r1.getC0().getX(), r1.getC0().getY(), size1.getX(), size1.getY());
|
||||
|
||||
final Rectangle intersection = rect0.intersection(rect1);
|
||||
final var intersection = rect0.intersection(rect1);
|
||||
if (intersection.isEmpty()) {
|
||||
return null;
|
||||
}
|
||||
@@ -210,10 +210,10 @@ public final class WorldUtils2 {
|
||||
* @return The intersected area if r0 and r1 overlap, else null
|
||||
*/
|
||||
public static Area2 intersectAreas(final HasPositionAndDimension2 a0, final HasPositionAndDimension2 a1) {
|
||||
final Rectangle rect0 = new Rectangle(a0.getPosition().getX(), a0.getPosition().getY(), a0.getDimension().getX(), a0.getDimension().getY());
|
||||
final Rectangle rect1 = new Rectangle(a1.getPosition().getX(), a1.getPosition().getY(), a1.getDimension().getX(), a1.getDimension().getY());
|
||||
final var rect0 = new Rectangle(a0.getPosition().getX(), a0.getPosition().getY(), a0.getDimension().getX(), a0.getDimension().getY());
|
||||
final var rect1 = new Rectangle(a1.getPosition().getX(), a1.getPosition().getY(), a1.getDimension().getX(), a1.getDimension().getY());
|
||||
|
||||
final Rectangle intersection = rect0.intersection(rect1);
|
||||
final var intersection = rect0.intersection(rect1);
|
||||
if (intersection.isEmpty()) {
|
||||
return null;
|
||||
}
|
||||
@@ -242,10 +242,10 @@ public final class WorldUtils2 {
|
||||
* @return true / false whether obj0 intersects with obj1
|
||||
*/
|
||||
public static boolean intersects(final CoordI2 position0, final CoordI2 dimension0, final CoordI2 position1, final CoordI2 dimension1) {
|
||||
int d0x = dimension0.getX();
|
||||
int d0y = dimension0.getY();
|
||||
int d1x = dimension1.getX();
|
||||
int d1y = dimension1.getY();
|
||||
var d0x = dimension0.getX();
|
||||
var d0y = dimension0.getY();
|
||||
var d1x = dimension1.getX();
|
||||
var d1y = dimension1.getY();
|
||||
if (d0x <= 0 || d0y <= 0 || d1x <= 0 || d1y <= 0) {
|
||||
return false;
|
||||
}
|
||||
@@ -261,7 +261,6 @@ public final class WorldUtils2 {
|
||||
(d1y < position1.getY() || d1y > position0.getY()));
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Builds an aligned Area2 from arbitrary points
|
||||
* @return
|
||||
@@ -273,7 +272,7 @@ public final class WorldUtils2 {
|
||||
|
||||
final CoordI2 corner0 = MutableCoordI2.create(points[0]);
|
||||
final CoordI2 corner1 = MutableCoordI2.create(points[0]).add(1, 1);
|
||||
for (int i = 1; i < points.length; i++) {
|
||||
for (var i = 1; i < points.length; i++) {
|
||||
corner0.setXY(Math.min(corner0.getX(), points[i].getX()), Math.min(corner0.getY(), points[i].getY()));
|
||||
corner1.setXY(Math.max(corner1.getX(), points[i].getX() + 1), Math.max(corner1.getY(), points[i].getY() + 1));
|
||||
}
|
||||
@@ -295,14 +294,14 @@ public final class WorldUtils2 {
|
||||
final CoordD2 pTarget = ImmutableCoordD2.create(pTarget_);
|
||||
final CoordD2 vTarget = ImmutableCoordD2.create(vTarget_);
|
||||
|
||||
final double a = (vTarget.getX() * vTarget.getX()) + (vTarget.getY() * vTarget.getY()) - (velOrigin * velOrigin);
|
||||
final double b = 2 * ((pTarget.getX() * vTarget.getX()) + (pTarget.getY() * vTarget.getY()) - (pOrigin.getX() * vTarget.getX()) - (pOrigin.getY() * vTarget.getY()));
|
||||
final double c = (pTarget.getX() * pTarget.getX()) + (pTarget.getY() * pTarget.getY()) + (pOrigin.getX() * pOrigin.getX()) + (pOrigin.getY() * pOrigin.getY()) - (2 * pOrigin.getX() * pTarget.getX()) - (2 * pOrigin.getY() * pTarget.getY());
|
||||
final double t0 = (-b + Math.sqrt((b * b) - (4.0 * a * c))) / (2.0 * a);
|
||||
final double t1 = (-b - Math.sqrt((b * b) - (4.0 * a * c))) / (2.0 * a);
|
||||
final var a = (vTarget.getX() * vTarget.getX()) + (vTarget.getY() * vTarget.getY()) - (velOrigin * velOrigin);
|
||||
final var b = 2 * ((pTarget.getX() * vTarget.getX()) + (pTarget.getY() * vTarget.getY()) - (pOrigin.getX() * vTarget.getX()) - (pOrigin.getY() * vTarget.getY()));
|
||||
final var c = (pTarget.getX() * pTarget.getX()) + (pTarget.getY() * pTarget.getY()) + (pOrigin.getX() * pOrigin.getX()) + (pOrigin.getY() * pOrigin.getY()) - (2 * pOrigin.getX() * pTarget.getX()) - (2 * pOrigin.getY() * pTarget.getY());
|
||||
final var t0 = (-b + Math.sqrt((b * b) - (4.0 * a * c))) / (2.0 * a);
|
||||
final var t1 = (-b - Math.sqrt((b * b) - (4.0 * a * c))) / (2.0 * a);
|
||||
|
||||
final boolean t0Pass = !Double.isNaN(t0) && t0 > 0.0;
|
||||
final boolean t1Pass = !Double.isNaN(t1) && t1 > 0.0;
|
||||
final var t0Pass = !Double.isNaN(t0) && t0 > 0.0;
|
||||
final var t1Pass = !Double.isNaN(t1) && t1 > 0.0;
|
||||
double t;
|
||||
if (t0Pass && t1Pass) {
|
||||
t = Math.min(t0, t1);
|
||||
@@ -341,7 +340,7 @@ public final class WorldUtils2 {
|
||||
|
||||
Arrays.sort(dists, (e0, e1) -> Double.compare(e0.dist, e1.dist));
|
||||
|
||||
final int sector = dists[0].sector | dists[1].sector;
|
||||
final var sector = dists[0].sector | dists[1].sector;
|
||||
|
||||
if (sector == 0b11) {
|
||||
return Edge2.TOP;
|
||||
@@ -366,22 +365,22 @@ public final class WorldUtils2 {
|
||||
* @return Pedal of altitude c
|
||||
*/
|
||||
public static CoordD2 getPedal(final CoordI2 a, final CoordI2 b, final CoordI2 c) {
|
||||
final double distA = getDistance(a, b);
|
||||
final var distA = getDistance(a, b);
|
||||
if (distA == 0.0) {
|
||||
return null;
|
||||
}
|
||||
final double distASquare = Math.pow(distA, 2.0);
|
||||
final double distB = getDistance(b, c);
|
||||
final double distBSquare = Math.pow(distB, 2.0);
|
||||
final double distC = getDistance(c, a);
|
||||
final double distCSquare = Math.pow(distC, 2.0);
|
||||
final var distASquare = Math.pow(distA, 2.0);
|
||||
final var distB = getDistance(b, c);
|
||||
final var distBSquare = Math.pow(distB, 2.0);
|
||||
final var distC = getDistance(c, a);
|
||||
final var distCSquare = Math.pow(distC, 2.0);
|
||||
|
||||
final double altA = Math.sqrt((2.0 * ((distASquare * distBSquare) + (distBSquare * distCSquare) + (distCSquare * distASquare))) - (Math.pow(distA, 4.0) + Math.pow(distB, 4.0) + Math.pow(distC, 4.0))) / (2.0 * distA);
|
||||
final var altA = Math.sqrt((2.0 * ((distASquare * distBSquare) + (distBSquare * distCSquare) + (distCSquare * distASquare))) - (Math.pow(distA, 4.0) + Math.pow(distB, 4.0) + Math.pow(distC, 4.0))) / (2.0 * distA);
|
||||
if (Double.isNaN(altA)) {
|
||||
return null;
|
||||
}
|
||||
final double alpha = getVectorAngle(b.substract(a), c.substract(a));
|
||||
final double scaleA = (Math.sqrt(distCSquare - Math.pow(altA, 2.0)) / distA) * copySign(Math.PI / 2.0 - Math.abs(alpha));
|
||||
final var alpha = getVectorAngle(b.substract(a), c.substract(a));
|
||||
final var scaleA = (Math.sqrt(distCSquare - Math.pow(altA, 2.0)) / distA) * copySign(Math.PI / 2.0 - Math.abs(alpha));
|
||||
if (Double.isNaN(scaleA)) {
|
||||
return null;
|
||||
}
|
||||
@@ -404,12 +403,12 @@ public final class WorldUtils2 {
|
||||
* Returns null if there is no pedal.
|
||||
*/
|
||||
public static CoordD2 getPedalOnLineSegmentAB(final CoordI2 a, final CoordI2 b, final CoordI2 c) {
|
||||
final CoordD2 pedal = getPedal(a, b, c);
|
||||
final var pedal = getPedal(a, b, c);
|
||||
if (pedal == null) {
|
||||
return null;
|
||||
}
|
||||
|
||||
double x = pedal.getX();
|
||||
var x = pedal.getX();
|
||||
final double minX = Math.min(a.getX(), b.getX());
|
||||
if (x < minX) {
|
||||
x = minX;
|
||||
@@ -419,7 +418,7 @@ public final class WorldUtils2 {
|
||||
x = maxX;
|
||||
}
|
||||
|
||||
double y = pedal.getY();
|
||||
var y = pedal.getY();
|
||||
final double minY = Math.min(a.getY(), b.getY());
|
||||
if (y < minY) {
|
||||
y = minY;
|
||||
@@ -446,15 +445,15 @@ public final class WorldUtils2 {
|
||||
* @return
|
||||
*/
|
||||
public static CoordI2 getClosestPoint(final CoordI2 origin, final HasPositionAndDimension2 target) {
|
||||
double minDistance = Double.MAX_VALUE;
|
||||
var minDistance = Double.MAX_VALUE;
|
||||
CoordI2 result = null;
|
||||
|
||||
final List<CoordI2> vertices = getVertices(target);
|
||||
for (int i = 1; i < 4; i++) {
|
||||
final CoordD2 pedal = getPedalOnLineSegmentAB(vertices.get(i - 1), vertices.get(i), origin);
|
||||
final var vertices = getVertices(target);
|
||||
for (var i = 1; i < 4; i++) {
|
||||
final var pedal = getPedalOnLineSegmentAB(vertices.get(i - 1), vertices.get(i), origin);
|
||||
if (pedal != null) {
|
||||
final CoordI2 pedalI = pedal.toImmutableCoordI2();
|
||||
final double distance = getDistance(origin, pedalI);
|
||||
final var pedalI = pedal.toImmutableCoordI2();
|
||||
final var distance = getDistance(origin, pedalI);
|
||||
if (distance < minDistance) {
|
||||
minDistance = distance;
|
||||
result = pedalI;
|
||||
@@ -477,17 +476,17 @@ public final class WorldUtils2 {
|
||||
* @return Waypoints for evasion or null if there is no collision
|
||||
*/
|
||||
public static List<CoordI2> evade(final HasPositionAndDimension2 origin, final double velOrigin, final CoordD2 vOrigin, final HasPositionAndDimension2 target, final CoordD2 vTarget, final CoordI2 oTarget, final CoordI2 pInterception_) {
|
||||
final double THRESHOLD_NOT_MOVING = 0.2;
|
||||
final var THRESHOLD_NOT_MOVING = 0.2;
|
||||
|
||||
final CoordI2 pOrigin = ImmutableCoordI2.create(origin.getPosition()).add(ImmutableCoordI2.create(origin.getDimension()).divide(2));
|
||||
final CoordI2 pTarget = ImmutableCoordI2.create(target.getPosition()).add(ImmutableCoordI2.create(target.getDimension()).divide(2));
|
||||
final double velTarget = getDistance(vTarget);
|
||||
final var velTarget = getDistance(vTarget);
|
||||
|
||||
if (velOrigin < THRESHOLD_NOT_MOVING) {
|
||||
// Corner case: Origin is not moving
|
||||
|
||||
final CoordD2 vOriginToTarget = ImmutableCoordD2.create(pTarget).substract(ImmutableCoordD2.create(pOrigin));
|
||||
CoordD2 vEvasion = MutableCoordD2
|
||||
var vEvasion = MutableCoordD2
|
||||
.create(-vOriginToTarget.getY(), vOriginToTarget.getX()) // Rotate by PI/2
|
||||
.toVNorm()
|
||||
.multiply(getDistance(origin.getDimension()) * 2.0);
|
||||
@@ -513,31 +512,31 @@ public final class WorldUtils2 {
|
||||
final CoordI2 boxDim = ImmutableCoordI2.create(
|
||||
Math.max(origin.getDimension().getX(), origin.getDimension().getY()) + 4,
|
||||
Math.max(origin.getDimension().getX(), origin.getDimension().getY()) + 4);
|
||||
final CoordI2 targetDimHalf = target.getDimension().divide(2);
|
||||
final Area2 box = new Area2(pInterception
|
||||
final var targetDimHalf = target.getDimension().divide(2);
|
||||
final var box = new Area2(pInterception
|
||||
.add(targetDimHalf.substract(oTarget))
|
||||
.substract(targetDimHalf)
|
||||
.substract(boxDim),
|
||||
targetDimHalf
|
||||
.add(boxDim)
|
||||
.multiply(2));
|
||||
final List<CoordI2> vertices = getVertices(box);
|
||||
final var vertices = getVertices(box);
|
||||
|
||||
// Rule out one or more vertices, because ...
|
||||
|
||||
if (velTarget >= THRESHOLD_NOT_MOVING && Math.abs(getVectorAngle(vOrigin, vTarget)) < Math.PI / 4.0) { // Velocity vectors are similar -> collision from behind
|
||||
// Remove both vertices in origin move direction
|
||||
|
||||
int removeVertexIdxLow = -1;
|
||||
int removeVertexIdxHigh = -1;
|
||||
var removeVertexIdxLow = -1;
|
||||
var removeVertexIdxHigh = -1;
|
||||
|
||||
double aLow = Math.PI;
|
||||
double aHigh = 0.0;
|
||||
for (int i = 0; i < vertices.size(); i++) {
|
||||
final CoordI2 curVertex = vertices.get(i);
|
||||
var aLow = Math.PI;
|
||||
var aHigh = 0.0;
|
||||
for (var i = 0; i < vertices.size(); i++) {
|
||||
final var curVertex = vertices.get(i);
|
||||
|
||||
final CoordD2 direction = pInterception.substract(curVertex).toImmutableCoordD2();
|
||||
final double a = Math.abs(getVectorAngle(vOrigin, direction));
|
||||
final var direction = pInterception.substract(curVertex).toImmutableCoordD2();
|
||||
final var a = Math.abs(getVectorAngle(vOrigin, direction));
|
||||
if (removeVertexIdxLow == -1 || a < aLow) {
|
||||
aLow = a;
|
||||
removeVertexIdxLow = i;
|
||||
@@ -554,26 +553,26 @@ public final class WorldUtils2 {
|
||||
else if (velTarget < velOrigin - 0.75) { // Origin speed is higher
|
||||
// Remove vertex farthest from origin move direction, but closest vertex will never be ruled out (-> primary)
|
||||
|
||||
int safeVertexIdx = 0;
|
||||
double vLen = -1.0;
|
||||
for (int i = 0; i < vertices.size(); i++) {
|
||||
final CoordI2 curVertex = vertices.get(i);
|
||||
final double curVLen = getDistance(pOrigin, curVertex);
|
||||
var safeVertexIdx = 0;
|
||||
var vLen = -1.0;
|
||||
for (var i = 0; i < vertices.size(); i++) {
|
||||
final var curVertex = vertices.get(i);
|
||||
final var curVLen = getDistance(pOrigin, curVertex);
|
||||
if (vLen < 0.0 || curVLen < vLen) {
|
||||
vLen = curVLen;
|
||||
safeVertexIdx = i;
|
||||
}
|
||||
}
|
||||
|
||||
int removeVertexIdx = 0;
|
||||
double aHigh = 0.0;
|
||||
for (int i = 0; i < vertices.size(); i++) {
|
||||
var removeVertexIdx = 0;
|
||||
var aHigh = 0.0;
|
||||
for (var i = 0; i < vertices.size(); i++) {
|
||||
if (i == safeVertexIdx) {
|
||||
continue;
|
||||
}
|
||||
|
||||
final CoordI2 curVertex = vertices.get(i);
|
||||
final double a = Math.abs(getVectorAngle(curVertex.substract(pOrigin).toImmutableCoordD2(), vOrigin));
|
||||
final var curVertex = vertices.get(i);
|
||||
final var a = Math.abs(getVectorAngle(curVertex.substract(pOrigin).toImmutableCoordD2(), vOrigin));
|
||||
if (a > aHigh) {
|
||||
aHigh = a;
|
||||
removeVertexIdx = i;
|
||||
@@ -585,13 +584,13 @@ public final class WorldUtils2 {
|
||||
else {
|
||||
// Remove vertex closest to target move direction
|
||||
|
||||
int removeVertexIdx = -1;
|
||||
var removeVertexIdx = -1;
|
||||
|
||||
double vLen = -1.0;
|
||||
for (int i = 0; i < vertices.size(); i++) {
|
||||
final CoordI2 curVertex = vertices.get(i);
|
||||
var vLen = -1.0;
|
||||
for (var i = 0; i < vertices.size(); i++) {
|
||||
final var curVertex = vertices.get(i);
|
||||
final CoordD2 curV = ImmutableCoordD2.create(pInterception.substract(curVertex)).add(vTarget);
|
||||
final double curVLen = getDistance(curV);
|
||||
final var curVLen = getDistance(curV);
|
||||
if (vLen < 0.0 || curVLen < vLen) {
|
||||
vLen = curVLen;
|
||||
removeVertexIdx = i;
|
||||
@@ -603,11 +602,11 @@ public final class WorldUtils2 {
|
||||
|
||||
// Get closest vertex -> primary
|
||||
|
||||
int primaryVertexIdx = -1;
|
||||
double closestDist = -1.0;
|
||||
for (int i = 0; i < vertices.size(); i++) {
|
||||
var primaryVertexIdx = -1;
|
||||
var closestDist = -1.0;
|
||||
for (var i = 0; i < vertices.size(); i++) {
|
||||
if (vertices.get(i) != null) {
|
||||
final double curDist = getDistance(vertices.get(i), pOrigin);
|
||||
final var curDist = getDistance(vertices.get(i), pOrigin);
|
||||
if (closestDist < 0.0 || curDist < closestDist) {
|
||||
closestDist = curDist;
|
||||
primaryVertexIdx = i;
|
||||
@@ -617,13 +616,13 @@ public final class WorldUtils2 {
|
||||
|
||||
// Choose secondary vertex
|
||||
|
||||
final int candidate0 = (primaryVertexIdx + 1) % vertices.size();
|
||||
final int candidate1 = Math.floorMod(primaryVertexIdx - 1, vertices.size());
|
||||
final var candidate0 = (primaryVertexIdx + 1) % vertices.size();
|
||||
final var candidate1 = Math.floorMod(primaryVertexIdx - 1, vertices.size());
|
||||
int secondVertexIdx;
|
||||
if (vertices.get(candidate0) != null && vertices.get(candidate1) != null) {
|
||||
// Center vertex, choose secondary which is closer to origin velocity vector
|
||||
final double a0 = getVectorAngle(pInterception.substract(pOrigin), vertices.get(candidate0).substract(pOrigin));
|
||||
final double a1 = getVectorAngle(pInterception.substract(pOrigin), vertices.get(candidate1).substract(pOrigin));
|
||||
final var a0 = getVectorAngle(pInterception.substract(pOrigin), vertices.get(candidate0).substract(pOrigin));
|
||||
final var a1 = getVectorAngle(pInterception.substract(pOrigin), vertices.get(candidate1).substract(pOrigin));
|
||||
if (Math.abs(a0) < Math.abs(a1)) {
|
||||
secondVertexIdx = candidate0;
|
||||
}
|
||||
@@ -742,7 +741,7 @@ public final class WorldUtils2 {
|
||||
* @return random point in the circle
|
||||
*/
|
||||
public static CoordI2 getRandomPointOnCircle(final CoordI2 center, final int radius, final Random random) {
|
||||
final double angle = random.nextDouble() * Math.PI * 2.0 - Math.PI;
|
||||
final var angle = random.nextDouble() * Math.PI * 2.0 - Math.PI;
|
||||
return MutableCoordD2
|
||||
.create(Math.cos(angle), Math.sin(angle))
|
||||
.multiply(radius)
|
||||
@@ -758,7 +757,7 @@ public final class WorldUtils2 {
|
||||
* @return random point in the circle
|
||||
*/
|
||||
public static CoordI2 getReproduciblePointOnCircle(final CoordI2 center, final int radius, final AtomicInteger counter) {
|
||||
final double angle = counter.incrementAndGet() / 3.0 % Math.PI * 2.0 - Math.PI;
|
||||
final var angle = counter.incrementAndGet() / 3.0 % Math.PI * 2.0 - Math.PI;
|
||||
return MutableCoordD2
|
||||
.create(Math.cos(angle), Math.sin(angle))
|
||||
.multiply(radius)
|
||||
@@ -777,10 +776,10 @@ public final class WorldUtils2 {
|
||||
* @return Edges that are required as bit mask
|
||||
*/
|
||||
public static int calcEdgeRequirement(final CoordI2 c0, final CoordI2 c1) {
|
||||
final int dx = c0.getX() - c1.getX();
|
||||
final int dy = c0.getY() - c1.getY();
|
||||
final var dx = c0.getX() - c1.getX();
|
||||
final var dy = c0.getY() - c1.getY();
|
||||
|
||||
int edgeReq = 0;
|
||||
var edgeReq = 0;
|
||||
if (dx < 0 && dy < 0) {
|
||||
edgeReq = Edge2.LEFT.getBit() | Edge2.TOP.getBit();
|
||||
}
|
||||
|
||||
@@ -49,7 +49,7 @@ public final class GridIndex2D<T extends HasPosition2> implements Iterable<T>, A
|
||||
}
|
||||
|
||||
public List<T> get(final HasPosition2 hasPosition2) {
|
||||
final CoordI2 coord = hasPosition2.getPosition();
|
||||
final var coord = hasPosition2.getPosition();
|
||||
if (!this.checkBounds(coord)) {
|
||||
return List.of();
|
||||
}
|
||||
@@ -101,7 +101,7 @@ public final class GridIndex2D<T extends HasPosition2> implements Iterable<T>, A
|
||||
throw new ConcurrentModificationException();
|
||||
}
|
||||
|
||||
final T result = GridIndex2D.this.index.get(this.x).get(this.y).get(this.i);
|
||||
final var result = GridIndex2D.this.index.get(this.x).get(this.y).get(this.i);
|
||||
this.forward();
|
||||
return result;
|
||||
}
|
||||
@@ -138,9 +138,9 @@ public final class GridIndex2D<T extends HasPosition2> implements Iterable<T>, A
|
||||
|
||||
@Override
|
||||
public void forEach(final Consumer<? super T> action) {
|
||||
for (int x = 0; x < this.index.size(); x++) {
|
||||
for (int y = 0; y < this.index.get(x).size(); y++) {
|
||||
for (int i = 0; i < this.index.get(x).get(y).size(); i++) {
|
||||
for (var x = 0; x < this.index.size(); x++) {
|
||||
for (var y = 0; y < this.index.get(x).size(); y++) {
|
||||
for (var i = 0; i < this.index.get(x).get(y).size(); i++) {
|
||||
action.accept(this.index.get(x).get(y).get(i));
|
||||
}
|
||||
}
|
||||
@@ -150,8 +150,8 @@ public final class GridIndex2D<T extends HasPosition2> implements Iterable<T>, A
|
||||
public void forEach(final BiConsumer<CoordI2, List<T>> action) {
|
||||
final CoordI2 coord = MutableCoordI2.create();
|
||||
|
||||
for (int x = 0; x < this.index.size(); x++) {
|
||||
for (int y = 0; y < this.index.get(x).size(); y++) {
|
||||
for (var x = 0; x < this.index.size(); x++) {
|
||||
for (var y = 0; y < this.index.get(x).size(); y++) {
|
||||
if (this.index.get(x).get(y).size() > 0) {
|
||||
coord.setXY(x, y);
|
||||
action.accept(coord, this.index.get(x).get(y));
|
||||
@@ -161,7 +161,7 @@ public final class GridIndex2D<T extends HasPosition2> implements Iterable<T>, A
|
||||
}
|
||||
|
||||
private void ensureBounds(final CoordI2 coord) {
|
||||
int delta = this.index.size() - coord.getX();
|
||||
var delta = this.index.size() - coord.getX();
|
||||
if (delta < 1) {
|
||||
for (delta = -delta; delta >= 0; delta--) {
|
||||
this.index.add(new ArrayList<>());
|
||||
|
||||
@@ -48,8 +48,8 @@ public final class LinearSearchIndex2D<T extends SpatialIndex2Capable> implement
|
||||
public List<T> find(final CoordI2 position, final CoordI2 dimension, final Predicate<T> filter) {
|
||||
List<T> result = null;
|
||||
|
||||
for (int i = 0; i < this.objects.size(); i++) {
|
||||
final T obj = this.objects.get(i);
|
||||
for (var i = 0; i < this.objects.size(); i++) {
|
||||
final var obj = this.objects.get(i);
|
||||
|
||||
if (WorldUtils2.intersects(position, dimension, obj.getPosition(), obj.getDimension())) {
|
||||
if (filter == null || filter.test(obj)) {
|
||||
@@ -73,8 +73,8 @@ public final class LinearSearchIndex2D<T extends SpatialIndex2Capable> implement
|
||||
|
||||
@Override
|
||||
public T findFirstAt(final CoordI2 position, final Predicate<T> filter) {
|
||||
for (int i = 0; i < this.objects.size(); i++) {
|
||||
final T obj = this.objects.get(i);
|
||||
for (var i = 0; i < this.objects.size(); i++) {
|
||||
final var obj = this.objects.get(i);
|
||||
|
||||
if (WorldUtils2.intersects(position, ImmutableCoordI2.one(), obj.getPosition(), obj.getDimension())) {
|
||||
if (filter == null || filter.test(obj)) {
|
||||
@@ -88,8 +88,8 @@ public final class LinearSearchIndex2D<T extends SpatialIndex2Capable> implement
|
||||
|
||||
@Override
|
||||
public void executeAt(final CoordI2 position, final Consumer<T> consumer, final Predicate<T> filter) {
|
||||
for (int i = 0; i < this.objects.size(); i++) {
|
||||
final T obj = this.objects.get(i);
|
||||
for (var i = 0; i < this.objects.size(); i++) {
|
||||
final var obj = this.objects.get(i);
|
||||
|
||||
if (WorldUtils2.intersects(position, ImmutableCoordI2.one(), obj.getPosition(), obj.getDimension())) {
|
||||
if (filter == null || filter.test(obj)) {
|
||||
|
||||
@@ -37,8 +37,8 @@ public final class Matrix2<T> implements Iterable<T> {
|
||||
this.dimension.setX(other.matrix.size());
|
||||
|
||||
this.matrix = new ArrayList<>(other.matrix);
|
||||
for (int x = 0; x < this.matrix.size(); x++) {
|
||||
final List<T> column = other.matrix.get(x);
|
||||
for (var x = 0; x < this.matrix.size(); x++) {
|
||||
final var column = other.matrix.get(x);
|
||||
this.matrix.set(x, new ArrayList<>(column));
|
||||
|
||||
if (column.size() > this.dimension.getY()) {
|
||||
@@ -93,8 +93,8 @@ public final class Matrix2<T> implements Iterable<T> {
|
||||
}
|
||||
|
||||
public void removeAll() {
|
||||
for (int x = 0; x < this.matrix.size(); x++) {
|
||||
for (int y = 0; y < this.matrix.get(x).size(); y++) {
|
||||
for (var x = 0; x < this.matrix.size(); x++) {
|
||||
for (var y = 0; y < this.matrix.get(x).size(); y++) {
|
||||
this.matrix.get(x).set(y, null);
|
||||
}
|
||||
}
|
||||
@@ -127,11 +127,11 @@ public final class Matrix2<T> implements Iterable<T> {
|
||||
return;
|
||||
}
|
||||
|
||||
int delta = this.matrix.size() - x;
|
||||
var delta = this.matrix.size() - x;
|
||||
if (delta < 1) {
|
||||
for (delta = -delta; delta >= 0; delta--) {
|
||||
final List<T> row = new ArrayList<>(y + 1);
|
||||
for (int i = 0; i <= y; i++) {
|
||||
for (var i = 0; i <= y; i++) {
|
||||
row.add(null);
|
||||
}
|
||||
this.matrix.add(row);
|
||||
@@ -165,8 +165,8 @@ public final class Matrix2<T> implements Iterable<T> {
|
||||
this.allocate(origDim.getY() - 1, origDim.getX() - 1);
|
||||
|
||||
final CoordI2 posSrc = MutableCoordI2.create();
|
||||
for (int x = 0; x < origDim.getY(); x++) {
|
||||
for (int y = 0; y < origDim.getX(); y++) {
|
||||
for (var x = 0; x < origDim.getY(); x++) {
|
||||
for (var y = 0; y < origDim.getX(); y++) {
|
||||
if (direction == Edge2.LEFT) {
|
||||
posSrc.setXY(origDim.getX() - y - 1, x);
|
||||
}
|
||||
@@ -174,7 +174,7 @@ public final class Matrix2<T> implements Iterable<T> {
|
||||
posSrc.setXY(y, origDim.getY() - x - 1);
|
||||
}
|
||||
|
||||
final List<T> originalObjs = original.get(posSrc.getX());
|
||||
final var originalObjs = original.get(posSrc.getX());
|
||||
if (originalObjs.size() > posSrc.getY()) {
|
||||
this.matrix.get(x).set(y, originalObjs.get(posSrc.getY()));
|
||||
}
|
||||
@@ -222,8 +222,8 @@ public final class Matrix2<T> implements Iterable<T> {
|
||||
return this.obj;
|
||||
}
|
||||
|
||||
int x = this.x;
|
||||
int y = this.y;
|
||||
var x = this.x;
|
||||
var y = this.y;
|
||||
for (; x < Matrix2.this.matrix.size(); x++) {
|
||||
for (; y < Matrix2.this.matrix.get(x).size(); y++) {
|
||||
this.obj = Matrix2.this.matrix.get(x).get(y);
|
||||
@@ -251,9 +251,9 @@ public final class Matrix2<T> implements Iterable<T> {
|
||||
|
||||
@Override
|
||||
public void forEach(final Consumer<? super T> action) {
|
||||
for (int x = 0; x < this.matrix.size(); x++) {
|
||||
for (int y = 0; y < this.matrix.get(x).size(); y++) {
|
||||
final T obj = this.matrix.get(x).get(y);
|
||||
for (var x = 0; x < this.matrix.size(); x++) {
|
||||
for (var y = 0; y < this.matrix.get(x).size(); y++) {
|
||||
final var obj = this.matrix.get(x).get(y);
|
||||
if (obj != null) {
|
||||
action.accept(obj);
|
||||
}
|
||||
@@ -264,9 +264,9 @@ public final class Matrix2<T> implements Iterable<T> {
|
||||
public void forEach(final BiConsumer<CoordI2, T> consumer) {
|
||||
final CoordI2 coord = MutableCoordI2.create();
|
||||
|
||||
for (int x = 0; x < this.matrix.size(); x++) {
|
||||
for (int y = 0; y < this.matrix.get(x).size(); y++) {
|
||||
final T obj = this.matrix.get(x).get(y);
|
||||
for (var x = 0; x < this.matrix.size(); x++) {
|
||||
for (var y = 0; y < this.matrix.get(x).size(); y++) {
|
||||
final var obj = this.matrix.get(x).get(y);
|
||||
if (obj != null) {
|
||||
coord.setXY(x, y);
|
||||
consumer.accept(coord, obj);
|
||||
|
||||
@@ -51,10 +51,10 @@ public final class QuadTree<T extends SpatialIndex2Capable> implements SpatialIn
|
||||
@SuppressWarnings("unchecked")
|
||||
@Override
|
||||
public void add(final T obj) {
|
||||
final RectI2 rect = this.toRectI2(obj.getPosition(), obj.getDimension());
|
||||
final var rect = this.toRectI2(obj.getPosition(), obj.getDimension());
|
||||
this.expandTree(rect);
|
||||
|
||||
Node<T> node = this.root;
|
||||
var node = this.root;
|
||||
traversal: while (true) {
|
||||
if (node.branches == null) {
|
||||
// Add leaf to fresh branch
|
||||
@@ -65,14 +65,14 @@ public final class QuadTree<T extends SpatialIndex2Capable> implements SpatialIn
|
||||
|
||||
// Overflow -> Split if not already at lowest level
|
||||
if (node.createBranches()) {
|
||||
final List<T> toSplit = node.leaves;
|
||||
final var toSplit = node.leaves;
|
||||
if (toSplit != null) {
|
||||
node.leaves = null;
|
||||
|
||||
splitLeaves: for (int l = 0; l < toSplit.size(); l++) {
|
||||
final T leaf = toSplit.get(l);
|
||||
splitLeaves: for (var l = 0; l < toSplit.size(); l++) {
|
||||
final var leaf = toSplit.get(l);
|
||||
|
||||
for (int b = 0; b < ORDER; b++) {
|
||||
for (var b = 0; b < ORDER; b++) {
|
||||
if (this.contains(node.branches[b], leaf)) {
|
||||
this.addLeave(node.branches[b], leaf);
|
||||
continue splitLeaves;
|
||||
@@ -88,7 +88,7 @@ public final class QuadTree<T extends SpatialIndex2Capable> implements SpatialIn
|
||||
}
|
||||
else {
|
||||
// Traverse
|
||||
for (int i = 0; i < ORDER; i++) {
|
||||
for (var i = 0; i < ORDER; i++) {
|
||||
if (this.contains(node.branches[i], rect)) {
|
||||
node = node.branches[i];
|
||||
continue traversal;
|
||||
@@ -105,17 +105,17 @@ public final class QuadTree<T extends SpatialIndex2Capable> implements SpatialIn
|
||||
@SuppressWarnings("unchecked")
|
||||
private void expandTree(final RectI2 rect) {
|
||||
if (this.root == null) {
|
||||
final int side = 1 << DEPTH_START;
|
||||
final var side = 1 << DEPTH_START;
|
||||
this.root = new Node<>(rect.getC0().getX() - side, rect.getC0().getY() - side, side << 1);
|
||||
this.root.createBranches();
|
||||
this.recalcDepth();
|
||||
}
|
||||
|
||||
for (int i = 0; !this.contains(this.root, rect); i++) {
|
||||
final RectI2 expansion = new RectI2(MutableCoordI2.create(), MutableCoordI2.create());
|
||||
final int[] branchesIntersect = new int[4];
|
||||
int intersects = 0;
|
||||
int containsBranch = -1;
|
||||
for (var i = 0; !this.contains(this.root, rect); i++) {
|
||||
final var expansion = new RectI2(MutableCoordI2.create(), MutableCoordI2.create());
|
||||
final var branchesIntersect = new int[4];
|
||||
var intersects = 0;
|
||||
var containsBranch = -1;
|
||||
|
||||
expansion.getC0().setXY(this.root.xMin, this.root.yMin);
|
||||
expansion.getC1().setXY(Integer.MAX_VALUE, Integer.MAX_VALUE);
|
||||
@@ -157,8 +157,8 @@ public final class QuadTree<T extends SpatialIndex2Capable> implements SpatialIn
|
||||
}
|
||||
|
||||
Node<T> rootNew = null;
|
||||
final int branch = containsBranch != -1 ? containsBranch : branchesIntersect[i % intersects];
|
||||
final int size = this.root.xMax - this.root.xMin + 1;
|
||||
final var branch = containsBranch != -1 ? containsBranch : branchesIntersect[i % intersects];
|
||||
final var size = this.root.xMax - this.root.xMin + 1;
|
||||
switch (branch) {
|
||||
case 0:
|
||||
rootNew = new Node<>(this.root.xMin, this.root.yMin, size << 1);
|
||||
@@ -221,7 +221,7 @@ public final class QuadTree<T extends SpatialIndex2Capable> implements SpatialIn
|
||||
|
||||
@Override
|
||||
public void remove(final T obj) {
|
||||
final RectI2 rect = this.toRectI2Bounded(obj.getPosition(), obj.getDimension());
|
||||
final var rect = this.toRectI2Bounded(obj.getPosition(), obj.getDimension());
|
||||
if (rect == null) {
|
||||
return;
|
||||
}
|
||||
@@ -231,7 +231,7 @@ public final class QuadTree<T extends SpatialIndex2Capable> implements SpatialIn
|
||||
|
||||
@SuppressWarnings("unchecked")
|
||||
private void remove(final T obj, final RectI2 rect) {
|
||||
Node<T> node = this.root;
|
||||
var node = this.root;
|
||||
traversal: while (true) {
|
||||
if (node.leaves != null) {
|
||||
node.leaves.remove(obj);
|
||||
@@ -243,7 +243,7 @@ public final class QuadTree<T extends SpatialIndex2Capable> implements SpatialIn
|
||||
}
|
||||
|
||||
if (node.branches != null) {
|
||||
for (int i = 0; i < ORDER; i++) {
|
||||
for (var i = 0; i < ORDER; i++) {
|
||||
if (this.contains(node.branches[i], rect)) {
|
||||
node = node.branches[i];
|
||||
continue traversal;
|
||||
@@ -256,9 +256,9 @@ public final class QuadTree<T extends SpatialIndex2Capable> implements SpatialIn
|
||||
}
|
||||
|
||||
private void shrink(final Node<T> node_) {
|
||||
Node<T> node = node_;
|
||||
var node = node_;
|
||||
while (node.parent != null) {
|
||||
for (int i = 0; i < ORDER; i++) {
|
||||
for (var i = 0; i < ORDER; i++) {
|
||||
if (node.parent.branches[i].leaves != null || node.parent.branches[i].branches != null) {
|
||||
return;
|
||||
}
|
||||
@@ -272,17 +272,17 @@ public final class QuadTree<T extends SpatialIndex2Capable> implements SpatialIn
|
||||
@SuppressWarnings("unchecked")
|
||||
@Override
|
||||
public void move(final T obj, final CoordI2 oldPosition, final CoordI2 oldDimension) {
|
||||
final RectI2 rect = this.toRectI2Bounded(oldPosition, oldDimension);
|
||||
final var rect = this.toRectI2Bounded(oldPosition, oldDimension);
|
||||
if (rect != null) {
|
||||
int nodes = 0;
|
||||
Node<T> node = this.root;
|
||||
var nodes = 0;
|
||||
var node = this.root;
|
||||
traversal: while (true) {
|
||||
if (node.leaves != null) {
|
||||
this.nodesCache[nodes++] = node;
|
||||
}
|
||||
|
||||
if (node.branches != null) {
|
||||
for (int i = 0; i < ORDER; i++) {
|
||||
for (var i = 0; i < ORDER; i++) {
|
||||
if (this.contains(node.branches[i], rect)) {
|
||||
node = node.branches[i];
|
||||
continue traversal;
|
||||
@@ -292,7 +292,7 @@ public final class QuadTree<T extends SpatialIndex2Capable> implements SpatialIn
|
||||
|
||||
if (!this.contains(node, obj)) {
|
||||
while (nodes-- > 0) {
|
||||
final Node<T> curNode = this.nodesCache[nodes];
|
||||
final var curNode = this.nodesCache[nodes];
|
||||
if (curNode.leaves != null) {
|
||||
curNode.leaves.remove(obj);
|
||||
if (curNode.leaves.isEmpty()) {
|
||||
@@ -319,7 +319,7 @@ public final class QuadTree<T extends SpatialIndex2Capable> implements SpatialIn
|
||||
return this.findDim1(position, filter);
|
||||
}
|
||||
|
||||
final RectI2 rect = this.toRectI2Bounded(position, dimension);
|
||||
final var rect = this.toRectI2Bounded(position, dimension);
|
||||
if (rect == null) {
|
||||
return List.of();
|
||||
}
|
||||
@@ -337,7 +337,7 @@ public final class QuadTree<T extends SpatialIndex2Capable> implements SpatialIn
|
||||
this.resultHolder.get().add(obj);
|
||||
}, filter);
|
||||
|
||||
final List<T> result = this.resultHolder.get();
|
||||
final var result = this.resultHolder.get();
|
||||
if (result == null) {
|
||||
return List.of();
|
||||
}
|
||||
@@ -349,13 +349,13 @@ public final class QuadTree<T extends SpatialIndex2Capable> implements SpatialIn
|
||||
private List<T> findDimN(final RectI2 rect, final Predicate<T> filter) {
|
||||
List<T> result = null;
|
||||
|
||||
int level = 0;
|
||||
int branch = 0;
|
||||
Node<T> node = this.root;
|
||||
var level = 0;
|
||||
var branch = 0;
|
||||
var node = this.root;
|
||||
|
||||
traversal: while (true) {
|
||||
if (node.branches != null) {
|
||||
for (int b = branch; b < ORDER; b++) {
|
||||
for (var b = branch; b < ORDER; b++) {
|
||||
if (this.intersects(node.branches[b], rect)) {
|
||||
node = node.branches[b];
|
||||
this.traverseStack[level++] = b + 1;
|
||||
@@ -367,8 +367,8 @@ public final class QuadTree<T extends SpatialIndex2Capable> implements SpatialIn
|
||||
}
|
||||
|
||||
if (node.leaves != null) {
|
||||
for (int i = 0; i < node.leaves.size(); i++) {
|
||||
final T obj = node.leaves.get(i);
|
||||
for (var i = 0; i < node.leaves.size(); i++) {
|
||||
final var obj = node.leaves.get(i);
|
||||
if (this.intersects(obj, rect) && (filter == null || filter.test((T) obj))) {
|
||||
if (result == null) {
|
||||
result = new ArrayList<>(this.resultDim);
|
||||
@@ -397,16 +397,16 @@ public final class QuadTree<T extends SpatialIndex2Capable> implements SpatialIn
|
||||
@SuppressWarnings("unchecked")
|
||||
@Override
|
||||
public T findFirstAt(final CoordI2 position, final Predicate<T> filter) {
|
||||
final RectI2 rect = this.toRectI2Bounded(position, ImmutableCoordI2.one());
|
||||
final var rect = this.toRectI2Bounded(position, ImmutableCoordI2.one());
|
||||
if (rect == null) {
|
||||
return null;
|
||||
}
|
||||
|
||||
Node<T> node = this.root;
|
||||
var node = this.root;
|
||||
traversal: while (true) {
|
||||
if (node.leaves != null) {
|
||||
for (int i = 0; i < node.leaves.size(); i++) {
|
||||
final T obj = node.leaves.get(i);
|
||||
for (var i = 0; i < node.leaves.size(); i++) {
|
||||
final var obj = node.leaves.get(i);
|
||||
if (this.contains(obj, rect) && (filter == null || filter.test((T) obj))) {
|
||||
return obj;
|
||||
}
|
||||
@@ -414,7 +414,7 @@ public final class QuadTree<T extends SpatialIndex2Capable> implements SpatialIn
|
||||
}
|
||||
|
||||
if (node.branches != null) {
|
||||
for (int i = 0; i < ORDER; i++) {
|
||||
for (var i = 0; i < ORDER; i++) {
|
||||
if (this.contains(node.branches[i], rect)) {
|
||||
node = node.branches[i];
|
||||
continue traversal;
|
||||
@@ -431,16 +431,16 @@ public final class QuadTree<T extends SpatialIndex2Capable> implements SpatialIn
|
||||
@SuppressWarnings("unchecked")
|
||||
@Override
|
||||
public void executeAt(final CoordI2 position, final Consumer<T> consumer, final Predicate<T> filter) {
|
||||
final RectI2 rect = this.toRectI2Bounded(position, ImmutableCoordI2.one());
|
||||
final var rect = this.toRectI2Bounded(position, ImmutableCoordI2.one());
|
||||
if (rect == null) {
|
||||
return;
|
||||
}
|
||||
|
||||
Node<T> node = this.root;
|
||||
var node = this.root;
|
||||
traversal: while (true) {
|
||||
if (node.leaves != null) {
|
||||
for (int i = 0; i < node.leaves.size(); i++) {
|
||||
final T obj = node.leaves.get(i);
|
||||
for (var i = 0; i < node.leaves.size(); i++) {
|
||||
final var obj = node.leaves.get(i);
|
||||
if (this.contains(obj, rect) && (filter == null || filter.test((T) obj))) {
|
||||
consumer.accept(obj);
|
||||
}
|
||||
@@ -448,7 +448,7 @@ public final class QuadTree<T extends SpatialIndex2Capable> implements SpatialIn
|
||||
}
|
||||
|
||||
if (node.branches != null) {
|
||||
for (int i = 0; i < ORDER; i++) {
|
||||
for (var i = 0; i < ORDER; i++) {
|
||||
if (this.contains(node.branches[i], rect)) {
|
||||
node = node.branches[i];
|
||||
continue traversal;
|
||||
@@ -493,7 +493,7 @@ public final class QuadTree<T extends SpatialIndex2Capable> implements SpatialIn
|
||||
|
||||
if (this.node.leaves != null) {
|
||||
if (this.leaf < this.node.leaves.size()) {
|
||||
final T obj = this.node.leaves.get(this.leaf++);
|
||||
final var obj = this.node.leaves.get(this.leaf++);
|
||||
this.next = obj;
|
||||
break traversal;
|
||||
}
|
||||
@@ -533,8 +533,8 @@ public final class QuadTree<T extends SpatialIndex2Capable> implements SpatialIn
|
||||
public void forEach(final Consumer<? super T> action) {
|
||||
this.traverseAll(node -> {
|
||||
if (node.leaves != null) {
|
||||
for (int i = 0; i < node.leaves.size(); i++) {
|
||||
final T obj = node.leaves.get(i);
|
||||
for (var i = 0; i < node.leaves.size(); i++) {
|
||||
final var obj = node.leaves.get(i);
|
||||
action.accept(obj);
|
||||
}
|
||||
}
|
||||
@@ -564,9 +564,9 @@ public final class QuadTree<T extends SpatialIndex2Capable> implements SpatialIn
|
||||
return;
|
||||
}
|
||||
|
||||
int level = 0;
|
||||
int branch = 0;
|
||||
Node<T> node = this.root;
|
||||
var level = 0;
|
||||
var branch = 0;
|
||||
var node = this.root;
|
||||
|
||||
traversal: while (true) {
|
||||
if (node.branches != null && branch < ORDER) {
|
||||
@@ -644,8 +644,8 @@ public final class QuadTree<T extends SpatialIndex2Capable> implements SpatialIn
|
||||
}
|
||||
|
||||
public boolean intersects(final T obj, final RectI2 rect) {
|
||||
final int oUpperX = obj.getDimension().getX() + obj.getPosition().getX();
|
||||
final int oUpperY = obj.getDimension().getY() + obj.getPosition().getY();
|
||||
final var oUpperX = obj.getDimension().getX() + obj.getPosition().getX();
|
||||
final var oUpperY = obj.getDimension().getY() + obj.getPosition().getY();
|
||||
return ((oUpperX < obj.getPosition().getX() || oUpperX > rect.getC0().getX()) &&
|
||||
(oUpperY < obj.getPosition().getY() || oUpperY > rect.getC0().getY()) &&
|
||||
(rect.getC1().getX() + 1 < rect.getC0().getX() || rect.getC1().getX() >= obj.getPosition().getX()) &&
|
||||
@@ -692,7 +692,7 @@ public final class QuadTree<T extends SpatialIndex2Capable> implements SpatialIn
|
||||
}
|
||||
|
||||
boolean createBranches() {
|
||||
final int partition = (this.xMax - this.xMin + 1) >> 1;
|
||||
final var partition = (this.xMax - this.xMin + 1) >> 1;
|
||||
if (partition == 0) {
|
||||
return false;
|
||||
}
|
||||
@@ -708,7 +708,7 @@ public final class QuadTree<T extends SpatialIndex2Capable> implements SpatialIn
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
final var builder = new StringBuilder();
|
||||
builder.append("Node [xMin=");
|
||||
builder.append(this.xMin);
|
||||
builder.append(", xMax=");
|
||||
|
||||
@@ -44,8 +44,8 @@ public class Area2 extends Point2 implements HasPositionAndDimension2, SpatialIn
|
||||
|
||||
@Override
|
||||
public int hashCode() {
|
||||
final int prime = 31;
|
||||
int result = super.hashCode();
|
||||
final var prime = 31;
|
||||
var result = super.hashCode();
|
||||
result = prime * result + ((this.dimension == null) ? 0 : this.dimension.hashCode());
|
||||
return result;
|
||||
}
|
||||
@@ -58,7 +58,7 @@ public class Area2 extends Point2 implements HasPositionAndDimension2, SpatialIn
|
||||
if (!super.equals(obj)) {
|
||||
return false;
|
||||
}
|
||||
final Area2 other = (Area2) obj;
|
||||
final var other = (Area2) obj;
|
||||
if (this.dimension == null) {
|
||||
if (other.dimension != null) {
|
||||
return false;
|
||||
@@ -72,7 +72,7 @@ public class Area2 extends Point2 implements HasPositionAndDimension2, SpatialIn
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
final var builder = new StringBuilder();
|
||||
builder.append("Area2 [getPosition()=");
|
||||
builder.append(this.getPosition());
|
||||
builder.append(", dimension=");
|
||||
|
||||
@@ -59,7 +59,7 @@ public interface Coord2Conversion {
|
||||
vNorm = (CoordD2) this;
|
||||
}
|
||||
|
||||
final double length = WorldUtils2.getDistance(vNorm);
|
||||
final var length = WorldUtils2.getDistance(vNorm);
|
||||
if (length > 0.0) {
|
||||
vNorm = vNorm.divide(length);
|
||||
}
|
||||
|
||||
@@ -10,7 +10,7 @@ public enum Edge2 {
|
||||
LEFT(),
|
||||
TOP();
|
||||
|
||||
public final static Edge2[] VALUES_CACHED = new Edge2[] {
|
||||
public final static Edge2[] VALUES_CACHED = {
|
||||
RIGHT,
|
||||
BOTTOM,
|
||||
LEFT,
|
||||
@@ -121,7 +121,7 @@ public enum Edge2 {
|
||||
}
|
||||
|
||||
public static String toString(final int edges) {
|
||||
final StringBuilder sb = new StringBuilder();
|
||||
final var sb = new StringBuilder();
|
||||
sb.append("Edges [");
|
||||
|
||||
for (final Edge2 edge : Edge2.VALUES_CACHED) {
|
||||
@@ -135,7 +135,7 @@ public enum Edge2 {
|
||||
return sb.toString();
|
||||
}
|
||||
|
||||
private int bit;
|
||||
private final int bit;
|
||||
|
||||
Edge2() {
|
||||
this.bit = 1 << this.ordinal();
|
||||
|
||||
@@ -129,28 +129,28 @@ public final class ImmutableCoordD2 implements CoordD2 {
|
||||
|
||||
@Override
|
||||
public ImmutableCoordD2 divide(final CoordD2 delta) {
|
||||
final double dx = delta.getX() != 0.0 ? delta.getX() : 1.0;
|
||||
final double dy = delta.getY() != 0.0 ? delta.getY() : 1.0;
|
||||
final var dx = delta.getX() != 0.0 ? delta.getX() : 1.0;
|
||||
final var dy = delta.getY() != 0.0 ? delta.getY() : 1.0;
|
||||
return create(this.x / dx, this.y / dy);
|
||||
}
|
||||
|
||||
@Override
|
||||
public ImmutableCoordD2 divide(final double dx, final double dy) {
|
||||
final double dx_ = dx != 0.0 ? dx : 1.0;
|
||||
final double dy_ = dy != 0.0 ? dy : 1.0;
|
||||
final var dx_ = dx != 0.0 ? dx : 1.0;
|
||||
final var dy_ = dy != 0.0 ? dy : 1.0;
|
||||
return create(this.x / dx_, this.y / dy_);
|
||||
}
|
||||
|
||||
@Override
|
||||
public CoordD2 divide(final double n) {
|
||||
final double n_ = n != 0.0 ? n : 1.0;
|
||||
final var n_ = n != 0.0 ? n : 1.0;
|
||||
return create(this.x / n_, this.y / n_);
|
||||
}
|
||||
|
||||
@Override
|
||||
public int hashCode() {
|
||||
final int prime = 31;
|
||||
int result = 1;
|
||||
final var prime = 31;
|
||||
var result = 1;
|
||||
long temp;
|
||||
temp = Double.doubleToLongBits(this.x);
|
||||
result = prime * result + (int) (temp ^ (temp >>> 32));
|
||||
@@ -164,10 +164,9 @@ public final class ImmutableCoordD2 implements CoordD2 {
|
||||
if (this == obj) {
|
||||
return true;
|
||||
}
|
||||
if ((obj == null) || !(obj instanceof CoordD2)) {
|
||||
if ((obj == null) || !(obj instanceof final CoordD2 other)) {
|
||||
return false;
|
||||
}
|
||||
final CoordD2 other = (CoordD2) obj;
|
||||
if (Double.doubleToLongBits(this.x) != Double.doubleToLongBits(other.getX())) {
|
||||
return false;
|
||||
}
|
||||
|
||||
@@ -20,9 +20,9 @@ public final class ImmutableCoordI2 implements CoordI2 {
|
||||
private final static ImmutableCoordI2 COORD_ONE = new ImmutableCoordI2(1, 1);
|
||||
|
||||
static {
|
||||
int i = 0;
|
||||
for (int x = -COORD_CACHE_BOUND; x < COORD_CACHE_BOUND; x++) {
|
||||
for (int y = -COORD_CACHE_BOUND; y < COORD_CACHE_BOUND; y++) {
|
||||
var i = 0;
|
||||
for (var x = -COORD_CACHE_BOUND; x < COORD_CACHE_BOUND; x++) {
|
||||
for (var y = -COORD_CACHE_BOUND; y < COORD_CACHE_BOUND; y++) {
|
||||
COORD_CACHE[i++] = new ImmutableCoordI2(x, y);
|
||||
}
|
||||
}
|
||||
@@ -52,13 +52,13 @@ public final class ImmutableCoordI2 implements CoordI2 {
|
||||
|
||||
public static ImmutableCoordI2 create(final int x, final int y) {
|
||||
if (x >= -COORD_CACHE_BOUND && x < COORD_CACHE_BOUND && y >= -COORD_CACHE_BOUND && y < COORD_CACHE_BOUND) {
|
||||
final int idx = (x + COORD_CACHE_BOUND) * COORD_CACHE_DIM + (y + COORD_CACHE_BOUND);
|
||||
final var idx = (x + COORD_CACHE_BOUND) * COORD_CACHE_DIM + (y + COORD_CACHE_BOUND);
|
||||
if (idx >= 0 && idx < COORD_CACHE_SIZE) {
|
||||
return COORD_CACHE[idx];
|
||||
}
|
||||
}
|
||||
|
||||
ImmutableCoordI2 cached = LAST_CACHED;
|
||||
var cached = LAST_CACHED;
|
||||
if (cached.getX() != x || cached.getY() != y) {
|
||||
cached = new ImmutableCoordI2(x, y);
|
||||
LAST_CACHED = cached;
|
||||
@@ -160,28 +160,28 @@ public final class ImmutableCoordI2 implements CoordI2 {
|
||||
|
||||
@Override
|
||||
public ImmutableCoordI2 divide(final HasPosition2 delta) {
|
||||
final int dx = delta.getPosition().getX() != 0 ? delta.getPosition().getX() : 1;
|
||||
final int dy = delta.getPosition().getY() != 0 ? delta.getPosition().getY() : 1;
|
||||
final var dx = delta.getPosition().getX() != 0 ? delta.getPosition().getX() : 1;
|
||||
final var dy = delta.getPosition().getY() != 0 ? delta.getPosition().getY() : 1;
|
||||
return create(this.x / dx, this.y / dy);
|
||||
}
|
||||
|
||||
@Override
|
||||
public ImmutableCoordI2 divide(final int dx, final int dy) {
|
||||
final int dx_ = dx != 0 ? dx : 1;
|
||||
final int dy_ = dy != 0 ? dy : 1;
|
||||
final var dx_ = dx != 0 ? dx : 1;
|
||||
final var dy_ = dy != 0 ? dy : 1;
|
||||
return create(this.x / dx_, this.y / dy_);
|
||||
}
|
||||
|
||||
@Override
|
||||
public ImmutableCoordI2 divide(final int n) {
|
||||
final int n_ = n != 0 ? n : 1;
|
||||
final var n_ = n != 0 ? n : 1;
|
||||
return create(this.x / n_, this.y / n_);
|
||||
}
|
||||
|
||||
@Override
|
||||
public int hashCode() {
|
||||
final int prime = 31;
|
||||
int result = 1;
|
||||
final var prime = 31;
|
||||
var result = 1;
|
||||
result = prime * result + this.x;
|
||||
result = prime * result + this.y;
|
||||
return result;
|
||||
@@ -192,10 +192,9 @@ public final class ImmutableCoordI2 implements CoordI2 {
|
||||
if (this == obj) {
|
||||
return true;
|
||||
}
|
||||
if ((obj == null) || !(obj instanceof CoordI2)) {
|
||||
if ((obj == null) || !(obj instanceof final CoordI2 other)) {
|
||||
return false;
|
||||
}
|
||||
final CoordI2 other = (CoordI2) obj;
|
||||
if (this.x != other.getX()) {
|
||||
return false;
|
||||
}
|
||||
|
||||
@@ -178,8 +178,8 @@ public final class MutableCoordD2 implements CoordD2 {
|
||||
|
||||
@Override
|
||||
public int hashCode() {
|
||||
final int prime = 31;
|
||||
int result = 1;
|
||||
final var prime = 31;
|
||||
var result = 1;
|
||||
long temp;
|
||||
temp = Double.doubleToLongBits(this.x);
|
||||
result = prime * result + (int) (temp ^ (temp >>> 32));
|
||||
@@ -193,10 +193,9 @@ public final class MutableCoordD2 implements CoordD2 {
|
||||
if (this == obj) {
|
||||
return true;
|
||||
}
|
||||
if ((obj == null) || !(obj instanceof CoordD2)) {
|
||||
if ((obj == null) || !(obj instanceof final CoordD2 other)) {
|
||||
return false;
|
||||
}
|
||||
final CoordD2 other = (CoordD2) obj;
|
||||
if (Double.doubleToLongBits(this.x) != Double.doubleToLongBits(other.getX())) {
|
||||
return false;
|
||||
}
|
||||
|
||||
@@ -178,8 +178,8 @@ public final class MutableCoordI2 implements CoordI2 {
|
||||
|
||||
@Override
|
||||
public int hashCode() {
|
||||
final int prime = 31;
|
||||
int result = 1;
|
||||
final var prime = 31;
|
||||
var result = 1;
|
||||
result = prime * result + this.x;
|
||||
result = prime * result + this.y;
|
||||
return result;
|
||||
@@ -190,10 +190,9 @@ public final class MutableCoordI2 implements CoordI2 {
|
||||
if (this == obj) {
|
||||
return true;
|
||||
}
|
||||
if ((obj == null) || !(obj instanceof CoordI2)) {
|
||||
if ((obj == null) || !(obj instanceof final CoordI2 other)) {
|
||||
return false;
|
||||
}
|
||||
final CoordI2 other = (CoordI2) obj;
|
||||
if (this.x != other.getX()) {
|
||||
return false;
|
||||
}
|
||||
|
||||
@@ -26,8 +26,8 @@ public class Point2 implements HasPosition2 {
|
||||
|
||||
@Override
|
||||
public int hashCode() {
|
||||
final int prime = 31;
|
||||
int result = 1;
|
||||
final var prime = 31;
|
||||
var result = 1;
|
||||
result = prime * result + ((this.coord == null) ? 0 : this.coord.hashCode());
|
||||
return result;
|
||||
}
|
||||
@@ -40,7 +40,7 @@ public class Point2 implements HasPosition2 {
|
||||
if ((obj == null) || (this.getClass() != obj.getClass())) {
|
||||
return false;
|
||||
}
|
||||
final Point2 other = (Point2) obj;
|
||||
final var other = (Point2) obj;
|
||||
if (this.coord == null) {
|
||||
if (other.coord != null) {
|
||||
return false;
|
||||
@@ -54,7 +54,7 @@ public class Point2 implements HasPosition2 {
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
final var builder = new StringBuilder();
|
||||
builder.append("Point2 [coord=");
|
||||
builder.append(this.coord);
|
||||
builder.append("]");
|
||||
|
||||
@@ -58,8 +58,8 @@ public class RectI2 {
|
||||
|
||||
@Override
|
||||
public int hashCode() {
|
||||
final int prime = 31;
|
||||
int result = 1;
|
||||
final var prime = 31;
|
||||
var result = 1;
|
||||
result = prime * result + ((this.c0 == null) ? 0 : this.c0.hashCode());
|
||||
result = prime * result + ((this.c1 == null) ? 0 : this.c1.hashCode());
|
||||
return result;
|
||||
@@ -73,7 +73,7 @@ public class RectI2 {
|
||||
if ((obj == null) || (this.getClass() != obj.getClass())) {
|
||||
return false;
|
||||
}
|
||||
final RectI2 other = (RectI2) obj;
|
||||
final var other = (RectI2) obj;
|
||||
if (this.c0 == null) {
|
||||
if (other.c0 != null) {
|
||||
return false;
|
||||
|
||||
Reference in New Issue
Block a user