Wishing Compass Solver, Metal Detector Solver improvements, add /neudiag, other misc changes (#90)

2 files changed, 692 insertions, 76 deletions

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 4586d190..27c334ad 100644
--- a/src/main/java/io/github/moulberry/notenoughupdates/miscfeatures/CrystalMetalDetectorSolver.java
+++ b/src/main/java/io/github/moulberry/notenoughupdates/miscfeatures/CrystalMetalDetectorSolver.java
@@ -2,31 +2,119 @@ package io.github.moulberry.notenoughupdates.miscfeatures;
 
 import io.github.moulberry.notenoughupdates.NotEnoughUpdates;
 import io.github.moulberry.notenoughupdates.core.util.render.RenderUtils;
+import io.github.moulberry.notenoughupdates.options.customtypes.NEUDebugFlag;
+import io.github.moulberry.notenoughupdates.util.NEUDebugLogger;
 import io.github.moulberry.notenoughupdates.util.SBInfo;
 import net.minecraft.client.Minecraft;
-import net.minecraft.util.*;
+import net.minecraft.entity.item.EntityArmorStand;
+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.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.HashSet;
 import java.util.List;
+import java.util.stream.Collectors;
 
 public class CrystalMetalDetectorSolver {
 	private static final Minecraft mc = Minecraft.getMinecraft();
+
 	private static BlockPos prevPlayerPos;
 	private static double prevDistToTreasure = 0;
-	private static List<BlockPos> possibleBlocks = new ArrayList<>();
-	private static final List<BlockPos> locations = new ArrayList<>();
-
+	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 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 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));
+		put(EMERALD_STRING, new Vec3i(-3,0,33));
+		put(GOLD_STRING, new Vec3i(3,0,-33));
+	}};
+
+	// Chest offsets from center
+	private static final HashSet<Long> knownChestOffsets = new HashSet<>(Arrays.asList(
+		-10171958951910L,	// x=-38, y=-22, z=26
+		10718829084646L,	// x=38, y=-22, z=-26
+		-10721714765806L,	// x=-40, y=-22, z=18
+		-10996458455018L,	// x=-41, y=-20, z=22
+		-1100920913904L,	// x=-5, y=-21, z=16
+		11268584898530L,	// x=40, y=-22, z=-30
+		-11271269253148L,	// x=-42, y=-20, z=-28
+		-11546281377832L,	// x=-43, y=-22, z=-40
+		11818542038999L,	// x=42, y=-19, z=-41
+		12093285728240L,	// x=43, y=-21, z=-16
+		-1409286164L,			// x=-1, y=-22, z=-20
+		1922736062492L,		// x=6, y=-21, z=28
+		2197613969419L,		// x=7, y=-21, z=11
+		2197613969430L,		// x=7, y=-21, z=22
+		-3024999153708L,	// x=-12, y=-21, z=-44
+		3571936395295L,		// x=12, y=-22, z=31
+		3572003504106L,		// x=12, y=-22, z=-22
+		3572003504135L,		// x=12, y=-21, z=7
+		3572070612949L,		// x=12, y=-21, z=-43
+		-3574822076373L,	// x=-14, y=-21, z=43
+		-3574822076394L,	// x=-14, y=-21, z=22
+		-4399455797228L,	// x=-17, y=-21, z=20
+		-5224156626944L,	// x=-20, y=-22, z=0
+		548346527764L,		// x=1, y=-21, z=20
+		5496081743901L,		// x=19, y=-22, z=29
+		5770959650816L,		// x=20, y=-22, z=0
+		5771093868518L,		// x=20, y=-21, z=-26
+		-6048790347736L,	// x=-23, y=-22, z=40
+		6320849682418L,		// x=22, y=-21, z=-14
+		-6323668254708L,	// x=-24, y=-22, z=12
+		6595593371674L,		// x=23, y=-22, z=26
+		6595660480473L,		// x=23, y=-22, z=-39
+		6870471278619L,		// x=24, y=-22, z=27
+		7145349185553L,		// x=25, y=-22, z=17
+		8244995030996L,		// x=29, y=-21, z=-44
+		-8247679385612L,	// x=-31, y=-21, z=-12
+		-8247679385640L,	// x=-31, y=-21, z=-40
+		8519872937959L,		// x=30, y=-21, z=-25
+		-8522557292584L,	// x=-32, y=-21, z=-40
+		-9622068920278L,	// x=-36, y=-20, z=42
+		-9896946827278L,	// x=-37, y=-21, z=-14
+		-9896946827286L		// x=-37, y=-21, z=-22
+	));
 
 	public static void process(IChatComponent message) {
+		if (SBInfo.getInstance().getLocation() == null ||
+			!NotEnoughUpdates.INSTANCE.config.mining.metalDetectorEnabled ||
+			!SBInfo.getInstance().getLocation().equals("crystal_hollows") ||
+			!message.getUnformattedText().contains("TREASURE: ")) {
+			return;
+		}
+
+		locateMinesCenterIfNeeded();
+
+		double distToTreasure = Double.parseDouble(message
+			.getUnformattedText()
+			.split("TREASURE: ")[1].split("m")[0].replaceAll("(?!\\.)\\D", ""));
+
 		// Delay to keep old chest location from being treated as the new chest location
 		if (chestRecentlyFound) {
 			long currentTimeMillis = System.currentTimeMillis();
 			if (chestLastFoundMillis == 0) {
 				chestLastFoundMillis = currentTimeMillis;
 				return;
-			} else if (currentTimeMillis - chestLastFoundMillis < 1000) {
+			} else if (currentTimeMillis - chestLastFoundMillis < 1000 && distToTreasure < 5.0) {
 				return;
 			}
 
@@ -34,80 +122,239 @@ public class CrystalMetalDetectorSolver {
 			chestRecentlyFound = false;
 		}
 
-		if (SBInfo.getInstance().getLocation() != null && SBInfo.getInstance().getLocation().equals("crystal_hollows")
-			&& message.getUnformattedText().contains("TREASURE: ")) {
-			double distToTreasure = Double.parseDouble(message
-				.getUnformattedText()
-				.split("TREASURE: ")[1].split("m")[0].replaceAll("(?!\\.)\\D", ""));
-			if (NotEnoughUpdates.INSTANCE.config.mining.metalDetectorEnabled && prevDistToTreasure == distToTreasure &&
-				prevPlayerPos.getX() == mc.thePlayer.getPosition().getX() &&
-				prevPlayerPos.getY() == mc.thePlayer.getPosition().getY() &&
-				prevPlayerPos.getZ() == mc.thePlayer.getPosition().getZ() && !locations.contains(mc.thePlayer.getPosition())) {
-				if (possibleBlocks.size() == 0) {
-					locations.add(mc.thePlayer.getPosition());
-					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 && !possibleBlocks.contains(pos) &&
-									treasureAllowed(pos) && mc.theWorld.
-									getBlockState(pos.add(0, 1, 0)).getBlock().getRegistryName().equals("minecraft:air")) {
-									possibleBlocks.add(pos);
-								}
-								xOffset++;
-							}
-							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 && !possibleBlocks.contains(pos) &&
-									treasureAllowed(pos) && mc.theWorld.
-									getBlockState(pos.add(0, 1, 0)).getBlock().getRegistryName().equals("minecraft:air")) {
-									possibleBlocks.add(pos);
-								}
-								xOffset++;
+		if (prevDistToTreasure == distToTreasure &&
+				prevPlayerPos.equals(mc.thePlayer.getPosition()) &&
+				!evaluatedPlayerPositions.keySet().contains(mc.thePlayer.getPosition())) {
+			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)) {
+								possibleBlocks.add(pos);
 							}
+							xOffset++;
 						}
-					}
-					sendMessage();
-				} else if (possibleBlocks.size() != 1) {
-					locations.add(mc.thePlayer.getPosition());
-					List<BlockPos> temp = new ArrayList<>();
-					for (BlockPos pos : possibleBlocks) {
-						if (round(getPlayerPos().distanceTo(new Vec3(pos).addVector(0D, 1D, 0D)), 1) == distToTreasure) {
-							temp.add(pos);
+						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)) {
+								possibleBlocks.add(pos);
+							}
+							xOffset++;
 						}
 					}
-					possibleBlocks = temp;
-					sendMessage();
-				} else {
-					BlockPos pos = possibleBlocks.get(0);
-					if (Math.abs(distToTreasure - (getPlayerPos().distanceTo(new Vec3(pos)))) > 5) {
-						mc.thePlayer.addChatMessage(new ChatComponentText(
-							EnumChatFormatting.RED + "[NEU] Previous solution is invalid."));
-						reset(false);
+				}
+
+				checkAndDisplaySolutionState();
+			} 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) {
+						temp.add(pos);
 					}
 				}
 
+				possibleBlocks = temp;
+				checkAndDisplaySolutionState();
+			} 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);
+				}
 			}
+		}
+
+		prevPlayerPos = mc.thePlayer.getPosition().getImmutable();
+		prevDistToTreasure = distToTreasure;
+	}
+
+	private static void checkForSingleKnownLocationMatch() {
+		if (minesCenter == BlockPos.NULL_VECTOR || possibleBlocks.size() < 2) {
+			return;
+		}
 
-			prevPlayerPos = mc.thePlayer.getPosition();
-			prevDistToTreasure = distToTreasure;
+		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 reset(Boolean chestFound) {
+	private static String getFriendlyBlockPositions(Collection<BlockPos> positions) {
+		if (!NEUDebugLogger.isFlagEnabled(NEUDebugFlag.METAL) || positions.size() == 0) {
+			return "";
+		}
+
+		StringBuilder sb = new StringBuilder();
+		sb.append("\n");
+		for (BlockPos blockPos : positions) {
+			sb.append("Absolute: " + blockPos.toString());
+			if (minesCenter != Vec3i.NULL_VECTOR) {
+				BlockPos relativeOffset = blockPos.subtract(minesCenter);
+				sb.append(", Relative: " + relativeOffset.toString() + " (" + relativeOffset.toLong() + ")");
+			}
+			sb.append("\n");
+		}
+
+		return sb.toString();
+	}
+
+	private static String getFriendlyEvaluatedPositions(HashMap<BlockPos, Double> positions) {
+		if (!NEUDebugLogger.isFlagEnabled(NEUDebugFlag.METAL) || positions.size() == 0) {
+			return "";
+		}
+
+		StringBuilder sb = new StringBuilder();
+		sb.append("\n");
+		for (BlockPos blockPos : positions.keySet()) {
+			sb.append("Absolute: " + blockPos.toString());
+			if (minesCenter != Vec3i.NULL_VECTOR) {
+				BlockPos relativeOffset = blockPos.subtract(minesCenter);
+				sb.append(", Relative: " + relativeOffset.toString() + " (" + relativeOffset.toLong() + ")");
+			}
+
+			sb.append(" Distance: ");
+			sb.append(positions.get(blockPos));
+
+			sb.append("\n");
+		}
+
+		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) {
+				openedChestPositions.add(possibleBlocks.iterator().next().getImmutable());
+			}
+		}
+
 		chestRecentlyFound = chestFound;
 		possibleBlocks.clear();
-		locations.clear();
+		evaluatedPlayerPositions.clear();
+	}
+
+	public static void initWorld() {
+		minesCenter = Vec3i.NULL_VECTOR;
+		visitKeeperMessagePrinted = false;
+		blockPosIfLastSolutionInvalid = null;
+		openedChestPositions.clear();
+		prevDistToTreasure = 0;
+		prevPlayerPos = null;
+		resetSolution(false);
 	}
 
 	public static void render(float partialTicks) {
@@ -117,10 +364,10 @@ public class CrystalMetalDetectorSolver {
 			SBInfo.getInstance().location.equals("Mines of Divan")) {
 
 			if (possibleBlocks.size() == 1) {
-				BlockPos block = possibleBlocks.get(0);
+				BlockPos block = possibleBlocks.iterator().next();
 
 				RenderUtils.renderBeaconBeam(block.add(0, 1, 0), beaconRGB, 1.0f, partialTicks);
-				RenderUtils.renderWayPoint("Treasure", possibleBlocks.get(0).add(0, 2.5, 0), partialTicks);
+				RenderUtils.renderWayPoint("Treasure", possibleBlocks.iterator().next().add(0, 2.5, 0), partialTicks);
 			} else if (possibleBlocks.size() > 1 && NotEnoughUpdates.INSTANCE.config.mining.metalDetectorShowPossible) {
 				for (BlockPos block : possibleBlocks) {
 					RenderUtils.renderBeaconBeam(block.add(0, 1, 0), beaconRGB, 1.0f, partialTicks);
@@ -130,19 +377,55 @@ public class CrystalMetalDetectorSolver {
 		}
 	}
 
+	private static void locateMinesCenterIfNeeded() {
+		if (minesCenter != Vec3i.NULL_VECTOR) {
+			return;
+		}
+
+		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;
+		});
+
+		if (keeperEntities.size() == 0) {
+			if (!visitKeeperMessagePrinted) {
+				mc.thePlayer.addChatMessage(new ChatComponentText(EnumChatFormatting.YELLOW +
+					"[NEU] Approach a Keeper while holding the metal detector to enable faster treasure hunting."));
+				visitKeeperMessagePrinted = true;
+			}
+			return;
+		}
+
+		EntityArmorStand keeperEntity = keeperEntities.get(0);
+		String keeperName = keeperEntity.getCustomNameTag();
+		NEUDebugLogger.log(NEUDebugFlag.METAL,"Locating center using Keeper: " +
+			EnumChatFormatting.WHITE + keeperEntity);
+		String keeperType = keeperName.substring(keeperName.indexOf(KEEPER_OF_STRING) + KEEPER_OF_STRING.length());
+		minesCenter =  keeperEntity.getPosition().add(keeperOffsets.get(keeperType.toLowerCase()));
+		NEUDebugLogger.log(NEUDebugFlag.METAL,"Mines center: " +
+			EnumChatFormatting.WHITE + minesCenter.toString());
+		mc.thePlayer.addChatMessage(new ChatComponentText(
+			EnumChatFormatting.YELLOW + "[NEU] Faster treasure hunting is now enabled based on Keeper location."));
+	}
+
 	private static double round(double value, int precision) {
 		int scale = (int) Math.pow(10, precision);
 		return (double) Math.round(value * scale) / scale;
 	}
 
-	private static void sendMessage() {
+	private static void checkAndDisplaySolutionState() {
+		if (possibleBlocks.size() == 0) {
+			mc.thePlayer.addChatMessage(new ChatComponentText(EnumChatFormatting.RED + "[NEU] Failed to find a solution."));
+			logDiagnosticData(false);
+			resetSolution(false);
+			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 if (possibleBlocks.size() == 0) {
-			mc.thePlayer.addChatMessage(new ChatComponentText(EnumChatFormatting.RED + "[NEU] Failed to find solution."));
-			reset(false);
+			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."));
 		}
@@ -157,12 +440,16 @@ public class CrystalMetalDetectorSolver {
 	}
 
 	private static boolean treasureAllowed(BlockPos pos) {
-		return mc.theWorld.getBlockState(pos).getBlock().getRegistryName().equals("minecraft:gold_block") ||
+		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") ||
 			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);
 	}
 }
diff --git a/src/main/java/io/github/moulberry/notenoughupdates/miscfeatures/CrystalWishingCompassSolver.java b/src/main/java/io/github/moulberry/notenoughupdates/miscfeatures/CrystalWishingCompassSolver.java
new file mode 100644
index 00000000..25f39c3a
--- /dev/null
+++ b/src/main/java/io/github/moulberry/notenoughupdates/miscfeatures/CrystalWishingCompassSolver.java
@@ -0,0 +1,329 @@
+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.options.customtypes.NEUDebugFlag;
+import io.github.moulberry.notenoughupdates.util.NEUDebugLogger;
+import io.github.moulberry.notenoughupdates.util.SBInfo;
+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.minecraftforge.event.entity.player.PlayerInteractEvent;
+import net.minecraftforge.event.world.WorldEvent;
+import net.minecraftforge.fml.common.Loader;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+
+public class CrystalWishingCompassSolver {
+	private static final CrystalWishingCompassSolver INSTANCE = new CrystalWishingCompassSolver();
+	public static CrystalWishingCompassSolver getInstance() {
+		return INSTANCE;
+	}
+
+	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;
+	}
+
+	private void resetForNewTarget() {
+		NEUDebugLogger.log(NEUDebugFlag.WISHING,"Resetting for new target");
+		resetForNewCompass();
+		firstCompassLine = null;
+		secondCompassLine = null;
+		solutionIntersectionLine = null;
+		prevPlayerPos = null;
+		solution = null;
+	}
+
+	@SubscribeEvent
+	public void onWorldLoad(WorldEvent.Unload event) {
+		resetForNewTarget();
+		isSkytilsPresent = Loader.isModLoaded("skytils");
+	}
+
+	@SubscribeEvent
+	public void onPlayerInteract(PlayerInteractEvent event) {
+		if (!NotEnoughUpdates.INSTANCE.config.mining.wishingCompassSolver ||
+			SBInfo.getInstance().getLocation() == null ||
+			!SBInfo.getInstance().getLocation().equals("crystal_hollows") ||
+			event.entityPlayer != mc.thePlayer ||
+			(event.action != PlayerInteractEvent.Action.RIGHT_CLICK_AIR &&
+				event.action != PlayerInteractEvent.Action.RIGHT_CLICK_BLOCK)
+			) {
+			return;
+		}
+
+		ItemStack heldItem = event.entityPlayer.getHeldItem();
+		if (heldItem == null || heldItem.getItem() != Items.skull) {
+			return;
+		}
+
+		String heldInternalName = NotEnoughUpdates.INSTANCE.manager.getInternalNameForItem(heldItem);
+		if (heldInternalName == null || !heldInternalName.equals("WISHING_COMPASS")) {
+			return;
+		}
+
+		try {
+			if (isSolved()) {
+				resetForNewTarget();
+			}
+
+			// 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;
+			}
+
+			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();
+		}
+	}
+
+	/*
+	 * Processes particles if the wishing compass was used within the last 5 seconds.
+	 *
+	 * The first and the last particles are used to create a line for each wishing compass
+	 * use that is then used to calculate the target.
+	 *
+	 * Once two lines have been calculated, the shortest line between the two is calculated
+	 * with the midpoint on that line being the wishing compass target. The accuracy of this
+	 * seems to be very high.
+	 *
+	 * The target location varies based on various criteria, including, but not limited to:
+	 *  Topaz Crystal (Khazad-dûm)                Magma Fields
+	 *  Odawa (Jungle Village)                    Jungle w/no Jungle Key in inventory
+	 *  Amethyst Crystal (Jungle Temple)          Jungle w/Jungle Key in inventory
+	 *  Sapphire Crystal (Lost Precursor City)    Precursor Remnants
+	 *  Jade Crystal (Mines of Divan)             Mithril Deposits
+	 *  King Yolkar                               Goblin Holdout without "King's Scent I" effect
+	 *  Goblin Queen                              Goblin Holdout with "King's Scent I" effect
+	 *  Crystal Nucleus                           All Crystals found and none placed
+	 *                                            per-area structure missing, or because Hypixel.
+	 *                                            Always within 1 block of X=513 Y=106 Z=551.
+	 */
+	public void onSpawnParticle(
+		EnumParticleTypes particleType,
+		double x,
+		double y,
+		double z
+	) {
+		if (!NotEnoughUpdates.INSTANCE.config.mining.wishingCompassSolver ||
+			particleType != EnumParticleTypes.VILLAGER_HAPPY ||
+			!SBInfo.getInstance().getLocation().equals("crystal_hollows") ||
+			isSolved() ||
+			System.currentTimeMillis() - compassUsedMillis > 5000) {
+			return;
+		}
+
+		try {
+			Vec3 particleVec = new Vec3(x, y, z);
+			if (firstParticle == null) {
+				firstParticle = particleVec;
+				return;
+			}
+
+			double distanceFromFirst = particleVec.distanceTo(firstParticle);
+			if (distanceFromFirst > MAX_COMPASS_PARTICLE_SPREAD) {
+				return;
+			}
+
+			if (distanceFromFirst >= lastParticleDistanceFromFirst) {
+				lastParticleDistanceFromFirst = distanceFromFirst;
+				lastParticle = particleVec;
+				return;
+			}
+
+			// 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;
+			}
+
+			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;
+			}
+
+			solution = solutionIntersectionLine.getMidpoint();
+
+			if (solution.distanceTo(firstParticle) < 8) {
+				mc.thePlayer.addChatMessage(new ChatComponentText(EnumChatFormatting.YELLOW +
+					"[NEU] WARNING: Solution is likely incorrect."));
+				logDiagnosticData(false);
+				return;
+			}
+
+			showSolution();
+		} catch (Exception e) {
+			mc.thePlayer.addChatMessage(new ChatComponentText(EnumChatFormatting.RED +
+				"[NEU] Exception while calculating wishing compass solution - see log for details"));
+			e.printStackTrace();
+		}
+	}
+
+	private boolean isSolved() {
+		return solution != null;
+	}
+
+	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);
+
+		if (NUCLEUS_BB.isVecInside(solution)) {
+			description += "Crystal Nucleus (" + coordsText + ")";
+		} else {
+			description += coordsText;
+		}
+
+		ChatComponentText message = new ChatComponentText(EnumChatFormatting.YELLOW + description);
+
+		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);
+		}
+
+		Minecraft.getMinecraft().thePlayer.addChatMessage(message);
+	}
+
+	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"));
+			return;
+		}
+
+		if (!NotEnoughUpdates.INSTANCE.config.mining.wishingCompassSolver)
+		{
+			mc.thePlayer.addChatMessage(new ChatComponentText(EnumChatFormatting.RED +
+				"[NEU] Wishing Compass Solver is not enabled."));
+			return;
+		}
+
+		if (!outputAlways && !NotEnoughUpdates.INSTANCE.config.hidden.debugFlags.contains(NEUDebugFlag.WISHING)) {
+			return;
+		}
+
+		boolean originalDebugFlag = !NotEnoughUpdates.INSTANCE.config.hidden.debugFlags.add(NEUDebugFlag.WISHING);
+
+		StringBuilder diagsMessage = new StringBuilder();
+
+		diagsMessage.append("\n");
+		diagsMessage.append(EnumChatFormatting.AQUA);
+		diagsMessage.append("Skytils Present: ");
+		diagsMessage.append(EnumChatFormatting.WHITE);
+		diagsMessage.append(isSkytilsPresent);
+		diagsMessage.append("\n");
+
+		diagsMessage.append(EnumChatFormatting.AQUA);
+		diagsMessage.append("Compass Used Millis: ");
+		diagsMessage.append(EnumChatFormatting.WHITE);
+		diagsMessage.append(compassUsedMillis);
+		diagsMessage.append("\n");
+
+		diagsMessage.append(EnumChatFormatting.AQUA);
+		diagsMessage.append("Compass Used Position: ");
+		diagsMessage.append(EnumChatFormatting.WHITE);
+		diagsMessage.append((prevPlayerPos == null) ? "<NONE>" : prevPlayerPos.toString());
+		diagsMessage.append("\n");
+
+		diagsMessage.append(EnumChatFormatting.AQUA);
+		diagsMessage.append("First Particle: ");
+		diagsMessage.append(EnumChatFormatting.WHITE);
+		diagsMessage.append((firstParticle == null) ? "<NONE>" : firstParticle.toString());
+		diagsMessage.append("\n");
+
+		diagsMessage.append(EnumChatFormatting.AQUA);
+		diagsMessage.append("Last Particle: ");
+		diagsMessage.append(EnumChatFormatting.WHITE);
+		diagsMessage.append((lastParticle == null) ? "<NONE>" : lastParticle.toString());
+		diagsMessage.append("\n");
+
+		diagsMessage.append(EnumChatFormatting.AQUA);
+		diagsMessage.append("Last Particle Distance From First: ");
+		diagsMessage.append(EnumChatFormatting.WHITE);
+		diagsMessage.append(lastParticleDistanceFromFirst);
+		diagsMessage.append("\n");
+
+		diagsMessage.append(EnumChatFormatting.AQUA);
+		diagsMessage.append("First Compass Line: ");
+		diagsMessage.append(EnumChatFormatting.WHITE);
+		diagsMessage.append((firstCompassLine == null) ? "<NONE>" : firstCompassLine.toString());
+		diagsMessage.append("\n");
+
+		diagsMessage.append(EnumChatFormatting.AQUA);
+		diagsMessage.append("Second Compass Line: ");
+		diagsMessage.append(EnumChatFormatting.WHITE);
+		diagsMessage.append((secondCompassLine == null) ? "<NONE>" : secondCompassLine.toString());
+		diagsMessage.append("\n");
+
+		diagsMessage.append(EnumChatFormatting.AQUA);
+		diagsMessage.append("Intersection Line: ");
+		diagsMessage.append(EnumChatFormatting.WHITE);
+		diagsMessage.append((secondCompassLine == null) ? "<NONE>" : solutionIntersectionLine);
+		diagsMessage.append("\n");
+
+		diagsMessage.append(EnumChatFormatting.AQUA);
+		diagsMessage.append("Solution: ");
+		diagsMessage.append(EnumChatFormatting.WHITE);
+		diagsMessage.append((solution == null) ? "<NONE>" : solution.toString());
+		diagsMessage.append("\n");
+
+		NEUDebugLogger.log(NEUDebugFlag.WISHING, diagsMessage.toString());
+
+		if (!originalDebugFlag) {
+			NotEnoughUpdates.INSTANCE.config.hidden.debugFlags.remove(NEUDebugFlag.WISHING);
+		}
+	}
+}