private void ParseTileArea(OtFileReader reader, OtFileNode otbNode, bool replaceTiles, ISet <ulong> tileLocations)
        {
            OtPropertyReader props = reader.GetPropertyReader(otbNode);

            int baseX = props.ReadUInt16();
            int baseY = props.ReadUInt16();
            int baseZ = props.ReadByte();

            OtFileNode nodeTile = otbNode.Child;

            while (nodeTile != null)
            {
                if (nodeTile.Type == (long)OtMapNodeTypes.TILE ||
                    nodeTile.Type == (long)OtMapNodeTypes.HOUSETILE)
                {
                    props = reader.GetPropertyReader(nodeTile);

                    var tileLocation = new Location(baseX + props.ReadByte(), baseY + props.ReadByte(), baseZ);

                    var tile = new OtTile(tileLocation);

                    if (nodeTile.Type == (long)OtMapNodeTypes.HOUSETILE)
                    {
                        tile.HouseId = props.ReadUInt32();
                    }

                    while (props.PeekChar() != -1)
                    {
                        byte attribute = props.ReadByte();
                        switch ((OtMapAttribute)attribute)
                        {
                        case OtMapAttribute.TILE_FLAGS: {
                            tile.Flags = props.ReadUInt32();
                            break;
                        }

                        case OtMapAttribute.ITEM: {
                            ushort itemId = props.ReadUInt16();

                            var itemType = Items.GetItem(itemId);
                            if (itemType == null)
                            {
                                throw new Exception("Unkonw item type " + itemId + " in position " + tileLocation + ".");
                            }

                            var item = OtItem.Create(itemType);
                            tile.InternalAddItem(item);

                            break;
                        }

                        default:
                            throw new Exception(string.Format("{0} Unknown tile attribute.", tileLocation));
                        }
                    }

                    OtFileNode nodeItem = nodeTile.Child;

                    while (nodeItem != null)
                    {
                        if (nodeItem.Type == (long)OtMapNodeTypes.ITEM)
                        {
                            props = reader.GetPropertyReader(nodeItem);

                            ushort itemId = props.ReadUInt16();

                            var itemType = Items.GetItem(itemId);
                            if (itemType == null)
                            {
                                throw new Exception("Unkonw item type " + itemId + " in position " + tileLocation + ".");
                            }

                            var item = OtItem.Create(itemType);
                            item.Deserialize(reader, nodeItem, props, Items);

                            tile.InternalAddItem(item);
                        }
                        else
                        {
                            throw new Exception(string.Format("{0} Unknown node type.", tileLocation));
                        }
                        nodeItem = nodeItem.Next;
                    }

                    var index   = tileLocation.ToIndex();
                    var hasTile = HasTile(index);

                    if (!hasTile)
                    {
                        SetTile(tile);
                        tileLocations.Add(tileLocation.ToIndex());
                    }
                    else if (replaceTiles)
                    {
                        SetTile(tile);
                    }
                }

                nodeTile = nodeTile.Next;
            }
        }
 public void SetTile(ulong index, OtTile tile)
 {
     tiles[index] = tile;
 }
 public void SetTile(OtTile tile)
 {
     SetTile(tile.Location.ToIndex(), tile);
 }
        public static void Map_Updated(object sender, MapUpdatedEventArgs e)
        {
            try {
                lock (map) {
                    foreach (var tile in e.Tiles)
                    {
                        var index = tile.Location.ToIndex();

                        OtTile mapTile = map.GetTile(tile.Location);
                        if (mapTile != null)
                        {
                            continue;
                        }
                        else if (mapTile == null)
                        {
                            mapTile = new OtTile(tile.Location);
                        }

                        mapTile.Clear();

                        for (int i = 0; i < tile.ThingCount; i++)
                        {
                            var thing = tile.GetThing(i);

                            if (thing is Creature)
                            {
                                var creature = thing as Creature;

                                if (creature.Type == CreatureType.PLAYER || (creature.Type == CreatureType.MONSTER) || (creature.Type == CreatureType.NPC))
                                {
                                    continue;
                                }

                                map.AddCreature(new OtCreature {
                                    Id = creature.Id, Location = creature.Location, Name = creature.Name, Type = creature.Type
                                });
                            }
                            else if (thing is Item)
                            {
                                var item = tile.GetThing(i) as Item;

                                var itemType = Instance.otItems.GetItemBySpriteId((ushort)item.Id);
                                if (itemType == null)
                                {
                                    //Console.WriteLine("Tibia item not in items.otb. Details: item id " + item.Id.ToString());
                                    continue;
                                }

                                OtItem mapItem = OtItem.Create(itemType);

                                if (mapItem.Type.IsStackable)
                                {
                                    mapItem.SetAttribute(OtItemAttribute.COUNT, item.Count);
                                }
                                else if (mapItem.Type.Group == OtItemGroup.Splash || mapItem.Type.Group == OtItemGroup.FluidContainer)
                                {
                                    mapItem.SetAttribute(OtItemAttribute.COUNT, OtConverter.TibiaFluidToOtFluid(item.SubType));
                                }

                                mapTile.AddItem(mapItem);
                            }
                        }

                        map.SetTile(mapTile);
                    }
                }
            } catch (Exception ex) {
                //Console.WriteLine("[Error] Unable to convert tibia tile to open tibia tile. Details: " + ex.Message);
            }
        }