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)
{
#if !MONO
_lread(fsData.SafeFileHandle.DangerousGetHandle(), pTiles, 192);
#else
if (m_Buffer == null || 192 > m_Buffer.Length)
{
m_Buffer = new byte[192];
}
fsData.Read(m_Buffer, 0, 192);
fixed(byte *pbBuffer = m_Buffer)
{
Tile *pBuffer = (Tile *)pbBuffer;
Tile *pEnd = pBuffer + 64;
Tile *pCur = pTiles;
while (pBuffer < pEnd)
{
*pCur++ = *pBuffer++;
}
}
#endif
}
matrix.SetLandBlock(x, y, tiles);
}
indexReader.Close();
return(count);
}
}
}
public unsafe static Vector2i StickyTiles(Vector2 Position, Vector2 Velocity, int Width, int Height)
{
Vector2 vector = Position;
int num = ((int)Position.X >> 4) - 1;
int num2 = ((int)Position.X + Width >> 4) + 2;
int num3 = ((int)Position.Y >> 4) - 1;
int num4 = ((int)Position.Y + Height >> 4) + 2;
if (num < 0)
{
num = 0;
}
if (num2 > Main.maxTilesX)
{
num2 = Main.maxTilesX;
}
if (num3 < 0)
{
num3 = 0;
}
if (num4 > Main.maxTilesY)
{
num4 = Main.maxTilesY;
}
fixed(Tile *ptr = Main.tile)
{
for (int i = num; i < num2; i++)
{
Tile *ptr2 = ptr + (i * 1440 + num3);
int num5 = num3;
while (num5 < num4)
{
if (ptr2->type == 51 && ptr2->active != 0)
{
double num6 = i * 16;
double num7 = num5 * 16;
if ((double)(vector.X + (float)Width) > num6 && (double)vector.X < num6 + 16.0 && (double)(vector.Y + (float)Height) > num7 && (double)vector.Y < num7 + 16.01)
{
if (Math.Abs(Velocity.X) + Math.Abs(Velocity.Y) > 0.7f && Main.rand.Next(30) == 0)
{
Main.dust.NewDust(i * 16, num5 * 16, 16, 16, 30);
}
return(new Vector2i(i, num5));
}
}
num5++;
ptr2++;
}
}
}
return(new Vector2i(-1, -1));
}
public unsafe static bool SwitchTiles(Vector2 Position, int Width, int Height, Vector2 oldPosition)
{
int num = ((int)Position.X >> 4) - 1;
int num2 = ((int)Position.X + Width >> 4) + 1;
int num3 = ((int)Position.Y >> 4) - 1;
int num4 = ((int)Position.Y + Height >> 4) + 1;
if (num < 0)
{
num = 0;
}
if (num2 > Main.maxTilesX)
{
num2 = Main.maxTilesX;
}
if (num3 < 0)
{
num3 = 0;
}
if (num4 > Main.maxTilesY)
{
num4 = Main.maxTilesY;
}
fixed(Tile *ptr = Main.tile)
{
for (int i = num; i < num2; i++)
{
Tile *ptr2 = ptr + (i * 1440 + num3);
int num5 = num3;
while (num5 < num4)
{
if (ptr2->type == 135 && ptr2->active != 0)
{
double num6 = i * 16;
double num7 = num5 * 16 + 12;
if ((double)(Position.X + (float)Width) > num6 && (double)Position.X < num6 + 16.0 && (double)(Position.Y + (float)Height) > num7 && (double)Position.Y < num7 + 4.01 && (!((double)(oldPosition.X + (float)Width) > num6) || !((double)oldPosition.X < num6 + 16.0) || !((double)(oldPosition.Y + (float)Height) > num7) || !((double)oldPosition.Y < num7 + 16.01)))
{
WorldGen.hitSwitch(i, num5);
NetMessage.CreateMessage2(59, i, num5);
NetMessage.SendMessage();
return(true);
}
}
num5++;
ptr2++;
}
}
}
return(false);
}
private void RecreateMiniMap()
{
if (_miniMap != null)
{
Memory.HeapFree(_miniMap);
}
if (_width <= MINI_MAP_SIZE && _height <= MINI_MAP_SIZE)
{
MiniMapWidth = _width;
MiniMapHeight = _height;
}
else if (_width > _height)
{
MiniMapWidth = MINI_MAP_SIZE;
MiniMapHeight = (ushort)((float)_height / _width * MINI_MAP_SIZE);
}
else
{
MiniMapHeight = MINI_MAP_SIZE;
MiniMapWidth = (ushort)((float)_width / _height * MINI_MAP_SIZE);
}
MiniMapSize = new ShortSize(MiniMapWidth, MiniMapHeight);
int miniMapArea = MiniMapWidth * MiniMapHeight;
_miniMap = (byte *)Memory.HeapAlloc(miniMapArea / 2);
float xCoef = (float)_width / MiniMapWidth;
float yCoef = (float)_height / MiniMapHeight;
for (int i = 0; i < miniMapArea; i++)
{
ushort mapX = (ushort)(i * xCoef % _width);
ushort mapY = (ushort)(i * xCoef * yCoef / _width);
Tile *tile = &_tiles[mapY * _width + mapX];
byte pxl = (byte)((*tile).Type == TileType.Wall ? 1 : 0);
if (i % 2 == 0)
{
_miniMap[i / 2] = (byte)(pxl << 4);
}
else
{
_miniMap[i / 2] = (byte)(_miniMap[i / 2] | pxl);
}
}
}
public unsafe static bool SolidCollision(ref Vector2 Position, int Width, int Height)
{
float num = Position.X + (float)Width;
float num2 = Position.Y + (float)Height;
int num3 = ((int)Position.X >> 4) - 1;
int num4 = ((int)num >> 4) + 2;
int num5 = ((int)Position.Y >> 4) - 1;
int num6 = ((int)num2 >> 4) + 2;
if (num3 < 0)
{
num3 = 0;
}
if (num4 > Main.maxTilesX)
{
num4 = Main.maxTilesX;
}
if (num5 < 0)
{
num5 = 0;
}
if (num6 > Main.maxTilesY)
{
num6 = Main.maxTilesY;
}
fixed(Tile *ptr = Main.tile)
{
for (int i = num3; i < num4; i++)
{
if (num > (float)(i << 4) && Position.X < (float)(i + 1 << 4))
{
Tile *ptr2 = ptr + (i * 1440 + num5);
int num7 = num5;
while (num7 < num6)
{
if (ptr2->active != 0 && num2 > (float)(num7 << 4) && Position.Y < (float)(num7 + 1 << 4) && Main.tileSolidNotSolidTop[ptr2->type])
{
return(true);
}
num7++;
ptr2++;
}
}
}
}
return(false);
}
public unsafe static void HitTiles(Vector2 Position, Vector2 Velocity, int Width, int Height)
{
Vector2 vector = Position + Velocity;
int num = ((int)Position.X >> 4) - 1;
int num2 = ((int)Position.X + Width >> 4) + 1;
int num3 = ((int)Position.Y >> 4) - 1;
int num4 = ((int)Position.Y + Height >> 4) + 1;
if (num < 0)
{
num = 0;
}
if (num2 > Main.maxTilesX)
{
num2 = Main.maxTilesX;
}
if (num3 < 0)
{
num3 = 0;
}
if (num4 > Main.maxTilesY)
{
num4 = Main.maxTilesY;
}
fixed(Tile *ptr = Main.tile)
{
for (int i = num; i < num2; i++)
{
Tile *ptr2 = ptr + (i * 1440 + num3);
int num5 = num3;
while (num5 < num4)
{
if (ptr2->canStandOnTop())
{
double num6 = i << 4;
double num7 = num5 << 4;
if ((double)(vector.X + (float)Width) >= num6 && (double)vector.X <= num6 + 16.0 && (double)(vector.Y + (float)Height) >= num7 && (double)vector.Y <= num7 + 16.0)
{
WorldGen.KillTile(i, num5, fail: true, effectOnly: true);
}
}
num5++;
ptr2++;
}
}
}
}
private void CheckTilesListCapacity()
{
if (_tilesListCount == _tilesListCapacity)
{
if (_tiles == null)
{
_tilesListCapacity = TILES_LIST_DEF_CAPACITY;
_tiles = (Tile *)Memory.HeapAlloc(_tilesListCapacity * sizeof(Tile), false);
}
else
{
_tilesListCapacity = (ushort)(_tilesListCapacity * TILES_LIST_CAPACITY_INC);
_tiles = (Tile *)Memory.HeapReAlloc(_tiles, _tilesListCapacity * sizeof(Tile), false);
}
}
}
private unsafe Tile[] ReadLandBlock(int x, int y)
{
try
{
m_Map.Seek(((x * m_BlockHeight) + y) * 196 + 4, SeekOrigin.Begin);
Tile[] tiles = new Tile[64];
fixed(Tile *pTiles = tiles)
{
#if !MONO
_lread(m_Map.Handle, pTiles, 192);
#else
if (m_Buffer == null || 192 > m_Buffer.Length)
{
m_Buffer = new byte[192];
}
m_Map.Read(m_Buffer, 0, 192);
fixed(byte *pbBuffer = m_Buffer)
{
Tile *pBuffer = (Tile *)pbBuffer;
Tile *pEnd = pBuffer + 64;
Tile *pCur = pTiles;
while (pBuffer < pEnd)
{
*pCur++ = *pBuffer++;
}
}
#endif
}
return(tiles);
}
catch
{
if (DateTime.Now >= m_NextLandWarning)
{
Console.WriteLine("Warning: Land EOS for {0} ({1}, {2})", m_Owner, x, y);
m_NextLandWarning = DateTime.Now + TimeSpan.FromMinutes(1.0);
}
return(m_InvalidLandBlock);
}
}
internal void TestGameMapPerf()
{
const ushort mapWidth = 1000, mapHeight = 1000;
int count = mapWidth * mapHeight;
HRTimer timer = HRTimer.CreateAndStart();
#if UNSAFE_ARRAY
int sizeOfTile = Marshal.SizeOf(typeof(Tile));
Tile *pTiles = (Tile *)Memory.HeapAlloc(count * sizeOfTile);
#else
Tile[,] aTiles = new Tile[MapWidth, MapHeight];
#endif
System.Console.WriteLine(timer.StopWatch());
timer = HRTimer.CreateAndStart();
for (int i = 0; i < count; i++)
{
#if !UNSAFE_ARRAY
fixed(Tile *pTiles = aTiles)
#endif
{
pTiles[i].Type = TileType.Wall;
pTiles[i].TypeIndex = 100;
}
}
System.Console.WriteLine(timer.StopWatch());
#if UNSAFE_ARRAY
Memory.HeapFree(pTiles);
#endif
using (ServerMap map = new ServerMap(mapWidth, mapHeight, 0))
{
timer = HRTimer.CreateAndStart();
for (ushort y = 0; y < mapHeight; y++)
{
for (ushort x = 0; x < mapWidth; x++)
{
Tile *tile = map[x, y];
(*tile).Type = TileType.Nothing;
(*tile).TypeIndex = 1;
}
}
System.Console.WriteLine(timer.StopWatch());
}
}
private void SetTileType(int x, int y, TileType type, bool set)
{
if (!set)
{
return;
}
if (x >= 0 && y >= 0 && x < _map.Width && y < _map.Height)
{
Tile *tile = _map.SetTileType((ushort)x, (ushort)y, type);
if (tile != null)
{
foreach (IMapRenderer renderer in _renderers)
{
renderer.UpdateTile(this, (ushort)x, (ushort)y, *tile);
}
}
}
}
public unsafe static bool SolidTiles(int startX, int endX, int startY, int endY)
{
if (startX < 0)
{
return(true);
}
if (endX >= Main.maxTilesX)
{
return(true);
}
if (startY < 0)
{
return(true);
}
if (endY >= Main.maxTilesY)
{
return(true);
}
fixed(Tile *ptr = Main.tile)
{
for (int i = startX; i < endX + 1; i++)
{
Tile *ptr2 = ptr + (i * 1440 + startY);
int num = startY;
while (num < endY + 1)
{
if (ptr2->active != 0 && Main.tileSolidNotSolidTop[ptr2->type])
{
return(true);
}
num++;
ptr2++;
}
}
}
return(false);
}
public void ToggleWallUnderCursor(Point location)
{
ShortPoint?tilePos = CursorToTilePos(location);
if (tilePos != null)
{
Tile * tile = _map[tilePos.Value.X, tilePos.Value.Y];
TileType newTileType = (*tile).Type == TileType.Wall ? TileType.Nothing : TileType.Wall;
tile = _map.SetTileType(tilePos.Value.X, tilePos.Value.Y, newTileType);
if (tile != null)
{
foreach (IMapRenderer renderer in _renderers)
{
renderer.UpdateTile(this, tilePos.Value.X, tilePos.Value.Y, *tile);
}
if (TilesChanged != null)
{
TilesChanged(this);
}
}
}
}
private void ReinitializeTilesArray(ushort width, ushort height)
{
if (_tiles != null)
{
Memory.HeapFree(_tiles);
}
_tiles = (Tile*)Memory.HeapAlloc((_width = width) * (_height = height) * sizeof(Tile));
}
private unsafe short[] RenderBlock(int x, int y, bool drawStatics)
{
int mID;
HuedTile[][][] staticBlock;
short[] numArray = new short[64];
Tile[] landBlock = this.m_Tiles.GetLandBlock(x, y);
fixed(short *mColors = &Map.m_Colors[0])
{
fixed(int *heightTable = &TileData.HeightTable[0])
{
fixed(Tile *tilePointer = &landBlock[0])
{
Tile *tilePointer1 = tilePointer;
fixed(short *numPointer = &numArray[0])
{
short *numPointer1 = numPointer;
if (!drawStatics)
{
Tile *tilePointer2 = tilePointer1 + 64 * sizeof(Tile);
while (tilePointer1 < tilePointer2)
{
short *mID1 = numPointer1;
numPointer1 = mID1 + 2;
Tile *tilePointer3 = tilePointer1;
tilePointer1 = tilePointer3 + sizeof(Tile);
*mID1 = (short)(*(mColors + (void *)(*tilePointer3).m_ID * 2));
}
}
else
{
if (drawStatics)
{
staticBlock = this.m_Tiles.GetStaticBlock(x, y);
}
else
{
staticBlock = null;
}
HuedTile[][][] huedTileArray = staticBlock;
int num = 0;
int num1 = 0;
while (num < 8)
{
for (int i = 0; i < 8; i++)
{
int num2 = -255;
int num3 = -255;
int mID2 = 0;
int mHue = 0;
HuedTile[] huedTileArray1 = huedTileArray[i][num];
if ((int)huedTileArray1.Length > 0)
{
fixed(HuedTile *huedTilePointer = &huedTileArray1[0])
{
HuedTile *huedTilePointer1 = huedTilePointer;
HuedTile *length = huedTilePointer1 + (int)huedTileArray1.Length * sizeof(HuedTile);
while (huedTilePointer1 < length)
{
int mZ = (*huedTilePointer1).m_Z;
mID = mZ + *(heightTable + ((*huedTilePointer1).m_ID & 16383) * 4);
if (mID > num2 || mZ > num3 && mID >= num2)
{
num2 = mID;
num3 = mZ;
mID2 = (*huedTilePointer1).m_ID;
mHue = (*huedTilePointer1).m_Hue;
}
huedTilePointer1 = huedTilePointer1 + sizeof(HuedTile);
}
}
}
mID = (*tilePointer1).m_Z;
if (mID > num2)
{
mID2 = (*tilePointer1).m_ID;
mHue = 0;
}
if (mHue != 0)
{
short *colors = numPointer1;
numPointer1 = colors + 2;
*colors = Hues.GetHue(mHue - 1).Colors[*(mColors + mID2 * 2) >> 10 & 31];
}
else
{
short *numPointer2 = numPointer1;
numPointer1 = numPointer2 + 2;
*numPointer2 = *(mColors + mID2 * 2);
}
tilePointer1 = tilePointer1 + sizeof(Tile);
}
num++;
num1 = num1 + 8;
}
}
}
}
}
}
return(numArray);
}
private void Dispose(bool disposing)
{
if (!disposing)
{
Memory.HeapFree(_tiles);
_tiles = null;
}
}
private unsafe short[] RenderBlock(int x, int y, bool drawStatics, bool diff)
{
var data = new short[64];
Tile[] tiles = _tiles.GetLandBlock(x, y, diff);
fixed(short *pColors = RadarCol.Colors)
{
fixed(int *pHeight = TileData.HeightTable)
fixed(Tile * ptTiles = tiles)
{
Tile *pTiles = ptTiles;
fixed(short *pData = data)
{
short *pvData = pData;
if (drawStatics)
{
HuedTile[][][] statics = _tiles.GetStaticBlock(x, y, diff);
for (int k = 0; k < 8; ++k)
{
for (int p = 0; p < 8; ++p)
{
int highTop = -255;
int highZ = -255;
int highId = 0;
int highHue = 0;
int z, top;
bool highStatic = false;
HuedTile[] curStatics = statics[p][k];
if (curStatics.Length > 0)
{
fixed(HuedTile *phtStatics = curStatics)
{
HuedTile *pStatics = phtStatics;
HuedTile *pStaticsEnd = pStatics + curStatics.Length;
while (pStatics < pStaticsEnd)
{
z = pStatics->Z;
top = z + pHeight[pStatics->Id];
if (top > highTop || (z > highZ && top >= highTop))
{
highTop = top;
highZ = z;
highId = pStatics->Id;
highHue = pStatics->Hue;
highStatic = true;
}
++pStatics;
}
}
}
StaticTile[] pending = _tiles.GetPendingStatics(x, y);
if (pending != null)
{
foreach (StaticTile penS in pending)
{
if (penS.X != p || penS.Y != k)
{
continue;
}
z = penS.Z;
top = z + pHeight[penS.Id];
if (top <= highTop && (z <= highZ || top < highTop))
{
continue;
}
highTop = top;
highZ = z;
highId = penS.Id;
highHue = penS.Hue;
highStatic = true;
}
}
top = pTiles->Z;
if (top > highTop)
{
highId = pTiles->Id;
highHue = 0;
highStatic = false;
}
if (highHue == 0)
{
try
{
if (highStatic)
{
*pvData++ = pColors[highId + 0x4000];
}
else
{
*pvData++ = pColors[highId];
}
}
catch
{
// TODO: ignored?
// ignored
}
}
else
{
*pvData++ = Hues.GetHue(highHue - 1)
.Colors[(pColors[highId + 0x4000] >> 10) & 0x1F];
}
++pTiles;
}
}
}
else
{
Tile *pEnd = pTiles + 64;
while (pTiles < pEnd)
{
*pvData++ = pColors[(pTiles++)->Id];
}
}
}
}
}
return(data);
}
public unsafe static void AnyCollision(ref Vector2 Position, ref Vector2 Velocity, int Width, int Height)
{
Vector2 vector = Position + Velocity;
Vector2 vector2 = Position;
int num = ((int)Position.X >> 4) - 1;
int num2 = ((int)Position.X + Width >> 4) + 2;
int num3 = ((int)Position.Y >> 4) - 1;
int num4 = ((int)Position.Y + Height >> 4) + 2;
int num5 = -1;
int num6 = -1;
int num7 = -1;
int num8 = -1;
if (num < 0)
{
num = 0;
}
if (num2 > Main.maxTilesX)
{
num2 = Main.maxTilesX;
}
if (num3 < 0)
{
num3 = 0;
}
if (num4 > Main.maxTilesY)
{
num4 = Main.maxTilesY;
}
fixed(Tile *ptr = Main.tile)
{
for (int i = num; i < num2; i++)
{
double num9 = i << 4;
if ((double)(vector.X + (float)Width) > num9 && (double)vector.X < num9 + 16.0)
{
Tile *ptr2 = ptr + (i * 1440 + num3);
int num10 = num3;
while (num10 < num4)
{
if (ptr2->active != 0)
{
double num11 = num10 << 4;
if ((double)(vector.Y + (float)Height) > num11 && (double)vector.Y < num11 + 16.0)
{
if ((double)(vector2.Y + (float)Height) <= num11)
{
num7 = i;
num8 = num10;
if (num7 != num5)
{
Velocity.Y = (float)(num11 - (double)(vector2.Y + (float)Height));
}
}
else if (!Main.tileSolidTop[ptr2->type])
{
if ((double)(vector2.X + (float)Width) <= num9)
{
num5 = i;
num6 = num10;
if (num6 != num8)
{
Velocity.X = (float)(num9 - (double)(vector2.X + (float)Width));
}
}
else if ((double)vector2.X >= num9 + 16.0)
{
num5 = i;
num6 = num10;
if (num6 != num8)
{
Velocity.X = (float)(num9 + 16.0 - (double)vector2.X);
}
}
else if ((double)vector2.Y >= num11 + 16.0)
{
num7 = i;
num8 = num10;
Velocity.Y = (float)(num11 + 16.0 - (double)vector2.Y + 0.01);
if (num8 == num6)
{
Velocity.X += 0.01f;
}
}
}
}
}
num10++;
ptr2++;
}
}
}
}
}
public TileAdapter(ref Tile tile)
{
_tile = (Tile *)Unsafe.AsPointer(ref tile);
}
public unsafe static void TileCollision(ref Vector2 Position, ref Vector2 Velocity, int Width, int Height, bool fallThrough = false, bool fall2 = false)
{
up = false;
down = false;
Vector2 vector = Velocity;
float num = Position.X + (float)Width;
float num2 = Position.Y + (float)Height;
float num3 = Position.X + Velocity.X;
float num4 = Position.Y + Velocity.Y;
float num5 = num3 + (float)Width;
float num6 = num4 + (float)Height;
int num7 = ((int)Position.X >> 4) - 1;
int num8 = ((int)num >> 4) + 2;
int num9 = ((int)Position.Y >> 4) - 1;
int num10 = ((int)num2 >> 4) + 2;
int num11 = -1;
int num12 = -1;
int num13 = -1;
int num14 = -1;
if (num7 < 0)
{
num7 = 0;
}
if (num8 > Main.maxTilesX)
{
num8 = Main.maxTilesX;
}
if (num9 < 0)
{
num9 = 0;
}
if (num10 > Main.maxTilesY)
{
num10 = Main.maxTilesY;
}
fixed(Tile *ptr = Main.tile)
{
for (int i = num7; i < num8; i++)
{
int num15 = i << 4;
if (num5 > (float)num15 && num3 < (float)(num15 + 16))
{
Tile *ptr2 = ptr + (i * 1440 + num9);
int num16 = num9;
while (num16 < num10)
{
if (ptr2->active != 0)
{
int type = ptr2->type;
bool flag = Main.tileSolidTop[type];
if ((flag && ptr2->frameY == 0) || Main.tileSolid[type])
{
int num17 = num16 << 4;
if (num6 > (float)num17 && num4 < (float)(num17 + 16))
{
if (num2 <= (float)num17)
{
down = true;
if (!flag || !fallThrough || (!(vector.Y <= 1f) && !fall2))
{
num13 = i;
num14 = num16;
if (num13 != num11)
{
Velocity.Y = (float)num17 - num2;
}
}
}
else if (!flag)
{
if (num <= (float)num15)
{
num11 = i;
num12 = num16;
if (num12 != num14)
{
Velocity.X = (float)num15 - num;
}
if (num13 == num11)
{
Velocity.Y = vector.Y;
}
}
else if (Position.X >= (float)(num15 + 16))
{
num11 = i;
num12 = num16;
if (num12 != num14)
{
Velocity.X = (float)(num15 + 16) - Position.X;
}
if (num13 == num11)
{
Velocity.Y = vector.Y;
}
}
else if (Position.Y >= (float)(num17 + 16))
{
up = true;
num13 = i;
num14 = num16;
Velocity.Y = (float)(num17 + 16) - Position.Y;
if (num14 == num12)
{
Velocity.X = vector.X;
}
}
}
}
}
}
num16++;
ptr2++;
}
}
}
}
}
private unsafe short[] RenderBlock(int x, int y, bool drawstatics)
{
short[] data = new short[64];
Tile[] tiles = _tiles.GetLandBlock(x, y);
fixed(Tile *ptTiles = tiles)
{
Tile *ptiles = ptTiles;
fixed(short *pdata = data)
{
short *pvdata = pdata;
if (drawstatics)
{
HuedTile[][][] statics = _tiles.GetStaticBlock(x, y);
for (int k = 0, v = 0; k < 8; k++, v += 8)
{
for (int p = 0; p < 8; p++)
{
int highTop = -255;
int highZ = -255;
int highID = 0;
int highHue = 0;
int z, top;
bool highstatic = false;
HuedTile[] curStatics = statics[p][k];
if (curStatics.Length > 0)
{
fixed(HuedTile *phtStatics = curStatics)
{
HuedTile *pStatics = phtStatics;
HuedTile *pStaticsEnd = pStatics + curStatics.Length;
while (pStatics < pStaticsEnd)
{
z = pStatics->Z;
top = z + TileData.StaticData[pStatics->ID].Height;
if (top > highTop || (z > highZ && top >= highTop))
{
highTop = top;
highZ = z;
highID = pStatics->ID;
highHue = pStatics->Hue;
highstatic = true;
}
++pStatics;
}
}
}
StaticTile[] pending = _tiles.GetPendingStatics(x, y);
if (pending != null)
{
foreach (StaticTile pens in pending)
{
if (pens.X == p && pens.Y == k)
{
z = pens.Z;
top = z + TileData.StaticData[pens.ID].Height;
if (top > highTop || (z > highZ && top >= highTop))
{
highTop = top;
highZ = z;
highID = pens.ID;
highHue = pens.Hue;
highstatic = true;
}
}
}
}
top = ptiles->Z;
if (top > highTop)
{
highID = ptiles->ID;
highHue = 0;
highstatic = false;
}
if (highHue == 0)
{
if (highstatic)
{
*pvdata++ = (short)Hues.GetRadarColorData(highID + 0x4000);
}
else
{
*pvdata++ = (short)Hues.GetRadarColorData(highID);
}
}
else
{
*pvdata++ = (short)Hues.GetColor((ushort)(highHue - 1), (ushort)((Hues.GetRadarColorData(highID + 0x4000) >> 10) & 0x1F));
}
++ptiles;
}
}
}
else
{
Tile *pend = ptiles + 64;
while (ptiles < pend)
{
*pvdata++ = (short)Hues.GetRadarColorData((ptiles++)->ID);
}
}
}
}
return(data);
}
public unsafe static bool DrownCollision(ref Vector2 Position, int Width, int Height, int gravDir)
{
Vector2 vector = Position;
int num = 10;
int num2 = 12;
if (num > Width)
{
num = Width;
}
if (num2 > Height)
{
num2 = Height;
}
vector.X += Width >> 1;
vector.X -= num >> 1;
vector.Y -= 2f;
if (gravDir == -1)
{
vector.Y += (Height >> 1) - 6;
}
int num3 = ((int)Position.X >> 4) - 1;
int num4 = ((int)Position.X + Width >> 4) + 2;
int num5 = ((int)Position.Y >> 4) - 1;
int num6 = ((int)Position.Y + Height >> 4) + 2;
if (num3 < 0)
{
num3 = 0;
}
if (num4 > Main.maxTilesX)
{
num4 = Main.maxTilesX;
}
if (num5 < 0)
{
num5 = 0;
}
if (num6 > Main.maxTilesY)
{
num6 = Main.maxTilesY;
}
fixed(Tile *ptr = Main.tile)
{
for (int i = num3; i < num4; i++)
{
Tile *ptr2 = ptr + (i * 1440 + num5);
int num7 = num5;
while (num7 < num6)
{
int liquid = ptr2->liquid;
if (liquid > 0)
{
int num8 = i << 4;
float num9 = num7 << 4;
float num10 = 256 - liquid;
num10 *= 0.0625f;
num9 += num10;
int num11 = 16 - (int)num10;
if (vector.X + (float)num > (float)num8 && vector.X < (float)(num8 + 16) && vector.Y + (float)num2 > num9 && vector.Y < num9 + (float)num11)
{
return(true);
}
}
num7++;
ptr2++;
}
}
}
return(false);
}
private void CheckTilesListCapacity()
{
if (_tilesListCount == _tilesListCapacity)
{
if (_tiles == null)
{
_tilesListCapacity = TILES_LIST_DEF_CAPACITY;
_tiles = (Tile*) Memory.HeapAlloc(_tilesListCapacity*sizeof (Tile), false);
}
else
{
_tilesListCapacity = (ushort) (_tilesListCapacity*TILES_LIST_CAPACITY_INC);
_tiles = (Tile*) Memory.HeapReAlloc(_tiles, _tilesListCapacity*sizeof (Tile), false);
}
}
}
public void Render(MapControl mapCtrl, Graphics buffer, Rectangle area)
{
ClientMap map = mapCtrl.Map;
if (map == null)
{
return;
}
float scale = mapCtrl.ScaleFactor;
float pixelSize = ConstMap.PIXEL_SIZE * scale;
ushort mapX1 = (ushort)Math.Max(Math.Floor(mapCtrl.PosX / pixelSize - 1), 0);
ushort mapY1 = (ushort)Math.Max(Math.Floor(mapCtrl.PosY / pixelSize - 1), 0);
ushort mapX2 = (ushort)Math.Min(Math.Ceiling(mapCtrl.Width / scale / pixelSize + 2) + mapX1, map.Width);
ushort mapY2 = (ushort)Math.Min(Math.Ceiling(mapCtrl.Height / scale / pixelSize + 2) + mapY1, map.Height);
for (ushort y = mapY1; y < mapY2; y++)
{
for (ushort x = mapX1; x < mapX2; x++)
{
Tile *tile = map[x, y];
if (tile != null && (*tile).Type == TileType.Wall)
{
float x1 = x * pixelSize - mapCtrl.PosX;
float y1 = y * pixelSize - mapCtrl.PosY;
int borders = map.Borders(x, y);
if (borders == 0)
{
borders = TileBorders.ScanAndSetBorders(x, y, TileType.Wall, map);
}
if (borders < 2)
{
continue;
}
float x2, y2;
if ((borders | 2) == borders)
{
y2 = y1 + pixelSize - 0;
buffer.DrawLine(_borderPen, x1, y1, x1, y2);
}
if ((borders | 4) == borders)
{
x2 = x1 + pixelSize - 0;
y2 = y1 + pixelSize - 0;
buffer.DrawLine(_borderPen, x2, y1, x2, y2);
}
if ((borders | 8) == borders)
{
x2 = x1 + pixelSize - 0;
buffer.DrawLine(_borderPen, x1, y1, x2, y1);
}
if ((borders | 16) == borders)
{
x2 = x1 + pixelSize - 0;
y2 = y1 + pixelSize - 0;
buffer.DrawLine(_borderPen, x1, y2, x2, y2);
}
}
}
}
}
private unsafe short[] RenderBlock(int x, int y, bool drawStatics, bool diff)
{
var data = new short[64];
Tile[] tiles = m_Tiles.GetLandBlock(x, y, diff);
fixed(short *pColors = RadarCol.Colors)
{
fixed(int *pHeight = TileData.HeightTable)
{
fixed(Tile *ptTiles = tiles)
{
Tile *pTiles = ptTiles;
fixed(short *pData = data)
{
short *pvData = pData;
if (drawStatics)
{
HuedTile[][][] statics = drawStatics ? m_Tiles.GetStaticBlock(x, y, diff) : null;
for (int k = 0, v = 0; k < 8; ++k, v += 8)
{
for (int p = 0; p < 8; ++p)
{
int highTop = -255;
int highZ = -255;
int highID = 0;
int highHue = 0;
int z, top;
bool highstatic = false;
HuedTile[] curStatics = statics[p][k];
if (curStatics.Length > 0)
{
fixed(HuedTile *phtStatics = curStatics)
{
HuedTile *pStatics = phtStatics;
HuedTile *pStaticsEnd = pStatics + curStatics.Length;
while (pStatics < pStaticsEnd)
{
z = pStatics->m_Z;
top = z + pHeight[pStatics->ID];
if (top > highTop || (z > highZ && top >= highTop))
{
highTop = top;
highZ = z;
highID = pStatics->ID;
highHue = pStatics->Hue;
highstatic = true;
}
++pStatics;
}
}
}
StaticTile[] pending = m_Tiles.GetPendingStatics(x, y);
if (pending != null)
{
foreach (StaticTile penS in pending)
{
if (penS.m_X == p)
{
if (penS.m_Y == k)
{
z = penS.m_Z;
top = z + pHeight[penS.m_ID];
if (top > highTop || (z > highZ && top >= highTop))
{
highTop = top;
highZ = z;
highID = penS.m_ID;
highHue = penS.m_Hue;
highstatic = true;
}
}
}
}
}
top = pTiles->m_Z;
if (top > highTop)
{
highID = pTiles->m_ID;
highHue = 0;
highstatic = false;
}
if (highHue == 0)
{
try
{
if (highstatic)
{
*pvData++ = pColors[highID + 0x4000];
}
else
{
*pvData++ = pColors[highID];
}
}
catch
{ }
}
else
{
*pvData++ = Hues.GetHue(highHue - 1).Colors[(pColors[highID + 0x4000] >> 10) & 0x1F];
}
++pTiles;
}
}
}
else
{
Tile *pEnd = pTiles + 64;
while (pTiles < pEnd)
{
*pvData++ = pColors[(pTiles++)->m_ID];
}
}
}
}
}
}
return(data);
}
public unsafe static int HurtTiles(ref Vector2 Position, ref Vector2 Velocity, int Width, int Height, bool fireImmune = false)
{
int num = ((int)Position.X >> 4) - 1;
int num2 = ((int)Position.X + Width >> 4) + 1;
int num3 = ((int)Position.Y >> 4) - 1;
int num4 = ((int)Position.Y + Height >> 4) + 1;
if (num < 0)
{
num = 0;
}
if (num2 > Main.maxTilesX)
{
num2 = Main.maxTilesX;
}
if (num3 < 0)
{
num3 = 0;
}
if (num4 > Main.maxTilesY)
{
num4 = Main.maxTilesY;
}
fixed(Tile *ptr = Main.tile)
{
for (int i = num; i < num2; i++)
{
Tile *ptr2 = ptr + (i * 1440 + num3);
int num5 = num3;
while (num5 < num4)
{
if (ptr2->active != 0)
{
int type = ptr2->type;
if (type == 32 || type == 37 || type == 48 || type == 53 || type == 57 || type == 58 || type == 69 || type == 76 || type == 112 || type == 116 || type == 123)
{
double num6 = i << 4;
double num7 = num5 << 4;
int result = 0;
switch (type)
{
case 32:
case 69:
case 80:
if ((double)(Position.X + (float)Width) > num6 && (double)Position.X < num6 + 16.0 && (double)(Position.Y + (float)Height) > num7 && (double)Position.Y < num7 + 16.01)
{
result = 10;
switch (type)
{
case 69:
result = 17;
break;
case 80:
result = 6;
break;
}
if ((type == 32 || type == 69) && WorldGen.KillTile(i, num5))
{
NetMessage.CreateMessage5(17, 4, i, num5, 0);
NetMessage.SendMessage();
}
return(result);
}
break;
case 53:
case 112:
case 116:
case 123:
if ((double)(Position.X + (float)Width - 2f) >= num6 && (double)(Position.X + 2f) <= num6 + 16.0 && (double)(Position.Y + (float)Height - 2f) >= num7 && (double)(Position.Y + 2f) <= num7 + 16.0)
{
return(20);
}
break;
default:
if ((double)(Position.X + (float)Width) >= num6 && (double)Position.X <= num6 + 16.0 && (double)(Position.Y + (float)Height) >= num7 && (double)Position.Y <= num7 + 16.01)
{
if (type == 48)
{
result = 40;
}
else if (!fireImmune && (type == 37 || type == 58 || type == 76))
{
result = 20;
}
return(result);
}
break;
}
}
}
num5++;
ptr2++;
}
}
}
return(0);
}
private unsafe short[] RenderBlock(int x, int y, bool drawStatics)
{
short[] data = new short[64];
Tile[] tiles = m_Tiles.GetLandBlock(x, y);
fixed(short *pColors = m_Colors)
{
fixed(int *pHeight = TileData.HeightTable)
{
fixed(Tile *ptTiles = tiles)
{
Tile *pTiles = ptTiles;
fixed(short *pData = data)
{
short *pvData = pData;
if (drawStatics)
{
HuedTile[][][] statics = drawStatics ? m_Tiles.GetStaticBlock(x, y) : null;
for (int k = 0, v = 0; k < 8; ++k, v += 8)
{
for (int p = 0; p < 8; ++p)
{
int highTop = -255;
int highZ = -255;
int highID = 0;
int highHue = 0;
int z, top;
HuedTile[] curStatics = statics[p][k];
if (curStatics.Length > 0)
{
fixed(HuedTile *phtStatics = curStatics)
{
HuedTile *pStatics = phtStatics;
HuedTile *pStaticsEnd = pStatics + curStatics.Length;
while (pStatics < pStaticsEnd)
{
z = pStatics->m_Z;
top = z + pHeight[pStatics->m_ID & 0x3FFF];
if (top > highTop || (z > highZ && top >= highTop))
{
highTop = top;
highZ = z;
highID = pStatics->m_ID;
highHue = pStatics->m_Hue;
}
++pStatics;
}
}
}
top = pTiles->m_Z;
if (top > highTop)
{
highID = pTiles->m_ID;
highHue = 0;
}
if (highHue == 0)
{
*pvData++ = pColors[highID];
}
else
{
*pvData++ = Hues.GetHue(highHue - 1).Colors[(pColors[highID] >> 10) & 0x1F];
}
++pTiles;
}
}
}
else
{
Tile *pEnd = pTiles + 64;
while (pTiles < pEnd)
{
*pvData++ = pColors[(pTiles++)->m_ID];
}
}
}
}
}
}
return(data);
}
private unsafe short[] RenderBlock(int x, int y, bool drawStatics)
{
short[] numArray = new short[64];
Tile[] landBlock = this.m_Tiles.GetLandBlock(x, y);
fixed(short *numPtr1 = &Map.m_Colors[0])
fixed(int *numPtr2 = &TileData.HeightTable[0])
fixed(Tile * tilePtr1 = &landBlock[0])
{
Tile *tilePtr2 = tilePtr1;
fixed(short *numPtr3 = &numArray[0])
{
short *numPtr4 = numPtr3;
if (drawStatics)
{
HuedTile[][][] huedTileArray1 = drawStatics ? this.m_Tiles.GetStaticBlock(x, y) : (HuedTile[][][])null;
int index1 = 0;
int num1 = 0;
while (index1 < 8)
{
for (int index2 = 0; index2 < 8; ++index2)
{
int num2 = -255;
int num3 = -255;
int index3 = 0;
int num4 = 0;
HuedTile[] huedTileArray2 = huedTileArray1[index2][index1];
if (huedTileArray2.Length > 0)
{
fixed(HuedTile *huedTilePtr1 = &huedTileArray2[0])
{
HuedTile *huedTilePtr2 = huedTilePtr1;
for (HuedTile *huedTilePtr3 = huedTilePtr2 + huedTileArray2.Length; huedTilePtr2 < huedTilePtr3; ++huedTilePtr2)
{
int num5 = (int)huedTilePtr2->m_Z;
int num6 = num5 + numPtr2[(int)huedTilePtr2->m_ID & 16383];
if (num6 > num2 || num5 > num3 && num6 >= num2)
{
num2 = num6;
num3 = num5;
index3 = (int)huedTilePtr2->m_ID;
num4 = (int)huedTilePtr2->m_Hue;
}
}
}
}
if ((int)tilePtr2->m_Z > num2)
{
index3 = (int)tilePtr2->m_ID;
num4 = 0;
}
*numPtr4++ = num4 != 0 ? Hues.GetHue(num4 - 1).Colors[(int)numPtr1[index3] >> 10 & 31] : numPtr1[index3];
++tilePtr2;
}
++index1;
num1 += 8;
}
}
else
{
Tile *tilePtr3 = tilePtr2 + 64;
while (tilePtr2 < tilePtr3)
{
*numPtr4++ = numPtr1[tilePtr2++->m_ID];
}
}
}
}
return(numArray);
}
