/// <summary>
/// Creates a new section at the given Y location.
/// </summary>
/// <param name="y">The location of the section in relative coordinates.</param>
public Section(byte y)
{
this.Y = y;
Blocks = new byte[Width*Height*Depth];
Metadata = new NibbleArray(Width*Height*Depth);
BlockLight = new NibbleArray(Width*Height*Depth);
SkyLight = new NibbleArray(Width*Height*Depth);
nonAirCount = 0;
}
/// <summary>
/// Creates a new section at the given Y location.
/// </summary>
/// <param name="y">The location of the section in relative coordinates.</param>
public Section(byte y)
{
this.Y = y;
Blocks = new byte[Width*Height*Depth];
Metadata = new NibbleArray(Width*Height*Depth);
BlockLight = new NibbleArray(Width*Height*Depth);
SkyLight = new NibbleArray(Width*Height*Depth);
for (int i = 0; i < SkyLight.Data.Length; i++)
SkyLight.Data[i] = BlockLight.Data[i] = 0xFF;
nonAirCount = 0;
}
public SubChunk(bool clearBuffers = true)
{
_blocks = ArrayPool <short> .Shared.Rent(4096);
_loggedBlocks = ArrayPool <byte> .Shared.Rent(4096);
_blocklight = new NibbleArray(ArrayPool <byte> .Shared.Rent(2048));
_skylight = new NibbleArray(ArrayPool <byte> .Shared.Rent(2048));
if (clearBuffers)
{
ClearBuffers();
}
}
public ChunkSection()
{
SkyLight = new NibbleArray(TotalBlocks);
BlockLight = new NibbleArray(TotalBlocks);
Types = new VariableValueArray(13, TotalBlocks);
for (int i = 0; i < TotalBlocks; i++)
{
Types[i] = 0;
SkyLight[i] = 0xff;
}
AirBlocks = TotalBlocks;
}
public ChunkData()
{
m_Blocks = new byte[BlockCountInChunk];
m_BlockStates = new byte[BlockCountInChunk];
m_SkyLights = new NibbleArray(BlockCountInChunk);
m_BlockLights = new NibbleArray(BlockCountInChunk);
m_HeightMap = new byte[ChunkWidth * ChunkWidth];
m_TickRefCounts = new ushort[SectionCountInChunk];
m_RenderableCounts = new uint[SectionCountInChunk];
m_ReadWriteLock = new ReaderWriterLockSlim(LockRecursionPolicy.NoRecursion);
}
public Chunk(Coordinates2D coordinates) : this()
{
X = coordinates.X;
Z = coordinates.Z;
const int size = Width * Height * Depth;
Blocks = new byte[size];
Metadata = new NibbleArray(size);
BlockLight = new NibbleArray(size);
SkyLight = new NibbleArray(size);
for (int i = 0; i < size; i++)
{
SkyLight[i] = 0xFF;
}
}
public SubChunk(bool clearBuffers = true)
{
_runtimeIds = new List <int> {
(int)BlockFactory.GetBlockByName("minecraft:air").GetRuntimeId()
};
_blocks = ArrayPool <short> .Shared.Rent(4096);
_loggedBlocks = ArrayPool <byte> .Shared.Rent(4096);
_blocklight = new NibbleArray(ArrayPool <byte> .Shared.Rent(2048));
_skylight = new NibbleArray(ArrayPool <byte> .Shared.Rent(2048));
if (clearBuffers)
{
ClearBuffers();
}
}
protected virtual void Dispose(bool disposing)
{
if (!disposed)
{
if (disposing)
{
Blocks = null;
Metadata = null;
Blocklight.Data = null;
Blocklight = null;
BiomeId = null;
BiomeColor = null;
Skylight.Data = null;
Skylight = null;
}
disposed = true;
}
}
public ChunkSection(ChunkColumn owner, int y, bool storeSkylight, int sections = 2)
{
Owner = owner;
if (sections <= 0)
{
sections = 1;
}
this._yBase = y;
//Data = new BlockStorage();
_blockStorages = new BlockStorage[sections];
for (int i = 0; i < sections; i++)
{
_blockStorages[i] = new BlockStorage();
}
this.BlockLight = new NibbleArray(new byte[2048]);
MiNET.Worlds.ChunkColumn.Fill <byte>(BlockLight.Data, 0);
// if (storeSkylight)
{
this.SkyLight = new NibbleArray(new byte[2048]);
MiNET.Worlds.ChunkColumn.Fill <byte>(SkyLight.Data, (byte)(storeSkylight ? 0xff : 0x00));
}
//System.Collections.BitArray a = new System.Collections.BitArray(new byte[(16 * 16 * 16) / 8]);
TransparentBlocks = new System.Collections.BitArray(new byte[(16 * 16 * 16) / 8]);
SolidBlocks = new System.Collections.BitArray(new byte[(16 * 16 * 16) / 8]);
ScheduledUpdates = new System.Collections.BitArray(new byte[(16 * 16 * 16) / 8]);
ScheduledSkylightUpdates = new System.Collections.BitArray(new byte[(16 * 16 * 16) / 8]);
ScheduledBlocklightUpdates = new System.Collections.BitArray(new byte[(16 * 16 * 16) / 8]);
RenderedBlocks = new System.Collections.BitArray(new byte[(16 * 16 * 16) / 8]);
for (int i = 0; i < TransparentBlocks.Length; i++)
{
TransparentBlocks[i] = true;
SolidBlocks[i] = false;
}
}
public ChunkSection(int y, bool storeSkylight)
{
this._yBase = y;
Data = new BlockStorage();
this.BlockLight = new NibbleArray(4096, 0);
if (storeSkylight)
{
this.SkyLight = new NibbleArray(4096, 0xff);
}
TransparentBlocks = new BitArray(new byte[(16 * 16 * 16) / 8]);
SolidBlocks = new BitArray(new byte[(16 * 16 * 16) / 8]);
ScheduledUpdates = new BitArray(new byte[(16 * 16 * 16) / 8]);
ScheduledSkylightUpdates = new BitArray(new byte[(16 * 16 * 16) / 8]);
RenderedBlocks = new BitArray(new byte[(16 * 16 * 16) / 8]);
for (int i = 0; i < TransparentBlocks.Length; i++)
{
TransparentBlocks[i] = true;
SolidBlocks[i] = false;
}
}
public void ResetSkyLight()
{
this.SkyLight = new NibbleArray(4096, 0);
}
/// <summary>
/// Called by a Chunk to initialize the MSB array if getBlockMSBArray returns null. Returns the newly-created
/// NibbleArray instance.
/// </summary>
public virtual NibbleArray CreateBlockMSBArray()
{
BlockMSBArray = new NibbleArray(BlockLSBArray.Length, 4);
return(BlockMSBArray);
}
public virtual void Load(TagCompound c)
{
_blockLight = (new NibbleArray(c.GetByteArray("BlockLight"), 4));
_skyLight = (new NibbleArray(c.GetByteArray("SkyLight"), 4));
}
public void Correct_Backing_len()
{
var a = new NibbleArray(3);
Assert.Equal(2, a.Backing.Length);
}
public void ResetWater(ByteArray blocks, NibbleArray data)
{
for (int i = 0; i < blocks.Length; i++) {
if ((blocks[i] == BlockType.STATIONARY_WATER || blocks[i] == BlockType.WATER) && data[i] != 0) {
blocks[i] = BlockType.AIR;
data[i] = 0;
}
else if (blocks[i] == BlockType.WATER) {
blocks[i] = BlockType.STATIONARY_WATER;
}
}
}
public static byte[] Compress(Bitmap image, ref NibbleArray beforeCompressed, PixelFormat format)
{
using var info = new MemoryStream();
var bitmapData = image.LockBits(new Rectangle(0, 0, image.Width, image.Height), ImageLockMode.ReadOnly,
format);
var pixelsPer = System.Drawing.Image.GetPixelFormatSize(bitmapData.PixelFormat) >> 3;
var height = bitmapData.Height;
var width = bitmapData.Width * pixelsPer;
var pixels = new NibbleArray(width * height);
var changedPixelData = new NibbleArray(width * height);
var offset = bitmapData.Stride - width;
var changedPos = 0;
unsafe
{
var pos = 0;
var point = (byte *)bitmapData.Scan0;
var changed = false;
var startChanged = 0;
for (var y = 0; y < height; y++)
{
for (var x = 0; x < width; x++)
{
var before = changed;
var color = pixels[pos++] = *point++;
var check = pos - 1;
changed = pixels[check] != beforeCompressed[check];
if (changed)
{
changedPixelData[changedPos++] = color;
}
if (before == changed)
{
continue;
}
if (!before)
{
startChanged = check;
}
else
{
var count = check - startChanged - 1;
Write(info, ByteBuf.GetVarInt(startChanged));
Write(info, ByteBuf.GetVarInt(count));
}
}
point += offset;
}
if (changed)
{
var count = pos - startChanged - 1;
Write(info, ByteBuf.GetVarInt(startChanged));
Write(info, ByteBuf.GetVarInt(count));
}
}
beforeCompressed = pixels;
image.UnlockBits(bitmapData);
if (changedPos == 0)
{
return(null);
}
using var ms = new MemoryStream();
var changedPixels = changedPixelData.GetData(changedPos);
var length = changedPixels.Length;
// var compressed = ByteHelper.Compress(changedPixels);
// if (length > compressed.Length)
// {
// // Debug.WriteLine($"{changedPixels.Length} -> {compressed.Length}");
// length = compressed.Length;
// changedPixels = compressed;
// ms.WriteByte(1);
// }
// else
ms.WriteByte(0);
Write(ms, ByteBuf.GetVarInt(length));
ms.Write(changedPixels, 0, length);
Write(ms, info.ToArray());
return(ms.ToArray());
}
public void Throws_OutOfRange()
{
var a = new NibbleArray(3);
Assert.Throws <IndexOutOfRangeException>(() => a[3] = 10);
}
public AnvilSectionClassic(int y, bool makeSkyLight)
: base(y, makeSkyLight)
{
_blocks = new byte[4096];
_data = new NibbleArray();
}
public ChunkSectionCompactStorage(DataArray data, NibbleArray blockLight, NibbleArray skyLight)
{
Data = data;
BlockLight = blockLight;
SkyLight = skyLight;
}
private void HandleChunk(byte[] chunkData, int cx, int cz, Action <ChunkColumn> callback)
{
MeasureProfiler.StartCollectingData();
var profiler = MiniProfiler.StartNew("BEToJavaColumn");
try
{
using (MemoryStream stream = new MemoryStream(chunkData))
{
NbtBinaryReader defStream = new NbtBinaryReader(stream, true);
int count = defStream.ReadByte();
if (count < 1)
{
Log.Warn("Nothing to read");
return;
}
ChunkColumn chunkColumn = new ChunkColumn();
chunkColumn.IsDirty = true;
chunkColumn.X = cx;
chunkColumn.Z = cz;
for (int s = 0; s < count; s++)
{
var section = chunkColumn.Sections[s] as ChunkSection;
if (section == null)
{
section = new ChunkSection(s, true);
}
int version = defStream.ReadByte();
if (version == 1 || version == 8)
{
int storageSize = defStream.ReadByte();
for (int storage = 0; storage < storageSize; storage++)
{
int paletteAndFlag = defStream.ReadByte();
bool isRuntime = (paletteAndFlag & 1) != 0;
int bitsPerBlock = paletteAndFlag >> 1;
int blocksPerWord = (int)Math.Floor(32f / bitsPerBlock);
int wordCount = (int)Math.Ceiling(4096.0f / blocksPerWord);
uint[] words = new uint[wordCount];
for (int w = 0; w < wordCount; w++)
{
int word = defStream.ReadInt32();
words[w] = SwapBytes((uint)word);
}
uint[] pallete = new uint[0];
if (isRuntime)
{
int palleteSize = VarInt.ReadSInt32(stream);
pallete = new uint[palleteSize];
for (int pi = 0; pi < pallete.Length; pi++)
{
var ui = (uint)VarInt.ReadSInt32(stream);
pallete[pi] = ui;
}
if (palleteSize == 0)
{
Log.Warn($"Pallete size is 0");
continue;
}
}
int position = 0;
for (int w = 0; w < wordCount; w++)
{
uint word = words[w];
for (int block = 0; block < blocksPerWord; block++)
{
if (position >= 4096)
{
break; // padding bytes
}
uint state =
(uint)((word >> ((position % blocksPerWord) * bitsPerBlock)) &
((1 << bitsPerBlock) - 1));
int x = (position >> 8) & 0xF;
int y = position & 0xF;
int z = (position >> 4) & 0xF;
if (storage == 0)
{
if (state >= pallete.Length)
{
continue;
}
IBlockState translated = _convertedStates.GetOrAdd(pallete[state],
u =>
{
if (_blockStateMap.TryGetValue(pallete[state], out var bs))
{
var result =
BlockFactory.RuntimeIdTable.FirstOrDefault(xx =>
xx.Name == bs.Name);
if (result != null && result.Id >= 0)
{
var reverseMap = MiNET.Worlds.AnvilWorldProvider.Convert.FirstOrDefault(map =>
map.Value.Item1 == result.Id);
var id = result.Id;
if (reverseMap.Value != null)
{
id = reverseMap.Key;
}
var res = BlockFactory.GetBlockStateID(
(int)id,
(byte)bs.Data);
if (AnvilWorldProvider.BlockStateMapper.TryGetValue(
res,
out var res2))
{
var t = BlockFactory.GetBlockState(res2);
t = TranslateBlockState(t, id,
bs.Data);
return(t);
}
else
{
Log.Info(
$"Did not find anvil statemap: {result.Name}");
return(TranslateBlockState(
BlockFactory.GetBlockState(result.Name),
id, bs.Data));
}
}
return(TranslateBlockState(
BlockFactory.GetBlockState(bs.Name),
-1, bs.Data));
}
return(null);
});
if (translated != null)
{
section.Set(x, y, z, translated);
}
}
else
{
//TODO.
}
position++;
}
if (position >= 4096)
{
break;
}
}
}
}
else
{
#region OldFormat
byte[] blockIds = new byte[4096];
defStream.Read(blockIds, 0, blockIds.Length);
NibbleArray data = new NibbleArray(4096);
defStream.Read(data.Data, 0, data.Data.Length);
for (int x = 0; x < 16; x++)
{
for (int z = 0; z < 16; z++)
{
for (int y = 0; y < 16; y++)
{
int idx = (x << 8) + (z << 4) + y;
var id = blockIds[idx];
var meta = data[idx];
IBlockState result = null;
if (id > 0 && result == null)
{
var res = BlockFactory.GetBlockStateID(id, meta);
if (AnvilWorldProvider.BlockStateMapper.TryGetValue(res,
out var res2))
{
var t = BlockFactory.GetBlockState(res2);
t = TranslateBlockState(t, id,
meta);
result = t;
}
else
{
Log.Info($"Did not find anvil statemap: {result.Name}");
result = TranslateBlockState(BlockFactory.GetBlockState(res),
id, meta);
}
}
if (result == null)
{
var results = BlockFactory.RuntimeIdTable.Where(xx =>
xx.Id == id && xx.Data == meta).ToArray();
if (results.Length > 0)
{
result = TranslateBlockState(
BlockFactory.GetBlockState((uint)results[0].RuntimeId), id,
meta);
}
}
if (result != null)
{
section.Set(x, y, z, result);
}
}
}
}
#endregion
}
if (UseAlexChunks)
{
// Log.Info($"Alex chunk!");
var rawSky = new Utils.NibbleArray(4096);
defStream.Read(rawSky.Data, 0, rawSky.Data.Length);
var rawBlock = new Utils.NibbleArray(4096);
defStream.Read(rawBlock.Data, 0, rawBlock.Data.Length);
for (int x = 0; x < 16; x++)
{
for (int y = 0; y < 16; y++)
{
for (int z = 0; z < 16; z++)
{
var peIndex = (x * 256) + (z * 16) + y;
var sky = rawSky[peIndex];
var block = rawBlock[peIndex];
var idx = y << 8 | z << 4 | x;
section.SkyLight[idx] = sky;
section.BlockLight[idx] = block;
}
}
}
}
section.RemoveInvalidBlocks();
section.IsDirty = true;
//Make sure the section is saved.
chunkColumn.Sections[s] = section;
}
byte[] ba = new byte[512];
if (defStream.Read(ba, 0, 256 * 2) != 256 * 2)
{
Log.Error($"Out of data height");
}
Buffer.BlockCopy(ba, 0, chunkColumn.Height, 0, 512);
int[] biomeIds = new int[256];
for (int i = 0; i < biomeIds.Length; i++)
{
biomeIds[i] = defStream.ReadByte();
}
chunkColumn.BiomeId = biomeIds;
if (stream.Position >= stream.Length - 1)
{
callback?.Invoke(chunkColumn);
return;
}
int borderBlock = VarInt.ReadSInt32(stream);
if (borderBlock > 0)
{
byte[] buf = new byte[borderBlock];
int len = defStream.Read(buf, 0, borderBlock);
}
if (stream.Position < stream.Length - 1)
{
while (stream.Position < stream.Length)
{
NbtFile file = new NbtFile()
{
BigEndian = false,
UseVarInt = true
};
file.LoadFromStream(stream, NbtCompression.None);
}
}
if (stream.Position < stream.Length - 1)
{
Log.Warn(
$"Still have data to read\n{Packet.HexDump(defStream.ReadBytes((int) (stream.Length - stream.Position)))}");
}
//Done processing this chunk, send to world
callback?.Invoke(chunkColumn);
}
}
catch (Exception ex)
{
Log.Error($"Exception in chunk loading: {ex.ToString()}");
}
finally
{
profiler?.Stop();
MeasureProfiler.SaveData();
}
}
public void ResetWater(ByteArray blocks, NibbleArray data)
{
for (int i = 0; i < blocks.Length; i++) {
if ((blocks[i] == BlockInfo.StationaryWater.ID || blocks[i] == BlockInfo.Water.ID) && data[i] != 0) {
blocks[i] = (byte)BlockInfo.Air.ID;
data[i] = 0;
}
else if (blocks[i] == BlockInfo.Water.ID) {
blocks[i] = (byte)BlockInfo.StationaryWater.ID;
}
}
}
public virtual void Func_48715_h()
{
BlockMSBArray = null;
}
public void ResetLava(ByteArray blocks, NibbleArray data)
{
for (int i = 0; i < blocks.Length; i++) {
if ((blocks[i] == BlockType.STATIONARY_LAVA || blocks[i] == BlockType.LAVA) && data[i] != 0) {
blocks[i] = BlockType.AIR;
data[i] = 0;
}
else if (blocks[i] == BlockType.LAVA) {
blocks[i] = BlockType.STATIONARY_LAVA;
}
}
}
/// <summary>
/// Sets the NibbleArray instance used for Sky-light values in this particular storage block.
/// </summary>
public virtual void SetSkylightArray(NibbleArray par1NibbleArray)
{
SkylightArray = par1NibbleArray;
}
public static void ConvertToAnvilFormat(AnvilConverterData par0AnvilConverterData, NBTTagCompound par1NBTTagCompound, WorldChunkManager par2WorldChunkManager)
{
par1NBTTagCompound.SetInteger("xPos", par0AnvilConverterData.x);
par1NBTTagCompound.SetInteger("zPos", par0AnvilConverterData.z);
par1NBTTagCompound.SetLong("LastUpdate", par0AnvilConverterData.LastUpdated);
int[] ai = new int[par0AnvilConverterData.Heightmap.Length];
for (int i = 0; i < par0AnvilConverterData.Heightmap.Length; i++)
{
ai[i] = par0AnvilConverterData.Heightmap[i];
}
par1NBTTagCompound.Func_48183_a("HeightMap", ai);
par1NBTTagCompound.Setbool("TerrainPopulated", par0AnvilConverterData.TerrainPopulated);
NBTTagList nbttaglist = new NBTTagList("Sections");
for (int j = 0; j < 8; j++)
{
bool flag = true;
for (int l = 0; l < 16 && flag; l++)
{
label0:
for (int j1 = 0; j1 < 16 && flag; j1++)
{
int k1 = 0;
do
{
if (k1 >= 16)
{
goto label0;
}
int l1 = l << 11 | k1 << 7 | j1 + (j << 4);
byte byte0 = par0AnvilConverterData.Blocks[l1];
if (byte0 != 0)
{
flag = false;
goto label0;
}
k1++;
}while (true);
}
}
if (flag)
{
continue;
}
byte[] abyte1 = new byte[4096];
NibbleArray nibblearray = new NibbleArray(abyte1.Length, 4);
NibbleArray nibblearray1 = new NibbleArray(abyte1.Length, 4);
NibbleArray nibblearray2 = new NibbleArray(abyte1.Length, 4);
for (int i2 = 0; i2 < 16; i2++)
{
for (int j2 = 0; j2 < 16; j2++)
{
for (int k2 = 0; k2 < 16; k2++)
{
int l2 = i2 << 11 | k2 << 7 | j2 + (j << 4);
byte byte1 = par0AnvilConverterData.Blocks[l2];
abyte1[j2 << 8 | k2 << 4 | i2] = (byte)(byte1 & 0xff);
nibblearray.Set(i2, j2, k2, par0AnvilConverterData.Data.Get(i2, j2 + (j << 4), k2));
nibblearray1.Set(i2, j2, k2, par0AnvilConverterData.SkyLight.Get(i2, j2 + (j << 4), k2));
nibblearray2.Set(i2, j2, k2, par0AnvilConverterData.BlockLight.Get(i2, j2 + (j << 4), k2));
}
}
}
NBTTagCompound nbttagcompound = new NBTTagCompound();
nbttagcompound.SetByte("Y", (byte)(j & 0xff));
nbttagcompound.SetByteArray("Blocks", abyte1);
nbttagcompound.SetByteArray("Data", nibblearray.Data);
nbttagcompound.SetByteArray("SkyLight", nibblearray1.Data);
nbttagcompound.SetByteArray("BlockLight", nibblearray2.Data);
nbttaglist.AppendTag(nbttagcompound);
}
par1NBTTagCompound.SetTag("Sections", nbttaglist);
byte[] abyte0 = new byte[256];
for (int k = 0; k < 16; k++)
{
for (int i1 = 0; i1 < 16; i1++)
{
abyte0[i1 << 4 | k] = (byte)(par2WorldChunkManager.GetBiomeGenAt(par0AnvilConverterData.x << 4 | k, par0AnvilConverterData.z << 4 | i1).BiomeID & 0xff);
}
}
par1NBTTagCompound.SetByteArray("Biomes", abyte0);
par1NBTTagCompound.SetTag("Entities", par0AnvilConverterData.Entities);
par1NBTTagCompound.SetTag("TileEntities", par0AnvilConverterData.TileEntities);
if (par0AnvilConverterData.TileTicks != null)
{
par1NBTTagCompound.SetTag("TileTicks", par0AnvilConverterData.TileTicks);
}
}
private static bool WriteStore(MemoryStream stream, short[] blocks, NibbleArray metadata, bool forceWrite)
{
var palette = new Dictionary <uint, byte>();
uint prevHash = uint.MaxValue;
for (int i = 0; i < 4096; i++)
{
uint hash = (uint)blocks[i] << 4 | metadata[i]; // 1.7
if (hash == prevHash)
{
continue;
}
prevHash = hash;
palette[hash] = 0;
}
// log2(number of entries) => bits needed to store them
int bitsPerBlock = (int)Math.Ceiling(Math.Log(palette.Count, 2));
switch (bitsPerBlock)
{
case 0:
if (!forceWrite && palette.ContainsKey(0))
{
return(false);
}
bitsPerBlock = 1;
break;
case 1:
case 2:
case 3:
case 4:
case 5:
case 6:
//Paletted1 = 1, // 32 blocks per word
//Paletted2 = 2, // 16 blocks per word
//Paletted3 = 3, // 10 blocks and 2 bits of padding per word
//Paletted4 = 4, // 8 blocks per word
//Paletted5 = 5, // 6 blocks and 2 bits of padding per word
//Paletted6 = 6, // 5 blocks and 2 bits of padding per word
break;
case 7:
case 8:
//Paletted8 = 8, // 4 blocks per word
bitsPerBlock = 8;
break;
case int i when i > 8:
//Paletted16 = 16, // 2 blocks per word
bitsPerBlock = 16;
break;
default:
break;
}
stream.WriteByte((byte)((bitsPerBlock << 1) | 1)); // version
int blocksPerWord = (int)Math.Floor(32f / bitsPerBlock); // Floor to remove padding bits
int wordsPerChunk = (int)Math.Ceiling(4096f / blocksPerWord);
byte t = 0;
foreach (var b in palette.ToArray())
{
palette[b.Key] = t++;
}
uint[] indexes = new uint[wordsPerChunk];
int position = 0;
for (int w = 0; w < wordsPerChunk; w++)
{
uint word = 0;
for (int block = 0; block < blocksPerWord; block++)
{
if (position >= 4096)
{
continue;
}
uint state = palette[(uint)blocks[position] << 4 | metadata[position]];
word |= state << (bitsPerBlock * block);
//string bin = Convert.ToString(word, 2);
//bin = new string('0', 32 - bin.Length) + bin;
//Console.WriteLine($"{bin}");
position++;
}
indexes[w] = word;
}
byte[] ba = new byte[indexes.Length * 4];
Buffer.BlockCopy(indexes, 0, ba, 0, indexes.Length * 4);
stream.Write(ba, 0, ba.Length);
int[] legacyToRuntimeId = BlockFactory.LegacyToRuntimeId;
VarInt.WriteSInt32(stream, palette.Count); // count
foreach (var val in palette)
{
VarInt.WriteSInt32(stream, legacyToRuntimeId[val.Key]);
}
return(true);
}
/// <summary>
/// Sets the NibbleArray of block metadata (blockMetadataArray) for this ExtendedBlockStorage.
/// </summary>
public virtual void SetBlockMetadataArray(NibbleArray par1NibbleArray)
{
BlockMetadataArray = par1NibbleArray;
}
private CompoundTag ConvertSection(Tag sectionTag)
{
byte[] blockData = new byte[4096];
NibbleArray metaData = new NibbleArray(4096);
CompoundTag section = (CompoundTag)sectionTag;
long[] states = section.GetLongArray("BlockStates");
ListTag palette = section.GetList("Palette");
List <RuntimeTable.Table> indexs = new List <RuntimeTable.Table>();
foreach (Tag paletteTag in palette.Tags)
{
if (paletteTag is CompoundTag)
{
CompoundTag pt = (CompoundTag)paletteTag;
string name = pt.GetString("Name");
indexs.Add(RuntimeTable.GetNameToTable(name, pt.GetCompound("Properties").Tags));
}
}
int bits = CheckMostBit(indexs.Count - 1);
List <byte> fixStates = new List <byte>();
foreach (long state in states)
{
fixStates.AddRange(BitConverter.GetBytes((ulong)state));
}
BitArray stateBits = new BitArray(fixStates.ToArray());
for (int i = 0; i < 4096; i++)
{
int bitOffset = i * bits;
uint index = stateBits.Get(bitOffset + bits - 1) ? 1u : 0u;
for (int j = bits - 2; j >= 0; j--)
{
index <<= 1;
index |= stateBits.Get(bitOffset + j) ? 1u : 0u;
}
try
{
RuntimeTable.Table table = indexs[(int)index];
blockData[i] = (byte)(table.Id & 0xff);
metaData[i] = (byte)(table.Data & 0xf);
}
catch (Exception e)
{
Logger.Info(indexs.Count + " = " + states[0] + " >>> " + states[1]);
throw e;
}
}
var newSection = (CompoundTag)section.Clone();
newSection.Remove("BlockStates");
newSection.Remove("Palette");
newSection.PutByteArray("Blocks", blockData);
newSection.PutByteArray("Data", metaData.ArrayData);
return(newSection);
}
/// <summary>
/// Sets the NibbleArray instance used for Block-light values in this particular storage block.
/// </summary>
public virtual void SetBlocklightArray(NibbleArray par1NibbleArray)
{
BlocklightArray = par1NibbleArray;
}
public void GetRawDataNoCheck(out ChunkPos pos, out IWorld world, out BlockData[,,] blocks, out Quaternion[,,] rotations, out NibbleArray skyLights, out byte[,] heightMap)
{
pos = m_Position;
world = m_World;
blocks = m_Blocks;
rotations = m_Rotations;
skyLights = m_SkyLights;
heightMap = m_HeightMap;
}
