diff --git a/src/main/java/org/dynmap/MapManager.java b/src/main/java/org/dynmap/MapManager.java
index 1f628b40..3649dc36 100644
--- a/src/main/java/org/dynmap/MapManager.java
+++ b/src/main/java/org/dynmap/MapManager.java
@@ -7,6 +7,7 @@ import java.util.List;
 import java.util.Map;
 import java.util.logging.Logger;
 
+import org.bukkit.Chunk;
 import org.bukkit.Location;
 import org.bukkit.World;
 import org.bukkit.event.player.PlayerChatEvent;
@@ -135,24 +136,28 @@ public class MapManager extends Thread {
 			log.info("Map renderer has started.");
 	
 			while(running) {
-				boolean found = false;
-	
 				MapTile t = staleQueue.popStaleTile();
 				if(t != null) {
-					debugger.debug("rendering tile " + t + "...");
+					MapType map = t.getMap();
+					World world = map.getWorld();
+					
+					Chunk[] requiredChunks = map.getRequiredChunks(t);
+					debugger.debug("Loading " + requiredChunks.length + " chunks for tile " + t + "...");
+					for (int i=0;i<requiredChunks.length;i++) {
+						Chunk requiredChunk = requiredChunks[i];
+						if (!world.isChunkLoaded(requiredChunk))
+							world.loadChunk(requiredChunk);
+					}
+					
+					debugger.debug("Rendering tile " + t + "...");
 					t.getMap().render(t);
-	
 					staleQueue.onTileUpdated(t);
 	
 					try {
 						Thread.sleep(renderWait);
 					} catch(InterruptedException e) {
 					}
-	
-					found = true;
-				}
-	
-				if(!found) {
+				} else {
 					try {
 						Thread.sleep(500);
 					} catch(InterruptedException e) {
@@ -168,12 +173,15 @@ public class MapManager extends Thread {
 
 	public void touch(int x, int y, int z) {
 		for (int i = 0; i < maps.length; i++) {
-			maps[i].touch(new Location(world, x, y, z));
+			MapTile[] tiles = maps[i].getTiles(new Location(world, x, y, z));
+			for(int j=0;j<tiles.length;j++) {
+				invalidateTile(tiles[j]);
+			}
 		}
 	}
 	
 	public void invalidateTile(MapTile tile) {
-		debugger.debug("invalidating tile " + tile.getName());
+		debugger.debug("Invalidating tile " + tile.getName());
 		staleQueue.pushStaleTile(tile);
 	}
 	
diff --git a/src/main/java/org/dynmap/MapType.java b/src/main/java/org/dynmap/MapType.java
index eb01fa57..e068ff55 100644
--- a/src/main/java/org/dynmap/MapType.java
+++ b/src/main/java/org/dynmap/MapType.java
@@ -1,5 +1,6 @@
 package org.dynmap;
 
+import org.bukkit.Chunk;
 import org.bukkit.Location;
 import org.bukkit.World;
 import org.dynmap.debug.Debugger;
@@ -26,10 +27,9 @@ public abstract class MapType {
 		this.debugger = debugger;
 	}
 	
-	public void invalidateTile(MapTile tile) {
-		manager.invalidateTile(tile);
-	}
-	
-	public abstract void touch(Location l);
-	public abstract void render(MapTile tile);
+	public abstract MapTile[] getTiles(Location l);
+	public abstract MapTile[] getAdjecentTiles(MapTile tile);
+	public abstract Chunk[] getRequiredChunks(MapTile tile);
+	public abstract boolean render(MapTile tile);
+	public abstract boolean isRendered(MapTile tile);
 }
diff --git a/src/main/java/org/dynmap/kzedmap/CaveTileRenderer.java b/src/main/java/org/dynmap/kzedmap/CaveTileRenderer.java
index 5e85f60a..a83f4c31 100644
--- a/src/main/java/org/dynmap/kzedmap/CaveTileRenderer.java
+++ b/src/main/java/org/dynmap/kzedmap/CaveTileRenderer.java
@@ -18,7 +18,7 @@ public class CaveTileRenderer extends DefaultTileRenderer {
 
 		for(;;) {
 			if(y < 0)
-				return Color.BLACK;
+				return translucent;
 
 			int id = world.getBlockTypeIdAt(x, y, z);
 
diff --git a/src/main/java/org/dynmap/kzedmap/DefaultTileRenderer.java b/src/main/java/org/dynmap/kzedmap/DefaultTileRenderer.java
index 217bb419..6493c744 100644
--- a/src/main/java/org/dynmap/kzedmap/DefaultTileRenderer.java
+++ b/src/main/java/org/dynmap/kzedmap/DefaultTileRenderer.java
@@ -13,85 +13,88 @@ import org.bukkit.World;
 import org.dynmap.debug.Debugger;
 
 public class DefaultTileRenderer implements MapTileRenderer {
+	protected static Color translucent = new Color(0, 0, 0, 0);
 	private String name;
 	protected Debugger debugger;
-	
+
 	public String getName() {
 		return name;
 	}
-	
+
 	public DefaultTileRenderer(Debugger debugger, Map<String, Object> configuration) {
 		this.debugger = debugger;
-		name = (String)configuration.get("prefix");
+		name = (String) configuration.get("prefix");
 	}
-	
-	public void render(KzedMapTile tile, String path) {
+
+	public boolean render(KzedMapTile tile, String path) {
 		World world = tile.getMap().getWorld();
 		BufferedImage im = new BufferedImage(KzedMap.tileWidth, KzedMap.tileHeight, BufferedImage.TYPE_INT_RGB);
 
 		WritableRaster r = im.getRaster();
+		boolean isempty = true;
 
 		int ix = tile.mx;
 		int iy = tile.my;
 		int iz = tile.mz;
-		
+
 		int jx, jz;
 
 		int x, y;
 
 		/* draw the map */
-		for(y=0; y<KzedMap.tileHeight;) {
+		for (y = 0; y < KzedMap.tileHeight;) {
 			jx = ix;
 			jz = iz;
 
-			for(x=KzedMap.tileWidth-1; x>=0; x-=2) {
+			for (x = KzedMap.tileWidth - 1; x >= 0; x -= 2) {
 				Color c1 = scan(world, jx, iy, jz, 0);
 				Color c2 = scan(world, jx, iy, jz, 2);
-
+				isempty = isempty && c1 == translucent && c2 == translucent;
 				r.setPixel(x, y, new int[] { c1.getRed(), c1.getGreen(), c1.getBlue() });
-				r.setPixel(x-1, y, new int[] { c2.getRed(), c2.getGreen(), c2.getBlue() });
+				r.setPixel(x - 1, y, new int[] { c2.getRed(), c2.getGreen(), c2.getBlue() });
 
 				jx++;
 				jz++;
 
 			}
 
-			y ++;
+			y++;
 
 			jx = ix;
 			jz = iz - 1;
 
-			for(x=KzedMap.tileWidth-1; x>=0; x-=2) {
+			for (x = KzedMap.tileWidth - 1; x >= 0; x -= 2) {
 				Color c1 = scan(world, jx, iy, jz, 2);
 				jx++;
 				jz++;
 				Color c2 = scan(world, jx, iy, jz, 0);
-
+				isempty = isempty && c1 == translucent && c2 == translucent;
 				r.setPixel(x, y, new int[] { c1.getRed(), c1.getGreen(), c1.getBlue() });
-				r.setPixel(x-1, y, new int[] { c2.getRed(), c2.getGreen(), c2.getBlue() });
+				r.setPixel(x - 1, y, new int[] { c2.getRed(), c2.getGreen(), c2.getBlue() });
 			}
 
-			y ++;
+			y++;
 
-			ix ++;
-			iz --;
+			ix++;
+			iz--;
 		}
 
 		/* save the generated tile */
 		saveTile(tile, im, path);
-		
-		((KzedMap)tile.getMap()).invalidateTile(new KzedZoomedMapTile((KzedMap)tile.getMap(), im, tile));
+
+		((KzedMap) tile.getMap()).invalidateTile(new KzedZoomedMapTile((KzedMap)tile.getMap(), im, tile));
+
+		return !isempty;
 	}
-	
-	protected Color scan(World world, int x, int y, int z, int seq)
-	{
-		for(;;) {
-			if(y < 0)
-				return Color.BLUE;
+
+	protected Color scan(World world, int x, int y, int z, int seq) {
+		for (;;) {
+			if (y < 0)
+				return translucent;
 
 			int id = world.getBlockTypeIdAt(x, y, z);
 
-			switch(seq) {
+			switch (seq) {
 			case 0:
 				x--;
 				break;
@@ -108,13 +111,13 @@ public class DefaultTileRenderer implements MapTileRenderer {
 
 			seq = (seq + 1) & 3;
 
-			if(id != 0) {
+			if (id != 0) {
 				Color[] colors = KzedMap.colors.get(id);
-				if(colors != null) {
+				if (colors != null) {
 					Color c = colors[seq];
-					if(c.getAlpha() > 0) {
+					if (c.getAlpha() > 0) {
 						/* we found something that isn't transparent! */
-						if(c.getAlpha() == 255) {
+						if (c.getAlpha() == 255) {
 							/* it's opaque - the ray ends here */
 							return c;
 						}
@@ -137,138 +140,25 @@ public class DefaultTileRenderer implements MapTileRenderer {
 			}
 		}
 	}
-	
+
 	/* save rendered tile, update zoom-out tile */
-	public void saveTile(KzedMapTile tile, BufferedImage im, String path)
-	{
+	public void saveTile(KzedMapTile tile, BufferedImage im, String path) {
 		String tilePath = getPath(tile, path);
-		
+
 		debugger.debug("saving tile " + tilePath);
-		
+
 		/* save image */
 		try {
 			File file = new File(tilePath);
 			ImageIO.write(im, "png", file);
-		} catch(IOException e) {
+		} catch (IOException e) {
 			debugger.error("Failed to save tile: " + tilePath, e);
-		} catch(java.lang.NullPointerException e) {
+		} catch (java.lang.NullPointerException e) {
 			debugger.error("Failed to save tile (NullPointerException): " + tilePath, e);
 		}
-		
-		
-
-		/* now update zoom-out tile */
-		/*BufferedImage zIm = mgr.zoomCache.get(zoomPath);
-
-		
-		if(zIm == null) {
-			// zoom-out tile doesn't exist - try to load it from disk
-
-			mgr.debug("Trying to load zoom-out tile: " + zoomPath);
-
-			try {
-				File file = new File(zoomPath);
-				zIm = ImageIO.read(file);
-			} catch(IOException e) {
-			}
-
-			if(zIm == null) {
-				mgr.debug("Failed to load zoom-out tile: " + zoomPath);
-				// create new one
-				// TODO: we might use existing tiles that we could load
-				// to fill the zoomed out tile in...
-				zIm = new BufferedImage(MapManager.tileWidth, MapManager.tileHeight, BufferedImage.TYPE_INT_RGB);
-			} else {
-				mgr.debug("Loaded zoom-out tile from " + zoomPath);
-			}
-		} else {
-			mgr.debug("Using zoom-out tile from cache: " + zoomPath);
-		}
-
-		// update zoom-out tile
-
-		// scaled size
-		int scw = mgr.tileWidth / 2;
-		int sch = mgr.tileHeight / 2;
-
-		// origin in zoomed-out tile
-		int ox = scw;
-		int oy = 0;
-
-		if(zpx != px) ox = 0;
-		if(zpy != py) oy = sch;
-
-		// blit scaled rendered tile onto zoom-out tile
-		WritableRaster zr = zIm.getRaster();
-		Graphics2D g2 = zIm.createGraphics();
-		g2.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR);
-		g2.drawImage(im, ox, oy, scw, sch, null);
-
-		// update zoom-out tile cache
-		BufferedImage oldIm = mgr.zoomCache.put(zoomPath, zIm);
-		if(oldIm != null && oldIm != zIm) {
-			oldIm.flush();
-		}
-
-		// save zoom-out tile
-		try {
-			File file = new File(zoomPath);
-			ImageIO.write(zIm, "png", file);
-			mgr.debug("saved zoom-out tile at " + zoomPath);
-
-			//log.info("Saved tile: " + path);
-		} catch(IOException e) {
-			log.log(Level.SEVERE, "Failed to save zoom-out tile: " + zoomPath, e);
-		} catch(java.lang.NullPointerException e) {
-			log.log(Level.SEVERE, "Failed to save zoom-out tile (NullPointerException): " + zoomPath, e);
-		}*/
 	}
-	
-	public String getPath(KzedMapTile tile, String outputPath)
-	{
+
+	public static String getPath(KzedMapTile tile, String outputPath) {
 		return new File(new File(outputPath), tile.getName() + ".png").getPath();
 	}
-	
-	/* try to load already generated image */
-	/*public BufferedImage loadTile(KzedMapTile tile)
-	{
-		try {
-			String path = getPath(tile);
-			//log.info("Loading tile from " + path);
-			File file = new File(path);
-			BufferedImage im = ImageIO.read(file);
-			//log.info("OK");
-			return im;
-		} catch(IOException e) {
-			//log.info("failed: " + e.toString());
-		}
-
-		return null;
-	}*/
-	
-	/*
-	// generate a path name for this map tile
-	public String getPath(MapManager mgr)
-	{
-		return mgr.tilepath + "t_" + px + "_" + py + ".png";
-	}
-
-	// generate a path name for the zoomed-out tile
-	public String getZoomPath(MapManager mgr)
-	{
-		return mgr.tilepath + "zt_" + zpx + "_" + zpy + ".png";
-	}
-
-	// generate a path name for this cave map tile
-	public String getCavePath(MapManager mgr)
-	{
-		return mgr.tilepath + "ct_" + px + "_" + py + ".png";
-	}
-
-	// generate a path name for the zoomed-out cave tile
-	public String getZoomCavePath(MapManager mgr)
-	{
-		return mgr.tilepath + "czt_" + zpx + "_" + zpy + ".png";
-	}
-	*/
 }
diff --git a/src/main/java/org/dynmap/kzedmap/KzedMap.java b/src/main/java/org/dynmap/kzedmap/KzedMap.java
index 1fe82bdf..5e2b7b47 100644
--- a/src/main/java/org/dynmap/kzedmap/KzedMap.java
+++ b/src/main/java/org/dynmap/kzedmap/KzedMap.java
@@ -12,6 +12,7 @@ import java.util.Map;
 import java.util.Scanner;
 import java.util.logging.Logger;
 
+import org.bukkit.Chunk;
 import org.bukkit.Location;
 import org.bukkit.World;
 import org.dynmap.MapManager;
@@ -73,7 +74,7 @@ public class KzedMap extends MapType {
 	}
 	
 	@Override
-	public void touch(Location l) {
+	public MapTile[] getTiles(Location l) {
 		int x = l.getBlockX();
 		int y = l.getBlockY();
 		int z = l.getBlockZ();
@@ -87,37 +88,101 @@ public class KzedMap extends MapType {
 		int tx = tilex(px);
 		int ty = tiley(py);
 
-		invalidateTile(tx, ty);
+		ArrayList<MapTile> tiles = new ArrayList<MapTile>();
+		
+		addTile(tiles, tx, ty);
 
 		boolean ledge = tilex(px - 4) != tx;
 		boolean tedge = tiley(py - 4) != ty;
 		boolean redge = tilex(px + 4) != tx;
 		boolean bedge = tiley(py + 4) != ty;
 
-		if(ledge) invalidateTile(tx - tileWidth, ty);
-		if(redge) invalidateTile(tx + tileWidth, ty);
-		if(tedge) invalidateTile(tx, ty - tileHeight);
-		if(bedge) invalidateTile(tx, ty + tileHeight);
+		if(ledge) addTile(tiles, tx - tileWidth, ty);
+		if(redge) addTile(tiles, tx + tileWidth, ty);
+		if(tedge) addTile(tiles, tx, ty - tileHeight);
+		if(bedge) addTile(tiles, tx, ty + tileHeight);
 
-		if(ledge && tedge) invalidateTile(tx - tileWidth, ty - tileHeight);
-		if(ledge && bedge) invalidateTile(tx - tileWidth, ty + tileHeight);
-		if(redge && tedge) invalidateTile(tx + tileWidth, ty - tileHeight);
-		if(redge && bedge) invalidateTile(tx + tileWidth, ty + tileHeight);
+		if(ledge && tedge) addTile(tiles, tx - tileWidth, ty - tileHeight);
+		if(ledge && bedge) addTile(tiles, tx - tileWidth, ty + tileHeight);
+		if(redge && tedge) addTile(tiles, tx + tileWidth, ty - tileHeight);
+		if(redge && bedge) addTile(tiles, tx + tileWidth, ty + tileHeight);
+		
+		MapTile[] result = new MapTile[tiles.size()];
+		tiles.toArray(result);
+		return result;
 	}
 	
-	public void invalidateTile(int px, int py) {
-		for(MapTileRenderer renderer : renderers) {
-			invalidateTile(new KzedMapTile(this, renderer, px, py));
+	@Override
+	public MapTile[] getAdjecentTiles(MapTile tile) {
+		if (tile instanceof KzedMapTile) {
+			KzedMapTile t = (KzedMapTile)tile;
+			MapTileRenderer renderer = t.renderer;
+			return new MapTile[] {
+					new KzedMapTile(this, renderer, t.px-tileWidth, t.py),
+					new KzedMapTile(this, renderer, t.px+tileWidth, t.py),
+					new KzedMapTile(this, renderer, t.px, t.py-tileHeight),
+					new KzedMapTile(this, renderer, t.px, t.py+tileHeight)
+			};
+		}
+		return new MapTile[0];
+	}
+	
+	public void addTile(ArrayList<MapTile> tiles, int px, int py) {
+		for (int i=0;i<renderers.length;i++) {
+			tiles.add(new KzedMapTile(this, renderers[i], px, py));
+		}
+	}
+	
+	public void invalidateTile(MapTile tile) {
+		getMapManager().invalidateTile(tile);
+	}
+	
+	@Override
+	public Chunk[] getRequiredChunks(MapTile tile) {
+		if (tile instanceof KzedMapTile) {
+			KzedMapTile t = (KzedMapTile)tile;
+			int x1 = t.mx - KzedMap.tileHeight / 2;
+			int x2 = t.mx + KzedMap.tileWidth / 2 + KzedMap.tileHeight / 2;
+	
+			int z1 = t.mz - KzedMap.tileHeight / 2;
+			int z2 = t.mz + KzedMap.tileWidth / 2 + KzedMap.tileHeight / 2;
+	
+			int x, z;
+			
+			ArrayList<Chunk> chunks = new ArrayList<Chunk>();
+			World world = getWorld();
+			for(x=x1; x<x2; x+=16) {
+				for(z=z1; z<z2; z+=16) {
+					Chunk chunk = world.getChunkAt(x/16, z/16);
+					chunks.add(chunk);
+				}
+			}
+			Chunk[] result = new Chunk[chunks.size()];
+			chunks.toArray(result);
+			return result;
+		} else {
+			return new Chunk[0];
 		}
 	}
 	
 	@Override
-	public void render(MapTile tile) {
+	public boolean render(MapTile tile) {
 		if (tile instanceof KzedZoomedMapTile) {
 			zoomrenderer.render((KzedZoomedMapTile)tile, getMapManager().tileDirectory.getAbsolutePath());
+			return true;
 		} else if (tile instanceof KzedMapTile) {
-			((KzedMapTile)tile).renderer.render((KzedMapTile)tile, getMapManager().tileDirectory.getAbsolutePath());
+			return ((KzedMapTile)tile).renderer.render((KzedMapTile)tile, getMapManager().tileDirectory.getAbsolutePath());
 		}
+		return false;
+	}
+	
+	@Override
+	public boolean isRendered(MapTile tile) {
+		if (tile instanceof KzedMapTile) {
+			File tileFile = new File(DefaultTileRenderer.getPath((KzedMapTile)tile, getMapManager().tileDirectory.getAbsolutePath()));
+			return tileFile.exists();
+		}
+		return false;
 	}
 	
 	/* tile X for position x */
diff --git a/src/main/java/org/dynmap/kzedmap/KzedMapTile.java b/src/main/java/org/dynmap/kzedmap/KzedMapTile.java
index da4ed069..78a15c09 100644
--- a/src/main/java/org/dynmap/kzedmap/KzedMapTile.java
+++ b/src/main/java/org/dynmap/kzedmap/KzedMapTile.java
@@ -1,16 +1,15 @@
 package org.dynmap.kzedmap;
 
 import java.util.logging.Logger;
-
 import org.dynmap.MapTile;
 
 public class KzedMapTile extends MapTile {
 	protected static final Logger log = Logger.getLogger("Minecraft");
 
 	public KzedMap map;
-	
+
 	public MapTileRenderer renderer;
-	
+
 	/* projection position */
 	public int px, py;
 
@@ -20,6 +19,7 @@ public class KzedMapTile extends MapTile {
 	/* create new MapTile */
 	public KzedMapTile(KzedMap map, MapTileRenderer renderer, int px, int py) {
 		super(map);
+		this.map = map;
 		this.renderer = renderer;
 		this.px = px;
 		this.py = py;
@@ -28,107 +28,30 @@ public class KzedMapTile extends MapTile {
 		my = KzedMap.anchory;
 		mz = KzedMap.anchorz + px / 2 - py / 2;
 	}
-	
+
 	@Override
 	public String getName() {
 		return renderer.getName() + "_" + px + "_" + py;
 	}
-	
-	/* try to get the server to load the relevant chunks */
-	public void loadChunks()
-	{
-		int x1 = mx - 64;
-		int x2 = mx + KzedMap.tileWidth / 2 + KzedMap.tileHeight / 2;
 
-		int z1 = mz - KzedMap.tileHeight / 2;
-		int z2 = mz + KzedMap.tileWidth / 2 + 64;
-
-		int x, z;
-
-		for(x=x1; x<x2; x+=16) {
-			for(z=z1; z<z2; z+=16) {
-				if(!map.getWorld().isChunkLoaded(map.getWorld().getChunkAt(x, z))) {
-					log.info("chunk not loaded: " + x + ", 0, " + z);
-					/*
-
-					try {
-						s.loadChunk(x, 0, z);
-					} catch(Exception e) {
-						log.log(Level.SEVERE, "Caught exception from loadChunk!", e);
-					}*/
-				}
-			}
-		}
-	}
-
-	/* check if all relevant chunks are loaded */
-	public boolean isMapLoaded()
-	{
-		int x1 = mx - KzedMap.tileHeight / 2;
-		int x2 = mx + KzedMap.tileWidth / 2 + KzedMap.tileHeight / 2;
-
-		int z1 = mz - KzedMap.tileHeight / 2;
-		int z2 = mz + KzedMap.tileWidth / 2 + 64;
-
-		int x, z;
-
-		for(x=x1; x<x2; x+=16) {
-			for(z=z1; z<z2; z+=16) {
-				if(!map.getWorld().isChunkLoaded(map.getWorld().getChunkAt(x, z))) {
-					// Will try to load chunk.
-					//log.info("chunk not loaded: " + x + ", " + z + " for tile " + this.toString());
-					return false;
-					
-					// Sometimes give very heavy serverload:
-                                        /*try {
-                                                s.loadChunk(x, 0, z);
-                                        } catch(Exception e) {
-                                                log.log(Level.SEVERE, "Caught exception from loadChunk!", e);
-						return false;
-                                        }
-					if(!s.isChunkLoaded(x, 0, z)) {
-						log.info("Could not load chunk: " + x + ", " + z + " for tile " + this.toString());
-						return false;
-					}*/
-				}
-			}
-		}
-
-		return true;
-	}
-
-	/* get key by projection position */
-	public static long key(int px, int py)
-	{
-		long lpx = (long) px;
-		long lpy = (long) py;
-
-		return ((lpx & (long) 0xffffffffL) << 32) | (lpy & (long) 0xffffffffL);
-	}
-
-	/* hash value, based on projection position */
-	public int hashCode()
-	{
-		return ((px << 16) ^ py) ^ getName().hashCode();
+	public int hashCode() {
+		return getName().hashCode();
 	}
 
 	@Override
 	public boolean equals(Object obj) {
 		if (obj instanceof KzedMapTile) {
-			return equals((KzedMapTile)obj);
+			return equals((KzedMapTile) obj);
 		}
 		return super.equals(obj);
 	}
-	
-	/* equality comparison - based on projection position */
-	public boolean equals(KzedMapTile o)
-	{
-		return o.getName().equals(getName()) && o.px == px && o.py == py;
+
+	public boolean equals(KzedMapTile o) {
+		return o.getName().equals(getName());
 	}
 
 	/* return a simple string representation... */
-	public String toString()
-	{
-		return getName() + "_" + px + "_" + py;
+	public String toString() {
+		return getName();
 	}
 }
diff --git a/src/main/java/org/dynmap/kzedmap/KzedZoomedMapTile.java b/src/main/java/org/dynmap/kzedmap/KzedZoomedMapTile.java
index 2cd42cab..3cde3a9d 100644
--- a/src/main/java/org/dynmap/kzedmap/KzedZoomedMapTile.java
+++ b/src/main/java/org/dynmap/kzedmap/KzedZoomedMapTile.java
@@ -1,7 +1,6 @@
 package org.dynmap.kzedmap;
 
 import java.awt.image.BufferedImage;
-
 import org.dynmap.MapTile;
 
 public class KzedZoomedMapTile extends MapTile {
@@ -9,8 +8,10 @@ public class KzedZoomedMapTile extends MapTile {
 	public String getName() {
 		return "z" + originalTile.renderer.getName() + "_" + getTileX() + "_" + getTileY();
 	}
+
 	public BufferedImage unzoomedImage;
 	public KzedMapTile originalTile;
+
 	public KzedZoomedMapTile(KzedMap map, BufferedImage unzoomedImage, KzedMapTile original) {
 		super(map);
 		this.unzoomedImage = unzoomedImage;
@@ -18,38 +19,37 @@ public class KzedZoomedMapTile extends MapTile {
 	}
 
 	public int getTileX() {
-		return ztilex(originalTile.px+KzedMap.tileWidth);
+		return ztilex(originalTile.px + KzedMap.tileWidth);
 	}
-	
+
 	public int getTileY() {
 		return ztiley(originalTile.py);
 	}
-	
+
 	private static int ztilex(int x) {
-		if(x < 0)
-			return x + (x % (KzedMap.tileWidth*2));
+		if (x < 0)
+			return x + (x % (KzedMap.tileWidth * 2));
 		else
-			return x - (x % (KzedMap.tileWidth*2));
+			return x - (x % (KzedMap.tileWidth * 2));
 	}
 
 	/* zoomed-out tile Y for tile position y */
-	private static int ztiley(int y)
-	{
-		if(y < 0)
-			return y + (y % (KzedMap.tileHeight*2));
+	private static int ztiley(int y) {
+		if (y < 0)
+			return y + (y % (KzedMap.tileHeight * 2));
 		else
-			return y - (y % (KzedMap.tileHeight*2));
+			return y - (y % (KzedMap.tileHeight * 2));
 	}
-	
+
 	@Override
 	public int hashCode() {
 		return getName().hashCode();
 	}
-	
+
 	@Override
 	public boolean equals(Object obj) {
 		if (obj instanceof KzedZoomedMapTile) {
-			return ((KzedZoomedMapTile)obj).originalTile.equals(originalTile);
+			return ((KzedZoomedMapTile) obj).originalTile.equals(originalTile);
 		}
 		return super.equals(obj);
 	}
diff --git a/src/main/java/org/dynmap/kzedmap/MapTileRenderer.java b/src/main/java/org/dynmap/kzedmap/MapTileRenderer.java
index d75dc8aa..af2fc549 100644
--- a/src/main/java/org/dynmap/kzedmap/MapTileRenderer.java
+++ b/src/main/java/org/dynmap/kzedmap/MapTileRenderer.java
@@ -3,5 +3,5 @@ package org.dynmap.kzedmap;
 
 public interface MapTileRenderer {
 	String getName();
-	void render(KzedMapTile tile, String path);
+	boolean render(KzedMapTile tile, String path);
 }