public override TagNode BuildTree ()
        {
            TagNodeCompound tree = base.BuildTree() as TagNodeCompound;
            tree["Command"] = new TagNodeString(_command);

            return tree;
        }
Esempio n. 2
0
        private bool VerifyString(TagNode tag, SchemaNodeString schema)
        {
            TagNodeString stag = tag as TagNodeString;

            if (stag == null)
            {
                if (!OnInvalidTagType(new TagEventArgs(schema, tag)))
                {
                    return(false);
                }
            }
            if (schema.Length > 0 && stag.Length > schema.Length)
            {
                if (!OnInvalidTagValue(new TagEventArgs(schema, tag)))
                {
                    return(false);
                }
            }
            if (schema.Value != null && stag.Data != schema.Value)
            {
                if (!OnInvalidTagValue(new TagEventArgs(schema, tag)))
                {
                    return(false);
                }
            }

            return(true);
        }
Esempio n. 3
0
        private TagNode ReadString()
        {
            byte[] lenBytes = new byte[2];
            _stream.Read(lenBytes, 0, 2);

            if (BitConverter.IsLittleEndian)
            {
                Array.Reverse(lenBytes);
            }

            short len = BitConverter.ToInt16(lenBytes, 0);

            if (len < 0)
            {
                throw new NBTException(NBTException.MSG_READ_NEG);
            }

            byte[] strBytes = new byte[len];
            _stream.Read(strBytes, 0, len);

            System.Text.Encoding str = Encoding.GetEncoding(28591);

            TagNodeString val = new TagNodeString(str.GetString(strBytes));

            return(val);
        }
Esempio n. 4
0
        public override bool Verify(NbtVerifier verifier, TagNode tag)
        {
            TagNodeString stag = tag as TagNodeString;

            if (stag == null)
            {
                if (!verifier.OnInvalidTagType(new TagEventArgs(this, tag)))
                {
                    return(false);
                }
            }
            if (Length > 0 && stag.Length > Length)
            {
                if (!verifier.OnInvalidTagValue(new TagEventArgs(this, tag)))
                {
                    return(false);
                }
            }
            if (Value != null && stag.Data != Value)
            {
                if (!verifier.OnInvalidTagValue(new TagEventArgs(this, tag)))
                {
                    return(false);
                }
            }

            return(true);
        }
Esempio n. 5
0
        private TagNode ReadString()
        {
            var lenBytes = new byte[2];

            _stream.Read(lenBytes, 0, 2);

            if (BitConverter.IsLittleEndian)
            {
                Array.Reverse(lenBytes);
            }

            var len = BitConverter.ToInt16(lenBytes, 0);

            if (len < 0)
            {
                throw new NBTException(NBTException.MSG_READ_NEG);
            }

            var strBytes = new byte[len];

            _stream.Read(strBytes, 0, len);

            var str = Encoding.UTF8;

            var val = new TagNodeString(str.GetString(strBytes));

            return(val);
        }
        public override TagNode BuildTree()
        {
            TagNodeCompound tree = base.BuildTree() as TagNodeCompound;
            tree["EntityId"] = new TagNodeString(_entityID);
            tree["Delay"] = new TagNodeShort(_delay);

            return tree;
        }
Esempio n. 7
0
        public override TagNode BuildTree()
        {
            TagNodeCompound tree = base.BuildTree() as TagNodeCompound;
            tree["Owner"] = new TagNodeString(_owner);
            tree["Sitting"] = new TagNodeByte((byte)(_sitting ? 1 : 0));
            tree["Angry"] = new TagNodeByte((byte)(_angry ? 1 : 0));

            return tree;
        }
Esempio n. 8
0
        public override TagNode BuildTree()
        {
            TagNodeCompound tree = base.BuildTree() as TagNodeCompound;
            tree["Text1"] = new TagNodeString(_text1);
            tree["Text2"] = new TagNodeString(_text2);
            tree["Text3"] = new TagNodeString(_text3);
            tree["Text4"] = new TagNodeString(_text4);

            return tree;
        }
Esempio n. 9
0
        private void WriteString(TagNodeString val)
        {
            byte[] lenBytes = BitConverter.GetBytes((short)val.Length);

            if (BitConverter.IsLittleEndian)
            {
                Array.Reverse(lenBytes);
            }

            _stream.Write(lenBytes, 0, 2);

            System.Text.Encoding str = Encoding.GetEncoding(28591);
            byte[] gzBytes           = str.GetBytes(val.Data);

            _stream.Write(gzBytes, 0, gzBytes.Length);
        }
Esempio n. 10
0
        private void WriteString(TagNodeString val)
        {
            var str     = Encoding.UTF8;
            var gzBytes = str.GetBytes(val.Data);

            var lenBytes = BitConverter.GetBytes((short)gzBytes.Length);

            if (BitConverter.IsLittleEndian)
            {
                Array.Reverse(lenBytes);
            }

            _stream.Write(lenBytes, 0, 2);

            _stream.Write(gzBytes, 0, gzBytes.Length);
        }
        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;
            }
        }
Esempio n. 12
0
 public TagStringDataNode(TagNodeString tag)
     : base(tag)
 {
 }
        public override TagNode BuildTree ()
        {
            TagNodeCompound tree = base.BuildTree() as TagNodeCompound;
            tree["Dir"] = new TagNodeByte((byte)_dir);
            tree["Motive"] = new TagNodeString(_motive);
            tree["TileX"] = new TagNodeInt(_xTile);
            tree["TileY"] = new TagNodeInt(_yTile);
            tree["TileZ"] = new TagNodeInt(_zTile);

            return tree;
        }
Esempio n. 14
0
        public override TagNode BuildTree()
        {
            TagNodeCompound tree = base.BuildTree() as TagNodeCompound;
            tree["EntityId"] = new TagNodeString(_entityID);
            tree["Delay"] = new TagNodeShort(_delay);

            if (_maxDelay != null)
                tree["MaxSpawnDelay"] = new TagNodeShort(_maxDelay ?? 0);
            if (_minDelay != null)
                tree["MinSpawnDelay"] = new TagNodeShort(_minDelay ?? 0);
            if (_spawnCount != null)
                tree["SpawnCount"] = new TagNodeShort(_spawnCount ?? 0);
            if (_spawnRange != null)
                tree["SpawnRange"] = new TagNodeShort(_spawnRange ?? 0);
            if (_maxNearbyEnemies != null)
                tree["MaxNearbyEnemies"] = new TagNodeShort(_maxNearbyEnemies ?? 0);
            if (_requiredPlayerRange != null)
                tree["RequiredPlayerRange"] = new TagNodeShort(_requiredPlayerRange ?? 0);
            if (_maxExperience != null)
                tree["MaxExperience"] = new TagNodeInt(_maxExperience ?? 0);
            if (_remainingExperience != null)
                tree["RemainingExperience"] = new TagNodeInt(_remainingExperience ?? 0);
            if (_experienceRegenTick != null)
                tree["ExperienceRegenTick"] = new TagNodeInt(_experienceRegenTick ?? 0);
            if (_experienceRegenRate != null)
                tree["ExperienceRegenRate"] = new TagNodeInt(_experienceRegenRate ?? 0);
            if (_experienceRegenAmount != null)
                tree["ExperienceRegenAmount"] = new TagNodeInt(_experienceRegenAmount ?? 0);

            if (_spawnData != null && _spawnData.Count > 0)
                tree["SpawnData"] = _spawnData;

            return tree;
        }
Esempio n. 15
0
 public override TagNode BuildTree()
 {
     TagNodeCompound tree = base.BuildTree() as TagNodeCompound;
     tree["EntityId"] = new TagNodeString(_entityID);
     tree["Delay"] = new TagNodeShort(_delay);
     tree["MaxSpawnDelay"] = new TagNodeShort(_maxDelay);
     tree["MinSpawnDelay"] = new TagNodeShort(_minDelay);
     tree["SpawnCount"] = new TagNodeShort(_spawnCount);
     tree["SpawnData"] = _spawnData.BuildTree();
     return tree;
 }
Esempio n. 16
0
        /// <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();
        }