internal unsafe void ReloadBlock(int map, int blocknum)
{
int mapblocksize = UnsafeMemoryManager.SizeOf <MapBlock>();
int staticidxblocksize = UnsafeMemoryManager.SizeOf <StaidxBlock>();
int staticblocksize = UnsafeMemoryManager.SizeOf <StaticsBlock>();
UOFile file = _filesMap[map];
UOFile fileidx = _filesIdxStatics[map];
UOFile staticfile = _filesStatics[map];
ulong staticidxaddress = (ulong)fileidx.StartAddress;
ulong endstaticidxaddress = staticidxaddress + (ulong)fileidx.Length;
ulong staticaddress = (ulong)staticfile.StartAddress;
ulong endstaticaddress = staticaddress + (ulong)staticfile.Length;
ulong mapddress = (ulong)file.StartAddress;
ulong endmapaddress = mapddress + (ulong)file.Length;
ulong uopoffset = 0;
int fileNumber = -1;
bool isuop = file is UOFileUop;
ulong realmapaddress = 0, realstaticaddress = 0;
uint realstaticcount = 0;
int block = blocknum;
if (isuop)
{
blocknum &= 4095;
int shifted = block >> 12;
if (fileNumber != shifted)
{
fileNumber = shifted;
if (shifted < Entries.Length)
{
uopoffset = (ulong)Entries[map][shifted].Offset;
}
}
}
ulong address = mapddress + uopoffset + (ulong)(blocknum * mapblocksize);
if (address < endmapaddress)
{
realmapaddress = address;
}
ulong stidxaddress = staticidxaddress + (ulong)(block * staticidxblocksize);
StaidxBlock *bb = (StaidxBlock *)stidxaddress;
if (stidxaddress < endstaticidxaddress && bb->Size > 0 && bb->Position != 0xFFFFFFFF)
{
ulong address1 = staticaddress + bb->Position;
if (address1 < endstaticaddress)
{
realstaticaddress = address1;
realstaticcount = (uint)(bb->Size / staticblocksize);
if (realstaticcount > 1024)
{
realstaticcount = 1024;
}
}
}
ref var data = ref BlockData[map][block];
internal unsafe void LoadMap(int i)
{
if (i < 0 || i + 1 > Constants.MAPS_COUNT || _filesMap[i] == null)
{
i = 0;
}
if (BlockData[i] != null || _filesMap[i] == null)
{
return;
}
int mapblocksize = sizeof(MapBlock);
int staticidxblocksize = sizeof(StaidxBlock);
int staticblocksize = sizeof(StaticsBlock);
int width = MapBlocksSize[i, 0];
int height = MapBlocksSize[i, 1];
int maxblockcount = width * height;
BlockData[i] = new IndexMap[maxblockcount];
UOFile file = _filesMap[i];
UOFile fileidx = _filesIdxStatics[i];
UOFile staticfile = _filesStatics[i];
if (fileidx == null && i == 1)
{
fileidx = _filesIdxStatics[0];
}
if (staticfile == null && i == 1)
{
staticfile = _filesStatics[0];
}
ulong staticidxaddress = (ulong)fileidx.StartAddress;
ulong endstaticidxaddress = staticidxaddress + (ulong)fileidx.Length;
ulong staticaddress = (ulong)staticfile.StartAddress;
ulong endstaticaddress = staticaddress + (ulong)staticfile.Length;
ulong mapddress = (ulong)file.StartAddress;
ulong endmapaddress = mapddress + (ulong)file.Length;
ulong uopoffset = 0;
int fileNumber = -1;
bool isuop = file is UOFileUop;
for (int block = 0; block < maxblockcount; block++)
{
ulong realmapaddress = 0, realstaticaddress = 0;
uint realstaticcount = 0;
int blocknum = block;
if (isuop)
{
blocknum &= 4095;
int shifted = block >> 12;
if (fileNumber != shifted)
{
fileNumber = shifted;
if (shifted < Entries[i].Length)
{
uopoffset = (ulong)Entries[i][shifted].Offset;
}
}
}
ulong address = mapddress + uopoffset + (ulong)(blocknum * mapblocksize);
if (address < endmapaddress)
{
realmapaddress = address;
}
ulong stidxaddress = staticidxaddress + (ulong)(block * staticidxblocksize);
StaidxBlock *bb = (StaidxBlock *)stidxaddress;
if (stidxaddress < endstaticidxaddress && bb->Size > 0 && bb->Position != 0xFFFFFFFF)
{
ulong address1 = staticaddress + bb->Position;
if (address1 < endstaticaddress)
{
realstaticaddress = address1;
realstaticcount = (uint)(bb->Size / staticblocksize);
if (realstaticcount > 1024)
{
realstaticcount = 1024;
}
}
}
ref var data = ref BlockData[i][block];
data.MapAddress = realmapaddress;
data.StaticAddress = realstaticaddress;
data.StaticCount = realstaticcount;
data.OriginalMapAddress = realmapaddress;
data.OriginalStaticAddress = realstaticaddress;
data.OriginalStaticCount = realstaticcount;
}
internal unsafe void ReloadBlock(int map, int blockNumber)
{
int mapBlockSize = sizeof(MapBlock);
int staticIdxBlockSize = sizeof(StaidxBlock);
int staticblockSize = sizeof(StaticsBlock);
UOFile file = _filesMap[map];
UOFile fileIdx = _filesIdxStatics[map];
UOFile staticFile = _filesStatics[map];
ulong staticIdxAddress = (ulong)fileIdx.StartAddress;
ulong endStaticIdxAddress = staticIdxAddress + (ulong)fileIdx.Length;
ulong staticAddress = (ulong)staticFile.StartAddress;
ulong endStaticAddress = staticAddress + (ulong)staticFile.Length;
ulong mapAddress = (ulong)file.StartAddress;
ulong endMapAddress = mapAddress + (ulong)file.Length;
ulong uopOffset = 0;
int fileNumber = -1;
bool isUop = file is UOFileUop;
ulong realMapAddress = 0;
ulong realStaticAddress = 0;
uint realStaticCount = 0;
int block = blockNumber;
if (isUop)
{
blockNumber &= 4095;
int shifted = block >> 12;
if (fileNumber != shifted)
{
fileNumber = shifted;
if (shifted < Entries.Length)
{
uopOffset = (ulong)Entries[map][shifted].Offset;
}
}
}
ulong address = mapAddress + uopOffset + (ulong)(blockNumber * mapBlockSize);
if (address < endMapAddress)
{
realMapAddress = address;
}
ulong stidxaddress = staticIdxAddress + (ulong)(block * staticIdxBlockSize);
StaidxBlock *bb = (StaidxBlock *)stidxaddress;
if (stidxaddress < endStaticIdxAddress && bb->Size > 0 && bb->Position != 0xFFFFFFFF)
{
ulong address1 = staticAddress + bb->Position;
if (address1 < endStaticAddress)
{
realStaticAddress = address1;
realStaticCount = (uint)(bb->Size / staticblockSize);
if (realStaticCount > 1024)
{
realStaticCount = 1024;
}
}
}
ref IndexMap data = ref BlockData[map][block];
public static unsafe void LoadMap(int i)
{
int mapblocksize = UnsafeMemoryManager.SizeOf <MapBlock>();
int staticidxblocksize = UnsafeMemoryManager.SizeOf <StaidxBlock>();
int staticblocksize = UnsafeMemoryManager.SizeOf <StaticsBlock>();
int width = MapBlocksSize[i, 0];
int height = MapBlocksSize[i, 1];
int maxblockcount = width * height;
BlockData[i] = new IndexMap[maxblockcount];
UOFile file = _filesMap[i];
UOFile fileidx = _filesIdxStatics[i];
UOFile staticfile = _filesStatics[i];
ulong staticidxaddress = (ulong)fileidx.StartAddress;
ulong endstaticidxaddress = staticidxaddress + (ulong)fileidx.Length;
ulong staticaddress = (ulong)staticfile.StartAddress;
ulong endstaticaddress = staticaddress + (ulong)staticfile.Length;
ulong mapddress = (ulong)file.StartAddress;
ulong endmapaddress = mapddress + (ulong)file.Length;
ulong uopoffset = 0;
int fileNumber = -1;
bool isuop = file is UOFileUop;
for (int block = 0; block < maxblockcount; block++)
{
ulong realmapaddress = 0, realstaticaddress = 0;
uint realstaticcount = 0;
int blocknum = block;
if (isuop)
{
blocknum &= 4095;
int shifted = block >> 12;
if (fileNumber != shifted)
{
fileNumber = shifted;
if (shifted < file.Entries.Length)
{
uopoffset = (ulong)file.Entries[shifted].Offset;
}
}
}
ulong address = mapddress + uopoffset + (ulong)(blocknum * mapblocksize);
if (address < endmapaddress)
{
realmapaddress = address;
}
ulong stidxaddress = staticidxaddress + (ulong)(block * staticidxblocksize);
StaidxBlock *bb = (StaidxBlock *)stidxaddress;
if (stidxaddress < endstaticidxaddress && bb->Size > 0 && bb->Position != 0xFFFFFFFF)
{
ulong address1 = staticaddress + bb->Position;
if (address1 < endstaticaddress)
{
realstaticaddress = address1;
realstaticcount = (uint)(bb->Size / staticblocksize);
if (realstaticcount > 1024)
{
realstaticcount = 1024;
}
}
}
BlockData[i][block] = new IndexMap(realmapaddress, realstaticaddress, realstaticcount, realmapaddress, realstaticaddress, realstaticcount);
}
}
public unsafe bool ApplyPatches(Packet reader)
{
ResetPatchesInBlockTable();
PatchesCount = (int)reader.ReadUInt();
if (PatchesCount < 0)
{
PatchesCount = 0;
}
if (PatchesCount > MAPS_COUNT)
{
PatchesCount = MAPS_COUNT;
}
MapPatchCount.ForEach(s => s = 0);
StaticPatchCount.ForEach(s => s = 0);
bool result = false;
for (int i = 0; i < PatchesCount; i++)
{
if (_filesMap[i] == null || _filesMap[i].StartAddress == IntPtr.Zero)
{
reader.Skip(8);
continue;
}
int mapPatchesCount = (int)reader.ReadUInt();
MapPatchCount[i] = mapPatchesCount;
int staticPatchesCount = (int)reader.ReadUInt();
StaticPatchCount[i] = staticPatchesCount;
int w = MapBlocksSize[i, 0];
int h = MapBlocksSize[i, 1];
int maxBlockCount = w * h;
if (mapPatchesCount != 0)
{
var difl = _mapDifl[i];
var dif = _mapDif[i];
if (difl == null || dif == null)
{
continue;
}
mapPatchesCount = Math.Min(mapPatchesCount, (int)(difl.Length / 4));
difl.Seek(0);
dif.Seek(0);
for (int j = 0; j < mapPatchesCount; j++)
{
uint blockIndex = difl.ReadUInt();
if (blockIndex < maxBlockCount)
{
BlockData[i][blockIndex].MapAddress = (ulong)dif.PositionAddress;
result = true;
}
dif.Skip(UnsafeMemoryManager.SizeOf <MapBlock>());
}
}
if (staticPatchesCount != 0)
{
var difl = _staDifl[i];
var difi = _staDifi[i];
if (difl == null || difi == null || _staDif[i] == null)
{
continue;
}
ulong startAddress = (ulong)_staDif[i].StartAddress;
staticPatchesCount = Math.Min(staticPatchesCount, (int)(difl.Length / 4));
difl.Seek(0);
difi.Seek(0);
int sizeOfStaicsBlock = UnsafeMemoryManager.SizeOf <StaticsBlock>();
for (int j = 0; j < staticPatchesCount; j++)
{
uint blockIndex = difl.ReadUInt();
StaidxBlock *sidx = (StaidxBlock *)difi.PositionAddress;
difi.Skip(sizeof(StaidxBlock));
if (blockIndex < maxBlockCount)
{
ulong realStaticAddress = 0;
int realStaticCount = 0;
if (sidx->Size > 0 && sidx->Position != 0xFFFF_FFFF)
{
realStaticAddress = startAddress + sidx->Position;
realStaticCount = (int)(sidx->Size / sizeOfStaicsBlock);
if (realStaticCount > 0)
{
if (realStaticCount > 1024)
{
realStaticCount = 1024;
}
}
}
BlockData[i][blockIndex].StaticAddress = realStaticAddress;
BlockData[i][blockIndex].StaticCount = (uint)realStaticCount;
result = true;
}
}
}
}
return(result);
}
