Others players's name on PTR ?

[VesperCore]

Anyone found how to retrieve players name with the old method:

as now GUID are 128bits, do we still need/ is there still this "shortGUID" ?

(note: it was taking 32bits out of 64bits by pushing 0xFFFFFFFF to it)

do we need to consider the "low" as a 64bits GUID and leave the smartguid appart to do this ?

public enum PlayerNameStore
{
nameStorePtr = 0xDAE3F0 + 0x8, // 18935 // 18414=0xC86838
nameMaskOffset = 0x24, // ?? 18414
nameBaseOffset = 0x18, // ?? 18414
nameStringOffset = 0x21, // ?? 18414
}

uint mask =
Memory.WowMemory.Memory.ReadUInt(Memory.WowProcess.WowModule + (uint) Addresses.PlayerNameStore.nameStorePtr + (uint) Addresses.PlayerNameStore.nameMaskOffset);
uint baseAddresse =
Memory.WowMemory.Memory.ReadUInt(Memory.WowProcess.WowModule + (uint) Addresses.PlayerNameStore.nameStorePtr + (uint) Addresses.PlayerNameStore.nameBaseOffset);

UInt128 shortGUID = guid & 0xffffffff;
if (mask == 0xffffffff)
return "";

uint offset = 12*(uint) (mask & shortGUID);
uint current = Memory.WowMemory.Memory.ReadUInt(baseAddresse + offset + ;
offset = Memory.WowMemory.Memory.ReadUInt(baseAddresse + offset);

if (current == 0 || (current & 0x1) == 0x1)
return "";

uint testGUID = Memory.WowMemory.Memory.ReadUInt(current);

while (testGUID != shortGUID)
{
current = Memory.WowMemory.Memory.ReadUInt(current + offset + 4);
if (current == 0 || (current & 0x1) == 0x1)
return "";
testGUID = Memory.WowMemory.Memory.ReadUInt(current);
Thread.Sleep(5);
}


return Memory.WowMemory.Memory.ReadUTF8String(current + (uint) Addresses.PlayerNameStore.nameStringOffset);

Or can you simply show me which function this was reversed from originally ? (on Live 18414 and/or PTR 18935)
I lost most of my IDA DB names due to a HDD failure.

[Torpedoes]

I started reversing the PTR but quickly realized it might be prudent to wait for release seeing as all the debug code is still in there. Unless of course I'm missing something.

As for player names, I thought player GUID's were the same, just padded out to be 128-bit. Does the player name cache approach no longer work? What about the addon interface?

[VesperCore]

I started reversing the PTR but quickly realized it might be prudent to wait for release seeing as all the debug code is still in there. Unless of course I'm missing something.

As for player names, I thought player GUID's were the same, just padded out to be 128-bit. Does the player name cache approach no longer work? What about the addon interface?

Didn't check the addon interface yet, but I exported them from the client, will check.

For the 128-bit GUID, I tryed to extract a "shortGUID", it wont works.

FFFFFFFF (max 32bits value) kinda break a 64bits into 2, if you apply it to 128guid, it will give you the "smart bits" of the guid which are not really a guid itself, if you apply it to the other part (the 64bits guid left from the 2) it will gives you 0

I cannot find where the player name cache was reversed from since my IDB is too old atm due to HDD issue, I mean, I don't even have the function on 18414. I can easily find it back, even with all their debug code and breakpoint "int 3" messign arround.

[Mr.Sergey]

public string GetPlayerName(UInt128 GUID)
{
    uint next = Memory.process.ReadUInt(Const.PlayerNameCachePointer + Const.PlayerNameNextOffset);
    uint ptr = next;
    while (true)
    {
        uint ncstart = ptr + 16;
        if (Memory.process.ReadUInt128(ncstart) == GUID)
            return ReadUTF8String(ncstart + Const.PlayerNameStringOffset, 48);
        ptr = Memory.process.ReadUInt(ptr);
        if (ptr == next) break;
    }
    return "";
}

For 18934 build:

Const.PlayerNameCachePointer = 0xDAF410;
Const.PlayerNameNextOffset = 0x14;
Const.PlayerNameStringOffset = 0x11;

[VesperCore]

public string GetPlayerName(UInt128 GUID)
{
    uint next = Memory.process.ReadUInt(Const.PlayerNameCachePointer + Const.PlayerNameNextOffset);
    uint ptr = next;
    while (true)
    {
        uint ncstart = ptr + 16;
        if (Memory.process.ReadUInt128(ncstart) == GUID)
            return ReadUTF8String(ncstart + Const.PlayerNameStringOffset, 48);
        ptr = Memory.process.ReadUInt(ptr);
        if (ptr == next) break;
    }
    return "";
}

For 18934 build:

Const.PlayerNameCachePointer = 0xDAF410;
Const.PlayerNameNextOffset = 0x14;
Const.PlayerNameStringOffset = 0x11;

thanks for sharing +rep


Offsets as of 18950:

/// <summary>
/// Get Players name
/// </summary>
public enum PlayerNameStore
{
PlayerNameStorePtr = 0xC82390,
PlayerNameNextOffset = 0x14,
PlayerNameStringOffset = 0x11,
}

[-Ryuk-]

You know, you may want to make your SmartGUID like this

ulong low = read<ulong>(ptr + ofguid);
ulong high = read<ulong>(ptr + ofguid + 0x;
new SmartGuid(low, high)

It it make it easier later.


Does anyone have a complete list of GuidType and GuidSubTypes?

[TOM_RUS]

You know, you may want to make your SmartGUID like this

ulong low = read<ulong>(ptr + ofguid);
ulong high = read<ulong>(ptr + ofguid + 0x;
new SmartGuid(low, high)

It it make it easier later.


Does anyone have a complete list of GuidType and GuidSubTypes?

All GuidType's is in wow.exe, GuidSubTypes not sure.

[-Ryuk-]

All GuidType's is in wow.exe, GuidSubTypes not sure.

I have the GuidType, just not SubType

[VesperCore]

You know, you may want to make your SmartGUID like this

ulong low = read<ulong>(ptr + ofguid);
ulong high = read<ulong>(ptr + ofguid + 0x;
new SmartGuid(low, high)

It it make it easier later.


Does anyone have a complete list of GuidType and GuidSubTypes?

Why would I do that ? ^^

I have a complete UInt128 struct + the implementation to extract "SmartGUID" informations.

I really don't need to make some wierd implementation.

I simply do a Mem.ReadUInt128 that will read 16 bytes directly,

I just had to update my code to change UInt64/ulong to UInt128 for GUIDs, so I didn't had to modify anything else such as doing "new SmartGUID(Read64(ptr), Read64(ptr+0x)" every single time I'm using a GUID.

This class "as is" was written for an emu, means this class intent to help handling the creation a GUID, as far as I know, we don't create GUID in a bot, we simply read existing data created by WoW.

PS: You can finds those "GuidType" list directly into where you found this SmartGUID class.

[fvicaria]

I got mine to work pretty well now...

        private string GetPlayerName()
        {
            var next = Memory.Read<IntPtr>(IntPtr.Add(Memory.ImageBase, (int)Offsets.ObjectNameOffsets.PlayerNameCachePtr));
            IntPtr ptr = next;

            while (true)
            {
                var ncstart = IntPtr.Add(next, (int)Offsets.ObjectNameOffsets.PlayerNameGuidOffset);
                var curGuid = Memory.Read<WoWGuid>(ncstart);

                if (curGuid == Guid)
                {
                    var temp =  Memory.ReadASCIIString(IntPtr.Add(ncstart, (int)Offsets.ObjectNameOffsets.PlayerNameStringOffset), 48);
                    return temp;
                }

                next = Memory.Read<IntPtr>(IntPtr.Add(next, (int)Offsets.ObjectNameOffsets.PlayerNameNextOffset));
                if (ptr == next) 
                    break;

                ptr = next;
            }
            return "";
        }

With these:

    public enum ObjectNameOffsets
    {
        ObjectCache = 0x26C,                                    
        ObjectCacheNamePtr = 0xB4,               

        UnitCache = 0xBC4,                          
        UnitCacheNamePtr = 0x7C,

        PlayerNameCachePtr = 0xC8B574,
        PlayerNameGuidOffset = 0x10,
        PlayerNameNextOffset = 0x0,
        PlayerNameStringOffset = 0x11,             
    }

Unit and player names are working perfectly but I am still having some issues with items. Can anybody confirm is the values I am using are OK?