/// <summary> /// Attempt to load an Entity subtree into the <see cref="Entity"/> without validation. /// </summary> /// <param name="tree">The root node of an Entity subtree.</param> /// <returns>The <see cref="Entity"/> returns itself on success, or null if the tree was unparsable.</returns> public Entity LoadTree(TagNode tree) { TagNodeCompound ctree = tree as TagNodeCompound; if (ctree == null) { return(null); } TagNodeList pos = ctree["Pos"].ToTagList(); _pos = new Vector3(); _pos.X = pos[0].ToTagDouble(); _pos.Y = pos[1].ToTagDouble(); _pos.Z = pos[2].ToTagDouble(); TagNodeList motion = ctree["Motion"].ToTagList(); _motion = new Vector3(); _motion.X = motion[0].ToTagDouble(); _motion.Y = motion[1].ToTagDouble(); _motion.Z = motion[2].ToTagDouble(); TagNodeList rotation = ctree["Rotation"].ToTagList(); _rotation = new Orientation(); _rotation.Yaw = rotation[0].ToTagFloat(); _rotation.Pitch = rotation[1].ToTagFloat(); _fire = ctree["Fire"].ToTagShort(); _air = ctree["Air"].ToTagShort(); _onGround = ctree["OnGround"].ToTagByte(); return(this); }
public void SetTileTick(int x, int y, int z, TileTick te) { if (te.ID != _blocks[x, y, z]) { throw new ArgumentException("The TileTick type is not valid for this block.", "te"); } BlockKey key = (TranslateCoordinates != null) ? TranslateCoordinates(x, y, z) : new BlockKey(x, y, z); TagNodeCompound oldte; if (_tileTickTable.TryGetValue(key, out oldte)) { _tileTicks.Remove(oldte); } te.X = key.x; te.Y = key.y; te.Z = key.z; TagNodeCompound tree = te.BuildTree() as TagNodeCompound; _tileTicks.Add(tree); _tileTickTable[key] = tree; }
public void CreateTileTick(int x, int y, int z) { TileTick te = new TileTick() { ID = _blocks[x, y, z], }; BlockKey key = (TranslateCoordinates != null) ? TranslateCoordinates(x, y, z) : new BlockKey(x, y, z); TagNodeCompound oldte; if (_tileTickTable.TryGetValue(key, out oldte)) { _tileTicks.Remove(oldte); } te.X = key.x; te.Y = key.y; te.Z = key.z; TagNodeCompound tree = te.BuildTree() as TagNodeCompound; _tileTicks.Add(tree); _tileTickTable[key] = tree; }
private static Block[] LoadBlocks(TagNodeCompound tag, TranslationMap palette, int length, int width, Dictionary <BlockPos, TileEntity> tiles) { var bLower = tag["Blocks"].ToTagByteArray().Data; var bUpper = new byte[(bLower.Length >> 1) + 1]; if (tag.ContainsKey("AddBlocks")) { bUpper = tag["AddBlocks"].ToTagByteArray().Data; } else if (tag.ContainsKey("Add")) { Console.WriteLine("Schematic contains deprecated tag \"Add\", use \"AddBlocks\" instead. Loading regardless."); var add = tag["Add"].ToTagByteArray().Data; for (var i = 0; i < bLower.Length; i++) { if ((i & 1) == 1) { bUpper[i >> 1] |= (byte)(add[i] & 0x0F); } else { bUpper[i >> 1] |= (byte)((add[i] & 0x0F) << 4); } } } var bMetadata = new byte[bLower.Length]; if (tag.ContainsKey("Metadata")) { bMetadata = tag["Metadata"].ToTagByteArray().Data; } else if (tag.ContainsKey("Data")) { bMetadata = tag["Data"].ToTagByteArray().Data; } var blocks = new Block[bLower.Length]; for (var i = 0; i < bLower.Length; i++) { short id; if ((i & 1) == 1) { id = (short)(((bUpper[i >> 1] & 0x0F) << 8) + (bLower[i] & 0xFF)); } else { id = (short)(((bUpper[i >> 1] & 0xF0) << 4) + (bLower[i] & 0xFF)); } var pos = GetBlockPos(length, width, i); var metadata = bMetadata[i]; tiles.TryGetValue(pos, out var tile); blocks[i] = new Block(TranslateBlockId(palette, id), metadata, tile?.Data); } return(blocks); }
public TileEntityMobSpawner(TileEntity te) : base(te) { TileEntityMobSpawner tes = te as TileEntityMobSpawner; if (tes != null) { _delay = tes._delay; _entityID = tes._entityID; _maxDelay = tes._maxDelay; _minDelay = tes._minDelay; _spawnCount = tes._spawnCount; _spawnRange = tes._spawnRange; _maxNearbyEnemies = tes._maxNearbyEnemies; _requiredPlayerRange = tes._requiredPlayerRange; _maxExperience = tes._maxExperience; _remainingExperience = tes._remainingExperience; _experienceRegenTick = tes._experienceRegenTick; _experienceRegenRate = tes._experienceRegenRate; _experienceRegenAmount = tes._experienceRegenAmount; if (tes._spawnData != null) { _spawnData = tes._spawnData.Copy() as TagNodeCompound; } } }
public static void Init() { TagNodeCompound player = NBTHelper.GetPlayerData(); int gameMode = player["playerGameType"] as TagNodeInt; _mode = (GameMode)gameMode; }
/// <summary> /// Builds an Entity subtree from the current data. /// </summary> /// <returns>The root node of an Entity subtree representing the current data.</returns> public TagNode BuildTree() { TagNodeCompound tree = new TagNodeCompound(); TagNodeList pos = new TagNodeList(TagType.TAG_DOUBLE); pos.Add(new TagNodeDouble(_pos.X)); pos.Add(new TagNodeDouble(_pos.Y)); pos.Add(new TagNodeDouble(_pos.Z)); tree["Pos"] = pos; TagNodeList motion = new TagNodeList(TagType.TAG_DOUBLE); motion.Add(new TagNodeDouble(_motion.X)); motion.Add(new TagNodeDouble(_motion.Y)); motion.Add(new TagNodeDouble(_motion.Z)); tree["Motion"] = motion; TagNodeList rotation = new TagNodeList(TagType.TAG_FLOAT); rotation.Add(new TagNodeFloat((float)_rotation.Yaw)); rotation.Add(new TagNodeFloat((float)_rotation.Pitch)); tree["Rotation"] = rotation; tree["FallDistance"] = new TagNodeFloat(_fallDistance); tree["Fire"] = new TagNodeShort(_fire); tree["Air"] = new TagNodeShort(_air); tree["OnGround"] = new TagNodeByte(_onGround); return(tree); }
/// <summary> /// Removes all entities matching the given condition from the collection. /// </summary> /// <param name="match">A <see cref="Predicate{T}"/> defining the matching condition.</param> /// <returns>A count of the number of entities that were removed.</returns> public int RemoveAll(Predicate <TypedEntity> match) { int rem = _entities.RemoveAll(val => { TagNodeCompound cval = val as TagNodeCompound; if (cval == null) { return(false); } TypedEntity obj = EntityFactory.Create(cval); if (obj == null) { return(false); } return(match(obj)); }); if (rem > 0) { _dirty = true; } return(rem); }
public static BlockState Load(TagNodeCompound tag) { var name = tag["Name"].ToTagString().Data; var props = tag.ContainsKey("Properties") ? tag["Properties"].ToTagCompound() : null; return(new BlockState(name, props)); }
public override TypedEntity LoadTree(TagNode tree) { TagNodeCompound ctree = tree as TagNodeCompound; if (ctree == null || base.LoadTree(tree) == null) { return(null); } _type = (CartType)ctree["Type"].ToTagInt().Data; switch (_type) { case CartType.EMPTY: return(this); case CartType.CHEST: return(new EntityMinecartChest().LoadTreeSafe(tree)); case CartType.FURNACE: return(new EntityMinecartFurnace().LoadTreeSafe(tree)); default: return(this); } }
/// <summary> /// Creates a new <see cref="Level"/> object with reasonable defaults tied to the given world. /// </summary> /// <param name="world">The world that the <see cref="Level"/> should be tied to.</param> public Level(NbtWorld world) { _world = world; // Sane defaults _time = 0; _lastPlayed = 0; _spawnX = 0; _spawnY = 64; _spawnZ = 0; _sizeOnDisk = 0; _randomSeed = new Random().Next(); //_version = 19132; _version = 19133; _name = "Untitled"; _generator = "default"; _hardcore = 0; _generatorOptions = ""; _generatorVersion = 1; _initialized = 0; _allowCommands = 0; _DayTime = 0; _gameRules = new GameRules(); GameType = GameType.SURVIVAL; UseMapFeatures = true; _source = new TagNodeCompound(); }
//input is local position public void GetBlockData(int xInChunk, int worldY, int zInChunk, out byte blockType, out byte blockData) { blockType = 0; blockData = 0; if (worldY < 0 || worldY > 255) { return; } if (xInChunk < 0 || xInChunk > 15 || zInChunk < 0 || zInChunk > 15) { NBTHelper.GetBlockData(xInChunk + 16 * x, worldY, zInChunk + 16 * z, out blockType, out blockData); return; } int sectionIndex = Mathf.FloorToInt(worldY / 16f); if (sectionIndex >= 0 && sectionIndex < Sections.Count) { TagNodeCompound section = Sections[sectionIndex] as TagNodeCompound; TagNodeByteArray blocks = section["Blocks"] as TagNodeByteArray; TagNodeByteArray data = section["Data"] as TagNodeByteArray; int yInSection = worldY - sectionIndex * 16; int blockPos = yInSection * 16 * 16 + zInChunk * 16 + xInChunk; if (blockPos >= 0 && blockPos < 4096) { blockType = blocks.Data[blockPos]; blockData = NBTHelper.GetNibble(data.Data, blockPos); return; } } return; }
void InitTileEntity() { if (hasInitTileEntity) { return; } foreach (Vector3Int pos in tileEntityList) { if (!tileEntityObjs.ContainsKey(pos)) { int sectionIndex = pos.y / 16; TagNodeCompound Section = Sections[sectionIndex] as TagNodeCompound; TagNodeByteArray Blocks = Section["Blocks"] as TagNodeByteArray; TagNodeByteArray Data = Section["Data"] as TagNodeByteArray; int yInSection = pos.y % 16; int blockPos = yInSection * 16 * 16 + pos.z * 16 + pos.x; byte rawType = Blocks.Data[blockPos]; NBTBlock generator = NBTGeneratorManager.GetMeshGenerator(rawType); byte blockData = NBTHelper.GetNibble(Data.Data, blockPos); GameObject obj = generator.GetTileEntityGameObject(this, blockData, pos); tileEntityObjs[pos] = obj; } } hasInitTileEntity = true; }
/// <inheritdoc/> public Item LoadTree(TagNode tree) { TagNodeCompound ctree = tree as TagNodeCompound; if (ctree == null) { return(null); } _enchantments.Clear(); _id = ctree["id"].ToTagString(); _count = ctree["Count"].ToTagByte(); _damage = ctree["Damage"].ToTagShort(); if (ctree.ContainsKey("tag")) { TagNodeCompound tagtree = ctree["tag"].ToTagCompound(); if (tagtree.ContainsKey("ench")) { TagNodeList enchList = tagtree["ench"].ToTagList(); foreach (TagNode tag in enchList) { _enchantments.Add(new Enchantment().LoadTree(tag)); } } } _source = ctree.Copy() as TagNodeCompound; return(this); }
/// <summary> /// Builds a Level subtree from the current data. /// </summary> /// <returns>The root node of a Level subtree representing the current data.</returns> public virtual TagNode BuildTree() { TagNodeCompound data = new TagNodeCompound(); data["Time"] = new TagNodeLong(_time); data["LastPlayed"] = new TagNodeLong(_lastPlayed); if (_player != null) { data["Player"] = _player.BuildTree(); } data["SpawnX"] = new TagNodeInt(_spawnX); data["SpawnY"] = new TagNodeInt(_spawnY); data["SpawnZ"] = new TagNodeInt(_spawnZ); data["SizeOnDisk"] = new TagNodeLong(_sizeOnDisk); data["RandomSeed"] = new TagNodeLong(_randomSeed); if (_version != null && _version != 0) { data["version"] = new TagNodeInt(_version ?? 0); } if (_name != null) { data["LevelName"] = new TagNodeString(_name); } if (_raining != null) { data["raining"] = new TagNodeByte(_raining ?? 0); } if (_thundering != null) { data["thundering"] = new TagNodeByte(_thundering ?? 0); } if (_rainTime != null) { data["rainTime"] = new TagNodeInt(_rainTime ?? 0); } if (_thunderTime != null) { data["thunderTime"] = new TagNodeInt(_thunderTime ?? 0); } if (_gameType != null) { data["GameType"] = new TagNodeInt(_gameType ?? 0); } if (_mapFeatures != null) { data["MapFeatures"] = new TagNodeByte(_mapFeatures ?? 0); } TagNodeCompound tree = new TagNodeCompound(); tree.Add("Data", data); return(tree); }
private void BuildNbtTree() { int elements3 = XDIM * YDIM * ZDIM; TagNodeByteArray blocks = new TagNodeByteArray(new byte[elements3]); TagNodeByteArray data = new TagNodeByteArray(new byte[elements3 >> 1]); TagNodeByteArray skyLight = new TagNodeByteArray(new byte[elements3 >> 1]); TagNodeByteArray blockLight = new TagNodeByteArray(new byte[elements3 >> 1]); TagNodeByteArray addBlocks = new TagNodeByteArray(new byte[elements3 >> 1]); _blocks = new YZXByteArray(XDIM, YDIM, ZDIM, blocks); _data = new YZXNibbleArray(XDIM, YDIM, ZDIM, data); _skyLight = new YZXNibbleArray(XDIM, YDIM, ZDIM, skyLight); _blockLight = new YZXNibbleArray(XDIM, YDIM, ZDIM, blockLight); _addBlocks = new YZXNibbleArray(XDIM, YDIM, ZDIM, addBlocks); TagNodeCompound tree = new TagNodeCompound(); tree.Add("Y", new TagNodeByte(_y)); tree.Add("Blocks", blocks); tree.Add("Data", data); tree.Add("SkyLight", skyLight); tree.Add("BlockLight", blockLight); tree.Add("AddBlocks", addBlocks); _tree = tree; }
/// <inheritdoc/> public TagNode BuildTree() { TagNodeCompound tree = new TagNodeCompound(); tree["id"] = new TagNodeString(_id); tree["Count"] = new TagNodeByte(_count); tree["Damage"] = new TagNodeShort(_damage); if (_enchantments.Count > 0) { TagNodeList enchList = new TagNodeList(TagType.TAG_COMPOUND); foreach (Enchantment e in _enchantments) { enchList.Add(e.BuildTree()); } TagNodeCompound tagtree = new TagNodeCompound(); tagtree["ench"] = enchList; if (_source != null && _source.ContainsKey("tag")) { tagtree.MergeFrom(_source["tag"].ToTagCompound()); } tree["tag"] = tagtree; } if (_source != null) { tree.MergeFrom(_source); } return(tree); }
/// <summary> /// Attempt to load a Level subtree into the <see cref="Level"/> without validation. /// </summary> /// <param name="tree">The root node of a Level subtree.</param> /// <returns>The <see cref="Level"/> returns itself on success, or null if the tree was unparsable.</returns> public virtual Level LoadTree(TagNode tree) { TagNodeCompound dtree = tree as TagNodeCompound; if (dtree == null) { return(null); } _version = null; _raining = null; _rainTime = null; _thundering = null; _thunderTime = null; TagNodeCompound ctree = dtree["Data"].ToTagCompound(); _time = ctree["Time"].ToTagLong(); _lastPlayed = ctree["LastPlayed"].ToTagLong(); if (ctree.ContainsKey("Player")) { _player = new Player().LoadTree(ctree["Player"]); } _spawnX = ctree["SpawnX"].ToTagInt(); _spawnY = ctree["SpawnY"].ToTagInt(); _spawnZ = ctree["SpawnZ"].ToTagInt(); _sizeOnDisk = ctree["SizeOnDisk"].ToTagLong(); _randomSeed = ctree["RandomSeed"].ToTagLong(); if (ctree.ContainsKey("version")) { _version = ctree["version"].ToTagInt(); } if (ctree.ContainsKey("LevelName")) { _name = ctree["LevelName"].ToTagString(); } if (ctree.ContainsKey("raining")) { _raining = ctree["raining"].ToTagByte(); } if (ctree.ContainsKey("thundering")) { _thundering = ctree["thundering"].ToTagByte(); } if (ctree.ContainsKey("rainTime")) { _rainTime = ctree["rainTime"].ToTagInt(); } if (ctree.ContainsKey("thunderTime")) { _thunderTime = ctree["thunderTime"].ToTagInt(); } return(this); }
public AnvilSection LoadTree(TagNode tree) { TagNodeCompound ctree = tree as TagNodeCompound; if (ctree == null) { return(null); } _y = ctree["Y"] as TagNodeByte; _blocks = new YZXByteArray(XDIM, YDIM, ZDIM, ctree["Blocks"] as TagNodeByteArray); _data = new YZXNibbleArray(XDIM, YDIM, ZDIM, ctree["Data"] as TagNodeByteArray); _skyLight = new YZXNibbleArray(XDIM, YDIM, ZDIM, ctree["SkyLight"] as TagNodeByteArray); _blockLight = new YZXNibbleArray(XDIM, YDIM, ZDIM, ctree["BlockLight"] as TagNodeByteArray); if (!ctree.ContainsKey("AddBlocks")) { ctree["AddBlocks"] = new TagNodeByteArray(new byte[2048]); } _addBlocks = new YZXNibbleArray(XDIM, YDIM, ZDIM, ctree["AddBlocks"] as TagNodeByteArray); _tree = ctree; return(this); }
public Entity(double x, double y, double z, TagNodeCompound data) { X = x; Y = y; Z = z; Data = data; }
/// <summary> /// Creates a copy of an existing <see cref="Level"/> object. /// </summary> /// <param name="p">The <see cref="Level"/> object to copy.</param> protected Level(Level p) { _world = p._world; _time = p._time; _lastPlayed = p._lastPlayed; _spawnX = p._spawnX; _spawnY = p._spawnY; _spawnZ = p._spawnZ; _sizeOnDisk = p._sizeOnDisk; _randomSeed = p._randomSeed; _version = p._version; _name = p._name; _raining = p._raining; _thundering = p._thundering; _rainTime = p._rainTime; _thunderTime = p._thunderTime; _gameType = p._gameType; _mapFeatures = p._mapFeatures; _hardcore = p._hardcore; if (p._player != null) { _player = p._player.Copy(); } if (p._source != null) { _source = p._source.Copy() as TagNodeCompound; } }
public static NBTChunk LoadChunk(int chunkX, int chunkZ) { UnityEngine.Profiling.Profiler.BeginSample("ChunkChecker.Update"); key.Set(chunkX, chunkZ); if (!chunkDict.ContainsKey(key)) { TagNodeCompound Chunk = GetChunkNode(chunkX, chunkZ); if (Chunk != null) { TagNodeCompound Level = Chunk["Level"] as TagNodeCompound; TagNodeList Sections = Level["Sections"] as TagNodeList; NBTChunk chunk = ChunkPool.GetChunk(); chunk.SetData(chunkX, chunkZ, Sections); chunkDict.Add(key, chunk); } } UnityEngine.Profiling.Profiler.EndSample(); if (chunkDict.ContainsKey(key)) { return(chunkDict[key]); } return(null); }
/// <summary> /// Removes all entities matching the given id (type) from the collection. /// </summary> /// <param name="id">The id (type) of entities that should be removed.</param> /// <returns>A count of the number of entities that were removed.</returns> public int RemoveAll(string id) { int rem = _entities.RemoveAll(val => { TagNodeCompound cval = val as TagNodeCompound; if (cval == null) { return(false); } TagNode sval; if (!cval.TryGetValue("id", out sval)) { return(false); } return(sval.ToTagString().Data == id); }); if (rem > 0) { _dirty = true; } return(rem); }
static void SaveData() { // save to chest Instance.Items.Clear(); Instance.Items.ChangeValueType(TagType.TAG_COMPOUND); int count = 0; for (int i = 46; i <= 72; i++) { InventoryItem item = InventorySystem.items[i]; if (item.id != null) { TagNodeCompound serializeItem = new TagNodeCompound(); serializeItem.Add("Count", (TagNodeByte)item.count); serializeItem.Add("Damage", (TagNodeShort)item.damage); serializeItem.Add("id", (TagNodeString)item.id); serializeItem.Add("Slot", (TagNodeByte)(i - 46)); Instance.Items.Insert(count, serializeItem); InventorySystem.items[i].id = null; InventorySystem.items[i].damage = 0; InventorySystem.items[i].count = 0; } } }
/// <summary> /// Constructs a new generic <see cref="Entity"/> by copying fields from another <see cref="Entity"/> object. /// </summary> /// <param name="e">An <see cref="Entity"/> to copy fields from.</param> protected Entity(Entity e) { _pos = new Vector3(); _pos.X = e._pos.X; _pos.Y = e._pos.Y; _pos.Z = e._pos.Z; _motion = new Vector3(); _motion.X = e._motion.X; _motion.Y = e._motion.Y; _motion.Z = e._motion.Z; _rotation = new Orientation(); _rotation.Pitch = e._rotation.Pitch; _rotation.Yaw = e._rotation.Yaw; _fallDistance = e._fallDistance; _fire = e._fire; _air = e._air; _onGround = e._onGround; if (e._source != null) { _source = e._source.Copy() as TagNodeCompound; } }
public override TypedEntity LoadTree(TagNode tree) { TagNodeCompound ctree = tree as TagNodeCompound; if (ctree == null || base.LoadTree(tree) == null) { return(null); } _attackTime = ctree["AttackTime"].ToTagShort(); _deathTime = ctree["DeathTime"].ToTagShort(); _health = ctree["Health"].ToTagShort(); _hurtTime = ctree["HurtTime"].ToTagShort(); if (ctree.ContainsKey("ActiveEffects")) { TagNodeCompound ae = ctree["ActiveEffects"].ToTagCompound(); _activeEffects = new ActiveEffects(); _activeEffects.Id = ae["Id"].ToTagByte(); _activeEffects.Amplifier = ae["Amplifier"].ToTagByte(); _activeEffects.Duration = ae["Duration"].ToTagInt(); } return(this); }
/// <summary> /// Builds a Player subtree from the current data. /// </summary> /// <returns>The root node of a Player subtree representing the current data.</returns> public virtual new TagNode BuildTree() { TagNodeCompound tree = base.BuildTree() as TagNodeCompound; tree["AttackTime"] = new TagNodeShort(_attackTime); tree["DeathTime"] = new TagNodeShort(_deathTime); tree["Health"] = new TagNodeShort(_health); tree["HurtTime"] = new TagNodeShort(_hurtTime); tree["Dimension"] = new TagNodeInt(_dimension); tree["Sleeping"] = new TagNodeByte(_sleeping); tree["SleepTimer"] = new TagNodeShort(_sleepTimer); if (_spawnX != null && _spawnY != null && _spawnZ != null) { tree["SpawnX"] = new TagNodeInt(_spawnX ?? 0); tree["SpawnY"] = new TagNodeInt(_spawnY ?? 0); tree["SpawnZ"] = new TagNodeInt(_spawnZ ?? 0); } if (_world != null) { tree["World"] = new TagNodeString(_world); } tree["Inventory"] = _inventory.BuildTree(); return(tree); }
public void SetTileEntity(int x, int y, int z, TileEntity te) { BlockInfoEx info = BlockInfo.BlockTable[_blocks[x, y, z]] as BlockInfoEx; if (info == null) { throw new InvalidOperationException("The given block is of a type that does not support TileEntities."); } if (te.GetType() != TileEntityFactory.Lookup(info.TileEntityName)) { throw new ArgumentException("The TileEntity type is not valid for this block.", "te"); } BlockKey key = (TranslateCoordinates != null) ? TranslateCoordinates(x, y, z) : new BlockKey(x, y, z); TagNodeCompound oldte; if (_tileEntityTable.TryGetValue(key, out oldte)) { _tileEntities.Remove(oldte); } te.X = key.x; te.Y = key.y; te.Z = key.z; TagNodeCompound tree = te.BuildTree() as TagNodeCompound; _tileEntities.Add(tree); _tileEntityTable[key] = tree; }
public TagNode BuildTree() { TagNodeCompound level = _tree.Root["Level"] as TagNodeCompound; TagNodeCompound levelCopy = new TagNodeCompound(); foreach (KeyValuePair <string, TagNode> node in level) { levelCopy.Add(node.Key, node.Value); } TagNodeList sections = new TagNodeList(TagType.TAG_COMPOUND); for (int i = 0; i < _sections.Length; i++) { if (ShouldIncludeSection(_sections[i])) { sections.Add(_sections[i].BuildTree()); } } levelCopy["Sections"] = sections; if (_tileTicks.Count == 0) { levelCopy.Remove("TileTicks"); } return(levelCopy); }
public override bool Process (DataNode dataNode, ConsoleOptions options) { if (options.Values.Count == 0) return false; string jsonPath = options.Values[0]; using (FileStream stream = File.OpenWrite(jsonPath)) { using (StreamWriter writer = new StreamWriter(stream)) { if (dataNode is TagDataNode) { TagDataNode tagNode = dataNode as TagDataNode; WriteNbtTag(writer, tagNode.Tag); } else if (dataNode is NbtFileDataNode) { dataNode.Expand(); TagNodeCompound root = new TagNodeCompound(); foreach (DataNode child in dataNode.Nodes) { TagDataNode childTagNode = child as TagDataNode; if (childTagNode == null) continue; if (childTagNode.Tag != null) root.Add(childTagNode.NodeName, childTagNode.Tag); } WriteNbtTag(writer, root); } } } return true; }
public Item(TagNodeCompound item) { if (!item.ContainsKey("tag")) { return; } TagNodeCompound tag = item["tag"].ToTagCompound(); if (!tag.ContainsKey("display")) { return; } TagNodeCompound display = tag["display"].ToTagCompound(); if (display.Keys.Contains("Name")) { Name = display["Name"].ToTagString().Data; } if (display.Keys.Contains("Lore")) { TagNodeList l = display["Lore"].ToTagList(); for (int k = 0; k < l.Count; k++) { Lore += l[k].ToTagString().Data.Replace("Line" + (k + 1) + ":", "") + "\n"; } if (Lore.Length > 0) { Lore = Lore.Substring(0, Lore.Length - 1); } } }
/// <summary> /// Creates a new instance of a nonspecific <see cref="TypedEntity"/> object by NBT node. /// </summary> /// <param name="tree">A <see cref="TagNodeCompound"/> representing a single Entity, containing an 'id' field.</param> /// <returns>A new instance of a <see cref="TypedEntity"/> object, or null if the entity is not typed.</returns> public static TypedEntity CreateGeneric (TagNodeCompound tree) { TagNode type; if (!tree.TryGetValue("id", out type)) { return null; } TypedEntity te = new TypedEntity(type.ToTagString().Data); return te.LoadTreeSafe(tree); }
/// <summary> /// Create a new instance of a concrete <see cref="TileEntity"/> type by NBT node. /// </summary> /// <param name="tree">A <see cref="TagNodeCompound"/> representing a single Tile Entity, containing an 'id' field of the Tile Entity's registered name.</param> /// <returns>A new instance of a concrete <see cref="TileEntity"/> type, or null if no type was registered with the given name.</returns> public static TileEntity Create(TagNodeCompound tree) { string type = tree["id"].ToTagString(); Type t; if (!_registry.TryGetValue(type, out t)) { return null; } TileEntity te = Activator.CreateInstance(t) as TileEntity; return te.LoadTreeSafe(tree); }
public static byte[] SerializeNode (TagNode node) { TagNodeCompound root = new TagNodeCompound(); root.Add("root", node); NbtTree tree = new NbtTree(root); using (MemoryStream ms = new MemoryStream()) { tree.WriteTo(ms); byte[] data = new byte[ms.Length]; Array.Copy(ms.GetBuffer(), data, ms.Length); return data; } }
/// <summary> /// Create a new instance of a concrete <see cref="TypedEntity"/> type by NBT node. /// </summary> /// <param name="tree">A <see cref="TagNodeCompound"/> representing a single Entity, containing an 'id' field of the Entity's registered name.</param> /// <returns>A new instance of a concrete <see cref="TypedEntity"/> type, or null if no type was registered with the given name.</returns> public static TypedEntity Create (TagNodeCompound tree) { TagNode type; if (!tree.TryGetValue("id", out type)) { return null; } Type t; if (!_registry.TryGetValue(type.ToTagString(), out t)) { return null; } TypedEntity te = Activator.CreateInstance(t) as TypedEntity; return te.LoadTreeSafe(tree); }
private static void SerializeCompound (TagNodeCompound tag, StringBuilder str, int level) { if (tag.Count == 0) { str.Append("{ }"); return; } str.AppendLine(); AddLine(str, "{", level); IEnumerator<KeyValuePair<string, TagNode>> en = tag.GetEnumerator(); bool first = true; while (en.MoveNext()) { if (!first) { str.Append(","); str.AppendLine(); } KeyValuePair<string, TagNode> item = en.Current; Add(str, "\"" + item.Key + "\": ", level + 1); if (item.Value.GetTagType() == TagType.TAG_COMPOUND) { SerializeCompound(item.Value as TagNodeCompound, str, level + 1); } else if (item.Value.GetTagType() == TagType.TAG_LIST) { SerializeList(item.Value as TagNodeList, str, level + 1); } else if (item.Value.GetTagType() == TagType.TAG_BYTE_ARRAY) { SerializeByteArray(item.Value as TagNodeByteArray, str, level); } else if (item.Value.GetTagType() == TagType.TAG_INT_ARRAY) { SerializeIntArray(item.Value as TagNodeIntArray, str, level + 1); } else { SerializeScaler(item.Value, str); } first = false; } str.AppendLine(); Add(str, "}", level); }
public TileEntityMobSpawner(TileEntity te) : base(te) { TileEntityMobSpawner tes = te as TileEntityMobSpawner; if (tes != null) { _delay = tes._delay; _entityID = tes._entityID; _maxDelay = tes._maxDelay; _minDelay = tes._minDelay; _spawnCount = tes._spawnCount; _spawnRange = tes._spawnRange; _maxNearbyEnemies = tes._maxNearbyEnemies; _requiredPlayerRange = tes._requiredPlayerRange; _maxExperience = tes._maxExperience; _remainingExperience = tes._remainingExperience; _experienceRegenTick = tes._experienceRegenTick; _experienceRegenRate = tes._experienceRegenRate; _experienceRegenAmount = tes._experienceRegenAmount; if (tes._spawnData != null) _spawnData = tes._spawnData.Copy() as TagNodeCompound; } }
/// <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(); }
public static TagNodeList GetEnchantmentNBT(List<Enchantment> enchantments) { TagNodeCompound compound; TagNodeList list = new TagNodeList(TagType.TAG_COMPOUND); foreach (Enchantment ench in enchantments.ToArray()) { compound = new TagNodeCompound(); compound.Add("id", new TagNodeShort(ench.id)); compound.Add("lvl", new TagNodeShort(ench.level)); list.Add(compound); } return list; }
public TagNodeCompound GetNBTData() { TagNodeCompound comp = new TagNodeCompound(); comp.Add("ID", new TagNodeShort(id)); comp.Add("Count", new TagNodeByte(count)); comp.Add("Meta", new TagNodeShort(meta)); comp.Add("Ench", GetEnchantmentNBT()); return comp; }
public void LoadNBTData(TagNodeCompound comp) { try { id = comp["ID"].ToTagShort(); count = comp["Count"].ToTagByte(); meta = comp["Meta"].ToTagShort(); LoadEnchantmentNBT(comp["Ench"].ToTagList()); } catch { Logger.Log("NBT data is invalid."); } }
public TagCompoundDataNode(TagNodeCompound tag) : base(tag) { _container = new CompoundTagContainer(tag); }
public override TagNode BuildTree() { TagNodeCompound tree = base.BuildTree() as TagNodeCompound; tree["AttackTime"] = new TagNodeShort(_attackTime); tree["DeathTime"] = new TagNodeShort(_deathTime); tree["Health"] = new TagNodeShort(_health); tree["HurtTime"] = new TagNodeShort(_hurtTime); if (_activeEffects != null) { TagNodeCompound ae = new TagNodeCompound(); ae["Id"] = new TagNodeByte((byte)_activeEffects.Id); ae["Amplifier"] = new TagNodeByte((byte)_activeEffects.Amplifier); ae["Duration"] = new TagNodeInt(_activeEffects.Duration); tree["ActiveEffects"] = ae; } return tree; }
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; } }
public static byte[] GetEnchantmentNBTData(List<Enchantment> enchantments) { if (enchantments.Count < 1) return new byte[0]; NbtTree nbt = new NbtTree(); TagNodeList list = new TagNodeList(TagType.TAG_COMPOUND); TagNodeCompound compound; foreach (Enchantment ench in enchantments.ToArray()) { compound = new TagNodeCompound(); compound.Add("id", new TagNodeShort(ench.id)); compound.Add("lvl", new TagNodeShort(ench.level)); list.Add(compound); } nbt.Root.Add("ench", list); using (MemoryStream ms = new MemoryStream()) { nbt.WriteTo(ms); return ms.ToArray().Compress(Ionic.Zlib.CompressionLevel.BestCompression, CompressionType.GZip); } }
public void Save(World w) { try { string path = CreatePath(w, x, z, true); string file = CreatePath(w, x, z); if (!Directory.Exists(path)) Directory.CreateDirectory(path); NbtTree nbt = new NbtTree(); nbt.Root.Add("Generated", new TagNodeByte((byte)(generated ? 1 : 0))); nbt.Root.Add("Populated", new TagNodeByte((byte)(populated ? 1 : 0))); nbt.Root.Add("Blocks", new TagNodeByteArray(blocks)); nbt.Root.Add("Meta", new TagNodeByteArray(meta)); nbt.Root.Add("BlockLight", new TagNodeByteArray(Light)); nbt.Root.Add("SkyLight", new TagNodeByteArray(SkyL)); nbt.Root.Add("HeightMap", new TagNodeByteArray(heightMap)); nbt.Root.Add("HeightMapPrec", new TagNodeByteArray(precipitationHeightMap.ToByteArray())); TagNodeList nbtList = new TagNodeList(TagType.TAG_COMPOUND); TagNodeCompound nbtCompound; lock (extra) foreach (KeyValuePair<int, ushort> kvp in extra) { nbtCompound = new TagNodeCompound(); nbtCompound.Add("Pos", new TagNodeInt(kvp.Key)); nbtCompound.Add("Value", new TagNodeShort((short)kvp.Value)); nbtList.Add(nbtCompound); } nbt.Root.Add("Extra", nbtList); nbtList = new TagNodeList(TagType.TAG_COMPOUND); List<Physics.Check> physChecks = w.physics.GetChunkChecks(x, z); foreach (Physics.Check check in physChecks) { nbtCompound = new TagNodeCompound(); nbtCompound.Add("Pos", new TagNodeList(TagType.TAG_INT) { new TagNodeInt(check.x), new TagNodeInt(check.y), new TagNodeInt(check.z) }); nbtCompound.Add("Meta", new TagNodeByte(check.meta)); nbtCompound.Add("Time", new TagNodeShort(check.time)); nbtList.Add(nbtCompound); } nbt.Root.Add("Physics", nbtList); nbtList = new TagNodeList(TagType.TAG_COMPOUND); List<Entity> entities = Entities; TagNodeCompound nbtCompound2; foreach (Entity e in entities) { if (e.isPlayer) continue; nbtCompound = new TagNodeCompound(); nbtCompound.Add("Motion", new TagNodeList(TagType.TAG_DOUBLE) { new TagNodeDouble(e.velocity[0]), new TagNodeDouble(e.velocity[1]), new TagNodeDouble(e.velocity[2]) }); nbtCompound.Add("Pos", new TagNodeList(TagType.TAG_DOUBLE) { new TagNodeDouble(e.pos.x), new TagNodeDouble(e.pos.y), new TagNodeDouble(e.pos.z) }); nbtCompound.Add("Rotation", new TagNodeList(TagType.TAG_FLOAT) { new TagNodeFloat(e.rot[0]), new TagNodeFloat(e.rot[1]) }); nbtCompound.Add("Type", new TagNodeByte((byte)e.Type)); nbtCompound.Add("Age", new TagNodeInt(e.age)); nbtCompound.Add("OnGround", new TagNodeByte(e.onground)); nbtCompound.Add("Health", new TagNodeShort(e.Health)); nbtCompound2 = new TagNodeCompound(); switch (e.Type) { case EntityType.AI: nbtCompound2.Add("Type", new TagNodeByte(e.ai.type)); break; case EntityType.Object: nbtCompound2.Add("Type", new TagNodeByte(e.obj.type)); break; case EntityType.Item: nbtCompound2.Add("ID", new TagNodeShort(e.I.id)); nbtCompound2.Add("Count", new TagNodeByte(e.I.count)); nbtCompound2.Add("Meta", new TagNodeShort(e.I.meta)); break; } nbtCompound.Add("Data", nbtCompound2); nbtList.Add(nbtCompound); } nbt.Root.Add("Entities", nbtList); nbtList = new TagNodeList(TagType.TAG_COMPOUND); foreach (Container c in GetContainers(w)) { nbtCompound = new TagNodeCompound(); nbtCompound.Add("Type", new TagNodeByte((byte)c.Type)); nbtCompound.Add("Pos", new TagNodeList(TagType.TAG_INT) { new TagNodeInt((int)c.Pos.x), new TagNodeInt((int)c.Pos.y), new TagNodeInt((int)c.Pos.z) }); nbtCompound.Add("Items", c.GetNBTData()); nbtList.Add(nbtCompound); //Console.WriteLine("SAVED CONTAINER @ " + (int)c.Pos.x + "," + (int)c.Pos.y + "," + (int)c.Pos.z + " @ " + x + "," + z); } nbt.Root.Add("Containers", nbtList); try { using (MemoryStream ms = new MemoryStream()) { nbt.WriteTo(ms); byte[] bytes = ms.ToArray().Compress(CompressionLevel.BestCompression, CompressionType.GZip); using (FileStream fs = new FileStream(file, FileMode.Create, FileAccess.Write)) fs.Write(bytes, 0, bytes.Length); } } catch (Exception ex) { Logger.LogToFile("Error saving chunk at " + x + "," + z + "!"); Logger.LogErrorToFile(ex); } this._dirty = false; //Console.WriteLine("SAVED " + x + " " + z); } catch (Exception ex) { Logger.LogError(ex); } }
public CompoundTagContainer(TagNodeCompound tag) { _tag = tag; }
public override TileEntity LoadTree(TagNode tree) { TagNodeCompound ctree = tree as TagNodeCompound; if (ctree == null || base.LoadTree(tree) == null) { return null; } _delay = ctree["Delay"].ToTagShort(); _entityID = ctree["EntityId"].ToTagString(); if (ctree.ContainsKey("MaxSpawnDelay")) _maxDelay = ctree["MaxSpawnDelay"].ToTagShort(); if (ctree.ContainsKey("MinSpawnDelay")) _minDelay = ctree["MinSpawnDelay"].ToTagShort(); if (ctree.ContainsKey("SpawnCount")) _spawnCount = ctree["SpawnCount"].ToTagShort(); if (ctree.ContainsKey("SpawnRange")) _spawnRange = ctree["SpawnRange"].ToTagShort(); if (ctree.ContainsKey("MaxNearbyEnemies")) _maxNearbyEnemies = ctree["MaxNearbyEnemies"].ToTagShort(); if (ctree.ContainsKey("RequiredPlayerRange")) _requiredPlayerRange = ctree["RequiredPlayerRange"].ToTagShort(); if (ctree.ContainsKey("MaxExperience")) _maxExperience = ctree["MaxExperience"].ToTagInt(); if (ctree.ContainsKey("RemainingExperience")) _remainingExperience = ctree["RemainingExperience"].ToTagInt(); if (ctree.ContainsKey("ExperienceRegenTick")) _experienceRegenTick = ctree["ExperienceRegenTick"].ToTagInt(); if (ctree.ContainsKey("ExperienceRegenRate")) _experienceRegenRate = ctree["ExperienceRegenRate"].ToTagInt(); if (ctree.ContainsKey("ExperienceRegenAmount")) _experienceRegenRate = ctree["ExperienceRegenAmount"].ToTagInt(); if (ctree.ContainsKey("SpawnData")) _spawnData = ctree["SpawnData"].ToTagCompound(); return this; }