Object manager question

[para_]

Hey guys,

I'm back trying to get better at this memory editing stuff. I'm able to change the FoV, zoom, climb angle, and walk on air (replacing a jump instruction) using the offsets provided for the latest version (ty btw).

Anyways here's an image of what I think is the object manager. I ask a pointed question after the link.

cheat engine screenshot

Main question (about photo): I think this value would represent the Type of the sixth element in the object manager. Is that right?

Type = 0x20, // Size: 0x1, Flags: 0x1

I'm using the offset for the s_curMgr in that thread dump.

Also, a few more dumb questions that can be ignored if you want:
- what does the prepended s_ in s_curMgr stand for?
- I get that size 0x1 means one byte (I think) but what does the flag part mean. It seems to say next to alot of the values provided

Thanks!

[Jadd]

http://www.ownedcore.com/forums/worl...ml#post3372219 (Explanation of release info dumps)

Everything you're asking is answered there. Except this:

- what does the prepended s_ in s_curMgr stand for?

's_' means the variable is static in a similar fashion to 'm_' being used to denote an instance member. It's pretty widely used with C++ naming conventions (and usually replaces the older 'g_' prefix.)

Edit: Also, flags:

    [Flags]
    public enum MirrorFlags {
        None            = 0x00000000,
        All             = 0x00000001,
        Self            = 0x00000002,
        Owner           = 0x00000004,
        EMPath          = 0x00000010,
        Party           = 0x00000020,
        UnitAll         = 0x00000040,
        ViewerDependent = 0x00000080,
        Urgent          = 0x00000200,
        UrgentSelfOnly  = 0x00000400
    }

[para_]

Thanks Jadd. I really appreciate it. No idea how I missed that post to the explanation. I should have known you guys were using standard naming conventions.

EDIT: Upon looking a bit closer - I see the suggestions are to look at old projects. I had looked at WoWRadar by I think it was KcDan (among others like OHack by l0l1dk) and the above Cheat Engine scheme is how I interpreted his type checking. I suppose I just wanted confirmation that what I had done correctly mirrored what I read. The only issue I see is that the types are the same across all the objects. And that there are only like 25 of them depending on the surrounding area.

[para_]

Can anyone confirm if that Cheat Engine screen shot does indeed point at the 6th object's object type? The advice was to look at other projects to try and glean the meaning of a lot of these offsets which is exactly what I did.

The things that makes me think it is:
* There is a static size between each iteration of 3C offsets - 0x69C

The things that make me think it isnt:
* Each object type byte is 0 meaning it would be the same type of object?

Screenshot: Imgur: The most awesome images on the Internet

[danwins]

Object type is at object+0xC (object -> type)

looks like you are trying to read this:

namespace CGObjectData {
enum {
    Guid = 0x0, // Size: 0x4, Flags: 0x1
    Data = 0x10, // Size: 0x4, Flags: 0x1
    Type = 0x20, // Size: 0x1, Flags: 0x1
    EntryID = 0x24, // Size: 0x1, Flags: 0x80
    DynamicFlags = 0x28, // Size: 0x1, Flags: 0x280
    Scale = 0x2C, // Size: 0x1, Flags: 0x1
};
}

in which case you should be reading: [object+0x4]+0x20 (object -> descriptors -> type)

[para_]

Thanks danwins. That did it. I think I got it.



This has helped me look at the offsets a bit differently. I was treating the 0x20 as if the descriptors were loaded at the start of the object... Kinda dumb. Thanks for the nudge.

[Buntstift]

Hi Para_
I run into a similar problems (some old hints in this forum not always work for me).
This is my result of digging days over the forum and google:

/* 
s_curMgr = 0xDA6A20
FirstObject = 0xD8
NextObjectOffset = 0xD0
*/
				
uint objMgr = wowMem.ReadUInt((uint)wowMem.MainModule.BaseAddress + (uint)ObjectOffsets.s_curMgr);
uint curObj = wowMem.ReadUInt((uint)objMgr + (uint)ObjectOffsets.FirstObject);

while ((curObj & 1) == 0)
{
	uint curObjDescriptor = wowMem.ReadUInt(curObj + 0x04);
	uint objGUID = wowMem.ReadUInt((uint)curObjDescriptor + 0x0);
	int objType = wowMem.ReadByte((uint)curObjDescriptor + 0x20);
	txtDebug.Text += "[" + objGUID.ToString("X16") + "]" + "\tType: " + objType + "\r\n";
	curObj = wowMem.ReadUInt((uint)wowMem.ReadUInt((uint)objMgr + (uint)ObjectOffsets.NextObjectOffset) + (uint)curObj + (uint)0x4);
}