[19034 x64] Guids and ClntObjMgrObjectPtr question

[apollo0510]

Hello there.

While studying the latest patch, I came across a strange thing:

ClntObjMgrObjectPtr now wants a pointer to a 16 byte structure.
The lower uint64 is of course the guid of the object.
But the upper uint64 is some kind of mask that is used for filtering the results.
Anyone has some insights yet about the meaning of those bits ?

Thanks for your help.

BTW: (no rebase, 0x140000000 ida default)
ClntObjMgrObjectPtr = 0x1403E9650 if you want to have a look at it.

[Torpedoes]

Remember that GUIDs are 128-Bit integers now.

[apollo0510]

Remember that GUIDs are 128-Bit integers now.

wholy crap. Yes, indeed. *starts refactoring*

Thank you.

[Flam2]

/*
 * Copyright (C) 2012-2014 Arctium Emulation <http://arctium.org>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

using Framework.Constants.Object;
using Framework.Objects.WorldEntities;

namespace Framework.Objects
{
    public class SmartGuid
    {
        public ulong Low { get; set; }
        public ulong High { get; set; }

        public SmartGuid() { }

        public SmartGuid(IWorldObject obj)
        {
            if ((var player = obj as Player) != null)
            {
                Type         = GuidType.Player;
                MapId        = (ushort)player.Data.Map;
                CreationBits = player.Data.Guid;
            }
        }

        public GuidType Type
        {
            get { return (GuidType)(High >> 58); }
            set { High |= (ulong)value << 58; }
        }

        public GuidSubType SubType
        {
            get { return (GuidSubType)(Low >> 56); }
            set { Low |= (ulong)value << 56; }
        }

        public ushort RealmId
        {
            get { return (ushort)((High >> 42) & 0x1FFF); }
            set { High |= (ulong)value << 42; }
        }

        public ushort ServerId
        {
            get { return (ushort)((Low >> 40) & 0x1FFF); }
            set { Low |= (ulong)value << 40; }
        }

        public ushort MapId
        {
            get { return (ushort)((High >> 29) & 0x1FFF); }
            set { High |= (ulong)value << 29; }
        }

        public uint Id
        {
            get { return (uint)(High & 0xFFFFFF) >> 6; }
            set { High |= (ulong)value << 6; }
        }

        public ulong CreationBits
        {
            get { return Low & 0xFFFFFFFFFF; }
            set { Low |= value; }
        }
    }
}

Excuse me, but how to use it?

If I had the following code:

        public ulong Guid
        {
            get { return Memory.WoW.Read<ulong>(BaseAddress + (int)Offsets.Object.Guid); }
        }

then now it should look something like this?

        public ulong gLow
        {
            get { return Memory.WoW.Read<ulong>(BaseAddress + (int)Offsets.Object.Guid); }
        }
        public ulong gHigh 
        {
            get { return Memory.WoW.Read<ulong>(BaseAddress + (int)Offsets.Object.Guid) + 64; }
        }

  SmartGuid Guid = new SmartGuid ();
  Guid.Low  = gLow;
  Guid.High = gHigh ;

  Interact(Guid.id);

[-Ryuk-]

Excuse me, but how to use it?

If I had the following code:

        public ulong Guid
        {
            get { return Memory.WoW.Read<ulong>(BaseAddress + (int)Offsets.Object.Guid); }
        }

then now it should look something like this?

        public ulong gLow
        {
            get { return Memory.WoW.Read<ulong>(BaseAddress + (int)Offsets.Object.Guid); }
        }
        public ulong gHigh 
        {
            get { return Memory.WoW.Read<ulong>(BaseAddress + (int)Offsets.Object.Guid) + 64; }
        }

  SmartGuid Guid = new SmartGuid ();
  Guid.Low  = gLow;
  Guid.High = gHigh ;

  Interact(Guid.id);

public SmartGuid GUID()
{
ulong low = Memory.WoW.Read<ulong>(BaseAddress + (int)Offsets.Object.Guid);
ulong high= Memory.WoW.Read<ulong>(BaseAddress + (int)Offsets.Object.Guid + 0x8);

return new SmartGuid(low, high)
}

Interact(GUID)

[Torpedoes]

public SmartGuid GUID()
{
ulong low = Memory.WoW.Read<ulong>(BaseAddress + (int)Offsets.Object.Guid);
ulong high= Memory.WoW.Read<ulong>(BaseAddress + (int)Offsets.Object.Guid + 0x8);

return new SmartGuid(low, high)
}

Interact(GUID)

Two reads, that's expensive if you're not caching. I'm no C# expert but isn't there a way to just read 16 bytes and store it directly on a SmartGuid?

[-Ryuk-]

Two reads, that's expensive if you're not caching. I'm no C# expert but isn't there a way to just read 16 bytes and store it directly on a SmartGuid?

Not with the SmartGuid code he is using...

For one read just use uint128

[Flam2]

Now I have this code, but get incorrect values​​, where I made ​​a mistake?

 public class WoWGuid
    {
        public ulong Low { get; set; }
        public ulong High { get; set; }

        public WoWGuid() { }

        public WoWGuid(ulong lowGuid, ulong highGuid)
        {
            Low = lowGuid ;
            High = highGuid  ;
        }

        public WoWGuidType Type
        {
            get { return (WoWGuidType)(High >> 58); }
            set { High |= (ulong)value << 58; }
        }

        public GuidSubType SubType
        {
            get { return (GuidSubType)(Low >> 56); }
            set { Low |= (ulong)value << 56; }
        }

        public ushort RealmId
        {
            get { return (ushort)((High >> 42) & 0x1FFF); }
            set { High |= (ulong)value << 42; }
        }

        public ushort ServerId
        {
            get { return (ushort)((Low >> 40) & 0x1FFF); }
            set { Low |= (ulong)value << 40; }
        }

        public ushort MapId
        {
            get { return (ushort)((High >> 29) & 0x1FFF); }
            set { High |= (ulong)value << 29; }
        }

        public uint Id
        {
            get { return (uint)(High & 0xFFFFFF) >> 6; }
            set { High |= (ulong)value << 6; }
        }

        public ulong CreationBits
        {
            get { return Low & 0xFFFFFFFFFF; }
            set { Low |= value; }
        }
    }

        public WoWGuid GUID()
        {
            ulong high = Memory.WoW.Read<ulong>(BaseAddress + (int)Offsets.ObjectFields.Guid);
            ulong low = Memory.WoW.Read<ulong>(BaseAddress + (int)Offsets.ObjectFields.Guid + 0x8);

            return new WoWGuid(low, high);
        }

    public enum ObjectFields
    {
        Guid = 0x0,
    };

[hamburger12]

Here:

public enum ObjectFields
{
Guid = 0x0, = > 0x28
};

[gdfsxwy]

public ushort ServerId
{
get { return (ushort)((Low >> 40) & 0xFFFF); }
set { Low |= (ulong)value << 40; }
}

[Flam2]

Thank you all! Now I got a good guid! By the way, another my mistake - changed the high offset and low offset positions.

[TOM_RUS]

public ushort ServerId
{
get { return (ushort)((Low >> 40) & 0xFFFF); }
set { Low |= (ulong)value << 40; }
}

Pretty sure mask is 0x1FFF.

[fvicaria]

Two reads, that's expensive if you're not caching. I'm no C# expert but isn't there a way to just read 16 bytes and store it directly on a SmartGuid?

Still one read.

Memory.Read<WoWGuid>(IntPtr.Add(BaseAddress, 0x28));

[evil2]

Still one read.

Memory.Read<WoWGuid>(IntPtr.Add(BaseAddress, 0x28));

one line of code does not necessarily imply one memory read ^^

go for ReadBytes -> direct into your GUID struct

[fvicaria]

Never said the implementation was one line. But it does read all 16 bytes at once from the process memory (Kernel32::ReadProcessMemory)
Not sure what you are trying to say...