Side Note: WoW, or any comparable MMORPG, is probably a bad target for your research, because many of those feature various anti-hack, anti-cheat or anti-botting techniques, which will probably detect what you're doing.
I'm far from being an expert on this myself, but i've disassembled and tried to understand a 20 year old game as a hobby project recently. The executable has a size of 800 KB, IDA detected about 1750 functions in it, 250 of which were C/C++ library functions. Needless to say, i spent quite some time looking at various functions and checking the strings they used without understanding too much.
What brought the breakthrough for me was when i found out how the compiler handled class construction; each class constructor calls a
malloc()-like function (with the size as parameter), then calls the constructor of the superclass, then initializes the methods (there is no vtable like in more modern compilers; the compiler initializes every "function pointer" individually) and class variables. Cross-referencing those
malloc() calls, checking the sizes of the classes allocated, and following the chains of "constructor calls superclass constructor" immediately gave me an idea of the whole class tree and the size of each class.
Also, i got an idea of which function was a subclass method of which other function in the main class, which brought a lot of insight into the purpose of those functions, as as i knew which function was a class method of which class, it was quite easy to track the
this pointer of the function, track its dereferences, and find out which class element was used as integer, double, or pointer type, and in case of pointers, know which other class type they pointed to.
This was my first exposure to IDA, so i knew nothing about its scripting capabilities and started learning about them when things became too repetitive; if i had to do the same now, i'd probably script/automate a lot of what i did manually.
I think this might even be easier with modern C++ compilers that use vtables in a predictible way; check where the vtables get assigned to find out where classes get instantiated; check the superclass-constructor calls to find out about class hierarchy; check the sizes in
new calls to get structure/class sizes; track the
this pointers in class methods (which are easily identified through the vtables) to find out how the elements are used. All this can be done using static analysis, so you don't even have to care much about how anti-cheat/anti-debug techniques might affect the outcome.