[DELPHI] Dynamic Offsets WOW Player Coords

function MemRCoords(adresse,size:integer): Integer;
var p : pointer;
    puffer : Integer;
    BytesRead: Cardinal;
    WindowName,ProcessId,HandleWindow, Base, BaseOffset1, BaseOffset2  :  integer;
begin
        WindowName  :=  FindWindow(nil, 'World of Warcraft'); //get Handle
        GetWindowThreadProcessId(WindowName,@ProcessId);
        HandleWindow  :=  OpenProcess(PROCESS_ALL_ACCESS,False,ProcessId);
        Base := $00CD87A8;
        BaseOffset1 := $34;
        BaseOffset2 := $24;
        ReadProcessMemory( HandleWindow, ptr(Base) , @puffer, size, BytesRead );
        ReadProcessMemory( HandleWindow, ptr(puffer + BaseOffset1) , @puffer, size, BytesRead );
        ReadProcessMemory( HandleWindow, ptr(puffer + BaseOffset2) , @puffer, size, BytesRead );
        ReadProcessMemory( HandleWindow, ptr(puffer + adresse) , @puffer, size, BytesRead );
        closehandle(HandleWindow);//close
        MemRCoords := Puffer;
end;

function GetCoords(adresse, size: integer): Single;
var
  h: hwnd;
  hProc: THandle;
  fTemp: Single;
  dwRead, dwpId, dwTemp: Cardinal;
const
  dwBase        = $00CD87A8;
  dwBaseOffset1 = $34;
  dwBaseOffset2 = $24;
begin
  result := 0.0;

  h :=  FindWindow(nil, 'World of Warcraft');

  if (h <> 0) then
  begin
    GetWindowThreadProcessId(h, @dwpId);
    hProc :=  OpenProcess(PROCESS_ALL_ACCESS, false, dwpId);

    if (hProc <> 0) then
    begin
      ReadProcessMemory(hProc, ptr(dwBase), @dwTemp, size, dwRead);
      ReadProcessMemory(hProc, ptr(dwTemp + dwBaseOffset1), @dwTemp, size, dwRead);
      ReadProcessMemory(hProc, ptr(dwTemp + dwBaseOffset2), @dwTemp, size, dwRead);
      ReadProcessMemory(hProc, ptr(dwTemp + adresse), @fTemp, size, dwRead);

      CloseHandle(hProc);

      result := fTemp;
    end;
  end;
end;

Caption := Format('Spieler X: %f', [GetCoords($798, 4)]);

public string PlayerNameFromGuid(ulong guid) 
        {
            const ulong nameStorePtr = 0x1137CE0 + 0x8;  // Player name database
            const ulong nameMaskOffset = 0x024;  // Offset for the mask used with GUID to select a linked list
            const ulong nameBaseOffset = 0x01c;  // Offset for the start of the name linked list
            const ulong nameStringOffset = 0x020;  // Offset to the C string in a name structure

            ulong mask, base_, offset, current, shortGUID, testGUID;

            mask = WowReader.ReadUInt32((IntPtr)(nameStorePtr + nameMaskOffset));
            base_ = WowReader.ReadUInt32((IntPtr)(nameStorePtr + nameBaseOffset));

            shortGUID = guid & 0xffffffff;  // Only half the guid is used to check for a hit
            offset = 12 * (mask & shortGUID);

            current = WowReader.ReadUInt32((IntPtr)(base_ + offset + 8));
            offset = WowReader.ReadUInt32((IntPtr)(base_ + offset));
            //current == 0 || (current & 0x1)
            if ((current & 0x1) == 0x1) { return ""; }

            testGUID = WowReader.ReadUInt32((IntPtr)(current));

            while (testGUID != shortGUID)
            {
                current = WowReader.ReadUInt32((IntPtr)(current + offset + 4));

                if ((current & 0x1) == 0x1) { return ""; }
                testGUID = WowReader.ReadUInt32((IntPtr)(current));
            }

            // Found the guid in the name list...
            //ReadBytesIntoBuffer(current + nameStringOffset, numBytes, name);
            return WowReader.ReadString((IntPtr)(current + nameStringOffset));
        }

shortGUID = guid & 0xffffffff;  // Only half the guid is used to check

function PlayerFromGUID(GUID:UInt64): String;
var
  mask, base, shortGUID, testGUID, offset, current: Integer;
begin
  mask := MemRInteger(nameStorePtr + nameMaskOffset);
  base := MemRInteger(nameStorePtr + nameBaseOffset);

  shortGUID := GUID + $ffffffff;

    if mask = $FFFFFFFF
    then Result := '';

  offset  := 12 * (mask + shortGUID);
  current := MemRInteger(base + offset + $8);
  offset  := MemRInteger(base + offset);

    if (current = 0) or ((current + $1) = $1)
    then Result := '';

  testGUID := MemRInteger(current);
  while testGUID <> current do begin
    current := MemRInteger(current + offset + $4);

      if (current = 0) or ((current + $1) = $1)
      then Result := '';

    testGUID := MemRInteger(current);
  end;
  Result := MemRString(current + nameStringOffset);
end;

  nameStorePtr      =   $C5D938 + $8;
  nameMaskOffset    =   $24;
  nameBaseOffset    =   $1C;
  nameStringOffset  =   $20;

shortGUID = guid & 0xffffffff;

function PlayerFromGUID(GUID:UInt64): String;
var
  nameMask, nameBase, testGUID, offset, current: Integer;
  shortGUID: UInt64;
begin
  nameMask := MemRInteger(nameStorePtr + nameMaskOffset);
  nameBase := MemRInteger(nameStorePtr + nameBaseOffset);

  shortGUID := GUID and $FFFFFFFF;      // Only half the guid is used to check for a hit
    if nameMask = $FFFFFFFF then
    begin
      Result := 'Fehler1';
      Exit;
    end;
  offset  := 12 * (nameMask and shortGUID);  // select the appropriate linked list
  current := MemRInteger(nameBase + offset + 8);
  offset  := MemRInteger(nameBase + offset);
      if (current = (current and $1)) or (current = 0) then
      begin
        Result := 'Fehler2';
        Exit;
      end;
  testGUID := MemRInteger(current);
  while testGUID <> current do begin
    current := MemRInteger(current + offset + 4);
      if (current = (current and $1)) or (current = 0) then
      begin
        Result := 'Fehler3';
        Exit;
      end;
    testGUID := MemRInteger(current);
  end;
  Result := MemRString(current + nameStringOffset);
end;