Put 3D biome code in spigot 1.18 - still working on grass shading...
This commit is contained in:
Mike Primm
parent
635bbf2b4d
commit
dac53e38fc
8 changed files with 430 additions and 762 deletions
|
|
@ -61,8 +61,10 @@ import java.util.Map;
|
|||
/**
|
||||
* Helper for isolation of bukkit version specific issues
|
||||
*/
|
||||
public class BukkitVersionHelperSpigot118 extends BukkitVersionHelper {
|
||||
public class BukkitVersionHelperSpigot118 extends BukkitVersionHelper {
|
||||
|
||||
public BukkitVersionHelperSpigot118() {
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -191,7 +193,7 @@ public class BukkitVersionHelperSpigot118 extends BukkitVersionHelper {
|
|||
*/
|
||||
@Override
|
||||
public MapChunkCache getChunkCache(BukkitWorld dw, List<DynmapChunk> chunks) {
|
||||
MapChunkCache118 c = new MapChunkCache118();
|
||||
MapChunkCache118 c = new MapChunkCache118(gencache);
|
||||
c.setChunks(dw, chunks);
|
||||
return c;
|
||||
}
|
||||
|
|
@ -437,4 +439,9 @@ public class BukkitVersionHelperSpigot118 extends BukkitVersionHelper {
|
|||
CraftWorld cw = (CraftWorld) w;
|
||||
return cw.getMinHeight();
|
||||
}
|
||||
@Override
|
||||
public boolean useGenericCache() {
|
||||
return true;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -6,11 +6,16 @@ import org.bukkit.block.Biome;
|
|||
import org.bukkit.craftbukkit.v1_18_R1.CraftWorld;
|
||||
import org.dynmap.DynmapChunk;
|
||||
import org.dynmap.DynmapCore;
|
||||
import org.dynmap.bukkit.helper.BukkitWorld;
|
||||
import org.dynmap.bukkit.helper.AbstractMapChunkCache;
|
||||
import org.dynmap.bukkit.helper.BukkitVersionHelper;
|
||||
import org.dynmap.bukkit.helper.SnapshotCache;
|
||||
import org.dynmap.bukkit.helper.SnapshotCache.SnapshotRec;
|
||||
import org.dynmap.common.BiomeMap;
|
||||
import org.dynmap.common.chunk.GenericChunk;
|
||||
import org.dynmap.common.chunk.GenericChunkCache;
|
||||
import org.dynmap.common.chunk.GenericChunkSection;
|
||||
import org.dynmap.common.chunk.GenericMapChunkCache;
|
||||
import org.dynmap.renderer.DynmapBlockState;
|
||||
import org.dynmap.utils.DataBitsPacked;
|
||||
import org.dynmap.utils.DynIntHashMap;
|
||||
|
|
@ -28,417 +33,260 @@ import net.minecraft.world.level.chunk.Chunk;
|
|||
import java.io.IOException;
|
||||
import java.util.Arrays;
|
||||
import java.util.LinkedList;
|
||||
import java.util.List;
|
||||
import java.util.ArrayList;
|
||||
|
||||
/**
|
||||
* Container for managing chunks - dependent upon using chunk snapshots, since rendering is off server thread
|
||||
*/
|
||||
public class MapChunkCache118 extends AbstractMapChunkCache {
|
||||
public class MapChunkCache118 extends GenericMapChunkCache {
|
||||
private World w;
|
||||
/**
|
||||
* Construct empty cache
|
||||
*/
|
||||
public MapChunkCache118(GenericChunkCache cc) {
|
||||
super(cc);
|
||||
init();
|
||||
}
|
||||
|
||||
public static class NBTSnapshot implements Snapshot {
|
||||
private static interface Section {
|
||||
public DynmapBlockState getBlockType(int x, int y, int z);
|
||||
public int getBlockSkyLight(int x, int y, int z);
|
||||
public int getBlockEmittedLight(int x, int y, int z);
|
||||
public boolean isEmpty();
|
||||
public int getBiome(int x, int y, int z);
|
||||
}
|
||||
private final int x, z;
|
||||
private final Section[] section;
|
||||
private final int sectionOffset;
|
||||
private final int[] hmap; // Height map
|
||||
private final int[] biome;
|
||||
private final Object[] biomebase;
|
||||
private final long captureFulltime;
|
||||
private final int sectionCnt;
|
||||
private final long inhabitedTicks;
|
||||
private GenericChunk parseChunkFromNBT(NBTTagCompound nbt) {
|
||||
if ((nbt != null) && nbt.e("Level")) {
|
||||
nbt = nbt.p("Level");
|
||||
}
|
||||
if (nbt == null) return null;
|
||||
// Start generic chunk builder
|
||||
GenericChunk.Builder bld = new GenericChunk.Builder(dw.minY, dw.worldheight);
|
||||
bld.coords(nbt.h("xPos"), nbt.h("zPos"));
|
||||
if (nbt.e("InhabitedTime")) {
|
||||
bld.inhabitedTicks(nbt.i("InhabitedTime"));
|
||||
}
|
||||
// Check for 2D or old 3D biome data from chunk level: need these when we build old sections
|
||||
List<BiomeMap[]> old3d = null; // By section, then YZX list
|
||||
BiomeMap[] old2d = null;
|
||||
if (nbt.e("Biomes")) {
|
||||
int[] bb = nbt.n("Biomes");
|
||||
if (bb != null) {
|
||||
// If v1.15+ format
|
||||
if (bb.length > 256) {
|
||||
old3d = new ArrayList<BiomeMap[]>();
|
||||
// Get 4 x 4 x 4 list for each section
|
||||
for (int sect = 0; sect < (bb.length / 64); sect++) {
|
||||
BiomeMap smap[] = new BiomeMap[64];
|
||||
for (int i = 0; i < 64; i++) {
|
||||
smap[i] = BiomeMap.byBiomeID(bb[sect*64 + i]);
|
||||
}
|
||||
old3d.add(smap);
|
||||
}
|
||||
}
|
||||
else { // Else, older chunks
|
||||
old2d = new BiomeMap[256];
|
||||
for (int i = 0; i < bb.length; i++) {
|
||||
old2d[i] = BiomeMap.byBiomeID(bb[i]);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
// Start section builder
|
||||
GenericChunkSection.Builder sbld = new GenericChunkSection.Builder();
|
||||
/* Get sections */
|
||||
NBTTagList sect = nbt.e("sections") ? nbt.c("sections", 10) : nbt.c("Sections", 10);
|
||||
for (int i = 0; i < sect.size(); i++) {
|
||||
NBTTagCompound sec = sect.a(i);
|
||||
int secnum = sec.h("Y");
|
||||
|
||||
DynmapBlockState[] palette = null;
|
||||
// If we've got palette and block states list, process non-empty section
|
||||
if (sec.b("Palette", 9) && sec.b("BlockStates", 12)) {
|
||||
NBTTagList plist = sec.c("Palette", 10);
|
||||
long[] statelist = sec.o("BlockStates");
|
||||
palette = new DynmapBlockState[plist.size()];
|
||||
for (int pi = 0; pi < plist.size(); pi++) {
|
||||
NBTTagCompound tc = plist.a(pi);
|
||||
String pname = tc.l("Name");
|
||||
if (tc.e("Properties")) {
|
||||
StringBuilder statestr = new StringBuilder();
|
||||
NBTTagCompound prop = tc.p("Properties");
|
||||
for (String pid : prop.d()) {
|
||||
if (statestr.length() > 0) statestr.append(',');
|
||||
statestr.append(pid).append('=').append(prop.c(pid).e_());
|
||||
}
|
||||
palette[pi] = DynmapBlockState.getStateByNameAndState(pname, statestr.toString());
|
||||
}
|
||||
if (palette[pi] == null) {
|
||||
palette[pi] = DynmapBlockState.getBaseStateByName(pname);
|
||||
}
|
||||
if (palette[pi] == null) {
|
||||
palette[pi] = DynmapBlockState.AIR;
|
||||
}
|
||||
}
|
||||
int recsperblock = (4096 + statelist.length - 1) / statelist.length;
|
||||
int bitsperblock = 64 / recsperblock;
|
||||
DataBits db = null;
|
||||
DataBitsPacked dbp = null;
|
||||
try {
|
||||
db = new SimpleBitStorage(bitsperblock, 4096, statelist);
|
||||
} catch (Exception x) { // Handle legacy encoded
|
||||
bitsperblock = (statelist.length * 64) / 4096;
|
||||
dbp = new DataBitsPacked(bitsperblock, 4096, statelist);
|
||||
}
|
||||
if (bitsperblock > 8) { // Not palette
|
||||
for (int j = 0; j < 4096; j++) {
|
||||
int v = (dbp != null) ? dbp.getAt(j) : db.a(j);
|
||||
sbld.xyzBlockState(j & 0xF, (j & 0xF00) >> 8, (j & 0xF0) >> 4, DynmapBlockState.getStateByGlobalIndex(v));
|
||||
}
|
||||
}
|
||||
else {
|
||||
for (int j = 0; j < 4096; j++) {
|
||||
int v = (dbp != null) ? dbp.getAt(j) : db.a(j);
|
||||
DynmapBlockState bs = (v < palette.length) ? palette[v] : DynmapBlockState.AIR;
|
||||
sbld.xyzBlockState(j & 0xF, (j & 0xF00) >> 8, (j & 0xF0) >> 4, bs);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private static final int BLOCKS_PER_SECTION = 16 * 16 * 16;
|
||||
private static final int BIOMES_PER_SECTION = 4 * 4 * 4;
|
||||
private static final int COLUMNS_PER_CHUNK = 16 * 16;
|
||||
private static final byte[] emptyData = new byte[BLOCKS_PER_SECTION / 2];
|
||||
private static final byte[] fullData = new byte[BLOCKS_PER_SECTION / 2];
|
||||
else if (sec.e("block_states")) { // 1.18
|
||||
NBTTagCompound block_states = sec.p("block_states");
|
||||
// If we've block state data, process non-empty section
|
||||
if (block_states.b("data", 12)) {
|
||||
long[] statelist = block_states.o("data");
|
||||
NBTTagList plist = block_states.c("palette", 10);
|
||||
palette = new DynmapBlockState[plist.size()];
|
||||
for (int pi = 0; pi < plist.size(); pi++) {
|
||||
NBTTagCompound tc = plist.a(pi);
|
||||
String pname = tc.l("Name");
|
||||
if (tc.e("Properties")) {
|
||||
StringBuilder statestr = new StringBuilder();
|
||||
NBTTagCompound prop = tc.p("Properties");
|
||||
for (String pid : prop.d()) {
|
||||
if (statestr.length() > 0) statestr.append(',');
|
||||
statestr.append(pid).append('=').append(prop.c(pid).e_());
|
||||
}
|
||||
palette[pi] = DynmapBlockState.getStateByNameAndState(pname, statestr.toString());
|
||||
}
|
||||
if (palette[pi] == null) {
|
||||
palette[pi] = DynmapBlockState.getBaseStateByName(pname);
|
||||
}
|
||||
if (palette[pi] == null) {
|
||||
palette[pi] = DynmapBlockState.AIR;
|
||||
}
|
||||
}
|
||||
SimpleBitStorage db = null;
|
||||
DataBitsPacked dbp = null;
|
||||
|
||||
static
|
||||
{
|
||||
Arrays.fill(fullData, (byte)0xFF);
|
||||
}
|
||||
|
||||
private static byte[] dataCopy(byte[] v) {
|
||||
if (Arrays.equals(v, emptyData))
|
||||
return emptyData;
|
||||
else if (Arrays.equals(v, fullData))
|
||||
return fullData;
|
||||
else
|
||||
return v.clone();
|
||||
}
|
||||
|
||||
private static class EmptySection implements Section {
|
||||
@Override
|
||||
public DynmapBlockState getBlockType(int x, int y, int z) {
|
||||
return DynmapBlockState.AIR;
|
||||
}
|
||||
@Override
|
||||
public int getBlockSkyLight(int x, int y, int z) {
|
||||
return 15;
|
||||
}
|
||||
@Override
|
||||
public int getBlockEmittedLight(int x, int y, int z) {
|
||||
return 0;
|
||||
}
|
||||
@Override
|
||||
public boolean isEmpty() {
|
||||
return true;
|
||||
}
|
||||
@Override
|
||||
public int getBiome(int x, int y, int z) {
|
||||
return BiomeMap.PLAINS.getBiomeID();
|
||||
}
|
||||
}
|
||||
|
||||
private static final EmptySection empty_section = new EmptySection();
|
||||
|
||||
private static class StdSection implements Section {
|
||||
DynmapBlockState[] states;
|
||||
byte[] skylight;
|
||||
byte[] emitlight;
|
||||
int[] biomes;
|
||||
|
||||
public StdSection() {
|
||||
states = new DynmapBlockState[BLOCKS_PER_SECTION];
|
||||
Arrays.fill(states, DynmapBlockState.AIR);
|
||||
biomes = new int[BIOMES_PER_SECTION];
|
||||
skylight = emptyData;
|
||||
emitlight = emptyData;
|
||||
}
|
||||
@Override
|
||||
public DynmapBlockState getBlockType(int x, int y, int z) {
|
||||
return states[((y & 0xF) << 8) | (z << 4) | x];
|
||||
}
|
||||
@Override
|
||||
public int getBlockSkyLight(int x, int y, int z) {
|
||||
int off = ((y & 0xF) << 7) | (z << 3) | (x >> 1);
|
||||
return (skylight[off] >> (4 * (x & 1))) & 0xF;
|
||||
}
|
||||
@Override
|
||||
public int getBlockEmittedLight(int x, int y, int z)
|
||||
{
|
||||
int off = ((y & 0xF) << 7) | (z << 3) | (x >> 1);
|
||||
return (emitlight[off] >> (4 * (x & 1))) & 0xF;
|
||||
}
|
||||
@Override
|
||||
public boolean isEmpty() {
|
||||
return false;
|
||||
}
|
||||
@Override
|
||||
public int getBiome(int x, int y, int z) {
|
||||
int off = (((y & 0xF) >> 2) << 4) | ((z >> 2) << 2) | (x >> 2);
|
||||
return biomes[off];
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Construct empty chunk snapshot
|
||||
*
|
||||
* @param x
|
||||
* @param z
|
||||
*/
|
||||
public NBTSnapshot(int worldheight, int x, int z, long captime, long inhabitedTime)
|
||||
{
|
||||
this.x = x;
|
||||
this.z = z;
|
||||
this.captureFulltime = captime;
|
||||
this.biome = new int[COLUMNS_PER_CHUNK];
|
||||
this.biomebase = new Object[COLUMNS_PER_CHUNK];
|
||||
this.sectionCnt = worldheight / 16;
|
||||
/* Allocate arrays indexed by section */
|
||||
this.section = new Section[this.sectionCnt+1];
|
||||
this.sectionOffset = 0;
|
||||
/* Fill with empty data */
|
||||
for (int i = 0; i <= this.sectionCnt; i++) {
|
||||
this.section[i] = empty_section;
|
||||
}
|
||||
|
||||
/* Create empty height map */
|
||||
this.hmap = new int[16 * 16];
|
||||
|
||||
this.inhabitedTicks = inhabitedTime;
|
||||
}
|
||||
|
||||
public NBTSnapshot(NBTTagCompound nbt, int worldheight) {
|
||||
this.x = nbt.h("xPos");
|
||||
this.z = nbt.h("zPos");
|
||||
this.captureFulltime = 0;
|
||||
this.hmap = nbt.n("HeightMap");
|
||||
this.sectionCnt = worldheight / 16;
|
||||
if (nbt.e("InhabitedTime")) {
|
||||
this.inhabitedTicks = nbt.i("InhabitedTime");
|
||||
}
|
||||
else {
|
||||
this.inhabitedTicks = 0;
|
||||
}
|
||||
/* Allocate arrays indexed by section */
|
||||
LinkedList<Section> sections = new LinkedList<Section>();
|
||||
int sectoff = 0; // Default to zero
|
||||
int sectcnt = 0;
|
||||
/* Fill with empty data */
|
||||
for (int i = 0; i <= this.sectionCnt; i++) {
|
||||
sections.add(empty_section);
|
||||
sectcnt++;
|
||||
}
|
||||
//System.out.println("nbt.keys()=" + nbt.d().toString());
|
||||
StdSection lastsectwithbiome = null;
|
||||
/* Get sections */
|
||||
|
||||
NBTTagList sect = nbt.e("sections") ? nbt.c("sections", 10) : nbt.c("Sections", 10);
|
||||
for (int i = 0; i < sect.size(); i++) {
|
||||
NBTTagCompound sec = sect.a(i);
|
||||
int secnum = sec.h("Y");
|
||||
// Beyond end - extend up
|
||||
while (secnum >= (sectcnt - sectoff)) {
|
||||
sections.addLast(empty_section); // Pad with empty
|
||||
sectcnt++;
|
||||
}
|
||||
// Negative - see if we need to extend sectionOffset
|
||||
while ((secnum + sectoff) < 0) {
|
||||
sections.addFirst(empty_section); // Pad with empty
|
||||
sectoff++;
|
||||
sectcnt++;
|
||||
}
|
||||
//System.out.println("section(" + secnum + ")=" + sec.toString());
|
||||
// Create normal section to initialize
|
||||
StdSection cursect = new StdSection();
|
||||
sections.set(secnum + sectoff, cursect);
|
||||
DynmapBlockState[] states = cursect.states;
|
||||
DynmapBlockState[] palette = null;
|
||||
// If we've got palette and block states list, process non-empty section
|
||||
if (sec.b("Palette", 9) && sec.b("BlockStates", 12)) {
|
||||
NBTTagList plist = sec.c("Palette", 10);
|
||||
long[] statelist = sec.o("BlockStates");
|
||||
palette = new DynmapBlockState[plist.size()];
|
||||
for (int pi = 0; pi < plist.size(); pi++) {
|
||||
NBTTagCompound tc = plist.a(pi);
|
||||
String pname = tc.l("Name");
|
||||
if (tc.e("Properties")) {
|
||||
StringBuilder statestr = new StringBuilder();
|
||||
NBTTagCompound prop = tc.p("Properties");
|
||||
for (String pid : prop.d()) {
|
||||
if (statestr.length() > 0) statestr.append(',');
|
||||
statestr.append(pid).append('=').append(prop.c(pid).e_());
|
||||
}
|
||||
palette[pi] = DynmapBlockState.getStateByNameAndState(pname, statestr.toString());
|
||||
}
|
||||
if (palette[pi] == null) {
|
||||
palette[pi] = DynmapBlockState.getBaseStateByName(pname);
|
||||
}
|
||||
if (palette[pi] == null) {
|
||||
palette[pi] = DynmapBlockState.AIR;
|
||||
}
|
||||
}
|
||||
int recsperblock = (4096 + statelist.length - 1) / statelist.length;
|
||||
int bitsperblock = 64 / recsperblock;
|
||||
DataBits db = null;
|
||||
DataBitsPacked dbp = null;
|
||||
try {
|
||||
db = new SimpleBitStorage(bitsperblock, 4096, statelist);
|
||||
} catch (Exception x) { // Handle legacy encoded
|
||||
int bitsperblock = (statelist.length * 64) / 4096;
|
||||
int expectedStatelistLength = (4096 + (64 / bitsperblock) - 1) / (64 / bitsperblock);
|
||||
if (statelist.length == expectedStatelistLength) {
|
||||
db = new SimpleBitStorage(bitsperblock, 4096, statelist);
|
||||
}
|
||||
else {
|
||||
bitsperblock = (statelist.length * 64) / 4096;
|
||||
dbp = new DataBitsPacked(bitsperblock, 4096, statelist);
|
||||
}
|
||||
if (bitsperblock > 8) { // Not palette
|
||||
for (int j = 0; j < 4096; j++) {
|
||||
int v = (dbp != null) ? dbp.getAt(j) : db.a(j);
|
||||
states[j] = DynmapBlockState.getStateByGlobalIndex(v);
|
||||
}
|
||||
}
|
||||
else {
|
||||
for (int j = 0; j < 4096; j++) {
|
||||
int v = (dbp != null) ? dbp.getAt(j) : db.a(j);
|
||||
states[j] = (v < palette.length) ? palette[v] : DynmapBlockState.AIR;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (bitsperblock > 8) { // Not palette
|
||||
for (int j = 0; j < 4096; j++) {
|
||||
int v = db != null ? db.a(j) : dbp.getAt(j);
|
||||
sbld.xyzBlockState(j & 0xF, (j & 0xF00) >> 8, (j & 0xF0) >> 4, DynmapBlockState.getStateByGlobalIndex(v));
|
||||
}
|
||||
}
|
||||
else {
|
||||
for (int j = 0; j < 4096; j++) {
|
||||
int v = db != null ? db.a(j) : dbp.getAt(j);
|
||||
DynmapBlockState bs = (v < palette.length) ? palette[v] : DynmapBlockState.AIR;
|
||||
sbld.xyzBlockState(j & 0xF, (j & 0xF00) >> 8, (j & 0xF0) >> 4, bs);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if (sec.e("BlockLight")) {
|
||||
sbld.emittedLight(sec.m("BlockLight"));
|
||||
}
|
||||
if (sec.e("SkyLight")) {
|
||||
sbld.skyLight(sec.m("SkyLight"));
|
||||
}
|
||||
// If section biome palette
|
||||
if (sec.e("biomes")) {
|
||||
NBTTagCompound nbtbiomes = sec.p("biomes");
|
||||
long[] bdataPacked = nbtbiomes.o("data");
|
||||
NBTTagList bpalette = nbtbiomes.c("palette", 8);
|
||||
SimpleBitStorage bdata = null;
|
||||
if (bdataPacked.length > 0)
|
||||
bdata = new SimpleBitStorage(bdataPacked.length, 64, bdataPacked);
|
||||
for (int j = 0; j < 64; j++) {
|
||||
int b = bdata != null ? bdata.a(j) : 0;
|
||||
sbld.xyzBiome(j & 0x3, (j & 0x30) >> 4, (j & 0xC) >> 2, BiomeMap.byBiomeResourceLocation(bpalette.j(b)));
|
||||
}
|
||||
}
|
||||
else { // Else, apply legacy biomes
|
||||
if (old3d != null) {
|
||||
BiomeMap m[] = old3d.get(secnum);
|
||||
if (m != null) {
|
||||
for (int j = 0; j < 64; j++) {
|
||||
sbld.xyzBiome(j & 0x3, (j & 0x30) >> 4, (j & 0xC) >> 2, m[j]);
|
||||
}
|
||||
}
|
||||
}
|
||||
else if (sec.e("block_states")) { // 1.18
|
||||
NBTTagCompound block_states = sec.p("block_states");
|
||||
// If we've block state data, process non-empty section
|
||||
if (block_states.b("data", 12)) {
|
||||
long[] statelist = block_states.o("data");
|
||||
NBTTagList plist = block_states.c("palette", 10);
|
||||
palette = new DynmapBlockState[plist.size()];
|
||||
for (int pi = 0; pi < plist.size(); pi++) {
|
||||
NBTTagCompound tc = plist.a(pi);
|
||||
String pname = tc.l("Name");
|
||||
if (tc.e("Properties")) {
|
||||
StringBuilder statestr = new StringBuilder();
|
||||
NBTTagCompound prop = tc.p("Properties");
|
||||
for (String pid : prop.d()) {
|
||||
if (statestr.length() > 0) statestr.append(',');
|
||||
statestr.append(pid).append('=').append(prop.c(pid).e_());
|
||||
}
|
||||
palette[pi] = DynmapBlockState.getStateByNameAndState(pname, statestr.toString());
|
||||
}
|
||||
if (palette[pi] == null) {
|
||||
palette[pi] = DynmapBlockState.getBaseStateByName(pname);
|
||||
}
|
||||
if (palette[pi] == null) {
|
||||
palette[pi] = DynmapBlockState.AIR;
|
||||
}
|
||||
}
|
||||
SimpleBitStorage db = null;
|
||||
DataBitsPacked dbp = null;
|
||||
|
||||
int bitsperblock = (statelist.length * 64) / 4096;
|
||||
int expectedStatelistLength = (4096 + (64 / bitsperblock) - 1) / (64 / bitsperblock);
|
||||
if (statelist.length == expectedStatelistLength) {
|
||||
db = new SimpleBitStorage(bitsperblock, 4096, statelist);
|
||||
}
|
||||
else {
|
||||
bitsperblock = (statelist.length * 64) / 4096;
|
||||
dbp = new DataBitsPacked(bitsperblock, 4096, statelist);
|
||||
}
|
||||
if (bitsperblock > 8) { // Not palette
|
||||
for (int j = 0; j < 4096; j++) {
|
||||
int v = db != null ? db.a(j) : dbp.getAt(j);
|
||||
states[j] = DynmapBlockState.getStateByGlobalIndex(v);
|
||||
}
|
||||
}
|
||||
else {
|
||||
for (int j = 0; j < 4096; j++) {
|
||||
int v = db != null ? db.a(j) : dbp.getAt(j);
|
||||
states[j] = (v < palette.length) ? palette[v] : DynmapBlockState.AIR;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (sec.e("BlockLight")) {
|
||||
cursect.emitlight = dataCopy(sec.m("BlockLight"));
|
||||
}
|
||||
if (sec.e("SkyLight")) {
|
||||
cursect.skylight = dataCopy(sec.m("SkyLight"));
|
||||
else if (old2d != null) {
|
||||
for (int j = 0; j < 256; j++) {
|
||||
sbld.xzBiome(j & 0xF, (j & 0xF0) >> 4, old2d[j]);
|
||||
}
|
||||
}
|
||||
// If section biome palette
|
||||
if (sec.e("biomes")) {
|
||||
NBTTagCompound nbtbiomes = sec.p("biomes");
|
||||
long[] bdataPacked = nbtbiomes.o("data");
|
||||
NBTTagList bpalette = nbtbiomes.c("palette", 8);
|
||||
SimpleBitStorage bdata = null;
|
||||
if (bdataPacked.length > 0)
|
||||
bdata = new SimpleBitStorage(bdataPacked.length, 64, bdataPacked);
|
||||
for (int j = 0; j < 64; j++) {
|
||||
int b = bdata != null ? bdata.a(j) : 0;
|
||||
cursect.biomes[j] = b < bpalette.size() ? BiomeMap.byBiomeResourceLocation(bpalette.j(b)).getBiomeID() : -1;
|
||||
}
|
||||
// Favor the Y=64 version
|
||||
if ((secnum == 4) || (lastsectwithbiome == null)) {
|
||||
lastsectwithbiome = cursect;
|
||||
}
|
||||
}
|
||||
}
|
||||
/* Get biome data */
|
||||
this.biome = new int[COLUMNS_PER_CHUNK];
|
||||
this.biomebase = new Object[COLUMNS_PER_CHUNK];
|
||||
Object[] bbl = BukkitVersionHelper.helper.getBiomeBaseList();
|
||||
if (nbt.e("Biomes")) {
|
||||
int[] bb = nbt.n("Biomes");
|
||||
if (bb != null) {
|
||||
// If v1.15+ format
|
||||
if (bb.length > COLUMNS_PER_CHUNK) {
|
||||
// For now, just pad the grid with the first 16
|
||||
for (int i = 0; i < COLUMNS_PER_CHUNK; i++) {
|
||||
int off = ((i >> 4) & 0xC) + ((i >> 2) & 0x3);
|
||||
int bv = bb[off + 64]; // Offset to y=64
|
||||
if (bv < 0) bv = 0;
|
||||
this.biome[i] = bv;
|
||||
this.biomebase[i] = bbl[bv];
|
||||
}
|
||||
}
|
||||
else { // Else, older chunks
|
||||
for (int i = 0; i < bb.length; i++) {
|
||||
int bv = bb[i];
|
||||
if (bv < 0) bv = 0;
|
||||
this.biome[i] = bv;
|
||||
this.biomebase[i] = bbl[bv];
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
else { // Make up 2D version for now
|
||||
if (lastsectwithbiome != null) {
|
||||
// For now, just pad the grid with the first 16
|
||||
for (int i = 0; i < COLUMNS_PER_CHUNK; i++) {
|
||||
int off = ((i >> 4) & 0xC) + ((i >> 2) & 0x3);
|
||||
int bv = lastsectwithbiome.biomes[off]; // Offset to y=64
|
||||
if (bv < 0) bv = 0;
|
||||
this.biome[i] = bv;
|
||||
this.biomebase[i] = bbl[bv];
|
||||
}
|
||||
}
|
||||
}
|
||||
// Finalize sections array
|
||||
this.section = sections.toArray(new Section[sections.size()]);
|
||||
this.sectionOffset = sectoff;
|
||||
}
|
||||
|
||||
public int getX()
|
||||
{
|
||||
return x;
|
||||
}
|
||||
}
|
||||
// Finish and add section
|
||||
bld.addSection(secnum, sbld.build());
|
||||
sbld.reset();
|
||||
}
|
||||
return bld.build();
|
||||
}
|
||||
|
||||
// Load generic chunk from existing and already loaded chunk
|
||||
protected GenericChunk getLoadedChunk(DynmapChunk chunk) {
|
||||
CraftWorld cw = (CraftWorld) w;
|
||||
NBTTagCompound nbt = null;
|
||||
if (cw.isChunkLoaded(chunk.x, chunk.z)) {
|
||||
Chunk c = cw.getHandle().getChunkIfLoaded(chunk.x, chunk.z);
|
||||
if ((c != null) && c.o) { // c.loaded
|
||||
nbt = ChunkRegionLoader.a(cw.getHandle(), c);
|
||||
}
|
||||
if (nbt.e("Level")) {
|
||||
nbt = nbt.p("Level");
|
||||
}
|
||||
if (nbt != null) {
|
||||
String stat = nbt.l("Status");
|
||||
ChunkStatus cs = ChunkStatus.a(stat);
|
||||
if ((stat == null) || (!cs.b(ChunkStatus.l))) { // ChunkStatus.LIGHT
|
||||
nbt = null;
|
||||
}
|
||||
}
|
||||
}
|
||||
return parseChunkFromNBT(nbt);
|
||||
}
|
||||
// Load generic chunk from unloaded chunk
|
||||
protected GenericChunk loadChunk(DynmapChunk chunk) {
|
||||
CraftWorld cw = (CraftWorld) w;
|
||||
NBTTagCompound nbt = null;
|
||||
ChunkCoordIntPair cc = new ChunkCoordIntPair(chunk.x, chunk.z);
|
||||
try {
|
||||
nbt = cw.getHandle().k().a.f(cc); // playerChunkMap
|
||||
} catch (IOException iox) {
|
||||
}
|
||||
if (nbt != null) {
|
||||
// See if we have Level - unwrap this if so
|
||||
if (nbt.e("Level")) {
|
||||
nbt = nbt.p("Level");
|
||||
}
|
||||
if (nbt != null) {
|
||||
String stat = nbt.l("Status");
|
||||
if ((stat == null) || (stat.equals("full") == false)) {
|
||||
nbt = null;
|
||||
}
|
||||
}
|
||||
}
|
||||
return parseChunkFromNBT(nbt);
|
||||
}
|
||||
|
||||
public int getZ()
|
||||
{
|
||||
return z;
|
||||
}
|
||||
|
||||
public DynmapBlockState getBlockType(int x, int y, int z)
|
||||
{
|
||||
int idx = (y >> 4) + sectionOffset;
|
||||
if ((idx < 0) || (idx >= section.length)) return DynmapBlockState.AIR;
|
||||
return section[idx].getBlockType(x, y, z);
|
||||
}
|
||||
|
||||
public int getBlockSkyLight(int x, int y, int z)
|
||||
{
|
||||
int idx = (y >> 4) + sectionOffset;
|
||||
if ((idx < 0) || (idx >= section.length)) return 15;
|
||||
return section[idx].getBlockSkyLight(x, y, z);
|
||||
}
|
||||
|
||||
public int getBlockEmittedLight(int x, int y, int z)
|
||||
{
|
||||
int idx = (y >> 4) + sectionOffset;
|
||||
if ((idx < 0) || (idx >= section.length)) return 0;
|
||||
return section[idx].getBlockEmittedLight(x, y, z);
|
||||
}
|
||||
|
||||
public int getHighestBlockYAt(int x, int z)
|
||||
{
|
||||
return hmap[z << 4 | x];
|
||||
}
|
||||
|
||||
public final long getCaptureFullTime()
|
||||
{
|
||||
return captureFulltime;
|
||||
}
|
||||
|
||||
public boolean isSectionEmpty(int sy)
|
||||
{
|
||||
int idx = sy + sectionOffset;
|
||||
if ((idx < 0) || (idx >= section.length)) return true;
|
||||
return section[idx].isEmpty();
|
||||
}
|
||||
|
||||
public long getInhabitedTicks() {
|
||||
return inhabitedTicks;
|
||||
}
|
||||
|
||||
@Override
|
||||
public Biome getBiome(int x, int z) {
|
||||
return AbstractMapChunkCache.getBiomeByID(biome[z << 4 | x]);
|
||||
}
|
||||
|
||||
@Override
|
||||
public Object[] getBiomeBaseFromSnapshot() {
|
||||
return this.biomebase;
|
||||
}
|
||||
public void setChunks(BukkitWorld dw, List<DynmapChunk> chunks) {
|
||||
this.w = dw.getWorld();
|
||||
super.setChunks(dw, chunks);
|
||||
}
|
||||
|
||||
private NBTTagCompound fetchLoadedChunkNBT(World w, int x, int z) {
|
||||
|
|
@ -463,156 +311,5 @@ public class MapChunkCache118 extends AbstractMapChunkCache {
|
|||
}
|
||||
}
|
||||
return nbt;
|
||||
}
|
||||
|
||||
private NBTTagCompound loadChunkNBT(World w, int x, int z) {
|
||||
//.info("loadChunkNBT(" + w.getName() + "," + x + "," + z);
|
||||
CraftWorld cw = (CraftWorld) w;
|
||||
NBTTagCompound nbt = null;
|
||||
ChunkCoordIntPair cc = new ChunkCoordIntPair(x, z);
|
||||
try {
|
||||
nbt = cw.getHandle().k().a.f(cc); // playerChunkMap
|
||||
} catch (IOException iox) {
|
||||
}
|
||||
if (nbt != null) {
|
||||
// See if we have Level - unwrap this if so
|
||||
if (nbt.e("Level")) {
|
||||
nbt = nbt.p("Level");
|
||||
}
|
||||
if (nbt != null) {
|
||||
String stat = nbt.l("Status");
|
||||
if ((stat == null) || (stat.equals("full") == false)) {
|
||||
nbt = null;
|
||||
if ((stat == null) || stat.equals("") && DynmapCore.migrateChunks()) {
|
||||
Chunk c = cw.getHandle().getChunkIfLoaded(x, z);
|
||||
if (c != null) {
|
||||
nbt = fetchLoadedChunkNBT(w, x, z);
|
||||
cw.getHandle().a(c);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return nbt;
|
||||
}
|
||||
|
||||
@Override
|
||||
public Snapshot wrapChunkSnapshot(ChunkSnapshot css) {
|
||||
// TODO Auto-generated method stub
|
||||
return null;
|
||||
}
|
||||
|
||||
// Load chunk snapshots
|
||||
@Override
|
||||
public int loadChunks(int max_to_load) {
|
||||
if(dw.isLoaded() == false)
|
||||
return 0;
|
||||
int cnt = 0;
|
||||
if(iterator == null)
|
||||
iterator = chunks.listIterator();
|
||||
|
||||
DynmapCore.setIgnoreChunkLoads(true);
|
||||
// Load the required chunks.
|
||||
while((cnt < max_to_load) && iterator.hasNext()) {
|
||||
long startTime = System.nanoTime();
|
||||
DynmapChunk chunk = iterator.next();
|
||||
boolean vis = true;
|
||||
if(visible_limits != null) {
|
||||
vis = false;
|
||||
for(VisibilityLimit limit : visible_limits) {
|
||||
if (limit.doIntersectChunk(chunk.x, chunk.z)) {
|
||||
vis = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
if(vis && (hidden_limits != null)) {
|
||||
for(VisibilityLimit limit : hidden_limits) {
|
||||
if (limit.doIntersectChunk(chunk.x, chunk.z)) {
|
||||
vis = false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
/* Check if cached chunk snapshot found */
|
||||
Snapshot ss = null;
|
||||
long inhabited_ticks = 0;
|
||||
DynIntHashMap tileData = null;
|
||||
int idx = (chunk.x-x_min) + (chunk.z - z_min)*x_dim;
|
||||
SnapshotRec ssr = SnapshotCache.sscache.getSnapshot(dw.getName(), chunk.x, chunk.z, blockdata, biome, biomeraw, highesty);
|
||||
if(ssr != null) {
|
||||
inhabited_ticks = ssr.inhabitedTicks;
|
||||
if(!vis) {
|
||||
if(hidestyle == HiddenChunkStyle.FILL_STONE_PLAIN)
|
||||
ss = STONE;
|
||||
else if(hidestyle == HiddenChunkStyle.FILL_OCEAN)
|
||||
ss = OCEAN;
|
||||
else
|
||||
ss = EMPTY;
|
||||
}
|
||||
else {
|
||||
ss = ssr.ss;
|
||||
}
|
||||
snaparray[idx] = ss;
|
||||
snaptile[idx] = ssr.tileData;
|
||||
inhabitedTicks[idx] = inhabited_ticks;
|
||||
|
||||
endChunkLoad(startTime, ChunkStats.CACHED_SNAPSHOT_HIT);
|
||||
continue;
|
||||
}
|
||||
// Fetch NTB for chunk if loaded
|
||||
NBTTagCompound nbt = fetchLoadedChunkNBT(w, chunk.x, chunk.z);
|
||||
boolean did_load = false;
|
||||
if (nbt == null) {
|
||||
// Load NTB for chunk, if it exists
|
||||
nbt = loadChunkNBT(w, chunk.x, chunk.z);
|
||||
did_load = true;
|
||||
}
|
||||
if (nbt != null) {
|
||||
NBTSnapshot nss = new NBTSnapshot(nbt, w.getMaxHeight());
|
||||
ss = nss;
|
||||
inhabited_ticks = nss.getInhabitedTicks();
|
||||
if(!vis) {
|
||||
if(hidestyle == HiddenChunkStyle.FILL_STONE_PLAIN)
|
||||
ss = STONE;
|
||||
else if(hidestyle == HiddenChunkStyle.FILL_OCEAN)
|
||||
ss = OCEAN;
|
||||
else
|
||||
ss = EMPTY;
|
||||
}
|
||||
}
|
||||
else {
|
||||
ss = EMPTY;
|
||||
}
|
||||
ssr = new SnapshotRec();
|
||||
ssr.ss = ss;
|
||||
ssr.inhabitedTicks = inhabited_ticks;
|
||||
ssr.tileData = tileData;
|
||||
SnapshotCache.sscache.putSnapshot(dw.getName(), chunk.x, chunk.z, ssr, blockdata, biome, biomeraw, highesty);
|
||||
snaparray[idx] = ss;
|
||||
snaptile[idx] = ssr.tileData;
|
||||
inhabitedTicks[idx] = inhabited_ticks;
|
||||
if (nbt == null)
|
||||
endChunkLoad(startTime, ChunkStats.UNGENERATED_CHUNKS);
|
||||
else if (did_load)
|
||||
endChunkLoad(startTime, ChunkStats.UNLOADED_CHUNKS);
|
||||
else
|
||||
endChunkLoad(startTime, ChunkStats.LOADED_CHUNKS);
|
||||
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;
|
||||
}
|
||||
}
|
||||
|
||||
return cnt;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue