public void ReadInvalidateTest()
{
BitStreamer bs = new BitStreamer(false);
IntPtr ptr = Memory.Alloc(4);
Assert.IsFalse(bs.ThrowsOnExceededBuffer);
Assert.IsFalse(bs.IsValid);
bs.ResetRead(ptr, 4);
Assert.IsTrue(bs.IsValid);
bs.ReadInt32();
Assert.IsTrue(bs.IsValid);
bs.ReadInt32();
Assert.IsFalse(bs.IsValid);
// Confirm offset hasn't increased.
Assert.AreEqual(4, bs.ByteOffset);
bs.ResetRead();
Assert.IsTrue(bs.IsValid);
Memory.Free(ptr);
}
public void WriteInvalidateTest()
{
BitStreamer bs = new BitStreamer(false);
IntPtr ptr = Memory.Alloc(8);
Assert.IsFalse(bs.ThrowsOnExceededBuffer);
Assert.IsFalse(bs.IsValid);
bs.ResetWrite(ptr, 8);
Assert.IsTrue(bs.IsValid);
bs.WriteULong(123);
Assert.IsTrue(bs.IsValid);
bs.WriteInt32(321);
Assert.IsFalse(bs.IsValid);
// Confirm offset hasn't increased.
Assert.AreEqual(8, bs.ByteOffset);
bs.ResetWrite();
Assert.IsTrue(bs.IsValid);
Memory.Free(ptr);
}
public void NonAlignBufferTest()
{
IntPtr ptr = Memory.Alloc(12);
BitStreamer bs = new BitStreamer();
bs.ResetWrite(ptr, 12);
Assert.AreEqual(8, bs.ByteLength);
bs.ResetRead();
Assert.AreEqual(12, bs.ByteLength);
bs.ResetWrite();
Assert.AreEqual(8, bs.ByteLength);
bs.WriteULong(123);
// The write buffer should be rounded down to 8. So this must fail.
Assert.Throws <InvalidOperationException>(() =>
{
bs.WriteByte(1);
});
Memory.Free(ptr);
}
private unsafe NetPacket CreatePacket(int size)
{
NetPacket pack = new NetPacket();
IntPtr data = Memory.Alloc(size);
pack.OnReceive(new ReadOnlySpan <byte>(data.ToPointer(), size));
return(pack);
}
internal static IntPtr AllocAndWrite(byte[] data)
{
IntPtr addr = Memory.Alloc((uint)data.Length);
Memory.Write(addr, data);
return(addr);
}
private unsafe NetPacket CreatePacket(int size)
{
IntPtr mem = Memory.Alloc(size);
var span = new ReadOnlySpan <byte>(mem.ToPointer(), size);
NetPacket packet = new NetPacket();
packet.OnReceive(span);
return(packet);
}
private byte *CreateArray()
{
var arr = (byte *)Memory.Alloc(8);
for (int i = 0; i < 8; i++)
{
arr[i] = (byte)i;
}
return(arr);
}
private void btnApply_Click(object sender, EventArgs e)
{
InitProcess();
try
{
if (SelectedVersion.Version == 1)
{
HotsOffsets_V1 CurrentVersion = SelectedVersion as HotsOffsets_V1;
FileVersionInfo ver = Memory.CurrentProcess.MainModule.FileVersionInfo;
if (ver.FilePrivatePart != Offsets[cbVersions.SelectedIndex].Build)
{
MessageBox.Show("Wrong or incompatible build selected! Patch failed.");
return;
}
// Map patch
byte[] mapName = Encoding.ASCII.GetBytes(cbMapSelect.SelectedItem + "\0\0\0");
if (mapNamePtr == IntPtr.Zero)
{
mapNamePtr = Memory.Alloc(mapName.Length);
}
Memory.Write(mapNamePtr, mapName);
oldMapPtr1 = Memory.Read <IntPtr>(CurrentVersion.PatchMapOffset1);
oldMapPtr2 = Memory.Read <IntPtr>(CurrentVersion.PatchMapOffset2);
Memory.Write <IntPtr>(CurrentVersion.PatchMapOffset1, mapNamePtr);
Memory.Write <IntPtr>(CurrentVersion.PatchMapOffset2, mapNamePtr + mapName.Length - 3);
}
for (int i = 0; i < 10; ++i)
{
Heroes[i] = (int)Enum.Parse(SelectedVersion.HeroIDEnum, (string)HeroComboBoxes[i].SelectedItem);
}
AlliedAI = (AIDifficulty)Enum.Parse(typeof(AIDifficulty), (string)cbAllyTeamAI.SelectedItem);
EnemyAI = (AIDifficulty)Enum.Parse(typeof(AIDifficulty), (string)cbEnemyTeamAI.SelectedItem);
timer1.Enabled = true;
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString());
}
}
public void ResetWriteInvalid()
{
BitStreamer bs = new BitStreamer();
IntPtr buff = Memory.Alloc(16);
*(byte *)buff = 212;
bs.ResetWrite(8);
Assert.Throws <InvalidOperationException>(() =>
{
bs.ResetWrite(buff, 16);
});
}
/// <summary>
/// Инициализирует новый экземпляр класса.
/// </summary>
/// <param name="itemSize">
/// Размер одного элемента.
/// </param>
/// <param name="rowsCount">
/// Количество строк.
/// </param>
/// <param name="columnsCount">
/// Количество столбцов.
/// </param>
/// <exception cref="ArgumentOutOfRangeException">
/// <para>В параметре <paramref name="itemSize"/> передано отрицательное или равное нулю значение.</para>
/// <para>- или -</para>
/// <para>В параметре <paramref name="rowsCount"/> передано отрицательное значение.</para>
/// <para>- или -</para>
/// <para>В параметре <paramref name="columnsCount"/> передано отрицательное значение.</para>
/// </exception>
/// <exception cref="OutOfMemoryException">
/// Недостаточно памяти для выполнения запроса.
/// </exception>
public Matrix(int itemSize, int rowsCount, int columnsCount)
{
if (itemSize <= 0)
{
throw new ArgumentOutOfRangeException("itemSize", "Передано отрицательное или равное нулю значение.");
}
if (rowsCount < 0)
{
throw new ArgumentOutOfRangeException("rowsCount", "Передано отрицательное значение.");
}
if (columnsCount < 0)
{
throw new ArgumentOutOfRangeException("columnsCount", "Передано отрицательное значение.");
}
RowsCount = rowsCount;
ColumnsCount = columnsCount;
Pointer = Memory.Alloc(rowsCount * ((long)columnsCount) * itemSize);
}
internal void Resize(int newSize)
{
if (newSize > Capacity)
{
var alignedSize = MathUtils.GetNextMultipleOf8(newSize);
if (Data == null)
{
Data = (byte *)Memory.Alloc(alignedSize);
}
else
{
Data = (byte *)Memory.Realloc((IntPtr)Data, Capacity, alignedSize);
}
Capacity = alignedSize;
}
}
public void ResetWriteCopyBufferNull()
{
BitStreamer bs = new BitStreamer();
IntPtr buff = Memory.Alloc(16);
*(byte *)buff = 212;
bs.ResetWrite(buff, 16, true);
Assert.AreEqual(16, bs.ByteLength);
Assert.AreEqual(16, bs.ByteOffset);
bs.ResetRead();
Assert.AreEqual(212, bs.ReadByte());
Assert.IsTrue(bs.OwnsBuffer);
Memory.Free(buff);
}
private void WriteStringInternal(char *ptr, int charCount, Encoding encoding)
{
const int BUFFERSIZE = 256;
int byteSize = encoding.GetByteCount(ptr, charCount);
if (byteSize > ushort.MaxValue)
{
throw new ArgumentOutOfRangeException("value", "String is too large to be written.");
}
// Abort when the buffer doesn't have the required space.
if (!EnsureWriteSize((byteSize + sizeof(ushort)) * 8))
{
return;
}
// Write the length of the string in bytes.
WriteUnchecked((ushort)byteSize, 16);
// Fast route, use stackalloc for small strings.
if (byteSize <= BUFFERSIZE)
{
byte *buffer = stackalloc byte[byteSize];
encoding.GetBytes(ptr, charCount, buffer, byteSize);
WriteMemoryUnchecked(buffer, byteSize);
}
// Slow route, alloc mem for large strings.
else
{
byte *buffer = (byte *)Memory.Alloc(byteSize);
try
{
encoding.GetBytes(ptr, charCount, buffer, byteSize);
WriteMemoryUnchecked(ptr, byteSize);
}
finally
{
// Ensure we don't have a mem leak.
Memory.Free(buffer);
}
}
}
public void OnReceiveResizeTest()
{
var pack = CreatePacket(8);
Assert.AreEqual(8, pack.Capacity);
Assert.AreEqual(8, pack.Size);
var dataPtr = (ulong)pack.Data;
// Must be larger than existing buffer.
IntPtr ptr = Memory.Alloc(14);
pack.OnReceive(new ReadOnlySpan <byte>(ptr.ToPointer(), 14));
Assert.IsFalse(dataPtr == (ulong)pack.Data);
Assert.AreEqual(16, pack.Capacity);
Assert.AreEqual(14, pack.Size);
pack.Dispose();
}
public void NonAlignBufferSet()
{
IntPtr ptr = Memory.Alloc(12);
BitStreamer bs = new BitStreamer();
bs.ResetRead(ptr, 4);
Assert.AreEqual(4, bs.ByteLength);
bs.ReadFloat();
// Should fail because we are exceeding the allowed size of 4.
Assert.Throws <InvalidOperationException>(() =>
{
bs.ReadByte(1);
});
bs.ResetWrite();
Assert.AreEqual(0, bs.ByteLength);
}
public void OnReceiveTest()
{
var pack = CreatePacket(16);
Assert.AreEqual(16, pack.Capacity);
Assert.AreEqual(16, pack.Size);
Assert.IsTrue(pack.IsValid);
var dataPtr = (ulong)pack.Data;
// Must be smaller than existing buffer.
IntPtr ptr = Memory.Alloc(8);
pack.OnReceive(new ReadOnlySpan <byte>(ptr.ToPointer(), 8));
Assert.IsTrue(dataPtr == (ulong)pack.Data);
Assert.AreEqual(16, pack.Capacity);
Assert.AreEqual(8, pack.Size);
pack.Dispose();
}
/// <summary>
/// Reads a string from the <see cref="NetPacket"/>.
/// </summary>
public string ReadString(Encoding encoding)
{
const int BUFFERSIZE = 256;
ushort byteSize = ReadUShort();
if (byteSize == 0)
{
return(string.Empty);
}
if (!EnsureReadSize(byteSize * 8))
{
return(string.Empty);
}
// Fast route, use stackalloc for small strings.
if (byteSize <= BUFFERSIZE)
{
byte *buffer = stackalloc byte[byteSize];
ReadMemoryUnchecked(buffer, byteSize);
return(new string((sbyte *)buffer, 0, byteSize, encoding));
}
// Slow route, alloc mem for large strings.
else
{
byte *buffer = (byte *)Memory.Alloc(byteSize);
try
{
ReadMemoryUnchecked(buffer, byteSize);
return(new string((sbyte *)buffer, 0, byteSize, encoding));
}
finally
{
// Ensure we don't have a mem leak.
Memory.Free(buffer);
}
}
}
public Model()
{
_forward = (Node *)Memory.Alloc(sizeof(Node));
_backward = (Node *)Memory.Alloc(sizeof(Node));
}