2018-08-08 08:39:51 +02:00
|
|
|
package org.dynmap.bukkit.helper;
|
2013-01-22 06:54:13 +01:00
|
|
|
|
2013-04-18 08:20:59 +02:00
|
|
|
import java.lang.reflect.Field;
|
2013-12-01 15:32:16 +01:00
|
|
|
import java.lang.reflect.InvocationTargetException;
|
2013-01-22 06:54:13 +01:00
|
|
|
import java.lang.reflect.Method;
|
2013-04-28 17:12:01 +02:00
|
|
|
import java.util.ArrayList;
|
2013-01-22 06:54:13 +01:00
|
|
|
import java.util.Map;
|
2016-06-10 08:14:06 +02:00
|
|
|
import java.util.Set;
|
2014-11-28 18:08:44 +01:00
|
|
|
|
2013-01-22 06:54:13 +01:00
|
|
|
import org.bukkit.Bukkit;
|
|
|
|
import org.bukkit.Chunk;
|
|
|
|
import org.bukkit.Server;
|
|
|
|
import org.bukkit.World;
|
|
|
|
import org.dynmap.Log;
|
2016-06-10 08:14:06 +02:00
|
|
|
import org.dynmap.hdmap.HDBlockModels;
|
2015-02-15 19:40:30 +01:00
|
|
|
import org.dynmap.utils.Polygon;
|
2013-01-22 06:54:13 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Helper for isolation of bukkit version specific issues
|
|
|
|
*/
|
|
|
|
public class BukkitVersionHelperCB extends BukkitVersionHelperGeneric {
|
2013-04-18 08:20:59 +02:00
|
|
|
private Class<?> nmsblock;
|
|
|
|
private Class<?> nmsblockarray;
|
2013-04-28 17:12:01 +02:00
|
|
|
private Class<?> nmsmaterial;
|
2013-04-18 08:20:59 +02:00
|
|
|
private Field blockbyid;
|
2013-04-28 17:12:01 +02:00
|
|
|
private Field material;
|
2013-12-01 15:32:16 +01:00
|
|
|
private Method blockbyidfunc; // 1.7+ method for getting block by id
|
2015-02-15 19:40:30 +01:00
|
|
|
private Method getworldborder; // 1.8+ method for getting world border
|
|
|
|
private Class<?> nmsworldborder;
|
|
|
|
private Method worldborderminx;
|
|
|
|
private Method worldbordermaxx;
|
|
|
|
private Method worldborderminz;
|
|
|
|
private Method worldbordermaxz;
|
2016-03-02 05:40:52 +01:00
|
|
|
private Method getbiomebyid;
|
|
|
|
private Method getidbybiome;
|
2016-04-08 07:25:30 +02:00
|
|
|
private boolean isBadUnload = false;
|
2013-04-18 08:20:59 +02:00
|
|
|
|
2018-08-08 08:39:51 +02:00
|
|
|
public BukkitVersionHelperCB() {
|
|
|
|
|
|
|
|
String bukkitver = Bukkit.getServer().getVersion();
|
2016-06-10 08:14:06 +02:00
|
|
|
String mcver = "1.0.0";
|
|
|
|
int idx = bukkitver.indexOf("(MC: ");
|
|
|
|
if(idx > 0) {
|
|
|
|
mcver = bukkitver.substring(idx+5);
|
|
|
|
idx = mcver.indexOf(")");
|
|
|
|
if(idx > 0) mcver = mcver.substring(0, idx);
|
|
|
|
}
|
|
|
|
isBadUnload = HDBlockModels.checkVersionRange(mcver, "1.9-");
|
|
|
|
Log.verboseinfo("MCVER=" + mcver + ", isBadUnload=" + isBadUnload);
|
2013-01-22 06:54:13 +01:00
|
|
|
}
|
|
|
|
@Override
|
|
|
|
protected String getNMSPackage() {
|
|
|
|
Server srv = Bukkit.getServer();
|
|
|
|
/* Get getHandle() method */
|
|
|
|
try {
|
|
|
|
Method m = srv.getClass().getMethod("getHandle");
|
|
|
|
Object scm = m.invoke(srv); /* And use it to get SCM (nms object) */
|
|
|
|
return scm.getClass().getPackage().getName();
|
|
|
|
} catch (Exception x) {
|
|
|
|
Log.severe("Error finding net.minecraft.server packages");
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
@Override
|
|
|
|
protected void loadNMS() {
|
2013-04-18 08:20:59 +02:00
|
|
|
// Get block fields
|
|
|
|
nmsblock = getNMSClass("net.minecraft.server.Block");
|
|
|
|
nmsblockarray = getNMSClass("[Lnet.minecraft.server.Block;");
|
2013-04-28 17:12:01 +02:00
|
|
|
nmsmaterial = getNMSClass("net.minecraft.server.Material");
|
2013-12-01 15:32:16 +01:00
|
|
|
blockbyid = getFieldNoFail(nmsblock, new String[] { "byId" }, nmsblockarray);
|
|
|
|
if (blockbyid == null) {
|
2014-07-10 05:20:33 +02:00
|
|
|
blockbyidfunc = getMethod(nmsblock, new String[] { "getById", "e" }, new Class[] { int.class });
|
2013-12-01 15:32:16 +01:00
|
|
|
}
|
|
|
|
material = getPrivateField(nmsblock, new String[] { "material" }, nmsmaterial);
|
2013-04-18 08:20:59 +02:00
|
|
|
|
2013-01-22 06:54:13 +01:00
|
|
|
/* Set up biomebase fields */
|
|
|
|
biomebase = getNMSClass("net.minecraft.server.BiomeBase");
|
|
|
|
biomebasearray = getNMSClass("[Lnet.minecraft.server.BiomeBase;");
|
2016-03-02 05:40:52 +01:00
|
|
|
biomebaselist = getPrivateFieldNoFail(biomebase, new String[] { "biomes" }, biomebasearray);
|
|
|
|
if (biomebaselist == null) {
|
|
|
|
getbiomebyid = getMethod(biomebase, new String[] { "a" }, new Class[] { int.class} );
|
|
|
|
}
|
2017-05-16 04:35:27 +02:00
|
|
|
biomebasetemp = getPrivateFieldNoFail(biomebase, new String[] { "B" }, float.class);
|
|
|
|
if (biomebasetemp != null) {
|
|
|
|
biomebasehumi = getPrivateField(biomebase, new String[] { "C" }, float.class);
|
|
|
|
}
|
|
|
|
else {
|
2018-08-08 08:39:51 +02:00
|
|
|
biomebasetemp = getPrivateField(biomebase, new String[] { "temperature", "F", "C", "aO" }, float.class);
|
|
|
|
biomebasehumi = getPrivateField(biomebase, new String[] { "humidity", "G", "D", "aP" }, float.class);
|
2017-05-16 04:35:27 +02:00
|
|
|
}
|
2018-08-08 08:39:51 +02:00
|
|
|
biomebaseidstring = getPrivateField(biomebase, new String[] { "y", "af", "ah", "z", "aS" }, String.class);
|
2016-03-02 05:40:52 +01:00
|
|
|
biomebaseid = getFieldNoFail(biomebase, new String[] { "id" }, int.class);
|
|
|
|
if (biomebaseid == null) {
|
|
|
|
getidbybiome = getMethod(biomebase, new String[] { "a" }, new Class[] { biomebase } );
|
|
|
|
}
|
2013-01-22 06:54:13 +01:00
|
|
|
/* n.m.s.World */
|
|
|
|
nmsworld = getNMSClass("net.minecraft.server.WorldServer");
|
|
|
|
chunkprovserver = getNMSClass("net.minecraft.server.ChunkProviderServer");
|
2016-03-02 05:40:52 +01:00
|
|
|
nmsw_chunkproviderserver = getPrivateFieldNoFail(nmsworld, new String[] { "chunkProviderServer" }, chunkprovserver);
|
|
|
|
if (nmsw_chunkproviderserver == null) {
|
2016-05-23 07:30:40 +02:00
|
|
|
Class<?> nmsworldbase = getNMSClass("net.minecraft.server.World");
|
|
|
|
Class<?> nmsichunkprovider = getNMSClass("net.minecraft.server.IChunkProvider");
|
2016-03-02 05:40:52 +01:00
|
|
|
nmsw_chunkproviderserver = getPrivateField(nmsworldbase, new String[] { "chunkProvider" }, nmsichunkprovider);
|
|
|
|
}
|
2015-02-15 19:40:30 +01:00
|
|
|
getworldborder = getMethodNoFail(nmsworld, new String[] { "af" }, nulltypes);
|
2013-03-02 06:51:45 +01:00
|
|
|
|
|
|
|
longhashset = getOBCClassNoFail("org.bukkit.craftbukkit.util.LongHashSet");
|
|
|
|
if(longhashset != null) {
|
|
|
|
lhs_containskey = getMethod(longhashset, new String[] { "contains" }, new Class[] { int.class, int.class });
|
|
|
|
}
|
|
|
|
else {
|
2016-06-10 08:14:06 +02:00
|
|
|
longhashset = getOBCClassNoFail("org.bukkit.craftbukkit.util.LongHashset");
|
|
|
|
if (longhashset != null) {
|
|
|
|
lhs_containskey = getMethod(longhashset, new String[] { "containsKey" }, new Class[] { int.class, int.class });
|
|
|
|
}
|
2018-08-08 08:39:51 +02:00
|
|
|
else {
|
|
|
|
longhashset = getOBCClassNoFail("org.bukkit.craftbukkit.libs.it.unimi.dsi.fastutil.longs.LongSet");
|
|
|
|
if (longhashset != null) {
|
|
|
|
lhs_containskey = getMethod(longhashset, new String[] { "contains" }, new Class[] { long.class });
|
|
|
|
cps_unloadqueue_isSet = true;
|
|
|
|
}
|
|
|
|
}
|
2013-03-02 06:51:45 +01:00
|
|
|
}
|
|
|
|
|
2016-06-10 08:14:06 +02:00
|
|
|
cps_unloadqueue_isSet = false;
|
|
|
|
if (longhashset != null) {
|
|
|
|
cps_unloadqueue = getFieldNoFail(chunkprovserver, new String[] { "unloadQueue" }, longhashset);
|
|
|
|
}
|
|
|
|
if(cps_unloadqueue == null) {
|
|
|
|
cps_unloadqueue = getFieldNoFail(chunkprovserver, new String[] { "unloadQueue" }, Set.class);
|
|
|
|
cps_unloadqueue_isSet = true;
|
|
|
|
}
|
2013-01-22 06:54:13 +01:00
|
|
|
if(cps_unloadqueue == null) {
|
|
|
|
Log.info("Unload queue not found - default to unload all chunks");
|
|
|
|
}
|
|
|
|
/** n.m.s.Chunk */
|
|
|
|
nmschunk = getNMSClass("net.minecraft.server.Chunk");
|
2014-01-18 00:40:39 +01:00
|
|
|
nmsc_tileentities = getField(nmschunk, new String[] { "tileEntities" }, Map.class);
|
2018-08-08 08:39:51 +02:00
|
|
|
nmsc_inhabitedticks = getPrivateFieldNoFail(nmschunk, new String[] { "s", "q", "u", "v", "w", "A" }, long.class);
|
2014-01-18 00:40:39 +01:00
|
|
|
if (nmsc_inhabitedticks == null) {
|
|
|
|
Log.info("inhabitedTicks field not found - inhabited shader not functional");
|
|
|
|
}
|
2015-02-15 19:40:30 +01:00
|
|
|
/** n.m.s.WorldBorder */
|
|
|
|
nmsworldborder = getNMSClassNoFail("net.minecraft.server.WorldBorder");
|
|
|
|
if (nmsworldborder != null) {
|
|
|
|
worldborderminx = getMethod(nmsworldborder, new String[] { "b" }, nulltypes);
|
|
|
|
worldborderminz = getMethod(nmsworldborder, new String[] { "c" }, nulltypes);
|
|
|
|
worldbordermaxx = getMethod(nmsworldborder, new String[] { "d" }, nulltypes);
|
|
|
|
worldbordermaxz = getMethod(nmsworldborder, new String[] { "e" }, nulltypes);
|
|
|
|
}
|
|
|
|
|
2013-01-22 06:54:13 +01:00
|
|
|
/** nbt classes */
|
|
|
|
nbttagcompound = getNMSClass("net.minecraft.server.NBTTagCompound");
|
|
|
|
nbttagbyte = getNMSClass("net.minecraft.server.NBTTagByte");
|
|
|
|
nbttagshort = getNMSClass("net.minecraft.server.NBTTagShort");
|
|
|
|
nbttagint = getNMSClass("net.minecraft.server.NBTTagInt");
|
|
|
|
nbttaglong = getNMSClass("net.minecraft.server.NBTTagLong");
|
|
|
|
nbttagfloat = getNMSClass("net.minecraft.server.NBTTagFloat");
|
|
|
|
nbttagdouble = getNMSClass("net.minecraft.server.NBTTagDouble");
|
|
|
|
nbttagbytearray = getNMSClass("net.minecraft.server.NBTTagByteArray");
|
|
|
|
nbttagstring = getNMSClass("net.minecraft.server.NBTTagString");
|
|
|
|
nbttagintarray = getNMSClass("net.minecraft.server.NBTTagIntArray");
|
|
|
|
compound_get = getMethod(nbttagcompound, new String[] { "get" }, new Class[] { String.class });
|
2013-12-01 15:32:16 +01:00
|
|
|
nbttagbyte_val = getPrivateField(nbttagbyte, new String[] { "data" }, byte.class);
|
|
|
|
nbttagshort_val = getPrivateField(nbttagshort, new String[] { "data" }, short.class);
|
|
|
|
nbttagint_val = getPrivateField(nbttagint, new String[] { "data" }, int.class);
|
|
|
|
nbttaglong_val = getPrivateField(nbttaglong, new String[] { "data" }, long.class);
|
|
|
|
nbttagfloat_val = getPrivateField(nbttagfloat, new String[] { "data" }, float.class);
|
|
|
|
nbttagdouble_val = getPrivateField(nbttagdouble, new String[] { "data" }, double.class);
|
|
|
|
nbttagbytearray_val = getPrivateField(nbttagbytearray, new String[] { "data" }, byte[].class);
|
|
|
|
nbttagstring_val = getPrivateField(nbttagstring, new String[] { "data" }, String.class);
|
|
|
|
nbttagintarray_val = getPrivateField(nbttagintarray, new String[] { "data" }, int[].class);
|
2013-01-22 06:54:13 +01:00
|
|
|
|
|
|
|
/** Tile entity */
|
|
|
|
nms_tileentity = getNMSClass("net.minecraft.server.TileEntity");
|
2016-03-02 05:40:52 +01:00
|
|
|
nmst_readnbt = getMethod(nms_tileentity, new String[] { "b", "save" }, new Class[] { nbttagcompound });
|
2014-11-28 18:08:44 +01:00
|
|
|
nmst_getposition = getMethodNoFail(nms_tileentity, new String[] { "getPosition" }, new Class[0]); // Try 1.8 method
|
|
|
|
if (nmst_getposition == null) {
|
|
|
|
nmst_x = getField(nms_tileentity, new String[] { "x" }, int.class);
|
|
|
|
nmst_y = getField(nms_tileentity, new String[] { "y" }, int.class);
|
|
|
|
nmst_z = getField(nms_tileentity, new String[] { "z" }, int.class);
|
|
|
|
}
|
|
|
|
else { /* BlockPosition */
|
|
|
|
nms_blockposition = getNMSClass("net.minecraft.server.BlockPosition");
|
|
|
|
nmsbp_getx = getMethod(nms_blockposition, new String[] { "getX" }, new Class[0]);
|
|
|
|
nmsbp_gety = getMethod(nms_blockposition, new String[] { "getY" }, new Class[0]);
|
|
|
|
nmsbp_getz = getMethod(nms_blockposition, new String[] { "getZ" }, new Class[0]);
|
|
|
|
}
|
2013-01-22 06:54:13 +01:00
|
|
|
}
|
2013-03-18 05:43:11 +01:00
|
|
|
@Override
|
2013-03-19 02:30:13 +01:00
|
|
|
public void unloadChunkNoSave(World w, Chunk c, int cx, int cz) {
|
2013-03-18 05:43:11 +01:00
|
|
|
w.unloadChunk(cx, cz, false, false);
|
|
|
|
}
|
2018-08-06 04:27:18 +02:00
|
|
|
private String stripBlockString(String bname) {
|
|
|
|
int idx = bname.indexOf('{');
|
|
|
|
if (idx >= 0) bname = bname.substring(idx+1);
|
|
|
|
idx = bname.indexOf('}');
|
|
|
|
if (idx >= 0) bname = bname.substring(0, idx);
|
|
|
|
return bname;
|
|
|
|
}
|
2013-04-18 08:20:59 +02:00
|
|
|
/**
|
|
|
|
* Get block short name list
|
|
|
|
*/
|
|
|
|
@Override
|
2018-08-06 04:27:18 +02:00
|
|
|
public String[] getBlockNames() {
|
2013-04-18 08:20:59 +02:00
|
|
|
try {
|
2013-12-01 15:32:16 +01:00
|
|
|
String[] names = new String[4096];
|
|
|
|
if (blockbyid != null) {
|
|
|
|
Object[] byid = (Object[])blockbyid.get(nmsblock);
|
|
|
|
for (int i = 0; i < names.length; i++) {
|
|
|
|
if (byid[i] != null) {
|
2018-08-06 04:27:18 +02:00
|
|
|
names[i] = stripBlockString(byid[i].toString());
|
2013-12-01 15:32:16 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
for (int i = 0; i < names.length; i++) {
|
|
|
|
Object blk = blockbyidfunc.invoke(nmsblock, i);
|
|
|
|
if (blk != null) {
|
2018-08-06 04:27:18 +02:00
|
|
|
names[i] = stripBlockString(blk.toString());
|
2013-12-01 15:32:16 +01:00
|
|
|
}
|
2013-04-18 08:20:59 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return names;
|
|
|
|
} catch (IllegalArgumentException e) {
|
|
|
|
} catch (IllegalAccessException e) {
|
2013-12-01 15:32:16 +01:00
|
|
|
} catch (InvocationTargetException e) {
|
2013-04-18 08:20:59 +02:00
|
|
|
}
|
|
|
|
return new String[0];
|
|
|
|
}
|
|
|
|
/**
|
|
|
|
* Get biome name list
|
|
|
|
*/
|
|
|
|
@Override
|
|
|
|
public String[] getBiomeNames() {
|
|
|
|
String[] names;
|
|
|
|
/* Find array of biomes in biomebase */
|
|
|
|
Object[] biomelist = getBiomeBaseList();
|
|
|
|
names = new String[biomelist.length];
|
|
|
|
/* Loop through list, starting afer well known biomes */
|
|
|
|
for(int i = 0; i < biomelist.length; i++) {
|
|
|
|
Object bb = biomelist[i];
|
|
|
|
if(bb != null) {
|
|
|
|
names[i] = getBiomeBaseIDString(bb);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return names;
|
|
|
|
}
|
2013-04-28 17:12:01 +02:00
|
|
|
/**
|
|
|
|
* Get block material index list
|
|
|
|
*/
|
|
|
|
public int[] getBlockMaterialMap() {
|
|
|
|
try {
|
2013-12-01 15:32:16 +01:00
|
|
|
int[] map = new int[4096];
|
|
|
|
if (blockbyid != null) {
|
|
|
|
Object[] byid = (Object[])blockbyid.get(nmsblock);
|
|
|
|
ArrayList<Object> mats = new ArrayList<Object>();
|
|
|
|
for (int i = 0; i < map.length; i++) {
|
|
|
|
if (byid[i] != null) {
|
|
|
|
Object mat = (Object)material.get(byid[i]);
|
|
|
|
if (mat != null) {
|
|
|
|
map[i] = mats.indexOf(mat);
|
|
|
|
if (map[i] < 0) {
|
|
|
|
map[i] = mats.size();
|
|
|
|
mats.add(mat);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
map[i] = -1;
|
2013-04-28 17:12:01 +02:00
|
|
|
}
|
|
|
|
}
|
2013-12-01 15:32:16 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
ArrayList<Object> mats = new ArrayList<Object>();
|
|
|
|
for (int i = 0; i < map.length; i++) {
|
|
|
|
Object blk = blockbyidfunc.invoke(nmsblock, i);
|
|
|
|
if (blk != null) {
|
|
|
|
Object mat = (Object)material.get(blk);
|
|
|
|
if (mat != null) {
|
|
|
|
map[i] = mats.indexOf(mat);
|
|
|
|
if (map[i] < 0) {
|
|
|
|
map[i] = mats.size();
|
|
|
|
mats.add(mat);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
map[i] = -1;
|
|
|
|
}
|
2013-04-28 17:12:01 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return map;
|
|
|
|
} catch (IllegalArgumentException e) {
|
|
|
|
} catch (IllegalAccessException e) {
|
2013-12-01 15:32:16 +01:00
|
|
|
} catch (InvocationTargetException e) {
|
2013-04-28 17:12:01 +02:00
|
|
|
}
|
|
|
|
return new int[0];
|
|
|
|
}
|
2015-02-15 19:40:30 +01:00
|
|
|
@Override
|
|
|
|
public Polygon getWorldBorder(World world) {
|
|
|
|
Polygon p = null;
|
|
|
|
if ((getworldborder == null) || (world == null)) {
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
Object cw = getNMSWorld(world);
|
|
|
|
if (cw == null) return null;
|
|
|
|
Object wb = callMethod(cw, getworldborder, nullargs, null);
|
|
|
|
if (wb != null) {
|
|
|
|
double minx = (Double) callMethod(wb, worldborderminx, nullargs, Double.MIN_VALUE);
|
|
|
|
double minz = (Double) callMethod(wb, worldborderminz, nullargs, Double.MIN_VALUE);
|
|
|
|
double maxx = (Double) callMethod(wb, worldbordermaxx, nullargs, Double.MAX_VALUE);
|
|
|
|
double maxz = (Double) callMethod(wb, worldbordermaxz, nullargs, Double.MAX_VALUE);
|
|
|
|
if (maxx < 1E7) {
|
|
|
|
p = new Polygon();
|
|
|
|
p.addVertex(minx, minz);
|
|
|
|
p.addVertex(minx, maxz);
|
|
|
|
p.addVertex(maxx, maxz);
|
|
|
|
p.addVertex(maxx, minz);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return p;
|
|
|
|
}
|
2016-03-02 05:40:52 +01:00
|
|
|
private Object[] biomelist = null;
|
|
|
|
/**
|
|
|
|
* Get list of defined biomebase objects
|
|
|
|
*/
|
|
|
|
public Object[] getBiomeBaseList() {
|
|
|
|
if (getbiomebyid != null) {
|
|
|
|
if (biomelist == null) {
|
2016-04-02 06:55:53 +02:00
|
|
|
biomelist = new Object[1024];
|
|
|
|
for (int i = 0; i < 1024; i++) {
|
2016-03-02 05:40:52 +01:00
|
|
|
try {
|
|
|
|
biomelist[i] = getbiomebyid.invoke(biomebase, i);
|
|
|
|
} catch (IllegalAccessException x) {
|
|
|
|
} catch (IllegalArgumentException x) {
|
|
|
|
} catch (InvocationTargetException x) {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return biomelist;
|
|
|
|
}
|
|
|
|
return super.getBiomeBaseList();
|
|
|
|
}
|
|
|
|
/** Get ID from biomebase */
|
|
|
|
public int getBiomeBaseID(Object bb) {
|
|
|
|
if (getidbybiome != null) {
|
|
|
|
try {
|
|
|
|
return (Integer) getidbybiome.invoke(biomebase, bb);
|
|
|
|
} catch (IllegalAccessException e) {
|
|
|
|
} catch (IllegalArgumentException e) {
|
|
|
|
} catch (InvocationTargetException e) {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return super.getBiomeBaseID(bb);
|
|
|
|
}
|
2016-04-08 07:25:30 +02:00
|
|
|
/**
|
|
|
|
* Test if broken unloadChunk
|
|
|
|
*/
|
|
|
|
@Override
|
|
|
|
public boolean isUnloadChunkBroken() { return isBadUnload; }
|
2013-01-22 06:54:13 +01:00
|
|
|
}
|