Example #1
0
        public void Serialize(GenericWriter writer)
        {
            writer.Write((int)1);                // version;

            writer.Write(m_Min);
            writer.Write(m_Max);
            writer.Write(Center);

            writer.Write((int)Width);
            writer.Write((int)Height);

            writer.Write((int)List.Length);

            for (int i = 0; i < List.Length; ++i)
            {
                MultiTileEntry ent = List[i];

                writer.Write((ushort)ent.m_ItemID);
                writer.Write((short)ent.m_OffsetX);
                writer.Write((short)ent.m_OffsetY);
                writer.Write((short)ent.m_OffsetZ);
                writer.Write((int)ent.m_Flags);
            }
        }
Example #2
0
        public void Serialize(GenericWriter writer)
        {
            writer.Write(1);             // version;

            writer.Write(m_Min);
            writer.Write(m_Max);
            writer.Write(m_Center);

            writer.Write(m_Width);
            writer.Write(m_Height);

            writer.Write(m_List.Length);

            for (int i = 0; i < m_List.Length; ++i)
            {
                MultiTileEntry ent = m_List[i];

                writer.Write(ent.m_ItemID);
                writer.Write(ent.m_OffsetX);
                writer.Write(ent.m_OffsetY);
                writer.Write(ent.m_OffsetZ);
                writer.Write(ent.m_Flags);
            }
        }
Example #3
0
        public void Resize(int newWidth, int newHeight)
        {
            int oldWidth = m_Width, oldHeight = m_Height;
            var oldTiles = m_Tiles;

            int totalLength = 0;

            var newTiles = new StaticTile[newWidth][][];

            for (int x = 0; x < newWidth; ++x)
            {
                newTiles[x] = new StaticTile[newHeight][];

                for (int y = 0; y < newHeight; ++y)
                {
                    if (x < oldWidth && y < oldHeight)
                    {
                        newTiles[x][y] = oldTiles[x][y];
                    }
                    else
                    {
                        newTiles[x][y] = new StaticTile[0];
                    }

                    totalLength += newTiles[x][y].Length;
                }
            }

            m_Tiles  = newTiles;
            m_List   = new MultiTileEntry[totalLength];
            m_Width  = newWidth;
            m_Height = newHeight;

            m_Min = Point2D.Zero;
            m_Max = Point2D.Zero;

            int index = 0;

            for (int x = 0; x < newWidth; ++x)
            {
                for (int y = 0; y < newHeight; ++y)
                {
                    var tiles = newTiles[x][y];

                    for (int i = 0; i < tiles.Length; ++i)
                    {
                        StaticTile tile = tiles[i];

                        int vx = x - m_Center.X;
                        int vy = y - m_Center.Y;

                        if (vx < m_Min.m_X)
                        {
                            m_Min.m_X = vx;
                        }

                        if (vy < m_Min.m_Y)
                        {
                            m_Min.m_Y = vy;
                        }

                        if (vx > m_Max.m_X)
                        {
                            m_Max.m_X = vx;
                        }

                        if (vy > m_Max.m_Y)
                        {
                            m_Max.m_Y = vy;
                        }

                        m_List[index++] = new MultiTileEntry((ushort)tile.ID, (short)vx, (short)vy, (short)tile.Z, 1);
                    }
                }
            }
        }
Example #4
0
        public void Add(int itemID, int x, int y, int z)
        {
            #region Stygian Abyss
            itemID &= TileData.MaxItemValue;
            itemID |= 0x10000;
            #endregion

            int vx = x + m_Center.m_X;
            int vy = y + m_Center.m_Y;

            if (vx >= 0 && vx < m_Width && vy >= 0 && vy < m_Height)
            {
                var oldTiles = m_Tiles[vx][vy];

                for (int i = oldTiles.Length - 1; i >= 0; --i)
                {
                    ItemData data = TileData.ItemTable[itemID & TileData.MaxItemValue];

                    if (oldTiles[i].Z == z && (oldTiles[i].Height > 0 == data.Height > 0))
                    {
                        bool newIsRoof = (data.Flags & TileFlag.Roof) != 0;
                        bool oldIsRoof = (TileData.ItemTable[oldTiles[i].ID & TileData.MaxItemValue].Flags & TileFlag.Roof) != 0;

                        if (newIsRoof == oldIsRoof)
                        {
                            Remove(oldTiles[i].ID, x, y, z);
                        }
                    }
                }

                oldTiles = m_Tiles[vx][vy];

                var newTiles = new StaticTile[oldTiles.Length + 1];

                for (int i = 0; i < oldTiles.Length; ++i)
                {
                    newTiles[i] = oldTiles[i];
                }

                newTiles[oldTiles.Length] = new StaticTile((ushort)itemID, (sbyte)z);

                m_Tiles[vx][vy] = newTiles;

                var oldList = m_List;
                var newList = new MultiTileEntry[oldList.Length + 1];

                for (int i = 0; i < oldList.Length; ++i)
                {
                    newList[i] = oldList[i];
                }

                newList[oldList.Length] = new MultiTileEntry((ushort)itemID, (short)x, (short)y, (short)z, 1);

                m_List = newList;

                if (x < m_Min.m_X)
                {
                    m_Min.m_X = x;
                }

                if (y < m_Min.m_Y)
                {
                    m_Min.m_Y = y;
                }

                if (x > m_Max.m_X)
                {
                    m_Max.m_X = x;
                }

                if (y > m_Max.m_Y)
                {
                    m_Max.m_Y = y;
                }
            }
        }
Example #5
0
        public void RemoveXYZH(int x, int y, int z, int minHeight)
        {
            var vx = x + m_Center.m_X;
            var vy = y + m_Center.m_Y;

            if (vx >= 0 && vx < Width && vy >= 0 && vy < Height)
            {
                var oldTiles = Tiles[vx][vy];

                for (var i = 0; i < oldTiles.Length; ++i)
                {
                    var tile = oldTiles[i];

                    if (tile.Z == z && tile.Height >= minHeight)
                    {
                        var newTiles = new StaticTile[oldTiles.Length - 1];

                        for (var j = 0; j < i; ++j)
                        {
                            newTiles[j] = oldTiles[j];
                        }

                        for (var j = i + 1; j < oldTiles.Length; ++j)
                        {
                            newTiles[j - 1] = oldTiles[j];
                        }

                        Tiles[vx][vy] = newTiles;

                        break;
                    }
                }

                var oldList = m_List;

                for (var i = 0; i < oldList.Length; ++i)
                {
                    var tile = oldList[i];

                    if (tile.m_OffsetX == (short)x && tile.m_OffsetY == (short)y && tile.m_OffsetZ == (short)z &&
                        TileData.ItemTable[tile.m_ItemID & TileData.MaxItemValue].Height >= minHeight)
                    {
                        var newList = new MultiTileEntry[oldList.Length - 1];

                        for (var j = 0; j < i; ++j)
                        {
                            newList[j] = oldList[j];
                        }

                        for (var j = i + 1; j < oldList.Length; ++j)
                        {
                            newList[j - 1] = oldList[j];
                        }

                        m_List = newList;

                        break;
                    }
                }
            }
        }
Example #6
0
        public MultiComponentList(BinaryReader reader, int count)
        {
            MultiTileEntry[] allTiles = m_List = new MultiTileEntry[count];

            for (int i = 0; i < count; ++i)
            {
                allTiles[i].m_ItemID  = reader.ReadUInt16();
                allTiles[i].m_OffsetX = reader.ReadInt16();
                allTiles[i].m_OffsetY = reader.ReadInt16();
                allTiles[i].m_OffsetZ = reader.ReadInt16();

                if (PostHSFormat)
                {
                    allTiles[i].m_Flags = (TileFlag)reader.ReadUInt64();
                }
                else
                {
                    allTiles[i].m_Flags = (TileFlag)reader.ReadUInt32();
                }

                MultiTileEntry e = allTiles[i];

                if (i == 0 || e.m_Flags != 0)
                {
                    if (e.m_OffsetX < m_Min.m_X)
                    {
                        m_Min.m_X = e.m_OffsetX;
                    }

                    if (e.m_OffsetY < m_Min.m_Y)
                    {
                        m_Min.m_Y = e.m_OffsetY;
                    }

                    if (e.m_OffsetX > m_Max.m_X)
                    {
                        m_Max.m_X = e.m_OffsetX;
                    }

                    if (e.m_OffsetY > m_Max.m_Y)
                    {
                        m_Max.m_Y = e.m_OffsetY;
                    }
                }
            }

            m_Center = new Point2D(-m_Min.m_X, -m_Min.m_Y);
            m_Width  = m_Max.m_X - m_Min.m_X + 1;
            m_Height = m_Max.m_Y - m_Min.m_Y + 1;

            TileList[][] tiles = new TileList[m_Width][];
            m_Tiles = new StaticTile[m_Width][][];

            for (int x = 0; x < m_Width; ++x)
            {
                tiles[x]   = new TileList[m_Height];
                m_Tiles[x] = new StaticTile[m_Height][];

                for (int y = 0; y < m_Height; ++y)
                {
                    tiles[x][y] = new TileList();
                }
            }

            for (int i = 0; i < allTiles.Length; ++i)
            {
                if (i == 0 || allTiles[i].m_Flags != 0)
                {
                    int xOffset = allTiles[i].m_OffsetX + m_Center.m_X;
                    int yOffset = allTiles[i].m_OffsetY + m_Center.m_Y;
                    int itemID  = (allTiles[i].m_ItemID & TileData.MaxItemValue) | 0x10000;

                    tiles[xOffset][yOffset].Add((ushort)itemID, (sbyte)allTiles[i].m_OffsetZ);
                }
            }

            for (int x = 0; x < m_Width; ++x)
            {
                for (int y = 0; y < m_Height; ++y)
                {
                    m_Tiles[x][y] = tiles[x][y].ToArray();
                }
            }
        }
Example #7
0
        public void Add(int itemID, int x, int y, int z)
        {
            var vx = x + Center.m_X;
            var vy = y + Center.m_Y;

            if (vx >= 0 && vx < Width && vy >= 0 && vy < Height)
            {
                var oldTiles = Tiles[vx][vy];

                for (var i = oldTiles.Length - 1; i >= 0; --i)
                {
                    var data = TileData.ItemTable[itemID & TileData.MaxItemValue];

                    if (oldTiles[i].Z == z && oldTiles[i].Height > 0 == data.Height > 0)
                    {
                        var newIsRoof = (data.Flags & TileFlag.Roof) != 0;
                        var oldIsRoof =
                            (TileData.ItemTable[oldTiles[i].ID & TileData.MaxItemValue].Flags & TileFlag.Roof) != 0;

                        if (newIsRoof == oldIsRoof)
                        {
                            Remove(oldTiles[i].ID, x, y, z);
                        }
                    }
                }

                oldTiles = Tiles[vx][vy];

                var newTiles = new StaticTile[oldTiles.Length + 1];

                for (var i = 0; i < oldTiles.Length; ++i)
                {
                    newTiles[i] = oldTiles[i];
                }

                newTiles[oldTiles.Length] = new StaticTile((ushort)itemID, (sbyte)z);

                Tiles[vx][vy] = newTiles;

                var oldList = List;
                var newList = new MultiTileEntry[oldList.Length + 1];

                for (var i = 0; i < oldList.Length; ++i)
                {
                    newList[i] = oldList[i];
                }

                newList[oldList.Length] = new MultiTileEntry(
                    (ushort)itemID,
                    (short)x,
                    (short)y,
                    (short)z,
                    TileFlag.Background
                    );

                List = newList;

                if (x < m_Min.m_X)
                {
                    m_Min.m_X = x;
                }

                if (y < m_Min.m_Y)
                {
                    m_Min.m_Y = y;
                }

                if (x > m_Max.m_X)
                {
                    m_Max.m_X = x;
                }

                if (y > m_Max.m_Y)
                {
                    m_Max.m_Y = y;
                }
            }
        }
Example #8
0
        public MultiComponentList(BinaryReader reader, int count)
        {
            var allTiles = List = new MultiTileEntry[count];

            for (var i = 0; i < count; ++i)
            {
                allTiles[i].ItemId  = reader.ReadUInt16();
                allTiles[i].OffsetX = reader.ReadInt16();
                allTiles[i].OffsetY = reader.ReadInt16();
                allTiles[i].OffsetZ = reader.ReadInt16();

                if (PostHSFormat)
                {
                    allTiles[i].Flags = (TileFlag)reader.ReadUInt64();
                }
                else
                {
                    allTiles[i].Flags = (TileFlag)reader.ReadUInt32();
                }

                var e = allTiles[i];

                if (i == 0 || e.Flags != 0)
                {
                    if (e.OffsetX < m_Min.m_X)
                    {
                        m_Min.m_X = e.OffsetX;
                    }

                    if (e.OffsetY < m_Min.m_Y)
                    {
                        m_Min.m_Y = e.OffsetY;
                    }

                    if (e.OffsetX > m_Max.m_X)
                    {
                        m_Max.m_X = e.OffsetX;
                    }

                    if (e.OffsetY > m_Max.m_Y)
                    {
                        m_Max.m_Y = e.OffsetY;
                    }
                }
            }

            Center = new Point2D(-m_Min.m_X, -m_Min.m_Y);
            Width  = m_Max.m_X - m_Min.m_X + 1;
            Height = m_Max.m_Y - m_Min.m_Y + 1;

            var tiles = new TileList[Width][];

            Tiles = new StaticTile[Width][][];

            for (var x = 0; x < Width; ++x)
            {
                tiles[x] = new TileList[Height];
                Tiles[x] = new StaticTile[Height][];

                for (var y = 0; y < Height; ++y)
                {
                    tiles[x][y] = new TileList();
                }
            }

            for (var i = 0; i < allTiles.Length; ++i)
            {
                if (i == 0 || allTiles[i].Flags != 0)
                {
                    var xOffset = allTiles[i].OffsetX + Center.m_X;
                    var yOffset = allTiles[i].OffsetY + Center.m_Y;

                    tiles[xOffset][yOffset].Add(allTiles[i].ItemId, (sbyte)allTiles[i].OffsetZ);
                }
            }

            for (var x = 0; x < Width; ++x)
            {
                for (var y = 0; y < Height; ++y)
                {
                    Tiles[x][y] = tiles[x][y].ToArray();
                }
            }
        }
Example #9
0
        public MultiComponentList(BinaryReader reader, int count)
        {
            int            num1;
            MultiTileEntry entry1;
            int            num2;
            int            num3;
            int            num4;
            int            num5;
            int            num6;
            int            num7;
            int            num8;

            MultiTileEntry[] entryArray2;
            this.m_List = (entryArray2 = new MultiTileEntry[count]);
            MultiTileEntry[] entryArray1 = entryArray2;
            for (num1 = 0; (num1 < count); ++num1)
            {
                entryArray1[num1].m_ItemID  = reader.ReadInt16();
                entryArray1[num1].m_OffsetX = reader.ReadInt16();
                entryArray1[num1].m_OffsetY = reader.ReadInt16();
                entryArray1[num1].m_OffsetZ = reader.ReadInt16();
                entryArray1[num1].m_Flags   = reader.ReadInt32();
                entry1 = entryArray1[num1];
                if ((num1 == 0) || (entry1.m_Flags != 0))
                {
                    if (entry1.m_OffsetX < this.m_Min.m_X)
                    {
                        this.m_Min.m_X = entry1.m_OffsetX;
                    }
                    if (entry1.m_OffsetY < this.m_Min.m_Y)
                    {
                        this.m_Min.m_Y = entry1.m_OffsetY;
                    }
                    if (entry1.m_OffsetX > this.m_Max.m_X)
                    {
                        this.m_Max.m_X = entry1.m_OffsetX;
                    }
                    if (entry1.m_OffsetY > this.m_Max.m_Y)
                    {
                        this.m_Max.m_Y = entry1.m_OffsetY;
                    }
                }
            }
            this.m_Center = new Point2D(-this.m_Min.m_X, -this.m_Min.m_Y);
            this.m_Width  = ((this.m_Max.m_X - this.m_Min.m_X) + 1);
            this.m_Height = ((this.m_Max.m_Y - this.m_Min.m_Y) + 1);
            TileList[][] listArrayArray1 = new TileList[this.m_Width][];
            this.m_Tiles = new Tile[this.m_Width][][];
            for (num2 = 0; (num2 < this.m_Width); ++num2)
            {
                listArrayArray1[num2] = new TileList[this.m_Height];
                this.m_Tiles[num2]    = new Tile[this.m_Height][];
                for (num3 = 0; (num3 < this.m_Height); ++num3)
                {
                    listArrayArray1[num2][num3] = new TileList();
                }
            }
            for (num4 = 0; (num4 < entryArray1.Length); ++num4)
            {
                if ((num4 == 0) || (entryArray1[num4].m_Flags != 0))
                {
                    num5 = (entryArray1[num4].m_OffsetX + this.m_Center.m_X);
                    num6 = (entryArray1[num4].m_OffsetY + this.m_Center.m_Y);
                    listArrayArray1[num5][num6].Add(((short)((entryArray1[num4].m_ItemID & 16383) | 16384)), ((sbyte)entryArray1[num4].m_OffsetZ));
                }
            }
            for (num7 = 0; (num7 < this.m_Width); ++num7)
            {
                for (num8 = 0; (num8 < this.m_Height); ++num8)
                {
                    this.m_Tiles[num7][num8] = listArrayArray1[num7][num8].ToArray();
                }
            }
        }
Example #10
0
        public MultiComponentList(BinaryReader reader, int count)
        {
            MultiTileEntry[] allTiles = List = new MultiTileEntry[count];

            for (int i = 0; i < count; ++i)
            {
                allTiles[i].m_ItemID  = reader.ReadUInt16();
                allTiles[i].m_OffsetX = reader.ReadInt16();
                allTiles[i].m_OffsetY = reader.ReadInt16();
                allTiles[i].m_OffsetZ = reader.ReadInt16();
                allTiles[i].m_Flags   = reader.ReadInt32();

                if (PostHSFormat)
                {
                    reader.ReadInt32();                     // ??
                }
                MultiTileEntry e = allTiles[i];

                if (i == 0 || e.m_Flags != 0)
                {
                    if (e.m_OffsetX < m_Min.m_X)
                    {
                        m_Min.m_X = e.m_OffsetX;
                    }

                    if (e.m_OffsetY < m_Min.m_Y)
                    {
                        m_Min.m_Y = e.m_OffsetY;
                    }

                    if (e.m_OffsetX > m_Max.m_X)
                    {
                        m_Max.m_X = e.m_OffsetX;
                    }

                    if (e.m_OffsetY > m_Max.m_Y)
                    {
                        m_Max.m_Y = e.m_OffsetY;
                    }
                }
            }

            m_Center = new Point2D(-m_Min.m_X, -m_Min.m_Y);
            Width    = (m_Max.m_X - m_Min.m_X) + 1;
            Height   = (m_Max.m_Y - m_Min.m_Y) + 1;

            TileList[][] tiles = new TileList[Width][];
            Tiles = new StaticTile[Width][][];

            for (int x = 0; x < Width; ++x)
            {
                tiles[x] = new TileList[Height];
                Tiles[x] = new StaticTile[Height][];

                for (int y = 0; y < Height; ++y)
                {
                    tiles[x][y] = new TileList();
                }
            }

            for (int i = 0; i < allTiles.Length; ++i)
            {
                if (i == 0 || allTiles[i].m_Flags != 0)
                {
                    int xOffset = allTiles[i].m_OffsetX + m_Center.m_X;
                    int yOffset = allTiles[i].m_OffsetY + m_Center.m_Y;

                    tiles[xOffset][yOffset].Add(allTiles[i].m_ItemID, (sbyte)allTiles[i].m_OffsetZ);
                }
            }

            for (int x = 0; x < Width; ++x)
            {
                for (int y = 0; y < Height; ++y)
                {
                    Tiles[x][y] = tiles[x][y].ToArray();
                }
            }
        }
Example #11
0
		public void Remove( int itemID, int x, int y, int z )
		{
			int vx = x + m_Center.m_X;
			int vy = y + m_Center.m_Y;

			if ( vx >= 0 && vx < m_Width && vy >= 0 && vy < m_Height )
			{
				Tile[] oldTiles = m_Tiles[vx][vy];

				for ( int i = 0; i < oldTiles.Length; ++i )
				{
					Tile tile = oldTiles[i];

					#region SA
					if ( (tile.ID & 0x7FFF) == (itemID & 0x7FFF) && tile.Z == z )
					{
					#endregion

						Tile[] newTiles = new Tile[oldTiles.Length - 1];

						for ( int j = 0; j < i; ++j )
							newTiles[j] = oldTiles[j];

						for ( int j = i + 1; j < oldTiles.Length; ++j )
							newTiles[j - 1] = oldTiles[j];

						m_Tiles[vx][vy] = newTiles;

						break;
					}
				}

				MultiTileEntry[] oldList = m_List;

				for ( int i = 0; i < oldList.Length; ++i )
				{
					MultiTileEntry tile = oldList[i];

					#region SA
					if ( (tile.m_ItemID & 0x7FFF) == (short)(itemID & 0x7FFF) && tile.m_OffsetX == (short)x && tile.m_OffsetY == (short)y && tile.m_OffsetZ == (short)z )
					{
					#endregion

						MultiTileEntry[] newList = new MultiTileEntry[oldList.Length - 1];

						for ( int j = 0; j < i; ++j )
							newList[j] = oldList[j];

						for ( int j = i + 1; j < oldList.Length; ++j )
							newList[j - 1] = oldList[j];

						m_List = newList;

						break;
					}
				}
			}
		}
Example #12
0
		public void Add( int itemID, int x, int y, int z )
		{
			#region SA
			itemID &= 0x7FFF;
			itemID |= 0x8000; // Note #2 8000 prevented you from walking on them
			// 4003 | 8000 = C003 & 7FFF = 4003
			// 4003 | 4000 = 3 & 7FFF = 3
			itemID &= 0x7FFF;
			#endregion

			int vx = x + m_Center.m_X;
			int vy = y + m_Center.m_Y;

			if ( vx >= 0 && vx < m_Width && vy >= 0 && vy < m_Height )
			{
				Tile[] oldTiles = m_Tiles[vx][vy];

				for ( int i = oldTiles.Length - 1; i >= 0; --i )
				{
					#region SA
					ItemData data = TileData.ItemTable[itemID & 0x7FFF];
					#endregion

					if ( oldTiles[i].Z == z && (oldTiles[i].Height > 0 == data.Height > 0 ) )
					{
						bool newIsRoof = ( data.Flags & TileFlag.Roof) != 0;
						#region SA
						bool oldIsRoof = (TileData.ItemTable[oldTiles[i].ID & 0x7FFF].Flags & TileFlag.Roof ) != 0;
						#endregion

						if ( newIsRoof == oldIsRoof )
							Remove( oldTiles[i].ID, x, y, z );
					}
				}

				oldTiles = m_Tiles[vx][vy];

				Tile[] newTiles = new Tile[oldTiles.Length + 1];

				for ( int i = 0; i < oldTiles.Length; ++i )
					newTiles[i] = oldTiles[i];

				newTiles[oldTiles.Length] = new Tile( (short)itemID, (sbyte)z );

				m_Tiles[vx][vy] = newTiles;

				MultiTileEntry[] oldList = m_List;
				MultiTileEntry[] newList = new MultiTileEntry[oldList.Length + 1];

				for ( int i = 0; i < oldList.Length; ++i )
					newList[i] = oldList[i];

				newList[oldList.Length] = new MultiTileEntry( (short)itemID, (short)x, (short)y, (short)z, 1 );

				m_List = newList;

				if ( x < m_Min.m_X )
					m_Min.m_X = x;

				if ( y < m_Min.m_Y )
					m_Min.m_Y = y;

				if ( x > m_Max.m_X )
					m_Max.m_X = x;

				if ( y > m_Max.m_Y )
					m_Max.m_Y = y;
			}
		}
Example #13
0
        // END ALAN MOD

        public MultiComponentList(BinaryReader reader, int count)
        {
            MultiTileEntry[] allTiles = m_List = new MultiTileEntry[count];

            for (int i = 0; i < count; ++i)
            {
                allTiles[i].m_ItemID  = reader.ReadUInt16();
                allTiles[i].m_OffsetX = reader.ReadInt16();
                allTiles[i].m_OffsetY = reader.ReadInt16();
                allTiles[i].m_OffsetZ = reader.ReadInt16();
                allTiles[i].m_Flags   = reader.ReadInt32();

                /*
                 * // BEGIN ALAN PARSING OUT STUFF (THIS IS TEMPORARY) ==================================================
                 * if (allTiles[i].m_Flags == 0) // invisible
                 * {
                 *  int[,] transformation = new int[2, 2] { { 1, 0 }, { 0, 1 } }; // transformation matrix
                 *
                 *  //Console.WriteLine(allTiles[i].m_ItemID + "\t" + allTiles[i].m_OffsetX + "\t" + allTiles[i].m_OffsetY + "\t" + allTiles[i].m_OffsetZ + "\t" + allTiles[i].m_Flags);
                 *  int baseMultiID = 0; // this is the "base" multi (northern undamaged boat) used to rotate from in order to connect the pieces
                 *  int damageLevel = 0;
                 *  int direction = 0;
                 *  if (MultiData.currentMultiID == 24) // orc north BASE
                 *  {
                 *      if (!MultiEntries.ContainsKey(24)) MultiEntries.Add(24, new MultiEntry(24));
                 *      baseMultiID = 24; transformation = new int[2, 2] { { 1, 0 }, { 0, 1 } }; damageLevel = 0; direction = 0;
                 *  }
                 *  else if (MultiData.currentMultiID == 25) // orc east
                 *  {
                 *      baseMultiID = 24; transformation = new int[2, 2] { { 0, -1 }, { 1, 0 } }; damageLevel = 0; direction = 1;
                 *  }
                 *  else if (MultiData.currentMultiID == 26) // orc south
                 *  {
                 *      baseMultiID = 24; transformation = new int[2, 2] { { -1, 0 }, { 0, -1 } }; damageLevel = 0; direction =2 ;
                 *  }
                 *  else if (MultiData.currentMultiID == 27) // orc west
                 *  {
                 *      baseMultiID = 24; transformation = new int[2, 2] { { 0, 1 }, { -1, 0 } }; damageLevel = 0; direction = 3;
                 *  }
                 *  else if (MultiData.currentMultiID == 28) // orc north damaged 1
                 *  {
                 *      baseMultiID = 24; transformation = new int[2, 2] { { 1, 0 }, { 0, 1 } }; damageLevel = 1; direction = 0;
                 *  }
                 *  else if (MultiData.currentMultiID == 29) // orc east damaged 1
                 *  {
                 *      baseMultiID = 24; transformation = new int[2, 2] { { 0, -1 }, { 1, 0 } }; damageLevel = 1; direction = 1;
                 *  }
                 *  else if (MultiData.currentMultiID == 30) // orc south damaged 1
                 *  {
                 *      baseMultiID = 24; transformation = new int[2, 2] { { -1, 0 }, { 0, -1 } }; damageLevel = 1; direction = 2;
                 *  }
                 *  else if (MultiData.currentMultiID == 31) // orc west damaged 1
                 *  {
                 *      baseMultiID = 24; transformation = new int[2, 2] { { 0, 1 }, { -1, 0 } }; damageLevel = 1; direction = 3;
                 *  }
                 *  else if (MultiData.currentMultiID == 32) // orc north damaged 2
                 *  {
                 *      baseMultiID = 24; transformation = new int[2, 2] { { 1, 0 }, { 0, 1 } }; damageLevel = 2; direction = 0;
                 *  }
                 *  else if (MultiData.currentMultiID == 33) // orc east damaged 2
                 *  {
                 *      baseMultiID = 24; transformation = new int[2, 2] { { 0, -1 }, { 1, 0 } }; damageLevel = 2; direction = 1;
                 *  }
                 *  else if (MultiData.currentMultiID == 34) // orc south damaged 2
                 *  {
                 *      baseMultiID = 24; transformation = new int[2, 2] { { -1, 0 }, { 0, -1 } }; damageLevel = 2; direction = 2;
                 *  }
                 *  else if (MultiData.currentMultiID == 35) // orc west damaged 2
                 *  {
                 *      baseMultiID = 24; transformation = new int[2, 2] { { 0, 1 }, { -1, 0 } }; damageLevel = 2; direction = 3;
                 *  }
                 *
                 *
                 *
                 *
                 *
                 *
                 *  else if (MultiData.currentMultiID == 36) // gargoyle north BASE
                 *  {
                 *      if (!MultiEntries.ContainsKey(36)) MultiEntries.Add(36, new MultiEntry(36));
                 *      baseMultiID = 36; transformation = new int[2, 2] { { 1, 0 }, { 0, 1 } }; damageLevel = 0; direction = 0;
                 *  }
                 *  else if (MultiData.currentMultiID == 37) // gargoyle east
                 *  {
                 *      baseMultiID = 36; transformation = new int[2, 2] { { 0, -1 }, { 1, 0 } }; damageLevel = 0; direction = 1;
                 *  }
                 *  else if (MultiData.currentMultiID == 38) // gargoyle south
                 *  {
                 *      baseMultiID = 36; transformation = new int[2, 2] { { -1, 0 }, { 0, -1 } }; damageLevel = 0; direction = 2;
                 *  }
                 *  else if (MultiData.currentMultiID == 39) // gargoyle west
                 *  {
                 *      baseMultiID = 36; transformation = new int[2, 2] { { 0, 1 }, { -1, 0 } }; damageLevel = 0; direction = 3;
                 *  }
                 *  else if (MultiData.currentMultiID == 40) // gargoyle north damaged 1
                 *  {
                 *      baseMultiID = 36; transformation = new int[2, 2] { { 1, 0 }, { 0, 1 } }; damageLevel = 1; direction = 0;
                 *  }
                 *  else if (MultiData.currentMultiID == 41) // gargoyle east damaged 1
                 *  {
                 *      baseMultiID = 36; transformation = new int[2, 2] { { 0, -1 }, { 1, 0 } }; damageLevel = 1; direction = 1;
                 *  }
                 *  else if (MultiData.currentMultiID == 42) // gargoyle south damaged 1
                 *  {
                 *      baseMultiID = 36; transformation = new int[2, 2] { { -1, 0 }, { 0, -1 } }; damageLevel = 1; direction = 2;
                 *  }
                 *  else if (MultiData.currentMultiID == 43) // gargoyle west damaged 1
                 *  {
                 *      baseMultiID = 36; transformation = new int[2, 2] { { 0, 1 }, { -1, 0 } }; damageLevel = 1; direction = 3;
                 *  }
                 *  else if (MultiData.currentMultiID == 44) // gargoyle north damaged 2
                 *  {
                 *      baseMultiID = 36; transformation = new int[2, 2] { { 1, 0 }, { 0, 1 } }; damageLevel = 2; direction = 0;
                 *  }
                 *  else if (MultiData.currentMultiID == 45) // gargoyle east damaged 2
                 *  {
                 *      baseMultiID = 36; transformation = new int[2, 2] { { 0, -1 }, { 1, 0 } }; damageLevel = 2; direction = 1;
                 *  }
                 *  else if (MultiData.currentMultiID == 46) // gargoyle south damaged 2
                 *  {
                 *      baseMultiID = 36; transformation = new int[2, 2] { { -1, 0 }, { 0, -1 } }; damageLevel = 2; direction = 2;
                 *  }
                 *  else if (MultiData.currentMultiID == 47) // gargoyle west damaged 2
                 *  {
                 *      baseMultiID = 36; transformation = new int[2, 2] { { 0, 1 }, { -1, 0 } }; damageLevel = 2; direction = 3;
                 *  }
                 *
                 *
                 *
                 *
                 *  else if (MultiData.currentMultiID == 48) // tokuno north BASE
                 *  {
                 *      if (!MultiEntries.ContainsKey(48)) MultiEntries.Add(48, new MultiEntry(48));
                 *      baseMultiID = 48; transformation = new int[2, 2] { { 1, 0 }, { 0, 1 } }; damageLevel = 0; direction = 0;
                 *  }
                 *  else if (MultiData.currentMultiID == 49) // tokuno east
                 *  {
                 *      baseMultiID = 48; transformation = new int[2, 2] { { 0, -1 }, { 1, 0 } }; damageLevel = 0; direction = 1;
                 *  }
                 *  else if (MultiData.currentMultiID == 50) // tokuno south
                 *  {
                 *      baseMultiID = 48; transformation = new int[2, 2] { { -1, 0 }, { 0, -1 } }; damageLevel = 0; direction = 2;
                 *  }
                 *  else if (MultiData.currentMultiID == 51) // tokuno west
                 *  {
                 *      baseMultiID = 48; transformation = new int[2, 2] { { 0, 1 }, { -1, 0 } }; damageLevel = 0; direction = 3;
                 *  }
                 *  else if (MultiData.currentMultiID == 52) // tokuno north damaged 1
                 *  {
                 *      baseMultiID = 48; transformation = new int[2, 2] { { 1, 0 }, { 0, 1 } }; damageLevel = 1; direction = 0;
                 *  }
                 *  else if (MultiData.currentMultiID == 53) // tokuno east damaged 1
                 *  {
                 *      baseMultiID = 48; transformation = new int[2, 2] { { 0, -1 }, { 1, 0 } }; damageLevel = 1; direction = 1;
                 *  }
                 *  else if (MultiData.currentMultiID == 54) // tokuno south damaged 1
                 *  {
                 *      baseMultiID = 48; transformation = new int[2, 2] { { -1, 0 }, { 0, -1 } }; damageLevel = 1; direction = 2;
                 *  }
                 *  else if (MultiData.currentMultiID == 55) // tokuno west damaged 1
                 *  {
                 *      baseMultiID = 48; transformation = new int[2, 2] { { 0, 1 }, { -1, 0 } }; damageLevel = 1; direction = 3;
                 *  }
                 *  else if (MultiData.currentMultiID == 56) // tokuno north damaged 2
                 *  {
                 *      baseMultiID = 48; transformation = new int[2, 2] { { 1, 0 }, { 0, 1 } }; damageLevel = 2; direction = 0;
                 *  }
                 *  else if (MultiData.currentMultiID == 57) // tokuno east damaged 2
                 *  {
                 *      baseMultiID = 48; transformation = new int[2, 2] { { 0, -1 }, { 1, 0 } }; damageLevel = 2; direction = 1;
                 *  }
                 *  else if (MultiData.currentMultiID == 58) // tokuno south damaged 2
                 *  {
                 *      baseMultiID = 48; transformation = new int[2, 2] { { -1, 0 }, { 0, -1 } }; damageLevel = 2; direction = 2;
                 *  }
                 *  else if (MultiData.currentMultiID == 59) // tokuno west damaged 2
                 *  {
                 *      baseMultiID = 48; transformation = new int[2, 2] { { 0, 1 }, { -1, 0 } }; damageLevel = 2; direction = 3;
                 *  }
                 *
                 *
                 *
                 *  if (MultiEntries.ContainsKey(baseMultiID))
                 *  {
                 *      MultiEntry entry = MultiEntries[baseMultiID];
                 *      entry.AddMultiEntryComponent(damageLevel, direction, allTiles[i].m_ItemID, new Point3D(allTiles[i].m_OffsetX, allTiles[i].m_OffsetY, allTiles[i].m_OffsetZ), transformation);
                 *  }
                 *  else
                 *  {
                 *      Console.WriteLine("MultiEntries did not yet contain key " + baseMultiID);
                 *  }
                 * }
                 *
                 * // END ALAN PARSING OUT STUFF ===================================================================
                 */
                if (_PostHSFormat)
                {
                    reader.ReadInt32();                     // ??
                }
                MultiTileEntry e = allTiles[i];

                if (i == 0 || e.m_Flags != 0)
                {
                    if (e.m_OffsetX < m_Min.m_X)
                    {
                        m_Min.m_X = e.m_OffsetX;
                    }

                    if (e.m_OffsetY < m_Min.m_Y)
                    {
                        m_Min.m_Y = e.m_OffsetY;
                    }

                    if (e.m_OffsetX > m_Max.m_X)
                    {
                        m_Max.m_X = e.m_OffsetX;
                    }

                    if (e.m_OffsetY > m_Max.m_Y)
                    {
                        m_Max.m_Y = e.m_OffsetY;
                    }
                }
            }

            m_Center = new Point2D(-m_Min.m_X, -m_Min.m_Y);
            m_Width  = (m_Max.m_X - m_Min.m_X) + 1;
            m_Height = (m_Max.m_Y - m_Min.m_Y) + 1;

            TileList[][] tiles = new TileList[m_Width][];
            m_Tiles = new StaticTile[m_Width][][];

            for (int x = 0; x < m_Width; ++x)
            {
                tiles[x]   = new TileList[m_Height];
                m_Tiles[x] = new StaticTile[m_Height][];

                for (int y = 0; y < m_Height; ++y)
                {
                    tiles[x][y] = new TileList();
                }
            }

            for (int i = 0; i < allTiles.Length; ++i)
            {
                if (i == 0 || allTiles[i].m_Flags != 0)
                {
                    int xOffset = allTiles[i].m_OffsetX + m_Center.m_X;
                    int yOffset = allTiles[i].m_OffsetY + m_Center.m_Y;

                    tiles[xOffset][yOffset].Add((ushort)allTiles[i].m_ItemID, (sbyte)allTiles[i].m_OffsetZ);
                }
            }

            for (int x = 0; x < m_Width; ++x)
            {
                for (int y = 0; y < m_Height; ++y)
                {
                    m_Tiles[x][y] = tiles[x][y].ToArray();
                }
            }
        }
Example #14
0
        public void Add(int itemID, int x, int y, int z)
        {
            int vx = x + Center.X;
            int vy = y + Center.Y;

            if (vx >= 0 && vx < Width && vy >= 0 && vy < Height)
            {
                Tile[] oldTiles = Tiles[vx][vy];

                for (int i = oldTiles.Length - 1; i >= 0; --i)
                {
                    ItemData data = TileData.ItemTable[itemID & TileData.MaxItemValue];

                    if (oldTiles[i].Z == z && (oldTiles[i].Height > 0 == data.Height > 0))
                    {
                        bool newIsRoof = (data.Flags & TileFlag.Roof) != 0;
                        bool oldIsRoof = (TileData.ItemTable[oldTiles[i].ID & TileData.MaxItemValue].Flags & TileFlag.Roof) != 0;

                        if (newIsRoof == oldIsRoof)
                        {
                            Remove(oldTiles[i].ID, x, y, z);
                        }
                    }
                }

                oldTiles = Tiles[vx][vy];

                Tile[] newTiles = new Tile[oldTiles.Length + 1];

                for (int i = 0; i < oldTiles.Length; ++i)
                {
                    newTiles[i] = oldTiles[i];
                }

                newTiles[oldTiles.Length] = new Tile((ushort)itemID, (sbyte)z);

                Tiles[vx][vy] = newTiles;

                MultiTileEntry[] oldList = List;
                MultiTileEntry[] newList = new MultiTileEntry[oldList.Length + 1];

                for (int i = 0; i < oldList.Length; ++i)
                {
                    newList[i] = oldList[i];
                }

                newList[oldList.Length] = new MultiTileEntry((ushort)itemID, (short)x, (short)y, (short)z, 1);

                List = newList;

                if (x < m_Min.X)
                {
                    m_Min.X = x;
                }

                if (y < m_Min.Y)
                {
                    m_Min.Y = y;
                }

                if (x > m_Max.X)
                {
                    m_Max.X = x;
                }

                if (y > m_Max.Y)
                {
                    m_Max.Y = y;
                }
            }
        }
Example #15
0
        public MultiComponentList(GenericReader reader)
        {
            int num3;
            int num4;
            int num5;
            int num6;
            int num7;
            int num8;
            int num9;
            int num10;

            MultiTileEntry[] entryArray2;
            int num11 = reader.ReadInt();

            if (num11 != 0)
            {
                return;
            }
            this.m_Min    = reader.ReadPoint2D();
            this.m_Max    = reader.ReadPoint2D();
            this.m_Center = reader.ReadPoint2D();
            this.m_Width  = reader.ReadInt();
            this.m_Height = reader.ReadInt();
            int num2 = reader.ReadInt();

            this.m_List = (entryArray2 = new MultiTileEntry[num2]);
            MultiTileEntry[] entryArray1 = entryArray2;
            for (num3 = 0; (num3 < num2); ++num3)
            {
                entryArray1[num3].m_ItemID  = reader.ReadShort();
                entryArray1[num3].m_OffsetX = reader.ReadShort();
                entryArray1[num3].m_OffsetY = reader.ReadShort();
                entryArray1[num3].m_OffsetZ = reader.ReadShort();
                entryArray1[num3].m_Flags   = reader.ReadInt();
            }
            TileList[][] listArrayArray1 = new TileList[this.m_Width][];
            this.m_Tiles = new Tile[this.m_Width][][];
            for (num4 = 0; (num4 < this.m_Width); ++num4)
            {
                listArrayArray1[num4] = new TileList[this.m_Height];
                this.m_Tiles[num4]    = new Tile[this.m_Height][];
                for (num5 = 0; (num5 < this.m_Height); ++num5)
                {
                    listArrayArray1[num4][num5] = new TileList();
                }
            }
            for (num6 = 0; (num6 < entryArray1.Length); ++num6)
            {
                if ((num6 == 0) || (entryArray1[num6].m_Flags != 0))
                {
                    num7 = (entryArray1[num6].m_OffsetX + this.m_Center.m_X);
                    num8 = (entryArray1[num6].m_OffsetY + this.m_Center.m_Y);
                    listArrayArray1[num7][num8].Add(((short)((entryArray1[num6].m_ItemID & 16383) | 16384)), ((sbyte)entryArray1[num6].m_OffsetZ));
                }
            }
            for (num9 = 0; (num9 < this.m_Width); ++num9)
            {
                for (num10 = 0; (num10 < this.m_Height); ++num10)
                {
                    this.m_Tiles[num9][num10] = listArrayArray1[num9][num10].ToArray();
                }
            }
        }
Example #16
0
        public MultiComponentList(BinaryReader reader, int count)
        {
            var allTiles = m_List = new MultiTileEntry[count];

            for (int i = 0; i < count; ++i)
            {
                allTiles[i].m_ItemID  = reader.ReadUInt16();
                allTiles[i].m_OffsetX = reader.ReadInt16();
                allTiles[i].m_OffsetY = reader.ReadInt16();
                allTiles[i].m_OffsetZ = reader.ReadInt16();
                allTiles[i].m_Flags   = reader.ReadInt32();

                if (_PostHSFormat)
                {
                    reader.ReadInt32();                     // ??
                }

                MultiTileEntry e = allTiles[i];

                if (i == 0 || e.m_Flags != 0)
                {
                    if (e.m_OffsetX < m_Min.m_X)
                    {
                        m_Min.m_X = e.m_OffsetX;
                    }

                    if (e.m_OffsetY < m_Min.m_Y)
                    {
                        m_Min.m_Y = e.m_OffsetY;
                    }

                    if (e.m_OffsetX > m_Max.m_X)
                    {
                        m_Max.m_X = e.m_OffsetX;
                    }

                    if (e.m_OffsetY > m_Max.m_Y)
                    {
                        m_Max.m_Y = e.m_OffsetY;
                    }
                }
            }

            m_Center = new Point2D(-m_Min.m_X, -m_Min.m_Y);
            m_Width  = (m_Max.m_X - m_Min.m_X) + 1;
            m_Height = (m_Max.m_Y - m_Min.m_Y) + 1;

            var tiles = new TileList[m_Width][];

            m_Tiles = new StaticTile[m_Width][][];

            for (int x = 0; x < m_Width; ++x)
            {
                tiles[x]   = new TileList[m_Height];
                m_Tiles[x] = new StaticTile[m_Height][];

                for (int y = 0; y < m_Height; ++y)
                {
                    tiles[x][y] = new TileList();
                }
            }

            for (int i = 0; i < allTiles.Length; ++i)
            {
                if (i == 0 || allTiles[i].m_Flags != 0)
                {
                    int xOffset = allTiles[i].m_OffsetX + m_Center.m_X;
                    int yOffset = allTiles[i].m_OffsetY + m_Center.m_Y;

                    #region Stygian Abyss
                    //tiles[xOffset][yOffset].Add( (ushort)allTiles[i].m_ItemID, (sbyte)allTiles[i].m_OffsetZ );
                    tiles[xOffset][yOffset].Add(
                        (ushort)((allTiles[i].m_ItemID & TileData.MaxItemValue) | 0x10000), (sbyte)allTiles[i].m_OffsetZ);
                    #endregion
                }
            }

            for (int x = 0; x < m_Width; ++x)
            {
                for (int y = 0; y < m_Height; ++y)
                {
                    m_Tiles[x][y] = tiles[x][y].ToArray();
                }
            }
        }
        public void AddFixtures( Mobile from, MultiTileEntry[] list )
        {
            if ( m_Fixtures == null )
                m_Fixtures = new ArrayList();

            uint keyValue = 0;

            for ( int i = 0; i < list.Length; ++i )
            {
                MultiTileEntry mte = list[i];
                int itemID = mte.m_ItemID & 0x3FFF;

                if ( itemID >= 0x181D && itemID < 0x1829 )
                {
                    HouseTeleporter tp = new HouseTeleporter( itemID );

                    AddFixture( tp, mte );
                }
                else
                {
                    BaseDoor door = null;

                    if ( itemID >= 0x675 && itemID < 0x6F5 )
                    {
                        int type = (itemID - 0x675) / 16;
                        DoorFacing facing = (DoorFacing)(((itemID - 0x675) / 2) % 8);

                        switch ( type )
                        {
                            case 0: door = new GenericHouseDoor( facing, 0x675, 0xEC, 0xF3 ); break;
                            case 1: door = new GenericHouseDoor( facing, 0x685, 0xEC, 0xF3 ); break;
                            case 2: door = new GenericHouseDoor( facing, 0x695, 0xEB, 0xF2 ); break;
                            case 3: door = new GenericHouseDoor( facing, 0x6A5, 0xEA, 0xF1 ); break;
                            case 4: door = new GenericHouseDoor( facing, 0x6B5, 0xEA, 0xF1 ); break;
                            case 5: door = new GenericHouseDoor( facing, 0x6C5, 0xEC, 0xF3 ); break;
                            case 6: door = new GenericHouseDoor( facing, 0x6D5, 0xEA, 0xF1 ); break;
                            case 7: door = new GenericHouseDoor( facing, 0x6E5, 0xEA, 0xF1 ); break;
                        }
                    }
                    else if ( itemID >= 0x314 && itemID < 0x364 )
                    {
                        int type = (itemID - 0x314) / 16;
                        DoorFacing facing = (DoorFacing)(((itemID - 0x314) / 2) % 8);

                        switch ( type )
                        {
                            case 0: door = new GenericHouseDoor( facing, 0x314, 0xED, 0xF4 ); break;
                            case 1: door = new GenericHouseDoor( facing, 0x324, 0xED, 0xF4 ); break;
                            case 2: door = new GenericHouseDoor( facing, 0x334, 0xED, 0xF4 ); break;
                            case 3: door = new GenericHouseDoor( facing, 0x344, 0xED, 0xF4 ); break;
                            case 4: door = new GenericHouseDoor( facing, 0x354, 0xED, 0xF4 ); break;
                        }
                    }
                    else if ( itemID >= 0x824 && itemID < 0x834 )
                    {
                        DoorFacing facing = (DoorFacing)(((itemID - 0x824) / 2) % 8);
                        door = new GenericHouseDoor( facing, 0x824, 0xEC, 0xF3 );
                    }
                    else if ( itemID >= 0x839 && itemID < 0x849 )
                    {
                        DoorFacing facing = (DoorFacing)(((itemID - 0x839) / 2) % 8);
                        door = new GenericHouseDoor( facing, 0x839, 0xEB, 0xF2 );
                    }
                    else if ( itemID >= 0x84C && itemID < 0x85C )
                    {
                        DoorFacing facing = (DoorFacing)(((itemID - 0x84C) / 2) % 8);
                        door = new GenericHouseDoor( facing, 0x84C, 0xEC, 0xF3 );
                    }
                    else if ( itemID >= 0x866 && itemID < 0x876 )
                    {
                        DoorFacing facing = (DoorFacing)(((itemID - 0x866) / 2) % 8);
                        door = new GenericHouseDoor( facing, 0x866, 0xEB, 0xF2 );
                    }
                    else if ( itemID >= 0xE8 && itemID < 0xF8 )
                    {
                        DoorFacing facing = (DoorFacing)(((itemID - 0xE8) / 2) % 8);
                        door = new GenericHouseDoor( facing, 0xE8, 0xED, 0xF4 );
                    }
                    else if ( itemID >= 0x1FED && itemID < 0x1FFD )
                    {
                        DoorFacing facing = (DoorFacing)(((itemID - 0x1FED) / 2) % 8);
                        door = new GenericHouseDoor( facing, 0x1FED, 0xEC, 0xF3 );
                    }
                    else if ( itemID >= 0x241F && itemID < 0x2421 )
                    {
                        //DoorFacing facing = (DoorFacing)(((itemID - 0x241F) / 2) % 8);
                        door = new GenericHouseDoor( DoorFacing.NorthCCW, 0x2415, -1, -1 );
                    }
                    else if ( itemID >= 0x2423 && itemID < 0x2425 )
                    {
                        //DoorFacing facing = (DoorFacing)(((itemID - 0x241F) / 2) % 8);
                        //This one and the above one are 'special' cases, ie: OSI had the ItemID pattern discombobulated for these
                        door = new GenericHouseDoor( DoorFacing.WestCW, 0x2423, -1, -1 );
                    }
                    else if  ( itemID >= 0x2A05 && itemID < 0x2A1D )
                    {
                        DoorFacing facing = (DoorFacing)((((itemID - 0x2A05) / 2) % 4) + 8);

                        int sound = ( itemID >= 0x2A0D && itemID < 0x2a15 ) ? 0x539 : -1;

                        door = new GenericHouseDoor( facing, 0x29F5 + (8 * ((itemID - 0x2A05) / 8)), sound, sound );
                    }

                    if ( door != null )
                    {
                        if ( keyValue == 0 )
                            keyValue = CreateKeys( from );

                        door.Locked = true;
                        door.KeyValue = keyValue;

                        AddDoor( door, mte.m_OffsetX, mte.m_OffsetY, mte.m_OffsetZ );
                        m_Fixtures.Add( door );
                    }
                }
            }

            for ( int i = 0; i < m_Fixtures.Count; ++i )
            {
                Item fixture = (Item)m_Fixtures[i];

                if ( fixture is HouseTeleporter )
                {
                    HouseTeleporter tp = (HouseTeleporter)fixture;

                    for ( int j = 1; j <= m_Fixtures.Count; ++j )
                    {
                        HouseTeleporter check = m_Fixtures[(i + j) % m_Fixtures.Count] as HouseTeleporter;

                        if ( check != null && check.ItemID == tp.ItemID )
                        {
                            tp.Target = check;
                            break;
                        }
                    }
                }
                else if ( fixture is BaseHouseDoor )
                {
                    BaseHouseDoor door = (BaseHouseDoor)fixture;

                    if ( door.Link != null )
                        continue;

                    DoorFacing linkFacing;
                    int xOffset, yOffset;

                    switch ( door.Facing )
                    {
                        default:
                        case DoorFacing.WestCW: linkFacing = DoorFacing.EastCCW; xOffset = 1; yOffset = 0; break;
                        case DoorFacing.EastCCW: linkFacing = DoorFacing.WestCW; xOffset = -1; yOffset = 0; break;
                        case DoorFacing.WestCCW: linkFacing = DoorFacing.EastCW; xOffset = 1; yOffset = 0; break;
                        case DoorFacing.EastCW: linkFacing = DoorFacing.WestCCW; xOffset = -1; yOffset = 0; break;
                        case DoorFacing.SouthCW: linkFacing = DoorFacing.NorthCCW; xOffset = 0; yOffset = -1; break;
                        case DoorFacing.NorthCCW: linkFacing = DoorFacing.SouthCW; xOffset = 0; yOffset = 1; break;
                        case DoorFacing.SouthCCW: linkFacing = DoorFacing.NorthCW; xOffset = 0; yOffset = -1; break;
                        case DoorFacing.NorthCW: linkFacing = DoorFacing.SouthCCW; xOffset = 0; yOffset = 1; break;
                        case DoorFacing.SouthSW: linkFacing = DoorFacing.SouthSE; xOffset = 1; yOffset = 0; break;
                        case DoorFacing.SouthSE: linkFacing = DoorFacing.SouthSW; xOffset = -1; yOffset = 0; break;
                        case DoorFacing.WestSN: linkFacing = DoorFacing.WestSS; xOffset = 0; yOffset = 1; break;
                        case DoorFacing.WestSS: linkFacing = DoorFacing.WestSN; xOffset = 0; yOffset = -1; break;
                    }

                    for ( int j = i + 1; j < m_Fixtures.Count; ++j )
                    {
                        BaseHouseDoor check = m_Fixtures[j] as BaseHouseDoor;

                        if ( check != null && check.Link == null && check.Facing == linkFacing && (check.X - door.X) == xOffset && (check.Y - door.Y) == yOffset && (check.Z == door.Z) )
                        {
                            check.Link = door;
                            door.Link = check;
                            break;
                        }
                    }
                }
            }
        }
Example #18
0
        public void Add(int itemID, int x, int y, int z, bool ignoreRoof)
        {
            itemID &= 0x3FFF;
            itemID |= 0x4000;

            int vx = x + m_Center.m_X;
            int vy = y + m_Center.m_Y;

            if (vx >= 0 && vx < m_Width && vy >= 0 && vy < m_Height)
            {
                Tile[] oldTiles = m_Tiles[vx][vy];

                // adam: we added the ignoreRoof override for our StaticHouses
                if (ignoreRoof == false)
                {
                    for (int i = oldTiles.Length - 1; i >= 0; --i)
                    {
                        ItemData data = TileData.ItemTable[itemID & 0x3FFF];

                        if (oldTiles[i].Z == z && (oldTiles[i].Height > 0 == data.Height > 0))
                        {
                            bool newIsRoof = (data.Flags & TileFlag.Roof) != 0;
                            bool oldIsRoof = (TileData.ItemTable[oldTiles[i].ID & 0x3FFF].Flags & TileFlag.Roof) != 0;

                            if (newIsRoof == oldIsRoof)
                            {
                                Remove(oldTiles[i].ID, x, y, z);
                            }
                        }
                    }
                }

                oldTiles = m_Tiles[vx][vy];

                Tile[] newTiles = new Tile[oldTiles.Length + 1];

                for (int i = 0; i < oldTiles.Length; ++i)
                {
                    newTiles[i] = oldTiles[i];
                }

                newTiles[oldTiles.Length] = new Tile((short)itemID, (sbyte)z);

                m_Tiles[vx][vy] = newTiles;

                MultiTileEntry[] oldList = m_List;
                MultiTileEntry[] newList = new MultiTileEntry[oldList.Length + 1];

                for (int i = 0; i < oldList.Length; ++i)
                {
                    newList[i] = oldList[i];
                }

                newList[oldList.Length] = new MultiTileEntry((short)itemID, (short)x, (short)y, (short)z, 1);

                m_List = newList;

                if (x < m_Min.m_X)
                {
                    m_Min.m_X = x;
                }

                if (y < m_Min.m_Y)
                {
                    m_Min.m_Y = y;
                }

                if (x > m_Max.m_X)
                {
                    m_Max.m_X = x;
                }

                if (y > m_Max.m_Y)
                {
                    m_Max.m_Y = y;
                }
            }
        }
Example #19
0
        public MultiComponentList(IGenericReader reader)
        {
            var version = reader.ReadInt();

            m_Min  = reader.ReadPoint2D();
            m_Max  = reader.ReadPoint2D();
            Center = reader.ReadPoint2D();
            Width  = reader.ReadInt();
            Height = reader.ReadInt();

            var length = reader.ReadInt();

            var allTiles = List = new MultiTileEntry[length];

            if (version == 0)
            {
                for (var i = 0; i < length; ++i)
                {
                    int id = reader.ReadShort();
                    if (id >= 0x4000)
                    {
                        id -= 0x4000;
                    }

                    allTiles[i].ItemId  = (ushort)id;
                    allTiles[i].OffsetX = reader.ReadShort();
                    allTiles[i].OffsetY = reader.ReadShort();
                    allTiles[i].OffsetZ = reader.ReadShort();
                    allTiles[i].Flags   = (TileFlag)reader.ReadInt();
                }
            }
            else
            {
                for (var i = 0; i < length; ++i)
                {
                    allTiles[i].ItemId  = reader.ReadUShort();
                    allTiles[i].OffsetX = reader.ReadShort();
                    allTiles[i].OffsetY = reader.ReadShort();
                    allTiles[i].OffsetZ = reader.ReadShort();
                    allTiles[i].Flags   = (TileFlag)reader.ReadInt();
                }
            }

            var tiles = new TileList[Width][];

            Tiles = new StaticTile[Width][][];

            for (var x = 0; x < Width; ++x)
            {
                tiles[x] = new TileList[Height];
                Tiles[x] = new StaticTile[Height][];

                for (var y = 0; y < Height; ++y)
                {
                    tiles[x][y] = new TileList();
                }
            }

            for (var i = 0; i < allTiles.Length; ++i)
            {
                if (i == 0 || allTiles[i].Flags != 0)
                {
                    var xOffset = allTiles[i].OffsetX + Center.m_X;
                    var yOffset = allTiles[i].OffsetY + Center.m_Y;

                    tiles[xOffset][yOffset].Add(allTiles[i].ItemId, (sbyte)allTiles[i].OffsetZ);
                }
            }

            for (var x = 0; x < Width; ++x)
            {
                for (var y = 0; y < Height; ++y)
                {
                    Tiles[x][y] = tiles[x][y].ToArray();
                }
            }
        }
		public void AddFixtures( Mobile from, MultiTileEntry[] list )
		{
			if( m_Fixtures == null )
				m_Fixtures = new ArrayList();

			uint keyValue = 0;

			for( int i = 0; i < list.Length; ++i )
			{
				MultiTileEntry mte = list[i];
				int itemID = mte.m_ItemID & 0x3FFF;

				if( itemID >= 0x181D && itemID < 0x1829 )
				{
					HouseTeleporter tp = new HouseTeleporter( itemID );

					AddFixture( tp, mte );
				}
				else
				{
					BaseDoor door = null;

					if( itemID >= 0x675 && itemID < 0x6F5 )
					{
						int type = (itemID - 0x675) / 16;
						DoorFacing facing = (DoorFacing)(((itemID - 0x675) / 2) % 8);

						switch( type )
						{
							case 0: door = new GenericHouseDoor( facing, 0x675, 0xEC, 0xF3 ); break;
							case 1: door = new GenericHouseDoor( facing, 0x685, 0xEC, 0xF3 ); break;
							case 2: door = new GenericHouseDoor( facing, 0x695, 0xEB, 0xF2 ); break;
							case 3: door = new GenericHouseDoor( facing, 0x6A5, 0xEA, 0xF1 ); break;
							case 4: door = new GenericHouseDoor( facing, 0x6B5, 0xEA, 0xF1 ); break;
							case 5: door = new GenericHouseDoor( facing, 0x6C5, 0xEC, 0xF3 ); break;
							case 6: door = new GenericHouseDoor( facing, 0x6D5, 0xEA, 0xF1 ); break;
							case 7: door = new GenericHouseDoor( facing, 0x6E5, 0xEA, 0xF1 ); break;
						}
					}
					else if( itemID >= 0x314 && itemID < 0x364 )
					{
						int type = (itemID - 0x314) / 16;
						DoorFacing facing = (DoorFacing)(((itemID - 0x314) / 2) % 8);

						//TODO: Change this to just do a 0x314 + type*16
						switch( type )
						{
							case 0: door = new GenericHouseDoor( facing, 0x314, 0xED, 0xF4 ); break;
							case 1: door = new GenericHouseDoor( facing, 0x324, 0xED, 0xF4 ); break;
							case 2: door = new GenericHouseDoor( facing, 0x334, 0xED, 0xF4 ); break;
							case 3: door = new GenericHouseDoor( facing, 0x344, 0xED, 0xF4 ); break;
							case 4: door = new GenericHouseDoor( facing, 0x354, 0xED, 0xF4 ); break;
						}
					}
					else if( itemID >= 0x824 && itemID < 0x834 )
					{
						DoorFacing facing = (DoorFacing)(((itemID - 0x824) / 2) % 8);
						door = new GenericHouseDoor( facing, 0x824, 0xEC, 0xF3 );
					}
					else if( itemID >= 0x839 && itemID < 0x849 )
					{
						DoorFacing facing = (DoorFacing)(((itemID - 0x839) / 2) % 8);
						door = new GenericHouseDoor( facing, 0x839, 0xEB, 0xF2 );
					}
					else if( itemID >= 0x84C && itemID < 0x85C )
					{
						DoorFacing facing = (DoorFacing)(((itemID - 0x84C) / 2) % 8);
						door = new GenericHouseDoor( facing, 0x84C, 0xEC, 0xF3 );
					}
					else if( itemID >= 0x866 && itemID < 0x876 )
					{
						DoorFacing facing = (DoorFacing)(((itemID - 0x866) / 2) % 8);
						door = new GenericHouseDoor( facing, 0x866, 0xEB, 0xF2 );
					}
					else if( itemID >= 0xE8 && itemID < 0xF8 )
					{
						DoorFacing facing = (DoorFacing)(((itemID - 0xE8) / 2) % 8);
						door = new GenericHouseDoor( facing, 0xE8, 0xED, 0xF4 );
					}
					else if( itemID >= 0x1FED && itemID < 0x1FFD )
					{
						DoorFacing facing = (DoorFacing)(((itemID - 0x1FED) / 2) % 8);
						door = new GenericHouseDoor( facing, 0x1FED, 0xEC, 0xF3 );
					}
					else if( itemID >= 0x241F && itemID < 0x2421 )
					{
						//DoorFacing facing = (DoorFacing)(((itemID - 0x241F) / 2) % 8);
						door = new GenericHouseDoor( DoorFacing.NorthCCW, 0x2415, -1, -1 );
					}
					else if( itemID >= 0x2423 && itemID < 0x2425 )
					{
						//DoorFacing facing = (DoorFacing)(((itemID - 0x241F) / 2) % 8);
						//This one and the above one are 'special' cases, ie: OSI had the ItemID pattern discombobulated for these
						door = new GenericHouseDoor( DoorFacing.WestCW, 0x2423, -1, -1 );
					}
					else if( itemID >= 0x2A05 && itemID < 0x2A1D )
					{
						DoorFacing facing = (DoorFacing)((((itemID - 0x2A05) / 2) % 4) + 8);

						int sound = (itemID >= 0x2A0D && itemID < 0x2a15) ? 0x539 : -1;

						door = new GenericHouseDoor( facing, 0x29F5 + (8 * ((itemID - 0x2A05) / 8)), sound, sound );
					}
					else if( itemID == 0x2D46 )
					{
						door = new GenericHouseDoor( DoorFacing.NorthCW, 0x2D46, 0xEA, 0xF1, false );
					}
					else if( itemID == 0x2D48 || itemID == 0x2FE2 )
					{
						door = new GenericHouseDoor( DoorFacing.SouthCCW, itemID, 0xEA, 0xF1, false );
					}
					else if( itemID >= 0x2D63 && itemID < 0x2D70 )
					{
						int mod = (itemID - 0x2D63)/2%2;
						DoorFacing facing = ( ( mod == 0 ) ? DoorFacing.SouthCCW : DoorFacing.WestCCW );
						
						int type = (itemID - 0x2D63) / 4;

						door = new GenericHouseDoor( facing, 0x2D63 + 4*type + mod*2, 0xEA, 0xF1, false );
					}
					else if( itemID == 0x2FE4 || itemID == 0x31AE )
					{
						door = new GenericHouseDoor( DoorFacing.WestCCW, itemID, 0xEA, 0xF1, false );
					}
					else if( itemID >= 0x319C && itemID < 0x31AE )
					{
						//special case for 0x31aa <-> 0x31a8 (a9)

						int mod = (itemID - 0x319C) / 2 % 2;

						bool specialCase = (itemID == 0x31AA || itemID == 0x31A8);

						DoorFacing facing;

						if ( itemID == 0x31AA || itemID == 0x31A8 )
							facing = ((mod == 0) ? DoorFacing.NorthCW : DoorFacing.EastCW);
						else
							facing = ((mod == 0) ? DoorFacing.EastCW : DoorFacing.NorthCW);

						int type = (itemID - 0x319C) / 4;

						door = new GenericHouseDoor( facing, 0x319C + 4 * type + mod * 2, 0xEA, 0xF1, false );
					}
						
						/*
						* ASayre HATE doors.  ASayre SMASH
					  	WestCCW	EastCW	SoutCCW	NorthCW
						0x31AE*	0x31AC	0x2D48*	0x2D46*	Elvan Wood Door
						0x2d65*	0x31a0	0x2d63*	0x31a2	Elvan White Wooden Door 1
						0x2d69*	0x31a4	0x2d67*	0x31a6	Elvan Ornate Door
						0x2d6d*	0x31aa	0x2d6b*	0x31a8	Elvan Kia Wood Door 2
						0x2fe4*	0x319c	0x2fe2*	0x319e	Elvan Moon Door
					  * 
					  * */

					if( door != null )
					{
						if( keyValue == 0 )
							keyValue = CreateKeys( from );

						door.Locked = true;
						door.KeyValue = keyValue;

						AddDoor( door, mte.m_OffsetX, mte.m_OffsetY, mte.m_OffsetZ );
						m_Fixtures.Add( door );
					}
				}
			}

			for( int i = 0; i < m_Fixtures.Count; ++i )
			{
				Item fixture = (Item)m_Fixtures[i];

				if( fixture is HouseTeleporter )
				{
					HouseTeleporter tp = (HouseTeleporter)fixture;

					for( int j = 1; j <= m_Fixtures.Count; ++j )
					{
						HouseTeleporter check = m_Fixtures[(i + j) % m_Fixtures.Count] as HouseTeleporter;

						if( check != null && check.ItemID == tp.ItemID )
						{
							tp.Target = check;
							break;
						}
					}
				}
				else if( fixture is BaseHouseDoor )
				{
					BaseHouseDoor door = (BaseHouseDoor)fixture;

					if( door.Link != null )
						continue;

					DoorFacing linkFacing;
					int xOffset, yOffset;

					switch( door.Facing )
					{
						default:
						case DoorFacing.WestCW: linkFacing = DoorFacing.EastCCW; xOffset = 1; yOffset = 0; break;
						case DoorFacing.EastCCW: linkFacing = DoorFacing.WestCW; xOffset = -1; yOffset = 0; break;
						case DoorFacing.WestCCW: linkFacing = DoorFacing.EastCW; xOffset = 1; yOffset = 0; break;
						case DoorFacing.EastCW: linkFacing = DoorFacing.WestCCW; xOffset = -1; yOffset = 0; break;
						case DoorFacing.SouthCW: linkFacing = DoorFacing.NorthCCW; xOffset = 0; yOffset = -1; break;
						case DoorFacing.NorthCCW: linkFacing = DoorFacing.SouthCW; xOffset = 0; yOffset = 1; break;
						case DoorFacing.SouthCCW: linkFacing = DoorFacing.NorthCW; xOffset = 0; yOffset = -1; break;
						case DoorFacing.NorthCW: linkFacing = DoorFacing.SouthCCW; xOffset = 0; yOffset = 1; break;
						case DoorFacing.SouthSW: linkFacing = DoorFacing.SouthSE; xOffset = 1; yOffset = 0; break;
						case DoorFacing.SouthSE: linkFacing = DoorFacing.SouthSW; xOffset = -1; yOffset = 0; break;
						case DoorFacing.WestSN: linkFacing = DoorFacing.WestSS; xOffset = 0; yOffset = 1; break;
						case DoorFacing.WestSS: linkFacing = DoorFacing.WestSN; xOffset = 0; yOffset = -1; break;
					}

					for( int j = i + 1; j < m_Fixtures.Count; ++j )
					{
						BaseHouseDoor check = m_Fixtures[j] as BaseHouseDoor;

						if( check != null && check.Link == null && check.Facing == linkFacing && (check.X - door.X) == xOffset && (check.Y - door.Y) == yOffset && (check.Z == door.Z) )
						{
							check.Link = door;
							door.Link = check;
							break;
						}
					}
				}
			}
		}
Example #21
0
        public MultiComponentList(List <MultiTileEntry> list)
        {
            var allTiles = List = new MultiTileEntry[list.Count];

            for (var i = 0; i < list.Count; ++i)
            {
                allTiles[i].ItemId  = list[i].ItemId;
                allTiles[i].OffsetX = list[i].OffsetX;
                allTiles[i].OffsetY = list[i].OffsetY;
                allTiles[i].OffsetZ = list[i].OffsetZ;

                allTiles[i].Flags = list[i].Flags;

                var e = allTiles[i];

                if (i == 0 || e.Flags != 0)
                {
                    if (e.OffsetX < m_Min.m_X)
                    {
                        m_Min.m_X = e.OffsetX;
                    }

                    if (e.OffsetY < m_Min.m_Y)
                    {
                        m_Min.m_Y = e.OffsetY;
                    }

                    if (e.OffsetX > m_Max.m_X)
                    {
                        m_Max.m_X = e.OffsetX;
                    }

                    if (e.OffsetY > m_Max.m_Y)
                    {
                        m_Max.m_Y = e.OffsetY;
                    }
                }
            }

            Center = new Point2D(-m_Min.m_X, -m_Min.m_Y);
            Width  = m_Max.m_X - m_Min.m_X + 1;
            Height = m_Max.m_Y - m_Min.m_Y + 1;

            var tiles = new TileList[Width][];

            Tiles = new StaticTile[Width][][];

            for (var x = 0; x < Width; ++x)
            {
                tiles[x] = new TileList[Height];
                Tiles[x] = new StaticTile[Height][];

                for (var y = 0; y < Height; ++y)
                {
                    tiles[x][y] = new TileList();
                }
            }

            for (var i = 0; i < allTiles.Length; ++i)
            {
                if (i == 0 || allTiles[i].Flags != 0)
                {
                    var xOffset = allTiles[i].OffsetX + Center.m_X;
                    var yOffset = allTiles[i].OffsetY + Center.m_Y;
                    var itemID  = (allTiles[i].ItemId & TileData.MaxItemValue) | 0x10000;

                    tiles[xOffset][yOffset].Add((ushort)itemID, (sbyte)allTiles[i].OffsetZ);
                }
            }

            for (var x = 0; x < Width; ++x)
            {
                for (var y = 0; y < Height; ++y)
                {
                    Tiles[x][y] = tiles[x][y].ToArray();
                }
            }
        }
Example #22
0
 private MultiComponentList()
 {
     Tiles = new StaticTile[0][][];
     List  = new MultiTileEntry[0];
 }
Example #23
0
        public void Remove(int itemID, int x, int y, int z)
        {
            var vx = x + Center.m_X;
            var vy = y + Center.m_Y;

            if (vx >= 0 && vx < Width && vy >= 0 && vy < Height)
            {
                var oldTiles = Tiles[vx][vy];

                for (var i = 0; i < oldTiles.Length; ++i)
                {
                    var tile = oldTiles[i];

                    if (tile.ID == itemID && tile.Z == z)
                    {
                        var newTiles = new StaticTile[oldTiles.Length - 1];

                        for (var j = 0; j < i; ++j)
                        {
                            newTiles[j] = oldTiles[j];
                        }

                        for (var j = i + 1; j < oldTiles.Length; ++j)
                        {
                            newTiles[j - 1] = oldTiles[j];
                        }

                        Tiles[vx][vy] = newTiles;

                        break;
                    }
                }

                var oldList = List;

                for (var i = 0; i < oldList.Length; ++i)
                {
                    var tile = oldList[i];

                    if (tile.ItemId == itemID && tile.OffsetX == (short)x && tile.OffsetY == (short)y &&
                        tile.OffsetZ == (short)z)
                    {
                        var newList = new MultiTileEntry[oldList.Length - 1];

                        for (var j = 0; j < i; ++j)
                        {
                            newList[j] = oldList[j];
                        }

                        for (var j = i + 1; j < oldList.Length; ++j)
                        {
                            newList[j - 1] = oldList[j];
                        }

                        List = newList;

                        break;
                    }
                }
            }
        }
Example #24
0
        public void Resize(int newWidth, int newHeight)
        {
            int oldWidth = Width, oldHeight = Height;

            StaticTile[][][] oldTiles = Tiles;

            int totalLength           = 0;

            StaticTile[][][] newTiles = new StaticTile[newWidth][][];

            for (int x = 0; x < newWidth; ++x)
            {
                newTiles[x] = new StaticTile[newHeight][];

                for (int y = 0; y < newHeight; ++y)
                {
                    if (x < oldWidth && y < oldHeight)
                    {
                        newTiles[x][y] = oldTiles[x][y];
                    }
                    else
                    {
                        newTiles[x][y] = new StaticTile[0];
                    }

                    totalLength += newTiles[x][y].Length;
                }
            }

            Tiles  = newTiles;
            List   = new MultiTileEntry[totalLength];
            Width  = newWidth;
            Height = newHeight;

            m_Min = Point2D.Zero;
            m_Max = Point2D.Zero;

            int index = 0;

            for (int x = 0; x < newWidth; ++x)
            {
                for (int y = 0; y < newHeight; ++y)
                {
                    StaticTile[] tiles = newTiles[x][y];

                    for (int i = 0; i < tiles.Length; ++i)
                    {
                        StaticTile tile = tiles[i];

                        int vx = x - Center.X;
                        int vy = y - Center.Y;

                        if (vx < m_Min.m_X)
                        {
                            m_Min.m_X = vx;
                        }

                        if (vy < m_Min.m_Y)
                        {
                            m_Min.m_Y = vy;
                        }

                        if (vx > m_Max.m_X)
                        {
                            m_Max.m_X = vx;
                        }

                        if (vy > m_Max.m_Y)
                        {
                            m_Max.m_Y = vy;
                        }

                        List[index++] = new MultiTileEntry((ushort)tile.ID, (short)vx, (short)vy, (short)tile.Z, TileFlag.Background);
                    }
                }
            }
        }
Example #25
0
        public MultiComponentList(List <MultiTileEntry> list)
        {
            MultiTileEntry[] allTiles = m_List = new MultiTileEntry[list.Count];

            for (int i = 0; i < list.Count; ++i)
            {
                allTiles[i].m_ItemID  = list[i].m_ItemID;
                allTiles[i].m_OffsetX = list[i].m_OffsetX;
                allTiles[i].m_OffsetY = list[i].m_OffsetY;
                allTiles[i].m_OffsetZ = list[i].m_OffsetZ;

                allTiles[i].m_Flags = list[i].m_Flags;

                MultiTileEntry e = allTiles[i];

                if (i == 0 || e.m_Flags != 0)
                {
                    if (e.m_OffsetX < m_Min.m_X)
                    {
                        m_Min.m_X = e.m_OffsetX;
                    }

                    if (e.m_OffsetY < m_Min.m_Y)
                    {
                        m_Min.m_Y = e.m_OffsetY;
                    }

                    if (e.m_OffsetX > m_Max.m_X)
                    {
                        m_Max.m_X = e.m_OffsetX;
                    }

                    if (e.m_OffsetY > m_Max.m_Y)
                    {
                        m_Max.m_Y = e.m_OffsetY;
                    }
                }
            }

            m_Center = new Point2D(-m_Min.m_X, -m_Min.m_Y);
            m_Width  = m_Max.m_X - m_Min.m_X + 1;
            m_Height = m_Max.m_Y - m_Min.m_Y + 1;

            TileList[][] tiles = new TileList[m_Width][];
            m_Tiles = new StaticTile[m_Width][][];

            for (int x = 0; x < m_Width; ++x)
            {
                tiles[x]   = new TileList[m_Height];
                m_Tiles[x] = new StaticTile[m_Height][];

                for (int y = 0; y < m_Height; ++y)
                {
                    tiles[x][y] = new TileList();
                }
            }

            for (int i = 0; i < allTiles.Length; ++i)
            {
                if (i == 0 || allTiles[i].m_Flags != 0)
                {
                    int xOffset = allTiles[i].m_OffsetX + m_Center.m_X;
                    int yOffset = allTiles[i].m_OffsetY + m_Center.m_Y;
                    int itemID  = (allTiles[i].m_ItemID & TileData.MaxItemValue) | 0x10000;

                    tiles[xOffset][yOffset].Add((ushort)itemID, (sbyte)allTiles[i].m_OffsetZ);
                }
            }

            for (int x = 0; x < m_Width; ++x)
            {
                for (int y = 0; y < m_Height; ++y)
                {
                    m_Tiles[x][y] = tiles[x][y].ToArray();
                }
            }
        }
Example #26
0
        public void Remove(int itemID, int x, int y, int z)
        {
            int vx = x + this.m_Center.m_X;
            int vy = y + this.m_Center.m_Y;

            if (vx >= 0 && vx < this.m_Width && vy >= 0 && vy < this.m_Height)
            {
                StaticTile[] oldTiles = this.m_Tiles[vx][vy];

                for (int i = 0; i < oldTiles.Length; ++i)
                {
                    StaticTile tile = oldTiles[i];

                    if (tile.ID == itemID && tile.Z == z)
                    {
                        StaticTile[] newTiles = new StaticTile[oldTiles.Length - 1];

                        for (int j = 0; j < i; ++j)
                            newTiles[j] = oldTiles[j];

                        for (int j = i + 1; j < oldTiles.Length; ++j)
                            newTiles[j - 1] = oldTiles[j];

                        this.m_Tiles[vx][vy] = newTiles;

                        break;
                    }
                }

                MultiTileEntry[] oldList = this.m_List;

                for (int i = 0; i < oldList.Length; ++i)
                {
                    MultiTileEntry tile = oldList[i];

                    if (tile.m_ItemID == itemID && tile.m_OffsetX == (short)x && tile.m_OffsetY == (short)y && tile.m_OffsetZ == (short)z)
                    {
                        MultiTileEntry[] newList = new MultiTileEntry[oldList.Length - 1];

                        for (int j = 0; j < i; ++j)
                            newList[j] = oldList[j];

                        for (int j = i + 1; j < oldList.Length; ++j)
                            newList[j - 1] = oldList[j];

                        this.m_List = newList;

                        break;
                    }
                }
            }
        }
Example #27
0
        public void Resize(int newWidth, int newHeight)
        {
            int oldWidth = Width, oldHeight = Height;
            var oldTiles = Tiles;

            var totalLength = 0;

            var newTiles = new StaticTile[newWidth][][];

            for (var x = 0; x < newWidth; ++x)
            {
                newTiles[x] = new StaticTile[newHeight][];

                for (var y = 0; y < newHeight; ++y)
                {
                    if (x < oldWidth && y < oldHeight)
                    {
                        newTiles[x][y] = oldTiles[x][y];
                    }
                    else
                    {
                        newTiles[x][y] = new StaticTile[0];
                    }

                    totalLength += newTiles[x][y].Length;
                }
            }

            Tiles  = newTiles;
            m_List = new MultiTileEntry[totalLength];
            Width  = newWidth;
            Height = newHeight;

            m_Min = Point2D.Zero;
            m_Max = Point2D.Zero;

            var index = 0;

            for (var x = 0; x < newWidth; ++x)
            {
                for (var y = 0; y < newHeight; ++y)
                {
                    var tiles = newTiles[x][y];

                    foreach (var tile in tiles)
                    {
                        var vx = x - m_Center.X;
                        var vy = y - m_Center.Y;

                        if (vx < m_Min.m_X)
                        {
                            m_Min.m_X = vx;
                        }

                        if (vy < m_Min.m_Y)
                        {
                            m_Min.m_Y = vy;
                        }

                        if (vx > m_Max.m_X)
                        {
                            m_Max.m_X = vx;
                        }

                        if (vy > m_Max.m_Y)
                        {
                            m_Max.m_Y = vy;
                        }

                        m_List[index++] = new MultiTileEntry((ushort)tile.ID, (short)vx, (short)vy, (short)tile.Z, TileFlag.Background);
                    }
                }
            }
        }
Example #28
0
        public void AddFixtures( Mobile from, MultiTileEntry[] list )
        {
            if( m_Fixtures == null )
                m_Fixtures = new List<Item>();

            uint keyValue = 0;

            for( int i = 0; i < list.Length; ++i )
            {
                MultiTileEntry mte = list[i];
                int itemID = mte.m_ItemID;

                if( itemID >= 0x181D && itemID < 0x1829 )
                {
                    HouseTeleporter tp = new HouseTeleporter( itemID );

                    AddFixture( tp, mte );
                }
                else
                {
                    BaseDoor door = null;

                    if( itemID >= 0x675 && itemID < 0x6F5 )
                    {
                        int type = (itemID - 0x675) / 16;
                        DoorFacing facing = (DoorFacing)(((itemID - 0x675) / 2) % 8);

                        switch( type )
                        {
                            case 0: door = new GenericHouseDoor( facing, 0x675, 0xEC, 0xF3 ); break;
                            case 1: door = new GenericHouseDoor( facing, 0x685, 0xEC, 0xF3 ); break;
                            case 2: door = new GenericHouseDoor( facing, 0x695, 0xEB, 0xF2 ); break;
                            case 3: door = new GenericHouseDoor( facing, 0x6A5, 0xEA, 0xF1 ); break;
                            case 4: door = new GenericHouseDoor( facing, 0x6B5, 0xEA, 0xF1 ); break;
                            case 5: door = new GenericHouseDoor( facing, 0x6C5, 0xEC, 0xF3 ); break;
                            case 6: door = new GenericHouseDoor( facing, 0x6D5, 0xEA, 0xF1 ); break;
                            case 7: door = new GenericHouseDoor( facing, 0x6E5, 0xEA, 0xF1 ); break;
                        }
                    }
                    else if( itemID >= 0x314 && itemID < 0x364 )
                    {
                        int type = (itemID - 0x314) / 16;
                        DoorFacing facing = (DoorFacing)(((itemID - 0x314) / 2) % 8);
                        door = new GenericHouseDoor( facing, 0x314 + ( type * 16 ), 0xED, 0xF4 );
                    }
                    else if( itemID >= 0x824 && itemID < 0x834 )
                    {
                        DoorFacing facing = (DoorFacing)(((itemID - 0x824) / 2) % 8);
                        door = new GenericHouseDoor( facing, 0x824, 0xEC, 0xF3 );
                    }
                    else if( itemID >= 0x839 && itemID < 0x849 )
                    {
                        DoorFacing facing = (DoorFacing)(((itemID - 0x839) / 2) % 8);
                        door = new GenericHouseDoor( facing, 0x839, 0xEB, 0xF2 );
                    }
                    else if( itemID >= 0x84C && itemID < 0x85C )
                    {
                        DoorFacing facing = (DoorFacing)(((itemID - 0x84C) / 2) % 8);
                        door = new GenericHouseDoor( facing, 0x84C, 0xEC, 0xF3 );
                    }
                    else if( itemID >= 0x866 && itemID < 0x876 )
                    {
                        DoorFacing facing = (DoorFacing)(((itemID - 0x866) / 2) % 8);
                        door = new GenericHouseDoor( facing, 0x866, 0xEB, 0xF2 );
                    }
                    else if( itemID >= 0xE8 && itemID < 0xF8 )
                    {
                        DoorFacing facing = (DoorFacing)(((itemID - 0xE8) / 2) % 8);
                        door = new GenericHouseDoor( facing, 0xE8, 0xED, 0xF4 );
                    }
                    else if( itemID >= 0x1FED && itemID < 0x1FFD )
                    {
                        DoorFacing facing = (DoorFacing)(((itemID - 0x1FED) / 2) % 8);
                        door = new GenericHouseDoor( facing, 0x1FED, 0xEC, 0xF3 );
                    }
                    else if( itemID >= 0x241F && itemID < 0x2421 )
                    {
                        //DoorFacing facing = (DoorFacing)(((itemID - 0x241F) / 2) % 8);
                        door = new GenericHouseDoor( DoorFacing.NorthCCW, 0x2415, -1, -1 );
                    }
                    else if( itemID >= 0x2423 && itemID < 0x2425 )
                    {
                        //DoorFacing facing = (DoorFacing)(((itemID - 0x241F) / 2) % 8);
                        //This one and the above one are 'special' cases, ie: OSI had the ItemID pattern discombobulated for these
                        door = new GenericHouseDoor( DoorFacing.WestCW, 0x2423, -1, -1 );
                    }
                    else if( itemID >= 0x2A05 && itemID < 0x2A1D )
                    {
                        DoorFacing facing = (DoorFacing)((((itemID - 0x2A05) / 2) % 4) + 8);

                        int sound = (itemID >= 0x2A0D && itemID < 0x2a15) ? 0x539 : -1;

                        door = new GenericHouseDoor( facing, 0x29F5 + (8 * ((itemID - 0x2A05) / 8)), sound, sound );
                    }
                    else if( itemID == 0x2D46 )
                    {
                        door = new GenericHouseDoor( DoorFacing.NorthCW, 0x2D46, 0xEA, 0xF1, false );
                    }
                    else if( itemID == 0x2D48 || itemID == 0x2FE2 )
                    {
                        door = new GenericHouseDoor( DoorFacing.SouthCCW, itemID, 0xEA, 0xF1, false );
                    }
                    else if( itemID >= 0x2D63 && itemID < 0x2D70 )
                    {
                        int mod = (itemID - 0x2D63)/2%2;
                        DoorFacing facing = ( ( mod == 0 ) ? DoorFacing.SouthCCW : DoorFacing.WestCCW );

                        int type = (itemID - 0x2D63) / 4;

                        door = new GenericHouseDoor( facing, 0x2D63 + 4*type + mod*2, 0xEA, 0xF1, false );
                    }
                    else if( itemID == 0x2FE4 || itemID == 0x31AE )
                    {
                        door = new GenericHouseDoor( DoorFacing.WestCCW, itemID, 0xEA, 0xF1, false );
                    }
                    else if( itemID >= 0x319C && itemID < 0x31AE )
                    {
                        //special case for 0x31aa <-> 0x31a8 (a9)

                        int mod = (itemID - 0x319C) / 2 % 2;

                        bool specialCase = (itemID == 0x31AA || itemID == 0x31A8);

                        DoorFacing facing;

                        if ( itemID == 0x31AA || itemID == 0x31A8 )
                            facing = ((mod == 0) ? DoorFacing.NorthCW : DoorFacing.EastCW);
                        else
                            facing = ((mod == 0) ? DoorFacing.EastCW : DoorFacing.NorthCW);

                        int type = (itemID - 0x319C) / 4;

                        door = new GenericHouseDoor( facing, 0x319C + 4 * type + mod * 2, 0xEA, 0xF1, false );
                    }
                    else if( itemID >= 0x367B && itemID < 0x369B )
                    {
                        int type = (itemID - 0x367B) / 16;
                        DoorFacing facing = (DoorFacing)(((itemID - 0x367B) / 2) % 8);

                        switch( type )
                        {
                            case 0: door = new GenericHouseDoor( facing, 0x367B, 0xED, 0xF4 ); break;	//crystal
                            case 1: door = new GenericHouseDoor( facing, 0x368B, 0xEC, 0x3E7 ); break;	//shadow
                        }
                    }
                    else if( itemID >= 0x409B && itemID < 0x40A3 )
                    {
                        door = new GenericHouseDoor( GetSADoorFacing( itemID - 0x409B ), itemID, 0xEA, 0xF1, false );
                    }
                    else if( itemID >= 0x410C && itemID < 0x4114 )
                    {
                        door = new GenericHouseDoor( GetSADoorFacing( itemID - 0x410C ), itemID, 0xEA, 0xF1, false );
                    }
                    else if( itemID >= 0x41C2 && itemID < 0x41CA )
                    {
                        door = new GenericHouseDoor( GetSADoorFacing( itemID - 0x41C2 ), itemID, 0xEA, 0xF1, false );
                    }
                    else if( itemID >= 0x41CF && itemID < 0x41D7 )
                    {
                        door = new GenericHouseDoor( GetSADoorFacing( itemID - 0x41CF ), itemID, 0xEA, 0xF1, false );
                    }
                    else if( itemID >= 0x436E && itemID < 0x437E )
                    {
                        /* These ones had to be different...
                         * Offset		0	2	4	6	8	10	12	14
                         * DoorFacing	2	3	2	3	6	7	6	7
                         */
                        int offset = itemID - 0x436E;
                        DoorFacing facing = (DoorFacing)( ( offset / 2 + 2 * ( ( 1 + offset / 4 ) % 2 ) ) % 8 );
                        door = new GenericHouseDoor( facing, itemID, 0xEA, 0xF1, false );
                    }
                    else if( itemID >= 0x46DD && itemID < 0x46E5 )
                    {
                        door = new GenericHouseDoor( GetSADoorFacing( itemID - 0x46DD ), itemID, 0xEB, 0xF2, false );
                    }
                    else if( itemID >= 0x4D22 && itemID < 0x4D2A )
                    {
                        door = new GenericHouseDoor( GetSADoorFacing( itemID - 0x4D22 ), itemID, 0xEA, 0xF1, false );
                    }
                    else if( itemID >= 0x50C8 && itemID < 0x50D0 )
                    {
                        door = new GenericHouseDoor( GetSADoorFacing( itemID - 0x50C8 ), itemID, 0xEA, 0xF1, false );
                    }
                    else if( itemID >= 0x50D0 && itemID < 0x50D8 )
                    {
                        door = new GenericHouseDoor( GetSADoorFacing( itemID - 0x50D0 ), itemID, 0xEA, 0xF1, false );
                    }
                    else if( itemID >= 0x5142 && itemID < 0x514A )
                    {
                        door = new GenericHouseDoor( GetSADoorFacing( itemID - 0x5142 ), itemID, 0xF0, 0xEF, false );
                    }

                    if( door != null )
                    {
                        if( keyValue == 0 )
                            keyValue = CreateKeys( from );

                        door.Locked = true;
                        door.KeyValue = keyValue;

                        AddDoor( door, mte.m_OffsetX, mte.m_OffsetY, mte.m_OffsetZ );
                        m_Fixtures.Add( door );
                    }
                }
            }

            for( int i = 0; i < m_Fixtures.Count; ++i )
            {
                Item fixture = m_Fixtures[i];

                if( fixture is HouseTeleporter )
                {
                    HouseTeleporter tp = (HouseTeleporter)fixture;

                    for( int j = 1; j <= m_Fixtures.Count; ++j )
                    {
                        HouseTeleporter check = m_Fixtures[(i + j) % m_Fixtures.Count] as HouseTeleporter;

                        if( check != null && check.ItemID == tp.ItemID )
                        {
                            tp.Target = check;
                            break;
                        }
                    }
                }
                else if( fixture is BaseHouseDoor )
                {
                    BaseHouseDoor door = (BaseHouseDoor)fixture;

                    if( door.Link != null )
                        continue;

                    DoorFacing linkFacing;
                    int xOffset, yOffset;

                    switch( door.Facing )
                    {
                        default:
                        case DoorFacing.WestCW: linkFacing = DoorFacing.EastCCW; xOffset = 1; yOffset = 0; break;
                        case DoorFacing.EastCCW: linkFacing = DoorFacing.WestCW; xOffset = -1; yOffset = 0; break;
                        case DoorFacing.WestCCW: linkFacing = DoorFacing.EastCW; xOffset = 1; yOffset = 0; break;
                        case DoorFacing.EastCW: linkFacing = DoorFacing.WestCCW; xOffset = -1; yOffset = 0; break;
                        case DoorFacing.SouthCW: linkFacing = DoorFacing.NorthCCW; xOffset = 0; yOffset = -1; break;
                        case DoorFacing.NorthCCW: linkFacing = DoorFacing.SouthCW; xOffset = 0; yOffset = 1; break;
                        case DoorFacing.SouthCCW: linkFacing = DoorFacing.NorthCW; xOffset = 0; yOffset = -1; break;
                        case DoorFacing.NorthCW: linkFacing = DoorFacing.SouthCCW; xOffset = 0; yOffset = 1; break;
                        case DoorFacing.SouthSW: linkFacing = DoorFacing.SouthSE; xOffset = 1; yOffset = 0; break;
                        case DoorFacing.SouthSE: linkFacing = DoorFacing.SouthSW; xOffset = -1; yOffset = 0; break;
                        case DoorFacing.WestSN: linkFacing = DoorFacing.WestSS; xOffset = 0; yOffset = 1; break;
                        case DoorFacing.WestSS: linkFacing = DoorFacing.WestSN; xOffset = 0; yOffset = -1; break;
                    }

                    for( int j = i + 1; j < m_Fixtures.Count; ++j )
                    {
                        BaseHouseDoor check = m_Fixtures[j] as BaseHouseDoor;

                        if( check != null && check.Link == null && check.Facing == linkFacing && (check.X - door.X) == xOffset && (check.Y - door.Y) == yOffset && (check.Z == door.Z) )
                        {
                            check.Link = door;
                            door.Link = check;
                            break;
                        }
                    }
                }
            }
        }
Example #29
0
        public void Remove(int itemID, int x, int y, int z)
        {
            int vx = x + m_Center.m_X;
            int vy = y + m_Center.m_Y;

            if (vx >= 0 && vx < m_Width && vy >= 0 && vy < m_Height)
            {
                var oldTiles = m_Tiles[vx][vy];

                for (int i = 0; i < oldTiles.Length; ++i)
                {
                    StaticTile tile = oldTiles[i];

                    if (tile.ID == itemID && tile.Z == z)
                    {
                        var newTiles = new StaticTile[oldTiles.Length - 1];

                        for (int j = 0; j < i; ++j)
                        {
                            newTiles[j] = oldTiles[j];
                        }

                        for (int j = i + 1; j < oldTiles.Length; ++j)
                        {
                            newTiles[j - 1] = oldTiles[j];
                        }

                        m_Tiles[vx][vy] = newTiles;

                        break;
                    }
                }

                var oldList = m_List;

                for (int i = 0; i < oldList.Length; ++i)
                {
                    MultiTileEntry tile = oldList[i];

                    if (tile.m_ItemID == itemID && tile.m_OffsetX == (short)x && tile.m_OffsetY == (short)y &&
                        tile.m_OffsetZ == (short)z)
                    {
                        var newList = new MultiTileEntry[oldList.Length - 1];

                        for (int j = 0; j < i; ++j)
                        {
                            newList[j] = oldList[j];
                        }

                        for (int j = i + 1; j < oldList.Length; ++j)
                        {
                            newList[j - 1] = oldList[j];
                        }

                        m_List = newList;

                        break;
                    }
                }
            }
        }
Example #30
0
        public MultiComponentList(BinaryReader reader, int count)
        {
            MultiTileEntry[] allTiles = m_List = new MultiTileEntry[count];

            for (int i = 0; i < count; ++i)
            {
                allTiles[i].m_ItemID  = reader.ReadInt16();
                allTiles[i].m_OffsetX = reader.ReadInt16();
                allTiles[i].m_OffsetY = reader.ReadInt16();
                allTiles[i].m_OffsetZ = reader.ReadInt16();
                allTiles[i].m_Flags   = reader.ReadInt32();

                MultiTileEntry e = allTiles[i];

                if (i == 0 || e.m_Flags != 0)
                {
                    if (e.m_OffsetX < m_Min.m_X)
                    {
                        m_Min.m_X = e.m_OffsetX;
                    }

                    if (e.m_OffsetY < m_Min.m_Y)
                    {
                        m_Min.m_Y = e.m_OffsetY;
                    }

                    if (e.m_OffsetX > m_Max.m_X)
                    {
                        m_Max.m_X = e.m_OffsetX;
                    }

                    if (e.m_OffsetY > m_Max.m_Y)
                    {
                        m_Max.m_Y = e.m_OffsetY;
                    }
                }
            }

            m_Center = new Point2D(-m_Min.m_X, -m_Min.m_Y);
            m_Width  = (m_Max.m_X - m_Min.m_X) + 1;
            m_Height = (m_Max.m_Y - m_Min.m_Y) + 1;

            TileList[][] tiles = new TileList[m_Width][];
            m_Tiles = new Tile[m_Width][][];

            for (int x = 0; x < m_Width; ++x)
            {
                tiles[x]   = new TileList[m_Height];
                m_Tiles[x] = new Tile[m_Height][];

                for (int y = 0; y < m_Height; ++y)
                {
                    tiles[x][y] = new TileList();
                }
            }

            for (int i = 0; i < allTiles.Length; ++i)
            {
                if (i == 0 || allTiles[i].m_Flags != 0)
                {
                    int xOffset = allTiles[i].m_OffsetX + m_Center.m_X;
                    int yOffset = allTiles[i].m_OffsetY + m_Center.m_Y;

                    tiles[xOffset][yOffset].Add((short)((allTiles[i].m_ItemID & 0x3FFF) | 0x4000), (sbyte)allTiles[i].m_OffsetZ);
                }
            }

            for (int x = 0; x < m_Width; ++x)
            {
                for (int y = 0; y < m_Height; ++y)
                {
                    m_Tiles[x][y] = tiles[x][y].ToArray();
                }
            }
        }
Example #31
0
        public void Add( int itemID, int x, int y, int z )
        {
            int vx = x + m_Center.m_X;
            int vy = y + m_Center.m_Y;

            if ( vx >= 0 && vx < m_Width && vy >= 0 && vy < m_Height )
            {
                StaticTile[] oldTiles = m_Tiles[vx][vy];

                for ( int i = oldTiles.Length - 1; i >= 0; --i )
                {
                    ItemData data = TileData.ItemTable[itemID & TileData.MaxItemValue];

                    if ( oldTiles[i].Z == z && (oldTiles[i].Height > 0 == data.Height > 0 ) )
                    {
                        bool newIsRoof = ( data.Flags & TileFlag.Roof) != 0;
                        bool oldIsRoof = (TileData.ItemTable[oldTiles[i].ID & TileData.MaxItemValue].Flags & TileFlag.Roof ) != 0;

                        if ( newIsRoof == oldIsRoof )
                            Remove( oldTiles[i].ID, x, y, z );
                    }
                }

                oldTiles = m_Tiles[vx][vy];

                StaticTile[] newTiles = new StaticTile[oldTiles.Length + 1];

                for ( int i = 0; i < oldTiles.Length; ++i )
                    newTiles[i] = oldTiles[i];

                newTiles[oldTiles.Length] = new StaticTile( (ushort)itemID, (sbyte)z );

                m_Tiles[vx][vy] = newTiles;

                MultiTileEntry[] oldList = m_List;
                MultiTileEntry[] newList = new MultiTileEntry[oldList.Length + 1];

                for ( int i = 0; i < oldList.Length; ++i )
                    newList[i] = oldList[i];

                newList[oldList.Length] = new MultiTileEntry( (ushort)itemID, (short)x, (short)y, (short)z, 1 );

                m_List = newList;

                if ( x < m_Min.m_X )
                    m_Min.m_X = x;

                if ( y < m_Min.m_Y )
                    m_Min.m_Y = y;

                if ( x > m_Max.m_X )
                    m_Max.m_X = x;

                if ( y > m_Max.m_Y )
                    m_Max.m_Y = y;
            }
        }
Example #32
0
        public void RemoveXYZH( int x, int y, int z, int minHeight )
        {
            int vx = x + m_Center.m_X;
            int vy = y + m_Center.m_Y;

            if ( vx >= 0 && vx < m_Width && vy >= 0 && vy < m_Height )
            {
                StaticTile[] oldTiles = m_Tiles[vx][vy];

                for ( int i = 0; i < oldTiles.Length; ++i )
                {
                    StaticTile tile = oldTiles[i];

                    if ( tile.Z == z && tile.Height >= minHeight )
                    {
                        StaticTile[] newTiles = new StaticTile[oldTiles.Length - 1];

                        for ( int j = 0; j < i; ++j )
                            newTiles[j] = oldTiles[j];

                        for ( int j = i + 1; j < oldTiles.Length; ++j )
                            newTiles[j - 1] = oldTiles[j];

                        m_Tiles[vx][vy] = newTiles;

                        break;
                    }
                }

                MultiTileEntry[] oldList = m_List;

                for ( int i = 0; i < oldList.Length; ++i )
                {
                    MultiTileEntry tile = oldList[i];

                    if ( tile.m_OffsetX == (short)x && tile.m_OffsetY == (short)y && tile.m_OffsetZ == (short)z && TileData.ItemTable[tile.m_ItemID & TileData.MaxItemValue].Height >= minHeight )
                    {
                        MultiTileEntry[] newList = new MultiTileEntry[oldList.Length - 1];

                        for ( int j = 0; j < i; ++j )
                            newList[j] = oldList[j];

                        for ( int j = i + 1; j < oldList.Length; ++j )
                            newList[j - 1] = oldList[j];

                        m_List = newList;

                        break;
                    }
                }
            }
        }
 public void AddFixture( Item item, MultiTileEntry mte )
 {
     m_Fixtures.Add( item );
     item.MoveToWorld( new Point3D( X + mte.m_OffsetX, Y + mte.m_OffsetY, Z + mte.m_OffsetZ ), Map );
 }
Example #34
0
        public void Resize( int newWidth, int newHeight )
        {
            int oldWidth = m_Width, oldHeight = m_Height;
            StaticTile[][][] oldTiles = m_Tiles;

            int totalLength = 0;

            StaticTile[][][] newTiles = new StaticTile[newWidth][][];

            for ( int x = 0; x < newWidth; ++x )
            {
                newTiles[x] = new StaticTile[newHeight][];

                for ( int y = 0; y < newHeight; ++y )
                {
                    if ( x < oldWidth && y < oldHeight )
                        newTiles[x][y] = oldTiles[x][y];
                    else
                        newTiles[x][y] = new StaticTile[0];

                    totalLength += newTiles[x][y].Length;
                }
            }

            m_Tiles = newTiles;
            m_List = new MultiTileEntry[totalLength];
            m_Width = newWidth;
            m_Height = newHeight;

            m_Min = Point2D.Zero;
            m_Max = Point2D.Zero;

            int index = 0;

            for ( int x = 0; x < newWidth; ++x )
            {
                for ( int y = 0; y < newHeight; ++y )
                {
                    StaticTile[] tiles = newTiles[x][y];

                    for ( int i = 0; i < tiles.Length; ++i )
                    {
                        StaticTile tile = tiles[i];

                        int vx = x - m_Center.X;
                        int vy = y - m_Center.Y;

                        if ( vx < m_Min.m_X )
                            m_Min.m_X = vx;

                        if ( vy < m_Min.m_Y )
                            m_Min.m_Y = vy;

                        if ( vx > m_Max.m_X )
                            m_Max.m_X = vx;

                        if ( vy > m_Max.m_Y )
                            m_Max.m_Y = vy;

                        m_List[index++] = new MultiTileEntry( (ushort)tile.ID, (short)vx, (short)vy, (short)tile.Z, 1 );
                    }
                }
            }
        }
        public DesignStateDetailed( int serial, int revision, int xMin, int yMin, int xMax, int yMax, MultiTileEntry[] tiles )
            : base(0xD8)
        {
            EnsureCapacity( 17 + (tiles.Length * 5) );

            Write( (byte) 0x03 ); // Compression Type
            Write( (byte) 0x00 ); // Unknown
            Write( (int) serial );
            Write( (int) revision );
            Write( (short) tiles.Length );
            Write( (short) 0 ); // Buffer length : reserved
            Write( (byte) 0 ); // Plane count : reserved

            int totalLength = 1; // includes plane count

            int width = (xMax - xMin) + 1;
            int height = (yMax - yMin) + 1;

            if ( m_PlaneBuffers == null )
            {
                m_PlaneBuffers = new byte[9][];
                m_PlaneUsed = new bool[9];

                for ( int i = 0; i < m_PlaneBuffers.Length; ++i )
                    m_PlaneBuffers[i] = new byte[0x400];

                m_StairBuffers = new byte[6][];

                for ( int i = 0; i < m_StairBuffers.Length; ++i )
                    m_StairBuffers[i] = new byte[MaxItemsPerStairBuffer * 5];
            }
            else
            {
                for ( int i = 0; i < m_PlaneUsed.Length; ++i )
                    m_PlaneUsed[i] = false;

                Clear( m_PlaneBuffers[0], width * height * 2 );

                for ( int i = 0; i < 4; ++i )
                {
                    Clear( m_PlaneBuffers[1 + i], (width - 1) * (height - 2) * 2 );
                    Clear( m_PlaneBuffers[5 + i], width * (height - 1) * 2 );
                }
            }

            int totalStairsUsed = 0;

            for ( int i = 0; i < tiles.Length; ++i )
            {
                MultiTileEntry mte = tiles[i];
                int x = mte.m_OffsetX - xMin;
                int y = mte.m_OffsetY - yMin;
                int z = mte.m_OffsetZ;
                bool floor = ( TileData.ItemTable[mte.m_ItemID & 0x3FFF].Height <= 0 );
                int plane, size;

                switch ( z )
                {
                    case 0: plane = 0; break;
                    case 7: plane = 1; break;
                    case 27: plane = 2; break;
                    case 47: plane = 3; break;
                    case 67: plane = 4; break;
                    default:
                    {
                        int stairBufferIndex = ( totalStairsUsed / MaxItemsPerStairBuffer );
                        byte[] stairBuffer = m_StairBuffers[stairBufferIndex];

                        int byteIndex = (totalStairsUsed % MaxItemsPerStairBuffer) * 5;

                        stairBuffer[byteIndex++] = (byte) ((mte.m_ItemID >> 8) & 0x3F);
                        stairBuffer[byteIndex++] = (byte) mte.m_ItemID;

                        stairBuffer[byteIndex++] = (byte) mte.m_OffsetX;
                        stairBuffer[byteIndex++] = (byte) mte.m_OffsetY;
                        stairBuffer[byteIndex++] = (byte) mte.m_OffsetZ;

                        ++totalStairsUsed;

                        continue;
                    }
                }

                if ( plane == 0 )
                {
                    size = height;
                }
                else if ( floor )
                {
                    size = height - 2;
                    x -= 1;
                    y -= 1;
                }
                else
                {
                    size = height - 1;
                    plane += 4;
                }

                int index = ((x * size) + y) * 2;

                if ( x < 0 || y < 0 || y >= size || (index + 1) >= 0x400 )
                {
                    int stairBufferIndex = ( totalStairsUsed / MaxItemsPerStairBuffer );
                    byte[] stairBuffer = m_StairBuffers[stairBufferIndex];

                    int byteIndex = (totalStairsUsed % MaxItemsPerStairBuffer) * 5;

                    stairBuffer[byteIndex++] = (byte) ((mte.m_ItemID >> 8) & 0x3F);
                    stairBuffer[byteIndex++] = (byte) mte.m_ItemID;

                    stairBuffer[byteIndex++] = (byte) mte.m_OffsetX;
                    stairBuffer[byteIndex++] = (byte) mte.m_OffsetY;
                    stairBuffer[byteIndex++] = (byte) mte.m_OffsetZ;

                    ++totalStairsUsed;
                }
                else
                {
                    m_PlaneUsed[plane] = true;
                    m_PlaneBuffers[plane][index] = (byte) ((mte.m_ItemID >> 8) & 0x3F);
                    m_PlaneBuffers[plane][index + 1] = (byte) mte.m_ItemID;
                }
            }

            int planeCount = 0;

            for ( int i = 0; i < m_PlaneBuffers.Length; ++i )
            {
                if ( !m_PlaneUsed[i] )
                    continue;

                ++planeCount;

                int size = 0;

                if ( i == 0 )
                    size = width * height * 2;
                else if ( i < 5 )
                    size = (width - 1) * (height - 2) * 2;
                else
                    size = width * (height - 1) * 2;

                byte[] inflatedBuffer = m_PlaneBuffers[i];

                int deflatedLength = m_DeflatedBuffer.Length;
                ZLibError ce = ZLib.compress2( m_DeflatedBuffer, ref deflatedLength, inflatedBuffer, size, ZLibCompressionLevel.Z_DEFAULT_COMPRESSION );

                if ( ce != ZLibError.Z_OK )
                {
                    log.ErrorFormat("ZLib error: {0} (#{1})", ce, (int)ce);
                    deflatedLength = 0;
                    size = 0;
                }

                Write( (byte) (0x20 | i) );
                Write( (byte) size );
                Write( (byte) deflatedLength );
                Write( (byte) (((size >> 4) & 0xF0) | ((deflatedLength >> 8) & 0xF)) );
                Write( m_DeflatedBuffer, 0, deflatedLength );

                totalLength += 4 + deflatedLength;
            }

            int totalStairBuffersUsed = ( totalStairsUsed + (MaxItemsPerStairBuffer - 1) ) / MaxItemsPerStairBuffer;

            for ( int i = 0; i < totalStairBuffersUsed; ++i )
            {
                ++planeCount;

                int count = ( totalStairsUsed - (i * MaxItemsPerStairBuffer) );

                if ( count > MaxItemsPerStairBuffer )
                    count = MaxItemsPerStairBuffer;

                int size = count * 5;

                byte[] inflatedBuffer = m_StairBuffers[i];

                int deflatedLength = m_DeflatedBuffer.Length;
                ZLibError ce = ZLib.compress2( m_DeflatedBuffer, ref deflatedLength, inflatedBuffer, size, ZLibCompressionLevel.Z_DEFAULT_COMPRESSION );

                if ( ce != ZLibError.Z_OK )
                {
                    log.ErrorFormat("ZLib error: {0} (#{1})", ce, (int)ce);
                    deflatedLength = 0;
                    size = 0;
                }

                Write( (byte) (9 + i) );
                Write( (byte) size );
                Write( (byte) deflatedLength );
                Write( (byte) (((size >> 4) & 0xF0) | ((deflatedLength >> 8) & 0xF)) );
                Write( m_DeflatedBuffer, 0, deflatedLength );

                totalLength += 4 + deflatedLength;
            }

            m_Stream.Seek( 15, System.IO.SeekOrigin.Begin );

            Write( (short) totalLength ); // Buffer length
            Write( (byte) planeCount ); // Plane count
        }
Example #36
0
		public void Add(int itemID, int x, int y, int z, bool ignoreRoof)
		{
			itemID &= 0x3FFF;
			itemID |= 0x4000;

			int vx = x + m_Center.m_X;
			int vy = y + m_Center.m_Y;

			if (vx >= 0 && vx < m_Width && vy >= 0 && vy < m_Height)
			{
				Tile[] oldTiles = m_Tiles[vx][vy];

				// adam: we added the ignoreRoof override for our StaticHouses
				if (ignoreRoof == false)
					for (int i = oldTiles.Length - 1; i >= 0; --i)
					{
						ItemData data = TileData.ItemTable[itemID & 0x3FFF];

						if (oldTiles[i].Z == z && (oldTiles[i].Height > 0 == data.Height > 0))
						{
							bool newIsRoof = (data.Flags & TileFlag.Roof) != 0;
							bool oldIsRoof = (TileData.ItemTable[oldTiles[i].ID & 0x3FFF].Flags & TileFlag.Roof) != 0;

							if (newIsRoof == oldIsRoof)
								Remove(oldTiles[i].ID, x, y, z);
						}
					}

				oldTiles = m_Tiles[vx][vy];

				Tile[] newTiles = new Tile[oldTiles.Length + 1];

				for (int i = 0; i < oldTiles.Length; ++i)
					newTiles[i] = oldTiles[i];

				newTiles[oldTiles.Length] = new Tile((short)itemID, (sbyte)z);

				m_Tiles[vx][vy] = newTiles;

				MultiTileEntry[] oldList = m_List;
				MultiTileEntry[] newList = new MultiTileEntry[oldList.Length + 1];

				for (int i = 0; i < oldList.Length; ++i)
					newList[i] = oldList[i];

				newList[oldList.Length] = new MultiTileEntry((short)itemID, (short)x, (short)y, (short)z, 1);

				m_List = newList;

				if (x < m_Min.m_X)
					m_Min.m_X = x;

				if (y < m_Min.m_Y)
					m_Min.m_Y = y;

				if (x > m_Max.m_X)
					m_Max.m_X = x;

				if (y > m_Max.m_Y)
					m_Max.m_Y = y;
			}
		}