private static NbtFileDataNode TryCreateFrom (string path, CompressionType compressionType)
{
try {
NBTFile file = new NBTFile(path);
NbtTree tree = new NbtTree();
tree.ReadFrom(file.GetDataInputStream(compressionType));
if (tree.Root == null)
return null;
return new NbtFileDataNode(path, compressionType);
}
catch {
return null;
}
}
NbtTree LoadLevelTree(string path)
{
NBTFile nf = new NBTFile(path);
NbtTree tree = null;
using (Stream nbtstr = nf.GetDataInputStream())
{
if (nbtstr == null)
{
return null;
}
tree = new NbtTree(nbtstr);
}
return tree;
}
static void Main(string[] args)
{
if (!File.Exists("level.dat")) {
Console.WriteLine("Could not find level.dat");
return;
}
NBTFile nf = new NBTFile("level.dat");
NbtTree tree;
using (Stream nbtstr = nf.GetDataInputStream()) {
if (nbtstr == null) {
Console.WriteLine("Could not open level.dat");
return;
}
tree = new NbtTree(nbtstr);
}
TagNodeList list = tree.Root["FML"].ToTagCompound()["ItemData"].ToTagList();
foreach (TagNodeCompound tag in list) {
TagNodeString modid = tag["K"].ToTagString();
if (modid.Data.Contains("modularpots:modularpots:")) {
modid.Data = modid.Data.Replace("modularpots:modularpots:", "modularpots:");
Console.WriteLine("Updating entry " + tag["V"].ToTagInt().Data + ": " + modid.Data);
}
}
using (Stream zipstr = nf.GetDataOutputStream()) {
if (zipstr == null) {
Console.WriteLine("Could not write back to level.dat");
return;
}
tree.WriteTo(zipstr);
}
Console.WriteLine("Update complete");
}
public NBTBuffer(NBTFile c)
: base(8096)
{
this.file = c;
}
private bool LoadLevel ()
{
NBTFile nf = new NBTFile(IO.Path.Combine(Path, _levelFile));
NbtTree tree;
using (Stream nbtstr = nf.GetDataInputStream())
{
if (nbtstr == null)
{
return false;
}
tree = new NbtTree(nbtstr);
}
_level = new Level(this);
_level = _level.LoadTreeSafe(tree.Root);
return _level != null;
}
protected override void SaveCore()
{
NBTFile file = new NBTFile(_path);
using (Stream str = file.GetDataOutputStream(_compressionType)) {
_tree.WriteTo(str);
}
}
//private TagNodeCompound _metaRoot;
protected override void ExpandCore()
{
if (_tree == null) {
NBTFile file = new NBTFile(_path);
_tree = new NbtTree();
_tree.ReadFrom(file.GetDataInputStream(_compressionType));
//_metaRoot = new TagNodeCompound();
if (_tree.Root != null) {
//_metaRoot.Add(_tree.Name, _tree.Root);
_container = new CompoundTagContainer(_tree.Root);
}
}
/*foreach (TagNode tag in _metaRoot.Values) {
TagDataNode node = TagDataNode.CreateFromTag(tag);
if (node != null)
Nodes.Add(node);
}*/
foreach (TagNode tag in _tree.Root.Values) {
TagDataNode node = TagDataNode.CreateFromTag(tag);
if (node != null)
Nodes.Add(node);
}
}
protected override void ExpandCore()
{
if (_tree == null) {
NBTFile file = new NBTFile(_path);
_tree = new NbtTree();
_tree.ReadFrom(file.GetDataInputStream(_compressionType));
if (_tree.Root != null) {
_container = new CompoundTagContainer(_tree.Root);
}
}
var list = new SortedList<TagKey, TagNode>();
foreach (var item in _tree.Root) {
list.Add(new TagKey(item.Key, item.Value.GetTagType()), item.Value);
}
foreach (TagNode tag in list.Values) {
TagDataNode node = TagDataNode.CreateFromTag(tag);
if (node != null)
Nodes.Add(node);
}
}
internal static void TryLoadFile(TreeNodeCollection parent, string path)
{
string ext = Path.GetExtension(path);
if (ext == ".mcr" || ext == ".mca")
{
TreeNode node = ServerNode.CreateLazyRegion(path);
parent.Add(node);
LinkDataNodeParent(node, node.Parent);
return;
}
if (ext == ".dat" || ext == ".nbt" || ext == ".schematic")
{
try
{
NBTFile file = new NBTFile(path);
NbtTree tree = new NbtTree();
tree.ReadFrom(file.GetDataInputStream());
TreeNode node = ServerNode.CreateLazyNbt(path, CompressionType.GZip);
parent.Add(node);
LinkDataNodeParent(node, node.Parent);
return;
}
catch { }
try
{
NBTFile file = new NBTFile(path);
NbtTree tree = new NbtTree();
tree.ReadFrom(file.GetDataInputStream(CompressionType.None));
TreeNode node = ServerNode.CreateLazyNbt(path, CompressionType.None);
parent.Add(node);
LinkDataNodeParent(node, node.Parent);
return;
}
catch { }
}
}
internal static void LoadLazyNbt(TreeNode node, int descriptionImageIndex)
{
NbtFileData data = node.Tag as NbtFileData;
if (data == null || data.Modified)
return;
node.Nodes.Clear();
NBTFile file = new NBTFile(data.Path);
LoadNbtStream(node, descriptionImageIndex, file.GetDataInputStream(data.CompressionType));
data.Expanded = true;
}
public NBTBuffer(NBTFile c)
: base(8096)
{
this.file = c;
}
/// <summary>
/// Exports the <see cref="Schematic"/> object to a schematic file.
/// </summary>
/// <param name="path">The path to write out the schematic file to.</param>
public void Export(string path)
{
int xdim = _blockset.XDim;
int ydim = _blockset.YDim;
int zdim = _blockset.ZDim;
byte[] blockData = new byte[xdim * ydim * zdim];
byte[] dataData = new byte[xdim * ydim * zdim];
YZXByteArray schemaBlocks = new YZXByteArray(_blockset.XDim, _blockset.YDim, _blockset.ZDim, blockData);
YZXByteArray schemaData = new YZXByteArray(_blockset.XDim, _blockset.YDim, _blockset.ZDim, dataData);
TagNodeList entities = new TagNodeList(TagType.TAG_COMPOUND);
TagNodeList tileEntities = new TagNodeList(TagType.TAG_COMPOUND);
for (int x = 0; x < xdim; x++) {
for (int z = 0; z < zdim; z++) {
for (int y = 0; y < ydim; y++) {
AlphaBlock block = _blockset.GetBlock(x, y, z);
schemaBlocks[x, y, z] = (byte)block.ID;
schemaData[x, y, z] = (byte)block.Data;
TileEntity te = block.GetTileEntity();
if (te != null) {
te.X = x;
te.Y = y;
te.Z = z;
tileEntities.Add(te.BuildTree());
}
}
}
}
foreach (TypedEntity e in _entityset) {
entities.Add(e.BuildTree());
}
TagNodeCompound schematic = new TagNodeCompound();
schematic["Width"] = new TagNodeShort((short)xdim);
schematic["Length"] = new TagNodeShort((short)zdim);
schematic["Height"] = new TagNodeShort((short)ydim);
schematic["Entities"] = entities;
schematic["TileEntities"] = tileEntities;
schematic["Materials"] = new TagNodeString("Alpha");
schematic["Blocks"] = new TagNodeByteArray(blockData);
schematic["Data"] = new TagNodeByteArray(dataData);
NBTFile schematicFile = new NBTFile(path);
Stream nbtStream = schematicFile.GetDataOutputStream();
if (nbtStream == null) {
return;
}
NbtTree tree = new NbtTree(schematic, "Schematic");
tree.WriteTo(nbtStream);
nbtStream.Close();
}
/// <summary>
/// Imports a schematic file at the given path and returns in as a <see cref="Schematic"/> object.
/// </summary>
/// <param name="path">The path to the schematic file.</param>
/// <returns>A <see cref="Schematic"/> object containing the decoded schematic file data.</returns>
public static Schematic Import(string path)
{
NBTFile schematicFile = new NBTFile(path);
if (!schematicFile.Exists()) {
return null;
}
Stream nbtStream = schematicFile.GetDataInputStream();
if (nbtStream == null) {
return null;
}
NbtTree tree = new NbtTree(nbtStream);
NbtVerifier v = new NbtVerifier(tree.Root, _schema);
if (!v.Verify()) {
return null;
}
//TagNodeCompound schematic = tree.Root["Schematic"] as TagNodeCompound;
TagNodeCompound schematic = tree.Root;
int xdim = schematic["Width"].ToTagShort();
int zdim = schematic["Length"].ToTagShort();
int ydim = schematic["Height"].ToTagShort();
Schematic self = new Schematic(xdim, ydim, zdim);
// Damnit, schematic is YZX ordering.
YZXByteArray schemaBlocks = new YZXByteArray(xdim, ydim, zdim, schematic["Blocks"].ToTagByteArray());
YZXByteArray schemaData = new YZXByteArray(xdim, ydim, zdim, schematic["Data"].ToTagByteArray());
for (int x = 0; x < xdim; x++) {
for (int y = 0; y < ydim; y++) {
for (int z = 0; z < zdim; z++) {
self._blocks[x, y, z] = schemaBlocks[x, y, z];
self._data[x, y, z] = schemaData[x, y, z];
}
}
}
TagNodeList entities = schematic["Entities"] as TagNodeList;
foreach (TagNode e in entities) {
self._entities.Add(e);
}
TagNodeList tileEntities = schematic["TileEntities"] as TagNodeList;
foreach (TagNode te in tileEntities) {
self._tileEntities.Add(te);
}
self._blockset.Refresh();
return self;
}
static void SaveNbtFileNode(TreeNode node)
{
NbtFileData data = node.Tag as NbtFileData;
if (data == null || !data.Modified)
return;
NBTFile file = new NBTFile(data.Path);
using (Stream str = file.GetDataOutputStream(data.CompressionType))
{
data.Tree.WriteTo(str);
}
data.Modified = false;
}