private static void SerializeByteArray(TagNodeByteArray tag, StringBuilder str, int level)
{
if (tag.Length == 0)
{
str.Append("[ ]");
return;
}
str.Append("[ ");
bool first = true;
for (int i = 0; i < tag.Length; i++)
{
if (!first)
{
str.Append(", ");
}
str.Append(tag.Data[i]);
first = false;
}
str.Append(" ]");
}
private TagNode ReadByteArray()
{
var lenBytes = new byte[4];
_stream.Read(lenBytes, 0, 4);
if (BitConverter.IsLittleEndian)
{
Array.Reverse(lenBytes);
}
var length = BitConverter.ToInt32(lenBytes, 0);
if (length < 0)
{
throw new NBTException(NBTException.MSG_READ_NEG);
}
var data = new byte[length];
_stream.Read(data, 0, length);
var val = new TagNodeByteArray(data);
return(val);
}
private void WriteByteArray(TagNodeByteArray val)
{
byte[] lenBytes = BitConverter.GetBytes(val.Length);
if (BitConverter.IsLittleEndian)
{
Array.Reverse(lenBytes);
}
_stream.Write(lenBytes, 0, 4);
_stream.Write(val.Data, 0, val.Length);
}
private bool VerifyArray(TagNode tag, SchemaNodeArray schema)
{
TagNodeByteArray atag = tag as TagNodeByteArray;
if (atag == null)
{
if (!OnInvalidTagType(new TagEventArgs(schema, tag)))
{
return(false);
}
}
if (schema.Length > 0 && atag.Length != schema.Length)
{
if (!OnInvalidTagValue(new TagEventArgs(schema, tag)))
{
return(false);
}
}
return(true);
}
private static void SerializeByteArray(TagNodeByteArray tag, StringBuilder str, int level)
{
if (tag.Length == 0) {
str.Append("[ ]");
return;
}
str.Append("[ ");
bool first = true;
for (int i = 0; i < tag.Length; i++) {
if (!first) {
str.Append(", ");
}
str.Append(tag.Data[i]);
first = false;
}
str.Append(" ]");
}
public override bool Verify(NbtVerifier verifier, TagNode tag)
{
TagNodeByteArray atag = tag as TagNodeByteArray;
if (atag == null)
{
if (!verifier.OnInvalidTagType(new TagEventArgs(this, tag)))
{
return(false);
}
}
if (Length > 0 && atag.Length != Length)
{
if (!verifier.OnInvalidTagValue(new TagEventArgs(this, tag)))
{
return(false);
}
}
return(true);
}
public TagByteArrayDataNode (TagNodeByteArray tag)
: base(tag)
{ }
internal static void AddTagToNode(TreeNode node, int descriptionIndex, TagType type)
{
TagNode tag = GetTagNode(node);
if (tag == null)
return;
if (tag.GetTagType() != TagType.TAG_COMPOUND &&
tag.GetTagType() != TagType.TAG_LIST)
return;
if (tag.GetTagType() == TagType.TAG_LIST &&
tag.ToTagList().ValueType != type &&
tag.ToTagList().Count > 0)
return;
TagNode newNode = null;
switch (type)
{
case TagType.TAG_BYTE:
newNode = new TagNodeByte();
break;
case TagType.TAG_SHORT:
newNode = new TagNodeShort();
break;
case TagType.TAG_INT:
newNode = new TagNodeInt();
break;
case TagType.TAG_LONG:
newNode = new TagNodeLong();
break;
case TagType.TAG_FLOAT:
newNode = new TagNodeFloat();
break;
case TagType.TAG_DOUBLE:
newNode = new TagNodeDouble();
break;
case TagType.TAG_BYTE_ARRAY:
newNode = new TagNodeByteArray();
break;
case TagType.TAG_STRING:
newNode = new TagNodeString();
break;
case TagType.TAG_LIST:
newNode = new TagNodeList(TagType.TAG_BYTE);
break;
case TagType.TAG_COMPOUND:
newNode = new TagNodeCompound();
break;
case TagType.TAG_INT_ARRAY:
newNode = new TagNodeIntArray();
break;
}
if (tag is TagNodeCompound)
{
TagNodeCompound ctag = tag as TagNodeCompound;
EditValue form = new EditValue("");
foreach (string key in ctag.Keys)
{
form.InvalidNames.Add(key);
}
if (form.ShowDialog() != DialogResult.OK)
return;
ctag.Add(form.NodeName, newNode);
TreeNode tnode = NodeFromTag(newNode, descriptionIndex, form.NodeName);
node.Nodes.Add(tnode);
tnode.TreeView.SelectedNode = tnode;
tnode.Expand();
}
else if (tag is TagNodeList)
{
var ltag = tag as TagNodeList;
if (ltag.ValueType != type)
ltag.ChangeValueType(type);
ltag.Add(newNode);
TreeNode tnode = NodeFromTag(newNode, descriptionIndex);
node.Nodes.Add(tnode);
tnode.TreeView.SelectedNode = tnode;
tnode.Expand();
}
node.Text = GetNodeText(node);
TreeNode baseNode = BaseNode(node);
if (baseNode != null)
{
(baseNode.Tag as DataNode).Modified = true;
}
}
/// <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();
}
