[Help][Pointers]

ILTClient holds a value itself. In this case it's 0x377ED910, initializing it as a pointer means you can use the reference operator to either change the contents of the address it's holding or simply read it.

Let's assume that the value of the first 4 bytes at 0x377ED910 equal to 1.
Let's also assume that it's possible to read what ever is at the address 0x00000001, let's give it the value 10.

ILTClient = 0x377ED910
*ILTClient = 1
**ILTClient = 10

Why is much better at this... \:

Let's turn it into int just to make it more clear for you:

int a;
Normal int, nothing special.

int *b = &a;
b is a pointer, it points to a. so the value of b is the address of a, while *b gives the value of what is pointed to, thus the value of a.

int **c = &b;
c is a pointer to a pointer, so the value of c is the address of b, *c will give you the value of what c points to, which means it gives you the value of b, which is the address of a(does that make sense, if not ill try to rephrase it), so if you want the value of a from c, you'd have to add another star so it looks like **c, which means gimme the value of the object of the pointer i'm pointing to points to(that sounds so messed up >.<)


so:

c -> b -> a
a = 5;
b = &a;
*b = a = 5;
c = &b;
*c = b = &a;
**c = *b = a = 5;

Okay, ima have a shot too. Do tell us who's explanation you liked best xD

Let's invent a hypothetical LTClient class:

[php]class LTClient
{
bool GetGameStatus();
int RunConsoleCommand(char *szCommand);
}[/php]

Now, in game, let's say I have a function that takes the LTClient as a parameter. I do not want to use a new LTClient, but whatever I do I want to modify the current LTClient. To do this, I use a pointer, which points to the real LTClient, rather than a copy of it.

[php]
void UpdatePlayerPositions(LTClient * client)
{
client->RunConsoleCommand("whatever");

}
[/php]

At this point, we might get the address of the POINTER that tells us (points) where the real LTClient is. Because we've made a hack, we cannot directly access that pointer, and we do not know the address of the original LTClient.

Therefore, we have to create a pointer to that pointer which will then tell us where the real LTClient is.

LTClient** = points to the LTClient* that we know, which points to the LTClient whose address we do not know.

That's why we need 2 levels of indirection. The first level is due to the game, the second is because we need to access something that we don't have direct access to.

Basically every variable is a pointer

excellent freedom and HD!
And SCHIM, while everything can be pointed to not every variable is a pointer. From an ASM point of view all variables are the same, just memory addresses storing values, It's their function or high level behavior that defines them.

K last but not least you asked me to explain this:
Memoria is just a fancy way to use memcpy( pDest, szPatch, sSize );
memcpy essentially will copy a string to a destination. And repeat that string to fill to the size specified.


pDest is the address you want write over.
szPatch is a char* or string, but it is important to understand that a c-string is the same thing as a byte array, So what usually is put here are opcodes, which are one byte inside.
sSize is the number of bytes you want to overwrite with your opcodes you provided in szPatch.

Using this function is a piece of cake. Using it effectively is a different story. You can patch anything with this, but it is primarily used for code hence the PAGE_EXECUTE_READWRITE you see being passed to VirtualProtect.