protected virtual void RefreshDynamic() { if (Pool == null || Pool.Value == null) { return; } _Value = MemoryDataConverter.Read <T>(Pool.Value, Offset); }
public TOut ReadAs <TOut>(string field) { if (Fields.ContainsKey(field)) { return(Fields[field].ReadAs <TOut>()); } else { return(MemoryDataConverter.Read <TOut>(new byte[32], 0)); } }
private void ScanRegion <T>(MemoryRegion region, IEnumerable <MemorySignatureScanObject> signature, Action <T, int> addAction) { if (region.Data.Length == 0) { return; } byte startByte = signature.FirstOrDefault().data; var signatureLength = signature.Count(); var address = (uint)Array.IndexOf(region.Data, startByte, 0); var signatureCheckIndex = 0; var targetIndex = 0; var target = new byte[32]; var matchFailed = false; while (address < region.Data.Length - signatureLength) { foreach (var sigByte in signature) { if (sigByte.wildcard) { signatureCheckIndex++; continue; } var by = region.Data[address + signatureCheckIndex]; if (sigByte.target) { target[targetIndex++] = by; } else if (sigByte.data != by) { matchFailed = true; break; } signatureCheckIndex++; } if (!matchFailed) { addAction(MemoryDataConverter.Read <T>(target, 0), (int)address); //Debug.WriteLine("0x{0} -> 0x{2:X} [ 0x{1:X} ] ",string.Format("{0:X}", address), BitConverter.ToString(target), address); target = new byte[32]; } signatureCheckIndex = 0; targetIndex = 0; matchFailed = false; address = (uint)Array.IndexOf(region.Data, startByte, (int)address + 1); } }
public byte[] ReadBytes(string field) { var oField = this.Fields[field]; if (oField.HasChanged()) { return(MemoryDataConverter.Rawify(oField.Read)); } else { return(new byte[0]); } }
protected virtual void RefreshStatic() { if (Memory == null) { return; } var computedAddress = 0; if (Address != 0 && Offset != 0) { computedAddress = Memory.Reader.ReadInt32(Memory.BaseAddress + Address) + Offset; } else { computedAddress = AddressType == MemoryAddress.Static ? Memory.BaseAddress + Address : Address; } var data = Memory.Reader.ReadBytes(computedAddress, (uint)Size); _Value = MemoryDataConverter.Read <T>(data, 0); }
public TOut ReadAs <TOut>() { return(MemoryDataConverter.Cast <T, TOut>(ValidationFunc(Pool))); }
public TOut ReadAs <TOut>(int offset) { return(MemoryDataConverter.Read <TOut>(Value, offset)); }
public TOut ReadAs <TOut>() { return(MemoryDataConverter.Read <TOut>(new byte[32], 0)); }
public void Refresh() { if (IsTemplate) { return; } var computedAddress = 0; if (IsSignature && Offset == 0 && Address == 0 && Memory.Scanner.Enabled) { var result = Memory.Scanner.Scan <uint>(MemoryRegionType.EXECUTE, Signature); // Search the address and offset. switch (AddressType) { case MemoryAddress.StaticAbsolute: case MemoryAddress.Static: if (result == 0) { return; } if (Pointers.Count() == 0) { // The result is directly our address Address = (int)result; } else { // We must follow one pointer. if (AddressType == MemoryAddress.Static) { computedAddress = Memory.BaseAddress + (int)result; } else { computedAddress = (int)result; } Address = computedAddress; } break; case MemoryAddress.Dynamic: Offset = (int)result; break; default: throw new Exception("AddressType for '" + Name + "' is not valid"); break; } } // Refresh pointers too foreach (var ptr in Pointers) { ptr.Refresh(Memory); } // Refresh this memory block. if (Size > 0) { AddressTree = new int[1 + Pointers.Count()]; if (IsStatic) { if (Address != 0 && Offset != 0) { computedAddress = Memory.Reader.ReadInt32(Memory.BaseAddress + Address) + Offset; } else { computedAddress = AddressType == MemoryAddress.Static ? Memory.BaseAddress + Address : Address; } } else { computedAddress = Pool == null ? 0 : MemoryDataConverter.Read <int>(Pool.Value, Offset); } int treeInd = 0; foreach (var ptr in Pointers) { AddressTree[treeInd++] = computedAddress; if (ptr.Additive) { computedAddress += ptr.Offset; } else { computedAddress = Memory.Reader.ReadInt32(computedAddress + ptr.Offset); } } AddressTree[treeInd] = computedAddress; // Read into this buffer. Memory.Reader.Read(computedAddress, Value); } // Refresh underlying fields. foreach (var field in Fields) { field.Value.Refresh(); } foreach (var pool in Pools.Values) { pool.Refresh(); } }
public TOut ReadAs <TOut>() { return(MemoryDataConverter.Cast <T, TOut>(StaticValue)); }
public virtual TOut ReadAs <TOut>() { return(MemoryDataConverter.Cast <T, TOut>(Value)); }