Sulkta-OSS/dynmap-neoforge
3
0
Fork 0
Code Issues 1 Pull requests 10 Projects Releases Packages Wiki Activity Actions

Added chunk loading to rendering.

Browse source
This commit is contained in:
FrozenCow 2011-02-04 23:12:55 +01:00
parent adddc86047
commit ea0a286f0a
8 changed files with 175 additions and 289 deletions
Download patch file Download diff file Expand all files Collapse all files

30
src/main/java/org/dynmap/MapManager.java
View file

@ -7,6 +7,7 @@ import java.util.List;
import java.util.Map; import java.util.Map;
import java.util.logging.Logger; import java.util.logging.Logger;
import org.bukkit.Chunk;
import org.bukkit.Location; import org.bukkit.Location;
import org.bukkit.World; import org.bukkit.World;
import org.bukkit.event.player.PlayerChatEvent; import org.bukkit.event.player.PlayerChatEvent;
@ -135,24 +136,28 @@ public class MapManager extends Thread {
log.info("Map renderer has started."); log.info("Map renderer has started.");
while(running) { while(running) {
boolean found = false;
MapTile t = staleQueue.popStaleTile(); MapTile t = staleQueue.popStaleTile();
if(t != null) { if(t != null) {
debugger.debug("rendering tile " + t + "..."); MapType map = t.getMap();
t.getMap().render(t); 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); staleQueue.onTileUpdated(t);
try { try {
Thread.sleep(renderWait); Thread.sleep(renderWait);
} catch(InterruptedException e) { } catch(InterruptedException e) {
} }
} else {
found = true;
}
if(!found) {
try { try {
Thread.sleep(500); Thread.sleep(500);
} catch(InterruptedException e) { } catch(InterruptedException e) {
@ -168,12 +173,15 @@ public class MapManager extends Thread {
public void touch(int x, int y, int z) { public void touch(int x, int y, int z) {
for (int i = 0; i < maps.length; i++) { 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) { public void invalidateTile(MapTile tile) {
debugger.debug("invalidating tile " + tile.getName()); debugger.debug("Invalidating tile " + tile.getName());
staleQueue.pushStaleTile(tile); staleQueue.pushStaleTile(tile);
} }

12
src/main/java/org/dynmap/MapType.java
View file

@ -1,5 +1,6 @@
package org.dynmap; package org.dynmap;
import org.bukkit.Chunk;
import org.bukkit.Location; import org.bukkit.Location;
import org.bukkit.World; import org.bukkit.World;
import org.dynmap.debug.Debugger; import org.dynmap.debug.Debugger;
@ -26,10 +27,9 @@ public abstract class MapType {
this.debugger = debugger; this.debugger = debugger;
} }
public void invalidateTile(MapTile tile) { public abstract MapTile[] getTiles(Location l);
manager.invalidateTile(tile); public abstract MapTile[] getAdjecentTiles(MapTile tile);
} public abstract Chunk[] getRequiredChunks(MapTile tile);
public abstract boolean render(MapTile tile);
public abstract void touch(Location l); public abstract boolean isRendered(MapTile tile);
public abstract void render(MapTile tile);
} }

2
src/main/java/org/dynmap/kzedmap/CaveTileRenderer.java
View file

@ -18,7 +18,7 @@ public class CaveTileRenderer extends DefaultTileRenderer {
for(;;) { for(;;) {
if(y < 0) if(y < 0)
return Color.BLACK; return translucent;
int id = world.getBlockTypeIdAt(x, y, z); int id = world.getBlockTypeIdAt(x, y, z);

172
src/main/java/org/dynmap/kzedmap/DefaultTileRenderer.java
View file

@ -13,6 +13,7 @@ import org.bukkit.World;
import org.dynmap.debug.Debugger; import org.dynmap.debug.Debugger;
public class DefaultTileRenderer implements MapTileRenderer { public class DefaultTileRenderer implements MapTileRenderer {
protected static Color translucent = new Color(0, 0, 0, 0);
private String name; private String name;
protected Debugger debugger; protected Debugger debugger;
@ -22,14 +23,15 @@ public class DefaultTileRenderer implements MapTileRenderer {
public DefaultTileRenderer(Debugger debugger, Map<String, Object> configuration) { public DefaultTileRenderer(Debugger debugger, Map<String, Object> configuration) {
this.debugger = debugger; 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(); World world = tile.getMap().getWorld();
BufferedImage im = new BufferedImage(KzedMap.tileWidth, KzedMap.tileHeight, BufferedImage.TYPE_INT_RGB); BufferedImage im = new BufferedImage(KzedMap.tileWidth, KzedMap.tileHeight, BufferedImage.TYPE_INT_RGB);
WritableRaster r = im.getRaster(); WritableRaster r = im.getRaster();
boolean isempty = true;
int ix = tile.mx; int ix = tile.mx;
int iy = tile.my; int iy = tile.my;
@ -40,58 +42,59 @@ public class DefaultTileRenderer implements MapTileRenderer {
int x, y; int x, y;
/* draw the map */ /* draw the map */
for(y=0; y<KzedMap.tileHeight;) { for (y = 0; y < KzedMap.tileHeight;) {
jx = ix; jx = ix;
jz = iz; 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 c1 = scan(world, jx, iy, jz, 0);
Color c2 = scan(world, jx, iy, jz, 2); 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, 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++; jx++;
jz++; jz++;
} }
y ++; y++;
jx = ix; jx = ix;
jz = iz - 1; 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); Color c1 = scan(world, jx, iy, jz, 2);
jx++; jx++;
jz++; jz++;
Color c2 = scan(world, jx, iy, jz, 0); 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, 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 ++; ix++;
iz --; iz--;
} }
/* save the generated tile */ /* save the generated tile */
saveTile(tile, im, path); 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) protected Color scan(World world, int x, int y, int z, int seq) {
{ for (;;) {
for(;;) { if (y < 0)
if(y < 0) return translucent;
return Color.BLUE;
int id = world.getBlockTypeIdAt(x, y, z); int id = world.getBlockTypeIdAt(x, y, z);
switch(seq) { switch (seq) {
case 0: case 0:
x--; x--;
break; break;
@ -108,13 +111,13 @@ public class DefaultTileRenderer implements MapTileRenderer {
seq = (seq + 1) & 3; seq = (seq + 1) & 3;
if(id != 0) { if (id != 0) {
Color[] colors = KzedMap.colors.get(id); Color[] colors = KzedMap.colors.get(id);
if(colors != null) { if (colors != null) {
Color c = colors[seq]; Color c = colors[seq];
if(c.getAlpha() > 0) { if (c.getAlpha() > 0) {
/* we found something that isn't transparent! */ /* we found something that isn't transparent! */
if(c.getAlpha() == 255) { if (c.getAlpha() == 255) {
/* it's opaque - the ray ends here */ /* it's opaque - the ray ends here */
return c; return c;
} }
@ -139,8 +142,7 @@ public class DefaultTileRenderer implements MapTileRenderer {
} }
/* save rendered tile, update zoom-out tile */ /* 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); String tilePath = getPath(tile, path);
debugger.debug("saving tile " + tilePath); debugger.debug("saving tile " + tilePath);
@ -149,126 +151,14 @@ public class DefaultTileRenderer implements MapTileRenderer {
try { try {
File file = new File(tilePath); File file = new File(tilePath);
ImageIO.write(im, "png", file); ImageIO.write(im, "png", file);
} catch(IOException e) { } catch (IOException e) {
debugger.error("Failed to save tile: " + tilePath, 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); 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(); 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";
}
*/
} }

95
src/main/java/org/dynmap/kzedmap/KzedMap.java
View file

@ -12,6 +12,7 @@ import java.util.Map;
import java.util.Scanner; import java.util.Scanner;
import java.util.logging.Logger; import java.util.logging.Logger;
import org.bukkit.Chunk;
import org.bukkit.Location; import org.bukkit.Location;
import org.bukkit.World; import org.bukkit.World;
import org.dynmap.MapManager; import org.dynmap.MapManager;
@ -73,7 +74,7 @@ public class KzedMap extends MapType {
} }
@Override @Override
public void touch(Location l) { public MapTile[] getTiles(Location l) {
int x = l.getBlockX(); int x = l.getBlockX();
int y = l.getBlockY(); int y = l.getBlockY();
int z = l.getBlockZ(); int z = l.getBlockZ();
@ -87,37 +88,101 @@ public class KzedMap extends MapType {
int tx = tilex(px); int tx = tilex(px);
int ty = tiley(py); int ty = tiley(py);
invalidateTile(tx, ty); ArrayList<MapTile> tiles = new ArrayList<MapTile>();
addTile(tiles, tx, ty);
boolean ledge = tilex(px - 4) != tx; boolean ledge = tilex(px - 4) != tx;
boolean tedge = tiley(py - 4) != ty; boolean tedge = tiley(py - 4) != ty;
boolean redge = tilex(px + 4) != tx; boolean redge = tilex(px + 4) != tx;
boolean bedge = tiley(py + 4) != ty; boolean bedge = tiley(py + 4) != ty;
if(ledge) invalidateTile(tx - tileWidth, ty); if(ledge) addTile(tiles, tx - tileWidth, ty);
if(redge) invalidateTile(tx + tileWidth, ty); if(redge) addTile(tiles, tx + tileWidth, ty);
if(tedge) invalidateTile(tx, ty - tileHeight); if(tedge) addTile(tiles, tx, ty - tileHeight);
if(bedge) invalidateTile(tx, ty + tileHeight); if(bedge) addTile(tiles, tx, ty + tileHeight);
if(ledge && tedge) invalidateTile(tx - tileWidth, ty - tileHeight); if(ledge && tedge) addTile(tiles, tx - tileWidth, ty - tileHeight);
if(ledge && bedge) invalidateTile(tx - tileWidth, ty + tileHeight); if(ledge && bedge) addTile(tiles, tx - tileWidth, ty + tileHeight);
if(redge && tedge) invalidateTile(tx + tileWidth, ty - tileHeight); if(redge && tedge) addTile(tiles, tx + tileWidth, ty - tileHeight);
if(redge && bedge) invalidateTile(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) { @Override
for(MapTileRenderer renderer : renderers) { public MapTile[] getAdjecentTiles(MapTile tile) {
invalidateTile(new KzedMapTile(this, renderer, px, py)); 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 @Override
public void render(MapTile tile) { public boolean render(MapTile tile) {
if (tile instanceof KzedZoomedMapTile) { if (tile instanceof KzedZoomedMapTile) {
zoomrenderer.render((KzedZoomedMapTile)tile, getMapManager().tileDirectory.getAbsolutePath()); zoomrenderer.render((KzedZoomedMapTile)tile, getMapManager().tileDirectory.getAbsolutePath());
return true;
} else if (tile instanceof KzedMapTile) { } 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 */ /* tile X for position x */

93
src/main/java/org/dynmap/kzedmap/KzedMapTile.java
View file

@ -1,7 +1,6 @@
package org.dynmap.kzedmap; package org.dynmap.kzedmap;
import java.util.logging.Logger; import java.util.logging.Logger;
import org.dynmap.MapTile; import org.dynmap.MapTile;
public class KzedMapTile extends MapTile { public class KzedMapTile extends MapTile {
@ -20,6 +19,7 @@ public class KzedMapTile extends MapTile {
/* create new MapTile */ /* create new MapTile */
public KzedMapTile(KzedMap map, MapTileRenderer renderer, int px, int py) { public KzedMapTile(KzedMap map, MapTileRenderer renderer, int px, int py) {
super(map); super(map);
this.map = map;
this.renderer = renderer; this.renderer = renderer;
this.px = px; this.px = px;
this.py = py; this.py = py;
@ -34,101 +34,24 @@ public class KzedMapTile extends MapTile {
return renderer.getName() + "_" + px + "_" + py; return renderer.getName() + "_" + px + "_" + py;
} }
/* try to get the server to load the relevant chunks */ public int hashCode() {
public void loadChunks() return getName().hashCode();
{
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();
} }
@Override @Override
public boolean equals(Object obj) { public boolean equals(Object obj) {
if (obj instanceof KzedMapTile) { if (obj instanceof KzedMapTile) {
return equals((KzedMapTile)obj); return equals((KzedMapTile) obj);
} }
return super.equals(obj); return super.equals(obj);
} }
/* equality comparison - based on projection position */ public boolean equals(KzedMapTile o) {
public boolean equals(KzedMapTile o) return o.getName().equals(getName());
{
return o.getName().equals(getName()) && o.px == px && o.py == py;
} }
/* return a simple string representation... */ /* return a simple string representation... */
public String toString() public String toString() {
{ return getName();
return getName() + "_" + px + "_" + py;
} }
} }

22
src/main/java/org/dynmap/kzedmap/KzedZoomedMapTile.java
View file

@ -1,7 +1,6 @@
package org.dynmap.kzedmap; package org.dynmap.kzedmap;
import java.awt.image.BufferedImage; import java.awt.image.BufferedImage;
import org.dynmap.MapTile; import org.dynmap.MapTile;
public class KzedZoomedMapTile extends MapTile { public class KzedZoomedMapTile extends MapTile {
@ -9,8 +8,10 @@ public class KzedZoomedMapTile extends MapTile {
public String getName() { public String getName() {
return "z" + originalTile.renderer.getName() + "_" + getTileX() + "_" + getTileY(); return "z" + originalTile.renderer.getName() + "_" + getTileX() + "_" + getTileY();
} }
public BufferedImage unzoomedImage; public BufferedImage unzoomedImage;
public KzedMapTile originalTile; public KzedMapTile originalTile;
public KzedZoomedMapTile(KzedMap map, BufferedImage unzoomedImage, KzedMapTile original) { public KzedZoomedMapTile(KzedMap map, BufferedImage unzoomedImage, KzedMapTile original) {
super(map); super(map);
this.unzoomedImage = unzoomedImage; this.unzoomedImage = unzoomedImage;
@ -18,7 +19,7 @@ public class KzedZoomedMapTile extends MapTile {
} }
public int getTileX() { public int getTileX() {
return ztilex(originalTile.px+KzedMap.tileWidth); return ztilex(originalTile.px + KzedMap.tileWidth);
} }
public int getTileY() { public int getTileY() {
@ -26,19 +27,18 @@ public class KzedZoomedMapTile extends MapTile {
} }
private static int ztilex(int x) { private static int ztilex(int x) {
if(x < 0) if (x < 0)
return x + (x % (KzedMap.tileWidth*2)); return x + (x % (KzedMap.tileWidth * 2));
else else
return x - (x % (KzedMap.tileWidth*2)); return x - (x % (KzedMap.tileWidth * 2));
} }
/* zoomed-out tile Y for tile position y */ /* zoomed-out tile Y for tile position y */
private static int ztiley(int y) private static int ztiley(int y) {
{ if (y < 0)
if(y < 0) return y + (y % (KzedMap.tileHeight * 2));
return y + (y % (KzedMap.tileHeight*2));
else else
return y - (y % (KzedMap.tileHeight*2)); return y - (y % (KzedMap.tileHeight * 2));
} }
@Override @Override
@ -49,7 +49,7 @@ public class KzedZoomedMapTile extends MapTile {
@Override @Override
public boolean equals(Object obj) { public boolean equals(Object obj) {
if (obj instanceof KzedZoomedMapTile) { if (obj instanceof KzedZoomedMapTile) {
return ((KzedZoomedMapTile)obj).originalTile.equals(originalTile); return ((KzedZoomedMapTile) obj).originalTile.equals(originalTile);
} }
return super.equals(obj); return super.equals(obj);
} }

2
src/main/java/org/dynmap/kzedmap/MapTileRenderer.java
View file

@ -3,5 +3,5 @@ package org.dynmap.kzedmap;
public interface MapTileRenderer { public interface MapTileRenderer {
String getName(); String getName();
void render(KzedMapTile tile, String path); boolean render(KzedMapTile tile, String path);
} }