Overwrite

Complete Overwrite of the Folder with the free shard. ServUO 57.3 has been added.

Server/TileMatrixPatch.cs

@@ -0,0 +1,188 @@
+#region References
+using System.IO;
+using System.Runtime.CompilerServices;
+#endregion
+
+namespace Server
+{
+	public class TileMatrixPatch
+	{
+		private readonly int m_LandBlocks;
+		private readonly int m_StaticBlocks;
+
+		private static bool m_Enabled = true;
+
+		public static bool Enabled { get { return m_Enabled; } set { m_Enabled = value; } }
+
+		public int LandBlocks
+		{
+			get
+			{
+				lock (this)
+					return m_LandBlocks;
+			}
+		}
+
+		public int StaticBlocks
+		{
+			get
+			{
+				lock (this)
+					return m_StaticBlocks;
+			}
+		}
+
+		public TileMatrixPatch(TileMatrix matrix, int index)
+		{
+			if (!m_Enabled)
+			{
+				return;
+			}
+
+			string mapDataPath = Core.FindDataFile("mapdif{0}.mul", index);
+			string mapIndexPath = Core.FindDataFile("mapdifl{0}.mul", index);
+
+			if (File.Exists(mapDataPath) && File.Exists(mapIndexPath))
+			{
+				m_LandBlocks = PatchLand(matrix, mapDataPath, mapIndexPath);
+			}
+
+			string staDataPath = Core.FindDataFile("stadif{0}.mul", index);
+			string staIndexPath = Core.FindDataFile("stadifl{0}.mul", index);
+			string staLookupPath = Core.FindDataFile("stadifi{0}.mul", index);
+
+			if (File.Exists(staDataPath) && File.Exists(staIndexPath) && File.Exists(staLookupPath))
+			{
+				m_StaticBlocks = PatchStatics(matrix, staDataPath, staIndexPath, staLookupPath);
+			}
+		}
+
+		[MethodImpl(MethodImplOptions.Synchronized)]
+		private unsafe int PatchLand(TileMatrix matrix, string dataPath, string indexPath)
+		{
+			using (FileStream fsData = new FileStream(dataPath, FileMode.Open, FileAccess.Read, FileShare.Read))
+			{
+				using (FileStream fsIndex = new FileStream(indexPath, FileMode.Open, FileAccess.Read, FileShare.Read))
+				{
+					BinaryReader indexReader = new BinaryReader(fsIndex);
+
+					int count = (int)(indexReader.BaseStream.Length / 4);
+
+					for (int i = 0; i < count; ++i)
+					{
+						int blockID = indexReader.ReadInt32();
+						int x = blockID / matrix.BlockHeight;
+						int y = blockID % matrix.BlockHeight;
+
+						fsData.Seek(4, SeekOrigin.Current);
+
+						var tiles = new LandTile[64];
+
+						fixed (LandTile* pTiles = tiles)
+						{
+							NativeReader.Read(fsData.SafeFileHandle.DangerousGetHandle(), pTiles, 192);
+						}
+
+						matrix.SetLandBlock(x, y, tiles);
+					}
+
+					indexReader.Close();
+
+					return count;
+				}
+			}
+		}
+
+		private StaticTile[] m_TileBuffer = new StaticTile[128];
+
+		[MethodImpl(MethodImplOptions.Synchronized)]
+		private unsafe int PatchStatics(TileMatrix matrix, string dataPath, string indexPath, string lookupPath)
+		{
+			using (FileStream fsData = new FileStream(dataPath, FileMode.Open, FileAccess.Read, FileShare.Read))
+			{
+				using (FileStream fsIndex = new FileStream(indexPath, FileMode.Open, FileAccess.Read, FileShare.Read))
+				{
+					using (FileStream fsLookup = new FileStream(lookupPath, FileMode.Open, FileAccess.Read, FileShare.Read))
+					{
+						BinaryReader indexReader = new BinaryReader(fsIndex);
+						BinaryReader lookupReader = new BinaryReader(fsLookup);
+
+						int count = (int)(indexReader.BaseStream.Length / 4);
+
+						var lists = new TileList[8][];
+
+						for (int x = 0; x < 8; ++x)
+						{
+							lists[x] = new TileList[8];
+
+							for (int y = 0; y < 8; ++y)
+							{
+								lists[x][y] = new TileList();
+							}
+						}
+
+						for (int i = 0; i < count; ++i)
+						{
+							int blockID = indexReader.ReadInt32();
+							int blockX = blockID / matrix.BlockHeight;
+							int blockY = blockID % matrix.BlockHeight;
+
+							int offset = lookupReader.ReadInt32();
+							int length = lookupReader.ReadInt32();
+							lookupReader.ReadInt32(); // Extra
+
+							if (offset < 0 || length <= 0)
+							{
+								matrix.SetStaticBlock(blockX, blockY, matrix.EmptyStaticBlock);
+								continue;
+							}
+
+							fsData.Seek(offset, SeekOrigin.Begin);
+
+							int tileCount = length / 7;
+
+							if (m_TileBuffer.Length < tileCount)
+							{
+								m_TileBuffer = new StaticTile[tileCount];
+							}
+
+							var staTiles = m_TileBuffer;
+
+							fixed (StaticTile* pTiles = staTiles)
+							{
+								NativeReader.Read(fsData.SafeFileHandle.DangerousGetHandle(), pTiles, length);
+								
+								StaticTile* pCur = pTiles, pEnd = pTiles + tileCount;
+
+								while (pCur < pEnd)
+								{
+									lists[pCur->m_X & 0x7][pCur->m_Y & 0x7].Add(pCur->m_ID, pCur->m_Z);
+									pCur = pCur + 1;
+								}
+
+								var tiles = new StaticTile[8][][];
+
+								for (int x = 0; x < 8; ++x)
+								{
+									tiles[x] = new StaticTile[8][];
+
+									for (int y = 0; y < 8; ++y)
+									{
+										tiles[x][y] = lists[x][y].ToArray();
+									}
+								}
+
+								matrix.SetStaticBlock(blockX, blockY, tiles);
+							}
+						}
+
+						indexReader.Close();
+						lookupReader.Close();
+
+						return count;
+					}
+				}
+			}
+		}
+	}
+}