public void SkippingTagsOnFileLoad()
{
var loadedFile = new NbtFile();
loadedFile.LoadFromFile("TestFiles/bigtest.nbt",
NbtCompression.None,
tag => tag.Name != "nested compound test");
Assert.IsFalse(loadedFile.RootTag.Contains("nested compound test"));
Assert.IsTrue(loadedFile.RootTag.Contains("listTest (long)"));
loadedFile.LoadFromFile("TestFiles/bigtest.nbt",
NbtCompression.None,
tag => tag.TagType != NbtTagType.Float || tag.Parent.Name != "Level");
Assert.IsFalse(loadedFile.RootTag.Contains("floatTest"));
Assert.AreEqual(0.75f, loadedFile.RootTag["nested compound test"]["ham"]["value"].FloatValue);
loadedFile.LoadFromFile("TestFiles/bigtest.nbt",
NbtCompression.None,
tag => tag.Name != "listTest (long)");
Assert.IsFalse(loadedFile.RootTag.Contains("listTest (long)"));
Assert.IsTrue(loadedFile.RootTag.Contains("byteTest"));
loadedFile.LoadFromFile("TestFiles/bigtest.nbt",
NbtCompression.None,
tag => false);
Assert.AreEqual(0, loadedFile.RootTag.Count);
}
public void LoadingBigFileGZip()
{
var file = new NbtFile();
long length = file.LoadFromFile(TestFiles.BigGZip);
TestFiles.AssertNbtBigFile(file);
Assert.AreEqual(length, new FileInfo(TestFiles.BigGZip).Length);
}
public void ByteArrayFromStream()
{
var data = new byte[64*1024];
for (int i = 0; i < data.Length; i++) {
data[i] = unchecked((byte)i);
}
using (var ms = new MemoryStream()) {
var writer = new NbtWriter(ms, "root");
{
byte[] buffer = new byte[1024];
using (var dataStream = new NonSeekableStream(new MemoryStream(data))) {
writer.WriteByteArray("byteArray1", dataStream, data.Length);
}
using (var dataStream = new NonSeekableStream(new MemoryStream(data))) {
writer.WriteByteArray("byteArray2", dataStream, data.Length, buffer);
}
using (var dataStream = new NonSeekableStream(new MemoryStream(data))) {
writer.WriteByteArray("byteArray3", dataStream, 1);
}
using (var dataStream = new NonSeekableStream(new MemoryStream(data))) {
writer.WriteByteArray("byteArray4", dataStream, 1, buffer);
}
writer.BeginList("innerLists", NbtTagType.ByteArray, 4);
using (var dataStream = new NonSeekableStream(new MemoryStream(data))) {
writer.WriteByteArray(dataStream, data.Length);
}
using (var dataStream = new NonSeekableStream(new MemoryStream(data))) {
writer.WriteByteArray(dataStream, data.Length, buffer);
}
using (var dataStream = new NonSeekableStream(new MemoryStream(data))) {
writer.WriteByteArray(dataStream, 1);
}
using (var dataStream = new NonSeekableStream(new MemoryStream(data))) {
writer.WriteByteArray(dataStream, 1, buffer);
}
writer.EndList();
}
writer.EndCompound();
writer.Finish();
ms.Position = 0;
var file = new NbtFile();
file.LoadFromStream(ms, NbtCompression.None);
CollectionAssert.AreEqual(data, file.RootTag["byteArray1"].ByteArrayValue);
CollectionAssert.AreEqual(data, file.RootTag["byteArray2"].ByteArrayValue);
Assert.AreEqual(1, file.RootTag["byteArray3"].ByteArrayValue.Length);
Assert.AreEqual(data[0], file.RootTag["byteArray3"].ByteArrayValue[0]);
Assert.AreEqual(1, file.RootTag["byteArray4"].ByteArrayValue.Length);
Assert.AreEqual(data[0], file.RootTag["byteArray4"].ByteArrayValue[0]);
CollectionAssert.AreEqual(data, file.RootTag["innerLists"][0].ByteArrayValue);
CollectionAssert.AreEqual(data, file.RootTag["innerLists"][1].ByteArrayValue);
Assert.AreEqual(1, file.RootTag["innerLists"][2].ByteArrayValue.Length);
Assert.AreEqual(data[0], file.RootTag["innerLists"][2].ByteArrayValue[0]);
Assert.AreEqual(1, file.RootTag["innerLists"][3].ByteArrayValue.Length);
Assert.AreEqual(data[0], file.RootTag["innerLists"][3].ByteArrayValue[0]);
}
}
public void ErrorTest()
{
var root = new NbtCompound("root");
byte[] testData = new NbtFile(root).SaveToBuffer(NbtCompression.None);
// creating NbtReader without a stream, or with a non-readable stream
Assert.Throws<ArgumentNullException>(() => new NbtReader(null));
Assert.Throws<ArgumentException>(() => new NbtReader(new NonReadableStream()));
// corrupt the data
testData[0] = 123;
var reader = new NbtReader(new MemoryStream(testData));
// attempt to use ReadValue when not at value
Assert.Throws<InvalidOperationException>(() => reader.ReadValue());
reader.CacheTagValues = true;
Assert.Throws<InvalidOperationException>(() => reader.ReadValue());
// attempt to read a corrupt stream
Assert.Throws<NbtFormatException>(() => reader.ReadToFollowing());
// make sure we've properly entered the error state
Assert.IsTrue(reader.IsInErrorState);
Assert.IsFalse(reader.HasName);
Assert.Throws<InvalidReaderStateException>(() => reader.ReadToFollowing());
Assert.Throws<InvalidReaderStateException>(() => reader.ReadListAsArray<int>());
Assert.Throws<InvalidReaderStateException>(() => reader.ReadToNextSibling());
Assert.Throws<InvalidReaderStateException>(() => reader.ReadToDescendant("derp"));
Assert.Throws<InvalidReaderStateException>(() => reader.ReadAsTag());
Assert.Throws<InvalidReaderStateException>(() => reader.Skip());
}
public void SkippingLists()
{
{
var file = new NbtFile(TestFiles.MakeListTest());
byte[] savedFile = file.SaveToBuffer(NbtCompression.None);
file.LoadFromBuffer(savedFile, 0, savedFile.Length, NbtCompression.None,
tag => tag.TagType != NbtTagType.List);
Assert.AreEqual(0, file.RootTag.Count);
}
{
// Check list-compound interaction
NbtCompound comp = new NbtCompound("root") {
new NbtCompound("compOfLists") {
new NbtList("listOfComps") {
new NbtCompound {
new NbtList("emptyList", NbtTagType.Compound)
}
}
}
};
var file = new NbtFile(comp);
byte[] savedFile = file.SaveToBuffer(NbtCompression.None);
file.LoadFromBuffer(savedFile, 0, savedFile.Length, NbtCompression.None,
tag => tag.TagType != NbtTagType.List);
Assert.AreEqual(1, file.RootTag.Count);
}
}
public void TestNbtSmallFileLoadingUncompressed()
{
var file = new NbtFile();
file.LoadFile("TestFiles/test.nbt", false);
AssertNbtSmallFile(file);
}
public void TestNbtSmallFileLoading()
{
var file = new NbtFile();
file.LoadFile("TestFiles/test.nbt.gz");
AssertNbtSmallFile(file);
}
public void LoadingBigFileZLib()
{
var file = new NbtFile();
int length = file.LoadFromFile(TestFiles.BigZLib);
TestFiles.AssertNbtBigFile(file);
Assert.AreEqual(length, new FileInfo(TestFiles.BigZLib).Length);
}
public void SkippingLists()
{
var file = new NbtFile(TestFiles.MakeListTest());
byte[] savedFile = file.SaveToBuffer(NbtCompression.None);
file.LoadFromBuffer(savedFile, 0, savedFile.Length, NbtCompression.None, tag => false);
Assert.AreEqual(file.RootTag.Count, 0);
}
public void ReloadUncompressed()
{
NbtFile loadedFile = new NbtFile( "TestFiles/bigtest.nbt", NbtCompression.AutoDetect );
loadedFile.SaveToFile( "TestTemp/bigtest.nbt", NbtCompression.None );
loadedFile.LoadFromFile( "TestTemp/bigtest.nbt", NbtCompression.AutoDetect );
AssertNbtBigFile( loadedFile );
}
public void LoadingBigFileZLib()
{
var file = new NbtFile();
int length = file.LoadFromFile( "TestFiles/bigtest.nbt.z" );
AssertNbtBigFile( file );
Assert.AreEqual( length, new FileInfo( "TestFiles/bigtest.nbt.z" ).Length );
}
public void LoadingBigFileBuffer()
{
byte[] fileBytes = File.ReadAllBytes( "TestFiles/bigtest.nbt" );
var file = new NbtFile();
int length = file.LoadFromBuffer( fileBytes, 0, fileBytes.Length, NbtCompression.AutoDetect, null );
AssertNbtBigFile( file );
Assert.AreEqual( length, new FileInfo( "TestFiles/bigtest.nbt" ).Length );
}
public void HugeNbtFileTest()
{
byte[] val = new byte[1024*1024*1024];
NbtCompound root = new NbtCompound("root") {
new NbtByteArray("payload1") {
Value = val
}
};
NbtFile file = new NbtFile(root);
file.SaveToStream(Stream.Null, NbtCompression.None);
}
public void SkippingValuesInCompoundTest()
{
NbtCompound root = TestFiles.MakeValueTest();
NbtCompound nestedComp = TestFiles.MakeValueTest();
nestedComp.Name = "NestedComp";
root.Add(nestedComp);
var file = new NbtFile(root);
byte[] savedFile = file.SaveToBuffer(NbtCompression.None);
file.LoadFromBuffer(savedFile, 0, savedFile.Length, NbtCompression.None, tag => false);
Assert.AreEqual(0, file.RootTag.Count);
}
public void LoadingBigFileStream()
{
byte[] fileBytes = File.ReadAllBytes(TestFiles.Big);
using (var ms = new MemoryStream(fileBytes)) {
using (var nss = new NonSeekableStream(ms)) {
var file = new NbtFile();
long length = file.LoadFromStream(nss, NbtCompression.None, null);
TestFiles.AssertNbtBigFile(file);
Assert.AreEqual(length, new FileInfo(TestFiles.Big).Length);
}
}
}
public void LoadingBigFileBuffer()
{
byte[] fileBytes = File.ReadAllBytes(TestFiles.Big);
var file = new NbtFile();
Assert.Throws<ArgumentNullException>(
() => file.LoadFromBuffer(null, 0, fileBytes.Length, NbtCompression.AutoDetect, null));
long length = file.LoadFromBuffer(fileBytes, 0, fileBytes.Length, NbtCompression.AutoDetect, null);
TestFiles.AssertNbtBigFile(file);
Assert.AreEqual(length, new FileInfo(TestFiles.Big).Length);
}
public void LoadingBigFileStream()
{
byte[] fileBytes = File.ReadAllBytes( "TestFiles/bigtest.nbt" );
using( MemoryStream ms = new MemoryStream( fileBytes ) ) {
using( NonSeekableStream nss = new NonSeekableStream( ms ) ) {
var file = new NbtFile();
int length = file.LoadFromStream( nss, NbtCompression.None, null );
AssertNbtBigFile( file );
Assert.AreEqual( length, new FileInfo( "TestFiles/bigtest.nbt" ).Length );
}
}
}
public void TestNbtSmallFileSavingUncompressed()
{
var file = new NbtFile
{
RootTag = new NbtCompound("hello world", new NbtTag[]
{
new NbtString("name", "Bananrama")
})
};
file.SaveFile("TestTemp/test.nbt", false);
FileAssert.AreEqual("TestFiles/test.nbt", "TestTemp/test.nbt");
}
public void CacheTagValuesTest()
{
byte[] testData = new NbtFile(TestFiles.MakeValueTest()).SaveToBuffer(NbtCompression.None);
var reader = new NbtReader(new MemoryStream(testData));
Assert.IsFalse(reader.CacheTagValues);
reader.CacheTagValues = true;
Assert.IsTrue(reader.ReadToFollowing()); // root
Assert.IsTrue(reader.ReadToFollowing()); // byte
Assert.AreEqual(reader.ReadValue(), 1);
Assert.AreEqual(reader.ReadValue(), 1);
Assert.IsTrue(reader.ReadToFollowing()); // short
Assert.AreEqual(reader.ReadValue(), 2);
Assert.AreEqual(reader.ReadValue(), 2);
Assert.IsTrue(reader.ReadToFollowing()); // int
Assert.AreEqual(reader.ReadValue(), 3);
Assert.AreEqual(reader.ReadValue(), 3);
Assert.IsTrue(reader.ReadToFollowing()); // long
Assert.AreEqual(reader.ReadValue(), 4L);
Assert.AreEqual(reader.ReadValue(), 4L);
Assert.IsTrue(reader.ReadToFollowing()); // float
Assert.AreEqual(reader.ReadValue(), 5f);
Assert.AreEqual(reader.ReadValue(), 5f);
Assert.IsTrue(reader.ReadToFollowing()); // double
Assert.AreEqual(reader.ReadValue(), 6d);
Assert.AreEqual(reader.ReadValue(), 6d);
Assert.IsTrue(reader.ReadToFollowing()); // byteArray
CollectionAssert.AreEqual((byte[])reader.ReadValue(),
new byte[] {
10, 11, 12
});
CollectionAssert.AreEqual((byte[])reader.ReadValue(),
new byte[] {
10, 11, 12
});
Assert.IsTrue(reader.ReadToFollowing()); // intArray
CollectionAssert.AreEqual((int[])reader.ReadValue(),
new[] {
20, 21, 22
});
CollectionAssert.AreEqual((int[])reader.ReadValue(),
new[] {
20, 21, 22
});
Assert.IsTrue(reader.ReadToFollowing()); // string
Assert.AreEqual(reader.ReadValue(), "123");
Assert.AreEqual(reader.ReadValue(), "123");
}
public void GlobalsTest()
{
Assert.AreEqual(NbtFile.DefaultBufferSize, new NbtFile(new NbtCompound("Foo")).BufferSize);
Assert.Throws<ArgumentOutOfRangeException>(() => NbtFile.DefaultBufferSize = -1);
NbtFile.DefaultBufferSize = 12345;
Assert.AreEqual(12345, NbtFile.DefaultBufferSize);
// Newly-created NbtFiles should use default buffer size
NbtFile tempFile = new NbtFile(new NbtCompound("Foo"));
Assert.AreEqual(NbtFile.DefaultBufferSize, tempFile.BufferSize);
Assert.Throws<ArgumentOutOfRangeException>(() => tempFile.BufferSize = -1);
tempFile.BufferSize = 54321;
Assert.AreEqual(54321, tempFile.BufferSize);
// Changing default buffer size should not retroactively change already-existing NbtFiles' buffer size.
NbtFile.DefaultBufferSize = 8192;
Assert.AreEqual(54321, tempFile.BufferSize);
}
private void UpdateMinecraftWorlds()
{
List <WorldItem> worlds = new List <WorldItem>();
string minecraftSavesPath = Path.Join(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "\\.minecraft\\saves");
string[] paths = Directory.GetDirectories(minecraftSavesPath);
foreach (string dir in paths)
{
//check if leveldata and levelname can be determined
try {
NbtFile level = new NbtFile(Path.Join(dir, "/level.dat"));
string name = level.RootTag.Get <NbtCompound>("Data").Get <NbtString>("LevelName").Value.ToString();
worlds.Add(new WorldItem {
name = name, path = dir
});
} catch { }
}
WorldSelection.DataSource = worlds;
}
protected bool Equals(Item other)
{
if (Id != other.Id || Metadata != other.Metadata)
{
return(false);
}
if (ExtraData == null ^ other.ExtraData == null)
{
return(false);
}
byte[] saveToBuffer = null;
if (other.ExtraData != null)
{
other.ExtraData.Name = string.Empty;
saveToBuffer = new NbtFile(other.ExtraData).SaveToBuffer(NbtCompression.None);
}
byte[] saveToBuffer2 = null;
if (ExtraData != null)
{
ExtraData.Name = string.Empty;
saveToBuffer2 = new NbtFile(ExtraData).SaveToBuffer(NbtCompression.None);
}
var nbtCheck = !(saveToBuffer == null ^ saveToBuffer2 == null);
if (nbtCheck)
{
if (saveToBuffer == null)
{
nbtCheck = true;
}
else
{
nbtCheck = saveToBuffer.SequenceEqual(saveToBuffer2);
}
}
return(nbtCheck);
}
public void TestNbtListType()
{
var file = new NbtFile();
file.RootTag = new NbtCompound("ListTypeTest");
NbtTagType mytype = NbtTagType.TAG_Compound;
NbtList list = new NbtList("Entities", null, mytype);
file.RootTag.Tags.Add(list);
file.SaveFile("TestFiles/NbtListType.nbt");
NbtFile read = new NbtFile();
read.LoadFile("TestFiles/NbtListType.nbt");
Assert.NotNull(read);
Console.WriteLine(read.RootTag.ToString());
NbtList readlist = (NbtList)read.RootTag.Tags.ToArray()[0];
Assert.NotNull(readlist);
Assert.AreEqual(mytype, readlist.ListType);
}
public void SaveLevelInfo(LevelInfo level)
{
if (!Directory.Exists(BasePath))
{
Directory.CreateDirectory(BasePath);
}
else
{
return;
}
if (LevelInfo.SpawnY <= 0)
{
LevelInfo.SpawnY = 256;
}
NbtFile file = new NbtFile();
NbtTag dataTag = file.RootTag["Data"] = new NbtCompound("Data");
level.SaveToNbt(dataTag);
file.SaveToFile(Path.Combine(BasePath, "level.dat"), NbtCompression.ZLib);
}
public void WriteTagTest()
{
using var ms = new MemoryStream();
var writer = new NbtWriter(ms, "root");
{
foreach (NbtTag tag in TestFiles.MakeValueTest().Tags)
{
writer.WriteTag(tag);
}
writer.EndCompound();
Assert.True(writer.IsDone);
writer.Finish();
}
ms.Position = 0;
var file = new NbtFile();
long bytesRead = file.LoadFromBuffer(ms.ToArray(), 0, (int)ms.Length, NbtCompression.None);
Assert.Equal(bytesRead, ms.Length);
TestFiles.AssertValueTest(file);
}
private void openToolStripMenuItem_Click(object sender, EventArgs e)
{
string filename1 = "";
//DDS test;
openFileDialog.Filter = "Schematic Files .schematic | *.schematic";
openFileDialog.Title = "Select a Schematic";
openFileDialog.InitialDirectory = System.Environment.GetFolderPath(Environment.SpecialFolder.Personal);
if (openFileDialog.ShowDialog() == DialogResult.OK)
{
NbtFile test = new NbtFile(openFileDialog.FileName, true);
test.LoadFile();
AssertNbtBigFile(test);
paintIt = true;
this.Width = rXmax * 20;
this.Height = rYmax * 20;
this.Refresh();
Console.WriteLine("CLICK!");
}
}
public void SkippingTagsOnFileLoad()
{
NbtFile loadedFile = new NbtFile();
loadedFile.LoadFromFile("TestFiles/bigtest.nbt",
NbtCompression.None,
tag => tag.Name != "nested compound test");
Assert.IsFalse(loadedFile.RootTag.Contains("nested compound test"));
Assert.IsTrue(loadedFile.RootTag.Contains("listTest (long)"));
loadedFile.LoadFromFile("TestFiles/bigtest.nbt",
NbtCompression.None,
tag => tag.TagType != NbtTagType.Float || tag.Parent.Name != "Level");
Assert.IsFalse(loadedFile.RootTag.Contains("floatTest"));
Assert.AreEqual(loadedFile.RootTag["nested compound test"]["ham"]["value"].FloatValue, 0.75);
loadedFile.LoadFromFile("TestFiles/bigtest.nbt",
NbtCompression.None,
tag => tag.Name != "listTest (long)");
Assert.IsFalse(loadedFile.RootTag.Contains("listTest (long)"));
Assert.IsTrue(loadedFile.RootTag.Contains("byteTest"));
}
public void NullParameterTest()
{
Assert.Throws <ArgumentNullException>(() => new NbtFile((NbtCompound)null));
Assert.Throws <ArgumentNullException>(() => new NbtFile((string)null));
NbtFile file = new NbtFile();
Assert.Throws <ArgumentNullException>(() => file.LoadFromBuffer(null, 0, 1, NbtCompression.None));
Assert.Throws <ArgumentNullException>(() => file.LoadFromBuffer(null, 0, 1, NbtCompression.None, tag => true));
Assert.Throws <ArgumentNullException>(() => file.LoadFromFile(null));
Assert.Throws <ArgumentNullException>(() => file.LoadFromFile(null, NbtCompression.None, tag => true));
Assert.Throws <ArgumentNullException>(() => file.LoadFromStream(null, NbtCompression.AutoDetect));
Assert.Throws <ArgumentNullException>(() => file.LoadFromStream(null, NbtCompression.AutoDetect, tag => true));
Assert.Throws <ArgumentNullException>(() => file.SaveToBuffer(null, 0, NbtCompression.None));
Assert.Throws <ArgumentNullException>(() => file.SaveToFile(null, NbtCompression.None));
Assert.Throws <ArgumentNullException>(() => file.SaveToStream(null, NbtCompression.None));
Assert.Throws <ArgumentNullException>(() => NbtFile.ReadRootTagName(null));
Assert.Throws <ArgumentNullException>(
() => NbtFile.ReadRootTagName((Stream)null, NbtCompression.None, true, 0));
}
public void Save()
{
lock (Regions)
{
foreach (var region in Regions)
{
region.Value.Save(Path.Combine(BaseDirectory, Region.GetRegionFileName(region.Key)));
}
}
var file = new NbtFile();
file.RootTag.Add(new NbtCompound("SpawnPoint", new[]
{
new NbtInt("X", this.SpawnPoint.X),
new NbtInt("Y", this.SpawnPoint.Y),
new NbtInt("Z", this.SpawnPoint.Z)
}));
file.RootTag.Add(new NbtInt("Seed", this.Seed));
file.RootTag.Add(new NbtString("ChunkProvider", this.ChunkProvider.GetType().FullName));
file.RootTag.Add(new NbtString("Name", Name));
file.SaveToFile(Path.Combine(this.BaseDirectory, "manifest.nbt"), NbtCompression.ZLib);
}
public static List <WorldData> getSavedWorldData()
{
List <WorldData> worlds = new List <WorldData>();
string[] names = Directory.GetDirectories("saves/");
foreach (string folderName in names)
{
string dataFile = folderName + "/world.nbt";
if (File.Exists(dataFile))
{
NbtFile file = new NbtFile();
file.LoadFromFile(dataFile);
WorldData data = new WorldData(folderName.Substring(folderName.LastIndexOf('/') + 1, folderName.Length - 1 - folderName.LastIndexOf('/')));
data.readFromNbt(file.RootTag);
worlds.Add(data);
}
}
worlds.Sort((i2, i1) => DateTime.Compare(i1.lastLoaded, i2.lastLoaded));
return(worlds);
}
protected override Dictionary <long, Map> LoadMaps()
{
var maps = new Dictionary <long, Map>();
OpenDB();
// thank you A Cynodont for help with this section
const string MapKeyword = "map";
var iterator = BedrockDB.CreateIterator();
iterator.Seek(MapKeyword);
while (iterator.IsValid())
{
var name = iterator.StringKey();
if (name.StartsWith(MapKeyword))
{
if (MapString(name, out long number))
{
NbtFile nbtfile = new NbtFile();
nbtfile.BigEndian = false;
byte[] data = iterator.Value();
nbtfile.LoadFromBuffer(data, 0, data.Length, NbtCompression.AutoDetect);
var colors = nbtfile.RootTag["colors"].ByteArrayValue;
// skip completely blank maps (bedrock likes generating pointless parents)
if (!colors.All(x => x == 0))
{
maps.Add(number, new BedrockMap(colors));
}
}
}
else
{
break;
}
iterator.Next();
}
iterator.Dispose();
CloseDB();
return(maps);
}
public void ReadValueTest()
{
var root = new NbtCompound("root")
{
new NbtByte("byte", 1),
new NbtShort("short", 2),
new NbtInt("int", 3),
new NbtLong("long", 4),
new NbtFloat("float", 5),
new NbtDouble("double", 6),
new NbtByteArray("byteArray", new byte[] { 10, 11, 12 }),
new NbtIntArray("intArray", new[] { 20, 21, 22 }),
new NbtString("string", "23")
};
var testData = new NbtFile(root).SaveToBuffer(NbtCompression.None);
var reader = new NbtReader(new MemoryStream(testData));
Assert.IsTrue(reader.ReadToFollowing()); // root
Assert.IsTrue(reader.ReadToFollowing()); // byte
Assert.AreEqual(reader.ReadValue(), 1);
Assert.IsTrue(reader.ReadToFollowing()); // short
Assert.AreEqual(reader.ReadValue(), 2);
Assert.IsTrue(reader.ReadToFollowing()); // int
Assert.AreEqual(reader.ReadValue(), 3);
Assert.IsTrue(reader.ReadToFollowing()); // long
Assert.AreEqual(reader.ReadValue(), 4);
Assert.IsTrue(reader.ReadToFollowing()); // float
Assert.AreEqual(reader.ReadValue(), 5f);
Assert.IsTrue(reader.ReadToFollowing()); // double
Assert.AreEqual(reader.ReadValue(), 6d);
Assert.IsTrue(reader.ReadToFollowing()); // byteArray
CollectionAssert.AreEqual((byte[])reader.ReadValue(), new byte[] { 10, 11, 12 });
Assert.IsTrue(reader.ReadToFollowing()); // intArray
CollectionAssert.AreEqual((int[])reader.ReadValue(), new[] { 20, 21, 22 });
Assert.IsTrue(reader.ReadToFollowing()); // string
Assert.AreEqual(reader.ReadValue(), "23");
}
public void NestedListAndCompoundTest()
{
byte[] data;
{
var root = new NbtCompound("Root");
var outerList = new NbtList("OuterList", NbtTagType.Compound);
var outerCompound = new NbtCompound();
var innerList = new NbtList("InnerList", NbtTagType.Compound);
var innerCompound = new NbtCompound();
innerList.Add(innerCompound);
outerCompound.Add(innerList);
outerList.Add(outerCompound);
root.Add(outerList);
var file = new NbtFile(root);
data = file.SaveToBuffer(NbtCompression.None);
}
{
var file = new NbtFile();
long bytesRead = file.LoadFromBuffer(data, 0, data.Length, NbtCompression.None);
Assert.AreEqual(bytesRead, data.Length);
NbtCompound rootTag = (NbtCompound)file.RootTag;
Assert.AreEqual(1, rootTag.Get <NbtList>("OuterList").Count);
Assert.AreEqual(null, rootTag.Get <NbtList>("OuterList").Get <NbtCompound>(0).Name);
Assert.AreEqual(1,
rootTag.Get <NbtList>("OuterList")
.Get <NbtCompound>(0)
.Get <NbtList>("InnerList")
.Count);
Assert.AreEqual(null,
rootTag.Get <NbtList>("OuterList")
.Get <NbtCompound>(0)
.Get <NbtList>("InnerList")
.Get <NbtCompound>(0)
.Name);
}
}
private void LoadFromNbt(NbtFile nbtFile)
{
NbtTag dataTag = nbtFile.RootTag["Level"];
//Debug.WriteLine($"Chunk {x},{z}: {nbtFile}");
biomeId = dataTag["Biomes"].ByteArrayValue;
isAllAir = true;
var sections = dataTag["Sections"] as NbtList;
foreach (NbtTag sectionTag in sections)
{
LoadNbtSection(sectionTag);
}
var entities = dataTag["Entities"] as NbtList;
if (entities != null)
{
foreach (NbtTag entityTag in entities)
{
LoadNbtEntity(entityTag);
}
}
var blockEntities = dataTag["TileEntities"] as NbtList;
if (blockEntities != null)
{
foreach (NbtTag blockEntityTag in blockEntities)
{
LoadNbtBlockEntity(blockEntityTag);
}
}
isDirty = false;
}
public void NestedListTest()
{
NbtCompound root = new NbtCompound( "root" ) {
new NbtList( "OuterList" ) {
new NbtList {
new NbtByte()
},
new NbtList {
new NbtShort()
},
new NbtList {
new NbtInt()
}
}
};
byte[] testData = new NbtFile( root ).SaveToBuffer( NbtCompression.None );
using( MemoryStream ms = new MemoryStream( testData ) ) {
NbtReader reader = new NbtReader( ms );
while( reader.ReadToFollowing() ) {
Console.WriteLine( reader.ToString( true ) );
}
}
}
private void IncreaseMapIdCount(int id)
{
NbtFile idcounts;
string path = Path.Combine(Folder, "data", "idcounts.dat");
if (File.Exists(path))
{
idcounts = new NbtFile(Path.Combine(Folder, "data", "idcounts.dat"));
int existing = idcounts.RootTag["data"]["map"].IntValue;
idcounts.RootTag["data"]["map"] = new NbtInt("map", Math.Max(existing, id));
}
else
{
idcounts = new NbtFile(new NbtCompound("")
{
new NbtCompound("data")
{
new NbtInt("map", id)
}
});
}
idcounts.SaveToFile(path, NbtCompression.GZip);
}
public bool Load()
{
var path = Path.Combine(Directory.GetCurrentDirectory(), "players", Username + ".nbt");
if (!File.Exists(path))
{
return(false);
}
try
{
var nbt = new NbtFile(path);
Entity.Position = new Vector3(
nbt.RootTag["position"][0].DoubleValue,
nbt.RootTag["position"][1].DoubleValue,
nbt.RootTag["position"][2].DoubleValue);
Inventory.SetSlots(((NbtList)nbt.RootTag["inventory"]).Select(t => ItemStack.FromNbt(t as NbtCompound)).ToArray());
(Entity as PlayerEntity).Health = nbt.RootTag["health"].ShortValue;
Entity.Yaw = nbt.RootTag["yaw"].FloatValue;
Entity.Pitch = nbt.RootTag["pitch"].FloatValue;
}
catch { /* Who cares */ }
return(true);
}
public void Palette(string file)
{
var myFile = new NbtFile();
myFile.LoadFromFile(file);
var myCompTag = myFile.RootTag;
NbtList block = myFile.RootTag.Get <NbtList>("palette");
for (int i = 0; i < block.Count; i++)
{
if (block.Get <NbtCompound>(i).Contains("Properties") == true)
{
BlockStateConstraint bSC = new BlockStateConstraint();
palette.Add(bSC.BlockStates(file, i));
}
else
{
palette.Add(new List <string> {
block.Get <NbtCompound>(i).Get <NbtString>("Name").StringValue, "null", "null", "null", "null", "null", "null"
});
}
}
}
public void ByteArrayFromStream()
{
var data = new byte[64*1024];
for (int i = 0; i < data.Length; i++) {
data[i] = unchecked((byte)i);
}
using (var ms = new MemoryStream()) {
var writer = new NbtWriter(ms, "root");
{
using (var dataStream = new NonSeekableStream(new MemoryStream(data))) {
writer.WriteByteArray("byteArray", dataStream, data.Length);
}
}
writer.EndCompound();
writer.Finish();
ms.Position = 0;
var file = new NbtFile();
file.LoadFromStream(ms, NbtCompression.None);
CollectionAssert.AreEqual(file.RootTag["byteArray"].ByteArrayValue, data);
}
}
public static bool GenerateFlat(int x, int y, int z, string path = "./")
{
if (ExistChunk(x, y, z, path))
{
return(false);
}
NbtCompound TileEntities = new NbtCompound("TileEntities");
if (y > 0)
{
NbtCompound Blocks;
TileEntities.Add(Blocks = new NbtCompound("Blocks"));
for (int i = 0; i < 4096; i++)
{
Blocks.Add(new NbtCompound(i.ToString())
{
new NbtFloat("BlockPos", i),
new NbtInt("BlockID", 1),
});
}
}
NbtCompound compound = new NbtCompound("root")
{
new NbtInt("DataVersion", Amane.chunkVersion),
new NbtCompound("Level")
{
new NbtInt("xPos", x),
new NbtInt("yPos", y),
new NbtInt("zPos", z),
TileEntities
}
};
var NBTFile = new NbtFile(compound);
NBTFile.SaveToFile($"{path}world/awo/{x.ToString()}.{y.ToString()}.{z.ToString()}.nbt.zlib", NbtCompression.ZLib);
return(true);
}
public static void SaveOfflinePlayerData(this MiNetServer server, string name, NbtCompound nbtTag, bool async = false)
{
NbtFile nbt = new NbtFile(nbtTag);
nbt.BigEndian = true;
ParameterizedThreadStart threadStart = new ParameterizedThreadStart(obj =>
{
try
{
string path = Config.GetProperty("PluginDirectory", ".\\") + "\\PlayerSave\\players\\";
if (!Directory.Exists(path))
{
Directory.CreateDirectory(path);
}
((NbtFile)((object[])obj)[0]).SaveToFile(path + ((object[])obj)[1].ToString().ToLower() + ".dat", NbtCompression.ZLib);
}
catch (Exception e)
{
ConsoleColor col = Console.ForegroundColor;
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine(e.Message);
Console.WriteLine(e.StackTrace);
Console.ForegroundColor = col;
}
});
Thread thread = new Thread(threadStart);
if (async)
{
thread.Start(new object[] { nbt, name });
}
else
{
threadStart(new object[] { nbt, name });
}
}
protected bool Equals(Item other)
{
if (Id != other.Id || Metadata != other.Metadata)
{
return(false);
}
if (ExtraData == null ^ other.ExtraData == null)
{
return(false);
}
//TODO: This doesn't work in most cases. We need to fix comparison when name == null
byte[] saveToBuffer = null;
if (other.ExtraData?.Name != null)
{
saveToBuffer = new NbtFile(other.ExtraData).SaveToBuffer(NbtCompression.None);
}
byte[] saveToBuffer2 = null;
if (ExtraData?.Name != null)
{
saveToBuffer2 = new NbtFile(ExtraData).SaveToBuffer(NbtCompression.None);
}
bool nbtCheck = !(saveToBuffer == null ^ saveToBuffer2 == null);
if (nbtCheck)
{
if (saveToBuffer == null)
{
nbtCheck = true;
}
else
{
nbtCheck = saveToBuffer.SequenceEqual(saveToBuffer2);
}
}
return(nbtCheck);
}
// creates a file with lots of compounds and lists, used to test NbtReader compliance
public static Stream MakeReaderTest()
{
var root = new NbtCompound("root")
{
new NbtInt("first"),
new NbtInt("second"),
new NbtCompound("third-comp")
{
new NbtInt("inComp1"),
new NbtInt("inComp2"),
new NbtInt("inComp3")
},
new NbtList("fourth-list")
{
new NbtList {
new NbtCompound {
new NbtCompound("inList1")
}
},
new NbtList {
new NbtCompound {
new NbtCompound("inList2")
}
},
new NbtList {
new NbtCompound {
new NbtCompound("inList3")
}
}
},
new NbtInt("fifth"),
new NbtByteArray("hugeArray", new byte[1024 * 1024])
};
byte[] testData = new NbtFile(root).SaveToBuffer(NbtCompression.None);
return(new MemoryStream(testData));
}
public void Test1()
{
var nbtFile = new NbtFile();
nbtFile.RootTag.Add(new NbtInt(1, "23333"));
nbtFile.RootTag.Add(new NbtCompound("test"));
var testCompound = nbtFile.RootTag["test"] as NbtCompound;
Assert.NotNull(testCompound);
var testList = new NbtList(NbtTagType.Int, "testList");
testCompound.Add(testList);
testList.Add(new NbtInt(2));
testList.Add(new NbtInt(4));
testCompound.Add(new NbtLong(0x000000FFFFFFFFFF, "testLong"));
using (var sw = new StringWriter())
{
nbtFile.RootTag.Accept(new OutputVisitor(sw));
var str = sw.ToString();
Console.WriteLine(str);
}
var stream = new FileStream("test.bin", FileMode.OpenOrCreate, FileAccess.ReadWrite);
stream.SetLength(0);
nbtFile.WriteTo(stream);
stream.Seek(0, SeekOrigin.Begin);
var nbtFile2 = new NbtFile(stream);
using (var sw = new StringWriter())
{
nbtFile2.RootTag.Accept(new OutputVisitor(sw));
Console.WriteLine(sw.ToString());
}
}
public void CacheTagValuesTest()
{
byte[] testData = new NbtFile(TestFiles.MakeValueTest()).SaveToBuffer(NbtCompression.None);
var reader = new NbtReader(new MemoryStream(testData));
Assert.IsFalse(reader.CacheTagValues);
reader.CacheTagValues = true;
Assert.IsTrue(reader.ReadToFollowing()); // root
Assert.IsTrue(reader.ReadToFollowing()); // byte
Assert.AreEqual(1, reader.ReadValue());
Assert.AreEqual(1, reader.ReadValue());
Assert.IsTrue(reader.ReadToFollowing()); // short
Assert.AreEqual(2, reader.ReadValue());
Assert.AreEqual(2, reader.ReadValue());
Assert.IsTrue(reader.ReadToFollowing()); // int
Assert.AreEqual(3, reader.ReadValue());
Assert.AreEqual(3, reader.ReadValue());
Assert.IsTrue(reader.ReadToFollowing()); // long
Assert.AreEqual(4L, reader.ReadValue());
Assert.AreEqual(4L, reader.ReadValue());
Assert.IsTrue(reader.ReadToFollowing()); // float
Assert.AreEqual(5f, reader.ReadValue());
Assert.AreEqual(5f, reader.ReadValue());
Assert.IsTrue(reader.ReadToFollowing()); // double
Assert.AreEqual(6d, reader.ReadValue());
Assert.AreEqual(6d, reader.ReadValue());
Assert.IsTrue(reader.ReadToFollowing()); // byteArray
CollectionAssert.AreEqual(new byte[] { 10, 11, 12 }, (byte[])reader.ReadValue());
CollectionAssert.AreEqual(new byte[] { 10, 11, 12 }, (byte[])reader.ReadValue());
Assert.IsTrue(reader.ReadToFollowing()); // intArray
CollectionAssert.AreEqual(new[] { 20, 21, 22 }, (int[])reader.ReadValue());
CollectionAssert.AreEqual(new[] { 20, 21, 22 }, (int[])reader.ReadValue());
Assert.IsTrue(reader.ReadToFollowing()); // string
Assert.AreEqual("123", reader.ReadValue());
Assert.AreEqual("123", reader.ReadValue());
}
//[Test]
//public void LevelDbGetValueFromMissingKey()
//{
// using var db = new Database(new DirectoryInfo(@"C:\Development\Other\bedrock-server-1.14.1.4\worlds\BedrockGeneratedLevel\db"));
// db.Open();
// int x = 15;
// int z = 6;
// Log.Warn("Looking for version");
// var versionKey = BitConverter.GetBytes(x).Concat(BitConverter.GetBytes(z)).Concat(new byte[] {0x76}).ToArray();
// var version = db.Get(versionKey);
// Assert.AreEqual(15, version.First());
// Log.Warn("Looking for key");
// Assert.NotNull(db.Get(BitConverter.GetBytes(x).Concat(BitConverter.GetBytes(z)).Concat(new byte[] {0x2f, 0}).ToArray()));
// Assert.NotNull(db.Get(BitConverter.GetBytes(x).Concat(BitConverter.GetBytes(z)).Concat(new byte[] {0x2f, 1}).ToArray()));
// Assert.NotNull(db.Get(BitConverter.GetBytes(x).Concat(BitConverter.GetBytes(z)).Concat(new byte[] {0x2f, 2}).ToArray()));
// Assert.NotNull(db.Get(BitConverter.GetBytes(x).Concat(BitConverter.GetBytes(z)).Concat(new byte[] {0x2f, 3}).ToArray()));
// Assert.NotNull(db.Get(BitConverter.GetBytes(x).Concat(BitConverter.GetBytes(z)).Concat(new byte[] {0x2f, 4}).ToArray()));
// Assert.NotNull(db.Get(BitConverter.GetBytes(x).Concat(BitConverter.GetBytes(z)).Concat(new byte[] {0x2f, 5}).ToArray()));
// Assert.Null(db.Get(BitConverter.GetBytes(x).Concat(BitConverter.GetBytes(z)).Concat(new byte[] {0x2f, 6}).ToArray()));
// Assert.Null(db.Get(BitConverter.GetBytes(x).Concat(BitConverter.GetBytes(z)).Concat(new byte[] {0x2f, 7}).ToArray()));
// Assert.Null(db.Get(BitConverter.GetBytes(x).Concat(BitConverter.GetBytes(z)).Concat(new byte[] {0x2f, 8}).ToArray())); // Fail??
// Assert.Null(db.Get(BitConverter.GetBytes(x).Concat(BitConverter.GetBytes(z)).Concat(new byte[] {0x2f, 9}).ToArray()));
// Assert.Null(db.Get(BitConverter.GetBytes(x).Concat(BitConverter.GetBytes(z)).Concat(new byte[] {0x2f, 10}).ToArray()));
// Assert.Null(db.Get(BitConverter.GetBytes(x).Concat(BitConverter.GetBytes(z)).Concat(new byte[] {0x2f, 11}).ToArray()));
// Assert.Null(db.Get(BitConverter.GetBytes(x).Concat(BitConverter.GetBytes(z)).Concat(new byte[] {0x2f, 12}).ToArray()));
// Assert.Null(db.Get(BitConverter.GetBytes(x).Concat(BitConverter.GetBytes(z)).Concat(new byte[] {0x2f, 13}).ToArray()));
// Assert.Null(db.Get(BitConverter.GetBytes(x).Concat(BitConverter.GetBytes(z)).Concat(new byte[] {0x2f, 14}).ToArray()));
// Assert.Null(db.Get(BitConverter.GetBytes(x).Concat(BitConverter.GetBytes(z)).Concat(new byte[] {0x2f, 15}).ToArray()));
//}
private void ParseChunk(ReadOnlySpan <byte> data)
{
var reader = new SpanReader(data);
var version = reader.ReadByte();
Assert.AreEqual(8, version); // new palette-based chunk format
var storageSize = reader.ReadByte();
for (int i = 0; i < storageSize; i++)
{
var bitsPerBlock = reader.ReadByte() >> 1;
Assert.AreEqual(4, bitsPerBlock);
int numberOfBytes = 4096 / (32 / bitsPerBlock) * 4;
var blockData = reader.Read(numberOfBytes);
Assert.AreEqual(4096 / 2, blockData.Length);
int paletteSize = reader.ReadInt32();
Assert.AreEqual(12, paletteSize);
for (int j = 0; j < paletteSize; j++)
{
NbtFile file = new NbtFile();
file.BigEndian = false;
file.UseVarInt = false;
var buffer = data.Slice(reader.Position).ToArray();
int numberOfBytesRead = (int)file.LoadFromStream(new MemoryStream(buffer), NbtCompression.None);
reader.Position += numberOfBytesRead;
Console.WriteLine(file.RootTag);
Assert.NotZero(numberOfBytesRead);
}
}
}
public void Save(Map mapToSave, string path)
{
NbtCompound rootTag = new NbtCompound("Schematic")
{
new NbtShort("Width", (short)mapToSave.Width),
new NbtShort("Height", (short)mapToSave.Height),
new NbtShort("Length", (short)mapToSave.Length),
new NbtString("Materials", "Classic"),
new NbtByteArray("Blocks", mapToSave.Blocks),
// set to 0 unless converted in overloaded DoConversion
new NbtByteArray("Data", new byte[mapToSave.Volume]),
// these two lists are empty, but required for compatibility
new NbtList("Entities", NbtTagType.Compound),
new NbtList("TileEntities", NbtTagType.Compound),
};
DoConversion(rootTag);
NbtFile file = new NbtFile(rootTag);
file.SaveToFile(path, NbtCompression.GZip);
File.WriteAllText("debug.txt", file.RootTag.ToString(" "));
}
static Stream MakeTest()
{
NbtCompound root = new NbtCompound("root")
{
new NbtInt("first"),
new NbtInt("second"),
new NbtCompound("third-comp")
{
new NbtInt("inComp1"),
new NbtInt("inComp2"),
new NbtInt("inComp3")
},
new NbtList("fourth-list")
{
new NbtList {
new NbtCompound {
new NbtCompound("inList1")
}
},
new NbtList {
new NbtCompound {
new NbtCompound("inList2")
}
},
new NbtList {
new NbtCompound {
new NbtCompound("inList3")
}
}
},
new NbtInt("fifth")
};
byte[] testData = new NbtFile(root).SaveToBuffer(NbtCompression.None);
return(new MemoryStream(testData));
}
public void Initialize()
{
if (_isInitialized)
{
return; // Quick exit
}
lock (_initializeSync)
{
if (_isInitialized)
{
return;
}
var file = new NbtFile();
file.LoadFromFile(Path.Combine(BasePath, "level.dat"));
NbtTag dataTag = file.RootTag["Data"];
LevelInfo = new LevelInfo(dataTag);
LoadAvailableRegions();
_isInitialized = true;
}
}
public override Level Read(Stream src, string name, bool metadata)
{
NbtFile file = new NbtFile();
file.LoadFromStream(src);
NbtCompound root = file.RootTag;
byte[] raw = root["Blocks"].ByteArrayValue;
byte[] meta = root["Data"].ByteArrayValue;
int width = root["Width"].ShortValue;
int height = root["Height"].ShortValue;
int length = root["Length"].ShortValue;
Level lvl = new Level(name, (ushort)width, (ushort)height, (ushort)length);
byte[] blocks = lvl.blocks;
for (int i = 0; i < blocks.Length; i++)
{
blocks[i] = (byte)mcConv[raw[i], meta[i] & 0x0F];
}
for (int i = 0; i < blocks.Length; i++)
{
byte block = blocks[i];
if (block < Block.CPE_COUNT)
{
continue;
}
blocks[i] = Block.custom_block;
ushort x, y, z;
lvl.IntToPos(i, out x, out y, out z);
lvl.FastSetExtTile(x, y, z, block);
}
return(lvl);
}
public override void Save(string Folder)
{
string f = Path.Combine(Folder, "DefaultMapGenerator.dat");
NbtFile nf = new NbtFile(f);
nf.RootTag = new NbtCompound("__ROOT__");
NbtCompound c = new NbtCompound("DefaultMapGenerator");
c.Add(new NbtByte("GenerateCaves", (byte)(GenerateCaves ? 1 : 0)));
c.Add(new NbtByte("GenerateDungeons", (byte)(GenerateDungeons ? 1 : 0)));
c.Add(new NbtByte("GenerateOres", (byte)(GenerateOres ? 1 : 0)));
c.Add(new NbtByte("GenerateWater", (byte)(GenerateWater ? 1 : 0)));
c.Add(new NbtByte("HellMode", (byte)(HellMode ? 1 : 0)));
c.Add(new NbtByte("GenerateTrees", (byte)(GenerateTrees ? 1 : 0)));
c.Add(new NbtDouble("Frequency", Frequency));
c.Add(new NbtByte("NoiseQuality", (byte)NoiseQuality));
c.Add(new NbtInt("OctaveCount", OctaveCount));
c.Add(new NbtDouble("Lacunarity", Lacunarity));
c.Add(new NbtDouble("Persistance", Persistance));
c.Add(new NbtDouble("ContinentNoiseFrequency", ContinentNoiseFrequency));
c.Add(new NbtDouble("CaveThreshold", CaveThreshold));
nf.RootTag.Add(c);
nf.SaveFile(f);
}
public Zakaznici(Form1 form)
{
this.form = form;
ZakazniciS = new SortedDictionary <string, byte>();
if (File.Exists(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData) + "\\Ticketnik\\zakaznici"))
{
Zak = zak = new NbtFile(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData) + "\\Ticketnik\\zakaznici");
form.verze = zak.RootTag.Get <NbtInt>("verze").Value;
foreach (NbtTag c in zak.RootTag)
{
if (c.TagType == NbtTagType.Compound)
{
ZakazniciS.Add(((NbtCompound)c).Get <NbtString>("Jmeno").Value, ((NbtCompound)c).Get <NbtByte>("Velikost").Value);
}
}
if (zak.RootTag.Get <NbtInt>("verze").Value >= 17)
{
if (zak.RootTag.Get <NbtList>("Terpy") != null)
{
Terpy = (NbtCompound)zak.RootTag.Get <NbtList>("Terpy")[0];
}
else
{
form.Aktualizace(true);
}
}
}
else
{
zak = new NbtFile();
Directory.CreateDirectory(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData) + "\\Ticketnik");
zak.RootTag.Add(new NbtInt("verze", 1));
zak.SaveToFile(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData) + "\\Ticketnik\\zakaznici", NbtCompression.GZip);
}
}
public void Initialize()
{
BasePath = BasePath ?? Config.GetProperty("LevelDBWorldFolder", "World").Trim();
var directory = new DirectoryInfo(Path.Combine(BasePath, "db"));
var levelFileName = Path.Combine(BasePath, "level.dat");
Log.Debug($"Loading level.dat from {levelFileName}");
if (File.Exists(levelFileName))
{
var file = new NbtFile
{
BigEndian = false,
UseVarInt = false
};
var levelStream = File.OpenRead(levelFileName);
levelStream.Seek(8, SeekOrigin.Begin);
file.LoadFromStream(levelStream, NbtCompression.None);
Log.Debug($"Level DAT\n{file.RootTag}");
NbtTag dataTag = file.RootTag["Data"];
//LevelInfo = new LevelInfoBedrock(dataTag);
}
else
{
Log.Warn($"No level.dat found at {levelFileName}. Creating empty.");
LevelInfo = new LevelInfoBedrock();
}
var db = new Database(directory);
db.Open();
_db = db;
MissingChunkProvider?.Initialize();
}
public void CacheTagValuesTest()
{
byte[] testData = new NbtFile(TestFiles.MakeValueTest()).SaveToBuffer(NbtCompression.None);
var reader = new NbtReader(new MemoryStream(testData));
Assert.False(reader.CacheTagValues);
reader.CacheTagValues = true;
Assert.True(reader.ReadToFollowing()); // root
Assert.True(reader.ReadToFollowing()); // byte
Assert.Equal((byte) 1, reader.ReadValue());
Assert.Equal((byte) 1, reader.ReadValue());
Assert.True(reader.ReadToFollowing()); // short
Assert.Equal((Int16) 2, reader.ReadValue());
Assert.Equal((Int16) 2, reader.ReadValue());
Assert.True(reader.ReadToFollowing()); // int
Assert.Equal(3, reader.ReadValue());
Assert.Equal(3, reader.ReadValue());
Assert.True(reader.ReadToFollowing()); // long
Assert.Equal(4L, reader.ReadValue());
Assert.Equal(4L, reader.ReadValue());
Assert.True(reader.ReadToFollowing()); // float
Assert.Equal(5f, reader.ReadValue());
Assert.Equal(5f, reader.ReadValue());
Assert.True(reader.ReadToFollowing()); // double
Assert.Equal(6d, reader.ReadValue());
Assert.Equal(6d, reader.ReadValue());
Assert.True(reader.ReadToFollowing()); // byteArray
Assert.Equal(new byte[] {10, 11, 12}, (byte[]) reader.ReadValue());
Assert.Equal(new byte[] {10, 11, 12}, (byte[]) reader.ReadValue());
Assert.True(reader.ReadToFollowing()); // intArray
Assert.Equal(new[] {20, 21, 22}, (int[]) reader.ReadValue());
Assert.Equal(new[] {20, 21, 22}, (int[]) reader.ReadValue());
Assert.True(reader.ReadToFollowing()); // string
Assert.Equal("123", reader.ReadValue());
Assert.Equal("123", reader.ReadValue());
}
static NbtFile PartialReadTestInternal(NbtFile comp)
{
byte[] testData = comp.SaveToBuffer(NbtCompression.None);
var reader = new NbtReader(new PartialReadStream(new MemoryStream(testData)));
var root = (NbtCompound) reader.ReadAsTag();
return new NbtFile(root);
}
public void ReadValueAsTest()
{
byte[] testData = new NbtFile(TestFiles.MakeValueTest()).SaveToBuffer(NbtCompression.None);
var reader = new NbtReader(new MemoryStream(testData));
Assert.True(reader.ReadToFollowing()); // root
Assert.True(reader.ReadToFollowing()); // byte
Assert.Equal(1, reader.ReadValueAs<byte>());
Assert.True(reader.ReadToFollowing()); // short
Assert.Equal(2, reader.ReadValueAs<short>());
Assert.True(reader.ReadToFollowing()); // int
Assert.Equal(3, reader.ReadValueAs<int>());
Assert.True(reader.ReadToFollowing()); // long
Assert.Equal(4L, reader.ReadValueAs<long>());
Assert.True(reader.ReadToFollowing()); // float
Assert.Equal(5f, reader.ReadValueAs<float>());
Assert.True(reader.ReadToFollowing()); // double
Assert.Equal(6d, reader.ReadValueAs<double>());
Assert.True(reader.ReadToFollowing()); // byteArray
Assert.Equal(new byte[] {10, 11, 12}, reader.ReadValueAs<byte[]>());
Assert.True(reader.ReadToFollowing()); // intArray
Assert.Equal(new[] {20, 21, 22}, reader.ReadValueAs<int[]>());
Assert.True(reader.ReadToFollowing()); // string
Assert.Equal("123", reader.ReadValueAs<string>());
}
public void ReadValueTest()
{
byte[] testData = new NbtFile(TestFiles.MakeValueTest()).SaveToBuffer(NbtCompression.None);
var reader = new NbtReader(new MemoryStream(testData));
Assert.True(reader.ReadToFollowing()); // root
Assert.True(reader.ReadToFollowing()); // byte
Assert.Equal((byte) 1, reader.ReadValue());
Assert.True(reader.ReadToFollowing()); // short
Assert.Equal((Int16) 2, reader.ReadValue());
Assert.True(reader.ReadToFollowing()); // int
Assert.Equal(3, reader.ReadValue());
Assert.True(reader.ReadToFollowing()); // long
Assert.Equal(4L, reader.ReadValue());
Assert.True(reader.ReadToFollowing()); // float
Assert.Equal(5f, reader.ReadValue());
Assert.True(reader.ReadToFollowing()); // double
Assert.Equal(6d, reader.ReadValue());
Assert.True(reader.ReadToFollowing()); // byteArray
Assert.Equal(new byte[] {10, 11, 12}, (byte[]) reader.ReadValue());
Assert.True(reader.ReadToFollowing()); // intArray
Assert.Equal(new[] {20, 21, 22}, (int[]) reader.ReadValue());
Assert.True(reader.ReadToFollowing()); // string
Assert.Equal("123", reader.ReadValue());
// Skip to the very end and make sure that we can't read any more values
reader.ReadToFollowing();
Assert.Throws<EndOfStreamException>(() => reader.ReadValue());
}
public void ReadAsTagTest4()
{
// read a bunch of lists as tags
byte[] testData = new NbtFile(TestFiles.MakeListTest()).SaveToBuffer(NbtCompression.None);
// first, read everything all-at-once
{
var reader = new NbtReader(new MemoryStream(testData));
while (!reader.IsAtStreamEnd)
{
Console.WriteLine(reader.ReadAsTag());
}
}
// next, read each list individually
{
var reader = new NbtReader(new MemoryStream(testData));
reader.ReadToFollowing(); // read to root
reader.ReadToFollowing(); // read to first list tag
while (!reader.IsAtStreamEnd)
{
Console.WriteLine(reader.ReadAsTag());
}
}
}
public void ReadAsTagTest3()
{
// read values as tags
byte[] testData = new NbtFile(TestFiles.MakeValueTest()).SaveToBuffer(NbtCompression.None);
var reader = new NbtReader(new MemoryStream(testData));
var root = new NbtCompound("root");
// skip root
reader.ReadToFollowing();
reader.ReadToFollowing();
while (!reader.IsAtStreamEnd)
{
root.Add(reader.ReadAsTag());
}
TestFiles.AssertValueTest(new NbtFile(root));
}
public void ReadAsTagTest2()
{
// read the whole thing as one tag
byte[] testData = new NbtFile(TestFiles.MakeValueTest()).SaveToBuffer(NbtCompression.None);
{
var reader = new NbtReader(new MemoryStream(testData));
var root = (NbtCompound) reader.ReadAsTag();
TestFiles.AssertValueTest(new NbtFile(root));
}
{
// Try the same thing but with end tag skipping disabled
var reader = new NbtReader(new MemoryStream(testData))
{
SkipEndTags = false
};
var root = (NbtCompound) reader.ReadAsTag();
TestFiles.AssertValueTest(new NbtFile(root));
}
}
