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)); } }