public int loadChunks(int max_to_load) {
if (dw.isLoaded() == false) return 0;
long t0 = System.nanoTime();
Object queue = helper.getUnloadQueue(helper.getNMSWorld(w));
int cnt = 0;
if (iterator == null) iterator = chunks.listIterator();
DynmapCore.setIgnoreChunkLoads(true);
// boolean isnormral = w.getEnvironment() == Environment.NORMAL;
// Load the required chunks.
while ((cnt < max_to_load) && iterator.hasNext()) {
DynmapChunk chunk = iterator.next();
boolean vis = true;
if (visible_limits != null) {
vis = false;
for (VisibilityLimit limit : visible_limits) {
if ((chunk.x >= limit.x0)
&& (chunk.x <= limit.x1)
&& (chunk.z >= limit.z0)
&& (chunk.z <= limit.z1)) {
vis = true;
break;
}
}
}
if (vis && (hidden_limits != null)) {
for (VisibilityLimit limit : hidden_limits) {
if ((chunk.x >= limit.x0)
&& (chunk.x <= limit.x1)
&& (chunk.z >= limit.z0)
&& (chunk.z <= limit.z1)) {
vis = false;
break;
}
}
}
/* Check if cached chunk snapshot found */
ChunkSnapshot ss = null;
DynIntHashMap tileData = null;
SnapshotRec ssr =
DynmapPlugin.plugin.sscache.getSnapshot(
dw.getName(), chunk.x, chunk.z, blockdata, biome, biomeraw, highesty);
if (ssr != null) {
ss = ssr.ss;
if (!vis) {
if (hidestyle == HiddenChunkStyle.FILL_STONE_PLAIN) ss = STONE;
else if (hidestyle == HiddenChunkStyle.FILL_OCEAN) ss = OCEAN;
else ss = EMPTY;
}
int idx = (chunk.x - x_min) + (chunk.z - z_min) * x_dim;
snaparray[idx] = ss;
snaptile[idx] = ssr.tileData;
continue;
}
chunks_attempted++;
boolean wasLoaded = w.isChunkLoaded(chunk.x, chunk.z);
boolean didload = false;
boolean isunloadpending = false;
if (queue != null) {
isunloadpending = helper.isInUnloadQueue(queue, chunk.x, chunk.z);
}
if (isunloadpending) {
/* Workaround: can't be pending if not loaded */
wasLoaded = true;
}
try {
if (!wasLoaded) {
didload = w.loadChunk(chunk.x, chunk.z, false);
} else {
/* If already was loaded, no need to load */
didload = true;
}
} catch (Throwable t) {
/* Catch chunk error from Bukkit */
Log.warning("Bukkit error loading chunk " + chunk.x + "," + chunk.z + " on " + w.getName());
if (!wasLoaded) {
/* If wasn't loaded, we loaded it if it now is */
didload = w.isChunkLoaded(chunk.x, chunk.z);
}
}
boolean didgenerate = false;
/* If we didn't load, and we're supposed to generate, do it */
if ((!didload) && do_generate && vis)
didgenerate = didload = w.loadChunk(chunk.x, chunk.z, true);
/* If it did load, make cache of it */
if (didload) {
tileData = new DynIntHashMap();
Chunk c = w.getChunkAt(chunk.x, chunk.z); /* Get the chunk */
/* Test if chunk isn't populated */
boolean populated = true;
// TODO: figure out why this doesn't appear to be reliable in Bukkit
// if((nmschunk != null) && (doneflag != null)) {
// try {
// populated = doneflag.getBoolean(nmschunk);
// } catch (IllegalArgumentException e) {
// } catch (IllegalAccessException e) {
// }
// }
if (!vis) {
if (hidestyle == HiddenChunkStyle.FILL_STONE_PLAIN) ss = STONE;
else if (hidestyle == HiddenChunkStyle.FILL_OCEAN) ss = OCEAN;
else ss = EMPTY;
} else if (!populated) {
/* If not populated, treat as empty */
ss = EMPTY;
} else {
if (blockdata || highesty) {
ss = c.getChunkSnapshot(highesty, biome, biomeraw);
if (use_spout) {
ss = checkSpoutData(c, ss);
}
/* Get tile entity data */
List<Object> vals = new ArrayList<Object>();
Map tileents = helper.getTileEntitiesForChunk(c);
for (Object t : tileents.values()) {
int te_x = helper.getTileEntityX(t);
int te_y = helper.getTileEntityY(t);
int te_z = helper.getTileEntityZ(t);
int cx = te_x & 0xF;
int cz = te_z & 0xF;
int blkid = ss.getBlockTypeId(cx, te_y, cz);
int blkdat = ss.getBlockData(cx, te_y, cz);
String[] te_fields = HDBlockModels.getTileEntityFieldsNeeded(blkid, blkdat);
if (te_fields != null) {
Object nbtcompound = helper.readTileEntityNBT(t);
vals.clear();
for (String id : te_fields) {
Object val = helper.getFieldValue(nbtcompound, id);
if (val != null) {
vals.add(id);
vals.add(val);
}
}
if (vals.size() > 0) {
Object[] vlist = vals.toArray(new Object[vals.size()]);
tileData.put(getIndexInChunk(cx, te_y, cz), vlist);
}
}
}
} else ss = w.getEmptyChunkSnapshot(chunk.x, chunk.z, biome, biomeraw);
if (ss != null) {
ssr = new SnapshotRec();
ssr.ss = ss;
ssr.tileData = tileData;
DynmapPlugin.plugin.sscache.putSnapshot(
dw.getName(), chunk.x, chunk.z, ssr, blockdata, biome, biomeraw, highesty);
}
}
snaparray[(chunk.x - x_min) + (chunk.z - z_min) * x_dim] = ss;
snaptile[(chunk.x - x_min) + (chunk.z - z_min) * x_dim] = tileData;
/* If wasn't loaded before, we need to do unload */
if (!wasLoaded) {
chunks_read++;
/* It looks like bukkit "leaks" entities - they don't get removed from the world-level table
* when chunks are unloaded but not saved - removing them seems to do the trick */
if (!(didgenerate && do_save)) {
helper.removeEntitiesFromChunk(c);
}
/* Since we only remember ones we loaded, and we're synchronous, no player has
* moved, so it must be safe (also prevent chunk leak, which appears to happen
* because isChunkInUse defined "in use" as being within 256 blocks of a player,
* while the actual in-use chunk area for a player where the chunks are managed
* by the MC base server is 21x21 (or about a 160 block radius).
* Also, if we did generate it, need to save it */
w.unloadChunk(chunk.x, chunk.z, didgenerate && do_save, false);
} else if (isunloadpending) {
/* Else, if loaded and unload is pending */
w.unloadChunkRequest(chunk.x, chunk.z); /* Request new unload */
}
}
cnt++;
}
DynmapCore.setIgnoreChunkLoads(false);
if (iterator.hasNext() == false) {
/* If we're done */
isempty = true;
/* Fill missing chunks with empty dummy chunk */
for (int i = 0; i < snaparray.length; i++) {
if (snaparray[i] == null) snaparray[i] = EMPTY;
else if (snaparray[i] != EMPTY) isempty = false;
}
}
total_loadtime += System.nanoTime() - t0;
return cnt;
}
/**
* Container for managing chunks - dependent upon using chunk snapshots, since rendering is off
* server thread
*/
public class NewMapChunkCache implements MapChunkCache {
private static boolean init = false;
private static boolean use_spout = false;
private World w;
private DynmapWorld dw;
private int nsect;
private List<DynmapChunk> chunks;
private ListIterator<DynmapChunk> iterator;
private int x_min, x_max, z_min, z_max;
private int x_dim;
private boolean biome, biomeraw, highesty, blockdata;
private HiddenChunkStyle hidestyle = HiddenChunkStyle.FILL_AIR;
private List<VisibilityLimit> visible_limits = null;
private List<VisibilityLimit> hidden_limits = null;
private boolean do_generate = false;
private boolean do_save = false;
private boolean isempty = true;
private ChunkSnapshot[] snaparray; /* Index = (x-x_min) + ((z-z_min)*x_dim) */
private DynIntHashMap[] snaptile;
private byte[][] sameneighborbiomecnt;
private BiomeMap[][] biomemap;
private boolean[][] isSectionNotEmpty; /* Indexed by snapshot index, then by section index */
private int chunks_read; /* Number of chunks actually loaded */
private int chunks_attempted; /* Number of chunks attempted to load */
private long total_loadtime; /* Total time loading chunks, in nanoseconds */
private long exceptions;
private static BukkitVersionHelper helper = BukkitVersionHelper.getHelper();
private static final BlockStep unstep[] = {
BlockStep.X_MINUS,
BlockStep.Y_MINUS,
BlockStep.Z_MINUS,
BlockStep.X_PLUS,
BlockStep.Y_PLUS,
BlockStep.Z_PLUS
};
private static BiomeMap[] biome_to_bmap;
private static final int getIndexInChunk(int cx, int cy, int cz) {
return (cy << 8) | (cz << 4) | cx;
}
/** Iterator for traversing map chunk cache (base is for non-snapshot) */
public class OurMapIterator implements MapIterator {
@SuppressWarnings("unused")
private int x, y, z, chunkindex, bx, bz, off;
private ChunkSnapshot snap;
private BlockStep laststep;
private int typeid = -1;
private int blkdata = -1;
private final int worldheight;
private final int x_base;
private final int z_base;
OurMapIterator(int x0, int y0, int z0) {
x_base = x_min << 4;
z_base = z_min << 4;
if (biome) biomePrep();
initialize(x0, y0, z0);
worldheight = w.getMaxHeight();
}
public final void initialize(int x0, int y0, int z0) {
this.x = x0;
this.y = y0;
this.z = z0;
this.chunkindex = ((x >> 4) - x_min) + (((z >> 4) - z_min) * x_dim);
this.bx = x & 0xF;
this.bz = z & 0xF;
this.off = bx + (bz << 4);
try {
snap = snaparray[chunkindex];
} catch (ArrayIndexOutOfBoundsException aioobx) {
snap = EMPTY;
exceptions++;
}
laststep = BlockStep.Y_MINUS;
if ((y >= 0) && (y < worldheight)) typeid = blkdata = -1;
else typeid = blkdata = 0;
}
public final int getBlockTypeID() {
if (typeid < 0) {
typeid = snap.getBlockTypeId(bx, y, bz);
}
return typeid;
}
public final int getBlockData() {
if (blkdata < 0) {
blkdata = snap.getBlockData(bx, y, bz);
}
return blkdata;
}
public int getBlockSkyLight() {
try {
return snap.getBlockSkyLight(bx, y, bz);
} catch (ArrayIndexOutOfBoundsException aioobx) {
return 15;
}
}
public final int getBlockEmittedLight() {
try {
return snap.getBlockEmittedLight(bx, y, bz);
} catch (ArrayIndexOutOfBoundsException aioobx) {
return 0;
}
}
private void biomePrep() {
if (sameneighborbiomecnt != null) return;
int x_size = x_dim << 4;
int z_size = (z_max - z_min + 1) << 4;
sameneighborbiomecnt = new byte[x_size][];
biomemap = new BiomeMap[x_size][];
for (int i = 0; i < x_size; i++) {
sameneighborbiomecnt[i] = new byte[z_size];
biomemap[i] = new BiomeMap[z_size];
}
Object[] biomebase = null;
ChunkSnapshot biome_css = null;
for (int i = 0; i < x_size; i++) {
initialize(i + x_base, 64, z_base);
for (int j = 0; j < z_size; j++) {
BiomeMap bm;
if (snap != biome_css) {
biomebase = null;
biome_css = snap;
if (biome_css instanceof SpoutChunkSnapshot) {
biome_css = ((SpoutChunkSnapshot) biome_css).chunk;
}
biomebase = helper.getBiomeBaseFromSnapshot(biome_css);
}
if (biomebase != null) {
bm = BiomeMap.byBiomeID(helper.getBiomeBaseID(biomebase[bz << 4 | bx]));
} else {
Biome bb = snap.getBiome(bx, bz);
if (bb == null) bm = BiomeMap.NULL;
else bm = biome_to_bmap[bb.ordinal()];
}
biomemap[i][j] = bm;
int cnt = 0;
if (i > 0) {
if (bm == biomemap[i - 1][j]) {
/* Same as one to left */
cnt++;
sameneighborbiomecnt[i - 1][j]++;
}
if ((j > 0) && (bm == biomemap[i - 1][j - 1])) {
cnt++;
sameneighborbiomecnt[i - 1][j - 1]++;
}
if ((j < (z_size - 1)) && (bm == biomemap[i - 1][j + 1])) {
cnt++;
sameneighborbiomecnt[i - 1][j + 1]++;
}
}
if ((j > 0) && (biomemap[i][j] == biomemap[i][j - 1])) {
/* Same as one to above */
cnt++;
sameneighborbiomecnt[i][j - 1]++;
}
sameneighborbiomecnt[i][j] = (byte) cnt;
stepPosition(BlockStep.Z_PLUS);
}
}
}
public final BiomeMap getBiome() {
try {
return biomemap[x - x_base][z - z_base];
} catch (Exception ex) {
exceptions++;
return BiomeMap.NULL;
}
}
public final int getSmoothGrassColorMultiplier(int[] colormap, int width) {
int mult = 0xFFFFFF;
try {
int rx = x - x_base;
int rz = z - z_base;
BiomeMap bm = biomemap[rx][rz];
if (sameneighborbiomecnt[rx][rz] >= (byte) 8) {
/* All neighbors same? */
mult = bm.getModifiedGrassMultiplier(colormap[bm.biomeLookup(width)]);
} else {
int raccum = 0;
int gaccum = 0;
int baccum = 0;
for (int xoff = -1; xoff < 2; xoff++) {
for (int zoff = -1; zoff < 2; zoff++) {
bm = biomemap[rx + xoff][rz + zoff];
int rmult = bm.getModifiedGrassMultiplier(colormap[bm.biomeLookup(width)]);
raccum += (rmult >> 16) & 0xFF;
gaccum += (rmult >> 8) & 0xFF;
baccum += rmult & 0xFF;
}
}
mult = ((raccum / 9) << 16) | ((gaccum / 9) << 8) | (baccum / 9);
}
} catch (Exception x) {
exceptions++;
mult = 0xFFFFFF;
}
return mult;
}
public final int getSmoothFoliageColorMultiplier(int[] colormap, int width) {
int mult = 0xFFFFFF;
try {
int rx = x - x_base;
int rz = z - z_base;
BiomeMap bm = biomemap[rx][rz];
if (sameneighborbiomecnt[rx][rz] >= (byte) 8) {
/* All neighbors same? */
mult = bm.getModifiedFoliageMultiplier(colormap[bm.biomeLookup(width)]);
} else {
int raccum = 0;
int gaccum = 0;
int baccum = 0;
for (int xoff = -1; xoff < 2; xoff++) {
for (int zoff = -1; zoff < 2; zoff++) {
bm = biomemap[rx + xoff][rz + zoff];
int rmult = bm.getModifiedFoliageMultiplier(colormap[bm.biomeLookup(width)]);
raccum += (rmult >> 16) & 0xFF;
gaccum += (rmult >> 8) & 0xFF;
baccum += rmult & 0xFF;
}
}
mult = ((raccum / 9) << 16) | ((gaccum / 9) << 8) | (baccum / 9);
}
} catch (Exception x) {
exceptions++;
mult = 0xFFFFFF;
}
return mult;
}
public final int getSmoothColorMultiplier(
int[] colormap, int width, int[] swampmap, int swampwidth) {
int mult = 0xFFFFFF;
try {
int rx = x - x_base;
int rz = z - z_base;
BiomeMap bm = biomemap[rx][rz];
if (sameneighborbiomecnt[rx][rz] >= (byte) 8) {
/* All neighbors same? */
if (bm == BiomeMap.SWAMPLAND) {
mult = swampmap[bm.biomeLookup(swampwidth)];
} else {
mult = colormap[bm.biomeLookup(width)];
}
} else {
int raccum = 0;
int gaccum = 0;
int baccum = 0;
for (int xoff = -1; xoff < 2; xoff++) {
for (int zoff = -1; zoff < 2; zoff++) {
bm = biomemap[rx + xoff][rz + zoff];
int rmult;
if (bm == BiomeMap.SWAMPLAND) {
rmult = swampmap[bm.biomeLookup(swampwidth)];
} else {
rmult = colormap[bm.biomeLookup(width)];
}
raccum += (rmult >> 16) & 0xFF;
gaccum += (rmult >> 8) & 0xFF;
baccum += rmult & 0xFF;
}
}
mult = ((raccum / 9) << 16) | ((gaccum / 9) << 8) | (baccum / 9);
}
} catch (Exception x) {
exceptions++;
mult = 0xFFFFFF;
}
return mult;
}
public final int getSmoothWaterColorMultiplier() {
try {
int rx = x - x_base;
int rz = z - z_base;
BiomeMap bm = biomemap[rx][rz];
if (sameneighborbiomecnt[rx][rz] >= (byte) 8) {
/* All neighbors same? */
return bm.getWaterColorMult();
}
int raccum = 0;
int gaccum = 0;
int baccum = 0;
for (int xoff = -1; xoff < 2; xoff++) {
for (int zoff = -1; zoff < 2; zoff++) {
bm = biomemap[rx + xoff][rz + zoff];
int mult = bm.getWaterColorMult();
raccum += (mult >> 16) & 0xFF;
gaccum += (mult >> 8) & 0xFF;
baccum += mult & 0xFF;
}
}
return ((raccum / 9) << 16) | ((gaccum / 9) << 8) | (baccum / 9);
} catch (Exception x) {
exceptions++;
return 0xFFFFFF;
}
}
public final int getSmoothWaterColorMultiplier(int[] colormap, int width) {
int mult = 0xFFFFFF;
try {
int rx = x - x_base;
int rz = z - z_base;
BiomeMap bm = biomemap[rx][rz];
if (sameneighborbiomecnt[rx][rz] >= (byte) 8) {
/* All neighbors same? */
mult = colormap[bm.biomeLookup(width)];
} else {
int raccum = 0;
int gaccum = 0;
int baccum = 0;
for (int xoff = -1; xoff < 2; xoff++) {
for (int zoff = -1; zoff < 2; zoff++) {
bm = biomemap[rx + xoff][rz + zoff];
int rmult = colormap[bm.biomeLookup(width)];
raccum += (rmult >> 16) & 0xFF;
gaccum += (rmult >> 8) & 0xFF;
baccum += rmult & 0xFF;
}
}
mult = ((raccum / 9) << 16) | ((gaccum / 9) << 8) | (baccum / 9);
}
} catch (Exception x) {
exceptions++;
mult = 0xFFFFFF;
}
return mult;
}
public final double getRawBiomeTemperature() {
return snap.getRawBiomeTemperature(bx, bz);
}
public final double getRawBiomeRainfall() {
return snap.getRawBiomeRainfall(bx, bz);
}
/** Step current position in given direction */
public final void stepPosition(BlockStep step) {
typeid = -1;
blkdata = -1;
switch (step.ordinal()) {
case 0:
x++;
bx++;
off++;
if (bx == 16) {
/* Next chunk? */
try {
bx = 0;
off -= 16;
chunkindex++;
snap = snaparray[chunkindex];
} catch (ArrayIndexOutOfBoundsException aioobx) {
snap = EMPTY;
exceptions++;
}
}
break;
case 1:
y++;
if (y >= worldheight) {
typeid = blkdata = 0;
}
break;
case 2:
z++;
bz++;
off += 16;
if (bz == 16) {
/* Next chunk? */
try {
bz = 0;
off -= 256;
chunkindex += x_dim;
snap = snaparray[chunkindex];
} catch (ArrayIndexOutOfBoundsException aioobx) {
snap = EMPTY;
exceptions++;
}
}
break;
case 3:
x--;
bx--;
off--;
if (bx == -1) {
/* Next chunk? */
try {
bx = 15;
off += 16;
chunkindex--;
snap = snaparray[chunkindex];
} catch (ArrayIndexOutOfBoundsException aioobx) {
snap = EMPTY;
exceptions++;
}
}
break;
case 4:
y--;
if (y < 0) {
typeid = blkdata = 0;
}
break;
case 5:
z--;
bz--;
off -= 16;
if (bz == -1) {
/* Next chunk? */
try {
bz = 15;
off += 256;
chunkindex -= x_dim;
snap = snaparray[chunkindex];
} catch (ArrayIndexOutOfBoundsException aioobx) {
snap = EMPTY;
exceptions++;
}
}
break;
}
laststep = step;
}
/** Unstep current position to previous position */
public BlockStep unstepPosition() {
BlockStep ls = laststep;
stepPosition(unstep[ls.ordinal()]);
return ls;
}
/** Unstep current position in oppisite director of given step */
public void unstepPosition(BlockStep s) {
stepPosition(unstep[s.ordinal()]);
}
public final void setY(int y) {
if (y > this.y) laststep = BlockStep.Y_PLUS;
else laststep = BlockStep.Y_MINUS;
this.y = y;
if ((y < 0) || (y >= worldheight)) {
typeid = blkdata = 0;
} else {
typeid = blkdata = -1;
}
}
public final int getX() {
return x;
}
public final int getY() {
return y;
}
public final int getZ() {
return z;
}
public final int getBlockTypeIDAt(BlockStep s) {
if (s == BlockStep.Y_MINUS) {
if (y > 0) return snap.getBlockTypeId(bx, y - 1, bz);
} else if (s == BlockStep.Y_PLUS) {
if (y < (worldheight - 1)) return snap.getBlockTypeId(bx, y + 1, bz);
} else {
BlockStep ls = laststep;
stepPosition(s);
int tid = snap.getBlockTypeId(bx, y, bz);
unstepPosition();
laststep = ls;
return tid;
}
return 0;
}
public BlockStep getLastStep() {
return laststep;
}
@Override
public int getWorldHeight() {
return worldheight;
}
@Override
public long getBlockKey() {
return (((chunkindex * worldheight) + y) << 8) | (bx << 4) | bz;
}
@Override
public final boolean isEmptySection() {
try {
return !isSectionNotEmpty[chunkindex][y >> 4];
} catch (Exception x) {
initSectionData(chunkindex);
return !isSectionNotEmpty[chunkindex][y >> 4];
}
}
@Override
public RenderPatchFactory getPatchFactory() {
return HDBlockModels.getPatchDefinitionFactory();
}
@Override
public Object getBlockTileEntityField(String fieldId) {
try {
int idx = getIndexInChunk(bx, y, bz);
Object[] vals = (Object[]) snaptile[chunkindex].get(idx);
for (int i = 0; i < vals.length; i += 2) {
if (vals[i].equals(fieldId)) {
return vals[i + 1];
}
}
} catch (Exception x) {
}
return null;
}
@Override
public int getBlockTypeIDAt(int xoff, int yoff, int zoff) {
int xx = this.x + xoff;
int yy = this.y + yoff;
int zz = this.z + zoff;
int idx = ((xx >> 4) - x_min) + (((zz >> 4) - z_min) * x_dim);
try {
return snaparray[idx].getBlockTypeId(xx & 0xF, yy, zz & 0xF);
} catch (Exception x) {
return 0;
}
}
@Override
public int getBlockDataAt(int xoff, int yoff, int zoff) {
int xx = this.x + xoff;
int yy = this.y + yoff;
int zz = this.z + zoff;
int idx = ((xx >> 4) - x_min) + (((zz >> 4) - z_min) * x_dim);
try {
return snaparray[idx].getBlockData(xx & 0xF, yy, zz & 0xF);
} catch (Exception x) {
return 0;
}
}
@Override
public Object getBlockTileEntityFieldAt(String fieldId, int xoff, int yoff, int zoff) {
return null;
}
}
private class OurEndMapIterator extends OurMapIterator {
OurEndMapIterator(int x0, int y0, int z0) {
super(x0, y0, z0);
}
public final int getBlockSkyLight() {
return 15;
}
}
/** Chunk cache for representing unloaded chunk (or air) */
private static class EmptyChunk implements ChunkSnapshot {
/* Need these for interface, but not used */
public int getX() {
return 0;
}
public int getZ() {
return 0;
}
public String getWorldName() {
return "";
}
public long getCaptureFullTime() {
return 0;
}
public final int getBlockTypeId(int x, int y, int z) {
return 0;
}
public final int getBlockData(int x, int y, int z) {
return 0;
}
public final int getBlockSkyLight(int x, int y, int z) {
return 15;
}
public final int getBlockEmittedLight(int x, int y, int z) {
return 0;
}
public final int getHighestBlockYAt(int x, int z) {
return 0;
}
public Biome getBiome(int x, int z) {
return null;
}
public double getRawBiomeTemperature(int x, int z) {
return 0.0;
}
public double getRawBiomeRainfall(int x, int z) {
return 0.0;
}
public boolean isSectionEmpty(int sy) {
return true;
}
}
/** Chunk cache for representing generic stone chunk */
private static class PlainChunk implements ChunkSnapshot {
private int fillid;
PlainChunk(int fillid) {
this.fillid = fillid;
}
/* Need these for interface, but not used */
public int getX() {
return 0;
}
public int getZ() {
return 0;
}
public String getWorldName() {
return "";
}
public Biome getBiome(int x, int z) {
return null;
}
public double getRawBiomeTemperature(int x, int z) {
return 0.0;
}
public double getRawBiomeRainfall(int x, int z) {
return 0.0;
}
public long getCaptureFullTime() {
return 0;
}
public final int getBlockTypeId(int x, int y, int z) {
if (y < 64) return fillid;
return 0;
}
public final int getBlockData(int x, int y, int z) {
return 0;
}
public final int getBlockSkyLight(int x, int y, int z) {
if (y < 64) return 0;
return 15;
}
public final int getBlockEmittedLight(int x, int y, int z) {
return 0;
}
public final int getHighestBlockYAt(int x, int z) {
return 64;
}
public boolean isSectionEmpty(int sy) {
return (sy < 4);
}
}
private static class SpoutChunkSnapshot implements ChunkSnapshot {
private ChunkSnapshot chunk;
private short[] customids;
private final int shiftx;
private final int shiftz;
SpoutChunkSnapshot(ChunkSnapshot chunk, short[] customids, int height) {
this.chunk = chunk;
this.customids = customids.clone();
int sx = 11;
int sz = 7; /* 128 high values */
while (height > 128) {
sx++;
sz++;
height = (height >> 1);
}
shiftx = sx;
shiftz = sz;
}
/* Need these for interface, but not used */
public final int getX() {
return chunk.getX();
}
public final int getZ() {
return chunk.getZ();
}
public final String getWorldName() {
return chunk.getWorldName();
}
public final Biome getBiome(int x, int z) {
return chunk.getBiome(x, z);
}
public final double getRawBiomeTemperature(int x, int z) {
return chunk.getRawBiomeTemperature(x, z);
}
public final double getRawBiomeRainfall(int x, int z) {
return chunk.getRawBiomeRainfall(x, z);
}
public final long getCaptureFullTime() {
return chunk.getCaptureFullTime();
}
public final int getBlockTypeId(int x, int y, int z) {
int id = customids[(x << shiftx) | (z << shiftz) | y];
if (id != 0) return id;
return chunk.getBlockTypeId(x, y, z);
}
public final int getBlockData(int x, int y, int z) {
return chunk.getBlockData(x, y, z);
}
public final int getBlockSkyLight(int x, int y, int z) {
return chunk.getBlockSkyLight(x, y, z);
}
public final int getBlockEmittedLight(int x, int y, int z) {
return chunk.getBlockEmittedLight(x, y, z);
}
public final int getHighestBlockYAt(int x, int z) {
return chunk.getHighestBlockYAt(x, z);
}
public boolean isSectionEmpty(int sy) {
return chunk.isSectionEmpty(sy);
}
}
private static final EmptyChunk EMPTY = new EmptyChunk();
private static final PlainChunk STONE = new PlainChunk(1);
private static final PlainChunk OCEAN = new PlainChunk(9);
/** Construct empty cache */
public NewMapChunkCache() {
if (!init) {
use_spout = DynmapPlugin.plugin.hasSpout();
init = true;
}
}
public void setChunks(BukkitWorld dw, List<DynmapChunk> chunks) {
this.dw = dw;
this.w = dw.getWorld();
if (this.w == null) {
this.chunks = new ArrayList<DynmapChunk>();
}
nsect = dw.worldheight >> 4;
this.chunks = chunks;
/* Compute range */
if (chunks.size() == 0) {
this.x_min = 0;
this.x_max = 0;
this.z_min = 0;
this.z_max = 0;
x_dim = 1;
} else {
x_min = x_max = chunks.get(0).x;
z_min = z_max = chunks.get(0).z;
for (DynmapChunk c : chunks) {
if (c.x > x_max) x_max = c.x;
if (c.x < x_min) x_min = c.x;
if (c.z > z_max) z_max = c.z;
if (c.z < z_min) z_min = c.z;
}
x_dim = x_max - x_min + 1;
}
int snapcnt = x_dim * (z_max - z_min + 1);
snaparray = new ChunkSnapshot[snapcnt];
snaptile = new DynIntHashMap[snapcnt];
isSectionNotEmpty = new boolean[snapcnt][];
}
private ChunkSnapshot checkSpoutData(Chunk c, ChunkSnapshot ss) {
if (c instanceof SpoutChunk) {
SpoutChunk sc = (SpoutChunk) c;
short[] custids = sc.getCustomBlockIds();
if (custids != null) {
return new SpoutChunkSnapshot(ss, custids, c.getWorld().getMaxHeight());
}
}
return ss;
}
public int loadChunks(int max_to_load) {
if (dw.isLoaded() == false) return 0;
long t0 = System.nanoTime();
Object queue = helper.getUnloadQueue(helper.getNMSWorld(w));
int cnt = 0;
if (iterator == null) iterator = chunks.listIterator();
DynmapCore.setIgnoreChunkLoads(true);
// boolean isnormral = w.getEnvironment() == Environment.NORMAL;
// Load the required chunks.
while ((cnt < max_to_load) && iterator.hasNext()) {
DynmapChunk chunk = iterator.next();
boolean vis = true;
if (visible_limits != null) {
vis = false;
for (VisibilityLimit limit : visible_limits) {
if ((chunk.x >= limit.x0)
&& (chunk.x <= limit.x1)
&& (chunk.z >= limit.z0)
&& (chunk.z <= limit.z1)) {
vis = true;
break;
}
}
}
if (vis && (hidden_limits != null)) {
for (VisibilityLimit limit : hidden_limits) {
if ((chunk.x >= limit.x0)
&& (chunk.x <= limit.x1)
&& (chunk.z >= limit.z0)
&& (chunk.z <= limit.z1)) {
vis = false;
break;
}
}
}
/* Check if cached chunk snapshot found */
ChunkSnapshot ss = null;
DynIntHashMap tileData = null;
SnapshotRec ssr =
DynmapPlugin.plugin.sscache.getSnapshot(
dw.getName(), chunk.x, chunk.z, blockdata, biome, biomeraw, highesty);
if (ssr != null) {
ss = ssr.ss;
if (!vis) {
if (hidestyle == HiddenChunkStyle.FILL_STONE_PLAIN) ss = STONE;
else if (hidestyle == HiddenChunkStyle.FILL_OCEAN) ss = OCEAN;
else ss = EMPTY;
}
int idx = (chunk.x - x_min) + (chunk.z - z_min) * x_dim;
snaparray[idx] = ss;
snaptile[idx] = ssr.tileData;
continue;
}
chunks_attempted++;
boolean wasLoaded = w.isChunkLoaded(chunk.x, chunk.z);
boolean didload = false;
boolean isunloadpending = false;
if (queue != null) {
isunloadpending = helper.isInUnloadQueue(queue, chunk.x, chunk.z);
}
if (isunloadpending) {
/* Workaround: can't be pending if not loaded */
wasLoaded = true;
}
try {
if (!wasLoaded) {
didload = w.loadChunk(chunk.x, chunk.z, false);
} else {
/* If already was loaded, no need to load */
didload = true;
}
} catch (Throwable t) {
/* Catch chunk error from Bukkit */
Log.warning("Bukkit error loading chunk " + chunk.x + "," + chunk.z + " on " + w.getName());
if (!wasLoaded) {
/* If wasn't loaded, we loaded it if it now is */
didload = w.isChunkLoaded(chunk.x, chunk.z);
}
}
boolean didgenerate = false;
/* If we didn't load, and we're supposed to generate, do it */
if ((!didload) && do_generate && vis)
didgenerate = didload = w.loadChunk(chunk.x, chunk.z, true);
/* If it did load, make cache of it */
if (didload) {
tileData = new DynIntHashMap();
Chunk c = w.getChunkAt(chunk.x, chunk.z); /* Get the chunk */
/* Test if chunk isn't populated */
boolean populated = true;
// TODO: figure out why this doesn't appear to be reliable in Bukkit
// if((nmschunk != null) && (doneflag != null)) {
// try {
// populated = doneflag.getBoolean(nmschunk);
// } catch (IllegalArgumentException e) {
// } catch (IllegalAccessException e) {
// }
// }
if (!vis) {
if (hidestyle == HiddenChunkStyle.FILL_STONE_PLAIN) ss = STONE;
else if (hidestyle == HiddenChunkStyle.FILL_OCEAN) ss = OCEAN;
else ss = EMPTY;
} else if (!populated) {
/* If not populated, treat as empty */
ss = EMPTY;
} else {
if (blockdata || highesty) {
ss = c.getChunkSnapshot(highesty, biome, biomeraw);
if (use_spout) {
ss = checkSpoutData(c, ss);
}
/* Get tile entity data */
List<Object> vals = new ArrayList<Object>();
Map tileents = helper.getTileEntitiesForChunk(c);
for (Object t : tileents.values()) {
int te_x = helper.getTileEntityX(t);
int te_y = helper.getTileEntityY(t);
int te_z = helper.getTileEntityZ(t);
int cx = te_x & 0xF;
int cz = te_z & 0xF;
int blkid = ss.getBlockTypeId(cx, te_y, cz);
int blkdat = ss.getBlockData(cx, te_y, cz);
String[] te_fields = HDBlockModels.getTileEntityFieldsNeeded(blkid, blkdat);
if (te_fields != null) {
Object nbtcompound = helper.readTileEntityNBT(t);
vals.clear();
for (String id : te_fields) {
Object val = helper.getFieldValue(nbtcompound, id);
if (val != null) {
vals.add(id);
vals.add(val);
}
}
if (vals.size() > 0) {
Object[] vlist = vals.toArray(new Object[vals.size()]);
tileData.put(getIndexInChunk(cx, te_y, cz), vlist);
}
}
}
} else ss = w.getEmptyChunkSnapshot(chunk.x, chunk.z, biome, biomeraw);
if (ss != null) {
ssr = new SnapshotRec();
ssr.ss = ss;
ssr.tileData = tileData;
DynmapPlugin.plugin.sscache.putSnapshot(
dw.getName(), chunk.x, chunk.z, ssr, blockdata, biome, biomeraw, highesty);
}
}
snaparray[(chunk.x - x_min) + (chunk.z - z_min) * x_dim] = ss;
snaptile[(chunk.x - x_min) + (chunk.z - z_min) * x_dim] = tileData;
/* If wasn't loaded before, we need to do unload */
if (!wasLoaded) {
chunks_read++;
/* It looks like bukkit "leaks" entities - they don't get removed from the world-level table
* when chunks are unloaded but not saved - removing them seems to do the trick */
if (!(didgenerate && do_save)) {
helper.removeEntitiesFromChunk(c);
}
/* Since we only remember ones we loaded, and we're synchronous, no player has
* moved, so it must be safe (also prevent chunk leak, which appears to happen
* because isChunkInUse defined "in use" as being within 256 blocks of a player,
* while the actual in-use chunk area for a player where the chunks are managed
* by the MC base server is 21x21 (or about a 160 block radius).
* Also, if we did generate it, need to save it */
w.unloadChunk(chunk.x, chunk.z, didgenerate && do_save, false);
} else if (isunloadpending) {
/* Else, if loaded and unload is pending */
w.unloadChunkRequest(chunk.x, chunk.z); /* Request new unload */
}
}
cnt++;
}
DynmapCore.setIgnoreChunkLoads(false);
if (iterator.hasNext() == false) {
/* If we're done */
isempty = true;
/* Fill missing chunks with empty dummy chunk */
for (int i = 0; i < snaparray.length; i++) {
if (snaparray[i] == null) snaparray[i] = EMPTY;
else if (snaparray[i] != EMPTY) isempty = false;
}
}
total_loadtime += System.nanoTime() - t0;
return cnt;
}
/** Test if done loading */
public boolean isDoneLoading() {
if (dw.isLoaded() == false) {
isempty = true;
unloadChunks();
return true;
}
if (iterator != null) return !iterator.hasNext();
return false;
}
/** Test if all empty blocks */
public boolean isEmpty() {
return isempty;
}
/** Unload chunks */
public void unloadChunks() {
if (snaparray != null) {
for (int i = 0; i < snaparray.length; i++) {
snaparray[i] = null;
}
snaparray = null;
}
}
private void initSectionData(int idx) {
isSectionNotEmpty[idx] = new boolean[nsect + 1];
if (snaparray[idx] != EMPTY) {
for (int i = 0; i < nsect; i++) {
if (snaparray[idx].isSectionEmpty(i) == false) {
isSectionNotEmpty[idx][i] = true;
}
}
}
}
public boolean isEmptySection(int sx, int sy, int sz) {
int idx = (sx - x_min) + (sz - z_min) * x_dim;
if (isSectionNotEmpty[idx] == null) {
initSectionData(idx);
}
return !isSectionNotEmpty[idx][sy];
}
/** Get cache iterator */
public MapIterator getIterator(int x, int y, int z) {
if (w.getEnvironment().toString().equals("THE_END")) return new OurEndMapIterator(x, y, z);
return new OurMapIterator(x, y, z);
}
/** Set hidden chunk style (default is FILL_AIR) */
public void setHiddenFillStyle(HiddenChunkStyle style) {
this.hidestyle = style;
}
/** Set autogenerate - must be done after at least one visible range has been set */
public void setAutoGenerateVisbileRanges(DynmapWorld.AutoGenerateOption generateopt) {
if ((generateopt != DynmapWorld.AutoGenerateOption.NONE)
&& ((visible_limits == null) || (visible_limits.size() == 0))) {
Log.severe("Cannot setAutoGenerateVisibleRanges() without visible ranges defined");
return;
}
this.do_generate = (generateopt != DynmapWorld.AutoGenerateOption.NONE);
this.do_save = (generateopt == DynmapWorld.AutoGenerateOption.PERMANENT);
}
/**
* Add visible area limit - can be called more than once Needs to be set before chunks are loaded
* Coordinates are block coordinates
*/
public void setVisibleRange(VisibilityLimit lim) {
VisibilityLimit limit = new VisibilityLimit();
if (lim.x0 > lim.x1) {
limit.x0 = (lim.x1 >> 4);
limit.x1 = ((lim.x0 + 15) >> 4);
} else {
limit.x0 = (lim.x0 >> 4);
limit.x1 = ((lim.x1 + 15) >> 4);
}
if (lim.z0 > lim.z1) {
limit.z0 = (lim.z1 >> 4);
limit.z1 = ((lim.z0 + 15) >> 4);
} else {
limit.z0 = (lim.z0 >> 4);
limit.z1 = ((lim.z1 + 15) >> 4);
}
if (visible_limits == null) visible_limits = new ArrayList<VisibilityLimit>();
visible_limits.add(limit);
}
/**
* Add hidden area limit - can be called more than once Needs to be set before chunks are loaded
* Coordinates are block coordinates
*/
public void setHiddenRange(VisibilityLimit lim) {
VisibilityLimit limit = new VisibilityLimit();
if (lim.x0 > lim.x1) {
limit.x0 = (lim.x1 >> 4);
limit.x1 = ((lim.x0 + 15) >> 4);
} else {
limit.x0 = (lim.x0 >> 4);
limit.x1 = ((lim.x1 + 15) >> 4);
}
if (lim.z0 > lim.z1) {
limit.z0 = (lim.z1 >> 4);
limit.z1 = ((lim.z0 + 15) >> 4);
} else {
limit.z0 = (lim.z0 >> 4);
limit.z1 = ((lim.z1 + 15) >> 4);
}
if (hidden_limits == null) hidden_limits = new ArrayList<VisibilityLimit>();
hidden_limits.add(limit);
}
@Override
public boolean setChunkDataTypes(
boolean blockdata, boolean biome, boolean highestblocky, boolean rawbiome) {
this.biome = biome;
this.biomeraw = rawbiome;
this.highesty = highestblocky;
this.blockdata = blockdata;
return true;
}
@Override
public DynmapWorld getWorld() {
return dw;
}
@Override
public int getChunksLoaded() {
return chunks_read;
}
@Override
public int getChunkLoadsAttempted() {
return chunks_attempted;
}
@Override
public long getTotalRuntimeNanos() {
return total_loadtime;
}
@Override
public long getExceptionCount() {
return exceptions;
}
static {
Biome[] b = Biome.values();
BiomeMap[] bm = BiomeMap.values();
biome_to_bmap = new BiomeMap[256];
for (int i = 0; i < biome_to_bmap.length; i++) {
biome_to_bmap[i] = BiomeMap.NULL;
}
for (int i = 0; i < b.length; i++) {
String bs = b[i].toString();
for (int j = 0; j < bm.length; j++) {
if (bm[j].toString().equals(bs)) {
biome_to_bmap[b[i].ordinal()] = bm[j];
break;
}
}
}
}
}
