-
Contributor
Avid Ailurophile
-
Post Thanks / Like - 2 Thanks
-
Member
-
Contributor
Last edited by ChrisIsMe; 11-01-2023 at 04:58 PM.
no war
-
Member
Originally Posted by
ChrisIsMe
What does that mean? Do you like old harry putin dick up your ******* or are you just shit posting?
Means Thanks to R,Thanks for share。
I once thought you were as good at sharing as razzue, because razzue's post mentioned that he wanted to thank you. But I didn't expect your quality to be so poor.
-
Member
I don't even know why I keep posting these
This is useful, as the offset dumper you've shared sometimes doesn't return exactly what you provide here.
Thanks for sharing!
Last edited by 0xd5d; 06-17-2022 at 02:39 AM.
-
-
Member
Hi ! I have a problem reading the object type. At first, I don't have a correct offset value for the objectType constant and I don't know how to find it by myself. So I tried some for loops to find a matchable value, but found nothing, only false leads.
So I think that I'm trying to read the value in an incorrect way. As I didn't found anything about this (or outdated posts), I'm asking there il it's possible to have a little helping hand.
Code:
public void Update()
{
IntPtr CurrentManagerAddress = memoryReader.ReadIntPtr(IntPtr.Add(memoryReader.BaseAddress, Object_Manager.Base)); //OK
int NbObjects = memoryReader.ReadInt(CurrentManagerAddress); //Always 1024
IntPtr ArrayAddr = memoryReader.ReadIntPtr(IntPtr.Add(CurrentManagerAddress, ManagerArray)); //OK ManagerArray = 0x08;
for (int i = 0; i < NbObjects; i++)
{
IntPtr ObjPtr = memoryReader.ReadIntPtr(IntPtr.Add(ArrayAddr, i * ManagerArray));//OK
while (ObjPtr != IntPtr.Zero)
{
Int128 guid = memoryReader.ReadInt128(ObjPtr + ObjGuid);//ok ObjGuid = 0x08;
// this line doesn't work
ObjectType type = (ObjectType)memoryReader.ReadByte(ObjPtr + objectType);//NOT OK objectType = 0x??;
ObjPtr = memoryReader.ReadIntPtr(ObjPtr);
}
}
}
Thanks in advance
-
-
Contributor
Last edited by ChrisIsMe; 11-01-2023 at 04:58 PM.
no war
-
Contributor
Avid Ailurophile
Originally Posted by
ChrisIsMe
This will not expose that (for all intensive purposes I consider it a fake object or a honey pot or something like that, since it seems to trip almost everyone up) fake object to your object list. @
Razzue has previously documented it as 'nil: 255' or whatever in his object type list, that's invalid IMO.
Code:
public enum eType
{
Object = 0,
Item = 1,
Container = 2,
EmpAzeriteItem = 3,
AzeriteItem = 4,
Unit = 5,
Player = 6,
LocalPlayer = 7,
GameObject = 8,
DynamicObject = 9,
Corpse = 10,
AreaTrigger = 11,
SceneObject = 12,
Conversation = 13,
Nil = 255 // do -1 if SByte
}
So in here I honestly just defined "nil" as a backup incase I fucked up somewhere. I peeked at a few months of logs and have never actually seen it get used. :shrug:
Using the below I don't think I've ever actually encountered a "fake" object kicking around the array :though.. Though yes, I can likely read this in better ways.
(Keeping in mind more does happen outside this loop such as base address checks, and clearing entries that haven't been updated in a while)
Code:
var count = _entries.Count;
var curCount = Memory.Read<int>(managerBase + 0x10);
var maxCount = Memory.Read<int>(managerBase + 0x0);
for (var i = 0; i < maxCount; i++)
{
var ptr = Memory.Read<IntPtr>(managerBase, new[] { 0x8, (i * 0x8) });
if (ptr == IntPtr.Zero) continue;
while (IntPtr.Zero != ptr)
{
var entryPtr = Memory.Read<IntPtr>(ptr + 0x18);
var guid = Memory.Read<GUID>(entryPtr + 0x18);
if (guid.IsEmpty() || IntPtr.Zero == entryPtr ) continue;
if (_objects.ContainsKey(guid))
_objects[guid].Updated = true;
else _objects.Add(guid, new Entry(entryPtr , guid));
ptr = Memory.Read<IntPtr>(ptr + 0x0);
}
}
"May all your bacon burn"
-
Contributor
Last edited by ChrisIsMe; 11-01-2023 at 04:58 PM.
no war
-
Originally Posted by
Razzue
Patterns just need to be updated, but i'm too lazy to push to github so :shrugs:
It would make my day if you blessed your github repo with a push!
-
-
Member
How are you using Key_Bindings? I can't find the actual key it is bound to anymore in memory.