From 9f7d3c6cfc2ab732cbc4ae04b33b62e8d247a7bf Mon Sep 17 00:00:00 2001 From: asofold Date: Wed, 13 Feb 2013 21:26:26 +0100 Subject: [PATCH] Add basic ray-tracing support. --- .../nocheatplus/utilities/RayTracing.java | 160 ++++++++++++++++ .../nocheatplus/test/TestRayTracing.java | 177 ++++++++++++++++++ 2 files changed, 337 insertions(+) create mode 100644 NCPCompat/src/main/java/fr/neatmonster/nocheatplus/utilities/RayTracing.java create mode 100644 NCPCompat/src/test/java/fr/neatmonster/nocheatplus/test/TestRayTracing.java diff --git a/NCPCompat/src/main/java/fr/neatmonster/nocheatplus/utilities/RayTracing.java b/NCPCompat/src/main/java/fr/neatmonster/nocheatplus/utilities/RayTracing.java new file mode 100644 index 00000000..0976d597 --- /dev/null +++ b/NCPCompat/src/main/java/fr/neatmonster/nocheatplus/utilities/RayTracing.java @@ -0,0 +1,160 @@ +package fr.neatmonster.nocheatplus.utilities; + +import org.bukkit.Location; + +/** + * Ray tracing for block coordinates with entry point offsets. + * @author mc_dev + * + */ +public abstract class RayTracing { + +// /** End point coordinates (from, to) */ +// protected double x0, y0, z0, x1, y1, z1; + +// /** Total distance between end points. */ +// protected double d; + + /** Distance per axis. */ + protected double dX, dY, dZ; + + /** Current block. */ + protected int blockX, blockY, blockZ; + + /** Offset within current block. */ + protected double oX, oY, oZ; + + /** Current "time" in [0..1]. */ + protected double t = Double.MIN_VALUE; + + /** Tolerance for time, for checking the abort condition: 1.0 - t <= tol . */ + protected double tol = 0.0; + + public RayTracing(double x0, double y0, double z0, double x1, double y1, double z1){ + set(x0, y0, z0, x1, y1, z1); + } + + public void set(double x0, double y0, double z0, double x1, double y1, double z1){ +// // TODO: Consider not using end-points at all. +// this.x0 = x0; +// this.y0 = y0; +// this.z0 = z0; +// this.x1 = x1; +// this.y1 = y1; +// this.z1 = z1; +// // Set the "runtime" info. +// d = CheckUtils.distance(x0, y0, z0, x1, y1, z1); + dX = x1 - x0; + dY = y1 - y0; + dZ = z1 - z0; + blockX = Location.locToBlock(x0); + blockY = Location.locToBlock(y0); + blockZ = Location.locToBlock(z0); + oX = (double) (x0 - blockX); + oY = (double) (y0 - blockY); + oZ = (double) (z0 - blockZ); + t = 0.0; + } + + private static final double tDiff(final double dTotal, final double offset){ + if (dTotal > 0.0){ + return (1 - offset) / dTotal; + } + else if (dTotal < 0.0){ + return offset / -dTotal; + } + else{ + return Double.MAX_VALUE; + } + } + + /** + * Loop through blocks. + */ + public void loop(){ + // TODO: Might intercept 0 dist ? + + // Time to block edge. + double tX, tY, tZ, tMin; + while (1.0 - t > tol){ + // Determine smallest time to block edge. + tX = tDiff(dX, oX); + tY = tDiff(dY, oY); + tZ = tDiff(dZ, oZ); + tMin = Math.min(tX, Math.min(tY, tZ)); + if (tMin == Double.MAX_VALUE || t + tMin > 1.0) tMin = 1.0 - t; + // Call step with appropriate arguments. + if (!step(blockX, blockY, blockZ, oX, oY, oZ, tMin)) break; // || tMin == 0) break; + if (t + tMin >= 1.0 - tol) break; + // Advance (add to t etc.). + // x + oX += tMin * dX; + if (tX == tMin){ + if (dX < 0){ + oX = 1; + blockX --; + } + else{ + oX = 0; + blockX ++; + } + } + else if (oX >= 1){ + oX -= 1; + blockX ++; + } + else if (oX < 0){ + oX += 1; + blockX --; + } + // y + oY += tMin * dY; + if (tY == tMin){ + if (dY < 0){ + oY = 1; + blockY --; + } + else{ + oY = 0; + blockY ++; + } + } + else if (oY >= 1){ + oY -= 1; + blockY ++; + } + else if (oY < 0){ + oY += 1; + blockY --; + } + // z + oZ += tMin * dZ; + if (tZ == tMin){ + if (dZ < 0){ + oZ = 1; + blockZ --; + } + else{ + oZ = 0; + blockZ ++; + } + } + else if (oZ >= 1){ + oZ -= 1; + blockZ ++; + } + else if (oZ < 0){ + oZ += 1; + blockZ --; + } + t += tMin; + } + } + + /** + * One step in the loop. + * @return If to continue loop. + */ + protected abstract boolean step(int blockX, int blockY, int blockZ, double oX, double oY, double oZ, double dT); + +} diff --git a/NCPCompat/src/test/java/fr/neatmonster/nocheatplus/test/TestRayTracing.java b/NCPCompat/src/test/java/fr/neatmonster/nocheatplus/test/TestRayTracing.java new file mode 100644 index 00000000..21f83e8c --- /dev/null +++ b/NCPCompat/src/test/java/fr/neatmonster/nocheatplus/test/TestRayTracing.java @@ -0,0 +1,177 @@ +package fr.neatmonster.nocheatplus.test; + +import static org.junit.Assert.fail; + +import java.util.Random; + +import org.bukkit.Location; +import org.junit.Test; + +import fr.neatmonster.nocheatplus.utilities.RayTracing; +import fr.neatmonster.nocheatplus.utilities.StringUtil; + +public class TestRayTracing { + + protected static final Random random = new Random(System.nanoTime() + 13391); + + public static class CountRayTracing extends RayTracing{ + public CountRayTracing(double x0, double y0, double z0, double x1, double y1, double z1) { + super(x0, y0, z0, x1, y1, z1); + } + + protected int done = 0; + @Override + protected boolean step(int blockX, int blockY, int blockZ, double oX, + double oY, double oZ, double dT) { + done ++; + return true; + } + + public int loopCount() { + super.loop(); + return done; + } + } + + public static double[] randomCoords(double max){ + double[] res = new double[6]; + for (int i = 0; i < 6 ; i++){ + res[i] = (random.nextDouble() * 2.0 - 1.0 ) * max; + } + return res; + } + + public static void doFail(String message, double[] coords) { + System.out.println("---- Failure trace ----"); + System.out.println(message); + if (coords != null){ + System.out.println("{" + coords[0] + ", " + coords[1]+ ", " + coords[2] + " , " + coords[3] + ", " + coords[4]+ ", " + coords[5] + "}"); + dumpRawRayTracing(coords); + } + fail(message); + } + + /** + * Mostly block-coordinate consistency checking. + * @param coords + * @return + */ + public static RayTracing checkConsistency(final double[] coords){ + RayTracing rt = new RayTracing(coords[0], coords[1], coords[2], coords[3], coords[4], coords[5]) { + + protected int lbx, lby, lbz; + + protected int step = 0; + + /* (non-Javadoc) + * @see fr.neatmonster.nocheatplus.utilities.RayTracing#set(double, double, double, double, double, double) + */ + @Override + public void set(double x0, double y0, double z0, double x1, double y1, double z1) { + super.set(x0, y0, z0, x1, y1, z1); + lbx = blockX - 1; + lby = blockY - 1; + lbz = blockZ - 1; + } + + private boolean ignEdge(double offset, double dTotal){ + return offset == 1 && dTotal > 0 || offset == 0 && dTotal < 0; + } + + @Override + protected boolean step(int blockX, int blockY, int blockZ, double oX, double oY, double oZ, double dT) { + // TODO: This does not check last step for some occasions where it should. + step ++; + if (dT == 0 && 1.0 - (t + dT) > tol){ + if (!ignEdge(oX, dX) && !ignEdge(oY, dY) && !ignEdge(oZ, dZ)){ + doFail("Premature dT = 0 at t = " + StringUtil.fdec3.format(t), coords); + } + } + // TODO: check with last block coordinates + if (lbx == blockX && lby == blockY && lbz == blockZ){ + if (1.0 - (t + dT) > tol){ + doFail("Expect block coordinates to change with each step (step=" + step + ", t=" + StringUtil.fdec3.format(t) +").", coords); + } + } + // TODO: check offsets + // Set to current. + lbx = blockX; + lby = blockY; + lbz = blockZ; + + return true; + } + + @Override + public void loop() { + super.loop(); + checkBlockTarget(coords[3], blockX, oX, dX, "x"); + checkBlockTarget(coords[4], blockY, oY, dY, "y"); + checkBlockTarget(coords[5], blockZ, oZ, dZ, "z"); + } + + private void checkBlockTarget(double target, int current, double offset, double dTotal, String name){ + int b = Location.locToBlock(target); + if (current != b){ + // TODO: Might do with or without these ? +// if (current == b + 1 && dTotal > 0 && offset == 0) return; +// if (current == b - 1 && dTotal < 0 && offset == 1) return; + // Failure. + doFail("Bad target " + name + "-coordinate: " + current + " instead of " + b, coords); + } + } + + }; + rt.loop(); + return rt; + } + + public static RayTracing checkNumberOfSteps(double[] coords, int steps) { + CountRayTracing crt = new CountRayTracing(coords[0], coords[1], coords[2], coords[3], coords[4], coords[5]); + int done = crt.loopCount(); + if (done != steps) doFail("Wrong number of steps: " + done + " instead of " + steps, coords); + return crt; + } + + public static void dump(int blockX, int blockY, int blockZ, double oX, double oY, double oZ, double t, double dT) { + System.out.println(StringUtil.fdec3.format(t) + " (+" + StringUtil.fdec3.format(dT) + "): " + blockX + ", "+blockY + ", " + blockZ + " / " + StringUtil.fdec3.format(oX) + ", " + StringUtil.fdec3.format(oY)+ ", " + StringUtil.fdec3.format(oZ)); + } + + public static RayTracing dumpRawRayTracing(double[] coords) { + RayTracing rt = new RayTracing(coords[0], coords[1], coords[2], coords[3], coords[4], coords[5]) { + @Override + protected boolean step(int blockX, int blockY, int blockZ, double oX, double oY, double oZ, double dT) { + dump(blockX, blockY, blockZ, oX, oY, oZ, t, dT); + return true; + } + }; + rt.loop(); + return rt; + } + + @Test + public void testNumberOfSteps(){ + // Hand picked stuff. + checkNumberOfSteps(new double[]{0.5, 0.5, 0.5, 1.5, -0.5, 1.5}, 2); + } + + @Test + public void testConsistency(){ + // Past failures / making a difference. + for (double[] coords : new double[][]{ + // Sort by x0. + new double[]{-9.873, -4.773, -3.387, -0.161, -1.879, -7.079}, + new double[]{-3.0066423238842366, 0.8056808285866079, 5.359238045631369 , 2.0000000356757375, -2.3002237817433757, -5.889349195033338}, + new double[]{2.5619753859456917, -5.010424935746547, -7.39326637860553 , -4.678643570182639, -2.0000000105642313, -4.634727842675916}, + new double[]{7.388348424961977, -8.000000029346532, -2.5365675909347507 , 2.17126848312847, 3.236994108042559, -8.423292642985071}, + new double[]{7.525633617461991, 2.654408573114717, 3.5119744782127893 , 9.99999995904821, 9.599753890871172, 6.721727939686946}, + }){ + checkConsistency(coords); + } + // Random tests. + for (int i = 0; i < 100000; i++){ + checkConsistency(randomCoords(10.0)); + } + } + +}