Deal with potential exceptions better.

src/main/java/world/bentobox/greenhouses/world/AsyncWorldCache.java

@@ -11,6 +11,7 @@
 import org.bukkit.World;
 import org.bukkit.World.Environment;
 import org.bukkit.util.Vector;
+import org.eclipse.jdt.annotation.Nullable;
 
 import world.bentobox.bentobox.util.Pair;
 import world.bentobox.bentobox.util.Util;
@@ -66,23 +67,20 @@ private CompletableFuture<ChunkSnapshot> getAChunk(int x, int z) {
      * Get snapshot from cache or world
      * @param x - block coord
      * @param z - block coord
-     * @return chunk snapshot
+     * @return chunk snapshot or null if there's an error getting the chunk
+     * @throws ExecutionException - if the chunk getting throws an exception
+     * @throws InterruptedException  - if the future is interrupted
      */
-    private ChunkSnapshot getSnap(final int x, final int z) {
+    @Nullable
+    private ChunkSnapshot getSnap(final int x, final int z) throws InterruptedException, ExecutionException {
         // Convert from block to chunk coords
         Pair<Integer, Integer> key = new Pair<>((x >> 4), (z >> 4));
         // Get from cache if it is available
         if (cache.containsKey(key)) {
             return cache.get(key);
         }
-        ChunkSnapshot cs = null;
-        try {
-            // Block on getting the chunk because this is running async
-            cs = getAChunk(key.x, key.z).get();
-        } catch (InterruptedException | ExecutionException e) {
-            Greenhouses.getInstance().logError("Could not get chunk! " + e);
-            Thread.currentThread().interrupt();
-        }
+        // Block on getting the chunk because this is running async
+        ChunkSnapshot cs = getAChunk(key.x, key.z).get();
         // Store in cache
         cache.put(key, cs);
         return cs;
@@ -95,15 +93,19 @@ private ChunkSnapshot getSnap(final int x, final int z) {
      * @param x block coordinate
      * @param y 0-255
      * @param z block coordinate
-     * @return material type
+     * @return material type or Material.AIR if there is an exception
      */
     public Material getBlockType(final int x, final int y, final int z) {
         // Convert block coords to chunk coords
         // TODO: simplify this - it must be easier than this!
         int xx = x >= 0 ? x % 16 : (16 + (x % 16)) % 16;
         int zz = z >= 0 ? z % 16 : (16 + (z % 16)) % 16;
-        Material m = getSnap(x,z).getBlockType(xx, y, zz);
-        return m;
+        try {
+            return getSnap(x,z).getBlockType(xx, y, zz);
+        } catch (InterruptedException | ExecutionException e) {
+            Greenhouses.getInstance().logError("Chunk could not be obtained async! " + e);
+            return Material.AIR;
+        }
     }
 
     /**