diff options
Diffstat (limited to 'src')
11 files changed, 2909 insertions, 336 deletions
diff --git a/src/main/java/io/github/moulberry/notenoughupdates/commands/dev/DiagCommand.java b/src/main/java/io/github/moulberry/notenoughupdates/commands/dev/DiagCommand.java index 88264538..dab99698 100644 --- a/src/main/java/io/github/moulberry/notenoughupdates/commands/dev/DiagCommand.java +++ b/src/main/java/io/github/moulberry/notenoughupdates/commands/dev/DiagCommand.java @@ -17,8 +17,10 @@ public class DiagCommand extends ClientCommandBase { private static final String USAGE_TEXT = EnumChatFormatting.WHITE + "Usage: /neudiag <metal | wishing | debug>\n\n" + - "/neudiag metal Metal Detector Solver diagnostics\n" + - "/neudiag wishing Wishing Compass Solver diagnostics\n" + + "/neudiag metal Metal Detector Solver diagnostics\n" + + " <no sub-command> Show current solution diags\n" + + " center=<off | on> Disable / enable using center\n" + + "/neudiag wishing Wishing Compass Solver diagnostics\n" + "/neudiag debug\n" + " <no sub-command> Show current flags\n" + " <enable | disable> <flag> Enable/disable flag\n"; @@ -37,7 +39,26 @@ public class DiagCommand extends ClientCommandBase { String command = args[0].toLowerCase(); switch (command) { case "metal": - CrystalMetalDetectorSolver.logDiagnosticData(true); + if (args.length == 1) { + CrystalMetalDetectorSolver.logDiagnosticData(true); + return; + } + + String subCommand = args[1].toLowerCase(); + if (subCommand.equals("center=off")) { + CrystalMetalDetectorSolver.setDebugDoNotUseCenter(true); + sender.addChatMessage(new ChatComponentText(EnumChatFormatting.YELLOW + + "Center coordinates-based solutions disabled")); + } + else if (subCommand.equals("center=on")) { + CrystalMetalDetectorSolver.setDebugDoNotUseCenter(false); + sender.addChatMessage(new ChatComponentText(EnumChatFormatting.YELLOW + + "Center coordinates-based solutions enabled")); + } else { + showUsage(sender); + return; + } + break; case "wishing": CrystalWishingCompassSolver.getInstance().logDiagnosticData(true); diff --git a/src/main/java/io/github/moulberry/notenoughupdates/core/util/Vec3Comparable.java b/src/main/java/io/github/moulberry/notenoughupdates/core/util/Vec3Comparable.java new file mode 100644 index 00000000..cd144c21 --- /dev/null +++ b/src/main/java/io/github/moulberry/notenoughupdates/core/util/Vec3Comparable.java @@ -0,0 +1,129 @@ +package io.github.moulberry.notenoughupdates.core.util; + +import net.minecraft.util.BlockPos; +import net.minecraft.util.Vec3; +import net.minecraft.util.Vec3i; + +public class Vec3Comparable extends Vec3 implements Comparable<Vec3Comparable> { + public static final Vec3Comparable NULL_VECTOR = new Vec3Comparable(0.0, 0.0, 0.0); + + public Vec3Comparable(double x, double y, double z) { + super(x, y, z); + } + + public Vec3Comparable(Vec3i sourceVec) { + super(sourceVec); + } + + public Vec3Comparable(Vec3 source) { + super(source.xCoord, source.yCoord, source.zCoord); + } + + public Vec3Comparable(BlockPos source) { + + super(source.getX(), source.getY(), source.getZ()); + } + + public Vec3Comparable(Vec3Comparable source) { + super(source.xCoord, source.yCoord, source.zCoord); + } + + @Override + public Vec3Comparable subtractReverse(Vec3 vec) { + return new Vec3Comparable(super.subtractReverse(vec)); + } + + @Override + public Vec3Comparable normalize() { + return new Vec3Comparable(super.normalize()); + } + + @Override + public Vec3Comparable crossProduct(Vec3 vec) { + return new Vec3Comparable(super.crossProduct(vec)); + } + + @Override + public Vec3Comparable subtract(Vec3 vec) { + return new Vec3Comparable(super.subtract(vec)); + } + + @Override + public Vec3Comparable subtract(double x, double y, double z) { + return new Vec3Comparable(super.subtract(x, y, z)); + } + + @Override + public Vec3Comparable add(Vec3 other) { + return new Vec3Comparable(super.add(other)); + } + + @Override + public Vec3Comparable addVector(double x, double y, double z) { + return new Vec3Comparable(super.addVector(x, y, z)); + } + + @Override + public Vec3Comparable getIntermediateWithXValue(Vec3 vec, double x) { + return new Vec3Comparable(super.getIntermediateWithXValue(vec, x)); + } + + @Override + public Vec3Comparable getIntermediateWithYValue(Vec3 vec, double y) { + return new Vec3Comparable(super.getIntermediateWithYValue(vec, y)); + } + + @Override + public Vec3Comparable getIntermediateWithZValue(Vec3 vec, double z) { + return new Vec3Comparable(super.getIntermediateWithZValue(vec, z)); + } + + @Override + public Vec3Comparable rotatePitch(float pitch) { + return new Vec3Comparable(super.rotatePitch(pitch)); + } + + @Override + public Vec3Comparable rotateYaw(float yaw) { + return new Vec3Comparable(super.rotateYaw(yaw)); + } + + @Override + public boolean equals(Object other) { + if (this == other) { + return true; + } else if (!(other instanceof Vec3Comparable)) { + return false; + } else { + Vec3Comparable vec3c = (Vec3Comparable) other; + return this.xCoord == vec3c.xCoord && this.yCoord == vec3c.yCoord && this.zCoord == vec3c.zCoord; + } + } + + @Override + public int hashCode() { + long bits = 1L; + bits = 31L * bits + doubleToLongBits(xCoord); + bits = 31L * bits + doubleToLongBits(yCoord); + bits = 31L * bits + doubleToLongBits(zCoord); + return (int) (bits ^ (bits >> 32)); + } + + public int compareTo(Vec3Comparable other) { + return this.yCoord == other.yCoord ? + (this.zCoord == other.zCoord ? + (int)(this.xCoord - other.xCoord) + : (int)(this.zCoord - other.zCoord)) + : (int)(this.yCoord - other.yCoord); + } + + public boolean signumEquals(Vec3 other) { + return Math.signum(xCoord) == Math.signum(other.xCoord) && + Math.signum(yCoord) == Math.signum(other.yCoord) && + Math.signum(zCoord) == Math.signum(other.zCoord); + } + + private static long doubleToLongBits(double d) { + return d == 0.0 ? 0L : Double.doubleToLongBits(d); + } +} diff --git a/src/main/java/io/github/moulberry/notenoughupdates/miscfeatures/CrystalMetalDetectorSolver.java b/src/main/java/io/github/moulberry/notenoughupdates/miscfeatures/CrystalMetalDetectorSolver.java index 27c334ad..f43ebda2 100644 --- a/src/main/java/io/github/moulberry/notenoughupdates/miscfeatures/CrystalMetalDetectorSolver.java +++ b/src/main/java/io/github/moulberry/notenoughupdates/miscfeatures/CrystalMetalDetectorSolver.java @@ -1,6 +1,7 @@ package io.github.moulberry.notenoughupdates.miscfeatures; import io.github.moulberry.notenoughupdates.NotEnoughUpdates; +import io.github.moulberry.notenoughupdates.core.util.Vec3Comparable; import io.github.moulberry.notenoughupdates.core.util.render.RenderUtils; import io.github.moulberry.notenoughupdates.options.customtypes.NEUDebugFlag; import io.github.moulberry.notenoughupdates.util.NEUDebugLogger; @@ -11,7 +12,6 @@ import net.minecraft.util.BlockPos; import net.minecraft.util.ChatComponentText; import net.minecraft.util.EnumChatFormatting; import net.minecraft.util.IChatComponent; -import net.minecraft.util.Vec3; import net.minecraft.util.Vec3i; import java.util.Arrays; @@ -22,25 +22,35 @@ import java.util.List; import java.util.stream.Collectors; public class CrystalMetalDetectorSolver { + enum SolutionState { + NOT_STARTED, + MULTIPLE, + MULTIPLE_KNOWN, + FOUND, + FOUND_KNOWN, + FAILED, + INVALID, + } + private static final Minecraft mc = Minecraft.getMinecraft(); - private static BlockPos prevPlayerPos; - private static double prevDistToTreasure = 0; + private static Vec3Comparable prevPlayerPos; + private static double prevDistToTreasure; private static HashSet<BlockPos> possibleBlocks = new HashSet<>(); - private static final HashMap<BlockPos, Double> evaluatedPlayerPositions = new HashMap<>(); - private static BlockPos blockPosIfLastSolutionInvalid; - private static Boolean chestRecentlyFound = false; - private static long chestLastFoundMillis = 0; + private static final HashMap<Vec3Comparable, Double> evaluatedPlayerPositions = new HashMap<>(); + private static boolean chestRecentlyFound; + private static long chestLastFoundMillis; private static final HashSet<BlockPos> openedChestPositions = new HashSet<>(); // Keeper and Mines of Divan center location info private static Vec3i minesCenter; - private static boolean visitKeeperMessagePrinted = false; - private static String KEEPER_OF_STRING = "Keeper of "; - private static String DIAMOND_STRING = "diamond"; - private static String LAPIS_STRING = "lapis"; - private static String EMERALD_STRING = "emerald"; - private static String GOLD_STRING = "gold"; + private static boolean debugDoNotUseCenter = false; + private static boolean visitKeeperMessagePrinted; + private static final String KEEPER_OF_STRING = "Keeper of "; + private static final String DIAMOND_STRING = "diamond"; + private static final String LAPIS_STRING = "lapis"; + private static final String EMERALD_STRING = "emerald"; + private static final String GOLD_STRING = "gold"; private static final HashMap<String, Vec3i> keeperOffsets = new HashMap<String, Vec3i>() {{ put(DIAMOND_STRING, new Vec3i(33,0,3)); put(LAPIS_STRING, new Vec3i(-33,0,-3)); @@ -94,6 +104,14 @@ public class CrystalMetalDetectorSolver { -9896946827286L // x=-37, y=-21, z=-22 )); + static Predicate<BlockPos> treasureAllowedPredicate = CrystalMetalDetectorSolver::treasureAllowed; + static SolutionState currentState = SolutionState.NOT_STARTED; + static SolutionState previousState = SolutionState.NOT_STARTED; + + public interface Predicate<BlockPos> { + boolean check(BlockPos blockPos); + } + public static void process(IChatComponent message) { if (SBInfo.getInstance().getLocation() == null || !NotEnoughUpdates.INSTANCE.config.mining.metalDetectorEnabled || @@ -102,7 +120,7 @@ public class CrystalMetalDetectorSolver { return; } - locateMinesCenterIfNeeded(); + boolean centerNewlyDiscovered = locateMinesCenterIfNeeded(); double distToTreasure = Double.parseDouble(message .getUnformattedText() @@ -122,20 +140,64 @@ public class CrystalMetalDetectorSolver { chestRecentlyFound = false; } - if (prevDistToTreasure == distToTreasure && - prevPlayerPos.equals(mc.thePlayer.getPosition()) && - !evaluatedPlayerPositions.keySet().contains(mc.thePlayer.getPosition())) { + SolutionState originalState = currentState; + int originalCount = possibleBlocks.size(); + Vec3Comparable adjustedPlayerPos = getPlayerPosAdjustedForEyeHeight(); + findPossibleSolutions(distToTreasure, adjustedPlayerPos, centerNewlyDiscovered); + if (currentState != originalState || originalCount != possibleBlocks.size()) { + switch (currentState) { + case FOUND_KNOWN: + NEUDebugLogger.log(NEUDebugFlag.METAL, "Known location identified."); + // falls through + case FOUND: + mc.thePlayer.addChatMessage(new ChatComponentText(EnumChatFormatting.YELLOW + "[NEU] Found solution.")); + if (NotEnoughUpdates.INSTANCE.config.hidden.debugFlags.contains(NEUDebugFlag.METAL) && + (previousState == SolutionState.INVALID || previousState == SolutionState.FAILED)) { + NEUDebugLogger.log(NEUDebugFlag.METAL, + EnumChatFormatting.AQUA + "Solution coordinates: " + + EnumChatFormatting.WHITE + possibleBlocks.iterator().next().toString()); + } + break; + case INVALID: + mc.thePlayer.addChatMessage(new ChatComponentText( + EnumChatFormatting.RED + "[NEU] Previous solution is invalid.")); + logDiagnosticData(false); + resetSolution(false); + break; + case FAILED: + mc.thePlayer.addChatMessage(new ChatComponentText( + EnumChatFormatting.RED + "[NEU] Failed to find a solution.")); + logDiagnosticData(false); + resetSolution(false); + break; + case MULTIPLE_KNOWN: + NEUDebugLogger.log(NEUDebugFlag.METAL, "Multiple known locations identified:"); + // falls through + case MULTIPLE: + mc.thePlayer.addChatMessage(new ChatComponentText(EnumChatFormatting.YELLOW + + "[NEU] Need another position to find solution. Possible blocks: " + possibleBlocks.size())); + break; + default: + throw new IllegalStateException("Metal detector is in invalid state"); + } + } + } + + static void findPossibleSolutions(double distToTreasure, Vec3Comparable playerPos, boolean centerNewlyDiscovered) { + if (prevDistToTreasure == distToTreasure && prevPlayerPos.equals(playerPos) && + !evaluatedPlayerPositions.containsKey(playerPos)) { + evaluatedPlayerPositions.put(playerPos, distToTreasure); if (possibleBlocks.size() == 0) { - evaluatedPlayerPositions.put(mc.thePlayer.getPosition(), distToTreasure); for (int zOffset = (int) Math.floor(-distToTreasure); zOffset <= Math.ceil(distToTreasure); zOffset++) { for (int y = 65; y <= 75; y++) { double calculatedDist = 0; int xOffset = 0; while (calculatedDist < distToTreasure) { - BlockPos pos = new BlockPos(Math.floor(mc.thePlayer.posX) + xOffset, - y, Math.floor(mc.thePlayer.posZ) + zOffset); - calculatedDist = getPlayerPos().distanceTo(new Vec3(pos).addVector(0D, 1D, 0D)); - if (round(calculatedDist, 1) == distToTreasure && treasureAllowed(pos)) { + BlockPos pos = new BlockPos(Math.floor(playerPos.xCoord) + xOffset, + y, Math.floor(playerPos.zCoord) + zOffset + ); + calculatedDist = playerPos.distanceTo(new Vec3Comparable(pos).addVector(0D, 1D, 0D)); + if (round(calculatedDist, 1) == distToTreasure && treasureAllowedPredicate.check(pos)) { possibleBlocks.add(pos); } xOffset++; @@ -143,10 +205,11 @@ public class CrystalMetalDetectorSolver { xOffset = 0; calculatedDist = 0; while (calculatedDist < distToTreasure) { - BlockPos pos = new BlockPos(Math.floor(mc.thePlayer.posX) - xOffset, - y, Math.floor(mc.thePlayer.posZ) + zOffset); - calculatedDist = getPlayerPos().distanceTo(new Vec3(pos).addVector(0D, 1D, 0D)); - if (round(calculatedDist, 1) == distToTreasure && treasureAllowed(pos)) { + BlockPos pos = new BlockPos(Math.floor(playerPos.xCoord) - xOffset, + y, Math.floor(playerPos.zCoord) + zOffset + ); + calculatedDist = playerPos.distanceTo(new Vec3Comparable(pos).addVector(0D, 1D, 0D)); + if (round(calculatedDist, 1) == distToTreasure && treasureAllowedPredicate.check(pos)) { possibleBlocks.add(pos); } xOffset++; @@ -154,48 +217,33 @@ public class CrystalMetalDetectorSolver { } } - checkAndDisplaySolutionState(); + updateSolutionState(); } else if (possibleBlocks.size() != 1) { - evaluatedPlayerPositions.put(mc.thePlayer.getPosition().getImmutable(), distToTreasure); HashSet<BlockPos> temp = new HashSet<>(); for (BlockPos pos : possibleBlocks) { - if (round(getPlayerPos().distanceTo(new Vec3(pos).addVector(0D, 1D, 0D)), 1) == distToTreasure) { + if (round(playerPos.distanceTo(new Vec3Comparable(pos).addVector(0D, 1D, 0D)), 1) == distToTreasure) { temp.add(pos); } } possibleBlocks = temp; - checkAndDisplaySolutionState(); + updateSolutionState(); } else { BlockPos pos = possibleBlocks.iterator().next(); - if (Math.abs(distToTreasure - (getPlayerPos().distanceTo(new Vec3(pos)))) > 5) { - mc.thePlayer.addChatMessage(new ChatComponentText( - EnumChatFormatting.RED + "[NEU] Previous solution is invalid.")); - blockPosIfLastSolutionInvalid = pos.getImmutable(); - logDiagnosticData(false); - resetSolution(false); + if (Math.abs(distToTreasure - (playerPos.distanceTo(new Vec3Comparable(pos)))) > 5) { + currentState = SolutionState.INVALID; } } + } else if (centerNewlyDiscovered && possibleBlocks.size() > 1) { + updateSolutionState(); } - prevPlayerPos = mc.thePlayer.getPosition().getImmutable(); + prevPlayerPos = playerPos; prevDistToTreasure = distToTreasure; } - private static void checkForSingleKnownLocationMatch() { - if (minesCenter == BlockPos.NULL_VECTOR || possibleBlocks.size() < 2) { - return; - } - - HashSet<BlockPos> temp = possibleBlocks.stream() - .filter(block -> knownChestOffsets.contains(block.subtract(minesCenter).toLong())) - .collect(Collectors.toCollection(HashSet::new)); - if (temp.size() == 1) { - possibleBlocks = temp; - NEUDebugLogger.log(NEUDebugFlag.METAL, "Known location identified."); - } else if (temp.size() > 1) { - NEUDebugLogger.log(NEUDebugFlag.METAL, temp.size() + " known locations identified:"); - } + public static void setDebugDoNotUseCenter(boolean val) { + debugDoNotUseCenter = val; } private static String getFriendlyBlockPositions(Collection<BlockPos> positions) { @@ -206,10 +254,13 @@ public class CrystalMetalDetectorSolver { StringBuilder sb = new StringBuilder(); sb.append("\n"); for (BlockPos blockPos : positions) { - sb.append("Absolute: " + blockPos.toString()); + sb.append("Absolute: "); + sb.append(blockPos.toString()); if (minesCenter != Vec3i.NULL_VECTOR) { BlockPos relativeOffset = blockPos.subtract(minesCenter); - sb.append(", Relative: " + relativeOffset.toString() + " (" + relativeOffset.toLong() + ")"); + sb.append(", Relative: "); + sb.append(relativeOffset.toString() ); + sb.append(" (" + relativeOffset.toLong() + ")"); } sb.append("\n"); } @@ -217,22 +268,23 @@ public class CrystalMetalDetectorSolver { return sb.toString(); } - private static String getFriendlyEvaluatedPositions(HashMap<BlockPos, Double> positions) { - if (!NEUDebugLogger.isFlagEnabled(NEUDebugFlag.METAL) || positions.size() == 0) { + private static String getFriendlyEvaluatedPositions() { + if (!NEUDebugLogger.isFlagEnabled(NEUDebugFlag.METAL) || evaluatedPlayerPositions.size() == 0) { return ""; } StringBuilder sb = new StringBuilder(); sb.append("\n"); - for (BlockPos blockPos : positions.keySet()) { - sb.append("Absolute: " + blockPos.toString()); + for (Vec3Comparable vec : evaluatedPlayerPositions.keySet()) { + sb.append("Absolute: " + vec.toString()); if (minesCenter != Vec3i.NULL_VECTOR) { - BlockPos relativeOffset = blockPos.subtract(minesCenter); + BlockPos positionBlockPos = new BlockPos(vec); + BlockPos relativeOffset = positionBlockPos.subtract(minesCenter); sb.append(", Relative: " + relativeOffset.toString() + " (" + relativeOffset.toLong() + ")"); } sb.append(" Distance: "); - sb.append(positions.get(blockPos)); + sb.append(evaluatedPlayerPositions.get(vec)); sb.append("\n"); } @@ -240,101 +292,8 @@ public class CrystalMetalDetectorSolver { return sb.toString(); } - public static void logDiagnosticData(boolean outputAlways) { - if (SBInfo.getInstance().getLocation() == null) { - mc.thePlayer.addChatMessage(new ChatComponentText(EnumChatFormatting.RED + - "[NEU] This command is not available outside SkyBlock")); - return; - } - - if (!NotEnoughUpdates.INSTANCE.config.mining.metalDetectorEnabled) - { - mc.thePlayer.addChatMessage(new ChatComponentText(EnumChatFormatting.RED + - "[NEU] Metal Detector Solver is not enabled.")); - return; - } - - if (!outputAlways && !NotEnoughUpdates.INSTANCE.config.hidden.debugFlags.contains(NEUDebugFlag.METAL)) { - return; - } - - boolean originalDebugFlag = !NotEnoughUpdates.INSTANCE.config.hidden.debugFlags.add(NEUDebugFlag.METAL); - - StringBuilder diagsMessage = new StringBuilder(); - - diagsMessage.append(EnumChatFormatting.AQUA); - diagsMessage.append("Mines Center: "); - diagsMessage.append(EnumChatFormatting.WHITE); - diagsMessage.append((minesCenter == Vec3i.NULL_VECTOR) ? "<NOT DISCOVERED>" : minesCenter.toString()); - diagsMessage.append("\n"); - - diagsMessage.append("\n"); - diagsMessage.append(EnumChatFormatting.AQUA); - diagsMessage.append("Previous Player Position: "); - diagsMessage.append(EnumChatFormatting.WHITE); - diagsMessage.append((prevPlayerPos == null) ? "<NONE>" : prevPlayerPos.toString()); - diagsMessage.append("\n"); - - diagsMessage.append(EnumChatFormatting.AQUA); - diagsMessage.append("Previous Distance To Treasure: "); - diagsMessage.append(EnumChatFormatting.WHITE); - diagsMessage.append((prevDistToTreasure == 0) ? "<NONE>" : prevDistToTreasure); - diagsMessage.append("\n"); - - diagsMessage.append(EnumChatFormatting.AQUA); - diagsMessage.append("Last Solution Invalid Position: "); - diagsMessage.append(EnumChatFormatting.WHITE); - diagsMessage.append((blockPosIfLastSolutionInvalid == null) ? "<NONE>" : blockPosIfLastSolutionInvalid.toString()); - diagsMessage.append("\n"); - - diagsMessage.append(EnumChatFormatting.AQUA); - diagsMessage.append("Current Possible Blocks: "); - diagsMessage.append(EnumChatFormatting.WHITE); - diagsMessage.append(possibleBlocks.size()); - diagsMessage.append(getFriendlyBlockPositions(possibleBlocks)); - diagsMessage.append("\n"); - - diagsMessage.append(EnumChatFormatting.AQUA); - diagsMessage.append("Evaluated player positions: "); - diagsMessage.append(EnumChatFormatting.WHITE); - diagsMessage.append(evaluatedPlayerPositions.size()); - diagsMessage.append(getFriendlyEvaluatedPositions(evaluatedPlayerPositions)); - diagsMessage.append("\n"); - - diagsMessage.append(EnumChatFormatting.AQUA); - diagsMessage.append("Chest locations not on known list:\n"); - diagsMessage.append(EnumChatFormatting.WHITE); - if (minesCenter != Vec3i.NULL_VECTOR) { - HashSet<BlockPos> locationsNotOnKnownList = openedChestPositions - .stream() - .filter(block -> !knownChestOffsets.contains(block.subtract(minesCenter).toLong())) - .map(block -> block.subtract(minesCenter)) - .collect(Collectors.toCollection(HashSet::new)); - if (locationsNotOnKnownList.size() > 0) { - for (BlockPos blockPos : locationsNotOnKnownList) { - diagsMessage.append(String.format( - "%dL,\t\t// x=%d, y=%d, z=%d", - blockPos.toLong(), - blockPos.getX(), - blockPos.getY(), - blockPos.getZ() - )); - } - } - } else { - diagsMessage.append("<REQUIRES MINES CENTER>"); - } - - NEUDebugLogger.log(NEUDebugFlag.METAL, diagsMessage.toString()); - - if (!originalDebugFlag) { - NotEnoughUpdates.INSTANCE.config.hidden.debugFlags.remove(NEUDebugFlag.METAL); - } - } - public static void resetSolution(Boolean chestFound) { if (chestFound) { - blockPosIfLastSolutionInvalid = null; prevPlayerPos = null; prevDistToTreasure = 0; if (possibleBlocks.size() == 1) { @@ -345,15 +304,18 @@ public class CrystalMetalDetectorSolver { chestRecentlyFound = chestFound; possibleBlocks.clear(); evaluatedPlayerPositions.clear(); + previousState = currentState; + currentState = SolutionState.NOT_STARTED; } public static void initWorld() { minesCenter = Vec3i.NULL_VECTOR; visitKeeperMessagePrinted = false; - blockPosIfLastSolutionInvalid = null; openedChestPositions.clear(); + chestLastFoundMillis = 0; prevDistToTreasure = 0; prevPlayerPos = null; + currentState = SolutionState.NOT_STARTED; resetSolution(false); } @@ -377,15 +339,14 @@ public class CrystalMetalDetectorSolver { } } - private static void locateMinesCenterIfNeeded() { + private static boolean locateMinesCenterIfNeeded() { if (minesCenter != Vec3i.NULL_VECTOR) { - return; + return false; } List<EntityArmorStand> keeperEntities = mc.theWorld.getEntities(EntityArmorStand.class, (entity) -> { if (!entity.hasCustomName()) return false; - if (entity.getCustomNameTag().contains(KEEPER_OF_STRING)) return true; - return false; + return entity.getCustomNameTag().contains(KEEPER_OF_STRING); }); if (keeperEntities.size() == 0) { @@ -394,7 +355,7 @@ public class CrystalMetalDetectorSolver { "[NEU] Approach a Keeper while holding the metal detector to enable faster treasure hunting.")); visitKeeperMessagePrinted = true; } - return; + return false; } EntityArmorStand keeperEntity = keeperEntities.get(0); @@ -407,6 +368,11 @@ public class CrystalMetalDetectorSolver { EnumChatFormatting.WHITE + minesCenter.toString()); mc.thePlayer.addChatMessage(new ChatComponentText( EnumChatFormatting.YELLOW + "[NEU] Faster treasure hunting is now enabled based on Keeper location.")); + return true; + } + + public static void setMinesCenter(BlockPos center) { + minesCenter = center; } private static double round(double value, int precision) { @@ -414,42 +380,174 @@ public class CrystalMetalDetectorSolver { return (double) Math.round(value * scale) / scale; } - private static void checkAndDisplaySolutionState() { + private static void updateSolutionState() { + previousState = currentState; + if (possibleBlocks.size() == 0) { - mc.thePlayer.addChatMessage(new ChatComponentText(EnumChatFormatting.RED + "[NEU] Failed to find a solution.")); - logDiagnosticData(false); - resetSolution(false); + currentState = SolutionState.FAILED; return; } - checkForSingleKnownLocationMatch(); - if (possibleBlocks.size() > 1) { - mc.thePlayer.addChatMessage(new ChatComponentText(EnumChatFormatting.YELLOW + - "[NEU] Need another position to find solution. Possible blocks: " + possibleBlocks.size())); - } else { - mc.thePlayer.addChatMessage(new ChatComponentText(EnumChatFormatting.YELLOW + "[NEU] Found solution.")); + if (possibleBlocks.size() == 1) { + currentState = SolutionState.FOUND; + return; } + + // Narrow solutions using known locations if the mines center is known + if (minesCenter.equals(BlockPos.NULL_VECTOR) || debugDoNotUseCenter) { + currentState = SolutionState.MULTIPLE; + return; + } + + HashSet<BlockPos> temp = + possibleBlocks.stream() + .filter(block -> knownChestOffsets.contains(block.subtract(minesCenter).toLong())) + .collect(Collectors.toCollection(HashSet::new)); + if (temp.size() == 0) { + currentState = SolutionState.MULTIPLE; + return; + } + + if (temp.size() == 1) { + possibleBlocks = temp; + currentState = SolutionState.FOUND_KNOWN; + return; + + } + + currentState = SolutionState.MULTIPLE_KNOWN; + } + + public static BlockPos getSolution() { + if (CrystalMetalDetectorSolver.possibleBlocks.size() != 1) { + return BlockPos.ORIGIN; + } + + return CrystalMetalDetectorSolver.possibleBlocks.stream().iterator().next(); } - private static Vec3 getPlayerPos() { - return new Vec3( + private static Vec3Comparable getPlayerPosAdjustedForEyeHeight() { + return new Vec3Comparable( mc.thePlayer.posX, mc.thePlayer.posY + (mc.thePlayer.getEyeHeight() - mc.thePlayer.getDefaultEyeHeight()), mc.thePlayer.posZ ); } - private static boolean treasureAllowed(BlockPos pos) { - boolean airAbove = mc.theWorld. - getBlockState(pos.add(0, 1, 0)).getBlock().getRegistryName().equals("minecraft:air"); - boolean allowedBlockType = mc.theWorld.getBlockState(pos).getBlock().getRegistryName().equals("minecraft:gold_block") || + static boolean isKnownOffset(BlockPos pos) { + return knownChestOffsets.contains(pos.subtract(minesCenter).toLong()); + } + + static boolean isAllowedBlockType(BlockPos pos) { + return mc.theWorld.getBlockState(pos).getBlock().getRegistryName().equals("minecraft:gold_block") || mc.theWorld.getBlockState(pos).getBlock().getRegistryName().equals("minecraft:prismarine") || mc.theWorld.getBlockState(pos).getBlock().getRegistryName().equals("minecraft:chest") || mc.theWorld.getBlockState(pos).getBlock().getRegistryName().equals("minecraft:stained_glass") || mc.theWorld.getBlockState(pos).getBlock().getRegistryName().equals("minecraft:stained_glass_pane") || mc.theWorld.getBlockState(pos).getBlock().getRegistryName().equals("minecraft:wool") || mc.theWorld.getBlockState(pos).getBlock().getRegistryName().equals("minecraft:stained_hardened_clay"); - boolean knownOffset = knownChestOffsets.contains(pos.subtract(minesCenter).toLong()); - return airAbove & (knownOffset | allowedBlockType); + } + + static boolean isAirAbove(BlockPos pos) { + return mc.theWorld. + getBlockState(pos.add(0, 1, 0)).getBlock().getRegistryName().equals("minecraft:air"); + } + + private static boolean treasureAllowed(BlockPos pos) { + boolean airAbove = isAirAbove(pos); + boolean allowedBlockType = isAllowedBlockType(pos); + return isKnownOffset(pos) || (airAbove && allowedBlockType); + } + + static private String getDiagnosticMessage() { + StringBuilder diagsMessage = new StringBuilder(); + + diagsMessage.append(EnumChatFormatting.AQUA); + diagsMessage.append("Mines Center: "); + diagsMessage.append(EnumChatFormatting.WHITE); + diagsMessage.append((minesCenter.equals(Vec3i.NULL_VECTOR)) ? "<NOT DISCOVERED>" : minesCenter.toString()); + diagsMessage.append("\n"); + + diagsMessage.append(EnumChatFormatting.AQUA); + diagsMessage.append("Current Solution State: "); + diagsMessage.append(EnumChatFormatting.WHITE); + diagsMessage.append(currentState.name()); + diagsMessage.append("\n"); + + diagsMessage.append(EnumChatFormatting.AQUA); + diagsMessage.append("Previous Solution State: "); + diagsMessage.append(EnumChatFormatting.WHITE); + diagsMessage.append(previousState.name()); + diagsMessage.append("\n"); + + diagsMessage.append(EnumChatFormatting.AQUA); + diagsMessage.append("Previous Player Position: "); + diagsMessage.append(EnumChatFormatting.WHITE); + diagsMessage.append((prevPlayerPos == null) ? "<NONE>" : prevPlayerPos.toString()); + diagsMessage.append("\n"); + + diagsMessage.append(EnumChatFormatting.AQUA); + diagsMessage.append("Previous Distance To Treasure: "); + diagsMessage.append(EnumChatFormatting.WHITE); + diagsMessage.append((prevDistToTreasure == 0) ? "<NONE>" : prevDistToTreasure); + diagsMessage.append("\n"); + + diagsMessage.append(EnumChatFormatting.AQUA); + diagsMessage.append("Current Possible Blocks: "); + diagsMessage.append(EnumChatFormatting.WHITE); + diagsMessage.append(possibleBlocks.size()); + diagsMessage.append(getFriendlyBlockPositions(possibleBlocks)); + diagsMessage.append("\n"); + + diagsMessage.append(EnumChatFormatting.AQUA); + diagsMessage.append("Evaluated player positions: "); + diagsMessage.append(EnumChatFormatting.WHITE); + diagsMessage.append(evaluatedPlayerPositions.size()); + diagsMessage.append(getFriendlyEvaluatedPositions()); + diagsMessage.append("\n"); + + diagsMessage.append(EnumChatFormatting.AQUA); + diagsMessage.append("Chest locations not on known list:\n"); + diagsMessage.append(EnumChatFormatting.WHITE); + if (minesCenter != Vec3i.NULL_VECTOR) { + HashSet<BlockPos> locationsNotOnKnownList = openedChestPositions + .stream() + .filter(block -> !knownChestOffsets.contains(block.subtract(minesCenter).toLong())) + .map(block -> block.subtract(minesCenter)) + .collect(Collectors.toCollection(HashSet::new)); + if (locationsNotOnKnownList.size() > 0) { + for (BlockPos blockPos : locationsNotOnKnownList) { + diagsMessage.append(String.format( + "%dL,\t\t// x=%d, y=%d, z=%d", + blockPos.toLong(), + blockPos.getX(), + blockPos.getY(), + blockPos.getZ() + )); + } + } + } else { + diagsMessage.append("<REQUIRES MINES CENTER>"); + } + + return diagsMessage.toString(); + } + + public static void logDiagnosticData(boolean outputAlways) { + if (!SBInfo.getInstance().checkForSkyblockLocation()) { + return; + } + + if (!NotEnoughUpdates.INSTANCE.config.mining.metalDetectorEnabled) + { + mc.thePlayer.addChatMessage(new ChatComponentText(EnumChatFormatting.RED + + "[NEU] Metal Detector Solver is not enabled.")); + return; + } + + boolean metalDebugFlagSet = NotEnoughUpdates.INSTANCE.config.hidden.debugFlags.contains(NEUDebugFlag.METAL); + if (outputAlways || metalDebugFlagSet) { + NEUDebugLogger.logAlways(getDiagnosticMessage()); + } } } diff --git a/src/main/java/io/github/moulberry/notenoughupdates/miscfeatures/CrystalWishingCompassSolver.java b/src/main/java/io/github/moulberry/notenoughupdates/miscfeatures/CrystalWishingCompassSolver.java index 25f39c3a..9a950e7f 100644 --- a/src/main/java/io/github/moulberry/notenoughupdates/miscfeatures/CrystalWishingCompassSolver.java +++ b/src/main/java/io/github/moulberry/notenoughupdates/miscfeatures/CrystalWishingCompassSolver.java @@ -2,27 +2,67 @@ package io.github.moulberry.notenoughupdates.miscfeatures; import io.github.moulberry.notenoughupdates.NotEnoughUpdates; import io.github.moulberry.notenoughupdates.core.util.Line; +import io.github.moulberry.notenoughupdates.core.util.Vec3Comparable; +import io.github.moulberry.notenoughupdates.options.NEUConfig; import io.github.moulberry.notenoughupdates.options.customtypes.NEUDebugFlag; import io.github.moulberry.notenoughupdates.util.NEUDebugLogger; import io.github.moulberry.notenoughupdates.util.SBInfo; +import io.github.moulberry.notenoughupdates.util.Utils; import net.minecraft.client.Minecraft; import net.minecraft.event.ClickEvent; -import net.minecraft.event.HoverEvent; import net.minecraft.init.Items; import net.minecraft.item.ItemStack; import net.minecraft.util.AxisAlignedBB; import net.minecraft.util.BlockPos; import net.minecraft.util.ChatComponentText; -import net.minecraft.util.ChatStyle; import net.minecraft.util.EnumChatFormatting; import net.minecraft.util.EnumParticleTypes; -import net.minecraft.util.Vec3; +import net.minecraft.util.Vec3i; +import net.minecraftforge.client.ClientCommandHandler; import net.minecraftforge.event.entity.player.PlayerInteractEvent; import net.minecraftforge.event.world.WorldEvent; import net.minecraftforge.fml.common.Loader; import net.minecraftforge.fml.common.eventhandler.SubscribeEvent; +import java.util.ArrayList; +import java.util.EnumSet; +import java.util.HashMap; +import java.util.function.BooleanSupplier; +import java.util.function.LongSupplier; + public class CrystalWishingCompassSolver { + enum SolverState { + NOT_STARTED, + PROCESSING_FIRST_USE, + NEED_SECOND_COMPASS, + PROCESSING_SECOND_USE, + SOLVED, + FAILED_EXCEPTION, + FAILED_TIMEOUT_NO_REPEATING, + FAILED_TIMEOUT_NO_PARTICLES, + FAILED_INTERSECTION_CALCULATION, + FAILED_INVALID_SOLUTION, + } + + enum CompassTarget { + GOBLIN_QUEEN, + GOBLIN_KING, + BAL, + JUNGLE_TEMPLE, + ODAWA, + PRECURSOR_CITY, + MINES_OF_DIVAN, + CRYSTAL_NUCLEUS, + } + + enum Crystal { + AMBER, + AMETHYST, + JADE, + SAPPHIRE, + TOPAZ, + } + private static final CrystalWishingCompassSolver INSTANCE = new CrystalWishingCompassSolver(); public static CrystalWishingCompassSolver getInstance() { return INSTANCE; @@ -31,40 +71,72 @@ public class CrystalWishingCompassSolver { private static final Minecraft mc = Minecraft.getMinecraft(); private static boolean isSkytilsPresent = false; - // Crystal Nucleus unbreakable blocks, area coordinates reported by Hypixel server are slightly different - private static final AxisAlignedBB NUCLEUS_BB = new AxisAlignedBB(463, 63, 460, 563, 181, 564); - private static final double MAX_COMPASS_PARTICLE_SPREAD = 16; - - private static BlockPos prevPlayerPos; - private long compassUsedMillis = 0; - private Vec3 firstParticle = null; - private Vec3 lastParticle = null; - private double lastParticleDistanceFromFirst = 0; - private Line firstCompassLine = null; - private Line secondCompassLine = null; - private Vec3 solution = null; - private Line solutionIntersectionLine = null; - - private void resetForNewCompass() { - compassUsedMillis = 0; - firstParticle = null; - lastParticle = null; - lastParticleDistanceFromFirst = 0; + // NOTE: There is a small set of breakable blocks above the nucleus at Y > 181. While this zone is reported + // as the Crystal Nucleus by Hypixel, for wishing compass purposes it is in the appropriate quadrant. + private static final AxisAlignedBB NUCLEUS_BB = new AxisAlignedBB(462, 63, 461, 564, 181, 565); + private static final AxisAlignedBB HOLLOWS_BB = new AxisAlignedBB(201, 30, 201, 824, 189, 824); + private static final AxisAlignedBB PRECURSOR_REMNANTS_BB = new AxisAlignedBB(513, 64, 513, 824, 189, 824); + private static final AxisAlignedBB MITHRIL_DEPOSITS_BB = new AxisAlignedBB(513, 64, 201, 824, 189, 512); + private static final AxisAlignedBB GOBLIN_HOLDOUT_BB = new AxisAlignedBB(201, 64, 513, 512, 189, 824); + private static final AxisAlignedBB JUNGLE_BB = new AxisAlignedBB(201, 64, 201, 512, 189, 512); + private static final AxisAlignedBB MAGMA_FIELDS_BB = new AxisAlignedBB(201, 30, 201, 824, 63, 824); + private static final double MAX_DISTANCE_BETWEEN_PARTICLES = 0.6; + private static final double MAX_DISTANCE_FROM_USE_TO_FIRST_PARTICLE = 9.0; + + // 64.0 is an arbitrary value but seems to work well + private static final double MINIMUM_DISTANCE_SQ_BETWEEN_COMPASSES = 64.0; + + // All particles typically arrive in < 3500, so 5000 should be enough buffer + public static final long ALL_PARTICLES_MAX_MILLIS = 5000L; + + public LongSupplier currentTimeMillis = System::currentTimeMillis; + public BooleanSupplier kingsScentPresent = this::isKingsScentPresent; + public BooleanSupplier keyInInventory = this::isKeyInInventory; + public interface CrystalEnumSetSupplier { + EnumSet<Crystal> getAsCrystalEnumSet(); + } + public CrystalEnumSetSupplier foundCrystals = this::getFoundCrystals; + + private SolverState solverState; + private Compass firstCompass; + private Compass secondCompass; + private Line solutionIntersectionLine; + private EnumSet<CompassTarget> possibleTargets; + private Vec3Comparable solution; + private Vec3Comparable originalSolution; + private EnumSet<CompassTarget> solutionPossibleTargets; + + public SolverState getSolverState() { + return solverState; + } + + public Vec3i getSolutionCoords() { + return new Vec3i(solution.xCoord, solution.yCoord, solution.zCoord); + } + + public EnumSet<CompassTarget> getPossibleTargets() { + return possibleTargets; } private void resetForNewTarget() { NEUDebugLogger.log(NEUDebugFlag.WISHING,"Resetting for new target"); - resetForNewCompass(); - firstCompassLine = null; - secondCompassLine = null; + solverState = SolverState.NOT_STARTED; + firstCompass = null; + secondCompass = null; solutionIntersectionLine = null; - prevPlayerPos = null; + possibleTargets = null; solution = null; + originalSolution = null; + solutionPossibleTargets = null; + } + + public void initWorld() { + resetForNewTarget(); } @SubscribeEvent public void onWorldLoad(WorldEvent.Unload event) { - resetForNewTarget(); + initWorld(); isSkytilsPresent = Loader.isModLoaded("skytils"); } @@ -90,28 +162,101 @@ public class CrystalWishingCompassSolver { return; } - try { - if (isSolved()) { - resetForNewTarget(); - } + BlockPos playerPos = mc.thePlayer.getPosition().getImmutable(); - // 64.0 is an arbitrary value but seems to work well - if (prevPlayerPos != null && prevPlayerPos.distanceSq(mc.thePlayer.getPosition()) < 64.0) { - mc.thePlayer.addChatMessage(new ChatComponentText(EnumChatFormatting.YELLOW + - "[NEU] Move a little further before using the wishing compass again.")); - event.setCanceled(true); - return; + try { + HandleCompassResult result = handleCompassUse(playerPos); + switch (result) { + case SUCCESS: + return; + case STILL_PROCESSING_PRIOR_USE: + mc.thePlayer.addChatMessage(new ChatComponentText(EnumChatFormatting.YELLOW + + "[NEU] Wait a little longer before using the wishing compass again.")); + event.setCanceled(true); + break; + case LOCATION_TOO_CLOSE: + mc.thePlayer.addChatMessage(new ChatComponentText(EnumChatFormatting.YELLOW + + "[NEU] Move a little further before using the wishing compass again.")); + event.setCanceled(true); + break; + case POSSIBLE_TARGETS_CHANGED: + mc.thePlayer.addChatMessage(new ChatComponentText(EnumChatFormatting.YELLOW + + "[NEU] Possible wishing compass targets have changed. Solver has been reset.")); + event.setCanceled(true); + break; + case NO_PARTICLES_FOR_PREVIOUS_COMPASS: + mc.thePlayer.addChatMessage(new ChatComponentText(EnumChatFormatting.YELLOW + + "[NEU] No particles detected for prior compass use. Need another position to solve.")); + break; + case PLAYER_IN_NUCLEUS: + mc.thePlayer.addChatMessage(new ChatComponentText(EnumChatFormatting.YELLOW + + "[NEU] Wishing compass must be used outside the nucleus for accurate results.")); + event.setCanceled(true); + break; + default: + throw new IllegalStateException("Unexpected wishing compass solver state: \n" + getDiagnosticMessage()); } - - prevPlayerPos = mc.thePlayer.getPosition().getImmutable(); - compassUsedMillis = System.currentTimeMillis(); } catch (Exception e) { mc.thePlayer.addChatMessage(new ChatComponentText(EnumChatFormatting.RED + "[NEU] Error processing wishing compass action - see log for details")); e.printStackTrace(); + event.setCanceled(true); + solverState = SolverState.FAILED_EXCEPTION; } } + public HandleCompassResult handleCompassUse(BlockPos playerPos) { + long lastCompassUsedMillis = 0; + switch (solverState) { + case PROCESSING_SECOND_USE: + if (secondCompass != null) { + lastCompassUsedMillis = secondCompass.whenUsedMillis; + } + case PROCESSING_FIRST_USE: + if (lastCompassUsedMillis == 0 && firstCompass != null) { + lastCompassUsedMillis = firstCompass.whenUsedMillis; + } + if (lastCompassUsedMillis != 0 && + (currentTimeMillis.getAsLong() > lastCompassUsedMillis + ALL_PARTICLES_MAX_MILLIS)) { + return HandleCompassResult.NO_PARTICLES_FOR_PREVIOUS_COMPASS; + } + + return HandleCompassResult.STILL_PROCESSING_PRIOR_USE; + case SOLVED: + case FAILED_EXCEPTION: + case FAILED_TIMEOUT_NO_REPEATING: + case FAILED_TIMEOUT_NO_PARTICLES: + case FAILED_INTERSECTION_CALCULATION: + case FAILED_INVALID_SOLUTION: + resetForNewTarget(); + // falls through, NOT_STARTED is the state when resetForNewTarget returns + case NOT_STARTED: + if (NUCLEUS_BB.isVecInside(new Vec3Comparable(playerPos.getX(), playerPos.getY(), playerPos.getZ()))) { + return HandleCompassResult.PLAYER_IN_NUCLEUS; + } + + firstCompass = new Compass(playerPos, currentTimeMillis.getAsLong()); + solverState = SolverState.PROCESSING_FIRST_USE; + possibleTargets = calculatePossibleTargets(playerPos); + return HandleCompassResult.SUCCESS; + case NEED_SECOND_COMPASS: + if (firstCompass.whereUsed.distanceSq(playerPos) < MINIMUM_DISTANCE_SQ_BETWEEN_COMPASSES) { + return HandleCompassResult.LOCATION_TOO_CLOSE; + } + + if (!possibleTargets.equals(calculatePossibleTargets(playerPos))) { + resetForNewTarget(); + return HandleCompassResult.POSSIBLE_TARGETS_CHANGED; + } + + secondCompass = new Compass(playerPos, currentTimeMillis.getAsLong()); + solverState = SolverState.PROCESSING_SECOND_USE; + return HandleCompassResult.SUCCESS; + } + + throw new IllegalStateException("Unexpected compass state" ); + } + /* * Processes particles if the wishing compass was used within the last 5 seconds. * @@ -142,188 +287,701 @@ public class CrystalWishingCompassSolver { ) { if (!NotEnoughUpdates.INSTANCE.config.mining.wishingCompassSolver || particleType != EnumParticleTypes.VILLAGER_HAPPY || - !SBInfo.getInstance().getLocation().equals("crystal_hollows") || - isSolved() || - System.currentTimeMillis() - compassUsedMillis > 5000) { + !SBInfo.getInstance().getLocation().equals("crystal_hollows")) { return; } try { - Vec3 particleVec = new Vec3(x, y, z); - if (firstParticle == null) { - firstParticle = particleVec; - return; + SolverState originalSolverState = solverState; + solveUsingParticle(x, y, z, currentTimeMillis.getAsLong()); + if (solverState != originalSolverState) { + switch (solverState) { + case SOLVED: + showSolution(); + break; + case FAILED_EXCEPTION: + mc.thePlayer.addChatMessage(new ChatComponentText(EnumChatFormatting.RED + + "[NEU] Unable to determine wishing compass target.")); + logDiagnosticData(false); + break; + case FAILED_TIMEOUT_NO_REPEATING: + mc.thePlayer.addChatMessage(new ChatComponentText(EnumChatFormatting.RED + + "[NEU] Timed out waiting for repeat set of compass particles.")); + logDiagnosticData(false); + break; + case FAILED_TIMEOUT_NO_PARTICLES: + mc.thePlayer.addChatMessage(new ChatComponentText(EnumChatFormatting.RED + + "[NEU] Timed out waiting for compass particles.")); + logDiagnosticData(false); + break; + case FAILED_INTERSECTION_CALCULATION: + mc.thePlayer.addChatMessage(new ChatComponentText(EnumChatFormatting.RED + + "[NEU] Unable to determine intersection of wishing compasses.")); + logDiagnosticData(false); + break; + case FAILED_INVALID_SOLUTION: + mc.thePlayer.addChatMessage(new ChatComponentText(EnumChatFormatting.RED + + "[NEU] Failed to find solution.")); + logDiagnosticData(false); + break; + case NEED_SECOND_COMPASS: + mc.thePlayer.addChatMessage(new ChatComponentText(EnumChatFormatting.YELLOW + + "[NEU] Need another position to determine wishing compass target.")); + break; + } } + } catch (Exception e) { + mc.thePlayer.addChatMessage(new ChatComponentText(EnumChatFormatting.RED + + "[NEU] Exception while calculating wishing compass solution - see log for details")); + e.printStackTrace(); + } + } - double distanceFromFirst = particleVec.distanceTo(firstParticle); - if (distanceFromFirst > MAX_COMPASS_PARTICLE_SPREAD) { + /** + * + * @param x Particle x coordinate + * @param y Particle y coordinate + * @param z Particle z coordinate + */ + public void solveUsingParticle(double x, double y, double z, long currentTimeMillis) { + Compass currentCompass; + switch (solverState) { + case PROCESSING_FIRST_USE: + currentCompass = firstCompass; + break; + case PROCESSING_SECOND_USE: + currentCompass = secondCompass; + break; + default: return; - } + } - if (distanceFromFirst >= lastParticleDistanceFromFirst) { - lastParticleDistanceFromFirst = distanceFromFirst; - lastParticle = particleVec; + currentCompass.processParticle(x, y, z, currentTimeMillis); + switch (currentCompass.compassState) { + case FAILED_TIMEOUT_NO_PARTICLES: + solverState = SolverState.FAILED_TIMEOUT_NO_PARTICLES; + return; + case FAILED_TIMEOUT_NO_REPEATING: + solverState = SolverState.FAILED_TIMEOUT_NO_REPEATING; + return; + case WAITING_FOR_FIRST_PARTICLE: + case COMPUTING_LAST_PARTICLE: return; + case COMPLETED: + if (solverState == SolverState.NEED_SECOND_COMPASS) { + return; + } + if (solverState == SolverState.PROCESSING_FIRST_USE) { + solverState = SolverState.NEED_SECOND_COMPASS; + return; + } + break; + } + + // First and Second compasses have completed + solutionIntersectionLine = firstCompass.line.getIntersectionLineSegment(secondCompass.line); + + if (solutionIntersectionLine == null) { + solverState = SolverState.FAILED_INTERSECTION_CALCULATION; + return; + } + + solution = new Vec3Comparable(solutionIntersectionLine.getMidpoint()); + + Vec3Comparable firstDirection = firstCompass.getDirection(); + Vec3Comparable firstSolutionDirection = firstCompass.getDirectionTo(solution); + Vec3Comparable secondDirection = secondCompass.getDirection(); + Vec3Comparable secondSolutionDirection = secondCompass.getDirectionTo(solution); + if (!firstDirection.signumEquals(firstSolutionDirection) || + !secondDirection.signumEquals(secondSolutionDirection) || + !HOLLOWS_BB.isVecInside(solution)) { + solverState = SolverState.FAILED_INVALID_SOLUTION; + return; + } + + solutionPossibleTargets = getSolutionTargets(possibleTargets, solution); + + // Adjust the Jungle Temple solution coordinates + if (solutionPossibleTargets.size() == 1 && + solutionPossibleTargets.contains(CompassTarget.JUNGLE_TEMPLE)) { + originalSolution = solution; + solution = solution.addVector(-57, 36, -21); + } + + solverState = SolverState.SOLVED; + } + + private boolean isKeyInInventory() + { + for (ItemStack item : mc.thePlayer.inventory.mainInventory){ + if (item != null && item.getDisplayName().contains("Jungle Key")) { + return true; } + } + return false; + } - // We get here when the second repetition of particles begins. - // Since the second repetition overlaps with the last few particles - // of the first repetition, the last particle we capture isn't truly the last. - // But that's OK since subsequent particles will be on the same line. - Line line = new Line(firstParticle, lastParticle); - if (firstCompassLine == null) { - firstCompassLine = line; - resetForNewCompass(); - mc.thePlayer.addChatMessage(new ChatComponentText(EnumChatFormatting.YELLOW + - "[NEU] Need another position to determine wishing compass target.")); - return; + private boolean isKingsScentPresent() + { + return SBInfo.getInstance().footer.getUnformattedText().contains("King's Scent I"); + } + + private EnumSet<Crystal> getFoundCrystals() { + EnumSet<Crystal> foundCrystals = EnumSet.noneOf(Crystal.class); + NEUConfig.HiddenProfileSpecific perProfileConfig = NotEnoughUpdates.INSTANCE.config.getProfileSpecific(); + if (perProfileConfig == null) return foundCrystals; + HashMap<String, Integer> crystals = perProfileConfig.crystals; + for (String crystalName : crystals.keySet()) { + Integer crystalState = crystals.get(crystalName); + if (crystalState != null && crystalState > 0) { + foundCrystals.add(Crystal.valueOf(crystalName.toUpperCase())); } + } - secondCompassLine = line; - solutionIntersectionLine = firstCompassLine.getIntersectionLineSegment(secondCompassLine); - if (solutionIntersectionLine == null) { - mc.thePlayer.addChatMessage(new ChatComponentText(EnumChatFormatting.RED + - "[NEU] Unable to determine wishing compass target.")); - logDiagnosticData(false); - return; + return foundCrystals; + } + + // Returns candidates based on seen Y coordinates and quadrants that + // are not adjacent to the solution's quadrant. If the solution is + // the nucleus then a copy of the original possible targets is + // returned. + // + // NOTE: Adjacent quadrant filtering could be improved based on + // structure sizes in the future to only allow a certain + // distance into the adjacent quadrant. + // + // |----------|------------| + // | Jungle | Mithril | + // | | Deposits | + // |----------|----------- | + // | Goblin | Precursor | + // | Holdout | Deposits | + // |----------|------------| + static public EnumSet<CompassTarget> getSolutionTargets( + EnumSet<CompassTarget> possibleTargets, + Vec3Comparable solution) { + EnumSet<CompassTarget> solutionPossibleTargets; + solutionPossibleTargets = possibleTargets.clone(); + + if (NUCLEUS_BB.isVecInside(solution)) { + return solutionPossibleTargets; + } + + solutionPossibleTargets.remove(CompassTarget.CRYSTAL_NUCLEUS); + + // Eliminate non-adjacent zones first + if (MITHRIL_DEPOSITS_BB.isVecInside(solution)) { + solutionPossibleTargets.remove(CompassTarget.GOBLIN_KING); + solutionPossibleTargets.remove(CompassTarget.GOBLIN_QUEEN); + } else if (PRECURSOR_REMNANTS_BB.isVecInside(solution)) { + solutionPossibleTargets.remove(CompassTarget.ODAWA); + solutionPossibleTargets.remove(CompassTarget.JUNGLE_TEMPLE); + } else if (GOBLIN_HOLDOUT_BB.isVecInside(solution)) { + solutionPossibleTargets.remove(CompassTarget.MINES_OF_DIVAN); + } else if (JUNGLE_BB.isVecInside(solution)) { + solutionPossibleTargets.remove(CompassTarget.PRECURSOR_CITY); + } + + // If there's only 1 possible target then don't remove based + // on Y coordinates since assumptions about Y coordinates could + // be wrong. + if (solutionPossibleTargets.size() > 1) { + // Y coordinates are 43-70 from 11 samples + if (solutionPossibleTargets.contains(CompassTarget.BAL) && + solution.yCoord > 72) { + solutionPossibleTargets.remove(CompassTarget.BAL); } - solution = solutionIntersectionLine.getMidpoint(); + // Y coordinates are 93-157 from 10 samples, may be able to filter + // more based on the offset of the King within the structure + if (solutionPossibleTargets.contains(CompassTarget.GOBLIN_KING) && + solution.yCoord < 64) { + solutionPossibleTargets.remove(CompassTarget.GOBLIN_KING); + } - if (solution.distanceTo(firstParticle) < 8) { - mc.thePlayer.addChatMessage(new ChatComponentText(EnumChatFormatting.YELLOW + - "[NEU] WARNING: Solution is likely incorrect.")); - logDiagnosticData(false); - return; + // Y coordinates are 129-139 from 10 samples + if (solutionPossibleTargets.contains(CompassTarget.GOBLIN_QUEEN) && + (solution.yCoord < 127 || solution.yCoord > 141)) { + solutionPossibleTargets.remove(CompassTarget.GOBLIN_QUEEN); } - showSolution(); - } catch (Exception e) { - mc.thePlayer.addChatMessage(new ChatComponentText(EnumChatFormatting.RED + - "[NEU] Exception while calculating wishing compass solution - see log for details")); - e.printStackTrace(); + // Y coordinates are 72-80 from 10 samples + if (solutionPossibleTargets.contains(CompassTarget.JUNGLE_TEMPLE) && + (solution.yCoord < 70 || solution.yCoord > 82)) { + solutionPossibleTargets.remove(CompassTarget.JUNGLE_TEMPLE); + } + + // Y coordinates are 110-128 from 3 samples, not enough data to use + if (solutionPossibleTargets.contains(CompassTarget.ODAWA) && + solution.yCoord < 64) { + solutionPossibleTargets.remove(CompassTarget.ODAWA); + } + + // Y coordinates are 122-129 from 8 samples + if (solutionPossibleTargets.contains(CompassTarget.PRECURSOR_CITY) && + (solution.yCoord < 119 || solution.yCoord > 132)) { + solutionPossibleTargets.remove(CompassTarget.PRECURSOR_CITY); + } + + // Y coordinates are 98-102 from 15 samples + if (solutionPossibleTargets.contains(CompassTarget.MINES_OF_DIVAN) && + (solution.yCoord < 96 || solution.yCoord > 104)) { + solutionPossibleTargets.remove(CompassTarget.MINES_OF_DIVAN); + } } + + return solutionPossibleTargets; } - private boolean isSolved() { - return solution != null; + private EnumSet<CompassTarget> calculatePossibleTargets(BlockPos playerPos) { + boolean targetsBasedOnZoneWithoutCrystal = false; + EnumSet<CompassTarget> candidateTargets = EnumSet.allOf(CompassTarget.class); + EnumSet<Crystal> foundCrystals = this.foundCrystals.getAsCrystalEnumSet(); + Vec3Comparable playerPosVec = new Vec3Comparable(playerPos); + + // If the current zone's crystal hasn't been found then remove all non-nucleus candidates other + // than the ones in the current zone. The one exception is that the king is kept when in the jungle + // since the compass can point to the king if odawa is missing (which often happens). + // The nucleus is kept since it can be returned if the structure for the current zone is missing. + if (GOBLIN_HOLDOUT_BB.isVecInside(playerPosVec) && !foundCrystals.contains(Crystal.AMBER)) { + candidateTargets.clear(); + candidateTargets.add(CompassTarget.CRYSTAL_NUCLEUS); + candidateTargets.add(CompassTarget.GOBLIN_KING); + candidateTargets.add(CompassTarget.GOBLIN_QUEEN); + targetsBasedOnZoneWithoutCrystal = true; + } + + if (JUNGLE_BB.isVecInside(playerPosVec) && !foundCrystals.contains(Crystal.AMETHYST)) { + candidateTargets.clear(); + candidateTargets.add(CompassTarget.CRYSTAL_NUCLEUS); + candidateTargets.add(CompassTarget.ODAWA); + candidateTargets.add(CompassTarget.JUNGLE_TEMPLE); + if (!keyInInventory.getAsBoolean() && !kingsScentPresent.getAsBoolean()) { + // If Odawa is missing then the king may be returned + candidateTargets.add(CompassTarget.GOBLIN_KING); + } + targetsBasedOnZoneWithoutCrystal = true; + } + + if (MITHRIL_DEPOSITS_BB.isVecInside(playerPosVec) && !foundCrystals.contains(Crystal.JADE)) { + candidateTargets.clear(); + candidateTargets.add(CompassTarget.CRYSTAL_NUCLEUS); + candidateTargets.add(CompassTarget.MINES_OF_DIVAN); + targetsBasedOnZoneWithoutCrystal = true; + } + + if (PRECURSOR_REMNANTS_BB.isVecInside(playerPosVec) && !foundCrystals.contains(Crystal.SAPPHIRE)) { + candidateTargets.clear(); + candidateTargets.add(CompassTarget.CRYSTAL_NUCLEUS); + candidateTargets.add(CompassTarget.PRECURSOR_CITY); + targetsBasedOnZoneWithoutCrystal = true; + } + + if (MAGMA_FIELDS_BB.isVecInside(playerPosVec) && !foundCrystals.contains(Crystal.TOPAZ)) { + candidateTargets.clear(); + candidateTargets.add(CompassTarget.CRYSTAL_NUCLEUS); + candidateTargets.add(CompassTarget.BAL); + targetsBasedOnZoneWithoutCrystal = true; + } + + if (!targetsBasedOnZoneWithoutCrystal) { + // Filter out crystal-based targets outside the current zone + if (foundCrystals.contains(Crystal.AMBER)) { + candidateTargets.remove(CompassTarget.GOBLIN_KING); + candidateTargets.remove(CompassTarget.GOBLIN_QUEEN); + } + + if (foundCrystals.contains(Crystal.AMETHYST)) { + candidateTargets.remove(CompassTarget.ODAWA); + candidateTargets.remove(CompassTarget.JUNGLE_TEMPLE); + } + + if (foundCrystals.contains(Crystal.JADE)) { + candidateTargets.remove(CompassTarget.MINES_OF_DIVAN); + } + + if (foundCrystals.contains(Crystal.TOPAZ)) { + candidateTargets.remove(CompassTarget.BAL); + } + + if (foundCrystals.contains(Crystal.SAPPHIRE)) { + candidateTargets.remove(CompassTarget.PRECURSOR_CITY); + } + } + + candidateTargets.remove(kingsScentPresent.getAsBoolean() ? CompassTarget.GOBLIN_KING : CompassTarget.GOBLIN_QUEEN); + candidateTargets.remove(keyInInventory.getAsBoolean() ? CompassTarget.ODAWA : CompassTarget.JUNGLE_TEMPLE); + + return candidateTargets; } - private void showSolution() { - if (solution == null) return; - String description = "[NEU] Wishing compass target: "; - String coordsText = String.format("%.0f %.0f %.0f", - solution.xCoord, - solution.yCoord, - solution.zCoord); + private String getFriendlyNameForCompassTarget(CompassTarget compassTarget) { + switch (compassTarget) { + case BAL: return EnumChatFormatting.RED + "Bal"; + case ODAWA: return EnumChatFormatting.GREEN + "Odawa"; + case JUNGLE_TEMPLE: return EnumChatFormatting.AQUA + "the " + + EnumChatFormatting.GREEN + "Jungle Temple"; + case GOBLIN_KING: return EnumChatFormatting.GOLD + "King Yolkar"; + case GOBLIN_QUEEN: return EnumChatFormatting.AQUA + "the " + + EnumChatFormatting.YELLOW + "Goblin Queen"; + case PRECURSOR_CITY: return EnumChatFormatting.AQUA + "the " + + EnumChatFormatting.WHITE + "Precursor City"; + case MINES_OF_DIVAN: return EnumChatFormatting.AQUA + "the " + + EnumChatFormatting.BLUE + "Mines of Divan"; + default: return EnumChatFormatting.WHITE + "an undetermined location"; + } + } - if (NUCLEUS_BB.isVecInside(solution)) { - description += "Crystal Nucleus (" + coordsText + ")"; - } else { - description += coordsText; + private String getNameForCompassTarget(CompassTarget compassTarget) { + boolean useSkytilsNames = (NotEnoughUpdates.INSTANCE.config.mining.wishingCompassWaypointNameType == 1); + switch (compassTarget) { + case BAL: return useSkytilsNames ? "internal_bal" : "Bal"; + case ODAWA: return "Odawa"; + case JUNGLE_TEMPLE: return useSkytilsNames ? "internal_temple" : "Temple"; + case GOBLIN_KING: return useSkytilsNames ? "internal_king" : "King"; + case GOBLIN_QUEEN: return useSkytilsNames ? "internal_den" : "Queen"; + case PRECURSOR_CITY: return useSkytilsNames ? "internal_city" : "City"; + case MINES_OF_DIVAN: return useSkytilsNames ? "internal_mines" : "Mines"; + default: return "WishingTarget"; } + } - ChatComponentText message = new ChatComponentText(EnumChatFormatting.YELLOW + description); + private String getSolutionCoordsText() { + return solution == null ? "" : + String.format("%.0f %.0f %.0f", solution.xCoord, solution.yCoord, solution.zCoord); + } - if (isSkytilsPresent) { - ChatStyle clickEvent = new ChatStyle().setChatClickEvent( - new ClickEvent(ClickEvent.Action.SUGGEST_COMMAND, "/sthw add WishingTarget " + coordsText)); - clickEvent.setChatHoverEvent(new HoverEvent(HoverEvent.Action.SHOW_TEXT, new ChatComponentText( - EnumChatFormatting.YELLOW + - "Add Skytils hollows waypoint"))); - message.setChatStyle(clickEvent); + private String getWishingCompassDestinationsMessage() { + StringBuilder sb = new StringBuilder(); + sb.append(EnumChatFormatting.YELLOW); + sb.append("[NEU] "); + sb.append(EnumChatFormatting.AQUA); + sb.append("Wishing compass points to "); + int index = 1; + for (CompassTarget target : solutionPossibleTargets) { + if (index > 1) { + sb.append(EnumChatFormatting.AQUA); + if (index == solutionPossibleTargets.size()) { + sb.append(" or "); + } else { + sb.append(", "); + } + } + sb.append(getFriendlyNameForCompassTarget(target)); + index++; } - Minecraft.getMinecraft().thePlayer.addChatMessage(message); + sb.append(EnumChatFormatting.AQUA); + sb.append(" ("); + sb.append(getSolutionCoordsText()); + sb.append(")"); + return sb.toString(); } - public void logDiagnosticData(boolean outputAlways) { - if (SBInfo.getInstance().getLocation() == null) { - mc.thePlayer.addChatMessage(new ChatComponentText(EnumChatFormatting.RED + - "[NEU] This command is not available outside SkyBlock")); + private void showSolution() { + if (solution == null) return; + + if (NUCLEUS_BB.isVecInside(solution)) { + mc.thePlayer.addChatMessage(new ChatComponentText(EnumChatFormatting.YELLOW + "[NEU] " + + EnumChatFormatting.AQUA + "Wishing compass target is the Crystal Nucleus")); return; } - if (!NotEnoughUpdates.INSTANCE.config.mining.wishingCompassSolver) - { - mc.thePlayer.addChatMessage(new ChatComponentText(EnumChatFormatting.RED + - "[NEU] Wishing Compass Solver is not enabled.")); + String destinationMessage = getWishingCompassDestinationsMessage(); + + if (!isSkytilsPresent) { + mc.thePlayer.addChatMessage(new ChatComponentText(destinationMessage)); return; } - if (!outputAlways && !NotEnoughUpdates.INSTANCE.config.hidden.debugFlags.contains(NEUDebugFlag.WISHING)) { - return; + String targetNameForSkytils = solutionPossibleTargets.size() == 1 ? + getNameForCompassTarget(solutionPossibleTargets.iterator().next()) : + "WishingTarget"; + String skytilsCommand = String.format("/sthw add %s %s", targetNameForSkytils, getSolutionCoordsText()); + if (NotEnoughUpdates.INSTANCE.config.mining.wishingCompassAutocreateKnownWaypoints && + solutionPossibleTargets.size() == 1) { + mc.thePlayer.addChatMessage(new ChatComponentText(destinationMessage)); + int commandResult = ClientCommandHandler.instance.executeCommand(mc.thePlayer, skytilsCommand); + if (commandResult == 1) + { + return; + } + mc.thePlayer.addChatMessage(new ChatComponentText(EnumChatFormatting.RED + "[NEU] Failed to automatically run /sthw")); } - boolean originalDebugFlag = !NotEnoughUpdates.INSTANCE.config.hidden.debugFlags.add(NEUDebugFlag.WISHING); + destinationMessage += EnumChatFormatting.YELLOW + " [Add Skytils Waypoint]"; + ChatComponentText chatMessage = new ChatComponentText(destinationMessage); + chatMessage.setChatStyle(Utils.createClickStyle(ClickEvent.Action.RUN_COMMAND, + skytilsCommand, + EnumChatFormatting.YELLOW + "Set waypoint for wishing target\n")); + mc.thePlayer.addChatMessage(chatMessage); + } + private String getDiagnosticMessage() { StringBuilder diagsMessage = new StringBuilder(); - diagsMessage.append("\n"); diagsMessage.append(EnumChatFormatting.AQUA); - diagsMessage.append("Skytils Present: "); + diagsMessage.append("Solver State: "); diagsMessage.append(EnumChatFormatting.WHITE); - diagsMessage.append(isSkytilsPresent); + diagsMessage.append(solverState.name()); diagsMessage.append("\n"); - diagsMessage.append(EnumChatFormatting.AQUA); - diagsMessage.append("Compass Used Millis: "); - diagsMessage.append(EnumChatFormatting.WHITE); - diagsMessage.append(compassUsedMillis); - diagsMessage.append("\n"); + if (firstCompass == null) { + diagsMessage.append(EnumChatFormatting.AQUA); + diagsMessage.append("First Compass: "); + diagsMessage.append(EnumChatFormatting.WHITE); + diagsMessage.append("<NONE>"); + diagsMessage.append("\n"); + } else { + firstCompass.appendCompassDiagnostics(diagsMessage, "First Compass"); + } + + if (secondCompass == null) { + diagsMessage.append(EnumChatFormatting.AQUA); + diagsMessage.append("Second Compass: "); + diagsMessage.append(EnumChatFormatting.WHITE); + diagsMessage.append("<NONE>"); + diagsMessage.append("\n"); + } else { + secondCompass.appendCompassDiagnostics(diagsMessage, "Second Compass"); + } diagsMessage.append(EnumChatFormatting.AQUA); - diagsMessage.append("Compass Used Position: "); + diagsMessage.append("Intersection Line: "); diagsMessage.append(EnumChatFormatting.WHITE); - diagsMessage.append((prevPlayerPos == null) ? "<NONE>" : prevPlayerPos.toString()); + diagsMessage.append((solutionIntersectionLine == null) ? "<NONE>" : solutionIntersectionLine); diagsMessage.append("\n"); diagsMessage.append(EnumChatFormatting.AQUA); - diagsMessage.append("First Particle: "); + diagsMessage.append("Jungle Key in Inventory: "); diagsMessage.append(EnumChatFormatting.WHITE); - diagsMessage.append((firstParticle == null) ? "<NONE>" : firstParticle.toString()); + diagsMessage.append(isKeyInInventory()); diagsMessage.append("\n"); diagsMessage.append(EnumChatFormatting.AQUA); - diagsMessage.append("Last Particle: "); + diagsMessage.append("King's Scent Present: "); diagsMessage.append(EnumChatFormatting.WHITE); - diagsMessage.append((lastParticle == null) ? "<NONE>" : lastParticle.toString()); + diagsMessage.append(isKingsScentPresent()); diagsMessage.append("\n"); diagsMessage.append(EnumChatFormatting.AQUA); - diagsMessage.append("Last Particle Distance From First: "); + diagsMessage.append("First Compass Targets: "); diagsMessage.append(EnumChatFormatting.WHITE); - diagsMessage.append(lastParticleDistanceFromFirst); + diagsMessage.append(possibleTargets == null ? "<NONE>" : possibleTargets.toString()); diagsMessage.append("\n"); diagsMessage.append(EnumChatFormatting.AQUA); - diagsMessage.append("First Compass Line: "); + diagsMessage.append("Current Calculated Targets: "); diagsMessage.append(EnumChatFormatting.WHITE); - diagsMessage.append((firstCompassLine == null) ? "<NONE>" : firstCompassLine.toString()); + diagsMessage.append(calculatePossibleTargets(mc.thePlayer.getPosition())); diagsMessage.append("\n"); diagsMessage.append(EnumChatFormatting.AQUA); - diagsMessage.append("Second Compass Line: "); + diagsMessage.append("Found Crystals: "); diagsMessage.append(EnumChatFormatting.WHITE); - diagsMessage.append((secondCompassLine == null) ? "<NONE>" : secondCompassLine.toString()); + diagsMessage.append(getFoundCrystals()); diagsMessage.append("\n"); + if (originalSolution != null) { + diagsMessage.append(EnumChatFormatting.AQUA); + diagsMessage.append("Original Solution: "); + diagsMessage.append(EnumChatFormatting.WHITE); + diagsMessage.append(originalSolution); + diagsMessage.append("\n"); + } + diagsMessage.append(EnumChatFormatting.AQUA); - diagsMessage.append("Intersection Line: "); + diagsMessage.append("Solution: "); diagsMessage.append(EnumChatFormatting.WHITE); - diagsMessage.append((secondCompassLine == null) ? "<NONE>" : solutionIntersectionLine); + diagsMessage.append((solution == null) ? "<NONE>" : solution.toString()); diagsMessage.append("\n"); diagsMessage.append(EnumChatFormatting.AQUA); - diagsMessage.append("Solution: "); + diagsMessage.append("Solution Targets: "); diagsMessage.append(EnumChatFormatting.WHITE); - diagsMessage.append((solution == null) ? "<NONE>" : solution.toString()); + diagsMessage.append((solutionPossibleTargets == null) ? "<NONE>" : solutionPossibleTargets.toString()); diagsMessage.append("\n"); - NEUDebugLogger.log(NEUDebugFlag.WISHING, diagsMessage.toString()); + return diagsMessage.toString(); + } + + public void logDiagnosticData(boolean outputAlways) { + if (!SBInfo.getInstance().checkForSkyblockLocation()) { + return; + } - if (!originalDebugFlag) { - NotEnoughUpdates.INSTANCE.config.hidden.debugFlags.remove(NEUDebugFlag.WISHING); + if (!NotEnoughUpdates.INSTANCE.config.mining.wishingCompassSolver) + { + mc.thePlayer.addChatMessage(new ChatComponentText(EnumChatFormatting.RED + + "[NEU] Wishing Compass Solver is not enabled.")); + return; + } + + boolean wishingDebugFlagSet = NotEnoughUpdates.INSTANCE.config.hidden.debugFlags.contains(NEUDebugFlag.WISHING); + if (outputAlways || wishingDebugFlagSet) { + NEUDebugLogger.logAlways(getDiagnosticMessage()); + } + } + + enum CompassState { + WAITING_FOR_FIRST_PARTICLE, + COMPUTING_LAST_PARTICLE, + COMPLETED, + FAILED_TIMEOUT_NO_REPEATING, + FAILED_TIMEOUT_NO_PARTICLES, + } + + enum HandleCompassResult { + SUCCESS, + LOCATION_TOO_CLOSE, + STILL_PROCESSING_PRIOR_USE, + POSSIBLE_TARGETS_CHANGED, + NO_PARTICLES_FOR_PREVIOUS_COMPASS, + PLAYER_IN_NUCLEUS + } + + static class Compass { + public CompassState compassState; + public Line line = null; + + private final BlockPos whereUsed; + private final long whenUsedMillis; + private Vec3Comparable firstParticle = null; + private Vec3Comparable previousParticle = null; + private Vec3Comparable lastParticle = null; + private final ArrayList<ProcessedParticle> processedParticles; + + Compass(BlockPos whereUsed, long whenUsedMillis) { + this.whereUsed = whereUsed; + this.whenUsedMillis = whenUsedMillis; + compassState = CompassState.WAITING_FOR_FIRST_PARTICLE; + processedParticles = new ArrayList<>(); + } + + public Vec3Comparable getDirection() { + if (firstParticle == null || lastParticle == null) { + return null; + } + + return new Vec3Comparable(firstParticle.subtractReverse(lastParticle).normalize()); + } + + public Vec3Comparable getDirectionTo(Vec3Comparable target) { + if (firstParticle == null || target == null) { + return null; + } + + return new Vec3Comparable(firstParticle.subtractReverse(target).normalize()); + } + + public double particleSpread() { + if (firstParticle == null || lastParticle == null) { + return 0.0; + } + return firstParticle.distanceTo(lastParticle); + } + + public void processParticle(double x, double y, double z, long particleTimeMillis) { + if (compassState == CompassState.FAILED_TIMEOUT_NO_REPEATING || + compassState == CompassState.FAILED_TIMEOUT_NO_PARTICLES || + compassState == CompassState.COMPLETED) { + throw new UnsupportedOperationException("processParticle should not be called in a failed or completed state"); + } + + if (particleTimeMillis - this.whenUsedMillis > ALL_PARTICLES_MAX_MILLIS) { + // Assume we have failed if we're still trying to process particles + compassState = CompassState.FAILED_TIMEOUT_NO_REPEATING; + return; + } + + Vec3Comparable currentParticle = new Vec3Comparable(x, y, z); + if (compassState == CompassState.WAITING_FOR_FIRST_PARTICLE) { + if (currentParticle.distanceTo(new Vec3Comparable(whereUsed)) < MAX_DISTANCE_FROM_USE_TO_FIRST_PARTICLE) { + processedParticles.add(new ProcessedParticle(currentParticle, particleTimeMillis)); + firstParticle = currentParticle; + previousParticle = currentParticle; + compassState = CompassState.COMPUTING_LAST_PARTICLE; + } + return; + } + + // State is COMPUTING_LAST_PARTICLE, keep updating the previousParticle until + // the first particle in the second sequence is seen. + if (currentParticle.distanceTo(previousParticle) <= MAX_DISTANCE_BETWEEN_PARTICLES) { + processedParticles.add(new ProcessedParticle(currentParticle, particleTimeMillis)); + previousParticle = currentParticle; + return; + } + + if (currentParticle.distanceTo(firstParticle) > MAX_DISTANCE_BETWEEN_PARTICLES) { + return; + } + + // It's a repeating particle + processedParticles.add(new ProcessedParticle(currentParticle, particleTimeMillis)); + lastParticle = previousParticle; + line = new Line(firstParticle, lastParticle); + compassState = CompassState.COMPLETED; + } + + public void appendCompassDiagnostics(StringBuilder diagsMessage, String compassName) { + diagsMessage.append(EnumChatFormatting.AQUA); + diagsMessage.append("Compass State: "); + diagsMessage.append(EnumChatFormatting.WHITE); + diagsMessage.append(compassState.name()); + diagsMessage.append("\n"); + + diagsMessage.append(EnumChatFormatting.AQUA); + diagsMessage.append(compassName); + diagsMessage.append(" Used Millis: "); + diagsMessage.append(EnumChatFormatting.WHITE); + diagsMessage.append(whenUsedMillis); + diagsMessage.append("\n"); + + diagsMessage.append(EnumChatFormatting.AQUA); + diagsMessage.append(compassName); + diagsMessage.append(" Used Position: "); + diagsMessage.append(EnumChatFormatting.WHITE); + diagsMessage.append((whereUsed == null) ? "<NONE>" : whereUsed.toString()); + diagsMessage.append("\n"); + + diagsMessage.append(EnumChatFormatting.AQUA); + diagsMessage.append(compassName); + diagsMessage.append(" All Seen Particles: \n"); + diagsMessage.append(EnumChatFormatting.WHITE); + for (ProcessedParticle particle : processedParticles) { + diagsMessage.append(particle.toString()); + diagsMessage.append("\n"); + } + + diagsMessage.append(EnumChatFormatting.AQUA); + diagsMessage.append(compassName); + diagsMessage.append(" Particle Spread: "); + diagsMessage.append(EnumChatFormatting.WHITE); + diagsMessage.append(particleSpread()); + diagsMessage.append("\n"); + + diagsMessage.append(EnumChatFormatting.AQUA); + diagsMessage.append(compassName); + diagsMessage.append(" Compass Line: "); + diagsMessage.append(EnumChatFormatting.WHITE); + diagsMessage.append((line == null) ? "<NONE>" : line.toString()); + diagsMessage.append("\n"); + } + + static class ProcessedParticle { + Vec3Comparable coords; + long particleTimeMillis; + + ProcessedParticle(Vec3Comparable coords, long particleTimeMillis) { + this.coords = coords; + this.particleTimeMillis = particleTimeMillis; + } + + @Override + public String toString() { + return coords.toString() + " " + particleTimeMillis; + } } } } diff --git a/src/main/java/io/github/moulberry/notenoughupdates/options/seperateSections/Mining.java b/src/main/java/io/github/moulberry/notenoughupdates/options/seperateSections/Mining.java index 6cfb8c04..f793baf0 100644 --- a/src/main/java/io/github/moulberry/notenoughupdates/options/seperateSections/Mining.java +++ b/src/main/java/io/github/moulberry/notenoughupdates/options/seperateSections/Mining.java @@ -641,6 +641,42 @@ public class Mining { @ConfigAccordionId(id = 6) public int crystalHollowNoneColor = 12; + @ConfigOption( + name = "Wishing Compass Solver", + desc = "" + ) + @ConfigEditorAccordion(id = 7) + public boolean wishingCompassSolverAccordion = false; + + @Expose + @ConfigOption( + name = "Enable Solver", + desc = "Show wishing compass target coordinates based on two samples" + ) + @ConfigAccordionId(id = 7) + @ConfigEditorBoolean + public boolean wishingCompassSolver = true; + + @Expose + @ConfigOption( + name = "Skytils Waypoints", + desc = "Automatically create Skytils waypoints for well-known targets" + ) + @ConfigAccordionId(id = 7) + @ConfigEditorBoolean + public boolean wishingCompassAutocreateKnownWaypoints = false; + + @Expose + @ConfigOption( + name = "Waypoint Type", + desc = "Skytils Waypoint name type. Skytils Built-in will be overwritten by Skytils when the waypoint is nearby." + ) + @ConfigAccordionId(id = 7) + @ConfigEditorDropdown( + values = {"NEU", "Skytils"} + ) + public int wishingCompassWaypointNameType = 0; + @Expose @ConfigOption( name = "Puzzler Solver", @@ -665,19 +701,11 @@ public class Mining { @ConfigEditorBoolean public boolean titaniumAlertMustBeVisible = false; - @Expose - @ConfigOption( - name = "Wishing Compass Solver", - desc = "Show wishing compass target coordinates based on two samples" - ) - @ConfigEditorBoolean - public boolean wishingCompassSolver = true; - @ConfigOption( name = "Custom Textures", desc = "" ) - @ConfigEditorAccordion(id = 7) + @ConfigEditorAccordion(id = 8) public boolean texturesAccordion = false; @Expose @@ -685,7 +713,7 @@ public class Mining { name = "Dwarven Mines Textures", desc = "Allows texture packs to retexture blocks in the Dwarven Mines. If you don't have a texture pack that does this, you should leave this off" ) - @ConfigAccordionId(id = 7) + @ConfigAccordionId(id = 8) @ConfigEditorBoolean public boolean dwarvenTextures = false; @Expose @@ -693,7 +721,7 @@ public class Mining { name = "Crystal Hollows Textures", desc = "Allows texture packs to retexture blocks in the Crystal Hollows. If you don't have a texture pack that does this, you should leave this off" ) - @ConfigAccordionId(id = 7) + @ConfigAccordionId(id = 8) @ConfigEditorBoolean public boolean crystalHollowTextures = false; @@ -702,7 +730,7 @@ public class Mining { name = "Replace Gemstone sounds", desc = "Replace the break sounds of crystals in the Crystal Hollows. Requires a texture pack with this feature" ) - @ConfigAccordionId(id = 7) + @ConfigAccordionId(id = 8) @ConfigEditorBoolean public boolean gemstoneSounds = false; @@ -711,7 +739,7 @@ public class Mining { name = "Replace Mithril sounds", desc = "Replace the break sounds of mithril and titanium in the Dwarven mines. Requires a texture pack with this feature" ) - @ConfigAccordionId(id = 7) + @ConfigAccordionId(id = 8) @ConfigEditorBoolean public boolean mithrilSounds = false; diff --git a/src/main/java/io/github/moulberry/notenoughupdates/util/NEUDebugLogger.java b/src/main/java/io/github/moulberry/notenoughupdates/util/NEUDebugLogger.java index d662a872..827a3e97 100644 --- a/src/main/java/io/github/moulberry/notenoughupdates/util/NEUDebugLogger.java +++ b/src/main/java/io/github/moulberry/notenoughupdates/util/NEUDebugLogger.java @@ -13,6 +13,8 @@ import java.util.function.Consumer; public class NEUDebugLogger { private static final Minecraft mc = Minecraft.getMinecraft(); public static Consumer<String> logMethod = NEUDebugLogger::chatLogger; + // Used to prevent accessing NEUConfig in unit tests + public static boolean allFlagsEnabled = false; private static void chatLogger(String message) { mc.thePlayer.addChatMessage(new ChatComponentText(EnumChatFormatting.YELLOW + "[NEU DEBUG] " + message)); @@ -23,7 +25,13 @@ public class NEUDebugLogger { } public static void log(NEUDebugFlag flag, String message) { - if (logMethod != null && isFlagEnabled(flag)) { + if (logMethod != null && (allFlagsEnabled || isFlagEnabled(flag))) { + logAlways(message); + } + } + + public static void logAlways(String message) { + if (logMethod != null) { logMethod.accept(message); } } diff --git a/src/main/java/io/github/moulberry/notenoughupdates/util/SBInfo.java b/src/main/java/io/github/moulberry/notenoughupdates/util/SBInfo.java index 95a3539a..f1e40671 100644 --- a/src/main/java/io/github/moulberry/notenoughupdates/util/SBInfo.java +++ b/src/main/java/io/github/moulberry/notenoughupdates/util/SBInfo.java @@ -18,6 +18,8 @@ import net.minecraft.scoreboard.Score; import net.minecraft.scoreboard.ScoreObjective; import net.minecraft.scoreboard.ScorePlayerTeam; import net.minecraft.scoreboard.Scoreboard; +import net.minecraft.util.ChatComponentText; +import net.minecraft.util.EnumChatFormatting; import net.minecraft.util.IChatComponent; import net.minecraftforge.client.event.ClientChatReceivedEvent; import net.minecraftforge.client.event.GuiOpenEvent; @@ -57,7 +59,7 @@ public class SBInfo { public String slayer = ""; public boolean stranded = false; - public String mode = ""; + public String mode = null; public Date currentTimeDate = null; @@ -120,6 +122,16 @@ public class SBInfo { } } + public boolean checkForSkyblockLocation() { + if (!NotEnoughUpdates.INSTANCE.hasSkyblockScoreboard() || getLocation() == null) { + Minecraft.getMinecraft().thePlayer.addChatMessage(new ChatComponentText(EnumChatFormatting.RED + + "[NEU] This command is not available outside SkyBlock")); + return false; + } + + return true; + } + private static final Pattern PROFILE_PATTERN = Pattern.compile("(?<type>(♲ Ironman)|(☀ Stranded)|()) *Profile: (?<name>[^ ]+)"); diff --git a/src/test/java/io/github/moulberry/notenoughupdates/core/util/Vec3ComparableTest.java b/src/test/java/io/github/moulberry/notenoughupdates/core/util/Vec3ComparableTest.java new file mode 100644 index 00000000..c0b451e3 --- /dev/null +++ b/src/test/java/io/github/moulberry/notenoughupdates/core/util/Vec3ComparableTest.java @@ -0,0 +1,193 @@ +package io.github.moulberry.notenoughupdates.core.util; + +import net.minecraft.util.BlockPos; +import net.minecraft.util.Vec3; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; + +class Vec3ComparableTest { + @Test + void equals_false_when_null() { + // Arrange + Vec3Comparable vec3c = new Vec3Comparable(1.0, 2.0, 3.0); + + // Act + boolean areEqual = vec3c.equals(null); + + // Assert + assertFalse(areEqual); + } + + @Test + void equals_true_when_same_object() { + // Arrange + Vec3Comparable vec3c = new Vec3Comparable(1.0, 2.0, 3.0); + + // Act + boolean areEqual = vec3c.equals(vec3c); + + // Assert + assertTrue(areEqual); + } + + @Test + void equals_true_when_same_value() { + // Arrange + Vec3Comparable vec3c1 = new Vec3Comparable(1.0, 2.0, 3.0); + Vec3Comparable vec3c2 = new Vec3Comparable(1.0, 2.0, 3.0); + + // Act + boolean areEqual = vec3c1.equals(vec3c2); + + // Assert + assertTrue(areEqual); + } + + @Test + void equals_false_when_vec3_equals() { + // Arrange + Vec3Comparable vec3c1 = new Vec3Comparable(1.0, 2.0, 3.0); + Vec3 vec3c2 = new Vec3(1.0, 2.0, 3.0); + + // Act + boolean areEqual = vec3c1.equals(vec3c2); + + // Assert + assertFalse(areEqual); + } + + @Test + void equals_false_when_different_object_type() { + // Arrange + Vec3Comparable vec3c1 = new Vec3Comparable(1.0, 2.0, 3.0); + BlockPos blockPos = new BlockPos(1.0, 2.0, 3.0); + + // Act + boolean areEqual = vec3c1.equals(blockPos); + + // Assert + assertFalse(areEqual); + } + + @Test + void equals_false_when_different_value() { + // Arrange + Vec3Comparable vec3c1 = new Vec3Comparable(1.0, 2.0, 3.0); + Vec3Comparable vec3c2 = new Vec3Comparable(3.0, 2.0, 1.0); + + // Act + boolean areEqual = vec3c1.equals(vec3c2); + + // Assert + assertFalse(areEqual); + } + + @Test + void hashCode_same_when_same_value() { + // Arrange + Vec3Comparable vec3c1 = new Vec3Comparable(1.0, 2.0, 3.0); + Vec3Comparable vec3c2 = new Vec3Comparable(1.0, 2.0, 3.0); + + // Act + double vec3c1Hash = vec3c1.hashCode(); + double vec3c2Hash = vec3c2.hashCode(); + + // Assert + assertEquals(vec3c1Hash, vec3c2Hash); + } + + @Test + void hashCode_different_when_different_value() { + // Arrange + Vec3Comparable vec3c1 = new Vec3Comparable(1.0, 2.0, 3.0); + Vec3Comparable vec3c2 = new Vec3Comparable(3.0, 2.0, 1.0); + + // Act + double vec3c1Hash = vec3c1.hashCode(); + double vec3c2Hash = vec3c2.hashCode(); + + // Assert + assertNotEquals(vec3c1Hash, vec3c2Hash); + } + + @Test + void compareTo_zero_when_equal() { + // Arrange + Vec3Comparable vec3c1 = new Vec3Comparable(1.0, 2.0, 3.0); + Vec3Comparable vec3c2 = new Vec3Comparable(1.0, 2.0, 3.0); + + // Act + int result = vec3c1.compareTo(vec3c2); + + // Assert + assertEquals(0, result); + } + + @Test + void compareTo_negative_when_lower() { + // Arrange + Vec3Comparable vec3c1 = new Vec3Comparable(0.0, 2.0, 3.0); + Vec3Comparable vec3c2 = new Vec3Comparable(1.0, 2.0, 3.0); + + // Act + int result = vec3c1.compareTo(vec3c2); + + // Assert + assertTrue(result < 0); + } + + @Test + void compareTo_positive_when_x_y_or_z_is_higher() { + // Arrange + Vec3Comparable vec3c1x = new Vec3Comparable(2.0, 2.0, 3.0); + Vec3Comparable vec3c2x = new Vec3Comparable(1.0, 2.0, 3.0); + Vec3Comparable vec3c1y = new Vec3Comparable(1.0, 3.0, 3.0); + Vec3Comparable vec3c2y = new Vec3Comparable(1.0, 2.0, 3.0); + Vec3Comparable vec3c1z = new Vec3Comparable(1.0, 2.0, 4.0); + Vec3Comparable vec3c2z = new Vec3Comparable(1.0, 2.0, 3.0); + + // Act + int resultX = vec3c1x.compareTo(vec3c2x); + int resultY = vec3c1y.compareTo(vec3c2y); + int resultZ = vec3c1z.compareTo(vec3c2z); + + // Assert + assertTrue(resultX > 0); + assertTrue(resultY > 0); + assertTrue(resultZ > 0); + } + + @Test + void compareTo_throws_on_null() { + // Arrange + Vec3Comparable vec3c = new Vec3Comparable(1.0, 2.0, 3.0); + + // Act & Assert + Assertions.assertThrows(NullPointerException.class, () -> { + vec3c.compareTo(null); + }); + } + + @Test + void signumEquals_is_true_when_all_signums_match() { + Vec3Comparable first = new Vec3Comparable(-1.0, 1.0, 0); + Vec3 second = new Vec3(-1.0, 1.0, 0); + Assertions.assertTrue(first.signumEquals(second)); + } + + @Test + void signumEquals_is_false_when_any_signum_differs() { + Vec3Comparable first = new Vec3Comparable(-1.0, 1.0, 0); + Vec3 second = new Vec3(-1.0, 1.0, 1.0); + Vec3 third = new Vec3(-1.0, -1.0, 0); + Vec3 fourth = new Vec3(1.0, 1.0, 1.0); + Assertions.assertFalse(first.signumEquals(second)); + Assertions.assertFalse(first.signumEquals(third)); + Assertions.assertFalse(first.signumEquals(fourth)); + } +} diff --git a/src/test/java/io/github/moulberry/notenoughupdates/miscfeatures/CrystalMetalDetectorSolverTest.java b/src/test/java/io/github/moulberry/notenoughupdates/miscfeatures/CrystalMetalDetectorSolverTest.java new file mode 100644 index 00000000..58233410 --- /dev/null +++ b/src/test/java/io/github/moulberry/notenoughupdates/miscfeatures/CrystalMetalDetectorSolverTest.java @@ -0,0 +1,204 @@ +package io.github.moulberry.notenoughupdates.miscfeatures; + +import io.github.moulberry.notenoughupdates.core.util.Vec3Comparable; +import io.github.moulberry.notenoughupdates.miscfeatures.CrystalMetalDetectorSolver.SolutionState; +import io.github.moulberry.notenoughupdates.util.NEUDebugLogger; +import net.minecraft.util.BlockPos; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.Assertions; + +import java.util.ArrayList; + +class CrystalMetalDetectorSolverTest { + class Location { + double distance; + Vec3Comparable playerPosition; + SolutionState expectedState; + boolean centerKnown; + + public Location(double distance, + Vec3Comparable playerPosition, + SolutionState expectedState, + boolean centerKnown) { + this.distance = distance; + this.playerPosition = playerPosition; + this.expectedState = expectedState; + this.centerKnown = centerKnown; + } + } + + class Solution { + ArrayList<Location> locations = new ArrayList<>(); + BlockPos center = BlockPos.ORIGIN; + BlockPos expectedSolution = BlockPos.ORIGIN; + } + + @BeforeEach + void setUp() { + CrystalMetalDetectorSolver.initWorld(); + CrystalMetalDetectorSolver.treasureAllowedPredicate = blockPos -> true; + NEUDebugLogger.logMethod = CrystalMetalDetectorSolverTest::neuDebugLog; + NEUDebugLogger.allFlagsEnabled = true; + } + + private void findPossibleSolutionsTwice(Location loc, boolean centerNewlyDiscovered) { + // Each location has to be received twice to be valid + CrystalMetalDetectorSolver.findPossibleSolutions(loc.distance, loc.playerPosition, centerNewlyDiscovered); + CrystalMetalDetectorSolver.findPossibleSolutions(loc.distance, loc.playerPosition, false); + } + + private void checkSolution(Solution solution) { + boolean centerSet = false; + int index = 0; + for (Location loc : solution.locations) { + if (loc.centerKnown && !centerSet && !solution.center.equals(BlockPos.ORIGIN)) { + CrystalMetalDetectorSolver.setMinesCenter(solution.center); + centerSet = true; + findPossibleSolutionsTwice(loc, true); + } else { + findPossibleSolutionsTwice(loc, false); + } + Assertions.assertEquals(loc.expectedState, + CrystalMetalDetectorSolver.currentState, + "Location index " + index); + index++; + } + + Assertions.assertEquals(solution.expectedSolution, CrystalMetalDetectorSolver.getSolution()); + } + + @Test + void findPossibleSolutions_single_location_sample_is_ignored() { + Location location = new Location(37.3, + new Vec3Comparable(779.1057116115207, 70.5, 502.2997937667801), + SolutionState.MULTIPLE, + false); + + CrystalMetalDetectorSolver.findPossibleSolutions(location.distance, location.playerPosition, false); + Assertions.assertEquals(SolutionState.NOT_STARTED, CrystalMetalDetectorSolver.previousState, + "Previous state"); + Assertions.assertEquals(SolutionState.NOT_STARTED, CrystalMetalDetectorSolver.currentState, + "Current state"); + } + + @Test + void findPossibleSolutions_currentState_becomes_previousState() { + Location location = new Location(37.3, + new Vec3Comparable(779.1057116115207, 70.5, 502.2997937667801), + SolutionState.MULTIPLE, + false); + + findPossibleSolutionsTwice(location, false); + Assertions.assertEquals(SolutionState.NOT_STARTED, CrystalMetalDetectorSolver.previousState, + "Previous state"); + Assertions.assertEquals(location.expectedState, CrystalMetalDetectorSolver.currentState, + "Current state"); + } + + @Test + void findPossibleSolutions_state_is_invalid_when_solution_and_distance_mismatch() { + Solution solution = new Solution(); + solution.center = new BlockPos(736, 88, 547); + solution.expectedSolution = new BlockPos(722, 67, 590); + solution.locations.add(new Location(67.5, + new Vec3Comparable(757.8235166144441, 68.0, 532.8037800566217), + SolutionState.FOUND_KNOWN, + true)); + // slightly different player position with invalid distance + solution.locations.add(new Location(4.0, + new Vec3Comparable(757.8235166144441, 69.0, 532.8037800566217), + SolutionState.INVALID, + true)); + checkSolution(solution); + } + + @Test + void findPossibleSolutions_state_is_failed_when_second_location_eliminates_all_blocks() { + Solution solution = new Solution(); + solution.center = new BlockPos(736, 88, 547); + solution.locations.add(new Location(29.4, + new Vec3Comparable(721.5979761606153, 68.0, 590.9056839507032), + SolutionState.MULTIPLE_KNOWN, + true)); + solution.locations.add(new Location(4.0, // actual distance should be 38.2 + new Vec3Comparable(711.858759313838, 67.0, 590.3583935310772), + SolutionState.FAILED, + true)); + checkSolution(solution); + } + + @Test + void findPossibleSolutions_state_is_found_known_when_center_found_after_location() { + Solution solution = new Solution(); + solution.center = new BlockPos(736, 88, 547); + solution.locations.add(new Location(67.5, + new Vec3Comparable(757.8235166144441, 68.0, 532.8037800566217), + SolutionState.MULTIPLE, + false)); + checkSolution(solution); + + solution.locations.get(0).centerKnown = true; + solution.locations.get(0).expectedState = SolutionState.FOUND_KNOWN; + solution.expectedSolution = new BlockPos(722, 67, 590); + checkSolution(solution); + } + + @Test + void findPossibleSolutions_state_is_found_when_single_known_location() { + Solution solution = new Solution(); + solution.center = new BlockPos(736, 88, 547); + solution.expectedSolution = new BlockPos(722, 67, 590); + solution.locations.add(new Location(67.5, + new Vec3Comparable(757.8235166144441, 68.0, 532.8037800566217), + SolutionState.FOUND_KNOWN, + true)); + checkSolution(solution); + } + + @Test + void findPossibleSolutions_states_are_correct_using_multiple_locations_with_unknown_center() { + Solution solution = new Solution(); + solution.locations.add(new Location(37.3, + new Vec3Comparable(779.1057116115207, 70.5, 502.2997937667801), + SolutionState.MULTIPLE, + false)); + solution.locations.add(new Location(34.8, + new Vec3Comparable(782.6999999880791, 71.0, 508.69999998807907), + SolutionState.FOUND, + false)); + solution.expectedSolution = new BlockPos(758, 67, 533); + + checkSolution(solution); + } + + @Test + void findPossibleSolutions_states_are_correct_when_multiple_known_locations_found() { + Solution solution = new Solution(); + + // First, validate that the solution doesn't work without the center + solution.locations.add(new Location(29.4, + new Vec3Comparable(721.5979761606153, 68.0, 590.9056839507032), + SolutionState.MULTIPLE, + false)); + solution.locations.add(new Location(38.2, + new Vec3Comparable(711.858759313838, 67.0, 590.3583935310772), + SolutionState.MULTIPLE, + false)); + checkSolution(solution); + + // Now validate that the solution works with the center + CrystalMetalDetectorSolver.resetSolution(false); + solution.locations.get(0).expectedState = SolutionState.MULTIPLE_KNOWN; + solution.locations.get(0).centerKnown = true; + solution.locations.get(1).expectedState = SolutionState.FOUND_KNOWN; + solution.locations.get(1).centerKnown = true; + solution.expectedSolution = new BlockPos(748, 66, 578); + solution.center = new BlockPos(736, 88, 547); + checkSolution(solution); + } + + private static void neuDebugLog(String message) { + System.out.println(message); + } +} diff --git a/src/test/java/io/github/moulberry/notenoughupdates/miscfeatures/CrystalWishingCompassSolverTest.java b/src/test/java/io/github/moulberry/notenoughupdates/miscfeatures/CrystalWishingCompassSolverTest.java new file mode 100644 index 00000000..ed39a505 --- /dev/null +++ b/src/test/java/io/github/moulberry/notenoughupdates/miscfeatures/CrystalWishingCompassSolverTest.java @@ -0,0 +1,1206 @@ +package io.github.moulberry.notenoughupdates.miscfeatures; + +import io.github.moulberry.notenoughupdates.core.util.Vec3Comparable; +import io.github.moulberry.notenoughupdates.miscfeatures.CrystalWishingCompassSolver.CompassTarget; +import io.github.moulberry.notenoughupdates.miscfeatures.CrystalWishingCompassSolver.HandleCompassResult; +import io.github.moulberry.notenoughupdates.miscfeatures.CrystalWishingCompassSolver.SolverState; +import io.github.moulberry.notenoughupdates.util.NEUDebugLogger; +import net.minecraft.util.BlockPos; +import net.minecraft.util.Vec3; +import net.minecraft.util.Vec3i; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collections; +import java.util.EnumSet; + +import static io.github.moulberry.notenoughupdates.miscfeatures.CrystalWishingCompassSolver.*; + +class CrystalWishingCompassSolverTest { + private static final CrystalWishingCompassSolver solver = getInstance(); + long systemTimeMillis; + private final long DELAY_AFTER_FIRST_COMPASS_LAST_PARTICLE = 500L; + + private final CompassUse minesOfDivanCompassUse1 = new CompassUse( + 1647528732979L, + new BlockPos(754, 137, 239), + new ArrayList<>(Arrays.asList( + new ParticleSpawn(new Vec3Comparable(754.358459, 138.536407, 239.200928), 137), + new ParticleSpawn(new Vec3Comparable(754.315735, 138.444351, 239.690521), 45), + new ParticleSpawn(new Vec3Comparable(754.272278, 138.352051, 240.180008), 51), + new ParticleSpawn(new Vec3Comparable(754.228760, 138.259750, 240.669479), 49), + new ParticleSpawn(new Vec3Comparable(754.185303, 138.167435, 241.158966), 57), + new ParticleSpawn(new Vec3Comparable(754.141846, 138.075134, 241.648438), 50), + new ParticleSpawn(new Vec3Comparable(754.098328, 137.982819, 242.137909), 51), + new ParticleSpawn(new Vec3Comparable(754.054871, 137.890518, 242.627396), 57), + new ParticleSpawn(new Vec3Comparable(754.011353, 137.798203, 243.116867), 44), + new ParticleSpawn(new Vec3Comparable(753.967896, 137.705887, 243.606354), 59), + new ParticleSpawn(new Vec3Comparable(753.924438, 137.613586, 244.095825), 35), + new ParticleSpawn(new Vec3Comparable(753.880920, 137.521271, 244.585297), 48), + new ParticleSpawn(new Vec3Comparable(753.837463, 137.428970, 245.074783), 70), + new ParticleSpawn(new Vec3Comparable(753.793945, 137.336655, 245.564255), 33), + new ParticleSpawn(new Vec3Comparable(753.750488, 137.244354, 246.053741), 55), + new ParticleSpawn(new Vec3Comparable(753.707031, 137.152039, 246.543213), 42), + new ParticleSpawn(new Vec3Comparable(753.663513, 137.059738, 247.032700), 56), + new ParticleSpawn(new Vec3Comparable(753.620056, 136.967422, 247.522171), 48), + new ParticleSpawn(new Vec3Comparable(753.576538, 136.875122, 248.011642), 56), + new ParticleSpawn(new Vec3Comparable(754.333618, 138.527710, 239.197800), 55) + )), + HandleCompassResult.SUCCESS, + SolverState.NEED_SECOND_COMPASS); + + private final CompassUse minesOfDivanCompassUse2 = new CompassUse( + DELAY_AFTER_FIRST_COMPASS_LAST_PARTICLE, + new BlockPos(760, 134, 266), + new ArrayList<>(Arrays.asList( + new ParticleSpawn(new Vec3Comparable(759.686951, 135.524994, 266.190704), 129), + new ParticleSpawn(new Vec3Comparable(759.625183, 135.427887, 266.677277), 69), + new ParticleSpawn(new Vec3Comparable(759.561707, 135.330704, 267.163635), 31), + new ParticleSpawn(new Vec3Comparable(759.498230, 135.233536, 267.649963), 115), + new ParticleSpawn(new Vec3Comparable(759.434753, 135.136368, 268.136322), 0), + new ParticleSpawn(new Vec3Comparable(759.371277, 135.039200, 268.622650), 46), + new ParticleSpawn(new Vec3Comparable(759.307800, 134.942017, 269.109009), 49), + new ParticleSpawn(new Vec3Comparable(759.244324, 134.844849, 269.595337), 59), + new ParticleSpawn(new Vec3Comparable(759.180847, 134.747681, 270.081696), 45), + new ParticleSpawn(new Vec3Comparable(759.117371, 134.650513, 270.568024), 39), + new ParticleSpawn(new Vec3Comparable(759.053894, 134.553329, 271.054352), 67), + new ParticleSpawn(new Vec3Comparable(758.990356, 134.456161, 271.540710), 49), + new ParticleSpawn(new Vec3Comparable(758.926880, 134.358994, 272.027039), 32), + new ParticleSpawn(new Vec3Comparable(758.863403, 134.261826, 272.513397), 61), + new ParticleSpawn(new Vec3Comparable(758.799927, 134.164642, 272.999725), 44), + new ParticleSpawn(new Vec3Comparable(758.736450, 134.067474, 273.486084), 48), + new ParticleSpawn(new Vec3Comparable(758.672974, 133.970306, 273.972412), 57), + new ParticleSpawn(new Vec3Comparable(758.609497, 133.873138, 274.458740), 55), + new ParticleSpawn(new Vec3Comparable(758.546021, 133.775955, 274.945099), 59), + new ParticleSpawn(new Vec3Comparable(758.482544, 133.678787, 275.431427), 38), + new ParticleSpawn(new Vec3Comparable(759.636658, 135.522827, 266.186371), 0) + )), + HandleCompassResult.SUCCESS, + SolverState.SOLVED); + + Vec3i minesOfDivanSolution = new Vec3i(735, 98, 451); + + private final CompassUse goblinHoldoutCompassUse1 = new CompassUse( + 1647776326763L, + new BlockPos(454, 87, 776), + new ArrayList<>(Arrays.asList( + new ParticleSpawn(new Vec3Comparable(454.171722, 88.616852, 775.807190), 188), + new ParticleSpawn(new Vec3Comparable(454.010315, 88.613464, 775.333984), 44), + new ParticleSpawn(new Vec3Comparable(453.849243, 88.610069, 774.860657), 61), + new ParticleSpawn(new Vec3Comparable(453.688141, 88.606674, 774.387329), 51), + new ParticleSpawn(new Vec3Comparable(453.527069, 88.603271, 773.914001), 40), + new ParticleSpawn(new Vec3Comparable(453.365997, 88.599876, 773.440674), 57), + new ParticleSpawn(new Vec3Comparable(453.204926, 88.596481, 772.967346), 45), + new ParticleSpawn(new Vec3Comparable(453.043854, 88.593086, 772.494019), 49), + new ParticleSpawn(new Vec3Comparable(452.882782, 88.589691, 772.020691), 46), + new ParticleSpawn(new Vec3Comparable(452.721710, 88.586288, 771.547302), 65), + new ParticleSpawn(new Vec3Comparable(452.560638, 88.582893, 771.073975), 43), + new ParticleSpawn(new Vec3Comparable(452.399567, 88.579498, 770.600647), 50), + new ParticleSpawn(new Vec3Comparable(452.238495, 88.576103, 770.127319), 48), + new ParticleSpawn(new Vec3Comparable(452.077423, 88.572701, 769.653992), 47), + new ParticleSpawn(new Vec3Comparable(451.916351, 88.569305, 769.180664), 60), + new ParticleSpawn(new Vec3Comparable(451.755280, 88.565910, 768.707336), 40), + new ParticleSpawn(new Vec3Comparable(451.594208, 88.562515, 768.234009), 69), + new ParticleSpawn(new Vec3Comparable(451.433136, 88.559120, 767.760681), 40), + new ParticleSpawn(new Vec3Comparable(451.272064, 88.555717, 767.287354), 42), + new ParticleSpawn(new Vec3Comparable(454.183441, 88.616600, 775.803040), 54) + )), + HandleCompassResult.SUCCESS, + SolverState.NEED_SECOND_COMPASS); + + private final CompassUse goblinHoldoutCompassUse2 = new CompassUse( + DELAY_AFTER_FIRST_COMPASS_LAST_PARTICLE, + new BlockPos(439, 85, 777), + new ArrayList<>(Arrays.asList( + new ParticleSpawn(new Vec3Comparable(439.068848, 86.624870, 776.043701), 136), + new ParticleSpawn(new Vec3Comparable(438.936066, 86.625786, 775.561646), 46), + new ParticleSpawn(new Vec3Comparable(438.804352, 86.626595, 775.079346), 65), + new ParticleSpawn(new Vec3Comparable(438.672699, 86.627396, 774.596985), 40), + new ParticleSpawn(new Vec3Comparable(438.541016, 86.628197, 774.114624), 51), + new ParticleSpawn(new Vec3Comparable(438.409332, 86.628998, 773.632263), 50), + new ParticleSpawn(new Vec3Comparable(438.277679, 86.629799, 773.149902), 50), + new ParticleSpawn(new Vec3Comparable(438.145996, 86.630608, 772.667603), 56), + new ParticleSpawn(new Vec3Comparable(438.014343, 86.631409, 772.185242), 40), + new ParticleSpawn(new Vec3Comparable(437.882660, 86.632210, 771.702881), 65), + new ParticleSpawn(new Vec3Comparable(437.751007, 86.633011, 771.220520), 45), + new ParticleSpawn(new Vec3Comparable(437.619324, 86.633812, 770.738159), 42), + new ParticleSpawn(new Vec3Comparable(437.487671, 86.634613, 770.255798), 60), + new ParticleSpawn(new Vec3Comparable(437.355988, 86.635414, 769.773499), 51), + new ParticleSpawn(new Vec3Comparable(437.224335, 86.636215, 769.291138), 44), + new ParticleSpawn(new Vec3Comparable(437.092651, 86.637024, 768.808777), 56), + new ParticleSpawn(new Vec3Comparable(436.960999, 86.637825, 768.326416), 56), + new ParticleSpawn(new Vec3Comparable(436.829315, 86.638626, 767.844055), 40), + new ParticleSpawn(new Vec3Comparable(436.697632, 86.639427, 767.361694), 50), + new ParticleSpawn(new Vec3Comparable(436.565979, 86.640228, 766.879395), 46), + new ParticleSpawn(new Vec3Comparable(439.108551, 86.620811, 776.031067), 0) + )), + HandleCompassResult.SUCCESS, + SolverState.SOLVED); + + Vec3i goblinHoldoutKingSolution = new Vec3i(377, 87, 550); + Vec3i goblinHoldoutQueenSolution = new Vec3i(322, 139, 769); + + private final CompassUse precursorCityCompassUse1 = new CompassUse( + 1647744920365L, + new BlockPos(570, 120, 565), + new ArrayList<>(Arrays.asList( + new ParticleSpawn(new Vec3Comparable(570.428955, 121.630745, 565.674500), 192), + new ParticleSpawn(new Vec3Comparable(570.572998, 121.642563, 566.153137), 52), + new ParticleSpawn(new Vec3Comparable(570.714233, 121.654442, 566.632629), 45), + new ParticleSpawn(new Vec3Comparable(570.855286, 121.666321, 567.112183), 51), + new ParticleSpawn(new Vec3Comparable(570.996338, 121.678200, 567.591736), 0), + new ParticleSpawn(new Vec3Comparable(571.137390, 121.690079, 568.071289), 111), + new ParticleSpawn(new Vec3Comparable(571.278442, 121.701958, 568.550781), 38), + new ParticleSpawn(new Vec3Comparable(571.419495, 121.713844, 569.030334), 51), + new ParticleSpawn(new Vec3Comparable(571.560547, 121.725723, 569.509888), 49), + new ParticleSpawn(new Vec3Comparable(571.701599, 121.737602, 569.989441), 0), + new ParticleSpawn(new Vec3Comparable(571.842651, 121.749481, 570.468994), 101), + new ParticleSpawn(new Vec3Comparable(571.983704, 121.761360, 570.948547), 53), + new ParticleSpawn(new Vec3Comparable(572.124756, 121.773239, 571.428101), 47), + new ParticleSpawn(new Vec3Comparable(572.265747, 121.785118, 571.907654), 49), + new ParticleSpawn(new Vec3Comparable(572.406799, 121.796997, 572.387207), 49), + new ParticleSpawn(new Vec3Comparable(572.547852, 121.808876, 572.866699), 51), + new ParticleSpawn(new Vec3Comparable(572.688904, 121.820755, 573.346252), 57), + new ParticleSpawn(new Vec3Comparable(572.829956, 121.832634, 573.825806), 42), + new ParticleSpawn(new Vec3Comparable(572.971008, 121.844513, 574.305359), 50), + new ParticleSpawn(new Vec3Comparable(573.112061, 121.856392, 574.784912), 52), + new ParticleSpawn(new Vec3Comparable(570.372192, 121.631874, 565.694946), 0) + )), + HandleCompassResult.SUCCESS, + SolverState.NEED_SECOND_COMPASS); + + private final CompassUse precursorCityCompassUse2 = new CompassUse( + DELAY_AFTER_FIRST_COMPASS_LAST_PARTICLE, + new BlockPos(591, 136, 579), + new ArrayList<>(Arrays.asList( + new ParticleSpawn(new Vec3Comparable(590.847961, 137.589584, 579.776672), 192), + new ParticleSpawn(new Vec3Comparable(590.918945, 137.528259, 580.267761), 50), + new ParticleSpawn(new Vec3Comparable(590.985229, 137.465118, 580.759338), 56), + new ParticleSpawn(new Vec3Comparable(591.051147, 137.401855, 581.250916), 47), + new ParticleSpawn(new Vec3Comparable(591.117126, 137.338593, 581.742493), 47), + new ParticleSpawn(new Vec3Comparable(591.183044, 137.275330, 582.234070), 49), + new ParticleSpawn(new Vec3Comparable(591.249023, 137.212067, 582.725647), 60), + new ParticleSpawn(new Vec3Comparable(591.314941, 137.148804, 583.217224), 55), + new ParticleSpawn(new Vec3Comparable(591.380920, 137.085541, 583.708801), 47), + new ParticleSpawn(new Vec3Comparable(591.446838, 137.022263, 584.200378), 50), + new ParticleSpawn(new Vec3Comparable(591.512817, 136.959000, 584.691956), 39), + new ParticleSpawn(new Vec3Comparable(591.578735, 136.895737, 585.183533), 53), + new ParticleSpawn(new Vec3Comparable(591.644714, 136.832474, 585.675110), 53), + new ParticleSpawn(new Vec3Comparable(591.710632, 136.769211, 586.166687), 45), + new ParticleSpawn(new Vec3Comparable(591.776611, 136.705948, 586.658264), 79), + new ParticleSpawn(new Vec3Comparable(591.842529, 136.642685, 587.149841), 20), + new ParticleSpawn(new Vec3Comparable(591.908508, 136.579407, 587.641418), 62), + new ParticleSpawn(new Vec3Comparable(591.974426, 136.516144, 588.132996), 48), + new ParticleSpawn(new Vec3Comparable(592.040344, 136.452881, 588.624573), 40), + new ParticleSpawn(new Vec3Comparable(592.106323, 136.389618, 589.116150), 51), + new ParticleSpawn(new Vec3Comparable(590.766357, 137.556885, 579.791565), 0) + )), + HandleCompassResult.SUCCESS, + SolverState.SOLVED); + + Vec3i precursorCitySolution = new Vec3i(604, 124, 681); + + private final CompassUse jungleCompassUse1 = new CompassUse( + 1647744980313L, + new BlockPos(454, 122, 459), + new ArrayList<>(Arrays.asList( + new ParticleSpawn(new Vec3Comparable(453.954895, 122.958122, 458.687866), 141), + new ParticleSpawn(new Vec3Comparable(453.515991, 122.760010, 458.553314), 59), + new ParticleSpawn(new Vec3Comparable(453.078156, 122.560112, 458.417877), 41), + new ParticleSpawn(new Vec3Comparable(452.640381, 122.360123, 458.282349), 50), + new ParticleSpawn(new Vec3Comparable(452.202606, 122.160133, 458.146851), 66), + new ParticleSpawn(new Vec3Comparable(451.764832, 121.960136, 458.011353), 35), + new ParticleSpawn(new Vec3Comparable(451.327057, 121.760147, 457.875854), 49), + new ParticleSpawn(new Vec3Comparable(450.889313, 121.560150, 457.740356), 50), + new ParticleSpawn(new Vec3Comparable(450.451538, 121.360161, 457.604858), 49), + new ParticleSpawn(new Vec3Comparable(450.013763, 121.160172, 457.469330), 51), + new ParticleSpawn(new Vec3Comparable(449.575989, 120.960175, 457.333832), 59), + new ParticleSpawn(new Vec3Comparable(449.138214, 120.760185, 457.198334), 41), + new ParticleSpawn(new Vec3Comparable(448.700439, 120.560196, 457.062836), 55), + new ParticleSpawn(new Vec3Comparable(448.262695, 120.360199, 456.927338), 50), + new ParticleSpawn(new Vec3Comparable(447.824921, 120.160210, 456.791840), 49), + new ParticleSpawn(new Vec3Comparable(447.387146, 119.960213, 456.656311), 53), + new ParticleSpawn(new Vec3Comparable(446.949371, 119.760223, 456.520813), 43), + new ParticleSpawn(new Vec3Comparable(446.511597, 119.560234, 456.385315), 51), + new ParticleSpawn(new Vec3Comparable(446.073853, 119.360237, 456.249817), 49), + new ParticleSpawn(new Vec3Comparable(445.636078, 119.160248, 456.114319), 56), + new ParticleSpawn(new Vec3Comparable(453.975647, 122.920158, 458.668488), 0) + )), + HandleCompassResult.SUCCESS, + SolverState.NEED_SECOND_COMPASS); + + private final CompassUse jungleCompassUse2 = new CompassUse( + DELAY_AFTER_FIRST_COMPASS_LAST_PARTICLE, + new BlockPos(438, 126, 468), + new ArrayList<>(Arrays.asList( + new ParticleSpawn(new Vec3Comparable(437.701721, 127.395279, 467.455048), 139), + new ParticleSpawn(new Vec3Comparable(437.297852, 127.161415, 467.275604), 35), + new ParticleSpawn(new Vec3Comparable(436.895813, 126.927208, 467.092529), 68), + new ParticleSpawn(new Vec3Comparable(436.493896, 126.692986, 466.909241), 41), + new ParticleSpawn(new Vec3Comparable(436.091980, 126.458763, 466.725952), 54), + new ParticleSpawn(new Vec3Comparable(435.690033, 126.224533, 466.542664), 39), + new ParticleSpawn(new Vec3Comparable(435.288116, 125.990311, 466.359375), 52), + new ParticleSpawn(new Vec3Comparable(434.886200, 125.756088, 466.176086), 66), + new ParticleSpawn(new Vec3Comparable(434.484283, 125.521866, 465.992767), 40), + new ParticleSpawn(new Vec3Comparable(434.082367, 125.287636, 465.809479), 41), + new ParticleSpawn(new Vec3Comparable(433.680420, 125.053413, 465.626190), 50), + new ParticleSpawn(new Vec3Comparable(433.278503, 124.819191, 465.442902), 59), + new ParticleSpawn(new Vec3Comparable(432.876587, 124.584969, 465.259613), 54), + new ParticleSpawn(new Vec3Comparable(432.474670, 124.350746, 465.076294), 38), + new ParticleSpawn(new Vec3Comparable(432.072723, 124.116516, 464.893005), 63), + new ParticleSpawn(new Vec3Comparable(431.670807, 123.882294, 464.709717), 36), + new ParticleSpawn(new Vec3Comparable(431.268890, 123.648071, 464.526428), 64), + new ParticleSpawn(new Vec3Comparable(430.866974, 123.413849, 464.343140), 48), + new ParticleSpawn(new Vec3Comparable(430.465057, 123.179619, 464.159821), 53), + new ParticleSpawn(new Vec3Comparable(430.063110, 122.945396, 463.976532), 46), + new ParticleSpawn(new Vec3Comparable(437.732666, 127.385803, 467.381592), 1) + )), + HandleCompassResult.SUCCESS, + SolverState.SOLVED); + + Vec3i jungleSolution = new Vec3i(343, 72, 424); + Vec3i jungleSolutionTempleDoor = new Vec3i( + jungleSolution.getX() - 57, + jungleSolution.getY() + 36, + jungleSolution.getZ() -21); + + private final CompassUse magmaCompassUse1 = new CompassUse( + 1647745029814L, + new BlockPos(462, 58, 550), + new ArrayList<>(Arrays.asList( + new ParticleSpawn(new Vec3Comparable(462.226898, 59.614380, 550.032654), 160), + new ParticleSpawn(new Vec3Comparable(462.693848, 59.609089, 549.853943), 47), + new ParticleSpawn(new Vec3Comparable(463.160706, 59.603809, 549.674988), 48), + new ParticleSpawn(new Vec3Comparable(463.627533, 59.598526, 549.496033), 136), + new ParticleSpawn(new Vec3Comparable(464.094391, 59.593246, 549.317017), 0), + new ParticleSpawn(new Vec3Comparable(464.561218, 59.587963, 549.138062), 0), + new ParticleSpawn(new Vec3Comparable(465.028076, 59.582684, 548.959106), 53), + new ParticleSpawn(new Vec3Comparable(465.494904, 59.577400, 548.780090), 48), + new ParticleSpawn(new Vec3Comparable(465.961761, 59.572117, 548.601135), 55), + new ParticleSpawn(new Vec3Comparable(466.428589, 59.566837, 548.422180), 47), + new ParticleSpawn(new Vec3Comparable(466.895416, 59.561554, 548.243164), 46), + new ParticleSpawn(new Vec3Comparable(467.362274, 59.556274, 548.064209), 53), + new ParticleSpawn(new Vec3Comparable(467.829102, 59.550991, 547.885254), 50), + new ParticleSpawn(new Vec3Comparable(468.295959, 59.545712, 547.706238), 54), + new ParticleSpawn(new Vec3Comparable(468.762787, 59.540428, 547.527283), 52), + new ParticleSpawn(new Vec3Comparable(469.229645, 59.535145, 547.348328), 105), + new ParticleSpawn(new Vec3Comparable(469.696472, 59.529865, 547.169312), 1), + new ParticleSpawn(new Vec3Comparable(470.163300, 59.524582, 546.990356), 51), + new ParticleSpawn(new Vec3Comparable(470.630157, 59.519302, 546.811401), 40), + new ParticleSpawn(new Vec3Comparable(471.096985, 59.514019, 546.632385), 49), + new ParticleSpawn(new Vec3Comparable(462.221954, 59.614719, 550.019165), 0) + )), + HandleCompassResult.SUCCESS, + SolverState.NEED_SECOND_COMPASS); + + private final CompassUse magmaCompassUse2 = new CompassUse( + DELAY_AFTER_FIRST_COMPASS_LAST_PARTICLE, + new BlockPos(449, 53, 556), + new ArrayList<>(Arrays.asList( + new ParticleSpawn(new Vec3Comparable(449.120911, 54.624340, 556.108948), 204), + new ParticleSpawn(new Vec3Comparable(449.587433, 54.627399, 555.929138), 102), + new ParticleSpawn(new Vec3Comparable(450.053741, 54.630432, 555.748657), 0), + new ParticleSpawn(new Vec3Comparable(450.520020, 54.633465, 555.568237), 62), + new ParticleSpawn(new Vec3Comparable(450.986298, 54.636497, 555.387756), 38), + new ParticleSpawn(new Vec3Comparable(451.452606, 54.639530, 555.207275), 48), + new ParticleSpawn(new Vec3Comparable(451.918884, 54.642563, 555.026794), 63), + new ParticleSpawn(new Vec3Comparable(452.385162, 54.645596, 554.846375), 52), + new ParticleSpawn(new Vec3Comparable(452.851471, 54.648628, 554.665894), 35), + new ParticleSpawn(new Vec3Comparable(453.317749, 54.651661, 554.485413), 53), + new ParticleSpawn(new Vec3Comparable(453.784027, 54.654694, 554.304993), 54), + new ParticleSpawn(new Vec3Comparable(454.250305, 54.657726, 554.124512), 50), + new ParticleSpawn(new Vec3Comparable(454.716614, 54.660759, 553.944031), 55), + new ParticleSpawn(new Vec3Comparable(455.182892, 54.663792, 553.763550), 49), + new ParticleSpawn(new Vec3Comparable(455.649170, 54.666824, 553.583130), 41), + new ParticleSpawn(new Vec3Comparable(456.115479, 54.669857, 553.402649), 48), + new ParticleSpawn(new Vec3Comparable(456.581757, 54.672890, 553.222168), 54), + new ParticleSpawn(new Vec3Comparable(457.048035, 54.675922, 553.041687), 45), + new ParticleSpawn(new Vec3Comparable(457.514313, 54.678959, 552.861267), 55), + new ParticleSpawn(new Vec3Comparable(449.110443, 54.623035, 556.079163), 49) + )), + HandleCompassResult.SUCCESS, + SolverState.SOLVED); + + Vec3i magmaSolution = new Vec3i(737, 56, 444); + + Vec3Comparable kingMinesOrNucleusCoordsInRemnants = new Vec3Comparable(604, 100, 681); + Vec3Comparable odawaSolution = new Vec3Comparable(349, 110, 390); + + private final CompassUse nucleusCompass = new CompassUse( + 1647745029814L, + new BlockPos(512, 106, 512), + null, + HandleCompassResult.PLAYER_IN_NUCLEUS, + SolverState.NOT_STARTED); + + private void resetSolverState() { + solver.initWorld(); + systemTimeMillis = 0; + solver.currentTimeMillis = () -> (systemTimeMillis); + // These must be overridden for all test cases or an exception will be thrown when + // data that is only present when running in the context of Minecraft is accessed. + solver.keyInInventory = () -> false; + solver.kingsScentPresent = () -> false; + solver.foundCrystals = () -> EnumSet.noneOf(Crystal.class); + } + + @BeforeEach + void setUp() { + NEUDebugLogger.logMethod = CrystalWishingCompassSolverTest::neuDebugLog; + NEUDebugLogger.allFlagsEnabled = true; + resetSolverState(); + } + + private void checkSolution(Solution solution) { + int index = 0; + for (CompassUse compassUse : solution.compassUses) { + systemTimeMillis += compassUse.timeIncrementMillis; + HandleCompassResult handleCompassResult = solver.handleCompassUse(compassUse.playerPos); + Assertions.assertEquals(compassUse.expectedHandleCompassUseResult, + handleCompassResult, + "CompassUse index " + index); + + for (ParticleSpawn particle : compassUse.particles) { + systemTimeMillis += particle.timeIncrementMillis; + solver.solveUsingParticle( + particle.spawnLocation.xCoord, + particle.spawnLocation.yCoord, + particle.spawnLocation.zCoord, + systemTimeMillis); + } + + Assertions.assertEquals(compassUse.expectedSolverState, + solver.getSolverState(), + "CompassUse index " + index); + if (compassUse.expectedSolverState == SolverState.SOLVED) { + Assertions.assertEquals(solution.expectedSolutionCoords, + solver.getSolutionCoords()); + } + + index++; + } + } + + @Test + void first_compass_without_particles_sets_solver_state_to_processing_first_use() { + // Arrange + CompassUse compassUse = new CompassUse(minesOfDivanCompassUse1); + compassUse.particles.clear(); + compassUse.expectedSolverState = SolverState.PROCESSING_FIRST_USE; + + Solution solution = new Solution( + new ArrayList<>(Collections.singletonList(compassUse)), + Vec3i.NULL_VECTOR); + + // Act & Assert + checkSolution(solution); + } + + @Test + void new_compass_resets_processing_first_use_state_after_timeout() { + // Arrange + CompassUse processingFirstUseCompassUse = new CompassUse(minesOfDivanCompassUse1); + processingFirstUseCompassUse.particles.clear(); + processingFirstUseCompassUse.expectedSolverState = SolverState.PROCESSING_FIRST_USE; + Solution processingFirstUseSolution = new Solution( + new ArrayList<>(Collections.singletonList(processingFirstUseCompassUse)), + Vec3i.NULL_VECTOR); + checkSolution(processingFirstUseSolution); + Assertions.assertEquals(SolverState.PROCESSING_FIRST_USE, solver.getSolverState()); + + CompassUse resetStateCompassUse = new CompassUse(jungleCompassUse1); + resetStateCompassUse.timeIncrementMillis = ALL_PARTICLES_MAX_MILLIS + 1; + resetStateCompassUse.expectedHandleCompassUseResult = HandleCompassResult.NO_PARTICLES_FOR_PREVIOUS_COMPASS; + resetStateCompassUse.expectedSolverState = SolverState.FAILED_TIMEOUT_NO_REPEATING; + Solution goodSolution = new Solution( + new ArrayList<>(Collections.singletonList(resetStateCompassUse)), + Vec3i.NULL_VECTOR); + + // Act & Assert + checkSolution(goodSolution); + } + + @Test + void first_compass_with_repeating_particles_sets_state_to_need_second_compass() { + // Arrange + Solution solution = new Solution( + new ArrayList<>(Collections.singletonList(minesOfDivanCompassUse1)), + Vec3i.NULL_VECTOR); + + // Act & Assert + checkSolution(solution); + } + + @Test + void first_compass_in_nucleus_sets_state_to_player_in_nucleus() { + // Arrange + Solution solution = new Solution( + new ArrayList<>(Collections.singletonList(nucleusCompass)), + Vec3i.NULL_VECTOR); + + // Act & Assert + checkSolution(solution); + } + + @Test + void use_while_handling_previous_returns_still_processing_first_use() { + // Arrange + CompassUse compassUse1 = new CompassUse( + 1647528732979L, + new BlockPos(754, 137, 239), + new ArrayList<>(Collections.singletonList( + new ParticleSpawn(new Vec3Comparable(754.358459, 138.536407, 239.200928), 137) + )), + HandleCompassResult.SUCCESS, + SolverState.PROCESSING_FIRST_USE); + + // STILL_PROCESSING_FIRST_USE is expected instead of LOCATION_TOO_CLOSE since the solver + // isn't ready for the second compass use, which includes the location check + CompassUse compassUse2 = new CompassUse(compassUse1); + compassUse2.expectedHandleCompassUseResult = HandleCompassResult.STILL_PROCESSING_PRIOR_USE; + compassUse2.timeIncrementMillis = 500; + + Solution solution = new Solution( + new ArrayList<>(Arrays.asList(compassUse1, compassUse2)), + Vec3i.NULL_VECTOR); + + // Act & Assert + checkSolution(solution); + } + + @Test + void missing_repeating_particles_sets_state_to_failed_timeout_no_repeating() { + CompassUse compassUse = new CompassUse(minesOfDivanCompassUse1); + compassUse.particles.remove(compassUse.particles.size()-1); + compassUse.particles.get(compassUse.particles.size()-1).timeIncrementMillis += ALL_PARTICLES_MAX_MILLIS; + compassUse.expectedSolverState = SolverState.FAILED_TIMEOUT_NO_REPEATING; + + Solution solution = new Solution( + new ArrayList<>(Collections.singletonList(compassUse)), + Vec3i.NULL_VECTOR); + + // Act & Assert + checkSolution(solution); + } + + @Test + void compasses_too_close_returns_location_too_close_and_solver_state_is_still_need_second_compass() { + // Arrange + CompassUse secondCompassUse = new CompassUse( + DELAY_AFTER_FIRST_COMPASS_LAST_PARTICLE, + minesOfDivanCompassUse1.playerPos.add(2, 2, 2), + null, + HandleCompassResult.LOCATION_TOO_CLOSE, + SolverState.NEED_SECOND_COMPASS + ); + + Solution solution = new Solution( + new ArrayList<>(Arrays.asList(minesOfDivanCompassUse1, secondCompassUse)), + Vec3i.NULL_VECTOR); + + // Act & Assert + checkSolution(solution); + } + + @Test + void second_compass_sets_solver_state_to_processing_second_use() { + // Arrange + CompassUse secondCompassUse = new CompassUse(minesOfDivanCompassUse2); + secondCompassUse.expectedSolverState = SolverState.PROCESSING_SECOND_USE; + secondCompassUse.particles.clear(); + + // Arrange + Solution solution = new Solution( + new ArrayList<>(Arrays.asList(minesOfDivanCompassUse1, minesOfDivanCompassUse2)), + minesOfDivanSolution + ); + + // Act & Assert + checkSolution(solution); + } + + @Test + void second_compass_with_repeating_particles_sets_state_to_solved() { + // Arrange + Solution solution = new Solution( + new ArrayList<>(Arrays.asList(minesOfDivanCompassUse1, minesOfDivanCompassUse2)), + minesOfDivanSolution + ); + + // Act & Assert + checkSolution(solution); + } + + @Test + void particles_from_first_compass_are_ignored_by_second_compass() { + // Arrange + CompassUse compassUse2 = new CompassUse(minesOfDivanCompassUse2); + compassUse2.particles.add(0, minesOfDivanCompassUse1.particles.get(0)); + Solution solution = new Solution( + new ArrayList<>(Arrays.asList(minesOfDivanCompassUse1, compassUse2)), + minesOfDivanSolution + ); + + // Act & Assert + checkSolution(solution); + } + + private void execInvalidParticlesInvalidSolution() { + // Arrange + CompassUse compassUse2 = new CompassUse(minesOfDivanCompassUse2); + + // reverse the direction of the particles, moving the repeat particle + // to "new" end + compassUse2.particles.remove(compassUse2.particles.size()-1); + Collections.reverse(compassUse2.particles); + // add a new repeat particle + compassUse2.particles.add(new ParticleSpawn(compassUse2.particles.get(0))); + + // Adjust the player position + compassUse2.playerPos = new BlockPos(compassUse2.particles.get(0).spawnLocation); + compassUse2.expectedSolverState = SolverState.FAILED_INVALID_SOLUTION; + Solution solution = new Solution( + new ArrayList<>(Arrays.asList(minesOfDivanCompassUse1, compassUse2)), + Vec3i.NULL_VECTOR); + + // Act & Assert + checkSolution(solution); + } + + @Test + void second_compass_with_inverted_particles_sets_state_to_invalid_solution() { + // Arrange, Act, and Assert + execInvalidParticlesInvalidSolution(); + } + + @Test + void solution_outside_hollows_sets_state_to_invalid_solution() { + // Arrange + CompassUse compassUse1 = new CompassUse(minesOfDivanCompassUse1); + CompassUse compassUse2 = new CompassUse(minesOfDivanCompassUse2); + Vec3 offset = new Vec3(0.0, 200.0, 0.0); + + compassUse1.playerPos = compassUse1.playerPos.add(offset.xCoord, offset.yCoord, offset.zCoord); + for (ParticleSpawn particle : compassUse1.particles) { + particle.spawnLocation = particle.spawnLocation.add(offset); + } + + compassUse2.playerPos = compassUse2.playerPos.add(offset.xCoord, offset.yCoord, offset.zCoord); + for (ParticleSpawn particle : compassUse2.particles) { + particle.spawnLocation = particle.spawnLocation.add(offset); + } + compassUse2.expectedSolverState = SolverState.FAILED_INVALID_SOLUTION; + + Solution solution = new Solution( + new ArrayList<>(Arrays.asList(compassUse1, compassUse2)), + Vec3i.NULL_VECTOR); + + // Act & Assert + checkSolution(solution); + } + + @Test + void second_solution_can_be_solved_after_state_is_solved() { + // Arrange + Solution solution = new Solution( + new ArrayList<>(Arrays.asList(minesOfDivanCompassUse1, minesOfDivanCompassUse2)), + minesOfDivanSolution + ); + checkSolution(solution); + + Solution solution2 = new Solution( + new ArrayList<>(Arrays.asList(precursorCityCompassUse1, precursorCityCompassUse2)), + precursorCitySolution + ); + + // Act & Assert + checkSolution(solution2); + } + + @Test + void second_solution_can_be_solved_after_state_is_failed() { + // Arrange + execInvalidParticlesInvalidSolution(); + Assertions.assertEquals(solver.getSolverState(), SolverState.FAILED_INVALID_SOLUTION); + + Solution solution2 = new Solution( + new ArrayList<>(Arrays.asList(precursorCityCompassUse1, precursorCityCompassUse2)), + precursorCitySolution + ); + + // Act & Assert + checkSolution(solution2); + } + + @Test + void distant_particles_are_ignored() { + // Arrange + CompassUse compassUse = new CompassUse(minesOfDivanCompassUse1); + compassUse.particles.get(2).spawnLocation.addVector(100.0, 100.0, 100.0); + Solution solution = new Solution( + new ArrayList<>(Collections.singletonList(minesOfDivanCompassUse1)), + Vec3i.NULL_VECTOR); + + // Act & Assert + checkSolution(solution); + } + + @Test + void possible_targets_includes_queen_and_excludes_king_when_kings_scent_is_present() { + // Arrange + Solution solution = new Solution( + new ArrayList<>(Collections.singletonList(goblinHoldoutCompassUse1)), + Vec3i.NULL_VECTOR); + solver.kingsScentPresent = () -> true; + + // Act + checkSolution(solution); + EnumSet<CompassTarget> targets = solver.getPossibleTargets(); + + // Assert + Assertions.assertTrue(targets.contains(CompassTarget.GOBLIN_QUEEN)); + Assertions.assertFalse(targets.contains(CompassTarget.GOBLIN_KING)); + } + + @Test + void possible_targets_excludes_king_and_includes_queen_when_kings_scent_is_not_present() { + // Arrange + Solution solution = new Solution( + new ArrayList<>(Collections.singletonList(goblinHoldoutCompassUse1)), + Vec3i.NULL_VECTOR); + solver.kingsScentPresent = () -> false; + + // Act + checkSolution(solution); + EnumSet<CompassTarget> targets = solver.getPossibleTargets(); + + // Assert + Assertions.assertFalse(targets.contains(CompassTarget.GOBLIN_QUEEN)); + Assertions.assertTrue(targets.contains(CompassTarget.GOBLIN_KING)); + } + + @Test + void possible_targets_excludes_odawa_and_includes_temple_when_key_in_inventory() { + // Arrange + Solution solution = new Solution( + new ArrayList<>(Collections.singletonList(jungleCompassUse1)), + Vec3i.NULL_VECTOR); + solver.keyInInventory = () -> true; + + // Act + checkSolution(solution); + EnumSet<CompassTarget> targets = solver.getPossibleTargets(); + + // Assert + Assertions.assertFalse(targets.contains(CompassTarget.ODAWA)); + Assertions.assertTrue(targets.contains(CompassTarget.JUNGLE_TEMPLE)); + } + + @Test + void possible_targets_includes_odawa_and_excludes_temple_when_key_not_in_inventory() { + // Arrange + Solution solution = new Solution( + new ArrayList<>(Collections.singletonList(jungleCompassUse1)), + Vec3i.NULL_VECTOR); + solver.keyInInventory = () -> false; + + // Act + checkSolution(solution); + EnumSet<CompassTarget> targets = solver.getPossibleTargets(); + + // Assert + Assertions.assertTrue(targets.contains(CompassTarget.ODAWA)); + Assertions.assertFalse(targets.contains(CompassTarget.JUNGLE_TEMPLE)); + } + + @Test + void possible_targets_only_contains_city_and_nucleus_when_in_remnants_without_sapphire_crystal() { + // Arrange + Solution solution = new Solution( + new ArrayList<>(Collections.singletonList(precursorCityCompassUse1)), + Vec3i.NULL_VECTOR); + + // Act + checkSolution(solution); + EnumSet<CompassTarget> targets = solver.getPossibleTargets(); + + // Assert + Assertions.assertTrue(targets.contains(CompassTarget.PRECURSOR_CITY)); + Assertions.assertTrue(targets.contains(CompassTarget.CRYSTAL_NUCLEUS)); + Assertions.assertEquals(2, targets.size()); + } + + @Test + void possible_targets_only_contains_mines_and_nucleus_when_in_deposits_without_jade_crystal() { + // Arrange + Solution solution = new Solution( + new ArrayList<>(Collections.singletonList(minesOfDivanCompassUse1)), + Vec3i.NULL_VECTOR); + + // Act + checkSolution(solution); + EnumSet<CompassTarget> targets = solver.getPossibleTargets(); + + // Assert + Assertions.assertTrue(targets.contains(CompassTarget.MINES_OF_DIVAN)); + Assertions.assertTrue(targets.contains(CompassTarget.CRYSTAL_NUCLEUS)); + Assertions.assertEquals(2, targets.size()); + } + + @Test + void possible_targets_only_contains_king_or_queen_and_nucleus_when_in_holdout_without_crystal() { + // Arrange + Solution solution = new Solution( + new ArrayList<>(Collections.singletonList(goblinHoldoutCompassUse1)), + Vec3i.NULL_VECTOR); + + // Act + checkSolution(solution); + EnumSet<CompassTarget> targets = solver.getPossibleTargets(); + + // Assert + Assertions.assertTrue(targets.contains(CompassTarget.GOBLIN_KING) || + targets.contains(CompassTarget.GOBLIN_QUEEN)); + Assertions.assertTrue(targets.contains(CompassTarget.CRYSTAL_NUCLEUS)); + Assertions.assertEquals(2, targets.size()); + } + + @Test + void possible_targets_only_contains_king_and_odawa_and_nucleus_when_in_jungle_without_crystal_or_key() { + // Arrange + Solution solution = new Solution( + new ArrayList<>(Collections.singletonList(jungleCompassUse1)), + Vec3i.NULL_VECTOR); + + // Act + checkSolution(solution); + EnumSet<CompassTarget> targets = solver.getPossibleTargets(); + + // Assert + Assertions.assertTrue(targets.contains(CompassTarget.GOBLIN_KING)); + Assertions.assertTrue(targets.contains(CompassTarget.ODAWA)); + Assertions.assertTrue(targets.contains(CompassTarget.CRYSTAL_NUCLEUS)); + Assertions.assertEquals(3, targets.size()); + } + + @Test + void possible_targets_only_contains_bal_and_nucleus_when_in_magma_fields_without_crystal() { + // Arrange + Solution solution = new Solution( + new ArrayList<>(Collections.singletonList(magmaCompassUse1)), + Vec3i.NULL_VECTOR); + + // Act + checkSolution(solution); + EnumSet<CompassTarget> targets = solver.getPossibleTargets(); + + // Assert + Assertions.assertTrue(targets.contains(CompassTarget.BAL)); + Assertions.assertTrue(targets.contains(CompassTarget.CRYSTAL_NUCLEUS)); + Assertions.assertEquals(2, targets.size()); + } + + private void CheckExcludedTargetsForCrystals( + CompassUse compassUseToExecute, + ArrayList<CompassTarget> excludedTargets, + EnumSet<Crystal> foundCrystals) { + // Arrange + EnumSet<CompassTarget> targets; + Solution solution = new Solution( + new ArrayList<>(Collections.singletonList(compassUseToExecute)), + Vec3i.NULL_VECTOR); + + // Act + checkSolution(solution); + targets = solver.getPossibleTargets(); + boolean targetFound = false; + for (CompassTarget target : excludedTargets) { + if (targets.contains(target)) { + targetFound = true; + break; + } + } + Assertions.assertTrue(targetFound); + + resetSolverState(); + solver.foundCrystals = () -> foundCrystals; + checkSolution(solution); + targets = solver.getPossibleTargets(); + + // Assert + for (CompassTarget target : excludedTargets) { + Assertions.assertFalse(targets.contains(target)); + } + } + + @Test + void possible_targets_excludes_king_and_queen_when_amber_crystal_found() { + ArrayList<CompassTarget> excludedTargets = new ArrayList<>(Arrays.asList( + CompassTarget.GOBLIN_KING, + CompassTarget.GOBLIN_QUEEN + )); + CheckExcludedTargetsForCrystals(goblinHoldoutCompassUse1, excludedTargets, EnumSet.of(Crystal.AMBER)); + } + + @Test + void possible_targets_excludes_odawa_and_temple_when_amethyst_crystal_found() { + ArrayList<CompassTarget> excludedTargets = new ArrayList<>(Arrays.asList( + CompassTarget.ODAWA, + CompassTarget.JUNGLE_TEMPLE)); + CheckExcludedTargetsForCrystals(jungleCompassUse1, excludedTargets, EnumSet.of(Crystal.AMETHYST)); + } + + @Test + void possible_targets_excludes_mines_when_jade_crystal_found() { + ArrayList<CompassTarget> excludedTargets = new ArrayList<>(Collections.singletonList( + CompassTarget.MINES_OF_DIVAN)); + CheckExcludedTargetsForCrystals(minesOfDivanCompassUse1, excludedTargets, EnumSet.of(Crystal.JADE)); + } + + @Test + void possible_targets_excludes_city_when_sapphire_crystal_found() { + ArrayList<CompassTarget> excludedTargets = new ArrayList<>(Collections.singletonList( + CompassTarget.PRECURSOR_CITY)); + CheckExcludedTargetsForCrystals(precursorCityCompassUse1, excludedTargets, EnumSet.of(Crystal.SAPPHIRE)); + } + + @Test + void possible_targets_excludes_bal_when_topaz_crystal_found() { + ArrayList<CompassTarget> excludedTargets = new ArrayList<>(Collections.singletonList( + CompassTarget.BAL)); + CheckExcludedTargetsForCrystals(magmaCompassUse1, excludedTargets, EnumSet.of(Crystal.TOPAZ)); + } + + @Test + void solver_resets_when_possible_targets_change_based_on_found_crystals() { + // Arrange + Solution solution = new Solution( + new ArrayList<>(Collections.singletonList(minesOfDivanCompassUse1)), + Vec3i.NULL_VECTOR); + + // Act + checkSolution(solution); + systemTimeMillis += minesOfDivanCompassUse2.timeIncrementMillis; + solver.foundCrystals = () -> EnumSet.of(Crystal.JADE); + HandleCompassResult handleCompassResult = solver.handleCompassUse(minesOfDivanCompassUse2.playerPos); + + // Assert + Assertions.assertEquals(HandleCompassResult.POSSIBLE_TARGETS_CHANGED, handleCompassResult); + Assertions.assertEquals(SolverState.NOT_STARTED, solver.getSolverState()); + } + + @Test + void solver_resets_when_possible_targets_change_based_on_location() { + // Arrange + Solution solution = new Solution( + new ArrayList<>(Collections.singletonList(minesOfDivanCompassUse1)), + Vec3i.NULL_VECTOR); + + // Act + checkSolution(solution); + systemTimeMillis += minesOfDivanCompassUse2.timeIncrementMillis; + BlockPos newLocation = minesOfDivanCompassUse2.playerPos.add(-400, 0 ,0); + HandleCompassResult handleCompassResult = solver.handleCompassUse(newLocation); + + // Assert + Assertions.assertEquals(HandleCompassResult.POSSIBLE_TARGETS_CHANGED, handleCompassResult); + Assertions.assertEquals(SolverState.NOT_STARTED, solver.getSolverState()); + } + + @Test + void mines_of_divan_solution_is_solved() { + // Arrange + Solution solution = new Solution( + new ArrayList<>(Arrays.asList(minesOfDivanCompassUse1, minesOfDivanCompassUse2)), + minesOfDivanSolution + ); + + // Act & Assert + checkSolution(solution); + } + + @Test + void jungle_temple_solution_with_key_in_inventory_is_solved() { + // Arrange + Solution solution = new Solution( + new ArrayList<>(Arrays.asList(jungleCompassUse1, jungleCompassUse2)), + jungleSolutionTempleDoor + ); + solver.keyInInventory = () -> true; + + // Act & Assert + checkSolution(solution); + } + + @Test + void jungle_temple_solution_is_solved() { + // Arrange + Solution solution = new Solution( + new ArrayList<>(Arrays.asList(jungleCompassUse1, jungleCompassUse2)), + jungleSolution + ); + + // Act & Assert + checkSolution(solution); + } + + @Test + void precursor_city_solution_is_solved() { + // Arrange + Solution solution = new Solution( + new ArrayList<>(Arrays.asList(precursorCityCompassUse1, precursorCityCompassUse2)), + precursorCitySolution + ); + + // Act & Assert + checkSolution(solution); + } + + @Test + void goblin_king_solution_is_solved() { + // Arrange + Solution solution = new Solution( + new ArrayList<>(Arrays.asList(goblinHoldoutCompassUse1, goblinHoldoutCompassUse2)), + goblinHoldoutKingSolution + ); + + // Act & Assert + checkSolution(solution); + } + + @Test + void bal_solution_is_solved() { + // Arrange + Solution solution = new Solution( + new ArrayList<>(Arrays.asList(magmaCompassUse1, magmaCompassUse2)), + magmaSolution + ); + + // Act & Assert + checkSolution(solution); + } + + EnumSet<CompassTarget> GetSolutionTargetsHelper( + EnumSet<CompassTarget> possibleTargets, + Vec3Comparable solutionCoords, + int expectedSolutionCount) { + EnumSet<CompassTarget> solutionTargets = + CrystalWishingCompassSolver.getSolutionTargets(possibleTargets, solutionCoords); + Assertions.assertEquals(expectedSolutionCount, solutionTargets.size()); + return solutionTargets; + } + + @Test + void solutionPossibleTargets_removes_nucleus_when_coords_not_in_nucleus() { + // Arrange & Act + EnumSet<CompassTarget> solutionTargets = GetSolutionTargetsHelper( + EnumSet.allOf(CompassTarget.class), + new Vec3Comparable(minesOfDivanSolution), + 2); + + //Assert + Assertions.assertFalse(solutionTargets.contains(CompassTarget.CRYSTAL_NUCLEUS)); + } + + @Test + void solutionPossibleTargets_includes_adjacent_zones() { + // Arrange & Act + EnumSet<CompassTarget> solutionTargets = GetSolutionTargetsHelper( + EnumSet.allOf(CompassTarget.class), + kingMinesOrNucleusCoordsInRemnants, + 2); + + //Assert + Assertions.assertTrue(solutionTargets.contains(CompassTarget.GOBLIN_KING)); + Assertions.assertTrue(solutionTargets.contains(CompassTarget.MINES_OF_DIVAN)); + } + + @Test + void solutionPossibleTargets_skips_y_filtering_when_single_possible_target() { + // Arrange & Act + EnumSet<CompassTarget> solutionTargets = GetSolutionTargetsHelper( + EnumSet.of(CompassTarget.GOBLIN_QUEEN), + new Vec3Comparable(goblinHoldoutKingSolution), // Coords not valid for queen + 1); + + //Assert + Assertions.assertTrue(solutionTargets.contains(CompassTarget.GOBLIN_QUEEN)); + } + + @Test + void solutionPossibleTargets_still_filters_non_adjacent_when_single_possible_target() { + // Arrange, Act and Assert + GetSolutionTargetsHelper( + EnumSet.of(CompassTarget.ODAWA), + kingMinesOrNucleusCoordsInRemnants, + 0); + } + + @Test + void solutionPossibleTargets_includes_king_based_on_y_coordinate() { + // Arrange & Act + EnumSet<CompassTarget> possibleTargets = EnumSet.allOf(CompassTarget.class); + possibleTargets.remove(CompassTarget.ODAWA); + EnumSet<CompassTarget> solutionTargets = GetSolutionTargetsHelper( + possibleTargets, + new Vec3Comparable(goblinHoldoutKingSolution), + 1); + + //Assert + Assertions.assertTrue(solutionTargets.contains(CompassTarget.GOBLIN_KING)); + } + + @Test + void solutionPossibleTargets_includes_odawa_based_on_y_coordinate() { + // Arrange & Act + // Arrange & Act + EnumSet<CompassTarget> possibleTargets = EnumSet.allOf(CompassTarget.class); + possibleTargets.remove(CompassTarget.GOBLIN_KING); + EnumSet<CompassTarget> solutionTargets = GetSolutionTargetsHelper( + possibleTargets, + new Vec3Comparable(odawaSolution), + 1); + + //Assert + Assertions.assertTrue(solutionTargets.contains(CompassTarget.ODAWA)); + } + + @Test + void solutionPossibleTargets_includes_mines_based_on_y_coordinate() { + // Arrange & Act + EnumSet<CompassTarget> possibleTargets = EnumSet.allOf(CompassTarget.class); + possibleTargets.remove(CompassTarget.ODAWA); + EnumSet<CompassTarget> solutionTargets = GetSolutionTargetsHelper( + possibleTargets, + new Vec3Comparable(minesOfDivanSolution), + 1); + + //Assert + Assertions.assertTrue(solutionTargets.contains(CompassTarget.MINES_OF_DIVAN)); + } + + @Test + void solutionPossibleTargets_includes_temple_based_on_y_coordinate() { + // Arrange & Act + EnumSet<CompassTarget> possibleTargets = EnumSet.allOf(CompassTarget.class); + possibleTargets.remove(CompassTarget.BAL); + possibleTargets.remove(CompassTarget.ODAWA); + possibleTargets.remove(CompassTarget.GOBLIN_KING); + EnumSet<CompassTarget> solutionTargets = GetSolutionTargetsHelper( + possibleTargets, + new Vec3Comparable(jungleSolution), + 1); + + //Assert + Assertions.assertTrue(solutionTargets.contains(CompassTarget.JUNGLE_TEMPLE)); + } + + @Test + void solutionPossibleTargets_includes_queen_based_on_y_coordinate() { + // Arrange & Act + EnumSet<CompassTarget> possibleTargets = EnumSet.allOf(CompassTarget.class); + possibleTargets.remove(CompassTarget.GOBLIN_KING); + possibleTargets.remove(CompassTarget.ODAWA); + EnumSet<CompassTarget> solutionTargets = GetSolutionTargetsHelper( + possibleTargets, + new Vec3Comparable(goblinHoldoutQueenSolution), + 1); + + //Assert + Assertions.assertTrue(solutionTargets.contains(CompassTarget.GOBLIN_QUEEN)); + } + + @Test + void solutionPossibleTargets_includes_city_based_on_y_coordinate() { + // Arrange & Act + EnumSet<CompassTarget> possibleTargets = EnumSet.allOf(CompassTarget.class); + possibleTargets.remove(CompassTarget.GOBLIN_KING); + EnumSet<CompassTarget> solutionTargets = GetSolutionTargetsHelper( + possibleTargets, + new Vec3Comparable(precursorCitySolution), + 1); + + //Assert + Assertions.assertTrue(solutionTargets.contains(CompassTarget.PRECURSOR_CITY)); + } + + @Test + void solutionPossibleTargets_includes_bal_based_on_y_coordinate() { + // Arrange & Act + EnumSet<CompassTarget> solutionTargets = GetSolutionTargetsHelper( + EnumSet.allOf(CompassTarget.class), + new Vec3Comparable(magmaSolution), + 1); + + //Assert + Assertions.assertTrue(solutionTargets.contains(CompassTarget.BAL)); + } + + // Represents a particle spawn, including: + // - Milliseconds to increment the "system time" prior to spawn. + // - The particle spawn location. + static class ParticleSpawn { + long timeIncrementMillis; + Vec3Comparable spawnLocation; + + ParticleSpawn(Vec3Comparable spawnLocation, long timeIncrementMillis) { + this.timeIncrementMillis = timeIncrementMillis; + this.spawnLocation = spawnLocation; + } + + ParticleSpawn(ParticleSpawn source) { + timeIncrementMillis = source.timeIncrementMillis; + spawnLocation = new Vec3Comparable(source.spawnLocation); + } + } + + // Represents a use of the wishing compass, including: + // - Milliseconds to increment the "system time" prior to use. + // - The player's position when the compass is used. + // - The resulting set of particles + // - The expected state of the wishing compass solver after this compass is used + static class CompassUse { + long timeIncrementMillis; + BlockPos playerPos; + ArrayList<ParticleSpawn> particles; + HandleCompassResult expectedHandleCompassUseResult; + SolverState expectedSolverState; + + CompassUse(long timeIncrementMillis, + BlockPos playerPos, + ArrayList<ParticleSpawn> particles, + HandleCompassResult expectedHandleCompassUseResult, + SolverState expectedState) { + this.timeIncrementMillis = timeIncrementMillis; + this.playerPos = playerPos; + this.particles = particles != null ? particles : new ArrayList<>(); + this.expectedHandleCompassUseResult = expectedHandleCompassUseResult; + this.expectedSolverState = expectedState; + } + + CompassUse(CompassUse source) { + this.timeIncrementMillis = source.timeIncrementMillis; + this.playerPos = new BlockPos(source.playerPos); + this.particles = new ArrayList<>(source.particles); + this.expectedHandleCompassUseResult = source.expectedHandleCompassUseResult; + this.expectedSolverState = source.expectedSolverState; + } + } + + static class Solution { + ArrayList<CompassUse> compassUses; + Vec3i expectedSolutionCoords; + + Solution(ArrayList<CompassUse> compassUses, Vec3i expectedSolutionCoords) { + this.compassUses = compassUses; + this.expectedSolutionCoords = new Vec3i(expectedSolutionCoords.getX(), expectedSolutionCoords.getY(), expectedSolutionCoords.getZ()); + } + } + + private static void neuDebugLog(String message) { + System.out.println(message); + } +} diff --git a/src/test/resources/log4j2-test.xml b/src/test/resources/log4j2-test.xml new file mode 100644 index 00000000..25209eae --- /dev/null +++ b/src/test/resources/log4j2-test.xml @@ -0,0 +1,16 @@ +<?xml version="1.0" encoding="UTF-8"?> +<Configuration status="WARN"> + <Appenders> + <Console name="SysOut" target="SYSTEM_OUT"> + <PatternLayout pattern="[%d{HH:mm:ss}] [%t/%level]: %msg{nolookups}%n" /> + </Console> + </Appenders> + <Loggers> + <Root level="info"> + <filters> + <MarkerFilter marker="NETWORK_PACKETS" onMatch="DENY" onMismatch="NEUTRAL" /> + </filters> + <AppenderRef ref="SysOut"/> + </Root> + </Loggers> +</Configuration> |