SetLandBlock() public method

public SetLandBlock ( int x, int y, Tile value ) : void
x int
y int
value Tile
return void
Esempio n. 1
0
		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 );

						Tile[] tiles = new Tile[64];

						fixed ( Tile *pTiles = tiles )
						{
                            NativeMethods._lread(fsData.SafeFileHandle, pTiles, 192);
						}

						matrix.SetLandBlock( x, y, tiles );
					}

					return count;
				}
			}
		}
Esempio n. 2
0
        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);

                        Tile[] tiles = new Tile[64];

                        fixed(Tile *pTiles = tiles)
                        {
                            _lread(fsData.Handle, pTiles, 192);
                        }

                        matrix.SetLandBlock(x, y, tiles);
                    }

                    return(count);
                }
            }
        }
Esempio n. 3
0
        private unsafe int PatchLand(TileMatrix matrix, string dataPath, string indexPath)
        {
            using (FileStream fileStream1 = new FileStream(dataPath, FileMode.Open, FileAccess.Read, FileShare.Read))
            {
                using (FileStream fileStream2 = new FileStream(indexPath, FileMode.Open, FileAccess.Read, FileShare.Read))
                {
                    BinaryReader binaryReader = new BinaryReader((Stream)fileStream2);
                    int          num1         = (int)(binaryReader.BaseStream.Length / 4L);
                    for (int index = 0; index < num1; ++index)
                    {
                        int num2 = binaryReader.ReadInt32();
                        int x    = num2 / matrix.BlockHeight;
                        int y    = num2 % matrix.BlockHeight;
                        fileStream1.Seek(4L, SeekOrigin.Current);
                        Tile[] tileArray = new Tile[64];

                        fixed(Tile *tilePtr = &tileArray[0])
                        TileMatrixPatch._lread(fileStream1.Handle, (void *)tilePtr, 192);

                        matrix.SetLandBlock(x, y, tileArray);
                    }
                    return(num1);
                }
            }
        }
 private unsafe int PatchLand(TileMatrix matrix, string dataPath, string indexPath)
 {
     using (FileStream fileStream1 = new FileStream(dataPath, FileMode.Open, FileAccess.Read, FileShare.Read))
       {
     using (FileStream fileStream2 = new FileStream(indexPath, FileMode.Open, FileAccess.Read, FileShare.Read))
     {
       BinaryReader binaryReader = new BinaryReader((Stream) fileStream2);
       int num1 = (int) (binaryReader.BaseStream.Length / 4L);
       for (int index = 0; index < num1; ++index)
       {
     int num2 = binaryReader.ReadInt32();
     int x = num2 / matrix.BlockHeight;
     int y = num2 % matrix.BlockHeight;
     fileStream1.Seek(4L, SeekOrigin.Current);
     Tile[] tileArray = new Tile[64];
     fixed (Tile* tilePtr = &tileArray[0])
       TileMatrixPatch._lread(fileStream1.Handle, (void*) tilePtr, 192);
     matrix.SetLandBlock(x, y, tileArray);
       }
       return num1;
     }
       }
 }
Esempio n. 5
0
 private int PatchLand(TileMatrix matrix, string dataPath, string indexPath)
 {
     unsafe
     {
         int num;
         using (FileStream fileStream = new FileStream(dataPath, FileMode.Open, FileAccess.Read, FileShare.Read))
         {
             using (FileStream fileStream1 = new FileStream(indexPath, FileMode.Open, FileAccess.Read, FileShare.Read))
             {
                 BinaryReader binaryReader = new BinaryReader(fileStream1);
                 int          length       = (int)(binaryReader.BaseStream.Length / (long)4);
                 for (int i = 0; i < length; i++)
                 {
                     int num1         = binaryReader.ReadInt32();
                     int blockHeight  = num1 / matrix.BlockHeight;
                     int blockHeight1 = num1 % matrix.BlockHeight;
                     fileStream.Seek((long)4, SeekOrigin.Current);
                     Tile[] tileArray = new Tile[64];
                     try
                     {
                         fixed(Tile *tilePointer = &tileArray[0])
                         {
                             TileMatrixPatch._lread(fileStream.Handle, tilePointer, 192);
                         }
                     }
                     finally
                     {
                         tilePointer = null;
                     }
                     matrix.SetLandBlock(blockHeight, blockHeight1, tileArray);
                 }
                 num = length;
             }
         }
         return(num);
     }
 }