internal override void EndInit()
{
base.EndInit();
Scales.EndInit();
Ranges.EndInit();
Pointers.EndInit();
}
internal override void Notify(MessageType msg, NamedElement element, object param)
{
base.Notify(msg, element, param);
Scales.Notify(msg, element, param);
Ranges.Notify(msg, element, param);
Pointers.Notify(msg, element, param);
}
public void CollectLineOffsets()
{
if (_listStartOffsets.Any())
{
throw new InvalidOperationException("Object already initialized.");
}
AddOffset(0);
for (byte *p = _blockStart; p < _blockEnd - _characterSize; p += _characterSize)
{
char ch;
if (_characterSize == 1)
{
ch = (char)*p;
}
else
{
ch = *(char *)p;
}
if (ch == LineBreak)
{
var byteOffset = Pointers.Offset32(_blockStart, p) + _characterSize;
AddOffset(byteOffset / _characterSize);
}
}
}
private static WindowsBufferStruct AllocBuffer(IntPtr data, int size)
{
var ptr = Pointers.Alloc(size);
var buf = Lib.uv_buf_init(ptr, (uint)size);
return(buf);
}
public unsafe void PointerOffset()
{
void *v = (void *)1000;
v = Pointers.Offset(v, 42);
((int)v).Should().Be(1042);
}
public unsafe void PointerOffset_Negative()
{
void *v = (void *)1000;
v = Pointers.Offset(v, -42);
((int)v).Should().Be(958);
}
private string GetText(int offset, int length)
{
byte *start = Pointers.Add(_blockStart, offset);
byte *end = Pointers.Add(_blockStart, offset + length);
return(Conversion.UTF8ToString(start, end));
}
protected override void OnDispose()
{
base.OnDispose();
Scales.Dispose();
Ranges.Dispose();
Pointers.Dispose();
}
internal override void BeginInit()
{
base.BeginInit();
Scales.BeginInit();
Ranges.BeginInit();
Pointers.BeginInit();
}
private byte[] ReadData(IntPtr pHCIPacket, Structs.HCI_Packet hciPacket, int len)
{
byte[] data = GetBufferOfAtLeast(len);
var pData = Pointers.Add(pHCIPacket, OffsetOfData);
Marshal.Copy(pData, data, 0, len);
return(data);
}
public unsafe void NonNullParameter()
{
fixed(int *value = &_value)
{
Pointers.NonNullParameter(value);
Assert.ThrowsException <ArgumentNullException>(() => Pointers.NonNullParameter(null));
}
}
public JumpPad(int offset)
{
ObjectDP = new DeepPointer(PtrDB.DP_JumpPad).ModifyOffset(2, offset);
// Pointers
Pointers.Add("Speed", new Tuple <DeepPointer, IntPtr>(AppendBaseOffset(0x248), IntPtr.Zero));
Pointers.Add("Rotation", new Tuple <DeepPointer, IntPtr>(AppendBaseOffset(0x230, 0x1C0), IntPtr.Zero));
}
public SignSpawner(int offset)
{
ObjectDP = new DeepPointer(PtrDB.DP_SignSpawner).ModifyOffset(4, offset);
Pointers.Add("Speed", new Tuple <DeepPointer, IntPtr>(AppendBaseOffset(0x248), IntPtr.Zero));
Pointers.Add("SpawnDelay", new Tuple <DeepPointer, IntPtr>(AppendBaseOffset(0x24C), IntPtr.Zero));
Pointers.Add("DelayOnStart", new Tuple <DeepPointer, IntPtr>(AppendBaseOffset(0x250), IntPtr.Zero));
}
public void ParseEnv()
{
var byteBuffer = BytePool.Intance.Get(_readBufferSize);
Marshal.Copy(_readBuffer, byteBuffer.Array, byteBuffer.Offset, _readBufferSize);
Pointers.Free(_readBuffer);
ByteRequestParser.Parse(byteBuffer, Env);
}
public void CanCreateBuffer()
{
const int size = 1024;
var ptr = Pointers.Alloc(size);
var buf = Lib.uv_buf_init(ptr, size);
Assert.Equal(size, (int)buf.length);
}
public unsafe BackupStreamInformation?GetNextInfo()
{
void *buffer = _buffer.VoidPointer;
Error.ThrowLastErrorIfFalse(
Imports.BackupRead(
hFile: _fileHandle,
lpBuffer: buffer,
nNumberOfBytesToRead: s_headerSize,
lpNumberOfBytesRead: out uint bytesRead,
bAbort: false,
bProcessSecurity: true,
context: ref _context));
// Exit if at the end
if (bytesRead == 0)
{
return(null);
}
WIN32_STREAM_ID *streamId = (WIN32_STREAM_ID *)buffer;
if (streamId->dwStreamNameSize > 0)
{
_buffer.EnsureByteCapacity(s_headerSize + streamId->dwStreamNameSize);
Error.ThrowLastErrorIfFalse(
Imports.BackupRead(
hFile: _fileHandle,
lpBuffer: Pointers.Offset(buffer, s_headerSize),
nNumberOfBytesToRead: streamId->dwStreamNameSize,
lpNumberOfBytesRead: out bytesRead,
bAbort: false,
bProcessSecurity: true,
context: ref _context));
}
if (streamId->Size > 0)
{
// Move to the next header, if any
if (!Imports.BackupSeek(
hFile: _fileHandle,
dwLowBytesToSeek: uint.MaxValue,
dwHighBytesToSeek: int.MaxValue,
lpdwLowByteSeeked: out _,
lpdwHighByteSeeked: out _,
context: ref _context))
{
Error.ThrowIfLastErrorNot(WindowsError.ERROR_SEEK);
}
}
return(new BackupStreamInformation
{
Name = streamId->cStreamName.CreateString(),
StreamType = streamId->dwStreamId,
Size = streamId->Size
});
}
//base + 98 + <firstOffset> + 128 + A8 + <secondOffset> + XXX
public ToggleableFan(int firstOffset, int secondOffset)
{
ObjectDP = new DeepPointer(PtrDB.DP_ToggleableFan).ModifyOffset(1, firstOffset).ModifyOffset(4, secondOffset);
// Add pointers
Pointers.Add("FanSpeed", new Tuple <DeepPointer, IntPtr>(AppendBaseOffset(0x2E0), IntPtr.Zero));
Pointers.Add("HackedFanSpeed", new Tuple <DeepPointer, IntPtr>(AppendBaseOffset(0x2E8), IntPtr.Zero));
Pointers.Add("HackedDuration", new Tuple <DeepPointer, IntPtr>(AppendBaseOffset(0x2EC), IntPtr.Zero));
}
public TomLaser(int offset)
{
ObjectDP = new DeepPointer(PtrDB.DP_Tom_Laser).ModifyOffset(5, offset);
// pointers
Pointers.Add("Pos", new Tuple <DeepPointer, IntPtr>(AppendBaseOffset(0x11C), IntPtr.Zero));
Pointers.Add("VerticalAngle", new Tuple <DeepPointer, IntPtr>(AppendBaseOffset(0x128), IntPtr.Zero));
Pointers.Add("Rotation", new Tuple <DeepPointer, IntPtr>(AppendBaseOffset(0x1A0), IntPtr.Zero));
}
public object Clone()
{
return(new ExecutionPath
{
Id = Id,
CreateDateTime = CreateDateTime,
Pointers = Pointers.Select(_ => (ExecutionPointer)_.Clone()).ToList()
});
}
public UplinkSlowmo(int firstOffset, int secondOffset, int thirdOffet)
{
ObjectDP = new DeepPointer(PtrDB.DP_UplinkSlowmo).ModifyOffset(1, firstOffset).ModifyOffset(4, secondOffset).ModifyOffset(6, thirdOffet);
// add pointers
Pointers.Add("TimeMultiplier", new Tuple <DeepPointer, IntPtr>(AppendBaseOffset(0x8), IntPtr.Zero));
Pointers.Add("MidCurveTime", new Tuple <DeepPointer, IntPtr>(AppendBaseOffset(0x20), IntPtr.Zero));
Pointers.Add("TotalTime", new Tuple <DeepPointer, IntPtr>(AppendBaseOffset(0x3C), IntPtr.Zero));
}
public unsafe void ReturnSameValueNullableParameter()
{
fixed(int *value = &_value)
{
Pointers.ReturnSameValueNullableParameter(value);
var ex = Assert.ThrowsException <NullReferenceException>(() => Pointers.ReturnSameValueNullableParameter(null));
Assert.IsTrue(ex.Message.Contains("return", StringComparison.OrdinalIgnoreCase), "Exception message did not apply to return value.");
}
}
public unsafe void AllowNullOnlyNoOp()
{
fixed(int *value = &_value)
{
Pointers.AllowNullOnlyNoOp(value);
var ex = Assert.ThrowsException <NullReferenceException>(() => Pointers.AllowNullOnlyNoOp(null));
Assert.IsTrue(ex.Message.Contains("output", StringComparison.OrdinalIgnoreCase), "Exception message did not apply to output value.");
}
}
//0x045A3C20, 0x98, <firstOffset>, 0x128, 0xA8, <secondOffset>
public UplinkJump(int firstOffset, int secondOffset)
{
ObjectDP = new DeepPointer(PtrDB.DP_UplinkJump).ModifyOffset(1, firstOffset).ModifyOffset(4, secondOffset);
// add pointers
Pointers.Add("TimeToActivate", new Tuple <DeepPointer, IntPtr>(AppendBaseOffset(0x234), IntPtr.Zero));
Pointers.Add("JumpMultiplier", new Tuple <DeepPointer, IntPtr>(AppendBaseOffset(0x280), IntPtr.Zero));
Pointers.Add("JumpForwardMultiplier", new Tuple <DeepPointer, IntPtr>(AppendBaseOffset(0x284), IntPtr.Zero));
Pointers.Add("JumpGravity", new Tuple <DeepPointer, IntPtr>(AppendBaseOffset(0x288), IntPtr.Zero)); // 6 by default, 2x from basic value ingame
}
// base, 0x98, firstOffset, 0x128, 0xA8, secondOffset
public Billboard(int firstOffset, int secondOffset)
{
ObjectDP = new DeepPointer(PtrDB.DP_Billboard).ModifyOffset(1, firstOffset).ModifyOffset(4, secondOffset);
// Pointers
Pointers.Add("Time1", new Tuple <DeepPointer, IntPtr>(AppendBaseOffset(0x2C8), IntPtr.Zero));
Pointers.Add("Angle1", new Tuple <DeepPointer, IntPtr>(AppendBaseOffset(0x2CC), IntPtr.Zero));
Pointers.Add("Time2", new Tuple <DeepPointer, IntPtr>(AppendBaseOffset(0x2C0), IntPtr.Zero));
Pointers.Add("Angle2", new Tuple <DeepPointer, IntPtr>(AppendBaseOffset(0x2D4), IntPtr.Zero));
}
public void CanCreateTcpServer()
{
var loop = Lib.uv_default_loop();
var server = Pointers.Alloc(Lib.uv_handle_size(HandleType.UV_TCP));
int error = -1;
Assert.DoesNotThrow(() =>
error = Lib.uv_tcp_init(loop, server));
Assert.Equal(0, error);
Pointers.Free(server);
}
public void AddPointer()
{
WorldPointer p = new WorldPointer()
{
X = 8,
Y = 0x16,
LevelGuid = Guid.Empty
};
Pointers.Add(p);
}
public FilePositionSpan GetLineExtent(int offset)
{
var lineNumber = GetLineStartIndex(offset);
var lineStartOffset = _listStartOffsets[lineNumber];
var lineEndOffset = (lineNumber == _listStartOffsets.Count - 1) ?
Pointers.Offset32(_blockStart, _blockEnd) :
_listStartOffsets[lineNumber + 1];
return(new FilePositionSpan {
Position = lineStartOffset, Length = lineEndOffset - lineStartOffset
});
}
public void SetPointer(Pointers _pointer)
{
switch(_pointer)
{
case Pointers.Monster_Pointer:
pointer = monsterPointer;
break;
case Pointers.SpiritGate_Pointer:
pointer = spiritGatePointer;
break;
}
}
public override void onTick()
{
base.onTick();
UInt64 facing = SDK.instance.entityFacing;
if (facing > 0)
{
MCM.writeBaseByte((int)Pointers.attackSwing(), 0);
}
else
{
MCM.writeBaseByte((int)Pointers.attackSwing(), 1);
}
}
public void AddPointer()
{
LevelPointer p = new LevelPointer()
{
ExitType = 0,
XExit = 0,
XEnter = 0,
YExit = 0,
YEnter = 0,
LevelGuid = Guid.Empty
};
Pointers.Add(p);
}
private string GetText(int offset, int length)
{
byte *start = Pointers.Add(_blockStart, offset * _characterSize);
byte *end = Pointers.Add(_blockStart, (offset + length) * _characterSize);
if (_characterSize == 1)
{
return(Conversion.Utf8ToString(start, end));
}
else
{
return(Conversion.Utf16ToString(start, end));
}
}
