HELP with Multi Level Pointers

Here you go.

Cool, so do you understand the concepts of what we're doing?

1. what a 'pattern' is
2. converting a series of assembly instructions to a pattern
3. taking out parts that might change
4. The AOB/FindPattern function itsself

A bit. I've read about some of it before on the net. Not really sure of how to do it properly though.

Do you know the pattern

would make? Or even a small piece of it?

Do you understand which bytes in an instruction can/will change, and which will stay constant?

Nope. Got no pattern/anything. Don't understand what will change or not either. Do you happen to know what signature scans are? another person recommended that I should use them but idk what they are. Another one said something like " GetModuleHandle(NULL), or use a x87 call, then fstenv and read [esp]->FloatingPointInstructionPointer (esp+$0c iirc). "

You already have the pattern well..maybe exact pattern, but we'll get to the parts that change. You really need to have an understanding of asm to do this type of thing? Can you name the 8 general purpose registers?

A series of instructions == a pattern

so if the game.exe had some area that looked like
each of those instructions will be represented by 1 or several bytes.

See the "BYTES" tab on the Memory View image? those are the actual bytes, the 0's and 1's, that make up that instruction.

a pattern = several bytes in a row

So when you "Scan memory for a pattern" you're scanning for some specific array of bytes because you know the game uses that code (sequence of bytes) somewhere.

This (sometimes. - more often than hardcoding addr/offsets) works across game-updates because the game function still ends up using very similar asm code. Or the code wasn't changed at all, and only it's relative location in the program changed (and therefor possibly the offsets it uses).
Some parts of the instructions will change, some won't. For example, a jmp instruction is 5 bytes --> 1 bytes for the instruction code, and a 4 byte offset for where to jump to. So, if that jump instruction was a pattern...the first byte would never changes, and the next 4 bytes probably will. So your pattern, for that part, would look like "x****"; where x = an important byte, * = changing byte/unimportant

I'm not explaining it very well...it's kind of hard w/o knowing your background knowledge first. Plz ask a specific question?
I highly recommend the assembly videos tutorials by 'whatsacreel' on youtube for learning a little more about assembly.

--I've heard of x86, no idea what x87 is : p Not sure what they were talking about...